bool spec_auth( CHAR_DATA * ch )
{
CHAR_DATA *victim = NULL;
CHAR_DATA *v_next = NULL;
char buf[MAX_STRING_LENGTH];
for( victim = ch->in_room->first_person; victim; victim = v_next )
{
v_next = victim->next_in_room;
if( IS_NPC( victim )
|| !IS_SET( victim->pcdata->flags, PCFLAG_UNAUTHED ) )
continue;
victim->pcdata->auth_state = 3;
REMOVE_BIT( victim->pcdata->flags, PCFLAG_UNAUTHED );
if( victim->pcdata->authed_by )
STRFREE( victim->pcdata->authed_by );
victim->pcdata->authed_by = QUICKLINK( ch->name );
snprintf( buf, MAX_STRING_LENGTH,
"%s has graduated the academy.", victim->name );
to_channel( buf, CHANNEL_MONITOR, "Monitor", ch->top_level );
if( victim->pcdata->clan )
victim->pcdata->clan->members++;
}
return FALSE;
}
bool spec_auth(CHAR_DATA * ch)
{
CHAR_DATA *victim;
CHAR_DATA *v_next;
char buf[MAX_STRING_LENGTH];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
bool hasdiploma;
for (victim = ch->in_room->first_person; victim; victim = v_next) {
v_next = victim->next_in_room;
if (!IS_NPC(victim)
&& (pObjIndex =
get_obj_index(OBJ_VNUM_SCHOOL_DIPLOMA)) != NULL) {
hasdiploma = FALSE;
for (obj = victim->last_carrying; obj;
obj = obj->prev_content)
if (obj->pIndexData ==
get_obj_index(OBJ_VNUM_SCHOOL_DIPLOMA))
hasdiploma = TRUE;
if (!hasdiploma) {
obj = create_object(pObjIndex, 1);
obj = obj_to_char(obj, victim);
send_to_char
("&cThe schoolmaster gives you a diploma, and shakes your hand.\n\r&w",
victim);
}
}
if (IS_NPC(victim)
|| !IS_SET(victim->pcdata->flags, PCFLAG_UNAUTHED))
continue;
victim->pcdata->auth_state = 3;
REMOVE_BIT(victim->pcdata->flags, PCFLAG_UNAUTHED);
if (victim->pcdata->authed_by)
STRFREE(victim->pcdata->authed_by);
victim->pcdata->authed_by = QUICKLINK(ch->name);
sprintf(buf, "%s authorized %s", ch->name, victim->name);
to_channel(buf, CHANNEL_MONITOR, "Monitor", ch->top_level);
}
return FALSE;
}
void note_attach( CHAR_DATA * ch )
{
NOTE_DATA *pnote = NULL;
if( ch->pnote )
return;
CREATE( pnote, NOTE_DATA, 1 );
pnote->next = NULL;
pnote->prev = NULL;
pnote->sender = QUICKLINK( ch->name );
pnote->date = STRALLOC( "" );
pnote->to_list = STRALLOC( "" );
pnote->subject = STRALLOC( "" );
pnote->text = STRALLOC( "" );
ch->pnote = pnote;
}
void do_chess( CHAR_DATA * ch, const char *argument )
{
char arg[MAX_INPUT_LENGTH];
argument = one_argument( argument, arg );
if ( IS_NPC( ch ) )
{
send_to_char( "NPC's can't be in chess games.\r\n", ch );
return;
}
if ( !str_cmp( arg, "begin" ) )
{
GAME_BOARD_DATA *board;
if ( ch->pcdata->game_board )
{
send_to_char( "You are already in a chess match.\r\n", ch );
return;
}
CREATE( board, GAME_BOARD_DATA, 1 );
init_board( board );
ch->pcdata->game_board = board;
ch->pcdata->game_board->player1 = QUICKLINK( ch->name );
send_to_char( "You have started a game of chess.\r\n", ch );
return;
}
if ( !str_cmp( arg, "join" ) )
{
GAME_BOARD_DATA *board = NULL;
CHAR_DATA *vch;
char arg2[MAX_INPUT_LENGTH];
if ( ch->pcdata->game_board )
{
send_to_char( "You are already in a game of chess.\r\n", ch );
return;
}
argument = one_argument( argument, arg2 );
if ( arg2[0] == '\0' )
{
send_to_char( "Join whom in a chess match?\r\n", ch );
return;
}
#ifdef IMC
if ( strstr( arg2, "@" ) )
{
if ( !str_cmp( imc_mudof( arg2 ), this_imcmud->localname ) )
{
send_to_char( "You cannot join IMC chess on the local mud!\r\n", ch );
return;
}
if ( !str_cmp( imc_mudof( arg2 ), "*" ) )
{
send_to_char( "* is not a valid mud name.\r\n", ch );
return;
}
if ( !str_cmp( imc_nameof( arg2 ), "*" ) )
{
send_to_char( "* is not a valid player name.\r\n", ch );
return;
}
send_to_char( "Attempting to initiate IMC chess game...\r\n", ch );
CREATE( board, GAME_BOARD_DATA, 1 );
init_board( board );
board->type = TYPE_IMC;
board->player1 = QUICKLINK( ch->name );
board->player2 = STRALLOC( arg2 );
board->turn = -1;
ch->pcdata->game_board = board;
imc_send_chess( ch->name, arg2, "start" );
return;
}
#endif
if ( !( vch = get_char_world( ch, arg2 ) ) )
{
send_to_char( "Cannot find that player.\r\n", ch );
return;
}
if ( IS_NPC( vch ) )
{
send_to_char( "That player is an NPC, and cannot play games.\r\n", ch );
return;
}
board = vch->pcdata->game_board;
if ( !board )
{
send_to_char( "That player is not playing a game.\r\n", ch );
return;
}
if ( board->player2 )
{
send_to_char( "That game already has two players.\r\n", ch );
return;
}
board->player2 = QUICKLINK( ch->name );
ch->pcdata->game_board = board;
send_to_char( "You have joined a game of chess.\r\n", ch );
vch = get_char_world( ch, board->player1 );
ch_printf( vch, "%s has joined your game.\r\n", ch->name );
return;
}
if ( !ch->pcdata->game_board )
{
send_to_char( "Usage: chess <begin|cease|status|board|move|join>\r\n", ch );
return;
}
if ( !str_cmp( arg, "cease" ) )
{
free_game( ch->pcdata->game_board );
return;
}
if ( !str_cmp( arg, "status" ) )
{
GAME_BOARD_DATA *board = ch->pcdata->game_board;
if ( !board->player1 )
send_to_char( "There is no black player.\r\n", ch );
else if ( !str_cmp( board->player1, ch->name ) )
send_to_char( "You are black.\r\n", ch );
else
ch_printf( ch, "%s is black.\r\n", board->player1 );
if ( king_in_checkmate( board, BLACK_KING ) )
send_to_char( "The black king is in checkmate!\r\n", ch );
else if ( king_in_check( board, BLACK_KING ) )
send_to_char( "The black king is in check.\r\n", ch );
if ( !board->player2 )
send_to_char( "There is no white player.\r\n", ch );
else if ( !str_cmp( board->player2, ch->name ) )
send_to_char( "You are white.\r\n", ch );
else
ch_printf( ch, "%s is white.\r\n", board->player2 );
if ( king_in_checkmate( board, WHITE_KING ) )
send_to_char( "The white king is in checkmate!\r\n", ch );
else if ( king_in_check( board, WHITE_KING ) )
send_to_char( "The white king is in check.\r\n", ch );
if ( !board->player2 || !board->player1 )
return;
ch_printf( ch, "%d turns.\r\n", board->turn );
if ( board->turn % 2 == 1 && !str_cmp( board->player1, ch->name ) )
{
ch_printf( ch, "It is %s's turn.\r\n", board->player2 );
return;
}
else if ( board->turn % 2 == 0 && !str_cmp( board->player2, ch->name ) )
{
ch_printf( ch, "It is %s's turn.\r\n", board->player1 );
return;
}
else
{
send_to_char( "It is your turn.\r\n", ch );
return;
}
return;
}
if ( !str_prefix( arg, "board" ) )
{
send_to_char( print_big_board( ch, ch->pcdata->game_board ), ch );
return;
}
if ( !str_prefix( arg, "move" ) )
{
CHAR_DATA *opp;
char opp_name[MAX_INPUT_LENGTH];
char a, b;
int x, y, dx, dy, ret;
if ( !ch->pcdata->game_board->player1 || !ch->pcdata->game_board->player2 )
{
send_to_char( "There is only 1 player.\r\n", ch );
return;
}
if ( ch->pcdata->game_board->turn < 0 )
{
send_to_char( "The game hasn't started yet.\r\n", ch );
return;
}
if ( king_in_checkmate( ch->pcdata->game_board, BLACK_KING ) )
{
send_to_char( "The black king has been checkmated, the game is over.\r\n", ch );
return;
}
if ( king_in_checkmate( ch->pcdata->game_board, WHITE_KING ) )
{
send_to_char( "The white king has been checkmated, the game is over.\r\n", ch );
return;
}
if ( !*argument )
{
send_to_char( "Usage: chess move [piece to move] [where to move]\r\n", ch );
return;
}
if ( ch->pcdata->game_board->turn % 2 == 1 && !str_cmp( ch->pcdata->game_board->player1, ch->name ) )
{
send_to_char( "It is not your turn.\r\n", ch );
return;
}
if ( ch->pcdata->game_board->turn % 2 == 0 && !str_cmp( ch->pcdata->game_board->player2, ch->name ) )
{
send_to_char( "It is not your turn.\r\n", ch );
return;
}
if ( sscanf( argument, "%c%d %c%d", &a, &y, &b, &dy ) != 4 )
{
send_to_char( "Usage: chess move [dest] [source]\r\n", ch );
return;
}
if ( a < 'a' || a > 'h' || b < 'a' || b > 'h' || y < 1 || y > 8 || dy < 1 || dy > 8 )
{
send_to_char( "Invalid move, use a-h, 1-8.\r\n", ch );
return;
}
x = a - 'a';
dx = b - 'a';
--y;
--dy;
ret = is_valid_move( ch, ch->pcdata->game_board, x, y, dx, dy );
if ( ret == MOVE_OK || ret == MOVE_TAKEN )
{
GAME_BOARD_DATA *board;
int piece, destpiece;
board = ch->pcdata->game_board;
piece = board->board[x][y];
destpiece = board->board[dx][dy];
board->board[dx][dy] = piece;
board->board[x][y] = NO_PIECE;
if ( king_in_check( board, IS_WHITE( board->board[dx][dy] ) ? WHITE_KING : BLACK_KING ) && ( board->board[dx][dy] != WHITE_KING && board->board[dx][dy] != BLACK_KING ) )
{
board->board[dx][dy] = destpiece;
board->board[x][y] = piece;
ret = MOVE_INCHECK;
}
else
{
++board->turn;
#ifdef IMC
if ( ch->pcdata->game_board->type == TYPE_IMC )
{
snprintf( arg, LGST, "move %d%d %d%d", x, y, dx, dy );
imc_send_chess( ch->pcdata->game_board->player1, ch->pcdata->game_board->player2, arg );
}
#endif
}
}
if ( !str_cmp( ch->name, ch->pcdata->game_board->player1 ) )
{
opp = get_char_world( ch, ch->pcdata->game_board->player2 );
if ( !opp )
mudstrlcpy( opp_name, ch->pcdata->game_board->player2, MAX_INPUT_LENGTH );
}
else
{
opp = get_char_world( ch, ch->pcdata->game_board->player1 );
if ( !opp )
mudstrlcpy( opp_name, ch->pcdata->game_board->player1, MAX_INPUT_LENGTH );
}
#ifdef IMC
# define SEND_TO_OPP(arg,opp) \
if( opp ) \
{ \
if( ch->pcdata->game_board->type == TYPE_LOCAL ) \
ch_printf( (opp), "%s\r\n", (arg) ); \
} \
else \
{ \
if( ch->pcdata->game_board->type == TYPE_IMC ) \
imc_send_tell( ch->name, opp_name, (arg), 1 ); \
}
#else
# define SEND_TO_OPP(arg,opp) \
if( opp ) \
{ \
if( ch->pcdata->game_board->type == TYPE_LOCAL ) \
ch_printf( (opp), "%s\r\n", (arg) ); \
}
#endif
switch ( ret )
{
case MOVE_OK:
send_to_char( "Ok.\r\n", ch );
snprintf( arg, MAX_INPUT_LENGTH, "%s has moved.\r\n", ch->name );
SEND_TO_OPP( arg, opp );
break;
case MOVE_INVALID:
send_to_char( "Invalid move.\r\n", ch );
break;
case MOVE_BLOCKED:
send_to_char( "You are blocked in that direction.\r\n", ch );
break;
case MOVE_TAKEN:
send_to_char( "You take the enemy's piece.\r\n", ch );
snprintf( arg, MAX_INPUT_LENGTH, "%s has taken one of your pieces!", ch->name );
SEND_TO_OPP( arg, opp );
break;
case MOVE_CHECKMATE:
send_to_char( "That move would result in a checkmate.\r\n", ch );
snprintf( arg, MAX_INPUT_LENGTH, "%s has attempted a move that would result in checkmate.", ch->name );
SEND_TO_OPP( arg, opp );
break;
case MOVE_OFFBOARD:
send_to_char( "That move would be off the board.\r\n", ch );
break;
case MOVE_SAMECOLOR:
send_to_char( "Your own piece blocks the way.\r\n", ch );
break;
case MOVE_CHECK:
send_to_char( "That move would result in a check.\r\n", ch );
snprintf( arg, MAX_INPUT_LENGTH, "%s has made a move that would result in a check.", ch->name );
SEND_TO_OPP( arg, opp );
break;
case MOVE_WRONGCOLOR:
send_to_char( "That is not your piece.\r\n", ch );
break;
case MOVE_INCHECK:
send_to_char( "You are in check, you must save your king.\r\n", ch );
break;
default:
bug( "%s: Unknown return value", __FUNCTION__ );
break;
}
#undef SEND_TO_OPP
return;
}
send_to_char( "Usage: chess <begin|cease|status|board|move|join>\r\n", ch );
}
void do_mapout( CHAR_DATA* ch, const char* argument)
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *map_obj; /* an obj made with map as an ed */
OBJ_INDEX_DATA *map_obj_index; /* obj_index for previous */
EXTRA_DESCR_DATA *ed; /* the ed for it to go in */
int rooms, rows, cols, avail_rooms;
if( !ch )
{
bug( "%s", "do_mapout: null ch" );
return;
}
if( IS_NPC( ch ) )
{
send_to_char( "Not in mobs.\r\n", ch );
return;
}
if( !ch->desc )
{
bug( "%s", "do_mapout: no descriptor" );
return;
}
switch ( ch->substate )
{
default:
break;
case SUB_WRITING_NOTE:
if( ch->dest_buf != ch->pnote )
bug( "%s", "do_mapout: sub_writing_map: ch->dest_buf != ch->pnote" );
STRFREE( ch->pnote->text );
ch->pnote->text = copy_buffer( ch );
stop_editing( ch );
return;
}
set_char_color( AT_NOTE, ch );
argument = one_argument( argument, arg );
smash_tilde( argument );
if( !str_cmp( arg, "stat" ) )
{
if( !ch->pnote )
{
send_to_char( "You have no map in progress.\r\n", ch );
return;
}
map_stats( ch, &rooms, &rows, &cols );
ch_printf( ch, "Map represents %d rooms, %d rows, and %d columns\r\n", rooms, rows, cols );
avail_rooms = num_rooms_avail( ch );
ch_printf( ch, "You currently have %d unused rooms.\r\n", avail_rooms );
act( AT_ACTION, "$n glances at an etherial map.", ch, NULL, NULL, TO_ROOM );
return;
}
if( !str_cmp( arg, "write" ) )
{
note_attach( ch );
ch->substate = SUB_WRITING_NOTE;
ch->dest_buf = ch->pnote;
start_editing( ch, ch->pnote->text );
return;
}
if( !str_cmp( arg, "clear" ) )
{
if( !ch->pnote )
{
send_to_char( "You have no map in progress\r\n", ch );
return;
}
STRFREE( ch->pnote->text );
STRFREE( ch->pnote->subject );
STRFREE( ch->pnote->to_list );
STRFREE( ch->pnote->date );
STRFREE( ch->pnote->sender );
DISPOSE( ch->pnote );
ch->pnote = NULL;
send_to_char( "Map cleared.\r\n", ch );
return;
}
if( !str_cmp( arg, "show" ) )
{
if( !ch->pnote )
{
send_to_char( "You have no map in progress.\r\n", ch );
return;
}
send_to_char( ch->pnote->text, ch );
do_mapout( ch, "stat" );
return;
}
if( !str_cmp( arg, "create" ) )
{
if( !ch->pnote )
{
send_to_char( "You have no map in progress.\r\n", ch );
return;
}
map_stats( ch, &rooms, &rows, &cols );
avail_rooms = num_rooms_avail( ch );
/*
* check for not enough rooms
*/
if( rooms > avail_rooms )
{
send_to_char( "You don't have enough unused rooms allocated!\r\n", ch );
return;
}
act( AT_ACTION, "$n warps the very dimensions of space!", ch, NULL, NULL, TO_ROOM );
map_to_rooms( ch, NULL ); /* this does the grunt work */
map_obj_index = get_obj_index( 91 );
if( map_obj_index )
{
map_obj = create_object( map_obj_index, 0 );
ed = SetOExtra( map_obj, "runes map scrawls" );
STRFREE( ed->description );
ed->description = QUICKLINK( ch->pnote->text );
obj_to_char( map_obj, ch );
}
else
{
send_to_char( "Couldn't give you a map object. Need Great Eastern Desert\r\n", ch );
return;
}
do_mapout( ch, "clear" );
send_to_char( "Ok.\r\n", ch );
return;
}
send_to_char( "mapout write: create a map in edit buffer.\r\n", ch );
send_to_char( "mapout stat: get information about a written, but not yet created map.\r\n", ch );
send_to_char( "mapout clear: clear a written, but not yet created map.\r\n", ch );
send_to_char( "mapout show: show a written, but not yet created map.\r\n", ch );
send_to_char( "mapout create: turn a written map into rooms in your assigned room vnum range.\r\n", ch );
return;
}
void do_mposet( CHAR_DATA * ch, const char *argument )
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
OBJ_DATA *obj;
char outbuf[MAX_STRING_LENGTH];
int value, tmp;
/*
* A desc means switched.. too many loopholes if we allow that..
*/
if ( !IS_NPC( ch ) || IS_AFFECTED( ch, AFF_CHARM ) || ch->desc )
{
send_to_char( "Huh?\r\n", ch );
return;
}
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
mudstrlcpy( arg3, argument, MAX_INPUT_LENGTH );
if ( !*arg1 )
{
progbug( "MpOset: no args", ch );
return;
}
if ( ( obj = get_obj_here( ch, arg1 ) ) == NULL )
{
progbug( "MpOset: no object", ch );
return;
}
if ( IS_OBJ_STAT( obj, ITEM_PROTOTYPE ) )
{
progbug( "MpOset: can't set prototype items", ch );
return;
}
separate_obj( obj );
value = atoi( arg3 );
if ( !str_cmp( arg2, "value0" ) || !str_cmp( arg2, "v0" ) )
{
obj->value[0] = value;
return;
}
if ( !str_cmp( arg2, "value1" ) || !str_cmp( arg2, "v1" ) )
{
obj->value[1] = value;
return;
}
if ( !str_cmp( arg2, "value2" ) || !str_cmp( arg2, "v2" ) )
{
obj->value[2] = value;
return;
}
if ( !str_cmp( arg2, "value3" ) || !str_cmp( arg2, "v3" ) )
{
obj->value[3] = value;
return;
}
if ( !str_cmp( arg2, "value4" ) || !str_cmp( arg2, "v4" ) )
{
obj->value[4] = value;
return;
}
if ( !str_cmp( arg2, "value5" ) || !str_cmp( arg2, "v5" ) )
{
obj->value[5] = value;
return;
}
if ( !str_cmp( arg2, "type" ) )
{
if ( !argument || argument[0] == '\0' )
{
progbug( "MpOset: no type", ch );
return;
}
value = get_otype( argument );
if ( value < 1 )
{
progbug( "MpOset: Invalid type", ch );
return;
}
obj->item_type = ( short ) value;
return;
}
if ( !str_cmp( arg2, "flags" ) )
{
if ( !argument || argument[0] == '\0' )
{
progbug( "MpOset: no flags", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_oflag( arg3 );
if ( value < 0 || value >= MAX_BITS )
progbug( "MpOset: Invalid flag", ch );
else
{
if ( value == ITEM_PROTOTYPE )
progbug( "MpOset: can't set prototype flag", ch );
else
xTOGGLE_BIT( obj->extra_flags, value );
}
}
return;
}
if ( !str_cmp( arg2, "wear" ) )
{
if ( !argument || argument[0] == '\0' )
{
progbug( "MpOset: no wear", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_wflag( arg3 );
if ( value < 0 || value > 31 )
progbug( "MpOset: Invalid wear", ch );
else
TOGGLE_BIT( obj->wear_flags, 1 << value );
}
return;
}
if ( !str_cmp( arg2, "level" ) )
{
obj->level = value;
return;
}
if ( !str_cmp( arg2, "weight" ) )
{
obj->weight = value;
return;
}
if ( !str_cmp( arg2, "cost" ) )
{
obj->cost = value;
return;
}
if ( !str_cmp( arg2, "timer" ) )
{
obj->timer = value;
return;
}
if ( !str_cmp( arg2, "name" ) )
{
STRFREE( obj->name );
obj->name = STRALLOC( arg3 );
return;
}
if ( !str_cmp( arg2, "short" ) )
{
STRFREE( obj->short_descr );
obj->short_descr = STRALLOC( arg3 );
if ( obj == supermob_obj )
{
STRFREE( supermob->short_descr );
supermob->short_descr = QUICKLINK( obj->short_descr );
}
/*
* Feature added by Narn, Apr/96
* * If the item is not proto, add the word 'rename' to the keywords
* * if it is not already there.
*/
if ( str_infix( "mprename", obj->name ) )
{
snprintf( buf, MAX_STRING_LENGTH, "%s %s", obj->name, "mprename" );
STRFREE( obj->name );
obj->name = STRALLOC( buf );
}
return;
}
if ( !str_cmp( arg2, "long" ) )
{
STRFREE( obj->description );
mudstrlcpy( buf, arg3, MAX_STRING_LENGTH );
obj->description = STRALLOC( buf );
return;
}
if ( !str_cmp( arg2, "actiondesc" ) )
{
if ( strstr( arg3, "%n" ) || strstr( arg3, "%d" ) || strstr( arg3, "%l" ) )
{
progbug( "MpOset: Illegal actiondesc", ch );
return;
}
STRFREE( obj->action_desc );
obj->action_desc = STRALLOC( arg3 );
return;
}
if ( !str_cmp( arg2, "affect" ) )
{
AFFECT_DATA *paf;
short loc;
int bitv;
argument = one_argument( argument, arg2 );
if ( arg2[0] == '\0' || !argument || argument[0] == 0 )
{
progbug( "MpOset: Bad affect syntax", ch );
send_to_char( "Usage: oset <object> affect <field> <value>\r\n", ch );
return;
}
loc = get_atype( arg2 );
if ( loc < 1 )
{
progbug( "MpOset: Invalid affect field", ch );
return;
}
if ( loc >= APPLY_AFFECT && loc < APPLY_WEAPONSPELL )
{
bitv = 0;
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
if ( loc == APPLY_AFFECT )
value = get_aflag( arg3 );
else
value = get_risflag( arg3 );
if ( value < 0 || value > 31 )
progbug( "MpOset: bad affect flag", ch );
else
SET_BIT( bitv, 1 << value );
}
if ( !bitv )
return;
value = bitv;
}
else
{
argument = one_argument( argument, arg3 );
value = atoi( arg3 );
}
CREATE( paf, AFFECT_DATA, 1 );
paf->type = -1;
paf->duration = -1;
paf->location = loc;
paf->modifier = value;
xCLEAR_BITS( paf->bitvector );
paf->next = NULL;
LINK( paf, obj->first_affect, obj->last_affect, next, prev );
++top_affect;
return;
}
if ( !str_cmp( arg2, "rmaffect" ) )
{
AFFECT_DATA *paf;
short loc, count;
if ( !argument || argument[0] == '\0' )
{
progbug( "MpOset: no rmaffect", ch );
return;
}
loc = atoi( argument );
if ( loc < 1 )
{
progbug( "MpOset: Invalid rmaffect", ch );
return;
}
count = 0;
for ( paf = obj->first_affect; paf; paf = paf->next )
{
if ( ++count == loc )
{
UNLINK( paf, obj->first_affect, obj->last_affect, next, prev );
DISPOSE( paf );
send_to_char( "Removed.\r\n", ch );
--top_affect;
return;
}
}
progbug( "MpOset: rmaffect not found", ch );
return;
}
/*
* save some finger-leather
*/
if ( !str_cmp( arg2, "ris" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect resistant %s", arg1, arg3 );
do_mposet( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect immune %s", arg1, arg3 );
do_mposet( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect susceptible %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "r" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect resistant %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "i" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect immune %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "s" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect susceptible %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "ri" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect resistant %s", arg1, arg3 );
do_mposet( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect immune %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "rs" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect resistant %s", arg1, arg3 );
do_mposet( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect susceptible %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "is" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect immune %s", arg1, arg3 );
do_mposet( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s affect susceptible %s", arg1, arg3 );
do_mposet( ch, outbuf );
return;
}
/*
* Make it easier to set special object values by name than number
* -Thoric
*/
tmp = -1;
switch ( obj->item_type )
{
case ITEM_WEAPON:
if ( !str_cmp( arg2, "weapontype" ) )
{
unsigned int x;
value = -1;
for ( x = 0; x < sizeof( attack_table ) / sizeof( attack_table[0] ); x++ )
if ( !str_cmp( arg3, attack_table[x] ) )
value = x;
if ( value < 0 )
{
progbug( "MpOset: Invalid weapon type", ch );
return;
}
tmp = 3;
break;
}
if ( !str_cmp( arg2, "condition" ) )
tmp = 0;
break;
case ITEM_ARMOR:
if ( !str_cmp( arg2, "condition" ) )
tmp = 3;
if ( !str_cmp( arg2, "ac" ) )
tmp = 1;
break;
case ITEM_SALVE:
if ( !str_cmp( arg2, "slevel" ) )
tmp = 0;
if ( !str_cmp( arg2, "maxdoses" ) )
tmp = 1;
if ( !str_cmp( arg2, "doses" ) )
tmp = 2;
if ( !str_cmp( arg2, "delay" ) )
tmp = 3;
if ( !str_cmp( arg2, "spell1" ) )
tmp = 4;
if ( !str_cmp( arg2, "spell2" ) )
tmp = 5;
if ( tmp >= 4 && tmp <= 5 )
value = skill_lookup( arg3 );
break;
case ITEM_SCROLL:
case ITEM_POTION:
case ITEM_PILL:
if ( !str_cmp( arg2, "slevel" ) )
tmp = 0;
if ( !str_cmp( arg2, "spell1" ) )
tmp = 1;
if ( !str_cmp( arg2, "spell2" ) )
tmp = 2;
if ( !str_cmp( arg2, "spell3" ) )
tmp = 3;
if ( tmp >= 1 && tmp <= 3 )
value = skill_lookup( arg3 );
break;
case ITEM_STAFF:
case ITEM_WAND:
if ( !str_cmp( arg2, "slevel" ) )
tmp = 0;
if ( !str_cmp( arg2, "spell" ) )
{
tmp = 3;
value = skill_lookup( arg3 );
}
if ( !str_cmp( arg2, "maxcharges" ) )
tmp = 1;
if ( !str_cmp( arg2, "charges" ) )
tmp = 2;
break;
case ITEM_CONTAINER:
if ( !str_cmp( arg2, "capacity" ) )
tmp = 0;
if ( !str_cmp( arg2, "cflags" ) )
tmp = 1;
if ( !str_cmp( arg2, "key" ) )
tmp = 2;
break;
case ITEM_SWITCH:
case ITEM_LEVER:
case ITEM_PULLCHAIN:
case ITEM_BUTTON:
if ( !str_cmp( arg2, "tflags" ) )
{
tmp = 0;
value = get_trigflag( arg3 );
}
break;
}
if ( tmp >= 0 && tmp <= 3 )
{
obj->value[tmp] = value;
return;
}
progbug( "MpOset: Invalid field", ch );
return;
}
void do_mpmset( CHAR_DATA * ch, const char *argument )
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
char log_buf[MAX_STRING_LENGTH];
char outbuf[MAX_STRING_LENGTH];
CHAR_DATA *victim;
int value, v2;
int minattr, maxattr;
/*
* A desc means switched.. too many loopholes if we allow that..
*/
if ( !IS_NPC( ch ) || IS_AFFECTED( ch, AFF_CHARM ) || ch->desc )
{
send_to_char( "Huh?\r\n", ch );
return;
}
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
mudstrlcpy( arg3, argument, MAX_INPUT_LENGTH );
if ( !*arg1 )
{
progbug( "MpMset: no args", ch );
return;
}
if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
{
progbug( "MpMset: no victim", ch );
return;
}
if ( IS_IMMORTAL( victim ) )
{
send_to_char( "You can't do that!\r\n", ch );
return;
}
if ( IS_NPC( victim ) && xIS_SET( victim->act, ACT_PROTOTYPE ) )
{
progbug( "MpMset: victim is proto", ch );
return;
}
if ( IS_NPC( victim ) )
{
minattr = 1;
maxattr = 25;
}
else
{
minattr = 3;
maxattr = 18;
}
value = is_number( arg3 ) ? atoi( arg3 ) : -1;
if ( atoi( arg3 ) < -1 && value == -1 )
value = atoi( arg3 );
if ( !str_cmp( arg2, "str" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid str", ch );
return;
}
victim->perm_str = value;
return;
}
if ( !str_cmp( arg2, "int" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid int", ch );
return;
}
victim->perm_int = value;
return;
}
if ( !str_cmp( arg2, "wis" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid wis", ch );
return;
}
victim->perm_wis = value;
return;
}
if ( !str_cmp( arg2, "dex" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid dex", ch );
return;
}
victim->perm_dex = value;
return;
}
if ( !str_cmp( arg2, "con" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid con", ch );
return;
}
victim->perm_con = value;
return;
}
if ( !str_cmp( arg2, "cha" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid cha", ch );
return;
}
victim->perm_cha = value;
return;
}
if ( !str_cmp( arg2, "lck" ) )
{
if ( value < minattr || value > maxattr )
{
progbug( "MpMset: Invalid lck", ch );
return;
}
victim->perm_lck = value;
return;
}
if ( !str_cmp( arg2, "sav1" ) )
{
if ( value < -30 || value > 30 )
{
progbug( "MpMset: Invalid sav1", ch );
return;
}
victim->saving_poison_death = value;
return;
}
if ( !str_cmp( arg2, "sav2" ) )
{
if ( value < -30 || value > 30 )
{
progbug( "MpMset: Invalid sav2", ch );
return;
}
victim->saving_wand = value;
return;
}
if ( !str_cmp( arg2, "sav3" ) )
{
if ( value < -30 || value > 30 )
{
progbug( "MpMset: Invalid sav3", ch );
return;
}
victim->saving_para_petri = value;
return;
}
if ( !str_cmp( arg2, "sav4" ) )
{
if ( value < -30 || value > 30 )
{
progbug( "MpMset: Invalid sav4", ch );
return;
}
victim->saving_breath = value;
return;
}
if ( !str_cmp( arg2, "sav5" ) )
{
if ( value < -30 || value > 30 )
{
progbug( "MpMset: Invalid sav5", ch );
return;
}
victim->saving_spell_staff = value;
return;
}
if ( !str_cmp( arg2, "sex" ) )
{
if ( value < 0 || value > 2 )
{
progbug( "MpMset: Invalid sex", ch );
return;
}
victim->sex = value;
return;
}
if ( !str_cmp( arg2, "class" ) )
{
if ( IS_NPC( victim ) ) /* Broken by Haus... fixed by Thoric */
{
if ( value >= MAX_NPC_CLASS || value < 0 )
{
progbug( "MpMset: Invalid npc class", ch );
return;
}
victim->Class = value;
return;
}
progbug( "MpMset: can't set pc class", ch );
}
if ( !str_cmp( arg2, "race" ) )
{
value = get_npc_race( arg3 );
if ( value < 0 )
value = atoi( arg3 );
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc race", ch );
return;
}
if ( value < 0 || value >= MAX_NPC_RACE )
{
progbug( "MpMset: Invalid npc race", ch );
return;
}
victim->race = value;
return;
}
if ( !str_cmp( arg2, "armor" ) )
{
if ( value < -300 || value > 300 )
{
send_to_char( "AC range is -300 to 300.\r\n", ch );
return;
}
victim->armor = value;
return;
}
if ( !str_cmp( arg2, "level" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc level", ch );
return;
}
if ( value < 0 || value > LEVEL_AVATAR + 5 )
{
progbug( "MpMset: Invalid npc level", ch );
return;
}
victim->level = value;
return;
}
if ( !str_cmp( arg2, "numattacks" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc numattacks", ch );
return;
}
if ( value < 0 || value > 20 )
{
progbug( "MpMset: Invalid npc numattacks", ch );
return;
}
victim->numattacks = value;
return;
}
if ( !str_cmp( arg2, "gold" ) )
{
victim->gold = value;
return;
}
if ( !str_cmp( arg2, "hitroll" ) )
{
victim->hitroll = URANGE( 0, value, 85 );
return;
}
if ( !str_cmp( arg2, "damroll" ) )
{
victim->damroll = URANGE( 0, value, 65 );
return;
}
if ( !str_cmp( arg2, "hp" ) )
{
if ( value < 1 || value > 32700 )
{
progbug( "MpMset: Invalid hp", ch );
return;
}
victim->max_hit = value;
return;
}
if ( !str_cmp( arg2, "mana" ) )
{
if ( value < 0 || value > 30000 )
{
progbug( "MpMset: Invalid mana", ch );
return;
}
victim->max_mana = value;
return;
}
if ( !str_cmp( arg2, "move" ) )
{
if ( value < 0 || value > 30000 )
{
progbug( "MpMset: Invalid move", ch );
return;
}
victim->max_move = value;
return;
}
if ( !str_cmp( arg2, "practice" ) )
{
if ( value < 0 || value > 100 )
{
progbug( "MpMset: Invalid practice", ch );
return;
}
victim->practice = value;
return;
}
if ( !str_cmp( arg2, "align" ) )
{
if ( value < -1000 || value > 1000 )
{
progbug( "MpMset: Invalid align", ch );
return;
}
victim->alignment = value;
return;
}
/* non-functional for now -- Blod
if ( !str_cmp( arg2, "quest" ) )
{
if ( IS_NPC(victim) )
{
progbug("MpMset: can't set npc quest", ch);
return;
}
if ( value < 0 || value > 500 )
{
progbug("MpMset: Invalid pc quest", ch);
return;
}
victim->pcdata->quest = value;
return;
}
*/
if ( !str_cmp( arg2, "questplus" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc qp", ch );
return;
}
if ( value < 0 || value > 5000 )
{
progbug( "MpMset: Invalid pc qp", ch );
return;
}
snprintf( log_buf, MAX_STRING_LENGTH, "%s raising glory of %s by %d ...", ch->name, victim->name, value );
log_string( log_buf );
victim->pcdata->quest_curr += value;
victim->pcdata->quest_accum += value;
return;
}
if ( !str_cmp( arg2, "favor" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc favor", ch );
return;
}
if ( value < -2500 || value > 2500 )
{
progbug( "MpMset: Invalid pc favor", ch );
return;
}
victim->pcdata->favor = value;
return;
}
if ( !str_cmp( arg2, "mentalstate" ) )
{
if ( value < -100 || value > 100 )
{
progbug( "MpMset: Invalid mentalstate", ch );
return;
}
victim->mental_state = value;
return;
}
if ( !str_cmp( arg2, "emotion" ) )
{
if ( value < -100 || value > 100 )
{
progbug( "MpMset: Invalid emotion", ch );
return;
}
victim->emotional_state = value;
return;
}
if ( !str_cmp( arg2, "thirst" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc thirst", ch );
return;
}
if ( value < 0 || value > 100 )
{
progbug( "MpMset: Invalid pc thirst", ch );
return;
}
victim->pcdata->condition[COND_THIRST] = value;
return;
}
if ( !str_cmp( arg2, "drunk" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc drunk", ch );
return;
}
if ( value < 0 || value > 100 )
{
progbug( "MpMset: Invalid pc drunk", ch );
return;
}
victim->pcdata->condition[COND_DRUNK] = value;
return;
}
if ( !str_cmp( arg2, "full" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc full", ch );
return;
}
if ( value < 0 || value > 100 )
{
progbug( "MpMset: Invalid pc full", ch );
return;
}
victim->pcdata->condition[COND_FULL] = value;
return;
}
if ( !str_cmp( arg2, "blood" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc blood", ch );
return;
}
if ( value < 0 || value > MAX_LEVEL + 10 )
{
progbug( "MpMset: Invalid pc blood", ch );
return;
}
victim->pcdata->condition[COND_BLOODTHIRST] = value;
return;
}
if ( !str_cmp( arg2, "name" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc name", ch );
return;
}
STRFREE( victim->name );
victim->name = STRALLOC( arg3 );
return;
}
if ( !str_cmp( arg2, "deity" ) )
{
DEITY_DATA *deity;
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc deity", ch );
return;
}
if ( arg3[0] == '\0' )
{
STRFREE( victim->pcdata->deity_name );
victim->pcdata->deity_name = STRALLOC( "" );
victim->pcdata->deity = NULL;
return;
}
deity = get_deity( arg3 );
if ( !deity )
{
progbug( "MpMset: Invalid deity", ch );
return;
}
STRFREE( victim->pcdata->deity_name );
victim->pcdata->deity_name = QUICKLINK( deity->name );
victim->pcdata->deity = deity;
return;
}
if ( !str_cmp( arg2, "short" ) )
{
STRFREE( victim->short_descr );
victim->short_descr = STRALLOC( arg3 );
return;
}
if ( !str_cmp( arg2, "long" ) )
{
STRFREE( victim->long_descr );
mudstrlcpy( buf, arg3, MAX_STRING_LENGTH );
mudstrlcat( buf, "\r\n", MAX_STRING_LENGTH );
victim->long_descr = STRALLOC( buf );
return;
}
if ( !str_cmp( arg2, "title" ) )
{
if ( IS_NPC( victim ) )
{
progbug( "MpMset: can't set npc title", ch );
return;
}
set_title( victim, arg3 );
return;
}
if ( !str_cmp( arg2, "spec" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc spec", ch );
return;
}
if ( !str_cmp( arg3, "none" ) )
{
victim->spec_fun = NULL;
return;
}
if ( ( victim->spec_fun = spec_lookup( arg3 ) ) == 0 )
{
progbug( "MpMset: Invalid spec", ch );
return;
}
return;
}
if ( !str_cmp( arg2, "flags" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc flags", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no flags", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_actflag( arg3 );
if ( value < 0 || value >= MAX_BITS )
progbug( "MpMset: Invalid flag", ch );
else
{
if ( value == ACT_PROTOTYPE )
progbug( "MpMset: can't set prototype flag", ch );
else if ( value == ACT_IS_NPC )
progbug( "MpMset: can't remove npc flag", ch );
else
xTOGGLE_BIT( victim->act, value );
}
}
return;
}
if ( !str_cmp( arg2, "affected" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't modify pc affected", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no affected", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_aflag( arg3 );
if ( value < 0 || value >= MAX_BITS )
progbug( "MpMset: Invalid affected", ch );
else
xTOGGLE_BIT( victim->affected_by, value );
}
return;
}
/*
* save some more finger-leather for setting RIS stuff
* Why there's can_modify checks here AND in the called function, Ill
* never know, so I removed them.. -- Alty
*/
if ( !str_cmp( arg2, "r" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s resistant %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "i" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s immune %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "s" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s susceptible %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "ri" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s resistant %s", arg1, arg3 );
do_mpmset( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s immune %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "rs" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s resistant %s", arg1, arg3 );
do_mpmset( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s susceptible %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "is" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s immune %s", arg1, arg3 );
do_mpmset( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s susceptible %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "ris" ) )
{
snprintf( outbuf, MAX_STRING_LENGTH, "%s resistant %s", arg1, arg3 );
do_mpmset( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s immune %s", arg1, arg3 );
do_mpmset( ch, outbuf );
snprintf( outbuf, MAX_STRING_LENGTH, "%s susceptible %s", arg1, arg3 );
do_mpmset( ch, outbuf );
return;
}
if ( !str_cmp( arg2, "resistant" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc resistant", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no resistant", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_risflag( arg3 );
if ( value < 0 || value > 31 )
progbug( "MpMset: Invalid resistant", ch );
else
TOGGLE_BIT( victim->resistant, 1 << value );
}
return;
}
if ( !str_cmp( arg2, "immune" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc immune", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no immune", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_risflag( arg3 );
if ( value < 0 || value > 31 )
progbug( "MpMset: Invalid immune", ch );
else
TOGGLE_BIT( victim->immune, 1 << value );
}
return;
}
if ( !str_cmp( arg2, "susceptible" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc susceptible", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no susceptible", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_risflag( arg3 );
if ( value < 0 || value > 31 )
progbug( "MpMset: Invalid susceptible", ch );
else
TOGGLE_BIT( victim->susceptible, 1 << value );
}
return;
}
if ( !str_cmp( arg2, "part" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc part", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no part", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_partflag( arg3 );
if ( value < 0 || value > 31 )
progbug( "MpMset: Invalid part", ch );
else
TOGGLE_BIT( victim->xflags, 1 << value );
}
return;
}
if ( !str_cmp( arg2, "attack" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc attack", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no attack", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_attackflag( arg3 );
if ( value < 0 )
progbug( "MpMset: Invalid attack", ch );
else
xTOGGLE_BIT( victim->attacks, value );
}
return;
}
if ( !str_cmp( arg2, "defense" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc defense", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no defense", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_defenseflag( arg3 );
if ( value < 0 || value >= MAX_BITS )
progbug( "MpMset: Invalid defense", ch );
else
xTOGGLE_BIT( victim->defenses, value );
}
return;
}
if ( !str_cmp( arg2, "pos" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc pos", ch );
return;
}
if ( value < 0 || value > POS_STANDING )
{
progbug( "MpMset: Invalid pos", ch );
return;
}
victim->position = value;
return;
}
if ( !str_cmp( arg2, "defpos" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc defpos", ch );
return;
}
if ( value < 0 || value > POS_STANDING )
{
progbug( "MpMset: Invalid defpos", ch );
return;
}
victim->defposition = value;
return;
}
if ( !str_cmp( arg2, "speaks" ) )
{
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no speaks", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_langflag( arg3 );
v2 = get_langnum( arg3 );
if ( value == LANG_UNKNOWN )
progbug( "MpMset: Invalid speaks", ch );
else if ( !IS_NPC( victim ) )
{
if ( !( value &= VALID_LANGS ) )
{
progbug( "MpMset: Invalid player language", ch );
continue;
}
if ( v2 == -1 )
ch_printf( ch, "Unknown language: %s\r\n", arg3 );
else
TOGGLE_BIT( victim->speaks, 1 << v2 );
}
else
{
if ( v2 == -1 )
ch_printf( ch, "Unknown language: %s\r\n", arg3 );
else
TOGGLE_BIT( victim->speaks, 1 << v2 );
}
}
if ( !IS_NPC( victim ) )
{
REMOVE_BIT( victim->speaks, race_table[victim->race]->language );
if ( !knows_language( victim, victim->speaking, victim ) )
victim->speaking = race_table[victim->race]->language;
}
return;
}
if ( !str_cmp( arg2, "speaking" ) )
{
if ( !IS_NPC( victim ) )
{
progbug( "MpMset: can't set pc speaking", ch );
return;
}
if ( !argument || argument[0] == '\0' )
{
progbug( "MpMset: no speaking", ch );
return;
}
while ( argument[0] != '\0' )
{
argument = one_argument( argument, arg3 );
value = get_langflag( arg3 );
if ( value == LANG_UNKNOWN )
progbug( "MpMset: Invalid speaking", ch );
else
{
v2 = get_langnum( arg3 );
if ( v2 == -1 )
ch_printf( ch, "Unknown language: %s\r\n", arg3 );
else
TOGGLE_BIT( victim->speaks, 1 << v2 );
}
}
return;
}
progbug( "MpMset: Invalid field", ch );
return;
}
void do_note( CHAR_DATA * ch, char *arg_passed, bool IS_MAIL )
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
NOTE_DATA *pnote = NULL;
BOARD_DATA *board = NULL;
int vnum = 0;
int anum = 0;
int first_list = 0;
OBJ_DATA *paper = NULL, *tmpobj = NULL;
EXTRA_DESCR_DATA *ed = NULL;
char notebuf[MAX_STRING_LENGTH];
char short_desc_buf[MAX_STRING_LENGTH];
char long_desc_buf[MAX_STRING_LENGTH];
char keyword_buf[MAX_STRING_LENGTH];
bool mfound = FALSE;
bool wasfound = FALSE;
if( IS_NPC( ch ) )
return;
if( !ch->desc )
{
bug( "do_note: no descriptor", 0 );
return;
}
switch ( ch->substate )
{
default:
break;
case SUB_WRITING_NOTE:
if( ( paper = get_eq_char( ch, WEAR_HOLD ) ) == NULL
|| paper->item_type != ITEM_PAPER )
{
bug( "do_note: player not holding paper", 0 );
stop_editing( ch );
return;
}
ed = ( EXTRA_DESCR_DATA * ) ch->dest_buf;
STRFREE( ed->description );
ed->description = copy_buffer( ch );
stop_editing( ch );
return;
}
set_char_color( AT_NOTE, ch );
arg_passed = one_argument( arg_passed, arg );
smash_tilde( arg_passed );
if( !str_cmp( arg, "list" ) )
{
board = find_board( ch );
if( !board )
{
send_to_char( "There is no board here to look at.\r\n", ch );
return;
}
if( !can_read( ch, board ) )
{
send_to_char
( "You cannot make any sense of the cryptic scrawl on this board...\r\n",
ch );
return;
}
first_list = atoi( arg_passed );
if( first_list )
{
if( IS_MAIL )
{
send_to_char
( "You cannot use a list number (at this time) with mail.\r\n",
ch );
return;
}
if( first_list < 1 )
{
send_to_char( "You can't read a message before 1!\r\n", ch );
return;
}
}
if( !IS_MAIL )
{
vnum = 0;
set_pager_color( AT_NOTE, ch );
for( pnote = board->first_note; pnote; pnote = pnote->next )
{
vnum++;
if( ( first_list && vnum >= first_list ) || !first_list )
pager_printf( ch, "%2d%c %-12s%c %-12s %s\r\n",
vnum,
is_note_to( ch, pnote ) ? ')' : '}',
pnote->sender,
( pnote->voting !=
VOTE_NONE ) ? ( pnote->voting ==
VOTE_OPEN ? 'V' : 'C' ) : ':',
pnote->to_list, pnote->subject );
}
act( AT_ACTION, "$n glances over the messages.", ch, NULL, NULL,
TO_ROOM );
return;
}
else
{
vnum = 0;
if( IS_MAIL ) /* SB Mail check for Brit */
{
for( pnote = board->first_note; pnote; pnote = pnote->next )
if( is_note_to( ch, pnote ) )
mfound = TRUE;
if( !mfound && !IS_IMMORTAL( ch ) )
{
ch_printf( ch, "You have no mail.\r\n" );
return;
}
}
for( pnote = board->first_note; pnote; pnote = pnote->next )
if( is_note_to( ch, pnote ) || IS_IMMORTAL( ch ) )
ch_printf( ch, "%2d%c %s: %s\r\n",
++vnum,
is_note_to( ch, pnote ) ? '-' : '}',
pnote->sender, pnote->subject );
return;
}
}
if( !str_cmp( arg, "read" ) )
{
bool fAll = FALSE;
board = find_board( ch );
if( !board )
{
send_to_char( "There is no board here to look at.\r\n", ch );
return;
}
if( !can_read( ch, board ) )
{
send_to_char
( "You cannot make any sense of the cryptic scrawl on this board...\r\n",
ch );
return;
}
if( !str_cmp( arg_passed, "all" ) )
{
fAll = TRUE;
anum = 0;
}
else if( is_number( arg_passed ) )
{
fAll = FALSE;
anum = atoi( arg_passed );
}
else
{
send_to_char( "Note read which number?\r\n", ch );
return;
}
set_pager_color( AT_NOTE, ch );
if( !IS_MAIL )
{
vnum = 0;
for( pnote = board->first_note; pnote; pnote = pnote->next )
{
vnum++;
if( vnum == anum || fAll )
{
wasfound = TRUE;
pager_printf( ch, "[%3d] %s: %s\r\n%s\r\nTo: %s\r\n%s",
vnum,
pnote->sender,
pnote->subject,
pnote->date, pnote->to_list, pnote->text );
if( pnote->yesvotes[0] != '\0' || pnote->novotes[0] != '\0'
|| pnote->abstentions[0] != '\0' )
{
send_to_pager
( "------------------------------------------------------------\r\n",
ch );
pager_printf( ch,
"Votes:\r\nYes: %s\r\nNo: %s\r\nAbstain: %s\r\n",
pnote->yesvotes, pnote->novotes,
pnote->abstentions );
}
act( AT_ACTION, "$n reads a message.", ch, NULL, NULL,
TO_ROOM );
}
}
if( !wasfound )
ch_printf( ch, "No such message: %d\r\n", anum );
return;
}
else
{
vnum = 0;
for( pnote = board->first_note; pnote; pnote = pnote->next )
{
if( is_note_to( ch, pnote ) || IS_IMMORTAL( ch ) )
{
vnum++;
if( vnum == anum || fAll )
{
wasfound = TRUE;
pager_printf( ch, "[%3d] %s: %s\r\n%s\r\nTo: %s\r\n%s",
vnum,
pnote->sender,
pnote->subject,
pnote->date,
pnote->to_list, pnote->text );
}
}
}
if( !wasfound )
ch_printf( ch, "No such message: %d\r\n", anum );
return;
}
}
/* Voting added by Narn, June '96 */
if( !str_cmp( arg, "vote" ) )
{
char arg2[MAX_INPUT_LENGTH];
arg_passed = one_argument( arg_passed, arg2 );
board = find_board( ch );
if( !board )
{
send_to_char( "There is no bulletin board here.\r\n", ch );
return;
}
if( !can_read( ch, board ) )
{
send_to_char( "You cannot vote on this board.\r\n", ch );
return;
}
if( is_number( arg2 ) )
anum = atoi( arg2 );
else
{
send_to_char( "Note vote which number?\r\n", ch );
return;
}
vnum = 1;
for( pnote = board->first_note; pnote && vnum < anum;
pnote = pnote->next )
vnum++;
if( !pnote )
{
send_to_char( "No such note.\r\n", ch );
return;
}
/* Options: open close yes no abstain */
/* If you're the author of the note and can read the board you can open
and close voting, if you can read it and voting is open you can vote.
*/
if( !str_cmp( arg_passed, "open" ) )
{
if( str_cmp( ch->name, pnote->sender ) )
{
send_to_char( "You are not the author of this message.\r\n",
ch );
return;
}
pnote->voting = VOTE_OPEN;
act( AT_ACTION, "$n opens voting on a note.", ch, NULL, NULL,
TO_ROOM );
send_to_char( "Voting opened.\r\n", ch );
write_board( board );
return;
}
if( !str_cmp( arg_passed, "close" ) )
{
if( str_cmp( ch->name, pnote->sender ) )
{
send_to_char( "You are not the author of this message.\r\n",
ch );
return;
}
pnote->voting = VOTE_CLOSED;
act( AT_ACTION, "$n closes voting on a note.", ch, NULL, NULL,
TO_ROOM );
send_to_char( "Voting closed.\r\n", ch );
write_board( board );
return;
}
/* Make sure the note is open for voting before going on. */
if( pnote->voting != VOTE_OPEN )
{
send_to_char( "Voting is not open on this note.\r\n", ch );
return;
}
/* Can only vote once on a note. */
sprintf( buf, "%s %s %s",
pnote->yesvotes, pnote->novotes, pnote->abstentions );
if( is_name( ch->name, buf ) )
{
send_to_char( "You have already voted on this note.\r\n", ch );
return;
}
if( !str_cmp( arg_passed, "yes" ) )
{
sprintf( buf, "%s %s", pnote->yesvotes, ch->name );
DISPOSE( pnote->yesvotes );
pnote->yesvotes = str_dup( buf );
act( AT_ACTION, "$n votes on a note.", ch, NULL, NULL, TO_ROOM );
send_to_char( "Ok.\r\n", ch );
write_board( board );
return;
}
if( !str_cmp( arg_passed, "no" ) )
{
sprintf( buf, "%s %s", pnote->novotes, ch->name );
DISPOSE( pnote->novotes );
pnote->novotes = str_dup( buf );
act( AT_ACTION, "$n votes on a note.", ch, NULL, NULL, TO_ROOM );
send_to_char( "Ok.\r\n", ch );
write_board( board );
return;
}
if( !str_cmp( arg_passed, "abstain" ) )
{
sprintf( buf, "%s %s", pnote->abstentions, ch->name );
DISPOSE( pnote->abstentions );
pnote->abstentions = str_dup( buf );
act( AT_ACTION, "$n votes on a note.", ch, NULL, NULL, TO_ROOM );
send_to_char( "Ok.\r\n", ch );
write_board( board );
return;
}
do_note( ch, STRLIT_EMPTY, FALSE );
}
if( !str_cmp( arg, "write" ) )
{
if( ch->substate == SUB_RESTRICTED )
{
send_to_char
( "You cannot write a note from within another command.\r\n",
ch );
return;
}
if( ( paper = get_eq_char( ch, WEAR_HOLD ) ) == NULL
|| paper->item_type != ITEM_PAPER )
{
paper = create_object( get_obj_index( OBJ_VNUM_NOTE ) );
if( ( tmpobj = get_eq_char( ch, WEAR_HOLD ) ) != NULL )
unequip_char( ch, tmpobj );
paper = obj_to_char( paper, ch );
equip_char( ch, paper, WEAR_HOLD );
act( AT_MAGIC, "$n grabs a message disk to record a note.",
ch, NULL, NULL, TO_ROOM );
act( AT_MAGIC, "You get a message disk to record your note.",
ch, NULL, NULL, TO_CHAR );
}
if( paper->value[0] < 2 )
{
paper->value[0] = 1;
ed = SetOExtra( paper, "_text_" );
ch->substate = SUB_WRITING_NOTE;
ch->dest_buf = ed;
start_editing( ch, ed->description );
return;
}
else
{
send_to_char( "You cannot modify this message.\r\n", ch );
return;
}
}
if( !str_cmp( arg, "subject" ) )
{
if( !arg_passed || arg_passed[0] == '\0' )
{
send_to_char( "What do you wish the subject to be?\r\n", ch );
return;
}
if( ( paper = get_eq_char( ch, WEAR_HOLD ) ) == NULL
|| paper->item_type != ITEM_PAPER )
{
paper = create_object( get_obj_index( OBJ_VNUM_NOTE ) );
if( ( tmpobj = get_eq_char( ch, WEAR_HOLD ) ) != NULL )
unequip_char( ch, tmpobj );
paper = obj_to_char( paper, ch );
equip_char( ch, paper, WEAR_HOLD );
act( AT_MAGIC, "$n grabs a message disk.",
ch, NULL, NULL, TO_ROOM );
act( AT_MAGIC, "You get a message disk to record your note.",
ch, NULL, NULL, TO_CHAR );
}
if( paper->value[1] > 1 )
{
send_to_char( "You cannot modify this message.\r\n", ch );
return;
}
else
{
paper->value[1] = 1;
ed = SetOExtra( paper, "_subject_" );
STRFREE( ed->description );
ed->description = STRALLOC( arg_passed );
send_to_char( "Ok.\r\n", ch );
return;
}
}
if( !str_cmp( arg, "to" ) )
{
struct stat fst;
char fname[1024];
if( !arg_passed || arg_passed[0] == '\0' )
{
send_to_char( "Please specify an addressee.\r\n", ch );
return;
}
if( ( paper = get_eq_char( ch, WEAR_HOLD ) ) == NULL
|| paper->item_type != ITEM_PAPER )
{
paper = create_object( get_obj_index( OBJ_VNUM_NOTE ) );
if( ( tmpobj = get_eq_char( ch, WEAR_HOLD ) ) != NULL )
unequip_char( ch, tmpobj );
paper = obj_to_char( paper, ch );
equip_char( ch, paper, WEAR_HOLD );
act( AT_MAGIC, "$n gets a message disk to record a note.",
ch, NULL, NULL, TO_ROOM );
act( AT_MAGIC, "You grab a message disk to record your note.",
ch, NULL, NULL, TO_CHAR );
}
if( paper->value[2] > 1 )
{
send_to_char( "You cannot modify this message.\r\n", ch );
return;
}
arg_passed[0] = UPPER( arg_passed[0] );
sprintf( fname, "%s%c/%s", PLAYER_DIR, tolower( ( int ) arg_passed[0] ),
capitalize( arg_passed ) );
if( !IS_MAIL || stat( fname, &fst ) != -1
|| !str_cmp( arg_passed, "all" ) )
{
paper->value[2] = 1;
ed = SetOExtra( paper, "_to_" );
STRFREE( ed->description );
ed->description = STRALLOC( arg_passed );
send_to_char( "Ok.\r\n", ch );
return;
}
else
{
send_to_char( "No player exists by that name.\r\n", ch );
return;
}
}
if( !str_cmp( arg, "show" ) )
{
const char *subject = "";
const char *to_list = "";
const char *text = "";
if( ( paper = get_eq_char( ch, WEAR_HOLD ) ) == NULL
|| paper->item_type != ITEM_PAPER )
{
send_to_char( "You are not holding a message disk.\r\n", ch );
return;
}
if( ( subject =
get_extra_descr( "_subject_", paper->first_extradesc ) ) == NULL )
subject = "(no subject)";
if( ( to_list =
get_extra_descr( "_to_", paper->first_extradesc ) ) == NULL )
to_list = "(nobody)";
sprintf( buf, "%s: %s\r\nTo: %s\r\n", ch->name, subject, to_list );
send_to_char( buf, ch );
if( ( text =
get_extra_descr( "_text_", paper->first_extradesc ) ) == NULL )
text = "The disk is blank.\r\n";
send_to_char( text, ch );
return;
}
if( !str_cmp( arg, "post" ) )
{
char *strtime = NULL;
const char *text = NULL;
if( ( paper = get_eq_char( ch, WEAR_HOLD ) ) == NULL
|| paper->item_type != ITEM_PAPER )
{
send_to_char( "You are not holding a message disk.\r\n", ch );
return;
}
if( paper->value[0] == 0 )
{
send_to_char( "There is nothing written on this disk.\r\n", ch );
return;
}
if( paper->value[1] == 0 )
{
send_to_char( "This message has no subject... using 'none'.\r\n",
ch );
paper->value[1] = 1;
ed = SetOExtra( paper, "_subject_" );
STRFREE( ed->description );
ed->description = STRALLOC( "none" );
}
if( paper->value[2] == 0 )
{
if( IS_MAIL )
{
send_to_char( "This message is addressed to no one!\r\n", ch );
return;
}
else
{
send_to_char
( "This message is addressed to no one... sending to 'all'!\r\n",
ch );
paper->value[2] = 1;
ed = SetOExtra( paper, "_to_" );
STRFREE( ed->description );
ed->description = STRALLOC( "All" );
}
}
board = find_board( ch );
if( !board )
{
send_to_char
( "There is no terminal here to upload your message to.\r\n",
ch );
return;
}
if( !can_post( ch, board ) )
{
send_to_char
( "You cannot use this terminal. It is encrypted...\r\n", ch );
return;
}
if( board->num_posts >= board->max_posts )
{
send_to_char
( "This terminal is full. There is no room for your message.\r\n",
ch );
return;
}
act( AT_ACTION, "$n uploads a message.", ch, NULL, NULL, TO_ROOM );
strtime = ctime( ¤t_time );
strtime[strlen( strtime ) - 1] = '\0';
CREATE( pnote, NOTE_DATA, 1 );
pnote->date = STRALLOC( strtime );
text = get_extra_descr( "_text_", paper->first_extradesc );
pnote->text = text ? STRALLOC( text ) : STRALLOC( "" );
text = get_extra_descr( "_to_", paper->first_extradesc );
pnote->to_list = text ? STRALLOC( text ) : STRALLOC( "all" );
text = get_extra_descr( "_subject_", paper->first_extradesc );
pnote->subject = text ? STRALLOC( text ) : STRALLOC( "" );
pnote->sender = QUICKLINK( ch->name );
pnote->voting = 0;
pnote->yesvotes = str_dup( "" );
pnote->novotes = str_dup( "" );
pnote->abstentions = str_dup( "" );
LINK( pnote, board->first_note, board->last_note, next, prev );
board->num_posts++;
write_board( board );
send_to_char( "You upload your message to the terminal.\r\n", ch );
extract_obj( paper );
return;
}
if( !str_cmp( arg, "remove" )
|| !str_cmp( arg, "take" ) || !str_cmp( arg, "copy" ) )
{
char take = 0;
board = find_board( ch );
if( !board )
{
send_to_char
( "There is no terminal here to download a note from!\r\n", ch );
return;
}
if( !str_cmp( arg, "take" ) )
take = 1;
else if( !str_cmp( arg, "copy" ) )
{
if( !IS_IMMORTAL( ch ) )
{
send_to_char( "Huh? Type 'help note' for usage.\r\n", ch );
return;
}
take = 2;
}
else
take = 0;
if( !is_number( arg_passed ) )
{
send_to_char( "Note remove which number?\r\n", ch );
return;
}
if( !can_read( ch, board ) )
{
send_to_char
( "You can't make any sense of what's posted here, let alone remove anything!\r\n",
ch );
return;
}
anum = atoi( arg_passed );
vnum = 0;
for( pnote = board->first_note; pnote; pnote = pnote->next )
{
if( IS_MAIL && ( ( is_note_to( ch, pnote ) )
|| IS_IMMORTAL( ch ) ) )
vnum++;
else if( !IS_MAIL )
vnum++;
if( ( !str_cmp( ch->name, pnote->sender )
|| can_remove( ch, board ) ) && ( vnum == anum ) )
{
if( ( is_name( "all", pnote->to_list ) )
&& ( !IS_IMMORTAL( ch ) ) && ( take == 1 ) )
{
send_to_char
( "Notes addressed to 'all' can not be taken.\r\n", ch );
return;
}
if( take != 0 )
{
paper = create_object( get_obj_index( OBJ_VNUM_NOTE ) );
ed = SetOExtra( paper, "_sender_" );
STRFREE( ed->description );
ed->description = QUICKLINK( pnote->sender );
ed = SetOExtra( paper, "_text_" );
STRFREE( ed->description );
ed->description = QUICKLINK( pnote->text );
ed = SetOExtra( paper, "_to_" );
STRFREE( ed->description );
ed->description = QUICKLINK( pnote->to_list );
ed = SetOExtra( paper, "_subject_" );
STRFREE( ed->description );
ed->description = QUICKLINK( pnote->subject );
ed = SetOExtra( paper, "_date_" );
STRFREE( ed->description );
ed->description = QUICKLINK( pnote->date );
ed = SetOExtra( paper, "note" );
STRFREE( ed->description );
sprintf( notebuf, "From: " );
strcat( notebuf, pnote->sender );
strcat( notebuf, "\r\nTo: " );
strcat( notebuf, pnote->to_list );
strcat( notebuf, "\r\nSubject: " );
strcat( notebuf, pnote->subject );
strcat( notebuf, "\r\n\r\n" );
strcat( notebuf, pnote->text );
strcat( notebuf, "\r\n" );
ed->description = STRALLOC( notebuf );
paper->value[0] = 2;
paper->value[1] = 2;
paper->value[2] = 2;
sprintf( short_desc_buf, "a note from %s to %s",
pnote->sender, pnote->to_list );
STRFREE( paper->short_descr );
paper->short_descr = STRALLOC( short_desc_buf );
sprintf( long_desc_buf,
"A note from %s to %s lies on the ground.",
pnote->sender, pnote->to_list );
STRFREE( paper->description );
paper->description = STRALLOC( long_desc_buf );
sprintf( keyword_buf, "note parchment paper %s",
pnote->to_list );
STRFREE( paper->name );
paper->name = STRALLOC( keyword_buf );
}
if( take != 2 )
note_remove( board, pnote );
send_to_char( "Ok.\r\n", ch );
if( take == 1 )
{
act( AT_ACTION, "$n downloads a message.", ch, NULL, NULL,
TO_ROOM );
obj_to_char( paper, ch );
}
else if( take == 2 )
{
act( AT_ACTION, "$n copies a message.", ch, NULL, NULL,
TO_ROOM );
obj_to_char( paper, ch );
}
else
act( AT_ACTION, "$n removes a message.", ch, NULL, NULL,
TO_ROOM );
return;
}
}
send_to_char( "No such message.\r\n", ch );
return;
}
send_to_char( "Huh? Type 'help note' for usage.\r\n", ch );
}
