---

Feat.h

/*
 * Feat.h -- class interface for feats
 * Copyright (C) 2002  Eric Lemings <elemings@users.sourceforge.net>
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA
 *
 * RCS: $Id: Feat.h,v 1.10 2003/04/15 16:58:36 elemings Exp $
 */

#ifdef __cplusplus

#  ifndef OGS_CORE_FEAT_H
#    define OGS_CORE_FEAT_H

#    include <ogs/core/Creature.h>
#    include <ogs/core/Experience.h>
#    include <ogs/core/Feature.h>
#    include <ogs/core/Namespace.h>

OGS_BEGIN_CORE_NAMESPACE

class Feat: public Feature {
  public:
    enum Compatibility {
      EXCLUSIVE = 1,

      REPEATABLE = 2,

      CUMULATIVE = 3
    };

    enum Group {
      GENERAL = 1,

      COMBAT = 2,

      MAGIC = 3,

      SPECIAL = 4,
    };

    static unsigned getSlotCount (XP::Level xpLevel);
    static XP::Level getSlotCountLevel (unsigned slotCount);

    Compatibility getCompatibility () const;
    Group getGroup () const;

    virtual ~Feat () { }

  protected:
    Feat (Compatibility compatibility, Group group = GENERAL);

    virtual bool canAttach (const Object& object) const;
    Creature* getCreature ();

    template <class T>
    struct IsInstance {
      bool operator() (FeatPtr featPtr);
    };

    template <class T>
    bool findFeat (const Object& object) const;

  private:
    Compatibility _compatibility;
    Group _group;
};

inline Feat::Feat (Compatibility compatibility, Group group):
  _compatibility (compatibility),
  _group (group) {
  // empty constructor body
}

inline unsigned
Feat::getSlotCount (XP::Level xpLevel) {
  return (xpLevel < 2? xpLevel: xpLevel / 3 + 1);
}

inline Feat::Compatibility
Feat::getCompatibility () const {
  return (this->_compatibility);
}

inline Feat::Group
Feat::getGroup () const {
  return (this->_group);
}

inline Creature*
Feat::getCreature () {
  return (dynamic_cast<Creature*> (getObject ()));
}

template <class T>
bool Feat::IsInstance<T>::operator() (FeatPtr featPtr) {
  return (dynamic_cast<T*> (featPtr.get ()) != NULL);
}

template <class T>
bool Feat::findFeat (const Object& object) const {
  const Creature* creature = dynamic_cast<const Creature*> (&object);

  if (creature != NULL) {
    Feats feats = creature->getFeats ();
    Feats::iterator end = feats.end ();
    return (end != std::find_if (feats.begin (), end, IsInstance<T> ()));
  }

  return (false);
}

OGS_END_CORE_NAMESPACE

#  endif /* !defined OGS_CORE_FEAT_H */

#endif /* defined __cplusplus */

---