brew（2）

最新推荐文章于 2024-05-04 21:34:24 发布
最新推荐文章于 2024-05-04 21:34:24 发布
阅读量649 收藏
点赞数
文章标签： brew byte null windows struct go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ghc_ghc/article/details/5283309
版权

应该经过的多次扩张
//
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
抛砖引玉:希望大家开源,共同进步!
祝大家能开发优秀的产品!!

ghc_ghc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
brew_install
10-30
官方源安装brew 缓慢 安装容易失败，这个脚本是替换过源（将官方源替换成了清华源 brew bottle）下载后直接运行: ruby brew_install
Mac必备工具址brew
hellocsz的博客
07-25 300
brew 是 Mac 下的一个包管理工具，类似于 centos 下的 yum，可以很方便地进行安装/卸载/更新各种软件包，例如：nodejs, elasticsearch, kibana, mysql, mongodb 等等，可以用来快速搭建各种本地环境，程序员必备工具 安装 brew 首先要通过如下命令安装 brew /usr/bin/ruby -e "$(curl -fsSL https...
在BREW中打造自己的GUI（7）－动态效果的实现
SHARE & TOP
03-10 3698
今天讨论关于GUI的另一个话题：如何在两个界面切换中表现出比较炫一点的效果，比如渐变、缩放等等。同样我们还是用组件的方式来做。IGSlider，负责管理两个IControl切换的动态效果，它的使用比较简单：static void loadMenu(DisplayFavt * pMe,uint16 wParam)...{    TItemData    *pData;    IControl
brew-4.1.14
10-11
brew-4.1.14内容： brew-4.1.14.tar.gz brew-4.1.14.zip Homebrew-4.1.14.pkg
brew-4.1.15
10-11
brew-4.1.15内容： brew-4.1.15.tar.gz brew-4.1.15.zip Homebrew-4.1.15.pkg
mac brew安装文件
11-19
mac brew安装文件
brew_install.rb
10-20
brew_install.rb
java技术栈快速复习04_javaweb基础总结
咖啡味的小认真
04-30 864
JDBC（Java DataBase Connectivity，Java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问。简单说就是用Java语言来操作数据库。jdbc原理早期SUN公司的天才们想编写一套可以连接天下所有数据库的API，但是当他们刚刚开始时就发现这是不可完成的任务，因为各个厂商的数据库服务器差异太大了。
循环链表 -- c语言实现
weixin_60243362的博客
05-03 670
【代码】循环链表 -- c语言实现。
C++list的模拟实现
m0_74189279的博客
05-01 884
C++list容器模拟实现
批量抓取某电影网站的下载链接
知命不惧，日日自新。
05-04 2184
在这个Python项目中，开发者创建了一个名为`MovieScraper`的类，用于从网站抓取电影信息。这个类包含了一些方法，每个方法都负责完成一个特定的任务： - `get_response(url)`：向指定的URL发送GET请求并返回响应。 - `get_movie_list_html(response)`：从响应中提取电影列表的HTML。 - `get_sub_url_list(movie_list_html)`：从电影列表HTML中提取子URL。
环形链表面试题详解
最新发布
2302_80357424的博客
05-04 1078
必看必看必看~~~
【JAVA】part5-Java集合
KX_52517的博客
04-30 1358
Java系列教程之Java集合，本文旨在弄懂Java集合，为Java 学习者提供价值，多说不唠，详见此文！
Java中优雅实现泛型类型的强制转换
byx的博客
04-30 378
Java中优雅实现泛型类型的强制转换
Content type ‘application/json；charset=UTF-8‘ not supported异常的解决过程
m0_68310465的博客
04-30 562
1.首先说明开发场景 *就是对该json格式数据传输到后台 后台实体类 import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.fasterxml.jackson.annotation.JsonIgnore; import lombok.Data; import org.springframework.format.annota
C++11：shared_ptr循环引用问题
2201_75880188的博客
04-30 752
详细介绍了引用循环出现的场景及为什么会出现引用循环，以及如何解决引用循环，引入了weak的概念。
边循环边删除List中的数据
G_whang的博客
04-30 776
删除的所有，但是最终还留下两个值，这是因为当一个元素被移除时，该List的大小(size)就会缩减，同时也改变了索引的指向，也就是上面的代码只会循环两次，长度在不断减少，第一次循环0 < 4 ，第二次循环 1 < 3 ，不满足下一次循环条件 2 < 2，故只有两次循环就结束。这是因为，在 foreach循环中，编译器使得 remove()方法先于next()方法被调用，因为先执行了remove()方法，导致next()获取的数组长度和remove()后的数组长度不一致，则抛出异常。List边循环，边删除；
18 内核开发-内核重点数据结构学习
jxusthusiwen的专栏
05-04 442
无论你是计算机科学专业的学生、软件工程师还是对Linux内核开发感兴趣的爱好者，Linux内核开发入门课程都将为你提供一个扎实的学习平台，帮助你掌握Linux内核开发的基础知识，为进一步深入研究和应用Linux内核打下坚实的基础。该课程旨在为对Linux内核开发感兴趣的初学者提供一个扎实的基础，让他们能够理解和参与到Linux内核的开发过程中。无论你是否具有编程或操作系统的背景，该课程都将从最基本的概念和技术开始，逐步引导学习者深入了解Linux内核开发的核心原理。
ArrayList.remove()方法盲区
lpf11214的博客
04-30 661
ArrayList.remove()
iterm2 找不到brew
10-03
iterm2找不到brew可能是因为以下原因之一： 1. 没有正确安装brew：请检查是否按照正确的步骤安装了brew。你可以使用命令`/usr/bin/ruby -e "$(curl -fsSL ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值