things.cpp

Go to the documentation of this file.

// libdoomwad: manipulates Doom wad files.
// Copyright (C) 2005  John Gaughan
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// This library is distributed with the full text of the LGPL. Please see
// the accompanying file named COPYING.
// 
// You may contact the author at john@johngaughan.net

// C++ required.
#if !defined __cplusplus
#error C++ compiler required
#endif

// C++ headers
#include <exception>
#include <sstream>
#include <stdexcept>
#include <string>

// Doom headers
#include "global.hpp"
#include "lump.hpp"
#include "things.hpp"
#include "wadentry.hpp"

using namespace Doomwad;

const size_t Thing::LENGTH      = 0x0000000A;
const size_t HexenThing::LENGTH = 0x00000014;

const std::string Things::NAME      = "THINGS";
const std::string HexenThings::NAME = "THINGS";

// Thing directions
const uint16 Thing::EAST      = 0x0000;
const uint16 Thing::NORTHEAST = 0x002D;
const uint16 Thing::NORTH     = 0x005A;
const uint16 Thing::NORTHWEST = 0x0087;
const uint16 Thing::WEST      = 0x00B4;
const uint16 Thing::SOUTHWEST = 0x00E1;
const uint16 Thing::SOUTH     = 0x010E;
const uint16 Thing::SOUTHEAST = 0x013B;

// Thing flags
const uint16 Thing::SKILL1       = 0x0001;
const uint16 Thing::SKILL2       = 0x0002;
const uint16 Thing::SKILL3       = 0x0004;
const uint16 Thing::DEAF         = 0x0008;
const uint16 Thing::MULTI        = 0x0010;
const uint16 Thing::BOOM_NODM    = 0x0020;
const uint16 Thing::BOOM_NOCO    = 0x0040;
const uint16 Thing::MBF_FRIENDLY = 0x0080;

const uint16 HexenThing::IN_SP       = 0x0100;
const uint16 HexenThing::IN_COOP     = 0x0200;
const uint16 HexenThing::IN_DM       = 0x0400;
const uint16 HexenThing::TRANSLUCENT = 0x0800;
const uint16 HexenThing::INVISIBLE   = 0x1000;
const uint16 HexenThing::FRIENDLY    = 0x2000;
const uint16 HexenThing::STANDSTILL  = 0x4000;

Thing::Thing (int16 _x, int16 _y, uint16 _angle, uint16 _type, uint16 _flags) throw () : x (_x), y (_y), angle (_angle), type (_type), flags (_flags)
{
}

Thing::~Thing (void) throw ()
{
}

size_t Thing::getLength (void) const throw ()
{
  return LENGTH;
}

bool Thing::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setInt16  (this->x,     i);
    lump.setInt16  (this->y,     i + 2);
    lump.setUInt16 (this->angle, i + 4);
    lump.setUInt16 (this->type,  i + 6);
    lump.setUInt16 (this->flags, i + 8);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Thing::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->x     = lump.getInt16  (i);
    this->y     = lump.getInt16  (i + 2);
    this->angle = lump.getUInt16 (i + 4);
    this->type  = lump.getUInt16 (i + 6);
    this->flags = lump.getUInt16 (i + 8);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Thing::toString (void) const throw ()
{
  std::ostringstream str;
  str << '(' << x << ',' << y << ',' << angle << ',' << type << ',' << flags << ')';
  return str.str ();
}

HexenThing::HexenThing (uint16 _id, int16 _x, int16 _y, int16 _height, uint16 _angle, uint16 _type, uint16 _flags, byte _special, byte _arg1, byte _arg2, byte _arg3, byte _arg4, byte _arg5) throw () : id (_id), x (_x), y (_y), height (_height), angle (_angle), type (_type), flags (_flags), special (_special), arg1 (_arg1), arg2 (_arg2), arg3 (_arg3), arg4 (_arg4), arg5 (_arg5)
{
}

HexenThing::~HexenThing (void) throw ()
{
}

size_t HexenThing::getLength (void) const throw ()
{
  return LENGTH;
}

bool HexenThing::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setUInt16 (this->id,      i);
    lump.setInt16  (this->x,       i + 2);
    lump.setInt16  (this->y,       i + 4);
    lump.setInt16  (this->height,  i + 6);
    lump.setUInt16 (this->angle,   i + 8);
    lump.setUInt16 (this->type,    i + 10);
    lump.setUInt16 (this->flags,   i + 12);
    lump.setByte   (this->special, i + 14);
    lump.setByte   (this->arg1,    i + 15);
    lump.setByte   (this->arg2,    i + 16);
    lump.setByte   (this->arg3,    i + 17);
    lump.setByte   (this->arg4,    i + 18);
    lump.setByte   (this->arg5,    i + 19);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool HexenThing::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->id      = lump.getUInt16 (i);
    this->x       = lump.getInt16  (i + 2);
    this->y       = lump.getInt16  (i + 4);
    this->height  = lump.getInt16  (i + 6);
    this->angle   = lump.getUInt16 (i + 8);
    this->type    = lump.getUInt16 (i + 10);
    this->flags   = lump.getUInt16 (i + 12);
    this->special = lump.getByte   (i + 14);
    this->arg1    = lump.getByte   (i + 15);
    this->arg2    = lump.getByte   (i + 16);
    this->arg3    = lump.getByte   (i + 17);
    this->arg4    = lump.getByte   (i + 18);
    this->arg5    = lump.getByte   (i + 19);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string HexenThing::toString (void) const throw ()
{
  std::ostringstream str;
  str << '(' << id << ',' << x << ',' << y << ',' << height << ',' << angle << ','
      << type << ',' << flags << ','
      << (static_cast<int> (special)) << ',' << (static_cast<int> (arg1)) << ',' << (static_cast<int> (arg2)) << ','
      << (static_cast<int> (arg3)) << ',' << (static_cast<int> (arg4)) << ',' << (static_cast<int> (arg5)) << ')';
  return str.str ();
}

Things::Things (void) throw ()
{
  return;
}

Things::Things (const Lump &lump) throw ()
{
  this->setFromLump (lump);
  return;
}

Things::~Things (void) throw ()
{
  return;
}

bool Things::setFromLump (const Lump &lump) throw ()
{

  // Things lumps must be multiples of 10 bytes
  size_t q = lump.size ();
  if (q % Thing::LENGTH != 0) return false;

  Thing t;

  this->clear ();

  for (size_t i = 0; i < q; i += Thing::LENGTH)
  {
    t.read (lump, i);
    this->push_back (t);
  }

  return true;
}

Lump Things::toLump (void) const throw ()
{
  Lump lump (NAME, this->size () * Thing::LENGTH);

  size_t i = 0;
  const_iterator iter = this->begin ();
  for (; iter != this->end (); i += Thing::LENGTH, ++iter)
  {
    iter->write (lump, i);
  }

  return lump;
}

std::string Things::toString (void) const throw ()
{
  std::ostringstream str;
  for (const_iterator iter = this->begin (); iter != this->end (); ++iter)
    str << iter->toString () << '\n';
  return str.str ();
}

HexenThings::HexenThings (void) throw ()
{
  return;
}

HexenThings::HexenThings (const Lump &lump) throw ()
{
  this->setFromLump (lump);
  return;
}

HexenThings::~HexenThings (void) throw ()
{
  return;
}

bool HexenThings::setFromLump (const Lump &lump) throw ()
{
  size_t q = lump.size ();
  if (q % HexenThing::LENGTH != 0) return false;

  HexenThing t;

  this->clear ();

  for (size_t i = 0; i < q; i += HexenThing::LENGTH)
  {
    t.read (lump, i);
    this->push_back (t);
  }

  return true;
}

Lump HexenThings::toLump (void) const throw ()
{
  Lump lump (NAME, this->size () * HexenThing::LENGTH);

  size_t i = 0;
  const_iterator iter = this->begin ();
  for (; iter != this->end (); i += HexenThing::LENGTH, ++iter)
  {
    iter->write (lump, i);
  }

  return lump;
}

std::string HexenThings::toString (void) const throw ()
{
  std::ostringstream str;
  for (const_iterator iter = this->begin (); iter != this->end (); ++iter)
    str << iter->toString () << '\n';
  return str.str ();
}

---