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

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.245 by root, Tue Apr 6 03:53:29 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>
 #include <skills.h>
 #include <tod.h>
 #include <sproto.h>
-typedef bitset<NUM_TYPES> types_t;
 // these must be in the inventory before they can be applied
-static const struct may_attempt_inv : types_t
+static const struct apply_types_inv_only : typeset
 {
-  may_attempt_inv ()
+  apply_types_inv_only ()
   {
     set (WEAPON);
     set (ARMOUR);
     set (BOOTS);
     set (GLOVES);
     set (BOW);
     set (RANGED);
     set (BUILDER);
     set (SKILL_TOOL);
   }
-} may_attempt_inv;
+} apply_types_inv_only;
 // these only make sense for the player
-static const struct may_attempt_player : types_t
+static const struct apply_types_player_only : typeset
 {
-  may_attempt_player ()
+  apply_types_player_only ()
   {
+    set (TRANSPORT);
     set (EXIT);
+    set (BOOK);
+    set (SIGN);
     set (BOOK);
     set (SKILLSCROLL);
     set (SPELLBOOK);
+    set (INSCRIBABLE);
     set (TREASURE);
     set (SAVEBED);
     set (ARMOUR_IMPROVER);
     set (WEAPON_IMPROVER);
     set (CLOCK);
     set (MENU);
     set (LIGHTER);            /* for lighting torches/lanterns/etc */
-    set (INSCRIBABLE);
-    set (SIGN);
-    set (BOOK);
   }
-} may_attempt_player;
+} apply_types_player_only;
 // applying these _can_ be attempted, others cannot
 // be applied at all. used by e.g. apply below.
-static const struct may_attempt : types_t
+static const struct apply_types : typeset
 {
-  may_attempt ()
+  apply_types ()
-  : types_t ((types_t)may_attempt_player | (types_t)may_attempt_inv)
+  : typeset ((typeset)apply_types_player_only | (typeset)apply_types_inv_only)
   {
     set (T_HANDLE);
     set (TRIGGER);
     set (SCROLL);
     set (POTION);
     set (FLESH);
     set (POISON);
     set (POWER_CRYSTAL);
     set (ITEM_TRANSFORMER);
   }
-} may_attempt;
+} apply_types;
 /****************************************************************************
  * Weapon improvement code follows
  ****************************************************************************/
   if (!item)
     return 0;
   for (op = op->below; op; op = op->below)
     if (op->arch->archname == item)
-      if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
+      if (!op->flag [FLAG_CURSED] && !op->flag [FLAG_DAMNED]
-          && /* Loophole bug? -FD- */  !QUERY_FLAG (op, FLAG_UNPAID))
+          && /* Loophole bug? -FD- */  !op->flag [FLAG_UNPAID])
         count += op->number_of ();
   return count;
 }
   if (improver->slaying)
     {
       count = check_item (op, improver->slaying);
       if (count < 1)
         {
-          op->failmsg (format ("The gods want more %ss", &improver->slaying));
+          op->failmsgf ("The gods want more %ss", &improver->slaying);
           return 0;
         }
     }
   else
     count = 1;
  */
 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;
     {
       op->failmsg ("This weapon cannot be improved any more.");
       return 0;
     }
-  if (QUERY_FLAG (weapon, FLAG_APPLIED)
+  if (weapon->flag [FLAG_APPLIED]
       && !check_item_power (op, weapon->item_power + 1))
     {
       op->failmsg ("Improving the weapon will make it too "
                     "powerful for you to use. Unready it if you "
                     "really want to improve it.");
   sacrifice_needed *= 2;
   sacrifice_count = check_sacrifice (op, improver);
   if (sacrifice_count < sacrifice_needed)
     {
-      op->failmsg (format ("You need at least %d %s.", sacrifice_needed, &improver->slaying));
+      op->failmsgf ("You need at least %d %s.", sacrifice_needed, &improver->slaying);
       return 0;
     }
   eat_item (op, improver->slaying, sacrifice_needed);
   weapon->item_power++;
  * then calls improve_weapon to do the dirty work.
  */
 static int
 check_improve_weapon (object *op, object *tmp)
 {
-  object *otmp;
   if (op->type != PLAYER)
     return 0;
-  if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))
+  if (!op->flag [FLAG_WIZCAST] && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))
     {
       op->failmsg ("Something blocks the magic of the scroll!");
       return 0;
     }
-  otmp = find_marked_object (op);
+  object *otmp = op->mark ();
   if (!otmp)
     {
       op->failmsg ("You need to mark a weapon object. H<Use the mark command or the mark option from the item popup menu.>");
       return 0;
     }
   if (otmp->type != WEAPON && otmp->type != BOW)
     {
       op->failmsg ("Marked item is not a weapon or bow!");
+      return 0;
+    }
+  if (!op->apply (otmp, AP_UNAPPLY))
+    {
+      op->failmsg ("You are unable to take off your weapon to improve it!");
       return 0;
     }
   op->statusmsg ("Applied weapon builder.");
  * changing of physical area right now.
  */
 static int
 improve_armour (object *op, object *improver, object *armour)
 {
-  object *tmp;
   if (armour->magic >= settings.armor_max_enchant)
     {
       op->failmsg ("This armour can not be enchanted any further!");
       return 0;
     }
     }
   /* Split objects if needed. Can't insert tmp until the
    * end of this function - otherwise it will just re-merge.
    */
-  tmp = armour->nrof > 1 ? armour->split (armour->nrof - 1) : 0;
+  object *tmp = armour->nrof > 1 ? armour->split (armour->nrof - 1) : 0;
   armour->magic++;
   if (!settings.armor_speed_linear)
     {
   if (op->type == PLAYER)
     {
       esrv_send_item (op, armour);
-      if (QUERY_FLAG (armour, FLAG_APPLIED))
+      if (armour->flag [FLAG_APPLIED])
         op->update_stats ();
     }
   improver->decrease ();
       for (ob = converter->inv->below, i = 1; ob; ob = ob->below, i++)
         if (rndm (0, i) == 0)
           ob_to_copy = ob;
       item = ob_to_copy->deep_clone ();
-      CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);
+      item->clr_flag (FLAG_IS_A_TEMPLATE);
       unflag_inv (item, FLAG_IS_A_TEMPLATE);
     }
   else
     {
       if (!conv_to)
   if (nr)
     item->nrof *= nr;
   if (converter->flag [FLAG_PRECIOUS])
-    SET_FLAG (item, FLAG_UNPAID);
+    item->set_flag (FLAG_UNPAID);
   if (converter->is_in_shop ())
     {
       // converters on shop floors don't work anymore, bug lets check for it
       // and report in case someone still does it.
       LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",
            converter->debug_desc ());
-      SET_FLAG (item, FLAG_UNPAID);
+      item->set_flag (FLAG_UNPAID);
     }
   else if (price_in < sint64 (item->nrof) * item->value)
     {
       LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",
            &converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);
        */
     }
   // elmex: only identify if we need to, for example so that generated money doesn't
   //        get an 'identified' flag so easily.
-  if (need_identify (item))
+  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->failmsg (format ("Somebody else is using the %s already.", query_name (sack)));
+          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;
 }
 /**
 {
   int rv = 0;
   double opinion;
   object *tmp, *next;
-  SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
+  op->set_flag (FLAG_NO_APPLY); /* prevent loops */
   bool has_unpaid = false;
   // quite inefficient to do this here twice, but the api doesn't lend itself to
   // a quick and small change :(
        */
       for (tmp = op->inv; tmp; tmp = next)
         {
           next = tmp->below;
-          if (QUERY_FLAG (tmp, FLAG_UNPAID))
+          if (tmp->flag [FLAG_UNPAID])
             {
               int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
               if (i >= 0)
                 tmp->move (i);
             }
         }
       /* Don't teleport things like spell effects */
-      if (QUERY_FLAG (op, FLAG_NO_PICK))
+      if (op->flag [FLAG_NO_PICK])
         return 0;
       /* unpaid objects, or non living objects, can't transfer by
        * shop mats.  Instead, put it on a nearby space.
        */
-      if (QUERY_FLAG (op, FLAG_UNPAID) || !QUERY_FLAG (op, FLAG_ALIVE))
+      if (op->flag [FLAG_UNPAID] || !op->flag [FLAG_ALIVE])
         {
           /* Somebody dropped an unpaid item, just move to an adjacent place. */
           int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
           if (i != -1)
           op->y += freearr_y[i];
           rv = insert_ob_in_map (op, op->map, shop_mat, 0) == NULL;
         }
     }
-  CLEAR_FLAG (op, FLAG_NO_APPLY);
+  op->clr_flag (FLAG_NO_APPLY);
   return rv;
 }
 /**
  * Handles applying a sign.
             op->failmsg ("You cannot read it anymore.");
           return;
         }
-      if (!QUERY_FLAG (op, FLAG_WIZPASS))
+      if (!op->flag [FLAG_WIZPASS])
         sign->last_eat++;
     }
   /* Sign or magic mouth?  Do we need to see it, or does it talk to us?
    * No way to know for sure.  The presumption is basically that if
    * move_on is zero, it needs to be manually applied (doesn't talk
    * to us).
    */
-  if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on)
+  if (op->flag [FLAG_BLIND] && !op->flag [FLAG_WIZ] && !sign->move_on)
     {
       op->failmsg ("You are unable to read while blind!");
       return;
     }
         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);
           }
         else
           {
-            who->change_skill (0);
             if (op->type == BOW)
               op->flag [FLAG_READY_BOW  ] = false;
             else
               op->flag [FLAG_READY_RANGE] = false;
           }
 static bool
 unapply_for_ob (object *who, object *op, int aflags)
 {
   if (op->is_range ())
     for (object *tmp = who->inv; tmp; tmp = tmp->below)
-      if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
+      if (tmp->flag [FLAG_APPLIED] && tmp->is_range ())
-        if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))
+        if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!tmp->flag [FLAG_CURSED] && !tmp->flag [FLAG_DAMNED]))
           {
             if (aflags & AP_PRINT)
               who->failmsg (query_name (tmp));
             else
               unapply_special (who, tmp, aflags);
           {
             /* In this case, we want to try and remove a cursed item.
              * While we know it won't work, we want unapply_special to
              * at least generate the message.
              */
-            who->failmsg (format ("No matter how hard you try, you just can't remove the %s." CANNOT_REMOVE_CURSED, query_name (tmp)));
+            who->failmsgf ("No matter how hard you try, you just can't remove the %s." CANNOT_REMOVE_CURSED, query_name (tmp));
             return 1;
           }
   for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
     {
 #endif
                   return 1;
                 }
               /* If we are just printing, we don't care about cursed status */
-              if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))
+              if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED])))
                 {
                   if (aflags & AP_PRINT)
                     who->failmsg (query_name (tmp));
                   else
                     unapply_special (who, tmp, aflags);
                   /* Cursed item that we can't unequip - tell the player.
                    * Note this could be annoying if this is just one of a few,
                    * so it may not be critical (eg, putting on a ring and you have
                    * one cursed ring.)
                    */
-                  who->failmsg (format ("The %s just won't come off." CANNOT_REMOVE_CURSED, query_name (tmp)));
+                  who->failmsgf ("The %s just won't come off." CANNOT_REMOVE_CURSED, query_name (tmp));
                 }
               last = tmp->below;
             }
           /* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the
    * the weapon/shield checks, and the range checks for monsters,
    * because you can't control those just by body location - bows, shields,
    * and weapons all use the same slot.  Similar for horn/rod/wand - they
    * all use the same location.
    */
-  if (op->type == WEAPON && !QUERY_FLAG (who, FLAG_USE_WEAPON))
+  if (op->type == WEAPON && !who->flag [FLAG_USE_WEAPON])
     retval |= CAN_APPLY_RESTRICTION;
-  if (op->type == SHIELD && !QUERY_FLAG (who, FLAG_USE_SHIELD))
+  if (op->type == SHIELD && !who->flag [FLAG_USE_SHIELD])
     retval |= CAN_APPLY_RESTRICTION;
   if (who->type != PLAYER)
     {
-      if ((op->type == WAND || op->type == HORN || op->type == ROD) && !QUERY_FLAG (who, FLAG_USE_RANGE))
+      if ((op->type == WAND || op->type == HORN || op->type == ROD) && !who->flag [FLAG_USE_RANGE])
         retval |= CAN_APPLY_RESTRICTION;
-      if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
+      if (op->type == BOW && !who->flag [FLAG_USE_BOW])
         retval |= CAN_APPLY_RESTRICTION;
-      if (op->type == RING && !QUERY_FLAG (who, FLAG_USE_RING))
+      if (op->type == RING && !who->flag [FLAG_USE_RING])
         retval |= CAN_APPLY_RESTRICTION;
-      if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
+      if (op->type == BOW && !who->flag [FLAG_USE_BOW])
         retval |= CAN_APPLY_RESTRICTION;
     }
   return retval;
 }
 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 (QUERY_FLAG (op, FLAG_APPLIED))
+  if (op->flag [FLAG_APPLIED])
     {
       /* always apply, so no reason to unapply */
       if (basic_flag == AP_APPLY)
         return 0;
-      if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))
-        {
-          who->failmsg (format ("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;
   /* Can't just apply this object.  Lets see what not and what to do */
   if (int i = can_apply_object (who, op))
     {
       if (i & CAN_APPLY_NEVER)
         {
-          who->failmsg (format ("You don't have the body to use a %s. H<You can never apply this item.>", query_name (op)));
+          who->failmsgf ("You don't have the body to use a %s. H<You can never apply this item.>", query_name (op));
           return 1;
         }
       else if (i & CAN_APPLY_RESTRICTION)
         {
-          who->failmsg (format (
+          who->failmsgf (
             "You have a prohibition against using a %s. "
             "H<Your belief, profession or class prevents you from applying this item.>",
             query_name (op)
-          ));
+          );
           return 1;
         }
       if (who->type != PLAYER)
         {
       // try to ready attached skill first
       skop = find_skill_by_name (who, op->skill);
       if (!skop)
         {
-          who->failmsg (format ("You need the %s skill to use this item!", &op->skill));
+          who->failmsgf ("You need the %s skill to use this item!", &op->skill);
           return 1;
         }
       else if (!who->apply (skop, AP_APPLY | AP_NO_SLOT))
         {
-          who->failmsg (format ("You can't use the required %s skill!", &op->skill));
+          who->failmsgf ("You can't use the required %s skill!", &op->skill);
           return 1;
         }
     }
   if (!check_item_power (who, op->item_power))
         if (player *pl = who->contr)
           {
             who->statusmsg (format ("You wield %s.", query_name (op)));
             change_abil (who, op);
           }
-        else
-          who->change_skill (skop);
         op->flag [FLAG_READY_WEAPON] = true;
         break;
       case ARMOUR:
       case GIRDLE:
       case BRACERS:
       case CLOAK:
       case RING:
       case AMULET:
-        SET_FLAG (op, FLAG_APPLIED);
+        op->set_flag (FLAG_APPLIED);
         who->statusmsg (format ("You wear %s.", query_name (op)));
         change_abil (who, op);
         break;
       case SKILL_TOOL:
         // applying a skill tool does not ready the skill
         // if something needs the skill, it has to ready it itself
         //TODO: unapplying should unapply the skill, though
-        SET_FLAG (op, FLAG_APPLIED);
+        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->failmsg (format (
-                  "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->failmsg (format (
-                    "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->failmsg (format (
-                    "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)));
-          }
-        SET_FLAG (who, FLAG_READY_SKILL);
+        who->set_flag (FLAG_READY_SKILL);
-        SET_FLAG (op, FLAG_APPLIED);
+        op->set_flag (FLAG_APPLIED);
         change_abil (who, op);
         break;
       case BOW:
         if (op->level && (!op->name.starts_with (who->name) || op->name [who->name.length ()] != '\''))
        /*FALLTHROUGH*/
       case WAND:
       case ROD:
       case HORN:
-        /* check for skill, alter player status */
-        if (!skop)
-          {
-            who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO
-            if (tmp) who->insert (tmp);
-            return 1;
-          }
         op->flag [FLAG_APPLIED] = true;
         if (player *pl = who->contr)
           {
             who->statusmsg (format ("You ready %s.", query_name (op)));
             change_abil (who, op);
           }
         else
           {
-            who->change_skill (skop);
             if (op->type == BOW)
               op->flag [FLAG_READY_BOW  ] = true;
             else
               op->flag [FLAG_READY_RANGE] = true;
           }
       default:
         who->statusmsg (format ("You apply %s.", query_name (op)));
     }
-  SET_FLAG (op, FLAG_APPLIED);
+  op->set_flag (FLAG_APPLIED);
   if (tmp) who->insert (tmp);
   who->update_stats ();
   /* We exclude spell casting objects.  The fire code will set the
    * been applied flag when they are used - until that point,
    * you don't know anything about them.
    */
   if (who->type == PLAYER && op->type != WAND && op->type != HORN && op->type != ROD)
-    SET_FLAG (op, FLAG_BEEN_APPLIED);
+    op->set_flag (FLAG_BEEN_APPLIED);
-  if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
+  if (op->flag [FLAG_CURSED] || op->flag [FLAG_DAMNED])
     if (who->type == PLAYER)
       {
         who->failmsg (
           "Oops, it feels deadly cold! "
           "H<Maybe it wasn't such a bright idea to apply this cursed or damned item.>"
         );
-        SET_FLAG (op, FLAG_KNOWN_CURSED);
+        op->set_flag (FLAG_KNOWN_CURSED);
       }
   if (object *pl = op->visible_to ())
     esrv_send_item (pl, op);
     return 0;
   /* if the player has a marked item, identify that if it needs to be
    * identified. If it doesn't, then go through the player inventory.
    */
-  if (object *marked = find_marked_object (pl))
+  if (object *marked = pl->mark ())
-    if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
+    if (!marked->flag [FLAG_IDENTIFIED] && marked->need_identify ())
       {
         if (operate_altar (altar, &money, pl))
           {
             identify (marked);
           }
       }
   for (object *id = pl->inv; id; id = id->below)
     {
-      if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
+      if (!id->flag [FLAG_IDENTIFIED] && !id->invisible && id->need_identify ())
         {
           if (operate_altar (altar, &money, pl))
             {
               identify (id);
  * 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.
 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!");
-      CLEAR_FLAG (tmp, FLAG_APPLIED);
+      tmp->clr_flag (FLAG_APPLIED);
       return 0;
     }
   if (op->type == PLAYER)
-    if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
+    if (!tmp->flag [FLAG_IDENTIFIED])
       identify (tmp);
   handle_apply_yield (tmp);
   /* Potion of restoration - only for players */
   if (op->type == PLAYER && (tmp->attacktype & AT_DEPLETE))
     {
       object *depl;
       archetype *at;
-      if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
+      if (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED])
         {
           op->drain_stat ();
           op->update_stats ();
           tmp->decrease ();
           return 1;
   /* improvement potion - only for players */
   if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
     {
       for (i = 1; i < min (11, op->level); i++)
         {
-          if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
+          if (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED])
             {
               if (op->contr->levhp[i] != 1)
                 {
                   op->contr->levhp[i] = 1;
                   break;
       /* Just makes checking easier */
       if (i < min (11, op->level))
         got_one = 1;
-      if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
+      if (!tmp->flag [FLAG_CURSED] && !tmp->flag [FLAG_DAMNED])
         {
           if (got_one)
             {
               op->update_stats ();
               op->statusmsg ("The Gods smile upon you and remake you "
    * there is no limit to the number of spells that potions can be cast,
    * but direction is problematic to try and imbue fireball potions for example.
    */
   if (tmp->inv)
     {
-      if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
+      if (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED])
         {
           op->failmsg ("Yech! Your lungs are on fire!");
           create_exploding_ball_at (op, op->level);
         }
       else
         cast_spell (op, tmp, op->facing, tmp->inv, NULL);
       tmp->decrease ();
       /* if youre dead, no point in doing this... */
-      if (!QUERY_FLAG (op, FLAG_REMOVED))
+      if (!op->flag [FLAG_REMOVED])
         op->update_stats ();
       return 1;
     }
   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 */
         }
   /* This is a protection potion */
   if (force)
     {
       /* cursed items last longer */
-      if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
+      if (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED])
         {
           force->stats.food *= 10;
           for (i = 0; i < NROFATTACKS; i++)
             if (force->resist[i] > 0)
               force->resist[i] = -force->resist[i];     /* prot => vuln */
         }
       force->speed_left = -1;
       force = insert_ob_in_ob (force, op);
-      CLEAR_FLAG (tmp, FLAG_APPLIED);
+      tmp->clr_flag (FLAG_APPLIED);
-      SET_FLAG (force, FLAG_APPLIED);
+      force->set_flag (FLAG_APPLIED);
       change_abil (op, force);
       tmp->decrease ();
       return 1;
     }
   /* Only thing left are the stat potions */
   if (op->type == PLAYER)
     {                           /* only for players */
-      if ((QUERY_FLAG (tmp, FLAG_CURSED)
+      if ((tmp->flag [FLAG_CURSED]
-           || QUERY_FLAG (tmp, FLAG_DAMNED))
+           || tmp->flag [FLAG_DAMNED])
           && tmp->value != 0)
-        CLEAR_FLAG (tmp, FLAG_APPLIED);
+        tmp->clr_flag (FLAG_APPLIED);
       else
-        SET_FLAG (tmp, FLAG_APPLIED);
+        tmp->set_flag (FLAG_APPLIED);
       if (!change_abil (op, tmp))
         op->statusmsg ("Nothing happened.");
     }
   /* CLEAR_FLAG is so that if the character has other potions
    * that were grouped with the one consumed, his
    * stat will not be raised by them.  fix_player just clears
    * up all the stats.
    */
-  CLEAR_FLAG (tmp, FLAG_APPLIED);
+  tmp->clr_flag (FLAG_APPLIED);
   op->update_stats ();
   tmp->decrease ();
   return 1;
 }
 void
 move_apply (object *trap, object *victim, object *originator)
 {
   static int recursion_depth = 0;
+  trap = trap->head_ ();
   /* Only exits affect DMs. */
-  if (QUERY_FLAG (victim, FLAG_WIZPASS) && trap->type != EXIT && trap->type != SIGN)
+  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 ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->has_active_speed ())
+          if ((victim->flag [FLAG_ALIVE] && trap->has_active_speed ())
               && trap->owner != victim)
             hit_with_arrow (trap, victim);
           break;
         case SPELL_EFFECT:
           }
         case CONVERTER:
           if (convert_item (victim, trap) < 0)
             {
-              originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
+              originator->failmsgf ("The %s seems to be broken!", query_name (trap));
               archetype::get (shstr_burnout)->insert_at (trap, trap);
             }
           break;
           apply_container (victim, trap);
           break;
         case RUNE:
         case TRAP:
-          if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
+          if (trap->level && victim->flag [FLAG_ALIVE])
             spring_trap (trap, victim);
           break;
         default:
           LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
 apply_book (object *op, object *tmp)
 {
   int lev_diff;
   object *skill_ob;
-  if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
+  if (op->flag [FLAG_BLIND] && !op->flag [FLAG_WIZ])
     {
       op->failmsg ("You are unable to read while blind!");
       return;
     }
   if (!tmp->msg)
     {
-      op->failmsg (format ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name));
+      op->failmsgf ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name);
       return;
     }
   /* need a literacy skill to read stuff! */
   skill_ob = find_skill_by_name (op, tmp->skill);
   if (!skill_ob)
     {
-      op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill to read this.>", &tmp->skill));
+      op->failmsgf ("You are unable to decipher the strange symbols. H<You lack the %s skill to read this.>", &tmp->skill);
       return;
     }
   lev_diff = tmp->level - (skill_ob->level + 5);
-  if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
+  if (!op->flag [FLAG_WIZ] && lev_diff > 0)
     {
       op->failmsg (lev_diff  <  2 ? "This book is just barely beyond your comprehension."
                   : lev_diff <  3 ? "This book is slightly beyond your comprehension."
                   : lev_diff <  5 ? "This book is beyond your comprehension."
                   : lev_diff <  8 ? "This book is quite a bit beyond your comprehension."
   if (player *pl = op->contr)
     if (client *ns = pl->ns)
       pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
   /* gain xp from reading */
-  if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
+  if (!tmp->flag [FLAG_NO_SKILL_IDENT])
     {                           /* only if not read before */
       int exp_gain = calc_skill_exp (op, tmp, skill_ob);
-      if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
+      if (!tmp->flag [FLAG_IDENTIFIED])
         {
           /*exp_gain *= 2; because they just identified it too */
-          SET_FLAG (tmp, FLAG_IDENTIFIED);
+          tmp->set_flag (FLAG_IDENTIFIED);
           if (object *pl = tmp->visible_to ())
             esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
         }
       change_exp (op, exp_gain, skill_ob->skill, 0);
-      SET_FLAG (tmp, FLAG_NO_SKILL_IDENT);      /* so no more xp gained from this book */
+      tmp->set_flag (FLAG_NO_SKILL_IDENT);      /* so no more xp gained from this book */
     }
 }
 /**
  * op made some mistake with a scroll, this takes care of punishment.
   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 ();
         }
     }
 {
   switch (learn_skill (op, tmp))
     {
       case 0:
         op->play_sound (sound_find ("generic_fail"));
-        op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp)));
+        op->failmsgf ("You already possess the knowledge held within the %s.", query_name (tmp));
         break;
       case 1:
         tmp->decrease ();
         op->play_sound (sound_find ("skill_learn"));
         break;
       default:
         tmp->decrease ();
         op->play_sound (sound_find ("generic_fail"));
-        op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp)));
+        op->failmsgf ("You fail to learn the knowledge of the %s.\n", query_name (tmp));
         break;
     }
 }
 /**
     }
   /* Upgrade special prayers to normal prayers */
   if ((tmp = check_spell_known (op, spell->name)) != NULL)
     {
-      if (special_prayer && !QUERY_FLAG (tmp, FLAG_STARTEQUIP))
+      if (special_prayer && !tmp->flag [FLAG_STARTEQUIP])
         {
           LOG (llevError, "BUG: do_learn_spell(): spell already known, but not marked as startequip\n");
           return;
         }
       return;
   tmp = spell->clone ();
   insert_ob_in_ob (tmp, op);
   if (special_prayer)
-    SET_FLAG (tmp, FLAG_STARTEQUIP);
+    tmp->set_flag (FLAG_STARTEQUIP);
   esrv_add_spells (op->contr, tmp);
 }
 /**
     {
       LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
       return;
     }
-  op->failmsg (format ("You lose knowledge of %s.", spell));
+  op->failmsgf ("You lose knowledge of %s.", spell);
   esrv_remove_spell (op->contr, spob);
   spob->destroy ();
 }
 /**
 static void
 apply_spellbook (object *op, object *tmp)
 {
   object *skop, *spell, *spell_skill;
-  if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
+  if (op->flag [FLAG_BLIND] && !op->flag [FLAG_WIZ])
     {
       op->failmsg ("You are unable to read while blind.");
       return;
     }
     {
       spell = find_archetype_by_object_name (tmp->slaying)->instance ();
       if (!spell)
         {
-          op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));
+          op->failmsgf ("The book's formula for %s is incomplete.", &tmp->slaying);
           return;
         }
       else
         insert_ob_in_ob (spell, tmp);
   /* need a literacy skill to learn spells. Also, having a literacy level
    * lower than the spell will make learning the spell more difficult */
   if (!skop)
     {
-      op->failmsg (format ("You can't read! Your attempt fails. H<You lack the %s skill.>", &tmp->skill));
+      op->failmsgf ("You can't read! Your attempt fails. H<You lack the %s skill.>", &tmp->skill);
       return;
     }
   spell = tmp->inv;
     }
   int learn_level = sqrtf (spell->level) * 1.5f;
   if (skop->level < learn_level)
     {
-      op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
+      op->failmsgf ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
-                           &tmp->skill, learn_level));
+                           &tmp->skill, learn_level);
       return;
     }
   op->statusmsg (format ("The spellbook contains the %s level spell %s.", ordinal (spell->level), &spell->name));
-  if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
+  if (!tmp->flag [FLAG_IDENTIFIED])
     identify (tmp);
   /* I removed the check for special_prayer_mark here - it didn't make
    * a lot of sense - special prayers are not found in spellbooks, and
    * if the player doesn't know the spell, doesn't make a lot of sense that
     {
       spell_skill = find_skill_by_name (op, spell->skill);
       if (!spell_skill)
         {
-          op->failmsg (format ("You lack the %s skill to use this spell.", &spell->skill));
+          op->failmsgf ("You lack the %s skill to use this spell.", &spell->skill);
           return;
         }
       if (spell_skill->level < spell->level)
         {
-          op->failmsg (format ("You need to be level %d in %s to learn this spell.", spell->level, &spell->skill));
+          op->failmsgf ("You need to be level %d in %s to learn this spell.", spell->level, &spell->skill);
           return;
         }
     }
   /* Logic as follows
    *  3 -Automatically fail to learn if you read while confused
    *
    * Overall, chances are the same but a player will find having a high
    * literacy rate very useful!  -b.t.
    */
-  if (QUERY_FLAG (op, FLAG_CONFUSED))
+  if (op->flag [FLAG_CONFUSED])
     {
       op->failmsg ("In your confused state you flub the wording of the text!");
       scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), max (spell->stats.sp, spell->stats.grace));
     }
-  else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
+  else if (tmp->flag [FLAG_STARTEQUIP] ||
            (random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
     {
       op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
       do_learn_spell (op, spell, 0);
       /* xp gain to literacy for spell learning */
-      if (!QUERY_FLAG (tmp, FLAG_STARTEQUIP))
+      if (!tmp->flag [FLAG_STARTEQUIP])
         change_exp (op, calc_skill_exp (op, tmp, skop), skop->skill, 0);
     }
   else
     {
       op->contr->play_sound (sound_find ("fumble_spell"));
 void
 apply_scroll (object *op, object *tmp, int dir)
 {
   object *skop;
-  if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
+  if (op->flag [FLAG_BLIND] && !op->flag [FLAG_WIZ])
     {
       op->failmsg ("You are unable to read while blind.");
       return;
     }
       int exp_gain = 0;
       /* hard code literacy - tmp->skill points to where the exp
        * should go for anything killed by the spell.
        */
-      skop = find_skill_by_name (op, skill_names[SK_LITERACY]);
+      skop = find_skill_by_name (op, shstr_literacy);
       if (!skop)
         {
-          op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill.>", &skill_names[SK_LITERACY]));
+          op->failmsgf ("You are unable to decipher the strange symbols. H<You lack the literacy skill.>");
           return;
         }
       if ((exp_gain = calc_skill_exp (op, tmp, skop)))
         change_exp (op, exp_gain, skop->skill, 0);
     }
-  if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
+  if (!tmp->flag [FLAG_IDENTIFIED])
     identify (tmp);
   op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name));
   cast_spell (op, tmp, dir, tmp->inv, NULL);
       treas->x = op->x;
       treas->y = op->y;
       treas = insert_ob_in_map (treas, op->map, op, INS_BELOW_ORIGINATOR);
-      if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && QUERY_FLAG (op, FLAG_ALIVE))
+      if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && op->flag [FLAG_ALIVE])
         spring_trap (treas, op);
       /* If either player or container was destroyed, no need to do
        * further processing. I think this should be enclused with
        * spring trap above, as I don't think there is otherwise
                 : tmp->type == DRINK
                      ? sound_find ("eat_drink")
                      : sound_find ("eat_food")
           );
-          if (!QUERY_FLAG (tmp, FLAG_CURSED))
+          if (!tmp->flag [FLAG_CURSED])
             {
               const char *buf;
               if (!op->is_dragon ())
                 {
               min_it (op->stats.hp, op->stats.maxhp);
               min_it (op->stats.food, MAX_FOOD);
             }
           /* special food hack -b.t. */
-          if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
+          if (tmp->title || tmp->flag [FLAG_CURSED])
             eat_special_food (op, tmp);
         }
     }
   handle_apply_yield (tmp);
  * Does some sanity checks, then calls improve_armour.
  */
 static void
 apply_armour_improver (object *op, object *tmp)
 {
-  object *armor;
-  if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_NO_MAGIC))
+  if (!op->flag [FLAG_WIZCAST] && (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_NO_MAGIC))
     {
       op->failmsg ("Something blocks the magic of the scroll. H<This area prevents magic effects.>");
       return;
     }
-  armor = find_marked_object (op);
+  object *armor = op->mark ();
   if (!armor)
     {
       op->failmsg ("You need to mark an armor object. Use the right mouse button popup or the mark command to do this.");
       return;
   if (armor->type != ARMOUR
       && armor->type != CLOAK
       && armor->type != BOOTS && armor->type != GLOVES && armor->type != BRACERS && armor->type != SHIELD && armor->type != HELMET)
     {
       op->failmsg ("Your marked item is not armour!\n");
+      return;
+    }
+  if (!op->apply (armor, AP_UNAPPLY))
+    {
+      op->failmsg ("You are unable to take off your armour to improve it!");
       return;
     }
   op->statusmsg ("Applying armour enchantment.");
   improve_armour (op, tmp, armor);
             }
         }
       if (!lighter)
         {
-          who->failmsg (format (
+          who->failmsgf (
             "You can't light up the %s with your bare hands! "
             "H<You need a lighter in your inventory, for example a flint and steel.>",
-            &op->name));
+            &op->name
+          );
           return 0;
         }
     }
   // last_eat == 0 means the lighter is not being used up!
       who->insert (lighter);
     }
   else if (lighter->last_eat)
     {
       /* no charges left in lighter */
-      who->failmsg (format (
+      who->failmsgf (
         "You attempt to light the %s with a used up %s.",
-        &op->name, &lighter->name));
+        &op->name, &lighter->name
+      );
       return 0;
     }
   return lighter;
 }
  * the selected object to "burn". -b.t.
  */
 static void
 apply_lighter (object *who, object *lighter)
 {
-  object *item;
+  if (object *item = who->mark ())
-  int is_player_env = 0;
-  item = find_marked_object (who);
-  if (item)
     {
       if (!auto_apply_lighter (who, item, lighter))
         return;
       /* Perhaps we should split what we are trying to light on fire?
       if (item->destroyed ()
           || ((item->type == LAMP || item->type == TORCH)
               && item->glow_radius > 0))
         who->statusmsg (format (
           "You light the %s with the %s.",
-          &item->name, &lighter->name));
+          &item->name, &lighter->name
+        ));
       else
-        who->failmsg (format (
+        who->failmsgf (
           "You attempt to light the %s with the %s and fail.",
-          &item->name, &lighter->name));
+          &item->name, &lighter->name
+        );
     }
   else
     who->failmsg ("You need to mark a lightable object.");
 }
 static void
 player_apply_lamp_cursed_effect (object *who, object *op)
 {
   if (op->level)
     {
-      who->failmsg (format (
+      who->failmsgf (
         "The %s was cursed, it explodes in a big fireball!",
-        &op->name));
+        &op->name
+      );
       create_exploding_ball_at (who, op->level);
     }
   else
     {
-      who->failmsg (format (
+      who->failmsgf (
         "The %s was cursed, it crumbles to dust, at least it didn't explode.!",
-        &op->name));
+        &op->name
+      );
     }
   op->destroy ();
 }
         return;
       if (op->stats.food < 1)
         {
           if (op->type == LAMP)
-            who->failmsg (format (
+            who->failmsgf (
               "The %s is out of fuel! "
               "H<Lamps and similar items need fuel. They cannot be refilled.>",
-              &op->name));
+              &op->name
+            );
           else
-            who->failmsg (format (
+            who->failmsgf (
               "The %s is burnt out! "
               "H<Torches and similar items burn out and become worthless.>",
-              &op->name));
+              &op->name
+            );
           return;
         }
       if (op->flag [FLAG_CURSED])
         {
  * The 'slaying' field for transformer is used as verb for the action.
  */
 static void
 apply_item_transformer (object *pl, object *transformer)
 {
-  object *marked;
   object *new_item;
   const char *find;
   char *separator;
   int yield;
   char got[MAX_BUF];
   int len;
   if (!pl || !transformer)
     return;
-  marked = find_marked_object (pl);
+  object *marked = pl->mark ();
   if (!marked)
     {
-      pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
+      pl->failmsgf ("Use the %s with what item?", query_name (transformer));
       return;
     }
   if (!marked->slaying)
     {
-      pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
+      pl->failmsgf ("You can't use the %s with your %s!", query_name (transformer), query_name (marked));
       return;
     }
   /* check whether they are compatible or not */
   find = strstr (&marked->slaying, transformer->arch->archname);
   if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
     {
-      pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
+      pl->failmsgf ("You can't use the %s with your %s!", query_name (transformer), query_name (marked));
       return;
     }
   find += strlen (transformer->arch->archname) + 1;
   /* Item can be used, now find how many and what it yields */
   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->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
+      pl->failmsgf ("This %s is strange, better to not use it.", query_base_name (marked, 0));
       return;
     }
   new_item->nrof = yield;
  * 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 (may_attempt_inv [op->type])
+  else if (apply_types_inv_only [op->type])
     {
       // special item, using slot system, needs to be in inv
       if (op->env == who)
         return apply_special (who, op, aflag);
-      who->failmsg (format ("You must get it first! H<You can only apply the %s if it is in your inventory.>\n", query_name (op)));
+      who->failmsgf ("You must get it first! H<You can only apply the %s if it is in your inventory.>\n", query_name (op));
     }
-  else if (!who->contr && may_attempt_player [op->type])
+  else if (!who->contr && apply_types_player_only [op->type])
     return 0; // monsters shouldn't try to apply player-only stuff
-  else if (may_attempt [op->type])
+  else if (apply_types [op->type])
     {
       // ordinary stuff, may be on the floor
       switch (op->type)
         {
           case T_HANDLE:
             break;
           case EXIT:
             if (!EXIT_PATH (op))
-              who->failmsg (format ("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;
     }
 }
 /**
    * item in the container.  Otherwise, use the map.
    */
   // first try to apply "applyables"
   for (object *tmp = top; tmp; tmp = tmp->below)
-    if (!tmp->invisible && may_attempt [tmp->type])
+    if (!tmp->invisible && apply_types [tmp->type])
       {
         // If it is visible, player can apply it.
         pl->apply (tmp);
         return;
       }
     switch (top->type)
       {
         // TODO: all this should move to examine
         case ALTAR:
         case IDENTIFY_ALTAR:
+        case TRIGGER_ALTAR:
         case CONVERTER:
+        //case TRIGGER_PEDESTAL:
-          pl->failmsg (format (
+          pl->failmsgf (
             "You see no obvious mechanism on the %s."
             "H<You have to drop one or more specific items here.>",
             query_short_name (top)
-          ));
+          );
           break;
         case BUTTON:
+        case TRIGGER_BUTTON:
-          pl->failmsg (format (
+          pl->failmsgf (
             "The %s looks as if you could activate it with somehting heavy. "
             "H<You must put enough items here to activate it.>",
             query_short_name (top)
-          ));
+          );
           break;
         default:
           examine (pl, top);
-          printf ("z %d\n", top->type);//D
           break;
       }
 }
 // saner interface, returns successful status
 bool
 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))
         {
   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;
-  CLEAR_FLAG (op, FLAG_AUTO_APPLY);
+  op->clr_flag (FLAG_AUTO_APPLY);
   switch (op->type)
     {
       case SHOP_FLOOR:
         if (!op->has_random_items ())
                    == NULL && --i);
             if (tmp == NULL)
               return 0;
-            if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
+            if (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED])
               {
                 tmp->destroy ();
                 tmp = NULL;
               }
           }
         while (!tmp);
         tmp->x = op->x;
         tmp->y = op->y;
-        SET_FLAG (tmp, FLAG_UNPAID);
+        tmp->set_flag (FLAG_UNPAID);
         insert_ob_in_map (tmp, op->map, NULL, 0);
         identify (tmp);
         break;
       case TREASURE:
-        if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
+        if (op->flag [FLAG_IS_A_TEMPLATE])
           return 0;
         while (op->stats.hp-- > 0)
           create_treasure (op->randomitems, op, op->map ? GT_ENVIRONMENT : 0,
                            op->stats.exp ? (int) op->stats.exp : op->map == NULL ? 14 : op->map->difficulty, 0);
             for (invtmp = tmp->inv; invtmp; invtmp = invnext)
               {
                 invnext = invtmp->below;
-                if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))
+                if (invtmp->flag [FLAG_AUTO_APPLY])
                   auto_apply (invtmp);
                 else if (invtmp->type == TREASURE && invtmp->has_random_items ())
                   {
                     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
                      */
             if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL
                 || tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)
               tmp->randomitems = NULL;
           }
-        if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))
+        if (tmp->flag [FLAG_AUTO_APPLY])
           auto_apply (tmp);
         else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())
           {
             while ((tmp->stats.hp--) > 0)
               create_treasure (tmp->randomitems, tmp, 0, difficulty, 0);
           }
         else if (tmp->type == TIMED_GATE)
           {
             object *head = tmp->head != NULL ? tmp->head : tmp;
-            if (QUERY_FLAG (head, FLAG_IS_LINKED))
+            if (head->flag [FLAG_IS_LINKED])
               tmp->set_speed (0);
           }
         /* This function can be called everytime a map is loaded, even when
          * swapping back in.  As such, we don't want to create the treasure
          * over and ove again, so after we generate the treasure, blank out
     }
   /* check for hp, sp change */
   if (food->stats.hp != 0)
     {
-      if (QUERY_FLAG (food, FLAG_CURSED))
+      if (food->flag [FLAG_CURSED])
         {
           who->contr->killer = food;
           hit_player (who, food->stats.hp, food, AT_POISON, 1);
           who->failmsg ("Eck!...that was poisonous!");
         }
         }
     }
   if (food->stats.sp != 0)
     {
-      if (QUERY_FLAG (food, FLAG_CURSED))
+      if (food->flag [FLAG_CURSED])
         {
           who->failmsg ("You are drained of mana!");
           who->stats.sp -= food->stats.sp;
           if (who->stats.sp < 0)
             who->stats.sp = 0;
               pl->animation_id        = change->animation_id;
               pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
             }
           /* check the special case of can't use weapons */
-          /*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
+          /*if(change->flag [FLAG_USE_WEAPON]) pl->clr_flag (FLAG_USE_WEAPON); */
           if (change->name == shstr_monk)
-            CLEAR_FLAG (pl, FLAG_USE_WEAPON);
+            pl->clr_flag (FLAG_USE_WEAPON);
           break;
         }
     }
 }

Diff Legend

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

Comparing deliantra/server/server/apply.C (file contents): Revision 1.245 by root, Tue Apr 6 03:53:29 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.245 by root, Tue Apr 6 03:53:29 2010 UTC vs.
Revision 1.278 by root, Thu Nov 17 04:49:22 2016 UTC