百度之星坦克大战代码Word文档格式.docx
《百度之星坦克大战代码Word文档格式.docx》由会员分享，可在线阅读，更多相关《百度之星坦克大战代码Word文档格式.docx（16页珍藏版）》请在冰点文库上搜索。
//标记目标矿点是否被己方锁定，存在则锁定
intpoint2id（introw,intcol）//节点编号
intid=row*（MAP_WIDTH+2）+col;
returnid;
}
Pointid2point（intid）//节点反编号
Pointpo;
po.row=id/（MAP_WIDTH+2）;
po.col=id%（MAP_WIDTH+2）;
returnpo;
//查找某vector表中是否有一节点
intfind（intid,vector<
vet）
if（vet.empty（））
return-1;
for（inti=0;
i<
vet.size（）;
i++）
if（id==vet[i].id）
{
returni;
}
return-1;
//查找当然位置在path[myID]中的index
intfindPathIdx（intid,vector<
pathT）
if（pathT.empty（））
pathT.size（）;
if（id==pathT[i]）
//返回从一节点到邻近节点的花费（坦克要走的步数）
//可通过PERVIOUS为1，BRICK为2，BREAKBRICK为3
intaddcost（CellTypetype）
switch（type）{
casePERVIOUS:
return1;
break;
caseBRICK:
return2;
default:
return3;
//对给定扩展点进行检测添加
voidaddExtNode（nodetmpNode,intextid,CellTypetype）
PointextPo;
nodeextNode;
extPo=id2point（extid）;
if（（-1==find（extid,closedT））&
&
（STONE!
=type））//要扩展点不在closed表中，且不为石头则扩展
intidx=find（extid,openT）;
//在open表中的索引
if（-1==idx）//如果不在open表中则添加
extNode.id=extid;
extNode.father=tmpNode.id;
extNode.cost=tmpNode.cost+addcost（type）;
openT.push_back（extNode）;
}
else//如果在open表中，看新路径是否更近，近则修改
if（tmpNode.cost+addcost（type）<
openT[idx].cost）
openT[idx].father=tmpNode.id;
openT[idx].cost=tmpNode.cost+addcost（type）;
}
//得到本坦克的路径
voidgetPath（intmyID,intgoalIdx）
//id为myID的坦克路径存于path[myID]中
path[myID].clear（）;
nodetmpNode=openT[goalIdx];
path[myID].insert（path[myID].begin（）,tmpNode.id）;
/*
Pointdebug_po=id2point（tmpNode.id）;
printf（"
PathStar!
\nGoal（%d,%d）\n"
debug_po.row,debug_po.col）;
*/
while（-1!
=tmpNode.father）
inttmpIdx=find（tmpNode.father,closedT）;
//printf（"
%d"
tmpIdx）;
if（-1!
=tmpIdx）
tmpNode=closedT[tmpIdx];
/*
Pointdebug_po=id2point（tmpNode.id）;
printf（"
（%d,%d）\n"
*/
path[myID].insert（path[myID].begin（）,tmpNode.id）;
else
path[myID].clear（）;
return;
//根据下一步目标返回：
方向运动指令
OrderTypegetOrder（FlagTypemyFlag,PointmySite,PointnextStep）
introwD=nextStep.row-mySite.row;
rowD）;
intcolD=nextStep.col-mySite.col;
colD）;
switch（rowD）
case-1:
returnGOUP;
case1:
returnGODOWN;
;
switch（colD）
returnGOLEFT;
returnGORIGHT;
returnSTOP;
//A*寻路算法，路径存储在path[myID]中
voidaStar（intmyID,Pointstart,Pointgoal,MapCellmap[][MAP_WIDTH+2]）
openT.clear（）;
closedT.clear（）;
//1.把初始节点放入openT
nodetmpNode;
tmpNode.id=point2id（start.row,start.col）;
tmpNode.father=-1;
//初始节点无父节点
tmpNode.cost=0;
openT.push_back（tmpNode）;
//2.如果openT为空，搜索失败退出
boolfindGoal=false;
while（!
openT.empty（）&
!
findGoal）
tmpNode=openT[0];
intno=0;
//记录最小f（x）的索引
//3.移除openT中f（x）值最小的
Pointp1=id2point（tmpNode.id）;
//当前考察点位置
inthx1=abs（goal.row-p1.row）+abs（goal.col-p1.col）;
//当前路径cost
intfx1=hx1+tmpNode.cost;
//寻找f（x）最小的节点
for（inti=0;
openT.size（）;
nodetmpNode2=openT[i];
Pointp2=id2point（tmpNode2.id）;
inthx2=abs（goal.row-p2.row）+abs（goal.col-p2.col）;
intfx2=hx2+tmpNode2.cost;
if（fx1>
fx2）
tmpNode=openT[i];
no=i;
//如果节点为目标节点，则路径找到，返回路径
if（point2id（goal.row,goal.col）==tmpNode.id）
//存储路径
getPath（myID,no）;
//当目标在open中，得到的最小f（x）的点是目标节点索引为no
//从openT移节点如closedT中
openT.erase（openT.begin（）+no）;
closedT.push_back（tmpNode）;
//4.从四个方向扩展节点
PointtmpPo;
tmpPo=id2point（tmpNode.id）;
intextid;
CellTypetype;
//上
extid=point2id（tmpPo.row-1,tmpPo.col）;
type=（map[tmpPo.row-1][tmpPo.col]）.type;
addExtNode（tmpNode,extid,type）;
//下
extid=point2id（tmpPo.row+1,tmpPo.col）;
type=（map[tmpPo.row+1][tmpPo.col]）.type;
//左
extid=point2id（tmpPo.row,tmpPo.col-1）;
type=（map[tmpPo.row][tmpPo.col-1]）.type;
//右
extid=point2id（tmpPo.row,tmpPo.col+1）;
type=（map[tmpPo.row][tmpPo.col+1]）.type;
//平台0回合时调用此函数获取AI名称及坦克类型信息，请勿修改此函数声明。
extern"
C"
InitiateInfochooseType（）
InitiateInfoInfo;
Info.tank[0]=Pioneer;
Info.tank[1]=Sniper;
Info.tank[2]=Pioneer;
Info.tank[3]=Sniper;
Info.tank[4]=Pioneer;
strcpy（Info.aiName,"
AISeminar_cn"
）;
//AI名请勿使用中文。
targeted.clear（）;
returnInfo;
//平台从第1回合开始调用此函数获得每回合指令，请勿修改此函数声明。
OrdermakeOrder（DataForAIdata）
Orderorder;
PointmySite;
//获得当前坦克位置
intmyID=data.myID;
inttankType=data.tank[myID].type;
//获得自己的坐标点
mySite.row=data.tank[myID].row;
mySite.col=data.tank[myID].col;
//获得自己的资源类型
intmySrcType;
switch（data.myFlag）
caseRED:
mySrcType=RedSource;
caseBLUE:
mySrcType=BlueSource;
//获得自己的射程
intactDist;
switch（tankType）
caseSniper:
actDist=5;
caseStriker:
actDist=3;
actDist=1;
//获取敌方坦克位置信息（行列的第0、MAP_WIDTH+1处为墙）
//如果，在攻击范围内，则攻击
for（intmCol=1;
mCol<
MAP_WIDTH+1;
mCol++）
for（intmRow=1;
mRow<
MAP_HEIGHT+1;
mRow++）
inttankIdx=data.map[mRow][mCol].whoIsHere;
if（tankIdx!
=-1&
data.tank[tankIdx].flag!
=data.myFlag）
inttankDist=abs（data.tank[tankIdx].row-mySite.row）+abs（data.tank[tankIdx].col-mySite.col）;
if（tankDist<
=actDist）
order.type=FIRE;
order.row=mRow;
order.col=mCol;
returnorder;
//不进行攻击时，获取矿点信息
//命令构造：
如果攻击范围内有坦克，先攻击，在寻路
intidx=findPathIdx（point2id（mySite.row,mySite.col）,path[myID]）;
boolneedPath=false;
if（path[myID].empty（））//不在存储路径中
needPath=true;
else
intendIdx=path[myID].size（）-1;
PointendPo=id2point（path[myID][endIdx]）;
//查找目标是否已经是己方占领
if（（-1==idx）||（endIdx==idx）||（（data.map[endPo.row][endPo.col]）.isHereSource==mySrcType））
targeted.erase（point2id（endPo.row,endPo.col））;
//当前位置不存在路径中，或已经达到目标、或目标点已经是己方则重新计算路径
while（needPath||（-1==idx））
{
//获得离自己最近的非己方矿点位置
PointgoalSite;
//目标坐标点
goalSite.row=data.source[0].row;
//防止目标全部被锁定，无目标时传递给astar的数据出错
goalSite.col=data.source[0].col;
intmy2srcDist=MAP_WIDTH*MAP_WIDTH+MAP_HEIGHT*MAP_HEIGHT;
//记录与最近非己方资源的距离（直线距离平方，“行距+列距”效果不好，初始最大）
//寻找“距离本坦克最近”的非己方矿点（**且“自己在己方中也是最近”）
data.totalSource;
inttempSR=data.source[i].row;
inttempSC=data.source[i].col;
intsrcID=point2id（tempSR,tempSC）;
//在矿点非己方时，且矿点未被己方坦克锁定时（锁定表中不存在），规划路径
if（（（data.map[tempSR][tempSC]）.isHereSource!
=mySrcType）&
（targeted.find（srcID）==targeted.end（）））
//inttempDist=abs（tempSR-mySite.row）+abs（tempSC-mySite.col）;
inttempDist=（tempSR-mySite.row）*（tempSR-mySite.row）+（tempSC-mySite.col）*（tempSC-mySite.col）;
if（tempDist<
my2srcDist）
my2srcDist=tempDist;
goalSite.row=tempSR;
goalSite.col=tempSC;
//如果目标未被锁定则加入锁定表，如果已锁定，说明无满足条件者
if（targeted.find（point2id（goalSite.row,goalSite.col））==targeted.end（））
targeted.insert（point2id（goalSite.row,goalSite.col））;
Tand%d-Goal:
（%d,%d）\n"
myID,goalSite.row,goalSite.col）;
//debug!
//A*寻路
aStar（myID,mySite,goalSite,&
（data.map[0]））;
needPath=false;
//*显示路径debug
for（intpi=0;
pi<
path[0].size（）;
pi++）
Pointdebug_po=id2point（path[0][pi]）;
//*/
//寻找当前位置在path中的索引
idx=findPathIdx（point2id（mySite.row,mySite.col）,path[myID]）;
//路径判断后进行命令处理
PointnextStep=id2point（path[myID][idx+1]）;
if（PERVIOUS!
=（data.map[nextStep.row][nextStep.col]）.type）//如果路径不是可通过的，则轰炸
order.row=nextStep.row;
order.col=nextStep.col;
order.type=getOrder（data.myFlag,mySite,nextStep）;
returnorder;
升级会员 