#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include "merc.h"
#include "olc.h"
#include "clans.h"
#include "space.h"
#include "interp.h"
#define flabs(i) ((i) < 0 ? -(i) : (i))
SHIP_DATA *first_ship;
SHIP_DATA *last_ship;
MISSILE_DATA *first_missile;
MISSILE_DATA *last_missile;
SPACE_DATA *first_starsystem;
SPACE_DATA *last_starsystem;
PLANET_DATA *first_planet;
PLANET_DATA *last_planet;
// local functions
void fread_ship args( (SHIP_DATA *ship, FILE *fp) );
void fread_planet args( (PLANET_DATA *planet, FILE *fp) );
void write_ship_list args( (void) );
void fread_starsystem args( (SPACE_DATA *starsystem, FILE *fp) );
void write_starsystem_list args( (void) );
void save_ship args( (SHIP_DATA *ship) );
void reset_ship args( (SHIP_DATA *ship) );
void land_ship args( (SHIP_DATA *ship, char *arg) );
void launch_ship args( (SHIP_DATA *ship) );
void damage_ship args( (CHAR_DATA *ch, SHIP_DATA *ship, int min, int max) );
void destroy_ship args( (SHIP_DATA *ship, CHAR_DATA *ch) );
void new_missile args( (SHIP_DATA *ship, SHIP_DATA *target, CHAR_DATA *ch) );
void create_ship_rooms args( (SHIP_DATA *ship) );
void ship_to_starsystem args( (SHIP_DATA *ship, SPACE_DATA *starsystem) );
void ship_from_starsystem args( (SHIP_DATA *ship, SPACE_DATA *starsystem) );
void echo_to_room args( (ROOM_INDEX_DATA *room, char *argument) );
/*
void sound_to_ship args( (SHIP_DATA *ship, char *argument) );
*/
bool load_ship_file args( (char *shipfile) );
bool load_starsystem args( (char *starsystemfile) );
bool load_planet_file args( (char *planetfile) );
bool autofly args( (SHIP_DATA *ship) );
bool is_facing args( (SHIP_DATA *ship, SHIP_DATA *target) );
int extract_missile args( (MISSILE_DATA *missile) );
SPACE_DATA *starsystem_from_name(char *name);
SHIP_DATA *get_ship_here(char *name, SPACE_DATA *starsystem);
void move_ships(void) {
CHAR_DATA *ch;
PLANET_DATA *planet;
bool ch_found = FALSE;
float dx, dy, dz, change;
char buf[MAX_STRING_LENGTH];
MISSILE_DATA *missile, *m_next;
SHIP_DATA *ship, *nextship, *target;
for (missile = first_missile; missile; missile = m_next) {
m_next = missile->next;
ship = missile->fired_from;
target = missile->target;
if (target && target->starsystem &&
target->starsystem == missile->starsystem) {
if (missile->mx < target->vx)
missile->mx += UMIN(missile->speed/5, target->vx - missile->mx);
else if (missile->mx > target->vx)
missile->mx -= UMIN(missile->speed/5, missile->mx - target->vx);
if (missile->my < target->vy)
missile->my += UMIN(missile->speed/5, target->vy - missile->my);
else if (missile->my > target->vy)
missile->my -= UMIN(missile->speed/5, missile->my - target->vy);
if (missile->mz < target->vz)
missile->mz += UMIN(missile->speed/5, target->vz - missile->mz);
else if (missile->mz > target->vz)
missile->mz -= UMIN(missile->speed/5, missile->mz - target->vz);
if (flabs(missile->mx) - flabs(target->vx) <= 20 &&
flabs(missile->mx) - flabs(target->vx) >= -20
&& flabs(missile->my) - flabs(target->vy) <= 20 &&
flabs(missile->my) - flabs(target->vy) >= -20
&& flabs(missile->mz) - flabs(target->vz) <= 20 &&
flabs(missile->mz) - flabs(target->vz) >= -20) {
if (target->chaff_released <= 0) {
echo_to_ship(TO_GUNSEAT, ship, "`YYour missile hits its target dead on!`n");
echo_to_ship(TO_COCKPIT, target, "`RThe ship is hit by a missile.`n");
echo_to_ship(TO_SHIP, target, "`RA loud explosion shake the ship violently!`n");
echo_to_system(target, ship, "`yYou see a small explosion as %s is hit by a missile.`n", target->name);
for (ch = char_list; ch != NULL; ch = ch->next) {
if (!IS_NPC(ch) && strstr(missile->fired_by,ch->name))
damage_ship(ch, target, 30, 50);
else
damage_ship(NULL, target, 30, 50);
extract_missile(missile);
}
} else {
echo_to_ship(TO_GUNSEAT, ship, "`YYour missile explodes harmlessly in a cloud of chaff!`n");
echo_to_ship(TO_COCKPIT, target, "`YA missile explodes in your chaff.`n");
extract_missile(missile);
}
continue;
} else {
missile->age++;
if (missile->age >= 50) {
extract_missile(missile);
continue;
}
}
} else {
extract_missile(missile);
continue;
}
}
for (ship = first_ship; ship; ship = nextship) {
nextship = ship->next;
if (!ship->starsystem)
continue;
if (ship->currspeed > 0) {
change = sqrt(ship->hx * ship->hx + ship->hy * ship->hy + ship->hz * ship->hz);
if (change > 0) {
dx = ship->hx / change;
dy = ship->hy / change;
dz = ship->hz / change;
ship->vx += (dx * ship->currspeed / 5);
ship->vy += (dy * ship->currspeed / 5);
ship->vz += (dz * ship->currspeed / 5);
}
}
if (autofly(ship))
continue;
if (ship->starsystem->star1 && strcmp(ship->starsystem->star1,"") &&
flabs(ship->vx - ship->starsystem->s1x) < 10 &&
flabs(ship->vy - ship->starsystem->s1y) < 10 &&
flabs(ship->vz - ship->starsystem->s1z) < 10) {
echo_to_ship(TO_COCKPIT, ship, "`R`fYou fly directly into the sun.`n");
echo_to_system(ship, NULL, "`y%s flies directly into %s!`n", ship->name, ship->starsystem->star1);
destroy_ship(ship, NULL);
continue;
}
if (ship->starsystem->star2 && strcmp(ship->starsystem->star2,"") &&
flabs(ship->vx - ship->starsystem->s2x) < 10 &&
flabs(ship->vy - ship->starsystem->s2y) < 10 &&
flabs(ship->vz - ship->starsystem->s2z) < 10) {
echo_to_ship(TO_COCKPIT, ship, "`r`fYou fly directly into the sun.`n");
echo_to_system(ship, NULL, "`y%s flies directly into %s!`n", ship->name, ship->starsystem->star2);
destroy_ship(ship, NULL);
continue;
}
if (ship->currspeed > 0) {
for (planet = ship->starsystem->first_planet; planet; planet = planet->next_in_system) {
if (flabs(ship->vx - planet->x) < 10 &&
flabs(ship->vy - planet->y) < 10 &&
flabs(ship->vz - planet->z) < 10) {
echo_to_ship(TO_COCKPIT, ship, "`YYou begin orbiting %s.`n", planet->name);
echo_to_system(ship, NULL, "`y%s begins orbiting %s.`n", ship->name, planet->name);
ship->currspeed = 0;
continue;
}
}
}
}
for (ship = first_ship; ship; ship = nextship) {
nextship = ship->next;
if (ship->collision) {
echo_to_ship(TO_COCKPIT, ship, "`W`fYou have collided with another ship!`n");
echo_to_ship(TO_SHIP, ship, "`RA loud explosion shakes the ship violently!`n");
damage_ship(NULL, ship, ship->collision, ship->collision);
ship->collision = 0;
}
}
}
void recharge_ships(void) {
TURRET_DATA *turret;
SHIP_DATA *ship, *nextship;
char buf[MAX_STRING_LENGTH];
for (ship = first_ship; ship; ship = nextship) {
nextship = ship->next;
for (turret = ship->first_turret; turret; turret = turret->next) {
if (turret->laserstate > 0) {
ship->energy -= turret->laserstate;
turret->laserstate = 0;
}
if (ship->laserstate > 0) {
ship->energy -= ship->laserstate;
ship->laserstate = 0;
}
if (ship->missilestate == MISSILE_RELOAD_2) {
ship->missilestate = MISSILE_READY;
if (ship->missiles > 0)
echo_to_ship(TO_GUNSEAT, ship, "`YMissile launcher reloaded.`n");
}
if (ship->missilestate == MISSILE_RELOAD)
ship->missilestate = MISSILE_RELOAD_2;
if (ship->missilestate == MISSILE_FIRED)
ship->missilestate = MISSILE_RELOAD;
if (autofly(ship)) {
if (ship->starsystem) {
if (ship->target && ship->laserstate != LASER_DAMAGED) {
int shots;
float chance = 100;
SHIP_DATA *target = ship->target;
for (shots = 0; shots <= ship->lasers; shots++) {
if (!ship->target)
break;
if (ship->shipstate != SHIP_HYPERSPACE && ship->energy > 25
&& ship->target->starsystem == ship->starsystem
&& flabs(target->vx - ship->vx) <= 1000
&& flabs(target->vy - ship->vy) <= 1000
&& flabs(target->vz - ship->vz) <= 1000
&& ship->laserstate < ship->lasers) {
if (ship->shipclass == SPACE_STATION || is_facing(ship, target)) {
chance += target->model*10;
chance -= target->manuever/10;
chance -= target->currspeed/20;
chance -= (flabs(target->vx - ship->vx) / 70);
chance -= (flabs(target->vy - ship->vy) / 70);
chance -= (flabs(target->vz - ship->vz) / 70);
chance = URANGE(10, chance, 90);
if (number_percent() > chance) {
echo_to_ship(TO_COCKPIT, target, "`y%s fires at you but misses.`n", ship->name);
echo_to_system(target, NULL, "`yLaserfire from %s barely misses %s.`n", ship->name, target->name);
} else {
echo_to_system(ship, NULL, "`yLaserfire from %s hits %s.`n", ship->name, target->name);
echo_to_ship(TO_COCKPIT, target, "`rYou are hit by lasers from %s!`n", ship->name);
echo_to_ship(TO_SHIP, target, "`RA small explosion vibrates through the ship.`n");
if (autofly(target))
target->target = ship;
damage_ship(NULL, target, 5, 10);
}
ship->laserstate++;
}
}
}
}
}
}
}
}
}
void space_update(void) {
SHIP_DATA *target;
SHIP_DATA *ship, *nextship;
char buf[MAX_STRING_LENGTH];
SInt32 recharge, too_close, target_too_close;
for (ship = first_ship; ship; ship = nextship) {
nextship = ship->next;
if (ship->starsystem) {
if (ship->energy > 0 && ship->shipstate == SHIP_DISABLED && ship->shipclass != SPACE_STATION)
ship->energy -= 100;
else
ship->energy += 5 + ship->model * 2;
}
if (ship->chaff_released > 0)
ship->chaff_released = FALSE;
if (ship->shipstate == SHIP_HYPERSPACE) {
ship->hyperdistance -= ship->hyperspeed * 2;
if (ship->hyperdistance <= 0) {
ship_to_starsystem(ship, ship->currjump);
if (ship->starsystem == NULL)
echo_to_ship(TO_COCKPIT, ship, "`RShip lost in hyperspace. Make new calculations.`n");
else {
echo_to_ship(TO_PILOTSEAT, ship, "`YHyperjump complete.`n");
echo_to_ship(TO_SHIP, ship, "`YThe ship lurches slightly as it comes out of hyperspace.`n");
echo_to_system(ship, NULL, "`Y%s enters the starsystem at %.0f %.0f %.0f`n", ship->name, ship->vx, ship->vy, ship->vz);
ship->shipstate = SHIP_READY;
free_string(ship->home);
ship->home = str_dup(ship->starsystem->name);
}
} else
echo_to_ship(TO_PILOTSEAT, ship, "`YRemaining jump distance: `W%d`n", ship->hyperdistance);
}
if (ship->shipstate == SHIP_BUSY_3) {
echo_to_ship(TO_PILOTSEAT, ship, "`YManuever complete.`n");
ship->shipstate = SHIP_READY;
}
if (ship->shipstate == SHIP_BUSY_2)
ship->shipstate = SHIP_BUSY_3;
if (ship->shipstate == SHIP_BUSY)
ship->shipstate = SHIP_BUSY_2;
if (ship->shipstate == SHIP_LAND_2)
land_ship(ship, ship->dest);
if (ship->shipstate == SHIP_LAND)
ship->shipstate = SHIP_LAND_2;
if (ship->shipstate == SHIP_LAUNCH_2)
launch_ship(ship);
if (ship->shipstate == SHIP_LAUNCH)
ship->shipstate = SHIP_LAUNCH_2;
ship->shield = UMAX(0, ship->shield - 1 - ship->model / 5);
if (ship->autorecharge && ship->maxshield > ship->shield && ship->energy > 100) {
recharge = UMIN(ship->maxshield - ship->shield, 10 + ship->model * 2);
recharge = UMIN(recharge, ship->energy - 100);
recharge = UMAX(1, recharge);
ship->shield += recharge;
ship->energy -= recharge;
}
if (ship->shield > 0) {
if (ship->energy > 200) {
ship->shield = 0;
echo_to_ship(TO_COCKPIT, ship, "`RThe ships shields fizzle and die.`n");
ship->autorecharge = FALSE;
}
}
if (ship->starsystem && ship->currspeed > 0)
echo_to_ship(TO_PILOTSEAT, ship, "`BSpeed: `C%d `BCoords: `C%.0f %.0f %.0f`n", ship->currspeed, ship->vx, ship->vy, ship->vz);
if (ship->starsystem) {
too_close = ship->currspeed + 50;
for (target = ship->starsystem->first_ship; target; target = target->next_in_starsystem) {
target_too_close = too_close + target->currspeed;
if (target != ship &&
flabs(ship->vx - target->vx) < target_too_close &&
flabs(ship->vy - target->vy) < target_too_close &&
flabs(ship->vz - target->vz) < target_too_close)
echo_to_ship(TO_PILOTSEAT, ship, "`RProximity alert: %s %.0f %.0f %.0f`n", target->name, target->vx, target->vy, target->vz);
}
too_close = ship->currspeed + 100;
if (ship->starsystem->star1 && strcmp(ship->starsystem->star1, "") &&
flabs(ship->vx - ship->starsystem->s1x) < too_close &&
flabs(ship->vy - ship->starsystem->s1y) < too_close &&
flabs(ship->vz - ship->starsystem->s1z) < too_close)
echo_to_ship(TO_PILOTSEAT, ship, "`RProximity alert: %s %.0f %.0f %.0f`n", ship->starsystem->star1, ship->starsystem->s1x, ship->starsystem->s1y, ship->starsystem->s1z);
if (ship->target) {
echo_to_ship(TO_PILOTSEAT, ship, "`BTarget: `C%s %.0f %.0f %.0f`n", ship->target->name, ship->target->vx, ship->target->vy, ship->target->vz);
if (ship->starsystem != ship->target->starsystem)
ship->target = NULL;
}
if (ship->energy < 100 && ship->starsystem)
echo_to_ship(TO_COCKPIT, ship, "`RWarning: Ship fuel low.`n");
ship->energy = URANGE(0, ship->energy, ship->maxenergy);
}
}
for (ship = first_ship; ship; ship = ship->next) {
if (ship->autotrack && ship->target && ship->shipclass < SPACE_STATION) {
target = ship->target;
too_close = ship->currspeed + 10;
target_too_close = too_close + target->currspeed;
if (target != ship && ship->shipstate == SHIP_READY &&
flabs(ship->vx - target->vx) < target_too_close &&
flabs(ship->vy - target->vy) < target_too_close &&
flabs(ship->vz - target->vz) < target_too_close) {
ship->hx = 0 - (ship->target->vx - ship->vx);
ship->vy = 0 - (ship->target->vy - ship->vy);
ship->vz = 0 - (ship->target->vz - ship->vz);
ship->energy -= ship->currspeed / 10;
echo_to_ship(TO_PILOTSEAT, ship, "`RAutotrack: Evading to avoid collision!`n");
if (ship->manuever > 100)
ship->shipstate = SHIP_BUSY_3;
else if (ship->manuever > 50)
ship->shipstate = SHIP_BUSY_2;
else
ship->shipstate = SHIP_BUSY;
} else if (!is_facing(ship, ship->target)) {
ship->hx = ship->target->vx - ship->vx;
ship->hy = ship->target->vy - ship->vy;
ship->hz = ship->target->vz - ship->vz;
echo_to_ship(TO_PILOTSEAT, ship, "`BAutotracking target ... setting new course.`n");
if (ship->manuever > 100)
ship->shipstate = SHIP_BUSY_3;
else if (ship->manuever > 50)
ship->shipstate = SHIP_BUSY_2;
else
ship->shipstate = SHIP_BUSY;
}
}
if (autofly(ship)) {
if (ship->starsystem) {
if (ship->target) {
float chance = 100;
target = ship->target;
ship->autotrack = TRUE;
if (ship->shipclass != SPACE_STATION)
ship->currspeed = ship->realspeed;
if (ship->energy > 200)
ship->autorecharge = TRUE;
if (ship->shipstate != SHIP_HYPERSPACE && ship->energy > 200
&& ship->hyperspeed > 0 && ship->target->starsystem == ship->starsystem
&& (flabs(target->vx - ship->vx) > 5000
|| flabs(target->vy - ship->vy) > 5000
|| flabs(target->vz - ship->vz) > 5000)
&& number_bits(2) == 0) {
ship->currjump = ship->starsystem;
ship->hyperdistance = 1;
echo_to_system(ship, NULL, "`Y%s disappears from your scanner.`n", ship->name);
ship_from_starsystem(ship, ship->starsystem);
ship->shipstate = SHIP_HYPERSPACE;
ship->energy -= 100;
ship->jx = target->vx;
ship->jy = target->vy;
ship->jz = target->vz;
}
if (ship->shipstate != SHIP_HYPERSPACE && ship->energy > 25
&& ship->missilestate == MISSILE_READY
&& ship->target->starsystem == ship->starsystem
&& flabs(target->vx - ship->vx) <= 1200
&& flabs(target->vy - ship->vy) <= 1200
&& flabs(target->vz - ship->vz) <= 1200
&& ship->missiles > 0) {
if (ship->shipclass == SPACE_STATION || is_facing(ship, target)) {
chance -= target->manuever / 5;
chance -= target->currspeed / 20;
chance += target->model * target->model * 2;
chance -= (flabs(target->vx - ship->vx) / 100);
chance -= (flabs(target->vy - ship->vy) / 100);
chance -= (flabs(target->vz - ship->vz) / 100);
chance += 30;
chance = URANGE(10 , chance, 90);
if (number_percent() < chance) {
new_missile(ship, target, NULL);
ship->missiles--;
echo_to_ship(TO_COCKPIT, target, "`rIncoming missile from %s.`n", ship->name);
echo_to_system(target, NULL, "`y%s fires a missile towards %s.`n", ship->name, target->name);
if (ship->shipclass == SPACE_STATION)
ship->missilestate = MISSILE_RELOAD_2;
else
ship->missilestate = MISSILE_RELOAD;
}
}
}
if (ship->missilestate == MISSILE_DAMAGED)
ship->missilestate = MISSILE_READY;
if (ship->laserstate == LASER_DAMAGED)
ship->laserstate = LASER_READY;
if (ship->shipstate == SHIP_DISABLED)
ship->shipstate = SHIP_READY;
} else {
int targetok;
CHAR_DATA *passenger = NULL;
ROOM_INDEX_DATA *room = NULL;
ship->currspeed = 0;
// nya nya
}
} else if ((ship->shipclass == SPACE_STATION || ship->type == MOB_SHIP) && ship->home) {
if (number_range(1, 25) == 25) {
ship_to_starsystem(ship, starsystem_from_name(ship->home));
ship->vx = number_range(-5000, 5000);
ship->vy = number_range(-5000, 5000);
ship->vz = number_range(-5000, 5000);
ship->hx = ship->hy = ship->hz = 1;
ship->autopilot = TRUE;
}
}
}
if (ship->shipclass == SPACE_STATION && ship->target == NULL) {
if (ship->missiles < ship->maxmissiles)
ship->missiles++;
}
}
}
void echo_to_ship(Flags type, SHIP_DATA *ship, char *argument, ...) {
va_list args;
char send_buf[MAX_STRING_LENGTH];
if (!argument || !*argument)
return;
va_start(args, argument);
vsprintf(send_buf, argument, args);
va_end(args);
if (IS_SET(type, TO_SHIP)) {
ROOM_INDEX_DATA *room;
for (room = ship->first_room; room; room = room->next_in_ship)
echo_to_room(room, send_buf);
}
if (IS_SET(type, TO_PILOTSEAT))
echo_to_room(ship->pilotseat, send_buf);
if (IS_SET(type, TO_COCKPIT)) {
TURRET_DATA *turret;
echo_to_room(ship->pilotseat, send_buf);
if (ship->pilotseat != ship->gunseat)
echo_to_room(ship->gunseat, send_buf);
if (ship->pilotseat != ship->viewscreen && ship->viewscreen != ship->gunseat)
echo_to_room(ship->viewscreen, send_buf);
for (turret = ship->first_turret; turret; turret = turret->next)
if (turret->room)
echo_to_room(turret->room, send_buf);
}
}
void echo_to_system(SHIP_DATA *ship, SHIP_DATA *ignore, char *argument, ...) {
va_list args;
SHIP_DATA *target;
char send_buf[MAX_STRING_LENGTH];
if (!ship->starsystem || !argument || !*argument)
return;
va_start(args, argument);
vsprintf(send_buf, argument, args);
va_end(args);
for (target = ship->starsystem->first_ship; target; target = target->next_in_starsystem) {
if (target != ship && target != ignore)
echo_to_ship(TO_COCKPIT, target, send_buf);
}
return;
}
void echo_to_room(ROOM_INDEX_DATA *room, char *argument) {
CHAR_DATA *to;
if (room == NULL)
return;
for (to = room->people; to; to = to->next_in_room)
to->Send("%s\n\r", argument);
return;
}
bool is_facing(SHIP_DATA *ship, SHIP_DATA *target) {
float dx, dy, dz, hx, hy, hz, cosofa;
hx = ship->hx;
hy = ship->hy;
hz = ship->hz;
dx = target->vx - ship->vx;
dy = target->vy - ship->vy;
dz = target->vz - ship->vz;
cosofa = (hx*dx + hy*dy + hz*dz) /
(sqrt(hx*hx + hy*hy + hz*hz) + sqrt(dx*dx + dy*dy + dz*dz));
if (cosofa > 0.75)
return TRUE;
return FALSE;
}
bool autofly(SHIP_DATA *ship) {
if (!ship)
return FALSE;
if (ship->type == MOB_SHIP)
return TRUE;
return ship->autopilot;
}
bool check_pilot(CHAR_DATA *ch, SHIP_DATA *ship) {
if (NO_STAFF_HASSLE(ch))
return TRUE;
if (!str_cmp(ch->name, ship->owner))
return TRUE;
return FALSE;
}
bool extract_ship(SHIP_DATA *ship) {
ROOM_INDEX_DATA *room;
if ((room = ship->in_room) != NULL) {
UNLINK(ship, room->first_ship, room->last_ship, next_in_room, prev_in_room);
ship->in_room = NULL;
}
return TRUE;
}
bool ship_to_room(SHIP_DATA *ship, UInt32 vnum) {
ROOM_INDEX_DATA *shipto;
if ((shipto = get_room_index(vnum)) == NULL)
return FALSE;
LINK(ship, shipto->first_ship, shipto->last_ship, next_in_room, prev_in_room);
ship->in_room = shipto;
return TRUE;
}
SPACE_DATA *starsystem_from_name(char *name) {
SPACE_DATA *starsystem;
for (starsystem = first_starsystem; starsystem; starsystem = starsystem->next)
if (!str_cmp(name, starsystem->name))
return starsystem;
for (starsystem = first_starsystem; starsystem; starsystem = starsystem->next)
if (!str_prefix(name, starsystem->name))
return starsystem;
return NULL;
}
SHIP_DATA *ship_from_room(ROOM_INDEX_DATA *room) {
SHIP_DATA *ship;
ROOM_INDEX_DATA *sRoom;
if (room == NULL)
return NULL;
for (ship = first_ship; ship; ship = ship->next)
for (sRoom = ship->first_room; sRoom; sRoom = sRoom->next_in_ship)
if (room == sRoom)
return ship;
return NULL;
}
SHIP_DATA *ship_from_cockpit(ROOM_INDEX_DATA *room) {
SHIP_DATA *ship;
TURRET_DATA *turret;
if (room == NULL)
return NULL;
for (ship = first_ship; ship; ship = ship->next) {
if (room == ship->pilotseat)
return ship;
if (room == ship->gunseat)
return ship;
if (room == ship->viewscreen)
return ship;
for (turret = ship->first_turret; turret; turret = turret->next)
if (room == turret->room)
return ship;
}
return NULL;
}
SHIP_DATA *ship_from_pilotseat(ROOM_INDEX_DATA *room) {
SHIP_DATA *ship;
if (room == NULL)
return NULL;
for (ship = first_ship; ship; ship = ship->next)
if (room == ship->pilotseat)
return ship;
return NULL;
}
SPACE_DATA *starsystem_from_room(ROOM_INDEX_DATA *room) {
SHIP_DATA *ship;
ROOM_INDEX_DATA *sRoom;
if (room == NULL)
return NULL;
if (room->area != NULL && room->area->planet != NULL)
return room->area->planet->starsystem;
for (ship = first_ship; ship; ship = ship->next) {
for (sRoom = ship->first_room; sRoom; sRoom = sRoom->next_in_ship)
if (room == sRoom)
return ship->starsystem;
}
return NULL;
}
void land_ship(SHIP_DATA *ship, char *argument) {
SHIP_DATA *target;
PLANET_DATA *planet;
RNum vnum, dest = 0;
ROOM_INDEX_DATA *room;
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH], arg1[MAX_INPUT_LENGTH];
strcpy(arg, argument);
argument = one_argument(argument, arg1);
for (planet = ship->starsystem->first_planet; planet; planet = planet->next_in_system) {
if (!str_prefix(arg1, planet->name)) {
if (!planet->area)
continue;
for (vnum = planet->area->min_vnum; vnum <= planet->area->max_vnum; vnum++) {
if ((room = get_room_index(vnum)) != NULL && ROOM_FLAGGED(room, ROOM_CAN_LAND) && !str_prefix(argument, room->name)) {
dest = room->vnum;
break;
}
}
break;
}
}
if (!dest) {
target = get_ship_here(arg, ship->starsystem);
if (target != ship && target != NULL)
dest = 0;
dest = 0; // disabled landing on ships
}
if (!ship_to_room(ship, dest)) {
echo_to_room(ship->pilotseat, "`YCould not complete aproach. Landing aborted.`n");
echo_to_ship(TO_SHIP, ship, "`YThe ship pulls back up out of its landing sequence.`n");
if (ship->shipstate != SHIP_DISABLED)
ship->shipstate = SHIP_READY;
return;
}
echo_to_room(ship->pilotseat, "`YLanding sequence complete.`n");
echo_to_ship(TO_SHIP, ship, "`YYou feel a slight thud as the ship sets down on the ground.`n");
echo_to_system(ship, NULL, "`Y%s enters the atmosphere of %s.`n", ship->name, planet->name);
ship->location = dest;
ship->lastdoc = ship->location;
if (ship->shipstate != SHIP_DISABLED)
ship->shipstate = SHIP_DOCKED;
ship_from_starsystem(ship, ship->starsystem);
sprintf(buf, "`Y%s lands on the platform.`n", ship->name);
echo_to_room(get_room_index(ship->location), buf);
ship->energy = ship->energy - 25 - 5 * ship->model;
save_ship(ship);
}
void launch_ship(SHIP_DATA *ship) {
SHIP_DATA *source;
ROOM_INDEX_DATA *room;
char buf[MAX_STRING_LENGTH];
ship_to_starsystem(ship, starsystem_from_room(ship->in_room));
if (ship->starsystem == NULL) {
echo_to_ship(TO_PILOTSEAT, ship, "`YLaunch path unavailable.. Launch aborted.`n");
echo_to_ship(TO_SHIP, ship, "`YThe ship slowly sets back back down on the landing pad.`n");
ship->shipstate = SHIP_DOCKED;
return;
}
source = ship_from_room(ship->in_room);
extract_ship(ship);
ship->location = 0;
if (ship->shipstate != SHIP_DISABLED)
ship->shipstate = SHIP_READY;
ship->hx = number_range(-1, 1);
ship->hy = number_range(-1, 1);
ship->hz = number_range(-1, 1);
if ((room = get_room_index(ship->lastdoc)) != NULL
&& room->area && room->area->planet && room->area->planet->starsystem
&& room->area->planet->starsystem == ship->starsystem) {
ship->vx = room->area->planet->x;
ship->vy = room->area->planet->y;
ship->vz = room->area->planet->z;
} else if (source) {
ship->vx = source->vx;
ship->vy = source->vy;
ship->vz = source->vz;
}
ship->energy -= (100 + 10 * ship->model);
ship->vx += (ship->hx * ship->currspeed * 2);
ship->vy += (ship->hy * ship->currspeed * 2);
ship->vz += (ship->hz * ship->currspeed * 2);
echo_to_room(get_room_index(ship->location), "`GLaunch complete.`n");
echo_to_ship(TO_SHIP, ship, "`YThe ship leaves the platform far behind as it flies into space.`n");
echo_to_system(ship, NULL, "`Y%s enters the starsystem at %.0f %.0f %.0f`n", ship->name, ship->vx, ship->vy, ship->vz);
sprintf(buf, "`Y%s lifts off into space.`n", ship->name);
echo_to_room(get_room_index(ship->lastdoc), buf);
}
void damage_ship(CHAR_DATA *ch, SHIP_DATA *ship, int min, int max) {
}
void destroy_ship(SHIP_DATA *ship, CHAR_DATA *ch) {
}
void new_missile(SHIP_DATA *ship, SHIP_DATA *target, CHAR_DATA *ch) {
MISSILE_DATA *missile;
SPACE_DATA *starsystem;
if (ship == NULL || target == NULL)
return;
if ((starsystem = ship->starsystem) == NULL)
return;
missile = (MISSILE_DATA *)alloc_mem(sizeof(MISSILE_DATA));
LINK(missile, first_missile, last_missile, next, prev);
missile->age = 0;
missile->speed = 200;
missile->target = target;
missile->fired_from = ship;
missile->fired_by = str_dup(ch ? ch->name : "");
missile->mx = ship->vx;
missile->my = ship->vy;
missile->mz = ship->vz;
if (starsystem->first_missile == NULL)
starsystem->first_missile = missile;
if (starsystem->last_missile) {
starsystem->last_missile->next_in_starsystem = missile;
missile->prev_in_starsystem = starsystem->last_missile;
}
starsystem->last_missile = missile;
missile->starsystem = starsystem;
}
void ship_to_starsystem(SHIP_DATA *ship, SPACE_DATA *starsystem) {
if (ship == NULL || starsystem == NULL)
return;
LINK(ship, starsystem->first_ship, starsystem->last_ship, next_in_starsystem, prev_in_starsystem);
ship->starsystem = starsystem;
}
void ship_from_starsystem(SHIP_DATA *ship, SPACE_DATA *starsystem) {
if (ship == NULL || starsystem == NULL)
return;
UNLINK(ship, starsystem->first_ship, starsystem->last_ship, next_in_starsystem, prev_in_starsystem);
ship->starsystem = NULL;
}
SHIP_DATA *get_ship_here(char *name, SPACE_DATA *starsystem) {
SHIP_DATA *ship;
if (starsystem == NULL)
return NULL;
for (ship = starsystem->first_ship; ship; ship = ship->next_in_starsystem)
if (is_name(name, ship->name))
return ship;
return NULL;
}
SHIP_DATA *ship_in_room(ROOM_INDEX_DATA *room, char *name) {
SHIP_DATA *ship;
if (room == NULL)
return NULL;
for (ship = room->first_ship; ship; ship = ship->next_in_room)
if (!str_cmp(name, ship->name) || !str_prefix(name, ship->name) || is_name(name, ship->name))
if (ship->owner && ship->owner[0] != '\0')
return ship;
return NULL;
}
SHIP_DATA *ship_from_entrance(ROOM_INDEX_DATA *room) {
SHIP_DATA *ship;
if (room == NULL)
return NULL;
for (ship = first_ship; ship; ship = ship->next)
if (room == ship->entrance)
return ship;
return NULL;
}
int extract_missile(MISSILE_DATA *missile) {
SPACE_DATA *starsystem;
return 0;
}
void write_starsystem_list(void) {
FILE *fp;
SPACE_DATA *system;
if (!(fp = fopen(SPACE_LIST, "w"))) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: Couldn't open %s for writing.", SPACE_LIST);
return;
}
for (system = first_starsystem; system; system = system->next)
fprintf(fp, "%s\n", system->filename);
fprintf(fp, "$\n");
fclose(fp);
}
void save_starsystem(SPACE_DATA *starsystem) {
FILE *fp;
char buf[MAX_STRING_LENGTH];
if (!starsystem) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: save_starsystem: null starsystem!");
return;
}
if (!starsystem->filename || !*starsystem->filename) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: save_starsystem: %s has no filename", starsystem->name);
return;
}
fclose(fpReserve);
if ((fp = fopen(STARSYSTEM_FILE, "w")) == NULL) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: save_starsystem: Couldn't open %s for writing.", STARSYSTEM_FILE);
return;
}
fprintf(fp, "#SPACE\n");
fprintf(fp, "Name %s~\n", starsystem->name);
fprintf(fp, "FName %s~\n", starsystem->filename);
fprintf(fp, "Star1 %s~\n", starsystem->star1);
fprintf(fp, "Star2 %s~\n", starsystem->star2);
fprintf(fp, "S1xyz %.0f %.0f %.0f\n",
starsystem->s1x, starsystem->s1y, starsystem->s1z);
fprintf(fp, "S2xyz %.0f %.0f %.0f\n",
starsystem->s2x, starsystem->s2y, starsystem->s2z);
fprintf(fp, "End\n");
fprintf(fp, "#END\n");
fclose(fp);
fpReserve = fopen(NULL_FILE, "r");
return;
}
#if defined(KEY)
#undef KEY
#endif
#define KEY(literal, field, value) \
if (!str_cmp(word, literal)) { \
field = value; \
fMatch = TRUE; \
break; \
}
#if defined(KEYS)
#undef KEYS
#endif
#define KEYS(literal, field, value) \
if (!str_cmp(word, literal)) { \
free_string(field); \
field = value; \
fMatch = TRUE; \
break; \
}
void fread_starsystem(SPACE_DATA *starsystem, FILE *fp) {
char *word;
bool fMatch;
char buf[MAX_STRING_LENGTH];
for (;;) {
word = feof(fp) ? (char *)"End" : fread_word(fp);
fMatch = FALSE;
switch(UPPER(*word)) {
case '*':
fMatch = TRUE;
fread_to_eol(fp);
break;
case 'E':
if (!str_cmp(word, "End")) {
if (!starsystem->name)
starsystem->name = str_dup("");
if (!starsystem->star1)
starsystem->star1 = str_dup("");
if (!starsystem->star2)
starsystem->star2 = str_dup("");
return;
}
break;
case 'F':
KEY("FName", starsystem->filename, fread_string(fp));
break;
case 'N':
KEY("Name", starsystem->name, fread_string(fp));
break;
case 'S':
KEY("Star1", starsystem->star1, fread_string(fp));
KEY("Star2", starsystem->star2, fread_string(fp));
if (!str_cmp(word, "S1xyz")) {
fMatch = TRUE;
starsystem->s1x = fread_number(fp);
starsystem->s1y = fread_number(fp);
starsystem->s1z = fread_number(fp);
break;
}
if (!str_cmp(word, "S2xyz")) {
fMatch = TRUE;
starsystem->s2x = fread_number(fp);
starsystem->s2y = fread_number(fp);
starsystem->s2z = fread_number(fp);
break;
}
break;
}
if (!fMatch)
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: fread_starsystem: no match: %s", word);
}
}
bool load_starsystem(char *systemfile) {
FILE *fp;
SPACE_DATA *starsystem;
char filename[MAX_INPUT_LENGTH];
starsystem = (SPACE_DATA *)alloc_perm(sizeof(SPACE_DATA));
starsystem->first_planet = NULL;
starsystem->last_planet = NULL;
starsystem->first_ship = NULL;
starsystem->last_ship = NULL;
starsystem->first_missile = NULL;
starsystem->last_missile = NULL;
sprintf(filename, "%s%s", SPACE_DIR, systemfile);
if ((fp = fopen(filename, "r")) == NULL) {
free_mem(starsystem, sizeof(starsystem));
return FALSE;
} else {
LINK(starsystem, first_starsystem, last_starsystem, next, prev);
for (;;) {
char *word, letter = fread_letter(fp);
if (letter == '*') {
fread_to_eol(fp);
continue;
}
if (letter != '#') {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: load_starsystem: # not found.");
break;
}
word = fread_word(fp);
if (!str_cmp(word, "SPACE")) {
fread_starsystem(starsystem, fp);
break;
} else if (!str_cmp(word, "END"))
break;
else {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: load_starsystem: bad section: %s.", word);
break;
}
}
fclose(fp);
return TRUE;
}
}
bool load_planet_file(char *planetfile) {
FILE *fp;
PLANET_DATA *planet;
char filename[MAX_INPUT_LENGTH];
planet = (PLANET_DATA *)alloc_perm(sizeof(*planet));
planet->governed_by = NULL;
planet->next_in_system = NULL;
planet->prev_in_system = NULL;
planet->starsystem = NULL;
planet->area = NULL;
sprintf(filename, "%s%s", PLANET_DIR, planetfile);
if ((fp = fopen(filename, "r")) == NULL) {
free_mem(planet, sizeof(planet));
return FALSE;
} else {
LINK(planet, first_planet, last_planet, next, prev);
for (;;) {
char *word, letter = fread_letter(fp);
if (letter == '*') {
fread_to_eol(fp);
continue;
}
if (letter != '#') {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: load_planet_file: # not found.");
break;
}
word = fread_word(fp);
if (!str_cmp(word, "PLANET")) {
fread_planet(planet, fp);
break;
} else if (!str_cmp(word, "END"))
break;
else {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: load_planet_file: bad section: %s", word);
break;
}
}
fclose(fp);
return TRUE;
}
}
void load_space(void) {
FILE *fp;
char *filename;
first_starsystem = NULL;
last_starsystem = NULL;
fclose(fpReserve);
if ((fp = fopen(SPACE_LIST, "r")) == NULL) {
perror(SPACE_LIST);
exit(1);
}
for (;;) {
filename = feof(fp) ? (char *)"$" : fread_word(fp);
if (*filename == '$')
break;
if (!load_starsystem(filename))
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: Cannot load starsystem file: %s", filename);
}
fclose(fp);
fpReserve = fopen(NULL_FILE, "r");
return;
}
void load_planets(void) {
FILE *fp;
char *filename;
first_planet = NULL;
last_planet = NULL;
fclose(fpReserve);
if ((fp = fopen(PLANET_LIST, "r")) == NULL) {
perror(PLANET_LIST);
exit(1);
}
for (;;) {
filename = feof(fp) ? (char *)"$" : fread_word(fp);
if (*filename == '$')
break;
if (!load_planet_file(filename))
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: Cannot load starsystem file: %s", filename);
}
fclose(fp);
fpReserve = fopen(NULL_FILE, "r");
return;
}
void write_ship_list(void) {
FILE *fp;
SHIP_DATA *ship;
if (!(fp = fopen(SHIP_LIST, "w"))) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: Could not open %s for writing.", SHIP_LIST);
return;
}
for (ship = first_ship; ship; ship = ship->next)
if (ship->type != MOB_SHIP && ship->owner && *ship->owner)
fprintf(fp, "%s\n", ship->filename);
fprintf(fp, "$\n");
fclose(fp);
}
void save_ship(SHIP_DATA *ship) {
FILE *fp;
ROOM_INDEX_DATA *room;
char filename[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH];
if (!ship) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: save_ship: null pointer");
return;
}
if (ship->type == MOB_SHIP)
return;
if (!ship->filename || !*ship->filename) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: save_ship: %s has no filename.", ship->name);
return;
}
sprintf(filename, "%s%s", SHIP_DIR, ship->filename);
fclose(fpReserve);
if ((fp = fopen(filename, "w")) == NULL) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: save_ship: Cannot open %s for writing.", filename);
perror(filename);
} else {
fprintf(fp, "#SHIP\n");
fprintf(fp, "Name %s~\n", ship->name);
fprintf(fp, "FName %s~\n", ship->filename);
for (room = ship->first_room; room; room = room->next_in_ship)
fprintf(fp, "Desc %s~\n", room->description);
fprintf(fp, "Owner %s~\n", ship->owner);
fprintf(fp, "Pilot %s~\n", ship->pilot);
fprintf(fp, "Copilot %s~\n", ship->copilot);
fprintf(fp, "Model %d\n", ship->model);
fprintf(fp, "Class %d\n", ship->shipclass);
fprintf(fp, "Shipyard %d\n", ship->shipyard);
fprintf(fp, "Lasers %d\n", ship->lasers);
fprintf(fp, "Laserstate %d\n", ship->laserstate);
fprintf(fp, "Missiles %d\n", ship->missiles);
fprintf(fp, "Maxmissiles %d\n", ship->maxmissiles);
fprintf(fp, "Lastdoc %d\n", ship->lastdoc);
fprintf(fp, "Shield %d\n", ship->shield);
fprintf(fp, "Maxshield %d\n", ship->maxshield);
fprintf(fp, "Hull %d\n", ship->hull);
fprintf(fp, "Maxhull %d\n", ship->maxhull);
fprintf(fp, "Maxenergy %d\n", ship->maxenergy);
fprintf(fp, "Hyperspeed %d\n", ship->hyperspeed);
fprintf(fp, "Chaff %d\n", ship->chaff);
fprintf(fp, "Maxchaff %d\n", ship->maxchaff);
fprintf(fp, "Realspeed %d\n", ship->realspeed);
fprintf(fp, "Type %d\n", ship->type);
fprintf(fp, "Shipstate %d\n", ship->shipstate);
fprintf(fp, "Missilestate %d\n", ship->missilestate);
fprintf(fp, "Energy %d\n", ship->energy);
fprintf(fp, "Manuever %d\n", ship->manuever);
fprintf(fp, "Home %s~\n", ship->home);
fprintf(fp, "End\n\n");
fprintf(fp, "#END\n");
}
fclose(fp);
fpReserve = fopen(NULL_FILE, "r");
return;
}
void fread_ship(SHIP_DATA *ship, FILE *fp) {
char *word;
bool fMatch;
SInt32 dIndex = 0;
for (;;) {
word = feof(fp) ? (char *)"End" : fread_word(fp);
fMatch = FALSE;
switch (UPPER(word[0])) {
case '*':
fMatch = TRUE;
fread_to_eol(fp);
break;
case 'C':
KEY("Class", ship->shipclass, fread_number(fp));
KEY("Chaff", ship->chaff, fread_number(fp));
KEYS("Copilot", ship->copilot, fread_string(fp));
break;
case 'D':
if (dIndex < MAX_SHIP_ROOMS)
KEYS("Desc", ship->description[dIndex++], fread_string(fp));
break;
case 'E':
KEY("Energy", ship->energy, fread_number(fp));
if (!str_cmp(word, "End")) {
if (!ship->home)
ship->home = str_dup("");
if (!ship->name)
ship->name = str_dup("");
if (!ship->owner)
ship->owner = str_dup("");
if (!ship->pilot)
ship->pilot = str_dup("");
if (!ship->copilot)
ship->copilot = str_dup("");
if (ship->shipstate != SHIP_DISABLED)
ship->shipstate = SHIP_DOCKED;
if (ship->laserstate != LASER_DAMAGED)
ship->laserstate = LASER_READY;
if (ship->missilestate != MISSILE_DAMAGED)
ship->missilestate = MISSILE_READY;
if (ship->shipyard <= 0)
ship->shipyard = ROOM_SHIP_LIMBO;
if (ship->lastdoc <= 0)
ship->lastdoc = ship->shipyard;
ship->autopilot = FALSE;
ship->hatchopen = FALSE;
ship->starsystem = NULL;
ship->hull = ship->maxhull;
ship->energy = ship->maxenergy;
ship->in_room = NULL;
ship->next_in_room = NULL;
ship->prev_in_room = NULL;
ship->first_turret = NULL;
ship->last_turret = NULL;
ship->first_hanger = NULL;
ship->last_hanger = NULL;
create_ship_rooms(ship);
return;
}
break;
case 'F':
KEYS("FName", ship->filename, fread_string(fp));
break;
case 'H':
KEY("Hyperspeed", ship->hyperspeed, fread_number(fp));
KEY("Hull", ship->hull, fread_number(fp));
KEYS("Home", ship->home, fread_string(fp));
break;
case 'L':
KEY("Lasers", ship->lasers, fread_number(fp));
KEY("Laserstate", ship->laserstate, fread_number(fp));
KEY("Lastdoc", ship->lastdoc, fread_number(fp));
break;
case 'M':
KEY("Model", ship->model, fread_number(fp));
KEY("Manuever", ship->manuever, fread_number(fp));
KEY("Missiles", ship->missiles, fread_number(fp));
KEY("Maxmissiles", ship->maxmissiles, fread_number(fp));
KEY("Maxshield",ship->maxshield, fread_number(fp));
KEY("Maxenergy",ship->maxenergy, fread_number(fp));
KEY("Maxhull", ship->maxhull, fread_number(fp));
KEY("Maxchaff", ship->maxchaff, fread_number(fp));
KEY("Missilestate", ship->missilestate, fread_number(fp));
break;
case 'N':
KEYS("Name", ship->name, fread_string(fp));
break;
case 'O':
KEYS("Owner", ship->owner, fread_string(fp));
break;
case 'P':
KEYS("Pilot", ship->pilot, fread_string(fp));
break;
case 'R':
KEY("Realspeed",ship->realspeed, fread_number(fp));
break;
case 'S':
KEY("Shipyard", ship->shipyard, fread_number(fp));
KEY("Shield", ship->shield, fread_number(fp));
KEY("Shipstate",ship->shipstate, fread_number(fp));
break;
case 'T':
KEY("Type", ship->type, fread_number(fp));
break;
}
if (!fMatch)
mudlogf(BRF, LVL_STAFF, TRUE, "fread_ship: no match: %s", word);
}
}
void fread_planet(PLANET_DATA *planet, FILE *fp) {
bool fMatch;
char *word, buf[MAX_STRING_LENGTH];
for (;;) {
fMatch = FALSE;
word = feof(fp) ? (char *)"End" : fread_word(fp);
switch (UPPER(word[0])) {
case '*':
fMatch = TRUE;
fread_to_eol(fp);
break;
case 'A':
if (!str_cmp(word, "Area")) {
AREA_DATA *pArea;
char area_name[MAX_STRING_LENGTH];
sprintf(area_name, fread_string(fp));
for (pArea = area_first; pArea; pArea = pArea->next)
if (pArea->file_name && !str_cmp(pArea->file_name, area_name)) {
ROOM_INDEX_DATA *room;
planet->size = 0;
planet->citysize = 0;
planet->wilderness = 0;
planet->farmland = 0;
planet->barracks = 0;
planet->controls = 0;
pArea->planet = planet;
planet->area = pArea;
}
fMatch = TRUE;
}
break;
case 'E':
if (!str_cmp(word, "End")) {
if (!planet->name)
planet->name = str_dup("");
return;
}
break;
case 'F':
KEYS("Filename", planet->filename, fread_string(fp));
break;
case 'G':
if (!str_cmp(word, "GovernedBy")) {
// planet->governed_by = -1;
fMatch = TRUE;
}
break;
case 'N':
KEYS("Name", planet->name, fread_string(fp));
break;
case 'P':
KEY("Popsupport", planet->pop_support, fread_number(fp));
break;
case 'S':
KEY("Sector", planet->sector, fread_number(fp));
if (!str_cmp(word, "Starsystem")) {
planet->starsystem = starsystem_from_name(fread_string(fp));
if (planet->starsystem) {
SPACE_DATA *starsystem = planet->starsystem;
LINK(planet, starsystem->first_planet, starsystem->last_planet, next_in_system, prev_in_system);
}
fMatch = TRUE;
}
break;
case 'X':
KEY("X", planet->x, fread_number(fp));
break;
case 'Y':
KEY("Y", planet->y, fread_number(fp));
break;
case 'Z':
KEY("Z", planet->z, fread_number(fp));
break;
}
if (!fMatch)
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: fread_planet: no match %s", word);
}
}
bool load_ship_file(char *shipfile) {
FILE *fp;
SHIP_DATA *ship;
CLAN_DATA *clan;
char filename[MAX_INPUT_LENGTH];
ship = (SHIP_DATA *)alloc_mem(sizeof(SHIP_DATA));
sprintf(filename, "%s%s", SHIP_DIR, shipfile);
if ((fp = fopen(filename, "r")) == NULL) {
free_mem(ship, sizeof(ship));
return FALSE;
} else {
for (;;) {
char *word, letter;
letter = fread_letter(fp);
if (letter == '*') {
fread_to_eol(fp);
continue;
}
if (letter != '#') {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: load_ship_file: # not found.");
break;
}
word = fread_word(fp);
if (!str_cmp(word, "SHIP")) {
fread_ship(ship, fp);
break;
} else if (!str_cmp(word, "END"))
break;
else {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: load_ship_file: bad section: %s", word);
break;
}
}
}
fclose(fp);
LINK(ship, first_ship, last_ship, next, prev);
if (ship->shipclass == SPACE_STATION || ship->type == MOB_SHIP) {
ship->currspeed = 0;
ship->shield = 0;
ship->currjump = NULL;
ship->target = NULL;
ship->energy = ship->maxenergy;
ship->chaff = ship->maxchaff;
ship->hull = ship->maxhull;
ship->missiles = ship->maxmissiles;
ship->shield = ship->maxshield;
ship->laserstate = LASER_READY;
ship->missilestate = MISSILE_READY;
ship->hatchopen = FALSE;
ship->autorecharge = FALSE;
ship->autotrack = FALSE;
ship->autospeed = FALSE;
ship_to_starsystem(ship, starsystem_from_name(ship->home));
ship->vx = number_range(-5000, 5000);
ship->vy = number_range(-5000, 5000);
ship->vz = number_range(-5000, 5000);
ship->hx = ship->hy = ship->hz = 1;
ship->shipstate = SHIP_READY;
ship->autopilot = TRUE;
ship->autorecharge = TRUE;
} else {
ship_to_room(ship, ship->lastdoc);
ship->location = ship->lastdoc;
}
if (ship->type != MOB_SHIP && ship->clan != -1) {
if (ship->shipclass <= SPACE_STATION)
;
// clan->spacecraft++;
else
;
// clan->vehicles++;
}
return TRUE;
}
void load_ships(void) {
FILE *fp;
char *filename;
first_ship = NULL;
last_ship = NULL;
first_missile = NULL;
last_missile = NULL;
fclose(fpReserve);
if ((fp = fopen(SHIP_LIST, "r")) == NULL) {
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: Couldn't open %s for reading.", SHIP_LIST);
exit(1);
}
for (;;) {
filename = feof(fp) ? (char *)"$" : fread_word(fp);
if (filename[0] == '$')
break;
if (!load_ship_file(filename))
mudlogf(BRF, LVL_STAFF, TRUE, "SYSERR: Couldn't load ship file: %s", filename);
}
fclose(fp);
fpReserve = fopen(NULL_FILE, "r");
return;
}
void reset_ship(SHIP_DATA *ship) {
ship->shipstate = SHIP_READY;
if (ship->shipclass != SPACE_STATION && ship->type != MOB_SHIP) {
extract_ship(ship);
ship_to_room(ship, ship->lastdoc);
ship->location = ship->lastdoc;
ship->shipstate = SHIP_DOCKED;
free_string(ship->home);
ship->home = str_dup("");
}
if (ship->starsystem)
ship_from_starsystem(ship, ship->starsystem);
ship->shield = 0;
ship->currspeed = 0;
ship->hull = ship->maxhull;
ship->chaff = ship->maxchaff;
ship->energy = ship->maxenergy;
ship->missiles = ship->maxmissiles;
ship->laserstate = LASER_READY;
ship->missilestate = MISSILE_READY;
ship->target = NULL;
ship->currjump = NULL;
ship->hatchopen = FALSE;
ship->autotrack = FALSE;
ship->autospeed = FALSE;
ship->autorecharge = FALSE;
save_ship(ship);
}
ROOM_INDEX_DATA *make_ship_room(SHIP_DATA *ship) {
ROOM_INDEX_DATA *pRoomIndex = new_room_index();
pRoomIndex->area = NULL;
pRoomIndex->vnum = -1;
pRoomIndex->name = str_dup(ship->name);
pRoomIndex->description = str_dup("Inside the ship.\n\r");
pRoomIndex->sector_type = SECT_INSIDE;
SET_BIT(ROOM_FLAGS(pRoomIndex), ROOM_INDOORS | ROOM_SPACECRAFT);
LINK(pRoomIndex, ship->first_room, ship->last_room, next_in_ship, prev_in_ship);
top_room++;
return pRoomIndex;
}
void create_ship_rooms(SHIP_DATA *ship) {
int roomnum, numrooms;
ROOM_INDEX_DATA *room[24];
if (ship->shipclass != SPACECRAFT)
ship->model = 0;
numrooms = UMIN(1, MAX_SHIP_ROOMS-1);
for (roomnum = 0; roomnum < numrooms; roomnum++)
room[roomnum] = make_ship_room(ship);
switch (ship->model) {
default:
ship->pilotseat = room[0];
ship->gunseat = room[0];
ship->viewscreen = room[0];
ship->entrance = room[0];
ship->engine = room[0];
break;
}
for (roomnum = 0; roomnum < numrooms; roomnum++) {
if (ship->description[roomnum] && ship->description[roomnum][0] != '\0') {
free_string(room[roomnum]->description);
room[roomnum]->description = str_dup(ship->description[roomnum]);
}
}
}
ACMD(do_openhatch) {
SHIP_DATA *ship;
char buf[MAX_STRING_LENGTH];
if (!argument || argument[0] == '\0' || !str_cmp(argument, "hatch")) {
if ((ship = ship_from_entrance(ch->in_room)) == NULL) {
ch->Send("Open what?\n\r");
return;
} else {
if (!ship->hatchopen) {
if (ship->shipclass == SPACE_STATION) {
ch->Send("Try one of the docking bays!\n\r");
return;
}
if (ship->location != ship->lastdoc
|| (ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED)) {
ch->Send("Please wait until the ship lands!\n\r");
return;
}
ship->hatchopen = TRUE;
ch->Send("You open the hatch.\n\r");
act("$n opens the hatch.", ch, 0, 0, TO_ROOM);
sprintf(buf, "The hatch on %s opens.", ship->name);
echo_to_room(get_room_index(ship->location), buf);
return;
} else {
ch->Send("It's already open.\n\r");
return;
}
}
}
argument = one_argument(argument, buf);
if ((ship = ship_in_room(ch->in_room, argument)) == NULL) {
act("I see no $T here.", ch, NULL, argument, TO_CHAR);
return;
}
if (ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED) {
ch->Send("That ship has already started to launch.\n\r");
return;
}
if (!check_pilot(ch, ship)) {
ch->Send("That's not your ship!\n\r");
return;
}
if (!ship->hatchopen) {
ship->hatchopen = TRUE;
act("You open the hatch on $T.", ch, 0, ship->name, TO_CHAR);
act("$n opens the hatch on $T.", ch, 0, ship->name, TO_ROOM);
echo_to_room(ship->entrance, "The hatch opens from the outside.`n");
return;
}
ch->Send("Its already open!\n\r");
}
ACMD(do_boardship) {
SHIP_DATA *ship;
ROOM_INDEX_DATA *toroom, *fromroom;
if (!argument || argument[0] == '\0') {
ch->Send("Board what?\n\r");
return;
}
if ((ship = ship_in_room(ch->in_room, argument)) == NULL) {
act("I see no $T here.", ch, 0, argument, TO_CHAR);
return;
}
fromroom = ch->in_room;
if ((toroom = ship->entrance) != NULL) {
if (!ship->hatchopen) {
ch->Send("The hatch is closed!\n\r");
return;
}
if (ship->shipstate == SHIP_LAUNCH || ship->shipstate == SHIP_LAUNCH_2) {
ch->Send("That ship has already started launching!\n\r");
return;
}
act("You enter $T.", ch, 0, ship->name, TO_CHAR);
act("$n enters $T.", ch, 0, ship->name, TO_ROOM);
char_from_room(ch);
char_to_room(ch, toroom);
act("$n enters the ship.", ch, 0, 0, TO_ROOM);
do_look(ch, "", 0);
} else
ch->Send("That ship has no entrance!\n\r");
}
ACMD(do_land) {
RNum vnum;
PLANET_DATA *planet;
ROOM_INDEX_DATA *room;
SHIP_DATA *ship, *target;
bool rfound = FALSE, pfound = FALSE;
char arg[MAX_INPUT_LENGTH], arg1[MAX_INPUT_LENGTH];
strcpy(arg, argument);
argument = one_argument(argument, arg1);
if ((ship = ship_from_pilotseat(IN_ROOM(ch))) == NULL) {
ch->Send("`RYou must be in the pilots seat of a ship to do that!`n\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis isn't a spacecraft!`n\n\r");
return;
}
if (autofly(ship)) {
ch->Send("`RYou'll have to turn off the ships autopilot first.`n\n\r");
return;
}
if (ship->shipclass == SPACE_STATION) {
ch->Send("`RYou can't land space stations.`n\n\r");
return;
}
switch (ship->shipstate) {
case SHIP_DISABLED:
ch->Send("`RThe ships drive is disabled. Unable to land.`n\n\r");
return;
case SHIP_DOCKED:
ch->Send("`RThe ship is already docked!`n\n\r");
return;
case SHIP_HYPERSPACE:
ch->Send("`RYou can only do that in realspace!`n\n\r");
return;
default:
break;
}
if (ship->shipstate != SHIP_READY) {
ch->Send("`RPlease wait until the ship has finished its current manouver.`n\n\r");
return;
}
if (ship->starsystem == NULL) {
ch->Send("`RThere's nowhere to land around here.`n\n\r");
return;
}
if (!*arg) {
ch->Send("`CLand where? Choices:\n\r");
for (target = ship->starsystem->first_ship; target; target = target->next_in_starsystem) {
if (target->shipclass == SPACE_STATION && target != ship)
ch->Send("%-24.24s %.0f %.0f %.0f\n\r", target->name, target->vx, target->vy, target->vz);
}
for (planet = ship->starsystem->first_planet; planet; planet = planet->next_in_system)
ch->Send("%-24.24s %.0f %.0f %.0f\n\r", planet->name, planet->x, planet->y, planet->z);
ch->Send("\n\rYour Coordinates: %.0f %.0f %.0f`n\n\r", ship->vx, ship->vy, ship->vz);
return;
}
for (planet = ship->starsystem->first_planet; planet; planet = planet->next_in_system) {
if (!str_prefix(arg1, planet->name)) {
pfound = TRUE;
if (!planet->area) {
ch->Send("`RThat planet doesn't have any landing areas.`n\n\r");
return;
}
if ((planet->x > ship->vx + 200) || (planet->x < ship->vx - 200) ||
(planet->y > ship->vy + 200) || (planet->y < ship->vy - 200) ||
(planet->z > ship->vz + 200) || (planet->z < ship->vz - 200)) {
ch->Send("`RThat planet is too far away! You'll have to fly a little closer.`n\n\r");
return;
}
if (*argument) {
for (vnum = planet->area->min_vnum; vnum <= planet->area->max_vnum; vnum++) {
if ((room = get_room_index(vnum)) != NULL
&& ROOM_FLAGGED(room, ROOM_CAN_LAND)
&& !str_prefix(argument, room->name)) {
rfound = TRUE;
break;
}
}
}
if (!rfound) {
ch->Send("`CPlease type the location after the planet name.`n\n\r");
ch->Send("Possible choices for %s:\n\r\n\r", planet->name);
for (vnum = planet->area->min_vnum; vnum <= planet->area->max_vnum; vnum++)
if ((room = get_room_index(vnum)) != NULL && ROOM_FLAGGED(room, ROOM_CAN_LAND))
ch->Send("%s\n\r", room->name);
return;
}
break;
}
}
if (!pfound) {
if ((target = get_ship_here(arg, ship->starsystem)) != NULL) {
if (target == ship) {
ch->Send("`RYou can't land your ship inside itself!`n\n\r");
return;
}
if (target->shipclass != SPACE_STATION) {
ch->Send("`RThat ship has no hanger for you to land in!`n\n\r");
return;
}
if ((target->vx > ship->vx + 200) || (target->vx < ship->vx - 200) ||
(target->vy > ship->vy + 200) || (target->vy < ship->vy - 200) ||
(target->vz > ship->vz + 200) || (target->vz < ship->vz - 200)) {
ch->Send("`RThat ship is too far away! You'll have to fly a little closer.`n\n\r");
return;
}
} else {
ch->Send("`RI don't see that here.`n\n\r");
do_land(ch, "", 0);
return;
}
}
ch->Send("`GLanding sequence initiated.`n\n\r");
act("$n begins the landing sequence.", ch, NULL, NULL, TO_ROOM);
echo_to_ship(TO_SHIP, ship, "`YThe ship slowly begins its landing aproach.`n");
ship->dest = str_dup(arg);
ship->shipstate = SHIP_LAND;
ship->currspeed = 0;
}
ACMD(do_launch) {
SHIP_DATA *ship;
char buf[MAX_STRING_LENGTH];
if ((ship = ship_from_pilotseat(IN_ROOM(ch))) == NULL) {
ch->Send("You must be in the pilot's seat of a ship to do that!\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis isn't a spacecraft.`n\n\r");
return;
}
if (ship->shipclass == SPACE_STATION) {
ch->Send("You can't do that here.\n\r");
return;
}
if (ship->lastdoc != ship->location) {
ch->Send("`rYou don't seem to be docked right now.`n\n\r");
return;
}
if (ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED) {
ch->Send("The ship is not docked right now.\n\r");
return;
}
if (ship->hatchopen) {
ship->hatchopen = FALSE;
sprintf(buf, "`YThe hatch on %s closes.`n",ship->name);
echo_to_room(get_room_index(ship->location), buf);
echo_to_room(ship->entrance, "`YThe hatch slides shut.`n");
}
ship->shield = 0;
ship->hull = ship->maxhull;
ship->chaff = ship->maxchaff;
ship->energy = ship->maxenergy;
ship->missiles = ship->maxmissiles;
ship->autorecharge = FALSE;
ship->autotrack = FALSE;
ship->autospeed = FALSE;
ship->shipstate = SHIP_READY;
ship->laserstate = LASER_READY;
ship->missilestate = MISSILE_READY;
ch->Send("`GLaunch sequence initiated.`n\n\r");
echo_to_ship(TO_SHIP, ship, "`YThe ship hums as it lifts off the ground.`n");
sprintf(buf, "`Y%s begins to launch.`n", ship->name);
echo_to_room(get_room_index(ship->location), buf);
ship->shipstate = SHIP_LAUNCH;
ship->currspeed = ship->realspeed;
}
ACMD(do_radar) {
PLANET_DATA *planet;
MISSILE_DATA *missile;
SHIP_DATA *ship, *target;
double x, y, z, distance;
if ((ship = ship_from_cockpit(ch->in_room)) == NULL) {
ch->Send("`RYou must be in the cockpit or turret of a ship to do that!`n\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis isn't a spacecraft!`n\n\r");
return;
}
switch (ship->shipstate) {
case SHIP_DOCKED:
ch->Send("`RWait until after you launch!`n\n\r");
return;
case SHIP_HYPERSPACE:
ch->Send("`RYou can only do that in normal space.`n\n\r");
return;
default:
break;
}
if (ship->starsystem == NULL) {
ch->Send("`RYou can't do that unless the ship is flying in normal space.`n\n\r");
return;
}
act("$n checks the radar.", ch, 0, 0, TO_ROOM);
ch->Send("%s\n\r\n\r", ship->starsystem->name);
if (ship->starsystem->star1 && ship->starsystem->star1[0] != '\0') {
x = ship->vx - ship->starsystem->s1x;
y = ship->vy - ship->starsystem->s1y;
z = ship->vz - ship->starsystem->s1z;
distance = sqrt(x*x + y*y + z*z);
ch->Send("`Y%-14.14s %.0f %.0f %.0f; (%.0f)`n\n\r",
ship->starsystem->star1,
ship->starsystem->s1x, ship->starsystem->s1y,
ship->starsystem->s1z, distance);
}
if (ship->starsystem->star2 && ship->starsystem->star2[0] != '\0') {
x = ship->vx - ship->starsystem->s2x;
y = ship->vy - ship->starsystem->s2y;
z = ship->vz - ship->starsystem->s2z;
distance = sqrt(x*x + y*y + z*z);
ch->Send("`Y%-14.14s %.0f %.0f %.0f; (%.0f)`n\n\r",
ship->starsystem->star2,
ship->starsystem->s2x, ship->starsystem->s2y,
ship->starsystem->s2z, distance);
}
for (planet = ship->starsystem->first_planet; planet; planet = planet->next_in_system) {
x = ship->vx - planet->x;
y = ship->vy - planet->y;
z = ship->vz - planet->z;
distance = sqrt(x*x + y*y + z*z);
ch->Send("`G%-14.14s %.0f %.0f %.0f; (%.0f)`n\n\r",
planet->name,
planet->x, planet->y, planet->z, distance);
}
ch->Send("\n\r");
for (missile = ship->starsystem->first_missile; missile; missile = missile->next_in_starsystem) {
x = ship->vx - missile->mx;
y = ship->vy - missile->my;
z = ship->vz - missile->mz;
distance = sqrt(x*x + y*y + z*z);
ch->Send("`R%-14.14s %.0f %.0f %.0f; (%.0f)`n\n\r",
"A missile", missile->mx, missile->my, missile->mz, distance);
}
ch->Send("\n\r");
for (target = ship->starsystem->first_ship; target; target = target->next_in_starsystem) {
if (target == ship)
continue;
x = ship->vx - target->vx;
y = ship->vy - target->vy;
z = ship->vz - target->vz;
distance = sqrt(x*x + y*y + z*z);
ch->Send("`C%s %.0f %.0f %.0f; (%.0f)`n\n\r",
target->name, target->vx, target->vy, target->vz, distance);
}
ch->Send("\n\r`WYour coordinates: %.0f %.0f %.0f\n\r",
ship->vx, ship->vy, ship->vz);
}
ACMD(do_accelerate) {
int change;
SHIP_DATA *ship;
if ((ship = ship_from_pilotseat(ch->in_room)) == NULL) {
ch->Send("`RYou must be at the controls of a ship to do that!n\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis isn't a spacecraft!`n\n\r");
return;
}
if (autofly(ship)) {
ch->Send("`RYou'll have to turn off the ships autopilot first.`n\n\r");
return;
}
if (ship->shipclass == SPACE_STATION) {
ch->Send("`RPlatforms don't fly!`n\n\r");
return;
}
switch (ship->shipstate) {
case SHIP_HYPERSPACE:
ch->Send("`RYou can only do that in realspace!`n\n\r");
return;
case SHIP_DISABLED:
ch->Send("`RThe ships drive is disabled. Unable to accelerate.`n\n\r");
return;
case SHIP_DOCKED:
ch->Send("`RYou can't do that until after you've launched!`n\n\r");
return;
default:
break;
}
change = atoi(argument);
if (ship->energy < flabs((change - flabs(ship->currspeed)) / 10)) {
ch->Send("`RThere is not enough fuel!`n\n\r");
return;
}
act("$n manipulates the ship's controls.", ch, 0, 0, TO_ROOM);
if (ship->currspeed < change) {
ch->Send("`GAccelerating`n\n\r");
echo_to_ship(TO_COCKPIT, ship, "`YThe ship begins to accelerate.`n");
echo_to_system(ship, NULL, "`y%s begins to speed up.`n", ship->name);
}
if (ship->currspeed > change) {
ch->Send("`GDecelerating`n\n\r");
echo_to_ship(TO_COCKPIT, ship, "`YThe ship begins to slow down.`n");
echo_to_system(ship, NULL, "`y%s begins to slow down.`n", ship->name);
}
ship->energy -= flabs((change - flabs(ship->currspeed))/10);
ship->currspeed = URANGE(0 , change, ship->realspeed);
}
ACMD(do_course) {
SHIP_DATA *ship;
float vx, vy, vz;
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
if ((ship = ship_from_pilotseat(ch->in_room)) == NULL) {
ch->Send("`RYou must be at the healm of a ship to do that!`n\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis is not a spacecraft.`n\n\r");
return;
}
if (autofly(ship)) {
ch->Send("`RYou'll have to turn off the ships autopilot first.`n\n\r");
return;
}
if (ship->shipstate == SHIP_DISABLED) {
ch->Send("`RThe ships drive is disabled. Unable to manuever.`n\n\r");
return;
}
if (ship->shipclass == SPACE_STATION) {
ch->Send("`RPlatforms cannot fly.`n\n\r");
return;
}
switch (ship->shipstate) {
case SHIP_HYPERSPACE:
ch->Send("`RYou can only do that in realspace!`n\n\r");
return;
case SHIP_DOCKED:
ch->Send("`RYou can't do that until after you've launched!`n\n\r");
return;
default:
break;
}
if (ship->shipstate != SHIP_READY) {
ch->Send("`RPlease wait until the ship has finished its current manouver.`n\n\r");
return;
}
if (ship->energy < (ship->currspeed / 10)) {
ch->Send("`RThere is not enough fuel!`n\n\r");
return;
}
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
vx = atof(arg1);
vy = atof(arg2);
vz = atof(argument);
if (vx == ship->vx && vy == ship->vy && vz == ship->vz) {
ch->Send("The ship is already at %.0f %.0f %.0f!\n\r", vx, vy, vz);
return;
}
ship->hx = vx - ship->vx;
ship->hy = vy - ship->vy;
ship->hz = vz - ship->vz;
ship->energy -= (ship->currspeed / 10);
ch->Send("`GNew course set, aproaching %.0f %.0f %.0f.`n\n\r", vx, vy, vz);
act("$n manipulates the ships controls.", ch, 0, 0, TO_ROOM);
echo_to_ship(TO_COCKPIT, ship, "`YThe ship begins to turn.`n");
echo_to_system(ship, NULL, "`y%s turns altering its present course.`n", ship->name);
if (ship->manuever > 100)
ship->shipstate = SHIP_BUSY_3;
else if (ship->manuever > 50)
ship->shipstate = SHIP_BUSY_2;
else
ship->shipstate = SHIP_BUSY;
}
ACMD(do_shipstat) {
SHIP_DATA *ship, *target;
if ((ship = ship_from_cockpit(IN_ROOM(ch))) == NULL) {
ch->Send("`RYou must be in the cockpit, turret or engineroom of a ship to do that!`n\n\r");
return;
}
if (!*argument)
target = ship;
else
target = get_ship_here(argument, ship->starsystem);
if (target == NULL) {
ch->Send("`RI don't see that here.`n\n\r"
"`RTry the radar, or type status by itself for your ship's status.`n\n\r");
return;
}
act("$n checks various gages and displays on the control panel.", ch, 0, 0, TO_ROOM);
ch->Send(
"`W%s:`n\n\r"
"`yCurrent Speed : `Y%d`y/`Y%d`n\n\r"
"`yCurrent Heading : `Y%.0f %.0f %.0f`n\n\r"
"`yCurrent Coordinates: `Y%.0f %.0f %.0f`n\n\r"
"`yCurrent Target : `Y%s`n\n\r"
"`yShip Condition : `Y%s`n\n\r"
"`yLaser Condition : `Y%-11.11s `yMissile Condition: `Y%s`n\n\r"
"`yHull : `Y%5d`y/`Y%-5d `yShields : `Y%d`y/`Y%d`n\n\r"
"`yEnergy (fuel) : `Y%5d`y/`Y%-5d `yMissiles: `Y%d`y/`Y%d`n\n\r",
target->name, target->currspeed, target->realspeed,
target->hx, target->hy, target->hz,
target->vx, target->vy, target->vz,
target->target ? target->target->name : "None",
target->shipstate == SHIP_DISABLED ? "Disabled" : "Running",
target->laserstate == LASER_DAMAGED ? "Damaged" : "Good",
target->missilestate == MISSILE_DAMAGED ? "Damaged" : "Good",
target->hull, target->maxhull, target->shield, target->maxshield,
target->energy, target->maxenergy, target->missiles, target->maxmissiles);
}
ACMD(do_calculate) {
int count = 0;
SHIP_DATA *ship;
PLANET_DATA *planet;
SPACE_DATA *starsystem;
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
argument = one_argument(argument, arg3);
if ((ship = ship_from_pilotseat(IN_ROOM(ch))) == NULL) {
ch->Send("`RYou must be in control of a ship to do that!`n\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis isn't a space craft.`n\n\r");
return;
}
if (autofly(ship)) {
ch->Send("`RYou'll have to turn off the ships autopilot first.`n\n\r");
return;
}
if (ship->shipclass == SPACE_STATION) {
ch->Send("`RThis station is a little too big for hyperspace.`n\n\r");
return;
}
if (ship->hyperspeed == 0) {
ch->Send("`RThis ship is not equipped with a hyperdrive!\n\r");
return;
}
if (ship->shipstate == SHIP_DOCKED) {
ch->Send("`RYou can't do that until after you've launched!`n\n\r");
return;
}
if (ship->starsystem == NULL) {
ch->Send("`RYou can only do that in real space.`n\n\r");
return;
}
if (!*argument) {
ch->Send("`WUsage: Calculate <starsystem> <entry x> <entry y> <entry z>\n\r");
ch->Send("Possible destinations:`n\n\r");
for (starsystem = first_starsystem; starsystem; starsystem = starsystem->next) {
count++;
ch->Send("%-12.12s%s",
starsystem->name, !(count % 6) ? "\n\r" : " ");
}
if (!count)
ch->Send("No starsystems found.\n\r");
return;
}
ship->currjump = starsystem_from_name(arg1);
ship->jx = atoi(arg2);
ship->jy = atoi(arg3);
ship->jz = atoi(argument);
if (ship->currjump == NULL) {
ch->Send("`RYou can't seem to find that starsytem on your charts.`n\n\r");
return;
} else {
starsystem = ship->currjump;
if (starsystem->star1 && *starsystem->star1
&& flabs(ship->jx - starsystem->s1x) < 300
&& flabs(ship->jy - starsystem->s1y) < 300
&& flabs(ship->jz - starsystem->s1z) < 300) {
echo_to_ship(TO_COCKPIT, ship, "`RWARNING.. Jump coordinates too close to stellar object.`n");
echo_to_ship(TO_COCKPIT, ship, "`RWARNING.. Hyperjump NOT set.`n");
ship->currjump = NULL;
return;
}
if (starsystem->star2 && *starsystem->star2
&& flabs(ship->jx - starsystem->s2x) < 300
&& flabs(ship->jy - starsystem->s2y) < 300
&& flabs(ship->jz - starsystem->s2z) < 300) {
echo_to_ship(TO_COCKPIT, ship, "`RWARNING.. Jump coordinates too close to stellar object.`n");
echo_to_ship(TO_COCKPIT, ship, "`RWARNING.. Hyperjump NOT set.`n");
ship->currjump = NULL;
return;
}
for (planet = starsystem->first_planet; planet; planet = planet->next_in_system) {
if (flabs(ship->jx - planet->x) < 300
&& flabs(ship->jy - planet->y) < 300
&& flabs(ship->jz - planet->z) < 300) {
echo_to_ship(TO_COCKPIT, ship, "`RWARNING.. Jump coordinates too close to stellar object.`n");
echo_to_ship(TO_COCKPIT, ship, "`RWARNING.. Hyperjump NOT set.`n");
ship->currjump = NULL;
return;
}
}
ship->jx += number_range(-250, 250);
ship->jy += number_range(-250, 250);
ship->jz += number_range(-250, 250);
}
if (ship->starsystem == ship->currjump)
ship->hyperdistance = number_range(0, 250);
else
ship->hyperdistance = number_range(500, 2000);
ch->Send("`GHyperspace course set. Ready for the jump to lightspeed.`n\n\r");
act("$n does some calculations using the ships computer.", ch, 0, 0, TO_ROOM);
if (!NO_STAFF_HASSLE(ch))
WAIT_STATE(ch, 2 * PULSE_VIOLENCE);
}
ACMD(do_hyperspace) {
SHIP_DATA *ship;
if ((ship = ship_from_pilotseat(IN_ROOM(ch))) == NULL) {
ch->Send("`RYou must be in control of a ship to do that!`n\n\r");
return;
}
if (ship->shipclass > SPACE_STATION) {
ch->Send("`RThis isn't a spacecraft.`n\n\r");
return;
}
if (autofly(ship)) {
ch->Send("`RYou'll have to turn off the ships autopilot first.`n\n\r");
return;
}
if (ship->shipclass == SPACE_STATION) {
ch->Send("Space platforms can't move!\n\r");
return;
}
if (ship->hyperspeed == 0) {
ch->Send("`RThis ship is not equipped with a hyperdrive!`n\n\r");
return;
}
switch (ship->shipstate) {
case SHIP_HYPERSPACE:
ch->Send("`RYou are already travelling lightspeed!`n\n\r");
return;
case SHIP_DISABLED:
ch->Send("`RThe ships drive is disabled. Unable to manuever.`n\n\r");
return;
case SHIP_DOCKED:
ch->Send("`RYou can't do that until after you've launched!`n\n\r");
return;
default:
break;
}
if (ship->shipstate != SHIP_READY) {
ch->Send("`RPlease wait until the ship has finished its current manouver.`n\n\r");
return;
}
if (ship->currjump == NULL) {
ch->Send("`RYou need to calculate your jump first!`n\n\r");
return;
}
if (ship->energy < (200 + ship->hyperdistance)) {
ch->Send("`RThere is not enough fuel!`n\n\r");
return;
}
if (ship->currspeed <= 0) {
ch->Send("`RYou need to speed up first.`n\n\r");
return;
}
echo_to_system(ship, NULL, "`Y%s disapears from your scanner.`n", ship->name);
ship_from_starsystem(ship, ship->starsystem);
ship->shipstate = SHIP_HYPERSPACE;
ch->Send("`GYou push forward the hyperspeed lever.`n\n\r");
act("$n pushes a lever forward on the control panel.", ch, 0, 0, TO_ROOM);
echo_to_ship(TO_SHIP, ship, "`YThe ship lurches slightly as it makes the jump to lightspeed.`n");
echo_to_ship(TO_COCKPIT, ship, "`YThe stars become streaks of light as you enter hyperspace.`n");
ship->energy -= (100 + ship->hyperdistance);
ship->vx = ship->jx;
ship->vy = ship->jy;
ship->vz = ship->jz;
}