/***************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
*
* Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael *
* Chastain, Michael Quan, and Mitchell Tse. *
* *
* In order to use any part of this Merc Diku Mud, you must comply with *
* both the original Diku license in 'license.doc' as well the Merc *
* license in 'license.txt'. In particular, you may not remove either of *
* these copyright notices. *
* *
* Much time and thought has gone into this software and you are *
* benefitting. We hope that you share your changes too. What goes *
* around, comes around. *
***************************************************************************/
#include <glib.h>
#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <merc.h>
#include <tables.h>
#include <recycle.h>
#include <interp.h>
#include <olc.h>
#include <string>
#include <fstream>
#include <iomanip>
#include <iostream>
extern bool merc_down;
extern int top_rt;
extern void destroy_memory_chunck args( () );
/*
* Local functions.
*/
ROOM_INDEX_DATA * find_location args( ( CHAR_DATA *ch, char *arg ) );
void call_all args( ( CHAR_DATA *ch ) );
void remove_snooper args( ( CHAR_DATA *ch, CHAR_DATA *target ) );
void do_wizhelp( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
int cmd;
int col;
int level;
for ( level = get_trust( ch ) ; level >= LEVEL_IMMORTAL ; level-- )
{
sprintf( buf, "{r----------------------------------- {WLevel %2d {r-----------------------------------{x\n\r", level );
send_to_char( buf, ch );
col = 0;
for ( cmd = 0; cmd_table[ cmd ].name[ 0 ] != '\0'; cmd++ )
{
if ( cmd_table[ cmd ].level == level )
{
sprintf( buf, "%-12s", cmd_table[ cmd ].name );
send_to_char( buf, ch );
if ( ++col % 6 == 0 )
send_to_char( "\n\r", ch );
}
}
if ( col % 6 != 0 )
send_to_char( "\n\r", ch );
}
return ;
}
void do_bamfin( CHAR_DATA *ch, char *argument )
{
if ( !IS_NPC( ch ) )
{
smash_tilde( argument );
ch->pcdata->bamfin = g_string_assign( ch->pcdata->bamfin, argument );
send_to_char( "Ok.\n\r", ch );
}
return ;
}
void do_bamfout( CHAR_DATA *ch, char *argument )
{
if ( !IS_NPC( ch ) )
{
smash_tilde( argument );
ch->pcdata->bamfout = g_string_assign( ch->pcdata->bamfout, argument );
send_to_char( "Ok.\n\r", ch );
}
return ;
}
void do_summon( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
one_argument( argument, arg );
if ( IS_NPC( ch ) )
return ;
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Do you wish to switch summon ON or OFF?\n\r", ch );
return ;
}
if ( IS_IMMUNE( ch, IMM_SUMMON ) && !str_cmp( arg, "off" ) )
{
REMOVE_BIT( ch->immune, IMM_SUMMON );
send_to_char( "You can no longer be the target of summon and portal.\n\r", ch );
}
else if ( !IS_IMMUNE( ch, IMM_SUMMON ) && !str_cmp( arg, "off" ) )
{
send_to_char( "But it is already off!\n\r", ch );
return ;
}
else if ( !IS_IMMUNE( ch, IMM_SUMMON ) && !str_cmp( arg, "on" ) )
{
SET_BIT( ch->immune, IMM_SUMMON );
send_to_char( "You can now be the target of summon and portal.\n\r", ch );
}
else if ( IS_IMMUNE( ch, IMM_SUMMON ) && !str_cmp( arg, "on" ) )
{
send_to_char( "But it is already on!\n\r", ch );
return ;
}
else
send_to_char( "Do you wish to switch it ON or OFF?\n\r", ch );
return ;
}
void do_transport( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
one_argument( argument, arg );
if ( IS_NPC( ch ) )
return ;
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Do you wish to switch transport ON or OFF?\n\r", ch );
return ;
}
if ( IS_IMMUNE( ch, IMM_TRANSPORT ) && !str_cmp( arg, "off" ) )
{
REMOVE_BIT( ch->immune, IMM_TRANSPORT );
send_to_char( "You can no longer be the target of transport spells.\n\r", ch );
}
else if ( !IS_IMMUNE( ch, IMM_TRANSPORT ) && !str_cmp( arg, "off" ) )
{
send_to_char( "But it is already off!\n\r", ch );
return ;
}
else if ( !IS_IMMUNE( ch, IMM_TRANSPORT ) && !str_cmp( arg, "on" ) )
{
SET_BIT( ch->immune, IMM_TRANSPORT );
send_to_char( "You can now be the target of transport spells.\n\r", ch );
}
else if ( IS_IMMUNE( ch, IMM_TRANSPORT ) && !str_cmp( arg, "on" ) )
{
send_to_char( "But it is already on!\n\r", ch );
return ;
}
else
send_to_char( "Do you wish to switch it ON or OFF?\n\r", ch );
return ;
}
void do_watcher( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
one_argument( argument, arg );
if ( IS_NPC( ch ) || !IS_SET( ch->act, PLR_WATCHER )
|| ( ch->level > 6 )
|| ( ch->level < 2 )
|| ( ch->trust > 0 ) )
{
send_to_char( "Huh?\n\r", ch );
return ;
}
if ( arg[ 0 ] == '\0' )
{
do_users( ch, "" );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( ch == victim )
{
send_to_char( "Not on yourself.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( victim->desc->snoop_by != NULL )
{
send_to_char( "You better not, they are being snooped.\n\r", ch );
return ;
}
SET_BIT( victim->act, PLR_WATCHER );
act( "$n has made you a watcher.", ch, NULL, victim, TO_VICT );
act( "You make $N a watcher.", ch, NULL, victim, TO_CHAR );
return ;
}
void do_deny( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
char buf[ MAX_STRING_LENGTH ];
sprintf( buf, "%s: Deny %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Deny whom?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "You failed.\n\r", ch );
return ;
}
SET_BIT( victim->act, PLR_DENY );
send_to_char( "You are denied access!\n\r", victim );
send_to_char( "OK.\n\r", ch );
do_quit( victim, "" );
return ;
}
void do_disconnect( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
DESCRIPTOR_DATA *d;
CHAR_DATA *victim;
GSList *desc_list;
sprintf( buf, "%s: Disconnect %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Disconnect whom?\n\r", ch );
return ;
}
/* Disco by Number - Rom Style - Spiral */
if ( is_number( arg ) )
{
int desc;
desc = atoi( arg );
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->descriptor == desc )
{
close_socket( d );
send_to_char( "Ok.\n\r", ch );
return ;
}
}
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( victim->desc == NULL )
{
act( "$N doesn't have a descriptor.", ch, NULL, victim, TO_CHAR );
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d == victim->desc )
{
close_socket( d );
send_to_char( "Ok.\n\r", ch );
return ;
}
}
bug( "Do_disconnect: desc not found.", 0 );
send_to_char( "Descriptor not found!\n\r", ch );
return ;
}
void do_info( CHAR_DATA *ch, char *argument )
{
DESCRIPTOR_DATA * d;
char buf[ MAX_STRING_LENGTH ];
GSList *desc_list;
if ( argument[ 0 ] == '\0' )
{
send_to_char( "What do you want the town crier to shout?\n\r", ch );
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING &&
!IS_SET( d->character->deaf, CHANNEL_INFO ) )
{
sprintf( buf, "\n\r{Ra town crier shouts 'I just saw that %s'{x\n\r", argument );
send_to_char( buf, d->character );
}
}
return ;
}
void play_wave( int wavnum )
{
DESCRIPTOR_DATA * d;
char buf[ MAX_STRING_LENGTH ];
GSList *desc_list;
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING &&
IS_SET( d->character->deaf, CHANNEL_MSP ) )
{
sprintf( buf, "\n\r!!SOUND(%s T=sound L=1 V=100 U=http://%s%s )\n\r", msp_general_table[ wavnum ].msp_string, msp_general_table[ wavnum ].msp_server, msp_general_table[ wavnum ].msp_dirinfo );
send_to_char( buf, d->character );
}
}
return ;
}
void do_gen_info( char *argument )
{
DESCRIPTOR_DATA * d;
char buf[ MSL ];
GSList *desc_list;
if ( argument[ 0 ] == '\0' )
{
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING &&
!IS_SET( d->character->deaf, CHANNEL_INFO ) )
{
sprintf( buf, "\n\r{Ra town crier shouts 'I just saw that %s %s!'\n\r", d->character->name->str, argument );
send_to_char( buf, d->character );
}
}
return ;
}
void do_watching( CHAR_DATA *ch, char *argument )
{
DESCRIPTOR_DATA * d;
GSList *desc_list;
if ( argument[ 0 ] == '\0' )
{
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING &&
IS_SET( d->character->act, PLR_WATCHER ) &&
!IS_SET( d->character->deaf, CHANNEL_INFO ) )
{
send_to_char( "Monitor -> ", d->character );
send_to_char( argument, d->character );
send_to_char( "\n\r", d->character );
}
}
return ;
}
void do_wiznet( CHAR_DATA *ch, char *argument )
{
int flag;
char buf[ MAX_STRING_LENGTH ];
if ( argument[ 0 ] == '\0' )
{
if ( IS_SET( ch->pcdata->wiznet, WIZ_ON ) )
{
send_to_char( "{WSigning off of Wiznet.{x\n\r", ch );
REMOVE_BIT( ch->pcdata->wiznet, WIZ_ON );
}
else
{
send_to_char( "{WWelcome to Wiznet!{x\n\r", ch );
SET_BIT( ch->pcdata->wiznet, WIZ_ON );
}
return ;
}
if ( !str_prefix( argument, "on" ) )
{
send_to_char( "{WWelcome to Wiznet!{x\n\r", ch );
SET_BIT( ch->pcdata->wiznet, WIZ_ON );
return ;
}
if ( !str_prefix( argument, "off" ) )
{
send_to_char( "{WSigning off of Wiznet.{x\n\r", ch );
REMOVE_BIT( ch->pcdata->wiznet, WIZ_ON );
return ;
}
/* show wiznet status */
if ( !str_prefix( argument, "status" ) )
{
buf[ 0 ] = '\0';
if ( !IS_SET( ch->pcdata->wiznet, WIZ_ON ) )
strcat( buf, "off " );
for ( flag = 0; wiznet_table[ flag ].name != NULL; flag++ )
if ( IS_SET( ch->pcdata->wiznet, wiznet_table[ flag ].flag ) )
{
strcat( buf, wiznet_table[ flag ].name );
strcat( buf, " " );
}
strcat( buf, "\n\r" );
send_to_char( "Wiznet status:\n\r", ch );
send_to_char( buf, ch );
return ;
}
if ( !str_prefix( argument, "show" ) )
/* list of all wiznet options */
{
buf[ 0 ] = '\0';
for ( flag = 0; wiznet_table[ flag ].name != NULL; flag++ )
{
if ( wiznet_table[ flag ].level <= get_trust( ch ) )
{
strcat( buf, wiznet_table[ flag ].name );
strcat( buf, " " );
}
}
strcat( buf, "\n\r" );
send_to_char( "Wiznet options available to you are:\n\r", ch );
send_to_char( buf, ch );
return ;
}
flag = wiznet_lookup( argument );
if ( flag == -1 || get_trust( ch ) < wiznet_table[ flag ].level )
{
send_to_char( "No such option.\n\r", ch );
return ;
}
if ( IS_SET( ch->pcdata->wiznet, wiznet_table[ flag ].flag ) )
{
sprintf( buf, "You will no longer see %s on wiznet.\n\r",
wiznet_table[ flag ].name );
send_to_char( buf, ch );
REMOVE_BIT( ch->pcdata->wiznet, wiznet_table[ flag ].flag );
return ;
}
else
{
sprintf( buf, "You will now see %s on wiznet.\n\r",
wiznet_table[ flag ].name );
send_to_char( buf, ch );
SET_BIT( ch->pcdata->wiznet, wiznet_table[ flag ].flag );
return ;
}
}
void do_echo( CHAR_DATA *ch, char *argument )
{
DESCRIPTOR_DATA * d;
char buf[ MAX_STRING_LENGTH ];
GSList *desc_list;
if ( ch != NULL )
{
sprintf( buf, "%s: Echo %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
}
if ( argument[ 0 ] == '\0' )
{
send_to_char( "Echo what?\n\r", ch );
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING )
{
send_to_char( argument, d->character );
send_to_char( "\n\r", d->character );
}
}
return ;
}
void do_recho( CHAR_DATA *ch, char *argument )
{
DESCRIPTOR_DATA * d;
char buf[ MAX_STRING_LENGTH ];
GSList *desc_list;
sprintf( buf, "%s: Recho %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
if ( argument[ 0 ] == '\0' )
{
send_to_char( "Recho what?\n\r", ch );
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING
&& d->character->in_room == ch->in_room )
{
send_to_char( argument, d->character );
send_to_char( "\n\r", d->character );
}
}
return ;
}
ROOM_INDEX_DATA *find_location( CHAR_DATA *ch, char *arg )
{
CHAR_DATA * victim;
OBJ_DATA *obj;
if ( is_number( arg ) && atoi( arg ) != 30008 )
return get_room_index( atoi( arg ) );
if ( ( victim = get_char_world( ch, arg ) ) != NULL )
return victim->in_room;
if ( ( obj = get_obj_world( ch, arg ) ) != NULL && obj->in_room != NULL )
return obj->in_room;
if ( obj != NULL && obj->carried_by != NULL && obj->carried_by->in_room != NULL )
return obj->carried_by->in_room;
if ( obj != NULL && obj->in_obj != NULL && obj->in_obj->in_room != NULL )
return obj->in_obj->in_room;
if ( obj != NULL && obj->in_obj != NULL && obj->in_obj->carried_by && obj->in_obj->carried_by->in_room != NULL )
return obj->in_obj->carried_by->in_room;
return NULL;
}
void do_transfer( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
ROOM_INDEX_DATA *location;
DESCRIPTOR_DATA *d;
CHAR_DATA *victim;
CHAR_DATA *mount;
GSList *desc_list;
sprintf( buf, "%s: Transfer %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Transfer whom (and where)?\n\r", ch );
return ;
}
if ( !str_cmp( arg1, "all" ) )
{
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING
&& d->character != ch
&& d->character->in_room != NULL
&& can_see( ch, d->character ) )
{
char buf[ MAX_STRING_LENGTH ];
sprintf( buf, "%s %s", d->character->name->str, arg2 );
do_transfer( ch, buf );
}
}
return ;
}
/*
* Thanks to Grodyn for the optional location parameter.
*/
if ( arg2[ 0 ] == '\0' )
{
location = ch->in_room;
}
else
{
if ( ( location = find_location( ch, arg2 ) ) == NULL )
{
send_to_char( "No such location.\n\r", ch );
return ;
}
if ( room_is_private( location ) )
{
send_to_char( "That room is private right now.\n\r", ch );
return ;
}
}
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( victim->in_room == NULL )
{
send_to_char( "They are in limbo.\n\r", ch );
return ;
}
if ( victim->fighting != NULL )
stop_fighting( victim, TRUE );
act( "$n disappears in a mushroom cloud.", victim, NULL, NULL, TO_ROOM );
char_from_room( victim );
char_to_room( victim, location );
act( "$n arrives from a puff of smoke.", victim, NULL, NULL, TO_ROOM );
if ( ch != victim )
act( "$n has transferred you.", ch, NULL, victim, TO_VICT );
do_look( victim, "auto" );
send_to_char( "Ok.\n\r", ch );
if ( ( mount = victim->mount ) == NULL )
return ;
char_from_room( mount );
char_to_room( mount, get_room_index( victim->in_room->vnum ) );
if ( ch != mount )
act( "$n has transferred you.", ch, NULL, mount, TO_VICT );
do_look( mount, "auto" );
}
void do_at( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
ROOM_INDEX_DATA *location;
ROOM_INDEX_DATA *original;
CHAR_DATA *wch;
sprintf( buf, "%s: At %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
argument = one_argument( argument, arg );
if ( arg[ 0 ] == '\0' || argument[ 0 ] == '\0' )
{
send_to_char( "At where what?\n\r", ch );
return ;
}
if ( ( location = find_location( ch, arg ) ) == NULL )
{
send_to_char( "No such location.\n\r", ch );
return ;
}
if ( room_is_private( location ) )
{
send_to_char( "That room is private right now.\n\r", ch );
return ;
}
original = ch->in_room;
char_from_room( ch );
char_to_room( ch, location );
interpret( ch, argument );
/*
* See if 'ch' still exists before continuing!
* Handles 'at XXXX quit' case.
*/
for ( wch = char_list; wch != NULL; wch = wch->next )
{
if ( wch == ch )
{
char_from_room( ch );
char_to_room( ch, original );
break;
}
}
mudsetting->last_proc_logged = 10;
return ;
}
void do_goto( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
ROOM_INDEX_DATA *location;
CHAR_DATA *mount;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Goto where?\n\r", ch );
return ;
}
if ( ( location = find_location( ch, arg ) ) == NULL )
{
send_to_char( "No such location.\n\r", ch );
return ;
}
if ( room_is_private( location ) )
{
send_to_char( "That room is private right now.\n\r", ch );
return ;
}
if ( ch->fighting != NULL )
stop_fighting( ch, TRUE );
if ( !IS_SET( ch->act, PLR_WIZINVIS ) )
{
act( "$n $T.", ch, NULL,
( ch->pcdata != NULL && ch->pcdata->bamfout->str[ 0 ] != '\0' )
? ch->pcdata->bamfout->str : "leaves in a swirling mist", TO_ROOM );
}
char_from_room( ch );
char_to_room( ch, location );
if ( !IS_SET( ch->act, PLR_WIZINVIS ) )
{
act( "$n $T.", ch, NULL,
( ch->pcdata != NULL && ch->pcdata->bamfin->str[ 0 ] != '\0' )
? ch->pcdata->bamfin->str : "appears in a swirling mist", TO_ROOM );
}
do_look( ch, "auto" );
if ( ( mount = ch->mount ) == NULL )
return ;
char_from_room( mount );
char_to_room( mount, ch->in_room );
do_look( mount, "auto" );
return ;
}
void do_rstat( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
ROOM_INDEX_DATA *location;
OBJ_DATA *obj;
CHAR_DATA *rch;
int door;
one_argument( argument, arg );
location = ( arg[ 0 ] == '\0' ) ? ch->in_room : find_location( ch, arg );
if ( location == NULL )
{
send_to_char( "No such location.\n\r", ch );
return ;
}
if ( ch->in_room != location && room_is_private( location ) )
{
send_to_char( "That room is private right now.\n\r", ch );
return ;
}
sprintf( buf, "Name: '%s.'\n\rArea: '%s'.\n\r",
location->name,
location->area->name );
send_to_char( buf, ch );
sprintf( buf,
"Vnum: %d. Sector: %d. Light: %d.\n\r",
location->vnum,
location->sector_type,
location->light );
send_to_char( buf, ch );
sprintf( buf,
"Room flags: %d.\n\rDescription:\n\r%s",
location->room_flags,
location->description );
send_to_char( buf, ch );
if ( location->extra_descr != NULL )
{
EXTRA_DESCR_DATA * ed;
send_to_char( "Extra description keywords: '", ch );
for ( ed = location->extra_descr; ed; ed = ed->next )
{
send_to_char( ed->keyword, ch );
if ( ed->next != NULL )
send_to_char( " ", ch );
}
send_to_char( "'.\n\r", ch );
}
send_to_char( "Characters:", ch );
for ( rch = location->people; rch; rch = rch->next_in_room )
{
send_to_char( " ", ch );
one_argument( rch->name->str, buf );
send_to_char( buf, ch );
}
send_to_char( ".\n\rObjects: ", ch );
for ( obj = location->contents; obj; obj = obj->next_content )
{
send_to_char( " ", ch );
one_argument( obj->name->str, buf );
send_to_char( buf, ch );
}
send_to_char( ".\n\r", ch );
for ( door = 0; door <= 5; door++ )
{
EXIT_DATA *pexit;
if ( ( pexit = location->exit[ door ] ) != NULL )
{
sprintf( buf,
"Door: %d. To: %d. Key: %d. Exit flags: %d.\n\rKeyword: '%s'. Description: %s",
door,
pexit->to_room != NULL ? pexit->to_room->vnum : 0,
pexit->key,
pexit->exit_info,
pexit->keyword,
pexit->description[ 0 ] != '\0'
? pexit->description : "(none).\n\r" );
send_to_char( buf, ch );
}
}
return ;
}
void do_ostat( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
char nm1[ 40 ];
char nm2[ 40 ];
AFFECT_DATA *paf;
OBJ_DATA *obj;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Ostat what?\n\r", ch );
return ;
}
if ( ( obj = get_obj_world( ch, arg ) ) == NULL )
{
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
if ( obj->questmaker != NULL && obj->questmaker->len > 1 )
sprintf( nm1, obj->questmaker->str );
else
sprintf( nm1, "None" );
if ( obj->questowner != NULL && obj->questowner->len > 1 )
sprintf( nm2, obj->questowner->str );
else
sprintf( nm2, "None" );
sprintf( buf, "Name: %s.\n\r",
obj->name->str );
send_to_char( buf, ch );
sprintf( buf, "Vnum: %d. Type: %s.\n\r",
obj->pIndexData->vnum, item_type_name( obj ) );
send_to_char( buf, ch );
sprintf( buf, "Short description: %s.\n\rLong description: %s\n\r",
obj->short_descr->str, obj->description->str );
send_to_char( buf, ch );
sprintf( buf, "Object creator: %s. OOwner: %s Object owner: %s. Quest points: %d.\n\r", nm1, obj->OOwner->str[ 0 ] == '\0' ? "(none)" : obj->OOwner->str, nm2, obj->points );
send_to_char( buf, ch );
if ( obj->quest != 0 )
{
send_to_char( "Quest selections:", ch );
if ( IS_SET( obj->quest, QUEST_STR ) )
send_to_char( " Str", ch );
if ( IS_SET( obj->quest, QUEST_DEX ) )
send_to_char( " Dex", ch );
if ( IS_SET( obj->quest, QUEST_INT ) )
send_to_char( " Int", ch );
if ( IS_SET( obj->quest, QUEST_WIS ) )
send_to_char( " Wis", ch );
if ( IS_SET( obj->quest, QUEST_CON ) )
send_to_char( " Con", ch );
if ( IS_SET( obj->quest, QUEST_HIT ) )
send_to_char( " Hp", ch );
if ( IS_SET( obj->quest, QUEST_MANA ) )
send_to_char( " Mana", ch );
if ( IS_SET( obj->quest, QUEST_MOVE ) )
send_to_char( " Move", ch );
if ( IS_SET( obj->quest, QUEST_HITROLL ) )
send_to_char( " Hit", ch );
if ( IS_SET( obj->quest, QUEST_DAMROLL ) )
send_to_char( " Dam", ch );
if ( IS_SET( obj->quest, QUEST_AC ) )
send_to_char( " Ac", ch );
if ( IS_SET( obj->quest, QUEST_ARTIFACT ) )
send_to_char( " Arti", ch );
send_to_char( ".\n\r", ch );
}
sprintf( buf, "Wear bits: %d. Extra bits: %s.\n\r",
obj->wear_flags, extra_bit_name( obj->extra_flags ) );
send_to_char( buf, ch );
sprintf( buf, "Weight: %d/%d.\n\r",
obj->weight, get_obj_weight( obj ) );
send_to_char( buf, ch );
sprintf( buf, "Cost: %d. Timer: %d. Level: %d.\n\r",
obj->cost, obj->timer, obj->level );
send_to_char( buf, ch );
sprintf( buf,
"In room: %d. In object: %s. Carried by: %s. Wear_loc: %d.\n\r",
obj->in_room == NULL ? 0 : obj->in_room->vnum,
obj->in_obj == NULL ? "(none)" : obj->in_obj->short_descr->str,
obj->carried_by == NULL ? "(none)" : obj->carried_by->name->str,
obj->wear_loc );
send_to_char( buf, ch );
sprintf( buf, "Values: %d %d %d %d.\n\r",
obj->value[ 0 ], obj->value[ 1 ], obj->value[ 2 ], obj->value[ 3 ] );
send_to_char( buf, ch );
if ( obj->extra_descr != NULL || obj->pIndexData->extra_descr != NULL )
{
EXTRA_DESCR_DATA * ed;
send_to_char( "Extra description keywords: '", ch );
for ( ed = obj->extra_descr; ed != NULL; ed = ed->next )
{
send_to_char( ed->keyword, ch );
if ( ed->next != NULL )
send_to_char( " ", ch );
}
for ( ed = obj->pIndexData->extra_descr; ed != NULL; ed = ed->next )
{
send_to_char( ed->keyword, ch );
if ( ed->next != NULL )
send_to_char( " ", ch );
}
send_to_char( "'.\n\r", ch );
}
for ( paf = obj->affected; paf != NULL; paf = paf->next )
{
sprintf( buf, "Affects %s by %d.\n\r",
affect_loc_name( paf->location ), paf->modifier );
send_to_char( buf, ch );
}
for ( paf = obj->pIndexData->affected; paf != NULL; paf = paf->next )
{
sprintf( buf, "Affects %s by %d.\n\r",
affect_loc_name( paf->location ), paf->modifier );
send_to_char( buf, ch );
}
return ;
}
void do_mstat( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
AFFECT_DATA *paf;
CHAR_DATA *victim;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Mstat whom?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
sprintf( buf, "Name: %s.\n\r",
victim->name->str );
send_to_char( buf, ch );
sprintf( buf, "Vnum: %d. Sex: %s. Room: %d.\n\r",
IS_NPC( victim ) ? victim->pIndexData->vnum : 0,
victim->sex == SEX_MALE ? "male" :
victim->sex == SEX_FEMALE ? "female" : "neutral",
victim->in_room == NULL ? 0 : victim->in_room->vnum
);
send_to_char( buf, ch );
sprintf( buf, "Str: %d. Int: %d. Wis: %d. Dex: %d. Con: %d.\n\r",
get_curr_str( victim ),
get_curr_int( victim ),
get_curr_wis( victim ),
get_curr_dex( victim ),
get_curr_con( victim ) );
send_to_char( buf, ch );
sprintf( buf, "Hp: %d/%d. Mana: %d/%d. Move: %d/%d. Primal: %d.\n\r",
victim->hit, victim->max_hit,
victim->mana, victim->max_mana,
victim->move, victim->max_move,
victim->practice );
send_to_char( buf, ch );
sprintf( buf,
"Lv: %d. Align: %d. AC: %d. Gold: %d. Exp: %d.\n\r",
victim->level, victim->alignment,
char_ac( victim ), victim->gold, victim->exp );
send_to_char( buf, ch );
sprintf( buf, "Hitroll: %d. Damroll: %d. Position: %d. Wimpy: %d.\n\r",
char_hitroll( victim ), char_damroll( victim ),
victim->position, victim->wimpy );
send_to_char( buf, ch );
sprintf( buf, "Fighting: %s.\n\r",
victim->fighting ? victim->fighting->name->str : "(none)" );
send_to_char( buf, ch );
if (IS_NPC(victim))
{
sprintf(buf,"Killed: %d\n\r",victim->pIndexData->killed);
send_to_char(buf,ch);
}
if ( !IS_NPC( victim ) )
{
sprintf( buf,
"Thirst: %d. Full: %d. Drunk: %d. Saving throw: %d.\n\r",
victim->pcdata->condition[ COND_THIRST ],
victim->pcdata->condition[ COND_FULL ],
victim->pcdata->condition[ COND_DRUNK ],
victim->saving_throw );
send_to_char( buf, ch );
if ( IS_CLASS( victim, CLASS_VAMPIRE ) || IS_CLASS( victim, CLASS_WEREWOLF ) )
{
if ( victim->clan > CLAN_NONE )
sprintf( buf, "Clan: %s. ", iclan_table[ victim->clan ].pretty_name );
else
sprintf( buf, "Clan: None. " );
send_to_char( buf, ch );
sprintf( buf, "Rage: %d. ", victim->pcdata->stats[ UNI_RAGE ] );
send_to_char( buf, ch );
if ( IS_CLASS( victim, CLASS_VAMPIRE ) )
{
sprintf( buf, "Beast: %d. ", victim->beast );
send_to_char( buf, ch );
sprintf( buf, "Blood: %d.", victim->pcdata->condition[ COND_THIRST ] );
send_to_char( buf, ch );
}
send_to_char( "\n\r", ch );
}
}
sprintf( buf, "Carry number: %d. Carry weight: %d.\n\r",
victim->carry_number, victim->carry_weight );
send_to_char( buf, ch );
sprintf( buf, "Age: %d. Played: %d. Timer: %d.\n\r",
get_age( victim ), ( int ) victim->played, victim->timer );
send_to_char( buf, ch );
sprintf( buf, "{bAct: {C%s{x\n\r", act_bit_name( victim->act ) );
send_to_char( buf, ch );
sprintf( buf, "{bStance: {C%s{x\n\r", fight_bit_name( victim->mob_fight ) );
send_to_char( buf, ch );
sprintf( buf, "{bAdded: {C%s{x\n\r", added_bit_name( victim->added ) );
send_to_char( buf, ch );
if ( IS_SET( victim->act, PLR_ATTACK ) )
{
sprintf( buf, "Attack: {Y%s{x\n\r", attack_bit_name( victim->pk_sect ) );
send_to_char( buf, ch );
}
sprintf( buf, "{bSpaffect: {C%s{x\n\r", spaffect_bit_name( victim->sphere_spaffect ) );
send_to_char( buf, ch );
if ( !IS_NPC( victim ) )
{
sprintf( buf, "{bComm: {C%s{x\n\r", comm_bit_name( victim->pcdata->comm ) );
send_to_char( buf, ch );
}
sprintf( buf, "Master: %s. Leader: %s. Affected by: %s.\n\r",
victim->master ? victim->master->name->str : "(none)",
victim->leader ? victim->leader->name->str : "(none)",
affect_bit_name( victim->affected_by ) );
send_to_char( buf, ch );
sprintf( buf, "Short description: %s.\n\rLong description: %s",
victim->short_descr->str,
victim->long_descr->str[ 0 ] != '\0' ? victim->long_descr->str : "(none).\n\r" );
send_to_char( buf, ch );
if ( IS_NPC( victim ) && victim->spec_fun != 0 )
send_to_char( "Mobile has spec fun.\n\r", ch );
for ( paf = victim->affected; paf != NULL; paf = paf->next )
{
sprintf( buf,
"Spell: '%s' modifies %s by %d for %d hours with bits %s.\n\r",
skill_table[ ( int ) paf->type ].name,
affect_loc_name( paf->location ),
paf->modifier,
paf->duration,
affect_bit_name( paf->bitvector )
);
send_to_char( buf, ch );
}
return ;
}
int get_mvnum_count( int vnum )
{
CHAR_DATA * wch;
int count = 0;
for ( wch = char_list;wch != NULL; wch = wch->next )
{
if ( IS_NPC( wch ) && wch->pIndexData->vnum == vnum )
count++;
}
return count;
}
void do_mfind( CHAR_DATA *ch, char *argument )
{
extern int top_mob_index;
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
MOB_INDEX_DATA *pMobIndex;
int vnum;
int nMatch;
bool fAll;
bool found;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Mfind whom?\n\r", ch );
return ;
}
fAll = !str_cmp( arg, "all" );
found = FALSE;
nMatch = 0;
/*
* Yeah, so iterating over all vnum's takes 10,000 loops.
* Get_mob_index is fast, and I don't feel like threading another link.
* Do you?
* -- Furey
*/
for ( vnum = 0; nMatch < top_mob_index; vnum++ )
{
if ( ( pMobIndex = get_mob_index( vnum ) ) != NULL )
{
nMatch++;
if ( fAll || is_name( arg, pMobIndex->player_name ) )
{
found = TRUE;
sprintf( buf, "{W[{M%5d{W] ({R%3d{W) {B%-40s{x Loaded: %-3d\n\r",
pMobIndex->vnum,
pMobIndex->level,
capitalize( pMobIndex->short_descr ),
get_mvnum_count( pMobIndex->vnum ) );
send_to_char( buf, ch );
}
}
}
if ( !found )
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
int get_ovnum_count( int vnum )
{
int count = 0;
OBJ_DATA *obj;
GSList *tmp = object_list;
while ( tmp != NULL )
{
obj = ( OBJ_DATA* ) tmp->data;
if ( obj->pIndexData->vnum == vnum )
count++;
tmp = g_slist_next( tmp );
}
g_slist_free( tmp );
return count;
}
void do_ofind( CHAR_DATA *ch, char *argument )
{
extern int top_obj_index;
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
int vnum;
int nMatch;
bool fAll;
bool found;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Ofind what?\n\r", ch );
return ;
}
fAll = !str_cmp( arg, "all" );
found = FALSE;
nMatch = 0;
/*
* Yeah, so iterating over all vnum's takes 10,000 loops.
* Get_obj_index is fast, and I don't feel like threading another link.
* Do you?
* -- Furey
*/
for ( vnum = 0; nMatch < top_obj_index; vnum++ )
{
if ( ( pObjIndex = get_obj_index( vnum ) ) != NULL )
{
nMatch++;
if ( fAll || is_name( arg, pObjIndex->name ) )
{
found = TRUE;
sprintf( buf, "{W[{M%5d{W] {B%-40s{x Loaded: %-3d\n\r",
pObjIndex->vnum,
capitalize( pObjIndex->short_descr ),
get_ovnum_count( pObjIndex->vnum ) );
send_to_char( buf, ch );
}
}
}
if ( !found )
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
void do_mwhere( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
bool found;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Mwhere whom?\n\r", ch );
return ;
}
/* Had problems when lots of gremlins existed - KaVir
if ( !str_cmp( arg, "gremlin" ) )
{
send_to_char( "Sorry, but in the interest of mud stability you cannot do that.\n\r", ch );
return;
}
*/
found = FALSE;
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( IS_NPC( victim )
&& victim->in_room != NULL
&& is_name( arg, victim->name->str ) )
{
found = TRUE;
sprintf( buf, "[%5d] %-28s [%5d] %s\n\r",
victim->pIndexData->vnum,
victim->short_descr->str,
victim->in_room->vnum,
victim->in_room->name );
send_to_char( buf, ch );
}
}
if ( !found )
act( "You didn't find any $T.", ch, NULL, arg, TO_CHAR );
mudsetting->last_proc_logged = 11;
return ;
}
void do_reboo( CHAR_DATA *ch, char *argument )
{
send_to_char( "If you want to REBOOT, spell it out.\n\r", ch );
return ;
}
void do_reboot( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
extern bool merc_down;
sprintf( buf, "Reboot by %s.", ch->name->str );
do_echo( ch, buf );
do_forceauto( ch, "save" );
do_autosave( ch, "" );
merc_down = TRUE;
return ;
}
void do_shutdow( CHAR_DATA *ch, char *argument )
{
send_to_char( "If you want to SHUTDOWN, spell it out.\n\r", ch );
return ;
}
void do_shutdown( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
extern bool merc_down;
sprintf( buf, "Shutdown by %s.", ch->name->str );
append_file( ch, SHUTDOWN_FILE, buf );
strcat( buf, "\n\r" );
do_echo( ch, buf );
do_forceauto( ch, "save" );
do_forceauto( ch, "quit" );
do_autosave( ch, "" );
//Free up lists back to the system.
destroy_memory_chunck();
merc_down = TRUE;
exit( 0 );
}
int count_snoopers( DESCRIPTOR_DATA *ch )
{
GSList * desc_list = NULL;
GSList *snoop_list = NULL;
int count = 0;
DESCRIPTOR_DATA *target;
DESCRIPTOR_DATA *targetSnooper;
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
target = ( DESCRIPTOR_DATA* ) desc_list->data;
for ( snoop_list = target->snoop_by; snoop_list != NULL; snoop_list = g_slist_next( snoop_list ) )
{
targetSnooper = ( DESCRIPTOR_DATA* ) snoop_list->data;
if ( targetSnooper == ch )
count++;
}
}
g_slist_free( desc_list );
g_slist_free( snoop_list );
return count;
}
void add_snooper( DESCRIPTOR_DATA *ch_desc, DESCRIPTOR_DATA *vic_desc )
{
GSList * snoop_list = NULL;
DESCRIPTOR_DATA *snooper;
if ( vic_desc == NULL )
{
send_to_char( "No descriptor to snoop.\n\r", ch_desc->character );
return ;
}
if ( vic_desc->snoop_by != NULL )
{
for ( snoop_list = vic_desc->snoop_by; snoop_list != NULL; snoop_list = g_slist_next( snoop_list ) )
{
snooper = ( DESCRIPTOR_DATA* ) snoop_list->data;
if ( snooper == ch_desc )
{
remove_snooper( ch_desc->character, vic_desc->character );
return ;
}
}
}
g_slist_free( snoop_list );
vic_desc->snoop_by = g_slist_append( vic_desc->snoop_by, ch_desc );
if ( IS_IMMORTAL( ch_desc->character ) )
send_to_char( "Snoop ok\n\r", ch_desc->character );
else
send_to_char( "You attempt to Unveil their Shrouded Mind.\n\r", ch_desc->character );
return ;
}
/*
* Removes all of the people that is snooping victim
*/
void removeAllSnoopers( DESCRIPTOR_DATA *ch_desc )
{
GSList * snoop_list = NULL;
DESCRIPTOR_DATA *snooper;
if ( ch_desc == NULL )
return ;
for ( snoop_list = ch_desc->snoop_by; snoop_list != NULL; snoop_list = g_slist_next( snoop_list ) )
{
snooper = ( DESCRIPTOR_DATA* ) snoop_list->data;
remove_snooper( snooper->character, ch_desc->character );
}
g_slist_free( snoop_list );
return ;
}
void remove_snooper( CHAR_DATA *ch, CHAR_DATA *target )
{
GSList * desc_list = NULL;
DESCRIPTOR_DATA *PersonDesc;
DESCRIPTOR_DATA *Snooper;
GSList *snoop_list = NULL;
if ( target == NULL || ch == NULL )
return ;
if ( target == ch )
{
if ( IS_IMMORTAL( ch ) )
send_to_char( "Cancelling all snoops.\n\r", ch );
else
send_to_char( "You cease trying to Unveil any minds.\n\r", ch );
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
PersonDesc = ( DESCRIPTOR_DATA* ) desc_list->data;
/*
* Scroll throgh the peron's snoop_by looking for snooper
*/
for ( snoop_list = PersonDesc->snoop_by; snoop_list != NULL; snoop_list = g_slist_next( snoop_list ) )
{
Snooper = ( DESCRIPTOR_DATA* ) snoop_list->data;
if ( Snooper == ch->desc )
{
PersonDesc->snoop_by = g_slist_remove( PersonDesc->snoop_by, Snooper );
continue;
}
}
}
g_slist_free( snoop_list );
g_slist_free( desc_list );
}
else
{
for ( snoop_list = target->desc->snoop_by; snoop_list != NULL; snoop_list = g_slist_next( snoop_list ) )
{
Snooper = ( DESCRIPTOR_DATA* ) snoop_list->data;
if ( Snooper == ch->desc )
{
if ( IS_IMMORTAL( ch ) )
send_to_char( "Removing snoop.\n\r", ch );
else
send_to_char( "You cease trying to Unveil that mind.\n\r", ch );
target->desc->snoop_by = g_slist_remove( target->desc->snoop_by, Snooper );
}
}
g_slist_free( snoop_list );
}
return ;
}
void do_snoop( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Snoop %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Snoop whom?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( victim == ch )
{
remove_snooper( ch, ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "You failed.\n\r", ch );
return ;
}
add_snooper( ch->desc, victim->desc );
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_oswitch( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
OBJ_DATA *obj;
CHAR_DATA *mount;
sprintf( buf, "%s: Oswitch %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( IS_NPC( ch ) )
return ;
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Switch into what?\n\r", ch );
return ;
}
if ( IS_EXTRA( ch, EXTRA_OSWITCH ) || IS_HEAD( ch, LOST_HEAD ) )
{
send_to_char( "You are already oswitched.\n\r", ch );
return ;
}
if ( IS_AFFECTED( ch, AFF_POLYMORPH ) )
{
send_to_char( "Not while polymorphed.\n\r", ch );
return ;
}
if ( IS_NPC( ch ) || IS_EXTRA( ch, EXTRA_SWITCH ) )
{
send_to_char( "Not while switched.\n\r", ch );
return ;
}
if ( ( obj = get_obj_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( obj->chobj != NULL )
{
send_to_char( "Object in use.\n\r", ch );
return ;
}
if ( ( mount = ch->mount ) != NULL )
do_dismount( ch, "" );
obj->chobj = ch;
ch->pcdata->chobj = obj;
SET_BIT( ch->affected_by, AFF_POLYMORPH );
SET_BIT( ch->extra, EXTRA_OSWITCH );
ch->morph = g_string_assign( ch->morph, obj->short_descr->str );
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_oreturn( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
OBJ_DATA *obj;
sprintf( buf, "%s: Oreturn", ch->name->str );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( IS_NPC( ch ) )
return ;
if ( !IS_EXTRA( ch, EXTRA_OSWITCH ) && !IS_HEAD( ch, LOST_HEAD ) )
{
send_to_char( "You are not oswitched.\n\r", ch );
return ;
}
if ( ( obj = ch->pcdata->chobj ) != NULL )
obj->chobj = NULL;
ch->pcdata->chobj = NULL;
REMOVE_BIT( ch->affected_by, AFF_POLYMORPH );
REMOVE_BIT( ch->extra, EXTRA_OSWITCH );
if ( IS_HEAD( ch, LOST_HEAD ) )
REMOVE_BIT( ch->loc_hp[ 0 ], LOST_HEAD );
ch->morph = g_string_assign( ch->morph, "" );
char_from_room( ch );
char_to_room( ch, get_room_index( ROOM_VNUM_ALTAR ) );
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_switch( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Switch %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Switch into whom?\n\r", ch );
return ;
}
if ( ch->desc == NULL )
return ;
if ( ch->desc->original != NULL )
{
send_to_char( "You are already switched.\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( victim == ch )
{
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( victim->level >= 200 && ch->trust < LEVEL_ENFORCER )
{
send_to_char( "Try to find a lower level mobile to switch in to.", ch );
return ;
}
if ( victim->desc != NULL )
{
send_to_char( "Character in use.\n\r", ch );
return ;
}
if ( !IS_NPC( victim ) )
{
send_to_char( "Only on NPC's.\n\r", ch );
return ;
}
SET_BIT( ch->extra, EXTRA_SWITCH );
ch->desc->character = victim;
ch->desc->original = ch;
victim->desc = ch->desc;
ch->desc = NULL;
SET_BIT( victim->act, ACT_HOLYLIGHT );
send_to_char( "Ok.\n\r", victim );
return ;
}
void do_mload( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
MOB_INDEX_DATA *pMobIndex;
CHAR_DATA *victim = NULL;
int loop_count = 0;
sprintf( buf, "%s: Mload %s", ch->name->str, argument );
if ( ch->level < NO_WATCH && ch->trust > 3 )
do_watching( ch, buf );
argument = one_argument( argument, arg );
argument = one_argument( argument, arg2 );
if ( arg[ 0 ] == '\0' || !is_number( arg ) )
{
send_to_char( "Syntax: mload <vnum>.\n\r", ch );
return ;
}
if ( ( pMobIndex = get_mob_index( atoi( arg ) ) ) == NULL )
{
send_to_char( "No mob has that vnum.\n\r", ch );
return ;
}
if ( arg2[ 0 ] != '\0' )
{
for ( loop_count = 0; loop_count != atoi( arg2 );loop_count++ )
{
victim = create_mobile( pMobIndex );
char_to_room( victim, ch->in_room );
}
act( "You have created $N!", ch, NULL, victim, TO_CHAR );
}
else
{
victim = create_mobile( pMobIndex );
char_to_room( victim, ch->in_room );
act( "You have created $N!", ch, NULL, victim, TO_CHAR );
}
// act( "$n has created $N!", ch, NULL, victim, TO_ROOM );
return ;
}
void do_pload( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
DESCRIPTOR_DATA *d;
ROOM_INDEX_DATA *in_room;
bool fOld;
if ( IS_NPC( ch ) || ch->desc == NULL || ch->in_room == NULL )
return ;
if ( argument[ 0 ] == '\0' )
{
send_to_char( "Syntax: pload <name>.\n\r", ch );
return ;
}
if ( !check_parse_name( argument ) )
{
send_to_char( "Thats an illegal name.\n\r", ch );
return ;
}
if ( !char_exists( TRUE, argument ) )
{
send_to_char( "That player doesn't exist.\n\r", ch );
return ;
}
sprintf( buf, "%s: Pload %s", ch->name->str, argument );
if ( ch->level < NO_WATCH && ch->trust > 3 )
do_watching( ch, buf );
argument[ 0 ] = UPPER( argument[ 0 ] );
sprintf( buf, "You transform into %s.\n\r", argument );
send_to_char( buf, ch );
sprintf( buf, "$n transforms into %s.", argument );
act( buf, ch, NULL, NULL, TO_ROOM );
d = ch->desc;
do_autosave( ch, "" );
in_room = ch->in_room;
extract_char( ch, TRUE );
d->character = NULL;
fOld = load_char_obj( d, argument );
ch = d->character;
ch->next = char_list;
char_list = ch;
char_to_room( ch, in_room );
mudsetting->last_proc_logged = 111;
return ;
}
void do_preturn( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
DESCRIPTOR_DATA *d;
bool fOld;
if ( IS_NPC( ch ) )
{send_to_char( "Huh?\n\r", ch ); return ;}
if ( ch->pload == NULL )
{send_to_char( "Huh?\n\r", ch ); return ;}
sprintf( arg, ch->pload->str );
if ( strlen( arg ) < 3 || strlen( arg ) > 8 )
{send_to_char( "Huh?\n\r", ch ); return ;}
if ( !str_cmp( ch->name->str, arg ) )
{send_to_char( "Huh?\n\r", ch ); return ;}
d = ch->desc;
sprintf( buf, "You transform back into %s.\n\r", capitalize( ch->pload->str ) );
send_to_char( buf, ch );
sprintf( buf, "$n transforms back into %s.", capitalize( ch->pload->str ) );
act( buf, ch, NULL, NULL, TO_ROOM );
do_autosave( ch, "" );
if ( ch != NULL && ch->desc != NULL )
extract_char( ch, TRUE );
else if ( ch != NULL )
extract_char( ch, TRUE );
if ( ch->desc )
ch->desc->character = NULL;
/*
ch->next = char_list;
char_list = ch;
*/
fOld = load_char_obj( d, capitalize( arg ) );
if ( ch->in_room != NULL )
char_to_room( ch, ch->in_room );
else
char_to_room( ch, get_room_index( 3001 ) );
ch->pload = g_string_assign( ch->pload, "" );
return ;
}
void do_oload( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
int level;
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
sprintf( buf, "%s: Oload %s", ch->name->str, argument );
if ( ch->level < NO_WATCH && ch->trust > 3 )
do_watching( ch, buf );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' || !is_number( arg1 ) )
{
send_to_char( "Syntax: oload <vnum> <level>.\n\r", ch );
return ;
}
if ( arg2[ 0 ] == '\0' )
{
level = get_trust( ch );
}
else
{
if ( !is_number( arg2 ) )
{
send_to_char( "Syntax: oload <vnum> <level>.\n\r", ch );
return ;
}
level = atoi( arg2 );
if ( level < 0 || level > get_trust( ch ) )
{
send_to_char( "Limited to your trust level.\n\r", ch );
return ;
}
}
if ( ( pObjIndex = get_obj_index( atoi( arg1 ) ) ) == NULL )
{
send_to_char( "No object has that vnum.\n\r", ch );
return ;
}
obj = create_object( pObjIndex, level );
if ( CAN_WEAR( obj, ITEM_TAKE ) )
{
obj_to_char( obj, ch );
act( "$p appears in $n's hands!", ch, obj, NULL, TO_ROOM );
}
else
{
obj_to_room( obj, ch->in_room );
act( "$n has created $p!", ch, obj, NULL, TO_ROOM );
}
act( "You create $p.", ch, obj, NULL, TO_CHAR );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
void do_purge( CHAR_DATA *ch, 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 = ch->in_room->people; victim != NULL; victim = vnext )
{
vnext = victim->next_in_room;
if ( !IS_NPC( victim ) )
continue;
if ( victim->mount != NULL )
continue;
if ( victim->desc != NULL )
continue;
extract_char( victim, TRUE );
}
for ( obj = ch->in_room->contents; obj != NULL; obj = obj_next )
{
obj_next = obj->next_content;
extract_obj( obj );
}
act( "$n purges the room!", ch, NULL, NULL, TO_ROOM );
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( !IS_NPC( victim ) )
{
send_to_char( "Not on PC's.\n\r", ch );
return ;
}
if ( victim->desc != NULL )
{
send_to_char( "Not on switched players.\n\r", ch );
return ;
}
act( "$n purges $N.", ch, NULL, victim, TO_NOTVICT );
extract_char( victim, TRUE );
return ;
}
void do_trust( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
int level;
sprintf( buf, "%s: Trust %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' )
{
send_to_char( "Syntax: trust <char> <trust>.\n\r", ch );
send_to_char( "Trust being one of: None, Builder, Questmaker, Enforcer, Judge, or Highjudge.\n\r", ch );
return ;
}
if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
{
send_to_char( "That player is not here.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "none" ) )
level = 0;
else if ( !str_cmp( arg2, "builder" ) )
level = 7;
else if ( !str_cmp( arg2, "questmaker" ) )
level = 8;
else if ( !str_cmp( arg2, "enforcer" ) )
level = 9;
else if ( !str_cmp( arg2, "judge" ) )
level = 10;
else if ( !str_cmp( arg2, "highjudge" ) )
level = 11;
else
{
send_to_char( "Please enter: None, Builder, Questmaker, Enforcer, Judge, or Highjudge.\n\r", ch );
return ;
}
if ( level >= get_trust( ch ) )
{
send_to_char( "Limited to below your trust.\n\r", ch );
return ;
}
send_to_char( "Ok.\n\r", ch );
victim->trust = level;
return ;
}
void do_restore( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Restore %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Restore whom?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
victim->hit = victim->max_hit;
victim->mana = victim->max_mana;
victim->move = victim->max_move;
victim->loc_hp[ 0 ] = 0;
victim->loc_hp[ 1 ] = 0;
victim->loc_hp[ 2 ] = 0;
victim->loc_hp[ 3 ] = 0;
victim->loc_hp[ 4 ] = 0;
victim->loc_hp[ 5 ] = 0;
victim->loc_hp[ 6 ] = 0;
update_pos( victim );
act( "$n has restored you.", ch, NULL, victim, TO_VICT );
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_freeze( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Freeze %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Freeze whom?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "You failed.\n\r", ch );
return ;
}
if ( IS_SET( victim->act, PLR_FREEZE ) )
{
REMOVE_BIT( victim->act, PLR_FREEZE );
send_to_char( "You can play again. You have been thawed out by an Admin.\n\r", victim );
send_to_char( "FREEZE removed.\n\r", ch );
}
else
{
SET_BIT( victim->act, PLR_FREEZE );
send_to_char( "You can't do ANYthing! You have been FROZEN by an Admin.\n\r", victim );
send_to_char( "FREEZE set.\n\r", ch );
}
save_char_obj( victim );
return ;
}
void do_log( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Log %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Log whom?\n\r", ch );
return ;
}
if ( !str_cmp( arg, "all" ) )
{
if ( fLogAll )
{
fLogAll = FALSE;
send_to_char( "Log ALL off.\n\r", ch );
}
else
{
fLogAll = TRUE;
send_to_char( "Log ALL on.\n\r", ch );
}
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
/*
* No level check, gods can log anyone.
*/
if ( IS_SET( victim->act, PLR_LOG ) )
{
REMOVE_BIT( victim->act, PLR_LOG );
send_to_char( "LOG removed.\n\r", ch );
}
else
{
SET_BIT( victim->act, PLR_LOG );
send_to_char( "LOG set.\n\r", ch );
}
return ;
}
void do_noemote( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Noemote %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Noemote whom?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "You failed.\n\r", ch );
return ;
}
if ( IS_SET( victim->act, PLR_NO_EMOTE ) )
{
REMOVE_BIT( victim->act, PLR_NO_EMOTE );
send_to_char( "You can emote again.\n\r", victim );
send_to_char( "NO_EMOTE removed.\n\r", ch );
}
else
{
SET_BIT( victim->act, PLR_NO_EMOTE );
send_to_char( "You can't emote!\n\r", victim );
send_to_char( "NO_EMOTE set.\n\r", ch );
}
return ;
}
void do_notell( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Notell %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Notell whom?", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "You failed.\n\r", ch );
return ;
}
if ( IS_SET( victim->act, PLR_NO_TELL ) )
{
REMOVE_BIT( victim->act, PLR_NO_TELL );
send_to_char( "You can tell again.\n\r", victim );
send_to_char( "NO_TELL removed.\n\r", ch );
}
else
{
SET_BIT( victim->act, PLR_NO_TELL );
send_to_char( "You can't tell!\n\r", victim );
send_to_char( "NO_TELL set.\n\r", ch );
}
return ;
}
void do_silence( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
sprintf( buf, "%s: Silence %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Silence whom?", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "You failed.\n\r", ch );
return ;
}
if ( IS_SET( victim->act, PLR_SILENCE ) )
{
REMOVE_BIT( victim->act, PLR_SILENCE );
send_to_char( "You can use channels again.\n\r", victim );
send_to_char( "SILENCE removed.\n\r", ch );
}
else
{
SET_BIT( victim->act, PLR_SILENCE );
send_to_char( "You can't use channels!\n\r", victim );
send_to_char( "SILENCE set.\n\r", ch );
}
return ;
}
void do_peace( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * rch;
char buf[ MAX_STRING_LENGTH ];
sprintf( buf, "%s: Peace %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
for ( rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room )
{
if ( rch->fighting != NULL )
stop_fighting( rch, TRUE );
}
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_wizlock( CHAR_DATA *ch, char *argument )
{
extern bool wizlock;
char buf[ MAX_STRING_LENGTH ];
sprintf( buf, "%s: Wizlock %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
wizlock = !wizlock;
if ( wizlock )
send_to_char( "Game wizlocked.\n\r", ch );
else
send_to_char( "Game un-wizlocked.\n\r", ch );
return ;
}
/* RT anti-newbie code */
void do_newlock( CHAR_DATA *ch, char *argument )
{
extern bool newlock;
newlock = !newlock;
if ( newlock )
{
send_to_char( "New characters have been locked out.\n\r", ch );
}
else
{
send_to_char( "Newlock removed.\n\r", ch );
}
return ;
}
void do_slookup( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
int sn;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Slookup what?\n\r", ch );
return ;
}
if ( !str_cmp( arg, "all" ) )
{
for ( sn = 0; sn < MAX_SKILL; sn++ )
{
if ( skill_table[ sn ].name == NULL )
break;
sprintf( buf, "Sn: %4d Slot: %4d Skill/spell: '%s'\n\r",
sn, skill_table[ sn ].slot, skill_table[ sn ].name );
send_to_char( buf, ch );
}
}
else
{
if ( ( sn = skill_lookup( arg ) ) < 0 )
{
send_to_char( "No such skill or spell.\n\r", ch );
return ;
}
sprintf( buf, "Sn: %4d Slot: %4d Skill/spell: '%s'\n\r",
sn, skill_table[ sn ].slot, skill_table[ sn ].name );
send_to_char( buf, ch );
}
return ;
}
void do_sset( CHAR_DATA *ch, char *argument )
{
char arg1 [ MAX_INPUT_LENGTH ];
char arg2 [ MAX_INPUT_LENGTH ];
char arg3 [ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
int value;
int sn;
bool fAll;
sprintf( buf, "%s: Sset %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
argument = one_argument( argument, arg3 );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' || arg3[ 0 ] == '\0' )
{
send_to_char( "Syntax: sset <victim> <skill> <value>\n\r", ch );
send_to_char( "or: sset <victim> all <value>\n\r", ch );
send_to_char( "Skill being any skill or spell.\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
fAll = !str_cmp( arg2, "all" );
sn = 0;
if ( !fAll && ( sn = skill_lookup( arg2 ) ) < 0 )
{
send_to_char( "No such skill or spell.\n\r", ch );
return ;
}
/*
* Snarf the value.
*/
if ( !is_number( arg3 ) )
{
send_to_char( "Value must be numeric.\n\r", ch );
return ;
}
value = atoi( arg3 );
if ( value < 0 || value > 100 )
{
send_to_char( "Value range is 0 to 100.\n\r", ch );
return ;
}
if ( fAll )
{
for ( sn = 0; sn < MAX_SKILL; sn++ )
{
if ( skill_table[ sn ].name != NULL )
victim->pcdata->learned[ sn ] = value;
}
}
else
{
victim->pcdata->learned[ sn ] = value;
}
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_mset( CHAR_DATA *ch, char *argument )
{
char arg1 [ MAX_INPUT_LENGTH ];
char arg2 [ MAX_INPUT_LENGTH ];
char arg3 [ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
int value, loop_count; // , age_ch;
bool SECT_FOUND = FALSE;
sprintf( buf, "%s: Mset %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
str_cpy( arg3, argument );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' || arg3[ 0 ] == '\0' )
{
send_to_char( "Syntax: mset <victim> <field> <value>\n\r", ch );
send_to_char( "or: mset <victim> <string> <value>\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "Field being one of:\n\r", ch );
send_to_char( " str int wis dex con sex level exp sec\n\r", ch );
send_to_char( " gold hp mana move primal align\n\r", ch );
send_to_char( " thirst drunk full hit dam ac hours\n\r", ch );
send_to_char( " rpstatus clan cp honor glory wisdom\n\r", ch );
send_to_char( " pkstatus lag\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "String being one of:\n\r", ch );
send_to_char( " name short long description title sect spec\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
/*
* Snarf the value (which need not be numeric).
*/
value = is_number( arg3 ) ? atoi( arg3 ) : -1;
/*
* Set something.
*/
if ( !str_cmp( arg2, "str" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 3 || value > 18 )
{
send_to_char( "Strength range is 3 to 18.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->perm_str = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "lag" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 || value > 20 )
{
send_to_char( "lag range is 0 to 20.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->lag_time = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "glory" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( !IS_SWWF( victim ) )
{
send_to_char( "Only on The Spiral Children Garou..\n\r", ch );
return ;
}
if ( value < 1 || value > 5 )
{
send_to_char( "glory range is 1 to 5.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->renown[ RENOWN_GLORY ] = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "honor" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( !IS_SWWF( victim ) )
{
send_to_char( "Only on The Spiral Children Garou..\n\r", ch );
return ;
}
if ( value < 1 || value > 5 )
{
send_to_char( "honor range is 1 to 5.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->renown[ RENOWN_GLORY ] = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "wisdom" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( !IS_SWWF( victim ) )
{
send_to_char( "Only on The Spiral Children Garou..\n\r", ch );
return ;
}
if ( value < 1 || value > 5 )
{
send_to_char( "wisdom range is 1 to 5.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->renown[ RENOWN_WISDOM ] = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "pkstatus" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 || value > 25 )
{
send_to_char( "pk_status range is 0 to 25.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->race = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "cp" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 || value > 20 )
{
send_to_char( "cp range is 0 to 20.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->charpoints = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "int" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 3 || value > 18 )
{
send_to_char( "Intelligence range is 3 to 18.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->perm_int = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "hours" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value > 3000 )
{
send_to_char( "Hour range is 0 to 3000.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
// age_ch = (value / 2 ) - 17;
// ch->played = (((value * 7200) - 17) - (int) (current_time - ch->logon));
value *= 3600;
victim->played = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "sec" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value > 9 )
{
send_to_char( "Security range is 0 to 9.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->security = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "wis" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 3 || value > 18 )
{
send_to_char( "Wisdom range is 3 to 18.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->perm_wis = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "dex" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 3 || value > 18 )
{
send_to_char( "Dexterity range is 3 to 18.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->perm_dex = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "con" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 3 || value > 18 )
{
send_to_char( "Constitution range is 3 to 18.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) )
{
victim->pcdata->perm_con = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "sex" ) )
{
if ( value < 0 || value > 2 )
{
send_to_char( "Sex range is 0 to 2.\n\r", ch );
return ;
}
victim->sex = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "level" ) )
{
if ( IS_NPC( victim ) && ( value < 1 || value > 250 ) )
{
send_to_char( "Level range is 1 to 250 for mobs.\n\r", ch );
return ;
}
else if ( !IS_JUDGE( ch ) )
{
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg3, "mortal" ) )
value = 2;
else if ( !str_cmp( arg3, "avatar" ) )
value = 3;
else if ( !str_cmp( arg3, "apprentice" ) )
value = 4;
else if ( !str_cmp( arg3, "mage" ) )
value = 5;
else if ( !str_cmp( arg3, "archmage" ) )
value = 6;
else if ( !str_cmp( arg3, "builder" ) )
value = 7;
else if ( !str_cmp( arg3, "questmaker" ) )
value = 8;
else if ( !str_cmp( arg3, "enforcer" ) )
value = 9;
else if ( !str_cmp( arg3, "judge" ) )
value = 10;
else if ( !str_cmp( arg3, "highjudge" ) )
value = 11;
else if ( !IS_NPC( victim ) )
{
send_to_char( "Level should be one of the following:\n\rMortal, Avatar, Apprentice, Mage, Archmage, Builder, Questmaker, Enforcer,\n\rJudge, or Highjudge.\n\r", ch );
return ;
}
if ( value >= ch->level && !IS_NPC( victim ) )
send_to_char( "Sorry, no can do...\n\r", ch );
else
{
victim->level = value;
victim->trust = value;
send_to_char( "Ok.\n\r", ch );
}
return ;
}
if ( !str_cmp( arg2, "hitroll" ) || !str_cmp( arg2, "hit" ) )
{
if ( !IS_NPC( victim ) && ( value < 0 || value > 50 ) )
{
send_to_char( "Hitroll range is 0 to 50.\n\r", ch );
return ;
}
else if ( IS_NPC( victim ) && ( value < 0 || value > 250 ) )
{
send_to_char( "Hitroll range is 0 to 250.\n\r", ch );
return ;
}
if ( !IS_NPC( victim ) && !IS_JUDGE( ch ) && ch != victim )
{
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
victim->hitroll = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "damroll" ) || !str_cmp( arg2, "dam" ) )
{
if ( !IS_NPC( victim ) && ( value < 0 || value > 50 ) )
{
send_to_char( "Damroll range is 0 to 50.\n\r", ch );
return ;
}
else if ( IS_NPC( victim ) && ( value < 0 || value > 250 ) )
{
send_to_char( "Damroll range is 0 to 250.\n\r", ch );
return ;
}
if ( !IS_NPC( victim ) && !IS_JUDGE( ch ) && ch != victim )
{
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
victim->damroll = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "armor" ) || !str_cmp( arg2, "ac" ) )
{
if ( !IS_NPC( victim ) && ( value < -200 || value > 200 ) )
{
send_to_char( "Armor class range is -200 to 200.\n\r", ch );
return ;
}
if ( !IS_NPC( victim ) && !IS_JUDGE( ch ) && ch != victim )
{
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
victim->armor = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "exp" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 )
{
send_to_char( "Exp must be at least 0.\n\r", ch );
return ;
}
if ( value > 100000000 )
{
send_to_char( "No more than 100,000,000 possible.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) || ( ch == victim ) )
{
victim->exp = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "gold" ) )
{
if ( value > 100000 && !IS_JUDGE( ch ) )
send_to_char( "Don't be so damn greedy!\n\r", ch );
else
{victim->gold = value; send_to_char( "Ok.\n\r", ch );}
return ;
}
if ( !str_cmp( arg2, "hp" ) )
{
if ( value < 1 || value > 120000 )
{
send_to_char( "Hp range is 1 to 120,000 hit points.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) || ( ch == victim ) || ( IS_NPC( victim ) ) )
{
victim->max_hit = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "mana" ) )
{
if ( value < 0 || value > 120000 )
{
send_to_char( "Mana range is 0 to 120,000 mana points.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) || ( ch == victim ) || ( IS_NPC( victim ) ) )
{
victim->max_mana = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "move" ) )
{
if ( value < 0 || value > 120000 )
{
send_to_char( "Move range is 0 to 120,000 move points.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) || ( ch == victim ) || ( IS_NPC( victim ) ) )
{
victim->max_move = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "primal" ) )
{
if ( value < 0 || value > 10000 )
{
send_to_char( "Primal range is 0 to 10000.\n\r", ch );
return ;
}
if ( IS_JUDGE( ch ) || ( ch == victim ) )
{
victim->practice = value;
send_to_char( "Ok.\n\r", ch );
}
else
send_to_char( "Sorry, no can do...\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "align" ) )
{
if ( value < -1000 || value > 1000 )
{
send_to_char( "Alignment range is -1000 to 1000.\n\r", ch );
return ;
}
victim->alignment = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "thirst" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 || value > 100 )
{
send_to_char( "Thirst range is 0 to 100.\n\r", ch );
return ;
}
victim->pcdata->condition[ COND_THIRST ] = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "drunk" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 || value > 100 )
{
send_to_char( "Drunk range is 0 to 100.\n\r", ch );
return ;
}
victim->pcdata->condition[ COND_DRUNK ] = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "full" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( value < 0 || value > 100 )
{
send_to_char( "Full range is 0 to 100.\n\r", ch );
return ;
}
victim->pcdata->condition[ COND_FULL ] = value;
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "name" ) )
{
if ( !IS_NPC( victim ) )
{
send_to_char( "Not on PC's.\n\r", ch );
return ;
}
victim->name = g_string_assign( victim->name, arg3 );
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "short" ) )
{
victim->short_descr = g_string_assign( victim->short_descr, arg3 );
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "long" ) )
{
strcat( arg3, "\n\r" );
victim->long_descr = g_string_assign( victim->long_descr, arg3 );
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "title" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
set_title( victim, arg3 );
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "sect" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( arg3 != NULL )
{
if ( !str_cmp( arg3, "none" ) )
{
victim->sect = SECT_INDEPENDENT;
send_to_char( "Sect cleared.\n\r", ch );
return ;
}
else
{
for ( loop_count = 0;loop_count != MAX_SECTS;loop_count++ )
{
if ( !str_prefix( arg3, sect_table[ loop_count ].pretty_name ) )
{
SECT_FOUND = TRUE;
break;
}
}
if ( SECT_FOUND == TRUE )
{
victim->sect = loop_count;
send_to_char( "Sect set to '", ch );
send_to_char( sect_table[ victim->sect ].pretty_name, ch );
send_to_char( "'.\n\r", ch );
}
else
send_to_char( "Sect not found!\n\r", ch );
return ;
}
}
else
{
send_to_char( "You must enter a sect, or 'none' to clear.\n\r", ch );
return ;
}
}
if ( !str_cmp( arg2, "clan" ) )
{
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( arg3 != NULL )
{
for ( loop_count = 0;loop_count != MAX_ICLAN;loop_count++ )
{
if ( !str_prefix( arg3, iclan_table[ loop_count ].pretty_name ) )
{
SECT_FOUND = TRUE;
break;
}
}
if ( SECT_FOUND == TRUE )
{
victim->clan = loop_count;
send_to_char( "Clan set to '", ch );
send_to_char( iclan_table[ victim->clan ].pretty_name, ch );
send_to_char( "'.\n\r", ch );
return ;
}
else
{
send_to_char( "Clan not found!\n\r", ch );
return ;
}
}
else
{
send_to_char( "You must enter a clan.\n\r", ch );
return ;
}
}
if ( !str_cmp( arg2, "spec" ) )
{
if ( !IS_NPC( victim ) )
{
send_to_char( "Not on PC's.\n\r", ch );
return ;
}
if ( ( victim->spec_fun = spec_lookup( arg3 ) ) == 0 )
{
send_to_char( "No such spec fun.\n\r", ch );
return ;
}
send_to_char( "Ok.\n\r", ch );
return ;
}
/*
* Generate usage message.
*/
do_mset( ch, "" );
return ;
}
void do_oset( CHAR_DATA *ch, char *argument )
{
char arg1 [ MAX_INPUT_LENGTH ];
char arg2 [ MAX_INPUT_LENGTH ];
char arg3 [ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
OBJ_DATA *obj;
OBJ_DATA *morph;
OBJ_INDEX_DATA *pObjIndex;
int value;
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
sprintf( buf, "%s: Oset %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
str_cpy( arg3, argument );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' || arg3[ 0 ] == '\0' )
{
send_to_char( "Syntax: oset <object> <field> <value>\n\r", ch );
send_to_char( "or: oset <object> <string> <value>\n\r", ch );
send_to_char( "or: oset <object> <affect> <value>\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "Field being one of:\n\r", ch );
send_to_char( " value0 value1 value2 value3\n\r", ch );
send_to_char( " level weight cost timer morph\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "String being one of:\n\r", ch );
send_to_char( " name short long ed type extra wear owner\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "Affect being one of:\n\r", ch );
send_to_char( " str dex int wis con\n\r", ch );
send_to_char( " hit dam ac hp mana move\n\r", ch );
return ;
}
if ( ( obj = get_obj_world( ch, arg1 ) ) == NULL )
{
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
if ( !IS_JUDGE( ch ) && ( obj->questmaker == NULL || str_cmp( ch->name->str, obj->questmaker->str ) ) )
{
send_to_char( "You don't have permission to change that item.\n\r", ch );
return ;
}
/*
* Snarf the value (which need not be numeric).
*/
value = atoi( arg3 );
/*
* Set something.
*/
if ( !str_cmp( arg2, "value0" ) || !str_cmp( arg2, "v0" ) )
{
if ( obj->item_type == ITEM_WEAPON && !IS_JUDGE( ch ) )
{
send_to_char( "You are not authorised to create spell weapons.\n\r", ch );
return ;
}
else if ( obj->item_type == ITEM_QUEST )
{
send_to_char( "You cannot change a quest tokens value with oset.\n\r", ch );
return ;
}
else if ( obj->item_type == ITEM_ARMOR && value > 15 )
obj->value[ 0 ] = 15;
else
obj->value[ 0 ] = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "value1" ) || !str_cmp( arg2, "v1" ) )
{
if ( obj->item_type == ITEM_WEAPON && value > 10 )
obj->value[ 1 ] = 10;
else
obj->value[ 1 ] = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "value2" ) || !str_cmp( arg2, "v2" ) )
{
if ( obj->item_type == ITEM_WEAPON && value > 20 )
obj->value[ 2 ] = 20;
else
obj->value[ 2 ] = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "value3" ) || !str_cmp( arg2, "v3" ) )
{
if ( obj->item_type == ITEM_ARMOR && !IS_JUDGE( ch ) )
send_to_char( "You are not authorised to create spell armour.\n\r", ch );
else
{obj->value[ 3 ] = value; send_to_char( "Ok.\n\r", ch );}
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "morph" ) )
{
int mnum;
if ( IS_SET( obj->spectype, SITEM_MORPH ) )
{
send_to_char( "This item can already morph.\n\r", ch );
return ;
}
if ( ( pObjIndex = get_obj_index( value ) ) == NULL )
{
send_to_char( "No object has that vnum.\n\r", ch );
return ;
}
morph = create_object( pObjIndex, obj->level );
if ( !CAN_WEAR( morph, ITEM_TAKE ) )
SET_BIT( morph->wear_flags, ITEM_TAKE );
if ( !IS_SET( obj->spectype, SITEM_MORPH ) )
SET_BIT( obj->spectype, SITEM_MORPH );
if ( !IS_SET( morph->spectype, SITEM_MORPH ) )
SET_BIT( morph->spectype, SITEM_MORPH );
obj_to_char( morph, ch );
act( "$p morphs into $P in $n's hands!", ch, obj, morph, TO_ROOM );
act( "$p morphs into $P in your hands!", ch, obj, morph, TO_CHAR );
mnum = obj->wear_loc;
obj_from_char( obj );
obj_to_obj( obj, morph );
if ( morph->wear_flags == obj->wear_flags && mnum != WEAR_NONE )
equip_char( ch, morph, mnum );
morph->questmaker = g_string_assign( morph->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "extra" ) )
{
if ( !str_cmp( arg3, "glow" ) )
value = ITEM_GLOW;
else if ( !str_cmp( arg3, "hum" ) )
value = ITEM_HUM;
else if ( !str_cmp( arg3, "thrown" ) )
value = ITEM_THROWN;
else if ( !str_cmp( arg3, "vanish" ) )
value = ITEM_VANISH;
else if ( !str_cmp( arg3, "invis" ) )
value = ITEM_INVIS;
else if ( !str_cmp( arg3, "magic" ) )
value = ITEM_MAGIC;
else if ( !str_cmp( arg3, "nodrop" ) )
value = ITEM_NODROP;
else if ( !str_cmp( arg3, "bless" ) )
value = ITEM_BLESS;
else if ( !str_cmp( arg3, "anti-good" ) )
value = ITEM_ANTI_GOOD;
else if ( !str_cmp( arg3, "anti-evil" ) )
value = ITEM_ANTI_EVIL;
else if ( !str_cmp( arg3, "anti-neutral" ) )
value = ITEM_ANTI_NEUTRAL;
else if ( !str_cmp( arg3, "noremove" ) )
value = ITEM_NOREMOVE;
else if ( !str_cmp( arg3, "inventory" ) )
value = ITEM_INVENTORY;
else if ( !str_cmp( arg3, "loyal" ) )
value = ITEM_LOYAL;
else
{
send_to_char( "Extra flag can be from the following: Glow, Hum, Thrown, Vanish, Invis, Magic, Nodrop, Bless, Anti-Good, Anti-Evil, Anti-Neutral, Noremove, Inventory, Loyal.\n\r", ch );
return ;
}
/* Removing magic flag allows multiple enchants */
if ( IS_SET( obj->extra_flags, value ) && value == ITEM_MAGIC && !IS_JUDGE( ch ) )
{send_to_char( "Sorry, no can do...\n\r", ch ); return ;}
if ( IS_SET( obj->extra_flags, value ) )
REMOVE_BIT( obj->extra_flags, value );
else
SET_BIT( obj->extra_flags, value );
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "wear" ) )
{
if ( !str_cmp( arg3, "none" ) || !str_cmp( arg3, "clear" ) )
{
obj->wear_flags = 0;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
else if ( !str_cmp( arg3, "take" ) )
{
if ( IS_SET( obj->wear_flags, ITEM_TAKE ) )
REMOVE_BIT( obj->wear_flags, ITEM_TAKE );
else
SET_BIT( obj->wear_flags, ITEM_TAKE );
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
else if ( !str_cmp( arg3, "finger" ) )
value = ITEM_WEAR_FINGER;
else if ( !str_cmp( arg3, "neck" ) )
value = ITEM_WEAR_NECK;
else if ( !str_cmp( arg3, "body" ) )
value = ITEM_WEAR_BODY;
else if ( !str_cmp( arg3, "head" ) )
value = ITEM_WEAR_HEAD;
else if ( !str_cmp( arg3, "legs" ) )
value = ITEM_WEAR_LEGS;
else if ( !str_cmp( arg3, "feet" ) )
value = ITEM_WEAR_FEET;
else if ( !str_cmp( arg3, "hands" ) )
value = ITEM_WEAR_HANDS;
else if ( !str_cmp( arg3, "arms" ) )
value = ITEM_WEAR_ARMS;
else if ( !str_cmp( arg3, "about" ) )
value = ITEM_WEAR_ABOUT;
else if ( !str_cmp( arg3, "waist" ) )
value = ITEM_WEAR_WAIST;
else if ( !str_cmp( arg3, "wrist" ) )
value = ITEM_WEAR_WRIST;
else if ( !str_cmp( arg3, "hold" ) )
value = ITEM_WIELD;
else if ( !str_cmp( arg3, "face" ) )
value = ITEM_WEAR_FACE;
else
{
send_to_char( "Wear location can be from: None, Take, Finger, Neck, Body, Head, Legs, Hands, Arms, About, Waist, Hold, Face.\n\r", ch );
return ;
}
if ( IS_SET( obj->wear_flags, ITEM_TAKE ) )
value += 1;
obj->wear_flags = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "level" ) )
{
if ( value < 1 )
value = 1;
else if ( value > 50 )
value = 50;
if ( !IS_JUDGE( ch ) )
send_to_char( "You are not authorised to change an items level.\n\r", ch );
else
{
obj->level = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
}
if ( !str_cmp( arg2, "weight" ) )
{
obj->weight = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "cost" ) )
{
if ( value > 100000 && !IS_JUDGE( ch ) )
send_to_char( "Don't be so damn greedy!\n\r", ch );
else
{
obj->cost = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
}
return ;
}
if ( !str_cmp( arg2, "timer" ) )
{
obj->timer = value;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "hitroll" ) || !str_cmp( arg2, "hit" ) )
{oset_affect( ch, obj, value, APPLY_HITROLL, FALSE ); return ;}
else if ( !str_cmp( arg2, "damroll" ) || !str_cmp( arg2, "dam" ) )
{oset_affect( ch, obj, value, APPLY_DAMROLL, FALSE ); return ;}
else if ( !str_cmp( arg2, "armor" ) || !str_cmp( arg2, "ac" ) )
{oset_affect( ch, obj, value, APPLY_AC, FALSE ); return ;}
else if ( !str_cmp( arg2, "hitpoints" ) || !str_cmp( arg2, "hp" ) )
{oset_affect( ch, obj, value, APPLY_HIT, FALSE ); return ;}
else if ( !str_cmp( arg2, "mana" ) )
{oset_affect( ch, obj, value, APPLY_MANA, FALSE ); return ;}
else if ( !str_cmp( arg2, "move" ) || !str_cmp( arg2, "movement" ) )
{oset_affect( ch, obj, value, APPLY_MOVE, FALSE ); return ;}
else if ( !str_cmp( arg2, "str" ) || !str_cmp( arg2, "strength" ) )
{oset_affect( ch, obj, value, APPLY_STR, FALSE ); return ;}
else if ( !str_cmp( arg2, "dex" ) || !str_cmp( arg2, "dexterity" ) )
{oset_affect( ch, obj, value, APPLY_DEX, FALSE ); return ;}
else if ( !str_cmp( arg2, "int" ) || !str_cmp( arg2, "intelligence" ) )
{oset_affect( ch, obj, value, APPLY_INT, FALSE ); return ;}
else if ( !str_cmp( arg2, "wis" ) || !str_cmp( arg2, "wisdom" ) )
{oset_affect( ch, obj, value, APPLY_WIS, FALSE ); return ;}
else if ( !str_cmp( arg2, "con" ) || !str_cmp( arg2, "constitution" ) )
{oset_affect( ch, obj, value, APPLY_CON, FALSE ); return ;}
if ( !str_cmp( arg2, "type" ) )
{
if ( !IS_JUDGE( ch ) )
{
send_to_char( "You are not authorised to change an item type.\n\r", ch );
return ;
}
if ( !str_cmp( arg3, "light" ) )
obj->item_type = 1;
else if ( !str_cmp( arg3, "scroll" ) )
obj->item_type = 2;
else if ( !str_cmp( arg3, "wand" ) )
obj->item_type = 3;
else if ( !str_cmp( arg3, "staff" ) )
obj->item_type = 4;
else if ( !str_cmp( arg3, "weapon" ) )
obj->item_type = 5;
else if ( !str_cmp( arg3, "treasure" ) )
obj->item_type = 8;
else if ( !str_cmp( arg3, "armor" ) )
obj->item_type = 9;
else if ( !str_cmp( arg3, "armour" ) )
obj->item_type = 9;
else if ( !str_cmp( arg3, "potion" ) )
obj->item_type = 10;
else if ( !str_cmp( arg3, "furniture" ) )
obj->item_type = 12;
else if ( !str_cmp( arg3, "trash" ) )
obj->item_type = 13;
else if ( !str_cmp( arg3, "container" ) )
obj->item_type = 15;
else if ( !str_cmp( arg3, "drink" ) )
obj->item_type = 17;
else if ( !str_cmp( arg3, "key" ) )
obj->item_type = 18;
else if ( !str_cmp( arg3, "food" ) )
obj->item_type = 19;
else if ( !str_cmp( arg3, "money" ) )
obj->item_type = 20;
else if ( !str_cmp( arg3, "boat" ) )
obj->item_type = 22;
else if ( !str_cmp( arg3, "corpse" ) )
obj->item_type = 23;
else if ( !str_cmp( arg3, "fountain" ) )
obj->item_type = 25;
else if ( !str_cmp( arg3, "pill" ) )
obj->item_type = 26;
else if ( !str_cmp( arg3, "portal" ) )
obj->item_type = 27;
else if ( !str_cmp( arg3, "stake" ) )
obj->item_type = 30;
else if ( !str_cmp( arg3, "stake" ) )
obj->item_type = 30;
else
{
send_to_char( "Type can be one of: Light, Scroll, Wand, Staff, Weapon, Treasure, Armor, Potion, Furniture, Trash, Container, Drink, Key, Food, Money, Boat, Corpse, Fountain, Pill, Portal, Stake.\n\r", ch );
return ;
}
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "owner" ) )
{
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
if ( !IS_JUDGE( ch ) && ( obj->questmaker == NULL || str_cmp( ch->name->str, obj->questmaker->str ) ) )
{send_to_char( "Someone else has already changed this item.\n\r", ch ); return ;}
if ( ( victim = get_char_world( ch, arg3 ) ) == NULL )
{send_to_char( "You cannot find any player by that name.\n\r", ch ); return ;}
if ( IS_NPC( victim ) )
{send_to_char( "Not on NPC's.\n\r", ch ); return ;}
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
obj->questmaker = g_string_assign( obj->questmaker, victim->name->str );
send_to_char( "Ok.\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "name" ) )
{
obj->name = g_string_assign( obj->name, arg3 );
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "short" ) )
{
obj->name = g_string_assign( obj->name, arg3 );
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "long" ) )
{
obj->description = g_string_assign( obj->description, arg3 );
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
if ( !str_cmp( arg2, "ed" ) )
{
EXTRA_DESCR_DATA * ed;
argument = one_argument( argument, arg3 );
if ( argument == NULL )
{
send_to_char( "Syntax: oset <object> ed <keyword> <string>\n\r",
ch );
return ;
}
/*
if ( extra_descr_free == NULL )
{
ed = alloc_perm( sizeof(*ed) );
}
else
{
ed = extra_descr_free;
extra_descr_free = ed;
}
*/
ed = new_extra_descr();
ed->keyword = g_strdup( arg3 );
ed->description = g_strdup( argument );
ed->next = obj->extra_descr;
obj->extra_descr = ed;
send_to_char( "Ok.\n\r", ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
return ;
}
/*
* Generate usage message.
*/
do_oset( ch, "" );
return ;
}
void do_rset( CHAR_DATA *ch, char *argument )
{
char arg1 [ MAX_INPUT_LENGTH ];
char arg2 [ MAX_INPUT_LENGTH ];
char arg3 [ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
ROOM_INDEX_DATA *location;
int value;
sprintf( buf, "%s: Rset %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
str_cpy( arg3, argument );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' || arg3[ 0 ] == '\0' )
{
send_to_char( "Syntax: rset <location> <field> value\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "Field being one of:\n\r", ch );
send_to_char( " flags sector\n\r", ch );
return ;
}
if ( ( location = find_location( ch, arg1 ) ) == NULL )
{
send_to_char( "No such location.\n\r", ch );
return ;
}
/*
* Snarf the value.
*/
if ( !is_number( arg3 ) )
{
send_to_char( "Value must be numeric.\n\r", ch );
return ;
}
value = atoi( arg3 );
/*
* Set something.
*/
if ( !str_cmp( arg2, "flags" ) )
{
location->room_flags = value;
return ;
}
if ( !str_cmp( arg2, "sector" ) )
{
location->sector_type = value;
return ;
}
/*
* Generate usage message.
*/
do_rset( ch, "" );
return ;
}
struct desc_index
{
DESCRIPTOR_DATA *d;
};
typedef struct desc_index DESCRIPTOR_INDEX;
int sort_d_list( const void *v1, const void *v2 )
{
DESCRIPTOR_INDEX d1 = *( DESCRIPTOR_INDEX * ) v1;
DESCRIPTOR_INDEX d2 = *( DESCRIPTOR_INDEX * ) v2;
int i;
for ( i = 0; d1.d->host->str[ i ] != '\0'; i++ )
{
if ( d1.d->host->str[ i ] == d2.d->host->str[ i ] )
continue;
if ( d2.d->host->str[ i ] == '\0' )
return 1;
if ( d1.d->host->str[ i ] > d2.d->host->str[ i ] )
return 1;
if ( d1.d->host->str[ i ] < d2.d->host->str[ i ] )
return -1;
}
return 0;
}
void sort_user_host( CHAR_DATA *ch )
{
char buf[ MAX_STRING_LENGTH ];
char buf2[ MAX_STRING_LENGTH ];
DESCRIPTOR_DATA *d;
DESCRIPTOR_INDEX d_sort[ 100 ];
int count, i;
char * st;
char s[ 100 ];
char idle[ 10 ];
CHAR_DATA *vch;
GSList *desc_list;
count = 0;
buf[ 0 ] = '\0';
buf2[ 0 ] = '\0';
send_to_char( "Sorted!\n\r", ch );
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->character != NULL && can_see( ch, d->character ) )
{
d_sort[ count ].d = d;
count++;
}
}
/* index array, count, size of singe cell, sort command */
qsort( d_sort, count, sizeof( DESCRIPTOR_INDEX ), sort_d_list );
for ( i = 0; i < count; i++ )
{
d = d_sort[ i ].d;
if ( d == NULL )
continue;
/* NB: You may need to edit the CON_ values */
switch ( d->connected )
{
case CON_PLAYING:
st = " PLAYING ";
break;
case CON_GET_NAME:
st = " Get Name ";
break;
case CON_GET_OLD_PASSWORD:
st = "Get Old Passwd ";
break;
case CON_CONFIRM_NEW_NAME:
st = " Confirm Name ";
break;
case CON_GET_NEW_PASSWORD:
st = "Get New Passwd ";
break;
case CON_CONFIRM_NEW_PASSWORD:
st = "Confirm Passwd ";
break;
case CON_READ_MOTD:
st = " Reading MOTD ";
break;
case CON_NOT_PLAYING:
st = " Not Playing ";
break;
case CON_NOTE_TO:
st = " Note To ";
break;
case CON_NOTE_SUBJECT:
st = " Note Subject ";
break;
case CON_NOTE_TEXT:
st = " Note Text ";
break;
case CON_NOTE_FINISH:
st = " Note Finish ";
break;
case CON_COPYOVER_RECOVER:
st = "CopyoverRecover";
break;
case CON_READLOG:
st = " Readlog ";
break;
default:
st = " !UNKNOWN! ";
break;
}
/* Format "login" value... */
vch = d->original ? d->original : d->character;
strftime( s, 100, "%I:%M%p", localtime( &vch->logon ) );
if ( vch->level <= LEVEL_HERO && vch->timer > 0 )
sprintf( idle, "%-2d", vch->timer );
else
sprintf( idle, " " );
sprintf( buf, "[%3d {r%s{x %7s %2s] {b%-12s{x {Y%-32.32s{x\n\r",
d->descriptor,
st,
s,
idle,
( d->original ) ? d->original->name->str
: ( d->character ) ? d->character->name->str
: "(None!)",
d->host->str );
strcat( buf2, buf );
}
sprintf( buf, "\n\r%d user%s\n\r", count, count == 1 ? "" : "s" );
strcat( buf2, buf );
send_to_char( buf2, ch );
return ;
}
void do_users( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char buf2[ MAX_STRING_LENGTH ];
DESCRIPTOR_DATA *d;
int count;
GSList *desc_list;
count = 0;
buf[ 0 ] = '\0';
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->character != NULL && can_see( ch, d->character ) )
{
count++;
if ( strlen( d->character->lasthost->str ) < 2 )
{
sprintf( buf + strlen( buf ), "[%3d %2d] %s@%s\n\r",
d->descriptor,
d->connected,
d->original ? d->original->name->str :
d->character ? d->character->name->str : "(none)",
d->host->str
);
}
else
{
sprintf( buf + strlen( buf ), "[%3d %2d] %s@%s\n\r",
d->descriptor,
d->connected,
d->original ? d->original->name->str :
d->character ? d->character->name->str : "(none)",
d->character->lasthost->str
);
}
}
}
sprintf( buf2, "%d user%s\n\r", count, count == 1 ? "" : "s" );
send_to_char( buf2, ch );
send_to_char( buf, ch );
return ;
}
void do_newusers( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * vch;
DESCRIPTOR_DATA *d;
char buf [ MAX_STRING_LENGTH ];
char buf2 [ MAX_STRING_LENGTH ];
int count;
char arg [ MAX_STRING_LENGTH ];
char * st;
char s[ 100 ];
char idle[ 10 ];
GSList *desc_list;
argument = one_argument( argument, arg );
if ( arg[ 0 ] != '\0' )
{
if ( !strcmp( arg, "host" ) )
sort_user_host( ch );
return ;
}
count = 0;
buf[ 0 ] = '\0';
buf2[ 0 ] = '\0';
strcat( buf2, "\n\r[Num Connected_State Login@ Idl] Player Name Host\n\r" );
strcat( buf2,
"--------------------------------------------------------------------------------\n\r"
);
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->character && can_see( ch, d->character ) )
{
/* NB: You may need to edit the CON_ values */
switch ( d->connected )
{
case CON_PLAYING:
st = " PLAYING ";
break;
case CON_GET_NAME:
st = " Get Name ";
break;
case CON_GET_OLD_PASSWORD:
st = "Get Old Passwd ";
break;
case CON_CONFIRM_NEW_NAME:
st = " Confirm Name ";
break;
case CON_GET_NEW_PASSWORD:
st = "Get New Passwd ";
break;
case CON_CONFIRM_NEW_PASSWORD:
st = "Confirm Passwd ";
break;
case CON_READ_MOTD:
st = " Reading MOTD ";
break;
case CON_NOT_PLAYING:
st = " Not Playing ";
break;
case CON_NOTE_TO:
st = " Note To ";
break;
case CON_NOTE_SUBJECT:
st = " Note Subject ";
break;
case CON_NOTE_TEXT:
st = " Note Text ";
break;
case CON_NOTE_FINISH:
st = " Note Finish ";
break;
case CON_COPYOVER_RECOVER:
st = "CopyoverRecover";
break;
case CON_READLOG:
st = " Readlog ";
break;
default:
st = " !UNKNOWN! ";
break;
}
count++;
/* Format "login" value... */
vch = d->original ? d->original : d->character;
strftime( s, 100, "%I:%M%p", localtime( &vch->logon ) );
if ( vch->level <= LEVEL_HERO && vch->timer > 0 )
sprintf( idle, "%-2d", vch->timer );
else
sprintf( idle, " " );
sprintf( buf, "[%3d {r%s{x %7s %2s] {b%-12s{x {Y%-32.32s{x\n\r",
d->descriptor,
st,
s,
idle,
( d->original ) ? d->original->name->str
: ( d->character ) ? d->character->name->str
: "(None!)",
d->host->str );
strcat( buf2, buf );
}
}
sprintf( buf, "\n\r%d user%s\n\r", count, count == 1 ? "" : "s" );
strcat( buf2, buf );
send_to_char( buf2, ch );
return ;
}
/*
* Thanks to Grodyn for pointing out bugs in this function.
*/
void do_force( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
sprintf( buf, "%s: Force %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
argument = one_argument( argument, arg );
if ( arg[ 0 ] == '\0' || argument[ 0 ] == '\0' )
{
send_to_char( "Force whom to do what?\n\r", ch );
return ;
}
if ( !str_cmp( arg, "all" ) )
{
CHAR_DATA * vch;
CHAR_DATA *vch_next;
if ( get_trust( ch ) < LEVEL_JUDGE )
{
send_to_char( "Nope.. not at your level.\n\r", ch );
return ;
}
for ( vch = char_list; vch != NULL; vch = vch_next )
{
vch_next = vch->next;
if ( !IS_NPC( vch ) && get_trust( vch ) < get_trust( ch ) )
{
act( "$n forces you to '$t'.", ch, argument, vch, TO_VICT );
interpret( vch, argument );
}
}
}
else
{
CHAR_DATA *victim;
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( victim == ch )
{
send_to_char( "Aye aye, right away!\n\r", ch );
return ;
}
if ( get_trust( ch ) < LEVEL_JUDGE && !IS_NPC( victim ) )
{
send_to_char( "You can only force mobs.\n\r", ch );
return ;
}
if ( get_trust( victim ) >= get_trust( ch ) )
{
send_to_char( "Do it yourself!\n\r", ch );
return ;
}
act( "$n forces you to '$t'.", ch, argument, victim, TO_VICT );
interpret( victim, argument );
}
send_to_char( "Ok.\n\r", ch );
mudsetting->last_proc_logged = 12;
return ;
}
void do_forceauto( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * vch;
CHAR_DATA *vch_next;
for ( vch = char_list; vch != NULL; vch = vch_next )
{
vch_next = vch->next;
if ( !IS_NPC( vch ) && vch != ch )
{
act( "Autocommand: $t.", ch, argument, vch, TO_VICT );
interpret( vch, argument );
}
}
mudsetting->last_proc_logged = 13;
return ;
}
/*
* New routines by Dionysos.
*/
void do_invis( CHAR_DATA *ch, char *argument )
{
int level;
char arg[ MAX_STRING_LENGTH ];
/* RT code for taking a level argument */
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
/* take the default path */
if ( ch->invis_level )
{
if ( IS_SET( ch->act, PLR_WIZINVIS ) )
{
REMOVE_BIT( ch->act, PLR_WIZINVIS );
}
ch->invis_level = 0;
act( "$n slowly fades into existence.", ch, NULL, NULL, TO_ROOM );
send_to_char( "You slowly fade back into existence.\n\r", ch );
}
else
{
if ( !IS_SET( ch->act, PLR_WIZINVIS ) )
{
SET_BIT( ch->act, PLR_WIZINVIS );
}
ch->invis_level = get_trust( ch );
act( "$n slowly fades into thin air.", ch, NULL, NULL, TO_ROOM );
send_to_char( "You slowly vanish into thin air.\n\r", ch );
}
else
/* do the level thing */
{
level = atoi( arg );
if ( level < 2 || level > get_trust( ch ) )
{
send_to_char( "Invis level must be between 2 and your level.\n\r", ch );
return ;
}
else
{
if ( !IS_SET( ch->act, PLR_WIZINVIS ) )
{
SET_BIT( ch->act, PLR_WIZINVIS );
}
ch->reply = NULL;
ch->invis_level = level;
act( "$n slowly fades into thin air.", ch, NULL, NULL, TO_ROOM );
send_to_char( "You slowly vanish into thin air.\n\r", ch );
}
}
return ;
}
void do_incog( CHAR_DATA *ch, char *argument )
{
if ( IS_NPC( ch ) )
return ;
if ( IS_SET( ch->act, PLR_INCOG ) )
{
REMOVE_BIT( ch->act, PLR_INCOG );
act( "$n slowly fades into existence.", ch, NULL, NULL, TO_ROOM );
send_to_char( "You slowly fade back into existence.\n\r", ch );
}
else
{
act( "$n slowly fades into thin air.", ch, NULL, NULL, TO_ROOM );
send_to_char( "You slowly vanish into thin air.\n\r", ch );
SET_BIT( ch->act, PLR_INCOG );
}
return ;
}
void do_holylight( CHAR_DATA *ch, char *argument )
{
if ( IS_NPC( ch ) )
return ;
if ( IS_SET( ch->act, PLR_HOLYLIGHT ) )
{
REMOVE_BIT( ch->act, PLR_HOLYLIGHT );
send_to_char( "Holy light mode off.\n\r", ch );
}
else
{
SET_BIT( ch->act, PLR_HOLYLIGHT );
send_to_char( "Holy light mode on.\n\r", ch );
}
return ;
}
void do_safe( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
one_argument( argument, arg );
if ( ch->in_room != NULL && is_tempsafe( ch ) && weather_info[ ch->in_room->sector_type ].sunlight != SUN_DARK )
send_to_char( "You cannot be attacked by other players here.\n\r", ch );
else
send_to_char( "You are not safe from player attacks in this room.\n\r", ch );
if ( !IS_CLASS( ch, CLASS_VAMPIRE ) )
return ;
if ( ch->in_room->sector_type == SECT_INSIDE )
{
send_to_char( "You are inside, which means you are safe from sunlight.\n\r", ch );
return ;
}
if ( weather_info[ ch->in_room->sector_type ].sunlight == SUN_DARK )
{
send_to_char( "It is not yet light out, so you are safe from the sunlight...for now.\n\r", ch );
return ;
}
if ( room_is_dark( ch->in_room ) )
{
send_to_char( "This room is dark, and will protect you from the sunlight.\n\r", ch );
return ;
}
send_to_char( "This room will provide you no protection from the sunlight.\n\r", ch );
return ;
}
void do_qstat( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
OBJ_DATA *obj;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Which item?\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg ) ) == NULL )
{
send_to_char( "You are not carrying that item.\n\r", ch );
return ;
}
sprintf( buf, "Object %s.\n\r", obj->short_descr->str );
send_to_char( buf, ch );
sprintf( buf, "Owner when worn: %s\n\r", obj->chpoweron->str );
send_to_char( buf, ch );
sprintf( buf, "Other when worn: %s\n\r", obj->victpoweron->str );
send_to_char( buf, ch );
sprintf( buf, "Owner when removed: %s\n\r", obj->chpoweroff->str );
send_to_char( buf, ch );
sprintf( buf, "Other when removed: %s\n\r", obj->victpoweroff->str );
send_to_char( buf, ch );
sprintf( buf, "Owner when used: %s\n\r", obj->chpoweruse->str );
send_to_char( buf, ch );
sprintf( buf, "Other when used: %s\n\r", obj->victpoweruse->str );
send_to_char( buf, ch );
send_to_char( "Type:", ch );
if ( IS_SET( obj->spectype, SITEM_ACTIVATE ) )
send_to_char( " Activate", ch );
if ( IS_SET( obj->spectype, SITEM_TWIST ) )
send_to_char( " Twist", ch );
if ( IS_SET( obj->spectype, SITEM_PRESS ) )
send_to_char( " Press", ch );
if ( IS_SET( obj->spectype, SITEM_PULL ) )
send_to_char( " Pull", ch );
if ( IS_SET( obj->spectype, SITEM_TARGET ) )
send_to_char( " Target", ch );
if ( IS_SET( obj->spectype, SITEM_SPELL ) )
send_to_char( " Spell", ch );
if ( IS_SET( obj->spectype, SITEM_TRANSPORTER ) )
send_to_char( " Transporter", ch );
if ( IS_SET( obj->spectype, SITEM_TELEPORTER ) )
send_to_char( " Teleporter", ch );
if ( IS_SET( obj->spectype, SITEM_OBJECT ) )
send_to_char( " Object", ch );
if ( IS_SET( obj->spectype, SITEM_MOBILE ) )
send_to_char( " Mobile", ch );
if ( IS_SET( obj->spectype, SITEM_ACTION ) )
send_to_char( " Action", ch );
if ( IS_SET( obj->spectype, SITEM_DELAY1 ) )
send_to_char( " Delay1", ch );
if ( IS_SET( obj->spectype, SITEM_DELAY2 ) )
send_to_char( " Delay2", ch );
if ( !IS_SET( obj->spectype, SITEM_ACTIVATE )
&& !IS_SET( obj->spectype, SITEM_TWIST )
&& !IS_SET( obj->spectype, SITEM_PRESS )
&& !IS_SET( obj->spectype, SITEM_PULL )
&& !IS_SET( obj->spectype, SITEM_TARGET )
&& !IS_SET( obj->spectype, SITEM_SPELL )
&& !IS_SET( obj->spectype, SITEM_TELEPORTER )
&& !IS_SET( obj->spectype, SITEM_DELAY1 )
&& !IS_SET( obj->spectype, SITEM_DELAY2 )
&& !IS_SET( obj->spectype, SITEM_OBJECT )
&& !IS_SET( obj->spectype, SITEM_MOBILE )
&& !IS_SET( obj->spectype, SITEM_ACTION )
&& !IS_SET( obj->spectype, SITEM_TRANSPORTER ) )
send_to_char( " No flags set", ch );
send_to_char( ".\n\r", ch );
sprintf( buf, "Power: %d.\n\r", obj->specpower );
send_to_char( buf, ch );
return ;
}
void do_qset( CHAR_DATA *ch, 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;
int value;
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
str_cpy( arg3, argument );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' || arg3[ 0 ] == '0' )
{
send_to_char( "You can change the following fields...\n\r", ch );
send_to_char( "chwear = Message to owner when item is worn.\n\r", ch );
send_to_char( "chrem = Message to owner when item is removed.\n\r", ch );
send_to_char( "chuse = Message to owner when item is used.\n\r", ch );
send_to_char( "victwear = Message to others in room when item is worn.\n\r", ch );
send_to_char( "victrem = Message to others in room when item is removed.\n\r", ch );
send_to_char( "victuse = Message to others in room when item is used.\n\r", ch );
send_to_char( "type activate = Item can be activated.\n\r", ch );
send_to_char( " twist = Item can be twisted.\n\r", ch );
send_to_char( " press = Item can be pressed.\n\r", ch );
send_to_char( " pull = Item can be pulled.\n\r", ch );
send_to_char( " target = Item can target people (for spell, etc).\n\r", ch );
send_to_char( " spell = Item can cast spells.\n\r", ch );
send_to_char( " transporter = Owner can transport freely between two locations.\n\r", ch );
send_to_char( " teleporter = Owner can transport to target location at will.\n\r", ch );
send_to_char( " object = Owner can create the specified object.\n\r", ch );
send_to_char( " mobile = Owner can create the specified mobile.\n\r", ch );
send_to_char( " action = Target must perform an action.\n\r", ch );
send_to_char( " delay1 = Sets a delay of half a round on spell items.\n\r", ch );
send_to_char( " delay2 = Sets a delay of one round on spell items.\n\r", ch );
send_to_char( "power <value> = Spell number/transporter room number.\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg1 ) ) == NULL )
{
send_to_char( "You are not carrying that item.\n\r", ch );
return ;
}
value = is_number( arg3 ) ? atoi( arg3 ) : -1;
if ( !str_cmp( arg2, "chwear" ) )
{
if ( obj->chpoweron != NULL )
str_cpy( buf, obj->chpoweron->str );
if ( !str_cmp( arg3, "clear" ) )
{
obj->chpoweron = g_string_assign( obj->chpoweron, "(null)" );
}
else if ( obj->chpoweron != NULL && buf[ 0 ] != '\0' && str_cmp( buf, "(null)" ) )
{
if ( strlen( buf ) + strlen( arg3 ) >= MAX_STRING_LENGTH - 4 )
{
send_to_char( "Line too long.\n\r", ch );
return ;
}
else
{
strcat( buf, "\n\r" );
strcat( buf, arg3 );
obj->chpoweron = g_string_assign( obj->chpoweron, buf );
}
}
else
{
obj->chpoweron = g_string_assign( obj->chpoweron, arg3 );
}
}
else if ( !str_cmp( arg2, "chrem" ) )
{
if ( obj->chpoweroff != NULL )
str_cpy( buf, obj->chpoweroff->str );
if ( !str_cmp( arg3, "clear" ) )
{
obj->chpoweroff = g_string_assign( obj->chpoweroff, "(null)" );
}
else if ( obj->chpoweroff != NULL && buf[ 0 ] != '\0' && str_cmp( buf, "(null)" ) )
{
if ( strlen( buf ) + strlen( arg3 ) >= MAX_STRING_LENGTH - 4 )
{
send_to_char( "Line too long.\n\r", ch );
return ;
}
else
{
strcat( buf, "\n\r" );
strcat( buf, arg3 );
obj->chpoweroff = g_string_assign( obj->chpoweroff, buf );
}
}
else
{
obj->chpoweroff = g_string_assign( obj->chpoweroff, arg3 );
}
}
else if ( !str_cmp( arg2, "chuse" ) )
{
if ( obj->chpoweruse != NULL )
str_cpy( buf, obj->chpoweruse->str );
if ( !str_cmp( arg3, "clear" ) )
{
obj->chpoweruse = g_string_assign( obj->chpoweruse, "(null)" );
}
else if ( obj->chpoweruse != NULL && buf[ 0 ] != '\0' && str_cmp( buf, "(null)" ) )
{
if ( strlen( buf ) + strlen( arg3 ) >= MAX_STRING_LENGTH - 4 )
{
send_to_char( "Line too long.\n\r", ch );
return ;
}
else
{
strcat( buf, "\n\r" );
strcat( buf, arg3 );
obj->chpoweruse = g_string_assign( obj->chpoweruse, buf );
}
}
else
{
obj->chpoweruse = g_string_assign( obj->chpoweruse, arg3 );
}
}
else if ( !str_cmp( arg2, "victwear" ) )
{
if ( obj->victpoweron != NULL )
str_cpy( buf, obj->victpoweron->str );
if ( !str_cmp( arg3, "clear" ) )
{
obj->victpoweron = g_string_assign( obj->victpoweron, "(null)" );
}
else if ( obj->victpoweron != NULL && buf[ 0 ] != '\0' && str_cmp( buf, "(null)" ) )
{
if ( strlen( buf ) + strlen( arg3 ) >= MAX_STRING_LENGTH - 4 )
{
send_to_char( "Line too long.\n\r", ch );
return ;
}
else
{
strcat( buf, "\n\r" );
strcat( buf, arg3 );
obj->victpoweron = g_string_assign( obj->victpoweron, buf );
}
}
else
{
obj->victpoweron = g_string_assign( obj->victpoweron, arg3 );
}
}
else if ( !str_cmp( arg2, "victrem" ) )
{
if ( obj->victpoweroff != NULL )
str_cpy( buf, obj->victpoweroff->str );
if ( !str_cmp( arg3, "clear" ) )
{
obj->victpoweroff = g_string_assign( obj->victpoweroff, "(null)" );
}
else if ( obj->victpoweroff != NULL && buf[ 0 ] != '\0' && str_cmp( buf, "(null)" ) )
{
if ( strlen( buf ) + strlen( arg3 ) >= MAX_STRING_LENGTH - 4 )
{
send_to_char( "Line too long.\n\r", ch );
return ;
}
else
{
strcat( buf, "\n\r" );
strcat( buf, arg3 );
obj->victpoweroff = g_string_assign( obj->victpoweroff, buf );
}
}
else
{
obj->victpoweroff = g_string_assign( obj->victpoweroff, arg3 );
}
}
else if ( !str_cmp( arg2, "victuse" ) )
{
if ( obj->victpoweruse != NULL )
str_cpy( buf, obj->victpoweruse->str );
if ( !str_cmp( arg3, "clear" ) )
{
obj->victpoweruse = g_string_assign( obj->victpoweruse, "(null)" );
}
else if ( obj->victpoweruse != NULL && buf[ 0 ] != '\0' && str_cmp( buf, "(null)" ) )
{
if ( strlen( buf ) + strlen( arg3 ) >= MAX_STRING_LENGTH - 4 )
{
send_to_char( "Line too long.\n\r", ch );
return ;
}
else
{
strcat( buf, "\n\r" );
strcat( buf, arg3 );
obj->victpoweruse = g_string_assign( obj->victpoweruse, buf );
}
}
else
{
obj->victpoweruse = g_string_assign( obj->victpoweruse, arg3 );
}
}
else if ( !str_cmp( arg2, "type" ) )
{
if ( !str_cmp( arg3, "activate" ) && IS_SET( obj->spectype, SITEM_ACTIVATE ) )
REMOVE_BIT( obj->spectype, SITEM_ACTIVATE );
else if ( !str_cmp( arg3, "activate" ) && !IS_SET( obj->spectype, SITEM_ACTIVATE ) )
SET_BIT( obj->spectype, SITEM_ACTIVATE );
else if ( !str_cmp( arg3, "twist" ) && IS_SET( obj->spectype, SITEM_TWIST ) )
REMOVE_BIT( obj->spectype, SITEM_TWIST );
else if ( !str_cmp( arg3, "twist" ) && !IS_SET( obj->spectype, SITEM_TWIST ) )
SET_BIT( obj->spectype, SITEM_TWIST );
else if ( !str_cmp( arg3, "press" ) && IS_SET( obj->spectype, SITEM_PRESS ) )
REMOVE_BIT( obj->spectype, SITEM_PRESS );
else if ( !str_cmp( arg3, "press" ) && !IS_SET( obj->spectype, SITEM_PRESS ) )
SET_BIT( obj->spectype, SITEM_PRESS );
else if ( !str_cmp( arg3, "pull" ) && IS_SET( obj->spectype, SITEM_PULL ) )
REMOVE_BIT( obj->spectype, SITEM_PULL );
else if ( !str_cmp( arg3, "pull" ) && !IS_SET( obj->spectype, SITEM_PULL ) )
SET_BIT( obj->spectype, SITEM_PULL );
else if ( !str_cmp( arg3, "target" ) && IS_SET( obj->spectype, SITEM_TARGET ) )
REMOVE_BIT( obj->spectype, SITEM_TARGET );
else if ( !str_cmp( arg3, "target" ) && !IS_SET( obj->spectype, SITEM_TARGET ) )
SET_BIT( obj->spectype, SITEM_TARGET );
else if ( !str_cmp( arg3, "spell" ) && IS_SET( obj->spectype, SITEM_SPELL ) )
REMOVE_BIT( obj->spectype, SITEM_SPELL );
else if ( !str_cmp( arg3, "spell" ) && !IS_SET( obj->spectype, SITEM_SPELL ) )
SET_BIT( obj->spectype, SITEM_SPELL );
else if ( !str_cmp( arg3, "transporter" ) && IS_SET( obj->spectype, SITEM_TRANSPORTER ) )
REMOVE_BIT( obj->spectype, SITEM_TRANSPORTER );
else if ( !str_cmp( arg3, "transporter" ) && !IS_SET( obj->spectype, SITEM_TRANSPORTER ) )
SET_BIT( obj->spectype, SITEM_TRANSPORTER );
else if ( !str_cmp( arg3, "teleporter" ) && IS_SET( obj->spectype, SITEM_TELEPORTER ) )
REMOVE_BIT( obj->spectype, SITEM_TELEPORTER );
else if ( !str_cmp( arg3, "teleporter" ) && !IS_SET( obj->spectype, SITEM_TELEPORTER ) )
SET_BIT( obj->spectype, SITEM_TELEPORTER );
else if ( !str_cmp( arg3, "object" ) && IS_SET( obj->spectype, SITEM_OBJECT ) )
REMOVE_BIT( obj->spectype, SITEM_OBJECT );
else if ( !str_cmp( arg3, "object" ) && !IS_SET( obj->spectype, SITEM_OBJECT ) )
SET_BIT( obj->spectype, SITEM_OBJECT );
else if ( !str_cmp( arg3, "mobile" ) && IS_SET( obj->spectype, SITEM_MOBILE ) )
REMOVE_BIT( obj->spectype, SITEM_MOBILE );
else if ( !str_cmp( arg3, "mobile" ) && !IS_SET( obj->spectype, SITEM_MOBILE ) )
SET_BIT( obj->spectype, SITEM_MOBILE );
else if ( !str_cmp( arg3, "action" ) && IS_SET( obj->spectype, SITEM_ACTION ) )
REMOVE_BIT( obj->spectype, SITEM_ACTION );
else if ( !str_cmp( arg3, "action" ) && !IS_SET( obj->spectype, SITEM_ACTION ) )
SET_BIT( obj->spectype, SITEM_ACTION );
else if ( !str_cmp( arg3, "delay1" ) && IS_SET( obj->spectype, SITEM_DELAY1 ) )
REMOVE_BIT( obj->spectype, SITEM_DELAY1 );
else if ( !str_cmp( arg3, "delay1" ) && !IS_SET( obj->spectype, SITEM_DELAY1 ) )
SET_BIT( obj->spectype, SITEM_DELAY1 );
else if ( !str_cmp( arg3, "delay2" ) && IS_SET( obj->spectype, SITEM_DELAY2 ) )
REMOVE_BIT( obj->spectype, SITEM_DELAY2 );
else if ( !str_cmp( arg3, "delay2" ) && !IS_SET( obj->spectype, SITEM_DELAY2 ) )
SET_BIT( obj->spectype, SITEM_DELAY2 );
else
{
send_to_char( "No such flag to set.\n\r", ch );
return ;
}
sprintf( buf, "%s flag toggled.\n\r", capitalize( arg3 ) );
send_to_char( buf, ch );
return ;
}
else if ( !str_cmp( arg2, "power" ) )
obj->specpower = value;
else
{
send_to_char( "No such flag.\n\r", ch );
return ;
}
send_to_char( "Ok.\n\r", ch );
return ;
}
void do_oclone( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
OBJ_DATA *obj2;
AFFECT_DATA *paf;
AFFECT_DATA *paf2;
argument = one_argument( argument, arg1 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Make a clone of what object?\n\r", ch );
return ;
}
if ( ( obj = get_obj_world( ch, arg1 ) ) == NULL )
{
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
if ( !IS_JUDGE( ch ) && ( obj->questmaker == NULL || str_cmp( ch->name->str, obj->questmaker->str ) || obj->questmaker->len < 2 ) )
{
send_to_char( "You can only clone your own creations.\n\r", ch );
return ;
}
pObjIndex = get_obj_index( obj->pIndexData->vnum );
obj2 = create_object( pObjIndex, obj->level );
/* Copy any changed parts of the object. */
obj2->name = g_string_assign( obj2->name, obj->name->str );
obj2->short_descr = g_string_assign( obj2->short_descr, obj->short_descr->str );
obj2->description = g_string_assign( obj2->description, obj->description->str );
if ( obj->questmaker != NULL && obj->questmaker->len > 1 )
{
obj2->questmaker = g_string_assign( obj2->questmaker, obj->questmaker->str );
}
if ( obj->chpoweron != NULL )
{
obj2->chpoweron = g_string_assign( obj2->chpoweron, obj->chpoweron->str );
}
if ( obj->chpoweroff != NULL )
{
obj2->chpoweroff = g_string_assign( obj2->chpoweroff, obj->chpoweroff->str );
}
if ( obj->chpoweruse != NULL )
{
obj2->chpoweruse = g_string_assign( obj2->chpoweruse, obj->chpoweruse->str );
}
if ( obj->victpoweron != NULL )
{
obj2->victpoweron = g_string_assign( obj2->victpoweron, obj->victpoweron->str );
}
if ( obj->victpoweroff != NULL )
{
obj2->victpoweroff = g_string_assign( obj2->victpoweroff, obj->victpoweroff->str );
}
if ( obj->victpoweruse != NULL )
{
obj2->victpoweruse = g_string_assign( obj2->victpoweruse, obj->victpoweruse->str );
}
obj2->item_type = obj->item_type;
obj2->extra_flags = obj->extra_flags;
obj2->wear_flags = obj->wear_flags;
obj2->weight = obj->weight;
obj2->spectype = obj->spectype;
obj2->specpower = obj->specpower;
obj2->condition = obj->condition;
obj2->toughness = obj->toughness;
obj2->resistance = obj->resistance;
obj2->quest = obj->quest;
obj2->points = obj->points;
obj2->cost = obj->cost;
obj2->value[ 0 ] = obj->value[ 0 ];
obj2->value[ 1 ] = obj->value[ 1 ];
obj2->value[ 2 ] = obj->value[ 2 ];
obj2->value[ 3 ] = obj->value[ 3 ];
/*****************************************/
obj_to_char( obj2, ch );
if ( obj->affected != NULL )
{
for ( paf = obj->affected; paf != NULL; paf = paf->next )
{
paf2 = new_affect();
paf2->type = 0;
paf2->duration = paf->duration;
paf2->location = paf->location;
paf2->modifier = paf->modifier;
paf2->bitvector = 0;
paf2->next = obj2->affected;
obj2->affected = paf2;
}
}
act( "You create a clone of $p.", ch, obj, NULL, TO_CHAR );
return ;
}
void do_evileye( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
int value;
smash_tilde( argument );
argument = one_argument( argument, arg1 );
str_cpy( arg2, argument );
if ( IS_NPC( ch ) || get_disc( ch, DISC_DOMINATE ) < 1 )
{
send_to_char( "Huh?\n\r", ch );
return ;
}
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' )
{
send_to_char( "Format is: evileye <option> <value>\n\r", ch );
send_to_char( "Option ACTION is a text string action performed by you or the viewer.\n\r", ch );
send_to_char( "Option MESSAGE is a text string shown to the person looking at you.\n\r", ch );
send_to_char( "Option TOGGLE has values: spell, self, other.\n\r\n\r", ch );
if ( ch->poweraction != NULL )
{
sprintf( buf, "Current action: %s.\n\r", ch->poweraction->str );
send_to_char( buf, ch );
}
if ( ch->powertype != NULL )
{
sprintf( buf, "Current message: %s.\n\r", ch->powertype->str );
send_to_char( buf, ch );
}
send_to_char( "Current flags:", ch );
if ( IS_SET( ch->spectype, EYE_SPELL ) )
send_to_char( " Spell", ch );
if ( IS_SET( ch->spectype, EYE_SELFACTION ) )
send_to_char( " Self", ch );
if ( IS_SET( ch->spectype, EYE_ACTION ) )
send_to_char( " Other", ch );
if ( !IS_SET( ch->spectype, EYE_SPELL ) &&
!IS_SET( ch->spectype, EYE_SELFACTION ) &&
!IS_SET( ch->spectype, EYE_ACTION ) )
send_to_char( " None", ch );
send_to_char( ".\n\r", ch );
return ;
}
value = is_number( arg2 ) ? atoi( arg2 ) : -1;
if ( !str_cmp( arg1, "action" ) )
{
ch->poweraction = g_string_assign( ch->poweraction, arg2 );
return ;
}
else if ( !str_cmp( arg1, "message" ) )
{
ch->powertype = g_string_assign( ch->powertype, arg2 );
return ;
}
else if ( !str_cmp( arg1, "toggle" ) )
{
if ( !str_cmp( arg2, "spell" ) && IS_SET( ch->spectype, EYE_SPELL ) )
REMOVE_BIT( ch->spectype, EYE_SPELL );
else if ( !str_cmp( arg2, "spell" ) && !IS_SET( ch->spectype, EYE_SPELL ) )
SET_BIT( ch->spectype, EYE_SPELL );
else if ( !str_cmp( arg2, "self" ) && IS_SET( ch->spectype, EYE_SELFACTION ) )
REMOVE_BIT( ch->spectype, EYE_SELFACTION );
else if ( !str_cmp( arg2, "self" ) && !IS_SET( ch->spectype, EYE_SELFACTION ) )
SET_BIT( ch->spectype, EYE_SELFACTION );
else if ( !str_cmp( arg2, "other" ) && IS_SET( ch->spectype, EYE_ACTION ) )
REMOVE_BIT( ch->spectype, EYE_ACTION );
else if ( !str_cmp( arg2, "other" ) && !IS_SET( ch->spectype, EYE_ACTION ) )
SET_BIT( ch->spectype, EYE_ACTION );
else
{
send_to_char( "TOGGLE flag should be one of: spell, self, other.\n\r", ch );
return ;
}
sprintf( buf, "%s flag toggled.\n\r", capitalize( arg2 ) );
send_to_char( buf, ch );
return ;
}
else
{
send_to_char( "Format is: evileye <option> <value>\n\r", ch );
send_to_char( "Option ACTION is a text string action performed by you or the viewer.\n\r", ch );
send_to_char( "Option MESSAGE is a text string shown to the person looking at you.\n\r", ch );
send_to_char( "Option TOGGLE has values: spell, self, other.\n\r\n\r", ch );
if ( ch->poweraction != NULL )
{
sprintf( buf, "Current action: %s.\n\r", ch->poweraction->str );
send_to_char( buf, ch );
}
if ( ch->powertype != NULL )
{
sprintf( buf, "Current message: %s.\n\r", ch->powertype->str );
send_to_char( buf, ch );
}
send_to_char( "Current flags:", ch );
if ( IS_SET( ch->spectype, EYE_SPELL ) )
send_to_char( " Spell", ch );
if ( IS_SET( ch->spectype, EYE_SELFACTION ) )
send_to_char( " Self", ch );
if ( IS_SET( ch->spectype, EYE_ACTION ) )
send_to_char( " Other", ch );
if ( !IS_SET( ch->spectype, EYE_SPELL ) &&
!IS_SET( ch->spectype, EYE_SELFACTION ) &&
!IS_SET( ch->spectype, EYE_ACTION ) )
send_to_char( " None", ch );
send_to_char( ".\n\r", ch );
}
return ;
}
void do_artifact( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
OBJ_DATA *obj;
OBJ_DATA *in_obj;
bool found;
GSList *tmp = object_list;
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
found = FALSE;
while ( tmp != NULL )
{
obj = ( OBJ_DATA* ) tmp->data;
if ( !IS_SET( obj->quest, QUEST_ARTIFACT ) )
{
tmp = g_slist_next( tmp );
continue;
}
found = TRUE;
for ( in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj )
;
if ( in_obj->carried_by != NULL )
{
sprintf( buf, "%s created by %s and carried by %s.\n\r",
obj->short_descr->str, obj->questmaker->str,
PERS( in_obj->carried_by, ch ) );
}
else
{
sprintf( buf, "%s created by %s and in %s.\n\r",
obj->short_descr->str, obj->questmaker->str,
in_obj->in_room == NULL ? "somewhere" : in_obj->in_room->name );
}
buf[ 0 ] = UPPER( buf[ 0 ] );
send_to_char( buf, ch );
tmp = g_slist_next( tmp );
}
g_slist_free( tmp );
if ( !found )
send_to_char( "There are no artifacts in the game.\n\r", ch );
return ;
}
void do_locate( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
OBJ_DATA *obj;
OBJ_DATA *in_obj;
bool found;
GSList *tmp = object_list;
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
found = FALSE;
while ( tmp != NULL )
{
obj = ( OBJ_DATA* ) tmp->data;
if ( !can_see_obj( ch, obj ) || obj->questowner == NULL ||
obj->questowner->len < 2 || str_cmp( ch->name->str, obj->questowner->str ) )
{
tmp = g_slist_next( tmp );
continue;
}
found = TRUE;
for ( in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj )
;
if ( in_obj->carried_by != NULL )
{
sprintf( buf, "%s carried by %s.\n\r",
obj->short_descr->str, PERS( in_obj->carried_by, ch ) );
}
else
{
sprintf( buf, "%s in %s.\n\r",
obj->short_descr->str, in_obj->in_room == NULL
? "somewhere" : in_obj->in_room->name );
}
buf[ 0 ] = UPPER( buf[ 0 ] );
send_to_char( buf, ch );
tmp = g_slist_next( tmp );
}
g_slist_free( tmp );
if ( !found )
send_to_char( "You cannot locate any items belonging to you.\n\r", ch );
return ;
}
void do_claim( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
one_argument( argument, arg );
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
if ( ch->exp < 500 )
{send_to_char( "It costs 500 exp to claim ownership of an item.\n\r", ch ); return ;}
if ( arg[ 0 ] == '\0' )
{
send_to_char( "What object do you wish to claim ownership of?\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg ) ) == NULL )
{send_to_char( "You are not carrying that item.\n\r", ch ); return ;}
if ( obj->item_type == ITEM_QUEST || obj->item_type == ITEM_AMMO ||
obj->item_type == ITEM_EGG || obj->item_type == ITEM_VOODOO ||
obj->item_type == ITEM_MONEY || obj->item_type == ITEM_TREASURE ||
IS_SET( obj->quest, QUEST_ARTIFACT ) )
{
send_to_char( "You cannot claim that item.\n\r", ch );
return ;
}
else if ( obj->chobj != NULL && !IS_NPC( obj->chobj ) &&
obj->chobj->pcdata->obj_vnum != 0 )
{
send_to_char( "You cannot claim that item.\n\r", ch );
return ;
}
if ( obj->questowner != NULL && obj->questowner->len > 1 )
{
if ( !str_cmp( ch->name->str, obj->questowner->str ) )
send_to_char( "But you already own it!\n\r", ch );
else
send_to_char( "Someone else has already claimed ownership to it.\n\r", ch );
return ;
}
ch->exp -= 500;
obj->questowner = g_string_assign( obj->questowner, ch->name->str );
act( "You are now the owner of $p.", ch, obj, NULL, TO_CHAR );
act( "$n is now the owner of $p.", ch, obj, NULL, TO_ROOM );
return ;
}
void do_gift( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( IS_NPC( ch ) )
{send_to_char( "Not while switched.\n\r", ch ); return ;}
if ( ch->exp < 500 )
{send_to_char( "It costs 500 exp to make a gift of an item.\n\r", ch ); return ;}
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' )
{
send_to_char( "Make a gift of which object to whom?\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg1 ) ) == NULL )
{send_to_char( "You are not carrying that item.\n\r", ch ); return ;}
if ( ( victim = get_char_room( ch, arg2 ) ) == NULL )
{send_to_char( "Nobody here by that name.\n\r", ch ); return ;}
if ( obj->item_type == ITEM_FOCI )
{
send_to_char( "You cannot gift the item that is most dearest to your heart.", ch );
return ;
}
if ( obj->points > 3999 )
{
send_to_char( "You can't gift mythical equipment.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( obj->questowner == NULL || obj->questowner->len < 2 )
{
send_to_char( "That item has not yet been claimed.\n\r", ch );
return ;
}
if ( str_cmp( ch->name->str, obj->questowner->str ) )
{
send_to_char( "But you don't own it!\n\r", ch );
return ;
}
ch->exp -= 500;
obj->questowner = g_string_assign( obj->questowner, victim->name->str );
act( "You grant ownership of $p to $N.", ch, obj, victim, TO_CHAR );
act( "$n grants ownership of $p to $N.", ch, obj, victim, TO_NOTVICT );
act( "$n grants ownership of $p to you.", ch, obj, victim, TO_VICT );
return ;
}
void do_create( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
int itemtype = 13;
int level;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
itemtype = ITEM_TRASH;
else if ( !str_cmp( arg1, "light" ) )
itemtype = ITEM_LIGHT;
else if ( !str_cmp( arg1, "scroll" ) )
itemtype = ITEM_SCROLL;
else if ( !str_cmp( arg1, "wand" ) )
itemtype = ITEM_WAND;
else if ( !str_cmp( arg1, "staff" ) )
itemtype = ITEM_STAFF;
else if ( !str_cmp( arg1, "weapon" ) )
itemtype = ITEM_WEAPON;
else if ( !str_cmp( arg1, "treasure" ) )
itemtype = ITEM_TREASURE;
else if ( !str_cmp( arg1, "armor" ) )
itemtype = ITEM_ARMOR;
else if ( !str_cmp( arg1, "armour" ) )
itemtype = ITEM_ARMOR;
else if ( !str_cmp( arg1, "potion" ) )
itemtype = ITEM_POTION;
else if ( !str_cmp( arg1, "furniture" ) )
itemtype = ITEM_FURNITURE;
else if ( !str_cmp( arg1, "trash" ) )
itemtype = ITEM_TRASH;
else if ( !str_cmp( arg1, "container" ) )
itemtype = ITEM_CONTAINER;
else if ( !str_cmp( arg1, "drink" ) )
itemtype = ITEM_DRINK_CON;
else if ( !str_cmp( arg1, "key" ) )
itemtype = ITEM_KEY;
else if ( !str_cmp( arg1, "food" ) )
itemtype = ITEM_FOOD;
else if ( !str_cmp( arg1, "money" ) )
itemtype = ITEM_MONEY;
else if ( !str_cmp( arg1, "boat" ) )
itemtype = ITEM_BOAT;
else if ( !str_cmp( arg1, "corpse" ) )
itemtype = ITEM_CORPSE_NPC;
else if ( !str_cmp( arg1, "fountain" ) )
itemtype = ITEM_FOUNTAIN;
else if ( !str_cmp( arg1, "pill" ) )
itemtype = ITEM_PILL;
else if ( !str_cmp( arg1, "portal" ) )
itemtype = ITEM_PORTAL;
else if ( !str_cmp( arg1, "egg" ) )
itemtype = ITEM_EGG;
else if ( !str_cmp( arg1, "stake" ) )
itemtype = ITEM_STAKE;
else if ( !str_cmp( arg1, "missile" ) )
itemtype = ITEM_MISSILE;
else if ( !str_cmp( arg1, "page" ) )
itemtype = ITEM_PAGE;
else if ( !str_cmp( arg1, "book" ) )
itemtype = ITEM_BOOK;
else
itemtype = ITEM_TRASH;
if ( arg2[ 0 ] == '\0' || !is_number( arg2 ) )
{
level = 0;
}
else
{
level = atoi( arg2 );
if ( level < 1 || level > 50 )
{
send_to_char( "Level should be within range 1 to 50.\n\r", ch );
return ;
}
}
if ( ( pObjIndex = get_obj_index( OBJ_VNUM_PROTOPLASM ) ) == NULL )
{
send_to_char( "Error...missing object, please inform Spiral\n\r", ch );
return ;
}
obj = create_object( pObjIndex, level );
obj->level = level;
obj->item_type = itemtype;
obj_to_char( obj, ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
act( "You reach up into the air and draw out a ball of protoplasm.", ch, obj, NULL, TO_CHAR );
act( "$n reaches up into the air and draws out a ball of protoplasm.", ch, obj, NULL, TO_ROOM );
return ;
}
void do_token( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
CHAR_DATA *victim;
int value;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( IS_NPC( ch ) || ( ch->pcdata->quest < 1 && !IS_JUDGE( ch ) ) )
{
send_to_char( "You are unable to make a quest token.\n\r", ch );
return ;
}
else if ( arg1[ 0 ] == '\0' || !is_number( arg1 ) )
{
send_to_char( "Please specify a value for the quest token.\n\r", ch );
return ;
}
else
{
value = atoi( arg1 );
if ( value < 1 || value > 500 )
{
send_to_char( "Quest token should have a value between 1 and 500.\n\r", ch );
return ;
}
else if ( value > ch->pcdata->quest && !IS_JUDGE( ch ) )
{
sprintf( buf, "You only have %d quest points left to put into tokens.\n\r", ch->pcdata->quest );
send_to_char( buf, ch );
return ;
}
}
victim = get_char_room( ch, arg2 );
if ( ( pObjIndex = get_obj_index( OBJ_VNUM_PROTOPLASM ) ) == NULL )
{
send_to_char( "Error...missing object, please inform Spiral\n\r", ch );
return ;
}
ch->pcdata->quest -= value;
ch->pcdata->spent[ SPENT_T ] += value;
if ( ch->pcdata->quest < 0 )
ch->pcdata->quest = 0;
obj = create_object( pObjIndex, value );
obj->value[ 0 ] = value;
obj->level = 1;
obj->cost = value * 1000;
obj->item_type = ITEM_QUEST;
obj_to_char( obj, ch );
obj->questmaker = g_string_assign( obj->questmaker, ch->name->str );
obj->name = g_string_assign( obj->name, "quest token" );
sprintf( buf, "a %d point quest token", value );
obj->short_descr = g_string_assign( obj->short_descr, buf );
sprintf( buf, "A %d point quest token lies on the floor.", value );
obj->description = g_string_assign( obj->description, buf );
if ( victim != NULL && victim != ch )
{
act( "You reach behind $N's ear and produce $p.", ch, obj, victim, TO_CHAR );
act( "$n reaches behind $N's ear and produces $p.", ch, obj, victim, TO_NOTVICT );
act( "$n reaches behind your ear and produces $p.", ch, obj, victim, TO_VICT );
}
else
{
act( "You snap your fingers and reveal $p.", ch, obj, NULL, TO_CHAR );
act( "$n snaps $s fingers and reveals $p.", ch, obj, NULL, TO_ROOM );
}
return ;
}
void do_qtrust( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: qtrust <char> <on/off>.\n\r", ch );
return ;
}
if ( arg2[ 0 ] == '\0' )
{
send_to_char( "Do you wish to set qtrust ON or OFF?\n\r", ch );
return ;
}
if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
{
send_to_char( "That player is not here.\n\r", ch );
return ;
}
if ( str_cmp( arg2, "on" ) && str_cmp( arg2, "off" ) )
{
send_to_char( "Do you want to set their qtrust ON or OFF?\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "off" ) )
{
if ( !IS_EXTRA( victim, EXTRA_TRUSTED ) )
{
send_to_char( "Their qtrust is already off.\n\r", ch );
return ;
}
REMOVE_BIT( victim->extra, EXTRA_TRUSTED );
send_to_char( "Quest trust OFF.\n\r", ch );
send_to_char( "You are no longer quest trusted.\n\r", victim );
return ;
}
else if ( !str_cmp( arg2, "on" ) )
{
if ( IS_EXTRA( victim, EXTRA_TRUSTED ) )
{
send_to_char( "Their qtrust is already on.\n\r", ch );
return ;
}
SET_BIT( victim->extra, EXTRA_TRUSTED );
send_to_char( "Quest trust ON.\n\r", ch );
send_to_char( "You are now quest trusted.\n\r", victim );
return ;
}
return ;
}
void do_ntrust( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: ntrust <char> <on/off>.\n\r", ch );
return ;
}
if ( arg2[ 0 ] == '\0' )
{
send_to_char( "Do you wish to set ntrust ON or OFF?\n\r", ch );
return ;
}
if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
{
send_to_char( "That player is not here.\n\r", ch );
return ;
}
if ( str_cmp( arg2, "on" ) && str_cmp( arg2, "off" ) )
{
send_to_char( "Do you want to set their ntrust ON or OFF?\n\r", ch );
return ;
}
if ( !str_cmp( arg2, "off" ) )
{
if ( !IS_EXTRA( victim, EXTRA_NOTE_TRUST ) )
{
send_to_char( "Their ntrust is already off.\n\r", ch );
return ;
}
REMOVE_BIT( victim->extra, EXTRA_NOTE_TRUST );
send_to_char( "Note trust OFF.\n\r", ch );
send_to_char( "You are no longer note trusted.\n\r", victim );
return ;
}
else if ( !str_cmp( arg2, "on" ) )
{
if ( IS_EXTRA( victim, EXTRA_NOTE_TRUST ) )
{
send_to_char( "Their ntrust is already on.\n\r", ch );
return ;
}
SET_BIT( victim->extra, EXTRA_NOTE_TRUST );
send_to_char( "Note trust ON.\n\r", ch );
send_to_char( "You are now note trusted.\n\r", victim );
return ;
}
return ;
}
void do_otransfer( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
CHAR_DATA *victim;
ROOM_INDEX_DATA *chroom;
ROOM_INDEX_DATA *objroom;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Otransfer which object?\n\r", ch );
return ;
}
if ( arg2[ 0 ] == '\0' )
victim = ch;
else if ( ( victim = get_char_world( ch, arg2 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( ( obj = get_obj_world( ch, arg1 ) ) == NULL )
{
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
if ( !IS_JUDGE( ch ) && ( obj->questmaker == NULL ||
str_cmp( ch->name->str, obj->questmaker->str ) || obj->questmaker->len < 2 ) )
{
send_to_char( "You don't have permission to otransfer that item.\n\r", ch );
return ;
}
if ( obj->carried_by != NULL )
{
if ( !IS_NPC( obj->carried_by ) )
{
send_to_char( "You failed.\n\r", ch );
act( "$p flickers briefly with energy.", obj->carried_by, obj, NULL, TO_CHAR );
return ;
}
act( "$p vanishes from your hands in an explosion of energy.", obj->carried_by, obj, NULL, TO_CHAR );
act( "$p vanishes from $n's hands in an explosion of energy.", obj->carried_by, obj, NULL, TO_ROOM );
obj_from_char( obj );
}
else if ( obj->in_obj != NULL )
obj_from_obj( obj );
else if ( obj->in_room != NULL )
{
chroom = ch->in_room;
objroom = obj->in_room;
char_from_room( ch );
char_to_room( ch, objroom );
act( "$p vanishes from the ground in an explosion of energy.", ch, obj, NULL, TO_ROOM );
if ( chroom == objroom )
act( "$p vanishes from the ground in an explosion of energy.", ch, obj, NULL, TO_CHAR );
char_from_room( ch );
char_to_room( ch, chroom );
obj_from_room( obj );
}
else
{
send_to_char( "You were unable to get it.\n\r", ch );
return ;
}
obj_to_char( obj, victim );
act( "$p appears in your hands in an explosion of energy.", victim, obj, NULL, TO_CHAR );
act( "$p appears in $n's hands in an explosion of energy.", victim, obj, NULL, TO_ROOM );
return ;
}
void bind_char( CHAR_DATA *ch )
{
OBJ_DATA * obj;
OBJ_INDEX_DATA *pObjIndex;
ROOM_INDEX_DATA *location;
if ( IS_NPC( ch ) || ch->pcdata->obj_vnum < 1 )
return ;
if ( ( pObjIndex = get_obj_index( ch->pcdata->obj_vnum ) ) == NULL )
return ;
if ( ch->in_room == NULL || ch->in_room->vnum == ROOM_VNUM_IN_OBJECT )
{
location = get_room_index( ROOM_VNUM_ALTAR );
char_from_room( ch );
char_to_room( ch, location );
}
else
location = ch->in_room;
obj = create_object( pObjIndex, 50 );
obj_to_room( obj, location );
obj->chobj = ch;
ch->pcdata->chobj = obj;
SET_BIT( ch->affected_by, AFF_POLYMORPH );
SET_BIT( ch->extra, EXTRA_OSWITCH );
ch->morph = g_string_assign( ch->morph, obj->short_descr->str );
send_to_char( "You reform yourself.\n\r", ch );
act( "$p fades into existance on the floor.", ch, obj, NULL, TO_ROOM );
do_look( ch, "auto" );
return ;
}
void do_bind( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' || arg2[ 0 ] == '\0' )
{
send_to_char( "Syntax: bind <player> <object>\n\r", ch );
return ;
}
if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
{
send_to_char( "That player is not here.\n\r", ch );
return ;
}
if ( ch == victim )
{
send_to_char( "You can't do this to yourself.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
else if ( IS_AFFECTED( victim, AFF_POLYMORPH ) )
{
send_to_char( "You cannot do this while they are polymorphed.\n\r", ch );
return ;
}
else if ( IS_IMMORTAL( victim ) )
{
send_to_char( "Only on mortals or avatars.\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg2 ) ) == NULL )
{
send_to_char( "You are not carrying that item.\n\r", ch );
return ;
}
if ( obj->questmaker != NULL && obj->questmaker->len > 1 )
{
send_to_char( "You cannot bind someone into a modified item.\n\r", ch );
return ;
}
if ( obj->chobj != NULL )
{
send_to_char( "That item already has someone bound in it.\n\r", ch );
return ;
}
send_to_char( "Ok.\n\r", ch );
act( "$n transforms into a white vapour and pours into $p.", victim, obj, NULL, TO_ROOM );
act( "You transform into a white vapour and pour into $p.", victim, obj, NULL, TO_CHAR );
victim->pcdata->obj_vnum = obj->pIndexData->vnum;
obj->chobj = victim;
victim->pcdata->chobj = obj;
SET_BIT( victim->affected_by, AFF_POLYMORPH );
SET_BIT( victim->extra, EXTRA_OSWITCH );
victim->morph = g_string_assign( victim->morph, obj->short_descr->str );
return ;
}
void do_release( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
CHAR_DATA *victim;
argument = one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Syntax: release <object>\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg ) ) == NULL )
{
send_to_char( "You are not carrying that item.\n\r", ch );
return ;
}
if ( ( victim = obj->chobj ) == NULL )
{
send_to_char( "There is nobody bound in that item.\n\r", ch );
return ;
}
send_to_char( "Ok.\n\r", ch );
victim->pcdata->obj_vnum = 0;
obj->chobj = NULL;
victim->pcdata->chobj = NULL;
REMOVE_BIT( victim->affected_by, AFF_POLYMORPH );
REMOVE_BIT( victim->extra, EXTRA_OSWITCH );
victim->morph = g_string_assign( victim->morph, "" );
act( "A white vapour pours out of $p and forms into $n.", victim, obj, NULL, TO_ROOM );
act( "Your spirit floats out of $p and reforms its body.", victim, obj, NULL, TO_CHAR );
return ;
}
void do_morph( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char arg2[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
OBJ_DATA *morph;
int mnum;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: morph <object> <form>\n\r", ch );
return ;
}
if ( ( obj = get_obj_wear( ch, arg1 ) ) == NULL )
{
if ( ( obj = get_obj_carry( ch, arg1 ) ) == NULL )
{
send_to_char( "You are not carrying that item.\n\r", ch );
return ;
}
}
if ( !IS_SET( obj->spectype, SITEM_MORPH ) )
{
send_to_char( "That item cannot morph.\n\r", ch );
return ;
}
if ( arg2[ 0 ] == '\0' )
{
act( "$p can morph into the following forms:", ch, obj, NULL, TO_CHAR );
show_list_to_char( obj->contains, ch, TRUE, TRUE );
return ;
}
if ( ( morph = get_obj_list( ch, arg2, obj->contains ) ) == NULL )
{
send_to_char( "It cannot assume that form.\n\r", ch );
return ;
}
obj_from_obj( morph );
obj_to_char( morph, ch );
act( "$p morphs into $P in $n's hands!", ch, obj, morph, TO_ROOM );
act( "$p morphs into $P in your hands!", ch, obj, morph, TO_CHAR );
mnum = obj->wear_loc;
obj_from_char( obj );
obj_to_obj( obj, morph );
if ( morph->wear_flags == obj->wear_flags && mnum != WEAR_NONE )
equip_char( ch, morph, mnum );
return ;
}
/* prefix command: it will put the string typed on each line typed */
void do_prefi ( CHAR_DATA *ch, char *argument )
{
send_to_char( "You cannot abbreviate the prefix command.\r\n", ch );
return ;
}
void do_prefix ( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_INPUT_LENGTH ];
if ( argument[ 0 ] == '\0' )
{
if ( ch->prefix->str[ 0 ] == '\0' )
{
send_to_char( "You have no prefix to clear.\r\n", ch );
return ;
}
send_to_char( "Prefix removed.\r\n", ch );
ch->prefix = g_string_assign( ch->prefix, "" );
return ;
}
if ( ch->prefix->str[ 0 ] != '\0' )
{
sprintf( buf, "Prefix changed to %s.\r\n", argument );
}
else
{
sprintf( buf, "Prefix set to %s.\r\n", argument );
}
ch->prefix = g_string_assign( ch->prefix, argument );
return ;
}
void do_spc( CHAR_DATA *ch, char *argument )
{
char arg1 [ MAX_INPUT_LENGTH ];
char arg2 [ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
int count;
smash_tilde( argument );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: spc <victim>\n\r", ch );
send_to_char( "or: spc <victim> <flag_name>\n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "Flag_name being one of:\n\r", ch );
send_to_char( " champion demon_lord prince sire\n\r", ch );
send_to_char( " anarch inconnu antitribu sabbat\n\r", ch );
send_to_char( " camarilla independent inducted\n\r", ch );
send_to_char( " primogen justicar bloodhunt wyrm\n\r", ch );
send_to_char( " pack beta followers technocracy elder\n\r", ch );
send_to_char( "\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
// if (IS_SET(victim->act, PLR_GODLESS) && get_trust(ch) < NO_GODLESS
// && !IS_SET(ch->extra , EXTRA_ANTI_GODLESS))
// {
// send_to_char( "You failed.\n\r", ch );
// return;
// }
if ( arg2[ 0 ] == '\0' )
{
str_cpy( buf, "" );
for ( count = 0 ; spc_flags[ count ].name != NULL ; count++ )
{
if ( IS_SET( victim->special, spc_flags[ count ].bit ) )
{
sprintf( buf + strlen( buf ), "%s\n\r", spc_flags[ count ].name );
}
}
act( "$N has the following SPC bits set:", ch, NULL, victim, TO_CHAR );
if ( strlen( buf ) < 2 )
str_cpy( buf, "none\n\r" );
send_to_char( buf, ch );
return ;
}
/*
* Set something.
*/
for ( count = 0 ; spc_flags[ count ].name != NULL ; count++ )
{
if ( !str_cmp( spc_flags[ count ].name, arg2 ) )
{
if ( spc_flags[ count ].settable )
{
if ( IS_SET( victim->special, spc_flags[ count ].bit ) )
REMOVE_BIT( victim->special, spc_flags[ count ].bit );
else
SET_BIT( victim->special, spc_flags[ count ].bit );
sprintf( buf, "You've toggled the %s bit.\n\r", spc_flags[ count ].name );
send_to_char( buf, ch );
return ;
}
else
{
send_to_char( "That bit cannot be changed.\n\r", ch );
return ;
}
}
}
/*
* Generate usage message.
*/
do_spc( ch, "" );
return ;
}
void do_auto_shutdown()
{
GSList * desc_list;
DESCRIPTOR_DATA *d;
/*
* This allows for a shutdown without somebody in-game actually calling it.
* -Ferric
*/
merc_down = TRUE;
/* This is to write to the file.
fclose(fpReserve);
if((fp = fopen(LAST_COMMAND,"a")) == NULL)
bug("Error in do_auto_save opening last_command.txt",0);
fprintf(fp,"Last Command: %s\n",
last_command);
fclose( fp );
fpReserve = fopen( NULL_FILE, "r" );
*/
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->character )
do_save ( d->character, "" );
close_socket( d );
}
return ;
}
void do_showspecial( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
int count, gt, cmd;
char arg1[ MAX_INPUT_LENGTH ];
bool fFound = FALSE;
char buf2[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
sprintf ( buf, "%s's Current powers:\n\r", victim->name->str );
if ( IS_CLASS( victim, CLASS_VAMPIRE ) )
{
str_cpy( buf, "" );
for ( count = 0 ; count < MAX_DISC ; count++ )
{
if ( get_disc( victim, count ) > 0 && !IS_VAMPPASS( victim, count ) )
{
sprintf( buf2, " %s %d", discipline_table[ count ].name, get_disc( victim, count ) );
strcat( buf, buf2 );
fFound = TRUE;
}
else if ( IS_VAMPPASS( victim, count ) )
{
sprintf( buf2, " %s %d", discipline_table[ count ].name_caps, get_disc( victim, count ) );
strcat( buf, buf2 );
fFound = TRUE;
}
}
}
if ( IS_CLASS( victim, CLASS_WEREWOLF ) )
{
sprintf( buf2, "Totems: Bear (%d), Lynx (%d), Boar (%d), Owl (%d), Spider (%d), Wolf (%d),\n\r Hawk (%d), Mantis (%d), Shark(%d), Sphinx (%d), Rat (%d), Chameleon (%d).\n\r",
victim->pcdata->powers[ WPOWER_BEAR ], victim->pcdata->powers[ WPOWER_LYNX ],
victim->pcdata->powers[ WPOWER_BOAR ], victim->pcdata->powers[ WPOWER_OWL ],
victim->pcdata->powers[ WPOWER_SPIDER ], victim->pcdata->powers[ WPOWER_WOLF ],
victim->pcdata->powers[ WPOWER_HAWK ], victim->pcdata->powers[ WPOWER_MANTIS ],
victim->pcdata->powers[ WPOWER_SHARK ], victim->pcdata->powers[ WPOWER_SPHINX ],
victim->pcdata->powers[ WPOWER_RAT ], victim->pcdata->powers[ WPOWER_CHAMELEON ] );
fFound = TRUE;
strcat( buf, buf2 );
}
if ( IS_CLASS( victim, CLASS_MAGE ) )
{
sprintf( buf2, "Correspondence: %d Entropy: %d Forces: %d\n\r", has_sphere( victim, SPHERE_CORRESPONDENCE ),
has_sphere( victim, SPHERE_ENTROPY ), has_sphere( victim, SPHERE_FORCES ) );
strcat( buf, buf2 );
sprintf( buf2, "Mind: %d Matter: %d Prime: %d\n\r", has_sphere( victim, SPHERE_MIND ),
has_sphere( victim, SPHERE_MATTER ), has_sphere( victim, SPHERE_PRIME ) );
strcat( buf, buf2 );
sprintf( buf2, "Spirit: %d Life: %d Time: %d\n\r", has_sphere( victim, SPHERE_SPIRIT ),
has_sphere( victim, SPHERE_LIFE ), has_sphere( victim, SPHERE_TIME ) );
strcat( buf, buf2 );
fFound = TRUE;
}
if ( IS_SWWF( victim ) )
{
sprintf( buf, "Breed: \n\r" );
for ( cmd = 0; cmd <= BREED_MAX;cmd++ )
{
if ( ( victim->pcdata->breed[ cmd ] == -1 ) || ( victim->pcdata->breed[ cmd ] > 0 ) )
{
if ( victim->pcdata->breed[ cmd ] == -1 )
gt = 0;
else
gt = victim->pcdata->breed[ cmd ];
sprintf( buf2, " {R%s{W: {W({B%d{W){x", breed_table[ cmd ].haunt, gt );
if ( strlen( buf ) >= 70 )
{
strcat( buf, "\n\r" );
send_to_char( buf, ch );
strcpy( buf, buf2 );
}
else
strcat( buf, buf2 );
}
}
if ( buf[ 0 ] != '\0' )
{
strcat( buf, "\n\r" );
send_to_char( buf, ch );
}
sprintf( buf, "Auspice: \n\r" );
for ( cmd = 0; cmd <= AUSPICE_MAX;cmd++ )
{
if ( ( victim->pcdata->auspice[ cmd ] == -1 ) || ( victim->pcdata->auspice[ cmd ] > 0 ) )
{
if ( victim->pcdata->auspice[ cmd ] == -1 )
gt = 0;
else
gt = victim->pcdata->auspice[ cmd ];
sprintf( buf2, " {R%s{W: {W({B%d{W){x", auspice_table[ cmd ].haunt, gt );
if ( strlen( buf ) >= 70 )
{
strcat( buf, "\n\r" );
send_to_char( buf, ch );
strcpy( buf, buf2 );
}
else
strcat( buf, buf2 );
}
}
if ( buf[ 0 ] != '\0' )
{
strcat( buf, "\n\r" );
send_to_char( buf, ch );
}
sprintf( buf, "Tribe: \n\r" );
for ( cmd = 0; cmd <= TRIBE_MAX;cmd++ )
{
if ( ( victim->pcdata->tribes[ cmd ] == -1 ) || ( victim->pcdata->tribes[ cmd ] > 0 ) )
{
if ( victim->pcdata->tribes[ cmd ] == -1 )
gt = 0;
else
gt = victim->pcdata->tribes[ cmd ];
sprintf( buf2, " {R%s{W: {W({B%d{W){x", tribe_table[ cmd ].haunt, gt );
if ( strlen( buf ) >= 70 )
{
strcat( buf, "\n\r" );
send_to_char( buf, ch );
strcpy( buf, buf2 );
}
else
strcat( buf, buf2 );
}
}
if ( buf[ 0 ] != '\0' )
{
strcat( buf, "\n\r" );
send_to_char( buf, ch );
}
}
if ( fFound )
send_to_char( buf, ch );
else
send_to_char( " None", ch );
send_to_char( ".\n\r", ch );
}
void do_outfit( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
OBJ_DATA *obj2;
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
if ( arg1[ 0 ] == '\0' )
victim = ch;
else if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
/*create eq*/
obj = create_object( get_obj_index( OBJ_VNUM_FEARBAG ), ch->level );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARBRAC ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARBRAC ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARAMUL ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARAMUL ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARRING ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARRING ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARCHES ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARHELM ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARLEGP ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARBOOT ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARGAUN ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARARMP ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARSHIL ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARCLOA ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARGIRT ), ch->level );
obj_to_obj( obj2, obj );
obj2 = create_object( get_obj_index( OBJ_VNUM_FEARMASK ), ch->level );
obj_to_obj( obj2, obj );
obj_to_char( obj, victim );
act( "$p appears in your hands in an explosion of energy.", victim, obj, NULL, TO_CHAR );
act( "type 'get all bag' then 'wear all', and you may want to claim it...", victim, obj, NULL, TO_CHAR );
act( "$p appears in $n's hands in an explosion of energy.", victim, obj, NULL, TO_ROOM );
return ;
}
void do_check( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg[ MAX_INPUT_LENGTH ];
GString *buffer;
CHAR_DATA *victim;
int count = 1;
one_argument( argument, arg );
buffer = g_string_new( "" );
if ( arg[ 0 ] == '\0' || !str_prefix( arg, "stats" ) )
{
if ( ch->level < LEVEL_JUDGE )
{
send_to_char( "You can't use this check option.\n\r", ch );
return ;
}
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( IS_NPC( victim ) || !can_see( ch, victim ) )
continue;
if ( victim->desc == NULL )
{
sprintf( buf, "%3d) {r%12s{x is linkdead.\n\r", count, victim->name->str );
buffer = g_string_append( buffer, buf );
count++;
continue;
}
if ( victim->desc->connected == CON_GET_NEW_CLASS )
{
sprintf( buf, "%3d) {r%12s{x is being created.\n\r",
count, victim->name->str );
buffer = g_string_append( buffer, buf );
count++;
continue;
}
if ( ( victim->desc->connected == CON_GET_OLD_PASSWORD
|| victim->desc->connected >= CON_READ_MOTD )
&& get_trust( victim ) <= get_trust( ch ) )
{
sprintf( buf, "%3d) {r%12s{x is connecting.\n\r",
count, victim->name->str );
buffer = g_string_append( buffer, buf );
count++;
continue;
}
if ( victim->desc->connected == CON_PLAYING )
{
if ( get_trust( victim ) > get_trust( ch ) )
sprintf( buf, "%3d) {r%12s{x.\n\r", count, victim->name->str );
else
{
sprintf( buf, "%3d) {r%12s{x, Level %2d connected since {c%2d{x hours ({C%4d{x total hours)\n\r",
count, victim->name->str, victim->level,
( ( int ) ( current_time - victim->logon ) ) / 3600,
( victim->played + ( int ) ( current_time - victim->logon ) ) / 3600 );
buffer = g_string_append( buffer, buf );
if ( arg[ 0 ] != '\0' && !str_prefix( arg, "stats" ) )
{
sprintf( buf, " {R%6d{x HP {R%5d{x Mana (Str:{M%2d{x Int:{M%2d{x Wis:{M%2d{x Dex:{M%2d{x Con:{M%2d{x) {C%3d{x Pr {C%5d{x Qpts.\n\r",
victim->max_hit, victim->max_mana, victim->pcdata->perm_str,
victim->pcdata->perm_int, victim->pcdata->perm_wis,
victim->pcdata->perm_dex, victim->pcdata->perm_con,
victim->practice, victim->pcdata->quest );
buffer = g_string_append( buffer, buf );
}
count++;
}
continue;
}
sprintf( buf, "%3d) bug (oops)...please report to Spiral %s %d\n\r",
count, victim->name->str, victim->desc->connected );
buffer = g_string_append( buffer, buf );
count++;
}
page_to_char( buffer->str, ch );
return ;
}
buffer = g_string_assign( buffer, "" );
if ( !str_prefix( arg, "eq" ) )
{
if ( ch->level < LEVEL_JUDGE )
{
send_to_char( "You can't use this check option.\n\r", ch );
return ;
}
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( IS_NPC( victim )
|| victim->desc == NULL
|| victim->desc->connected != CON_PLAYING
|| !can_see( ch, victim )
|| get_trust( victim ) > get_trust( ch ) )
continue;
sprintf( buf, "%3d) {r%12s{x, {R%3d{x items (weight {R%3d{x) Hit:{R%4d{x Dam:{R%4d{x Save:{r%3d{x AC:{r%5d{x.\n\r",
count, victim->name->str, victim->carry_number, victim->carry_weight,
victim->hitroll, victim->damroll, victim->saving_throw,
victim->armor );
buffer = g_string_append( buffer, buf );
count++;
}
page_to_char( buffer->str, ch );
return ;
}
buffer = g_string_assign( buffer, "" );
if ( !str_prefix( arg, "snoop" ) ) /* this part by jerome */
{
char bufsnoop [ 100 ];
if ( ch->level < MAX_LEVEL )
{
send_to_char( "You can't use this check option.\n\r", ch );
return ;
}
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( IS_NPC( victim )
|| victim->desc == NULL
|| victim->desc->connected != CON_PLAYING
|| !can_see( ch, victim )
|| get_trust( victim ) > get_trust( ch ) )
continue;
if ( victim->desc->snoop_by != NULL && g_slist_length( victim->desc->snoop_by ) > 0 )
{
GSList * snoop_list;
DESCRIPTOR_DATA *snooper;
for ( snoop_list = victim->desc->snoop_by; snoop_list != NULL; snoop_list = g_slist_next( snoop_list ) )
{
snooper = ( DESCRIPTOR_DATA* ) snoop_list->data;
sprintf( bufsnoop, " %15s .", snooper->character->name->str );
}
g_slist_free( snoop_list );
}
else
sprintf( bufsnoop, " (none) ." );
sprintf( buf, "%3d {r%15s{x : {m%s{x \n\r", count, victim->name->str, bufsnoop );
buffer = g_string_append( buffer, buf );
count++;
}
page_to_char( buffer->str, ch );
return ;
}
send_to_char( "Syntax: 'check' display info about players\n\r", ch );
send_to_char( " 'check stats' display info and resume stats\n\r", ch );
send_to_char( " 'check eq' resume eq of all players\n\r", ch );
send_to_char( "Use the stat command in case of doubt about someone...\n\r", ch );
g_string_free( buffer, TRUE );
return ;
}
/* show a list of all used AreaVNUMS */
/* By The Mage */
void do_fvlist ( CHAR_DATA *ch, char *argument )
{
int i, j;
char buf[ MAX_STRING_LENGTH ];
GString *buffer;
char arg[ MAX_INPUT_LENGTH ];
char *string;
int COLUMS = 8;
string = one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Syntax:\n\r", ch );
send_to_char( " fvlist obj\n\r", ch );
send_to_char( " fvlist mob\n\r", ch );
send_to_char( " fvlist room\n\r", ch );
return ;
}
j = 1;
if ( !str_cmp( arg, "obj" ) )
{
sprintf( buf, "{WFree {C%s{W vnum listing for area {C%s{x\n\r", arg,
ch->in_room->area->name );
send_to_char( buf, ch );
sprintf( buf, "{Y=============================================================================={C\n\r" );
send_to_char( buf, ch );
buffer = g_string_new( "" );
for ( i = ch->in_room->area->min_vnum; i <= ch->in_room->area->max_vnum; i++ )
{
if ( get_obj_index( i ) == NULL )
{
sprintf( buf, "%8d, ", i );
if ( j == COLUMS )
{
page_to_char( buffer->str, ch );
send_to_char( "\n\r", ch );
j = 0;
buffer = g_string_assign( buffer, "" );
}
else
{
buffer = g_string_append( buffer, buf );
j++;
}
}
}
send_to_char( "{x\n\r", ch );
g_string_free( buffer, TRUE );
return ;
}
if ( !str_cmp( arg, "mob" ) )
{
sprintf( buf, "{WFree {C%s {Wvnum listing for area {C%s{x\n\r", arg,
ch->in_room->area->name );
send_to_char( buf, ch );
sprintf( buf, "{Y=============================================================================={C\n\r" );
send_to_char( buf, ch );
buffer = g_string_new( "" );
for ( i = ch->in_room->area->min_vnum; i <= ch->in_room->area->max_vnum; i++ )
{
if ( get_mob_index( i ) == NULL )
{
sprintf( buf, "%8d, ", i );
if ( j == COLUMS )
{
page_to_char( buffer->str, ch );
send_to_char( "\n\r", ch );
j = 0;
buffer = g_string_assign( buffer, "" );
}
else
{
buffer = g_string_append( buffer, buf );
j++;
}
}
}
send_to_char( "{x\n\r", ch );
g_string_free( buffer, TRUE );
return ;
}
if ( !str_cmp( arg, "room" ) )
{
sprintf( buf, "{WFree {C%s {Wvnum listing for area {C%s{x\n\r", arg,
ch->in_room->area->name );
send_to_char( buf, ch );
sprintf( buf, "{Y=============================================================================={C\n\r" );
send_to_char( buf, ch );
buffer = g_string_new( "" );
for ( i = ch->in_room->area->min_vnum; i <= ch->in_room->area->max_vnum; i++ )
{
if ( get_room_index( i ) == NULL )
{
sprintf( buf, "%8d, ", i );
if ( j == COLUMS )
{
page_to_char( buffer->str, ch );
send_to_char( "\n\r", ch );
j = 0;
buffer = g_string_assign( buffer, "" );
}
else
{
buffer = g_string_append( buffer, buf );
j++;
}
}
send_to_char( "{x\n\r", ch );
g_string_free( buffer, TRUE );
return ;
}
send_to_char( "WHAT??? \n\r", ch );
send_to_char( "Syntax:\n\r", ch );
send_to_char( " fvlist obj\n\r", ch );
send_to_char( " fvlist mob\n\r", ch );
send_to_char( " fvlist room\n\r", ch );
}
}
/*
* Spiral's Nice Debugging Utils... These will give you the count of
* objects and mobiles at all times.. just make a call to them.
* for instance: check_mobiles("Proc_Name")
* that will check all the mobiles at the time of the call
* and if they changed will report to the bug log with the proc name
* nice huh?
*
* Spiral
*/
void check_both ( char *argument )
{
if ( !IS_SET( mudsetting->mud_setting, MS_DEBUG ) )
return ;
check_object( argument );
check_mobile( argument );
}
void check_object( char *argument )
{
OBJ_DATA * wch;
char buf[ MAX_STRING_LENGTH ];
int sh_count = 0;
GSList *tmp = object_list;
if ( !IS_SET( mudsetting->mud_setting, MS_DEBUG ) )
return ;
while ( tmp != NULL )
{
wch = ( OBJ_DATA* ) tmp->data;
sh_count++;
tmp = g_slist_next( tmp );
}
g_slist_free( tmp );
if ( mudsetting->Obj_Count > sh_count )
{
sprintf( buf, "Change in object count in proc %s, from %d to %d", argument, mudsetting->Obj_Count, sh_count );
g_message( "%s", buf );
bug( buf, 0 );
}
mudsetting->Obj_Count = sh_count;
}
void check_mobile( char *argument )
{
CHAR_DATA * wch;
CHAR_DATA *wch_next = NULL;
char buf[ MAX_STRING_LENGTH ];
int sh_count = 0;
if ( !IS_SET( mudsetting->mud_setting, MS_DEBUG ) )
return ;
for ( wch = char_list; wch != NULL; wch = wch_next )
{
wch_next = wch->next;
sh_count++;
}
if ( mudsetting->Char_Count > sh_count )
{
sprintf( buf, "Change in Mobile count in proc %s, from %d to %d", argument, mudsetting->Char_Count, sh_count );
g_message( "%s", buf );
bug( buf, 0 );
}
mudsetting->Char_Count = sh_count;
}
void do_style( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_INPUT_LENGTH ];
char buf[ MAX_INPUT_LENGTH ];
CHAR_DATA *victim;
argument = one_argument( argument, arg1 );
if ( IS_IMMORTAL( ch ) && arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: style (char).\n\r", ch );
return ;
}
if ( IS_IMMORTAL( ch ) )
{
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
}
else
victim = ch;
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's jerky.\n\r", ch );
return ;
}
sprintf( buf, " Nature: {W%s{x\n\r", victim->pcdata->nature->str );
send_to_char( buf, ch );
sprintf( buf, "Demeanor: {W%s{x\n\r", victim->pcdata->demeanor->str );
send_to_char( buf, ch );
sprintf( buf, "AnonDesc: {W%s{x\n\r", victim->pcdata->anon_desc->str );
send_to_char( buf, ch );
if ( IS_SWWF( victim ) )
{
sprintf( buf, "Auspice: {W%s{x\n\r", auspice_table[ victim->pcdata->sgift[ 2 ] ].haunt );
send_to_char( buf, ch );
}
return ;
}
const char * name_expand ( CHAR_DATA *ch )
{
int count = 1;
CHAR_DATA *rch;
char name[ MAX_INPUT_LENGTH ]; /* HOPEFULLY no mob has a name longer than THAT */
static char outbuf[ MAX_INPUT_LENGTH ];
if ( !IS_NPC( ch ) )
return ch->name->str;
one_argument ( ch->name->str, name ); /* copy the first word into name */
if ( !name[ 0 ] ) /* weird mob .. no keywords */
{
str_cpy ( outbuf, "" ); /* Do not return NULL, just an empty buffer */
return outbuf;
}
for ( rch = ch->in_room->people; rch && ( rch != ch );rch = rch->next_in_room )
if ( is_name ( name, rch->name->str ) )
count++;
sprintf ( outbuf, "%d.%s", count, name );
return outbuf;
}
void do_for ( CHAR_DATA *ch, char *argument )
{
char range[ MAX_INPUT_LENGTH ];
char buf[ MAX_STRING_LENGTH ];
bool fRoom = FALSE, fGods = FALSE, fMortals = FALSE, fMobs = FALSE, fEverywhere = FALSE, found;
ROOM_INDEX_DATA *room, *old_room;
CHAR_DATA *p, *p_next;
int i;
argument = one_argument ( argument, range );
if ( range[ 0 ] == '\0' || argument[ 0 ] == '\0' ) /* invalid usage? */
{
do_help ( ch, "for" );
return ;
}
if ( !str_prefix( "quit", argument ) )
{
send_to_char ( "Are you trying to crash the MUD or something?\n\r", ch );
return ;
}
if ( !str_cmp ( range, "all" ) )
{
fMortals = TRUE;
fGods = TRUE;
}
else if ( !str_cmp ( range, "room" ) )
fRoom = TRUE;
else if ( !str_cmp ( range, "gods" ) )
fGods = TRUE;
else if ( !str_cmp ( range, "mortals" ) )
fMortals = TRUE;
else if ( !str_cmp ( range, "mobs" ) )
fMobs = TRUE;
else if ( !str_cmp ( range, "everywhere" ) )
fEverywhere = TRUE;
else
do_help ( ch, "for" ); /* show syntax */
/* do not allow # to make it easier */
if ( fEverywhere && strchr ( argument, '#' ) )
{
send_to_char ( "Cannot use FOR EVERYWHERE with the # thingie.\n\r", ch );
return ;
}
if ( strchr ( argument, '#' ) ) /* replace # ? */
{
for ( p = char_list; p ; p = p_next )
{
p_next = p->next; /* In case someone DOES try to AT MOBS SLAY # */
found = FALSE;
if ( !( p->in_room ) || room_is_private( p->in_room ) || ( p == ch ) )
continue;
if ( IS_NPC( p ) && fMobs )
found = TRUE;
else if ( !IS_NPC( p ) && p->level >= LEVEL_IMMORTAL && fGods )
found = TRUE;
else if ( !IS_NPC( p ) && p->level < LEVEL_IMMORTAL && fMortals )
found = TRUE;
else if ( ch->in_room == p->in_room && fRoom )
found = TRUE;
/* It looks ugly to me.. but it works :) */
if ( found ) /* p is 'appropriate' */
{
char * pSource = argument; /* head of buffer to be parsed */
char *pDest = buf; /* parse into this */
while ( *pSource )
{
if ( *pSource == '#' ) /* Replace # with name of target */
{
const char * namebuf = name_expand ( p );
if ( namebuf ) /* in case there is no mob name ?? */
while ( *namebuf ) /* copy name over */
*( pDest++ ) = *( namebuf++ );
pSource++;
}
else
*( pDest++ ) = *( pSource++ );
} /* while */
*pDest = '\0'; /* Terminate */
/* Execute */
old_room = ch->in_room;
char_from_room ( ch );
char_to_room ( ch, p->in_room );
interpret ( ch, buf );
send_to_char( "--------------------------------------------------------\n\r", ch );
// send_to_char("\n\r",ch);
char_from_room ( ch );
char_to_room ( ch, old_room );
} /* if found */
} /* for every char */
}
else /* just for every room with the appropriate people in it */
{
for ( i = 0; i < MAX_KEY_HASH; i++ ) /* run through all the buckets */
for ( room = room_index_hash[ i ] ; room ; room = room->next )
{
found = FALSE;
/* Anyone in here at all? */
if ( fEverywhere ) /* Everywhere executes always */
found = TRUE;
else if ( !room->people ) /* Skip it if room is empty */
continue;
/* Check if there is anyone here of the requried type */
/* Stop as soon as a match is found or there are no more ppl in room */
for ( p = room->people; p && !found; p = p->next_in_room )
{
if ( p == ch ) /* do not execute on oneself */
continue;
if ( IS_NPC( p ) && fMobs )
found = TRUE;
else if ( !IS_NPC( p ) && ( p->level >= LEVEL_IMMORTAL ) && fGods )
found = TRUE;
else if ( !IS_NPC( p ) && ( p->level <= LEVEL_IMMORTAL ) && fMortals )
found = TRUE;
} /* for everyone inside the room */
if ( found && !room_is_private( room ) ) /* Any of the required type here AND room not private? */
{
/* This may be ineffective. Consider moving character out of old_room
once at beginning of command then moving back at the end.
This however, is more safe?
*/
old_room = ch->in_room;
char_from_room ( ch );
char_to_room ( ch, room );
interpret ( ch, argument );
send_to_char( "--------------------------------------------------------\n\r", ch );
send_to_char( "\n\r", ch );
char_from_room ( ch );
char_to_room ( ch, old_room );
} /* if found */
} /* for every room in a bucket */
} /* if strchr */
mudsetting->last_proc_logged = 100;
return ;
} /* do_for */
void do_autocopy( CHAR_DATA *ch, char *argument )
{
if ( copyover_set == TRUE )
{
copyover_set = FALSE;
copyover_time = 0;
do_echo( ch, "{R Copyover stopped.{x" );
return ;
}
if ( !strcmp( argument, "" ) )
copyover_time = 1;
else
copyover_time = atoi( argument );
copyover_set = TRUE;
send_to_char( "OKies.\n\r", ch );
}
int get_object_count( char *argument )
{
OBJ_DATA * obj;
int sh_count = 0;
GSList *tmp = object_list;
while ( tmp != NULL )
{
obj = ( OBJ_DATA* ) tmp->data;
sh_count++;
tmp = g_slist_next( tmp );
}
g_slist_free( tmp );
return sh_count;
}
int get_mobile_count( char *argument )
{
CHAR_DATA * wch;
CHAR_DATA *wch_next = NULL;
int sh_count = 0;
for ( wch = char_list; wch != NULL; wch = wch_next )
{
wch_next = wch->next;
sh_count++;
}
return sh_count;
}
int get_player_count( char *argument )
{
CHAR_DATA * wch;
CHAR_DATA *wch_next = NULL;
int sh_count = 0;
for ( wch = char_list; wch != NULL; wch = wch_next )
{
wch_next = wch->next;
if ( !IS_NPC( wch ) )
sh_count++;
}
return sh_count;
}
void do_spiralbow( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * victim;
DESCRIPTOR_DATA *d;
char buf[ MAX_STRING_LENGTH ];
char arg1[ MAX_STRING_LENGTH ];
int loop_count = 0;
int rand_player = 0;
GSList *desc_list;
argument = one_argument( argument, arg1 );
if ( arg1[ 0 ] == '\0' )
{
//Find a victim randomly
rand_player = dice( 1, get_mobile_count( arg1 ) );
for ( victim = char_list;victim != NULL;victim = victim->next )
{
loop_count++;
if ( loop_count == rand_player )
break;
}
}
else if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
//To check if I missed the victim
if ( victim == NULL )
{
send_to_char( "Null Victim!\n\r", ch );
return ;
}
send_to_char( "Puff quickly grabs you!\n\r", victim );
act( "Puff quickly appears in front of $n, grabs $m and throws $m about 30 feet in the sky!", victim, NULL, NULL, TO_ROOM );
send_to_char( "You promptly get thrown in the air!\n\r", victim );
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING && d->character != victim && d->character != ch )
{
act( "You see $n falling from the sky!", victim, NULL, d->character, TO_VICT );
act( "$n pulls back {WSpiral's{x bow and aims...then shoots!\n\r", ch, NULL, d->character, TO_VICT );
act( "THUD! $n gets impaled by the arrow!.\n\r", victim, NULL, d->character, TO_VICT );
act( "{BPuff OOCs: Nice shot $n!{X\n\r", ch, NULL, d->character, TO_VICT );
}
}
sprintf( buf, "You see %s falling from the sky!\n\r", victim->name->str );
send_to_char( buf, ch );
send_to_char( "You think quickly and pull out your trusty {WSpiral{x bow.\n\r", ch );
sprintf( buf, "THUD! You nail %s dead on!.\n\r", victim->name->str );
send_to_char( buf, ch );
send_to_char( "{BPuff OOCs: Nice shot!{x\n\r", ch );
act( "You see $n pull back a arrow from thier bow.\n\r", ch, NULL, victim, TO_VICT );
send_to_char( "You have just gotten hit with a arrow!\n\r", victim );
send_to_char( "{BPuff OOCs: Nice shot!{x\n\r", victim );
send_to_char( "You fall and hit the ground!\n\r", victim );
return ;
}
/* show a list of all used VNUMS */
#define COLUMNS 5 /* number of columns */
#define MAX_ROW ((MAX_SHOW_VNUM / COLUMNS)+1) /* rows */
#define MAX_SHOW_VNUM 305 /* show only 1 - 100*100 */
void do_vlist ( CHAR_DATA *ch, char *argument )
{
int i, j, vnum;
ROOM_INDEX_DATA *room;
char buffer[ MAX_ROW * 100 ]; /* should be plenty */
char buf2 [ 100 ];
for ( i = 0; i < MAX_ROW; i++ )
{
strcpy ( buffer, "" ); /* clear the buffer for this row */
for ( j = 0; j < COLUMNS; j++ ) /* for each column */
{
vnum = ( ( j * MAX_ROW ) + i ); /* find a vnum whih should be there */
if ( vnum < MAX_SHOW_VNUM )
{
room = get_room_index ( vnum * 100 + 1 ); /* each zone has to have a XXX01 room */
sprintf ( buf2, "%3d %-8.8s ", vnum,
room ? room->area->name : "-" );
/* something there or unused ? */
strcat ( buffer, buf2 );
}
} /* for columns */
send_to_char ( buffer, ch );
send_to_char ( "\n\r", ch );
} /* for rows */
}
void do_list_skills( CHAR_DATA *ch, char *argument )
{
int sn;
char buf[ MAX_STRING_LENGTH ];
for ( sn = 0; sn < ( MAX_SKILL + 2 ); sn++ )
{
if ( skill_table[ sn ].name == NULL )
break;
sprintf( buf, "%13s %3d ", skill_table[ sn ].name, sn );
send_to_char( buf, ch );
if ( sn++ != ( MAX_SKILL + 3 ) )
{
sprintf( buf, "%13s %3d\n\r", skill_table[ sn ].name, sn );
send_to_char( buf, ch );
}
else
{
str_cpy( buf, "\n\r" );
send_to_char( buf, ch );
}
}
}
void do_showfight( CHAR_DATA *ch, char *argument )
{
if ( !IS_IMMORTAL( ch ) )
{
send_to_char( "huh?", ch );
return ;
}
if ( IS_SET( ch->pcdata->comm, COMM_SHOW_FIGHT ) )
{
REMOVE_BIT( ch->pcdata->comm, COMM_SHOW_FIGHT );
send_to_char( "You will not be shown fight varibles.\n\r", ch );
return ;
}
else
{
SET_BIT( ch->pcdata->comm, COMM_SHOW_FIGHT );
send_to_char( "You will now see the fight varibles.\n\r", ch );
return ;
}
return ;
}
void clear_bits( CHAR_DATA *victim )
{
if ( IS_SET( victim->added, ADDED_ENLARGE ) )
REMOVE_BIT( victim->added, ADDED_ENLARGE );
if ( IS_SET( victim->added, ADDED_SHRINK ) )
REMOVE_BIT( victim->added, ADDED_SHRINK );
if ( IS_SET( victim->added, ADDED_FLAMES_PURE ) )
REMOVE_BIT( victim->added, ADDED_FLAMES_PURE );
if ( IS_SET( victim->added, ADDED_POLY_MIST ) )
REMOVE_BIT( victim->added, ADDED_POLY_MIST );
if ( IS_SET( victim->added, ADDED_POLY_GENERAL ) )
REMOVE_BIT( victim->added, ADDED_POLY_GENERAL );
if ( IS_SET( victim->added, ADDED_COURAGE ) )
REMOVE_BIT( victim->added, ADDED_COURAGE );
if ( IS_SET( victim->added, ADDED_BRISTLES ) )
REMOVE_BIT( victim->added, ADDED_BRISTLES );
if ( IS_SET( victim->added, ADDED_ANIMAL_MASTER ) )
REMOVE_BIT( victim->added, ADDED_ANIMAL_MASTER );
if ( IS_SET( victim->added, ADDED_ILLUSION ) )
REMOVE_BIT( victim->added, ADDED_ILLUSION );
if ( IS_SET( victim->added, ADDED_LOYAL ) )
REMOVE_BIT( victim->added, ADDED_LOYAL );
if ( IS_SET( victim->added, ADDED_HAND_FLAME ) )
REMOVE_BIT( victim->added, ADDED_HAND_FLAME );
if ( IS_SET( victim->added, ADDED_ANGER ) )
REMOVE_BIT( victim->added, ADDED_ANGER );
if ( IS_SET( victim->added, ADDED_CALM ) )
REMOVE_BIT( victim->added, ADDED_CALM );
if ( IS_SET( victim->added, ADDED_HAUNT ) )
REMOVE_BIT( victim->added, ADDED_HAUNT );
if ( IS_SET( victim->added, ADDED_INSANE ) )
REMOVE_BIT( victim->added, ADDED_INSANE );
if ( IS_SET( victim->added, ADDED_CONFUSE ) )
REMOVE_BIT( victim->added, ADDED_CONFUSE );
if ( IS_SET( victim->added, ADDED_NIGHTFALL ) )
REMOVE_BIT( victim->added, ADDED_NIGHTFALL );
if ( IS_SET( victim->added, ADDED_CLOAK ) )
REMOVE_BIT( victim->added, ADDED_CLOAK );
if ( IS_SET( victim->added, ADDED_FRENZY ) )
REMOVE_BIT( victim->added, ADDED_FRENZY );
if ( IS_SET( victim->added, ADDED_DIABLERIE ) )
REMOVE_BIT( victim->added, ADDED_DIABLERIE );
if ( IS_SET( victim->added, ADDED_BRAGE ) )
REMOVE_BIT( victim->added, ADDED_BRAGE );
if ( IS_SET( victim->added, ADDED_GIFTSPRIG ) )
REMOVE_BIT( victim->added, ADDED_GIFTSPRIG );
if ( IS_SET( victim->added, ADDED_DISCERN ) )
REMOVE_BIT( victim->added, ADDED_DISCERN );
if ( IS_SET( victim->added, ADDED_CHAMELEON ) )
REMOVE_BIT( victim->added, ADDED_CHAMELEON );
if ( IS_SET( victim->added, ADDED_VOICESOFCASTLE ) )
REMOVE_BIT( victim->added, ADDED_VOICESOFCASTLE );
if ( IS_SET( victim->act, PLR_HOLYLIGHT ) )
REMOVE_BIT( victim->act, PLR_HOLYLIGHT );
if ( IS_SET( victim->act, PLR_MARBLEFLESH ) )
REMOVE_BIT( victim->act, PLR_MARBLEFLESH );
return ;
}
/*consolidate all our clear commands in to one*/
void do_clear( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_STRING_LENGTH ];
char arg1[ MAX_INPUT_LENGTH ];
OBJ_DATA *obj;
AFFECT_DATA *paf;
AFFECT_DATA *paf_last = NULL;
SPHERE_DATA *spaf;
SPHERE_DATA *spaf_last = NULL;
OBJ_DATA *obj_next;
CHAR_DATA *victim;
sh_int count;
argument = one_argument( argument, arg );
argument = one_argument( argument, arg1 );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "Clear Commands: timer,tell, card, stat, marriage, or vamp\n\r", ch );
return ;
}
if ( !strcmp( arg, "tell" ) )
{
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( victim->reply == ch )
victim->reply = NULL;
}
send_to_char( "Tells and replys cleared.\n\r", ch );
return ;
}
else if ( !strcmp( arg, "card" ) )
{
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: clearcard <quest card>\n\r", ch );
return ;
}
if ( ( obj = get_obj_carry( ch, arg1 ) ) == NULL )
{
send_to_char( "You are not carrying that object.\n\r", ch );
return ;
}
if ( obj->item_type != ITEM_QUESTCARD )
{
send_to_char( "That is not a quest card.\n\r", ch );
return ;
}
obj->value[ 0 ] = -1;
obj->value[ 1 ] = -1;
obj->value[ 2 ] = -1;
obj->value[ 3 ] = -1;
quest_object( ch, obj );
send_to_char( "This card has been reset.\n\r", ch );
do_autosave( ch, "" );
return ;
}
else if ( !strcmp( arg, "timer" ) )
{
if ( get_trust( ch ) < LEVEL_HIGHJUDGE )
{
send_to_char( "You don't have the security to use this argument!.\n\r", ch );
return ;
}
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( !IS_NPC( victim ) )
{
if ( victim->delay_timer > 1 )
victim->delay_timer = 0;
if ( victim->pk_timer > 1 )
victim->pk_timer = 0;
send_to_char( "Your timer has been cleared.\n\r", victim );
}
}
send_to_char( "timers cleared.\n\r", ch );
return ;
}
else if ( !strcmp( arg, "marriage" ) )
{
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: marriage (char).\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
victim->pcdata->marriage = g_string_assign( victim->pcdata->marriage, "" );
send_to_char( "Marriage Cleared\n\r", ch );
}
else if ( !strcmp( arg, "stat" ) )
{
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: mclear <char>.\n\r", ch );
return ;
}
if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
{
send_to_char( "That player is not here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
return ;
if ( IS_SWWF( victim ) && ch->pcdata->wwf_shape != SHAPE_HOMID )
shape_shift( victim, SHAPE_HOMID );
for ( obj = victim->carrying; obj != NULL; obj = obj_next )
{
obj_next = obj->next_content;
if ( obj->wear_loc != WEAR_NONE )
{
obj_from_char( obj );
obj_to_char( obj, victim );
}
}
for ( paf = victim->affected; paf != NULL; paf = paf->next )
{
if ( paf_last != NULL && paf->type == paf_last->type )
continue;
else
{
if ( paf->type <= MAX_SKILL )
affect_remove( victim, paf );
}
paf_last = paf;
}
for ( spaf = victim->sphere_affected; spaf != NULL; spaf = spaf->next )
{
if ( spaf_last != NULL && spaf->type == spaf_last->type )
continue;
else
{
if ( spaf->type <= MAX_SKILL )
sphere_remove( victim, spaf );
}
spaf_last = spaf;
}
if ( IS_SET( victim->act, PLR_WIZINVIS ) )
REMOVE_BIT( victim->act, PLR_WIZINVIS );
if ( IS_AFFECTED( victim, AFF_POLYMORPH ) )
{
victim->affected_by = AFF_POLYMORPH;
}
else if ( IS_AFFECTED( victim, AFF_POLYMORPH ) )
victim->affected_by = AFF_POLYMORPH;
else
victim->affected_by = 0;
clear_bits( victim );
victim->armor = 100;
victim->hit = UMAX( 1, victim->hit );
victim->mana = UMAX( 1, victim->mana );
victim->move = UMAX( 1, victim->move );
victim->hitroll = 0;
victim->damroll = 0;
victim->saving_throw = 0;
victim->pcdata->mod_str = 0;
victim->pcdata->mod_int = 0;
victim->pcdata->mod_wis = 0;
victim->pcdata->mod_dex = 0;
victim->pcdata->mod_con = 0;
save_char_obj( victim );
send_to_char( "Player Cleared.\n\r", ch );
send_to_char( "{YYour stats have been cleared. Please rewear your equipment.{x\n\r", victim );
return ;
}
else if ( !strcmp( arg, "vamp" ) )
{
if ( arg1[ 0 ] == '\0' || is_number( arg1 ) )
{
send_to_char( "Clear who's clan?\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
{
send_to_char( "They aren't here.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not on NPC's.\n\r", ch );
return ;
}
if ( IS_CLASS( victim, CLASS_VAMPIRE ) )
do_mortalvamp( victim, "" );
victim->lord = g_string_assign( victim->lord, "" );
victim->clan = 0;
victim->pcdata->stats[ UNI_GEN ] = 0;
victim->pcdata->stats[ UNI_AFF ] = 0;
victim->pcdata->stats[ UNI_CURRENT ] = -1;
for ( count = 0 ; count < MAX_DISC ; count++ )
{
victim->pcdata->discipline[ count ] = 0;
victim->pcdata->inherited[ count ] = 0;
}
REMOVE_BIT( victim->special, SPC_SIRE );
REMOVE_BIT( victim->special, SPC_PRINCE );
REMOVE_BIT( victim->special, SPC_ANARCH );
victim->pcdata->stats[ UNI_RAGE ] = 0;
victim->pcdata->rank = AGE_CHILDE;
send_to_char( "Ok.\n\r", ch );
return ;
}
else
{
send_to_char( "Clear Commands: timer,tell, card, stat, marriage, or vamp\n\r", ch );
return ;
}
return ;
}
void do_mud_config( CHAR_DATA *ch, char *argument )
{
char arg[ MAX_INPUT_LENGTH ];
if ( IS_NPC( ch ) )
return ;
one_argument( argument, arg );
if ( arg[ 0 ] == '\0' )
{
send_to_char( "[ Keyword ] Option\n\r", ch );
send_to_char( IS_SET( mudsetting->mud_setting, MS_CHAOS_NIGHT )
? "{W[{R+CHAOSNIGHT{W]{x Chaos Night is On.\n\r"
: "{W[{B-CHAOSNIGHT{W]{x Chaos Night is Off.\n\r"
, ch );
send_to_char( IS_SET( mudsetting->mud_setting, MS_LIVING_DEAD )
? "{W[{R+LIVINGDEAD{W]{x Night of the Living Dead is On!.\n\r"
: "{W[{B-LIVINGDEAD{W]{x Night of the Living Dead is Off.\n\r"
, ch );
send_to_char( IS_SET( mudsetting->mud_setting, MS_DEBUG )
? "{W[{R+DEBUG {W]{x Debugger is On.\n\r"
: "{W[{B-DEBUG {W]{x Debugger is Off.\n\r"
, ch );
send_to_char( IS_SET( mudsetting->mud_setting, MS_DOUBLE_HP )
? "{W[{R+DOUBLE HP {W]{x Double Hp is On.\n\r"
: "{W[{B-DOUBLE HP {W]{x Double Hp is Off.\n\r"
, ch );
send_to_char( IS_SET( mudsetting->mud_setting, MS_DOUBLE_MANA )
? "{W[{R+DOUBLEMANA{W]{x Double Mana is On.\n\r"
: "{W[{B-DOUBLEMANA{W]{x Double Mana is Off.\n\r"
, ch );
send_to_char( IS_SET( mudsetting->mud_setting, MS_CASINO )
? "{W[{R+CASINO{W ]{x The Casino is Open.\n\r"
: "{W[{B-CASINO{W ]{x The Casino Is Closed.\n\r"
, ch );
}
else
{
bool fSet;
int bit;
if ( arg[ 0 ] == '+' )
fSet = TRUE;
else if ( arg[ 0 ] == '-' )
fSet = FALSE;
else
{
send_to_char( "mudconfig -option or +option?\n\r", ch );
return ;
}
if ( !str_cmp( arg + 1, "chaosnight" ) )
bit = MS_CHAOS_NIGHT;
else if ( !str_cmp( arg + 1, "debug" ) )
bit = MS_DEBUG;
else if ( !str_cmp( arg + 1, "hp" ) )
bit = MS_DOUBLE_HP;
else if ( !str_cmp( arg + 1, "mana" ) )
bit = MS_DOUBLE_MANA;
else if ( !str_cmp( arg + 1, "livingdead" ) )
bit = MS_LIVING_DEAD;
else if ( !str_cmp( arg + 1, "casino" ) )
bit = MS_CASINO;
else
{
send_to_char( "mudconfig which option?\n\r", ch );
return ;
}
if ( fSet )
SET_BIT ( mudsetting->mud_setting, bit );
else
REMOVE_BIT ( mudsetting->mud_setting, bit );
send_to_char( "Ok.\n\r", ch );
}
return ;
}
void do_bad_name ( CHAR_DATA *ch, char *argument )
{
char arg1[ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
FILE *fp;
argument = one_argument( argument, arg1 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: baname (player name)\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg1 ) ) != NULL )
send_to_char( "Your name is unacceptable! Please change it!\n\r", victim );
fclose( fpReserve );
if ( ( fp = fopen( BAD_NAME_FILE, "a" ) ) != NULL )
{
fprintf( fp, "%s\n", arg1 ) ;
fclose( fp );
}
fpReserve = fopen( NULL_FILE, "r" );
send_to_char( "Player name banned.\n\r", ch );
return ;
}
void do_list_oowners( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
char arg1[ MAX_STRING_LENGTH ];
OBJ_DATA *obj;
OBJ_DATA *in_obj;
bool found;
int count = 0;
GSList *tmp = object_list;
argument = one_argument( argument, arg1 );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "You must supply a name with that!.\n\r", ch );
return ;
}
found = FALSE;
while ( tmp != NULL )
{
obj = ( OBJ_DATA* ) tmp->data;
if ( !is_name( arg1, obj->OOwner->str ) )
{
tmp = g_slist_next( tmp );
continue;
}
found = TRUE;
for ( in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj )
;
if ( in_obj->carried_by != NULL )
{
sprintf( buf, "%s carried by %s.\n\r",
obj->short_descr->str, PERS( in_obj->carried_by, ch ) );
}
else
{
sprintf( buf, "%s in %s.\n\r",
obj->short_descr->str, in_obj->in_room == NULL
? "somewhere" : in_obj->in_room->name );
}
buf[ 0 ] = UPPER( buf[ 0 ] );
send_to_char( buf, ch );
if ( count > 50 )
break;
else
count++;
tmp = g_slist_next( tmp );
}
g_slist_free( tmp );
if ( !found )
send_to_char( "Nothing like that in hell, earth, or heaven.\n\r", ch );
return ;
}
void do_mxpecho( CHAR_DATA *ch, char *argument )
{
DESCRIPTOR_DATA * d;
char buf[ MAX_STRING_LENGTH ];
GString *mxpout;
GSList *desc_list;
if ( ch != NULL )
{
sprintf( buf, "%s: MXPEcho %s", ch->name->str, argument );
if ( ch->level < NO_WATCH )
do_watching( ch, buf );
}
if ( argument[ 0 ] == '\0' )
{
send_to_char( "MxPEcho what?\n\r", ch );
return ;
}
for ( desc_list = descriptor_list; desc_list != NULL; desc_list = g_slist_next( desc_list ) )
{
d = ( DESCRIPTOR_DATA* ) desc_list->data;
if ( d->connected == CON_PLAYING && IS_SET( d->character->deaf, CHANNEL_MXP ) )
{
mxpout = g_string_new( "" );
mxpconv( mxpout, argument, d->character );
send_to_char( mxpout->str, d->character );
send_to_char( "\n\r", d->character );
g_string_free( mxpout, TRUE );
}
}
return ;
}
void do_safe_room ( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * safeimm;
if ( IS_NPC( ch ) )
safeimm = ch->desc->original;
else
safeimm = ch;
if ( !IS_IMMORTAL( safeimm ) )
{
send_to_char( "huh?", ch );
return ;
}
if ( IS_SET( safeimm->pcdata->comm, COMM_IMM_SAFE ) )
{
REMOVE_BIT( safeimm->pcdata->comm, COMM_IMM_SAFE );
send_to_char( "You no longer have a safty net around you.\n\r", safeimm );
return ;
}
else
{
SET_BIT( safeimm->pcdata->comm, COMM_IMM_SAFE );
send_to_char( "You shield those around you from combat.\n\r", safeimm );
return ;
}
return ;
}
void do_checkld( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * victim;
char buf[ MSL ];
send_to_char( "The Link Dead:\n\r", ch );
for ( victim = char_list; victim != NULL; victim = victim->next )
{
if ( !IS_NPC( victim ) && victim->desc == NULL )
{
sprintf( buf, "%s\n\r", victim->name->str );
send_to_char( buf, ch );
}
}
}
void do_makepet( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * pet;
char arg[ MSL ];
char buf[ MSL ];
one_argument( argument, arg );
if ( arg[ 0 ] == '0' )
{
send_to_char( "Syntax: makepet (victim) <----works on NPC's Only\n\r", ch );
return ;
}
if ( ( pet = get_char_room( ch, arg ) ) == NULL )
{
send_to_char( "They are not here.\n\r", ch );
return ;
}
if ( !IS_NPC( pet ) )
{
send_to_char( "Umm NPC's only...\n\r", ch );
return ;
}
ch->pet = pet;
pet->pet_master = ch;
if ( pet->master )
stop_follower( pet );
add_follower( pet, ch );
SET_BIT( pet->mob_con, MOBCON_PET );
sprintf( buf, "You have made %s your pet.\n\r", pet->name->str );
do_say( pet, "Please take care of me please" );
return ;
}
void do_dissolve( CHAR_DATA *ch, char *argument )
{
char arg[ MSL ];
CHAR_DATA *victim;
one_argument( argument, arg );
if ( ( victim = get_char_room( ch, arg ) ) == NULL )
{
send_to_char( "They are not there.", ch );
return ;
}
if ( !IS_NPC( victim ) || ( IS_NPC( victim ) && !IS_PET( victim ) ) )
{
send_to_char( "They are not your PET!\n\r", ch );
return ;
}
if ( victim != ch->pet || victim->pet_master != ch )
{
send_to_char( "They are not your PET!\n\r", ch );
return ;
}
if ( ch->pet == NULL )
{
send_to_char( "You don't have a pet!\n\r", ch );
return ;
}
send_to_char( "Your pet dissolved in to nothing!\n\r", ch );
extract_char( victim, FALSE );
ch->pet = NULL;
return ;
}
void do_imm_stake( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * victim;
int aPrimal = 0, iCount = 0, aDiscNum = 0, aCount = 0;
if ( ( victim = get_char_room( ch, argument ) ) == NULL )
{
send_to_char( "They are not here my friend.\n\r", ch );
return ;
}
if ( !IS_AVATAR( victim ) )
{
send_to_char( "They are not an avatar.\n\r", ch );
return ;
}
switch ( victim->creature )
{
case CLASS_MAGE:
for ( iCount = 0 ; iCount <= 8 ; iCount++ )
{
if ( ( aDiscNum = victim->pcdata->discipline[ iCount ] ) > 0 )
{
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += ( ( aCount * 50 ) + 50 );
}
victim->pcdata->discipline[ iCount ] = 0;
}
}
for ( iCount = 0; iCount <= victim->arete; iCount++ )
{
aPrimal += ( iCount * 50 ) + 50;
}
break;
case CLASS_SWWF:
//don't forget gnosis
break;
case CLASS_VAMPIRE:
for ( iCount = 0 ; iCount <= MAX_DISC ; iCount++ )
{
if ( ( aDiscNum = victim->pcdata->disc[ iCount ] ) > 0 )
{
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
if ( IS_VAMPPASS( victim, iCount ) )
aPrimal += ( COST_DIS * aCount ) ;
else
aPrimal += ( COST_DIS * aCount ) + COST_DIS;
}
victim->pcdata->disc[ iCount ] = 0;
}
}
break;
case CLASS_WEREWOLF:
aDiscNum = victim->pcdata->powers[ WPOWER_BEAR ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_LYNX ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_BOAR ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_OWL ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_SPIDER ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_WOLF ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_HAWK ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_MANTIS ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += aCount * COST_TOTEM;
}
aDiscNum = victim->pcdata->powers[ WPOWER_SHARK ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += ( aCount * COST_TOTEM ) + 50;
}
aDiscNum = victim->pcdata->powers[ WPOWER_SPHINX ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += ( aCount * COST_TOTEM ) + 50;
}
aDiscNum = victim->pcdata->powers[ WPOWER_RAT ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += ( aCount * COST_TOTEM ) + 50;
}
aDiscNum = victim->pcdata->powers[ WPOWER_CHAMELEON ];
for ( aCount = 0; aCount <= aDiscNum; aCount++ )
{
aPrimal += ( aCount * COST_TOTEM ) + 50;
}
victim->pcdata->powers[ WPOWER_BEAR ] = 0;
victim->pcdata->powers[ WPOWER_LYNX ] = 0;
victim->pcdata->powers[ WPOWER_BOAR ] = 0;
victim->pcdata->powers[ WPOWER_OWL ] = 0;
victim->pcdata->powers[ WPOWER_SPIDER ] = 0;
victim->pcdata->powers[ WPOWER_WOLF ] = 0;
victim->pcdata->powers[ WPOWER_HAWK ] = 0;
victim->pcdata->powers[ WPOWER_MANTIS ] = 0;
victim->pcdata->powers[ WPOWER_SHARK ] = 0;
victim->pcdata->powers[ WPOWER_SPHINX ] = 0;
victim->pcdata->powers[ WPOWER_RAT ] = 0;
victim->pcdata->powers[ WPOWER_CHAMELEON ] = 0;
for ( iCount = 0; iCount <= victim->pcdata->powers[ WPOWER_SILVER ]; iCount++ )
victim->exp += iCount * 2500;
break;
default:
send_to_char( "Umm they are not classed...\n\r", ch );
return ;
break;
}
victim->primal_hold += aPrimal;
victim->creature = 0;
act( "$n creates a stake from nothing and pluges it deep with in you!", ch, NULL, victim, TO_VICT );
act( "You create a stake from nothing and plunge it deep with in $N!", ch, NULL, victim, TO_CHAR );
act( "$n creates a stake from nothing and plunges it deep with in $N!", ch, NULL, victim, TO_ROOM );
return ;
}
/*
This is for aslan as I loved as on abyss
and he wishes I bring it to lurf..
so here it is... Spiral's Version of AXE
*/
void aslan_axe( CHAR_DATA *ch, char *argument )
{
CHAR_DATA * victim;
char arg[ MSL ], arg2[ MSL ];
argument = one_argument( argument, arg );
argument = one_argument( argument, arg2 );
if ( arg[ 0 ] == '\0' || arg2[ 0 ] == '\0' )
{
send_to_char( "Syntax:\n\raaxe (victim) (rpstatus amount)\n\r", ch );
return ;
}
if ( ( victim = get_char_world( ch, arg ) ) == NULL )
{
send_to_char( "Sorry there not logged in.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Sorry this only works on players.\n\r", ch );
return ;
}
if ( !is_number( arg2 ) )
{
send_to_char( "Amount needs to be in number format.\n\r", ch );
return ;
}
// OK now comes the fun part.. ASLAN AXES
act( "Magical axes start falling above your head from the sky!", ch, NULL, victim, TO_VICT );
act( "Magical axes start falling from the sky and fall on $N's head!", victim, NULL, victim, TO_ROOM );
act( "Magical axes start falling from the sky and fall on $N's head!", ch, NULL, victim, TO_CHAR );
}
void do_cset( CHAR_DATA *ch, char* argument )
{
char string[ MSL ];
char value[ MSL ];
char victim_arg[ MSL ];
CHAR_DATA *victim;
int x, int_value;
argument = one_argument( argument, victim_arg );
argument = one_argument( argument, string );
argument = one_argument( argument, value );
if ( value[ 0 ] == '\0' )
{
send_to_char( "No value set.\n\r", ch );
send_to_char( "Syntax: cset (victim) (string) (value)\n\r", ch );
return ;
}
if ( string[ 0 ] == '\0' )
{
// TODO need to set up the list of syntax here for what we can do with cset...
send_to_char( "No string set.\n\r", ch );
send_to_char( "Syntax: cset (victim) (string) (value)\n\r", ch );
send_to_char( "Strings: (Disc/Sphere/Gift)\r\n", ch );
return ;
}
if ( ( victim = get_char_world( ch, victim_arg ) ) == NULL )
{
send_to_char( "No one is logged on with that name.\n\r", ch );
return ;
}
if ( IS_NPC( victim ) )
{
send_to_char( "Not possible\n\r", ch );
return ;
}
for ( x = 0; cset_powers_list[ x ].power_name != NULL; x++ )
{
if ( !strcmp( cset_powers_list[ x ].power_name, string ) )
{
int_value = atoi( value );
if ( int_value < 0 || int_value > 9 )
{
send_to_char( "invalid value.\n\r", ch );
return ;
}
if ( IS_VAMPIRE( victim ) && cset_powers_list[ x ].power_class == CLS_VAMP )
{
victim->pcdata->disc[ cset_powers_list[ x ].power_value ] = int_value;
return ;
}
if ( IS_SWWF( victim ) && cset_powers_list[ x ].power_class == CLS_TRIBE )
{
victim->pcdata->tribes[ cset_powers_list[ x ].power_value ] = int_value;
return ;
}
if ( IS_SWWF( victim ) && cset_powers_list[ x ].power_class == CLS_AUSPICE )
{
victim->pcdata->auspice[ cset_powers_list[ x ].power_value ] = int_value;
return ;
}
if ( IS_SWWF( victim ) && cset_powers_list[ x ].power_class == CLS_BREED )
{
victim->pcdata->breed[ cset_powers_list[ x ].power_value ] = int_value;
return ;
}
if ( IS_MAGE( victim ) && cset_powers_list[ x ].power_class == CLS_MAGE )
{
victim->pcdata->discipline[ cset_powers_list[ x ].power_value ] = int_value;
return ;
}
}
return ;
}
send_to_char( "Invalid String\n\r", ch );
return ;
}
void do_planewalk( CHAR_DATA *ch, char *argument )
{
char arg1[ MSL ];
char arg2[ MSL ];
char timer[ MSL ];
char buf[ MSL ];
CHAR_DATA *victim;
int plane;
int plane_to = 0;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
argument = one_argument( argument, timer );
if ( arg1[ 0 ] == '\0' )
{
send_to_char( "Syntax: planewalk (plane) (victim) (timer)\n\r", ch );
send_to_char( "Victim and Timer options are optional.\n\r", ch );
return ;
}
for ( plane = 0; plane_table[ plane ].name[ 0 ] != '\0'; plane++ )
{
if ( arg1[ 0 ] == plane_table[ plane ].name[ 0 ]
&& !str_prefix( arg1, plane_table[ plane ].name ) )
{
plane_to = plane;
break;
}
}
if ( plane_to == 0 )
{
send_to_char( "That plane don't exsist.\n\r", ch );
return ;
}
if ( arg2[ 0 ] == '\0' )
{
ch->plane = plane_to;
shift_obj_plane( ch );
sprintf( buf, "You suddenly shift in to the %s\n\r", plane_table[ plane ].name );
shift_obj_plane( ch );
return ;
}
if ( ( victim = get_char_world( ch, arg2 ) ) == NULL )
{
send_to_char( "Send who?\n\r", ch );
return ;
}
victim->plane = plane_to;
shift_obj_plane( victim );
if ( !IS_NPC( victim ) && atoi( timer ) > 0 )
victim->pcdata->obeah += atoi( timer );
sprintf( buf, "You suddenly shift in to the %s\n\r", plane_table[ plane ].name );
send_to_char( buf, victim );
sprintf( buf, "$N's form suddenly shimmers as they are forced in the %s\n\r", plane_table[ plane ].name );
act( buf, ch, NULL, victim, TO_CHAR );
return ;
}
/*
* Left in to demo the use of strings in GLIB...
*
void do_gstring_test( CHAR_DATA *ch, char *argument)
{
GString *testing;
testing = g_string_new("testing");
ch->pcdata->anon_desc2 = testing;
send_to_char(ch->pcdata->anon_desc2->str,ch);
g_string_free(testing,TRUE);
return;
}
*/
void do_areas( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
AREA_DATA *pArea1;
AREA_DATA *pArea2;
int iArea;
int iAreaHalf;
iAreaHalf = ( top_area + 1 ) / 2;
pArea1 = area_first;
pArea2 = area_first;
for ( iArea = 0; iArea < iAreaHalf; iArea++ )
pArea2 = pArea2->next;
for ( iArea = 0; iArea < iAreaHalf; iArea++ )
{
sprintf( buf, "%-39s%-39s\n\r",
pArea1->name, ( pArea2 != NULL ) ? pArea2->name : "" );
send_to_char( buf, ch );
pArea1 = pArea1->next;
if ( pArea2 != NULL )
pArea2 = pArea2->next;
}
return ;
}
void do_memory( CHAR_DATA *ch, char *argument )
{
char buf[ MAX_STRING_LENGTH ];
sprintf( buf, "Affects %5d\n\r", top_affect );
send_to_char( buf, ch );
sprintf( buf, "Areas %5d\n\r", top_area );
send_to_char( buf, ch );
sprintf( buf, "RmTxt %5d\n\r", top_rt );
send_to_char( buf, ch );
sprintf( buf, "ExDes %5d\n\r", top_ed );
send_to_char( buf, ch );
sprintf( buf, "Exits %5d\n\r", top_exit );
send_to_char( buf, ch );
sprintf( buf, "Helps %5d\n\r", top_help );
send_to_char( buf, ch );
sprintf( buf, "Mobs %5d Mobs Created: %5ld Tot_Mobs: %5ld ActMob: %5d\n\r", top_mob_index, mudsetting->mobiles_created, mudsetting->total_mobiles_created, get_mobile_count( argument ) );
send_to_char( buf, ch );
sprintf( buf, "Objs %5d Objs Created: %5ld Objs Recycled: %5ld Tot_Objs: %5ld ActObj: %5d\n\r", top_obj_index, mudsetting->objects_created, mudsetting->objects_recycled, mudsetting->total_objects_created, get_object_count( argument ) );
send_to_char( buf, ch );
sprintf( buf, "Descr %5ld Desc Recycled: %5ld Tot_Desc: %5ld\n\r", mudsetting->current_players_connected, mudsetting->players_recycled, mudsetting->total_players_connected );
send_to_char( buf, ch );
sprintf( buf, "Resets %5d\n\r", top_reset );
send_to_char( buf, ch );
sprintf( buf, "Rooms %5d\n\r", top_room );
send_to_char( buf, ch );
sprintf( buf, "Shops %5d\n\r", top_shop );
send_to_char( buf, ch );
g_mem_chunk_info();
g_mem_profile();
return ;
}
void do_area_report( CHAR_DATA *ch, char *argument )
{
MOB_INDEX_DATA *pMobIndex;
std::ofstream outfile( "report.txt" );
int maxhit = 0;
int tempvalue = 0;
int armor = 0;
int vnum;
for ( vnum = 0; vnum < mudsetting->high_mobile_vnum; vnum++ )
{
if ( ( pMobIndex = get_mob_index( vnum ) ) != NULL )
{
armor = ( pMobIndex->ac == 0 ) ?
interpolate( pMobIndex->level, 100, -100 ) :
pMobIndex->ac;
tempvalue = pMobIndex->level * 8 + number_range(
pMobIndex->level * pMobIndex->level / 4,
pMobIndex->level * pMobIndex->level );
if ( pMobIndex->hitnodice == 0
&& pMobIndex->hitsizedice == 0
&& pMobIndex->hitplus == 0 )
{
maxhit = tempvalue;
}
else
{
maxhit = dice( pMobIndex->hitnodice, pMobIndex->hitsizedice )
+ pMobIndex->hitplus;
}
outfile << pMobIndex->vnum << "," << pMobIndex->level << "," << pMobIndex->hitroll << ",";
outfile << armor << "," << maxhit << std::endl;
}
}
send_to_char("Done!",ch);
}