2806 lines
78 KiB
JavaScript
2806 lines
78 KiB
JavaScript
/*
|
|
|
|
oolite-ailib.js
|
|
|
|
Priority-based Javascript AI library
|
|
|
|
|
|
Oolite
|
|
Copyright © 2004-2013 Giles C Williams and contributors
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
/* AI Library */
|
|
this.name = "oolite-libPriorityAI";
|
|
this.version = "1.79";
|
|
this.copyright = "© 2008-2013 the Oolite team.";
|
|
this.author = "cim";
|
|
|
|
|
|
/* Constructor */
|
|
|
|
this.AILib = function(ship)
|
|
{
|
|
this.ship = ship;
|
|
this.ship.AIScript.oolite_intership = {};
|
|
this.ship.AIScript.oolite_priorityai = this;
|
|
var activeHandlers = [];
|
|
var priorityList = null;
|
|
var parameters = {};
|
|
var communications = {};
|
|
var waypointgenerator = null;
|
|
|
|
/* Private utility functions. Do not call these from external code */
|
|
|
|
/* Considers a priority list, potentially recursively */
|
|
this._reconsiderList = function(priorities) {
|
|
var l = priorities.length;
|
|
for (var i = 0; i < l; i++)
|
|
{
|
|
var priority = priorities[i];
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
if (priority.label)
|
|
{ log(this.ship.name,"Considering: "+priority.label);
|
|
}
|
|
else
|
|
{
|
|
log(this.ship.name,"Considering: entry "+i);
|
|
}
|
|
}
|
|
// always call the preconfiguration function at this point
|
|
// to set up condition parameters
|
|
if (priority.preconfiguration)
|
|
{
|
|
priority.preconfiguration.call(this);
|
|
}
|
|
// allow inverted conditions
|
|
var condmet = true;
|
|
if (priority.notcondition)
|
|
{
|
|
condmet = !priority.notcondition.call(this);
|
|
}
|
|
else if (priority.condition)
|
|
{
|
|
condmet = priority.condition.call(this);
|
|
}
|
|
// absent condition is always true
|
|
if (condmet)
|
|
{
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
log(this.ship.name,"Conditions met");
|
|
}
|
|
|
|
// always call the configuration function at this point
|
|
if (priority.configuration)
|
|
{
|
|
priority.configuration.call(this);
|
|
}
|
|
// this is what we're doing
|
|
if (priority.behaviour)
|
|
{
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
log(this.ship.name,"Executing behaviour");
|
|
}
|
|
|
|
if (priority.reconsider)
|
|
{
|
|
this._resetReconsideration.call(this,priority.reconsider);
|
|
}
|
|
return priority.behaviour;
|
|
}
|
|
// otherwise this is what we might be doing
|
|
if (priority.truebranch)
|
|
{
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
log(this.ship.name,"Entering truebranch");
|
|
}
|
|
|
|
var branch = this._reconsiderList.call(this,priority.truebranch);
|
|
if (branch != null)
|
|
{
|
|
return branch;
|
|
}
|
|
// otherwise nothing in the branch was usable, so move on
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (priority.falsebranch)
|
|
{
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
log(this.ship.name,"Entering falsebranch");
|
|
}
|
|
|
|
var branch = this._reconsiderList.call(this,priority.falsebranch);
|
|
if (branch != null)
|
|
{
|
|
return branch;
|
|
}
|
|
// otherwise nothing in the branch was usable, so move on
|
|
}
|
|
}
|
|
}
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
log(this.ship.name,"Exiting branch");
|
|
}
|
|
|
|
return null; // nothing in the list is usable, so return
|
|
};
|
|
|
|
/* Only call this from aiAwoken to avoid loops */
|
|
this._reconsider = function() {
|
|
if (!this.ship || !this.ship.isValid || !this.ship.isInSpace)
|
|
{
|
|
return;
|
|
}
|
|
var newBehaviour = this._reconsiderList.call(this,priorityList);
|
|
if (newBehaviour == null) {
|
|
log(this.name,"AI '"+this.ship.AIScript.name+"' for ship "+this.ship+" had all priorities fail. All priority based AIs should end with an unconditional entry.");
|
|
return false;
|
|
}
|
|
|
|
if (this.getParameter("oolite_flag_behaviourLogging"))
|
|
{
|
|
log(this.ship.name,newBehaviour);
|
|
}
|
|
newBehaviour.call(this);
|
|
return true;
|
|
};
|
|
|
|
|
|
/* Resets the reconsideration timer. */
|
|
this._resetReconsideration = function(delay)
|
|
{
|
|
this.ship.AIScriptWakeTime = clock.adjustedSeconds + delay;
|
|
};
|
|
|
|
|
|
/* ****************** General AI functions ************** */
|
|
|
|
|
|
this.setPriorities = function(prioritylist)
|
|
{
|
|
priorityList = prioritylist;
|
|
this.setUpHandlers({});
|
|
this.reconsiderNow();
|
|
}
|
|
|
|
|
|
// parameters created by Oolite must always be prefixed oolite-
|
|
this.setCommunication = function(key, value)
|
|
{
|
|
communications[key] = value;
|
|
}
|
|
|
|
|
|
// parameters created by Oolite must always be prefixed oolite-
|
|
this.setParameter = function(key, value)
|
|
{
|
|
parameters[key] = value;
|
|
}
|
|
|
|
this.getParameter = function(key)
|
|
{
|
|
if (key in parameters)
|
|
{
|
|
return parameters[key];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// set the waypoint generator function
|
|
this.setWaypointGenerator = function(value)
|
|
{
|
|
waypointgenerator = value;
|
|
}
|
|
|
|
this.getWaypointGenerator = function()
|
|
{
|
|
return waypointgenerator;
|
|
}
|
|
|
|
|
|
/* Requests reconsideration of behaviour ahead of schedule. */
|
|
this.reconsiderNow = function()
|
|
{
|
|
this._resetReconsideration.call(this,0.25);
|
|
}
|
|
|
|
|
|
this.setUpHandlers = function(handlers)
|
|
{
|
|
// step 1: go through activeHandlers, and delete those
|
|
// functions from this.ship.AIScript
|
|
for (var i=0; i < activeHandlers.length ; i++)
|
|
{
|
|
delete this.ship.AIScript[activeHandlers[i]];
|
|
}
|
|
|
|
/* This handler must always exist for a priority AI */
|
|
handlers.aiAwoken = function()
|
|
{
|
|
this._reconsider();
|
|
}
|
|
|
|
// step 2: go through the keys in handlers and put those handlers
|
|
// into this.ship.AIScript and the keys into activeHandlers
|
|
activeHandlers = Object.keys(handlers);
|
|
for (var i=0; i < activeHandlers.length ; i++)
|
|
{
|
|
this.ship.AIScript[activeHandlers[i]] = handlers[[activeHandlers[i]]].bind(this);
|
|
}
|
|
|
|
}
|
|
|
|
this.checkScannerWithPredicate = function(predicate)
|
|
{
|
|
var scan = this.getParameter("oolite_scanResults");
|
|
if (scan == null || predicate == null)
|
|
{
|
|
return false;
|
|
}
|
|
for (var i = 0 ; i < scan.length ; i++)
|
|
{
|
|
if (predicate.call(this,scan[i]))
|
|
{
|
|
this.setParameter("oolite_scanResultSpecific",scan[i]);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
this.communicate = function(key,parameter1,parameter2)
|
|
{
|
|
if (key in communications)
|
|
{
|
|
this.ship.commsMessage(expandDescription(communications[key],{"p1":parameter1,"p2":parameter2}));
|
|
}
|
|
}
|
|
|
|
this.friendlyStation = function(station)
|
|
{
|
|
if (station.isMainStation && this.ship.bounty > 50)
|
|
{
|
|
return false;
|
|
}
|
|
return (station.target != this.ship || !station.hasHostileTarget);
|
|
}
|
|
|
|
this.cruiseSpeed = function()
|
|
{
|
|
var cruise = this.ship.maxSpeed * 0.8;
|
|
if (this.ship.group)
|
|
{
|
|
for (var i = 0 ; i < this.ship.group.ships.length ; i++)
|
|
{
|
|
if (this.ship.group.ships[i].maxSpeed >= this.ship.maxSpeed/4)
|
|
{
|
|
if (cruise > this.ship.group.ships[i].maxSpeed)
|
|
{
|
|
cruise = this.ship.group.ships[i].maxSpeed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.ship.escortGroup)
|
|
{
|
|
for (var i = 0 ; i < this.ship.escortGroup.ships.length ; i++)
|
|
{
|
|
if (this.ship.escortGroup.ships[i].maxSpeed >= this.ship.maxSpeed/4)
|
|
{
|
|
if (cruise > this.ship.escortGroup.ships[i].maxSpeed)
|
|
{
|
|
cruise = this.ship.escortGroup.ships[i].maxSpeed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return cruise;
|
|
}
|
|
|
|
this.allied = function(ship1,ship2)
|
|
{
|
|
// ships in same group
|
|
if (ship1.group && ship1.group.containsShip(ship2))
|
|
{
|
|
return true;
|
|
}
|
|
if (ship1.group && ship1.group.leader)
|
|
{
|
|
// ship1 is escort of ship in same group as ship2
|
|
if (ship1.group.leader.group && ship1.group.leader.group.containsShip(ship2))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
// or in reverse, ship2 is the escort
|
|
if (ship2.group && ship2.group.leader)
|
|
{
|
|
// ship2 is escort of ship in same group as ship1
|
|
if (ship2.group.leader.group && ship2.group.leader.group.containsShip(ship1))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
// ship1 is escort of a ship, ship2 is escort of a ship, both
|
|
// those ships are in the same group
|
|
if (ship1.group && ship1.group.leader && ship2.group && ship2.group.leader && ship1.group.leader.group && ship1.group.leader.group.containsShip(ship2.group.leader))
|
|
{
|
|
return true;
|
|
}
|
|
// Okay, these ships really do have nothing to do with each other...
|
|
return false;
|
|
}
|
|
|
|
this.isAggressive = function(ship)
|
|
{
|
|
return ship && ship.hasHostileTarget && !ship.isFleeing && !ship.isDerelict;
|
|
}
|
|
|
|
this.isFighting = function(ship)
|
|
{
|
|
return ship && (ship.hasHostileTarget || (ship.isStation && ship.alertCondition > 1));
|
|
}
|
|
|
|
|
|
/* ****************** Condition functions ************** */
|
|
|
|
/* Conditions. Any function which returns true or false can be used as
|
|
* a condition. They do not have to be part of the AI library, but
|
|
* several common conditions are provided here. */
|
|
|
|
this.conditionLosingCombat = function()
|
|
{
|
|
var cascade = this.getParameter("oolite_cascadeDetected");
|
|
if (cascade != null)
|
|
{
|
|
if (cascade.distanceTo(this.ship) < 25600)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
this.setParameter("oolite_cascadeDetected",null);
|
|
}
|
|
}
|
|
if (this.ship.energy == this.ship.maxEnergy)
|
|
{
|
|
// forget previous defeats
|
|
this.setParameter("oolite_lastFleeing",null);
|
|
}
|
|
if (!this.conditionInCombat())
|
|
{
|
|
return false;
|
|
}
|
|
var lastThreat = this.getParameter("oolite_lastFleeing");
|
|
if (lastThreat != null && this.ship.position.distanceTo(lastThreat) < 25600)
|
|
{
|
|
// the thing that attacked us is still nearby
|
|
return true;
|
|
}
|
|
if (this.ship.energy * 4 < this.ship.maxEnergy)
|
|
{
|
|
// TODO: adjust threshold based on group odds
|
|
return true; // losing if less than 1/4 energy
|
|
}
|
|
var dts = this.ship.defenseTargets;
|
|
for (var i = 0 ; i < dts.length ; i++)
|
|
{
|
|
if (dts[i].scanClass == "CLASS_MISSILE" && dts[i].target == this.ship)
|
|
{
|
|
return true;
|
|
}
|
|
if (dts[i].scanClass == "CLASS_MINE")
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
// if we've dumped cargo or the group leader has, then we're losing
|
|
if (this.ship.AIScript.oolite_intership.cargodemandpaid)
|
|
{
|
|
return true;
|
|
}
|
|
if (this.ship.group && this.ship.group.leader && this.ship.group.leader.AIScript.oolite_intership && this.ship.group.leader.AIScript.oolite_intership.cargodemandpaid)
|
|
{
|
|
return true;
|
|
}
|
|
// TODO: add some reassessment of odds based on group size
|
|
return false; // not losing yet
|
|
}
|
|
|
|
this.conditionInCombat = function()
|
|
{
|
|
if (this.isFighting(this.ship))
|
|
{
|
|
return true;
|
|
}
|
|
var dts = this.ship.defenseTargets;
|
|
for (var i=0; i < dts.length; i++)
|
|
{
|
|
if (dts[i].position.squaredDistanceTo(this.ship) < this.ship.scannerRange * this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if (this.ship.group != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.group.length ; i++)
|
|
{
|
|
if (this.isFighting(this.ship.group.ships[i]))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (this.ship.escortGroup != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.escortGroup.length ; i++)
|
|
{
|
|
if (this.isFighting(this.ship.escortGroup.ships[i]))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete this.ship.AIScript.oolite_intership.cargodemandpaid;
|
|
return false;
|
|
}
|
|
|
|
/* Ships being attacked are firing back */
|
|
this.conditionInCombatWithHostiles = function()
|
|
{
|
|
if (this.isFighting(ship) && this.isAggressive(this.ship.target))
|
|
{
|
|
return true;
|
|
}
|
|
var dts = this.ship.defenseTargets;
|
|
for (var i=0; i < dts.length; i++)
|
|
{
|
|
if (this.isAggressive(dts[i]) && dts[i].position.squaredDistanceTo(this.ship) < this.ship.scannerRange * this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if (this.ship.group != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.group.length ; i++)
|
|
{
|
|
if (this.isFighting(this.ship.group.ships[i]) && this.isAggressive(this.ship.group.ships[i].target))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (this.ship.escortGroup != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.escortGroup.length ; i++)
|
|
{
|
|
if (this.isFighting(this.ship.escortGroup.ships[i]) && this.isAggressive(this.ship.escortGroup.ships[i].target))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete this.ship.AIScript.oolite_intership.cargodemandpaid;
|
|
return false;
|
|
}
|
|
|
|
|
|
this.conditionHasMothership = function()
|
|
{
|
|
return (this.ship.group && this.ship.group.leader && this.ship.group.leader != this.ship && this.ship.group.leader.escortGroup && this.ship.group.leader.escortGroup.containsShip(this.ship));
|
|
}
|
|
|
|
this.conditionMothershipInCombat = function()
|
|
{
|
|
if (this.ship.group && this.ship.group.leader && this.ship.group.leader != this.ship && this.ship.group.leader.escortGroup.containsShip(this.ship))
|
|
{
|
|
var leader = this.ship.group.leader;
|
|
if (leader.position.distanceTo(this.ship) > this.ship.scannerRange)
|
|
{
|
|
return false; // can't tell
|
|
}
|
|
if (this.isFighting(leader))
|
|
{
|
|
return true;
|
|
}
|
|
if (leader.target && leader.target.target == leader && leader.target.hasHostileTarget)
|
|
{
|
|
return true;
|
|
}
|
|
var dts = leader.defenseTargets;
|
|
for (var i = 0 ; i < dts.length ; i++)
|
|
{
|
|
if (dts[i].target == leader && dts[i].hasHostileTarget)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// no mothership
|
|
return false;
|
|
}
|
|
}
|
|
|
|
this.conditionMothershipUnderAttack = function()
|
|
{
|
|
if (this.ship.group && this.ship.group.leader != this.ship && this.ship.group.leader.escortGroup.containsShip(this.ship))
|
|
{
|
|
var leader = this.ship.group.leader;
|
|
if (leader.target && leader.target.target == leader && leader.target.hasHostileTarget && leader.target.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
var dts = leader.defenseTargets;
|
|
for (var i = 0 ; i < dts.length ; i++)
|
|
{
|
|
if (dts[i].target == leader && dts[i].hasHostileTarget && dts[i].position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
this.conditionMothershipIsAttacking = function()
|
|
{
|
|
if (this.ship.group && this.ship.group.leader != this.ship && this.ship.group.leader.escortGroup.containsShip(this.ship))
|
|
{
|
|
var leader = this.ship.group.leader;
|
|
if (leader.target && this.isFighting(leader) && leader.target.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionNearDestination = function()
|
|
{
|
|
return (this.ship.destination.squaredDistanceTo(this.ship) < this.ship.desiredRange * this.ship.desiredRange);
|
|
}
|
|
|
|
|
|
this.conditionScannerContainsFugitive = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.isInSpace && s.bounty > 50;
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsHunters = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.primaryRole == "hunter" || s.scanClass == "CLASS_POLICE" || (s.isStation && s.isMainStation);
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsPirateVictims = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
// is a pirate victim
|
|
// has some cargo on board
|
|
// hasn't already paid up
|
|
return s.isPirateVictim && s.cargoSpaceUsed > 0 && (!s.AIScript || !s.AIScript.oolite_intership || !s.AIScript.oolite_intership.cargodemandpaid);
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsHuntableOffender = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
var threshold = 50 - (system.info.government * 7);
|
|
return s.isInSpace && s.bounty > threshold;
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsFineableOffender = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
var threshold = 50 - (system.info.government * 7);
|
|
return s.isInSpace && s.bounty <= threshold && s.bounty > 0 && !s.markedForFines && (s.scanClass == "CLASS_NEUTRAL" || s.isPlayer) && !s.isDerelict;
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsNonThargoid = function()
|
|
{
|
|
var prioritytargets = this.checkScannerWithPredicate(function(s) {
|
|
return s.scanClass != "CLASS_THARGOID" && s.scanClass != "CLASS_ROCK" && s.scanClass != "CLASS_CARGO";
|
|
});
|
|
if (prioritytargets)
|
|
{
|
|
return true;
|
|
}
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.scanClass != "CLASS_THARGOID";
|
|
});
|
|
}
|
|
|
|
|
|
this.conditionScannerContainsSalvageForMe = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.isInSpace && s.scanClass == "CLASS_CARGO" && s.velocity.magnitude() < this.ship.maxSpeed && this.conditionCanScoopCargo();
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsEscapePods = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.primaryRole == "escape-capsule" && s.isInSpace && s.scanClass == "CLASS_CARGO" && s.velocity.magnitude() < this.ship.maxSpeed && this.conditionCanScoopCargo();
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsSalvageForGroup = function()
|
|
{
|
|
var maxspeed = 0;
|
|
if (this.conditionCanScoopCargo())
|
|
{
|
|
maxspeed = this.ship.maxSpeed;
|
|
}
|
|
if (this.ship.group)
|
|
{
|
|
for (var i = 0; i < this.ship.group.ships.length ; i++)
|
|
{
|
|
var ship = this.ship.group.ships[i];
|
|
if (ship.cargoSpaceAvailable > 0 && ship.equipmentStatus("EQ_FUEL_SCOOPS") == "EQUIPMENT_OK" && ship.maxSpeed > maxspeed)
|
|
{
|
|
maxspeed = ship.maxSpeed;
|
|
}
|
|
}
|
|
}
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.isInSpace && s.scanClass == "CLASS_CARGO" && s.velocity.magnitude() < maxspeed;
|
|
});
|
|
}
|
|
|
|
this.conditionHasReceivedDistressCall = function()
|
|
{
|
|
var aggressor = this.getParameter("oolite_distressAggressor");
|
|
var sender = this.getParameter("oolite_distressSender");
|
|
if (aggressor == null || !aggressor.isInSpace || sender == null || !sender.isInSpace || sender.position.distanceTo(this.ship) > this.ship.scannerRange)
|
|
{
|
|
// no, or it has expired
|
|
this.setParameter("oolite_distressAggressor",null);
|
|
this.setParameter("oolite_distressSender",null);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
this.conditionHasWaypoint = function()
|
|
{
|
|
return this.getParameter("oolite_waypoint") != null;
|
|
}
|
|
|
|
this.conditionHasSelectedStation = function()
|
|
{
|
|
var station = this.getParameter("oolite_selectedStation");
|
|
if (station && (!station.isValid || !station.isStation))
|
|
{
|
|
this.setParameter("oolite_selectedStation",null);
|
|
return false;
|
|
}
|
|
return station != null;
|
|
}
|
|
|
|
this.conditionHasSelectedPlanet = function()
|
|
{
|
|
var planet = this.getParameter("oolite_selectedPlanet");
|
|
if (planet && (!planet.isValid || !planet.isPlanet))
|
|
{
|
|
this.setParameter("oolite_selectedPlanet",null);
|
|
return false;
|
|
}
|
|
return planet != null;
|
|
}
|
|
|
|
|
|
this.conditionInInterstellarSpace = function()
|
|
{
|
|
return system.isInterstellarSpace;
|
|
}
|
|
|
|
this.conditionWitchspaceEntryRequested = function()
|
|
{
|
|
return (this.getParameter("oolite_witchspaceWormhole") != null);
|
|
}
|
|
|
|
this.conditionSelectedStationNearby = function()
|
|
{
|
|
var station = this.getParameter("oolite_selectedStation");
|
|
if (station && station.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionSelectedStationNearMainPlanet = function()
|
|
{
|
|
if (!system.mainPlanet)
|
|
{
|
|
return false;
|
|
}
|
|
var station = this.getParameter("oolite_selectedStation");
|
|
if (station && station.position.distanceTo(system.mainPlanet) < system.mainPlanet.radius * 4)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionNearMainPlanet = function()
|
|
{
|
|
if (!system.mainPlanet)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.ship.position.distanceTo(system.mainPlanet) < system.mainPlanet.radius * 4)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
this.conditionFriendlyStationNearby = function()
|
|
{
|
|
var stations = system.stations;
|
|
for (var i = 0 ; i < stations.length ; i++)
|
|
{
|
|
var station = stations[i];
|
|
if (this.friendlyStation(station))
|
|
{
|
|
// this is not a very good check for friendliness, but
|
|
// it will have to do for now
|
|
if (station.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionFriendlyStationExists = function()
|
|
{
|
|
var stations = system.stations;
|
|
for (var i = 0 ; i < stations.length ; i++)
|
|
{
|
|
var station = stations[i];
|
|
if (this.friendlyStation(station))
|
|
{
|
|
// this is not a very good check for friendliness, but
|
|
// it will have to do for now
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionHasNonThargoidTarget = function()
|
|
{
|
|
return (this.ship.target && this.ship.target.scanClass != "CLASS_THARGOID");
|
|
}
|
|
|
|
this.conditionScannerContainsThargoidMothership = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.hasRole("thargoid-mothership");
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsReadyThargoidMothership = function()
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.hasRole("thargoid-mothership") && (!s.escortGroup || s.escortGroup.count <= 16);
|
|
});
|
|
}
|
|
|
|
this.conditionScannerContainsShipNeedingEscort = function()
|
|
{
|
|
if (this.ship.bounty == 0)
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.scanClass == this.ship.scanClass && s.bounty == 0 && (!s.escortGroup || s.escortGroup.count <= s.maxEscorts);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
return this.checkScannerWithPredicate(function(s) {
|
|
return s.scanClass == this.ship.scanClass && s.bounty > 0 && (!s.escortGroup || s.escortGroup.count <= s.maxEscorts);
|
|
});
|
|
}
|
|
}
|
|
|
|
this.conditionCanWitchspaceOut = function()
|
|
{
|
|
if (!this.ship.hasHyperspaceMotor)
|
|
{
|
|
return false;
|
|
}
|
|
return (system.info.systemsInRange(this.ship.fuel).length > 0);
|
|
}
|
|
|
|
this.conditionCargoIsProfitableHere = function()
|
|
{
|
|
if (!system.mainStation)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.ship.cargoSpaceUsed == 0)
|
|
{
|
|
return false;
|
|
}
|
|
var cargo = this.ship.cargoList;
|
|
var profit = 0;
|
|
var multiplier = (system.info.economy <= 3)?-1:1;
|
|
for (var i = 0 ; i < cargo.length ; i++)
|
|
{
|
|
var commodity = cargo[i].commodity;
|
|
var quantity = cargo[i].quantity;
|
|
var adjust = system.mainStation.market[commodity].marketEcoAdjustPrice * multiplier * quantity / system.mainStation.market[commodity].marketMaskPrice;
|
|
profit += adjust;
|
|
}
|
|
return (profit >= 0);
|
|
}
|
|
|
|
this.conditionReadyToSunskim = function()
|
|
{
|
|
return (this.ship.position.distanceTo(system.sun) < system.sun.radius * 1.15);
|
|
}
|
|
|
|
this.conditionSunskimPossible = function()
|
|
{
|
|
return (system.sun &&
|
|
!system.sun.hasGoneNova &&
|
|
!system.sun.isGoingNova &&
|
|
this.ship.fuel < 7 &&
|
|
this.ship.equipmentStatus("EQ_FUEL_SCOOPS") == "EQUIPMENT_OK" &&
|
|
(this.ship.heatInsulation > 1000/this.ship.maxSpeed || this.ship.heatInsulation >= 12));
|
|
}
|
|
|
|
this.conditionPiratesCanBePaidOff = function()
|
|
{
|
|
if (this.ship.AIScript.oolite_intership.cargodemandpaid)
|
|
{
|
|
return false;
|
|
}
|
|
// TODO: need some way for the player to set this
|
|
if (!this.ship.AIScript.oolite_intership.cargodemand)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.ship.cargoSpaceUsed < this.ship.AIScript.oolite_intership.cargodemand)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
this.conditionIsGroupLeader = function()
|
|
{
|
|
if (!this.ship.group)
|
|
{
|
|
return true;
|
|
}
|
|
return (this.ship.group.leader == this.ship);
|
|
}
|
|
|
|
this.conditionIsEscorting = function()
|
|
{
|
|
if (!this.ship.group || !this.ship.group.leader || this.ship.group.leader == this.ship)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.ship.group.leader.escortGroup && this.ship.group.leader.escortGroup.containsShip(this.ship))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionAllEscortsInFlight = function()
|
|
{
|
|
if (!this.ship.escortGroup)
|
|
{
|
|
return true; // there are no escorts not in flight
|
|
}
|
|
for (var i = 0 ; i < this.ship.escortGroup.ships.length ; i++)
|
|
{
|
|
if (this.ship.escortGroup.ships[i].status != "STATUS_IN_FLIGHT")
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
this.conditionCanScoopCargo = function()
|
|
{
|
|
if (this.ship.cargoSpaceAvailable == 0 || this.ship.equipmentStatus("EQ_FUEL_SCOOPS") != "EQUIPMENT_OK")
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
this.conditionCargoDemandsMet = function()
|
|
{
|
|
if (!this.getParameter("oolite_flag_watchForCargo"))
|
|
{
|
|
log(this.name,"AI '"+this.ship.AIScript.name+"' for ship "+this.ship+" is asking if cargo demands are met but has not set 'oolite_flag_watchForCargo'");
|
|
return true;
|
|
}
|
|
var seen = this.getParameter("oolite_cargoDropped");
|
|
if (seen != null)
|
|
{
|
|
var recorder = null;
|
|
var demand = 0;
|
|
if (this.ship.group)
|
|
{
|
|
if (this.ship.group.leader && this.ship.group.leader.AIScript.oolite_intership && this.ship.group.leader.AIScript.oolite_intership.cargodemanded > 0)
|
|
{
|
|
if (this.ship.group.leader.AIScript.oolite_intership.cargodemandmet)
|
|
{
|
|
return true;
|
|
}
|
|
recorder = this.ship.group.leader;
|
|
demand = this.ship.group.leader.AIScript.oolite_intership.cargodemanded;
|
|
}
|
|
else if (this.ship.group.ships[0].AIScript.oolite_intership && this.ship.group.ships[0].AIScript.oolite_intership.cargodemanded > 0)
|
|
|
|
{
|
|
demand = this.ship.group.ships[0].AIScript.oolite_intership.cargodemanded;
|
|
if (this.ship.group.ships[0].AIScript.oolite_intership.cargodemandmet)
|
|
{
|
|
return true;
|
|
}
|
|
recorder = this.ship.group.ships[0];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.ship.AIScript.oolite_intership.cargodemanded > 0)
|
|
{
|
|
if (this.ship.AIScript.oolite_intership.cargodemandmet)
|
|
{
|
|
return true;
|
|
}
|
|
demand = this.ship.AIScript.oolite_intership.cargodemanded;
|
|
recorder = this.ship;
|
|
}
|
|
}
|
|
|
|
if (demand == 0)
|
|
{
|
|
return false; // no demand made, so it can't have been met
|
|
}
|
|
if (demand <= seen)
|
|
{
|
|
recorder.AIScript.oolite_intership.cargodemandmet = true;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionGroupLeaderIsStation = function()
|
|
{
|
|
return (this.ship.group && this.ship.group.leader && this.ship.group.leader.isStation);
|
|
}
|
|
|
|
this.conditionGroupIsSeparated = function()
|
|
{
|
|
if (!this.ship.group || !this.ship.group.leader)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.ship.group.leader.isStation)
|
|
{
|
|
// can get 2x as far from station
|
|
return (this.ship.position.distanceTo(this.ship.group.leader) > this.ship.scannerRange * 2);
|
|
}
|
|
else
|
|
{
|
|
return (this.ship.position.distanceTo(this.ship.group.leader) > this.ship.scannerRange);
|
|
}
|
|
}
|
|
|
|
this.conditionCombatOddsGood = function()
|
|
{
|
|
// TODO: this should consider what the ships are, somehow
|
|
var us = 1;
|
|
if (this.ship.group)
|
|
{
|
|
us += this.ship.group.count - 1;
|
|
}
|
|
if (this.ship.escortGroup)
|
|
{
|
|
us += this.ship.escortGroup.count - 1;
|
|
}
|
|
|
|
var them = 1;
|
|
if (!this.ship.target)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (this.ship.target.group)
|
|
{
|
|
them += this.ship.target.group.count - 1;
|
|
}
|
|
if (this.ship.target.escortGroup)
|
|
{
|
|
them += this.ship.target.escortGroup.count - 1;
|
|
}
|
|
}
|
|
return us >= them;
|
|
}
|
|
|
|
this.conditionGroupHasEnoughLoot = function()
|
|
{
|
|
var used = 0;
|
|
var available = 0;
|
|
if (!this.ship.group)
|
|
{
|
|
used = this.ship.cargoSpaceUsed;
|
|
if (this.ship.equipmentStatus("EQ_FUEL_SCOOPS") == "EQUIPMENT_OK")
|
|
{
|
|
available = this.ship.cargoSpaceAvailable;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (var i = 0; i < this.ship.group.ships.length; i++)
|
|
{
|
|
used += this.ship.group.ships[i].cargoSpaceUsed;
|
|
if (this.ship.equipmentStatus("EQ_FUEL_SCOOPS") == "EQUIPMENT_OK")
|
|
{
|
|
available += this.ship.group.ships[i].cargoSpaceAvailable;
|
|
}
|
|
}
|
|
}
|
|
if (available < used || available == 0)
|
|
{
|
|
/* Over half-full. This will do for now. TODO: cutting
|
|
* losses if group is taking damage, losing ships, running
|
|
* low on consumables, etc. */
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.conditionThargonIsActive = function()
|
|
{
|
|
return this.ship.scanClass == "CLASS_THARGOID" && this.ship.hasRole("EQ_THARGON");
|
|
}
|
|
|
|
/* ****************** Behaviour functions ************** */
|
|
|
|
/* Behaviours. Behaviours are effectively a state definition,
|
|
* defining a set of events and responses. They are aided in this
|
|
* by the 'responses', which mean that the event handlers for the
|
|
* behaviour within the definition can itself be templated. */
|
|
|
|
this.behaviourFleeCombat = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
|
|
var cascade = this.getParameter("oolite_cascadeDetected");
|
|
if (cascade != null)
|
|
{
|
|
if (cascade.distanceTo(this.ship) < 25600)
|
|
{
|
|
if (this.ship.destination != cascade)
|
|
{
|
|
this.communication("oolite_quiriumCascade");
|
|
}
|
|
this.ship.destination = cascade;
|
|
this.ship.desiredRange = 30000;
|
|
this.ship.desiredSpeed = 10*this.ship.maxSpeed;
|
|
this.ship.performFlyToRangeFromDestination();
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
this.setParameter("oolite_cascadeDetected",null);
|
|
}
|
|
}
|
|
this.ship.target = this.ship.AIPrimaryAggressor;
|
|
if (!this.ship.target || this.ship.position.distanceTo(this.ship.target) > 25600)
|
|
{
|
|
var dts = this.ship.defenseTargets;
|
|
for (var i = 0 ; i < dts.length ; i++)
|
|
{
|
|
this.ship.position.distanceTo(dts[i]) < 25600;
|
|
this.ship.target = dts[i];
|
|
break;
|
|
}
|
|
}
|
|
this.setParameter("oolite_lastFleeing",this.ship.target);
|
|
this.ship.performFlee();
|
|
}
|
|
|
|
|
|
this.behaviourDestroyCurrentTarget = function()
|
|
{
|
|
this.setParameter("oolite_witchspaceEntry",null);
|
|
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
if (this.ship.target && !this.ship.hasHostileTarget)
|
|
{
|
|
// entering attack mode
|
|
this.communicate("oolite_beginningAttack",this.ship.target.displayName);
|
|
}
|
|
this.ship.performAttack();
|
|
}
|
|
|
|
|
|
this.behaviourRepelCurrentTarget = function()
|
|
{
|
|
this.setParameter("oolite_witchspaceEntry",null);
|
|
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
if (!this.ship.target || !this.ship.target.isValid || !this.ship.target.isShip)
|
|
{
|
|
this.reconsiderNow();
|
|
return;
|
|
}
|
|
if (!this.isAggressive(this.ship.target))
|
|
{
|
|
var target = this.ship.target;
|
|
// repelling succeeded
|
|
if (this.ship.escortGroup)
|
|
{
|
|
// also tell escorts to stop attacking it
|
|
for (var i = 0 ; i < this.ship.escortGroup.ships.length ; i++)
|
|
{
|
|
this.ship.escortGroup.ships[i].removeDefenseTarget(target);
|
|
if (this.ship.escortGroup.ships[i].target == target)
|
|
{
|
|
this.ship.escortGroup.ships[i].target = null;
|
|
}
|
|
}
|
|
}
|
|
this.ship.removeDefenseTarget(target);
|
|
this.ship.target = null;
|
|
}
|
|
else
|
|
{
|
|
if (!this.ship.hasHostileTarget)
|
|
{
|
|
// entering attack mode
|
|
this.communicate("oolite_beginningAttack",this.ship.target.displayName);
|
|
}
|
|
this.ship.performAttack();
|
|
}
|
|
}
|
|
|
|
|
|
this.behaviourFineCurrentTarget = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
|
|
if (this.ship.scanClass == "CLASS_POLICE" && this.ship.target)
|
|
{
|
|
this.communicate("oolite_markForFines",this.ship.target.displayName);
|
|
|
|
this.ship.markTargetForFines();
|
|
}
|
|
|
|
this.ship.performIdle();
|
|
}
|
|
|
|
|
|
this.behaviourCollectSalvage = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
handlers.shipScoopedOther = function(other)
|
|
{
|
|
this.setParameter("oolite_cargoDropped",null);
|
|
this.reconsiderNow();
|
|
}
|
|
this.setUpHandlers(handlers);
|
|
this.ship.performCollect();
|
|
}
|
|
|
|
|
|
this.behaviourApproachDestination = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
|
|
handlers.shipAchievedDesiredRange = function()
|
|
{
|
|
var waypoints = this.getParameter("oolite_waypoints");
|
|
if (waypoints != null)
|
|
{
|
|
if (waypoints.length > 0)
|
|
{
|
|
waypoints.pop();
|
|
if (waypoints.length == 0)
|
|
{
|
|
waypoints = null;
|
|
}
|
|
this.setParameter("oolite_waypoints",waypoints);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var patrol = this.getParameter("oolite_waypoint");
|
|
if (patrol != null && this.ship.destination.distanceTo(patrol) < 1000+this.getParameter("oolite_waypointRange"))
|
|
{
|
|
// finished patrol to waypoint
|
|
// clear route
|
|
this.communicate("oolite_waypointReached");
|
|
this.setParameter("oolite_waypoint",null);
|
|
this.setParameter("oolite_waypointRange",null);
|
|
if (this.getParameter("oolite_flag_patrolStation"))
|
|
{
|
|
if (this.ship.group)
|
|
{
|
|
var station = this.ship.group.leader;
|
|
if (station != null && station.isStation)
|
|
{
|
|
this.communicate("oolite_patrolReportIn",station.displayName);
|
|
this.ship.patrolReportIn(station);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.reconsiderNow();
|
|
};
|
|
|
|
var waypoints = this.getParameter("oolite_waypoints");
|
|
if (waypoints != null)
|
|
{
|
|
this.ship.destination = waypoints[waypoints.length-1];
|
|
this.ship.desiredRange = 1000;
|
|
}
|
|
var blocker = this.ship.checkCourseToDestination();
|
|
if (blocker)
|
|
{
|
|
if (blocker.isPlanet || blocker.isSun)
|
|
{
|
|
// the selected planet can't block
|
|
if (blocker.isSun || this.getParameter("oolite_selectedPlanet") != blocker)
|
|
{
|
|
if (this.ship.position.distanceTo(blocker) < blocker.radius * 3)
|
|
{
|
|
if (waypoints == null)
|
|
{
|
|
waypoints = [];
|
|
}
|
|
waypoints.push(this.ship.getSafeCourseToDestination());
|
|
this.ship.destination = waypoints[waypoints.length-1];
|
|
this.ship.desiredRange = 1000;
|
|
}
|
|
}
|
|
}
|
|
else if (blocker.isShip)
|
|
{
|
|
if (this.ship.position.distanceTo(blocker) < 25600)
|
|
{
|
|
if (!blocker.group || !blocker.group.leader == this.ship)
|
|
{
|
|
// our own escorts are not a blocker!
|
|
if (waypoints == null)
|
|
{
|
|
waypoints = [];
|
|
}
|
|
waypoints.push(this.ship.getSafeCourseToDestination());
|
|
this.ship.destination = waypoints[waypoints.length-1];
|
|
this.ship.desiredRange = 1000;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.setParameter("oolite_waypoints",waypoints);
|
|
this.setUpHandlers(handlers);
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
|
|
|
|
this.behaviourDockWithStation = function()
|
|
{
|
|
// may need to release escorts
|
|
if (this.ship.escortGroup && this.ship.escortGroup.count > 1)
|
|
{
|
|
this.ship.dockEscorts();
|
|
}
|
|
var station = this.getParameter("oolite_dockingStation");
|
|
this.ship.target = station;
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.responsesAddDocking(handlers);
|
|
this.ship.requestDockingInstructions();
|
|
switch (this.ship.dockingInstructions.ai_message)
|
|
{
|
|
case "TOO_BIG_TO_DOCK":
|
|
case "DOCKING_REFUSED":
|
|
this.ship.setParameter("oolite_dockingStation",null);
|
|
this.ship.target = null;
|
|
this.reconsiderNow();
|
|
break;
|
|
case "TRY_AGAIN_LATER":
|
|
if (this.ship.target.position.distanceTo(this.ship) < 10000)
|
|
{
|
|
this.ship.destination = this.ship.target.position;
|
|
this.ship.desiredRange = 12500;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
// else fall through
|
|
case "HOLD_POSITION":
|
|
this.ship.destination = this.ship.target.position;
|
|
this.ship.performFaceDestination();
|
|
// and will reconsider in a little bit
|
|
break;
|
|
case "APPROACH":
|
|
case "APPROACH_COORDINATES":
|
|
case "BACK_OFF":
|
|
this.ship.performFlyToRangeFromDestination();
|
|
break;
|
|
}
|
|
this.setUpHandlers(handlers);
|
|
}
|
|
|
|
/* Standard "help the innocent" distress call response. Perhaps
|
|
* there should be a 'blood in the water' response available
|
|
* too... */
|
|
this.behaviourRespondToDistressCall = function()
|
|
{
|
|
var aggressor = this.getParameter("oolite_distressAggressor");
|
|
var sender = this.getParameter("oolite_distressSender");
|
|
if (sender.bounty > aggressor.bounty)
|
|
{
|
|
var tmp = sender;
|
|
sender = aggressor;
|
|
aggressor = tmp;
|
|
}
|
|
if (aggressor.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = aggressor;
|
|
this.ship.performAttack();
|
|
this.reconsiderNow();
|
|
this.communicate("oolite_distressResponseAggressor",aggressor.displayName);
|
|
}
|
|
else
|
|
{ // we can't actually see what's attacking the sender yet
|
|
this.ship.destination = sender.position;
|
|
this.ship.desiredRange = 1000+sender.collisionRadius+this.ship.collisionRadius;
|
|
this.ship.desiredSpeed = 7 * this.ship.maxSpeed; // use injectors if possible
|
|
this.ship.performFlyToRangeFromDestination();
|
|
// and when we next reconsider, hopefully the aggressor will be on the scanner
|
|
this.communicate("oolite_distressResponseSender",sender.displayName);
|
|
}
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
}
|
|
|
|
|
|
this.behaviourEnterWitchspace = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
var wormhole = this.getParameter("oolite_witchspaceWormhole");
|
|
if (wormhole && wormhole.expiryTime < clock.adjustedSeconds)
|
|
{
|
|
// the wormhole we were trying for has expired
|
|
this.setParameter("oolite_witchspaceWormhole",null);
|
|
}
|
|
else if (wormhole)
|
|
{
|
|
this.ship.destination = wormhole.position;
|
|
this.ship.desiredRange = 0;
|
|
this.ship.desiredSpeed = this.ship.maxSpeed;
|
|
this.ship.performFlyToRangeFromDestination();
|
|
this.setUpHandlers(handlers);
|
|
return;
|
|
}
|
|
|
|
var destID = this.getParameter("oolite_witchspaceDestination");
|
|
if (destID == null)
|
|
{
|
|
// look for wormholes out of here
|
|
// no systems in range
|
|
handlers.wormholeSuggested = function(hole)
|
|
{
|
|
this.ship.destination = hole.position;
|
|
this.ship.desiredRange = 0;
|
|
this.ship.desiredSpeed = this.ship.maxSpeed;
|
|
this.ship.performFlyToRangeFromDestination();
|
|
this.setParameter("oolite_witchspaceWormhole",hole);
|
|
// don't reconsider
|
|
}
|
|
handlers.playerWillEnterWitchspace = function()
|
|
{
|
|
var wormhole = this.getParameter("oolite_witchspaceWormhole");
|
|
if (wormhole != null)
|
|
{
|
|
this.ship.enterWormhole(wormhole);
|
|
}
|
|
else
|
|
{
|
|
this.ship.enterWormhole();
|
|
}
|
|
}
|
|
this.setUpHandlers(handlers);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
handlers.shipWitchspaceBlocked = function(blocker)
|
|
{
|
|
this.ship.setDestination = blocker.position;
|
|
this.ship.setDesiredRange = 30000;
|
|
this.ship.setDesiredSpeed = this.cruiseSpeed();
|
|
this.ship.performFlyToRangeFromDestination();
|
|
this.setParameter("oolite_witchspaceEntry",null);
|
|
// no reconsidering yet
|
|
}
|
|
// set up the handlers before trying it
|
|
this.setUpHandlers(handlers);
|
|
|
|
var entry = this.getParameter("oolite_witchspaceEntry");
|
|
// wait for escorts to launch
|
|
if (!this.conditionAllEscortsInFlight())
|
|
{
|
|
this.ship.destination = this.ship.position;
|
|
this.ship.desiredRange = 10000;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
if (this.ship.checkCourseToDestination())
|
|
{
|
|
this.ship.destination = this.ship.getSafeCourseToDestination();
|
|
}
|
|
this.ship.performFlyToRangeFromDestination();
|
|
|
|
}
|
|
else if (entry != null && entry < clock.seconds)
|
|
{
|
|
// this should work
|
|
var result = this.ship.exitSystem(destID);
|
|
// if it doesn't, we'll get blocked
|
|
if (result)
|
|
{
|
|
this.setParameter("oolite_witchspaceEntry",null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (entry == null)
|
|
{
|
|
this.communicate("oolite_engageWitchspaceDrive");
|
|
this.setParameter("oolite_witchspaceEntry",clock.seconds + 15);
|
|
}
|
|
this.ship.destination = this.ship.position;
|
|
this.ship.desiredRange = 10000;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
if (this.ship.checkCourseToDestination())
|
|
{
|
|
this.ship.destination = this.ship.getSafeCourseToDestination();
|
|
}
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
this.behaviourEscortMothership = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.responsesAddEscort(handlers);
|
|
this.setUpHandlers(handlers);
|
|
this.ship.desiredRange = 0;
|
|
this.ship.performEscort();
|
|
}
|
|
|
|
|
|
// Separate behaviour just in case we want to change it later
|
|
// This is the one to catch up with a distant mothership
|
|
this.behaviourRejoinMothership = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.responsesAddEscort(handlers);
|
|
this.setUpHandlers(handlers);
|
|
// to consider: should this behaviour use injectors if
|
|
// possible? so few escorts have them that it's probably not
|
|
// worth it.
|
|
this.ship.desiredRange = 0;
|
|
this.ship.performEscort();
|
|
}
|
|
|
|
/* Follow the group leader in a less organised way than escorting them */
|
|
this.behaviourFollowGroupLeader = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
if (!this.ship.group || !this.ship.group.leader)
|
|
{
|
|
this.ship.performIdle();
|
|
}
|
|
else
|
|
{
|
|
this.ship.destination = this.ship.group.leader.position;
|
|
this.ship.desiredRange = 2000+Math.random()*2000;
|
|
this.ship.desiredSpeed = this.ship.maxSpeed;
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
}
|
|
|
|
|
|
this.behaviourOfferToEscort = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
|
|
var possible = this.getParameter("oolite_scanResultSpecific");
|
|
if (possible == null)
|
|
{
|
|
this.reconsiderNow();
|
|
}
|
|
else
|
|
{
|
|
if (this.ship.offerToEscort(possible))
|
|
{
|
|
// accepted
|
|
this.reconsiderNow();
|
|
}
|
|
// if rejected, wait for next scheduled reconsideration
|
|
}
|
|
}
|
|
|
|
this.behaviourSunskim = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.responsesAddScooping(handlers);
|
|
this.setUpHandlers(handlers);
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
|
|
this.behaviourPayOffPirates = function()
|
|
{
|
|
this.ship.dumpCargo(this.ship.AIScript.oolite_intership.cargodemand);
|
|
this.communicate("oolite_agreeingToDumpCargo");
|
|
delete this.ship.AIScript.oolite_intership.cargodemand;
|
|
this.ship.AIScript.oolite_intership.cargodemandpaid = true;
|
|
this.behaviourFleeCombat();
|
|
}
|
|
|
|
this.behaviourLeaveVicinityOfTarget = function()
|
|
{
|
|
if (!this.ship.target)
|
|
{
|
|
this.reconsiderNow();
|
|
return;
|
|
}
|
|
this.ship.destination = this.ship.target.position;
|
|
this.ship.desiredRange = 27500;
|
|
this.ship.desiredSpeed = this.ship.maxSpeed;
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
|
|
this.behaviourRobTarget = function()
|
|
{
|
|
var demand = null;
|
|
if (this.ship.group && this.ship.group.leader)
|
|
{
|
|
if (this.ship.group.leader.AIScript.oolite_intership && this.ship.group.leader.AIScript.oolite_intership.cargodemanded)
|
|
{
|
|
demand = this.ship.group.leader.AIScript.oolite_intership.cargodemanded;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.ship.AIScript.oolite_intership.cargodemanded)
|
|
{
|
|
demand = this.ship.AIScript.oolite_intership.cargodemanded;
|
|
}
|
|
}
|
|
if (demand == null)
|
|
{
|
|
var hascargo = this.ship.target.cargoSpaceUsed;
|
|
// blowing them up probably gets ~10%, so how much we feel
|
|
// confident in demanding depends on how likely patrols
|
|
// are to come along and interfere.
|
|
demand = (hascargo/20)*(8-system.info.government)*(1+Math.random());
|
|
// between 5% and 80% of cargo
|
|
demand = Math.ceil(demand); // round it up so there's always at least 1
|
|
demand = 2+(demand%10); //
|
|
/*
|
|
// since cargo dumping detection uses checkScanner, this doesn't work
|
|
// for any substantial volume of cargo. Consider reinstating if
|
|
// increasing the max-count on checkScanner doesn't break things
|
|
|
|
var maxdemand = 0;
|
|
var gc = 1;
|
|
if (!this.ship.group)
|
|
{
|
|
if (this.ship.equipmentStatus("EQ_FUEL_SCOOPS") == "EQUIPMENT_OK")
|
|
{
|
|
maxdemand = this.ship.cargoSpaceAvailable;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gc = this.ship.group.ships.length;
|
|
for (var i = 0; i < gc ; i++)
|
|
{
|
|
var ship = this.ship.group.ships[i];
|
|
if (ship.equipmentStatus("EQ_FUEL_SCOOPS") == "EQUIPMENT_OK")
|
|
{
|
|
maxdemand += ship.cargoSpaceAvailable;
|
|
}
|
|
}
|
|
}
|
|
if (demand > maxdemand)
|
|
{
|
|
demand = maxdemand; // don't ask for more than we can carry
|
|
}
|
|
while (demand > gc * 5)
|
|
{
|
|
// asking for more than 5TC each probably means there
|
|
// won't be time to pick it all up anyway
|
|
demand = Math.ceil(demand/2);
|
|
}
|
|
if (demand < 2)
|
|
{
|
|
demand = 2;
|
|
}
|
|
*/
|
|
|
|
/* Record our demand with the group leader */
|
|
if (this.ship.group && this.ship.group.leader)
|
|
{
|
|
this.ship.group.leader.AIScript.oolite_intership.cargodemanded = demand;
|
|
}
|
|
else
|
|
{
|
|
this.ship.AIScript.oolite_intership.cargodemanded = demand;
|
|
}
|
|
/* Inform the victim of the demand, if possible */
|
|
if (this.ship.target.AIScript && this.ship.target.AIScript.oolite_intership)
|
|
{
|
|
this.ship.target.AIScript.oolite_intership.cargodemand = demand;
|
|
}
|
|
this.communicate("oolite_piracyAlert",this.ship.target.displayName,demand);
|
|
this.ship.requestHelpFromGroup();
|
|
/* }
|
|
else
|
|
{
|
|
log(this.ship.displayName,"Already asked for "+demand); */
|
|
}
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
this.ship.performAttack();
|
|
}
|
|
|
|
this.behaviourGuardTarget = function()
|
|
{
|
|
if (!this.ship.target)
|
|
{
|
|
this.ship.destination = this.ship.position;
|
|
}
|
|
else
|
|
{
|
|
this.ship.destination = this.ship.target.position;
|
|
}
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
this.ship.desiredRange = 2500;
|
|
}
|
|
|
|
this.behaviourReconsider = function()
|
|
{
|
|
var handlers = {};
|
|
this.responsesAddStandard(handlers);
|
|
this.setUpHandlers(handlers);
|
|
this.reconsiderNow();
|
|
}
|
|
|
|
this.behaviourBecomeInactiveThargon = function()
|
|
{
|
|
this.setUpHandlers({});
|
|
this.ship.scanClass = "CLASS_CARGO";
|
|
this.ship.target = null;
|
|
this.ship.clearDefenseTargets();
|
|
if (this.ship.group)
|
|
{
|
|
this.ship.group.removeShip(this.ship);
|
|
this.ship.group = null;
|
|
}
|
|
if (this.ship.escortGroup)
|
|
{
|
|
this.ship.escortGroup.removeShip(this.ship);
|
|
}
|
|
this.ship.desiredSpeed = 0;
|
|
this.ship.performStop();
|
|
var nearby = this.ship.checkScanner();
|
|
for (var i = 0 ; i < nearby.length ; i++)
|
|
{
|
|
var ship = nearby[i];
|
|
if (ship.target == this.ship && !ship.isPlayer && ship.hasHostileTarget)
|
|
{
|
|
ship.target = null;
|
|
}
|
|
ship.removeDefenseTarget(this.ship);
|
|
}
|
|
}
|
|
|
|
this.behaviourTumble = function()
|
|
{
|
|
this.setUpHandlers({});
|
|
this.ship.performTumble();
|
|
}
|
|
|
|
this.behaviourLandOnPlanet = function()
|
|
{
|
|
this.ship.desiredSpeed = this.ship.maxSpeed / 4;
|
|
this.ship.performLandOnPlanet();
|
|
this.ship.AIScriptWakeTime = 0; // cancel reconsiderations
|
|
this.setUpHandlers({}); // cancel interruptions
|
|
this.communicate("oolite_landingOnPlanet");
|
|
}
|
|
|
|
/* ****************** Configuration functions ************** */
|
|
|
|
/* Configurations. Configurations are set up actions for a behaviour
|
|
* or behaviours. They can also be used on a fall-through conditional
|
|
* to set parameters for later tests */
|
|
|
|
this.configurationAcquireCombatTarget = function()
|
|
{
|
|
if (this.ship.target && this.allied(this.ship,this.ship.target))
|
|
{
|
|
// don't shoot at allies even if they have ended up as a target...
|
|
this.ship.removeDefenseTarget(this.ship.target);
|
|
this.ship.target = null;
|
|
}
|
|
if (this.ship.target && this.ship.target.scanClass == "CLASS_CARGO")
|
|
{
|
|
this.ship.target = null;
|
|
}
|
|
/* Iff the ship does not currently have a target, select a new one
|
|
* from the defense target list. */
|
|
if (this.ship.target && this.ship.target.isInSpace)
|
|
{
|
|
return;
|
|
}
|
|
var dts = this.ship.defenseTargets
|
|
for (var i = 0; i < dts.length ; i++)
|
|
{
|
|
if (dts[i].position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = dts[0];
|
|
return;
|
|
}
|
|
}
|
|
if (this.ship.group != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.group.length ; i++)
|
|
{
|
|
if (this.ship.group.ships[i] != this.ship)
|
|
{
|
|
if (this.ship.group.ships[i].target && this.isFighting(this.ship.group.ships[i]) && this.ship.group.ships[i].target.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = this.ship.group.ships[i].target;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.ship.escortGroup != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.escortGroup.length ; i++)
|
|
{
|
|
if (this.ship.escortGroup.ships[i] != this.ship)
|
|
{
|
|
if (this.ship.escortGroup.ships[i].target && this.isFighting(this.ship.escortGroup.ships[i]) && this.ship.escortGroup.ships[i].target.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = this.ship.escortGroup.ships[i].target;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: reuse code from AcquireCombatTarget better
|
|
this.configurationAcquireHostileCombatTarget = function()
|
|
{
|
|
if (this.ship.target && this.allied(this.ship,this.ship.target))
|
|
{
|
|
// don't shoot at allies even if they have ended up as a target...
|
|
this.ship.removeDefenseTarget(this.ship.target);
|
|
this.ship.target = null;
|
|
}
|
|
/* Iff the ship does not currently have a target, select a new one
|
|
* from the defense target list. */
|
|
if (this.ship.target && this.ship.target.isInSpace && this.isAggressive(this.ship.target))
|
|
{
|
|
return;
|
|
}
|
|
var dts = this.ship.defenseTargets
|
|
for (var i = 0; i < dts.length ; i++)
|
|
{
|
|
if (dts[i].position.distanceTo(this.ship) < this.ship.scannerRange && this.isAggressive(dts[i]))
|
|
{
|
|
this.ship.target = dts[0];
|
|
return;
|
|
}
|
|
}
|
|
if (this.ship.group != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.group.length ; i++)
|
|
{
|
|
if (this.ship.group.ships[i] != this.ship)
|
|
{
|
|
if (this.ship.group.ships[i].target && this.isFighting(this.ship.group.ships[i]) && this.ship.group.ships[i].target.position.distanceTo(this.ship) < this.ship.scannerRange && this.isAggressive(this.ship.group.ships[i].target))
|
|
{
|
|
this.ship.target = this.ship.group.ships[i].target;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.ship.escortGroup != null)
|
|
{
|
|
for (var i = 0 ; i < this.ship.escortGroup.length ; i++)
|
|
{
|
|
if (this.ship.escortGroup.ships[i] != this.ship)
|
|
{
|
|
if (this.ship.escortGroup.ships[i].target && this.isFighting(this.ship.escortGroup.ships[i]) && this.ship.escortGroup.ships[i].target.position.distanceTo(this.ship) < this.ship.scannerRange && this.isAggressive(this.ship.escortGroup.ships[i].target))
|
|
{
|
|
this.ship.target = this.ship.escortGroup.ships[i].target;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
this.configurationAcquireOffensiveEscortTarget = function()
|
|
{
|
|
if (this.ship.group && this.ship.group.leader && this.ship.group.leader.target && this.ship.group.leader.hasHostileTarget)
|
|
{
|
|
if (this.ship.position.distanceTo(this.ship.group.leader.target) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = this.ship.group.leader.target;
|
|
this.ship.addDefenseTarget(this.ship.target);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.configurationAcquireDefensiveEscortTarget = function()
|
|
{
|
|
if (this.ship.group && this.ship.group.leader)
|
|
{
|
|
var leader = this.ship.group.leader;
|
|
if (leader.target.target == leader && this.isFighting(leader) && leader.target.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = leader.target;
|
|
}
|
|
else
|
|
{
|
|
var dts = leader.defenseTargets;
|
|
for (var i = 0 ; i < dts.length ; i++)
|
|
{
|
|
if (dts[i].target == leader && this.isAggressive(dts[i]) && dts[i].position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.ship.target = dts[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.configurationCheckScanner = function()
|
|
{
|
|
this.setParameter("oolite_scanResults",this.ship.checkScanner());
|
|
this.setParameter("oolite_scanResultSpecific",null);
|
|
}
|
|
|
|
this.configurationAcquireScannedTarget = function()
|
|
{
|
|
this.ship.target = this.getParameter("oolite_scanResultSpecific");
|
|
}
|
|
|
|
this.configurationSelectShuttleDestination = function()
|
|
{
|
|
var possibles = system.planets.concat(system.stations);
|
|
var destinations1 = [];
|
|
var destinations2 = [];
|
|
for (var i = 0; i < possibles.length ; i++)
|
|
{
|
|
var possible = possibles[i];
|
|
// travel at least a little way
|
|
var distance = possible.position.distanceTo(this.ship);
|
|
if (distance > possible.collisionRadius + 10000)
|
|
{
|
|
// must be friendly destination and not moving too fast
|
|
if (possible.isPlanet || this.friendlyStation(possible) || possible.maxSpeed > this.ship.maxSpeed / 5)
|
|
{
|
|
if (distance > system.mainPlanet.radius * 5)
|
|
{
|
|
destinations2.push(possible);
|
|
}
|
|
else
|
|
{
|
|
destinations1.push(possible);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// no nearby destinations
|
|
if (destinations1.length == 0)
|
|
{
|
|
destinations1 = destinations2;
|
|
}
|
|
// no destinations
|
|
if (destinations1.length == 0)
|
|
{
|
|
return;
|
|
}
|
|
var destination = destinations1[Math.floor(Math.random()*destinations1.length)];
|
|
if (destination.isPlanet)
|
|
{
|
|
this.setParameter("oolite_selectedPlanet",destination);
|
|
this.setParameter("oolite_selectedStation",null);
|
|
}
|
|
else
|
|
{
|
|
this.setParameter("oolite_selectedStation",destination);
|
|
this.setParameter("oolite_selectedPlanet",null);
|
|
}
|
|
}
|
|
|
|
this.configurationSelectRandomTradeStation = function()
|
|
{
|
|
var stations = system.stations;
|
|
var threshold = 1E16;
|
|
var chosenStation = null;
|
|
if (this.ship.bounty == 0)
|
|
{
|
|
if (Math.random() < 0.9 && this.friendlyStation(system.mainStation))
|
|
{
|
|
this.setParameter("oolite_selectedStation",system.mainStation);
|
|
return;
|
|
}
|
|
}
|
|
else if (this.ship.bounty <= 50)
|
|
{
|
|
if (Math.random() < 0.5 && this.friendlyStation(system.mainStation))
|
|
{
|
|
this.setParameter("oolite_selectedStation",system.mainStation);
|
|
return;
|
|
}
|
|
}
|
|
var friendlies = 0;
|
|
for (var i = 0 ; i < stations.length ; i++)
|
|
{
|
|
var station = stations[i];
|
|
if (this.friendlyStation(station))
|
|
{
|
|
friendlies++;
|
|
if (Math.random() < 1/friendlies)
|
|
{
|
|
chosenStation = station;
|
|
}
|
|
}
|
|
}
|
|
this.setParameter("oolite_selectedStation",system.mainStation);
|
|
this.communicate("oolite_selectedStation",system.mainStation.displayName);
|
|
}
|
|
|
|
|
|
this.configurationSetDestinationToWitchpoint = function()
|
|
{
|
|
this.ship.destination = new Vector3D(0,0,0);
|
|
this.ship.desiredRange = 10000;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
|
|
this.configurationSetDestinationToMainPlanet = function()
|
|
{
|
|
this.ship.destination = system.mainPlanet.position;
|
|
this.ship.desiredRange = system.mainPlanet.radius * 3;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
|
|
this.configurationSetDestinationToMainStation = function()
|
|
{
|
|
this.ship.destination = system.mainStation.position;
|
|
this.ship.desiredRange = this.ship.scannerRange/2;
|
|
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
|
|
this.configurationSetDestinationToSelectedStation = function()
|
|
{
|
|
var station = this.getParameter("oolite_selectedStation");
|
|
if (station)
|
|
{
|
|
this.ship.destination = station.position;
|
|
this.ship.desiredRange = this.ship.scannerRange/2;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
}
|
|
|
|
this.configurationSetDestinationToSelectedPlanet = function()
|
|
{
|
|
var planet = this.getParameter("oolite_selectedPlanet");
|
|
if (planet)
|
|
{
|
|
this.ship.destination = planet.position;
|
|
this.ship.desiredRange = planet.radius+100;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
}
|
|
|
|
|
|
this.configurationSetDestinationToPirateLurk = function()
|
|
{
|
|
var lurk = this.getParameter("oolite_pirateLurk");
|
|
if (lurk != null)
|
|
{
|
|
this.ship.destination = lurk;
|
|
}
|
|
else
|
|
{
|
|
var code = "WITCHPOINT";
|
|
var p = this.ship.position;
|
|
// if already on a lane, stay on it
|
|
if (p.z < system.mainPlanet.position.z && ((p.x * p.x) + (p.y * p.y)) < system.mainPlanet.radius * 3)
|
|
{
|
|
lurk = p;
|
|
}
|
|
else if (p.subtract(system.mainPlanet).dot(p.subtract(system.sun)) < -0.9)
|
|
{
|
|
lurk = p;
|
|
}
|
|
else if (p.dot(system.sun.position) > 0.9)
|
|
{
|
|
lurk = p;
|
|
}
|
|
else // not on a lane, so pick somewhere at random
|
|
{
|
|
var choice = Math.random();
|
|
if (choice < 0.8)
|
|
{
|
|
code = "LANE_WP";
|
|
}
|
|
else
|
|
{
|
|
code = "LANE_PS";
|
|
}
|
|
// code = "LANE_WS"? "WITCHPOINT"?
|
|
// what about other locations in less policed systems?
|
|
lurk = system.locationFromCode(code);
|
|
}
|
|
this.setParameter("oolite_pirateLurk",lurk);
|
|
}
|
|
this.ship.desiredRange = 1000;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
|
|
|
|
this.configurationSetDestinationToSunskimStart = function()
|
|
{
|
|
this.ship.destination = system.sun.position;
|
|
// max sunskim height is sqrt(4/3) radius
|
|
this.ship.desiredRange = system.sun.radius * 1.125;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
|
|
this.configurationSetDestinationToSunskimEnd = function()
|
|
{
|
|
var direction = Vector3D.random().cross(this.ship.position.subtract(system.sun.position));
|
|
// 2km parallel to local sun surface for every LY of fuel
|
|
this.ship.destination = this.ship.position.add(direction.multiply(2000*(7-this.ship.fuel)));
|
|
// max sunskim height is sqrt(4/3) radius
|
|
this.ship.desiredRange = 0;
|
|
this.ship.desiredSpeed = this.ship.maxSpeed;
|
|
}
|
|
|
|
this.configurationSetDestinationToNearestFriendlyStation = function()
|
|
{
|
|
var stations = system.stations;
|
|
var threshold = 1E16;
|
|
var chosenStation = null;
|
|
for (var i = 0 ; i < stations.length ; i++)
|
|
{
|
|
var station = stations[i];
|
|
if (this.friendlyStation(station))
|
|
{
|
|
var distance = station.position.distanceTo(this.ship);
|
|
if (distance < threshold)
|
|
{
|
|
threshold = distance;
|
|
chosenStation = station;
|
|
}
|
|
}
|
|
}
|
|
if (chosenStation == null)
|
|
{
|
|
this.ship.destination = this.ship.position;
|
|
this.ship.desiredRange = 0;
|
|
}
|
|
else
|
|
{
|
|
this.ship.destination = chosenStation.position;
|
|
this.ship.desiredRange = 15000;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
}
|
|
|
|
this.configurationSetDestinationToGroupLeader = function()
|
|
{
|
|
if (!this.ship.group || !this.ship.group.leader)
|
|
{
|
|
this.ship.destination = this.ship.position;
|
|
}
|
|
else
|
|
{
|
|
this.ship.destination = this.ship.group.leader.position;
|
|
}
|
|
this.ship.desiredRange = 2000;
|
|
this.ship.desiredSpeed = this.ship.maxSpeed;
|
|
}
|
|
|
|
this.configurationSetWaypoint = function()
|
|
{
|
|
var gen = this.getWaypointGenerator();
|
|
if(gen != null)
|
|
{
|
|
gen.call(this);
|
|
this.configurationSetDestinationToWaypoint();
|
|
}
|
|
}
|
|
|
|
this.configurationSetDestinationToWaypoint = function()
|
|
{
|
|
this.ship.destination = this.getParameter("oolite_waypoint");
|
|
this.ship.desiredRange = this.getParameter("oolite_waypointRange");
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
}
|
|
|
|
|
|
this.configurationSelectWitchspaceDestination = function()
|
|
{
|
|
if (!this.ship.hasHyperspaceMotor)
|
|
{
|
|
this.setParameter("oolite_witchspaceDestination",null);
|
|
return;
|
|
}
|
|
var preselected = this.getParameter("oolite_witchspaceDestination");
|
|
if (preselected != system.ID && system.info.distanceToSystem(System.infoForSystem(galaxyNumber,preselected)) <= this.ship.fuel)
|
|
{
|
|
// we've already got a destination
|
|
return;
|
|
}
|
|
var possible = system.info.systemsInRange(this.ship.fuel);
|
|
var selected = possible[Math.floor(Math.random()*possible.length)];
|
|
this.setParameter("oolite_witchspaceDestination",selected.systemID);
|
|
this.communicate("oolite_selectedWitchspaceDestination",selected.name);
|
|
}
|
|
|
|
this.configurationSetNearbyFriendlyStationForDocking = function()
|
|
{
|
|
var stations = system.stations;
|
|
for (var i = 0 ; i < stations.length ; i++)
|
|
{
|
|
var station = stations[i];
|
|
if (this.friendlyStation(station))
|
|
{
|
|
// this is not a very good check for friendliness, but
|
|
// it will have to do for now
|
|
if (station.position.distanceTo(this.ship) < this.ship.scannerRange)
|
|
{
|
|
this.setParameter("oolite_dockingStation",station)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
this.configurationSetSelectedStationForDocking = function()
|
|
{
|
|
this.setParameter("oolite_dockingStation",this.getParameter("oolite_selectedStation"));
|
|
}
|
|
|
|
|
|
this.configurationAppointGroupLeader = function()
|
|
{
|
|
if (this.ship.group && !this.ship.group.leader)
|
|
{
|
|
this.ship.group.leader = this.ship.group.ships[0];
|
|
for (var i = 0 ; i < this.ship.group.ships.length ; i++)
|
|
{
|
|
if (this.ship.group.ships[i].hasHyperspaceMotor)
|
|
{
|
|
// bias towards jump-capable ships
|
|
this.ship.group.leader = this.ship.group.ships[i];
|
|
break;
|
|
}
|
|
}
|
|
var leadrole = this.getParameter("oolite_leaderRole")
|
|
if (leadrole != null)
|
|
{
|
|
this.ship.group.leader.primaryRole = leadrole;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.configurationEscortGroupLeader = function()
|
|
{
|
|
if (!this.ship.group || !this.ship.group.leader || this.ship.group.leader == this.ship)
|
|
{
|
|
return;
|
|
}
|
|
if (this.ship.group.leader.escortGroup && this.ship.group.leader.escortGroup.containsShip(this.ship))
|
|
{
|
|
return;
|
|
}
|
|
var escrole = this.getParameter("oolite_escortRole")
|
|
if (escrole != null)
|
|
{
|
|
var oldrole = this.ship.primaryRole;
|
|
this.ship.primaryRole = escrole;
|
|
var accepted = this.ship.offerToEscort(this.ship.group.leader);
|
|
if (!accepted)
|
|
{
|
|
this.ship.primaryRole = oldrole;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
this.configurationForgetCargoDemand = function()
|
|
{
|
|
/* if (this.ship.group && this.ship.group.leader && this.ship.group.leader.AIScript.oolite_intership.cargodemanded)
|
|
{
|
|
delete this.ship.group.leader.AIScript.oolite_intership.cargodemanded;
|
|
} */ // not sure about this, maybe not needed
|
|
|
|
if (this.ship.AIScript.oolite_intership.cargodemanded)
|
|
{
|
|
delete this.ship.AIScript.oolite_intership.cargodemanded;
|
|
delete this.ship.AIScript.oolite_intership.cargodemandmet;
|
|
// and make the group lose the cargo count from the last demand
|
|
if (this.ship.group)
|
|
{
|
|
for (var i = 0 ; i < this.ship.group.ships.length ; i++)
|
|
{
|
|
var ship = this.ship.group.ships[i];
|
|
if (ship.AIScript && ship.AIScript.oolite_priorityai)
|
|
{
|
|
ship.AIScript.oolite_priorityai.setParameter("oolite_cargoDropped",0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* ****************** Response definition functions ************** */
|
|
|
|
/* Standard state-machine responses. These set up a set of standard
|
|
* state machine responses where incoming events will cause reasonable
|
|
* default behaviour and often force a reconsideration of
|
|
* priorities. Many behaviours will need to supplement the standard
|
|
* responses with additional definitions. */
|
|
|
|
this.responsesAddStandard = function(handlers)
|
|
{
|
|
handlers.cascadeWeaponDetected = function(weapon)
|
|
{
|
|
this.ship.clearDefenseTargets();
|
|
this.ship.addDefenseTarget(weapon);
|
|
this.setParameter("oolite_cascadeDetected",weapon.position);
|
|
this.ship.target = weapon;
|
|
this.ship.performFlee();
|
|
this.reconsiderNow();
|
|
};
|
|
|
|
handlers.shipAttackedWithMissile = function(missile,whom)
|
|
{
|
|
if (!this.ship.hasHostileTarget && this.getParameter("oolite_flag_sendsDistressCalls"))
|
|
{
|
|
this.ship.broadcastDistressMessage();
|
|
}
|
|
if (this.ship.equipmentStatus("EQ_ECM") == "EQUIPMENT_OK")
|
|
{
|
|
this.ship.fireECM();
|
|
this.ship.addDefenseTarget(missile);
|
|
this.ship.addDefenseTarget(whom);
|
|
// but don't reconsider immediately
|
|
}
|
|
else
|
|
{
|
|
this.ship.addDefenseTarget(missile);
|
|
this.ship.addDefenseTarget(whom);
|
|
var tmp = this.ship.target;
|
|
this.ship.target = whom;
|
|
this.ship.requestHelpFromGroup();
|
|
this.ship.target = tmp;
|
|
this.reconsiderNow();
|
|
}
|
|
};
|
|
|
|
handlers.shipBeingAttacked = function(whom)
|
|
{
|
|
if (whom.target != this.ship && whom != player.ship)
|
|
{
|
|
// was accidental
|
|
if (this.allied(whom,this.ship))
|
|
{
|
|
this.communicate("oolite_friendlyFire",whom.displayName);
|
|
// ignore it
|
|
return;
|
|
}
|
|
if (Math.random() > 0.1)
|
|
{
|
|
// usually ignore it anyway
|
|
return;
|
|
}
|
|
}
|
|
if (!this.ship.hasHostileTarget && this.getParameter("oolite_flag_sendsDistressCalls"))
|
|
{
|
|
this.ship.broadcastDistressMessage();
|
|
}
|
|
if (this.ship.defenseTargets.indexOf(whom) < 0)
|
|
{
|
|
this.ship.addDefenseTarget(whom);
|
|
this.reconsiderNow();
|
|
}
|
|
else
|
|
{
|
|
// else we know about this attacker already
|
|
if (this.ship.energy * 4 < this.ship.maxEnergy)
|
|
{
|
|
// but at low energy still reconsider
|
|
this.reconsiderNow();
|
|
this.ship.requestHelpFromGroup();
|
|
}
|
|
}
|
|
if (this.ship.hasHostileTarget)
|
|
{
|
|
if (!this.isAggressive(this.ship.target))
|
|
{
|
|
// if our current target is running away, switch targets
|
|
this.ship.target = whom;
|
|
}
|
|
else if (this.ship.target.target != this.ship)
|
|
{
|
|
// if our current target isn't aiming at us
|
|
if (Math.random() < 0.2)
|
|
{
|
|
// occasionally switch
|
|
this.ship.target = whom;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.ship.escortGroup != null)
|
|
{
|
|
this.ship.requestHelpFromGroup();
|
|
}
|
|
};
|
|
handlers.shipBeingAttackedUnsuccessfully = function(whom)
|
|
{
|
|
if (!this.ship.hasHostileTarget && this.getParameter("oolite_flag_sendsDistressCalls"))
|
|
{
|
|
this.ship.broadcastDistressMessage();
|
|
}
|
|
if (this.ship.defenseTargets.indexOf(whom) < 0)
|
|
{
|
|
this.ship.addDefenseTarget(whom);
|
|
this.reconsiderNow();
|
|
}
|
|
};
|
|
handlers.shipTargetLost = function(target)
|
|
{
|
|
this.reconsiderNow();
|
|
};
|
|
// overridden for escorts
|
|
handlers.helpRequestReceived = function(ally, enemy)
|
|
{
|
|
this.ship.addDefenseTarget(enemy);
|
|
if (!this.ship.hasHostileTarget)
|
|
{
|
|
this.reconsiderNow();
|
|
return; // not in a combat mode
|
|
}
|
|
if (ally.energy / ally.maxEnergy < this.ship.energy / this.ship.maxEnergy)
|
|
{
|
|
// not in worse shape than ally
|
|
if (this.ship.target.target != ally && this.ship.target != ally.target)
|
|
{
|
|
// not already helping, go for it...
|
|
this.ship.target = enemy;
|
|
this.reconsiderNow();
|
|
}
|
|
}
|
|
}
|
|
handlers.cargoDumpedNearby = function(cargo,ship)
|
|
{
|
|
if (this.getParameter("oolite_flag_watchForCargo"))
|
|
{
|
|
var previously = this.getParameter("oolite_cargoDropped");
|
|
if (previously == null)
|
|
{
|
|
previously = 0;
|
|
}
|
|
previously++;
|
|
this.setParameter("oolite_cargoDropped",previously);
|
|
}
|
|
}
|
|
handlers.approachingPlanetSurface = function()
|
|
{
|
|
if (this.getParameter("oolite_flag_allowPlanetaryLanding"))
|
|
{
|
|
this.ship.desiredSpeed = this.ship.maxSpeed / 4;
|
|
this.ship.performLandOnPlanet();
|
|
this.ship.AIScriptWakeTime = 0; // cancel reconsiderations
|
|
this.setUpHandlers({}); // cancel interruptions
|
|
this.communicate("oolite_landingOnPlanet");
|
|
}
|
|
else
|
|
{
|
|
this.reconsiderNow();
|
|
}
|
|
}
|
|
handlers.shipLaunchedFromStation = function(station)
|
|
{
|
|
// clear the station
|
|
this.ship.destination = station.position;
|
|
this.ship.desiredSpeed = this.cruiseSpeed();
|
|
this.ship.desiredRange = 15000;
|
|
this.ship.performFlyToRangeFromDestination();
|
|
}
|
|
handlers.shipWillEnterWormhole = function()
|
|
{
|
|
this.setUpHandlers({});
|
|
}
|
|
handlers.shipExitedWormhole = function()
|
|
{
|
|
this.ship.AIScript.oolite_intership = {};
|
|
// this.reconsiderNow();
|
|
}
|
|
|
|
handlers.distressMessageReceived = function(aggressor, sender)
|
|
{
|
|
if (this.getParameter("oolite_flag_listenForDistressCall") != true)
|
|
{
|
|
return;
|
|
}
|
|
this.setParameter("oolite_distressAggressor",aggressor);
|
|
this.setParameter("oolite_distressSender",sender);
|
|
this.reconsiderNow();
|
|
}
|
|
handlers.offenceCommittedNearby = function(attacker, victim)
|
|
{
|
|
if (this.getParameter("oolite_flag_markOffenders"))
|
|
{
|
|
attacker.setBounty(attacker.bounty | 7,"seen by police");
|
|
this.ship.addDefenseTarget(attacker);
|
|
this.reconsiderNow();
|
|
}
|
|
}
|
|
handlers.playerWillEnterWitchspace = function()
|
|
{
|
|
var wormhole = this.getParameter("oolite_witchspaceWormhole");
|
|
if (wormhole != null)
|
|
{
|
|
this.ship.enterWormhole(wormhole);
|
|
}
|
|
}
|
|
handlers.wormholeSuggested = function(hole)
|
|
{
|
|
this.setParameter("oolite_witchspaceWormhole",hole);
|
|
this.reconsiderNow();
|
|
}
|
|
// TODO: more event handlers
|
|
}
|
|
|
|
/* Additional handlers for use while docking */
|
|
this.responsesAddDocking = function(handlers)
|
|
{
|
|
handlers.stationWithdrewDockingClearance = function()
|
|
{
|
|
this.setParameter("oolite_dockingStation",null);
|
|
this.reconsiderNow();
|
|
};
|
|
|
|
handlers.shipAchievedDesiredRange = function()
|
|
{
|
|
var message = this.ship.dockingInstructions.ai_message;
|
|
if (message == "APPROACH" || message == "BACK_OFF" || message == "APPROACH_COORDINATES")
|
|
{
|
|
this.reconsiderNow();
|
|
}
|
|
};
|
|
}
|
|
|
|
/* Override of standard handlers for use while escorting */
|
|
this.responsesAddEscort = function(handlers)
|
|
{
|
|
handlers.helpRequestReceived = function(ally, enemy)
|
|
{
|
|
// always help the leader
|
|
if (ally == this.ship.group.leader)
|
|
{
|
|
if (!this.ship.target || this.ship.target.target != ally)
|
|
{
|
|
this.ship.target = enemy;
|
|
this.reconsiderNow();
|
|
return;
|
|
}
|
|
}
|
|
this.ship.addDefenseTarget(enemy);
|
|
if (!this.ship.hasHostileTarget)
|
|
{
|
|
this.reconsiderNow();
|
|
return; // not in a combat mode
|
|
}
|
|
if (ally.energy / ally.maxEnergy < this.ship.energy / this.ship.maxEnergy)
|
|
{
|
|
// not in worse shape than ally
|
|
if (this.ship.target.target != ally && this.ship.target != ally.target)
|
|
{
|
|
// not already helping, go for it...
|
|
this.ship.target = enemy;
|
|
this.reconsiderNow();
|
|
}
|
|
}
|
|
}
|
|
handlers.escortDock = function()
|
|
{
|
|
this.reconsiderNow();
|
|
}
|
|
|
|
}
|
|
|
|
/* Additional handlers for scooping */
|
|
this.responsesAddScooping = function(handlers)
|
|
{
|
|
handlers.shipAchievedDesiredRange = function()
|
|
{
|
|
this.reconsiderNow();
|
|
}
|
|
handlers.shipScoopedFuel = function()
|
|
{
|
|
if (this.ship.fuel == 7)
|
|
{
|
|
this.reconsiderNow();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* ******************* Waypoint generators *********************** */
|
|
|
|
/* Waypoint generators. When these are called, they should set up
|
|
* the next waypoint for the ship. Ideally ships should either
|
|
* reach that waypoint or formally give up on it before asking for
|
|
* the next one, but the generator shouldn't assume that unless
|
|
* it's one written specifically for a particular AI. */
|
|
|
|
this.waypointsSpacelanePatrol = function()
|
|
{
|
|
var p = this.ship.position;
|
|
var choice = "";
|
|
if (p.magnitude() < 10000)
|
|
{
|
|
// near witchpoint
|
|
if (Math.random() < 0.9)
|
|
{
|
|
// mostly return to planet
|
|
choice = "PLANET";
|
|
}
|
|
else
|
|
{
|
|
choice = "SUN";
|
|
}
|
|
}
|
|
else if (p.distanceTo(system.mainPlanet) < system.mainPlanet.radius * 2)
|
|
{
|
|
// near planet
|
|
if (Math.random() < 0.75)
|
|
{
|
|
// mostly go to witchpoint
|
|
choice = "WITCHPOINT";
|
|
}
|
|
else
|
|
{
|
|
choice = "SUN";
|
|
}
|
|
}
|
|
else if (p.distanceTo(system.sun) < system.sun.radius * 3)
|
|
{
|
|
// near sun
|
|
if (Math.random() < 0.9)
|
|
{
|
|
// mostly return to planet
|
|
choice = "PLANET";
|
|
}
|
|
else
|
|
{
|
|
choice = "SUN";
|
|
}
|
|
}
|
|
else if (p.z < system.mainPlanet.position.z && ((p.x * p.x) + (p.y * p.y)) < system.mainPlanet.radius * 3)
|
|
{
|
|
// on lane 1
|
|
if (Math.random() < 0.5)
|
|
{
|
|
choice = "PLANET";
|
|
}
|
|
else
|
|
{
|
|
choice = "WITCHPOINT";
|
|
}
|
|
}
|
|
else if (p.subtract(system.mainPlanet).dot(p.subtract(system.sun)) < -0.9)
|
|
{
|
|
// on lane 2
|
|
if (Math.random() < 0.5)
|
|
{
|
|
choice = "PLANET";
|
|
}
|
|
else
|
|
{
|
|
choice = "SUN";
|
|
}
|
|
}
|
|
else if (p.dot(system.sun.position) > 0.9)
|
|
{
|
|
// on lane 3
|
|
if (Math.random() < 0.5)
|
|
{
|
|
choice = "WITCHPOINT";
|
|
}
|
|
else
|
|
{
|
|
choice = "SUN";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we're not on any lane. Return to the planet
|
|
choice = "PLANET";
|
|
}
|
|
// having chosen, now set up the next stop on the patrol
|
|
switch (choice) {
|
|
case "WITCHPOINT":
|
|
this.setParameter("oolite_waypoint",new Vector3D(0,0,0));
|
|
this.setParameter("oolite_waypointRange",7500);
|
|
break;
|
|
case "PLANET":
|
|
this.setParameter("oolite_waypoint",system.mainPlanet.position);
|
|
this.setParameter("oolite_waypointRange",system.mainPlanet.radius*2);
|
|
break;
|
|
case "SUN":
|
|
this.setParameter("oolite_waypoint",system.sun.position);
|
|
this.setParameter("oolite_waypointRange",system.sun.radius*2.5);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
this.waypointsStationPatrol = function()
|
|
{
|
|
var station = null;
|
|
if (this.ship.group)
|
|
{
|
|
station = this.ship.group.leader;
|
|
}
|
|
if (!station)
|
|
{
|
|
station = system.mainStation;
|
|
if (!station)
|
|
{
|
|
this.setParameter("oolite_waypoint",new Vector3D(0,0,0));
|
|
this.setParameter("oolite_waypointRange",7500);
|
|
return;
|
|
}
|
|
}
|
|
var z = station.vectorForward;
|
|
var tmp = new Vector3D(0,1,0);
|
|
if (system.sun)
|
|
{
|
|
tmp = z.cross(system.sun.position.direction());
|
|
}
|
|
var x = z.cross(tmp);
|
|
var y = z.cross(x);
|
|
// x and y now consistent vectors relative to a rotating station
|
|
|
|
var waypoints = [
|
|
station.position.add(x.multiply(25000)),
|
|
station.position.add(y.multiply(25000)),
|
|
station.position.add(x.multiply(-25000)),
|
|
station.position.add(y.multiply(-25000))
|
|
];
|
|
|
|
var waypoint = waypoints[0];
|
|
for (var i=0;i<=3;i++)
|
|
{
|
|
if (this.ship.position.distanceTo(waypoints[i]) < 500)
|
|
{
|
|
waypoint = waypoints[(i+1)%4];
|
|
break;
|
|
}
|
|
}
|
|
this.setParameter("oolite_waypoint",waypoint);
|
|
this.setParameter("oolite_waypointRange",100);
|
|
|
|
}
|
|
|
|
|
|
}; // end object constructor
|
|
|
|
|
|
/* Object prototype */
|
|
AILib.prototype.constructor = AILib;
|
|
AILib.prototype.name = this.name;
|