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

using namespace Doomwad;

const size_t      Sidedef::LENGTH     = 0x0000001E;
const std::string Sidedef::NO_TEXTURE = "-";
const uint16      Sidedef::NO_SECTOR  = 0xFFFF;

const std::string Sidedefs::NAME = "SIDEDEFS";

Sidedef::Sidedef (int16 _x, int16 _y, const std::string &_upper, const std::string &_lower, const std::string &_middle, uint16 _sector) throw () : x_offset (_x), y_offset (_y), upper (_upper), lower (_lower), middle (_middle), sector (_sector)
{
}

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

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

bool Sidedef::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setInt16 (this->x_offset, i);
    lump.setInt16 (this->y_offset, i + 2);
    lump.setDString (this->upper, 4);
    lump.setDString (this->lower, 12);
    lump.setDString (this->middle, 20);
    lump.setUInt16 (this->sector, i + 28);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Sidedef::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->x_offset = lump.getInt16 (i);
    this->y_offset = lump.getInt16 (i + 2);
    this->upper    = lump.getDString (i + 4);
    this->lower    = lump.getDString (i + 12);
    this->middle   = lump.getDString (i + 20);
    this->sector   = lump.getUInt16 (i + 28);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Sidedef::toString (void) const throw ()
{
  std::ostringstream str;
  char buffer[9];
  buffer[8] = 0;

  str << '(' << x_offset << ',' << y_offset << ','
      << upper << ',' << lower << ','
      << middle << ',' << sector << ')';

  return str.str ();
}

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

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

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

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

  Sidedef s;
  this->clear ();

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

  return true;
}

Lump Sidedefs::toLump (void) const throw ()
{
  Lump lump (NAME, this->size () * Sidedef::LENGTH);
  const_iterator iter = this->begin ();
  for (size_t i = 0; iter != this->end (); i += Sidedef::LENGTH, ++iter)
  {
    iter->write (lump, i);
  }
  return lump;
}

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

---