linedefs.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 "linedefs.hpp"
#include "wadentry.hpp"

using namespace Doomwad;

const std::string Linedefs::NAME = "LINEDEFS";
const std::string HexenLinedefs::NAME = "LINEDEFS";

// Linedef blank Sidedef reference
const uint16 Linedef::NOSIDEDEF = 0xFFFF;

const size_t Linedef::LENGTH      = 0x0000000E;
const size_t HexenLinedef::LENGTH = 0x00000010;

// Linedef flags
const uint16 Linedef::IMPASSIBLE    = 0x0001;
const uint16 Linedef::BLOCK_MONSTER = 0x0002;
const uint16 Linedef::TWOSIDED      = 0x0004;
const uint16 Linedef::UNPEG_UPPER   = 0x0008;
const uint16 Linedef::UNPEG_LOWER   = 0x0010;
const uint16 Linedef::SECRET        = 0x0020;
const uint16 Linedef::BLOCK_SOUND   = 0x0040;
const uint16 Linedef::INVISIBLE     = 0x0080;
const uint16 Linedef::ALWAYS_MAPPED = 0x0100;
const uint16 Linedef::ACTION_PASSTHROUGH   = 0x0200;

const uint16 HexenLinedef::ACTIVE_MULTIPLE               = 0x0200;
const uint16 HexenLinedef::ACTIVE_PLAYER                 = 0x0400;
const uint16 HexenLinedef::ACTIVE_MONSTER                = 0x0800;
const uint16 HexenLinedef::ACTIVE_PROJECTILE_HIT         = 0x0C00;
const uint16 HexenLinedef::ACTIVE_PLAYER_BUMP            = 0x1000;
const uint16 HexenLinedef::ACTIVE_PROJECTILE_PASSTHROUGH = 0x1400;
const uint16 HexenLinedef::ACTIVE_PLAYER_PASSTHROUGH     = 0x1000;
const uint16 HexenLinedef::ACTIVE_PLAYER_MONSTERS        = 0x2000;
const uint16 HexenLinedef::ZDOOM_UNKNOWN                 = 0x4000;
const uint16 HexenLinedef::BLOCKS_EVERYTHING             = 0x8000;

Linedef::Linedef (uint16 _start, uint16 _end, uint16 _flags, uint16 _tag, uint16 _sidedef1, uint16 _sidedef2, uint16 _type) throw () : start (_start), end (_end), flags (_flags), tag (_tag), sidedef1 (_sidedef1), sidedef2 (_sidedef2), type (_type)
{
}

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

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

bool Linedef::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setUInt16 (this->start, i);
    lump.setUInt16 (this->end, i + 2);
    lump.setUInt16 (this->flags, i + 4);
    lump.setUInt16 (this->tag, i + 6);
    lump.setUInt16 (this->sidedef1, i + 8);
    lump.setUInt16 (this->sidedef2, i + 10);
    lump.setUInt16 (this->type, i + 12);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Linedef::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->start    = lump.getUInt16 (i);
    this->end      = lump.getUInt16 (i + 2);
    this->flags    = lump.getUInt16 (i + 4);
    this->tag      = lump.getUInt16 (i + 6);
    this->sidedef1 = lump.getUInt16 (i + 8);
    this->sidedef2 = lump.getUInt16 (i + 10);
    this->type     = lump.getUInt16 (i + 12);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Linedef::toString (void) const throw ()
{
  std::ostringstream str;

  str << '(' << start << ',' << end << ',' << flags << ',' << tag << ','
      << sidedef1 << ',' << sidedef2 << ',' << type << ')';

  return str.str ();
}

HexenLinedef::HexenLinedef (uint16 _start, uint16 _end, uint16 _flags, uint16 _sidedef1, uint16 _sidedef2, uint8 _type, int8 _arg1, int8 _arg2, int8 _arg3, int8 _arg4, int8 _arg5) throw () : start (_start), end (_end), flags (_flags), sidedef1 (_sidedef1), sidedef2 (_sidedef2), type (_type), arg1 (_arg1), arg2 (_arg2), arg3 (_arg3), arg4 (_arg4), arg5 (_arg5)
{
}

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

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

bool HexenLinedef::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setUInt16 (this->start, i);
    lump.setUInt16 (this->end, i + 2);
    lump.setUInt16 (this->flags, i + 4);
    lump.setUInt16 (this->sidedef1, i + 6);
    lump.setUInt16 (this->sidedef2, i + 8);
    lump.setUInt8 (this->type, i + 10);
    lump.setInt8 (this->arg1, i + 11);
    lump.setInt8 (this->arg2, i + 12);
    lump.setInt8 (this->arg3, i + 13);
    lump.setInt8 (this->arg4, i + 14);
    lump.setInt8 (this->arg5, i + 15);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool HexenLinedef::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->start    = lump.getUInt16 (i);
    this->end      = lump.getUInt16 (i + 2);
    this->flags    = lump.getUInt16 (i + 4);
    this->sidedef1 = lump.getUInt16 (i + 6);
    this->sidedef2 = lump.getUInt16 (i + 8);
    this->type     = lump.getUInt8 (i + 10);
    this->arg1     = lump.getInt8 (i + 11);
    this->arg2     = lump.getInt8 (i + 12);
    this->arg3     = lump.getInt8 (i + 13);
    this->arg4     = lump.getInt8 (i + 14);
    this->arg5     = lump.getInt8 (i + 15);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string HexenLinedef::toString (void) const throw ()
{
  std::ostringstream str;

  str << '(' << start << ',' << end << ',' << flags << ','
      << sidedef1 << ',' << sidedef2 << ','
      << (static_cast<int> (type)) << ',' << (static_cast<int> (arg1)) << ',' << (static_cast<int> (arg2)) << ','
      << (static_cast<int> (arg3)) << ',' << (static_cast<int> (arg4)) << ',' << (static_cast<int> (arg5)) << ')';

  return str.str ();
}

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

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

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

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

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

  Linedef l;

  this->clear ();

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

  return true;
}

Lump Linedefs::toLump (void) const throw ()
{
  Lump l (NAME);

  l.setSize (this->size () * Linedef::LENGTH);
  size_t i = 0;
  const_iterator iter = this->begin ();
  for (; iter != this->end (); i += 14, ++iter)
  {
    iter->write (l, i);
  }

  return l;
}

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

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

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

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

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

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

  HexenLinedef l;

  this->clear ();

  for (size_t i = 0; i < q; i += 10)
  {
    l.read (lump, i);
    this->push_back (l);
  }

  return true;
}

Lump HexenLinedefs::toLump (void) const throw ()
{
  Lump l (NAME);

  l.setSize (this->size () * 16);
  size_t i = 0;
  const_iterator iter = this->begin ();
  for (; iter != this->end (); i += 14, ++iter)
  {
    iter->write (l, i);
  }

  return l;
}

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

---