some commenting on the map classes

[l2e.git] / src / map / Entity.h

diff --git a/src/map/Entity.h b/src/map/Entity.h
index cc30c9518288e3886a6711a937a9d4b22133cddf..8d5c6a5bbb2b8b1d825211e4328e0e9356ad9f6e 100644 (file)
--- a/src/map/Entity.h
+++ b/src/map/Entity.h
@@ -19,6 +19,8 @@
 
 namespace map {
 
+/// An entity that can be placed on a map, moved around, animated, and possibly
+/// interact with the player.
 class Entity {
 
 public:
@@ -39,53 +41,96 @@ public:
        };
 
 public:
+       /// Pixel resolved position of the entity's top left corner on the map.
        geometry::Vector<float> &Position() { return position; }
        const geometry::Vector<float> &Position() const { return position; }
 
+       /// Velocity of the entity in pixels per second.
        geometry::Vector<float> &Velocity() { return velocity; }
        const geometry::Vector<float> &Velocity() const { return velocity; }
 
+       /// Offset of the entity's sprite's to left corner relative to Position().
        geometry::Vector<int> &SpriteOffset() { return spriteOffset; }
        const geometry::Vector<int> &SpriteOffset() const { return spriteOffset; }
 
+       /// Reset the entity to the stored tile coordinates (usually set when
+       /// loading game data).
        void ResetPosition(const geometry::Vector<int> &tileSize) { position = tilePosition * tileSize; }
 
+       /// Set the animation to use for animated entities.
+       /// For orientable entities, the animation  should have north, south, east,
+       /// and west sprites at offsets (0,0), (1,0), (2,0), and (3,0) respectively.
+       /// If the entity can carry, row offset 2 is used.
+       /// If the entity can push, row offset 4 is used.
        void SetAnimation(const graphics::Animation *a);
+       /// Start the animation on a global timer.
        void StartAnimation(app::Application &ctrl);
+       /// Start the animation on a state timer.
        void StartAnimation(app::State &ctrl);
+       /// Stop the animation.
        void StopAnimation();
+       /// Check if an animation is running.
        bool AnimationRunning() const { return runner.Running(); }
 
+       /// Set the sprite used for the non-animated state.
+       /// For orientable entities, the sprite should have north, south, east, and
+       /// west sprites at offsets (0,0), (1,0), (2,0), and (3,0) respectively.
        void SetSprite(const graphics::Sprite *s) { sprite = s; }
 
+       /// Change the entity's orientation to given one.
+       /// If the entity is moving, velocity is changed accordingly.
        void SetOrientation(Orientation);
        Orientation GetOrientation() const { return orientation; }
+       /// Set the entity's speed in pixels per second.
+       /// This speed is then combined with the orientation to form a velocity.
        void SetSpeed(float);
 
+       /// Change to a natural, relaxed animation state (row offset 0).
        void SetHandsFree();
+       /// Change animation to represent a carrying thingamabob (row offset 2).
        void SetCarrying();
+       /// Set a pushy animation state (row offset 4).
        void SetPushing();
 
+       /// Set some basic boolean properties.
+       /// Parameter should be a combination from the Flags enum.
        void SetFlags(int f) { flags = f; }
+       /// Check if the entity is blocking other entities from occupying its tile.
        bool Blocking() const { return !(flags & FLAG_NONBLOCKING); }
+       /// Check if a battle should be launched when stepping onto a neighboring
+       /// tile.
        bool Hostile() const { return partyLayout && numMonsters > 0; }
+       /// Check if this entity can be pushed around.
        bool Pushable() const { return flags & FLAG_PUSHABLE; }
+       /// Check if the entity's orientation has any effect on the column rendered
+       /// from the animation or sprite.
        bool CanTurn() const { return !(flags & FLAG_FIXED_ORIENTATION); }
 
+       /// Set a layout in battle for the party described by SetMonsters().
        void SetPartyLayout(battle::PartyLayout *l) { partyLayout = l; }
+       /// Get the layout in battle for the party described by
+       /// Monsters{Begin,End}().
        battle::PartyLayout *PartyLayout() { return partyLayout; }
 
+       /// Add monsters. This will cause the entity to be Hostile() and result in a
+       /// battle scene with given monsters when touched.
        void SetMonsters(battle::Monster *m, int num) { monsters = m; numMonsters = num; }
        battle::Monster *MonstersBegin() { return monsters; }
        battle::Monster *MonstersEnd() { return monsters + numMonsters; }
 
+       /// Get an entity that should follow in this one's steps or 0 if none.
        Entity *Follower() { return follower; }
        const Entity *Follower() const { return follower; }
+       /// Add an entity that follows this one.
+       /// If this already has a follower, it is added to that one instead.
        void AddFollower(Entity *);
+       /// Remove given entity from this entity or its follower.
        void RemoveFollower(Entity *);
 
+       /// Check if position locks into grid defined by given tileSize.
        bool TileLock(const geometry::Vector<int> &tileSize) const;
 
+       /// Integrate this entity's physical properties over given time interval.
        void Update(float deltaT);
 
        void Render(SDL_Surface *, const geometry::Vector<int> &offset) const;