#include <math.h> #include <sys/types.h> #include <ctype.h> #include <stdio.h> #include <string.h> #include <time.h> #include "mud.h" SHIP_DATA *first_ship; SHIP_DATA *last_ship; MISSILE_DATA *first_missile; MISSILE_DATA *last_missile; SPACE_DATA *first_starsystem; SPACE_DATA *last_starsystem; int bus_pos = 0; int bus_planet = 0; int bus2_pos = 0; int bus2_planet = 0; int turbocar_stop = 0; int corus_shuttle = 0; int turbocar_delay = 0; bool spaceDeath = FALSE; #define MAX_STATION 4 #define MAX_BUS_STOP 3 #define MAX_BUS_STOP2 3 #define STOP_PLANET 202 #define STOP_SHIPYARD 32015 #define SENATEPAD 10196 #define OUTERPAD 10195 int gsn_weaponsystems; int gsn_shipsystems; int gsn_navigation; int gsn_shipmaintenance; int gsn_spacecombat; int gsn_spacecombat2; int gsn_spacecombat3; int gsn_capitalships; int gsn_midships; int gsn_starfighters; int const station_vnum[MAX_STATION] = { 3916, 2124, 9042, 110000 }; char *const station_name[MAX_STATION] = { "Satan City Train Station", "Kame's Lookout", "Space Port Delta", "Capsule Corp" }; int const bus_vnum[MAX_BUS_STOP] = { 210, 3871, 60000 }; int const bus_vnum2[MAX_BUS_STOP] = { 208, 5000, 40000 }; char *const bus_stop[MAX_BUS_STOP + 1] = { "The Center of the Universe", "Earth - Space Port Alpha", "Vegeta - Soltari Spaceport", "The Center of the Universe" /* last should always be same as first */ }; char *const bus_stop2[MAX_BUS_STOP2 + 1] = { "The Center of the Universe", "Namek - A Large Crater", "Namek - Welcome to Planet Namek", "The Center of the Universe" /* last should always be same as first */ }; /* local routines */ void fread_ship args( ( SHIP_DATA * ship, FILE * fp ) ); bool load_ship_file args( ( char *shipfile ) ); void write_ship_list args( ( void ) ); void fread_starsystem args( ( SPACE_DATA * starsystem, FILE * fp ) ); bool load_starsystem args( ( char *starsystemfile ) ); void write_starsystem_list args( ( void ) ); void landship args( ( SHIP_DATA * ship, char *arg ) ); void launchship args( ( SHIP_DATA * ship ) ); void echo_to_room_dnr args( ( int ecolor, ROOM_INDEX_DATA * room, char *argument ) ); bool autofly( SHIP_DATA * ship ); bool is_facing( SHIP_DATA * ship, SHIP_DATA * target ); void resetship args( ( SHIP_DATA * ship ) ); bool land_bus args( ( SHIP_DATA * ship, int destination ) ); void launch_bus args( ( SHIP_DATA * ship ) ); ch_ret drive_ship( CHAR_DATA * ch, SHIP_DATA * ship, EXIT_DATA * exit, int fall ); bool combatShip( SHIP_DATA * ship ) { if( ship->maxchaff > 0 ) return TRUE; if( ship->lasers > 0 ) return TRUE; if( ship->maxmissiles > 0 ) return TRUE; if( ship->maxtorpedos > 0 ) return TRUE; if( ship->maxrockets > 0 ) return TRUE; return FALSE; } long int get_ship_value( SHIP_DATA * ship ) { return ship->cost; } void write_ship_list( ) { SHIP_DATA *tship; FILE *fpout; char filename[256]; sprintf( filename, "%s%s", SHIP_DIR, SHIP_LIST ); fpout = fopen( filename, "w" ); if( !fpout ) { bug( "FATAL: cannot open ship.lst for writing!\n\r", 0 ); return; } for( tship = first_ship; tship; tship = tship->next ) fprintf( fpout, "%s\n", tship->filename ); fprintf( fpout, "$\n" ); fclose( fpout ); } SHIP_DATA *ship_in_room( ROOM_INDEX_DATA * room, char *name ) { SHIP_DATA *ship; if( !room ) return NULL; for( ship = room->first_ship; ship; ship = ship->next_in_room ) if( !str_cmp( name, ship->name ) ) return ship; for( ship = room->first_ship; ship; ship = ship->next_in_room ) if( nifty_is_name_prefix( name, ship->name ) ) return ship; return NULL; } SHIP_DATA *ship_from_entrance( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->entrance ) return ship; return NULL; } SHIP_DATA *ship_from_pilotseat( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->pilotseat ) return ship; return NULL; } bool check_pilot( CHAR_DATA * ch, SHIP_DATA * ship ) { if( !str_cmp( ch->name, ship->owner ) || !str_cmp( ch->name, ship->pilot ) || !str_cmp( ch->name, ship->copilot ) || !str_cmp( "Public", ship->owner ) ) return TRUE; if( !IS_NPC( ch ) && ch->pcdata && ch->pcdata->clan ) { if( !str_cmp( ch->pcdata->clan->name, ship->owner ) ) { if( is_leader( ch ) ) return TRUE; if( ch->pcdata->bestowments && is_name( "pilot", ch->pcdata->bestowments ) ) return TRUE; } } return FALSE; } bool is_rental( CHAR_DATA * ch, SHIP_DATA * ship ) { if( !str_cmp( "Public", ship->owner ) ) return TRUE; return FALSE; } bool rent_ship( CHAR_DATA * ch, SHIP_DATA * ship ) { long price; if( IS_NPC( ch ) ) return FALSE; price = get_ship_value( ship ) / 100; if( ch->gold < price ) { pager_printf_color( ch, "&RRenting this ship costs %ld. You don't have enough credits!\n\r", price ); return FALSE; } ch->gold -= price; pager_printf_color( ch, "&GYou pay %ld credits to rent the ship.\n\r", price ); return TRUE; } SHIP_DATA *ship_from_coseat( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->coseat ) return ship; return NULL; } SHIP_DATA *ship_from_navseat( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->navseat ) return ship; return NULL; } SHIP_DATA *ship_from_gunseat( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->gunseat ) return ship; return NULL; } SHIP_DATA *ship_from_engine( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) { if( ship->engineroom ) { if( vnum == ship->engineroom ) return ship; } else { if( vnum == ship->cockpit ) return ship; } } return NULL; } SHIP_DATA *ship_from_turret( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->gunseat || vnum == ship->turret1 || vnum == ship->turret2 ) return ship; return NULL; } SHIP_DATA *get_ship( char *name ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( !str_cmp( name, ship->name ) ) return ship; for( ship = first_ship; ship; ship = ship->next ) if( nifty_is_name_prefix( name, ship->name ) ) return ship; return NULL; } SHIP_DATA *ship_from_cockpit( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->cockpit || vnum == ship->turret1 || vnum == ship->turret2 || vnum == ship->pilotseat || vnum == ship->coseat || vnum == ship->navseat || vnum == ship->gunseat || vnum == ship->engineroom ) return ship; return NULL; } SHIP_DATA *ship_from_hanger( int vnum ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->hanger ) return ship; return NULL; } bool land_bus( SHIP_DATA * ship, int destination ) { char buf[MAX_STRING_LENGTH]; if( !ship_to_room( ship, destination ) ) { return FALSE; } echo_to_ship( AT_YELLOW, ship, "You feel a slight thud as the ship sets down on the ground." ); ship->location = destination; ship->lastdoc = ship->location; ship->shipstate = SHIP_DOCKED; if( ship->starsystem ) ship_from_starsystem( ship, ship->starsystem ); sprintf( buf, "%s lands on the platform.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); sprintf( buf, "The hatch on %s opens.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); echo_to_room( AT_YELLOW, get_room_index( ship->entrance ), "The hatch opens." ); ship->hatchopen = TRUE; return TRUE; } void launch_bus( SHIP_DATA * ship ) { char buf[MAX_STRING_LENGTH]; sprintf( buf, "The hatch on %s closes and it begins to launch.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); echo_to_room( AT_YELLOW, get_room_index( ship->entrance ), "The hatch slides shut." ); ship->hatchopen = FALSE; extract_ship( ship ); echo_to_ship( AT_YELLOW, ship, "The ship begins to launch." ); ship->location = 0; ship->shipstate = SHIP_READY; } /* * Checks if ships in a starsystem and returns poiner if it is. */ 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( !str_cmp( name, ship->name ) ) return ship; for( ship = starsystem->first_ship; ship; ship = ship->next_in_starsystem ) if( nifty_is_name_prefix( name, ship->name ) ) return ship; return NULL; } void ship_from_starsystem( SHIP_DATA * ship, SPACE_DATA * starsystem ) { if( starsystem == NULL ) return; if( ship == NULL ) return; if( starsystem->last_ship == ship ) starsystem->last_ship = ship->prev_in_starsystem; if( starsystem->first_ship == ship ) starsystem->first_ship = ship->next_in_starsystem; if( ship->prev_in_starsystem ) ship->prev_in_starsystem->next_in_starsystem = ship->next_in_starsystem; if( ship->next_in_starsystem ) ship->next_in_starsystem->prev_in_starsystem = ship->prev_in_starsystem; ship->starsystem = NULL; ship->next_in_starsystem = NULL; ship->prev_in_starsystem = NULL; } void echo_to_cockpit( int color, SHIP_DATA * ship, char *argument ) { int room; for( room = ship->firstroom; room <= ship->lastroom; room++ ) { if( room == ship->cockpit || room == ship->navseat || room == ship->pilotseat || room == ship->coseat || room == ship->gunseat || room == ship->engineroom || room == ship->turret1 || room == ship->turret2 ) echo_to_room( color, get_room_index( room ), argument ); } } void echo_to_system( int color, SHIP_DATA * ship, char *argument, SHIP_DATA * ignore ) { SHIP_DATA *target; if( !ship->starsystem ) return; for( target = ship->starsystem->first_ship; target; target = target->next_in_starsystem ) { if( target != ship && target != ignore ) echo_to_cockpit( color, target, argument ); } } void echo_to_ship( int color, SHIP_DATA * ship, char *argument ) { int room; for( room = ship->firstroom; room <= ship->lastroom; room++ ) { echo_to_room( color, get_room_index( room ), argument ); } } void echo_to_room_dnr( int ecolor, ROOM_INDEX_DATA * room, char *argument ) { CHAR_DATA *vic; if( room == NULL ) return; for( vic = room->first_person; vic; vic = vic->next_in_room ) { set_char_color( ecolor, vic ); send_to_pager_color( argument, vic ); } } bool is_facing( SHIP_DATA * ship, SHIP_DATA * target ) { float dy, dx, dz, hx, hy, hz; float 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; if( ship->autopilot ) return TRUE; return FALSE; } int wherehome( CHAR_DATA * ch ) { // if( ch->plr_home ) // return ch->plr_home->vnum; if( ch->race == RACE_SAIYAN ) return ROOM_START_SAIYAN; if( ch->race == RACE_HUMAN ) return ROOM_START_HUMAN; if( ch->race == RACE_HALFBREED ) return ROOM_START_HALFBREED; if( ch->race == RACE_NAMEK ) return ROOM_START_NAMEK; if( ch->race == RACE_ANDROID ) return ROOM_START_ANDROID; if( is_superandroid( ch ) ) return ROOM_START_ANDROID; if( ch->race == RACE_ICER ) return ROOM_START_ICER; return ROOM_VNUM_TEMPLE; } void write_starsystem_list( ) { SPACE_DATA *tstarsystem; FILE *fpout; char filename[256]; sprintf( filename, "%s%s", SPACE_DIR, SPACE_LIST ); fpout = fopen( filename, "w" ); if( !fpout ) { bug( "FATAL: cannot open starsystem.lst for writing!\n\r", 0 ); return; } for( tstarsystem = first_starsystem; tstarsystem; tstarsystem = tstarsystem->next ) fprintf( fpout, "%s\n", tstarsystem->filename ); fprintf( fpout, "$\n" ); fclose( fpout ); } /* * Get pointer to space structure from starsystem name. */ 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; } /* * Get pointer to space structure from the dock vnun. */ SPACE_DATA *starsystem_from_vnum( int vnum ) { SPACE_DATA *starsystem; SHIP_DATA *ship; for( starsystem = first_starsystem; starsystem; starsystem = starsystem->next ) if( vnum == starsystem->doc1a || vnum == starsystem->doc2a || vnum == starsystem->doc3a || vnum == starsystem->doc1b || vnum == starsystem->doc2b || vnum == starsystem->doc3b || vnum == starsystem->doc1c || vnum == starsystem->doc2c || vnum == starsystem->doc3c ) return starsystem; for( ship = first_ship; ship; ship = ship->next ) if( vnum == ship->hanger ) return ship->starsystem; return NULL; } /* * Save a starsystem's data to its data file */ void save_starsystem( SPACE_DATA * starsystem ) { FILE *fp; char filename[256]; char buf[MAX_STRING_LENGTH]; if( !starsystem ) { bug( "save_starsystem: null starsystem pointer!", 0 ); return; } if( !starsystem->filename || starsystem->filename[0] == '\0' ) { sprintf( buf, "save_starsystem: %s has no filename", starsystem->name ); bug( buf, 0 ); return; } sprintf( filename, "%s%s", SPACE_DIR, starsystem->filename ); fclose( fpReserve ); if( ( fp = fopen( filename, "w" ) ) == NULL ) { bug( "save_starsystem: fopen", 0 ); perror( filename ); } else { fprintf( fp, "#SPACE\n" ); fprintf( fp, "Name %s~\n", starsystem->name ); fprintf( fp, "Filename %s~\n", starsystem->filename ); fprintf( fp, "Planet1 %s~\n", starsystem->planet1 ); fprintf( fp, "Planet2 %s~\n", starsystem->planet2 ); fprintf( fp, "Planet3 %s~\n", starsystem->planet3 ); fprintf( fp, "Star1 %s~\n", starsystem->star1 ); fprintf( fp, "Star2 %s~\n", starsystem->star2 ); fprintf( fp, "Location1a %s~\n", starsystem->location1a ); fprintf( fp, "Location1b %s~\n", starsystem->location1b ); fprintf( fp, "Location1c %s~\n", starsystem->location1c ); fprintf( fp, "Location2a %s~\n", starsystem->location2a ); fprintf( fp, "Location2b %s~\n", starsystem->location2b ); fprintf( fp, "Location2c %s~\n", starsystem->location2c ); fprintf( fp, "Location3a %s~\n", starsystem->location3a ); fprintf( fp, "Location3b %s~\n", starsystem->location3b ); fprintf( fp, "Location3c %s~\n", starsystem->location3c ); fprintf( fp, "Doc1a %d\n", starsystem->doc1a ); fprintf( fp, "Doc2a %d\n", starsystem->doc2a ); fprintf( fp, "Doc3a %d\n", starsystem->doc3a ); fprintf( fp, "Doc1b %d\n", starsystem->doc1b ); fprintf( fp, "Doc2b %d\n", starsystem->doc2b ); fprintf( fp, "Doc3b %d\n", starsystem->doc3b ); fprintf( fp, "Doc1c %d\n", starsystem->doc1c ); fprintf( fp, "Doc2c %d\n", starsystem->doc2c ); fprintf( fp, "Doc3c %d\n", starsystem->doc3c ); fprintf( fp, "P1x %d\n", starsystem->p1x ); fprintf( fp, "P1y %d\n", starsystem->p1y ); fprintf( fp, "P1z %d\n", starsystem->p1z ); fprintf( fp, "P2x %d\n", starsystem->p2x ); fprintf( fp, "P2y %d\n", starsystem->p2y ); fprintf( fp, "P2z %d\n", starsystem->p2z ); fprintf( fp, "P3x %d\n", starsystem->p3x ); fprintf( fp, "P3y %d\n", starsystem->p3y ); fprintf( fp, "P3z %d\n", starsystem->p3z ); fprintf( fp, "S1x %d\n", starsystem->s1x ); fprintf( fp, "S1y %d\n", starsystem->s1y ); fprintf( fp, "S1z %d\n", starsystem->s1z ); fprintf( fp, "S2x %d\n", starsystem->s2x ); fprintf( fp, "S2y %d\n", starsystem->s2y ); fprintf( fp, "S2z %d\n", starsystem->s2z ); fprintf( fp, "Gravitys1 %d\n", starsystem->gravitys1 ); fprintf( fp, "Gravitys2 %d\n", starsystem->gravitys2 ); fprintf( fp, "Gravityp1 %d\n", starsystem->gravityp1 ); fprintf( fp, "Gravityp2 %d\n", starsystem->gravityp2 ); fprintf( fp, "Gravityp3 %d\n", starsystem->gravityp3 ); fprintf( fp, "Xpos %d\n", starsystem->xpos ); fprintf( fp, "Ypos %d\n", starsystem->ypos ); fprintf( fp, "End\n\n" ); fprintf( fp, "#END\n" ); } fclose( fp ); fpReserve = fopen( NULL_FILE, "r" ); return; } /* * Read in actual starsystem data. */ #if defined(KEY) #undef KEY #endif #define KEY( literal, field, value ) \ if ( !str_cmp( word, literal ) ) \ { \ field = value; \ fMatch = TRUE; \ break; \ } void fread_starsystem( SPACE_DATA * starsystem, FILE * fp ) { char buf[MAX_STRING_LENGTH]; char *word; bool fMatch; for( ;; ) { word = feof( fp ) ? "End" : fread_word( fp ); fMatch = FALSE; switch ( UPPER( word[0] ) ) { case '*': fMatch = TRUE; fread_to_eol( fp ); break; case 'D': KEY( "Doc1a", starsystem->doc1a, fread_number( fp ) ); KEY( "Doc2a", starsystem->doc2a, fread_number( fp ) ); KEY( "Doc3a", starsystem->doc3a, fread_number( fp ) ); KEY( "Doc1b", starsystem->doc1b, fread_number( fp ) ); KEY( "Doc2b", starsystem->doc2b, fread_number( fp ) ); KEY( "Doc3b", starsystem->doc3b, fread_number( fp ) ); KEY( "Doc1c", starsystem->doc1c, fread_number( fp ) ); KEY( "Doc2c", starsystem->doc2c, fread_number( fp ) ); KEY( "Doc3c", starsystem->doc3c, fread_number( fp ) ); break; case 'E': if( !str_cmp( word, "End" ) ) { if( !starsystem->name ) starsystem->name = STRALLOC( "" ); if( !starsystem->location1a ) starsystem->location1a = STRALLOC( "" ); if( !starsystem->location2a ) starsystem->location2a = STRALLOC( "" ); if( !starsystem->location3a ) starsystem->location3a = STRALLOC( "" ); if( !starsystem->location1b ) starsystem->location1b = STRALLOC( "" ); if( !starsystem->location2b ) starsystem->location2b = STRALLOC( "" ); if( !starsystem->location3b ) starsystem->location3b = STRALLOC( "" ); if( !starsystem->location1c ) starsystem->location1c = STRALLOC( "" ); if( !starsystem->location2c ) starsystem->location2c = STRALLOC( "" ); if( !starsystem->location3c ) starsystem->location3c = STRALLOC( "" ); if( !starsystem->planet1 ) starsystem->planet1 = STRALLOC( "" ); if( !starsystem->planet2 ) starsystem->planet2 = STRALLOC( "" ); if( !starsystem->planet3 ) starsystem->planet3 = STRALLOC( "" ); if( !starsystem->star1 ) starsystem->star1 = STRALLOC( "" ); if( !starsystem->star2 ) starsystem->star2 = STRALLOC( "" ); return; } break; case 'F': KEY( "Filename", starsystem->filename, fread_string_nohash( fp ) ); break; case 'G': KEY( "Gravitys1", starsystem->gravitys1, fread_number( fp ) ); KEY( "Gravitys2", starsystem->gravitys2, fread_number( fp ) ); KEY( "Gravityp1", starsystem->gravityp1, fread_number( fp ) ); KEY( "Gravityp2", starsystem->gravityp2, fread_number( fp ) ); KEY( "Gravityp3", starsystem->gravityp3, fread_number( fp ) ); break; case 'L': KEY( "Location1a", starsystem->location1a, fread_string( fp ) ); KEY( "Location2a", starsystem->location2a, fread_string( fp ) ); KEY( "Location3a", starsystem->location3a, fread_string( fp ) ); KEY( "Location1b", starsystem->location1b, fread_string( fp ) ); KEY( "Location2b", starsystem->location2b, fread_string( fp ) ); KEY( "Location3b", starsystem->location3b, fread_string( fp ) ); KEY( "Location1c", starsystem->location1c, fread_string( fp ) ); KEY( "Location2c", starsystem->location2c, fread_string( fp ) ); KEY( "Location3c", starsystem->location3c, fread_string( fp ) ); break; case 'N': KEY( "Name", starsystem->name, fread_string( fp ) ); break; case 'P': KEY( "Planet1", starsystem->planet1, fread_string( fp ) ); KEY( "Planet2", starsystem->planet2, fread_string( fp ) ); KEY( "Planet3", starsystem->planet3, fread_string( fp ) ); KEY( "P1x", starsystem->p1x, fread_number( fp ) ); KEY( "P1y", starsystem->p1y, fread_number( fp ) ); KEY( "P1z", starsystem->p1z, fread_number( fp ) ); KEY( "P2x", starsystem->p2x, fread_number( fp ) ); KEY( "P2y", starsystem->p2y, fread_number( fp ) ); KEY( "P2z", starsystem->p2z, fread_number( fp ) ); KEY( "P3x", starsystem->p3x, fread_number( fp ) ); KEY( "P3y", starsystem->p3y, fread_number( fp ) ); KEY( "P3z", starsystem->p3z, fread_number( fp ) ); break; case 'S': KEY( "Star1", starsystem->star1, fread_string( fp ) ); KEY( "Star2", starsystem->star2, fread_string( fp ) ); KEY( "S1x", starsystem->s1x, fread_number( fp ) ); KEY( "S1y", starsystem->s1y, fread_number( fp ) ); KEY( "S1z", starsystem->s1z, fread_number( fp ) ); KEY( "S2x", starsystem->s2x, fread_number( fp ) ); KEY( "S2y", starsystem->s2y, fread_number( fp ) ); KEY( "S2z", starsystem->s2z, fread_number( fp ) ); case 'X': KEY( "Xpos", starsystem->xpos, fread_number( fp ) ); case 'Y': KEY( "Ypos", starsystem->ypos, fread_number( fp ) ); } if( !fMatch ) { sprintf( buf, "Fread_starsystem: no match: %s", word ); bug( buf, 0 ); } } } /* * Load a starsystem file */ bool load_starsystem( char *starsystemfile ) { char filename[256]; SPACE_DATA *starsystem; FILE *fp; bool found; CREATE( starsystem, SPACE_DATA, 1 ); found = FALSE; sprintf( filename, "%s%s", SPACE_DIR, starsystemfile ); if( ( fp = fopen( filename, "r" ) ) != NULL ) { found = TRUE; LINK( starsystem, first_starsystem, last_starsystem, next, prev ); for( ;; ) { char letter; char *word; letter = fread_letter( fp ); if( letter == '*' ) { fread_to_eol( fp ); continue; } if( letter != '#' ) { bug( "Load_starsystem_file: # not found.", 0 ); break; } word = fread_word( fp ); if( !str_cmp( word, "SPACE" ) ) { fread_starsystem( starsystem, fp ); break; } else if( !str_cmp( word, "END" ) ) break; else { char buf[MAX_STRING_LENGTH]; sprintf( buf, "Load_starsystem_file: bad section: %s.", word ); bug( buf, 0 ); break; } } fclose( fp ); } if( !( found ) ) DISPOSE( starsystem ); return found; } /* * Load in all the starsystem files. */ void load_space( ) { FILE *fpList; char *filename; char starsystemlist[256]; char buf[MAX_STRING_LENGTH]; first_starsystem = NULL; last_starsystem = NULL; log_string( "Loading space..." ); sprintf( starsystemlist, "%s%s", SPACE_DIR, SPACE_LIST ); fclose( fpReserve ); if( ( fpList = fopen( starsystemlist, "r" ) ) == NULL ) { perror( starsystemlist ); exit( 1 ); } for( ;; ) { filename = feof( fpList ) ? "$" : fread_word( fpList ); if( filename[0] == '$' ) break; if( !load_starsystem( filename ) ) { sprintf( buf, "Cannot load starsystem file: %s", filename ); bug( buf, 0 ); } } fclose( fpList ); log_string( " Done starsystems " ); fpReserve = fopen( NULL_FILE, "r" ); return; } /* * Read in actual ship data. */ #if defined(KEY) #undef KEY #endif #define KEY( literal, field, value ) \ if ( !str_cmp( word, literal ) ) \ { \ field = value; \ fMatch = TRUE; \ break; \ } void fread_ship( SHIP_DATA * ship, FILE * fp ) { char buf[MAX_STRING_LENGTH]; char *word; bool fMatch; int dummy_number; for( ;; ) { word = feof( fp ) ? "End" : fread_word( fp ); fMatch = FALSE; switch ( UPPER( word[0] ) ) { case '*': fMatch = TRUE; fread_to_eol( fp ); break; case 'A': KEY( "Astro_array", ship->astro_array, fread_number( fp ) ); break; case 'C': KEY( "Cost", ship->cost, fread_number( fp ) ); KEY( "Cockpit", ship->cockpit, fread_number( fp ) ); KEY( "Coseat", ship->coseat, fread_number( fp ) ); KEY( "Class", ship->class, fread_number( fp ) ); KEY( "Copilot", ship->copilot, fread_string( fp ) ); KEY( "Comm", ship->comm, fread_number( fp ) ); KEY( "Chaff", ship->chaff, fread_number( fp ) ); break; case 'D': KEY( "Description", ship->description, fread_string( fp ) ); break; case 'E': KEY( "Engineroom", ship->engineroom, fread_number( fp ) ); KEY( "Entrance", ship->entrance, fread_number( fp ) ); KEY( "Energy", ship->energy, fread_number( fp ) ); if( !str_cmp( word, "End" ) ) { if( !ship->home ) ship->home = STRALLOC( "" ); if( !ship->name ) ship->name = STRALLOC( "" ); if( !ship->owner ) ship->owner = STRALLOC( "" ); if( !ship->description ) ship->description = STRALLOC( "" ); if( !ship->copilot ) ship->copilot = STRALLOC( "" ); if( !ship->pilot ) ship->pilot = STRALLOC( "" ); if( ship->shipstate != SHIP_DISABLED ) ship->shipstate = SHIP_DOCKED; if( ship->statet0 != LASER_DAMAGED ) ship->statet0 = LASER_READY; if( ship->statet1 != LASER_DAMAGED ) ship->statet1 = LASER_READY; if( ship->statet2 != LASER_DAMAGED ) ship->statet2 = LASER_READY; if( ship->missilestate != MISSILE_DAMAGED ) ship->missilestate = MISSILE_READY; if( ship->shipyard <= 0 ) ship->shipyard = ROOM_LIMBO_SHIPYARD; if( ship->lastdoc <= 0 ) ship->lastdoc = ship->shipyard; ship->bayopen = TRUE; ship->autopilot = FALSE; ship->hatchopen = FALSE; if( ship->navseat <= 0 ) ship->navseat = ship->cockpit; if( ship->gunseat <= 0 ) ship->gunseat = ship->cockpit; if( ship->coseat <= 0 ) ship->coseat = ship->cockpit; if( ship->pilotseat <= 0 ) ship->pilotseat = ship->cockpit; if( ship->missiletype == 1 ) { ship->torpedos = ship->missiles; /* for back compatability */ ship->missiles = 0; } ship->starsystem = NULL; ship->energy = ship->maxenergy; ship->hull = ship->maxhull; ship->in_room = NULL; ship->next_in_room = NULL; ship->prev_in_room = NULL; return; } break; case 'F': KEY( "Filename", ship->filename, fread_string_nohash( fp ) ); KEY( "Firstroom", ship->firstroom, fread_number( fp ) ); break; case 'G': KEY( "Gunseat", ship->gunseat, fread_number( fp ) ); break; case 'H': KEY( "Home", ship->home, fread_string( fp ) ); KEY( "Hyperspeed", ship->hyperspeed, fread_number( fp ) ); KEY( "Hull", ship->hull, fread_number( fp ) ); KEY( "Hanger", ship->hanger, fread_number( fp ) ); break; case 'L': KEY( "Laserstr", ship->lasers, ( sh_int ) ( fread_number( fp ) / 10 ) ); KEY( "Lasers", ship->lasers, fread_number( fp ) ); KEY( "Lastdoc", ship->lastdoc, fread_number( fp ) ); KEY( "Lastroom", ship->lastroom, fread_number( fp ) ); break; case 'M': KEY( "Manuever", ship->manuever, fread_number( fp ) ); KEY( "Maxmissiles", ship->maxmissiles, fread_number( fp ) ); KEY( "Maxtorpedos", ship->maxtorpedos, fread_number( fp ) ); KEY( "Maxrockets", ship->maxrockets, fread_number( fp ) ); KEY( "Missiles", ship->missiles, fread_number( fp ) ); KEY( "Missiletype", ship->missiletype, fread_number( fp ) ); KEY( "Maxshield", ship->maxshield, fread_number( fp ) ); KEY( "Maxenergy", ship->maxenergy, fread_number( fp ) ); KEY( "Missilestate", ship->missilestate, fread_number( fp ) ); KEY( "Maxhull", ship->maxhull, fread_number( fp ) ); KEY( "Maxchaff", ship->maxchaff, fread_number( fp ) ); break; case 'N': KEY( "Name", ship->name, fread_string( fp ) ); KEY( "Navseat", ship->navseat, fread_number( fp ) ); break; case 'O': KEY( "Owner", ship->owner, fread_string( fp ) ); KEY( "Objectnum", dummy_number, fread_number( fp ) ); break; case 'P': KEY( "Pilot", ship->pilot, fread_string( fp ) ); KEY( "Pilotseat", ship->pilotseat, fread_number( fp ) ); break; case 'R': KEY( "Realspeed", ship->realspeed, fread_number( fp ) ); KEY( "Rockets", ship->rockets, fread_number( fp ) ); break; case 'S': KEY( "Shipyard", ship->shipyard, fread_number( fp ) ); KEY( "Sensor", ship->sensor, fread_number( fp ) ); KEY( "Shield", ship->shield, fread_number( fp ) ); KEY( "Shipstate", ship->shipstate, fread_number( fp ) ); KEY( "Statet0", ship->statet0, fread_number( fp ) ); KEY( "Statet1", ship->statet1, fread_number( fp ) ); KEY( "Statet2", ship->statet2, fread_number( fp ) ); break; case 'T': KEY( "Type", ship->type, fread_number( fp ) ); KEY( "Tractorbeam", ship->tractorbeam, fread_number( fp ) ); KEY( "Turret1", ship->turret1, fread_number( fp ) ); KEY( "Turret2", ship->turret2, fread_number( fp ) ); KEY( "Torpedos", ship->torpedos, fread_number( fp ) ); break; } if( !fMatch ) { sprintf( buf, "Fread_ship: no match: %s", word ); bug( buf, 0 ); } } } /* * Load a ship file */ bool load_ship_file( char *shipfile ) { char filename[256]; SHIP_DATA *ship; FILE *fp; bool found; ROOM_INDEX_DATA *pRoomIndex; CREATE( ship, SHIP_DATA, 1 ); found = FALSE; sprintf( filename, "%s%s", SHIP_DIR, shipfile ); if( ( fp = fopen( filename, "r" ) ) != NULL ) { found = TRUE; for( ;; ) { char letter; char *word; letter = fread_letter( fp ); if( letter == '*' ) { fread_to_eol( fp ); continue; } if( letter != '#' ) { bug( "Load_ship_file: # not found.", 0 ); break; } word = fread_word( fp ); if( !str_cmp( word, "SHIP" ) ) { fread_ship( ship, fp ); break; } else if( !str_cmp( word, "END" ) ) break; else { char buf[MAX_STRING_LENGTH]; sprintf( buf, "Load_ship_file: bad section: %s.", word ); bug( buf, 0 ); break; } } fclose( fp ); } if( !( found ) ) DISPOSE( ship ); else { LINK( ship, first_ship, last_ship, next, prev ); if( !str_cmp( "Public", ship->owner ) || ship->type == MOB_SHIP ) { if( ship->class != SHIP_PLATFORM && ship->type != MOB_SHIP && ship->class != CAPITAL_SHIP ) { extract_ship( ship ); ship_to_room( ship, ship->shipyard ); ship->location = ship->shipyard; ship->lastdoc = ship->shipyard; ship->shipstate = SHIP_DOCKED; } ship->currspeed = 0; ship->energy = ship->maxenergy; ship->chaff = ship->maxchaff; ship->hull = ship->maxhull; ship->shield = 0; ship->statet1 = LASER_READY; ship->statet2 = LASER_READY; ship->statet0 = LASER_READY; ship->missilestate = LASER_READY; ship->currjump = NULL; ship->target0 = NULL; ship->target1 = NULL; ship->target2 = NULL; ship->hatchopen = FALSE; ship->bayopen = TRUE; ship->missiles = ship->maxmissiles; ship->torpedos = ship->maxtorpedos; ship->rockets = ship->maxrockets; ship->autorecharge = FALSE; ship->autotrack = FALSE; ship->autospeed = FALSE; } else if( ship->cockpit == ROOM_SHUTTLE_BUS || ship->cockpit == ROOM_SHUTTLE_BUS_2 || ship->cockpit == ROOM_SENATE_SHUTTLE || ship->cockpit == ROOM_EARTH_TURBOCAR || ship->cockpit == ROOM_CORUSCANT_SHUTTLE ) { } else if( ( pRoomIndex = get_room_index( ship->lastdoc ) ) != NULL && ship->class != CAPITAL_SHIP && ship->class != SHIP_PLATFORM ) { LINK( ship, pRoomIndex->first_ship, pRoomIndex->last_ship, next_in_room, prev_in_room ); ship->in_room = pRoomIndex; ship->location = ship->lastdoc; } if( ( pRoomIndex = get_room_index( ship->lastdoc ) ) == NULL && ship->class != CAPITAL_SHIP && ship->class != SHIP_PLATFORM ) { pRoomIndex = get_room_index( 2 ); LINK( ship, pRoomIndex->first_ship, pRoomIndex->last_ship, next_in_room, prev_in_room ); ship->in_room = pRoomIndex; ship->location = 2; } if( ship->class == SHIP_PLATFORM || ship->type == MOB_SHIP || ship->class == CAPITAL_SHIP ) { 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 = 1; ship->hy = 1; ship->hz = 1; ship->shipstate = SHIP_READY; ship->autopilot = TRUE; ship->autorecharge = TRUE; ship->shield = ship->maxshield; } } return found; } /* * Load in all the ship files. */ void load_ships( ) { FILE *fpList; char *filename; char shiplist[256]; char buf[MAX_STRING_LENGTH]; first_ship = NULL; last_ship = NULL; first_missile = NULL; last_missile = NULL; log_string( "Loading ships..." ); sprintf( shiplist, "%s%s", SHIP_DIR, SHIP_LIST ); fclose( fpReserve ); if( ( fpList = fopen( shiplist, "r" ) ) == NULL ) { perror( shiplist ); exit( 1 ); } for( ;; ) { filename = feof( fpList ) ? "$" : fread_word( fpList ); if( filename[0] == '$' ) break; if( !load_ship_file( filename ) ) { sprintf( buf, "Cannot load ship file: %s", filename ); bug( buf, 0 ); } } fclose( fpList ); log_string( " Done ships " ); fpReserve = fopen( NULL_FILE, "r" ); return; } 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, int 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; } void ship_to_starsystem( SHIP_DATA * ship, SPACE_DATA * starsystem ) { if( starsystem == NULL ) return; if( ship == NULL ) return; if( starsystem->first_ship == NULL ) starsystem->first_ship = ship; if( starsystem->last_ship ) { starsystem->last_ship->next_in_starsystem = ship; ship->prev_in_starsystem = starsystem->last_ship; } starsystem->last_ship = ship; ship->starsystem = starsystem; } void landship( SHIP_DATA * ship, char *arg ) { SHIP_DATA *target; char buf[MAX_STRING_LENGTH]; int destination = 0; if( !str_prefix( arg, ship->starsystem->location3a ) ) destination = ship->starsystem->doc3a; if( !str_prefix( arg, ship->starsystem->location3b ) ) destination = ship->starsystem->doc3b; if( !str_prefix( arg, ship->starsystem->location3c ) ) destination = ship->starsystem->doc3c; if( !str_prefix( arg, ship->starsystem->location2a ) ) destination = ship->starsystem->doc2a; if( !str_prefix( arg, ship->starsystem->location2b ) ) destination = ship->starsystem->doc2b; if( !str_prefix( arg, ship->starsystem->location2c ) ) destination = ship->starsystem->doc2c; if( !str_prefix( arg, ship->starsystem->location1a ) ) destination = ship->starsystem->doc1a; if( !str_prefix( arg, ship->starsystem->location1b ) ) destination = ship->starsystem->doc1b; if( !str_prefix( arg, ship->starsystem->location1c ) ) destination = ship->starsystem->doc1c; target = get_ship_here( arg, ship->starsystem ); if( target != ship && target != NULL && target->bayopen && ( ship->class != MIDSIZE_SHIP || target->class != MIDSIZE_SHIP ) ) destination = target->hanger; if( !ship_to_room( ship, destination ) ) { echo_to_room( AT_YELLOW, get_room_index( ship->pilotseat ), "Could not complete aproach. Landing aborted." ); echo_to_ship( AT_YELLOW, ship, "The ship pulls back up out of its landing sequence." ); if( ship->shipstate != SHIP_DISABLED ) ship->shipstate = SHIP_READY; return; } echo_to_room( AT_YELLOW, get_room_index( ship->pilotseat ), "Landing sequence complete." ); echo_to_ship( AT_YELLOW, ship, "You feel a slight thud as the ship sets down on the ground." ); sprintf( buf, "%s disapears from your scanner.", ship->name ); echo_to_system( AT_YELLOW, ship, buf, NULL ); ship->location = destination; ship->lastdoc = ship->location; if( ship->shipstate != SHIP_DISABLED ) ship->shipstate = SHIP_DOCKED; ship_from_starsystem( ship, ship->starsystem ); sprintf( buf, "%s lands on the platform.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); ship->energy = ship->energy - 25 - 25 * ship->class; if( !str_cmp( "Public", ship->owner ) ) { ship->energy = ship->maxenergy; ship->chaff = ship->maxchaff; ship->missiles = ship->maxmissiles; ship->torpedos = ship->maxtorpedos; ship->rockets = ship->maxrockets; ship->shield = 0; ship->autorecharge = FALSE; ship->autotrack = FALSE; ship->autospeed = FALSE; ship->hull = ship->maxhull; ship->missilestate = MISSILE_READY; ship->statet0 = LASER_READY; ship->statet1 = LASER_READY; ship->statet2 = LASER_READY; ship->shipstate = SHIP_DOCKED; echo_to_cockpit( AT_YELLOW, ship, "Repairing and refueling ship..." ); } save_ship( ship ); } void launchship( SHIP_DATA * ship ) { char buf[MAX_STRING_LENGTH]; SHIP_DATA *target; int plusminus; ship_to_starsystem( ship, starsystem_from_vnum( ship->location ) ); if( ship->starsystem == NULL ) { echo_to_room( AT_YELLOW, get_room_index( ship->pilotseat ), "Launch path blocked .. Launch aborted." ); echo_to_ship( AT_YELLOW, ship, "The ship slowly sets back back down on the landing pad." ); sprintf( buf, "%s slowly sets back down.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); ship->shipstate = SHIP_DOCKED; return; } extract_ship( ship ); ship->location = 0; if( ship->shipstate != SHIP_DISABLED ) ship->shipstate = SHIP_READY; plusminus = number_range( -1, 2 ); if( plusminus > 0 ) ship->hx = 1; else ship->hx = -1; plusminus = number_range( -1, 2 ); if( plusminus > 0 ) ship->hy = 1; else ship->hy = -1; plusminus = number_range( -1, 2 ); if( plusminus > 0 ) ship->hz = 1; else ship->hz = -1; if( ship->lastdoc == ship->starsystem->doc1a || ship->lastdoc == ship->starsystem->doc1b || ship->lastdoc == ship->starsystem->doc1c ) { ship->vx = ship->starsystem->p1x; ship->vy = ship->starsystem->p1y; ship->vz = ship->starsystem->p1z; } else if( ship->lastdoc == ship->starsystem->doc2a || ship->lastdoc == ship->starsystem->doc2b || ship->lastdoc == ship->starsystem->doc2c ) { ship->vx = ship->starsystem->p2x; ship->vy = ship->starsystem->p2y; ship->vz = ship->starsystem->p2z; } else if( ship->lastdoc == ship->starsystem->doc3a || ship->lastdoc == ship->starsystem->doc3b || ship->lastdoc == ship->starsystem->doc3c ) { ship->vx = ship->starsystem->p3x; ship->vy = ship->starsystem->p3y; ship->vz = ship->starsystem->p3z; } else { for( target = ship->starsystem->first_ship; target; target = target->next_in_starsystem ) { if( ship->lastdoc == target->hanger ) { ship->vx = target->vx; ship->vy = target->vy; ship->vz = target->vz; } } } ship->energy -= ( 100 + 100 * ship->class ); ship->vx += ( ship->hx * ship->currspeed * 2 ); ship->vy += ( ship->hy * ship->currspeed * 2 ); ship->vz += ( ship->hz * ship->currspeed * 2 ); echo_to_room( AT_GREEN, get_room_index( ship->lastdoc ), "Launch complete.\n\r" ); echo_to_ship( AT_YELLOW, ship, "The ship leaves the platform far behind as it flies into space." ); sprintf( buf, "%s enters the starsystem at %.0f %.0f %.0f", ship->name, ship->vx, ship->vy, ship->vz ); echo_to_system( AT_YELLOW, ship, buf, NULL ); sprintf( buf, "%s lifts off into space.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->lastdoc ), buf ); } void destroy_ship( SHIP_DATA * ship, CHAR_DATA * ch ) { char buf[MAX_STRING_LENGTH]; int roomnum; ROOM_INDEX_DATA *room; OBJ_DATA *robj; CHAR_DATA *rch; sprintf( buf, "%s explodes in a blinding flash of light!", ship->name ); echo_to_system( AT_WHITE + AT_BLINK, ship, buf, NULL ); if( ship->class == FIGHTER_SHIP ) echo_to_ship( AT_WHITE + AT_BLINK, ship, "A blinding flahs of light burns your eyes..." ); echo_to_ship( AT_WHITE, ship, "But before you have a chance to scream...\n\rYou are ripped apart as your spacecraft explodes..." ); for( roomnum = ship->firstroom; roomnum <= ship->lastroom; roomnum++ ) { room = get_room_index( roomnum ); if( room != NULL ) { rch = room->first_person; while( rch ) { if( IS_IMMORTAL( rch ) ) { char_from_room( rch ); char_to_room( rch, get_room_index( wherehome( rch ) ) ); } else { if( ch ) { raw_kill( ch, rch ); spaceDeath = TRUE; } else { raw_kill( rch, rch ); spaceDeath = TRUE; } } rch = room->first_person; } for( robj = room->first_content; robj; robj = robj->next_content ) { separate_obj( robj ); extract_obj( robj ); } } } resetship( ship ); } void save_ship( SHIP_DATA * ship ) { FILE *fp; char filename[256]; char buf[MAX_STRING_LENGTH]; if( !ship ) { bug( "save_ship: null ship pointer!", 0 ); return; } if( !ship->filename || ship->filename[0] == '\0' ) { sprintf( buf, "save_ship: %s has no filename", ship->name ); bug( buf, 0 ); return; } sprintf( filename, "%s%s", SHIP_DIR, ship->filename ); fclose( fpReserve ); if( ( fp = fopen( filename, "w" ) ) == NULL ) { bug( "save_ship: fopen", 0 ); perror( filename ); } else { fprintf( fp, "#SHIP\n" ); fprintf( fp, "Name %s~\n", ship->name ); fprintf( fp, "Filename %s~\n", ship->filename ); fprintf( fp, "Description %s~\n", ship->description ); fprintf( fp, "Owner %s~\n", ship->owner ); fprintf( fp, "Pilot %s~\n", ship->pilot ); fprintf( fp, "Copilot %s~\n", ship->copilot ); fprintf( fp, "Class %d\n", ship->class ); fprintf( fp, "Tractorbeam %d\n", ship->tractorbeam ); fprintf( fp, "Shipyard %d\n", ship->shipyard ); fprintf( fp, "Hanger %d\n", ship->hanger ); fprintf( fp, "Turret1 %d\n", ship->turret1 ); fprintf( fp, "Turret2 %d\n", ship->turret2 ); fprintf( fp, "Statet0 %d\n", ship->statet0 ); fprintf( fp, "Statet1 %d\n", ship->statet1 ); fprintf( fp, "Statet2 %d\n", ship->statet2 ); fprintf( fp, "Lasers %d\n", ship->lasers ); fprintf( fp, "Missiles %d\n", ship->missiles ); fprintf( fp, "Maxmissiles %d\n", ship->maxmissiles ); fprintf( fp, "Rockets %d\n", ship->rockets ); fprintf( fp, "Maxrockets %d\n", ship->maxrockets ); fprintf( fp, "Torpedos %d\n", ship->torpedos ); fprintf( fp, "Maxtorpedos %d\n", ship->maxtorpedos ); fprintf( fp, "Lastdoc %d\n", ship->lastdoc ); fprintf( fp, "Firstroom %d\n", ship->firstroom ); fprintf( fp, "Lastroom %d\n", ship->lastroom ); 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, "Comm %d\n", ship->comm ); fprintf( fp, "Chaff %d\n", ship->chaff ); fprintf( fp, "Maxchaff %d\n", ship->maxchaff ); fprintf( fp, "Sensor %d\n", ship->sensor ); fprintf( fp, "Astro_array %d\n", ship->astro_array ); fprintf( fp, "Realspeed %d\n", ship->realspeed ); fprintf( fp, "Type %d\n", ship->type ); fprintf( fp, "Cockpit %d\n", ship->cockpit ); fprintf( fp, "Coseat %d\n", ship->coseat ); fprintf( fp, "Pilotseat %d\n", ship->pilotseat ); fprintf( fp, "Gunseat %d\n", ship->gunseat ); fprintf( fp, "Navseat %d\n", ship->navseat ); fprintf( fp, "Engineroom %d\n", ship->engineroom ); fprintf( fp, "Entrance %d\n", ship->entrance ); 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, "Cost %d\n", ship->cost ); 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 new_missile( SHIP_DATA * ship, SHIP_DATA * target, CHAR_DATA * ch, int missiletype ) { SPACE_DATA *starsystem; MISSILE_DATA *missile; if( ship == NULL ) return; if( target == NULL ) return; if( ( starsystem = ship->starsystem ) == NULL ) return; CREATE( missile, MISSILE_DATA, 1 ); LINK( missile, first_missile, last_missile, next, prev ); missile->target = target; missile->fired_from = ship; if( ch ) missile->fired_by = STRALLOC( ch->name ); else missile->fired_by = STRALLOC( "" ); missile->missiletype = missiletype; missile->age = 0; if( missile->missiletype == HEAVY_BOMB ) missile->speed = 20; else if( missile->missiletype == PROTON_TORPEDO ) missile->speed = 200; else if( missile->missiletype == CONCUSSION_MISSILE ) missile->speed = 300; else missile->speed = 50; 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 resetship( SHIP_DATA * ship ) { ship->shipstate = SHIP_READY; if( ship->class != SHIP_PLATFORM && ship->type != MOB_SHIP ) { extract_ship( ship ); ship_to_room( ship, ship->shipyard ); ship->location = ship->shipyard; ship->lastdoc = ship->shipyard; ship->shipstate = SHIP_DOCKED; } if( ship->starsystem ) ship_from_starsystem( ship, ship->starsystem ); ship->currspeed = 0; ship->energy = ship->maxenergy; ship->chaff = ship->maxchaff; ship->hull = ship->maxhull; ship->shield = 0; ship->statet1 = LASER_READY; ship->statet2 = LASER_READY; ship->statet0 = LASER_READY; ship->missilestate = LASER_READY; ship->currjump = NULL; ship->target0 = NULL; ship->target1 = NULL; ship->target2 = NULL; ship->hatchopen = FALSE; ship->bayopen = TRUE; ship->missiles = ship->maxmissiles; ship->torpedos = ship->maxtorpedos; ship->rockets = ship->maxrockets; ship->autorecharge = FALSE; ship->autotrack = FALSE; ship->autospeed = FALSE; if( str_cmp( "Public", ship->owner ) && ship->type != MOB_SHIP ) { STRFREE( ship->owner ); ship->owner = STRALLOC( "" ); STRFREE( ship->pilot ); ship->pilot = STRALLOC( "" ); STRFREE( ship->copilot ); ship->copilot = STRALLOC( "" ); } if( ship->type == SHIP_REPUBLIC || ( ship->type == MOB_SHIP && !str_cmp( ship->owner, "the new republic" ) ) ) { STRFREE( ship->home ); ship->home = STRALLOC( "coruscant" ); } else if( ship->type == SHIP_IMPERIAL || ( ship->type == MOB_SHIP && !str_cmp( ship->owner, "the empire" ) ) ) { STRFREE( ship->home ); ship->home = STRALLOC( "byss" ); } else if( ship->type == SHIP_CIVILIAN ) { STRFREE( ship->home ); ship->home = STRALLOC( "corperate" ); } save_ship( ship ); } void update_traffic( ) { SHIP_DATA *shuttle, *senate; SHIP_DATA *turbocar; char buf[MAX_STRING_LENGTH]; shuttle = ship_from_cockpit( ROOM_CORUSCANT_SHUTTLE ); senate = ship_from_cockpit( ROOM_SENATE_SHUTTLE ); if( senate != NULL && shuttle != NULL ) { switch ( corus_shuttle ) { default: corus_shuttle++; break; case 0: land_bus( shuttle, STOP_PLANET ); land_bus( senate, SENATEPAD ); corus_shuttle++; echo_to_ship( AT_CYAN, shuttle, "Welcome to Menari Spaceport." ); echo_to_ship( AT_CYAN, senate, "Welcome to The Senate Halls." ); break; case 4: launch_bus( shuttle ); launch_bus( senate ); corus_shuttle++; break; case 5: land_bus( shuttle, STOP_SHIPYARD ); land_bus( senate, OUTERPAD ); echo_to_ship( AT_CYAN, shuttle, "Welcome to Coruscant Shipyard." ); echo_to_ship( AT_CYAN, senate, "Welcome to The Outer System Landing Area." ); corus_shuttle++; break; case 9: launch_bus( shuttle ); launch_bus( senate ); corus_shuttle++; break; } if( corus_shuttle >= 10 ) corus_shuttle = 0; } turbocar = ship_from_cockpit( ROOM_EARTH_TURBOCAR ); if( turbocar != NULL ) // && get_room_index(turbocar->location) != NULL) Blah blah blah --Saiyr { turbocar_delay++; if( turbocar_delay == 2 ) { if( get_room_index( turbocar->location ) ) { sprintf( buf, "The turbocar doors close and it speeds out of the station." ); echo_to_room( AT_YELLOW, get_room_index( turbocar->location ), buf ); } extract_ship( turbocar ); turbocar->location = 0; } else if( turbocar_delay >= 4 ) { ship_to_room( turbocar, station_vnum[turbocar_stop] ); echo_to_ship( AT_YELLOW, turbocar, "The turbocar makes a quick journey to the next station." ); turbocar->location = station_vnum[turbocar_stop]; turbocar->lastdoc = turbocar->location; turbocar->shipstate = SHIP_DOCKED; if( turbocar->starsystem ) ship_from_starsystem( turbocar, turbocar->starsystem ); sprintf( buf, "A turbocar pulls into the platform and the doors slide open." ); echo_to_room( AT_YELLOW, get_room_index( turbocar->location ), buf ); sprintf( buf, "Welcome to %s.", station_name[turbocar_stop] ); echo_to_ship( AT_CYAN, turbocar, buf ); turbocar->hatchopen = TRUE; turbocar_stop++; if( turbocar_stop >= MAX_STATION ) turbocar_stop = 0; turbocar_delay = 0; } } } void update_bus( ) { SHIP_DATA *ship; SHIP_DATA *ship2; SHIP_DATA *target; SHIP_DATA *target2; int destination; int destination2; char buf[MAX_STRING_LENGTH]; ship = ship_from_cockpit( ROOM_SHUTTLE_BUS ); ship2 = ship_from_cockpit( ROOM_SHUTTLE_BUS_2 ); if( ( ship == NULL ) || ( ship2 == NULL ) ) return; switch ( bus_pos ) { case 0: target = ship_from_hanger( bus_vnum[bus_planet] ); if( target != NULL && !target->starsystem ) { sprintf( buf, "An electronic voice says, 'Cannot land at %s ... it seems to have dissapeared.'", bus_stop[bus_planet] ); echo_to_ship( AT_CYAN, ship, buf ); bus_pos = 5; } bus_pos++; break; case 6: launch_bus( ship ); bus_pos++; break; case 7: echo_to_ship( AT_YELLOW, ship, "The ship lurches slightly as it makes the jump to lightspeed." ); bus_pos++; break; case 9: echo_to_ship( AT_YELLOW, ship, "The ship lurches slightly as it comes out of hyperspace.." ); bus_pos++; break; case 1: destination = bus_vnum[bus_planet]; if( !land_bus( ship, destination ) ) { sprintf( buf, "An electronic voice says, 'Oh My, %s seems to have dissapeared.'", bus_stop[bus_planet] ); echo_to_ship( AT_CYAN, ship, buf ); echo_to_ship( AT_CYAN, ship, "An electronic voice says, 'I do hope it wasn't a superlaser. Landing aborted.'" ); } else { sprintf( buf, "An electronic voice says, 'Welcome to %s'", bus_stop[bus_planet] ); echo_to_ship( AT_CYAN, ship, buf ); echo_to_ship( AT_CYAN, ship, "It continues, 'Please exit through the main ramp. Enjoy your stay.'" ); } bus_pos++; break; case 5: sprintf( buf, "It continues, 'Next stop, %s'", bus_stop[bus_planet + 1] ); echo_to_ship( AT_CYAN, ship, "An electronic voice says, 'Preparing for launch.'" ); echo_to_ship( AT_CYAN, ship, buf ); bus_pos++; break; default: bus_pos++; break; } switch ( bus2_pos ) { case 0: target2 = ship_from_hanger( bus_vnum2[bus2_planet] ); if( target2 != NULL && !target2->starsystem ) { sprintf( buf, "An electronic voice says, 'Cannot land at %s ... it seems to have dissapeared.'", bus_stop2[bus2_planet] ); echo_to_ship( AT_CYAN, ship2, buf ); bus2_pos = 5; } bus2_pos++; break; case 6: launch_bus( ship2 ); bus2_pos++; break; case 7: echo_to_ship( AT_YELLOW, ship2, "The ship lurches slightly as it makes the jump to lightspeed." ); bus2_pos++; break; case 9: echo_to_ship( AT_YELLOW, ship2, "The ship lurches slightly as it comes out of hyperspace.." ); bus2_pos++; break; case 1: destination2 = bus_vnum2[bus2_planet]; if( !land_bus( ship2, destination2 ) ) { sprintf( buf, "An electronic voice says, 'Oh My, %s seems to have dissapeared.'", bus_stop2[bus2_planet] ); echo_to_ship( AT_CYAN, ship2, buf ); echo_to_ship( AT_CYAN, ship2, "An electronic voice says, 'I do hope it wasn't a superlaser. Landing aborted.'" ); } else { sprintf( buf, "An electronic voice says, 'Welcome to %s'", bus_stop2[bus2_planet] ); echo_to_ship( AT_CYAN, ship2, buf ); echo_to_ship( AT_CYAN, ship2, "It continues, 'Please exit through the main ramp. Enjoy your stay.'" ); } bus2_pos++; break; case 5: sprintf( buf, "It continues, 'Next stop, %s'", bus_stop2[bus2_planet + 1] ); echo_to_ship( AT_CYAN, ship2, "An electronic voice says, 'Preparing for launch.'" ); echo_to_ship( AT_CYAN, ship2, buf ); bus2_pos++; break; default: bus2_pos++; break; } if( bus_pos >= 10 ) { bus_pos = 0; bus_planet++; } if( bus2_pos >= 10 ) { bus2_pos = 0; bus2_planet++; } if( bus_planet >= MAX_BUS_STOP ) bus_planet = 0; if( bus2_planet >= MAX_BUS_STOP2 ) bus2_planet = 0; } void move_ships( ) { SHIP_DATA *ship; MISSILE_DATA *missile; MISSILE_DATA *m_next; SHIP_DATA *target; float dx, dy, dz, change; char buf[MAX_STRING_LENGTH]; CHAR_DATA *ch; bool ch_found = FALSE; for( missile = first_missile; missile; missile = m_next ) { m_next = missile->next; ship = missile->fired_from; target = missile->target; if( 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( abs( missile->mx ) - abs( target->vx ) <= 20 && abs( missile->mx ) - abs( target->vx ) >= -20 && abs( missile->my ) - abs( target->vy ) <= 20 && abs( missile->my ) - abs( target->vy ) >= -20 && abs( missile->mz ) - abs( target->vz ) <= 20 && abs( missile->mz ) - abs( target->vz ) >= -20 ) { if( target->chaff_released <= 0 ) { echo_to_room( AT_YELLOW, get_room_index( ship->gunseat ), "Your missile hits its target dead on!" ); echo_to_cockpit( AT_BLOOD, target, "The ship is hit by a missile." ); echo_to_ship( AT_RED, target, "A loud explosion shakes thee ship violently!" ); sprintf( buf, "You see a small explosion as %s is hit by a missile", target->name ); echo_to_system( AT_ORANGE, target, buf, ship ); for( ch = first_char; ch; ch = ch->next ) if( !IS_NPC( ch ) && nifty_is_name( missile->fired_by, ch->name ) ) { ch_found = TRUE; damage_ship_ch( target, 20 + missile->missiletype * missile->missiletype * 20, 30 + missile->missiletype * missile->missiletype * missile->missiletype * 30, ch ); } if( !ch_found ) damage_ship( target, 20 + missile->missiletype * missile->missiletype * 20, 30 + missile->missiletype * missile->missiletype * ship->missiletype * 30 ); extract_missile( missile ); } else { echo_to_room( AT_YELLOW, get_room_index( ship->gunseat ), "Your missile explodes harmlessly in a cloud of chaff!" ); echo_to_cockpit( AT_YELLOW, target, "A missile explodes in your chaff." ); 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 = 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->class != SHIP_PLATFORM && !autofly(ship) ) { if ( ship->starsystem->star1 && strcmp(ship->starsystem->star1,"") ) { if (ship->vx >= ship->starsystem->s1x + 1 || ship->vx <= ship->starsystem->s1x - 1 ) ship->vx -= URANGE(-3,(ship->starsystem->gravitys1)/(ship->vx - ship->starsystem->s1x)/2,3); if (ship->vy >= ship->starsystem->s1y + 1 || ship->vy <= ship->starsystem->s1y - 1 ) ship->vy -= URANGE(-3,(ship->starsystem->gravitys1)/(ship->vy - ship->starsystem->s1y)/2,3); if (ship->vz >= ship->starsystem->s1z + 1 || ship->vz <= ship->starsystem->s1z - 1 ) ship->vz -= URANGE(-3,(ship->starsystem->gravitys1)/(ship->vz - ship->starsystem->s1z)/2,3); } if ( ship->starsystem->star2 && strcmp(ship->starsystem->star2,"") ) { if (ship->vx >= ship->starsystem->s2x + 1 || ship->vx <= ship->starsystem->s2x - 1 ) ship->vx -= URANGE(-3,(ship->starsystem->gravitys2)/(ship->vx - ship->starsystem->s2x)/2,3); if (ship->vy >= ship->starsystem->s2y + 1 || ship->vy <= ship->starsystem->s2y - 1 ) ship->vy -= URANGE(-3,(ship->starsystem->gravitys2)/(ship->vy - ship->starsystem->s2y)/2,3); if (ship->vz >= ship->starsystem->s2z + 1 || ship->vz <= ship->starsystem->s2z - 1 ) ship->vz -= URANGE(-3,(ship->starsystem->gravitys2)/(ship->vz - ship->starsystem->s2z)/2,3); } if ( ship->starsystem->planet1 && strcmp(ship->starsystem->planet1,"") ) { if (ship->vx >= ship->starsystem->p1x + 1 || ship->vx <= ship->starsystem->p1x - 1 ) ship->vx -= URANGE(-3,(ship->starsystem->gravityp1)/(ship->vx - ship->starsystem->p1x)/2,3); if (ship->vy >= ship->starsystem->p1y + 1 || ship->vy <= ship->starsystem->p1y - 1 ) ship->vy -= URANGE(-3,(ship->starsystem->gravityp1)/(ship->vy - ship->starsystem->p1y)/2,3); if (ship->vz >= ship->starsystem->p1z + 1 || ship->vz <= ship->starsystem->p1z - 1 ) ship->vz -= URANGE(-3,(ship->starsystem->gravityp1)/(ship->vz - ship->starsystem->p1z)/2,3); } if ( ship->starsystem->planet2 && strcmp(ship->starsystem->planet2,"") ) { if (ship->vx >= ship->starsystem->p2x + 1 || ship->vx <= ship->starsystem->p2x - 1 ) ship->vx -= URANGE(-3,(ship->starsystem->gravityp2)/(ship->vx - ship->starsystem->p2x)/2,3); if (ship->vy >= ship->starsystem->p2y + 1 || ship->vy <= ship->starsystem->p2y - 1 ) ship->vy -= URANGE(-3,(ship->starsystem->gravityp2)/(ship->vy - ship->starsystem->p2y)/2,3); if (ship->vz >= ship->starsystem->p2z + 1 || ship->vz <= ship->starsystem->p2z - 1 ) ship->vz -= URANGE(-3,(ship->starsystem->gravityp2)/(ship->vz - ship->starsystem->p2z)/2,3); } if ( ship->starsystem->planet3 && strcmp(ship->starsystem->planet3,"") ) { if (ship->vx >= ship->starsystem->p3x + 1 || ship->vx <= ship->starsystem->p3x - 1 ) ship->vx -= URANGE(-3,(ship->starsystem->gravityp3)/(ship->vx - ship->starsystem->p3x)/2,3); if (ship->vy >= ship->starsystem->p3y + 1 || ship->vy <= ship->starsystem->p3y - 1 ) ship->vy -= URANGE(-3,(ship->starsystem->gravityp3)/(ship->vy - ship->starsystem->p3y)/2,3); if (ship->vz >= ship->starsystem->p3z + 1 || ship->vz <= ship->starsystem->p3z - 1 ) ship->vz -= URANGE(-3,(ship->starsystem->gravityp3)/(ship->vz - ship->starsystem->p3z)/2,3); } } */ /* for ( target = ship->starsystem->first_ship; target; target = target->next_in_starsystem) { if ( target != ship && abs(ship->vx - target->vx) < 1 && abs(ship->vy - target->vy) < 1 && abs(ship->vz - target->vz) < 1 ) { ship->collision = target->maxhull; target->collision = ship->maxhull; } } */ if( ship->starsystem->star1 && strcmp( ship->starsystem->star1, "" ) && abs( ship->vx - ship->starsystem->s1x ) < 10 && abs( ship->vy - ship->starsystem->s1y ) < 10 && abs( ship->vz - ship->starsystem->s1z ) < 10 ) { echo_to_cockpit( AT_BLOOD + AT_BLINK, ship, "You fly directly into the sun." ); sprintf( buf, "%s flys directly into %s!", ship->name, ship->starsystem->star1 ); echo_to_system( AT_ORANGE, ship, buf, NULL ); destroy_ship( ship, NULL ); continue; } if( ship->starsystem->star2 && strcmp( ship->starsystem->star2, "" ) && abs( ship->vx - ship->starsystem->s2x ) < 10 && abs( ship->vy - ship->starsystem->s2y ) < 10 && abs( ship->vz - ship->starsystem->s2z ) < 10 ) { echo_to_cockpit( AT_BLOOD + AT_BLINK, ship, "You fly directly into the sun." ); sprintf( buf, "%s flys directly into %s!", ship->name, ship->starsystem->star2 ); echo_to_system( AT_ORANGE, ship, buf, NULL ); destroy_ship( ship, NULL ); continue; } if( ship->currspeed > 0 ) { if( ship->starsystem->planet1 && strcmp( ship->starsystem->planet1, "" ) && abs( ship->vx - ship->starsystem->p1x ) < 10 && abs( ship->vy - ship->starsystem->p1y ) < 10 && abs( ship->vz - ship->starsystem->p1z ) < 10 ) { sprintf( buf, "You begin orbitting %s.", ship->starsystem->planet1 ); echo_to_cockpit( AT_YELLOW, ship, buf ); sprintf( buf, "%s begins orbiting %s.", ship->name, ship->starsystem->planet1 ); echo_to_system( AT_ORANGE, ship, buf, NULL ); ship->currspeed = 0; continue; } if( ship->starsystem->planet2 && strcmp( ship->starsystem->planet2, "" ) && abs( ship->vx - ship->starsystem->p2x ) < 10 && abs( ship->vy - ship->starsystem->p2y ) < 10 && abs( ship->vz - ship->starsystem->p2z ) < 10 ) { sprintf( buf, "You begin orbitting %s.", ship->starsystem->planet2 ); echo_to_cockpit( AT_YELLOW, ship, buf ); sprintf( buf, "%s begins orbiting %s.", ship->name, ship->starsystem->planet2 ); echo_to_system( AT_ORANGE, ship, buf, NULL ); ship->currspeed = 0; continue; } if( ship->starsystem->planet3 && strcmp( ship->starsystem->planet3, "" ) && abs( ship->vx - ship->starsystem->p3x ) < 10 && abs( ship->vy - ship->starsystem->p3y ) < 10 && abs( ship->vz - ship->starsystem->p3z ) < 10 ) { sprintf( buf, "You begin orbitting %s.", ship->starsystem->planet2 ); echo_to_cockpit( AT_YELLOW, ship, buf ); sprintf( buf, "%s begins orbiting %s.", ship->name, ship->starsystem->planet2 ); echo_to_system( AT_ORANGE, ship, buf, NULL ); ship->currspeed = 0; continue; } } } for( ship = first_ship; ship; ship = ship->next ) if( ship->collision ) { echo_to_cockpit( AT_WHITE + AT_BLINK, ship, "You have collided with another ship!" ); echo_to_ship( AT_RED, ship, "A loud explosion shakes the ship violently!" ); damage_ship( ship, ship->collision, ship->collision ); ship->collision = 0; } } void recharge_ships( ) { SHIP_DATA *ship; char buf[MAX_STRING_LENGTH]; for( ship = first_ship; ship; ship = ship->next ) { if( ship->statet0 > 0 ) { ship->energy -= ship->statet0; ship->statet0 = 0; } if( ship->statet1 > 0 ) { ship->energy -= ship->statet1; ship->statet1 = 0; } if( ship->statet2 > 0 ) { ship->energy -= ship->statet2; ship->statet2 = 0; } if( ship->missilestate == MISSILE_RELOAD_2 ) { ship->missilestate = MISSILE_READY; if( ship->missiles > 0 ) echo_to_room( AT_YELLOW, get_room_index( ship->gunseat ), "Missile launcher reloaded." ); } 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->target0 && ship->statet0 != LASER_DAMAGED ) { int chance = 50; SHIP_DATA *target = ship->target0; int shots; for( shots = 0; shots <= ship->lasers; shots++ ) { if( ship->shipstate != SHIP_HYPERSPACE && ship->energy > 25 && ship->target0->starsystem == ship->starsystem && abs( target->vx - ship->vx ) <= 1000 && abs( target->vy - ship->vy ) <= 1000 && abs( target->vz - ship->vz ) <= 1000 && ship->statet0 < ship->lasers ) { if( ship->class > 1 || is_facing( ship, target ) ) { chance += target->class * 25; chance -= target->manuever / 10; chance -= target->currspeed / 20; chance -= ( abs( target->vx - ship->vx ) / 70 ); chance -= ( abs( target->vy - ship->vy ) / 70 ); chance -= ( abs( target->vz - ship->vz ) / 70 ); chance = URANGE( 10, chance, 90 ); if( number_percent( ) > chance ) { sprintf( buf, "%s fires at you but misses.", ship->name ); echo_to_cockpit( AT_ORANGE, target, buf ); sprintf( buf, "Laserfire from %s barely misses %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, target, buf, NULL ); } else { sprintf( buf, "Laserfire from %s hits %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, target, buf, NULL ); sprintf( buf, "You are hit by lasers from %s!", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); echo_to_ship( AT_RED, target, "A small explosion vibrates through the ship." ); damage_ship( target, 5, 10 ); } ship->statet0++; } } } } } } } } void update_space( ) { SHIP_DATA *ship; SHIP_DATA *target; char buf[MAX_STRING_LENGTH]; int too_close, target_too_close; int recharge; for( ship = first_ship; ship; ship = ship->next ) { if( ship->starsystem ) { if( ship->energy > 0 && ship->shipstate == SHIP_DISABLED && ship->class != SHIP_PLATFORM ) ship->energy -= 100; else if( ship->energy > 0 ) ship->energy += ( 5 + ship->class * 5 ); else destroy_ship( ship, NULL ); } if( ship->chaff_released > 0 ) ship->chaff_released--; 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_cockpit( AT_RED, ship, "Ship lost in Hyperspace. Make new calculations." ); } else { echo_to_room( AT_YELLOW, get_room_index( ship->pilotseat ), "Hyperjump complete." ); echo_to_ship( AT_YELLOW, ship, "The ship lurches slightly as it comes out of hyperspace." ); sprintf( buf, "%s enters the starsystem at %.0f %.0f %.0f", ship->name, ship->vx, ship->vy, ship->vz ); echo_to_system( AT_YELLOW, ship, buf, NULL ); ship->shipstate = SHIP_READY; STRFREE( ship->home ); ship->home = STRALLOC( ship->starsystem->name ); if( str_cmp( "Public", ship->owner ) ) save_ship( ship ); } } else { sprintf( buf, "%d", ship->hyperdistance ); echo_to_room_dnr( AT_YELLOW, get_room_index( ship->pilotseat ), "Remaining jump distance: " ); echo_to_room( AT_WHITE, get_room_index( ship->pilotseat ), buf ); } } /* * following was originaly to fix ships that lost their pilot * in the middle of a manuever and are stuck in a busy state * but now used for timed manouevers such as turning */ if( ship->shipstate == SHIP_BUSY_3 ) { echo_to_room( AT_YELLOW, get_room_index( ship->pilotseat ), "Manuever complete." ); 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 ) landship( ship, ship->dest ); if( ship->shipstate == SHIP_LAND ) ship->shipstate = SHIP_LAND_2; if( ship->shipstate == SHIP_LAUNCH_2 ) launchship( ship ); if( ship->shipstate == SHIP_LAUNCH ) ship->shipstate = SHIP_LAUNCH_2; ship->shield = UMAX( 0, ship->shield - 1 - ship->class ); if( ship->autorecharge && ship->maxshield > ship->shield && ship->energy > 100 ) { recharge = UMIN( ship->maxshield - ship->shield, 10 + ship->class * 10 ); recharge = UMIN( recharge, ship->energy / 2 - 100 ); recharge = UMAX( 1, recharge ); ship->shield += recharge; ship->energy -= recharge; } if( ship->shield > 0 ) { if( ship->energy < 200 ) { ship->shield = 0; echo_to_cockpit( AT_RED, ship, "The ships shields fizzle and die." ); ship->autorecharge = FALSE; } } if( ship->starsystem && ship->currspeed > 0 ) { sprintf( buf, "%d", ship->currspeed ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->pilotseat ), "Speed: " ); echo_to_room_dnr( AT_LBLUE, get_room_index( ship->pilotseat ), buf ); sprintf( buf, "%.0f %.0f %.0f", ship->vx, ship->vy, ship->vz ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->pilotseat ), " Coords: " ); echo_to_room( AT_LBLUE, get_room_index( ship->pilotseat ), buf ); if( ship->pilotseat != ship->coseat ) { sprintf( buf, "%d", ship->currspeed ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->coseat ), "Speed: " ); echo_to_room_dnr( AT_LBLUE, get_room_index( ship->coseat ), buf ); sprintf( buf, "%.0f %.0f %.0f", ship->vx, ship->vy, ship->vz ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->coseat ), " Coords: " ); echo_to_room( AT_LBLUE, get_room_index( ship->coseat ), buf ); } } 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 && abs( ship->vx - target->vx ) < target_too_close && abs( ship->vy - target->vy ) < target_too_close && abs( ship->vz - target->vz ) < target_too_close ) { sprintf( buf, "Proximity alert: %s %.0f %.0f %.0f", target->name, target->vx, target->vy, target->vz ); echo_to_room( AT_RED, get_room_index( ship->pilotseat ), buf ); } } too_close = ship->currspeed + 100; if( ship->starsystem->star1 && strcmp( ship->starsystem->star1, "" ) && abs( ship->vx - ship->starsystem->s1x ) < too_close && abs( ship->vy - ship->starsystem->s1y ) < too_close && abs( ship->vz - ship->starsystem->s1z ) < too_close ) { sprintf( buf, "Proximity alert: %s %d %d %d", ship->starsystem->star1, ship->starsystem->s1x, ship->starsystem->s1y, ship->starsystem->s1z ); echo_to_room( AT_RED, get_room_index( ship->pilotseat ), buf ); } if( ship->starsystem->star2 && strcmp( ship->starsystem->star2, "" ) && abs( ship->vx - ship->starsystem->s2x ) < too_close && abs( ship->vy - ship->starsystem->s2y ) < too_close && abs( ship->vz - ship->starsystem->s2z ) < too_close ) { sprintf( buf, "Proximity alert: %s %d %d %d", ship->starsystem->star2, ship->starsystem->s2x, ship->starsystem->s2y, ship->starsystem->s2z ); echo_to_room( AT_RED, get_room_index( ship->pilotseat ), buf ); } if( ship->starsystem->planet1 && strcmp( ship->starsystem->planet1, "" ) && abs( ship->vx - ship->starsystem->p1x ) < too_close && abs( ship->vy - ship->starsystem->p1y ) < too_close && abs( ship->vz - ship->starsystem->p1z ) < too_close ) { sprintf( buf, "Proximity alert: %s %d %d %d", ship->starsystem->planet1, ship->starsystem->p1x, ship->starsystem->p1y, ship->starsystem->p1z ); echo_to_room( AT_RED, get_room_index( ship->pilotseat ), buf ); } if( ship->starsystem->planet2 && strcmp( ship->starsystem->planet2, "" ) && abs( ship->vx - ship->starsystem->p2x ) < too_close && abs( ship->vy - ship->starsystem->p2y ) < too_close && abs( ship->vz - ship->starsystem->p2z ) < too_close ) { sprintf( buf, "Proximity alert: %s %d %d %d", ship->starsystem->planet2, ship->starsystem->p2x, ship->starsystem->p2y, ship->starsystem->p2z ); echo_to_room( AT_RED, get_room_index( ship->pilotseat ), buf ); } if( ship->starsystem->planet3 && strcmp( ship->starsystem->planet3, "" ) && abs( ship->vx - ship->starsystem->p3x ) < too_close && abs( ship->vy - ship->starsystem->p3y ) < too_close && abs( ship->vz - ship->starsystem->p3z ) < too_close ) { sprintf( buf, "Proximity alert: %s %d %d %d", ship->starsystem->planet3, ship->starsystem->p3x, ship->starsystem->p3y, ship->starsystem->p3z ); echo_to_room( AT_RED, get_room_index( ship->pilotseat ), buf ); } } if( ship->target0 ) { sprintf( buf, "%s %.0f %.0f %.0f", ship->target0->name, ship->target0->vx, ship->target0->vy, ship->target0->vz ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->gunseat ), "Target: " ); echo_to_room( AT_LBLUE, get_room_index( ship->gunseat ), buf ); if( ship->starsystem != ship->target0->starsystem ) ship->target0 = NULL; } if( ship->target1 ) { sprintf( buf, "%s %.0f %.0f %.0f", ship->target1->name, ship->target1->vx, ship->target1->vy, ship->target1->vz ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->turret1 ), "Target: " ); echo_to_room( AT_LBLUE, get_room_index( ship->turret1 ), buf ); if( ship->starsystem != ship->target1->starsystem ) ship->target1 = NULL; } if( ship->target2 ) { sprintf( buf, "%s %.0f %.0f %.0f", ship->target2->name, ship->target2->vx, ship->target2->vy, ship->target2->vz ); echo_to_room_dnr( AT_BLUE, get_room_index( ship->turret2 ), "Target: " ); echo_to_room( AT_LBLUE, get_room_index( ship->turret2 ), buf ); if( ship->starsystem != ship->target2->starsystem ) ship->target2 = NULL; } if( ship->energy < 100 && ship->starsystem ) { echo_to_cockpit( AT_RED, ship, "Warning: Ship fuel low." ); } ship->energy = URANGE( 0, ship->energy, ship->maxenergy ); } for( ship = first_ship; ship; ship = ship->next ) { if( ship->autotrack && ship->target0 && ship->class < 3 ) { target = ship->target0; too_close = ship->currspeed + 10; target_too_close = too_close + target->currspeed; if( target != ship && ship->shipstate == SHIP_READY && abs( ship->vx - target->vx ) < target_too_close && abs( ship->vy - target->vy ) < target_too_close && abs( ship->vz - target->vz ) < target_too_close ) { ship->hx = 0 - ( ship->target0->vx - ship->vx ); ship->hy = 0 - ( ship->target0->vy - ship->vy ); ship->hz = 0 - ( ship->target0->vz - ship->vz ); ship->energy -= ship->currspeed / 10; echo_to_room( AT_RED, get_room_index( ship->pilotseat ), "Autotrack: Evading to avoid collision!\n\r" ); if( ship->class == FIGHTER_SHIP || ( ship->class == MIDSIZE_SHIP && ship->manuever > 50 ) ) ship->shipstate = SHIP_BUSY_3; else if( ship->class == MIDSIZE_SHIP || ( ship->class == CAPITAL_SHIP && ship->manuever > 50 ) ) ship->shipstate = SHIP_BUSY_2; else ship->shipstate = SHIP_BUSY; } else if( !is_facing( ship, ship->target0 ) ) { ship->hx = ship->target0->vx - ship->vx; ship->hy = ship->target0->vy - ship->vy; ship->hz = ship->target0->vz - ship->vz; ship->energy -= ship->currspeed / 10; echo_to_room( AT_BLUE, get_room_index( ship->pilotseat ), "Autotracking target ... setting new course.\n\r" ); if( ship->class == FIGHTER_SHIP || ( ship->class == MIDSIZE_SHIP && ship->manuever > 50 ) ) ship->shipstate = SHIP_BUSY_3; else if( ship->class == MIDSIZE_SHIP || ( ship->class == CAPITAL_SHIP && ship->manuever > 50 ) ) ship->shipstate = SHIP_BUSY_2; else ship->shipstate = SHIP_BUSY; } } if( autofly( ship ) ) { if( ship->starsystem ) { if( ship->target0 ) { int chance = 50; /* * auto assist ships */ for( target = ship->starsystem->first_ship; target; target = target->next_in_starsystem ) { if( autofly( target ) ) if( !str_cmp( target->owner, ship->owner ) && target != ship ) if( target->target0 == NULL && ship->target0 != target ) { target->target0 = ship->target0; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, target->target0, buf ); break; } } target = ship->target0; ship->autotrack = TRUE; if( ship->class != SHIP_PLATFORM ) ship->currspeed = ship->realspeed; if( ship->energy > 200 ) ship->autorecharge = TRUE; if( ship->shipstate != SHIP_HYPERSPACE && ship->energy > 25 && ship->missilestate == MISSILE_READY && ship->target0->starsystem == ship->starsystem && abs( target->vx - ship->vx ) <= 1200 && abs( target->vy - ship->vy ) <= 1200 && abs( target->vz - ship->vz ) <= 1200 && ship->missiles > 0 ) { if( ship->class > 1 || is_facing( ship, target ) ) { chance -= target->manuever / 5; chance -= target->currspeed / 20; chance += target->class * target->class * 25; chance -= ( abs( target->vx - ship->vx ) / 100 ); chance -= ( abs( target->vy - ship->vy ) / 100 ); chance -= ( abs( target->vz - ship->vz ) / 100 ); chance += ( 30 ); chance = URANGE( 10, chance, 90 ); if( number_percent( ) > chance ) { } else { new_missile( ship, target, NULL, CONCUSSION_MISSILE ); ship->missiles--; sprintf( buf, "Incoming missile from %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "%s fires a missile towards %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, target, buf, NULL ); if( ship->class == CAPITAL_SHIP || ship->class == SHIP_PLATFORM ) ship->missilestate = MISSILE_RELOAD_2; else ship->missilestate = MISSILE_FIRED; } } } if( ship->missilestate == MISSILE_DAMAGED ) ship->missilestate = MISSILE_READY; if( ship->statet0 == LASER_DAMAGED ) ship->statet0 = LASER_READY; if( ship->shipstate == SHIP_DISABLED ) ship->shipstate = SHIP_READY; } else { ship->currspeed = 0; if( !str_cmp( ship->owner, "The Empire" ) ) for( target = first_ship; target; target = target->next ) if( ship->starsystem == target->starsystem ) if( !str_cmp( target->owner, "The New Republic" ) ) { ship->target0 = target; sprintf( buf, "You are being targetted by %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); break; } if( !str_cmp( ship->owner, "The New Republic" ) ) for( target = first_ship; target; target = target->next ) if( ship->starsystem == target->starsystem ) if( !str_cmp( target->owner, "The Empire" ) ) { sprintf( buf, "You are being targetted by %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); ship->target0 = target; break; } if( !str_cmp( ship->owner, "Pirates" ) ) for( target = first_ship; target; target = target->next ) if( ship->starsystem == target->starsystem ) { sprintf( buf, "You are being targetted by %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); ship->target0 = target; break; } } } else { 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 = 1; ship->hy = 1; ship->hz = 1; } } } if( ( ship->class == CAPITAL_SHIP || ship->class == SHIP_PLATFORM ) && ship->target0 == NULL ) { if( ship->missiles < ship->maxmissiles ) ship->missiles++; if( ship->torpedos < ship->maxtorpedos ) ship->torpedos++; if( ship->rockets < ship->maxrockets ) ship->rockets++; } } } void damage_ship_ch( SHIP_DATA * ship, int min, int max, CHAR_DATA * ch ) { int damage, shield_dmg; damage = number_range( min, max ); /* xp = ( exp_level( ch->skill_level[PILOTING_ABILITY]+1) - exp_level( ch->skill_level[PILOTING_ABILITY]) ) / 25 ; xp = UMIN( get_ship_value( ship ) /100 , xp ) ; gain_exp( ch , xp , PILOTING_ABILITY ); */ if( ship->shield > 0 ) { shield_dmg = UMIN( ship->shield, damage ); damage -= shield_dmg; ship->shield -= shield_dmg; if( ship->shield == 0 ) echo_to_cockpit( AT_BLOOD, ship, "Shields down..." ); } if( damage > 0 ) { if( number_range( 1, 100 ) <= 5 && ship->shipstate != SHIP_DISABLED ) { echo_to_cockpit( AT_BLOOD + AT_BLINK, ship, "Ships Drive DAMAGED!" ); ship->shipstate = SHIP_DISABLED; } if( number_range( 1, 100 ) <= 5 && ship->missilestate != MISSILE_DAMAGED && ship->maxmissiles > 0 ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->gunseat ), "Ships Missile Launcher DAMAGED!" ); ship->missilestate = MISSILE_DAMAGED; } if( number_range( 1, 100 ) <= 2 && ship->statet0 != LASER_DAMAGED ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->gunseat ), "Lasers DAMAGED!" ); ship->statet1 = LASER_DAMAGED; } if( number_range( 1, 100 ) <= 5 && ship->statet1 != LASER_DAMAGED && ship->turret1 ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->turret1 ), "Turret DAMAGED!" ); ship->statet1 = LASER_DAMAGED; } if( number_range( 1, 100 ) <= 5 && ship->statet2 != LASER_DAMAGED && ship->turret2 ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->turret2 ), "Turret DAMAGED!" ); ship->statet2 = LASER_DAMAGED; } } ship->hull -= damage * 5; if( ship->hull <= 0 ) { destroy_ship( ship, ch ); /* xp = ( exp_level( ch->skill_level[PILOTING_ABILITY]+1) - exp_level( ch->skill_level[PILOTING_ABILITY]) ); xp = UMIN( get_ship_value( ship ) , xp ); gain_exp( ch , xp , PILOTING_ABILITY); pager_printf_color( ch, "&WYou gain %ld piloting experience!\n\r", xp ); */ return; } if( ship->hull <= ship->maxhull / 20 ) echo_to_cockpit( AT_BLOOD + AT_BLINK, ship, "WARNING! Ship hull severely damaged!" ); } void damage_ship( SHIP_DATA * ship, int min, int max ) { int damage, shield_dmg; damage = number_range( min, max ); if( ship->shield > 0 ) { shield_dmg = UMIN( ship->shield, damage ); damage -= shield_dmg; ship->shield -= shield_dmg; if( ship->shield == 0 ) echo_to_cockpit( AT_BLOOD, ship, "Shields down..." ); } if( damage > 0 ) { if( number_range( 1, 100 ) <= 5 && ship->shipstate != SHIP_DISABLED ) { echo_to_cockpit( AT_BLOOD + AT_BLINK, ship, "Ships Drive DAMAGED!" ); ship->shipstate = SHIP_DISABLED; } if( number_range( 1, 100 ) <= 5 && ship->missilestate != MISSILE_DAMAGED && ship->maxmissiles > 0 ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->gunseat ), "Ships Missile Launcher DAMAGED!" ); ship->missilestate = MISSILE_DAMAGED; } if( number_range( 1, 100 ) <= 2 && ship->statet1 != LASER_DAMAGED && ship->turret1 ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->turret1 ), "Turret DAMAGED!" ); ship->statet1 = LASER_DAMAGED; } if( number_range( 1, 100 ) <= 2 && ship->statet2 != LASER_DAMAGED && ship->turret2 ) { echo_to_room( AT_BLOOD + AT_BLINK, get_room_index( ship->turret2 ), "Turret DAMAGED!" ); ship->statet2 = LASER_DAMAGED; } } ship->hull -= damage * 5; if( ship->hull <= 0 ) { destroy_ship( ship, NULL ); return; } if( ship->hull <= ship->maxhull / 20 ) echo_to_cockpit( AT_BLOOD + AT_BLINK, ship, "WARNING! Ship hull severely damaged!" ); } void extract_missile( MISSILE_DATA * missile ) { SPACE_DATA *starsystem; if( missile == NULL ) return; if( ( starsystem = missile->starsystem ) != NULL ) { if( starsystem->last_missile == missile ) starsystem->last_missile = missile->prev_in_starsystem; if( starsystem->first_missile == missile ) starsystem->first_missile = missile->next_in_starsystem; if( missile->prev_in_starsystem ) missile->prev_in_starsystem->next_in_starsystem = missile->next_in_starsystem; if( missile->next_in_starsystem ) missile->next_in_starsystem->prev_in_starsystem = missile->prev_in_starsystem; missile->starsystem = NULL; missile->next_in_starsystem = NULL; missile->prev_in_starsystem = NULL; } UNLINK( missile, first_missile, last_missile, next, prev ); missile->target = NULL; missile->fired_from = NULL; if( missile->fired_by ) STRFREE( missile->fired_by ); DISPOSE( missile ); } void do_setstarsystem( CHAR_DATA * ch, char *argument ) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; SPACE_DATA *starsystem; if( IS_NPC( ch ) ) { send_to_pager_color( "Huh?\n\r", ch ); return; } argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if( arg2[0] == '\0' || arg1[0] == '\0' ) { send_to_pager_color( "Usage: setstarsystem <starsystem> <field> <values>\n\r", ch ); send_to_pager_color( "\n\rField being one of:\n\r", ch ); send_to_pager_color( "name filename xpos ypos,\n\r", ch ); send_to_pager_color( "star1 s1x s1y s1z gravitys1\n\r", ch ); send_to_pager_color( "star2 s2x s2y s2z gravitys2\n\r", ch ); send_to_pager_color( "planet1 p1x p1y p1z gravityp1\n\r", ch ); send_to_pager_color( "planet2 p2x p2y p2z gravityp2\n\r", ch ); send_to_pager_color( "planet3 p3x p3y p3z gravityp3\n\r", ch ); send_to_pager_color( "location1a location1b location1c doc1a doc1b doc1c\n\r", ch ); send_to_pager_color( "location2a location2b location2c doc2a doc2b doc2c\n\r", ch ); send_to_pager_color( "location3a location3b location3c doc3a doc3b doc3c\n\r", ch ); send_to_pager_color( "", ch ); return; } starsystem = starsystem_from_name( arg1 ); if( !starsystem ) { send_to_pager_color( "No such starsystem.\n\r", ch ); return; } if( !str_cmp( arg2, "doc1a" ) ) { starsystem->doc1a = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc1b" ) ) { starsystem->doc1b = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc1c" ) ) { starsystem->doc1c = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc2a" ) ) { starsystem->doc2a = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc2b" ) ) { starsystem->doc2b = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc2c" ) ) { starsystem->doc2c = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc3a" ) ) { starsystem->doc3a = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc3b" ) ) { starsystem->doc3b = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "doc3c" ) ) { starsystem->doc3c = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "s1x" ) ) { starsystem->s1x = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "s1y" ) ) { starsystem->s1y = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "s1z" ) ) { starsystem->s1z = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "s2x" ) ) { starsystem->s2x = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "s2y" ) ) { starsystem->s2y = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "s2z" ) ) { starsystem->s2z = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p1x" ) ) { starsystem->p1x = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p1y" ) ) { starsystem->p1y = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p1z" ) ) { starsystem->p1z = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p2x" ) ) { starsystem->p2x = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p2y" ) ) { starsystem->p2y = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p2z" ) ) { starsystem->p2z = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p3x" ) ) { starsystem->p3x = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p3y" ) ) { starsystem->p3y = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "p3z" ) ) { starsystem->p3z = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "xpos" ) ) { starsystem->xpos = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "ypos" ) ) { starsystem->ypos = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "gravitys1" ) ) { starsystem->gravitys1 = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "gravitys2" ) ) { starsystem->gravitys2 = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "gravityp1" ) ) { starsystem->gravityp1 = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "gravityp2" ) ) { starsystem->gravityp2 = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "gravityp3" ) ) { starsystem->gravityp3 = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "name" ) ) { STRFREE( starsystem->name ); starsystem->name = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "star1" ) ) { STRFREE( starsystem->star1 ); starsystem->star1 = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "star2" ) ) { STRFREE( starsystem->star2 ); starsystem->star2 = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "planet1" ) ) { STRFREE( starsystem->planet1 ); starsystem->planet1 = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "planet2" ) ) { STRFREE( starsystem->planet2 ); starsystem->planet2 = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "planet3" ) ) { STRFREE( starsystem->planet3 ); starsystem->planet3 = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location1a" ) ) { STRFREE( starsystem->location1a ); starsystem->location1a = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location1b" ) ) { STRFREE( starsystem->location1b ); starsystem->location1b = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location1c" ) ) { STRFREE( starsystem->location1c ); starsystem->location1c = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location2a" ) ) { STRFREE( starsystem->location2a ); starsystem->location2a = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location2b" ) ) { STRFREE( starsystem->location2a ); starsystem->location2b = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location2c" ) ) { STRFREE( starsystem->location2c ); starsystem->location2c = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location3a" ) ) { STRFREE( starsystem->location3a ); starsystem->location3a = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location3b" ) ) { STRFREE( starsystem->location3b ); starsystem->location3b = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } if( !str_cmp( arg2, "location3c" ) ) { STRFREE( starsystem->location3c ); starsystem->location3c = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_starsystem( starsystem ); return; } do_setstarsystem( ch, "" ); return; } void showstarsystem( CHAR_DATA * ch, SPACE_DATA * starsystem ) { pager_printf_color( ch, "Starsystem:%s Filename: %s Xpos: %d Ypos: %d\n\r", starsystem->name, starsystem->filename, starsystem->xpos, starsystem->ypos ); pager_printf_color( ch, "Star1: %s Gravity: %d Coordinates: %d %d %d\n\r", starsystem->star1, starsystem->gravitys1, starsystem->s1x, starsystem->s1y, starsystem->s1z ); pager_printf_color( ch, "Star2: %s Gravity: %d Coordinates: %d %d %d\n\r", starsystem->star2, starsystem->gravitys2, starsystem->s2x, starsystem->s2y, starsystem->s2z ); pager_printf_color( ch, "Planet1: %s Gravity: %d Coordinates: %d %d %d\n\r", starsystem->planet1, starsystem->gravityp1, starsystem->p1x, starsystem->p1y, starsystem->p1z ); pager_printf_color( ch, " Doc1a: %5d (%s)\n\r", starsystem->doc1a, starsystem->location1a ); pager_printf_color( ch, " Doc1b: %5d (%s)\n\r", starsystem->doc1b, starsystem->location1b ); pager_printf_color( ch, " Doc1c: %5d (%s)\n\r", starsystem->doc1c, starsystem->location1c ); pager_printf_color( ch, "Planet2: %s Gravity: %d Coordinates: %d %d %d\n\r", starsystem->planet2, starsystem->gravityp2, starsystem->p2x, starsystem->p2y, starsystem->p2z ); pager_printf_color( ch, " Doc2a: %5d (%s)\n\r", starsystem->doc2a, starsystem->location2a ); pager_printf_color( ch, " Doc2b: %5d (%s)\n\r", starsystem->doc2b, starsystem->location2b ); pager_printf_color( ch, " Doc2c: %5d (%s)\n\r", starsystem->doc2c, starsystem->location2c ); pager_printf_color( ch, "Planet3: %s Gravity: %d Coordinates: %d %d %d\n\r", starsystem->planet3, starsystem->gravityp3, starsystem->p3x, starsystem->p3y, starsystem->p3z ); pager_printf_color( ch, " Doc3a: %5d (%s)\n\r", starsystem->doc3a, starsystem->location3a ); pager_printf_color( ch, " Doc3b: %5d (%s)\n\r", starsystem->doc3b, starsystem->location3b ); pager_printf_color( ch, " Doc3c: %5d (%s)\n\r", starsystem->doc3c, starsystem->location3c ); return; } void do_showstarsystem( CHAR_DATA * ch, char *argument ) { SPACE_DATA *starsystem; starsystem = starsystem_from_name( argument ); if( starsystem == NULL ) send_to_pager_color( "&RNo such starsystem.\n\r", ch ); else showstarsystem( ch, starsystem ); } void do_makestarsystem( CHAR_DATA * ch, char *argument ) { char arg[MAX_INPUT_LENGTH]; char filename[256]; SPACE_DATA *starsystem; if( !argument || argument[0] == '\0' ) { send_to_pager_color( "Usage: makestarsystem <starsystem name>\n\r", ch ); return; } CREATE( starsystem, SPACE_DATA, 1 ); LINK( starsystem, first_starsystem, last_starsystem, next, prev ); starsystem->name = STRALLOC( argument ); starsystem->location1a = STRALLOC( "" ); starsystem->location2a = STRALLOC( "" ); starsystem->location3a = STRALLOC( "" ); starsystem->location1b = STRALLOC( "" ); starsystem->location2b = STRALLOC( "" ); starsystem->location3b = STRALLOC( "" ); starsystem->location1c = STRALLOC( "" ); starsystem->location2c = STRALLOC( "" ); starsystem->location3c = STRALLOC( "" ); starsystem->planet1 = STRALLOC( "" ); starsystem->planet2 = STRALLOC( "" ); starsystem->planet3 = STRALLOC( "" ); starsystem->star1 = STRALLOC( "" ); starsystem->star2 = STRALLOC( "" ); argument = one_argument( argument, arg ); sprintf( filename, "%s.system", strlower( arg ) ); starsystem->filename = str_dup( filename ); save_starsystem( starsystem ); write_starsystem_list( ); } void do_starsystems( CHAR_DATA * ch, char *argument ) { SPACE_DATA *starsystem; int count = 0; for( starsystem = first_starsystem; starsystem; starsystem = starsystem->next ) { set_char_color( AT_NOTE, ch ); pager_printf_color( ch, "%s\n\r", starsystem->name ); count++; } if( !count ) { send_to_pager_color( "There are no starsystems currently formed.\n\r", ch ); return; } } void do_resetship( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; ship = get_ship( argument ); if( ship == NULL ) { send_to_pager_color( "&RNo such ship!", ch ); return; } resetship( ship ); if( ( ship->class == SHIP_PLATFORM || ship->type == MOB_SHIP || ship->class == CAPITAL_SHIP ) && ship->home ) { 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->shipstate = SHIP_READY; ship->autopilot = TRUE; ship->autorecharge = TRUE; ship->shield = ship->maxshield; } } void do_setship( CHAR_DATA * ch, char *argument ) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; SHIP_DATA *ship; int tempnum; ROOM_INDEX_DATA *roomindex; if( IS_NPC( ch ) ) { send_to_pager_color( "Huh?\n\r", ch ); return; } argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if( arg1[0] == '\0' || arg2[0] == '\0' || arg1[0] == '\0' ) { send_to_pager_color( "Usage: setship <ship> <field> <values>\n\r", ch ); send_to_pager_color( "\n\rField being one of:\n\r", ch ); send_to_pager_color( "filename name owner copilot pilot description home\n\r", ch ); send_to_pager_color( "cockpit entrance turret1 turret2 hanger\n\r", ch ); send_to_pager_color( "engineroom firstroom lastroom shipyard\n\r", ch ); send_to_pager_color( "manuever speed hyperspeed tractorbeam\n\r", ch ); send_to_pager_color( "lasers missiles shield hull energy chaff\n\r", ch ); send_to_pager_color( "comm sensor astroarray class torpedos\n\r", ch ); send_to_pager_color( "pilotseat coseat gunseat navseat rockets cost\n\r", ch ); return; } ship = get_ship( arg1 ); if( !ship ) { send_to_pager_color( "No such ship.\n\r", ch ); return; } if( !str_cmp( arg2, "owner" ) ) { STRFREE( ship->owner ); ship->owner = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "home" ) ) { STRFREE( ship->home ); ship->home = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "pilot" ) ) { STRFREE( ship->pilot ); ship->pilot = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "copilot" ) ) { STRFREE( ship->copilot ); ship->copilot = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "firstroom" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } ship->firstroom = tempnum; ship->lastroom = tempnum; ship->cockpit = tempnum; ship->coseat = tempnum; ship->pilotseat = tempnum; ship->gunseat = tempnum; ship->navseat = tempnum; ship->entrance = tempnum; ship->turret1 = 0; ship->turret2 = 0; ship->hanger = 0; send_to_pager_color( "You will now need to set the other rooms in the ship.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "lastroom" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom ) { send_to_pager_color( "The last room on a ship must be greater than or equal to the first room.\n\r", ch ); return; } if( ship->class == FIGHTER_SHIP && ( tempnum - ship->firstroom ) > 5 ) { send_to_pager_color( "Starfighters may have up to 5 rooms only.\n\r", ch ); return; } if( ship->class == MIDSIZE_SHIP && ( tempnum - ship->firstroom ) > 25 ) { send_to_pager_color( "Midships may have up to 25 rooms only.\n\r", ch ); return; } if( ship->class == CAPITAL_SHIP && ( tempnum - ship->firstroom ) > 100 ) { send_to_pager_color( "Capital Ships may have up to 100 rooms only.\n\r", ch ); return; } ship->lastroom = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "cockpit" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->hanger ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->cockpit = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "pilotseat" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->hanger ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->pilotseat = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "coseat" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->hanger ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->coseat = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "navseat" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->hanger ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->navseat = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "gunseat" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->hanger ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->gunseat = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "entrance" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } ship->entrance = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "turret1" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( ship->class == FIGHTER_SHIP ) { send_to_pager_color( "Starfighters can't have extra laser turrets.\n\r", ch ); return; } if( tempnum == ship->cockpit || tempnum == ship->entrance || tempnum == ship->turret2 || tempnum == ship->hanger || tempnum == ship->engineroom ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->turret1 = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "turret2" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( ship->class == FIGHTER_SHIP ) { send_to_pager_color( "Starfighters can't have extra laser turrets.\n\r", ch ); return; } if( tempnum == ship->cockpit || tempnum == ship->entrance || tempnum == ship->turret1 || tempnum == ship->hanger || tempnum == ship->engineroom ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->turret2 = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "hanger" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->cockpit || tempnum == ship->entrance || tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->engineroom ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } if( ship->class == FIGHTER_SHIP ) { send_to_pager_color( "Starfighters are to small to have hangers for other ships!\n\r", ch ); return; } ship->hanger = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "engineroom" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.\n\r", ch ); return; } if( tempnum < ship->firstroom || tempnum > ship->lastroom ) { send_to_pager_color( "That room number is not in that ship .. \n\rIt must be between Firstroom and Lastroom.\n\r", ch ); return; } if( tempnum == ship->cockpit || tempnum == ship->entrance || tempnum == ship->turret1 || tempnum == ship->turret2 || tempnum == ship->hanger ) { send_to_pager_color( "That room is already being used by another part of the ship\n\r", ch ); return; } ship->engineroom = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "shipyard" ) ) { tempnum = atoi( argument ); roomindex = get_room_index( tempnum ); if( roomindex == NULL ) { send_to_pager_color( "That room doesn't exist.", ch ); return; } ship->shipyard = tempnum; send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "type" ) ) { if( !str_cmp( argument, "republic" ) ) ship->type = SHIP_REPUBLIC; else if( !str_cmp( argument, "imperial" ) ) ship->type = SHIP_IMPERIAL; else if( !str_cmp( argument, "civilian" ) ) ship->type = SHIP_CIVILIAN; else if( !str_cmp( argument, "mob" ) ) ship->type = MOB_SHIP; else { send_to_pager_color( "Ship type must be either: republic, imperial, civilian or mob.\n\r", ch ); return; } send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "name" ) ) { STRFREE( ship->name ); ship->name = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "filename" ) ) { if( ship->filename ) DISPOSE( ship->filename ); ship->filename = str_dup( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); write_ship_list( ); return; } if( !str_cmp( arg2, "desc" ) ) { STRFREE( ship->description ); ship->description = STRALLOC( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "manuever" ) ) { ship->manuever = URANGE( 0, atoi( argument ), 120 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "lasers" ) ) { ship->lasers = URANGE( 0, atoi( argument ), 10 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "cost" ) ) { ship->cost = atoi( argument ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "class" ) ) { ship->class = URANGE( 0, atoi( argument ), 9 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "missiles" ) ) { ship->maxmissiles = URANGE( 0, atoi( argument ), 255 ); ship->missiles = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "torpedos" ) ) { ship->maxtorpedos = URANGE( 0, atoi( argument ), 255 ); ship->torpedos = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "rockets" ) ) { ship->maxrockets = URANGE( 0, atoi( argument ), 255 ); ship->rockets = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "speed" ) ) { ship->realspeed = URANGE( 0, atoi( argument ), 150 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "tractorbeam" ) ) { ship->tractorbeam = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "hyperspeed" ) ) { ship->hyperspeed = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "shield" ) ) { ship->maxshield = URANGE( 0, atoi( argument ), 1000 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "hull" ) ) { ship->hull = URANGE( 1, atoi( argument ), 20000 ); ship->maxhull = URANGE( 1, atoi( argument ), 20000 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "energy" ) ) { ship->energy = URANGE( 1, atoi( argument ), 30000 ); ship->maxenergy = URANGE( 1, atoi( argument ), 30000 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "sensor" ) ) { ship->sensor = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "astroarray" ) ) { ship->astro_array = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "comm" ) ) { ship->comm = URANGE( 0, atoi( argument ), 255 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( arg2, "chaff" ) ) { ship->chaff = URANGE( 0, atoi( argument ), 25 ); ship->maxchaff = URANGE( 0, atoi( argument ), 25 ); send_to_pager_color( "Done.\n\r", ch ); save_ship( ship ); return; } do_setship( ch, "" ); return; } void do_showship( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; if( IS_NPC( ch ) ) { send_to_pager_color( "Huh?\n\r", ch ); return; } if( argument[0] == '\0' ) { send_to_pager_color( "Usage: showship <ship>\n\r", ch ); return; } ship = get_ship( argument ); if( !ship ) { send_to_pager_color( "No such ship.\n\r", ch ); return; } set_char_color( AT_YELLOW, ch ); pager_printf_color( ch, "%s %s : %s\n\rFilename: %s\n\r", ship->type == SHIP_REPUBLIC ? "New Republic" : ( ship->type == SHIP_IMPERIAL ? "Imperial" : ( ship->type == SHIP_CIVILIAN ? "Civilian" : "Mob" ) ), ship->class == FIGHTER_SHIP ? "Starfighter" : ( ship->class == MIDSIZE_SHIP ? "Midship" : ( ship->class == CAPITAL_SHIP ? "Capital Ship" : ( ship->class == SHIP_PLATFORM ? "Platform" : ( ship->class == CLOUD_CAR ? "Cloudcar" : ( ship->class == OCEAN_SHIP ? "Boat" : ( ship->class == LAND_SPEEDER ? "Speeder" : ( ship->class == WHEELED ? "Wheeled Transport" : ( ship->class == LAND_CRAWLER ? "Crawler" : ( ship->class == WALKER ? "Walker" : "Unknown" ) ) ) ) ) ) ) ) ), ship->name, ship->filename ); pager_printf_color( ch, "Home: %s Description: %s\n\rOwner: %s Pilot: %s Copilot: %s\n\r", ship->home, ship->description, ship->owner, ship->pilot, ship->copilot ); pager_printf_color( ch, "Firstroom: %d Lastroom: %d", ship->firstroom, ship->lastroom ); pager_printf_color( ch, "Cockpit: %d Entrance: %d Hanger: %d Engineroom: %d\n\r", ship->cockpit, ship->entrance, ship->hanger, ship->engineroom ); pager_printf_color( ch, "Pilotseat: %d Coseat: %d Navseat: %d Gunseat: %d\n\r", ship->pilotseat, ship->coseat, ship->navseat, ship->gunseat ); pager_printf_color( ch, "Location: %d Lastdoc: %d Shipyard: %d\n\r", ship->location, ship->lastdoc, ship->shipyard ); pager_printf_color( ch, "Tractor Beam: %d Comm: %d Sensor: %d Astro Array: %d\n\r", ship->tractorbeam, ship->comm, ship->sensor, ship->astro_array ); pager_printf_color( ch, "Lasers: %d Laser Condition: %s\n\r", ship->lasers, ship->statet0 == LASER_DAMAGED ? "Damaged" : "Good" ); pager_printf_color( ch, "Turret One: %d Condition: %s\n\r", ship->turret1, ship->statet1 == LASER_DAMAGED ? "Damaged" : "Good" ); pager_printf_color( ch, "Turret Two: %d Condition: %s\n\r", ship->turret2, ship->statet2 == LASER_DAMAGED ? "Damaged" : "Good" ); pager_printf_color( ch, "Missiles: %d/%d Torpedos: %d/%d Rockets: %d/%d Condition: %s\n\r", ship->missiles, ship->maxmissiles, ship->torpedos, ship->maxtorpedos, ship->rockets, ship->maxrockets, ship->missilestate == MISSILE_DAMAGED ? "Damaged" : "Good" ); pager_printf_color( ch, "Hull: %d/%d Ship Condition: %s\n\r", ship->hull, ship->maxhull, ship->shipstate == SHIP_DISABLED ? "Disabled" : "Running" ); pager_printf_color( ch, "Shields: %d/%d Energy(fuel): %d/%d Chaff: %d/%d\n\r", ship->shield, ship->maxshield, ship->energy, ship->maxenergy, ship->chaff, ship->maxchaff ); pager_printf_color( ch, "Current Coordinates: %.0f %.0f %.0f\n\r", ship->vx, ship->vy, ship->vz ); pager_printf_color( ch, "Current Heading: %.0f %.0f %.0f\n\r", ship->hx, ship->hy, ship->hz ); pager_printf_color( ch, "Speed: %d/%d Hyperspeed: %d\n\r Manueverability: %d\n\r", ship->currspeed, ship->realspeed, ship->hyperspeed, ship->manuever ); pager_printf_color( ch, "Cost: %s\n\r", num_punct( ship->cost ) ); return; } void do_makeship( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; char arg[MAX_INPUT_LENGTH]; argument = one_argument( argument, arg ); if( !argument || argument[0] == '\0' ) { send_to_pager_color( "Usage: makeship <filename> <ship name>\n\r", ch ); return; } CREATE( ship, SHIP_DATA, 1 ); LINK( ship, first_ship, last_ship, next, prev ); ship->name = STRALLOC( argument ); ship->description = STRALLOC( "" ); ship->owner = STRALLOC( "" ); ship->copilot = STRALLOC( "" ); ship->pilot = STRALLOC( "" ); ship->home = STRALLOC( "" ); ship->type = SHIP_CIVILIAN; ship->starsystem = NULL; ship->energy = ship->maxenergy; ship->hull = ship->maxhull; ship->in_room = NULL; ship->next_in_room = NULL; ship->prev_in_room = NULL; ship->currjump = NULL; ship->target0 = NULL; ship->target1 = NULL; ship->target2 = NULL; ship->filename = str_dup( arg ); save_ship( ship ); write_ship_list( ); } void do_copyship( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; SHIP_DATA *old; char arg[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; argument = one_argument( argument, arg ); argument = one_argument( argument, arg2 ); if( !argument || argument[0] == '\0' ) { send_to_pager_color( "Usage: copyship <oldshipname> <filename> <newshipname>\n\r", ch ); return; } old = get_ship( arg ); if( !old ) { send_to_pager_color( "Thats not a ship!\n\r", ch ); return; } CREATE( ship, SHIP_DATA, 1 ); LINK( ship, first_ship, last_ship, next, prev ); ship->name = STRALLOC( argument ); ship->description = STRALLOC( "" ); ship->owner = STRALLOC( "" ); ship->copilot = STRALLOC( "" ); ship->pilot = STRALLOC( "" ); ship->home = STRALLOC( "" ); ship->type = old->type; ship->class = old->class; ship->lasers = old->lasers; ship->maxmissiles = old->maxmissiles; ship->maxrockets = old->maxrockets; ship->maxtorpedos = old->maxtorpedos; ship->maxshield = old->maxshield; ship->maxhull = old->maxhull; ship->maxenergy = old->maxenergy; ship->hyperspeed = old->hyperspeed; ship->maxchaff = old->maxchaff; ship->realspeed = old->realspeed; ship->manuever = old->manuever; ship->cost = old->cost; ship->in_room = NULL; ship->next_in_room = NULL; ship->prev_in_room = NULL; ship->currjump = NULL; ship->target0 = NULL; ship->target1 = NULL; ship->target2 = NULL; ship->filename = str_dup( arg2 ); save_ship( ship ); write_ship_list( ); } void do_ships( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; int count = 0; if( !IS_NPC( ch ) ) { count = 0; send_to_pager_color( "&YThe following ships are owned by you or by your organization:\n\r", ch ); send_to_pager_color( "\n\r&WShip Owner\n\r", ch ); for( ship = first_ship; ship; ship = ship->next ) { if( str_cmp( ship->owner, ch->name ) ) { if( !ch->pcdata || !ch->pcdata->clan || str_cmp( ship->owner, ch->pcdata->clan->name ) || ship->class > SHIP_PLATFORM ) continue; } if( ship->type == MOB_SHIP ) continue; else if( ship->type == SHIP_REPUBLIC ) set_char_color( AT_BLOOD, ch ); else if( ship->type == SHIP_IMPERIAL ) set_char_color( AT_DGREEN, ch ); else set_char_color( AT_BLUE, ch ); if( ship->in_room ) pager_printf_color( ch, "%s (%s) - %s\n\r", ship->name, ship->in_room->name ); else pager_printf_color( ch, "%s (%s)\n\r", ship->name ); count++; } if( !count ) { send_to_pager_color( "There are no ships owned by you.\n\r", ch ); } } count = 0; send_to_pager_color( "&Y\n\rThe following ships are docked here:\n\r", ch ); send_to_pager_color( "\n\r&WShip Owner Cost/Rent\n\r", ch ); for( ship = first_ship; ship; ship = ship->next ) { if( ship->location != ch->in_room->vnum || ship->class > SHIP_PLATFORM ) continue; if( ship->type == MOB_SHIP ) continue; else if( ship->type == SHIP_REPUBLIC ) set_char_color( AT_BLOOD, ch ); else if( ship->type == SHIP_IMPERIAL ) set_char_color( AT_DGREEN, ch ); else set_char_color( AT_BLUE, ch ); pager_printf_color( ch, "%-35s %-15s", ship->name, ship->owner ); if( ship->type == MOB_SHIP || ship->class == SHIP_PLATFORM ) { pager_printf_color( ch, "\n\r" ); continue; } if( !str_cmp( ship->owner, "Public" ) ) { pager_printf_color( ch, "%s to rent.\n\r", num_punct( get_ship_value( ship ) / 100 ) ); } else if( str_cmp( ship->owner, "" ) ) pager_printf_color( ch, "%s", "\n\r" ); else pager_printf_color( ch, "%s to buy.\n\r", num_punct( get_ship_value( ship ) ) ); count++; } if( !count ) { send_to_pager_color( "There are no ships docked here.\n\r", ch ); } } void do_speeders( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; int count = 0; if( !IS_NPC( ch ) ) { count = 0; send_to_pager_color( "&YThe following are owned by you or by your organization:\n\r", ch ); send_to_pager_color( "\n\r&WVehicle Owner\n\r", ch ); for( ship = first_ship; ship; ship = ship->next ) { if( str_cmp( ship->owner, ch->name ) ) { if( !ch->pcdata || !ch->pcdata->clan || str_cmp( ship->owner, ch->pcdata->clan->name ) || ship->class <= SHIP_PLATFORM ) continue; } if( ship->location != ch->in_room->vnum || ship->class <= SHIP_PLATFORM ) continue; if( ship->type == MOB_SHIP ) continue; else if( ship->type == SHIP_REPUBLIC ) set_char_color( AT_BLOOD, ch ); else if( ship->type == SHIP_IMPERIAL ) set_char_color( AT_DGREEN, ch ); else set_char_color( AT_BLUE, ch ); pager_printf_color( ch, "%-35s %-15s\n\r", ship->name, ship->owner ); count++; } if( !count ) { send_to_pager_color( "There are no land or air vehicles owned by you.\n\r", ch ); } } count = 0; send_to_pager_color( "&Y\n\rThe following vehicles are parked here:\n\r", ch ); send_to_pager_color( "\n\r&WVehicle Owner Cost/Rent\n\r", ch ); for( ship = first_ship; ship; ship = ship->next ) { if( ship->location != ch->in_room->vnum || ship->class <= SHIP_PLATFORM ) continue; if( ship->type == MOB_SHIP ) continue; else if( ship->type == SHIP_REPUBLIC ) set_char_color( AT_BLOOD, ch ); else if( ship->type == SHIP_IMPERIAL ) set_char_color( AT_DGREEN, ch ); else set_char_color( AT_BLUE, ch ); pager_printf_color( ch, "%-35s %-15s", ship->name, ship->owner ); if( !str_cmp( ship->owner, "Public" ) ) { pager_printf_color( ch, "%s to rent.\n\r", num_punct( get_ship_value( ship ) / 100 ) ); } else if( str_cmp( ship->owner, "" ) ) pager_printf_color( ch, "%s", "\n\r" ); else pager_printf_color( ch, "%s to buy.\n\r", num_punct( get_ship_value( ship ) ) ); count++; } if( !count ) { send_to_pager_color( "There are no sea air or land vehicles here.\n\r", ch ); } } void do_allspeeders( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; int count = 0; count = 0; send_to_pager_color( "&Y\n\rThe following sea/land/air vehicles are currently formed:\n\r", ch ); send_to_pager_color( "\n\r&WVehicle Owner\n\r", ch ); for( ship = first_ship; ship; ship = ship->next ) { if( ship->class <= SHIP_PLATFORM ) continue; if( ship->type == MOB_SHIP ) continue; else if( ship->type == SHIP_REPUBLIC ) set_char_color( AT_BLOOD, ch ); else if( ship->type == SHIP_IMPERIAL ) set_char_color( AT_DGREEN, ch ); else set_char_color( AT_BLUE, ch ); pager_printf_color( ch, "%-35s %-15s ", ship->name, ship->owner ); if( !str_cmp( ship->owner, "Public" ) ) { pager_printf_color( ch, "%s to rent.\n\r", num_punct( get_ship_value( ship ) / 100 ) ); } else if( str_cmp( ship->owner, "" ) ) pager_printf_color( ch, "%s", "\n\r" ); else pager_printf_color( ch, "%s to buy.\n\r", num_punct( get_ship_value( ship ) ) ); count++; } if( !count ) { send_to_pager_color( "There are none currently formed.\n\r", ch ); return; } } void do_allships( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; int count = 0; count = 0; send_to_pager_color( "&Y\n\rThe following ships are currently formed:\n\r", ch ); send_to_pager_color( "\n\r&WShip Owner\n\r", ch ); if( IS_IMMORTAL( ch ) ) for( ship = first_ship; ship; ship = ship->next ) if( ship->type == MOB_SHIP ) pager_printf_color( ch, "&w%-35s %-15s\n\r", ship->name, ship->owner ); for( ship = first_ship; ship; ship = ship->next ) { if( ship->class > SHIP_PLATFORM ) continue; if( ship->type == MOB_SHIP ) continue; else if( ship->type == SHIP_REPUBLIC ) set_char_color( AT_BLOOD, ch ); else if( ship->type == SHIP_IMPERIAL ) set_char_color( AT_DGREEN, ch ); else set_char_color( AT_BLUE, ch ); pager_printf_color( ch, "%-35s %-15s ", ship->name, ship->owner ); if( ship->type == MOB_SHIP || ship->class == SHIP_PLATFORM ) { pager_printf_color( ch, "\n\r" ); continue; } if( !str_cmp( ship->owner, "Public" ) ) { pager_printf_color( ch, "%s to rent.\n\r", num_punct( get_ship_value( ship ) / 100 ) ); } else if( str_cmp( ship->owner, "" ) ) pager_printf_color( ch, "%s", "\n\r" ); else pager_printf_color( ch, "%s to buy.\n\r", num_punct( get_ship_value( ship ) ) ); count++; } if( !count ) { send_to_pager_color( "There are no ships currently formed.\n\r", ch ); return; } } void do_board( CHAR_DATA * ch, char *argument ) { ROOM_INDEX_DATA *fromroom; ROOM_INDEX_DATA *toroom; SHIP_DATA *ship; if( !argument || argument[0] == '\0' ) { send_to_pager_color( "Board what?\n\r", ch ); return; } if( ( ship = ship_in_room( ch->in_room, argument ) ) == NULL ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } if( xIS_SET( ch->act, ACT_MOUNTED ) ) { act( AT_PLAIN, "You can't go in there riding THAT.", ch, NULL, argument, TO_CHAR ); return; } if( ch->position < POS_STANDING ) { act( AT_PLAIN, "You can't do that in your current state.", ch, NULL, argument, TO_CHAR ); return; } fromroom = ch->in_room; if( ( toroom = get_room_index( ship->entrance ) ) != NULL ) { if( !ship->hatchopen ) { send_to_pager_color( "&RThe hatch is closed!\n\r", ch ); return; } if( toroom->tunnel > 0 ) { CHAR_DATA *ctmp; int count = 0; for( ctmp = toroom->first_person; ctmp; ctmp = ctmp->next_in_room ) if( ++count >= toroom->tunnel ) { send_to_pager_color( "There is no room for you in there.\n\r", ch ); return; } } if( ship->shipstate == SHIP_LAUNCH || ship->shipstate == SHIP_LAUNCH_2 ) { send_to_pager_color( "&rThat ship has already started launching!\n\r", ch ); return; } act( AT_PLAIN, "$n enters $T.", ch, NULL, ship->name, TO_ROOM ); act( AT_PLAIN, "You enter $T.", ch, NULL, ship->name, TO_CHAR ); char_from_room( ch ); char_to_room( ch, toroom ); act( AT_PLAIN, "$n enters the ship.", ch, NULL, argument, TO_ROOM ); do_look( ch, "auto" ); } else send_to_pager_color( "That ship has no entrance!\n\r", ch ); } void do_leaveship( CHAR_DATA * ch, char *argument ) { ROOM_INDEX_DATA *fromroom; ROOM_INDEX_DATA *toroom; SHIP_DATA *ship; fromroom = ch->in_room; if( ( ship = ship_from_entrance( fromroom->vnum ) ) == NULL ) { send_to_pager_color( "I see no exit here.\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "You can't do that here.\n\r", ch ); return; } if( ship->lastdoc != ship->location ) { send_to_pager_color( "&rMaybe you should wait until the ship lands.\n\r", ch ); return; } if( ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED ) { send_to_pager_color( "&rPlease wait till the ship is properly docked.\n\r", ch ); return; } if( !ship->hatchopen ) { send_to_pager_color( "&RYou need to open the hatch first", ch ); return; } if( ch->position < POS_STANDING ) { act( AT_PLAIN, "You can't do that in your current state.", ch, NULL, argument, TO_CHAR ); return; } if( ( toroom = get_room_index( ship->location ) ) != NULL ) { act( AT_PLAIN, "$n exits the ship.", ch, NULL, argument, TO_ROOM ); act( AT_PLAIN, "You exit the ship.", ch, NULL, argument, TO_CHAR ); char_from_room( ch ); char_to_room( ch, toroom ); act( AT_PLAIN, "$n steps out of a ship.", ch, NULL, argument, TO_ROOM ); do_look( ch, "auto" ); } else send_to_pager_color( "The exit doesn't seem to be working properly.\n\r", ch ); } void do_launch( CHAR_DATA * ch, char *argument ) { long price = 0; SHIP_DATA *ship; char buf[MAX_STRING_LENGTH]; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou don't seem to be in the pilot seat!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RThe ship is set on autopilot, you'll have to turn it off first.\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "You can't do that here.\n\r", ch ); return; } if( !check_pilot( ch, ship ) ) { send_to_pager_color( "&RHey, thats not your ship! Try renting a public one.\n\r", ch ); return; } if( ship->lastdoc != ship->location ) { send_to_pager_color( "&rYou don't seem to be docked right now.\n\r", ch ); return; } if( ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED ) { send_to_pager_color( "The ship is not docked right now.\n\r", ch ); return; } /* if ( ship->class == FIGHTER_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_starfighters]) ; if ( ship->class == MIDSIZE_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_midships]) ; if ( ship->class == CAPITAL_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_capitalships]); */ if( is_rental( ch, ship ) ) if( !rent_ship( ch, ship ) ) return; if( !is_rental( ch, ship ) ) { if( ship->class == FIGHTER_SHIP ) price = 20; if( ship->class == MIDSIZE_SHIP ) price = 50; if( ship->class == CAPITAL_SHIP ) price = 500; price += ( ship->maxhull - ship->hull ); if( ship->missiles ) price += ( 50 * ( ship->maxmissiles - ship->missiles ) ); else if( ship->torpedos ) price += ( 75 * ( ship->maxtorpedos - ship->torpedos ) ); else if( ship->rockets ) price += ( 150 * ( ship->maxrockets - ship->rockets ) ); if( ship->shipstate == SHIP_DISABLED ) price += 200; if( ship->missilestate == MISSILE_DAMAGED ) price += 100; if( ship->statet0 == LASER_DAMAGED ) price += 50; if( ship->statet1 == LASER_DAMAGED ) price += 50; if( ship->statet2 == LASER_DAMAGED ) price += 50; } /* if ( ch->pcdata && ch->pcdata->clan && !str_cmp(ch->pcdata->clan->name,ship->owner) ) { if ( ch->pcdata->clan->funds < price ) { pager_printf_color(ch, "&R%s doesn't have enough funds to prepare this ship for launch.\n\r", ch->pcdata->clan->name ); return; } ch->pcdata->clan->funds -= price; pager_printf_color(ch, "&GIt costs %s %ld credits to ready this ship for launch.\n\r", ch->pcdata->clan->name, price ); } */ else if( str_cmp( ship->owner, "Public" ) ) { if( ch->gold < price ) { pager_printf_color( ch, "&RYou don't have enough funds to prepare this ship for launch.\n\r" ); return; } ch->gold -= price; pager_printf_color( ch, "&GYou pay %ld credits to ready the ship for launch.\n\r", price ); } ship->energy = ship->maxenergy; ship->chaff = ship->maxchaff; ship->missiles = ship->maxmissiles; ship->torpedos = ship->maxtorpedos; ship->rockets = ship->maxrockets; ship->shield = 0; ship->autorecharge = FALSE; ship->autotrack = FALSE; ship->autospeed = FALSE; ship->hull = ship->maxhull; ship->missilestate = MISSILE_READY; ship->statet0 = LASER_READY; ship->statet1 = LASER_READY; ship->statet2 = LASER_READY; ship->shipstate = SHIP_DOCKED; if( ship->hatchopen ) { ship->hatchopen = FALSE; sprintf( buf, "The hatch on %s closes.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); echo_to_room( AT_YELLOW, get_room_index( ship->entrance ), "The hatch slides shut." ); } set_char_color( AT_GREEN, ch ); send_to_pager_color( "Launch sequence initiated.\n\r", ch ); act( AT_PLAIN, "$n starts up the ship and begins the launch sequence.", ch, NULL, argument, TO_ROOM ); echo_to_ship( AT_YELLOW, ship, "The ship hums as it lifts off the ground." ); sprintf( buf, "%s begins to launch.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); ship->shipstate = SHIP_LAUNCH; ship->currspeed = ship->realspeed; if( ship->class == FIGHTER_SHIP ) learn_from_success( ch, gsn_starfighters ); if( ship->class == MIDSIZE_SHIP ) learn_from_success( ch, gsn_midships ); if( ship->class == CAPITAL_SHIP ) learn_from_success( ch, gsn_capitalships ); return; } void do_land( CHAR_DATA * ch, char *argument ) { char arg[MAX_INPUT_LENGTH]; SHIP_DATA *ship; SHIP_DATA *target; int vx = 0; int vy = 0; int vz = 0; strcpy( arg, argument ); if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou need to be in the pilot seat!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first.\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RYou can't land platforms\n\r", ch ); return; } if( ship->class == CAPITAL_SHIP ) { send_to_pager_color( "&RCapital ships are to big to land. You'll have to take a shuttle.\n\r", ch ); return; } if( ship->shipstate == SHIP_DISABLED ) { send_to_pager_color( "&RThe ships drive is disabled. Unable to land.\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RThe ship is already docked!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( ship->shipstate != SHIP_READY ) { send_to_pager_color( "&RPlease wait until the ship has finished its current manouver.\n\r", ch ); return; } if( ship->starsystem == NULL ) { send_to_pager_color( "&RThere's nowhere to land around here!", ch ); return; } if( ship->energy < ( 25 + 25 * ship->class ) ) { send_to_pager_color( "&RTheres not enough fuel!\n\r", ch ); return; } if( argument[0] == '\0' ) { set_char_color( AT_CYAN, ch ); pager_printf_color( ch, "%s", "Land where?\n\r\n\rChoices: " ); if( ship->starsystem->doc1a ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location1a, ship->starsystem->planet1, ship->starsystem->p1x, ship->starsystem->p1y, ship->starsystem->p1z ); if( ship->starsystem->doc1b ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location1b, ship->starsystem->planet1, ship->starsystem->p1x, ship->starsystem->p1y, ship->starsystem->p1z ); if( ship->starsystem->doc1c ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location1c, ship->starsystem->planet1, ship->starsystem->p1x, ship->starsystem->p1y, ship->starsystem->p1z ); if( ship->starsystem->doc2a ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location2a, ship->starsystem->planet2, ship->starsystem->p2x, ship->starsystem->p2y, ship->starsystem->p2z ); if( ship->starsystem->doc2b ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location2b, ship->starsystem->planet2, ship->starsystem->p2x, ship->starsystem->p2y, ship->starsystem->p2z ); if( ship->starsystem->doc2c ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location2c, ship->starsystem->planet2, ship->starsystem->p2x, ship->starsystem->p2y, ship->starsystem->p2z ); if( ship->starsystem->doc3a ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location3a, ship->starsystem->planet3, ship->starsystem->p3x, ship->starsystem->p3y, ship->starsystem->p3z ); if( ship->starsystem->doc3b ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location3b, ship->starsystem->planet3, ship->starsystem->p3x, ship->starsystem->p3y, ship->starsystem->p3z ); if( ship->starsystem->doc3c ) pager_printf_color( ch, "%s (%s) %d %d %d\n\r ", ship->starsystem->location3c, ship->starsystem->planet3, ship->starsystem->p3x, ship->starsystem->p3y, ship->starsystem->p3z ); for( target = ship->starsystem->first_ship; target; target = target->next_in_starsystem ) { if( target->hanger > 0 && target != ship ) pager_printf_color( ch, "%s %.0f %.0f %.0f\n\r ", target->name, target->vx, target->vy, target->vz ); } pager_printf_color( ch, "\n\rYour Coordinates: %.0f %.0f %.0f\n\r", ship->vx, ship->vy, ship->vz ); return; } if( str_prefix( argument, ship->starsystem->location1a ) && str_prefix( argument, ship->starsystem->location2a ) && str_prefix( argument, ship->starsystem->location3a ) && str_prefix( argument, ship->starsystem->location1b ) && str_prefix( argument, ship->starsystem->location2b ) && str_prefix( argument, ship->starsystem->location3b ) && str_prefix( argument, ship->starsystem->location1c ) && str_prefix( argument, ship->starsystem->location2c ) && str_prefix( argument, ship->starsystem->location3c ) ) { target = get_ship_here( argument, ship->starsystem ); if( target == NULL ) { send_to_pager_color( "&RI don't see that here. Type land by itself for a list\n\r", ch ); return; } if( target == ship ) { send_to_pager_color( "&RYou can't land your ship inside itself!\n\r", ch ); return; } if( !target->hanger ) { send_to_pager_color( "&RThat ship has no hanger for you to land in!\n\r", ch ); return; } if( ship->class == MIDSIZE_SHIP && target->class == MIDSIZE_SHIP ) { send_to_pager_color( "&RThat ship is not big enough for your ship to land in!\n\r", ch ); return; } if( !target->bayopen ) { send_to_pager_color( "&RTheir hanger is closed. You'll have to ask them to open it for you\n\r", ch ); 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 ) ) { send_to_pager_color( "&R That ship is too far away! You'll have to fly a little closer.\n\r", ch ); return; } } else { if( !str_prefix( argument, ship->starsystem->location3a ) || !str_prefix( argument, ship->starsystem->location3b ) || !str_prefix( argument, ship->starsystem->location3c ) ) { vx = ship->starsystem->p3x; vy = ship->starsystem->p3y; vz = ship->starsystem->p3z; } if( !str_prefix( argument, ship->starsystem->location2a ) || !str_prefix( argument, ship->starsystem->location2b ) || !str_prefix( argument, ship->starsystem->location2c ) ) { vx = ship->starsystem->p2x; vy = ship->starsystem->p2y; vz = ship->starsystem->p2z; } if( !str_prefix( argument, ship->starsystem->location1a ) || !str_prefix( argument, ship->starsystem->location1b ) || !str_prefix( argument, ship->starsystem->location1c ) ) { vx = ship->starsystem->p1x; vy = ship->starsystem->p1y; vz = ship->starsystem->p1z; } if( ( vx > ship->vx + 200 ) || ( vx < ship->vx - 200 ) || ( vy > ship->vy + 200 ) || ( vy < ship->vy - 200 ) || ( vz > ship->vz + 200 ) || ( vz < ship->vz - 200 ) ) { send_to_pager_color( "&R That platform is too far away! You'll have to fly a little closer.\n\r", ch ); return; } } /* if ( ship->class == FIGHTER_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_starfighters]) ; if ( ship->class == MIDSIZE_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_midships]) ; */ set_char_color( AT_GREEN, ch ); send_to_pager_color( "Landing sequence initiated.\n\r", ch ); act( AT_PLAIN, "$n begins the landing sequence.", ch, NULL, argument, TO_ROOM ); echo_to_ship( AT_YELLOW, ship, "The ship slowly begins its landing aproach." ); ship->dest = STRALLOC( arg ); ship->shipstate = SHIP_LAND; ship->currspeed = 0; if( ship->class == FIGHTER_SHIP ) learn_from_success( ch, gsn_starfighters ); if( ship->class == MIDSIZE_SHIP ) learn_from_success( ch, gsn_midships ); return; } void do_accelerate( CHAR_DATA * ch, char *argument ) { int change; SHIP_DATA *ship; char buf[MAX_STRING_LENGTH]; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RThe controls must be at the pilots chair...\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first.\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RPlatforms can't move!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( ship->shipstate == SHIP_DISABLED ) { send_to_pager_color( "&RThe ships drive is disabled. Unable to accelerate.\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RYou can't do that until after you've launched!\n\r", ch ); return; } if( ship->energy < abs( ( atoi( argument ) - abs( ship->currspeed ) ) / 10 ) ) { send_to_pager_color( "&RTheres not enough fuel!\n\r", ch ); return; } /* if ( ship->class == FIGHTER_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_starfighters]) ; if ( ship->class == MIDSIZE_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_midships]) ; if ( ship->class == CAPITAL_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_capitalships]); */ change = atoi( argument ); act( AT_PLAIN, "$n manipulates the ships controls.", ch, NULL, argument, TO_ROOM ); if( change > ship->currspeed ) { send_to_pager_color( "&GAccelerating\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "The ship begins to accelerate." ); sprintf( buf, "%s begins to speed up.", ship->name ); echo_to_system( AT_ORANGE, ship, buf, NULL ); } if( change < ship->currspeed ) { send_to_pager_color( "&GDecelerating\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "The ship begins to slow down." ); sprintf( buf, "%s begins to slow down.", ship->name ); echo_to_system( AT_ORANGE, ship, buf, NULL ); } ship->energy -= abs( ( change - abs( ship->currspeed ) ) / 10 ); ship->currspeed = URANGE( 0, change, ship->realspeed ); if( ship->class == FIGHTER_SHIP ) learn_from_success( ch, gsn_starfighters ); if( ship->class == MIDSIZE_SHIP ) learn_from_success( ch, gsn_midships ); if( ship->class == CAPITAL_SHIP ) learn_from_success( ch, gsn_capitalships ); } void do_trajectory( CHAR_DATA * ch, char *argument ) { char buf[MAX_STRING_LENGTH]; char arg2[MAX_INPUT_LENGTH]; char arg3[MAX_INPUT_LENGTH]; float vx, vy, vz; SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYour not in the pilots seat.\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first.\n\r", ch ); return; } if( ship->shipstate == SHIP_DISABLED ) { send_to_pager_color( "&RThe ships drive is disabled. Unable to manuever.\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RPlatforms can't turn!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RYou can't do that until after you've launched!\n\r", ch ); return; } if( ship->shipstate != SHIP_READY ) { send_to_pager_color( "&RPlease wait until the ship has finished its current manouver.\n\r", ch ); return; } if( ship->energy < ( ship->currspeed / 10 ) ) { send_to_pager_color( "&RTheres not enough fuel!\n\r", ch ); return; } /* if ( ship->class == FIGHTER_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_starfighters]) ; if ( ship->class == MIDSIZE_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_midships]) ; if ( ship->class == CAPITAL_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_capitalships]); */ argument = one_argument( argument, arg2 ); argument = one_argument( argument, arg3 ); vx = atof( arg2 ); vy = atof( arg3 ); vz = atof( argument ); if( vx == ship->vx && vy == ship->vy && vz == ship->vz ) { pager_printf_color( ch, "The ship is already at %.0f %.0f %.0f !", vx, vy, vz ); } ship->hx = vx - ship->vx; ship->hy = vy - ship->vy; ship->hz = vz - ship->vz; ship->energy -= ( ship->currspeed / 10 ); pager_printf_color( ch, "&GNew course set, aproaching %.0f %.0f %.0f.\n\r", vx, vy, vz ); act( AT_PLAIN, "$n manipulates the ships controls.", ch, NULL, argument, TO_ROOM ); echo_to_cockpit( AT_YELLOW, ship, "The ship begins to turn.\n\r" ); sprintf( buf, "%s turns altering its present course.", ship->name ); echo_to_system( AT_ORANGE, ship, buf, NULL ); if( ship->class == FIGHTER_SHIP || ( ship->class == MIDSIZE_SHIP && ship->manuever > 50 ) ) ship->shipstate = SHIP_BUSY_3; else if( ship->class == MIDSIZE_SHIP || ( ship->class == CAPITAL_SHIP && ship->manuever > 50 ) ) ship->shipstate = SHIP_BUSY_2; else ship->shipstate = SHIP_BUSY; if( ship->class == FIGHTER_SHIP ) learn_from_success( ch, gsn_starfighters ); if( ship->class == MIDSIZE_SHIP ) learn_from_success( ch, gsn_midships ); if( ship->class == CAPITAL_SHIP ) learn_from_success( ch, gsn_capitalships ); } void do_buyship( CHAR_DATA * ch, char *argument ) { long price; SHIP_DATA *ship; SHIP_DATA *ship_list; if( IS_NPC( ch ) || !ch->pcdata ) { send_to_pager_color( "&ROnly players can do that!\n\r", ch ); return; } ship = ship_in_room( ch->in_room, argument ); if( !ship ) { ship = ship_from_cockpit( ch->in_room->vnum ); if( !ship ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } } if( str_cmp( ship->owner, "" ) || ship->type == MOB_SHIP ) { send_to_pager_color( "&RThat ship isn't for sale!", ch ); return; } /* if ( ship->type == SHIP_IMPERIAL ) { if ( !ch->pcdata->clan || str_cmp( ch->pcdata->clan->name , "the empire" ) ) { if ( !ch->pcdata->clan || !ch->pcdata->clan->mainclan || str_cmp( ch->pcdata->clan->mainclan->name , "The Empire" ) ) { send_to_pager_color( "&RThat ship may only be purchaced by the Empire!\n\r" ,ch ); return; } } } else if ( ship->type == SHIP_REPUBLIC ) { if ( !ch->pcdata->clan || str_cmp( ch->pcdata->clan->name , "the new republic" ) ) { if ( !ch->pcdata->clan || !ch->pcdata->clan->mainclan || str_cmp( ch->pcdata->clan->mainclan->name , "The New Republic" ) ) { send_to_pager_color( "&RThat ship may only be purchaced by The New Republic!\n\r" ,ch ); return; } } } else { if ( ch->pcdata->clan && ( !str_cmp( ch->pcdata->clan->name , "the new republic" ) || ( ch->pcdata->clan->mainclan && !str_cmp(ch->pcdata->clan->mainclan->name ,"the new republic") ) ) ) { send_to_pager_color( "&RAs a member of the New Republic you may only purchase NR Ships!\n\r" ,ch ); return; } if ( ch->pcdata->clan && ( !str_cmp( ch->pcdata->clan->name , "the empire" ) || ( ch->pcdata->clan->mainclan && !str_cmp(ch->pcdata->clan->mainclan->name ,"the empire") ) ) ) { send_to_pager_color( "&RAs a member of the Empire you may only purchase Imperial Ships!\n\r" ,ch ); return; } } */ price = get_ship_value( ship ); if( ch->gold < price ) { pager_printf_color( ch, "&RThis ship costs %s. You don't have enough zeni!\n\r", num_punct( price ) ); return; } for( ship_list = first_ship; ship_list; ship_list = ship_list->next ) { if( ship_list && ship_list->owner && !str_cmp( ship_list->owner, ch->name ) ) { send_to_pager_color( "&RYou already own a ship! Sell it before buying another.\n\r", ch ); return; } } ch->gold -= price; pager_printf_color( ch, "&GYou pay %s credits to purchace the ship.\n\r", num_punct( price ) ); act( AT_PLAIN, "$n walks over to a terminal and makes a credit transaction.", ch, NULL, argument, TO_ROOM ); STRFREE( ship->owner ); ship->owner = STRALLOC( ch->name ); save_ship( ship ); } /* void do_clanbuyship(CHAR_DATA *ch, char *argument ) { long price; SHIP_DATA *ship; CLAN_DATA *clan; CLAN_DATA *mainclan; if ( IS_NPC(ch) || !ch->pcdata ) { send_to_pager_color( "&ROnly players can do that!\n\r" ,ch ); return; } if ( !ch->pcdata->clan ) { send_to_pager_color( "&RYou aren't a member of any organizations!\n\r" ,ch ); return; } clan = ch->pcdata->clan; mainclan = ch->pcdata->clan->mainclan ? ch->pcdata->clan->mainclan : clan; if ( ( ch->pcdata->bestowments && is_name("clanbuyship", ch->pcdata->bestowments)) || !str_cmp( ch->name, clan->leader )) ; else { send_to_pager_color( "&RYour organization hasn't seen fit to bestow you with that ability.\n\r" ,ch ); return; } ship = ship_in_room( ch->in_room , argument ); if ( !ship ) { ship = ship_from_cockpit( ch->in_room->vnum ); if ( !ship ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } } if ( str_cmp( ship->owner , "" ) || ship->type == MOB_SHIP ) { send_to_pager_color( "&RThat ship isn't for sale!\n\r" ,ch ); return; } if ( str_cmp( mainclan->name , "The Empire" ) && ship->type == SHIP_IMPERIAL ) { send_to_pager_color( "&RThat ship may only be purchaced by the Empire!\n\r" ,ch ); return; } if ( str_cmp( mainclan->name , "The New Republic" ) && ship->type == SHIP_REPUBLIC ) { send_to_pager_color( "&RThat ship may only be purchaced by The New Republic!\n\r" ,ch ); return; } if ( !str_cmp( mainclan->name , "The Empire" ) && ship->type != SHIP_IMPERIAL ) { send_to_pager_color( "&RDue to contractual agreements that ship may not be purchaced by the empire!\n\r" ,ch ); return; } if ( !str_cmp( mainclan->name , "The New Republic" ) && ship->type != SHIP_REPUBLIC ) { send_to_pager_color( "&RBecause of contractual agreements, the NR can only purchase NR ships!\n\r" ,ch ); return; } price = get_ship_value( ship ); if ( ch->pcdata->clan->funds < price ) { pager_printf_color(ch, "&RThis ship costs %ld. You don't have enough credits!\n\r" , price ); return; } clan->funds -= price; pager_printf_color(ch, "&G%s pays %ld credits to purchace the ship.\n\r", clan->name , price ); act( AT_PLAIN, "$n walks over to a terminal and makes a credit transaction.",ch, NULL, argument , TO_ROOM ); STRFREE( ship->owner ); ship->owner = STRALLOC( clan->name ); save_ship( ship ); if ( ship->class <= SHIP_PLATFORM ) clan->spacecraft++; else clan->vehicles++; } */ void do_sellship( CHAR_DATA * ch, char *argument ) { long price; SHIP_DATA *ship; ship = ship_in_room( ch->in_room, argument ); if( !ship ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } if( str_cmp( ship->owner, ch->name ) ) { send_to_pager_color( "&RThat isn't your ship!", ch ); return; } price = get_ship_value( ship ); ch->gold += ( price - price / 2 ); pager_printf_color( ch, "&GYou receive %s credits from selling your ship.\n\r", num_punct( price - price / 10 ) ); act( AT_PLAIN, "$n walks over to a terminal and makes a credit transaction.", ch, NULL, argument, TO_ROOM ); STRFREE( ship->owner ); ship->owner = STRALLOC( "" ); save_ship( ship ); } void do_shipinfo( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; SHIP_DATA *target; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { if( argument[0] == '\0' ) { act( AT_PLAIN, "Which ship do you want info on?.", ch, NULL, NULL, TO_CHAR ); return; } ship = ship_in_room( ch->in_room, argument ); if( !ship ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } target = ship; } else if( argument[0] == '\0' ) target = ship; else target = get_ship_here( argument, ship->starsystem ); if( target == NULL ) { send_to_pager_color( "&RI don't see that here.\n\rTry the radar, or type info by itself for info on this ship.\n\r", ch ); return; } if( abs( target->vx - ship->vx ) > 500 + ship->sensor * 2 || abs( target->vy - ship->vy ) > 500 + ship->sensor * 2 || abs( target->vz - ship->vz ) > 500 + ship->sensor * 2 ) { send_to_pager_color( "&RThat ship is to far away to scan.\n\r", ch ); return; } pager_printf_color( ch, "&Y%s %s : %s\n\r&B", target->type == SHIP_REPUBLIC ? "New Republic" : ( target->type == SHIP_IMPERIAL ? "Imperial" : "Civilian" ), target->class == FIGHTER_SHIP ? "Starfighter" : ( target->class == MIDSIZE_SHIP ? "Midtarget" : ( target->class == CAPITAL_SHIP ? "Capital Ship" : ( ship->class == SHIP_PLATFORM ? "Platform" : ( ship->class == CLOUD_CAR ? "Cloudcar" : ( ship->class == OCEAN_SHIP ? "Boat" : ( ship->class == LAND_SPEEDER ? "Speeder" : ( ship->class == WHEELED ? "Wheeled Transport" : ( ship->class == LAND_CRAWLER ? "Crawler" : ( ship->class == WALKER ? "Walker" : "Unknown" ) ) ) ) ) ) ) ) ), target->name, target->filename ); pager_printf_color( ch, "Description: %s\n\rOwner: %s Pilot: %s Copilot: %s\n\r", target->description, target->owner, target->pilot, target->copilot ); pager_printf_color( ch, "Laser cannons: %d ", target->lasers ); pager_printf_color( ch, "Maximum Missiles: %d ", target->maxmissiles ); pager_printf_color( ch, "Max Chaff: %d\n\r", target->maxchaff ); pager_printf_color( ch, "Max Hull: %d ", target->maxhull ); pager_printf_color( ch, "Max Shields: %d Max Energy(fuel): %d\n\r", target->maxshield, target->maxenergy ); pager_printf_color( ch, "Maximum Speed: %d Hyperspeed: %d\n\r", target->realspeed, target->hyperspeed ); act( AT_PLAIN, "$n checks various gages and displays on the control panel.", ch, NULL, argument, TO_ROOM ); } void do_autorecharge( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; int recharge; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ( ship = ship_from_coseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the co-pilots seat!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first.\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_shipsystems]) ; */ act( AT_PLAIN, "$n flips a switch on the control panell.", ch, NULL, argument, TO_ROOM ); if( !str_cmp( argument, "on" ) ) { ship->autorecharge = TRUE; send_to_pager_color( "&GYou power up the shields.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Shields ON. Autorecharge ON." ); } else if( !str_cmp( argument, "off" ) ) { ship->autorecharge = FALSE; send_to_pager_color( "&GYou shutdown the shields.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Shields OFF. Shield strength set to 0. Autorecharge OFF." ); ship->shield = 0; } else if( !str_cmp( argument, "idle" ) ) { ship->autorecharge = FALSE; send_to_pager_color( "&GYou let the shields idle.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Autorecharge OFF. Shields IDLEING." ); } else { if( ship->autorecharge == TRUE ) { ship->autorecharge = FALSE; send_to_pager_color( "&GYou toggle the shields.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Autorecharge OFF. Shields IDLEING." ); } else { ship->autorecharge = TRUE; send_to_pager_color( "&GYou toggle the shields.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Shields ON. Autorecharge ON" ); } } if( ship->autorecharge ) { recharge = URANGE( 1, ship->maxshield - ship->shield, 25 + ship->class * 25 ); recharge = UMIN( recharge, ship->energy * 5 + 100 ); ship->shield += recharge; ship->energy -= ( recharge * 2 + recharge * ship->class ); } learn_from_success( ch, gsn_shipsystems ); } void do_autopilot( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the pilots seat!\n\r", ch ); return; } if( !check_pilot( ch, ship ) ) { send_to_pager_color( "&RHey! Thats not your ship!\n\r", ch ); return; } if( ship->target0 || ship->target1 || ship->target2 ) { send_to_pager_color( "&RNot while the ship is enganged with an enemy!\n\r", ch ); return; } act( AT_PLAIN, "$n flips a switch on the control panell.", ch, NULL, argument, TO_ROOM ); if( ship->autopilot == TRUE ) { ship->autopilot = FALSE; send_to_pager_color( "&GYou toggle the autopilot.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Autopilot OFF." ); } else { ship->autopilot = TRUE; ship->autorecharge = TRUE; send_to_pager_color( "&GYou toggle the autopilot.\n\r", ch ); echo_to_cockpit( AT_YELLOW, ship, "Autopilot ON." ); } } void do_openhatch( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; char buf[MAX_STRING_LENGTH]; if( !argument || argument[0] == '\0' || !str_cmp( argument, "hatch" ) ) { ship = ship_from_entrance( ch->in_room->vnum ); if( ship == NULL ) { send_to_pager_color( "&ROpen what?\n\r", ch ); return; } else { if( !ship->hatchopen ) { if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RTry one of the docking bays!\n\r", ch ); return; } if( ship->location != ship->lastdoc || ( ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED ) ) { send_to_pager_color( "&RPlease wait till the ship lands!\n\r", ch ); return; } ship->hatchopen = TRUE; send_to_pager_color( "&GYou open the hatch.\n\r", ch ); act( AT_PLAIN, "$n opens the hatch.", ch, NULL, argument, TO_ROOM ); sprintf( buf, "The hatch on %s opens.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); return; } else { send_to_pager_color( "&RIt's already open.\n\r", ch ); return; } } } ship = ship_in_room( ch->in_room, argument ); if( !ship ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } if( ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED ) { send_to_pager_color( "&RThat ship has already started to launch", ch ); return; } if( !check_pilot( ch, ship ) ) { send_to_pager_color( "&RHey! Thats not your ship!\n\r", ch ); return; } if( !ship->hatchopen ) { ship->hatchopen = TRUE; act( AT_PLAIN, "You open the hatch on $T.", ch, NULL, ship->name, TO_CHAR ); act( AT_PLAIN, "$n opens the hatch on $T.", ch, NULL, ship->name, TO_ROOM ); echo_to_room( AT_YELLOW, get_room_index( ship->entrance ), "The hatch opens from the outside." ); return; } send_to_pager_color( "&GIts already open!\n\r", ch ); } void do_closehatch( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; char buf[MAX_STRING_LENGTH]; if( !argument || argument[0] == '\0' || !str_cmp( argument, "hatch" ) ) { ship = ship_from_entrance( ch->in_room->vnum ); if( ship == NULL ) { send_to_pager_color( "&RClose what?\n\r", ch ); return; } else { if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RTry one of the docking bays!\n\r", ch ); return; } if( !check_pilot( ch, ship ) ) { send_to_pager_color( "&RHey! Thats not your ship!\n\r", ch ); return; } if( ship->hatchopen ) { ship->hatchopen = FALSE; send_to_pager_color( "&GYou close the hatch.\n\r", ch ); act( AT_PLAIN, "$n closes the hatch.", ch, NULL, argument, TO_ROOM ); sprintf( buf, "The hatch on %s closes.", ship->name ); echo_to_room( AT_YELLOW, get_room_index( ship->location ), buf ); return; } else { send_to_pager_color( "&RIt's already closed.\n\r", ch ); return; } } } ship = ship_in_room( ch->in_room, argument ); if( !ship ) { act( AT_PLAIN, "I see no $T here.", ch, NULL, argument, TO_CHAR ); return; } if( ship->shipstate != SHIP_DOCKED && ship->shipstate != SHIP_DISABLED ) { send_to_pager_color( "&RThat ship has already started to launch", ch ); return; } else { if( ship->hatchopen ) { if( !check_pilot( ch, ship ) ) { send_to_pager_color( "&RHey! Thats not your ship!\n\r", ch ); return; } ship->hatchopen = FALSE; act( AT_PLAIN, "You close the hatch on $T.", ch, NULL, ship->name, TO_CHAR ); act( AT_PLAIN, "$n closes the hatch on $T.", ch, NULL, ship->name, TO_ROOM ); echo_to_room( AT_YELLOW, get_room_index( ship->entrance ), "The hatch is closed from outside." ); return; } else { send_to_pager_color( "&RIts already closed.\n\r", ch ); return; } } } void do_status( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; SHIP_DATA *target; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit, turret or engineroom of a ship to do that!\n\r", ch ); return; } if( argument[0] == '\0' ) target = ship; else target = get_ship_here( argument, ship->starsystem ); if( target == NULL ) { send_to_pager_color( "&RI don't see that here.\n\rTry the radar, or type status by itself for your ships status.\n\r", ch ); return; } if( abs( target->vx - ship->vx ) > 500 + ship->sensor * 2 || abs( target->vy - ship->vy ) > 500 + ship->sensor * 2 || abs( target->vz - ship->vz ) > 500 + ship->sensor * 2 ) { send_to_pager_color( "&RThat ship is to far away to scan.\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_shipsystems]) ; */ act( AT_PLAIN, "$n checks various gages and displays on the control panel.", ch, NULL, argument, TO_ROOM ); pager_printf_color( ch, "&W%s:\n\r", target->name ); pager_printf_color( ch, "&OCurrent Coordinates:&Y %.0f %.0f %.0f\n\r", target->vx, target->vy, target->vz ); pager_printf_color( ch, "&OCurrent Heading:&Y %.0f %.0f %.0f\n\r", target->hx, target->hy, target->hz ); pager_printf_color( ch, "&OCurrent Speed:&Y %d&O/%d\n\r", target->currspeed, target->realspeed ); pager_printf_color( ch, "&OHull:&Y %d&O/%d Ship Condition:&Y %s\n\r", target->hull, target->maxhull, target->shipstate == SHIP_DISABLED ? "Disabled" : "Running" ); pager_printf_color( ch, "&OShields:&Y %d&O/%d Energy(fuel):&Y %d&O/%d\n\r", target->shield, target->maxshield, target->energy, target->maxenergy ); pager_printf_color( ch, "&OLaser Condition:&Y %s &OCurrent Target:&Y %s\n\r", target->statet0 == LASER_DAMAGED ? "Damaged" : "Good", target->target0 ? target->target0->name : "none" ); if( target->turret1 ) pager_printf_color( ch, "&OTurret One:&Y %s &OCurrent Target:&Y %s\n\r", target->statet1 == LASER_DAMAGED ? "Damaged" : "Good", target->target1 ? target->target1->name : "none" ); if( target->turret2 ) pager_printf_color( ch, "&OTurret Two:&Y %s &OCurrent Target:&Y %s\n\r", target->statet2 == LASER_DAMAGED ? "Damaged" : "Good", target->target2 ? target->target2->name : "none" ); pager_printf_color( ch, "\n\r&OMissiles:&Y %d&O/%d Torpedos: &Y%d&O/%d Rockets: &Y%d&O/%d Condition:&Y %s&w\n\r", ship->missiles, ship->maxmissiles, ship->torpedos, ship->maxtorpedos, ship->rockets, ship->maxrockets, ship->missilestate == MISSILE_DAMAGED ? "Damaged" : "Good" ); learn_from_success( ch, gsn_shipsystems ); } void do_hyperspace( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; SHIP_DATA *eShip; char buf[MAX_STRING_LENGTH]; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou aren't in the pilots seat.\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first.\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RPlatforms can't move!\n\r", ch ); return; } if( ship->hyperspeed == 0 ) { send_to_pager_color( "&RThis ship is not equipped with a hyperdrive!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou are already travelling lightspeed!\n\r", ch ); return; } if( ship->shipstate == SHIP_DISABLED ) { send_to_pager_color( "&RThe ships drive is disabled. Unable to manuever.\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RYou can't do that until after you've launched!\n\r", ch ); return; } if( ship->shipstate != SHIP_READY ) { send_to_pager_color( "&RPlease wait until the ship has finished its current manouver.\n\r", ch ); return; } if( !ship->currjump ) { send_to_pager_color( "&RYou need to calculate your jump first!\n\r", ch ); return; } if( ship->energy < ( 200 + ship->hyperdistance * ( 1 + ship->class ) / 3 ) ) { send_to_pager_color( "&RTheres not enough fuel!\n\r", ch ); return; } if( ship->currspeed <= 0 ) { send_to_pager_color( "&RYou need to speed up a little first!\n\r", ch ); return; } for( eShip = ship->starsystem->first_ship; eShip; eShip = eShip->next_in_starsystem ) { if( eShip == ship ) continue; if( abs( eShip->vx - ship->vx ) < 500 && abs( eShip->vy - ship->vy ) < 500 && abs( eShip->vz - ship->vz ) < 500 ) { pager_printf_color( ch, "&RYou are too close to %s to make the jump to lightspeed.\n\r", eShip->name ); return; } } /* if ( ship->class == FIGHTER_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_starfighters]) ; if ( ship->class == MIDSIZE_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_midships]) ; if ( ship->class == CAPITAL_SHIP ) chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_capitalships]); */ sprintf( buf, "%s disapears from your scanner.", ship->name ); echo_to_system( AT_YELLOW, ship, buf, NULL ); ship_from_starsystem( ship, ship->starsystem ); ship->shipstate = SHIP_HYPERSPACE; send_to_pager_color( "&GYou push forward the hyperspeed lever.\n\r", ch ); act( AT_PLAIN, "$n pushes a lever forward on the control panel.", ch, NULL, argument, TO_ROOM ); echo_to_ship( AT_YELLOW, ship, "The ship lurches slightly as it makes the jump to lightspeed." ); echo_to_cockpit( AT_YELLOW, ship, "The stars become streaks of light as you enter hyperspace." ); ship->energy -= ( 100 + ship->hyperdistance * ( 1 + ship->class ) / 3 ); ship->vx = ship->jx; ship->vy = ship->jy; ship->vz = ship->jz; if( ship->class == FIGHTER_SHIP ) learn_from_success( ch, gsn_starfighters ); if( ship->class == MIDSIZE_SHIP ) learn_from_success( ch, gsn_midships ); if( ship->class == CAPITAL_SHIP ) learn_from_success( ch, gsn_capitalships ); } void do_target( CHAR_DATA * ch, char *argument ) { char arg[MAX_INPUT_LENGTH]; SHIP_DATA *ship; SHIP_DATA *target; char buf[MAX_STRING_LENGTH]; strcpy( arg, argument ); switch ( ch->substate ) { default: if( ( ship = ship_from_turret( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the gunners seat or turret of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( !ship->starsystem ) { send_to_pager_color( "&RYou can't do that until you've finished launching!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first....\n\r", ch ); return; } if( arg[0] == '\0' ) { send_to_pager_color( "&RYou need to specify a target!\n\r", ch ); return; } if( !str_cmp( arg, "none" ) ) { send_to_pager_color( ">arget set to none.\n\r", ch ); if( ch->in_room->vnum == ship->gunseat ) ship->target0 = NULL; if( ch->in_room->vnum == ship->turret1 ) ship->target1 = NULL; if( ch->in_room->vnum == ship->turret2 ) ship->target2 = NULL; return; } target = get_ship_here( arg, ship->starsystem ); if( target == NULL ) { send_to_pager_color( "&RThat ship isn't here!\n\r", ch ); return; } if( target == ship ) { send_to_pager_color( "&RYou can't target your own ship!\n\r", ch ); return; } if( !str_cmp( target->owner, ship->owner ) && str_cmp( target->owner, "" ) ) { send_to_pager_color( "&RThat ship has the same owner... try targetting an enemy ship instead!\n\r", ch ); return; } if( abs( ship->vx - target->vx ) > 5000 || abs( ship->vy - target->vy ) > 5000 || abs( ship->vz - target->vz ) > 5000 ) { send_to_pager_color( "&RThat ship is too far away to target.\n\r", ch ); return; } if( !combatShip( ship ) ) { send_to_pager_color( "&RThat ship has no means of fighting back.\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_weaponsystems]) ; */ send_to_pager_color( ">racking target.\n\r", ch ); act( AT_PLAIN, "$n makes some adjustments on the targeting computer.", ch, NULL, argument, TO_ROOM ); add_timer( ch, TIMER_DO_FUN, 1, do_target, 1 ); ch->dest_buf = str_dup( arg ); return; case 1: if( !ch->dest_buf ) return; strcpy( arg, ch->dest_buf ); DISPOSE( ch->dest_buf ); break; case SUB_TIMER_DO_ABORT: DISPOSE( ch->dest_buf ); ch->substate = SUB_NONE; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) return; send_to_pager_color( "&RYour concentration is broken. You fail to lock onto your target.\n\r", ch ); return; } ch->substate = SUB_NONE; if( ( ship = ship_from_turret( ch->in_room->vnum ) ) == NULL ) { return; } target = get_ship_here( arg, ship->starsystem ); if( target == NULL || target == ship ) { send_to_pager_color( "&RThe ship has left the starsytem. Targeting aborted.\n\r", ch ); return; } if( ch->in_room->vnum == ship->gunseat ) ship->target0 = target; if( ch->in_room->vnum == ship->turret1 ) ship->target1 = target; if( ch->in_room->vnum == ship->turret2 ) ship->target2 = target; send_to_pager_color( ">arget Locked.\n\r", ch ); sprintf( buf, "You are being targetted by %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); learn_from_success( ch, gsn_weaponsystems ); if( autofly( target ) && !target->target0 ) { sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); target->target0 = ship; } } void do_fire( CHAR_DATA * ch, char *argument ) { int chance = 50; SHIP_DATA *ship; SHIP_DATA *target; char buf[MAX_STRING_LENGTH]; if( ( ship = ship_from_turret( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the gunners chair or turret of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( ship->starsystem == NULL ) { send_to_pager_color( "&RYou can't do that until after you've finished launching!\n\r", ch ); return; } if( ship->energy < 5 ) { send_to_pager_color( "&RTheres not enough energy left to fire!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first.\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) ( ch->perm_dex*2 + ch->pcdata->learned[gsn_spacecombat]/3 + ch->pcdata->learned[gsn_spacecombat2]/3 + ch->pcdata->learned[gsn_spacecombat3]/3 ); */ if( ch->in_room->vnum == ship->gunseat && !str_prefix( argument, "lasers" ) ) { if( ship->statet0 == LASER_DAMAGED ) { send_to_pager_color( "&RThe ships main laser is damaged.\n\r", ch ); return; } if( ship->statet0 >= ship->lasers ) { send_to_pager_color( "&RThe lasers are still recharging.\n\r", ch ); return; } if( ship->target0 == NULL ) { send_to_pager_color( "&RYou need to choose a target first.\n\r", ch ); return; } target = ship->target0; if( ship->target0->starsystem != ship->starsystem ) { send_to_pager_color( "&RYour target seems to have left.\n\r", ch ); ship->target0 = NULL; return; } if( abs( target->vx - ship->vx ) > 1000 || abs( target->vy - ship->vy ) > 1000 || abs( target->vz - ship->vz ) > 1000 ) { send_to_pager_color( "&RThat ship is out of laser range.\n\r", ch ); return; } if( ship->class < 2 && !is_facing( ship, target ) ) { send_to_pager_color( "&RThe main laser can only fire forward. You'll need to turn your ship!\n\r", ch ); return; } ship->statet0++; chance += target->class * 25; chance -= target->manuever / 10; chance -= target->currspeed / 20; chance -= ( abs( target->vx - ship->vx ) / 70 ); chance -= ( abs( target->vy - ship->vy ) / 70 ); chance -= ( abs( target->vz - ship->vz ) / 70 ); chance = URANGE( 10, chance, 90 ); act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); if( number_percent( ) > chance ) { sprintf( buf, "Lasers fire from %s at you but miss.", ship->name ); echo_to_cockpit( AT_ORANGE, target, buf ); sprintf( buf, "The ships lasers fire at %s but miss.", target->name ); echo_to_cockpit( AT_ORANGE, ship, buf ); learn_from_failure( ch, gsn_spacecombat ); learn_from_failure( ch, gsn_spacecombat2 ); learn_from_failure( ch, gsn_spacecombat3 ); sprintf( buf, "Laserfire from %s barely misses %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); return; } sprintf( buf, "Laserfire from %s hits %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); sprintf( buf, "You are hit by lasers from %s!", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "Your ships lasers hit %s!.", target->name ); echo_to_cockpit( AT_YELLOW, ship, buf ); learn_from_success( ch, gsn_spacecombat ); learn_from_success( ch, gsn_spacecombat2 ); learn_from_success( ch, gsn_spacecombat3 ); echo_to_ship( AT_RED, target, "A small explosion vibrates through the ship." ); damage_ship_ch( target, 5, 10, ch ); if( autofly( target ) && target->target0 != ship ) { target->target0 = ship; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); } return; } if( ch->in_room->vnum == ship->gunseat && !str_prefix( argument, "missile" ) ) { if( ship->missilestate == MISSILE_DAMAGED ) { send_to_pager_color( "&RThe ships missile launchers are dammaged.\n\r", ch ); return; } if( ship->missiles <= 0 ) { send_to_pager_color( "&RYou have no missiles to fire!\n\r", ch ); return; } if( ship->missilestate != MISSILE_READY ) { send_to_pager_color( "&RThe missiles are still reloading.\n\r", ch ); return; } if( ship->target0 == NULL ) { send_to_pager_color( "&RYou need to choose a target first.\n\r", ch ); return; } target = ship->target0; if( ship->target0->starsystem != ship->starsystem ) { send_to_pager_color( "&RYour target seems to have left.\n\r", ch ); ship->target0 = NULL; return; } if( abs( target->vx - ship->vx ) > 1000 || abs( target->vy - ship->vy ) > 1000 || abs( target->vz - ship->vz ) > 1000 ) { send_to_pager_color( "&RThat ship is out of missile range.\n\r", ch ); return; } if( ship->class < 2 && !is_facing( ship, target ) ) { send_to_pager_color( "&RMissiles can only fire in a forward. You'll need to turn your ship!\n\r", ch ); return; } chance -= target->manuever / 5; chance -= target->currspeed / 20; chance += target->class * target->class * 25; chance -= ( abs( target->vx - ship->vx ) / 100 ); chance -= ( abs( target->vy - ship->vy ) / 100 ); chance -= ( abs( target->vz - ship->vz ) / 100 ); chance += ( 30 ); chance = URANGE( 20, chance, 80 ); act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); if( number_percent( ) > chance ) { send_to_pager_color( "&RYou fail to lock onto your target!", ch ); ship->missilestate = MISSILE_RELOAD_2; return; } new_missile( ship, target, ch, CONCUSSION_MISSILE ); ship->missiles--; act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); echo_to_cockpit( AT_YELLOW, ship, "Missiles launched." ); sprintf( buf, "Incoming missile from %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "%s fires a missile towards %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); learn_from_success( ch, gsn_weaponsystems ); if( ship->class == CAPITAL_SHIP || ship->class == SHIP_PLATFORM ) ship->missilestate = MISSILE_RELOAD; else ship->missilestate = MISSILE_FIRED; if( autofly( target ) && target->target0 != ship ) { target->target0 = ship; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); } return; } if( ch->in_room->vnum == ship->gunseat && !str_prefix( argument, "torpedo" ) ) { if( ship->missilestate == MISSILE_DAMAGED ) { send_to_pager_color( "&RThe ships missile launchers are dammaged.\n\r", ch ); return; } if( ship->torpedos <= 0 ) { send_to_pager_color( "&RYou have no torpedos to fire!\n\r", ch ); return; } if( ship->missilestate != MISSILE_READY ) { send_to_pager_color( "&RThe torpedos are still reloading.\n\r", ch ); return; } if( ship->target0 == NULL ) { send_to_pager_color( "&RYou need to choose a target first.\n\r", ch ); return; } target = ship->target0; if( ship->target0->starsystem != ship->starsystem ) { send_to_pager_color( "&RYour target seems to have left.\n\r", ch ); ship->target0 = NULL; return; } if( abs( target->vx - ship->vx ) > 1000 || abs( target->vy - ship->vy ) > 1000 || abs( target->vz - ship->vz ) > 1000 ) { send_to_pager_color( "&RThat ship is out of torpedo range.\n\r", ch ); return; } if( ship->class < 2 && !is_facing( ship, target ) ) { send_to_pager_color( "&RTorpedos can only fire in a forward direction. You'll need to turn your ship!\n\r", ch ); return; } chance -= target->manuever / 5; chance -= target->currspeed / 20; chance += target->class * target->class * 25; chance -= ( abs( target->vx - ship->vx ) / 100 ); chance -= ( abs( target->vy - ship->vy ) / 100 ); chance -= ( abs( target->vz - ship->vz ) / 100 ); chance = URANGE( 20, chance, 80 ); act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); if( number_percent( ) > chance ) { send_to_pager_color( "&RYou fail to lock onto your target!", ch ); ship->missilestate = MISSILE_RELOAD_2; return; } new_missile( ship, target, ch, PROTON_TORPEDO ); ship->torpedos--; act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); echo_to_cockpit( AT_YELLOW, ship, "Missiles launched." ); sprintf( buf, "Incoming torpedo from %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "%s fires a torpedo towards %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); learn_from_success( ch, gsn_weaponsystems ); if( ship->class == CAPITAL_SHIP || ship->class == SHIP_PLATFORM ) ship->missilestate = MISSILE_RELOAD; else ship->missilestate = MISSILE_FIRED; if( autofly( target ) && target->target0 != ship ) { target->target0 = ship; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); } return; } if( ch->in_room->vnum == ship->gunseat && !str_prefix( argument, "rocket" ) ) { if( ship->missilestate == MISSILE_DAMAGED ) { send_to_pager_color( "&RThe ships missile launchers are damaged.\n\r", ch ); return; } if( ship->rockets <= 0 ) { send_to_pager_color( "&RYou have no rockets to fire!\n\r", ch ); return; } if( ship->missilestate != MISSILE_READY ) { send_to_pager_color( "&RThe missiles are still reloading.\n\r", ch ); return; } if( ship->target0 == NULL ) { send_to_pager_color( "&RYou need to choose a target first.\n\r", ch ); return; } target = ship->target0; if( ship->target0->starsystem != ship->starsystem ) { send_to_pager_color( "&RYour target seems to have left.\n\r", ch ); ship->target0 = NULL; return; } if( abs( target->vx - ship->vx ) > 800 || abs( target->vy - ship->vy ) > 800 || abs( target->vz - ship->vz ) > 800 ) { send_to_pager_color( "&RThat ship is out of rocket range.\n\r", ch ); return; } if( ship->class < 2 && !is_facing( ship, target ) ) { send_to_pager_color( "&RRockets can only fire forward. You'll need to turn your ship!\n\r", ch ); return; } chance -= target->manuever / 5; chance -= target->currspeed / 20; chance += target->class * target->class * 25; chance -= ( abs( target->vx - ship->vx ) / 100 ); chance -= ( abs( target->vy - ship->vy ) / 100 ); chance -= ( abs( target->vz - ship->vz ) / 100 ); chance -= 30; chance = URANGE( 20, chance, 80 ); act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); if( number_percent( ) > chance ) { send_to_pager_color( "&RYou fail to lock onto your target!", ch ); ship->missilestate = MISSILE_RELOAD_2; return; } new_missile( ship, target, ch, HEAVY_ROCKET ); ship->rockets--; act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); echo_to_cockpit( AT_YELLOW, ship, "Rocket launched." ); sprintf( buf, "Incoming rocket from %s.", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "%s fires a heavy rocket towards %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); learn_from_success( ch, gsn_weaponsystems ); if( ship->class == CAPITAL_SHIP || ship->class == SHIP_PLATFORM ) ship->missilestate = MISSILE_RELOAD; else ship->missilestate = MISSILE_FIRED; if( autofly( target ) && target->target0 != ship ) { target->target0 = ship; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); } return; } if( ch->in_room->vnum == ship->turret1 && !str_prefix( argument, "lasers" ) ) { if( ship->statet1 == LASER_DAMAGED ) { send_to_pager_color( "&RThe ships turret is damaged.\n\r", ch ); return; } if( ship->statet1 > ship->class ) { send_to_pager_color( "&RThe turbolaser is recharging.\n\r", ch ); return; } if( ship->target1 == NULL ) { send_to_pager_color( "&RYou need to choose a target first.\n\r", ch ); return; } target = ship->target1; if( ship->target1->starsystem != ship->starsystem ) { send_to_pager_color( "&RYour target seems to have left.\n\r", ch ); ship->target1 = NULL; return; } if( abs( target->vx - ship->vx ) > 1000 || abs( target->vy - ship->vy ) > 1000 || abs( target->vz - ship->vz ) > 1000 ) { send_to_pager_color( "&RThat ship is out of laser range.\n\r", ch ); return; } ship->statet1++; chance -= target->manuever / 10; chance += target->class * 25; chance -= target->currspeed / 20; chance -= ( abs( target->vx - ship->vx ) / 70 ); chance -= ( abs( target->vy - ship->vy ) / 70 ); chance -= ( abs( target->vz - ship->vz ) / 70 ); chance = URANGE( 10, chance, 90 ); act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); if( number_percent( ) > chance ) { sprintf( buf, "Turbolasers fire from %s at you but miss.", ship->name ); echo_to_cockpit( AT_ORANGE, target, buf ); sprintf( buf, "Turbolasers fire from the ships turret at %s but miss.", target->name ); echo_to_cockpit( AT_ORANGE, ship, buf ); sprintf( buf, "%s fires at %s but misses.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); learn_from_failure( ch, gsn_spacecombat ); learn_from_failure( ch, gsn_spacecombat2 ); learn_from_failure( ch, gsn_spacecombat3 ); return; } sprintf( buf, "Turboasers fire from %s, hitting %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); sprintf( buf, "You are hit by turbolasers from %s!", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "Turbolasers fire from the turret, hitting %s!.", target->name ); echo_to_cockpit( AT_YELLOW, ship, buf ); learn_from_success( ch, gsn_spacecombat ); learn_from_success( ch, gsn_spacecombat2 ); learn_from_success( ch, gsn_spacecombat3 ); echo_to_ship( AT_RED, target, "A small explosion vibrates through the ship." ); damage_ship_ch( target, 10, 25, ch ); if( autofly( target ) && target->target0 != ship ) { target->target0 = ship; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); } return; } if( ch->in_room->vnum == ship->turret2 && !str_prefix( argument, "lasers" ) ) { if( ship->statet2 == LASER_DAMAGED ) { send_to_pager_color( "&RThe ships turret is damaged.\n\r", ch ); return; } if( ship->statet2 > ship->class ) { send_to_pager_color( "&RThe turbolaser is still recharging.\n\r", ch ); return; } if( ship->target2 == NULL ) { send_to_pager_color( "&RYou need to choose a target first.\n\r", ch ); return; } target = ship->target2; if( ship->target2->starsystem != ship->starsystem ) { send_to_pager_color( "&RYour target seems to have left.\n\r", ch ); ship->target2 = NULL; return; } if( abs( target->vx - ship->vx ) > 1000 || abs( target->vy - ship->vy ) > 1000 || abs( target->vz - ship->vz ) > 1000 ) { send_to_pager_color( "&RThat ship is out of laser range.\n\r", ch ); return; } ship->statet2++; chance -= target->manuever / 10; chance += target->class * 25; chance -= target->currspeed / 20; chance -= ( abs( target->vx - ship->vx ) / 70 ); chance -= ( abs( target->vy - ship->vy ) / 70 ); chance -= ( abs( target->vz - ship->vz ) / 70 ); chance = URANGE( 10, chance, 90 ); act( AT_PLAIN, "$n presses the fire button.", ch, NULL, argument, TO_ROOM ); if( number_percent( ) > chance ) { sprintf( buf, "Turbolasers fire from %s barely missing %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); sprintf( buf, "Turbolasers fire from %s at you but miss.", ship->name ); echo_to_cockpit( AT_ORANGE, target, buf ); sprintf( buf, "Turbolasers fire from the turret missing %s.", target->name ); echo_to_cockpit( AT_ORANGE, ship, buf ); learn_from_failure( ch, gsn_spacecombat ); learn_from_failure( ch, gsn_spacecombat2 ); learn_from_failure( ch, gsn_spacecombat3 ); return; } sprintf( buf, "Turbolasers fire from %s, hitting %s.", ship->name, target->name ); echo_to_system( AT_ORANGE, ship, buf, target ); sprintf( buf, "You are hit by turbolasers from %s!", ship->name ); echo_to_cockpit( AT_BLOOD, target, buf ); sprintf( buf, "turbolasers fire from the turret hitting %s!.", target->name ); echo_to_cockpit( AT_YELLOW, ship, buf ); learn_from_success( ch, gsn_spacecombat ); learn_from_success( ch, gsn_spacecombat2 ); learn_from_success( ch, gsn_spacecombat3 ); echo_to_ship( AT_RED, target, "A small explosion vibrates through the ship." ); damage_ship_ch( target, 10, 25, ch ); if( autofly( target ) && target->target0 != ship ) { target->target0 = ship; sprintf( buf, "You are being targetted by %s.", target->name ); echo_to_cockpit( AT_BLOOD, ship, buf ); } return; } send_to_pager_color( "&RYou can't fire that!\n\r", ch ); } void do_calculate( CHAR_DATA * ch, char *argument ) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; char arg3[MAX_INPUT_LENGTH]; int count = 0; SHIP_DATA *ship; SPACE_DATA *starsystem; argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); argument = one_argument( argument, arg3 ); if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_navseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be at a nav computer to calculate jumps.\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first....\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RAnd what exactly are you going to calculate...?\n\r", ch ); return; } if( ship->hyperspeed == 0 ) { send_to_pager_color( "&RThis ship is not equipped with a hyperdrive!\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RYou can't do that until after you've launched!\n\r", ch ); return; } if( ship->starsystem == NULL ) { send_to_pager_color( "&RYou can only do that in realspace.\n\r", ch ); return; } if( argument[0] == '\0' ) { send_to_pager_color( "&WFormat: Calculate <starsystem> <entry x> <entry y> <entry z>\n\r&wPossible destinations:\n\r", ch ); for( starsystem = first_starsystem; starsystem; starsystem = starsystem->next ) { set_char_color( AT_NOTE, ch ); pager_printf_color( ch, "%-30s %d\n\r", starsystem->name, ( abs( starsystem->xpos - ship->starsystem->xpos ) + abs( starsystem->ypos - ship->starsystem->ypos ) ) / 2 ); count++; } if( !count ) { send_to_pager_color( "No Starsystems found.\n\r", ch ); } return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_navigation]) ; */ ship->currjump = starsystem_from_name( arg1 ); ship->jx = atoi( arg2 ); ship->jy = atoi( arg3 ); ship->jz = atoi( argument ); if( ship->currjump == NULL ) { send_to_pager_color( "&RYou can't seem to find that starsytem on your charts.\n\r", ch ); return; } else { SPACE_DATA *starsystem; starsystem = ship->currjump; if( starsystem->star1 && strcmp( starsystem->star1, "" ) && abs( ship->jx - starsystem->s1x ) < 300 && abs( ship->jy - starsystem->s1y ) < 300 && abs( ship->jz - starsystem->s1z ) < 300 ) { echo_to_cockpit( AT_RED, ship, "WARNING.. Jump coordinates too close to stellar object." ); echo_to_cockpit( AT_RED, ship, "WARNING.. Hyperjump NOT set." ); ship->currjump = NULL; return; } else if( starsystem->star2 && strcmp( starsystem->star2, "" ) && abs( ship->jx - starsystem->s2x ) < 300 && abs( ship->jy - starsystem->s2y ) < 300 && abs( ship->jz - starsystem->s2z ) < 300 ) { echo_to_cockpit( AT_RED, ship, "WARNING.. Jump coordinates too close to stellar object." ); echo_to_cockpit( AT_RED, ship, "WARNING.. Hyperjump NOT set." ); ship->currjump = NULL; return; } else if( starsystem->planet1 && strcmp( starsystem->planet1, "" ) && abs( ship->jx - starsystem->p1x ) < 300 && abs( ship->jy - starsystem->p1y ) < 300 && abs( ship->jz - starsystem->p1z ) < 300 ) { echo_to_cockpit( AT_RED, ship, "WARNING.. Jump coordinates too close to stellar object." ); echo_to_cockpit( AT_RED, ship, "WARNING.. Hyperjump NOT set." ); ship->currjump = NULL; return; } else if( starsystem->planet2 && strcmp( starsystem->planet2, "" ) && abs( ship->jx - starsystem->p2x ) < 300 && abs( ship->jy - starsystem->p2y ) < 300 && abs( ship->jz - starsystem->p2z ) < 300 ) { echo_to_cockpit( AT_RED, ship, "WARNING.. Jump coordinates too close to stellar object." ); echo_to_cockpit( AT_RED, ship, "WARNING.. Hyperjump NOT set." ); ship->currjump = NULL; return; } else if( starsystem->planet3 && strcmp( starsystem->planet3, "" ) && abs( ship->jx - starsystem->p3x ) < 300 && abs( ship->jy - starsystem->p3y ) < 300 && abs( ship->jz - starsystem->p3z ) < 300 ) { echo_to_cockpit( AT_RED, ship, "WARNING.. Jump coordinates too close to stellar object." ); echo_to_cockpit( AT_RED, ship, "WARNING.. Hyperjump NOT set." ); ship->currjump = NULL; return; } else { ship->jx += number_range( -250, 250 ); ship->jy += number_range( -250, 250 ); ship->jz += number_range( -250, 250 ); } } ship->hyperdistance = abs( ship->starsystem->xpos - ship->currjump->xpos ); ship->hyperdistance += abs( ship->starsystem->ypos - ship->currjump->ypos ); ship->hyperdistance /= 5; if( ship->hyperdistance < 100 ) ship->hyperdistance = 100; ship->hyperdistance += number_range( 0, 200 ); send_to_pager_color( "&GHyperspace course set. Ready for the jump to lightspeed.\n\r", ch ); act( AT_PLAIN, "$n does some calculations using the ships computer.", ch, NULL, argument, TO_ROOM ); learn_from_success( ch, gsn_navigation ); WAIT_STATE( ch, 2 * PULSE_VIOLENCE ); } void do_recharge( CHAR_DATA * ch, char *argument ) { int recharge; SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ( ship = ship_from_coseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RThe controls must be at the co-pilot station.\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&R...\n\r", ch ); return; } if( ship->shipstate == SHIP_DISABLED ) { send_to_pager_color( "&RThe ships drive is disabled. Unable to manuever.\n\r", ch ); return; } if( ship->energy < 100 ) { send_to_pager_color( "&RTheres not enough energy!\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_shipsystems]); */ if( ship->shield >= ship->maxshield ) { send_to_pager_color( "&RShields are already at max.\n\r", ch ); ship->shield = ship->maxshield; return; } send_to_pager_color( "&GRecharging shields..\n\r", ch ); act( AT_PLAIN, "$n pulls back a lever on the control panel.", ch, NULL, argument, TO_ROOM ); learn_from_success( ch, gsn_shipsystems ); recharge = UMIN( ship->maxshield - ship->shield, ship->energy * 5 + 100 ); recharge = URANGE( 1, recharge, 25 + ship->class * 25 ); ship->shield += recharge; ship->energy -= ( recharge * 2 + recharge * ship->class ); } void do_repairship( CHAR_DATA * ch, char *argument ) { char arg[MAX_INPUT_LENGTH]; int change = 0; SHIP_DATA *ship; strcpy( arg, argument ); switch ( ch->substate ) { default: if( ( ship = ship_from_engine( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the engine room of a ship to do that!\n\r", ch ); return; } if( str_cmp( argument, "hull" ) && str_cmp( argument, "drive" ) && str_cmp( argument, "launcher" ) && str_cmp( argument, "laser" ) && str_cmp( argument, "turret 1" ) && str_cmp( argument, "turret 2" ) ) { send_to_pager_color( "&RYou need to spceify something to repair:\n\r", ch ); send_to_pager_color( "&rTry: hull, drive, launcher, laser, turret 1, or turret 2\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_shipmaintenance]); */ if( ship->shipstate == SHIP_HYPERSPACE && !str_cmp( argument, "drive" ) ) { send_to_pager_color( "&RYou can't do that while the ship is moving.\n\r", ch ); return; } send_to_pager_color( "&GYou begin your repairs\n\r", ch ); act( AT_PLAIN, "$n begins repairing the ships $T.", ch, NULL, argument, TO_ROOM ); if( !str_cmp( arg, "hull" ) ) add_timer( ch, TIMER_DO_FUN, 15, do_repairship, 1 ); else add_timer( ch, TIMER_DO_FUN, 5, do_repairship, 1 ); ch->dest_buf = str_dup( arg ); return; case 1: if( !ch->dest_buf ) return; strcpy( arg, ch->dest_buf ); DISPOSE( ch->dest_buf ); break; case SUB_TIMER_DO_ABORT: DISPOSE( ch->dest_buf ); ch->substate = SUB_NONE; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) return; send_to_pager_color( "&RYou are distracted and fail to finish your repairs.\n\r", ch ); return; } ch->substate = SUB_NONE; if( ( ship = ship_from_engine( ch->in_room->vnum ) ) == NULL ) { return; } if( !str_cmp( arg, "hull" ) ) { change = URANGE( 0, number_range( ( int )( ch->pcdata->learned[gsn_shipmaintenance] / 2 ), ( int )( ch->pcdata->learned[gsn_shipmaintenance] ) ), ( ship->maxhull - ship->hull ) ); ship->hull += change; pager_printf_color( ch, "&GRepair complete.. Hull strength inreased by %d points.\n\r", change ); } if( !str_cmp( arg, "drive" ) ) { if( ship->location == ship->lastdoc ) ship->shipstate = SHIP_DOCKED; else ship->shipstate = SHIP_READY; send_to_pager_color( "&GShips drive repaired.\n\r", ch ); } if( !str_cmp( arg, "launcher" ) ) { ship->missilestate = MISSILE_READY; send_to_pager_color( "&GMissile launcher repaired.\n\r", ch ); } if( !str_cmp( arg, "laser" ) ) { ship->statet0 = LASER_READY; send_to_pager_color( "&GMain laser repaired.\n\r", ch ); } if( !str_cmp( arg, "turret 1" ) ) { ship->statet1 = LASER_READY; send_to_pager_color( "&GLaser Turret 1 repaired.\n\r", ch ); } if( !str_cmp( arg, "turret 2" ) ) { ship->statet2 = LASER_READY; send_to_pager_color( "&Laser Turret 2 repaired.\n\r", ch ); } act( AT_PLAIN, "$n finishes the repairs.", ch, NULL, argument, TO_ROOM ); learn_from_success( ch, gsn_shipmaintenance ); } void do_refuel( CHAR_DATA * ch, char *argument ) { } void do_addpilot( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RYou can't do that here.\n\r", ch ); return; } if( str_cmp( ship->owner, ch->name ) ) { if( !IS_NPC( ch ) && ch->pcdata && ch->pcdata->clan && !str_cmp( ch->pcdata->clan->name, ship->owner ) ) if( is_leader( ch ) ) ; else { send_to_pager_color( "&RThat isn't your ship!", ch ); return; } else { send_to_pager_color( "&RThat isn't your ship!", ch ); return; } } if( argument[0] == '\0' ) { send_to_pager_color( "&RAdd which pilot?\n\r", ch ); return; } if( str_cmp( ship->pilot, "" ) ) { if( str_cmp( ship->copilot, "" ) ) { send_to_pager_color( "&RYou are ready have a pilot and copilot..\n\r", ch ); send_to_pager_color( "&RTry rempilot first.\n\r", ch ); return; } STRFREE( ship->copilot ); ship->copilot = STRALLOC( argument ); send_to_pager_color( "Copilot Added.\n\r", ch ); save_ship( ship ); return; return; } STRFREE( ship->pilot ); ship->pilot = STRALLOC( argument ); send_to_pager_color( "Pilot Added.\n\r", ch ); save_ship( ship ); } void do_rempilot( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RYou can't do that here.\n\r", ch ); return; } if( str_cmp( ship->owner, ch->name ) ) { if( !IS_NPC( ch ) && ch->pcdata && ch->pcdata->clan && !str_cmp( ch->pcdata->clan->name, ship->owner ) ) if( is_leader( ch ) ) ; else { send_to_pager_color( "&RThat isn't your ship!", ch ); return; } else { send_to_pager_color( "&RThat isn't your ship!", ch ); return; } } if( argument[0] == '\0' ) { send_to_pager_color( "&RRemove which pilot?\n\r", ch ); return; } if( !str_cmp( ship->pilot, argument ) ) { STRFREE( ship->pilot ); ship->pilot = STRALLOC( "" ); send_to_pager_color( "Pilot Removed.\n\r", ch ); save_ship( ship ); return; } if( !str_cmp( ship->copilot, argument ) ) { STRFREE( ship->copilot ); ship->copilot = STRALLOC( "" ); send_to_pager_color( "Copilot Removed.\n\r", ch ); save_ship( ship ); return; } send_to_pager_color( "&RThat person isn't listed as one of the ships pilots.\n\r", ch ); } void do_radar( CHAR_DATA * ch, char *argument ) { SHIP_DATA *target; SHIP_DATA *ship; MISSILE_DATA *missile; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit or turret of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RWait until after you launch!\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( ship->starsystem == NULL ) { send_to_pager_color( "&RYou can't do that unless the ship is flying in realspace!\n\r", ch ); return; } // chance = IS_NPC(ch) ? ch->top_level // : (int) (ch->pcdata->learned[gsn_navigation]) ; act( AT_PLAIN, "$n checks the radar.", ch, NULL, argument, TO_ROOM ); set_char_color( AT_WHITE, ch ); pager_printf_color( ch, "%s\n\r\n\r", ship->starsystem->name ); set_char_color( AT_LBLUE, ch ); if( ship->starsystem->star1 && str_cmp( ship->starsystem->star1, "" ) ) pager_printf_color( ch, "%s %d %d %d\n\r", ship->starsystem->star1, ship->starsystem->s1x, ship->starsystem->s1y, ship->starsystem->s1z ); if( ship->starsystem->star2 && str_cmp( ship->starsystem->star2, "" ) ) pager_printf_color( ch, "%s %d %d %d\n\r", ship->starsystem->star2, ship->starsystem->s2x, ship->starsystem->s2y, ship->starsystem->s2z ); if( ship->starsystem->planet1 && str_cmp( ship->starsystem->planet1, "" ) ) pager_printf_color( ch, "%s %d %d %d\n\r", ship->starsystem->planet1, ship->starsystem->p1x, ship->starsystem->p1y, ship->starsystem->p1z ); if( ship->starsystem->planet2 && str_cmp( ship->starsystem->planet2, "" ) ) pager_printf_color( ch, "%s %d %d %d\n\r", ship->starsystem->planet2, ship->starsystem->p2x, ship->starsystem->p2y, ship->starsystem->p2z ); if( ship->starsystem->planet3 && str_cmp( ship->starsystem->planet3, "" ) ) pager_printf_color( ch, "%s %d %d %d\n\r", ship->starsystem->planet3, ship->starsystem->p3x, ship->starsystem->p3y, ship->starsystem->p3z ); pager_printf_color( ch, "\n\r" ); for( target = ship->starsystem->first_ship; target; target = target->next_in_starsystem ) { if( target != ship ) pager_printf_color( ch, "%s %.0f %.0f %.0f\n\r", target->name, target->vx, target->vy, target->vz ); } pager_printf_color( ch, "\n\r" ); for( missile = ship->starsystem->first_missile; missile; missile = missile->next_in_starsystem ) { pager_printf_color( ch, "%s %d %d %d\n\r", missile->missiletype == CONCUSSION_MISSILE ? "A Concusion missile" : ( missile->missiletype == PROTON_TORPEDO ? "A Torpedo" : ( missile->missiletype == HEAVY_ROCKET ? "A Heavy Rocket" : "A Heavy Bomb" ) ), missile->mx, missile->my, missile->mz ); } pager_printf_color( ch, "\n\r&WYour Coordinates: %.0f %.0f %.0f\n\r", ship->vx, ship->vy, ship->vz ); learn_from_success( ch, gsn_navigation ); } void do_autotrack( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ship->class == SHIP_PLATFORM ) { send_to_pager_color( "&RPlatforms don't have autotracking systems!\n\r", ch ); return; } if( ship->class == CAPITAL_SHIP ) { send_to_pager_color( "&RThis ship is too big for autotracking!\n\r", ch ); return; } if( ( ship = ship_from_pilotseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou aren't in the pilots chair!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn off the ships autopilot first....\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_shipsystems]) ; */ act( AT_PLAIN, "$n flips a switch on the control panel.", ch, NULL, argument, TO_ROOM ); if( ship->autotrack ) { ship->autotrack = FALSE; echo_to_cockpit( AT_YELLOW, ship, "Autotracking off." ); } else { ship->autotrack = TRUE; echo_to_cockpit( AT_YELLOW, ship, "Autotracking on." ); } learn_from_success( ch, gsn_shipsystems ); } void do_jumpvector( CHAR_DATA * ch, char *argument ) { } void do_reload( CHAR_DATA * ch, char *argument ) { } void do_closebay( CHAR_DATA * ch, char *argument ) { } void do_openbay( CHAR_DATA * ch, char *argument ) { } void do_tractorbeam( CHAR_DATA * ch, char *argument ) { } void do_pluogus( CHAR_DATA * ch, char *argument ) { bool ch_comlink = FALSE; OBJ_DATA *obj; int next_planet, itt; if( is_android( ch ) || wearing_sentient_chip( ch ) ) { ch_comlink = TRUE; } else { for( obj = ch->last_carrying; obj; obj = obj->prev_content ) { if( obj->pIndexData->item_type == ITEM_SCOUTER ) ch_comlink = TRUE; } } if( !ch_comlink ) { send_to_pager_color( "You need a scouter to do that to contact the ship!\n\r", ch ); return; } send_to_pager_color( "&CHome World Transport Ship Schedule Information:\n\r\n\r", ch ); /* * current port */ if( bus_pos < 7 && bus_pos > 1 ) pager_printf_color( ch, "&CThe Home World Transport Ship is Currently docked at &W%s.\n\r", bus_stop[bus_planet] ); /* * destinations */ next_planet = bus_planet; send_to_pager_color( "&CNext stops: \n\r", ch ); for( itt = 0; itt < MAX_BUS_STOP; itt++ ) { next_planet++; if( next_planet >= MAX_BUS_STOP ) next_planet = 0; pager_printf_color( ch, " &W%s\n\r", bus_stop[next_planet] ); } send_to_pager_color( "\n\r&CNamek Transport Ship Schedule Information:\n\r\n\r", ch ); /* * current port */ if( bus_pos < 7 && bus_pos > 1 ) pager_printf_color( ch, "&CThe Namek Transport Ship is Currently docked at &W%s.\n\r", bus_stop2[bus2_planet] ); /* * destinations */ next_planet = bus2_planet; send_to_pager_color( "&CNext stops: \n\r", ch ); for( itt = 0; itt < MAX_BUS_STOP2; itt++ ) { next_planet++; if( next_planet >= MAX_BUS_STOP2 ) next_planet = 0; pager_printf_color( ch, " &W%s\n\r", bus_stop2[next_planet] ); } return; } void do_drive( CHAR_DATA * ch, char *argument ) { int dir; SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the drivers seat of a land vehicle to do that!\n\r", ch ); return; } if( ship->class < LAND_SPEEDER ) { send_to_pager_color( "&RThis isn't a land vehicle!\n\r", ch ); return; } if( ship->shipstate == SHIP_DISABLED ) { send_to_pager_color( "&RThe drive is disabled.\n\r", ch ); return; } if( ship->energy < 1 ) { send_to_pager_color( "&RTheres not enough fuel!\n\r", ch ); return; } if( ( dir = get_door( argument ) ) == -1 ) { send_to_pager_color( "Usage: drive <direction>\n\r", ch ); return; } drive_ship( ch, ship, get_exit( get_room_index( ship->location ), dir ), 0 ); } void do_bomb( CHAR_DATA * ch, char *argument ) { } void do_chaff( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; if( ( ship = ship_from_cockpit( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RYou must be in the cockpit of a ship to do that!\n\r", ch ); return; } if( ship->class > SHIP_PLATFORM ) { send_to_pager_color( "&RThis isn't a spacecraft!\n\r", ch ); return; } if( ( ship = ship_from_coseat( ch->in_room->vnum ) ) == NULL ) { send_to_pager_color( "&RThe controls are at the copilots seat!\n\r", ch ); return; } if( autofly( ship ) ) { send_to_pager_color( "&RYou'll have to turn the autopilot off first...\n\r", ch ); return; } if( ship->shipstate == SHIP_HYPERSPACE ) { send_to_pager_color( "&RYou can only do that in realspace!\n\r", ch ); return; } if( ship->shipstate == SHIP_DOCKED ) { send_to_pager_color( "&RYou can't do that until after you've launched!\n\r", ch ); return; } if( ship->chaff <= 0 ) { send_to_pager_color( "&RYou don't have any chaff to release!\n\r", ch ); return; } /* chance = IS_NPC(ch) ? ch->top_level : (int) (ch->pcdata->learned[gsn_weaponsystems]) ; */ ship->chaff--; ship->chaff_released++; send_to_pager_color( "You flip the chaff release switch.\n\r", ch ); act( AT_PLAIN, "$n flips a switch on the control pannel", ch, NULL, argument, TO_ROOM ); echo_to_cockpit( AT_YELLOW, ship, "A burst of chaff is released from the ship." ); learn_from_success( ch, gsn_weaponsystems ); } ch_ret drive_ship( CHAR_DATA * ch, SHIP_DATA * ship, EXIT_DATA * pexit, int fall ) { ROOM_INDEX_DATA *in_room; ROOM_INDEX_DATA *to_room; ROOM_INDEX_DATA *from_room; ROOM_INDEX_DATA *original; char buf[MAX_STRING_LENGTH]; char *txt; char *dtxt; ch_ret retcode; sh_int door, distance; bool drunk = FALSE; CHAR_DATA *rch; CHAR_DATA *next_rch; if( !IS_NPC( ch ) ) if( IS_DRUNK( ch, 2 ) && ( ch->position != POS_SHOVE ) && ( ch->position != POS_DRAG ) ) drunk = TRUE; if( drunk && !fall ) { door = number_door( ); pexit = get_exit( get_room_index( ship->location ), door ); } #ifdef DEBUG if( pexit ) { sprintf( buf, "drive_ship: %s to door %d", ch->name, pexit->vdir ); log_string( buf ); } #endif retcode = rNONE; txt = NULL; in_room = get_room_index( ship->location ); from_room = in_room; if( !pexit || ( to_room = pexit->to_room ) == NULL ) { if( drunk ) send_to_pager_color( "You drive into a wall in your drunken state.\n\r", ch ); else send_to_pager_color( "Alas, you cannot go that way.\n\r", ch ); return rNONE; } door = pexit->vdir; distance = pexit->distance; if( IS_SET( pexit->exit_info, EX_WINDOW ) && !IS_SET( pexit->exit_info, EX_ISDOOR ) ) { send_to_pager_color( "Alas, you cannot go that way.\n\r", ch ); return rNONE; } if( IS_SET( pexit->exit_info, EX_PORTAL ) && IS_NPC( ch ) ) { act( AT_PLAIN, "Mobs can't use portals.", ch, NULL, NULL, TO_CHAR ); return rNONE; } if( IS_SET( pexit->exit_info, EX_NOMOB ) && IS_NPC( ch ) ) { act( AT_PLAIN, "Mobs can't enter there.", ch, NULL, NULL, TO_CHAR ); return rNONE; } if( IS_SET( pexit->exit_info, EX_CLOSED ) && ( IS_SET( pexit->exit_info, EX_NOPASSDOOR ) ) ) { if( !IS_SET( pexit->exit_info, EX_SECRET ) && !IS_SET( pexit->exit_info, EX_DIG ) ) { if( drunk ) { act( AT_PLAIN, "$n drives into the $d in $s drunken state.", ch, NULL, pexit->keyword, TO_ROOM ); act( AT_PLAIN, "You drive into the $d in your drunken state.", ch, NULL, pexit->keyword, TO_CHAR ); } else act( AT_PLAIN, "The $d is closed.", ch, NULL, pexit->keyword, TO_CHAR ); } else { if( drunk ) send_to_pager_color( "You hit a wall in your drunken state.\n\r", ch ); else send_to_pager_color( "Alas, you cannot go that way.\n\r", ch ); } return rNONE; } /* if ( distance > 1 ) if ( (to_room=generate_exit(in_room, &pexit)) == NULL ) send_to_pager_color( "Alas, you cannot go that way.\n\r", ch ); */ if( room_is_private( to_room ) ) { send_to_pager_color( "That room is private right now.\n\r", ch ); return rNONE; } if( !IS_IMMORTAL( ch ) && !IS_NPC( ch ) && ch->in_room->area != to_room->area ) { if( ch->level < to_room->area->low_hard_range ) { set_char_color( AT_TELL, ch ); switch ( to_room->area->low_hard_range - ch->level ) { case 1: send_to_pager_color( "A voice in your mind says, 'You are nearly ready to go that way...'", ch ); break; case 2: send_to_pager_color( "A voice in your mind says, 'Soon you shall be ready to travel down this path... soon.'", ch ); break; case 3: send_to_pager_color( "A voice in your mind says, 'You are not ready to go down that path... yet.'.\n\r", ch ); break; default: send_to_pager_color( "A voice in your mind says, 'You are not ready to go down that path.'.\n\r", ch ); } return rNONE; } else if( ch->level > to_room->area->hi_hard_range ) { set_char_color( AT_TELL, ch ); send_to_pager_color( "A voice in your mind says, 'There is nothing more for you down that path.'", ch ); return rNONE; } } if( !fall ) { if( xIS_SET( to_room->room_flags, ROOM_INDOORS ) || xIS_SET( to_room->room_flags, ROOM_SPACECRAFT ) || to_room->sector_type == SECT_INSIDE ) { send_to_pager_color( "You can't drive indoors!\n\r", ch ); return rNONE; } if( xIS_SET( to_room->room_flags, ROOM_NO_DRIVING ) ) { send_to_pager_color( "You can't take a vehicle through there!\n\r", ch ); return rNONE; } if( in_room->sector_type == SECT_AIR || to_room->sector_type == SECT_AIR || IS_SET( pexit->exit_info, EX_FLY ) ) { if( ship->class > CLOUD_CAR ) { send_to_pager_color( "You'd need to fly to go there.\n\r", ch ); return rNONE; } } if( in_room->sector_type == SECT_WATER_NOSWIM || to_room->sector_type == SECT_WATER_NOSWIM || to_room->sector_type == SECT_WATER_SWIM || to_room->sector_type == SECT_UNDERWATER || to_room->sector_type == SECT_OCEANFLOOR ) { if( ship->class != OCEAN_SHIP ) { send_to_pager_color( "You'd need a boat to go there.\n\r", ch ); return rNONE; } } if( IS_SET( pexit->exit_info, EX_CLIMB ) ) { if( ship->class < CLOUD_CAR ) { send_to_pager_color( "You need to fly or climb to get up there.\n\r", ch ); return rNONE; } } } if( to_room->tunnel > 0 ) { CHAR_DATA *ctmp; int count = 0; for( ctmp = to_room->first_person; ctmp; ctmp = ctmp->next_in_room ) if( ++count >= to_room->tunnel ) { send_to_pager_color( "There is no room for you in there.\n\r", ch ); return rNONE; } } if( fall ) txt = "falls"; else if( !txt ) { if( ship->class < OCEAN_SHIP ) txt = "fly"; else if( ship->class == OCEAN_SHIP ) { txt = "float"; } else if( ship->class > OCEAN_SHIP ) { txt = "drive"; } } sprintf( buf, "$n %ss the vehicle $T.", txt ); act( AT_ACTION, buf, ch, NULL, dir_name[door], TO_ROOM ); sprintf( buf, "You %s the vehicle $T.", txt ); act( AT_ACTION, buf, ch, NULL, dir_name[door], TO_CHAR ); sprintf( buf, "%s %ss %s.", ship->name, txt, dir_name[door] ); echo_to_room( AT_ACTION, get_room_index( ship->location ), buf ); extract_ship( ship ); ship_to_room( ship, to_room->vnum ); ship->location = to_room->vnum; ship->lastdoc = ship->location; if( fall ) txt = "falls"; else if( ship->class < OCEAN_SHIP ) txt = "flys in"; else if( ship->class == OCEAN_SHIP ) { txt = "floats in"; } else if( ship->class > OCEAN_SHIP ) { txt = "drives in"; } switch ( door ) { default: dtxt = "somewhere"; break; case 0: dtxt = "the south"; break; case 1: dtxt = "the west"; break; case 2: dtxt = "the north"; break; case 3: dtxt = "the east"; break; case 4: dtxt = "below"; break; case 5: dtxt = "above"; break; case 6: dtxt = "the south-west"; break; case 7: dtxt = "the south-east"; break; case 8: dtxt = "the north-west"; break; case 9: dtxt = "the north-east"; break; } sprintf( buf, "%s %s from %s.", ship->name, txt, dtxt ); echo_to_room( AT_ACTION, get_room_index( ship->location ), buf ); for( rch = ch->in_room->last_person; rch; rch = next_rch ) { next_rch = rch->prev_in_room; original = rch->in_room; char_from_room( rch ); char_to_room( rch, to_room ); do_look( rch, "auto" ); char_from_room( rch ); char_to_room( rch, original ); } /* if ( CHECK FOR FALLING HERE && fall > 0 ) { if (!IS_AFFECTED( ch, AFF_FLOATING ) || ( ch->mount && !IS_AFFECTED( ch->mount, AFF_FLOATING ) ) ) { set_char_color( AT_HURT, ch ); send_to_pager_color( "OUCH! You hit the ground!\n\r", ch ); WAIT_STATE( ch, 20 ); retcode = damage( ch, ch, 50 * fall, TYPE_UNDEFINED ); } else { set_char_color( AT_MAGIC, ch ); send_to_pager_color( "You lightly float down to the ground.\n\r", ch ); } } */ return retcode; } bool is_dock( ROOM_INDEX_DATA * room ) { int vnum = room->vnum; SPACE_DATA *starsystem; for( starsystem = first_starsystem; starsystem; starsystem = starsystem->next ) { if( vnum == starsystem->doc1a || vnum == starsystem->doc1b || vnum == starsystem->doc1c || vnum == starsystem->doc2a || vnum == starsystem->doc2b || vnum == starsystem->doc2c || vnum == starsystem->doc3a || vnum == starsystem->doc3b || vnum == starsystem->doc3c ) return TRUE; } return FALSE; } SHIP_DATA *has_ship( CHAR_DATA * ch ) { SHIP_DATA *ship; for( ship = first_ship; ship; ship = ship->next ) if( !str_cmp( ch->name, ship->owner ) || !str_cmp( ch->name, ship->pilot ) || !str_cmp( ch->name, ship->copilot ) ) return ship; return NULL; } void do_callship( CHAR_DATA * ch, char *argument ) { SHIP_DATA *ship; int oldRoom; char arg[MAX_INPUT_LENGTH]; argument = one_argument( argument, arg ); if( !is_android && !has_scouter( ch ) ) { send_to_char( "You need a scouter to do that.\n\r", ch ); return; } if( !str_cmp( arg, "list" ) ) { if( !has_ship( ch ) ) { pager_printf_color( ch, "&cYou don't own a ship.\n\r" ); return; } pager_printf_color( ch, "&cYou currently own:\n\r" ); for( ship = first_ship; ship; ship = ship->next ) { if( !str_cmp( ch->name, ship->owner ) || !str_cmp( ch->name, ship->pilot ) || !str_cmp( ch->name, ship->copilot ) ) { pager_printf_color( ch, "&W *&C%s\n\r", ship->name ); if( ship->in_room != NULL ) pager_printf_color( ch, "&c Docked at %s\n\r", ship->in_room->name ); else if( ship->starsystem != NULL ) pager_printf_color( ch, "&c In the %s\n\r", ship->starsystem->name ); else if( ship->shipstate == SHIP_HYPERSPACE ) pager_printf_color( ch, "&c In hyperspace heading to the %s\n\r", ship->currjump->name ); else pager_printf_color( ch, "&c Can't locate ships position at this time\n\r" ); } } return; } if( !is_dock( ch->in_room ) ) { send_to_char( "You need to be at a space dock first.\n\r", ch ); return; } ship = has_ship( ch ); if( ship == NULL ) { send_to_char( "You don't have a ship to call.\n\r", ch ); return; } if( arg[0] != '\0' ) { ship = get_ship( arg ); if( ship == NULL ) { send_to_char( "You don't own that ship.\n\r", ch ); return; } if( !str_cmp( ch->name, ship->owner ) || !str_cmp( ch->name, ship->pilot ) || !str_cmp( ch->name, ship->copilot ) ) ; else { send_to_char( "You don't own that ship.\n\r", ch ); return; } } if( ch->in_room == ship->in_room ) { pager_printf_color( ch, "Your ship '%s' is already here.\n\r", ship->name ); return; } if( ship->shipstate != SHIP_DOCKED ) { pager_printf_color( ch, "Your ship(%s) is currently in flight to some where else. Please wait until it has docked.\n\r", ship->name ); return; } pager_printf_color( ch, "Calling %s...\n\r", ship->name ); oldRoom = ship->in_room->vnum; launch_bus( ship ); if( !land_bus( ship, ch->in_room->vnum ) ) { bug( "do_callship: Can't land %s's ship (%s) in room %d", ch->name, ship->name, ch->in_room->vnum ); send_to_char( "Your ship couldn't land here for some reason.\n\r", ch ); land_bus( ship, oldRoom ); } save_ship( ship ); return; } extern MOB_INDEX_DATA *mob_index_hash[MAX_KEY_HASH]; void miv( CHAR_DATA * ch, char *argument ) { char arg[MAX_INPUT_LENGTH]; MOB_INDEX_DATA *pMobIndex; CHAR_DATA *victim; int vnum; one_argument( argument, arg ); if( arg[0] == '\0' ) { send_to_char( "Syntax: miv <vnum>\n\r", ch ); return; } if( !is_number( arg ) ) { char arg2[MAX_INPUT_LENGTH]; int hash, cnt; int count = number_argument( arg, arg2 ); vnum = -1; for( hash = cnt = 0; hash < MAX_KEY_HASH; hash++ ) for( pMobIndex = mob_index_hash[hash]; pMobIndex; pMobIndex = pMobIndex->next ) if( nifty_is_name( arg2, pMobIndex->player_name ) && ++cnt == count ) { vnum = pMobIndex->vnum; break; } if( vnum == -1 ) { send_to_char( "Not found.\n\r", ch ); return; } } else vnum = atoi( arg ); if( ( pMobIndex = get_mob_index( vnum ) ) == NULL ) { send_to_char( "No m has that v.\n\r", ch ); return; } if( !xIS_SET( pMobIndex->act, ACT_PROTOTYPE ) && ch->level < sysdata.level_modify_proto ) { send_to_char( "You can't.\n\r", ch ); return; } victim = create_mobile( pMobIndex ); char_to_room( victim, ch->in_room ); return; } extern OBJ_INDEX_DATA *obj_index_hash[MAX_KEY_HASH]; void oiv( CHAR_DATA * ch, char *argument ) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; OBJ_INDEX_DATA *pObjIndex; OBJ_DATA *obj; int vnum; int level = 0; set_char_color( AT_IMMORT, ch ); argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if( arg1[0] == '\0' ) { send_to_char( "Syntax: oiv <vnum> <level>.\n\r", ch ); return; } if( !is_number( arg1 ) ) { char arg[MAX_INPUT_LENGTH]; int hash, cnt; int count = number_argument( arg1, arg ); vnum = -1; for( hash = cnt = 0; hash < MAX_KEY_HASH; hash++ ) for( pObjIndex = obj_index_hash[hash]; pObjIndex; pObjIndex = pObjIndex->next ) if( nifty_is_name( arg, pObjIndex->name ) && ++cnt == count ) { vnum = pObjIndex->vnum; break; } if( vnum == -1 ) { send_to_char( "Not found.\n\r", ch ); return; } } else vnum = atoi( arg1 ); if( ( pObjIndex = get_obj_index( vnum ) ) == NULL ) { send_to_char( "Not found.\n\r", ch ); return; } /* * if ( !IS_OBJ_STAT(pObjIndex, ITEM_PROTOTYPE) ) * { * send_to_char( "You can't.\n\r", ch ); * return ; * } */ obj = create_object_new( pObjIndex, level, ORIGIN_OINVOKE, ch->name ); if( CAN_WEAR( obj, ITEM_TAKE ) ) obj = obj_to_char( obj, ch ); else obj = obj_to_room( obj, ch->in_room ); return; }