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