diff -upN ./SVN_Comp01/Fire/src/act_comm.c ./SVN_Comp/Fire/src/act_comm.c
--- ./SVN_Comp01/Fire/src/act_comm.c 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/act_comm.c 2009-01-11 07:32:28.000000000 -0500
@@ -259,7 +259,6 @@ void do_replay( CHAR_DATA *ch, const cha
/* RT auction rewritten in ROM style */
void do_auction( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -292,29 +291,15 @@ void do_auction( CHAR_DATA *ch, const ch
}
REMOVE_BIT( ch->comm, COMM_NOAUCTION );
+
+ channel_speech( CHAN_AUCTION, ch, argument, NULL );
}
-
- ch_printf( ch, "You auction '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim = NULL;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_NOAUCTION ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act_new( "$n auctions '$t'", ch, argument, d->character, TO_VICT, POS_DEAD );
- }
- }
+
}
/* RT chat replaced with ROM gossip */
void do_gossip( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -349,28 +334,12 @@ void do_gossip( CHAR_DATA *ch, const cha
REMOVE_BIT( ch->comm, COMM_NOGOSSIP );
- ch_printf( ch, "You gossip '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_NOGOSSIP ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act_new( "$n gossips '$t'",
- ch, argument, d->character, TO_VICT, POS_SLEEPING );
- }
- }
+ channel_speech( CHAN_GOSSIP, ch, argument, NULL );
}
}
void do_grats( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -405,28 +374,12 @@ void do_grats( CHAR_DATA *ch, const char
REMOVE_BIT( ch->comm, COMM_NOGRATS );
- ch_printf( ch, "You grats '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_NOGRATS ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act_new( "$n grats '$t'",
- ch, argument, d->character, TO_VICT, POS_SLEEPING );
- }
- }
+ channel_speech( CHAN_GRATS, ch, argument, NULL );
}
}
void do_quote( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -461,29 +414,13 @@ void do_quote( CHAR_DATA *ch, const char
REMOVE_BIT( ch->comm, COMM_NOQUOTE );
- ch_printf( ch, "You quote '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_NOQUOTE ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act_new( "$n quotes '$t'",
- ch, argument, d->character, TO_VICT, POS_SLEEPING );
- }
- }
+ channel_speech( CHAN_QUOTE, ch, argument, NULL );
}
}
/* RT question channel */
void do_question( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -517,29 +454,13 @@ void do_question( CHAR_DATA *ch, const c
REMOVE_BIT( ch->comm, COMM_NOQUESTION );
- ch_printf( ch, "You question '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim = NULL;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_NOQUESTION ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act_new( "$n questions '$t'",
- ch, argument, d->character, TO_VICT, POS_SLEEPING );
- }
- }
+ channel_speech( CHAN_QUESTION, ch, argument, NULL );
}
}
/* RT answer channel - uses same line as questions */
void do_answer( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -573,29 +494,13 @@ void do_answer( CHAR_DATA *ch, const cha
REMOVE_BIT( ch->comm, COMM_NOQUESTION );
- ch_printf( ch, "You answer '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim = NULL;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_NOQUESTION ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act_new( "$n answers '$t'",
- ch, argument, d->character, TO_VICT, POS_SLEEPING );
- }
- }
+ channel_speech( CHAN_ANSWER, ch, argument, NULL );
}
}
/* clan channels */
void do_clantalk( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( !is_clan( ch ) || clan_table[ch->clan].independent )
{
@@ -625,25 +530,12 @@ void do_clantalk( CHAR_DATA *ch, const c
REMOVE_BIT( ch->comm, COMM_NOCLAN );
- ch_printf( ch, "You clan '%s'\r\n", argument );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- is_same_clan( ch, d->character ) &&
- !IS_SET( d->character->comm, COMM_NOCLAN ) &&
- !IS_SET( d->character->comm, COMM_QUIET ) )
- {
- act_new( "$n clans '$t'", ch, argument, d->character, TO_VICT, POS_DEAD );
- }
- }
-
+ channel_speech( CHAN_CLAN, ch, argument, NULL );
return;
}
void do_immtalk( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -662,16 +554,7 @@ void do_immtalk( CHAR_DATA *ch, const ch
REMOVE_BIT( ch->comm, COMM_NOWIZ );
- act_new( "$n: $t", ch, argument, NULL, TO_CHAR, POS_DEAD );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- if ( d->connected == CON_PLAYING &&
- IS_IMMORTAL( d->character ) && !IS_SET( d->character->comm, COMM_NOWIZ ) )
- {
- act_new( "$n: $t", ch, argument, d->character, TO_VICT, POS_DEAD );
- }
- }
-
+ channel_speech( CHAN_WIZ, ch, argument, NULL );
return;
}
@@ -683,8 +566,7 @@ void do_say( CHAR_DATA *ch, const char *
return;
}
- act( "$n says '$T'", ch, NULL, argument, TO_ROOM );
- act( "You say '$T'", ch, NULL, argument, TO_CHAR );
+ channel_speech( CHAN_SAY, ch, argument, NULL );
if ( !IS_NPC( ch ) )
{
@@ -704,7 +586,6 @@ void do_say( CHAR_DATA *ch, const char *
void do_shout( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( argument[0] == '\0' )
{
@@ -731,22 +612,7 @@ void do_shout( CHAR_DATA *ch, const char
WAIT_STATE( ch, 12 );
- act( "You shout '$T'", ch, NULL, argument, TO_CHAR );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- CHAR_DATA *victim = NULL;
-
- victim = d->original ? d->original : d->character;
-
- if ( d->connected == CON_PLAYING &&
- d->character != ch &&
- !IS_SET( victim->comm, COMM_SHOUTSOFF ) &&
- !IS_SET( victim->comm, COMM_QUIET ) )
- {
- act( "$n shouts '$t'", ch, argument, d->character, TO_VICT );
- }
- }
-
+ channel_speech( CHAN_SHOUT, ch, argument, NULL );
return;
}
@@ -832,8 +698,7 @@ void do_tell( CHAR_DATA *ch, const char
return;
}
- act( "You tell $N '$t'", ch, argument, victim, TO_CHAR );
- act_new( "$n tells you '$t'", ch, argument, victim, TO_VICT, POS_DEAD );
+ channel_speech( CHAN_TELL, ch, argument, victim );
victim->reply = ch;
if ( !IS_NPC( ch ) && IS_NPC( victim ) && HAS_TRIGGER( victim, TRIG_SPEECH ) )
@@ -904,9 +769,8 @@ void do_reply( CHAR_DATA *ch, const char
add_buf( victim->pcdata->buffer, buf );
return;
}
-
- act_new( "You tell $N '$t'", ch, argument, victim, TO_CHAR, POS_DEAD );
- act_new( "$n tells you '$t'", ch, argument, victim, TO_VICT, POS_DEAD );
+
+ channel_speech( CHAN_REPLY, ch, argument, victim );
victim->reply = ch;
return;
@@ -914,7 +778,6 @@ void do_reply( CHAR_DATA *ch, const char
void do_yell( CHAR_DATA *ch, const char *argument )
{
- DESCRIPTOR_DATA *d = NULL;
if ( IS_SET( ch->comm, COMM_NOSHOUT ) )
{
@@ -928,19 +791,7 @@ void do_yell( CHAR_DATA *ch, const char
return;
}
- act( "You yell '$t'", ch, argument, NULL, TO_CHAR );
- for ( d = descriptor_list; d != NULL; d = d->next )
- {
- if ( d->connected == CON_PLAYING
- && d->character != ch
- && d->character->in_room != NULL
- && d->character->in_room->area == ch->in_room->area
- && !IS_SET( d->character->comm, COMM_QUIET ) )
- {
- act( "$n yells '$t'", ch, argument, d->character, TO_VICT );
- }
- }
-
+ channel_speech( CHAN_YELL, ch, argument, NULL );
return;
}
@@ -1811,7 +1662,6 @@ void do_split( CHAR_DATA *ch, const char
void do_gtell( CHAR_DATA *ch, const char *argument )
{
- CHAR_DATA *gch = NULL;
if ( argument[0] == '\0' )
{
@@ -1825,14 +1675,38 @@ void do_gtell( CHAR_DATA *ch, const char
return;
}
- for ( gch = char_list; gch != NULL; gch = gch->next )
+ channel_speech( CHAN_GROUP, ch, argument, NULL );
+ return;
+}
+
+void do_speak( CHAR_DATA *ch, const char *argument )
+{
+
+ char arg[MAX_INPUT_LENGTH] = "\0\0\0\0\0\0\0";
+ int lang;
+
+ one_argument( argument, arg );
+
+ if ( arg[0] == '\0' )
{
- if ( is_same_group( gch, ch ) )
- act_new( "$n tells the group '$t'",
- ch, argument, gch, TO_VICT, POS_SLEEPING );
+ ch_printf( ch, "Speak which language?\r\n" );
+ return;
}
- return;
+ //TODO: this needs to be a skill lookup
+ lang = language_lookup( arg );
+
+ if ( lang == -1 )
+ {
+ ch_printf( ch, "You don't know how to speak in that language.\r\n" );
+ }
+ else
+ {
+ ch->speaking = language_table[lang].language;
+ ch_printf( ch, "You now speak in %s.\r\n", language_table[lang].name );
+ }
+
+ return;
}
/*
@@ -1852,3 +1726,301 @@ bool is_same_group( const CHAR_DATA *ach
bch = bch->leader;
return ach == bch;
}
+
+const char *slur_words(const char *speech, int cond_drunk)
+{
+ static char buf[MAX_INPUT_LENGTH];
+ char temp0, temp1;
+ int inlength = strlen(speech);
+ int outpos = 0;
+ int i, idx, randomnum;
+
+
+ for( i=0; i<inlength; i++ )
+ {
+ temp0 = UPPER(speech[i]);
+ if(temp0 >= 'A' && temp0 <= 'Z')
+ {
+ temp1 = temp0 - 'A';
+ idx = temp1;
+ if(cond_drunk > drunken_slur_table[idx].min_drunk)
+ {
+ randomnum = number_range( 0, drunken_slur_table[idx].rep_count);
+ strcpy(&buf[outpos], drunken_slur_table[idx].replacement[randomnum]);
+ outpos += strlen(drunken_slur_table[idx].replacement[randomnum]);
+ }
+ else
+ {
+ buf[outpos] = speech[i];
+ outpos++;
+ }
+
+ }
+ else if(temp0 >= '0' && temp0 <= '9')
+ {
+ if(cond_drunk > 4)
+ {
+ temp1 = '0' + number_range(0, 9);
+ buf[outpos] = temp1;
+ outpos++;
+ }
+ else
+ {
+ buf[outpos] = speech[i];
+ outpos++;
+ }
+ }
+ else
+ {
+ buf[outpos] = speech[i];
+ outpos++;
+
+ }
+
+ }
+
+ buf[outpos] = '\0'; /* Mark end of the string... */
+ return ( char * )buf;
+}
+
+const char *language_convert(const char *speech, CHAR_DATA *ch, CHAR_DATA *vch)
+{
+ static char buf[MAX_INPUT_LENGTH];
+ char word[MAX_STRING_LENGTH];
+ int lang;
+ int inlength = strlen(speech);
+ int outpos = 0;
+ int i, j, k, l, m;
+ int chance, comprehension, sn;
+ int len, len_sub;
+ bool word_translated, word_matched;
+ bool full_caps;
+ buf[outpos] = '\0';
+ word[0] = '\0';
+
+ if ( ch == NULL || vch == NULL )
+ {
+ log_error("NULL character data sent to %s.", __FUNCTION__ );
+ return "";
+ }
+
+ lang = ch->speaking;
+
+ if ( lang < LANG_COMMON || lang > LANG_UNKNOWN )
+ {
+ log_error("Invalid language %i passed to language_convert.", lang);
+ return "";
+ }
+
+ if ( lang == LANG_COMMON )
+ {
+ strcpy( buf, speech );
+ return buf;
+ }
+
+ sprintf( word, "%s comprehension", language_table[language_lookup( ch->speaking )].name );
+
+ if ( ( sn = skill_lookup( word ) ) == -1 )
+ {
+ log_error( "Can't find the \"%s\" skill in %s?", word, __FUNCTION__ );
+ return "";
+ }
+
+ comprehension = get_skill( vch, sn );
+
+ chance = comprehension + 7;
+
+ for( i = 0, j = 0; i <= inlength; i++ )
+ {
+ if( LOWER(speech[i]) >= 'a' && LOWER(speech[i]) <= 'z' )
+ {
+ word[j] = speech[i];
+ j++;
+
+ }
+ else
+ {
+
+ word[j] = '\0';
+ word_translated = chance < number_percent( );
+ check_improve( vch, sn, !word_translated, 2 );
+
+ if ( strlen( word ) > 0 )
+ {
+ if ( !word_translated )
+ {
+ strcat( buf, word );
+ outpos += strlen( word );
+ }
+ else
+ {
+ word_matched = false;
+ for ( k = 0; lang_word_table[lang][k].word != NULL; k++ )
+ {
+ if ( LOWER( word[0] ) == lang_word_table[lang][k].word[0]
+ && !str_cmp( word, lang_word_table[lang][k].word) )
+ {
+ word_matched = true;
+
+ if ( word[0] == UPPER( word[0] ) )
+ {
+ len = strlen( word );
+ for ( full_caps = true, l = 0; l < len; l++ )
+ {
+ if ( word[l] != UPPER ( word[l] ) )
+ full_caps = false;
+ }
+
+ strcpy( word, lang_word_table[lang][k].foreign_word );
+
+ if ( full_caps )
+ {
+ len = strlen( word );
+ for ( l = 0; l < len; l++ )
+ {
+ word[l] = UPPER( word[l] );
+ }
+ }
+ else
+ {
+ word[0] = UPPER( word[0] );
+ }
+
+ strcat( buf, word );
+ }
+ else
+ {
+ strcat( buf, lang_word_table[lang][k].foreign_word );
+ }
+ outpos += strlen( lang_word_table[lang][k].foreign_word );
+ break;
+ }
+ }
+
+ if ( !word_matched )
+ {
+ len = strlen( word );
+ for ( k = 0; k < len; k++ )
+ {
+ for ( l = 0; lang_letter_table[lang][l].letter != NULL; l++ )
+ {
+ if ( LOWER( word[k] ) == lang_letter_table[lang][l].letter[0] )
+ {
+ strcat( buf, lang_letter_table[lang][l].foreign_letter );
+ if ( word[k] == UPPER( word[k] ) )
+ {
+ len_sub = strlen ( lang_letter_table[lang][l].foreign_letter );
+ if ( len_sub > 1 && ( word[k + 1] == UPPER( word[k + 1] )
+ || word[k + 1] == '\0' ) )
+ {
+ for( m = 0; m < len_sub; m++ )
+ {
+ buf[outpos + m] = UPPER( buf[outpos + m] );
+ }
+ }
+ else
+ {
+ buf[outpos] = UPPER( buf[outpos] );
+ }
+ }
+ outpos += strlen( lang_letter_table[lang][l].foreign_letter );
+ break;
+ }
+ }
+ }
+ }
+ }
+ j = 0;
+
+ }
+
+ buf[outpos] = speech[i];
+ outpos++;
+ buf[outpos] = '\0'; /* strcat needs this */
+
+ }
+ }
+
+ buf[outpos] = '\0'; /* Mark end of the string... */
+ return ( char * )buf;
+}
+
+
+void channel_speech(int channel, CHAR_DATA *ch, const char *argument, CHAR_DATA *vch)
+{
+ char buf[MAX_INPUT_LENGTH] = "\0\0\0\0\0\0\0";
+ DESCRIPTOR_DATA *d = NULL;
+ bool receipt = false;
+ int chanidx = channel_lookup( channel );
+
+ if ( channel == CHAN_TELL || channel == CHAN_REPLY )
+ {
+ if ( vch == NULL )
+ {
+ log_error( "NULL victim char passed to channel_speech with channel = %i", channel );
+ return;
+ }
+ strcpy( buf, vch->name );
+ strcat( buf, " ");
+ buf[0] = UPPER( buf[0] );
+ }
+
+ ch_printf( ch, "You %s %s'%s'\r\n",
+ channel_table[chanidx].outgoing_verb, buf,
+ slur_words( argument, ch->pcdata->condition[COND_DRUNK] ) );
+
+
+ for ( d = descriptor_list; d != NULL; d = d->next )
+ {
+ CHAR_DATA *victim;
+
+ if ( channel == CHAN_TELL || channel == CHAN_REPLY )
+ victim = vch;
+ else
+ victim = d->original ? d->original : d->character;
+
+ receipt = d->connected == CON_PLAYING && victim != ch;
+
+ /* Immortals speak through all blocking flags */
+ if ( channel_table[chanidx].blocking_flag != -1 )
+ receipt = receipt && ( !IS_SET( victim->comm,
+ channel_table[chanidx].blocking_flag)
+ || IS_IMMORTAL(ch) );
+
+ if ( channel != CHAN_WIZ && channel != CHAN_SAY && channel != CHAN_GROUP )
+ receipt = receipt && ( !IS_SET( victim->comm, COMM_QUIET )
+ || IS_IMMORTAL(ch) );
+
+
+ if ( channel == CHAN_CLAN )
+ receipt = receipt && is_same_clan( ch, victim );
+ else if ( channel == CHAN_GROUP )
+ receipt = receipt && is_same_group( victim, ch );
+ else if ( channel == CHAN_YELL )
+ receipt = receipt && victim->in_room != NULL
+ && victim->in_room->area == ch->in_room->area;
+ else if ( channel == CHAN_WIZ )
+ receipt = receipt && IS_IMMORTAL( victim );
+ else if ( channel == CHAN_SAY )
+ receipt = receipt && victim->in_room != NULL
+ && victim->in_room == ch->in_room;
+ else if ( channel == CHAN_TELL || channel == CHAN_REPLY )
+ receipt = true; /* victim already located */
+
+ if ( receipt )
+ {
+
+ act_printf( "$n %s '$t'", ch,
+ slur_words( language_convert(argument, ch, victim),
+ ch->pcdata->condition[COND_DRUNK] ),
+ victim, TO_VICT, channel_table[chanidx].min_pos, false,
+ channel_table[chanidx].incoming_verb );
+
+
+
+ if ( channel == CHAN_TELL || channel == CHAN_REPLY )
+ return;
+ }
+ }
+
+}
diff -upN ./SVN_Comp01/Fire/src/act.h ./SVN_Comp/Fire/src/act.h
--- ./SVN_Comp01/Fire/src/act.h 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/act.h 2009-01-09 17:14:09.000000000 -0500
@@ -55,6 +55,8 @@ void stop_follower( C
void nuke_pets( CHAR_DATA *ch );
void die_follower( CHAR_DATA *ch );
bool is_same_group( const CHAR_DATA *ach, const CHAR_DATA *bch );
+void channel_speech( int channel, CHAR_DATA *ch, const char *argument,
+ CHAR_DATA *vch );
/* act_info.c */
char *format_obj_to_char( OBJ_DATA *obj, CHAR_DATA *ch, bool fShort );
diff -upN ./SVN_Comp01/Fire/src/act_info.c ./SVN_Comp/Fire/src/act_info.c
--- ./SVN_Comp01/Fire/src/act_info.c 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/act_info.c 2009-01-11 02:02:44.000000000 -0500
@@ -1578,6 +1578,9 @@ void do_score( CHAR_DATA *ch, const char
else
ch_printf( ch, "satanic.\r\n" );
+ ch_printf( ch, "You speak in %s.\r\n",
+ language_table[language_lookup(ch->speaking)].name );
+
if ( IS_SET( ch->comm, COMM_SHOW_AFFECTS ) )
do_function( ch, &do_affects, "" );
}
diff -upN ./SVN_Comp01/Fire/src/act_wiz.c ./SVN_Comp/Fire/src/act_wiz.c
--- ./SVN_Comp01/Fire/src/act_wiz.c 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/act_wiz.c 2009-01-09 17:14:09.000000000 -0500
@@ -3145,7 +3145,7 @@ void do_mset( CHAR_DATA *ch, const char
ch_printf( ch, " str int wis dex con sex class level\r\n" );
ch_printf( ch, " race group gold silver hp mana move prac\r\n" );
ch_printf( ch, " align train thirst hunger drunk full\r\n" );
- ch_printf( ch, " security\r\n" );
+ ch_printf( ch, " security speaking\r\n" );
return;
}
@@ -3513,6 +3513,30 @@ void do_mset( CHAR_DATA *ch, const char
return;
}
+ if ( !str_cmp( arg2, "speaking" ) ) /* language */
+ {
+ if ( IS_NPC( ch ) )
+ {
+ ch_printf( ch, "Yeah, sure.\r\n" );
+ return;
+ }
+
+ if ( IS_NPC( victim ) )
+ {
+ ch_printf( ch, "Not on NPC's.\r\n" );
+ return;
+ }
+
+ if ( value < LANG_COMMON || value > LANG_UNKNOWN )
+ {
+ ch_printf( ch, "Invalid language.\r\n" );
+ return;
+ }
+
+ victim->speaking = value;
+ return;
+ }
+
/*
* Generate usage message.
*/
diff -upN ./SVN_Comp01/Fire/src/comm.c ./SVN_Comp/Fire/src/comm.c
--- ./SVN_Comp01/Fire/src/comm.c 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/comm.c 2009-01-11 21:59:14.000000000 -0500
@@ -1310,6 +1308,14 @@ void nanny( DESCRIPTOR_DATA *d, const ch
ch->pcdata->points = pc_race_table[race].points;
ch->size = pc_race_table[race].size;
+ /*
+ * add language comprehensions
+ */
+ ch->pcdata->learned[skill_lookup( "common comprehension" )] = 100;
+ sprintf( local_argument, "%s comprehension",
+ language_table[language_lookup( pc_race_table[race].lang )].name);
+ ch->pcdata->learned[skill_lookup( local_argument )] = 100;
+
desc_printf( d, "What is your sex (M/F)? " );
d->connected = CON_GET_NEW_SEX;
break;
@@ -2312,8 +2318,6 @@ void act_printf( const char *format, CHA
continue;
if ( to->position < min_pos )
continue;
- if ( !IS_AWAKE( to ) )
- continue;
if ( !can_see( to, ch ) && hide_invis )
continue;
if ( type == TO_CHAR && to != ch )
diff -upN ./SVN_Comp01/Fire/src/interp.c ./SVN_Comp/Fire/src/interp.c
--- ./SVN_Comp01/Fire/src/interp.c 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/interp.c 2009-01-11 02:02:47.000000000 -0500
@@ -195,6 +195,7 @@ const struct cmd_type cmd_table[] = {
{"shout", do_shout, POS_RESTING, 3, LOG_NORMAL, 1},
{"unread", do_unread, POS_SLEEPING, 0, LOG_NORMAL, 1},
{"yell", do_yell, POS_RESTING, 0, LOG_NORMAL, 1},
+ {"speak", do_speak, POS_SLEEPING, 0, LOG_NORMAL, 1},
/*
* Object manipulation commands.
diff -upN ./SVN_Comp01/Fire/src/interp.h ./SVN_Comp/Fire/src/interp.h
--- ./SVN_Comp01/Fire/src/interp.h 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/interp.h 2009-01-11 01:30:04.000000000 -0500
@@ -117,6 +117,7 @@ void do_order( CHAR_D
void do_group( CHAR_DATA *ch, const char *argument );
void do_split( CHAR_DATA *ch, const char *argument );
void do_gtell( CHAR_DATA *ch, const char *argument );
+void do_speak( CHAR_DATA *ch, const char *argument );
/* act_info.c */
void do_scroll( CHAR_DATA *ch, const char *argument );
diff -upN ./SVN_Comp01/Fire/src/merc.h ./SVN_Comp/Fire/src/merc.h
--- ./SVN_Comp01/Fire/src/merc.h 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/merc.h 2009-01-11 21:49:37.000000000 -0500
@@ -115,6 +116,7 @@ typedef void SPELL_FUN ( int sn, int le
#define MAX_ALIAS 5
#define MAX_CLASS 4
#define MAX_PC_RACE 5
+#define MAX_LANG_WORDS 512
#define MAX_CLAN 3
#define MAX_DAMAGE_MESSAGE 41
#define MAX_LEVEL 60
@@ -177,6 +199,33 @@ struct weather_data
};
/*
+ * Channel types.
+ */
+#define CHAN_GOSSIP 0
+#define CHAN_AUCTION 1
+#define CHAN_QUESTION 2
+#define CHAN_ANSWER 3
+#define CHAN_QUOTE 4
+#define CHAN_GRATS 5
+#define CHAN_WIZ 6
+#define CHAN_SHOUT 7
+#define CHAN_TELL 8
+#define CHAN_REPLY 9
+#define CHAN_SAY 10
+#define CHAN_GROUP 11
+#define CHAN_CLAN 12
+#define CHAN_YELL 13
+
+/*
+ * Languages. LANG_COMMON must be first, and LANG_UNKNOWN last.
+ */
+#define LANG_COMMON 0
+#define LANG_ELVEN 1
+#define LANG_DWARVEN 2
+#define LANG_GIANT 3
+#define LANG_UNKNOWN 4
+
+/*
* Connected state for a channel.
*/
#define CON_PLAYING 0
@@ -385,6 +434,7 @@ struct pc_race_type
int stats[MAX_STATS]; /* starting stats */
int max_stats[MAX_STATS]; /* maximum stats */
int size; /* aff bits for the race */
+ int lang; /* default language for race */
};
/*
@@ -1349,6 +1399,7 @@ struct char_data
int sex;
int iclass;
int race;
+ int speaking; /* current language */
int level;
int trust;
int played;
@@ -1883,6 +1934,16 @@ struct social_type
};
/*
+ * Drunk struct
+ */
+struct drunken_slur_type
+{
+ int min_drunk;
+ int rep_count;
+ const char *replacement[11];
+};
+
+/*
* We've switched from crypt() to sha256_crypt() to avoid
* issues with some systems having crypt, and others not having
* it. Rather than fight silly US export laws, we'll just use
diff -upN ./SVN_Comp01/Fire/src/tables.c ./SVN_Comp/Fire/src/tables.c
--- ./SVN_Comp01/Fire/src/tables.c 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/tables.c 2009-01-11 21:59:06.000000000 -0500
@@ -65,6 +65,447 @@ const struct clan_type clan_table[MAX_C
{"rom", "[ ROM ] ", ROOM_VNUM_ALTAR, false}
};
+/* for channels */
+const struct channel_type channel_table[] = {
+/* channel, outgoing, incoming, min position, blocking flag */
+ {CHAN_GOSSIP, "gossip", "gossip", "gossips", POS_SLEEPING, COMM_NOGOSSIP},
+ {CHAN_AUCTION, "auction", "auction", "auctions", POS_DEAD, COMM_NOAUCTION},
+ {CHAN_QUESTION, "question", "question", "questions", POS_SLEEPING, COMM_NOQUESTION},
+ {CHAN_ANSWER, "answer", "answer", "answers", POS_SLEEPING, COMM_NOQUESTION},
+ {CHAN_QUOTE, "quote", "quote", "quotes", POS_SLEEPING, COMM_NOQUOTE},
+ {CHAN_GRATS, "grats", "grats", "grats", POS_SLEEPING, COMM_NOGRATS},
+ {CHAN_WIZ, "immtell", "godspeak", "godspeaks", POS_DEAD, COMM_NOWIZ},
+ {CHAN_SHOUT, "shout", "shout", "shouts", POS_RESTING, COMM_SHOUTSOFF},
+ {CHAN_TELL, "tell", "tell", "tells you", POS_DEAD, COMM_DEAF},
+ {CHAN_REPLY, "reply", "tell", "tells you", POS_DEAD, COMM_DEAF},
+ {CHAN_SAY, "say", "say", "says", POS_RESTING, -1},
+ {CHAN_GROUP, "gtell", "tell your group", "tells the group", POS_SLEEPING, -1},
+ {CHAN_CLAN, "clan", "clan", "clans", POS_DEAD, COMM_NOCLAN},
+ {CHAN_YELL, "yell", "yell", "yells", POS_RESTING, -1},
+ {0, NULL, NULL, NULL, 0, -1}
+};
+
+const struct lang_word_type lang_word_table[LANG_UNKNOWN][MAX_LANG_WORDS] = {
+ {
+ {NULL, NULL}
+ },
+
+ {
+ {"above", "ar"},
+ {"adamantine", "atamar"},
+ {"after", "deshu"},
+ {"air", "drii"},
+ {"ale", "irasku"},
+ {"and", "ent"},
+ {"animal", "tarine"},
+ {"armor", "hithar"},
+ {"arrow", "elandi"},
+ {"axe", "shaalth"},
+ {"bag", "esk"},
+ {"battle", "enyor"},
+ {"beautiful", "lani"},
+ {"before", "kesha"},
+ {"behind", "lothos"},
+ {"below", "saaden"},
+ {"beside", "ausa"},
+ {"big", "ary"},
+ {"black", "cerlyn"},
+ {"blossom", "ilphu"},
+ {"blue", "tha"},
+ {"bow", "athel"},
+ {"branch", "kathan"},
+ {"bread", "kulaa"},
+ {"breeze", "nai"},
+ {"bribe", "kukisha"},
+ {"brook", "sain"},
+ {"but", "ieha"},
+ {"cave", "sanerek"},
+ {"celestial", "surinya"},
+ {"city", "benerel"},
+ {"cleric", "surnar"},
+ {"clothing", "tenya"},
+ {"courage", "arranaseer"},
+ {"bravery", "arranaseer"},
+ {"cowardice", "reloseer"},
+ {"dance", "quar"},
+ {"danger", "daquin"},
+ {"dark", "nevae"},
+ {"darkvision", "nevaedarn"},
+ {"day", "noresh"},
+ {"deity", "arsurinya"},
+ {"demon", "karask"},
+ {"dew", "holi"},
+ {"diamond", "mion"},
+ {"die", "mor"},
+ {"dragon", "hakarmaskannar"},
+ {"dwarf", "erkatam"},
+ {"earth", "erek"},
+ {"elf", "kesir"},
+ {"enemy", "hakar"},
+ {"evil", "vaarn"},
+ {"far", "noarun"},
+ {"few", "ennamar"},
+ {"fire", "maskan"},
+ {"flee", "sekkar"},
+ {"flower", "ama"},
+ {"food", "klatha"},
+ {"for", "nesh"},
+ {"forest", "ravan"},
+ {"friend", "revanthas"},
+ {"frond", "lia"},
+ {"gem", "kiir"},
+ {"give", "yewl"},
+ {"gnome", "sharatam"},
+ {"go", "shan"},
+ {"gold", "scient"},
+ {"good", "thar"},
+ {"green", "chas"},
+ {"halfling", "sherekir"},
+ {"hate", "drag"},
+ {"heal", "faenya"},
+ {"heel", "meli"},
+ {"home", "enial"},
+ {"horse", "heriryar"},
+ {"human", "bhen"},
+ {"in", "aul"},
+ {"inn", "scennal"},
+ {"iron", "mault"},
+ {"king", "cor"},
+ {"leather", "anharad"},
+ {"light", "lvae"},
+ {"luck", "staleen"},
+ {"magic", "lerret"},
+ {"many", "rell"},
+ {"meat", "klathmor"},
+ {"mithral", "mithral"},
+ {"mithril", "mithril"},
+ {"moon", "nodel"},
+ {"mountain", "silath"},
+ {"name", "lahr"},
+ {"near", "tham"},
+ {"night", "lo"},
+ {"no", "neh"},
+ {"nor", "nars"},
+ {"oak", "amne"},
+ {"on", "arta"},
+ {"one", "enna"},
+ {"or", "quin"},
+ {"orc", "hakavarn"},
+ {"peace", "adon"},
+ {"petal", "xilo"},
+ {"rain", "alushtasa"},
+ {"red", "harsan"},
+ {"rest", "revar"},
+ {"rope", "jharren"},
+ {"scroll", "lersaat"},
+ {"silver", "don"},
+ {"small", "sarash"},
+ {"smart", "kekuel"},
+ {"so", "desha"},
+ {"song", "hinue"},
+ {"soul", "quarlani"},
+ {"speak", "hinual"},
+ {"star", "stacia"},
+ {"steel", "maskaulat"},
+ {"stone", "diir"},
+ {"stop", "neshanas"},
+ {"stupid", "kessuk"},
+ {"sword", "kerym"},
+ {"take", "teshuel"},
+ {"theif", "leshere"},
+ {"through", "eshaal"},
+ {"to", "nae"},
+ {"tomb", "morenial"},
+ {"tomorrow", "belath"},
+ {"travel", "sehan"},
+ {"tree", "lath"},
+ {"true", "avae"},
+ {"ugly", "biir"},
+ {"undead", "mormhaor"},
+ {"under", "ernath"},
+ {"war", "keryth"},
+ {"water", "alus"},
+ {"we", "quen"},
+ {"weapon", "kerymeth"},
+ {"whisper", "gala"},
+ {"white", "ivae"},
+ {"wine", "iasa"},
+ {"with", "faer"},
+ {"wood", "rilis"},
+ {"year", "ashanelath"},
+ {"yellow", "thuen"},
+ {"yes", "avavaen"},
+ {"yet", "aeleth"},
+ {"you", "nehel"},
+ {"midgaard", "midgaard"},
+ {"thalos", "thalos"},
+ {"ofcol", "ofcol"},
+ {"mota", "mota"},
+ {NULL, NULL}
+ },
+
+ {
+ {"behind", "abat"},
+ {"yet", "aglot"},
+ {"air", "alf"},
+ {"silver", "ang"},
+ {"mithral", "angdor"},
+ {"chest", "argul"},
+ {"water", "aun"},
+ {"gold", "aur"},
+ {"ale", "auraun"},
+ {"inn", "aurdrukar"},
+ {"night", "azan"},
+ {"you", "bak"},
+ {"red", "bar"},
+ {"above", "bel"},
+ {"demon", "braut"},
+ {"celestial", "darsam"},
+ {"mustard", "deg"},
+ {"spice", "deg"},
+ {"strong", "dek"},
+ {"evil", "der"},
+ {"on", "dews"},
+ {"near", "dog"},
+ {"beside", "dogos"},
+ {"iron", "dor"},
+ {"anvil", "dormark"},
+ {"king", "dornar"},
+ {"city", "drukafaren"},
+ {"home", "drukar"},
+ {"smart", "dug"},
+ {"shield", "dur"},
+ {"dragon", "durgarn"},
+ {"dwarf", "dwar"},
+ {"clan", "dwarkar"},
+ {"hammer", "ews"},
+ {"big", "far"},
+ {"rope", "farl"},
+ {"year", "farrenglos"},
+ {"scroll", "flos"},
+ {"leather", "frul"},
+ {"horse", "frulbraut"},
+ {"animal", "frus"},
+ {"battle", "ged"},
+ {"peace", "gelm"},
+ {"danger", "gend"},
+ {"day", "glos"},
+ {"after", "glot"},
+ {"gnome", "gnur"},
+ {"go", "gos"},
+ {"meat", "gost"},
+ {"poison", "gren"},
+ {"beard", "grim"},
+ {"steel", "grum"},
+ {"adamantine", "grumdek"},
+ {"good", "gul"},
+ {"luck", "gullend"},
+ {"heal", "gulm"},
+ {"call", "gund"},
+ {"green", "gurn"},
+ {"tree", "gurnvos"},
+ {"forest", "gurnvosen"},
+ {"halfling", "heng"},
+ {"to", "her"},
+ {"travel", "hergos"},
+ {"through", "hermot"},
+ {"take", "horlem"},
+ {"cleric", "horm"},
+ {"rain", "hren"},
+ {"few", "hrot"},
+ {"one", "hrun"},
+ {"name", "hrunnar"},
+ {"human", "hurm"},
+ {"giant", "hurmfar"},
+ {"many", "jor"},
+ {"for", "kagel"},
+ {"give", "kaglem"},
+ {"darkvision", "kanazan"},
+ {"far", "kar"},
+ {"scout", "karakan"},
+ {"tomorrow", "karglos"},
+ {"below", "kel"},
+ {"glitter", "khun"},
+ {"bright", "khun"},
+ {"bread", "klar"},
+ {"food", "klos"},
+ {"ugly", "kos"},
+ {"bag", "kurm"},
+ {"enemy", "kurn"},
+ {"war", "kurnzarn"},
+ {"in", "kurs"},
+ {"we", "lar"},
+ {"earth", "lu"},
+ {"black", "mag"},
+ {"undead", "magmornder"},
+ {"true", "mal"},
+ {"mountain", "mar"},
+ {"stop", "marn"},
+ {"rune", "marnak"},
+ {"magic", "marnarn"},
+ {"clothing", "marrur"},
+ {"friend", "mer"},
+ {"under", "mord"},
+ {"die", "morn"},
+ {"tomb", "mornludrukar"},
+ {"no", "mos"},
+ {"but", "mosk"},
+ {"stupid", "mulg"},
+ {"yes", "murg"},
+ {"stone", "nae"},
+ {"cave", "naeborn"},
+ {"bravery", "nar"},
+ {"white", "ney"},
+ {"with", "nos"},
+ {"gem", "nur"},
+ {"sword", "nus"},
+ {"axe", "nyr"},
+ {"armor", "og"},
+ {"elf", "olv"},
+ {"orc", "ork"},
+ {"speak", "rem"},
+ {"song", "remarn"},
+ {"weapon", "ros"},
+ {"spear", "rosh"},
+ {"bow", "tang"},
+ {"arrow", "tanthanus"},
+ {"fire", "tel"},
+ {"forge", "telormar"},
+ {"small", "than"},
+ {"rest", "thanamorn"},
+ {"dance", "thannergos"},
+ {"beautiful", "then"},
+ {"thief", "thos"},
+ {"greed", "thost"},
+ {"before", "toglot"},
+ {"soul", "tor"},
+ {"deity", "torfarn"},
+ {"cowardice", "valdar"},
+ {"flee", "valergos"},
+ {"bribe", "valkag"},
+ {"loyal", "var"},
+ {"so", "vas"},
+ {"and", "vel"},
+ {"nor", "velmos"},
+ {"blue", "vol"},
+ {"wood", "vos"},
+ {"yellow", "yar"},
+ {"midgaard", "midgaard"},
+ {"thalos", "thalos"},
+ {"ofcol", "ofcol"},
+ {"mota", "mota"},
+ {NULL, NULL}
+ },
+
+ {
+ {NULL, NULL}
+ }
+
+};
+
+const struct lang_letter_type lang_letter_table[LANG_UNKNOWN][26] = {
+ /* common */
+ {
+ {"a", "a"},
+ {"b", "b"},
+ {"c", "c"},
+ {"d", "d"},
+ {"e", "e"},
+ {"f", "f"},
+ {"g", "g"},
+ {"h", "h"},
+ {"i", "i"},
+ {"j", "j"},
+ {"k", "k"},
+ {"l", "l"},
+ {"m", "m"},
+ {"n", "n"},
+ {"o", "o"},
+ {"p", "p"},
+ {"q", "q"},
+ {"r", "r"},
+ {"s", "s"},
+ {"t", "t"},
+ {"u", "u"},
+ {"v", "v"},
+ {"w", "w"},
+ {"x", "x"},
+ {"y", "y"},
+ {"z", "z"}
+ },
+ /* elven */
+ {
+ {"a", "il"},
+ {"b", "f"},
+ {"c", "ny"},
+ {"d", "w"},
+ {"e", "a"},
+ {"f", "o"},
+ {"g", "v"},
+ {"h", "ir"},
+ {"i", "e"},
+ {"j", "qu"},
+ {"k", "n"},
+ {"l", "c"},
+ {"m", "s"},
+ {"n", "l"},
+ {"o", "e"},
+ {"p", "ty"},
+ {"q", "h"},
+ {"r", "m"},
+ {"s", "la"},
+ {"t", "an"},
+ {"u", "y"},
+ {"v", "el"},
+ {"w", "am"},
+ {"x", "'"},
+ {"y", "a"},
+ {"z", "j"}
+ },
+ /* dwarven */
+ {
+ {"a", "az"},
+ {"b", "po"},
+ {"c", "zi"},
+ {"d", "t"},
+ {"e", "a"},
+ {"f", "wa"},
+ {"g", "k"},
+ {"h", "'"},
+ {"i", "a"},
+ {"j", "dr"},
+ {"k", "g"},
+ {"l", "n"},
+ {"m", "l"},
+ {"n", "r"},
+ {"o", "ur"},
+ {"p", "rh"},
+ {"q", "k"},
+ {"r", "h"},
+ {"s", "th"},
+ {"t", "k"},
+ {"u", "'"},
+ {"v", "g"},
+ {"w", "zh"},
+ {"x", "q"},
+ {"y", "o"},
+ {"z", "j"}
+ },
+
+ {
+ {NULL, NULL}
+ }
+};
+
+const struct language_type language_table[] = {
+ {LANG_COMMON, "common"},
+ {LANG_ELVEN, "elven"},
+ {LANG_DWARVEN, "dwarven"},
+ {LANG_GIANT, "giant"},
+ {LANG_UNKNOWN, "unknown"},
+ {-1, NULL}
+};
+
/* for position */
const struct position_type position_table[] = {
{"dead", "dead"},
@@ -641,22 +1082,22 @@ const struct pc_race_type pc_race_table[
{
"human", "Human", 0, {100, 100, 100, 100},
{""},
- {13, 13, 13, 13, 13}, {18, 18, 18, 18, 18}, SIZE_MEDIUM},
+ {13, 13, 13, 13, 13}, {18, 18, 18, 18, 18}, SIZE_MEDIUM, LANG_COMMON},
{
"elf", " Elf ", 5, {100, 125, 100, 120},
{"sneak", "hide"},
- {12, 14, 13, 15, 11}, {16, 20, 18, 21, 15}, SIZE_SMALL},
+ {12, 14, 13, 15, 11}, {16, 20, 18, 21, 15}, SIZE_SMALL, LANG_ELVEN},
{
"dwarf", "Dwarf", 8, {150, 100, 125, 100},
{"berserk"},
- {14, 12, 14, 10, 15}, {20, 16, 19, 14, 21}, SIZE_MEDIUM},
+ {14, 12, 14, 10, 15}, {20, 16, 19, 14, 21}, SIZE_MEDIUM, LANG_DWARVEN},
{
"giant", "Giant", 6, {200, 150, 150, 105},
{"bash", "fast healing"},
- {16, 11, 13, 11, 14}, {22, 15, 18, 15, 20}, SIZE_LARGE}
+ {16, 11, 13, 11, 14}, {22, 15, 18, 15, 20}, SIZE_LARGE, LANG_GIANT}
};
/*
@@ -1189,6 +1630,64 @@ const struct liq_type liq_table[] = {
{NULL, NULL, {0, 0, 0, 0, 0}}
};
+const struct drunken_slur_type drunken_slur_table[] =
+ {
+ {3, 10,
+ {"a", "a", "a", "A", "aa", "ah", "Ah", "ao", "aw", "oa", "ahhhh"}},
+ {8, 5,
+ {"b", "b", "b", "B", "B", "vb"}},
+ {3, 5,
+ {"c", "c", "C", "cj", "sj", "zj"}},
+ {5, 2,
+ {"d", "d", "D"}},
+ {3, 3,
+ {"e", "e", "eh", "E"}},
+ {4, 5,
+ {"f", "f", "ff", "fff", "fFf", "F"}},
+ {8, 2,
+ {"g", "g", "G"}},
+ {9, 6,
+ {"h", "h", "hh", "hhh", "Hhh", "HhH", "H"}},
+ {7, 6,
+ {"i", "i", "Iii", "ii", "iI", "Ii", "I"}},
+ {9, 5,
+ {"j", "j", "jj", "Jj", "jJ", "J"}},
+ {7, 2,
+ {"k", "k", "K"}},
+ {3, 2,
+ {"l", "l", "L"}},
+ {5, 8,
+ {"m", "m", "mm", "mmm", "mmmm", "mmmmm", "MmM", "mM", "M"}},
+ {6, 6,
+ {"n", "n", "nn", "Nn", "nnn", "nNn", "N"}},
+ {3, 6,
+ {"o", "o", "ooo", "ao", "aOoo", "Ooo", "ooOo"}},
+ {3, 2,
+ {"p", "p", "P"}},
+ {5, 5,
+ {"q", "q", "Q", "ku", "ququ", "kukeleku"}},
+ {4, 2,
+ {"r", "r", "R"}},
+ {2, 5,
+ {"s", "ss", "zzZzssZ", "ZSssS", "sSzzsss", "sSss"}},
+ {5, 2,
+ {"t", "t", "T"}},
+ {3, 6,
+ {"u", "u", "uh", "Uh", "Uhuhhuh", "uhU", "uhhu"}},
+ {4, 2,
+ {"v", "v", "V"}},
+ {4, 2,
+ {"w", "w", "W"}},
+ {5, 6,
+ {"x", "x", "X", "ks", "iks", "kz", "xz"}},
+ {3, 2,
+ {"y", "y", "Y"}},
+ {2, 9,
+ {"z", "z", "ZzzZz", "Zzz", "Zsszzsz", "szz", "sZZz", "ZSz", "zZ", "Z"}},
+ {0, 0, {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}}
+ };
+
+
/*
* The skill and spell table.
* Slot numbers must never be changed as they appear in #OBJECTS sections.
@@ -2022,12 +2528,37 @@ struct skill_type skill_table[MAX_
spell_null, TAR_IGNORE, POS_STANDING,
NULL, SLOT( 133 ), 0, 12,
"", "!Wands!", ""},
-
{
"recall", {1, 1, 1, 1}, {2, 2, 2, 2},
spell_null, TAR_IGNORE, POS_STANDING,
NULL, SLOT( 134 ), 0, 12,
- "", "!Recall!", ""}
+ "", "!Recall!", ""},
+
+ {
+ "common comprehension", {1, 1, 1, 1}, {3, 3, 4, 4},
+ spell_null, TAR_IGNORE, POS_SLEEPING,
+ NULL, SLOT( 135 ), 0, 0,
+ "", "!Common Comprehension!", ""},
+
+ {
+ "elven comprehension", {1, 1, 1, 1}, {3, 3, 4, 4},
+ spell_null, TAR_IGNORE, POS_SLEEPING,
+ NULL, SLOT( 136 ), 0, 0,
+ "", "!Elven Comprehension!", ""},
+
+ {
+ "dwarven comprehension", {1, 1, 1, 1}, {3, 3, 5, 5},
+ spell_null, TAR_IGNORE, POS_SLEEPING,
+ NULL, SLOT( 137 ), 0, 0,
+ "", "!Dwarven Comprehension!", ""},
+
+ {
+ "giant comprehension", {1, 1, 1, 1}, {3, 3, 5, 5},
+ spell_null, TAR_IGNORE, POS_SLEEPING,
+ NULL, SLOT( 138 ), 0, 0,
+ "", "!Giant Comprehension!", ""},
+
+
};
const struct group_type group_table[MAX_GROUP] = {
@@ -2899,6 +3430,61 @@ int clan_lookup( const char *name )
return 0;
}
+int channel_lookup( int channel )
+{
+ int chanidx = 0;
+
+ for ( chanidx = 0; channel_table[chanidx].name != NULL; chanidx++ )
+ {
+ if ( channel == channel_table[chanidx].channel )
+ return chanidx;
+ }
+
+ return -1;
+}
+
+int channel_lookup( const char *name )
+{
+ int chanidx = 0;
+
+ for ( chanidx = 0; channel_table[chanidx].name != NULL; chanidx++ )
+ {
+ if ( LOWER( name[0] ) == LOWER( channel_table[chanidx].name[0] )
+ && !str_prefix( name, channel_table[chanidx].name ) )
+ return chanidx;
+ }
+
+ return -1;
+}
+
+int language_lookup( int language )
+{
+ int langidx = 0;
+
+ for ( langidx = 0; language_table[langidx].name != NULL; langidx++ )
+ {
+ if ( language == language_table[langidx].language )
+ return langidx;
+ }
+
+ return -1;
+}
+
+int language_lookup( const char *name )
+{
+ int langidx = 0;
+
+ for ( langidx = 0; language_table[langidx].name != NULL; langidx++ )
+ {
+ if ( LOWER( name[0] ) == LOWER( language_table[langidx].name[0] )
+ && !str_prefix( name, language_table[langidx].name ) )
+ return langidx;
+ }
+
+ return -1;
+}
+
+
int position_lookup( const char *name )
{
int pos = 0;
diff -upN ./SVN_Comp01/Fire/src/tables.h ./SVN_Comp/Fire/src/tables.h
--- ./SVN_Comp01/Fire/src/tables.h 2009-01-11 23:13:16.000000000 -0500
+++ ./SVN_Comp/Fire/src/tables.h 2009-01-11 02:05:48.000000000 -0500
@@ -44,6 +44,34 @@ struct clan_type
bool independent; /* true for loners */
};
+struct channel_type
+{
+ int channel; // CHAN_ defines in merc.h
+ const char *name;
+ const char *outgoing_verb;
+ const char *incoming_verb;
+ int min_pos;
+ int blocking_flag;
+};
+
+struct lang_word_type
+{
+ const char *word;
+ const char *foreign_word;
+};
+
+struct lang_letter_type
+{
+ const char *letter;
+ const char *foreign_letter;
+};
+
+struct language_type
+{
+ int language;
+ const char *name;
+};
+
struct position_type
{
const char *name;
@@ -74,6 +102,8 @@ struct bit_type
/* game tables */
extern const struct clan_type clan_table[MAX_CLAN];
+extern const struct channel_type channel_table[];
+extern const struct language_type language_table[];
extern const struct position_type position_table[];
extern const struct sex_type sex_table[];
extern const struct size_type size_table[];
@@ -116,6 +146,9 @@ extern const struct liq_type liq_table[]
extern struct skill_type skill_table[MAX_SKILL];
extern const struct group_type group_table[MAX_GROUP];
extern const char *title_table[MAX_CLASS][MAX_LEVEL + 1][2];
+extern const struct drunken_slur_type drunken_slur_table[];
+extern const struct lang_word_type lang_word_table[LANG_UNKNOWN][MAX_LANG_WORDS];
+extern const struct lang_letter_type lang_letter_table[LANG_UNKNOWN][26];
/* This is for OLC */
extern const struct flag_stat_type flag_stat_table[];
@@ -142,6 +175,10 @@ extern const struct bit_type bitvector_t
int flag_lookup( const char *name,
const struct flag_type *flag_table );
int clan_lookup( const char *name );
+int channel_lookup( int channel );
+int channel_lookup( const char *name );
+int language_lookup( int language );
+int language_lookup( const char *name );
int position_lookup( const char *name );
int sex_lookup( const char *name );
int size_lookup( const char *name );