olc_act.c

Go to the documentation of this file.

/***************************************************************************
 *  File: olc_act.c                                                        *
 *                                                                         *
 *  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.                                                  *
 *                                                                         *
 *  This code was freely distributed with the The Isles 1.1 source code,   *
 *  and has been used here for OLC - OLC would not be what it is without   *
 *  all the previous coders who released their source code.                *
 *                                                                         *
 ***************************************************************************/



#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#endif
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "merc.h"
#include "tables.h"
#include "olc.h"
#include "recycle.h"
#include "lookup.h"

char *mprog_type_to_name (int type);

#define ALT_FLAGVALUE_SET( _blargh, _table, _arg )        \
    {                            \
        int blah = flag_value( _table, _arg );        \
        _blargh = (blah == NO_FLAG) ? 0 : blah;        \
    }

#define ALT_FLAGVALUE_TOGGLE( _blargh, _table, _arg )        \
    {                            \
        int blah = flag_value( _table, _arg );        \
        _blargh ^= (blah == NO_FLAG) ? 0 : blah;    \
    }

/* Return TRUE if area changed, FALSE if not. */
#define REDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
#define OEDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
#define MEDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
#define AEDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
#define SEDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
#define HEDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
//#define CEDIT( fun )      bool fun( CHAR_DATA *ch, char *argument )

struct olc_help_type {
    char *command;
    const void *structure;
    char *desc;
};

bool show_version (CHAR_DATA * ch, char *argument)
{
    send_to_char (VERSION, ch);
    send_to_char ("\n\r", ch);
    send_to_char (AUTHOR, ch);
    send_to_char ("\n\r", ch);
    send_to_char (DATE, ch);
    send_to_char ("\n\r", ch);
    send_to_char (CREDITS, ch);
    send_to_char ("\n\r", ch);

    return FALSE;
}

/*
 * This table contains help commands and a brief description of each.
 * ------------------------------------------------------------------
 */
const struct olc_help_type help_table[] = {
    {"area", area_flags, "Area attributes."},
    {"room", room_flags, "Room attributes."},
    {"sector", sector_flags, "Sector types, terrain."},
    {"exit", exit_flags, "Exit types."},
    {"type", type_flags, "Types of objects."},
    {"extra", extra_flags, "Object attributes."},
    {"wear", wear_flags, "Where to wear object."},
    {"spec", spec_table, "Available special programs."},
    {"sex", sex_flags, "Sexes."},
    {"act", act_flags, "Mobile attributes."},
    {"affect", affect_flags, "Mobile affects."},
    {"wear-loc", wear_loc_flags, "Where mobile wears object."},
    {"spells", skill_table, "Names of current spells."},
    {"container", container_flags, "Container status."},
    {"extended", room_flags_extra, "Extended room Attributes -- tribul"},

/* ROM specific bits: */

    {"armor", ac_type, "Ac for different attacks."},
    {"apply", apply_flags, "Apply flags"},
    {"form", form_flags, "Mobile body form."},
    {"part", part_flags, "Mobile body parts."},
    {"imm", imm_flags, "Mobile immunity."},
    {"res", res_flags, "Mobile resistance."},
    {"vuln", vuln_flags, "Mobile vulnerability."},
    {"off", off_flags, "Mobile offensive behaviour."},
    {"size", size_flags, "Mobile size."},
    {"position", position_flags, "Mobile positions."},
    {"wclass", weapon_class, "Weapon class."},
    {"wtype", weapon_type2, "Special weapon type."},
    {"portal", portal_flags, "Portal types."},
    {"furniture", furniture_flags, "Furniture types."},
    {"liquid", liq_table, "Liquid types."},
    {"apptype", apply_types, "Apply types."},
    {"weapon", attack_table, "Weapon types."},
    {"mprog", mprog_flags, "MobProgram flags."},
    /*{"wname", cedit_wname, "Three letter who name"},
    {"thac0", cedit_thac_0, "To hit armor class level zero"},
    {"thac32", cedit_thac_32, "To hit armor class level 32"},
    {"skill", cedit_skill, "How high the class can practice a skill to"},*/
    {NULL, NULL, NULL}
};

/*****************************************************************************
 Name:        show_flag_cmds
 Purpose:    Displays settable flags and stats.
 Called by:    show_help(olc_act.c).
 ****************************************************************************/
void show_flag_cmds (CHAR_DATA * ch, const struct flag_type *flag_table)
{
    char buf[MAX_STRING_LENGTH];
    char buf1[MAX_STRING_LENGTH];
    int flag;
    int col;

    buf1[0] = '\0';
    col = 0;
    for (flag = 0; flag_table[flag].name != NULL; flag++)
    {
        if (flag_table[flag].settable)
        {
            sprintf (buf, "%-19.18s", flag_table[flag].name);
            strcat (buf1, buf);
            if (++col % 4 == 0)
                strcat (buf1, "\n\r");
        }
    }

    if (col % 4 != 0)
        strcat (buf1, "\n\r");

    send_to_char (buf1, ch);
    return;
}


/*****************************************************************************
 Name:        show_skill_cmds
 Purpose:    Displays all skill functions.
         Does remove those damn immortal commands from the list.
         Could be improved by:
         (1) Adding a check for a particular class.
         (2) Adding a check for a level range.
 Called by:    show_help(olc_act.c).
 ****************************************************************************/
void show_skill_cmds (CHAR_DATA * ch, int tar)
{
    char buf[MAX_STRING_LENGTH];
    char buf1[MAX_STRING_LENGTH * 2];
    int sn;
    int col;

    buf1[0] = '\0';
    col = 0;
    for (sn = 0; sn < MAX_SKILL; sn++)
    {
        if (!skill_table[sn].name)
            break;

        if (!str_cmp (skill_table[sn].name, "reserved")
            || skill_table[sn].spell_fun == spell_null)
            continue;

        if (tar == -1 || skill_table[sn].target == tar)
        {
            sprintf (buf, "%-19.18s", skill_table[sn].name);
            strcat (buf1, buf);
            if (++col % 4 == 0)
                strcat (buf1, "\n\r");
        }
    }

    if (col % 4 != 0)
        strcat (buf1, "\n\r");

    send_to_char (buf1, ch);
    return;
}


/*****************************************************************************
 Name:        show_spec_cmds
 Purpose:    Displays settable special functions.
 Called by:    show_help(olc_act.c).
 ****************************************************************************/
void show_spec_cmds (CHAR_DATA * ch)
{
    char buf[MAX_STRING_LENGTH];
    char buf1[MAX_STRING_LENGTH];
    int spec;
    int col;

    buf1[0] = '\0';
    col = 0;
    send_to_char ("Preceed special functions with 'spec_'\n\r\n\r", ch);
    for (spec = 0; spec_table[spec].function != NULL; spec++)
    {
        sprintf (buf, "%-19.18s", &spec_table[spec].name[5]);
        strcat (buf1, buf);
        if (++col % 4 == 0)
            strcat (buf1, "\n\r");
    }

    if (col % 4 != 0)
        strcat (buf1, "\n\r");

    send_to_char (buf1, ch);
    return;
}

/*****************************************************************************
 Name:        show_help
 Purpose:    Displays help for many tables used in OLC.
 Called by:    olc interpreters.
 ****************************************************************************/
bool show_help (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    char arg[MAX_INPUT_LENGTH];
    char spell[MAX_INPUT_LENGTH];
    int cnt;

    argument = one_argument (argument, arg);
    one_argument (argument, spell);

    /*
     * Display syntax.
     */
    if (arg[0] == '\0')
    {
        send_to_char ("Syntax:  ? [command]\n\r\n\r", ch);
        send_to_char ("[command]  [description]\n\r", ch);
        for (cnt = 0; help_table[cnt].command != NULL; cnt++)
        {
            sprintf (buf, "%-10.10s -%s\n\r",
                     capitalize (help_table[cnt].command),
                     help_table[cnt].desc);
            send_to_char (buf, ch);
        }
        return FALSE;
    }

    /*
     * Find the command, show changeable data.
     * ---------------------------------------
     */
    for (cnt = 0; help_table[cnt].command != NULL; cnt++)
    {
        if (arg[0] == help_table[cnt].command[0]
            && !str_prefix (arg, help_table[cnt].command))
        {
            if (help_table[cnt].structure == spec_table)
            {
                show_spec_cmds (ch);
                return FALSE;
            }
            else if (help_table[cnt].structure == liq_table)
            {
                show_liqlist (ch);
                return FALSE;
            }
            else if (help_table[cnt].structure == attack_table)
            {
                show_damlist (ch);
                return FALSE;
            }
            else if (help_table[cnt].structure == skill_table)
            {

                if (spell[0] == '\0')
                {
                    send_to_char ("Syntax:  ? spells "
                                  "[ignore/attack/defend/self/object/all]\n\r",
                                  ch);
                    return FALSE;
                }

                if (!str_prefix (spell, "all"))
                    show_skill_cmds (ch, -1);
                else if (!str_prefix (spell, "ignore"))
                    show_skill_cmds (ch, TAR_IGNORE);
                else if (!str_prefix (spell, "attack"))
                    show_skill_cmds (ch, TAR_CHAR_OFFENSIVE);
                else if (!str_prefix (spell, "defend"))
                    show_skill_cmds (ch, TAR_CHAR_DEFENSIVE);
                else if (!str_prefix (spell, "self"))
                    show_skill_cmds (ch, TAR_CHAR_SELF);
                else if (!str_prefix (spell, "object"))
                    show_skill_cmds (ch, TAR_OBJ_INV);
                else
                    send_to_char ("Syntax:  ? spell "
                                  "[ignore/attack/defend/self/object/all]\n\r",
                                  ch);

                return FALSE;
            }
            else
            {
                show_flag_cmds (ch, help_table[cnt].structure);
                return FALSE;
            }
        }
    }

    show_help (ch, "");
    return FALSE;
}
/*
void do_flagall(CHAR_DATA *ch, char *argument)
{
    char arg[MSL];
    char buf[MSL];
    ROOM_INDEX_DATA *pRoom;
    AREA_DATA *pArea;
    int count,vnum,value=0;
    bool found;
    

    argument = one_argument(argument, arg);

    if (ch->level < 59)
    {
        send_to_char("Huh?\n\r",ch);
        return;
    }
    
    if (arg[0] == '\0' || argument[0] == '\0')
    {
        send_to_char("Syntax: Flagall [name|sector|room|extended] <flags>\n\r",ch);
        return;
    }

    if (!str_prefix(arg, "name") || !str_prefix(arg, "sector") || !str_prefix(arg, "room") 
            || !str_prefix(arg, "extended"))
    {
        pArea = ch->in_room->area;
        for (vnum=pArea->min_vnum;vnum <=pArea->max_vnum;vnum++)
        {
            
            if ((pRoom = get_room_index(vnum)))
            {
                found = TRUE;
                if (!str_prefix(arg, "name"))
                {
                    free_string (pRoom->name);
                    pRoom->name = str_dup (argument);
                    count++;
                    continue;
                }
                else if (!str_prefix(arg, "sector"))
                {
                    if ((value = flag_value (sector_flags, argument)) == NO_FLAG)
                    {
                        send_to_char ("Invalid flag. Not setting rooms.\n\r", ch);
                        return;
                    }
                    pRoom->sector_type = value;
                    count++;
                    continue;
                }
                else if (!str_prefix(arg, "room"))
                {
                    if ((value = flag_value(room_flags, argument)) == NO_FLAG)
                    {
                        send_to_char("Invalid flag. Not setting rooms.\n\r",ch);
                        return;
                    }
                    pRoom->room_flags = value;
                    count++;
                    continue;
                }
                else if (!str_prefix(arg, "extended"))
                {
                    send_to_char("No extendeds allowed right now.\n\r",ch);
                    return;
                }
                else
                {
                    send_to_char("Invalid type.\n\r",ch);
                    return;
                }
            }
        }
        
        if (found)
        {
            sprintf(buf, "%d rooms set.\n\r",count);
            send_to_char(buf,ch);
            SET_BIT (ch->in_room->area->area_flags, AREA_CHANGED);
                    
            return;
        }
        else
        {
            send_to_char("No rooms in area.\n\r",ch);
            return;
        }
    }
}
                
                
*/
                
SEDIT (sedit_create)
{
        SOCIAL_LIST *slist;
    slist = new_social();
    add_social(slist);
    ch->desc->pEdit = (void*)slist;
    
    send_to_char("Social Created.\n\r", ch);
    //strcpy(slist->name, argument) ;
    slist->name = str_dup(argument);
    return;
}

SEDIT (sedit_show)
{
    SOCIAL_LIST *slist;
    EDIT_SOCIAL(ch, slist);
    
        printf_to_char(ch, "Name          : %s\n", slist->name);
    printf_to_char(ch, "Char, no arg  : %s\n", slist->char_no_arg);
    printf_to_char(ch, "Others, no arg: %s\n", slist->others_no_arg);
    printf_to_char(ch, "Char Found    : %s\n", slist->char_found);
    printf_to_char(ch, "Others Found  : %s\n", slist->others_found);
    printf_to_char(ch, "Vict found    : %s\n", slist->vict_found);
    printf_to_char(ch, "Char not found: %s\n", slist->char_not_found);
    printf_to_char(ch, "Char auto     : %s\n", slist->char_auto);
    printf_to_char(ch, "Others auto   : %s\n", slist->others_auto);
    return;
}

SEDIT (sedit_char_no_arg)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n",ch);
        return;
    }

    EDIT_SOCIAL(ch, slist);
    slist->char_no_arg = str_dup(argument);
    printf_to_char(ch, "Char_no_arg set to %s.\n", slist->char_no_arg);
    return;
}

SEDIT (sedit_others_no_arg)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n",ch);
        return;
    }
    
    EDIT_SOCIAL(ch, slist);
    slist->others_no_arg = str_dup(argument);
    printf_to_char(ch, "Others_no_arg set to %s.\n", slist->others_no_arg);
    
        return;
}

SEDIT (sedit_char_found)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n",ch);
        return;
    }

    EDIT_SOCIAL(ch, slist);
    slist->char_found = str_dup(argument);
    printf_to_char(ch, "Char_found set to %s.\n", slist->char_found);
        return;
}

SEDIT (sedit_vict_found)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n",ch);
        return;
    }

    EDIT_SOCIAL(ch,slist);
    slist->vict_found = str_dup(argument);
    printf_to_char(ch, "Vict_found set to %s.\n", slist->vict_found);
    return;
}

SEDIT (sedit_others_found)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n",ch);
        return;
    }
    EDIT_SOCIAL(ch,slist);
    slist->others_found = str_dup(argument);
    printf_to_char(ch, "Others_found set to %s.\n", slist->others_found);
        return;
}

SEDIT (sedit_char_auto)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n\r",ch);
        return;
    }
    EDIT_SOCIAL(ch, slist);
    slist->char_auto = str_dup(argument);
    printf_to_char(ch, "Char_auto set to %s.\n\r", slist->char_auto);
    return;
}

SEDIT (sedit_others_auto)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n\r",ch);
        return;
    }

    EDIT_SOCIAL (ch, slist);
    slist->others_auto = str_dup(argument);
    printf_to_char(ch, "Others_auto set to %s\n\r",slist->others_auto);
        return;
}

SEDIT (sedit_char_not_found)
{
    SOCIAL_LIST *slist;
    if (argument[0] == '\0')
    {
        send_to_char("Please enter a value.\n\r",ch);
        return;
    }

    EDIT_SOCIAL(ch,slist);
    slist->char_not_found = str_dup(argument);
    printf_to_char(ch, "Char_not_found set to %s.\n\r",slist->char_not_found);
    return;
}

SEDIT (sedit_delete)
{
    SOCIAL_LIST *slist;
    EDIT_SOCIAL(ch,slist);

    slist->name = NULL;
    slist->char_no_arg = NULL;

    send_to_char("Social Marked for deletion.\n\r",ch);
    
        return;
}

REDIT (redit_rlist)
{
    ROOM_INDEX_DATA *pRoomIndex;
    AREA_DATA *pArea;
    char buf[MAX_STRING_LENGTH];
    BUFFER *buf1;
    char arg[MAX_INPUT_LENGTH];
    bool found;
    int vnum;
    int col = 0;
    int roomcount=0;

    one_argument (argument, arg);

    pArea = ch->in_room->area;
    buf1 = new_buf ();
/*    buf1[0] = '\0'; */
    found = FALSE;

    for (vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++)
    {
        if ((pRoomIndex = get_room_index (vnum)))
        {
            found = TRUE;
            sprintf (buf, "{x[{c%9d{x] {W%-17.16s{x",
                     vnum, capitalize (pRoomIndex->name));
            add_buf (buf1, buf);
        roomcount++;
            if (++col % 3 == 0)
                add_buf (buf1, "\n\r");
        }
    }

    if (!found)
    {
        send_to_char ("Room(s) not found in this area.\n\r", ch);
        return FALSE;
    }

    if (col % 3 != 0)
        add_buf (buf1, "\n\r");
        sprintf(buf, "\n\r\n\rRooms total: {R%d{x\n\r", roomcount);
    add_buf (buf1, buf);

    page_to_char (buf_string (buf1), ch);
    free_buf (buf1);
    return FALSE;
}


REDIT (redit_mlist)
{
    MOB_INDEX_DATA *pMobIndex;
    AREA_DATA *pArea;
    char buf[MAX_STRING_LENGTH];
    BUFFER *buf1;
    char arg[MAX_INPUT_LENGTH];
    bool fAll, found;
    int vnum;
    int col = 0;
    int numcount=0;

    one_argument (argument, arg);
    if (arg[0] == '\0')
    {
        send_to_char ("Syntax:  mlist <all/name>\n\r", ch);
        return FALSE;
    }

    buf1 = new_buf ();
    pArea = ch->in_room->area;
/*    buf1[0] = '\0'; */
    fAll = !str_cmp (arg, "all");
    found = FALSE;

    for (vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++)
    {
        if ((pMobIndex = get_mob_index (vnum)) != NULL)
        {
            if (fAll || is_name (arg, pMobIndex->player_name))
            {
                found = TRUE;
                sprintf (buf, "[%5d] %-17.16s",
                         pMobIndex->vnum,
                         capitalize (pMobIndex->short_descr));
                add_buf (buf1, buf);
        numcount++;
                if (++col % 3 == 0)
                    add_buf (buf1, "\n\r");
            }
        }
    }

    if (!found)
    {
        send_to_char ("Mobile(s) not found in this area.\n\r", ch);
        return FALSE;
    }

    if (col % 3 != 0)
        add_buf (buf1, "\n\r");
    sprintf(buf, "\n\r\n\rMobiles found: %d\n\r", numcount);
    add_buf(buf1,buf);

    page_to_char (buf_string (buf1), ch);
    free_buf (buf1);
    return FALSE;
}

REDIT (redit_olist)
{
    OBJ_INDEX_DATA *pObjIndex;
    AREA_DATA *pArea;
    char buf[MAX_STRING_LENGTH*2];
    BUFFER *buf1;
    char arg[MAX_INPUT_LENGTH];
    bool fAll, found;
    int vnum;
    int col = 0;

    one_argument (argument, arg);
    if (arg[0] == '\0')
    {
        send_to_char ("Syntax:  olist <all/name/item_type>\n\r", ch);
        return FALSE;
    }

    pArea = ch->in_room->area;
    buf1 = new_buf ();
/*    buf1[0] = '\0'; */
    fAll = !str_cmp (arg, "all");
    found = FALSE;

    for (vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++)
    {
        if ((pObjIndex = get_obj_index (vnum)))
        {
            if (fAll || is_name (arg, pObjIndex->name)
                || flag_value (type_flags, arg) == pObjIndex->item_type)
            {
                found = TRUE;
                sprintf (buf, "{x[{c%-7d{x] {W%-40.39s{x ", pObjIndex->vnum, 
                str_dup(pObjIndex->short_descr));
                add_buf (buf1, buf);
                if (++col % 1 == 0)
                    add_buf (buf1, "\n\r");
            }
        }
    }

    if (!found)
    {
        send_to_char ("Object(s) not found in this area.\n\r", ch);
        return FALSE;
    }

    if (col % 3 != 0)
        add_buf (buf1, "\n\r");

    page_to_char (buf_string (buf1), ch);
    free_buf (buf1);
    return FALSE;
}

REDIT (redit_mshow)
{
    MOB_INDEX_DATA *pMob;
    int value;

    if (argument[0] == '\0')
    {
        send_to_char ("Syntax:  mshow <vnum>\n\r", ch);
        return FALSE;
    }

    if (!is_number (argument))
    {
        send_to_char ("REdit: Must be a number.\n\r", ch);
        return FALSE;
    }

    if (is_number (argument))
    {
        value = atoi (argument);
        if (!(pMob = get_mob_index (value)))
        {
            send_to_char ("REdit:  That mobile does not exist.\n\r", ch);
            return FALSE;
        }

        ch->desc->pEdit = (void *) pMob;
    }

    medit_show (ch, argument);
    ch->desc->pEdit = (void *) ch->in_room;
    return FALSE;
}

REDIT (redit_oshow)
{
    OBJ_INDEX_DATA *pObj;
    int value;

    if (argument[0] == '\0')
    {
        send_to_char ("Syntax:  oshow <vnum>\n\r", ch);
        return FALSE;
    }

    if (!is_number (argument))
    {
        send_to_char ("REdit: Must be a number.\n\r", ch);
        return FALSE;
    }

    if (is_number (argument))
    {
        value = atoi (argument);
        if (!(pObj = get_obj_index (value)))
        {
            send_to_char ("REdit:  That object does not exist.\n\r", ch);
            return FALSE;
        }

        ch->desc->pEdit = (void *) pObj;
    }

    oedit_show (ch, argument);
    ch->desc->pEdit = (void *) ch->in_room;
    return FALSE;
}

/*****************************************************************************
 Name:        check_range( lower vnum, upper vnum )
 Purpose:    Ensures the range spans only one area.
 Called by:    aedit_vnum(olc_act.c).
 ****************************************************************************/
bool check_range (int lower, int upper)
{
    AREA_DATA *pArea;
    int cnt = 0;

    for (pArea = area_first; pArea; pArea = pArea->next)
    {
        /*
         * lower < area < upper
         */
        if ((lower <= pArea->min_vnum && pArea->min_vnum <= upper)
            || (lower <= pArea->max_vnum && pArea->max_vnum <= upper))
            ++cnt;

        if (cnt > 1)
            return FALSE;
    }
    return TRUE;
}

AREA_DATA *get_vnum_area (int vnum)
{
    AREA_DATA *pArea;

    for (pArea = area_first; pArea; pArea = pArea->next)
    {
        if (vnum >= pArea->min_vnum && vnum <= pArea->max_vnum)
            return pArea;
    }

    return 0;
}

/*
 * Area Editor Functions.
 */
AEDIT (aedit_show)
{
    AREA_DATA *pArea;
    char buf[MAX_STRING_LENGTH];

    EDIT_AREA (ch, pArea);

    sprintf (buf, "Name:     [{c%5d{x] {c%s{x\n\r", pArea->vnum, pArea->name);
    send_to_char (buf, ch);

#if 0                            /* ROM OLC */
    sprintf (buf, "Recall:   [%5d] %s\n\r", pArea->recall,
             get_room_index (pArea->recall)
             ? get_room_index (pArea->recall)->name : "none");
    send_to_char (buf, ch);
#endif /* ROM */

    sprintf (buf, "File:     {c%s{x\n\r", pArea->file_name);
    send_to_char (buf, ch);

    sprintf (buf, "Vnums:    [{c%d{w-{c%d{x]\n\r", pArea->min_vnum, pArea->max_vnum);
    send_to_char (buf, ch);

    sprintf (buf, "Age:      [{c%d{x]\n\r", pArea->age);
    send_to_char (buf, ch);

    sprintf (buf, "Players:  [{c%d{x]\n\r", pArea->nplayer);
    send_to_char (buf, ch);

    sprintf (buf, "Security: [{c%d{x]\n\r", pArea->security);
    send_to_char (buf, ch);

    sprintf (buf, "Builders: [{c%s{x]\n\r", pArea->builders);
    send_to_char (buf, ch);

    sprintf (buf, "Credits : [{c%s{x]\n\r", pArea->credits);
    send_to_char (buf, ch);

    sprintf (buf, "Flags:    [{c%s{x]\n\r",
             flag_string (area_flags, pArea->area_flags));
    send_to_char (buf, ch);

    sprintf(buf, "Cont:     [{c%s{x]\n\r", pArea->cont);
    send_to_char(buf,ch);

    return FALSE;
}

AEDIT (aedit_reset)
{
    AREA_DATA *pArea;

    EDIT_AREA (ch, pArea);

    reset_area (pArea);
    send_to_char ("Area reset.\n\r", ch);

    return FALSE;
}

AEDIT (aedit_create)
{
    AREA_DATA *pArea;

    pArea = new_area ();
    area_last->next = pArea;
    area_last = pArea;            /* Thanks, Walker. */
    ch->desc->pEdit = (void *) pArea;

    SET_BIT (pArea->area_flags, AREA_ADDED);
    send_to_char ("Area Created.\n\r", ch);
    return FALSE;
}



AEDIT (aedit_name)
{
    AREA_DATA *pArea;

    EDIT_AREA (ch, pArea);

    if (argument[0] == '\0')
    {
        send_to_char ("Syntax:   name [$name]\n\r", ch);
        return FALSE;
    }

    free_string (pArea->name);
    pArea->name = str_dup (argument);

    send_to_char ("Name set.\n\r", ch);
    return TRUE;
}
AEDIT (aedit_cont)
{
    AREA_DATA *pArea;
    EDIT_AREA(ch,pArea);

    if (argument[0] == '\0')
    {
        send_to_char("Syntax: cont <contname> -- do 'cshow' for a list of continents.\n\r",ch);
        return FALSE;
    }

    free_string (pArea->cont);
    if (cont_lookup(argument) != 0)
    {
        pArea->cont = str_dup(conts_table[cont_lookup(argument)].name);
        send_to_char("Continent set.\n\r",ch);
        return TRUE;
    }
    else
    {
        send_to_char ("Invalid Continent. Use 'cshow' to view current continents.\n\r",ch);
        return FALSE;
    }
    return TRUE;
}

AEDIT (aedit_credits)
{
    AREA_DATA *pArea;

    EDIT_AREA (ch, pArea);

    if (argument[0] == '\0')
    {
        send_to_char ("Syntax:   credits [$credits]\n\r", ch);
        return FALSE;
    }

    free_string (pArea->credits);
    pArea->credits = str_dup (argument);

    send_to_char ("Credits set.\n\r", ch);
    return TRUE;
}


AEDIT (aedit_file)
{
    AREA_DATA *pArea;
    char file[MAX_STRING_LENGTH];
    int i, length;

    EDIT_AREA (ch, pArea);

    one_argument (argument, file);    /* Forces Lowercase */

    if (argument[0] == '\0')
    {
        send_to_char ("Syntax:  filename [$file]\n\r", ch);
        return FALSE;
    }

    /*
     * Simple Syntax Check.
     */
    length = strlen (argument);
    if (length > 8)
    {
        send_to_char ("No more than eight characters allowed.\n\r", ch);
        return FALSE;
    }

    /*
     * Allow only letters and numbers.
     */
    for (i = 0; i < length; i++)
    {
        if (!isalnum (file[i]))
        {
            send_to_char ("Only letters and numbers are valid.\n\r", ch);
            return FALSE;
        }
    }

    free_string (pArea->file_name);
    strcat (file, ".are");
    pArea->file_name = str_dup (file);

    send_to_char ("Filename set.\n\r", ch);
    return TRUE;
}



AEDIT (aedit_age)
{
    AREA_DATA *pArea;
    char age[MAX_STRING_LENGTH];

    EDIT_AREA (ch, pArea);

    one_argument (argument, age);

    if (!is_number (age) || age[0] == '\0')
    {
        send_to_char ("Syntax:  age [#xage]\n\r", ch);
        return FALSE;
    }

    pArea->age = atoi (age);

    send_to_char ("Age set.\n\r", ch);
    return TRUE;
}


#if 0                            /* ROM OLC */
AEDIT (aedit_recall)
{
    AREA_DATA *pArea;
    char room[MAX_STRING_LENGTH];
    int value;

    EDIT_AREA (ch, pArea);

    one_argument (argument, room);

    if (!is_number (argument) || argument[0] == '\0')
    {
        send_to_char ("Syntax:  recall [#xrvnum]\n\r", ch);
        return FALSE;
    }

    value = atoi (room);

    if (!get_room_index (value))
    {
        send_to_char ("AEdit:  Room vnum does not exist.\n\r", ch);
        return FALSE;
    }

    pArea->recall = value;

    send_to_char ("Recall set.\n\r", ch);
    return TRUE;
}
#endif /* ROM OLC */


AEDIT (aedit_security)
{
    AREA_DATA *pArea;
    char sec[MAX_STRING_LENGTH];
    char buf[MAX_STRING_LENGTH];
    int value;

    EDIT_AREA (ch, pArea);

    one_argument (argument, sec);

    if (!is_number (sec) || sec[0] == '\0')
    {
        send_to_char ("Syntax:  security [#xlevel]\n\r", ch);
        return FALSE;
    }

    value = atoi (sec);

    if (value > ch->pcdata->security || value < 0)
    {
        if (ch->pcdata->security != 0)
        {
            sprintf (buf, "Security is 0-%d.\n\r", ch->pcdata->security);
            send_to_char (buf, ch);
        }
        else
            send_to_char ("Security is 0 only.\n\r", ch);
        return FALSE;
    }

    pArea->security = value;

    send_to_char ("Security set.\n\r", ch);
    return TRUE;
}



AEDIT (aedit_builder)
{
    AREA_DATA *pArea;
    char name[MAX_STRING_LENGTH];
    char buf[MAX_STRING_LENGTH];

    EDIT_AREA (ch, pArea);

    one_argument (argument, name);

    if (name[0] == '\0')
    {
        send_to_char ("Syntax:  builder [$name]  -toggles builder\n\r", ch);
        send_to_char ("Syntax:  builder All      -allows everyone\n\r", ch);
        return FALSE;
    }

    name[0] = UPPER (name[0]);

    if (strstr (pArea->builders, name) != '\0')
    {
        pArea->builders = string_replace (pArea->builders, name, "\0");
        pArea->builders = string_unpad (pArea->builders);

        if (pArea->builders[0] == '\0')
        {
            free_string (pArea->builders);
            pArea->builders = str_dup ("None");
        }
        send_to_char ("Builder removed.\n\r", ch);
        return TRUE;
    }
    else
    {
        buf[0] = '\0';
        if (strstr (pArea->builders, "None") != '\0')
        {
            pArea->builders = string_replace (pArea->builders, "None", "\0");
            pArea->builders = string_unpad (pArea->builders);
        }

        if (pArea->builders[0] != '\0')
        {
            strcat (buf, pArea->builders);
            strcat (buf, " ");
        }
        strcat (buf, name);
        free_string (pArea->builders);
        pArea->builders = string_proper (str_dup (buf));

        send_to_char ("Builder added.\n\r", ch);
        send_to_char (pArea->builders, ch);
        return TRUE;
    }

    return FALSE;
}

/* Tribul - Delete an area..Maybe? */

AEDIT (aedit_delete)
{
    AREA_DATA *pArea;

    EDIT_AREA(ch, pArea);

    if (ch->level < 60)
    {
        send_to_char("You do not have access in deleteing areas.\n\r",ch);
        return FALSE;
    }

    if (pArea->adelete)
    {
        send_to_char("Area's delete status removed.\n\r",ch);
        pArea->adelete = FALSE;
        return TRUE;
    }
    send_to_char("Area's delete status set.\n\r",ch);
    pArea->adelete = TRUE;
    return TRUE;
}

AEDIT (aedit_vnum)
{
    AREA_DATA *pArea;
    char lower[MAX_STRING_LENGTH];
    char upper[MAX_STRING_LENGTH];
    int ilower;
    int iupper;

    EDIT_AREA (ch, pArea);

    argument = one_argument (argument, lower);
    one_argument (argument, upper);

    if (!is_number (lower) || lower[0] == '\0'
        || !is_number (upper) || upper[0] == '\0')
    {
        send_to_char ("Syntax:  vnum [#xlower] [#xupper]\n\r", ch);
        return FALSE;
    }

    if ((ilower = atoi (lower)) > (iupper = atoi (upper)))
    {
        send_to_char ("AEdit:  Upper must be larger then lower.\n\r", ch);
        return FALSE;
    }

    if (!check_range (atoi (lower), atoi (upper)))
    {
        send_to_char ("AEdit:  Range must include only this area.\n\r", ch);
        return FALSE;
    }

    if (get_vnum_area (ilower) && get_vnum_area (ilower) != pArea)
    {
        send_to_char ("AEdit:  Lower vnum already assigned.\n\r", ch);
        return FALSE;
    }

    pArea->min_vnum = ilower;
    send_to_char ("Lower vnum set.\n\r", ch);

    if (get_vnum_area (iupper) && get_vnum_area (iupper) != pArea)
    {
        send_to_char ("AEdit:  Upper vnum already assigned.\n\r", ch);
        return TRUE;            /* The lower value has been set. */
    }

    pArea->max_vnum = iupper;
    send_to_char ("Upper vnum set.\n\r", ch);

    return TRUE;
}



AEDIT (aedit_lvnum)
{
    AREA_DATA *pArea;
    char lower[MAX_STRING_LENGTH];
    int ilower;
    int iupper;

    EDIT_AREA (ch, pArea);

    one_argument (argument, lower);

    if (!is_number (lower) || lower[0] == '\0')
    {
        send_to_char ("Syntax:  min_vnum [#xlower]\n\r", ch);
        return FALSE;
    }

    if ((ilower = atoi (lower)) > (iupper = pArea->max_vnum))
    {
        send_to_char ("AEdit:  Value must be less than the max_vnum.\n\r",
                      ch);
        return FALSE;
    }

    if (!check_range (ilower, iupper))
    {
        send_to_char ("AEdit:  Range must include only this area.\n\r", ch);
        return FALSE;
    }

    if (get_vnum_area (ilower) && get_vnum_area (ilower) != pArea)
    {
        send_to_char ("AEdit:  Lower vnum already assigned.\n\r", ch);
        return FALSE;
    }

    pArea->min_vnum = ilower;
    send_to_char ("Lower vnum set.\n\r", ch);
    return TRUE;
}



AEDIT (aedit_uvnum)
{
    AREA_DATA *pArea;
    char upper[MAX_STRING_LENGTH];
    int ilower;
    int iupper;

    EDIT_AREA (ch, pArea);

    one_argument (argument, upper);

    if (!is_number (upper) || upper[0] == '\0')
    {
        send_to_char ("Syntax:  max_vnum [#xupper]\n\r", ch);
        return FALSE;
    }

    if ((ilower = pArea->min_vnum) > (iupper = atoi (upper)))
    {
        send_to_char ("AEdit:  Upper must be larger then lower.\n\r", ch);
        return FALSE;
    }

    if (!check_range (ilower, iupper))
    {
        send_to_char ("AEdit:  Range must include only this area.\n\r", ch);
        return FALSE;
    }

    if (get_vnum_area (iupper) && get_vnum_area (iupper) != pArea)
    {
        send_to_char ("AEdit:  Upper vnum already assigned.\n\r", ch);
        return FALSE;
    }

    pArea->max_vnum = iupper;
    send_to_char ("Upper vnum set.\n\r", ch);

    return TRUE;
}



/*
 * Room Editor Functions.
 */
// New functions for redit.
REDIT (redit_troute)
{
    ROOM_INDEX_DATA *room;
    EDIT_ROOM(ch,room);

    if (room->travel_route == TRUE)
    {
        send_to_char("This room is no longer part of a travel route.\n\r",ch);
        room->travel_route = FALSE;
        return;
    }
    send_to_char("This room is now part of a travel route.\n\r",ch);
    room->travel_route = TRUE;
    return;
}
REDIT (redit_tstate)
{
    ROOM_INDEX_DATA *room;
    EDIT_ROOM(ch,room);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("REdit: Argument must be numerical.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("REdit: Argument must be above zero.\n\r",ch);
        return;
    }
    room->travel_route = TRUE;
    room->travel_state = atoi(argument);
    send_to_char("Room's travel state set.\n\r",ch);
    return;
}

REDIT (redit_ttype)
{
    ROOM_INDEX_DATA *room;
    EDIT_ROOM(ch, room);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("REdit: Argument must be numerical.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("REdit: Argument must be above zero.\n\r",ch);
        return;
    }
    room->travel_route = TRUE;
    room->travel_type = atoi(argument);
    send_to_char("Room's travel route type is set.\n\r",ch);
    return;
}


REDIT (redit_show)
{
    ROOM_INDEX_DATA *pRoom;
    int vv;
    char buf[MAX_STRING_LENGTH];
    char buf1[2 * MAX_STRING_LENGTH];
    OBJ_DATA *obj;
    CHAR_DATA *rch;
    int door;
    bool fcnt;

    EDIT_ROOM (ch, pRoom);
    vv= pRoom->vnum;

    buf1[0] = '\0';

    sprintf (buf, "Description:\n\r%s\n\r", pRoom->description);
    strcat (buf1, buf);

    sprintf (buf, "\n\r{DNight{x Description:\n\r%s\n\r", pRoom->night_description);
    strcat (buf1,buf);

    sprintf (buf, "Name:       [%s]\n\rArea:       [%5d] %s\n\r",
             pRoom->name, pRoom->area->vnum, pRoom->area->name);
    strcat (buf1, buf);

    sprintf (buf, "Vnum:       [%5d]\n\rSector:     [%s]\n\r",
             pRoom->vnum, flag_string (sector_flags, pRoom->sector_type));
    strcat (buf1, buf);

    sprintf (buf, "Room flags: [%s]\n\r",
             flag_string (room_flags, pRoom->room_flags));
    strcat (buf1, buf);
    sprintf (buf, "Extended room flags: [%s]\n\r",
            flag_string (room_flags_extra, pRoom->room_flags_extra));
    strcat (buf1, buf);
    if (pRoom->heal_rate != 100 || pRoom->mana_rate != 100)
    {
        sprintf (buf, "Health rec: [%d]\n\rMana rec  : [%d]\n\r",
                 pRoom->heal_rate, pRoom->mana_rate);
        strcat (buf1, buf);
    }

    if (pRoom->clan > 0)
    {
        sprintf (buf, "Clan      : [%d] %s\n\r",
                 pRoom->clan, clan_table[pRoom->clan].name);
        strcat (buf1, buf);
    }

    if (!IS_NULLSTR (pRoom->owner))
    {
        sprintf (buf, "Owner     : [%s]\n\r", pRoom->owner);
        strcat (buf1, buf);
    }

    if (pRoom->extra_descr)
    {
        EXTRA_DESCR_DATA *ed;

        strcat (buf1, "Desc Kwds:  [");
        for (ed = pRoom->extra_descr; ed; ed = ed->next)
        {
            strcat (buf1, ed->keyword);
            if (ed->next)
                strcat (buf1, " ");
        }
        strcat (buf1, "]\n\r");
    }

    strcat (buf1, "Characters: [");
    fcnt = FALSE;
    for (rch = pRoom->people; rch; rch = rch->next_in_room)
    {
        one_argument (rch->name, buf);
        strcat (buf1, buf);
        strcat (buf1, " ");
        fcnt = TRUE;
    }

    if (fcnt)
    {
        int end;

        end = strlen (buf1) - 1;
        buf1[end] = ']';
        strcat (buf1, "\n\r");
    }
    else
        strcat (buf1, "none]\n\r");

    strcat (buf1, "Objects:    [");
    fcnt = FALSE;
    for (obj = pRoom->contents; obj; obj = obj->next_content)
    {
        one_argument (obj->name, buf);
        strcat (buf1, buf);
        strcat (buf1, " ");
        fcnt = TRUE;
    }

    if (fcnt)
    {
        int end;

        end = strlen (buf1) - 1;
        buf1[end] = ']';
        strcat (buf1, "\n\r");
    }
    else
        strcat (buf1, "none]\n\r");

    for (door = 0; door < MAX_DIR; door++)
    {
        EXIT_DATA *pexit;

        if ((pexit = pRoom->exit[door]))
        {
            char word[MAX_INPUT_LENGTH];
            char reset_state[MAX_STRING_LENGTH];
            char *state;
            int i, length;

            sprintf (buf, "-%-5s to [%5d] Key: [%5d] ",
                     capitalize (dir_name[door]),
                     pexit->u1.to_room ? pexit->u1.to_room->vnum : 0,    /* ROM OLC */
                     pexit->key);
            strcat (buf1, buf);

            /*
             * Format up the exit info.
             * Capitalize all flags that are not part of the reset info.
             */
            strcpy (reset_state,(char*)flag_string (exit_flags, pexit->rs_flags));
            state =(char*)flag_string (exit_flags, pexit->exit_info);
            strcat (buf1, " Exit flags: [");
            for (;;)
            {
                state = one_argument (state, word);

                if (word[0] == '\0')
                {
                    int end;

                    end = strlen (buf1) - 1;
                    buf1[end] = ']';
                    strcat (buf1, "\n\r");
                    break;
                }

                if (str_infix (word, reset_state))
                {
                    length = strlen (word);
                    for (i = 0; i < length; i++)
                        word[i] = UPPER (word[i]);
                }
                strcat (buf1, word);
                strcat (buf1, " ");
            }

            if (pexit->keyword && pexit->keyword[0] != '\0')
            {
                sprintf (buf, "Kwds: [%s]\n\r", pexit->keyword);
                strcat (buf1, buf);
            }
            if (pexit->description && pexit->description[0] != '\0')
            {
                sprintf (buf, "%s", pexit->description);
                strcat (buf1, buf);
            }
        }
    }
    send_to_char(buf1,ch);
    printf_to_char(ch, "Travel Route:  [%s]\n\r", pRoom->travel_route ? "Yes" : "No");
    if (pRoom->travel_route == TRUE)
    {
        printf_to_char(ch, "Travel Type:   [%d]\n\r", pRoom->travel_type);
        printf_to_char(ch, "Travel State:  [%d]\n\r", pRoom->travel_state);
    }

//    send_to_char (buf1, ch);
    
    printf_to_char(ch,"\n\r\n\r {R%d {cvehicles are pointed here.{x\n\r", vehicle_here(vv));
    return FALSE;
}




/* Local function. */
bool change_exit (CHAR_DATA * ch, char *argument, int door)
{
    ROOM_INDEX_DATA *pRoom;
    char command[MAX_INPUT_LENGTH];
    char arg[MAX_INPUT_LENGTH];
    int value;

    EDIT_ROOM (ch, pRoom);

    /*
     * Set the exit flags, needs full argument.
     * ----------------------------------------
     */
    if ((value = flag_value (exit_flags, argument)) != NO_FLAG)
    {
        ROOM_INDEX_DATA *pToRoom;
        sh_int rev;                /* ROM OLC */

        if (!pRoom->exit[door])
        {
            send_to_char ("Exit doesn't exist.\n\r", ch);
            return FALSE;
        }

        /*
         * This room.
         */
        TOGGLE_BIT (pRoom->exit[door]->rs_flags, value);
        /* Don't toggle exit_info because it can be changed by players. */
        pRoom->exit[door]->exit_info = pRoom->exit[door]->rs_flags;

        /*
         * Connected room.
         */
        pToRoom = pRoom->exit[door]->u1.to_room;    /* ROM OLC */
        rev = rev_dir[door];

        if (pToRoom->exit[rev] != NULL)
        {
            pToRoom->exit[rev]->rs_flags = pRoom->exit[door]->rs_flags;
            pToRoom->exit[rev]->exit_info = pRoom->exit[door]->exit_info;
        }

        send_to_char ("Exit flag toggled.\n\r", ch);
        return TRUE;
    }

    /*
     * Now parse the arguments.
     */
    argument = one_argument (argument, command);
    one_argument (argument, arg);

    if (command[0] == '\0' && argument[0] == '\0')
    {                            /* Move command. */
        move_char (ch, door, TRUE);    /* ROM OLC */
        return FALSE;
    }

    if (command[0] == '?')
    {
        do_help (ch, "EXIT");
        return FALSE;
    }

    if (!str_cmp (command, "delete"))
    {
        ROOM_INDEX_DATA *pToRoom;
        sh_int rev;                /* ROM OLC */

        if (!pRoom->exit[door])
        {
            send_to_char ("REdit:  Cannot delete a null exit.\n\r", ch);
            return FALSE;
        }

        /*
         * Remove ToRoom Exit.
         */
        rev = rev_dir[door];
        pToRoom = pRoom->exit[door]->u1.to_room;    /* ROM OLC */

        if (pToRoom->exit[rev])
        {
            free_exit (pToRoom->