void mpedit (CHAR_DATA * ch, char *argument)
{
MPROG_CODE *pMcode;
char arg[MAX_INPUT_LENGTH];
char command[MAX_INPUT_LENGTH];
int cmd;
AREA_DATA *ad;
smash_tilde (argument);
strcpy (arg, argument);
argument = one_argument (argument, command);
EDIT_MPCODE (ch, pMcode);
if (pMcode)
{
ad = get_vnum_area (pMcode->vnum);
if (ad == NULL)
{ /* ??? */
edit_done (ch);
return;
}
if (!IS_BUILDER (ch, ad))
{
send_to_char ("MPEdit: Insufficient security to modify code.\n\r",
ch);
edit_done (ch);
return;
}
}
if (command[0] == '\0')
{
mpedit_show (ch, argument);
return;
}
if (!str_cmp (command, "done"))
{
edit_done (ch);
return;
}
for (cmd = 0; mpedit_table[cmd].name != NULL; cmd++)
{
if (!str_prefix (command, mpedit_table[cmd].name))
{
if ((*mpedit_table[cmd].olc_fun) (ch, argument) && pMcode)
if ((ad = get_vnum_area (pMcode->vnum)) != NULL)
SET_BIT (ad->area_flags, AREA_CHANGED);
return;
}
}
interpret (ch, arg);
return;
}
/* Area Interpreter, called by do_aedit. */
void aedit (CHAR_DATA * ch, char *argument)
{
AREA_DATA *pArea;
char command[MAX_INPUT_LENGTH];
char arg[MAX_INPUT_LENGTH];
int cmd;
int value;
EDIT_AREA (ch, pArea);
smash_tilde (argument);
strcpy (arg, argument);
argument = one_argument (argument, command);
if (!IS_BUILDER (ch, pArea))
{
send_to_char ("AEdit: Insufficient security to modify area.\n\r",
ch);
edit_done (ch);
return;
}
if (!str_cmp (command, "done"))
{
edit_done (ch);
return;
}
if (command[0] == '\0')
{
aedit_show (ch, argument);
return;
}
if ((value = flag_value (area_flags, command)) != NO_FLAG)
{
TOGGLE_BIT (pArea->area_flags, value);
send_to_char ("Flag toggled.\n\r", ch);
return;
}
/* Search Table and Dispatch Command. */
for (cmd = 0; aedit_table[cmd].name != NULL; cmd++)
{
if (!str_prefix (command, aedit_table[cmd].name))
{
if ((*aedit_table[cmd].olc_fun) (ch, argument))
{
SET_BIT (pArea->area_flags, AREA_CHANGED);
return;
}
else
return;
}
}
/* Default to Standard Interpreter. */
interpret (ch, arg);
return;
}
void bsedit( CHAR_DATA *ch, char *argument )
{
BONUS_INDEX_DATA * pBonus;
char arg[ MAX_INPUT_LENGTH ];
char command[ MAX_INPUT_LENGTH ];
int cmd;
AREA_DATA *ad;
smash_tilde( argument );
strcpy( arg, argument );
argument = one_argument( argument, command );
EDIT_BSDATA( ch, pBonus );
if ( pBonus )
{
ad = get_vnum_area( pBonus->vnum );
if ( ad == NULL )
{
edit_done( ch );
return ;
}
if ( !IS_BUILDER( ch, ad ) )
{
send_to_char( "BSEdit: Masz niewystarczaj±ce security.\n\r", ch );
edit_done( ch );
return ;
}
}
if ( command[ 0 ] == '\0' )
{
bsedit_show( ch, argument );
return ;
}
if ( !str_cmp( command, "done" ) )
{
edit_done( ch );
return ;
}
for ( cmd = 0; bsedit_table[ cmd ].name != NULL; cmd++ )
{
if ( !str_prefix( command, bsedit_table[ cmd ].name ) )
{
if ( ( *bsedit_table[ cmd ].olc_fun ) ( ch, argument ) && pBonus )
if ( ( ad = get_vnum_area( pBonus->vnum ) ) != NULL )
SET_BIT( ad->area_flags, AREA_CHANGED );
return ;
}
}
interpret( ch, arg );
return ;
}
void rdedit( CHAR_DATA *ch, char *argument)
{
RAND_DESC_DATA *pDdata;
char arg[MAX_INPUT_LENGTH];
char command[MAX_INPUT_LENGTH];
int cmd;
AREA_DATA *ad;
smash_tilde(argument);
strcpy(arg, argument);
argument = one_argument( argument, command);
EDIT_RDESCDATA(ch, pDdata);
if (pDdata)
{
ad = get_vnum_area( pDdata->vnum );
if ( ad == NULL )
{
edit_done(ch);
return;
}
if ( !IS_BUILDER(ch, ad) )
{
send_to_char("DescEdit: Brak praw dostêpu.\n\r", ch);
edit_done(ch);
return;
}
}
if (command[0] == '\0')
{
rdedit_show(ch, argument);
return;
}
if (!str_cmp(command, "done") )
{
edit_done(ch);
return;
}
for (cmd = 0; rdedit_table[cmd].name != NULL; cmd++)
{
if (!str_prefix(command, rdedit_table[cmd].name) )
{
if ((*rdedit_table[cmd].olc_fun) (ch, argument) && pDdata)
if ((ad = get_vnum_area(pDdata->vnum)) != NULL)
SET_BIT(ad->area_flags, AREA_CHANGED);
return;
}
}
interpret(ch, arg);
return;
}
void do_rdedit(CHAR_DATA *ch, char *argument)
{
RAND_DESC_DATA *pDdata;
char command[MAX_INPUT_LENGTH];
argument = one_argument(argument, command);
if( is_number(command) )
{
unsigned int vnum = atoi(command);
AREA_DATA *ad;
if ( (pDdata = get_rdesc_index(vnum)) == NULL )
{
send_to_char("RDEdit: Nie istnieje taki opis.\n\r",ch);
return;
}
ad = get_vnum_area(vnum);
if ( ad == NULL )
{
send_to_char( "RDEdit: Nie ma przypisanej krainy.\n\r", ch );
return;
}
if ( !IS_BUILDER(ch, ad) )
{
send_to_char("RDEdit: Masz niewystarczaj±ce security.\n\r", ch );
return;
}
ch->desc->pEdit = (void *)pDdata;
ch->desc->editor = ED_RDESCDATA;
return;
}
if ( !str_cmp(command, "create") )
{
if (argument[0] == '\0')
{
send_to_char( "RDEdit: Sk³adnia: rdedit create [vnum]\n\r", ch );
return;
}
rdedit_create(ch, argument);
return;
}
send_to_char( "RDEdit: Sk³adnia: rdedit [vnum]\n\r", ch );
send_to_char( " rdedit create [vnum]\n\r", ch );
return;
}
void do_mpedit (CHAR_DATA * ch, char *argument)
{
MPROG_CODE *pMcode;
char command[MAX_INPUT_LENGTH];
argument = one_argument (argument, command);
if (is_number (command))
{
int vnum = atoi (command);
AREA_DATA *ad;
if ((pMcode = get_mprog_index (vnum)) == NULL)
{
send_to_char ("MPEdit : That vnum does not exist.\n\r", ch);
return;
}
ad = get_vnum_area (vnum);
if (ad == NULL)
{
send_to_char ("MPEdit : VNUM no asignado a ningun area.\n\r", ch);
return;
}
if (!IS_BUILDER (ch, ad))
{
send_to_char
("MPEdit : Insuficiente seguridad para editar area.\n\r", ch);
return;
}
ch->desc->pEdit = (void *) pMcode;
ch->desc->editor = ED_MPCODE;
return;
}
if (!str_cmp (command, "create"))
{
if (argument[0] == '\0')
{
send_to_char ("Sintaxis : mpedit create [vnum]\n\r", ch);
return;
}
mpedit_create (ch, argument);
return;
}
send_to_char ("Sintaxis : mpedit [vnum]\n\r", ch);
send_to_char (" mpedit create [vnum]\n\r", ch);
return;
}
void do_bsedit( CHAR_DATA *ch, char *argument )
{
BONUS_INDEX_DATA * pBonus;
char command[ MAX_INPUT_LENGTH ];
argument = one_argument( argument, command );
if ( is_number( command ) )
{
ush_int vnum = atoi( command );
AREA_DATA *ad;
if ( ( pBonus = get_bonus_index( vnum ) ) == NULL )
{
send_to_char( "BSEdit: Nie istnieje taki bonus set.\n\r", ch );
return ;
}
ad = get_vnum_area( vnum );
if ( ad == NULL )
{
send_to_char( "BSEdit: Nie ma przypisanej krainy.\n\r", ch );
return ;
}
if ( !IS_BUILDER( ch, ad ) )
{
send_to_char( "BSEdit: Masz niewystarczaj±ce security.\n\r", ch );
return ;
}
ch->desc->pEdit = ( void * ) pBonus;
ch->desc->editor = ED_BSDATA;
return ;
}
if ( !str_cmp( command, "create" ) )
{
if ( argument[ 0 ] == '\0' )
{
send_to_char( "BSEdit: Sk³adnia: bsedit create [vnum]\n\r", ch );
return ;
}
bsedit_create( ch, argument );
return ;
}
send_to_char( "BSEdit: SK³adnia: bsedit [vnum]\n\r", ch );
send_to_char( " bsedit create [vnum]\n\r", ch );
return ;
}
void do_mpedit(CHAR_DATA *ch, char *argument)
{
MPROG_CODE *pMcode;
char command[MAX_INPUT_LENGTH]={'\0'};
argument = one_argument(argument, command);
if( is_number(command) )
{
int vnum = atoi(command);
AREA_DATA *ad;
if ( (pMcode = get_mprog_index(vnum)) == NULL )
{
send_to_char("MPEdit : That vnum does not exist.\n\r",ch);
return;
}
ad = get_vnum_area(vnum);
if ( ad == NULL )
{
send_to_char( "MPEdit : That vnum has not been assigned to an area.\n\r", ch );
return;
}
if ( !IS_BUILDER(ch, ad) )
{
send_to_char("MPEdit : You do not have access to that area.\n\r", ch );
return;
}
ch->desc->pEdit = (void *)pMcode;
ch->desc->editor = ED_MPCODE;
return;
}
if ( !str_cmp(command, "create") )
{
if (IS_NULLSTR(argument))
{
send_to_char( "Syntax : mpedit create [vnum]\n\r", ch );
return;
}
mpedit_create(ch, argument);
return;
}
send_to_char( "Syntax : mpedit [vnum]\n\r", ch );
send_to_char( " mpedit create [vnum]\n\r", ch );
return;
}
void do_rpedit(CHAR_DATA *ch, char *argument)
{
PROG_CODE *pRcode;
char command[MAX_INPUT_LENGTH];
argument = one_argument(argument, command);
if( is_number(command) )
{
int vnum = atoi(command);
AREA_DATA *ad;
if ( (pRcode = get_prog_index(vnum,PRG_RPROG)) == NULL )
{
send_to_char("RPEdit : That vnum does not exist.\n\r",ch);
return;
}
ad = get_vnum_area(vnum);
if ( ad == NULL )
{
send_to_char( "RPEdit : Vnum is not assigned an area.\n\r", ch );
return;
}
if ( !IS_BUILDER(ch, ad) )
{
send_to_char("RPEdit : Insufficient security to modify area.\n\r", ch );
return;
}
ch->desc->pEdit = (void *)pRcode;
ch->desc->editor = ED_RPCODE;
return;
}
if ( !str_cmp(command, "create") )
{
if (argument[0] == '\0')
{
send_to_char( "Syntax : rpedit create [vnum]\n\r", ch );
return;
}
rpedit_create(ch, argument);
return;
}
send_to_char( "Syntax : rpedit [vnum]\n\r", ch );
send_to_char( " rpedit create [vnum]\n\r", ch );
return;
}
/* Room Interpreter, called by do_redit. */
void redit (CHAR_DATA * ch, char *argument)
{
AREA_DATA *pArea;
ROOM_INDEX_DATA *pRoom;
char arg[MAX_STRING_LENGTH];
char command[MAX_INPUT_LENGTH];
int cmd;
EDIT_ROOM (ch, pRoom);
pArea = pRoom->area;
smash_tilde (argument);
strcpy (arg, argument);
argument = one_argument (argument, command);
if (!IS_BUILDER (ch, pArea))
{
send_to_char ("REdit: Insufficient security to modify room.\n\r",
ch);
edit_done (ch);
return;
}
if (!str_cmp (command, "done"))
{
edit_done (ch);
return;
}
if (command[0] == '\0')
{
redit_show (ch, argument);
return;
}
/* Search Table and Dispatch Command. */
for (cmd = 0; redit_table[cmd].name != NULL; cmd++)
{
if (!str_prefix (command, redit_table[cmd].name))
{
if ((*redit_table[cmd].olc_fun) (ch, argument))
{
SET_BIT (pArea->area_flags, AREA_CHANGED);
return;
}
else
return;
}
}
/* Default to Standard Interpreter. */
interpret (ch, arg);
return;
}
/*****************************************************************************
* do_medit
*
* mobile editing interpreter
*****************************************************************************/
void medit(struct char_data *ch, const char *argument)
{
struct area_data *pArea;
struct mob_index_data *pMob;
char command[MAX_INPUT_LENGTH];
char arg[MAX_STRING_LENGTH];
const char *parg;
int cmd;
strcpy(arg, argument);
smash_tilde(arg);
parg = one_argument(arg, command);
EDIT_MOB(ch, pMob);
pArea = pMob->area;
if (!IS_BUILDER(ch, pArea)) {
send_to_char("MEdit: Insufficient security to modify area.\n\r", ch);
edit_done(ch);
return;
}
if (!str_cmp(command, "done")) {
edit_done(ch);
return;
}
if (command[0] == '\0') {
medit_show(ch, parg);
return;
}
/* Search Table and Dispatch Command. */
for (cmd = 0; medit_table[cmd].name != NULL; cmd++) {
if (!str_prefix(command, medit_table[cmd].name)) {
if ((*medit_table[cmd].olc_fn)(ch, parg)) {
SET_BIT(pArea->area_flags, AREA_CHANGED);
return;
} else {
return;
}
}
}
/* Default to Standard Interpreter. */
interpret(ch, arg);
return;
}
void look_room(struct char_data *ch, struct room_index_data *in_room) {
if (!validate_look(ch)) {
return;
}
if (in_room == NULL) {
send_to_char("NOWHERE.", ch);
return;
}
if (room_is_dark(ch, in_room) && !IS_SET(ch->act, PLR_HOLYLIGHT)) {
send_to_char("It is pitch ```8black...`` \n\r", ch);
show_char_to_char(in_room->people, ch);
return;
}
send_to_char(in_room->name, ch);
if ((IS_IMMORTAL(ch) && (IS_NPC(ch) || IS_SET(ch->act, PLR_HOLYLIGHT))) || IS_BUILDER(ch, in_room->area)) {
printf_to_char(ch, " [`1Room `!%d``]", in_room->vnum);
}
send_to_char("\n\r", ch);
if ((!IS_NPC(ch) && !IS_SET(ch->comm, COMM_BRIEF))) {
send_to_char(" ", ch);
send_to_char(in_room->description, ch);
}
send_to_char("\n\r", ch);
if ((is_affected(ch, gsp_detect_magic) || IS_SET(ch->act, PLR_HOLYLIGHT))) {
struct affect_data *paf;
for (paf = in_room->affected; paf != NULL; paf = paf->next) {
send_to_char(room_affect(paf), ch);
}
send_to_char("\n\r", ch);
}
if (!IS_NPC(ch) && IS_SET(ch->act, PLR_AUTOEXIT))
do_exits(ch, "auto");
if (is_affected_room(in_room, gsp_faerie_fog))
send_to_char("There is a `Ppurple haze`` floating throughout the room.\n\r", ch);
show_list_to_char(in_room->contents, ch, false, false);
show_char_to_char(in_room->people, ch);
return;
}
/* Entry point for editing area_data. */
void do_aedit (CHAR_DATA * ch, char *argument)
{
AREA_DATA *pArea;
int value;
char arg[MAX_STRING_LENGTH];
if (IS_NPC (ch))
return;
pArea = ch->in_room->area;
argument = one_argument (argument, arg);
if (is_number (arg))
{
value = atoi (arg);
if (!(pArea = get_area_data (value)))
{
send_to_char ("That area vnum does not exist.\n\r", ch);
return;
}
}
else if (!str_cmp (arg, "create"))
{
if (ch->pcdata->security < 9)
{
send_to_char ("AEdit : Insufficient security to create area.\n\r",
ch);
return;
}
aedit_create (ch, "");
ch->desc->editor = ED_AREA;
return;
}
if (!IS_BUILDER (ch, pArea))
{
send_to_char ("Insufficient security to edit areas.\n\r", ch);
return;
}
ch->desc->pEdit = (void *) pArea;
ch->desc->editor = ED_AREA;
return;
}
void do_mpedit( CHAR_DATA *ch, char *argument )
{
PROG_CODE * pMcode;
AREA_DATA *ad;
char command[ MAX_INPUT_LENGTH ];
argument = one_argument( argument, command );
if ( command[0] == '\0' )
{
send_to_char( "MPEdit: Skladnia : mpedit [name]\n\r", ch );
send_to_char( " mpedit create [name]\n\r", ch );
}
if ( !str_cmp( command, "create" ) )
{
if ( argument[ 0 ] == '\0' )
{
send_to_char( "RPEdit: Sk³adnia: mpedit create [name]\n\r", ch );
return ;
}
mpedit_create( ch, argument );
return ;
}
if ( ( pMcode = get_mprog_index( command ) ) == NULL )
{
print_char( ch, "MPEdit : Mobprog o nazwie '%s' nie istnieje.\n\r", command );
return ;
}
ad = pMcode->area;
if ( ad && !IS_BUILDER( ch, ad ) )
{
send_to_char( "MPEdit : Niewystarczaj±ce uprawnienia.\n\r", ch );
return ;
}
ch->desc->pEdit = ( void * ) pMcode;
ch->desc->editor = ED_MPCODE;
return ;
}
/*****************************************************************************
Name: do_asave
Purpose: Entry point for saving area data.
Called by: interpreter(interp.c)
****************************************************************************/
void do_asave( CHAR_DATA *ch, char *argument )
{
char arg1 [MAX_INPUT_LENGTH];
AREA_DATA *pArea;
int value;
if ( !ch ) /* Do an autosave */
{
save_area_list();
for( pArea = area_first; pArea; pArea = pArea->next )
{
save_area( pArea );
REMOVE_BIT( pArea->area_flags, AREA_CHANGED | AREA_ADDED );
}
return;
}
if (IS_NPC(ch)) return;
if (ch->pcdata->security < 1)
{
send_to_char("Huh?\n\r", ch );
return;
}
argument = one_argument( argument, arg1 );
if ( arg1[0] == '\0' )
{
send_to_char( "Syntax:\n\r", ch );
send_to_char( " asave <vnum> - saves a particular area\n\r", ch );
send_to_char( " asave list - saves the area.lst file\n\r", ch );
send_to_char( " asave helps - saves the help file\n\r", ch );
send_to_char( " asave area - saves the area being edited\n\r", ch );
send_to_char( " asave changed - saves all changed zones\n\r", ch );
send_to_char( " asave world - saves the world! (db dump)\n\r", ch );
send_to_char( " asave ^ verbose - saves in verbose mode\n\r", ch );
send_to_char( "\n\r", ch );
return;
}
/* Snarf the value (which need not be numeric). */
value = atoi( arg1 );
/* Save the area of given vnum. */
/* ---------------------------- */
if ( !( pArea = get_area_data( value ) ) && is_number( arg1 ) )
{
send_to_char( "That area does not exist.\n\r", ch );
return;
}
if ( is_number( arg1 ) )
{
if ( !IS_BUILDER( ch, pArea ) )
{
send_to_char( "You are not a builder for this area.\n\r", ch );
return;
}
save_area_list();
if ( !str_cmp( "verbose", argument ) )
SET_BIT( pArea->area_flags, AREA_VERBOSE );
save_area( pArea );
REMOVE_BIT( pArea->area_flags, AREA_VERBOSE );
return;
}
/* Save the world, only authorized areas. */
/* -------------------------------------- */
if ( !str_cmp( "world", arg1 ) )
{
save_area_list();
for( pArea = area_first; pArea; pArea = pArea->next )
{
/* Builder must be assigned this area. */
if ( !IS_BUILDER( ch, pArea ) )
continue;
if ( !str_cmp( "verbose", argument ) )
SET_BIT( pArea->area_flags, AREA_VERBOSE );
save_area( pArea );
REMOVE_BIT( pArea->area_flags, AREA_CHANGED | AREA_ADDED | AREA_VERBOSE );
}
send_to_char( "You saved the world.\n\r", ch );
return;
}
if (!str_cmp(arg1, "helps"))
{
if (ch->level > 6)
{
save_help();
send_to_char(" Helps saved.\n\r", ch);
}
return;
}
/* Save changed areas, only authorized areas. */
/* ------------------------------------------ */
if ( !str_cmp( "changed", arg1 ) )
{
char buf[MAX_INPUT_LENGTH];
save_area_list();
send_to_char( "Saved zones:\n\r", ch );
sprintf( buf, "None.\n\r" );
for( pArea = area_first; pArea; pArea = pArea->next )
{
/* Builder must be assigned this area. */
if ( !IS_BUILDER( ch, pArea ) )
continue;
/* Save changed areas. */
if ( IS_SET(pArea->area_flags, AREA_CHANGED)
|| IS_SET(pArea->area_flags, AREA_ADDED) )
{
if ( !str_cmp( "verbose", argument ) )
SET_BIT( pArea->area_flags, AREA_VERBOSE );
save_area( pArea );
REMOVE_BIT( pArea->area_flags, AREA_CHANGED | AREA_ADDED | AREA_VERBOSE );
sprintf( buf, "%24s - '%s'\n\r", pArea->name, pArea->filename );
send_to_char( buf, ch );
}
}
if ( !str_cmp( buf, "None.\n\r" ) )
send_to_char( buf, ch );
return;
}
/* Save the area.lst file. */
/* ----------------------- */
if ( !str_cmp( arg1, "list" ) )
{
save_area_list();
return;
}
/* Save area being edited, if authorized. */
/* -------------------------------------- */
if ( !str_cmp( arg1, "area" ) )
{
/* Find the area to save. */
switch (ch->desc->editor)
{
case ED_AREA:
pArea = (AREA_DATA *)ch->desc->pEdit;
break;
case ED_ROOM:
pArea = ch->in_room->area;
break;
case ED_OBJECT:
pArea = ( (OBJ_INDEX_DATA *)ch->desc->pEdit )->area;
break;
case ED_MOBILE:
pArea = ( (MOB_INDEX_DATA *)ch->desc->pEdit )->area;
break;
default:
pArea = ch->in_room->area;
break;
}
if ( !IS_BUILDER( ch, pArea ) )
{
send_to_char( "You are not a builder for this area.\n\r", ch );
return;
}
save_area_list();
if ( !str_cmp( "verbose", argument ) )
SET_BIT( pArea->area_flags, AREA_VERBOSE );
save_area( pArea );
REMOVE_BIT( pArea->area_flags, AREA_CHANGED | AREA_ADDED | AREA_VERBOSE );
send_to_char( "Area saved.\n\r", ch );
return;
}
/* Show correct syntax. */
/* -------------------- */
do_asave( ch, "" );
return;
}
/* Entry point for editing room_index_data. */
void do_redit (CHAR_DATA * ch, char *argument)
{
ROOM_INDEX_DATA *pRoom;
char arg1[MAX_STRING_LENGTH];
if (IS_NPC (ch))
return;
argument = one_argument (argument, arg1);
pRoom = ch->in_room;
if (!str_cmp (arg1, "reset"))
{ /* redit reset */
if (!IS_BUILDER (ch, pRoom->area))
{
send_to_char ("Insufficient security to modify room.\n\r", ch);
return;
}
reset_room (pRoom);
send_to_char ("Room reset.\n\r", ch);
return;
}
else if (!str_cmp (arg1, "create"))
{ /* redit create <vnum> */
if (argument[0] == '\0' || atoi (argument) == 0)
{
send_to_char ("Syntax: edit room create [vnum]\n\r", ch);
return;
}
if (redit_create (ch, argument))
{ /* pEdit == nuevo cuarto */
ch->desc->editor = ED_ROOM;
char_from_room (ch);
char_to_room (ch, ch->desc->pEdit);
SET_BIT (((ROOM_INDEX_DATA *) ch->desc->pEdit)->area->area_flags,
AREA_CHANGED);
}
return;
}
else if (!IS_NULLSTR (arg1))
{ /* redit <vnum> */
pRoom = get_room_index (atoi (arg1));
if (!pRoom)
{
send_to_char ("REdit : Nonexistant room.\n\r", ch);
return;
}
if (!IS_BUILDER (ch, pRoom->area))
{
send_to_char ("REdit : Insufficient security to modify room.\n\r",
ch);
return;
}
char_from_room (ch);
char_to_room (ch, pRoom);
}
if (!IS_BUILDER (ch, pRoom->area))
{
send_to_char ("REdit : Insufficient security to modify room.\n\r",
ch);
return;
}
ch->desc->pEdit = (void *) pRoom;
ch->desc->editor = ED_ROOM;
return;
}
/***************************************************************************
* change_exit
*
* change the values of an exit
***************************************************************************/
static bool change_exit(struct char_data *ch, const char *argument, int door)
{
struct room_index_data *room;
char command[MAX_INPUT_LENGTH];
char arg[MAX_INPUT_LENGTH];
int value;
EDIT_ROOM(ch, room);
/* set the exit flags - needs full argument */
if ((value = flag_value(exit_flags, argument)) != NO_FLAG) {
struct room_index_data *pToRoom;
int rev;
if (!room->exit[door]) {
send_to_char("Exit does not exist.\n\r", ch);
return false;
}
/* this room */
TOGGLE_BIT(room->exit[door]->rs_flags, value);
room->exit[door]->exit_info = room->exit[door]->rs_flags;
/* connected room */
pToRoom = room->exit[door]->u1.to_room;
rev = rev_dir[door];
if (pToRoom->exit[rev] != NULL) {
pToRoom->exit[rev]->rs_flags = room->exit[door]->rs_flags;
pToRoom->exit[rev]->exit_info = room->exit[door]->exit_info;
}
send_to_char("Exit flag toggled.\n\r", ch);
return true;
}
/* parse the arguments */
argument = one_argument(argument, command);
one_argument(argument, arg);
if (command[0] == '\0' && argument[0] == '\0') {
move_char(ch, door, true);
return false;
}
if (command[0] == '?') {
show_help(ch->desc, "OLC_EXIT", NULL);
return false;
}
if (!str_cmp(command, "delete")) {
struct room_index_data *pToRoom;
int rev;
if (!room->exit[door]) {
send_to_char("REdit: Cannot delete a null exit.\n\r", ch);
return false;
}
/* remove ToRoom exit */
rev = rev_dir[door];
pToRoom = room->exit[door]->u1.to_room;
if (pToRoom->exit[rev]) {
free_exit(pToRoom->exit[rev]);
pToRoom->exit[rev] = NULL;
}
/* remove this exit */
free_exit(room->exit[door]);
room->exit[door] = NULL;
send_to_char("Exit unlinked.\n\r", ch);
return true;
}
if (!str_cmp(command, "link")) {
struct exit_data *pExit;
struct room_index_data *toRoom;
if (arg[0] == '\0' || !is_number(arg)) {
send_to_char("Syntax: [direction] link [vnum]\n\r", ch);
return false;
}
value = parse_int(arg);
if (!(toRoom = get_room_index(value))) {
send_to_char("REdit: Cannot link to non-existant room.\n\r", ch);
return false;
}
if (!IS_BUILDER(ch, toRoom->area)) {
send_to_char("REdit: Cannot link to that area.\n\r", ch);
return false;
}
if (toRoom->exit[rev_dir[door]]) {
send_to_char("REdit: Remote side's exit already exists.\n\r", ch);
return false;
}
if (!room->exit[door])
room->exit[door] = new_exit();
room->exit[door]->u1.to_room = toRoom;
room->exit[door]->orig_door = door;
door = rev_dir[door];
pExit = new_exit();
pExit->u1.to_room = room;
pExit->orig_door = door;
toRoom->exit[door] = pExit;
send_to_char("Two-way link established.\n\r", ch);
return true;
}
if (!str_cmp(command, "dig")) {
char buf[MAX_STRING_LENGTH];
if (arg[0] == '\0' || !is_number(arg)) {
send_to_char("Syntax: [direction] dig <vnum>\n\r", ch);
return false;
}
redit_create(ch, arg);
sprintf(buf, "link %s", arg);
change_exit(ch, buf, door);
return true;
}
if (!str_cmp(command, "room")) {
struct room_index_data *toRoom;
if (arg[0] == '\0' || !is_number(arg)) {
send_to_char("Syntax: [direction] room [vnum]\n\r", ch);
return false;
}
value = parse_int(arg);
if (!(toRoom = get_room_index(value))) {
send_to_char("REdit: Cannot link to non-existant room.\n\r", ch);
return false;
}
if (!room->exit[door])
room->exit[door] = new_exit();
room->exit[door]->u1.to_room = toRoom;
room->exit[door]->orig_door = door;
send_to_char("One-way link established.\n\r", ch);
return true;
}
if (!str_cmp(command, "key")) {
struct objectprototype *key;
if (arg[0] == '\0' || !is_number(arg)) {
send_to_char("Syntax: [direction] key [vnum]\n\r", ch);
return false;
}
if (!room->exit[door]) {
send_to_char("Exit does not exist.\n\r", ch);
return false;
}
value = parse_int(arg);
if (!(key = objectprototype_getbyvnum(value))) {
send_to_char("REdit: Key doesn't exist.\n\r", ch);
return false;
}
if (key->item_type != ITEM_KEY) {
send_to_char("REdit: Object is not a key.\n\r", ch);
return false;
}
room->exit[door]->key = value;
send_to_char("Exit key set.\n\r", ch);
return true;
}
if (!str_cmp(command, "name")) {
if (arg[0] == '\0') {
send_to_char("Syntax: [direction] name [string]\n\r", ch);
send_to_char(" [direction] name none\n\r", ch);
return false;
}
if (!room->exit[door]) {
send_to_char("Exit does not exist.\n\r", ch);
return false;
}
free_string(room->exit[door]->keyword);
if (str_cmp(arg, "none"))
room->exit[door]->keyword = str_dup(arg);
else
room->exit[door]->keyword = str_dup("");
send_to_char("Exit name set.\n\r", ch);
return true;
}
if (!str_prefix(command, "description")) {
if (arg[0] == '\0') {
if (!room->exit[door]) {
send_to_char("Exit does not exist.\n\r", ch);
return false;
}
string_append(ch, &room->exit[door]->description);
return true;
}
send_to_char("Syntax: [direction] desc\n\r", ch);
return false;
}
return false;
}
/*****************************************************************************
* do_redit
*
* entry level function into the room editor
*****************************************************************************/
void do_redit(struct char_data *ch, const char *argument)
{
struct room_index_data *room;
char arg[MAX_STRING_LENGTH];
if (IS_NPC(ch))
return;
argument = one_argument(argument, arg);
room = ch->in_room;
if (!str_cmp(arg, "reset")) { /* redit reset */
if (!IS_BUILDER(ch, room->area)) {
send_to_char("Insufficient security to edit rooms.\n\r", ch);
return;
}
reset_room(room);
send_to_char("Room reset.\n\r", ch);
return;
} else {
if (!str_cmp(arg, "create")) { /* redit create <vnum> */
if (argument[0] == '\0' || parse_int(argument) == 0) {
send_to_char("Syntax: edit room create [vnum]\n\r", ch);
return;
}
if (redit_create(ch, argument)) {
ch->desc->editor = ED_ROOM;
char_from_room(ch);
char_to_room(ch, ch->desc->ed_data);
SET_BIT(((struct room_index_data *)ch->desc->ed_data)->area->area_flags, AREA_CHANGED);
}
return;
} else if (!str_cmp(arg, "clone")) {
if (argument[0] == '\0') {
send_to_char("Syntax: edit room clone [new vnum] [existing vnum]\n\r", ch);
return;
}
if (redit_create(ch, argument)) {
argument = one_argument(argument, arg);
ch->desc->editor = ED_ROOM;
char_from_room(ch);
char_to_room(ch, ch->desc->ed_data);
SET_BIT(((struct room_index_data *)ch->desc->ed_data)->area->area_flags, AREA_CHANGED);
redit_clone(ch, argument);
}
return;
} else if (!IS_NULLSTR(arg)) { /* redit <vnum> */
room = get_room_index(parse_int(arg));
if (!room) {
send_to_char("REdit : room does not exist.\n\r", ch);
return;
}
if (!IS_BUILDER(ch, room->area)) {
send_to_char("REdit : insufficient security to edit rooms.\n\r", ch);
return;
}
char_from_room(ch);
char_to_room(ch, room);
}
}
if (!IS_BUILDER(ch, room->area)) {
send_to_char("REdit : Insufficient security to edit rooms.\n\r", ch);
return;
}
ch->desc->ed_data = (void *)room;
ch->desc->editor = ED_ROOM;
return;
}
/* Entry point for editing obj_index_data. */
void do_oedit (CHAR_DATA * ch, char *argument)
{
OBJ_INDEX_DATA *pObj;
AREA_DATA *pArea;
char arg1[MAX_STRING_LENGTH];
int value;
if (IS_NPC (ch))
return;
argument = one_argument (argument, arg1);
if (is_number (arg1))
{
value = atoi (arg1);
if (!(pObj = get_obj_index (value)))
{
send_to_char ("OEdit: That vnum does not exist.\n\r", ch);
return;
}
if (!IS_BUILDER (ch, pObj->area))
{
send_to_char ("Insufficient security to modify objects.\n\r", ch);
return;
}
ch->desc->pEdit = (void *) pObj;
ch->desc->editor = ED_OBJECT;
return;
}
else
{
if (!str_cmp (arg1, "create"))
{
value = atoi (argument);
if (argument[0] == '\0' || value == 0)
{
send_to_char ("Syntax: edit object create [vnum]\n\r", ch);
return;
}
pArea = get_vnum_area (value);
if (!pArea)
{
send_to_char
("OEdit: That vnum is not assigned an area.\n\r", ch);
return;
}
if (!IS_BUILDER (ch, pArea))
{
send_to_char ("Insufficient security to modify objects.\n\r",
ch);
return;
}
if (oedit_create (ch, argument))
{
SET_BIT (pArea->area_flags, AREA_CHANGED);
ch->desc->editor = ED_OBJECT;
}
return;
}
}
send_to_char ("OEdit: There is no default object to edit.\n\r", ch);
return;
}
void mpedit( CHAR_DATA *ch, char *argument )
{
PROG_CODE * pMcode;
char arg[ MAX_INPUT_LENGTH ];
char command[ MAX_INPUT_LENGTH ];
char log_buf[ MAX_STRING_LENGTH ];
int cmd;
AREA_DATA *ad;
smash_tilde( argument );
strcpy( arg, argument );
argument = one_argument( argument, command );
EDIT_MPCODE( ch, pMcode );
if ( pMcode )
{
ad = pMcode->area;
if ( ad == NULL ) /* ? */
{
edit_done( ch );
return ;
}
if ( !IS_BUILDER( ch, ad ) )
{
send_to_char( "MPEdit: Insufficient security to modify code.\n\r", ch );
edit_done( ch );
return ;
}
}
if ( command[ 0 ] == '\0' )
{
mpedit_show( ch, argument );
return ;
}
if ( !str_cmp( command, "done" ) )
{
edit_done( ch );
return ;
}
for ( cmd = 0; mpedit_table[ cmd ].name != NULL; cmd++ )
{
if ( !str_prefix( command, mpedit_table[ cmd ].name ) )
{
if ( ( *mpedit_table[ cmd ].olc_fun ) ( ch, argument ) && pMcode )
{
if ( ( ad = pMcode->area ) != NULL )
{
SET_BIT( ad->area_flags, AREA_CHANGED );
}
append_file_format_daily( ch, BUILD_LOG_FILE, "-> mpedit %s: %s", pMcode ? pMcode->name: "0", arg );
}
return ;
}
}
interpret( ch, arg );
return ;
}
/* Entry point for editing mob_index_data. */
void do_medit (CHAR_DATA * ch, char *argument)
{
MOB_INDEX_DATA *pMob;
AREA_DATA *pArea;
int value;
char arg1[MAX_STRING_LENGTH];
argument = one_argument (argument, arg1);
if (IS_NPC (ch))
return;
if (is_number (arg1))
{
value = atoi (arg1);
if (!(pMob = get_mob_index (value)))
{
send_to_char ("MEdit: That vnum does not exist.\n\r", ch);
return;
}
if (!IS_BUILDER (ch, pMob->area))
{
send_to_char ("Insufficient security to modify mobs.\n\r", ch);
return;
}
ch->desc->pEdit = (void *) pMob;
ch->desc->editor = ED_MOBILE;
return;
}
else
{
if (!str_cmp (arg1, "create"))
{
value = atoi (argument);
if (arg1[0] == '\0' || value == 0)
{
send_to_char ("Syntax: edit mobile create [vnum]\n\r", ch);
return;
}
pArea = get_vnum_area (value);
if (!pArea)
{
send_to_char
("OEdit: That vnum is not assigned an area.\n\r", ch);
return;
}
if (!IS_BUILDER (ch, pArea))
{
send_to_char ("Insufficient security to modify mobs.\n\r",
ch);
return;
}
if (medit_create (ch, argument))
{
SET_BIT (pArea->area_flags, AREA_CHANGED);
ch->desc->editor = ED_MOBILE;
}
return;
}
}
send_to_char ("MEdit: There is no default mobile to edit.\n\r", ch);
return;
}
