www.pudn.com > SimpleMUD.rar > Entity.h

// MUD Programming 
// Ron Penton 
// (C)2003 
// Entity.h - This is a base class defining classes in SimpleMUD that may be 
//             matched by name either partially or fully, and have ID's 
//  
//  
 
 
#ifndef SIMPLEMUDENTITY_H 
#define SIMPLEMUDENTITY_H 
 
#include  
#include "BasicLib/BasicLib.h" 
 
 
namespace SimpleMUD 
{ 
 
typedef unsigned int entityid; 
using std::string; 
 
// -------------------------------------------------------------------- 
//  This class has a given name, and will allow you to match 
//  the name with any other names either partially or fully. 
//  It also has ID's 
// -------------------------------------------------------------------- 
class Entity 
{ 
public: 
 
 
    // -------------------------------------------------------------------- 
    //  Constructor 
    // -------------------------------------------------------------------- 
    inline Entity() 
    { 
        m_name = "UNDEFINED"; 
        m_id = 0; 
    } 
 
    // -------------------------------------------------------------------- 
    //  Retrieves a reference to the name, which is modifiable. 
    // -------------------------------------------------------------------- 
    inline string& Name()   { return m_name; } 
 
 
    // -------------------------------------------------------------------- 
    //  returns the "comparison name", which is lowercased. This is because 
    //  all comparisons are case-insensitive. 
    // -------------------------------------------------------------------- 
    inline string CompName() const 
    {  
        return BasicLib::LowerCase( m_name ); 
    } 
 
    // -------------------------------------------------------------------- 
    //  Compares the name with a full match. Names must be identical except 
    //  for case. 
    // -------------------------------------------------------------------- 
    inline bool MatchFull( const string& p_str ) const 
    { 
        return CompName() == BasicLib::LowerCase( p_str ); 
    } 
 
    // -------------------------------------------------------------------- 
    //  Performs a partial match on the name, where it will match the first 
    //  n characters from m_name with a n-character-long string p_name. 
    //  Case-insensitive. 
    //  IE: "J", "j", "JO" all match "John".  "o", "ohn" will not. 
    // -------------------------------------------------------------------- 
    inline bool Match( const string& p_str ) const 
    { 
        // match on empty strings 
        if( p_str.size() == 0 ) 
            return true; 
 
        // grab the comparison name 
        string name = CompName(); 
        string search = BasicLib::LowerCase( p_str ); 
 
        // find the position of a match 
        size_t pos = name.find( search ); 
 
        // perform as many search passes as needed 
        // for example, if the user types "st" when searching a "rusty stake", 
        // only one pass would find the 'st' in "rusty", and determine that 
        // there is no match. That's why more than one pass is needed. 
        while( pos != string::npos ) 
        { 
            // match found at beginning, or match found at beginning of a word,  
            // therefore, return true. 
            if( pos == 0 || m_name[pos-1] == ' ' ) 
                return true; 
 
            // perform another search, starting at where the last one left off 
            pos = name.find( search, pos + 1 ); 
        } 
 
        // no matches 
        return false; 
    } 
 
    // -------------------------------------------------------------------- 
    //  Returns the ID for the entity 
    // -------------------------------------------------------------------- 
    inline entityid& ID()    { return m_id; } 
 
 
protected: 
    string m_name; 
    entityid m_id; 
 
};  // end class Entity 
 
 
 
struct matchentityfull 
{  
    matchentityfull( const string& p_str ) 
        : m_str( p_str ) { /* do nothing */ } 
 
    bool operator() ( const Entity& p_entity ) 
    { 
        return p_entity.MatchFull( m_str ); 
    } 
 
    bool operator() ( Entity* p_entity ) 
    { 
        return p_entity != 0 && p_entity->MatchFull( m_str ); 
    } 
 
 
    string m_str; 
}; 
 
 
struct matchentity 
{  
    matchentity( const string& p_str ) 
        : m_str( p_str ) { /* do nothing */ } 
 
    bool operator() ( const Entity& p_entity ) 
    { 
        return p_entity.Match( m_str ); 
    } 
 
    bool operator() ( Entity* p_entity ) 
    { 
        return p_entity != 0 && p_entity->Match( m_str ); 
    } 
 
    string m_str; 
}; 
 
 
 
 
 
 
 
}   // end namespace SimpleMUD 
 
 
#endif