/***************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
* *
* Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael *
* Chastain, Michael Quan, and Mitchell Tse. *
* *
* Ack 2.2 improvements copyright (C) 1994 by Stephen Dooley *
* *
* In order to use any part of this Merc Diku Mud, you must comply with *
* both the original Diku license in 'license.doc' as well the Merc *
* license in 'license.txt'. In particular, you may not remove either of *
* these copyright notices. *
* *
* _/ _/_/_/ _/ _/ _/ ACK! MUD is modified *
* _/_/ _/ _/ _/ _/ Merc2.0/2.1/2.2 code *
* _/ _/ _/ _/_/ _/ (c)Stephen Zepp 1998 *
* _/_/_/_/ _/ _/ _/ Version #: 4.3 *
* _/ _/ _/_/_/ _/ _/ _/ *
* *
* http://ackmud.nuc.net/ *
* zenithar@ackmud.nuc.net *
* Much time and thought has gone into this software and you are *
* benefitting. We hope that you share your changes too. What goes *
* around, comes around. *
***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
/* For forks etc. */
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#ifndef DEC_ACK_H
#include "globals.h"
#include "tables.h"
#endif
#ifndef DEC_STRFUNS_H
#include "strfuns.h"
#endif
void pre_parse( char *list, char *victimname, char *containername, char *things )
{
char arg1[MSL];
char container_name[MSL];
char one_object[MSL];
char holdbuf[MSL];
char victim_name[MSL];
char object_list[MSL];
char *argument = list;
container_name[0] = '\0';
victim_name[0] = '\0';
object_list[0] = '\0';
for( ;; )
{
argument = one_argument( argument, arg1 );
if( arg1[0] == '\0' )
break;
if( ( !str_cmp( "from", arg1 ) ) || ( !str_cmp( "in", arg1 ) ) )
{
argument = one_argument( argument, container_name );
}
else if( !str_cmp( "to", arg1 ) )
{
argument = one_argument( argument, victim_name );
}
else
{
if( is_number( arg1 ) )
{
argument = one_argument( argument, one_object );
sprintf( holdbuf, "%s %s ", arg1, one_object );
safe_strcat( MSL, object_list, holdbuf );
}
else
{
sprintf( holdbuf, "1 %s ", arg1 );
safe_strcat( MSL, object_list, holdbuf );
}
}
}
strcpy( victimname, victim_name );
strcpy( things, object_list );
strcpy( containername, container_name );
return;
}
/*
* Return true if an argument is completely numeric.
*/
bool is_number( char *arg )
{
if( *arg == '\0' )
return FALSE;
if( *arg == '+' || *arg == '-' )
arg++;
for( ; *arg != '\0'; arg++ )
{
if( !isdigit( *arg ) )
return FALSE;
}
return TRUE;
}
bool is_name( const char *str, char *namelist )
{
char name[MAX_INPUT_LENGTH];
for( ;; )
{
namelist = one_argument( namelist, name );
if( name[0] == '\0' )
return FALSE;
if( !str_cmp( str, name ) )
return TRUE;
}
}
void safe_strcat( int max_len, char *dest, char *source )
{
int a;
char c;
char *orig_dest;
char *orig_source;
if( dest == NULL && source == NULL )
return;
if( dest == NULL )
{
fprintf( stderr, "safe_strcat: Null dest string for source : %s\n", source );
return;
}
if( source == NULL )
{
fprintf( stderr, "safe_strcat: NULL source for dest : %s\n", dest );
return;
}
orig_dest = dest;
orig_source = source;
while( *dest != '\0' ) /* Check to see if dest is already over limit. */
dest++;
a = dest - orig_dest;
if( a > max_len )
{
fprintf( stderr, "WARNING: dest string already too long:\nsource: %s\ndest: %s\n", source, orig_dest );
return;
}
if( a == max_len )
{
fprintf( stderr, "safe_strcat: string too long, source is : %s\n", orig_source );
return;
}
while( ( c = *( source++ ) ) != 0 )
{
*( dest++ ) = c;
a++;
if( a == max_len )
{
*( --dest ) = '\0';
fprintf( stderr, "safe_strcat: string too long, source is : %s\n", orig_source );
return;
}
}
*dest = '\0';
return;
}
char *space_pad( const char *str, sh_int final_size )
{
sh_int space_pad = my_strlen( str );
static char padbuf[MSL];
sprintf( padbuf, "%s", str );
for( ; space_pad != final_size; space_pad++ )
safe_strcat( MSL, padbuf, " " );
return padbuf;
}
/*
* Removes the tildes from a string.
* Used for player-entered strings that go into disk files.
*/
void smash_tilde( char *str )
{
for( ; *str != '\0'; str++ )
{
if( *str == '~' )
*str = '-';
}
return;
}
/*
* Compare strings, case insensitive.
* Return TRUE if different
* (compatibility with historical functions).
*/
bool str_cmp( const char *astr, const char *bstr )
{
int count = 0;
bool notrunc = FALSE;
if( astr == NULL )
{
/*
* bug( "Str_cmp: null astr.", 0 );
*/
return TRUE;
}
if( bstr == NULL )
{
/* bug( "Str_cmp: null bstr.", 0 ); */
return TRUE;
}
if( *astr == '^' )
{
notrunc = TRUE;
astr++;
}
if( *bstr == '^' )
{
notrunc = TRUE;
bstr++;
}
if( astr == NULL )
{
/*
* bug( "Str_cmp: null astr.", 0 );
*/
return TRUE;
}
if( bstr == NULL )
{
/* bug( "Str_cmp: null bstr.", 0 ); */
return TRUE;
}
for( ; *astr || *bstr; astr++, bstr++ )
{
if( !notrunc )
if( *astr == '*' && count )
return FALSE;
if( LOWER( *astr ) != LOWER( *bstr ) )
return TRUE;
count++;
}
return FALSE;
}
/*
* Compare strings, case insensitive, for prefix matching.
* Return TRUE if astr not a prefix of bstr
* (compatibility with historical functions).
*/
bool str_prefix( const char *astr, const char *bstr )
{
if( astr == NULL )
{
bug( "Strn_cmp: null astr.", 0 );
return TRUE;
}
if( bstr == NULL )
{
bug( "Strn_cmp: null bstr.", 0 );
return TRUE;
}
for( ; *astr; astr++, bstr++ )
{
if( LOWER( *astr ) != LOWER( *bstr ) )
return TRUE;
}
return FALSE;
}
/*
* Compare strings, case insensitive, for match anywhere.
* Returns TRUE is astr not part of bstr.
* (compatibility with historical functions).
*/
bool str_infix( const char *astr, const char *bstr )
{
int sstr1;
int sstr2;
int ichar;
char c0;
if( ( c0 = LOWER( astr[0] ) ) == '\0' )
return FALSE;
sstr1 = strlen( astr );
sstr2 = strlen( bstr );
for( ichar = 0; ichar <= sstr2 - sstr1; ichar++ )
{
if( c0 == LOWER( bstr[ichar] ) && !str_prefix( astr, bstr + ichar ) )
return FALSE;
}
return TRUE;
}
/*
* Compare strings, case insensitive, for suffix matching.
* Return TRUE if astr not a suffix of bstr
* (compatibility with historical functions).
*/
bool str_suffix( const char *astr, const char *bstr )
{
int sstr1;
int sstr2;
sstr1 = strlen( astr );
sstr2 = strlen( bstr );
if( sstr1 <= sstr2 && !str_cmp( astr, bstr + sstr2 - sstr1 ) )
return FALSE;
else
return TRUE;
}
/*
* Returns an initial-capped string.
*/
#if 0
char *capitalize( const char *str )
{
static char strcap[MAX_STRING_LENGTH];
int i;
for( i = 0; str[i] != '\0'; i++ )
{
if( ( str[i] == '@' ) && ( str[i + 1] == '@' ) && ( str[i + 2] != '\0' ) )
{
strcap[i] = str[i];
strcap[i + 1] = str[i + 1];
strcap[i + 2] = str[i + 2];
i += 2;
}
else
strcap[i] = LOWER( str[i] );
}
strcap[i] = '\0';
for( i = 0; strcap[i] != '\0' && !isalpha( strcap[i] ); i++ );
if( ( i > 0 ) && ( strcap[i] != '\0' ) )
i++;
if( strcap[i] != '\0' )
strcap[i] = UPPER( strcap[i] );
return strcap;
}
#endif
/* Capitalize function by KaVir: 3th December 1997.
*
* Pass in a pointer to the string to capitalize. The function will return
* a pointer to the corrected string, however for safety purposes the original
* pointer will also be set to point to the new string. Thus if you do:
* char *normal_string = "a piece of text";
* char *cap_string = capitalize( normal_string );
* Then both cap_string and normal_string will contain the capitalized string.
*
* The precise rules of capitalization are as follows:
* 1) The first non-colorcode alphabetic character will be uppercase.
* 2) Any alphabetic character following two or more @'s will be unchanged.
* 3) Any other alphabetic character will be set to lowercase.
* 4) Any other non-alphabetic characters will be ignored.
*/
char *capitalize( const char *str )
{
static char strcap[MAX_STRING_LENGTH]; /* Permanent store */
/* char *oldstr = str; */
int i = 0; /* Position in strcap */
int count = 0; /* Number of previous '@'s encountered */
bool first_letter = TRUE; /* You will UPPER the first letter you find */
bool ignore_next = FALSE; /* Ignore the case of the next letter you find */
/*
* If this occurs, then you have a bug elsewhere
*/
if( ( strcap[i] = *str ) == '\0' )
{
bug( "Capitalize: Attempted to capitalize a NULL string.", 0 );
return NULL;
}
do /* Begin looping through the string, checking each character */
{
/*
* Should be more efficient than all those 'if' statements ;)
*/
switch ( strcap[i] )
{
default: /* Non-alphabetic letters and not '@' */
ignore_next = FALSE; /* Not a color code */
count = 0;
break;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': /* Any lowercase letter */
if( ignore_next )
ignore_next = FALSE; /* We ignore the case of the this letter */
else if( first_letter )
{
first_letter = FALSE; /* Reset the flag */
strcap[i] = UPPER( strcap[i] ); /* We set this letter to uppercase */
}
count = 0;
break;
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z': /* Any uppercase letter */
/*
* Then its the first letter in the string
*/
if( ignore_next )
ignore_next = FALSE; /* We ignore the case of the this letter */
else if( first_letter )
first_letter = FALSE; /* We ignore the case of the this letter */
else
strcap[i] = LOWER( strcap[i] ); /* Set this letter to lowercase */
count = 0;
break;
case '@':
if( ++count >= 2 ) /* If there are two or more '@@'s in a row */
ignore_next = TRUE; /* Set the flag to ignore the next letter */
break;
}
}
while( ( strcap[++i] = *++str ) != '\0' ); /* loop until end of string */
i = 0; /* str = oldstr; Reset variables */
#if 0
/*
* Copy strcap back into the old string
*/
while( ( *str++ = strcap[i++] ) != '\0' )
;
return ( oldstr ); /* Return pointer to start of old string */
#endif
return ( strcap );
}
/*
* We need a replacement for strlen() which will take the color
* codes into account when reporting a string's length.
* -- Stephen
*/
int my_strlen( const char *text )
{
char c;
int i;
int status;
int length;
int strlen_size;
status = 0;
length = 0;
strlen_size = strlen( text );
for( i = 0; i < strlen_size; i++ )
{
c = text[i];
length++;
switch ( status )
{
case 0:
case 1:
if( c == '@' )
status++;
else
status = 0;
break;
case 2:
length -= 3; /* Subtract for '@@x' */
status = 0;
break;
}
}
return ( length );
}
char *learnt_name( int learnt )
{
/*
* For skills/spells. Return a string indicating how well the
* skill is learnt.
*/
if( learnt < 1 )
return "Unknown";
else if( learnt < 15 )
return "Awful";
else if( learnt < 30 )
return "Weak";
else if( learnt < 40 )
return "Poor";
else if( learnt < 50 )
return "Average";
else if( learnt < 60 )
return "Fair";
else if( learnt < 70 )
return "Good";
else if( learnt < 80 )
return "Great";
else if( learnt < 85 )
return "Superb";
else if( learnt < 90 )
return "Amazing";
else if( learnt < 101 )
return "Godlike";
else if( learnt < 102 )
return "RACE";
else
return "Godlike";
}
char *get_adept_name( CHAR_DATA * ch )
{
/*
* this is weak for now..will eventually have like 200 total names, based on the remort
* classes the adept has
*/
switch ( ch->adept_level )
{
case 1:
return "@@W Mystic @@N";
break;
case 2:
return "@@a Templar @@N";
break;
case 3:
return "@@l Illusionist @@N";
break;
case 4:
return "@@e Crusader @@N";
break;
case 5:
return "@@d Warlock @@N";
break;
case 6:
return "@@a Paladin @@N";
case 7:
return "@@r Ranger @@N";
break;
case 8:
return "@@c Gladiator @@N";
break;
case 9:
return "@@l Shogun @@N";
break;
case 10:
return "@@e Shamen @@N";
break;
case 11:
return "@@r Druid @@N";
break;
case 12:
return "@@b Conjurer @@N";
case 13:
return "@@l Elementalist @@N";
break;
case 14:
return "@@m Runemaster @@N";
case 15:
return "@@d Shadowmaster @@N";
break;
case 16:
return "@@b Beastmaster @@N";
break;
case 17:
return "@@R Warlord @@N";
break;
case 18:
return "@@e Dragonlord @@N";
break;
case 19:
return "@@d Demonlord @@N";
break;
case 20:
return "@@m Realm Lord @@N";
}
return "@@W Adept @@N";
}
int nocol_strlen( const char *text )
{
char c;
int i;
int status;
int length;
int strlen_size;
status = 0;
length = 0;
strlen_size = strlen( text );
for( i = 0; i < strlen_size; i++ )
{
c = text[i];
length++;
switch ( status )
{
case 0:
case 1:
if( c == '@' )
status++;
else
status = 0;
break;
case 2:
length -= 3; /* Subtract for '@@x' */
status = 0;
break;
}
}
return ( length );
}
int ccode_len( const char *text, sh_int desired )
{
char c;
int i;
int status;
int length;
int strlen_size;
status = 0;
length = 0;
strlen_size = strlen( text );
for( i = 0; i < strlen_size; i++ )
{
c = text[i];
switch ( status )
{
case 0:
case 1:
if( c == '@' )
status++;
else
status = 0;
break;
case 2:
length += 3; /* Subtract for '@@x' */
status = 0;
break;
}
}
return ( length + desired );
}
/* END NOTE */
/* A Function to "center" text, and return a string with
* the required amount of white space either side of the
* original text. --Stephen
*/
char *center_text( char *text, int width )
{
/*
* This could do with a LOT of improvement sometime!
*/
/*
* Improvements done.. -- Altrag
*/
static char foo[MAX_STRING_LENGTH];
int len, diff;
/*
* Don't bother with strings too long..
*/
if( ( len = my_strlen( text ) ) >= width )
return text;
diff = strlen( text ) - len;
/*
* Add the spaces and terminate string
*/
memset( foo, ' ', width + diff );
foo[width + diff] = '\0';
/*
* Copy old string over
*/
memcpy( &foo[( width - len ) / 2], text, len + diff );
return foo;
}
char *str_mod( char *mod_string, char *argument )
{
char arg1[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
char *buf2;
char *buf3 = NULL;
char *word;
char temp[MSL];
int i = 0;
bool multiple = FALSE;
if( !str_cmp( argument, "" ) )
{
sprintf( bug_buf, "Unknown reason for return, argument is -%s-", argument );
monitor_chan( bug_buf, MONITOR_DEBUG );
return mod_string;
}
if( argument[0] == '+' || argument[0] == '-' )
{
buf[0] = '\0';
smash_tilde( argument );
if( argument[0] == '+' )
{
argument++;
if( mod_string )
strcat( buf, mod_string );
while( isspace( *argument ) )
argument++;
if( !str_infix( argument, mod_string ) )
{
return mod_string;
}
strcat( buf, argument );
strcat( buf, " " );
}
if( argument[0] == '-' )
{
argument++;
if( argument[0] == '\'' )
multiple = TRUE;
one_argument( argument, arg1 );
if( multiple )
{
sprintf( temp, "\'%s\'", arg1 );
sprintf( arg1, "%s", temp );
}
if( arg1 )
{
buf2 = str_dup( mod_string );
buf3 = buf2;
if( ( word = strstr( buf2, arg1 ) ) == NULL )
{
free_string( buf2 );
return mod_string;
}
else
{
while( buf2 != word )
buf[i++] = *( buf2++ );
while( ( !isspace( *( buf2++ ) ) ) || ( ( multiple ) && ( ( buf2[0] != '\'' ) && ( buf2[0] != '\0' ) ) ) );
buf[i] = '\0';
strcat( buf, buf2 );
}
}
}
free_string( buf3 );
word = buf2 = buf3 = NULL;
free_string( mod_string );
mod_string = str_dup( buf );
}
return mod_string;
}
void rand_arg( char *argument, char *output )
{
char temp[MSL];
sh_int counter = 0;
argument = one_argument( argument, temp );
while( temp[0] )
{
if( number_range( 0, counter ) == 0 )
strcpy( output, temp );
counter++;
argument = one_argument( argument, temp );
}
}
/*
* Given a string like 14.foo, return 14 and 'foo'
*/
int number_argument( char *argument, char *arg )
{
char *pdot;
int number;
for( pdot = argument; *pdot != '\0'; pdot++ )
{
if( *pdot == '.' )
{
*pdot = '\0';
number = atoi( argument );
*pdot = '.';
strcpy( arg, pdot + 1 );
return number;
}
}
strcpy( arg, argument );
return 1;
}
/*
* Pick off one argument from a string and return the rest.
* Understands quotes.
*/
char *one_argument( char *argument, char *arg_first )
{
char cEnd;
if( argument == NULL )
return NULL;
while( isspace( *argument ) )
argument++;
cEnd = ' ';
if( *argument == '\'' || *argument == '"' )
cEnd = *argument++;
while( *argument != '\0' )
{
if( *argument == cEnd )
{
argument++;
break;
}
*arg_first = LOWER( *argument );
arg_first++;
argument++;
}
*arg_first = '\0';
while( isspace( *argument ) )
argument++;
return argument;
}
/*
* Pick off one argument from a string and return the rest.
* Understands quotes.
*/
char *one_word( char *argument, char *arg_first )
{
char cEnd;
if( argument == NULL )
return NULL;
while( isspace( *argument ) )
argument++;
cEnd = ' ';
if( *argument == '\'' || *argument == '"' )
cEnd = *argument++;
while( *argument != '\0' )
{
if( *argument == cEnd )
{
argument++;
break;
}
*arg_first = ( *argument );
arg_first++;
argument++;
}
*arg_first = '\0';
while( isspace( *argument ) )
argument++;
return argument;
}
char *two_args( char *argument, char *arg_first, char *arg_second )
{
char *temp_arg = argument;
temp_arg = one_argument( temp_arg, arg_first );
temp_arg = one_argument( temp_arg, arg_second );
return temp_arg;
}
char *strip_out( const char *orig, const char *strip )
{
static char buf[MAX_STRING_LENGTH];
char *i, *b = buf;
int slen;
if( !orig || !strip )
{
/* log_f("strip_out called with NULL param"); */
return "!!OUT!!";
}
slen = strlen( strip );
for( i = strstr( orig, strip ); i; i = strstr( orig, strip ) )
{
strncpy( b, orig, ( i - orig ) );
b += i - orig;
orig = i + slen;
}
strcpy( b, orig );
return buf;
}
/* this code donated by Altrag */
char *strip_color( const char *orig, const char *strip )
{
static char buf[MAX_STRING_LENGTH];
char *i, *b = buf;
int slen;
if( !orig || !strip )
{
/* log_f("strip_out called with NULL param"); */
return "!!OUT!!";
}
slen = strlen( strip ) + 1;
for( i = strstr( orig, strip ); i; i = strstr( orig, strip ) )
{
strncpy( b, orig, ( i - orig ) );
b += i - orig;
orig = i + slen;
}
strcpy( b, orig );
return buf;
}
char *get_tribe_standing_name( int standing )
{
switch ( standing )
{
case 0:
return "@@mEternal@@N";
break;
case 1:
return "@@rEldest@@N";
break;
case 2:
return "@@rMate@@N";
break;
case 3:
return "@@eWarder@@N";
break;
case 4:
return "@@GGuardian@@N";
break;
case 5:
return "@@aSentry@@N";
break;
case 6:
return "@@yElder@@N";
case 7:
return "@@rAdult@@N";
break;
case 8:
return "@@RYounger@@N";
break;
case 9:
return "@@bCub@@N";
break;
}
return "@@WCUB@@N";
}
char *get_moon_phase_name( void )
{
switch ( weather_info.moon_phase )
{
case MOON_NEW:
return "@@bDark@@N";
break;
case MOON_WAX_CRE:
return "@@aWaxing @@dCresent@@N";
break;
case MOON_WAX_HALF:
return "@@aWaxing @@gHalf@@N";
break;
case MOON_WAX_GIB:
return "@@aWaxing @@WGibbous@@N";
break;
case MOON_FULL:
return "@@WFULL@@N";
break;
case MOON_WAN_GIB:
return "@@cWaning @@WGibbous@@N";
break;
case MOON_WAN_HALF:
return "@@cWaning @@gHalf@@N";
break;
case MOON_WAN_CRE:
return "@@cWaning @@dCrescent@@N";
break;
}
return "@@eDESTROYED!!!@@N";
}
bool list_in_list( char *first_list, char *second_list )
{
char check_word[MAX_INPUT_LENGTH];
char against_word[MSL];
char *checklist;
char *againstlist;
checklist = first_list;
againstlist = second_list;
for( ;; )
{
checklist = one_argument( checklist, check_word );
againstlist = second_list;
if( check_word[0] == '\0' )
{
return FALSE;
}
for( ;; )
{
againstlist = one_argument( againstlist, against_word );
if( against_word[0] == '\0' )
break;
if( !str_cmp( check_word, against_word ) )
{
return TRUE;
}
}
}
}
/*
* Return ascii name of an item type.
*/
char *item_type_name( OBJ_DATA * obj )
{
char log[MAX_STRING_LENGTH];
switch ( obj->item_type )
{
case ITEM_LIGHT:
return "light";
case ITEM_SCROLL:
return "scroll";
case ITEM_WAND:
return "wand";
case ITEM_STAFF:
return "staff";
case ITEM_BEACON:
return "beacon";
case ITEM_WEAPON:
return "weapon";
case ITEM_TREASURE:
return "treasure";
case ITEM_ARMOR:
return "armor";
case ITEM_POTION:
return "potion";
case ITEM_FURNITURE:
return "furniture";
case ITEM_TRASH:
return "trash";
case ITEM_CONTAINER:
return "container";
case ITEM_QUEST:
return "quest";
case ITEM_DRINK_CON:
return "drink container";
case ITEM_KEY:
return "key";
case ITEM_FOOD:
return "food";
case ITEM_MONEY:
return "money";
case ITEM_BOAT:
return "boat";
case ITEM_CORPSE_NPC:
return "npc corpse";
case ITEM_CORPSE_PC:
return "pc corpse";
case ITEM_FOUNTAIN:
return "fountain";
case ITEM_PILL:
return "pill";
case ITEM_BOARD:
return "bulletin board";
case ITEM_CLUTCH:
return "clutch";
case ITEM_TRIGGER:
return "trigger";
case ITEM_STAKE:
return "stake";
case ITEM_SOUL:
return "soul";
case ITEM_PIECE:
return "piece";
case ITEM_SPELL_MATRIX:
return "spell matrix";
case ITEM_ENCHANTMENT:
return "enchantment";
case ITEM_PORTAL:
return "portal";
}
sprintf( log, "Item_type_name: Object: %d. Unknown Type: %d", obj->pIndexData->vnum, obj->item_type );
monitor_chan( log, MONITOR_OBJ );
bug( log, 0 );
return "(unknown)";
}
/*
* Return ascii name of an affect location.
*/
char *affect_loc_name( int location )
{
char buf[MAX_STRING_LENGTH];
switch ( location )
{
case APPLY_NONE:
return "none";
case APPLY_STR:
return "strength";
case APPLY_DEX:
return "dexterity";
case APPLY_INT:
return "intelligence";
case APPLY_WIS:
return "wisdom";
case APPLY_CON:
return "constitution";
case APPLY_SEX:
return "sex";
case APPLY_CLASS:
return "class";
case APPLY_LEVEL:
return "level";
case APPLY_AGE:
return "age";
case APPLY_HEIGHT:
return "height";
case APPLY_WEIGHT:
return "weight";
case APPLY_MANA:
return "mana";
case APPLY_HIT:
return "hp";
case APPLY_MOVE:
return "moves";
case APPLY_GOLD:
return "gold";
case APPLY_EXP:
return "experience";
case APPLY_AC:
return "armor class";
case APPLY_HITROLL:
return "hit roll";
case APPLY_DAMROLL:
return "damage roll";
case APPLY_SAVING_PARA:
return "save vs paralysis";
case APPLY_SAVING_ROD:
return "save vs rod";
case APPLY_SAVING_PETRI:
return "save vs petrification";
case APPLY_SAVING_BREATH:
return "save vs breath";
case APPLY_SAVING_SPELL:
return "save vs spell";
}
sprintf( buf, "affect_location_name: location %d unknown.", location );
monitor_chan( buf, MONITOR_OBJ );
bug( "Affect_location_name: unknown location %d.", location );
return "(unknown)";
}
char *raffect_bit_name( int vector )
{
static char rbuf[512];
rbuf[0] = '\0';
if( vector & ROOM_BV_NONE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " NONE" );
if( vector & ROOM_BV_SILENCE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " Silence" );
if( vector & ROOM_BV_SAFE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " Safe" );
if( vector & ROOM_BV_ENCAPS )
safe_strcat( MAX_STRING_LENGTH, rbuf, " Seal Room" );
if( vector & ROOM_BV_SHADE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " Shade" );
if( vector & ROOM_BV_HEAL_REGEN )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@mHealing Light@@N" );
if( vector & ROOM_BV_HEAL_STEAL )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@dWither Shadow@@N" );
if( vector & ROOM_BV_MANA_REGEN )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@eMana Flare@@N" );
if( vector & ROOM_BV_MANA_STEAL )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@dMana Drain@@N" );
if( vector & ROOM_BV_FIRE_RUNE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@eFire @@NRune" );
if( vector & ROOM_BV_FIRE_TRAP )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@eFire @@NTrap" );
if( vector & ROOM_BV_DAMAGE_TRAP )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@dDamage @@NTrap" );
if( vector & ROOM_BV_SHOCK_RUNE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@lShock @@NRune" );
if( vector & ROOM_BV_SHOCK_TRAP )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@lShock @@NTrap" );
if( vector & ROOM_BV_HOLD )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@rCage@@N" );
if( vector & ROOM_BV_POISON_RUNE )
safe_strcat( MAX_STRING_LENGTH, rbuf, " @@Poison@@N Rune" );
return ( rbuf[0] != '\0' ) ? rbuf + 1 : "none";
}
/*
* Return ascii name of an affect bit vector.
*/
char *affect_bit_name( int vector )
{
static char buf[512];
buf[0] = '\0';
if( vector & AFF_BLIND )
safe_strcat( MAX_STRING_LENGTH, buf, " blind" );
if( vector & AFF_INVISIBLE )
safe_strcat( MAX_STRING_LENGTH, buf, " invisible" );
if( vector & AFF_DETECT_EVIL )
safe_strcat( MAX_STRING_LENGTH, buf, " detect_evil" );
if( vector & AFF_DETECT_INVIS )
safe_strcat( MAX_STRING_LENGTH, buf, " detect_invis" );
if( vector & AFF_DETECT_MAGIC )
safe_strcat( MAX_STRING_LENGTH, buf, " detect_magic" );
if( vector & AFF_DETECT_HIDDEN )
safe_strcat( MAX_STRING_LENGTH, buf, " detect_hidden" );
if( vector & AFF_HOLD )
safe_strcat( MAX_STRING_LENGTH, buf, " hold" );
if( vector & AFF_SANCTUARY )
safe_strcat( MAX_STRING_LENGTH, buf, " sanctuary" );
if( vector & AFF_FAERIE_FIRE )
safe_strcat( MAX_STRING_LENGTH, buf, " faerie_fire" );
if( vector & AFF_INFRARED )
safe_strcat( MAX_STRING_LENGTH, buf, " infrared" );
if( vector & AFF_CURSE )
safe_strcat( MAX_STRING_LENGTH, buf, " curse" );
if( vector & AFF_CLOAK_FLAMING )
safe_strcat( MAX_STRING_LENGTH, buf, " flaming" );
if( vector & AFF_POISON )
safe_strcat( MAX_STRING_LENGTH, buf, " poison" );
if( vector & AFF_PROTECT )
safe_strcat( MAX_STRING_LENGTH, buf, " protect" );
if( vector & AFF_PARALYSIS )
safe_strcat( MAX_STRING_LENGTH, buf, " paralysis" );
if( vector & AFF_SLEEP )
safe_strcat( MAX_STRING_LENGTH, buf, " sleep" );
if( vector & AFF_SNEAK )
safe_strcat( MAX_STRING_LENGTH, buf, " sneak" );
if( vector & AFF_HIDE )
safe_strcat( MAX_STRING_LENGTH, buf, " hide" );
if( vector & AFF_CHARM )
safe_strcat( MAX_STRING_LENGTH, buf, " charm" );
if( vector & AFF_FLYING )
safe_strcat( MAX_STRING_LENGTH, buf, " flying" );
if( vector & AFF_PASS_DOOR )
safe_strcat( MAX_STRING_LENGTH, buf, " pass_door" );
if( vector & AFF_CLOAK_REFLECTION )
safe_strcat( MAX_STRING_LENGTH, buf, " cloak:reflection" );
if( vector & AFF_CLOAK_ABSORPTION )
safe_strcat( MAX_STRING_LENGTH, buf, " cloak:absorption" );
if( vector & AFF_CLOAK_ADEPT )
safe_strcat( MAX_STRING_LENGTH, buf, " cloak:adept" );
if( vector & AFF_CLOAK_REGEN )
safe_strcat( MAX_STRING_LENGTH, buf, " cloak:regeneration" );
return ( buf[0] != '\0' ) ? buf + 1 : "none";
}
/*
* Return ascii name of extra flags vector.
*/
char *extra_bit_name( int extra_flags )
{
static char buf[512];
buf[0] = '\0';
if( extra_flags & ITEM_GLOW )
safe_strcat( MAX_STRING_LENGTH, buf, " glow" );
if( extra_flags & ITEM_HUM )
safe_strcat( MAX_STRING_LENGTH, buf, " hum" );
if( extra_flags & ITEM_DARK )
safe_strcat( MAX_STRING_LENGTH, buf, " nodisarm" );
if( extra_flags & ITEM_LOCK )
safe_strcat( MAX_STRING_LENGTH, buf, " lock" );
if( extra_flags & ITEM_EVIL )
safe_strcat( MAX_STRING_LENGTH, buf, " evil" );
if( extra_flags & ITEM_INVIS )
safe_strcat( MAX_STRING_LENGTH, buf, " invis" );
if( extra_flags & ITEM_MAGIC )
safe_strcat( MAX_STRING_LENGTH, buf, " magic" );
if( extra_flags & ITEM_NODROP )
safe_strcat( MAX_STRING_LENGTH, buf, " nodrop" );
if( extra_flags & ITEM_BLESS )
safe_strcat( MAX_STRING_LENGTH, buf, " bless" );
if( extra_flags & ITEM_ANTI_GOOD )
safe_strcat( MAX_STRING_LENGTH, buf, " anti-good" );
if( extra_flags & ITEM_ANTI_EVIL )
safe_strcat( MAX_STRING_LENGTH, buf, " anti-evil" );
if( extra_flags & ITEM_ANTI_NEUTRAL )
safe_strcat( MAX_STRING_LENGTH, buf, " anti-neutral" );
if( extra_flags & ITEM_NOREMOVE )
safe_strcat( MAX_STRING_LENGTH, buf, " noremove" );
if( extra_flags & ITEM_INVENTORY )
safe_strcat( MAX_STRING_LENGTH, buf, " inventory" );
if( extra_flags & ITEM_NOLOOT )
safe_strcat( MAX_STRING_LENGTH, buf, " noloot" );
if( extra_flags & ITEM_NOSAC )
safe_strcat( MAX_STRING_LENGTH, buf, " nosac" );
if( extra_flags & ITEM_REMORT )
safe_strcat( MAX_STRING_LENGTH, buf, " remort" );
if( extra_flags & ITEM_CLAN_EQ )
safe_strcat( MAX_STRING_LENGTH, buf, " claneq" );
if( extra_flags & ITEM_NOSAVE )
safe_strcat( MAX_STRING_LENGTH, buf, " nosave" );
if( extra_flags & ITEM_NO_AUCTION )
safe_strcat( MAX_STRING_LENGTH, buf, " no_auction" );
if( extra_flags & ITEM_RARE )
safe_strcat( MAX_STRING_LENGTH, buf, " rare" );
if( extra_flags & ITEM_VAMP )
safe_strcat( MAX_STRING_LENGTH, buf, " vamp" );
if( extra_flags & ITEM_UNIQUE )
safe_strcat( MAX_STRING_LENGTH, buf, " unique" );
if( extra_flags & ITEM_TRIG_DESTROY )
safe_strcat( MAX_STRING_LENGTH, buf, " trigger:destroy" );
if( extra_flags & ITEM_LIFESTEALER )
safe_strcat( MAX_STRING_LENGTH, buf, " lifestealer" );
if( extra_flags & ITEM_SILVER )
safe_strcat( MAX_STRING_LENGTH, buf, " silver" );
return ( buf[0] != '\0' ) ? buf + 1 : "none";
}
/* Return the ASCII name of a character's race
* -- Stephen
*/
char *race_name( CHAR_DATA * ch )
{
if( IS_NPC( ch ) )
return ( "NPC" );
if( ch->race >= MAX_RACE || ch->race < 0 )
{
/*
* error reporting here one day... maybe
*/
return ( "???" );
}
return ( race_table[ch->race].race_title );
}
char *short_race_name( CHAR_DATA * ch )
{
static char buf[MAX_STRING_LENGTH];
if( IS_NPC( ch ) )
sprintf( buf, "NPC" );
else if( ch->race >= MAX_RACE || ch->race < 0 )
{
/*
* error reporting here one day... maybe
*/
sprintf( buf, "unknown!" );
}
else
sprintf( buf, "%s", race_table[ch->race].race_name );
return ( buf );
}
char *get_family_name( CHAR_DATA * ch )
{
switch ( ch->pcdata->vamp_bloodline )
{
default:
return "Renegade!";
case 1:
return "@@WNOT SET@@N";
case 2:
return "@@WNOT SET@@N";
case 3:
return "@@WNOT SET@@N";
case 4:
return "@@WNOT SET@@N";
}
}
char *get_tribe_name( CHAR_DATA * ch )
{
switch ( ch->pcdata->vamp_bloodline )
{
default:
return "Renegade!";
case 1:
return "@@WNOT SET@@N";
case 2:
return "@@WNOT SET@@N";
case 3:
return "@@WNOT SET@@N";
case 4:
return "@@WNOT SET@@N";
}
}