--- deliantra/server/common/anim.C	2006/09/03 08:05:39	1.6
+++ deliantra/server/common/anim.C	2006/09/10 16:00:23	1.7
@@ -1,6 +1,7 @@
+
 /*
  * static char *rcsid_anim_c =
- *   "$Id: anim.C,v 1.6 2006/09/03 08:05:39 root Exp $";
+ *   "$Id: anim.C,v 1.7 2006/09/10 16:00:23 root Exp $";
  */
 
 /*
@@ -31,11 +32,12 @@
 #include <global.h>
 #include <stdio.h>
 
-std::vector<Animations> animations;
+std::vector < Animations > animations;
 
-void free_all_anim(void)
+void
+free_all_anim (void)
 {
-  for (int i=0; i<=num_animations; i++)
+  for (int i = 0; i <= num_animations; i++)
     {
       animations[i].name = 0;
       free (animations[i].faces);
@@ -44,105 +46,130 @@
   animations.clear ();
 }
 
-void init_anim(void) {
-    char buf[MAX_BUF];
-    FILE *fp;
-    static int anim_init=0;
-    int num_frames=0,faces[MAX_ANIMATIONS],i;
-
-    if (anim_init) return;
-    num_animations=0;
-    /* Make a default.  New animations start at one, so if something
-     * thinks it is animated but hasn't set the animation_id properly,
-     * it will have a default value that should be pretty obvious.
-     */
-    /* set the name so we don't try to dereferance null.
-     * Put # at start so it will be first in alphabetical
-     * order.
-     */
-    {
-      Animations anim0;
-
-      anim0.name = "###none";
-      anim0.num_animations=1;
-      anim0.faces = (Fontindex *) malloc(sizeof(Fontindex));
-      anim0.faces[0]=0;
-      anim0.facings=0;
-
-      animations.push_back (anim0);
-    }
-
-    sprintf(buf,"%s/animations", settings.datadir);
-    LOG(llevDebug,"Reading animations from %s...", buf);
-    if ((fp=fopen(buf,"r")) ==NULL) {
-        LOG(llevError, "Cannot open animations file %s: %s\n", buf, strerror(errno));
-        exit(-1);
-    }
-    while (fgets(buf, MAX_BUF-1, fp)!=NULL) {
-        if (*buf=='#') continue;
-        /* Kill the newline */
-        buf[strlen(buf)-1] = '\0';
-        if (!strncmp(buf,"anim ", 5)) {
-            if (num_frames) {
-                LOG(llevError,"Didn't get a mina before %s\n", buf);
-                num_frames=0;
+void
+init_anim (void)
+{
+  char
+    buf[MAX_BUF];
+  FILE *
+    fp;
+  static int
+    anim_init = 0;
+  int
+    num_frames = 0, faces[MAX_ANIMATIONS], i;
+
+  if (anim_init)
+    return;
+  num_animations = 0;
+  /* Make a default.  New animations start at one, so if something
+   * thinks it is animated but hasn't set the animation_id properly,
+   * it will have a default value that should be pretty obvious.
+   */
+  /* set the name so we don't try to dereferance null.
+   * Put # at start so it will be first in alphabetical
+   * order.
+   */
+  {
+    Animations
+      anim0;
+
+    anim0.name = "###none";
+    anim0.num_animations = 1;
+    anim0.faces = (Fontindex *) malloc (sizeof (Fontindex));
+    anim0.faces[0] = 0;
+    anim0.facings = 0;
+
+    animations.push_back (anim0);
+  }
+
+  sprintf (buf, "%s/animations", settings.datadir);
+  LOG (llevDebug, "Reading animations from %s...", buf);
+  if ((fp = fopen (buf, "r")) == NULL)
+    {
+      LOG (llevError, "Cannot open animations file %s: %s\n", buf, strerror (errno));
+      exit (-1);
+    }
+  while (fgets (buf, MAX_BUF - 1, fp) != NULL)
+    {
+      if (*buf == '#')
+        continue;
+      /* Kill the newline */
+      buf[strlen (buf) - 1] = '\0';
+      if (!strncmp (buf, "anim ", 5))
+        {
+          if (num_frames)
+            {
+              LOG (llevError, "Didn't get a mina before %s\n", buf);
+              num_frames = 0;
             }
-            num_animations++;
+          num_animations++;
+
+          Animations
+            anim;
 
-            Animations anim;
-            anim.name = buf + 5;
-            anim.num = num_animations;	/* for bsearch */
-            anim.facings = 1;
-            animations.push_back (anim);
-        }
-        else if (!strncmp(buf,"mina",4)) {
-            animations[num_animations].faces = (Fontindex *) malloc(sizeof(Fontindex)*num_frames);
-            for (i=0; i<num_frames; i++)
-                animations[num_animations].faces[i]=faces[i];
-            animations[num_animations].num_animations = num_frames;
-            if (num_frames % animations[num_animations].facings) {
-                LOG(llevDebug,"Animation %s frame numbers (%d) is not a multiple of facings (%d)\n",
-                    &animations[num_animations].name, num_frames, animations[num_animations].facings);
+          anim.name = buf + 5;
+          anim.num = num_animations;    /* for bsearch */
+          anim.facings = 1;
+          animations.push_back (anim);
+        }
+      else if (!strncmp (buf, "mina", 4))
+        {
+          animations[num_animations].faces = (Fontindex *) malloc (sizeof (Fontindex) * num_frames);
+          for (i = 0; i < num_frames; i++)
+            animations[num_animations].faces[i] = faces[i];
+          animations[num_animations].num_animations = num_frames;
+          if (num_frames % animations[num_animations].facings)
+            {
+              LOG (llevDebug, "Animation %s frame numbers (%d) is not a multiple of facings (%d)\n",
+                   &animations[num_animations].name, num_frames, animations[num_animations].facings);
             }
-            num_frames=0;
+          num_frames = 0;
         }
-        else if (!strncmp(buf,"facings",7)) {
-            if (!(animations[num_animations].facings = atoi(buf+7))) {
-                LOG(llevDebug,"Animation %s has 0 facings, line=%s\n",
-                    &animations[num_animations].name, buf);
-                animations[num_animations].facings=1;
+      else if (!strncmp (buf, "facings", 7))
+        {
+          if (!(animations[num_animations].facings = atoi (buf + 7)))
+            {
+              LOG (llevDebug, "Animation %s has 0 facings, line=%s\n", &animations[num_animations].name, buf);
+              animations[num_animations].facings = 1;
             }
 
-        } else {
-            if (!(faces[num_frames++] = FindFace(buf,0)))
-                LOG(llevDebug,"Could not find face %s for animation %s\n",
-                    buf, &animations[num_animations].name);
+        }
+      else
+        {
+          if (!(faces[num_frames++] = FindFace (buf, 0)))
+            LOG (llevDebug, "Could not find face %s for animation %s\n", buf, &animations[num_animations].name);
         }
     }
-    fclose(fp);
-    LOG(llevDebug,"done. got (%d)\n", num_animations);
+  fclose (fp);
+  LOG (llevDebug, "done. got (%d)\n", num_animations);
 }
 
-static int anim_compare(const Animations *a, const Animations *b) {
-    return strcmp(a->name, b->name);
+static int
+anim_compare (const Animations * a, const Animations * b)
+{
+  return strcmp (a->name, b->name);
 }
 
 /* Tries to find the animation id that matches name.  Returns an integer match 
  * 0 if no match found (animation 0 is initialized as the 'bug' face
  */
-int find_animation(const char *name)
+int
+find_animation (const char *name)
 {
-    Animations search, *match;
+  Animations
+  search, *
+    match;
 
-    search.name = name;
+  search.name = name;
 
-    match = (Animations*)bsearch(&search, &animations [0], (num_animations+1), 
-                sizeof(Animations), (int (*)(const void*, const void*))anim_compare);
+  match = (Animations *) bsearch (&search, &animations[0], (num_animations + 1),
+                                  sizeof (Animations), (int (*)(const void *, const void *)) anim_compare);
 
 
-    if (match) return match->num;
-    LOG(llevError,"Unable to find animation %s\n", name);
-    return 0;
+  if (match)
+    return match->num;
+  LOG (llevError, "Unable to find animation %s\n", name);
+  return 0;
 }
 
 /*
@@ -155,82 +182,102 @@
  *    so let it pass along the right one.
  */
 
-void animate_object(object *op, int dir) {
-    int max_state;  /* Max animation state object should be drawn in */
-    int base_state; /* starting index # to draw from */
-
-    if(!op->animation_id || !NUM_ANIMATIONS(op)) {
-        LOG(llevError,"Object lacks animation.\n");
-        dump_object(op);
-        return;
-    }
-    if (op->head) {
-        dir=op->head->direction;
-
-        if (NUM_ANIMATIONS(op) == NUM_ANIMATIONS(op->head))
-            op->state = op->head->state;
-        else
-            ++op->state;
-    }
-    else {
-        ++op->state;    /* increase draw state */
-    }
-
-    /* If object is turning, then max animation state is half through the
-     * animations.  Otherwise, we can use all the animations.
-     */
-    max_state=NUM_ANIMATIONS(op)/ NUM_FACINGS(op);
-    base_state=0;
-    /* at least in the older aniamtions that used is_turning, the first half
-     * of the animations were left facing, the second half right facing.
-     * Note in old the is_turning, it was set so that the animation for a monster
-     * was always towards the enemy - now it is whatever direction the monster
-     * is facing.
-     */
-    if (NUM_FACINGS(op)==2) {
-        if (dir<5) base_state=0;
-        else base_state=NUM_ANIMATIONS(op)/2;
-    }
-    else if (NUM_FACINGS(op)==4) {
-        if (dir==0) base_state=0;
-        else base_state = ((dir-1)/2) * (NUM_ANIMATIONS(op)/4); 
-    }
-    else if (NUM_FACINGS(op)==8) {
-        if (dir==0) base_state=0;
-        else base_state = (dir-1)*(NUM_ANIMATIONS(op)/8);
-    }
-
-    /* If beyond drawable states, reset */
-    if (op->state>=max_state) op->state=0;
-
-    SET_ANIMATION(op, op->state + base_state);
-
-    if(op->face==blank_face)
-        op->invisible=1;
-
-    /* This block covers monsters (eg, pixies) which are supposed to
-     * cycle from visible to invisible and back to being visible.
-     * as such, disable it for players, as then players would become
-     * visible.
-     */
-    else if(op->type != PLAYER && QUERY_FLAG((&op->arch->clone),FLAG_ALIVE)) {
-        if(op->face->number==0) {
-            op->invisible=1;
-            CLEAR_FLAG(op, FLAG_ALIVE);
-        } else {
-            op->invisible=0;
-            SET_FLAG(op, FLAG_ALIVE);
-        }
-    }
-
-    if(op->more)
-        animate_object(op->more, dir);
-
-    /* update_object will also recursively update all the pieces.
-     * as such, we call it last, and only call it for the head
-     * piece, and not for the other tail pieces.
-     */
-    if (!op->head)
-        update_object(op, UP_OBJ_FACE);
-}
+void
+animate_object (object *op, int dir)
+{
+  int
+    max_state;                  /* Max animation state object should be drawn in */
+  int
+    base_state;                 /* starting index # to draw from */
+
+  if (!op->animation_id || !NUM_ANIMATIONS (op))
+    {
+      LOG (llevError, "Object lacks animation.\n");
+      dump_object (op);
+      return;
+    }
+  if (op->head)
+    {
+      dir = op->head->direction;
 
+      if (NUM_ANIMATIONS (op) == NUM_ANIMATIONS (op->head))
+        op->state = op->head->state;
+      else
+        ++op->state;
+    }
+  else
+    {
+      ++op->state;              /* increase draw state */
+    }
+
+  /* If object is turning, then max animation state is half through the
+   * animations.  Otherwise, we can use all the animations.
+   */
+  max_state = NUM_ANIMATIONS (op) / NUM_FACINGS (op);
+  base_state = 0;
+  /* at least in the older aniamtions that used is_turning, the first half
+   * of the animations were left facing, the second half right facing.
+   * Note in old the is_turning, it was set so that the animation for a monster
+   * was always towards the enemy - now it is whatever direction the monster
+   * is facing.
+   */
+  if (NUM_FACINGS (op) == 2)
+    {
+      if (dir < 5)
+        base_state = 0;
+      else
+        base_state = NUM_ANIMATIONS (op) / 2;
+    }
+  else if (NUM_FACINGS (op) == 4)
+    {
+      if (dir == 0)
+        base_state = 0;
+      else
+        base_state = ((dir - 1) / 2) * (NUM_ANIMATIONS (op) / 4);
+    }
+  else if (NUM_FACINGS (op) == 8)
+    {
+      if (dir == 0)
+        base_state = 0;
+      else
+        base_state = (dir - 1) * (NUM_ANIMATIONS (op) / 8);
+    }
+
+  /* If beyond drawable states, reset */
+  if (op->state >= max_state)
+    op->state = 0;
+
+  SET_ANIMATION (op, op->state + base_state);
+
+  if (op->face == blank_face)
+    op->invisible = 1;
+
+  /* This block covers monsters (eg, pixies) which are supposed to
+   * cycle from visible to invisible and back to being visible.
+   * as such, disable it for players, as then players would become
+   * visible.
+   */
+  else if (op->type != PLAYER && QUERY_FLAG ((&op->arch->clone), FLAG_ALIVE))
+    {
+      if (op->face->number == 0)
+        {
+          op->invisible = 1;
+          CLEAR_FLAG (op, FLAG_ALIVE);
+        }
+      else
+        {
+          op->invisible = 0;
+          SET_FLAG (op, FLAG_ALIVE);
+        }
+    }
+
+  if (op->more)
+    animate_object (op->more, dir);
+
+  /* update_object will also recursively update all the pieces.
+   * as such, we call it last, and only call it for the head
+   * piece, and not for the other tail pieces.
+   */
+  if (!op->head)
+    update_object (op, UP_OBJ_FACE);
+}