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

using namespace Doomwad;

const size_t Sector::LENGTH                = 0x0000001A;
const std::string Sectors::NAME            = "SECTORS";

// Sector blank flat
const std::string Sector::NOFLAT           = "-";

const uint16 Sector::NORMAL                = 0x0000;

const uint16 Sector::LIGHT_RANDOM          = 0x0001;
const uint16 Sector::LIGHT_BLINK_HALF      = 0x0002;
const uint16 Sector::LIGHT_BLINK_SEC       = 0x0003;
const uint16 Sector::LIGHT_BLINK_DAMAGE    = 0x0004;
const uint16 Sector::LIGHT_OSCILLATE       = 0x0008;
const uint16 Sector::LIGHT_BLINK_HALF_SYNC = 0x000C;
const uint16 Sector::LIGHT_BLINK_SEC_SYNC  = 0x000D;
const uint16 Sector::LIGHT_FLICKER         = 0x0011;

const uint16 Sector::DAMAGE_5              = 0x0020;
const uint16 Sector::DAMAGE_10             = 0x0040;
const uint16 Sector::DAMAGE_20             = 0x0060;

const uint16 Sector::SECRET                = 0x0080;
const uint16 Sector::FRICTION              = 0x0100;
const uint16 Sector::WIND                  = 0x0200;
const uint16 Sector::NO_SOUND              = 0x0400;
const uint16 Sector::NO_MOTION_SOUND       = 0x0800;

const uint16 Sector::INVALID               = 0xFFFF;

const uint16 Sector::GENERALIZED_MASK      = 0x01FF;

Sector::Sector (int16 _z_f, int16 _z_c, const std::string &_flat_f, const std::string &_flat_c, uint16 _light, uint16 _type, uint16 _tag) throw () : z_floor (_z_f), z_ceil (_z_c), flat_floor (_flat_f), flat_ceil (_flat_c), light (_light), type (_type), tag (_tag)
{
}

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

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

  str << '(' << z_floor << ',' << z_ceil << ','
      << flat_floor << ',' << flat_ceil << ','
      << light << ',' << type << ',' << tag << ')';

  return str.str ();
}

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

bool Sector::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setInt16   (this->z_floor,    i);
    lump.setInt16   (this->z_ceil,     i + 2);
    lump.setDString (this->flat_floor, i + 4);
    lump.setDString (this->flat_ceil,  i + 12);
    lump.setUInt16  (this->light,      i + 20);
    lump.setUInt16  (this->type,       i + 22);
    lump.setUInt16  (this->tag,        i + 24);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Sector::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->z_floor    = lump.getInt16  (i);
    this->z_ceil     = lump.getInt16  (i + 2);
    this->flat_floor = lump.getDString (i + 4);
    this->flat_ceil  = lump.getDString (i + 12);
    this->light      = lump.getUInt16 (i + 20);
    this->type       = lump.getUInt16 (i + 22);
    this->tag        = lump.getUInt16 (i + 24);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

uint16 Sector::makeGeneralized (uint16 flags) throw ()
{
  uint16 low = flags & GENERALIZED_MASK;

  if (flags > NO_MOTION_SOUND || low > LIGHT_FLICKER || (low > LIGHT_BLINK_DAMAGE && low < LIGHT_OSCILLATE) || (low > LIGHT_OSCILLATE && low < LIGHT_BLINK_HALF_SYNC) || (low > LIGHT_BLINK_SEC_SYNC && low < LIGHT_FLICKER))
    flags = INVALID;

  return flags;
}

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

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

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

bool Sectors::setFromLump (const Lump &lump) throw ()
{
  size_t q = lump.size ();
  if (q % Sector::LENGTH != 0) return false;
  Sector s;
  this->clear ();
  for (size_t i = 0; i < q; i += Sector::LENGTH)
  {
    s.read (lump, i);
    this->push_back (s);
  }
  return true;
}

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

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

---