| Scripts/escortdeck.js |
"use strict";
this.name = "escortdeck";
this.version = "1.12"
this.author = "Norby";
this.copyright = "2015 Norbert Nagy";
this.description = "Buy and hold escort ships on external deck";
this.licence = "CC BY-NC-SA 4.0";
this.$debug = false; // debug verbose log
this.$logging = true; // verbose log
this.$Derelicts = false; //add derelict ships near the nav buoy of the starting station
this.$EscortDeckAutoLaunch = false; // automatically launch/callback when leaving/entering green condition
this.$EscortDeckBigTraderLaunch = false; //launch Anaconda from Carriers automatically or not
this.$EscortDeckCMaxMass = 800000; //escorts must below this mass on XL deck of Carriers
this.$EscortDeckExtremeMass = 10*this.$EscortDeckCMaxMass; //so much so don't display message
this.$EscortDeckJumpDist = 50; //escorts jump this m farther from the main ship at launch
this.$EscortDeckMassEffect = true; //slower steering and acceleration with more mass on deck
this.$EscortDeckMassFactor = 1; // fraction of steering maneuverability to retain
this.$EscortDeckMinMass = 30000; //which ships can tow the deck (30t not small in ShipVersion)
this.$EscortDeckLandingDist = 1500; //escorts will be added to the deck within this m if possible
this.$EscortDeckSpinModel = true;//spinning model in the interface screen
//this.$EscortDeckLargeMass = 130000; //max. escort mass, border of large ships in ShipVersion OXP
//this.$EscortDeckWMass = 2 * this.$EscortDeckLargeMass; //which ships can tow wide deck (2*large)
this.$EscortDeckLargeMass = 205000; //max. escort mass, border of large ships in ShipVersion OXP
this.$EscortDeckWMass = 1.5 * this.$EscortDeckLargeMass; //which ships can tow wide deck (2*large)
this.$EscortDeckXLMass = 400000; //which can tow XL deck (400t mean xl ships in Telescope OXP)
this.$EscortDeckBasicUnusableProb = 0.9; //probability of damage (0-1) to base systems (not equipment) of a derelict, which would render it unusable
//internal properties, should not touch
this.$EscortDeckEqs = []; //buyable escort ship sizes and masses
this.$EscortDeckEqs["EQ_ESCORTDECK_adder"] = [28.02, 14.9, 51, 16000];
this.$EscortDeckEqs["EQ_ESCORTDECK_asp"] = [64.73, 23.52, 83.69, 75882];
this.$EscortDeckEqs["EQ_ESCORTDECK_gecko"] = [61.48, 14.64, 51, 24670];
this.$EscortDeckEqs["EQ_ESCORTDECK_sidewinder"] = [63.23, 14.43, 44, 25088];
this.$EscortDeckEqs["EQ_ESCORTDECK_viper"] = [50, 18.12, 65.199, 34000];
this.$EscortDeckPad = { //landing pad max. x,y,z sizes and max. mass
escort:[70,29,135,this.$EscortDeckLargeMass], //for Asp SG, Arachnid, S8
// escort:[70,45,135,this.$EscortDeckLargeMass], //for Asp SG, Arachnid, S8
mini:[39,15,65,30000], //Adder, Ophidian
wide:[95,29,135,this.$EscortDeckLargeMass], //wide ship: Krait SG, Tiger Ray
// wide:[95,45,135,this.$EscortDeckLargeMass], //wide ship: Krait SG, Tiger Ray
xl:[70,29,95,60000], //sizes like heavy escorts but smaller mass, no Asp
// xl:[70,45,95,60000], //sizes like heavy escorts but smaller mass, no Asp
//Carrier specific pads
center:[65,29,95,130000], //small center pad for Asp, Fer-De-Lance, S8
main:[95,64,170,this.$EscortDeckCMaxMass], //Anaconda, D.T.T. Atlas, Krait SG
side:[70,29,95,this.$EscortDeckLargeMass], //heavy escorts: Asp, Arachnid, S8
small:[65,19,66,40000], //aft side pad for Gecko, Ophidian, Sonoran, Viper
top:[140,35,135,this.$EscortDeckCMaxMass] } //Cobra Mark III, King Cobra, Krait SG
this.$EscortDeckLPos = [[-36,6,-25], [36,6,-25], //landing pad positions: top left-right
[-36,-6,-25], [36,-6,-25], //bottom left-right
[-43,0,-25], [43,0,-25]]; //center left-right (Adder only)
// [34,0,-43], [-34,0,-43], //aft left, aft right (facing backward) - disabled
this.$EscortDeckLVec = [[0,1,0], [0,1,0], //vectors from landing pad to ship center: up
[0,-1,0], [0,-1,0], //down
[-1,0,0], [1,0,0]]; //left, right
// [0,0,-1], [0,0,-1], //back - disabled
this.$EscortDeckWPos = [[-48,6,-25], [48,6,-25], //Wide deck landing pad positions: top left-right
[-48,-6,-25], [48,-6,-25], //bottom left-right
[-54,0,-25], [54,0,-25]]; //center left-right (Adder only)
// [34,0,-43], [-34,0,-43], //aft left, aft right (facing backward)
this.$EscortDeckWVec = [[0,1,0], [0,1,0], //vectors from landing pad to ship center: up
[0,-1,0], [0,-1,0], //down
[-1,0,0], [1,0,0]]; //left, right
// [0,0,-1], [0,0,-1], //back
this.$EscortDeckXLPos = [[-8,0,-15], [8,0,-15], //XL deck landing pad positions: left, right
[-8,0,-44], [8,0,-44], //left, right
[-8,0,-73], [8,0,-73], //left, right
[-8,0,-102], [8,0,-102]]; //left, right
this.$EscortDeckXLVec = [[-1,0,0], [1,0,0], //XL deck vectors from landing pad to ship center
[-1,0,0], [1,0,0], //left, right
[-1,0,0], [1,0,0], //left, right
[-1,0,0], [1,0,0]]; //left, right
this.$EscortDeckCPos = [[0,15,215], [0,15,135], //Carrier pad positions: top front and center
[0,15,15], [-67,16,15], [67,16,15], //aft center, left, right
[-52,15,46], [52,15,46], //main deck left, right
[-30,0,233], [30,0,233]]; //mini front deck left, right
this.$EscortDeckCSize = [this.$EscortDeckPad.top, //Carrier max. sizes and mass, top front pad
this.$EscortDeckPad.center, //center: Asp, Fer-De-Lance, S8
this.$EscortDeckPad.top, //top aft for Cobra Mark III and King Cobra
this.$EscortDeckPad.small, this.$EscortDeckPad.small, //aft sides
this.$EscortDeckPad.main, this.$EscortDeckPad.main, //left-right main deck
this.$EscortDeckPad.mini, this.$EscortDeckPad.mini]; //front pads
this.$EscortDeckCVec = [[0,1,0], [0,1,0], //Carrier vectors from landing pad to ship center: up
[0,1,0], //up
[0,1,0], [0,1,0], //up
[0,0,1], [0,0,1], //forward
[0,0,0], [0,0,0]]; //center
this.$EscortDeckCXPos = [[0,15,215], [0,15,115], //Carrier XL deck positions: top front, center
[-48,16,15], [48,16,15], //aft left, right
[-11,0,151], [11,0,151], //left, right
[-11,0,81], [11,0,81], //left, right
[-30,0,233], [30,0,233]]; //front left, right
this.$EscortDeckCXSize = [this.$EscortDeckPad.top, this.$EscortDeckPad.top, //top front and center
this.$EscortDeckPad.wide, this.$EscortDeckPad.wide, //top aft wide pads
this.$EscortDeckPad.side, this.$EscortDeckPad.side, //4 heavy escorts
this.$EscortDeckPad.side, this.$EscortDeckPad.side, //on main decks
this.$EscortDeckPad.mini, this.$EscortDeckPad.mini]; //front pads
this.$EscortDeckCXVec = [[0,1,0], [0,1,0], //Carrier XL deck vectors from landing pad to ship center: up
[0,1,0], [0,1,0], //up
[-1,0,0], [1,0,0], //left, right
[-1,0,0], [1,0,0], //left, right
[0,0,0], [0,0,0]]; //center
/* Carrier deck positions for 10 heavy escorts, removed to be less powerful
this.$EscortDeckCXXPos = [[0,14,220], [0,14,23], //landing pad positions: top front-aft
[-11,0,170], [11,0,170], //left, right
[-11,0,135], [11,0,135], //left, right
[-11,0,100], [11,0,100], //left, right
[-11,0,65], [11,0,65]]; //left, right
this.$EscortDeckCXXSize = [this.$EscortDeckPad.top, this.$EscortDeckPad.top, //top front and aft
this.$EscortDeckPad.escort, this.$EscortDeckPad.escort, //8 heavy escorts
this.$EscortDeckPad.escort, this.$EscortDeckPad.escort, //on main decks
this.$EscortDeckPad.escort, this.$EscortDeckPad.escort,
this.$EscortDeckPad.escort, this.$EscortDeckPad.escort];
this.$EscortDeckCXXVec = [[0,1,0], [0,1,0], //vectors from landing pad to ship center: up
[-1,0,0], [1,0,0], //left, right
[-1,0,0], [1,0,0], //left, right
[-1,0,0], [1,0,0], //left, right
[-1,0,0], [1,0,0]]; //left, right
*/
this.$EscortDeckVersion = null; //version of EscortDeck installed on the ship
this.$EscortDeckCWS = null; //carriers worldscript if Carriers OXP is installed
this.$EscortDeckDockingTunnel = false; //player in the tunnel
this.$EscortDeckEWS = null; //escortdeck_escort worldscript
this.$EscortDeckFCB = null; //FrameCallBack updating escort ship positions
this.$EscortDeckFCBDelta = 0; //delta counter in FrameCallBack
this.$EscortDeckFirstMSO = true; //first missionScreenOpportunity after docked
this.$EscortDeckGWS = null; //Gallery worldscript
this.$EscortDeckI = false; //start on the first page within EscortDeck Interface
this.$EscortDeckLaunch = false; //launch or call back via primeable equipment
this.$EscortDeckLastTooLargeTarget = null; //prevent repeated too large messages
this.$EscortDeckLocked = []; //which positions will not launch with the other escorts
this.$EscortDeckMaxs = null; //store maxThrust, maxPitch, maxRoll and maxYaw
this.$EscortDeckNPCEqDamage = false; // NPC Equipment Damage OPC is installed
this.$EscortDeckPadPos = []; //landing pad positions
this.$EscortDeckPadSize = []; //landing pad sizes
this.$EscortDeckPadVec = []; //vectors from landing pad to ship center
this.$EscortDeckPlayableDataKeys = null; //playable ships
this.$EscortDeckPWS = null; //escortpack worldscript if escortpack OXP is installed
this.$EscortDeckSelectedPad = -1; //the pad selected via primeable equipment
this.$EscortDeckShip = []; //store the ship objects of escorts
this.$EscortDeckShipData = []; //store the data of escort ships
this.$EscortDeckShipPos = []; //positions of escort ships on board
this.$EscortDeckSitInto = false; //sit into the selected escort when launch it from a Carrier
this.$EscortDeckSitIntoWithMode = false; //allow sit into with mode key when deck is primed
this.$EscortDeckSound = null; //sound of escort landing
this.$EscortDeckSpawnedShips = []; //stack for restoring ship data in FCB after shipSpawned
this.$EscortDeckSGWS = null; //snipergun worldscript if Sniper Gun OXP is installed
this.$EscortDeckTWS = null; //telecope worldscript if telecope OXP is installed
this.$EscortDeckToWS = null; //towbar worldscript if towbar OXP is installed
this.$EscortDeckV = null; //visualeffect of the escort deck of the player ship
this.$EscortDeckXL = false; //the current deck is xl or not
this.$EscortDeckZV = 0; //the z offset of deck position from the center of the player ship
// configuration settings for use in Lib_Config
this.$newUsableProb = 1 - this.$EscortDeckBasicUnusableProb;
this.$newAutoLaunch = false;
this._compConfig = {
Name:this.name, Alias:"EscortDeck", Display:"Config", Alive:"_compConfig", Notify:"$onChange", Reset:true,
Bool: {
B0: {Name:"$newAutoLaunch", Def:true, Desc:"Automatic Launch"},
Info:"Automatic launch/callback on Red condition transition (0:no, 1:yes)"
},
SInt: {
S0:{Name:"$newUsableProb", Min:0, Max:1, Float:true, Def:0.1, Desc:"Usable derelict probability"},
Info:"0 - Value between 0 (all unusable) and 1 (all usable)"
},
};
//
//equipment events
//
//-----------------------------------------------------------------------------------------------//
this.activated = function _escortdeck_activated() { //launch or call back one or all escorts
var w = worldScripts.escortdeck;
w.$EscortDeck_EQActivated(w);
}
//-----------------------------------------------------------------------------------------------//
this.mode = function _escortdeck_mode() { //select the next pad on escort deck
var w = worldScripts.escortdeck;
w.$EscortDeck_EQMode(w);
}
//
//worldscript events
//
//-----------------------------------------------------------------------------------------------//
this.startUp = function _escortdeck_startUp() {
var hh = worldScripts.HyperspaceHangar;
if (!player.ship.addCollisionException) { //before v1.81 need more room
for (var i = 0; i < this.$EscortDeckLPos.length; i++)
this.$EscortDeckLPos[i][2] -= 30;
for (var i = 0; i < this.$EscortDeckWPos.length; i++)
this.$EscortDeckWPos[i][2] -= 30;
for (var i = 0; i < this.$EscortDeckXLPos.length; i++)
this.$EscortDeckXLPos[i][2] -= 20;
}
this.$EscortDeck_SetPads(player.ship, this);
this.$EscortDeckSound = new SoundSource;
this.$EscortDeckSound.sound = "escortdeck.ogg";
this.$EscortDeckSound.loop = false;
this.$EscortDeckSound.repeatCount = 1;
this.$EscortDeckSound2 = new SoundSource;
if (worldScripts["BGS-M"]) this.$EscortDeckSound2.sound = "bgs-c_sell.ogg";
else this.$EscortDeckSound2.sound = "sell.ogg"; //Oolite default sell sound
this.$EscortDeckSound2.loop = false;
this.$EscortDeckSound2.repeatCount = 1;
this.$EscortDeckSound3 = new SoundSource;
this.$EscortDeckSound3.sound = "escortdeckhitderelict.ogg";
this.$EscortDeckSound3.loop = false;
this.$EscortDeckSound3.repeatCount = 1;
this.$EscortDeckPlayableDataKeys = Ship.keysForRole( "player" ); //playable ships
if (worldScripts.escortdeck_escort) this.$EscortDeckEWS = worldScripts.escortdeck_escort;
if (worldScripts.carriers) this.$EscortDeckCWS = worldScripts.carriers;
if (worldScripts.gallery) this.$EscortDeckGWS = worldScripts.gallery;
if (worldScripts.escortpack) this.$EscortDeckPWS = worldScripts.escortpack;
if (worldScripts.snipergun) this.$EscortDeckSGWS = worldScripts.snipergun;
if (worldScripts.telescope) this.$EscortDeckTWS = worldScripts.telescope;
if (worldScripts.NPC_Equipment_Damage) this.$EscortDeckNPCEqDamage = true;
var h = worldScripts.hudselector;
if( h && h.$HUDSelectorAddMFD ) h.$HUDSelectorAddMFD(this.name);
var s = missionVariables.$EscortDeckShipData;
if( s && s.length > 0 ) this.$EscortDeckShipData = JSON.parse(s);
var s = missionVariables.$EscortDeckLocked;
if( s && s.length > 0 ) this.$EscortDeckLocked = JSON.parse(s);
var t = worldScripts.towbar;
if (t) {
this.$EscortDeckToWS = t; //save Towbar worldscript
//inject code to do not lock on derelicts of escort deck
eval("t.$EscortDeckToWS_IsDerelictOrig = "+t.$Towbar_IsDerelict);
eval("t.$Towbar_IsDerelict = function(entity) { \
var w = worldScripts.escortdeck; \
if ((!w.$EscortDeckXL || \
w.$EscortDeckCWS && player.ship && player.ship.isValid \
&& player.ship.dataKey.indexOf('carrier') > -1 ) && \
worldScripts.towbar.$EscortDeckToWS_IsDerelictOrig(entity) \
&& ( !w.$EscortDeckShip \
|| w.$EscortDeckShip.indexOf(entity) == -1 )) \
return true; \
return false; \
}");
eval("t.$EscortDeckToWS_shipCollidedOrig = "+t.shipCollided);
eval("t.shipCollided = function(otherShip) { \
var w = worldScripts.escortdeck; \
if( (!w.$EscortDeckXL || \
w.$EscortDeckCWS && player.ship && player.ship.isValid && \
player.ship.dataKey.indexOf('carrier') > -1 ) && \
!w.$EscortDeckShip || w.$EscortDeckShip.indexOf(otherShip) == -1 ) \
worldScripts.towbar.$EscortDeckToWS_shipCollidedOrig(otherShip); \
}");
if (hh) {
//makes Towbar not salvage usable derelicts
eval("t.$EscortDeckToWS_missionScreenOpportunityOrig = "+t.missionScreenOpportunity);
eval("t.missionScreenOpportunity = function _Towbar_missionScreenOpportunity_escortdeck() { \
var w = worldScripts.towbar; \
if (w.$TowbarShip && w.$TowbarShip.script && w.$TowbarShip.script.$EscortDeckUsable != 1) \
w.$EscortDeckToWS_missionScreenOpportunityOrig(); \
}");
//makes Towbar's Tug Drone not salvage usable derelicts
eval("t.$Towbar_TugDrone_ProcessingOrig = "+t.$Towbar_TugDrone_Processing);
eval("t.$Towbar_TugDrone_Processing = "+worldScripts.escortdeck.$EscortDeck_TugDrone_Processing)
}
}
}
//-----------------------------------------------------------------------------------------------//
this.startUpComplete = function _escortdeck_startUpComplete() {
// register our settings, if Lib_Config is present
if (worldScripts.Lib_Config) worldScripts.Lib_Config._registerSet(this._compConfig);
if (missionVariables.$EscortDeck_unusable_derelic_prob) {
this.$EscortDeckBasicUnusableProb = parseFloat(missionVariables.$EscortDeck_unusable_derelic_prob)
} else {
if (worldScripts.NPC_Equipment_Damage) this.$EscortDeckBasicUnusableProb -= 0.1
}
this.$newUsableProb = 1 - this.$EscortDeckBasicUnusableProb;
log(this.name, "Base unusable derelict probability: "+this.$EscortDeckBasicUnusableProb)
this.$EscortDeck_SaveMaxs( player.ship, this );
//call after towbar and ccl startups finished
this.$EscortDeck_SalvageBadEscorts(player.ship);
this.$EscortDeckI = false; //start on the first page
this.$EscortDeck_Interface();
this.$EscortDeckVersion = this.$EscortDeck_Version();
}
//-----------------------------------------------------------------------------------------------//
this.alertConditionChanged = function _escortdeck_alertConditionChanged(newCondition, oldCondition) {
if (!this.$EscortDeckVersion) return;
if( !player.ship || !player.ship.isValid || !this.$EscortDeckAutoLaunch) return;
if( newCondition == 3 && player.alertHostiles ) {
this.$EscortDeck_ControlAll(true, false, this); //launch all escorts
} else if( newCondition == 1 ) { //call back escorts in green alert
this.$EscortDeck_ControlAll(false, false, this);
}
}
//-----------------------------------------------------------------------------------------------//
this.guiScreenChanged = function _escortdeck_guiScreenChanged(to, from) {
if( to == "GUI_SCREEN_INTERFACES" ) this.$EscortDeck_Interface(); //update displayed ship names
}
//-----------------------------------------------------------------------------------------------//
this.missionScreenOpportunity = function _escortdeck_missionScreenOpportunity() {
var that = _escortdeck_missionScreenOpportunity;
var hh = (that.hh = that.hh || worldScripts.HyperspaceHangar);
var t = this.$EscortDeckToWS; //use Towbar salvage if available
if (t && t.$TowbarShip && t.$TowbarShip.isValid
&& !t.$Towbar_IsHeavyShip(t.$TowbarShip)) { //avoid heavy ships in aegis with autodock
if (t.$TowbarShip.script && t.$TowbarShip.script.$EscortDeckUsable > 0 && hh) {
var displayName = t.$TowbarShip.displayName;
log("escortdeck", "Towed ship "+displayName+" is usable, storing in Hyperspace Hangar");
// towed ship is usable and HH is installed, transfer it to HH
this.$EscortDeck_HHStoreShip(t.$TowbarShip)
player.consoleMessage("Usable ship "+displayName+" stored into Hyperspace Hangar", 10);
player.commsMessage("Usable ship "+displayName+" stored into Hyperspace Hangar", 10);
t.$TowbarShip.remove(true);
t.$TowbarShip = null;
} else {
log("escortdeck", t.$TowbarShip.displayName+" is not usable, salvaging it!");
t.$Towbar_Payout(t.$TowbarShip); //call payout in towbar oxp
}
}
if( player.ship.docked && this.$EscortDeckFirstMSO
&& this.$EscortDeckShip && this.$EscortDeckShip.length > 0 ) {
this.$EscortDeckFirstMSO = false; //do only once
for(var i = 0; i < this.$EscortDeckPadPos.length; i++ ) { //salvage unusables
var s = this.$EscortDeckShip[i]; //the ship on this pad
if( s && s.isValid ) {
if( !s.script || !( s.script.$EscortDeckUsable > 0 ) ) { //unusable
this.$EscortDeck_Salvage(i, player.ship); //salvage
if(this.$EscortDeckToWS) {
this.$EscortDeckFirstMSO = true; //do one at a time
i = this.$EscortDeckPadPos.length;
}
}
} else { //inside stations check saved ship data
var d = this.$EscortDeckShipData[i];
if( d && d[1] && ( !d[14] || !(d[14].usable > 0) ) ) {//unusable
this.$EscortDeck_Salvage(i, player.ship);
if(this.$EscortDeckToWS) {
this.$EscortDeckFirstMSO = true; //do one at a time
i = this.$EscortDeckPadPos.length;
}
}
}
}
}
if( t && t.$TowbarRunScreens.length > 0 ) {
var rs = t.$TowbarRunScreens.shift(); //get and remove the oldest element
if(this.$debug) log(this.name, "MSO "+t.$TowbarRunScreens.length+" "+guiScreen+" "+rs );
t.$Towbar_RunScreen(rs.place, rs.msg, rs.model); //show sell salvage screen
}
}
//-----------------------------------------------------------------------------------------------//
this.playerBoughtEquipment = this.equipmentAdded = function _escortdeck_playerBoughtEquipment(equipment) {
var p = player.ship;
var w = this; //w is used below
if( equipment.indexOf("EQ_ESCORTDECK_" ) == 0 ) {
p.removeEquipment(equipment);
var k = equipment.substring(14); //extract datakey from the end of the eq key
var s = this.$EscortDeck_SpawnOne( "[escortdeck-"+k+"]", this, false );
if(this.$debug) log(this.name, k+" "+s); //debug
if( !s || !s[0] || !s[0].isValid ) { //possible bug
this.$EscortDeck_RollBack(equipment, "You can't buy "+k+".");
return;
} else s = s[0];
var c = EquipmentInfo.infoForKey(equipment).price/10; //escort price
if( p && p.dockedStation ) { //Rock Hermits ask more
var e = p.dockedStation.equipmentPriceFactor;
if( e > 0 ) c = e * c;
}
var en = EquipmentInfo.infoForKey(equipment).name; //escort name
w.$EscortDeck_AwardEQs(s);
var d = this.$EscortDeck_MakeShipData(s);
if(d[14]) d[14].usable = 1; //usable
var added = false;
var reason = this.$EscortDeck_TooLarge(s, p, this);
if( !reason && !this.$EscortDeckXL && this.$EscortDeck_isLarge(p, this)
&& this.$EscortDeck_isMini(s) ) { //Adder or smaller, try side decks first
for( var i = 0; !added && i < w.$EscortDeckPadPos.length; i++ ) {
if( w.$EscortDeck_isMiniPad(i, p, w) ) {
if( !this.$EscortDeckShipData[i] ) {
this.$EscortDeckShipData[i] = d;
added = i+1; //=pad+1
}
}
}
}
var len = this.$EscortDeckPadPos.length;
if( !reason && !added ) for(var i = 0; i < len; i++ ) {
if( !this.$EscortDeckShipData[i]
&& !w.$EscortDeck_TooLarge2(s, p, w, i) ) {
this.$EscortDeckShipData[i] = d;
added = i+1;
i=10;
}
}
s.remove(true);
if( added ) player.consoleMessage("You paid "+c+" credits for "+en+" placed to landing pad "+added, 10);
else {
if(!reason) reason = "no room on your deck";
this.$EscortDeck_RollBack( equipment, "You can't buy "+en+", "+reason );
}
}
if( equipment == "EQ_ESCORTDECK" ) {
this.$EscortDeckXL = false;
if( w && w.$EscortDeckCWS && p.dataKey.indexOf("carrier") > -1
&& p.equipmentStatus("EQ_ESCORTDECKXL") == "EQUIPMENT_OK" ) {
//salvage pad 8, exchange pad 2-3 and shift pad 9-10 to 8-9
w.$EscortDeck_Salvage(7, p); //salvage a ship to reduce from 10 to 9
var d = [], s = [];
d[0] = w.$EscortDeckShipData[0]; s[0] = w.$EscortDeckShip[0];
d[1] = w.$EscortDeckShipData[2]; s[1] = w.$EscortDeckShip[2];
d[2] = w.$EscortDeckShipData[1]; s[2] = w.$EscortDeckShip[1];
d[3] = w.$EscortDeckShipData[3]; s[3] = w.$EscortDeckShip[3];
d[4] = w.$EscortDeckShipData[4]; s[4] = w.$EscortDeckShip[4];
d[5] = w.$EscortDeckShipData[5]; s[5] = w.$EscortDeckShip[5];
d[6] = w.$EscortDeckShipData[6]; s[6] = w.$EscortDeckShip[6];
d[7] = w.$EscortDeckShipData[8]; s[7] = w.$EscortDeckShip[8];
d[8] = w.$EscortDeckShipData[9]; s[8] = w.$EscortDeckShip[9];
w.$EscortDeckShipData = d;
w.$EscortDeckShip = s;
}
p.removeEquipment("EQ_ESCORTDECKXL"); //replace
this.$EscortDeck_SalvageBadEscorts(p);
}
if( equipment == "EQ_ESCORTDECKXL" ) {
this.$EscortDeckXL = true;
if( w && w.$EscortDeckCWS && p.dataKey.indexOf("carrier") > -1
&& p.equipmentStatus("EQ_ESCORTDECK") == "EQUIPMENT_OK" ) {
//exchange pad 2-3 and shift pad 8-9 to 9-10
var d = [], s = [];
d[0] = w.$EscortDeckShipData[0]; s[0] = w.$EscortDeckShip[0];
d[1] = w.$EscortDeckShipData[2]; s[1] = w.$EscortDeckShip[2];
d[2] = w.$EscortDeckShipData[1]; s[2] = w.$EscortDeckShip[1];
d[3] = w.$EscortDeckShipData[3]; s[3] = w.$EscortDeckShip[3];
d[4] = w.$EscortDeckShipData[4]; s[4] = w.$EscortDeckShip[4];
d[5] = w.$EscortDeckShipData[5]; s[5] = w.$EscortDeckShip[5];
d[6] = w.$EscortDeckShipData[6]; s[6] = w.$EscortDeckShip[6];
d[7] = null; s[7] = null;
d[8] = w.$EscortDeckShipData[7]; s[8] = w.$EscortDeckShip[7];
d[9] = w.$EscortDeckShipData[8]; s[9] = w.$EscortDeckShip[8];
w.$EscortDeckShipData = d;
w.$EscortDeckShip = s;
}
p.removeEquipment("EQ_ESCORTDECK"); //replace
this.$EscortDeck_SalvageBadEscorts(p);
}
if( equipment == "EQ_FUEL" ) {
var d = this.$EscortDeckShipData;
var f = 0;
var s = "";
var len = this.$EscortDeckPadPos.length;
if(d) for(var i = 0; i < len; i++ ) {
if( d[i] && d[i][9] < 7 ) {
if( f > 0 ) s = "s"; //more than one escort ship need refuel
f += 7 - d[i][9];
}
}
if( f > 0 ) {
var c = f * 3;//3cr/ly
if( player.credits > c ) {
for(var i = 0; i < len; i++ ) {
if( d[i] && d[i][9] < 7 ) d[i][9] = 7;
}
player.credits -= c;
player.consoleMessage("Your escort"+s+" got "+(Math.round(f*10)/10)+" ly fuel for "+(Math.round(c*10)/10)+" credits", 10);
}
}
}
}
//-----------------------------------------------------------------------------------------------//
this.playerBoughtNewShip = function _escortdeck_playerBoughtNewShip(ship) {
this.$EscortDeck_SaveMaxs( player.ship, this );
if( !this.$EscortDeckCWS || !this.$EscortDeckCWS.$CarriersPlayerInEscort ) {
this.$EscortDeck_SalvageBadEscorts(player.ship);
//setup new pads after SalvageBadEscorts only!
this.$EscortDeck_SetPads( player.ship, this );
}
}
//-----------------------------------------------------------------------------------------------//
this.playerStartedJumpCountdown = function _escortdeck_playerStartedJumpCountdown(type, seconds) {
if (!this.$EscortDeckVersion) return;
//fix for Granite ships to the too close high mass do not prevent the jump
if( !this.$EscortDeckCWS || player.ship.dataKey.indexOf("carrier") == -1 ) {
for( var i = 0; i < this.$EscortDeckPadPos.length; i++ )
if( this.$EscortDeckShipPos[i] )
this.$EscortDeckShipPos[i].z -= 40; //move backward on non-Carriers
} else { //on Carriers move escort up
for( var i = 0; i < this.$EscortDeckPadPos.length; i++ )
if( this.$EscortDeckShipPos[i] )
this.$EscortDeckShipPos[i].y += 100;
}
}
//-----------------------------------------------------------------------------------------------//
this.playerWillSaveGame = function _escortdeck_playerWillSaveGame(message) {
missionVariables.$EscortDeckShipData = JSON.stringify(this.$EscortDeckShipData);
missionVariables.$EscortDeckLocked = JSON.stringify(this.$EscortDeckLocked);
missionVariables.$EscortDeck_unusable_derelic_prob = this.$EscortDeckBasicUnusableProb
}
//-----------------------------------------------------------------------------------------------//
this.shipKilledOther = function _escortdeck_shipKilledOther(whom, damageType) {
var _npcShip = this.ship; // set if called from an escort's ship script, unidefined if called as a world script for the playership
var _ship = (_npcShip ? _npcShip : player.ship);
if (!_npcShip && !this.$EscortDeckVersion) return;
log("escortdeck", _ship.displayName+" killed "+whom.displayName+" with "+damageType);
if (_npcShip && this.$EscortDeckUsable === 1)
_ship.commsMessage("Mama, "+whom.displayName+" is no more!", player.ship);
}
//-----------------------------------------------------------------------------------------------//
this.shipAttackedOther = function _escortdeck_shipAttackedOther(other) { //player hits other
// this function is both a world script event handler for the playership and a ship event handler for the escorts
var that = _escortdeck_shipAttackedOther;
var wc = (that.wc = that.wc || worldScripts.escortdeck);
var tb = (that.tb = that.tb || worldScripts.towbar);
var weak_lasers = (that.weak_lasers = that.weak_lasers || ["EQ_WEAPON_EBEAM_LASER","EQ_WEAPON_BEAM_LASER"]);
var npcShip = this.ship; // set if called from an escort's ship script, unidefined if called as a world script for the playership
var _ship = (npcShip ? npcShip : player.ship);
var current_weapon = _ship.currentWeapon;
var weapon_info = current_weapon.weaponInfo;
var hit_energy = (weapon_info && weapon_info.damage ?
weapon_info.damage :
(weak_lasers.indexOf(current_weapon.equipmentKey) >= 0 ? 14 : 23)
);
var fname = "shipAttackedOther";
var debug = this.$debug;
var logging = this.$logging;
if (!npcShip && !this.$EscortDeckVersion) return;
if (!other || !other.isValid || other.isPlayer) return; //for sure
if (npcShip && logging) log("escortdeck", _ship.displayName+" attacked "+other.displayName+" with "+other.energy.toFixed(1)+" energy at "+_ship.position.distanceTo(other).toFixed(1));
if( !other.script ) other.script = "oolite-default-ship-script.js"; //for sure
if( other.script ) other.script.$EscortDeck_Target = 1; //flag for escort AI
if (!other.isThargoid && !other.isDerelict && other.energy > 0 && other.energy < 2 * hit_energy) {
//the next Military Laser hit can destroy the target
if (logging) log("escortdeck", _ship.displayName+": forcing target '"+other.displayName+"' to abandon ship");
other.fireMissile();//last resort
if( other.equipmentStatus("EQ_ESCAPE_POD") === "EQUIPMENT_OK"
&& other.abandonShip()) {//eject to make more derelict ship but only if has Escape Pod
var dn;
if( worldScripts["detectors"] ) {
dn = other.script.$Detectors_Origname;//short name with version
} else {
dn = other.displayName;
other.displayName = "Derelict " + dn;
}
if (!npcShip) {
player.consoleMessage(dn+" ejected!");
log("escortdeck", _ship.displayName+" turned "+other.displayName+" derelict");
if( other.script && !other.script.$AlreadyScored ) {
other.script.$AlreadyScored = true;
player.score++;
}
} else if (npcShip && this.$EscortDeckUsable === 1) {
_ship.commsMessage("Mama, look, I got "+other.displayName+" !", player.ship);
log("escortdeck", "Escort "+_ship.displayName+" turned "+other.displayName+" derelict");
}
} else log("escortdeck", _ship.displayName+" "+other.displayName+" has no functional escape pod");
}
if( other.isDerelict && !other.isThargoid ) {
if (!npcShip) this.$EscortDeckSound3.play(); //audio feedback if derelict
if( other.script ) {
if( !other.script.$TowbarDerelictAttack ) {
other.script.$TowbarDerelictAttack = 1;
} else {
if (++other.script.$TowbarDerelictAttack >= tb.$TowbarMaxReduct)
log("escortdeck", _ship.displayName+", Laser Reductor disabled for "+other.displayName+", used too many times:"+other.script.$TowbarDerelictAttack);
}
}
if (_ship.equipmentStatus("EQ_LASERREDUCTOR") === "EQUIPMENT_OK" && tb.$TowbarLaserReductorOn &&
(!other.script || other.script.$TowbarDerelictAttack <= tb.$TowbarMaxReduct) ) { //prevent invulnerability
// there are too many special cases for weapons and weapons positions (like shipdata's weapon_energy field)
// so let's err on the conservative side...
if (debug) log("escortdeck", _ship.displayName+" giving "+2*hit_energy+" back to derelict "+other.displayName+", "+other.script.$TowbarDerelictAttack+" attacks");
other.energy += 2 * hit_energy;
}
if (npcShip) return;
var reason = wc.$EscortDeck_TooLarge(_ship, other, this); //fit into the deck limits?
if (other.script && !(other.script.$EscortDeckUsable > 0) && !(other.script.$EscortDeckUsable < 0) ) {
if (wc.$isUsable(other, fname) ) { //fit into the deck limits and lucky
log(this.name, _ship.displayName+": "+fname+": '"+other.displayName+"' is usable");
other.script.$EscortDeckUsable = 1;
other.script.$TowbarUsableShip = true;
other.script.$TowbarShipHealth = 1;
wc.$EscortDeck_AwardEQs(other);
} else {
log(this.name, _ship.displayName+": "+fname+": '"+other.displayName+"' is NOT usable");
other.script.$EscortDeckUsable = -1; //unusable as escort
other.script.$TowbarUsableShip = false;
}
}
}
if (!npcShip) this.$EscortDeck_Bounty( other );
}
//-----------------------------------------------------------------------------------------------//
this.shipCollided = function _escortdeck_shipCollided(otherShip) {
var _fname = "shipCollided";
var p = player.ship;
if (!this.$EscortDeckVersion) return;
if( !p || !p.isValid ) return;
var w = this;
var i = w.$EscortDeckShip.indexOf(otherShip);
if( i > -1 ) {
if( w.$EscortDeckShipPos[i] ) { //move escort until avoid collision
if( !w.$EscortDeckCWS || p.dataKey.indexOf("carrier") == -1 ) {
w.$EscortDeckShipPos[i].z -= 2; //move backward on non-Carriers
} else { //on Carriers move escort up until avoid collision
w.$EscortDeckShipPos[i].y += 5;
// if( w.$EscortDeckXL ) {
// if( i < 4 ) w.$EscortDeckShipPos[i].y += 5; //top pads up
// else w.$EscortDeckShipPos[i].y -= 5; //others move down
// else if( Math.round(i/2) != i/2 )
// w.$EscortDeckShipPos[i].x += 5; //move right
// else w.$EscortDeckShipPos[i].x -= 5; //move left
// } else {
// if( i < 5 ) w.$EscortDeckShipPos[i].y += 5; //on top move up
// else w.$EscortDeckShipPos[i].y -= 5; //others move down
// }
}
}
if( otherShip.AIState == "LANDING" ) {
var r = w.$EscortDeck_PutShip(false, otherShip, i, p, true, true);
if( !r ) otherShip.AIState == "DECK"; //landed
else {
otherShip.AIState == "FOLLOW"; //no room?
if(w.$debug) log(w.name, "Can't add "+t.displayName +" to Escort Deck pad "+i+", "+r); //debug
}
}
} else {
if (this.$debug) log(this.name, _fname+": bumped '"+otherShip.dislayName+"'");
w.$EscortDeck_AddEscort( otherShip, w.$EscortDeckShip, p, w, true );
}
}
//-----------------------------------------------------------------------------------------------//
this.shipDied = function _escortdeck_shipDied() {
var p = player.ship;
//var e = system.addVisualEffect("escortdeckxl", p.position);e.orientation = p.orientation;
//this.$EscortDeckV.remove();
}
//-----------------------------------------------------------------------------------------------//
this.shipDockedWithStation = function _escortdeck_shipDockedWithStation(station) {
this.$EscortDeck_RestoreMaxs(player.ship, this);
this.$EscortDeckDockingTunnel = false;
this.$EscortDeckI = false; //start on the first page
this.$EscortDeck_Interface();
}
//-----------------------------------------------------------------------------------------------//
this.shipExitedWitchspace = function _escortdeck_shipExitedWitchspace() {
if (!this.$EscortDeckVersion) return;
this.$EscortDeck_Show(player.ship);
this.$EscortDeckDockingTunnel = false;
}
//-----------------------------------------------------------------------------------------------//
this.shipLaunchedFromStation = function _escortdeck_shipLaunchedFromStation() {
if (!this.$EscortDeckVersion) return;
this.$EscortDeck_SaveMaxs( player.ship, this );
this.$EscortDeckDockingTunnel = false;
if( this.$EscortDeckCWS && this.$EscortDeckCWS.$CarriersPlayerInEscort ) return;
if (this.$debug) {
log(this.name, "Launching, PadSize:"+JSON.stringify(this.$$EscortDeckPadSize));
this.$printDeckLoad();
}
this.$EscortDeck_Show(player.ship);
}
//-----------------------------------------------------------------------------------------------//
this.shipTargetAcquired = function _escortdeck_shipTargetAcquired(t) { //make some derelicts usable
var _fname = "shipTargetAcquired";
if( !t || !t.isValid ) return;
this.$EscortDeckLastTooLargeTarget = null;
var p = player.ship;
var pad = this.$EscortDeckShip.indexOf(t);
// if( pad > -1 ) this.$EscortDeckSelectedPad = pad; - do not use, cause disturbing changes in selected pad
if( !t.script ) t.script = "oolite-default-ship-script.js"; //for sure
if( t.script.$TowbarMinedShip ) t.script.$EscortDeckUsable = -1; //unusable as escort
if ( t.isDerelict && !(t.script.$EscortDeckUsable > 0) && !(t.script.$EscortDeckUsable < 0) ) {
//determine usability once only
if (this.$isUsable(t, _fname)) { //limits and lucky
log(this.name, "'"+t.displayName+"' is usable");
t.displayName = t.displayName.replace("Derelict", "Usable");
t.script.$EscortDeckUsable = 1;
t.script.$TowbarUsableShip = true;
t.script.$TowbarShipHealth = 1;
this.$EscortDeck_AwardEQs(t);
} else {
log(this.name, "'"+t.displayName+"' is NOT usable");
t.script.$EscortDeckUsable = -1; //unusable
t.script.$TowbarUsableShip = false;
if(this.$debug) log(this.name, t.displayName+" is set to unusable: "+t);
}
}
if( t.script && pad == -1 && ( t.isDerelict || t.script.$EscortDeckUsable > 0 )
&& (!this.$EscortDeck_isLarge(t, this) //exclude ships over 130t except for Carriers
|| this.$EscortDeckCWS && p.dataKey.indexOf("carrier") > -1
&& t.mass < this.$EscortDeckCMaxMass ) ) { //must below this mass on Carriers
var shipmass = t.mass/1000;
//remove extra density from HardShips and Granite ships
if( t.scriptInfo && t.scriptInfo.hardarmour > 1 )
shipmass = shipmass / 2;
var reason = this.$EscortDeck_TooLarge(t, p, this); //fit into the deck limits?
if( t.script.$EscortDeckUsable > 0 ) {
t.script.$TowbarUsableShip = true; //show Usable! flag in CombatMFD
var f = "Found an usable "+t.name+" ("+Math.ceil(shipmass)+"t) ";
var g = null;
if( p.equipmentStatus("EQ_ESCORTDECK") != "EQUIPMENT_OK"
&& p.equipmentStatus("EQ_ESCORTDECKXL") != "EQUIPMENT_OK" )
g = "You need an Escort Deck equipment to use as your escort";
else if( reason ) f = t.name+" is "+reason+" for your Escort Deck";
else if( t.position.distanceTo(p.position) > this.$EscortDeckLandingDist
+ t.collisionRadius )
g = "Go near to pick up to the Escort Deck";
if(this.$debug) log(this.name, f+" "+g); //debug
player.consoleMessage(f, 10);
if(g) player.consoleMessage(g, 10);
} else if( t.script.$EscortDeckUsable < 0 ) {
t.script.$TowbarUsableShip = false;
player.consoleMessage("Salvage "+t.displayName+" ("+Math.ceil(shipmass)+"t)", 4.5);
}
}
if( pad == -1 && t.script && t.script.$EscortDeckUsable > 0 )
p.awardEquipment("EQ_DTAUSA"); //show Usable label on NumericHUD
else p.removeEquipment("EQ_DTAUSA"); //remove Usable label on NumericHUD
}
//-----------------------------------------------------------------------------------------------//
this.shipTargetLost = function _escortdeck_shipTargetLost() {
if (!this.$EscortDeckVersion) return;
player.ship.removeEquipment("EQ_DTAUSA"); //remove Usable label on NumericHUD
}
//-----------------------------------------------------------------------------------------------//
this.shipWillDockWithStation = function _escortdeck_shipWillDockWithStation(station) {
if (!this.$EscortDeckVersion) return;
if (this.$debug) {
log(this.name, "Will Dock");
this.$printDeckLoad();
}
this.$EscortDeckDockingTunnel = true;
if( station.dataKey != "carriers-vdock"
&& station.dataKey.indexOf("carrier-player") == -1 )
this.$EscortDeck_VClear(this);
else this.$EscortDeckFirstMSO = false; //do not salvage in vdock
player.ship.removeEquipment("EQ_DTAUSA"); //remove Usable label on NumericHUD
}
//-----------------------------------------------------------------------------------------------//
this.shipWillEnterWitchspace = function _escortdeck_shipWillEnterWitchspace(cause) {
if (!this.$EscortDeckVersion) return;
this.$EscortDeckDockingTunnel = true;
this.$EscortDeck_VClear(this);
player.ship.removeEquipment("EQ_DTAUSA"); //remove Usable label on NumericHUD
}
//-----------------------------------------------------------------------------------------------//
this.shipWillLaunchFromStation = function _escortdeck_shipWillLaunchFromStation() {
this.$EscortDeckVersion = this.$EscortDeck_Version();
if (!this.$EscortDeckVersion) return;
this.$EscortDeckDockingTunnel = true;
// this.$EscortDeck_Show(player.ship); - lose escorts here, must call in shipLaunchedFromStation
var ps = player.ship; //show mfd as early as other mfds but avoid no escorts message
if( ps.setMultiFunctionText ) ps.setMultiFunctionText(this.name, "", false);
if( this.$EscortDeckCWS && this.$EscortDeckCWS.$CarriersPlayerInEscort )
return;
this.$EscortDeckFirstMSO = true;
if( this.$Derelicts && system && !system.isInterstellarSpace ) { //derelict targets
var m = system.mainStation;
var r = 300; //spread ship in this radius
var ships = system.addShips("escort", 16, //random escorts over the nav buoy
m.position.add(m.vectorForward.multiply( 11000 )), 3*r);
if( this.$EscortDeckSGWS ) {
var a = system.addShips("[asp-sg]", 2,
m.position.add(m.vectorForward.multiply( 1800 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[cobra3-sg]", 2,
m.position.add(m.vectorForward.multiply( 2100 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[ferdelance-sg]", 2,
m.position.add(m.vectorForward.multiply( 2400 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[krait-sg]", 2,
m.position.add(m.vectorForward.multiply( 2700 )), r);
ships.push(a[0]); ships.push(a[1]);
}
var a = system.addShips("[escortdeck-adder]", 4,
m.position.add(m.vectorForward.multiply( 3000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
/* var a = system.addShips("[escortdeck-asp]", 4,
m.position.add(m.vectorForward.multiply( 3500 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[escortdeck-gecko]", 4,
m.position.add(m.vectorForward.multiply( 4000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[escortdeck-sidewinder]", 4,
m.position.add(m.vectorForward.multiply( 4500 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[escortdeck-viper]", 4,
m.position.add(m.vectorForward.multiply( 5000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[cobramk1]", 4,
m.position.add(m.vectorForward.multiply( 6000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[ferdelance]", 4,
m.position.add(m.vectorForward.multiply( 7000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[moray]", 4,
m.position.add(m.vectorForward.multiply( 8000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[cobra3-player]", 4,
m.position.add(m.vectorForward.multiply( 6500 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
var a = system.addShips("[krait]", 4,
m.position.add(m.vectorForward.multiply( 7500 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
*/
if( this.$EscortDeckPWS ) {
var a = system.addShips("[escortdeck-ophidian]", 4,
m.position.add(m.vectorForward.multiply( 8000 )), r);
ships.push(a[0]); ships.push(a[1]); ships.push(a[2]); ships.push(a[3]);
/* var a = system.addShips("[escortdeck-ghavial]", 2,
m.position.add(m.vectorForward.multiply( 8000 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[escortdeck-wolf]", 2,
m.position.add(m.vectorForward.multiply( 8500 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[escortdeck-sniper-wolf]", 2,
m.position.add(m.vectorForward.multiply( 8500 )), r);
ships.push(a[0]); ships.push(a[1]);
*/ var a = system.addShips("[escortdeck-arachnid]", 2,
m.position.add(m.vectorForward.multiply( 9000 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[escortdeck-sniper-arachnid]", 2,
m.position.add(m.vectorForward.multiply( 9000 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[escortdeck-s8]", 2,
m.position.add(m.vectorForward.multiply( 9500 )), r);
ships.push(a[0]); ships.push(a[1]);
var a = system.addShips("[escortdeck-sniper-s8]", 2,
m.position.add(m.vectorForward.multiply( 9500 )), r);
ships.push(a[0]); ships.push(a[1]);
}
for(var i=0; i<ships.length; i++) {
if( ships[i] ) {
ships[i].orientation = ps.orientation;
ships[i].switchAI("nullAI.plist"); //need to deactivate escortdeck AI
if( worldScripts["shipversion"] ) {
worldScripts["shipversion"].shipSpawned(ships[i]);
}
ships[i].awardEquipment("EQ_ESCAPE_POD");
if(i == 0) { //make first ship to weak offender without injectors, need a few shot only to eject it
ships[i].removeEquipment("EQ_FUEL_INJECTION");
ships[i].bounty=33;
ships[i].energy=33;
} else ships[i].abandonShip(); //other ships derelict
} else if( this.$debug ) log(this.name, "ships["+i+"] is undefined ");
}
if( this.$debug ) log(this.name, "test derelict ships: "+ships);
}
}
//
// Internal functions
//
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Version = function _escortdeck_EscortDeck_Version() {
var that = _escortdeck_EscortDeck_Version;
var eq_list = (that.eq_list = that.eq_list || [ "EQ_ESCORTDECK", "EQ_ESCORTDECKXL" ]);
var ship = player.ship;
var i = eq_list.length;
while (i--)
if (ship.equipmentStatus(eq_list[i]) === "EQUIPMENT_OK")
return eq_list[i];
return null;
}
//-----------------------------------------------------------------------------------------------//
this.$onChange = function _escortdeck_onChange() {
if (this.$newUsableProb != (1-this.$EscortDeckBasicUnusableProb) && this.$newUsableProb >= 0 && this.$newUsableProb <= 1) {
this.$EscortDeckBasicUnusableProb = (1-this.$newUsableProb);
log(this.name, "Unusable derelict probability changed to "+this.$EscortDeckBasicUnusableProb);
}
if (this.$newAutoLaunch != this.$EscortDeckAutoLaunch) {
this.$EscortDeckAutoLaunch = this.$newAutoLaunch;
log(this.name, "AutoLaunch changed to "+this.$EscortDeckAutoLaunch);
}
log(this.name,"Config changed, newUsableProb:"+this.$newUsableProb+", newAutoLaunch:"+this.$newAutoLaunch+", $EscortDeckBasicUnusableProb:"+this.$EscortDeckBasicUnusableProb+", $EscortDeckAutoLaunch:"+this.$EscortDeckAutoLaunch);
}
//-----------------------------------------------------------------------------------------------//
this.$damageRatio = function _escortdeck_damageRatio(s) {
var fname = "damageRatio";
var shipEquipments = s.equipment;
var i = shipEquipments.length;
var ok = 0;
var damaged = 0;
var eqpKey, eqpStatus, damaged_ratio;
while (i--) {
eqpKey = shipEquipments[i].equipmentKey;
eqpStatus = s.equipmentStatus(eqpKey);
if (this.$debug) log(this.name, fname+": '"+s.displayName+"' has "+eqpKey+": "+eqpStatus);
if (eqpStatus === "EQUIPMENT_OK") {
ok++;
} else if (eqpStatus === "EQUIPMENT_DAMAGED") {
damaged++;
}
}
if (ok + damaged === 0) {
damaged_ratio = 0;
} else if (ok === 0 && damaged > 0) {
damaged_ratio = 1;
} else {
damaged_ratio = damaged / (damaged + ok);
}
if (this.$debug) log(this.name, fname+": '"+s.displayName+"' has "+damaged+" damaged of "+(damaged+ok)+" equipments, ratio "+damaged_ratio+", $EscortDeckUsable: "+s.script.$EscortDeckUsable);
return damaged_ratio
}
//-----------------------------------------------------------------------------------------------//
this.$isUsable = function _escortdeck_isUsable(s, from_fname) {
var fname = "isUsable";
var unusable_prob, rnd;
if (s.script && s.script.$EscortDeckUsable && s.script.$EscortDeckUsable === -1) return false;
var damaged_ratio = this.$damageRatio(s);
if (this.$EscortDeckNPCEqDamage) {
// NPC Equipment Damage OPC is installed, and it adds _a lot_ of equipment damage
damaged_ratio = damaged_ratio / 6.7;
}
if (this.$debug) log(this.name, fname+"("+from_fname+"): '"+s.displayName+"', adjusted damage_ratio: "+damaged_ratio+", $EscortDeckUsable: "+s.script.$EscortDeckUsable);
// probability of damaged to basic systems + equipment damage
// (it's not a probem being larger than 1)
unusable_prob = this.$EscortDeckBasicUnusableProb + damaged_ratio;
rnd = Math.random();
if (this.$debug) log(this.name, fname+": unusable probability: "+unusable_prob+", random: "+rnd);
return (rnd > unusable_prob);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_HHStoreShip = function _escortdeck_HHStoreShip(ship) {
var that = _escortdeck_HHStoreShip;
var ws = (that.ws = that.ws || worldScripts.escortdeck);
if (!ship) return;
var shipdata = $EscortDeck_MakeShipData(ship);
if (shipdata && shipdata[0]) {
ws.$EscortDeck_HHStoreShipData(shipdata);
} else {
log(ws.name, "Trouble creating shipData for "+ship.displayName);
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_HHStoreShipData = function _escortdeck_HHStoreShipData(shipdata) {
var that = _escortdeck_HHStoreShipData;
var ws = (that.ws = that.ws || worldScripts.escortdeck);
var hh = (that.hh = that.hh || worldScripts.HyperspaceHangar);
if (shipdata && shipdata[0]) {
var k = clock.absoluteSeconds;
while (hh._shipsStored[k]) k++;
var displayName = shipdata[0][3];
shipdata[0][0] = galaxyNumber;
shipdata[0][1] = system.ID;
hh._shipsStored[k] = JSON.stringify(shipdata);
hh._currentNames[k] = displayName;
if (hh._currentNames["0_EXIT"] === "EMPTY") hh._currentNames["0_EXIT"] = "Exit";
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_AddEscort = function _escortdeck_AddEscort( t, e, owner, w, msg ) { //add t into the deck of ship if possible
var _fname = "$EscortDeck_AddEscort";
// if (this.$debug) log(this.name, _fname+": examining "+(t.displayName ? t.displayName : t)+", mass:"+t.mass);
if( t && t.isValid && t.script &&
( t.isDerelict || t.script.$EscortDeckUsable === -1 || t.script.$EscortDeckUsable > 0 )
&& t.mass > 1000 && t.mass < this.$EscortDeckExtremeMass && !t.isVisualEffect && !t.isPlayer
&& !t.isDock && !t.isStation && !t.isCargo && !t.isRock && !t.isThargoid && !t.isWeapon
&& owner && owner.isValid
&& ( owner.equipmentStatus("EQ_ESCORTDECK") == "EQUIPMENT_OK"
|| owner.equipmentStatus("EQ_ESCORTDECKXL") == "EQUIPMENT_OK" )
&& owner.mass >= w.$EscortDeckMinMass
&& owner.position.distanceTo(t.position) < w.$EscortDeckLandingDist + t.collisionRadius ) {
var p = e.indexOf(t);
if( p > -1 && t.AIState != "LANDING" ) return false;//owned escort is on way, do not land
var r = this.$EscortDeck_TooLarge(t, owner, w);
if( r ) { //reason
w.$EscortDeckLastTooLargeTarget = t; //prevent repeated message
if( msg && owner == player.ship ) {
player.consoleMessage("You can't pick up "+t.displayName+" to your Escort Deck, "+r, 10);
}
return false;
}
if (t.script.$EscortDeckUsable != 1 && t.script.$EscortDeckUsable != -1 ) {
// derelict was not examined for usability
if (this.$isUsable(t, _fname)) { //fit into the deck limits and lucky
log(this.name, t.displayName+" is usable");
t.script.$EscortDeckUsable = 1;
t.script.$TowbarUsableShip = true;
t.script.$TowbarShipHealth = 1;
this.$EscortDeck_AwardEQs(t);
} else {
log(this.name, t.displayName+" is NOT usable");
t.script.$EscortDeckUsable = -1; //unusable as escort
t.script.$TowbarUsableShip = false;
if(this.$debug) log(this.name, t.displayName+" is set to unusable: "+t);
}
}
var diff = owner.velocity.subtract( t.velocity ).magnitude();
if( diff > 100 ) {
log(this.name, "Velocity difference ("+(Math.round(diff/10)*10)+"m/s) too big to load into EscortDeck");
if( owner == player.ship && msg && p == -1 ) //not in auto landing
player.consoleMessage(Math.round(diff/10)*10+" m/s speed difference");
return false;
}
//put into the selected pad if fit into
//and regardless of occupied (replace) if this is the current target
var spad = w.$EscortDeckSelectedPad;
if( spad > -1 ) {
if(this.$debug) log(w.name, "Try "+t.displayName+" to selected pad "+(spad+1)); //debug
var f = false; //force replace
if( owner.target == t ) f = true;
r = w.$EscortDeck_PutShip(false, t, spad, owner, msg, f);
if( !r ) return true; //report successfully added
else if(this.$debug) log(w.name, "Can't add "+t.displayName+" to selected pad "+(spad+1)+", "+r); //debug
}
//put owned escorts back to the correct pad
if( p > -1 ) {
if(this.$debug) log(w.name, "Try "+t.displayName+" to old pad "+(p+1)); //debug
r = w.$EscortDeck_PutShip(false, t, p, owner, msg, true);
if( !r ) return true; //report successfully added
else { //if faliled the remove and try other pads as new ships
if(this.$debug) log(w.name, "Can't add "+t.displayName+" back to pad "+(p+1)+", "+r); //debug
e[p] = null;
p = -1;
}
}
if(this.$debug) log(w.name, "Try "+t.displayName+" to empty pads"); //debug
//if Adder or smaller then try Adder pads first
var large = w.$EscortDeck_isLarge(owner, w);
if( large && //side pads need large ship
w.$EscortDeck_AddMini(t, owner, w, msg, false) )
return true; //report successfully added
//non-small escort need large ship
for(var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
if( !w.$EscortDeck_isMiniPad(i, owner, w) ) {
//find the first empty pad except Adder only pads
// log(w.name, i+". free:"+w.$EscortDeck_isPadFree(i, w)); //debug
r = w.$EscortDeck_PutShip(false, t, i, owner, msg, false);
if( !r ) i = w.$EscortDeckPadPos.length;//exit from the for cycle
}
}
if( e.indexOf(t) > -1 ) return true; //report successfully added
//replace first flying escort if no more empty pad and none selected
if(this.$debug) log(w.name, "Try "+t.displayName+" to replace a flying escort");
for(var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
if( !w.$EscortDeck_isMiniPad(i, owner, w)
|| large && w.$EscortDeck_isMini(t) ) {
if( !w.$EscortDeckShipPos[i] ) { //on the way
r = w.$EscortDeck_PutShip(false, t, i, owner, msg, true);
if( !r ) return true;
}
}
}
if( e.indexOf(t) > -1 ) return true; //report successfully added
else {
if( msg && owner == player.ship ) {
player.consoleMessage("No room on Escort Deck for "+t.displayName, 10);
}
if(this.$debug) log(w.name, "Can't add "+t.displayName+" to Escort Deck, "+r); //debug
return false;
}
} //else log(this.name, _fname+": ship "+(t.displayName ? t.displayName : t)+" didn't meet basic condition, ignoring");
return false; //can not add escort to the deck
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_AddMini = function _escortdeck_AddMini( t, owner, w, msg, land ) { //add mini escort to a small pad if possible
if( !w.$EscortDeck_isMini(t) ) return false; //need like an Adder or smaller
for( var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
if( w.$EscortDeck_isMiniPad(i, owner, w) ) {
if( !w.$EscortDeck_PutShip(false, t, i, owner, msg, land ) )
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_AwardEQs = function _escortdeck_AwardEQs(ship) {
var logging = this.$logging;
var debug = this.$debug;
var LN10 = Math.LN10;
var damage_ratio = this.$damageRatio(ship);
function escortdeck_awardEQ(eqKey) {
var eqInfo = EquipmentInfo.infoForKey(eqKey);
var rnd = Math.random();
var threshold = 0.03 * eqInfo.techLevel + 0.05 * Math.log(eqInfo.calculatedPrice/10)/LN10;
if (debug) log("escortdeck", "usable "+ship.displayName+", "+eqKey+": tl:"+eqInfo.techLevel+" ("+0.03 * eqInfo.techLevel+"), price: "+eqInfo.calculatedPrice/10+" ("+0.05 * Math.log(eqInfo.calculatedPrice/10)/LN10+"), threshold: "+threshold+", rnd: "+rnd);
if (rnd > threshold) {
var damage_prob = damage_ratio * eqInfo.damageProbability;
ship.awardEquipment(eqKey);
if (Math.random() < damage_prob) ship.setEquipmentStatus(eqKey, "EQUIPMENT_DAMAGED");
if (logging) log("escortdeck", "awarding "+eqKey+"("+ship.equipmentStatus(eqKey)+") to usable "+ship.displayName);
return true;
}
return false;
}
//award player specific equipments, useful when sitting in from a Carrier
if (ship && ship.isValid) {
escortdeck_awardEQ("EQ_ADVANCED_COMPASS");
if(worldScripts.combat_MFD) escortdeck_awardEQ("EQ_COMBATMFD");
if (worldScripts.MFDFastConfiguration) escortdeck_awardEQ("EQ_MFD_FAST_CONFIG");
if (ship.hasHyperspaceMotor) escortdeck_awardEQ("EQ_ADVANCED_NAVIGATIONAL_ARRAY");
escortdeck_awardEQ("EQ_MULTI_TARGET");
escortdeck_awardEQ("EQ_SCANNER_SHOW_MISSILE_TARGET");
if (worldScripts.targetAutolock) //requires EQ_SCANNER_SHOW_MISSILE_TARGET so add after
escortdeck_awardEQ("EQ_TARGET_AUTOLOCK");
escortdeck_awardEQ("EQ_TARGET_MEMORY");
escortdeck_awardEQ("EQ_INTEGRATED_TARGETING_SYSTEM");//requires Target Memory so add after
if (worldScripts.telescope) escortdeck_awardEQ("EQ_TELESCOPE");
if (worldScripts.sniperlock) escortdeck_awardEQ("EQ_SNIPERLOCK");
if (worldScripts.towbar) escortdeck_awardEQ("EQ_LASERREDUCTOR");
if (worldScripts.traildetector) escortdeck_awardEQ("EQ_TRAIL_DETECTOR");
if (worldScripts.Police_Scanner_Upgrade) escortdeck_awardEQ("EQ_POLICE_SCANNER_UPGRADE");
if (worldScripts.hudselector) escortdeck_awardEQ("EQ_HUDSELECTOR");
if (worldScripts.BarrelRoll) escortdeck_awardEQ("EQ_BARREL_ROLL");
escortdeck_awardEQ("EQ_WORMHOLE_SCANNER");
escortdeck_awardEQ("EQ_HEAT_SHIELD");//protection for sunskimming, requested by QCS
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Bounty = function _escortdeck_Bounty( ship ) {
if( ship.isDerelict && ship.bounty > 0 ) {
player.credits += ship.bounty;
player.consoleMessage("Bounty: "+formatCredits(ship.bounty, true, true));
player.consoleMessage("Total: "+formatCredits(player.credits, true, true));
ship.bounty = 0;
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_ControlAll = function _escortdeck_ControlAll( launch, manual, w ) { //launch or call back all escorts
if( launch && w.$EscortDeck_ControlFast(manual) ) return(false);
var c = 0;
var carrier = false;
if( w.$EscortDeckCWS && player.ship.dataKey.indexOf("carrier") > -1 )
carrier = true;
for(var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
if( !w.$EscortDeckLocked[i] &&
( !launch || !carrier || w.$EscortDeckXL || manual ||
//can prevent auto launch of Anaconda from Carrier
w.$EscortDeckCBigTraderLaunch ||
w.$EscortDeckShip && w.$EscortDeckShip[i]
&& w.$EscortDeckShip[i].mass < w.$EscortDeckXLMass ) ) {
if( w.$EscortDeck_Control1(launch, i, false, manual)) //launch without message
c++; //count usable escorts
}
}
if( c > 0 && ( manual || !launch ) ) { //do not message autolaunch when entering red alert
var e = c+" Escorts ";
if( c == 1 ) e = "1 Escort ";
var m = "called back";
if( launch ) m = "on the way";
player.consoleMessage(e+m, 10);
}
w.$EscortDeck_MFD(w); //update MFD
return(c);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_ControlFast = function _escortdeck_ControlFast(manual) {
var max = player.ship.maxSpeed; //no launch over max.speed
// if( !manual ) max = max * 0.999; //no autolaunch at max.speed
if( player.ship.speed > max ) {
if( manual ) player.consoleMessage("You travel too fast to launch escorts", 3);
// else player.consoleMessage("No autolaunch of escorts at maximal speed", 3);
return(true);
}
return(false);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Control = function _escortdeck_Control( launch, pad, msg, w ) { //launch or call back an escort
w.$EscortDeck_Control1(launch, pad, msg, true);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Control1 = function _escortdeck_Control1(launch, pad, msg, manual) { //launch or call back an escort
var that = _escortdeck_Control1;
var w = (that.w = that.w || worldScripts.escortdeck);
if (launch && this.$EscortDeck_ControlFast(manual)) return false;
var s = null;
var p = player.ship;
if (w.$EscortDeckShip) s = w.$EscortDeckShip[pad];
if (s && s.isValid) {
if (!s.script || !(s.script.$EscortDeckUsable > 0)) { //unusable
if (msg) w.$EscortDeck_Release(p, pad, w); //msg mean manual and one ship
return(false);
}
var m = null; //the carrier can't launch
if (launch && !w.$EscortDeckLocked[pad]) {
var seen = [];
s.script.shipAttackedOther = this.shipAttackedOther;
s.script.shipKilledOther = this.shipKilledOther;
s.script.$debugHarderWay = true;
s.script.$debug = false;
s.script.$logging = true;
log(this.name, "Launching "+s.displayName+" from Pad "+pad+", escortdeckUsable "+s.script.$EscortDeckUsable+" script: "+JSON.stringify(s.script, function(key,val) {
if (val != null && typeof val == "object") {
if (seen.indexOf(val) >= 0) {return;}
seen.push(val);
}
return val;
}));
if (p.removeCollisionException) //from v1.81
p.removeCollisionException(s);
w.$EscortDeckShipData[pad] = null; //prevent recreation in dock
w.$EscortDeckShipPos[pad] = null; //do not update position in FCB
//increase steering and acceleration in proportion with the smaller mass on deck
w.$EscortDeck_SetMaxs(p, w);
if (s.AI != "EscortDeck_AI.plist") s.switchAI("EscortDeck_AI.plist");
s.AIState = "GOTO"; //switch back from waypoint AI
s.scannerDisplayColor1 = [0, 0.7, 0]; //green
s.velocity = p.velocity; //prevent collision if player travel at speed
if (w.$EscortDeckPadVec) {//help to leave the owner: jump 20m far
var j = w.$EscortDeckJumpDist;
var x = j * w.$EscortDeckPadVec[pad][0];
var y = j * w.$EscortDeckPadVec[pad][1];
var z = j * w.$EscortDeckPadVec[pad][2];
if (p.dataKey.indexOf("carrier") > -1) {
if (w.$EscortDeck_isMiniPad(pad, p, w)) {
z = j; //Carrier mini pads jump forward
} else if(!w.$EscortDeckXL) { //traders jump sideways
if (pad == 6) {x = j; z = 0;}
else if (pad == 5) {x = -j; z = 0;}
}
}
var o = p.orientation;
var sp = s.position.add(o.vectorRight().multiply(x))
.add(o.vectorUp().multiply(y))
.add(p.heading.multiply(z));
if (sp.magnitude() > 500) s.position = sp;
}
s.script.$EscortDeckOnDeck = false;
m = "on the way";
} else { //call back
if (s.AIState != "DECK") { //isn't in deck already
// if( !w.$EscortDeckShipPos[pad] ) {
if (s.AI != "EscortDeck_AI.plist") s.switchAI("EscortDeck_AI.plist");
s.AIState = "LANDING"; //switch back from waypoint AI
m = "called back";
}
}
if (m && msg) {
player.consoleMessage(s.displayName+" "+m, 5);
w.$EscortDeck_MFD(w); //update MFD
}
if (w.$debug) log(w.name, pad+". launch:"+launch+" "+m); //debug
if (m) return true;
}
return false;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_EQActivated = function _escortdeck_EQActivated(w) { //launch or call back one or all escorts
var p = player.ship; //called from carriers-escort-eq.js also!
if( !p || !p.isValid ) return;
if( w.$EscortDeckSelectedPad == w.$EscortDeckPadPos.length && w.$EscortDeckToWS ) {
if( w.$EscortDeckToWS.$TowbarShip ) w.$EscortDeckToWS.$Towbar_Release();
else player.consoleMessage("No ship on Towbar");
} else if( w.$EscortDeckSelectedPad == -2 ) { //setup sit into mode
w.$EscortDeckSitInto = !w.$EscortDeckSitInto; //flip-flop
w.$EscortDeck_EQDisplayMode(w);
} else if( w.$EscortDeckSelectedPad == -1 ) { //launch or call back all escorts
w.$EscortDeckLaunch = !w.$EscortDeckLaunch; //flip-flop
w.$EscortDeck_ControlAll(w.$EscortDeckLaunch, true, w);
} else { //launch or call back a selected escort with message
var s = w.$EscortDeckShip[w.$EscortDeckSelectedPad];
if( s && s.isValid ) {
if( w.$EscortDeckShipPos[w.$EscortDeckSelectedPad] ) {
if( w.$EscortDeckLocked[w.$EscortDeckSelectedPad] ) {
w.$EscortDeckLaunch = true; //launch if on deck and locked
w.$EscortDeckLocked[w.$EscortDeckSelectedPad] = false;
} else {
w.$EscortDeckLaunch = false;
w.$EscortDeckLocked[w.$EscortDeckSelectedPad] = true; //lock
}
w.$EscortDeck_MFD(w); //update MFD
} else {
w.$EscortDeckLocked[w.$EscortDeckSelectedPad] = false;
if( s.AIState == "LANDING" ) w.$EscortDeckLaunch = true;
else {
w.$EscortDeckLaunch = false;
if( s.dataKey.indexOf("carrier-player") > -1 ) {
if( p.target == s ) {//target is the player's carrier?
player.consoleMessage("Approach the Carrier "+
"within "+w.$EscortDeckLandingDist+
"m with small speed difference "+
" for landing",10);
} else { player.consoleMessage("Hold ident lock on"+
" your Carrier to keep up"+
" landing clearance",5);
}
}
}
}
if( w.$EscortDeckSitInto //deck is in the "sit into the escort" mode
&& w.$EscortDeckCWS //Carriers OXP is installed
&& p.dataKey.indexOf("carrier-player") > -1 //player in the Carrier
&& s.AIState == "DECK" //selected a landed, usable and playable escort
&& s.missileCapacity > 0 //bugfix against a core bug with 0 max_missiles
&& w.$EscortDeckPlayableDataKeys.indexOf(s.dataKey) > -1 ) {
w.$EscortDeckCWS.$Carriers_SitIntoAnEscort(s); //launch player
} else w.$EscortDeck_Control( w.$EscortDeckLaunch,
w.$EscortDeckSelectedPad, true, w);
} else { //no ship in this pad
if( w.$EscortDeckLocked[w.$EscortDeckSelectedPad] )
w.$EscortDeckLocked[w.$EscortDeckSelectedPad] = false;
else w.$EscortDeckLocked[w.$EscortDeckSelectedPad] = true;
}
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_EQDisplayMode = function _escortdeck_EQDisplayMode(w) {
if( w.$EscortDeckSelectedPad == -1 ) { //launch or callback mode
var l = "Launch all non-locked";
if( w.$EscortDeckLaunch ) l = "Call back all flying";
player.consoleMessage(l+" escorts when EscortDeck activated",5);
} else if( w.$EscortDeckSelectedPad == -2 ) { //setup sit into mode
var l = "avoid";
if( w.$EscortDeckSitInto ) l = "allow";
player.consoleMessage("EscortDeck "+l+" to sit into a selected escort",5);
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_EQMode = function _escortdeck_EQMode(w, playable) { //select the next pad on escort deck
var p = player.ship; //called from carriers-escort-eq.js also!
if( p && p.isValid ) {
w.$EscortDeckSelectedPad++;
/* if( playable ) { - removed to allow select any ship to drop salvage, etc.
var start = false;
if( w.$EscortDeckSelectedPad == 0 ) start = true; //start from the first pad
var found = -1;
while( found < 0 && w.$EscortDeckSelectedPad < w.$EscortDeckPadPos.length ) {
var s = w.$EscortDeckShip[w.$EscortDeckSelectedPad];
if( s && s.isValid && s.script && s.script.$EscortDeckUsable > 0
&& w.$EscortDeckPlayableDataKeys.indexOf(s.dataKey) > -1 )
found = w.$EscortDeckSelectedPad;
w.$EscortDeckSelectedPad++;
}
w.$EscortDeckSelectedPad = found;
if( start && found == -1 )
player.consoleMessage( "You have not any playable ships on board", 5 );
}
*/
// while( w.$EscortDeckSelectedPad < w.$EscortDeckPadPos.length
// && !w.$EscortDeckShip[w.$EscortDeckSelectedPad] ) //skip empty pads
// w.$EscortDeckSelectedPad++; - no skip to be able to lock to a specific pad
if( !w.$EscortDeckToWS || w.$EscortDeckSelectedPad <= w.$EscortDeckPadPos.length ) {
if( w.$EscortDeckSelectedPad >= w.$EscortDeckPadPos.length ) {
if( w.$EscortDeckSitIntoWithMode //allowing sit into enabled with mode key
&& p.dataKey.indexOf("carrier") > -1 )//and player in a Carrier
w.$EscortDeckSelectedPad = -2; //setup sit into mode
else w.$EscortDeckSelectedPad = -1; //none selected
var ws = w.$EscortDeckTWS; //Telescope worldScript
if( ws ) ws.$TelescopeTargetSet = true;
p.target = null;
if( ws ) ws.$TelescopeTargetSet = false;
}
if( w.$EscortDeckSelectedPad > -1 ) {
var s = w.$EscortDeckShip[w.$EscortDeckSelectedPad];
if( s && s.isValid ) {
var ws = w.$EscortDeckTWS; //Telescope worldScript
if( ws ) {
var mi = ws.$TelescopeList.indexOf( s );
if( mi == -1 ) ws.$Telescope_Scan(); //forced rescan
if( mi > -1 ) {
if( ws.$TelescopeListi != mi + 1 ) {
ws.$TelescopeListi = mi + 1;
ws.$Telescope_Show2( false ); //lock target
}
}
} else p.target = s; //target the selected ship
}
} else w.$EscortDeck_EQDisplayMode(w);
}
w.$EscortDeck_MFD(w); //update MFD
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_FCB = function _escortdeck_FCB(delta) { //FrameCallBack updating positions of escort ships
var that = _escortdeck_FCB;
var owner = (that.owner = that.owner || player.ship); //modify this for NPCs
var w = (that.w = that.w || worldScripts.escortdeck);
var wSV = (that.wSV = that.wSV || worldScripts.shipversion); // ShipVersion
var tb = (that.tb = that.tb || w.$EscortDeckToWS); // Towbar
var oldSV = (that.oldSV = that.oldSV || (wSV && wSV.version && wSV.version > "1.24" ? false : true));
if (!owner || !owner.isValid) { //test with PS.explode() in debug console
var v = w.$EscortDeckV;
if (!v || !v.position) return; //exit if player died
if (!w.$EDH) w.$EDH = v.heading.multiply(-4).add(Vector3D.randomDirection());
v.position = v.position.add(w.$EDH.multiply(100*delta)); //deck drift away
v.orientation = v.orientation.rotateX(delta).rotateY(delta).rotateZ(delta/2);
//log(w.name, w.$EscortDeckV.position.x);
return;
}
var zv = w.$EscortDeckZV;
var eship = w.$EscortDeckShip;
var epos = w.$EscortDeckShipPos;
if (owner != player.ship && owner.script && owner.script.$EscortDeckZV) { //NPC
zv = owner.script.$EscortDeckZV;
eship = owner.script.$EscortDeckShip;
epos = owner.script.$EscortDeckShipPos;
} else if (w.$EscortDeckCWS && w.$EscortDeckCWS.$CarriersPlayerInEscort) {
owner = w.$EscortDeckCWS.$CarriersCarrier; //deck is no more on player ship but on Carrier
if (!owner || !owner.isValid) return; //exit if carrier died
}
if (!zv) {
if (!zv) zv = Vector3D(0,0,-50);
zv.x = 0;
var hl = owner.boundingBox.z * 0.5; //half of the ship's length
if (zv.z < hl) zv.z = -hl; //correct z position for carriers
if (zv.y > 0) zv.y = 0; //do not raise over the center line
w.$EscortDeckZV = zv;
}
var d = w.$EscortDeckShipData;
var sh = w.$EscortDeckSpawnedShips.pop();
if ( sh && sh.isValid && oldSV) {
// restore ship data after ShipVersion's shipSpawned has its way with the ship
// ShipVersion 1.25+ looks for ship.script.$ShipVersionIgnore, which we set, and ignores the ship
var pad = eship.indexOf(sh);
if (w.$debug) log(w.name, "FCB pad:"+pad+" d:"+d[pad]);
if (pad > -1 && d[pad]) {
var seen = [];
w.$EscortDeck_RestoreShipData(sh, d[pad], w, owner);
log(w.name, "restored ship: "+JSON.stringify(sh, function(key,val) {
if (val != null && typeof val == "object") {
if (seen.indexOf(val) >= 0) {return;}
seen.push(val);
}
return val;
}));
}
}
// if(w.$debug) log(w.name, "FCB pad:1 d:"+d[1]);
//set the new position of the deck if exist (carriers haven't added deck)
var dp = owner.position.add(owner.heading.multiply(zv.z)); //deck position, used at escorts also
if (zv.y != 0) dp = dp.add(owner.orientation.vectorUp().multiply(zv.y)); //move lower if needed
if (w.$EscortDeckV) { //set the new position of the deck if exist (carriers haven't added deck)
w.$EscortDeckV.position = dp;
w.$EscortDeckV.orientation = owner.orientation;
}
//set the new positions of escorts
for (var pad = 0; pad < w.$EscortDeckPadPos.length; pad++) {
var s = eship[pad];
if (s) {
if(s.isValid) {
var sp = epos[pad]; //on deck and is not a Carrier?
if (sp && s.dataKey.indexOf("carrier") === -1) {
var h = owner.heading;
var o = owner.orientation;
var r = o.vectorRight();
var u = o.vectorUp();
var pos = dp.add(h.multiply(sp.z)).add(r.multiply(sp.x)).add(u.multiply(sp.y));
if (pos.magnitude() > 500) s.position = pos;
if (w.$EscortDeckCWS
&& owner.dataKey.indexOf("carrier") > -1) {
w.$EscortDeck_FCBC(s, owner, pad, o, h, r, u, w);
} else if (w.$EscortDeckXL) {
var left = -0.5; //left side of the xl deck
if (Math.round(pad/2) != pad/2) left = 0.5; //right
var p = -Math.PI;
s.orientation=o.rotate(r,p*0.5001).rotate(h,left*p);
} else s.orientation = o.rotate(r, 0.0001);
//if(pad==6 || pad==7) reverse ori
}
} else { //escort ship destroyed
if (w.$EscortDeckShip) {
if (owner != player.ship && (!w.$EscortDeckCWS
|| owner != w.$EscortDeckCWS.$CarriersCarrier))
owner.script.$EscortDeckShip[pad] = null; //NPC escort
else w.$EscortDeckShip[pad] = null; //player escort
}
}
}
}
w.$EscortDeckFCBDelta += delta;
if (w.$EscortDeckFCBDelta > 0.5) { //update AI and MFD twice in a second
w.$EscortDeckFCBDelta = 0;
//check nearby usable derelict for pickup
var t = owner.target;
// log(w.name, "target:"+t); //debug
if (t && w.$EscortDeckLastTooLargeTarget != t //prevent repeated too large message
&& eship.indexOf(t) === -1 //and must not already owned
&& !(tb && tb.$TowbarShip && t == tb.$TowbarShip) ) //and not being towed
w.$EscortDeck_AddEscort(t, eship, owner, w, true);
//AI helper part, keep in sync with the UPDATE parts of EscortDeck_AI.plist
for (var pad = 0; pad < w.$EscortDeckPadPos.length; pad++) {
var s = eship[pad];
if (s && s.isValid && s.AI === "EscortDeck_AI.plist") { //skip waipoint AIs
var e = s.script;
if (s.AIState === "FOLLOW") e._locatePlayer2(s);
else if (s.AIState === "GOTO") e._findPlayerHostiles2(s);
else if (s.AIState === "ATTACK" || s.AIState == "INJECT"
|| s.AIState === "SNIPER") e._combatCheck2(s);
else if (s.AIState === "FLEE") e._fleeCheck2(s);
else if (s.AIState === "LANDING") e._landing2(s);
}
}
w.$EscortDeck_MFD(w); //update MFD
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_FCBC = function _escortdeck_FCBC(s, owner, pad, o, h, r, u, w) { //FrameCallBack rotate ships on Carriers
var left = -0.5001; //left side of the xl deck
if( Math.round(pad/2) != pad/2 ) left = 0.5001; //right side
var p = -Math.PI;
if( w.$EscortDeck_isMiniPad(pad, owner, w) ) {
if( w.$EscortDeckXL ) left = -left;
s.orientation = o.rotate( h, left*p ).rotate( u, left*p*0.6 ).rotate( r, 0.0001 );
} else if( w.$EscortDeckXL && pad > 3 )
s.orientation = o.rotate( u, left*p ).rotate( r, 0.0001 );
else s.orientation = o.rotate( r, 0.0001 ); //fix blinking shaders bug
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_HHGet = function _escortdeck_HHGet(k, pad, w) { //get a ship from Hyperspace Hangar into the given pad
var that = _escortdeck_HHGet;
var w = (that.w = that.w || worldScripts.escortdeck);
var hh = (that.hh = that.hh || worldScripts.HyperspaceHangar);
var d = w.$EscortDeckShipData[pad];
if( !d || !d[1] ) {
log(this.name, "Parsing ship "+k+" "+hh._shipsStored[k]);
w.$EscortDeckShipData[pad] = JSON.parse(hh._shipsStored[k]);
delete hh._shipsStored[k];
delete hh._currentNames[k];
if( Object.keys(hh._currentNames).length < 1 ) //this was the last ship
hh._currentNames["1_EXIT"] = "EMPTY";
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Interface = function _escortdeck_Interface() {
var ps = player.ship; if( !ps || !ps.isValid || !ps.docked ) return;
var n = 0, m = 0, h = this.$EscortDeckShipData, p = this.$EscortDeckPadPos;
if( h ) n = h.length;
if( p ) m = p.length;
var s = "";
if( n > 0 ) {
n = 0;
for(var i = 0; i < m; i++) {
s += " Deck "+(i+1)+": ";
var d = h[i];
if( d && d[0] ) {
n++;
if( d[0][3] ) s += d[0][3]+"\n"; //displayName
else {
if(d[0] && d[0][7]) { //shipClassName
s += d[0][7];
if(d[0][8]) s += d[0][8]; //shipUniqueName
s += "\n";
} else if(d[1]) s += d[1]+"\n"; //dataKey at last resort
}
} else s += "empty\n"
}
n = " ("+n+" of "+m+" ships)";
//s = s.substr( 0, s.length - 2 ); //cut last comma
} else {
n = "";
s = "You have no ships on Escort Deck.";
}
if( ps.equipmentStatus("EQ_ESCORTDECKXL") == "EQUIPMENT_OK" ) n = " XL"+n;
ps.dockedStation.setInterface(this.name,{
title:"Escort Deck"+n,
category:"Ship Systems",
summary:s,
callback:this.$EscortDeck_InterfaceCallBack.bind(this)
});
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_InterfaceCallBack = function _escortdeck_InterfaceCallBack(lastchoice) {
var that = _escortdeck_InterfaceCallBack;
var w = (that.w = that.w || worldScripts.escortdeck);
var hh = (that.hh = that.hh || worldScripts.HyperspaceHangar);
var ps = player.ship; if( !ps || !ps.isValid ) return;
player.ship.hudHidden = true;//to shift down the menu
var d = w.$EscortDeckShipData;
var dkm = null;
if( !w.$EscortDeckI ) w.$EscortDeckSpinModel = false; //rotate only in the subpage
var curChoices = {};
var exitscr = "GUI_SCREEN_INTERFACES";
var ex = "99_EXIT";
var ic = ex;
if( lastchoice === "51_SPIN" ) ic = lastchoice;
var mp = 0;
var msg = "";
var oc = "orangeColor";
var j = 0;
var getHH = false;
var len = w.$EscortDeckPadPos.length;
if( w.$EscortDeckSelectedPad < 0 ) w.$EscortDeckSelectedPad = 0;
if( ps.equipmentStatus("EQ_ESCORTDECK") !== "EQUIPMENT_OK"
&& ps.equipmentStatus("EQ_ESCORTDECKXL") !== "EQUIPMENT_OK" ) {
msg = "You have no Escort Deck";
if( ps.mass > w.$EscortDeckMinMass ) msg += ", buy it in the Equipment shop.";
else msg += ", moreover your ship is too small to hold it."
exitscr = "GUI_SCREEN_EQUIP_SHIP";
} else {
var pad = w.$EscortDeckSelectedPad;
if( w.$EscortDeckI ) { //show submenu when an escort ship is selected
if( d[pad] && d[pad][1] ) {
// curChoices["31_EQUIP"] = {text:"Equip", color:oc };
curChoices["41_RENAME"] = {text:"Rename", color:oc };
if( w.$EscortDeckSpinModel )
curChoices["51_SPIN"] = {text:"Stop rotation", color:oc };
else curChoices["51_SPIN"] = {text:"Rotate", color:oc };
if (d[pad][9] < 7) {
curChoices["61_REFUEL"] = {text:"Refuel", color:oc };
}
if (hh) {
curChoices["71_HH"] = {text:"Put into Hyperspace Hangar", color:oc };
} else curChoices["72_NHH"] = {text:"No Hyperspace Hangar installed",
unselectable:true };
let salvage_price = w.$EscortDeck_SalvagePadPrice(pad);
curChoices["81_SALVAGE"] = {text:"Salvage"+(salvage_price ? " and get about "
+Math.round(salvage_price/1000)*1000+" credits" : ""),
color:"redColor" };
} else if (hh) {
var fitinto=false;
var sID = system.ID;
for( var k in hh._shipsStored ) {
var sh = JSON.parse(hh._shipsStored[k]); //ship in hangar
if (sh[0][1] === sID) {
if( sh && !w.$EscortDeck_TooLarge2b(ps, w, pad, sh)) {
fitinto=true;
var n = sh[0];
if( n ) n = n[3]; else n = sh[1]; //show dataKey if no name
/* if( sh[14] ) {
n += " ("+Math.floor(sh[14].mass/1000)+"t, "
+Math.round(sh[14].x)+"x"
+Math.round(sh[14].y)+"x"
+Math.round(sh[14].z)+"m)";
}*/
curChoices["22_"+k] = "Get "+n+" from Hyperspace Hangar into Deck "+(pad+1);
}
} else { log(this.name, "HyperSpaceHangar ship "+sh[0][3]+" is in system "+sh[0][4]); }
}
if( !fitinto ) {
curChoices["21_PHH"] = {
text:"No ship in Hyperspace Hangar which fit into Deck "
+(pad+1),
unselectable:true };
} else {
getHH = true;
}
} else curChoices["20_NHH"] = { text:"No Hyperspace Hangar installed", unselectable:true };
// curChoices["71_EMPTY_LINE"] = {text:""};
} else { //in the first screen show the list of pads with escort names
for( pad = 0; pad < len && j++ < 20; pad++ ) {
var co = "orangeColor";
var s = d[pad];
var tx = "Deck "+(pad+1)+" ";
var x = 0, y = 0, z = 0, maxmass = 0;
var si = w.$EscortDeckPadSize;
if( si && si[0] ) {
var e = null;
var len = si.length-1;
if( pad < 0 || pad > len ) e = si[len]; //the last line contain the maximums
else e = si[pad];
if( e && e[0] ) {
x = e[0];
y = e[1];
z = e[2];
maxmass = e[3];
}
}
tx += "("+Math.floor(maxmass/1000)+"t, "+x+"x"+y+"x"+z+"m): ";
if( s && s[0] && s[0][3] ) {
tx += s[0][3].substring(0,38);// + " Fuel: "+Math.round(s[9]*10)/10+"ly";
// msg += w.$EscortDeck_MFDAlign(tx, s.AIState)+"\n";
} else {
tx += "Empty";
co = "grayColor";
}
tx += "\n";
var cc = "01_" + ( pad < 10 ? "0" : "" ) + pad;
curChoices[cc] = {text:tx, color:co, alignment:"LEFT"};
if( pad == w.$EscortDeckSelectedPad ) {
ic = cc; //initialChoicesKey
}
}
pad = w.$EscortDeckSelectedPad;
}
msg = "Deck "+(pad+1)+": ";
if( d[pad] && d[pad][1] ) {
dkm = "["+d[pad][1]+"]";//dataKey
mp = d[pad][13];//personality
msg += w.$EscortDeck_InterfaceShipData(d[pad],
w.$EscortDeckSpinModel ); //no eqs when spinning
} else msg += "Empty";
}
if(w.$EscortDeckI) curChoices[ex] = {text:"Back", color:oc};
else curChoices[ex] = {text:"Exit", color:oc, alignment:"LEFT"};
var xl = "";
if( ps.equipmentStatus("EQ_ESCORTDECKXL") == "EQUIPMENT_OK" ) xl = " XL";
var opts = {
screenID: "escortdeck",
title: "Escort Deck"+xl,
background: {name:"escortdeck_bg.png", height:512},//532//546
allowInterrupt: false,
exitScreen: exitscr,
choices: curChoices,
initialChoicesKey: ic,
message: msg,
model: dkm,
modelPersonality: mp,
spinModel: w.$EscortDeckSpinModel
};
if (getHH) {
worldScripts["Paginated Screen"].$runScreen(opts, w.$EscortDeck_InterfaceChoice, w, true);
} else {
mission.runScreen(opts, w.$EscortDeck_InterfaceChoice, w);
}
// if Gallery or Towbar has been loaded and used, remove the frame callback
var g = w.$EscortDeckGWS;
if (g && isValidFrameCallback(g.$GalleryFCB)) removeFrameCallback(g.$GalleryFCB);
var r = w.$EscortDeckToWS;
if( r && isValidFrameCallback( r.$TowbarFCB2 ) ) removeFrameCallback( r.$TowbarFCB2 );
var m = mission.displayModel;
if( m && !w.$EscortDeckSpinModel ) {
m.orientation = m.orientation.rotateZ(-Math.PI/2).rotateX(-Math.PI/4).rotateY(Math.PI/8);
m.position = Vector3D(m.position.x, m.position.y, 150);
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_InterfaceChoice = function _escortdeck_InterfaceChoice(choice) {
var that = _escortdeck_InterfaceChoice;
var w = (that.w = that.w || worldScripts.escortdeck);
// log(this.name, choice+" "+choice.indexOf("01_")+" "+choice.substr(3));
if (choice === "99_EXIT") {
if( !w.$EscortDeckI ) { //selected on the first page
w.$EscortDeckSelectedPad = -1; //clear pad selection
player.ship.hudHidden = false;
return;
} else w.$EscortDeckI = false; //back to the first page
}
if (choice.indexOf("01_") === 0) {
w.$EscortDeckSelectedPad = 1*choice.substr(3);
w.$EscortDeckI = true; //go to the subpage
} else if (choice.indexOf("22_") === 0) { //get ship from HyperHangar
var k = choice.substr(3);
w.$EscortDeck_HHGet(k, w.$EscortDeckSelectedPad, w);
w.$EscortDeckI = false; //back to the first page
} else if (choice === "41_RENAME") {
var pad = w.$EscortDeckSelectedPad;
var d = w.$EscortDeckShipData[pad];
if (d && d[1] ) {
var msg = "Deck "+(pad+1)+": ";
var dkm = "["+d[1]+"]";//dataKey
var mp = d[13];//personality
msg += w.$EscortDeck_InterfaceShipData(d, true)+
"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nType the new name of "
+d[0][3]+":";
mission.runScreen({
screenID: "escortdeck",
title: "Escort Deck",
background: {name:"escortdeck_bg.png", height:512},
allowInterrupt: false,
message: msg,
model: dkm,
modelPersonality: mp,
spinModel: w.$EscortDeckSpinModel,
textEntry: true
},function(text) {
if (text && text.length > 0) {
if( d && d[0] ) {
w.$EscortDeckShipData[pad][0][8]=text;//shipUniqueName
var t = "";
if( d[0][7] ) t = d[0][7]+": ";
w.$EscortDeckShipData[pad][0][3] = t + text;
}
}
w.$EscortDeckI = false; //back to the first page
w.$EscortDeck_InterfaceCallBack(choice); //display the menu again
});
}
return;
} else if (choice === "51_SPIN") {
if( w.$EscortDeckSpinModel ) w.$EscortDeckSpinModel = false;
else w.$EscortDeckSpinModel = true;
} else if (choice === "61_REFUEL") {
this.$EscortDeck_RefuelEscort(w.$EscortDeckShipData[w.$EscortDeckSelectedPad]);
} else if (choice === "71_HH") { //put ship into HyperHangar
w.$EscortDeck_HHStoreShipData(w.$EscortDeckShipData[w.$EscortDeckSelectedPad]);
player.consoleMessage(w.$EscortDeckShipData[w.$EscortDeckSelectedPad][0][3]+" from deck "+(w.$EscortDeckSelectedPad+1)+" stored into Hyperspace Hangar", 10);
w.$EscortDeckShipData[w.$EscortDeckSelectedPad] = [];
w.$EscortDeckI = false; //back to the first page
} else if (choice === "81_SALVAGE") {
//are you sure?
w.$EscortDeck_Salvage(w.$EscortDeckSelectedPad, player.ship);
w.$EscortDeckI = false; //back to the first page
}
w.$EscortDeck_InterfaceCallBack(choice); //display the menu again
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_InterfaceShipData = function _escortdeck_InterfaceShipData(d, noeq, all) {
if (!d || !d[1]) return("No data");
var psd = d[0][3]+"\n";//ship.displayName+
var equip="";
var s="";
s=d[3]; if(s) s=EquipmentInfo.infoForKey(s);//ship.forwardWeapon;
if (s!=null && s.equipmentKey !== "EQ_WEAPON_NONE") equip+="Forward "+s.name;
s=d[2]; if(s) s=EquipmentInfo.infoForKey(s)//ship.aftWeapon;
if (s!=null && s.equipmentKey !== "EQ_WEAPON_NONE") {
if (equip.length > 0) equip+=", "; //Anaconda has aft weapon only
equip+="Aft "+s.name;
}
s=d[4]; if(s) s=EquipmentInfo.infoForKey(s)//ship.portWeapon;
if (s!=null && s.equipmentKey !== "EQ_WEAPON_NONE") equip+=", Port "+s.name;
s=d[5]; if(s) s=EquipmentInfo.infoForKey(s)//ship.starboardWeapon;
if (s!=null && s.equipmentKey !== "EQ_WEAPON_NONE") equip+=", Starboard "+s.name;
if (equip.length > 0) equip+=""; //no newline, save space
else equip+="No Laser";
var eqs = "";
var savedEQ = d[7], counter;
if (!noeq && savedEQ) for (counter = 0; counter < savedEQ.length; counter++) {
if (savedEQ[counter][1] !== "EQUIPMENT_DAMAGED" && savedEQ[counter][0].indexOf("EQ_NUMERIC3_") === -1 && savedEQ[counter][0].indexOf("EQ_ADDHUD_") === -1 && savedEQ[counter][0].indexOf("EQ_XENONHUD_") === -1) {
s = EquipmentInfo.infoForKey(savedEQ[counter][0]);
if (s) {
var n = s.name;
if (n.length > 0) eqs += n + ", ";
}
}
}
eqs = eqs.substr(0, eqs.length - 2); //cut last comma
if (eqs.length > 0) equip+=", "+eqs+"\n";
eqs = "";
if (!noeq && savedEQ) for (counter = 0; counter < savedEQ.length; counter++) {
if (savedEQ[counter][1] === "EQUIPMENT_DAMAGED" && savedEQ[counter][0].indexOf("EQ_NUMERIC3_") === -1 && savedEQ[counter][0].indexOf("EQ_ADDHUD_") === -1 && savedEQ[counter][0].indexOf("EQ_XENONHUD_") === -1) {
s = EquipmentInfo.infoForKey(savedEQ[counter][0]);
if (s) {
var n = s.name;
if (n.length > 0) eqs += n + ", ";
}
}
}
eqs = eqs.substr( 0, eqs.length - 2 ); //cut last comma
if (eqs.length > 0) equip+="\nDamaged: "+eqs+"\n";
var desc = "";
var speed = d[0][19];
psd += "Fuel: "+Math.round(d[9]*10)/10+" ly ";
if (speed > 0) psd += "Speed: "+speed+" mLS ";
if (d[0][17] > 0) psd += "Thrust: "+d[0][17]+" ";
if (d[0][15] > 0) psd += "Pitch: "+Math.round(d[0][15]*100)/100+" ";
if (d[0][16] > 0) psd += "Roll: "+Math.round(d[0][16]*100)/100+" ";
if (d[0][14] > 0) psd += "Yaw: "+Math.round(d[0][14]*100)/100+" ";
var en = "";
var r = "";
if (all && d[0][20] > 0) en = "Energy+Shields: "+d[0][20]+" ";
else {
if (d[0][20] > 0) {
var eb = Math.max(1, Math.floor(d[0][20]/64));
en = "Energy+Shields";
en += ": "+eb+" ";
}
}
var er = d[0][21];
if (er > 0) {
var ers = "";
if (er < 2.5) ers = "Poor";
else if (er < 3.5) ers = "Medium";
else if (er < 4.5) ers = "Good";
else if (er < 10) ers = "Excellent";
else ers = "Extreme";
if (all) ers += " ("+er+")";
r = "Recharge: "+ers+" ";
}
if (d[0][6] > 0) {
var v = Math.round(d[0][6]/1333)*1000; //trade-in value is 75% of ship price
psd += "Value: "+formatCredits(v, false, true)+" ";
}
psd += "\n"+en+r;
//{usable:u, mass:ship.mass, x:b.x, y:b.y, z:b.z});//storedShipArray[14]
if (d[14]) psd += "Mass: "+Math.max(Math.round(d[14].mass/100)/10, 1)+ //min.1t
"t Size: "+Math.round(d[14].x)+"*"+
Math.round(d[14].y)+"*"+Math.round(d[14].z)+"m ";
// "m Radius: "+Math.round(ship.collisionRadius)+"m"+//" Sphere: "+sp+"m^2"+
psd += "\n"+equip;
psd = desc + psd;
return(psd);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_isFreePadFor = function _escortdeck_isFreePadFor(eqKey, owner, context, w, mini) {
//called from escortship equipment conditions
//should check TooLarge but no ship nor mass,etc. data available
//due to shouldn't spawn ships in equipment conditions
//so must provide in the prefilled $EscortDeckEqs array for TooLarge3
var len = w.$EscortDeckPadPos.length;
for(var i = 0; i < len; i++ ) {
if( !w.$EscortDeckShipData[i] && //find the first empty pad where fit
( !w.$EscortDeck_isMiniPad(i, owner, w) || mini ) ) {
if( !w.$EscortDeckEqs || !w.$EscortDeckEqs[eqKey] ||
!w.$EscortDeck_TooLarge3( owner, w,
w.$EscortDeckEqs[eqKey][3],
w.$EscortDeckEqs[eqKey][0],
w.$EscortDeckEqs[eqKey][1],
w.$EscortDeckEqs[eqKey][2], i ) )
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_isLarge = function _escortdeck_isLarge(ship, w) { //check if the ship is over the large border
var m = ship.mass; //revert HardShips' double mass caused by density=2
if( ship.scriptInfo && ship.scriptInfo.hardarmour > 1 ) m = m / 2;
if( m >= w.$EscortDeckLargeMass ) return true;
return false;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_isMini = function _escortdeck_isMini(ship) { //check if the ship is like an Adder or smaller
if( !ship || !ship.isValid ) return false;
var b = ship.boundingBox;
if( !b || ship.mass > this.$EscortDeckPad.mini[3]
|| b.x > this.$EscortDeckPad.mini[0]
|| b.y > this.$EscortDeckPad.mini[1]
|| b.z > this.$EscortDeckPad.mini[2] ) return false;
return true;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_isMiniPad = function _escortdeck_isMiniPad(pad, owner, w) { //check if this pad is for mini ships only
if( w.$EscortDeckCWS && owner.dataKey.indexOf("carrier") > -1 ) {
if( w.$EscortDeckXL ) {
if( pad != 8 && pad != 9 ) return false;
} else if( pad != 7 && pad != 8 ) return false;
} else if( w.$EscortDeckXL || pad != 4 && pad != 5 ) return false;
return true;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_isPadFree = function _escortdeck_isPadFree(pad, owner, w) { //is this pad free for this ship?
var s = null; //or the assigned ship is not valid or not in scanner range
if( w && w.$EscortDeckShip ) s = w.$EscortDeckShip[pad];
if( w && pad < w.$EscortDeckPadPos.length && ( !s || !s.isValid
// || owner && owner.isValid && owner.position.distanceTo(s.position) > owner.scannerRange
|| pad == w.$EscortDeckSelectedPad ) ) { //pad is selected to replace ship?
return(true);
}
return(false);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_MakeShipData = function _escortdeck_MakeShipData(ship) {
var that = _escortdeck_MakeShipData;
var ssh = (that.ssh = that.ssh || worldScripts["Ship_Storage_Helper.js"]);
if (!ship || !ship.isValid) return null;
var storedShipArray = [];
var entry_time = Date.now();
if (ssh && ssh.storeCurrentShipToArray) {
storedShipArray = ssh.storeCurrentShipToArray(ship);
} else {
var stationAttributes;
if (ship.dockedStation) {
stationAttributes = [ship.dockedStation.primaryRole,ship.dockedStation.dataKey, ship.dockedStation.position];
} else {
stationAttributes = [null,null,null];
}
storedShipArray.push([galaxyNumber, system.ID, clock.seconds, ship.displayName,
system.name, stationAttributes, ship.price,
ship.shipClassName, ship.shipUniqueName, ship.AIScriptWakeTime, ship.beaconLabel,
ship.destinationSystem, ship.exhaustEmissiveColor, ship.homeSystem,
ship.maxYaw, ship.maxPitch, ship.maxRoll, ship.maxThrust, ship.thrust,
ship.maxSpeed, ship.maxEnergy, ship.energyRechargeRate, ship.cargoSpaceCapacity,
ship.injectorBurnRate, ship.injectorSpeedFactor,
ship.scanDescription, ship.hyperspaceSpinTime,
ship.scannerHostileDisplayColor1, ship.scannerHostileDisplayColor2,
ship.forwardShield, ship.maxForwardShield, ship.forwardShieldRechargeRate,
ship.aftShield, ship.maxAftShield, ship.aftShieldRechargeRate,
ship.passengerCapacity]); //storedShipArray[0]
storedShipArray.push(ship.dataKey); // storedShipArray[1]
if (!ship.aftWeapon) { // storedShipArray[2]
storedShipArray.push(ship.aftWeapon);
} else {
storedShipArray.push(ship.aftWeapon.equipmentKey);
}
if (!ship.forwardWeapon) { // storedShipArray[3]
storedShipArray.push(ship.forwardWeapon);
} else {
storedShipArray.push(ship.forwardWeapon.equipmentKey);
}
if (!ship.portWeapon) { // storedShipArray[4]
storedShipArray.push(ship.portWeapon);
} else {
storedShipArray.push(ship.portWeapon.equipmentKey);
}
if (!ship.starboardWeapon) { // storedShipArray[5]
storedShipArray.push(ship.starboardWeapon);
} else {
storedShipArray.push(ship.starboardWeapon.equipmentKey);
}
var missiles = [];
if( ship.missileCapacity > 0 ) { //bugfix of "Tried to init array with nil object" in Oolite 1.81
missiles = ship.missiles;
var counter;
for(counter = 0;counter<missiles.length;counter++)
missiles.splice(counter,1,missiles[counter].equipmentKey);
}
storedShipArray.push(missiles); // storedShipArray[6]
var equipment = ship.equipment;
var tempArray;
for(counter = 0;counter<equipment.length;counter++) {
tempArray = [equipment[counter].equipmentKey, ship.equipmentStatus(equipment[counter])];
equipment.splice(counter,1,tempArray);
}
storedShipArray.push(equipment); // storedShipArray[7]
storedShipArray.push(ship.cargoList); // storedShipArray[8]
storedShipArray.push(ship.fuel); //storedShipArray[9]
storedShipArray.push(new Array); //passengers is player only, storedShipArray[10]
var subEnts = new Array;
if (ship.subEntityCapacity > 0 && ship.subEntityCapacity !== ship.subEntities.length) {
// only store subEnts if at less than capacity
for (counter = 0;counter < ship.subEntities.length; counter++) {
subEnts.push([ship.subEntities[counter].dataKey,
ship.subEntities[counter].position.x,
ship.subEntities[counter].position.y,
ship.subEntities[counter].position.z]);
}
}
storedShipArray.push(subEnts);//storedShipArray[11]
if( ship == player.ship ) {
storedShipArray.push(ship.serviceLevel);//storedShipArray[12]
ship.script.$SSH_serviceLevel = ship.serviceLevel; //save for Carriers OXP
} else if( ship.script ) storedShipArray.push(ship.script.$SSH_serviceLevel);
storedShipArray.push(ship.entityPersonality);//storedShipArray[13]
var u = 0; //escortdeck specific data
if( ship.script && ship.script.$EscortDeckUsable > 0 )
u = ship.script.$EscortDeckUsable;
var b = ship.boundingBox; //mass for TooLarge and ship price, sizes needed in playerboughtnewship
storedShipArray.push({usable:u, mass:ship.mass, x:b.x, y:b.y, z:b.z});//storedShipArray[14]
}
if (this.$debug) log(this.name, "Serializing ship "+ship.displayName+" took "+(Date.now()-entry_time).toFixed(0)+"ms");
return(storedShipArray);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_MassFactor = function _escortdeck_MassFactor(ship, w) { //compute thrust reduction due to extra mass in deck
var m = 0; //total mass of ships on deck
for(var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
var d = w.$EscortDeckShipData[i]; //inside stations must use the saved data array
var s = w.$EscortDeckShip[i];
if( ( d || s ) && w.$EscortDeckShipPos[i] ) { //there is a ship in this deck
if( d && d[14] && d[14].mass > 0 ) m += d[14].mass;
else if( s && s.mass > 0 ) m += s.mass;
else m += 50000; //guess
}
}
//in proportion with the original mass (max. 1)
return( ship.mass / ( ship.mass + m / 3 ) );
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_MFD = function _escortdeck_MFD(w) { //update MFD
var ps = player.ship; if (!ps || !ps.isValid) return;
var d = w.$EscortDeckShipData;
var mfd = "";
var j = 0;
var len = w.$EscortDeckPadPos.length;
if (w.$EscortDeckDockingTunnel) ; //show an empty MFD while the player travel in the tunnel
else if (ps.equipmentStatus("EQ_ESCORTDECK") != "EQUIPMENT_OK"
&& ps.equipmentStatus("EQ_ESCORTDECKXL") != "EQUIPMENT_OK")
mfd = "No Escort Deck\n";
else for ( var pad = 0; pad < len && j++ < 10; pad++) {
var s = w.$EscortDeckShip[pad];
var state = "";
if (w.$EscortDeckLocked[pad]) state = "LOCKED";
var l = (pad+1)+": ";
if (pad == w.$EscortDeckSelectedPad) l += "-> "; //mark selected pad
if (s && s.isValid) {
if (state.length == 0) state = s.AIState; //only if not locked
if (s.script && s.script.$EscortDeckUsable > 0) { //show for usables only
//l += s.shipUniqueName.substring(0,18)+" E"+Math.round(s.energy/64);
l += (s.shipUniqueName ? s.shipUniqueName.substring(0,18) : s.shipClassName.substr(0,18))+" E"+s.energy.toFixed(0);
//+"/"+Math.round(s.maxEnergy/64);
//first 18 char to fit into but show Sidewinder Special
//l += " E"+Math.round(s.energy);
// var r = "";
// var t = Math.round(s.maxEnergy/64); //total letters
// for(var k = 0; k < t; k++ )
// if( k < Math.round(s.energy/64) ) r += "E";
// else r += "-"; //empty bank
// l += " "+r;
//if( s.equipmentStatus("EQ_FUEL_INJECTION") == "EQUIPMENT_OK" )
l += " F"+Math.ceil(s.fuel-0.01);
if (s.forwardShield)
l += " S"+Math.ceil(s.forwardShield/64)+Math.ceil(s.aftShield/64);
if (s.forwardShield < 64 || s.aftShield < 64 )
log(this.name, "Escort "+s.displayName+" has low shields: "+s.forwardShield.toFixed(0)+"/"+s.aftShield.toFixed(0));
if (!w.$EscortDeckShipPos[pad]) //not in deck
l += " "+Math.floor(ps.position.distanceTo(s.position)/1000)+"km "+w.$EscortDeck_MFDFrom(s.position);
} else l += s.displayName+" ("+Math.round(s.mass/1000)+"t)";
mfd += this.$EscortDeck_MFDAlign(l, state)+"\n";
} else {
var x = 0, y = 0, z = 0, maxmass = 0;
var s = w.$EscortDeckPadSize;
if (s && s[0]) {
var e = null;
var len = s.length-1;
if (pad < 0 || pad > len) e = s[len]; //the last line contain the maximums
else e = s[pad];
if (e && e[0]) {
x = e[0];
y = e[1];
z = e[2];
maxmass = e[3];
}
}
l += "("+Math.floor(maxmass/1000)+"t, "+x+"x"+y+"x"+z+"m)";
if (state.length > 0) mfd += this.$EscortDeck_MFDAlign(l, state)+"\n";
else mfd += l+"\n";
}
}
var t = this.$EscortDeckToWS; //Towbar
if (t && j < 10 && !w.$EscortDeckDockingTunnel) {
var l = "T: ";
if (j == w.$EscortDeckSelectedPad) l += "-> "; //mark selected pad
var s = t.$TowbarShip;
if (s) {
l += s.displayName+" ("+Math.round(s.mass/1000)+"t)";
mfd += this.$EscortDeck_MFDAlign(l, (s.script && s.script.$EscortDeckUsable && s.script.$EscortDeckUsable > 0 ? "Usable" : "Salvage"))+"\n";
} else mfd += l+"("+Math.floor(ps.mass*1.6/1000)+"t)\n"; //max. mass on towbar
}
if (ps.setMultiFunctionText) ps.setMultiFunctionText(w.name, mfd, false);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_MFDAlign = function _escortdeck_MFDAlign(left, right) { //insert as many spaces between as fill the line
var width = 14.2;
var space = " ";
left += space;
var t = left + right;
while( defaultFont.measureString(t) < width ) {
left += space;
t = left + right;
}
//fine tune with hair spaces - from spara's marketObserver
var hairSpace = String.fromCharCode(31);
while ( defaultFont.measureString(t + hairSpace) < width ) {
left += hairSpace;
t = left + right;
}
return(t);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_MFDFrom = function _escortdeck_MFDFrom(whomposition) { //direction mark
var ship = player.ship;
if( !ship || !ship.isValid || !whomposition || !whomposition.dot ) return ("");
var v = ship.position.subtract(whomposition);
var fw = ship.vectorForward.angleTo(v);
var ri = ship.vectorRight.angleTo(v);
var up = ship.vectorUp.angleTo(v);
var s = ""; // refine if out of front 1 degree cone
if( ri < 1.56 ) s += "<";
if( up > 1.58 ) s += "^";
else if( up < 1.56 ) s += "v";
if( ri > 1.58 ) s += ">";
// if( s.length > 0 || fw < 1 ) //do not exclude the aft 1 degree cone
// s = Math.round( 180 * ( 1 - fw / Math.PI ) ) + "° " + s;
return( s );
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_PutShip = function _escortdeck_PutShip(deckinit, ship, pad, owner, msg, land, xch ) { //put ship into the pad
var that = _escortdeck_PutShip;
var w = (that.w = that.w || worldScripts.escortdeck);
var r = w.$EscortDeck_TooLarge2(ship, owner, w, pad);
if (r) return (r); //too large
if (ship && ship.isValid && owner && owner.isValid
&& (land || w.$EscortDeck_isPadFree(pad, owner, w))) { //landing back or new ship
if (!w.$EscortDeckShip) w.$EscortDeckShip = [];
var old = w.$EscortDeckShip[pad];
var sp = w.$EscortDeckShip.indexOf(ship); //ship pad if already owned
if (old && old.isValid && !xch) { //prevent recursion during exchange with old ship
if (sp > -1 && sp != pad) { //put an owned ship to other pad
//exchange with the old ship if old fit into the another pad
//if( w.$EscortDeck_PutShip(old, sp, owner, w, msg, true, true ) )
w.$EscortDeck_Release(owner, pad, w, //relock old if fit
w.$EscortDeckLandingDist-100, msg);
w.$EscortDeckSelectedPad = -1; //prevent lock to the new pad
owner.target = old; //for relock
} else if (ship != old)
w.$EscortDeck_Release(owner, pad, w, false, msg); //replace old ship
}
if (sp > -1) { //remove from the previous pad
var d = [], s = [];
for(var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
if (i == sp) {
s[i] = null;
d[i] = null;
} else {
s[i] = w.$EscortDeckShip[i];
d[i] = w.$EscortDeckShipData[i];
}
}
w.$EscortDeckShipData = d;
w.$EscortDeckShip = s;
}
w.$EscortDeckShip[pad] = ship;
if (!deckinit) {
w.$EscortDeckShipData[pad] = w.$EscortDeck_MakeShipData(ship);
if (w.$debug) log(w.name, (pad+1)+". "+JSON.stringify(w.$EscortDeckShipData[pad]));
}
var usable = 0;
if (ship.script && ship.script.$EscortDeckUsable > 0)
usable = ship.script.$EscortDeckUsable;
if (usable > 0 && ship.isDerelict) { //removing derelict flag need respawn
var ship2 = w.$EscortDeck_SpawnShip(pad, w, owner);
if (ship2 && ship2.isValid) {
ship.remove(true);
w.$EscortDeckShip[pad] = ship = ship2;
} //else fallback to the derelict ship
}
if (ship.AI != "EscortDeck_AI.plist") ship.switchAI("EscortDeck_AI.plist");
// var js = "escortdeck_escort";
// if( !ship.script || ship.script.name != js ) {
// var sl = 0; //must set usable and sl again after setScript
// if( ship.script ) sl = ship.script.$SSH_serviceLevel;
// ship.setScript(js+".js");
// if( ship.script ) {
// ship.script.$EscortDeckUsable = usable;
// ship.script.$SSH_serviceLevel = sl;
// }
// }
ship.script.$EscortDeckOnDeck = true;
if (usable > 0) {
log(this.name, "Adding escort "+ship.displayName+" with accuracy "+ship.accuracy+" to pad "+pad+", escortdeckUsable:"+ship.script.$EscortDeckUsable);
ship.AIState = "DECK";
if (!owner.group) { //escort group for performEscort AI command
owner.group = new ShipGroup();
owner.group.addShip(owner);
//from Oolite 1.84 the player can not be the leader of a group
if (owner != player.ship) owner.group.leader = owner;
}
if (owner && owner.group.leader != owner && owner != player.ship) owner.group.leader = owner;
if (!owner.group.containsShip(ship)) owner.group.addShip(ship);
} else ship.AIState = "SALVAGE";
ship.beaconCode = "E"+pad+" "+ship.name;
ship.bounty = 0;
ship.scanClass = "CLASS_CARGO"; //prevent masslock
ship.scannerDisplayColor1 = [0,0,0]; //black
//
var carrier = false;
if (w.$EscortDeckCWS && owner.dataKey.indexOf("carrier") > -1) carrier = true;
var p = w.$EscortDeckPadPos[pad];
if (!p) {
w.$EscortDeck_SetPads(owner, w);
p = w.$EscortDeckPadPos[pad];
if (!p) p = [0,70*(pad+1),0];
}
var sp = Vector3D(p[0], p[1], p[2]);
var x = ship.boundingBox.x * 0.5;
var y = ship.boundingBox.y * 0.5;
var z = ship.boundingBox.z * 0.5;
if (w.$EscortDeckXL && (!carrier || pad > 3 && pad < 8)) {
var left = -0.5; //left side of the xl deck
if( Math.round(pad/2) != pad/2 ) left = 0.5; //right side
sp = sp.add(Vector3D(left * 2 * z, 0, 0));
} else {
var v = w.$EscortDeckPadVec[pad];
if (!v) v = [0,1,0];//up
var vx = v[0] * x;
if (!carrier && y > 12) y = 12 - ( y - 12 ); //sunk if taller than 24m
var vy = v[1] * y;
var vz = v[2] * z;
sp = sp.add(Vector3D(vx, vy, vz));
}
if (owner.addCollisionException) owner.addCollisionException(ship); //from v1.81
else if(carrier) { //must move up to avoid kill by Injector speed
var a = y + 25;
if (w.$EscortDeck_isMiniPad(pad, owner, w)) a = 2 * x + 30;
sp = sp.add(Vector3D(0, a, 0));
}
if (sp.magnitude() > 500) ship.position = sp; //prevent terminated by Witchpoint Beacon
if (owner != player.ship && ship.script) {
if (!ship.script.$EscortDeckShipPos)
ship.script.$EscortDeckShipPos = [];
ship.script.$EscortDeckShipPos[pad] = sp; //NPC
} else w.$EscortDeckShipPos[pad] = sp; //player ship
//ship.orientation = owner.orientation;
ship.velocity = owner.velocity;
//slower steering and acceleration in proportion with the mass on deck
w.$EscortDeck_SetMaxs(owner, w);
if (ship.script) {
ship.script.$Towbar_TimedBombCounter = -1; //disarm timed bomb
if (ship.script.$TowbarUsableShip)
ship.script.$TowbarUsableShip = null;
}
if (owner == player.ship) {
if (msg) {
var m = ship.displayName+" locked on deck "+(pad+1);
player.consoleMessage(m, 10);
if (w.$debug) log(w.name, m); //debug
w.$EscortDeckSound.play();
}
}
return false;
}
return("no room");
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Release = function _escortdeck_Release(owner, pad, w, dist, nomsg) {
if( !dist ) var dist = w.$EscortDeckLandingDist + 500; //drop distance over lock range
var s = w.$EscortDeckShip[pad];
if( s && s.isValid ) {
// if (s.script.$EscortDeckUsable < 0) s.script.$EscortDeckUsable = 0;
//move the old ship backward, over the relock range if on deck
if( w.$EscortDeckShipPos[pad] ) {
var sp = s.position.add(player.ship.heading.multiply(-dist));
if( sp.magnitude() > 500 ) s.position = sp; //prevent terminated by Witchpoint Beacon
w.$EscortDeckSound.play();
}
if( owner.removeCollisionException ) //from v1.81
owner.removeCollisionException(s);
w.$EscortDeckShipData[pad] = null;
w.$EscortDeckShip[pad] = null;
w.$EscortDeckShipPos[pad] = null;
s.script.$EscortDeckOnDeck = false;
if(!nomsg && s.dataKey.indexOf("carrier-player") == -1 ) //no msg for carrier
player.consoleMessage( s.displayName+" released from deck "+(pad+1), 10 );
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_RestoreShipData = function _escortdeck_RestoreShipData(s, d, w, owner) {
var that = _escortdeck_RestoreShipData;
var ssh = (that.ssh = that.ssh || worldScripts["Ship_Storage_Helper.js"]);
if (s && s.isValid && d && d[0]) {
var entry_time = Date.now();
if (!s.script) s.setScript("escortdeck_escort.js");
if (ssh && ssh.restoreStoredShipFromArray) {
ssh.restoreStoredShipFromArray(d, s);
} else {
if( d[0][7] ) s.shipClassName = d[0][7];
if( d[0][8] ) s.shipUniqueName = d[0][8];
if( s != player.ship ) s.displayName = d[0][3];
if(d[2]) s.aftWeapon = EquipmentInfo.infoForKey(d[2]);
if(d[3]) s.forwardWeapon = EquipmentInfo.infoForKey(d[3]);
if(d[4]) s.portWeapon = EquipmentInfo.infoForKey(d[4]);
if(d[5]) s.starboardWeapon = EquipmentInfo.infoForKey(d[5]);
//set new writable ship properties in Oolite 1.82
var oolite182 = false;
if (0 < oolite.compareVersion("1.82")) { ; }
else oolite182 = true;
if( oolite182 ) { //these are not writable before Oolite 1.82
var a = d[0];
if( a[9] ) s.AIScriptWakeTime = a[9];
if( a[11] ) s.destinationSystem = a[11];
if( a[12] ) s.exhaustEmissiveColor = a[12];
if( a[13] ) s.homeSystem = a[13];
if( a[14] ) s.maxYaw = a[14];
if( a[15] ) s.maxPitch = a[15];
if( a[16] ) s.maxRoll = a[16];
if( a[17] ) s.maxThrust = a[17];
if( a[18] ) s.thrust = a[18];
if( a[19] ) s.maxSpeed = a[19];
if( a[20] > 0 ) s.maxEnergy = a[20];
if( a[20] > 0 ) {
s.maxEnergy = a[20];
if(s.energy < s.maxEnergy ) s.energy = s.maxEnergy;
}
if( a[21] > 0 ) s.energyRechargeRate = a[21];
if( a[22] ) s.cargoSpaceCapacity = a[22];
if( a[23] ) s.injectorBurnRate = a[23];
if( a[24] ) s.injectorSpeedFactor = a[24];
if( a[25] ) s.scanDescription = a[25];
if( a[26] ) s.hyperspaceSpinTime = a[26];
if( a[27] ) s.scannerHostileDisplayColor1 = a[27];
if( a[28] ) s.scannerHostileDisplayColor2 = a[28];
if( s == player.ship ) {
if( a[29] ) s.forwardShield = a[29];
if( a[30] ) s.maxForwardShield = a[30];
if( a[31] ) s.forwardShieldRechargeRate = a[31];
if( a[32] ) s.aftShield = a[32];
if( a[33] ) s.maxAftShield = a[33];
if( a[34] ) s.aftShieldRechargeRate = a[34];
} else if( a[10] ) s.beaconLabel = a[10]; //read-only for player
}
var counter, counter1;
var equipment = s.equipment;
//remove all equipments
var r = [];
for(counter = 0;counter<equipment.length;counter++)
r.push(equipment[counter].equipmentKey);
for(counter = 0;counter<r.length;counter++) //separated to avoid problems during eq array shortening
s.removeEquipment(r[counter]);
// if(w.$debug) log(w.name, "RestoreShipData2 d:"+d);
// if(w.$debug) log(w.name, "RestoreShipData2e "+equipment);
var tempArray = [];
var savedEQ = d[7];
for(counter = 0; counter < savedEQ.length; counter++) {
tempArray.push(savedEQ[counter][0]);
}
for(counter = 0; counter < equipment.length; counter++) {
var e = equipment[counter].equipmentKey;
var index = tempArray.indexOf(e);
if( index == -1 ) s.removeEquipment(e);
else if( savedEQ[index][1] == "EQUIPMENT_DAMAGED" )
s.setEquipmentStatus( e, "EQUIPMENT_DAMAGED" );
}
var depth = 0;
var retryArray = []; //try again if a required equipment comes later
retryArray[depth] = savedEQ;
do {
var added = false;
retryArray[depth+1] = [];
for(counter = 0; counter < retryArray[depth].length; counter++) {
var e = retryArray[depth][counter][0]; //award if exists and has not
var ed = retryArray[depth][counter][1];
if( EquipmentInfo.infoForKey(e) ) {
if( !s.awardEquipment(e) ) //retry next time if failed
retryArray[depth+1].push([e,ed]);
else {
added = true;
if( ed == "EQUIPMENT_DAMAGED" )
s.setEquipmentStatus( e, "EQUIPMENT_DAMAGED" );
}
}
}
depth++;
// if(w.$debug) log(w.name, "RestoreShipData3 depth:"+depth+" retryArray:"+retryArray[depth]);
} while( retryArray[depth].length > 0 && added && depth < 100 ) //until no more added eq
/* old code lose equipments due to make changes in the original d array
for(counter = 0; counter<equipment.length; counter++) {
tempArray = [equipment[counter].equipmentKey,
s.equipmentStatus(equipment[counter])];
for(counter1 = 0; counter1<savedEQ.length; counter1++) {
if (savedEQ[counter1][0] === tempArray[0]) {
tempArray.push(true);
tempArray.push(counter1);
if (savedEQ[counter1][1] === "EQUIPMENT_DAMAGED")
s.setEquipmentStatus(tempArray[0],
"EQUIPMENT_DAMAGED");
break;
}
}
if (!tempArray[2]) {
s.removeEquipment(tempArray[0]);
continue;
} else savedEQ.splice(tempArray[3],1);
}
for(counter = 0; counter<savedEQ.length; counter++) {
if(EquipmentInfo.infoForKey(savedEQ[counter][0])) {
s.awardEquipment(savedEQ[counter][0]);
if(savedEQ[counter][1] === "EQUIPMENT_DAMAGED")
s.setEquipmentStatus(savedEQ[counter][0],savedEQ[counter][1]);
}
}*/
// if(w.$debug) log(w.name, "RestoreShipData3 d[7]:"+d[7]);
// if(w.$debug) log(w.name, "RestoreShipData3e "+s.equipment);
//ship.cargoList is read-only and no ship.manifest so d[8] is skipped
s.fuel = d[9];
//passengers is player only, so d[10] is skipped
var subEnts = d[11]; //will only exist if less subEnts than capacity when ship was stored.
if (subEnts && subEnts.length>0) {
var currentSubEnts = s.subEntities;
for (counter = 0; counter<currentSubEnts.length; counter++) {
currentSubEnts[counter].toBeRemoved = true;
for(counter1 = 0; counter1<subEnts.length; counter1++) {
if(subEnts[counter1][0] === currentSubEnts[counter].dataKey &&
subEnts[counter1][1] === currentSubEnts[counter].position.x &&
subEnts[counter1][2] === currentSubEnts[counter].position.y &&
subEnts[counter1][3] === currentSubEnts[counter].position.z )
delete currentSubEnts[counter].toBeRemoved;
}
if (currentSubEnts[counter].toBeRemoved) {
delete currentSubEnts[counter].toBeRemoved;
currentSubEnts[counter].remove(true);
}
}
}
//serviceLevel is player only, NPCs store it in script variable
if( d[12] > 0 ) {
if( s == player.ship && d[12] ) s.serviceLevel = d[12];
else if( s.script ) s.script.$SSH_serviceLevel = d[12]; //must set after setScript
}
if (oolite.compareVersion("1.80") < 0) {// can only do this in Oolite 1.81 or greater
s.entityPersonality = d[13];
}
if( s.script && d[14] )
//s.script.$EscortDeckUsable = d[14].usable; //must set after setScript
s.script.$EscortDeckUsable = 1; //must set after setScript
// if(w.$debug) log(w.name, "missileCapacity:"+s.missileCapacity+" d[6]:"+d[6]);
if( s.missileCapacity > 0 ) {
//do missiles at the end due to there is a core bug in Oolite 1.80
//when land back to the carrier from an Asp which has max_missiles=0:
//Error: Native exception: Tried to init array with nil object
var missiles = [];
if( s.missiles && s.missiles.length > 0 ) {
missiles = s.missiles;
for(counter = 0;counter<missiles.length;counter++) {
s.removeEquipment(missiles[counter]);
}
}
missiles = d[6];
if( missiles && missiles.length > 0 ) {
for(counter = 0; counter<missiles.length; counter++)
if(EquipmentInfo.infoForKey(missiles[counter]))
s.awardEquipment(missiles[counter]);
}
}
}
if (s.script && s.script.$EscortDeckUsable === 1) {
var js = "escortdeck_escort";
if (!s.script || s.script.name != js) {
// sanity check only, since we set ship.script as soon as we spawn it
var sl = 0; //must set usable and sl again after setScript
if (s.script) sl = s.script.$SSH_serviceLevel;
s.setScript(js+".js");
if (s.script) {
s.script.$EscortDeckUsable = 1;
s.script.$SSH_serviceLevel = sl;
}
}
// make sure the escorts can use LaserReductor if they have it - if the player wants derelicts, they will have it!
s.script.shipAttackedOther = this.shipAttackedOther;
s.script.shipKilledOther = this.shipKilledOther;
// if running HarderWay, attach SolarWind to ship script if it hasn't been already to set fuel scooping/consumption
if (worldScripts.SolarWind && typeof s.script.$debugHarderWay === 'undefined') worldScripts.SolarWind.shipSpawned(s);
s.script.$debugHarderWay = true; // see log messages form the escorts in Latest.log
// nobody would hire a novice as a escort pilot, so take out the lower accuracy range
if (s.accuracy == null || s.accuracy < 6.1) s.accuracy = 6.1 + 4 * Math.random();
}
var now = Date.now();
if (this.$debug) log(this.name, "Deserializing ship "+s.displayName+" took "+(now-entry_time).toFixed(0)+"ms");
}
if (this.$debug) log(this.name, s.displayName+": shipRestore returns");
return (s);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_RollBack = function _escortdeck_RollBack(eq, msg) {
var f = 1;
if( player.ship && player.ship.dockedStation ) {
var e = player.ship.dockedStation.equipmentPriceFactor;
if( e > 0 ) f = e;
}
player.credits += f * EquipmentInfo.infoForKey(eq).price/10;
player.consoleMessage(msg, 5);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Salvage = function _escortdeck_Salvage( pad, owner ) { //salvage the escort on the given pad
var that = _escortdeck_Salvage;
var w = (that.w = that.w || worldScripts.escortdeck);
var d = null;
if( w.$EscortDeckShipData ) d = w.$EscortDeckShipData[pad];
var s = null;
if( w.$EscortDeckShip ) s = w.$EscortDeckShip[pad];
var sn = "escort";
var t = w.$EscortDeckToWS;
if( t ) {
var s = w.$EscortDeck_SpawnShip( pad, w, owner );
if (s && s.isValid) {
if (w.$debug) log(w.name, "Using Towbar_Payout to salvage "+s.displayName);
t.$Towbar_Payout(s); //call payout in towbar oxp
}
} else { //pay salvage price like in towbar
var cr = w.$EscortDeck_SalvagePadPrice(pad); //salvage payment
log(w.name, "Salvage "+pad+". pad for "+cr+"cr: "+d);
if( s && s.isValid ) sn = s.shipClassName; //must be short name to fit into a line
else {
if( !d || !d[1] ) return false; //no ship in this pad
sn = d[0][7]; //shipClassName
}
player.consoleMessage("You got "+cr+" Cr for salvaging "+sn, 10);
player.credits += cr;
w.$EscortDeckSound2.play();
}
if( s && s.isValid ) s.remove(true);
w.$EscortDeckShipData[pad] = null;
w.$EscortDeckShip[pad] = null;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Salvage2 = function _escortdeck_Salvage2(pad, owner) { //salvage or save into Hyperspace Hangar
var that = _escortdeck_Salvage2;
var w = (that.w = that.w || worldScripts.escortdeck);
var hh = (that.hh = that.hh || worldScripts.HyperspaceHangar);
if (hh && w.$EscortDeckShipData[pad]) {
if (w.$EscortDeckShipData[pad][0])
player.consoleMessage(w.$EscortDeckShipData[pad][0][3]+" from deck "+(pad+1)+" stored into Hyperspace Hangar", 10);
w.$EscortDeck_HHStoreShipData(w.$EscortDeckShipData[pad]);
w.$EscortDeckShipData[pad] = [];//clear this deck
} else w.$EscortDeck_Salvage(pad, owner); //salvage the escort on the given pad
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SalvageBadEscorts = function _escortdeck_SalvageBadEscorts(owner) {
var that = _escortdeck_SalvageBadEscorts;
var w = (that.w = that.w || worldScripts.escortdeck);
if (!owner) return;
var oldlength = w.$EscortDeckPadPos.length; //save the old length before SetPads when sold a Carrier
w.$EscortDeck_SetPads( owner, w );
if (owner.mass < w.$EscortDeckMinMass) { //bought a too small ship
owner.removeEquipment("EQ_ESCORTDECK");
owner.removeEquipment("EQ_ESCORTDECKXL");
for(var i = 0; i < oldlength; i++ ) //salvage all escorts
w.$EscortDeck_Salvage2(i, owner); //or save into Hyperspace Hangar
} else if (!w.$EscortDeck_isLarge(owner, w)) { //no side pads
w.$EscortDeck_Salvage2(4, owner); //salvage or save left adder
w.$EscortDeck_Salvage2(5, owner); //salvage or save right adder
}
if (owner.mass < w.$EscortDeckXLMass) { //bought a non-xl ship
if (owner.equipmentStatus("EQ_ESCORTDECKXL") == "EQUIPMENT_OK") {
owner.removeEquipment("EQ_ESCORTDECKXL"); //downgrade
owner.awardEquipment("EQ_ESCORTDECK");
}
}
if (owner.equipmentStatus("EQ_ESCORTDECKXL") == "EQUIPMENT_OK") w.$EscortDeckXL = true;
else w.$EscortDeckXL = false; //must set XL for the following TooLarge call
for(var i = 0; i < oldlength; i++ ) {
var t = null;
if (w.$EscortDeckShip) t = w.$EscortDeckShip[i]; //the ship on this pad
if (i >= w.$EscortDeckPadPos.length || //salvage too much decks when bougth a smaller ship
w.$EscortDeck_TooLarge2(t, owner, w, i)) //can use ShipData array if no ship
w.$EscortDeck_Salvage2(i, owner); //salvage too large escorts or save into HH
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SalvagePadPrice = function _escortdeck_SalvagePadPrice(pad) { //salvage price of an escort on this pad
var that = _escortdeck_SalvagePadPrice;
var w = (that.w = that.w || worldScripts.escortdeck);
var s = null;
var t = w.$EscortDeckToWS;
if (t) return null; // Towbar_Payout will be used to salvage, we don't know the salvage price
if (w.$EscortDeckShip) s = w.$EscortDeckShip[pad]; //the ship on this pad if player is not docked
if (s && s.isValid) return(w.$EscortDeck_SalvageShipPrice(s, w));
var d = null;
if (w.$EscortDeckShipData) d = w.$EscortDeckShipData[pad]; //inside stations must use the saved data array
if (!d || !d[1]) return(0); //no price for a nonexistent ship
var eq = [];
for (var i = 0; i < d[7].length; i++) {
var ep = 0;
var e = EquipmentInfo.infoForKey(d[7][i][0]);
if (e) ep = e.price;
eq[i] = {price:ep};
if (w.$debug) log(w.name, i+". "+e+" fullprice:"+eq[i].price); //debug
}
var mass = 30000;//guess
if (d[14] && d[14].mass > 0) mass = d[14].mass;
return(w.$EscortDeck_SalvagePrice(mass, eq, d[3], d[2], w));
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SalvagePrice = function _escortdeck_SalvagePrice( mass, eq, fw, af, w ) {//price like in towbar OXP
var hull = Math.round( 32.8 * Math.min(80, Math.round( //1t alloys = 32.8cr in average
0.3 * mass * 0.001 )) * 0.1 ) * 10 //alloys from the hull
var comp = 0; if( mass > 30000 ) comp = 84; //price of 1t computers
var eqcr = 0; //payment for all equipments
var rnd = 0.5;//Math.random(); - removed randomness due to repeated price listing in interface
var i = -1;
function weapon_value(eqKey) {
var value = 0;
if (eqKey) {
var eqInfo = EquipmentInfo.infoForKey(eqKey);
if (eqInfo) {
value = Math.round(eqInfo.price/10*(0.2+rnd*0.2)/10)*10;
}
}
return value;
}
while( eq[++i] ) {
var p = eq[i].price * 0.04; //20% of the original cost in credits (not in credits*10)
if( p > 300 ) {
// rnd = rnd * ( 300 / p ); //costly eqs always damaged - removed, already cheap
eqcr += Math.round( Math.max( 50, Math.round(p * rnd ))/10)*10; //min. 50cr
} else eqcr += Math.round( Math.max( 10,
Math.round( p * rnd ))/10)*10; //at least 10cr
}
//payment for fw and aft weapons, min. 20%, max 40% of original price, fixed rnd mean fix 30%
var fc = weapon_value(fw);
var ac = weapon_value(af);
var cr = hull + comp + eqcr + fc + ac; //all payments but nothing for cargo
return( cr ); //* 0.5 ); //deduct 50% commission - removed, an escort already cheap
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SalvageShipPrice = function _escortdeck_SalvageShipPrice( ship, w ) { //salvage price of this ship
return( w.$EscortDeck_SalvagePrice( ship.mass, ship.equipment,
ship.forwardWeapon, ship.aftWeapon, w ) );
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SaveMaxs = function _escortdeck_SaveMaxs( ship, w ) {
if(ship)
w.$EscortDeckMaxs = {
maxThrust:ship.maxThrust,
maxPitch:ship.maxPitch,
maxRoll:ship.maxRoll,
maxYaw:ship.maxYaw
};
else w.$EscortDeckMaxs = { maxThrust:32, maxPitch:1, maxRoll:2, maxYaw:1 };
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_RestoreMaxs = function _EscortDeck_RestoreMaxs(ship, w) {
var stored_max = w.$EscortDeckMaxs;
if (stored_max) {
ship.thrust = stored_max.maxThrust;
ship.maxPitch = stored_max.maxPitch;
ship.maxRoll = stored_max.maxRoll;
ship.maxYaw = stored_max.maxYaw;
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SetMaxs = function _escortdeck_SetMaxs( ship, w ) {
var old_f = this.$EscortDeckMassFactor;
if( !ship || !ship.addCollisionException //need Oolite v1.81
|| !w.$EscortDeckMassEffect ) return;
var f = w.$EscortDeck_MassFactor(ship, w);
// var m = w.$EscortDeckMaxs; //original maximums of player ship
ship.thrust *= f / old_f;
ship.maxPitch *= f / old_f;
ship.maxRoll *= f / old_f;
ship.maxYaw *= f / old_f;
this.$EscortDeckMassFactor = f;
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SetPads = function _escortdeck_SetPads(owner, w) {
var carrier = false;
if (w.$EscortDeckCWS && owner.dataKey.indexOf("carrier") > -1) carrier = true;
var p = w.$EscortDeckLPos;
var v = w.$EscortDeckLVec;
var xl = "escortdeck";
var m, s = [], si, x, y, z, maxmass;
if (owner && owner.isValid) {
if (owner.equipmentStatus("EQ_ESCORTDECKXL") === "EQUIPMENT_OK") {
w.$EscortDeckXL = true;
} else w.$EscortDeckXL = false;
if (carrier) {
xl = null; //use the carrier's hull as deck
if (w.$EscortDeckXL) { //XL deck on carrier
p = w.$EscortDeckCXPos;
v = w.$EscortDeckCXVec;
si = w.$EscortDeckCXSize;
} else { //normal deck on carrier
p = w.$EscortDeckCPos;
v = w.$EscortDeckCVec;
si = w.$EscortDeckCSize;
}
for (var i = 0; i < p.length; i++) {
var siz = si[i];
if( siz ) {
x = siz[0];
y = siz[1];
z = siz[2];
maxmass = siz[3];
} else x = y = z = maxmass = 0;
s[i] = [x, y, z, maxmass];
if (i == 0) m = [x, y, z, maxmass];
else {
m[0] = Math.max(x, m[0]);
m[1] = Math.max(y, m[1]);
m[2] = Math.max(z, m[2]);
m[3] = Math.max(maxmass, m[3]);
}
}
s.push(m); //the last item contain the maximums of size values
} else if (w.$EscortDeckXL) { //XL deck on non-carrier
xl += "xl";
p = w.$EscortDeckXLPos;
v = w.$EscortDeckXLVec;
x = w.$EscortDeckPad.xl[0];
y = w.$EscortDeckPad.xl[1];
z = w.$EscortDeckPad.xl[2];
maxmass = w.$EscortDeckPad.xl[3]; //60t
for (var i = 0; i <= p.length; i++) { // <= due to all equal
s[i] = [x, y, z, maxmass]; //so the maximums are the same
}
} else { //normal deck on non-carrier
if (owner.mass >= w.$EscortDeckWMass) {
xl += "w";
p = w.$EscortDeckWPos;
v = w.$EscortDeckWVec;
}
if (owner.mass >= w.$EscortDeckWMass) { //wide pad
x = w.$EscortDeckPad.wide[0];
y = w.$EscortDeckPad.wide[1];
z = w.$EscortDeckPad.wide[2];
maxmass = w.$EscortDeckPad.wide[3];
} else { //normal escort pad (non-wide)
x = w.$EscortDeckPad.escort[0];
y = w.$EscortDeckPad.escort[1];
z = w.$EscortDeckPad.escort[2];
maxmass = w.$EscortDeckPad.escort[3];
}
maxmass = Math.min(owner.mass * 0.4, maxmass); //max. 40% of the owner's mass
// maxmass = Math.min(owner.mass * 0.5, maxmass); //max. 50% of the owner's mass
maxmass = Math.min(w.$EscortDeckLargeMass, maxmass); //max. 130t
for ( var i = 0; i <= p.length; i++) {
if (w.$EscortDeck_isMiniPad(i, owner, w))
s[i] = [w.$EscortDeckPad.mini[0],
w.$EscortDeckPad.mini[1],
w.$EscortDeckPad.mini[2],
w.$EscortDeckPad.mini[3]];
else s[i] = [x, y, z, maxmass];
}
}
}
var len = p.length;
if (owner && owner.isValid && !w.$EscortDeck_isLarge(owner, w))
len = 4; //without adder pads
w.$EscortDeckPadPos = []; //landing pad positions
w.$EscortDeckPadSize = []; //landing pad sizes
w.$EscortDeckPadVec = []; //vectors from landing pad to ship center
for (var i = 0; i < len; i++) { //fill up from the proper array
w.$EscortDeckPadPos[i] = p[i];
w.$EscortDeckPadSize[i] = s[i];
w.$EscortDeckPadVec[i] = v[i];
}
w.$EscortDeckPadSize[len] = s[s.length-1]; //the last item contain the maximums of size values
log(w.name, "Pads Size:"+JSON.stringify(w.$EscortDeckPadSize)+", wide:"+JSON.stringify(w.$EscortDeckPad.wide));
return(xl);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_Show = function _escortdeck_Show(owner) { //create the deck and escorts
var that = _escortdeck_Show;
var w = (that.w = that.w || worldScripts.escortdeck);
var xl = "notcarrier"; //carriers set xl to null
if ((owner.equipmentStatus("EQ_ESCORTDECK") === "EQUIPMENT_OK"
|| owner.equipmentStatus("EQ_ESCORTDECKXL") === "EQUIPMENT_OK")
&& owner.mass >= w.$EscortDeckMinMass) {
xl = w.$EscortDeck_SetPads(owner, w); //return null for Carriers
if (!w.$EscortDeckV && xl) {
var r = system.addVisualEffect(xl, [0,0,0]);
if (r) w.$EscortDeckV = r; //position and orientation will be set in FCB
}
//make the z offset of deck position from the center of the owner ship
var zv = owner.weaponPositionAft;//to be able to fire backward if the deck is solid
if (!zv.z) zv = zv[0]; //fix for the change of weaponPositions in Oolite 1.83.
zv.x = 0;
var hl = owner.boundingBox.z * 0.5 + 30;
if (zv.z < hl) zv.z = -hl; //correct z position for carriers
//if there is an aft Sniper Gun on the ship then move the deck nearer
var sg = w.$EscortDeckSGWS;
if (sg) {
var sub = sg._checkAftSubEnt(owner, "snipergun", sg);
if (sub >= 0) {
var e = owner.exhausts;
if (e && e[0] && e[0].position) {
if (w.$debug) log(w.name, "zvz:"+zv.z+" ez:"+(e[0].position.z-3));
zv.z = e[0].position.z - 3; //3m after engine
} else { //no engine on this ship, like Nyoka
var subh = sg._checkAftSubEnt(owner, "snipergun-heavy", sg);
if (subh >= 0) { //Heavy Sniper Gun, move about 50m
var g = owner.subEntities[subh];
var subz = g.position.z - g.boundingBox.z;
if (subz < zv.z) zv.z += g.boundingBox.z - 10;
} else { //normal Sniper Gun, move about 20m
var g = owner.subEntities[sub];
var subz = g.position.z - g.boundingBox.z;
if (subz < zv.z) zv.z += g.boundingBox.z - 10;
}
if (w.$debug) log(w.name, "subz:"+subz+" zvz:"+zv.z);
}
}
}
if (zv.y > 0) zv.y = 0; //do not raise over the center line
if (owner == player.ship) w.$EscortDeckZV = zv;
else { //NPC deck
if (!owner.script) owner.script = "oolite-default-ship-script.js"; //for sure
owner.script.$EscortDeckZV = zv;
}
//spawn ships based on $EscortDeckShipData
var b = system.shipsWithPrimaryRole("buoy-witchpoint"); //avoid instant collision after hyperjump
for (var i = 0; i < w.$EscortDeckPadPos.length; i++) { //fill up ShipPos array
var s = w.$EscortDeck_SpawnShip(i, w, owner);
if (s && s.isValid) {
if (b && b[0] && b[0].addCollisionException) //from v1.81
b[0].addCollisionException(s);
var r = w.$EscortDeck_PutShip(true, s, i, owner);
if (w.$debug) log(w.name, (i+1)+". spawn "+s+" r:"+r); //debug
}
}
}
w.$EscortDeck_MFD(w); //update MFD
if ((w.$EscortDeckV || !xl) && !isValidFrameCallback(w.$EscortDeckFCB))
w.$EscortDeckFCB = addFrameCallback(w.$EscortDeck_FCB);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SpawnOne = function _escortdeck_SpawnOne(role, w, isShip) {
var s = system.addShips(role, 1, [10000000,0,0], 5000);
// set script as soon as possible, hopefully before any OXP's shipSpawned event handler set any property in th ship's script
if (isShip && s && s[0]) s[0].setScript("escortdeck_escort.js");
return( s );
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_SpawnShip = function _escortdeck_SpawnShip(pad, w, owner) {
var s = null;
var d = w.$EscortDeckShipData[pad];
if (d && d[1]) {
if (w.$EscortDeckCWS && d[14] && d[14].usable > 0
&& w.$EscortDeckPlayableDataKeys.indexOf(d[1]) === -1) {
var n = d[1]+"-player"; //try the player variant for Carriers
if (w.$EscortDeckPlayableDataKeys.indexOf(n) > -1) d[1] = n;
else {
var e = d[1].indexOf("-trader"); //try without suffix
if (e == d[1].length-(e.length)) {
n = d[1].substr(0, e);
if (w.$EscortDeckPlayableDataKeys.indexOf(n) > -1)
d[1] = n;
else {
n += "-player"; //try replace -trader to -player
if (w.$EscortDeckPlayableDataKeys.indexOf(n) > -1)
d[1] = n;
}
} else {
var e = d[1].indexOf("-pirate"); //try without suffix
if (e == d[1].length-(e.length)) {
n = d[1].substr(0, e);
if (w.$EscortDeckPlayableDataKeys.indexOf(n) > -1)
d[1] = n;
else {
n += "-player"; //try replace to -player
if(w.$EscortDeckPlayableDataKeys.indexOf(n) > -1) d[1] = n;
}
}
}
}
}
s = w.$EscortDeck_SpawnOne("["+d[1]+"]", w, true);
if (s && s[0]) {
if (s.script) s.script.$ShipVersionIgnore = true;
if (w.$debug) log(w.name, "Spawn escort pad:"+pad+" d:"+d+" s:"+s);
s = w.$EscortDeck_RestoreShipData(s[0], d, w, owner);
//setup restore in FCB also, need after ShipVersion changes in shipSpawned
w.$EscortDeckSpawnedShips.push(s);
}
}
return(s);
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_TooLarge = function _escortdeck_TooLarge(ship, owner, w) { //size or mass is too large to this deck?
return(w.$EscortDeck_TooLarge2(ship, owner, w, -1));
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_TooLarge2 = function _escortdeck_TooLarge2(ship, owner, w, pad) { //use saved data if no ship
if( !ship || !ship.isValid ) {
if( pad < 0 ) return("invalid escort ship");
var d = w.$EscortDeckShipData;
if( !d ) return("missing escort ship data");
d = d[pad];
return(w.$EscortDeck_TooLarge2b(owner, w, pad, d ));
} else { //ship is present
var shipmass = ship.mass;
if( ship.scriptInfo && ship.scriptInfo.hardarmour > 1 )
shipmass = shipmass / 2; //remove extra density from HardShips and Granite ships
var b = ship.boundingBox;
return(w.$EscortDeck_TooLarge3(owner, w, shipmass, b.x, b.y, b.z, pad ));
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_TooLarge2b = function _escortdeck_TooLarge2b(owner, w, pad, d) { //use saved data if no ship
if( !d || !d[14] || !d[14].mass ) return("invalid escort ship data");
var shipmass = d[14].mass;
if( d[1].indexOf("hard") == 0 ) //if this is a HardShip or Granite ship
shipmass = shipmass / 2; //remove the extra density
return(w.$EscortDeck_TooLarge3(owner, w, shipmass, d[14].x, d[14].y, d[14].z, pad ));
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_TooLarge3 = function _escortdeck_TooLarge3(owner, w, shipmass, bx, by, bz, pad) { //check given data
if (!owner || !owner.isValid) return("invalid owner ship");
if (!(shipmass > 0)) return("missing escort ship mass");
if (!bx || !(bx>0) || !by || !(by>0) || !bz || !(bz>0))
return("invalid escort ship size");
var e, l, x = 0, y = 0, z = 0, maxmass = 0;
var s = w.$EscortDeckPadSize;
if (s && s[0]) {
l = s.length-1;
if (pad < 0 || pad > l) e = s[l]; //the last line contain the maximums
else e = s[pad];
if (e && e[0]) {
x = e[0];
y = e[1];
z = e[2];
maxmass = e[3];
}
}
var r = null;
if (shipmass > maxmass) r = "too heavy ("+Math.ceil(shipmass/1000)+"t > "+Math.floor(maxmass/1000)+"t)";
else if (bx > x) r = "too wide ("+Math.ceil(bx)+"m > "+x+"m)";
else if (by > y) r = "too tall ("+Math.ceil(by)+"m > "+y+"m)";
else if (bz > z) r = "too long ("+Math.ceil(bz)+"m > "+z+"m)";
if (w.$debug) {
var p = pad+1;
if (p == 0) p = "any";
if (r) var l = r;
else var l = "["+Math.ceil(bx*100)/100+","+Math.ceil(by*100)/100+","+
Math.ceil(bz*100)/100+","+Math.ceil(shipmass)+"] fit into ["+Math.floor(x*100)/100+","+
Math.floor(y*100)/100+","+Math.floor(z*100)/100+","+Math.floor(maxmass)+"]";
// log(w.name, "Pad "+p+": "+l); //debug
}
return(r); //if null then not too large
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_VClear = function _escortdeck_VClear(w) { //remove the models of deck and escorts
var p = player.ship;
if( isValidFrameCallback( w.$EscortDeckFCB ) )
removeFrameCallback( w.$EscortDeckFCB );
if( w.$EscortDeckV ) w.$EscortDeckV.remove();
w.$EscortDeckV = null;
w.$EscortDeckSelectedPad = -1;
if( w.$EscortDeckShip ) {
for(var i = 0; i < w.$EscortDeckPadPos.length; i++ ) {
var s = w.$EscortDeckShip[i];
if( s && s.isValid ) {
var lost = false;
if( !w.$EscortDeckShipPos[i] ) { //not in deck
var rnd = ( 5 * Math.random() + 1 ) * p.scannerRange;
var d = s.position.distanceTo(p.position) - p.scannerRange;
if( d > rnd ) lost = true; //leaved farther than its luck
}
if( lost ) player.consoleMessage(s.name+" is left behind from pad "+i, 10);
else {
w.$EscortDeckShipData[i] = w.$EscortDeck_MakeShipData(s);
s.remove(true);
}
if(w.$debug) log(w.name, (i+1)+". "+w.$EscortDeckShipData[i]); //debug
}
w.$EscortDeckShip[i] = null;
w.$EscortDeckShipPos[i] = null;
}
} else {
w.$EscortDeckShip = [];
w.$EscortDeckShipPos = [];
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_TugDrone_Processing = function _escortdeck_TugDrone_Processing(ship) {
var that = _escortdeck_TugDrone_Processing;
var t = (that.t = that.t || worldScripts.towbar);
var wse = (that.wse = that.wse || worldScripts.escortdeck);
log(wse.name, "_escortdeck_TugDrone_Processing_escortdeck: Tug Drone towed ship "+ship.displayName);
if (ship && ship.isValid && ship.script && ship.script.$EscortDeckUsable > 0) {
log(wse.name, "Tug Drone towed ship "+ship.displayName+" is usable, storing in Hyperspace Hangar");
wse.$EscortDeck_HHStoreShip(ship);
player.consoleMessage("Usable ship "+ship.displayName+" stored into Hyperspace Hangar", 10);
player.commsMessage("Usable ship "+ship.displayName+" stored into Hyperspace Hangar", 10);
ship.remove(true);
} else {
log(wse.name, "Tug Drone towed ship "+ship.displayName+" not usable");
t.$Towbar_TugDrone_ProcessingOrig(ship);
}
}
//-----------------------------------------------------------------------------------------------//
this.$printDeckLoad = function _escortdeck_printDeckLoad() {
var w = worldScripts.escortdeck;
var _sArray = w.$EscortDeckShip;
var _sDataArray = w.$EscortDeckShipData;
var i;
i = w.$EscortDeckPadPos.length;
log(w.name, "Decks has "+i+" pads");
while (i--) {
if (_sArray[i])
log(w.name, "Pad "+i+": "+_sArray[i].shipUniqueName+" ("+_sArray[i].dataKey+")");
else
log(w.name, "Pad "+i+": "+_sDataArray[i]);
}
}
//-----------------------------------------------------------------------------------------------//
this.$EscortDeck_RefuelEscort = function _escortdeck_RefuelEscort(d) {
if (!d) return;
if (d[9] >= 7) return;
var f = 7 - d[9];
var v = f * 3; // 3 CR/LY (gotta charge extra for the service :-)
if (player.credits < v) {
log(this.name, "Insufficient funds to refuel escort "+d[0][3]);
player.consoleMessage("Insufficient funds to refuel escort "+d[0][3]);
} else {
player.credits -= v;
d[9] = 7;
log(this.name, "Refuelled escort "+d[0][3]+": "+ f.toFixed(1) +"LY for "+ formatCredits(v, true, true));
player.consoleMessage("Refuelled escort "+d[0][3]+": "+ f.toFixed(1) +"LY for "+ formatCredits(v, true, true));
}
}
|
Expansion Escort Deck