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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.360 by root, Wed Nov 16 23:41:59 2016 UTC vs.
Revision 1.366 by root, Sat Nov 17 23:40:00 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,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
 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)
 {
 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)
    * 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 ();
 }
           || (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)
     {
            * 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; )
 //+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.360 by root, Wed Nov 16 23:41:59 2016 UTC vs. Revision 1.366 by root, Sat Nov 17 23:40:00 2018 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.360 by root, Wed Nov 16 23:41:59 2016 UTC vs.
Revision 1.366 by root, Sat Nov 17 23:40:00 2018 UTC