monsters.cc

Go to the documentation of this file.

/*
 *  monsters.cc - Monsters.
 *
 *  Copyright (C) 2000-2001  The Exult Team
 *
 *  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "monsters.h"
#include "monstinf.h"
#include "gamewin.h"
#include "animate.h"
#include "schedule.h"
#include "chunks.h"
#include "Audio.h"
#include "gamemap.h"
#include "game.h"
#include "effects.h"

#ifndef UNDER_CE
using std::rand;
#endif

/*
 *  Slimes move differently.
 */
class Slime_actor : public Monster_actor
  {
  void update_frames(Tile_coord src, Tile_coord dest);
public:
  Slime_actor(const std::string &nm, int shapenum, int num = -1, 
              int uc = -1)
    : Monster_actor(nm, shapenum, num, uc)
    {  }
          // Step onto an (adjacent) tile.
  virtual int step(Tile_coord t, int frame);
          // Remove/delete this object.
  virtual void remove_this(int nodel = 0);
          // Move to new abs. location.
  virtual void move(int newtx, int newty, int newlift);
  };

/*
 *  Monsters (like cyclops) that cause quakes when they walk:
 */
class Quaking_actor : public Monster_actor
  {
  int qsteps;     // # steps between quakes.
  int steps;      // # steps taken.
public:
  Quaking_actor(const std::string &nm, int shapenum, int qs = 5,
            int num = -1, int uc = -1)
    : Monster_actor(nm, shapenum, num, uc), qsteps(qs), steps(0)
    {  }
          // Step onto an (adjacent) tile.
  virtual int step(Tile_coord t, int frame);
  };

Monster_actor *Monster_actor::in_world = 0;

/*
 *  Add to global list (if not already there).
 */

void Monster_actor::link_in
  (
  )
  {
  if (prev_monster || in_world == this)
    return;     // Already in list.
  if (in_world)     // Add to head.
    in_world->prev_monster = this;
  next_monster = in_world;
  in_world = this;
  }

/*
 *  Remove from global list (if in list).
 */

void Monster_actor::link_out
  (
  )
  {
  if (next_monster)
    next_monster->prev_monster = prev_monster;
  if (prev_monster)
    prev_monster->next_monster = next_monster;
  else        // We're at start of list.
    if (in_world == this)
      in_world = next_monster;
  next_monster = prev_monster = 0;
  }

/*
 *  Create monster.
 */

Monster_actor::Monster_actor
  (
  const std::string &nm, 
  int shapenum, 
  int num,      // Generally -1.
  int uc
  ) : Npc_actor(nm, shapenum, num, uc), prev_monster(0),
      next_monster(0), animator(0)
  {
          // Check for animated shape.
  Shape_info& info = get_info();
  if (info.is_animated())
    animator = Animator::create(this);
  }

/*
 *  Delete.
 */

Monster_actor::~Monster_actor
  (
  )
  {
  delete animator;
  link_out();     // Remove from chain.
  }

/*
 *  Another set of constants that should be in a data file (or that's
 *  probably already in one of the U7 data files), this one correlating
 *  a 'monster' shape with the food frame you get when you kill it.
 */
static int Monster_food[] = {
  498, 10,      // Chicken.
  500,  9,      // Cow - beef steaks.
  502,  14,     // Deer - meat.
  509, 12,      // Fish.
  811, 9,       // Rabbit - same as cow?
  970, 8,       // Sheep - mutton.
  727, 23,      // Horse - ribs.
  329, 11       // Boar - ham.
  };

/*
 *  Find food frame for given monster shape.
 *
 *  Output: Frame if found, else a random frame (0-31).
 */

static int Find_monster_food
  (
  int shnum     // Monster shape.
  )
  {
  const int cnt = sizeof(Monster_food)/(2*sizeof(Monster_food[0]));
  for (int i = 0; i < cnt; i++)
    if (Monster_food[2*i] == shnum)
      return Monster_food[2*i + 1];
  return rand()%32;
  }

/*
 *  Create an instance of a monster.
 */

Monster_actor *Monster_actor::create
  (
  int shnum     // Shape to use.
  )
  {
  if (shnum == 529)   // Slime?
          // Usecode = shape.
    return new Slime_actor("", shnum, -1, shnum);
  else if (shnum == 501 || (shnum == 380 && GAME_BG))
    return new Quaking_actor("", shnum, 5, -1, shnum);
  else
    return new Monster_actor("", shnum, -1, shnum);
  }

/*
 *  Create an instance of a monster and initialize from monstinf.dat.
 */

Monster_actor *Monster_actor::create
  (
  int shnum,      // Shape to use.
  Tile_coord pos,     // Where to place it.  If pos.tx < 0,
          //   it's not placed in the world.
  int sched,      // Schedule type.
  int align,      // Alignment.
  bool temporary,
  bool equipment
  )
  {
          // Get 'monsters.dat' info.
  const Monster_info *inf = ShapeID::get_info(shnum).get_monster_info();
  if (!inf)
    inf = Monster_info::get_default();
  Monster_actor *monster = create(shnum);
  monster->set_alignment(align == static_cast<int>(Actor::neutral)
            ? inf->alignment : align);
  // Movement flags
  if ((inf->flags >> Monster_info::fly)&1)
  {
    monster->set_type_flag(Actor::tf_fly);
  }
  if ((inf->flags >> Monster_info::swim)&1)
  {
    monster->set_type_flag(Actor::tf_swim);
  }
  if ((inf->flags >> Monster_info::walk)&1)
  {
    monster->set_type_flag(Actor::tf_walk);
  }
  if ((inf->flags >> Monster_info::ethereal)&1)
  {
    monster->set_type_flag(Actor::tf_ethereal);
  }
  monster->set_property(Actor::strength, inf->strength);
          // Max. health = strength.
  monster->set_property(Actor::health, inf->strength);
  monster->set_property(Actor::dexterity, inf->dexterity);
  monster->set_property(Actor::intelligence, inf->intelligence);
  monster->set_property(Actor::combat, inf->combat);

  // Set temporary
  if (temporary) monster->set_flag (Obj_flags::is_temporary);
  monster->set_invalid();   // Place in world.
  if (pos.tx >= 0)
    monster->move(pos.tx, pos.ty, pos.tz);
  if (equipment) {
          // Get equipment.
    int equip_offset = inf->equip_offset;
    Equip_record *equip = inf->equip;
    if (equip_offset && equip_offset - 1 < inf->equip_cnt)
    {
      Equip_record& rec = equip[equip_offset - 1];
      for (size_t i = 0;
         i < sizeof(equip->elements)/sizeof(
              equip->elements[0]);
         i++)
      {   // Give equipment.
        Equip_element& elem = rec.elements[i];
        if (!elem.shapenum || 1 + rand()%100 > 
            elem.probability)
          continue;// You lose.
        int frnum = (elem.shapenum == 377) ? 
          Find_monster_food(shnum) : 0;
        monster->create_quantity(elem.quantity, 
            elem.shapenum, c_any_qual, 
              frnum, temporary);
      }
    }
  }

  if (sched < 0)      // Set sched. AFTER equipping.
    sched = static_cast<int>(Schedule::loiter);
  monster->set_schedule_type(sched);
  return (monster);
  }

/*
 *  Delete all monsters.  (Should only be called after deleting chunks.)
 */

void Monster_actor::delete_all
  (
  )
  {
  while (in_world)
    delete in_world;
  }

/*
 *  Render.
 */

void Monster_actor::paint
  (
  )
  {
  // Animate first
  if (animator)     // Be sure animation is on.
    animator->want_animation();
  Npc_actor::paint();   // Draw on screen.
  }

/*
 *  Step onto an adjacent tile.
 *
 *  Output: 0 if blocked.
 *    Dormant is set if off screen.
 */

int Monster_actor::step
  (
  Tile_coord t,     // Tile to step onto.
  int frame     // New frame #.
  )
  {
  // If move not allowed do I remove or change destination?
  // I'll do nothing for now
  if (!gwin->emulate_is_move_allowed(t.tx, t.ty))
    return (0);
  if (get_flag(Obj_flags::paralyzed))
    return 0;
          // Store old chunk.
  int old_cx = get_cx(), old_cy = get_cy();
          // Get chunk.
  int cx = t.tx/c_tiles_per_chunk, cy = t.ty/c_tiles_per_chunk;
          // Get ->new chunk.
  Map_chunk *nlist = gmap->get_chunk(cx, cy);
  nlist->setup_cache();   // Setup cache if necessary.
          // Blocked?
  if (is_blocked(t))
    {
    if (schedule)   // Tell scheduler.
      schedule->set_blocked(t);
    stop();
    if (!gwin->add_dirty(this))
      dormant = true; // Off-screen.
    return (0);   // Done.
    }
          // Check for scrolling.
  gwin->scroll_if_needed(this, t);
  add_dirty();      // Set to repaint old area.
          // Get old chunk.
  Map_chunk *olist = gmap->get_chunk(old_cx, old_cy);
          // Move it.
          // Get rel. tile coords.
  int tx = t.tx%c_tiles_per_chunk, ty = t.ty%c_tiles_per_chunk;
  movef(olist, nlist, tx, ty, frame, t.tz);
  if (!add_dirty(1) &&
          // And > a screenful away?
      distance(gwin->get_camera_actor()) > 1 + 320/c_tilesize)
    {     // No longer on screen.
    stop();
    dormant = true;
    return (0);
    }
  return (1);     // Add back to queue for next time.
  }

/*
 *  Remove an object from its container, or from the world.
 *  The object is deleted.
 */

void Monster_actor::remove_this
  (
  int nodel     // 1 to not delete.
  )
  {
  link_out();     // Remove from list.
  Npc_actor::remove_this(nodel);
  }

/*
 *  Move (teleport) to a new spot.
 */

void Monster_actor::move
  (
  int newtx, 
  int newty, 
  int newlift
  )
  {
  Npc_actor::move(newtx, newty, newlift);
  link_in();      // Insure it's in global list.
  }

/*
 *  Add an object.
 *
 *  Output: 1, meaning object is completely contained in this,
 *    0 if not enough space.
 */

bool Monster_actor::add
  (
  Game_object *obj,
  bool dont_check,    // 1 to skip volume check.
  bool combine      // True to try to combine obj.  MAY
          //   cause obj to be deleted.
  )
  {
          // Try to add to 'readied' spot.
  if (Npc_actor::add(obj, true, combine))
    return (true);    // Successful.
          // Just add anything.
  return Container_game_object::add(obj, true, combine);
  }

/*
 *  Get total value of armor being worn.
 */

int Monster_actor::get_armor_points
  (
  )
  {
  Monster_info *inf = get_info().get_monster_info();
          // Kind of guessing here.
  return Actor::get_armor_points() + (inf ? inf->armor : 0);
  }

/*
 *  Get weapon value.
 */

Weapon_info *Monster_actor::get_weapon
  (
  int& points,
  int& shape
  )
  {
  Monster_info *inf = get_info().get_monster_info();
          // Kind of guessing here.
  Weapon_info *winf = Actor::get_weapon(points, shape);
  if (!winf)      // No readied weapon?
    {     // Look up monster itself.
    shape = 0;
    winf = get_info().get_weapon_info();
    if (winf)
      {
      shape = get_shapenum();
      points = winf->get_damage();
      }
    else if (inf)   // Builtin (claws?):
      points = inf->weapon;
    }
  return winf;
  }

/*
 *  We're dead.  We're removed from the world, but not deleted.
 */

void Monster_actor::die
  (
  Actor *attacker
  )
  {
  Actor::die(attacker);
          // Got to delete this somewhere, but
          //   doing it here crashes.
  }

/*
 *  Get the tiles where slimes adjacent to one in a given position should
 *  be found.
 */

static void Get_slime_neighbors
  (
  Tile_coord pos,     // Position to look around.
  Tile_coord *neighbors   // N,E,S,W tiles returned.
  )
  {
          // Offsets to neighbors 2 tiles away.
  static int offsets[8] = {0,-2, 2,0, 0,2, -2,0};
  for (int dir = 0; dir < 4; dir++)
    neighbors[dir] = pos +Tile_coord(offsets[2*dir],
                offsets[2*dir + 1], 0);
  }

/*
 *  Find whether a slime is a neighbor of a given spot.
 *
 *  Output: Direction (0-3 for N,E,S,W), or -1 if not found.
 */

int Find_neighbor
  (
  Game_object *slime,
  Tile_coord *neighbors   // Neighboring spots to check.
  )
  {
  Tile_coord pos = slime->get_tile();
  for (int dir = 0; dir < 4; dir++)
    if (pos == neighbors[dir])
      return dir;
  return -1;      // Not found.
  }

/*
 *  Update the frame of a slime and its neighbors after it has been moved.
 *  The assumption is that slimes are 2x2 tiles, and that framenum/2 is
 *  based on whether there are adjoining slimes to the N, W, S, or E, with
 *  bit 0 being random.
 */

void Slime_actor::update_frames
  (
  Tile_coord src,     // May be invalid (tx = -1).
  Tile_coord dest     // May be invalid.  If src & dest are
          //   both valid, we assume they're at
          //   most 2 tiles apart.
  )
  {
  Tile_coord neighbors[4];  // Gets surrounding spots for slimes.
  int dir;      // Get direction of neighbor.
  Game_object_vector nearby;    // Get nearby slimes.
  if (src.tx != -1)
    if (dest.tx != -1)  // Assume within 2 tiles.
      Game_object::find_nearby(nearby, dest, 529, 4, 8);
    else
      Game_object::find_nearby(nearby, src, 529, 2, 8);
  else        // Assume they're both not invalid.
    Game_object::find_nearby(nearby, dest, 529, 2, 8);
  if (src.tx != -1)   // Update neighbors we moved from.
    {
    Get_slime_neighbors(src, neighbors);
    for (Game_object_vector::const_iterator it = nearby.begin();
            it != nearby.end(); ++it)
      {
      Game_object *slime = *it;
      if (slime != this && 
          (dir = Find_neighbor(slime, neighbors)) >= 0)
        {
        int ndir = (dir+2)%4;
          // Turn off bit (1<<ndir)*2, and set
          //   bit 0 randomly.
        slime->change_frame((slime->get_framenum()&
          ~(((1<<ndir)*2)|1)) |(rand()%2));
        }
      }
    }
  if (dest.tx != -1)    // Update neighbors we moved to.
    {
    int frnum = 0;    // Figure our new frame too.
    Get_slime_neighbors(dest, neighbors);
    for (Game_object_vector::const_iterator it = nearby.begin();
            it != nearby.end(); ++it)
      {
      Game_object *slime = *it;
      if (slime != this && 
          (dir = Find_neighbor(slime, neighbors)) >= 0)
        { // In a neighboring spot?
        frnum |= (1<<dir)*2;
        int ndir = (dir+2)%4;
          // Turn on bit (1<<ndir)*2, and set
          //   bit 0 randomly.
        slime->change_frame((slime->get_framenum()&~1)|
            ((1<<ndir)*2)|(rand()%2));
        }
      }
    change_frame(frnum|(rand()%2));
    }
  }

/*
 *  Step onto an adjacent tile.
 *
 *  Output: 0 if blocked.
 *    Dormant is set if off screen.
 */

int Slime_actor::step
  (
  Tile_coord t,     // Tile to step onto.
  int /* frame */     // New frame # (ignored).
  )
  {
          // Save old pos.
  Tile_coord oldpos = get_tile();
  int ret = Monster_actor::step(t, -1);
          // Update surrounding frames (& this).
  Tile_coord newpos = get_tile();
  update_frames(oldpos, newpos);
  Game_object_vector blood; // Place blood in old spot.
  if (newpos != oldpos && rand()%9 == 0 &&
      !find_nearby(blood, oldpos, 912, 1, 0))
    {
          // Frames 4-11 are green.
    Game_object *b = gmap->create_ireg_object(912, 4 + rand()%8);
    b->set_flag(Obj_flags::is_temporary);
    b->move(oldpos);
    }
  return ret;
  }

/*
 *  Remove an object from its container, or from the world.
 *  The object is deleted.
 */

void Slime_actor::remove_this
  (
  int nodel     // 1 to not delete.
  )
  {
  Tile_coord pos = get_tile();
  Monster_actor::remove_this(nodel);
          // Update surrounding slimes.
  update_frames(pos, Tile_coord(-1, -1, -1));
  }

/*
 *  Move (teleport) to a new spot.  I assume slimes only use this when
 *  being added to the world.
 */

void Slime_actor::move
  (
  int newtx, 
  int newty, 
  int newlift
  )
  {
          // Save old pos.
  Tile_coord pos = get_tile();
  if (get_cx() == 255)    // Invalid?
    pos = Tile_coord(-1, -1, -1);
  Monster_actor::move(newtx, newty, newlift);
          // Update surrounding frames (& this).
  update_frames(pos, get_tile());
  }

/*
 *  Step onto an adjacent tile.
 *
 *  Output: 0 if blocked.
 *    Dormant is set if off screen.
 */

int Quaking_actor::step
  (
  Tile_coord t,     // Tile to step onto.
  int frame     // New frame #.
  )
  {
  int ret = Monster_actor::step(t, frame);
  if (ret)
    {
    steps = (steps + 1)%qsteps;
    if (!steps)   // Time to roll?
      gwin->get_tqueue()->add(Game::get_ticks() + 10,
          new Earthquake(2), 0L);
    }
  return ret;
  }

---