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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.357 by root, Tue Nov 13 01:29:30 2012 UTC vs.
Revision 1.368 by root, Wed Dec 5 19:03:26 2018 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
- * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 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
 uint32_t object::create_count;
 uint32_t object::destroy_count;
 //+GPL
-short freearr_x[SIZEOFFREE] = {
+int freearr_x[SIZEOFFREE] = {
    0,
    0,  1,  1,  1,  0, -1, -1, -1,
    0,  1,  2,  2,  2,  2,  2,  1,  0, -1, -2, -2, -2, -2, -2, -1,
    0,  1,  2,  3,  3,  3,  3,  3,  3,  3,  2,  1,  0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
 };
-short freearr_y[SIZEOFFREE] = {
+int freearr_y[SIZEOFFREE] = {
    0,
   -1, -1,  0,  1,  1,  1,  0, -1,
   -2, -2, -2, -1,  0,  1,  2,  2,  2,  2,  2,  1,  0, -1, -2, -2,
   -3, -3, -3, -3, -2, -1,  0,  1,  2,  3,  3,  3,  3,  3,  3,  3,  2,  1,  0, -1, -2, -3, -3, -3
 };
   25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48,
   49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
 };
 const char *wall_suffix[16] = {
   "0",
   "1_3",
   "1_4",
   "2_1_2",
   "1_2",
   "2_2_4",
   "2_2_1",
   "3_1",
   "1_1",
   "2_2_3",
   "2_2_2",
   "3_3",
   "2_1_1",
   "3_4",
   "3_2",
   "4"
 };
 static void
 write_uuid (uval64 skip, bool sync)
 {
 {
   UUID uid;
   uid.seq = ++cur.seq;
-  if (expect_false (cur.seq >= seq_next_save))
+  if (ecb_expect_false (cur.seq >= seq_next_save))
     {
       seq_next_save = UUID::cur.seq + (UUID_GAP >> 1);
       write_uuid (UUID_GAP, false);
     }
 static bool
 compare_ob_value_lists_one (const object *wants, const object *has)
 {
   /* n-squared behaviour (see kv.get), but I'm hoping both
    * objects with lists are rare, and lists stay short. If not, use a
    * different structure or at least keep the lists sorted...
    */
   /* For each field in wants, */
   for (key_value *kv = wants->kv.first; kv; kv = kv->next)
     if (has->kv.get (kv->key) != kv->value)
       /* inventory ok - still need to check rest of this object to see
        * if it is valid.
        */
     }
-  /* Don't merge objects that are applied.  With the new 'body' code,
+  /* Don't merge objects that are applied. With the new 'body' code,
    * it is possible for most any character to have more than one of
    * some items equipped, and we don't want those to merge.
    */
   if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED])
     return 0;
-  /* Note sure why the following is the case - either the object has to
+  /* Not sure why the following is the case - either the object has to
-   * be animated or have a very low speed.  Is this an attempted monster
+   * be animated or have a very low speed. Is this an attempted monster
    * check?
    */
   if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ())
     return 0;
     speed_left = -1.;
   /* copy the body_info to the body_used - this is only really
    * need for monsters, but doesn't hurt to do it for everything.
    * by doing so, when a monster is created, it has good starting
    * values for the body_used info, so when items are created
    * for it, they can be properly equipped.
    */
-  for (int i = NUM_BODY_LOCATIONS; i--; )
+  for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
     slot[i].used = slot[i].info;
   attachable::instantiate ();
 }
   neu->map = map; // not copied by copy_to
   return neu;
 }
+// update the anhimation frame of an object, but only if it has an animation
+// assigned and the frame number if within the animation.
+void object::update_anim_frame (int frame)
+{
+  if (ecb_expect_false (!has_anim () || frame >= anim_frames ()))
+    return;
+  set_anim_frame (frame);
+  update_object (this, UP_OBJ_FACE);
+}
 /*
  * If an object with the IS_TURNABLE() flag needs to be turned due
  * to the closest player being on the other side, this function can
  * be called to update the face variable, _and_ how it looks on the map.
  */
 update_turn_face (object *op)
 {
   if (!op->flag [FLAG_IS_TURNABLE] || !op->arch)
     return;
-  SET_ANIMATION (op, op->direction);
+  op->update_anim_frame (op->direction);
-  update_object (op, UP_OBJ_FACE);
 }
 /*
  * Updates the speed of an object.  If the speed changes from 0 to another
  * value, or vice versa, then add/remove the object from the active list.
   else
     deactivate ();
 }
 /*
- * update_object() updates the the map.
+ * update_object() updates the map.
  * It takes into account invisible objects (and represent squares covered
  * by invisible objects by whatever is below them (unless it's another
  * invisible object, etc...)
  * If the object being updated is beneath a player, the look-window
  * of that player is updated (this might be a suboptimal way of
           || (op->flag [FLAG_DAMNED]   && !(m.flags_ & P_NO_CLERIC))
           || (m.move_on   | op->move_on  ) != m.move_on
           || (m.move_off  | op->move_off ) != m.move_off
           || (m.move_slow | op->move_slow) != m.move_slow
           /* This isn't perfect, but I don't expect a lot of objects to
            * have move_allow right now.
            */
           || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
         m.invalidate ();
 #else
       // the above is not strong enough a test to skip updating. los maybe? TODO (schmorp)
     op->activate_recursive ();
 }
 /* This function removes object 'op' from the list of active
  * objects.
  * This should only be used for style maps or other such
  * reference maps where you don't want an object that isn't
  * in play chewing up cpu time getting processed.
  * The reverse of this is to call update_ob_speed, which
  * will do the right thing based on the speed of the object.
  */
   flag [FLAG_REMOVED] = true;
   if (more)
     more->remove ();
   /*
    * In this case, the object to be removed is in someones
    * inventory.
    */
   if (env)
     {
       below = 0;
       env   = 0;
       if (pl && pl->is_player ())
         {
-          if (expect_false (pl->contr->combat_ob == this))
+          if (ecb_expect_false (pl->contr->combat_ob == this))
             {
               pl->apply (pl->contr->combat_ob, AP_UNAPPLY | AP_IGNORE_CURSE);
               pl->contr->combat_ob = 0;
               if (pl->contr->ranged_ob) pl->apply (pl->contr->ranged_ob);
             }
-          if (expect_false (pl->contr->ranged_ob == this))
+          if (ecb_expect_false (pl->contr->ranged_ob == this))
             {
               pl->apply (pl->contr->ranged_ob, AP_UNAPPLY | AP_IGNORE_CURSE);
               pl->contr->ranged_ob = 0;
               if (pl->contr->combat_ob) pl->apply (pl->contr->combat_ob);
             }
           pl->contr->queue_stats_update ();
-          if (expect_false (glow_radius) && pl->is_on_map ())
+          if (ecb_expect_false (glow_radius) && pl->is_on_map ())
             update_all_los (pl->map, pl->x, pl->y);
         }
     }
   else if (map)
     {
            * We've already dealt with merging if appropriate.
            * Generally, we want to put the new object on top. But if
            * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
            * floor, we want to insert above that and no further.
            * Also, if there are spell objects on this space, we stop processing
            * once we get to them.  This reduces the need to traverse over all of
            * them when adding another one - this saves quite a bit of cpu time
            * when lots of spells are cast in one area.  Currently, it is presumed
            * that flying non pickable objects are spell objects.
            */
           for (object *tmp = ms.bot; tmp; tmp = tmp->above)
   return op;
 }
 /* this function inserts an object in the map, but if it
  * finds an object of its own type, it'll remove that one first.
  * op is the object to insert it under: supplies x and the map.
  */
 void
 replace_insert_ob_in_map (shstr_tmp archname, object *op)
 {
 /*
  * env->insert (op)
  *   This function inserts the object op in the linked list
  *   inside the object environment.
  *
  * The function returns now pointer to inserted item, and return value can
  * be != op, if items are merged. -Tero
  */
 object *
 object::insert (object *op)
 {
    */
   if ((op->move_type & ~move_on & ~move_block) != 0 && (op->move_type & ~move_slow & ~move_block) != 0)
     return 0;
   /* The objects have to be checked from top to bottom.
    * Hence, we first go to the top:
    */
   for (object *next, *tmp = ms.top; tmp; tmp = next)
     {
       next = tmp->below;
  * inform the caller.  However, insert_ob_in_map will update as
  * necessary, so the caller shouldn't need to do any special work.
  * Note - updated to take an object instead of archetype - this is necessary
  * because arch_blocked (now ob_blocked) needs to know the movement type
  * to know if the space in question will block the object.  We can't use
  * the archetype because that isn't correct if the monster has been
  * customized, changed states, etc.
  */
 int
 find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
 {
           continue;
         }
       /* Basically, if we find a wall on a space, we cut down the search size.
        * In this way, we won't return spaces that are on another side of a wall.
        * This mostly work, but it cuts down the search size in all directions -
        * if the space being examined only has a wall to the north and empty
        * spaces in all the other directions, this will reduce the search space
        * to only the spaces immediately surrounding the target area, and
        * won't look 2 spaces south of the target space.
        */
  */
 int
 find_first_free_spot (const object *ob, maptile *m, int x, int y)
 {
   for (int i = 0; i < SIZEOFFREE; i++)
-    if (!ob->blocked (m, x + freearr_x[i], y + freearr_y[i]))
+    if (!ob->blocked (m, x + DIRX (i), y + DIRY (i)))
       return i;
   return -1;
 }
   while (--end)
     swap (arr [end], arr [rndm (end + 1)]);
 }
 /* new function to make monster searching more efficient, and effective!
  * This basically returns a randomized array (in the passed pointer) of
  * the spaces to find monsters.  In this way, it won't always look for
  * monsters to the north first.  However, the size of the array passed
  * covers all the spaces, so within that size, all the spaces within
  * the 3x3 area will be searched, just not in a predictable order.
   int mflags;
   if (dir < 0)
     return 0;                   /* exit condition:  invalid direction */
-  dx = x + freearr_x[dir];
+  dx = x + DIRX (dir);
-  dy = y + freearr_y[dir];
+  dy = y + DIRY (dir);
   mflags = get_map_flags (m, &m, dx, dy, &dx, &dy);
   /* This functional arguably was incorrect before - it was
    * checking for P_WALL - that was basically seeing if
   return 0;
 }
 /* Zero the key_values on op, decrementing the shared-string
  * refcounts and freeing the links.
  */
 void
 key_values::clear ()
 {
   for (key_value *kvp = first; kvp; )
   for (key_value *kvp = kv.first; kvp; kvp = kvp->next)
     add (kvp->key, kvp->value);
   reverse ();
+  return *this;
 }
 object::depth_iterator::depth_iterator (object *container)
 : iterator_base (container)
 {
 //+GPL
 object *
 object::force_find (shstr_tmp 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);

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.357 by root, Tue Nov 13 01:29:30 2012 UTC vs. Revision 1.368 by root, Wed Dec 5 19:03:26 2018 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.357 by root, Tue Nov 13 01:29:30 2012 UTC vs.
Revision 1.368 by root, Wed Dec 5 19:03:26 2018 UTC