server/common/anim.C

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