code
stringlengths 57
237k
|
|---|
package platform.client.fp10.core.type {
import alternativa.types.Long;
import platform.client.fp10.core.network.ICommandSender;
public interface ISpace {
function get id() : Long;
function get commandSender() : ICommandSender;
function getObject(param1:Long) : IGameObject;
function get rootObject() : IGameObject;
function createObject(param1:Long, param2:IGameClass, param3:String) : IGameObject;
function destroyObject(param1:Long) : void;
function get objects() : Vector.<IGameObject>;
function close() : void;
function addEventListener(param1:ISpaceListener) : void;
function removeEventListener(param1:ISpaceListener) : void;
}
}
|
package alternativa.utils
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Loader;
import flash.events.Event;
public class TextureConstructor
{
private var loader:Loader;
private var textureData:TextureByteData;
private var _texture:BitmapData;
private var listener:ITextureConstructorListener;
public function TextureConstructor()
{
super();
}
public function get texture() : BitmapData
{
return this._texture;
}
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.textureData = textureData;
this.listener = listener;
textureData.diffuseData.position = 0;
this.loader = new Loader();
this.loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onDiffuseTextureLoadingComplete);
this.loader.loadBytes(textureData.diffuseData);
}
private function onDiffuseTextureLoadingComplete(e:Event) : void
{
this._texture = Bitmap(this.loader.content).bitmapData;
this.loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.onDiffuseTextureLoadingComplete);
this.loader.unload();
if(this.textureData.opacityData != null)
{
this.textureData.opacityData.position = 0;
this.loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onAlphaTextureLoadingComplete);
this.loader.loadBytes(this.textureData.opacityData);
}
else
{
this.complete();
}
}
private function onAlphaTextureLoadingComplete(e:Event) : void
{
var alpha:BitmapData = 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 projects.tanks.clients.fp10.libraries.tanksservices.service.clan {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
import projects.tanks.client.clans.clan.permissions.ClanAction;
public interface ClanUserInfoService extends IEventDispatcher {
function updateUserClanInfo(param1:UserClanInfo) : void;
function userClanInfoByUserId(param1:Long) : UserClanInfo;
function get updateFriendsClanButtonFunction() : Function;
function set updateFriendsClanButtonFunction(param1:Function) : void;
function hasAction(param1:ClanAction) : Boolean;
function get actions() : Vector.<ClanAction>;
function set actions(param1:Vector.<ClanAction>) : void;
function get restrictionTime() : int;
function set restrictionTime(param1:int) : void;
function inSameClan(param1:Long) : Boolean;
function get selfClan() : Boolean;
function set selfClan(param1:Boolean) : void;
function get clanMember() : Boolean;
function set clanMember(param1:Boolean) : void;
function get giveBonusesClan() : Boolean;
function set giveBonusesClan(param1:Boolean) : void;
function onLeaveClan() : void;
function onJoinClan() : void;
}
}
|
package alternativa.tanks.model.item.itempersonaldiscount {
import alternativa.tanks.model.item.discount.DiscountInfo;
import alternativa.tanks.model.item.discount.ICollectDiscount;
import alternativa.tanks.model.item.discount.IDiscountCollector;
import flash.utils.getTimer;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.garage.models.item.itempersonaldiscount.DiscountData;
import projects.tanks.client.garage.models.item.itempersonaldiscount.IItemPersonalDiscountModelBase;
import projects.tanks.client.garage.models.item.itempersonaldiscount.ItemPersonalDiscountModelBase;
[ModelInfo]
public class ItemPersonalDiscountModel extends ItemPersonalDiscountModelBase implements IItemPersonalDiscountModelBase, ICollectDiscount, ObjectLoadListener {
private static const DELAY_IN_SECONDS:int = 5;
public function ItemPersonalDiscountModel() {
super();
}
public function objectLoaded() : void {
var local4:DiscountData = null;
var local5:uint = 0;
var local1:Vector.<DiscountInfo> = new Vector.<DiscountInfo>();
var local2:Vector.<DiscountData> = getInitParam().discounts;
var local3:int = 0;
while(local3 < local2.length) {
local4 = local2[local3];
local5 = uint(getTimer() + (local4.duration - DELAY_IN_SECONDS) * 1000);
local1[local3] = new DiscountInfo(local4.discountForPercent,0,local5);
local3++;
}
putData(DiscountInfo,local1);
}
public function collectDiscountsInfo(param1:IDiscountCollector) : void {
var local2:DiscountInfo = null;
for each(local2 in Vector.<DiscountInfo>(getData(DiscountInfo))) {
param1.addDiscount(local2);
}
}
}
}
|
package projects.tanks.client.garage.models.item.properties {
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 ItemPropertiesModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ItemPropertiesModelServer;
private var client:IItemPropertiesModelBase = IItemPropertiesModelBase(this);
private var modelId:Long = Long.getLong(988366120,-592971316);
public function ItemPropertiesModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ItemPropertiesModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ItemPropertiesCC,false)));
}
protected function getInitParam() : ItemPropertiesCC {
return ItemPropertiesCC(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 projects.tanks.client.tanksservices.model.notifier.referrals {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ReferralNotifierModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ReferralNotifierModelServer;
private var client:IReferralNotifierModelBase = IReferralNotifierModelBase(this);
private var modelId:Long = Long.getLong(1904649067,-739596764);
private var _setIsReferralId:Long = Long.getLong(474883635,-1307823504);
private var _setIsReferral_usersCodec:ICodec;
public function ReferralNotifierModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ReferralNotifierModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ReferralNotifierData,false)));
this._setIsReferral_usersCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ReferralNotifierData,false),false,1));
}
protected function getInitParam() : ReferralNotifierData {
return ReferralNotifierData(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setIsReferralId:
this.client.setIsReferral(this._setIsReferral_usersCodec.decode(param2) as Vector.<ReferralNotifierData>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.gfx.agal.FragmentShader;
import alternativa.gfx.agal.SamplerDim;
import alternativa.gfx.agal.SamplerFilter;
import alternativa.gfx.agal.SamplerMipMap;
import alternativa.gfx.agal.SamplerRepeat;
public class ShadowMapFragmentShader extends FragmentShader
{
public function ShadowMapFragmentShader(param1:Boolean)
{
super();
if(param1)
{
tex(ft0,v1,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.LINEAR).mipmap(SamplerMipMap.NONE));
sub(ft0.w,ft0,v1);
kil(ft0.w);
}
frc(ft0,v0.z);
sub(ft0.x,v0.z,ft0);
mul(ft0.x,ft0,fc[0]);
mov(ft0.zw,fc[0]);
mov(oc,ft0);
}
}
}
|
package alternativa.osgi.service.console {
import alternativa.osgi.service.command.FormattedOutput;
import alternativa.osgi.service.console.variables.ConsoleVar;
public interface IConsole extends FormattedOutput {
function show() : void;
function hide() : void;
function isVisible() : Boolean;
function setSize(param1:int, param2:int) : void;
function set width(param1:int) : void;
function get width() : int;
function set height(param1:int) : void;
function get height() : int;
function set horizontalAlignment(param1:int) : void;
function get horizontalAlignment() : int;
function set vericalAlignment(param1:int) : void;
function get vericalAlignment() : int;
function set alpha(param1:Number) : void;
function get alpha() : Number;
function setCommandHandler(param1:String, param2:Function) : void;
function removeCommandHandler(param1:String) : void;
function executeCommand(param1:String) : void;
function addVariable(param1:ConsoleVar) : void;
function removeVariable(param1:String) : void;
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.hornet {
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 HornetUltimateModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function HornetUltimateModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class NormalObject3DPositionProvider extends PooledObject implements Object3DPositionProvider {
private var normal:Vector3 = new Vector3();
private var position:Vector3 = new Vector3();
private var distance:Number;
private var computedPosition:Vector3 = new Vector3();
public function NormalObject3DPositionProvider(param1:Pool) {
super(param1);
}
public function init(param1:Vector3, param2:Vector3, param3:Number) : void {
this.position.copy(param1);
this.normal.copy(param2);
this.distance = param3;
this.normal.normalize();
this.compute();
}
private function compute() : void {
this.computedPosition.copy(this.normal);
this.computedPosition.scale(this.distance);
this.computedPosition.add(this.position);
}
public function initPosition(param1:Object3D) : void {
param1.x = this.computedPosition.x;
param1.y = this.computedPosition.y;
param1.z = this.computedPosition.z;
}
public function updateObjectPosition(param1:Object3D, param2:GameCamera, param3:int) : void {
this.initPosition(param1);
}
public function destroy() : void {
recycle();
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol382")]
public dynamic class MainPanelAccountButton extends BaseButton {
public function MainPanelAccountButton() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.colortransform {
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 ColorTransformModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ColorTransformModelServer;
private var client:IColorTransformModelBase = IColorTransformModelBase(this);
private var modelId:Long = Long.getLong(1855402535,537941602);
public function ColorTransformModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ColorTransformModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ColorTransformCC,false)));
}
protected function getInitParam() : ColorTransformCC {
return ColorTransformCC(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.model.payment.paymentstate {
import alternativa.model.description.IDescription;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.components.paymentview.PaymentView;
import alternativa.tanks.gui.shop.events.ShopWindowBackButtonEvent;
import alternativa.tanks.gui.shop.events.ShopWindowJumpButtonEvent;
import alternativa.tanks.gui.shop.forms.GoToUrlForm;
import alternativa.tanks.gui.shop.payment.PayModeChooseView;
import alternativa.tanks.gui.shop.payment.PaymentFormOneTimePurchaseView;
import alternativa.tanks.gui.shop.payment.PaymentFormView;
import alternativa.tanks.gui.shop.payment.PaymentFormWithoutChosenItemView;
import alternativa.tanks.gui.shop.payment.event.ApproveFormEvent;
import alternativa.tanks.gui.shop.payment.event.PayModeChosen;
import alternativa.tanks.gui.shop.paymentform.item.PaymentFormItemBase;
import alternativa.tanks.gui.shop.shopitems.GoodsChooseView;
import alternativa.tanks.gui.shop.shopitems.event.ShopItemChosen;
import alternativa.tanks.gui.shop.shopitems.item.crystalonlypaymode.CrystalOnlyPayModeButton;
import alternativa.tanks.gui.shop.windows.ShopWindow;
import alternativa.tanks.gui.shop.windows.ShopWindowParams;
import alternativa.tanks.model.emailreminder.EmailReminderService;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.modes.CrystalsOnlyPaymentMode;
import alternativa.tanks.model.payment.modes.braintree.BraintreePayment;
import alternativa.tanks.model.payment.modes.paygarden.PayGardenPayment;
import alternativa.tanks.model.payment.modes.paypal.PayPalPayment;
import alternativa.tanks.model.payment.modes.pricerange.PriceRange;
import alternativa.tanks.model.payment.shop.ShopItemView;
import alternativa.tanks.model.payment.shop.category.ShopCategory;
import alternativa.tanks.model.payment.shop.crystal.CrystalPackage;
import alternativa.tanks.model.payment.shop.discount.ShopDiscount;
import alternativa.tanks.model.payment.shop.emailrequired.ShopItemEmailRequired;
import alternativa.tanks.model.payment.shop.featuring.ShopItemFeaturing;
import alternativa.tanks.model.payment.shop.item.ShopItem;
import alternativa.tanks.model.payment.shop.itemcategory.ShopItemCategory;
import alternativa.tanks.model.payment.shop.onetimepurchase.ShopItemOneTimePurchase;
import alternativa.tanks.model.payment.shop.premium.PremiumPackage;
import alternativa.tanks.model.payment.shop.specialkit.SinglePayMode;
import alternativa.tanks.model.payment.shop.specialkit.SpecialKitPackage;
import alternativa.tanks.model.payment.shop.specialkit.view.PayPalKitView;
import alternativa.tanks.model.promo.ShopPromoCode;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.commons.socialnetwork.SocialNetworkEnum;
import projects.tanks.client.panel.model.payment.modes.paygarden.PayGardenProductType;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.paymentactions.UserPaymentActionsService;
public class PaymentWindowServiceImpl implements PaymentWindowService {
[Inject]
public static var userPaymentActionsService:UserPaymentActionsService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
[Inject]
public static var fullscreenService:FullscreenService;
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var emailReminderService:EmailReminderService;
private static const FEATURING_FAKE_CATEGORY_ID:Long = Long.ZERO;
private var window:ShopWindow;
private var params:ShopWindowParams;
private var crystalOnlyPayModes:Vector.<IGameObject> = new Vector.<IGameObject>();
private var currentState:PaymentState;
private var chosenItem:IGameObject;
private var chosenPayMode:IGameObject;
private var alreadyTriedToBuy:Object;
private var savedScrollPosition:int;
private var stopOnPaymentForm:Boolean;
private var singleItemPayment:Boolean;
public function PaymentWindowServiceImpl() {
super();
}
public function buildWindow(param1:ShopWindowParams) : void {
var local2:Vector.<IGameObject> = null;
var local3:IGameObject = null;
this.params = param1;
this.window = new ShopWindow(this.params);
this.alreadyTriedToBuy = {};
this.stopOnPaymentForm = false;
this.singleItemPayment = false;
this.crystalOnlyPayModes = new Vector.<IGameObject>();
this.window.addEventListener(ShopWindowBackButtonEvent.CLICK,this.onBackButtonClick);
this.window.addEventListener(ShopWindowJumpButtonEvent.CLICK,this.onJumpButtonClick);
if(this.params.shopItems.length == 1) {
this.singleItemPayment = true;
this.chosenItem = this.params.shopItems[0];
if(this.params.paymentModes.length == 1) {
this.stopOnPaymentForm = true;
this.onItemChosen(new ShopItemChosen(this.chosenItem));
return;
}
} else {
local2 = new Vector.<IGameObject>();
for each(local3 in param1.paymentModes) {
if(local3.hasModel(CrystalsOnlyPaymentMode)) {
this.crystalOnlyPayModes.push(local3);
} else {
local2.push(local3);
}
}
param1.paymentModes = local2;
}
this.switchToBeginning();
}
public function switchToBeginning() : void {
if(this.stopOnPaymentForm) {
return;
}
this.switchToState(this.params.shopItems.length == 1 ? PaymentState.PAYMODE_CHOOSE : PaymentState.ITEM_CHOOSE);
}
private function switchToState(param1:PaymentState) : void {
this.removeChooseListeners();
this.currentState = param1;
this.window.switchToPaymentState(param1,this.buildStateView(param1));
this.setupChooseListeners();
}
private function buildStateView(param1:PaymentState) : PaymentView {
switch(param1) {
case PaymentState.ITEM_CHOOSE:
return this.createGoodsChooseView();
case PaymentState.PAYMODE_CHOOSE:
return this.createPaymentChooseView();
case PaymentState.PAY_FORM:
return this.createPayFormView();
case PaymentState.PAY_FORM_WITHOUT_CHOSEN_ITEM:
return this.createPayFormWithoutChosenItem();
case PaymentState.PAY_FORM_ONE_TIME_PURCHASE:
return this.createPayFormForOneTimePurchase();
default:
return null;
}
}
private function onBackButtonClick(param1:ShopWindowBackButtonEvent) : void {
if(Boolean(this.chosenItem.hasModel(CrystalsOnlyPaymentMode)) && this.currentState == PaymentState.PAY_FORM_WITHOUT_CHOSEN_ITEM) {
this.switchToState(PaymentState.ITEM_CHOOSE);
return;
}
if(this.params.paymentModes.length == 1) {
this.switchToState(PaymentState.ITEM_CHOOSE);
return;
}
if(this.currentState == PaymentState.PAY_FORM_WITHOUT_CHOSEN_ITEM || this.currentState == PaymentState.PAY_FORM_ONE_TIME_PURCHASE) {
this.switchToState(PaymentState.PAYMODE_CHOOSE);
return;
}
var local2:int = int(PaymentState.PAYMENT_FLOW.indexOf(this.currentState));
var local3:PaymentState = PaymentState.PAYMENT_FLOW[local2 - 1];
this.switchToState(local3);
}
private function onJumpButtonClick(param1:ShopWindowJumpButtonEvent) : void {
(this.window.currentPaymentView as GoodsChooseView).jumpToCategory(param1.categoryId);
}
public function show() : void {
this.window.show();
this.window.navigateToCategory(this.params.currentShopCategoryType);
}
public function destroy() : void {
if(Boolean(this.window)) {
this.removeChooseListeners();
this.window.removeEventListener(ShopWindowBackButtonEvent.CLICK,this.onBackButtonClick);
this.window.removeEventListener(ShopWindowJumpButtonEvent.CLICK,this.onJumpButtonClick);
this.window.destroy();
this.window = null;
this.params = null;
this.chosenItem = null;
this.chosenPayMode = null;
}
}
private function hasCrystalOnlyPayMode() : Boolean {
return this.crystalOnlyPayModes.length != 0;
}
private function createGoodsChooseView() : GoodsChooseView {
var local3:IGameObject = null;
var local6:IGameObject = null;
var local7:String = null;
var local8:String = null;
var local9:IGameObject = null;
var local10:IGameObject = null;
var local11:ShopItemFeaturing = null;
var local1:GoodsChooseView = new GoodsChooseView();
if(this.hasFeaturedShopItems()) {
local1.addShopCategory(FEATURING_FAKE_CATEGORY_ID,localeService.getText(TanksLocale.TEXT_SHOP_FEATURING_HEADER),localeService.getText(TanksLocale.TEXT_SHOP_FEATURING_DESCRIPTION));
}
var local2:Vector.<IGameObject> = this.params.shopCategories;
for each(local3 in local2) {
local7 = IDescription(local3.adapt(IDescription)).getName();
local8 = IDescription(local3.adapt(IDescription)).getDescription();
local1.addShopCategory(local3.id,local7,local8);
}
if(this.hasCrystalOnlyPayMode()) {
local9 = this.getLastShopCategory();
for each(local10 in this.crystalOnlyPayModes) {
local1.addItem(new CrystalOnlyPayModeButton(local10),local9.id);
}
}
var local4:Vector.<IGameObject> = this.params.shopItems;
var local5:Vector.<IGameObject> = new Vector.<IGameObject>();
for each(local6 in local4) {
local11 = ShopItemFeaturing(local6.adapt(ShopItemFeaturing));
if(!local11.isHiddenInOriginalCategory()) {
local1.addItem(ShopItemView(local6.adapt(ShopItemView)).getButtonView(),ShopItemCategory(local6.adapt(ShopItemCategory)).getCategory().id);
}
if(local11.isLocatedInFeaturingCategory()) {
local5.push(local6);
}
}
this.addFeaturedItemsToView(local5,local1);
return local1;
}
private function getLastShopCategory() : IGameObject {
var local2:IGameObject = null;
var local3:IGameObject = null;
var local4:ShopCategory = null;
var local1:int = int.MIN_VALUE;
for each(local3 in this.params.shopCategories) {
local4 = ShopCategory(local3.adapt(ShopCategory));
if(local1 < local4.getOrderIndex()) {
local1 = int(local4.getOrderIndex());
local2 = local3;
}
}
return local2;
}
private function addFeaturedItemsToView(param1:Vector.<IGameObject>, param2:GoodsChooseView) : void {
var shopItemInFeaturing:IGameObject = null;
var featuringShopItems:Vector.<IGameObject> = param1;
var view:GoodsChooseView = param2;
featuringShopItems.sort(function(param1:IGameObject, param2:IGameObject):Number {
return getItemPosition(param1) - getItemPosition(param2);
});
for each(shopItemInFeaturing in featuringShopItems) {
view.addItem(ShopItemView(shopItemInFeaturing.adapt(ShopItemView)).getButtonView(),FEATURING_FAKE_CATEGORY_ID);
}
}
private function getItemPosition(param1:IGameObject) : int {
return ShopItemFeaturing(param1.adapt(ShopItemFeaturing)).getPosition();
}
private function hasFeaturedShopItems() : Boolean {
var local1:IGameObject = null;
for each(local1 in this.params.shopItems) {
if(ShopItemFeaturing(local1.adapt(ShopItemFeaturing)).isLocatedInFeaturingCategory()) {
return true;
}
}
return false;
}
private function createPaymentChooseView() : PaymentView {
var local2:IGameObject = null;
if(this.chosenItem.hasModel(ShopPromoCode)) {
return ShopPromoCode(this.chosenItem.adapt(ShopPromoCode)).getForm();
}
var local1:PayModeChooseView = new PayModeChooseView(this.chosenItem);
if(partnerService.isRunningInside(SocialNetworkEnum.ODNOKLASSNIKI_INTERNAL.name)) {
local1.addPaymentCategoriesViewForOdnoklassniki(this.hasPayModeWithDiscountsCategory());
} else {
if(this.hasPayModeWithDiscountsCategory()) {
local1.addPaymentCategoriesWithDiscountView();
}
if(this.hasPayModeWithoutDiscountsCategory()) {
local1.addPaymentCategoriesView();
}
}
for each(local2 in this.params.paymentModes) {
if(this.payModeCanBeAdded(this.chosenItem,local2)) {
local1.addPayMode(local2);
}
}
return local1;
}
private function hasPayModeWithDiscountsCategory() : Boolean {
return this.existsPayModeWithTrueFor(function(param1:IGameObject, param2:IGameObject):Boolean {
return payModeHasDiscount(param2) && payModeCanBeAdded(param1,param2);
});
}
private function hasPayModeWithoutDiscountsCategory() : Boolean {
return this.existsPayModeWithTrueFor(function(param1:IGameObject, param2:IGameObject):Boolean {
return !payModeHasDiscount(param2) && payModeCanBeAdded(param1,param2);
});
}
private function existsPayModeWithTrueFor(param1:Function) : Boolean {
var local2:IGameObject = null;
for each(local2 in this.params.paymentModes) {
if(param1(this.chosenItem,local2)) {
return true;
}
}
return false;
}
private function payModeHasDiscount(param1:IGameObject) : Boolean {
var local2:Boolean = Boolean(this.chosenItem.hasModel(SpecialKitPackage));
return !local2 && Boolean(ShopDiscount(param1.adapt(ShopDiscount)).isEnabled());
}
private function payModeCanBeAdded(param1:IGameObject, param2:IGameObject) : Boolean {
var local3:PayGardenProductType = null;
var local4:Number = NaN;
var local5:Number = NaN;
if(partnerService.isRunningInside(SocialNetworkEnum.ODNOKLASSNIKI_INTERNAL.name)) {
return true;
}
if(param1.hasModel(PayPalKitView)) {
return this.isPayPalPayMode(param2);
}
if(param1.hasModel(SinglePayMode)) {
return SinglePayMode(param1.adapt(SinglePayMode)).getPayMode() == param2;
}
if(param2.hasModel(PayGardenPayment)) {
local3 = PayGardenPayment(param2.adapt(PayGardenPayment)).getProductType();
if(local3 == PayGardenProductType.CRYSTALS) {
return param1.hasModel(CrystalPackage);
}
if(local3 == PayGardenProductType.PREMIUM) {
return param1.hasModel(PremiumPackage);
}
if(local3 == PayGardenProductType.ITEM && (Boolean(param1.hasModel(CrystalPackage)) || Boolean(param1.hasModel(PremiumPackage)))) {
return false;
}
}
if(param2.hasModel(CrystalsOnlyPaymentMode)) {
return false;
}
if(param2.hasModel(PriceRange)) {
local4 = Number(ShopItem(param1.adapt(ShopItem)).getPriceWithDiscount());
local5 = Number(ShopDiscount(param2.adapt(ShopDiscount)).applyDiscount(local4));
return PriceRange(param2.adapt(PriceRange)).priceIsValid(local5);
}
return true;
}
private function createPayFormView() : PaymentFormView {
var local3:PaymentFormItemBase = null;
var local1:PayModeForm = PayModeView(this.chosenPayMode.adapt(PayModeView)).getView();
var local2:PaymentFormView = new PaymentFormView(this.chosenItem,local1.shouldBeOmitted() ? null : this.chosenPayMode);
if(!local1.shouldBeOmitted()) {
local3 = new PaymentFormItemBase(local1);
local2.addPaymentForm(local3);
}
local1.activate();
return local2;
}
private function createPayFormWithoutChosenItem() : PaymentFormWithoutChosenItemView {
var local1:PaymentFormWithoutChosenItemView = new PaymentFormWithoutChosenItemView(this.chosenPayMode);
var local2:PayModeForm = PayModeView(this.chosenPayMode.adapt(PayModeView)).getView();
local2.activate();
return local1;
}
private function createPayFormForOneTimePurchase() : PaymentFormOneTimePurchaseView {
var local1:PaymentFormOneTimePurchaseView = new PaymentFormOneTimePurchaseView(this.chosenItem,this.chosenPayMode);
local1.addEventListener(ApproveFormEvent.EVENT_TYPE,this.onApproveConfirmed);
return local1;
}
private function onApproveConfirmed(param1:ApproveFormEvent) : void {
this.choosePayMode();
}
public function getChosenItem() : IGameObject {
return this.chosenItem;
}
private function setupChooseListeners() : void {
if(Boolean(this.window.currentPaymentView)) {
this.window.currentPaymentView.addEventListener(PayModeChosen.EVENT_TYPE,this.onPayModeChosen);
this.window.currentPaymentView.addEventListener(ShopItemChosen.EVENT_TYPE,this.onItemChosen);
}
}
private function removeChooseListeners() : void {
if(Boolean(this.window.currentPaymentView)) {
this.window.currentPaymentView.removeEventListener(ShopItemChosen.EVENT_TYPE,this.onItemChosen);
this.window.currentPaymentView.removeEventListener(PayModeChosen.EVENT_TYPE,this.onPayModeChosen);
}
}
private function onItemChosen(param1:ShopItemChosen) : void {
var local2:IGameObject = null;
this.chosenItem = param1.item;
userPaymentActionsService.chooseItem(this.chosenItem.id);
if(this.itemIsRequiredEmail() && Boolean(settingsService.isNeedEmailRemind())) {
emailReminderService.showNeedEmailAlert();
return;
}
if(this.chosenItem.hasModel(CrystalsOnlyPaymentMode)) {
this.onPayModeChosen(new PayModeChosen(this.chosenItem));
return;
}
if(this.chosenItem.hasModel(PayPalKitView)) {
for each(local2 in this.params.paymentModes) {
if(this.isPayPalPayMode(local2)) {
this.onPayModeChosen(new PayModeChosen(local2));
return;
}
}
}
if(this.chosenItem.hasModel(SinglePayMode)) {
local2 = SinglePayMode(this.chosenItem.adapt(SinglePayMode)).getPayMode();
this.onPayModeChosen(new PayModeChosen(local2));
return;
}
if(this.chosenItem.hasModel(ShopPromoCode)) {
this.switchToState(PaymentState.PAYMODE_CHOOSE);
return;
}
this.switchFullScreenIfNeed();
if(partnerService.isRunningInside(SocialNetworkEnum.ODNOKLASSNIKI_INTERNAL.name)) {
this.stopOnPaymentForm = false;
this.switchToState(PaymentState.PAYMODE_CHOOSE);
return;
}
if(this.params.paymentModes.length == 1) {
this.onPayModeChosen(new PayModeChosen(this.params.paymentModes[0]));
} else {
this.switchToState(PaymentState.PAYMODE_CHOOSE);
}
}
private function switchFullScreenIfNeed() : void {
if(Boolean(partnerService.isRunningInsidePartnerEnvironment()) && Boolean(fullscreenService.isFullScreenNow())) {
fullscreenService.switchFullscreen();
}
}
private function onPayModeChosen(param1:PayModeChosen) : void {
this.chosenPayMode = param1.payMode;
if(this.chosenItem.hasModel(ShopItemOneTimePurchase)) {
this.choosePayModeForOneTimePurchase();
} else {
this.choosePayMode();
}
}
private function choosePayModeForOneTimePurchase() : void {
var local2:String = null;
var local1:ShopItemOneTimePurchase = ShopItemOneTimePurchase(this.chosenItem.adapt(ShopItemOneTimePurchase));
if(local1.isOneTimePurchase()) {
local2 = this.chosenItem.id.toString();
if(Boolean(local1.isTriedToBuy()) || Boolean(this.alreadyTriedToBuy.hasOwnProperty(local2))) {
this.switchToState(PaymentState.PAY_FORM_ONE_TIME_PURCHASE);
return;
}
this.alreadyTriedToBuy[local2] = true;
}
this.choosePayMode();
}
private function itemIsRequiredEmail() : Boolean {
return Boolean(this.chosenItem.hasModel(ShopItemEmailRequired)) && Boolean(ShopItemEmailRequired(this.chosenItem.adapt(ShopItemEmailRequired)).isEmailRequired());
}
private function choosePayMode() : void {
var local1:PayModeForm = PayModeView(this.chosenPayMode.adapt(PayModeView)).getView();
userPaymentActionsService.choosePaymode(this.chosenPayMode.id,this.chosenItem.id);
var local2:PaymentState = PaymentState.PAY_FORM;
if(!this.stopOnPaymentForm) {
if(local1 is GoToUrlForm) {
local1.activate();
local2 = PaymentState.ITEM_CHOOSE;
}
if(local1.isWithoutChosenItem()) {
local2 = PaymentState.PAY_FORM_WITHOUT_CHOSEN_ITEM;
}
}
this.switchToState(local2);
}
public function getChosenPayMode() : IGameObject {
return this.chosenPayMode;
}
public function render() : void {
this.window.render();
}
public function saveScrollPosition(param1:int) : void {
this.savedScrollPosition = param1;
}
public function getScrollPosition() : int {
return this.savedScrollPosition;
}
public function isStoppedOnPaymentForm() : Boolean {
return this.stopOnPaymentForm;
}
public function isSingleItemPayment() : Boolean {
return this.singleItemPayment;
}
public function hasBonusForItem(param1:IGameObject) : Boolean {
return this.hasBonusForCategory(ShopItemCategory(param1.adapt(ShopItemCategory)).getCategory());
}
public function hasBonusForCategory(param1:IGameObject) : Boolean {
return this.params.categoriesWithBonus.indexOf(param1) != -1;
}
private function isPayPalPayMode(param1:IGameObject) : Boolean {
var local2:BraintreePayment = null;
if(param1.hasModel(BraintreePayment)) {
local2 = BraintreePayment(param1.adapt(BraintreePayment));
return local2.isPayPal();
}
return param1.hasModel(PayPalPayment);
}
}
}
|
package alternativa.tanks.sound
{
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.ISound3DEffect;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
public interface ISoundManager
{
function playSound(param1:Sound, param2:int = 0, param3:int = 0, param4:SoundTransform = null) : SoundChannel;
function stopSound(param1:SoundChannel) : void;
function stopAllSounds() : void;
function addEffect(param1:ISound3DEffect) : void;
function removeEffect(param1:ISound3DEffect) : void;
function removeAllEffects() : void;
function updateSoundEffects(param1:int, param2:GameCamera) : void;
function killEffectsByOwner(param1:ClientObject) : void;
function set maxDistance(param1:Number) : void;
}
}
|
package alternativa.tanks.controller.commands {
import alternativa.tanks.service.IEntranceServerFacade;
import alternativa.tanks.view.events.SendRestoreEmailMessageEvent;
import org.robotlegs.mvcs.Command;
public class SendRestoreEmailMessageCommand extends Command {
[Inject]
public var entranceGateway:IEntranceServerFacade;
[Inject]
public var sendMessageEvent:SendRestoreEmailMessageEvent;
public function SendRestoreEmailMessageCommand() {
super();
}
override public function execute() : void {
this.entranceGateway.sendEmailRestoreMessage(this.sendMessageEvent.emailAddress);
}
}
}
|
package alternativa.protocol.codec.primitive {
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
public class ByteCodec implements IPrimitiveCodec {
public function ByteCodec() {
super();
}
public function nullValue() : Object {
return int.MAX_VALUE;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
param1.writer.writeByte(int(param2));
}
public function decode(param1:ProtocolBuffer) : Object {
return param1.reader.readByte();
}
public function init(param1:IProtocol) : void {
}
}
}
|
package alternativa.tanks.engine3d {
import flash.display.BitmapData;
import flash.geom.Rectangle;
internal class MipMapConstructionData {
public var w:Number = 0;
public var h:Number = 0;
public var rect:Rectangle = new Rectangle();
public var tmpBitmapData:BitmapData;
public function MipMapConstructionData() {
super();
}
public function setInitialSize(param1:int, param2:int) : void {
this.w = param1;
this.h = param2;
this.rect.width = param1;
this.rect.height = param2;
}
}
}
|
package alternativa.tanks.models.weapon.machinegun.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.models.weapon.machinegun.sfx.sound.MachineGunSoundManager;
import alternativa.tanks.sfx.MuzzlePositionProvider;
import alternativa.tanks.sfx.OmniStreamLightEffect;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
import projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.cc.MachineGunCC;
public class MachineGunEffects {
[Inject]
public static var battleService:BattleService;
private static const HIT_EFFECT_INTERVAL:Number = 0.1;
private static const HIT_EFFECT_OFFSET_TO_CAMERA:Number = 50;
private static const BARREL_MIN_SPEED:Number = 0.001;
private static const BARREL_MAX_SPEED:Number = 15;
private const targetPosition:Vector3 = new Vector3();
private var spinUpTime:Number;
private var spinDownTime:Number;
private var sfxData:MachineGunSFXData;
private var turret:Object3D;
private var localMuzzlePoint:Vector3;
private var shotEffect:MachineGunShotEffect;
private var fireLightEffect:OmniStreamLightEffect;
private var soundManager:MachineGunSoundManager;
private var hasHit:Boolean = false;
private var isHitInTank:Boolean;
private var hitEffectTime:Number;
private var tankSkin:TankSkin;
private var wasShooting:Boolean = false;
public function MachineGunEffects(param1:WeaponPlatform, param2:MachineGunCC, param3:MachineGunSFXData) {
super();
var local4:TankSkin = param1.getSkin();
this.tankSkin = local4;
this.turret = local4.getTurret3D();
this.spinUpTime = param2.spinUpTime;
this.spinDownTime = param2.spinDownTime;
this.localMuzzlePoint = param1.getLocalMuzzlePosition();
this.sfxData = param3;
this.soundManager = new MachineGunSoundManager(this.turret,param3,this.spinUpTime);
this.hitEffectTime = 0;
}
public function setTargetPosition(param1:Vector3, param2:Boolean) : void {
this.hasHit = true;
this.isHitInTank = param2;
this.targetPosition.copy(param1);
this.soundManager.playHitSound(param1,param2);
if(this.shotEffect != null) {
this.shotEffect.setTargetPosition(param1,param2);
}
}
public function clearTargetPosition(param1:Boolean) : void {
this.hasHit = false;
this.soundManager.stopHitSounds();
if(this.shotEffect != null) {
this.shotEffect.clearTargetPosition(param1);
}
}
public function update(param1:int, param2:Number, param3:Boolean) : void {
this.playSound(param2,param3);
var local4:Boolean = param2 == 1;
var local5:Number = param1 / 1000;
this.hitEffectTime += local5;
if(local4) {
this.updateEffectsForShooting(local5);
} else {
this.destroyEffects();
}
this.updateBarrelSkin(local5,param2);
}
public function destroy() : void {
this.destroyMuzzleFlashGraphicEffect();
this.destroyFireLightEffect();
this.soundManager.destroy();
this.soundManager = null;
this.localMuzzlePoint = null;
this.turret = null;
this.sfxData = null;
this.tankSkin = null;
}
private function playSound(param1:Number, param2:Boolean) : void {
if(param2) {
if(param1 == 1) {
this.soundManager.playShootSound();
this.wasShooting = true;
} else {
this.soundManager.playBeginSound(this.spinUpTime * param1);
}
} else if(param1 == 0) {
this.wasShooting = false;
this.soundManager.stopSound();
} else if(this.wasShooting) {
this.soundManager.playEndSound();
} else {
this.soundManager.playEndFailSound(param1 * this.spinDownTime);
}
}
private function updateEffectsForShooting(param1:Number) : void {
this.createShotEffect();
this.createFireLightEffect();
if(this.hasHit && this.hitEffectTime >= HIT_EFFECT_INTERVAL) {
this.hitEffectTime = 0;
this.createHitGraphicEffect();
}
}
private function createShotEffect() : void {
if(this.shotEffect == null) {
this.shotEffect = MachineGunShotEffect(battleService.getObjectPool().getObject(MachineGunShotEffect));
this.shotEffect.init(this.turret,this.localMuzzlePoint,this.sfxData);
battleService.addGraphicEffect(this.shotEffect);
}
}
private function createFireLightEffect() : void {
var local1:ObjectPool = null;
var local2:MuzzlePositionProvider = null;
if(this.fireLightEffect == null) {
local1 = battleService.getObjectPool();
this.fireLightEffect = OmniStreamLightEffect(local1.getObject(OmniStreamLightEffect));
local2 = MuzzlePositionProvider(local1.getObject(MuzzlePositionProvider));
local2.init(this.turret,this.localMuzzlePoint);
this.fireLightEffect.init(local2,this.sfxData.fireStartLightAnimation,this.sfxData.fireLoopLightAnimation);
battleService.addGraphicEffect(this.fireLightEffect);
}
}
private function createHitGraphicEffect() : void {
var local1:StaticObject3DPositionProvider = null;
var local2:MachineGunHitEffect = null;
if(!this.isHitInTank) {
local1 = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local1.init(this.targetPosition,HIT_EFFECT_OFFSET_TO_CAMERA);
local2 = MachineGunHitEffect(battleService.getObjectPool().getObject(MachineGunHitEffect));
local2.init(local1,this.sfxData);
battleService.addGraphicEffect(local2);
}
}
private function destroyEffects() : void {
this.clearTargetPosition(false);
this.destroyMuzzleFlashGraphicEffect();
this.destroyFireLightEffect();
}
private function destroyMuzzleFlashGraphicEffect() : void {
if(this.shotEffect != null) {
this.shotEffect.stop();
this.shotEffect = null;
}
}
private function destroyFireLightEffect() : void {
if(this.fireLightEffect != null) {
this.fireLightEffect.stop();
this.fireLightEffect = null;
}
}
private function updateBarrelSkin(param1:Number, param2:Number) : void {
var local3:Number = BARREL_MAX_SPEED * param2;
if(local3 > BARREL_MIN_SPEED) {
this.tankSkin.getTurretSkin().getMeshes()[1].rotationY = this.tankSkin.getTurretSkin().getMeshes()[1].rotationY + local3 * param1;
}
}
}
}
|
package alternativa.tanks.models.controlpoints.hud {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.lights.OmniLight;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.BSP;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.models.teamlight.ModeLight;
import alternativa.tanks.models.teamlight.TeamLightColor;
import alternativa.tanks.services.colortransform.ColorTransformService;
import alternativa.tanks.services.lightingeffects.ILightingEffectsService;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.display.BlendMode;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import projects.tanks.client.battlefield.models.battle.cp.resources.DominationResources;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class KeyPointView {
[Inject]
public static var colorTransformService:ColorTransformService;
[Inject]
public static var materialRegistry:TextureMaterialRegistry;
[Inject]
public static var lightingEffectsService:ILightingEffectsService;
public static const CIRCLE_SIZE:Number = 1000;
public static const CIRCLE_ASCENSION:Number = 350;
private static const MAX_PROGRESS:Number = 100;
private static const CURVE:Number = 1.5;
private var pedestal:BSP;
private var currentPedestalMaterial:TextureMaterial;
private var redTextureMaterial:TextureMaterial;
private var blueTextureMaterial:TextureMaterial;
private var neutralTextureMaterial:TextureMaterial;
private var plane:ProgressPlane;
private var lightSource:OmniLight;
private var redTeamColor:TeamLightColor;
private var blueTeamColor:TeamLightColor;
private var neutralTeamColor:TeamLightColor;
public function KeyPointView(param1:String, param2:BattleScene3D, param3:DominationResources) {
super();
this.pedestal = createPedestal(param3.pedestal);
this.blueTextureMaterial = materialRegistry.getMaterial(param3.bluePedestalTexture.data);
this.redTextureMaterial = materialRegistry.getMaterial(param3.redPedestalTexture.data);
this.neutralTextureMaterial = materialRegistry.getMaterial(param3.neutralPedestalTexture.data);
var local4:ModeLight = lightingEffectsService.getLightForMode(BattleMode.CP);
this.redTeamColor = local4.getLightForTeam(BattleTeam.RED);
this.blueTeamColor = local4.getLightForTeam(BattleTeam.BLUE);
this.neutralTeamColor = local4.getLightForTeam(BattleTeam.NONE);
this.createIndicator(param1,param3);
this.createLightSource(local4);
param2.addObjectToExclusion(this.plane);
param2.addObjectToExclusion(this.pedestal);
}
private static function createPedestal(param1:Tanks3DSResource) : BSP {
var local2:Mesh = Mesh(param1.objects[0]);
var local3:BSP = new BSP();
local3.createTree(local2);
return local3;
}
private static function getCircleMaterial(param1:BitmapData) : TextureMaterial {
var local2:TextureMaterial = materialRegistry.getMaterial(param1,false);
local2.resolution = CIRCLE_SIZE / param1.width;
return local2;
}
private static function createMatrix(param1:BitmapData, param2:BitmapData, param3:int) : Matrix {
var local4:int = param2.height;
var local5:Matrix = new Matrix();
local5.tx = (param1.height - local4) / 2 - local4 * param3;
local5.ty = (param1.height - local4) / 2;
return local5;
}
private static function createRectangle(param1:BitmapData, param2:BitmapData) : Rectangle {
var local3:int = param2.height;
var local4:Number = (param1.height - local3) / 2;
return new Rectangle(local4,local4,local3,local3);
}
private static function createFillingTexture(param1:BitmapData, param2:BitmapData) : BitmapData {
var local3:BitmapData = param1.clone();
local3.copyChannel(param2,param2.rect,new Point(),BitmapDataChannel.ALPHA,BitmapDataChannel.ALPHA);
return local3;
}
private static function lerpNumber(param1:Number, param2:Number, param3:Number) : Number {
return param1 + (param2 - param1) * param3;
}
private static function lerpColor(param1:uint, param2:uint, param3:Number) : uint {
var local4:Number = (param1 >> 16 & 0xFF) / 255;
var local5:Number = (param1 >> 8 & 0xFF) / 255;
var local6:Number = (param1 & 0xFF) / 255;
var local7:Number = (param2 >> 16 & 0xFF) / 255;
var local8:Number = (param2 >> 8 & 0xFF) / 255;
var local9:Number = (param2 & 0xFF) / 255;
var local10:int = lerpNumber(local4,local7,param3) * 255;
var local11:int = lerpNumber(local5,local8,param3) * 255;
var local12:int = lerpNumber(local6,local9,param3) * 255;
return local10 << 16 | local11 << 8 | local12;
}
private function createLightSource(param1:ModeLight) : void {
this.lightSource = new OmniLight(0,param1.getAttenuationBegin(),param1.getAttenuationEnd());
this.setLightColor(this.neutralTeamColor);
}
private function createIndicator(param1:String, param2:DominationResources) : void {
var local3:BitmapData = param2.neutralCircle.data.clone();
var local4:BitmapData = param2.blueCircle.data.clone();
var local5:BitmapData = param2.redCircle.data.clone();
var local6:BitmapData = param2.bigLetters.data;
var local7:int = param1.charCodeAt(0) - "A".charCodeAt(0);
var local8:Rectangle = createRectangle(local3,local6);
var local9:Matrix = createMatrix(local3,local6,local7);
local3.draw(local6,local9,null,BlendMode.NORMAL,local8,true);
local4.draw(local6,local9,null,BlendMode.NORMAL,local8,true);
local5.draw(local6,local9,null,BlendMode.NORMAL,local8,true);
var local10:BitmapData = createFillingTexture(local4,local3);
var local11:BitmapData = createFillingTexture(local5,local3);
var local12:TextureMaterial = getCircleMaterial(local3);
var local13:TextureMaterial = getCircleMaterial(local4);
var local14:TextureMaterial = getCircleMaterial(local10);
var local15:TextureMaterial = getCircleMaterial(local5);
var local16:TextureMaterial = getCircleMaterial(local11);
this.plane = new ProgressPlane(CIRCLE_SIZE,CIRCLE_SIZE,local12,local14,local13,local16,local15);
}
public function update(param1:Number, param2:Camera3D) : void {
this.plane.setProgress(param1);
this.plane.updateRotation(param2);
this.updateTeamColor(param1 / MAX_PROGRESS);
}
public function addToScene(param1:BattleScene3D, param2:Vector3) : void {
this.pedestal.x = param2.x;
this.pedestal.y = param2.y;
this.pedestal.z = param2.z;
param1.addObject(this.pedestal);
this.plane.x = param2.x;
this.plane.y = param2.y;
this.plane.z = param2.z + CIRCLE_ASCENSION;
param1.addObject(this.plane);
this.lightSource.x = param2.x;
this.lightSource.y = param2.y;
this.lightSource.z = param2.z + CIRCLE_ASCENSION;
param1.addObject(this.lightSource);
}
public function becomeRed() : void {
this.setPedestalMaterial(this.redTextureMaterial);
this.setLightColor(this.redTeamColor);
}
public function becomeBlue() : void {
this.setPedestalMaterial(this.blueTextureMaterial);
this.setLightColor(this.blueTeamColor);
}
public function becomeNeutral() : void {
this.setPedestalMaterial(this.neutralTextureMaterial);
this.setLightColor(this.neutralTeamColor);
}
private function setPedestalMaterial(param1:TextureMaterial) : void {
if(this.currentPedestalMaterial != param1) {
this.currentPedestalMaterial = param1;
this.pedestal.setMaterialToAllFaces(param1);
}
}
private function setLightColor(param1:TeamLightColor) : void {
this.lightSource.color = param1.getColor();
this.lightSource.intensity = param1.getIntensity();
}
private function updateTeamColor(param1:Number) : void {
var local2:uint = param1 < 0 ? this.redTeamColor.getColor() : this.blueTeamColor.getColor();
var local3:Number = param1 < 0 ? this.redTeamColor.getIntensity() : this.blueTeamColor.getIntensity();
this.lightSource.color = lerpColor(this.neutralTeamColor.getColor(),local2,Math.pow(Math.abs(param1),CURVE));
this.lightSource.intensity = lerpNumber(this.neutralTeamColor.getIntensity(),local3,Math.pow(Math.abs(param1),CURVE));
}
}
}
|
package alternativa.physics.collision.colliders {
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.primitives.CollisionRect;
import alternativa.physics.collision.primitives.CollisionTriangle;
public class ColliderUtils {
private static const _basisAxisX:Vector3 = new Vector3();
private static const _basisAxisY:Vector3 = new Vector3();
public function ColliderUtils() {
super();
}
public static function buildContactBasis(param1:Vector3, param2:Matrix4, param3:Matrix4, param4:Matrix4) : void {
var local5:Vector3 = _basisAxisX;
var local6:Vector3 = _basisAxisY;
if(Math.abs(param1.x) < Math.abs(param1.y)) {
local5.x = 0;
local5.y = param1.z;
local5.z = -param1.y;
} else {
local5.x = -param1.z;
local5.y = 0;
local5.z = param1.x;
}
local5.normalize();
local6.x = param1.y * local5.z - param1.z * local5.y;
local6.y = param1.z * local5.x - param1.x * local5.z;
local6.z = param1.x * local5.y - param1.y * local5.x;
param4.m00 = local5.x;
param4.m10 = local5.y;
param4.m20 = local5.z;
param4.m01 = local6.x;
param4.m11 = local6.y;
param4.m21 = local6.z;
param4.m02 = param1.x;
param4.m12 = param1.y;
param4.m22 = param1.z;
}
public static function transformFaceToReferenceSpace(param1:Matrix4, param2:Matrix4, param3:Vector.<Vertex>, param4:int) : void {
var local6:Vertex = null;
var local5:int = 0;
while(local5 < param4) {
local6 = param3[local5];
param2.transformVector(local6.local,local6.global);
param1.transformVectorInverse(local6.global,local6.transformed);
local5++;
}
}
public static function getBoxFaceVerticesInCCWOrder(param1:CollisionBox, param2:Vector3, param3:FaceSide, param4:Vector.<Vertex>) : void {
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Vector3 = null;
var local16:Vector3 = null;
var local17:Vertex = null;
var local5:Matrix4 = param1.transform;
var local6:int = 0;
local11 = local5.m00;
local12 = local5.m10;
local13 = local5.m20;
local7 = local11 * param2.x + local12 * param2.y + local13 * param2.z;
local8 = Math.abs(local7);
local11 = local5.m01;
local12 = local5.m11;
local13 = local5.m21;
local10 = local11 * param2.x + local12 * param2.y + local13 * param2.z;
local9 = Math.abs(local10);
if(local9 > local8) {
local8 = local9;
local7 = local10;
local6 = 1;
}
local11 = local5.m02;
local12 = local5.m12;
local13 = local5.m22;
local10 = local11 * param2.x + local12 * param2.y + local13 * param2.z;
local9 = Math.abs(local10);
if(local9 > local8) {
local7 = local10;
local6 = 2;
}
local14 = local7 > 0 ? 1 : -1;
if(param3 == FaceSide.BACK) {
local14 = -local14;
}
local16 = param1.hs;
switch(local6) {
case 0:
local15 = Vertex(param4[0]).local;
local15.x = local14 * local16.x;
local15.y = local16.y;
local15.z = local16.z;
local15 = Vertex(param4[1]).local;
local15.x = local14 * local16.x;
local15.y = -local16.y;
local15.z = local16.z;
local15 = Vertex(param4[2]).local;
local15.x = local14 * local16.x;
local15.y = -local16.y;
local15.z = -local16.z;
local15 = Vertex(param4[3]).local;
local15.x = local14 * local16.x;
local15.y = local16.y;
local15.z = -local16.z;
break;
case 1:
local15 = Vertex(param4[0]).local;
local15.x = local16.x;
local15.y = local14 * local16.y;
local15.z = local16.z;
local15 = Vertex(param4[1]).local;
local15.x = local16.x;
local15.y = local14 * local16.y;
local15.z = -local16.z;
local15 = Vertex(param4[2]).local;
local15.x = -local16.x;
local15.y = local14 * local16.y;
local15.z = -local16.z;
local15 = Vertex(param4[3]).local;
local15.x = -local16.x;
local15.y = local14 * local16.y;
local15.z = local16.z;
break;
case 2:
local15 = Vertex(param4[0]).local;
local15.x = local16.x;
local15.y = local16.y;
local15.z = local14 * local16.z;
local15 = Vertex(param4[1]).local;
local15.x = -local16.x;
local15.y = local16.y;
local15.z = local14 * local16.z;
local15 = Vertex(param4[2]).local;
local15.x = -local16.x;
local15.y = -local16.y;
local15.z = local14 * local16.z;
local15 = Vertex(param4[3]).local;
local15.x = local16.x;
local15.y = -local16.y;
local15.z = local14 * local16.z;
break;
default:
throw new Error();
}
if(local7 < 0) {
local17 = param4[0];
param4[0] = param4[3];
param4[3] = local17;
local17 = param4[1];
param4[1] = param4[2];
param4[2] = local17;
}
}
public static function getRectFaceInCCWOrder(param1:CollisionRect, param2:Vector3, param3:Vector.<Vertex>) : void {
var local5:Vertex = null;
var local4:Vector3 = param1.hs;
local5 = param3[0];
local5.local.x = local4.x;
local5.local.y = local4.y;
local5.local.z = 0;
local5 = param3[1];
local5.local.x = -local4.x;
local5.local.y = local4.y;
local5.local.z = 0;
local5 = param3[2];
local5.local.x = -local4.x;
local5.local.y = -local4.y;
local5.local.z = 0;
local5 = param3[3];
local5.local.x = local4.x;
local5.local.y = -local4.y;
local5.local.z = 0;
var local6:Matrix4 = param1.transform;
var local7:Number = param2.x * local6.m02 + param2.y * local6.m12 + param2.z * local6.m22;
if(local7 < 0) {
local5 = param3[0];
param3[0] = param3[3];
param3[3] = local5;
local5 = param3[1];
param3[1] = param3[2];
param3[2] = local5;
}
}
public static function getTriangleFaceInCCWOrder(param1:CollisionTriangle, param2:Vector3, param3:Vector.<Vertex>) : void {
var local4:Vertex = null;
local4 = param3[0];
local4.local.x = param1.v0.x;
local4.local.y = param1.v0.y;
local4.local.z = 0;
local4 = param3[1];
local4.local.x = param1.v1.x;
local4.local.y = param1.v1.y;
local4.local.z = 0;
local4 = param3[2];
local4.local.x = param1.v2.x;
local4.local.y = param1.v2.y;
local4.local.z = 0;
var local5:Matrix4 = param1.transform;
var local6:Number = param2.x * local5.m02 + param2.y * local5.m12 + param2.z * local5.m22;
if(local6 < 0) {
local4 = param3[0];
param3[0] = param3[2];
param3[2] = local4;
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.twins {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public interface ITwinsModelBase {
function fire(param1:IGameObject, param2:int, param3:int, param4:Vector3d) : void;
function fireDummy(param1:IGameObject, param2:int) : void;
}
}
|
package alternativa.tanks.models.battlefield
{
public interface IUserStatListener
{
function userStatChanged(param1:String, param2:String, param3:int) : void;
}
}
|
package projects.tanks.client.garage.models.item.container.weekly {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import projects.tanks.client.garage.models.item.container.ContainerGivenItem;
public class WeeklyContainerModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:WeeklyContainerModelServer;
private var client:IWeeklyContainerModelBase = IWeeklyContainerModelBase(this);
private var modelId:Long = Long.getLong(895763411,-290717027);
private var _openSuccessfulId:Long = Long.getLong(414752496,-1868458890);
private var _openSuccessful_rewardsCodec:ICodec;
private var _updateCountId:Long = Long.getLong(1978161324,62150420);
private var _updateCount_countCodec:ICodec;
public function WeeklyContainerModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new WeeklyContainerModelServer(IModel(this));
this._openSuccessful_rewardsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ContainerGivenItem,false),false,1));
this._updateCount_countCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._openSuccessfulId:
this.client.openSuccessful(this._openSuccessful_rewardsCodec.decode(param2) as Vector.<ContainerGivenItem>);
break;
case this._updateCountId:
this.client.updateCount(int(this._updateCount_countCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.servermodels.loginbyhash {
[ModelInterface]
public interface ILoginByHash {
function loginByHash(param1:String) : void;
function loginBySingleUseHash(param1:String) : void;
}
}
|
package projects.tanks.client.panel.model
{
public interface IUserDataModelBase
{
}
}
|
package alternativa.tanks.models.weapon.machinegun.sfx {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.math.Vector3;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
public class CrumbsParticle extends Particle {
private var _sprite:Sprite3D = new Sprite3D(1,1);
private var _direction:Vector3 = new Vector3();
private var _time:Number = 0;
public function CrumbsParticle(param1:Pool) {
super(param1);
SFXUtils.setEffectParams(this._sprite);
}
public function init(param1:Number, param2:Vector3, param3:Vector3, param4:TextureMaterial) : void {
this._time = 0;
this._direction.copy(param3);
this._sprite.width = param1;
this._sprite.height = param1;
this._sprite.x = param2.x;
this._sprite.y = param2.y;
this._sprite.z = param2.z;
this._sprite.material = param4;
}
public function get sprite() : Sprite3D {
return this._sprite;
}
public function get direction() : Vector3 {
return this._direction;
}
public function get time() : Number {
return this._time;
}
public function set time(param1:Number) : void {
this._time = param1;
}
}
}
|
package projects.tanks.client.garage.models.item.buyable {
public class BuyableCC {
private var _buyable:Boolean;
private var _priceWithoutDiscount:int;
public function BuyableCC(param1:Boolean = false, param2:int = 0) {
super();
this._buyable = param1;
this._priceWithoutDiscount = param2;
}
public function get buyable() : Boolean {
return this._buyable;
}
public function set buyable(param1:Boolean) : void {
this._buyable = param1;
}
public function get priceWithoutDiscount() : int {
return this._priceWithoutDiscount;
}
public function set priceWithoutDiscount(param1:int) : void {
this._priceWithoutDiscount = param1;
}
public function toString() : String {
var local1:String = "BuyableCC [";
local1 += "buyable = " + this.buyable + " ";
local1 += "priceWithoutDiscount = " + this.priceWithoutDiscount + " ";
return local1 + "]";
}
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class EllipsoidCollider {
public var radiusX:Number;
public var radiusY:Number;
public var radiusZ:Number;
public var threshold:Number = 0.001;
private var matrix:Object3D = new Object3D();
private var faces:Vector.<Face> = new Vector.<Face>();
private var facesLength:int;
private var radius:Number;
private var src:Vector3D = new Vector3D();
private var displ:Vector3D = new Vector3D();
private var dest:Vector3D = new Vector3D();
private var collisionPoint:Vector3D = new Vector3D();
private var collisionPlane:Vector3D = new Vector3D();
private var vCenter:Vector3D = new Vector3D();
private var vA:Vector3D = new Vector3D();
private var vB:Vector3D = new Vector3D();
private var vC:Vector3D = new Vector3D();
private var vD:Vector3D = new Vector3D();
public function EllipsoidCollider(param1:Number, param2:Number, param3:Number) {
super();
this.radiusX = param1;
this.radiusY = param2;
this.radiusZ = param3;
}
private function prepare(param1:Vector3D, param2:Vector3D, param3:Object3D, param4:Dictionary, param5:Boolean) : void {
var local6:Number = NaN;
this.radius = this.radiusX;
if(this.radiusY > this.radius) {
this.radius = this.radiusY;
}
if(this.radiusZ > this.radius) {
this.radius = this.radiusZ;
}
this.matrix.scaleX = this.radiusX / this.radius;
this.matrix.scaleY = this.radiusY / this.radius;
this.matrix.scaleZ = this.radiusZ / this.radius;
this.matrix.x = param1.x;
this.matrix.y = param1.y;
this.matrix.z = param1.z;
this.matrix.alternativa3d::composeMatrix();
this.matrix.alternativa3d::invertMatrix();
this.src.x = 0;
this.src.y = 0;
this.src.z = 0;
this.displ.x = this.matrix.alternativa3d::ma * param2.x + this.matrix.alternativa3d::mb * param2.y + this.matrix.alternativa3d::mc * param2.z;
this.displ.y = this.matrix.alternativa3d::me * param2.x + this.matrix.alternativa3d::mf * param2.y + this.matrix.alternativa3d::mg * param2.z;
this.displ.z = this.matrix.alternativa3d::mi * param2.x + this.matrix.alternativa3d::mj * param2.y + this.matrix.alternativa3d::mk * param2.z;
this.dest.x = this.src.x + this.displ.x;
this.dest.y = this.src.y + this.displ.y;
this.dest.z = this.src.z + this.displ.z;
if(param5) {
this.vCenter.x = this.displ.x / 2;
this.vCenter.y = this.displ.y / 2;
this.vCenter.z = this.displ.z / 2;
local6 = this.radius + this.displ.length / 2;
} else {
this.vCenter.x = 0;
this.vCenter.y = 0;
this.vCenter.z = 0;
local6 = this.radius + this.displ.length;
}
this.vA.x = -local6;
this.vA.y = -local6;
this.vA.z = -local6;
this.vB.x = local6;
this.vB.y = -local6;
this.vB.z = -local6;
this.vC.x = local6;
this.vC.y = local6;
this.vC.z = -local6;
this.vD.x = -local6;
this.vD.y = local6;
this.vD.z = -local6;
param3.alternativa3d::composeAndAppend(this.matrix);
param3.alternativa3d::collectPlanes(this.vCenter,this.vA,this.vB,this.vC,this.vD,this.faces,param4);
this.facesLength = this.faces.length;
}
public function calculateDestination(param1:Vector3D, param2:Vector3D, param3:Object3D, param4:Dictionary = null) : Vector3D {
var local5:int = 0;
var local6:int = 0;
var local7:Number = NaN;
if(param2.length <= this.threshold) {
return param1.clone();
}
this.prepare(param1,param2,param3,param4,false);
if(this.facesLength > 0) {
local5 = 50;
local6 = 0;
while(local6 < local5) {
if(!this.checkCollision()) {
break;
}
local7 = this.radius + this.threshold + this.collisionPlane.w - this.dest.x * this.collisionPlane.x - this.dest.y * this.collisionPlane.y - this.dest.z * this.collisionPlane.z;
this.dest.x += this.collisionPlane.x * local7;
this.dest.y += this.collisionPlane.y * local7;
this.dest.z += this.collisionPlane.z * local7;
this.src.x = this.collisionPoint.x + this.collisionPlane.x * (this.radius + this.threshold);
this.src.y = this.collisionPoint.y + this.collisionPlane.y * (this.radius + this.threshold);
this.src.z = this.collisionPoint.z + this.collisionPlane.z * (this.radius + this.threshold);
this.displ.x = this.dest.x - this.src.x;
this.displ.y = this.dest.y - this.src.y;
this.displ.z = this.dest.z - this.src.z;
if(this.displ.length < this.threshold) {
break;
}
local6++;
}
this.faces.length = 0;
this.matrix.alternativa3d::composeMatrix();
return new Vector3D(this.matrix.alternativa3d::ma * this.dest.x + this.matrix.alternativa3d::mb * this.dest.y + this.matrix.alternativa3d::mc * this.dest.z + this.matrix.alternativa3d::md,this.matrix.alternativa3d::me * this.dest.x + this.matrix.alternativa3d::mf * this.dest.y + this.matrix.alternativa3d::mg * this.dest.z + this.matrix.alternativa3d::mh,this.matrix.alternativa3d::mi * this.dest.x + this.matrix.alternativa3d::mj * this.dest.y + this.matrix.alternativa3d::mk * this.dest.z + this.matrix.alternativa3d::ml);
}
return new Vector3D(param1.x + param2.x,param1.y + param2.y,param1.z + param2.z);
}
public function getCollision(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Object3D, param6:Dictionary = null) : Boolean {
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
if(param2.length <= this.threshold) {
return false;
}
this.prepare(param1,param2,param5,param6,true);
if(this.facesLength > 0) {
if(this.checkCollision()) {
this.matrix.alternativa3d::composeMatrix();
param3.x = this.matrix.alternativa3d::ma * this.collisionPoint.x + this.matrix.alternativa3d::mb * this.collisionPoint.y + this.matrix.alternativa3d::mc * this.collisionPoint.z + this.matrix.alternativa3d::md;
param3.y = this.matrix.alternativa3d::me * this.collisionPoint.x + this.matrix.alternativa3d::mf * this.collisionPoint.y + this.matrix.alternativa3d::mg * this.collisionPoint.z + this.matrix.alternativa3d::mh;
param3.z = this.matrix.alternativa3d::mi * this.collisionPoint.x + this.matrix.alternativa3d::mj * this.collisionPoint.y + this.matrix.alternativa3d::mk * this.collisionPoint.z + this.matrix.alternativa3d::ml;
if(this.collisionPlane.x < this.collisionPlane.y) {
if(this.collisionPlane.x < this.collisionPlane.z) {
local7 = 0;
local8 = -this.collisionPlane.z;
local9 = this.collisionPlane.y;
} else {
local7 = -this.collisionPlane.y;
local8 = this.collisionPlane.x;
local9 = 0;
}
} else if(this.collisionPlane.y < this.collisionPlane.z) {
local7 = this.collisionPlane.z;
local8 = 0;
local9 = -this.collisionPlane.x;
} else {
local7 = -this.collisionPlane.y;
local8 = this.collisionPlane.x;
local9 = 0;
}
local10 = this.collisionPlane.z * local8 - this.collisionPlane.y * local9;
local11 = this.collisionPlane.x * local9 - this.collisionPlane.z * local7;
local12 = this.collisionPlane.y * local7 - this.collisionPlane.x * local8;
local13 = this.matrix.alternativa3d::ma * local7 + this.matrix.alternativa3d::mb * local8 + this.matrix.alternativa3d::mc * local9;
local14 = this.matrix.alternativa3d::me * local7 + this.matrix.alternativa3d::mf * local8 + this.matrix.alternativa3d::mg * local9;
local15 = this.matrix.alternativa3d::mi * local7 + this.matrix.alternativa3d::mj * local8 + this.matrix.alternativa3d::mk * local9;
local16 = this.matrix.alternativa3d::ma * local10 + this.matrix.alternativa3d::mb * local11 + this.matrix.alternativa3d::mc * local12;
local17 = this.matrix.alternativa3d::me * local10 + this.matrix.alternativa3d::mf * local11 + this.matrix.alternativa3d::mg * local12;
local18 = this.matrix.alternativa3d::mi * local10 + this.matrix.alternativa3d::mj * local11 + this.matrix.alternativa3d::mk * local12;
param4.x = local15 * local17 - local14 * local18;
param4.y = local13 * local18 - local15 * local16;
param4.z = local14 * local16 - local13 * local17;
param4.normalize();
param4.w = param3.x * param4.x + param3.y * param4.y + param3.z * param4.z;
this.faces.length = 0;
return true;
}
this.faces.length = 0;
return false;
}
return false;
}
private function checkCollision() : Boolean {
var local4:Face = null;
var local5:Wrapper = null;
var local6:Vertex = null;
var local7:Vertex = null;
var local8:Vertex = null;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
var local26:Number = NaN;
var local27:Number = NaN;
var local28:Boolean = false;
var local29:Wrapper = 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:Number = NaN;
var local44:Number = NaN;
var local45:Number = NaN;
var local46:Number = NaN;
var local1:Number = 1;
var local2:Number = this.displ.length;
var local3:int = 0;
while(local3 < this.facesLength) {
local4 = this.faces[local3];
local5 = local4.alternativa3d::wrapper;
local6 = local5.alternativa3d::vertex;
local5 = local5.alternativa3d::next;
local7 = local5.alternativa3d::vertex;
local5 = local5.alternativa3d::next;
local8 = local5.alternativa3d::vertex;
local9 = local7.alternativa3d::cameraX - local6.alternativa3d::cameraX;
local10 = local7.alternativa3d::cameraY - local6.alternativa3d::cameraY;
local11 = local7.alternativa3d::cameraZ - local6.alternativa3d::cameraZ;
local12 = local8.alternativa3d::cameraX - local6.alternativa3d::cameraX;
local13 = local8.alternativa3d::cameraY - local6.alternativa3d::cameraY;
local14 = local8.alternativa3d::cameraZ - local6.alternativa3d::cameraZ;
local15 = local14 * local10 - local13 * local11;
local16 = local12 * local11 - local14 * local9;
local17 = local13 * local9 - local12 * local10;
local18 = local15 * local15 + local16 * local16 + local17 * local17;
if(local18 > 0.001) {
local18 = 1 / Math.sqrt(local18);
local15 *= local18;
local16 *= local18;
local17 *= local18;
local19 = local6.alternativa3d::cameraX * local15 + local6.alternativa3d::cameraY * local16 + local6.alternativa3d::cameraZ * local17;
local20 = this.src.x * local15 + this.src.y * local16 + this.src.z * local17 - local19;
if(local20 < this.radius) {
local21 = this.src.x - local15 * local20;
local22 = this.src.y - local16 * local20;
local23 = this.src.z - local17 * local20;
} else {
local33 = (local20 - this.radius) / (local20 - this.dest.x * local15 - this.dest.y * local16 - this.dest.z * local17 + local19);
local21 = this.src.x + this.displ.x * local33 - local15 * this.radius;
local22 = this.src.y + this.displ.y * local33 - local16 * this.radius;
local23 = this.src.z + this.displ.z * local33 - local17 * this.radius;
}
local27 = 1e+22;
local28 = true;
local29 = local4.alternativa3d::wrapper;
while(local29 != null) {
local6 = local29.alternativa3d::vertex;
local7 = local29.alternativa3d::next != null ? local29.alternativa3d::next.alternativa3d::vertex : local4.alternativa3d::wrapper.alternativa3d::vertex;
local9 = local7.alternativa3d::cameraX - local6.alternativa3d::cameraX;
local10 = local7.alternativa3d::cameraY - local6.alternativa3d::cameraY;
local11 = local7.alternativa3d::cameraZ - local6.alternativa3d::cameraZ;
local12 = local21 - local6.alternativa3d::cameraX;
local13 = local22 - local6.alternativa3d::cameraY;
local14 = local23 - local6.alternativa3d::cameraZ;
local34 = local14 * local10 - local13 * local11;
local35 = local12 * local11 - local14 * local9;
local36 = local13 * local9 - local12 * local10;
if(local34 * local15 + local35 * local16 + local36 * local17 < 0) {
local37 = local9 * local9 + local10 * local10 + local11 * local11;
local38 = (local34 * local34 + local35 * local35 + local36 * local36) / local37;
if(local38 < local27) {
local37 = Math.sqrt(local37);
local9 /= local37;
local10 /= local37;
local11 /= local37;
local33 = local9 * local12 + local10 * local13 + local11 * local14;
if(local33 < 0) {
local39 = local12 * local12 + local13 * local13 + local14 * local14;
if(local39 < local27) {
local27 = local39;
local24 = Number(local6.alternativa3d::cameraX);
local25 = Number(local6.alternativa3d::cameraY);
local26 = Number(local6.alternativa3d::cameraZ);
}
} else if(local33 > local37) {
local12 = local21 - local7.alternativa3d::cameraX;
local13 = local22 - local7.alternativa3d::cameraY;
local14 = local23 - local7.alternativa3d::cameraZ;
local39 = local12 * local12 + local13 * local13 + local14 * local14;
if(local39 < local27) {
local27 = local39;
local24 = Number(local7.alternativa3d::cameraX);
local25 = Number(local7.alternativa3d::cameraY);
local26 = Number(local7.alternativa3d::cameraZ);
}
} else {
local27 = local38;
local24 = local6.alternativa3d::cameraX + local9 * local33;
local25 = local6.alternativa3d::cameraY + local10 * local33;
local26 = local6.alternativa3d::cameraZ + local11 * local33;
}
}
local28 = false;
}
local29 = local29.alternativa3d::next;
}
if(local28) {
local24 = local21;
local25 = local22;
local26 = local23;
}
local30 = this.src.x - local24;
local31 = this.src.y - local25;
local32 = this.src.z - local26;
if(local30 * this.displ.x + local31 * this.displ.y + local32 * this.displ.z <= 0) {
local40 = -this.displ.x / local2;
local41 = -this.displ.y / local2;
local42 = -this.displ.z / local2;
local43 = local30 * local30 + local31 * local31 + local32 * local32;
local44 = local30 * local40 + local31 * local41 + local32 * local42;
local45 = this.radius * this.radius - local43 + local44 * local44;
if(local45 > 0) {
local46 = (local44 - Math.sqrt(local45)) / local2;
if(local46 < local1) {
local1 = local46;
this.collisionPoint.x = local24;
this.collisionPoint.y = local25;
this.collisionPoint.z = local26;
if(local28) {
this.collisionPlane.x = local15;
this.collisionPlane.y = local16;
this.collisionPlane.z = local17;
this.collisionPlane.w = local19;
} else {
local43 = Math.sqrt(local43);
this.collisionPlane.x = local30 / local43;
this.collisionPlane.y = local31 / local43;
this.collisionPlane.z = local32 / local43;
this.collisionPlane.w = this.collisionPoint.x * this.collisionPlane.x + this.collisionPoint.y * this.collisionPlane.y + this.collisionPoint.z * this.collisionPlane.z;
}
}
}
}
}
local3++;
}
return local1 < 1;
}
}
}
|
package alternativa.tanks.view.mainview.groupinvite {
import alternativa.types.Long;
import flash.events.Event;
public class InviteUserEvent extends Event {
public static const TYPE:String = "InviteUserEvent";
private var userId:Long;
public function InviteUserEvent(param1:Long) {
this.userId = param1;
super(TYPE,true);
}
public function getUserId() : Long {
return this.userId;
}
}
}
|
package alternativa.tanks.models.weapon.shared {
import alternativa.physics.Body;
public interface HealingGunTargetEvaluator {
function getTargetPriority(param1:Body) : Number;
}
}
|
package alternativa.tanks.models.controlpoints.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.utils.Dictionary;
public class DominationBeamEffect extends PooledObject implements GraphicEffect {
private static const conZOffset:ConsoleVarFloat = new ConsoleVarFloat("beam_zoffset",100,0,1000);
private static const startPosition:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private var beam:AnimatedBeam;
private var alive:Boolean;
private var object:Object3D;
private var endPosition:Vector3 = new Vector3();
private var excludedObects:Dictionary;
private var container:Scene3DContainer;
public function DominationBeamEffect(param1:Pool) {
super(param1);
this.beam = new AnimatedBeam(1,1,1,0);
}
public function init(param1:Object3D, param2:Vector3, param3:BeamProperties, param4:Dictionary) : void {
this.object = param1;
this.endPosition.copy(param2);
this.beam.setMaterials(param3.beamTipMaterial,param3.beamMaterial);
this.beam.setUnitLength(param3.unitLength);
this.beam.animationSpeed = param3.animationSpeed;
this.setBeamWidth(param3.beamWidth);
this.beam.setURange(param3.uRange);
this.beam.alpha = param3.alpha;
this.alive = true;
this.excludedObects = param4;
}
public function play(param1:int, param2:GameCamera) : Boolean {
startPosition.x = this.object.x;
startPosition.y = this.object.y;
startPosition.z = this.object.z + conZOffset.value;
direction.diff(this.endPosition,startPosition);
this.beam.setLength(direction.length());
direction.normalize();
SFXUtils.alignObjectPlaneToView(this.beam,startPosition,direction,param2.position);
this.beam.update(param1 * 0.001);
return this.alive;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.beam);
this.excludedObects[this.beam] = true;
}
public function destroy() : void {
this.object = null;
this.container.removeChild(this.beam);
this.beam.setMaterialToAllFaces(null);
delete this.excludedObects[this.beam];
this.excludedObects = null;
recycle();
}
public function kill() : void {
this.alive = false;
}
public function setBeamWidth(param1:Number) : void {
this.beam.setWidth(param1);
this.beam.setTipLength(param1);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.score.ASScoreIndicator_redScoreClass.png")]
public class ASScoreIndicator_redScoreClass extends BitmapAsset {
public function ASScoreIndicator_redScoreClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.garage.temperature {
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.garage.models.garage.temperature.TemperatureCC;
public class CodecTemperatureCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_temperatureAutoDecrement:ICodec;
public function CodecTemperatureCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_temperatureAutoDecrement = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TemperatureCC = new TemperatureCC();
local2.temperatureAutoDecrement = this.codec_temperatureAutoDecrement.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:TemperatureCC = TemperatureCC(param2);
this.codec_temperatureAutoDecrement.encode(param1,local3.temperatureAutoDecrement);
}
}
}
|
package alternativa.tanks.model.payment.modes.errors {
import projects.tanks.client.panel.model.payment.modes.errors.ErrorsDescriptionModelBase;
import projects.tanks.client.panel.model.payment.modes.errors.IErrorsDescriptionModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
[ModelInfo]
public class ErrorsDescriptionModel extends ErrorsDescriptionModelBase implements IErrorsDescriptionModelBase {
[Inject]
public static var alertService:IAlertService;
public function ErrorsDescriptionModel() {
super();
}
public function showError(param1:String) : void {
alertService.showOkAlert(param1);
}
}
}
|
package forms.events {
import flash.events.Event;
public class StatListEvent extends Event {
public static const UPDATE_SORT:String = "StatListUpdateSort";
public var sortField:int;
public function StatListEvent(param1:int) {
this.sortField = param1;
super(UPDATE_SORT,true);
}
}
}
|
package forms.friends
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendsWindowStateBigButton_ButtonCenter extends BitmapAsset
{
public function FriendsWindowStateBigButton_ButtonCenter()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.discount {
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 DiscountModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function DiscountModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.panel.model.payment.loader {
public interface IPaymentLoaderModelBase {
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.helper {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import controls.Label;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import flash.display.Sprite;
import flash.display.StageQuality;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
public class BubbleHelper extends Helper {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var display:IDisplay;
public static const r:int = 16;
private static const lineThickness:int = 1;
private static const lineColor:uint = 16777215;
private static const fillColor:uint = 0;
private static const lineAlpha:Number = 1;
private static const fillAlpha:Number = 0.85;
private static const arrowShift:int = r * 1.5;
private static const arrowWidth:int = r * 1.5;
private var back:Shape;
private var outline:Shape;
private var _arrowLehgth:int = 48;
private var _arrowAlign:int;
private var arrowP1:Point = new Point();
private var arrowP2:Point = new Point();
private var arrowTarget:Point = new Point();
private var outlineArrowP1:Point = new Point();
private var outlineArrowP2:Point = new Point();
private var outlineArrowTarget:Point = new Point();
private var arrowDirection:Boolean;
protected var descriptionLabel:TextField;
private var margin:int = 12;
private var bmp:Bitmap;
private var backContainer:Sprite;
public function BubbleHelper() {
super();
_size = new Point();
_targetPoint = new Point();
this.bmp = new Bitmap();
addChild(this.bmp);
this.backContainer = new Sprite();
this.backContainer.mouseEnabled = false;
this.backContainer.mouseChildren = false;
this.backContainer.tabEnabled = false;
this.backContainer.tabChildren = false;
this.outline = new Shape();
this.backContainer.addChild(this.outline);
this.back = new Shape();
this.backContainer.addChild(this.back);
this.arrowAlign = HelperAlign.MIDDLE_RIGHT;
this.descriptionLabel = new Label();
this.descriptionLabel.antiAliasType = AntiAliasType.ADVANCED;
this.descriptionLabel.gridFitType = GridFitType.SUBPIXEL;
this.descriptionLabel.autoSize = TextFieldAutoSize.LEFT;
this.descriptionLabel.wordWrap = false;
this.descriptionLabel.multiline = true;
this.descriptionLabel.selectable = false;
addChild(this.descriptionLabel);
this.descriptionLabel.x = this.margin - 3;
this.descriptionLabel.y = this.margin - 4;
this.descriptionLabel.mouseEnabled = false;
this.descriptionLabel.tabEnabled = false;
}
override public function draw(param1:Point) : void {
_size.x = int(param1.x);
_size.y = int(param1.y);
this.outline.graphics.clear();
this.outline.graphics.beginFill(lineColor,lineAlpha);
this.outline.graphics.drawRoundRect(-lineThickness,-lineThickness,param1.x + lineThickness * 2,param1.y + lineThickness * 2,r + 2,r + 2);
this.outline.graphics.drawRoundRect(0,0,param1.x,param1.y,r,r);
this.back.graphics.clear();
this.back.graphics.beginFill(fillColor,fillAlpha);
this.back.graphics.drawRoundRect(0,0,param1.x,param1.y,r,r);
var local2:Number = this._arrowLehgth / arrowWidth;
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.arrowP1.y = 0;
this.arrowP2.y = 0;
this.arrowTarget.y = -this._arrowLehgth;
this.outlineArrowP1.y = 0;
this.outlineArrowP2.y = 0;
this.outlineArrowTarget.y = -local2 * (arrowWidth + lineThickness * 2);
} else if(Boolean(this._arrowAlign & HelperAlign.MIDDLE_MASK)) {
this.arrowP1.y = param1.y - arrowWidth >> 1;
this.arrowP2.y = this.arrowP1.y + arrowWidth;
this.arrowTarget.y = this.arrowP1.y;
this.outlineArrowP1.y = this.arrowP1.y - lineThickness;
this.outlineArrowP2.y = this.arrowP1.y + arrowWidth + lineThickness;
this.outlineArrowTarget.y = this.outlineArrowP1.y;
} else {
this.arrowP1.y = param1.y;
this.arrowP2.y = param1.y;
this.arrowTarget.y = param1.y + this._arrowLehgth;
this.outlineArrowP1.y = param1.y;
this.outlineArrowP2.y = param1.y;
this.outlineArrowTarget.y = param1.y + local2 * (arrowWidth + lineThickness * 2);
}
if(Boolean(this._arrowAlign & HelperAlign.LEFT_MASK)) {
if(this.arrowDirection == HelperArrowDirection.VERTICAL) {
this.arrowTarget.x = arrowShift;
this.arrowP1.x = arrowShift;
this.arrowP2.x = arrowShift + arrowWidth;
this.outlineArrowTarget.x = arrowShift - lineThickness;
this.outlineArrowP1.x = arrowShift - lineThickness;
this.outlineArrowP2.x = arrowShift + arrowWidth + lineThickness;
} else {
this.arrowTarget.x = -this._arrowLehgth;
this.arrowP1.x = 0;
this.arrowP2.x = 0;
this.outlineArrowTarget.x = -local2 * (arrowWidth + lineThickness * 2);
this.outlineArrowP1.x = 0;
this.outlineArrowP2.x = 0;
}
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y - lineThickness,this.arrowP2.x - this.arrowP1.x,lineThickness);
} else if(Boolean(this._arrowAlign & HelperAlign.MIDDLE_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x - lineThickness,this.arrowP1.y,lineThickness,this.arrowP2.y - this.arrowP1.y);
} else {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,this.arrowP2.x - this.arrowP1.x,lineThickness);
}
} else if(Boolean(this._arrowAlign & HelperAlign.CENTER_MASK)) {
this.arrowTarget.x = param1.x - arrowWidth >> 1;
this.arrowP1.x = this.arrowTarget.x;
this.arrowP2.x = this.arrowTarget.x + arrowWidth;
this.outlineArrowTarget.x = this.arrowTarget.x - lineThickness;
this.outlineArrowP1.x = this.outlineArrowTarget.x;
this.outlineArrowP2.x = this.arrowP2.x + lineThickness;
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y - lineThickness,this.arrowP2.x - this.arrowP1.x,lineThickness);
} else {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,this.arrowP2.x - this.arrowP1.x,lineThickness);
}
} else {
if(this.arrowDirection == HelperArrowDirection.VERTICAL) {
this.arrowTarget.x = param1.x - arrowShift;
this.arrowP1.x = this.arrowTarget.x;
this.arrowP2.x = this.arrowP1.x - arrowWidth;
this.outlineArrowTarget.x = this.arrowTarget.x + lineThickness;
this.outlineArrowP1.x = this.outlineArrowTarget.x;
this.outlineArrowP2.x = this.arrowTarget.x - arrowWidth - lineThickness;
} else {
this.arrowTarget.x = param1.x + this._arrowLehgth;
this.arrowP1.x = param1.x;
this.arrowP2.x = param1.x;
this.outlineArrowTarget.x = param1.x + local2 * (arrowWidth + lineThickness * 2);
this.outlineArrowP1.x = param1.x;
this.outlineArrowP2.x = param1.x;
}
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y - lineThickness,this.arrowP2.x - this.arrowP1.x,lineThickness);
} else if(Boolean(this._arrowAlign & HelperAlign.MIDDLE_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,lineThickness,this.arrowP2.y - this.arrowP1.y);
} else {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,this.arrowP2.x - this.arrowP1.x,lineThickness);
}
}
this.back.graphics.moveTo(this.arrowTarget.x,this.arrowTarget.y);
this.back.graphics.lineTo(this.arrowP1.x,this.arrowP1.y);
this.back.graphics.lineTo(this.arrowP2.x,this.arrowP2.y);
this.back.graphics.lineTo(this.arrowTarget.x,this.arrowTarget.y);
this.outline.graphics.beginFill(lineColor,lineAlpha);
this.outline.graphics.moveTo(this.outlineArrowTarget.x,this.outlineArrowTarget.y);
this.outline.graphics.lineTo(this.outlineArrowP1.x,this.outlineArrowP1.y);
this.outline.graphics.lineTo(this.outlineArrowP2.x,this.outlineArrowP2.y);
this.outline.graphics.lineTo(this.outlineArrowTarget.x,this.outlineArrowTarget.y);
this.outline.graphics.moveTo(this.arrowTarget.x,this.arrowTarget.y);
this.outline.graphics.lineTo(this.arrowP1.x,this.arrowP1.y);
this.outline.graphics.lineTo(this.arrowP2.x,this.arrowP2.y);
this.outline.graphics.lineTo(this.arrowTarget.x,this.arrowTarget.y);
var local3:String = display.stage.quality;
display.stage.quality = StageQuality.HIGH;
var local4:Matrix = new Matrix();
if(this.outlineArrowTarget.x < 0) {
local4.tx = -Math.round(this.outlineArrowTarget.x);
this.bmp.x = Math.round(this.outlineArrowTarget.x);
} else {
local4.tx = lineThickness;
this.bmp.x = -lineThickness;
}
if(this.outlineArrowTarget.y < 0) {
local4.ty = -Math.round(this.outlineArrowTarget.y);
this.bmp.y = Math.round(this.outlineArrowTarget.y);
} else {
local4.ty = lineThickness;
this.bmp.y = -lineThickness;
}
this.bmp.bitmapData = new BitmapData(Math.round(this.outline.width),Math.round(this.outline.height),true,0);
this.bmp.bitmapData.draw(this.backContainer,local4,new ColorTransform(),BlendMode.NORMAL,null,true);
display.stage.quality = local3;
this.descriptionLabel.width = param1.x - this.margin * 2;
}
override public function align(param1:int, param2:int) : void {
this.doAlign();
}
protected function doAlign() : void {
var local1:Point = null;
if(parent != null) {
local1 = parent.globalToLocal(_targetPoint);
this.x = Math.round(local1.x - this.outlineArrowTarget.x);
this.y = Math.round(local1.y - this.outlineArrowTarget.y);
}
}
public function get arrowLehgth() : int {
return this._arrowLehgth;
}
public function set arrowLehgth(param1:int) : void {
this._arrowLehgth = param1;
}
public function get arrowAlign() : int {
return this._arrowAlign;
}
public function set arrowAlign(param1:int) : void {
if(param1 == HelperAlign.MIDDLE_CENTER) {
this._arrowAlign = HelperAlign.BOTTOM_LEFT;
} else {
this._arrowAlign = param1;
}
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK) || Boolean(this._arrowAlign & HelperAlign.BOTTOM_MASK)) {
this.arrowDirection = HelperArrowDirection.VERTICAL;
} else {
this.arrowDirection = HelperArrowDirection.HORIZONTAL;
}
}
public function set text(param1:String) : void {
this.descriptionLabel.htmlText = param1;
_size.x = Math.round(this.descriptionLabel.textWidth + this.margin * 2);
_size.y = Math.round(this.descriptionLabel.textHeight + this.margin * 2) - 3;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.map {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.map.BattleMapCC;
public class VectorCodecBattleMapCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleMapCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleMapCC,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.<BattleMapCC> = new Vector.<BattleMapCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleMapCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleMapCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleMapCC> = Vector.<BattleMapCC>(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.garage.models.item.upgradeable.types {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.commons.types.ItemGarageProperty;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
import projects.tanks.client.garage.models.item.upgradeable.types.PropertyData;
public class CodecGaragePropertyParams implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_precision:ICodec;
private var codec_properties:ICodec;
private var codec_property:ICodec;
private var codec_visibleInInfo:ICodec;
public function CodecGaragePropertyParams() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_precision = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_properties = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(PropertyData,false),false,1));
this.codec_property = param1.getCodec(new EnumCodecInfo(ItemGarageProperty,false));
this.codec_visibleInInfo = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:GaragePropertyParams = new GaragePropertyParams();
local2.precision = this.codec_precision.decode(param1) as int;
local2.properties = this.codec_properties.decode(param1) as Vector.<PropertyData>;
local2.property = this.codec_property.decode(param1) as ItemGarageProperty;
local2.visibleInInfo = this.codec_visibleInInfo.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:GaragePropertyParams = GaragePropertyParams(param2);
this.codec_precision.encode(param1,local3.precision);
this.codec_properties.encode(param1,local3.properties);
this.codec_property.encode(param1,local3.property);
this.codec_visibleInInfo.encode(param1,local3.visibleInInfo);
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.paygarden {
public class PayGardenPaymentCC {
private var _productType:PayGardenProductType;
public function PayGardenPaymentCC(param1:PayGardenProductType = null) {
super();
this._productType = param1;
}
public function get productType() : PayGardenProductType {
return this._productType;
}
public function set productType(param1:PayGardenProductType) : void {
this._productType = param1;
}
public function toString() : String {
var local1:String = "PayGardenPaymentCC [";
local1 += "productType = " + this.productType + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.garage.models.item.container {
public class ContainerItemCategory {
public static const COMMON:ContainerItemCategory = new ContainerItemCategory(0,"COMMON");
public static const UNCOMMON:ContainerItemCategory = new ContainerItemCategory(1,"UNCOMMON");
public static const RARE:ContainerItemCategory = new ContainerItemCategory(2,"RARE");
public static const EPIC:ContainerItemCategory = new ContainerItemCategory(3,"EPIC");
public static const LEGENDARY:ContainerItemCategory = new ContainerItemCategory(4,"LEGENDARY");
public static const EXOTIC:ContainerItemCategory = new ContainerItemCategory(5,"EXOTIC");
private var _value:int;
private var _name:String;
public function ContainerItemCategory(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<ContainerItemCategory> {
var local1:Vector.<ContainerItemCategory> = new Vector.<ContainerItemCategory>();
local1.push(COMMON);
local1.push(UNCOMMON);
local1.push(RARE);
local1.push(EPIC);
local1.push(LEGENDARY);
local1.push(EXOTIC);
return local1;
}
public function toString() : String {
return "ContainerItemCategory [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.battle {
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public interface TeamDMTargetEvaluator {
function setLocalTeamType(param1:BattleTeam) : void;
}
}
|
package alternativa.tanks.loader
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ProgressBar_bitmapLampOn extends BitmapAsset
{
public function ProgressBar_bitmapLampOn()
{
super();
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
public class BonusMesh extends Mesh
{
private var objectId:String;
private var ownAlpha:Number = 1;
private var alphaMultiplier:Number = 1;
public function BonusMesh(objectId:String, sourceMesh:Mesh)
{
super();
this.objectId = objectId;
clonePropertiesFrom(sourceMesh);
var face:Face = sourceMesh.faces[0];
setMaterialToAllFaces(face.material);
shadowMapAlphaThreshold = 0.1;
calculateVerticesNormalsBySmoothingGroups(0.01);
sorting = Sorting.DYNAMIC_BSP;
name = "bonus";
rotationX = 0;
rotationY = 0;
rotationZ = 0;
scaleX = 1;
scaleY = 1;
scaleZ = 1;
this.ownAlpha = 1;
this.alphaMultiplier = 1;
this.updateAlpha();
}
public function getObjectId() : String
{
return this.objectId;
}
public function getAlpha() : Number
{
return this.ownAlpha;
}
public function setAlpha(value:Number) : void
{
this.ownAlpha = value;
this.updateAlpha();
}
public function readPosition(result:Vector3) : void
{
result.x = x;
result.y = y;
result.z = z;
}
public function setAlphaMultiplier(value:Number) : void
{
this.alphaMultiplier = value;
this.updateAlpha();
}
private function updateAlpha() : void
{
alpha = this.alphaMultiplier * this.ownAlpha;
}
public function recycle() : void
{
this.ownAlpha = 1;
this.alphaMultiplier = 1;
BonusCache.putBonusMesh(this);
}
}
}
|
package projects.tanks.client.panel.model.shop.shopcategory {
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 ShopCategoryModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ShopCategoryModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.model.quest.common.gui.window.buttons {
import alternativa.osgi.service.locale.ILocaleService;
import controls.base.ThreeLineBigButton;
import controls.labels.MouseDisabledLabel;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class DailyQuestDisabledPrizeButton extends ThreeLineBigButton {
[Inject]
public static var localeService:ILocaleService;
private var priceLabel:MouseDisabledLabel;
public function DailyQuestDisabledPrizeButton() {
super();
this.priceLabel = new MouseDisabledLabel();
this.priceLabel.size = 11;
super.setText(localeService.getText(TanksLocale.TEXT_DAILY_QUEST_GET_PRIZE));
super.showInOneRow(captionLabel);
}
}
}
|
package alternativa.tanks.controller.commands.socialnetwork {
import alternativa.tanks.controller.events.socialnetwork.StartExternalEntranceEvent;
import alternativa.tanks.model.EntranceUrlParamsModel;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Command;
public class StartExternalLoginUserCommand extends Command {
[Inject]
public var event:StartExternalEntranceEvent;
[Inject]
public var serverFacade:IEntranceServerFacade;
[Inject]
public var urlParams:EntranceUrlParamsModel;
public function StartExternalLoginUserCommand() {
super();
}
override public function execute() : void {
this.serverFacade.startExternalLoginUser(this.event.socialNetworkId,this.event.rememberMe,this.urlParams.domain);
}
}
}
|
package alternativa.tanks.models.weapons.targeting.direction.sector.splitter {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapons.targeting.direction.*;
import alternativa.tanks.models.weapons.targeting.direction.sector.TargetingSector;
import alternativa.tanks.models.weapons.targeting.priority.TargetingPriorityCalculator;
public class SectorsSplitter {
private const DIRECTIONS_PER_SECTOR:int = 16;
private var targetPriority:TargetingPriorityCalculator;
private var matrix:Matrix3 = new Matrix3();
private var direction:Vector3 = new Vector3();
private var directions:Vector.<TargetingDirection> = new Vector.<TargetingDirection>();
private var currentOverlapSectors:SortedTargetingSectors = new SortedTargetingSectors();
public function SectorsSplitter(param1:TargetingPriorityCalculator) {
super();
this.targetPriority = param1;
}
public function splitSectorsOnDirections(param1:AllGlobalGunParams, param2:Vector.<TargetingSector>) : Vector.<TargetingDirection> {
var local4:TargetingSector = null;
var local5:Number = NaN;
var local6:Number = NaN;
var local3:Number = Number.NEGATIVE_INFINITY;
this.directions.length = 0;
this.currentOverlapSectors.clear();
for each(local4 in param2) {
local5 = local4.getLeft();
while(!this.currentOverlapSectors.isEmpty() && local3 < local5) {
local6 = Math.min(this.currentOverlapSectors.getRight(),local5);
this.addDirections(param1,local3,local6);
this.currentOverlapSectors.removeSectorsWhichRightCoordIsLessOrEqualThan(local6);
local3 = local6;
}
local3 = local5;
this.currentOverlapSectors.add(local4);
}
while(!this.currentOverlapSectors.isEmpty()) {
local6 = this.currentOverlapSectors.getRight();
this.addDirections(param1,local3,local6);
this.currentOverlapSectors.removeSectorsWhichRightCoordIsLessOrEqualThan(local6);
local3 = local6;
}
return this.directions;
}
private function addDirections(param1:AllGlobalGunParams, param2:Number, param3:Number) : void {
var local9:Vector3 = null;
var local4:Number = param3 - param2;
var local5:Number = local4 / this.DIRECTIONS_PER_SECTOR;
var local6:Number = param2 + local5 * 0.5;
var local7:Vector.<TargetingSector> = this.currentOverlapSectors.getOrderedByDistance();
this.matrix.fromAxisAngle(param1.elevationAxis,local6);
this.matrix.transformVector(param1.direction,this.direction);
this.matrix.fromAxisAngle(param1.elevationAxis,local5);
var local8:int = 0;
while(local8 < this.DIRECTIONS_PER_SECTOR) {
this.directions.push(new TargetingDirection(this.direction,local6,this.targetPriority.getPriorityForSectors(local6,local7)));
local9 = BattleUtils.tmpVector;
local9.copy(this.direction);
this.matrix.transformVector(local9,this.direction);
local6 += local5;
local8++;
}
if(param2 <= 0 && 0 <= param3) {
this.directions.push(new TargetingDirection(param1.direction,0,this.targetPriority.getPriorityForSectors(0,local7)));
}
}
}
}
|
package alternativa.tanks.models.panel.clanpanel {
import alternativa.tanks.models.service.ClanService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.clans.panel.clanpanel.ClanPanelModelBase;
import projects.tanks.client.clans.panel.clanpanel.IClanPanelModelBase;
[ModelInfo]
public class ClanPanelModel extends ClanPanelModelBase implements IClanPanelModelBase, IClanPanelModel, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var clanService:ClanService;
public function ClanPanelModel() {
super();
}
public function objectLoaded() : void {
clanService.clanPanelModel = IClanPanelModel(object.adapt(IClanPanelModel));
}
public function sendInviteToClan(param1:Long) : void {
server.sendInviteToClan(param1);
}
public function objectUnloaded() : void {
clanService.clanPanelModel = null;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.artillery {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class WeaponRotationLimitModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:WeaponRotationLimitModelServer;
private var client:IWeaponRotationLimitModelBase = IWeaponRotationLimitModelBase(this);
private var modelId:Long = Long.getLong(1326062457,-784723685);
public function WeaponRotationLimitModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new WeaponRotationLimitModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank04.png")]
public class PremiumRankBitmaps_bitmapSmallRank04 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank04() {
super();
}
}
}
|
package alternativa.tanks
{
import flash.geom.Vector3D;
public class Triangle extends Polygon
{
public function Triangle(v0:Vector3D, v1:Vector3D, v2:Vector3D, twoSided:Boolean)
{
var points:Vector.<Number> = Vector.<Number>([v0.x,v0.y,v0.z,v1.x,v1.y,v1.z,v2.x,v2.y,v2.z]);
var uv:Vector.<Number> = Vector.<Number>([0,0,0,1,1,1]);
super(points,uv,twoSided);
}
}
}
|
package alternativa.engine3d.loaders.collada {
import flash.utils.Dictionary;
use namespace collada;
public class DaeInstanceController extends DaeElement {
public var node:DaeNode;
public var topmostJoints:Vector.<DaeNode>;
public function DaeInstanceController(param1:XML, param2:DaeDocument, param3:DaeNode) {
super(param1,param2);
this.node = param3;
}
override protected function parseImplementation() : Boolean {
var local1:DaeController = this.controller;
if(local1 != null) {
this.topmostJoints = local1.findRootJointNodes(this.skeletons);
if(this.topmostJoints != null && this.topmostJoints.length > 1) {
this.replaceNodesByTopmost(this.topmostJoints);
}
}
return this.topmostJoints != null;
}
private function replaceNodesByTopmost(param1:Vector.<DaeNode>) : void {
var local2:int = 0;
var local3:DaeNode = null;
var local4:DaeNode = null;
var local5:int = int(param1.length);
var local6:Dictionary = new Dictionary();
local2 = 0;
while(local2 < local5) {
local3 = param1[local2];
local4 = local3.parent;
while(local4 != null) {
if(Boolean(local6[local4])) {
++local6[local4];
} else {
local6[local4] = 1;
}
local4 = local4.parent;
}
local2++;
}
local2 = 0;
while(local2 < local5) {
local3 = param1[local2];
while(true) {
local4 = local3.parent;
if(!(local4 != null && local6[local4] != local5)) {
break;
}
local3 = local3.parent;
}
param1[local2] = local3;
local2++;
}
}
private function get controller() : DaeController {
var local1:DaeController = document.findController(data.@url[0]);
if(local1 == null) {
document.logger.logNotFoundError(data.@url[0]);
}
return local1;
}
private function get skeletons() : Vector.<DaeNode> {
var local2:Vector.<DaeNode> = null;
var local3:int = 0;
var local4:int = 0;
var local5:XML = null;
var local6:DaeNode = null;
var local1:XMLList = data.skeleton;
if(local1.length() > 0) {
local2 = new Vector.<DaeNode>();
local3 = 0;
local4 = int(local1.length());
while(local3 < local4) {
local5 = local1[local3];
local6 = document.findNode(local5.text()[0]);
if(local6 != null) {
local2.push(local6);
} else {
document.logger.logNotFoundError(local5);
}
local3++;
}
return local2;
}
return null;
}
public function parseSkin(param1:Object) : DaeObject {
var local2:DaeController = this.controller;
if(local2 != null) {
local2.parse();
return local2.parseSkin(param1,this.topmostJoints,this.skeletons);
}
return null;
}
}
}
|
package alternativa.utils {
import flash.utils.Dictionary;
public function clearDictionary(param1:Dictionary) : void {
var local2:* = undefined;
for(local2 in param1) {
delete param1[local2];
}
}
}
|
package projects.tanks.client.battlefield.models.effects.duration.time {
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 DurationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function DurationModelServer(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_bitmapSmallRank19.png")]
public class DefaultRanksBitmaps_bitmapSmallRank19 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank19() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.statistics.targetingmode {
public class TargetingMode {
public static const NONE:TargetingMode = new TargetingMode(0,"NONE");
public static const KEYBOARD:TargetingMode = new TargetingMode(1,"KEYBOARD");
public static const MOUSE_LOOK:TargetingMode = new TargetingMode(2,"MOUSE_LOOK");
private var _value:int;
private var _name:String;
public function TargetingMode(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<TargetingMode> {
var local1:Vector.<TargetingMode> = new Vector.<TargetingMode>();
local1.push(NONE);
local1.push(KEYBOARD);
local1.push(MOUSE_LOOK);
return local1;
}
public function toString() : String {
return "TargetingMode [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.models.service {
import flash.events.Event;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public class ClanServiceUpdateEvent extends Event {
public static const UPDATE:String = "CreateClanServiceEvent.UPDATE";
public var description:String;
public var flag:ClanFlag;
public var rankIndex:int;
public var incomingRequestsEnabled:Boolean;
public function ClanServiceUpdateEvent(param1:String, param2:String, param3:int, param4:ClanFlag, param5:Boolean, param6:Boolean = false, param7:Boolean = false) {
this.description = param2;
this.flag = param4;
this.rankIndex = param3;
this.incomingRequestsEnabled = param5;
super(param1,param6,param7);
}
}
}
|
package alternativa.tanks.controller.commands.captcha {
import alternativa.tanks.controller.events.CheckCaptchaAnswerEvent;
import alternativa.tanks.service.ICaptchaService;
import org.robotlegs.mvcs.Command;
public class CheckCaptchaAnswerCommand extends Command {
[Inject]
public var captchaService:ICaptchaService;
[Inject]
public var event:CheckCaptchaAnswerEvent;
public function CheckCaptchaAnswerCommand() {
super();
}
override public function execute() : void {
commandMap.detain(this);
this.captchaService.checkAnswer(this.event.location,this.event.captchaAnswer,this.onCaptchaAnswerCorrect);
}
private function onCaptchaAnswerCorrect() : void {
commandMap.release(this);
dispatch(this.event.onSuccessEvent);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.shoot.thunder {
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 platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingSFXEntity;
import projects.tanks.client.battlefield.models.tankparts.sfx.shoot.thunder.ThunderShootSFXCC;
public class CodecThunderShootSFXCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_explosionMarkTexture:ICodec;
private var codec_explosionSize:ICodec;
private var codec_explosionSound:ICodec;
private var codec_explosionTexture:ICodec;
private var codec_lightingSFXEntity:ICodec;
private var codec_shotSound:ICodec;
private var codec_shotTexture:ICodec;
public function CodecThunderShootSFXCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_explosionMarkTexture = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_explosionSize = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_explosionSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_explosionTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_lightingSFXEntity = param1.getCodec(new TypeCodecInfo(LightingSFXEntity,false));
this.codec_shotSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_shotTexture = param1.getCodec(new TypeCodecInfo(TextureResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ThunderShootSFXCC = new ThunderShootSFXCC();
local2.explosionMarkTexture = this.codec_explosionMarkTexture.decode(param1) as TextureResource;
local2.explosionSize = this.codec_explosionSize.decode(param1) as Number;
local2.explosionSound = this.codec_explosionSound.decode(param1) as SoundResource;
local2.explosionTexture = this.codec_explosionTexture.decode(param1) as MultiframeTextureResource;
local2.lightingSFXEntity = this.codec_lightingSFXEntity.decode(param1) as LightingSFXEntity;
local2.shotSound = this.codec_shotSound.decode(param1) as SoundResource;
local2.shotTexture = this.codec_shotTexture.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:ThunderShootSFXCC = ThunderShootSFXCC(param2);
this.codec_explosionMarkTexture.encode(param1,local3.explosionMarkTexture);
this.codec_explosionSize.encode(param1,local3.explosionSize);
this.codec_explosionSound.encode(param1,local3.explosionSound);
this.codec_explosionTexture.encode(param1,local3.explosionTexture);
this.codec_lightingSFXEntity.encode(param1,local3.lightingSFXEntity);
this.codec_shotSound.encode(param1,local3.shotSound);
this.codec_shotTexture.encode(param1,local3.shotTexture);
}
}
}
|
package alternativa.tanks.models.tank.ultimate.hunter {
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.sfx.Sound3D;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.display.BlendMode;
import flash.geom.Vector3D;
public class ElectroEffect extends PooledObject implements GraphicEffect {
private static const SIZE:int = 600;
private static const FRAMES:int = 2;
public static const FADE:Number = 0.5;
public static const MID:Number = 10 / 60;
public static const END:Number = 30 / 60;
public static const OFFSET:Number = 150;
private static const vector:Vector3D = new Vector3D();
private static const vector3:Vector3 = new Vector3();
private var container:Scene3DContainer;
private var target:Object3D;
private var sprite:Sprite3D;
private var time:Number;
private var fadeOut:Boolean;
private var fadeOutTime:Number;
private var frame:int = 0;
private var sound:Sound3D;
public function ElectroEffect(param1:Pool) {
super(param1);
this.sprite = new Sprite3D(SIZE,SIZE);
this.sprite.rotation = Math.random() * Math.PI * 2;
this.sprite.useLight = false;
this.sprite.useShadowMap = false;
this.sprite.blendMode = BlendMode.ADD;
this.sprite.softAttenuation = 20;
}
public function init(param1:TextureMaterial, param2:Object3D, param3:Sound3D) : void {
this.target = param2;
this.sound = param3;
this.time = 0;
this.sprite.material = param1;
this.sprite.topLeftU = 0;
this.sprite.bottomRightU = 0.5;
this.fadeOut = false;
this.fadeOutTime = 0;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.sprite);
this.sound.play(0,100000);
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local4:Number = NaN;
var local3:Number = param1 / 1000;
this.time += local3;
vector.x = param2.x - this.target.x;
vector.y = param2.y - this.target.y;
vector.z = param2.z - this.target.z + 50;
vector.normalize();
vector3.reset(this.target.x,this.target.y,this.target.z + 50);
this.sound.checkVolume(param2.position,vector3,param2.xAxis);
this.sprite.x = this.target.x + vector.x * OFFSET;
this.sprite.y = this.target.y + vector.y * OFFSET;
this.sprite.z = this.target.z + vector.z * OFFSET + 100;
if(this.fadeOut) {
this.fadeOutTime += local3;
local4 = 1 - this.fadeOutTime / FADE;
if(local4 >= 0) {
this.sprite.alpha = local4;
return true;
}
return false;
}
if(this.time <= MID) {
this.sprite.alpha = this.time / MID;
} else if(this.time <= END) {
this.sprite.alpha = 1 - (this.time - MID) / (END - MID);
} else {
this.switchFrame();
}
return true;
}
private function switchFrame() : void {
this.frame = (this.frame + 1) % FRAMES;
this.sprite.topLeftU = 1 / FRAMES * this.frame;
this.sprite.bottomRightU = 0.5 + 1 / FRAMES * this.frame;
this.sprite.rotation = Math.random() * Number.PI * 2;
this.time = 0;
}
public function destroy() : void {
this.container.removeChild(this.sprite);
this.container = null;
this.sound.stop();
this.sound = null;
this.sprite.material = null;
this.target = null;
recycle();
}
public function kill() : void {
this.sprite.alpha = 0;
}
public function stop() : void {
this.fadeOut = true;
if(this.sound != null) {
this.sound.stop();
}
}
}
}
|
package alternativa.tanks.services.mipmapping.impl {
import alternativa.tanks.services.mipmapping.*;
import alternativa.utils.TextureMaterialRegistry;
public class DefaultMipMappingService implements MipMappingService {
private var mipMappingEnabled:Boolean;
private var materialRegistries:Vector.<TextureMaterialRegistry> = new Vector.<TextureMaterialRegistry>();
public function DefaultMipMappingService() {
super();
}
public function isMipMappingEnabled() : Boolean {
return this.mipMappingEnabled;
}
public function setMipMapping(param1:Boolean) : void {
var local2:TextureMaterialRegistry = null;
if(this.mipMappingEnabled != param1) {
this.mipMappingEnabled = param1;
for each(local2 in this.materialRegistries) {
local2.setMipMapping(param1);
}
}
}
public function toggleMipMapping() : void {
this.setMipMapping(!this.mipMappingEnabled);
}
public function addMaterialRegistry(param1:TextureMaterialRegistry) : void {
this.materialRegistries.push(param1);
param1.setMipMapping(this.mipMappingEnabled);
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.vkontakte {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.forms.GoToUrlForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.modes.asyncurl.AsyncUrlPayMode;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import flash.external.ExternalInterface;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.partners.impl.vkontakte.IVkontaktePaymentModelBase;
import projects.tanks.client.partners.impl.vkontakte.VkontaktePaymentModelBase;
[ModelInfo]
public class VkontaktePaymentModel extends VkontaktePaymentModelBase implements IVkontaktePaymentModelBase, AsyncUrlPayMode, ObjectLoadListener, PayModeView, ObjectUnloadListener {
[Inject]
public static var paymentWindowService:PaymentWindowService;
public function VkontaktePaymentModel() {
super();
}
public function requestAsyncUrl() : void {
server.getPaymentTransaction(paymentWindowService.getChosenItem().id);
}
public function receivePaymentTransaction(param1:String) : void {
if(ExternalInterface.available) {
ExternalInterface.call("showVkontaktePaymentForItem",param1);
}
paymentWindowService.switchToBeginning();
}
public function getView() : PayModeForm {
return PayModeForm(getData(PayModeForm));
}
public function objectLoaded() : void {
putData(PayModeForm,new GoToUrlForm(object));
}
public function objectUnloaded() : void {
this.getView().destroy();
clearData(PayModeForm);
}
}
}
|
package alternativa.tanks.models.weapons.charging {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponChargingListenerEvents implements WeaponChargingListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function WeaponChargingListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function handleChargingStart() : void {
var i:int = 0;
var m:WeaponChargingListener = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponChargingListener(this.impl[i]);
m.handleChargingStart();
i++;
}
}
finally {
Model.popObject();
}
}
public function handleChargingFinish(param1:int) : void {
var i:int = 0;
var m:WeaponChargingListener = null;
var durationMs:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponChargingListener(this.impl[i]);
m.handleChargingFinish(durationMs);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.china.partner4399 {
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.service.address.AddressService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.partners.impl.china.partner4399.IPartner4399ModelBase;
import projects.tanks.client.partners.impl.china.partner4399.Partner4399ModelBase;
[ModelInfo]
public class Partner4399Model extends Partner4399ModelBase implements IPartner4399ModelBase, IPartner {
[Inject]
public static var addressService:AddressService;
private static const PAYMENT_URL:String = "http://cz.4399.com/3dtk/?je=50";
public function Partner4399Model() {
super();
}
public function getLoginParameters(param1:IParametersListener) : void {
var local2:Dictionary = new Dictionary();
local2["username"] = addressService.getQueryParameter("username");
local2["serverid"] = addressService.getQueryParameter("serverid");
local2["time"] = addressService.getQueryParameter("time");
local2["site"] = addressService.getQueryParameter("site");
local2["flag"] = addressService.getQueryParameter("flag");
local2["cm"] = addressService.getQueryParameter("cm");
param1.onSetParameters(new LoginParameters(local2));
}
public function getFailRedirectUrl() : String {
return "http://my.4399.com/yxtk/";
}
public function isExternalLoginAllowed() : Boolean {
return false;
}
public function hasPaymentAction() : Boolean {
return true;
}
public function paymentAction() : void {
navigateToURL(new URLRequest(PAYMENT_URL),"_blank");
}
public function hasRatings() : Boolean {
return false;
}
}
}
|
package alternativa.tanks.models.sfx.colortransform {
[ModelInterface]
public interface ColorTransformConsumer {
function initColorTransform(param1:Vector.<ColorTransformEntry>) : void;
}
}
|
package projects.tanks.client.battlefield.models.bonus.bonus.battlebonuses.crystal {
import platform.client.fp10.core.type.IGameObject;
public interface IBattleGoldBonusesModelBase {
function goldTaken(param1:IGameObject) : void;
}
}
|
package alternativa.tanks.model.payment.shop.item {
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 ShopItemEvents implements ShopItem {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ShopItemEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getPrice() : Number {
var result:Number = NaN;
var i:int = 0;
var m:ShopItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItem(this.impl[i]);
result = Number(m.getPrice());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPriceWithDiscount() : Number {
var result:Number = NaN;
var i:int = 0;
var m:ShopItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItem(this.impl[i]);
result = Number(m.getPriceWithDiscount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getCurrencyName() : String {
var result:String = null;
var i:int = 0;
var m:ShopItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItem(this.impl[i]);
result = m.getCurrencyName();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getCurrencyRoundingPrecision() : int {
var result:int = 0;
var i:int = 0;
var m:ShopItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItem(this.impl[i]);
result = int(m.getCurrencyRoundingPrecision());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPreview() : ImageResource {
var result:ImageResource = null;
var i:int = 0;
var m:ShopItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItem(this.impl[i]);
result = m.getPreview();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.model.payment.shop.crystal {
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import alternativa.tanks.gui.shop.shopitems.item.crystalitem.CrystalPackageButton;
import alternativa.tanks.model.payment.shop.ShopItemView;
import alternativa.tanks.model.payment.shop.cashpackage.CashPackage;
import projects.tanks.client.panel.model.shop.crystalpackage.CrystalPackageModelBase;
import projects.tanks.client.panel.model.shop.crystalpackage.ICrystalPackageModelBase;
[ModelInfo]
public class CrystalPackageModel extends CrystalPackageModelBase implements ICrystalPackageModelBase, CrystalPackage, CashPackage, ShopItemView {
public function CrystalPackageModel() {
super();
}
public function getAmount() : int {
return getInitParam().crystals;
}
public function getBonusAmount() : int {
return getInitParam().bonusCrystals;
}
public function getPremiumDurationInDays() : int {
return getInitParam().premiumDurationInDays;
}
public function getButtonView() : ShopButton {
return new CrystalPackageButton(object);
}
}
}
|
package alternativa.tanks.models.user {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IClanUserModelEvents implements IClanUserModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IClanUserModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function loadingInServiceSpace() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IClanUserModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserModel(this.impl[i]);
result = Boolean(m.loadingInServiceSpace());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function addInClan(param1:IGameObject) : void {
var i:int = 0;
var m:IClanUserModel = null;
var clan:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserModel(this.impl[i]);
m.addInClan(clan);
i++;
}
}
finally {
Model.popObject();
}
}
public function rejectAll() : void {
var i:int = 0;
var m:IClanUserModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserModel(this.impl[i]);
m.rejectAll();
i++;
}
}
finally {
Model.popObject();
}
}
public function revoke(param1:IGameObject) : void {
var i:int = 0;
var m:IClanUserModel = null;
var clan:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserModel(this.impl[i]);
m.revoke(clan);
i++;
}
}
finally {
Model.popObject();
}
}
public function reject(param1:IGameObject) : void {
var i:int = 0;
var m:IClanUserModel = null;
var clan:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserModel(this.impl[i]);
m.reject(clan);
i++;
}
}
finally {
Model.popObject();
}
}
public function acceptRequest(param1:IGameObject) : void {
var i:int = 0;
var m:IClanUserModel = null;
var clan:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserModel(this.impl[i]);
m.acceptRequest(clan);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package _codec.projects.tanks.client.users.model.userbattlestatistics.rank {
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.users.model.userbattlestatistics.rank.RankBounds;
public class VectorCodecRankBoundsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRankBoundsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RankBounds,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.<RankBounds> = new Vector.<RankBounds>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RankBounds(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RankBounds = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RankBounds> = Vector.<RankBounds>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.TankWindowInner_bottomLeftClass.png")]
public class TankWindowInner_bottomLeftClass extends BitmapAsset {
public function TankWindowInner_bottomLeftClass() {
super();
}
}
}
|
package alternativa.model
{
import alternativa.object.ClientObject;
import alternativa.protocol.codec.NullMap;
import alternativa.protocol.factory.ICodecFactory;
import flash.utils.IDataInput;
public interface IModel
{
function _initObject(param1:ClientObject, param2:Object) : void;
function invoke(param1:ClientObject, param2:String, param3:ICodecFactory, param4:IDataInput, param5:NullMap) : void;
function get id() : String;
function get interfaces() : Vector.<Class>;
}
}
|
package alternativa.tanks.gui.payment.controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.payment.controls.ProceedButton_ButtonDownCenter.png")]
public class ProceedButton_ButtonDownCenter extends BitmapAsset {
public function ProceedButton_ButtonDownCenter() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.sfx {
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 MachineGunSFXModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MachineGunSFXModelServer;
private var client:IMachineGunSFXModelBase = IMachineGunSFXModelBase(this);
private var modelId:Long = Long.getLong(2045216394,-936740390);
public function MachineGunSFXModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MachineGunSFXModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(MachineGunSFXCC,false)));
}
protected function getInitParam() : MachineGunSFXCC {
return MachineGunSFXCC(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 platform.client.fp10.core.resource {
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.display.BlendMode;
import flash.geom.Matrix;
import flash.geom.Point;
public class ResourceUtils {
public function ResourceUtils() {
super();
}
public static function mergeBitmapAlpha(param1:BitmapData, param2:BitmapData, param3:Boolean = false) : BitmapData {
var local6:BitmapData = null;
var local4:BitmapData = new BitmapData(param1.width,param1.height);
var local5:Point = new Point();
local4.copyPixels(param1,param1.rect,local5);
if(param1.width != param2.width || param1.height != param2.height) {
local6 = param2;
param2 = new BitmapData(param1.width,param1.height);
param2.draw(local6,new Matrix(param1.width / local6.width,0,0,param1.height / local6.height),null,BlendMode.NORMAL,null,true);
}
local4.copyChannel(param2,param2.rect,local5,BitmapDataChannel.RED,BitmapDataChannel.ALPHA);
if(local6 != null) {
param2.dispose();
param2 = local6;
}
if(param3) {
param1.dispose();
param2.dispose();
}
return local4;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.plasma
{
import scpacker.Base;
public class PlasmaModelBase extends Base
{
public function PlasmaModelBase()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.healing {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import projects.tanks.client.battlefield.models.tankparts.weapon.healing.IsisState;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RemoteHealingGun implements Weapon, HealingGun {
private var effects:HealingGunEffects;
private var currentTarget:Tank;
public function RemoteHealingGun(param1:HealingGunEffects) {
super();
this.effects = param1;
}
public function init(param1:WeaponPlatform) : void {
this.effects.init(param1.getTurret3D(),param1.getLocalMuzzlePosition());
}
public function destroy() : void {
this.reset();
}
public function activate() : void {
}
public function deactivate() : void {
this.reset();
}
public function enable() : void {
}
public function disable(param1:Boolean) : void {
this.reset();
}
public function reset() : void {
this.currentTarget = null;
this.effects.stopEffects();
}
public function getStatus() : Number {
return 0;
}
public function startAction(param1:IsisState, param2:Tank = null, param3:Vector3 = null) : void {
this.effects.setRemoteEffectsType(param1,param2,param3);
this.currentTarget = param2;
}
public function resetTarget() : void {
this.effects.setRemoteEffectsType(IsisState.IDLE);
this.currentTarget = null;
}
public function stop() : void {
this.effects.stopEffects();
this.currentTarget = null;
}
public function onTargetLost(param1:Tank) : void {
if(param1 != null) {
if(this.currentTarget == param1) {
this.currentTarget = null;
this.effects.setRemoteEffectsType(IsisState.IDLE);
}
}
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.ISIS_RESISTANCE;
}
public function setBuffedMode(param1:Boolean) : void {
this.effects.setBuffedMode(param1);
}
public function updateRecoilForce(param1:Number) : void {
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.CongratulationsWindowWithBanner_tileClass.png")]
public class CongratulationsWindowWithBanner_tileClass extends BitmapAsset {
public function CongratulationsWindowWithBanner_tileClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.helper {
public class HelperArrowDirection {
public static const VERTICAL:Boolean = true;
public static const HORIZONTAL:Boolean = false;
public function HelperArrowDirection() {
super();
}
}
}
|
package projects.tanks.clients.fp10.StandaloneLoader {
import flash.html.HTMLLoader;
public class Alert {
private static var htmlLoader:HTMLLoader;
private static const html:String = "<!DOCTYPE html><html lang=\'en\'><head><meta charset=\'utf-8\'>" + "<title>Tanki Online</title><script></script></head><body></body></html>";
public function Alert() {
super();
}
public static function showMessage(message:String) : void {
if(htmlLoader == null) {
htmlLoader = new HTMLLoader();
htmlLoader.loadString(html);
}
htmlLoader.window.alert(message);
}
}
}
|
package alternativa.tanks.view.mainview {
import alternativa.tanks.service.achievement.IAchievementService;
import alternativa.tanks.view.mainview.button.MainViewButton;
import alternativa.tanks.view.mainview.button.MatchmakingButton;
import alternativa.tanks.view.mainview.button.ShowBattleSelectButton;
import base.DiscreteSprite;
import fl.containers.ScrollPane;
import fl.controls.ScrollPolicy;
import fl.events.ScrollEvent;
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.geom.Point;
import flash.utils.Dictionary;
import flash.utils.setTimeout;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
import projects.tanks.clients.flash.commons.models.challenge.ChallengeInfoService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import utils.ScrollStyleUtils;
public class BattleTypesPanel extends DiscreteSprite {
[Inject]
public static var achievementService:IAchievementService;
[Inject]
public static var challengeInfoService:ChallengeInfoService;
private static const cpBtnClass:Class = BattleTypesPanel_cpBtnClass;
private static const ctfBtnClass:Class = BattleTypesPanel_ctfBtnClass;
private static const dmBtnClass:Class = BattleTypesPanel_dmBtnClass;
private static const tdmBtnClass:Class = BattleTypesPanel_tdmBtnClass;
private static const quickBtnClass:Class = BattleTypesPanel_quickBtnClass;
private static const assaultBtnClass:Class = BattleTypesPanel_assaultBtnClass;
private static const rugbyBtnClass:Class = BattleTypesPanel_rugbyBtnClass;
private static const jgrBtnClass:Class = BattleTypesPanel_jgrBtnClass;
private static const cpButton:Bitmap = new Bitmap(new cpBtnClass().bitmapData);
private static const ctfButton:Bitmap = new Bitmap(new ctfBtnClass().bitmapData);
private static const dmButton:Bitmap = new Bitmap(new dmBtnClass().bitmapData);
private static const tdmButton:Bitmap = new Bitmap(new tdmBtnClass().bitmapData);
private static const quickButton:Bitmap = new Bitmap(new quickBtnClass().bitmapData);
private static const assaultButton:Bitmap = new Bitmap(new assaultBtnClass().bitmapData);
private static const rugbyButton:Bitmap = new Bitmap(new rugbyBtnClass().bitmapData);
private static const juggernautButton:Bitmap = new Bitmap(new jgrBtnClass().bitmapData);
private var scrollPane:ScrollPane = new ScrollPane();
private var buttonsContainer:Sprite = new Sprite();
private var modeButtons:Vector.<MainViewButton> = new Vector.<MainViewButton>();
private var quickPlayButton:MatchmakingButton;
private var dmModeButton:MatchmakingButton;
private var holidayButton:MatchmakingButton;
private var jgrModeButton:MatchmakingButton;
private var battleSelectButton:ShowBattleSelectButton;
private var panelWidth:int = 0;
public function BattleTypesPanel(param1:Dictionary, param2:HolidayParams, param3:int) {
super();
ScrollStyleUtils.setGreenStyle(this.scrollPane);
this.scrollPane.horizontalScrollPolicy = ScrollPolicy.OFF;
this.scrollPane.verticalScrollPolicy = ScrollPolicy.AUTO;
this.scrollPane.source = this.buttonsContainer;
this.scrollPane.update();
this.scrollPane.focusEnabled = false;
this.scrollPane.addEventListener(ScrollEvent.SCROLL,this.onScroll);
addChild(this.scrollPane);
this.quickPlayButton = new MatchmakingButton(TanksLocale.TEXT_QUICK_PLAY_MODE_NAME,TanksLocale.TEXT_QUICK_PLAY_MODE_DESCRIPTION,quickButton,MatchmakingMode.TEAM_MODE,param1[MatchmakingMode.TEAM_MODE]);
this.addButton(this.quickPlayButton);
if(param2 != null) {
this.holidayButton = new MatchmakingButton(param2.holidayTitle,param2.holidayDescription,new Bitmap(param2.holidayIcon.data),MatchmakingMode.HOLIDAY,1);
this.addButton(this.holidayButton);
}
this.addButton(new MatchmakingButton(TanksLocale.TEXT_TDM_MODE_NAME,TanksLocale.TEXT_TDM_MODE_DESCRIPTION,tdmButton,MatchmakingMode.TDM_ONLY,param1[MatchmakingMode.TDM_ONLY]));
if(param2 == null) {
this.dmModeButton = new MatchmakingButton(TanksLocale.TEXT_DM_MODE_NAME,TanksLocale.TEXT_DM_MODE_DESCRIPTION,dmButton,MatchmakingMode.DM_ONLY,param1[MatchmakingMode.DM_ONLY]);
this.addButton(this.dmModeButton);
}
this.addButton(new MatchmakingButton(TanksLocale.TEXT_CP_MODE_NAME,TanksLocale.TEXT_CP_MODE_DESCRIPTION,cpButton,MatchmakingMode.CP_ONLY,param1[MatchmakingMode.CP_ONLY]));
this.addButton(new MatchmakingButton(TanksLocale.TEXT_CTF_MODE_NAME,TanksLocale.TEXT_CTF_MODE_DESCRIPTION,ctfButton,MatchmakingMode.CTF_ONLY,param1[MatchmakingMode.CTF_ONLY]));
this.addButton(new MatchmakingButton(TanksLocale.TEXT_AS_MODE_NAME,TanksLocale.TEXT_AS_MODE_DESCRIPTION,assaultButton,MatchmakingMode.AS_ONLY,param1[MatchmakingMode.AS_ONLY]));
this.addButton(new MatchmakingButton(TanksLocale.TEXT_RUGBY_MODE_NAME,TanksLocale.TEXT_RUGBY_MODE_DESCRIPTION,rugbyButton,MatchmakingMode.RUGBY_ONLY,param1[MatchmakingMode.RUGBY_ONLY]));
this.jgrModeButton = new MatchmakingButton(TanksLocale.TEXT_JGR_MODE_NAME,TanksLocale.TEXT_JGR_MODE_DESCRIPTION,juggernautButton,MatchmakingMode.JGR_ONLY,param1[MatchmakingMode.JGR_ONLY]);
this.addButton(this.jgrModeButton);
this.battleSelectButton = new ShowBattleSelectButton(param3);
this.buttonsContainer.addChild(this.battleSelectButton);
}
private function onScroll(param1:ScrollEvent) : void {
setTimeout(this.moveBubble,5);
}
private function moveBubble() : void {
var local1:Point = this.quickPlayButton.localToGlobal(new Point(this.quickPlayButton.width - 75,110));
if(local1.y < 150) {
local1 = new Point(-100,-100);
}
achievementService.setBattleStartButtonTargetPoint(local1);
}
private function addButton(param1:MainViewButton) : void {
this.modeButtons.push(param1);
this.buttonsContainer.addChild(param1);
}
public function resize(param1:int, param2:int) : void {
this.panelWidth = param1;
this.alignButtons();
this.scrollPane.setSize(param1,param2);
this.scrollPane.update();
this.moveBubble();
}
private function alignButtons() : void {
var local3:MainViewButton = null;
var local1:int = -3;
var local2:Vector.<MainViewButton> = new Vector.<MainViewButton>().concat(this.modeButtons);
local2.push(this.battleSelectButton);
for each(local3 in local2) {
if(local3.visible) {
local3.resize(this.panelWidth);
local3.y = local1;
local1 += local3.height - 3;
}
}
}
public function userEntersGroup(param1:Boolean) : void {
if(!param1) {
this.lockBattleButtons();
}
this.battleSelectButton.lockButton();
this.setNotTeamButtonVisibility(false);
}
public function userLeavesGroup() : void {
this.unlockBattleButtons();
this.battleSelectButton.unlockIfPossible();
this.setNotTeamButtonVisibility(true);
}
public function lockBattleButtons() : void {
var local1:MainViewButton = null;
for each(local1 in this.modeButtons) {
local1.lockButton();
}
}
public function unlockBattleButtons() : void {
var local1:MainViewButton = null;
for each(local1 in this.modeButtons) {
local1.unlockIfPossible();
}
}
private function setNotTeamButtonVisibility(param1:Boolean) : void {
if(this.dmModeButton != null) {
this.dmModeButton.visible = param1;
}
this.jgrModeButton.visible = param1;
if(this.holidayButton != null) {
this.holidayButton.visible = param1;
}
this.alignButtons();
}
public function setSpectatorsButtonVisible(param1:Boolean) : void {
var local2:MainViewButton = null;
for each(local2 in this.modeButtons) {
local2.setSpectatorsButtonVisible(param1);
}
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapRicochetResistance.png")]
public class ResistancesIcons_bitmapRicochetResistance extends BitmapAsset {
public function ResistancesIcons_bitmapRicochetResistance() {
super();
}
}
}
|
package alternativa.tanks.services.colortransform.impl {
import alternativa.tanks.services.colortransform.*;
import flash.geom.ColorTransform;
public class SoftwareColorTransformService implements ColorTransformService {
private const transformers:Vector.<ColorTransformer> = new Vector.<ColorTransformer>();
private var colorTransform:ColorTransform;
private var heatColorAdjust:ColorTransform;
private var frostColorAdjust:ColorTransform;
public function SoftwareColorTransformService() {
super();
}
public function addColorTransformer(param1:ColorTransformer) : void {
this.transformers.push(param1);
param1.setColorTransform(this.colorTransform);
}
public function setColorTransform(param1:ColorTransform) : void {
var local2:ColorTransformer = null;
if(!ColorTransformUtils.equal(this.colorTransform,param1)) {
this.colorTransform = ColorTransformUtils.clone(param1);
for each(local2 in this.transformers) {
local2.setColorTransform(this.colorTransform);
}
}
}
public function getColorTransform() : ColorTransform {
return ColorTransformUtils.clone(this.colorTransform);
}
public function setColorAdjust(param1:ColorTransform, param2:ColorTransform, param3:ColorTransform, param4:ColorTransform) : void {
this.heatColorAdjust = param1;
this.frostColorAdjust = param2;
}
public function getHeatColorAdjust() : ColorTransform {
return this.heatColorAdjust;
}
public function getFrostColorAdjust() : ColorTransform {
return this.frostColorAdjust;
}
}
}
|
package controls.cellrenderer
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CellNormal_normalRight extends BitmapAsset
{
public function CellNormal_normalRight()
{
super();
}
}
}
|
package alternativa.tanks.models.tank.codec {
public class BitArea {
private var data:Array;
private var length:int;
private var position:int;
public function BitArea(param1:Array, param2:int) {
super();
this.data = param1;
this.position = 0;
this.length = param2 * 8;
}
public function reset() : void {
this.position = 0;
}
public function read(param1:int) : int {
if(param1 > 32) {
throw new Error("Cannot read more that 32 bit at once (requested " + param1 + ")");
}
if(this.position + param1 > this.length) {
throw new Error("BitArea is out of data: requesed " + param1 + " bits, avaliable:" + (this.length - this.position));
}
var local2:int = 0;
var local3:int = param1 - 1;
while(local3 >= 0) {
if(this.getBit(this.position)) {
local2 += 1 << local3;
}
++this.position;
local3--;
}
return local2;
}
public function write(param1:int, param2:int) : void {
var local4:Boolean = false;
if(param1 > 32) {
throw new Error("Cannot write more that 32 bit at once (requested " + param1 + ")");
}
if(this.position + param1 > this.length) {
throw new Error("BitArea overflow attempt to write " + param1 + " bits, space avaliable:" + (this.length - this.position));
}
var local3:int = param1 - 1;
while(local3 >= 0) {
local4 = (param2 & 1 << local3) != 0;
this.setBit(this.position,local4);
++this.position;
local3--;
}
}
private function arrayToHezString(param1:Array) : String {
var local4:int = 0;
var local2:String = "";
var local3:Boolean = true;
for each(local4 in param1) {
if(!local3) {
local2 += ", ";
}
local2 += local4.toString(16);
local3 = false;
}
return local2;
}
private function getBit(param1:int) : Boolean {
var local2:int = param1 >> 3;
var local3:int = 7 ^ param1 & 7;
return (this.data[local2] & 1 << local3) != 0;
}
private function setBit(param1:int, param2:Boolean) : void {
var local5:int = 0;
var local3:int = param1 >> 3;
var local4:int = 7 ^ param1 & 7;
if(param2) {
this.data[local3] = int(this.data[local3] | 1 << local4);
} else {
local5 = int(0xFF ^ 1 << local4);
this.data[local3] = int(this.data[local3] & local5);
}
}
public function getLength() : int {
return this.length;
}
public function getData() : Array {
return this.data;
}
}
}
|
package alternativa.tanks.models.tank.gearscore {
public class GearScoreEntity {
private var _score:int = 0;
public function GearScoreEntity(param1:int) {
super();
this._score = param1;
}
public function get score() : int {
return this._score;
}
public function set score(param1:int) : void {
this._score = param1;
}
}
}
|
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 alternativa.types.Float;
import platform.client.fp10.core.resource.types.SoundResource;
import projects.tanks.client.battlefield.models.map.BattleMapCC;
import projects.tanks.client.battlefield.models.map.DustParams;
import projects.tanks.client.battlefield.models.map.DynamicShadowParams;
import projects.tanks.client.battlefield.models.map.FogParams;
import projects.tanks.client.battlefield.models.map.SkyboxSides;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.clients.flash.resources.resource.MapResource;
public class CodecBattleMapCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_dustParams:ICodec;
private var codec_dynamicShadowParams:ICodec;
private var codec_environmentSound:ICodec;
private var codec_fogParams:ICodec;
private var codec_gravity:ICodec;
private var codec_mapResource:ICodec;
private var codec_skyBoxRevolutionAxis:ICodec;
private var codec_skyBoxRevolutionSpeed:ICodec;
private var codec_skyboxSides:ICodec;
private var codec_ssaoColor:ICodec;
public function CodecBattleMapCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_dustParams = param1.getCodec(new TypeCodecInfo(DustParams,false));
this.codec_dynamicShadowParams = param1.getCodec(new TypeCodecInfo(DynamicShadowParams,false));
this.codec_environmentSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_fogParams = param1.getCodec(new TypeCodecInfo(FogParams,false));
this.codec_gravity = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_mapResource = param1.getCodec(new TypeCodecInfo(MapResource,false));
this.codec_skyBoxRevolutionAxis = param1.getCodec(new TypeCodecInfo(Vector3d,false));
this.codec_skyBoxRevolutionSpeed = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_skyboxSides = param1.getCodec(new TypeCodecInfo(SkyboxSides,false));
this.codec_ssaoColor = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattleMapCC = new BattleMapCC();
local2.dustParams = this.codec_dustParams.decode(param1) as DustParams;
local2.dynamicShadowParams = this.codec_dynamicShadowParams.decode(param1) as DynamicShadowParams;
local2.environmentSound = this.codec_environmentSound.decode(param1) as SoundResource;
local2.fogParams = this.codec_fogParams.decode(param1) as FogParams;
local2.gravity = this.codec_gravity.decode(param1) as Number;
local2.mapResource = this.codec_mapResource.decode(param1) as MapResource;
local2.skyBoxRevolutionAxis = this.codec_skyBoxRevolutionAxis.decode(param1) as Vector3d;
local2.skyBoxRevolutionSpeed = this.codec_skyBoxRevolutionSpeed.decode(param1) as Number;
local2.skyboxSides = this.codec_skyboxSides.decode(param1) as SkyboxSides;
local2.ssaoColor = this.codec_ssaoColor.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:BattleMapCC = BattleMapCC(param2);
this.codec_dustParams.encode(param1,local3.dustParams);
this.codec_dynamicShadowParams.encode(param1,local3.dynamicShadowParams);
this.codec_environmentSound.encode(param1,local3.environmentSound);
this.codec_fogParams.encode(param1,local3.fogParams);
this.codec_gravity.encode(param1,local3.gravity);
this.codec_mapResource.encode(param1,local3.mapResource);
this.codec_skyBoxRevolutionAxis.encode(param1,local3.skyBoxRevolutionAxis);
this.codec_skyBoxRevolutionSpeed.encode(param1,local3.skyBoxRevolutionSpeed);
this.codec_skyboxSides.encode(param1,local3.skyboxSides);
this.codec_ssaoColor.encode(param1,local3.ssaoColor);
}
}
}
|
package projects.tanks.client.panel.model.shop.specialkit.view {
public interface INewbieKitViewModelBase {
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class EntranceErrorEvent extends Event {
public static const SERVER_FROZEN:String = "EntranceErrorEvent.SERVER_FROZEN";
public static const SERVER_HALT:String = "EntranceErrorEvent.SERVER_HALT";
public function EntranceErrorEvent(param1:String) {
super(param1);
}
}
}
|
package alternativa.tanks.models.tank.speedcharacteristics {
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.LocalTankParams;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.user.speedcharacteristics.ISpeedCharacteristicsModelBase;
import projects.tanks.client.battlefield.models.user.speedcharacteristics.SpeedCharacteristicsCC;
import projects.tanks.client.battlefield.models.user.speedcharacteristics.SpeedCharacteristicsModelBase;
[ModelInfo]
public class SpeedCharacteristicsModel extends SpeedCharacteristicsModelBase implements ISpeedCharacteristicsModelBase, ObjectLoadListener, SpeedCharacteristics {
public function SpeedCharacteristicsModel() {
super();
}
public function objectLoaded() : void {
var local1:SpeedCharacteristicsCC = getInitParam();
var local2:CurrentSpeedValues = new CurrentSpeedValues();
local2.speed = local1.currentSpeed;
local2.turnSpeed = local1.currentTurnSpeed;
local2.turretRotationSpeed = local1.currentTurretRotationSpeed;
local2.acceleration = local1.currentAcceleration;
putData(CurrentSpeedValues,local2);
}
public function getMaxTurretTurnSpeed() : Number {
var local1:CurrentSpeedValues = this.getCurrentValues();
return local1.turretRotationSpeed;
}
public function getMaxHullTurnSpeed() : Number {
var local1:CurrentSpeedValues = this.getCurrentValues();
return local1.turnSpeed;
}
public function getTurretRotationCoefficient() : Number {
var local1:CurrentSpeedValues = this.getCurrentValues();
if(getInitParam().baseTurretRotationSpeed == 0) {
return 0;
}
return local1.turretRotationSpeed / getInitParam().baseTurretRotationSpeed;
}
public function setInitialTankState() : void {
var local1:ITankModel = ITankModel(object.adapt(ITankModel));
var local2:Tank = local1.getTank();
local2.setReverseAcceleration(BattleUtils.toClientScale(getInitParam().reverseAcceleration));
local2.setSideAcceleration(BattleUtils.toClientScale(getInitParam().sideAcceleration));
local2.setTurnAcceleration(getInitParam().turnAcceleration);
local2.setReverseTurnAcceleration(getInitParam().reverseTurnAcceleration);
local2.setStabilizationAcceleration(getInitParam().turnStabilizationAcceleration);
this.setTankSpec(local1,getInitParam().currentSpeed,getInitParam().currentTurnSpeed,getInitParam().currentTurretRotationSpeed,getInitParam().currentAcceleration,true);
}
[Obfuscation(rename="false")]
public function setSpecification(param1:Number, param2:Number, param3:Number, param4:Number, param5:int, param6:Boolean) : void {
var local7:* = param6 || this.getCurrentValues().acceleration == 0;
var local8:ITankModel = ITankModel(object.adapt(ITankModel));
this.setTankSpec(local8,param1,param2,param3,param4,local7);
if(local8.isLocal()) {
LocalTankParams.setSpecificationId(param5);
}
}
private function setTankSpec(param1:ITankModel, param2:Number, param3:Number, param4:Number, param5:Number, param6:Boolean) : void {
var local7:CurrentSpeedValues = new CurrentSpeedValues();
local7.speed = param2;
local7.turnSpeed = param3;
local7.turretRotationSpeed = param4;
local7.acceleration = param5;
putData(CurrentSpeedValues,local7);
var local8:Tank = param1.getTank();
local8.setMaxSpeed(BattleUtils.toClientScale(param2),param6);
local8.setMaxTurnSpeed(param3,param6);
local8.setAcceleration(BattleUtils.toClientScale(param5));
local8.getWeaponMount().setMaxTurnSpeed(param4,param6);
}
private function getCurrentValues() : CurrentSpeedValues {
return CurrentSpeedValues(getData(CurrentSpeedValues));
}
}
}
class CurrentSpeedValues {
public var speed:Number;
public var turnSpeed:Number;
public var turretRotationSpeed:Number;
public var acceleration:Number;
public function CurrentSpeedValues() {
super();
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.BasicGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.shared.SimpleWeaponController;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import alternativa.tanks.utils.MathUtils;
import flash.utils.getTimer;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RailgunWeapon extends BattleRunnerProvider implements Weapon, LogicUnit {
private static const allGunParams:AllGlobalGunParams = new AllGlobalGunParams();
private static const basicGunParams:BasicGlobalGunParams = new BasicGlobalGunParams();
public static var DEFAULT_CHARGE_DURATION:int = 1100;
private var controller:SimpleWeaponController;
private var targetingSystem:TargetingSystem;
private var weaponObject:WeaponObject;
private var weaponForces:WeaponForces;
private var weakeningCoeff:Number;
private var chargingDuration:EncryptedInt = new EncryptedIntImpl();
private var effects:IRailgunEffects;
private var callback:RailgunCallback;
private var weaponPlatform:WeaponPlatform;
private var enabled:Boolean;
private var stunned:Boolean;
private var nextTime:EncryptedInt = new EncryptedIntImpl();
private var charging:Boolean;
private var stunStatus:Number = 0;
private var transitionChargingTime:int;
public function RailgunWeapon(param1:TargetingSystem, param2:SimpleWeaponController, param3:WeaponObject, param4:WeaponForces, param5:Number, param6:int, param7:IRailgunEffects, param8:RailgunCallback) {
super();
this.targetingSystem = param1;
this.controller = param2;
this.weaponObject = param3;
this.weaponForces = param4;
this.weakeningCoeff = param5;
this.chargingDuration.setInt(param6);
this.effects = param7;
this.callback = param8;
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
this.controller.init();
}
public function destroy() : void {
this.deactivate();
this.effects.stopEffects();
this.controller.destroy();
this.controller = null;
this.effects = null;
this.weaponForces = null;
this.targetingSystem = null;
this.callback = null;
}
public function activate() : void {
getBattleRunner().addLogicUnit(this);
}
public function deactivate() : void {
getBattleRunner().removeLogicUnit(this);
}
public function enable() : void {
if(!this.enabled) {
this.enabled = true;
this.controller.discardStoredAction();
}
}
public function disable(param1:Boolean) : void {
if(this.enabled) {
this.enabled = false;
this.effects.stopEffects();
}
}
public function reset() : void {
this.enabled = false;
this.effects.stopEffects();
this.nextTime.setInt(0);
this.charging = false;
this.transitionChargingTime = 0;
}
public function getStatus() : Number {
var local1:* = undefined;
if(this.charging) {
local1 = this.transitionChargingTime > 0 ? this.transitionChargingTime : this.chargingDuration.getInt();
return MathUtils.clamp((this.nextTime.getInt() - getTimer()) / local1,0,1);
}
if(this.stunned) {
return this.stunStatus;
}
return MathUtils.clamp(1 - (this.nextTime.getInt() - getTimer()) / this.weaponObject.getReloadTimeMS(),0,1);
}
public function runLogic(param1:int, param2:int) : void {
if(this.charging) {
if(param1 >= this.nextTime.getInt()) {
if(!this.stunned) {
this.shoot(param1);
} else {
this.stunStatus = 0;
this.charging = false;
}
}
} else if(this.enabled && !this.stunned) {
if(param1 >= this.nextTime.getInt() && this.controller.wasActive()) {
this.startCharging(param1);
}
}
this.controller.discardStoredAction();
}
private function startCharging(param1:int) : void {
this.charging = true;
this.transitionChargingTime = 0;
this.nextTime.setInt(param1 + this.chargingDuration.getInt());
this.effects.createChargeEffect(this.weaponPlatform.getLocalMuzzlePosition(),this.weaponPlatform.getTurret3D(),this.chargingDuration.getInt());
this.weaponPlatform.getBasicGunParams(basicGunParams);
this.effects.createSoundEffect(basicGunParams.muzzlePosition,DEFAULT_CHARGE_DURATION - this.chargingDuration.getInt());
this.callback.onStartCharging(param1);
}
private function shoot(param1:int) : void {
var local2:RailgunShotResult = null;
this.charging = false;
this.transitionChargingTime = 0;
this.nextTime.setInt(param1 + this.weaponObject.getReloadTimeMS());
this.weaponPlatform.getAllGunParams(allGunParams);
this.weaponPlatform.getBody().addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-this.weaponForces.getRecoilForce());
this.weaponPlatform.addDust();
if(BattleUtils.isTurretAboveGround(this.weaponPlatform.getBody(),allGunParams)) {
local2 = new RailgunShotResult();
local2.setFromTargetingResult(this.targetingSystem.target(allGunParams));
if(local2.hitPoints.length > 0) {
this.applyImpactToTargets(local2);
}
this.createShotEffect(local2,allGunParams);
this.callback.onShot(param1,local2.getStaticHitPoint(),local2.targets,local2.hitPoints);
} else {
this.callback.onShotDummy(param1);
}
}
private function applyImpactToTargets(param1:RailgunShotResult) : void {
var local4:Body = null;
var local5:Tank = null;
var local2:Number = 1;
var local3:int = 0;
while(local3 < param1.targets.length) {
local4 = param1.targets[local3];
local5 = local4.tank;
local5.applyWeaponHit(param1.hitPoints[local3],param1.shotDirection,this.weaponForces.getImpactForce() * local2);
local2 *= this.weakeningCoeff;
local3++;
}
}
private function createShotEffect(param1:RailgunShotResult, param2:AllGlobalGunParams) : void {
var local3:Vector3 = param1.getStaticHitPoint();
if(local3 == null && param1.targets.length > 0) {
local3 = RailgunUtils.getDistantPoint(param2.barrelOrigin,param1.shotDirection);
}
this.effects.createShotTrail(param2.muzzlePosition,local3,param2.direction);
this.effects.createStaticHitMark(param2.barrelOrigin,param1.getStaticHitPoint());
if(local3 != null) {
if(param1.hasStaticHit) {
this.effects.createStaticHitEffect(param2.muzzlePosition,param1.staticHitPoint,param1.staticHitNormal);
}
if(param1.targets.length > 0) {
this.effects.createTargetHitEffects(param2.muzzlePosition,local3,param1.hitPoints,param1.targets);
}
}
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.RAILGUN_RESISTANCE;
}
public function updateChargingTime(param1:int) : void {
if(this.charging) {
this.transitionChargingTime = this.chargingDuration.getInt();
}
this.chargingDuration.setInt(param1);
}
public function updateRecoilForce(param1:Number) : void {
this.weaponForces.setRecoilForce(param1);
}
public function fullyRecharge() : void {
var local1:int = int(battleService.getPhysicsTime());
if(this.nextTime.getInt() > local1 && !this.charging) {
this.nextTime.setInt(local1);
}
this.stunStatus = 1;
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
if(!this.charging || param1 > param2) {
this.nextTime.setInt(this.nextTime.getInt() - param1 + param2);
}
}
public function stun() : void {
this.stunStatus = this.charging ? 1 : this.getStatus();
this.charging = false;
this.stunned = true;
}
public function calm(param1:int) : void {
if(this.stunStatus < 1) {
this.nextTime.setInt(this.nextTime.getInt() + param1);
}
this.stunned = false;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.gauss.sfx {
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 GaussSFXModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:GaussSFXModelServer;
private var client:IGaussSFXModelBase = IGaussSFXModelBase(this);
private var modelId:Long = Long.getLong(716150790,-138300431);
public function GaussSFXModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new GaussSFXModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(GaussSFXCC,false)));
}
protected function getInitParam() : GaussSFXCC {
return GaussSFXCC(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 _codec.projects.tanks.client.tanksservices.model.notifier.online {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.tanksservices.model.notifier.online.OnlineNotifierData;
public class VectorCodecOnlineNotifierDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecOnlineNotifierDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(OnlineNotifierData,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.<OnlineNotifierData> = new Vector.<OnlineNotifierData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = OnlineNotifierData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:OnlineNotifierData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<OnlineNotifierData> = Vector.<OnlineNotifierData>(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.bonuses {
public class BattleBonusState {
public var pivotZ:Number = 0;
public var angleX:Number = 0;
public var angleZ:Number = 0;
public function BattleBonusState() {
super();
}
public function interpolate(param1:BattleBonusState, param2:BattleBonusState, param3:Number) : void {
this.pivotZ = param1.pivotZ + param3 * (param2.pivotZ - param1.pivotZ);
this.angleX = param1.angleX + param3 * (param2.angleX - param1.angleX);
this.angleZ = param1.angleZ + param3 * (param2.angleZ - param1.angleZ);
}
public function copy(param1:BattleBonusState) : void {
this.pivotZ = param1.pivotZ;
this.angleX = param1.angleX;
this.angleZ = param1.angleZ;
}
}
}
|
package alternativa.types {
public class Binary64 {
public var low:uint;
internal var internalHigh:uint;
public function Binary64(param1:uint = 0, param2:uint = 0) {
super();
this.low = param1;
this.internalHigh = param2;
}
final internal function div(param1:uint) : uint {
var local2:uint = 0;
local2 = this.internalHigh % param1;
var local3:uint = (this.low % param1 + local2 * 6) % param1;
this.internalHigh /= param1;
var local4:Number = (local2 * Number(4294967296) + this.low) / param1;
this.internalHigh += local4 / 4294967296;
this.low = local4;
return local3;
}
final internal function mul(param1:uint) : void {
var local2:Number = Number(this.low) * param1;
this.internalHigh = local2 / 4294967296 + Number(this.internalHigh) * param1;
this.low = local2;
}
final internal function add(param1:uint) : void {
var local2:Number = Number(this.low) + param1;
this.internalHigh = local2 / 4294967296 + this.internalHigh;
this.low = local2;
}
final internal function bitwiseNot() : void {
this.low = ~this.low;
this.internalHigh = ~this.internalHigh;
}
}
}
|
package projects.tanks.client.partners.impl.rambler {
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 RamblerLoginModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RamblerLoginModelServer(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 platform.client.fp10.core.network.command {
public class ControlCommand {
public static const SV_HASH_RESPONSE:int = 2;
public static const SV_OPEN_SPACE:int = 32;
public static const SV_MESSAGE:int = 35;
public static const SV_COMMAND_REQUEST:int = 9;
public static const CL_HASH_REQUEST:int = 1;
public static const CL_LOG:int = 32;
public static const CL_COMMAND_RESPONSE:int = 10;
public var id:int;
public var name:String;
public function ControlCommand(param1:int, param2:String) {
super();
this.id = param1;
this.name = param2;
}
public function toString() : String {
return "[ControlCommand id=" + this.id + ", name=" + this.name + "]";
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.