/*
* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
*
* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team
* Copyright (©) 1992,2007 Frank Tore Johansen
*
* Crossfire TRT 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 3 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, see .
*
* The authors can be reached via e-mail to
*/
/* This file contains animation related code. */
#include
#include
animhash_t animhash;
std::vector animations;
void
animation::resize (int new_size)
{
sfree (faces, num_animations);
num_animations = new_size;
faces = salloc (num_animations);
}
animation &
animation::create (const char *name, uint8 frames, uint8 facings)
{
if (animations.size () == MAXANIMNUM)
cleanup ("trying to create new animation, but MAXANIMNUM animations in use.");
animations.push_back (animation ());
animation &anim = animations.back ();
anim.number = animations.size () - 1;
anim.name = name;
anim.num_animations = frames;
anim.facings = facings;
anim.faces = salloc (frames);
animhash.insert (std::make_pair (anim.name, anim.number));
return anim;
}
animation &
animation::find (const char *name)
{
if (!name)
return animations [0];
animhash_t::iterator i = animhash.find (name);
return animations [i == animhash.end () ? 0 : i->second];
}
void
init_anim (void)
{
animation &anim0 = animation::create ("none", 1, 0);
anim0.faces [0] = 0;
}
/* Tries to find the animation id that matches name. Returns an integer match
* 0 if no match found (animation 0 is initialised as the 'bug' face
*/
//TODO: nuke this function and replace all occurences by animations::find
int
find_animation (const char *name)
{
return animation::find (name).number;
}
/*
* 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 %s lacks animation.\n", op->debug_desc ());
CLEAR_FLAG (op, FLAG_ANIMATE);
return;
}
if (op->head_ () != op)
{
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 animations 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 && op->arch->flag [FLAG_ALIVE])
{
if (op->face == 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_ () == op)
update_object (op, UP_OBJ_FACE);
}