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

Comparing deliantra/server/server/time.C (file contents):
Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC vs.
Revision 1.118 by root, Fri Jan 27 22:00:40 2012 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * 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.
     return;
   object *op;
   int dir;
-  if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
+  if (gen->flag [FLAG_CONTENT_ON_GEN])
     {
       // either copy one item from the inventory...
       if (!gen->inv)
         return;
       if (dir < 0)
         return;
       op = op->deep_clone ();
-      CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);
+      op->clr_flag (FLAG_IS_A_TEMPLATE);
       unflag_inv (op, FLAG_IS_A_TEMPLATE);
     }
   else if (gen->other_arch)
     {
       // ...or use other_arch
   if (op->env)
     switch (op->subtype)
       {
         case FORCE_CONFUSION:
-          CLEAR_FLAG (op->env, FLAG_CONFUSED);
+          op->env->clr_flag (FLAG_CONFUSED);
           new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");
         default:
-          CLEAR_FLAG (op, FLAG_APPLIED);
+          op->clr_flag (FLAG_APPLIED);
           change_abil (op->env, op);
           op->env->update_stats ();
       }
   op->destroy ();
 remove_blindness (object *op)
 {
   if (--op->stats.food > 0)
     return;
-  CLEAR_FLAG (op, FLAG_APPLIED);
+  op->clr_flag (FLAG_APPLIED);
   if (op->env)
     {
       change_abil (op->env, op);
       op->env->update_stats ();
 }
 static void
 poison_more (object *op)
 {
-  if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0)
+  if (op->env == NULL || !op->env->flag [FLAG_ALIVE] || op->env->stats.hp < 0)
     {
       op->destroy ();
       return;
     }
       /* need to unapply the object before update_stats is called, else fix_player
        * will not do anything.
        */
       if (op->env->type == PLAYER)
         {
-          CLEAR_FLAG (op, FLAG_APPLIED);
+          op->clr_flag (FLAG_APPLIED);
           op->env->update_stats ();
           new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
         }
       op->destroy ();
 {                               /* 1 = going down, 0 = going up */
   object *tmp;
   if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
     {
-      LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op));
+      LOG (llevError, "%s: gate error: animation was %d, max=%d\n", op->debug_desc (), op->stats.wc, NUM_ANIMATIONS (op));
       op->stats.wc = 0;
     }
   /* We're going down */
   if (op->value)
         }
       if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
         {
           op->move_block = 0;
-          CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
+          op->clr_flag (FLAG_BLOCKSVIEW);
           update_all_los (op->map, op->x, op->y);
         }
       SET_ANIMATION (op, op->stats.wc);
       update_object (op, UP_OBJ_CHANGE);
   /* We're going up */
   /* First, lets see if we are already at the top */
   if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
     {
       /* Check to make sure that only non pickable and non rollable
        * objects are above the gate.  If so, we finish closing the gate,
        * otherwise, we fall through to the code below which should lower
        * the gate slightly.
        */
       for (tmp = op->above; tmp; tmp = tmp->above)
-        if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))
+        if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
           break;
       if (!tmp)
         {
           if (op->arch->has_active_speed ())
           for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
             ;
           if (tmp)
             {
-              if (QUERY_FLAG (tmp, FLAG_ALIVE))
+              if (tmp->flag [FLAG_ALIVE])
                 {
                   hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
                   op->play_sound (sound_find ("blocked_gate"));
                   if (tmp->type == PLAYER)
                 }
                 /* If the object is not alive, and the object either can
                  * be picked up or the object rolls, move the object
                  * off the gate.
                  */
-              else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
+              else if (!tmp->flag [FLAG_ALIVE] && (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL]))
                 {
                   /* If it has speed, it should move itself, otherwise: */
                   int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
                   /* If there is a free spot, move the object someplace */
                 }
             }
           /* See if there is still anything blocking the gate */
           for (tmp = op->above; tmp; tmp = tmp->above)
-            if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))
+            if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
               break;
           /* IF there is, start putting the gate down  */
           if (tmp)
             op->stats.food = 1;
           else
             {
               op->move_block = MOVE_ALL;
               if (!op->arch->stats.ac)
-                SET_FLAG (op, FLAG_BLOCKSVIEW);
+                op->set_flag (FLAG_BLOCKSVIEW);
               update_all_los (op->map, op->x, op->y);
             }
         }                       /* gate is halfway up */
       SET_ANIMATION (op, op->stats.wc);
               move_apply (op, tmp, tmp);
             }
         }
       SET_ANIMATION (op, op->stats.wc);
-      update_object (op, UP_OBJ_FACE);
+      update_object (op, UP_OBJ_CHANGE);
       return;
     }
   /* We're closing */
   op->move_on = 0;
   op->stats.wc++;
-  if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
+  if (op->stats.wc >= NUM_ANIMATIONS (op))
     op->stats.wc = NUM_ANIMATIONS (op) - 1;
   SET_ANIMATION (op, op->stats.wc);
-  update_object (op, UP_OBJ_FACE);
+  update_object (op, UP_OBJ_CHANGE);
-  if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
+  if (op->stats.wc == (NUM_ANIMATIONS (op) - 1))
     op->set_speed (0);     /* closed, let's stop */
 }
 /* stop_item() returns a pointer to the stopped object.  The stopped object
 fix_stopped_item (object *op, maptile *map, object *originator)
 {
   if (map == NULL)
     return;
-  if (QUERY_FLAG (op, FLAG_REMOVED))
+  if (op->flag [FLAG_REMOVED])
     insert_ob_in_map (op, map, originator, 0);
   else if (op->type == ARROW)
     merge_ob (op, NULL);        /* only some arrows actually need this */
 }
       if (op)
         merge_ob (op, 0);
     }
 }
-/* Move an arrow along its course.  op is the arrow or thrown object.
+/* Move an arrow or throwen_obj along its course.  op is the arrow or thrown object.
  */
 void
 move_arrow (object *op)
 {
   int was_reflected;
   if (!op->map)
     {
-      LOG (llevError, "BUG: Arrow had no map.\n");
+      LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
       op->destroy ();
       return;
     }
   /* we need to stop thrown objects at some point. Like here. */
           stop_arrow (op);
           return;
         }
     }
+  /* decrease the speed as it flies. 0.05 means a standard bow will shoot
+   * about 17 squares. Tune as needed.
+   */
+  op->set_speed (op->speed - 0.05);
   /* if the arrow is moving too slow.. stop it.  0.5 was chosen as lower
      values look rediculous. */
-  if (op->speed < 0.5 && op->type == ARROW)
+  if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
     {
       stop_arrow (op);
       return;
     }
   if (pos->flags () & P_IS_ALIVE)
     {
       object *tmp;
       for (tmp = pos->bot; tmp; tmp = tmp->above)
-        if (QUERY_FLAG (tmp, FLAG_ALIVE))
+        if (tmp->flag [FLAG_ALIVE])
           break;
       /* Not really fair, but don't let monsters hit themselves with
        * their own arrow - this can be because they fire it then
        * move into it.
         {
           /* Found living object, but it is reflecting the missile.  Update
            * as below. (Note that for living creatures there is a small
            * chance that reflect_missile fails.)
            */
-          if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10))
+          if (tmp->flag [FLAG_REFL_MISSILE] && (rndm (0, 99)) < (90 - op->level / 10))
             {
-              int number = op->face;
               op->direction = absdir (op->direction + 4);
               update_turn_face (op);
               was_reflected = 1;        /* skip normal movement calculations */
             }
           else
        * note that this code will now catch cases where a monster is
        * on a wall but has reflecting - the arrow won't reflect.
        * Mapmakers shouldn't put monsters on top of wall in the first
        * place, so I don't consider that a problem.
        */
-      if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19)))
+      if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
         {
           stop_arrow (op);
           return;
         }
       else
           if (op->has_anim ())
             op->set_anim_frame (op->direction);
         }                       /* object is reflected */
     }                           /* object ran into a wall */
-  /* decrease the speed as it flies. 0.05 means a standard bow will shoot
-   * about 17 squares. Tune as needed.
-   */
-  op->speed -= 0.05;
   /* Move the arrow. */
   op->move_to (pos);
 }
 static void
       LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
       return;
     }
   /* In non-living items only change when food value is 0 */
-  if (!QUERY_FLAG (op, FLAG_ALIVE))
+  if (!op->flag [FLAG_ALIVE])
     {
       if (op->stats.food-- > 0)
         return;
       op->stats.food = 1;     /* so 1 other_arch is made */
   if (op->head)
     head = op->head;
   for (tmp = op->above; tmp; tmp = tmp->above)
-    if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR))
+    if (!tmp->flag [FLAG_IS_FLOOR])
       break;
   /* If nothing above us to move, nothing to do */
-  if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS))
+  if (!tmp || tmp->flag [FLAG_WIZPASS])
     return;
   if (EXIT_PATH (head))
     {
       if (tmp->type == PLAYER)
     }
   cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);
 }
-/*  move_player_mover:  this function takes a "player mover" as an
+/* move_player_mover:  this function takes a "player mover" as an
  * argument, and performs the function of a player mover, which is:
  *
  * a player mover finds any players that are sitting on it.  It
  * moves them in the op->stats.sp direction.  speed is how often it'll move.
  * If attacktype is nonzero it will paralyze the player.  If lifesave is set,
  * it'll paralyze the victim for hp*his speed/op->speed
  */
 static void
 move_player_mover (object *op)
 {
-  int dir = op->stats.sp;
+  int dir = 0;
-  sint16 nx, ny;
-  maptile *m;
-  /* Determine direction now for random movers so we do the right thing */
-  if (!dir)
-    dir = rndm (1, 8);
   for (object *victim = op->ms ().bot; victim; victim = victim->above)
     {
-      if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) &&
+      if (victim->flag [FLAG_ALIVE]
+          && !victim->flag [FLAG_WIZPASS]
-          (victim->move_type & op->move_type || !victim->move_type))
+          && (victim->move_type & op->move_type || !victim->move_type))
+        {
+          if (op->flag [FLAG_LIFESAVE] && op->stats.hp-- < 0)
-        {
+            {
+              op->destroy ();
+              return;
+            }
+          /* Determine direction only once so we do the right thing */
+          // why is it the right thing, though?
+          if (!dir)
+            dir = op->stats.sp ? op->stats.sp : rndm (1, 8);
+          sint16 nx = op->x + freearr_x[dir];
+          sint16 ny = op->y + freearr_y[dir];
+          maptile *m = op->map;
+          if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
+            {
+              LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
+              return;
+            }
           if (victim->head)
             victim = victim->head;
-          if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
-            {
-              op->remove ();
-              return;
-            }
-          nx = op->x + freearr_x[dir];
-          ny = op->y + freearr_y[dir];
-          m = op->map;
-          if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
-            {
-              LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
-              return;
-            }
           if (should_director_abort (op, victim))
             return;
           for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
             {
               if (nextmover->type == PLAYERMOVER)
                 nextmover->speed_left = -.99f;
-              if (QUERY_FLAG (nextmover, FLAG_ALIVE))
+              if (nextmover->flag [FLAG_ALIVE])
                 op->speed_left = -1.1f;        /* wait until the next thing gets out of the way */
             }
           if (victim->type == PLAYER)
             {
 void
 move_creator (object *creator)
 {
   object *new_ob;
-  if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0)
+  if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
     {
       creator->stats.hp = -1;
       return;
     }
       int i;
       object *ob_to_copy;
       /* select random object from inventory to copy */
       ob_to_copy = creator->inv;
-      for (ob = creator->inv->below, i = 1; ob != NULL; ob = ob->below, i++)
+      for (ob = creator->inv->below, i = 1; ob; ob = ob->below, i++)
         {
           if (rndm (0, i) == 0)
             {
               ob_to_copy = ob;
             }
         }
       new_ob = ob_to_copy->deep_clone ();
-      CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);
+      new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
       unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
     }
   else
     {
       if (!creator->other_arch)
       return;
     }
   // for now lets try to identify everything generated here, it mostly
   // happens automated, so this will at least fix many identify-experience holes
-  SET_FLAG (new_ob, FLAG_IDENTIFIED);
+  if (new_ob->need_identify ())
+    new_ob->set_flag (FLAG_IDENTIFIED);
   insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
-  if (QUERY_FLAG (new_ob, FLAG_FREED))
+  if (new_ob->flag [FLAG_FREED])
     return;
   if (creator->slaying)
     new_ob->name = new_ob->title = creator->slaying;
 }
 }
 void
 process_object (object *op)
 {
-  if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)))
+  if (expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
     return;
   if (expect_false (INVOKE_OBJECT (TICK, op)))
     return;
-  if (QUERY_FLAG (op, FLAG_MONSTER))
+  if (op->flag [FLAG_MONSTER])
-    if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED))
+    if (move_monster (op) || op->flag [FLAG_FREED])
       return;
-  if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0)
+  if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
     {
       animate_object (op, op->contr ? op->facing : op->direction);
-      if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
+      if (op->flag [FLAG_SEE_ANYWHERE])
         make_sure_seen (op);
     }
   if (expect_false (
         op->flag [FLAG_GENERATOR]
         || op->flag [FLAG_CHANGING]
         || op->flag [FLAG_IS_USED_UP]
      ))
     {
-      if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)
+      if (op->flag [FLAG_CHANGING] && !op->state)
         {
           change_object (op);
           return;
         }
-      if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY))
+      if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
         generate_monster (op);
-      if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0)
+      if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
         {
-          if (QUERY_FLAG (op, FLAG_APPLIED))
+          if (op->flag [FLAG_APPLIED])
             remove_force (op);
           else
             {
               op->remove (); // TODO: really necessary?
-              if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
+              if (op->flag [FLAG_SEE_ANYWHERE])
                 make_sure_not_seen (op);
               op->drop_and_destroy ();
             }
       case LAMP:
       case TORCH:
         move_lamp (op);
         break;
-    }
-}
+      case PHYSICS: // hmm, bad naming
+        move_physics (op);
+        break;
+    }
+}

Diff Legend

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

Comparing deliantra/server/server/time.C (file contents): Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC vs. Revision 1.118 by root, Fri Jan 27 22:00:40 2012 UTC

Diff Legend

Comparing deliantra/server/server/time.C (file contents):
Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC vs.
Revision 1.118 by root, Fri Jan 27 22:00:40 2012 UTC