code stringlengths 57 237k |
|---|
package controls.resultassets
{
import assets.resultwindow.bres_HEADER_RED_PIXEL;
import assets.resultwindow.bres_HEADER_RED_TL;
import controls.statassets.StatLineBase;
public class ResultWindowRedHeader extends StatLineBase
{
public function ResultWindowRedHeader()
{
super();
tl = new bres_HEADER_RED_TL(1,1);
px = new bres_HEADER_RED_PIXEL(1,1);
}
}
}
|
package alternativa.tanks.models.weapon.shared {
import alternativa.math.Vector3;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.models.sfx.colortransform.ColorTransformEntry;
import flash.geom.ColorTransform;
public class StreamWeaponParticle extends AnimatedSprite3D {
private static var INITIAL_POOL_SIZE:int = 20;
private static var pool:Vector.<StreamWeaponParticle> = new Vector.<StreamWeaponParticle>(INITIAL_POOL_SIZE);
private static var poolIndex:int = -1;
public var velocity:Vector3 = new Vector3();
public var particleDistance:Number = 0;
public var currFrame:Number;
public var rotationDirection:int;
private var animated:Boolean;
public function StreamWeaponParticle(param1:Boolean) {
super(100,100);
softAttenuation = 130;
colorTransform = new ColorTransform();
this.animated = param1;
}
public static function getParticle(param1:Boolean) : StreamWeaponParticle {
if(poolIndex == -1) {
return new StreamWeaponParticle(param1);
}
var local2:StreamWeaponParticle = pool[poolIndex];
local2.animated = param1;
var local3:* = poolIndex--;
pool[local3] = null;
local2.reset();
return local2;
}
private static function interpolateColorTransform(param1:ColorTransformEntry, param2:ColorTransformEntry, param3:Number, param4:ColorTransform) : void {
param4.alphaMultiplier = param1.alphaMultiplier + param3 * (param2.alphaMultiplier - param1.alphaMultiplier);
param4.alphaOffset = param1.alphaOffset + param3 * (param2.alphaOffset - param1.alphaOffset);
param4.redMultiplier = param1.redMultiplier + param3 * (param2.redMultiplier - param1.redMultiplier);
param4.redOffset = param1.redOffset + param3 * (param2.redOffset - param1.redOffset);
param4.greenMultiplier = param1.greenMultiplier + param3 * (param2.greenMultiplier - param1.greenMultiplier);
param4.greenOffset = param1.greenOffset + param3 * (param2.greenOffset - param1.greenOffset);
param4.blueMultiplier = param1.blueMultiplier + param3 * (param2.blueMultiplier - param1.blueMultiplier);
param4.blueOffset = param1.blueOffset + param3 * (param2.blueOffset - param1.blueOffset);
}
private static function copyStructToColorTransform(param1:ColorTransformEntry, param2:ColorTransform) : void {
param2.alphaMultiplier = param1.alphaMultiplier;
param2.alphaOffset = param1.alphaOffset;
param2.redMultiplier = param1.redMultiplier;
param2.redOffset = param1.redOffset;
param2.greenMultiplier = param1.greenMultiplier;
param2.greenOffset = param1.greenOffset;
param2.blueMultiplier = param1.blueMultiplier;
param2.blueOffset = param1.blueOffset;
}
override public function setFrameIndex(param1:int) : void {
if(this.animated) {
super.setFrameIndex(param1);
}
}
public function reset() : void {
var local1:ColorTransform = colorTransform;
local1.redMultiplier = 1;
local1.greenMultiplier = 1;
local1.blueMultiplier = 1;
local1.alphaMultiplier = 1;
local1.redOffset = 0;
local1.greenOffset = 0;
local1.blueOffset = 0;
local1.alphaOffset = 0;
alpha = 1;
}
public function dispose() : void {
clear();
var local1:* = ++poolIndex;
pool[local1] = this;
}
public function updateColorTransform(param1:Number, param2:Vector.<ColorTransformEntry>) : void {
var local3:Number = NaN;
var local4:ColorTransformEntry = null;
var local5:ColorTransformEntry = null;
var local6:int = 0;
if(param2 != null) {
local3 = this.particleDistance / param1;
if(local3 <= 0) {
local4 = param2[0];
copyStructToColorTransform(local4,colorTransform);
} else if(local3 >= 1) {
local4 = param2[param2.length - 1];
copyStructToColorTransform(local4,colorTransform);
} else {
local6 = 1;
local4 = param2[0];
local5 = param2[1];
while(local5.t < local3) {
local6++;
local4 = local5;
local5 = param2[local6];
}
local3 = (local3 - local4.t) / (local5.t - local4.t);
interpolateColorTransform(local4,local5,local3,colorTransform);
}
alpha = colorTransform.alphaMultiplier;
}
}
}
}
|
package controls.slider {
import assets.slider.slider_THUMB_CENTER;
import assets.slider.slider_THUMB_LEFT;
import assets.slider.slider_THUMB_RIGHT;
import flash.display.Graphics;
import flash.display.Sprite;
import flash.geom.Matrix;
public class SliderThumb extends Sprite {
protected var thumb_bmpLeft:slider_THUMB_LEFT = new slider_THUMB_LEFT(1,1);
protected var thumb_bmpCenter:slider_THUMB_CENTER = new slider_THUMB_CENTER(1,1);
protected var thumb_bmpRight:slider_THUMB_RIGHT = new slider_THUMB_RIGHT(1,1);
protected var _width:int;
public function SliderThumb() {
super();
buttonMode = true;
}
override public function set width(param1:Number) : void {
this._width = param1;
this.draw();
}
protected function draw() : void {
var local2:Matrix = null;
var local1:Graphics = this.graphics;
local1.clear();
local1.beginBitmapFill(this.thumb_bmpLeft);
local1.drawRect(0,0,10,30);
local1.endFill();
local2 = new Matrix();
local2.translate(10,0);
local1.beginBitmapFill(this.thumb_bmpCenter,local2);
local1.drawRect(10,0,this._width - 20,30);
local1.endFill();
local2 = new Matrix();
local2.translate(this._width - 10,0);
local1.beginBitmapFill(this.thumb_bmpRight,local2);
local1.drawRect(this._width - 10,0,10,30);
local1.endFill();
}
}
}
|
package alternativa.tanks.models.weapon.pumpkingun
{
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.ICollisionDetector;
import alternativa.physics.collision.IRayCollisionPredicate;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.models.weapon.shared.ICommonTargetEvaluator;
import alternativa.tanks.physics.CollisionGroup;
public class PumpkinTargetSystem implements IRayCollisionPredicate
{
public var angleUp:Number;
public var numRaysUp:int;
public var angleDown:Number;
public var numRaysDown:int;
public var range:Number;
public var collisionDetector:ICollisionDetector;
public var targetEvaluator:ICommonTargetEvaluator;
private var rayHit:RayIntersection;
private var targetDistance:Number;
private var maxPriority:Number;
private var currOrigin:Vector3;
private var currDirection:Vector3;
private var dir:Vector3;
private var matrix:Matrix3;
private var ricochetCount:int;
private var shooterBody:Body;
public function PumpkinTargetSystem(angleUp:Number, numRaysUp:int, angleDown:Number, numRaysDown:int, range:Number, collisionDetector:ICollisionDetector, targetEvaluator:ICommonTargetEvaluator)
{
this.rayHit = new RayIntersection();
this.currOrigin = new Vector3();
this.currDirection = new Vector3();
this.dir = new Vector3();
this.matrix = new Matrix3();
super();
this.init(angleUp,numRaysUp,angleDown,numRaysDown,range,collisionDetector,targetEvaluator);
}
public function init(angleUp:Number, numRaysUp:int, angleDown:Number, numRaysDown:int, range:Number, collisionDetector:ICollisionDetector, targetEvaluator:ICommonTargetEvaluator) : void
{
this.angleUp = angleUp;
this.numRaysUp = numRaysUp;
this.angleDown = angleDown;
this.numRaysDown = numRaysDown;
this.range = range;
this.collisionDetector = collisionDetector;
this.targetEvaluator = targetEvaluator;
}
public function getShotDirection(origin:Vector3, gunDir:Vector3, gunRotationAxis:Vector3, shooterBody:Body, result:Vector3) : Boolean
{
this.shooterBody = shooterBody;
this.maxPriority = 0;
this.targetDistance = this.range + 1;
this.checkDirection(origin,gunDir,0,result);
this.checkSector(origin,gunDir,gunRotationAxis,this.angleUp / this.numRaysUp,this.numRaysUp,result);
this.checkSector(origin,gunDir,gunRotationAxis,-this.angleDown / this.numRaysDown,this.numRaysDown,result);
this.shooterBody = null;
return this.targetDistance < this.range + 1;
}
public function considerBody(body:Body) : Boolean
{
return !(this.shooterBody == body && this.ricochetCount == 0);
}
private function checkDirection(origin:Vector3, direction:Vector3, angle:Number, result:Vector3) : void
{
var body:Body = null;
var distance:Number = NaN;
var targetPriority:Number = NaN;
var normal:Vector3 = null;
this.ricochetCount = 0;
var remainingDistance:Number = this.range;
var collisionGroup:int = CollisionGroup.WEAPON;
this.currOrigin.vCopy(origin);
this.currDirection.vCopy(direction);
while(remainingDistance > 0)
{
if(!this.collisionDetector.intersectRay(this.currOrigin,this.currDirection,collisionGroup,remainingDistance,this,this.rayHit))
{
return;
}
remainingDistance -= this.rayHit.t;
if(remainingDistance < 0)
{
remainingDistance = 0;
}
body = this.rayHit.primitive.body;
if(body != null && body != this.shooterBody)
{
distance = this.range - remainingDistance;
targetPriority = this.targetEvaluator.getTargetPriority(body,distance,angle);
if(targetPriority > this.maxPriority)
{
this.maxPriority = targetPriority;
this.targetDistance = distance;
result.vCopy(direction);
}
return;
}
++this.ricochetCount;
normal = this.rayHit.normal;
this.currDirection.vAddScaled(-2 * this.currDirection.vDot(normal),normal);
this.currOrigin.vCopy(this.rayHit.pos).vAddScaled(0.1,normal);
}
}
private function checkSector(origin:Vector3, gunDir:Vector3, gunRotationAxis:Vector3, angleStep:Number, numRays:int, result:Vector3) : void
{
this.dir.vCopy(gunDir);
this.matrix.fromAxisAngle(gunRotationAxis,angleStep);
if(angleStep < 0)
{
angleStep = -angleStep;
}
var angle:Number = angleStep;
for(var i:int = 0; i < numRays; i++,angle += angleStep)
{
this.dir.vTransformBy3(this.matrix);
this.checkDirection(origin,this.dir,angle,result);
}
}
}
}
|
package alternativa.tanks.model.item.item {
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.garage.models.item.item.IItemModelBase;
import projects.tanks.client.garage.models.item.item.ItemModelBase;
[ModelInfo]
public class ItemModel extends ItemModelBase implements IItemModelBase, IItem {
public function ItemModel() {
super();
}
public function getPosition() : int {
return getInitParam().position;
}
public function getPreviewResource() : ImageResource {
return getInitParam().preview;
}
public function getMaxRank() : int {
return getInitParam().maxRank;
}
public function getMinRank() : int {
return getInitParam().minRank;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.map {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.map.SkyboxSides;
public class CodecSkyboxSides implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_back:ICodec;
private var codec_bottom:ICodec;
private var codec_front:ICodec;
private var codec_left:ICodec;
private var codec_right:ICodec;
private var codec_top:ICodec;
public function CodecSkyboxSides() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_back = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_bottom = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_front = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_left = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_right = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_top = param1.getCodec(new TypeCodecInfo(TextureResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SkyboxSides = new SkyboxSides();
local2.back = this.codec_back.decode(param1) as TextureResource;
local2.bottom = this.codec_bottom.decode(param1) as TextureResource;
local2.front = this.codec_front.decode(param1) as TextureResource;
local2.left = this.codec_left.decode(param1) as TextureResource;
local2.right = this.codec_right.decode(param1) as TextureResource;
local2.top = this.codec_top.decode(param1) as TextureResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:SkyboxSides = SkyboxSides(param2);
this.codec_back.encode(param1,local3.back);
this.codec_bottom.encode(param1,local3.bottom);
this.codec_front.encode(param1,local3.front);
this.codec_left.encode(param1,local3.left);
this.codec_right.encode(param1,local3.right);
this.codec_top.encode(param1,local3.top);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.aiming {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.aiming.ShotGunAimingCC;
public class CodecShotGunAimingCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_coneHorizontalAngle:ICodec;
private var codec_coneVerticalAngle:ICodec;
private var codec_pelletCount:ICodec;
public function CodecShotGunAimingCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_coneHorizontalAngle = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_coneVerticalAngle = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_pelletCount = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShotGunAimingCC = new ShotGunAimingCC();
local2.coneHorizontalAngle = this.codec_coneHorizontalAngle.decode(param1) as Number;
local2.coneVerticalAngle = this.codec_coneVerticalAngle.decode(param1) as Number;
local2.pelletCount = this.codec_pelletCount.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShotGunAimingCC = ShotGunAimingCC(param2);
this.codec_coneHorizontalAngle.encode(param1,local3.coneHorizontalAngle);
this.codec_coneVerticalAngle.encode(param1,local3.coneVerticalAngle);
this.codec_pelletCount.encode(param1,local3.pelletCount);
}
}
}
|
package _codec.projects.tanks.client.clans.clan.clanmembersdata {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.clans.clan.clanmembersdata.ClanMembersCC;
import projects.tanks.client.clans.clan.clanmembersdata.UserData;
public class CodecClanMembersCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_users:ICodec;
public function CodecClanMembersCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_users = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(UserData,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanMembersCC = new ClanMembersCC();
local2.users = this.codec_users.decode(param1) as Vector.<UserData>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClanMembersCC = ClanMembersCC(param2);
this.codec_users.encode(param1,local3.users);
}
}
}
|
package projects.tanks.client.garage.models.garage.upgrade {
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 UpgradeGarageItemModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:UpgradeGarageItemModelServer;
private var client:IUpgradeGarageItemModelBase = IUpgradeGarageItemModelBase(this);
private var modelId:Long = Long.getLong(293210276,-627719811);
private var _itemAlreadyUpgradedId:Long = Long.getLong(2126423224,-768730341);
private var _itemAlreadyUpgraded_expectedPriceCodec:ICodec;
public function UpgradeGarageItemModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new UpgradeGarageItemModelServer(IModel(this));
this._itemAlreadyUpgraded_expectedPriceCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._itemAlreadyUpgradedId:
this.client.itemAlreadyUpgraded(int(this._itemAlreadyUpgraded_expectedPriceCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package forms.base {
import controls.TankWindowInner;
public class BaseFormWithInner extends BaseForm {
private static const BORDER:int = 12;
private var downHeight:int;
public var inner:TankWindowInner;
public function BaseFormWithInner(param1:int, param2:int, param3:int) {
super(param1 + BORDER * 2,param2 + param3 + BORDER * 3);
this.downHeight = param3;
this.inner = new TankWindowInner(param1,param2,TankWindowInner.GREEN);
this.inner.x = BORDER;
this.inner.y = BORDER;
this.inner.showBlink = true;
window.addChild(this.inner);
}
public function setHeight(param1:int) : void {
this.inner.height = param1;
window.height = param1 + this.downHeight + BORDER * 3;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.coloradjust {
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.battlefield.models.coloradjust.ColorAdjustCC;
import projects.tanks.client.battlefield.models.coloradjust.ColorAdjustParams;
public class CodecColorAdjustCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_frostParamsHW:ICodec;
private var codec_frostParamsSoft:ICodec;
private var codec_heatParamsHW:ICodec;
private var codec_heatParamsSoft:ICodec;
public function CodecColorAdjustCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_frostParamsHW = param1.getCodec(new TypeCodecInfo(ColorAdjustParams,false));
this.codec_frostParamsSoft = param1.getCodec(new TypeCodecInfo(ColorAdjustParams,false));
this.codec_heatParamsHW = param1.getCodec(new TypeCodecInfo(ColorAdjustParams,false));
this.codec_heatParamsSoft = param1.getCodec(new TypeCodecInfo(ColorAdjustParams,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ColorAdjustCC = new ColorAdjustCC();
local2.frostParamsHW = this.codec_frostParamsHW.decode(param1) as ColorAdjustParams;
local2.frostParamsSoft = this.codec_frostParamsSoft.decode(param1) as ColorAdjustParams;
local2.heatParamsHW = this.codec_heatParamsHW.decode(param1) as ColorAdjustParams;
local2.heatParamsSoft = this.codec_heatParamsSoft.decode(param1) as ColorAdjustParams;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ColorAdjustCC = ColorAdjustCC(param2);
this.codec_frostParamsHW.encode(param1,local3.frostParamsHW);
this.codec_frostParamsSoft.encode(param1,local3.frostParamsSoft);
this.codec_heatParamsHW.encode(param1,local3.heatParamsHW);
this.codec_heatParamsSoft.encode(param1,local3.heatParamsSoft);
}
}
}
|
package alternativa.tanks.view.mainview.button {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.mainview.button.DisabledButtonSkin_leftClass.png")]
public class DisabledButtonSkin_leftClass extends BitmapAsset {
public function DisabledButtonSkin_leftClass() {
super();
}
}
}
|
package projects.tanks.client.partners.impl.facebook.login {
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 FacebookInternalLoginModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function FacebookInternalLoginModelServer(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 forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank15.png")]
public class DefaultRanksBitmaps_bitmapSmallRank15 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank15() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank09.png")]
public class PremiumRankBitmaps_bitmapSmallRank09 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank09() {
super();
}
}
}
|
package projects.tanks.client.panel.model.panel {
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 PanelModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function PanelModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.discount.proabonement {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.discount.proabonement.ProAbonementRankDiscountCC;
public class VectorCodecProAbonementRankDiscountCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecProAbonementRankDiscountCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ProAbonementRankDiscountCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = int(LengthCodecHelper.decodeLength(param1));
var local3:Vector.<ProAbonementRankDiscountCC> = new Vector.<ProAbonementRankDiscountCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ProAbonementRankDiscountCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ProAbonementRankDiscountCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ProAbonementRankDiscountCC> = Vector.<ProAbonementRankDiscountCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.battlefield.hidableobjects
{
import alternativa.math.Vector3;
public class HidableGraphicObjects
{
private static const _objectPosition:Vector3 = new Vector3();
private var hideRadiusSquared:Number;
private const center:Vector3 = new Vector3();
private const objects:Vector.<HidableGraphicObject> = new Vector.<HidableGraphicObject>();
private var numObjects:int;
private var enabled:Boolean = false;
public function HidableGraphicObjects()
{
super();
}
public function add(param1:HidableGraphicObject) : void
{
if(this.objects.indexOf(param1) < 0)
{
var _loc2_:* = this.numObjects++;
this.objects[_loc2_] = param1;
}
}
public function remove(param1:HidableGraphicObject) : void
{
var _loc2_:int = this.objects.indexOf(param1);
if(_loc2_ >= 0)
{
param1.setAlphaMultiplier(1);
--this.numObjects;
this.objects[_loc2_] = this.objects[this.numObjects];
this.objects[this.numObjects] = null;
}
}
public function setCenterAndRadius(param1:Vector3, param2:Number) : void
{
this.center.vCopy(param1);
this.hideRadiusSquared = param2 * param2;
}
public function restore() : void
{
var _loc2_:HidableGraphicObject = null;
var _loc1_:int = 0;
while(_loc1_ < this.numObjects)
{
_loc2_ = this.objects[_loc1_];
_loc2_.setAlphaMultiplier(1);
_loc1_++;
}
}
public function render(param1:int, param2:int) : void
{
var _loc4_:HidableGraphicObject = null;
var _loc3_:int = 0;
while(_loc3_ < this.numObjects)
{
_loc4_ = this.objects[_loc3_];
_loc4_.readPosition(_objectPosition);
_loc4_.setAlphaMultiplier(this.getAlphaMultiplier(_objectPosition));
_loc3_++;
}
}
private function getAlphaMultiplier(param1:Vector3) : Number
{
var _loc2_:Number = param1.x - this.center.x;
var _loc3_:Number = param1.y - this.center.y;
var _loc4_:Number = param1.z - this.center.z;
var _loc5_:Number = _loc2_ * _loc2_ + _loc3_ * _loc3_ + _loc4_ * _loc4_;
if(_loc5_ < this.hideRadiusSquared)
{
return Math.sqrt(_loc5_ / this.hideRadiusSquared);
}
return 1;
}
public function clear() : void
{
this.objects.length = 0;
this.numObjects = 0;
}
public function enable() : void
{
this.enabled = true;
}
public function disnable() : void
{
this.enabled = false;
}
public function isEnabled() : Boolean
{
return this.enabled;
}
}
}
|
package alternativa.tanks.gui.presents {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.presents.NewPresentsAlert_bitmapDataClass.png")]
public class NewPresentsAlert_bitmapDataClass extends BitmapAsset {
public function NewPresentsAlert_bitmapDataClass() {
super();
}
}
}
|
package projects.tanks.client.commons.models.coloring {
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 ColoringModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ColoringModelServer;
private var client:IColoringModelBase = IColoringModelBase(this);
private var modelId:Long = Long.getLong(947299051,-358915161);
public function ColoringModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ColoringModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ColoringCC,false)));
}
protected function getInitParam() : ColoringCC {
return ColoringCC(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 controls.scroller.gray {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.gray.ScrollSkinGray_track.png")]
public class ScrollSkinGray_track extends BitmapAsset {
public function ScrollSkinGray_track() {
super();
}
}
}
|
package alternativa.tanks.gui.components.flag {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.panel.create.ClanCreateService;
import controls.dropdownlist.DropDownList;
import fl.events.ListEvent;
import flash.events.Event;
import forms.Styles;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public class FlagsDropDownList extends DropDownList {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var clanCreateService:ClanCreateService;
private static const COUNTRY:String = "country";
public var flag:Flag = new Flag();
public function FlagsDropDownList() {
super();
var local1:int = 0;
while(local1 < clanCreateService.flags.length) {
addItem({
"country":clanCreateService.flags[local1],
"gameName":""
});
local1++;
}
this.selectItemByField(COUNTRY,clanCreateService.defaultFlag);
width = 70;
this.flag.mouseEnabled = false;
addChild(this.flag);
this.flag.x = 8;
this.flag.y = 30 - this.flag.height >> 1;
addEventListener(Event.CHANGE,this.onChange,false,0,true);
height = (Math.min(clanCreateService.flags.length,6) + 1) * rowHeight + 14;
}
override public function setRenderer(param1:Class) : void {
getList().setStyle(Styles.CELL_RENDERER,FlagsRenderer);
}
override public function selectItemByField(param1:String, param2:Object) : void {
var local3:int = 0;
local3 = findItemIndexByField(param1,param2);
if(local3 != -1) {
_selectedItem = dp.getItemAt(local3);
_value = _selectedItem[COUNTRY];
this.flag.setFlag(ClanFlag(_value));
getList().selectedIndex = local3;
getList().scrollToSelected();
}
}
private function onChange(param1:Event) : void {
this.selectItemByField(COUNTRY,selectedItem[COUNTRY]);
}
override protected function onItemClick(param1:ListEvent) : void {
var local2:Object = param1.item;
_selectedIndex = param1.index;
_selectedItem = local2;
close();
dispatchEvent(new Event(Event.CHANGE));
}
}
}
|
package alternativa.tanks.model.bonus.showing.items {
import alternativa.tanks.gui.CongratulationsWindowWithBanner;
import alternativa.tanks.gui.RepatriateBonusWindow;
import alternativa.tanks.model.bonus.showing.info.BonusInfo;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemCC;
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemsShowingCC;
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemsShowingModelBase;
import projects.tanks.client.panel.model.bonus.showing.items.IBonusItemsShowingModelBase;
[ModelInfo]
public class BonusItemsShowingModel extends BonusItemsShowingModelBase implements IBonusItemsShowingModelBase, ObjectLoadListener {
public function BonusItemsShowingModel() {
super();
}
public function objectLoaded() : void {
var local3:IGameObject = null;
var local4:BonusInfo = null;
var local1:BonusItemsShowingCC = getInitParam();
var local2:Vector.<BonusItemCC> = new Vector.<BonusItemCC>();
for each(local3 in local1.bonuses) {
local2.push(BonusItem(local3.adapt(BonusItem)).getItem());
}
local4 = BonusInfo(object.adapt(BonusInfo));
if(local4.getImage() == null) {
new CongratulationsWindowWithBanner(object,local4.getTopText(),local2);
} else {
new RepatriateBonusWindow(object,local4.getImage().data,local4.getTopText(),local2);
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightEffectItem;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingEffectEntity;
public class CodecLightingEffectEntity implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_effectName:ICodec;
private var codec_items:ICodec;
public function CodecLightingEffectEntity() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_effectName = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_items = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(LightEffectItem,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:LightingEffectEntity = new LightingEffectEntity();
local2.effectName = this.codec_effectName.decode(param1) as String;
local2.items = this.codec_items.decode(param1) as Vector.<LightEffectItem>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:LightingEffectEntity = LightingEffectEntity(param2);
this.codec_effectName.encode(param1,local3.effectName);
this.codec_items.encode(param1,local3.items);
}
}
}
|
package alternativa.tanks.models.battle.battlefield {
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleSfxAdapt implements BattleSfx {
private var object:IGameObject;
private var impl:BattleSfx;
public function BattleSfxAdapt(param1:IGameObject, param2:BattleSfx) {
super();
this.object = param1;
this.impl = param2;
}
public function getLightingSfx() : LightingSfx {
var result:LightingSfx = null;
try {
Model.object = this.object;
result = this.impl.getLightingSfx();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.battle.objects.tank {
import alternativa.math.Matrix3;
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.BodyState;
import alternativa.tanks.utils.EncryptedNumber;
import alternativa.tanks.utils.EncryptedNumberImpl;
public class RemoteHullTransformUpdater implements HullTransformUpdater {
private static const position:Vector3 = new Vector3();
private static const m3:Matrix3 = new Matrix3();
private static const SMOOTHING_COEFF:EncryptedNumber = new EncryptedNumberImpl(Math.PI / 10.4719);
private static const smoothedEulerAngles:Vector3 = new Vector3();
private const smoothedPosition:Vector3 = new Vector3();
private const smoothedOrientation:Quaternion = new Quaternion();
private var tank:Tank;
public function RemoteHullTransformUpdater(param1:Tank) {
super();
this.tank = param1;
}
private static function smoothValue(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Number {
param1 += param2 * param3;
return param1 + (param4 - param1) * param5;
}
public function reset() : void {
var local1:BodyState = this.tank.getBody().prevState;
this.smoothedPosition.copy(local1.position);
this.smoothedOrientation.copy(local1.orientation);
}
public function update(param1:Number) : void {
var local2:Body = this.tank.getBody();
var local3:BodyState = local2.prevState;
var local4:Vector3 = local3.velocity;
var local5:Vector3 = this.tank.interpolatedPosition;
var local6:Number = Number(SMOOTHING_COEFF.getNumber());
this.smoothedPosition.x = smoothValue(this.smoothedPosition.x,local4.x,param1,local5.x,local6);
this.smoothedPosition.y = smoothValue(this.smoothedPosition.y,local4.y,param1,local5.y,local6);
this.smoothedPosition.z = smoothValue(this.smoothedPosition.z,local4.z,param1,local5.z,local6);
var local7:Vector3 = local3.angularVelocity;
this.smoothedOrientation.addScaledVector(local7,param1);
this.smoothedOrientation.slerp(this.smoothedOrientation,this.tank.interpolatedOrientation,local6);
this.smoothedOrientation.getEulerAngles(smoothedEulerAngles);
this.smoothedOrientation.toMatrix3(m3);
position.copy(this.tank.skinCenterOffset);
position.transform3(m3);
position.add(this.smoothedPosition);
this.tank.getSkin().updateHullTransform(position,smoothedEulerAngles);
}
}
}
|
package alternativa.tanks.models.battlefield.inventory
{
import alternativa.tanks.models.inventory.InventoryLock;
import controls.InventoryIcon;
import controls.Label;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.geom.ColorTransform;
public class InventoryPanelSlot
{
private static const FONT_SIZE:int = 10;
private static const FLASH_SHOW:int = 1;
private static const FLASH_FADE:int = 2;
private static const FLASH_DONE:int = 3;
private var slotNumber:int;
private var slotNumberLabel:Label;
private var item:InventoryItem;
private var canvas:DisplayObjectContainer;
private var cooldownMask:CooldownIndicator;
private var quantityLabel:Label;
private var lockBits:int;
private var emptyIcon:InventoryIcon;
private var flashState:int = 3;
private var colorTransform:ColorTransform;
private var flashStartTime:int;
private var prevItemReadiness:Number = 1;
public function InventoryPanelSlot(slotNumber:int)
{
this.emptyIcon = new InventoryIcon(InventoryIcon.EMPTY);
this.colorTransform = new ColorTransform();
super();
this.slotNumber = slotNumber;
this.canvas = new Sprite();
this.canvas.addChild(this.emptyIcon);
this.slotNumberLabel = new Label();
this.slotNumberLabel.size = FONT_SIZE;
this.slotNumberLabel.text = slotNumber.toString();
this.slotNumberLabel.x = 3;
this.slotNumberLabel.y = 1;
this.canvas.addChild(this.slotNumberLabel);
this.setLockMask(InventoryLock.PLAYER_INACTIVE,true);
}
public function setLockMask(mask:int, setLock:Boolean) : void
{
if(setLock)
{
this.lockBits |= mask;
}
else
{
this.lockBits &= ~mask;
}
}
public function isLocked() : Boolean
{
return this.lockBits != 0;
}
public function getCanvas() : DisplayObject
{
return this.canvas;
}
public function setItem(item:InventoryItem) : void
{
var icon:InventoryIcon = null;
if(this.item == item)
{
return;
}
if(this.item != null)
{
this.canvas.removeChild(this.item.getIcon());
}
this.item = item;
if(item != null)
{
if(this.canvas.contains(this.emptyIcon))
{
this.canvas.removeChild(this.emptyIcon);
}
icon = item.getIcon();
this.canvas.addChildAt(icon,0);
if(this.cooldownMask == null)
{
this.cooldownMask = new CooldownIndicator(icon.width - 4,8);
this.cooldownMask.x = 2;
this.cooldownMask.y = 2;
this.canvas.addChild(this.cooldownMask);
}
this.cooldownMask.visible = false;
if(this.quantityLabel == null)
{
this.quantityLabel = new Label();
this.quantityLabel.size = FONT_SIZE;
this.canvas.addChild(this.quantityLabel);
}
this.updateCounter();
}
else
{
if(!this.canvas.contains(this.emptyIcon))
{
this.canvas.addChildAt(this.emptyIcon,0);
}
this.quantityLabel.visible = false;
}
}
public function getItem() : InventoryItem
{
return this.item;
}
public function update(now:int) : void
{
var itemReadiness:Number = NaN;
if(this.item == null)
{
return;
}
if(this.isLocked())
{
this.cooldownMask.visible = true;
this.cooldownMask.draw(0);
this.prevItemReadiness = 1;
}
else
{
itemReadiness = this.item == null ? Number(Number(0)) : Number(Number(this.item.getCooldownStatus(now)));
if(itemReadiness == 1)
{
this.cooldownMask.visible = false;
if(this.prevItemReadiness < 1)
{
this.startFlash(now);
}
this.updateFlash(now);
}
else
{
this.stopFlash();
this.cooldownMask.visible = true;
this.cooldownMask.draw(itemReadiness);
}
this.prevItemReadiness = itemReadiness;
}
}
public function updateCounter() : void
{
if(this.item == null)
{
return;
}
var count:int = this.item.count;
if(count > 0)
{
this.quantityLabel.text = count.toString();
this.quantityLabel.x = this.item.getIcon().width - this.quantityLabel.width - 3;
this.quantityLabel.y = this.item.getIcon().height - this.quantityLabel.height - 1;
}
else
{
this.setItem(null);
}
}
private function updateFlash(now:int) : void
{
switch(this.flashState)
{
case FLASH_SHOW:
if(now < this.flashStartTime + 100)
{
this.setColorOffset(255 * (now - this.flashStartTime) / 100);
}
else
{
this.setColorOffset(255);
this.flashStartTime += 100 + 300;
this.flashState = FLASH_FADE;
}
break;
case FLASH_FADE:
if(now < this.flashStartTime)
{
this.setColorOffset(255 * (this.flashStartTime - now) / 300);
}
else
{
this.stopFlash();
}
}
}
private function setColorOffset(offset:uint) : void
{
this.colorTransform.redOffset = offset;
this.colorTransform.greenOffset = offset;
this.colorTransform.blueOffset = offset;
this.colorTransform.alphaOffset = offset;
this.canvas.transform.colorTransform = this.colorTransform;
}
private function startFlash(now:int) : void
{
this.flashState = FLASH_SHOW;
this.flashStartTime = now;
}
private function stopFlash() : void
{
if(this.flashState != FLASH_DONE)
{
this.flashState = FLASH_DONE;
this.setColorOffset(0);
}
}
}
}
|
package alternativa.tanks.model.bonus
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.service.IModelService;
import alternativa.tanks.gui.ConfugirationsNewbiesWindow;
import alternativa.tanks.gui.CongratulationsWindow;
import alternativa.tanks.gui.CongratulationsWindowPresent;
import alternativa.tanks.gui.CongratulationsWindowWithBanner;
import alternativa.tanks.locale.constants.TextConst;
import alternativa.tanks.model.panel.IPanel;
import alternativa.types.Long;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import projects.tanks.client.panel.model.bonus.BonusModelBase;
import projects.tanks.client.panel.model.bonus.IBonusModelBase;
public class BonusModel extends BonusModelBase implements IBonusModelBase, IObjectLoadListener, IBonus
{
private var clientObject:ClientObject;
private var panelModel:IPanel;
private var dialogsLayer:DisplayObjectContainer;
private var bonusWindow:CongratulationsWindowWithBanner;
private var bonusWindowPresent:CongratulationsWindowPresent;
private var bonusWindowNewbies:Sprite;
private var newRules:Sprite;
public function BonusModel()
{
super();
_interfaces.push(IModel,IBonus,IBonusModelBase,IObjectLoadListener);
this.dialogsLayer = Main.dialogsLayer;
var modelRegister:IModelService = Main.osgi.getService(IModelService) as IModelService;
this.panelModel = (modelRegister.getModelsByInterface(IPanel) as Vector.<IModel>)[0] as IPanel;
}
public function showBonuses(clientObject:ClientObject, items:Array, bannerObjectId:String) : void
{
if(items.length > 0)
{
this.panelModel.blur();
this.bonusWindow = new CongratulationsWindowWithBanner(ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_MESSAGE_TEXT),items,null);
this.dialogsLayer.addChild(this.bonusWindow);
this.bonusWindow.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindow);
this.alignWindow();
Main.stage.addEventListener(Event.RESIZE,this.alignWindow);
}
}
public function showCrystals(clientObject:ClientObject, count:int, banner:Long) : void
{
this.panelModel.blur();
this.bonusWindowPresent = new CongratulationsWindowPresent(CongratulationsWindowPresent.CRYSTALS,null,count);
this.dialogsLayer.addChild(this.bonusWindowPresent);
this.bonusWindowPresent.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindowPresent);
this.alignWindowPresent();
Main.stage.addEventListener(Event.RESIZE,this.alignWindowPresent);
}
public function showNoSupplies(clientObject:ClientObject, banner:Long) : void
{
this.panelModel.blur();
this.bonusWindowPresent = new CongratulationsWindowPresent(CongratulationsWindowPresent.NOSUPPLIES,null);
this.dialogsLayer.addChild(this.bonusWindowPresent);
this.bonusWindowPresent.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindowPresent);
this.alignWindowPresent();
Main.stage.addEventListener(Event.RESIZE,this.alignWindowPresent);
}
public function showDoubleCrystalls(clientObject:ClientObject, banner:Long) : void
{
this.panelModel.blur();
this.bonusWindowPresent = new CongratulationsWindowPresent(CongratulationsWindowPresent.DOUBLE_CRYSTALLS,null);
this.dialogsLayer.addChild(this.bonusWindowPresent);
this.bonusWindowPresent.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindowPresent);
this.alignWindowPresent();
Main.stage.addEventListener(Event.RESIZE,this.alignWindowPresent);
}
public function showNubeUpScore() : void
{
this.panelModel.blur();
var bonus:ConfugirationsNewbiesWindow = new ConfugirationsNewbiesWindow(TextConst.NEWBIES_BONUSES_WINDOW_MESSAGE_TEXT);
this.bonusWindowNewbies = bonus;
this.dialogsLayer.addChild(bonus);
bonus.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindowPresentNewbies);
this.alignWindowNewbies();
Main.stage.addEventListener(Event.RESIZE,this.alignWindowNewbies);
}
public function showNubeNewRank() : void
{
this.panelModel.blur();
var bonus:ConfugirationsNewbiesWindow = new ConfugirationsNewbiesWindow(TextConst.NEWBIES_BONUSES_NEW_RANK_WINDOW_MESSAGE_TEXT);
this.bonusWindowNewbies = bonus;
this.dialogsLayer.addChild(bonus);
bonus.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindowPresentNewbies);
this.alignWindowNewbies();
Main.stage.addEventListener(Event.RESIZE,this.alignWindowNewbies);
}
public function showRulesUpdate() : void
{
this.panelModel.blur();
var bonus:CongratulationsWindow = new CongratulationsWindow("Танкисты!\nБыли обновлены <a href = \"http://mytanksforum.net\"><u>Правила игры</u></a>, нажимая кнопку «Закрыть» вы соглашаетесь с этими правилами.",[],true);
this.newRules = bonus;
this.dialogsLayer.addChild(bonus);
bonus.closeButton.addEventListener(MouseEvent.CLICK,this.closeWindowNewRules);
this.alignNewRules();
Main.stage.addEventListener(Event.RESIZE,this.alignNewRules);
}
public function objectLoaded(object:ClientObject) : void
{
this.clientObject = this.clientObject;
}
public function objectUnloaded(object:ClientObject) : void
{
if(this.bonusWindow != null && this.dialogsLayer.contains(this.bonusWindow))
{
this.closeWindow();
this.bonusWindow.closeButton.removeEventListener(MouseEvent.CLICK,this.closeWindow);
Main.stage.removeEventListener(Event.RESIZE,this.alignWindow);
this.bonusWindow = null;
}
this.clientObject = null;
}
public function get congratulationsWindow() : CongratulationsWindowWithBanner
{
return this.bonusWindow;
}
private function alignWindowNewbies(e:Event = null) : void
{
this.bonusWindowNewbies.x = Math.round((Main.stage.stageWidth - this.bonusWindowNewbies.width) * 0.5);
this.bonusWindowNewbies.y = Math.round((Main.stage.stageHeight - this.bonusWindowNewbies.height) * 0.5);
}
private function alignNewRules(e:Event = null) : void
{
this.newRules.x = Math.round((Main.stage.stageWidth - this.newRules.width) * 0.5);
this.newRules.y = Math.round((Main.stage.stageHeight - this.newRules.height) * 0.5);
}
private function alignWindow(e:Event = null) : void
{
this.bonusWindow.x = Math.round((Main.stage.stageWidth - this.bonusWindow.width) * 0.5);
this.bonusWindow.y = Math.round((Main.stage.stageHeight - this.bonusWindow.height) * 0.5);
}
private function alignWindowPresent(e:Event = null) : void
{
this.bonusWindowPresent.x = Math.round((Main.stage.stageWidth - this.bonusWindowPresent.width) * 0.5);
this.bonusWindowPresent.y = Math.round((Main.stage.stageHeight - this.bonusWindowPresent.height) * 0.5);
}
private function closeWindow(e:MouseEvent = null) : void
{
this.panelModel.unblur();
this.dialogsLayer.removeChild(this.bonusWindow);
}
private function closeWindowPresent(e:MouseEvent = null) : void
{
this.panelModel.unblur();
this.dialogsLayer.removeChild(this.bonusWindowPresent);
}
private function closeWindowPresentNewbies(e:MouseEvent = null) : void
{
this.panelModel.unblur();
this.dialogsLayer.removeChild(this.bonusWindowNewbies);
}
private function closeWindowNewRules(e:MouseEvent = null) : void
{
this.panelModel.unblur();
this.dialogsLayer.removeChild(this.newRules);
}
}
}
|
package alternativa.engine3d.materials {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.lights.AmbientLight;
import alternativa.engine3d.lights.DirectionalLight;
import alternativa.engine3d.lights.OmniLight;
import alternativa.engine3d.lights.SpotLight;
import flash.display.BitmapData;
import flash.geom.ColorTransform;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class FlatShadingMaterial extends TextureMaterial {
alternativa3d static var colorTransform:ColorTransform = new ColorTransform();
alternativa3d static const lights:Vector.<Light3D> = new Vector.<Light3D>();
alternativa3d static const multiplier:ColorTransform = new ColorTransform(2,2,2);
alternativa3d var weights:Dictionary = new Dictionary();
public var defaultLightWeight:Number = 1;
public var multipliedDiffuse:Boolean = false;
public function FlatShadingMaterial(param1:BitmapData = null, param2:Boolean = false, param3:Boolean = true, param4:int = 0, param5:Number = 1) {
super(param1,param2,param3,param4,param5);
alternativa3d::useVerticesNormals = true;
}
public function setLightWeight(param1:Light3D, param2:Number) : void {
this.alternativa3d::weights[param1] = param2;
}
public function getLightWeight(param1:Light3D) : Number {
var local2:Number = Number(this.alternativa3d::weights[param1]);
return local2 == local2 ? local2 : this.defaultLightWeight;
}
public function setLightWeightToDefault(param1:Light3D) : void {
delete this.alternativa3d::weights[param1];
}
public function setAllLightWeightsToDefault() : void {
var local1:* = undefined;
for(local1 in this.alternativa3d::weights) {
delete this.alternativa3d::weights[local1];
}
}
override public function clone() : Material {
var local1:FlatShadingMaterial = new FlatShadingMaterial(alternativa3d::_texture,repeat,smooth,alternativa3d::_mipMapping,resolution);
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Material) : void {
super.clonePropertiesFrom(param1);
var local2:FlatShadingMaterial = param1 as FlatShadingMaterial;
this.defaultLightWeight = local2.defaultLightWeight;
this.multipliedDiffuse = local2.multipliedDiffuse;
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas, param3:Face, param4:Number) : void {
var local5:int = 0;
var local6:Light3D = null;
var local7:DirectionalLight = null;
var local8:OmniLight = null;
var local9:SpotLight = null;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
var local26:int = 0;
var local27:Wrapper = null;
var local28:Vertex = null;
var local29:Vertex = null;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local34:Number = NaN;
var local35:Number = NaN;
var local36:Number = NaN;
var local37:Number = NaN;
var local38:Number = NaN;
var local39:Number = NaN;
var local40:Number = NaN;
var local41:Number = NaN;
var local42:Number = NaN;
var local43:int = 0;
var local44:int = 0;
var local45:int = 0;
var local46:Number = NaN;
var local47:Number = NaN;
var local15:Number = Number(param1.alternativa3d::viewSizeX);
var local16:Number = Number(param1.alternativa3d::viewSizeY);
var local17:int = 0;
var local18:int = 0;
var local19:Canvas = param2.alternativa3d::getChildCanvas(true,false,param2.alternativa3d::object,1,"multiply");
var local20:int = 0;
local5 = 0;
while(local5 < param1.alternativa3d::lightsLength) {
local6 = param1.alternativa3d::lights[local5];
local22 = Number(this.alternativa3d::weights[local6]);
if(local22 != local22) {
local22 = this.defaultLightWeight;
}
if(local22 > 0) {
local6.alternativa3d::calculateObjectMatrix(param2.alternativa3d::object);
if(local6.alternativa3d::checkBoundsIntersection(param2.alternativa3d::object)) {
local6.alternativa3d::localRed = (local6.color >> 16 & 0xFF) * local6.intensity * local22;
local6.alternativa3d::localGreen = (local6.color >> 8 & 0xFF) * local6.intensity * local22;
local6.alternativa3d::localBlue = (local6.color & 0xFF) * local6.intensity * local22;
if(local6 is DirectionalLight) {
local7 = local6 as DirectionalLight;
local7.alternativa3d::localDirectionX = local7.alternativa3d::omc;
local7.alternativa3d::localDirectionY = local7.alternativa3d::omg;
local7.alternativa3d::localDirectionZ = local7.alternativa3d::omk;
local14 = Math.sqrt(local7.alternativa3d::localDirectionX * local7.alternativa3d::localDirectionX + local7.alternativa3d::localDirectionY * local7.alternativa3d::localDirectionY + local7.alternativa3d::localDirectionZ * local7.alternativa3d::localDirectionZ);
local7.alternativa3d::localDirectionX /= local14;
local7.alternativa3d::localDirectionY /= local14;
local7.alternativa3d::localDirectionZ /= local14;
} else if(local6 is OmniLight) {
local8 = local6 as OmniLight;
local10 = Math.sqrt(local8.alternativa3d::oma * local8.alternativa3d::oma + local8.alternativa3d::ome * local8.alternativa3d::ome + local8.alternativa3d::omi * local8.alternativa3d::omi);
local10 += Math.sqrt(local8.alternativa3d::omb * local8.alternativa3d::omb + local8.alternativa3d::omf * local8.alternativa3d::omf + local8.alternativa3d::omj * local8.alternativa3d::omj);
local10 += Math.sqrt(local8.alternativa3d::omc * local8.alternativa3d::omc + local8.alternativa3d::omg * local8.alternativa3d::omg + local8.alternativa3d::omk * local8.alternativa3d::omk);
local10 /= 3;
local8.alternativa3d::localAttenuationBegin = local8.attenuationBegin * local10;
local8.alternativa3d::localAttenuationEnd = local8.attenuationEnd * local10;
} else if(local6 is SpotLight) {
local9 = local6 as SpotLight;
local10 = Math.sqrt(local9.alternativa3d::oma * local9.alternativa3d::oma + local9.alternativa3d::ome * local9.alternativa3d::ome + local9.alternativa3d::omi * local9.alternativa3d::omi);
local10 += Math.sqrt(local9.alternativa3d::omb * local9.alternativa3d::omb + local9.alternativa3d::omf * local9.alternativa3d::omf + local9.alternativa3d::omj * local9.alternativa3d::omj);
local10 += Math.sqrt(local9.alternativa3d::omc * local9.alternativa3d::omc + local9.alternativa3d::omg * local9.alternativa3d::omg + local9.alternativa3d::omk * local9.alternativa3d::omk);
local10 /= 3;
local9.alternativa3d::localAttenuationBegin = local9.attenuationBegin * local10;
local9.alternativa3d::localAttenuationEnd = local9.attenuationEnd * local10;
local9.alternativa3d::localDirectionX = local9.alternativa3d::omc;
local9.alternativa3d::localDirectionY = local9.alternativa3d::omg;
local9.alternativa3d::localDirectionZ = local9.alternativa3d::omk;
local14 = Math.sqrt(local9.alternativa3d::localDirectionX * local9.alternativa3d::localDirectionX + local9.alternativa3d::localDirectionY * local9.alternativa3d::localDirectionY + local9.alternativa3d::localDirectionZ * local9.alternativa3d::localDirectionZ);
local9.alternativa3d::localDirectionX /= local14;
local9.alternativa3d::localDirectionY /= local14;
local9.alternativa3d::localDirectionZ /= local14;
local9.alternativa3d::localHotspot = Math.cos(local9.hotspot * 0.5);
local9.alternativa3d::localFalloff = Math.cos(local9.falloff * 0.5);
}
alternativa3d::lights[local20] = local6;
local20++;
}
}
local5++;
}
var local21:Face = param3;
while(local21 != null) {
local23 = 0;
local24 = 0;
local25 = 0;
local26 = 0;
local27 = local21.alternativa3d::wrapper;
local28 = local27.alternativa3d::vertex;
local23 += local28.x;
local24 += local28.y;
local25 += local28.z;
local26++;
local27 = local27.alternativa3d::next;
local29 = local27.alternativa3d::vertex;
local23 += local29.x;
local24 += local29.y;
local25 += local29.z;
local26++;
local30 = local29.x - local28.x;
local31 = local29.y - local28.y;
local32 = local29.z - local28.z;
local27 = local27.alternativa3d::next;
local29 = local27.alternativa3d::vertex;
local23 += local29.x;
local24 += local29.y;
local25 += local29.z;
local26++;
local33 = local29.x - local28.x;
local34 = local29.y - local28.y;
local35 = local29.z - local28.z;
local27 = local27.alternativa3d::next;
while(local27 != null) {
local29 = local27.alternativa3d::vertex;
local23 += local29.x;
local24 += local29.y;
local25 += local29.z;
local26++;
local27 = local27.alternativa3d::next;
}
local23 /= local26;
local24 /= local26;
local25 /= local26;
local36 = local35 * local31 - local34 * local32;
local37 = local33 * local32 - local35 * local30;
local38 = local34 * local30 - local33 * local31;
local39 = Math.sqrt(local36 * local36 + local37 * local37 + local38 * local38);
local36 /= local39;
local37 /= local39;
local38 /= local39;
local40 = 0;
local41 = 0;
local42 = 0;
local5 = 0;
while(local5 < local20) {
local6 = alternativa3d::lights[local5];
if(local6 is AmbientLight) {
local40 += local6.alternativa3d::localRed;
local41 += local6.alternativa3d::localGreen;
local42 += local6.alternativa3d::localBlue;
} else if(local6 is DirectionalLight) {
local7 = local6 as DirectionalLight;
local46 = -local36 * local7.alternativa3d::localDirectionX - local37 * local7.alternativa3d::localDirectionY - local38 * local7.alternativa3d::localDirectionZ;
if(local46 > 0) {
local40 += local6.alternativa3d::localRed * local46;
local41 += local6.alternativa3d::localGreen * local46;
local42 += local6.alternativa3d::localBlue * local46;
}
} else if(local6 is OmniLight) {
local8 = local6 as OmniLight;
local11 = local23 - local8.alternativa3d::omd;
local12 = local24 - local8.alternativa3d::omh;
local13 = local25 - local8.alternativa3d::oml;
local14 = local11 * local11 + local12 * local12 + local13 * local13;
if(local14 < local8.alternativa3d::localAttenuationEnd * local8.alternativa3d::localAttenuationEnd) {
local14 = Math.sqrt(local14);
local11 /= local14;
local12 /= local14;
local13 /= local14;
local46 = -local36 * local11 - local37 * local12 - local38 * local13;
if(local46 > 0) {
if(local14 > local8.alternativa3d::localAttenuationBegin) {
local46 *= 1 - (local14 - local8.alternativa3d::localAttenuationBegin) / (local8.alternativa3d::localAttenuationEnd - local8.alternativa3d::localAttenuationBegin);
}
local40 += local6.alternativa3d::localRed * local46;
local41 += local6.alternativa3d::localGreen * local46;
local42 += local6.alternativa3d::localBlue * local46;
}
}
} else if(local6 is SpotLight) {
local9 = local6 as SpotLight;
local11 = local23 - local9.alternativa3d::omd;
local12 = local24 - local9.alternativa3d::omh;
local13 = local25 - local9.alternativa3d::oml;
local14 = local11 * local11 + local12 * local12 + local13 * local13;
if(local14 < local9.alternativa3d::localAttenuationEnd * local9.alternativa3d::localAttenuationEnd) {
local14 = Math.sqrt(local14);
local11 /= local14;
local12 /= local14;
local13 /= local14;
local47 = local9.alternativa3d::localDirectionX * local11 + local9.alternativa3d::localDirectionY * local12 + local9.alternativa3d::localDirectionZ * local13;
if(local47 > local9.alternativa3d::localFalloff) {
local46 = -local36 * local11 - local37 * local12 - local38 * local13;
if(local46 > 0) {
if(local14 > local9.alternativa3d::localAttenuationBegin) {
local46 *= 1 - (local14 - local9.alternativa3d::localAttenuationBegin) / (local9.alternativa3d::localAttenuationEnd - local9.alternativa3d::localAttenuationBegin);
}
if(local47 < local9.alternativa3d::localHotspot) {
local46 *= (local47 - local9.alternativa3d::localFalloff) / (local9.alternativa3d::localHotspot - local9.alternativa3d::localFalloff);
}
local40 += local6.alternativa3d::localRed * local46;
local41 += local6.alternativa3d::localGreen * local46;
local42 += local6.alternativa3d::localBlue * local46;
}
}
}
}
local5++;
}
local43 = local40 > 255 ? 255 : (local40 < 0 ? 0 : int(local40));
local44 = local41 > 255 ? 255 : (local41 < 0 ? 0 : int(local41));
local45 = local42 > 255 ? 255 : (local42 < 0 ? 0 : int(local42));
local19.alternativa3d::gfx.beginFill((local43 << 16) + (local44 << 8) + local45);
local19.alternativa3d::gfx.moveTo(local28.alternativa3d::cameraX * local15 / local28.alternativa3d::cameraZ,local28.alternativa3d::cameraY * local16 / local28.alternativa3d::cameraZ);
local27 = local21.alternativa3d::wrapper.alternativa3d::next;
while(local27 != null) {
local29 = local27.alternativa3d::vertex;
local19.alternativa3d::gfx.lineTo(local29.alternativa3d::cameraX * local15 / local29.alternativa3d::cameraZ,local29.alternativa3d::cameraY * local16 / local29.alternativa3d::cameraZ);
local18++;
local27 = local27.alternativa3d::next;
}
local18--;
local17++;
local21 = local21.alternativa3d::processNext;
}
++param1.alternativa3d::numDraws;
param1.alternativa3d::numPolygons += local17;
param1.alternativa3d::numTriangles += local18;
super.alternativa3d::draw(param1,this.multipliedDiffuse ? param2 : param2.alternativa3d::getChildCanvas(true,false,param2.alternativa3d::object,1,"normal",alternativa3d::multiplier),param3,param4);
}
override alternativa3d function drawViewAligned(param1:Camera3D, param2:Canvas, param3:Face, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number) : void {
this.alternativa3d::calculateLight(param1,param2.alternativa3d::object);
if(this.multipliedDiffuse) {
alternativa3d::colorTransform.redMultiplier *= 0.5;
alternativa3d::colorTransform.greenMultiplier *= 0.5;
alternativa3d::colorTransform.blueMultiplier *= 0.5;
}
if(param2.alternativa3d::modifiedColorTransform) {
super.alternativa3d::drawViewAligned(param1,param2.alternativa3d::getChildCanvas(true,false,param2.alternativa3d::object,1,"normal",alternativa3d::colorTransform),param3,param4,param5,param6,param7,param8,param9,param10);
} else {
super.alternativa3d::drawViewAligned(param1,param2,param3,param4,param5,param6,param7,param8,param9,param10);
param2.transform.colorTransform = alternativa3d::colorTransform;
param2.alternativa3d::modifiedColorTransform = true;
}
}
alternativa3d function calculateLight(param1:Camera3D, param2:Object3D) : void {
var local7:Light3D = null;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:DirectionalLight = null;
var local25:OmniLight = null;
var local26:SpotLight = null;
var local27:Number = NaN;
var local28:Number = NaN;
var local29:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local3:Number = 0;
var local4:Number = 0;
var local5:Number = 0;
var local6:int = 0;
while(local6 < param1.alternativa3d::lightsLength) {
local7 = param1.alternativa3d::lights[local6];
local8 = Number(this.alternativa3d::weights[local7]);
if(local8 != local8) {
local8 = this.defaultLightWeight;
}
if(local8 > 0) {
local7.alternativa3d::calculateObjectMatrix(param2);
if(local7.alternativa3d::checkBoundsIntersection(param2)) {
local21 = (local7.color >> 16 & 0xFF) * local7.intensity * local8;
local22 = (local7.color >> 8 & 0xFF) * local7.intensity * local8;
local23 = (local7.color & 0xFF) * local7.intensity * local8;
if(local7 is AmbientLight) {
local3 += local21;
local4 += local22;
local5 += local23;
} else if(local7 is DirectionalLight) {
local24 = local7 as DirectionalLight;
local9 = -param2.alternativa3d::imc;
local10 = -param2.alternativa3d::img;
local11 = -param2.alternativa3d::imk;
local12 = Math.sqrt(local9 * local9 + local10 * local10 + local11 * local11);
local9 /= local12;
local10 /= local12;
local11 /= local12;
local13 = Number(local24.alternativa3d::omc);
local14 = Number(local24.alternativa3d::omg);
local15 = Number(local24.alternativa3d::omk);
local16 = Math.sqrt(local13 * local13 + local14 * local14 + local15 * local15);
local13 /= local16;
local14 /= local16;
local15 /= local16;
local17 = -local9 * local13 - local10 * local14 - local11 * local15;
if(local17 < 0) {
local17 = 0;
}
local3 += local21 * local17;
local4 += local22 * local17;
local5 += local23 * local17;
} else if(local7 is OmniLight) {
local25 = local7 as OmniLight;
local18 = Math.sqrt(local25.alternativa3d::oma * local25.alternativa3d::oma + local25.alternativa3d::ome * local25.alternativa3d::ome + local25.alternativa3d::omi * local25.alternativa3d::omi);
local18 += Math.sqrt(local25.alternativa3d::omb * local25.alternativa3d::omb + local25.alternativa3d::omf * local25.alternativa3d::omf + local25.alternativa3d::omj * local25.alternativa3d::omj);
local18 += Math.sqrt(local25.alternativa3d::omc * local25.alternativa3d::omc + local25.alternativa3d::omg * local25.alternativa3d::omg + local25.alternativa3d::omk * local25.alternativa3d::omk);
local18 /= 3;
local19 = local25.attenuationBegin * local18;
local20 = local25.attenuationEnd * local18;
local13 = -local25.alternativa3d::omd;
local14 = -local25.alternativa3d::omh;
local15 = -local25.alternativa3d::oml;
local16 = local13 * local13 + local14 * local14 + local15 * local15;
if(local16 < local20 * local20) {
local9 = -param2.alternativa3d::imc;
local10 = -param2.alternativa3d::img;
local11 = -param2.alternativa3d::imk;
local12 = Math.sqrt(local9 * local9 + local10 * local10 + local11 * local11);
local9 /= local12;
local10 /= local12;
local11 /= local12;
local16 = Math.sqrt(local16);
local13 /= local16;
local14 /= local16;
local15 /= local16;
local17 = -local9 * local13 - local10 * local14 - local11 * local15;
if(local17 < 0) {
local17 = 0;
}
if(local16 > local19) {
local17 *= 1 - (local16 - local19) / (local20 - local19);
}
local3 += local21 * local17;
local4 += local22 * local17;
local5 += local23 * local17;
}
} else if(local7 is SpotLight) {
local26 = local7 as SpotLight;
local18 = Math.sqrt(local26.alternativa3d::oma * local26.alternativa3d::oma + local26.alternativa3d::ome * local26.alternativa3d::ome + local26.alternativa3d::omi * local26.alternativa3d::omi);
local18 += Math.sqrt(local26.alternativa3d::omb * local26.alternativa3d::omb + local26.alternativa3d::omf * local26.alternativa3d::omf + local26.alternativa3d::omj * local26.alternativa3d::omj);
local18 += Math.sqrt(local26.alternativa3d::omc * local26.alternativa3d::omc + local26.alternativa3d::omg * local26.alternativa3d::omg + local26.alternativa3d::omk * local26.alternativa3d::omk);
local18 /= 3;
local19 = local26.attenuationBegin * local18;
local20 = local26.attenuationEnd * local18;
local13 = -local26.alternativa3d::omd;
local14 = -local26.alternativa3d::omh;
local15 = -local26.alternativa3d::oml;
local16 = local13 * local13 + local14 * local14 + local15 * local15;
if(local16 < local20 * local20) {
local16 = Math.sqrt(local16);
local13 /= local16;
local14 /= local16;
local15 /= local16;
local27 = Number(local26.alternativa3d::omc);
local28 = Number(local26.alternativa3d::omg);
local29 = Number(local26.alternativa3d::omk);
local30 = Math.sqrt(local27 * local27 + local28 * local28 + local29 * local29);
local27 /= local30;
local28 /= local30;
local29 /= local30;
local31 = Math.cos(local26.hotspot * 0.5);
local32 = Math.cos(local26.falloff * 0.5);
local33 = local27 * local13 + local28 * local14 + local29 * local15;
if(local33 > local32) {
local9 = -param2.alternativa3d::imc;
local10 = -param2.alternativa3d::img;
local11 = -param2.alternativa3d::imk;
local12 = Math.sqrt(local9 * local9 + local10 * local10 + local11 * local11);
local9 /= local12;
local10 /= local12;
local11 /= local12;
local17 = -local9 * local13 - local10 * local14 - local11 * local15;
if(local17 < 0) {
local17 = 0;
}
if(local16 > local19) {
local17 *= 1 - (local16 - local19) / (local20 - local19);
}
if(local33 < local31) {
local17 *= (local33 - local32) / (local31 - local32);
}
local3 += local21 * local17;
local4 += local22 * local17;
local5 += local23 * local17;
}
}
}
}
}
local6++;
}
alternativa3d::colorTransform.redMultiplier = local3 / 127.5;
alternativa3d::colorTransform.greenMultiplier = local4 / 127.5;
alternativa3d::colorTransform.blueMultiplier = local5 / 127.5;
}
}
}
|
package alternativa.tanks.model.item.discount {
import alternativa.tanks.model.item.discount.proabonement.ProAbonementRankDiscount;
import flash.utils.getTimer;
import projects.tanks.client.garage.models.item.discount.DiscountCollectorModelBase;
import projects.tanks.client.garage.models.item.discount.IDiscountCollectorModelBase;
[ModelInfo]
public class DiscountCollectorModel extends DiscountCollectorModelBase implements IDiscountCollectorModelBase, IDiscount {
public function DiscountCollectorModel() {
super();
}
public function getDiscountInPercent() : int {
var local2:Number = NaN;
var local1:Number = this.getDiscount();
if(object.hasModel(ProAbonementRankDiscount)) {
local2 = ProAbonementRankDiscount(object.adapt(ProAbonementRankDiscount)).getRankDiscount() * 0.01;
local1 = (local1 - local2) / (1 - local2);
}
return local1 * 100 + 0.0001;
}
public function applyDiscount(param1:int) : int {
var local5:DiscountInfo = null;
var local6:int = 0;
var local2:int = getTimer();
var local3:Vector.<int> = new Vector.<int>();
var local4:DiscountCollector = new DiscountCollector();
ICollectDiscount(object.event(ICollectDiscount)).collectDiscountsInfo(local4);
for each(local5 in local4.getDiscountInfoes()) {
if(local5.hasDiscount() && local5.isDiscountTime(local2)) {
local3.push(local5.getDiscountInPercent());
}
}
local3.sort(Array.NUMERIC);
for each(local6 in local3) {
param1 = int(param1 * (100 - local6) / 100 + 0.001);
}
return param1;
}
private function getDiscount() : Number {
var local4:DiscountInfo = null;
var local1:Number = 0;
var local2:int = getTimer();
var local3:DiscountCollector = new DiscountCollector();
ICollectDiscount(object.event(ICollectDiscount)).collectDiscountsInfo(local3);
for each(local4 in local3.getDiscountInfoes()) {
if(local4.isDiscountTime(local2)) {
local1 = 1 - (1 - local1) * (1 - local4.getDiscountInPercent() * 0.01);
}
}
return local1;
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.battle {
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 BattleNotifierModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattleNotifierModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.init
{
import alternativa.osgi.bundle.IBundleActivator;
public class ProtocolActivator implements IBundleActivator
{
public static var osgi:OSGi;
public function ProtocolActivator()
{
super();
}
public function start(osgi:OSGi) : void
{
ProtocolActivator.osgi = osgi;
}
public function stop(osgi:OSGi) : void
{
ProtocolActivator.osgi = null;
}
}
}
|
package _codec.platform.client.fp10.core.resource.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
public class VectorCodecImageResourceLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecImageResourceLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ImageResource,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<ImageResource> = new Vector.<ImageResource>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ImageResource(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ImageResource = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ImageResource> = Vector.<ImageResource>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.createparams {
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.battleservice.model.createparams.BattleLimits;
public class CodecBattleLimits implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_scoreLimit:ICodec;
private var codec_timeLimitInSec:ICodec;
public function CodecBattleLimits() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_scoreLimit = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_timeLimitInSec = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattleLimits = new BattleLimits();
local2.scoreLimit = this.codec_scoreLimit.decode(param1) as int;
local2.timeLimitInSec = this.codec_timeLimitInSec.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BattleLimits = BattleLimits(param2);
this.codec_scoreLimit.encode(param1,local3.scoreLimit);
this.codec_timeLimitInSec.encode(param1,local3.timeLimitInSec);
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.kits.description.panel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.shopitems.item.kits.description.panel.KitPackageDescriptionPanelBitmaps_bitmapLeftTopCorner.png")]
public class KitPackageDescriptionPanelBitmaps_bitmapLeftTopCorner extends BitmapAsset {
public function KitPackageDescriptionPanelBitmaps_bitmapLeftTopCorner() {
super();
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_blue_OVER_CENTER.png")]
public dynamic class button_blue_OVER_CENTER extends BitmapData {
public function button_blue_OVER_CENTER(param1:int = 201, param2:int = 30) {
super(param1,param2);
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.formatbattle {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.tanksservices.model.formatbattle.EquipmentConstraintsModeInfo;
public class CodecEquipmentConstraintsModeInfo implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_index:ICodec;
private var codec_mode:ICodec;
private var codec_name:ICodec;
public function CodecEquipmentConstraintsModeInfo() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_index = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_mode = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:EquipmentConstraintsModeInfo = new EquipmentConstraintsModeInfo();
local2.index = this.codec_index.decode(param1) as int;
local2.mode = this.codec_mode.decode(param1) as String;
local2.name = this.codec_name.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:EquipmentConstraintsModeInfo = EquipmentConstraintsModeInfo(param2);
this.codec_index.encode(param1,local3.index);
this.codec_mode.encode(param1,local3.mode);
this.codec_name.encode(param1,local3.name);
}
}
}
|
package projects.tanks.client.battlefield.models.inventory.cooldown {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class InventoryCooldownModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:InventoryCooldownModelServer;
private var client:IInventoryCooldownModelBase = IInventoryCooldownModelBase(this);
private var modelId:Long = Long.getLong(169566618,2066569805);
private var _activateCooldownId:Long = Long.getLong(450867590,-1737387168);
private var _activateCooldown_durationCodec:ICodec;
private var _activateDependentCooldownId:Long = Long.getLong(948633528,642461173);
private var _activateDependentCooldown_dependedItemsCodec:ICodec;
private var _readyId:Long = Long.getLong(1014436087,90975169);
private var _setCooldownDurationId:Long = Long.getLong(1069928691,-717266881);
private var _setCooldownDuration_durationCodec:ICodec;
public function InventoryCooldownModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new InventoryCooldownModelServer(IModel(this));
this._activateCooldown_durationCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._activateDependentCooldown_dependedItemsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(DependedCooldownItem,false),false,1));
this._setCooldownDuration_durationCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._activateCooldownId:
this.client.activateCooldown(int(this._activateCooldown_durationCodec.decode(param2)));
break;
case this._activateDependentCooldownId:
this.client.activateDependentCooldown(this._activateDependentCooldown_dependedItemsCodec.decode(param2) as Vector.<DependedCooldownItem>);
break;
case this._readyId:
this.client.ready();
break;
case this._setCooldownDurationId:
this.client.setCooldownDuration(int(this._setCooldownDuration_durationCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_27 extends BitmapAsset
{
public function BigRangIcon_rang_27()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.modification {
import alternativa.types.Long;
public class ModificationCC {
private var _baseItemId:Long;
private var _modificationIndex:int;
public function ModificationCC(param1:Long = null, param2:int = 0) {
super();
this._baseItemId = param1;
this._modificationIndex = param2;
}
public function get baseItemId() : Long {
return this._baseItemId;
}
public function set baseItemId(param1:Long) : void {
this._baseItemId = param1;
}
public function get modificationIndex() : int {
return this._modificationIndex;
}
public function set modificationIndex(param1:int) : void {
this._modificationIndex = param1;
}
public function toString() : String {
var local1:String = "ModificationCC [";
local1 += "baseItemId = " + this.baseItemId + " ";
local1 += "modificationIndex = " + this.modificationIndex + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.tank.ultimate.viking {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.event.TankEntityCreationListener;
import alternativa.tanks.models.tank.hullcommon.HullCommon;
import alternativa.tanks.sfx.Sound3D;
import alternativa.utils.TextureMaterialRegistry;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.ultimate.effects.viking.IVikingUltimateModelBase;
import projects.tanks.client.battlefield.models.ultimate.effects.viking.VikingUltimateModelBase;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
[ModelInfo]
public class VikingUltimateModel extends VikingUltimateModelBase implements IVikingUltimateModelBase, TankEntityCreationListener, ObjectUnloadListener {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
private var vector:Vector3 = new Vector3();
public function VikingUltimateModel() {
super();
}
private function createBurnEffect(param1:IGameObject, param2:TextureMaterial, param3:TextureMaterial, param4:Sound3D) : BurningEffect {
var local5:BurningEffect = BurningEffect(battleService.getObjectPool().getObject(BurningEffect));
var local6:Mesh = ITankModel(param1.adapt(ITankModel)).getTank().getSkin().getHullMesh();
local5.init(param2,param3,local6,param4);
battleService.addGraphicEffect(local5);
var local7:Sound3D = Sound3D.create(getInitParam().effectStartSound.sound);
var local8:GameCamera = battleService.getBattleScene3D().getCamera();
this.vector.reset(local6.x,local6.y,local6.z);
local7.play(0,0);
local7.checkVolume(local8.position,this.vector,local8.xAxis);
return local5;
}
public function effectActivated() : void {
var local1:IGameObject = HullCommon(object.adapt(HullCommon)).getTankObject();
var local2:TextureMaterial = textureMaterialRegistry.getMaterial(getInitParam().flame.data);
var local3:TextureMaterial = textureMaterialRegistry.getMaterial(getInitParam().smoke.data);
var local4:Sound3D = Sound3D.create(getInitParam().effectSound.sound);
var local5:BurningEffect = this.createBurnEffect(local1,local2,local3,local4);
putData(BurningEffect,local5);
}
public function effectDeactivated() : void {
var local2:IGameObject = null;
var local3:Mesh = null;
var local4:Sound3D = null;
var local5:GameCamera = null;
var local1:BurningEffect = BurningEffect(getData(BurningEffect));
if(local1 != null) {
local1.stop();
local2 = HullCommon(object.adapt(HullCommon)).getTankObject();
if(local2.hasModel(ITankModel)) {
local3 = ITankModel(local2.adapt(ITankModel)).getTank().getSkin().getHullMesh();
local4 = Sound3D.create(getInitParam().effectEndSound.sound);
local5 = battleService.getBattleScene3D().getCamera();
this.vector.reset(local3.x,local3.y,local3.z);
local4.play(0,0);
local4.checkVolume(local5.position,this.vector,local5.xAxis);
}
}
}
public function onTankEntityCreated(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
if(getInitParam().effectEnabled) {
this.effectActivated();
}
}
public function objectUnloaded() : void {
var local1:BurningEffect = BurningEffect(getData(BurningEffect));
if(local1 != null) {
local1.stop();
}
}
}
}
|
package alternativa.tanks.models.tank.ultimate.juggernaut {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.effects.ultimate.SparkleSphereEffect;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.hullcommon.HullCommon;
import alternativa.tanks.models.tank.ultimate.UltimateModel;
import alternativa.tanks.sfx.Sound3D;
import flash.geom.ColorTransform;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.ultimate.effects.juggernaut.IJuggernautUltimateModelBase;
import projects.tanks.client.battlefield.models.ultimate.effects.juggernaut.JuggernautUltimateModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class JuggernautUltimateModel extends JuggernautUltimateModelBase implements IJuggernautUltimateModelBase {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleInfoService:IBattleInfoService;
private var vector:Vector3 = new Vector3();
public function JuggernautUltimateModel() {
super();
}
public function showUltimateUsed(param1:Vector.<IGameObject>) : void {
var local3:IGameObject = null;
var local2:IGameObject = HullCommon(object.adapt(HullCommon)).getTankObject();
this.playActivationSound(local2);
this.createSparkleEffect(local2,true);
for each(local3 in param1) {
this.createSparkleEffect(local3,false);
}
}
private function playActivationSound(param1:IGameObject) : * {
var local2:ITankModel = ITankModel(param1.adapt(ITankModel));
var local3:Mesh = local2.getTank().getSkin().getHullMesh();
var local4:Sound3D = Sound3D.create(getInitParam().activateSound.sound);
this.vector.reset(local3.x,local3.y,local3.z);
var local5:GameCamera = battleService.getBattleScene3D().getCamera();
local4.play(0,0);
local4.checkVolume(local5.position,this.vector,local5.xAxis);
}
private function createSparkleEffect(param1:IGameObject, param2:Boolean) : void {
var local3:ITankModel = ITankModel(param1.adapt(ITankModel));
var local4:IGameObject = local3.getTankSet().hull;
var local5:Tank = local3.getTank();
var local6:Boolean = local4 != object;
var local7:TextureMaterial = new TextureMaterial(getInitParam().sparkImage.data);
var local8:ColorTransform = UltimateModel.parseColorTransform(getInitParam().positiveColorTransform);
var local9:ColorTransform = UltimateModel.parseColorTransform(getInitParam().positiveColorTransform);
var local10:SparkleSphereEffect = SparkleSphereEffect(battleService.getObjectPool().getObject(SparkleSphereEffect));
var local11:ColorTransform = param2 ? local8 : local9;
local10.init(local7,local5.getSkin().getHullMesh(),local6,local11);
battleService.addGraphicEffect(local10);
}
}
}
|
package alternativa.tanks.model.payment.modes.description {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
public class PayModeBottomDescriptionAdapt implements PayModeBottomDescription {
private var object:IGameObject;
private var impl:PayModeBottomDescription;
public function PayModeBottomDescriptionAdapt(param1:IGameObject, param2:PayModeBottomDescription) {
super();
this.object = param1;
this.impl = param2;
}
public function getDescription() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getDescription();
}
finally {
Model.popObject();
}
return result;
}
public function getImages() : Vector.<ImageResource> {
var result:Vector.<ImageResource> = null;
try {
Model.object = this.object;
result = this.impl.getImages();
}
finally {
Model.popObject();
}
return result;
}
public function enabled() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.enabled());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package _codec {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
public class VectorCodecStringLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecStringLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(String,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<String> = new Vector.<String>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = String(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:String = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<String> = Vector.<String>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.gui.garagelist {
import controls.timer.CountDownTimer;
import flash.display.DisplayObject;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemCategoryEnum;
public class GarageListRendererData {
public var id:IGameObject;
public var name:String;
public var type:ItemCategoryEnum;
public var mod:int;
public var crystalPrice:int;
public var rank:int;
public var showLockPremium:Boolean;
public var installed:Boolean;
public var garageElement:Boolean;
public var count:int;
public var preview:ImageResource;
public var sort:int;
public var discount:int;
public var timerDiscount:CountDownTimer;
public var iconNormal:DisplayObject;
public var iconSelected:DisplayObject;
public var label:String = "";
public var icon:DisplayObject;
public var source:*;
public var appearanceTime:Number;
public function GarageListRendererData() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank01.png")]
public class DefaultRanksBitmaps_bitmapSmallRank01 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank01() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapUpgradeTableLeft extends BitmapAsset
{
public function ItemInfoPanel_bitmapUpgradeTableLeft()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.kit {
import platform.client.fp10.core.type.IGameObject;
public class KitItem {
private var _count:int;
private var _item:IGameObject;
private var _mount:Boolean;
public function KitItem(param1:int = 0, param2:IGameObject = null, param3:Boolean = false) {
super();
this._count = param1;
this._item = param2;
this._mount = param3;
}
public function get count() : int {
return this._count;
}
public function set count(param1:int) : void {
this._count = param1;
}
public function get item() : IGameObject {
return this._item;
}
public function set item(param1:IGameObject) : void {
this._item = param1;
}
public function get mount() : Boolean {
return this._mount;
}
public function set mount(param1:Boolean) : void {
this._mount = param1;
}
public function toString() : String {
var local1:String = "KitItem [";
local1 += "count = " + this.count + " ";
local1 += "item = " + this.item + " ";
local1 += "mount = " + this.mount + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.matchmaking.group {
import alternativa.tanks.service.matchmaking.MatchmakingGroupFormService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.IMatchmakingGroupNotifyModelBase;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MatchmakingGroupNotifyModelBase;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MatchmakingUserData;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MountItemsUserData;
import projects.tanks.clients.fp10.libraries.tanksservices.service.matchmakinggroup.MatchmakingGroupService;
[ModelInfo]
public class MatchmakingGroupNotifyModel extends MatchmakingGroupNotifyModelBase implements IMatchmakingGroupNotifyModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var matchmakingFormService:MatchmakingGroupFormService;
[Inject]
public static var matchmakingGroupService:MatchmakingGroupService;
public function MatchmakingGroupNotifyModel() {
super();
}
public function objectLoaded() : void {
var local2:MatchmakingUserData = null;
var local1:Boolean = false;
for each(local2 in getInitParam().users) {
if(local2.leader && local2.local) {
local1 = true;
break;
}
}
if(local1) {
matchmakingGroupService.enableGroupInvite();
} else {
matchmakingGroupService.disableGroupInvite();
}
matchmakingFormService.showGroupView(getInitParam().users,local1);
}
public function objectUnloaded() : void {
matchmakingFormService.hideGroupView();
matchmakingGroupService.disableGroupInvite();
}
public function addUser(param1:MatchmakingUserData) : void {
matchmakingFormService.addUserToGroup(param1);
}
public function removeUser(param1:Long) : void {
matchmakingFormService.removeUserFromGroup(param1);
}
public function userReady(param1:Long) : void {
matchmakingFormService.showUserReady(param1);
}
public function userNotReady(param1:Long) : void {
matchmakingFormService.showUserNotReady(param1);
}
public function userMountedItem(param1:MountItemsUserData) : void {
matchmakingFormService.updateMountedItem(param1);
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.shopitems.item.base.GreenShopItemSkin_normalStateClass.png")]
public class GreenShopItemSkin_normalStateClass extends BitmapAsset {
public function GreenShopItemSkin_normalStateClass() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank23.png")]
public class DefaultRanksBitmaps_bitmapSmallRank23 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank23() {
super();
}
}
}
|
package controls.checkbox {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.checkbox.CheckBoxBase_checkboxUpClass.png")]
public class CheckBoxBase_checkboxUpClass extends BitmapAsset {
public function CheckBoxBase_checkboxUpClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.videoads {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.videoads.VideoAdsItemUpgradeCC;
public class CodecVideoAdsItemUpgradeCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_cooldownTimeInSec:ICodec;
private var codec_timeToReduceUpdateInMin:ICodec;
public function CodecVideoAdsItemUpgradeCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_cooldownTimeInSec = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_timeToReduceUpdateInMin = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:VideoAdsItemUpgradeCC = new VideoAdsItemUpgradeCC();
local2.cooldownTimeInSec = this.codec_cooldownTimeInSec.decode(param1) as int;
local2.timeToReduceUpdateInMin = this.codec_timeToReduceUpdateInMin.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:VideoAdsItemUpgradeCC = VideoAdsItemUpgradeCC(param2);
this.codec_cooldownTimeInSec.encode(param1,local3.cooldownTimeInSec);
this.codec_timeToReduceUpdateInMin.encode(param1,local3.timeToReduceUpdateInMin);
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
public class RocketTargetPoint {
private var lost:Boolean;
private var tank:Tank;
private var localPoint:Vector3 = new Vector3();
public function RocketTargetPoint() {
super();
}
public function setTank(param1:Tank) : void {
this.tank = param1;
this.lost = false;
}
public function setLocalPoint(param1:Vector3) : void {
this.localPoint.copy(param1);
this.lost = false;
}
public function resetTarget() : void {
this.tank = null;
this.lost = false;
}
public function isAlive() : Boolean {
return this.hasTarget() && this.tank.state == ClientTankState.ACTIVE;
}
public function isSameTank(param1:Tank) : Boolean {
return param1 == this.tank;
}
public function hasTarget() : Boolean {
return this.tank != null && this.tank.getBody() != null;
}
public function getTank() : Tank {
return this.tank;
}
public function getLocalPoint() : Vector3 {
return this.localPoint;
}
public function isLost() : Boolean {
return this.lost;
}
public function markAsLost() : void {
this.lost = true;
}
}
}
|
package projects.tanks.client.panel.model.videoads.containers {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
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 VideoAdsMobileLootBoxModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _showedId:Long = Long.getLong(1804020510,-1424776230);
private var model:IModel;
public function VideoAdsMobileLootBoxModelServer(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());
}
public function showed() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._showedId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol209")]
public dynamic class MainPanelAddButton extends BaseButton {
public function MainPanelAddButton() {
super();
}
}
}
|
package alternativa.tanks.models.battle.meteor {
import alternativa.math.Vector3;
public interface MeteorFlamePositionProvider {
function getPosition() : Vector3;
}
}
|
package projects.tanks.clients.flash.commons.services.autobattleenter {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.command.FormattedOutput;
import alternativa.osgi.service.logging.LogService;
import flash.events.EventDispatcher;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
public class AutomaticEnterExitService extends EventDispatcher {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var logService:LogService;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
private var enabledBattle:Boolean;
private var enabledGarage:Boolean;
private var enabledPayment:Boolean;
private var joinAsSpectator:Boolean;
private var countEntrance:int;
private var maxEntrance:int;
private var memoryGraph:Vector.<Number> = new Vector.<Number>();
public function AutomaticEnterExitService(param1:OSGi) {
super();
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
}
private function switchGarage(param1:LayoutState) : void {
}
private function _enableForPayment(param1:FormattedOutput, param2:int) : void {
}
private function _enableForGarage(param1:FormattedOutput, param2:int) : void {
}
private function _enableForSpectator(param1:FormattedOutput, param2:int) : void {
}
private function _enableForRegularUser(param1:FormattedOutput, param2:int) : void {
}
private function _enableBattle(param1:Boolean, param2:int) : void {
}
private function _disable(param1:FormattedOutput) : void {
}
private function _traceMemoryGraph(param1:FormattedOutput) : void {
}
public function onBattleInfoLoaded() : void {
}
private function saveMemory() : void {
}
public function onBattleLoaded() : void {
}
}
}
|
package alternativa.tanks.gui.clanmanagement.clanmemberlist {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ISourceDataAdapt implements ISourceData {
private var object:IGameObject;
private var impl:ISourceData;
public function ISourceDataAdapt(param1:IGameObject, param2:ISourceData) {
super();
this.object = param1;
this.impl = param2;
}
public function addByUid(param1:String) : void {
var name:String = param1;
try {
Model.object = this.object;
this.impl.addByUid(name);
}
finally {
Model.popObject();
}
}
public function checkUid(param1:String) : void {
var name:String = param1;
try {
Model.object = this.object;
this.impl.checkUid(name);
}
finally {
Model.popObject();
}
}
public function setSearchInput(param1:ISearchInput) : void {
var view:ISearchInput = param1;
try {
Model.object = this.object;
this.impl.setSearchInput(view);
}
finally {
Model.popObject();
}
}
public function accept(param1:Long) : void {
var userId:Long = param1;
try {
Model.object = this.object;
this.impl.accept(userId);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.sfx.levelup {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.display.BlendMode;
public class LightWaveEffect extends PooledObject implements GraphicEffect {
private static const vector:Vector3 = new Vector3();
private var wave:Sprite3D;
private var delay:int;
private var time:int;
private var maxScale:Number;
private var direction:Boolean;
private var turret:Object3D;
private var state:int;
private var container:Scene3DContainer;
public function LightWaveEffect(param1:Pool) {
super(param1);
this.wave = new Sprite3D(10,10);
this.wave.blendMode = BlendMode.ADD;
}
public function init(param1:int, param2:Number, param3:Number, param4:Boolean, param5:Object3D, param6:TextureMaterial) : void {
this.delay = param1;
this.wave.width = param2;
this.wave.height = param2;
this.wave.calculateBounds();
this.maxScale = param3;
this.direction = param4;
this.turret = param5;
param6.resolution = 5;
this.wave.material = param6;
this.wave.scaleX = 1;
this.wave.scaleY = 1;
this.wave.scaleZ = 1;
this.wave.rotation = 0;
this.wave.alpha = 0;
this.state = 0;
this.wave.softAttenuation = 150;
this.wave.depthMapAlphaThreshold = 2;
this.wave.shadowMapAlphaThreshold = 2;
this.wave.useShadowMap = false;
this.wave.useLight = false;
this.time = 0;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.wave);
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
if(this.state == 2) {
return false;
}
var local3:Number = 0.7 * 5;
var local4:Number = local3 / 3;
var local5:Number = 0.2;
local6 = 300;
vector.x = param2.x - this.turret.x;
vector.y = param2.y - this.turret.y;
vector.z = param2.z - this.turret.z;
vector.normalize();
vector.scale(local6);
this.wave.x = this.turret.x + vector.x;
this.wave.y = this.turret.y + vector.y;
this.wave.z = this.turret.z + vector.z + 30;
this.time += param1;
if(this.time >= this.delay) {
if(this.direction) {
this.wave.rotation += local5 * param1 * 0.001;
} else {
this.wave.rotation -= local5 * param1 * 0.001;
}
if(this.state == 0) {
local7 = local3 * param1 * 0.001;
this.wave.scaleX += local7;
this.wave.scaleY += local7;
this.wave.scaleZ += local7;
if(this.wave.scaleX > this.maxScale) {
this.wave.scaleX = this.maxScale;
this.wave.scaleY = this.maxScale;
this.wave.scaleZ = this.maxScale;
this.state = 1;
}
this.wave.alpha = (this.wave.scaleX - 1) / (this.maxScale - 1);
} else if(this.state == 1) {
local8 = local4 * param1 * 0.001;
this.wave.scaleX -= local8;
this.wave.scaleY -= local8;
this.wave.scaleZ -= local8;
if(this.wave.scaleX < 1) {
this.wave.scaleX = 1;
this.wave.scaleY = 1;
this.wave.scaleZ = 1;
this.state = 2;
}
this.wave.alpha = (this.wave.scaleX - 1) / (this.maxScale - 1) - 0.1;
}
}
return true;
}
public function destroy() : void {
this.container.removeChild(this.wave);
this.container = null;
this.wave.material = null;
recycle();
}
public function kill() : void {
this.state = 2;
this.wave.alpha = 0;
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.specialkit.view.singleitem {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.specialkit.view.singleitem.SingleItemKitViewCC;
public class VectorCodecSingleItemKitViewCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecSingleItemKitViewCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(SingleItemKitViewCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<SingleItemKitViewCC> = new Vector.<SingleItemKitViewCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = SingleItemKitViewCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:SingleItemKitViewCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<SingleItemKitViewCC> = Vector.<SingleItemKitViewCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.weapon.gauss {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class GaussSkinAdapt implements GaussSkin {
private var object:IGameObject;
private var impl:GaussSkin;
public function GaussSkinAdapt(param1:IGameObject, param2:GaussSkin) {
super();
this.object = param1;
this.impl = param2;
}
public function getSkin() : GaussTurretSkin {
var result:GaussTurretSkin = null;
try {
Model.object = this.object;
result = this.impl.getSkin();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class CallsignCheckResultEvent extends Event {
public static const CALLSIGN_IS_BUSY:String = "CallsignCheckResultEvent.CALLSIGN_IS_BUSY";
public static const CALLSIGN_IS_FREE:String = "CallsignCheckResultEvent.CALLSIGN_IS_FREE";
public static const CALLSIGN_IS_INCORRECT:String = "CallsignCheckResultEvent.CALLSIGN_IS_INCORRECT";
private var _freeUids:Vector.<String>;
public function CallsignCheckResultEvent(param1:String) {
super(param1);
}
public function get freeUids() : Vector.<String> {
return this._freeUids;
}
public function set freeUids(param1:Vector.<String>) : void {
this._freeUids = param1;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices {
import flash.events.Event;
public class AlertServiceEvent extends Event {
public static const ALERT_BUTTON_PRESSED:String = "AlertServiceEvent.ALERT_BUTTON_PRESSED";
public var typeButton:String;
public function AlertServiceEvent(param1:String, param2:String, param3:Boolean = false, param4:Boolean = false) {
super(param1,param3,param4);
this.typeButton = param2;
}
}
}
|
package projects.tanks.client.garage.models.garage.present {
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 PresentPurchaseModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _checkUidId:Long = Long.getLong(1646969835,427146179);
private var _checkUid_uidCodec:ICodec;
private var _purchasePresentId:Long = Long.getLong(169296918,-2003348677);
private var _purchasePresent_recipientUidCodec:ICodec;
private var _purchasePresent_presentItemCodec:ICodec;
private var _purchasePresent_textCodec:ICodec;
private var _purchasePresent_expectedPriceCodec:ICodec;
private var model:IModel;
public function PresentPurchaseModelServer(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._checkUid_uidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._purchasePresent_recipientUidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._purchasePresent_presentItemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._purchasePresent_textCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._purchasePresent_expectedPriceCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function checkUid(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._checkUid_uidCodec.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._checkUidId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function purchasePresent(param1:String, param2:IGameObject, param3:String, param4:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._purchasePresent_recipientUidCodec.encode(this.protocolBuffer,param1);
this._purchasePresent_presentItemCodec.encode(this.protocolBuffer,param2);
this._purchasePresent_textCodec.encode(this.protocolBuffer,param3);
this._purchasePresent_expectedPriceCodec.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._purchasePresentId,this.protocolBuffer);
var local6:IGameObject = Model.object;
var local7:ISpace = local6.space;
local7.commandSender.sendCommand(local5);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.garage.models.item.premium {
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 PremiumItemModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PremiumItemModelServer;
private var client:IPremiumItemModelBase = IPremiumItemModelBase(this);
private var modelId:Long = Long.getLong(265351749,620223358);
public function PremiumItemModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PremiumItemModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(PremiumItemCC,false)));
}
protected function getInitParam() : PremiumItemCC {
return PremiumItemCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.weapon.twins {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.engine3d.EffectsMaterialRegistry;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import alternativa.tanks.utils.GraphicsUtils;
import flash.display.BitmapData;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.shoot.twins.ITwinsShootSFXModelBase;
import projects.tanks.client.battlefield.models.tankparts.sfx.shoot.twins.TwinsShootSFXCC;
import projects.tanks.client.battlefield.models.tankparts.sfx.shoot.twins.TwinsShootSFXModelBase;
[ModelInfo]
public class TwinsSFXModel extends TwinsShootSFXModelBase implements ITwinsShootSFXModelBase, ObjectLoadPostListener, ObjectUnloadListener, ITwinsSFXModel {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:EffectsMaterialRegistry;
public function TwinsSFXModel() {
super();
}
private static function getMuzzleFlashMaterial(param1:BitmapData) : TextureMaterial {
var local2:TextureMaterial = materialRegistry.getMaterial(param1);
local2.resolution = TwinsEffects.FLASH_SIZE / param1.height;
return local2;
}
private static function getPlasmaAnimation(param1:MultiframeTextureResource) : TextureAnimation {
return getTextureAnimation(param1,TwinsShotParams.SPRITE_SIZE);
}
private static function getExplosionAnimation(param1:MultiframeTextureResource) : TextureAnimation {
return getTextureAnimation(param1,TwinsShotParams.EXPLOSION_SPRITE_SIZE);
}
private static function getTextureAnimation(param1:MultiframeTextureResource, param2:Number) : TextureAnimation {
var local3:TextureAnimation = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,param1);
local3.material.resolution = param2 / param1.frameWidth;
return local3;
}
private static function releaseMaterials(param1:TwinsSFXData) : void {
materialRegistry.releaseMaterial(param1.muzzleFlashMaterial);
materialRegistry.releaseMaterial(param1.shotAnimation.material);
materialRegistry.releaseMaterial(param1.explosionAnimation.material);
materialRegistry.releaseMaterial(param1.hitMarkMaterial);
}
public function getPlasmaWeaponEffects() : TwinsEffects {
return TwinsEffects(getData(TwinsEffects));
}
public function getSFXData() : TwinsSFXData {
return TwinsSFXData(getData(TwinsSFXData));
}
[Obfuscation(rename="false")]
public function objectLoadedPost() : void {
var local1:TwinsShootSFXCC = getInitParam();
var local2:TwinsSFXData = new TwinsSFXData();
local2.muzzleFlashMaterial = getMuzzleFlashMaterial(local1.muzzleFlashTexture.data);
local2.shotAnimation = getPlasmaAnimation(local1.shotTexture);
local2.explosionAnimation = getExplosionAnimation(local1.explosionTexture);
local2.hitMarkMaterial = materialRegistry.getMaterial(local1.hitMarkTexture.data);
local2.shotSound = local1.shotSound.sound;
var local3:LightingSfx = new LightingSfx(getInitParam().lightingSFXEntity);
local2.shotLightingAnimation = local3.createAnimation("shot");
local2.shellLightingAnimation = local3.createAnimation("bullet");
local2.hitLightingAnimation = local3.createAnimation("hit");
putData(TwinsSFXData,local2);
putData(TwinsEffects,new TwinsEffects(battleService,local2));
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
releaseMaterials(this.getSFXData());
}
}
}
|
package alternativa.tanks.models.mapbonuslight {
import flash.geom.ColorTransform;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IMapBonusLightAdapt implements IMapBonusLight {
private var object:IGameObject;
private var impl:IMapBonusLight;
public function IMapBonusLightAdapt(param1:IGameObject, param2:IMapBonusLight) {
super();
this.object = param1;
this.impl = param2;
}
public function getBonusLightIntensity() : Number {
var result:Number = NaN;
try {
Model.object = this.object;
result = Number(this.impl.getBonusLightIntensity());
}
finally {
Model.popObject();
}
return result;
}
public function getHWBonusColorAdjust() : ColorTransform {
var result:ColorTransform = null;
try {
Model.object = this.object;
result = this.impl.getHWBonusColorAdjust();
}
finally {
Model.popObject();
}
return result;
}
public function getSoftBonusColorAdjust() : ColorTransform {
var result:ColorTransform = null;
try {
Model.object = this.object;
result = this.impl.getSoftBonusColorAdjust();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battleservice.model.statistics.dm {
import projects.tanks.client.battleservice.model.statistics.UserInfo;
public class StatisticsDMCC {
private var _usersInfo:Vector.<UserInfo>;
public function StatisticsDMCC(param1:Vector.<UserInfo> = null) {
super();
this._usersInfo = param1;
}
public function get usersInfo() : Vector.<UserInfo> {
return this._usersInfo;
}
public function set usersInfo(param1:Vector.<UserInfo>) : void {
this._usersInfo = param1;
}
public function toString() : String {
var local1:String = "StatisticsDMCC [";
local1 += "usersInfo = " + this.usersInfo + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.shotgun {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionFilter;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.RayCollisionFilter;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.angles.verticals.autoaiming.VerticalAutoAiming;
import alternativa.tanks.models.weapon.shared.CommonTargetEvaluator;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.aiming.ShotGunAimingCC;
public class ShotgunRicochetTargetingSystem implements IRayCollisionFilter {
[Inject]
public static var battleService:BattleService;
private static const rayHit:RayHit = new RayHit();
private static const currOrigin:Vector3 = new Vector3();
private static const currDirection:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private static const matrix:Matrix3 = new Matrix3();
private var maxDistance:Number;
private var targetEvaluator:CommonTargetEvaluator;
private var ricochetCount:int;
private var shooterBody:Body;
private var collisionDetector:TanksCollisionDetector;
private var maxRicochetCount:int;
private var directions:Vector.<ShotgunTargetingDirection>;
private var pelletDirectionGenerator:PelletDirectionCalculator;
private var collisionFilter:RayCollisionFilter = new RayCollisionFilter();
private var autoAiming:VerticalAutoAiming;
private var bestDirectionIndexs:Vector.<int>;
private var angleStep:Number;
private var countSectors:int;
private var lengthDirections:int;
public function ShotgunRicochetTargetingSystem(param1:WeaponObject, param2:PelletDirectionCalculator, param3:ShotGunAimingCC) {
super();
this.collisionFilter.exclusion = this.shooterBody;
this.autoAiming = param1.verticalAutoAiming();
this.maxDistance = param1.distanceWeakening().getDistance();
this.targetEvaluator = battleService.getCommonTargetEvaluator();
this.collisionDetector = battleService.getBattleRunner().getCollisionDetector();
this.pelletDirectionGenerator = param2;
this.maxRicochetCount = 1;
this.lengthDirections = this.autoAiming.getNumRaysUp() + this.autoAiming.getNumRaysDown() + 1;
this.directions = new Vector.<ShotgunTargetingDirection>(this.lengthDirections);
this.angleStep = (this.autoAiming.getElevationAngleDown() + this.autoAiming.getElevationAngleUp()) / (this.autoAiming.getNumRaysDown() + this.autoAiming.getNumRaysUp());
this.countSectors = param3.coneVerticalAngle / this.angleStep;
this.bestDirectionIndexs = new Vector.<int>(this.countSectors);
}
public function considerBody(param1:Body) : Boolean {
return this.shooterBody != param1 || this.ricochetCount > 0;
}
public function getShotDirection(param1:AllGlobalGunParams, param2:Body, param3:Vector3) : Vector.<Tank> {
var local7:Number = NaN;
var local8:ShotgunTargetingDirection = null;
param3.copy(param1.direction);
this.shooterBody = param2;
var local4:int = 0;
var local5:Number = -this.autoAiming.getElevationAngleDown();
direction.copy(param1.direction);
matrix.fromAxisAngle(param1.elevationAxis,-this.autoAiming.getElevationAngleDown());
direction.transform3(matrix);
matrix.fromAxisAngle(param1.elevationAxis,this.angleStep);
while(local5 < this.autoAiming.getElevationAngleUp() + this.angleStep && local4 < this.lengthDirections) {
local7 = this.procesingHitAndGetTargetPriority(param1.barrelOrigin,direction,local5);
local8 = this.directions[local4];
if(local8 == null) {
local8 = new ShotgunTargetingDirection(direction,local7);
} else {
local8.init(direction,local7);
}
this.directions[local4] = local8;
local4++;
local5 += this.angleStep;
direction.transform3(matrix);
}
this.finishTargetSearch(param3);
var local6:Vector.<Tank> = new Vector.<Tank>();
this.processDirection(param3,param1,local6);
return local6;
}
private function procesingHitAndGetTargetPriority(param1:Vector3, param2:Vector3, param3:Number) : Number {
var local5:Body = null;
this.ricochetCount = 0;
currOrigin.copy(param1);
currDirection.copy(param2);
var local4:Number = this.maxDistance;
while(local4 > 0) {
if(!this.collisionDetector.raycast(currOrigin,currDirection,CollisionGroup.WEAPON,local4,this,rayHit)) {
return 0;
}
local4 -= rayHit.t;
if(local4 < 0) {
local4 = 0;
}
local5 = rayHit.shape.body;
if(local5.tank != null && local5 != this.shooterBody) {
return this.calculateTargetPriority(local5,local4,param3);
}
if(local5.tank != null) {
return 0;
}
if(!this.processRicochet()) {
return 0;
}
}
return 0;
}
private function calculateTargetPriority(param1:Body, param2:Number, param3:Number) : Number {
var local4:Number = this.maxDistance - param2;
return this.targetEvaluator.getTargetPriority(param1,local4,param3,this.maxDistance,Math.max(this.autoAiming.getElevationAngleUp(),this.autoAiming.getElevationAngleDown()));
}
private function processRicochet() : Boolean {
var local1:Vector3 = null;
if(this.ricochetCount < this.maxRicochetCount) {
++this.ricochetCount;
local1 = rayHit.normal;
currDirection.addScaled(-2 * currDirection.dot(local1),local1);
currOrigin.copy(rayHit.position).addScaled(0.5,local1);
return true;
}
return false;
}
private function finishTargetSearch(param1:Vector3) : void {
var local6:Number = NaN;
var local7:int = 0;
var local8:int = 0;
var local9:int = 0;
this.shooterBody = null;
var local2:Number = 0;
var local3:int = 0;
var local4:int = 0;
while(local4 < this.directions.length) {
local6 = 0;
local7 = this.countSectors / 2;
local8 = -local7;
while(local8 <= local7) {
local9 = local4 + local8;
if(local9 >= 0 && local9 < this.directions.length) {
local6 += this.directions[local9].getMaxPriority();
}
local8++;
}
if(local2 < local6) {
local2 = local6;
local3 = 0;
this.bestDirectionIndexs[local3] = local4;
} else if(local6 == local2 && local6 > 0) {
local3++;
this.bestDirectionIndexs[local3] = local4;
}
local4++;
}
var local5:ShotgunTargetingDirection = this.directions[this.bestDirectionIndexs[local3 >> 1]];
if(local5.getMaxPriority() > 0) {
param1.copy(local5.getDirection());
}
}
private function processDirection(param1:Vector3, param2:AllGlobalGunParams, param3:Vector.<Tank>) : void {
var local5:Vector3 = null;
var local4:Vector.<Vector3> = this.pelletDirectionGenerator.getDirectionsFor(param2.elevationAxis,param1.clone());
param3.length = 0;
for each(param1 in local4) {
if(!this.addTargetIfCollision(param2.barrelOrigin,param1,this.maxDistance,param3)) {
local5 = rayHit.normal;
currDirection.addScaled(-2 * currDirection.dot(local5),local5);
currOrigin.copy(rayHit.position).addScaled(0.5,local5);
this.addTargetIfCollision(currOrigin,currDirection,this.maxDistance,param3);
}
}
}
private function addTargetIfCollision(param1:Vector3, param2:Vector3, param3:Number, param4:Vector.<Tank>) : Boolean {
var local5:Tank = null;
if(this.collisionDetector.raycast(param1,param2,CollisionGroup.WEAPON,param3,this.collisionFilter,rayHit)) {
local5 = rayHit.shape.body.tank;
if(local5 != null) {
param4.push(local5);
return true;
}
}
return false;
}
}
}
|
package projects.tanks.client.panel.model.challenge.rewarding {
public class ChallengeRewardsCC {
private var _tiers:Vector.<Tier>;
public function ChallengeRewardsCC(param1:Vector.<Tier> = null) {
super();
this._tiers = param1;
}
public function get tiers() : Vector.<Tier> {
return this._tiers;
}
public function set tiers(param1:Vector.<Tier>) : void {
this._tiers = param1;
}
public function toString() : String {
var local1:String = "ChallengeRewardsCC [";
local1 += "tiers = " + this.tiers + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.servermodels {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ILeavableEntranceStateEvents implements ILeavableEntranceState {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ILeavableEntranceStateEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function leave() : void {
var i:int = 0;
var m:ILeavableEntranceState = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ILeavableEntranceState(this.impl[i]);
m.leave();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.statistics {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.notificationpausefinish.NotificationEndsPauseSupport;
import alternativa.tanks.models.battle.battlefield.BattleModel;
import alternativa.tanks.models.battle.battlefield.BattleType;
import alternativa.tanks.models.battle.battlefield.event.BattleRenameEvent;
import alternativa.tanks.models.battle.ctf.MessageColor;
import alternativa.tanks.models.battle.gui.BattlefieldGUI;
import alternativa.tanks.models.battle.gui.chat.IBattleChat;
import alternativa.tanks.models.battle.gui.gui.statistics.field.Widget;
import alternativa.tanks.models.battle.gui.gui.statistics.field.score.BattleStatistics;
import alternativa.tanks.models.battle.gui.gui.statistics.field.wink.WinkManager;
import alternativa.tanks.models.battle.gui.gui.statistics.fps.FPSText;
import alternativa.tanks.models.battle.gui.gui.statistics.messages.BattleMessages;
import alternativa.tanks.models.battle.gui.gui.statistics.messages.UserAction;
import alternativa.tanks.models.battle.gui.statistics.DefaultLayout;
import alternativa.tanks.models.battle.gui.statistics.ShortUserInfo;
import alternativa.tanks.models.battlemessages.BattlefieldMessages;
import alternativa.tanks.models.tank.LocalTankInfoService;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.types.Long;
import alternativa.utils.removeDisplayObject;
import flash.display.DisplayObjectContainer;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.types.DamageType;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.client.battleservice.model.statistics.IStatisticsModelBase;
import projects.tanks.client.battleservice.model.statistics.StatisticsModelBase;
import projects.tanks.client.battleservice.model.statistics.UserReward;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.IHelpService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleFormatUtil;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleInfoUtils;
[ModelInfo]
public class StatisticsModel extends StatisticsModelBase implements IStatisticsModelBase, IStatisticsModel, ObjectLoadListener, ObjectLoadPostListener, ObjectUnloadListener, BattlefieldGUI, LogicUnit {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var helpService:IHelpService;
[Inject]
public static var battleGUIService:BattleGUIService;
[Inject]
public static var battleFormatUtil:BattleFormatUtil;
[Inject]
public static var localTankInfoService:LocalTankInfoService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private var playerJoinedMessage:String;
private var playerLeftMessage:String;
private var fpsIndicator:FPSText;
private var battleMessages:BattleMessages;
private var battlefieldMessages:BattlefieldMessages;
private var battleStatistics:BattleStatistics;
private var defaultLayout:DefaultLayout;
public function StatisticsModel() {
super();
this.fpsIndicator = new FPSText();
WinkManager.init(500);
}
public function runLogic(param1:int, param2:int) : void {
this.battlefieldMessages.update(param2);
}
public function getBattleName() : String {
if(Boolean(getInitParam().battleName)) {
return getInitParam().battleName;
}
return this.getDefaultBattleName();
}
private function getDefaultBattleName() : String {
var local1:String = !!getInitParam().matchBattle ? BattleInfoUtils.buildBattleName(getInitParam().mapName,getInitParam().modeName) : getInitParam().mapName;
var local2:String = getInitParam().equipmentConstraintsMode;
var local3:Boolean = Boolean(getInitParam().parkourMode);
if(battleFormatUtil.isFormatBattle(local2,local3)) {
local1 = local1 + " " + battleFormatUtil.getShortFormatName(local2,local3);
}
return local1;
}
public function userConnect(param1:ShortUserInfo) : void {
this.battleMessages.addUserActionMessage(param1,UserAction.PLAYER_JOIN_THE_BATTLE);
}
public function userDisconnect(param1:ShortUserInfo) : void {
this.battleMessages.addUserActionMessage(param1,UserAction.PLAYER_LEAVE_THE_BATTLE);
}
public function updateUserKills(param1:Long, param2:int) : void {
this.battleStatistics.updateUserKills(param1,param2);
}
public function changeTeamScore(param1:BattleTeam, param2:int) : void {
this.battleStatistics.setTeamScore(param1,param2);
}
public function logUserAction(param1:Long, param2:UserAction, param3:Long) : void {
var local4:IClientUserInfo = IClientUserInfo(object.adapt(IClientUserInfo));
var local5:ShortUserInfo = local4.getShortUserInfo(param1);
var local6:ShortUserInfo = param3 == null ? null : local4.getShortUserInfo(param3);
this.battleMessages.addTwoUsersActionMessage(local5,param2,local6);
}
public function logKillAction(param1:Long, param2:Long, param3:DamageType) : void {
var local4:IClientUserInfo = IClientUserInfo(object.adapt(IClientUserInfo));
var local5:ShortUserInfo = local4.getShortUserInfo(param1);
var local6:ShortUserInfo = local4.getShortUserInfo(param2);
this.battleMessages.addKillMessage(local5,local6,param3);
}
public function setIndicatorState(param1:BattleTeam, param2:int) : void {
this.battleStatistics.setIndicatorState(param1,param2);
}
public function setBothIndicatorsState(param1:int, param2:int) : void {
this.battleStatistics.setBothIndicatorsState(param1,param2);
}
public function showBattleMessage(param1:uint, param2:String) : void {
this.battlefieldMessages.addMessage(param1,param2);
}
public function showPointBattleLogMessage(param1:String, param2:UserAction) : void {
this.battleMessages.addPointActionMessage(param1,param2);
}
public function showUserBattleLogMessage(param1:Long, param2:UserAction) : void {
var local3:IClientUserInfo = IClientUserInfo(object.adapt(IClientUserInfo));
var local4:ShortUserInfo = local3.getShortUserInfo(param1);
if(Boolean(local4)) {
this.battleMessages.addUserActionMessage(local4,param2);
}
}
public function showBattleLogMessage(param1:UserAction) : void {
this.battleMessages.addSimpleActionMessage(param1);
}
public function addWidget(param1:Widget) : void {
this.defaultLayout.addWidget(param1);
}
[Obfuscation(rename="false")]
public function objectLoaded() : void {
battleInfoService.running = getInitParam().running;
this.playerJoinedMessage = localeService.getText(TanksLocale.TEXT_BATTLE_PLAYER_JOINED);
this.playerLeftMessage = localeService.getText(TanksLocale.TEXT_BATTLE_PLAYER_LEFT);
var local1:BattleUserInfoServiceImpl = new BattleUserInfoServiceImpl(object);
putData(BattleUserInfoServiceImpl,local1);
putData(PauseIndicatorSupport,new PauseIndicatorSupport());
putData(NotificationEndsPauseSupport,new NotificationEndsPauseSupport());
putData(TankKillLogger,new TankKillLogger(object));
putData(FpsIndicatorToggleSupport,new FpsIndicatorToggleSupport(this.fpsIndicator));
var local2:DisplayObjectContainer = battleGUIService.getGuiContainer();
var local3:BattleType = BattleModel(object.adapt(BattleModel)).getBattleType();
var local4:Boolean = Boolean(getInitParam().valuableRound);
this.battleStatistics = new BattleStatistics(userPropertiesService.userId,getInitParam(),local3,local4);
local2.addChild(this.battleStatistics);
this.defaultLayout = new DefaultLayout();
this.defaultLayout.addWidget2(this.battleStatistics);
this.defaultLayout.init();
this.battlefieldMessages = new BattlefieldMessages();
local2.addChild(this.battlefieldMessages);
putData(BattlefieldMessagesAligner,new BattlefieldMessagesAligner(this.battlefieldMessages));
this.battleMessages = new BattleMessages();
local2.addChild(this.battleMessages);
if(settingsService.showFPS) {
local2.addChild(this.fpsIndicator);
}
if(getInitParam().spectator) {
this.createSpectatorScreenLayouts();
} else {
putData(ControlsMiniHelpSupport,new ControlsMiniHelpSupport());
putData(ControlsHelpSupport,new ControlsHelpSupport());
}
}
private function battleHasTimeLimit() : Boolean {
return getInitParam().limits.timeLimitInSec != 0;
}
[Obfuscation(rename="false")]
public function objectLoadedPost() : void {
var local1:Boolean = false;
this.markSuspectedUsers(getInitParam().suspiciousUserIds);
battleService.getBattleRunner().addLogicUnit(this);
if(this.battleHasTimeLimit()) {
local1 = Boolean(getInitParam().spectator);
if(!local1 || local1 && this.battleUserInfoService().getUsersCount() > 0) {
this.battleStatistics.startCountdownTimeLimit(getInitParam().timeLeft);
}
}
}
private function createSpectatorScreenLayouts() : void {
var local1:IBattleChat = IBattleChat(object.adapt(IBattleChat));
putData(SpectatorScreenLayouts,new SpectatorScreenLayouts(local1.getChat(),this.battleMessages,this.battlefieldMessages,this.battleStatistics,this.fpsIndicator));
}
private function markSuspectedUsers(param1:Vector.<Long>) : void {
var local2:Long = null;
for each(local2 in param1) {
this.setUserSuspiciousness(local2,true);
}
}
private function setUserSuspiciousness(param1:Long, param2:Boolean) : void {
var local3:IClientUserInfo = IClientUserInfo(object.adapt(IClientUserInfo));
local3.suspiciousnessChanged(param1,param2);
var local4:BattleUserInfoServiceImpl = this.battleUserInfoService();
local4.dispatchSuspiciousnessChange(param1,param2);
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
removeDisplayObject(this.battleStatistics);
removeDisplayObject(this.battleMessages);
removeDisplayObject(this.fpsIndicator);
this.battleStatistics = null;
battleService.getBattleRunner().removeLogicUnit(this);
this.battleMessages = null;
this.battlefieldMessages.removeFromParent();
this.battlefieldMessages = null;
this.defaultLayout.destroy();
this.defaultLayout = null;
}
[Obfuscation(rename="false")]
public function fundChange(param1:int) : void {
this.battleStatistics.updateFund(param1);
}
[Obfuscation(rename="false")]
public function roundStart(param1:int, param2:Boolean) : void {
battleInfoService.running = true;
this.battleStatistics.initOnRoundStart(param2);
if(this.battleHasTimeLimit()) {
this.battleStatistics.startCountdownTimeLimit(param1);
}
var local3:IStatisticRound = IStatisticRound(object.adapt(IStatisticRound));
local3.roundStart();
}
[Obfuscation(rename="false")]
public function roundStop() : void {
battleInfoService.running = false;
if(this.battleHasTimeLimit()) {
this.battleStatistics.stopCountdownTimeLimit();
}
this.battleStatistics.resetFields();
var local1:IStatisticRound = IStatisticRound(object.adapt(IStatisticRound));
local1.roundStop();
}
[Obfuscation(rename="false")]
public function roundFinish(param1:Boolean, param2:Vector.<UserReward>, param3:int) : void {
battleInfoService.running = false;
var local4:IStatisticRound = IStatisticRound(object.adapt(IStatisticRound));
local4.roundFinish(getInitParam().matchBattle,param1,param3,param2);
this.battleStatistics.finish();
}
[Obfuscation(rename="false")]
public function statusProbablyCheaterChanged(param1:Long, param2:Boolean) : void {
this.setUserSuspiciousness(param1,param2);
}
[Obfuscation(rename="false")]
public function onRankChanged(param1:Long, param2:int, param3:Boolean) : void {
var local5:BattleUserInfoServiceImpl = null;
var local4:IClientUserInfo = IClientUserInfo(object.adapt(IClientUserInfo));
local4.rankChanged(param1,param2);
if(Boolean(localTankInfoService.isLocalTankLoaded()) && param1 == localTankInfoService.getLocalTankObject().id) {
ControlsMiniHelpSupport(getData(ControlsMiniHelpSupport)).close();
}
if(!param3) {
local5 = this.battleUserInfoService();
local5.dispatchRankChange(param1,param2);
}
}
public function turnOnTimerToRestoreBalance(param1:int) : void {
this.battleStatistics.turnOnTimerToRestoreBalance(param1);
}
public function turnOffTimerToRestoreBalance() : void {
this.battleStatistics.turnOffTimerToRestoreBalance();
}
private function battleUserInfoService() : BattleUserInfoServiceImpl {
return BattleUserInfoServiceImpl(getData(BattleUserInfoServiceImpl));
}
public function notifyAboutTraining(param1:int) : void {
this.battlefieldMessages.addMessageWithDuration(MessageColor.ORANGE,localeService.getText(TanksLocale.TEXT_TOURNAMENT_BATTLE_TRAINING_LABEL),param1 * 1000);
}
public function notifyAboutBattle(param1:int) : void {
this.battlefieldMessages.addMessageWithDuration(MessageColor.RED,localeService.getText(TanksLocale.TEXT_TOURNAMENT_BATTLE_STARTING_LABEL),param1 * 1000);
}
public function getTimeLeftInSec() : int {
return getInitParam().timeLeft;
}
public function setBattleName(param1:String) : void {
battleEventDispatcher.dispatchEvent(new BattleRenameEvent(param1));
}
public function resetBattleName() : void {
battleEventDispatcher.dispatchEvent(new BattleRenameEvent(this.getDefaultBattleName()));
}
}
}
|
package platform.client.fp10.core.protocol.codec {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.network.command.SpaceOpenedCommand;
public class SpaceRootCodec implements ICodec {
private var spaceOpenedCommandCodec:ICodec;
private var longCodec:ICodec;
public function SpaceRootCodec() {
super();
}
public function init(param1:IProtocol) : void {
this.spaceOpenedCommandCodec = param1.getCodec(new TypeCodecInfo(SpaceOpenedCommand,false));
this.longCodec = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local3:SpaceCommand = null;
var local4:ByteArray = null;
var local5:int = 0;
var local6:int = 0;
if(param2 is SpaceOpenedCommand) {
this.spaceOpenedCommandCodec.encode(param1,param2);
} else {
if(!(param2 is SpaceCommand)) {
throw new Error("Unknown space command");
}
local3 = SpaceCommand(param2);
this.longCodec.encode(param1,local3.objectId);
this.longCodec.encode(param1,local3.methodId);
local4 = ByteArray(local3.protocolBuffer.reader);
local4.position = 0;
while(Boolean(local4.bytesAvailable)) {
local6 = local4.readByte();
param1.writer.writeByte(local6);
}
local3.protocolBuffer.optionalMap.reset();
local5 = 0;
while(local5 < local3.protocolBuffer.optionalMap.getSize()) {
param1.optionalMap.addBit(local3.protocolBuffer.optionalMap.get());
local5++;
}
}
}
public function decode(param1:ProtocolBuffer) : Object {
return param1;
}
}
}
|
package alternativa.tanks.models.sfx.shoot.railgun
{
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.engine3d.TanksTextureMaterial;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.AnimatedLightEffect;
import alternativa.tanks.models.sfx.LightDataManager;
import alternativa.tanks.models.sfx.MuzzlePositionProvider;
import alternativa.tanks.models.sfx.TubeLightEffect;
import alternativa.tanks.models.sfx.colortransform.ColorTransformEntry;
import alternativa.tanks.models.sfx.colortransform.IColorTransformModel;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.SoundOptions;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.GraphicsUtils;
import com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.railgun.IRailgunShootSFXModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.railgun.RailgunShootSFXModelBase;
import flash.display.BitmapData;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.media.Sound;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
public class RailgunSFXModel extends RailgunShootSFXModelBase implements IRailgunShootSFXModelBase, IRailgunSFXModel, IObjectLoadListener
{
private static const MIPMAP_RESOLUTION:Number = 3;
private static const CHARGE_FRAME_SIZE:int = 210;
private static const SOUND_VOLUME:Number = 1;
private static var objectPoolService:IObjectPoolService;
private static var materialRegistry:IMaterialRegistry;
private var colorTransform:ColorTransform;
private var matrix:Matrix;
private var battlefield:IBattleField;
private var bfModel:BattlefieldModel;
private var numLoadedObjects:int;
private var trailMaterial:TanksTextureMaterial;
private var shotSound:Sound;
private var chargeMaterials:Vector.<Material>;
private var charingData:TextureAnimation;
private var chargeLightEffect:AnimatedLightEffect;
public function RailgunSFXModel()
{
this.colorTransform = new ColorTransform();
this.matrix = new Matrix();
super();
_interfaces.push(IModel,IRailgunShootSFXModelBase,IRailgunSFXModel,IObjectLoadListener);
}
public function initObject(clientObject:ClientObject, chargingPart1:String, chargingPart2:String, chargingPart3:String, railImageId:String, shotSoundId:String) : void
{
++this.numLoadedObjects;
materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
if(materialRegistry == null)
{
throw new Error("пизда тебе");
}
objectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
if(this.numLoadedObjects == 1)
{
this.battlefield = Main.osgi.getService(IBattleField) as IBattleField;
trace(railImageId);
this.trailMaterial = new TanksTextureMaterial(ResourceUtil.getResource(ResourceType.IMAGE,railImageId).bitmapData,true,true,MIPMAP_RESOLUTION,MIPMAP_RESOLUTION);
this.trailMaterial.repeat = true;
this.createChargeMaterials(chargingPart1,chargingPart2,chargingPart3);
this.shotSound = ResourceUtil.getResource(ResourceType.SOUND,"railgun_shot").sound as Sound;
}
this.objectLoaded(clientObject);
}
public function getSFXData(clientObject:ClientObject) : RailgunShootSFXData
{
return RailgunShootSFXData(clientObject.getParams(RailgunSFXModel));
}
public function createGraphicShotEffect(clientObject:ClientObject, startPosition:Vector3, hitPosition:Vector3) : IGraphicEffect
{
var sfxData:RailgunShootSFXData = this.getSFXData(clientObject);
var effect:BeamEffect = BeamEffect(objectPoolService.objectPool.getObject(BeamEffect));
effect.init(startPosition,hitPosition,this.trailMaterial,25,0.5,1.5,20,1000);
this.createShotLightEffect(startPosition,clientObject);
this.createRailLightEffect(clientObject,startPosition,hitPosition,clientObject);
return effect;
}
public function createChargeEffect(clientObject:ClientObject, user:ClientObject, localMuzzlePosition:Vector3, turret:Object3D, chargingTime:int) : IGraphicEffect
{
var sfxData:RailgunShootSFXData = this.getSFXData(clientObject);
var effect:ChargeEffect = ChargeEffect(objectPoolService.objectPool.getObject(ChargeEffect));
var animation:TextureAnimation = this.charingData;
effect.init(user,210,210,this.chargeMaterials,localMuzzlePosition,turret,0,1000 * this.chargeMaterials.length / chargingTime,sfxData.colorTransform);
this.createChargeLightEffect(localMuzzlePosition,turret,chargingTime,clientObject);
return effect;
}
public function createChargeLightEffect(param1:Vector3, param2:Object3D, param3:int, turretObject:ClientObject) : void
{
if(this.chargeLightEffect != null)
{
this.chargeLightEffect.kill();
}
this.chargeLightEffect = AnimatedLightEffect(objectPoolService.objectPool.getObject(AnimatedLightEffect));
var _loc4_:MuzzlePositionProvider = MuzzlePositionProvider(objectPoolService.objectPool.getObject(MuzzlePositionProvider));
_loc4_.init(param2,param1);
this.chargeLightEffect.initFromTime(_loc4_,param3,LightDataManager.getLightDataMuzzle(turretObject.id));
this.bfModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
this.bfModel.addGraphicEffect(this.chargeLightEffect);
}
private function createRailLightEffect(clientObject:ClientObject, param1:Vector3, param2:Vector3, turretObject:ClientObject) : void
{
var sfxData:RailgunShootSFXData = this.getSFXData(clientObject);
var _loc3_:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
var _loc4_:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
_loc3_.init(param1,0);
_loc4_.init(param2,0);
var _loc5_:TubeLightEffect = TubeLightEffect(objectPoolService.objectPool.getObject(TubeLightEffect));
_loc5_.init(_loc3_,_loc4_,LightDataManager.getLightDataShot(turretObject.id));
this.bfModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
this.bfModel.addGraphicEffect(_loc5_);
}
public function createShotLightEffect(param1:Vector3, turretObject:ClientObject) : void
{
var _loc2_:AnimatedLightEffect = AnimatedLightEffect(objectPoolService.objectPool.getObject(AnimatedLightEffect));
var _loc3_:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
_loc3_.init(param1,0);
_loc2_.init(_loc3_,LightDataManager.getLightDataExplosion(turretObject.id));
this.bfModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
this.bfModel.addGraphicEffect(_loc2_);
}
public function createSoundShotEffect(clientObject:ClientObject, effectOwner:ClientObject, startGlobalPos:Vector3) : ISound3DEffect
{
if(this.shotSound == null)
{
return null;
}
var sound:Sound3D = Sound3D.create(this.shotSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,SOUND_VOLUME);
return Sound3DEffect.create(objectPoolService.objectPool,effectOwner,startGlobalPos,sound);
}
public function objectLoaded(clientObject:ClientObject) : void
{
var ctVector:Vector.<ColorTransformEntry> = null;
var ctData:ColorTransformEntry = null;
var sfxData:RailgunShootSFXData = new RailgunShootSFXData();
var modelService:IModelService = IModelService(Main.osgi.getService(IModelService));
var colorTransformModel:IColorTransformModel = IColorTransformModel(modelService.getModelForObject(clientObject,IColorTransformModel));
if(colorTransformModel != null)
{
ctVector = colorTransformModel.getModelData(clientObject);
if(ctVector != null && ctVector.length > 0)
{
ctData = ctVector[0];
sfxData.colorTransform = new ColorTransform(ctData.redMultiplier,ctData.greenMultiplier,ctData.blueMultiplier,ctData.alphaMultiplier,ctData.redOffset,ctData.greenOffset,ctData.blueOffset,ctData.alphaOffset);
}
}
clientObject.putParams(RailgunSFXModel,sfxData);
}
public function objectUnloaded(clientObject:ClientObject) : void
{
--this.numLoadedObjects;
if(this.numLoadedObjects == 0)
{
this.trailMaterial = null;
this.chargeMaterials = null;
this.shotSound = null;
}
}
private function createChargeMaterials(chargingPart1:String, chargingPart2:String, chargingPart3:String) : void
{
var chargeTexture:BitmapData = null;
var part1:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,chargingPart1).bitmapData;
if(part1 == null)
{
throw new Error("NULL");
}
var part2:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,chargingPart2).bitmapData;
if(part2 == null)
{
throw new Error("NULL");
}
var part3:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,chargingPart3).bitmapData;
if(part3 != null)
{
chargeTexture = this.createChargeTexture(part1,part2,part3);
this.charingData = GraphicsUtils.getTextureAnimation(null,chargeTexture,210,210);
this.charingData.fps = 30;
this.chargeMaterials = materialRegistry.materialSequenceRegistry.getSequence(MaterialType.EFFECT,chargeTexture,CHARGE_FRAME_SIZE,MIPMAP_RESOLUTION,true).materials;
return;
}
throw new Error("NULL");
}
private function createChargeTexture(chargingPart1:BitmapData, chargingPart2:BitmapData, chargingPart3:BitmapData) : BitmapData
{
var texture:BitmapData = new BitmapData(CHARGE_FRAME_SIZE * 30,CHARGE_FRAME_SIZE,true,0);
for(var i:int = 1; i <= 30; i++)
{
this.drawPart1(chargingPart1,texture,i,CHARGE_FRAME_SIZE,"normal");
this.drawPart2(chargingPart2,texture,i,CHARGE_FRAME_SIZE,"normal");
this.drawPart3(chargingPart3,texture,i,CHARGE_FRAME_SIZE,"normal");
}
return texture;
}
private function drawPart1(sourceBitmapData:BitmapData, destBitmapData:BitmapData, frame:int, frameSize:int, blendMode:String) : void
{
if(frame < 15)
{
this.colorTransform.alphaMultiplier = (frame - 1) / 14;
}
else if(frame < 26)
{
this.colorTransform.alphaMultiplier = 1;
}
else
{
this.colorTransform.alphaMultiplier = 1 - (frame - 25) / 5;
}
this.matrix.identity();
this.matrix.tx = (frame - 1) * frameSize + 0.5 * (frameSize - sourceBitmapData.width);
this.matrix.ty = 0.5 * (frameSize - sourceBitmapData.height);
destBitmapData.draw(sourceBitmapData,this.matrix,this.colorTransform,blendMode,null,true);
}
private function drawPart2(sourceBitmapData:BitmapData, destBitmapData:BitmapData, frame:int, frameSize:int, blendMode:String) : void
{
if(frame < 6)
{
this.colorTransform.alphaMultiplier = (frame - 1) / 5;
}
else if(frame < 26)
{
this.colorTransform.alphaMultiplier = 1;
}
else
{
this.colorTransform.alphaMultiplier = 1 - (frame - 25) / 5;
}
this.matrix.identity();
this.matrix.translate(-0.5 * sourceBitmapData.width,-0.5 * sourceBitmapData.height);
this.matrix.rotate(2 * (frame - 1) * Math.PI / 180);
this.matrix.translate((frame - 1) * frameSize + 0.5 * frameSize,0.5 * frameSize);
destBitmapData.draw(sourceBitmapData,this.matrix,this.colorTransform,blendMode,null,true);
}
private function drawPart3(sourceBitmapData:BitmapData, destBitmapData:BitmapData, frame:int, frameSize:int, blendMode:String) : void
{
var k:Number = NaN;
var scale:Number = NaN;
if(frame < 25)
{
k = (frame - 1) / 24;
this.colorTransform.alphaMultiplier = k;
scale = 0.4 + 0.6 * k;
}
else if(frame < 26)
{
this.colorTransform.alphaMultiplier = 1;
scale = 1;
}
else
{
k = 1 - (frame - 25) / 5;
this.colorTransform.alphaMultiplier = k;
scale = 0.2 + 0.8 * k;
}
this.matrix.identity();
this.matrix.translate(-0.5 * sourceBitmapData.width,-0.5 * sourceBitmapData.height);
this.matrix.scale(scale,scale);
this.matrix.rotate(2 * (1 - frame) * Math.PI / 180);
this.matrix.translate((frame - 1) * frameSize + 0.5 * frameSize,0.5 * frameSize);
destBitmapData.draw(sourceBitmapData,this.matrix,this.colorTransform,blendMode,null,true);
}
}
}
|
package utils.tweener.easing {
public class Circ {
public function Circ() {
super();
}
public static function easeIn(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return -param3 * (Math.sqrt(1 - (param1 = param1 / param4) * param1) - 1) + param2;
}
public static function easeOut(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return param3 * Math.sqrt(1 - (param1 = param1 / param4 - 1) * param1) + param2;
}
public static function easeInOut(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
param1 = param1 / (param4 * 0.5);
if(param1 < 1) {
return -param3 * 0.5 * (Math.sqrt(1 - param1 * param1) - 1) + param2;
}
return param3 * 0.5 * (Math.sqrt(1 - (param1 = param1 - 2) * param1) + 1) + param2;
}
}
}
|
package alternativa.tanks.gui.device.list {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.device.list.DeviceBorder_centerClass.png")]
public class DeviceBorder_centerClass extends BitmapAsset {
public function DeviceBorder_centerClass() {
super();
}
}
}
|
package com.reygazu.anticheat.variables
{
import com.reygazu.anticheat.managers.CheatManager;
public class SecureBoolean
{
private var secureData:SecureObject;
private var fake:Boolean;
public function SecureBoolean(name:String = "Unnamed SecureBoolean")
{
super();
this.secureData = new SecureObject();
}
public function set value(data:Boolean) : void
{
if(this.fake != this.secureData.objectValue)
{
CheatManager.getInstance().detectCheat(this.secureData.name,this.fake,this.secureData.objectValue);
}
this.secureData.objectValue = data;
this.fake = data;
}
public function get value() : Boolean
{
return this.secureData.objectValue as Boolean;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_acceleratedloadingmechanismIconClass.png")]
public class DeviceIcons_acceleratedloadingmechanismIconClass extends BitmapAsset {
public function DeviceIcons_acceleratedloadingmechanismIconClass() {
super();
}
}
}
|
package alternativa.utils.textureutils {
import alternativa.utils.BitmapUtils;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Loader;
import flash.events.Event;
import flash.utils.ByteArray;
public class TextureConstructor {
private var _texture:BitmapData;
private var listener:ITextureConstructorListener;
private var loader:Loader;
private var textureData:TextureByteData;
private var cancelled:Boolean;
public function TextureConstructor() {
super();
}
public function get texture() : BitmapData {
return this._texture;
}
public function cancel() : void {
this.cancelled = true;
}
public function createTexture(textureData:TextureByteData, listener:ITextureConstructorListener) : void {
if(this.loader != null) {
throw new Error("Construction in progress");
}
if(textureData == null) {
throw new ArgumentError("Parameter textureData is null");
}
if(textureData.diffuseData == null) {
throw new ArgumentError("Diffuse data is null");
}
this.cancelled = false;
this.textureData = textureData;
this.listener = listener;
this.loadBytes(textureData.diffuseData,this.onDiffuseTextureLoadingComplete);
}
private function loadBytes(data:ByteArray, callback:Function) : void {
data.position = 0;
this.loader = new Loader();
this.loader.contentLoaderInfo.addEventListener(Event.COMPLETE,callback);
this.loader.loadBytes(data);
}
private function onDiffuseTextureLoadingComplete(e:Event) : void {
if(this.cancelled) {
Bitmap(this.loader.content).bitmapData.dispose();
this.loader.unload();
this.loader = null;
} else {
this._texture = Bitmap(this.loader.content).bitmapData;
this.loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.onDiffuseTextureLoadingComplete);
this.loader.unload();
if(this.textureData.opacityData != null) {
this.loadBytes(this.textureData.opacityData,this.onAlphaTextureLoadingComplete);
} else {
this.complete();
}
}
}
private function onAlphaTextureLoadingComplete(e:Event) : void {
var alpha:BitmapData = null;
if(this.cancelled) {
Bitmap(this.loader.content).bitmapData.dispose();
this.loader.unload();
this.loader = null;
} else {
alpha = Bitmap(this.loader.content).bitmapData;
this.loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.onAlphaTextureLoadingComplete);
this.loader.unload();
this._texture = BitmapUtils.mergeBitmapAlpha(this._texture,alpha,true);
this.complete();
}
}
private function complete() : void {
this.loader = null;
this.textureData = null;
var listener:ITextureConstructorListener = this.listener;
this.listener = null;
listener.onTextureReady(this);
}
}
}
|
package _codec.platform.client.core.general.spaces.loading.dispatcher.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.core.general.spaces.loading.dispatcher.types.ObjectsData;
public class VectorCodecObjectsDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecObjectsDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ObjectsData,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<ObjectsData> = new Vector.<ObjectsData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ObjectsData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ObjectsData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ObjectsData> = Vector.<ObjectsData>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.paygarden {
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.EnumCodecInfo;
import projects.tanks.client.panel.model.payment.modes.paygarden.PayGardenPaymentCC;
import projects.tanks.client.panel.model.payment.modes.paygarden.PayGardenProductType;
public class CodecPayGardenPaymentCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_productType:ICodec;
public function CodecPayGardenPaymentCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_productType = param1.getCodec(new EnumCodecInfo(PayGardenProductType,true));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PayGardenPaymentCC = new PayGardenPaymentCC();
local2.productType = this.codec_productType.decode(param1) as PayGardenProductType;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:PayGardenPaymentCC = PayGardenPaymentCC(param2);
this.codec_productType.encode(param1,local3.productType);
}
}
}
|
package alternativa.gfx.agal {
public class RelativeRegister extends CommonRegister {
public function RelativeRegister(param1:int, param2:int) {
super(param1,param2);
}
public function rel(param1:Register, param2:uint) : CommonRegister {
relate(param1,param2);
return this;
}
}
}
|
package alternativa.tanks.view {
import alternativa.tanks.controller.events.CheckCaptchaAnswerEvent;
import alternativa.tanks.controller.events.ChooseInitialStateEvent;
import alternativa.tanks.controller.events.GetNewCaptchaEvent;
import flash.events.MouseEvent;
import org.robotlegs.mvcs.Mediator;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
public class StandAloneCaptchaMediator extends Mediator {
[Inject]
public var view:StandAloneCaptchaForm;
public function StandAloneCaptchaMediator() {
super();
}
override public function onRegister() : void {
addViewListener(RefreshCaptchaClickedEvent.CLICKED,this.onRefreshCaptcha,RefreshCaptchaClickedEvent);
eventMap.mapListener(this.view.playButton,MouseEvent.CLICK,this.onPlayClicked);
}
private function onRefreshCaptcha(param1:RefreshCaptchaClickedEvent) : void {
dispatch(new GetNewCaptchaEvent(CaptchaLocation.CLIENT_STARTUP));
}
private function onPlayClicked(param1:MouseEvent) : void {
dispatch(new CheckCaptchaAnswerEvent(this.view.captchaAnswer,CaptchaLocation.CLIENT_STARTUP,new ChooseInitialStateEvent()));
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.logging {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.tanksservices.model.logging.UserActionsLoggerCC;
public class VectorCodecUserActionsLoggerCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecUserActionsLoggerCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(UserActionsLoggerCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<UserActionsLoggerCC> = new Vector.<UserActionsLoggerCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = UserActionsLoggerCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:UserActionsLoggerCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<UserActionsLoggerCC> = Vector.<UserActionsLoggerCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon {
import platform.client.fp10.core.type.AutoClosable;
public interface RocketLauncherWeaponState extends AutoClosable {
function start(param1:int) : void;
function stop(param1:int) : void;
function getStatus() : Number;
function update(param1:int) : void;
function getReloadTime() : int;
function weaponStunned(param1:int) : void;
}
}
|
package alternativa.proplib.objects {
import alternativa.engine3d.objects.Sprite3D;
import alternativa.utils.textureutils.TextureByteData;
public class PropSprite extends PropObject {
public var textureData:TextureByteData;
public var scale:Number;
public function PropSprite(textureData:TextureByteData, originX:Number = 0.5, originY:Number = 0.5, scale:Number = 1) {
super(PropObjectType.SPRITE);
this.textureData = textureData;
this.scale = scale;
var sprite:Sprite3D = new Sprite3D(1,1);
sprite.originX = originX;
sprite.originY = originY;
object = sprite;
}
override public function traceProp() : void {
super.traceProp();
trace("\ttextureData",this.textureData.diffuseData.bytesAvailable,this.textureData.opacityData);
}
}
}
|
package alternativa.tanks.gui.communication.tabs.chat {
import flash.events.Event;
public class ChatTabEvent extends Event {
public static const HIDE_CHAT:String = "ChatTabEvent.HIDE_CHAT";
public static const SHOW_CHAT:String = "ChatTabEvent.SHOW_CHAT";
public function ChatTabEvent(param1:String) {
super(param1,true);
}
}
}
|
package alternativa.tanks.service.clan {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
public interface ClanFriendsService extends IEventDispatcher {
function get clanMembers() : Vector.<Long>;
function set clanMembers(param1:Vector.<Long>) : void;
}
}
|
package alternativa.tanks.models.tank.ultimate.hornet.radar {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.events.TankRemovedFromBattleEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.display.usertitle.TitleConfigFlags;
import alternativa.tanks.models.tank.bosstate.IBossState;
import alternativa.types.Long;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.ultimate.effects.hornet.radar.BattleUltimateRadarCC;
import projects.tanks.client.battlefield.models.ultimate.effects.hornet.radar.BattleUltimateRadarModelBase;
import projects.tanks.client.battlefield.models.ultimate.effects.hornet.radar.IBattleUltimateRadarModelBase;
import projects.tanks.client.battlefield.models.user.bossstate.BossRelationRole;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class BattleUltimateRadarModel extends BattleUltimateRadarModelBase implements IBattleUltimateRadarModelBase, ObjectLoadPostListener, ObjectUnloadListener {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleInfoService:IBattleInfoService;
private var battleRadarHudIndicators:BattleRadarHudIndicators;
private var battleEventSupport:BattleEventSupport;
private var discoveredTanksIds:Vector.<Long> = new Vector.<Long>();
private var tanksInBattle:Dictionary = new Dictionary();
public function BattleUltimateRadarModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
this.battleEventSupport.addEventHandler(TankRemovedFromBattleEvent,this.onTankRemovedFromBattle);
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
var local2:Tank = param1.tank;
var local3:Long = local2.getUser().id;
this.tanksInBattle[local3] = local2;
if(this.isDiscovered(local3)) {
this.revealTank(local2);
}
}
private function isDiscovered(param1:Long) : Boolean {
return this.discoveredTanksIds.indexOf(param1) >= 0;
}
private function onTankRemovedFromBattle(param1:TankRemovedFromBattleEvent) : void {
var local2:Tank = param1.tank;
var local3:Long = local2.getUser().id;
delete this.tanksInBattle[local3];
if(this.isDiscovered(local3)) {
this.concealTank(local2);
}
}
public function objectLoadedPost() : void {
var local1:BattleUltimateRadarCC = null;
if(this.isModelActive()) {
local1 = getInitParam();
this.battleRadarHudIndicators = new BattleRadarHudIndicators(local1);
battleService.getBattleScene3D().addRenderer(this.battleRadarHudIndicators);
this.discoveredTanksIds = Vector.<Long>(local1.discoveredTanksIds);
this.battleEventSupport.activateHandlers();
}
}
private function isModelActive() : Boolean {
return !battleInfoService.isSpectatorMode();
}
public function updateDiscoveredTanksList(param1:Vector.<Long>) : void {
this.concealTanks(this.discoveredTanksIds);
this.discoveredTanksIds = Vector.<Long>(param1);
this.revealTanks(param1);
}
private function concealTanks(param1:Vector.<Long>) : void {
var local2:Long = null;
var local3:Tank = null;
for each(local2 in param1) {
local3 = this.tanksInBattle[local2];
if(local3 != null) {
this.concealTank(local3);
}
}
}
private function revealTanks(param1:Vector.<Long>) : void {
var local2:Long = null;
var local3:Tank = null;
for each(local2 in param1) {
local3 = this.tanksInBattle[local2];
if(local3 != null) {
this.revealTank(local3);
}
}
}
private function revealTank(param1:Tank) : void {
if(!this.isBoss(param1.getUser())) {
this.battleRadarHudIndicators.addTankMarker(param1);
}
param1.getTitle().setConfigurationFlags(TitleConfigFlags.FORCE_HEALTH,true);
}
private function concealTank(param1:Tank) : void {
this.battleRadarHudIndicators.removeTankMarker(param1);
param1.getTitle().setConfigurationFlags(TitleConfigFlags.FORCE_HEALTH,false);
}
private function isBoss(param1:IGameObject) : Boolean {
return IBossState(param1.adapt(IBossState)).role() == BossRelationRole.BOSS;
}
public function objectUnloaded() : void {
if(this.isModelActive()) {
battleService.getBattleScene3D().removeRenderer(this.battleRadarHudIndicators);
this.battleRadarHudIndicators = null;
this.battleEventSupport.deactivateHandlers();
}
}
}
}
|
package projects.tanks.clients.flash.commons.models.runtime {
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface DataOwner {
function equals(param1:IGameObject) : Boolean;
function getDataOwnerId() : Long;
}
}
|
package projects.tanks.client.partners.impl.odnoklassniki.payment {
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 OdnoklassnikiPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getPaymentTransactionId:Long = Long.getLong(1016806079,439012965);
private var _getPaymentTransaction_shopItemIdCodec:ICodec;
private var model:IModel;
public function OdnoklassnikiPaymentModelServer(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._getPaymentTransaction_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function getPaymentTransaction(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getPaymentTransaction_shopItemIdCodec.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._getPaymentTransactionId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.view.battlelist.battleitem.renderer.normal {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.battleitem.renderer.normal.CellNormalSelected_normalLeft.png")]
public class CellNormalSelected_normalLeft extends BitmapAsset {
public function CellNormalSelected_normalLeft() {
super();
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.logging.gamescreen {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.tanksservices.model.logging.gamescreen.GameScreen;
public class CodecGameScreen implements ICodec {
public function CodecGameScreen() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:GameScreen = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = GameScreen.PAYMENT;
break;
case 1:
local2 = GameScreen.QUESTS;
break;
case 2:
local2 = GameScreen.BATTLE_SELECT;
break;
case 3:
local2 = GameScreen.GARAGE;
break;
case 4:
local2 = GameScreen.FRIENDS;
break;
case 5:
local2 = GameScreen.SETTINGS;
break;
case 6:
local2 = GameScreen.BATTLE;
break;
case 7:
local2 = GameScreen.STATISTICS;
break;
case 8:
local2 = GameScreen.EXIT_GAME;
break;
case 9:
local2 = GameScreen.CLAN;
break;
case 10:
local2 = GameScreen.MATCHMAKING;
break;
case 11:
local2 = GameScreen.ANDROID_SCREEN_HOME;
break;
case 12:
local2 = GameScreen.ANDROID_SCREEN_BATTLES;
break;
case 13:
local2 = GameScreen.ANDROID_SCREEN_QUEST;
break;
case 14:
local2 = GameScreen.ANDROID_SCREEN_WEEKLY_REWARDS;
break;
case 15:
local2 = GameScreen.ANDROID_SCREEN_BEGINNER_QUEST;
break;
case 16:
local2 = GameScreen.ANDROID_SCREEN_COMMUNICATOR_NEWS;
break;
case 17:
local2 = GameScreen.ANDROID_SCREEN_UNKNOWN;
break;
case 18:
local2 = GameScreen.ANDROID_SCREEN_SETTINGS_ACCOUNT;
break;
case 19:
local2 = GameScreen.ANDROID_SCREEN_SETTINGS_GRAPHIC;
break;
case 20:
local2 = GameScreen.ANDROID_SCREEN_SETTINGS_SOUND;
break;
case 21:
local2 = GameScreen.ANDROID_SCREEN_SETTINGS_GAME;
break;
case 22:
local2 = GameScreen.ANDROID_SCREEN_SETTINGS_CONTROL;
break;
case 23:
local2 = GameScreen.ANDROID_SCREEN_SETTINGS_HUD;
break;
case 24:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_WEAPON;
break;
case 25:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_ARMOR;
break;
case 26:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_PAINT;
break;
case 27:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_INVENTORY;
break;
case 28:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_KIT;
break;
case 29:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_SPECIAL;
break;
case 30:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_GIVEN_PRESENTS;
break;
case 31:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_RESISTANCE;
break;
case 32:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_DRONE;
break;
case 33:
local2 = GameScreen.ANDROID_SCREEN_GARAGE_SKINS;
break;
case 34:
local2 = GameScreen.ANDROID_SCREEN_SHOP_CRYSTALS;
break;
case 35:
local2 = GameScreen.ANDROID_SCREEN_SHOP_PREMIUM;
break;
case 36:
local2 = GameScreen.ANDROID_SCREEN_SHOP_GOLD_BOXES;
break;
case 37:
local2 = GameScreen.ANDROID_SCREEN_SHOP_PAINTS;
break;
case 38:
local2 = GameScreen.ANDROID_SCREEN_SHOP_KITS;
break;
case 39:
local2 = GameScreen.ANDROID_SCREEN_SHOP_OTHERS;
break;
case 40:
local2 = GameScreen.ANDROID_SCREEN_SHOP_LOOT_BOXES;
break;
case 41:
local2 = GameScreen.ANDROID_SCREEN_SHOP_NO_CATEGORY;
}
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 controls.base {
import controls.BigButton;
import utils.FontParamsUtil;
public class BigButtonBase extends BigButton {
public function BigButtonBase() {
super();
_label.sharpness = FontParamsUtil.SHARPNESS_LABEL_BASE;
_label.thickness = FontParamsUtil.THICKNESS_LABEL_BASE;
_info.sharpness = FontParamsUtil.SHARPNESS_LABEL_BASE;
_info.thickness = FontParamsUtil.THICKNESS_LABEL_BASE;
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncherErrorScreen {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.TanksLauncherErrorScreen.TankErrorWindow_bitmapTechnical.png")]
public class TankErrorWindow_bitmapTechnical extends BitmapAsset {
public function TankErrorWindow_bitmapTechnical() {
super();
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import controls.base.TankDefaultButton;
import flash.events.MouseEvent;
public class ClanStateButton extends TankDefaultButton {
private static const ButtonCenter:Class = ClanStateButton_ButtonCenter;
private static const ButtonLeft:Class = ClanStateButton_ButtonLeft;
private static const ButtonRight:Class = ClanStateButton_ButtonRight;
private static const ButtonOverCenter:Class = ClanStateButton_ButtonOverCenter;
private static const ButtonOverLeft:Class = ClanStateButton_ButtonOverLeft;
private static const ButtonOverRight:Class = ClanStateButton_ButtonOverRight;
private static const ButtonDownCenter:Class = ClanStateButton_ButtonDownCenter;
private static const ButtonDownLeft:Class = ClanStateButton_ButtonDownLeft;
private static const ButtonDownRight:Class = ClanStateButton_ButtonDownRight;
private static const LABEL_MARGIN:int = 26;
public function ClanStateButton() {
super();
this.init();
}
private function init() : void {
stateUP.bmpLeft = new ButtonLeft().bitmapData;
stateUP.bmpCenter = new ButtonCenter().bitmapData;
stateUP.bmpRight = new ButtonRight().bitmapData;
stateOVER.bmpLeft = new ButtonOverLeft().bitmapData;
stateOVER.bmpCenter = new ButtonOverCenter().bitmapData;
stateOVER.bmpRight = new ButtonOverRight().bitmapData;
stateDOWN.bmpLeft = new ButtonDownLeft().bitmapData;
stateDOWN.bmpCenter = new ButtonDownCenter().bitmapData;
stateDOWN.bmpRight = new ButtonDownRight().bitmapData;
stateOFF.bmpLeft = new ButtonDownLeft().bitmapData;
stateOFF.bmpCenter = new ButtonDownCenter().bitmapData;
stateOFF.bmpRight = new ButtonDownRight().bitmapData;
}
override protected function onMouseEvent(param1:MouseEvent) : void {
if(enable) {
switch(param1.type) {
case MouseEvent.MOUSE_OVER:
this.setState(2);
break;
case MouseEvent.MOUSE_OUT:
this.setState(1);
break;
case MouseEvent.MOUSE_DOWN:
this.setState(3);
break;
case MouseEvent.MOUSE_UP:
this.setState(1);
}
}
}
override protected function setState(param1:int = 0) : void {
switch(param1) {
case 0:
stateOFF.alpha = 1;
stateUP.alpha = 0;
stateOVER.alpha = 0;
stateDOWN.alpha = 0;
_label.y = 7;
break;
case 1:
stateOFF.alpha = 0;
stateUP.alpha = 1;
stateOVER.alpha = 0;
stateDOWN.alpha = 0;
_label.y = 6;
break;
case 2:
stateOFF.alpha = 0;
stateUP.alpha = 0;
stateOVER.alpha = 1;
stateDOWN.alpha = 0;
_label.y = 6;
break;
case 3:
stateOFF.alpha = 0;
stateUP.alpha = 0;
stateOVER.alpha = 0;
stateDOWN.alpha = 1;
_label.y = 7;
}
}
override public function set width(param1:Number) : void {
var local2:int = Math.ceil(_label.textWidth) + LABEL_MARGIN;
if(local2 > param1) {
super.width = local2;
} else {
super.width = param1;
}
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.terminal {
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 TerminalPaymentModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TerminalPaymentModelServer;
private var client:ITerminalPaymentModelBase = ITerminalPaymentModelBase(this);
private var modelId:Long = Long.getLong(1869072851,552140822);
public function TerminalPaymentModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TerminalPaymentModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(TerminalPaymentCC,false)));
}
protected function getInitParam() : TerminalPaymentCC {
return TerminalPaymentCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.bonuses {
public interface ISpawnableObject {
function setAlpha(param1:Number) : void;
function addSignal(param1:Function) : void;
function removeSignal(param1:Function) : void;
}
}
|
package com.alternativaplatform.client.models.core.users.model.timechecker
{
import scpacker.Base;
public class TimeCheckerModelBase extends Base
{
public function TimeCheckerModelBase()
{
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.