server/common/anim.C


/*
 * static char *rcsid_anim_c =
 *   "$Id: anim.C,v 1.7 2006-09-10 16:00:23 root Exp $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program 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
    (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
    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
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

/* This file contains animation related code. */

#include <global.h>
#include <stdio.h>

std::vector < Animations > animations;

void
free_all_anim (void)
{
  for (int i = 0; i <= num_animations; i++)
    {
      animations[i].name = 0;
      free (animations[i].faces);
    }

  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;
            }
          num_animations++;

          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);
            }
          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 (!(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);
}

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)
{
  Animations
  search, *
    match;

  search.name = name;

  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;
}

/*
 * animate_object(object) updates the face-variable of an object.
 * If the object is the head of a multi-object, all objects are animated.
 * op is the object to animate.
 * dir is the direction the object is facing.  This is generally same as
 *    op->direction, but in some cases, op->facing is used instead - the
 *    caller has a better idea which one it really wants to be using,
 *    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);
}
Revision:	1.8
Committed:	Mon Sep 11 20:28:37 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.7:	+3 -5 lines
Log Message:	implement owner pointer using refcounted refptr templates
#	User	Rev	Content
1	root	1.7
2	elmex	1.1	/*
3			* static char *rcsid_anim_c =
4	root	1.8	* "$Id: anim.C,v 1.7 2006-09-10 16:00:23 root Exp $";
5	elmex	1.1	*/
6
7			/*
8			CrossFire, A Multiplayer game for X-windows
9
10			Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team
11			Copyright (C) 1992 Frank Tore Johansen
12
13			This program is free software; you can redistribute it and/or modify
14			it under the terms of the GNU General Public License as published by
15			the Free Software Foundation; either version 2 of the License, or
16			(at your option) any later version.
17
18			This program is distributed in the hope that it will be useful,
19			but WITHOUT ANY WARRANTY; without even the implied warranty of
20			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21			GNU General Public License for more details.
22
23			You should have received a copy of the GNU General Public License
24			along with this program; if not, write to the Free Software
25			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27			The authors can be reached via e-mail at crossfire-devel@real-time.com
28			*/
29
30			/* This file contains animation related code. */
31
32			#include <global.h>
33			#include <stdio.h>
34
35	root	1.7	std::vector < Animations > animations;
36	elmex	1.1
37	root	1.7	void
38			free_all_anim (void)
39	root	1.4	{
40	root	1.7	for (int i = 0; i <= num_animations; i++)
41	root	1.4	{
42			animations[i].name = 0;
43			free (animations[i].faces);
44	elmex	1.1	}
45	root	1.4
46			animations.clear ();
47	elmex	1.1	}
48
49	root	1.7	void
50			init_anim (void)
51			{
52			char
53			buf[MAX_BUF];
54			FILE *
55			fp;
56			static int
57			anim_init = 0;
58			int
59			num_frames = 0, faces[MAX_ANIMATIONS], i;
60
61			if (anim_init)
62			return;
63			num_animations = 0;
64			/* Make a default. New animations start at one, so if something
65			* thinks it is animated but hasn't set the animation_id properly,
66			* it will have a default value that should be pretty obvious.
67			*/
68			/* set the name so we don't try to dereferance null.
69			* Put # at start so it will be first in alphabetical
70			* order.
71			*/
72			{
73	root	1.8	Animations anim0;
74	root	1.7
75			anim0.name = "###none";
76			anim0.num_animations = 1;
77			anim0.faces = (Fontindex *) malloc (sizeof (Fontindex));
78			anim0.faces[0] = 0;
79			anim0.facings = 0;
80
81			animations.push_back (anim0);
82			}
83
84			sprintf (buf, "%s/animations", settings.datadir);
85			LOG (llevDebug, "Reading animations from %s...", buf);
86			if ((fp = fopen (buf, "r")) == NULL)
87			{
88			LOG (llevError, "Cannot open animations file %s: %s\n", buf, strerror (errno));
89			exit (-1);
90			}
91			while (fgets (buf, MAX_BUF - 1, fp) != NULL)
92			{
93			if (*buf == '#')
94			continue;
95			/* Kill the newline */
96			buf[strlen (buf) - 1] = '\0';
97			if (!strncmp (buf, "anim ", 5))
98			{
99			if (num_frames)
100			{
101			LOG (llevError, "Didn't get a mina before %s\n", buf);
102			num_frames = 0;
103	root	1.2	}
104	root	1.7	num_animations++;
105
106	root	1.8	Animations anim;
107	root	1.4
108	root	1.7	anim.name = buf + 5;
109			anim.num = num_animations; /* for bsearch */
110			anim.facings = 1;
111			animations.push_back (anim);
112			}
113			else if (!strncmp (buf, "mina", 4))
114			{
115			animations[num_animations].faces = (Fontindex ) malloc (sizeof (Fontindex) num_frames);
116			for (i = 0; i < num_frames; i++)
117			animations[num_animations].faces[i] = faces[i];
118			animations[num_animations].num_animations = num_frames;
119			if (num_frames % animations[num_animations].facings)
120			{
121			LOG (llevDebug, "Animation %s frame numbers (%d) is not a multiple of facings (%d)\n",
122			&animations[num_animations].name, num_frames, animations[num_animations].facings);
123	root	1.2	}
124	root	1.7	num_frames = 0;
125	root	1.2	}
126	root	1.7	else if (!strncmp (buf, "facings", 7))
127			{
128			if (!(animations[num_animations].facings = atoi (buf + 7)))
129			{
130			LOG (llevDebug, "Animation %s has 0 facings, line=%s\n", &animations[num_animations].name, buf);
131			animations[num_animations].facings = 1;
132	root	1.2	}
133
134	root	1.7	}
135			else
136			{
137			if (!(faces[num_frames++] = FindFace (buf, 0)))
138			LOG (llevDebug, "Could not find face %s for animation %s\n", buf, &animations[num_animations].name);
139	root	1.2	}
140	elmex	1.1	}
141	root	1.7	fclose (fp);
142			LOG (llevDebug, "done. got (%d)\n", num_animations);
143	elmex	1.1	}
144
145	root	1.7	static int
146			anim_compare (const Animations * a, const Animations * b)
147			{
148			return strcmp (a->name, b->name);
149	elmex	1.1	}
150
151			/* Tries to find the animation id that matches name. Returns an integer match
152			* 0 if no match found (animation 0 is initialized as the 'bug' face
153			*/
154	root	1.7	int
155			find_animation (const char *name)
156	elmex	1.1	{
157	root	1.7	Animations
158			search, *
159			match;
160	elmex	1.1
161	root	1.7	search.name = name;
162	elmex	1.1
163	root	1.7	match = (Animations *) bsearch (&search, &animations[0], (num_animations + 1),
164			sizeof (Animations), (int ()(const void , const void *)) anim_compare);
165	elmex	1.1
166
167	root	1.7	if (match)
168			return match->num;
169			LOG (llevError, "Unable to find animation %s\n", name);
170			return 0;
171	elmex	1.1	}
172
173			/*
174			* animate_object(object) updates the face-variable of an object.
175			* If the object is the head of a multi-object, all objects are animated.
176			* op is the object to animate.
177			* dir is the direction the object is facing. This is generally same as
178			* op->direction, but in some cases, op->facing is used instead - the
179			* caller has a better idea which one it really wants to be using,
180			* so let it pass along the right one.
181			*/
182
183	root	1.7	void
184			animate_object (object *op, int dir)
185			{
186			int
187			max_state; /* Max animation state object should be drawn in */
188			int
189			base_state; /* starting index # to draw from */
190
191			if (!op->animation_id \|\| !NUM_ANIMATIONS (op))
192			{
193			LOG (llevError, "Object lacks animation.\n");
194			dump_object (op);
195			return;
196			}
197			if (op->head)
198			{
199			dir = op->head->direction;
200
201			if (NUM_ANIMATIONS (op) == NUM_ANIMATIONS (op->head))
202			op->state = op->head->state;
203			else
204			++op->state;
205			}
206			else
207			{
208			++op->state; /* increase draw state */
209			}
210
211			/* If object is turning, then max animation state is half through the
212			* animations. Otherwise, we can use all the animations.
213			*/
214			max_state = NUM_ANIMATIONS (op) / NUM_FACINGS (op);
215			base_state = 0;
216			/* at least in the older aniamtions that used is_turning, the first half
217			* of the animations were left facing, the second half right facing.
218			* Note in old the is_turning, it was set so that the animation for a monster
219			* was always towards the enemy - now it is whatever direction the monster
220			* is facing.
221			*/
222			if (NUM_FACINGS (op) == 2)
223			{
224			if (dir < 5)
225			base_state = 0;
226			else
227			base_state = NUM_ANIMATIONS (op) / 2;
228			}
229			else if (NUM_FACINGS (op) == 4)
230			{
231			if (dir == 0)
232			base_state = 0;
233			else
234			base_state = ((dir - 1) / 2) * (NUM_ANIMATIONS (op) / 4);
235			}
236			else if (NUM_FACINGS (op) == 8)
237			{
238			if (dir == 0)
239			base_state = 0;
240			else
241			base_state = (dir - 1) * (NUM_ANIMATIONS (op) / 8);
242			}
243
244			/* If beyond drawable states, reset */
245			if (op->state >= max_state)
246			op->state = 0;
247
248			SET_ANIMATION (op, op->state + base_state);
249
250			if (op->face == blank_face)
251			op->invisible = 1;
252
253			/* This block covers monsters (eg, pixies) which are supposed to
254			* cycle from visible to invisible and back to being visible.
255			* as such, disable it for players, as then players would become
256			* visible.
257			*/
258			else if (op->type != PLAYER && QUERY_FLAG ((&op->arch->clone), FLAG_ALIVE))
259			{
260			if (op->face->number == 0)
261			{
262			op->invisible = 1;
263			CLEAR_FLAG (op, FLAG_ALIVE);
264			}
265			else
266			{
267			op->invisible = 0;
268			SET_FLAG (op, FLAG_ALIVE);
269			}
270			}
271
272			if (op->more)
273			animate_object (op->more, dir);
274
275			/* update_object will also recursively update all the pieces.
276			* as such, we call it last, and only call it for the head
277			* piece, and not for the other tail pieces.
278			*/
279			if (!op->head)
280			update_object (op, UP_OBJ_FACE);
281	elmex	1.1	}