#include <sys/types.h>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include "merc.h"
#include "room_cmds.h"
DECLARE_DO_FUN( do_look );
extern ROOM_INDEX_DATA *find_location( CHAR_DATA *, char * );
extern char *prog_type_to_name( int type );
/*
* ROOMcommand table.
*/
const struct room_cmd_type room_cmd_table [] =
{
{ "at", do_rpat },
{ "asound", do_rpasound },
{ "gecho", do_rpgecho },
{ "zecho", do_rpzecho },
{ "echo", do_rpecho },
{ "echoaround", do_rpechoaround },
{ "echoat", do_rpechoat },
{ "mload", do_rpmload },
{ "iload", do_rpiload },
{ "oload", do_rpoload },
{ "purge", do_rppurge },
{ "transfer", do_rptransfer },
{ "gtransfer", do_rpgtransfer },
{ "otransfer", do_rpotransfer },
{ "force", do_rpforce },
{ "gforce", do_rpgforce },
{ "vforce", do_rpvforce },
{ "damage", do_rpdamage },
{ "remember", do_rpremember },
{ "forget", do_rpforget },
{ "delay", do_rpdelay },
{ "cancel", do_rpcancel },
{ "call", do_rpcall },
{ "remove", do_rpremove },
{ "", 0 },
};
/*
* ROOMprog section
*/
void do_room( ROOM_INDEX_DATA *room, char *argument )
{
room_interpret( room, argument );
}
/*
* Room command interpreter. Implemented separately for security and speed
* reasons. A trivial hack of interpret()
*/
void room_interpret( ROOM_INDEX_DATA *room, char *argument )
{
char buf[MAX_STRING_LENGTH], command[MAX_INPUT_LENGTH];
int cmd;
argument = one_argument( argument, command );
/*
* Look for command in command table.
*/
for ( cmd = 0; room_cmd_table[cmd].name[0] != '\0'; cmd++ )
{
if ( command[0] == room_cmd_table[cmd].name[0]
&& !str_prefix( command, room_cmd_table[cmd].name ) )
{
(*room_cmd_table[cmd].room_fun) ( room, argument );
tail_chain( );
return;
}
}
sprintf( buf, "Room_interpret: invalid cmd from room %d: '%s'",
room->vnum, command );
bug( buf, 0 );
}
/*
* Displays ROOMprogram triggers of a room
*
* Syntax: rpstat [name]
*/
void do_rpstat( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_STRING_LENGTH ];
PROG_LIST *rprg;
ROOM_INDEX_DATA *room;
int i;
one_argument( argument, arg );
if ( arg[0] == '\0' )
room = ch->in_room;
else if ( !is_number( arg ) )
{
send_to_char( "You must provide a number.\n\r", ch );
return;
}
else if ( ( room = get_room_index( atoi(arg) ) ) == NULL )
{
send_to_char( "No such room.\n\r", ch );
return;
}
ch_printf( ch, "Room #%-6d [%s]\n\r",
room->vnum, room->name );
ch_printf( ch, "Delay %-6d [%s]\n\r",
room->rprog_delay,
room->rprog_target == NULL
? "No target" : room->rprog_target->name );
if ( !room->rprog_flags )
{
send_to_char( "[No programs set]\n\r", ch);
return;
}
for ( i = 0, rprg = room->rprogs; rprg != NULL;
rprg = rprg->next )
{
draw_line(ch, "{W-{x-", 0);
ch_printf(ch, "[%2d] Trigger [%-8s] Program [%4d] Phrase [%s]\n\r Program comments :%s\n\r",
++i,
prog_type_to_name( rprg->trig_type ),
rprg->vnum,
rprg->trig_phrase,
rprg->comments );
}
return;
}
/*
* Displays the source code of a given ROOMprogram
*
* Syntax: rpdump [vnum]
*/
void do_rpdump( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_INPUT_LENGTH ];
PROG_CODE *rprg;
one_argument( argument, buf );
if ( ( rprg = get_prog_index( atoi(buf), PRG_RPROG ) ) == NULL )
{
send_to_char( "No such ROOMprogram.\n\r", ch );
return;
}
page_to_char( rprg->code, ch );
}
/*
* Prints the argument to all active players in the game
*
* Syntax: room gecho [string]
*/
void do_rpgecho( ROOM_INDEX_DATA *room, char *argument )
{
DESCRIPTOR_DATA *d;
if ( argument[0] == '\0' )
{
bug( "RpGEcho: missing argument from vnum %d",
room->vnum );
return;
}
for ( d = descriptor_list; d; d = d->next )
{
if ( d->connected == CON_PLAYING )
{
if ( IS_IMMORTAL(d->character) )
send_to_char( "Room echo> ", d->character );
send_to_char( argument, d->character );
send_to_char( "\n\r", d->character );
}
}
}
/*
* Prints the argument to all players in the same area as the room
*
* Syntax: room zecho [string]
*/
void do_rpzecho( ROOM_INDEX_DATA *room, char *argument )
{
DESCRIPTOR_DATA *d;
if ( argument[0] == '\0' )
{
bug( "RpZEcho: missing argument from vnum %d",
room->vnum );
return;
}
for ( d = descriptor_list; d; d = d->next )
{
if ( d->connected == CON_PLAYING
&& d->character->in_room != NULL
&& d->character->in_room->area == room->area )
{
if ( IS_IMMORTAL(d->character) )
send_to_char( "Room echo> ", d->character );
send_to_char( argument, d->character );
send_to_char( "\n\r", d->character );
}
}
}
/*
* Prints the argument to all the rooms aroud the room
*
* Syntax: room asound [string]
*/
void do_rpasound( ROOM_INDEX_DATA *room, char *argument )
{
int door;
if ( argument[0] == '\0' )
return;
for ( door = 0; door < 6; door++ )
{
EXIT_DATA *pexit;
if ( ( pexit = room->exit[door] ) != NULL
&& pexit->u1.to_room != NULL
&& pexit->u1.to_room != room
&& pexit->u1.to_room->people != NULL )
{
act( argument, pexit->u1.to_room->people, NULL, NULL, TO_ROOM );
act( argument, pexit->u1.to_room->people, NULL, NULL, TO_CHAR );
}
}
return;
}
/*
* Prints the message to everyone in the room other than the victim
*
* Syntax: room echoaround [victim] [string]
*/
void do_rpechoaround( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg );
if ( arg[0] == '\0' )
return;
if ( ( victim=get_char_room( NULL, room, arg ) ) == NULL )
return;
act( argument, victim, NULL, victim, TO_NOTVICT );
}
/*
* Prints the message to only the victim
*
* Syntax: room echoat [victim] [string]
*/
void do_rpechoat( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg );
if ( arg[0] == '\0' || argument[0] == '\0' )
return;
if ( ( victim = get_char_room( NULL, room, arg ) ) == NULL )
return;
act( argument, victim, NULL, NULL, TO_CHAR );
}
/*
* Prints the message to the room at large
*
* Syntax: rpecho [string]
*/
void do_rpecho( ROOM_INDEX_DATA *room, char *argument )
{
if ( argument[0] == '\0' )
return;
if ( !room->people )
return;
act( argument, room->people, NULL, NULL, TO_ROOM );
act( argument, room->people, NULL, NULL, TO_CHAR );
}
/*
* Lets the room load a mobile.
*
* Syntax: room mload [vnum]
*/
void do_rpmload( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
MOB_INDEX_DATA *pMobIndex;
CHAR_DATA *victim;
int vnum;
one_argument( argument, arg );
if ( arg[0] == '\0' || !is_number(arg) )
return;
vnum = atoi(arg);
if ( ( pMobIndex = get_mob_index( vnum ) ) == NULL )
{
sprintf( arg, "Rpmload: bad mob index (%d) from room %d",
vnum, room->vnum );
bug( arg, 0 );
return;
}
victim = create_mobile( pMobIndex );
char_to_room( victim, room );
return;
}
/*
* Lets the room load an object
* JH: 3/8/2004 11:15PM: Bullshit, -required- you to have a level.
* Total gayness.
* Syntax: room oload [vnum] [level]
*/
void do_rpoload( ROOM_INDEX_DATA *room, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
int level;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[0] == '\0' || !is_number( arg1 ))
{
bug( "Rpoload - Bad syntax from vnum %d.",
room->vnum );
return;
}
if ( ( pObjIndex = get_obj_index( atoi( arg1 ) ) ) == NULL )
{
bug( "Rpoload - Bad vnum arg from vnum %d.", room->vnum );
return;
}
if (arg2[0] == '\0' || !is_number( arg2 ))
level = pObjIndex->level;
else
level = atoi( arg2 );
if ( level < 0 || level > LEVEL_IMMORTAL )
{
bug( "Rpoload - Bad level from vnum %d.", room->vnum );
return;
}
obj = create_object( pObjIndex, level );
obj_to_room( obj, room );
return;
}
/*
* Lets the room load an object to someone's inventory
*
* Syntax: room iload [vnum] [person]
*/
void do_rpiload( ROOM_INDEX_DATA *room, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *nobj;
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[0] == '\0' || !is_number( arg1 ) )
{
bug( "Rpiload - Bad syntax from vnum %d.", room->vnum);
return;
}
if ( ( pObjIndex = get_obj_index( atoi( arg1 ) ) ) == NULL )
{
bug( "Rpiload - Bad vnum arg from vnum %d.", room->vnum);
return;
}
if ( ( victim = get_char_room( NULL, room, arg2 ) ) == NULL )
return;
nobj = create_object( pObjIndex, pObjIndex->level );
obj_to_char( nobj, victim );
return;
}
/*
* Lets the room purge all objects npcs in the room,
* or purge a specified object or mob in the room.
*
* syntax room purge {target}
*/
void do_rppurge( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
OBJ_DATA *obj;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
/* 'purge' */
CHAR_DATA *vnext;
OBJ_DATA *obj_next;
for ( victim = room->people; victim != NULL; victim = vnext )
{
vnext = victim->next_in_room;
if ( IS_NPC( victim )
&& !IS_SET(victim->act, ACT_NOPURGE) )
extract_char( victim, TRUE );
}
for ( obj = room->contents; obj != NULL; obj = obj_next )
{
obj_next = obj->next_content;
if ( !IS_SET(obj->extra_flags, ITEM_NOPURGE) )
extract_obj( obj );
}
return;
}
if ( ( victim = get_char_room( NULL, room, arg ) ) == NULL )
{
if ( ( obj = get_obj_here( NULL, room, arg ) ) )
{
extract_obj( obj );
}
else
{
bug( "Rppurge - Bad argument from vnum %d.", room->vnum );
}
return;
}
if ( !IS_NPC( victim ) )
{
bug( "Rppurge - Purging a PC from vnum %d.", room->vnum );
return;
}
extract_char( victim, TRUE );
return;
}
/*
* Lets the room transfer people. The 'all' argument transfers
* everyone in the room to the specified location
*
* Syntax: room transfer [target|'all'] [location]
*/
void do_rptransfer( ROOM_INDEX_DATA *room, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[MAX_STRING_LENGTH];
ROOM_INDEX_DATA *location;
CHAR_DATA *victim;
OBJ_DATA *tobj;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[0] == '\0' )
{
bug( "Rptransfer - Bad syntax from vnum %d.", room->vnum );
return;
}
if ( !str_cmp( arg1, "all" ) )
{
CHAR_DATA *victim_next;
for ( victim = room->people; victim != NULL; victim = victim_next )
{
victim_next = victim->next_in_room;
if ( !IS_NPC(victim) )
{
sprintf( buf, "%s %s", victim->name, arg2 );
do_rptransfer( room, buf );
}
}
return;
}
/*
* Thanks to Grodyn for the optional location parameter.
*/
if ( arg2[0] == '\0' )
{
location = room;
}
else
{
if ( is_number(arg2))
location = get_room_index( atoi(arg2) );
else if ( (victim = get_char_world( NULL, arg2 )) != NULL )
location = victim->in_room;
else if ( ( tobj = get_obj_world( NULL, arg2 )) != NULL )
location = tobj->in_room;
else
{
bug( "Rptransfer - No such location from vnum %d.", room->vnum );
return;
}
if ( room_is_private( location ) )
return;
}
if ( ( victim = get_char_world( NULL, arg1 ) ) == NULL )
return;
if ( victim->in_room == NULL )
return;
if ( victim->fighting != NULL )
stop_fighting( victim, TRUE );
char_from_room( victim );
char_to_room( victim, location );
do_look( victim, "auto" );
return;
}
/*
* Lets the room transfer all chars in same group as the victim.
*
* Syntax: room gtransfer [victim] [location]
*/
void do_rpgtransfer( ROOM_INDEX_DATA *room, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[MAX_STRING_LENGTH];
CHAR_DATA *who, *victim, *victim_next;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[0] == '\0' )
{
bug( "Rpgtransfer - Bad syntax from vnum %d.", room->vnum );
return;
}
if ( (who = get_char_room( NULL, room, arg1 )) == NULL )
return;
for ( victim = room->people; victim; victim = victim_next )
{
victim_next = victim->next_in_room;
if( is_same_group( who,victim ) )
{
sprintf( buf, "%s %s", victim->name, arg2 );
do_rptransfer( room, buf );
}
}
return;
}
/*
* Lets the room force someone to do something. Must be mortal level
* and the all argument only affects those in the room.
*
* Syntax: room force [victim] [commands]
*/
void do_rpforce( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
argument = one_argument( argument, arg );
if ( arg[0] == '\0' || argument[0] == '\0' )
{
bug( "Rpforce - Bad syntax from vnum %d.", room->vnum );
return;
}
if ( !str_cmp( arg, "all" ) )
{
CHAR_DATA *vch;
CHAR_DATA *vch_next;
for ( vch = char_list; vch != NULL; vch = vch_next )
{
vch_next = vch->next;
if ( vch->in_room == room && !IS_IMMORTAL( vch ) )
interpret( vch, argument );
}
}
else
{
CHAR_DATA *victim;
if ( ( victim = get_char_room( NULL, room, arg ) ) == NULL )
return;
interpret( victim, argument );
}
return;
}
/*
* Lets the room force a group something. Must be mortal level.
*
* Syntax: room gforce [victim] [commands]
*/
void do_rpgforce( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim, *vch, *vch_next;
argument = one_argument( argument, arg );
if ( arg[0] == '\0' || argument[0] == '\0' )
{
bug( "RpGforce - Bad syntax from vnum %d.", room->vnum );
return;
}
if ( ( victim = get_char_room( NULL, room, arg ) ) == NULL )
return;
for ( vch = victim->in_room->people; vch != NULL; vch = vch_next )
{
vch_next = vch->next_in_room;
if ( is_same_group(victim,vch) )
interpret( vch, argument );
}
return;
}
/*
* Forces all mobiles of certain vnum to do something
*
* Syntax: room vforce [vnum] [commands]
*/
void do_rpvforce( ROOM_INDEX_DATA *room, char *argument )
{
CHAR_DATA *victim, *victim_next;
char arg[ MAX_INPUT_LENGTH ];
int vnum;
argument = one_argument( argument, arg );
if ( arg[0] == '\0' || argument[0] == '\0' )
{
bug( "RpVforce - Bad syntax from vnum %d.", room->vnum );
return;
}
if ( !is_number( arg ) )
{
bug( "RpVforce - Non-number argument vnum %d.", room->vnum );
return;
}
vnum = atoi( arg );
for ( victim = char_list; victim; victim = victim_next )
{
victim_next = victim->next;
if ( IS_NPC(victim) && victim->pIndexData->vnum == vnum
&& victim->fighting == NULL )
interpret( victim, argument );
}
return;
}
/*
* Lets room cause unconditional damage to someone. Nasty, use with caution.
* Also, this is silent, you must show your own damage message...
*
* Syntax: room damage [victim] [min] [max] {kill}
*/
void do_rpdamage( ROOM_INDEX_DATA *room, char *argument )
{
CHAR_DATA *victim = NULL, *victim_next;
char target[ MAX_INPUT_LENGTH ],
min[ MAX_INPUT_LENGTH ],
max[ MAX_INPUT_LENGTH ];
int low, high;
bool fAll = FALSE, fKill = FALSE;
argument = one_argument( argument, target );
argument = one_argument( argument, min );
argument = one_argument( argument, max );
if ( target[0] == '\0' )
{
bug( "RpDamage - Bad syntax from vnum %d.", room->vnum );
return;
}
if( !str_cmp( target, "all" ) )
fAll = TRUE;
else if( ( victim = get_char_room( NULL, room, target ) ) == NULL )
return;
if ( is_number( min ) )
low = atoi( min );
else
{
bug( "RpDamage - Bad damage min vnum %d.", room->vnum );
return;
}
if ( is_number( max ) )
high = atoi( max );
else
{
bug( "RpDamage - Bad damage max vnum %d.", room->vnum );
return;
}
one_argument( argument, target );
/*
* If kill parameter is omitted, this command is "safe" and will not
* kill the victim.
*/
if ( target[0] != '\0' )
fKill = TRUE;
if ( fAll )
{
for( victim = room->people; victim; victim = victim_next )
{
victim_next = victim->next_in_room;
damage( victim, victim,
fKill ?
number_range(low,high) : UMIN(victim->hit,number_range(low,high)),
TYPE_UNDEFINED, DAM_NONE, FALSE );
}
}
else
damage( victim, victim,
fKill ?
number_range(low,high) : UMIN(victim->hit,number_range(low,high)),
TYPE_UNDEFINED, DAM_NONE, FALSE );
return;
}
/*
* Lets the room remember a target. The target can be referred to
* with $q and $Q codes in ROOMprograms. See also "room forget".
*
* Syntax: room remember [victim]
*/
void do_rpremember( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
one_argument( argument, arg );
if ( arg[0] != '\0' )
room->rprog_target = get_char_world( NULL, arg );
else
bug( "RpRemember: missing argument from vnum %d.", room->vnum );
}
/*
* Reverse of "room remember".
*
* Syntax: room forget
*/
void do_rpforget( ROOM_INDEX_DATA *room, char *argument )
{
room->rprog_target = NULL;
}
/*
* Sets a delay for ROOMprogram execution. When the delay time expires,
* the room is checked for a ROOMprogram with DELAY trigger, and if
* one is found, it is executed. Delay is counted in PULSE_AREA
*
* Syntax: room delay [pulses]
*/
void do_rpdelay( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
one_argument( argument, arg );
if ( !is_number( arg ) )
{
bug( "RpDelay: invalid arg from vnum %d.", room->vnum );
return;
}
room->rprog_delay = atoi( arg );
}
/*
* Reverse of "room delay", deactivates the timer.
*
* Syntax: room cancel
*/
void do_rpcancel( ROOM_INDEX_DATA *room, char *argument )
{
room->rprog_delay = -1;
}
/*
* Lets the room call another ROOMprogram within a ROOMprogram.
* This is a crude way to implement subroutines/functions. Beware of
* nested loops and unwanted triggerings... Stack usage might be a problem.
* Characters and objects referred to must be in the room.
*
* Syntax: room call [vnum] [victim|'null'] [object1|'null'] [object2|'null']
*
*/
void do_rpcall( ROOM_INDEX_DATA *room, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *vch;
OBJ_DATA *obj1, *obj2;
PROG_CODE *prg;
extern void program_flow( sh_int, char *, CHAR_DATA *, OBJ_DATA *, ROOM_INDEX_DATA *, CHAR_DATA *, const void *, const void *, int );
argument = one_argument( argument, arg );
if ( arg[0] == '\0' )
{
bug( "RpCall: missing arguments from vnum %d.", room->vnum );
return;
}
if ( ( prg = get_prog_index( atoi(arg), PRG_RPROG ) ) == NULL )
{
bug( "RpCall: invalid prog from vnum %d.", room->vnum );
return;
}
vch = NULL;
obj1 = obj2 = NULL;
argument = one_argument( argument, arg );
if ( arg[0] != '\0' )
vch = get_char_room( NULL, room, arg );
argument = one_argument( argument, arg );
if ( arg[0] != '\0' )
obj1 = get_obj_here( NULL, room, arg );
argument = one_argument( argument, arg );
if ( arg[0] != '\0' )
obj2 = get_obj_here( NULL, room, arg );
program_flow( prg->vnum, prg->code, NULL, NULL, room, vch, (void *)obj1, (void *)obj2, 1 );
}
/*
* Lets the room transfer an object. The object must be in the room.
*
* Syntax: room otransfer [item name] [location]
*/
void do_rpotransfer( ROOM_INDEX_DATA *room, char *argument )
{
OBJ_DATA *obj, *tobj;
ROOM_INDEX_DATA *location;
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg );
if ( arg[0] == '\0' )
{
bug( "RpOTransfer - Missing argument from vnum %d.", room->vnum );
return;
}
one_argument( argument, buf );
if ( is_number( buf ) )
location = get_room_index( atoi(buf) );
else if ( (victim = get_char_world( NULL, buf )) != NULL )
location = victim->in_room;
else if ( ( tobj = get_obj_world( NULL, arg )) != NULL )
location = tobj->in_room;
else
{
bug( "RpOTransfer - No such location from vnum %d.", room->vnum );
return;
}
if ( (obj = get_obj_here( NULL, room, arg )) == NULL )
return;
if ( obj->carried_by == NULL )
obj_from_room( obj );
else
{
if ( obj->wear_loc != WEAR_NONE )
unequip_char( obj->carried_by, obj );
obj_from_char( obj );
}
obj_to_room( obj, location );
}
/*
* Lets the room strip an object or all objects from the victim.
* Useful for removing e.g. quest objects from a character.
*
* Syntax: room remove [victim] [object vnum|'all']
*/
void do_rpremove( ROOM_INDEX_DATA *room, char *argument )
{
CHAR_DATA *victim;
OBJ_DATA *obj, *obj_next;
sh_int vnum = 0;
bool fAll = FALSE;
char arg[ MAX_INPUT_LENGTH ];
argument = one_argument( argument, arg );
if ( ( victim = get_char_room( NULL, room, arg ) ) == NULL )
return;
one_argument( argument, arg );
if ( !str_cmp( arg, "all" ) )
fAll = TRUE;
else if ( !is_number( arg ) )
{
bug ( "RpRemove: Invalid object from vnum %d.", room->vnum );
return;
}
else
vnum = atoi( arg );
for ( obj = victim->carrying; obj; obj = obj_next )
{
obj_next = obj->next_content;
if ( fAll || obj->pIndexData->vnum == vnum )
{
unequip_char( victim, obj );
obj_from_char( obj );
extract_obj( obj );
}
}
}
/*
* Lets a room do a command at another location.
* JH 3/2/2004 6:27PM
* Syntax: room at [location] [commands]
*/
void do_rpat( ROOM_INDEX_DATA *room, char *argument )
{
char arg[MIL];
ROOM_INDEX_DATA *location;
argument = one_argument( argument, arg );
if ( arg[0] == '\0' || argument[0] == '\0' )
{
bug( "RPat - Bad argument from vnum %d.", room->vnum);
return;
}
if ( ( location = find_location( NULL, arg ) ) == NULL )
{
bug( "RPat - Bad argument from vnum %d.", room->vnum);
return;
}
/*Dump the 'room' prefix, if applicable. Eg. room at 1430 room echo <whatever>*/
if (!str_prefix("room", argument))
argument = one_argument( argument, arg );
else
argument = argument;
room_interpret( location, argument );
return;
}