开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 查看源码
DB.C
资源名称：mercwsrc.zip　[点击查看]
上传用户：kesirui
上传日期：2007-01-07
资源大小：263k
文件大小：70k
源码类别：

Internet/网络编程

开发平台：

WINDOWS

DB.C：源码内容
  1. /***************************************************************************
  2.  *  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
  3.  *  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
  4.  *                                                                         *
  5.  *  Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael          *
  6.  *  Chastain, Michael Quan, and Mitchell Tse.                              *
  7.  *                                                                         *
  8.  *  In order to use any part of this Merc Diku Mud, you must comply with   *
  9.  *  both the original Diku license in 'license.doc' as well the Merc       *
  10.  *  license in 'license.txt'.  In particular, you may not remove either of *
  11.  *  these copyright notices.                                               *
  12.  *                                                                         *
  13.  *  Much time and thought has gone into this software and you are          *
  14.  *  benefitting.  We hope that you share your changes too.  What goes      *
  15.  *  around, comes around.                                                  *
  16.  ***************************************************************************/
  18. #if defined(macintosh)
  19. #include <types.h>
  20. #else
  21. #include <sys/types.h>
  22. #endif
  23. #include <ctype.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <time.h>
  28. #include "merc.h"
  30. #if !defined(macintosh)
  31. extern int _filbuf args( (FILE *) );
  32. #endif
  34. /*
  35.  * Globals.
  36.  */
  37. HELP_DATA * help_first;
  38. HELP_DATA * help_last;
  40. SHOP_DATA * shop_first;
  41. SHOP_DATA * shop_last;
  43. CHAR_DATA * char_free;
  44. EXTRA_DESCR_DATA * extra_descr_free;
  45. NOTE_DATA * note_free;
  46. OBJ_DATA * obj_free;
  47. PC_DATA * pcdata_free;
  49. char bug_buf [2*MAX_INPUT_LENGTH];
  50. CHAR_DATA * char_list;
  51. char * help_greeting;
  52. char log_buf [2*MAX_INPUT_LENGTH];
  53. KILL_DATA kill_table [MAX_LEVEL];
  54. NOTE_DATA * note_list;
  55. OBJ_DATA * object_list;
  56. TIME_INFO_DATA time_info;
  57. WEATHER_DATA weather_info;
  59. sh_int gsn_backstab;
  60. sh_int gsn_dodge;
  61. sh_int gsn_hide;
  62. sh_int gsn_peek;
  63. sh_int gsn_pick_lock;
  64. sh_int gsn_sneak;
  65. sh_int gsn_steal;
  67. sh_int gsn_disarm;
  68. sh_int gsn_enhanced_damage;
  69. sh_int gsn_kick;
  70. sh_int gsn_parry;
  71. sh_int gsn_rescue;
  72. sh_int gsn_second_attack;
  73. sh_int gsn_third_attack;
  75. sh_int gsn_blindness;
  76. sh_int gsn_charm_person;
  77. sh_int gsn_curse;
  78. sh_int gsn_invis;
  79. sh_int gsn_mass_invis;
  80. sh_int gsn_poison;
  81. sh_int gsn_sleep;
  83. /*
  84.  * Psionicist gsn's.
  85.  */
  86. int                     gsn_chameleon;
  87. int                     gsn_domination;
  88. int                     gsn_heighten;
  89. int                     gsn_shadow;
  95. /*
  96.  * Locals.
  97.  */
  98. MOB_INDEX_DATA * mob_index_hash [MAX_KEY_HASH];
  99. OBJ_INDEX_DATA * obj_index_hash [MAX_KEY_HASH];
  100. ROOM_INDEX_DATA * room_index_hash [MAX_KEY_HASH];
  101. char * string_hash [MAX_KEY_HASH];
  103. AREA_DATA * area_first;
  104. AREA_DATA * area_last;
  106. char * string_space;
  107. char * top_string;
  108. char str_empty [1];
  110. int top_affect;
  111. int top_area;
  112. int top_ed;
  113. int top_exit;
  114. int top_help;
  115. int top_mob_index;
  116. int top_obj_index;
  117. int top_reset;
  118. int top_room;
  119. int top_shop;
  121. /*
  122.  * MOBprogram locals
  123. */
  125. int  mprog_name_to_type args( ( char* name ) );
  126. MPROG_DATA * mprog_file_read args( ( char* f, MPROG_DATA* mprg, 
  127.                                         MOB_INDEX_DATA *pMobIndex ) );
  128. void load_mobprogs           args( ( FILE* fp ) );
  129. void    mprog_read_programs     args( ( FILE* fp,
  130. MOB_INDEX_DATA *pMobIndex ) );
  132. // Windows version locals
  133. int fIgnoreUnconnected = TRUE;
  136. /*
  137.  * Memory management.
  138.  * Increase MAX_STRING if you have too.
  139.  * Tune the others only if you understand what you're doing.
  140.  */
  141. #define MAX_STRING 1750000
  142. #define MAX_PERM_BLOCK 131072
  143. #define MAX_MEM_LIST 11
  145. void * rgFreeList [MAX_MEM_LIST];
  146. const int rgSizeList [MAX_MEM_LIST] =
  147. {
  148.     16, 32, 64, 128, 256, 1024, 2048, 4096, 8192, 16384, 32768-64
  149. };
  151. int nAllocString;
  152. int sAllocString;
  153. int nAllocPerm;
  154. int sAllocPerm;
  158. /*
  159.  * Semi-locals.
  160.  */
  161. bool fBootDb;
  162. FILE * fpArea;
  163. char strArea[MAX_INPUT_LENGTH];
  167. /*
  168.  * Local booting procedures.
  169.  */
  170. void init_mm args( ( void ) );
  172. void load_area args( ( FILE *fp ) );
  173. void load_helps args( ( FILE *fp ) );
  174. void load_mobiles args( ( FILE *fp ) );
  175. void load_objects args( ( FILE *fp ) );
  176. void load_resets args( ( FILE *fp ) );
  177. void load_rooms args( ( FILE *fp ) );
  178. void load_shops args( ( FILE *fp ) );
  179. void load_specials args( ( FILE *fp ) );
  180. void load_notes args( ( void ) );
  182. void fix_exits args( ( void ) );
  184. void reset_area args( ( AREA_DATA * pArea ) );
  188. /*
  189.  * Big mama top level function.
  190.  */
  191. void boot_db( void )
  192. {
  193.     /*
  194.      * Init some data space stuff.
  195.      */
  196.     {
  197. if ( ( string_space = calloc( 1, MAX_STRING ) ) == NULL )
  198. {
  199.     bug( "Boot_db: can't alloc %d string space.", MAX_STRING );
  200.     exit( 1 );
  201. }
  202. top_string = string_space;
  203. fBootDb = TRUE;
  204.     }
  206.     /*
  207.      * Init random number generator.
  208.      */
  209.     {
  210. init_mm( );
  211.     }
  213.     /*
  214.      * Set time and weather.
  215.      */
  216.     {
  217. long lhour, lday, lmonth;
  219. lhour = (current_time - 650336715)
  220. / (PULSE_TICK / PULSE_PER_SECOND);
  221. time_info.hour = lhour  % 24;
  222. lday = lhour  / 24;
  223. time_info.day = lday   % 35;
  224. lmonth = lday   / 35;
  225. time_info.month = lmonth % 17;
  226. time_info.year = lmonth / 17;
  228.      if ( time_info.hour <  5 ) weather_info.sunlight = SUN_DARK;
  229. else if ( time_info.hour <  6 ) weather_info.sunlight = SUN_RISE;
  230. else if ( time_info.hour < 19 ) weather_info.sunlight = SUN_LIGHT;
  231. else if ( time_info.hour < 20 ) weather_info.sunlight = SUN_SET;
  232. else                            weather_info.sunlight = SUN_DARK;
  234. weather_info.change = 0;
  235. weather_info.mmhg = 960;
  236. if ( time_info.month >= 7 && time_info.month <=12 )
  237.     weather_info.mmhg += number_range( 1, 50 );
  238. else
  239.     weather_info.mmhg += number_range( 1, 80 );
  241.      if ( weather_info.mmhg <=  980 ) weather_info.sky = SKY_LIGHTNING;
  242. else if ( weather_info.mmhg <= 1000 ) weather_info.sky = SKY_RAINING;
  243. else if ( weather_info.mmhg <= 1020 ) weather_info.sky = SKY_CLOUDY;
  244. else                                  weather_info.sky = SKY_CLOUDLESS;
  246.     }
  248.     /*
  249.      * Assign gsn's for skills which have them.
  250.      */
  251.     {
  252. int sn;
  254. for ( sn = 0; sn < MAX_SKILL; sn++ )
  255. {
  256.     if ( skill_table[sn].pgsn != NULL )
  257. *skill_table[sn].pgsn = sn;
  258. }
  259.     }
  261.     /*
  262.      * Read in all the area files.
  263.      */
  264.     {
  265. FILE *fpList;
  267. if ( ( fpList = fopen( AREA_LIST, "r" ) ) == NULL )
  268. {
  269.     perror( AREA_LIST );
  270.     exit( 1 );
  271. }
  273. for ( ; ; )
  274. {
  275.     strcpy( strArea, fread_word( fpList ) );
  276.     if ( strArea[0] == '$' )
  277. break;
  279.     if ( strArea[0] == '-' )
  280.     {
  281. fpArea = stdin;
  282.     }
  283.     else
  284.     {
  285. if ( ( fpArea = fopen( strArea, "r" ) ) == NULL )
  286. {
  287.     perror( strArea );
  288.     exit( 1 );
  289. }
  290.     }
  292.     for ( ; ; )
  293.     {
  294. char *word;
  296. if ( fread_letter( fpArea ) != '#' )
  297. {
  298.     bug( "Boot_db: # not found.", 0 );
  299.     exit( 1 );
  300. }
  302. word = fread_word( fpArea );
  304.      if ( word[0] == '$'               )                 break;
  305. else if ( !str_cmp( word, "AREA"     ) ) load_area    (fpArea);
  306. else if ( !str_cmp( word, "HELPS"    ) ) load_helps   (fpArea);
  307. else if ( !str_cmp( word, "MOBILES"  ) ) load_mobiles (fpArea);
  308. else if ( !str_cmp( word, "MOBPROGS" ) ) load_mobprogs(fpArea);
  309. else if ( !str_cmp( word, "OBJECTS"  ) ) load_objects (fpArea);
  310. else if ( !str_cmp( word, "RESETS"   ) ) load_resets  (fpArea);
  311. else if ( !str_cmp( word, "ROOMS"    ) ) load_rooms   (fpArea);
  312. else if ( !str_cmp( word, "SHOPS"    ) ) load_shops   (fpArea);
  313. else if ( !str_cmp( word, "SPECIALS" ) ) load_specials(fpArea);
  314. else
  315. {
  316.     bug( "Boot_db: bad section name.", 0 );
  317.     exit( 1 );
  318. }
  319.     }
  321.     if ( fpArea != stdin )
  322. fclose( fpArea );
  323.     fpArea = NULL;
  324. }
  325. fclose( fpList );
  326.     }
  328.     /*
  329.      * Fix up exits.
  330.      * Declare db booting over.
  331.      * Reset all areas once.
  332.      * Load up the notes file.
  333.      * Set the MOBtrigger.
  334.      */
  335.     {
  336. fix_exits( );
  337. fBootDb = FALSE;
  338. area_update( );
  339. load_notes( );
  340. MOBtrigger = TRUE;
  341.     }
  343.     return;
  344. }
  348. /*
  349.  * Snarf an 'area' header line.
  350.  */
  351. void load_area( FILE *fp )
  352. {
  353.     AREA_DATA *pArea;
  355.     pArea = alloc_perm( sizeof(*pArea) );
  356.     pArea->reset_first = NULL;
  357.     pArea->reset_last = NULL;
  358.     pArea->name = fread_string( fp );
  359.     pArea->age = 15;
  360.     pArea->nplayer = 0;
  362.     if ( area_first == NULL )
  363. area_first = pArea;
  364.     if ( area_last  != NULL )
  365. area_last->next = pArea;
  366.     area_last = pArea;
  367.     pArea->next = NULL;
  369.     top_area++;
  370.     return;
  371. }
  375. /*
  376.  * Snarf a help section.
  377.  */
  378. void load_helps( FILE *fp )
  379. {
  380.     HELP_DATA *pHelp;
  382.     for ( ; ; )
  383.     {
  384. pHelp = alloc_perm( sizeof(*pHelp) );
  385. pHelp->level = fread_number( fp );
  386. pHelp->keyword = fread_string( fp );
  387. if ( pHelp->keyword[0] == '$' )
  388.     break;
  389. pHelp->text = fread_string( fp );
  391. if ( !str_cmp( pHelp->keyword, "greeting" ) )
  392.     help_greeting = pHelp->text;
  394. if ( help_first == NULL )
  395.     help_first = pHelp;
  396. if ( help_last  != NULL )
  397.     help_last->next = pHelp;
  399. help_last = pHelp;
  400. pHelp->next = NULL;
  401. top_help++;
  402.     }
  404.     return;
  405. }
  409. /*
  410.  * Snarf a mob section.
  411.  */
  412. void load_mobiles( FILE *fp )
  413. {
  414.     MOB_INDEX_DATA *pMobIndex;
  416.     for ( ; ; )
  417.     {
  418. sh_int vnum;
  419. char letter;
  420. int iHash;
  422. letter = fread_letter( fp );
  423. if ( letter != '#' )
  424. {
  425.     bug( "Load_mobiles: # not found.", 0 );
  426.     exit( 1 );
  427. }
  429. vnum = fread_number( fp );
  430. if ( vnum == 0 )
  431.     break;
  433. fBootDb = FALSE;
  434. if ( get_mob_index( vnum ) != NULL )
  435. {
  436.     bug( "Load_mobiles: vnum %d duplicated.", vnum );
  437.     exit( 1 );
  438. }
  439. fBootDb = TRUE;
  441. pMobIndex = alloc_perm( sizeof(*pMobIndex) );
  442. pMobIndex->vnum = vnum;
  443. pMobIndex->player_name = fread_string( fp );
  444. pMobIndex->short_descr = fread_string( fp );
  445. pMobIndex->long_descr = fread_string( fp );
  446. pMobIndex->description = fread_string( fp );
  448. pMobIndex->long_descr[0] = UPPER(pMobIndex->long_descr[0]);
  449. pMobIndex->description[0] = UPPER(pMobIndex->description[0]);
  451. pMobIndex->act = fread_number( fp ) | ACT_IS_NPC;
  452. pMobIndex->affected_by = fread_number( fp );
  453. pMobIndex->pShop = NULL;
  454. pMobIndex->alignment = fread_number( fp );
  455. letter = fread_letter( fp );
  456. pMobIndex->level = number_fuzzy( fread_number( fp ) );
  458. /*
  459.  * The unused stuff is for imps who want to use the old-style
  460.  * stats-in-files method.
  461.  */
  462. pMobIndex->hitroll = fread_number( fp ); /* Unused */
  463. pMobIndex->ac = fread_number( fp ); /* Unused */
  464. pMobIndex->hitnodice = fread_number( fp ); /* Unused */
  465. /* 'd' */   fread_letter( fp ); /* Unused */
  466. pMobIndex->hitsizedice = fread_number( fp ); /* Unused */
  467. /* '+' */   fread_letter( fp ); /* Unused */
  468. pMobIndex->hitplus = fread_number( fp ); /* Unused */
  469. pMobIndex->damnodice = fread_number( fp ); /* Unused */
  470. /* 'd' */   fread_letter( fp ); /* Unused */
  471. pMobIndex->damsizedice = fread_number( fp ); /* Unused */
  472. /* '+' */   fread_letter( fp ); /* Unused */
  473. pMobIndex->damplus = fread_number( fp ); /* Unused */
  474. pMobIndex->gold = fread_number( fp ); /* Unused */
  475. /* xp can't be used! */   fread_number( fp ); /* Unused */
  476. /* position */   fread_number( fp ); /* Unused */
  477. /* start pos */   fread_number( fp ); /* Unused */
  479. /*
  480.  * Back to meaningful values.
  481.  */
  482. pMobIndex->sex = fread_number( fp );
  483.    pMobIndex->cargo     = 0; // @@@ ### Needed?
  485. if ( letter != 'S' )
  486. {
  487.     bug( "Load_mobiles: vnum %d non-S.", vnum );
  488.     exit( 1 );
  489. }
  491. letter=fread_letter(fp);
  492. if (letter=='>')
  493. {
  494.     ungetc(letter,fp);
  495.     mprog_read_programs(fp,pMobIndex);
  496. }
  497. else ungetc(letter,fp);
  498. iHash = vnum % MAX_KEY_HASH;
  499. pMobIndex->next = mob_index_hash[iHash];
  500. mob_index_hash[iHash] = pMobIndex;
  501. top_mob_index++;
  502. kill_table[URANGE(0, pMobIndex->level, MAX_LEVEL-1)].number++;
  503.     }
  505.     return;
  506. }
  510. /*
  511.  * Snarf an obj section.
  512.  */
  513. void load_objects( FILE *fp )
  514. {
  515.     OBJ_INDEX_DATA *pObjIndex;
  517.     for ( ; ; )
  518.     {
  519. sh_int vnum;
  520. char letter;
  521. int iHash;
  523. letter = fread_letter( fp );
  524. if ( letter != '#' )
  525. {
  526.     bug( "Load_objects: # not found.", 0 );
  527.     exit( 1 );
  528. }
  530. vnum = fread_number( fp );
  531. if ( vnum == 0 )
  532.     break;
  534. fBootDb = FALSE;
  535. if ( get_obj_index( vnum ) != NULL )
  536. {
  537.     bug( "Load_objects: vnum %d duplicated.", vnum );
  538.     exit( 1 );
  539. }
  540. fBootDb = TRUE;
  542. pObjIndex = alloc_perm( sizeof(*pObjIndex) );
  543. pObjIndex->vnum = vnum;
  544. pObjIndex->name = fread_string( fp );
  545. pObjIndex->short_descr = fread_string( fp );
  546. pObjIndex->description = fread_string( fp );
  547. /* Action description */   fread_string( fp );
  549. pObjIndex->short_descr[0] = LOWER(pObjIndex->short_descr[0]);
  550. pObjIndex->description[0] = UPPER(pObjIndex->description[0]);
  552. pObjIndex->item_type = fread_number( fp );
  553. pObjIndex->extra_flags = fread_number( fp );
  554. pObjIndex->wear_flags = fread_number( fp );
  555. pObjIndex->value[0] = fread_number( fp );
  556. pObjIndex->value[1] = fread_number( fp );
  557. pObjIndex->value[2] = fread_number( fp );
  558. pObjIndex->value[3] = fread_number( fp );
  559. pObjIndex->weight = fread_number( fp );
  560. pObjIndex->cost = fread_number( fp ); /* Unused */
  561. /* Cost per day */   fread_number( fp );
  563. if ( pObjIndex->item_type == ITEM_POTION )
  564.     SET_BIT(pObjIndex->extra_flags, ITEM_NODROP);
  566. for ( ; ; )
  567. {
  568.     char letter;
  570.     letter = fread_letter( fp );
  572.     if ( letter == 'A' )
  573.     {
  574. AFFECT_DATA *paf;
  576. paf = alloc_perm( sizeof(*paf) );
  577. paf->type = -1;
  578. paf->duration = -1;
  579. paf->location = fread_number( fp );
  580. paf->modifier = fread_number( fp );
  581. paf->bitvector = 0;
  582. paf->next = pObjIndex->affected;
  583. pObjIndex->affected = paf;
  584. top_affect++;
  585.     }
  587.     else if ( letter == 'E' )
  588.     {
  589. EXTRA_DESCR_DATA *ed;
  591. ed = alloc_perm( sizeof(*ed) );
  592. ed->keyword = fread_string( fp );
  593. ed->description = fread_string( fp );
  594. ed->next = pObjIndex->extra_descr;
  595. pObjIndex->extra_descr = ed;
  596. top_ed++;
  597.     }
  599.     else
  600.     {
  601. ungetc( letter, fp );
  602. break;
  603.     }
  604. }
  606. /*
  607.  * Translate spell "slot numbers" to internal "skill numbers."
  608.  */
  609. switch ( pObjIndex->item_type )
  610. {
  611. case ITEM_PILL:
  612. case ITEM_POTION:
  613. case ITEM_SCROLL:
  614.     pObjIndex->value[1] = slot_lookup( pObjIndex->value[1] );
  615.     pObjIndex->value[2] = slot_lookup( pObjIndex->value[2] );
  616.     pObjIndex->value[3] = slot_lookup( pObjIndex->value[3] );
  617.     break;
  619. case ITEM_STAFF:
  620. case ITEM_WAND:
  621.     pObjIndex->value[3] = slot_lookup( pObjIndex->value[3] );
  622.     break;
  623. }
  625. iHash = vnum % MAX_KEY_HASH;
  626. pObjIndex->next = obj_index_hash[iHash];
  627. obj_index_hash[iHash] = pObjIndex;
  628. top_obj_index++;
  629.     }
  631.     return;
  632. }
  636. /*
  637.  * Snarf a reset section.
  638.  */
  639. void load_resets( FILE *fp )
  640. {
  641.     RESET_DATA *pReset;
  643.     if ( area_last == NULL )
  644.     {
  645. bug( "Load_resets: no #AREA seen yet.", 0 );
  646. exit( 1 );
  647.     }
  649.     for ( ; ; )
  650.     {
  651. ROOM_INDEX_DATA *pRoomIndex;
  652. EXIT_DATA *pexit;
  653. char letter;
  655. if ( ( letter = fread_letter( fp ) ) == 'S' )
  656.     break;
  658. if ( letter == '*' )
  659. {
  660.     fread_to_eol( fp );
  661.     continue;
  662. }
  664. pReset = alloc_perm( sizeof(*pReset) );
  665. pReset->command = letter;
  666. /* if_flag */   fread_number( fp );
  667. pReset->arg1 = fread_number( fp );
  668. pReset->arg2 = fread_number( fp );
  669. pReset->arg3 = (letter == 'G' || letter == 'R' || letter == 'C' || letter == 'F')
  670.     ? 0 : fread_number( fp );
  671.   fread_to_eol( fp );
  673. /*
  674.  * Validate parameters.
  675.  * We're calling the index functions for the side effect.
  676.  */
  677. switch ( letter )
  678. {
  679. default:
  680.     bug( "Load_resets: bad command '%c'.", letter );
  681.     exit( 1 );
  682.     break;
  684. case 'M':
  685.     get_mob_index  ( pReset->arg1 );
  686.     get_room_index ( pReset->arg3 );
  687.     break;
  689. case 'O':
  690.     get_obj_index  ( pReset->arg1 );
  691.     get_room_index ( pReset->arg3 );
  692.     break;
  694. case 'P':
  695.     get_obj_index  ( pReset->arg1 );
  696.     get_obj_index  ( pReset->arg3 );
  697.     break;
  699. case 'G':
  700. case 'E':
  701.     get_obj_index  ( pReset->arg1 );
  702.     break;
  704. case 'D':
  705.     pRoomIndex = get_room_index( pReset->arg1 );
  707.     if ( pReset->arg2 < 0
  708.     ||   pReset->arg2 > 5
  709.     || ( pexit = pRoomIndex->exit[pReset->arg2] ) == NULL
  710.     || !IS_SET( pexit->exit_info, EX_ISDOOR ) )
  711.     {
  712. bug( "Load_resets: 'D': exit %d not door.", pReset->arg2 );
  713. exit( 1 );
  714.     }
  716.     if ( pReset->arg3 < 0 || pReset->arg3 > 2 )
  717.     {
  718. bug( "Load_resets: 'D': bad 'locks': %d.", pReset->arg3 );
  719. exit( 1 );
  720.     }
  722.     break;
  724. case 'R':
  725.     /*pRoomIndex =*/ get_room_index( pReset->arg1 );
  727.     if ( pReset->arg2 < 0 || pReset->arg2 > 6 )
  728.     {
  729. bug( "Load_resets: 'R': bad exit %d.", pReset->arg2 );
  730. exit( 1 );
  731.     }
  733.     break;
  734.    case 'C':
  735.    case 'F':
  736.       break;
  737. }
  739. if ( area_last->reset_first == NULL )
  740.     area_last->reset_first = pReset;
  741. if ( area_last->reset_last  != NULL )
  742.     area_last->reset_last->next = pReset;
  743.     
  744. area_last->reset_last = pReset;
  745. pReset->next = NULL;
  746. top_reset++;
  747.     }
  749.     return;
  750. }
  754. /*
  755.  * Snarf a room section.
  756.  */
  757. void load_rooms( FILE *fp )
  758. {
  759.     ROOM_INDEX_DATA *pRoomIndex;
  761.     if ( area_last == NULL )
  762.     {
  763. bug( "Load_resets: no #AREA seen yet.", 0 );
  764. exit( 1 );
  765.     }
  767.     for ( ; ; )
  768.     {
  769. sh_int vnum;
  770. char letter;
  771. int door;
  772. int iHash;
  774. letter = fread_letter( fp );
  775. if ( letter != '#' )
  776. {
  777.     bug( "Load_rooms: # not found.", 0 );
  778.     exit( 1 );
  779. }
  781. vnum = fread_number( fp );
  782. if ( vnum == 0 )
  783.     break;
  785. fBootDb = FALSE;
  786. if ( get_room_index( vnum ) != NULL )
  787. {
  788.     bug( "Load_rooms: vnum %d duplicated.", vnum );
  789.     exit( 1 );
  790. }
  791. fBootDb = TRUE;
  793. pRoomIndex = alloc_perm( sizeof(*pRoomIndex) );
  794. pRoomIndex->people = NULL;
  795. pRoomIndex->contents = NULL;
  796. pRoomIndex->extra_descr = NULL;
  797. pRoomIndex->area = area_last;
  798. pRoomIndex->vnum = vnum;
  799. pRoomIndex->name = fread_string( fp );
  800. pRoomIndex->description = fread_string( fp );
  801. /* Area number */   fread_number( fp );
  802. pRoomIndex->room_flags = fread_number( fp );
  803. pRoomIndex->sector_type = fread_number( fp );
  804. pRoomIndex->light = 0;
  805. for ( door = 0; door <= 5; door++ )
  806.     pRoomIndex->exit[door] = NULL;
  808. for ( ; ; )
  809. {
  810.     letter = fread_letter( fp );
  812.     if ( letter == 'S' )
  813. break;
  815.     if ( letter == 'D' )
  816.     {
  817. EXIT_DATA *pexit;
  818. int locks;
  820. door = fread_number( fp );
  821. if ( door < 0 || door > 5 )
  822. {
  823.     bug( "Fread_rooms: vnum %d has bad door number.", vnum );
  824.     exit( 1 );
  825. }
  827. pexit = alloc_perm( sizeof(*pexit) );
  828. pexit->description = fread_string( fp );
  829. pexit->keyword = fread_string( fp );
  830. pexit->exit_info = 0;
  831. locks = fread_number( fp );
  832. pexit->key = fread_number( fp );
  833. pexit->vnum = fread_number( fp );
  835. switch ( locks )
  836. {
  837. case 1: pexit->exit_info = EX_ISDOOR;                break;
  838. case 2: pexit->exit_info = EX_ISDOOR | EX_PICKPROOF; break;
  839. }
  841. pRoomIndex->exit[door] = pexit;
  842. top_exit++;
  843.     }
  844.     else if ( letter == 'E' )
  845.     {
  846. EXTRA_DESCR_DATA *ed;
  848. ed = alloc_perm( sizeof(*ed) );
  849. ed->keyword = fread_string( fp );
  850. ed->description = fread_string( fp );
  851. ed->next = pRoomIndex->extra_descr;
  852. pRoomIndex->extra_descr = ed;
  853. top_ed++;
  854.     }
  855.     else
  856.     {
  857. bug( "Load_rooms: vnum %d has flag not 'DES'.", vnum );
  858. exit( 1 );
  859.     }
  860. }
  862. iHash = vnum % MAX_KEY_HASH;
  863. pRoomIndex->next = room_index_hash[iHash];
  864. room_index_hash[iHash] = pRoomIndex;
  865. top_room++;
  866.     }
  868.     return;
  869. }
  873. /*
  874.  * Snarf a shop section.
  875.  */
  876. void load_shops( FILE *fp )
  877. {
  878.     SHOP_DATA *pShop;
  880.     for ( ; ; )
  881.     {
  882. MOB_INDEX_DATA *pMobIndex;
  883. int iTrade;
  885. pShop = alloc_perm( sizeof(*pShop) );
  886. pShop->keeper = fread_number( fp );
  887. if ( pShop->keeper == 0 )
  888.     break;
  889. for ( iTrade = 0; iTrade < MAX_TRADE; iTrade++ )
  890.     pShop->buy_type[iTrade] = fread_number( fp );
  891. pShop->profit_buy = fread_number( fp );
  892. pShop->profit_sell = fread_number( fp );
  893. pShop->open_hour = fread_number( fp );
  894. pShop->close_hour = fread_number( fp );
  895.   fread_to_eol( fp );
  896. pMobIndex = get_mob_index( pShop->keeper );
  897. pMobIndex->pShop = pShop;
  899. if ( shop_first == NULL )
  900.     shop_first = pShop;
  901. if ( shop_last  != NULL )
  902.     shop_last->next = pShop;
  904. shop_last = pShop;
  905. pShop->next = NULL;
  906. top_shop++;
  907.     }
  909.     return;
  910. }
  914. /*
  915.  * Snarf spec proc declarations.
  916.  */
  917. void load_specials( FILE *fp )
  918. {
  919.     for ( ; ; )
  920.     {
  921. MOB_INDEX_DATA *pMobIndex;
  922. char letter;
  924. switch ( letter = fread_letter( fp ) )
  925. {
  926. default:
  927.     bug( "Load_specials: letter '%c' not *MS.", letter );
  928.     exit( 1 );
  930. case 'S':
  931.     return;
  933. case '*':
  934.     break;
  936. case 'M':
  937.     pMobIndex = get_mob_index ( fread_number ( fp ) );
  938.     pMobIndex->spec_fun = spec_lookup ( fread_word   ( fp ) );
  939.     if ( pMobIndex->spec_fun == 0 )
  940.     {
  941. bug( "Load_specials: 'M': vnum %d.", pMobIndex->vnum );
  942. exit( 1 );
  943.     }
  944.     break;
  945. }
  947. fread_to_eol( fp );
  948.     }
  949. }
  953. /*
  954.  * Snarf notes file.
  955.  */
  956. void load_notes( void )
  957. {
  958.     FILE *fp;
  959.     NOTE_DATA *pnotelast;
  961.     if ( ( fp = fopen( NOTE_FILE, "r" ) ) == NULL )
  962. return;
  964.     pnotelast = NULL;
  965.     for ( ; ; )
  966.     {
  967. NOTE_DATA *pnote;
  968. char letter;
  970. do
  971. {
  972.     letter = getc( fp );
  973.     if ( feof(fp) )
  974.     {
  975. fclose( fp );
  976. return;
  977.     }
  978. }
  979. while ( isspace(letter) );
  980. ungetc( letter, fp );
  982. pnote   = alloc_perm( sizeof(*pnote) );
  984. if ( str_cmp( fread_word( fp ), "sender" ) )
  985.     break;
  986. pnote->sender   = fread_string( fp );
  988. if ( str_cmp( fread_word( fp ), "date" ) )
  989.     break;
  990. pnote->date   = fread_string( fp );
  992. if ( str_cmp( fread_word( fp ), "stamp" ) )
  993.     break;
  994. pnote->date_stamp = fread_number( fp );
  996. if ( str_cmp( fread_word( fp ), "to" ) )
  997.     break;
  998. pnote->to_list   = fread_string( fp );
  1000. if ( str_cmp( fread_word( fp ), "subject" ) )
  1001.     break;
  1002. pnote->subject   = fread_string( fp );
  1004. if ( str_cmp( fread_word( fp ), "text" ) )
  1005.     break;
  1006. pnote->text   = fread_string( fp );
  1008. if ( note_list == NULL )
  1009.     note_list = pnote;
  1010. else
  1011.     pnotelast->next = pnote;
  1013. pnotelast   = pnote;
  1014.     }
  1016.     strcpy( strArea, NOTE_FILE );
  1017.     fpArea = fp;
  1018.     bug( "Load_notes: bad key word.", 0 );
  1019.     exit( 1 );
  1020.     return;
  1021. }
  1025. /*
  1026.  * Translate all room exits from virtual to real.
  1027.  * Has to be done after all rooms are read in.
  1028.  * Check for bad reverse exits.
  1029.  */
  1030. void fix_exits( void )
  1031. {
  1032.     extern const sh_int rev_dir [];
  1033.     char buf[MAX_STRING_LENGTH];
  1034.     ROOM_INDEX_DATA *pRoomIndex;
  1035.     ROOM_INDEX_DATA *to_room;
  1036.     EXIT_DATA *pexit;
  1037.     EXIT_DATA *pexit_rev;
  1038.     int iHash;
  1039.     int door;
  1041.     for ( iHash = 0; iHash < MAX_KEY_HASH; iHash++ )
  1042.     {
  1043. for ( pRoomIndex  = room_index_hash[iHash];
  1044.       pRoomIndex != NULL;
  1045.       pRoomIndex  = pRoomIndex->next )
  1046. {
  1047.     bool fexit;
  1049.     fexit = FALSE;
  1050.     for ( door = 0; door <= 5; door++ )
  1051.     {
  1052. if ( ( pexit = pRoomIndex->exit[door] ) != NULL )
  1053. {
  1054.     fexit = TRUE;
  1055.     if ( pexit->vnum <= 0 )
  1056. pexit->to_room = NULL;
  1057.     else
  1058. pexit->to_room = get_room_index( pexit->vnum );
  1059. }
  1060.     }
  1062.     if ( !fexit )
  1063. SET_BIT( pRoomIndex->room_flags, ROOM_NO_MOB );
  1064. }
  1065.     }
  1066. #if 0
  1067.     for ( iHash = 0; iHash < MAX_KEY_HASH; iHash++ )
  1068.     {
  1069. for ( pRoomIndex  = room_index_hash[iHash];
  1070.       pRoomIndex != NULL;
  1071.       pRoomIndex  = pRoomIndex->next )
  1072. {
  1073.     for ( door = 0; door <= 5; door++ )
  1074.     {
  1075. if ( ( pexit     = pRoomIndex->exit[door]       ) != NULL
  1076. &&   ( to_room   = pexit->to_room               ) != NULL
  1077. &&   ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
  1078. &&   pexit_rev->to_room != pRoomIndex )
  1079. {
  1080.     sprintf( buf, "Fix_exits: %d:%d -> %d:%d -> %d.",
  1081. pRoomIndex->vnum, door,
  1082. to_room->vnum,    rev_dir[door],
  1083. (pexit_rev->to_room == NULL)
  1084.     ? 0 : pexit_rev->to_room->vnum );
  1085.     bug( buf, 0 );
  1086. }
  1087.     }
  1088. }
  1089.     }
  1090. #endif
  1091.     return;
  1092. }
  1096. /*
  1097.  * Repopulate areas periodically.
  1098.  */
  1099. void area_update( void )
  1100. {
  1101.     AREA_DATA *pArea;
  1103.     for ( pArea = area_first; pArea != NULL; pArea = pArea->next )
  1104.     {
  1105. CHAR_DATA *pch;
  1107. if ( ++pArea->age < 3 )
  1108.     continue;
  1110. /*
  1111.  * Check for PC's.
  1112.  */
  1113. if ( pArea->nplayer > 0 && pArea->age == 15 - 1 )
  1114. {
  1115.     for ( pch = char_list; pch != NULL; pch = pch->next )
  1116.     {
  1117. if ( !IS_NPC(pch)
  1118. &&   IS_AWAKE(pch)
  1119. &&   pch->in_room != NULL
  1120. &&   pch->in_room->area == pArea )
  1121. {
  1122.     send_to_char( "You hear the patter of little feet.nr",
  1123. pch );
  1124. }
  1125.     }
  1126. }
  1128. /*
  1129.  * Check age and reset.
  1130.  * Note: Mud School resets every 3 minutes (not 15).
  1131.  */
  1132. if ( pArea->nplayer == 0 || pArea->age >= 15 )
  1133. {
  1134.     ROOM_INDEX_DATA *pRoomIndex;
  1136.     reset_area( pArea );
  1137.     pArea->age = number_range( 0, 3 );
  1138.     pRoomIndex = get_room_index( ROOM_VNUM_SCHOOL );
  1139.     if ( pRoomIndex != NULL && pArea == pRoomIndex->area )
  1140. pArea->age = 15 - 3;
  1141. }
  1142.     }
  1144.     return;
  1145. }
  1149. /*
  1150.  * Reset one area.
  1151.  */
  1152. void reset_area( AREA_DATA *pArea )
  1153. {
  1154.     RESET_DATA *pReset;
  1155.     CHAR_DATA *mob;
  1156.     bool last;
  1157.     int level;
  1159.     mob  = NULL;
  1160.     last = TRUE;
  1161.     level = 0;
  1162.     for ( pReset = pArea->reset_first; pReset != NULL; pReset = pReset->next )
  1163.     {
  1164. ROOM_INDEX_DATA *pRoomIndex;
  1165. MOB_INDEX_DATA *pMobIndex;
  1166. OBJ_INDEX_DATA *pObjIndex;
  1167. OBJ_INDEX_DATA *pObjToIndex;
  1168. EXIT_DATA *pexit;
  1169. OBJ_DATA *obj;
  1170. OBJ_DATA *obj_to;
  1172. switch ( pReset->command )
  1173. {
  1174. default:
  1175.     bug( "Reset_area: bad command %c.", pReset->command );
  1176.     break;
  1178. case 'M':
  1179.     if ( ( pMobIndex = get_mob_index( pReset->arg1 ) ) == NULL )
  1180.     {
  1181. bug( "Reset_area: 'M': bad vnum %d.", pReset->arg1 );
  1182. continue;
  1183.     }
  1185.     if ( ( pRoomIndex = get_room_index( pReset->arg3 ) ) == NULL )
  1186.     {
  1187. bug( "Reset_area: 'R': bad vnum %d.", pReset->arg3 );
  1188. continue;
  1189.     }
  1191.     level = URANGE( 0, pMobIndex->level - 2, LEVEL_HERO );
  1192.     if ( pMobIndex->count >= pReset->arg2 )
  1193.     {
  1194. last = FALSE;
  1195. break;
  1196.     }
  1198.     mob = create_mobile( pMobIndex );
  1200.     /*
  1201.      * Check for pet shop.
  1202.      */
  1203.     {
  1204. ROOM_INDEX_DATA *pRoomIndexPrev;
  1205. pRoomIndexPrev = get_room_index( pRoomIndex->vnum - 1 );
  1206. if ( pRoomIndexPrev != NULL
  1207. &&   IS_SET(pRoomIndexPrev->room_flags, ROOM_PET_SHOP) )
  1208.     SET_BIT(mob->act, ACT_PET);
  1209.     }
  1211.     if ( room_is_dark( pRoomIndex ) )
  1212. SET_BIT(mob->affected_by, AFF_INFRARED);
  1214.     char_to_room( mob, pRoomIndex );
  1215.     level = URANGE( 0, mob->level - 2, LEVEL_HERO );
  1216.     last  = TRUE;
  1217.     break;
  1219. case 'O':
  1220.     if ( ( pObjIndex = get_obj_index( pReset->arg1 ) ) == NULL )
  1221.     {
  1222. bug( "Reset_area: 'O': bad vnum %d.", pReset->arg1 );
  1223. continue;
  1224.     }
  1226.     if ( ( pRoomIndex = get_room_index( pReset->arg3 ) ) == NULL )
  1227.     {
  1228. bug( "Reset_area: 'R': bad vnum %d.", pReset->arg3 );
  1229. continue;
  1230.     }
  1232.     if ( pArea->nplayer > 0
  1233.     ||   count_obj_list( pObjIndex, pRoomIndex->contents ) > 0 )
  1234.     {
  1235. last = FALSE;
  1236. break;
  1237.     }
  1239.     obj       = create_object( pObjIndex, number_fuzzy( level ) );
  1240.     obj->cost = 0;
  1241.     obj_to_room( obj, pRoomIndex );
  1242.     last = TRUE;
  1243.     break;
  1245. case 'P':
  1246.     if ( ( pObjIndex = get_obj_index( pReset->arg1 ) ) == NULL )
  1247.     {
  1248. bug( "Reset_area: 'P': bad vnum %d.", pReset->arg1 );
  1249. continue;
  1250.     }
  1252.     if ( ( pObjToIndex = get_obj_index( pReset->arg3 ) ) == NULL )
  1253.     {
  1254. bug( "Reset_area: 'P': bad vnum %d.", pReset->arg3 );
  1255. continue;
  1256.     }
  1258.     if ( pArea->nplayer > 0
  1259.     || ( obj_to = get_obj_type( pObjToIndex ) ) == NULL
  1260.     ||   count_obj_list( pObjIndex, obj_to->contains ) > 0 )
  1261.     {
  1262. last = FALSE;
  1263. break;
  1264.     }
  1266.     obj = create_object( pObjIndex, number_fuzzy( obj_to->level ) );
  1267.     obj_to_obj( obj, obj_to );
  1268.     last = TRUE;
  1269.     break;
  1271. case 'G':
  1272. case 'E':
  1273.     if ( ( pObjIndex = get_obj_index( pReset->arg1 ) ) == NULL )
  1274.     {
  1275. bug( "Reset_area: 'E' or 'G': bad vnum %d.", pReset->arg1 );
  1276. continue;
  1277.     }
  1279.     if ( !last )
  1280. break;
  1282.     if ( mob == NULL )
  1283.     {
  1284. bug( "Reset_area: 'E' or 'G': null mob for vnum %d.",
  1285.     pReset->arg1 );
  1286. last = FALSE;
  1287. break;
  1288.     }
  1290.     if ( mob->pIndexData->pShop != NULL )
  1291.     {
  1292. int olevel;
  1294. switch ( pObjIndex->item_type )
  1295. {
  1296. default: olevel = 0;                      break;
  1297. case ITEM_PILL: olevel = number_range(  0, 10 ); break;
  1298. case ITEM_POTION: olevel = number_range(  0, 10 ); break;
  1299. case ITEM_SCROLL: olevel = number_range(  5, 15 ); break;
  1300. case ITEM_WAND: olevel = number_range( 10, 20 ); break;
  1301. case ITEM_STAFF: olevel = number_range( 15, 25 ); break;
  1302. case ITEM_ARMOR: olevel = number_range(  5, 15 ); break;
  1303. case ITEM_WEAPON: olevel = number_range(  5, 15 ); break;
  1304. }
  1306. obj = create_object( pObjIndex, olevel );
  1307. SET_BIT( obj->extra_flags, ITEM_INVENTORY );
  1308.     }
  1309.     else
  1310.     {
  1311. obj = create_object( pObjIndex, number_fuzzy( level ) );
  1312.     }
  1313.     obj_to_char( obj, mob );
  1314.     if ( pReset->command == 'E' )
  1315. equip_char( mob, obj, pReset->arg3 );
  1316.     last = TRUE;
  1317.     break;
  1319. case 'D':
  1320.     if ( ( pRoomIndex = get_room_index( pReset->arg1 ) ) == NULL )
  1321.     {
  1322. bug( "Reset_area: 'D': bad vnum %d.", pReset->arg1 );
  1323. continue;
  1324.     }
  1326.     if ( ( pexit = pRoomIndex->exit[pReset->arg2] ) == NULL )
  1327. break;
  1329.     switch ( pReset->arg3 )
  1330.     {
  1331.     case 0:
  1332. REMOVE_BIT( pexit->exit_info, EX_CLOSED );
  1333. REMOVE_BIT( pexit->exit_info, EX_LOCKED );
  1334. break;
  1336.     case 1:
  1337. SET_BIT(    pexit->exit_info, EX_CLOSED );
  1338. REMOVE_BIT( pexit->exit_info, EX_LOCKED );
  1339. break;
  1341.     case 2:
  1342. SET_BIT(    pexit->exit_info, EX_CLOSED );
  1343. SET_BIT(    pexit->exit_info, EX_LOCKED );
  1344. break;
  1345.     }
  1347.     last = TRUE;
  1348.     break;
  1350. case 'R':
  1351.     if ( ( pRoomIndex = get_room_index( pReset->arg1 ) ) == NULL )
  1352.     {
  1353. bug( "Reset_area: 'R': bad vnum %d.", pReset->arg1 );
  1354. continue;
  1355.     }
  1357.     {
  1358. int d0;
  1359. int d1;
  1361. for ( d0 = 0; d0 < pReset->arg2 - 1; d0++ )
  1362. {
  1363.     d1                   = number_range( d0, pReset->arg2-1 );
  1364.     pexit                = pRoomIndex->exit[d0];
  1365.     pRoomIndex->exit[d0] = pRoomIndex->exit[d1];
  1366.     pRoomIndex->exit[d1] = pexit;
  1367. }
  1368.     }
  1369.     break;
  1370.    case 'C':
  1371.    case 'F':
  1372.       break;
  1373. }
  1374.     }
  1376.     return;
  1377. }
  1379. #define nelems(a) (sizeof (a)/sizeof (a)[0])
  1381. // Calculate a meaningful modifier and amount
  1382. void random_apply( OBJ_DATA *obj, CHAR_DATA *mob )
  1383. {
  1384.    static int attrib_types[] = { APPLY_STR, APPLY_DEX, APPLY_DEX, APPLY_INT,
  1385.       APPLY_INT, APPLY_WIS, APPLY_CON, APPLY_CON, APPLY_CON };
  1386.    static int power_types[] = { APPLY_MANA, APPLY_HIT, APPLY_MOVE, APPLY_AC };
  1387.    static int combat_types[] = { APPLY_HITROLL, APPLY_HITROLL, APPLY_DAMROLL,
  1388.       APPLY_SAVING_SPELL, APPLY_SAVING_SPELL, APPLY_SAVING_BREATH };
  1390.    AFFECT_DATA *paf = alloc_perm( sizeof(*paf) );
  1391.    paf->type      = -1;
  1392.    paf->duration  = -1;
  1393.    paf->bitvector = 0;
  1394.    paf->next      = obj->affected;
  1395.    obj->affected  = paf;
  1396.    switch (number_bits(2)) {
  1397.    case 0:
  1398.       paf->location  = attrib_types[number_range(0, nelems(attrib_types)-1)];
  1399.       paf->modifier  = 1;
  1400.       break;
  1401.    case 1:
  1402.       paf->location  = power_types[number_range(0, nelems(power_types)-1)];
  1403.       paf->modifier  = number_range(mob->level/2, mob->level);
  1404.       break;
  1405.    case 2:
  1406.    case 3:
  1407.       paf->location  = combat_types[number_range(0, nelems(combat_types)-1)];
  1408.       paf->modifier  = number_range(1, mob->level/6+1);
  1409.       break;
  1410.    }
  1412.    SET_BIT(obj->extra_flags, ITEM_MAGIC);
  1414.    // Is item cursed?
  1415.    if (number_percent() <= 5)
  1416.       {
  1417.       paf->modifier = -paf->modifier;
  1418.       SET_BIT(obj->extra_flags, ITEM_NODROP);
  1419.       if (number_percent() <= 15)
  1420.          SET_BIT(obj->extra_flags, ITEM_NOREMOVE);
  1421.       }
  1422. }
  1424. // Jewelry stuff
  1425. static char *adj1[] = { "splendid", "ancient", "dusty", "scratched",
  1426.    "flawed", "burnt", "heavy", "gilded", "spooky", "flaming", "plain",
  1427.    "ornate", "inscrutable", "obscene", "wrinkled" };
  1428. static char *adj2[] = { "diamond", "emerald", "topaz", "wooden", "jade",
  1429.    "white gold", "onyx", "tin", "glass", "marble", "black", "granite" };
  1431. #define MASK_IGNORE     (1<<TAR_IGNORE)
  1432. #define MASK_OFFENSIVE  (1<<TAR_CHAR_OFFENSIVE)
  1433. #define MASK_DEFENSIVE  (1<<TAR_CHAR_DEFENSIVE)
  1434. #define MASK_SELF       (1<<TAR_CHAR_SELF)
  1435. #define MASK_INV        (1<<TAR_OBJ_INV)
  1437. #define CLASS_MAGE       0
  1438. #define CLASS_CLERIC     1
  1440. // Returns a clerical or magical spell of the appropriate (masked) type
  1441. int random_spell( int level, int mask, sh_int *type )
  1442. {
  1443.    extern const struct skill_type skill_table[MAX_SKILL];
  1445.    for ( ;; )
  1446.       {
  1447.       int skill_no = number_range(0, MAX_SKILL-1);
  1448.       if ((skill_table[skill_no].skill_level[CLASS_MAGE] <= level ||
  1449.            skill_table[skill_no].skill_level[CLASS_CLERIC] <= level) &&
  1450.           skill_table[skill_no].spell_fun &&         /* an actual spell? */
  1451.           mask & (1<<skill_table[skill_no].target))  /* appropriate? */
  1452.          {
  1453.          *type = skill_table[skill_no].target;
  1454.          return skill_no;
  1455.          }
  1456.       }
  1457. }
  1459. // Wands/Staves/Potions/Pills and bags
  1460. void wield_random_magic( CHAR_DATA *mob )
  1461. {
  1462.    int item_type = number_range(48, 53);  /* Get template obj from LIMBO.ARE */
  1463.    OBJ_INDEX_DATA *pObjIndex = get_obj_index( item_type );
  1464.    OBJ_DATA *obj = create_object( pObjIndex, number_fuzzy( mob->level ) );
  1465.    sh_int type;
  1466.    int    n_adj1 = number_range(0, nelems(adj1)-1);
  1467.    int    n_adj2 = number_range(0, nelems(adj2)-1);
  1469.    // Potion stuff
  1470.    static char *potions[] = { "bottle", "snifter", "jar", "bulb", "potion" };
  1472.    // Pill stuff
  1473.    static char *pills[] = { "bag of dust", "honeycomb", "root", "leaf",
  1474.       "crystal", "powder packet", "seed" };
  1476.    // Bag types (no wearable belts/backpacks... yet)
  1477.    static char *skins[] = { "lamia skin", "cloth", "leather", "tough leather",
  1478.       "zebra-skin", "gilded" };
  1479.    static char *bags[] = { "bag", "valise", "pail", "basket", "jar",
  1480.       "box", "sack" };
  1482.    char buffer[256];
  1483.    char buf[MAX_STRING_LENGTH];
  1484.    char name[MAX_STRING_LENGTH];
  1486.    switch (item_type) {
  1487.    case 48: /* scroll */
  1488.       sprintf(buffer, "%s %s scroll", adj1[n_adj1], adj2[n_adj2]);
  1489.       obj->value[0] = number_range(obj->level / 2+1, obj->level * 3 / 2+1); /* level */
  1490.       obj->value[0] = URANGE(1, obj->value[0], 36);
  1491.       obj->value[1] = random_spell(obj->value[0],
  1492.          MASK_IGNORE|MASK_OFFENSIVE|MASK_DEFENSIVE|MASK_SELF, &type);
  1493.       if (number_percent() < 50)
  1494.          obj->value[2] = random_spell(obj->value[0], 1<<type, &type);
  1495.       break;
  1496.    case 49: /* wand */
  1497.       sprintf(buffer, "%s %s wand", adj1[n_adj1], adj2[n_adj2]);
  1498.       obj->value[0] = number_range(obj->level / 3 + 1, obj->level * 3 / 2);  /* level */
  1499.       obj->value[0] = URANGE(1, obj->value[0], 36);
  1500.       obj->value[1] = number_fuzzy(obj->level / 2 + 3); /* max charges */
  1501.       obj->value[2] = number_range(1, obj->value[1]);   /* charges left */
  1502.       obj->value[3] = random_spell(obj->value[0], MASK_OFFENSIVE, &type);
  1503.       break;
  1504.    case 50: /* staff */
  1505.       sprintf(buffer, "%s %s staff", adj1[n_adj1], adj2[n_adj2]);
  1506.       obj->value[0] = number_range(obj->level / 4 + 1, obj->level * 3 / 2);  /* level */
  1507.       obj->value[0] = URANGE(1, obj->value[0], 36);
  1508.       obj->value[1] = number_fuzzy(obj->level / 2 + 3); /* max charges */
  1509.       obj->value[2] = number_range(1, obj->value[1]);   /* charges left */
  1510.       obj->value[3] = random_spell(obj->value[0],
  1511.          MASK_IGNORE|MASK_OFFENSIVE|MASK_DEFENSIVE|MASK_SELF, &type);
  1512.       break;
  1513.    case 51: /* potion */
  1514.       sprintf(buffer, "%s %s %s", adj1[n_adj1], adj2[n_adj2],
  1515.          potions[number_range(0, nelems(potions)-1)]);
  1516.       obj->value[0] = number_range(obj->level / 2+1, obj->level * 3 / 2+1); /* level */
  1517.       obj->value[0] = URANGE(1, obj->value[0], 36);
  1518.       obj->value[1] = random_spell(obj->value[0], MASK_DEFENSIVE, &type);
  1519.       if (number_percent() < 50)
  1520.          obj->value[2] = random_spell(obj->value[0], MASK_DEFENSIVE, &type);
  1521.       break;
  1522.    case 52: /* pill */
  1523.       sprintf(buffer, "%s %s %s", adj1[n_adj1], adj2[n_adj2],
  1524.          pills[number_range(0, nelems(pills)-1)]);
  1525.       obj->value[0] = number_range(obj->level / 2+1, obj->level * 3 / 2+1); /* level */
  1526.       obj->value[0] = URANGE(1, obj->value[0], 36);
  1527.       obj->value[1] = random_spell(obj->value[0], MASK_DEFENSIVE, &type);
  1528.       if (number_percent() < 50)
  1529.          obj->value[2] = random_spell(obj->value[0], MASK_DEFENSIVE, &type);
  1530.       break;
  1531.    case 53: /* bag */
  1532.       sprintf(buffer, "%s %s %s", adj1[n_adj1],
  1533.          skins[number_range(0, nelems(skins)-1)],
  1534.          bags[number_range(0, nelems(bags)-1)]);
  1535.       obj->value[0] = number_range(mob->level, mob->level * 25); /* weight */
  1536.       obj->value[1] = number_range(0, 1);
  1537.       obj->value[2] = -1;
  1538.       break;
  1539.    };
  1541.    // Generate the description strings
  1542.    free_string( obj->name );
  1543.    obj->name = str_dup( buffer );
  1545.    sprintf( buf, "a%s %s",
  1546.       (buffer[0] == 'a' || buffer[0] == 'e' || buffer[0] == 'i' ||
  1547.        buffer[0] == 'o' || buffer[0] == 'u') ? "n" : "", buffer );
  1548.    free_string( obj->short_descr );
  1549.    obj->short_descr = str_dup( buf );
  1551.    free_string( obj->description );
  1552.    sprintf( buf, "%s lies here.", obj->short_descr );
  1553.    obj->description = str_dup( buf );
  1555.    // Put the item in the mob's inventory
  1556.    obj_to_char( obj, mob );
  1557. }
  1559. // Anything wearable, and trinkets
  1560. void wield_random_armor( CHAR_DATA *mob )
  1561. {
  1562.    int item_type = number_range(0, MAX_WEAR - 1); /* template from LIMBO.ARE */
  1563.    OBJ_INDEX_DATA *pObjIndex = get_obj_index( item_type + 30 );
  1564.    OBJ_DATA *obj = create_object( pObjIndex, number_fuzzy( mob->level ) );
  1565.    int    n_adj1 = number_range(0, nelems(adj1)-1);
  1566.    int    n_adj2 = number_range(0, nelems(adj2)-1);
  1567.    char *name = "[random]";
  1569.    // Armor stuff
  1570.    static char *armor_types[] = { "leather", "studded leather", "bronze",
  1571.       "chain", "plate", "mithral" };
  1572.    static int armor_mul[] = { 1, 3, 2, 5, 10, 10 };
  1573.    static int armor_div[] = { 1, 2, 1, 1,  1,  3 };
  1575.    // Weapon stuff
  1576.    static char *weapon_types[] = { "sword", "sword", "sword", "sword", "sword",
  1577.       "short sword", "dagger", "dagger", "hammer", "mace", "mace", "whip" };
  1578.    static int weapon_dam[] = { 3, 3, 3, 3, 3, 11, 11, 11, 0, 7, 7, 4 };
  1580.    // Trinket stuff
  1581.    static char *noun[] = { "pebble", "bauble", "stone", "charm", "fetish",
  1582.       "bone", "trinket" };
  1583.    char buffer[64];
  1585.    char buf[MAX_STRING_LENGTH];
  1587.    if (obj->item_type == ITEM_ARMOR)
  1588.       {
  1589.       int ac_type = URANGE(0, mob->level/5, nelems(armor_types)-1);
  1590.       name = armor_types[ac_type];
  1591.       obj->weight *= armor_mul[ac_type];
  1592.       obj->weight /= armor_div[ac_type];
  1594.       if (number_percent() < mob->level / 3)
  1595.          random_apply(obj, mob);
  1596.       }
  1597.    else if (obj->item_type == ITEM_WEAPON)
  1598.       {
  1599.       int wea_type = number_range(0, nelems(weapon_types)-1);
  1600.       name = weapon_types[wea_type];
  1601.       obj->value[3] = weapon_dam[wea_type];
  1602.       }
  1603.    else if (obj->item_type == ITEM_TREASURE)
  1604.       {
  1605.       if (number_percent() < mob->level)
  1606.          {
  1607.          random_apply(obj, mob);
  1609.          if (number_percent() < mob->level / 3)
  1610.             random_apply(obj, mob);
  1611.          }
  1613.       if (obj->wear_flags & ITEM_HOLD) /* trinket? */
  1614.          sprintf(buffer, "%s %s %s", adj1[n_adj1],
  1615.             adj2[n_adj2],
  1616.             noun[number_range(0, nelems(noun)-1)]);
  1617.       else /* no, necklace or something */
  1618.          sprintf(buffer, "%s %s", adj1[n_adj1],
  1619.             adj2[n_adj2]);
  1620.       name = buffer;
  1621.       }
  1623.    sprintf( buf, obj->short_descr, name );
  1624.    free_string( obj->short_descr );
  1625.    obj->short_descr = str_dup( buf );
  1627.    obj_to_char( obj, mob );
  1628.    equip_char( mob, obj, item_type );
  1629. }
  1631. /*
  1632.  * Create an instance of a mobile.
  1633.  */
  1634. CHAR_DATA *create_mobile( MOB_INDEX_DATA *pMobIndex )
  1635. {
  1636.     CHAR_DATA *mob;
  1638.     if ( pMobIndex == NULL )
  1639.     {
  1640. bug( "Create_mobile: NULL pMobIndex.", 0 );
  1641. exit( 1 );
  1642.     }
  1644.     if ( char_free == NULL )
  1645.     {
  1646. mob = alloc_perm( sizeof(*mob) );
  1647.     }
  1648.     else
  1649.     {
  1650. mob = char_free;
  1651. char_free = char_free->next;
  1652.     }
  1654.     clear_char( mob );
  1655.     mob->pIndexData = pMobIndex;
  1657.     mob->name = pMobIndex->player_name;
  1658.     mob->short_descr = pMobIndex->short_descr;
  1659.     mob->long_descr = pMobIndex->long_descr;
  1660.     mob->description = pMobIndex->description;
  1661.     mob->spec_fun = pMobIndex->spec_fun;
  1662.     mob->prompt         = "<%h %m %v>";
  1664.     mob->level = number_fuzzy( pMobIndex->level );
  1665.     mob->act = pMobIndex->act;
  1666.     mob->affected_by = pMobIndex->affected_by;
  1667.     mob->alignment = pMobIndex->alignment;
  1668.     mob->sex = pMobIndex->sex;
  1670. /*
  1671.  * IMPORTANT !!! to add gold as defined in areas to your MUD, all you
  1672.  *               need to do is remove the coments from the following 
  1673.  *               line.
  1674.  */
  1676.  /* mob->gold           = pMobIndex->gold; */
  1678.     mob->armor = interpolate( mob->level, 100, -100 );
  1680.     mob->max_hit = mob->level * 8 + number_range(
  1681. mob->level * mob->level / 4,
  1682. mob->level * mob->level );
  1683.     mob->hit = mob->max_hit;
  1685. #if 0
  1686. //    if (number_percent() <= 10)
  1687.        wield_random_magic( mob );
  1688. //    else
  1689. //       wield_random_armor( mob );
  1690. #endif
  1692.     /*
  1693.      * Insert in list.
  1694.      */
  1695.     mob->next = char_list;
  1696.     char_list = mob;
  1697.     pMobIndex->count++;
  1698.     return mob;
  1699. }
  1703. /*
  1704.  * Create an instance of an object.
  1705.  */
  1706. OBJ_DATA *create_object( OBJ_INDEX_DATA *pObjIndex, int level )
  1707. {
  1708.     static OBJ_DATA obj_zero;
  1709.     OBJ_DATA *obj;
  1711.     if ( pObjIndex == NULL )
  1712.     {
  1713. bug( "Create_object: NULL pObjIndex.", 0 );
  1714. exit( 1 );
  1715.     }
  1717.     if ( obj_free == NULL )
  1718.     {
  1719. obj = alloc_perm( sizeof(*obj) );
  1720.     }
  1721.     else
  1722.     {
  1723. obj = obj_free;
  1724. obj_free = obj_free->next;
  1725.     }
  1727.     *obj = obj_zero;
  1728.     obj->pIndexData = pObjIndex;
  1729.     obj->in_room = NULL;
  1730.     obj->level = level;
  1731.     obj->wear_loc = -1;
  1733.     obj->name = pObjIndex->name;
  1734.     obj->short_descr = pObjIndex->short_descr;
  1735.     obj->description = pObjIndex->description;
  1736.     obj->item_type = pObjIndex->item_type;
  1737.     obj->extra_flags = pObjIndex->extra_flags;
  1738.     obj->wear_flags = pObjIndex->wear_flags;
  1739.     obj->value[0] = pObjIndex->value[0];
  1740.     obj->value[1] = pObjIndex->value[1];
  1741.     obj->value[2] = pObjIndex->value[2];
  1742.     obj->value[3] = pObjIndex->value[3];
  1743.     obj->weight = pObjIndex->weight;
  1744.     obj->cost = number_fuzzy( 10 )
  1745. * number_fuzzy( level ) * number_fuzzy( level );
  1747.     /*
  1748.      * Mess with object properties.
  1749.      */
  1750.     switch ( obj->item_type )
  1751.     {
  1752.     default:
  1753. bug( "Read_object: vnum %d bad type.", pObjIndex->vnum );
  1754. break;
  1756.     case ITEM_LIGHT:
  1757.     case ITEM_TREASURE:
  1758.     case ITEM_FURNITURE:
  1759.     case ITEM_TRASH:
  1760.     case ITEM_CONTAINER:
  1761.     case ITEM_DRINK_CON:
  1762.     case ITEM_KEY:
  1763.     case ITEM_FOOD:
  1764.     case ITEM_BOAT:
  1765.     case ITEM_CORPSE_NPC:
  1766.     case ITEM_CORPSE_PC:
  1767.     case ITEM_FOUNTAIN:
  1768. break;
  1770.     case ITEM_SCROLL:
  1771. obj->value[0] = number_fuzzy( obj->value[0] );
  1772. break;
  1774.     case ITEM_WAND:
  1775.     case ITEM_STAFF:
  1776. obj->value[0] = number_fuzzy( obj->value[0] );
  1777. obj->value[1] = number_fuzzy( obj->value[1] );
  1778. obj->value[2] = obj->value[1];
  1779. break;
  1781.     case ITEM_WEAPON:
  1782. obj->value[1] = number_fuzzy( number_fuzzy( 1 * level / 4 + 2 ) );
  1783. obj->value[2] = number_fuzzy( number_fuzzy( 3 * level / 4 + 6 ) );
  1784. break;
  1786.     case ITEM_ARMOR:
  1787. obj->value[0] = number_fuzzy( level / 4 + 2 );
  1788. break;
  1790.     case ITEM_POTION:
  1791.     case ITEM_PILL:
  1792. obj->value[0] = number_fuzzy( number_fuzzy( obj->value[0] ) );
  1793. break;
  1795.     case ITEM_MONEY:
  1796. obj->value[0] = obj->cost;
  1797. break;
  1798.     }
  1800.     obj->next = object_list;
  1801.     object_list = obj;
  1802.     pObjIndex->count++;
  1804.     return obj;
  1805. }
  1809. /*
  1810.  * Clear a new character.
  1811.  */
  1812. void clear_char( CHAR_DATA *ch )
  1813. {
  1814.     static CHAR_DATA ch_zero;
  1816.     *ch = ch_zero;
  1817.     ch->name = &str_empty[0];
  1818.     ch->short_descr = &str_empty[0];
  1819.     ch->long_descr = &str_empty[0];
  1820.     ch->description = &str_empty[0];
  1821.     ch->prompt                  = &str_empty[0];
  1822.     ch->last_note               = 0;
  1823.     ch->logon = current_time;
  1824.     ch->armor = 100;
  1825.     ch->position = POS_STANDING;
  1826.     ch->practice = 21;
  1827.     ch->hit = 20;
  1828.     ch->max_hit = 20;
  1829.     ch->mana = 100;
  1830.     ch->max_mana = 100;
  1831.     ch->move = 100;
  1832.     ch->max_move = 100;
  1833.     return;
  1834. }
  1838. /*
  1839.  * Free a character.
  1840.  */
  1841. void free_char( CHAR_DATA *ch )
  1842. {
  1843.     OBJ_DATA *obj;
  1844.     OBJ_DATA *obj_next;
  1845.     AFFECT_DATA *paf;
  1846.     AFFECT_DATA *paf_next;
  1848.     for ( obj = ch->carrying; obj != NULL; obj = obj_next )
  1849.     {
  1850. obj_next = obj->next_content;
  1851. extract_obj( obj );
  1852.     }
  1854.     for ( paf = ch->affected; paf != NULL; paf = paf_next )
  1855.     {
  1856. paf_next = paf->next;
  1857. affect_remove( ch, paf );
  1858.     }
  1860.     free_string( ch->name );
  1861.     free_string( ch->short_descr );
  1862.     free_string( ch->long_descr );
  1863.     free_string( ch->description );
  1865.     if ( ch->pcdata != NULL )
  1866.     {
  1867. free_string( ch->pcdata->pwd );
  1868. free_string( ch->pcdata->bamfin );
  1869. free_string( ch->pcdata->bamfout );
  1870. free_string( ch->pcdata->title );
  1871. ch->pcdata->next = pcdata_free;
  1872. pcdata_free      = ch->pcdata;
  1873.     }
  1875.     ch->next      = char_free;
  1876.     char_free      = ch;
  1877.     return;
  1878. }
  1882. /*
  1883.  * Get an extra description from a list.
  1884.  */
  1885. char *get_extra_descr( const char *name, EXTRA_DESCR_DATA *ed )
  1886. {
  1887.     for ( ; ed != NULL; ed = ed->next )
  1888.     {
  1889. if ( is_name( name, ed->keyword ) )
  1890.     return ed->description;
  1891.     }
  1892.     return NULL;
  1893. }
  1897. /*
  1898.  * Translates mob virtual number to its mob index struct.
  1899.  * Hash table lookup.
  1900.  */
  1901. MOB_INDEX_DATA *get_mob_index( int vnum )
  1902. {
  1903.     MOB_INDEX_DATA *pMobIndex;
  1905.     for ( pMobIndex  = mob_index_hash[vnum % MAX_KEY_HASH];
  1906.   pMobIndex != NULL;
  1907.   pMobIndex  = pMobIndex->next )
  1908.     {
  1909. if ( pMobIndex->vnum == vnum )
  1910.     return pMobIndex;
  1911.     }
  1913.     if ( fBootDb )
  1914.     {
  1915. bug( "Get_mob_index: bad vnum %d.", vnum );
  1916. exit( 1 );
  1917.     }
  1919.     return NULL;
  1920. }
  1924. /*
  1925.  * Translates mob virtual number to its obj index struct.
  1926.  * Hash table lookup.
  1927.  */
  1928. OBJ_INDEX_DATA *get_obj_index( int vnum )
  1929. {
  1930.     OBJ_INDEX_DATA *pObjIndex;
  1932.     for ( pObjIndex  = obj_index_hash[vnum % MAX_KEY_HASH];
  1933.   pObjIndex != NULL;
  1934.   pObjIndex  = pObjIndex->next )
  1935.     {
  1936. if ( pObjIndex->vnum == vnum )
  1937.     return pObjIndex;
  1938.     }
  1940.     if ( fBootDb )
  1941.     {
  1942. bug( "Get_obj_index: bad vnum %d.", vnum );
  1943. exit( 1 );
  1944.     }
  1946.     return NULL;
  1947. }
  1951. /*
  1952.  * Translates mob virtual number to its room index struct.
  1953.  * Hash table lookup.
  1954.  */
  1955. ROOM_INDEX_DATA *get_room_index( int vnum )
  1956. {
  1957.     ROOM_INDEX_DATA *pRoomIndex;
  1959.     for ( pRoomIndex  = room_index_hash[vnum % MAX_KEY_HASH];
  1960.   pRoomIndex != NULL;
  1961.   pRoomIndex  = pRoomIndex->next )
  1962.     {
  1963. if ( pRoomIndex->vnum == vnum )
  1964.     return pRoomIndex;
  1965.     }
  1967.     if ( fBootDb && !fIgnoreUnconnected)
  1968.     {
  1969. bug( "Get_room_index: bad vnum %d.", vnum );
  1970. exit( 1 );
  1971.     }
  1973.     return NULL;
  1974. }
  1978. /*
  1979.  * Read a letter from a file.
  1980.  */
  1981. char fread_letter( FILE *fp )
  1982. {
  1983.     char c;
  1985.     do
  1986.     {
  1987. c = getc( fp );
  1988.     }
  1989.     while ( isspace(c) );
  1991.     return c;
  1992. }
  1996. /*
  1997.  * Read a number from a file.
  1998.  */
  1999. int fread_number( FILE *fp )
  2000. {
  2001.     int number;
  2002.     bool sign;
  2003.     char c;
  2005.     do
  2006.     {
  2007. c = getc( fp );
  2008.     }
  2009.     while ( isspace(c) );
  2011.     number = 0;
  2013.     sign   = FALSE;
  2014.     if ( c == '+' )
  2015.     {
  2016. c = getc( fp );
  2017.     }
  2018.     else if ( c == '-' )
  2019.     {
  2020. sign = TRUE;
  2021. c = getc( fp );
  2022.     }
  2024.     if ( !isdigit(c) )
  2025.     {
  2026. bug( "Fread_number: bad format.", 0 );
  2027. exit( 1 );
  2028.     }
  2030.     while ( isdigit(c) )
  2031.     {
  2032. number = number * 10 + c - '0';
  2033. c      = getc( fp );
  2034.     }
  2036.     if ( sign )
  2037. number = 0 - number;
  2039.     if ( c == '|' )
  2040. number += fread_number( fp );
  2041.     else if ( c != ' ' )
  2042. ungetc( c, fp );
  2044.     return number;
  2045. }
  2049. /*
  2050.  * Read and allocate space for a string from a file.
  2051.  * These strings are read-only and shared.
  2052.  * Strings are hashed:
  2053.  *   each string prepended with hash pointer to prev string,
  2054.  *   hash code is simply the string length.
  2055.  * This function takes 40% to 50% of boot-up time.
  2056.  */
  2057. char *fread_string( FILE *fp )
  2058. {
  2059.     char *plast;
  2060.     char c;
  2062.     plast = top_string + sizeof(char *);
  2063.     if ( plast > &string_space[MAX_STRING - MAX_STRING_LENGTH] )
  2064.     {
  2065. bug( "Fread_string: MAX_STRING %d exceeded.", MAX_STRING );
  2066. exit( 1 );
  2067.  }
  2069.  /*
  2070.   * Skip blanks.
  2071.   * Read first char.
  2072.   */
  2073.  do
  2074.  {
  2075. c = getc( fp );
  2076.  }
  2077.  while ( isspace(c) );
  2079.  if ( ( *plast++ = c ) == '~' )
  2080. return &str_empty[0];
  2082.  for ( ;; )
  2083.  {
  2084. /*
  2085.  * Back off the char type lookup,
  2086.  *   it was too dirty for portability.
  2087.  *   -- Furey
  2088.  */
  2089. switch ( *plast = getc( fp ) )
  2090. {
  2091. default:
  2092.  plast++;
  2093.  break;
  2095. case EOF:
  2096.  bug( "Fread_string: EOF", 0 );
  2097.  exit( 1 );
  2098.  break;
  2100. case 'n':
  2101.  plast++;
  2102.  *plast++ = 'r';
  2103.  break;
  2105. case 'r':
  2106.  break;
  2108. case '~':
  2109.  plast++;
  2110.  {
  2111. union
  2112. {
  2113.  char * pc;
  2114.  char rgc[sizeof(char *)];
  2115. } u1;
  2116. int ic;
  2117. int iHash;
  2118. char *pHash;
  2119. char *pHashPrev;
  2120. char *pString;
  2122. plast[-1] = '';
  2123. iHash     = UMIN( MAX_KEY_HASH - 1, plast - 1 - top_string );
  2124. for ( pHash = string_hash[iHash]; pHash; pHash = pHashPrev )
  2125. {
  2126.  for ( ic = 0; ic < sizeof(char *); ic++ )
  2127. u1.rgc[ic] = pHash[ic];
  2128.  pHashPrev = u1.pc;
  2129.  pHash    += sizeof(char *);
  2131.  if ( top_string[sizeof(char *)] == pHash[0]
  2132.  &&   !strcmp( top_string+sizeof(char *)+1, pHash+1 ) )
  2133. return pHash;
  2134. }
  2136. if ( fBootDb )
  2137. {
  2138.  pString = top_string;
  2139.  top_string = plast;
  2140.  u1.pc = string_hash[iHash];
  2141.  for ( ic = 0; ic < sizeof(char *); ic++ )
  2142. pString[ic] = u1.rgc[ic];
  2143.  string_hash[iHash] = pString;
  2145.  nAllocString += 1;
  2146.  sAllocString += top_string - pString;
  2147.  return pString + sizeof(char *);
  2148. }
  2149. else
  2150. {
  2151.  return str_dup( top_string + sizeof(char *) );
  2152. }
  2153.  }
  2154. }
  2155.  }
  2156. }
  2160. /*
  2161.  * Read to end of line (for comments).
  2162.  */
  2163. void fread_to_eol( FILE *fp )
  2164. {
  2165.     char c;
  2167.     do
  2168.     {
  2169. c = getc( fp );
  2170.     }
  2171.     while ( c != 'n' && c != 'r' );
  2173.     do
  2174.     {
  2175. c = getc( fp );
  2176.     }
  2177.     while ( c == 'n' || c == 'r' );
  2179.     ungetc( c, fp );
  2180.     return;
  2181. }
  2185. /*
  2186.  * Read one word (into static buffer).
  2187.  */
  2188. char *fread_word( FILE *fp )
  2189. {
  2190.     static char word[MAX_INPUT_LENGTH];
  2191.     char *pword;
  2192.     char cEnd;
  2194.     do
  2195.     {
  2196. cEnd = getc( fp );
  2197.     }
  2198.     while ( isspace( cEnd ) );
  2200.     if ( cEnd == ''' || cEnd == '"' )
  2201.     {
  2202. pword   = word;
  2203.     }
  2204.     else
  2205.     {
  2206. word[0] = cEnd;
  2207. pword   = word+1;
  2208. cEnd    = ' ';
  2209.     }
  2211.     for ( ; pword < word + MAX_INPUT_LENGTH; pword++ )
  2212.     {
  2213. *pword = getc( fp );
  2214. if ( cEnd == ' ' ? isspace(*pword) : *pword == cEnd )
  2215. {
  2216.     if ( cEnd == ' ' )
  2217. ungetc( *pword, fp );
  2218.     *pword = '';
  2219.     return word;
  2220. }
  2221.     }
  2223.     bug( "Fread_word: word too long.", 0 );
  2224.     exit( 1 );
  2225.     return NULL;
  2226. }
  2230. /*
  2231.  * Allocate some ordinary memory,
  2232.  *   with the expectation of freeing it someday.
  2233.  */
  2234. void *alloc_mem( int sMem )
  2235. {
  2236. #if 0 // %%%
  2237.     return malloc(sMem);
  2238. #else
  2239.     void *pMem;
  2240.     int iList;
  2242.     sMem += 2 * sizeof (int); // @@@
  2244.     for ( iList = 0; iList < MAX_MEM_LIST; iList++ )
  2245.     {
  2246. if ( sMem <= rgSizeList[iList] )
  2247.     break;
  2248.     }
  2250.     if ( iList == MAX_MEM_LIST )
  2251.     {
  2252. #if 1 // @@@
  2253. bug( "Alloc_mem: size %d too large.", sMem );
  2254. exit( 1 );
  2255. #else
  2256.    char szBuffer[256];
  2257.    wsprintf(szBuffer, "alloc_mem(%d) to large.  Continue?", sMem);
  2258.    if (MessageBox(0, szBuffer, "Merc22", MB_ICONQUESTION|MB_YESNO) == IDYES)
  2259.       return 0;
  2260.    else
  2261.       {
  2262.       DebugBreak();
  2263.       exit( 1 );
  2264.       }
  2265. #endif
  2266.     }
  2268.     if ( rgFreeList[iList] == NULL )
  2269.     {
  2270. pMem   = alloc_perm( rgSizeList[iList] );
  2271.     }
  2272.     else
  2273.     {
  2274. pMem              = rgFreeList[iList];
  2275. rgFreeList[iList] = * ((void **) rgFreeList[iList]);
  2276.     }
  2278.     ((int *) pMem)[0] = 0x55555555; // @@@
  2279.     ((int *) pMem)[1] = sMem; // @@@
  2280.     return ((int *) pMem) + 2; // @@@
  2281. //    return pMem; // @@@
  2282. #endif
  2283. }
  2287. /*
  2288.  * Free some memory.
  2289.  * Recycle it back onto the free list for blocks of that size.
  2290.  */
  2291. void free_mem( void *pMem, int sMem )
  2292. {
  2293. #if 0 // %%%
  2294.     free(pMem);
  2295. #else
  2296.     int iList;
  2298. #if 1 // @@@
  2299.     ((int *)pMem) -= 2;
  2300.     sMem += 2 * sizeof (int);
  2301.     if (((int *) pMem)[0] == 0xaaaaaaaa)
  2302.     {
  2303. bug( "Free_mem: this block was already freed.", 0 );
  2304. exit( 1 );
  2305.     }
  2306.     if (((int *) pMem)[0] != 0x55555555)
  2307.     {
  2308. bug( "Free_mem: invalid key.", 0 );
  2309. exit( 1 );
  2310.     }
  2311.     if (((int *) pMem)[1] != sMem)
  2312.     {
  2313. bug( "Free_mem: invalid size.", 0 );
  2314. exit( 1 );
  2315.     }
  2316.     ((int *) pMem)[0] = 0xaaaaaaaa;
  2317. #endif
  2319.     for ( iList = 0; iList < MAX_MEM_LIST; iList++ )
  2320.     {
  2321. if ( sMem <= rgSizeList[iList] )
  2322.     break;
  2323.     }
  2325.     if ( iList == MAX_MEM_LIST )
  2326.     {
  2327. bug( "Free_mem: size %d too large.", sMem );
  2328. exit( 1 );
  2329.     }
  2331.     pMem = memset( pMem, 0, sMem );
  2332.     * ((void **) pMem) = rgFreeList[iList];
  2333.     rgFreeList[iList]  = pMem;
  2335.     return;
  2336. #endif
  2337. }
  2341. /*
  2342.  * Allocate some permanent memory.
  2343.  * Permanent memory is never freed,
  2344.  *   pointers into it may be copied safely.
  2345.  */
  2346. void *alloc_perm( int sMem )
  2347. {
  2348.     static char *pMemPerm;
  2349.     static int iMemPerm;
  2350.     void *pMem;
  2352.     while ( sMem % sizeof(long) != 0 )
  2353. sMem++;
  2354.     if ( sMem > MAX_PERM_BLOCK )
  2355.     {
  2356. bug( "Alloc_perm: %d too large.", sMem );
  2357. exit( 1 );
  2358.     }
  2360.     if ( pMemPerm == NULL || iMemPerm + sMem > MAX_PERM_BLOCK )
  2361.     {
  2362. iMemPerm = 0;
  2363. if ( ( pMemPerm = calloc( 1, MAX_PERM_BLOCK ) ) == NULL )
  2364. {
  2365.     perror( "Alloc_perm" );
  2366.     exit( 1 );
  2367. }
  2368.     }
  2370.     pMem        = pMemPerm + iMemPerm;
  2371.     iMemPerm   += sMem;
  2372.     nAllocPerm += 1;
  2373.     sAllocPerm += sMem;
  2374.     return pMem;
  2375. }
  2379. /*
  2380.  * Duplicate a string into dynamic memory.
  2381.  * Fread_strings are read-only and shared.
  2382.  */
  2383. char *str_dup( const char *str )
  2384. {
  2385.     char *str_new;
  2386. #if 1 // %%%
  2387.     if ( str[0] == '' )
  2388. return &str_empty[0];
  2390.     if ( str >= string_space && str < top_string )
  2391. return (char *) str;
  2392. #endif
  2393.     str_new = alloc_mem( strlen(str) + 1 );
  2394.     strcpy( str_new, str );
  2395.     return str_new;
  2396. }
  2400. /*
  2401.  * Free a string.
  2402.  * Null is legal here to simplify callers.
  2403.  * Read-only shared strings are not touched.
  2404.  */
  2405. void free_string( char *pstr )
  2406. {
  2407.     if ( pstr == NULL
  2408.     ||   pstr == &str_empty[0]
  2409.     || ( pstr >= string_space && pstr < top_string ) )
  2410. return;
  2412.     free_mem( pstr, strlen(pstr) + 1 );
  2413.     return;
  2414. }
  2417. //#if 0
  2418. void do_areas( CHAR_DATA *ch, char *argument )
  2419. {
  2420.     char buf[MAX_STRING_LENGTH];
  2421.     AREA_DATA *pArea1;
  2422.     AREA_DATA *pArea2;
  2423.     int iArea;
  2424.     int iAreaHalf;
  2426.     iAreaHalf = (top_area + 1) / 2;
  2427.     pArea1    = area_first;
  2428.     pArea2    = area_first;
  2429.     for ( iArea = 0; iArea < iAreaHalf; iArea++ )
  2430. pArea2 = pArea2->next;
  2432.     for ( iArea = 0; iArea < iAreaHalf; iArea++ )
  2433.     {
  2434. sprintf( buf, "%-39s%-39snr",
  2435.     pArea1->name, (pArea2 != NULL) ? pArea2->name : "" );
  2436. send_to_char( buf, ch );
  2437. pArea1 = pArea1->next;
  2438. if ( pArea2 != NULL )
  2439.     pArea2 = pArea2->next;
  2440.     }
  2442.     return;
  2443. }
  2447. void do_memory( CHAR_DATA *ch, char *argument )
  2448. {
  2449.     char buf[MAX_STRING_LENGTH];
  2451.     sprintf( buf, "Affects %5dnr", top_affect    ); send_to_char( buf, ch );
  2452.     sprintf( buf, "Areas   %5dnr", top_area      ); send_to_char( buf, ch );
  2453.     sprintf( buf, "ExDes   %5dnr", top_ed        ); send_to_char( buf, ch );
  2454.     sprintf( buf, "Exits   %5dnr", top_exit      ); send_to_char( buf, ch );
  2455.     sprintf( buf, "Helps   %5dnr", top_help      ); send_to_char( buf, ch );
  2456.     sprintf( buf, "Mobs    %5dnr", top_mob_index ); send_to_char( buf, ch );
  2457.     sprintf( buf, "Objs    %5dnr", top_obj_index ); send_to_char( buf, ch );
  2458.  sprintf( buf, "Resets  %5dnr", top_reset     ); send_to_char( buf, ch );
  2459.  sprintf( buf, "Rooms   %5dnr", top_room      ); send_to_char( buf, ch );
  2460.  sprintf( buf, "Shops   %5dnr", top_shop      ); send_to_char( buf, ch );
  2462.  sprintf( buf, "Strings %5d strings of %7d bytes (max %d).nr",
  2463. nAllocString, sAllocString, MAX_STRING );
  2464.  send_to_char( buf, ch );
  2466.  sprintf( buf, "Perms   %5d blocks  of %7d bytes.nr",
  2467. nAllocPerm, sAllocPerm );
  2468.  send_to_char( buf, ch );
  2470.  return;
  2471. }
  2472. //#endif
  2475. /*
  2476.  * Stick a little fuzz on a number.
  2477.  */
  2478. int number_fuzzy( int number )
  2479. {
  2480.     switch ( number_bits( 2 ) )
  2481.     {
  2482.     case 0:  number -= 1; break;
  2483.     case 3:  number += 1; break;
  2484.     }
  2486.     return UMAX( 1, number );
  2487. }
  2491. /*
  2492.  * Generate a random number.
  2493.  */
  2494. int number_range( int from, int to )
  2495. {
  2496.     int power;
  2497.     int number;
  2499.     if ( ( to = to - from + 1 ) <= 1 )
  2500. return from;
  2502.     for ( power = 2; power < to; power <<= 1 )
  2503. ;
  2505.     while ( ( number = number_mm( ) & (power - 1) ) >= to )
  2506. ;
  2508.     return from + number;
  2509. }
  2513. /*
  2514.  * Generate a percentile roll.
  2515.  */
  2516. int number_percent( void )
  2517. {
  2518.     int percent;
  2520.     while ( ( percent = number_mm( ) & (128-1) ) > 99 )
  2521. ;
  2523.     return 1 + percent;
  2524. }
  2528. /*
  2529.  * Generate a random door.
  2530.  */
  2531. int number_door( void )
  2532. {
  2533.     int door;
  2535.     while ( ( door = number_mm( ) & (8-1) ) > 5 )
  2536. ;
  2538.     return door;
  2539. }
  2543. int number_bits( int width )
  2544. {
  2545.     return number_mm( ) & ( ( 1 << width ) - 1 );
  2546. }
  2550. /*
  2551.  * I've gotten too many bad reports on OS-supplied random number generators.
  2552.  * This is the Mitchell-Moore algorithm from Knuth Volume II.
  2553.  * Best to leave the constants alone unless you've read Knuth.
  2554.  * -- Furey
  2555.  */
  2556. static int rgiState[2+55];
  2558. void init_mm( )
  2559. {
  2560.     int *piState;
  2561.     int iState;
  2563.     piState = &rgiState[2];
  2565.     piState[-2] = 55 - 55;
  2566.     piState[-1] = 55 - 24;
  2568.     piState[0] = ((int) current_time) & ((1 << 30) - 1);
  2569.     piState[1] = 1;
  2570.     for ( iState = 2; iState < 55; iState++ )
  2571.     {
  2572. piState[iState] = (piState[iState-1] + piState[iState-2])
  2573. & ((1 << 30) - 1);
  2574.     }
  2575.     return;
  2576. }
  2580. int number_mm( void )
  2581. {
  2582.     int *piState;
  2583.     int iState1;
  2584.     int iState2;
  2585.     int iRand;
  2587.     piState = &rgiState[2];
  2588.     iState1   = piState[-2];
  2589.     iState2   = piState[-1];
  2590.     iRand   = (piState[iState1] + piState[iState2])
  2591. & ((1 << 30) - 1);
  2592.     piState[iState1] = iRand;
  2593.     if ( ++iState1 == 55 )
  2594. iState1 = 0;
  2595.     if ( ++iState2 == 55 )
  2596. iState2 = 0;
  2597.     piState[-2] = iState1;
  2598.     piState[-1] = iState2;
  2599.     return iRand >> 6;
  2600. }
  2604. /*
  2605.  * Roll some dice.
  2606.  */
  2607. int dice( int number, int size )
  2608. {
  2609.     int idice;
  2610.     int sum;
  2612.     switch ( size )
  2613.     {
  2614.     case 0: return 0;
  2615.     case 1: return number;
  2616.     }
  2618.     for ( idice = 0, sum = 0; idice < number; idice++ )
  2619. sum += number_range( 1, size );
  2621.     return sum;
  2622. }
  2626. /*
  2627.  * Simple linear interpolation.
  2628.  */
  2629. int interpolate( int level, int value_00, int value_32 )
  2630. {
  2631.     return value_00 + level * (value_32 - value_00) / 32;
  2632. }
  2636. /*
  2637.  * Removes the tildes from a string.
  2638.  * Used for player-entered strings that go into disk files.
  2639.  */
  2640. void smash_tilde( char *str )
  2641. {
  2642.     for ( ; *str != ''; str++ )
  2643.     {
  2644. if ( *str == '~' )
  2645.     *str = '-';
  2646.     }
  2648.     return;
  2649. }
  2653. /*
  2654.  * Compare strings, case insensitive.
  2655.  * Return TRUE if different
  2656.  *   (compatibility with historical functions).
  2657.  */
  2658. bool str_cmp( const char *astr, const char *bstr )
  2659. {
  2660.     if ( astr == NULL )
  2661.     {
  2662. bug( "Str_cmp: null astr.", 0 );
  2663. return TRUE;
  2664.     }
  2666.     if ( bstr == NULL )
  2667.     {
  2668. bug( "Str_cmp: null bstr.", 0 );
  2669. return TRUE;
  2670.     }
  2672.     for ( ; *astr || *bstr; astr++, bstr++ )
  2673.     {
  2674. if ( LOWER(*astr) != LOWER(*bstr) )
  2675.     return TRUE;
  2676.     }
  2678.     return FALSE;
  2679. }
  2683. /*
  2684.  * Compare strings, case insensitive, for prefix matching.
  2685.  * Return TRUE if astr not a prefix of bstr
  2686.  *   (compatibility with historical functions).
  2687.  */
  2688. bool str_prefix( const char *astr, const char *bstr )
  2689. {
  2690.     if ( astr == NULL )
  2691.     {
  2692. bug( "Strn_cmp: null astr.", 0 );
  2693. return TRUE;
  2694.     }
  2696.     if ( bstr == NULL )
  2697.     {
  2698. bug( "Strn_cmp: null bstr.", 0 );
  2699. return TRUE;
  2700.     }
  2702.     for ( ; *astr; astr++, bstr++ )
  2703.     {
  2704. if ( LOWER(*astr) != LOWER(*bstr) )
  2705.     return TRUE;
  2706.     }
  2708.     return FALSE;
  2709. }
  2713. /*
  2714.  * Compare strings, case insensitive, for match anywhere.
  2715.  * Returns TRUE is astr not part of bstr.
  2716.  *   (compatibility with historical functions).
  2717.  */
  2718. bool str_infix( const char *astr, const char *bstr )
  2719. {
  2720.     int sstr1;
  2721.     int sstr2;
  2722.     int ichar;
  2723.     char c0;
  2725.     if ( ( c0 = LOWER(astr[0]) ) == '' )
  2726. return FALSE;
  2728.     sstr1 = strlen(astr);
  2729.     sstr2 = strlen(bstr);
  2731.     for ( ichar = 0; ichar <= sstr2 - sstr1; ichar++ )
  2732.     {
  2733. if ( c0 == LOWER(bstr[ichar]) && !str_prefix( astr, bstr + ichar ) )
  2734.     return FALSE;
  2735.     }
  2737.     return TRUE;
  2738. }
  2742. /*
  2743.  * Compare strings, case insensitive, for suffix matching.
  2744.  * Return TRUE if astr not a suffix of bstr
  2745.  *   (compatibility with historical functions).
  2746.  */
  2747. bool str_suffix( const char *astr, const char *bstr )
  2748. {
  2749.     int sstr1;
  2750.     int sstr2;
  2752.     sstr1 = strlen(astr);
  2753.     sstr2 = strlen(bstr);
  2754.     if ( sstr1 <= sstr2 && !str_cmp( astr, bstr + sstr2 - sstr1 ) )
  2755. return FALSE;
  2756.     else
  2757. return TRUE;
  2758. }
  2762. /*
  2763.  * Returns an initial-capped string.
  2764.  */
  2765. char *capitalize( const char *str )
  2766. {
  2767.     static char strcap[MAX_STRING_LENGTH];
  2768.     int i;
  2770.     for ( i = 0; str[i] != ''; i++ )
  2771. strcap[i] = LOWER(str[i]);
  2772.     strcap[i] = '';
  2773.     strcap[0] = UPPER(strcap[0]);
  2774.     return strcap;
  2775. }
  2779. /*
  2780.  * Append a string to a file.
  2781.  */
  2782. void append_file( CHAR_DATA *ch, char *file, char *str )
  2783. {
  2784.     FILE *fp;
  2786.     if ( IS_NPC(ch) || str[0] == '' )
  2787. return;
  2789.     fclose( fpReserve );
  2790.     if ( ( fp = fopen( file, "a" ) ) == NULL )
  2791.     {
  2792. perror( file );
  2793. send_to_char( "Could not open the file!nr", ch );
  2794.     }
  2795.     else
  2796.     {
  2797. fprintf( fp, "[%5d] %s: %sn",
  2798.     ch->in_room ? ch->in_room->vnum : 0, ch->name, str );
  2799. fclose( fp );
  2800.     }
  2802.     fpReserve = fopen( NULL_FILE, "r" );
  2803.     return;
  2804. }
  2807. #if 0
  2808. /*
  2809.  * Reports a bug.
  2810.  */
  2811. void bug( const char *str, int param )
  2812. {
  2813.     char buf[MAX_STRING_LENGTH];
  2814.     FILE *fp;
  2816.     if ( fpArea != NULL )
  2817.     {
  2818. int iLine;
  2819. int iChar;
  2821. if ( fpArea == stdin )
  2822. {
  2823.     iLine = 0;
  2824. }
  2825. else
  2826. {
  2827.     iChar = ftell( fpArea );
  2828.     fseek( fpArea, 0, 0 );
  2829.     for ( iLine = 0; ftell( fpArea ) < iChar; iLine++ )
  2830.     {
  2831. while ( getc( fpArea ) != 'n' )
  2832.     ;
  2833.     }
  2834.     fseek( fpArea, iChar, 0 );
  2835. }
  2837. sprintf( buf, "[*****] FILE: %s LINE: %d", strArea, iLine );
  2838. log_string( buf );
  2840. if ( ( fp = fopen( "shutdown.txt", "a" ) ) != NULL )
  2841. {
  2842.     fprintf( fp, "[*****] %sn", buf );
  2843.     fclose( fp );
  2844. }
  2845.     }
  2847.     strcpy( buf, "[*****] BUG: " );
  2848.     sprintf( buf + strlen(buf), str, param );
  2849.     log_string( buf );
  2851.     fclose( fpReserve );
  2852.     if ( ( fp = fopen( BUG_FILE, "a" ) ) != NULL )
  2853.     {
  2854. fprintf( fp, "%sn", buf );
  2855. fclose( fp );
  2856.     }
  2857.     fpReserve = fopen( NULL_FILE, "r" );
  2859.     MessageBox(0, buf, "Merc2.2 server", MB_ICONHAND|MB_OK);
  2860.     DebugBreak();
  2862.     return;
  2863. }
  2864. #endif
  2866. #ifdef SINGLEUSER
  2867. /*
  2868.  * Writes a string to the log.
  2869.  */
  2870. void log_string( const char *str )
  2871. {
  2872.     char *strtime;
  2874.     strtime                    = ctime( &current_time );
  2875.     strtime[strlen(strtime)-1] = '';
  2876.     fprintf( stderr, "%s :: %sn", strtime, str );
  2877.     return;
  2878. }
  2879. #endif
  2882. /*
  2883.  * This function is here to aid in debugging.
  2884.  * If the last expression in a function is another function call,
  2885.  *   gcc likes to generate a JMP instead of a CALL.
  2886.  * This is called "tail chaining."
  2887.  * It hoses the debugger call stack for that call.
  2888.  * So I make this the last call in certain critical functions,
  2889.  *   where I really need the call stack to be right for debugging!
  2890.  *
  2891.  * If you don't understand this, then LEAVE IT ALONE.
  2892.  * Don't remove any calls to tail_chain anywhere.
  2893.  *
  2894.  * -- Furey
  2895.  */
  2896. void tail_chain( void )
  2897. {
  2898.     return;
  2899. }
  2901. /*
  2902.  * MOBprogram code block
  2903. */
  2904. /* the functions */
  2906. /* This routine transfers between alpha and numeric forms of the
  2907.  *  mob_prog bitvector types. This allows the use of the words in the
  2908.  *  mob/script files.
  2909.  */
  2910. int mprog_name_to_type (name) char* name;
  2911. {
  2912.    if (!str_cmp(name,"in_file_prog")) return IN_FILE_PROG;
  2913.    if (!str_cmp(name,"act_prog")) return ACT_PROG;
  2914.    if (!str_cmp(name,"speech_prog")) return SPEECH_PROG;
  2915.    if (!str_cmp(name,"rand_prog")) return RAND_PROG;
  2916.    if (!str_cmp(name,"fight_prog")) return FIGHT_PROG;
  2917.    if (!str_cmp(name,"hitprcnt_prog")) return HITPRCNT_PROG;
  2918.    if (!str_cmp(name,"death_prog")) return DEATH_PROG;
  2919.    if (!str_cmp(name,"entry_prog")) return ENTRY_PROG;
  2920.    if (!str_cmp(name,"greet_prog")) return GREET_PROG;
  2921.    if (!str_cmp(name,"all_greet_prog")) return ALL_GREET_PROG;
  2922.    if (!str_cmp(name,"give_prog")) return GIVE_PROG;
  2923.    if (!str_cmp(name,"bribe_prog")) return BRIBE_PROG;
  2924.    return(ERROR_PROG);
  2925. }
  2927. /* This routine reads in scripts of MOBprograms from a file */
  2928. MPROG_DATA* mprog_file_read(f, mprg, pMobIndex)
  2929. char* f;
  2930. MPROG_DATA* mprg;
  2931. MOB_INDEX_DATA* pMobIndex;
  2932. {
  2933.   MPROG_DATA* mprg2;
  2934.   FILE * progfile;
  2935.   char letter;
  2936.   bool done=FALSE;
  2937.   char MOBProgfile[MAX_INPUT_LENGTH];
  2939.   sprintf( MOBProgfile, "%s%s", MOB_DIR, f );
  2940.   progfile=fopen(MOBProgfile,"r");
  2941.   if (!progfile)
  2942.   {
  2943.      bug("Mob:%d couldnt open mobprog file",pMobIndex->vnum);
  2944.      exit( 1 );
  2945.   }
  2946.   mprg2=mprg;
  2947.   switch (letter=fread_letter(progfile))
  2948.   {
  2949.     case '>':
  2950.      break;
  2951.     case '|':
  2952.        bug("empty mobprog file.", 0);
  2953.        exit( 1 );
  2954.      break;
  2955.     default:
  2956.        bug("in mobprog file syntax error.", 0);
  2957.        exit( 1 );
  2958.      break;
  2959.   }
  2960.   while (!done)
  2961.   {
  2962.   mprg2->type=mprog_name_to_type(fread_word(progfile));
  2963.     switch (mprg2->type)
  2964.     {
  2965.      case ERROR_PROG:
  2966.         bug( "mobprog file type error", 0 );
  2967.         exit( 1 );
  2968.       break;
  2969.      case IN_FILE_PROG:
  2970.         bug( "mprog file contains a call to file.", 0 );
  2971.         exit( 1 );
  2972.       break;
  2973.      default:
  2974.         pMobIndex->progtypes = pMobIndex->progtypes | mprg2->type;
  2975.         mprg2->arglist=fread_string(progfile);
  2976.         mprg2->comlist=fread_string(progfile);
  2977.         switch (letter=fread_letter(progfile))
  2978.         {
  2979.           case '>':
  2980.              mprg2->next=(MPROG_DATA *)alloc_perm(sizeof(MPROG_DATA));
  2981.              mprg2=mprg2->next;
  2982.              mprg2->next=NULL;
  2983.            break;
  2984.           case '|':
  2985.              done=TRUE;
  2986.            break;
  2987.           default:
  2988.              bug( "in mobprog file syntax error.",0);
  2989.              exit( 1 );
  2990.            break;
  2991.         }
  2992.       break;
  2993.     }
  2994.   }
  2995.   fclose(progfile);
  2996.   return mprg2;
  2997. }
  3000. /* Snarf a MOBprogram section from the area file.
  3001.  */
  3002. void load_mobprogs(fp) FILE * fp;
  3003. {
  3004. char letter;
  3005. MOB_INDEX_DATA * iMob;
  3006. int value;
  3007. MPROG_DATA* original;
  3008. MPROG_DATA* working;
  3010. for (;;) switch (letter=fread_letter( fp))
  3011.   {
  3012.   default:
  3013.      bug( "Load_mobprogs: bad command '%c'.",letter);
  3014.      exit(1);
  3015.    break;
  3016.   case 'S':
  3017.   case 's':
  3018.      fread_to_eol(fp); 
  3019.      return;
  3020.   case '*':
  3021.      fread_to_eol(fp); 
  3022.      break;
  3023.   case 'M':
  3024.   case 'm':
  3025.    value=fread_number(fp);
  3026.    if ((iMob=get_mob_index(value))==NULL)
  3027.      {
  3028.       bug( "Load_mobprogs: vnum %d doesnt exist", value );
  3029.       exit( 1 );
  3030.      }
  3031.     
  3032.      if (original=iMob->mobprogs)
  3033.        for (;original->next!=NULL; original=original->next);
  3034.      working=(MPROG_DATA *)alloc_perm(sizeof(MPROG_DATA));
  3035.      if (original) original->next=working;
  3036.      else iMob->mobprogs=working;
  3037.      working=mprog_file_read(fread_word(fp),working,iMob);
  3038.      working->next=NULL;
  3039.      fread_to_eol(fp);
  3040.      break;
  3041.    }
  3042. } 
  3044. /* This procedure is responsible for reading any in_file MOBprograms.
  3045.  */
  3046. void mprog_read_programs(fp,pMobIndex) FILE* fp; MOB_INDEX_DATA * pMobIndex;
  3047. {
  3048. MPROG_DATA * mprg;
  3049. bool done=FALSE;
  3050. char letter;
  3051.   if ( (letter=fread_letter(fp)) != '>' )
  3052.   {
  3053.       bug( "Load_mobiles: vnum %d MOBPROG char", pMobIndex->vnum );
  3054.       exit( 1 );
  3055.   }
  3056.   pMobIndex->mobprogs=(MPROG_DATA *)alloc_perm(sizeof(MPROG_DATA));
  3057.   mprg=pMobIndex->mobprogs;
  3058.   while (!done)
  3059.   {
  3060.     mprg->type=mprog_name_to_type(fread_word(fp));
  3061.     switch (mprg->type)
  3062.     {
  3063.      case ERROR_PROG:
  3064.         bug( "Load_mobiles: vnum %d MOBPROG type.", pMobIndex->vnum );
  3065.         exit( 1 );
  3066.       break;
  3067.      case IN_FILE_PROG:
  3068.         mprg=mprog_file_read(fread_string(fp),mprg,pMobIndex);
  3069.         fread_to_eol(fp);
  3070.         switch (letter=fread_letter(fp))
  3071.         {
  3072.           case '>':
  3073.              mprg->next=(MPROG_DATA *)alloc_perm(sizeof(MPROG_DATA));
  3074.              mprg=mprg->next;
  3075.              mprg->next=NULL;
  3076.            break;
  3077.           case '|':
  3078.              mprg->next=NULL;
  3079.              fread_to_eol(fp);
  3080.              done=TRUE;
  3081.            break;
  3082.           default:
  3083.              bug( "Load_mobiles: vnum %d bad MOBPROG.", pMobIndex->vnum );
  3084.              exit( 1 );
  3085.            break;
  3086.         }
  3087.       break;
  3088.      default:
  3089.         pMobIndex->progtypes = pMobIndex->progtypes | mprg->type;
  3090.         mprg->arglist=fread_string(fp);
  3091.         fread_to_eol(fp);
  3092.         mprg->comlist=fread_string(fp);
  3093.         fread_to_eol(fp);
  3094.         switch (letter=fread_letter(fp))
  3095.         {
  3096.           case '>':
  3097.              mprg->next=(MPROG_DATA *)alloc_perm(sizeof(MPROG_DATA));
  3098.              mprg=mprg->next;
  3099.              mprg->next=NULL;
  3100.            break;
  3101.           case '|':
  3102.              mprg->next=NULL;
  3103.              fread_to_eol(fp);
  3104.              done=TRUE;
  3105.            break;
  3106.           default:
  3107.              bug( "Load_mobiles: vnum %d bad MOBPROG.", pMobIndex->vnum );
  3108.              exit( 1 );
  3109.            break;
  3110.         }
  3111.       break;
  3112.     }
  3113.   }
  3114. }