小火龙加强版

要求：见小火龙的代码配置化，即改变不同的配置文件，不动代码，根据客户端传递参数的不同，返回不同的兑换宝石数。

#include <iostream>
#include <string>
#include<map>
#include <vector>
#include <set>
#include <iterator>
#include <algorithm>
using namespace std;


//玩家剩余的包裹数目
const int spaceNum = 10;
//玩家包裹里水晶的数目
const int cryNum = 1;


//宝石的道具ID 
const int gemID = 799;
//水晶的道具ID 
const int crystalID = 800;
//小火龙的道具ID 
const int smallDragonID = 888;


/**
 * \brief 发送提示给玩家
 * @test 提示的内容
 */
void sendTextToUser(const string &text)
{
cout << text << endl;
}


/**
 * \brief 写日志到文件，以便查询相关错误日志信息
 * @log 日志的内容
 */
void writeLog(const string &log)
{
cout << "log:" << log << endl; 
}


struct exchangeGem_CS
{
int gemnum;
vector<int> aptitude;
set<int> grona_id;
//exchangeGem_CS()
//{
// objThisIDA = 0;
// objThisIDB = 0;
//}
//int objThisIDA;//道具A的唯一ID
//int objThisIDB;//道具B的唯一ID
};


struct item
{
int id;// 道具ID
int thisid;//道具唯一ID 
int aptitude;//资质
};


/**
 * \brief 玩家的包裹类
 */
struct package
{
/**
* \brief 获取包裹剩余空间
* @return 包裹剩余空间数目
*/
int getSpaceNum(){ return spaceNum;}


/**
* \brief 添加道具进包裹
* @itemID 道具ID
* @itemNum 道具数目
* @return 道具是否添加成功
*/
bool addItem(int itemID,int itemNum)
{
//中间有很长的代码，可能会返回false;
sendTextToUser("添加道具成功");
return true;
}


/**
* \brief 从包裹里扣除道具
* @itemID 道具ID
* @return 道具是否扣除成功
*/
bool removeItem(int itemID)
{
//中间有很长的代码，可能会返回false;
return true;
}

/**
* \brief 从包裹里扣除道具
* @thisid 道具指针
* @return 道具是否扣除成功
*/
bool removeItem(item* m_item)
{
if (m_item == NULL) return false;
itemMap.erase(m_item->thisid);
delete m_item;
m_item = NULL;
return true;
}


/**
* \brief 从包裹里扣除道具
* @itemID 道具ID
* @return 道具是否扣除成功
*/
int getItemNum(int itemID)
{
if (itemID == crystalID)
return cryNum;
return 0;
}



/**
* \brief 从包裹里获取道具指针
* @thisid 道具ID
* @return 道具指针
*/
item* getItemByThisID(const int thisid)
{
std::map<int,item*>::iterator it = itemMap.find(thisid);
if ((it != itemMap.end()) && (it->second != NULL))
return it->second;
return NULL;
}


bool addItem(item* m_item)
{
if (NULL == m_item || itemMap.find(m_item->thisid) != itemMap.end())
return false;


itemMap.insert(std::make_pair(m_item->thisid,m_item));
return true;
}
std::map<int,item*> itemMap;
};


/**
 * \brief 玩家类
 */
struct user
{
package pack;
};
/**
 *  假装为从置换宝石的规则
 */
bool Init_ve(vector<int> &ve)
{
ve.push_back(20);
ve.push_back(2);
ve.push_back(1);
ve.push_back(-1);
ve.push_back(50);
ve.push_back(2);
ve.push_back(2);
ve.push_back(-1);
ve.push_back(100);
ve.push_back(2);
ve.push_back(1);
ve.push_back(2);
ve.push_back(2);
ve.push_back(-1);
return true;
}
bool exchangeGem(exchangeGem_CS &cmd,user &m_user)
{
//确定没有被选中重复的小火龙
if(cmd.aptitude.size() != cmd.grona_id.size())
{
sendTextToUser("条件不足");
return false;
}
vector<int> ve;
if(!Init_ve(ve))
{
writeLog("init config.txt error\n");
return false;
}
item *tmp = NULL;
int i = 0;
set<int>::iterator it = cmd.grona_id.begin();


//检验传递参数是否为真，小火龙是否是小火龙，资质是否相同
while(it != cmd.grona_id.end())
{
tmp = m_user.pack.getItemByThisID(*it++);
if(!tmp || tmp->id != smallDragonID || tmp->aptitude != cmd.aptitude[i++])
{
sendTextToUser("条件不足");
return false;
}
tmp = NULL;
}
sort(cmd.aptitude.begin(),cmd.aptitude.end());

int totalsize = ve.size();
int j = 0;
i = 0;
int cmdsize = cmd.aptitude.size();
while(i < totalsize)
{
//如果请求宝石数相同并且资质相同则证明找到了兑换选项
if(cmd.gemnum == ve[i])
{
j = 0;
while(j < cmdsize)
{
int num = ve[++i];
int aptitude = ve[++i];
while(j < cmdsize && aptitude == cmd.aptitude[j++])
num--;
if(!num)
{
break;
}
}
if(j == cmdsize)
{
break;
}
}
else
while(i < totalsize && ve[++i] != -1);
i++;
}
if(j != cmdsize)
{
sendTextToUser("条件不足");
return false;
}

//删除小火龙
it = cmd.grona_id.begin();
while(it != cmd.grona_id.end())
{
tmp = m_user.pack.getItemByThisID(*it++);
if(!tmp || !m_user.pack.removeItem(tmp))
{
writeLog("delte error");
return false;
}
tmp = NULL;
}


//添加宝石
if(!m_user.pack.addItem(smallDragonID,cmd.gemnum))
{
writeLog("添加宝石失败");
return false;
}
return true;




/*
int size = cmd.ve.size();
if(size <= 3)
{
sendTextToUser("条件不足");
return false;
}
int gemIDnum = 0;
for(int i = 2; i <= size-1; )
{
int j = i+3 > size ? -1 : i+3;
if(j == -1)
break;
item* tmpa = m_user.pack.getItemByThisID(cmd.ve[i]);
item* tmpb = m_user.pack.getItemByThisID(cmd.ve[j]);
if(!tmpa || !tmpb || tmpa == tmpb)
{
sendTextToUser("条件不足");
return false;
}
if(!m_user.pack.removeItem(tmpa))
{
writeLog("删除%d失败",cmd.ve[i-1]);
return false;
}
if(!m_user.pack.removeItem(tmpb))
{
writeLog("删除%d失败",cmd.ve[j-1]);
return false;
}
gemIDnum += 20;
}
if(!m_user.pack.addItem(gemID,gemIDnum))
{
writeLog("宝石添加失败");
return false;
}




//if(cmd.objThisIDA == cmd.objThisIDB)
{
// writeLog("ID冲突");
// return false;
}
item* itemA = m_user.pack.getItemByThisID(cmd.objThisIDA);
item* itemB = m_user.pack.getItemByThisID(cmd.objThisIDB);
if(!itemA || !itemB || itemA->aptitude !=1 || itemB->aptitude !=1)
{
sendTextToUser("条件不足");
return false;
}
if(m_user.pack.getSpaceNum() < 2)
{
sendTextToUser("包裹空间不足");
return false;
}
if(!m_user.pack.removeItem(itemA))
{
writeLog("删除A失败");
return false;
}
if(!m_user.pack.removeItem(itemB))
{
writeLog("删除B失败");
return false;
}
if(!m_user.pack.addItem(gemID,100))
{
writeLog("添加宝石失败");
return false;
}
return true;
*/
}


int main()
{
//括号以内代码模拟 客户端消息发送到服务器解包以后，服务器处理逻辑的流程 返回0表示这个消息的处理逻辑结束 
/* 添加道具
* forExample
* user m_user;
         * m_user.addItem(1,1);
*/


//下面代码可认为是 之前玩家添加相关道具的过程。
user m_user;
item *dragon_1 = new item();
item *dragon_2 = new item();
if (dragon_1 && dragon_2)
{
dragon_1->id = smallDragonID;
dragon_1->thisid = 1001;
dragon_1->aptitude = 1;
dragon_2->id = smallDragonID;
dragon_2->thisid = 1000;
dragon_2->aptitude = 1;
}
m_user.pack.addItem(dragon_1);
m_user.pack.addItem(dragon_2);
//添加流程结束


//客户端发起请求流程
// exchangeGem_CS cmd;
// cmd.objThisIDA = 1000;
// cmd.objThisIDB = 1000;
// cmd.ve.push_back(1);//1个资质为2的小火龙，ID为3
// cmd.ve.push_back(2);
// cmd.ve.push_back(3);



exchangeGem_CS cmd;
cmd.gemnum = 20;
cmd.aptitude.push_back(2);
cmd.aptitude.push_back(1);
cmd.grona_id.insert(1001);
cmd.grona_id.insert(1000);




//服务器处理
exchangeGem(cmd,m_user);
return 0;
}


配置化就差最后一点，即将文本文档滞留出来，用户后序进行修改兑换的规则，而不用再去更改代码。

这个只需要一个文本文档，读取即可。