code
stringlengths 57
237k
|
|---|
package projects.tanks.client.battleselect.model.battleselect.create {
import projects.tanks.client.battleservice.Range;
import projects.tanks.client.battleservice.model.createparams.BattleLimits;
public class BattleCreateCC {
private var _battleCreationDisabled:Boolean;
private var _battlesLimits:Vector.<BattleLimits>;
private var _defaultRange:Range;
private var _maxRange:Range;
private var _maxRangeLength:int;
private var _ultimatesEnabled:Boolean;
public function BattleCreateCC(param1:Boolean = false, param2:Vector.<BattleLimits> = null, param3:Range = null, param4:Range = null, param5:int = 0, param6:Boolean = false) {
super();
this._battleCreationDisabled = param1;
this._battlesLimits = param2;
this._defaultRange = param3;
this._maxRange = param4;
this._maxRangeLength = param5;
this._ultimatesEnabled = param6;
}
public function get battleCreationDisabled() : Boolean {
return this._battleCreationDisabled;
}
public function set battleCreationDisabled(param1:Boolean) : void {
this._battleCreationDisabled = param1;
}
public function get battlesLimits() : Vector.<BattleLimits> {
return this._battlesLimits;
}
public function set battlesLimits(param1:Vector.<BattleLimits>) : void {
this._battlesLimits = param1;
}
public function get defaultRange() : Range {
return this._defaultRange;
}
public function set defaultRange(param1:Range) : void {
this._defaultRange = param1;
}
public function get maxRange() : Range {
return this._maxRange;
}
public function set maxRange(param1:Range) : void {
this._maxRange = param1;
}
public function get maxRangeLength() : int {
return this._maxRangeLength;
}
public function set maxRangeLength(param1:int) : void {
this._maxRangeLength = param1;
}
public function get ultimatesEnabled() : Boolean {
return this._ultimatesEnabled;
}
public function set ultimatesEnabled(param1:Boolean) : void {
this._ultimatesEnabled = param1;
}
public function toString() : String {
var local1:String = "BattleCreateCC [";
local1 += "battleCreationDisabled = " + this.battleCreationDisabled + " ";
local1 += "battlesLimits = " + this.battlesLimits + " ";
local1 += "defaultRange = " + this.defaultRange + " ";
local1 += "maxRange = " + this.maxRange + " ";
local1 += "maxRangeLength = " + this.maxRangeLength + " ";
local1 += "ultimatesEnabled = " + this.ultimatesEnabled + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.users.services.chatmoderator {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.users.services.chatmoderator.ChatModeratorLevel;
public class CodecChatModeratorLevel implements ICodec {
public function CodecChatModeratorLevel() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ChatModeratorLevel = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = ChatModeratorLevel.NONE;
break;
case 1:
local2 = ChatModeratorLevel.COMMUNITY_MANAGER;
break;
case 2:
local2 = ChatModeratorLevel.BATTLE_ADMINISTRATOR;
break;
case 3:
local2 = ChatModeratorLevel.BATTLE_MODERATOR;
break;
case 4:
local2 = ChatModeratorLevel.BATTLE_CANDIDATE;
break;
case 5:
local2 = ChatModeratorLevel.ADMINISTRATOR;
break;
case 6:
local2 = ChatModeratorLevel.MODERATOR;
break;
case 7:
local2 = ChatModeratorLevel.CANDIDATE;
break;
case 8:
local2 = ChatModeratorLevel.EVENT_CHAT_ADMIN;
break;
case 9:
local2 = ChatModeratorLevel.EVENT_CHAT_MODERATOR;
break;
case 10:
local2 = ChatModeratorLevel.EVENT_CHAT_CANDIDATE;
}
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.gui.category {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.category.ItemCategoryButton_colorIconClass.png")]
public class ItemCategoryButton_colorIconClass extends BitmapAsset {
public function ItemCategoryButton_colorIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.kitview.localized {
public interface IKitViewResourceLocalizedModelBase {
}
}
|
package alternativa.tanks.controller.commands.partners {
import alternativa.tanks.controller.events.LoginViaPartnerEvent;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Command;
public class LoginViaPartnerCommand extends Command {
[Inject]
public var event:LoginViaPartnerEvent;
[Inject]
public var serverFacade:IEntranceServerFacade;
public function LoginViaPartnerCommand() {
super();
}
override public function execute() : void {
this.serverFacade.loadPartnerObject(this.event.partnerId);
}
}
}
|
package alternativa.tanks.models.weapon.shaft
{
import flash.utils.Dictionary;
public class SetControllerForTemporaryItems
{
private var temporaryItems:Vector.<Object>;
private var sourceSet:Dictionary;
public function SetControllerForTemporaryItems(param1:Dictionary)
{
this.temporaryItems = new Vector.<Object>();
super();
this.sourceSet = param1;
}
public function addTemporaryItem(param1:Object) : void
{
this.sourceSet[param1] = true;
this.temporaryItems.push(param1);
}
public function deleteAllTemporaryItems() : void
{
var _loc1_:int = 0;
while(_loc1_ < this.temporaryItems.length)
{
delete this.sourceSet[this.temporaryItems[_loc1_]];
_loc1_++;
}
this.temporaryItems.length = 0;
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_NORMAL_GREEN_TL.png")]
public dynamic class bres_NORMAL_GREEN_TL extends BitmapData {
public function bres_NORMAL_GREEN_TL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.battle.objects.tank.tankskin {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.*;
import alternativa.tanks.utils.DataUnitValidator;
import alternativa.tanks.utils.DataValidatorType;
import alternativa.tanks.utils.EncryptedNumber;
import alternativa.tanks.utils.EncryptedNumberImpl;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class TankHullSkinCacheItem extends TankSkinPartCacheItem implements DataUnitValidator {
public var turretMountPoint:Vector3;
private var encTurretMountPointX:EncryptedNumber;
private var encTurretMountPointY:EncryptedNumber;
private var encTurretMountPointZ:EncryptedNumber;
public var mesh:Mesh;
public function TankHullSkinCacheItem(param1:Tanks3DSResource) {
super(param1);
var local2:Vector.<Object3D> = param1.getObjectsByName(/mount/i);
if(local2 == null) {
throw new TurretMountPointNotFoundError();
}
var local3:Object3D = local2[0];
this.turretMountPoint = new Vector3(local3.x,local3.y,local3.z);
this.encTurretMountPointX = new EncryptedNumberImpl(local3.x);
this.encTurretMountPointY = new EncryptedNumberImpl(local3.y);
this.encTurretMountPointZ = new EncryptedNumberImpl(local3.z);
this.mesh = initMesh(this.getMesh(param1));
}
public function hasIncorrectData() : Boolean {
return this.turretMountPoint.x != this.encTurretMountPointX.getNumber() || this.turretMountPoint.y != this.encTurretMountPointY.getNumber() || this.turretMountPoint.z != this.encTurretMountPointZ.getNumber();
}
public function getType() : int {
return DataValidatorType.MEMHACK_TURRET_MOUNT_POINT;
}
private function getMesh(param1:Tanks3DSResource) : Mesh {
var local2:Vector.<Object3D> = param1.getObjectsByName(/hull/i);
if(local2 == null) {
throw new HullNotFoundError();
}
return Mesh(local2[0]);
}
public function getTurretMountPointX() : Number {
return this.encTurretMountPointX.getNumber();
}
public function getTurretMountPointY() : Number {
return this.encTurretMountPointY.getNumber();
}
public function getTurretMountPointZ() : Number {
return this.encTurretMountPointZ.getNumber();
}
}
}
|
package alternativa.tanks.servermodels.newbie {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.entrance.model.entrance.newbie.INewbieRegistrationModelBase;
import projects.tanks.client.entrance.model.entrance.newbie.NewbieRegistrationModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
[ModelInfo]
public class NewbieRegistrationModel extends NewbieRegistrationModelBase implements INewbieRegistrationModelBase, ObjectLoadListener {
[Inject]
public static var storageService:IStorageService;
public function NewbieRegistrationModel() {
super();
}
public function objectLoaded() : void {
if(!this.haveVisitedTankiAlready()) {
server.markUserAsNewbie();
}
}
public function haveVisitedTankiAlready() : Boolean {
return storageService.getStorage().data.alreadyPlayedTanks != null ? Boolean(storageService.getStorage().data.alreadyPlayedTanks) : false;
}
}
}
|
package alternativa.tanks.models.battle.gui.chat {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.battle.battlefield.common.MessageLine;
import alternativa.tanks.models.battle.ctf.MessageColor;
import alternativa.tanks.models.battle.gui.userlabel.BattleChatUserLabel;
import alternativa.types.Long;
import controls.Label;
import flash.text.AntiAliasType;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class BattleChatLine extends MessageLine {
[Inject]
public static var localeService:ILocaleService;
private var output:Label;
private var _namesWidth:int = 0;
private var _width:int = 300;
private var chatUserLabel:BattleChatUserLabel;
public function BattleChatLine(param1:Long, param2:BattleTeam, param3:String, param4:Boolean, param5:Boolean) {
var local7:Label = null;
this.output = new Label();
super();
var local6:int = 0;
if(param5) {
local6 = 14;
local7 = new Label();
local7.color = MessageColor.YELLOW;
local7.text = localeService.getText(TanksLocale.TEXT_SPECTATOR_NAME) + ":";
local7.thickness = 50;
local7.sharpness = 0;
local7.mouseEnabled = false;
shadowContainer.addChild(local7);
local7.x = local6;
local6 += local7.textWidth + 1;
} else {
this.chatUserLabel = new BattleChatUserLabel(param1);
this.chatUserLabel.setUidColor(MessageColor.getUserNameColor(param2,param5),true);
this.chatUserLabel.setAdditionalText(":");
addChild(this.chatUserLabel);
local6 += this.chatUserLabel.width;
}
this.output.color = MessageColor.getTextColor(param2,param4,param5);
this.output.antiAliasType = AntiAliasType.ADVANCED;
this.output.thickness = 150;
this.output.sharpness = 200;
this.output.multiline = true;
this.output.wordWrap = true;
this.output.mouseEnabled = false;
shadowContainer.addChild(this.output);
this._namesWidth = local6;
if(this._namesWidth > this._width / 2) {
this.output.y = 15;
this.output.x = 0;
this.output.width = this._width - 5;
} else {
this.output.x = this._namesWidth + 3;
this.output.y = 0;
this.output.width = this._width - this._namesWidth - 8;
}
this.output.text = param3;
}
[Obfuscation(rename="false")]
public function alignChatUserLabel() : void {
this._namesWidth = this.chatUserLabel.width;
if(this._namesWidth > this._width / 2) {
this.output.y = 15;
this.output.x = 0;
this.output.width = this._width - 5;
} else {
this.output.x = this._namesWidth + 3;
this.output.y = 0;
this.output.width = this._width - this._namesWidth - 8;
}
}
[Obfuscation(rename="false")]
override public function set width(param1:Number) : void {
this._width = int(param1);
if(this._namesWidth > this._width / 2 && this.output.text.length * 8 > this._width - this._namesWidth) {
this.output.y = 21;
this.output.x = 0;
this.output.width = this._width - 5;
this.output.height = 20;
} else {
this.output.x = this._namesWidth;
this.output.y = 0;
this.output.width = this._width - this._namesWidth - 5;
this.output.height = 20;
}
}
}
}
|
package com.alternativaplatform.client.models.core.users.model.entrance
{
public class RegisterStatusEnum
{
public static var EMAIL_LDAP_UNIQUE:RegisterStatusEnum = new RegisterStatusEnum();
public static var EMAIL_NOT_VALID:RegisterStatusEnum = new RegisterStatusEnum();
public static var UID_LDAP_UNIQUE:RegisterStatusEnum = new RegisterStatusEnum();
public function RegisterStatusEnum()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.challenge.rewarding {
public interface IChallengesRewardingUserModelBase {
function rewardNotify(param1:int) : void;
}
}
|
package com.alternativaplatform.projects.tanks.client.models.tank.explosion
{
import scpacker.Base;
public class TankExplosionModelBase extends Base
{
public function TankExplosionModelBase()
{
super();
}
}
}
|
package alternativa.tanks.models.clan.info {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public class IClanInfoModelAdapt implements IClanInfoModel {
private var object:IGameObject;
private var impl:IClanInfoModel;
public function IClanInfoModelAdapt(param1:IGameObject, param2:IClanInfoModel) {
super();
this.object = param1;
this.impl = param2;
}
public function getClanName() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getClanName();
}
finally {
Model.popObject();
}
return result;
}
public function getClanTag() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getClanTag();
}
finally {
Model.popObject();
}
return result;
}
public function getDescription() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getDescription();
}
finally {
Model.popObject();
}
return result;
}
public function getClanFlag() : ClanFlag {
var result:ClanFlag = null;
try {
Model.object = this.object;
result = this.impl.getClanFlag();
}
finally {
Model.popObject();
}
return result;
}
public function getRankIndexForAddClan() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getRankIndexForAddClan());
}
finally {
Model.popObject();
}
return result;
}
public function incomingRequestEnabled() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.incomingRequestEnabled());
}
finally {
Model.popObject();
}
return result;
}
public function getCreatorId() : Long {
var result:Long = null;
try {
Model.object = this.object;
result = this.impl.getCreatorId();
}
finally {
Model.popObject();
}
return result;
}
public function getCreateTime() : Long {
var result:Long = null;
try {
Model.object = this.object;
result = this.impl.getCreateTime();
}
finally {
Model.popObject();
}
return result;
}
public function getUsersCount() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getUsersCount());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.protocol.factory
{
import alternativa.protocol.codec.ICodec;
import alternativa.protocol.codec.complex.ArrayCodec;
import alternativa.protocol.codec.complex.StringCodec;
import alternativa.protocol.codec.primitive.BooleanCodec;
import alternativa.protocol.codec.primitive.ByteCodec;
import alternativa.protocol.codec.primitive.DoubleCodec;
import alternativa.protocol.codec.primitive.FloatCodec;
import alternativa.protocol.codec.primitive.IntegerCodec;
import alternativa.protocol.codec.primitive.LongCodec;
import alternativa.protocol.codec.primitive.ShortCodec;
import alternativa.protocol.type.Byte;
import alternativa.protocol.type.Float;
import alternativa.protocol.type.Short;
import alternativa.types.Long;
import flash.utils.Dictionary;
public class CodecFactory implements ICodecFactory
{
private var codecs:Dictionary;
private var notnullArrayCodecs:Dictionary;
private var nullArrayCodecs:Dictionary;
public function CodecFactory()
{
super();
this.codecs = new Dictionary();
this.notnullArrayCodecs = new Dictionary();
this.nullArrayCodecs = new Dictionary();
this.registerCodec(int,new IntegerCodec());
this.registerCodec(Short,new ShortCodec());
this.registerCodec(Byte,new ByteCodec());
this.registerCodec(Number,new DoubleCodec());
this.registerCodec(Float,new FloatCodec());
this.registerCodec(Boolean,new BooleanCodec());
this.registerCodec(Long,new LongCodec());
this.registerCodec(String,new StringCodec());
}
public function registerCodec(targetClass:Class, codec:ICodec) : void
{
this.codecs[targetClass] = codec;
}
public function unregisterCodec(targetClass:Class) : void
{
this.codecs[targetClass] = null;
}
public function getCodec(targetClass:Class) : ICodec
{
return this.codecs[targetClass];
}
public function getArrayCodec(targetClass:Class, elementnotnull:Boolean = true, depth:int = 1) : ICodec
{
var codec:ArrayCodec = null;
var dict:Dictionary = null;
if(elementnotnull)
{
dict = this.notnullArrayCodecs;
}
else
{
dict = this.nullArrayCodecs;
}
if(dict[targetClass] == null)
{
dict[targetClass] = new Dictionary(false);
}
if(dict[targetClass][depth] == null)
{
codec = new ArrayCodec(targetClass,this.getCodec(targetClass),elementnotnull,depth);
dict[targetClass][depth] = codec;
}
else
{
codec = dict[targetClass][depth];
}
return codec;
}
}
}
|
package alternativa.tanks.models.weapon.terminator {
public interface TerminatorToggleCallback {
function onOpened() : void;
function onClosed() : void;
}
}
|
package alternativa.tanks.battle {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.CollisionDetector;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import flash.geom.Vector3D;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.TargetPosition;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleUtils {
[Inject]
public static var battleService:BattleService;
public static const tmpVector:Vector3 = new Vector3();
public static const tmpMatrix3:Matrix3 = new Matrix3();
private static const hundred:EncryptedInt = new EncryptedIntImpl(100);
private static const _direction:Vector3 = new Vector3();
private static const _rayHit:RayHit = new RayHit();
private static const TURN_THRESHOLD:Number = 0.22;
public function BattleUtils() {
super();
}
public static function isLocalTank(param1:IGameObject) : Boolean {
return ITankModel(param1.adapt(ITankModel)).isLocal();
}
public static function toClientScale(param1:Number) : Number {
return param1 * hundred.getInt();
}
public static function getOtherTeam(param1:BattleTeam) : BattleTeam {
return param1 == BattleTeam.BLUE ? BattleTeam.RED : BattleTeam.BLUE;
}
public static function isFiniteVector3d(param1:Vector3d) : Boolean {
return param1 != null && isFinite(param1.x) && isFinite(param1.y) && isFinite(param1.z);
}
public static function getVector3d(param1:Vector3) : Vector3d {
return new Vector3d(param1.x,param1.y,param1.z);
}
public static function getVector3dOrNull(param1:Vector3) : Vector3d {
return param1 == null ? null : new Vector3d(param1.x,param1.y,param1.z);
}
public static function copyToVector3d(param1:Vector3, param2:Vector3d) : void {
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
public static function copyVector3d(param1:Vector3d, param2:Vector3d) : void {
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
public static function getVector3(param1:Vector3d) : Vector3 {
return new Vector3(param1.x,param1.y,param1.z);
}
public static function getVector3OrNull(param1:Vector3d) : Vector3 {
return param1 == null ? null : new Vector3(param1.x,param1.y,param1.z);
}
public static function copyToVector3(param1:Vector3d, param2:Vector3) : void {
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
public static function copyToVector3D(param1:Vector3, param2:Vector3D) : void {
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
public static function globalToLocal(param1:Body, param2:Vector3) : void {
param2.subtract(param1.state.position);
param2.transformTransposed3(param1.baseMatrix);
}
public static function localToGlobal(param1:Body, param2:Vector3) : void {
param2.transform3(param1.baseMatrix);
param2.add(param1.state.position);
}
public static function parseNumber(param1:String, param2:Number = 0) : Number {
var local3:Number = Number(param1);
return isNaN(local3) ? param2 : local3;
}
public static function traceObject(param1:Object, param2:Array) : String {
return "";
}
public static function isTankBody(param1:Body) : Boolean {
return param1 != null && param1.tank != null;
}
public static function isTurretAboveGround(param1:Body, param2:AllGlobalGunParams) : Boolean {
var local4:CollisionDetector = null;
var local3:Vector3 = param1.state.position;
_direction.diff(param2.barrelOrigin,local3);
if(param1.scene != null) {
local4 = param1.scene.collisionDetector;
return !local4.raycastStatic(local3,_direction,CollisionGroup.STATIC,1,null,_rayHit);
}
return false;
}
public static function barrelCollidesWithStatic(param1:AllGlobalGunParams) : Boolean {
var local2:TanksCollisionDetector = battleService.getBattleRunner().getCollisionDetector();
var local3:Number = Vector3.distanceBetween(param1.barrelOrigin,param1.muzzlePosition);
return local2.raycastStatic(param1.barrelOrigin,param1.direction,CollisionGroup.STATIC,local3,null,_rayHit);
}
public static function getTargetPosition(param1:Tank) : TargetPosition {
var local2:TargetPosition = new TargetPosition();
local2.target = param1.getUser();
local2.position = BattleUtils.getVector3d(param1.getBody().state.position);
param1.getBody().state.orientation.getEulerAngles(tmpVector);
local2.orientation = getVector3d(tmpVector);
local2.turretAngle = param1.getWeaponMount().getTurretPhysicsDirection();
return local2;
}
public static function getTargetsPositions(param1:Vector.<Tank>) : Vector.<TargetPosition> {
var local2:Vector.<TargetPosition> = new Vector.<TargetPosition>(param1.length);
var local3:int = 0;
while(local3 < param1.length) {
local2[local3] = getTargetPosition(param1[local3]);
local3++;
}
return local2;
}
public static function isVector3dNaN(param1:Vector3d) : Boolean {
return isNaN(param1.x) || isNaN(param1.y) || isNaN(param1.z);
}
public static function isTurnedOver(param1:Body) : Boolean {
return param1.baseMatrix.m22 < TURN_THRESHOLD;
}
public static function getVector3dVector(param1:Vector.<Vector3>) : Vector.<Vector3d> {
var local2:Vector.<Vector3d> = new Vector.<Vector3d>(param1.length);
var local3:int = 0;
while(local3 < param1.length) {
local2[local3] = getVector3d(param1[local3]);
local3++;
}
return local2;
}
public static function getDirectionAngle(param1:Vector3) : Number {
return Math.atan2(-param1.x,param1.y);
}
public static function fillDirectionVector(param1:Vector3, param2:Number) : void {
param1.x = -Math.sin(param2);
param1.y = Math.cos(param2);
param1.z = 0;
}
public static function setObjectPosition3d(param1:Object3D, param2:Vector3d) : void {
param1.x = param2.x;
param1.y = param2.y;
param1.z = param2.z;
}
public static function setObjectRotation3d(param1:Object3D, param2:Vector3d) : void {
param1.rotationX = param2.x;
param1.rotationY = param2.y;
param1.rotationZ = param2.z;
}
}
}
|
package alternativa.tanks.models.tank {
[ModelInterface]
public interface AddToBattleListener {
function onAddToBattle() : void;
}
}
|
package projects.tanks.client.garage.models.garage.passtoshop {
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 PassToShopModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PassToShopModelServer;
private var client:IPassToShopModelBase = IPassToShopModelBase(this);
private var modelId:Long = Long.getLong(2134722200,-2075306131);
public function PassToShopModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PassToShopModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(PassToShopCC,false)));
}
protected function getInitParam() : PassToShopCC {
return PassToShopCC(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 {
import assets.combo.ComboOffButton;
[Embed(source="/_assets/assets.swf", symbol="symbol54")]
public dynamic class ComboBox_disabledSkin extends ComboOffButton {
public function ComboBox_disabledSkin() {
super();
}
}
}
|
package alternativa.tanks.models.sfx
{
import alternativa.engine3d.core.Light3D;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.sfx.Object3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class StreamLightEffect extends PooledObject implements IGraphicEffect
{
private static const FADE_TIME:int = 250;
protected var light:Light3D;
protected var startAnimation:LightAnimation;
protected var loopAnimation:LightAnimation;
protected var startTime:int;
protected var loopTime:int;
protected var currentLoopTime:int;
protected var currentTime:int;
protected var starting:Boolean;
protected var positionProvider:Object3DPositionProvider;
protected var alive:Boolean;
protected var random:int;
protected var fading:Boolean;
protected var fadeTime:int;
protected var container:Scene3DContainer;
public function StreamLightEffect(param1:ObjectPool, param2:Light3D)
{
super(param1);
this.light = param2;
}
public function addToContainer(param1:Scene3DContainer) : void
{
this.container = param1;
param1.addChild(this.light);
}
private function startLoop() : void
{
this.currentLoopTime = this.loopTime + (Math.random() * this.random - this.random / 2);
}
public function play(param1:int, param2:GameCamera) : Boolean
{
if(!this.alive)
{
return false;
}
if(this.starting)
{
this.currentTime += param1;
this.startAnimation.updateByTime(this.light,this.currentTime,this.startTime);
if(this.currentTime >= this.startTime)
{
this.starting = false;
this.currentTime = 0;
this.startLoop();
}
}
else
{
this.currentTime += param1;
if(this.currentTime > this.currentLoopTime)
{
this.currentTime %= this.currentLoopTime;
this.startLoop();
}
this.loopAnimation.updateByTime(this.light,this.currentTime,this.loopTime);
}
this.positionProvider.updateObjectPosition(this.light,param2,param1);
if(this.fading)
{
this.fadeTime += param1;
if(this.fadeTime <= FADE_TIME)
{
this.light.intensity *= 1 - this.fadeTime / FADE_TIME;
}
else
{
this.light.intensity = 0;
this.kill();
}
}
return true;
}
public function destroy() : void
{
this.container.removeChild(this.light);
this.container = null;
this.startAnimation = null;
this.loopAnimation = null;
this.positionProvider.destroy();
this.positionProvider = null;
}
public function kill() : void
{
this.alive = false;
}
public function stop() : void
{
this.fading = true;
this.fadeTime = 0;
}
public function get owner() : ClientObject
{
return null;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import alternativa.tanks.models.battle.battlefield.common.MessageLine;
import alternativa.tanks.models.battle.battlefield.event.ChatOutputLineEvent;
import alternativa.tanks.models.battle.ctf.MessageColor;
import alternativa.tanks.models.battle.gui.statistics.ShortUserInfo;
import alternativa.tanks.models.battle.gui.userlabel.BattleActionUserLabel;
import alternativa.tanks.models.battle.gui.userlabel.BattleChatUserLabel;
import controls.Label;
import forms.userlabel.ChatUpdateEvent;
public class OldActionOutputLine extends MessageLine {
private var userLabel:BattleChatUserLabel;
private var label:Label;
public function OldActionOutputLine(param1:ShortUserInfo, param2:String, param3:ShortUserInfo = null) {
super();
if(param1 != null) {
this.createUserLabel(param1);
}
this.createActionTextLabel(param2);
if(param3 != null) {
this.createUserLabel(param3);
}
}
private function createUserLabel(param1:ShortUserInfo) : void {
this.userLabel = new BattleActionUserLabel(param1.userId);
this.userLabel.addEventListener(ChatUpdateEvent.UPDATE,this.onUpdateEvent);
this.userLabel.setUidColor(MessageColor.getUserNameColor(param1.teamType,false),true);
this.userLabel.x = width + 4;
addChild(this.userLabel);
}
private function onUpdateEvent(param1:ChatUpdateEvent) : void {
this.userLabel.x = 4;
this.label.x = this.userLabel.width + 4;
dispatchEvent(new ChatOutputLineEvent(ChatOutputLineEvent.UPDATE_UID,this));
}
private function createActionTextLabel(param1:String) : void {
this.label = new Label();
this.label.text = param1;
this.label.x = width + 4;
shadowContainer.addChild(this.label);
}
}
}
|
package alternativa.resource
{
import flash.display.Loader;
import flash.display.MovieClip;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.ProgressEvent;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.system.SecurityDomain;
public class MovieClipResource extends Resource
{
private var loader:Loader;
public function MovieClipResource()
{
super("мувик");
throw new Error("Unimplemented");
}
override protected function loadResourceData() : void
{
var context:LoaderContext = new LoaderContext();
context.applicationDomain = ApplicationDomain.currentDomain;
context.securityDomain = SecurityDomain.currentDomain;
this.loader.load(new URLRequest(url + "mc.swf"),context);
}
private function onLoadProgress(e:ProgressEvent) : void
{
loadingProgress(this.loader.contentLoaderInfo.bytesLoaded,this.loader.contentLoaderInfo.bytesTotal);
}
protected function onLoadComplete(e:Event = null) : void
{
completeLoading();
}
public function get mc() : MovieClip
{
return MovieClip(this.loader.content);
}
private function onLoadError(e:ErrorEvent) : void
{
reportFatalError(e.text);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.armor.explosion {
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 TankExplosionModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TankExplosionModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers.purchaseofupgrades {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class AndroidPurchaseOfUpgradesUserModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AndroidPurchaseOfUpgradesUserModelServer;
private var client:IAndroidPurchaseOfUpgradesUserModelBase = IAndroidPurchaseOfUpgradesUserModelBase(this);
private var modelId:Long = Long.getLong(856727384,-557476859);
private var _changeLevelId:Long = Long.getLong(2065306189,-1463079708);
private var _changeLevel_itemIdCodec:ICodec;
private var _changeLevel_newLevelCodec:ICodec;
public function AndroidPurchaseOfUpgradesUserModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AndroidPurchaseOfUpgradesUserModelServer(IModel(this));
this._changeLevel_itemIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._changeLevel_newLevelCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._changeLevelId:
this.client.changeLevel(Long(this._changeLevel_itemIdCodec.decode(param2)),int(this._changeLevel_newLevelCodec.decode(param2)));
}
}
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.ItemCategoryEnum;
public class CodecItemCategoryEnum implements ICodec {
public function CodecItemCategoryEnum() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ItemCategoryEnum = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = ItemCategoryEnum.WEAPON;
break;
case 1:
local2 = ItemCategoryEnum.ARMOR;
break;
case 2:
local2 = ItemCategoryEnum.PAINT;
break;
case 3:
local2 = ItemCategoryEnum.INVENTORY;
break;
case 4:
local2 = ItemCategoryEnum.PLUGIN;
break;
case 5:
local2 = ItemCategoryEnum.KIT;
break;
case 6:
local2 = ItemCategoryEnum.EMBLEM;
break;
case 7:
local2 = ItemCategoryEnum.CRYSTAL;
break;
case 8:
local2 = ItemCategoryEnum.PRESENT;
break;
case 9:
local2 = ItemCategoryEnum.GIVEN_PRESENT;
break;
case 10:
local2 = ItemCategoryEnum.RESISTANCE_MODULE;
break;
case 11:
local2 = ItemCategoryEnum.DEVICE;
break;
case 12:
local2 = ItemCategoryEnum.LICENSE;
break;
case 13:
local2 = ItemCategoryEnum.CONTAINER;
break;
case 14:
local2 = ItemCategoryEnum.DRONE;
break;
case 15:
local2 = ItemCategoryEnum.SKIN;
break;
case 16:
local2 = ItemCategoryEnum.MOBILE_LOOT_BOX;
}
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 scpacker.resource.tanks
{
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.objects.Mesh;
import flash.geom.Vector3D;
public class TankResource
{
public var mesh:Mesh;
public var next:Object;
public var id:String;
public var muzzles:Vector.<Vector3D>;
public var flagMount:Vector3D;
public var turretMount:Vector3D;
public var objects:Vector.<Object3D>;
public function TankResource(mesh:Mesh, id:String, next:Object = null, muzzles:Vector.<Vector3D> = null, flagMount:Vector3D = null, turretMount:Vector3D = null)
{
super();
this.mesh = mesh;
this.id = id;
this.next = next;
this.muzzles = muzzles;
this.flagMount = flagMount;
this.turretMount = turretMount;
this.objects = new Vector.<Object3D>();
}
}
}
|
package alternativa.tanks.servermodels {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.service.IEntranceClientFacade;
import alternativa.tanks.service.IEntranceServerFacade;
import flash.events.Event;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.model.ObjectUnloadPostListener;
import projects.tanks.client.entrance.model.entrance.entrance.EntranceModelBase;
import projects.tanks.client.entrance.model.entrance.entrance.IEntranceModelBase;
import projects.tanks.clients.flash.commons.models.captcha.IServerCaptcha;
[ModelInfo]
public class EntranceModel extends EntranceModelBase implements IEntranceModelBase, ObjectLoadListener, ObjectLoadPostListener, ObjectUnloadListener, ObjectUnloadPostListener {
[Inject]
public static var serverFacade:IEntranceServerFacade;
[Inject]
public static var clientFacade:IEntranceClientFacade;
[Inject]
public static var display:IDisplay;
[Inject]
public static var loaderWindow:ILoaderWindowService;
public function EntranceModel() {
super();
}
public function objectLoaded() : void {
clientFacade.showView();
clientFacade.antiAddictionEnabled = getInitParam().antiAddictionEnabled;
display.stage.dispatchEvent(new Event("EntranceModel.objectLoaded",true));
}
public function objectLoadedPost() : void {
serverFacade.entranceObject = object;
clientFacade.entranceObject = object;
IServerCaptcha(object.adapt(IServerCaptcha)).bindFacade(clientFacade);
}
public function objectUnloaded() : void {
IServerCaptcha(object.adapt(IServerCaptcha)).unbindFacade();
loaderWindow.show();
}
public function objectUnloadedPost() : void {
clientFacade.hideView();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher {
import flash.events.IEventDispatcher;
public interface IDialogWindowsDispatcherService extends IEventDispatcher {
function isOpen() : Boolean;
function open() : void;
function close() : void;
function forciblyClose() : void;
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.freeze
{
import scpacker.Base;
public class FreezeSFXModelBase extends Base
{
public function FreezeSFXModelBase()
{
super();
}
}
}
|
package alternativa.tanks.model.profile
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import alternativa.tanks.model.challenge.greenpanel.GreenPanel;
import controls.Label;
import controls.rangicons.RangIconSmall;
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.MouseEvent;
import forms.buttons.MainPanelGoldenButton;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
public class GiftUserInfo extends Sprite
{
[Embed(source="910.png")]
private static const emeraldBitmap:Class;
[Embed(source="1065.png")]
private static const spinsBitmap:Class;
[Embed(source="830.png")]
private static const incomingBitmap:Class;
[Embed(source="836.png")]
private static const outcomingBitmap:Class;
private var emerald:Bitmap;
private var spin:Bitmap;
private var incoming:Bitmap;
private var outcoming:Bitmap;
private var localeService:ILocaleService;
private var panel:GreenPanel;
private var rankIcon:RangIconSmall;
private var userName:Label;
private var spinLabel:Label;
private var emeraldLabel:Label;
private var incomingGiftsLabel:Label;
private var outcomingGiftsLabel:Label;
private var button:MainPanelGoldenButton;
public function GiftUserInfo(userId:String, rank:int, spins:int, emeralds:int, incomingGifts:int, outcomingGifts:int)
{
this.emerald = new Bitmap(new emeraldBitmap().bitmapData);
this.spin = new Bitmap(new spinsBitmap().bitmapData);
this.incoming = new Bitmap(new incomingBitmap().bitmapData);
this.outcoming = new Bitmap(new outcomingBitmap().bitmapData);
this.panel = new GreenPanel(160,210);
this.button = new MainPanelGoldenButton();
super();
this.localeService = ILocaleService(Main.osgi.getService(ILocaleService));
addChild(this.panel);
this.rankIcon = new RangIconSmall(rank);
this.rankIcon.mouseEnabled = false;
this.rankIcon.x = 10;
this.rankIcon.y = 10;
this.panel.addChild(this.rankIcon);
this.userName = new Label();
this.userName.color = 5898034;
this.userName.text = userId;
this.userName.x = this.rankIcon.x + this.rankIcon.width + 3;
this.userName.y = this.rankIcon.y + (this.rankIcon.height / 2 - this.userName.height / 2);
this.panel.addChild(this.userName);
this.spin.x = this.rankIcon.x;
this.spin.y = this.rankIcon.y + this.rankIcon.height + 10;
this.panel.addChild(this.spin);
this.emerald.x = this.rankIcon.x;
this.emerald.y = this.spin.y + this.spin.height + 10;
this.panel.addChild(this.emerald);
this.spinLabel = new Label();
this.spinLabel.size = 18;
this.spinLabel.text = spins.toString();
this.spinLabel.x = this.spin.x + this.spin.width + 5;
this.spinLabel.y = this.spin.y + (this.spin.height / 2 - this.spinLabel.height / 2);
this.panel.addChild(this.spinLabel);
this.emeraldLabel = new Label();
this.emeraldLabel.size = 18;
this.emeraldLabel.text = emeralds.toString();
this.emeraldLabel.x = this.emerald.x + this.emerald.width + 5;
this.emeraldLabel.y = this.emerald.y + (this.emerald.height / 2 - this.emeraldLabel.height / 2);
this.panel.addChild(this.emeraldLabel);
this.incoming.x = this.rankIcon.x;
this.incoming.y = this.emerald.y + this.emerald.height + 10;
this.panel.addChild(this.incoming);
this.outcoming.x = this.rankIcon.x;
this.outcoming.y = this.incoming.y + this.incoming.height + 10;
this.panel.addChild(this.outcoming);
this.incomingGiftsLabel = new Label();
this.incomingGiftsLabel.size = 18;
this.incomingGiftsLabel.text = incomingGifts.toString();
this.incomingGiftsLabel.x = this.incoming.x + this.incoming.width + 5;
this.incomingGiftsLabel.y = this.incoming.y + (this.incoming.height / 2 - this.incomingGiftsLabel.height / 2);
this.panel.addChild(this.incomingGiftsLabel);
this.outcomingGiftsLabel = new Label();
this.outcomingGiftsLabel.size = 18;
this.outcomingGiftsLabel.text = outcomingGifts.toString();
this.outcomingGiftsLabel.x = this.outcoming.x + this.outcoming.width + 5;
this.outcomingGiftsLabel.y = this.outcoming.y + (this.outcoming.height / 2 - this.outcomingGiftsLabel.height / 2);
this.panel.addChild(this.outcomingGiftsLabel);
this.button.label = this.localeService.getText(TextConst.PROFILE_WINDOW_SEND_GIFT_TEXT);
this.button.x = this.panel.width / 2 - this.button.width / 2;
this.button.y = this.panel.height - this.button.height - 5;
this.button.addEventListener(MouseEvent.CLICK,function(e:MouseEvent = null):void
{
Network(Main.osgi.getService(INetworker)).send("lobby;get_spins_url");
});
this.panel.addChild(this.button);
}
}
}
|
package alternativa.tanks.models.battle.gui.chat.cmdhandlers {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.battle.gui.chat.BattleChatOutput;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blockuser.IBlockUserService;
public class BlockCommandHandler implements IChatCommandHandler {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var blockUserService:IBlockUserService;
private var output:BattleChatOutput;
public function BlockCommandHandler(param1:BattleChatOutput) {
super();
this.output = param1;
}
public function handleCommand(param1:Array) : Boolean {
if(param1.length == 0) {
return false;
}
var local2:String = param1[0];
blockUserService.blockUser(local2);
this.output.addSystemMessage(localeService.getText(TanksLocale.TEXT_CHAT_PANEL_COMMAND_BLOCK,local2));
return true;
}
}
}
|
package _codec.projects.tanks.client.clans.user {
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.clans.user.ClanUserCC;
public class CodecClanUserCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_clan:ICodec;
private var codec_giveBonusesClan:ICodec;
private var codec_loadingInServiceSpace:ICodec;
private var codec_restrictionTimeJoinClanInSec:ICodec;
private var codec_showBuyLicenseButton:ICodec;
private var codec_showOtherClan:ICodec;
public function CodecClanUserCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_clan = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_giveBonusesClan = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_loadingInServiceSpace = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_restrictionTimeJoinClanInSec = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_showBuyLicenseButton = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_showOtherClan = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanUserCC = new ClanUserCC();
local2.clan = this.codec_clan.decode(param1) as Boolean;
local2.giveBonusesClan = this.codec_giveBonusesClan.decode(param1) as Boolean;
local2.loadingInServiceSpace = this.codec_loadingInServiceSpace.decode(param1) as Boolean;
local2.restrictionTimeJoinClanInSec = this.codec_restrictionTimeJoinClanInSec.decode(param1) as int;
local2.showBuyLicenseButton = this.codec_showBuyLicenseButton.decode(param1) as Boolean;
local2.showOtherClan = this.codec_showOtherClan.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClanUserCC = ClanUserCC(param2);
this.codec_clan.encode(param1,local3.clan);
this.codec_giveBonusesClan.encode(param1,local3.giveBonusesClan);
this.codec_loadingInServiceSpace.encode(param1,local3.loadingInServiceSpace);
this.codec_restrictionTimeJoinClanInSec.encode(param1,local3.restrictionTimeJoinClanInSec);
this.codec_showBuyLicenseButton.encode(param1,local3.showBuyLicenseButton);
this.codec_showOtherClan.encode(param1,local3.showOtherClan);
}
}
}
|
package projects.tanks.client.clans.panel.foreignclan {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ForeignClanModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ForeignClanModelServer;
private var client:IForeignClanModelBase = IForeignClanModelBase(this);
private var modelId:Long = Long.getLong(1029456312,194126704);
private var _alreadyInClanOutgoingId:Long = Long.getLong(2072556979,560987130);
private var _alreadyInClanOutgoing_clanNameCodec:ICodec;
private var _alreadyInIncomingId:Long = Long.getLong(1821924666,143246274);
private var _alreadyInIncoming_clanNameCodec:ICodec;
private var _clanBlockedId:Long = Long.getLong(1269926118,-537285713);
private var _clanBlocked_reasonCodec:ICodec;
private var _onJoinClanId:Long = Long.getLong(2037318745,22259876);
private var _onJoinClan_clanNameCodec:ICodec;
private var _showForeignClanId:Long = Long.getLong(1203575776,253980200);
private var _showForeignClan_clanDataCodec:ICodec;
private var _userSmallRankForAddClanId:Long = Long.getLong(763277444,804297489);
public function ForeignClanModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ForeignClanModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ForeignClanCC,false)));
this._alreadyInClanOutgoing_clanNameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._alreadyInIncoming_clanNameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._clanBlocked_reasonCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._onJoinClan_clanNameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._showForeignClan_clanDataCodec = this._protocol.getCodec(new TypeCodecInfo(ForeignClanData,false));
}
protected function getInitParam() : ForeignClanCC {
return ForeignClanCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._alreadyInClanOutgoingId:
this.client.alreadyInClanOutgoing(String(this._alreadyInClanOutgoing_clanNameCodec.decode(param2)));
break;
case this._alreadyInIncomingId:
this.client.alreadyInIncoming(String(this._alreadyInIncoming_clanNameCodec.decode(param2)));
break;
case this._clanBlockedId:
this.client.clanBlocked(String(this._clanBlocked_reasonCodec.decode(param2)));
break;
case this._onJoinClanId:
this.client.onJoinClan(String(this._onJoinClan_clanNameCodec.decode(param2)));
break;
case this._showForeignClanId:
this.client.showForeignClan(ForeignClanData(this._showForeignClan_clanDataCodec.decode(param2)));
break;
case this._userSmallRankForAddClanId:
this.client.userSmallRankForAddClan();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.battle.battlefield {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleModelEvents implements BattleModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattleModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getBattleType() : BattleType {
var result:BattleType = null;
var i:int = 0;
var m:BattleModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleModel(this.impl[i]);
result = m.getBattleType();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.model.timeperiod {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class TimePeriodEvents implements TimePeriod {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function TimePeriodEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function isEnabled() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:TimePeriod = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TimePeriod(this.impl[i]);
result = Boolean(m.isEnabled());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function isTimeless() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:TimePeriod = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TimePeriod(this.impl[i]);
result = Boolean(m.isTimeless());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getModelLoadingTimeInMillis() : int {
var result:int = 0;
var i:int = 0;
var m:TimePeriod = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TimePeriod(this.impl[i]);
result = int(m.getModelLoadingTimeInMillis());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getTimeLeftInSeconds() : int {
var result:int = 0;
var i:int = 0;
var m:TimePeriod = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TimePeriod(this.impl[i]);
result = int(m.getTimeLeftInSeconds());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getTimeToStartInSeconds() : int {
var result:int = 0;
var i:int = 0;
var m:TimePeriod = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TimePeriod(this.impl[i]);
result = int(m.getTimeToStartInSeconds());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.clients.flash.commons.models.captcha {
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
[ModelInterface]
public interface IServerCaptcha {
function bindFacade(param1:CaptchaClientFacade) : void;
function unbindFacade() : void;
function checkCaptcha(param1:String, param2:CaptchaLocation) : void;
function getNewCaptcha(param1:CaptchaLocation) : void;
}
}
|
package _codec.platform.client.core.general.spaces.loading.modelconstructors {
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.Long;
import platform.client.core.general.spaces.loading.modelconstructors.ModelData;
public class CodecModelData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_data:ICodec;
private var codec_id:ICodec;
public function CodecModelData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_data = param1.getCodec(new TypeCodecInfo(Object,false));
this.codec_id = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ModelData = new ModelData();
local2.data = this.codec_data.decode(param1) as Object;
local2.id = this.codec_id.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ModelData = ModelData(param2);
this.codec_data.encode(param1,local3.data);
this.codec_id.encode(param1,local3.id);
}
}
}
|
package projects.tanks.client.battlefield.models.bonus.battle.battlefield {
import projects.tanks.client.battlefield.models.bonus.battle.BonusSpawnData;
public class BattlefieldBonusesCC {
private var _bonusFallSpeed:Number;
private var _bonuses:Vector.<BonusSpawnData>;
public function BattlefieldBonusesCC(param1:Number = 0, param2:Vector.<BonusSpawnData> = null) {
super();
this._bonusFallSpeed = param1;
this._bonuses = param2;
}
public function get bonusFallSpeed() : Number {
return this._bonusFallSpeed;
}
public function set bonusFallSpeed(param1:Number) : void {
this._bonusFallSpeed = param1;
}
public function get bonuses() : Vector.<BonusSpawnData> {
return this._bonuses;
}
public function set bonuses(param1:Vector.<BonusSpawnData>) : void {
this._bonuses = param1;
}
public function toString() : String {
var local1:String = "BattlefieldBonusesCC [";
local1 += "bonusFallSpeed = " + this.bonusFallSpeed + " ";
local1 += "bonuses = " + this.bonuses + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.friends {
public class RejectAllIncomingButton extends FriendWindowButton implements IRejectAllIncomingButtonEnabled {
public function RejectAllIncomingButton() {
super();
}
public function setEnable(param1:Boolean) : void {
super.enable = param1;
}
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsBattleInfoIcons_goldBonusesClass.png")]
public class BattleParamsBattleInfoIcons_goldBonusesClass extends BitmapAsset {
public function BattleParamsBattleInfoIcons_goldBonusesClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft {
public class ShaftEnergyMode {
public static const RECHARGE:ShaftEnergyMode = new ShaftEnergyMode("RECHARGE");
public static const DRAIN:ShaftEnergyMode = new ShaftEnergyMode("DRAIN");
private var value:String;
public function ShaftEnergyMode(param1:String) {
super();
this.value = param1;
}
[Obfuscation(rename="false")]
public function toString() : String {
return this.value;
}
}
}
|
package org.osflash.signals {
public interface ISignal {
function get valueClasses() : Array;
function set valueClasses(value:Array) : void;
function get numListeners() : uint;
function add(listener:Function) : Function;
function addOnce(listener:Function) : Function;
function remove(listener:Function) : Function;
}
}
|
package forms.buttons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MainPanelChallengeButton_overBtn extends BitmapAsset
{
public function MainPanelChallengeButton_overBtn()
{
super();
}
}
}
|
package alternativa.tanks.sfx.christmas {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.sfx.christmas.ChristmasTreeToyEffect_GreenTexture.png")]
public class ChristmasTreeToyEffect_GreenTexture extends BitmapAsset {
public function ChristmasTreeToyEffect_GreenTexture() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.kitview.localized {
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 KitViewResourceLocalizedModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function KitViewResourceLocalizedModelServer(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 services.alertservice {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import controls.ColorButton;
import controls.TankWindow;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.buttons.ButtonBase;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import forms.events.AlertEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.AlertUtils;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.KeyUpListenerPriority;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeDisplayObject;
public class Alert extends Sprite {
public static const ALERT_QUIT:int = 0;
public static const ALERT_CONFIRM_EMAIL:int = 1;
public static const ERROR_CALLSIGN_FIRST_SYMBOL:int = 2;
public static const ERROR_CALLSIGN_DEVIDE:int = 3;
public static const ERROR_CALLSIGN_LAST_SYMBOL:int = 4;
public static const ERROR_CALLSIGN_LENGTH:int = 5;
public static const ERROR_CALLSIGN_UNIQUE:int = 6;
public static const ERROR_PASSWORD_LENGTH:int = 7;
public static const ERROR_PASSWORD_INCORRECT:int = 8;
public static const ERROR_PASSWORD_CHANGE:int = 9;
public static const ERROR_EMAIL_UNIQUE:int = 10;
public static const ERROR_EMAIL_INVALID:int = 11;
public static const ERROR_EMAIL_NOTFOUND:int = 12;
public static const ERROR_EMAIL_NOTSENDED:int = 13;
public static const ERROR_FATAL:int = 14;
public static const ERROR_FATAL_DEBUG:int = 15;
public static const GARAGE_AVAILABLE:int = 16;
public static const ALERT_RECOVERY_LINK_SENDED:int = 17;
public static const ALERT_CHAT_PROCEED:int = 18;
public static const CAPTCHA_INCORRECT:int = 19;
public static const ERROR_CONFIRM_EMAIL:int = 20;
public static const CONFIRM_UNKINK_VK:int = 21;
public static const ERROR_PARTNER_LINK_ALREADY_EXISTS:int = 22;
protected var bgWindow:TankWindow = new TankWindow();
private var output:LabelBase;
private var message:String;
private var labels:Vector.<String>;
protected var alertWindow:Sprite = new Sprite();
public var closeButton:MainPanelCloseButton = new MainPanelCloseButton();
private var closable:Boolean = false;
private const alerts:Array = [];
private var id:int;
private var localeService:ILocaleService;
private var customButtons:Vector.<Sprite>;
public function Alert(param1:int = -1, param2:Boolean = false) {
super();
this.closable = param2;
this.id = param1;
this.init();
}
public static function fillButtonLabels(param1:ILocaleService) : void {
AlertAnswer.YES = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_YES);
AlertAnswer.NO = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_NO);
AlertAnswer.OK = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_OK);
AlertAnswer.CANCEL = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_CANCEL);
AlertAnswer.SEND = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_SEND_BUG_REPORT);
AlertAnswer.RETURN = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_RETURN_TO_BATTLE);
AlertAnswer.GARAGE = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_GO_TO_GARAGE);
AlertAnswer.PROCEED = param1.getText(TanksLocale.TEXT_ALERT_ANSWER_PROCEED);
AlertAnswer.ENTER = param1.getText(TanksLocale.TEXT_BATTLEINFO_PANEL_PAID_BATTLES_ALERT_ANSWER_ENTER);
AlertAnswer.DO_NOT_ENTER = param1.getText(TanksLocale.TEXT_BATTLEINFO_PANEL_PAID_BATTLES_ALERT_ANSWER_DONT_ENTER);
}
private function init() : void {
this.localeService = ILocaleService(OSGi.getInstance().getService(ILocaleService));
this.bgWindow.headerLang = this.localeService.getText(TanksLocale.TEXT_GUI_LANG);
if(AlertAnswer.YES == null) {
fillButtonLabels(this.localeService);
}
this.initStandardAlerts(this.localeService);
if(this.id > -1) {
this.showAlert(this.alerts[this.id][0],this.alerts[this.id][1]);
}
this.createOutput();
}
private function initStandardAlerts(param1:ILocaleService) : void {
this.alerts[ALERT_QUIT] = [param1.getText(TanksLocale.TEXT_ALERT_QUIT_TEXT),Vector.<String>([AlertAnswer.YES,AlertAnswer.NO])];
this.alerts[ALERT_CONFIRM_EMAIL] = [param1.getText(TanksLocale.TEXT_ALERT_EMAIL_CONFIRMED),Vector.<String>([AlertAnswer.YES])];
this.alerts[ERROR_FATAL] = [param1.getText(TanksLocale.TEXT_ERROR_FATAL),Vector.<String>([AlertAnswer.RETURN])];
this.alerts[ERROR_FATAL_DEBUG] = [param1.getText(TanksLocale.TEXT_ERROR_FATAL_DEBUG),Vector.<String>([AlertAnswer.SEND])];
this.alerts[ERROR_CALLSIGN_FIRST_SYMBOL] = [param1.getText(TanksLocale.TEXT_ERROR_CALLSIGN_WRONG_FIRST_SYMBOL),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_CALLSIGN_DEVIDE] = [param1.getText(TanksLocale.TEXT_ERROR_CALLSIGN_NOT_SINGLE_DEVIDERS),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_CALLSIGN_LAST_SYMBOL] = [param1.getText(TanksLocale.TEXT_ERROR_CALLSIGN_WRONG_LAST_SYMBOL),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_CALLSIGN_LENGTH] = [param1.getText(TanksLocale.TEXT_ERROR_CALLSIGN_LENGTH),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_CALLSIGN_UNIQUE] = [param1.getText(TanksLocale.TEXT_ERROR_CALLSIGN_NOT_UNIQUE),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_EMAIL_UNIQUE] = [param1.getText(TanksLocale.TEXT_ERROR_EMAIL_NOT_UNIQUE),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_EMAIL_INVALID] = [param1.getText(TanksLocale.TEXT_ERROR_EMAIL_INVALID),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_EMAIL_NOTFOUND] = [param1.getText(TanksLocale.TEXT_ERROR_EMAIL_NOT_FOUND),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_EMAIL_NOTSENDED] = [param1.getText(TanksLocale.TEXT_ERROR_EMAIL_NOT_SENDED),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_PASSWORD_INCORRECT] = [param1.getText(TanksLocale.TEXT_ERROR_PASSWORD_INCORRECT),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_PASSWORD_LENGTH] = [param1.getText(TanksLocale.TEXT_ERROR_PASSWORD_LENGTH),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_PASSWORD_CHANGE] = [param1.getText(TanksLocale.TEXT_ERROR_PASSWORD_CHANGE),Vector.<String>([AlertAnswer.OK])];
this.alerts[GARAGE_AVAILABLE] = [param1.getText(TanksLocale.TEXT_ALERT_GARAGE_AVAILABLE),Vector.<String>([AlertAnswer.GARAGE,AlertAnswer.CANCEL])];
this.alerts[ALERT_RECOVERY_LINK_SENDED] = [param1.getText(TanksLocale.TEXT_SETTINGS_CHANGE_PASSWORD_CONFIRMATION_SENT_TEXT),Vector.<String>([AlertAnswer.OK])];
this.alerts[ALERT_CHAT_PROCEED] = [param1.getText(TanksLocale.TEXT_ALERT_CHAT_PROCEED_EXTERNAL_LINK),Vector.<String>([AlertAnswer.CANCEL])];
this.alerts[CAPTCHA_INCORRECT] = [param1.getText(TanksLocale.TEXT_CAPTCHA_INCORRECT),Vector.<String>([AlertAnswer.OK])];
this.alerts[ERROR_CONFIRM_EMAIL] = [param1.getText(TanksLocale.TEXT_ALERT_EMAIL_CONFIRMED_WRONG_LINK),Vector.<String>([AlertAnswer.OK])];
this.alerts[CONFIRM_UNKINK_VK] = ["Внимание!\nПрежде чем вы сможете закрыть доступ для сервиса ВКонтакте, вам\nнеобходимо установить пароль для аккаунта \"Танков Онлайн\" в настройках.",[AlertAnswer.OK]];
this.alerts[ERROR_PARTNER_LINK_ALREADY_EXISTS] = [param1.getText(TanksLocale.TEXT_PARTNER_USERNAME_ALREDY_USED_ERROR),Vector.<String>([AlertAnswer.OK])];
}
private function createOutput() : void {
this.output = new LabelBase();
this.output.autoSize = TextFieldAutoSize.CENTER;
this.output.align = TextFormatAlign.CENTER;
this.output.size = 14;
this.output.width = 10;
this.output.height = 10;
this.output.x = -5;
this.output.y = 30;
this.output.multiline = true;
}
public function showAlert(param1:String, param2:Vector.<String>) : void {
this.message = param1;
this.customButtons = null;
this.labels = param2;
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
public function showAlertWithCustomButtons(param1:String, param2:Vector.<String>, param3:Vector.<Sprite>) : void {
this.message = param1;
this.labels = param2;
this.customButtons = param3;
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
this.doLayout(param1);
}
private function hasButtons() : Boolean {
return this.labels.length != 0;
}
private function isCustomLabels() : Boolean {
return this.customButtons != null;
}
protected function doLayout(param1:Event) : void {
var local4:Sprite = null;
var local5:int = 0;
var local6:DefaultButtonBase = null;
var local2:int = this.calculateButtonsWidth();
var local3:int = local2 * this.labels.length / 2;
addChild(this.alertWindow);
this.alertWindow.addChild(this.bgWindow);
this.alertWindow.addChild(this.output);
this.output.htmlText = this.message;
if(this.hasButtons()) {
local5 = 0;
while(local5 < this.labels.length) {
if(this.isCustomLabels()) {
local4 = this.customButtons[local5];
} else {
local6 = new DefaultButtonBase();
local4 = local6;
local6.label = this.labels[local5];
}
local4.x = local2 * local5 - local3;
local4.y = this.output.y + this.output.height + 15;
local4.width = local2 - 6;
local4.addEventListener(MouseEvent.CLICK,this.close);
this.alertWindow.addChild(local4);
local5++;
}
this.bgWindow.height = local4.y + 60;
} else {
this.bgWindow.height = this.output.y + this.output.height + 30;
}
this.bgWindow.width = Math.max(int(this.output.width + 50),local3 * 2 + 50);
this.bgWindow.x = -int(this.bgWindow.width / 2) - 3;
stage.addEventListener(Event.RESIZE,this.onStageResize);
stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp,false,KeyUpListenerPriority.ALERT);
stage.focus = this;
if(this.closable) {
this.alertWindow.addChild(this.closeButton);
this.closeButton.x = this.bgWindow.x + this.bgWindow.width - this.closeButton.width - 10;
this.closeButton.y = 10;
this.closeButton.addEventListener(MouseEvent.CLICK,this.close);
}
this.onStageResize(null);
}
private function onKeyUp(param1:KeyboardEvent) : void {
var local2:String = null;
switch(this.labels.length) {
case 1:
if(AlertUtils.isConfirmationKey(param1.keyCode) || AlertUtils.isCancelKey(param1.keyCode)) {
local2 = this.labels[0];
}
break;
case 2:
if(AlertUtils.isConfirmationKey(param1.keyCode)) {
local2 = this.getFirstExistingLabel(this.getConfirmationButtonNames());
} else if(AlertUtils.isCancelKey(param1.keyCode)) {
local2 = this.getFirstExistingLabel(this.getCancelButtonNames());
}
break;
case 3:
if(AlertUtils.isConfirmationKey(param1.keyCode)) {
local2 = this.getFirstExistingLabel(this.getConfirmationButtonNames());
} else if(AlertUtils.isCancelKey(param1.keyCode)) {
local2 = this.getFirstExistingLabel(Vector.<String>([AlertAnswer.CANCEL]));
}
}
if(local2 != null) {
param1.stopImmediatePropagation();
this.dispatchClickEventForButtonWithLabel(local2);
}
}
private function getCancelButtonNames() : Vector.<String> {
return Vector.<String>([AlertAnswer.NO,AlertAnswer.CANCEL,AlertAnswer.RETURN,AlertAnswer.DO_NOT_ENTER]);
}
private function getConfirmationButtonNames() : Vector.<String> {
return Vector.<String>([AlertAnswer.OK,AlertAnswer.YES,AlertAnswer.GARAGE,AlertAnswer.PROCEED,AlertAnswer.SEND,AlertAnswer.ENTER,this.localeService.getText(TanksLocale.TEXT_BATTLE_ENTER_WARNING_PARKOUR_BUTTON_ENTER)]);
}
private function getFirstExistingLabel(param1:Vector.<String>) : String {
var local3:int = 0;
var local2:int = 0;
while(local2 < this.labels.length) {
local3 = int(param1.indexOf(this.labels[local2]));
if(local3 > -1) {
return param1[local3];
}
local2++;
}
return "";
}
private function childHasLabel(param1:Object) : Boolean {
return param1 is ButtonBase || param1 is ColorButton;
}
private function getChildLabel(param1:Object) : String {
if(param1 is ButtonBase) {
return ButtonBase(param1).label;
}
if(param1 is ColorButton) {
return ColorButton(param1).label;
}
return null;
}
private function dispatchClickEventForButtonWithLabel(param1:String) : void {
var local3:DisplayObject = null;
var local2:int = 0;
while(local2 < this.alertWindow.numChildren) {
local3 = this.alertWindow.getChildAt(local2);
if(this.childHasLabel(local3) && this.getChildLabel(local3) == param1) {
local3.dispatchEvent(new MouseEvent(MouseEvent.CLICK));
return;
}
local2++;
}
}
private function calculateButtonsWidth() : int {
var local1:int = 80;
var local2:LabelBase = new LabelBase();
var local3:int = 0;
while(local3 < this.labels.length) {
local2.text = this.labels[local3];
if(local2.width > local1) {
local1 = local2.width;
}
local3++;
}
return local1 + 18;
}
private function onStageResize(param1:Event) : void {
this.alertWindow.x = int(stage.stageWidth / 2);
this.alertWindow.y = int(stage.stageHeight / 2 - this.alertWindow.height / 2);
}
private function close(param1:MouseEvent) : void {
stage.removeEventListener(Event.RESIZE,this.onStageResize);
stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
this.removeMouseListenerFromButtons();
while(this.alertWindow.numChildren > 0) {
this.alertWindow.removeChildAt(0);
}
if(this.childHasLabel(param1.currentTarget)) {
dispatchEvent(new AlertEvent(this.getChildLabel(param1.currentTarget)));
}
removeDisplayObject(this);
}
private function removeMouseListenerFromButtons() : void {
var local2:DisplayObject = null;
var local1:int = 0;
while(local1 < this.alertWindow.numChildren) {
local2 = this.alertWindow.getChildAt(local1);
if(local2 == this.closeButton) {
local2.removeEventListener(MouseEvent.CLICK,this.close);
}
local1++;
}
}
public function simulatePressedCancel() : void {
var local1:String = null;
if(this.labels.length == 2) {
local1 = this.getFirstExistingLabel(this.getCancelButtonNames());
} else if(this.labels.length == 1) {
local1 = this.labels[0];
}
if(local1 != null) {
this.dispatchClickEventForButtonWithLabel(local1);
}
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle {
import flash.events.Event;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.battle.BattleLinkData;
public class SetBattleNotifierServiceEvent extends Event {
public static const SET_BATTLE:String = "SetBattleNotifierServiceEvent.SET_BATTLE";
public var users:Vector.<BattleLinkData>;
public function SetBattleNotifierServiceEvent(param1:String, param2:Vector.<BattleLinkData>, param3:Boolean = false, param4:Boolean = false) {
this.users = param2;
super(param1,param3,param4);
}
}
}
|
package alternativa.tanks.models.sfx.healing
{
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.Sound3D;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.healing.IsisActionType;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
public class HealingGunSoundEffect implements ISound3DEffect
{
private static const NUM_LOOPS:int = 100000;
private static var position:Vector3 = new Vector3();
private var sfxData:HealingGunSFXData;
private var object:Object3D;
private var _mode:IsisActionType;
private var _enabled:Boolean;
private var dead:Boolean;
private var currentSound3D:Sound3D;
private var soundChannel:SoundChannel;
private var listener:IHealingGunEffectListener;
public function HealingGunSoundEffect(listener:IHealingGunEffectListener)
{
super();
this.listener = listener;
}
public function init(mode:IsisActionType, sfxData:HealingGunSFXData, object:Object3D) : void
{
this.sfxData = sfxData;
this.object = object;
this._mode = mode;
this.dead = false;
this._enabled = false;
this.updateMode();
}
public function set mode(value:IsisActionType) : void
{
if(this._mode == value)
{
return;
}
this._mode = value;
this.updateMode();
}
public function set enabled(value:Boolean) : void
{
if(this._enabled == value)
{
return;
}
this._enabled = value;
if(!this._enabled)
{
this.currentSound3D.stop();
this.soundChannel = null;
}
}
public function play(millis:int, camera:GameCamera) : Boolean
{
if(this.dead)
{
return false;
}
if(this.soundChannel == null)
{
this.soundChannel = this.currentSound3D.play(0,NUM_LOOPS);
}
position.x = this.object.x;
position.y = this.object.y;
position.z = this.object.z;
this.currentSound3D.checkVolume(camera.pos,position,camera.xAxis);
return true;
}
public function readPosition(result:Vector3) : void
{
result.x = this.object.x;
result.y = this.object.y;
result.z = this.object.z;
}
public function destroy() : void
{
if(this.currentSound3D != null)
{
Sound3D.destroy(this.currentSound3D);
this.currentSound3D = null;
this.soundChannel = null;
}
this.sfxData = null;
this.object = null;
this.listener.onEffectDestroyed(this);
}
public function get numSounds() : int
{
return !!this.dead ? int(int(0)) : int(int(1));
}
public function kill() : void
{
this.dead = true;
}
public function get owner() : ClientObject
{
return null;
}
private function updateMode() : void
{
var soundTransform:SoundTransform = null;
var sound:Sound = null;
if(this.sfxData == null)
{
return;
}
if(this.soundChannel != null)
{
soundTransform = this.soundChannel.soundTransform;
this.soundChannel = null;
}
if(this.currentSound3D != null)
{
Sound3D.destroy(this.currentSound3D);
}
switch(this._mode)
{
case IsisActionType.IDLE:
sound = this.sfxData.idleSound;
break;
case IsisActionType.HEAL:
sound = this.sfxData.healSound;
break;
case IsisActionType.DAMAGE:
sound = this.sfxData.damageSound;
}
this.currentSound3D = Sound3D.create(sound,1000,2000,2,1);
if(soundTransform != null)
{
this.soundChannel = this.currentSound3D.play(0,NUM_LOOPS);
this.soundChannel.soundTransform = soundTransform;
}
}
}
}
|
package alternativa.tanks.help
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class ScoreHelper extends BubbleHelper
{
public function ScoreHelper()
{
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
text = localeService.getText(TextConst.HELP_PANEL_SCORE_HELPER_TEXT);
arrowLehgth = int(localeService.getText(TextConst.HELP_PANEL_SCORE_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.TOP_LEFT;
_showLimit = 3;
_targetPoint.x = 79;
_targetPoint.y = 25;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.shoot.smoky {
public interface ISmokyShootSFXModelBase {
}
}
|
package alternativa.tanks.model.item.modification {
import alternativa.types.Long;
import projects.tanks.client.garage.models.item.modification.IModificationModelBase;
import projects.tanks.client.garage.models.item.modification.ModificationModelBase;
[ModelInfo]
public class ModificationModel extends ModificationModelBase implements IModificationModelBase, IModification {
public function ModificationModel() {
super();
}
public function getBaseItemId() : Long {
return getInitParam().baseItemId;
}
public function getModificationIndex() : int {
return getInitParam().modificationIndex;
}
}
}
|
package alternativa.tanks.models.weapon.weakening {
public class DistanceWeakening {
private var maximumDamageRadius:Number;
private var minimumDamageRadius:Number;
private var minimumDamagePercent:Number;
private var falloffInterval:Number;
public function DistanceWeakening(param1:Number, param2:Number, param3:Number) {
super();
this.maximumDamageRadius = param1;
this.minimumDamageRadius = param2;
this.minimumDamagePercent = param3;
this.falloffInterval = param2 - param1;
}
public function getImpactCoeff(param1:Number) : Number {
if(this.falloffInterval <= 0) {
return 1;
}
if(param1 <= this.maximumDamageRadius) {
return 1;
}
if(param1 >= this.minimumDamageRadius) {
return 0.01 * this.minimumDamagePercent;
}
return 0.01 * (this.minimumDamagePercent + (this.minimumDamageRadius - param1) * (100 - this.minimumDamagePercent) / this.falloffInterval);
}
public function getFullDamageDistance() : Number {
return this.maximumDamageRadius;
}
public function getDistance() : Number {
return this.minimumDamageRadius;
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.ctf.CTFHudIndicators_flagOnBaseRed.png")]
public class CTFHudIndicators_flagOnBaseRed extends BitmapAsset {
public function CTFHudIndicators_flagOnBaseRed() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.chat {
import alternativa.tanks.models.battle.battlefield.common.MessageContainer;
import alternativa.tanks.models.battle.battlefield.common.MessageLine;
import alternativa.tanks.models.battle.battlefield.event.ChatOutputLineEvent;
import alternativa.types.Long;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import forms.userlabel.ChatUpdateEvent;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleChatOutput extends MessageContainer {
private static const LINE_WIDTH:int = 300;
private static const MAX_MESSAGES:int = 100;
private static const MIN_MESSAGES:int = 5;
private var buffer:Array = [];
private var minimizedMode:Boolean = true;
private var updateId:uint = 0;
public function BattleChatOutput() {
super();
}
public function addLine(param1:Long, param2:BattleTeam, param3:String, param4:Boolean, param5:Boolean) : void {
this.removeFirsLineIfNeeded();
var local6:BattleChatLine = new BattleChatLine(param1,param2,param3,param4,param5);
local6.addEventListener(ChatOutputLineEvent.KILL_ME,this.killLine);
this.addToBuffer(local6);
pushBack(local6);
container.addEventListener(ChatUpdateEvent.UPDATE,this.onUpdateEvent);
}
private function onUpdateEvent(param1:ChatUpdateEvent) : void {
if(this.updateId != 0) {
clearTimeout(this.updateId);
}
this.updateId = setTimeout(this.updateLines,100);
}
private function updateLines() : void {
var local1:MessageLine = null;
this.updateId = 0;
for each(local1 in this.buffer) {
if(local1 is BattleChatLine) {
BattleChatLine(local1).alignChatUserLabel();
}
}
}
public function addSystemMessage(param1:String) : void {
this.removeFirsLineIfNeeded();
var local2:BattleChatSystemLine = new BattleChatSystemLine(LINE_WIDTH,param1);
local2.addEventListener(ChatOutputLineEvent.KILL_ME,this.killLine);
this.addToBuffer(local2);
pushBack(local2);
}
override public function removeFirstMessage(param1:Boolean = false) : MessageLine {
var local2:MessageLine = super.removeFirstMessage();
this.y += shift;
if(param1) {
this.buffer.shift();
}
return local2;
}
public function maximize() : void {
var local1:int = 0;
var local3:MessageLine = null;
this.minimizedMode = false;
var local2:int = this.buffer.length - container.numChildren;
local1 = 0;
while(local1 < container.numChildren) {
local3 = MessageLine(container.getChildAt(local1));
local3.killStop();
local1++;
}
local1 = local2 - 1;
while(local1 >= 0) {
try {
pushFront(MessageLine(this.buffer[local1]));
}
catch(err:Error) {
}
local1--;
}
}
public function minimize() : void {
var local1:int = 0;
var local3:MessageLine = null;
this.minimizedMode = true;
var local2:int = container.numChildren - MIN_MESSAGES;
local1 = 0;
while(local1 < local2) {
this.removeFirstMessage();
local1++;
}
local1 = 0;
while(local1 < container.numChildren) {
local3 = MessageLine(container.getChildAt(local1));
if(!local3.alive) {
this.removeFirstMessage();
local1--;
} else {
local3.killStart();
}
local1++;
}
}
public function clear() : void {
this.buffer.length = 0;
var local1:int = container.numChildren - 1;
while(local1 >= 0) {
container.removeChildAt(local1);
local1--;
}
}
private function killLine(param1:ChatOutputLineEvent) : void {
if(this.minimizedMode && container.contains(param1.line)) {
this.removeFirstMessage();
}
param1.line.removeEventListener(ChatOutputLineEvent.KILL_ME,this.killLine);
}
private function removeFirsLineIfNeeded() : void {
if(this.minimizedMode && container.numChildren > MIN_MESSAGES || !this.minimizedMode && container.numChildren >= MAX_MESSAGES) {
this.removeFirstMessage();
}
}
private function addToBuffer(param1:MessageLine) : void {
this.buffer.push(param1);
if(this.buffer.length > MAX_MESSAGES) {
this.buffer.shift();
}
}
}
}
|
package alternativa.tanks.gui.shopitems.item.kits.description.panel
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class KitPackageDescriptionPanelBitmaps_bitmapTopLine extends BitmapAsset
{
public function KitPackageDescriptionPanelBitmaps_bitmapTopLine()
{
super();
}
}
}
|
package alternativa.tanks.gui.components.button {
import alternativa.tanks.gui.clanmanagement.clanmemberlist.IClanActionListener;
import alternativa.tanks.models.service.ClanService;
import controls.DefaultButton;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
public class ClanButtonActionListener extends DefaultButton implements IClanActionListener {
[Inject]
public static var clanService:ClanService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
private var action:ClanAction;
public function ClanButtonActionListener(param1:ClanAction) {
super();
this.action = param1;
}
public function updateActions() : void {
visible = !clanService.isBlocked && Boolean(clanService.isSelf) && Boolean(clanUserInfoService.hasAction(this.action));
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.math.Vector3;
import alternativa.physics.Body;
[ModelInterface]
public interface RailgunCallback {
function onStartCharging(param1:int) : void;
function onShot(param1:int, param2:Vector3, param3:Vector.<Body>, param4:Vector.<Vector3>) : void;
function onShotDummy(param1:int) : void;
}
}
|
package alternativa.tanks.model.bonus.showing.items {
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemCC;
[ModelInterface]
public interface BonusItem {
function getItem() : BonusItemCC;
}
}
|
package projects.tanks.client.panel.model.socialnetwork {
public class SocialNetworkPanelCC {
private var _passwordCreated:Boolean;
private var _socialNetworkParams:Vector.<SocialNetworkPanelParams>;
public function SocialNetworkPanelCC(param1:Boolean = false, param2:Vector.<SocialNetworkPanelParams> = null) {
super();
this._passwordCreated = param1;
this._socialNetworkParams = param2;
}
public function get passwordCreated() : Boolean {
return this._passwordCreated;
}
public function set passwordCreated(param1:Boolean) : void {
this._passwordCreated = param1;
}
public function get socialNetworkParams() : Vector.<SocialNetworkPanelParams> {
return this._socialNetworkParams;
}
public function set socialNetworkParams(param1:Vector.<SocialNetworkPanelParams>) : void {
this._socialNetworkParams = param1;
}
public function toString() : String {
var local1:String = "SocialNetworkPanelCC [";
local1 += "passwordCreated = " + this.passwordCreated + " ";
local1 += "socialNetworkParams = " + this.socialNetworkParams + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.rugby {
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class RugbyCC {
private var _ballFallSpeeed:Number;
private var _ballModel:Tanks3DSResource;
private var _ballRadius:Number;
private var _ballSpawnZone:TextureResource;
private var _bigBlueBallMarker:TextureResource;
private var _bigGreenBallMarker:TextureResource;
private var _bigRedBallMarker:TextureResource;
private var _blueBallMarker:TextureResource;
private var _blueGoalModel:Tanks3DSResource;
private var _cordResource:TextureResource;
private var _greenBallMarker:TextureResource;
private var _parachuteInnerResource:Tanks3DSResource;
private var _parachuteResource:Tanks3DSResource;
private var _redBallMarker:TextureResource;
private var _redGoalModel:Tanks3DSResource;
private var _sounds:RugbySoundFX;
public function RugbyCC(param1:Number = 0, param2:Tanks3DSResource = null, param3:Number = 0, param4:TextureResource = null, param5:TextureResource = null, param6:TextureResource = null, param7:TextureResource = null, param8:TextureResource = null, param9:Tanks3DSResource = null, param10:TextureResource = null, param11:TextureResource = null, param12:Tanks3DSResource = null, param13:Tanks3DSResource = null, param14:TextureResource = null, param15:Tanks3DSResource = null, param16:RugbySoundFX = null) {
super();
this._ballFallSpeeed = param1;
this._ballModel = param2;
this._ballRadius = param3;
this._ballSpawnZone = param4;
this._bigBlueBallMarker = param5;
this._bigGreenBallMarker = param6;
this._bigRedBallMarker = param7;
this._blueBallMarker = param8;
this._blueGoalModel = param9;
this._cordResource = param10;
this._greenBallMarker = param11;
this._parachuteInnerResource = param12;
this._parachuteResource = param13;
this._redBallMarker = param14;
this._redGoalModel = param15;
this._sounds = param16;
}
public function get ballFallSpeeed() : Number {
return this._ballFallSpeeed;
}
public function set ballFallSpeeed(param1:Number) : void {
this._ballFallSpeeed = param1;
}
public function get ballModel() : Tanks3DSResource {
return this._ballModel;
}
public function set ballModel(param1:Tanks3DSResource) : void {
this._ballModel = param1;
}
public function get ballRadius() : Number {
return this._ballRadius;
}
public function set ballRadius(param1:Number) : void {
this._ballRadius = param1;
}
public function get ballSpawnZone() : TextureResource {
return this._ballSpawnZone;
}
public function set ballSpawnZone(param1:TextureResource) : void {
this._ballSpawnZone = param1;
}
public function get bigBlueBallMarker() : TextureResource {
return this._bigBlueBallMarker;
}
public function set bigBlueBallMarker(param1:TextureResource) : void {
this._bigBlueBallMarker = param1;
}
public function get bigGreenBallMarker() : TextureResource {
return this._bigGreenBallMarker;
}
public function set bigGreenBallMarker(param1:TextureResource) : void {
this._bigGreenBallMarker = param1;
}
public function get bigRedBallMarker() : TextureResource {
return this._bigRedBallMarker;
}
public function set bigRedBallMarker(param1:TextureResource) : void {
this._bigRedBallMarker = param1;
}
public function get blueBallMarker() : TextureResource {
return this._blueBallMarker;
}
public function set blueBallMarker(param1:TextureResource) : void {
this._blueBallMarker = param1;
}
public function get blueGoalModel() : Tanks3DSResource {
return this._blueGoalModel;
}
public function set blueGoalModel(param1:Tanks3DSResource) : void {
this._blueGoalModel = param1;
}
public function get cordResource() : TextureResource {
return this._cordResource;
}
public function set cordResource(param1:TextureResource) : void {
this._cordResource = param1;
}
public function get greenBallMarker() : TextureResource {
return this._greenBallMarker;
}
public function set greenBallMarker(param1:TextureResource) : void {
this._greenBallMarker = param1;
}
public function get parachuteInnerResource() : Tanks3DSResource {
return this._parachuteInnerResource;
}
public function set parachuteInnerResource(param1:Tanks3DSResource) : void {
this._parachuteInnerResource = param1;
}
public function get parachuteResource() : Tanks3DSResource {
return this._parachuteResource;
}
public function set parachuteResource(param1:Tanks3DSResource) : void {
this._parachuteResource = param1;
}
public function get redBallMarker() : TextureResource {
return this._redBallMarker;
}
public function set redBallMarker(param1:TextureResource) : void {
this._redBallMarker = param1;
}
public function get redGoalModel() : Tanks3DSResource {
return this._redGoalModel;
}
public function set redGoalModel(param1:Tanks3DSResource) : void {
this._redGoalModel = param1;
}
public function get sounds() : RugbySoundFX {
return this._sounds;
}
public function set sounds(param1:RugbySoundFX) : void {
this._sounds = param1;
}
public function toString() : String {
var local1:String = "RugbyCC [";
local1 += "ballFallSpeeed = " + this.ballFallSpeeed + " ";
local1 += "ballModel = " + this.ballModel + " ";
local1 += "ballRadius = " + this.ballRadius + " ";
local1 += "ballSpawnZone = " + this.ballSpawnZone + " ";
local1 += "bigBlueBallMarker = " + this.bigBlueBallMarker + " ";
local1 += "bigGreenBallMarker = " + this.bigGreenBallMarker + " ";
local1 += "bigRedBallMarker = " + this.bigRedBallMarker + " ";
local1 += "blueBallMarker = " + this.blueBallMarker + " ";
local1 += "blueGoalModel = " + this.blueGoalModel + " ";
local1 += "cordResource = " + this.cordResource + " ";
local1 += "greenBallMarker = " + this.greenBallMarker + " ";
local1 += "parachuteInnerResource = " + this.parachuteInnerResource + " ";
local1 += "parachuteResource = " + this.parachuteResource + " ";
local1 += "redBallMarker = " + this.redBallMarker + " ";
local1 += "redGoalModel = " + this.redGoalModel + " ";
local1 += "sounds = " + this.sounds + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.item.present {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class UserPresentEvents implements UserPresent {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function UserPresentEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getText() : String {
var result:String = null;
var i:int = 0;
var m:UserPresent = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = UserPresent(this.impl[i]);
result = m.getText();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPresenterId() : Long {
var result:Long = null;
var i:int = 0;
var m:UserPresent = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = UserPresent(this.impl[i]);
result = m.getPresenterId();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getDate() : Date {
var result:Date = null;
var i:int = 0;
var m:UserPresent = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = UserPresent(this.impl[i]);
result = m.getDate();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.model.item.skins {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.garage.skins.IMountSkinItemModelBase;
import projects.tanks.client.garage.skins.MountSkinItemModelBase;
[ModelInfo]
public class MountSkinItemModel extends MountSkinItemModelBase implements IMountSkinItemModelBase, MountSkin {
public function MountSkinItemModel() {
super();
}
public function getMountedSkin() : IGameObject {
return getInitParam().item;
}
public function mount(param1:IGameObject) : void {
getInitParam().item = param1;
server.mountSkin(param1);
}
}
}
|
package alternativa.tanks.servermodels.partners {
import alternativa.osgi.service.launcherparams.ILauncherParams;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.IEntranceClientFacade;
import flash.events.Event;
import flash.external.ExternalInterface;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.type.IGameObject;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.entrance.model.entrance.partners.CompositePartnerModelBase;
import projects.tanks.client.entrance.model.entrance.partners.ICompositePartnerModelBase;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import services.alertservice.AlertAnswer;
[ModelInfo]
public class CompositePartnerModel extends CompositePartnerModelBase implements ICompositePartnerModelBase, ICompositePartnerModel, IParametersListener {
[Inject]
public static var clientFacade:IEntranceClientFacade;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var launcherParams:ILauncherParams;
public function CompositePartnerModel() {
super();
}
private static function navigateToFailRedirectUrl(param1:Event) : void {
navigateToURL(new URLRequest(partnerService.getFailRedirectUrl()),"_top");
}
public function loadPartnerObject(param1:String) : void {
server.loadPartnerObjectOnClient(param1);
}
public function finishRegistration(param1:String, param2:String) : void {
server.finishRegistration(param1,param2);
}
public function bindAccount(param1:String, param2:String) : void {
server.bindAccount(param1,param2);
}
public function startPartnerRegistration() : void {
clientFacade.startPartnerRegistration();
}
public function linkAlreadyExists() : void {
clientFacade.partnerLinkAlreadyExists();
}
public function wrongPassword() : void {
clientFacade.partnerWrongPassword();
}
public function showTutorial() : void {
if(!ExternalInterface.available || ExternalInterface.call("showTutorial") == null) {
navigateToFailRedirectUrl(null);
}
}
public function loginFailed() : void {
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,navigateToFailRedirectUrl);
alertService.showAlert(localeService.getText(TanksLocale.TEXT_PARTNER_PARAMETRS_ERROR),Vector.<String>([localeService.getText(AlertAnswer.OK)]));
}
public function setPartnerObject(param1:IGameObject) : void {
partnerService.setPartner(param1);
var local2:IPartner = IPartner(param1.adapt(IPartner));
local2.getLoginParameters(IParametersListener(object.adapt(IParametersListener)));
}
public function onSetParameters(param1:LoginParameters) : void {
server.loginViaPartner(partnerService.getEnvironmentPartnerId(),param1);
}
public function onFailSetParameters() : void {
alertService.showAlert("Login failed",Vector.<String>([localeService.getText(AlertAnswer.OK)]));
}
}
}
|
package forms.userlabel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.userlabel.ChatUserLabel_bronzeStatusIconClass.png")]
public class ChatUserLabel_bronzeStatusIconClass extends BitmapAsset {
public function ChatUserLabel_bronzeStatusIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.UpgradeIndicator_m2Class.png")]
public class UpgradeIndicator_m2Class extends BitmapAsset {
public function UpgradeIndicator_m2Class() {
super();
}
}
}
|
package alternativa.tanks.view.battleinfo {
import assets.icons.BattleInfoIcons;
import assets.icons.InputCheckIcon;
import controls.TankWindowInner;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.filters.GlowFilter;
import flash.geom.Rectangle;
import flash.text.TextFieldAutoSize;
import forms.ranks.SmallRankIcon;
import forms.registration.CallsignIconStates;
public class BattleInfoBaseView extends Sprite {
private static const MAX_HEIGHT:int = 500;
private static const ICON_VERTICAL_MARGIN:int = 6;
private static const RANG_ICON_HEIGHT:int = 16;
private static const RANG_ICON_WIDTH:int = 15;
private static const filter:Array = [new GlowFilter(0,1,6,6)];
private static const waitIcon:InputCheckIcon = new InputCheckIcon();
protected var iconBar:Sprite = new Sprite();
private var proOptionsBar:Sprite = new Sprite();
private var scoreLimitIcon:BattleInfoIcons = new BattleInfoIcons();
private var timeLimitIcon:BattleInfoIcons = new BattleInfoIcons();
private var suppliesIcon:BattleInfoIcons = new BattleInfoIcons();
private var bonusesIcon:BattleInfoIcons = new BattleInfoIcons();
private var upgradesIcon:BattleInfoIcons = new BattleInfoIcons();
private var reArmorIcon:BattleInfoIcons = new BattleInfoIcons();
private var dependentCooldown:BattleInfoIcons = new BattleInfoIcons();
private var scoreLimitLabel:LabelBase = new LabelBase();
private var timeLimitLabel:LabelBase = new LabelBase();
private var rangBar:Sprite = new Sprite();
private var bg:TankWindowInner = new TankWindowInner(100,100,TankWindowInner.TRANSPARENT);
private var nameLabel:LabelBase = new LabelBase();
private var preview:Sprite = new Sprite();
private var rect:Rectangle = new Rectangle(0,0,400,300);
private var _width:int;
private var _height:int;
public function BattleInfoBaseView() {
super();
addChild(this.preview);
addChild(this.bg);
addChild(this.nameLabel);
addChild(this.rangBar);
addChild(this.iconBar);
addChild(this.proOptionsBar);
this.scoreLimitIcon.type = BattleInfoIcons.KILL_LIMIT;
this.timeLimitIcon.type = BattleInfoIcons.TIME_LIMIT;
this.suppliesIcon.type = BattleInfoIcons.PAYD;
this.bonusesIcon.type = BattleInfoIcons.INVENTORY_BONUS;
this.dependentCooldown.type = BattleInfoIcons.DEPENDENT_COOLDOWN;
this.upgradesIcon.type = BattleInfoIcons.UPGRADES;
this.reArmorIcon.type = BattleInfoIcons.REARMOR;
this.nameLabel.size = 18;
this.nameLabel.height = 25;
this.nameLabel.thickness = 0;
this.nameLabel.autoSize = TextFieldAutoSize.NONE;
this.nameLabel.filters = filter;
this.iconBar.filters = filter;
this.proOptionsBar.filters = filter;
this.preview.scrollRect = this.rect;
}
public function setPreview(param1:BitmapData) : void {
if(this.preview.numChildren > 0) {
this.preview.removeChildAt(0);
}
if(param1 == null) {
this.preview.addChild(waitIcon);
waitIcon.gotoAndStop(CallsignIconStates.CALLSIGN_ICON_STATE_PROGRESS);
waitIcon.x = int(375 - waitIcon.width / 2);
waitIcon.y = int(250 - waitIcon.height / 2);
this.preview.scrollRect = this.rect;
} else {
this.preview.addChild(new Bitmap(param1));
this.preview.scrollRect = this.rect;
}
this.width = this._width;
this.height = this._height;
}
public function setCommonParams(param1:String, param2:int, param3:int, param4:int, param5:int) : void {
this.fillRangBar(param2,param3);
this.nameLabel.text = param1;
this.clearIconBar();
if(param5 > 0) {
this.fillLimeLimit(param5);
}
if(param4 > 0) {
this.fillScoreLimit(param4);
}
}
public function setProBattleParams(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean) : void {
this.clearOptionsBar();
this.addIcon(this.bonusesIcon,param3);
this.addIcon(this.reArmorIcon,param5);
this.addIcon(this.upgradesIcon,param4);
this.addIcon(this.suppliesIcon,param1);
if(param1) {
this.addIcon(this.dependentCooldown,param2);
}
}
private function addIcon(param1:MovieClip, param2:Boolean) : void {
if(this.proOptionsBar.numChildren > 0) {
param1.x = this.proOptionsBar.width + ICON_VERTICAL_MARGIN;
} else {
param1.x = 0;
}
param1.alpha = param2 ? 1 : 0.5;
this.proOptionsBar.addChild(param1);
}
private function clearOptionsBar() : void {
while(this.proOptionsBar.numChildren > 0) {
this.proOptionsBar.removeChildAt(0);
}
}
private function fillScoreLimit(param1:int) : void {
this.scoreLimitLabel.size = 14;
this.scoreLimitLabel.text = String(param1);
this.scoreLimitLabel.x = this.iconBar.numChildren > 0 ? this.iconBar.width + ICON_VERTICAL_MARGIN : 0;
this.iconBar.addChild(this.scoreLimitLabel);
this.scoreLimitIcon.x = this.iconBar.width + ICON_VERTICAL_MARGIN;
this.scoreLimitIcon.type = BattleInfoIcons.KILL_LIMIT;
this.iconBar.addChild(this.scoreLimitIcon);
}
private function fillLimeLimit(param1:int) : void {
this.timeLimitLabel.text = param1.toString();
this.timeLimitLabel.size = 14;
this.iconBar.addChild(this.timeLimitLabel);
this.timeLimitIcon.x = this.iconBar.width + ICON_VERTICAL_MARGIN;
this.iconBar.addChild(this.timeLimitIcon);
}
private function fillRangBar(param1:int, param2:int) : void {
var local6:SmallRankIcon = null;
while(this.rangBar.numChildren > 0) {
this.rangBar.removeChildAt(0);
}
if(param1 == 0 || param2 == 0) {
return;
}
var local3:int = 0;
var local4:int = 0;
var local5:int = param2;
while(local5 >= param1) {
local6 = new SmallRankIcon(local5);
local6.x = local3 * RANG_ICON_WIDTH;
local6.y = local4 * RANG_ICON_HEIGHT;
this.rangBar.addChild(local6);
local3--;
if(local3 < -15) {
local4--;
local3 = 0;
}
local5--;
}
}
private function clearIconBar() : void {
while(this.iconBar.numChildren > 0) {
this.iconBar.removeChildAt(0);
}
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.bg.width = this._width;
this.preview.x = 1;
this.rect.x = int(375 - this._width / 2);
this.rect.width = this._width - 2;
this.preview.scrollRect = this.rect;
this.rangBar.x = this._width - 23;
this.nameLabel.x = 10;
this.nameLabel.width = this._width - 20;
this.iconBar.x = 12;
this.proOptionsBar.x = 12;
}
override public function set height(param1:Number) : void {
this._height = Math.min(param1,MAX_HEIGHT);
this.bg.height = this._height;
this.preview.y = 1;
this.rect.y = int(250 - this._height / 2);
this.rect.height = this.bg.height - 2;
this.preview.scrollRect = this.rect;
this.rangBar.y = this.bg.height - 23;
this.nameLabel.y = 10;
this.iconBar.y = 40;
this.proOptionsBar.y = 70;
}
override public function get width() : Number {
return this._width;
}
override public function get height() : Number {
return this._height;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.armor.common {
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 HullCommonModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function HullCommonModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.panel.model.payment.panel {
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public class PaymentButtonCC {
private var _enabledFullPayment:Boolean;
private var _paymentUrl:PaymentRequestUrl;
public function PaymentButtonCC(param1:Boolean = false, param2:PaymentRequestUrl = null) {
super();
this._enabledFullPayment = param1;
this._paymentUrl = param2;
}
public function get enabledFullPayment() : Boolean {
return this._enabledFullPayment;
}
public function set enabledFullPayment(param1:Boolean) : void {
this._enabledFullPayment = param1;
}
public function get paymentUrl() : PaymentRequestUrl {
return this._paymentUrl;
}
public function set paymentUrl(param1:PaymentRequestUrl) : void {
this._paymentUrl = param1;
}
public function toString() : String {
var local1:String = "PaymentButtonCC [";
local1 += "enabledFullPayment = " + this.enabledFullPayment + " ";
local1 += "paymentUrl = " + this.paymentUrl + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.statistics {
import alternativa.tanks.models.battle.gui.gui.statistics.fps.FPSText;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.SettingEnum;
import alternativa.tanks.service.settings.SettingsServiceEvent;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.utils.removeDisplayObject;
import platform.client.fp10.core.type.AutoClosable;
public class FpsIndicatorToggleSupport implements AutoClosable {
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var battleGuiService:BattleGUIService;
private var fpsIndicator:FPSText;
public function FpsIndicatorToggleSupport(param1:FPSText) {
super();
this.fpsIndicator = param1;
settingsService.addEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.onSettingsAccepted);
}
private function onSettingsAccepted(param1:SettingsServiceEvent) : void {
if(param1.getSetting() != SettingEnum.SHOW_FPS) {
return;
}
if(settingsService.showFPS) {
battleGuiService.getGuiContainer().addChild(this.fpsIndicator);
} else {
removeDisplayObject(this.fpsIndicator);
}
}
[Obfuscation(rename="false")]
public function close() : void {
this.fpsIndicator = null;
settingsService.removeEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.onSettingsAccepted);
}
}
}
|
package projects.tanks.clients.flash.commons.services.payment.event {
import flash.events.Event;
public class PaymentDisplayServiceUnloadEvent extends Event {
public static const UNLOAD_PAYMENT:String = "PaymentDisplayServiceEventUNLOAD_PAYMENT";
public function PaymentDisplayServiceUnloadEvent() {
super(UNLOAD_PAYMENT);
}
}
}
|
package alternativa.tanks.model.item.rename {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.item.actionpanel.SingleActionPanel;
import alternativa.tanks.model.item.countable.ICountableItem;
import alternativa.tanks.model.item.info.ItemActionPanel;
import alternativa.tanks.service.garage.GarageService;
import flash.display.DisplayObjectContainer;
import flash.events.IEventDispatcher;
import flash.net.SharedObject;
import mx.utils.StringUtil;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.garage.prototypes.item.renameitem.IRenameModelBase;
import projects.tanks.client.garage.prototypes.item.renameitem.RenameModelBase;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
[ModelInfo]
public class RenameModel extends RenameModelBase implements IRenameModelBase, ItemActionPanel, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var garageService:GarageService;
private var renameForm:RenameForm;
public function RenameModel() {
super();
}
public function updateActionElements(param1:DisplayObjectContainer, param2:IEventDispatcher) : void {
SingleActionPanel(getData(SingleActionPanel)).updateActionElements(param1);
}
public function handleDoubleClickOnItemPreview() : void {
if(!this.renameForm) {
this.renameForm = new RenameForm(!partnerService.isRunningInsidePartnerEnvironment());
this.renameForm.addEventListener(RenameEvent.RENAME_EVENT,getFunctionWrapper(this.onRename));
}
this.renameForm.show();
}
private function onRename(param1:RenameEvent) : void {
server.rename(param1.getNickname());
this.renameForm.close();
}
public function objectLoaded() : void {
var local1:SingleActionPanel = new SingleActionPanel(localeService.getText(TanksLocale.TEXT_RENAME_BUTTON_LABEL_IN_GARAGE),getFunctionWrapper(this.handleDoubleClickOnItemPreview));
putData(SingleActionPanel,local1);
}
public function objectUnloaded() : void {
if(Boolean(this.renameForm)) {
this.renameForm.removeEventListener(RenameEvent.RENAME_EVENT,getFunctionWrapper(this.onRename));
this.renameForm.dispose();
this.renameForm = null;
}
}
public function renameFail() : void {
alertService.showOkAlert(localeService.getText(TanksLocale.TEXT_RENAME_FAILED_ALERT));
}
public function renameSuccessfull(param1:String, param2:String) : void {
this.renameInCommonShared(param1,param2);
this.renameInAccountShared(param1,param2);
if(ICountableItem(object.adapt(ICountableItem)).getCount() <= 1) {
garageService.getView().removeItemFromDepot(object);
}
}
private function renameInCommonShared(param1:String, param2:String) : void {
var local3:SharedObject = storageService.getStorage();
var local4:String = StringUtil.trim(local3.data.userName);
if(local4.length != 0 && local4 == param1) {
local3.data.userName = param2;
local3.flush();
}
}
private function renameInAccountShared(param1:String, param2:String) : void {
var local3:SharedObject = storageService.getAccountsStorage();
var local4:Object = local3.data[param1];
if(Boolean(local4)) {
local3.data[param2] = local3.data[param1];
local3.data[param2].userName = param2;
delete local3.data[param1];
local3.flush();
}
}
}
}
|
package platform.client.fp10.core.resource.types {
import platform.client.fp10.core.resource.ILockableResource;
import platform.client.fp10.core.resource.IResourceLoadingListener;
import platform.client.fp10.core.resource.Resource;
import platform.client.fp10.core.resource.ResourceInfo;
public class SWFLibraryResource extends Resource implements ILockableResource {
public function SWFLibraryResource(param1:ResourceInfo) {
super(param1);
}
override public function get description() : String {
return "Library";
}
override public function load(param1:String, param2:IResourceLoadingListener) : void {
super.load(param1,param2);
completeLoading();
}
public function unlockResourceLoading() : void {
completeLoading();
}
}
}
|
package alternativa.tanks.models.weapon.gauss {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.StateCorrectionEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.tankskin.turret.CustomTurretSkin;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretSkin;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.ultimate.hunter.stun.UltimateStunListener;
import alternativa.tanks.models.weapon.IWeaponModel;
import alternativa.tanks.models.weapon.WeaponConst;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponBuffListener;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shared.shot.WeaponReloadTimeChangedListener;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import alternativa.tanks.models.weapons.targeting.direction.sector.SectorDirectionCalculator;
import alternativa.tanks.models.weapons.targeting.priority.TargetingPriorityCalculator;
import alternativa.tanks.models.weapons.targeting.priority.targeting.CommonTargetPriorityCalculator;
import alternativa.tanks.models.weapons.targeting.processor.PrecisionTargetingParams;
import alternativa.tanks.models.weapons.targeting.processor.SingleTargetPrecisionDirectionProcessor;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.GaussCC;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.GaussModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.IGaussModelBase;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
[ModelInfo]
public class GaussModel extends GaussModelBase implements IGaussModelBase, IWeaponModel, GaussSkin, ObjectLoadListener, CustomTurretSkin, WeaponBuffListener, WeaponReloadTimeChangedListener, UltimateStunListener, GaussWeaponCallback {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private static const MAX_DISTANCE:Number = 1000000;
private static const PRECISION_PARAMS:PrecisionTargetingParams = new PrecisionTargetingParams(5,15);
private var globalHitPoint:Vector3 = new Vector3();
private var localUser:IGameObject;
public function GaussModel() {
super();
}
public function objectLoaded() : void {
var local1:GaussCC = getInitParam();
local1.primaryShellRadius = BattleUtils.toClientScale(local1.primaryShellRadius);
local1.primaryShellSpeed = BattleUtils.toClientScale(local1.primaryShellSpeed);
local1.shotRange = BattleUtils.toClientScale(local1.shotRange);
local1.aimedShotKickback *= WeaponConst.BASE_IMPACT_FORCE.getNumber();
local1.aimedShotImpact *= WeaponConst.BASE_IMPACT_FORCE.getNumber();
}
public function dummyShot() : void {
this.remoteWeapon().dummyShot();
}
public function primaryShot(param1:int, param2:Vector3d) : void {
this.remoteWeapon().primaryShot(param1,BattleUtils.getVector3(param2));
}
public function secondaryHitTargetCommand(param1:IGameObject, param2:Vector3d) : void {
this.remoteWeapon().secondaryHitTargetCommand(param1,BattleUtils.getVector3(param2));
}
private function remoteWeapon() : RemoteGaussWeapon {
return RemoteGaussWeapon(getData(RemoteGaussWeapon));
}
private function localWeapon() : LocalGaussWeapon {
return LocalGaussWeapon(getData(LocalGaussWeapon));
}
public function createLocalWeapon(param1:IGameObject) : Weapon {
this.localUser = param1;
var local2:WeaponObject = new WeaponObject(object);
var local3:LocalGaussWeapon = new LocalGaussWeapon(local2,getInitParam(),this.createTargetingSystem(local2,param1),this.getWeaponForces());
putData(LocalGaussWeapon,local3);
return local3;
}
private function createTargetingSystem(param1:WeaponObject, param2:IGameObject) : TargetingSystem {
var local3:TargetingPriorityCalculator = new TargetingPriorityCalculator(new CommonTargetPriorityCalculator(param1));
var local4:SectorDirectionCalculator = new SectorDirectionCalculator(param2,param1,MAX_DISTANCE,local3);
var local5:SingleTargetPrecisionDirectionProcessor = new SingleTargetPrecisionDirectionProcessor(param2,MAX_DISTANCE,PRECISION_PARAMS);
var local6:TargetingSystem = new TargetingSystem(local4,local5,local3);
local6.getProcessor().setShotFromMuzzle();
return local6;
}
private function getWeaponForces() : WeaponForces {
var local1:WeaponCommonData = this.getWeaponCommon().getCommonData();
return new WeaponForces(local1.getImpactForce(),local1.getRecoilForce());
}
public function createRemoteWeapon(param1:IGameObject) : Weapon {
var local2:WeaponObject = new WeaponObject(object);
local2.markAsRemote();
var local3:RemoteGaussWeapon = new RemoteGaussWeapon(local2,getInitParam(),this.getWeaponForces());
putData(RemoteGaussWeapon,local3);
return local3;
}
public function startAiming() : void {
this.remoteWeapon().startAiming();
}
public function stopAiming() : void {
this.remoteWeapon().stopAiming();
}
private function getWeaponCommon() : IWeaponCommonModel {
return IWeaponCommonModel(object.adapt(IWeaponCommonModel));
}
public function doPrimaryShot(param1:int, param2:Vector3) : void {
battleEventDispatcher.dispatchEvent(StateCorrectionEvent.MANDATORY_UPDATE);
server.primaryShotCommand(this.getTime(),param1,param2.toVector3d());
}
public function doSecondaryShot(param1:IGameObject, param2:Vector3, param3:Vector3) : void {
battleEventDispatcher.dispatchEvent(StateCorrectionEvent.MANDATORY_UPDATE);
var local4:ITankModel = ITankModel(param1.adapt(ITankModel));
var local5:Tank = local4.getTank();
this.globalHitPoint.copy(param3);
BattleUtils.localToGlobal(local5.getBody(),this.globalHitPoint);
server.secondaryHitTargetCommand(this.getTime(),param1,param2.toVector3d(),param3.toVector3d(),this.globalHitPoint.toVector3d());
}
public function doDummyShot() : void {
server.dummyShotCommand(this.getTime());
}
public function doStartAiming() : void {
server.startAiming(this.getTime());
}
public function doStopAiming() : void {
server.stopAiming(this.getTime());
}
public function doPrimaryHitStatic(param1:int, param2:Vector3) : void {
server.primaryHitStaticCommand(this.getTime(),param1,param2.toVector3d());
}
public function doPrimaryHitTarget(param1:int, param2:IGameObject, param3:Vector3, param4:Vector3) : void {
server.primaryHitTargetCommand(this.getTime(),param1,param2,param3.toVector3d(),param4.toVector3d());
}
private function getTime() : int {
return battleService.getPhysicsTime();
}
public function createSkin(param1:Tanks3DSResource) : TurretSkin {
var local2:GaussTurretSkin = new GaussTurretSkin(param1);
putData(GaussTurretSkin,local2);
return local2;
}
public function getSkin() : GaussTurretSkin {
return GaussTurretSkin(getData(GaussTurretSkin));
}
private function isLocal(param1:IGameObject) : Boolean {
return this.localUser == param1;
}
public function weaponBuffStateChanged(param1:IGameObject, param2:Boolean, param3:Number) : void {
var local4:CommonGaussWeapon = null;
if(this.isLocal(param1)) {
local4 = this.localWeapon();
LocalGaussWeapon(local4).setBuffedMode(param2);
if(!param2) {
Weapon(local4).fullyRecharge();
}
} else {
local4 = this.remoteWeapon();
}
local4.updateRecoilForce(param3);
}
public function onStun(param1:Tank, param2:Boolean) : void {
if(param2) {
this.localWeapon().stun();
}
}
public function onCalm(param1:Tank, param2:Boolean, param3:int) : void {
if(param2) {
this.localWeapon().calm(param3);
}
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
var local3:LocalGaussWeapon = this.localWeapon();
if(local3 != null) {
local3.weaponReloadTimeChanged(param1,param2);
}
}
}
}
|
package controls.chat
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChatPermissionsLevel_sponsor extends BitmapAsset
{
public function ChatPermissionsLevel_sponsor()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft {
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.camera.GameCamera;
public class ShaftDeactivationTask implements Renderer {
private static const FOV_SPEED:Number = 5 * 0.001;
private static const ALPHA_SPEED:Number = 5 * 0.001;
private static const DEFAULT_TARGET_FOV:Number = Math.PI / 2;
private var battleScene3D:BattleScene3D;
private var skin:TankSkin;
private var targetFov:Number;
private var isRunning:Boolean;
public function ShaftDeactivationTask(param1:BattleScene3D) {
super();
this.battleScene3D = param1;
this.targetFov = DEFAULT_TARGET_FOV;
}
public function setSkin(param1:TankSkin) : void {
this.skin = param1;
}
public function setTargetFov(param1:Number) : void {
this.targetFov = param1;
}
public function start() : void {
if(!this.isRunning) {
this.isRunning = true;
this.battleScene3D.addRenderer(this);
}
}
public function stop() : void {
if(this.isRunning) {
this.isRunning = false;
this.battleScene3D.removeRenderer(this);
}
}
public function render(param1:int, param2:int) : void {
var local3:GameCamera = this.battleScene3D.getCamera();
local3.fov += FOV_SPEED * param2;
if(local3.fov > this.targetFov) {
local3.fov = this.targetFov;
}
var local4:Number = this.skin.getHullAlpha();
local4 += ALPHA_SPEED * param2;
if(local4 > 1) {
local4 = 1;
}
this.skin.setAlpha(local4);
if(local3.fov == this.targetFov && local4 == 1) {
this.stop();
}
}
}
}
|
package alternativa.tanks.battle
{
public interface DeferredAction
{
function execute() : void;
}
}
|
package alternativa.tanks.view.battleinfo {
import alternativa.tanks.view.battleinfo.renderer.BattleInfoUserListRenderer;
import alternativa.types.Long;
import fl.controls.List;
import fl.data.DataProvider;
import forms.Styles;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
import utils.ScrollStyleUtils;
public class BattleInfoUserList extends List {
public var usersCount:int;
public function BattleInfoUserList() {
super();
rowHeight = 20;
setStyle(Styles.CELL_RENDERER,BattleInfoUserListRenderer);
focusEnabled = false;
ScrollStyleUtils.setGreenStyle(this);
}
public function update(param1:int, param2:Vector.<BattleInfoUser>) : void {
var local3:BattleInfoUser = null;
var local4:int = 0;
var local5:int = 0;
dataProvider = new DataProvider();
this.usersCount = param2.length;
for each(local3 in param2) {
this.addUserSlot(local3);
}
this.sortUsersByScore();
local4 = param1 - this.usersCount;
local5 = 0;
while(local5 < local4) {
this.addEmptySlot();
local5++;
}
}
public function addUser(param1:BattleInfoUser) : void {
this.addUserSlot(param1,this.getFreeIndex());
++this.usersCount;
}
public function removeUser(param1:Long) : void {
var local2:int = this.getIndexById(param1);
dataProvider.removeItemAt(local2);
this.addEmptySlot();
--this.usersCount;
}
public function updateUserScore(param1:Long, param2:int) : void {
this.getUserById(param1).score = String(param2);
this.sortUsersByScore();
}
public function updateUserSuspiciousState(param1:Long, param2:Boolean) : void {
this.getUserById(param1).suspicious = param2;
}
public function getTeamClanId() : Long {
if(dataProvider.length > 0) {
return dataProvider.getItemAt(0).clanId;
}
return null;
}
private function sortUsersByScore() : void {
dataProvider.sortOn(["score"],[Array.DESCENDING | Array.NUMERIC]);
}
private function addUserSlot(param1:BattleInfoUser, param2:int = -1) : void {
var local3:Object = {};
local3.id = param1.user;
local3.suspicious = param1.suspicious;
local3.score = param1.score;
local3.clanId = param1.clanId;
if(param2 > -1) {
dataProvider.replaceItemAt(local3,param2);
} else {
dataProvider.addItem(local3);
}
}
private function addEmptySlot() : void {
var local1:Object = {};
local1.score = -1;
local1.id = null;
dataProvider.addItem(local1);
}
private function getIndexById(param1:Long) : int {
var local2:Object = null;
var local3:int = 0;
while(local3 < dataProvider.length) {
local2 = dataProvider.getItemAt(local3);
if(local2.id == param1) {
return local3;
}
local3++;
}
return -1;
}
private function getUserById(param1:Long) : Object {
var local2:Object = null;
var local3:int = 0;
while(local3 < dataProvider.length) {
local2 = dataProvider.getItemAt(local3);
if(local2.id == param1) {
return local2;
}
local3++;
}
return null;
}
private function getFreeIndex() : uint {
return this.usersCount;
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_additionalMinesClass.png")]
public class ItemInfoPanelBitmaps_additionalMinesClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_additionalMinesClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.profile.userproperties {
import projects.tanks.client.users.model.userbattlestatistics.rank.RankBounds;
public interface IUserPropertiesModelBase {
function changeCrystal(param1:int) : void;
function onJoinClan() : void;
function onLeaveClan() : void;
function updateGearScore(param1:int) : void;
function updateRank(param1:int, param2:int, param3:RankBounds, param4:int, param5:Boolean, param6:Boolean) : void;
function updateScore(param1:int) : void;
function updateUid(param1:String) : void;
function updateUserRating(param1:int) : void;
}
}
|
package platform.client.core.general.spaces.loading.dispatcher {
import platform.client.core.general.spaces.loading.dispatcher.types.ObjectsData;
import platform.client.core.general.spaces.loading.dispatcher.types.ObjectsDependencies;
import platform.client.fp10.core.type.IGameObject;
public interface IDispatcherModelBase {
function loadDependencies(param1:ObjectsDependencies) : void;
function loadObjectsData(param1:ObjectsData) : void;
function unloadObjects(param1:Vector.<IGameObject>) : void;
}
}
|
package forms.contextmenu {
import controls.base.LabelBase;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.filters.GlowFilter;
import flash.text.TextFieldAutoSize;
import forms.ColorConstants;
public class ContextMenuLabel extends Sprite {
private var glowFilter:GlowFilter = new GlowFilter(5898034,0.9,4,4,0);
private var fltrs:Array = [this.glowFilter];
protected var _label:LabelBase;
private var _locked:Boolean;
public function ContextMenuLabel() {
super();
this.init();
}
protected function init() : void {
this.tabChildren = false;
this.tabEnabled = false;
this._label = new LabelBase();
this._label.mouseEnabled = false;
this._label.autoSize = TextFieldAutoSize.LEFT;
addChild(this._label);
buttonMode = useHandCursor = true;
this.locked = false;
}
private function setEvents() : void {
if(!hasEventListener(MouseEvent.MOUSE_OVER)) {
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
}
if(!hasEventListener(MouseEvent.MOUSE_OUT)) {
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
}
private function removeEvents() : void {
if(hasEventListener(MouseEvent.MOUSE_OVER)) {
removeEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
}
if(hasEventListener(MouseEvent.MOUSE_OUT)) {
removeEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
}
public function destroy() : void {
this.removeEvents();
if(this._label != null && this.contains(this._label)) {
removeChild(this._label);
}
this._label = null;
}
private function onMouseOver(param1:MouseEvent) : void {
this.glowFilter.strength = 1;
filters = this.fltrs;
}
private function onMouseOut(param1:MouseEvent = null) : void {
this.glowFilter.strength = 0;
filters = this.fltrs;
}
public function set text(param1:String) : void {
this._label.text = param1;
}
public function get locked() : Boolean {
return this._locked;
}
public function set locked(param1:Boolean) : void {
this._locked = param1;
if(this._locked) {
this.removeEvents();
this.onMouseOut();
} else {
this.setEvents();
}
mouseChildren = mouseEnabled = !this._locked;
this._label.color = this._locked ? ColorConstants.ACCESS_LABEL : ColorConstants.CHAT_LABEL;
}
}
}
|
package projects.tanks.client.partners.impl.miniclip {
public interface IMiniclipLoginModelBase {
}
}
|
package alternativa.tanks.utils {
public interface EncryptedInt {
function setInt(param1:int) : void;
function getInt() : int;
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_autoBalanceClass.png")]
public class BattleParamsCheckButtonIcons_autoBalanceClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_autoBalanceClass() {
super();
}
}
}
|
package alternativa.tanks.gui.chat {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.chat.CautionExternalLinkWindow_bitmapDataClass.jpg")]
public class CautionExternalLinkWindow_bitmapDataClass extends BitmapAsset {
public function CautionExternalLinkWindow_bitmapDataClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.artillery {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ArtilleryVariantAdapt implements ArtilleryVariant {
private var object:IGameObject;
private var impl:ArtilleryVariant;
public function ArtilleryVariantAdapt(param1:IGameObject, param2:ArtilleryVariant) {
super();
this.object = param1;
this.impl = param2;
}
public function initArtilleryVariant(param1:IGameObject, param2:ArtilleryWeapon, param3:Boolean) : void {
var user:IGameObject = param1;
var weapon:ArtilleryWeapon = param2;
var isLocal:Boolean = param3;
try {
Model.object = this.object;
this.impl.initArtilleryVariant(user,weapon,isLocal);
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.garage.models.item.videoads {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class VideoAdsItemUpgradeModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _showedId:Long = Long.getLong(155542307,-704141979);
private var _showed_itemCodec:ICodec;
private var model:IModel;
public function VideoAdsItemUpgradeModelServer(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._showed_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
public function showed(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._showed_itemCodec.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._showedId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers {
public class AndroidSpecialOfferModelCC {
private var _oldPrice:Number;
private var _price:Number;
private var _saleInPercent:int;
private var _timeLeftInSec:int;
private var _timeLimited:Boolean;
public function AndroidSpecialOfferModelCC(param1:Number = 0, param2:Number = 0, param3:int = 0, param4:int = 0, param5:Boolean = false) {
super();
this._oldPrice = param1;
this._price = param2;
this._saleInPercent = param3;
this._timeLeftInSec = param4;
this._timeLimited = param5;
}
public function get oldPrice() : Number {
return this._oldPrice;
}
public function set oldPrice(param1:Number) : void {
this._oldPrice = param1;
}
public function get price() : Number {
return this._price;
}
public function set price(param1:Number) : void {
this._price = param1;
}
public function get saleInPercent() : int {
return this._saleInPercent;
}
public function set saleInPercent(param1:int) : void {
this._saleInPercent = param1;
}
public function get timeLeftInSec() : int {
return this._timeLeftInSec;
}
public function set timeLeftInSec(param1:int) : void {
this._timeLeftInSec = param1;
}
public function get timeLimited() : Boolean {
return this._timeLimited;
}
public function set timeLimited(param1:Boolean) : void {
this._timeLimited = param1;
}
public function toString() : String {
var local1:String = "AndroidSpecialOfferModelCC [";
local1 += "oldPrice = " + this.oldPrice + " ";
local1 += "price = " + this.price + " ";
local1 += "saleInPercent = " + this.saleInPercent + " ";
local1 += "timeLeftInSec = " + this.timeLeftInSec + " ";
local1 += "timeLimited = " + this.timeLimited + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_armorBoostClass.png")]
public class ItemInfoPanelBitmaps_armorBoostClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_armorBoostClass() {
super();
}
}
}
|
package alternativa.debug
{
import alternativa.init.*;
import alternativa.osgi.service.locale.*;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.filters.BitmapFilterQuality;
import flash.filters.DropShadowFilter;
import flash.geom.Point;
import flash.text.*;
public class ServerMessageWindow extends Sprite
{
private var message:TextField;
private var buttonOk:Sprite;
private var buttonText:TextField;
private var _currentSize:Point;
public function ServerMessageWindow()
{
var lang1:* = undefined;
super();
mouseEnabled = false;
tabEnabled = false;
this.message = new TextField();
this.message.thickness = 50;
this.message.sharpness = -50;
with(this.message)
{
width = 250;
y = 25;
defaultTextFormat = new TextFormat("Tahoma",11,0);
type = TextFieldType.DYNAMIC;
autoSize = TextFieldAutoSize.CENTER;
antiAliasType = AntiAliasType.ADVANCED;
embedFonts = false;
selectable = true;
multiline = true;
wordWrap = true;
}
addChild(this.message);
this.buttonOk = new Sprite();
this.buttonOk.graphics.beginFill(16777215,1);
this.buttonOk.graphics.lineStyle(1,6710886);
this.buttonOk.graphics.drawRoundRect(0,0,60,30,5,5);
addChild(this.buttonOk);
this.buttonOk.addEventListener(MouseEvent.CLICK,this.onOkButtonClick);
this.buttonText = new TextField();
this.buttonText.thickness = 50;
this.buttonText.sharpness = -50;
with(this.buttonText)
{
defaultTextFormat = new TextFormat("Tahoma",12,0,true);
type = TextFieldType.DYNAMIC;
autoSize = TextFieldAutoSize.NONE;
antiAliasType = AntiAliasType.ADVANCED;
embedFonts = false;
selectable = true;
multiline = false;
mouseEnabled = false;
tabEnabled = false;
lang1 = ILocaleService(Main.osgi.getService(ILocaleService)).language;
if(lang1 != null && lang1.toLocaleLowerCase() == "cn")
{
text = "чбошод";
}
else
{
text = "OK";
}
}
addChild(this.buttonText);
this._currentSize = new Point(300,200);
this.filters = [new DropShadowFilter(3,70,0,0.5,2,2,1,BitmapFilterQuality.MEDIUM,false,false,false)];
this.repaint();
}
public function set text(value:String) : void
{
this.message.text = value;
this._currentSize.x = Math.max(Math.round(this.message.length * 0.5),300);
this.message.width = this._currentSize.x - 50;
this.message.x = Math.round((this._currentSize.x - this.message.textWidth) * 0.5);
this.repaint();
}
public function get currentSize() : Point
{
return this._currentSize;
}
private function repaint() : void
{
this._currentSize.y = 25 + this.message.textHeight + 30 + this.buttonOk.height;
this.graphics.clear();
this.graphics.beginFill(13421772,1);
this.graphics.drawRoundRect(0,0,this._currentSize.x,this._currentSize.y,5,5);
this.buttonOk.x = Math.round((this._currentSize.x - this.buttonOk.width) * 0.5);
this.buttonOk.y = Math.round(this._currentSize.y - 15 - this.buttonOk.height);
this.buttonText.x = Math.round(this.buttonOk.x + (this.buttonOk.width - this.buttonText.textWidth) * 0.5 - 2);
this.buttonText.y = Math.round(this.buttonOk.y + (this.buttonOk.height - (this.buttonText.textHeight - 3)) * 0.5 - 3);
}
private function onOkButtonClick(e:MouseEvent) : void
{
Main.debug.hideServerMessageWindow();
}
}
}
|
package alternativa.utils
{
import flash.display.Sprite;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.utils.Dictionary;
public class DebugPanel extends Sprite
{
private var values:Dictionary;
private var count:int;
public function DebugPanel()
{
super();
this.values = new Dictionary();
mouseEnabled = false;
tabEnabled = false;
mouseChildren = false;
tabChildren = false;
}
public function printValue(valueName:String, ... args) : void
{
var textField:TextField = this.values[valueName];
if(textField == null)
{
textField = this.createTextField();
this.values[valueName] = textField;
}
textField.text = valueName + ": " + args.join(" ");
}
public function printText(text:String) : void
{
this.createTextField().text = text;
}
private function createTextField() : TextField
{
var textField:TextField = null;
textField = new TextField();
textField.autoSize = TextFieldAutoSize.LEFT;
addChild(textField);
textField.defaultTextFormat = new TextFormat("Tahoma",11,16777215);
textField.y = this.count * 20;
++this.count;
return textField;
}
}
}
|
package alternativa.tanks.servermodels {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ILeavableEntranceStateAdapt implements ILeavableEntranceState {
private var object:IGameObject;
private var impl:ILeavableEntranceState;
public function ILeavableEntranceStateAdapt(param1:IGameObject, param2:ILeavableEntranceState) {
super();
this.object = param1;
this.impl = param2;
}
public function leave() : void {
try {
Model.object = this.object;
this.impl.leave();
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.entrance.model.entrance.registration {
public interface IRegistrationModelBase {
function anchorRegistration() : void;
function enteredUidIsBusy(param1:Vector.<String>) : void;
function enteredUidIsFree() : void;
function enteredUidIsIncorrect() : void;
function passwordIsIncorrect() : void;
function registrationFailed() : void;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.shell {
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.Byte;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.TargetPosition;
import projects.tanks.client.battlefield.types.Vector3d;
public class ShellWeaponCommunicationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _tryToDummyShootId:Long = Long.getLong(1416574450,1036034301);
private var _tryToDummyShoot_clientTimeCodec:ICodec;
private var _tryToDummyShoot_barrelIndexCodec:ICodec;
private var _tryToHitId:Long = Long.getLong(1345782104,505677395);
private var _tryToHit_clientTimeCodec:ICodec;
private var _tryToHit_shellHitCodec:ICodec;
private var _tryToShootId:Long = Long.getLong(511445961,614544455);
private var _tryToShoot_clientTimeCodec:ICodec;
private var _tryToShoot_barrelIndexCodec:ICodec;
private var _tryToShoot_shotIdCodec:ICodec;
private var _tryToShoot_directionCodec:ICodec;
private var _tryToShootWithTargetId:Long = Long.getLong(1961620998,1436748144);
private var _tryToShootWithTarget_clientTimeCodec:ICodec;
private var _tryToShootWithTarget_barrelIndexCodec:ICodec;
private var _tryToShootWithTarget_shotIdCodec:ICodec;
private var _tryToShootWithTarget_directionCodec:ICodec;
private var _tryToShootWithTarget_targetCodec:ICodec;
private var _tryToShootWithTarget_localTargetPointCodec:ICodec;
private var model:IModel;
public function ShellWeaponCommunicationModelServer(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._tryToDummyShoot_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tryToDummyShoot_barrelIndexCodec = this.protocol.getCodec(new TypeCodecInfo(Byte,false));
this._tryToHit_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tryToHit_shellHitCodec = this.protocol.getCodec(new TypeCodecInfo(ShellHit,false));
this._tryToShoot_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tryToShoot_barrelIndexCodec = this.protocol.getCodec(new TypeCodecInfo(Byte,false));
this._tryToShoot_shotIdCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tryToShoot_directionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._tryToShootWithTarget_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tryToShootWithTarget_barrelIndexCodec = this.protocol.getCodec(new TypeCodecInfo(Byte,false));
this._tryToShootWithTarget_shotIdCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tryToShootWithTarget_directionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._tryToShootWithTarget_targetCodec = this.protocol.getCodec(new TypeCodecInfo(TargetPosition,false));
this._tryToShootWithTarget_localTargetPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
}
public function tryToDummyShoot(param1:int, param2:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._tryToDummyShoot_clientTimeCodec.encode(this.protocolBuffer,param1);
this._tryToDummyShoot_barrelIndexCodec.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._tryToDummyShootId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function tryToHit(param1:int, param2:ShellHit) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._tryToHit_clientTimeCodec.encode(this.protocolBuffer,param1);
this._tryToHit_shellHitCodec.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._tryToHitId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function tryToShoot(param1:int, param2:int, param3:int, param4:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._tryToShoot_clientTimeCodec.encode(this.protocolBuffer,param1);
this._tryToShoot_barrelIndexCodec.encode(this.protocolBuffer,param2);
this._tryToShoot_shotIdCodec.encode(this.protocolBuffer,param3);
this._tryToShoot_directionCodec.encode(this.protocolBuffer,param4);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local5:SpaceCommand = new SpaceCommand(Model.object.id,this._tryToShootId,this.protocolBuffer);
var local6:IGameObject = Model.object;
var local7:ISpace = local6.space;
local7.commandSender.sendCommand(local5);
this.protocolBuffer.optionalMap.clear();
}
public function tryToShootWithTarget(param1:int, param2:int, param3:int, param4:Vector3d, param5:TargetPosition, param6:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._tryToShootWithTarget_clientTimeCodec.encode(this.protocolBuffer,param1);
this._tryToShootWithTarget_barrelIndexCodec.encode(this.protocolBuffer,param2);
this._tryToShootWithTarget_shotIdCodec.encode(this.protocolBuffer,param3);
this._tryToShootWithTarget_directionCodec.encode(this.protocolBuffer,param4);
this._tryToShootWithTarget_targetCodec.encode(this.protocolBuffer,param5);
this._tryToShootWithTarget_localTargetPointCodec.encode(this.protocolBuffer,param6);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local7:SpaceCommand = new SpaceCommand(Model.object.id,this._tryToShootWithTargetId,this.protocolBuffer);
var local8:IGameObject = Model.object;
var local9:ISpace = local8.space;
local9.commandSender.sendCommand(local7);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.panel.model.premiumaccount.alert {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class PremiumAccountAlertModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PremiumAccountAlertModelServer;
private var client:IPremiumAccountAlertModelBase = IPremiumAccountAlertModelBase(this);
private var modelId:Long = Long.getLong(287111968,-1381886380);
private var _showWelcomeAlertId:Long = Long.getLong(167154466,288991176);
private var _showWelcomeAlert_wasShowAlertForFirstPurchasePremiumCodec:ICodec;
public function PremiumAccountAlertModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PremiumAccountAlertModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(PremiumAccountAlertCC,false)));
this._showWelcomeAlert_wasShowAlertForFirstPurchasePremiumCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
protected function getInitParam() : PremiumAccountAlertCC {
return PremiumAccountAlertCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._showWelcomeAlertId:
this.client.showWelcomeAlert(Boolean(this._showWelcomeAlert_wasShowAlertForFirstPurchasePremiumCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.shot {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class DiscreteShotModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:DiscreteShotModelServer;
private var client:IDiscreteShotModelBase = IDiscreteShotModelBase(this);
private var modelId:Long = Long.getLong(968114218,-1703577718);
private var _reconfigureWeaponId:Long = Long.getLong(1553277326,-178268452);
private var _reconfigureWeapon_reloadTimeCodec:ICodec;
public function DiscreteShotModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new DiscreteShotModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShotCC,false)));
this._reconfigureWeapon_reloadTimeCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
protected function getInitParam() : ShotCC {
return ShotCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._reconfigureWeaponId:
this.client.reconfigureWeapon(int(this._reconfigureWeapon_reloadTimeCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.controlpoints.hud.marker {
import flash.display.BitmapData;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.Dictionary;
import projects.tanks.client.battlefield.models.battle.cp.ControlPointState;
public class MarkerBitmaps {
private static const blueMarkerClass:Class = MarkerBitmaps_blueMarkerClass;
private static const blueMarkerBitmapData:BitmapData = new blueMarkerClass().bitmapData;
private static const grayMarkerClass:Class = MarkerBitmaps_grayMarkerClass;
private static const grayMarkerBitmapData:BitmapData = new grayMarkerClass().bitmapData;
private static const redMarkerClass:Class = MarkerBitmaps_redMarkerClass;
private static const redMarkerBitmapData:BitmapData = new redMarkerClass().bitmapData;
private static const letters:Class = MarkerBitmaps_letters;
private static const markerBitmaps:Dictionary = new Dictionary();
private static const markerWidth:int = redMarkerBitmapData.width;
private static const letterBar:BitmapData = new letters().bitmapData;
private static const letterBitmaps:Dictionary = new Dictionary();
markerBitmaps[ControlPointState.NEUTRAL] = grayMarkerBitmapData;
markerBitmaps[ControlPointState.BLUE] = blueMarkerBitmapData;
markerBitmaps[ControlPointState.RED] = redMarkerBitmapData;
public function MarkerBitmaps() {
super();
}
public static function getMarkerBitmapData(param1:ControlPointState) : BitmapData {
return markerBitmaps[param1];
}
public static function getLetterImage(param1:String) : BitmapData {
var local2:Number = param1.charCodeAt(0) - "A".charCodeAt(0);
var local3:BitmapData = letterBitmaps[local2];
if(local3 == null) {
local3 = new BitmapData(markerWidth,letterBar.height,true,0);
local3.copyPixels(letterBar,new Rectangle(local2 * markerWidth,0,markerWidth,letterBar.height),new Point());
letterBitmaps[local2] = local3;
}
return local3;
}
}
}
|
package projects.tanks.client.users.model.referrerbonus {
public interface IRankUpReferrerAwardModelBase {
}
}
|
package alternativa.tanks.loader.stylishdishonestprogressbar {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.loader.stylishdishonestprogressbar.StylishDishonestProgressBar_rightGlowClass.png")]
public class StylishDishonestProgressBar_rightGlowClass extends BitmapAsset {
public function StylishDishonestProgressBar_rightGlowClass() {
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.