db.c

Go to the documentation of this file.

/***************************************************************************
 *  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
 *  Michael Seifert, Hans Henrik Strfeldt, 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.                                                  *
 **************************************************************************/

/***************************************************************************
 *   ROM 2.4 is copyright 1993-1998 Russ Taylor                            *
 *   ROM has been brought to you by the ROM consortium                     *
 *       Russ Taylor (rtaylor@hypercube.org)                               *
 *       Gabrielle Taylor (gtaylor@hypercube.org)                          *
 *       Brian Moore (zump@rom.org)                                        *
 *   By using this code, you have agreed to follow the terms of the        *
 *   ROM license, in the file Rom24/doc/rom.license                        *
 **************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#endif

#include "merc.h"
#include "db.h"
#include "recycle.h"
#include "music.h"
#include "tables.h"
#include "lookup.h"
#include "olc.h"

#if !defined(macintosh)
extern int _filbuf args ((FILE *));
#endif

#if !defined(OLD_RAND)
#if !defined(linux)
#if !defined(QMFIXES)
long random ();
#endif
#endif
#if !defined(QMFIXES)
void srandom (unsigned int);
#endif
int getpid ();
time_t time (time_t * tloc);
#endif


/* externals for counting purposes */
extern OBJ_DATA *obj_free;
extern CHAR_DATA *char_free;
extern DESCRIPTOR_DATA *descriptor_free;
extern PC_DATA *pcdata_free;
extern AFFECT_DATA *affect_free;

/*
 * Globals.
 */
HELP_DATA *help_first;
HELP_DATA *help_last;

HELP_AREA *had_list;

SHOP_DATA *shop_first;
SHOP_DATA *shop_last;

NOTE_DATA *note_free;
NOTE_DATA *note_list;

MPROG_CODE *mprog_list;
//CRS          crs_info;
char bug_buf[2 * MAX_INPUT_LENGTH];
CHAR_DATA *char_list;
char *help_greeting;
char log_buf[2 * MAX_INPUT_LENGTH];
KILL_DATA kill_table[MAX_LEVEL];
OBJ_DATA *object_list;
TIME_INFO_DATA time_info;
WEATHER_DATA weather_info;
unsigned long int r_count=0; // Rooms
unsigned long int m_count=0; // Mobs
unsigned long int o_count=0; // Objects
unsigned long int reset_count=0; // Resets
unsigned long int s_count=0; // Shops
unsigned long int h_count=0; // helps
unsigned long int so_count=0;
unsigned long int skill_count=0;
unsigned long int v_count=0;
sh_int gsn_backstab;
sh_int gsn_dodge;
sh_int gsn_envenom;
sh_int gsn_hide;
sh_int gsn_peek;
sh_int gsn_pick_lock;
sh_int gsn_sneak;
sh_int gsn_steal;

sh_int gsn_disarm;
sh_int gsn_enhanced_damage;
sh_int gsn_kick;
sh_int gsn_dragonbash;
sh_int gsn_parry;
sh_int gsn_rescue;
sh_int gsn_second_attack;
sh_int gsn_third_attack;

sh_int gsn_blindness;
sh_int gsn_charm_person;
sh_int gsn_curse;
sh_int gsn_invis;
sh_int gsn_mass_invis;
sh_int gsn_poison;
sh_int gsn_plague;
sh_int gsn_sleep;
sh_int gsn_sanctuary;
sh_int gsn_fly;
/* new gsns */

sh_int gsn_axe;
sh_int gsn_dagger;
sh_int gsn_flail;
sh_int gsn_mace;
sh_int gsn_polearm;
sh_int gsn_shield_block;
sh_int gsn_spear;
sh_int gsn_sword;
sh_int gsn_whip;

sh_int gsn_bash;
sh_int gsn_berserk;
sh_int gsn_dirt;
sh_int gsn_hand_to_hand;
sh_int gsn_trip;

sh_int gsn_fast_healing;
sh_int gsn_haggle;
sh_int gsn_lore;
sh_int gsn_meditation;

sh_int gsn_scrolls;
sh_int gsn_staves;
sh_int gsn_wands;
sh_int gsn_recall;
sh_int gsn_tailor;
sh_int gsn_blacksmith;
sh_int gsn_fourth_attack;
sh_int gsn_fifth_attack;
sh_int gsn_dual_wield;
sh_int gsn_riding;
sh_int gsn_advanced_riding;
sh_int gsn_side_kick;
sh_int gsn_mudcoat;

/*
 * Locals.
 */
MOB_INDEX_DATA *mob_index_hash[MAX_KEY_HASH];
OBJ_INDEX_DATA *obj_index_hash[MAX_KEY_HASH];
ROOM_INDEX_DATA *room_index_hash[MAX_KEY_HASH];
char *string_hash[MAX_KEY_HASH];

AREA_DATA *area_first;
AREA_DATA *area_last;
AREA_DATA *current_area;

char *string_space;
char *top_string;
char str_empty[1];

int top_affect;
int top_area;
int top_ed;
int top_exit;
int top_help;
int top_mob_index;
int top_obj_index;
int top_reset;
int top_room;
int top_shop;
int top_vnum_room;                /* OLC */
int top_vnum_mob;                /* OLC */
int top_vnum_obj;                /* OLC */
int top_mprog_index;            /* OLC */
int mobile_count = 0;
int newmobs = 0;
int newobjs = 0;


/*
 * Memory management.
 * Increase MAX_STRING if you have too.
 * Tune the others only if you understand what you're doing.
 */
//#define            MAX_STRING    22826240
//:#define            MAX_PERM_BLOCK    131072
#define            MAX_MEM_LIST    11

//void *rgFreeList[MAX_MEM_LIST];
//const int rgSizeList[MAX_MEM_LIST] = {
//    16, 32, 64, 128, 256, 1024, 2048, 4096, 8192, 16384, 32768 - 64
//};

int nAllocString;
int sAllocString;
//int nAllocPerm;
//int sAllocPerm;



/*
 * Semi-locals.
 */
bool fBootDb;
FILE *fpArea;
char strArea[MAX_INPUT_LENGTH];



/*
 * Local booting procedures.
*/
void init_mm args ((void));
void load_area args ((FILE * fp));
void new_load_area args ((FILE * fp));    /* OLC */
void load_helps args ((FILE * fp, char *fname));
void load_old_mob args ((FILE * fp));
void load_mobiles args ((FILE * fp));
void load_old_obj args ((FILE * fp));
void load_objects args ((FILE * fp));
void load_resets args ((FILE * fp));
void load_rooms args ((FILE * fp));
void load_shops args ((FILE * fp));
void load_socials args ((FILE * fp));
void load_specials args ((FILE * fp));
void load_bans args ((void));
void load_mobprogs args ((FILE * fp));
void    load_notes  args( ( void ) );
void fix_exits args ((void));
void fix_mobprogs args ((void));

void reset_area args ((AREA_DATA * pArea));

/*
 * Big mama top level function.
 */
void boot_db ()
{

    /*
     * Init some data space stuff.
     */
    {
     //   if ((string_space = calloc (1, MAX_STRING)) == NULL)
       // {
         //   bug ("Boot_db: can't alloc %d string space.", MAX_STRING);
       //     exit (1);
       // }
       strspace_alloc();
        top_string = string_space;
        fBootDb = TRUE;
    }

    /*
     * Init random number generator.
     */
    {
        init_mm ();
    }

    /*
     * Set time and weather.
     */
    {
        long lhour, lday, lmonth;
    send_to_all_copyover("Loading weather ");
        lhour = (current_time - 650336715) / (PULSE_TICK / PULSE_PER_SECOND);
        time_info.hour = lhour % 24;
        lday = lhour / 24;
        time_info.day = lday % 35;
        lmonth = lday / 35;
        time_info.month = lmonth % 17;
        time_info.year = lmonth / 17;

        if (time_info.hour < 5)
            weather_info.sunlight = SUN_DARK;
        else if (time_info.hour < 6)
            weather_info.sunlight = SUN_RISE;
        else if (time_info.hour < 19)
            weather_info.sunlight = SUN_LIGHT;
        else if (time_info.hour < 20)
            weather_info.sunlight = SUN_SET;
        else
            weather_info.sunlight = SUN_DARK;

        weather_info.change = 0;
        weather_info.mmhg = 960;
        if (time_info.month >= 7 && time_info.month <= 12)
            weather_info.mmhg += number_range (1, 50);
        else
            weather_info.mmhg += number_range (1, 80);

        if (weather_info.mmhg <= 980)
            weather_info.sky = SKY_LIGHTNING;
        else if (weather_info.mmhg <= 1000)
            weather_info.sky = SKY_RAINING;
        else if (weather_info.mmhg <= 1020)
            weather_info.sky = SKY_CLOUDY;
        else
            weather_info.sky = SKY_CLOUDLESS;

    }
    send_to_all_copyover(" Done.\n\r");

{
   //crs_info.status = 0;
   //crs_info.who = &str_empty[0];
   //crs_info.reason = &str_empty[0];
   //crs_info.timer = -1;
 }   
/*
     * Assign gsn's for skills which have them.
     */
    {
        int sn;

        for (sn = 0; sn < MAX_SKILL; sn++)
        {
            if (skill_table[sn].pgsn != NULL)
                *skill_table[sn].pgsn = sn;
        }
    }
    send_to_all_copyover("Loading classes  "); 
    load_classes();
    
    send_to_all_copyover("Loading BTS's Game Settings  ");
    load_game_conf();
    send_to_all_copyover("\bDone.\n\r");
    send_to_all_copyover("Loading Kingdom Data  ");
    load_kingdom_data();
    send_to_all_copyover("\bDone.\n\r");
    send_to_all_copyover("Loading Clan Data  ");
    load_clan_data();
    send_to_all_copyover("\bDone.\n\r");
    /*
     * Read in all the area files.
     */
    {
        FILE *fpList;
    send_to_all_copyover( "Loading area files  "); twiddle();
        if ((fpList = fopen (AREA_LIST, "r")) == NULL)
        {
            perror (AREA_LIST);
            exit (1);
        }

        for (;;)
        {
            
        
        strcpy (strArea, fread_word (fpList));
            if (strArea[0] == '$')
                break;

            if (strArea[0] == '-')
            {
                fpArea = stdin;
            }
            else
            {
                if ((fpArea = fopen (strArea, "r")) == NULL)
                {
                    perror (strArea);
                    exit (1);
                }
            }

            current_area = NULL;

            for (;;)
            {
                char *word;

                if (fread_letter (fpArea) != '#')
                {
                    bug ("Boot_db: # not found.", 0);
                    exit (1);
                }

                word = fread_word (fpArea);

                if (word[0] == '$')
                    break;
                else if (!str_cmp (word, "AREA")) {
                    load_area (fpArea);
                }
                /* OLC */
                else if (!str_cmp (word, "AREADATA"))
                    new_load_area (fpArea);
                else if (!str_cmp (word, "HELPS"))
                    load_helps (fpArea, strArea);
                else if (!str_cmp (word, "MOBOLD"))
                    load_old_mob (fpArea);
                else if (!str_cmp (word, "MOBILES"))
                    load_mobiles (fpArea);
                else if (!str_cmp (word, "MOBPROGS"))
                    load_mobprogs (fpArea);
                else if (!str_cmp (word, "OBJOLD"))
                    load_old_obj (fpArea);
                else if (!str_cmp (word, "OBJECTS"))
                    load_objects (fpArea);
                else if (!str_cmp (word, "RESETS"))
                    load_resets (fpArea);
                else if (!str_cmp (word, "ROOMS"))
                    load_rooms (fpArea);
                else if (!str_cmp (word, "SHOPS"))
                    load_shops (fpArea);
                else if (!str_cmp (word, "SOCIALS"))
                    load_socials (fpArea);
                else if (!str_cmp (word, "SPECIALS"))
                    load_specials (fpArea);
                else
                {
                    bug ("Boot_db: bad section name.", 0);
                    exit (1);
                }
            }

            if (fpArea != stdin)
                fclose (fpArea);
            fpArea = NULL;
        }
        fclose (fpList);
    send_to_all_copyover("\bDone.\n\r");
    }

    /*
     * Fix up exits.
     * Declare db booting over.
     * Reset all areas once.
     * Load up the songs, notes and ban files.
     */
    {
        send_to_all_copyover("Fixing exits  ");
    fix_exits ();
        fix_mobprogs ();
        fBootDb = FALSE;
        convert_objects ();        /* ROM OLC */
        send_to_all_copyover("\bDone.\n\rUpdating areas  ");
    area_update ();
    //  load_boards();
    //  save_notes();
        send_to_all_copyover("\bDone.\n\rLoading vehicles  ");
    load_vehicles();
    send_to_all_copyover("Loading banned sites  ");
    load_bans ();
        load_songs ();
    send_to_all_copyover("\bDone.\n\r");
    send_to_all_copyover("Loading notes  ");
    load_notes();
    send_to_all_copyover("\bDone.\n\r");
    send_to_all_copyover("Loading disabled commands  ");
    load_disabled();
    load_enhanced_disable();
    
    send_to_all_copyover("\bDone.\n\r");


    }
    
return;
}



/*
 * Snarf an 'area' header line.
 */
void load_area (FILE * fp)
{
    AREA_DATA *pArea;
    send_to_all_copyover("Loading areas into BTS "); 
    pArea = alloc_perm (sizeof (*pArea));
    pArea->file_name = fread_string (fp);

    /* Pretty up the log a little */
    logf("Loading area %s", pArea->file_name);

    pArea->area_flags = AREA_LOADING;    /* OLC */
    pArea->security = 9;        /* OLC *//* 9 -- Hugin */
    pArea->builders = str_dup ("None");    /* OLC */
    pArea->vnum = top_area;        /* OLC */

    pArea->name = fread_string (fp);
    pArea->credits = fread_string (fp);
    pArea->min_vnum = fread_number (fp);
    pArea->max_vnum = fread_number (fp);
    pArea->age = 15;
    pArea->nplayer = 0;
    pArea->r_used =0;
    pArea->empty = FALSE;

    if (!area_first)
        area_first = pArea;
    if (area_last)
    {
        area_last->next = pArea;
        REMOVE_BIT (area_last->area_flags, AREA_LOADING);    /* OLC */
    }
    area_last = pArea;
    pArea->next = NULL;
    current_area = pArea;

    top_area++;
    send_to_all_copyover("Done.\n\r");
    return;
}

/*
 * OLC
 * Use these macros to load any new area formats that you choose to
 * support on your MUD.  See the new_load_area format below for
 * a short example.
 */
#if defined(KEY)
#undef KEY
#endif

#define KEY( literal, field, value )                \
                if ( !str_cmp( word, literal ) )    \
                {                                   \
                    field  = value;                 \
                    fMatch = TRUE;                  \
                    break;                          \
                                }

#define SKEY( string, field )                       \
                if ( !str_cmp( word, string ) )     \
                {                                   \
                    free_string( field );           \
                    field = fread_string( fp );     \
                    fMatch = TRUE;                  \
                    break;                          \
                                }



/* OLC
 * Snarf an 'area' header line.   Check this format.  MUCH better.  Add fields
 * too.
 *
 * #AREAFILE
 * Name   { All } Locke    Newbie School~
 * Repop  A teacher pops in the room and says, 'Repop coming!'~
 * Recall 3001
 * End
 */
void new_load_area (FILE * fp)
{
    AREA_DATA *pArea;
    char *word;
    bool fMatch;
//   send_to_all_copyover("Loading new areas ");
    pArea = alloc_perm (sizeof (*pArea));
    pArea->age = 15;
    pArea->nplayer = 0;
    pArea->file_name = str_dup (strArea);
    pArea->vnum = top_area;
    pArea->name = str_dup ("New Area");
    pArea->builders = str_dup ("");
    pArea->security = 9;        /* 9 -- Hugin */
    pArea->min_vnum = 0;
    pArea->max_vnum = 0;
    pArea->area_flags = 0;
/*  pArea->recall       = ROOM_VNUM_TEMPLE;        ROM OLC */

    for (;;)
    {
    
        word = feof (fp) ? "End" : fread_word (fp);
        fMatch = FALSE;

        switch (UPPER (word[0]))
        {
            case 'N':
                SKEY ("Name", pArea->name);
                break;
            case 'S':
                KEY ("Security", pArea->security, fread_number (fp));
                break;
            case 'V':
                if (!str_cmp (word, "VNUMs"))
                {
                    pArea->min_vnum = fread_number (fp);
                    pArea->max_vnum = fread_number (fp);
                }
                break;
            case 'E':
                if (!str_cmp (word, "End"))
                {
                    fMatch = TRUE;
                    if (area_first == NULL)
                        area_first = pArea;
                    if (area_last != NULL)
                        area_last->next = pArea;
                    area_last = pArea;
                    pArea->next = NULL;
                    current_area = pArea;
                    top_area++;

                    return;
                }
                break;
            case 'B':
                SKEY ("Builders", pArea->builders);
                break;
            case 'C':
                SKEY ("Credits", pArea->credits);
        SKEY ("Cont", pArea->cont);
                break;
        }
    }
//send_to_all_copyover("Done.\n\r");
}

/*
 * Sets vnum range for area using OLC protection features.
 */
void assign_area_vnum (int vnum)
{
    if (area_last->min_vnum == 0 || area_last->max_vnum == 0)
        area_last->min_vnum = area_last->max_vnum = vnum;
    if (vnum != URANGE (area_last->min_vnum, vnum, area_last->max_vnum))
    {
        if (vnum < area_last->min_vnum)
            area_last->min_vnum = vnum;
        else
            area_last->max_vnum = vnum;
    }
    return;
}

/*
 * Snarf a help section.
 */
void load_helps (FILE * fp, char *fname)
{
    HELP_DATA *pHelp;
    int level;
    char *keyword;
    //send_to_all_copyover("Loading help files ");
    for (;;)
    {
        HELP_AREA *had;

        level = fread_number (fp);
        keyword = fread_string (fp);

        if (keyword[0] == '$')
            break;

        if (!had_list)
        {
            had = new_had ();
            had->filename = str_dup (fname);
            had->area = current_area;
            if (current_area)
                current_area->helps = had;
            had_list = had;
        }
        else if (str_cmp (fname, had_list->filename))
        {
            had = new_had ();
            had->filename = str_dup (fname);
            had->area = current_area;
            if (current_area)
                current_area->helps = had;
            had->next = had_list;
            had_list = had;
        }
        else
            had = had_list;

        pHelp = new_help ();
        pHelp->level = level;
        pHelp->keyword = keyword;
        pHelp->text = fread_string (fp);

        if (!str_cmp (pHelp->keyword, "greeting"))
            help_greeting = pHelp->text;

        if (help_first == NULL)
            help_first = pHelp;
        if (help_last != NULL)
            help_last->next = pHelp;

        help_last = pHelp;
        pHelp->next = NULL;

        if (!had->first)
            had->first = pHelp;
        if (!had->last)
            had->last = pHelp;

        //had->last->next_area = pHelp;
        had->last = pHelp;
    h_count+=1;
        //pHelp->next_area = NULL;

        top_help++;
    }
//send_to_all_copyover ("Done.\n\r");
    return;
}



/*
 * Snarf a mob section.  old style 
 */
void load_old_mob (FILE * fp)
{
    MOB_INDEX_DATA *pMobIndex;
    /* for race updating */
    int race;
    char name[MAX_STRING_LENGTH];

    if (!area_last)
    {                            /* OLC */
        bug ("Load_mobiles: no #AREA seen yet.", 0);
        exit (1);
    }

    for (;;)
    {
        int vnum;
        char letter;
        int iHash;

        letter = fread_letter (fp);
        if (letter != '#')
        {
            bug ("Load_mobiles: # not found.", 0);
            exit (1);
        }

        vnum = fread_number (fp);
        if (vnum == 0)
            break;

        fBootDb = FALSE;
        if (get_mob_index (vnum) != NULL)
        {
            bug ("Load_mobiles: vnum %d duplicated.", vnum);
            exit (1);
        }
        fBootDb = TRUE;

        pMobIndex = alloc_perm (sizeof (*pMobIndex));
        pMobIndex->vnum = vnum;
        pMobIndex->area = area_last;    /* OLC */
        pMobIndex->new_format = FALSE;
        pMobIndex->player_name = fread_string (fp);
        pMobIndex->short_descr = fread_string (fp);
        pMobIndex->long_descr = fread_string (fp);
        pMobIndex->description = fread_string (fp);

        pMobIndex->long_descr[0] = UPPER (pMobIndex->long_descr[0]);
        pMobIndex->description[0] = UPPER (pMobIndex->description[0]);

        pMobIndex->act = fread_flag (fp) | ACT_IS_NPC;
        pMobIndex->affected_by = fread_flag (fp);
        pMobIndex->pShop = NULL;
        pMobIndex->alignment = fread_number (fp);
        letter = fread_letter (fp);
        pMobIndex->level = fread_number (fp);

        /*
         * The unused stuff is for imps who want to use the old-style
         * stats-in-files method.
         */
        fread_number (fp);        /* Unused */
        fread_number (fp);        /* Unused */
        fread_number (fp);        /* Unused */
        /* 'd'      */ fread_letter (fp);
        /* Unused */
        fread_number (fp);        /* Unused */
        /* '+'      */ fread_letter (fp);
        /* Unused */
        fread_number (fp);        /* Unused */
        fread_number (fp);        /* Unused */
        /* 'd'      */ fread_letter (fp);
        /* Unused */
        fread_number (fp);        /* Unused */
        /* '+'      */ fread_letter (fp);
        /* Unused */
        fread_number (fp);        /* Unused */
        pMobIndex->wealth = fread_number (fp) / 20;
        /* xp can't be used! */ fread_number (fp);
        /* Unused */
        pMobIndex->start_pos = fread_number (fp);    /* Unused */
        pMobIndex->default_pos = fread_number (fp);    /* Unused */

        if (pMobIndex->start_pos < POS_SLEEPING)
            pMobIndex->start_pos = POS_STANDING;
        if (pMobIndex->default_pos < POS_SLEEPING)
            pMobIndex->default_pos = POS_STANDING;

        /*
         * Back to meaningful values.
         */
        pMobIndex->sex = fread_number (fp);

        /* compute the race BS */
        one_argument (pMobIndex->player_name, name);

        if (name[0] == '\0' || (race = race_lookup (name)) == 0)
        {
            /* fill in with blanks */
            pMobIndex->race = race_lookup ("human");
            pMobIndex->off_flags =
                OFF_DODGE | OFF_DISARM | OFF_TRIP | ASSIST_VNUM;
            pMobIndex->imm_flags = 0;
            pMobIndex->res_flags = 0;
            pMobIndex->vuln_flags = 0;
            pMobIndex->form =
                FORM_EDIBLE | FORM_SENTIENT | FORM_BIPED | FORM_MAMMAL;
            pMobIndex->parts =
                PART_HEAD | PART_ARMS | PART_LEGS | PART_HEART | PART_BRAINS |
                PART_GUTS;
        }
        else
        {
            pMobIndex->race = race;
            pMobIndex->off_flags =
                OFF_DODGE | OFF_DISARM | OFF_TRIP | ASSIST_RACE |
                race_table[race].off;
            pMobIndex->imm_flags = race_table[race].imm;
            pMobIndex->res_flags = race_table[race].res;
            pMobIndex->vuln_flags = race_table[race].vuln;
            pMobIndex->form = race_table[race].form;
            pMobIndex->parts = race_table[race].parts;
        }

        if (letter != 'S')
        {
            bug ("Load_mobiles: vnum %d non-S.", vnum);
            exit (1);
        }

        convert_mobile (pMobIndex);    /* ROM OLC */

        iHash = vnum % MAX_KEY_HASH;
        pMobIndex->next = mob_index_hash[iHash];
        mob_index_hash[iHash] = pMobIndex;
        top_mob_index++;
        top_vnum_mob = top_vnum_mob < vnum ? vnum : top_vnum_mob;    /* OLC */
        assign_area_vnum (vnum);    /* OLC */
        kill_table[URANGE (0, pMobIndex->level, MAX_LEVEL - 1)].number++;
    m_count+=1;
    }

    return;
}

/*
 * Snarf an obj section.  old style 
 */
void load_old_obj (FILE * fp)
{
    OBJ_INDEX_DATA *pObjIndex;

    if (!area_last)
    {                            /* OLC */
        bug ("Load_objects: no #AREA seen yet.", 0);
        exit (1);
    }

    for (;;)
    {
        int vnum;
        char letter;
        int iHash;

        letter = fread_letter (fp);
        if (letter != '#')
        {
            bug ("Load_objects: # not found.", 0);
            exit (1);
        }

        vnum = fread_number (fp);
        if (vnum == 0)
            break;

        fBootDb = FALSE;
        if (get_obj_index (vnum) != NULL)
        {
            bug ("Load_objects: vnum %d duplicated.", vnum);
            exit (1);
        }
        fBootDb = TRUE;

        pObjIndex = alloc_perm (sizeof (*pObjIndex));
        pObjIndex->vnum = vnum;
        pObjIndex->area = area_last;    /* OLC */
        pObjIndex->new_format = FALSE;
        pObjIndex->reset_num = 0;
        pObjIndex->name = fread_string (fp);
        pObjIndex->short_descr = fread_string (fp);
        pObjIndex->description = fread_string (fp);
        /* Action description */ fread_string (fp);

        pObjIndex->short_descr[0] = LOWER (pObjIndex->short_descr[0]);
        pObjIndex->description[0] = UPPER (pObjIndex->description[0]);
        pObjIndex->material = str_dup ("");

        pObjIndex->item_type = fread_number (fp);
        pObjIndex->extra_flags = fread_flag (fp);
        pObjIndex->wear_flags = fread_flag (fp);
        pObjIndex->value[0] = fread_number (fp);
        pObjIndex->value[1] = fread_number (fp);
        pObjIndex->value[2] = fread_number (fp);
        pObjIndex->value[3] = fread_number (fp);
        pObjIndex->value[4] = 0;
        pObjIndex->level = 0;
        pObjIndex->condition = 100;
        pObjIndex->weight = fread_number (fp);
        pObjIndex->cost = fread_number (fp);    /* Unused */
        /* Cost per day */ fread_number (fp);


        if (pObjIndex->item_type == ITEM_WEAPON)
        {
            if (is_name ("two", pObjIndex->name)
                || is_name ("two-handed", pObjIndex->name)
                || is_name ("claymore", pObjIndex->name))
                SET_BIT (pObjIndex->value[4], WEAPON_TWO_HANDS);
        }

        for (;;)
        {
            char letter;

            letter = fread_letter (fp);

            if (letter == 'A')
            {
                AFFECT_DATA *paf;

                paf = alloc_perm (sizeof (*paf));
                paf->where = TO_OBJECT;
                paf->type = -1;
                paf->level = 20;    /* RT temp fix */
                paf->duration = -1;
                paf->location = fread_number (fp);
                paf->modifier = fread_number (fp);
                paf->bitvector = 0;
                paf->next = pObjIndex->affected;
                pObjIndex->affected = paf;
                top_affect++;
            }

            else if (letter == 'E')
            {
                EXTRA_DESCR_DATA *ed;

                ed = alloc_perm (sizeof (*ed));
                ed->keyword = fread_string (fp);
                ed->description = fread_string (fp);
                ed->next = pObjIndex->extra_descr;
                pObjIndex->extra_descr = ed;
                top_ed++;
            }

            else
            {
                ungetc (letter, fp);
                break;
            }
        }

        /* fix armors */
        if (pObjIndex->item_type == ITEM_ARMOR)
        {
            pObjIndex->value[1] = pObjIndex->value[0];
            pObjIndex->value[2] = pObjIndex->value[1];
        }

        /*
         * Translate spell "slot numbers" to internal "skill numbers."
         */
        switch (pObjIndex->item_type)
        {
            case ITEM_PILL:
            case ITEM_POTION:
            case ITEM_SCROLL:
                pObjIndex->value[1] = slot_lookup (pObjIndex->value[1]);
                pObjIndex->value[2] = slot_lookup (pObjIndex->value[2]);
                pObjIndex->value[3] = slot_lookup (pObjIndex->value[3]);
                pObjIndex->value[4] = slot_lookup (pObjIndex->value[4]);
                break;

            case ITEM_STAFF:
            case ITEM_WAND:
                pObjIndex->value[3] = slot_lookup (pObjIndex->value[3]);
                break;
        }

        iHash = vnum % MAX_KEY_HASH;
        pObjIndex->next = obj_index_hash[iHash];
        obj_index_hash[iHash] = pObjIndex;
        top_obj_index++;
        top_vnum_obj = top_vnum_obj < vnum ? vnum : top_vnum_obj;    /* OLC */
        assign_area_vnum (vnum);    /* OLC */
    o_count+=1;
    }

    return;
}

/*
 * Adds a reset to a room.  OLC
 * Similar to add_reset in olc.c
 */
void new_reset (ROOM_INDEX_DATA * pR, RESET_DATA * pReset)
{
    RESET_DATA *pr;

    if (!pR)
        return;

    pr = pR->reset_last;

    if (!pr)
    {
        pR->reset_first = pReset;
        pR->reset_last = pReset;
    }
    else
    {
        pR->reset_last->next = pReset;
        pR->reset_last = pReset;
        pR->reset_last->next = NULL;
    }

/*    top_reset++; no estamos asignando memoria!!!! */

    return;
}

/*
 * Snarf a reset section.
 */
void load_resets (FILE * fp)
{
    RESET_DATA *pReset;
    EXIT_DATA *pexit;
    ROOM_INDEX_DATA *pRoomIndex;
    int rVnum = -1;
//send_to_all_copyover("Loading resets ");
    if (!area_last)
    {
        bug ("Load_resets: no #AREA seen yet.", 0);
        exit (1);
    }

    for (;;)
    {
        char letter;

        if ((letter = fread_letter (fp)) == 'S')
            break;

        if (letter == '*')
        {
            fread_to_eol (fp);
            continue;
        }

        pReset = new_reset_data ();
    reset_count+=1;
        pReset->command = letter;
        /* if_flag */ fread_number (fp);
        pReset->arg1 = fread_number (fp);
        pReset->arg2 = fread_number (fp);
        pReset->arg3 = (letter == 'G' || letter == 'R')
            ? 0 : fread_number (fp);
        pReset->arg4 = (letter == 'P' || letter == 'M')
            ? fread_number (fp) : 0;
        fread_to_eol (fp);

        switch (pReset->command)
        {
            case 'M':
            case 'O':
                rVnum = pReset->arg3;
                break;

            case 'P':
            case 'G':
            case 'E':
                break;

            case 'D':
                pRoomIndex = get_room_index ((rVnum = pReset->arg1));
                if (pReset->arg2 < 0
                    || pReset->arg2 >= MAX_DIR
                    || !pRoomIndex
                    || !(pexit = pRoomIndex->exit[pReset->arg2])
                    || !IS_SET (pexit->rs_flags, EX_ISDOOR))
                {
                    bugf ("Load_resets: 'D': exit %d, room %d not door.",
                          pReset->arg2, pReset->arg1);
                    exit (1);
                }

                switch (pReset->arg3)
                {
                    default:
                        bug ("Load_resets: 'D': bad 'locks': %d.",
                             pReset->arg3);
                        break;
                    case 0:
                        break;
                    case 1:
                        SET_BIT (pexit->rs_flags, EX_CLOSED);
                        SET_BIT (pexit->exit_info, EX_CLOSED);
                        break;
                    case 2:
                        SET_BIT (pexit->rs_flags, EX_CLOSED | EX_LOCKED);
                        SET_BIT (pexit->exit_info, EX_CLOSED | EX_LOCKED);
                        break;
                }
                break;

            case 'R':
                rVnum = pReset->arg1;
                break;
        }

        if (rVnum == -1)
        {
            bugf ("load_resets : rVnum == -1");
            exit (1);
        }

        if (pReset->command != 'D')
            new_reset (get_room_index (rVnum), pReset);
        else
            free_reset_data (pReset);
    }
//  send_to_all_copyover("Done.\n\r");
    return;
}

/*
 * Snarf a room section.
 */
void load_rooms (FILE * fp)
{
    ROOM_INDEX_DATA *pRoomIndex;
//send_to_all_copyover("Loading rooms ");
    if (area_last == NULL)
    {
        bug ("Load_resets: no #AREA seen yet.", 0);
        exit (1);
    }

    for (;;)
    {
        int vnum;
        char letter;
        int door;
        int iHash;
    

        letter = fread_letter (fp);
        if (letter != '#')
        {
            bug ("Load_rooms: # not found.", 0);
            exit (1);
        }

        vnum = fread_number (fp);
        if (vnum == 0)
            break;

        fBootDb = FALSE;
        if (get_room_index (vnum) != NULL)
        {
            bug ("Load_rooms: vnum %d duplicated.", vnum);
            exit (1);
        }
        fBootDb = TRUE;

        pRoomIndex = alloc_perm (sizeof (*pRoomIndex));
    //RoomIndex = alloc_perm (pRoomIndex);
        pRoomIndex->owner = str_dup ("");
        pRoomIndex->people = NULL;
        pRoomIndex->contents = NULL;
        pRoomIndex->extra_descr = NULL;
        pRoomIndex->area = area_last;
        pRoomIndex->vnum = vnum;
        pRoomIndex->name = fread_string (fp);

    pRoomIndex->travel_route = fread_number(fp);
    pRoomIndex->travel_type = fread_number(fp);
    pRoomIndex->travel_state = fread_number(fp);
        pRoomIndex->description = fread_string(fp);
    pRoomIndex->night_description = fread_string(fp);
    /* Area number */ fread_number (fp);
        pRoomIndex->room_flags = fread_flag (fp);
      /*if ((pRoomIndex->room_flags_extra = fread_flag(fp)))
    {
    }*/

pRoomIndex->room_flags_extra = fread_flag (fp);
    /* horrible hack */
        if (3000 <= vnum && vnum < 3400)
            SET_BIT (pRoomIndex->room_flags, ROOM_LAW);
        pRoomIndex->sector_type = fread_number (fp);
        pRoomIndex->light = 0;
        for (door = 0; door <= 9; door++)
            pRoomIndex->exit[door] = NULL;

        /* defaults */
        pRoomIndex->heal_rate = 100;
        pRoomIndex->mana_rate = 100;

        for (;;)
        {
            letter = fread_letter (fp);
        twiddle();

            if (letter == 'S')
                break;

            if (letter == 'H')    /* healing room */
                pRoomIndex->heal_rate = fread_number (fp);

            else if (letter == 'M')    /* mana room */
                pRoomIndex->mana_rate = fread_number (fp);

            else if (letter == 'C')
            {                    /* clan */
                if (pRoomIndex->clan)
                {
                    bug ("Load_rooms: duplicate clan fields.", 0);
                    exit (1);
                }
                pRoomIndex->clan = clan_lookup (fread_string (fp));
            }


            else if (letter == 'D')
            {
                EXIT_DATA *pexit;
                int locks;

                door = fread_number (fp);
                if (door < 0 || door > 9)
                {
                    bug ("Fread_rooms: vnum %d has bad door number.", vnum);
                    exit (1);
                }

                pexit = alloc_perm (sizeof (*pexit));
                pexit->description = fread_string (fp);
                pexit->keyword = fread_string (fp);
                pexit->exit_info = 0;
                pexit->rs_flags = 0;    /* OLC */
                locks = fread_number (fp);
                pexit->key = fread_number (fp);
                pexit->u1.vnum = fread_number (fp);
                pexit->orig_door = door;    /* OLC */

                switch (locks)
                {
                    case 1:
                        pexit->exit_info = EX_ISDOOR;
                        pexit->rs_flags = EX_ISDOOR;
                        break;
                    case 2:
                        pexit->exit_info = EX_ISDOOR | EX_PICKPROOF;
                        pexit->rs_flags = EX_ISDOOR | EX_PICKPROOF;
                        break;
                    case 3:
                        pexit->exit_info = EX_ISDOOR | EX_NOPASS;
                        pexit->rs_flags = EX_ISDOOR | EX_NOPASS;
                        break;
                    case 4:
                        pexit->exit_info =
                            EX_ISDOOR | EX_NOPASS | EX_PICKPROOF;
                        pexit->rs_flags =
                            EX_ISDOOR | EX_NOPASS | EX_PICKPROOF;
                        break;
                }

                pRoomIndex->exit[door] = pexit;
                top_exit++;
            }
            else if (letter == 'E')
            {
                EXTRA_DESCR_DATA *ed;

                ed = alloc_perm (sizeof (*ed));
                ed->keyword = fread_string (fp);
                ed->