map_objects.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __MAP_OBJECTS_HEADER__
#define __MAP_OBJECTS_HEADER__

#include "utils.h"
#include "defs.h"

#include "video.h"

namespace hoa_map {

namespace private_map {

const uint8 PHYSICAL_TYPE = 0;
const uint8 VIRTUAL_TYPE = 1;
const uint8 SPRITE_TYPE = 2;
const uint8 ENEMY_TYPE = 3;

class MapObject {
public:
  int16 object_id;

  uint32 context;

  uint16 x_position, y_position;
  float x_offset, y_offset;

  float img_half_width, img_height;

  float coll_half_width, coll_height;

  bool updatable;

  bool visible;

  bool no_collision;

  bool draw_on_second_pass;

  std::string filename;

  // ---------- Methods

  MapObject();

  virtual ~MapObject()
    {}

  virtual void Update() = 0;

  virtual void Draw() = 0;

  bool DrawHelper();

  float ComputeXLocation() const
    { return (static_cast<float>(x_position) + x_offset); }

  float ComputeYLocation() const
    { return (static_cast<float>(y_position) + y_offset); }

  void SetObjectID(int16 id = 0)
    { object_id = id; }

  void SetContext(uint32 ctxt)
    { context = ctxt; }

  void SetXPosition(uint16 x, float offset)
    { x_position = x; x_offset = offset; }

  void SetYPosition(uint16 y, float offset)
    { y_position = y; y_offset = offset; }

  void SetImgHalfWidth(float width)
    { img_half_width = width; }

  void SetImgHeight(float height)
    { img_height = height; }

  void SetCollHalfWidth(float collision)
    { coll_half_width = collision; }

  void SetCollHeight(float collision)
    { coll_height = collision; }

  void SetUpdatable(bool update)
    { updatable = update; }

  void SetVisible(bool vis)
    { visible = vis; }

  void SetNoCollision(bool coll)
    { no_collision = coll; }

  void SetDrawOnSecondPass(bool pass)
    { draw_on_second_pass = pass; }

  int16 GetObjectID() const
    { return object_id; }

  uint32 GetContext() const
    { return context; }

  void GetXPosition(uint16 &x, float &offset) const
    { x = x_position; offset = x_offset; }

  void GetYPosition(uint16 &y, float &offset) const
    { y = y_position; offset = y_offset; }

  float GetImgHalfWidth() const
    { return img_half_width; }

  float GetImgHeight() const
    { return img_height; }

  float GetCollHalfWidth() const
    { return coll_half_width; }

  float GetCollHeight() const
    { return coll_height; }

  bool IsUpdatable() const
    { return updatable; }

  bool IsVisible() const
    { return visible; }

  bool IsNoCollision() const
    { return no_collision; }

  bool IsDrawOnSecondPass() const
    { return draw_on_second_pass; }

  uint8 GetType() const
    { return _object_type; }

protected:
  uint8 _object_type;

}; // class MapObject


struct MapObject_Ptr_Less {
  const bool operator()(const MapObject * a, const MapObject * b) {
    return (a->y_position + a->y_offset) < (b->y_position + b->y_offset);
  }
};


class PhysicalObject : public MapObject {
public:
  uint8 current_animation;

  std::vector<hoa_video::AnimatedImage> animations;

  PhysicalObject();

  ~PhysicalObject();

  void Update();

  void Draw();

  void AddAnimation(hoa_video::AnimatedImage new_img)
    { animations.push_back(new_img); }

  void SetCurrentAnimation(uint8 current)
    { animations[current_animation].SetTimeProgress(0); current_animation = current; }

  void SetAnimationProgress(uint32 progress)
    { animations[current_animation].SetTimeProgress(progress); }

  uint8 GetCurrentAnimation() const
    { return current_animation; }
}; // class PhysicalObject : public MapObject

} // namespace private_map

} // namespace hoa_map

#endif

---