[ViewVC] Diff of: cvs/deliantra/server/server/apply.C

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.93 by root, Sat May 12 21:56:34 2007 UTC vs.
Revision 1.97 by root, Tue May 15 19:07:15 2007 UTC

   object *tmp2;
   CLEAR_FLAG (op, FLAG_APPLIED);
+  if (player *pl = who->contr)
+    {
+      if (op == pl->ranged_ob) pl->ranged_ob = 0;
+      if (op == pl->combat_ob) pl->combat_ob = 0;
+    }
   switch (op->type)
     {
+      case SKILL_TOOL:
+        // unapplying a skill tool should also unapply the skill it governs
+        // but this is hard, as it shouldn't do so when the skill can
+        // be used for other reasons
+        for (object *tmp = who->inv; tmp; tmp = tmp->below)
+          if (tmp->skill == op->skill
+              && tmp->type == SKILL
+              && tmp->flag [FLAG_APPLIED]
+              && !tmp->flag [FLAG_CAN_USE_SKILL])
+            unapply_special (who, tmp, 0);
+        change_abil (who, op);
+        break;
       case WEAPON:
         new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));
         change_abil (who, op);
         CLEAR_FLAG (who, FLAG_READY_WEAPON);
-        if (who->contr)
-          {
-            if (who->contr->combat_ob == op)
-              who->contr->combat_ob = 0;
-            if (who->current_weapon == op)
-              who->current_weapon = 0;
-          }
         clear_skill (who);
         break;
-      case SKILL:              /* allows objects to impart skills */
-      case SKILL_TOOL:
+      case SKILL:
         if (op != who->chosen_skill)
           LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");
         if (who->contr)
           {
 /**
  * Returns the object that is using location 'loc'.
  * Note that 'start' is the first object to start examing - we
  * then go through the below of this.  In this way, you can do
  * something like:
- * tmp = get_item_from_body_location(who->inv, 1);
+ * tmp = get_next_item_from_body_location(who->inv, 1);
- * if (tmp) tmp1 = get_item_from_body_location(tmp->below, 1);
+ * if (tmp) tmp1 = get_next_item_from_body_location(tmp->below, 1);
  * to find the second object that may use this location, etc.
  * Returns NULL if no match is found.
  * loc is the index into the array we are looking for a match.
  * don't return invisible objects unless they are skill objects
  * invisible other objects that use
  * up body locations can be used as restrictions.
  */
 static object *
-get_item_from_body_location (int loc, object *start)
+get_next_item_from_body_location (int loc, object *start)
 {
-  if (start)
-    for (object *tmp = start; tmp; tmp = tmp->below)
+  for (object *tmp = start; tmp; tmp = tmp->below)
-      if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->slot[loc].info && (!tmp->invisible || tmp->type == SKILL))
+    if (tmp->flag [FLAG_APPLIED]
+        && tmp->slot[loc].info
+        && (!tmp->invisible || tmp->type == SKILL))
-        return tmp;
+      return tmp;
   return 0;
 }
 /**
           /* We do a while loop - may need to remove several items in order
            * to free up enough slots.
            */
           while ((who->slot[i].used + op->slot[i].info) < 0)
             {
-              object *tmp = get_item_from_body_location (i, last);
+              object *tmp = get_next_item_from_body_location (i, last);
               if (!tmp)
                 {
 #if 0
                   /* Not a bug - we'll get this if the player has cursed items
  * Checks to see if 'who' can apply object 'op'.
  * Returns 0 if apply can be done without anything special.
  * Otherwise returns a bitmask - potentially several of these may be
  * set, but largely depends on circumstance - in the future, processing
  * may be pruned once we know some status (eg, once CAN_APPLY_NEVER
- * is set, do we really are what the other flags may be?)
+ * is set, do we really care what the other flags may be?)
  *
  * See include/define.h for detailed description of the meaning of
  * these return values.
  */
 int
   for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
     {
       if (op->slot[i].info)
         {
           /* Item uses more slots than we have */
-          if (abs (op->slot[i].info) > who->slot[i].info)
+          if (who->slot[i].info + op->slot [i].info < 0)
             {
               /* Could return now for efficiency - rest of info below isn't
                * really needed.
                */
               retval |= CAN_APPLY_NEVER;
             }
-          else if ((who->slot[i].used + op->slot[i].info) < 0)
+          else if (who->slot[i].used + op->slot[i].info < 0)
             {
               /* in this case, equipping this would use more free spots than
                * we have.
                */
                   {
                     retval |= CAN_APPLY_UNAPPLY;
                     continue;
                   }
-              object *tmp1 = get_item_from_body_location (i, who->inv);
+              object *tmp1 = get_next_item_from_body_location (i, who->inv);
               if (!tmp1)
                 {
 #if 0
                   /* This is sort of an error, but happens a lot when old players
                    * join in with more stuff equipped than they are now allowed.
                    */
                   LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);
 #endif
+                  fprintf (stderr, "can apply never due to %d but %d - %d + %d\n",//D
+                           i, who->slot[i].used,ws ? ws->slot[i].info :-77,op->slot[i].info);//D
                   retval |= CAN_APPLY_NEVER;
                 }
               else
                 {
                   /* need to unapply something.  However, if this something
                    * is different than we had found before, it means they need
                    * to apply multiple objects
                    */
                   retval |= CAN_APPLY_UNAPPLY;
                   if (!tmp)
                     tmp = tmp1;
                   else if (tmp != tmp1)
                     retval |= CAN_APPLY_UNAPPLY_MULT;
     return 0;
   // if the item is combat/ranged, wield the relevant slot first
   // to resolve conflicts.
   if (player *pl = who->contr)
-    switch (op->type)
+    switch (op->slottype ())
       {
-        case WEAPON:
-          who->change_weapon (pl->combat_ob);
+        case slot_combat: who->change_weapon (pl->combat_ob); break;
-          break;
-        case BOW:
-        case ROD:
-        case WAND:
-        case HORN:
-        case SKILL_TOOL:
-          who->change_weapon (pl->ranged_ob);
+        case slot_ranged: who->change_weapon (pl->ranged_ob); break;
-          break;
-        case SKILL:
-          if (IS_COMBAT_SKILL (op->subtype))
-            who->change_weapon (pl->combat_ob);
-          else if (IS_RANGED_SKILL (op->subtype))
-            who->change_weapon (pl->ranged_ob);
-          break;
       }
   /* Can't just apply this object.  Lets see what not and what to do */
   if (int i = can_apply_object (who, op))
     {
         if (who->type == PLAYER)
           esrv_send_item (who, tmp2);
         return 0;
-        /* this part is needed for skill-tools */
+      case SKILL_TOOL:
+        // applying a skill tool also readies the skill
+        SET_FLAG (op, FLAG_APPLIED);
+        skop = find_skill_by_name (who, op->skill);
+        if (!skop->flag [FLAG_APPLIED])
+          apply_special (who, skop, AP_APPLY);
+        break;
       case SKILL:
-      case SKILL_TOOL:
         if (who->chosen_skill)
           {
             LOG (llevError, "BUG: apply_special(): can't apply two skills\n");
             return 1;
           }

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/server/apply.C (file contents): Revision 1.93 by root, Sat May 12 21:56:34 2007 UTC vs. Revision 1.97 by root, Tue May 15 19:07:15 2007 UTC

Diff Legend

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.93 by root, Sat May 12 21:56:34 2007 UTC vs.
Revision 1.97 by root, Tue May 15 19:07:15 2007 UTC