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 / act.other.c < prev    next >
C/C++ Source or Header  |  1991-03-01  |  16KB  |  656 lines
  1. /* ************************************************************************
  2. *  file: act.other.c , Implementation of commands.        Part of DIKUMUD *
  3. *  Usage : Other commands.                                                *
  4. *  Copyright (C) 1990, 1991 - see 'license.doc' for complete information. *
  5. ************************************************************************* */
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <ctype.h>
  10.  
  11. #include "structs.h"
  12. #include "utils.h"
  13. #include "comm.h"
  14. #include "interpreter.h"
  15. #include "handler.h"
  16. #include "db.h"
  17. #include "spells.h"
  18.  
  19. /* extern variables */
  20.  
  21. extern struct str_app_type str_app[];
  22. extern struct room_data *world;
  23. extern struct descriptor_data *descriptor_list;
  24. extern struct room_data *world;
  25. extern struct dex_skill_type dex_app_skill[];
  26. extern struct spell_info_type spell_info[];
  27.  
  28.  
  29. /* extern procedures */
  30.  
  31. void hit(struct char_data *ch, struct char_data *victim, int type);
  32. void do_shout(struct char_data *ch, char *argument, int cmd);
  33.  
  34.  
  35.  
  36. void do_qui(struct char_data *ch, char *argument, int cmd)
  37. {
  38.     send_to_char("You have to write quit - no less, to quit!\n\r",ch);
  39.     return;
  40. }
  41.  
  42. void do_quit(struct char_data *ch, char *argument, int cmd)
  43. {
  44.     void do_save(struct char_data *ch, char *argument, int cmd);
  45.     void die(struct char_data *ch);
  46.  
  47.     if (IS_NPC(ch) || !ch->desc)
  48.         return;
  49.  
  50.     if (GET_POS(ch) == POSITION_FIGHTING) {
  51.         send_to_char("No way! You are fighting.\n\r", ch);
  52.         return;
  53.     }
  54.  
  55.     if (GET_POS(ch) < POSITION_STUNNED) {
  56.         send_to_char("You die before your time!\n\r", ch);
  57.         die(ch);
  58.         return;
  59.     }
  60.  
  61.     act("Goodbye, friend.. Come back soon!", FALSE, ch, 0, 0, TO_CHAR);
  62.     act("$n has left the game.", TRUE, ch,0,0,TO_ROOM);
  63.     extract_char(ch); /* Char is saved in extract char */
  64. }
  65.  
  66.  
  67.  
  68. void do_save(struct char_data *ch, char *argument, int cmd)
  69. {
  70.     char buf[100];
  71.  
  72.     if (IS_NPC(ch) || !ch->desc)
  73.         return;
  74.  
  75.     sprintf(buf, "Saving %s.\n\r", GET_NAME(ch));
  76.     send_to_char(buf, ch);
  77.     save_char(ch, NOWHERE);
  78. }
  79.  
  80.  
  81. void do_not_here(struct char_data *ch, char *argument, int cmd)
  82. {
  83.     send_to_char("Sorry, but you cannot do that here!\n\r",ch);
  84. }
  85.  
  86.  
  87.  
  88. void do_sneak(struct char_data *ch, char *argument, int cmd)
  89. {
  90.     struct affected_type af;
  91.     byte percent;
  92.  
  93.     send_to_char("Ok, you'll try to move silently for a while.\n\r", ch);
  94.     if (IS_AFFECTED(ch, AFF_SNEAK))
  95.         affect_from_char(ch, SKILL_SNEAK);
  96.  
  97.     percent=number(1,101); /* 101% is a complete failure */
  98.  
  99.     if (percent > ch->skills[SKILL_SNEAK].learned +
  100.         dex_app_skill[GET_DEX(ch)].sneak)
  101.         return;
  102.  
  103.     af.type = SKILL_SNEAK;
  104.     af.duration = GET_LEVEL(ch);
  105.     af.modifier = 0;
  106.     af.location = APPLY_NONE;
  107.     af.bitvector = AFF_SNEAK;
  108.     affect_to_char(ch, &af);
  109. }
  110.  
  111.  
  112.  
  113. void do_hide(struct char_data *ch, char *argument, int cmd)
  114. {
  115.     byte percent;
  116.  
  117.     send_to_char("You attempt to hide yourself.\n\r", ch);
  118.  
  119.     if (IS_AFFECTED(ch, AFF_HIDE))
  120.         REMOVE_BIT(ch->specials.affected_by, AFF_HIDE);
  121.  
  122.     percent=number(1,101); /* 101% is a complete failure */
  123.  
  124.     if (percent > ch->skills[SKILL_HIDE].learned +
  125.         dex_app_skill[GET_DEX(ch)].hide)
  126.         return;
  127.  
  128.     SET_BIT(ch->specials.affected_by, AFF_HIDE);
  129. }
  130.  
  131.  
  132. void do_steal(struct char_data *ch, char *argument, int cmd)
  133. {
  134.     struct char_data *victim;
  135.     struct obj_data *obj;
  136.     char victim_name[240];
  137.     char obj_name[240];
  138.     char buf[240];
  139.     int percent, bits;
  140.     bool equipment = FALSE;
  141.     int gold, eq_pos;
  142.     bool ohoh = FALSE;
  143.  
  144.  
  145.  
  146.     argument = one_argument(argument, obj_name);
  147.     one_argument(argument, victim_name);
  148.  
  149.  
  150.     if (!(victim = get_char_room_vis(ch, victim_name))) {
  151.         send_to_char("Steal what from who?\n\r", ch);
  152.         return;
  153.     } else if (victim == ch) {
  154.         send_to_char("Come on now, that's rather stupid!\n\r", ch);
  155.         return;
  156.     }
  157.  
  158.     if ((GET_EXP(ch) < 1250) && (!IS_NPC(victim))) {
  159.       send_to_char("Due to misuse of steal, you can't steal from other players\n\r", ch);
  160.       send_to_char("unless you got at least 1,250 experience points.\n\r", ch);
  161.       return;
  162.     }
  163.  
  164.     /* 101% is a complete failure */
  165.     percent=number(1,101) - dex_app_skill[GET_DEX(ch)].p_pocket;
  166.  
  167.     if (GET_POS(victim) < POSITION_SLEEPING)
  168.         percent = -1; /* ALWAYS SUCCESS */
  169.  
  170.     if (GET_LEVEL(victim)>20) /* NO NO With Imp's and Shopkeepers! */
  171.         percent = 101; /* Failure */
  172.  
  173.     if (str_cmp(obj_name, "coins") && str_cmp(obj_name,"gold")) {
  174.  
  175.         if (!(obj = get_obj_in_list_vis(victim, obj_name, victim->carrying))) {
  176.  
  177.             for (eq_pos = 0; (eq_pos < MAX_WEAR); eq_pos++)
  178.                 if (victim->equipment[eq_pos] &&
  179.                    (isname(obj_name, victim->equipment[eq_pos]->name)) &&
  180.                         CAN_SEE_OBJ(ch,victim->equipment[eq_pos])) {
  181.                     obj = victim->equipment[eq_pos];
  182.                     break;
  183.                 }
  184.  
  185.             if (!obj) {
  186.                 act("$E has not got that item.",FALSE,ch,0,victim,TO_CHAR);
  187.                 return;
  188.             } else { /* It is equipment */
  189.                 if ((GET_POS(victim) > POSITION_STUNNED)) {
  190.                     send_to_char("Steal the equipment now? Impossible!\n\r", ch);
  191.                     return;
  192.                 } else {
  193.                     act("You unequip $p and steal it.",FALSE, ch, obj ,0, TO_CHAR);
  194.                     act("$n steals $p from $N.",FALSE,ch,obj,victim,TO_NOTVICT);
  195.                     obj_to_char(unequip_char(victim, eq_pos), ch);
  196.                 }
  197.             }
  198.         } else {  /* obj found in inventory */
  199.  
  200.             percent += GET_OBJ_WEIGHT(obj); /* Make heavy harder */
  201.  
  202.             if (AWAKE(victim) && (percent > ch->skills[SKILL_STEAL].learned)) {
  203.                 ohoh = TRUE;
  204.                 act("Oops..", FALSE, ch,0,0,TO_CHAR);
  205.                 act("$n tried to steal something from you!",FALSE,ch,0,victim,TO_VICT);
  206.                 act("$n tries to steal something from $N.", TRUE, ch, 0, victim, TO_NOTVICT);
  207.             } else { /* Steal the item */
  208.                 if ((IS_CARRYING_N(ch) + 1 < CAN_CARRY_N(ch))) {
  209.                     if ((IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj)) < CAN_CARRY_W(ch)) {
  210.                         obj_from_char(obj);
  211.                         obj_to_char(obj, ch);
  212.                         send_to_char("Got it!\n\r", ch);
  213.                     }
  214.                 } else
  215.                     send_to_char("You cannot carry that much.\n\r", ch);
  216.             }
  217.         }
  218.     } else { /* Steal some coins */
  219.         if (AWAKE(victim) && (percent > ch->skills[SKILL_STEAL].learned)) {
  220.             ohoh = TRUE;
  221.             act("Oops..", FALSE, ch,0,0,TO_CHAR);
  222.             act("You discover that $n has $s hands in your wallet.",FALSE,ch,0,victim,TO_VICT);
  223.             act("$n tries to steal gold from $N.",TRUE, ch, 0, victim, TO_NOTVICT);
  224.         } else {
  225.             /* Steal some gold coins */
  226.             gold = (int) ((GET_GOLD(victim)*number(1,10))/100);
  227.             gold = MIN(1782, gold);
  228.             if (gold > 0) {
  229.                 GET_GOLD(ch) += gold;
  230.                 GET_GOLD(victim) -= gold;
  231.                 sprintf(buf, "Bingo! You got %d gold coins.\n\r", gold);
  232.                 send_to_char(buf, ch);
  233.             } else {
  234.                 send_to_char("You couldn't get any gold...\n\r", ch);
  235.             }
  236.         }
  237.     }
  238.  
  239.     if (ohoh && IS_NPC(victim) && AWAKE(victim))
  240.         if (IS_SET(victim->specials.act, ACT_NICE_THIEF)) {
  241.             sprintf(buf, "%s is a bloody thief.", GET_NAME(ch));
  242.             do_shout(victim, buf, 0);
  243.             log(buf);
  244.             send_to_char("Don't you ever do that again!\n\r", ch);
  245.         } else {
  246.             hit(victim, ch, TYPE_UNDEFINED);
  247.         }
  248.  
  249. }
  250.  
  251.  
  252. #ifdef JKL
  253.  
  254. void do_pick(struct char_data *ch, char *argument, int cmd)
  255. {
  256.     byte percent;
  257.  
  258.     percent=number(1,101); /* 101% is a complete failure */
  259.  
  260.     if (percent > (ch->skills[SKILL_PICK_LOCK].learned +
  261.         dex_app_skill[GET_DEX(ch)].p_locks)) {
  262.         send_to_char("You failed to pick the lock.\n\r", ch);
  263.         return;
  264.     }
  265. }
  266.  
  267.  
  268. #endif
  269.  
  270. void do_practice(struct char_data *ch, char *arg, int cmd) {
  271.     send_to_char("You can only practise in a guild.\n\r", ch);
  272. }
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279. void do_idea(struct char_data *ch, char *argument, int cmd)
  280. {
  281.     FILE *fl;
  282.     char str[MAX_STRING_LENGTH];
  283.  
  284.     if (IS_NPC(ch))
  285.     {
  286.         send_to_char("Monsters can't have ideas - Go away.\n\r", ch);
  287.         return;
  288.     }
  289.  
  290.     /* skip whites */
  291.     for (; isspace(*argument); argument++);
  292.  
  293.     if (!*argument)
  294.     {
  295.         send_to_char("That doesn't sound like a good idea to me.. Sorry.\n\r",
  296.             ch);
  297.         return;
  298.     }
  299.  
  300.     if (!(fl = fopen(IDEA_FILE, "a")))
  301.     {
  302.         perror ("do_idea");
  303.         send_to_char("Could not open the idea-file.\n\r", ch);
  304.         return;
  305.     }
  306.  
  307.     sprintf(str, "**%s: %s\n", GET_NAME(ch), argument);
  308.     fputs(str, fl);
  309.     fclose(fl);
  310.     send_to_char("Ok. Thanks.\n\r", ch);
  311. }
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319. void do_typo(struct char_data *ch, char *argument, int cmd)
  320. {
  321.     FILE *fl;
  322.     char str[MAX_STRING_LENGTH];
  323.  
  324.     if (IS_NPC(ch))
  325.     {
  326.         send_to_char("Monsters can't spell - leave me alone.\n\r", ch);
  327.         return;
  328.     }
  329.  
  330.     /* skip whites */
  331.     for (; isspace(*argument); argument++);
  332.  
  333.     if (!*argument)
  334.     {
  335.         send_to_char("I beg your pardon?\n\r",
  336.             ch);
  337.         return;
  338.     }
  339.  
  340.     if (!(fl = fopen(TYPO_FILE, "a")))
  341.     {
  342.         perror ("do_typo");
  343.         send_to_char("Could not open the typo-file.\n\r", ch);
  344.         return;
  345.     }
  346.  
  347.     sprintf(str, "**%s[%d]: %s\n",
  348.         GET_NAME(ch), world[ch->in_room].number, argument);
  349.     fputs(str, fl);
  350.     fclose(fl);
  351.     send_to_char("Ok. thanks.\n\r", ch);
  352. }
  353.  
  354.  
  355.  
  356.  
  357.  
  358. void do_bug(struct char_data *ch, char *argument, int cmd)
  359. {
  360.     FILE *fl;
  361.     char str[MAX_STRING_LENGTH];
  362.  
  363.     if (IS_NPC(ch))
  364.     {
  365.         send_to_char("You are a monster! Bug off!\n\r", ch);
  366.         return;
  367.     }
  368.  
  369.     /* skip whites */
  370.     for (; isspace(*argument); argument++);
  371.  
  372.     if (!*argument)
  373.     {
  374.         send_to_char("Pardon?\n\r",
  375.             ch);
  376.         return;
  377.     }
  378.  
  379.     if (!(fl = fopen(BUG_FILE, "a")))
  380.     {
  381.         perror ("do_bug");
  382.         send_to_char("Could not open the bug-file.\n\r", ch);
  383.         return;
  384.     }
  385.  
  386.     sprintf(str, "**%s[%d]: %s\n",
  387.         GET_NAME(ch), world[ch->in_room].number, argument);
  388.     fputs(str, fl);
  389.     fclose(fl);
  390.     send_to_char("Ok.\n\r", ch);
  391. }
  392.  
  393.  
  394.  
  395. void do_brief(struct char_data *ch, char *argument, int cmd)
  396. {
  397.     if (IS_NPC(ch))
  398.         return;
  399.  
  400.     if (IS_SET(ch->specials.act, PLR_BRIEF))
  401.     {
  402.         send_to_char("Brief mode off.\n\r", ch);
  403.         REMOVE_BIT(ch->specials.act, PLR_BRIEF);
  404.     }
  405.     else
  406.     {
  407.         send_to_char("Brief mode on.\n\r", ch);
  408.         SET_BIT(ch->specials.act, PLR_BRIEF);
  409.     }
  410. }
  411.  
  412.  
  413. void do_compact(struct char_data *ch, char *argument, int cmd)
  414. {
  415.     if (IS_NPC(ch))
  416.         return;
  417.  
  418.     if (IS_SET(ch->specials.act, PLR_COMPACT))
  419.     {
  420.         send_to_char("You are now in the uncompacted mode.\n\r", ch);
  421.         REMOVE_BIT(ch->specials.act, PLR_COMPACT);
  422.     }
  423.     else
  424.     {
  425.         send_to_char("You are now in compact mode.\n\r", ch);
  426.         SET_BIT(ch->specials.act, PLR_COMPACT);
  427.     }
  428. }
  429.  
  430.  
  431. void do_group(struct char_data *ch, char *argument, int cmd)
  432. {
  433.     char name[256];
  434.     struct char_data *victim, *k;
  435.     struct follow_type *f;
  436.     bool found;
  437.  
  438.     one_argument(argument, name);
  439.  
  440.     if (!*name) {
  441.         if (!IS_AFFECTED(ch, AFF_GROUP)) {
  442.             send_to_char("But you are a member of no group?!\n\r", ch);
  443.         } else {
  444.             send_to_char("Your group consists of:\n\r", ch);
  445.             if (ch->master)
  446.                 k = ch->master;
  447.             else
  448.                 k = ch;
  449.  
  450.             if (IS_AFFECTED(k, AFF_GROUP))
  451.                 act("     $N (Head of group)",FALSE,ch, 0, k, TO_CHAR);
  452.  
  453.             for(f=k->followers; f; f=f->next)
  454.                 if (IS_AFFECTED(f->follower, AFF_GROUP))
  455.                     act("     $N",FALSE,ch, 0, f->follower, TO_CHAR);
  456.         }
  457.  
  458.         return;
  459.     }
  460.  
  461.     if (!(victim = get_char_room_vis(ch, name))) {
  462.         send_to_char("No one here by that name.\n\r", ch);
  463.     } else {
  464.  
  465.         if (ch->master) {
  466.             act("You can not enroll group members without being head of a group.",
  467.                FALSE, ch, 0, 0, TO_CHAR);
  468.             return;
  469.         }
  470.  
  471.         found = FALSE;
  472.  
  473.         if (victim == ch)
  474.             found = TRUE;
  475.         else {
  476.             for(f=ch->followers; f; f=f->next) {
  477.                 if (f->follower == victim) {
  478.                     found = TRUE;
  479.                     break;
  480.                 }
  481.             }
  482.         }
  483.         
  484.         if (found) {
  485.             if (IS_AFFECTED(victim, AFF_GROUP)) {
  486.                 act("$n has been kicked out of the group!", FALSE, victim, 0, ch, TO_ROOM);
  487.                 act("You are no longer a member of the group!", FALSE, victim, 0, 0, TO_CHAR);
  488.                 REMOVE_BIT(victim->specials.affected_by, AFF_GROUP);
  489.             } else {
  490.                 act("$n is now a group member.", FALSE, victim, 0, 0, TO_ROOM);
  491.                 act("You are now a group member.", FALSE, victim, 0, 0, TO_CHAR);
  492.                 SET_BIT(victim->specials.affected_by, AFF_GROUP);
  493.             }
  494.         } else {
  495.             act("$N must follow you, to enter the group", FALSE, ch, 0, victim, TO_CHAR);
  496.         }
  497.     }
  498. }
  499.  
  500.  
  501. void do_quaff(struct char_data *ch, char *argument, int cmd)
  502. {
  503.   char buf[100];
  504.   struct obj_data *temp;
  505.   int i;
  506.     bool equipped;
  507.  
  508.     equipped = FALSE;
  509.  
  510.   one_argument(argument,buf);
  511.  
  512.     if (!(temp = get_obj_in_list_vis(ch,buf,ch->carrying))) {
  513.         temp = ch->equipment[HOLD];
  514.         equipped = TRUE;
  515.       if ((temp==0) || !isname(buf, temp->name)) {
  516.             act("You do not have that item.",FALSE,ch,0,0,TO_CHAR);
  517.         return;
  518.       }
  519.     }
  520.  
  521.   if (temp->obj_flags.type_flag!=ITEM_POTION)
  522.   {
  523.     act("You can only quaff potions.",FALSE,ch,0,0,TO_CHAR);
  524.     return;
  525.   }
  526.  
  527.   act("$n quaffs $p.", TRUE, ch, temp, 0, TO_ROOM);
  528.   act("You quaff $p which dissolves.",FALSE,ch,temp,0,TO_CHAR);
  529.  
  530.   for (i=1; i<4; i++)
  531.     if (temp->obj_flags.value[i] >= 1)
  532.       ((*spell_info[temp->obj_flags.value[i]].spell_pointer)
  533.         ((byte) temp->obj_flags.value[0], ch, "", SPELL_TYPE_POTION, ch, 0));
  534.  
  535.     if (equipped)
  536.         unequip_char(ch, HOLD);
  537.  
  538.     extract_obj(temp);
  539. }
  540.  
  541.  
  542. void do_recite(struct char_data *ch, char *argument, int cmd)
  543. {
  544.     char buf[100];
  545.     struct obj_data *scroll, *obj;
  546.     struct char_data *victim;
  547.     int i, bits;
  548.     bool equipped;
  549.  
  550.     equipped = FALSE;
  551.     obj = 0;
  552.     victim = 0;
  553.  
  554.     argument = one_argument(argument,buf);
  555.  
  556.     if (!(scroll = get_obj_in_list_vis(ch,buf,ch->carrying))) {
  557.         scroll = ch->equipment[HOLD];
  558.         equipped = TRUE;
  559.       if ((scroll==0) || !isname(buf, scroll->name)) {
  560.             act("You do not have that item.",FALSE,ch,0,0,TO_CHAR);
  561.             return;
  562.       }
  563.     }
  564.  
  565.   if (scroll->obj_flags.type_flag!=ITEM_SCROLL)
  566.   {
  567.     act("Recite is normally used for scroll's.",FALSE,ch,0,0,TO_CHAR);
  568.     return;
  569.   }
  570.  
  571.     if (*argument) {
  572.       bits = generic_find(argument, FIND_OBJ_INV | FIND_OBJ_ROOM |
  573.         FIND_OBJ_EQUIP | FIND_CHAR_ROOM, ch, &victim, &obj);
  574.         if (bits == 0) {
  575.             send_to_char("No such thing around to recite the scroll on.\n\r", ch);
  576.             return;
  577.         }
  578.     } else {
  579.         victim = ch;
  580.     }
  581.  
  582.     act("$n recites $p.", TRUE, ch, scroll, 0, TO_ROOM);
  583.   act("You recite $p which dissolves.",FALSE,ch,scroll,0,TO_CHAR);
  584.  
  585.   for (i=1; i<4; i++)
  586.     if (scroll->obj_flags.value[i] >= 1)
  587.       ((*spell_info[scroll->obj_flags.value[i]].spell_pointer)
  588.       ((byte) scroll->obj_flags.value[0], ch, "", SPELL_TYPE_SCROLL, victim, obj));
  589.  
  590.     if (equipped)
  591.         unequip_char(ch, HOLD);
  592.  
  593.     extract_obj(scroll);
  594. }
  595.  
  596.  
  597.  
  598. void do_use(struct char_data *ch, char *argument, int cmd)
  599. {
  600.   char buf[100];
  601.     struct char_data *tmp_char;
  602.   struct obj_data *tmp_object, *stick;
  603.  
  604.   int bits;
  605.  
  606.   argument = one_argument(argument,buf);
  607.  
  608.   if (ch->equipment[HOLD] == 0 ||
  609.       !isname(buf, ch->equipment[HOLD]->name)) {
  610.     act("You do not hold that item in your hand.",FALSE,ch,0,0,TO_CHAR);
  611.     return;
  612.   }
  613.  
  614.     stick = ch->equipment[HOLD];
  615.  
  616.   if (stick->obj_flags.type_flag == ITEM_STAFF)
  617.   {
  618.         act("$n taps $p three times on the ground.",TRUE, ch, stick, 0,TO_ROOM);
  619.         act("You tap $p three times on the ground.",FALSE,ch, stick, 0,TO_CHAR);
  620.  
  621.         if (stick->obj_flags.value[2] > 0) {  /* Is there any charges left? */
  622.             stick->obj_flags.value[2]--;
  623.             ((*spell_info[stick->obj_flags.value[3]].spell_pointer)
  624.             ((byte) stick->obj_flags.value[0], ch, "", SPELL_TYPE_STAFF, 0, 0));
  625.  
  626.         } else {
  627.             send_to_char("The staff seems powerless.\n\r", ch);
  628.         }
  629.     } else if (stick->obj_flags.type_flag == ITEM_WAND) {
  630.  
  631.         bits = generic_find(argument, FIND_CHAR_ROOM | FIND_OBJ_INV | FIND_OBJ_ROOM |
  632.                             FIND_OBJ_EQUIP, ch, &tmp_char, &tmp_object);
  633.         if (bits) {
  634.             if (bits == FIND_CHAR_ROOM) {
  635.                 act("$n point $p at $N.", TRUE, ch, stick, tmp_char, TO_ROOM);
  636.                 act("You point $p at $N.",FALSE,ch, stick, tmp_char, TO_CHAR);
  637.             } else {
  638.                 act("$n point $p at $P.", TRUE, ch, stick, tmp_object, TO_ROOM);
  639.                 act("You point $p at $P.",FALSE,ch, stick, tmp_object, TO_CHAR);
  640.             }
  641.  
  642.             if (stick->obj_flags.value[2] > 0) { /* Is there any charges left? */
  643.                 stick->obj_flags.value[2]--;
  644.                 ((*spell_info[stick->obj_flags.value[3]].spell_pointer)
  645.               ((byte) stick->obj_flags.value[0], ch, "", SPELL_TYPE_WAND, tmp_char, tmp_object));
  646.             } else {
  647.                 send_to_char("The wand seems powerless.\n\r", ch);
  648.             }
  649.         } else {
  650.             send_to_char("What should the wand be pointed at?\n\r", ch);
  651.         }
  652.     } else {
  653.         send_to_char("Use is normally only for wand's and staff's.\n\r", ch);
  654.   }
  655. }
  656.