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

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

Internet/网络编程

开发平台：

WINDOWS

MOB_PROG.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. /***************************************************************************
  19.  *  The MOBprograms have been contributed by N'Atas-ha.  Any support for   *
  20.  *  these routines should not be expected from Merc Industries.  However,  *
  21.  *  under no circumstances should the blame for bugs, etc be placed on     *
  22.  *  Merc Industries.  They are not guaranteed to work on all systems due   *
  23.  *  to their frequent use of strxxx functions.  They are also not the most *
  24.  *  efficient way to perform their tasks, but hopefully should be in the   *
  25.  *  easiest possible way to install and begin using. Documentation for     *
  26.  *  such installation can be found in INSTALL.  Enjoy...         N'Atas-Ha *
  27.  ***************************************************************************/
  29. #include <sys/types.h>
  30. #include <stdio.h>
  31. #include <string.h>
  32. #include <stdlib.h>
  33. #include <ctype.h>
  34. #include "merc.h"
  36. /*
  37.  * Local function prototypes
  38.  */
  40. char * mprog_next_command args( ( char* clist ) );
  41. bool mprog_seval args( ( char* lhs, char* opr, char* rhs ) );
  42. bool mprog_veval args( ( int lhs, char* opr, int rhs ) );
  43. bool mprog_do_ifchck args( ( char* ifchck, CHAR_DATA* mob,
  44.        CHAR_DATA* actor, OBJ_DATA* obj,
  45.        void* vo, CHAR_DATA* rndm ) );
  46. char * mprog_process_if args( ( char* ifchck, char* com_list, 
  47.        CHAR_DATA* mob, CHAR_DATA* actor,
  48.        OBJ_DATA* obj, void* vo,
  49.        CHAR_DATA* rndm ) );
  50. void mprog_translate args( ( char ch, char* t, CHAR_DATA* mob,
  51.        CHAR_DATA* actor, OBJ_DATA* obj,
  52.        void* vo, CHAR_DATA* rndm ) );
  53. void mprog_process_cmnd args( ( char* cmnd, CHAR_DATA* mob, 
  54.        CHAR_DATA* actor, OBJ_DATA* obj,
  55.        void* vo, CHAR_DATA* rndm ) );
  56. void mprog_driver args( ( char* com_list, CHAR_DATA* mob,
  57.        CHAR_DATA* actor, OBJ_DATA* obj,
  58.        void* vo ) );
  60. /***************************************************************************
  61.  * Local function code and brief comments.
  62.  */
  64. /* if you dont have these functions, you damn well should... */
  66. #ifdef DUNNO_STRSTR
  67. char * strstr(s1,s2) const char *s1; const char *s2;
  68. {
  69.   char *cp;
  70.   int i,j=strlen(s1)-strlen(s2),k=strlen(s2);
  71.   if(j<0)
  72.     return NULL;
  73.   for(i=0; i<=j && strncmp(s1++,s2, k)!=0; i++);
  74.   return (i>j) ? NULL : (s1-1);
  75. }
  76. #endif
  78. /* Used to get sequential lines of a multi line string (separated by "nr")
  79.  * Thus its like one_argument(), but a trifle different. It is destructive
  80.  * to the multi line string argument, and thus clist must not be shared.
  81.  */
  82. char *mprog_next_command( char *clist )
  83. {
  85.   char *pointer = clist;
  87.   while ( *pointer != 'n' && *pointer != '' )
  88.     pointer++;
  89.   if ( *pointer == 'n' )
  90.     *pointer++ = '';
  91.   if ( *pointer == 'r' )
  92.     *pointer++ = '';
  94.   return ( pointer );
  96. }
  98. /* These two functions do the basic evaluation of ifcheck operators.
  99.  *  It is important to note that the string operations are not what
  100.  *  you probably expect.  Equality is exact and division is substring.
  101.  *  remember that lhs has been stripped of leading space, but can
  102.  *  still have trailing spaces so be careful when editing since:
  103.  *  "guard" and "guard " are not equal.
  104.  */
  105. bool mprog_seval( char *lhs, char *opr, char *rhs )
  106. {
  108.   if ( !str_cmp( opr, "==" ) )
  109.     return ( bool )( !str_cmp( lhs, rhs ) );
  110.   if ( !str_cmp( opr, "!=" ) )
  111.     return ( bool )( str_cmp( lhs, rhs ) );
  112.   if ( !str_cmp( opr, "/" ) )
  113.     return ( bool )( !str_infix( rhs, lhs ) );
  114.   if ( !str_cmp( opr, "!/" ) )
  115.     return ( bool )( str_infix( rhs, lhs ) );
  117.   bug ( "Improper MOBprog operatornr", 0 );
  118.   return 0;
  120. }
  122. bool mprog_veval( int lhs, char *opr, int rhs )
  123. {
  125.   if ( !str_cmp( opr, "==" ) )
  126.     return ( lhs == rhs );
  127.   if ( !str_cmp( opr, "!=" ) )
  128.     return ( lhs != rhs );
  129.   if ( !str_cmp( opr, ">" ) )
  130.     return ( lhs > rhs );
  131.   if ( !str_cmp( opr, "<" ) )
  132.     return ( lhs < rhs );
  133.   if ( !str_cmp( opr, ">=" ) )
  134.     return ( lhs <= rhs );
  135.   if ( !str_cmp( opr, ">=" ) )
  136.     return ( lhs >= rhs );
  137.   if ( !str_cmp( opr, "&" ) )
  138.     return ( lhs & rhs );
  139.   if ( !str_cmp( opr, "|" ) )
  140.     return ( lhs | rhs );
  142.   bug ( "Improper MOBprog operatornr", 0 );
  143.   return 0;
  145. }
  147. /* This function performs the evaluation of the if checks.  It is
  148.  * here that you can add any ifchecks which you so desire. Hopefully
  149.  * it is clear from what follows how one would go about adding your
  150.  * own. The syntax for an if check is: ifchck ( arg ) [opr val]
  151.  * where the parenthesis are required and the opr and val fields are
  152.  * optional but if one is there then both must be. The spaces are all
  153.  * optional. The evaluation of the opr expressions is farmed out
  154.  * to reduce the redundancy of the mammoth if statement list.
  155.  * If there are errors, then return -1 otherwise return boolean 1,0
  156.  */
  157. bool mprog_do_ifchck( char *ifchck, CHAR_DATA *mob, CHAR_DATA *actor,
  158.      OBJ_DATA *obj, void *vo, CHAR_DATA *rndm)
  159. {
  161.   char buf[ MAX_INPUT_LENGTH ];
  162.   char arg[ MAX_INPUT_LENGTH ];
  163.   char opr[ MAX_INPUT_LENGTH ];
  164.   char val[ MAX_INPUT_LENGTH ];
  165.   CHAR_DATA *vict = (CHAR_DATA *) vo;
  166.   OBJ_DATA *v_obj = (OBJ_DATA  *) vo;
  167.   char     *bufpt = buf;
  168.   char     *argpt = arg;
  169.   char     *oprpt = opr;
  170.   char     *valpt = val;
  171.   char     *point = ifchck;
  172.   int       lhsvl;
  173.   int       rhsvl;
  175.   if ( *point == '' ) 
  176.     {
  177.       bug ( "Mob: %d null ifchck", mob->pIndexData->vnum ); 
  178.       return -1;
  179.     }   
  180.   /* skip leading spaces */
  181.   while ( *point == ' ' )
  182.     point++;
  184.   /* get whatever comes before the left paren.. ignore spaces */
  185.   while ( *point != '(' ) 
  186.     if ( *point == '' ) 
  187.       {
  188. bug ( "Mob: %d ifchck syntax error", mob->pIndexData->vnum ); 
  189. return -1;
  190.       }   
  191.     else
  192.       if ( *point == ' ' )
  193. point++;
  194.       else 
  195. *bufpt++ = *point++; 
  197.   *bufpt = '';
  198.   point++;
  200.   /* get whatever is in between the parens.. ignore spaces */
  201.   while ( *point != ')' ) 
  202.     if ( *point == '' ) 
  203.       {
  204. bug ( "Mob: %d ifchck syntax error", mob->pIndexData->vnum ); 
  205. return -1;
  206.       }   
  207.     else
  208.       if ( *point == ' ' )
  209. point++;
  210.       else 
  211. *argpt++ = *point++; 
  213.   *argpt = '';
  214.   point++;
  216.   /* check to see if there is an operator */
  217.   while ( *point == ' ' )
  218.     point++;
  219.   if ( *point == '' ) 
  220.     {
  221.       *opr = '';
  222.       *val = '';
  223.     }   
  224.   else /* there should be an operator and value, so get them */
  225.     {
  226.       while ( ( *point != ' ' ) && ( !isalnum( *point ) ) ) 
  227. if ( *point == '' ) 
  228.   {
  229.     bug ( "Mob: %d ifchck operator without value",
  230.  mob->pIndexData->vnum ); 
  231.     return -1;
  232.   }   
  233. else
  234.   *oprpt++ = *point++; 
  236.       *oprpt = '';
  237.  
  238.       /* finished with operator, skip spaces and then get the value */
  239.       while ( *point == ' ' )
  240. point++;
  241.       for( ; ; )
  242. {
  243.   if ( ( *point != ' ' ) && ( *point == '' ) )
  244.     break;
  245.   else
  246.     *valpt++ = *point++; 
  247. }
  249.       *valpt = '';
  250.     }
  251.   bufpt = buf;
  252.   argpt = arg;
  253.   oprpt = opr;
  254.   valpt = val;
  256.   /* Ok... now buf contains the ifchck, arg contains the inside of the
  257.    *  parentheses, opr contains an operator if one is present, and val
  258.    *  has the value if an operator was present.
  259.    *  So.. basically use if statements and run over all known ifchecks
  260.    *  Once inside, use the argument and expand the lhs. Then if need be
  261.    *  send the lhs,opr,rhs off to be evaluated.
  262.    */
  264.   if ( !str_cmp( buf, "rand" ) )
  265.     {
  266.       return ( number_percent() <= atoi(arg) );
  267.     }
  269.   if ( !str_cmp( buf, "ispc" ) )
  270.     {
  271.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  272. {
  273. case 'i': return 0;
  274. case 'n': if ( actor )
  275.                return ( !IS_NPC( actor ) );
  276.           else return -1;
  277. case 't': if ( vict )
  278.                      return ( !IS_NPC( vict ) );
  279.           else return -1;
  280. case 'r': if ( rndm )
  281.                      return ( !IS_NPC( rndm ) );
  282.           else return -1;
  283. default:
  284.   bug ( "Mob: %d bad argument to 'ispc'", mob->pIndexData->vnum ); 
  285.   return -1;
  286. }
  287.     }
  289.   if ( !str_cmp( buf, "isnpc" ) )
  290.     {
  291.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  292. {
  293. case 'i': return 1;
  294. case 'n': if ( actor )
  295.              return IS_NPC( actor );
  296.           else return -1;
  297. case 't': if ( vict )
  298.                      return IS_NPC( vict );
  299.           else return -1;
  300. case 'r': if ( rndm )
  301.              return IS_NPC( rndm );
  302.           else return -1;
  303. default:
  304.   bug ("Mob: %d bad argument to 'isnpc'", mob->pIndexData->vnum ); 
  305.   return -1;
  306. }
  307.     }
  309.   if ( !str_cmp( buf, "isgood" ) )
  310.     {
  311.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  312. {
  313. case 'i': return IS_GOOD( mob );
  314. case 'n': if ( actor )
  315.              return IS_GOOD( actor );
  316.           else return -1;
  317. case 't': if ( vict )
  318.              return IS_GOOD( vict );
  319.           else return -1;
  320. case 'r': if ( rndm )
  321.              return IS_GOOD( rndm );
  322.           else return -1;
  323. default:
  324.   bug ( "Mob: %d bad argument to 'isgood'", mob->pIndexData->vnum ); 
  325.   return -1;
  326. }
  327.     }
  329.   if ( !str_cmp( buf, "isfight" ) )
  330.     {
  331.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  332. {
  333. case 'i': return ( mob->fighting ) ? 1 : 0;
  334. case 'n': if ( actor )
  335.              return ( actor->fighting ) ? 1 : 0;
  336.           else return -1;
  337. case 't': if ( vict )
  338.              return ( vict->fighting ) ? 1 : 0;
  339.           else return -1;
  340. case 'r': if ( rndm )
  341.              return ( rndm->fighting ) ? 1 : 0;
  342.           else return -1;
  343. default:
  344.   bug ( "Mob: %d bad argument to 'isfight'", mob->pIndexData->vnum ); 
  345.   return -1;
  346. }
  347.     }
  349.   if ( !str_cmp( buf, "isimmort" ) )
  350.     {
  351.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  352. {
  353. case 'i': return ( get_trust( mob ) > LEVEL_IMMORTAL );
  354. case 'n': if ( actor )
  355.              return ( get_trust( actor ) > LEVEL_IMMORTAL );
  356.              else return -1;
  357. case 't': if ( vict )
  358.              return ( get_trust( vict ) > LEVEL_IMMORTAL );
  359.                   else return -1;
  360. case 'r': if ( rndm )
  361.              return ( get_trust( rndm ) > LEVEL_IMMORTAL );
  362.                   else return -1;
  363. default:
  364.   bug ( "Mob: %d bad argument to 'isimmort'", mob->pIndexData->vnum ); 
  365.   return -1;
  366. }
  367.     }
  369.   if ( !str_cmp( buf, "ischarmed" ) )
  370.     {
  371.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  372. {
  373. case 'i': return IS_AFFECTED( mob, AFF_CHARM );
  374. case 'n': if ( actor )
  375.              return IS_AFFECTED( actor, AFF_CHARM );
  376.           else return -1;
  377. case 't': if ( vict )
  378.              return IS_AFFECTED( vict, AFF_CHARM );
  379.           else return -1;
  380. case 'r': if ( rndm )
  381.              return IS_AFFECTED( rndm, AFF_CHARM );
  382.           else return -1;
  383. default:
  384.   bug ( "Mob: %d bad argument to 'ischarmed'",
  385.        mob->pIndexData->vnum ); 
  386.   return -1;
  387. }
  388.     }
  390.   if ( !str_cmp( buf, "isfollow" ) )
  391.     {
  392.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  393. {
  394. case 'i': return ( mob->master != NULL
  395.   && mob->master->in_room == mob->in_room );
  396. case 'n': if ( actor )
  397.              return ( actor->master != NULL
  398.      && actor->master->in_room == actor->in_room );
  399.           else return -1;
  400. case 't': if ( vict )
  401.              return ( vict->master != NULL
  402.      && vict->master->in_room == vict->in_room );
  403.           else return -1;
  404. case 'r': if ( rndm )
  405.              return ( rndm->master != NULL
  406.      && rndm->master->in_room == rndm->in_room );
  407.           else return -1;
  408. default:
  409.   bug ( "Mob: %d bad argument to 'isfollow'", mob->pIndexData->vnum ); 
  410.   return -1;
  411. }
  412.     }
  414.   if ( !str_cmp( buf, "isaffected" ) )
  415.     {
  416.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  417. {
  418. case 'i': return ( mob->affected_by & atoi( arg ) );
  419. case 'n': if ( actor )
  420.              return ( actor->affected_by & atoi( arg ) );
  421.           else return -1;
  422. case 't': if ( vict )
  423.              return ( vict->affected_by & atoi( arg ) );
  424.           else return -1;
  425. case 'r': if ( rndm )
  426.              return ( rndm->affected_by & atoi( arg ) );
  427.           else return -1;
  428. default:
  429.   bug ( "Mob: %d bad argument to 'isaffected'",
  430.        mob->pIndexData->vnum ); 
  431.   return -1;
  432. }
  433.     }
  435.   if ( !str_cmp( buf, "hitprcnt" ) )
  436.     {
  437.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  438. {
  439. case 'i': lhsvl = mob->hit / mob->max_hit;
  440.           rhsvl = atoi( val );
  441.             return mprog_veval( lhsvl, opr, rhsvl );
  442. case 'n': if ( actor )
  443.           {
  444.     lhsvl = actor->hit / actor->max_hit;
  445.     rhsvl = atoi( val );
  446.     return mprog_veval( lhsvl, opr, rhsvl );
  447.   }
  448.           else
  449.     return -1;
  450. case 't': if ( vict )
  451.           {
  452.     lhsvl = vict->hit / vict->max_hit;
  453.     rhsvl = atoi( val );
  454.     return mprog_veval( lhsvl, opr, rhsvl );
  455.   }
  456.           else
  457.     return -1;
  458. case 'r': if ( rndm )
  459.           {
  460.     lhsvl = rndm->hit / rndm->max_hit;
  461.     rhsvl = atoi( val );
  462.     return mprog_veval( lhsvl, opr, rhsvl );
  463.   }
  464.           else
  465.     return -1;
  466. default:
  467.   bug ( "Mob: %d bad argument to 'hitprcnt'", mob->pIndexData->vnum ); 
  468.   return -1;
  469. }
  470.     }
  472.   if ( !str_cmp( buf, "inroom" ) )
  473.     {
  474.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  475. {
  476. case 'i': lhsvl = mob->in_room->vnum;
  477.           rhsvl = atoi(val);
  478.           return mprog_veval( lhsvl, opr, rhsvl );
  479. case 'n': if ( actor )
  480.           {
  481.     lhsvl = actor->in_room->vnum;
  482.     rhsvl = atoi( val );
  483.     return mprog_veval( lhsvl, opr, rhsvl );
  484.   }
  485.           else
  486.     return -1;
  487. case 't': if ( vict )
  488.           {
  489.     lhsvl = vict->in_room->vnum;
  490.     rhsvl = atoi( val );
  491.     return mprog_veval( lhsvl, opr, rhsvl );
  492.   }
  493.           else
  494.     return -1;
  495. case 'r': if ( rndm )
  496.           {
  497.     lhsvl = rndm->in_room->vnum;
  498.     rhsvl = atoi( val );
  499.     return mprog_veval( lhsvl, opr, rhsvl );
  500.   }
  501.           else
  502.     return -1;
  503. default:
  504.   bug ( "Mob: %d bad argument to 'inroom'", mob->pIndexData->vnum ); 
  505.   return -1;
  506. }
  507.     }
  509.   if ( !str_cmp( buf, "sex" ) )
  510.     {
  511.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  512. {
  513. case 'i': lhsvl = mob->sex;
  514.           rhsvl = atoi( val );
  515.           return mprog_veval( lhsvl, opr, rhsvl );
  516. case 'n': if ( actor )
  517.           {
  518.     lhsvl = actor->sex;
  519.     rhsvl = atoi( val );
  520.     return mprog_veval( lhsvl, opr, rhsvl );
  521.   }
  522.           else
  523.     return -1;
  524. case 't': if ( vict )
  525.           {
  526.     lhsvl = vict->sex;
  527.     rhsvl = atoi( val );
  528.     return mprog_veval( lhsvl, opr, rhsvl );
  529.   }
  530.           else
  531.     return -1;
  532. case 'r': if ( rndm )
  533.           {
  534.     lhsvl = rndm->sex;
  535.     rhsvl = atoi( val );
  536.     return mprog_veval( lhsvl, opr, rhsvl );
  537.   }
  538.           else
  539.     return -1;
  540. default:
  541.   bug ( "Mob: %d bad argument to 'sex'", mob->pIndexData->vnum ); 
  542.   return -1;
  543. }
  544.     }
  546.   if ( !str_cmp( buf, "position" ) )
  547.     {
  548.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  549. {
  550. case 'i': lhsvl = mob->position;
  551.           rhsvl = atoi( val );
  552.           return mprog_veval( lhsvl, opr, rhsvl );
  553. case 'n': if ( actor )
  554.           {
  555.     lhsvl = actor->position;
  556.     rhsvl = atoi( val );
  557.     return mprog_veval( lhsvl, opr, rhsvl );
  558.   }
  559.           else
  560.     return -1;
  561. case 't': if ( vict )
  562.           {
  563.     lhsvl = vict->position;
  564.     rhsvl = atoi( val );
  565.     return mprog_veval( lhsvl, opr, rhsvl );
  566.   }
  567.           else
  568.     return -1;
  569. case 'r': if ( rndm )
  570.           {
  571.     lhsvl = rndm->position;
  572.     rhsvl = atoi( val );
  573.     return mprog_veval( lhsvl, opr, rhsvl );
  574.   }
  575.           else
  576.     return -1;
  577. default:
  578.   bug ( "Mob: %d bad argument to 'position'", mob->pIndexData->vnum ); 
  579.   return -1;
  580. }
  581.     }
  583.   if ( !str_cmp( buf, "level" ) )
  584.     {
  585.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  586. {
  587. case 'i': lhsvl = get_trust( mob );
  588.           rhsvl = atoi( val );
  589.           return mprog_veval( lhsvl, opr, rhsvl );
  590. case 'n': if ( actor )
  591.           {
  592.     lhsvl = get_trust( actor );
  593.     rhsvl = atoi( val );
  594.     return mprog_veval( lhsvl, opr, rhsvl );
  595.   }
  596.           else 
  597.     return -1;
  598. case 't': if ( vict )
  599.           {
  600.     lhsvl = get_trust( vict );
  601.     rhsvl = atoi( val );
  602.     return mprog_veval( lhsvl, opr, rhsvl );
  603.   }
  604.           else
  605.     return -1;
  606. case 'r': if ( rndm )
  607.           {
  608.     lhsvl = get_trust( rndm );
  609.     rhsvl = atoi( val );
  610.     return mprog_veval( lhsvl, opr, rhsvl );
  611.   }
  612.           else
  613.     return -1;
  614. default:
  615.   bug ( "Mob: %d bad argument to 'level'", mob->pIndexData->vnum ); 
  616.   return -1;
  617. }
  618.     }
  620.   if ( !str_cmp( buf, "class" ) )
  621.     {
  622.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  623. {
  624. case 'i': lhsvl = mob->class;
  625.           rhsvl = atoi( val );
  626.                   return mprog_veval( lhsvl, opr, rhsvl );
  627. case 'n': if ( actor )
  628.           {
  629.     lhsvl = actor->class;
  630.     rhsvl = atoi( val );
  631.     return mprog_veval( lhsvl, opr, rhsvl );
  632.   }
  633.           else 
  634.     return -1;
  635. case 't': if ( vict )
  636.           {
  637.     lhsvl = vict->class;
  638.     rhsvl = atoi( val );
  639.     return mprog_veval( lhsvl, opr, rhsvl );
  640.   }
  641.           else
  642.     return -1;
  643. case 'r': if ( rndm )
  644.           {
  645.     lhsvl = rndm->class;
  646.     rhsvl = atoi( val );
  647.     return mprog_veval( lhsvl, opr, rhsvl );
  648.   }
  649.           else
  650.     return -1;
  651. default:
  652.   bug ( "Mob: %d bad argument to 'class'", mob->pIndexData->vnum ); 
  653.   return -1;
  654. }
  655.     }
  657.   if ( !str_cmp( buf, "goldamt" ) )
  658.     {
  659.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  660. {
  661. case 'i': lhsvl = mob->gold;
  662.                   rhsvl = atoi( val );
  663.                   return mprog_veval( lhsvl, opr, rhsvl );
  664. case 'n': if ( actor )
  665.           {
  666.     lhsvl = actor->gold;
  667.     rhsvl = atoi( val );
  668.     return mprog_veval( lhsvl, opr, rhsvl );
  669.   }
  670.           else
  671.     return -1;
  672. case 't': if ( vict )
  673.           {
  674.     lhsvl = vict->gold;
  675.     rhsvl = atoi( val );
  676.     return mprog_veval( lhsvl, opr, rhsvl );
  677.   }
  678.           else
  679.     return -1;
  680. case 'r': if ( rndm )
  681.           {
  682.     lhsvl = rndm->gold;
  683.     rhsvl = atoi( val );
  684.     return mprog_veval( lhsvl, opr, rhsvl );
  685.   }
  686.           else
  687.     return -1;
  688. default:
  689.   bug ( "Mob: %d bad argument to 'goldamt'", mob->pIndexData->vnum ); 
  690.   return -1;
  691. }
  692.     }
  694.   if ( !str_cmp( buf, "objtype" ) )
  695.     {
  696.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  697. {
  698. case 'o': if ( obj )
  699.           {
  700.     lhsvl = obj->item_type;
  701.     rhsvl = atoi( val );
  702.     return mprog_veval( lhsvl, opr, rhsvl );
  703.   }
  704.          else
  705.    return -1;
  706. case 'p': if ( v_obj )
  707.           {
  708.     lhsvl = v_obj->item_type;
  709.     rhsvl = atoi( val );
  710.     return mprog_veval( lhsvl, opr, rhsvl );
  711.   }
  712.           else
  713.     return -1;
  714. default:
  715.   bug ( "Mob: %d bad argument to 'objtype'", mob->pIndexData->vnum ); 
  716.   return -1;
  717. }
  718.     }
  720.   if ( !str_cmp( buf, "objval0" ) )
  721.     {
  722.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  723. {
  724. case 'o': if ( obj )
  725.           {
  726.     lhsvl = obj->value[0];
  727.     rhsvl = atoi( val );
  728.     return mprog_veval( lhsvl, opr, rhsvl );
  729.   }
  730.           else
  731.     return -1;
  732. case 'p': if ( v_obj )
  733.           {
  734.     lhsvl = v_obj->value[0];
  735.     rhsvl = atoi( val );
  736.     return mprog_veval( lhsvl, opr, rhsvl );
  737.   }
  738.           else 
  739.     return -1;
  740. default:
  741.   bug ( "Mob: %d bad argument to 'objval0'", mob->pIndexData->vnum ); 
  742.   return -1;
  743. }
  744.     }
  746.   if ( !str_cmp( buf, "objval1" ) )
  747.     {
  748.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  749. {
  750. case 'o': if ( obj )
  751.           {
  752.     lhsvl = obj->value[1];
  753.     rhsvl = atoi( val );
  754.     return mprog_veval( lhsvl, opr, rhsvl );
  755.   }
  756.           else
  757.     return -1;
  758. case 'p': if ( v_obj )
  759.           {
  760.     lhsvl = v_obj->value[1];
  761.     rhsvl = atoi( val );
  762.     return mprog_veval( lhsvl, opr, rhsvl );
  763.   }
  764.           else
  765.     return -1;
  766. default:
  767.   bug ( "Mob: %d bad argument to 'objval1'", mob->pIndexData->vnum ); 
  768.   return -1;
  769. }
  770.     }
  772.   if ( !str_cmp( buf, "objval2" ) )
  773.     {
  774.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  775. {
  776. case 'o': if ( obj )
  777.           {
  778.     lhsvl = obj->value[2];
  779.     rhsvl = atoi( val );
  780.     return mprog_veval( lhsvl, opr, rhsvl );
  781.   }
  782.           else
  783.     return -1;
  784. case 'p': if ( v_obj )
  785.           {
  786.     lhsvl = v_obj->value[2];
  787.     rhsvl = atoi( val );
  788.     return mprog_veval( lhsvl, opr, rhsvl );
  789.   }
  790.           else
  791.     return -1;
  792. default:
  793.   bug ( "Mob: %d bad argument to 'objval2'", mob->pIndexData->vnum ); 
  794.   return -1;
  795. }
  796.     }
  798.   if ( !str_cmp( buf, "objval3" ) )
  799.     {
  800.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  801. {
  802. case 'o': if ( obj )
  803.           {
  804.     lhsvl = obj->value[3];
  805.     rhsvl = atoi( val );
  806.     return mprog_veval( lhsvl, opr, rhsvl );
  807.   }
  808.           else
  809.     return -1;
  810. case 'p': if ( v_obj ) 
  811.           {
  812.     lhsvl = v_obj->value[3];
  813.     rhsvl = atoi( val );
  814.     return mprog_veval( lhsvl, opr, rhsvl );
  815.   }
  816.           else
  817.     return -1;
  818. default:
  819.   bug ( "Mob: %d bad argument to 'objval3'", mob->pIndexData->vnum ); 
  820.   return -1;
  821. }
  822.     }
  824.   if ( !str_cmp( buf, "number" ) )
  825.     {
  826.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  827. {
  828. case 'i': lhsvl = mob->gold;
  829.           rhsvl = atoi( val );
  830.           return mprog_veval( lhsvl, opr, rhsvl );
  831. case 'n': if ( actor )
  832.           {
  833.     if IS_NPC( actor )
  834.     {
  835.       lhsvl = actor->pIndexData->vnum;
  836.       rhsvl = atoi( val );
  837.       return mprog_veval( lhsvl, opr, rhsvl );
  838.     }
  839.   }
  840.           else
  841.     return -1;
  842. case 't': if ( vict )
  843.           {
  844.     if IS_NPC( actor )
  845.     {
  846.       lhsvl = vict->pIndexData->vnum;
  847.       rhsvl = atoi( val );
  848.       return mprog_veval( lhsvl, opr, rhsvl );
  849.     }
  850.   }
  851.                   else
  852.     return -1;
  853. case 'r': if ( rndm )
  854.           {
  855.     if IS_NPC( actor )
  856.     {
  857.       lhsvl = rndm->pIndexData->vnum;
  858.       rhsvl = atoi( val );
  859.       return mprog_veval( lhsvl, opr, rhsvl );
  860.     }
  861.   }
  862.          else return -1;
  863. case 'o': if ( obj )
  864.           {
  865.     lhsvl = obj->pIndexData->vnum;
  866.     rhsvl = atoi( val );
  867.     return mprog_veval( lhsvl, opr, rhsvl );
  868.   }
  869.           else
  870.     return -1;
  871. case 'p': if ( v_obj )
  872.           {
  873.     lhsvl = v_obj->pIndexData->vnum;
  874.     rhsvl = atoi( val );
  875.     return mprog_veval( lhsvl, opr, rhsvl );
  876.   }
  877.           else
  878.     return -1;
  879. default:
  880.   bug ( "Mob: %d bad argument to 'number'", mob->pIndexData->vnum ); 
  881.   return -1;
  882. }
  883.     }
  885.   if ( !str_cmp( buf, "name" ) )
  886.     {
  887.       switch ( arg[1] )  /* arg should be "$*" so just get the letter */
  888. {
  889. case 'i': return mprog_seval( mob->name, opr, val );
  890. case 'n': if ( actor )
  891.             return mprog_seval( actor->name, opr, val );
  892.           else
  893.     return -1;
  894. case 't': if ( vict )
  895.             return mprog_seval( vict->name, opr, val );
  896.           else
  897.     return -1;
  898. case 'r': if ( rndm )
  899.             return mprog_seval( rndm->name, opr, val );
  900.           else
  901.     return -1;
  902. case 'o': if ( obj )
  903.             return mprog_seval( obj->name, opr, val );
  904.           else
  905.     return -1;
  906. case 'p': if ( v_obj )
  907.             return mprog_seval( v_obj->name, opr, val );
  908.           else
  909.     return -1;
  910. default:
  911.   bug ( "Mob: %d bad argument to 'name'", mob->pIndexData->vnum ); 
  912.   return -1;
  913. }
  914.     }
  916.   /* Ok... all the ifchcks are done, so if we didnt find ours then something
  917.    * odd happened.  So report the bug and abort the MOBprogram (return error)
  918.    */
  919.   bug ( "Mob: %d unknown ifchck", mob->pIndexData->vnum ); 
  920.   return -1;
  922. }
  923. /* Quite a long and arduous function, this guy handles the control
  924.  * flow part of MOBprograms.  Basicially once the driver sees an
  925.  * 'if' attention shifts to here.  While many syntax errors are
  926.  * caught, some will still get through due to the handling of break
  927.  * and errors in the same fashion.  The desire to break out of the
  928.  * recursion without catastrophe in the event of a mis-parse was
  929.  * believed to be high. Thus, if an error is found, it is bugged and
  930.  * the parser acts as though a break were issued and just bails out
  931.  * at that point. I havent tested all the possibilites, so I'm speaking
  932.  * in theory, but it is 'guaranteed' to work on syntactically correct
  933.  * MOBprograms, so if the mud crashes here, check the mob carefully!
  934.  */
  935. char *mprog_process_if( char *ifchck, char *com_list, CHAR_DATA *mob,
  936.        CHAR_DATA *actor, OBJ_DATA *obj, void *vo,
  937.        CHAR_DATA *rndm )
  938. {
  940.  char null[ 1 ];
  941.  char buf[ MAX_INPUT_LENGTH ];
  942.  char *morebuf = '';
  943.  char    *cmnd = '';
  944.  bool loopdone = FALSE;
  945.  bool     flag = FALSE;
  946.  int  legal;
  948.  *null = '';
  950.  /* check for trueness of the ifcheck */
  951.  if ( ( legal = mprog_do_ifchck( ifchck, mob, actor, obj, vo, rndm ) ) )
  952.    if ( legal == 1 )
  953.      flag = TRUE;
  954.    else
  955.      return null;
  957.  while( loopdone == FALSE ) /*scan over any existing or statements */
  958.  {
  959.      cmnd     = com_list;
  960.      com_list = mprog_next_command( com_list );
  961.      while ( *cmnd == ' ' )
  962.        cmnd++;
  963.      if ( *cmnd == '' )
  964.      {
  965.  bug ( "Mob: %d no commands after IF/OR", mob->pIndexData->vnum ); 
  966.  return null;
  967.      }
  968.      morebuf = one_argument( cmnd, buf );
  969.      if ( !str_cmp( buf, "or" ) )
  970.      {
  971.  if ( ( legal = mprog_do_ifchck( morebuf,mob,actor,obj,vo,rndm ) ) )
  972.    if ( legal == 1 )
  973.      flag = TRUE;
  974.    else
  975.      return null;
  976.      }
  977.      else
  978.        loopdone = TRUE;
  979.  }
  980.  
  981.  if ( flag )
  982.    for ( ; ; ) /*ifcheck was true, do commands but ignore else to endif*/ 
  983.    {
  984.        if ( !str_cmp( buf, "if" ) )
  985.        { 
  986.    com_list = mprog_process_if(morebuf,com_list,mob,actor,obj,vo,rndm);
  987.    while ( *cmnd==' ' )
  988.      cmnd++;
  989.    if ( *com_list == '' )
  990.      return null;
  991.    cmnd     = com_list;
  992.    com_list = mprog_next_command( com_list );
  993.    morebuf  = one_argument( cmnd,buf );
  994.    continue;
  995.        }
  996.        if ( !str_cmp( buf, "break" ) )
  997.  return null;
  998.        if ( !str_cmp( buf, "endif" ) )
  999.  return com_list; 
  1000.        if ( !str_cmp( buf, "else" ) ) 
  1001.        {
  1002.    while ( str_cmp( buf, "endif" ) ) 
  1003.    {
  1004.        cmnd     = com_list;
  1005.        com_list = mprog_next_command( com_list );
  1006.        while ( *cmnd == ' ' )
  1007.  cmnd++;
  1008.        if ( *cmnd == '' )
  1009.        {
  1010.    bug ( "Mob: %d missing endif after else",
  1011. mob->pIndexData->vnum );
  1012.    return null;
  1013.        }
  1014.        morebuf = one_argument( cmnd,buf );
  1015.    }
  1016.    return com_list; 
  1017.        }
  1018.        mprog_process_cmnd( cmnd, mob, actor, obj, vo, rndm );
  1019.        cmnd     = com_list;
  1020.        com_list = mprog_next_command( com_list );
  1021.        while ( *cmnd == ' ' )
  1022.  cmnd++;
  1023.        if ( *cmnd == '' )
  1024.        {
  1025.            bug ( "Mob: %d missing else or endif", mob->pIndexData->vnum ); 
  1026.            return null;
  1027.        }
  1028.        morebuf = one_argument( cmnd, buf );
  1029.    }
  1030.  else /*false ifcheck, find else and do existing commands or quit at endif*/
  1031.    {
  1032.      while ( ( str_cmp( buf, "else" ) ) && ( str_cmp( buf, "endif" ) ) )
  1033.        {
  1034.  cmnd     = com_list;
  1035.  com_list = mprog_next_command( com_list );
  1036.  while ( *cmnd == ' ' )
  1037.    cmnd++;
  1038.  if ( *cmnd == '' )
  1039.    {
  1040.      bug ( "Mob: %d missing an else or endif",
  1041.   mob->pIndexData->vnum ); 
  1042.      return null;
  1043.    }
  1044.  morebuf = one_argument( cmnd, buf );
  1045.        }
  1047.      /* found either an else or an endif.. act accordingly */
  1048.      if ( !str_cmp( buf, "endif" ) )
  1049.        return com_list;
  1050.      cmnd     = com_list;
  1051.      com_list = mprog_next_command( com_list );
  1052.      while ( *cmnd == ' ' )
  1053.        cmnd++;
  1054.      if ( *cmnd == '' )
  1055.        { 
  1056.  bug ( "Mob: %d missing endif", mob->pIndexData->vnum ); 
  1057.  return null;
  1058.        }
  1059.      morebuf = one_argument( cmnd, buf );
  1060.      
  1061.      for ( ; ; ) /*process the post-else commands until an endif is found.*/
  1062.        {
  1063.  if ( !str_cmp( buf, "if" ) )
  1064.    { 
  1065.      com_list = mprog_process_if( morebuf, com_list, mob, actor,
  1066.  obj, vo, rndm );
  1067.      while ( *cmnd == ' ' )
  1068.        cmnd++;
  1069.      if ( *com_list == '' )
  1070.        return null;
  1071.      cmnd     = com_list;
  1072.      com_list = mprog_next_command( com_list );
  1073.      morebuf  = one_argument( cmnd,buf );
  1074.      continue;
  1075.    }
  1076.  if ( !str_cmp( buf, "else" ) ) 
  1077.    {
  1078.      bug ( "Mob: %d found else in an else section",
  1079.   mob->pIndexData->vnum ); 
  1080.      return null;
  1081.    }
  1082.  if ( !str_cmp( buf, "break" ) )
  1083.    return null;
  1084.  if ( !str_cmp( buf, "endif" ) )
  1085.    return com_list; 
  1086.  mprog_process_cmnd( cmnd, mob, actor, obj, vo, rndm );
  1087.  cmnd     = com_list;
  1088.  com_list = mprog_next_command( com_list );
  1089.  while ( *cmnd == ' ' )
  1090.    cmnd++;
  1091.  if ( *cmnd == '' )
  1092.    {
  1093.      bug ( "Mob:%d missing endif in else section",
  1094.   mob->pIndexData->vnum ); 
  1095.      return null;
  1096.    }
  1097.  morebuf = one_argument( cmnd, buf );
  1098.        }
  1099.    }
  1100. }
  1102. /* This routine handles the variables for command expansion.
  1103.  * If you want to add any go right ahead, it should be fairly
  1104.  * clear how it is done and they are quite easy to do, so you
  1105.  * can be as creative as you want. The only catch is to check
  1106.  * that your variables exist before you use them. At the moment,
  1107.  * using $t when the secondary target refers to an object 
  1108.  * i.e. >prog_act drops~<nl>if ispc($t)<nl>sigh<nl>endif<nl>~<nl>
  1109.  * probably makes the mud crash (vice versa as well) The cure
  1110.  * would be to change act() so that vo becomes vict & v_obj.
  1111.  * but this would require a lot of small changes all over the code.
  1112.  */
  1113. void mprog_translate( char ch, char *t, CHAR_DATA *mob, CHAR_DATA *actor,
  1114.                     OBJ_DATA *obj, void *vo, CHAR_DATA *rndm )
  1115. {
  1116.  static char *he_she        [] = { "it",  "he",  "she" };
  1117.  static char *him_her       [] = { "it",  "him", "her" };
  1118.  static char *his_her       [] = { "its", "his", "her" };
  1119.  CHAR_DATA   *vict             = (CHAR_DATA *) vo;
  1120.  OBJ_DATA    *v_obj            = (OBJ_DATA  *) vo;
  1122.  *t = '';
  1123.  switch ( ch ) {
  1124.      case 'i':
  1125.          one_argument( mob->name, t );
  1126.       break;
  1128.      case 'I':
  1129.          strcpy( t, mob->short_descr );
  1130.       break;
  1132.      case 'n':
  1133.          if ( actor )
  1134.    if ( can_see( mob,actor ) )
  1135.      one_argument( actor->name, t );
  1136.          if ( !IS_NPC( actor ) )
  1137.    *t = UPPER( *t );
  1138.       break;
  1140.      case 'N':
  1141.          if ( actor ) 
  1142.             if ( can_see( mob, actor ) )
  1143.        if ( IS_NPC( actor ) )
  1144.  strcpy( t, actor->short_descr );
  1145.        else
  1146.        {
  1147.    strcpy( t, actor->name );
  1148.    strcat( t, " " );
  1149.    strcat( t, actor->pcdata->title );
  1150.        }
  1151.     else
  1152.       strcpy( t, "someone" );
  1153.  break;
  1155.      case 't':
  1156.          if ( vict )
  1157.    if ( can_see( mob, vict ) )
  1158.      one_argument( vict->name, t );
  1159.          if ( !IS_NPC( vict ) )
  1160.    *t = UPPER( *t );
  1161.  break;
  1163.      case 'T':
  1164.          if ( vict ) 
  1165.             if ( can_see( mob, vict ) )
  1166.        if ( IS_NPC( vict ) )
  1167.  strcpy( t, vict->short_descr );
  1168.        else
  1169.        {
  1170.  strcpy( t, vict->name );
  1171.  strcat( t, " " );
  1172.  strcat( t, vict->pcdata->title );
  1173.        }
  1174.     else
  1175.       strcpy( t, "someone" );
  1176.  break;
  1177.      
  1178.      case 'r':
  1179.          if ( rndm )
  1180.    if ( can_see( mob, rndm ) )
  1181.      one_argument( rndm->name, t );
  1182.          if ( !IS_NPC( rndm ) )
  1183.    *t = UPPER( *t );
  1184.       break;
  1186.      case 'R':
  1187.          if ( rndm ) 
  1188.             if ( can_see( mob, rndm ) )
  1189.        if ( IS_NPC( rndm ) )
  1190.  strcpy(t,rndm->short_descr);
  1191.        else
  1192.        {
  1193.  strcpy( t, rndm->name );
  1194.  strcat( t, " " );
  1195.  strcat( t, rndm->pcdata->title );
  1196.        }
  1197.     else
  1198.       strcpy( t, "someone" );
  1199.  break;
  1201.      case 'e':
  1202.          if ( actor )
  1203.    can_see( mob, actor ) ? strcpy( t, he_she[ actor->sex ] )
  1204.                          : strcpy( t, "someone" );
  1205.  break;
  1206.   
  1207.      case 'm':
  1208.          if ( actor )
  1209.    can_see( mob, actor ) ? strcpy( t, him_her[ actor->sex ] )
  1210.                                  : strcpy( t, "someone" );
  1211.  break;
  1212.   
  1213.      case 's':
  1214.          if ( actor )
  1215.    can_see( mob, actor ) ? strcpy( t, his_her[ actor->sex ] )
  1216.                          : strcpy( t, "someone's" );
  1217.  break;
  1218.      
  1219.      case 'E':
  1220.          if ( vict )
  1221.    can_see( mob, vict ) ? strcpy( t, he_she[ vict->sex ] )
  1222.                                 : strcpy( t, "someone" );
  1223.  break;
  1224.   
  1225.      case 'M':
  1226.          if ( vict )
  1227.    can_see( mob, vict ) ? strcpy( t, him_her[ vict->sex ] )
  1228.                                 : strcpy( t, "someone" );
  1229.  break;
  1230.   
  1231.      case 'S':
  1232.          if ( vict )
  1233.    can_see( mob, vict ) ? strcpy( t, his_her[ vict->sex ] )
  1234.                                 : strcpy( t, "someone's" ); 
  1235.  break;
  1237.      case 'j':
  1238.  strcpy( t, he_she[ mob->sex ] );
  1239.  break;
  1240.   
  1241.      case 'k':
  1242.  strcpy( t, him_her[ mob->sex ] );
  1243.  break;
  1244.   
  1245.      case 'l':
  1246.  strcpy( t, his_her[ mob->sex ] );
  1247.  break;
  1249.      case 'J':
  1250.          if ( rndm )
  1251.    can_see( mob, rndm ) ? strcpy( t, he_she[ rndm->sex ] )
  1252.                         : strcpy( t, "someone" );
  1253.  break;
  1254.   
  1255.      case 'K':
  1256.          if ( rndm )
  1257.    can_see( mob, rndm ) ? strcpy( t, him_her[ rndm->sex ] )
  1258.                                 : strcpy( t, "someone" );
  1259.  break;
  1260.   
  1261.      case 'L':
  1262.          if ( rndm )
  1263.    can_see( mob, rndm ) ? strcpy( t, his_her[ rndm->sex ] )
  1264.                         : strcpy( t, "someone's" );
  1265.  break;
  1267.      case 'o':
  1268.          if ( obj )
  1269.    can_see_obj( mob, obj ) ? one_argument( obj->name, t )
  1270.                                    : strcpy( t, "something" );
  1271.  break;
  1273.      case 'O':
  1274.          if ( obj )
  1275.    can_see_obj( mob, obj ) ? strcpy( t, obj->short_descr )
  1276.                                    : strcpy( t, "something" );
  1277.  break;
  1279.      case 'p':
  1280.          if ( v_obj )
  1281.    can_see_obj( mob, v_obj ) ? one_argument( v_obj->name, t )
  1282.                                      : strcpy( t, "something" );
  1283.  break;
  1285.      case 'P':
  1286.          if ( v_obj )
  1287.    can_see_obj( mob, v_obj ) ? strcpy( t, v_obj->short_descr )
  1288.                                      : strcpy( t, "something" );
  1289.       break;
  1291.      case 'a':
  1292.          if ( obj ) 
  1293.           switch ( *( obj->name ) )
  1294.   {
  1295.     case 'a': case 'e': case 'i':
  1296.             case 'o': case 'u': strcpy( t, "an" );
  1297.       break;
  1298.             default: strcpy( t, "a" );
  1299.           }
  1300.  break;
  1302.      case 'A':
  1303.          if ( v_obj ) 
  1304.           switch ( *( v_obj->name ) )
  1305.   {
  1306.             case 'a': case 'e': case 'i':
  1307.     case 'o': case 'u': strcpy( t, "an" );
  1308.       break;
  1309.             default: strcpy( t, "a" );
  1310.           }
  1311.  break;
  1313.      case '$':
  1314.          strcpy( t, "$" );
  1315.  break;
  1317.      default:
  1318.          bug( "Mob: %d bad $var", mob->pIndexData->vnum );
  1319.  break;
  1320.        }
  1322.  return;
  1324. }
  1326. /* This procedure simply copies the cmnd to a buffer while expanding
  1327.  * any variables by calling the translate procedure.  The observant
  1328.  * code scrutinizer will notice that this is taken from act()
  1329.  */
  1330. void mprog_process_cmnd( char *cmnd, CHAR_DATA *mob, CHAR_DATA *actor,
  1331. OBJ_DATA *obj, void *vo, CHAR_DATA *rndm )
  1332. {
  1333.   char buf[ MAX_INPUT_LENGTH ];
  1334.   char tmp[ MAX_INPUT_LENGTH ];
  1335.   char *str;
  1336.   char *i;
  1337.   char *point;
  1339.   point   = buf;
  1340.   str     = cmnd;
  1342.   while ( *str != '' )
  1343.   {
  1344.     if ( *str != '$' )
  1345.     {
  1346.       *point++ = *str++;
  1347.       continue;
  1348.     }
  1349.     str++;
  1350.     mprog_translate( *str, tmp, mob, actor, obj, vo, rndm );
  1351.     i = tmp;
  1352.     ++str;
  1353.     while ( ( *point = *i ) != '' )
  1354.       ++point, ++i;
  1355.   }
  1356.   *point = '';
  1357.   interpret( mob, buf );
  1359.   return;
  1361. }
  1363. /* The main focus of the MOBprograms.  This routine is called 
  1364.  *  whenever a trigger is successful.  It is responsible for parsing
  1365.  *  the command list and figuring out what to do. However, like all
  1366.  *  complex procedures, everything is farmed out to the other guys.
  1367.  */
  1368. void mprog_driver ( char *com_list, CHAR_DATA *mob, CHAR_DATA *actor,
  1369.    OBJ_DATA *obj, void *vo)
  1370. {
  1372.  char tmpcmndlst[ MAX_STRING_LENGTH ];
  1373.  char buf       [ MAX_INPUT_LENGTH ];
  1374.  char *morebuf;
  1375.  char *command_list;
  1376.  char *cmnd;
  1377.  CHAR_DATA *rndm  = NULL;
  1378.  CHAR_DATA *vch   = NULL;
  1379.  int        count = 0;
  1381.  if IS_AFFECTED( mob, AFF_CHARM )
  1382.    return;
  1384.  /* get a random visable mortal player who is in the room with the mob */
  1385.  for ( vch = mob->in_room->people; vch; vch = vch->next_in_room )
  1386.    if ( !IS_NPC( vch )
  1387.        &&  vch->level < LEVEL_IMMORTAL
  1388.        &&  can_see( mob, vch ) )
  1389.      {
  1390.        if ( number_range( 0, count ) == 0 )
  1391.  rndm = vch;
  1392.        count++;
  1393.      }
  1394.   
  1395.  strcpy( tmpcmndlst, com_list );
  1396.  command_list = tmpcmndlst;
  1397.  cmnd         = command_list;
  1398.  command_list = mprog_next_command( command_list );
  1399.  while ( *cmnd != '' )
  1400.    {
  1401.      morebuf = one_argument( cmnd, buf );
  1402.      if ( !str_cmp( buf, "if" ) )
  1403.        command_list = mprog_process_if( morebuf, command_list, mob,
  1404.        actor, obj, vo, rndm );
  1405.      else
  1406.        mprog_process_cmnd( cmnd, mob, actor, obj, vo, rndm );
  1407.      cmnd         = command_list;
  1408.      command_list = mprog_next_command( command_list );
  1409.    }
  1411.  return;
  1413. }
  1415. /***************************************************************************
  1416.  * Global function code and brief comments.
  1417.  */
  1419. /* The next two routines are the basic trigger types. Either trigger
  1420.  *  on a certain percent, or trigger on a keyword or word phrase.
  1421.  *  To see how this works, look at the various trigger routines..
  1422.  */
  1423. void mprog_wordlist_check( char *arg, CHAR_DATA *mob, CHAR_DATA *actor,
  1424.   OBJ_DATA *obj, void *vo, int type )
  1425. {
  1427.   char        temp1[ MAX_STRING_LENGTH ];
  1428.   char        temp2[ MAX_INPUT_LENGTH ];
  1429.   char        word[ MAX_INPUT_LENGTH ];
  1430.   MPROG_DATA *mprg;
  1431.   char       *list;
  1432.   char       *start;
  1433.   char       *dupl;
  1434.   char       *end;
  1435.   int         i;
  1437.   for ( mprg = mob->pIndexData->mobprogs; mprg != NULL; mprg = mprg->next )
  1438.     if ( mprg->type & type )
  1439.       {
  1440. strcpy( temp1, mprg->arglist );
  1441. list = temp1;
  1442. for ( i = 0; i < strlen( list ); i++ )
  1443.   list[i] = LOWER( list[i] );
  1444. strcpy( temp2, arg );
  1445. dupl = temp2;
  1446. for ( i = 0; i < strlen( dupl ); i++ )
  1447.   dupl[i] = LOWER( dupl[i] );
  1448. if ( ( list[0] == 'p' ) && ( list[1] == ' ' ) )
  1449.   {
  1450.     list += 2;
  1451.     while ( ( start = strstr( dupl, list ) ) )
  1452.       if ( (start == dupl || *(start-1) == ' ' )
  1453.   && ( *(end = start + strlen( list ) ) == ' '
  1454.       || *end == 'n'
  1455.       || *end == 'r'
  1456.       || *end == '' ) )
  1457. {
  1458.   mprog_driver( mprg->comlist, mob, actor, obj, vo );
  1459.   break;
  1460. }
  1461.       else
  1462. dupl = start+1;
  1463.   }
  1464. else
  1465.   {
  1466.     list = one_argument( list, word );
  1467.     for( ; word[0] != ''; list = one_argument( list, word ) )
  1468.       while ( ( start = strstr( dupl, word ) ) )
  1469. if ( ( start == dupl || *(start-1) == ' ' )
  1470.     && ( *(end = start + strlen( word ) ) == ' '
  1471. || *end == 'n'
  1472. || *end == 'r'
  1473. || *end == '' ) )
  1474.   {
  1475.     mprog_driver( mprg->comlist, mob, actor, obj, vo );
  1476.     break;
  1477.   }
  1478. else
  1479.   dupl = start+1;
  1480.   }
  1481.       }
  1483.   return;
  1485. }
  1487. void mprog_percent_check( CHAR_DATA *mob, CHAR_DATA *actor, OBJ_DATA *obj,
  1488.  void *vo, int type)
  1489. {
  1490.  MPROG_DATA * mprg;
  1492.  for ( mprg = mob->pIndexData->mobprogs; mprg != NULL; mprg = mprg->next )
  1493.    if ( ( mprg->type & type )
  1494.        && ( number_percent( ) < atoi( mprg->arglist ) ) )
  1495.      {
  1496.        mprog_driver( mprg->comlist, mob, actor, obj, vo );
  1497.        if ( type != GREET_PROG && type != ALL_GREET_PROG )
  1498.  break;
  1499.      }
  1501.  return;
  1503. }
  1505. /* The triggers.. These are really basic, and since most appear only
  1506.  * once in the code (hmm. i think they all do) it would be more efficient
  1507.  * to substitute the code in and make the mprog_xxx_check routines global.
  1508.  * However, they are all here in one nice place at the moment to make it
  1509.  * easier to see what they look like. If you do substitute them back in,
  1510.  * make sure you remember to modify the variable names to the ones in the
  1511.  * trigger calls.
  1512.  */
  1513. void mprog_act_trigger( char *buf, CHAR_DATA *mob, CHAR_DATA *ch,
  1514.        OBJ_DATA *obj, void *vo)
  1515. {
  1517.   MPROG_ACT_LIST * tmp_act;
  1519.   if ( IS_NPC( mob )
  1520.       && ( mob->pIndexData->progtypes & ACT_PROG ) )
  1521.     {
  1522.       tmp_act = alloc_mem( sizeof( MPROG_ACT_LIST ) );
  1523.       if ( mob->mpactnum > 0 )
  1524. tmp_act->next = mob->mpact->next;
  1525.       else
  1526. tmp_act->next = NULL;
  1528.       mob->mpact      = tmp_act;
  1529.       mob->mpact->buf = str_dup( buf );
  1530.       mob->mpact->ch  = ch; 
  1531.       mob->mpact->obj = obj; 
  1532.       mob->mpact->vo  = vo; 
  1533.       mob->mpactnum++;
  1535.     }
  1536.   return;
  1538. }
  1540. void mprog_bribe_trigger( CHAR_DATA *mob, CHAR_DATA *ch, int amount )
  1541. {
  1543.   char        buf[ MAX_STRING_LENGTH ];
  1544.   MPROG_DATA *mprg;
  1545.   OBJ_DATA   *obj;
  1547.   if ( IS_NPC( mob )
  1548.       && ( mob->pIndexData->progtypes & BRIBE_PROG ) )
  1549.     {
  1550.       obj = create_object( get_obj_index( OBJ_VNUM_MONEY_SOME ), 0 );
  1551.       sprintf( buf, obj->short_descr, amount );
  1552.       free_string( obj->short_descr );
  1553.       obj->short_descr = str_dup( buf );
  1554.       obj->value[0]    = amount;
  1555.       obj_to_char( obj, mob );
  1556.       mob->gold -= amount;
  1558.       for ( mprg = mob->pIndexData->mobprogs; mprg != NULL; mprg = mprg->next )
  1559. if ( ( mprg->type & BRIBE_PROG )
  1560.     && ( amount >= atoi( mprg->arglist ) ) )
  1561.   {
  1562.     mprog_driver( mprg->comlist, mob, ch, obj, NULL );
  1563.     break;
  1564.   }
  1565.     }
  1566.   
  1567.   return;
  1569. }
  1571. void mprog_death_trigger( CHAR_DATA *mob )
  1572. {
  1574.  if ( IS_NPC( mob )
  1575.      && ( mob->pIndexData->progtypes & DEATH_PROG ) )
  1576.    {
  1577.      mprog_percent_check( mob, NULL, NULL, NULL, DEATH_PROG );
  1578.    }
  1580.  death_cry( mob );
  1581.  return;
  1583. }
  1585. void mprog_entry_trigger( CHAR_DATA *mob )
  1586. {
  1588.  if ( IS_NPC( mob )
  1589.      && ( mob->pIndexData->progtypes & ENTRY_PROG ) )
  1590.    mprog_percent_check( mob, NULL, NULL, NULL, ENTRY_PROG );
  1592.  return;
  1594. }
  1596. void mprog_fight_trigger( CHAR_DATA *mob, CHAR_DATA *ch )
  1597. {
  1599.  if ( IS_NPC( mob )
  1600.      && ( mob->pIndexData->progtypes & FIGHT_PROG ) )
  1601.    mprog_percent_check( mob, ch, NULL, NULL, FIGHT_PROG );
  1603.  return;
  1605. }
  1607. void mprog_give_trigger( CHAR_DATA *mob, CHAR_DATA *ch, OBJ_DATA *obj )
  1608. {
  1610.  char        buf[MAX_INPUT_LENGTH];
  1611.  MPROG_DATA *mprg;
  1613.  if ( IS_NPC( mob )
  1614.      && ( mob->pIndexData->progtypes & GIVE_PROG ) )
  1615.    for ( mprg = mob->pIndexData->mobprogs; mprg != NULL; mprg = mprg->next )
  1616.      {
  1617.        one_argument( mprg->arglist, buf );
  1618.        if ( ( mprg->type & GIVE_PROG )
  1619.    && ( ( !str_cmp( obj->name, mprg->arglist ) )
  1620.        || ( !str_cmp( "all", buf ) ) ) )
  1621.  {
  1622.    mprog_driver( mprg->comlist, mob, ch, obj, NULL );
  1623.    break;
  1624.  }
  1625.      }
  1627.  return;
  1629. }
  1631. void mprog_greet_trigger( CHAR_DATA *mob )
  1632. {
  1634.  CHAR_DATA *vmob;
  1636.  for ( vmob = mob->in_room->people; vmob != NULL; vmob = vmob->next_in_room )
  1637.    if ( IS_NPC( vmob )
  1638.        && mob != vmob
  1639.        && can_see( vmob, mob )
  1640.        && ( vmob->fighting == NULL )
  1641.        && IS_AWAKE( vmob )
  1642.        && ( vmob->pIndexData->progtypes & GREET_PROG) )
  1643.      mprog_percent_check( vmob, mob, NULL, NULL, GREET_PROG );
  1644.    else
  1645.      if ( IS_NPC( vmob )
  1646.  && ( vmob->fighting == NULL )
  1647.  && IS_AWAKE( vmob )
  1648.  && ( vmob->pIndexData->progtypes & ALL_GREET_PROG ) )
  1649.        mprog_percent_check( vmob, mob, NULL, NULL, ALL_GREET_PROG );
  1651.  return;
  1653. }
  1655. void mprog_hitprcnt_trigger( CHAR_DATA *mob, CHAR_DATA *ch)
  1656. {
  1658.  MPROG_DATA *mprg;
  1660.  if ( IS_NPC( mob )
  1661.      && ( mob->pIndexData->progtypes & HITPRCNT_PROG ) )
  1662.    for ( mprg = mob->pIndexData->mobprogs; mprg != NULL; mprg = mprg->next )
  1663.      if ( ( mprg->type & HITPRCNT_PROG )
  1664.  && ( ( 100*mob->hit / mob->max_hit ) < atoi( mprg->arglist ) ) )
  1665.        {
  1666.  mprog_driver( mprg->comlist, mob, ch, NULL, NULL );
  1667.  break;
  1668.        }
  1669.  
  1670.  return;
  1672. }
  1674. void mprog_random_trigger( CHAR_DATA *mob )
  1675. {
  1677.   if ( mob->pIndexData->progtypes & RAND_PROG)
  1678.     mprog_percent_check(mob,NULL,NULL,NULL,RAND_PROG);
  1680.   return;
  1682. }
  1684. void mprog_speech_trigger( char *txt, CHAR_DATA *mob )
  1685. {
  1687.   CHAR_DATA *vmob;
  1689.   for ( vmob = mob->in_room->people; vmob != NULL; vmob = vmob->next_in_room )
  1690.     if ( IS_NPC( vmob ) && ( vmob->pIndexData->progtypes & SPEECH_PROG ) )
  1691.       mprog_wordlist_check( txt, vmob, mob, NULL, NULL, SPEECH_PROG );
  1692.   
  1693.   return;
  1695. }