应该经过的多次扩张
//
void ExpandTimes(GoChessApp* pMe,BYTE nCount)
{
BYTE nX = 0;
for(nX = 0; nX {
Expand(pMe);
}
}
应该经过的多次侵蚀
void ErodeTimes(GoChessApp* pMe,BYTE nCount)
{
BYTE nX = 0;
for(nX = 0; nX {
Erode(pMe);
}
}
//扩张
void Expand(GoChessApp* pMe)
{
int nX = 0;
int nY = 0;
//return;
for(nX = 0;nX < PLANE_COL;nX ++)
{
for(nY = 0;nY {
/对四周的每一个点进行判断了.
if(pMe->WorldCell[nX][nY].bwColor ==BW_BLACK)
{
if(pMe->WorldCell[nX][nY].nWhite ==0)
pMe->WorldCell[nX][nY].nBPower += pMe->WorldCell[nX][nY].nBlack;
}
else if(pMe->WorldCell[nX][nY].bwColor ==BW_WHITE)
{
if(pMe->WorldCell[nX][nY].nBlack ==0)
pMe->WorldCell[nX][nY].nWPower += pMe->WorldCell[nX][nY].nWhite ;
}
else
{
pMe->WorldCell[nX][nY].nBPower += pMe->WorldCell[nX][nY].nBlack;
pMe->WorldCell[nX][nY].nWPower += pMe->WorldCell[nX][nY].nWhite ;
}
}
}
return;
}
侵蚀
void Erode(GoChessApp* pMe)
{
///
///
int nX = 0;
int nY = 0;
//return;
for(nX = 0;nX < PLANE_COL;nX ++)
{
for(nY = 0;nY {
/对四周的每一个点进行判断了.
if(pMe->WorldCell[nX][nY].bwColor ==BW_BLACK)
{
pMe->WorldCell[nX][nY].nBPower -= pMe->WorldCell[nX][nY].nWhite;
if(pMe->WorldCell[nX][nY].nBPower<0)
pMe->WorldCell[nX][nY].nBPower=0;
}
else
{
pMe->WorldCell[nX][nY].nWPower -= pMe->WorldCell[nX][nY].nBlack;
if(pMe->WorldCell[nX][nY].nWPower<0)
pMe->WorldCell[nX][nY].nWPower=0;
}
}
}
return;
}
///设置配置
void SetGoConfig(GoChessApp* pMe)
{
/临时设置了
pMe->bHost =TRUE; 假设为桌主
pMe->bLetOpp =FALSE; //不进行让子
pMe->bwCurColor =BW_BLACK; //我方执黑进行了.
pMe->GoTime = 10*Minu_Sec;//10分钟
pMe->LetNum =0;
pMe->playerMe.bThink =TRUE;
pMe->playerMe.bwColor = BW_BLACK;
pMe->playerMe.nTime = 0;
pMe->playerMe.posLast.x = INVALID_POS;
pMe->playerMe.posLast.y = INVALID_POS;
pMe->playerMe.pWho=PLAYER_ME ; ///le
pMe->playerMe.nOutTime =0;
pMe->playerMe.bTimeOut =FALSE;
pMe->playerOpp.bThink =FALSE;
pMe->playerOpp.bwColor = BW_WHITE;
pMe->playerOpp.nTime = 0;
pMe->playerOpp.posLast.x = INVALID_POS;
pMe->playerOpp.posLast.y = INVALID_POS;
pMe->playerOpp.pWho=PLAYER_COMPUTER ; ///le
pMe->playerOpp.nOutTime =0;
pMe->playerOpp.bTimeOut =FALSE;
/
return;
}
///让子配置
void GiveNumFirst(GoChessApp* pMe,BYTE nCount)
{
return;
}
设置时间
void SetGoTime(GoChessApp* pMe)
{
return;
}
void DrawBoard(GoChessApp* pMe) //显示棋盘
{
int nX = 0;
AEELine line;
//AEERect rectBoard;
///
IDISPLAY_DrawRect(pMe->pi.m_pIDisplay,
&(pMe->stGameRect ), MAKE_RGB(0, 0,0), MAKE_RGB(224, 128,64),
IDF_RECT_FILL);
///
IDISPLAY_DrawRect(pMe->pi.m_pIDisplay,
&(pMe->stInfoRect ), MAKE_RGB(0, 0,0), MAKE_RGB(255, 128,128),
IDF_RECT_FILL);
IGRAPHICS_SetColor(pMe->m_pGraphic, 0, 0, 0, 0);
for(nX = 0; nX {
line.sx = pMe->stGameRect.x + CELL_SIZE + nX * CELL_SIZE ;
line.sy = pMe->stGameRect.y + CELL_SIZE ;
line.ex = line.sx;
line.ey = pMe->stGameRect.y + CELL_SIZE + CELL_SIZE*(PLANE_ROW-1);
IGRAPHICS_DrawLine(pMe->m_pGraphic ,&line);
line.sx = pMe->stGameRect.x + CELL_SIZE ;
line.sy = pMe->stGameRect.y + CELL_SIZE + nX * CELL_SIZE;
line.ex = pMe->stGameRect.x + CELL_SIZE + CELL_SIZE*(PLANE_COL-1);
line.ey = line.sy;
IGRAPHICS_DrawLine(pMe->m_pGraphic ,&line);
}
//IGRAPHICS_Update(pMe->m_pGraphic);
}
void DrawChess(GoChessApp* pMe)
{
AEECircle circle;
int nX = 0;
int nY = 0;
circle.r = CELL_R ;
for(nX = 0;nX< PLANE_COL;nX ++)
{
for(nY = 0;nY< PLANE_ROW;nY ++)
{
开始画吧.
circle.cx = pMe->stGameRect.x + CELL_SIZE +nX*CELL_SIZE;
circle.cy = pMe->stGameRect.y + CELL_SIZE +nY*CELL_SIZE;
switch(pMe->WorldCell[nX][nY].bwColor)
{
case BW_BLACK:
IGRAPHICS_SetColor(pMe->m_pGraphic, 0, 0, 0, 0);
IGRAPHICS_SetFillColor(pMe->m_pGraphic, 0, 0, 0, 0);
// IGRAPHICS_SetFillMode(pMe->m_pGraphic , TRUE);
IGRAPHICS_DrawCircle(pMe->m_pGraphic , &circle);
break;
case BW_WHITE:
IGRAPHICS_SetColor(pMe->m_pGraphic, 255, 255, 255, 0);
IGRAPHICS_SetFillColor(pMe->m_pGraphic, 255, 255, 255, 0);
// IGRAPHICS_SetFillMode(pMe->m_pGraphic , TRUE);
IGRAPHICS_DrawCircle(pMe->m_pGraphic , &circle);
break;
default:
break;
}
}
}
//IGRAPHICS_Update(pMe->m_pGraphic);
}
void DrawChessFace(GoChessApp* pMe) /// 显示关于整个界面的东西.
{
IDISPLAY_ClearScreen(pMe->pi.m_pIDisplay);
///
IGRAPHICS_SetFillMode(pMe->m_pGraphic , TRUE);
DrawBoard(pMe);
DrawChess(pMe);
DrawGoInfo(pMe);
IGRAPHICS_Update(pMe->m_pGraphic);
//IDISPLAY_Update(pMe->pi.m_pIDisplay);
}
void DrawGoInfo(GoChessApp* pMe) ///显示走棋信息.
{
显示当前选标的位置.
int nX = 0 ;
int nY = 0 ;
int nDiv0 = 0;
int nLeft0 = 0;
int nDiv1 = 0;
int nLeft1 = 0;
AEECircle circle;
AEETriangle triAngle; //三角行了.
AEERect rectSel;
rectSel.x = pMe->stGameRect.x +CELL_SIZE +pMe->SelectPos.x* CELL_SIZE -CELL_R ;
rectSel.y = pMe->stGameRect.y +CELL_SIZE +pMe->SelectPos.y* CELL_SIZE -CELL_R ;
rectSel.dx = CELL_SIZE;
rectSel.dy = CELL_SIZE;
IDISPLAY_DrawRect(pMe->pi.m_pIDisplay,
&rectSel, MAKE_RGB(0,255,255), MAKE_RGB(0, 0,0),
IDF_RECT_FRAME);
///最近走得位置了.
if(pMe->JustGo.x != INVALID_POS)
{
triAngle.x0= 1 + pMe->stGameRect.x +CELL_SIZE +pMe->JustGo.x* CELL_SIZE -CELL_R ;
triAngle.y0= 1 + pMe->stGameRect.y +CELL_SIZE +pMe->JustGo.y* CELL_SIZE -CELL_R ;
triAngle.x1= 5 + pMe->stGameRect.x +CELL_SIZE +pMe->JustGo.x* CELL_SIZE -CELL_R ;
triAngle.y1= 1 + pMe->stGameRect.y +CELL_SIZE +pMe->JustGo.y* CELL_SIZE -CELL_R ;
triAngle.x2= 3 + pMe->stGameRect.x +CELL_SIZE +pMe->JustGo.x* CELL_SIZE -CELL_R ;
triAngle.y2= 6 + pMe->stGameRect.y +CELL_SIZE +pMe->JustGo.y* CELL_SIZE -CELL_R ;
///
IGRAPHICS_SetColor(pMe->m_pGraphic, 255, 0, 0, 0);
IGRAPHICS_SetFillColor(pMe->m_pGraphic, 255, 0, 0, 0);
// IGRAPHICS_SetFillMode(pMe->m_pGraphic , TRUE);
IGRAPHICS_DrawTriangle(pMe->m_pGraphic ,&triAngle);
}
nX = (pMe->stInfoRect.dx >>3);
nY = pMe->stInfoRect.y + (pMe->stInfoRect.dy>>2); /显示时间了.
nDiv0 = pMe->GoTime / Minu_Sec;
nLeft0= pMe->GoTime % Minu_Sec;
ShowNum(pMe,(pMe->stInfoRect.dx>>1)-3*Num_W,pMe->stWorldRect.dy - Num_H -2,nDiv0);
ShowNum(pMe,(pMe->stInfoRect.dx>>1),pMe->stWorldRect.dy - Num_H -2,nLeft0);
nDiv0 = pMe->playerMe.nTime/Minu_Sec;
nLeft0 = pMe->playerMe.nTime%Minu_Sec;
nDiv1 = pMe->playerOpp.nTime/Minu_Sec;
nLeft1 = pMe->playerOpp.nTime%Minu_Sec;
if(pMe->playerMe.bwColor ==BW_BLACK)
{
ShowNum(pMe,nX,nY,nDiv0);
ShowNum(pMe,nX+Num_W*3,nY,nLeft0);
ShowNum(pMe,nX+(pMe->stInfoRect.dx >>1) ,nY,nDiv1);
ShowNum(pMe,nX+(pMe->stInfoRect.dx >>1)+Num_W*3 ,nY,nLeft1);
}
else
{
ShowNum(pMe,nX,nY,nDiv1);
ShowNum(pMe,nX+Num_W*3,nY,nLeft1);
ShowNum(pMe,nX+(pMe->stInfoRect.dx >>1) ,nY,nDiv0);
ShowNum(pMe,nX+(pMe->stInfoRect.dx >>1)+Num_W*3 ,nY,nLeft0);
}
//
circle.r = (pMe->stInfoRect.dy>>2);
circle.cx= (pMe->stInfoRect.dx >>2) ;
circle.cy= nY+ (pMe->stInfoRect.dy>>1);
IGRAPHICS_SetColor(pMe->m_pGraphic, 0, 0, 0, 0);
IGRAPHICS_SetFillColor(pMe->m_pGraphic, 0, 0, 0, 0);
IGRAPHICS_DrawCircle(pMe->m_pGraphic , &circle);
//circle.r = ;
//circle.r = (pMe->stInfoRect.dy>>1);
circle.cx= (pMe->stInfoRect.dx >>2) + (pMe->stInfoRect.dx>>1)-circle.r;
//circle.cy= nY+ (pMe->stInfoRect.dy>>1);
IGRAPHICS_SetColor(pMe->m_pGraphic, 255, 255, 255, 0);
IGRAPHICS_SetFillColor(pMe->m_pGraphic, 255, 255, 255, 0);
IGRAPHICS_DrawCircle(pMe->m_pGraphic , &circle);
//
}
///
void Go_StartNewGame(GoChessApp* pMe)
{
pMe->gCurWin = WINDOWS_PLAY;
ResetGameData(pMe);
DrawChessFace(pMe);
SetGoConfig(pMe);
//根据设置问题进行处理了.
///看看谁先处理走.
///如果让子的话,不一定是白棋了.
CountTime(pMe);
return;
}
///
void CountTime(GoChessApp* pMe) //哈哈,计时了.
{
if(pMe->gCurWin ==WINDOWS_PLAY)
{
if(pMe->playerMe.bThink )
{
if(!pMe->playerMe.bTimeOut )
{
if(pMe->playerMe.nTime< pMe->GoTime)
pMe->playerMe.nTime ++;
else
pMe->playerMe.bTimeOut =TRUE;
}
else
{
if(pMe->playerMe.nOutTime< READSECOND )
pMe->playerMe.nOutTime++;
else
{
///
///判我方负棋
}
}
}
if(pMe->playerOpp.bThink )
{
if(!pMe->playerOpp.bTimeOut)
{
if(pMe->playerOpp.nTime GoTime )
pMe->playerOpp.nTime ++;
else
pMe->playerOpp.bTimeOut =TRUE;
}
else
if(pMe->playerOpp.nOutTime< READSECOND )
pMe->playerOpp.nOutTime++;
else
{
///
///判敌方超时负
}
}
}
DrawChessFace(pMe);
ISHELL_SetTimer(pMe->pi.m_pIShell, COUNTTIME_UNIT, (PFNNOTIFY)CountTime, (void*)pMe);
return;
}
//不直接显示数字,通过图来组合数字
void ShowNum(GoChessApp * pMe ,int x,int y,int nNum)
{
int i = 0,tmp,k;
BYTE ucTmp[10];
tmp = nNum;
if(nNum == 0)
{
IDISPLAY_BitBlt(pMe->pi.m_pIDisplay, x , y, Num_W, Num_H,(void*)pMe->m_pBmpNum,0,0,AEE_RO_COPY | AEE_RO_TRANSPARENT );
}
else
{
while(tmp)
{
ucTmp[i] = tmp % 10;
tmp = tmp/10;
i++;
}
for(k=0;k {
IDISPLAY_BitBlt(pMe->pi.m_pIDisplay,
x + k*(Num_W), //Des_x
y, //Des_y
Num_W, Num_H, //Length and high
(void*)pMe->m_pBmpNum,
Num_W * ucTmp[i-k-1], //Src_x
0, //Src_y
AEE_RO_COPY | AEE_RO_TRANSPARENT);
}
}
}
//播放声音文件
void PlayFile(GoChessApp * pMe,char *szFile)
{
if(!pMe->bSound)
return;
ISOUNDPLAYER_Stop(pMe->m_pISoundPlayer);
ISOUNDPLAYER_SetVolume(pMe->m_pISoundPlayer, AEE_MAX_VOLUME);
ISOUNDPLAYER_Set(pMe->m_pISoundPlayer, SDT_FILE, (void *)szFile);
ISOUNDPLAYER_Play(pMe->m_pISoundPlayer);
return ;
}
void SetSound(GoChessApp*pMe) //开关声音设置
{
if(pMe->bSound)
{
pMe->bSound = FALSE;
ISOUNDPLAYER_RegisterNotify(pMe->m_pISoundPlayer,NULL,(void*)pMe);
ISOUNDPLAYER_Stop(pMe->m_pISoundPlayer);
}
else
{
pMe->bSound = TRUE;
}
}
//
BOOL IfKillTheBunCh(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor) 有气返回TRUE ,无效的全部是FALSE
{
BOOL bHaveGas =FALSE;
if((nX<0)||(nY<0)||(nX>=PLANE_COL)||(nY>=PLANE_ROW))
return FALSE;
if(pMe->WorldCell[nX][nY].bFind) ///
return FALSE;
if(pMe->WorldCell[nX][nY].bwColor==bwColor) ///自身的无作用吧.
{
///设置为搜索过吗?
///等于自身的颜色,当然不用管了.
return FALSE;
}
else if(pMe->WorldCell[nX][nY].bwColor==BW_NONE) ///起到了作用哦. 只有刚开始才可能碰到,后面决无可能了.
{
///设置为搜索过吧?,就说刚开始的无效了.不用继续判断下去了.
return FALSE;
}
else
{
/
//判断是否有气
if(pMe->WorldCell[nX][nY].gas >0 )
{
///如果有气的话,就好了.
return TRUE;
}
else
{
/设置为有效了.
pMe->WorldCell[nX][nY].bFind =TRUE;
/
///判断它的每一个临界点
if(IfKillTheBunCh(pMe,nX-1,nY,bwColor)) ///左
{
return TRUE;
}
if(IfKillTheBunCh(pMe,nX+1,nY,bwColor)) //右
{
return TRUE;
}
if(IfKillTheBunCh(pMe,nX,nY-1,bwColor)) //上
{
return TRUE;
}
if(IfKillTheBunCh(pMe,nX,nY+1,bwColor)) //下
{
return TRUE;
}
return FALSE;
}
}
return FALSE;
}
//
void KillPoint(GoChessApp * pMe,int nX,int nY)
{
/杀死某个点,就应该考虑其他问题了.
if(pMe->WorldCell[nX][nY].bwColor==BW_NONE)
{
return;
}
else
{
KillNeighborEffect(pMe,nX -1,nY,pMe->WorldCell[nX][nY].bwColor);
KillNeighborEffect(pMe,nX +1,nY,pMe->WorldCell[nX][nY].bwColor);
KillNeighborEffect(pMe,nX ,nY-1,pMe->WorldCell[nX][nY].bwColor);
KillNeighborEffect(pMe,nX ,nY+1,pMe->WorldCell[nX][nY].bwColor);
}
pMe->WorldCell[nX][nY].bwColor = BW_NONE;
pMe->WorldCell[nX][nY].gas = 0 ;
return;
}
/
void KillNeighborEffect(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor)
{
if((nX<0)||(nY<0)||(nX>=PLANE_COL)||(nY>=PLANE_ROW))
return ;
if(bwColor==BW_BLACK)
{
pMe->WorldCell[nX][nY].nBlack --;
pMe->WorldCell[nX][nY].nBPower --;
}
else
{
pMe->WorldCell[nX][nY].nWhite --;
pMe->WorldCell[nX][nY].nWPower --;
}
pMe->WorldCell[nX][nY].gas ++;
return;
}
void SetAllNeighborEffect(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor)
{
SetNeighborEffect(pMe,nX -1, nY,bwColor);
SetNeighborEffect(pMe,nX +1, nY,bwColor);
SetNeighborEffect(pMe,nX , nY-1,bwColor);
SetNeighborEffect(pMe,nX , nY+1,bwColor);
return;
}
void SetNeighborEffect(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor)
{
if((nX<0)||(nY<0)||(nX>=PLANE_COL)||(nY>=PLANE_ROW))
return ;
if(bwColor==BW_BLACK)
{
pMe->WorldCell[nX][nY].nBlack ++;
pMe->WorldCell[nX][nY].nBPower ++;
}
else
{
pMe->WorldCell[nX][nY].nWhite ++;
pMe->WorldCell[nX][nY].nWPower ++;
}
pMe->WorldCell[nX][nY].gas --;
return;
}
//
void KillBunch(GoChessApp * pMe)
{
/
int nX = 0;
int nY = 0;
for(nX = 0;nX< PLANE_COL;nX ++)
{
for(nY = 0;nY< PLANE_ROW;nY ++)
{
if(pMe->WorldCell[nX][nY].bFind )
KillPoint(pMe,nX,nY);
}
}
/
}
///
void SetPointValue(GoChessApp* pMe,POINT point,BWCOLOR bwColor)
{
pMe->WorldCell[point.x][point.y].bwColor = bwColor ;
if(bwColor==BW_BLACK)
{
pMe->WorldCell[point.x][point.y].nBPower = GOCHESS_VALUE ;
}
else
{
pMe->WorldCell[point.x][point.y].nWPower = GOCHESS_VALUE ;
}
return;
}
///
BWCOLOR WhoWinTheGame(GoChessApp* pMe )
{
BWCOLOR bwColor =BW_NONE;
return bwColor;
}
void Go_GameOver(GoChessApp* pMe)
{
ISHELL_CancelTimer(pMe->pi.m_pIShell, NULL, (void*)pMe);
return;
}
void Go_JudgeSituation(GoChessApp* pMe)
{
//判断哪个串是否死亡了?
return;
}
BOOL IfPointInDepend(GoChessApp* pMe,POINT point,BWCOLOR bwColor) /判断该串是否是独立的.
{
///四周的问题了.
if(IfSameColor(pMe,point.x-1,point.y,bwColor))
return FALSE;
if(IfSameColor(pMe,point.x+1,point.y,bwColor))
return FALSE;
if(IfSameColor(pMe,point.x,point.y-1,bwColor))
return FALSE;
if(IfSameColor(pMe,point.x,point.y+1,bwColor))
return FALSE;
看看四周有没有
return TRUE;
}
void ConnectBunch(GoChessApp* pMe,int Bound1,int Bound2,BWCOLOR bwColor) 高的连成低的.
{
/
int nX = 0;
int nY = 0;
int nBig = 0 ;
int nSmall = 0;
nBig = MAX(nBig,nSmall);
nSmall = MIN(nBig,nSmall);
for(nX = 0;nX< PLANE_COL;nX ++)
{
for(nY = 0;nY< PLANE_ROW;nY ++)
{
if(pMe->WorldCell[nX][nY].nBunch > nBig ) ///大于大的再说吧
pMe->WorldCell[nX][nY].nBunch--;
if(pMe->WorldCell[nX][nY].nBunch == nBig ) ///等于的则自动减少了.
pMe->WorldCell[nX][nY].nBunch = nSmall;
}
}//
//ConnectResult(pMe,Bound,bwColor);
return ;
}
void ConnectResult(GoChessApp* pMe,int Bound,BWCOLOR bwColor) 重新计算各方面的问题了.
{
重新计算了气了.
int nX = 0;
int nY = 0;
for(nX = 0;nX< PLANE_COL;nX ++)
{
for(nY = 0;nY< PLANE_ROW;nY ++)
{
}
}//
return ;
}
int CountBunchOutGas(GoChessApp* pMe,int Bound,BWCOLOR bwColor) /判断该串的气数.主要是外围吧
{
return 0;
}
int CountBunchTrueEyes(GoChessApp* pMe,int Bound,BWCOLOR bwColor)
{
return 0;
}
int CountBunchFalseEyes(GoChessApp* pMe,int Bound,BWCOLOR bwColor) /
{
return 0;
}
BOOL IfBunchDead(GoChessApp* pMe,int Bound,BWCOLOR bwColor)
{
///
///
return TRUE;
}
判断是否越界了.
BOOL IfOverFlow(GoChessApp* pMe,int nX,int nY )
{
if((nX<0)||(nY<0)||(nX>=PLANE_COL)||(nY>=PLANE_ROW))
return TRUE;
else
return FALSE;
return FALSE;
}
BOOL IfSameColor(GoChessApp* pMe,int nX,int nY ,BWCOLOR bwColor)
{
if(IfOverFlow(pMe,nX,nY))
return FALSE;
else
{
if(pMe->WorldCell[nX][nY].bwColor ==bwColor )
return TRUE;
else
return FALSE;
}
}
///一个串是不可能断开的.但是需要考虑是否把一个空地域分为了两部分
void DisConnectArea(GoChessApp* pMe,int nX,int nY ,BWCOLOR bwColor)
{
}
///要好好的判断每一个串是否可以轻松做活了.
BOOL IfIsLastConnectPoint(GoChessApp* pMe,int nX,int nY)
{
return TRUE;
}
/
void AddNewBunch(GoChessApp* pMe,int nX,int nY,BWCOLOR bwColor)
{
//
switch(bwColor)
{
case BW_BLACK://
pMe->WorldCell[nX][nY].nBunch = pMe->nBlackBunch ++;
break;
case BW_WHITE:
pMe->WorldCell[nX][nY].nBunch = pMe->nWhiteBunch ++;
break;
case BW_NONE:///比较麻烦哦.
break;
}
//
}
/
BOOL IfGasBunchDisConnect(GoChessApp* pMe,int nX,int nY,BWCOLOR bwColor)
{
/判断四周有没有相同的空白串,有的话,就分开了.
//由于至少有两个方向有气,
return TRUE;
}
/
BOOL DisConnectGasArea(GoChessApp* pMe,int nX1,int nY1,int nX2,int nY2) //qi
{
if(IfOverFlow(pMe,nX1,nY1)||IfOverFlow(pMe,nX2,nY2)) ///有任意一个越界不考虑
return FALSE;
if((pMe->WorldCell[nX1][nY1].bwColor !=BW_NONE)||(pMe->WorldCell[nX2][nY2].bwColor !=BW_NONE)) //有任何一个则不空也不考虑了.
{
///
return FALSE;
}
if(pMe->WorldCell[nX1][nY1].nBunch ==pMe->WorldCell[nX2][nY2].nBunch )
{
//要判断一下里面的东西,能不能联系在一起?
//
return TRUE;
}
else
return FALSE;
}
/
BOOL IfCanConnectPoints(GoChessApp* pMe,int nX1,int nY1,int nX2,int nY2)
{
//是不是用A*算法好点?此处不要找出路径,只需要判断,是否可以连接?
FINDDATACHAIN * pAreaNew1 =NULL;
FINDDATACHAIN * pAreaOld1 =NULL;
FINDDATACHAIN * pAreaNew2 =NULL;
FINDDATACHAIN * pAreaOld2 =NULL;
if(IfOverFlow(pMe,nX1,nY1)||IfOverFlow(pMe,nX2,nY2)) ///有任意一个越界不考虑
return FALSE;
ReSetFindData(pMe); /
/
///将查询的新节点加入新节点集.
///
//看看节点二 的新节点急有没有节点;
///将查询的新节点加入新节点集.
///
//看看节点二 的新节点急有没有节点;
/
return TRUE;
}
//
int CountValue(GoChessApp* pMe,int nX1,int nY1,int nX2,int nY2)
{
return (ABS(nX1-nX2)+ABS(nY1-nY2));
}
//
BOOL AddFindDataCell(GoChessApp* pMe,FINDDATACHAIN * pFindDataChain,int nX,int nY,int nDestX,int nDestY,BOOL bHead)
{
FINDDATACHAIN * pFindDataCell =NULL;
pFindDataCell = (FINDDATACHAIN *)MALLOC(sizeof(FINDDATACHAIN));
if(pFindDataCell)
{
pFindDataCell->findData.nValue =CountValue(pMe,nX,nY,nDestX,nDestY);
pFindDataCell->findData.nX = nX;
pFindDataCell->findData.nY = nY;
/
}
else
return FALSE;
return TRUE;
}
void ReleaseFindData(GoChessApp* pMe,FINDDATACHAIN * pFindDataChain)
{
FINDDATACHAIN * pFindDataCell =NULL;
//FINDDATACHAIN * pFindDataCELL =NULL;
while(pFindDataChain)
{
pFindDataCell = pFindDataChain->pNext ;
FREEIF((void*)pFindDataChain);
pFindDataChain = pFindDataCell ;
}
pFindDataChain = NULL;
}
void AddIntoChain(GoChessApp* pMe,FINDDATACHAIN * pFindDataChain,FINDDATACHAIN * pFindDataCell,BOOL bHead)
{
FINDDATACHAIN * tmpFindData =NULL;
if(bHead) 这个其实移动了.不是申请哦.
{
if(pFindDataChain==NULL)
{
pFindDataCell->pNext = NULL ;
}
else //
{
pFindDataCell->pNext = pFindDataChain;
pFindDataChain->pPre = pFindDataCell;
}
pFindDataCell->pPre = NULL ;
pFindDataChain = pFindDataCell ;
}//
else /根据估值添加了.
{
if(pFindDataChain==NULL)
{
pFindDataCell->pPre = NULL ;
pFindDataCell->pNext = NULL ;
pFindDataChain = pFindDataCell ;
}
else ///比较了.
{
tmpFindData = pFindDataChain ;
while(pFindDataCell->findData.nValue >= tmpFindData->findData.nValue )
{
tmpFindData =tmpFindData->pNext ;
if(!tmpFindData)
break;
}
/此时,说明tmpFindData ,应该添加在tmpFindData之前了.
if(tmpFindData == pFindDataChain) 添加在最前面了.
{
pFindDataChain = pFindDataCell ;
}
pFindDataCell->pPre = tmpFindData->pPre ;
pFindDataCell->pNext = tmpFindData;
tmpFindData->pPre = pFindDataCell;
}
}
}
///
void MoveFromChainToChain(GoChessApp* pMe,FINDDATACHAIN * pFindDestChain,FINDDATACHAIN * pFindSourceChain,FINDDATACHAIN * pFindDataCell)
{
FINDDATACHAIN * pSourceChain = NULL;
if(pFindSourceChain==pFindDataCell)
{
///
pSourceChain=pFindDataCell->pNext ;
AddIntoChain(pMe,pFindDestChain,pFindDataCell,TRUE);
pFindSourceChain = pSourceChain;
}
else
{
if(pFindDataCell->pNext ==NULL)
{
}
else
{
}
}
return ;
}
///
BOOL ValueToFiles(GoChessApp* pMe)
{
IFile * pIFile =NULL;
int x=0,y=0;
char szBuf[4096];
char szTemp[10];
MEMSET(szBuf,0,sizeof(szBuf));
for(x=0;x {
for(y=0;y {
MEMSET(szTemp,0,sizeof(szTemp));
SPRINTF(szTemp,"%04d ",pMe->WorldCell[x][y].nBPower);
STRCAT(szBuf,szTemp);
}
STRCAT(szBuf,"/r/n");
}
STRCAT(szBuf,"/r/n/r/n");
for(x=0;x {
for(y=0;y {
MEMSET(szTemp,0,sizeof(szTemp));
SPRINTF(szTemp,"%04d ",pMe->WorldCell[x][y].nWPower);
STRCAT(szBuf,szTemp);
}
STRCAT(szBuf,"/r/n");
}
if ((pIFile = IFILEMGR_OpenFile(pMe->m_pIFileMgr, "debug.txt", _OFM_READWRITE)) == NULL)
{
return FALSE;
}
IFILE_Seek(pIFile,_SEEK_CURRENT,0);
if ((int)IFILE_Write(pIFile, szBuf, STRLEN(szBuf)) == STRLEN(szBuf))
{
IFILE_Release(pIFile);
return TRUE;
}
IFILE_Release(pIFile);
return FALSE;
}
/头文件:
/*===========================================================================
FILE:chess.h
作者:牛海防
2005-02-28
==============*/
#ifndef CHESS_H
#define CHESS_H
///
#include "AEEStdlib.h" // AEE Standard C library functions
//下面为了扩展网络游戏而定
#define MAX_USERID_LEN 10 一般8位即可
#define MAX_USERNAME_LEN 20 //一般16位即可
#define MAX_CERTIFICATION_LEN 20 //证件一般18位即可
#define MAX_CONNECT_LEN 12 //联系方式 一般11位即可
#define MAX_PASSWORD_LEN 12 //密码长度一般10位即可.
#define MAX_PROVINCE_LEN 12 //10位即可了.
#define MAX_CITY_LEN 15 //10位即可.
///一些初始化的等级了.
#define INIT_SCORE 500
#define INIT_MORAL 100
#define INIT_GO_TIMES 0
///
#define PLANE_ROW 19
#define PLANE_COL 19
#define INVALID_POS 19
#define CELL_SIZE 6
#define CELL_R 3
#define INIT_POS 3 ///选择框的初试位置
//
#define DELAYTIME 2000
#define COUNTTIME_UNIT 1000 //时间的统计单位了.
#define THINK_TIME 500
#define READSECOND 10
#define GOCHESS_VALUE 128
///
#define EXPAND_TIMES 5
#define ERODE_TIMES 21
/
#define Num_W 6
#define Num_H 7
#define Minu_Sec 60 //每分60秒
#define MAX_GAS 4 //
#define MAX_NEIGHBOR 4 //
#ifndef BOOL
typedef boolean BOOL;
#endif
#ifndef DWORD
typedef unsigned long int DWORD; /* Unsigned 32 bit value */
#endif
#ifndef WORD
typedef unsigned short WORD; /* Unsigned 16 bit value */
#endif
#ifndef BYTE
typedef unsigned char BYTE; /* Unsigned 8 bit value */
#endif
//初始化设置而已,各个点的power值,呵呵.
static const BYTE gPowerTab[PLANE_ROW][PLANE_COL] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,8,0,0,0,0,0,4,0,0,0,0,0,8,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,4,0,0,0,0,0,2,0,0,0,0,0,4,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,8,0,0,0,0,0,4,0,0,0,0,0,8,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
//
typedef struct _POINT
{
BYTE x;
BYTE y;
}POINT;//
typedef enum _SEX
{
SEX_MALE =0, //男士
SEX_FEMALE = 1 //女士
}SEX;
typedef enum _BWCOLOR
{
BW_NONE =0,
BW_BLACK =1,
BW_WHITE =2
}BWCOLOR;
typedef enum _PLAYER_WHO
{
PLAYER_NONE = 0 ,
PLAYER_COMPUTER = 1 ,
PLAYER_OPP = 2, ///网络的了.
PLAYER_ME = 3
}PLAYER_WHO;
typedef enum _GO_RANK
{
Rank_18K = 0, ///初级了,
Rank_5k = 1,
Rank_4k = 2,
Rank_3k = 3,
Rank_2k = 4,
Rank_1k = 5,
Rank_1d = 6, //升段了.
Rank_2d = 7,
Rank_3d = 8,
Rank_4d = 9,
Rank_5d = 10,
Rank_6d = 11,
Rank_7d = 12,
Rank_8d = 13,
Rank_9d = 14, //目前最高段了.
Rank_10d = 15 //保留段了.
Rank_1p = 16
Rank_2p = 17
Rank_3p = 18
Rank_4p = 19
Rank_5p = 20
Rank_6p = 21
Rank_7p = 22
Rank_8p = 23
Rank_9p = 24
Rank_10p = 25
}GO_RANK;
/*
typedef enum _MESSAGE_DEST
{
Dest_CommSvr = 0, //通讯服务器
Dest_GameSvr = 1, //游戏服务器
Dest_DbSvr = 2, //数据库服务器
Dest_User = 3, //客户端了.
Dest_Viewer = 4 //旁观者.
}MESSAGE_DEST;
*/
typedef struct _FINDDATA
{
BYTE nX;
BYTE nY;
BWCOLOR bwColor;
int nValue;
int nBunch;
}FINDDATA;
typedef struct _FINDDATACHAIN
{
FINDDATA findData;
struct _FINDDATACHAIN *pPre;
struct _FINDDATACHAIN *pNext;
}FINDDATACHAIN;
#endif
/*===========================================================================
FIL: gochess.h
作者:牛海防
2005-02-28
==============*/
#ifndef GOCHESS_H
#define GOCHESS_H
//
#include "AEEGraphics.h"
#include "Chess.h"
//define windows ID
#define WINDOWS_FLASH 0
#define WINDOWS_MAIN 1
#define WINDOWS_PLAY 2
#define WINDOWS_GAMEOVER 3
#define WINDOWS_HELP 4
#define WINDOWS_ABOUT 5
#define WINDOWS_PAUSE 6
#define WINDOWS_INIT 7
//当前游戏状态
#define GAME_STA_PLAYING 0
#define GAME_STA_PAUSE 1
#define GAME_STA_GAMEOVER 2
#define GAME_STA_IDLE 0xff
#define MENUITEM_NUM 5
//
typedef struct _PLAYER
{
POINT posLast;
BOOL bThink;
BOOL bTimeOut;
PLAYER_WHO pWho;
BWCOLOR bwColor;
int nTime;
int nOutTime;
}PLAYER;
typedef struct _WORLD_CELL
{
//POINT point;
BOOL bFind;
BWCOLOR bwColor;
BYTE gas;
BYTE nBlack;
BYTE nWhite;
BOOL bDead; 是否死了.
BOOL bInGas; 是否是某一方的内空.
/
int nBPower; ///
int nWPower; ///
int nBunch;
/
BYTE nTrueEyes;
BYTE nFALSEyes;
BYTE nOutGas;
BYTE nArea;
}WORLD_CELL;
typedef struct _GoChessApp
{
AEEApplet pi;//
BYTE gMenu;
BYTE gCurWin;
/
BOOL bSound; //是否音效
/
AEERect stWorldRect;//版面矩形
AEERect stGameRect; //游戏界面
AEERect stInfoRect; //信息界面
IGraphics *m_pGraphic; //画图只用了....
tuxing
IBitmap * m_pBmpNum;
///
POINT posForbid; //禁手设置了。
WORLD_CELL WorldCell[PLANE_COL][PLANE_ROW];
///
PLAYER playerMe;
PLAYER playerOpp;
引入形式的概念了.
int nBArea;
int nWArea;
int nHandNum;
/引入串的概念
int nBlackBunch; //黑串了.
int nWhiteBunch; ///白串问题
int nNullBunch; ///气串问题了.
int GoTime; ///
BYTE LetNum; ///
BOOL bHost;
POINT SelectPos;
POINT JustGo;
BWCOLOR bwCurColor;
BOOL bLetOpp; ///是否设置让子了.
//播放声音
ISoundPlayer * m_pISoundPlayer;
IFileMgr * m_pIFileMgr ;
}GoChessApp;
#endif
/*===========================================================================
FILE:gofuncdef.h
作者:牛阿牛
2005-02-28
==============*/
#ifndef GO_FUNC_DEF_H
#define GO_FUNC_DEF_H
#include "GoChess.h"
#include "Chess.h"
void Go_FreeAppRes(IApplet* pi );
void InitGlobalRes(GoChessApp * pMe);
BOOL InitAppRes(GoChessApp * pMe);
BOOL ShowSplash(GoChessApp * pMe);
BOOL Go_DrawMainWin(GoChessApp * pMe);
BOOL Go_DrawHelpWin(GoChessApp * pMe);
BOOL Go_DrawAboutWin(GoChessApp * pMe);
BOOL Go_SelectMenu(GoChessApp * pMe,uint16 wParam);
BOOL Go_PlayChess(GoChessApp * pMe,uint16 wParam);
void Go_StartNewGame(GoChessApp* pMe);
void ResetGameData(GoChessApp* pMe);
boolean CanGo(GoChessApp* pMe,BYTE x,BYTE y,BWCOLOR bwColor);
void SetForbid(GoChessApp* pMe,POINT point);
void Computer_Go(GoChessApp* pMe,POINT point,BWCOLOR bwColor);
void PerSon_Go(GoChessApp* pMe,POINT point,BWCOLOR bwColor);
void SetBWColor(GoChessApp* pMe,PLAYER *player,BWCOLOR bwColor);
void GetBestPos(GoChessApp* pMe,BWCOLOR bwColor,POINT * point);
void ExpandTimes(GoChessApp* pMe,BYTE nCount);
void ErodeTimes(GoChessApp* pMe,BYTE nCount);
void Expand(GoChessApp* pMe);
void Erode(GoChessApp* pMe);
void SetGoConfig(GoChessApp* pMe);
void GiveNumFirst(GoChessApp* pMe,BYTE nCount);
void SetGoTime(GoChessApp* pMe);
void DrawBoard(GoChessApp* pMe); ///画棋盘
void DrawChess(GoChessApp* pMe); ///画棋子
void DrawChessFace(GoChessApp* pMe); /// 显示关于整个界面的东西.
void DrawGoInfo(GoChessApp* pMe); ///显示走棋信息.
void CountTime(GoChessApp* pMe);
void ChangeCurrentPlayer(GoChessApp* pMe,POINT point,BWCOLOR bwColor);
void GoStep_Result(GoChessApp* pMe,POINT point,BWCOLOR bwColor);
void ReSetFindData(GoChessApp* pMe);
void PlayFile(GoChessApp * pMe,char *szFile);
void ShowNum(GoChessApp * pMe ,int x,int y,int nNum);
//
BOOL IfKillTheBunCh(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor);
void KillBunch(GoChessApp * pMe);
void KillPoint(GoChessApp * pMe,int nX,int nY);
void KillNeighborEffect(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor);
void SetAllNeighborEffect(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor);
void SetNeighborEffect(GoChessApp * pMe,int nX,int nY,BWCOLOR bwColor);
void SetPointValue(GoChessApp* pMe,POINT point,BWCOLOR bwColor);
BWCOLOR WhoWinTheGame(GoChessApp* pMe );
void Go_GameOver(GoChessApp* pMe);
void Go_JudgeSituation(GoChessApp* pMe);
BOOL IfPointInDepend(GoChessApp* pMe,POINT point,BWCOLOR bwColor); /判断该串是否是独立的.
void ConnectBunch(GoChessApp* pMe,int Bound1,int Bound2,BWCOLOR bwColor); 高的连成低的.
void ConnectResult(GoChessApp* pMe,int Bound,BWCOLOR bwColor); 将高的全部减少了.然后减少相应的东东.
int CountBunchOutGas(GoChessApp* pMe,int Bound,BWCOLOR bwColor); /判断该串的气数.主要是外围吧
int CountBunchTrueEyes(GoChessApp* pMe,int Bound,BWCOLOR bwColor);
int CountBunchFalseEyes(GoChessApp* pMe,int Bound,BWCOLOR bwColor); /
int CountBunchArea(GoChessApp* pMe,int Bound,BWCOLOR bwColor);
/
BOOL IfBunchDead(GoChessApp* pMe,int Bound,BWCOLOR bwColor);
BOOL IfOverFlow(GoChessApp* pMe,int nX,int nY ); //
BOOL IfSameColor(GoChessApp* pMe,int nX,int nY ,BWCOLOR bwColor);
void SetNewPointAsBunch(GoChessApp* pMe,int nX,int nY ,BWCOLOR bwColor);
void DisConnectArea(GoChessApp* pMe,int nX,int nY ,BWCOLOR bwColor);
BOOL IfIsLastConnectPoint(GoChessApp* pMe,int nX,int nY); 对其两边的串了.
void AddNewBunch(GoChessApp* pMe,int nX,int nY,BWCOLOR bwColor);
BOOL IfGasBunchDisConnect(GoChessApp* pMe,int nX,int nY,BWCOLOR bwColor);
//
BOOL DisConnectGasArea(GoChessApp* pMe,int nX1,int nY1,int nX2,int nY2);
BOOL IfCanConnectPoints(GoChessApp* pMe,int nX1,int nY1,int nX2,int nY2);
int CountValue(GoChessApp* pMe,int nX1,int nY1,int nX2,int nY2);
BOOL AddFindDataCell(GoChessApp* pMe,FINDDATACHAIN * pFindDataChain,int nX,int nY,int nDestX,int nDestY,BOOL bHead); ///
void AddIntoChain(GoChessApp* pMe,FINDDATACHAIN * pFindDataChain,FINDDATACHAIN * pFindDataCell,BOOL bHead);
void ReleaseFindData(GoChessApp* pMe,FINDDATACHAIN * pFindDataChain);
void MoveFromChainToChain(GoChessApp* pMe,FINDDATACHAIN * pFindDestChain,FINDDATACHAIN * pFindSourceChain,FINDDATACHAIN * pFindDataCell);
BOOL ValueToFiles(GoChessApp* pMe);
#endif
抛砖引玉:希望大家开源,共同进步!
祝大家能开发优秀的产品!!