---

/home/groups/n/no/noxwizard/cvs/src/guild.h

Go to the documentation of this file.

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    || NoX-Wizard UO Server Emulator (NXW) [http://noxwizard.sourceforge.net]  ||
    ||                                                                         ||
    || This software is free software released under GPL2 license.             ||
    || You can find detailed license information in nox-wizard.cpp file.       ||
    ||                                                                         ||
    || For any question post to NoX-Wizard forums.                             ||
    -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

#ifndef __GUILD_H__
#define __GUILD_H__

#include "constants.h"
#include "typedefs.h"
#include "worldmain.h"

class cGuildRecruit
{
        public:

                SERIAL  serial; 
                P_GUILD_MEMBER  recruiter; 
                
                cGuildRecruit( SERIAL recruit );
                ~cGuildRecruit();

                void load( cStringFile& file );
                void save( FILE* file );
};

typedef enum {
        GUILD_TOGGLE_ALL,
        GUILD_TOGGLE_SAMEGUILD,
        GUILD_TOGGLE_NONE
} GUILD_TITLE_TOGGLE;

/*
\note the menber of a guild
\author Endymion
*/
class cGuildMember
{


        public:
                
        SERIAL serial;  
        std::string     title;  
        GUILD_TITLE_TOGGLE toggle; 
        UI32 rank; 
        SERIAL fealty;

                cGuildMember( SERIAL serial );
                ~cGuildMember();

                void load( cStringFile& file );
                void save( FILE* file );
                inline const SERIAL getSerial() const
                { return serial; }
                inline void setSerial(SERIAL newSerial) 
                { serial = newSerial; }
                inline const UI32 getRank() const
                { return rank; }
                inline void setRank(UI32 newRank )
                { rank= newRank; }
                inline const SERIAL getFealty() const
                { return fealty; }
                inline void setFealty(SERIAL newFealty )
                { fealty= newFealty; }
                
};


#define GUILD_POLITICS_WAR 0
#define GUILD_POLITICS_PEACE 1
#define GUILD_POLITICS_ALLIED 2

typedef enum {
        GUILD_POLITICS_BLUE = 1,
        GUILD_POLITICS_GREEN,
        GUILD_POLITICS_ORANGE,
        GUILD_POLITICS_RED,
        GUILD_POLITICS_TRANSPARENT
} GUILD_POLITICS_COLOR;



class cGuildPolitics {

        public:

                SERIAL serial; 
                GUILD_POLITICS_COLOR color; 
                UI08 type; 
                bool forever;   

                cGuildPolitics();
                ~cGuildPolitics();
};


typedef enum {
        GUILD_TYPE_NORMAL,
        GUILD_TYPE_CHAOS,
        GUILD_TYPE_ORDER,
        GUILD_TYPE_CITY
} GUILD_TYPE;


class cGuild
{
private:
        SERIAL serial;  
        GUILD_TYPE type;        

        public:

                void load( cStringFile& file );
                void save( FILE* file );

        public:



        private:
                std::string     name;   
                std::string     abbreviation;   
                SERIAL_VECTOR guildWar;
                SERIAL_VECTOR guildPeace;
                SERIAL_VECTOR guildAllies;

                SERIAL guildMaster;
        typedef enum  {
                RANK_GUILDMASTER,
                RANK_GUILDVICE,
                RANK_GUILDMEMBER,
                RANK_GUILDRECRUIT,
                ALL_RANKS
        } GUILD_RANK;   
        public:

                std::map< SERIAL, P_GUILD_MEMBER > members;     
                std::wstring    charter;        
                std::string webpage;    

                cGuild( SERIAL guildstone );
                ~cGuild();
                void load();
                SERIAL getSerial();

                void setName( std::string &newName );
                std::string getName();
                void setAbbreviation( std::string &newAbbr );
                std::string getAbbreviation();
                inline const    GUILD_TYPE      getGuildType() const { return type; };
                inline void             setGuildType(GUILD_TYPE newGuildType)  
                { if ( newGuildType >= GUILD_TYPE_NORMAL && newGuildType <=  GUILD_TYPE_ORDER) type = newGuildType; };

                // Helper functions for 
                inline const    SERIAL  cGuild::getGuildMaster() const { return guildMaster; };
                inline void             cGuild::setGuildMaster(SERIAL newGuildMaster)  
                { guildMaster=newGuildMaster; getMember(guildMaster)->setRank(RANK_GUILDMASTER); };
                void cGuild::calculateFealty();
                void cGuild::showTitle(P_CHAR pc, P_CHAR pc2);
        public:
                inline std::map< SERIAL, P_GUILD_MEMBER >getMembers()
                { return members; }
                P_GUILD_MEMBER addMember( P_CHAR pc );
                void resignMember( P_CHAR pc );
                inline void removeMember(SERIAL member)
                { members.erase(member); }
                P_GUILD_MEMBER getMember( SERIAL member );
                int getMemberPosition(SERIAL member);
                SERIAL getMemberByIndex(int index);
                int getRecruitIndex(SERIAL member);
                SERIAL getRecruitByIndex(int index);
                std::vector<SERIAL> *getGuildsInWar();
                std::vector<SERIAL> *getGuildsInPeace();
                std::vector<SERIAL> *getGuildsAllied();
                void addWar(SERIAL guild);
                void addPeace(SERIAL guild);
                void addAlly(SERIAL guild);
                bool hasWarWith(SERIAL guild);
                bool hasPeaceWith(SERIAL guild);
                bool hasAllianceWith(SERIAL guild);
                void cGuild::makePeace(SERIAL guild);
        public:

                std::map< SERIAL, P_GUILD_RECRUIT > recruits;   
                
                P_GUILD_RECRUIT addNewRecruit( P_CHAR recruit, P_CHAR recruiter );
                void refuseRecruit( P_CHAR pc );
                P_GUILD_RECRUIT getRecruit( SERIAL recruit );
                

};


class cGuildz
{
        private:

                void safeoldsave();
                std::string getFullAdress();

        public:
                
                void archive();
                bool load();
                bool save();

        public:

                std::map< SERIAL, P_GUILD > guilds;

                cGuildz();
                ~cGuildz();

                P_GUILD getGuild( SERIAL guild );
                P_GUILD addGuild( SERIAL stone );
                void removeGuild( SERIAL guild );
                int cGuildz::compareGuilds(P_GUILD guild1,P_GUILD guild2);
                void cGuildz::checkConsistancy(void );
};

extern cGuildz Guildz;


#endif