animated.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>
#include <vector>

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

using namespace Doomwad;

const Doomwad::byte Animation::FLAT = 0x00;
const Doomwad::byte Animation::TEXTURE = 0x01;
const Doomwad::byte Animation::TERMINATE = 0xFF;
const Doomwad::byte Animation::DEFAULT_TYPE = Animation::TEXTURE;
const uint32 Animation::DEFAULT_SPEED = 0x00000008;
const size_t Animation::LENGTH = 0x00000017;

const std::string Animated::NAME = "ANIMATED";

Animation::Animation (void) throw () : type (TEXTURE), speed (DEFAULT_SPEED)
{
  return;
}

Animation::Animation (const std::string &_first, const std::string &_last, byte _type, uint32 _speed) : type (_type), last (_last), first (_first), speed (_speed)
{
  return;
}

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

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

bool Animation::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setByte   (this->type,  i);
    lump.setString (this->last,  i + 1);
    lump.setString (this->first, i + 10);
    lump.setUInt32 (speed,       i + 19);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Animation::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->type  = lump.getByte   (i);
    this->last  = lump.getString (i + 1);
    this->first = lump.getString (i + 10);
    this->speed = lump.getUInt32 (i + 19);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Animation::toString (void) const throw ()
{
  std::ostringstream str;
  str << (type == 1 ? "Texture:" : "Flat:") << last << ":" << first << ":" << speed;
  return str.str ();
}

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

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

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

bool Animated::setFromLump (const Lump &lump) throw ()
{
  size_t i = 0;
  Animation temp;

  // Lump size must be a multiple of 23 bytes.
  if (lump.size () % Animation::LENGTH != 0) return false;

  // Loop until the data runs out or we find an end marker.
  this->clear ();
  for (i = 0; (i < lump.size ()) && (lump[i] != Animation::TERMINATE); i += Animation::LENGTH)
  {
    temp.read (lump, i);
    this->insert (this->end (), temp);
  }

  return true;
}

Lump Animated::toLump (void) const throw ()
{
  Lump l (NAME, (this->size () + 1) * Animation::LENGTH);
  Animation temp ("", "", Animation::TERMINATE, 0);
  Lump::size_type p = 0;

  // Loop over this object, creating new records and adding them to the lump.
  for (const_iterator i = this->begin (); i != this->end (); ++i, p += Animation::LENGTH)
    i->write (l, p);

  // Add the dummy end record.
  temp.write (l, p);

  return l;
}

std::string Animated::toString (void) const throw ()
{
  std::ostringstream str;
  bool first = true;
  for (const_iterator i = this->begin (); i != this->end (); ++i, first = false)
  {
    if (!first) str << '\n';
    str << i->toString ();
  }
  return str.str ();
}

---