简单之协议框架设计

//我只是为了检查有谁喜欢做这些恶作剧 ~

#pragma once

#pragma pack(1)

#define SET_ARMY_RANK (1U) //转换队伍
#define SET_ARMY_TEAM (2U) //转换团队

#define ARMY_RETURN_ERROR (0x0FFFF) //人数上限

//全局数据ID
typedef union _ARMY_ROLE_GUID {
 struct _data {
  short _role_guid; //玩家成员ID
  short _rank_guid; //玩家队伍ID
  short _team_guid; //玩家团队ID
  short _data_guid; //玩家数据ID
 }GUID;
 unsigned long long _guid;
} ARMY_ROLE_GUID;

#define ARMY_IS_NULL (0x00000000) //没有组织
#define ARMY_IS_ITEM (0x00000001) //组织成员
#define ARMY_IS_IOFF (0x00000003) //成员掉线
#define ARMY_IS_CAPT (0x00000004) //组织队长
#define ARMY_IS_COFF (0x0000000C) //队长掉线
#define ARMY_IS_REPI (0x00000010) //组织团长
#define ARMY_IS_ROFF (0x00000030) //团长掉线
#define ARMY_IS_REQT (0x00000040) //邀请状态
#define ARMY_IS_APPL (0x00000080) //申请状态

//标记状态
typedef union _ARMY_ROLE_FLAG{
 struct _data {
  unsigned char _item : 1U; //是否为成员
  unsigned char _ioff : 1U; //是否成员掉线
  unsigned char _capt : 1U; //是否为队长
  unsigned char _coff : 1U; //是否队长掉线
  unsigned char _repi : 1U; //是否为团长
  unsigned char _roff : 1U; //是否团长掉线
  unsigned char _reqt : 1U; //邀请状体
  unsigned char _appl : 1U; //申请状态
 }FlAG;
 unsigned char _army_type;
} ARMY_ROLE_FLAG;

//基本属性
typedef struct _ARMY_ROLE_ATTRI {
 unsigned short _role_ic; //玩家头像
 unsigned short _role_se; //玩家性别
 unsigned short _role_hp; //玩家血量
 unsigned short _role_mp; //玩家魔法
 unsigned short _role_bf; //玩家附加属性
  //......其他属性
} ARMY_ROLE_ATTRI;

//用户信息
typedef struct _ARMY_USER_INFO {
 unsigned char _role_name[12]; //玩家名
 unsigned char _unio_name[12]; //公会名
} ARMY_USER_INFO;

//临时玩家数据存储
typedef struct _ARMY_ROLE_DATA {
 _ARMY_ROLE_GUID _role_guid;
 _ARMY_ROLE_FLAG _role_flag;
 _ARMY_USER_INFO _user_info;
} ARMY_ROLE_DATA;

//综合信息
typedef struct _ARMY_ROLE_INTEGR {
 _ARMY_ROLE_DATA _role_data; // 玩家信息
 _ARMY_ROLE_ATTRI _role_attr; //玩家属性
} ARMY_ROLE_INTEGR;

//团队GID对象
typedef struct _ARMY_GUID_OBJECT {
 unsigned short _rank_index; //插入索引
 unsigned short _rank_count; //小队总数
 _ARMY_ROLE_GUID * _rank_guid; //队伍总数
} ARMY_GUID_OBJECT;

//团队GID信息链
typedef struct _ARMY_GUID_SET {
 unsigned short _guid_index; //插入索引
 unsigned short _guid_count; //_gid_array 总数
 _ARMY_GUID_OBJECT ** _guid_array; //各个GUID对象
} ARMY_GUID_SET;

//小队组织类型对象
typedef struct _ARMY_ROLE_OBJECT {
 unsigned short _role_index; //插入索引
 unsigned short _role_count; //成员总数
 _ARMY_ROLE_INTEGR * _role_inte; //成员d总数
} ARMY_ROLE_OBJECT;

//小队组织信息链
typedef struct _ARMY_ROLE_SET {
 unsigned short _rank_index; //插入索引
 unsigned short _rank_count; //_rank_array 总数
 _ARMY_ROLE_OBJECT ** _rank_array; //各个组织对象
} ARMY_ROLE_SET;

//返回类型
typedef enum _ARMY_RETUNR_TYPE{
 _role_not, //没有找到玩家
 _role_succress, //玩家成功加入
 _role_reject, //玩家拒绝加入
 _role_exist, //玩家已有队列
 _role_dissolve, //队伍解散
 _role_exit, //玩家离开
 _role_quit, //踢出队列
 _role_limit, //组织上限
 _role_request, //玩家处于邀请状态
 _role_apply //玩家处于申请状态 
} ARMY_RETURN_TYPE;

typedef enum _ARMY_ORGAN_TYPE {
 _army_rank, //队伍
 _army_team //团队
} ARMY_ORGAN_TYPE;

//返回数据
typedef struct _ARMY_RETURN_INFO {
 unsigned char _repl_code; //_ARMY_RETUNR_TYPE
 unsigned char _army_type; //_ARMY_ORGAN_TYPE
 unsigned char _role_post; //玩家组织等级
 unsigned char _role_name[12]; //玩家名
} ARMY_RETURN_INFO;

//更新指定数据
typedef union _ARMY_SINGLE_ROLE {
 unsigned short _role_ic; //玩家头像
 unsigned short _role_se; //玩家性别
 unsigned short _role_hp; //玩家血量
 unsigned short _role_mp; //玩家魔法
 unsigned short _role_bf; //玩家附加属性
 //......其他属性
} ARMY_SINGLE_ROLE;

//更新指定名称
typedef union _ARMY_SINGLE_NAME {
 unsigned char _role_name[12]; //玩家名
 unsigned char _unio_name[12]; //公会名
 //.....其他信息
} ARMY_SINGLE_NAME;

//指定属性更新
typedef union _ARMY_UPDATA_DATA {
 _ARMY_USER_INFO _user_info; //用户信息
 _ARMY_ROLE_ATTRI _role_attr; //玩家属性
 _ARMY_RETURN_INFO _repl_info; //返回处理结果
 _ARMY_SINGLE_NAME _sing_name; //单个名称更新
 _ARMY_SINGLE_ROLE _sing_data; //单个数据更新
 _ARMY_ROLE_INTEGR _role_inte; //综合信息
} ARMY_UPDATA_DATA;

//类型定义
#define HEADLE_PACK (12U) //解包数据
#define HEADLE_TYPE (0xA0000000) //子协议
#define HEADLE_PROTOCOL (sizeof(unsigned int) + (sizeof(_ARMY_ROLE_GUID) * 2U)) //协议头大小

#define SERVER_APPLY_TYPE ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x00) //服务器转发申请
#define SERVER_REPLY_APPLY ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x01) //回馈申请给服务器
#define CLIENT_REPLY_APPLY ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x02) //客服端接收到申请人

#define SERVER_REQUEST_TYPE ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x03) //服务器转发邀请
#define SERVER_REPLY_REQUEST ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x04) //回馈邀请给服务器
#define CLIENT_REPLY_REQUEST ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x05) //客服端接收到请求

#define CLIENT_ADDTO_ITEM ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_ROLE_INTEGR)) << HEADLE_PACK)) + 0x06) //客服端增加成员

#define SERVER_REPLY_INFO ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_RETURN_INFO)) << HEADLE_PACK)) + 0x07) //回馈服务端错误信息
#define CLIENT_REPLY_INFO ((HEADLE_TYPE + ((HEADLE_PROTOCOL + sizeof(_ARMY_RETURN_INFO)) << HEADLE_PACK)) + 0x08) //回馈客服端错误信息

//......其他协议类型

#define MAX_FUNCTION_COUNT (0x000000FF) //函数总数
#define PROTOCOL_CHECK_VALUE (0x0AFF00F00) //效验值

#define MAKE_FINCTION_INDEX(_H) ((_H) & MAX_FUNCTION_COUNT) //获取函数索引
#define MAKE_SPACEDATA_SIZE(_H) ((((_H) ^ HEADLE_TYPE) - ((_H) & MAX_FUNCTION_COUNT)) >> HEADLE_PACK) //获取实际数据大小


//组织通信协议
typedef struct _ARMY_ROLE_PROTOCOL {
 unsigned int _proto_headle; //协议头 _ARMY_HEADLE_TYPE
 struct _data {
  _ARMY_ROLE_GUID _srce_guid; //发起者数据ID
  _ARMY_ROLE_GUID _dest_guid; //接受者数据ID
 }GUID;
 _ARMY_UPDATA_DATA _updata_data; //附加共享数据,取决于协议
} ARMY_ROLE_PROTOCOL;

#pragma pack()

class CGameArmy;

//内部函数指针
typedef bool(__thiscall CGameArmy:: * _Function)(ARMY_ROLE_PROTOCOL * _hProtocol);

class /*CS/SC*/CGameArmy //: public CIocpSocket
{

public:
 //初始化
 CGameArmy(void);
 //释放内存
 ~CGameArmy(void);

public:

 //服务器转发申请
 bool ArmyServerApplyItem(ARMY_ROLE_PROTOCOL * _hProtocol);
 //回馈申请给服务器
 bool ArmyServerReplyApply(ARMY_ROLE_PROTOCOL * _hProtocol);
 //客服端接收到申请
 bool ArmyClientReplyApply(ARMY_ROLE_PROTOCOL * _hProtocol);

 //服务器转发邀请
 bool ArmyServerRequestItem(ARMY_ROLE_PROTOCOL * _hProtocol);
 //回馈邀请给服务器
 bool ArmyServerReplyRequest(ARMY_ROLE_PROTOCOL * _hProtocol);
 //客服端接受到邀请
 bool ArmyCilentReplyRequest(ARMY_ROLE_PROTOCOL * _hProtocol);

 //客服端增加类型成员
 bool ArmyClientAddToItem(ARMY_ROLE_PROTOCOL * _hProtocol);

 //回馈给服务器信息
 bool ArmyServerReplyInfo(ARMY_ROLE_PROTOCOL * _hProtocol);
 //回馈给客服端信息
 bool ArmyClientRoplyInfo(ARMY_ROLE_PROTOCOL * _hProtocol);

private:

 bool ArmyAddTeamItem(const ARMY_ROLE_GUID * _RankGuid); //添加小队GUID
 bool ArmyAddRankItem(const ARMY_ROLE_INTEGR * _RoleInte); //添加小队成员

 inline void ArmyDelRankItem(unsigned int _RoleGuid) //删除小队成员
 {
  m_rObject._role_inte[_RoleGuid]._role_data._role_guid._guid = 0U;
  m_rObject._role_index = _RoleGuid;
 }
 inline void ArmyDelTeamItem(unsigned int _RankGuid) //删除团队队伍
 {
  m_tObject._rank_guid[_RankGuid]._guid = 0U;
  m_tObject._rank_index = _RankGuid;
 }

 inline void ArmyClearRankItem(ARMY_ROLE_OBJECT * _RoleObject) //清空小队成员
 {
  memset(_RoleObject, 0, sizeof(ARMY_ROLE_OBJECT));
 }
 inline void ArmyClearTeamItem(ARMY_GUID_OBJECT * _RankObject) //清空团队小队
 {
  memset(_RankObject, 0, sizeof(ARMY_GUID_OBJECT));
 }

 //指定添加队伍GUID
 bool ArmyAddSpaceTeamItem(ARMY_GUID_OBJECT * _TeamObject, const ARMY_ROLE_GUID * _RankGuid);
 //指定添加成员GUID
 bool ArmyAddSpaceRankItem(ARMY_ROLE_OBJECT * _RankObject, const ARMY_ROLE_INTEGR * _RoleInte);

 bool ArmyAddRankArray(const ARMY_ROLE_OBJECT * _RankObject); //添加队伍到集合
 bool ArmyAddTeamArray(const ARMY_GUID_OBJECT * _TeamObject); //添加团队到集合

 inline void ArmyDelRankArray(unsigned int _RankGuid) //删除队伍对象
 {
  m_aRoleSet._rank_array[_RankGuid] = NULL;
  m_aRoleSet._rank_index = _RankGuid;
 }
 inline void ArmyDelTeamArray(unsigned int _TeamGuid) //删除团队对象
 {
  m_aGuidSet._guid_array[_TeamGuid] = NULL;
  m_aGuidSet._guid_index = _TeamGuid;
 }

 void ArmyClearRankArray(void); //清空队伍集合
 void ArmyClearTeamArray(void); //清空团队集合

private:

 ARMY_ROLE_SET m_aRoleSet; //小队集合
 ARMY_GUID_SET m_aGuidSet; //团队集合

 ARMY_ROLE_OBJECT m_rObject; //小队成员
 ARMY_GUID_OBJECT m_tObject; //团队成员

 ARMY_ROLE_DATA * m_aRoleData; //临时数据存储

public:

 ARMY_ROLE_INTEGR m_mIntegr; //设置本地玩家综合信息

private:

 //异常数据处理
 inline bool ArmyNullFunction(ARMY_ROLE_PROTOCOL * _hProtocol)
 {
  //处理异常数据......
  printf("异常数据0x%08x\r\n", _hProtocol->_proto_headle);
  return false;
 }
 //功能索引
 _Function m_fIndex[MAX_FUNCTION_COUNT + 1U];

public:

 bool ArmyInitRtData(unsigned short _uRoleCount); //初始化数据
 bool ArmyInitRankCount(unsigned short _uRoleArray); //小队最大人数
 bool ArmyInitTeamCount(unsigned short _uRankArray); //团队最大队数

private:

 bool ArmyInitRankArray(unsigned short _uRoleCount); //初始化队伍总数
 bool ArmyInitTeamArray(unsigned short _uRoleCount); //初始化团队总数

private:

 inline void ArmyDelRoleFlagInfo(unsigned int _RoleGuid) //删除临时玩家数据
 {
  memset(&m_aRoleData[_RoleGuid], 0, sizeof(ARMY_ROLE_DATA));
 }

 inline void ArmyAddRoleFlagInfo(const ARMY_ROLE_PROTOCOL * _hProtocol) //添加临时玩家数据
 {
  memcpy(&m_aRoleData[_hProtocol->GUID._srce_guid.GUID._data_guid], \
   &_hProtocol->_updata_data._role_inte._role_data, sizeof(ARMY_ROLE_DATA));
 }

 inline bool ArmyGetRoleReplyOrRequestFlag(unsigned short _uRoleGuid) //是否不存在申请或邀请标记
 {
  return !(m_aRoleData[_uRoleGuid]._role_flag.FlAG._appl ^ m_aRoleData[_uRoleGuid]._role_flag.FlAG._reqt);
 }

public:

 bool ArmyIndexCallFunction(ARMY_ROLE_PROTOCOL * _hProtocol); //协议功能索引
};




/*******************************************************分割线*****************************************************************/




#include "stdafx.h"

#include "GameArmy.h"




CGameArmy::CGameArmy(void)
{
 //初始化数据
 m_aRoleData = NULL;

 m_rObject._role_inte = NULL;
 m_tObject._rank_guid = NULL;

 m_aRoleSet._rank_array = NULL;
 m_aGuidSet._guid_array = NULL;

 初始化协议函数
 m_fIndex[MAKE_FINCTION_INDEX(SERVER_APPLY_TYPE)] = &CGameArmy::ArmyServerApplyItem;
 m_fIndex[MAKE_FINCTION_INDEX(SERVER_REPLY_APPLY)] = &CGameArmy::ArmyServerReplyApply;
 m_fIndex[MAKE_FINCTION_INDEX(CLIENT_REPLY_APPLY)] = &CGameArmy::ArmyClientReplyApply;
 m_fIndex[MAKE_FINCTION_INDEX(SERVER_REQUEST_TYPE)] = &CGameArmy::ArmyServerRequestItem;
 m_fIndex[MAKE_FINCTION_INDEX(SERVER_REPLY_REQUEST)] = &CGameArmy::ArmyServerReplyRequest;
 m_fIndex[MAKE_FINCTION_INDEX(CLIENT_REPLY_REQUEST)] = &CGameArmy::ArmyCilentReplyRequest;
 m_fIndex[MAKE_FINCTION_INDEX(CLIENT_ADDTO_ITEM)] = &CGameArmy::ArmyClientAddToItem;
 m_fIndex[MAKE_FINCTION_INDEX(SERVER_REPLY_INFO)] = &CGameArmy::ArmyServerReplyInfo;
 m_fIndex[MAKE_FINCTION_INDEX(CLIENT_REPLY_INFO)] = &CGameArmy::ArmyClientRoplyInfo;

 //其他空函数作为异常数据处理
 for (register unsigned int i = MAKE_FINCTION_INDEX(CLIENT_REPLY_INFO) + 1U; i < (MAX_FUNCTION_COUNT + 1U); ++i)
 {
  m_fIndex[i] = &CGameArmy::ArmyNullFunction;
 }
}

CGameArmy::~CGameArmy(void)
{
 this->ArmyClearRankArray();
 this->ArmyClearTeamArray();

 if (m_aRoleData != NULL)
  free(m_aRoleData);
 if (m_rObject._role_inte != NULL)
  free(m_rObject._role_inte);
 if (m_tObject._rank_guid != NULL)
  free(m_tObject._rank_guid);
 if (m_aRoleSet._rank_array != NULL)
  free(m_aRoleSet._rank_array);
 if (m_aGuidSet._guid_array != NULL)
  free(m_aGuidSet._guid_array);
}

bool CGameArmy::ArmyInitRankCount(unsigned short _uRoleArray)
{
 m_rObject._role_count = _uRoleArray;
 const size_t _alloc_size = _uRoleArray * sizeof(_ARMY_ROLE_INTEGR);
 
 if ((m_rObject._role_inte = (_ARMY_ROLE_INTEGR *)malloc(_alloc_size)) != NULL)
 {
  memset(m_rObject._role_inte, 0, _alloc_size);
  return true;
 }
 return false;
}

bool CGameArmy::ArmyInitTeamCount(unsigned short _uRankArray)
{
 m_tObject._rank_count = _uRankArray;
 const size_t _alloc_size = _uRankArray * sizeof(_ARMY_ROLE_GUID);

 if ((m_tObject._rank_guid = (_ARMY_ROLE_GUID *)malloc(_alloc_size)) != NULL)
 {
  memset(m_tObject._rank_guid, 0, _alloc_size);
  return true;
 }
 return false;
}

bool CGameArmy::ArmyInitRankArray(unsigned short _uRoleCount)
{
 m_aRoleSet._rank_count = _uRoleCount >> 1U;
 const size_t _alloc_size = m_aRoleSet._rank_count * sizeof(_ARMY_ROLE_OBJECT *);

 if ((m_aRoleSet._rank_array = (_ARMY_ROLE_OBJECT **)malloc(_alloc_size)) != NULL)
 {
  memset(m_aRoleSet._rank_array, 0, _alloc_size);
  return true;
 }
 return false;
}

bool CGameArmy::ArmyInitTeamArray(unsigned short _uRoleCount)
{
 m_aGuidSet._guid_count = _uRoleCount >> 1U;
 const size_t _alloc_size = m_aGuidSet._guid_count * sizeof(_ARMY_GUID_OBJECT *);

 if ((m_aGuidSet._guid_array = (_ARMY_GUID_OBJECT **)malloc(_alloc_size)) != NULL)
 {
  memset(m_aGuidSet._guid_array, 0, _alloc_size);
  return true;
 }
 return false;
}

bool CGameArmy::ArmyInitRtData(unsigned short _uRoleCount)
{
 const unsigned short _alloc_size = _uRoleCount * sizeof(ARMY_ROLE_DATA);

 m_aRoleData = (ARMY_ROLE_DATA *)malloc(_alloc_size);

 if (m_aRoleData != NULL)
 {
  memset(m_aRoleData, 0, _alloc_size);
  return (ArmyInitTeamArray(_uRoleCount) & ArmyInitRankArray(_uRoleCount));
 }
 return false;
}

bool CGameArmy::ArmyServerApplyItem(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 if (true == this->ArmyGetRoleReplyOrRequestFlag(_hProtocol->GUID._srce_guid.GUID._data_guid))
 {
  this->ArmyAddRoleFlagInfo(_hProtocol); //保存玩家标记，防止重复访问

  if (m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid]-> \
   _role_inte[_hProtocol->GUID._dest_guid.GUID._role_guid]._role_data._role_flag.FlAG._repi == true) //团队
  {
   const ARMY_GUID_OBJECT * _army_guid_object = m_aGuidSet._guid_array[_hProtocol->GUID._dest_guid.GUID._team_guid];

   for (register unsigned int i = 0U; i < _army_guid_object->_rank_count; ++i)
   {
    if (m_aRoleSet._rank_array[_army_guid_object->_rank_guid[i].GUID._rank_guid]->_role_index != ARMY_RETURN_ERROR)
    {
     if (0U == m_aRoleSet._rank_array[_army_guid_object->_rank_guid[i].GUID._rank_guid]->_role_index)
     {
      _hProtocol->_updata_data._role_inte._role_data._role_flag._army_type = ARMY_IS_CAPT; //设置为队长
     }
     else
     {
      _hProtocol->_updata_data._role_inte._role_data._role_flag._army_type = ARMY_IS_ITEM; //甚至为成员
     }
     _hProtocol->_proto_headle = CLIENT_REPLY_APPLY;
     _hProtocol->GUID._srce_guid.GUID._team_guid = _hProtocol->GUID._dest_guid.GUID._team_guid;
     _hProtocol->GUID._srce_guid.GUID._rank_guid = _army_guid_object->_rank_guid[i].GUID._rank_guid;
     _hProtocol->GUID._srce_guid.GUID._role_guid = m_aRoleSet._rank_array[_army_guid_object->_rank_guid[i].\
      GUID._rank_guid]->_role_index;
     //发送到团长
     return true;
    }
   }
   _hProtocol->_proto_headle = CLIENT_REPLY_INFO;
   _hProtocol->_updata_data._repl_info._army_type = _army_team;
   _hProtocol->_updata_data._repl_info._repl_code = _role_limit;
   //告诉申请人团队已上限
   return true;
  }
  else if (m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid]-> \
   _role_inte[_hProtocol->GUID._dest_guid.GUID._role_guid]._role_data._role_flag.FlAG._capt == true) //队伍
  {
   if (m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid]->_role_index != ARMY_RETURN_ERROR)
   {
    _hProtocol->_proto_headle = CLIENT_REPLY_APPLY;
    _hProtocol->GUID._srce_guid.GUID._rank_guid = _hProtocol->GUID._dest_guid.GUID._rank_guid;
    _hProtocol->GUID._srce_guid.GUID._role_guid = m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID.\
     _rank_guid]->_role_index;
    //发送到队长
    return true;
   }
   else
   { 
    _hProtocol->_proto_headle = CLIENT_REPLY_INFO;
    _hProtocol->_updata_data._repl_info._army_type = _army_rank;
    _hProtocol->_updata_data._repl_info._repl_code = _role_limit;
    //告诉申请人队伍已上限
    return true;
   }
  }
 }
 return false;
}

bool CGameArmy::ArmyServerReplyApply(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 if (m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid]-> \
  _role_inte[_hProtocol->GUID._dest_guid.GUID._role_guid]._role_data._role_flag.FlAG._repi == true) //团队
 {
  if (_hProtocol->_updata_data._role_inte._role_data._role_flag.FlAG._capt != false) //如果是队长
  {
   //添加到团队集合
   this->ArmyAddSpaceTeamItem(m_aGuidSet._guid_array[_hProtocol->GUID._srce_guid.GUID._team_guid], \
    &_hProtocol->GUID._srce_guid);
  }
  //添加到小队成员
  this->ArmyAddSpaceRankItem(m_aRoleSet._rank_array[_hProtocol->GUID._srce_guid.GUID._rank_guid], \
   &_hProtocol->_updata_data._role_inte);

  _hProtocol->_proto_headle = CLIENT_REPLY_INFO;
  _hProtocol->_updata_data._repl_info._army_type = _army_team;
  _hProtocol->_updata_data._repl_info._role_post = ARMY_IS_ITEM;
  _hProtocol->_updata_data._repl_info._repl_code = _role_succress;
  //发送回馈信息给申请人->_hProtocol->GUID._srce_guid.GUID._data_guid......

  //新成员添加所有成员......
  //将新成员以及数据发送给其他玩家......

  this->ArmyDelRoleFlagInfo(_hProtocol->GUID._srce_guid.GUID._data_guid);
  return true;
 }
 else if (m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid]-> \
  _role_inte[_hProtocol->GUID._dest_guid.GUID._role_guid]._role_data._role_flag.FlAG._capt == true) //队长
 {
  this->ArmyAddSpaceRankItem(m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid], \
   &_hProtocol->_updata_data._role_inte);

  _hProtocol->_proto_headle = CLIENT_REPLY_INFO;
  _hProtocol->_updata_data._repl_info._army_type = _army_rank;
  _hProtocol->_updata_data._repl_info._role_post = ARMY_IS_ITEM;
  _hProtocol->_updata_data._repl_info._repl_code = _role_succress;
  //发送回馈信息给申请人->_hProtocol->GUID._srce_guid.GUID._data_guid......


  const ARMY_ROLE_OBJECT * _army_role_object = m_aRoleSet._rank_array[_hProtocol->GUID._dest_guid.GUID._rank_guid];
  //将新成员数据发送给所有其他玩家......
  for (register unsigned int i = 0U; i < _army_role_object->_role_count; ++i)
  {
   if (_army_role_object->_role_inte[i]._role_data._role_guid._guid != 0U)
   {
    _hProtocol->_proto_headle = CLIENT_ADDTO_ITEM;
    //发送新成员数据给指定客服端
   }
  }
  //新成员将得到所有其他玩家数据......
  for (register unsigned int i = 0U; i < _army_role_object->_role_count; ++i)
  {
   if (_army_role_object->_role_inte[i]._role_data._role_guid._guid != 0U)
   {
    _hProtocol->_proto_headle = CLIENT_ADDTO_ITEM;
    //发送除申请人以外其他玩家数据
   }
  }
  //删除玩家检测标记
  this->ArmyDelRoleFlagInfo(_hProtocol->GUID._srce_guid.GUID._data_guid);
  return true;
 }
 return false;
}

bool CGameArmy::ArmyClientReplyApply(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 if (true == m_mIntegr._role_data._role_flag.FlAG._repi) //团队
 {
  const int _msg_code = ::MessageBoxA(::GetActiveWindow(), "申请加入队伍!", "XXX", MB_OKCANCEL);

  if (IDOK == _msg_code)
  {
   //确认加入
   _hProtocol->_proto_headle = SERVER_REPLY_APPLY;
   _hProtocol->_updata_data._role_inte._role_data._role_guid.GUID._team_guid = _hProtocol->GUID._srce_guid.GUID._team_guid;
   _hProtocol->_updata_data._role_inte._role_data._role_guid.GUID._rank_guid = _hProtocol->GUID._srce_guid.GUID._rank_guid;
   _hProtocol->_updata_data._role_inte._role_data._role_guid.GUID._role_guid = _hProtocol->GUID._srce_guid.GUID._role_guid;
   //发送确认信息
   return true;
  }
  else
  {
   //拒绝加入
   _hProtocol->_proto_headle = SERVER_REPLY_INFO;
   _hProtocol->_updata_data._repl_info._army_type = _army_team;
   _hProtocol->_updata_data._repl_info._role_post = ARMY_IS_REPI;
   _hProtocol->_updata_data._repl_info._repl_code = _role_reject;
   memcpy(_hProtocol->_updata_data._repl_info._role_name, m_mIntegr._role_data._user_info._role_name, 12U);
   //发送拒绝信息
   return true;
  }
 }
 else if (true == m_mIntegr._role_data._role_flag.FlAG._capt) //队伍
 {
  const int _msg_code = ::MessageBoxA(::GetActiveWindow(), "申请加入队伍!", "XXX", MB_OKCANCEL);

  if (IDOK ==  _msg_code)
  {
   //确认加入
   _hProtocol->_proto_headle = SERVER_REPLY_APPLY;
   _hProtocol->_updata_data._role_inte._role_data._role_flag._army_type = ARMY_IS_ITEM;
   _hProtocol->_updata_data._role_inte._role_data._role_guid.GUID._rank_guid = _hProtocol->GUID._srce_guid.GUID._rank_guid;
   _hProtocol->_updata_data._role_inte._role_data._role_guid.GUID._role_guid = _hProtocol->GUID._srce_guid.GUID._role_guid;
   //发送确认信息
   return true;
  }
  else
  {
   //拒绝加入
   _hProtocol->_proto_headle = SERVER_REPLY_INFO;
   _hProtocol->_updata_data._repl_info._army_type = _army_rank;
   _hProtocol->_updata_data._repl_info._role_post = ARMY_IS_CAPT;
   _hProtocol->_updata_data._repl_info._repl_code = _role_reject;
   memcpy(_hProtocol->_updata_data._repl_info._role_name, m_mIntegr._role_data._user_info._role_name, 12U);
   //发送拒绝信息
   return true;
  }
 }
 return false;
}

bool CGameArmy::ArmyServerRequestItem(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 return false;
}

bool CGameArmy::ArmyServerReplyRequest(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 return false;
}

bool CGameArmy::ArmyCilentReplyRequest(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 return false;
}

bool CGameArmy::ArmyClientAddToItem(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 //客服端添加其他玩家数据
 return false;
}

bool CGameArmy::ArmyServerReplyInfo(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 //效验数据长度
 if (sizeof(_ARMY_RETURN_INFO) == (MAKE_SPACEDATA_SIZE(_hProtocol->_proto_headle)))
 {
  //将目标客服端返回的信息转发给源客服端
  return true;
 }
 return false;
}

bool CGameArmy::ArmyClientRoplyInfo(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 if (true == m_mIntegr._role_data._role_flag.FlAG._appl)
 {
  //处理回馈信息......
  m_mIntegr._role_data._role_flag.FlAG._appl = false;
  return true;
 }
 return false;
}

bool CGameArmy::ArmyAddRankItem(const ARMY_ROLE_INTEGR * _RoleInte)
{
 if (m_rObject._role_index != ARMY_RETURN_ERROR)
 {
  memcpy(&m_rObject._role_inte[m_rObject._role_index], _RoleInte, sizeof(_ARMY_ROLE_INTEGR));

  for (register unsigned int i = m_rObject._role_index + 1U; i < m_rObject._role_count; ++i)
  {
   if (0U == m_rObject._role_inte[i]._role_data._role_guid._guid)
   {
    m_rObject._role_index = i;
    return true;
   }
  }
  for (register unsigned int i = 0U; i < m_rObject._role_index; ++i)
  {
   if (0U == m_rObject._role_inte[i]._role_data._role_guid._guid)
   {
    m_rObject._role_index = i;
    return true;
   }
  }
  m_rObject._role_index = ARMY_RETURN_ERROR;
 }
 return false;
}

bool CGameArmy::ArmyAddTeamItem(const ARMY_ROLE_GUID * _RankGuid)
{
 if (m_tObject._rank_index != ARMY_RETURN_ERROR)
 {
  memcpy(&m_tObject._rank_guid[m_tObject._rank_index], _RankGuid, sizeof(ARMY_ROLE_GUID));

  for (register unsigned int i = m_tObject._rank_index + 1U; i < m_tObject._rank_count; ++i)
  {
   if (0U == m_tObject._rank_guid[i]._guid)
   {
    m_tObject._rank_index = i;
    return true;
   }
  }
  for (register unsigned int i = 0U; i < m_tObject._rank_index; ++i)
  {
   if (0U == m_tObject._rank_guid[i]._guid)
   {
    m_tObject._rank_index = i;
    return true;
   }
  }
  m_tObject._rank_index = ARMY_RETURN_ERROR;
 }
 return false;
}

bool CGameArmy::ArmyAddRankArray(const ARMY_ROLE_OBJECT * _RankObject)
{
 if (m_aRoleSet._rank_index != ARMY_RETURN_ERROR)
 {
  m_aRoleSet._rank_array[m_aRoleSet._rank_index] = const_cast<ARMY_ROLE_OBJECT *>(_RankObject);

  for (register unsigned int i = m_aRoleSet._rank_index + 1U; i < m_aRoleSet._rank_count; ++i)
  {
   if (NULL == m_aRoleSet._rank_array[i])
   {
    m_aRoleSet._rank_index = i;
    return true;
   }
  }
  for (register unsigned int i = 0U; i < m_aRoleSet._rank_index; ++i)
  {
   if (NULL == m_aRoleSet._rank_array[i])
   {
    m_aRoleSet._rank_index = i;
    return true;
   }
  }
  m_aRoleSet._rank_index = ARMY_RETURN_ERROR;
 }
 return false;
}

bool CGameArmy::ArmyAddTeamArray(const ARMY_GUID_OBJECT * _TeamObject)
{
 if (m_aGuidSet._guid_index != ARMY_RETURN_ERROR)
 {
  m_aGuidSet._guid_array[m_aGuidSet._guid_index] = const_cast<ARMY_GUID_OBJECT *>(_TeamObject);

  for (register unsigned int i = m_aGuidSet._guid_index + 1U; i < m_aGuidSet._guid_count; ++i)
  {
   if (NULL == m_aGuidSet._guid_array[i])
   {
    m_aGuidSet._guid_index = i;
    return true;
   }
  }
  for (register unsigned int i = 0U; i < m_aGuidSet._guid_index; ++i)
  {
   if (NULL == m_aGuidSet._guid_array[i])
   {
    m_aGuidSet._guid_index = i;
    return true;
   }
  }
  m_aGuidSet._guid_index = ARMY_RETURN_ERROR;
 }
 return false;
}

bool CGameArmy::ArmyAddSpaceTeamItem(ARMY_GUID_OBJECT * _TeamObject, const ARMY_ROLE_GUID * _RankGuid)
{
 if (_TeamObject->_rank_index != ARMY_RETURN_ERROR)
 {
  memcpy(&_TeamObject->_rank_guid[_TeamObject->_rank_index],_RankGuid, sizeof(ARMY_ROLE_GUID));
  return true;
 }
 return false;
}

bool CGameArmy::ArmyAddSpaceRankItem(ARMY_ROLE_OBJECT * _RankObject, const ARMY_ROLE_INTEGR * _RoleInte)
{
 if (_RankObject->_role_index != ARMY_RETURN_ERROR)
 {
  memcpy(&_RankObject->_role_inte[_RankObject->_role_index], _RoleInte, sizeof(ARMY_ROLE_INTEGR));
  return true;
 }
 return false;
}

void CGameArmy::ArmyClearRankArray(void)
{
 for (register unsigned int i = 0U; i < m_aRoleSet._rank_count; ++i)
 {
  if (m_aRoleSet._rank_array[i] != NULL)
  {
   free(m_aRoleSet._rank_array[i]);
   m_aRoleSet._rank_array[i] = NULL;
   continue;
  }
 }
 m_aRoleSet._rank_index = 0U;
}

void CGameArmy::ArmyClearTeamArray(void)
{
 for (register unsigned int i = 0U; i < m_aGuidSet._guid_count; ++i)
 {
  if (m_aGuidSet._guid_array[i] != NULL)
  {
   free(m_aGuidSet._guid_array[i]);
   m_aGuidSet._guid_array[i] = NULL;
   continue;
  }
 }
 m_aGuidSet._guid_index = 0U;
}

bool CGameArmy::ArmyIndexCallFunction(ARMY_ROLE_PROTOCOL * _hProtocol)
{
 //效验数据
 if (HEADLE_TYPE == (_hProtocol->_proto_headle & PROTOCOL_CHECK_VALUE))
 {
  //协议功能栈
  return (this->*(m_fIndex[MAKE_FINCTION_INDEX(_hProtocol->_proto_headle)]))(_hProtocol);
 }
 return this->ArmyNullFunction(_hProtocol); //异常数据处理
}