code
stringlengths 57
237k
|
|---|
package alternativa.tanks.model.map.mapinfo {
import alternativa.types.Long;
import platform.client.fp10.core.model.IObjectLoadListener;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleselect.model.map.IMapInfoModelBase;
import projects.tanks.client.battleselect.model.map.MapInfoModelBase;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.model.map.params.MapTheme;
[ModelInfo]
public class MapInfoModel extends MapInfoModelBase implements IMapInfoModelBase, IMapInfo, IObjectLoadListener {
private static var maps:Vector.<IGameObject> = new Vector.<IGameObject>();
public function MapInfoModel() {
super();
}
public static function getMaps() : Vector.<IGameObject> {
return maps;
}
public function getName() : String {
return getInitParam().mapName;
}
public function getMapId() : Long {
return getInitParam().mapId;
}
public function getMaxPeople() : int {
return getInitParam().maxPeople;
}
public function getMaxRank() : int {
return getInitParam().rankLimit.max;
}
public function getMinRank() : int {
return getInitParam().rankLimit.min;
}
public function getThemeName() : String {
return getInitParam().theme.toString();
}
public function getTheme() : MapTheme {
return getInitParam().theme;
}
public function getDefaultTheme() : MapTheme {
return getInitParam().defaultTheme;
}
public function getSupportedBattleModes() : Vector.<BattleMode> {
return getInitParam().supportedModes;
}
public function isEnabled() : Boolean {
return getInitParam().enabled;
}
public function getPreviewResource() : ImageResource {
return getInitParam().preview;
}
public function objectLoaded() : void {
if(this.isEnabled()) {
maps.push(object);
}
}
public function objectLoadedPost() : void {
}
public function objectUnloaded() : void {
var local1:int = int(maps.lastIndexOf(object));
if(local1 != -1) {
maps.splice(local1,1);
}
}
public function objectUnloadedPost() : void {
}
public function hasMatchmakingMark() : Boolean {
return getInitParam().matchmakingMark;
}
}
}
|
package projects.tanks.client.battlefield.models.effects.activeafterdeath {
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 ActiveAfterDeathModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ActiveAfterDeathModelServer(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.commons.models.runtime {
public interface IDataOwnerModelBase {
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
use namespace alternativa3d;
public class AnimSprite extends Sprite3D {
private var _materials:Vector.<Material>;
private var _frame:int = 0;
private var _loop:Boolean = false;
public function AnimSprite(param1:Number, param2:Number, param3:Vector.<Material> = null, param4:Boolean = false, param5:int = 0) {
super(param1,param2);
this._materials = param3;
this._loop = param4;
this.frame = param5;
}
public function get materials() : Vector.<Material> {
return this._materials;
}
public function set materials(param1:Vector.<Material>) : void {
this._materials = param1;
if(param1 != null) {
this.frame = this._frame;
} else {
material = null;
}
}
public function get loop() : Boolean {
return this._loop;
}
public function set loop(param1:Boolean) : void {
this._loop = param1;
this.frame = this._frame;
}
public function get frame() : int {
return this._frame;
}
public function set frame(param1:int) : void {
var local2:int = 0;
var local3:int = 0;
var local4:int = 0;
this._frame = param1;
if(this._materials != null) {
local2 = int(this._materials.length);
local3 = this._frame;
if(this._frame < 0) {
local4 = this._frame % local2;
local3 = this._loop && local4 != 0 ? local4 + local2 : 0;
} else if(this._frame > local2 - 1) {
local3 = this._loop ? int(this._frame % local2) : local2 - 1;
}
material = this._materials[local3];
}
}
override public function clone() : Object3D {
var local1:AnimSprite = new AnimSprite(width,height);
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:AnimSprite = param1 as AnimSprite;
this._materials = local2._materials;
this._loop = local2._loop;
this._frame = local2._frame;
}
}
}
|
package alternativa.tanks.camera {
import alternativa.math.Vector3;
public interface CameraTarget {
function getCameraParams(param1:Vector3, param2:Vector3) : void;
}
}
|
package projects.tanks.client.clans.clan.permissions {
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.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ClanPermissionsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanPermissionsModelServer;
private var client:IClanPermissionsModelBase = IClanPermissionsModelBase(this);
private var modelId:Long = Long.getLong(1602467880,168781542);
private var _updateActionsId:Long = Long.getLong(871743923,-1602562917);
private var _updateActions_actionsCodec:ICodec;
public function ClanPermissionsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanPermissionsModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ClanPermissionsCC,false)));
this._updateActions_actionsCodec = this._protocol.getCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanAction,false),false,1));
}
protected function getInitParam() : ClanPermissionsCC {
return ClanPermissionsCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._updateActionsId:
this.client.updateActions(this._updateActions_actionsCodec.decode(param2) as Vector.<ClanAction>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim {
public interface AimSoundEffect {
function playAimingSoundEffect() : void;
function playTargetLostSoundEffect() : void;
function killAimingSoundEffect() : void;
}
}
|
package alternativa.tanks.view.timeleftindicator {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.timeleftindicator.BigWhiteTimeLeftIndicator_emptyMarkerClass.png")]
public class BigWhiteTimeLeftIndicator_emptyMarkerClass extends BitmapAsset {
public function BigWhiteTimeLeftIndicator_emptyMarkerClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.clans.panel.foreignclan {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
import projects.tanks.client.clans.panel.foreignclan.ForeignClanCC;
public class CodecForeignClanCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_flags:ICodec;
public function CodecForeignClanCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_flags = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFlag,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ForeignClanCC = new ForeignClanCC();
local2.flags = this.codec_flags.decode(param1) as Vector.<ClanFlag>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ForeignClanCC = ForeignClanCC(param2);
this.codec_flags.encode(param1,local3.flags);
}
}
}
|
package platform.client.fp10.core.service.errormessage {
import flash.display.DisplayObject;
import platform.client.fp10.core.service.errormessage.errors.ErrorType;
public interface IMessageBox {
function getDisplayObject(param1:ErrorType) : DisplayObject;
function hide() : void;
}
}
|
package alternativa.tanks.models.weapon.shared.shot
{
import alternativa.object.ClientObject;
public interface IShot
{
function getShotData(param1:ClientObject) : ShotData;
}
}
|
package _codec.projects.tanks.client.panel.model.shop.shopitemcategory {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.shop.shopitemcategory.ShopItemCategoryCC;
public class CodecShopItemCategoryCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_category:ICodec;
public function CodecShopItemCategoryCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_category = param1.getCodec(new TypeCodecInfo(IGameObject,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShopItemCategoryCC = new ShopItemCategoryCC();
local2.category = this.codec_category.decode(param1) as IGameObject;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShopItemCategoryCC = ShopItemCategoryCC(param2);
this.codec_category.encode(param1,local3.category);
}
}
}
|
package _codec.projects.tanks.client.entrance.model.entrance.registration {
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.entrance.model.entrance.registration.RegistrationModelCC;
public class VectorCodecRegistrationModelCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRegistrationModelCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RegistrationModelCC,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.<RegistrationModelCC> = new Vector.<RegistrationModelCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RegistrationModelCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RegistrationModelCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RegistrationModelCC> = Vector.<RegistrationModelCC>(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 com.alternativaplatform.projects.tanks.client.warfare.models.common.bonuscommon
{
public interface IBonusCommonModelBase
{
}
}
|
package controls.containers {
import base.DiscreteSprite;
import controls.base.TankInputBase;
import flash.display.DisplayObject;
public class StackPanel extends DiscreteSprite {
private var margin:int;
public var items:Vector.<DisplayObject> = new Vector.<DisplayObject>();
public function StackPanel() {
super();
}
public function addItem(param1:DisplayObject) : void {
addChild(param1);
this.items.push(param1);
this.increaseContainerSize(param1);
}
public function removeItem(param1:DisplayObject) : DisplayObject {
var item:DisplayObject = param1;
var itemIndex:int = int(this.items.indexOf(item));
if(itemIndex < 0) {
return null;
}
try {
removeChild(item);
}
catch(e:ArgumentError) {
return null;
}
this.items.splice(itemIndex,1);
this.decreaseContainerSize(itemIndex,item);
return item;
}
protected function fixWidth(param1:DisplayObject) : int {
return int(param1 is TankInputBase ? param1.width - 10 : param1.width);
}
protected function decreaseContainerSize(param1:int, param2:DisplayObject) : void {
}
protected function increaseContainerSize(param1:DisplayObject) : void {
}
public function getMargin() : int {
return this.margin;
}
public function setMargin(param1:int) : void {
this.margin = param1;
}
public function getItemsCount() : int {
return this.items.length;
}
public function getItems() : Vector.<DisplayObject> {
return this.items;
}
}
}
|
package alternativa.protocol.codec.primitive {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
public class LongCodec implements ICodec {
public function LongCodec() {
super();
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
param1.writer.writeInt(Long(param2).high);
param1.writer.writeInt(Long(param2).low);
}
public function decode(param1:ProtocolBuffer) : Object {
return Long.getLong(param1.reader.readInt(),param1.reader.readInt());
}
public function init(param1:IProtocol) : void {
}
}
}
|
package alternativa.tanks.model.bonus.showing.info {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.LocalizedImageResource;
import platform.client.fp10.core.type.IGameObject;
public class BonusInfoEvents implements BonusInfo {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BonusInfoEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getTopText() : String {
var result:String = null;
var i:int = 0;
var m:BonusInfo = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BonusInfo(this.impl[i]);
result = m.getTopText();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getBottomText() : String {
var result:String = null;
var i:int = 0;
var m:BonusInfo = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BonusInfo(this.impl[i]);
result = m.getBottomText();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getImage() : LocalizedImageResource {
var result:LocalizedImageResource = null;
var i:int = 0;
var m:BonusInfo = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BonusInfo(this.impl[i]);
result = m.getImage();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package services.contextmenu {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import forms.contextmenu.ContextMenu;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendActionService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.UidUtil;
public class ContextMenuService extends EventDispatcher implements IContextMenuService {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var friendsActionService:IFriendActionService;
private var _contextMenu:ContextMenu;
private var _removeFromFriendsUserId:Long;
private var _removeFromFriendsUid:String;
public function ContextMenuService() {
super();
this._contextMenu = new ContextMenu();
}
public function show(param1:Long, param2:int, param3:String, param4:Boolean, param5:Boolean, param6:Boolean, param7:Boolean, param8:Boolean, param9:Boolean, param10:Boolean, param11:Boolean, param12:Boolean = false, param13:Boolean = true, param14:Boolean = true) : void {
this._contextMenu.show(param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14);
}
public function writeInPublic(param1:Long, param2:String) : void {
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.WRITE_IN_PUBLIC,param1,UidUtil.userNameWithoutClanTag(param2)));
}
public function writeInPrivate(param1:Long, param2:String) : void {
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.WRITE_IN_PRIVATE,param1,UidUtil.userNameWithoutClanTag(param2)));
}
public function removeFromFriends(param1:Long, param2:String) : void {
this._removeFromFriendsUserId = param1;
this._removeFromFriendsUid = param2;
var local3:String = localeService.getText(TanksLocale.TEXT_FRIENDS_REMOVE_USER).replace("%USERNAME%",param2);
alertService.showAlert(local3,Vector.<String>([localeService.getText(TanksLocale.TEXT_FRIENDS_YES),localeService.getText(TanksLocale.TEXT_FRIENDS_NO)]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onConfirmRemoveFromFriends);
}
private function onConfirmRemoveFromFriends(param1:AlertServiceEvent) : void {
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onConfirmRemoveFromFriends);
if(param1.typeButton == localeService.getText(TanksLocale.TEXT_FRIENDS_YES)) {
friendsActionService.breakItOff(this._removeFromFriendsUserId);
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.REMOVE_FROM_FRIENDS,this._removeFromFriendsUserId,this._removeFromFriendsUid));
}
}
public function rejectRequest(param1:Long, param2:String) : void {
friendsActionService.reject(param1);
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.REJECT_REQUEST,param1,param2));
}
public function acceptRequest(param1:Long, param2:String) : void {
friendsActionService.accept(param1);
}
public function addToFriend(param1:Long) : void {
friendsActionService.add(param1);
}
public function focusOnUser(param1:Long, param2:String) : void {
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.FOCUS_ON_USER,param1,param2));
}
public function showClan(param1:Long) : void {
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.SHOW_CLAN,null,null,param1));
}
public function voteUser(param1:Long, param2:String) : void {
dispatchEvent(new ContextMenuServiceEvent(ContextMenuServiceEvent.VOTE_USER,param1,param2));
}
}
}
|
package alternativa.tanks.models.user.outgoing {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IClanUserOutgoingModelAdapt implements IClanUserOutgoingModel {
private var object:IGameObject;
private var impl:IClanUserOutgoingModel;
public function IClanUserOutgoingModelAdapt(param1:IGameObject, param2:IClanUserOutgoingModel) {
super();
this.object = param1;
this.impl = param2;
}
public function getOutgoingClans() : Vector.<Long> {
var result:Vector.<Long> = null;
try {
Model.object = this.object;
result = this.impl.getOutgoingClans();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls.background {
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.Event;
public class Background extends Sprite {
private static var background:Class = Background_background;
public function Background() {
super();
addEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
}
private function addedToStage(e:Event) : void {
var bitmap:Bitmap = new background() as Bitmap;
bitmap.scaleX = stage.stageWidth / bitmap.width;
bitmap.scaleY = bitmap.scaleX;
addChild(bitmap);
removeEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.removedFromStage);
}
private function removedFromStage(e:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.removedFromStage);
addEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls.buttons {
import flash.events.Event;
import projects.tanks.clients.fp10.Prelauncher.Locale;
import projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp;
public class StartButton extends Button {
public function StartButton(onClick:Function) {
super(onClick);
addEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
}
private function addedToStage(e:Event) : void {
addChildToCenter(MakeUp.getStartButtonMakeUp());
addChildToCenter(MakeUp.getActiveStartButtonMakeUp());
addChild(textField);
textField.textColor = 15073125;
getChildAt(1).visible = false;
}
override public function switchLocale(locale:Locale) : void {
textField.defaultTextFormat.font = MakeUp.getFont(locale);
textField.text = locale.playText;
textFieldToCenter();
}
override protected function onResize(e:Event) : void {
this.x = stage.stageWidth >> 1;
this.y = (stage.stageHeight >> 1) + 80;
}
}
}
|
package alternativa.tanks.models.tank.ultimate {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.BattleRestartEvent;
import alternativa.tanks.battle.events.EffectActivatedEvent;
import alternativa.tanks.battle.events.EffectStoppedEvent;
import alternativa.tanks.battle.events.LocalTankActivationEvent;
import alternativa.tanks.battle.events.LocalTankKilledEvent;
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.battle.gui.inventory.InventorySoundService;
import alternativa.tanks.models.battle.gui.ultimate.UltimateIndicator;
import alternativa.tanks.models.inventory.InventoryItemType;
import alternativa.tanks.models.tank.AddToBattleListener;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.LocalTankInfoService;
import alternativa.tanks.models.tank.event.LocalTankLoadListener;
import alternativa.tanks.models.tank.event.LocalTankUnloadListener;
import alternativa.tanks.models.tank.hullcommon.HullCommon;
import alternativa.tanks.models.tank.ultimate.hunter.stun.UltimateStunListener;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.tanks.services.battleinput.GameActionListener;
import flash.events.TimerEvent;
import flash.geom.ColorTransform;
import flash.utils.Dictionary;
import flash.utils.Timer;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.ultimate.common.IUltimateModelBase;
import projects.tanks.client.battlefield.models.ultimate.common.UltimateModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class UltimateModel extends UltimateModelBase implements IUltimateModelBase, IUltimateModel, LocalTankLoadListener, LocalTankUnloadListener, ObjectLoadPostListener, UltimateStunListener, ObjectUnloadListener, AddToBattleListener, GameActionListener {
[Inject]
public static var inventorySoundService:InventorySoundService;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleInputService:BattleInputService;
[Inject]
public static var localTankInfoService:LocalTankInfoService;
[Inject]
public static var battleInfoService:IBattleInfoService;
private static const CHARGE_TIME_PERIOD_MILLIS:int = 100;
private static const FULL_CHARGE:int = 100;
private var battleEventSupport:BattleEventSupport;
private var chargeTimer:Timer;
private var chargePercentPerSecond:Number;
private var chargeInPercent:Number = 0;
private var localTankSpawned:Boolean;
private var ultimateBlocked:Boolean = true;
private var indicator:UltimateIndicator;
private var activeUltimates:Dictionary = new Dictionary();
public function UltimateModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(LocalTankActivationEvent,this.onLocalTankActivationEvent);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
this.battleEventSupport.addEventHandler(LocalTankKilledEvent,this.onLocalTankKilled);
this.battleEventSupport.addEventHandler(BattleRestartEvent,this.onBattleRestarted);
}
public static function parseColorTransform(param1:String) : ColorTransform {
if(param1 == null || param1.length != 6) {
return null;
}
var local2:Number = parseInt(param1.substr(0,2),16) / 255;
var local3:Number = parseInt(param1.substr(2,2),16) / 255;
var local4:Number = parseInt(param1.substr(4,2),16) / 255;
return new ColorTransform(local2,local3,local4);
}
public function updateCharge(param1:int) : void {
if(!battleInfoService.isSpectatorMode() && Boolean(localTankInfoService.isLocalTankLoaded()) && object == localTankInfoService.getLocalTankObject()) {
this.setCharge(param1);
}
}
private function onLocalTankActivationEvent(param1:Object) : void {
this.markInventoryIndicatorDisabled(false);
if(this.charged()) {
this.indicator.onCharged();
}
}
private function onBattleFinish(param1:BattleFinishEvent) : void {
this.reset();
this.markInventoryIndicatorDisabled(true);
}
private function onLocalTankKilled(param1:Object) : void {
this.markInventoryIndicatorDisabled(true);
}
private function onBattleRestarted(param1:Object) : void {
this.activeUltimates = new Dictionary();
this.reset();
this.localTankSpawned = true;
}
private function markInventoryIndicatorDisabled(param1:Boolean) : void {
this.ultimateBlocked = param1;
if(!battleInfoService.isSpectatorMode()) {
this.indicator.markDisabled(param1);
}
}
private function addChargeTimer() : void {
this.chargeTimer = new Timer(CHARGE_TIME_PERIOD_MILLIS);
this.chargeTimer.addEventListener(TimerEvent.TIMER,getFunctionWrapper(this.onChargeTick));
this.chargeTimer.start();
}
public function ultimateUsed() : void {
if(object == localTankInfoService.getLocalTankObjectOrNull()) {
this.setCharge(0);
}
this.hideTitleIcon();
}
private function onChargeTick(param1:TimerEvent) : void {
if(Boolean(battleService.isBattleActive()) && this.localTankSpawned) {
this.addCharge(this.chargePercentPerSecond / 10);
}
}
private function removeChargeTimer() : void {
this.chargeTimer.stop();
this.chargeTimer.removeEventListener(TimerEvent.TIMER,getFunctionWrapper(this.onChargeTick));
this.chargeTimer = null;
}
public function onGameAction(param1:GameActionEnum, param2:Boolean) : void {
var action:GameActionEnum = param1;
var isActive:Boolean = param2;
if(action == GameActionEnum.ULTIMATE && isActive && Boolean(localTankInfoService.isLocalTankLoaded())) {
object = localTankInfoService.getLocalTankObject();
try {
if(this.canActivate()) {
server.activateUltimate();
} else {
inventorySoundService.playNotReadySound();
}
}
finally {
Model.popObject();
}
}
}
private function canActivate() : Boolean {
return !this.ultimateBlocked && this.charged() && this.isInActiveState();
}
private function isInActiveState() : Boolean {
return ITankModel(object.adapt(ITankModel)).getTank().state == ClientTankState.ACTIVE;
}
private function charged() : Boolean {
return this.chargeInPercent >= FULL_CHARGE;
}
public function reset() : void {
this.localTankSpawned = false;
this.setCharge(0);
}
public function resetCharge() : void {
this.hideTitleIcon();
}
public function addCharge(param1:Number) : void {
if(this.charged()) {
return;
}
var local2:Number = this.chargeInPercent + param1;
if(local2 > 99) {
local2 = 99;
}
this.setCharge(local2);
}
public function showUltimateCharged() : void {
this.activeUltimates[object] = true;
if(!battleInfoService.isSpectatorMode() && object == localTankInfoService.getLocalTankObject()) {
this.setCharge(FULL_CHARGE);
if(this.isInActiveState()) {
this.indicator.onCharged();
}
}
this.showTitleIcon();
}
public function objectLoadedPost() : void {
if(getInitParam().enabled && getInitParam().charged) {
this.activeUltimates[object] = true;
this.showTitleIcon();
}
}
private function setCharge(param1:Number) : void {
if(Boolean(localTankInfoService.isLocalTankLoaded()) && object == localTankInfoService.getLocalTankObject() && this.indicator != null) {
this.chargeInPercent = param1;
this.indicator.updateCharge(param1);
}
}
public function objectUnloaded() : void {
delete this.activeUltimates[object];
}
public function localTankLoaded(param1:Boolean) : void {
if(getInitParam().enabled && !param1) {
this.localTankSpawned = true;
this.chargePercentPerSecond = getInitParam().chargePercentPerSecond;
this.addChargeTimer();
battleInputService.addGameActionListener(this);
}
}
public function initIndicator() : void {
if(Boolean(localTankInfoService.isLocalTankLoaded()) && object == localTankInfoService.getLocalTankObject()) {
if(this.indicator != null) {
this.indicator.destroy();
}
this.indicator = new UltimateIndicator(this.getUltimateIndex());
this.setCharge(0);
this.battleEventSupport.activateHandlers();
}
}
private function getUltimateIndex() : int {
var local1:IGameObject = ITankModel(object.adapt(ITankModel)).getTankSet().hull;
return HullCommon(local1.adapt(HullCommon)).getUltimateIconIndex();
}
public function localTankUnloaded(param1:Boolean) : void {
if(getInitParam().enabled && !param1) {
battleInputService.removeGameActionListener(this);
this.removeChargeTimer();
this.battleEventSupport.deactivateHandlers();
this.indicator.destroy();
this.indicator = null;
}
}
public function updateChargeAndRate(param1:int, param2:Number) : void {
this.chargePercentPerSecond = param2;
this.setCharge(param1);
}
public function onAddToBattle() : void {
if(getInitParam().enabled) {
if(Boolean(this.activeUltimates[object])) {
this.showTitleIcon();
}
}
}
private function showTitleIcon() : void {
battleEventDispatcher.dispatchEvent(new EffectActivatedEvent(object.id,InventoryItemType.ULTIMATE,int.MAX_VALUE));
}
private function hideTitleIcon() : void {
delete this.activeUltimates[object];
battleEventDispatcher.dispatchEvent(new EffectStoppedEvent(object.id,InventoryItemType.ULTIMATE));
}
public function isUltimateEnabled() : Boolean {
return getInitParam().enabled;
}
public function ultimateRejected() : void {
}
public function onStun(param1:Tank, param2:Boolean) : void {
if(param2) {
this.markInventoryIndicatorDisabled(true);
}
}
public function onCalm(param1:Tank, param2:Boolean, param3:int) : void {
if(param2) {
this.markInventoryIndicatorDisabled(false);
}
}
public function effectDeactivated() : void {
if(this.indicator != null) {
this.indicator.effectDeactivated();
}
}
public function effectActivatedOrMerged(param1:int) : void {
if(this.indicator != null) {
this.indicator.effectActivatedOrMerged(param1);
}
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_autoturretIconClass.png")]
public class DeviceIcons_autoturretIconClass extends BitmapAsset {
public function DeviceIcons_autoturretIconClass() {
super();
}
}
}
|
package forms.registration.bubbles {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class NameIsIncorrectBubble extends BubbleHelper {
[Inject]
public static var localeService:ILocaleService;
public function NameIsIncorrectBubble() {
super();
text = localeService.getText(TanksLocale.TEXT_HELP_NAME_IS_FORBIDDEN);
arrowLehgth = 20;
arrowAlign = HelperAlign.TOP_LEFT;
_showLimit = 3;
}
}
}
|
package alternativa.tanks.model.personaldiscount {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.personaldiscount.PersonalDiscountAlert;
import forms.events.PartsListEvent;
import projects.tanks.client.panel.model.garage.GarageItemInfo;
import projects.tanks.client.panel.model.personaldiscount.IPersonalDiscountModelBase;
import projects.tanks.client.panel.model.personaldiscount.PersonalDiscountModelBase;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
[ModelInfo]
public class PersonalDiscountModel extends PersonalDiscountModelBase implements IPersonalDiscountModelBase {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
private static const USER_NAME_PATTERN:String = "$USERNAME$";
private static const ITEM_NAME_PATTERN:String = "$ITEM-NAME$";
public static const DISCOUNT_TIMER_PATTERN:String = "$DISCOUNT_TIMER$";
private static const DISCOUNT_PATTERN:String = "$DISCOUNT$";
public function PersonalDiscountModel() {
super();
}
public function showPersonalDiscount(param1:GarageItemInfo, param2:int, param3:int, param4:int) : void {
var local5:String = localeService.getText(TanksLocale.TEXT_MESSAGE_ALERT_PERSONAL_DISCOUNT);
var local6:String = local5.replace(USER_NAME_PATTERN,userPropertiesService.userName).replace(ITEM_NAME_PATTERN,param1.name).replace(DISCOUNT_PATTERN,param2);
var local7:PersonalDiscountAlert = new PersonalDiscountAlert(param1,localeService.getText(TanksLocale.TEXT_HEADER_DISCOUNT),param2,param3,param4,local6);
if(lobbyLayoutService.isSwitchInProgress()) {
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
} else {
local7.enqueueDialog();
}
local7.partsList.addEventListener(PartsListEvent.SELECT_PARTS_LIST_ITEM,getFunctionWrapper(this.onItemSelect));
putData(PersonalDiscountAlert,local7);
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
var local2:PersonalDiscountAlert = PersonalDiscountAlert(getData(PersonalDiscountAlert));
local2.enqueueDialog();
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
}
private function onItemSelect(param1:PartsListEvent) : void {
var local2:PersonalDiscountAlert = PersonalDiscountAlert(getData(PersonalDiscountAlert));
server.select(local2.partsList.selectedItem);
local2.partsList.removeEventListener(PartsListEvent.SELECT_PARTS_LIST_ITEM,getFunctionWrapper(this.onItemSelect));
local2.close();
}
}
}
|
package projects.tanks.client.battlefield.models.statistics.fps {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class FpsStatisticsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _collectStatisticsId:Long = Long.getLong(1340801043,-1420381609);
private var _collectStatistics_numTicksCodec:ICodec;
private var _collectStatistics_durationCodec:ICodec;
private var _collectStatistics_settingsCodec:ICodec;
private var model:IModel;
public function FpsStatisticsModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._collectStatistics_numTicksCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._collectStatistics_durationCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._collectStatistics_settingsCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function collectStatistics(param1:int, param2:int, param3:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._collectStatistics_numTicksCodec.encode(this.protocolBuffer,param1);
this._collectStatistics_durationCodec.encode(this.protocolBuffer,param2);
this._collectStatistics_settingsCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._collectStatisticsId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
import flash.display.Sprite;
use namespace alternativa3d;
public class Debug {
public static const BOUNDS:int = 8;
public static const EDGES:int = 16;
public static const NODES:int = 128;
public static const LIGHTS:int = 256;
public static const BONES:int = 512;
private static const boundVertexList:Vertex = Vertex.alternativa3d::createList(8);
private static const nodeVertexList:Vertex = Vertex.alternativa3d::createList(4);
public function Debug() {
super();
}
alternativa3d static function drawEdges(param1:Camera3D, param2:Face, param3:int) : void {
var local6:Number = NaN;
var local9:Wrapper = null;
var local10:Vertex = null;
var local11:Number = NaN;
var local12:Number = NaN;
var local4:Number = Number(param1.alternativa3d::viewSizeX);
var local5:Number = Number(param1.alternativa3d::viewSizeY);
var local7:Sprite = param1.view.alternativa3d::canvas;
local7.graphics.lineStyle(0,param3);
var local8:Face = param2;
while(local8 != null) {
local9 = local8.alternativa3d::wrapper;
local10 = local9.alternativa3d::vertex;
local6 = 1 / local10.alternativa3d::cameraZ;
local11 = local10.alternativa3d::cameraX * local4 * local6;
local12 = local10.alternativa3d::cameraY * local5 * local6;
local7.graphics.moveTo(local11,local12);
local9 = local9.alternativa3d::next;
while(local9 != null) {
local10 = local9.alternativa3d::vertex;
local6 = 1 / local10.alternativa3d::cameraZ;
local7.graphics.lineTo(local10.alternativa3d::cameraX * local4 * local6,local10.alternativa3d::cameraY * local5 * local6);
local9 = local9.alternativa3d::next;
}
local7.graphics.lineTo(local11,local12);
local8 = local8.alternativa3d::processNext;
}
}
alternativa3d static function drawBounds(param1:Camera3D, param2:Object3D, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:int = -1, param10:Number = 1) : void {
var local11:Vertex = null;
var local23:Number = NaN;
var local12:Vertex = boundVertexList;
local12.x = param3;
local12.y = param4;
local12.z = param5;
var local13:Vertex = local12.alternativa3d::next;
local13.x = param6;
local13.y = param4;
local13.z = param5;
var local14:Vertex = local13.alternativa3d::next;
local14.x = param3;
local14.y = param7;
local14.z = param5;
var local15:Vertex = local14.alternativa3d::next;
local15.x = param6;
local15.y = param7;
local15.z = param5;
var local16:Vertex = local15.alternativa3d::next;
local16.x = param3;
local16.y = param4;
local16.z = param8;
var local17:Vertex = local16.alternativa3d::next;
local17.x = param6;
local17.y = param4;
local17.z = param8;
var local18:Vertex = local17.alternativa3d::next;
local18.x = param3;
local18.y = param7;
local18.z = param8;
var local19:Vertex = local18.alternativa3d::next;
local19.x = param6;
local19.y = param7;
local19.z = param8;
local11 = local12;
while(local11 != null) {
local11.alternativa3d::cameraX = param2.alternativa3d::ma * local11.x + param2.alternativa3d::mb * local11.y + param2.alternativa3d::mc * local11.z + param2.alternativa3d::md;
local11.alternativa3d::cameraY = param2.alternativa3d::me * local11.x + param2.alternativa3d::mf * local11.y + param2.alternativa3d::mg * local11.z + param2.alternativa3d::mh;
local11.alternativa3d::cameraZ = param2.alternativa3d::mi * local11.x + param2.alternativa3d::mj * local11.y + param2.alternativa3d::mk * local11.z + param2.alternativa3d::ml;
if(local11.alternativa3d::cameraZ <= 0) {
return;
}
local11 = local11.alternativa3d::next;
}
var local20:Number = Number(param1.alternativa3d::viewSizeX);
var local21:Number = Number(param1.alternativa3d::viewSizeY);
local11 = local12;
while(local11 != null) {
local23 = 1 / local11.alternativa3d::cameraZ;
local11.alternativa3d::cameraX = local11.alternativa3d::cameraX * local20 * local23;
local11.alternativa3d::cameraY = local11.alternativa3d::cameraY * local21 * local23;
local11 = local11.alternativa3d::next;
}
var local22:Sprite = param1.view.alternativa3d::canvas;
local22.graphics.lineStyle(0,param9 < 0 ? (param2.alternativa3d::culling > 0 ? 16776960 : 65280) : uint(param9),param10);
local22.graphics.moveTo(local12.alternativa3d::cameraX,local12.alternativa3d::cameraY);
local22.graphics.lineTo(local13.alternativa3d::cameraX,local13.alternativa3d::cameraY);
local22.graphics.lineTo(local15.alternativa3d::cameraX,local15.alternativa3d::cameraY);
local22.graphics.lineTo(local14.alternativa3d::cameraX,local14.alternativa3d::cameraY);
local22.graphics.lineTo(local12.alternativa3d::cameraX,local12.alternativa3d::cameraY);
local22.graphics.moveTo(local16.alternativa3d::cameraX,local16.alternativa3d::cameraY);
local22.graphics.lineTo(local17.alternativa3d::cameraX,local17.alternativa3d::cameraY);
local22.graphics.lineTo(local19.alternativa3d::cameraX,local19.alternativa3d::cameraY);
local22.graphics.lineTo(local18.alternativa3d::cameraX,local18.alternativa3d::cameraY);
local22.graphics.lineTo(local16.alternativa3d::cameraX,local16.alternativa3d::cameraY);
local22.graphics.moveTo(local12.alternativa3d::cameraX,local12.alternativa3d::cameraY);
local22.graphics.lineTo(local16.alternativa3d::cameraX,local16.alternativa3d::cameraY);
local22.graphics.moveTo(local13.alternativa3d::cameraX,local13.alternativa3d::cameraY);
local22.graphics.lineTo(local17.alternativa3d::cameraX,local17.alternativa3d::cameraY);
local22.graphics.moveTo(local15.alternativa3d::cameraX,local15.alternativa3d::cameraY);
local22.graphics.lineTo(local19.alternativa3d::cameraX,local19.alternativa3d::cameraY);
local22.graphics.moveTo(local14.alternativa3d::cameraX,local14.alternativa3d::cameraY);
local22.graphics.lineTo(local18.alternativa3d::cameraX,local18.alternativa3d::cameraY);
}
alternativa3d static function drawKDNode(param1:Camera3D, param2:Object3D, param3:int, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number, param11:Number) : void {
var local12:Vertex = null;
var local20:Number = NaN;
var local13:Vertex = nodeVertexList;
var local14:Vertex = local13.alternativa3d::next;
var local15:Vertex = local14.alternativa3d::next;
var local16:Vertex = local15.alternativa3d::next;
if(param3 == 0) {
local13.x = param4;
local13.y = param6;
local13.z = param10;
local14.x = param4;
local14.y = param9;
local14.z = param10;
local15.x = param4;
local15.y = param9;
local15.z = param7;
local16.x = param4;
local16.y = param6;
local16.z = param7;
} else if(param3 == 1) {
local13.x = param8;
local13.y = param4;
local13.z = param10;
local14.x = param5;
local14.y = param4;
local14.z = param10;
local15.x = param5;
local15.y = param4;
local15.z = param7;
local16.x = param8;
local16.y = param4;
local16.z = param7;
} else {
local13.x = param5;
local13.y = param6;
local13.z = param4;
local14.x = param8;
local14.y = param6;
local14.z = param4;
local15.x = param8;
local15.y = param9;
local15.z = param4;
local16.x = param5;
local16.y = param9;
local16.z = param4;
}
local12 = local13;
while(local12 != null) {
local12.alternativa3d::cameraX = param2.alternativa3d::ma * local12.x + param2.alternativa3d::mb * local12.y + param2.alternativa3d::mc * local12.z + param2.alternativa3d::md;
local12.alternativa3d::cameraY = param2.alternativa3d::me * local12.x + param2.alternativa3d::mf * local12.y + param2.alternativa3d::mg * local12.z + param2.alternativa3d::mh;
local12.alternativa3d::cameraZ = param2.alternativa3d::mi * local12.x + param2.alternativa3d::mj * local12.y + param2.alternativa3d::mk * local12.z + param2.alternativa3d::ml;
if(local12.alternativa3d::cameraZ <= 0) {
return;
}
local12 = local12.alternativa3d::next;
}
var local17:Number = Number(param1.alternativa3d::viewSizeX);
var local18:Number = Number(param1.alternativa3d::viewSizeY);
local12 = local13;
while(local12 != null) {
local20 = 1 / local12.alternativa3d::cameraZ;
local12.alternativa3d::cameraX = local12.alternativa3d::cameraX * local17 * local20;
local12.alternativa3d::cameraY = local12.alternativa3d::cameraY * local18 * local20;
local12 = local12.alternativa3d::next;
}
var local19:Sprite = param1.view.alternativa3d::canvas;
local19.graphics.lineStyle(0,param3 == 0 ? 16711680 : (param3 == 1 ? 65280 : 255),param11);
local19.graphics.moveTo(local13.alternativa3d::cameraX,local13.alternativa3d::cameraY);
local19.graphics.lineTo(local14.alternativa3d::cameraX,local14.alternativa3d::cameraY);
local19.graphics.lineTo(local15.alternativa3d::cameraX,local15.alternativa3d::cameraY);
local19.graphics.lineTo(local16.alternativa3d::cameraX,local16.alternativa3d::cameraY);
local19.graphics.lineTo(local13.alternativa3d::cameraX,local13.alternativa3d::cameraY);
}
alternativa3d static function drawBone(param1:Camera3D, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:int) : void {
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Sprite = null;
var local8:Number = param4 - param2;
var local9:Number = param5 - param3;
var local10:Number = Math.sqrt(local8 * local8 + local9 * local9);
if(local10 > 0.001) {
local8 /= local10;
local9 /= local10;
local11 = local9 * param6;
local12 = -local8 * param6;
local13 = -local9 * param6;
local14 = local8 * param6;
if(local10 > param6 * 2) {
local10 = param6;
} else {
local10 /= 2;
}
local15 = param1.view.alternativa3d::canvas;
local15.graphics.lineStyle(1,param7);
local15.graphics.beginFill(param7,0.6);
local15.graphics.moveTo(param2,param3);
local15.graphics.lineTo(param2 + local8 * local10 + local11,param3 + local9 * local10 + local12);
local15.graphics.lineTo(param4,param5);
local15.graphics.lineTo(param2 + local8 * local10 + local13,param3 + local9 * local10 + local14);
local15.graphics.lineTo(param2,param3);
local15.graphics.endFill();
}
}
}
}
|
package alternativa.tanks.model.quest.challenge.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.challenge.gui.ChallengesView_silverStarClass.png")]
public class ChallengesView_silverStarClass extends BitmapAsset {
public function ChallengesView_silverStarClass() {
super();
}
}
}
|
package alternativa.tanks.models.teamlight {
import alternativa.tanks.services.lightingeffects.ILightingEffectsService;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.teamlight.ITeamLightModelBase;
import projects.tanks.client.battlefield.models.teamlight.TeamLightColorParams;
import projects.tanks.client.battlefield.models.teamlight.TeamLightModelBase;
import projects.tanks.client.battlefield.models.teamlight.TeamLightParams;
[ModelInfo]
public class TeamLightModel extends TeamLightModelBase implements ITeamLightModelBase, ObjectLoadListener {
[Inject]
public static var lightingEffectsService:ILightingEffectsService;
public function TeamLightModel() {
super();
}
public function objectLoaded() : void {
var local1:TeamLightParams = null;
for each(local1 in getInitParam().lightModes) {
lightingEffectsService.setLightForMode(local1.battleMode,this.createTeamLight(local1));
}
}
private function createTeamLight(param1:TeamLightParams) : ModeLight {
return new ModeLight(this.createTeamLightColor(param1.redTeam),this.createTeamLightColor(param1.blueTeam),this.createTeamLightColor(param1.neutralTeam),param1.attenuationBegin,param1.attenuationEnd);
}
private function createTeamLightColor(param1:TeamLightColorParams) : TeamLightColor {
return new TeamLightColor(uint(param1.color),param1.intensity);
}
}
}
|
package alternativa.tanks.servermodels.loginwithoutregistration {
[ModelInterface]
public interface ILoginWithoutRegistration {
function passToFirstBattle() : void;
}
}
|
package alternativa.tanks.models.weapons.targeting.direction.sector {
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapons.targeting.direction.TargetingDirection;
import alternativa.tanks.models.weapons.targeting.direction.TargetingDirectionCalculator;
import alternativa.tanks.models.weapons.targeting.direction.sector.splitter.SectorsSplitter;
import alternativa.tanks.models.weapons.targeting.priority.TargetingPriorityCalculator;
import platform.client.fp10.core.type.IGameObject;
public class SectorDirectionCalculator implements TargetingDirectionCalculator {
private var targetingSectorsCalculator:TargetingSectorsCalculator;
private var sectorsSplitter:SectorsSplitter;
public function SectorDirectionCalculator(param1:IGameObject, param2:WeaponObject, param3:Number, param4:TargetingPriorityCalculator) {
super();
this.targetingSectorsCalculator = new TargetingSectorsCalculator(param1,param2,param3);
this.sectorsSplitter = new SectorsSplitter(param4);
}
public function getDirections(param1:AllGlobalGunParams) : Vector.<TargetingDirection> {
var local2:Vector.<TargetingSector> = this.targetingSectorsCalculator.getSectors(param1);
return this.sectorsSplitter.splitSectorsOnDirections(param1,local2);
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_firebirdClass.png")]
public class ItemInfoPanelBitmaps_firebirdClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_firebirdClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.sms {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class SMSPayModeModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getNumbersId:Long = Long.getLong(624215912,-359386284);
private var _getNumbers_operatorIdCodec:ICodec;
private var _getOperatorsId:Long = Long.getLong(1423929292,1785600561);
private var _getOperators_countryIdCodec:ICodec;
private var model:IModel;
public function SMSPayModeModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._getNumbers_operatorIdCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._getOperators_countryIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function getNumbers(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getNumbers_operatorIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._getNumbersId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function getOperators(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getOperators_countryIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._getOperatorsId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.service.country.event {
import flash.events.Event;
public class UserPaymentCountryChangedEvent extends Event {
public static const USER_PAYMENT_COUNTRY_CHANGED:String = "UserPaymentCountryChangedEventUSER_PAYMENT_COUNTRY_CHANGED";
public var countryCode:String;
public function UserPaymentCountryChangedEvent(param1:String, param2:String) {
super(param1,true);
this.countryCode = param2;
}
}
}
|
package platform.client.fp10.core.model {
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
public interface IModel {
function invoke(param1:Long, param2:ProtocolBuffer) : void;
function get id() : Long;
function putInitParams(param1:Object) : void;
function clearInitParams() : void;
function getData(param1:Class) : Object;
function putData(param1:Class, param2:Object) : void;
function clearData(param1:Class) : Object;
}
}
|
package alternativa.tanks.models.continuebattle {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ContinueBattleAdapt implements ContinueBattle {
private var object:IGameObject;
private var impl:ContinueBattle;
public function ContinueBattleAdapt(param1:IGameObject, param2:ContinueBattle) {
super();
this.object = param1;
this.impl = param2;
}
public function continueBattle() : void {
try {
Model.object = this.object;
this.impl.continueBattle();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.tank.turnover {
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.events.TankRemovedFromBattleEvent;
import alternativa.tanks.battle.events.death.TankDeadEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.event.LocalTankLoadListener;
import alternativa.tanks.models.tank.event.LocalTankUnloadListener;
import alternativa.tanks.models.tank.support.TurnOverIndicatorSupport;
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.turnover.ITankTurnOverModelBase;
import projects.tanks.client.battlefield.models.user.turnover.TankTurnOverModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
[ModelInfo]
public class TankTurnOverModel extends TankTurnOverModelBase implements ITankTurnOverModelBase, LocalTankLoadListener, BattleEventListener, LocalTankUnloadListener {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
private const CHECK_DELAY:int = 100;
private const SHOW_DELAY:int = 4000;
private const RANK_THRESHOLD:int = 5;
private var localUser:IGameObject;
private var timer:Timer;
private var lastTurnedTime:int;
private var wasTurnedOver:Boolean;
private var isInsideBattle:Boolean;
private var indicatorSupport:TurnOverIndicatorSupport;
public function TankTurnOverModel() {
super();
}
public function localTankLoaded(param1:Boolean) : void {
this.localUser = object;
this.timer = new Timer(this.CHECK_DELAY);
this.indicatorSupport = new TurnOverIndicatorSupport();
putData(TurnOverIndicatorSupport,this.indicatorSupport);
this.addEventHandlers();
this.timer.start();
}
private function checkTurnOverHandler(param1:TimerEvent) : void {
if(this.isTurnedOver()) {
if(!this.wasTurnedOver) {
this.lastTurnedTime = getTimer();
this.wasTurnedOver = true;
}
} else {
this.wasTurnedOver = false;
}
if(this.shouldShowIndicator()) {
this.indicatorSupport.shouldShow();
} else {
this.indicatorSupport.hide();
}
}
private function isTurnedOver() : Boolean {
var local1:ITankModel = ITankModel(this.localUser.adapt(ITankModel));
var local2:Tank = local1.getTank();
return BattleUtils.isTurnedOver(local2.getBody());
}
private function shouldShowIndicator() : Boolean {
return this.isInsideBattle && this.wasTurnedOver && this.timeSinceTurned() > this.SHOW_DELAY && userPropertiesService.rank <= this.RANK_THRESHOLD;
}
private function timeSinceTurned() : int {
return getTimer() - this.lastTurnedTime;
}
public function handleBattleEvent(param1:Object) : void {
if(param1 is BattleFinishEvent) {
this.resetTurnOverState(false);
} else if(param1 is TankDeadEvent) {
if(this.localUser == TankDeadEvent(param1).victim) {
this.resetTurnOverState(false);
}
} else if(param1 is TankAddedToBattleEvent) {
if(this.localUser == TankAddedToBattleEvent(param1).tank.getUser()) {
this.resetTurnOverState(true);
}
} else if(param1 is TankRemovedFromBattleEvent) {
if(this.localUser == TankRemovedFromBattleEvent(param1).tank.getUser()) {
this.resetTurnOverState(false);
}
}
}
private function resetTurnOverState(param1:Boolean) : void {
this.isInsideBattle = param1;
this.wasTurnedOver = false;
this.lastTurnedTime = 0;
this.indicatorSupport.hide();
}
private function addEventHandlers() : void {
this.timer.addEventListener(TimerEvent.TIMER,this.checkTurnOverHandler);
battleEventDispatcher.addBattleEventListener(BattleFinishEvent,this);
battleEventDispatcher.addBattleEventListener(TankDeadEvent,this);
battleEventDispatcher.addBattleEventListener(TankAddedToBattleEvent,this);
battleEventDispatcher.addBattleEventListener(TankRemovedFromBattleEvent,this);
}
private function removeEventHandlers() : void {
this.timer.removeEventListener(TimerEvent.TIMER,this.checkTurnOverHandler);
battleEventDispatcher.removeBattleEventListener(BattleFinishEvent,this);
battleEventDispatcher.removeBattleEventListener(TankDeadEvent,this);
battleEventDispatcher.removeBattleEventListener(TankAddedToBattleEvent,this);
battleEventDispatcher.removeBattleEventListener(TankRemovedFromBattleEvent,this);
}
public function localTankUnloaded(param1:Boolean) : void {
this.timer.stop();
this.removeEventHandlers();
this.timer = null;
this.lastTurnedTime = 0;
this.wasTurnedOver = false;
this.isInsideBattle = false;
this.indicatorSupport = null;
}
}
}
|
package alternativa.tanks.models.tank.suicude {
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.death.TankSuicideEvent;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.event.LocalTankLoadListener;
import alternativa.tanks.models.tank.event.LocalTankUnloadListener;
import alternativa.tanks.models.tank.support.SuicideSupport;
import projects.tanks.client.battlefield.models.user.suicide.ISuicideModelBase;
import projects.tanks.client.battlefield.models.user.suicide.SuicideModelBase;
[ModelInfo]
public class SuicideModel extends SuicideModelBase implements ISuicideModelBase, LocalTankLoadListener, LocalTankUnloadListener {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
public function SuicideModel() {
super();
}
public function localTankLoaded(param1:Boolean) : void {
putData(SuicideSupport,new SuicideSupport(object,server,getInitParam().suicideDelayMS));
}
public function localTankUnloaded(param1:Boolean) : void {
SuicideSupport(clearData(SuicideSupport)).close();
}
[Obfuscation(rename="false")]
public function suicide(param1:int) : void {
var local2:ITankModel = ITankModel(object.adapt(ITankModel));
local2.die(param1);
battleEventDispatcher.dispatchEvent(new TankSuicideEvent(object));
}
}
}
|
package controls.base {
public class RedButtonBase extends ColorButtonBase {
public function RedButtonBase() {
super();
setStyle(RED);
labelColor = 16777215;
}
}
}
|
package alternativa.types
{
import alternativa.init.OSGi;
import alternativa.osgi.service.console.IConsoleService;
public final class Long
{
private var _low:int;
private var _high:int;
public function Long(low:int, high:int)
{
super();
this._low = low;
this._high = high;
}
public function get low() : int
{
return this._low;
}
public function get high() : int
{
return this._high;
}
public function toString() : String
{
return this.intToUhex(this._high) + this.intToUhex(this._low);
}
private function intToUhex(value:int) : String
{
var result:String = null;
var a:uint = 0;
var console:IConsoleService = OSGi.osgi.getService(IConsoleService) as IConsoleService;
if(value >= 0)
{
result = value.toString(16);
}
else
{
a = value & ~2147483648 | 2147483648;
result = a.toString(16);
}
var numZeros:int = 8 - result.length;
while(numZeros > 0)
{
result = "0" + result;
numZeros--;
}
return result;
}
}
}
|
package alternativa.tanks.loader
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class LoaderWindow_bitmapWindowMedium extends BitmapAsset
{
public function LoaderWindow_bitmapWindowMedium()
{
super();
}
}
}
|
package projects.tanks.client.partners.impl.china.partner7k7k {
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 Partner7k7kModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function Partner7k7kModelServer(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.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapPower extends BitmapAsset
{
public function ItemInfoPanel_bitmapPower()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.armor.simple {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.armor.simple.SimpleArmorCC;
public class CodecSimpleArmorCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_maxHealth:ICodec;
public function CodecSimpleArmorCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_maxHealth = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SimpleArmorCC = new SimpleArmorCC();
local2.maxHealth = this.codec_maxHealth.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:SimpleArmorCC = SimpleArmorCC(param2);
this.codec_maxHealth.encode(param1,local3.maxHealth);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.score.RugbyScoreIndicator_flagRedLostClass.png")]
public class RugbyScoreIndicator_flagRedLostClass extends BitmapAsset {
public function RugbyScoreIndicator_flagRedLostClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased {
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.battle.pointbased.PointBasedBattleCC;
public class VectorCodecPointBasedBattleCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPointBasedBattleCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PointBasedBattleCC,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.<PointBasedBattleCC> = new Vector.<PointBasedBattleCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PointBasedBattleCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PointBasedBattleCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PointBasedBattleCC> = Vector.<PointBasedBattleCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.weapon.ricochet {
import alternativa.tanks.sfx.SimplePlane;
internal class TailTrail extends SimplePlane {
public function TailTrail(param1:Number, param2:Number) {
super(param1,param2,0.5,1);
setUVs(1,1,1,0,0,0,0,1);
shadowMapAlphaThreshold = 2;
depthMapAlphaThreshold = 2;
useShadowMap = false;
useLight = false;
}
}
}
|
package alternativa.tanks.models.weapon.flamethrower
{
import alternativa.object.ClientObject;
public interface IFlamethrower
{
function getFlameData(param1:ClientObject) : FlamethrowerData;
}
}
|
package alternativa.tanks.models.battle.tdm {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.TeamDMTargetEvaluator;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.LocalTankActivationEvent;
import alternativa.tanks.models.battle.battlefield.BattleModel;
import alternativa.tanks.models.battle.battlefield.BattleType;
import alternativa.tanks.models.weapon.ricochet.TeamDMRicochetTargetEvaluator;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battleservice.model.battle.tdm.BattleTDMModelBase;
import projects.tanks.client.battleservice.model.battle.tdm.IBattleTDMModelBase;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
[ModelInfo]
public class BattleTDMModel extends BattleTDMModelBase implements IBattleTDMModelBase, ObjectLoadPostListener, ObjectUnloadListener, BattleEventListener, BattleModel {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private var targetEvaluators:Vector.<TeamDMTargetEvaluator>;
public function BattleTDMModel() {
super();
}
public function getBattleType() : BattleType {
return BattleType.TDM;
}
[Obfuscation(rename="false")]
public function objectLoadedPost() : void {
this.targetEvaluators = new Vector.<TeamDMTargetEvaluator>();
var local1:TDMCommonTargetEvaluator = new TDMCommonTargetEvaluator();
battleService.setCommonTargetEvaluator(local1);
this.targetEvaluators.push(local1);
var local2:TDMHealingGunTargetEvaluator = new TDMHealingGunTargetEvaluator();
battleService.setHealingGunTargetEvaluator(local2);
this.targetEvaluators.push(local2);
var local3:TDMRailgunTargetEvaluator = new TDMRailgunTargetEvaluator();
battleService.setRailgunTargetEvaluator(local3);
this.targetEvaluators.push(local3);
var local4:TeamDMRicochetTargetEvaluator = new TeamDMRicochetTargetEvaluator();
battleService.setRicochetTargetEvaluator(local4);
this.targetEvaluators.push(local4);
battleEventDispatcher.addBattleEventListener(LocalTankActivationEvent,this);
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
this.targetEvaluators = null;
battleService.setCommonTargetEvaluator(null);
battleService.setHealingGunTargetEvaluator(null);
battleService.setRailgunTargetEvaluator(null);
battleService.setRicochetTargetEvaluator(null);
battleEventDispatcher.removeBattleEventListener(LocalTankActivationEvent,this);
}
public function handleBattleEvent(param1:Object) : void {
var local3:TeamDMTargetEvaluator = null;
var local2:BattleTeam = LocalTankActivationEvent(param1).tank.teamType;
for each(local3 in this.targetEvaluators) {
local3.setLocalTeamType(local2);
}
}
}
}
|
package projects.tanks.client.partners.impl.china.partner4399 {
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 Partner4399ModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:Partner4399ModelServer;
private var client:IPartner4399ModelBase = IPartner4399ModelBase(this);
private var modelId:Long = Long.getLong(15219793,-1921200771);
public function Partner4399ModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new Partner4399ModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.shop.notification.service {
import flash.events.IEventDispatcher;
public interface ShopNotifierService extends IEventDispatcher {
function showNotificationAboutNewItems() : void;
function showNotificationAboutDiscounts() : void;
function hideNotification() : void;
}
}
|
package alternativa.tanks.camera
{
import alternativa.engine3d.core.Camera3D;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
public class GameCamera extends Camera3D
{
private static const m:Matrix3 = new Matrix3();
public var pos:Vector3;
public var xAxis:Vector3;
public var yAxis:Vector3;
public var zAxis:Vector3;
public function GameCamera()
{
this.pos = new Vector3();
this.xAxis = new Vector3();
this.yAxis = new Vector3();
this.zAxis = new Vector3();
super();
diagramVerticalMargin = 35;
}
public function calculateAdditionalData() : void
{
var cosX:Number = Math.cos(rotationX);
var sinX:Number = Math.sin(rotationX);
var cosY:Number = Math.cos(rotationY);
var sinY:Number = Math.sin(rotationY);
var cosZ:Number = Math.cos(rotationZ);
var sinZ:Number = Math.sin(rotationZ);
var cosZsinY:Number = cosZ * sinY;
var sinZsinY:Number = sinZ * sinY;
this.xAxis.x = cosZ * cosY;
this.yAxis.x = cosZsinY * sinX - sinZ * cosX;
this.zAxis.x = cosZsinY * cosX + sinZ * sinX;
this.xAxis.y = sinZ * cosY;
this.yAxis.y = sinZsinY * sinX + cosZ * cosX;
this.zAxis.y = sinZsinY * cosX - cosZ * sinX;
this.xAxis.z = -sinY;
this.yAxis.z = cosY * sinX;
this.zAxis.z = cosY * cosX;
this.pos.x = x;
this.pos.y = y;
this.pos.z = z;
}
public function getGlobalVector(param1:Vector3, param2:Vector3) : void
{
m.setRotationMatrix(rotationX,rotationY,rotationZ);
m.transformVector(param1,param2);
}
public function updateFov() : void
{
fov = CameraFovCalculator.getCameraFov(view.width,view.height);
}
}
}
|
package controls.statassets {
import assets.stat.hall_SELECTED_ACTIVE;
import flash.display.BitmapData;
public class StatLineSelectedActive extends StatLineBase {
public function StatLineSelectedActive() {
super();
tl = new hall_SELECTED_ACTIVE(1,1);
px = new BitmapData(1,1,false,881920);
frameColor = 5898034;
}
}
}
|
package _codec.projects.tanks.client.clans.panel.notification {
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.clans.panel.notification.ClanPanelNotificationCC;
public class VectorCodecClanPanelNotificationCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecClanPanelNotificationCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ClanPanelNotificationCC,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.<ClanPanelNotificationCC> = new Vector.<ClanPanelNotificationCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ClanPanelNotificationCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ClanPanelNotificationCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ClanPanelNotificationCC> = Vector.<ClanPanelNotificationCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.partners.impl.facebook.login {
public interface IFacebookInternalLoginModelBase {
}
}
|
package forms.friends.list
{
import alternativa.tanks.model.Friend;
import forms.friends.IFriendsListState;
import forms.friends.IRejectAllIncomingButtonEnabled;
import forms.friends.list.renderer.FriendsIncomingListRenderer;
public class IncomingList extends FriendsList implements IFriendsListState
{
private var _rejectAllIncomingButton:IRejectAllIncomingButtonEnabled;
public function IncomingList(param1:IRejectAllIncomingButtonEnabled)
{
super();
this._rejectAllIncomingButton = param1;
init(FriendsIncomingListRenderer);
_dataProvider.getItemAtHandler = this.markAsViewed;
}
public function initList() : void
{
_dataProvider.sortOn(["isNew","uid"],[Array.NUMERIC | Array.DESCENDING,Array.CASEINSENSITIVE]);
fillIncomingList(Friend.friends);
this.updateEnableRejectButton();
_list.scrollToIndex(2);
resize(_width,_height);
}
public function onRemoveFromFriends() : void
{
_dataProvider.removeAll();
_dataProvider.refresh();
this.resize(_width,_height);
}
private function updateEnableRejectButton() : void
{
this._rejectAllIncomingButton.setEnable(_dataProvider.length != 0);
}
private function markAsViewed(param1:Object) : void
{
if(!isViewed(param1) && param1.isNew)
{
setAsViewed(param1);
}
}
public function hide() : void
{
if(parent.contains(this))
{
parent.removeChild(this);
_dataProvider.removeAll();
}
}
public function filter(param1:String, param2:String) : void
{
filterByProperty(param1,param2);
resize(_width,_height);
}
public function resetFilter() : void
{
_dataProvider.resetFilter();
resize(_width,_height);
}
}
}
|
package alternativa.tanks.model.payment.shop.cashpackage {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class CashPackageAdapt implements CashPackage {
private var object:IGameObject;
private var impl:CashPackage;
public function CashPackageAdapt(param1:IGameObject, param2:CashPackage) {
super();
this.object = param1;
this.impl = param2;
}
public function getAmount() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getAmount());
}
finally {
Model.popObject();
}
return result;
}
public function getBonusAmount() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getBonusAmount());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_highcaliberammoIconClass.png")]
public class DeviceIcons_highcaliberammoIconClass extends BitmapAsset {
public function DeviceIcons_highcaliberammoIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui.settings.controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.settings.controls.TabIcons_gameTabIconClass.png")]
public class TabIcons_gameTabIconClass extends BitmapAsset {
public function TabIcons_gameTabIconClass() {
super();
}
}
}
|
package controls.chat {
public class MessageColor {
public static const BLUE:uint = 10013694;
public static const RED:uint = 16685208;
public static const YELLOW:uint = 16777071;
public static const WHITE:uint = 14540253;
public function MessageColor() {
super();
}
}
}
|
package alternativa.protocol.codec.complex
{
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class LengthCodec
{
public function LengthCodec()
{
super();
}
public static function encodeLength(dest:IDataOutput, length:int) : void
{
var tmp:Number = NaN;
if(length < 0)
{
throw new Error("Length is incorrect (" + length + ")");
}
if(length < 128)
{
dest.writeByte(int(length & 127));
}
else if(length < 16384)
{
tmp = (length & 16383) + 32768;
dest.writeByte(int((tmp & 65280) >> 8));
dest.writeByte(int(tmp & 255));
}
else
{
if(length >= 4194304)
{
throw new Error("Length is incorrect (" + length + ")");
}
tmp = (length & 4194303) + 12582912;
dest.writeByte(int((tmp & 16711680) >> 16));
dest.writeByte(int((tmp & 65280) >> 8));
dest.writeByte(int(tmp & 255));
}
}
public static function decodeLength(reader:IDataInput) : int
{
var secondByte:int = 0;
var doubleByte:Boolean = false;
var thirdByte:int = 0;
var firstByte:int = reader.readByte();
var singleByte:Boolean = (firstByte & 128) == 0;
if(singleByte)
{
return firstByte;
}
secondByte = reader.readByte();
doubleByte = (firstByte & 64) == 0;
if(doubleByte)
{
return ((firstByte & 63) << 8) + (secondByte & 255);
}
thirdByte = reader.readByte();
return ((firstByte & 63) << 16) + ((secondByte & 255) << 8) + (thirdByte & 255);
}
}
}
|
package controls.slider
{
import assets.slider.slider_TRACK_CENTER;
import assets.slider.slider_TRACK_LEFT;
import assets.slider.slider_TRACK_RIGHT;
import flash.display.Graphics;
import flash.display.Sprite;
import flash.geom.Matrix;
public class SliderTrack extends Sprite
{
protected var track_bmpLeft:slider_TRACK_LEFT;
protected var track_bmpCenter:slider_TRACK_CENTER;
protected var track_bmpRight:slider_TRACK_RIGHT;
protected var _width:int;
protected var _showTrack:Boolean;
protected var _minValue:Number = 0;
protected var _maxValue:Number = 100;
protected var _tick:Number = 10;
public function SliderTrack(showtrack:Boolean = true)
{
this.track_bmpLeft = new slider_TRACK_LEFT(1,1);
this.track_bmpCenter = new slider_TRACK_CENTER(1,1);
this.track_bmpRight = new slider_TRACK_RIGHT(1,1);
super();
this._showTrack = showtrack;
}
override public function set width(w:Number) : void
{
this._width = w;
this.draw();
}
protected function draw() : void
{
var matrix:Matrix = null;
var tickDelta:Number = NaN;
var curTickX:Number = NaN;
var g:Graphics = this.graphics;
g.clear();
g.beginBitmapFill(this.track_bmpLeft);
g.drawRect(0,0,5,30);
g.endFill();
matrix = new Matrix();
matrix.translate(5,0);
g.beginBitmapFill(this.track_bmpCenter,matrix);
g.drawRect(5,0,this._width - 11,30);
g.endFill();
matrix = new Matrix();
matrix.translate(this._width - 6,0);
g.beginBitmapFill(this.track_bmpRight,matrix);
g.drawRect(this._width - 6,0,6,30);
g.endFill();
if(this._showTrack)
{
tickDelta = width / ((this._maxValue - this._minValue) / this._tick);
curTickX = tickDelta;
while(curTickX < this._width)
{
g.lineStyle(0,16777215,0.4);
g.moveTo(curTickX,5);
g.lineTo(curTickX,25);
curTickX += tickDelta;
}
}
}
public function set minValue(minValue:Number) : void
{
this._minValue = minValue;
this.draw();
}
public function set maxValue(maxValue:Number) : void
{
this._maxValue = maxValue;
this.draw();
}
public function set tickInterval(tick:Number) : void
{
this._tick = tick;
this.draw();
}
}
}
|
package assets.slider {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.slider.slider_THUMB_LEFT.png")]
public dynamic class slider_THUMB_LEFT extends BitmapData {
public function slider_THUMB_LEFT(param1:int = 10, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeParam extends DaeElement {
public function DaeParam(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get ref() : String {
var local1:XML = data.@ref[0];
return local1 == null ? null : local1.toString();
}
public function getFloat() : Number {
var local1:XML = data.float[0];
if(local1 != null) {
return parseNumber(local1);
}
return NaN;
}
public function getFloat4() : Array {
var local2:Array = null;
var local1:XML = data.float4[0];
if(local1 == null) {
local1 = data.float3[0];
if(local1 != null) {
local2 = parseNumbersArray(local1);
local2[3] = 1;
}
} else {
local2 = parseNumbersArray(local1);
}
return local2;
}
public function get surfaceSID() : String {
var local1:XML = data.sampler2D.source[0];
return local1 == null ? null : local1.text().toString();
}
public function get wrap_s() : String {
var local1:XML = data.sampler2D.wrap_s[0];
return local1 == null ? null : local1.text().toString();
}
public function get image() : DaeImage {
var local2:DaeImage = null;
var local3:XML = null;
var local4:XML = null;
var local1:XML = data.surface[0];
if(local1 != null) {
local3 = local1.init_from[0];
if(local3 == null) {
return null;
}
local2 = document.findImageByID(local3.text().toString());
} else {
local4 = data.instance_image.@url[0];
if(local4 == null) {
return null;
}
local2 = document.findImage(local4);
}
return local2;
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_wikiIconMakeUp.png")]
public class MakeUp_wikiIconMakeUp extends BitmapAsset {
public function MakeUp_wikiIconMakeUp() {
super();
}
}
}
|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload12 extends BitmapAsset
{
public function GTanksI_coldload12()
{
super();
}
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.objects.Mesh;
import flash.geom.Vector3D;
use namespace alternativa3d;
public class Shadow {
public var mapSize:int;
public var blur:int;
public var attenuation:Number;
public var nearDistance:Number;
public var farDistance:Number;
public var color:int;
public var alpha:Number;
public var direction:Vector3D = new Vector3D(0,0,-1);
public var offset:Number = 0;
public var backFadeRange:Number = 0;
private var casters:Vector.<Mesh> = new Vector.<Mesh>();
private var castersCount:int = 0;
public function Shadow(param1:int, param2:int, param3:Number, param4:Number, param5:Number, param6:int = 0, param7:Number = 1) {
super();
this.mapSize = param1;
this.blur = param2;
this.attenuation = param3;
this.nearDistance = param4;
this.farDistance = param5;
this.color = param6;
this.alpha = param7;
}
public function addCaster(param1:Mesh) : void {
this.casters[this.castersCount] = param1;
++this.castersCount;
}
public function removeCaster(param1:Mesh) : void {
var local2:int = 0;
while(local2 < this.castersCount) {
if(this.casters[local2] == param1) {
--this.castersCount;
while(local2 < this.castersCount) {
this.casters[local2] = this.casters[int(local2 + 1)];
local2++;
}
this.casters.length = this.castersCount;
break;
}
local2++;
}
}
public function removeAllCasters() : void {
this.castersCount = 0;
this.casters.length = 0;
}
}
}
|
package controls.buttons.h30px {
import controls.buttons.FixedHeightRectangleSkin;
public class GrayFrameMediumLabelSkin extends H30ButtonSkin {
public static const left:Class = GrayFrameMediumLabelSkin_left;
public static const middle:Class = GrayFrameMediumLabelSkin_middle;
public static const right:Class = GrayFrameMediumLabelSkin_right;
public function GrayFrameMediumLabelSkin() {
super(createStateSkin(left,middle,right),createStateSkin(left,middle,right),createStateSkin(left,middle,right));
}
private static function createStateSkin(param1:Class, param2:Class, param3:Class) : FixedHeightRectangleSkin {
return new FixedHeightRectangleSkin(param1,param2,param3);
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
public class LandingState
{
public const position:Vector3 = new Vector3();
public const orientation:Quaternion = new Quaternion();
public function LandingState()
{
super();
}
public function interpolate(a:LandingState, b:LandingState, t:Number) : void
{
this.position.interpolate(t,a.position,b.position);
this.orientation.slerp(a.orientation,b.orientation,t);
}
public function copy(src:LandingState) : void
{
this.position.vCopy(src.position);
this.orientation.copy(src.orientation);
}
}
}
|
package platform.client.core.general.resourcelocale.format {
import flash.utils.ByteArray;
public class ImagePair {
private var _key:String;
private var _value:ByteArray;
public function ImagePair(param1:String = null, param2:ByteArray = null) {
super();
this._key = param1;
this._value = param2;
}
public function get key() : String {
return this._key;
}
public function set key(param1:String) : void {
this._key = param1;
}
public function get value() : ByteArray {
return this._value;
}
public function set value(param1:ByteArray) : void {
this._value = param1;
}
public function toString() : String {
var local1:String = "ImagePair [";
local1 += "key = " + this.key + " ";
local1 += "value = " + this.value + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.sfx.healing
{
import alternativa.console.ConsoleVarFloat;
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
import alternativa.init.Main;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.models.sfx.LightDataManager;
import alternativa.tanks.models.sfx.MuzzlePositionProvider;
import alternativa.tanks.models.sfx.OmniStreamLightEffect;
import alternativa.tanks.models.sfx.TubeLightEffect;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.healing.IsisActionType;
use namespace alternativa3d;
public class HealingGunGraphicEffect implements IGraphicEffect
{
private static var endPositionOffset:ConsoleVarFloat = new ConsoleVarFloat("izida_end_offset",150,0,500);
private static var turretMatrix:Matrix4 = new Matrix4();
private static var targetMatrix:Matrix4 = new Matrix4();
private static var endPosition:Vector3 = new Vector3();
private static var startPosition:Vector3 = new Vector3();
private static var direction:Vector3 = new Vector3();
private static var cameraPosition:Vector3 = new Vector3();
private static var objectPoolService:IObjectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
private var bfModel:BattlefieldModel;
private var container:Scene3DContainer;
private var shaftPlane:Shaft;
private var spark:AnimatedSprite3D;
private var shaftEnd:AnimatedSprite3D;
private var turret:Object3D;
private var localSourcePosition:Vector3;
private var targetObject:Object3D;
private var localTargetPosition:Vector3;
private var dead:Boolean;
private var currentFrame:int;
private var frameRate:Number = 0.015;
private var time:int;
private var _mode:IsisActionType;
private var sfxData:HealingGunSFXData;
private var sparkMaterials:TextureAnimation;
private var shaftMaterials:Vector.<Material>;
private var shaftEndMaterials:Vector.<Material>;
private var shaftEndFrame:int;
private var listener:IHealingGunEffectListener;
private var lightEffect:OmniStreamLightEffect;
private var beamEffect:TubeLightEffect;
private var stateLightEffectCreatedFor:IsisActionType;
private var targetTankData:TankData;
public function HealingGunGraphicEffect(listener:IHealingGunEffectListener)
{
this.bfModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
this.localSourcePosition = new Vector3();
this.localTargetPosition = new Vector3();
super();
this.listener = listener;
this.shaftPlane = new Shaft();
this.shaftPlane.init(100,100);
this.spark = new AnimatedSprite3D(120,120);
this.shaftEnd = new AnimatedSprite3D(200,200);
this.spark.softAttenuation = 0;
this.shaftEnd.softAttenuation = 0;
this.shaftEnd.originY = 0.65;
}
public function createGraphics() : void
{
if(this.shaftPlane == null)
{
this.shaftPlane = new Shaft();
this.shaftPlane.init(100,100);
}
if(this.spark == null)
{
this.spark = new AnimatedSprite3D(120,120);
this.spark.softAttenuation = 0;
}
if(this.shaftEnd == null)
{
this.shaftEnd = new AnimatedSprite3D(200,200);
this.shaftEnd.softAttenuation = 0;
this.shaftEnd.originY = 0.65;
}
}
public function init(mode:IsisActionType, sfxData:HealingGunSFXData, turret:Object3D, localSourcePosition:Vector3, targetData:TankData) : void
{
this.sfxData = sfxData;
this.turret = turret;
this._mode = mode;
this.targetTankData = targetData;
this.localSourcePosition.vCopy(localSourcePosition);
this.dead = false;
this.currentFrame = 0;
this.time = 0;
this.updateMode();
this.createLightEffect(mode,targetData);
}
private function createLightEffect(param1:IsisActionType, targetData:TankData) : void
{
if(this.lightEffect != null)
{
this.stopLightEffect();
}
this.lightEffect = OmniStreamLightEffect(objectPoolService.objectPool.getObject(OmniStreamLightEffect));
var _loc2_:MuzzlePositionProvider = MuzzlePositionProvider(objectPoolService.objectPool.getObject(MuzzlePositionProvider));
_loc2_.init(this.turret,this.localSourcePosition);
switch(param1)
{
case IsisActionType.DAMAGE:
this.lightEffect.init(_loc2_,LightDataManager.getLightData(targetData.turret.id,"enemy_start"),LightDataManager.getLightData(targetData.turret.id,"enemy_loop"));
break;
case IsisActionType.HEAL:
this.lightEffect.init(_loc2_,LightDataManager.getLightData(targetData.turret.id,"friendly_start"),LightDataManager.getLightData(targetData.turret.id,"friendly_loop"));
break;
default:
this.lightEffect.init(_loc2_,LightDataManager.getLightData(targetData.turret.id,"idle_start"),LightDataManager.getLightData(targetData.turret.id,"idle_loop"));
}
this.stateLightEffectCreatedFor = param1;
this.bfModel.addGraphicEffect(this.lightEffect);
}
public function set mode(value:IsisActionType) : void
{
if(this._mode == value)
{
return;
}
this._mode = value;
this.updateMode();
}
public function setTargetParams(targetObject:Object3D, localTargetPosition:Vector3, targetTankData:TankData, mode:IsisActionType, showBeamLight:Boolean) : void
{
this.targetObject = targetObject;
this.localTargetPosition.vCopy(localTargetPosition);
this.createLightEffect(mode,targetTankData);
if(showBeamLight)
{
this.createBeamLight(mode,targetTankData,localTargetPosition);
}
}
public function get owner() : ClientObject
{
return null;
}
public function play(millis:int, camera:GameCamera) : Boolean
{
var len:int = 0;
if(this.dead)
{
return false;
}
this.createGraphics();
this.time += millis;
turretMatrix.setMatrix(this.turret.x,this.turret.y,this.turret.z,this.turret.rotationX,this.turret.rotationY,this.turret.rotationZ);
turretMatrix.transformVector(this.localSourcePosition,startPosition);
this.spark.x = startPosition.x;
this.spark.y = startPosition.y;
this.spark.z = startPosition.z;
var frame:int = int(this.time * this.frameRate);
if(frame > this.currentFrame)
{
this.currentFrame = frame;
this.spark.setFrameIndex(frame);
if(this._mode == IsisActionType.DAMAGE || this._mode == IsisActionType.HEAL)
{
len = this.shaftEndMaterials.length;
this.shaftEndFrame = (this.shaftEndFrame + 1) % len;
if(this._mode == IsisActionType.HEAL)
{
this.shaftEnd.setFrameIndex(this.shaftEndFrame);
}
else
{
this.shaftEnd.setFrameIndex(int(len - this.shaftEndFrame - 1));
}
}
}
if(this._mode == IsisActionType.DAMAGE || this._mode == IsisActionType.HEAL)
{
this.updateShaft(camera);
}
return true;
}
public function addToContainer(container:Scene3DContainer) : void
{
this.container = container;
this.updateMode();
}
public function destroy() : void
{
if(this.shaftPlane != null)
{
this.shaftPlane.removeFromParent();
}
if(this.shaftEnd != null)
{
this.shaftEnd.removeFromParent();
}
if(this.spark != null)
{
this.spark.removeFromParent();
}
this.container = null;
this.shaftPlane.setMaterialToAllFaces(null);
this.lightEffect.stop();
if(this.beamEffect != null)
{
this.beamEffect.kill();
}
this.lightEffect = null;
this.beamEffect = null;
this.sfxData = null;
this.sparkMaterials = null;
this.shaftMaterials = this.shaftEndMaterials = null;
this.turret = this.targetObject = null;
this.listener.onEffectDestroyed(this);
}
public function kill() : void
{
this.dead = true;
}
private function updateShaft(camera:GameCamera) : void
{
this.shaftPlane.setMaterialToAllFaces(this.getRandomFrame(this.shaftMaterials));
targetMatrix.setMatrix(this.targetObject.x,this.targetObject.y,this.targetObject.z,this.targetObject.rotationX,this.targetObject.rotationY,this.targetObject.rotationZ);
targetMatrix.transformVector(this.localTargetPosition,endPosition);
direction.vDiff(endPosition,startPosition);
var beamLength:Number = direction.vLength() - endPositionOffset.value;
if(beamLength < 0)
{
beamLength = 10;
}
this.shaftPlane.length = beamLength;
direction.vNormalize();
endPosition.x = startPosition.x + beamLength * direction.x;
endPosition.y = startPosition.y + beamLength * direction.y;
endPosition.z = startPosition.z + beamLength * direction.z;
this.shaftEnd.x = endPosition.x;
this.shaftEnd.y = endPosition.y;
this.shaftEnd.z = endPosition.z;
cameraPosition.x = camera.x;
cameraPosition.y = camera.y;
cameraPosition.z = camera.z;
SFXUtils.alignObjectPlaneToView(this.shaftPlane,startPosition,direction,cameraPosition);
}
private function createBeamLight(param1:IsisActionType, param2:TankData, param3:Vector3) : void
{
if(this.beamEffect != null)
{
this.beamEffect.kill();
this.beamEffect = null;
}
if(param1 == IsisActionType.IDLE)
{
return;
}
var _loc4_:MuzzlePositionProvider = MuzzlePositionProvider(objectPoolService.objectPool.getObject(MuzzlePositionProvider));
var _loc5_:MuzzlePositionProvider = MuzzlePositionProvider(objectPoolService.objectPool.getObject(MuzzlePositionProvider));
_loc4_.init(this.turret,this.localSourcePosition);
_loc5_.init(this.targetObject,this.localTargetPosition);
this.beamEffect = TubeLightEffect(objectPoolService.objectPool.getObject(TubeLightEffect));
switch(param1)
{
case IsisActionType.DAMAGE:
this.beamEffect.init(_loc4_,_loc5_,LightDataManager.getLightData(param2.turret.id,"enemy_beam"),true);
break;
case IsisActionType.HEAL:
this.beamEffect.init(_loc4_,_loc5_,LightDataManager.getLightData(param2.turret.id,"friendly_beam"),true);
}
this.bfModel.addGraphicEffect(this.beamEffect);
}
private function stopLightEffect() : void
{
this.lightEffect.stop();
this.lightEffect = null;
}
private function updateMode() : void
{
if(this.container == null)
{
return;
}
switch(this._mode)
{
case IsisActionType.IDLE:
this.setIdleMode();
break;
case IsisActionType.HEAL:
this.setHealMode();
break;
case IsisActionType.DAMAGE:
this.setDamageMode();
}
}
private function setIdleMode() : void
{
this.createGraphics();
this.shaftPlane.removeFromParent();
this.shaftEnd.removeFromParent();
if(this.spark.parent == null)
{
this.container.addChild(this.spark);
}
this.sparkMaterials = this.sfxData.idleSparkData;
this.spark.setAnimationData(this.sfxData.idleSparkData);
this.spark.setFrameIndex(0);
}
private function setHealMode() : void
{
this.createGraphics();
if(this.shaftPlane.parent == null)
{
this.container.addChild(this.shaftPlane);
this.container.addChild(this.shaftEnd);
this.shaftMaterials = this.sfxData.healShaftMaterials;
this.shaftPlane.material = this.shaftMaterials[0];
this.shaftEndMaterials = this.sfxData.healShaftEndMaterials;
this.shaftEnd.setAnimationData(this.sfxData.healShaftEndData);
this.shaftEnd.setFrameIndex(0);
}
if(this.spark.parent == null)
{
this.container.addChild(this.spark);
}
this.sparkMaterials = this.sfxData.healSparkData;
this.spark.setAnimationData(this.sfxData.healSparkData);
this.spark.setFrameIndex(0);
}
private function setDamageMode() : void
{
this.createGraphics();
if(this.shaftPlane.parent == null)
{
this.container.addChild(this.shaftPlane);
this.container.addChild(this.shaftEnd);
this.shaftMaterials = this.sfxData.damageShaftMaterials;
this.shaftPlane.material = this.shaftMaterials[0];
this.shaftEndMaterials = this.sfxData.damageShaftEndMaterials;
this.shaftEnd.setAnimationData(this.sfxData.damageShaftEndData);
this.shaftEnd.setFrameIndex(0);
}
if(this.spark.parent == null)
{
this.container.addChild(this.spark);
}
this.sparkMaterials = this.sfxData.damageSparkData;
this.spark.setAnimationData(this.sfxData.damageSparkData);
this.spark.setFrameIndex(0);
}
private function getRandomFrame(materials:Vector.<Material>) : Material
{
return materials[int(Math.random() * materials.length)];
}
}
}
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
use namespace alternativa3d;
class Shaft extends Mesh
{
private var a:Vertex;
private var b:Vertex;
private var c:Vertex;
private var d:Vertex;
private var face:Face;
function Shaft()
{
super();
this.a = this.createVertex(-1,0,0,0,1);
this.b = this.createVertex(1,0,0,1,1);
this.c = this.createVertex(1,1,0,1,0);
this.d = this.createVertex(-1,1,0,0,0);
this.face = this.createQuad(this.a,this.b,this.c,this.d);
calculateFacesNormals();
sorting = Sorting.DYNAMIC_BSP;
shadowMapAlphaThreshold = 2;
depthMapAlphaThreshold = 2;
useShadowMap = false;
useLight = false;
}
public function set material(value:Material) : void
{
this.face.material = value;
}
public function init(width:Number, length:Number) : void
{
var hw:Number = width / 2;
boundMinX = this.a.x = this.d.x = -hw;
boundMaxX = this.b.x = this.c.x = hw;
boundMinY = 0;
boundMaxY = this.d.y = this.c.y = length;
this.a.v = this.b.v = 1;
boundMinZ = boundMaxZ = 0;
}
public function get length() : Number
{
return this.d.y;
}
public function set length(value:Number) : void
{
if(value < 10)
{
value = 10;
}
boundMaxY = this.d.y = this.c.y = value;
}
private function createVertex(x:Number, y:Number, z:Number, u:Number, v:Number) : Vertex
{
var newVertex:Vertex = new Vertex();
newVertex.next = vertexList;
vertexList = newVertex;
newVertex.x = x;
newVertex.y = y;
newVertex.z = z;
newVertex.u = u;
newVertex.v = v;
return newVertex;
}
private function createQuad(a:Vertex, b:Vertex, c:Vertex, d:Vertex) : Face
{
var newFace:Face = new Face();
newFace.next = faceList;
faceList = newFace;
newFace.wrapper = new Wrapper();
newFace.wrapper.vertex = a;
newFace.wrapper.next = new Wrapper();
newFace.wrapper.next.vertex = b;
newFace.wrapper.next.next = new Wrapper();
newFace.wrapper.next.next.vertex = c;
newFace.wrapper.next.next.next = new Wrapper();
newFace.wrapper.next.next.next.vertex = d;
return newFace;
}
override public function destroy() : void
{
var buf:Vertex = null;
var buf1:Face = null;
this.a = null;
this.b = null;
this.c = null;
this.d = null;
this.face.destroy();
this.face = null;
if(vertexList != null)
{
while(vertexList.next != null)
{
buf = vertexList;
vertexList = null;
vertexList = buf.next;
}
vertexList = null;
}
if(faceList != null)
{
while(faceList.next != null)
{
buf1 = faceList;
faceList.wrapper.vertex = null;
faceList.wrapper = null;
faceList = null;
faceList = buf1.next;
}
faceList = null;
}
captureListeners = null;
bubbleListeners = null;
}
}
|
package alternativa.tanks.display.usertitle
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ProgressBarSkin_weaponRightBgCls extends BitmapAsset
{
public function ProgressBarSkin_weaponRightBgCls()
{
super();
}
}
}
|
package alternativa.tanks.models.bonus.notification {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.type.IGameObject;
public class BonusNotificationEvents implements BonusNotification {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BonusNotificationEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getMessage() : String {
var result:String = null;
var i:int = 0;
var m:BonusNotification = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BonusNotification(this.impl[i]);
result = m.getMessage();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getMessageContainsUid() : String {
var result:String = null;
var i:int = 0;
var m:BonusNotification = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BonusNotification(this.impl[i]);
result = m.getMessageContainsUid();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getSoundNotification() : SoundResource {
var result:SoundResource = null;
var i:int = 0;
var m:BonusNotification = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BonusNotification(this.impl[i]);
result = m.getSoundNotification();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_shellstabilizationIconClass.png")]
public class DeviceIcons_shellstabilizationIconClass extends BitmapAsset {
public function DeviceIcons_shellstabilizationIconClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft
{
public class LinearInterpolator
{
private var a:Number;
private var b:Number;
public function LinearInterpolator(param1:Number = 0, param2:Number = 1)
{
super();
this.a = param1;
this.b = param2;
}
public function setInterval(param1:Number, param2:Number) : void
{
this.a = param1;
this.b = param2;
}
public function interpolate(param1:Number) : Number
{
return this.a + (this.b - this.a) * param1;
}
}
}
|
package alternativa.console
{
import alternativa.init.Main;
public class ConsoleVar
{
protected var varName:String;
protected var inputListener:Function;
public function ConsoleVar(varName:String, inputListener:Function = null)
{
super();
this.varName = varName;
this.inputListener = inputListener;
var console:IConsole = IConsole(Main.osgi.getService(IConsole));
if(console != null)
{
console.addVariable(this);
}
}
public function getName() : String
{
return this.varName;
}
public function destroy() : void
{
var console:IConsole = IConsole(Main.osgi.getService(IConsole));
if(console != null)
{
console.removeVariable(this.varName);
}
this.inputListener = null;
}
public function processConsoleInput(console:IConsole, params:Array) : void
{
var oldValue:String = null;
var errorText:String = null;
if(params.length == 0)
{
console.addLine(this.varName + " = " + this.toString());
}
else
{
oldValue = this.toString();
errorText = this.acceptInput(params[0]);
if(errorText == null)
{
console.addLine(this.varName + " is set to " + this.toString() + " (was " + oldValue + ")");
if(this.inputListener != null)
{
this.inputListener.call(null,this);
}
}
else
{
console.addLine(errorText);
}
}
}
protected function acceptInput(value:String) : String
{
return "Not implemented";
}
public function toString() : String
{
return "Not implemented";
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_surviveMinesClass.png")]
public class ItemInfoPanelBitmaps_surviveMinesClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_surviveMinesClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
internal class ServerShotData {
public var staticHitPoint:Vector3d;
public var hitPoint:Vector3d;
public var tank:IGameObject;
public var incarnation:int;
public var tankPosition:Vector3d;
public var targetPositionGlobal:Vector3d;
public function ServerShotData(param1:Vector3d, param2:Vector3d, param3:IGameObject, param4:int, param5:Vector3d, param6:Vector3d) {
super();
this.staticHitPoint = param1;
this.hitPoint = param2;
this.tank = param3;
this.incarnation = param4;
this.tankPosition = param5;
this.targetPositionGlobal = param6;
}
}
}
|
package alternativa.tanks.gui.friends.button.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.button.friends.NewRequestIndicator_attentionIconClass.png")]
public class NewRequestIndicator_attentionIconClass extends BitmapAsset {
public function NewRequestIndicator_attentionIconClass() {
super();
}
}
}
|
package alternativa.engine3d.loaders
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.FillMaterial;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import flash.geom.Matrix;
import flash.geom.Vector3D;
import flash.utils.ByteArray;
import flash.utils.Endian;
use namespace alternativa3d;
public class Parser3DS
{
private static const CHUNK_MAIN:int = 19789;
private static const CHUNK_VERSION:int = 2;
private static const CHUNK_SCENE:int = 15677;
private static const CHUNK_ANIMATION:int = 45056;
private static const CHUNK_OBJECT:int = 16384;
private static const CHUNK_TRIMESH:int = 16640;
private static const CHUNK_VERTICES:int = 16656;
private static const CHUNK_FACES:int = 16672;
private static const CHUNK_FACESMATERIAL:int = 16688;
private static const CHUNK_MAPPINGCOORDS:int = 16704;
private static const CHUNK_TRANSFORMATION:int = 16736;
private static const CHUNK_MATERIAL:int = 45055;
private var data:ByteArray;
private var objectDatas:Object;
private var animationDatas:Array;
private var materialDatas:Object;
public var objects:Vector.<Object3D>;
public var parents:Vector.<Object3D>;
public var materials:Vector.<Material>;
public var textureMaterials:Vector.<TextureMaterial>;
public function Parser3DS()
{
super();
}
public function parse(data:ByteArray, texturesBaseURL:String = "", scale:Number = 1) : void
{
if(data.bytesAvailable < 6)
{
return;
}
this.data = data;
data.endian = Endian.LITTLE_ENDIAN;
this.parse3DSChunk(data.position,data.bytesAvailable);
this.objects = new Vector.<Object3D>();
this.parents = new Vector.<Object3D>();
this.materials = new Vector.<Material>();
this.textureMaterials = new Vector.<TextureMaterial>();
this.buildContent(texturesBaseURL,scale);
data = null;
this.objectDatas = null;
this.animationDatas = null;
this.materialDatas = null;
}
private function readChunkInfo(dataPosition:int) : ChunkInfo
{
this.data.position = dataPosition;
var chunkInfo:ChunkInfo = new ChunkInfo();
chunkInfo.id = this.data.readUnsignedShort();
chunkInfo.size = this.data.readUnsignedInt();
chunkInfo.dataSize = chunkInfo.size - 6;
chunkInfo.dataPosition = this.data.position;
chunkInfo.nextChunkPosition = dataPosition + chunkInfo.size;
return chunkInfo;
}
private function parse3DSChunk(dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
this.data.position = dataPosition;
switch(chunkInfo.id)
{
case CHUNK_MAIN:
this.parseMainChunk(chunkInfo.dataPosition,chunkInfo.dataSize);
}
this.parse3DSChunk(chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parseMainChunk(dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case CHUNK_VERSION:
break;
case CHUNK_SCENE:
this.parse3DChunk(chunkInfo.dataPosition,chunkInfo.dataSize);
break;
case CHUNK_ANIMATION:
this.parseAnimationChunk(chunkInfo.dataPosition,chunkInfo.dataSize);
}
this.parseMainChunk(chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parse3DChunk(dataPosition:int, bytesAvailable:int) : void
{
var chunkInfo:ChunkInfo = null;
var material:MaterialData = null;
while(bytesAvailable >= 6)
{
chunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case CHUNK_MATERIAL:
material = new MaterialData();
this.parseMaterialChunk(material,chunkInfo.dataPosition,chunkInfo.dataSize);
break;
case CHUNK_OBJECT:
this.parseObject(chunkInfo);
break;
}
dataPosition = chunkInfo.nextChunkPosition;
bytesAvailable -= chunkInfo.size;
}
}
private function parseObject(chunkInfo:ChunkInfo) : void
{
if(this.objectDatas == null)
{
this.objectDatas = new Object();
}
var object:ObjectData = new ObjectData();
object.name = this.getString(chunkInfo.dataPosition);
this.objectDatas[object.name] = object;
var offset:int = object.name.length + 1;
this.parseObjectChunk(object,chunkInfo.dataPosition + offset,chunkInfo.dataSize - offset);
}
private function parseObjectChunk(object:ObjectData, dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case CHUNK_TRIMESH:
this.parseMeshChunk(object,chunkInfo.dataPosition,chunkInfo.dataSize);
break;
case 17920:
break;
case 18176:
}
this.parseObjectChunk(object,chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parseMeshChunk(object:ObjectData, dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case CHUNK_VERTICES:
this.parseVertices(object);
break;
case CHUNK_MAPPINGCOORDS:
this.parseUVs(object);
break;
case CHUNK_TRANSFORMATION:
this.parseMatrix(object);
break;
case CHUNK_FACES:
this.parseFaces(object,chunkInfo);
}
this.parseMeshChunk(object,chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parseVertices(object:ObjectData) : void
{
var num:int = this.data.readUnsignedShort();
object.vertices = new Vector.<Number>();
var j:int = 0;
for (var i:int = 0; i < num; i++)
{
var _loc5_:* = j++;
object.vertices[_loc5_] = this.data.readFloat();
var _loc6_:* = j++;
object.vertices[_loc6_] = this.data.readFloat();
var _loc7_:* = j++;
object.vertices[_loc7_] = this.data.readFloat();
}
}
private function parseUVs(object:ObjectData) : void
{
var num:int = this.data.readUnsignedShort();
object.uvs = new Vector.<Number>();
var j:int = 0;
for (var i:int = 0; i < num; i++)
{
var _loc5_:* = j++;
object.uvs[_loc5_] = this.data.readFloat();
var _loc6_:* = j++;
object.uvs[_loc6_] = this.data.readFloat();
}
}
private function parseMatrix(object:ObjectData) : void
{
object.a = this.data.readFloat();
object.e = this.data.readFloat();
object.i = this.data.readFloat();
object.b = this.data.readFloat();
object.f = this.data.readFloat();
object.j = this.data.readFloat();
object.c = this.data.readFloat();
object.g = this.data.readFloat();
object.k = this.data.readFloat();
object.d = this.data.readFloat();
object.h = this.data.readFloat();
object.l = this.data.readFloat();
}
private function parseFaces(object:ObjectData, chunkInfo:ChunkInfo) : void
{
var num:int = this.data.readUnsignedShort();
object.faces = new Vector.<int>();
var j:int = 0;
for (var i:int = 0; i < num; i++)
{
var _loc7_:* = j++;
object.faces[_loc7_] = this.data.readUnsignedShort();
var _loc8_:* = j++;
object.faces[_loc8_] = this.data.readUnsignedShort();
var _loc9_:* = j++;
object.faces[_loc9_] = this.data.readUnsignedShort();
this.data.position += 2;
}
var offset:int = 2 + 8 * num;
this.parseFacesChunk(object,chunkInfo.dataPosition + offset,chunkInfo.dataSize - offset);
}
private function parseFacesChunk(object:ObjectData, dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case CHUNK_FACESMATERIAL:
this.parseSurface(object);
}
this.parseFacesChunk(object,chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parseSurface(object:ObjectData) : void
{
if(object.surfaces == null)
{
object.surfaces = new Object();
}
var surface:Vector.<int> = new Vector.<int>();
object.surfaces[this.getString(this.data.position)] = surface;
var num:int = this.data.readUnsignedShort();
for(var i:int = 0; i < num; i++)
{
surface[i] = this.data.readUnsignedShort();
}
}
private function parseAnimationChunk(dataPosition:int, bytesAvailable:int) : void
{
var chunkInfo:ChunkInfo = null;
var animation:AnimationData = null;
while(bytesAvailable >= 6)
{
chunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case 45057:
case 45058:
case 45059:
case 45060:
case 45061:
case 45062:
case 45063:
if(this.animationDatas == null)
{
this.animationDatas = new Array();
}
animation = new AnimationData();
this.animationDatas.push(animation);
this.parseObjectAnimationChunk(animation,chunkInfo.dataPosition,chunkInfo.dataSize);
break;
case 45064:
break;
}
dataPosition = chunkInfo.nextChunkPosition;
bytesAvailable -= chunkInfo.size;
}
}
private function parseObjectAnimationChunk(animation:AnimationData, dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case 45072:
animation.objectName = this.getString(this.data.position);
this.data.position += 4;
animation.parentIndex = this.data.readUnsignedShort();
break;
case 45073:
animation.objectName = this.getString(this.data.position);
break;
case 45075:
animation.pivot = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45088:
this.data.position += 20;
animation.position = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45089:
this.data.position += 20;
animation.rotation = this.getRotationFrom3DSAngleAxis(this.data.readFloat(),this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45090:
this.data.position += 20;
animation.scale = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
}
this.parseObjectAnimationChunk(animation,chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parseMaterialChunk(material:MaterialData, dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case 40960:
this.parseMaterialName(material);
break;
case 40976:
break;
case 40992:
this.data.position = chunkInfo.dataPosition + 6;
material.color = (this.data.readUnsignedByte() << 16) + (this.data.readUnsignedByte() << 8) + this.data.readUnsignedByte();
break;
case 41008:
break;
case 41024:
this.data.position = chunkInfo.dataPosition + 6;
material.glossiness = this.data.readUnsignedShort();
break;
case 41025:
this.data.position = chunkInfo.dataPosition + 6;
material.specular = this.data.readUnsignedShort();
break;
case 41040:
this.data.position = chunkInfo.dataPosition + 6;
material.transparency = this.data.readUnsignedShort();
break;
case 41472:
material.diffuseMap = new MapData();
this.parseMapChunk(material.name,material.diffuseMap,chunkInfo.dataPosition,chunkInfo.dataSize);
break;
case 41786:
break;
case 41488:
material.opacityMap = new MapData();
this.parseMapChunk(material.name,material.opacityMap,chunkInfo.dataPosition,chunkInfo.dataSize);
break;
case 41520:
break;
case 41788:
break;
case 41476:
break;
case 41789:
break;
case 41504:
}
this.parseMaterialChunk(material,chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function parseMaterialName(material:MaterialData) : void
{
if(this.materialDatas == null)
{
this.materialDatas = new Object();
}
material.name = this.getString(this.data.position);
this.materialDatas[material.name] = material;
}
private function parseMapChunk(materialName:String, map:MapData, dataPosition:int, bytesAvailable:int) : void
{
if(bytesAvailable < 6)
{
return;
}
var chunkInfo:ChunkInfo = this.readChunkInfo(dataPosition);
switch(chunkInfo.id)
{
case 41728:
map.filename = this.getString(chunkInfo.dataPosition).toLowerCase();
break;
case 41809:
break;
case 41812:
map.scaleU = this.data.readFloat();
break;
case 41814:
map.scaleV = this.data.readFloat();
break;
case 41816:
map.offsetU = this.data.readFloat();
break;
case 41818:
map.offsetV = this.data.readFloat();
break;
case 41820:
map.rotation = this.data.readFloat();
}
this.parseMapChunk(materialName,map,chunkInfo.nextChunkPosition,bytesAvailable - chunkInfo.size);
}
private function buildContent(texturesBaseURL:String, scale:Number) : void
{
var materialName:* = null;
var objectName:* = null;
var objectData:ObjectData = null;
var object:Object3D = null;
var materialData:MaterialData = null;
var mapData:MapData = null;
var materialMatrix:Matrix = null;
var rot:Number = NaN;
var textureMaterial:TextureMaterial = null;
var fillMaterial:FillMaterial = null;
var i:int = 0;
var length:int = 0;
var animationData:AnimationData = null;
var j:int = 0;
var nameCounter:int = 0;
var animationData2:AnimationData = null;
var newObjectData:ObjectData = null;
var newName:String = null;
for(materialName in this.materialDatas)
{
materialData = this.materialDatas[materialName];
mapData = materialData.diffuseMap;
if(mapData != null)
{
materialMatrix = new Matrix();
rot = mapData.rotation * Math.PI / 180;
materialMatrix.translate(-mapData.offsetU,mapData.offsetV);
materialMatrix.translate(-0.5,-0.5);
materialMatrix.rotate(-rot);
materialMatrix.scale(mapData.scaleU,mapData.scaleV);
materialMatrix.translate(0.5,0.5);
materialData.matrix = materialMatrix;
textureMaterial = new TextureMaterial();
textureMaterial.name = materialName;
textureMaterial.diffuseMapURL = texturesBaseURL + mapData.filename;
textureMaterial.opacityMapURL = materialData.opacityMap != null ? texturesBaseURL + materialData.opacityMap.filename : null;
materialData.material = textureMaterial;
textureMaterial.name = materialData.name;
this.textureMaterials.push(textureMaterial);
}
else
{
fillMaterial = new FillMaterial(materialData.color);
materialData.material = fillMaterial;
fillMaterial.name = materialData.name;
}
this.materials.push(materialData.material);
}
if(this.animationDatas != null)
{
if(this.objectDatas != null)
{
length = this.animationDatas.length;
for(i = 0; i < length; i++)
{
animationData = this.animationDatas[i];
objectName = animationData.objectName;
objectData = this.objectDatas[objectName];
if(objectData != null)
{
for(j = i + 1,nameCounter = 1; j < length; j++)
{
animationData2 = this.animationDatas[j];
if(!animationData2.isInstance && objectName == animationData2.objectName)
{
newObjectData = new ObjectData();
newName = objectName + nameCounter++;
newObjectData.name = newName;
this.objectDatas[newName] = newObjectData;
animationData2.objectName = newName;
newObjectData.vertices = objectData.vertices;
newObjectData.uvs = objectData.uvs;
newObjectData.faces = objectData.faces;
newObjectData.surfaces = objectData.surfaces;
newObjectData.a = objectData.a;
newObjectData.b = objectData.b;
newObjectData.c = objectData.c;
newObjectData.d = objectData.d;
newObjectData.e = objectData.e;
newObjectData.f = objectData.f;
newObjectData.g = objectData.g;
newObjectData.h = objectData.h;
newObjectData.i = objectData.i;
newObjectData.j = objectData.j;
newObjectData.k = objectData.k;
newObjectData.l = objectData.l;
}
}
}
if(objectData != null && objectData.vertices != null)
{
object = new Mesh();
this.buildMesh(object as Mesh,objectData,animationData,scale);
}
else
{
object = new Object3D();
}
object.name = objectName;
animationData.object = object;
if(animationData.position != null)
{
object.x = animationData.position.x * scale;
object.y = animationData.position.y * scale;
object.z = animationData.position.z * scale;
}
if(animationData.rotation != null)
{
object.rotationX = animationData.rotation.x;
object.rotationY = animationData.rotation.y;
object.rotationZ = animationData.rotation.z;
}
if(animationData.scale != null)
{
object.scaleX = animationData.scale.x;
object.scaleY = animationData.scale.y;
object.scaleZ = animationData.scale.z;
}
}
for(i = 0; i < length; i++)
{
animationData = this.animationDatas[i];
this.objects.push(animationData.object);
this.parents.push(animationData.parentIndex == 65535 ? null : AnimationData(this.animationDatas[animationData.parentIndex]).object);
}
}
}
else
{
for(objectName in this.objectDatas)
{
objectData = this.objectDatas[objectName];
if(objectData.vertices != null)
{
object = new Mesh();
object.name = objectName;
this.buildMesh(object as Mesh,objectData,null,scale);
this.objects.push(object);
this.parents.push(null);
}
}
}
}
private function buildMesh(mesh:Mesh, objectData:ObjectData, animationData:AnimationData, scale:Number) : void
{
var n:int = 0;
var m:int = 0;
var face:Face = null;
var vertex:Vertex = null;
var last:Face = null;
var a:Number = NaN;
var b:Number = NaN;
var c:Number = NaN;
var d:Number = NaN;
var e:Number = NaN;
var f:Number = NaN;
var g:Number = NaN;
var h:Number = NaN;
var i:Number = NaN;
var j:Number = NaN;
var k:Number = NaN;
var l:Number = NaN;
var det:Number = NaN;
var x:Number = NaN;
var y:Number = NaN;
var z:Number = NaN;
var key:* = null;
var surface:Vector.<int> = null;
var materialData:MaterialData = null;
var material:Material = null;
var w:Wrapper = null;
var u:Number = NaN;
var v:Number = NaN;
var vertices:Vector.<Vertex> = new Vector.<Vertex>();
var faces:Vector.<Face> = new Vector.<Face>();
var numVertices:int = 0;
var numFaces:int = 0;
var correct:Boolean = false;
if(animationData != null)
{
a = objectData.a;
b = objectData.b;
c = objectData.c;
d = objectData.d;
e = objectData.e;
f = objectData.f;
g = objectData.g;
h = objectData.h;
i = objectData.i;
j = objectData.j;
k = objectData.k;
l = objectData.l;
det = 1 / (-c * f * i + b * g * i + c * e * j - a * g * j - b * e * k + a * f * k);
objectData.a = (-g * j + f * k) * det;
objectData.b = (c * j - b * k) * det;
objectData.c = (-c * f + b * g) * det;
objectData.d = (d * g * j - c * h * j - d * f * k + b * h * k + c * f * l - b * g * l) * det;
objectData.e = (g * i - e * k) * det;
objectData.f = (-c * i + a * k) * det;
objectData.g = (c * e - a * g) * det;
objectData.h = (c * h * i - d * g * i + d * e * k - a * h * k - c * e * l + a * g * l) * det;
objectData.i = (-f * i + e * j) * det;
objectData.j = (b * i - a * j) * det;
objectData.k = (-b * e + a * f) * det;
objectData.l = (d * f * i - b * h * i - d * e * j + a * h * j + b * e * l - a * f * l) * det;
if(animationData.pivot != null)
{
objectData.d -= animationData.pivot.x;
objectData.h -= animationData.pivot.y;
objectData.l -= animationData.pivot.z;
}
correct = true;
}
var uv:Boolean = objectData.uvs != null && objectData.uvs.length > 0;
for(n = 0,m = 0; n < objectData.vertices.length; )
{
vertex = new Vertex();
if(correct)
{
x = objectData.vertices[n++];
y = objectData.vertices[n++];
z = objectData.vertices[n++];
vertex.x = objectData.a * x + objectData.b * y + objectData.c * z + objectData.d;
vertex.y = objectData.e * x + objectData.f * y + objectData.g * z + objectData.h;
vertex.z = objectData.i * x + objectData.j * y + objectData.k * z + objectData.l;
}
else
{
vertex.x = objectData.vertices[n++];
vertex.y = objectData.vertices[n++];
vertex.z = objectData.vertices[n++];
}
vertex.x *= scale;
vertex.y *= scale;
vertex.z *= scale;
if(uv)
{
vertex.u = objectData.uvs[m++];
vertex.v = 1 - objectData.uvs[m++];
}
vertex.transformId = -1;
var _loc40_:* = numVertices++;
vertices[_loc40_] = vertex;
vertex.next = mesh.vertexList;
mesh.vertexList = vertex;
}
for(n = 0; n < objectData.faces.length; )
{
face = new Face();
face.wrapper = new Wrapper();
face.wrapper.next = new Wrapper();
face.wrapper.next.next = new Wrapper();
face.wrapper.vertex = vertices[objectData.faces[n++]];
face.wrapper.next.vertex = vertices[objectData.faces[n++]];
face.wrapper.next.next.vertex = vertices[objectData.faces[n++]];
_loc40_ = numFaces++;
faces[_loc40_] = face;
if(last != null)
{
last.next = face;
}
else
{
mesh.faceList = face;
}
last = face;
}
if(objectData.surfaces != null)
{
for(key in objectData.surfaces)
{
surface = objectData.surfaces[key];
materialData = this.materialDatas[key];
material = materialData.material;
for(n = 0; n < surface.length; n++)
{
face = faces[surface[n]];
face.material = material;
if(materialData.matrix != null)
{
for(w = face.wrapper; w != null; w = w.next)
{
vertex = w.vertex;
if(vertex.transformId < 0)
{
u = vertex.u;
v = vertex.v;
vertex.u = materialData.matrix.a * u + materialData.matrix.b * v + materialData.matrix.tx;
vertex.v = materialData.matrix.c * u + materialData.matrix.d * v + materialData.matrix.ty;
vertex.transformId = 0;
}
}
}
}
}
}
var defaultMaterial:FillMaterial = new FillMaterial(8355711);
defaultMaterial.name = "default";
for(face = mesh.faceList; face != null; face = face.next)
{
if(face.material == null)
{
face.material = defaultMaterial;
}
}
mesh.calculateFacesNormals(true);
mesh.calculateBounds();
}
private function getString(index:int) : String
{
var charCode:int = 0;
this.data.position = index;
var res:String = "";
while((charCode = this.data.readByte()) != 0)
{
res += String.fromCharCode(charCode);
}
return res;
}
private function getRotationFrom3DSAngleAxis(angle:Number, x:Number, z:Number, y:Number) : Vector3D
{
var half:Number = NaN;
var res:Vector3D = new Vector3D();
var s:Number = Math.sin(angle);
var c:Number = Math.cos(angle);
var t:Number = 1 - c;
var k:Number = x * y * t + z * s;
if(k >= 1)
{
half = angle / 2;
res.z = -2 * Math.atan2(x * Math.sin(half),Math.cos(half));
res.y = -Math.PI / 2;
res.x = 0;
return res;
}
if(k <= -1)
{
half = angle / 2;
res.z = 2 * Math.atan2(x * Math.sin(half),Math.cos(half));
res.y = Math.PI / 2;
res.x = 0;
return res;
}
res.z = -Math.atan2(y * s - x * z * t,1 - (y * y + z * z) * t);
res.y = -Math.asin(x * y * t + z * s);
res.x = -Math.atan2(x * s - y * z * t,1 - (x * x + z * z) * t);
return res;
}
}
}
import alternativa.engine3d.materials.Material;
import flash.geom.Matrix;
class MaterialData
{
public var name:String;
public var color:int;
public var specular:int;
public var glossiness:int;
public var transparency:int;
public var diffuseMap:MapData;
public var opacityMap:MapData;
public var matrix:Matrix;
public var material:Material;
function MaterialData()
{
super();
}
}
class MapData
{
public var filename:String;
public var scaleU:Number = 1;
public var scaleV:Number = 1;
public var offsetU:Number = 0;
public var offsetV:Number = 0;
public var rotation:Number = 0;
function MapData()
{
super();
}
}
class ObjectData
{
public var name:String;
public var vertices:Vector.<Number>;
public var uvs:Vector.<Number>;
public var faces:Vector.<int>;
public var surfaces:Object;
public var a:Number;
public var b:Number;
public var c:Number;
public var d:Number;
public var e:Number;
public var f:Number;
public var g:Number;
public var h:Number;
public var i:Number;
public var j:Number;
public var k:Number;
public var l:Number;
function ObjectData()
{
super();
}
}
import alternativa.engine3d.core.Object3D;
import flash.geom.Vector3D;
class AnimationData
{
public var objectName:String;
public var object:Object3D;
public var parentIndex:int;
public var pivot:Vector3D;
public var position:Vector3D;
public var rotation:Vector3D;
public var scale:Vector3D;
public var isInstance:Boolean;
function AnimationData()
{
super();
}
}
class ChunkInfo
{
public var id:int;
public var size:int;
public var dataSize:int;
public var dataPosition:int;
public var nextChunkPosition:int;
function ChunkInfo()
{
super();
}
}
|
package projects.tanks.client.battlefield.models.continuebattle {
public interface IMatchmakingContinueBattleModelBase {
}
}
|
package alternativa.tanks.models.weapon.shared
{
import alternativa.physics.Body;
public interface ICommonTargetEvaluator
{
function getTargetPriority(param1:Body, param2:Number, param3:Number) : Number;
}
}
|
package projects.tanks.client.battlefield.models.bonus.bonus.common {
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class BonusCommonCC {
private var _boxResource:Tanks3DSResource;
private var _cordResource:TextureResource;
private var _parachuteInnerResource:Tanks3DSResource;
private var _parachuteResource:Tanks3DSResource;
private var _pickupSoundResource:SoundResource;
public function BonusCommonCC(param1:Tanks3DSResource = null, param2:TextureResource = null, param3:Tanks3DSResource = null, param4:Tanks3DSResource = null, param5:SoundResource = null) {
super();
this._boxResource = param1;
this._cordResource = param2;
this._parachuteInnerResource = param3;
this._parachuteResource = param4;
this._pickupSoundResource = param5;
}
public function get boxResource() : Tanks3DSResource {
return this._boxResource;
}
public function set boxResource(param1:Tanks3DSResource) : void {
this._boxResource = param1;
}
public function get cordResource() : TextureResource {
return this._cordResource;
}
public function set cordResource(param1:TextureResource) : void {
this._cordResource = param1;
}
public function get parachuteInnerResource() : Tanks3DSResource {
return this._parachuteInnerResource;
}
public function set parachuteInnerResource(param1:Tanks3DSResource) : void {
this._parachuteInnerResource = param1;
}
public function get parachuteResource() : Tanks3DSResource {
return this._parachuteResource;
}
public function set parachuteResource(param1:Tanks3DSResource) : void {
this._parachuteResource = param1;
}
public function get pickupSoundResource() : SoundResource {
return this._pickupSoundResource;
}
public function set pickupSoundResource(param1:SoundResource) : void {
this._pickupSoundResource = param1;
}
public function toString() : String {
var local1:String = "BonusCommonCC [";
local1 += "boxResource = " + this.boxResource + " ";
local1 += "cordResource = " + this.cordResource + " ";
local1 += "parachuteInnerResource = " + this.parachuteInnerResource + " ";
local1 += "parachuteResource = " + this.parachuteResource + " ";
local1 += "pickupSoundResource = " + this.pickupSoundResource + " ";
return local1 + "]";
}
}
}
|
package alternativa.service
{
import flash.events.Event;
public interface IAddressService
{
function reload() : void;
function back() : void;
function forward() : void;
function up() : void;
function go(param1:int) : void;
function href(param1:String, param2:String = "_self") : void;
function popup(param1:String, param2:String = "popup", param3:String = "\"\"", param4:String = "") : void;
function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void;
function removeEventListener(param1:String, param2:Function) : void;
function dispatchEvent(param1:Event) : Boolean;
function hasEventListener(param1:String) : Boolean;
function getBaseURL() : String;
function getStrict() : Boolean;
function setStrict(param1:Boolean) : void;
function getHistory() : Boolean;
function setHistory(param1:Boolean) : void;
function getTracker() : String;
function setTracker(param1:String) : void;
function getTitle() : String;
function setTitle(param1:String) : void;
function getStatus() : String;
function setStatus(param1:String) : void;
function resetStatus() : void;
function getValue() : String;
function setValue(param1:String) : void;
function getPath() : String;
function getPathNames() : Array;
function getQueryString() : String;
function getParameter(param1:String) : String;
function getParameterNames() : Array;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.logging.paymentactions {
import flash.events.Event;
import projects.tanks.client.tanksservices.model.logging.payment.PaymentAction;
public class UserPaymentActionEvent extends Event {
public static const TYPE:String = "UserPaymentActionEvent";
private var paymentAction:PaymentAction;
private var countryCode:String;
private var payModeId:String;
private var shopItemId:String;
private var layoutName:String;
public function UserPaymentActionEvent(param1:PaymentAction) {
this.paymentAction = param1;
super(TYPE);
}
public function getPaymentAction() : PaymentAction {
return this.paymentAction;
}
public function getCountryCode() : String {
return this.countryCode;
}
public function setCountryCode(param1:String) : void {
this.countryCode = param1;
}
public function getPayModeId() : String {
return this.payModeId;
}
public function setPayModeId(param1:String) : void {
this.payModeId = param1;
}
public function getShopItemId() : String {
return this.shopItemId;
}
public function setShopItemId(param1:String) : void {
this.shopItemId = param1;
}
public function getLayoutName() : String {
return this.layoutName;
}
public function setLayoutName(param1:String) : void {
this.layoutName = param1;
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.bigbutton_DOWN_RIGHT.png")]
public dynamic class bigbutton_DOWN_RIGHT extends BitmapData {
public function bigbutton_DOWN_RIGHT(param1:int = 7, param2:int = 50) {
super(param1,param2);
}
}
}
|
package _codec.projects.tanks.client.panel.model.challenge.rewarding {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.challenge.rewarding.ChallengeRewardsCC;
public class VectorCodecChallengeRewardsCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecChallengeRewardsCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ChallengeRewardsCC,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.<ChallengeRewardsCC> = new Vector.<ChallengeRewardsCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ChallengeRewardsCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ChallengeRewardsCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ChallengeRewardsCC> = Vector.<ChallengeRewardsCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.inventory.item {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.inventory.item.InventoryItemCC;
public class CodecInventoryItemCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_alternativeSlotItem:ICodec;
private var codec_count:ICodec;
private var codec_itemIndex:ICodec;
public function CodecInventoryItemCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_alternativeSlotItem = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_itemIndex = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:InventoryItemCC = new InventoryItemCC();
local2.alternativeSlotItem = this.codec_alternativeSlotItem.decode(param1) as Boolean;
local2.count = this.codec_count.decode(param1) as int;
local2.itemIndex = this.codec_itemIndex.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:InventoryItemCC = InventoryItemCC(param2);
this.codec_alternativeSlotItem.encode(param1,local3.alternativeSlotItem);
this.codec_count.encode(param1,local3.count);
this.codec_itemIndex.encode(param1,local3.itemIndex);
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory.splash {
public class SplashState {
public static const SHOW:int = 1;
public static const FADE:int = 2;
public static const DONE:int = 3;
public function SplashState() {
super();
}
}
}
|
package alternativa.types {
import flash.utils.ByteArray;
import flash.utils.Dictionary;
public final class Long {
private static var longMap:Dictionary = new Dictionary();
public static const ZERO:Long = getLong(0,0);
private var _low:int;
private var _high:int;
public function Long(param1:int, param2:int) {
super();
this._high = param1;
this._low = param2;
}
public static function getLong(param1:int, param2:int) : Long {
var local3:Long = null;
var local4:Dictionary = longMap[param2];
if(local4 != null) {
local3 = local4[param1];
if(local3 == null) {
local3 = new Long(param1,param2);
local4[param1] = local3;
}
} else {
longMap[param2] = new Dictionary();
local3 = new Long(param1,param2);
longMap[param2][param1] = local3;
}
return local3;
}
public static function fromHexString(param1:String) : Long {
var local2:int = param1.length;
if(local2 <= 8) {
return getLong(0,int("0x" + param1));
}
return getLong(int("0x" + param1.substr(0,local2 - 8)),int("0x" + param1.substr(local2 - 8)));
}
public static function fromInt(param1:int) : Long {
if(param1 < 0) {
return getLong(4294967295,param1);
}
return getLong(0,param1);
}
public static function comparator(param1:Long, param2:Long) : int {
if(param1 == param2) {
return 0;
}
if(param1.high != param2.high) {
return param1.high < param2.high ? -1 : 1;
}
if(param1.low != param2.low) {
return param1.low < param2.low ? -1 : 1;
}
return 0;
}
public function get low() : int {
return this._low;
}
public function get high() : int {
return this._high;
}
final public function toString(param1:uint = 10) : String {
var local4:uint = 0;
if(param1 < 2 || param1 > 36) {
throw new ArgumentError();
}
switch(this.high) {
case 0:
return this.low.toString(param1);
case -1:
return int(this.low).toString(param1);
default:
if(this.low == 0 && this.high == 0) {
return "0";
}
var local2:Array = [];
var local3:UInt64 = new UInt64(this.low,this.high);
if(this.high < 0) {
local3.bitwiseNot();
local3.add(1);
}
do {
local4 = uint(local3.div(param1));
local2.push((local4 < 10 ? "0" : "a").charCodeAt() + local4);
}
while(local3.high != 0);
if(this.high < 0) {
return "-" + local3.low.toString(param1) + String.fromCharCode.apply(String,local2.reverse());
}
return local3.low.toString(param1) + String.fromCharCode.apply(String,local2.reverse());
}
}
public function toByteArray(param1:ByteArray = null) : ByteArray {
if(param1 == null) {
param1 = new ByteArray();
}
param1.position = 0;
param1.writeInt(this._high);
param1.writeInt(this._low);
param1.position = 0;
return param1;
}
}
}
|
package controls.chat {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.chat.BattleChatInput_bitmapSC.png")]
public class BattleChatInput_bitmapSC extends BitmapAsset {
public function BattleChatInput_bitmapSC() {
super();
}
}
}
|
package projects.tanks.client.panel.model.mobilequest.quest {
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 MobileQuestModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MobileQuestModelServer;
private var client:IMobileQuestModelBase = IMobileQuestModelBase(this);
private var modelId:Long = Long.getLong(2137205145,748417604);
public function MobileQuestModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MobileQuestModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(MobileQuestCC,false)));
}
protected function getInitParam() : MobileQuestCC {
return MobileQuestCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo {
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapons.targeting.priority.targeting.CommonTargetPriorityCalculator;
public class RocketLauncherPriorityCalculator extends CommonTargetPriorityCalculator {
private static const CURRENT_TARGET_BONUS:Number = 900;
private var target:RocketTargetPoint;
private var shotRange:Number;
public function RocketLauncherPriorityCalculator(param1:WeaponObject, param2:RocketTargetPoint, param3:Number) {
this.target = param2;
this.shotRange = param3;
super(param1);
}
override public function getTargetPriority(param1:Tank, param2:Number, param3:Number) : Number {
return super.getTargetPriority(param1,param2,param3) + this.calculateBonusForLastTarget(param1);
}
override protected function getFullDamageDistance(param1:WeaponObject) : Number {
return this.shotRange;
}
private function calculateBonusForLastTarget(param1:Tank) : Number {
return this.target.isSameTank(param1) ? CURRENT_TARGET_BONUS : 0;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.armor.chassis.tracked {
public class TrackedChassisCC {
private var _damping:Number;
public function TrackedChassisCC(param1:Number = 0) {
super();
this._damping = param1;
}
public function get damping() : Number {
return this._damping;
}
public function set damping(param1:Number) : void {
this._damping = param1;
}
public function toString() : String {
var local1:String = "TrackedChassisCC [";
local1 += "damping = " + this.damping + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.shaft.sfx {
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
internal class Trail2 extends Mesh {
private var a:Vertex;
private var b:Vertex;
private var c:Vertex;
private var d:Vertex;
private var face:Face;
public function Trail2() {
super();
this.a = this.createVertex(-1,0,0,0,0.5);
this.b = this.createVertex(1,0,0,1,0.5);
this.c = this.createVertex(1,1,0,1,1);
this.d = this.createVertex(-1,1,0,0,1);
this.face = this.createQuad(this.a,this.b,this.c,this.d);
calculateFacesNormals();
sorting = Sorting.DYNAMIC_BSP;
shadowMapAlphaThreshold = 2;
depthMapAlphaThreshold = 2;
useShadowMap = false;
useLight = false;
}
public function init(param1:Number, param2:Number, param3:Number, param4:Material) : void {
alpha = 1;
var local5:Number = param1 / 2;
boundMinX = this.a.x = this.d.x = -local5;
boundMaxX = this.b.x = this.c.x = local5;
boundMinY = this.c.y = this.d.y = param2;
boundMaxY = 0;
boundMinZ = boundMaxZ = 0;
this.a.v = this.b.v = param3;
this.face.material = param4;
}
public function set width(param1:Number) : void {
var local2:Number = param1 / 2;
boundMinX = this.a.x = this.d.x = -local2;
boundMaxX = this.b.x = this.c.x = local2;
}
public function get length() : Number {
return this.d.y;
}
public function set length(param1:Number) : void {
if(param1 < 10) {
param1 = 10;
}
boundMaxY = this.c.y = this.d.y = param1;
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Vertex {
var local6:Vertex = new Vertex();
local6.next = vertexList;
vertexList = local6;
local6.x = param1;
local6.y = param2;
local6.z = param3;
local6.u = param4;
local6.v = param5;
return local6;
}
private function createQuad(param1:Vertex, param2:Vertex, param3:Vertex, param4:Vertex) : Face {
var local5:Face = new Face();
local5.next = faceList;
faceList = local5;
local5.wrapper = new Wrapper();
local5.wrapper.vertex = param1;
local5.wrapper.next = new Wrapper();
local5.wrapper.next.vertex = param2;
local5.wrapper.next.next = new Wrapper();
local5.wrapper.next.next.vertex = param3;
local5.wrapper.next.next.next = new Wrapper();
local5.wrapper.next.next.next.vertex = param4;
return local5;
}
}
}
|
package alternativa.tanks.models.tank.pause {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ITankPauseAdapt implements ITankPause {
private var object:IGameObject;
private var impl:ITankPause;
public function ITankPauseAdapt(param1:IGameObject, param2:ITankPause) {
super();
this.object = param1;
this.impl = param2;
}
public function enablePause() : void {
try {
Model.object = this.object;
this.impl.enablePause();
}
finally {
Model.popObject();
}
}
public function disablePause() : void {
try {
Model.object = this.object;
this.impl.disablePause();
}
finally {
Model.popObject();
}
}
public function resetIdleKickTime() : void {
try {
Model.object = this.object;
this.impl.resetIdleKickTime();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapon.pumpkingun
{
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.physics.Body;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.register.ObjectRegister;
import alternativa.service.IModelService;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.SpriteShotEffect;
import alternativa.tanks.models.sfx.shoot.pumpkingun.IPumpkingunSFXModel;
import alternativa.tanks.models.sfx.shoot.pumpkingun.PumpkingunSFXData;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.models.weapon.IWeaponController;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shared.CommonTargetEvaluator;
import alternativa.tanks.models.weapon.shared.shot.ShotData;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.AnimatedSpriteEffectNew;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.SoundOptions;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.vehicles.tanks.Tank;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.ricochet.IRicochetModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.ricochet.RicochetModelBase;
import com.reygazu.anticheat.variables.SecureInt;
import com.reygazu.anticheat.variables.SecureNumber;
import flash.media.Sound;
import flash.utils.getTimer;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.tanks.WeaponsManager;
public class PumpkinModel extends RicochetModelBase implements IRicochetModelBase, IObjectLoadListener, IWeaponController, IPumpkinShotListener
{
private static const EXPLOSION_SIZE:Number = 266;
private static var objectPoolService:IObjectPoolService;
private var weaponCommonModel:IWeaponCommonModel;
private var weakeningModel:IWeaponWeakeningModel;
private var battlefield:IBattleField;
private var tankModel:TankModel;
private var ricochetSfxModel:IPumpkingunSFXModel;
private var localTankData:TankData;
private var localPumpkinData:PumpkinData;
private var localPumpkingunSFXData:PumpkingunSFXData;
private var localShotData:ShotData;
private var localWeaponCommonData:WeaponCommonData;
private var triggerPressed:Boolean;
private var readyTime:SecureInt;
private var currentEnergy:SecureNumber;
private var targetSystem:PumpkinTargetSystem;
private var weaponUtils:WeaponUtils;
private var _barrelOrigin:Vector3;
private var _gunDirGlobal:Vector3;
private var _xAxis:Vector3;
private var _muzzlePosGlobal:Vector3;
private var _shotDirection:Vector3;
private var _localPosition:Vector3;
private var _hitDirection:Vector3;
private var rayHit:RayIntersection;
private var SHOT_FLASH_SIZE:Number = 150;
private var SHOT_FLASH_DURATION:int = 100;
private var SHOT_FLASH_FADE:int = 100;
public function PumpkinModel()
{
this.readyTime = new SecureInt("readyTime.value ricochet");
this.currentEnergy = new SecureNumber("currentEnergy.value ricochet");
this.weaponUtils = WeaponUtils.getInstance();
this._barrelOrigin = new Vector3();
this._gunDirGlobal = new Vector3();
this._xAxis = new Vector3();
this._muzzlePosGlobal = new Vector3();
this._shotDirection = new Vector3();
this._localPosition = new Vector3();
this._hitDirection = new Vector3();
this.rayHit = new RayIntersection();
super();
_interfaces.push(IModel,IObjectLoadListener,IWeaponController);
objectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
}
public function hit(clientObject:ClientObject, targetId:String, hitPoint:Vector3d, hitDirectionX:int, hitDirectionY:int, hitDirectionZ:int, weakeningCoeff:Number) : void
{
var targetData:TankData = this.getTankDataSafe(targetId,clientObject.register);
var td:TankData = clientObject.getParams(TankModel) as TankData;
if(targetData == null || td == null)
{
return;
}
var commonData:WeaponCommonData = this.weaponCommonModel.getCommonData(td.turret);
this._localPosition.vReset(hitPoint.x,hitPoint.y,hitPoint.z);
this._hitDirection.vReset(hitDirectionX / 32767,hitDirectionY / 32767,hitDirectionZ / 32767).vNormalize();
this.battlefield.tankHit(targetData,this._hitDirection,weakeningCoeff * commonData.impactCoeff);
this._hitDirection.vScale(weakeningCoeff * commonData.impactForce);
targetData.tank.addWorldForceAtLocalPoint(this._localPosition,this._hitDirection);
}
public function fire(clientObject:ClientObject, shooterId:String, shotDirectionX:int, shotDirectionY:int, shotDirectionZ:int) : void
{
var shooterData:TankData = this.getTankDataSafe(shooterId,clientObject.register);
if(shooterData == null || shooterData.tank == null || shooterData.tank.skin == null)
{
return;
}
if(this.tankModel.localUserData != null)
{
if(shooterData == this.tankModel.localUserData)
{
return;
}
}
var pumpkinData:PumpkinData = PumpkinData(shooterData.turret.getParams(PumpkinData));
var commonData:WeaponCommonData = this.weaponCommonModel.getCommonData(shooterData.turret);
var sfxData:PumpkingunSFXData = this.ricochetSfxModel.getSfxData(shooterData.turret);
var muzzlePosLocal:Vector3 = commonData.muzzles[0];
this.weaponUtils.calculateGunParams(shooterData.tank.skin.turretMesh,muzzlePosLocal,this._muzzlePosGlobal,this._barrelOrigin,this._xAxis,this._gunDirGlobal);
this._shotDirection.vReset(shotDirectionX / 32767,shotDirectionY / 32767,shotDirectionZ / 32767).vNormalize();
this.createShotEffects(shooterData,pumpkinData,sfxData,commonData,muzzlePosLocal,this._muzzlePosGlobal,this._shotDirection,this._gunDirGlobal);
}
public function hitSelf(clientObject:ClientObject, shooterId:String, relativeHitPosition:int) : void
{
var shooterData:TankData = this.getTankDataSafe(shooterId,clientObject.register);
if(shooterData == null)
{
return;
}
var commonData:WeaponCommonData = this.weaponCommonModel.getCommonData(clientObject);
var sfxData:PumpkingunSFXData = this.ricochetSfxModel.getSfxData(clientObject);
var muzzlePosLocal:Vector3 = commonData.muzzles[0];
this.weaponUtils.calculateGunParams(shooterData.tank.skin.turretMesh,muzzlePosLocal,this._muzzlePosGlobal,this._barrelOrigin,this._xAxis,this._gunDirGlobal);
this.createSelfHitEffects(shooterData,sfxData,commonData,relativeHitPosition,this._barrelOrigin,this._gunDirGlobal);
}
public function initObject(clientObject:ClientObject, energyCapacity:int, energyPerShot:int, energyRechargeSpeed:Number, shotDistance:Number, shotRadius:Number, shotSpeed:Number) : void
{
var modelService:IModelService = null;
var weaponData:PumpkinData = new PumpkinData(100 * shotRadius,100 * shotSpeed,energyCapacity,energyPerShot,energyRechargeSpeed,100 * shotDistance);
clientObject.putParams(PumpkinData,weaponData);
WeaponsManager.getPumpkingunSFXModel(clientObject);
if(this.battlefield == null)
{
modelService = IModelService(Main.osgi.getService(IModelService));
this.battlefield = IBattleField(modelService.getModelsByInterface(IBattleField)[0]);
this.tankModel = TankModel(Main.osgi.getService(ITank));
this.weaponCommonModel = IWeaponCommonModel(modelService.getModelsByInterface(IWeaponCommonModel)[0]);
}
this.objectLoaded(clientObject);
}
public function objectLoaded(object:ClientObject) : void
{
var modelService:IModelService = null;
if(this.weakeningModel == null)
{
modelService = IModelService(Main.osgi.getService(IModelService));
this.weakeningModel = IWeaponWeakeningModel(modelService.getModelsByInterface(IWeaponWeakeningModel)[0]);
this.ricochetSfxModel = WeaponsManager.getPumpkingunSFXModel(object);
}
}
public function objectUnloaded(object:ClientObject) : void
{
}
public function stopEffects(ownerTankData:TankData) : void
{
}
public function reset() : void
{
this.readyTime.value = 0;
this.currentEnergy.value = this.localPumpkinData.energyCapacity;
}
public function setLocalUser(localUserData:TankData) : void
{
var turretObject:ClientObject = localUserData.turret;
this.localTankData = localUserData;
this.localPumpkinData = PumpkinData(turretObject.getParams(PumpkinData));
this.localPumpkingunSFXData = PumpkingunSFXData(turretObject.getParams(PumpkingunSFXData));
var modelService:IModelService = IModelService(Main.osgi.getService(IModelService));
this.localShotData = WeaponsManager.shotDatas[turretObject.id];
this.localWeaponCommonData = this.weaponCommonModel.getCommonData(localUserData.turret);
var battleField:IBattleField = IBattleField(modelService.getModelsByInterface(IBattleField)[0]);
var tanksCollisionDetector:TanksCollisionDetector = battleField.getBattlefieldData().collisionDetector;
var commonTargetEvaluator:CommonTargetEvaluator = CommonTargetEvaluator.create(this.localTankData,this.localShotData,this.battlefield,this.weakeningModel,modelService);
this.targetSystem = new PumpkinTargetSystem(this.localShotData.autoAimingAngleUp.value,this.localShotData.numRaysUp.value,this.localShotData.autoAimingAngleDown.value,this.localShotData.numRaysDown.value,this.localPumpkinData.shotDistance,tanksCollisionDetector,commonTargetEvaluator);
}
public function clearLocalUser() : void
{
this.localTankData = null;
this.localPumpkinData = null;
this.localShotData = null;
this.localWeaponCommonData = null;
this.targetSystem = null;
}
public function activateWeapon(time:int) : void
{
this.triggerPressed = true;
}
public function deactivateWeapon(time:int, sendServerCommand:Boolean) : void
{
this.triggerPressed = false;
}
public function update(time:int, deltaTime:int) : Number
{
var energyCapacity:int = this.localPumpkinData.energyCapacity;
if(this.currentEnergy.value < energyCapacity)
{
this.currentEnergy.value += this.localPumpkinData.energyRechargeSpeed * deltaTime * 0.001;
if(this.currentEnergy.value > energyCapacity)
{
this.currentEnergy.value = energyCapacity;
}
}
if(this.triggerPressed && time >= this.readyTime.value && this.currentEnergy.value >= this.localPumpkinData.energyPerShot)
{
this.doFire(this.localWeaponCommonData);
}
return this.currentEnergy.value / this.localPumpkinData.energyCapacity;
}
public function shotHit(shot:PumpkinShot, hitPoint:Vector3, hitDir:Vector3, targetBody:Body) : void
{
var targetTank:Tank = null;
var targetTankData:TankData = null;
var pos:Vector3 = null;
var hitPos3d:Vector3d = null;
var targetPos3d:Vector3d = null;
this.createExplosion(hitPoint,shot.sfxData);
if(shot.shooterData == this.localTankData)
{
targetTank = Tank(targetBody);
targetTankData = targetTank.tankData;
pos = new Vector3().vCopy(hitPoint).vSubtract(targetTank.state.pos);
pos.vTransformBy3Tr(targetTank.baseMatrix);
hitPos3d = new Vector3d(pos.x,pos.y,pos.z);
pos = targetTank.state.pos;
targetPos3d = new Vector3d(pos.x,pos.y,pos.z);
this.hitCommand(this.localTankData.turret,targetTankData.user.id,shot.id,targetTankData.incarnation,hitPos3d,targetPos3d,hitDir.x * 32767,hitDir.y * 32767,hitDir.z * 32767,0.01 * shot.totalDistance);
}
}
private function hitCommand(turr:ClientObject, victimId:String, shotId:int, inc:int, hitPos3d:Vector3d, targetPos3d:Vector3d, x:Number, y:Number, z:Number, distance:Number) : void
{
var js:Object = new Object();
js.victimId = victimId;
js.shotId = shotId;
js.distance = distance;
js.hitPos3d = hitPos3d;
js.x = x;
js.y = y;
js.z = z;
js.reloadTime = this.localShotData.reloadMsec.value;
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(js));
}
private function createExplosion(position:Vector3, sfxData:PumpkingunSFXData) : void
{
var explosionEffect:AnimatedSpriteEffectNew = AnimatedSpriteEffectNew(objectPoolService.objectPool.getObject(AnimatedSpriteEffectNew));
var posProvider:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
posProvider.init(position,50);
var animaton:TextureAnimation = sfxData.dataExplosion;
explosionEffect.init(EXPLOSION_SIZE,EXPLOSION_SIZE,animaton,Math.random() * Math.PI * 2,posProvider,0.5,0.5,null,0);
this.battlefield.addGraphicEffect(explosionEffect);
this.addSoundEffect(sfxData.explosionSound,position,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.8);
}
private function addSoundEffect(sound:Sound, position:Vector3, nearRadius:Number, farRadius:Number, farDelimiter:Number, soundVolume:Number) : void
{
var sound3d:Sound3D = null;
var soundEffect:Sound3DEffect = null;
if(sound != null)
{
sound3d = Sound3D.create(sound,nearRadius,farRadius,farDelimiter,soundVolume);
soundEffect = Sound3DEffect.create(objectPoolService.objectPool,null,position,sound3d);
this.battlefield.addSound3DEffect(soundEffect);
}
}
private function doFire(param1:WeaponCommonData) : void
{
var _loc3_:int = 0;
var _loc4_:Vector3 = null;
var _loc5_:Vector3d = null;
var _loc6_:PumpkinShot = null;
this.readyTime.value = getTimer() + this.localShotData.reloadMsec.value;
this.currentEnergy.value -= this.localPumpkinData.energyPerShot;
var _loc2_:Vector3 = param1.muzzles[0];
this.weaponUtils.calculateGunParams(this.localTankData.tank.skin.turretMesh,_loc2_,this._muzzlePosGlobal,this._barrelOrigin,this._xAxis,this._gunDirGlobal);
if(this.battlefield.getBattlefieldData().collisionDetector.intersectRayWithStatic(this._barrelOrigin,this._gunDirGlobal,CollisionGroup.STATIC,_loc2_.y,null,this.rayHit))
{
_loc3_ = this.rayHit.t / _loc2_.y * 255 - 128;
_loc4_ = this.localTankData.tank.state.pos;
_loc5_ = new Vector3d(_loc4_.x,_loc4_.y,_loc4_.z);
this.createSelfHitEffects(this.localTankData,this.localPumpkingunSFXData,this.localWeaponCommonData,_loc3_,this._barrelOrigin,this._gunDirGlobal);
this.hitSelfCommand(this.localTankData.turret,this.localTankData.incarnation,_loc3_,_loc5_);
this.localTankData;
}
else if(this.battlefield.getBattlefieldData().collisionDetector.intersectRayWithStatic(this.localTankData.tank.state.pos,this._barrelOrigin.vClone().vRemove(this.localTankData.tank.state.pos).vNormalize(),CollisionGroup.STATIC,_loc2_.y,null,this.rayHit))
{
_loc3_ = this.rayHit.t / _loc2_.y * 255 - 128;
_loc4_ = this.localTankData.tank.state.pos;
_loc5_ = new Vector3d(_loc4_.x,_loc4_.y,_loc4_.z);
this.createSelfHitEffects(this.localTankData,this.localPumpkingunSFXData,this.localWeaponCommonData,_loc3_,this._barrelOrigin,this._gunDirGlobal);
this.hitSelfCommand(this.localTankData.turret,this.localTankData.incarnation,_loc3_,_loc5_);
}
else
{
if(!this.targetSystem.getShotDirection(this._muzzlePosGlobal,this._gunDirGlobal,this._xAxis,this.localTankData.tank,this._shotDirection))
{
this._shotDirection.vCopy(this._gunDirGlobal);
}
_loc6_ = this.createShotEffects(this.localTankData,this.localPumpkinData,this.localPumpkingunSFXData,param1,_loc2_,this._muzzlePosGlobal,this._shotDirection,this._gunDirGlobal);
this.fireCommand(this.localTankData.turret,_loc6_.id,this._shotDirection.x * 32767,this._shotDirection.y * 32767,this._shotDirection.z * 32767);
}
}
private function hitSelfCommand(turr:ClientObject, inc:int, relativeHitPos:int, pos3d:Vector3d) : void
{
var js:Object = new Object();
js.self_hit = true;
js.reloadTime = this.localShotData.reloadMsec.value;
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(js));
}
private function fireCommand(turr:ClientObject, shotid:int, x:Number, y:Number, z:Number) : void
{
var json:Object = new Object();
json.shotid = shotid;
json.x = x;
json.y = y;
json.z = z;
Network(Main.osgi.getService(INetworker)).send("battle;start_fire;" + JSON.stringify(json));
}
private function createShotEffects(shooterData:TankData, pumpkinData:PumpkinData, ricochetSFXData:PumpkingunSFXData, weaponCommonData:WeaponCommonData, localMuzzlePosition:Vector3, globalMuzzlePosition:Vector3, shotDirection:Vector3, gunDirection:Vector3) : PumpkinShot
{
var sound:Sound3D = null;
var soundEffect:Sound3DEffect = null;
var ricochetShot:PumpkinShot = PumpkinShot(objectPoolService.objectPool.getObject(PumpkinShot));
ricochetShot.init(globalMuzzlePosition,shotDirection,shooterData,pumpkinData,ricochetSFXData,this.battlefield.getBattlefieldData().collisionDetector,this.weakeningModel,this,this.battlefield);
this.battlefield.addGraphicEffect(ricochetShot);
var shotFlashEffect:SpriteShotEffect = SpriteShotEffect(objectPoolService.objectPool.getObject(SpriteShotEffect));
shotFlashEffect.init(ricochetSFXData.shotFlashMaterial,localMuzzlePosition,shooterData.tank.skin.turretMesh,20,this.SHOT_FLASH_SIZE,this.SHOT_FLASH_DURATION,this.SHOT_FLASH_FADE,ricochetSFXData.colorTransform);
this.battlefield.addGraphicEffect(shotFlashEffect);
if(ricochetSFXData.shotSound != null)
{
sound = Sound3D.create(ricochetSFXData.shotSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.8);
soundEffect = Sound3DEffect.create(objectPoolService.objectPool,null,globalMuzzlePosition,sound);
this.battlefield.addSound3DEffect(soundEffect);
}
shooterData.tank.addWorldForceScaled(globalMuzzlePosition,gunDirection,-weaponCommonData.kickback);
return ricochetShot;
}
private function createSelfHitEffects(shooterData:TankData, ricochetSFXData:PumpkingunSFXData, weaponCommonData:WeaponCommonData, relativeHitPos:int, globalBarrelOrigin:Vector3, gunDirection:Vector3) : void
{
var sound:Sound3D = null;
var soundEffect:Sound3DEffect = null;
var offsetAlongBarrel:Number = (relativeHitPos + 128) / 255 * weaponCommonData.muzzles[0].y;
var hitPos:Vector3 = globalBarrelOrigin.vClone();
hitPos.vAddScaled(offsetAlongBarrel,gunDirection);
if(ricochetSFXData.shotSound != null)
{
sound = Sound3D.create(ricochetSFXData.shotSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.8);
soundEffect = Sound3DEffect.create(objectPoolService.objectPool,null,hitPos,sound);
this.battlefield.addSound3DEffect(soundEffect);
}
this.createExplosion(hitPos,ricochetSFXData);
shooterData.tank.addWorldForceScaled(globalBarrelOrigin,gunDirection,-weaponCommonData.impactForce);
}
private function getTankDataSafe(objectId:String, objectRegister:ObjectRegister) : TankData
{
var object:ClientObject = BattleController.activeTanks[objectId];
if(object == null)
{
return null;
}
var tankData:TankData = this.tankModel.getTankData(object);
if(tankData == null || tankData.tank == null)
{
return null;
}
return tankData;
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.PaymentRequestVariable;
public class VectorCodecPaymentRequestVariableLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPaymentRequestVariableLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PaymentRequestVariable,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.<PaymentRequestVariable> = new Vector.<PaymentRequestVariable>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PaymentRequestVariable(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PaymentRequestVariable = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PaymentRequestVariable> = Vector.<PaymentRequestVariable>(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 platform.clients.fp10.libraries.alternativapartnersflash {
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.osgi.service.launcherparams.ILauncherParams;
import alternativa.osgi.service.logging.LogService;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.service.address.AddressService;
import platform.clients.fp10.libraries.alternativapartners.models.socialnetworkparameters.SocialNetworkParameters;
import platform.clients.fp10.libraries.alternativapartners.models.socialnetworkparameters.SocialNetworkParametersAdapt;
import platform.clients.fp10.libraries.alternativapartners.models.socialnetworkparameters.SocialNetworkParametersEvents;
import platform.clients.fp10.libraries.alternativapartners.models.socialnetworkparameters.SocialNetworkParametersModel;
import platform.clients.fp10.libraries.alternativapartners.service.impl.PartnerService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListenerAdapt;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListenerEvents;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import platform.clients.fp10.libraries.alternativapartners.type.IPartnerAdapt;
import platform.clients.fp10.libraries.alternativapartners.type.IPartnerEvents;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var modelRegisterAdapt:ModelRegistry;
var modelRegister:ModelRegistry;
var _osgi:OSGi = param1;
osgi = _osgi;
osgi.injectService(AddressService,function(param1:Object):void {
PartnerService.addressService = AddressService(param1);
},function():AddressService {
return PartnerService.addressService;
});
osgi.injectService(LogService,function(param1:Object):void {
PartnerService.log = LogService(param1);
},function():LogService {
return PartnerService.log;
});
osgi.injectService(ILauncherParams,function(param1:Object):void {
PartnerService.paramsService = ILauncherParams(param1);
},function():ILauncherParams {
return PartnerService.paramsService;
});
modelRegisterAdapt = osgi.getService(ModelRegistry) as ModelRegistry;
modelRegisterAdapt.registerAdapt(SocialNetworkParameters,SocialNetworkParametersAdapt);
modelRegisterAdapt.registerEvents(SocialNetworkParameters,SocialNetworkParametersEvents);
modelRegister = osgi.getService(ModelRegistry) as ModelRegistry;
modelRegister.add(new SocialNetworkParametersModel());
modelRegisterAdapt.registerAdapt(IParametersListener,IParametersListenerAdapt);
modelRegisterAdapt.registerEvents(IParametersListener,IParametersListenerEvents);
modelRegisterAdapt.registerAdapt(IPartner,IPartnerAdapt);
modelRegisterAdapt.registerEvents(IPartner,IPartnerEvents);
}
public function stop(param1:OSGi) : void {
}
}
}
|
package projects.tanks.client.battlefield.models.effects.description {
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 EffectDescriptionModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function EffectDescriptionModelServer(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());
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.