home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / d / d-linux.zip / dm-dist / interpreter.c < prev    next >
C/C++ Source or Header  |  1991-03-01  |  39KB  |  1,397 lines
  1. /* ************************************************************************
  2. *  file: Interpreter.c , Command interpreter module.      Part of DIKUMUD *
  3. *  Usage: Procedures interpreting user command                            *
  4. *  Copyright (C) 1990, 1991 - see 'license.doc' for complete information. *
  5. ************************************************************************* */
  6. /* This won't work */
  7.  
  8. #include <string.h>
  9. #include <ctype.h>
  10. #include <stdio.h>
  11. #include "structs.h"
  12. #include "comm.h"
  13. #include "interpreter.h"
  14. #include "db.h"
  15. #include "utils.h"
  16. #include "limits.h"
  17.  
  18. #define COMMANDO(number,min_pos,pointer,min_level) {      \
  19.     cmd_info[(number)].command_pointer = (pointer);         \
  20.     cmd_info[(number)].minimum_position = (min_pos);        \
  21.     cmd_info[(number)].minimum_level = (min_level); }
  22.  
  23. #define NOT !
  24. #define AND &&
  25. #define OR ||
  26.  
  27. #define STATE(d) ((d)->connected)
  28. #define MAX_CMD_LIST 250
  29.  
  30. extern const struct title_type titles[4][25];
  31. extern char motd[MAX_STRING_LENGTH];
  32. extern struct char_data *character_list;
  33. extern struct player_index_element *player_table;
  34. extern int top_of_p_table;
  35. extern struct index_data *mob_index;
  36. extern struct index_data *obj_index;
  37. extern struct room_data *world;
  38. struct command_info cmd_info[MAX_CMD_LIST];
  39.  
  40.  
  41. /* external fcntls */
  42.  
  43. void set_title(struct char_data *ch);
  44. void init_char(struct char_data *ch);
  45. void store_to_char(struct char_file_u *st, struct char_data *ch);
  46. int create_entry(char *name);
  47. int special(struct char_data *ch, int cmd, char *arg);
  48. void log(char *str);
  49.  
  50. void do_move(struct char_data *ch, char *argument, int cmd);
  51. void do_look(struct char_data *ch, char *argument, int cmd);
  52. void do_read(struct char_data *ch, char *argument, int cmd);
  53. void do_say(struct char_data *ch, char *argument, int cmd);
  54. void do_exit(struct char_data *ch, char *argument, int cmd);
  55. void do_snoop(struct char_data *ch, char *argument, int cmd);
  56. void do_insult(struct char_data *ch, char *argument, int cmd);
  57. void do_quit(struct char_data *ch, char *argument, int cmd);
  58. void do_qui(struct char_data *ch, char *argument, int cmd);
  59. void do_help(struct char_data *ch, char *argument, int cmd);
  60. void do_who(struct char_data *ch, char *argument, int cmd);
  61. void do_emote(struct char_data *ch, char *argument, int cmd);
  62. void do_echo(struct char_data *ch, char *argument, int cmd);
  63. void do_trans(struct char_data *ch, char *argument, int cmd);
  64. void do_kill(struct char_data *ch, char *argument, int cmd);
  65. void do_stand(struct char_data *ch, char *argument, int cmd);
  66. void do_sit(struct char_data *ch, char *argument, int cmd);
  67. void do_rest(struct char_data *ch, char *argument, int cmd);
  68. void do_sleep(struct char_data *ch, char *argument, int cmd);
  69. void do_wake(struct char_data *ch, char *argument, int cmd);
  70. void do_force(struct char_data *ch, char *argument, int cmd);
  71. void do_get(struct char_data *ch, char *argument, int cmd);
  72. void do_drop(struct char_data *ch, char *argument, int cmd);
  73. void do_news(struct char_data *ch, char *argument, int cmd);
  74. void do_score(struct char_data *ch, char *argument, int cmd);
  75. void do_inventory(struct char_data *ch, char *argument, int cmd);
  76. void do_equipment(struct char_data *ch, char *argument, int cmd);
  77. void do_shout(struct char_data *ch, char *argument, int cmd);
  78. void do_not_here(struct char_data *ch, char *argument, int cmd);
  79. void do_tell(struct char_data *ch, char *argument, int cmd);
  80. void do_wear(struct char_data *ch, char *argument, int cmd);
  81. void do_wield(struct char_data *ch, char *argument, int cmd);
  82. void do_grab(struct char_data *ch, char *argument, int cmd);
  83. void do_remove(struct char_data *ch, char *argument, int cmd);
  84. void do_put(struct char_data *ch, char *argument, int cmd);
  85. void do_shutdown(struct char_data *ch, char *argument, int cmd);
  86. void do_save(struct char_data *ch, char *argument, int cmd);
  87. void do_hit(struct char_data *ch, char *argument, int cmd);
  88. void do_string(struct char_data *ch, char *arg, int cmd);
  89. void do_give(struct char_data *ch, char *arg, int cmd);
  90. void do_stat(struct char_data *ch, char *arg, int cmd);
  91. void do_setskill(struct char_data *ch, char *arg, int cmd);
  92. void do_time(struct char_data *ch, char *arg, int cmd);
  93. void do_weather(struct char_data *ch, char *arg, int cmd);
  94. void do_load(struct char_data *ch, char *arg, int cmd);
  95. void do_purge(struct char_data *ch, char *arg, int cmd);
  96. void do_shutdow(struct char_data *ch, char *arg, int cmd);
  97. void do_idea(struct char_data *ch, char *arg, int cmd);
  98. void do_typo(struct char_data *ch, char *arg, int cmd);
  99. void do_bug(struct char_data *ch, char *arg, int cmd);
  100. void do_whisper(struct char_data *ch, char *arg, int cmd);
  101. void do_cast(struct char_data *ch, char *arg, int cmd);
  102. void do_at(struct char_data *ch, char *arg, int cmd);
  103. void do_goto(struct char_data *ch, char *arg, int cmd);
  104. void do_ask(struct char_data *ch, char *arg, int cmd);
  105. void do_drink(struct char_data *ch, char *arg, int cmd);
  106. void do_eat(struct char_data *ch, char *arg, int cmd);
  107. void do_pour(struct char_data *ch, char *arg, int cmd);
  108. void do_sip(struct char_data *ch, char *arg, int cmd);
  109. void do_taste(struct char_data *ch, char *arg, int cmd);
  110. void do_order(struct char_data *ch, char *arg, int cmd);
  111. void do_follow(struct char_data *ch, char *arg, int cmd);
  112. void do_rent(struct char_data *ch, char *arg, int cmd);
  113. void do_offer(struct char_data *ch, char *arg, int cmd);
  114. void do_advance(struct char_data *ch, char *arg, int cmd);
  115. void do_close(struct char_data *ch, char *arg, int cmd);
  116. void do_open(struct char_data *ch, char *arg, int cmd);
  117. void do_lock(struct char_data *ch, char *arg, int cmd);
  118. void do_unlock(struct char_data *ch, char *arg, int cmd);
  119. void do_exits(struct char_data *ch, char *arg, int cmd);
  120. void do_enter(struct char_data *ch, char *arg, int cmd);
  121. void do_leave(struct char_data *ch, char *arg, int cmd);
  122. void do_write(struct char_data *ch, char *arg, int cmd);
  123. void do_flee(struct char_data *ch, char *arg, int cmd);
  124. void do_sneak(struct char_data *ch, char *arg, int cmd);
  125. void do_hide(struct char_data *ch, char *arg, int cmd);
  126. void do_backstab(struct char_data *ch, char *arg, int cmd);
  127. void do_pick(struct char_data *ch, char *arg, int cmd);
  128. void do_steal(struct char_data *ch, char *arg, int cmd);
  129. void do_bash(struct char_data *ch, char *arg, int cmd);
  130. void do_rescue(struct char_data *ch, char *arg, int cmd);
  131. void do_kick(struct char_data *ch, char *arg, int cmd);
  132. void do_examine(struct char_data *ch, char *arg, int cmd);
  133. void do_info(struct char_data *ch, char *arg, int cmd);
  134. void do_users(struct char_data *ch, char *arg, int cmd);
  135. void do_where(struct char_data *ch, char *arg, int cmd);
  136. void do_levels(struct char_data *ch, char *arg, int cmd);
  137. void do_reroll(struct char_data *ch, char *arg, int cmd);
  138. void do_brief(struct char_data *ch, char *arg, int cmd);
  139. void do_wizlist(struct char_data *ch, char *arg, int cmd);
  140. void do_consider(struct char_data *ch, char *arg, int cmd);
  141. void do_group(struct char_data *ch, char *arg, int cmd);
  142. void do_restore(struct char_data *ch, char *arg, int cmd);
  143. void do_return(struct char_data *ch, char *argument, int cmd);
  144. void do_switch(struct char_data *ch, char *argument, int cmd);
  145. void do_quaff(struct char_data *ch, char *argument, int cmd);
  146. void do_recite(struct char_data *ch, char *argument, int cmd);
  147. void do_use(struct char_data *ch, char *argument, int cmd);
  148. void do_pose(struct char_data *ch, char *argument, int cmd);
  149. void do_noshout(struct char_data *ch, char *argument, int cmd);
  150. void do_wizhelp(struct char_data *ch, char *argument, int cmd);
  151. void do_credits(struct char_data *ch, char *argument, int cmd);
  152. void do_compact(struct char_data *ch, char *argument, int cmd);
  153.  
  154. void do_action(struct char_data *ch, char *arg, int cmd);
  155. void do_practice(struct char_data *ch, char *arg, int cmd);
  156.  
  157.  
  158. char *command[]=
  159. { "north",          /* 1 */
  160.   "east",
  161.   "south",
  162.   "west",
  163.   "up",
  164.   "down",
  165.   "enter",
  166.   "exits",
  167.   "kiss",
  168.   "get",
  169.   "drink",         /* 11 */
  170.   "eat",
  171.   "wear",
  172.   "wield",
  173.   "look",
  174.   "score",
  175.   "say",
  176.   "shout",
  177.   "tell",
  178.   "inventory",
  179.   "qui",           /* 21 */
  180.   "bounce",
  181.   "smile",
  182.   "dance",
  183.   "kill",
  184.   "cackle",
  185.   "laugh",
  186.   "giggle",
  187.   "shake",
  188.   "puke",
  189.   "growl",         /* 31 */    
  190.   "scream",
  191.   "insult",
  192.   "comfort",
  193.   "nod",
  194.   "sigh",
  195.   "sulk",
  196.   "help",
  197.   "who",
  198.   "emote",
  199.   "echo",        /* 41 */
  200.   "stand",
  201.   "sit",
  202.   "rest",
  203.   "sleep",
  204.   "wake",
  205.   "force",
  206.   "transfer",
  207.   "hug",
  208.   "snuggle",
  209.   "cuddle",         /* 51 */
  210.   "nuzzle",
  211.   "cry",
  212.   "news",
  213.   "equipment",
  214.   "buy",
  215.   "sell",
  216.   "value",
  217.   "list",
  218.   "drop",
  219.   "goto",           /* 61 */
  220.   "weather",
  221.   "read",
  222.   "pour",
  223.   "grab",
  224.   "remove",
  225.   "put",
  226.   "shutdow",
  227.   "save",
  228.   "hit",
  229.   "string",      /* 71 */
  230.   "give",
  231.   "quit",
  232.   "stat",
  233.   "setskill",
  234.   "time",
  235.   "load",
  236.   "purge",
  237.   "shutdown",
  238.   "idea",
  239.   "typo",        /* 81 */
  240.   "bug",
  241.   "whisper",
  242.   "cast",
  243.   "at",
  244.   "ask",
  245.   "order",
  246.   "sip",
  247.   "taste",
  248.   "snoop",
  249.   "follow",      /* 91 */
  250.   "rent",
  251.   "offer",
  252.   "poke",
  253.   "advance",
  254.   "accuse",
  255.   "grin",
  256.   "bow",
  257.   "open",
  258.   "close",
  259.   "lock",        /* 101 */
  260.   "unlock",
  261.   "leave",
  262.   "applaud",
  263.   "blush",
  264.   "burp",
  265.   "chuckle",
  266.   "clap",
  267.   "cough",
  268.   "curtsey",
  269.   "fart",        /* 111 */
  270.   "flip",
  271.   "fondle",
  272.   "frown",
  273.   "gasp",
  274.   "glare",
  275.   "groan",
  276.   "grope",
  277.   "hiccup",
  278.   "lick",
  279.   "love",        /* 121 */
  280.   "moan",
  281.   "nibble",
  282.   "pout",
  283.   "purr",
  284.   "ruffle",
  285.   "shiver",
  286.   "shrug",
  287.   "sing",
  288.   "slap",
  289.   "smirk",       /* 131 */
  290.   "snap",
  291.   "sneeze",
  292.   "snicker",
  293.   "sniff",
  294.   "snore",
  295.   "spit",
  296.   "squeeze",
  297.   "stare",
  298.   "strut",
  299.   "thank",       /* 141 */
  300.   "twiddle",
  301.   "wave",
  302.   "whistle",
  303.   "wiggle",
  304.   "wink",
  305.   "yawn",
  306.   "snowball",
  307.   "write",
  308.   "hold",
  309.   "flee",        /* 151 */
  310.   "sneak",
  311.   "hide",
  312.   "backstab",
  313.   "pick",
  314.   "steal",
  315.   "bash",
  316.   "rescue",
  317.   "kick",
  318.   "french",
  319.   "comb",        /* 161 */
  320.   "massage",
  321.   "tickle",
  322.   "practice",
  323.   "pat",
  324.   "examine",
  325.   "take",
  326.   "info",
  327.   "'",
  328.   "practise",
  329.   "curse",       /* 171 */
  330.   "use",
  331.   "where",
  332.   "levels",
  333.   "reroll",
  334.   "pray",
  335.   ",",
  336.   "beg",
  337.   "bleed",
  338.   "cringe",
  339.   "daydream",    /* 181 */
  340.   "fume",
  341.   "grovel",
  342.   "hop",
  343.   "nudge",
  344.   "peer",
  345.   "point",
  346.   "ponder",
  347.   "punch",
  348.   "snarl",
  349.   "spank",       /* 191 */
  350.   "steam",
  351.   "tackle",
  352.   "taunt",
  353.   "think",
  354.   "whine",
  355.   "worship",
  356.   "yodel",
  357.   "brief",
  358.   "wizlist",
  359.   "consider",    /* 201 */
  360.   "group",
  361.   "restore",
  362.   "return",
  363.   "switch",      /* 205 */
  364.     "quaff",
  365.     "recite",
  366.     "users",
  367.     "pose",
  368.     "noshout",
  369.     "wizhelp",   /* 211 */
  370.     "credits",
  371.     "compact",
  372.   "\n"
  373. };
  374.  
  375.  
  376. char *fill[]=
  377. { "in",
  378.   "from",
  379.   "with",
  380.   "the",
  381.   "on",
  382.   "at",
  383.   "to",
  384.   "\n"
  385. };
  386.  
  387. int search_block(char *arg, char **list, bool exact)
  388. {
  389.     register int i,l;
  390.  
  391.     /* Make into lower case, and get length of string */
  392.     for(l=0; *(arg+l); l++)
  393.         *(arg+l)=LOWER(*(arg+l));
  394.  
  395.     if (exact) {
  396.         for(i=0; **(list+i) != '\n'; i++)
  397.             if (!strcmp(arg, *(list+i)))
  398.                 return(i);
  399.     } else {
  400.         if (!l)
  401.             l=1; /* Avoid "" to match the first available string */
  402.         for(i=0; **(list+i) != '\n'; i++)
  403.             if (!strncmp(arg, *(list+i), l))
  404.                 return(i);
  405.     }
  406.  
  407.     return(-1);
  408. }
  409.  
  410.  
  411. int old_search_block(char *argument,int begin,int length,char **list,int mode)
  412. {
  413.     int guess, found, search;
  414.         
  415.     /* If the word contain 0 letters, then a match is already found */
  416.     found = (length < 1);
  417.  
  418.     guess = 0;
  419.  
  420.     /* Search for a match */
  421.  
  422.     if(mode)
  423.     while ( NOT found AND *(list[guess]) != '\n' )
  424.     {
  425.         found=(length==strlen(list[guess]));
  426.         for(search=0;( search < length AND found );search++)
  427.             found=(*(argument+begin+search)== *(list[guess]+search));
  428.         guess++;
  429.     } else {
  430.         while ( NOT found AND *(list[guess]) != '\n' ) {
  431.             found=1;
  432.             for(search=0;( search < length AND found );search++)
  433.                 found=(*(argument+begin+search)== *(list[guess]+search));
  434.             guess++;
  435.         }
  436.     }
  437.  
  438.     return ( found ? guess : -1 ); 
  439. }
  440.  
  441. void command_interpreter(struct char_data *ch, char *argument) 
  442. {
  443.     int look_at, cmd, begin;
  444.     extern int no_specials;
  445.  
  446.     REMOVE_BIT(ch->specials.affected_by, AFF_HIDE);
  447.  
  448.         /* Find first non blank */
  449.      for (begin = 0 ; (*(argument + begin ) == ' ' ) ; begin++ );
  450.     
  451.     /* Find length of first word */
  452.     for (look_at = 0; *(argument + begin + look_at ) > ' ' ; look_at++)
  453.  
  454.               /* Make all letters lower case AND find length */
  455.         *(argument + begin + look_at) = 
  456.         LOWER(*(argument + begin + look_at));
  457.  
  458.     
  459.     cmd = old_search_block(argument,begin,look_at,command,0);
  460.  
  461.     
  462.     if (!cmd)
  463.         return;
  464.  
  465.     if ( cmd>0 && GET_LEVEL(ch)<cmd_info[cmd].minimum_level )
  466.     {
  467.         send_to_char("Arglebargle, glop-glyf!?!\n\r", ch);
  468.         return;
  469.     }
  470.  
  471.     if ( cmd>0 && (cmd_info[cmd].command_pointer != 0))
  472.     {
  473.         if( GET_POS(ch) < cmd_info[cmd].minimum_position )
  474.             switch(GET_POS(ch))
  475.             {
  476.                 case POSITION_DEAD:
  477.                     send_to_char("Lie still; you are DEAD!!! :-( \n\r", ch);
  478.                 break;
  479.                 case POSITION_INCAP:
  480.                 case POSITION_MORTALLYW:
  481.                     send_to_char(
  482.                         "You are in a pretty bad shape, unable to do anything!\n\r",
  483.                         ch);
  484.                 break;
  485.  
  486.                 case POSITION_STUNNED:
  487.                     send_to_char(
  488.                     "All you can do right now, is think about the stars!\n\r", ch);
  489.                 break;
  490.                 case POSITION_SLEEPING:
  491.                     send_to_char("In your dreams, or what?\n\r", ch);
  492.                 break;
  493.                 case POSITION_RESTING:
  494.                     send_to_char("Nah... You feel too relaxed to do that..\n\r",
  495.                         ch);
  496.                 break;
  497.                 case POSITION_SITTING:
  498.                     send_to_char("Maybe you should get on your feet first?\n\r",ch);
  499.                 break;
  500.                 case POSITION_FIGHTING:
  501.                     send_to_char("No way! You are fighting for your life!\n\r", ch);
  502.                 break;
  503.             }
  504.         else
  505.         {
  506.             if (!no_specials && special(ch, cmd, argument + begin + look_at))
  507.                 return;  
  508.  
  509.             ((*cmd_info[cmd].command_pointer)
  510.             (ch, argument + begin + look_at, cmd));
  511.         }
  512.         return;
  513.     }
  514.     if ( cmd>0 && (cmd_info[cmd].command_pointer == 0))
  515.         send_to_char(
  516.         "Sorry, but that command has yet to be implemented...\n\r",
  517.             ch);
  518.     else 
  519.        send_to_char("Arglebargle, glop-glyf!?!\n\r", ch);
  520. }
  521.  
  522. void argument_interpreter(char *argument,char *first_arg,char *second_arg )
  523. {
  524.         int look_at, found, begin;
  525.  
  526.         found = begin = 0;
  527.  
  528.         do
  529.         {
  530.                 /* Find first non blank */
  531.                 for ( ;*(argument + begin ) == ' ' ; begin++);
  532.  
  533.                 /* Find length of first word */
  534.                 for ( look_at=0; *(argument+begin+look_at)> ' ' ; look_at++)
  535.  
  536.                         /* Make all letters lower case,
  537.                            AND copy them to first_arg */
  538.                         *(first_arg + look_at) =
  539.                         LOWER(*(argument + begin + look_at));
  540.  
  541.                 *(first_arg + look_at)='\0';
  542.                 begin += look_at;
  543.  
  544.         }
  545.         while( fill_word(first_arg));
  546.  
  547.         do
  548.         {
  549.                 /* Find first non blank */
  550.                 for ( ;*(argument + begin ) == ' ' ; begin++);
  551.  
  552.                 /* Find length of first word */
  553.                 for ( look_at=0; *(argument+begin+look_at)> ' ' ; look_at++)
  554.  
  555.                         /* Make all letters lower case,
  556.                            AND copy them to second_arg */
  557.                         *(second_arg + look_at) =
  558.                         LOWER(*(argument + begin + look_at));
  559.  
  560.                 *(second_arg + look_at)='\0';
  561.                 begin += look_at;
  562.  
  563.         }
  564.         while( fill_word(second_arg));
  565. }
  566.  
  567. int is_number(char *str)
  568. {
  569.     int look_at;
  570.  
  571.     if(*str=='\0')
  572.         return(0);
  573.  
  574.     for(look_at=0;*(str+look_at) != '\0';look_at++)
  575.         if((*(str+look_at)<'0')||(*(str+look_at)>'9'))
  576.             return(0);
  577.     return(1);
  578. }
  579.  
  580. /*  Quinn substituted a new one-arg for the old one.. I thought returning a 
  581.     char pointer would be neat, and avoiding the func-calls would save a
  582.     little time... If anyone feels pissed, I'm sorry.. Anyhow, the code is
  583.     snatched from the old one, so it outta work..
  584.  
  585. void one_argument(char *argument,char *first_arg )
  586. {
  587.     static char dummy[MAX_STRING_LENGTH];
  588.  
  589.     argument_interpreter(argument,first_arg,dummy);
  590. }
  591.  
  592. */
  593.  
  594.  
  595. /* find the first sub-argument of a string, return pointer to first char in
  596.    primary argument, following the sub-arg                        */
  597. char *one_argument(char *argument, char *first_arg )
  598. {
  599.     int found, begin, look_at;
  600.  
  601.         found = begin = 0;
  602.  
  603.         do
  604.         {
  605.                 /* Find first non blank */
  606.                 for ( ;isspace(*(argument + begin)); begin++);
  607.  
  608.                 /* Find length of first word */
  609.                 for (look_at=0; *(argument+begin+look_at) > ' ' ; look_at++)
  610.  
  611.                         /* Make all letters lower case,
  612.                            AND copy them to first_arg */
  613.                         *(first_arg + look_at) =
  614.                         LOWER(*(argument + begin + look_at));
  615.  
  616.                 *(first_arg + look_at)='\0';
  617.         begin += look_at;
  618.     }
  619.         while (fill_word(first_arg));
  620.  
  621.     return(argument+begin);
  622. }
  623.     
  624.     
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631. int fill_word(char *argument)
  632. {
  633.     return ( search_block(argument,fill,TRUE) >= 0);
  634. }
  635.  
  636.  
  637.  
  638.  
  639.  
  640. /* determine if a given string is an abbreviation of another */
  641. int is_abbrev(char *arg1, char *arg2)
  642. {
  643.     if (!*arg1)
  644.        return(0);
  645.  
  646.     for (; *arg1; arg1++, arg2++)
  647.        if (LOWER(*arg1) != LOWER(*arg2))
  648.           return(0);
  649.  
  650.     return(1);
  651. }
  652.  
  653.  
  654.  
  655.  
  656. /* return first 'word' plus trailing substring of input string */
  657. void half_chop(char *string, char *arg1, char *arg2)
  658. {
  659.     for (; isspace(*string); string++);
  660.  
  661.     for (; !isspace(*arg1 = *string) && *string; string++, arg1++);
  662.  
  663.     *arg1 = '\0';
  664.  
  665.     for (; isspace(*string); string++);
  666.  
  667.     for (; *arg2 = *string; string++, arg2++);
  668. }
  669.  
  670.  
  671.  
  672. int special(struct char_data *ch, int cmd, char *arg)
  673. {
  674.     register struct obj_data *i;
  675.     register struct char_data *k;
  676.     int j;
  677.  
  678.     /* special in room? */
  679.     if (world[ch->in_room].funct)
  680.        if ((*world[ch->in_room].funct)(ch, cmd, arg))
  681.           return(1);
  682.  
  683.     /* special in equipment list? */
  684.     for (j = 0; j <= (MAX_WEAR - 1); j++)
  685.        if (ch->equipment[j] && ch->equipment[j]->item_number>=0)
  686.           if (obj_index[ch->equipment[j]->item_number].func)
  687.              if ((*obj_index[ch->equipment[j]->item_number].func)
  688.                 (ch, cmd, arg))
  689.                 return(1);
  690.  
  691.     /* special in inventory? */
  692.     for (i = ch->carrying; i; i = i->next_content)
  693.         if (i->item_number>=0)
  694.             if (obj_index[i->item_number].func)
  695.               if ((*obj_index[i->item_number].func)(ch, cmd, arg))
  696.                  return(1);
  697.  
  698.     /* special in mobile present? */
  699.     for (k = world[ch->in_room].people; k; k = k->next_in_room)
  700.        if ( IS_MOB(k) )
  701.           if (mob_index[k->nr].func)
  702.              if ((*mob_index[k->nr].func)(ch, cmd, arg))
  703.                 return(1);
  704.  
  705.     /* special in object present? */
  706.     for (i = world[ch->in_room].contents; i; i = i->next_content)
  707.        if (i->item_number>=0)
  708.           if (obj_index[i->item_number].func)
  709.              if ((*obj_index[i->item_number].func)(ch, cmd, arg))
  710.                 return(1);
  711.  
  712.  
  713.     return(0);
  714. }
  715.  
  716. void assign_command_pointers ( void )
  717. {
  718.     int position;
  719.  
  720.     for (position = 0 ; position < MAX_CMD_LIST; position++)
  721.         cmd_info[position].command_pointer = 0;
  722.  
  723.     COMMANDO(1,POSITION_STANDING,do_move,0);
  724.     COMMANDO(2,POSITION_STANDING,do_move,0);
  725.     COMMANDO(3,POSITION_STANDING,do_move,0);
  726.     COMMANDO(4,POSITION_STANDING,do_move,0);
  727.     COMMANDO(5,POSITION_STANDING,do_move,0);
  728.     COMMANDO(6,POSITION_STANDING,do_move,0);
  729.     COMMANDO(7,POSITION_STANDING,do_enter,0);
  730.     COMMANDO(8,POSITION_RESTING,do_exits,0);
  731.     COMMANDO(9,POSITION_RESTING,do_action,0);
  732.     COMMANDO(10,POSITION_RESTING,do_get,0);
  733.     COMMANDO(11,POSITION_RESTING,do_drink,0);
  734.     COMMANDO(12,POSITION_RESTING,do_eat,0);
  735.     COMMANDO(13,POSITION_RESTING,do_wear,0);
  736.     COMMANDO(14,POSITION_RESTING,do_wield,0);
  737.     COMMANDO(15,POSITION_RESTING,do_look,0);
  738.     COMMANDO(16,POSITION_DEAD,do_score,0);
  739.     COMMANDO(17,POSITION_RESTING,do_say,0);
  740.     COMMANDO(18,POSITION_RESTING,do_shout,0);
  741.     COMMANDO(19,POSITION_DEAD,do_tell,0);
  742.     COMMANDO(20,POSITION_DEAD,do_inventory,0);
  743.     COMMANDO(21,POSITION_DEAD,do_qui,0);
  744.     COMMANDO(22,POSITION_STANDING,do_action,0);
  745.     COMMANDO(23,POSITION_RESTING,do_action,0);
  746.     COMMANDO(24,POSITION_STANDING,do_action,0);
  747.     COMMANDO(25,POSITION_FIGHTING,do_kill,0);
  748.     COMMANDO(26,POSITION_RESTING,do_action,0);
  749.     COMMANDO(27,POSITION_RESTING,do_action,0);
  750.     COMMANDO(28,POSITION_RESTING,do_action,0);
  751.     COMMANDO(29,POSITION_RESTING,do_action,0);
  752.     COMMANDO(30,POSITION_RESTING,do_action,0);
  753.     COMMANDO(31,POSITION_RESTING,do_action,0);
  754.     COMMANDO(32,POSITION_RESTING,do_action,0);
  755.     COMMANDO(33,POSITION_RESTING,do_insult,0);
  756.     COMMANDO(34,POSITION_RESTING,do_action,0);
  757.     COMMANDO(35,POSITION_RESTING,do_action,0);
  758.     COMMANDO(36,POSITION_RESTING,do_action,0);
  759.     COMMANDO(37,POSITION_RESTING,do_action,0);
  760.     COMMANDO(38,POSITION_DEAD,do_help,0);
  761.     COMMANDO(39,POSITION_DEAD,do_who,0);
  762.     COMMANDO(40,POSITION_SLEEPING,do_emote,1);
  763.     COMMANDO(41,POSITION_SLEEPING,do_echo,21);    
  764.     COMMANDO(42,POSITION_RESTING,do_stand,0);
  765.     COMMANDO(43,POSITION_RESTING,do_sit,0);
  766.     COMMANDO(44,POSITION_RESTING,do_rest,0);
  767.     COMMANDO(45,POSITION_SLEEPING,do_sleep,0);
  768.     COMMANDO(46,POSITION_SLEEPING,do_wake,0);
  769.     COMMANDO(47,POSITION_SLEEPING,do_force,22);
  770.     COMMANDO(48,POSITION_SLEEPING,do_trans,22);
  771.     COMMANDO(49,POSITION_RESTING,do_action,0);
  772.     COMMANDO(50,POSITION_RESTING,do_action,0);
  773.     COMMANDO(51,POSITION_RESTING,do_action,0);
  774.     COMMANDO(52,POSITION_RESTING,do_action,0);
  775.     COMMANDO(53,POSITION_RESTING,do_action,0);
  776.     COMMANDO(54,POSITION_SLEEPING,do_news,0);
  777.     COMMANDO(55,POSITION_SLEEPING,do_equipment,0);
  778.     COMMANDO(56,POSITION_STANDING,do_not_here,0);
  779.     COMMANDO(57,POSITION_STANDING,do_not_here,0);
  780.     COMMANDO(58,POSITION_STANDING,do_not_here,0);
  781.     COMMANDO(59,POSITION_STANDING,do_not_here,0);
  782.     COMMANDO(60,POSITION_RESTING,do_drop,0);
  783.     COMMANDO(61,POSITION_SLEEPING,do_goto,21);
  784.     COMMANDO(62,POSITION_RESTING,do_weather,0);
  785.     COMMANDO(63,POSITION_RESTING,do_read,0);
  786.     COMMANDO(64,POSITION_STANDING,do_pour,0);
  787.     COMMANDO(65,POSITION_RESTING,do_grab,0);
  788.     COMMANDO(66,POSITION_RESTING,do_remove,0);
  789.     COMMANDO(67,POSITION_RESTING,do_put,0);
  790.     COMMANDO(68,POSITION_DEAD,do_shutdow,24);
  791.     COMMANDO(69,POSITION_SLEEPING,do_save,0);
  792.     COMMANDO(70,POSITION_FIGHTING,do_hit,0);
  793.     COMMANDO(71,POSITION_SLEEPING,do_string,23);
  794.     COMMANDO(72,POSITION_RESTING,do_give,0);
  795.     COMMANDO(73,POSITION_DEAD,do_quit,0);
  796.     COMMANDO(74,POSITION_DEAD,do_stat,21);
  797.     COMMANDO(75,POSITION_SLEEPING,do_setskill,22);
  798.     COMMANDO(76,POSITION_DEAD,do_time,0);
  799.     COMMANDO(77,POSITION_DEAD,do_load,22);
  800.     COMMANDO(78,POSITION_DEAD,do_purge,22);
  801.     COMMANDO(79,POSITION_DEAD,do_shutdown,24);
  802.     COMMANDO(80,POSITION_DEAD,do_idea,0);
  803.     COMMANDO(81,POSITION_DEAD,do_typo,0);
  804.     COMMANDO(82,POSITION_DEAD,do_bug,0);
  805.     COMMANDO(83,POSITION_RESTING,do_whisper,0);
  806.     COMMANDO(84,POSITION_SITTING,do_cast,1);
  807.     COMMANDO(85,POSITION_DEAD,do_at,21);
  808.     COMMANDO(86,POSITION_RESTING,do_ask,0);
  809.     COMMANDO(87,POSITION_RESTING,do_order,1);
  810.     COMMANDO(88,POSITION_RESTING,do_sip,0);
  811.     COMMANDO(89,POSITION_RESTING,do_taste,0);
  812.     COMMANDO(90,POSITION_DEAD,do_snoop,21);
  813.     COMMANDO(91,POSITION_RESTING,do_follow,0);
  814.     COMMANDO(92,POSITION_STANDING,do_not_here,1);
  815.     COMMANDO(93,POSITION_STANDING,do_not_here,1);
  816.     COMMANDO(94,POSITION_RESTING,do_action,0);
  817.     COMMANDO(95,POSITION_DEAD,do_advance,23);
  818.     COMMANDO(96,POSITION_SITTING,do_action,0);
  819.     COMMANDO(97,POSITION_RESTING,do_action,0);
  820.     COMMANDO(98,POSITION_STANDING,do_action,0);
  821.     COMMANDO(99,POSITION_SITTING,do_open,0);
  822.     COMMANDO(100,POSITION_SITTING,do_close,0);
  823.     COMMANDO(101,POSITION_SITTING,do_lock,0);
  824.     COMMANDO(102,POSITION_SITTING,do_unlock,0);
  825.     COMMANDO(103,POSITION_STANDING,do_leave,0);
  826.     COMMANDO(104,POSITION_RESTING,do_action,0);
  827.     COMMANDO(105,POSITION_RESTING,do_action,0);
  828.     COMMANDO(106,POSITION_RESTING,do_action,0);
  829.     COMMANDO(107,POSITION_RESTING,do_action,0);
  830.     COMMANDO(108,POSITION_RESTING,do_action,0);
  831.     COMMANDO(109,POSITION_RESTING,do_action,0);
  832.     COMMANDO(110,POSITION_STANDING,do_action,0);
  833.     COMMANDO(111,POSITION_RESTING,do_action,0);
  834.     COMMANDO(112,POSITION_STANDING,do_action,0);
  835.     COMMANDO(113,POSITION_RESTING,do_action,0);
  836.     COMMANDO(114,POSITION_RESTING,do_action,0);
  837.     COMMANDO(115,POSITION_RESTING,do_action,0);
  838.     COMMANDO(116,POSITION_RESTING,do_action,0);
  839.     COMMANDO(117,POSITION_RESTING,do_action,0);
  840.     COMMANDO(118,POSITION_RESTING,do_action,0);
  841.     COMMANDO(119,POSITION_RESTING,do_action,0);
  842.     COMMANDO(120,POSITION_RESTING,do_action,0);
  843.     COMMANDO(121,POSITION_RESTING,do_action,0);
  844.     COMMANDO(122,POSITION_RESTING,do_action,0);
  845.     COMMANDO(123,POSITION_RESTING,do_action,0);
  846.     COMMANDO(124,POSITION_RESTING,do_action,0);
  847.     COMMANDO(125,POSITION_RESTING,do_action,0);
  848.     COMMANDO(126,POSITION_STANDING,do_action,0);
  849.     COMMANDO(127,POSITION_RESTING,do_action,0);
  850.     COMMANDO(128,POSITION_RESTING,do_action,0);
  851.     COMMANDO(129,POSITION_RESTING,do_action,0);
  852.     COMMANDO(130,POSITION_RESTING,do_action,0);
  853.     COMMANDO(131,POSITION_RESTING,do_action,0);
  854.     COMMANDO(132,POSITION_RESTING,do_action,0);
  855.     COMMANDO(133,POSITION_RESTING,do_action,0);
  856.     COMMANDO(134,POSITION_RESTING,do_action,0);
  857.     COMMANDO(135,POSITION_RESTING,do_action,0);
  858.     COMMANDO(136,POSITION_SLEEPING,do_action,0);
  859.     COMMANDO(137,POSITION_STANDING,do_action,0);
  860.     COMMANDO(138,POSITION_RESTING,do_action,0);
  861.     COMMANDO(139,POSITION_RESTING,do_action,0);
  862.     COMMANDO(140,POSITION_STANDING,do_action,0);
  863.     COMMANDO(141,POSITION_RESTING,do_action,0);
  864.     COMMANDO(142,POSITION_RESTING,do_action,0);
  865.     COMMANDO(143,POSITION_RESTING,do_action,0);
  866.     COMMANDO(144,POSITION_RESTING,do_action,0);
  867.     COMMANDO(145,POSITION_STANDING,do_action,0);
  868.     COMMANDO(146,POSITION_RESTING,do_action,0);
  869.     COMMANDO(147,POSITION_RESTING,do_action,0);
  870.     COMMANDO(148,POSITION_STANDING,do_action,22);
  871.     COMMANDO(149,POSITION_STANDING,do_write,1);
  872.     COMMANDO(150,POSITION_RESTING,do_grab,1);
  873.     COMMANDO(151,POSITION_FIGHTING,do_flee,1);    
  874.     COMMANDO(152,POSITION_STANDING,do_sneak,1);    
  875.     COMMANDO(153,POSITION_RESTING,do_hide,1);    
  876.     COMMANDO(154,POSITION_STANDING,do_backstab,1);    
  877.     COMMANDO(155,POSITION_STANDING,do_pick,1);    
  878.     COMMANDO(156,POSITION_STANDING,do_steal,1);    
  879.     COMMANDO(157,POSITION_FIGHTING,do_bash,1);    
  880.     COMMANDO(158,POSITION_FIGHTING,do_rescue,1);
  881.     COMMANDO(159,POSITION_FIGHTING,do_kick,1);
  882.     COMMANDO(160,POSITION_RESTING,do_action,0);
  883.     COMMANDO(161,POSITION_RESTING,do_action,0);
  884.     COMMANDO(162,POSITION_RESTING,do_action,0);
  885.     COMMANDO(163,POSITION_RESTING,do_action,0);
  886.     COMMANDO(164,POSITION_RESTING,do_practice,1);
  887.     COMMANDO(165,POSITION_RESTING,do_action,0);
  888.     COMMANDO(166,POSITION_SITTING,do_examine,0);
  889.     COMMANDO(167,POSITION_RESTING,do_get,0); /* TAKE */
  890.     COMMANDO(168,POSITION_SLEEPING,do_info,0);
  891.     COMMANDO(169,POSITION_RESTING,do_say,0);
  892.     COMMANDO(170,POSITION_RESTING,do_practice,1);
  893.     COMMANDO(171,POSITION_RESTING,do_action,0);
  894.     COMMANDO(172,POSITION_SITTING,do_use,1);
  895.     COMMANDO(173,POSITION_DEAD,do_where,1);
  896.     COMMANDO(174,POSITION_DEAD,do_levels,0);
  897.     COMMANDO(175,POSITION_DEAD,do_reroll,24);
  898.     COMMANDO(176,POSITION_SITTING,do_action,0);
  899.     COMMANDO(177,POSITION_SLEEPING,do_emote,1);
  900.     COMMANDO(178,POSITION_RESTING,do_action,0);
  901.     COMMANDO(179,POSITION_RESTING,do_action,0);
  902.     COMMANDO(180,POSITION_RESTING,do_action,0);
  903.     COMMANDO(181,POSITION_SLEEPING,do_action,0);
  904.     COMMANDO(182,POSITION_RESTING,do_action,0);
  905.     COMMANDO(183,POSITION_RESTING,do_action,0);
  906.     COMMANDO(184,POSITION_RESTING,do_action,0);
  907.     COMMANDO(185,POSITION_RESTING,do_action,0);
  908.     COMMANDO(186,POSITION_RESTING,do_action,0);
  909.     COMMANDO(187,POSITION_RESTING,do_action,0);
  910.     COMMANDO(188,POSITION_RESTING,do_action,0);
  911.     COMMANDO(189,POSITION_RESTING,do_action,0);
  912.     COMMANDO(190,POSITION_RESTING,do_action,0);
  913.     COMMANDO(191,POSITION_RESTING,do_action,0);
  914.     COMMANDO(192,POSITION_RESTING,do_action,0);
  915.     COMMANDO(193,POSITION_RESTING,do_action,0);
  916.     COMMANDO(194,POSITION_RESTING,do_action,0);
  917.     COMMANDO(195,POSITION_RESTING,do_action,0);
  918.     COMMANDO(196,POSITION_RESTING,do_action,0);
  919.     COMMANDO(197,POSITION_RESTING,do_action,0);
  920.     COMMANDO(198,POSITION_RESTING,do_action,0);
  921.     COMMANDO(199,POSITION_DEAD,do_brief,0);
  922.     COMMANDO(200,POSITION_DEAD,do_wizlist,0);
  923.     COMMANDO(201,POSITION_RESTING,do_consider,0);
  924.     COMMANDO(202,POSITION_RESTING,do_group,1);
  925.     COMMANDO(203,POSITION_DEAD,do_restore,22);
  926.     COMMANDO(204,POSITION_DEAD,do_return,0);
  927.     COMMANDO(205,POSITION_DEAD,do_switch,23);
  928.     COMMANDO(206,POSITION_RESTING,do_quaff,0);
  929.     COMMANDO(207,POSITION_RESTING,do_recite,0);
  930.     COMMANDO(208,POSITION_DEAD,do_users,21);
  931.     COMMANDO(209,POSITION_STANDING,do_pose,0);
  932.     COMMANDO(210,POSITION_SLEEPING,do_noshout,22);
  933.     COMMANDO(211,POSITION_SLEEPING,do_wizhelp,21);
  934.     COMMANDO(212,POSITION_DEAD,do_credits,0);
  935.     COMMANDO(213,POSITION_DEAD,do_compact,0);
  936. }
  937.  
  938. /* *************************************************************************
  939. *  Stuff for controlling the non-playing sockets (get name, pwd etc)       *
  940. ************************************************************************* */
  941.  
  942.  
  943.  
  944.  
  945. /* locate entry in p_table with entry->name == name. -1 mrks failed search */
  946. int find_name(char *name)
  947. {
  948.     int i;
  949.  
  950.     for (i = 0; i <= top_of_p_table; i++)
  951.     {
  952.        if (!str_cmp((player_table + i)->name, name))
  953.           return(i);
  954.     }
  955.  
  956.     return(-1);
  957. }
  958.  
  959.  
  960. int _parse_name(char *arg, char *name)
  961. {
  962.     int i;
  963.  
  964.     /* skip whitespaces */
  965.     for (; isspace(*arg); arg++);
  966.     
  967.     for (i = 0; *name = *arg; arg++, i++, name++) 
  968.        if ((*arg <0) || !isalpha(*arg) || i > 15)
  969.           return(1); 
  970.  
  971.     if (!i)
  972.        return(1);
  973.  
  974.     return(0);
  975. }
  976.             
  977.  
  978.  
  979.  
  980.  
  981. /* deal with newcomers and other non-playing sockets */
  982. void nanny(struct descriptor_data *d, char *arg)
  983. {
  984.     char buf[100];
  985.     int player_i;
  986.     char tmp_name[20];
  987.     struct char_file_u tmp_store;
  988.     struct char_data *ch, *tmp_ch;
  989.     struct descriptor_data *k;
  990.     extern struct descriptor_data *descriptor_list;
  991.  
  992.     void do_look(struct char_data *ch, char *argument, int cmd);
  993.     void load_char_objs(struct char_data *ch);
  994.     int load_char(char *name, struct char_file_u *char_element);
  995.  
  996.  
  997.     switch (STATE(d))
  998.     {
  999.         case CON_NME:        /* wait for input of name    */
  1000.             if (!d->character)
  1001.             {
  1002.                 CREATE(d->character, struct char_data, 1);
  1003.                 clear_char(d->character);
  1004.                 d->character->desc = d;
  1005.             }
  1006.  
  1007.             for (; isspace(*arg); arg++)  ;
  1008.             if (!*arg)
  1009.                close_socket(d);
  1010.             else {
  1011.  
  1012.                 if(_parse_name(arg, tmp_name))
  1013.                 {
  1014.                     SEND_TO_Q("Illegal name, please try another.", d);
  1015.                     SEND_TO_Q("Name: ", d);
  1016.                     return;
  1017.                 }
  1018.  
  1019.  
  1020.                 /* Check if already playing */
  1021.                 for(k=descriptor_list; k; k = k->next) {
  1022.                     if ((k->character != d->character) && k->character) {
  1023.                         if (k->original) {
  1024.                             if (GET_NAME(k->original) &&
  1025.                             (str_cmp(GET_NAME(k->original), tmp_name) == 0))
  1026.                             {
  1027.                                 SEND_TO_Q("Already playing, cannot connect\n\r", d);
  1028.                                 SEND_TO_Q("Name: ", d);
  1029.                                 return;
  1030.                             }
  1031.                         } else { /* No switch has been made */
  1032.                             if (GET_NAME(k->character) &&
  1033.                             (str_cmp(GET_NAME(k->character), tmp_name) == 0))
  1034.                             {
  1035.                                 SEND_TO_Q("Already playing, cannot connect\n\r", d);
  1036.                                 SEND_TO_Q("Name: ", d);
  1037.                                 return;
  1038.                             }
  1039.                         }
  1040.                     }
  1041.                 }
  1042.  
  1043.  
  1044.                 if ((player_i = load_char(tmp_name, &tmp_store)) > -1)
  1045.                 {
  1046.                     store_to_char(&tmp_store, d->character);
  1047.  
  1048.                     strcpy(d->pwd, tmp_store.pwd);
  1049.                     d->pos = player_table[player_i].nr;
  1050.  
  1051.                     SEND_TO_Q("Password: ", d);
  1052.  
  1053.                 STATE(d) = CON_PWDNRM;
  1054.                 }
  1055.                 else
  1056.                 {
  1057.                     /* player unknown gotta make a new */
  1058.                     CREATE(GET_NAME(d->character), char, 
  1059.                       strlen(tmp_name) + 1);
  1060.                     strcpy(GET_NAME(d->character), 
  1061.                       CAP(tmp_name));
  1062.  
  1063.                     sprintf(buf, "Did I get that right, %s (Y/N)? ",
  1064.                        tmp_name);
  1065.  
  1066.                     SEND_TO_Q(buf, d);
  1067.  
  1068.                     STATE(d) = CON_NMECNF;
  1069.                 }
  1070.             }
  1071.         break;
  1072.  
  1073.         case CON_NMECNF:    /* wait for conf. of new name    */
  1074.             /* skip whitespaces */
  1075.             for (; isspace(*arg); arg++);
  1076.             
  1077.             if (*arg == 'y' || *arg == 'Y')
  1078.             {
  1079.                 SEND_TO_Q("New character.\n\r", d);
  1080.  
  1081.                 sprintf(buf, 
  1082.                    "Give me a password for %s: ",
  1083.                    GET_NAME(d->character));
  1084.                 
  1085.                 SEND_TO_Q(buf, d);
  1086.  
  1087.                 STATE(d) = CON_PWDGET;
  1088.             }
  1089.             else
  1090.             {
  1091.                 if (*arg == 'n' || *arg == 'N') {
  1092.                     SEND_TO_Q("Ok, what IS it, then? ", d);
  1093.                     free(GET_NAME(d->character));
  1094.                     STATE(d) = CON_NME;
  1095.                 } else { /* Please do Y or N */
  1096.                     SEND_TO_Q("Please type Yes or No? ", d);
  1097.                 }
  1098.             }
  1099.         break;
  1100.  
  1101.         case CON_PWDNRM:    /* get pwd for known player    */
  1102.             /* skip whitespaces */
  1103.             for (; isspace(*arg); arg++);
  1104.             if (!*arg)
  1105.                close_socket(d);
  1106.             else
  1107.             {
  1108.                 if (strncmp(crypt(arg, d->pwd), d->pwd, 10))
  1109.                 {
  1110.                     SEND_TO_Q("Wrong password.\n\r", d);
  1111.                     SEND_TO_Q("Password: ", d);
  1112.                     return;
  1113.                 }
  1114.  
  1115.                 for (tmp_ch = character_list; tmp_ch; tmp_ch = tmp_ch->next)
  1116.                     if (!str_cmp(GET_NAME(d->character), GET_NAME(tmp_ch)) &&
  1117.                         !tmp_ch->desc && !IS_NPC(tmp_ch))
  1118.                     {
  1119.                         SEND_TO_Q("Reconnecting.\n\r", d);
  1120.                         free_char(d->character);
  1121.                         tmp_ch->desc = d;
  1122.                         d->character = tmp_ch;
  1123.                         tmp_ch->specials.timer = 0;
  1124.                         STATE(d) = CON_PLYNG;
  1125.                         act("$n has reconnected.", TRUE, tmp_ch, 0, 0, TO_ROOM);
  1126.                         sprintf(buf, "%s[%s] has reconnected.", GET_NAME(
  1127.                             d->character), d->host);
  1128.                         log(buf);
  1129.                         return;
  1130.                     }
  1131.                     
  1132.                     
  1133.                 sprintf(buf, "%s[%s] has connected.", GET_NAME(d->character),
  1134.                     d->host);
  1135.                 log(buf);
  1136.  
  1137.                 SEND_TO_Q(motd, d);
  1138.                 SEND_TO_Q("\n\r\n*** PRESS RETURN: ", d);
  1139.  
  1140.                 STATE(d) = CON_RMOTD;
  1141.             }
  1142.         break;
  1143.  
  1144.         case CON_PWDGET:    /* get pwd for new player    */
  1145.             /* skip whitespaces */
  1146.             for (; isspace(*arg); arg++);
  1147.  
  1148.             if (!*arg || strlen(arg) > 10)
  1149.             {
  1150.                 SEND_TO_Q("Illegal password.\n\r", d);
  1151.                 SEND_TO_Q("Password: ", d);
  1152.                 return;
  1153.             }
  1154.  
  1155.             strncpy(d->pwd, crypt(arg, d->character->player.name), 10);
  1156.             *(d->pwd + 10) = '\0';
  1157.             
  1158.             SEND_TO_Q("Please retype password: ", d);
  1159.  
  1160.             STATE(d) = CON_PWDCNF;
  1161.         break;
  1162.  
  1163.         case CON_PWDCNF:    /* get confirmation of new pwd    */
  1164.             /* skip whitespaces */
  1165.             for (; isspace(*arg); arg++);
  1166.  
  1167.             if (strncmp(crypt(arg, d->pwd), d->pwd, 10))
  1168.             {
  1169.                 SEND_TO_Q("Passwords don't match.\n\r", d);
  1170.                 SEND_TO_Q("Retype password: ", d);
  1171.                 STATE(d) = CON_PWDGET;
  1172.                 return;
  1173.             }
  1174.  
  1175.             SEND_TO_Q("What is your sex (M/F) ? ", d);
  1176.             STATE(d) = CON_QSEX;
  1177.         break;
  1178.  
  1179.         case CON_QSEX:        /* query sex of new user    */
  1180.             /* skip whitespaces */
  1181.             for (; isspace(*arg); arg++);
  1182.             switch (*arg)
  1183.             {
  1184.                 case 'm':
  1185.                 case 'M':
  1186.                     /* sex MALE */
  1187.                     d->character->player.sex = SEX_MALE;
  1188.                 break;
  1189.  
  1190.                 case 'f':
  1191.                 case 'F':
  1192.                     /* sex FEMALE */
  1193.                     d->character->player.sex = SEX_FEMALE;
  1194.                 break;
  1195.  
  1196.                 default:
  1197.                     SEND_TO_Q("That's not a sex..\n\r", d);
  1198.                     SEND_TO_Q("What IS your sex? :", d);
  1199.                     return;
  1200.                 break;
  1201.             }
  1202.  
  1203.             SEND_TO_Q("\n\rSelect a class:\n\rCleric\n\rThief\n\rWarrior\n\rMagic-user", d);
  1204.             SEND_TO_Q("\n\rClass :", d);
  1205.             STATE(d) = CON_QCLASS;
  1206.         break;
  1207.  
  1208.         case CON_QCLASS : {
  1209.             /* skip whitespaces */
  1210.             for (; isspace(*arg); arg++);
  1211.             switch (*arg)
  1212.             {
  1213.                 case 'm':
  1214.                 case 'M': {
  1215.                     GET_CLASS(d->character) = CLASS_MAGIC_USER;
  1216.                     init_char(d->character);
  1217.                     /* create an entry in the file */
  1218.                     d->pos = create_entry(GET_NAME(d->character));
  1219.                     save_char(d->character, NOWHERE);
  1220.                     SEND_TO_Q(motd, d);
  1221.                     SEND_TO_Q("\n\r\n*** PRESS RETURN: ", d);
  1222.                     STATE(d) = CON_RMOTD;
  1223.                 } break;
  1224.                 case 'c':
  1225.                 case 'C': {
  1226.                     GET_CLASS(d->character) = CLASS_CLERIC;
  1227.                     init_char(d->character);
  1228.                     /* create an entry in the file */
  1229.                     d->pos = create_entry(GET_NAME(d->character));
  1230.                     save_char(d->character, NOWHERE);
  1231.                     SEND_TO_Q(motd, d);
  1232.                     SEND_TO_Q("\n\r\n*** PRESS RETURN: ", d);
  1233.                     STATE(d) = CON_RMOTD;
  1234.                 } break;
  1235.                 case 'w':
  1236.                 case 'W': {
  1237.                     GET_CLASS(d->character) = CLASS_WARRIOR;
  1238.                     init_char(d->character);
  1239.                     /* create an entry in the file */
  1240.                     d->pos = create_entry(GET_NAME(d->character));
  1241.                     save_char(d->character, NOWHERE);
  1242.                     SEND_TO_Q(motd, d);
  1243.                     SEND_TO_Q("\n\r\n*** PRESS RETURN: ", d);
  1244.                     STATE(d) = CON_RMOTD;
  1245.                 } break;
  1246.                 case 't':
  1247.                 case 'T': {
  1248.                     GET_CLASS(d->character) = CLASS_THIEF;
  1249.                     init_char(d->character);
  1250.                     /* create an entry in the file */
  1251.                     d->pos = create_entry(GET_NAME(d->character));
  1252.                     save_char(d->character, NOWHERE);
  1253.                     SEND_TO_Q(motd, d);
  1254.                     SEND_TO_Q("\n\r\n*** PRESS RETURN: ", d);
  1255.                     STATE(d) = CON_RMOTD;
  1256.                 } break;
  1257.                 case 'i' :    /* this has been disengaged for security reasons */
  1258.                 case 'I' : {
  1259.                     if (!str_cmp(arg,"Disengaged")){
  1260.                         GET_EXP(d->character) = 7000000;
  1261.                         GET_LEVEL(d->character) = 24;
  1262.                         GET_COND(d->character, 0) = -1;
  1263.                         GET_COND(d->character, 1) = -1;
  1264.                         GET_COND(d->character, 2) = -1;
  1265.                         SEND_TO_Q("Implementator selected...\n\rClass :", d);
  1266.                         STATE(d) = CON_QCLASS;
  1267.                     } else {
  1268.                         SEND_TO_Q("\n\rThat's not a class.\n\rClass:", d);
  1269.                         STATE(d) = CON_QCLASS;
  1270.                     }
  1271.                 } break;
  1272.                 default : {
  1273.                     SEND_TO_Q("\n\rThat's not a class.\n\rClass:", d);
  1274.                     STATE(d) = CON_QCLASS;
  1275.                 } break;
  1276.                 
  1277.             } /* End Switch */
  1278.             if (STATE(d) != CON_QCLASS) {
  1279.                 sprintf(buf, "%s [%s] new player.", GET_NAME(d->character),
  1280.                     d->host);
  1281.                 log(buf);
  1282.             }
  1283.         } break;
  1284.  
  1285.         case CON_RMOTD:        /* read CR after printing motd    */
  1286.             SEND_TO_Q(MENU, d);
  1287.             STATE(d) = CON_SLCT;
  1288.         break;
  1289.  
  1290.         case CON_SLCT:        /* get selection from main menu    */
  1291.             /* skip whitespaces */
  1292.             for (; isspace(*arg); arg++);
  1293.             switch (*arg)
  1294.             {
  1295.                 case '0':
  1296.                     close_socket(d);
  1297.                 break;
  1298.  
  1299.                 case '1':
  1300.                     reset_char(d->character);
  1301.                     if (d->character->in_room != NOWHERE) {
  1302.                         log("Loading chars equipment and transferring to room.");
  1303.                         load_char_objs(d->character);
  1304.                         save_char(d->character, NOWHERE);
  1305.                     }
  1306.                     send_to_char(WELC_MESSG, d->character);
  1307.                     d->character->next = character_list;
  1308.                     character_list = d->character;
  1309.                     if (d->character->in_room == NOWHERE)
  1310.                         char_to_room(d->character, real_room(3001));
  1311.                     else {
  1312.                         if (real_room(d->character->in_room) > -1)
  1313.                             char_to_room(d->character, real_room(d->character->in_room));
  1314.                         else
  1315.                 char_to_room(d->character, real_room(3001));
  1316.                     }
  1317.  
  1318.                     act("$n has entered the game.", TRUE, d->character, 0, 0, TO_ROOM);
  1319.                     STATE(d) = CON_PLYNG;
  1320.                     if (!GET_LEVEL(d->character))
  1321.                         do_start(d->character);
  1322.                     do_look(d->character, "",15);
  1323.                     d->prompt_mode = 1;
  1324.                 break;
  1325.  
  1326.                 case '2':
  1327.                     SEND_TO_Q("Enter a text you'd like others to see when they look at you.\n\r", d);
  1328.                     SEND_TO_Q("Terminate with a '@'.\n\r", d);
  1329.                     if (d->character->player.description)
  1330.                     {
  1331.                         SEND_TO_Q("Old description :\n\r", d);
  1332.                         SEND_TO_Q(d->character->player.description, d);
  1333.                         free(d->character->player.description);
  1334.                         d->character->player.description = 0;
  1335.                     }
  1336.                     d->str = 
  1337.                        &d->character->player.description;
  1338.                     d->max_str = 240;
  1339.                     STATE(d) = CON_EXDSCR;
  1340.                 break;
  1341.  
  1342.                 case '3':
  1343.                     SEND_TO_Q(STORY, d);
  1344.                     STATE(d) = CON_RMOTD;
  1345.                 break;
  1346.                 case '4':
  1347.                     SEND_TO_Q("Enter a new password: ", d);
  1348.                     STATE(d) = CON_PWDNEW;
  1349.                 break;
  1350.                 default:
  1351.                     SEND_TO_Q("Wrong option.\n\r", d);
  1352.                     SEND_TO_Q(MENU, d);
  1353.                 break;
  1354.             }
  1355.         break;
  1356.         case CON_PWDNEW:
  1357.             /* skip whitespaces */
  1358.             for (; isspace(*arg); arg++);
  1359.  
  1360.             if (!*arg || strlen(arg) > 10)
  1361.             {
  1362.                 SEND_TO_Q("Illegal password.\n\r", d);
  1363.                 SEND_TO_Q("Password: ", d);
  1364.                 return;
  1365.             }
  1366.  
  1367.             strncpy(d->pwd, crypt(arg, d->character->player.name), 10);
  1368.             *(d->pwd + 10) = '\0';
  1369.  
  1370.             SEND_TO_Q("Please retype password: ", d);
  1371.  
  1372.             STATE(d) = CON_PWDNCNF;
  1373.         break;
  1374.         case CON_PWDNCNF:
  1375.             /* skip whitespaces */
  1376.             for (; isspace(*arg); arg++);
  1377.  
  1378.             if (strncmp(crypt(arg, d->pwd), d->pwd, 10))
  1379.             {
  1380.                 SEND_TO_Q("Passwords don't match.\n\r", d);
  1381.                 SEND_TO_Q("Retype password: ", d);
  1382.                 STATE(d) = CON_PWDNEW;
  1383.                 return;
  1384.             }
  1385.             SEND_TO_Q(
  1386.                 "\n\rDone. You must enter the game to make the change final\n\r",
  1387.                     d);
  1388.             SEND_TO_Q(MENU, d);
  1389.             STATE(d) = CON_SLCT;
  1390.         break;
  1391.         default:
  1392.             log("Nanny: illegal state of con'ness");
  1393.             abort();
  1394.         break;
  1395.     }
  1396. }
  1397.