code
stringlengths 57
237k
|
|---|
package projects.tanks.client.battleselect.model.matchmaking.view {
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 MatchmakingLayoutModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MatchmakingLayoutModelServer;
private var client:IMatchmakingLayoutModelBase = IMatchmakingLayoutModelBase(this);
private var modelId:Long = Long.getLong(1381232317,979335603);
private var _hideMatchmakingViewId:Long = Long.getLong(684570251,-10047503);
private var _showMatchmakingViewId:Long = Long.getLong(741085905,-1689593046);
public function MatchmakingLayoutModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MatchmakingLayoutModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(MatchmakingLayoutCC,false)));
}
protected function getInitParam() : MatchmakingLayoutCC {
return MatchmakingLayoutCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._hideMatchmakingViewId:
this.client.hideMatchmakingView();
break;
case this._showMatchmakingViewId:
this.client.showMatchmakingView();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import alternativa.physics.Body;
import alternativa.tanks.battle.CTFTargetEvaluator;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.battle.battlefield.CommonTargetEvaluatorConst;
import alternativa.tanks.models.battle.commonflag.CommonFlag;
import alternativa.tanks.models.weapon.FlagTargetEvaluator;
import alternativa.tanks.models.weapon.shared.CommonTargetEvaluator;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class CTFCommonTargetEvaluator implements CommonTargetEvaluator, CTFTargetEvaluator {
private static const FLAG_CARRIER_PRIORITY_BONUS:Number = 5;
private var localTeamType:BattleTeam;
private var flagTargetEvaluator:FlagTargetEvaluator = new FlagTargetEvaluator();
public function CTFCommonTargetEvaluator() {
super();
}
public function setLocalTeamType(param1:BattleTeam) : void {
this.localTeamType = param1;
}
public function setFlagCarrier(param1:CommonFlag, param2:Body) : void {
this.flagTargetEvaluator.setFlagCarrier(param1,param2);
}
public function getTargetPriority(param1:Body, param2:Number, param3:Number, param4:Number, param5:Number) : Number {
var local7:Number = NaN;
var local6:Tank = param1.tank;
if(local6.health > 0 && !local6.isSameTeam(this.localTeamType)) {
local7 = this.flagTargetEvaluator.isCarrier(param1) ? FLAG_CARRIER_PRIORITY_BONUS : 0;
return CommonTargetEvaluatorConst.MAX_PRIORITY - (CommonTargetEvaluatorConst.DISTANCE_WEIGHT * param2 / param4 + (1 - CommonTargetEvaluatorConst.DISTANCE_WEIGHT) * Math.abs(param3) / param5) + local7;
}
return 0;
}
}
}
|
package projects.tanks.client.battleservice.model.battle.jgr {
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 BattleJGRModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleJGRModelServer;
private var client:IBattleJGRModelBase = IBattleJGRModelBase(this);
private var modelId:Long = Long.getLong(1189086764,-465610899);
public function BattleJGRModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleJGRModelServer(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 assets.icons {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol1321")]
public dynamic class changeIcon extends MovieClip {
public function changeIcon() {
super();
}
}
}
|
package alternativa.tanks.battle {
import alternativa.physics.Body;
import alternativa.physics.collision.CollisionShape;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.triggers.Triggers;
import alternativa.tanks.battle.utils.AddPostPhysicsControllerAction;
import alternativa.tanks.battle.utils.LogicUnitDeferredAction;
import alternativa.tanks.battle.utils.PhysicsControllerDeferredAction;
import alternativa.tanks.battle.utils.RemovePostPhysicsController;
import alternativa.tanks.models.tank.LocalTankInfoService;
import alternativa.tanks.physics.TankBody;
import alternativa.tanks.physics.TankBodyIdProvider;
import alternativa.tanks.physics.TankPhysicsScene;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.sound.ISoundManager;
import alternativa.tanks.sound.SoundManager;
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import flash.media.Sound;
import flash.utils.getTimer;
public class BattleRunner {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var localTankInfoService:LocalTankInfoService;
public static const PHYSICS_STEP_IN_MS:int = 33;
public static const PHYSICS_STEP_IN_S:Number = 0.033;
private static const thousand:EncryptedInt = new EncryptedIntImpl(1000);
public var physicsPerformanceMonitor:PerformanceMonitor = new PerformanceMonitor(30);
private var time:int;
private var lastRunLogicTime:int;
private var inputProcessors:Vector.<LogicUnit> = new Vector.<LogicUnit>();
private var logicUnits:Vector.<LogicUnit> = new Vector.<LogicUnit>();
private var logicInProgress:Boolean;
private var physicsControllers:Vector.<PhysicsController> = new Vector.<PhysicsController>();
private var postPhysicsControllers:Vector.<PostPhysicsController> = new Vector.<PostPhysicsController>();
private var physicsInterpolators:Vector.<PhysicsInterpolator> = new Vector.<PhysicsInterpolator>();
private var deferredActions:Vector.<DeferredAction> = new Vector.<DeferredAction>();
private var localBody:Body;
private var physicsInProgress:Boolean;
private var soundManager:ISoundManager;
private var battleEventDispatcher:BattleEventDispatcher;
private const _triggers:Triggers = new Triggers();
private var physicsScene:TankPhysicsScene;
public function BattleRunner(param1:Number, param2:Sound, param3:BattleEventDispatcher) {
super();
this.battleEventDispatcher = param3;
this.time = getTimer();
this.physicsScene = new TankPhysicsScene(this.time,param1,param3);
this.soundManager = SoundManager.createSoundManager(param2);
this.lastRunLogicTime = this.time;
TankBodyIdProvider.resetIds();
}
public function getSoundManager() : ISoundManager {
return this.soundManager;
}
public function initStaticGeometry(param1:Vector.<CollisionShape>) : void {
this.physicsScene.initStaticGeometry(param1);
}
public function getCollisionDetector() : TanksCollisionDetector {
return this.physicsScene.getCollisionDetector();
}
public function addInputProcessor(param1:LogicUnit) : void {
if(this.inputProcessors.indexOf(param1) < 0) {
this.inputProcessors.push(param1);
}
}
public function removeInputProcessor(param1:LogicUnit) : void {
this.removeLogicUnitFromArray(param1,this.inputProcessors);
}
public function addLogicUnit(param1:LogicUnit) : void {
if(this.logicInProgress) {
this.addDeferredAction(new LogicUnitDeferredAction(param1,true));
} else if(this.logicUnits.indexOf(param1) < 0) {
this.logicUnits.push(param1);
}
}
public function removeLogicUnit(param1:LogicUnit) : void {
if(this.logicInProgress) {
this.addDeferredAction(new LogicUnitDeferredAction(param1,false));
} else {
this.removeLogicUnitFromArray(param1,this.logicUnits);
}
}
private function removeLogicUnitFromArray(param1:LogicUnit, param2:Vector.<LogicUnit>) : void {
var local4:int = 0;
var local3:int = int(param2.indexOf(param1));
if(local3 >= 0) {
local4 = param2.length - 1;
param2[local3] = param2[local4];
param2.length = local4;
}
}
public function addTrigger(param1:Trigger) : void {
this._triggers.add(param1);
}
public function removeTrigger(param1:Trigger) : void {
this._triggers.remove(param1);
}
public function setLocalBody(param1:Body) : void {
this.localBody = param1;
}
public function addBodyWrapper(param1:TankBody) : void {
this.physicsScene.addBody(param1);
}
public function removeBodyWrapper(param1:TankBody) : void {
this.physicsScene.removeBody(param1);
if(this.localBody == param1.body) {
this.setLocalBody(null);
}
}
public function addPhysicsController(param1:PhysicsController) : void {
if(this.physicsInProgress) {
this.addDeferredAction(new PhysicsControllerDeferredAction(param1,true));
} else if(this.physicsControllers.indexOf(param1) < 0) {
this.physicsControllers.push(param1);
}
}
public function removePhysicsController(param1:PhysicsController) : void {
var local2:int = 0;
var local3:int = 0;
if(this.physicsInProgress) {
this.addDeferredAction(new PhysicsControllerDeferredAction(param1,false));
} else {
local2 = int(this.physicsControllers.length);
if(local2 > 0) {
local3 = int(this.physicsControllers.indexOf(param1));
if(local3 >= 0) {
this.physicsControllers.splice(local3,1);
}
}
}
}
public function addPostPhysicsController(param1:PostPhysicsController) : void {
if(this.physicsInProgress) {
this.addDeferredAction(new AddPostPhysicsControllerAction(param1));
} else if(this.postPhysicsControllers.indexOf(param1) < 0) {
this.postPhysicsControllers.push(param1);
}
}
public function removePostPhysicsController(param1:PostPhysicsController) : void {
var local2:int = 0;
var local3:int = 0;
if(this.physicsInProgress) {
this.addDeferredAction(new RemovePostPhysicsController(param1));
} else {
local2 = int(this.postPhysicsControllers.length);
if(local2 > 0) {
local3 = int(this.postPhysicsControllers.indexOf(param1));
if(local3 >= 0) {
this.postPhysicsControllers.splice(local3,1);
}
}
}
}
public function addPhysicsInterpolator(param1:PhysicsInterpolator) : void {
if(this.physicsInterpolators.indexOf(param1) < 0) {
this.physicsInterpolators.push(param1);
}
}
public function removePhysicsInterpolator(param1:PhysicsInterpolator) : void {
var local3:int = 0;
var local2:int = int(this.physicsInterpolators.length);
if(local2 > 0) {
local3 = int(this.physicsInterpolators.indexOf(param1));
if(local3 >= 0) {
this.physicsInterpolators[local3] = this.physicsInterpolators[--local2];
this.physicsInterpolators.length = local2;
}
}
}
public function tick() : void {
var local1:int = getTimer();
var local2:int = local1 - this.time;
this.time = local1;
this.runInputProcessors(this.time,local2);
this.runPhysics(PHYSICS_STEP_IN_MS);
battleService.getBattleScene3D().render(this.time,local2);
battleService.getBattleView().update();
this.soundManager.updateSoundEffects(local2,battleService.getBattleScene3D().getCamera());
}
private function runInputProcessors(param1:int, param2:int) : void {
var local3:int = int(this.inputProcessors.length);
var local4:int = 0;
while(local4 < local3) {
this.inputProcessors[local4].runLogic(param1,param2);
local4++;
}
}
public function shutdown() : void {
this.soundManager.stopAllSounds();
this.soundManager.removeAllEffects();
this.physicsScene.destroy();
}
private function runLogicUnits(param1:int) : void {
var local5:LogicUnit = null;
var local2:int = param1 - this.lastRunLogicTime;
this.lastRunLogicTime = param1;
this.logicInProgress = true;
var local3:int = int(this.logicUnits.length);
var local4:int = 0;
while(local4 < local3) {
local5 = this.logicUnits[local4];
local5.runLogic(param1,local2);
local4++;
}
this.logicInProgress = false;
this.executeDeferedActions();
}
private function runPhysics(param1:int) : void {
this.physicsPerformanceMonitor.beginFrame();
while(this.physicsScene.getPhysicsTime() < this.time) {
this.updateLocalTankPhysicsState();
this.runLogicUnits(this.getPhysicsTime());
this.physicsInProgress = true;
this.runPhysicsControllers(param1 / thousand.getInt());
this.physicsScene.update(param1);
this.runPostPhysicsControllers(param1 / thousand.getInt());
this._triggers.check(this.localBody);
this.physicsInProgress = false;
this.executeDeferedActions();
}
this.physicsPerformanceMonitor.endFrame();
this.runPhysicsInterpolators(param1);
}
private function updateLocalTankPhysicsState() : void {
if(localTankInfoService.isLocalTankLoaded()) {
localTankInfoService.getLocalTank().updatePhysicsState();
}
}
private function runPhysicsControllers(param1:Number) : void {
var local4:PhysicsController = null;
var local2:int = int(this.physicsControllers.length);
var local3:int = 0;
while(local3 < local2) {
local4 = this.physicsControllers[local3];
local4.runBeforePhysicsUpdate(param1);
local3++;
}
}
private function runPostPhysicsControllers(param1:Number) : void {
var local4:PostPhysicsController = null;
var local2:int = int(this.postPhysicsControllers.length);
var local3:int = 0;
while(local3 < local2) {
local4 = this.postPhysicsControllers[local3];
local4.runAfterPhysicsUpdate(param1);
local3++;
}
}
private function runPhysicsInterpolators(param1:int) : void {
var local5:PhysicsInterpolator = null;
var local2:Number = 1 + (this.time - this.physicsScene.getPhysicsTime()) / PHYSICS_STEP_IN_MS;
var local3:int = int(this.physicsInterpolators.length);
var local4:int = 0;
while(local4 < local3) {
local5 = this.physicsInterpolators[local4];
local5.interpolatePhysicsState(local2,param1);
local4++;
}
}
private function addDeferredAction(param1:DeferredAction) : void {
this.deferredActions.push(param1);
}
private function executeDeferedActions() : void {
var local1:DeferredAction = null;
while(true) {
local1 = this.deferredActions.pop();
if(local1 == null) {
break;
}
local1.execute();
}
}
public function getPhysicsTime() : int {
return this.physicsScene.getPhysicsTime();
}
public function getGravity() : Number {
return this.physicsScene.getGravity();
}
}
}
|
package projects.tanks.client.panel.model.garage.rankupsupplybonus {
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 RankUpSupplyBonusModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RankUpSupplyBonusModelServer(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.clans.clan.incomingnotificator {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.clans.container.ContainerCC;
public class ClanIncomingNotificatorModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanIncomingNotificatorModelServer;
private var client:IClanIncomingNotificatorModelBase = IClanIncomingNotificatorModelBase(this);
private var modelId:Long = Long.getLong(1448266566,-1893699662);
private var _onAddingId:Long = Long.getLong(47370739,-335983741);
private var _onAdding_userIdCodec:ICodec;
private var _onRemovedId:Long = Long.getLong(1468492941,414226622);
private var _onRemoved_userIdCodec:ICodec;
public function ClanIncomingNotificatorModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanIncomingNotificatorModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ContainerCC,false)));
this._onAdding_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._onRemoved_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
protected function getInitParam() : ContainerCC {
return ContainerCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._onAddingId:
this.client.onAdding(Long(this._onAdding_userIdCodec.decode(param2)));
break;
case this._onRemovedId:
this.client.onRemoved(Long(this._onRemoved_userIdCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package platform.clients.fp10.libraries.alternativapartners.service {
import platform.client.fp10.core.type.IGameObject;
public interface IPartnerService {
function isRunningInsidePartnerEnvironment() : Boolean;
function getEnvironmentPartnerId() : String;
function setPartner(param1:IGameObject) : void;
function hasPaymentAction() : Boolean;
function makePaymentAction() : void;
function getFailRedirectUrl() : String;
function isExternalLoginAllowed() : Boolean;
function hasRatings() : Boolean;
function hasOwnPaymentSystem() : Boolean;
function hasSocialFunction() : Boolean;
function isRunningInside(param1:String) : Boolean;
}
}
|
package alternativa.tanks.utils.objectpool {
public class Pool {
private var numObjects:int;
private var objectClass:Class;
private var objects:Vector.<Object> = new Vector.<Object>();
public function Pool(param1:Class) {
super();
this.objectClass = param1;
}
final public function getNumObjects() : int {
return this.numObjects;
}
final public function getObject() : Object {
if(this.numObjects == 0) {
return new this.objectClass(this);
}
var local1:Object = this.objects[--this.numObjects];
this.objects[this.numObjects] = null;
return local1;
}
final public function putObject(param1:Object) : void {
if(this.objectClass != param1.constructor) {
throw new ArgumentError();
}
var local2:* = this.numObjects++;
this.objects[local2] = param1;
}
final public function clear() : void {
this.objects.length = 0;
this.numObjects = 0;
}
}
}
|
package alternativa.tanks.service.battleinfo {
import alternativa.tanks.controllers.battleinfo.BattleInfoDMController;
import alternativa.tanks.controllers.battleinfo.BattleInfoTeamController;
import alternativa.tanks.controllers.battleinfo.EmptyBattleInfoController;
import alternativa.tanks.controllers.battleinfo.IBattleInfoController;
import alternativa.tanks.model.battle.BattleEntrance;
import alternativa.tanks.tracker.ITrackerService;
import alternativa.tanks.view.battleinfo.BattleInfoViewEvent;
import alternativa.tanks.view.battleinfo.dm.BattleInfoDmParams;
import alternativa.tanks.view.battleinfo.team.BattleInfoTeamParams;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleInfoFormService extends EventDispatcher implements IBattleInfoFormService {
[Inject]
public static var trackerService:ITrackerService;
private static const GA_CATEGORY:String = "lobby";
private static const EMPTY_CONTROLLER:EmptyBattleInfoController = new EmptyBattleInfoController();
private var dmController:BattleInfoDMController;
private var teamController:BattleInfoTeamController;
private var formState:BattleInfoState = BattleInfoState.NONE;
public function BattleInfoFormService() {
super();
}
public function showLastShowedForm() : void {
this.getCurrentBattleInfoController().addFormToStage();
}
public function removeFormFromStage() : void {
this.getCurrentBattleInfoController().removeFormFromStage();
}
public function showDmForm(param1:BattleInfoDmParams) : void {
if(this.dmController == null) {
this.dmController = new BattleInfoDMController();
this.addEventListeners(this.dmController);
}
this.hideForms();
this.dmController.showForm(param1);
this.formState = BattleInfoState.DM_FORM;
}
private function addEventListeners(param1:IBattleInfoController) : void {
param1.addEventListener(BattleInfoViewEvent.ENTER_BATTLE,this.onEnterBattle);
param1.addEventListener(BattleInfoViewEvent.ENTER_SPECTATOR,this.onEnterSpectator);
param1.addEventListener(BattleInfoViewEvent.BUY_PRO_ABONEMENT,this.onBuyAbonement);
}
private function onEnterBattle(param1:BattleInfoViewEvent) : void {
BattleEntrance(this.getSelectedBattle().adapt(BattleEntrance)).fight(param1.team);
trackerService.trackEvent(GA_CATEGORY,"enterBattle",param1.team != null ? "Team" : "DM");
}
public function showTeamForm(param1:BattleInfoTeamParams) : void {
if(this.teamController == null) {
this.teamController = new BattleInfoTeamController();
this.addEventListeners(this.teamController);
}
this.teamController.showForm(param1);
this.formState = BattleInfoState.TEAM_FORM;
}
private function onBuyAbonement(param1:BattleInfoViewEvent) : void {
dispatchEvent(param1.clone());
}
private function onEnterSpectator(param1:BattleInfoViewEvent) : void {
BattleEntrance(this.getSelectedBattle().adapt(BattleEntrance)).enterAsSpectator();
trackerService.trackEvent(GA_CATEGORY,"enterBattle","Spectator");
}
public function hideForms() : void {
this.getCurrentBattleInfoController().hideForm();
this.formState = BattleInfoState.NONE;
}
public function hideBattleForms() : void {
this.getCurrentBattleInfoController().hideForm();
this.formState = BattleInfoState.NONE;
}
public function destroy() : void {
if(this.dmController != null) {
this.removeEventListeners(this.dmController);
this.dmController.destroy();
this.dmController = null;
}
if(this.teamController != null) {
this.removeEventListeners(this.teamController);
this.teamController.destroy();
this.teamController = null;
}
this.formState = BattleInfoState.NONE;
}
private function removeEventListeners(param1:IBattleInfoController) : void {
param1.removeEventListener(BattleInfoViewEvent.ENTER_BATTLE,this.onEnterBattle);
param1.removeEventListener(BattleInfoViewEvent.ENTER_SPECTATOR,this.onEnterSpectator);
param1.removeEventListener(BattleInfoViewEvent.BUY_PRO_ABONEMENT,this.onBuyAbonement);
}
public function updateTeamScore(param1:BattleTeam, param2:int) : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
if(this.formState == BattleInfoState.TEAM_FORM) {
this.teamController.updateTeamScore(param1,param2);
}
}
public function updateBattleName() : void {
this.getCurrentBattleInfoController().updateBattleName();
}
public function removeUser(param1:Long) : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.getCurrentBattleInfoController().removeUser(param1);
}
public function updateUserScore(param1:Long, param2:int) : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.getCurrentBattleInfoController().updateUserScore(param1,param2);
}
public function updateUserSuspiciousState(param1:Long, param2:Boolean) : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.getCurrentBattleInfoController().updateUserSuspiciousState(param1,param2);
}
public function swapTeams() : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.teamController.swapTeams();
}
public function roundStart(param1:int) : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.getCurrentBattleInfoController().roundStart(param1);
}
public function roundFinish() : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.getCurrentBattleInfoController().roundFinish();
}
public function battleStop() : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
this.getCurrentBattleInfoController().battleStop();
}
public function getSelectedBattle() : IGameObject {
return this.getCurrentBattleInfoController().getSelectedBattle();
}
private function getCurrentBattleInfoController() : IBattleInfoController {
switch(this.formState) {
case BattleInfoState.DM_FORM:
return this.dmController;
case BattleInfoState.TEAM_FORM:
return this.teamController;
default:
return EMPTY_CONTROLLER;
}
}
public function addUser(param1:BattleInfoUser, param2:BattleTeam = null) : void {
if(this.isCurrentBattleNotSelected()) {
return;
}
if(param2 == null) {
this.dmController.addUser(param1);
} else {
this.teamController.addUserToTeam(param1,param2);
}
}
private function isCurrentBattleNotSelected() : Boolean {
return Model.object != this.getSelectedBattle();
}
}
}
|
package alternativa.tanks.view {
import alternativa.tanks.view.forms.ViewText;
import org.robotlegs.core.IInjector;
import org.robotlegs.mvcs.Mediator;
public class ViewTextMediator extends Mediator {
[Inject]
public var injector:IInjector;
[Inject]
public var view:ViewText;
public function ViewTextMediator() {
super();
}
override public function onRegister() : void {
this.injector.injectInto(this.view);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.streamweapon {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class StreamWeaponModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:StreamWeaponModelServer;
private var client:IStreamWeaponModelBase = IStreamWeaponModelBase(this);
private var modelId:Long = Long.getLong(479046028,-1680303089);
private var _reconfigureWeaponId:Long = Long.getLong(385050719,606086059);
private var _reconfigureWeapon_dischargeSpeedCodec:ICodec;
public function StreamWeaponModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new StreamWeaponModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(StreamWeaponCC,false)));
this._reconfigureWeapon_dischargeSpeedCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
}
protected function getInitParam() : StreamWeaponCC {
return StreamWeaponCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._reconfigureWeaponId:
this.client.reconfigureWeapon(Number(this._reconfigureWeapon_dischargeSpeedCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.plasma
{
import scpacker.Base;
public class PlasmaShootSFXModelBase extends Base
{
public function PlasmaShootSFXModelBase()
{
super();
}
}
}
|
package alternativa.utils {
import flash.utils.Dictionary;
public function countDictionaryKeys(param1:Dictionary) : int {
var local3:* = undefined;
var local2:int = 0;
for(local3 in param1) {
local2++;
}
return local2;
}
}
|
package alternativa.tanks.models.battle.battlefield {
import alternativa.types.Long;
public interface BattleUserInfoListener {
function userInfoChanged(param1:Long, param2:String, param3:int, param4:Boolean) : void;
function userRankChanged(param1:Long, param2:int) : void;
function userSuspiciousnessChanged(param1:Long, param2:Boolean) : void;
}
}
|
package _codec.projects.tanks.client.garage.models.item.grouped {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.grouped.GroupedCC;
public class VectorCodecGroupedCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecGroupedCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(GroupedCC,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.<GroupedCC> = new Vector.<GroupedCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = GroupedCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:GroupedCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<GroupedCC> = Vector.<GroupedCC>(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.mailru.payment {
public interface IMailruGamesPaymentModelBase {
function receivePaymentTransaction(param1:String, param2:Number, param3:String) : void;
}
}
|
package _codec.projects.tanks.client.battleservice.model.performance {
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.battleservice.model.performance.PerformanceCC;
public class VectorCodecPerformanceCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPerformanceCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PerformanceCC,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.<PerformanceCC> = new Vector.<PerformanceCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PerformanceCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PerformanceCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PerformanceCC> = Vector.<PerformanceCC>(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.panel.model.socialnetwork {
public class SocialNetworkPanelParams {
private var _authorizationUrl:String;
private var _enabled:Boolean;
private var _linkExists:Boolean;
private var _snId:String;
public function SocialNetworkPanelParams(param1:String = null, param2:Boolean = false, param3:Boolean = false, param4:String = null) {
super();
this._authorizationUrl = param1;
this._enabled = param2;
this._linkExists = param3;
this._snId = param4;
}
public function get authorizationUrl() : String {
return this._authorizationUrl;
}
public function set authorizationUrl(param1:String) : void {
this._authorizationUrl = param1;
}
public function get enabled() : Boolean {
return this._enabled;
}
public function set enabled(param1:Boolean) : void {
this._enabled = param1;
}
public function get linkExists() : Boolean {
return this._linkExists;
}
public function set linkExists(param1:Boolean) : void {
this._linkExists = param1;
}
public function get snId() : String {
return this._snId;
}
public function set snId(param1:String) : void {
this._snId = param1;
}
public function toString() : String {
var local1:String = "SocialNetworkPanelParams [";
local1 += "authorizationUrl = " + this.authorizationUrl + " ";
local1 += "enabled = " + this.enabled + " ";
local1 += "linkExists = " + this.linkExists + " ";
local1 += "snId = " + this.snId + " ";
return local1 + "]";
}
}
}
|
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_flagFlashClass.png")]
public class RugbyScoreIndicator_flagFlashClass extends BitmapAsset {
public function RugbyScoreIndicator_flagFlashClass() {
super();
}
}
}
|
package alternativa.tanks.gui.friends {
public interface IRejectAllIncomingButtonEnabled {
function setEnable(param1:Boolean) : void;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.terminator {
import projects.tanks.client.battlefield.models.tankparts.weapon.railgun.RailgunCC;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
public class TerminatorCC {
private var _primaryCC:RailgunCC;
private var _secondaryCC:RocketLauncherCC;
private var _secondaryKickback:Number;
public function TerminatorCC(param1:RailgunCC = null, param2:RocketLauncherCC = null, param3:Number = 0) {
super();
this._primaryCC = param1;
this._secondaryCC = param2;
this._secondaryKickback = param3;
}
public function get primaryCC() : RailgunCC {
return this._primaryCC;
}
public function set primaryCC(param1:RailgunCC) : void {
this._primaryCC = param1;
}
public function get secondaryCC() : RocketLauncherCC {
return this._secondaryCC;
}
public function set secondaryCC(param1:RocketLauncherCC) : void {
this._secondaryCC = param1;
}
public function get secondaryKickback() : Number {
return this._secondaryKickback;
}
public function set secondaryKickback(param1:Number) : void {
this._secondaryKickback = param1;
}
public function toString() : String {
var local1:String = "TerminatorCC [";
local1 += "primaryCC = " + this.primaryCC + " ";
local1 += "secondaryCC = " + this.secondaryCC + " ";
local1 += "secondaryKickback = " + this.secondaryKickback + " ";
return local1 + "]";
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.railgun
{
import scpacker.Base;
public class RailgunModelBase extends Base
{
public function RailgunModelBase()
{
super();
}
}
}
|
package alternativa.tanks.models.weapons.targeting.processor {
import alternativa.math.Vector3;
import alternativa.physics.collision.IRayCollisionFilter;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.shared.MarginalCollider;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
public class CommonDirectionProcessor implements TargetingDirectionProcessor {
[Inject]
public static var battleService:BattleService;
private const COS_ALMOST_ZERO_ANGLE:Number = 0.9999;
private var collisionDetector:TanksCollisionDetector;
private var maxDistance:Number;
private var filter:IRayCollisionFilter;
private var shotFromMuzzle:Boolean = false;
public function CommonDirectionProcessor(param1:Number, param2:IRayCollisionFilter) {
super();
this.maxDistance = param1;
this.filter = param2;
this.collisionDetector = battleService.getBattleRunner().getCollisionDetector();
}
public function setShotFromMuzzle() : void {
this.shotFromMuzzle = true;
}
protected function raycast(param1:Vector3, param2:Vector3, param3:RayHit) : Boolean {
if(this.collisionDetector.raycast(param1,param2,CollisionGroup.WEAPON,this.maxDistance,this.filter,param3)) {
param3.staticHit = !BattleUtils.isTankBody(param3.shape.body) || MarginalCollider.segmentWithStaticIntersection(param1,param3.position);
return true;
}
return false;
}
protected function getOrigin(param1:AllGlobalGunParams, param2:Vector3) : Vector3 {
if(!this.shotFromMuzzle || param2.dot(param1.direction) > this.COS_ALMOST_ZERO_ANGLE) {
return param1.barrelOrigin;
}
return param1.muzzlePosition;
}
public function updateMaxDistance(param1:Number) : void {
this.maxDistance = param1;
}
public function process(param1:AllGlobalGunParams, param2:Vector3) : Vector.<RayHit> {
return undefined;
}
}
}
|
package projects.tanks.client.garage.models.item.drone {
public interface IHasBatteriesNotifyModelBase {
function setHasBatteries(param1:Boolean) : void;
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_nitroGrayIconClass.png")]
public class HudInventoryIcon_nitroGrayIconClass extends BitmapAsset {
public function HudInventoryIcon_nitroGrayIconClass() {
super();
}
}
}
|
package alternativa.tanks.model.quest.common {
import flash.events.IEventDispatcher;
import projects.tanks.client.panel.model.quest.QuestTypeEnum;
public interface MissionsWindowsService extends IEventDispatcher {
function initWindow() : void;
function openInTab(param1:QuestTypeEnum) : void;
function isWindowOpen() : Boolean;
function closeWindow() : void;
}
}
|
package alternativa.engine3d.loaders.collada {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationClip;
import alternativa.engine3d.animation.keys.NumberTrack;
import alternativa.engine3d.animation.keys.Track;
import alternativa.engine3d.animation.keys.TransformTrack;
import alternativa.engine3d.containers.LODContainer;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.objects.BSP;
import alternativa.engine3d.objects.Mesh;
import alternativa.engine3d.objects.Skin;
import alternativa.engine3d.objects.Sprite3D;
import flash.geom.Matrix3D;
import flash.geom.Vector3D;
use namespace collada;
use namespace alternativa3d;
use namespace daeAlternativa3DInstance;
public class DaeNode extends DaeElement {
public var scene:DaeVisualScene;
public var parent:DaeNode;
public var skinOrTopmostJoint:Boolean = false;
public var rootJoint:DaeNode = null;
private var channels:Vector.<DaeChannel>;
private var instanceControllers:Vector.<DaeInstanceController>;
public var nodes:Vector.<DaeNode>;
public var objects:Vector.<DaeObject>;
public var skins:Vector.<DaeObject>;
public function DaeNode(param1:XML, param2:DaeDocument, param3:DaeVisualScene = null, param4:DaeNode = null) {
super(param1,param2);
this.scene = param3;
this.parent = param4;
this.constructNodes();
}
public function get animName() : String {
var local1:String = this.name;
return local1 == null ? this.id : local1;
}
private function constructNodes() : void {
var local4:DaeNode = null;
var local1:XMLList = data.node;
var local2:int = int(local1.length());
this.nodes = new Vector.<DaeNode>(local2);
var local3:int = 0;
while(local3 < local2) {
local4 = new DaeNode(local1[local3],document,this.scene,this);
if(local4.id != null) {
document.nodes[local4.id] = local4;
}
this.nodes[local3] = local4;
local3++;
}
}
internal function registerInstanceControllers() : void {
var local2:int = 0;
var local4:XML = null;
var local5:DaeInstanceController = null;
var local6:Vector.<DaeNode> = null;
var local7:int = 0;
var local8:DaeNode = null;
var local9:int = 0;
var local1:XMLList = data.instance_controller;
var local3:int = int(local1.length());
local2 = 0;
while(local2 < local3) {
this.skinOrTopmostJoint = true;
local4 = local1[local2];
local5 = new DaeInstanceController(local4,document,this);
if(local5.parse()) {
local6 = local5.topmostJoints;
local7 = int(local6.length);
if(local7 > 0) {
local8 = local6[0];
local8.addInstanceController(local5);
if(this.rootJoint == null) {
this.rootJoint = local8;
}
local9 = 0;
while(local9 < local7) {
local6[local9].skinOrTopmostJoint = true;
local9++;
}
}
}
local2++;
}
local3 = int(this.nodes.length);
local2 = 0;
while(local2 < local3) {
this.nodes[local2].registerInstanceControllers();
local2++;
}
}
public function addChannel(param1:DaeChannel) : void {
if(this.channels == null) {
this.channels = new Vector.<DaeChannel>();
}
this.channels.push(param1);
}
public function addInstanceController(param1:DaeInstanceController) : void {
if(this.instanceControllers == null) {
this.instanceControllers = new Vector.<DaeInstanceController>();
}
this.instanceControllers.push(param1);
}
override protected function parseImplementation() : Boolean {
this.skins = this.parseSkins();
this.objects = this.parseObjects();
return true;
}
private function parseInstanceMaterials(param1:XML) : Object {
var local6:DaeInstanceMaterial = null;
var local2:Object = new Object();
var local3:XMLList = param1.bind_material.technique_common.instance_material;
var local4:int = 0;
var local5:int = int(local3.length());
while(local4 < local5) {
local6 = new DaeInstanceMaterial(local3[local4],document);
local2[local6.symbol] = local6;
local4++;
}
return local2;
}
public function getNodeBySid(param1:String) : DaeNode {
var local5:int = 0;
var local6:Vector.<Vector.<DaeNode>> = null;
var local7:Vector.<DaeNode> = null;
var local8:int = 0;
var local9:int = 0;
var local10:DaeNode = null;
if(param1 == this.sid) {
return this;
}
var local2:Vector.<Vector.<DaeNode>> = new Vector.<Vector.<DaeNode>>();
var local3:Vector.<Vector.<DaeNode>> = new Vector.<Vector.<DaeNode>>();
local2.push(this.nodes);
var local4:int = int(local2.length);
while(local4 > 0) {
local5 = 0;
while(local5 < local4) {
local7 = local2[local5];
local8 = int(local7.length);
local9 = 0;
while(local9 < local8) {
local10 = local7[local9];
if(local10.sid == param1) {
return local10;
}
if(local10.nodes.length > 0) {
local3.push(local10.nodes);
}
local9++;
}
local5++;
}
local6 = local2;
local2 = local3;
local3 = local6;
local3.length = 0;
local4 = int(local2.length);
}
return null;
}
public function parseSkins() : Vector.<DaeObject> {
var local4:DaeInstanceController = null;
var local5:DaeObject = null;
var local6:Skin = null;
var local7:BSP = null;
var local8:DaeObject = null;
if(this.instanceControllers == null) {
return null;
}
var local1:Vector.<DaeObject> = new Vector.<DaeObject>();
var local2:int = 0;
var local3:int = int(this.instanceControllers.length);
while(local2 < local3) {
local4 = this.instanceControllers[local2];
local4.parse();
local5 = local4.parseSkin(this.parseInstanceMaterials(local4.data));
if(local5 != null) {
local6 = Skin(local5.object);
local6.name = local4.node.name;
if(this.isAlternativa3DObject(local4.node)) {
this.updateAlternativa3DMesh(local4.node,local6,local5);
if(local6.sorting == 3) {
local7 = new BSP();
local7.name = local6.name;
local7.splitAnalysis = local6.alternativa3d::transformId > 0;
local7.createTree(local6,true);
local8 = this.applyAnimation(this.applyTransformations(local7));
local8.isSplitter = local5.isSplitter;
local8.isStaticGeometry = local5.isStaticGeometry;
local1.push(local8);
} else {
if(local6.sorting == Sorting.DYNAMIC_BSP && local6.alternativa3d::transformId > 0) {
local6.optimizeForDynamicBSP();
}
local1.push(local5);
}
} else {
local1.push(local5);
}
}
local2++;
}
return local1.length > 0 ? local1 : null;
}
public function parseObjects() : Vector.<DaeObject> {
var local3:int = 0;
var local4:int = 0;
var local5:DaeObject = null;
var local6:XML = null;
var local7:DaeLight = null;
var local8:DaeGeometry = null;
var local9:Light3D = null;
var local10:Matrix3D = null;
var local11:Mesh = null;
var local12:DaeObject = null;
var local13:BSP = null;
var local1:Vector.<DaeObject> = new Vector.<DaeObject>();
if(this.isAlternativa3DObject(this)) {
local5 = this.parseAlternativa3DObject();
if(local5 != null) {
local1.push(local5);
}
}
var local2:XMLList = data.children();
local3 = 0;
local4 = int(local2.length());
while(local3 < local4) {
local6 = local2[local3];
switch(local6.localName()) {
case "instance_light":
local7 = document.findLight(local6.@url[0]);
if(local7 != null) {
local9 = local7.parseLight();
if(local9 != null) {
local9.name = name;
if(local7.revertDirection) {
local10 = new Matrix3D();
local10.appendRotation(180,Vector3D.X_AXIS);
local1.push(new DaeObject(this.applyTransformations(local9,local10)));
} else {
local1.push(this.applyAnimation(this.applyTransformations(local9)));
}
}
} else {
document.logger.logNotFoundError(local6.@url[0]);
}
break;
case "instance_geometry":
local8 = document.findGeometry(local6.@url[0]);
if(local8 != null) {
local8.parse();
local11 = local8.parseMesh(this.parseInstanceMaterials(local6));
if(local11 != null) {
local11.name = name;
local12 = this.applyAnimation(this.applyTransformations(local11));
if(this.isAlternativa3DObject(this)) {
this.updateAlternativa3DMesh(this,local11,local12);
if(local11.sorting == 3) {
local13 = new BSP();
local13.splitAnalysis = local11.alternativa3d::transformId > 0;
local13.createTree(local11,true);
local13.name = local11.name;
local13.matrix = local11.matrix;
local12.object = local13;
} else if(local11.sorting == Sorting.DYNAMIC_BSP && local11.alternativa3d::transformId > 0) {
local11.optimizeForDynamicBSP();
}
}
local1.push(local12);
}
} else {
document.logger.logNotFoundError(local6.@url[0]);
}
break;
case "instance_node":
document.logger.logInstanceNodeError(local6);
break;
}
local3++;
}
return local1.length > 0 ? local1 : null;
}
private function getMatrix(param1:Matrix3D = null) : Matrix3D {
var local3:Array = null;
var local6:XML = null;
var local7:XML = null;
var local2:Matrix3D = param1 == null ? new Matrix3D() : param1;
var local4:XMLList = data.children();
var local5:int = local4.length() - 1;
for(; local5 >= 0; local5--) {
local6 = local4[local5];
local7 = local6.@sid[0];
if(local7 != null && local7.toString() == "post-rotationY") {
continue;
}
switch(local6.localName()) {
case "scale":
local3 = parseNumbersArray(local6);
local2.appendScale(local3[0],local3[1],local3[2]);
break;
case "rotate":
local3 = parseNumbersArray(local6);
local2.appendRotation(local3[3],new Vector3D(local3[0],local3[1],local3[2]));
break;
case "translate":
local3 = parseNumbersArray(local6);
local2.appendTranslation(local3[0],local3[1],local3[2]);
break;
case "matrix":
local3 = parseNumbersArray(local6);
local2.append(new Matrix3D(Vector.<Number>([local3[0],local3[4],local3[8],local3[12],local3[1],local3[5],local3[9],local3[13],local3[2],local3[6],local3[10],local3[14],local3[3],local3[7],local3[11],local3[15]])));
break;
case "lookat":
break;
case "skew":
document.logger.logSkewError(local6);
break;
}
}
return local2;
}
public function applyTransformations(param1:Object3D, param2:Matrix3D = null, param3:Matrix3D = null) : Object3D {
var local4:Matrix3D = null;
if(param3 != null) {
local4 = this.getMatrix(param2);
local4.append(param3);
param1.matrix = local4;
} else {
param1.matrix = this.getMatrix(param2);
}
return param1;
}
private function isAlternativa3DObject(param1:DaeNode) : Boolean {
var node:DaeNode = param1;
return node.data.extra.technique.(@profile == "Alternativa3D")[0] != null;
}
private function parseAlternativa3DObject() : DaeObject {
var techniqueXML:XML = null;
var profile:XML = null;
var containerXML:XML = null;
var spriteXML:XML = null;
var lodXML:XML = null;
var daeContainer:DaeAlternativa3DObject = null;
var container:Object3DContainer = null;
var daeSprite:DaeAlternativa3DObject = null;
var sprite:Sprite3D = null;
var material:DaeMaterial = null;
var daeLod:DaeAlternativa3DObject = null;
var lod:LODContainer = null;
techniqueXML = data.extra.technique.(@profile == "Alternativa3D")[0];
profile = techniqueXML.instance[0];
if(profile != null) {
containerXML = profile.instance_container[0];
if(containerXML != null) {
daeContainer = document.findAlternativa3DObject(containerXML.@url[0]);
if(daeContainer != null) {
container = daeContainer.parseContainer(name);
return container != null ? this.applyAnimation(this.applyTransformations(container)) : null;
}
document.logger.logNotFoundError(containerXML.@url[0]);
}
spriteXML = profile.instance_sprite[0];
if(spriteXML != null) {
daeSprite = document.findAlternativa3DObject(spriteXML.@url[0]);
if(daeSprite != null) {
material = document.findMaterial(spriteXML.instance_material.@target[0]);
if(material != null) {
material.parse();
material.used = true;
sprite = daeSprite.parseSprite3D(name,material.material);
} else {
sprite = daeSprite.parseSprite3D(name);
}
return sprite != null ? this.applyAnimation(this.applyTransformations(sprite)) : null;
}
document.logger.logNotFoundError(spriteXML.@url[0]);
}
lodXML = profile.instance_lod[0];
if(lodXML != null) {
daeLod = document.findAlternativa3DObject(lodXML.@url[0]);
if(daeLod != null) {
lod = daeLod.parseLOD(name,this);
return lod != null ? this.applyAnimation(this.applyTransformations(lod)) : null;
}
document.logger.logNotFoundError(lodXML.@url[0]);
}
}
return null;
}
private function updateAlternativa3DMesh(param1:DaeNode, param2:Mesh, param3:DaeObject) : void {
var techniqueXML:XML = null;
var profile:XML = null;
var meshXML:XML = null;
var daeMesh:DaeAlternativa3DObject = null;
var node:DaeNode = param1;
var mesh:Mesh = param2;
var daeObject:DaeObject = param3;
techniqueXML = node.data.extra.technique.(@profile == "Alternativa3D")[0];
profile = techniqueXML.instance[0];
if(profile != null) {
meshXML = profile.instance_mesh[0];
if(meshXML != null) {
daeMesh = document.findAlternativa3DObject(meshXML.@url[0]);
daeMesh.parse();
if(daeMesh != null) {
daeMesh.applyA3DMeshProperties(mesh);
daeObject.isSplitter = daeMesh.isSplitter;
daeObject.isStaticGeometry = daeMesh.isBaseGeometry;
} else {
document.logger.logNotFoundError(meshXML.@url[0]);
}
}
}
}
public function applyAnimation(param1:Object3D) : DaeObject {
var local2:AnimationClip = this.parseAnimation(param1);
if(local2 == null) {
return new DaeObject(param1);
}
param1.name = this.animName;
local2.attach(param1,false);
return new DaeObject(param1,local2);
}
public function parseAnimation(param1:Object3D = null) : AnimationClip {
if(this.channels == null || !this.hasTransformationAnimation()) {
return null;
}
var local2:DaeChannel = this.getChannel(DaeChannel.PARAM_MATRIX);
if(local2 != null) {
return this.createClip(local2.tracks);
}
var local3:AnimationClip = new AnimationClip();
var local4:Vector.<Vector3D> = param1 != null ? null : this.getMatrix().decompose();
local2 = this.getChannel(DaeChannel.PARAM_TRANSLATE);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local2 = this.getChannel(DaeChannel.PARAM_TRANSLATE_X);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("x",param1 == null ? local4[0].x : param1.x));
}
local2 = this.getChannel(DaeChannel.PARAM_TRANSLATE_Y);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("y",param1 == null ? local4[0].y : param1.y));
}
local2 = this.getChannel(DaeChannel.PARAM_TRANSLATE_Z);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("z",param1 == null ? local4[0].z : param1.z));
}
}
local2 = this.getChannel(DaeChannel.PARAM_ROTATION_X);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("rotationX",param1 == null ? local4[1].x : param1.rotationX));
}
local2 = this.getChannel(DaeChannel.PARAM_ROTATION_Y);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("rotationY",param1 == null ? local4[1].y : param1.rotationY));
}
local2 = this.getChannel(DaeChannel.PARAM_ROTATION_Z);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("rotationZ",param1 == null ? local4[1].z : param1.rotationZ));
}
local2 = this.getChannel(DaeChannel.PARAM_SCALE);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local2 = this.getChannel(DaeChannel.PARAM_SCALE_X);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("scaleX",param1 == null ? local4[2].x : param1.scaleX));
}
local2 = this.getChannel(DaeChannel.PARAM_SCALE_Y);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("scaleY",param1 == null ? local4[2].y : param1.scaleY));
}
local2 = this.getChannel(DaeChannel.PARAM_SCALE_Z);
if(local2 != null) {
this.addTracksToClip(local3,local2.tracks);
} else {
local3.addTrack(this.createValueStaticTrack("scaleZ",param1 == null ? local4[2].z : param1.scaleZ));
}
}
if(local3.numTracks > 0) {
return local3;
}
return null;
}
private function createClip(param1:Vector.<Track>) : AnimationClip {
var local2:AnimationClip = new AnimationClip();
var local3:int = 0;
var local4:int = int(param1.length);
while(local3 < local4) {
local2.addTrack(param1[local3]);
local3++;
}
return local2;
}
private function addTracksToClip(param1:AnimationClip, param2:Vector.<Track>) : void {
var local3:int = 0;
var local4:int = int(param2.length);
while(local3 < local4) {
param1.addTrack(param2[local3]);
local3++;
}
}
private function hasTransformationAnimation() : Boolean {
var local3:DaeChannel = null;
var local4:Boolean = false;
var local1:int = 0;
var local2:int = int(this.channels.length);
while(local1 < local2) {
local3 = this.channels[local1];
local3.parse();
local4 = local3.animatedParam == DaeChannel.PARAM_MATRIX;
local4 ||= local3.animatedParam == DaeChannel.PARAM_TRANSLATE;
local4 ||= local3.animatedParam == DaeChannel.PARAM_TRANSLATE_X;
local4 ||= local3.animatedParam == DaeChannel.PARAM_TRANSLATE_Y;
local4 ||= local3.animatedParam == DaeChannel.PARAM_TRANSLATE_Z;
local4 ||= local3.animatedParam == DaeChannel.PARAM_ROTATION_X;
local4 ||= local3.animatedParam == DaeChannel.PARAM_ROTATION_Y;
local4 ||= local3.animatedParam == DaeChannel.PARAM_ROTATION_Z;
local4 ||= local3.animatedParam == DaeChannel.PARAM_SCALE;
local4 ||= local3.animatedParam == DaeChannel.PARAM_SCALE_X;
local4 ||= local3.animatedParam == DaeChannel.PARAM_SCALE_Y;
local4 ||= local3.animatedParam == DaeChannel.PARAM_SCALE_Z;
if(local4) {
return true;
}
local1++;
}
return false;
}
private function getChannel(param1:String) : DaeChannel {
var local4:DaeChannel = null;
var local2:int = 0;
var local3:int = int(this.channels.length);
while(local2 < local3) {
local4 = this.channels[local2];
local4.parse();
if(local4.animatedParam == param1) {
return local4;
}
local2++;
}
return null;
}
private function concatTracks(param1:Vector.<Track>, param2:Vector.<Track>) : void {
var local3:int = 0;
var local4:int = int(param1.length);
while(local3 < local4) {
param2.push(param1[local3]);
local3++;
}
}
private function createValueStaticTrack(param1:String, param2:Number) : Track {
var local3:NumberTrack = new NumberTrack(this.animName,param1);
local3.addKey(0,param2);
return local3;
}
public function createStaticTransformTrack() : TransformTrack {
var local1:TransformTrack = new TransformTrack(this.animName);
local1.addKey(0,this.getMatrix());
return local1;
}
public function get layer() : String {
var local1:XML = data.@layer[0];
return local1 == null ? null : local1.toString();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.laser {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public interface ILaserPointerModelBase {
function aimRemoteAtTank(param1:IGameObject, param2:Vector3d) : void;
function hideRemote() : void;
function updateRemoteDirection(param1:Number) : void;
}
}
|
package alternativa.tanks.JPGencoder
{
public class BitString
{
public var len:int = 0;
public var val:int = 0;
public function BitString()
{
super();
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
public class RedShopItemSkin extends ButtonItemSkin {
private static const normalStateClass:Class = RedShopItemSkin_normalStateClass;
private static const overStateClass:Class = RedShopItemSkin_overStateClass;
public function RedShopItemSkin() {
super();
normalState = new normalStateClass().bitmapData;
overState = new overStateClass().bitmapData;
}
}
}
|
package org1.osflash.signals {
public interface ISignal {
function getValueClasses() : Array;
function setValueClasses(param1:Array) : void;
function getNumListeners() : uint;
function addOnce(param1:Function) : ISlot;
function add(param1:Function) : ISlot;
function dispatch(... rest) : void;
function remove(param1:Function) : ISlot;
function removeAll() : void;
}
}
|
package alternativa.tanks.models.controlpoints.hud.marker {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.controlpoints.hud.marker.MarkerBitmaps_letters.png")]
public class MarkerBitmaps_letters extends BitmapAsset {
public function MarkerBitmaps_letters() {
super();
}
}
}
|
package alternativa.tanks.model.payment.modes.paygarden {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.payment.modes.paygarden.PayGardenProductType;
public class PayGardenPaymentEvents implements PayGardenPayment {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PayGardenPaymentEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getProductType() : PayGardenProductType {
var result:PayGardenProductType = null;
var i:int = 0;
var m:PayGardenPayment = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayGardenPayment(this.impl[i]);
result = m.getProductType();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapon.machinegun.sfx {
import alternativa.math.Vector3;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
public class SmokeParticle extends Particle {
private var _rotation:Number;
private var _initialZ:Number;
private var _sprite:AnimatedSprite3D = new AnimatedSprite3D(1,1);
public function SmokeParticle(param1:Pool) {
super(param1);
SFXUtils.setEffectParams(this._sprite);
}
public function init(param1:Number, param2:Vector3, param3:Number, param4:TextureAnimation) : void {
this._sprite.width = param1;
this._sprite.height = param1;
this._sprite.setAnimationData(param4);
this._sprite.x = param2.x;
this._sprite.y = param2.y;
this._sprite.z = param2.z;
this._sprite.rotation = param3;
this._rotation = param3;
this._initialZ = param2.z;
}
public function get sprite() : AnimatedSprite3D {
return this._sprite;
}
public function get rotation() : Number {
return this._rotation;
}
public function get initialZ() : Number {
return this._initialZ;
}
}
}
|
package alternativa.tanks.model.quest.common.gui.greenpanel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.common.gui.greenpanel.GreenPanelBitmaps_LEFT_BOTTOM_CORNER_BITMAP.png")]
public class GreenPanelBitmaps_LEFT_BOTTOM_CORNER_BITMAP extends BitmapAsset {
public function GreenPanelBitmaps_LEFT_BOTTOM_CORNER_BITMAP() {
super();
}
}
}
|
package controls.base {
import flash.utils.setTimeout;
import forms.ColorConstants;
public class PasswordInput extends TankInputBase {
public function PasswordInput() {
super();
}
override public function set enable(param1:Boolean) : void {
super.enable = param1;
setTimeout(this.setTextColor,0);
}
private function setTextColor() : void {
textField.textColor = textField.selectable ? ColorConstants.WHITE : ColorConstants.INPUT_DISABLED;
}
}
}
|
package assets.combo {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.combo.combo_UP_LEFT.png")]
public dynamic class combo_UP_LEFT extends BitmapData {
public function combo_UP_LEFT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.panel.model.shop.kitview {
import platform.client.fp10.core.resource.types.ImageResource;
public class KitViewResourceCC {
private var _buttonKit:ImageResource;
private var _buttonKitOver:ImageResource;
public function KitViewResourceCC(param1:ImageResource = null, param2:ImageResource = null) {
super();
this._buttonKit = param1;
this._buttonKitOver = param2;
}
public function get buttonKit() : ImageResource {
return this._buttonKit;
}
public function set buttonKit(param1:ImageResource) : void {
this._buttonKit = param1;
}
public function get buttonKitOver() : ImageResource {
return this._buttonKitOver;
}
public function set buttonKitOver(param1:ImageResource) : void {
this._buttonKitOver = param1;
}
public function toString() : String {
var local1:String = "KitViewResourceCC [";
local1 += "buttonKit = " + this.buttonKit + " ";
local1 += "buttonKitOver = " + this.buttonKitOver + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.user.resistance {
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.user.resistance.TankResistance;
public class VectorCodecTankResistanceLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTankResistanceLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TankResistance,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.<TankResistance> = new Vector.<TankResistance>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TankResistance(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TankResistance = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TankResistance> = Vector.<TankResistance>(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.engine3d.loaders.events {
import flash.events.Event;
public class LoaderEvent extends Event {
public static const PART_OPEN:String = "partOpen";
public static const PART_COMPLETE:String = "partComplete";
private var _partsTotal:int;
private var _currentPart:int;
private var _target:Object;
public function LoaderEvent(param1:String, param2:int, param3:int, param4:Object = null) {
super(param1);
this._partsTotal = param2;
this._currentPart = param3;
this._target = param4;
}
public function get partsTotal() : int {
return this._partsTotal;
}
public function get currentPart() : int {
return this._currentPart;
}
override public function get target() : Object {
return this._target;
}
override public function clone() : Event {
return new LoaderEvent(type,this._partsTotal,this._currentPart,this._target);
}
override public function toString() : String {
return "[LoaderEvent type=" + type + ", partsTotal=" + this._partsTotal + ", currentPart=" + this._currentPart + ", target=" + this._target + "]";
}
}
}
|
package _codec.projects.tanks.client.commons.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
public class VectorCodecItemViewCategoryEnumLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecItemViewCategoryEnumLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(ItemViewCategoryEnum,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.<ItemViewCategoryEnum> = new Vector.<ItemViewCategoryEnum>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ItemViewCategoryEnum(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ItemViewCategoryEnum = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ItemViewCategoryEnum> = Vector.<ItemViewCategoryEnum>(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.protocol.codec
{
import alternativa.protocol.factory.ICodecFactory;
import alternativa.protocol.type.Short;
import alternativa.resource.ResourceInfo;
import alternativa.types.Long;
import flash.utils.IDataInput;
public class ResourceCodec extends AbstractCodec
{
private var codecFactory:ICodecFactory;
public function ResourceCodec(codecFactory:ICodecFactory)
{
super();
this.codecFactory = codecFactory;
}
override protected function doDecode(reader:IDataInput, nullmap:NullMap, notnull:Boolean) : Object
{
var id:Long = Long(this.codecFactory.getCodec(Long).decode(reader,nullmap,true));
var version:Long = Long(this.codecFactory.getCodec(Long).decode(reader,nullmap,true));
var type:int = int(this.codecFactory.getCodec(Short).decode(reader,nullmap,true));
var isOptional:Boolean = Boolean(this.codecFactory.getCodec(Boolean).decode(reader,nullmap,true));
return new ResourceInfo(id,version,type,isOptional);
}
}
}
|
package alternativa.tanks.model.item.resistance.view {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.item.resistance.view.ResistanceButton_mountedBGIconClass.png")]
public class ResistanceButton_mountedBGIconClass extends BitmapAsset {
public function ResistanceButton_mountedBGIconClass() {
super();
}
}
}
|
package projects.tanks.client.garage.models.item.rarity {
public class Rarity {
public static const CUSTOMISE:Rarity = new Rarity(0,"CUSTOMISE");
public static const LEGENDARY:Rarity = new Rarity(1,"LEGENDARY");
public static const EPIC:Rarity = new Rarity(2,"EPIC");
public static const RARE:Rarity = new Rarity(3,"RARE");
public static const CASUAL:Rarity = new Rarity(4,"CASUAL");
private var _value:int;
private var _name:String;
public function Rarity(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<Rarity> {
var local1:Vector.<Rarity> = new Vector.<Rarity>();
local1.push(CUSTOMISE);
local1.push(LEGENDARY);
local1.push(EPIC);
local1.push(RARE);
local1.push(CASUAL);
return local1;
}
public function toString() : String {
return "Rarity [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.grouplifecycle.invite {
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 MatchmakingGroupInviteModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _acceptId:Long = Long.getLong(431621756,-755546185);
private var _accept_senderIdCodec:ICodec;
private var _rejectId:Long = Long.getLong(431621756,-1244296928);
private var _reject_senderIdCodec:ICodec;
private var _sendInviteId:Long = Long.getLong(136598198,490692750);
private var _sendInvite_receiverCodec:ICodec;
private var model:IModel;
public function MatchmakingGroupInviteModelServer(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._accept_senderIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._reject_senderIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._sendInvite_receiverCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function accept(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._accept_senderIdCodec.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._acceptId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function reject(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._reject_senderIdCodec.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._rejectId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function sendInvite(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._sendInvite_receiverCodec.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._sendInviteId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.weapon.streamweapon {
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapon.streamweapon.IStreamWeaponModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapon.streamweapon.StreamWeaponCC;
import projects.tanks.client.battlefield.models.tankparts.weapon.streamweapon.StreamWeaponModelBase;
[ModelInfo]
public class StreamWeaponModel extends StreamWeaponModelBase implements IStreamWeaponModelBase, IStreamWeaponModel, ObjectLoadListener {
public function StreamWeaponModel() {
super();
}
public function objectLoaded() : void {
var local1:StreamWeaponCC = getInitParam();
var local2:StreamWeaponData = new StreamWeaponData(local1.energyCapacity,local1.energyDischargeSpeed,local1.energyRechargeSpeed,local1.weaponTickIntervalMsec);
putData(StreamWeaponData,local2);
}
public function getStreamWeaponData() : StreamWeaponData {
return StreamWeaponData(getData(StreamWeaponData));
}
public function reconfigureWeapon(param1:Number) : void {
StreamWeaponData(getData(StreamWeaponData)).setEnergyDischargeSpeed(param1);
var local2:StreamWeaponReconfiguredListener = StreamWeaponReconfiguredListener(object.event(StreamWeaponReconfiguredListener));
var local3:IGameObject = IWeaponCommonModel(object.adapt(IWeaponCommonModel)).getTank().user;
local2.streamWeaponReconfigured(local3,param1);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p6 extends BitmapAsset
{
public function RangIconNormal_p6()
{
super();
}
}
}
|
package alternativa.osgi.service.storage
{
import flash.net.SharedObject;
public interface IStorageService
{
function getStorage() : SharedObject;
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_28 extends BitmapAsset
{
public function BigRangIcon_rang_28()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.battleinvite {
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
public class BattleInviteMessage {
private var _availableSlot:Boolean;
private var _battleData:BattleInfoData;
public function BattleInviteMessage(param1:Boolean = false, param2:BattleInfoData = null) {
super();
this._availableSlot = param1;
this._battleData = param2;
}
public function get availableSlot() : Boolean {
return this._availableSlot;
}
public function set availableSlot(param1:Boolean) : void {
this._availableSlot = param1;
}
public function get battleData() : BattleInfoData {
return this._battleData;
}
public function set battleData(param1:BattleInfoData) : void {
this._battleData = param1;
}
public function toString() : String {
var local1:String = "BattleInviteMessage [";
local1 += "availableSlot = " + this.availableSlot + " ";
local1 += "battleData = " + this.battleData + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.view {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
import projects.tanks.client.garage.models.item.view.ItemViewCategoryCC;
public class CodecItemViewCategoryCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_category:ICodec;
public function CodecItemViewCategoryCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_category = param1.getCodec(new EnumCodecInfo(ItemViewCategoryEnum,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ItemViewCategoryCC = new ItemViewCategoryCC();
local2.category = this.codec_category.decode(param1) as ItemViewCategoryEnum;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ItemViewCategoryCC = ItemViewCategoryCC(param2);
this.codec_category.encode(param1,local3.category);
}
}
}
|
package platform.client.models.commons.description {
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 DescriptionModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:DescriptionModelServer;
private var client:IDescriptionModelBase = IDescriptionModelBase(this);
private var modelId:Long = Long.getLong(916213531,-841295065);
public function DescriptionModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new DescriptionModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(DescriptionModelCC,false)));
}
protected function getInitParam() : DescriptionModelCC {
return DescriptionModelCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.shop.items.base
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RedShopItemSkin_overStateClass extends BitmapAsset
{
public function RedShopItemSkin_overStateClass()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.upgradeable.types {
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class PropertyData {
private var _finalValue:Number;
private var _initialValue:Number;
private var _property:ItemProperty;
public function PropertyData(param1:Number = 0, param2:Number = 0, param3:ItemProperty = null) {
super();
this._finalValue = param1;
this._initialValue = param2;
this._property = param3;
}
public function get finalValue() : Number {
return this._finalValue;
}
public function set finalValue(param1:Number) : void {
this._finalValue = param1;
}
public function get initialValue() : Number {
return this._initialValue;
}
public function set initialValue(param1:Number) : void {
this._initialValue = param1;
}
public function get property() : ItemProperty {
return this._property;
}
public function set property(param1:ItemProperty) : void {
this._property = param1;
}
public function toString() : String {
var local1:String = "PropertyData [";
local1 += "finalValue = " + this.finalValue + " ";
local1 += "initialValue = " + this.initialValue + " ";
local1 += "property = " + this.property + " ";
return local1 + "]";
}
}
}
|
package utils {
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import flash.geom.Matrix;
import flash.geom.Rectangle;
import flash.text.TextField;
import flash.text.TextFormat;
public class TextUtils {
public function TextUtils() {
super();
}
public static function getTextInCells(param1:TextField, param2:int, param3:int, param4:uint = 52224, param5:Number = 0.5, param6:int = 1) : BitmapData {
var local14:Rectangle = null;
var local15:int = 0;
var local16:int = 0;
var local7:TextFormat = param1.getTextFormat();
var local8:Object = local7.letterSpacing;
local7.letterSpacing = 4;
param1.setTextFormat(local7);
var local9:int = param1.text.length;
var local10:BitmapData = new BitmapData(param2 * local9,param3,true,16777215);
var local11:Shape = new Shape();
local11.graphics.lineStyle(param6,param4,param5);
local11.graphics.drawRect(0,0,local9 * param2 - param6,param3 - param6);
var local12:int = 1;
while(local12 < local9) {
local11.graphics.moveTo(local12 * param2,0);
local11.graphics.lineTo(local12 * param2,param3);
local12++;
}
local10.draw(local11);
var local13:Matrix = new Matrix();
local12 = 0;
while(local12 < local9) {
local14 = param1.getCharBoundaries(local12);
local14.width -= 4;
local15 = Math.round((param2 - local14.width) * 0.5);
local16 = Math.round((param3 - local14.height) * 0.5);
local13.tx = -local14.x + local12 * param2 + local15;
local13.ty = -local14.y + local16;
local10.draw(param1,local13,null,BlendMode.NORMAL,new Rectangle(local12 * param2 + local15,local14.y + local16,local14.width + 1,local14.height),true);
local12++;
}
local7.letterSpacing = local8;
param1.setTextFormat(local7);
return local10;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.layout {
import projects.tanks.client.commons.models.layout.LayoutState;
public interface ILobbyLayoutService extends LobbyLayoutServiceBase {
function showGarage() : void;
function showBattleSelect() : void;
function showMatchmaking() : void;
function showBattleLobby() : void;
function isSwitchInProgress() : Boolean;
function getCurrentState() : LayoutState;
function exitFromGame() : void;
function exitFromBattle() : void;
function exitFromBattleToState(param1:LayoutState) : void;
function isWindowOpenOverBattle() : Boolean;
function closePopupOverBattle() : void;
function showClan() : void;
function returnToBattle() : void;
function isBattleReady() : Boolean;
function setBattleReady(param1:Boolean) : void;
}
}
|
package alternativa.tanks.controllers.battlelist {
import alternativa.types.Long;
import flash.events.Event;
public class BattleByURLNotFoundEvent extends Event {
public static const BATTLE_BY_URL_NOT_FOUND:String = "BattleListControllerEvent.BATTLE_BY_URL_NOT_FOUND";
public var battleId:Long;
public function BattleByURLNotFoundEvent(param1:String, param2:Long, param3:Boolean = false, param4:Boolean = false) {
super(param1,param3,param4);
this.battleId = param2;
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p15 extends BitmapAsset
{
public function RangIcon_p15()
{
super();
}
}
}
|
package alternativa.tanks.gui.shopitems.item.kits.description.panel
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class KitPackageDescriptionPanelBitmaps_bitmapLeftLine extends BitmapAsset
{
public function KitPackageDescriptionPanelBitmaps_bitmapLeftLine()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.freeze {
public class FreezeEffectsParams {
public static const PLANE_LENGTH:int = 350;
public static const PLANE_WIDTH:int = 210;
public static const PARTICLE_START_SIZE:Number = 75;
public static const PARTICLE_END_SIZE:Number = 450;
public static const PARTICLE_MUZZLE_OFFSET:Number = 90;
public static const PARTICLE_MUZZLE_RANDOM_OFFSET:Number = 40;
public static const PARTICLE_SPEED_PER_DISTANCE_METER:Number = 100;
public static const SOUND_VOLUME:Number = 1;
public static const FIRE_LIGHT_OFFSET:int = 1500;
public function FreezeEffectsParams() {
super();
}
}
}
|
package projects.tanks.client.partners.impl.steam {
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 SteamPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _finalizePaymentId:Long = Long.getLong(1195670366,541831155);
private var _finalizePayment_orderIdCodec:ICodec;
private var _makePaymentRequestId:Long = Long.getLong(2094962292,-1380873068);
private var _makePaymentRequest_shopItemIdCodec:ICodec;
private var model:IModel;
public function SteamPaymentModelServer(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._finalizePayment_orderIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._makePaymentRequest_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function finalizePayment(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._finalizePayment_orderIdCodec.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._finalizePaymentId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function makePaymentRequest(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._makePaymentRequest_shopItemIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._makePaymentRequestId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.model.payment.modes.paypal {
import platform.client.fp10.core.type.IGameObject;
public class PayPalPaymentEvents implements PayPalPayment {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PayPalPaymentEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
}
}
|
package alternativa.osgi {
public class ServiceParamNames {
public static const PARAM_NAME:String = "name";
public function ServiceParamNames() {
super();
}
}
}
|
package alternativa.tanks.service.country {
import alternativa.tanks.service.country.event.ChooseCountryForPaymentEvent;
import alternativa.tanks.service.country.event.UserPaymentCountryChangedEvent;
import flash.events.EventDispatcher;
import projects.tanks.client.panel.model.usercountry.CountryInfo;
import projects.tanks.client.panel.model.usercountry.UserCountryCC;
public class CountryServiceImpl extends EventDispatcher implements CountryService {
private var registeredCountries:Vector.<CountryInfo>;
private var defaultCountry:String;
public function CountryServiceImpl() {
super();
}
public function initService(param1:UserCountryCC) : void {
this.registeredCountries = param1.countries;
this.defaultCountry = param1.defaultCountryCode;
}
public function getRegisteredCountries() : Vector.<CountryInfo> {
return this.registeredCountries;
}
public function getDefaultCountryCode() : String {
return this.defaultCountry;
}
public function setDefaultCountryCode(param1:String) : void {
this.defaultCountry = param1;
}
public function changeCountry(param1:String) : void {
this.defaultCountry = param1;
dispatchEvent(new UserPaymentCountryChangedEvent(UserPaymentCountryChangedEvent.USER_PAYMENT_COUNTRY_CHANGED,param1));
}
public function chooseCountryForPayment() : void {
dispatchEvent(new ChooseCountryForPaymentEvent());
}
}
}
|
package alternativa.tanks.servermodels.objectdetach {
import alternativa.tanks.loader.ILoaderWindowService;
import projects.tanks.client.entrance.model.entrance.objectdetach.EntranceObjectDetachModelBase;
import projects.tanks.client.entrance.model.entrance.objectdetach.IEntranceObjectDetachModelBase;
[ModelInfo]
public class EntranceObjectDetachModel extends EntranceObjectDetachModelBase implements IEntranceObjectDetachModelBase {
[Inject]
public static var loaderWindowService:ILoaderWindowService;
public function EntranceObjectDetachModel() {
super();
}
public function objectDetach() : void {
loaderWindowService.show();
}
}
}
|
package alternativa.tanks.models.weapon.ricochet {
import alternativa.tanks.battle.objects.tank.Weapon;
public interface IRicochetWeapon extends Weapon {
function setBuffedMode(param1:Boolean) : void;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher {
import flash.events.Event;
public class DialogWindowsDispatcherServiceEvent extends Event {
public static const OPEN:String = "DialogWindowsDispatcherServiceEvent.OPEN";
public static const CLOSE:String = "DialogWindowsDispatcherServiceEvent.CLOSE";
public static const FORCIBLY_CLOSE:String = "DialogWindowsDispatcherServiceEvent.FORCIBLY_CLOSE";
public function DialogWindowsDispatcherServiceEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package scpacker.test.spectator
{
import alternativa.tanks.camera.CameraBookmark;
import alternativa.tanks.camera.CameraBookmarks;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
public class BookmarksHandler implements KeyboardHandler
{
private var bookmarks:Object;
private var bookmarkKeys:Dictionary;
private var controller:SpectatorCameraController;
public function BookmarksHandler(param1:SpectatorCameraController)
{
this.bookmarks = new CameraBookmarks(10);
this.bookmarkKeys = new Dictionary();
super();
this.controller = param1;
this.initKeyMap();
}
public function handleKeyDown(param1:KeyboardEvent) : void
{
var _loc2_:* = this.bookmarkKeys[param1.keyCode];
if(_loc2_ != null)
{
if(param1.ctrlKey)
{
this.saveCurrentPositionCameraToBookmark(_loc2_);
}
else
{
this.goToBookmark(_loc2_);
}
}
}
public function handleKeyUp(param1:KeyboardEvent) : void
{
}
private function initKeyMap() : void
{
this.bookmarkKeys[Keyboard.NUMBER_0] = 0;
this.bookmarkKeys[Keyboard.NUMBER_1] = 1;
this.bookmarkKeys[Keyboard.NUMBER_2] = 2;
this.bookmarkKeys[Keyboard.NUMBER_3] = 3;
this.bookmarkKeys[Keyboard.NUMBER_4] = 4;
this.bookmarkKeys[Keyboard.NUMBER_5] = 5;
this.bookmarkKeys[Keyboard.NUMBER_6] = 6;
this.bookmarkKeys[Keyboard.NUMBER_7] = 7;
this.bookmarkKeys[Keyboard.NUMBER_8] = 8;
this.bookmarkKeys[Keyboard.NUMBER_9] = 9;
}
private function saveCurrentPositionCameraToBookmark(param1:int) : void
{
this.bookmarks.saveCurrentPositionCameraToBookmark(param1);
}
private function goToBookmark(param1:int) : void
{
var _loc2_:CameraBookmark = this.bookmarks.getBookmark(param1);
if(_loc2_ != null)
{
this.controller.setCameraState(_loc2_.position,_loc2_.eulerAnlges);
}
}
}
}
|
package alternativa.resource.loaders
{
import alternativa.engine3d.loaders.events.LoaderEvent;
import alternativa.engine3d.loaders.events.LoaderProgressEvent;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.display.BlendMode;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.net.URLRequest;
import flash.system.LoaderContext;
[Event(name="open",type="flash.events.Event")]
[Event(name="complete",type="flash.events.Event")]
[Event(name="ioError",type="flash.events.IOErrorEvent")]
[Event(name="partOpen",type="alternativa.engine3d.loaders.events.LoaderEvent")]
[Event(name="partComplete",type="alternativa.engine3d.loaders.events.LoaderEvent")]
[Event(name="loaderProgress",type="alternativa.engine3d.loaders.events.LoaderProgressEvent")]
public class TextureLoader extends EventDispatcher
{
private static const IDLE:int = -1;
private static const LOADING_DIFFUSE_MAP:int = 0;
private static const LOADING_ALPHA_MAP:int = 1;
private var state:int = -1;
private var bitmapLoader:Loader;
private var loaderContext:LoaderContext;
private var alphaTextureUrl:String;
private var _bitmapData:BitmapData;
public function TextureLoader()
{
super();
}
public function get bitmapData() : BitmapData
{
return this._bitmapData;
}
public function load(diffuseTextureUrl:String, alphaTextureUrl:String = null, loaderContext:LoaderContext = null) : void
{
this.unload();
this.alphaTextureUrl = alphaTextureUrl == "" ? null : alphaTextureUrl;
this.loaderContext = loaderContext;
this.loadPart(LOADING_DIFFUSE_MAP,diffuseTextureUrl);
}
public function close() : void
{
if(this.state == IDLE)
{
return;
}
this.state = IDLE;
this.bitmapLoader.unload();
this.destroyLoader();
this.alphaTextureUrl = null;
this.loaderContext = null;
}
public function unload() : void
{
this.close();
this._bitmapData = null;
}
private function cleanup() : void
{
this.destroyLoader();
this.alphaTextureUrl = null;
this.loaderContext = null;
}
private function loadPart(state:int, url:String) : void
{
this.state = state;
this.createLoader();
this.bitmapLoader.load(new URLRequest(url),this.loaderContext);
}
private function onPartLoadingOpen(e:Event) : void
{
if(this._bitmapData == null && hasEventListener(Event.OPEN))
{
dispatchEvent(new Event(Event.OPEN));
}
if(hasEventListener(LoaderEvent.PART_OPEN))
{
dispatchEvent(new LoaderEvent(LoaderEvent.PART_OPEN,2,this.state == LOADING_DIFFUSE_MAP ? int(int(0)) : int(int(1))));
}
}
private function onPartLoadingProgress(e:ProgressEvent) : void
{
var partNumber:int = 0;
var totalProgress:Number = NaN;
if(hasEventListener(LoaderProgressEvent.LOADER_PROGRESS))
{
partNumber = this.state == LOADING_DIFFUSE_MAP ? int(int(0)) : int(int(1));
totalProgress = 0.5 * (partNumber + e.bytesLoaded / e.bytesTotal);
dispatchEvent(new LoaderProgressEvent(LoaderProgressEvent.LOADER_PROGRESS,2,partNumber,totalProgress,e.bytesLoaded,e.bytesTotal));
}
}
private function onPartLoadingComplete(e:Event) : void
{
var pt:Point = null;
var tmpBmd:BitmapData = null;
var alpha:BitmapData = null;
switch(this.state)
{
case LOADING_DIFFUSE_MAP:
this._bitmapData = Bitmap(this.bitmapLoader.content).bitmapData;
this.destroyLoader();
this.dispatchPartComplete(0);
if(this.alphaTextureUrl != null)
{
this.loadPart(LOADING_ALPHA_MAP,this.alphaTextureUrl);
}
else
{
this.complete();
}
break;
case LOADING_ALPHA_MAP:
pt = new Point();
tmpBmd = this._bitmapData;
this._bitmapData = new BitmapData(this._bitmapData.width,this._bitmapData.height);
this._bitmapData.copyPixels(tmpBmd,tmpBmd.rect,pt);
alpha = Bitmap(this.bitmapLoader.content).bitmapData;
this.destroyLoader();
if(this._bitmapData.width != alpha.width || this._bitmapData.height != alpha.height)
{
tmpBmd.draw(alpha,new Matrix(this._bitmapData.width / alpha.width,0,0,this._bitmapData.height / alpha.height),null,BlendMode.NORMAL,null,true);
alpha.dispose();
alpha = tmpBmd;
}
else
{
tmpBmd.dispose();
}
this._bitmapData.copyChannel(alpha,alpha.rect,pt,BitmapDataChannel.RED,BitmapDataChannel.ALPHA);
alpha.dispose();
this.dispatchPartComplete(1);
this.complete();
}
}
private function dispatchPartComplete(partNumber:int) : void
{
if(hasEventListener(LoaderEvent.PART_COMPLETE))
{
dispatchEvent(new LoaderEvent(LoaderEvent.PART_COMPLETE,2,partNumber));
}
}
private function onLoadError(e:Event) : void
{
this.state = IDLE;
this.cleanup();
dispatchEvent(e);
}
private function complete() : void
{
this.state = IDLE;
this.cleanup();
if(hasEventListener(Event.COMPLETE))
{
dispatchEvent(new Event(Event.COMPLETE));
}
}
private function createLoader() : void
{
this.bitmapLoader = new Loader();
var loaderInfo:LoaderInfo = this.bitmapLoader.contentLoaderInfo;
loaderInfo.addEventListener(Event.OPEN,this.onPartLoadingOpen);
loaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onPartLoadingProgress);
loaderInfo.addEventListener(Event.COMPLETE,this.onPartLoadingComplete);
loaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadError);
}
private function destroyLoader() : void
{
if(this.bitmapLoader == null)
{
return;
}
this.bitmapLoader.unload();
var loaderInfo:LoaderInfo = this.bitmapLoader.contentLoaderInfo;
loaderInfo.removeEventListener(Event.OPEN,this.onPartLoadingOpen);
loaderInfo.removeEventListener(ProgressEvent.PROGRESS,this.onPartLoadingProgress);
loaderInfo.removeEventListener(Event.COMPLETE,this.onPartLoadingComplete);
loaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,this.onLoadError);
this.bitmapLoader = null;
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _c0770b9dde448958634fa1986f750b79051e3cfa4c50db1d7c7c1616031ad2c8_flash_display_Sprite extends Sprite {
public function _c0770b9dde448958634fa1986f750b79051e3cfa4c50db1d7c7c1616031ad2c8_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package alternativa.tanks.gui.socialnetwork.ok {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.socialnetwork.ok.OkGroupThanksForEnteringWindow_thanksForEnteringBitmapDataClass.png")]
public class OkGroupThanksForEnteringWindow_thanksForEnteringBitmapDataClass extends BitmapAsset {
public function OkGroupThanksForEnteringWindow_thanksForEnteringBitmapDataClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.flamethrower {
import platform.client.fp10.core.type.IGameObject;
public interface IFlameThrowerModelBase {
function startFire(param1:IGameObject) : void;
function stopFire(param1:IGameObject) : void;
}
}
|
package projects.tanks.client.entrance.model.entrance.registration {
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 RegistrationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _checkUidId:Long = Long.getLong(458412608,-1323112141);
private var _checkUid_uidCodec:ICodec;
private var _registerId:Long = Long.getLong(458412513,903980216);
private var _register_userUidCodec:ICodec;
private var _register_passwordCodec:ICodec;
private var _register_registeredUrlCodec:ICodec;
private var _register_rememberMeCodec:ICodec;
private var _register_referralHashCodec:ICodec;
private var _register_realNameCodec:ICodec;
private var _register_idNumberCodec:ICodec;
private var _setFormerUserIdId:Long = Long.getLong(709671785,692586324);
private var _setFormerUserId_formerUserIdCodec:ICodec;
private var model:IModel;
public function RegistrationModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._checkUid_uidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._register_userUidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._register_passwordCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._register_registeredUrlCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._register_rememberMeCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._register_referralHashCodec = this.protocol.getCodec(new TypeCodecInfo(String,true));
this._register_realNameCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._register_idNumberCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._setFormerUserId_formerUserIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function checkUid(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._checkUid_uidCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._checkUidId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function register(param1:String, param2:String, param3:String, param4:Boolean, param5:String, param6:String, param7:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._register_userUidCodec.encode(this.protocolBuffer,param1);
this._register_passwordCodec.encode(this.protocolBuffer,param2);
this._register_registeredUrlCodec.encode(this.protocolBuffer,param3);
this._register_rememberMeCodec.encode(this.protocolBuffer,param4);
this._register_referralHashCodec.encode(this.protocolBuffer,param5);
this._register_realNameCodec.encode(this.protocolBuffer,param6);
this._register_idNumberCodec.encode(this.protocolBuffer,param7);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local8:SpaceCommand = new SpaceCommand(Model.object.id,this._registerId,this.protocolBuffer);
var local9:IGameObject = Model.object;
var local10:ISpace = local9.space;
local10.commandSender.sendCommand(local8);
this.protocolBuffer.optionalMap.clear();
}
public function setFormerUserId(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._setFormerUserId_formerUserIdCodec.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._setFormerUserIdId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.effects.activationsfx {
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.effects.activationsfx.EffectSFXRecordCC;
public class VectorCodecEffectSFXRecordCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecEffectSFXRecordCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(EffectSFXRecordCC,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.<EffectSFXRecordCC> = new Vector.<EffectSFXRecordCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = EffectSFXRecordCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:EffectSFXRecordCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<EffectSFXRecordCC> = Vector.<EffectSFXRecordCC>(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.tankparts.weapons.machinegun.cc {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.cc.MachineGunCC;
public class CodecMachineGunCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_spinDownTime:ICodec;
private var codec_spinUpTime:ICodec;
private var codec_started:ICodec;
private var codec_state:ICodec;
private var codec_temperatureHittingTime:ICodec;
private var codec_weaponTurnDecelerationCoeff:ICodec;
public function CodecMachineGunCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_spinDownTime = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_spinUpTime = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_started = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_state = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_temperatureHittingTime = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_weaponTurnDecelerationCoeff = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:MachineGunCC = new MachineGunCC();
local2.spinDownTime = this.codec_spinDownTime.decode(param1) as int;
local2.spinUpTime = this.codec_spinUpTime.decode(param1) as int;
local2.started = this.codec_started.decode(param1) as Boolean;
local2.state = this.codec_state.decode(param1) as Number;
local2.temperatureHittingTime = this.codec_temperatureHittingTime.decode(param1) as int;
local2.weaponTurnDecelerationCoeff = this.codec_weaponTurnDecelerationCoeff.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:MachineGunCC = MachineGunCC(param2);
this.codec_spinDownTime.encode(param1,local3.spinDownTime);
this.codec_spinUpTime.encode(param1,local3.spinUpTime);
this.codec_started.encode(param1,local3.started);
this.codec_state.encode(param1,local3.state);
this.codec_temperatureHittingTime.encode(param1,local3.temperatureHittingTime);
this.codec_weaponTurnDecelerationCoeff.encode(param1,local3.weaponTurnDecelerationCoeff);
}
}
}
|
package assets.windowinner.elemets {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol1307")]
public class WindowInnerBlink extends MovieClip {
public function WindowInnerBlink() {
super();
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.miniplay {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.forms.GoToUrlForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.modes.asyncurl.AsyncUrlPayMode;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import flash.external.ExternalInterface;
import mx.utils.StringUtil;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.partners.impl.miniplay.IMiniplayPaymentModelBase;
import projects.tanks.client.partners.impl.miniplay.MiniplayPaymentModelBase;
[ModelInfo]
public class MiniplayPaymentModel extends MiniplayPaymentModelBase implements IMiniplayPaymentModelBase, AsyncUrlPayMode, ObjectLoadListener, PayModeView, ObjectUnloadListener {
[Inject]
public static var paymentWindowService:PaymentWindowService;
public function MiniplayPaymentModel() {
super();
}
public function requestAsyncUrl() : void {
server.getPaymentData(paymentWindowService.getChosenItem().id);
}
public function receivePaymentData(param1:int, param2:String, param3:String, param4:String) : void {
if(ExternalInterface.available) {
ExternalInterface.call("showMiniplayPayment",StringUtil.substitute("{0}|{1}||{2}|{3}",param1,param2,param3,param4));
}
paymentWindowService.switchToBeginning();
}
public function getView() : PayModeForm {
return PayModeForm(getData(PayModeForm));
}
public function objectLoaded() : void {
putData(PayModeForm,new GoToUrlForm(object));
}
public function objectUnloaded() : void {
this.getView().destroy();
clearData(PayModeForm);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.gpu {
[ModelInterface]
public interface GPUDetector {
function detectGPUCapabilities() : void;
}
}
|
package projects.tanks.client.partners.impl.miniplay {
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 MiniplayPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getPaymentDataId:Long = Long.getLong(1694971044,1893806763);
private var _getPaymentData_shopItemIdCodec:ICodec;
private var model:IModel;
public function MiniplayPaymentModelServer(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._getPaymentData_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function getPaymentData(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getPaymentData_shopItemIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._getPaymentDataId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank23.png")]
public class DefaultRanksBitmaps_bitmapBigRank23 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank23() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.renameshopitem {
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 RenameShopItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RenameShopItemModelServer(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 scpacker.resource.tanks
{
import flash.utils.Dictionary;
public class TankResourceList
{
public var models:Dictionary;
public function TankResourceList()
{
super();
this.models = new Dictionary();
}
public function add(model:TankResource) : void
{
if(this.models[model.id] == null)
{
if(model.mesh == null)
{
throw new Error("Model null!");
}
this.models[model.id] = model;
}
else
{
trace("Model arleady registered!");
}
}
public function getModel(key:String) : TankResource
{
return this.models[key];
}
}
}
|
package projects.tanks.client.chat.osgi {
import _codec.projects.tanks.client.chat.models.chat.chat.CodecChatAddressMode;
import _codec.projects.tanks.client.chat.models.chat.chat.CodecChatCC;
import _codec.projects.tanks.client.chat.models.chat.chat.VectorCodecChatAddressModeLevel1;
import _codec.projects.tanks.client.chat.models.chat.chat.VectorCodecChatCCLevel1;
import _codec.projects.tanks.client.chat.models.chat.users.personalmessagereceiver.CodecPersonalMessageReceiveMode;
import _codec.projects.tanks.client.chat.models.chat.users.personalmessagereceiver.VectorCodecPersonalMessageReceiveModeLevel1;
import _codec.projects.tanks.client.chat.models.clanchat.clanchat.CodecClanChatCC;
import _codec.projects.tanks.client.chat.models.clanchat.clanchat.VectorCodecClanChatCCLevel1;
import _codec.projects.tanks.client.chat.models.news.showing.CodecNewsItemData;
import _codec.projects.tanks.client.chat.models.news.showing.CodecNewsShowingCC;
import _codec.projects.tanks.client.chat.models.news.showing.VectorCodecNewsItemDataLevel1;
import _codec.projects.tanks.client.chat.models.news.showing.VectorCodecNewsShowingCCLevel1;
import _codec.projects.tanks.client.chat.types.CodecBattleChatLink;
import _codec.projects.tanks.client.chat.types.CodecChatMessage;
import _codec.projects.tanks.client.chat.types.CodecMessageType;
import _codec.projects.tanks.client.chat.types.CodecUserStatus;
import _codec.projects.tanks.client.chat.types.VectorCodecBattleChatLinkLevel1;
import _codec.projects.tanks.client.chat.types.VectorCodecChatMessageLevel1;
import _codec.projects.tanks.client.chat.types.VectorCodecMessageTypeLevel1;
import _codec.projects.tanks.client.chat.types.VectorCodecUserStatusLevel1;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.chat.models.chat.chat.ChatAddressMode;
import projects.tanks.client.chat.models.chat.chat.ChatCC;
import projects.tanks.client.chat.models.chat.users.personalmessagereceiver.PersonalMessageReceiveMode;
import projects.tanks.client.chat.models.clanchat.clanchat.ClanChatCC;
import projects.tanks.client.chat.models.news.showing.NewsItemData;
import projects.tanks.client.chat.models.news.showing.NewsShowingCC;
import projects.tanks.client.chat.types.BattleChatLink;
import projects.tanks.client.chat.types.ChatMessage;
import projects.tanks.client.chat.types.MessageType;
import projects.tanks.client.chat.types.UserStatus;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var local4:ICodec = null;
osgi = param1;
var local2:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local2.register(Long.getLong(1413646454,-1397687631),Long.getLong(798714808,-1771953585));
local2.register(Long.getLong(1413646454,-1397687631),Long.getLong(978360780,-904735215));
local2.register(Long.getLong(1413646454,-1397687631),Long.getLong(613975441,130861697));
local2.register(Long.getLong(207484105,-2003218757),Long.getLong(1427006127,1489654476));
local2.register(Long.getLong(207484105,-2003218757),Long.getLong(485375957,-1291947355));
local2.register(Long.getLong(202181824,-248161435),Long.getLong(364381846,-771941222));
local2.register(Long.getLong(202181824,-248161435),Long.getLong(73337788,-905524322));
var local3:IProtocol = IProtocol(osgi.getService(IProtocol));
local4 = new CodecChatAddressMode();
local3.registerCodec(new EnumCodecInfo(ChatAddressMode,false),local4);
local3.registerCodec(new EnumCodecInfo(ChatAddressMode,true),new OptionalCodecDecorator(local4));
local4 = new CodecChatCC();
local3.registerCodec(new TypeCodecInfo(ChatCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ChatCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecPersonalMessageReceiveMode();
local3.registerCodec(new EnumCodecInfo(PersonalMessageReceiveMode,false),local4);
local3.registerCodec(new EnumCodecInfo(PersonalMessageReceiveMode,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanChatCC();
local3.registerCodec(new TypeCodecInfo(ClanChatCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanChatCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecNewsItemData();
local3.registerCodec(new TypeCodecInfo(NewsItemData,false),local4);
local3.registerCodec(new TypeCodecInfo(NewsItemData,true),new OptionalCodecDecorator(local4));
local4 = new CodecNewsShowingCC();
local3.registerCodec(new TypeCodecInfo(NewsShowingCC,false),local4);
local3.registerCodec(new TypeCodecInfo(NewsShowingCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecBattleChatLink();
local3.registerCodec(new TypeCodecInfo(BattleChatLink,false),local4);
local3.registerCodec(new TypeCodecInfo(BattleChatLink,true),new OptionalCodecDecorator(local4));
local4 = new CodecChatMessage();
local3.registerCodec(new TypeCodecInfo(ChatMessage,false),local4);
local3.registerCodec(new TypeCodecInfo(ChatMessage,true),new OptionalCodecDecorator(local4));
local4 = new CodecMessageType();
local3.registerCodec(new EnumCodecInfo(MessageType,false),local4);
local3.registerCodec(new EnumCodecInfo(MessageType,true),new OptionalCodecDecorator(local4));
local4 = new CodecUserStatus();
local3.registerCodec(new TypeCodecInfo(UserStatus,false),local4);
local3.registerCodec(new TypeCodecInfo(UserStatus,true),new OptionalCodecDecorator(local4));
local4 = new VectorCodecChatAddressModeLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ChatAddressMode,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ChatAddressMode,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecChatAddressModeLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ChatAddressMode,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ChatAddressMode,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecChatCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecChatCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecPersonalMessageReceiveModeLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(PersonalMessageReceiveMode,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(PersonalMessageReceiveMode,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecPersonalMessageReceiveModeLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(PersonalMessageReceiveMode,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(PersonalMessageReceiveMode,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanChatCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanChatCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanChatCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanChatCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanChatCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanChatCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecNewsItemDataLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsItemData,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsItemData,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecNewsItemDataLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsItemData,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsItemData,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecNewsShowingCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsShowingCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsShowingCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecNewsShowingCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsShowingCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsShowingCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleChatLinkLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleChatLink,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleChatLink,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleChatLinkLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleChatLink,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleChatLink,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecChatMessageLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatMessage,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatMessage,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecChatMessageLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatMessage,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ChatMessage,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMessageTypeLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MessageType,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MessageType,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMessageTypeLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MessageType,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MessageType,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecUserStatusLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserStatus,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserStatus,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecUserStatusLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserStatus,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserStatus,true),true,1),new OptionalCodecDecorator(local4));
}
public function stop(param1:OSGi) : void {
}
}
}
|
package alternativa.tanks.models.weapon.shared.shot
{
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.shot.IShotModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.shot.ShotModelBase;
public class ShotModel extends ShotModelBase implements IShotModelBase, IShot
{
public function ShotModel()
{
super();
_interfaces.push(IModel,IShotModelBase,IShot);
}
public function initObject(clientObject:ClientObject, autoAimingAngleDown:Number, autoAimingAngleUp:Number, reloadMsec:int) : void
{
var data:ShotData = new ShotData(reloadMsec);
data.autoAimingAngleDown.value = autoAimingAngleDown;
data.numRaysDown.value = 2 * 180 * autoAimingAngleDown / Math.PI;
data.autoAimingAngleUp.value = autoAimingAngleUp;
data.numRaysUp.value = 2 * 180 * autoAimingAngleUp / Math.PI;
clientObject.putParams(ShotModel,data);
}
public function getShotData(clientObject:ClientObject) : ShotData
{
return clientObject.getParams(ShotModel) as ShotData;
}
}
}
|
package alternativa.tanks.models.battlefield.gamemode
{
import alternativa.tanks.model.panel.IBattleSettings;
import alternativa.tanks.models.battlefield.BattleView3D;
import flash.display.BitmapData;
public class DefaultGameModel implements IGameMode
{
public function DefaultGameModel()
{
super();
}
public function applyChanges(viewport:BattleView3D) : void
{
viewport.camera.useLight = false;
viewport.camera.useShadowMap = false;
viewport.camera.deferredLighting = false;
}
public function applyChangesBeforeSettings(settings:IBattleSettings) : void
{
}
public function applyColorchangesToSkybox(skybox:BitmapData) : BitmapData
{
return skybox;
}
}
}
|
package alternativa.tanks.models.tank.ultimate.hunter.stun {
import alternativa.tanks.battle.objects.tank.Tank;
[ModelInterface]
public interface UltimateStunListener {
function onStun(param1:Tank, param2:Boolean) : void;
function onCalm(param1:Tank, param2:Boolean, param3:int) : void;
}
}
|
package alternativa.tanks.gui.category {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.category.ItemCategoryButton_resistanceIconClass.png")]
public class ItemCategoryButton_resistanceIconClass extends BitmapAsset {
public function ItemCategoryButton_resistanceIconClass() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.drone {
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
public class IDroneModelEvents implements IDroneModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IDroneModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function initDrones(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var i:int = 0;
var m:IDroneModel = null;
var tank:Tank = param1;
var isLocal:Boolean = param2;
var logicState:TankLogicState = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IDroneModel(this.impl[i]);
m.initDrones(tank,isLocal,logicState);
i++;
}
}
finally {
Model.popObject();
}
}
public function canOverheal() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IDroneModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IDroneModel(this.impl[i]);
result = Boolean(m.canOverheal());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapons.targeting {
import alternativa.math.Vector3;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleUtils;
public class TargetingResult {
private var direction:Vector3 = new Vector3();
private var staticHit:RayHit;
private var hits:Vector.<RayHit>;
public function TargetingResult() {
super();
}
public function hasStaticHit() : Boolean {
return this.staticHit != null;
}
public function getStaticHit() : RayHit {
return this.staticHit;
}
public function getDirection() : Vector3 {
return this.direction;
}
public function getHits() : Vector.<RayHit> {
return this.hits;
}
public function hasTankHit() : Boolean {
return this.hits.length > 0;
}
public function hasAnyHit() : Boolean {
return this.staticHit != null || this.hits.length > 0;
}
public function setData(param1:Vector3, param2:Vector.<RayHit>) : void {
var local3:RayHit = null;
this.direction.copy(param1);
this.hits = param2.concat();
this.staticHit = null;
if(this.hits.length > 0) {
local3 = this.hits[this.hits.length - 1];
if(!BattleUtils.isTankBody(local3.shape.body)) {
this.staticHit = this.hits.pop();
}
}
}
public function getSingleHit() : RayHit {
if(this.staticHit != null) {
return this.staticHit;
}
return this.hits[0];
}
}
}
|
package _codec.projects.tanks.client.panel.model.profile.rename {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.profile.rename.AndroidRenameCC;
public class CodecAndroidRenameCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_renameEnabled:ICodec;
public function CodecAndroidRenameCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_renameEnabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:AndroidRenameCC = new AndroidRenameCC();
local2.renameEnabled = this.codec_renameEnabled.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:AndroidRenameCC = AndroidRenameCC(param2);
this.codec_renameEnabled.encode(param1,local3.renameEnabled);
}
}
}
|
package alternativa.tanks.models.weapons.targeting.direction.sector.splitter {
import alternativa.tanks.models.weapons.targeting.direction.sector.TargetingSector;
public class SortedTargetingSectors {
private var orderByRight:Vector.<TargetingSector> = new Vector.<TargetingSector>();
private var orderByDistance:Vector.<TargetingSector> = new Vector.<TargetingSector>();
public function SortedTargetingSectors() {
super();
}
public function clear() : void {
this.orderByRight.length = 0;
this.orderByDistance.length = 0;
}
public function getOrderedByDistance() : Vector.<TargetingSector> {
return this.orderByDistance;
}
public function getRight() : Number {
var local1:TargetingSector = this.orderByRight[0];
return local1.getRight();
}
public function isEmpty() : Boolean {
return this.orderByRight.length == 0;
}
public function add(param1:TargetingSector) : void {
var local2:Number = NaN;
var local3:TargetingSector = null;
var local4:TargetingSector = null;
local2 = 0;
while(local2 < this.orderByRight.length) {
local3 = this.orderByRight[local2];
if(param1.getRight() < local3.getRight()) {
break;
}
local2++;
}
this.orderByRight.splice(local2,0,param1);
local2 = 0;
while(local2 < this.orderByDistance.length) {
local4 = this.orderByDistance[local2];
if(param1.getDistance() < local4.getDistance()) {
break;
}
local2++;
}
this.orderByDistance.splice(local2,0,param1);
}
public function removeSectorsWhichRightCoordIsLessOrEqualThan(param1:Number) : void {
var local2:TargetingSector = null;
while(this.orderByRight.length > 0) {
local2 = TargetingSector(this.orderByRight[0]);
if(local2.getRight() > param1) {
break;
}
this.removeSector(this.orderByRight[0]);
}
}
private function removeSector(param1:TargetingSector) : void {
this.removeElement(this.orderByRight,param1);
this.removeElement(this.orderByDistance,param1);
}
private function removeElement(param1:Vector.<TargetingSector>, param2:TargetingSector) : void {
param1.splice(param1.indexOf(param2),1);
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IRailgunSFXModelEvents implements IRailgunSFXModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IRailgunSFXModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getEffects() : IRailgunEffects {
var result:IRailgunEffects = null;
var i:int = 0;
var m:IRailgunSFXModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IRailgunSFXModel(this.impl[i]);
result = m.getEffects();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battlefield.gui.statistics.field
{
public class CTFScoreIndicatorBlinker
{
public var values:Vector.<Number>;
private var maxValue:Number;
private var minValue:Number;
private var intervals:Vector.<int>;
private var speedCoeffs:Vector.<Number>;
private var numValues:int;
private var speeds:Vector.<Number>;
private var switchTimes:Vector.<int>;
private var valueDelta:Number;
private var runCount:int = 0;
public function CTFScoreIndicatorBlinker(minValue:Number, maxValue:Number, intervals:Vector.<int>, speedCoeffs:Vector.<Number>)
{
super();
this.minValue = minValue;
this.maxValue = maxValue;
this.intervals = intervals;
this.speedCoeffs = speedCoeffs;
this.valueDelta = maxValue - minValue;
this.numValues = intervals.length;
this.speeds = new Vector.<Number>(this.numValues);
this.switchTimes = new Vector.<int>(this.numValues);
this.values = new Vector.<Number>(this.numValues);
}
public function start(now:int) : void
{
if(this.runCount == 0)
{
this.init(now);
}
++this.runCount;
}
public function stop() : void
{
--this.runCount;
}
public function update(now:int, delta:int) : void
{
if(this.runCount <= 0)
{
return;
}
for(var i:int = 0; i < this.numValues; i++)
{
this.values[i] += this.speeds[i] * delta;
if(this.values[i] > this.maxValue)
{
this.values[i] = this.maxValue;
}
if(this.values[i] < this.minValue)
{
this.values[i] = this.minValue;
}
if(now >= this.switchTimes[i])
{
this.switchTimes[i] += this.intervals[i];
if(this.speeds[i] < 0)
{
this.speeds[i] = this.getSpeed(1,this.speedCoeffs[i],this.intervals[i]);
}
else
{
this.speeds[i] = this.getSpeed(-1,this.speedCoeffs[i],this.intervals[i]);
}
}
}
}
private function init(now:int) : void
{
for(var i:int = 0; i < this.numValues; i++)
{
this.speeds[i] = this.getSpeed(-1,this.speedCoeffs[i],this.intervals[i]);
this.values[i] = this.maxValue;
this.switchTimes[i] = now + this.intervals[i];
}
}
private function getSpeed(direction:Number, speedCoeff:Number, interval:int) : Number
{
return direction * speedCoeff * this.valueDelta / interval;
}
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class SendNewPasswordAndEmailToChangeEvent extends Event {
public static const SEND:String = "SendNewPasswordAndEmailToChangeEvent.SEND";
public var password:String;
public var email:String;
public function SendNewPasswordAndEmailToChangeEvent(param1:String, param2:String) {
this.password = param1;
this.email = param2;
super(SEND);
}
override public function clone() : Event {
return new SendNewPasswordAndEmailToChangeEvent(this.password,this.email);
}
}
}
|
package alternativa.engine3d.loaders.collada {
import alternativa.engine3d.materials.FillMaterial;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
use namespace collada;
public class DaeEffect extends DaeElement {
private var effectParams:Object;
private var commonParams:Object;
private var techniqueParams:Object;
private var diffuse:DaeEffectParam;
private var emission:DaeEffectParam;
private var transparent:DaeEffectParam;
private var transparency:DaeEffectParam;
public function DaeEffect(param1:XML, param2:DaeDocument) {
super(param1,param2);
this.constructImages();
}
private function constructImages() : void {
var local2:XML = null;
var local3:DaeImage = null;
var local1:XMLList = data..image;
for each(local2 in local1) {
local3 = new DaeImage(local2,document);
if(local3.id != null) {
document.images[local3.id] = local3;
}
}
}
override protected function parseImplementation() : Boolean {
var shader:XML;
var element:XML = null;
var param:DaeParam = null;
var technique:XML = null;
var transparentXML:XML = null;
var transparencyXML:XML = null;
var emissionXML:XML = null;
var diffuseXML:XML = null;
this.effectParams = new Object();
for each(element in data.newparam) {
param = new DaeParam(element,document);
this.effectParams[param.sid] = param;
}
this.commonParams = new Object();
for each(element in data.profile_COMMON.newparam) {
param = new DaeParam(element,document);
this.commonParams[param.sid] = param;
}
this.techniqueParams = new Object();
technique = data.profile_COMMON.technique[0];
if(technique != null) {
for each(element in technique.newparam) {
param = new DaeParam(element,document);
this.techniqueParams[param.sid] = param;
}
}
shader = data.profile_COMMON.technique.*.(localName() == "constant" || localName() == "lambert" || localName() == "phong" || localName() == "blinn")[0];
if(shader != null) {
if(shader.localName() == "constant") {
emissionXML = shader.emission[0];
if(emissionXML != null) {
this.emission = new DaeEffectParam(emissionXML,this);
}
} else {
diffuseXML = shader.diffuse[0];
if(diffuseXML != null) {
this.diffuse = new DaeEffectParam(diffuseXML,this);
}
}
transparentXML = shader.transparent[0];
if(transparentXML != null) {
this.transparent = new DaeEffectParam(transparentXML,this);
}
transparencyXML = shader.transparency[0];
if(transparencyXML != null) {
this.transparency = new DaeEffectParam(transparencyXML,this);
}
}
return true;
}
internal function getParam(param1:String, param2:Object) : DaeParam {
var local3:DaeParam = param2[param1];
if(local3 != null) {
return local3;
}
local3 = this.techniqueParams[param1];
if(local3 != null) {
return local3;
}
local3 = this.commonParams[param1];
if(local3 != null) {
return local3;
}
return this.effectParams[param1];
}
private function float4ToUint(param1:Array, param2:Boolean = true) : uint {
var local6:uint = 0;
var local3:uint = param1[0] * 255;
var local4:uint = param1[1] * 255;
var local5:uint = param1[2] * 255;
if(param2) {
local6 = param1[3] * 255;
return local6 << 24 | local3 << 16 | local4 << 8 | local5;
}
return local3 << 16 | local4 << 8 | local5;
}
public function getMaterial(param1:Object) : Material {
var local3:Array = null;
var local4:FillMaterial = null;
var local5:Number = NaN;
var local6:DaeImage = null;
var local7:DaeParam = null;
var local8:TextureMaterial = null;
var local9:DaeImage = null;
var local2:DaeEffectParam = this.diffuse != null ? this.diffuse : this.emission;
if(local2 != null) {
local3 = local2.getColor(param1);
if(local3 != null) {
local4 = new FillMaterial(this.float4ToUint(local3,false),local3[3]);
if(this.transparency != null) {
local5 = this.transparency.getFloat(param1);
if(!isNaN(local5)) {
local4.alpha = local5;
}
}
return local4;
}
local6 = local2.getImage(param1);
if(local6 != null) {
local7 = local2.getSampler(param1);
local8 = new TextureMaterial();
local8.repeat = local7 == null ? true : local7.wrap_s == null || local7.wrap_s == "WRAP";
local8.diffuseMapURL = local6.init_from;
local9 = this.transparent == null ? null : this.transparent.getImage(param1);
if(local9 != null) {
local8.opacityMapURL = local9.init_from;
}
return local8;
}
}
return null;
}
public function get diffuseTexCoords() : String {
return this.diffuse == null && this.emission == null ? null : (this.diffuse != null ? this.diffuse.texCoord : this.emission.texCoord);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p12 extends BitmapAsset
{
public function RangIconNormal_p12()
{
super();
}
}
}
|
package alternativa.tanks.models.weapons.targeting.priority.targeting {
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.shared.CommonTargetEvaluator;
import alternativa.tanks.models.weapon.shared.RailgunTargetEvaluator;
public class PenetratingTargetPriorityCalculator implements TargetPriorityCalculator {
[Inject]
public static var battleService:BattleService;
private const COMMON_PRIORITY_WEIGHT:Number = 0.000001;
private const FULL_DAMAGE_DISTANCE:Number = 10000;
private var commonTargetEvaluator:CommonTargetEvaluator;
private var targetEvaluator:RailgunTargetEvaluator;
private var maxAngle:Number;
public function PenetratingTargetPriorityCalculator(param1:WeaponObject) {
super();
this.commonTargetEvaluator = battleService.getCommonTargetEvaluator();
this.targetEvaluator = battleService.getRailgunTargetEvaluator();
this.maxAngle = param1.verticalAutoAiming().getMaxAngle();
}
public function getTargetPriority(param1:Tank, param2:Number, param3:Number) : Number {
var local4:Body = param1.getBody();
var local5:Number = Number(this.commonTargetEvaluator.getTargetPriority(local4,param2,param3,this.FULL_DAMAGE_DISTANCE,this.maxAngle));
return this.targetEvaluator.getHitEfficiency(local4) + local5 * this.COMMON_PRIORITY_WEIGHT;
}
}
}
|
package controls.scroller.green
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinGreen_track extends BitmapAsset
{
public function ScrollSkinGreen_track()
{
super();
}
}
}
|
package com.lorentz.SVG.data
{
public class MarkerType
{
public static const START:String = "start";
public static const MID:String = "mid";
public static const END:String = "end";
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.