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

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.259 by root, Fri Apr 16 23:32:07 2010 UTC vs.
Revision 1.278 by root, Thu Nov 17 04:49:22 2016 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
  * the terms of the Affero GNU General Public License as published by the
  * Free Software Foundation, either version 3 of the License, or (at your
  * option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the Affero GNU General Public License
  * and the GNU General Public License along with this program. If not, see
  * <http://www.gnu.org/licenses/>.
  *
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
 #include <cmath>
  */
 static int
 prepare_weapon (object *op, object *improver, object *weapon)
 {
   int sacrifice_count, i;
-  char buf[MAX_BUF];
   if (weapon->level != 0)
     {
       op->failmsg ("Weapon is already prepared!");
       return 0;
     "Your sacrifice was accepted."
     "Your *%s may be improved %d times.",
     &weapon->name, weapon->level
   ));
-  sprintf (buf, "%s's %s", &op->name, &weapon->name);
+  weapon->name = weapon->name_pl = format ("%s's %s", &op->name, &weapon->name);
-  weapon->name = weapon->name_pl = buf;
   weapon->nrof = 0;             /*  prevents preparing n weapons in the same
                                    slot at once! */
   improver->decrease ();
   weapon->last_eat = 0;
   return 1;
   // elmex: only identify if we need to, for example so that generated money doesn't
   //        get an 'identified' flag so easily.
   if (item->need_identify ())
     identify (item);
-  insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);
+  item->insert_at (converter, 0, INS_NO_WALK_ON);
   return 1;
 }
 /**
  * Handle apply on containers.
           op->close_container ();
           return 1;
         }
       else if (!sack->env)
         {
-          // active, but not ours: some other player has opened it
+          // active on floor, but not ours: some other player has opened it
+          // normally this only happens to dms standing on the same space.
+          // but it doesn't hurt to handle it.
           op->failmsgf ("Somebody else is using the %s already.", query_name (sack));
           return 1;
         }
+    }
-      // fall through to opening it (active in inv)
+  // it's locked?
+  if (sack->slaying)
-    }
+    {
-  else if (sack->env)
+      if (object *tmp = find_key (op, op, sack))
+        {
+          op->statusmsg (format ("You unlock %s with %s.", query_name (sack), query_name (tmp)));
+        }
+      else
+        {
+          sack->flag [FLAG_APPLIED] = false; // might be applied in inv, let the user close it
+          esrv_update_item (UPD_FLAGS, op, sack);
+          op->statusmsg (format ("You don't have the key to unlock %s.", query_name (sack)));
+          return 1;
+        }
+    }
+  if (sack->env && !sack->flag [FLAG_APPLIED])
     {
       // it is in our env, so activate it, do not open yet
       op->close_container ();
-      sack->flag [FLAG_APPLIED] = 1;
+      sack->flag [FLAG_APPLIED] = true;
       esrv_update_item (UPD_FLAGS, op, sack);
       op->statusmsg (format ("You ready %s.", query_name (sack)));
-      return 1;
-    }
-  // it's locked?
-  if (sack->slaying)
-    {
+    }
-      if (object *tmp = find_key (op, op, sack))
-        op->statusmsg (format ("You unlock %s with %s.", query_name (sack), query_name (tmp)));
-      else
+  else
-        {
-          op->statusmsg (format ("You don't have the key to unlock %s.", query_name (sack)));
-          return 1;
-        }
-    }
-  op->open_container (sack);
+    op->open_container (sack);
   return 1;
 }
 /**
         who->flag [FLAG_READY_WEAPON] = false;
         // unapplying a weapon or 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
+        //TODO: really?
         if (who->chosen_skill)
           if (!who->chosen_skill->flag [FLAG_CAN_USE_SKILL])
-            unapply_special (who, op, 0);
+            unapply_special (who, who->chosen_skill, 0);
         break;
+      case RANGED:
       case BOW:
       case WAND:
       case ROD:
       case HORN:
-      case RANGED:
         if (player *pl = who->contr)
           {
             who->statusmsg (format ("You unready %s.", query_name (op)));
             change_abil (who, op);
           }
 static bool
 apply_special (object *who, object *op, int aflags)
 {
   int basic_flag = aflags & AP_MODE;
-  object *tmp, *tmp2, *skop = NULL;
+  object *tmp, *skop = NULL;
-  if (who == NULL)
-    {
-      LOG (llevError, "apply_special() from object without environment.\n");
-      return 1;
-    }
-  //TODO: remove these when apply_special is no longer exposed
-  if (op->env != who)
-    return 1;                   /* op is not in inventory */
   /* trying to unequip op */
   if (op->flag [FLAG_APPLIED])
     {
       /* always apply, so no reason to unapply */
       if (basic_flag == AP_APPLY)
         return 0;
-      if (!(aflags & AP_IGNORE_CURSE) && (op->flag [FLAG_CURSED] || op->flag [FLAG_DAMNED]))
-        {
-          who->failmsgf ("No matter how hard you try, you just can't remove %s." CANNOT_REMOVE_CURSED, query_name (op));
-          return 1;
-        }
       return unapply_special (who, op, aflags);
     }
   else if (basic_flag == AP_UNAPPLY)
     return 0;
         //TODO: unapplying should unapply the skill, though
         op->set_flag (FLAG_APPLIED);
         break;
       case SKILL:
-        if (!(aflags & AP_NO_SLOT))
-          {
-            // skill is used on it's own, as opposed to being a chosen_skill
-            if (skill_flags [op->subtype] & (SF_NEED_ITEM | SF_MANA))
-              {
-                who->failmsgf (
-                  "You feel as if you wanted to do something funny, but you can't remember what. "
-                  "H<The %s skill needs something else to function, for example a tool, weapon, rod, or spell. "
-                  "It cannot be used on its own.>",
-                  &op->skill
-                );
-                if (tmp) who->insert (tmp);
-                return 1;
-              }
-            if (skill_flags [op->subtype] & SF_AUTARK
-                || !(skill_flags [op->subtype] & (SF_COMBAT | SF_RANGED)))
-              {
-                if (skill_flags [op->subtype] & SF_USE)
-                  who->failmsgf (
-                    "You feel as if you wanted to do something funny, but you can't remember what. "
-                    "H<The %s skill cannot be readied, instead, try C<use_skill %s>.>",
-                    &op->skill, &op->skill
-                  );
-                else
-                  who->failmsgf (
-                    "You feel as if you wanted to do something funny, but you can't remember what. "
-                    "H<The %s skill cannot be readied or used, it is always active.>",
-                    &op->skill
-                  );
-                if (tmp) who->insert (tmp);
-                return 1;
-              }
-            if (who->contr)
+        if (who->contr)
-              if (op->invisible)
+          if (op->invisible)
-                who->statusmsg (format ("You can now use the %s skill.", &op->skill));
+            who->statusmsg (format ("You can now use the %s skill.", &op->skill));
-              else
+          else
-                who->statusmsg (format ("You ready %s.", query_name (op)));
+            who->statusmsg (format ("You ready %s.", query_name (op)));
-          }
         who->set_flag (FLAG_READY_SKILL);
         op->set_flag (FLAG_APPLIED);
         change_abil (who, op);
         break;
  * matching item.
  **/
 void
 handle_apply_yield (object *tmp)
 {
-  if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
+  if (shstr_tmp yield = tmp->kv [shstr_on_use_yield])
     archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
 }
 /**
  * Handles applying a potion.
 int
 apply_potion (object *op, object *tmp)
 {
   int got_one = 0, i;
   object *force = 0;
-  object *floor = GET_MAP_OB (op->map, op->x, op->y);
   if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
     {
       op->failmsg ("Gods prevent you from using this here, it's sacred ground!");
   for (i = 0; i < NROFATTACKS; i++)
     {
       if (tmp->resist[i])
         {
           if (!force)
-            force = get_archetype (FORCE_NAME);
+            force = archetype::get (FORCE_NAME);
           memcpy (force->resist, tmp->resist, sizeof (tmp->resist));
           force->type = POTION_EFFECT;
           break;                /* Only need to find one protection since we copy entire batch */
         }
 void
 move_apply (object *trap, object *victim, object *originator)
 {
   static int recursion_depth = 0;
+  trap = trap->head_ ();
   /* Only exits affect DMs. */
   if (victim->flag [FLAG_WIZPASS] && trap->type != EXIT && trap->type != SIGN)
     return;
   /* move_apply() is the most likely candidate for causing unwanted and
    * possibly unlimited recursion.
    */
   /* The following was changed because it was causing perfectly correct
    * maps to fail.  1)  it's not an error to recurse:
    * rune detonates, summoning monster.  monster lands on nearby rune.
    * nearby rune detonates.  This sort of recursion is expected and
    * proper.  This code was causing needless crashes.
            "[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->archname, &trap->name, &victim->arch->archname, &victim->name);
       return;
     }
   recursion_depth++;
-  if (trap->head)
-    trap = trap->head;
   if (!INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
     switch (trap->type)
       {
         case PLAYERMOVER:
               /* Just put in some sanity check.  I think there is a bug in the
                * above with some objects have zero speed, and thus the player
                * getting permanently paralyzed.
                */
-              if (victim->speed_left < -50.f)
+              victim->speed_left = max (-50.f, victim->speed_left);
-                victim->speed_left = -50.f;
               /*      LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
             }
           break;
         case SPINNER:
         case ARROW:
           /* bad bug: monster throw a object, make a step forwards, step on object ,
            * trigger this here and get hit by own missile - and will be own enemy.
            * Victim then is his own enemy and will start to kill herself (this is
            * removed) but we have not synced victim and his missile. To avoid senseless
            * action, we avoid hits here
            */
           if ((victim->flag [FLAG_ALIVE] && trap->has_active_speed ())
               && trap->owner != victim)
             hit_with_arrow (trap, victim);
           break;
   if (failure <= -1 && failure > -15)
     {                           /* wonder */
       object *tmp;
       op->failmsg ("Your spell warps!");
-      tmp = get_archetype (SPELL_WONDER);
+      tmp = archetype::get (SPELL_WONDER);
       cast_wonder (op, op, 0, tmp);
       tmp->destroy ();
     }
   else if (failure <= -15 && failure > -35)
     {                           /* drain mana */
           op->failmsg ("The magic recoils on you!");
           blind_player (op, op, power);
         }
       else if (failure <= -80)
         {                       /* blast the immediate area */
-          object *tmp = get_archetype (LOOSE_MANA);
+          object *tmp = archetype::get (LOOSE_MANA);
           cast_magic_storm (op, tmp, power);
           op->failmsg ("You unleash uncontrolled mana!");
           tmp->destroy ();
         }
     }
  * the selected object to "burn". -b.t.
  */
 static void
 apply_lighter (object *who, object *lighter)
 {
-  int is_player_env = 0;
   if (object *item = who->mark ())
     {
       if (!auto_apply_lighter (who, item, lighter))
         return;
   strcpy (got, find);
   got[len] = '\0';
   /* Now create new item, remove used ones when required. */
-  new_item = get_archetype (got);
+  new_item = archetype::get (got);
   if (!new_item)
     {
       pl->failmsgf ("This %s is strange, better to not use it.", query_base_name (marked, 0));
       return;
     }
  * them in this function - they are passed to apply_special
  */
 static bool
 manual_apply (object *who, object *op, int aflag)
 {
-  op = op->head_ ();
-  if (op->flag [FLAG_UNPAID] && !op->flag [FLAG_APPLIED])
-    {
-      if (who->contr)
-        {
-          examine (who, op);
-          //who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
-          return 1;
-        }
-      else
-        return 0;             /* monsters just skip unpaid items */
-    }
   if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
     return RESULT_INT (0);
   else if (apply_types_inv_only [op->type])
     {
       // special item, using slot system, needs to be in inv
             break;
           case EXIT:
             if (!EXIT_PATH (op))
-              who->failmsgf ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op));
+              who->failmsgf ("The %s is closed. H<This exit doesn't lead anywhere at the moment, and this is unlikely to change.>", query_name (op));
             else
               {
                 /* Don't display messages for random maps. */
                 if (op->msg && EXIT_PATH (op) != shstr_random_map_exit)
                   who->statusmsg (op->msg, NDI_NAVY);
             check_improve_weapon (who, op);
             break;
           case CLOCK:
             {
-              char buf[MAX_BUF];
               timeofday_t tod;
               get_tod (&tod);
               who->play_sound (sound_find ("sound_clock"));
               who->statusmsg (format (
       return 1;
     }
   else
     {
-      who->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
+      who->statusmsg (format ("I don't know how to apply the %s. H<This object cannot be applied.>", query_name (op)));
       return 0;
     }
 }
 /**
 object::apply (object *ob, int aflags)
 {
   if (!ob) // simplifies a lot of callers
     return true;
+  ob = ob->head_ ();
+  if (ob->flag [FLAG_UNPAID] && !ob->flag [FLAG_APPLIED])
+    {
+      if (contr)
+        {
+          examine (this, ob);
+          //who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
+          return 1;
+        }
+      else
+        return 0;             /* monsters just skip unpaid items */
+    }
   if (contr)
     {
       if (!ob->env && (move_type & MOVE_FLYING))
         {
           /* player is flying and applying object not in inventory */
   bool want_apply =
       aflags & AP_APPLY   ? true
     : aflags & AP_UNAPPLY ? false
     :                       !ob->flag [FLAG_APPLIED]; // AP_TOGGLE
+  // cannot unapply cursed items
+  if (!want_apply
+      && (ob->flag [FLAG_CURSED] || ob->flag [FLAG_DAMNED])
+      && ob->flag [FLAG_APPLIED]
+      && !(aflags & AP_IGNORE_CURSE))
+    {
+      failmsgf ("No matter how hard you try, you just can't remove %s." CANNOT_REMOVE_CURSED, ob->query_name ());
+      return 0;
+    }
   object_ptr *slot = 0;
   // detect the slot, if this is a player
   if (contr && !(aflags & AP_NO_SLOT))
     {
           case WEAPON:
             slot = &contr->combat_ob;
             oslot = contr->ranged_ob;
             break;
+          case RANGED:
           case BOW:
-          case RANGED:
           case SPELL:
           case WAND:
           case ROD:
           case HORN:
           case BUILDER:
             oslot = contr->combat_ob;
             break;
           // oh, the humanity
           case SKILL:
-            if (aflags & AP_NO_SLOT)
+            // skill is used on it's own, as opposed to being a chosen_skill
+            if (skill_flags [ob->subtype] & (SF_NEED_ITEM | SF_MANA))
-              break;
+              {
+                failmsgf (
+                  "You feel as if you wanted to do something funny, but you can't remember what. "
+                  "H<The %s skill needs something else to function, for example a tool, weapon, rod, or spell. "
+                  "It cannot be used on its own.>",
+                  &ob->skill
+                );
+                return 1;
+              }
+            if (skill_flags [ob->subtype] & SF_AUTARK
+                || !(skill_flags [ob->subtype] & (SF_COMBAT | SF_RANGED)))
+              {
+                if (skill_flags [ob->subtype] & SF_USE)
+                  failmsgf (
+                    "You feel as if you wanted to do something funny, but you can't remember what. "
+                    "H<The %s skill cannot be readied, instead, try C<use_skill %s>.>",
+                    &ob->skill, &ob->skill
+                  );
+                else
+                  failmsgf (
+                    "You feel as if you wanted to do something funny, but you can't remember what. "
+                    "H<The %s skill cannot be readied or used, it is always active.>",
+                    &ob->skill
+                  );
+                return 1;
+              }
             if (skill_flags [ob->subtype] & SF_NEED_ITEM)
               break;
             if (skill_flags [ob->subtype] & SF_COMBAT)
           // only one slot can be active
           if (want_apply)
             {
               // clear slot unless we are in it already
               if (*slot != ob)
-                apply (*slot, AP_UNAPPLY);
+                if (!apply (*slot, AP_UNAPPLY))
+                  return false;
               // unapply other slot, because we want to become active
-              apply (oslot, AP_UNAPPLY);
+              if (!apply (oslot, AP_UNAPPLY))
+                return false;
             }
           // clear item from slot if applied
           if (!want_apply && current_weapon == ob)
             current_weapon = 0;
  * Generates shop floor's item, and treasures.
  */
 int
 auto_apply (object *op)
 {
-  object *tmp = NULL, *tmp2;
+  object *tmp = NULL;
   int i;
   op->clr_flag (FLAG_AUTO_APPLY);
   switch (op->type)
                     while (invtmp->stats.hp-- > 0)
                       create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);
                     invtmp->randomitems = NULL;
                   }
-                else if (invtmp && invtmp->arch
+                else if (invtmp->arch
-                         && invtmp->type != TREASURE && invtmp->type != SPELL && invtmp->type != CLASS && invtmp->has_random_items ())
+                         && invtmp->type != TREASURE && invtmp->type != SPELL && invtmp->type != CLASS
+                         && invtmp->has_random_items ())
                   {
                     create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);
                     /* Need to clear this so that we never try to create
                      * treasure again for this object
                      */

Diff Legend

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

Comparing deliantra/server/server/apply.C (file contents): Revision 1.259 by root, Fri Apr 16 23:32:07 2010 UTC vs. Revision 1.278 by root, Thu Nov 17 04:49:22 2016 UTC

Diff Legend

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.259 by root, Fri Apr 16 23:32:07 2010 UTC vs.
Revision 1.278 by root, Thu Nov 17 04:49:22 2016 UTC