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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.149 by root, Mon May 14 19:56:45 2007 UTC vs.
Revision 1.184 by root, Wed Aug 22 20:46:46 2007 UTC

 /*
- * CrossFire, A Multiplayer game
+ * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
  *
- * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
+ * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
- * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
- * Copyright (C) 1992 Frank Tore Johansen
+ * Copyright (©) 1992,2007 Frank Tore Johansen
  *
- * This program is free software; you can redistribute it and/or modify
+ * Crossfire TRT is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- * The authors can be reached via e-mail at <crossfire@schmorp.de>
+ * The authors can be reached via e-mail to <crossfire@schmorp.de>
  */
 /* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
    sub/add_weight will transcend the environment updating the carrying
    variable. */
         return 0;
       else if (!compare_ob_value_lists (ob1, ob2))
         return 0;
     }
-  //TODO: generate an event or call into perl for additional checks
   if (ob1->self || ob2->self)
     {
       ob1->optimise ();
       ob2->optimise ();
       if (ob1->self || ob2->self)
+        if (!cfperl_can_merge (ob1, ob2))
-        return 0;
+          return 0;
     }
   /* Everything passes, must be OK. */
   return 1;
 }
 /*
  * get_nearest_part(multi-object, object 2) returns the part of the
  * multi-object 1 which is closest to the second object.
  * If it's not a multi-object, it is returned.
  */
 object *
 get_nearest_part (object *op, const object *pl)
 {
   object *tmp, *closest;
   int last_dist, i;
 }
 /*
  * Sets the owner and sets the skill and exp pointers to owner's current
  * skill and experience objects.
+ * ACTUALLY NO! investigate! TODO
  */
 void
 object::set_owner (object *owner)
 {
+  // allow objects which own objects
-  if (!owner)
+  if (owner)
-    return;
-  /* next line added to allow objects which own objects */
-  /* Add a check for ownercounts in here, as I got into an endless loop
-   * with the fireball owning a poison cloud which then owned the
-   * fireball.  I believe that was caused by one of the objects getting
-   * freed and then another object replacing it.  Since the ownercounts
-   * didn't match, this check is valid and I believe that cause is valid.
-   */
-  while (owner->owner)
+    while (owner->owner)
-    owner = owner->owner;
+      owner = owner->owner;
   this->owner = owner;
 }
 int
 object::change_weapon (object *ob)
 {
   if (current_weapon == ob)
     return true;
+  if (chosen_skill)
+    chosen_skill->flag [FLAG_APPLIED] = false;
   current_weapon = ob;
   chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
+  if (chosen_skill)
+    chosen_skill->flag [FLAG_APPLIED] = true;
   update_stats ();
   if (ob)
     {
           {
             current_weapon = chosen_skill = 0;
             update_stats ();
             new_draw_info_format (NDI_UNIQUE, 0, this,
-                                  "You try to balance your applied items all at once, but the %s is too much. "
+                                  "You try to balance all your items at once, "
+                                  "but the %s is just too much for your body. "
-                                  "You need to unapply some items first.", &ob->name);
+                                  "[You need to unapply some items first.]", &ob->name);
             return false;
           }
       //new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
     }
   else
     ;//new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
+  if (ob && !ob->flag [FLAG_APPLIED] && ob->type != SPELL)
+    {
+      LOG (llevError | logBacktrace, "%s changed to unapplied weapon %s",
+           &name, ob->debug_desc ());
+      return false;
+    }
   return true;
 }
 /* Zero the key_values on op, decrementing the shared-string
     map = freed_map;
     x = 1;
     y = 1;
   }
-  head = 0;
   if (more)
     {
       more->destroy ();
       more = 0;
     }
+  head = 0;
-  // clear those pointers that likely might have circular references to us
+  // clear those pointers that likely might cause circular references
-  owner       = 0;
+  owner          = 0;
-  enemy       = 0;
+  enemy          = 0;
-  attacked_by = 0;
+  attacked_by    = 0;
+  current_weapon = 0;
 }
 void
 object::destroy (bool destroy_inventory)
 {
   if (destroyed ())
     return;
   if (destroy_inventory)
     destroy_inv (false);
+  if (is_head ())
+    if (sound_destroy)
+      play_sound (sound_destroy);
+    else if (flag [FLAG_MONSTER])
+      play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism
   attachable::destroy ();
 }
 /*
       if (map->in_memory == MAP_SAVING)
         return;
       int check_walk_off = !flag [FLAG_NO_APPLY];
+      if (object *pl = ms.player ())
+        {
+          if (pl->container == this)
+            /* If a container that the player is currently using somehow gets
+             * removed (most likely destroyed), update the player view
+             * appropriately.
+             */
+            pl->close_container ();
+          pl->contr->ns->floorbox_update ();
+        }
       for (tmp = ms.bot; tmp; tmp = tmp->above)
         {
           /* No point updating the players look faces if he is the object
            * being removed.
            */
-          if (tmp->type == PLAYER && tmp != this)
-            {
-              /* If a container that the player is currently using somehow gets
-               * removed (most likely destroyed), update the player view
-               * appropriately.
-               */
-              if (tmp->container == this)
-                {
-                  flag [FLAG_APPLIED] = 0;
-                  tmp->container = 0;
-                }
-              if (tmp->contr->ns)
-                tmp->contr->ns->floorbox_update ();
-            }
           /* See if object moving off should effect something */
           if (check_walk_off
               && ((move_type & tmp->move_off)
                   && (move_type & ~tmp->move_off & ~tmp->move_block) == 0))
               if (destroyed ())
                 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
             }
-          /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
-          //TODO: why is this horrible hacka fix? get rid of this code=bug! (schmorp)
-          if (tmp->above == tmp)
-            tmp->above = 0;
           last = tmp;
         }
       /* last == NULL if there are no objects on this space */
       //TODO: this makes little sense, why only update the topmost object?
   if (more)
     return;
   object *prev = this;
-  for (archetype *at = arch->more; at; at = at->more)
+  for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more)
     {
       object *op = arch_to_object (at);
       op->name    = name;
       op->name_pl = name_pl;
 object *
 insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
 {
   for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
     {
-      tmp->x = x + tmp->arch->clone.x;
+      tmp->x = x + tmp->arch->x;
-      tmp->y = y + tmp->arch->clone.y;
+      tmp->y = y + tmp->arch->y;
     }
   return insert_ob_in_map (op, m, originator, flag);
 }
 object *
 insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
 {
   assert (!op->flag [FLAG_FREED]);
-  object *tmp, *top, *floor = NULL;
+  object *top, *floor = NULL;
   op->remove ();
-#if 0
-  if (!m->active != !op->active)
-    if (m->active)
-      op->activate_recursive ();
-    else
-      op->deactivate_recursive ();
-#endif
   if (out_of_map (m, op->x, op->y))
     {
       LOG (llevError, "Trying to insert object outside the map.\n%s\n", op->debug_desc ());
 #ifdef MANY_CORES
 #endif
       return op;
     }
   if (object *more = op->more)
-    {
-      if (!insert_ob_in_map (more, m, originator, flag))
+    if (!insert_ob_in_map (more, m, originator, flag))
-        {
-          if (!op->head)
-            LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
-          return 0;
+      return 0;
-        }
-    }
   CLEAR_FLAG (op, FLAG_REMOVED);
   /* Ideally, the caller figures this out.  However, it complicates a lot
    * of areas of callers (eg, anything that uses find_free_spot would now
   mapspace &ms = op->ms ();
   /* this has to be done after we translate the coordinates.
    */
   if (op->nrof && !(flag & INS_NO_MERGE))
-    for (tmp = ms.bot; tmp; tmp = tmp->above)
+    for (object *tmp = ms.bot; tmp; tmp = tmp->above)
       if (object::can_merge (op, tmp))
         {
           op->nrof += tmp->nrof;
           tmp->destroy ();
         }
                */
               if (last && last->below && last != floor)
                 top = last->below;
             }
         }                       /* If objects on this space */
       if (flag & INS_MAP_LOAD)
         top = ms.top;
       if (flag & INS_ABOVE_FLOOR_ONLY)
         top = floor;
       op->map->touch ();
     }
   op->map->dirty = true;
-  /* If we have a floor, we know the player, if any, will be above
-   * it, so save a few ticks and start from there.
-   */
   if (!(flag & INS_MAP_LOAD))
     if (object *pl = ms.player ())
-      if (pl->contr->ns)
-        pl->contr->ns->floorbox_update ();
+      pl->contr->ns->floorbox_update ();
   /* If this object glows, it may affect lighting conditions that are
    * visible to others on this map.  But update_all_los is really
    * an inefficient way to do this, as it means los for all players
    * on the map will get recalculated.  The players could very well
    * blocked() and wall() work properly), and these flags are updated by
    * update_object().
    */
   /* if this is not the head or flag has been passed, don't check walk on status */
-  if (!(flag & INS_NO_WALK_ON) && !op->head)
+  if (!(flag & INS_NO_WALK_ON) && op->head_ () == op)
     {
       if (check_move_on (op, originator))
         return 0;
       /* If we are a multi part object, lets work our way through the check
        * walk on's.
        */
-      for (tmp = op->more; tmp != NULL; tmp = tmp->more)
+      for (object *tmp = op->more; tmp; tmp = tmp->more)
         if (check_move_on (tmp, originator))
           return 0;
     }
   return op;
   object *tmp, *tmp1;
   /* first search for itself and remove any old instances */
   for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
-    if (!strcmp (tmp->arch->name, arch_string))       /* same archetype */
+    if (!strcmp (tmp->arch->archname, arch_string))       /* same archetype */
       tmp->destroy ();
   tmp1 = arch_to_object (archetype::find (arch_string));
   tmp1->x = op->x;
       LOG (llevError, "Trying to put object in NULL.\n%s\n", dump);
       free (dump);
       return op;
     }
-  if (where->head)
+  if (where->head_ () != where)
     {
-      LOG (llevDebug, "Warning: Tried to insert object into wrong part of multipart object.\n");
+      LOG (llevError | logBacktrace, "Warning: Tried to insert object into wrong part of multipart object.\n");
       where = where->head;
     }
   return where->insert (op);
 }
  * be != op, if items are merged. -Tero
  */
 object *
 object::insert (object *op)
 {
-  object *tmp, *otmp;
   if (!QUERY_FLAG (op, FLAG_REMOVED))
     op->remove ();
   if (op->more)
     {
       return op;
     }
   CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
   CLEAR_FLAG (op, FLAG_REMOVED);
   if (op->nrof)
     {
-      for (tmp = inv; tmp != NULL; tmp = tmp->below)
+      for (object *tmp = inv; tmp; tmp = tmp->below)
         if (object::can_merge (tmp, op))
           {
             /* return the original object and remove inserted object
                (client needs the original object) */
             tmp->nrof += op->nrof;
       add_weight (this, op->weight * op->nrof);
     }
   else
     add_weight (this, (op->weight + op->carrying));
-  otmp = this->in_player ();
+  if (object *otmp = this->in_player ())
-  if (otmp && otmp->contr)
-    if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
+    if (otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
       otmp->update_stats ();
+  op->owner = 0; // its his/hers now. period.
-  op->map = 0;
+  op->map   = 0;
-  op->env = this;
+  op->env   = this;
   op->above = 0;
   op->below = 0;
-  op->x = 0, op->y = 0;
+  op->x = op->y = 0;
   /* reset the light list and los of the players on the map */
-  if ((op->glow_radius != 0) && map)
+  if (op->glow_radius && map)
     {
 #ifdef DEBUG_LIGHTS
       LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
 #endif /* DEBUG_LIGHTS */
       if (map->darkness)
     for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below)
       {
         CLEAR_FLAG (tmp, flag);
         unflag_inv (tmp, flag);
       }
-}
-/*
- * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in
- * all it's inventory (recursively).
- * If checksums are used, a player will get set_cheat called for
- * him/her-self and all object carried by a call to this function.
- */
-void
-set_cheat (object *op)
-{
-  SET_FLAG (op, FLAG_WAS_WIZ);
-  flag_inv (op, FLAG_WAS_WIZ);
 }
 /*
  * find_free_spot(object, map, x, y, start, stop) will search for
  * a spot at the given map and coordinates which will be able to contain
   object *tmp;
   maptile *mp;
   MoveType blocked, move_type;
-  if (exclude && exclude->head)
+  if (exclude && exclude->head_ () != exclude)
     {
       exclude = exclude->head;
       move_type = exclude->move_type;
     }
   else
             max = maxfree[i];
           else if (mflags & P_IS_ALIVE)
             {
               for (tmp = ms.bot; tmp; tmp = tmp->above)
                 if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER)
-                    && (tmp != exclude || (tmp->head && tmp->head != exclude)))
+                    && (tmp != exclude || (tmp->head_ () != tmp && tmp->head_ () != exclude)))
                   break;
               if (tmp)
                 return freedir[i];
             }
  * Cf 0.91.3 - don't let WIZ's pick up anything - will likely cause
  * core dumps if they do.
  *
  * Add a check so we can't pick up invisible objects (0.93.8)
  */
 int
 can_pick (const object *who, const object *item)
 {
   return                        /*QUERY_FLAG(who,FLAG_WIZ)|| */
     (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
  * create clone from object to another
  */
 object *
 object_create_clone (object *asrc)
 {
-  object *dst = 0, *tmp, *src, *part, *prev, *item;
+  object *dst = 0, *tmp, *src, *prev, *item;
   if (!asrc)
     return 0;
-  src = asrc;
-  if (src->head)
-    src = src->head;
+  src = asrc->head_ ();
   prev = 0;
-  for (part = src; part; part = part->more)
+  for (object *part = src; part; part = part->more)
     {
       tmp = part->clone ();
       tmp->x -= src->x;
       tmp->y -= src->y;
           /* Basically, if the archetype has this key set,
            * we need to store the null value so when we save
            * it, we save the empty value so that when we load,
            * we get this value back again.
            */
-          if (get_ob_key_link (&op->arch->clone, canonical_key))
+          if (get_ob_key_link (op->arch, canonical_key))
             field->value = 0;
           else
             {
               if (last)
                 last->next = field->next;
     }
   else
     item = item->env;
 }
 const char *
 object::flag_desc (char *desc, int len) const
 {
   char *p = desc;
   bool first = true;
                  &name,
                  title ? "\",title:\"" : "",
                  title ? (const char *)title : "",
                  flag_desc (flagdesc, 512), type);
-  if (env)
+  if (!this->flag[FLAG_REMOVED] && env)
     p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
   if (map)
     p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
 }
 const materialtype_t *
 object::dominant_material () const
 {
-  if (materialtype_t *mat = name_to_material (materialname))
+  if (materialtype_t *mt = name_to_material (materialname))
-    return mat;
+    return mt;
-  // omfg this is slow, this has to be temporary :)
-  shstr unknown ("unknown");
-  return name_to_material (unknown);
+  return name_to_material (shstr_unknown);
 }
 void
 object::open_container (object *new_container)
 {
       old_container->flag [FLAG_APPLIED] = 0;
       container = 0;
       esrv_update_item (UPD_FLAGS, this, old_container);
       new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
+      play_sound (sound_find ("chest_close"));
     }
   if (new_container)
     {
       if (INVOKE_OBJECT (OPEN, new_container, ARG_OBJECT (this)))
       new_container->flag [FLAG_APPLIED] = 1;
       container = new_container;
       esrv_update_item (UPD_FLAGS, this, new_container);
       esrv_send_inventory (this, new_container);
+      play_sound (sound_find ("chest_open"));
+    }
+}
+object *
+object::force_find (const shstr name)
+{
+  /* cycle through his inventory to look for the MARK we want to
+   * place
+   */
+  for (object *tmp = inv; tmp; tmp = tmp->below)
+    if (tmp->type == FORCE && tmp->slaying == name)
+      return splay (tmp);
+  return 0;
+}
+void
+object::force_add (const shstr name, int duration)
+{
+  if (object *force = force_find (name))
+    force->destroy ();
+  object *force = get_archetype (FORCE_NAME);
+  force->slaying    = name;
+  force->stats.food = 1;
+  force->speed_left = -1.f;
+  force->set_speed (duration ? 1.f / duration : 0.f);
+  force->flag [FLAG_IS_USED_UP] = true;
+  force->flag [FLAG_APPLIED]    = true;
+  insert (force);
+}
+void
+object::play_sound (faceidx sound) const
+{
+  if (!sound)
+    return;
+  if (flag [FLAG_REMOVED])
+    return;
+  if (env)
-    }
+    {
+      if (object *pl = in_player ())
+        pl->contr->play_sound (sound);
+    }
+  else
+    map->play_sound (sound, x, y);
 }

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.149 by root, Mon May 14 19:56:45 2007 UTC vs. Revision 1.184 by root, Wed Aug 22 20:46:46 2007 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.149 by root, Mon May 14 19:56:45 2007 UTC vs.
Revision 1.184 by root, Wed Aug 22 20:46:46 2007 UTC