/*************************************************************************** * 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. * ***************************************************************************/ #if defined(macintosh) #include <types.h> #else #include <sys/types.h> #endif #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 "ack.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"; } }