A quick run through your code reveals a number of bad things.
Firstly, you should hide your variables inside the class. If you don't want to bother with get/set, this may help:
Code:
#ifndef UtilityMember_h__
#define UtilityMember_h__
#include <boost/type_traits.hpp>
#include "FriendTemplateClass.h"
namespace Stuff
{
template<typename T> struct ParamType
{
typedef typename boost::remove_cv
<
typename boost::remove_const
<
typename boost::remove_pointer
<
typename boost::remove_reference<T>::type
>::type
>::type
>::type BasicType;
};
template<typename T, bool IsFundamental> struct ParamPolicyInternal // IsFundamental = false
{
typedef typename boost::add_const
<
typename boost::add_reference<typename ParamType<T>::BasicType>::type
>
::type Type;
};
template<typename T> struct ParamPolicyInternal<T, true> { typedef typename ParamType<T>::BasicType Type; };
template<typename T> struct ParamPolicy: public ParamPolicyInternal<T, boost::is_fundamental<T>::value> { };
#define Template \
template \
< \
typename Type, \
typename Class = Dummy<Type>, \
typename ParamPolicy<Type>::Type (Class::* GetFunction)() = &Dummy<Type>::GetFunction, \
void (Class::* SetFunction)(typename ParamPolicy<Type>::Type) = &Dummy<Type>::SetFunction \
>
template
<
typename Type,
typename Class,
typename ParamPolicy<Type>::Type (Class::* GetFunction)(),
void (Class::* SetFunction)(typename ParamPolicy<Type>::Type)
>
class CUtilityMemberSpecial
{
private:
TYPE_FRIENDLY(Class);
Class* m_pClass;
typename ParamPolicy<Type>::Type m_Data;
public:
CUtilityMemberSpecial(Class* pClass): m_pClass(pClass) { }
CUtilityMemberSpecial(typename ParamPolicy<Type>::Type NewData, Class* pClass)
{
Data = NewData;
m_pClass = pClass;
}
CUtilityMemberSpecial& operator = (typename ParamPolicy<Type>::Type NewData)
{
(m_pClass->*SetFunction)(NewData);
return *this;
}
operator typename ParamPolicy<Type>::Type () const
{
return (m_pClass->*GetFunction)();
}
};
template<typename Type> class CUtilityMember
{
private:
typename ParamPolicy<Type>::Type m_Data;
public:
CUtilityMember() {}
CUtilityMember(typename ParamPolicy<Type>::Type NewData)
{
m_Data = NewData;
}
CUtilityMember& operator = (typename ParamPolicy<Type>::Type NewData)
{
m_Data = NewData;
return *this;
}
operator typename ParamPolicy<Type>::Type () const
{
return m_Data;
}
};
}
#endif // UtilityMember_h__
CUtilityMember<int> m_AttackStrength;
Is all you have to do to hide it. Later, you can use CUtilityMemberSpecial if you want further customization. Better encapsulation. Good for the overall health of your code.
CAccessorie is actually spelled CAccessory.
Your BOARD should probably be boost::array (and not a pointer!). It will detect out-of-bounds for you. And is it really necrssary to make it a pointer?
readStr should really use std::getline instead of std::cin.getline.
Race should probably be an enum.
I don't know if it's a good idea to name the struct and the instance of the struct by the same name (skills).
And lastly, you have too much code and too little code that runs the game.
Take it easy. Write the code to run the game, and add utility code to support it as you go.
If you have to change something in your utility classes now, you may end up breaking all the code.
And you don't even know if the current system works! Another good reason to write actual code to test if before going berserk and adding all sorts of different code to make the "system" work.