mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-01-17 00:05:07 -05:00
5c2e112349
* Code compiles - execution NOT tested * updating gitignore * Removed intellij settings files * Removed more intellij files * Added exclusion for JDK classes. * Fixed purchasing script for vendors that have listed coin types. * Updated script to not kick off until the entire preload is complete. * adds static name entry for Solo movie poster and tcg9 vendor entry * clean up empty and orphaned object templates * adds placeholder black market (static) spawns * corrects entries for the video game table to correctly set it in tcg series 2 and remove series 1 console errors * Updated gitignore and removed intellij project files * Fixed appearance reference for thranta payroll and kashyyyk door, added skipLosCheck objvar due to cannit see issue. Requires updated src * Fixed appearance and template for terminal (#2) * Fixed appearance and template for terminal (#3) * Fixed appearance and template for terminal (#4) * Deleted another faulty/orphaned object template * Fixed gcw ranks option on frog. Only issue is that it doesn't award the officer commands or badges. * Fixed some unneeded java 11 changes
708 lines
27 KiB
Java
Executable File
708 lines
27 KiB
Java
Executable File
package script.library;
|
|
|
|
import script.dictionary;
|
|
import script.obj_id;
|
|
import script.transform;
|
|
import script.vector;
|
|
|
|
import java.util.Random;
|
|
import java.util.Vector;
|
|
|
|
public class ship_ai extends script.base_script
|
|
{
|
|
public ship_ai()
|
|
{
|
|
}
|
|
public static final float DEFAULT_FOLLOW_DISTANCE = 20.0f;
|
|
public static final int BEHAVIOR_IDLE = 0;
|
|
public static final int BEHAVIOR_TRACK = 1;
|
|
public static final int BEHAVIOR_MOVETO = 2;
|
|
public static final int BEHAVIOR_PATROL = 3;
|
|
public static final int BEHAVIOR_FOLLOW = 4;
|
|
public static final int ATTACK_ORDERS_HOLD_FIRE = 0;
|
|
public static final int ATTACK_ORDERS_RETURN_FIRE = 1;
|
|
public static final int ATTACK_ORDERS_ATTACK_FREELY = 2;
|
|
public static final int FORMATION_INVALID = 0;
|
|
public static final int FORMATION_CLAW = 1;
|
|
public static final int FORMATION_WALL = 2;
|
|
public static final int FORMATION_SPHERE = 3;
|
|
public static final int FORMATION_DELTA = 4;
|
|
public static final int FORMATION_BROAD = 5;
|
|
public static final int FORMATION_X = 6;
|
|
public static int unitGetBehavior(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetBehavior(unit);
|
|
}
|
|
public static void unitIdle(obj_id unit) throws InterruptedException
|
|
{
|
|
_spaceUnitIdle(unit);
|
|
}
|
|
public static void squadIdle(int squadId) throws InterruptedException
|
|
{
|
|
_spaceSquadIdle(squadId);
|
|
}
|
|
public static void unitTrack(obj_id unit, obj_id target) throws InterruptedException
|
|
{
|
|
_spaceUnitTrack(unit, target);
|
|
}
|
|
public static void squadTrack(int squadId, obj_id target) throws InterruptedException
|
|
{
|
|
_spaceSquadTrack(squadId, target);
|
|
}
|
|
public static void unitMoveTo(obj_id unit, transform[] path) throws InterruptedException
|
|
{
|
|
_spaceUnitMoveTo(unit, path);
|
|
}
|
|
public static void squadMoveTo(int squadId, transform[] path) throws InterruptedException
|
|
{
|
|
_spaceSquadMoveTo(squadId, path);
|
|
}
|
|
public static void unitMoveTo(obj_id unit, transform position) throws InterruptedException
|
|
{
|
|
transform path[] = new transform[1];
|
|
path[0] = position;
|
|
_spaceUnitMoveTo(unit, path);
|
|
}
|
|
public static void squadMoveTo(int squadId, transform position) throws InterruptedException
|
|
{
|
|
transform path[] = new transform[1];
|
|
path[0] = position;
|
|
_spaceSquadMoveTo(squadId, path);
|
|
}
|
|
public static void unitAddPatrolPath(obj_id unit, transform[] path) throws InterruptedException
|
|
{
|
|
_spaceUnitAddPatrolPath(unit, path);
|
|
}
|
|
public static void squadAddPatrolPath(int squadId, transform[] path) throws InterruptedException
|
|
{
|
|
_spaceSquadAddPatrolPath(squadId, path);
|
|
}
|
|
public static void unitPatrol(obj_id unit, transform[] path) throws InterruptedException
|
|
{
|
|
unitClearPatrolPath(unit);
|
|
unitAddPatrolPath(unit, path);
|
|
}
|
|
public static void squadPatrol(int squadId, transform[] path) throws InterruptedException
|
|
{
|
|
squadClearPatrolPath(squadId);
|
|
squadAddPatrolPath(squadId, path);
|
|
}
|
|
public static transform[] createPatrolPathCircle(vector position_w, float radius) throws InterruptedException
|
|
{
|
|
final int points = 20;
|
|
transform path[] = new transform[points];
|
|
float radian;
|
|
float x;
|
|
float y;
|
|
float z;
|
|
for (int i = 0; i < points; ++i)
|
|
{
|
|
radian = (float)Math.PI * 2.0f * ((float)i / points);
|
|
x = position_w.x + (float) StrictMath.sin(radian) * radius;
|
|
y = position_w.y;
|
|
z = position_w.z + (float) StrictMath.cos(radian) * radius;
|
|
path[i] = transform.identity.setPosition_p(x, y, z);
|
|
}
|
|
return path;
|
|
}
|
|
public static transform[] createPatrolPathLoiter(transform transform_w, float minDist, float maxDist) throws InterruptedException
|
|
{
|
|
final int points = 20;
|
|
transform path[] = new transform[points];
|
|
vector direction;
|
|
vector position;
|
|
for (int i = 0; i < points; ++i)
|
|
{
|
|
direction = vector.randomUnit();
|
|
position = (transform_w.getPosition_p()).add(direction.multiply(minDist + (float)Math.random() * (maxDist - minDist)));
|
|
path[i] = transform.identity.setPosition_p(position);
|
|
}
|
|
return path;
|
|
}
|
|
public static void unitLoiter(obj_id unit, transform transform_w, float minDist, float maxDist) throws InterruptedException
|
|
{
|
|
unitPatrol(unit, createPatrolPathLoiter(transform_w, minDist, maxDist));
|
|
}
|
|
public static void squadLoiter(int squadId, transform transform_w, float minDist, float maxDist) throws InterruptedException
|
|
{
|
|
squadPatrol(squadId, createPatrolPathLoiter(transform_w, minDist, maxDist));
|
|
}
|
|
public static void unitClearPatrolPath(obj_id unit) throws InterruptedException
|
|
{
|
|
_spaceUnitClearPatrolPath(unit);
|
|
}
|
|
public static void squadClearPatrolPath(int squadId) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
_spaceUnitClearPatrolPath(anUnitList);
|
|
}
|
|
}
|
|
public static void unitFollow(obj_id unit, obj_id followedUnit, vector direction_o, float distance) throws InterruptedException
|
|
{
|
|
_spaceUnitFollow(unit, followedUnit, direction_o, distance);
|
|
}
|
|
public static void squadFollow(int squadId, obj_id followedUnit, vector direction_o, float distance) throws InterruptedException
|
|
{
|
|
_spaceSquadFollow(squadId, followedUnit, direction_o, distance);
|
|
}
|
|
public static void unitAddDamageTaken(obj_id unit, obj_id targetUnit, float damage) throws InterruptedException
|
|
{
|
|
_spaceUnitAddDamageTaken(unit, targetUnit, damage);
|
|
}
|
|
public static void unitSetAttackOrders(obj_id unit, int attackOrders) throws InterruptedException
|
|
{
|
|
_spaceUnitSetAttackOrders(unit, attackOrders);
|
|
}
|
|
public static void squadSetAttackOrders(int squadId, int attackOrders) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
unitSetAttackOrders(anUnitList, attackOrders);
|
|
}
|
|
}
|
|
public static void unitSetLeashDistance(obj_id unit, float distance) throws InterruptedException
|
|
{
|
|
_spaceUnitSetLeashDistance(unit, distance);
|
|
}
|
|
public static void squadSetLeashDistance(int squadId, float distance) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
unitSetLeashDistance(anUnitList, distance);
|
|
}
|
|
}
|
|
public static void unitSetPilotType(obj_id unit, String pilotType) throws InterruptedException
|
|
{
|
|
_spaceUnitSetPilotType(unit, pilotType);
|
|
}
|
|
public static String unitGetPilotType(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetPilotType(unit);
|
|
}
|
|
public static obj_id unitGetPrimaryAttackTarget(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetPrimaryAttackTarget(unit);
|
|
}
|
|
public static obj_id[] unitGetAttackTargetList(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetAttackTargetList(unit);
|
|
}
|
|
public static obj_id[] unitGetWhoIsTargetingMe(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetWhoIsTargetingMe(unit);
|
|
}
|
|
public static boolean unitIsAttacking(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitIsAttacking(unit);
|
|
}
|
|
public static void unitIncreaseHate(obj_id unit, obj_id unitToHate, float amountToHate, float hateDelay, int maxRecursions) throws InterruptedException
|
|
{
|
|
if ((!isIdValid(unit)) || isPlayer(unit) || !isIdValid(unitToHate))
|
|
{
|
|
return;
|
|
}
|
|
if (!exists(unitToHate) || !unitToHate.isLoaded())
|
|
{
|
|
return;
|
|
}
|
|
--maxRecursions;
|
|
if (maxRecursions < 1)
|
|
{
|
|
return;
|
|
}
|
|
else if (maxRecursions > 20)
|
|
{
|
|
maxRecursions = 20;
|
|
}
|
|
if (hateDelay < 10.0f)
|
|
{
|
|
hateDelay = 10.0f;
|
|
}
|
|
if (unitGetPrimaryAttackTarget(unit) != unitToHate)
|
|
{
|
|
unitAddDamageTaken(unit, unitToHate, amountToHate);
|
|
}
|
|
dictionary parms = new dictionary();
|
|
parms.put("unitToHate", unitToHate);
|
|
parms.put("amountToHate", amountToHate);
|
|
parms.put("hateDelay", hateDelay);
|
|
parms.put("maxRecursions", maxRecursions);
|
|
messageTo(unit, "handleUnitIncreaseHate", parms, hateDelay, false);
|
|
}
|
|
public static void unitRemoveAttackTarget(obj_id unit, obj_id unitToRemove) throws InterruptedException
|
|
{
|
|
_spaceUnitRemoveAttackTarget(unit, unitToRemove);
|
|
}
|
|
public static void unitRemoveFromAllAttackTargetLists(obj_id unit) throws InterruptedException
|
|
{
|
|
obj_id[] whoIsTargetingMeList = unitGetWhoIsTargetingMe(unit);
|
|
for (obj_id aWhoIsTargetingMeList : whoIsTargetingMeList) {
|
|
if (exists(aWhoIsTargetingMeList) && (aWhoIsTargetingMeList.isLoaded())) {
|
|
if (!space_utils.isPlayerControlledShip(aWhoIsTargetingMeList)) {
|
|
unitRemoveAttackTarget(aWhoIsTargetingMeList, unit);
|
|
} else {
|
|
LOG("space", aWhoIsTargetingMeList + " was passed into getWhoistargetingme but it's a PLAYER");
|
|
}
|
|
} else {
|
|
LOG("space", aWhoIsTargetingMeList + " was passed into unitGetWhoIsTargetingMe but doesn't exist on the server");
|
|
}
|
|
}
|
|
}
|
|
public static void unitSetPrimaryTarget(obj_id unit, obj_id targetUnit) throws InterruptedException
|
|
{
|
|
unitAddDamageTaken(unit, targetUnit, 100000.0f);
|
|
}
|
|
public static void unitAddTarget(obj_id unit, obj_id targetUnit) throws InterruptedException
|
|
{
|
|
unitAddDamageTaken(unit, targetUnit, 100.0f);
|
|
}
|
|
public static void squadSetPrimaryTarget(int squadId, obj_id targetUnit) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
unitAddDamageTaken(anUnitList, targetUnit, 100000.0f);
|
|
}
|
|
}
|
|
public static void squadAddTarget(int squadId, obj_id targetUnit) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
unitAddDamageTaken(anUnitList, targetUnit, 100.0f);
|
|
}
|
|
}
|
|
public static void squadSetPrimaryTarget(int squadId, int targetSquadId) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
obj_id[] targetUnitList = squadGetUnitList(targetSquadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
for (obj_id aTargetUnitList : targetUnitList) {
|
|
unitAddDamageTaken(anUnitList, aTargetUnitList, (float) Math.random() * 100000.0f + 100000.0f);
|
|
}
|
|
}
|
|
}
|
|
public static void squadAddTarget(int squadId, int targetSquadId) throws InterruptedException
|
|
{
|
|
obj_id[] unitList = squadGetUnitList(squadId);
|
|
obj_id[] targetUnitList = squadGetUnitList(targetSquadId);
|
|
for (obj_id anUnitList : unitList) {
|
|
for (obj_id aTargetUnitList : targetUnitList) {
|
|
unitAddDamageTaken(anUnitList, aTargetUnitList, (float) Math.random() * 100.0f + 100.0f);
|
|
}
|
|
}
|
|
}
|
|
public static void unitSetSquadId(obj_id unit, int squadId) throws InterruptedException
|
|
{
|
|
if (unitGetSquadId(unit) != squadId)
|
|
{
|
|
_spaceUnitSetSquadId(unit, squadId);
|
|
}
|
|
}
|
|
public static int unitGetSquadId(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetSquadId(unit);
|
|
}
|
|
public static int squadCreateSquadId() throws InterruptedException
|
|
{
|
|
return _spaceSquadCreateSquadId();
|
|
}
|
|
public static int squadRemoveUnit(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceSquadRemoveUnit(unit);
|
|
}
|
|
public static int squadCombine(int squadId1, int squadId2) throws InterruptedException
|
|
{
|
|
return _spaceSquadCombine(squadId1, squadId2);
|
|
}
|
|
public static int squadGetSize(int squadId) throws InterruptedException
|
|
{
|
|
return _spaceSquadGetSize(squadId);
|
|
}
|
|
public static obj_id[] squadGetUnitList(int squadId) throws InterruptedException
|
|
{
|
|
return _spaceSquadGetUnitList(squadId);
|
|
}
|
|
public static void squadSetFormation(int squadId, int formation) throws InterruptedException
|
|
{
|
|
_spaceSquadSetFormation(squadId, formation);
|
|
}
|
|
public static void squadSetFormationRandom(int squadId) throws InterruptedException
|
|
{
|
|
Random random = new Random();
|
|
final int value = Math.abs(random.nextInt()) % 6;
|
|
int formation;
|
|
switch (value)
|
|
{
|
|
case 0:
|
|
formation = FORMATION_CLAW;
|
|
break;
|
|
case 1:
|
|
formation = FORMATION_WALL;
|
|
break;
|
|
case 2:
|
|
formation = FORMATION_SPHERE;
|
|
break;
|
|
case 3:
|
|
formation = FORMATION_DELTA;
|
|
break;
|
|
case 4:
|
|
formation = FORMATION_BROAD;
|
|
break;
|
|
case 5:
|
|
formation = FORMATION_X;
|
|
break;
|
|
default:
|
|
formation = FORMATION_INVALID;
|
|
break;
|
|
}
|
|
_spaceSquadSetFormation(squadId, formation);
|
|
}
|
|
public static void squadSetFormationSpacing(int squadId, float scale) throws InterruptedException
|
|
{
|
|
_spaceSquadSetFormationSpacing(squadId, scale);
|
|
}
|
|
public static int squadGetFormation(int squadId) throws InterruptedException
|
|
{
|
|
return _spaceSquadGetFormation(squadId);
|
|
}
|
|
public static void squadSetLeader(int squadId, obj_id unit) throws InterruptedException
|
|
{
|
|
_spaceSquadSetLeader(squadId, unit);
|
|
}
|
|
public static obj_id squadGetLeader(int squadId) throws InterruptedException
|
|
{
|
|
return _spaceSquadGetLeader(squadId);
|
|
}
|
|
public static void squadSetGuardTarget(int squad, int targetSquad) throws InterruptedException
|
|
{
|
|
_spaceSquadSetGuardTarget(squad, targetSquad);
|
|
}
|
|
public static boolean squadIsGuarding(int squad) throws InterruptedException
|
|
{
|
|
return (squadGetGuardTarget(squad) == 0);
|
|
}
|
|
public static int squadGetGuardTarget(int squad) throws InterruptedException
|
|
{
|
|
return _spaceSquadGetGuardTarget(squad);
|
|
}
|
|
public static void squadRemoveGuardTarget(int squad) throws InterruptedException
|
|
{
|
|
_spaceSquadRemoveGuardTarget(squad);
|
|
}
|
|
public static void unitDock(obj_id unit, obj_id dockTarget, float timeAtDock) throws InterruptedException
|
|
{
|
|
_spaceUnitDock(unit, dockTarget, timeAtDock);
|
|
}
|
|
public static void unitDock(obj_id unit, obj_id dockTarget) throws InterruptedException
|
|
{
|
|
unitDock(unit, dockTarget, -1.0f);
|
|
}
|
|
public static void unitUnDock(obj_id unit) throws InterruptedException
|
|
{
|
|
_spaceUnitUnDock(unit);
|
|
}
|
|
public static boolean unitIsDocked(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitIsDocked(unit);
|
|
}
|
|
public static boolean unitIsDocking(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitIsDocking(unit);
|
|
}
|
|
public static void unitSetAutoAggroImmuneTime(obj_id unit, float time) throws InterruptedException
|
|
{
|
|
_spaceUnitSetAutoAggroImmuneTime(unit, time);
|
|
}
|
|
public static void unitSetAutoAggroImmune(obj_id unit, boolean enabled) throws InterruptedException
|
|
{
|
|
_spaceUnitSetAutoAggroImmuneTime(unit, enabled ? -1.0f : 0.0f);
|
|
}
|
|
public static boolean unitIsAutoAggroImmune(obj_id unit) throws InterruptedException
|
|
{
|
|
return _spaceUnitIsAutoAggroImmune(unit);
|
|
}
|
|
public static void unitSetDamageAggroImmune(obj_id unit, boolean enabled) throws InterruptedException
|
|
{
|
|
_spaceUnitSetDamageAggroImmune(unit, enabled);
|
|
}
|
|
public static transform unitGetDockTransform(obj_id dockTarget, obj_id dockingUnit) throws InterruptedException
|
|
{
|
|
return _spaceUnitGetDockTransform(dockTarget, dockingUnit);
|
|
}
|
|
public static void unitAddExclusiveAggro(obj_id unit, obj_id pilot) throws InterruptedException
|
|
{
|
|
_spaceUnitAddExclusiveAggro(unit, pilot);
|
|
}
|
|
public static void unitRemoveExclusiveAggro(obj_id unit, obj_id pilot) throws InterruptedException
|
|
{
|
|
_spaceUnitRemoveExclusiveAggro(unit, pilot);
|
|
}
|
|
public static boolean isSquadIdValid(int squadId) throws InterruptedException
|
|
{
|
|
return _spaceSquadIsSquadIdValid(squadId);
|
|
}
|
|
public static boolean isShipDead(obj_id ship) throws InterruptedException {
|
|
return !isIdValid(ship) || !ship.isLoaded() || (hasObjVar(ship, "ship.isDead"));
|
|
}
|
|
public static boolean isPlayerShip(obj_id ship) throws InterruptedException {
|
|
obj_id pilot = getPilotId(ship);
|
|
return isIdValid(pilot) && (isPlayer(pilot));
|
|
}
|
|
public static boolean isShipAggro(obj_id ship) throws InterruptedException
|
|
{
|
|
if (isPlayerShip(ship))
|
|
{
|
|
return false;
|
|
}
|
|
if (!hasObjVar(ship, "ship.shipName"))
|
|
{
|
|
return true;
|
|
}
|
|
String shipName = getStringObjVar(ship, "ship.shipName");
|
|
return (dataTableGetInt("datatables/space_mobile/space_mobile.iff", shipName, "isAggro") == 1);
|
|
}
|
|
public static boolean isShipAggroToward(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
String shipFaction = getShipFaction(ship);
|
|
String targetFaction = getShipFaction(target);
|
|
if (shipFaction == null || targetFaction == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (shipFaction.equals(targetFaction))
|
|
{
|
|
return false;
|
|
}
|
|
if (!hasObjVar(ship, "ship.shipName"))
|
|
{
|
|
return false;
|
|
}
|
|
String enemyFactionList = dataTableGetString("datatables/space_mobile/space_mobile.iff", getStringObjVar(ship, "ship.shipName"), "enemyFactions");
|
|
if (enemyFactionList == null)
|
|
{
|
|
return false;
|
|
}
|
|
String[] enemiesList = split(enemyFactionList, ',');
|
|
for (String anEnemiesList : enemiesList) {
|
|
if (anEnemiesList.equals(targetFaction)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public static boolean isShipAlliedWith(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
if (!isShipSocial(ship))
|
|
{
|
|
return false;
|
|
}
|
|
String shipFaction = getShipFaction(ship);
|
|
String targetFaction = getShipFaction(target);
|
|
if (shipFaction == null || targetFaction == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (shipFaction.equals(targetFaction))
|
|
{
|
|
return true;
|
|
}
|
|
if (!hasObjVar(ship, "ship.shipName"))
|
|
{
|
|
return false;
|
|
}
|
|
String allyFactionList = dataTableGetString("datatables/space_mobile/space_mobile.iff", getStringObjVar(ship, "ship.shipName"), "alliedFactions");
|
|
if (allyFactionList == null)
|
|
{
|
|
return false;
|
|
}
|
|
String[] allyList = split(allyFactionList, ',');
|
|
for (String anAllyList : allyList) {
|
|
if (anAllyList.equals(targetFaction)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public static boolean isShipSocial(obj_id ship) throws InterruptedException
|
|
{
|
|
if (!hasObjVar(ship, "ship.shipName"))
|
|
{
|
|
return true;
|
|
}
|
|
String shipName = getStringObjVar(ship, "ship.shipName");
|
|
String enemyFactionList = dataTableGetString("datatables/space_mobile/space_mobile.iff", shipName, "enemyFactions");
|
|
String allyFactionList = dataTableGetString("datatables/space_mobile/space_mobile.iff", shipName, "alliedFactions");
|
|
if (enemyFactionList == null || allyFactionList == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (enemyFactionList.equals("") || allyFactionList.equals(""))
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
public static boolean isSameFaction(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
String shipFaction = getShipFaction(ship);
|
|
String targetFaction = getShipFaction(target);
|
|
if (shipFaction == null || targetFaction == null)
|
|
{
|
|
return false;
|
|
}
|
|
return (shipFaction.equals(targetFaction));
|
|
}
|
|
public static obj_id[] getGroupShips(obj_id group, obj_id primaryTarget) throws InterruptedException
|
|
{
|
|
obj_id[] groupMembers = getGroupMemberIds(group);
|
|
Vector groupShips = new Vector();
|
|
groupShips.add(primaryTarget);
|
|
obj_id ship;
|
|
for (obj_id groupMember : groupMembers) {
|
|
if (groupMember.isLoaded()) {
|
|
ship = getPilotedShip(groupMember);
|
|
if (isIdValid(ship) && ship != primaryTarget && getDistance(ship, primaryTarget) < 120.0f) {
|
|
groupShips.add(ship);
|
|
}
|
|
}
|
|
}
|
|
obj_id[] returnArray = new obj_id[groupShips.size()];
|
|
groupShips.toArray(returnArray);
|
|
return returnArray;
|
|
}
|
|
public static String unitGetBehaviorString(int behavior) throws InterruptedException
|
|
{
|
|
String result;
|
|
switch (behavior)
|
|
{
|
|
case BEHAVIOR_IDLE:
|
|
result = "BEHAVIOR_IDLE";
|
|
break;
|
|
case BEHAVIOR_MOVETO:
|
|
result = "BEHAVIOR_MOVETO";
|
|
break;
|
|
case BEHAVIOR_PATROL:
|
|
result = "BEHAVIOR_PATROL";
|
|
break;
|
|
case BEHAVIOR_FOLLOW:
|
|
result = "BEHAVIOR_FOLLOW";
|
|
break;
|
|
case BEHAVIOR_TRACK:
|
|
result = "BEHAVIOR_TRACK";
|
|
break;
|
|
default:
|
|
result = "invalid";
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
public static String unitGetAttackOrdersString(int attackOrders) throws InterruptedException
|
|
{
|
|
String result;
|
|
switch (attackOrders)
|
|
{
|
|
case ATTACK_ORDERS_HOLD_FIRE:
|
|
result = "ATTACK_ORDERS_HOLD_FIRE";
|
|
break;
|
|
case ATTACK_ORDERS_RETURN_FIRE:
|
|
result = "ATTACK_ORDERS_DEFEND";
|
|
break;
|
|
case ATTACK_ORDERS_ATTACK_FREELY:
|
|
result = "ATTACK_ORDERS_ATTACK_FREELY";
|
|
break;
|
|
default:
|
|
result = "invalid";
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
public static void spaceAttack(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
unitAddDamageTaken(ship, target, 100000.0f);
|
|
}
|
|
public static void spaceAttack(obj_id ship, obj_id[] targets) throws InterruptedException
|
|
{
|
|
for (obj_id target : targets) {
|
|
unitAddDamageTaken(ship, target, 100000.0f);
|
|
}
|
|
}
|
|
public static obj_id spaceGetPrimaryTarget(obj_id ship) throws InterruptedException
|
|
{
|
|
return unitGetPrimaryAttackTarget(ship);
|
|
}
|
|
public static boolean spaceIsInCombat(obj_id ship) throws InterruptedException
|
|
{
|
|
return unitIsAttacking(ship);
|
|
}
|
|
public static void spaceStopAttack(obj_id ship) throws InterruptedException
|
|
{
|
|
unitSetAttackOrders(ship, ATTACK_ORDERS_HOLD_FIRE);
|
|
}
|
|
public static void spaceStopAttack(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
unitRemoveAttackTarget(ship, target);
|
|
}
|
|
public static void spaceGuard(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
debugServerConsoleMsg(ship, "Guarding is not supported ATM");
|
|
}
|
|
public static void spaceGuard(obj_id ship, obj_id[] targets) throws InterruptedException
|
|
{
|
|
debugServerConsoleMsg(ship, "Guarding is not supported ATM");
|
|
}
|
|
public static Vector spaceGetGuardList(obj_id ship) throws InterruptedException
|
|
{
|
|
debugServerConsoleMsg(ship, "Guarding is not supported ATM");
|
|
return null;
|
|
}
|
|
public static boolean spaceIsGuarding(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
debugServerConsoleMsg(ship, "Guarding is not supported ATM");
|
|
return false;
|
|
}
|
|
public static void spaceStopGuarding(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
debugServerConsoleMsg(ship, "Guarding is not supported ATM");
|
|
}
|
|
public static void spaceMoveTo(obj_id ship, transform position) throws InterruptedException
|
|
{
|
|
unitMoveTo(ship, position);
|
|
}
|
|
public static void spaceMoveTo(obj_id ship, transform[] path) throws InterruptedException
|
|
{
|
|
unitMoveTo(ship, path);
|
|
}
|
|
public static void spacePatrol(obj_id ship, transform[] transforms) throws InterruptedException
|
|
{
|
|
unitAddPatrolPath(ship, transforms);
|
|
}
|
|
public static void spaceStop(obj_id ship) throws InterruptedException
|
|
{
|
|
unitIdle(ship);
|
|
}
|
|
public static void spaceLoiter(obj_id ship, transform transform_w, float minDist, float maxDist) throws InterruptedException
|
|
{
|
|
unitLoiter(ship, transform_w, minDist, maxDist);
|
|
}
|
|
public static void spaceFollow(obj_id ship, obj_id target, float dist) throws InterruptedException
|
|
{
|
|
unitFollow(ship, target, new vector(0.0f, 0.0f, 1.0f), dist);
|
|
}
|
|
public static void spaceFollow(obj_id ship, obj_id target) throws InterruptedException
|
|
{
|
|
spaceFollow(ship, target, DEFAULT_FOLLOW_DISTANCE);
|
|
}
|
|
public static void spaceFollowInFormation(obj_id ship, obj_id target, int formationType) throws InterruptedException
|
|
{
|
|
spaceFollow(ship, target, DEFAULT_FOLLOW_DISTANCE);
|
|
}
|
|
public static int spaceGetShipBehavior(obj_id ship) throws InterruptedException
|
|
{
|
|
return unitGetBehavior(ship);
|
|
}
|
|
public static obj_id[] getWhoIsTargetingShip(obj_id ship) throws InterruptedException
|
|
{
|
|
return unitGetWhoIsTargetingMe(ship);
|
|
}
|
|
}
|