代码

最新推荐文章于 2024-06-20 09:44:04 发布
最新推荐文章于 2024-06-20 09:44:04 发布
阅读量872 收藏
点赞数 1
文章标签： delete null timer file c math
1.       CChess.h
#ifndef        CHESS_H
#define        CHESS_H
 
 
#define        C_ChessWidth 16
#define        C_ChessHeight 16
#define        C_ChessM2     -1   // 乘以二的chess
 
#define        C_StartPosX        8
#define        C_StartPosY        0
 
#define        C_ChessNumX        10   // 每行的chess个数
#define        C_ChessNumY        10   // 美列的chess个数
 
#include "glob.h"
 
 
class CChess
{
 
private :
    
     CGTimer * m_Timer;
     TPoint ComputPos( TInt aIndex );
     TRect ComputRect();
 
     enum EChessState
     {
         TSelected,
         TRemoved,
         TNormal,
         TBomb,
     };
    
     TInt          m_Num;
     TInt          m_Index; // 在棋盘中的位置。
     TInt          m_choosenIndex;
    
     EChessState        m_state;
    
     CImage             * m_NumImages[3];
 
     TInt          m_SelectNo; // 被选中的序号
    
public :
     TInt GetNum();
     TBool IsAlive();
     CChess( TInt aNum, TInt aIndex, CImage * aNumsImage[3], CGTimer * aTimer );
 
 
     TInt GetIndex(){ return m_Index; };
 
 
 
     TInt Render ( CFbsBitmap * aBmp );
     TBool select( TInt & aSelectNums );
     void remove();
     // 返回这个方块被选中的数
     TInt GetSelectIndex(void);
 
     void ResetChess();
 
 
     void DrawBomb1( CFbsBitmap * aBmp );
     void DrawBomb2( CFbsBitmap * aBmp );
 
};
 
 
#endif
 
2.      CChess.cpp
 
#include "chess.h"
 
 
CChess::CChess( TInt aNum, TInt aIndex, CImage * aNumsImage[3], CGTimer * aTimer )
{
     m_state = TNormal;
 
//   m_bSelect = EFalse;
 
     m_Num    = aNum;
     m_Index =aIndex;
 
     for ( TInt i = 0; i < 3; i++ ) {
         m_NumImages[i] = aNumsImage[i];
     }
     m_Timer = aTimer;
 
     m_SelectNo    = -1;
 
 
}
 
void CChess::remove()
{
     // m_state = TBomb;
     m_state = TRemoved;
}
 
 
 
TBool CChess::select( TInt & aSelectNums )
{
     if ( m_state == TSelected ) {
         m_SelectNo    = -1;
         aSelectNums --;
         m_state = TNormal;
         return EFalse;
     }
     else if ( m_state == TNormal ) {
         m_SelectNo    = aSelectNums;
         aSelectNums ++;
         m_state = TSelected;
         return ETrue;
        
     }
     //return ( m_state & TSelected );
 
}
 
// aIndex 是在容器中的位置
TInt CChess::Render( CFbsBitmap* aBmp )
{
     int i; i = 0;
     switch ( m_state )
     {
         case TNormal:
              m_NumImages[0]->RenderToBitmapL( aBmp, ComputPos(m_Index), ComputRect() );
              break;
        
         case TSelected:
              m_NumImages[1]->RenderToBitmapL( aBmp, ComputPos(m_Index), ComputRect() );
              break;
        
         case TRemoved:
              return 0;
              break;
 
         case TBomb:
    
              return 0;
              break;
     }
     return 1;
}
 
// 不负责计算爆炸图片
TRect CChess::ComputRect()
{
     if ( m_Num >=1 ) {
         return TRect( TPoint(C_ChessWidth * m_Num, 0), TSize(C_ChessWidth,C_ChessHeight) );
     }
     else if ( m_Num = C_ChessM2 ) {
         return TRect ( 0, 0, C_ChessWidth, C_ChessHeight );
     }
}
 
 
TPoint CChess::ComputPos( TInt aIndex )
{
     // 行列的计数都是从0 开始的
     TInt x = aIndex % C_ChessNumX;        // 每行8个元素
     TInt y = aIndex / C_ChessNumY;        // 每列8个元素
    
 
     return TPoint(     C_ChessWidth * x + C_StartPosX,
                       C_ChessHeight * y + C_StartPosY );
 
}   
 
 
TBool CChess::IsAlive()
{
     if ( m_state != TBomb && m_state != TRemoved ) {
         return ETrue;
     }
     else
     {
         return EFalse;
     }
}
 
 
TInt CChess::GetNum()
{
     return m_Num;
}
 
TInt CChess::GetSelectIndex(void)
{
     return m_SelectNo;
}
 
void CChess::ResetChess()
{
     m_state = TNormal;
     m_SelectNo    = -1;
}
 
 
void CChess::DrawBomb1( CFbsBitmap * aBmp )
{
     if ( m_NumImages[2] == NULL ) {
         return;
     }
     m_NumImages[2]->RenderToBitmapL( aBmp, ComputPos(m_Index) - TPoint(2,1),
                                               TRect( 0, 0, C_ChessWidth, C_ChessHeight ) );
}
        
 
void CChess::DrawBomb2( CFbsBitmap * aBmp )
{
     if ( m_NumImages[2] == NULL ) {
         return;
     }
     m_NumImages[2]->RenderToBitmapL( aBmp, ComputPos(m_Index) - TPoint(2,1),
                                               TRect( C_ChessWidth, 0, C_ChessWidth * 2, C_ChessHeight ) );
}
 
 
 
3.      CChessBoard.h
 
#ifndef       CHESSBOARD_H
#define        CHESSBOARD_H
 
#include "glob.h"
#include "chess.h"
#include "face.h"
#include "LaneTimer.h"
#include "ShortTimer.h"
#include "Cur.h"
#include "TargetNum.h"
#include "calculate.h"
#include "dialog.h"
#include "GFile.h"
#include "SoundPlayer.h"
 
 
class CChessBoard
{
private :
 
     enum EGameState {
         TIntroduce,
         TNew,
         TRun,
         TPause,
         TResume,
         TPassLeave,
         TGameOver,
         TWin,
         TShowScore,
         TShowHiS,
         TDoHiS,
    
     };
 
 
     EGameState    m_GameState;
 
 
     TBool    m_bGetHi; //  是否获得最高分
 
     CArrayPtrFlat<CChess>       * m_AliveChessList;    // 让然存在的方块指针数组，用于产生目标数字
     CArrayPtrFlat<CChess>       * m_BombChessList; // 保存要爆炸的图像文件
     CArrayPtrFlat<CChess>       * m_WaitKillChessList; // 选中的方块数组，用于按顺序消去
 
     void     RemoveChess ( TInt aChessIndex );   // 删除一个方块对象
     TInt     RandomChess();                            // 随即产生方块
     CChess        ** m_chess;            // 方块
     CImage        * m_ChessImage[3]; // 方块图片
     CImage        * m_BackGround;        // 背景
 
     CFace         * m_Face;          // 笑脸
     CGTimer       * m_pAniTimer;         // 动画的Timer
     CShortTimer   * m_ShortTimer;        // 10 秒倒计时的Timer;
     CLaneTimer    * m_pNumTimer;         // 总共倒计时
     CLaneCur * m_Cur;           // 选取框
     CTargetNum    * m_TargetNum;         // 目标数字
     TKeyHandler * m_KeyHandler;      // 输入控制器
     TInt     m_NumsList[10];        // 数字索引
     TInt64        m_iSeed;
     TInt     m_Leave;           // 游戏关卡
 
     TInt     m_Score;           // 玩家得分
     TInt     m_HighScore;       // 最高分纪录。
 
     CSoundPlayer * m_SoundPlayer;
 
    
     //
    
 
 
public :
     CDialog       * m_pDlg;
private :
 
 
 
     TInt GameRun( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp );
     TInt GameOver ( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp, TBool aWin = EFalse );
     TInt ShowSroce( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp );
     TInt ShowHiS( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp );
     TInt ShowDoHiS( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp );
     TInt Win( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp );
    
public : 
     void PassLeave();
     void GameStart();
     void SetLeave( TInt aLevel );
     void ConstructL();
     CChessBoard(TKeyHandler * aKeyHandler);
     ~CChessBoard();
 
     void RenderBomb( CFbsBitmap* aBmp );
 
 
     TInt Render ( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp );
 
     void NewGame();
 
 
     void EnableSound( TBool aAble );
 
 
 
     void Pause();
 
     void Resume();
};
 
 
#endif
 
4.      CChessboard.cpp
 
#include "ChessBoard.h"
 
CChessBoard::CChessBoard( TKeyHandler * aKeyHandler )
{
     m_NumsList[9]      = -1;    // -1 为乘2的棋子
     for ( TInt i = 0; i < 9; i ++ ) {
         m_NumsList[i] = i+1;   // 1 ~ 9
     }
 
     m_chess = NULL;
     for ( i = 0; i < 3; i ++ ) {
         m_ChessImage[i] = NULL ;
     }
     m_BackGround       = NULL;
     m_Face                 = NULL;
     m_pAniTimer            = NULL;
     m_pNumTimer            = NULL;
     m_Cur                  = NULL;
     m_ShortTimer       = NULL;
     m_AliveChessList   = NULL;
     m_BombChessList        = NULL;
     m_WaitKillChessList    = NULL;
     m_TargetNum            = NULL;
     m_KeyHandler       = aKeyHandler;
 
 
     m_Leave                = 1;
 
 
 
     m_HighScore            = 0;
     m_Score                = 0;
     m_pDlg                 = NULL;      
     m_bGetHi           = EFalse;
 
     //
     m_SoundPlayer      = NULL;
}
 
CChessBoard::~CChessBoard()
{
     for ( TInt i = 0; i < C_ChessNumX * C_ChessNumY; i ++ ) {
         if ( m_chess[i] )      delete m_chess[i];
     }
     delete[] m_chess;
     for ( i = 0; i < 3; i ++ ) {
         delete m_ChessImage[i] ;
     }
     if ( m_BackGround )         delete m_BackGround;
     if ( m_Face )                    delete m_Face;
     if ( m_pAniTimer )          delete m_pAniTimer;
     if ( m_pNumTimer )               delete m_pNumTimer;
     if ( m_ShortTimer )         delete   m_ShortTimer;
     if ( m_Cur )                delete m_Cur;
     if ( m_AliveChessList )     delete   m_AliveChessList;
     if ( m_BombChessList )      delete m_BombChessList;
     if ( m_WaitKillChessList ) delete m_WaitKillChessList;
     if ( m_TargetNum )               delete   m_TargetNum;
     if ( m_pDlg )               delete m_pDlg;
 
 
     if ( m_SoundPlayer )        delete m_SoundPlayer;
}
 
// 构造游戏需要的资源
void CChessBoard::ConstructL()
{
     // 背景
     m_BackGround = CImage::NewL( _L("res.mbm"), 0, ETrue, 0xffff );
     m_Face = new CFace;
     m_pAniTimer   = new CGTimer();
     m_pAniTimer->ConstructL();
     m_pAniTimer->Stop();
     // 正常的chess
     m_ChessImage[0] = CImage::NewL( _L("res.mbm"), 3, ETrue, 0xfff );
     // 被选中的chess
     m_ChessImage[1] = CImage::NewL( _L("res.mbm"), 4, ETrue, 0xfff );
     // 爆炸
     m_ChessImage[2] = CImage::NewL( _L("res.mbm"), 5, ETrue, 0xfff );
     m_chess = new CChess * [C_ChessNumX * C_ChessNumY];
     for ( TInt i = 0; i < C_ChessNumX * C_ChessNumY; i ++ ) {
         m_chess[i]    = NULL;
     }
     m_pNumTimer = new CLaneTimer;
     m_WaitKillChessList = new (ELeave) CArrayPtrFlat<CChess> ( 50 );
     m_AliveChessList = new (ELeave) CArrayPtrFlat<CChess> ( C_ChessNumX * C_ChessNumY );
     m_BombChessList = new (ELeave) CArrayPtrFlat<CChess> ( C_ChessNumX * C_ChessNumY );
     m_Cur = new CLaneCur( m_KeyHandler, m_chess, C_ChessNumX * C_ChessNumY, m_WaitKillChessList );
     m_TargetNum = new CTargetNum();
     m_pDlg        = CDialog::NewL();
    
    
    
     // 读取最高分。
 
 
#ifdef  __WINS__
     CGFile* file = CGFile::NewL(_L("c://HiS.sc"), EFileRead | EFileShareAny);
#else
     CGFile* file = CGFile::NewL(_L("HiS.sc"), EFileRead | EFileShareAny);
#endif
     file->ReadL((TText8*) & m_HighScore, sizeof(TInt));
     delete file;
 
 
     m_SoundPlayer =    CSoundPlayer::NewL();
    
 
 
//   m_GameState = TShowScore;
//   break;
//                 case -2:
//                     m_GameState = TDoHiS;
 
     m_GameState = TNew;
     //   m_GameState = TIntroduce;
}
 
// 数据计算跟渲染
TInt CChessBoard::Render( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp )
{
     switch( m_GameState ) {
 
         case TIntroduce:
              break;
 
         case TNew:
              GameStart();
              m_GameState = TRun;
              break;
 
         case TRun:
              switch ( GameRun( aCallerGc, aBmp ) ) {
                   case -1414:   // gameover
                       m_pDlg->Reset();
                       m_GameState = TGameOver;
                       break;
                   case 8888:    // 过关
                       if ( m_Leave < 3 ) {   // not win
                            m_pDlg->Reset();
                            m_GameState = TPassLeave;
                       }
                       else {        // win
                            m_pDlg->Reset();
                            m_GameState = TWin;
                       }
                       break;
                   case 3:
                       break;
                   default:
                       break;
              }
 
              break;
 
         case TPassLeave:
              m_pDlg->PassLeave();
              m_pDlg->Render(aCallerGc, aBmp);
              if ( m_KeyHandler->IsDown(53) || m_KeyHandler->IsDown(167) ) {
                   PassLeave();
              //   m_pDlg->Nothing();
                   m_pDlg->Reset();
                   m_GameState = TRun;
              }
              m_KeyHandler->Reset();
              break;
 
         case TPause:
              // Pause();
              break;
 
         case TShowScore:
              if ( ShowSroce( aCallerGc, aBmp ) == -1414 ) {
                   return -1414;
              }
              m_KeyHandler->Reset();
              break;  
 
         case TResume:
              // Resume();
              m_GameState = TRun;
              break;
 
         case TGameOver:
              switch ( GameOver( aCallerGc, aBmp ) ) { // 对画框结束
                   case -1:
                       m_GameState = TShowScore;
                       break;
                   case -2:
                       m_GameState = TDoHiS;
                       break;
                       }
 
              m_KeyHandler->Reset();
              break;
 
         case TShowHiS:
              if ( ShowHiS( aCallerGc, aBmp ) == -1 ) {
                   return -1414;
              }
              break;
         case TDoHiS:
              if ( ShowDoHiS(aCallerGc, aBmp) == -1 ) {
                   return -1414;
              }
              break;
 
         case TWin:
              switch ( GameOver( aCallerGc, aBmp, ETrue ) ) {    // 对画框结束
                   case -1:
                       m_GameState = TShowScore;
                       break;
                   case -2:
                       m_GameState = TDoHiS;
                       break;
              }
 
              // return     9999;         // 过全关
              break;
     }
     return 1;
 
 
}
 
TInt CChessBoard::GameRun( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp )
{
 
 
     // 1 ，绘制背景
     m_BackGround->RenderToBitmapL( aBmp, TPoint(0,0) );
 
 
     for ( TInt i = 0; i < m_AliveChessList->Count(); i ++ ) {
         m_AliveChessList->At(i)->Render( aBmp );
     }
 
     RenderBomb(aBmp);
 
 
     // 2 ，绘制选择框
     // 先绘制选择框--里面计算了拾取的哪个方块,该函数返回一共选择了多少个。
     // 用temp带到计算类型中。更新数据。根据返回数值进行下一步的操作。
     TInt & temp = m_Cur->Render(aBmp);   
 
 
 
     TInt CResult = CCalculate::UpdateCalcu( m_chess, temp, m_AliveChessList, m_TargetNum->GetTarNum(), m_BombChessList ,
         m_WaitKillChessList, m_Score );
 
     if ( CResult == -1 ) {     // 正确，消去方块
         m_TargetNum->ComputeTarNum( m_AliveChessList );
         m_Face->Smile();
         m_pAniTimer->Stop();
         m_pAniTimer->Play();
         m_ShortTimer->Stop();
         m_ShortTimer->Play();
         m_SoundPlayer->Bomb();      // 爆炸~~~~
     }
 
 
     else if ( CResult == -2 ) { // 错误，扣时间
         m_Face->Cry();
         m_pNumTimer->SubTime(1000);
     }
     m_TargetNum->Render(aBmp);
 
     // 4 ，先绘制短时间的倒计时---返回是否超时
     // 根据短倒计时计时器是否超时，决定是否增减1秒
     if ( m_ShortTimer->Render( aCallerGc, aBmp ) == 1 ) { // 短计时器超时了
         m_pNumTimer->SubTime(1000);
         m_Face->Cry();
     }
 
     // 3 ，绘制方块-----根据方块的选择情况绘制
 
//   for ( TInt i = 0; i < m_AliveChessList->Count(); i ++ ) {
//       m_AliveChessList->At(i)->Render( aBmp );
//   }
 
//   RenderBomb(aBmp);
 
     // 6 ，根据最后情况绘制笑脸、哭脸
     m_Face->Render( aBmp ); // 放在最后
     if ( m_AliveChessList->Count() == 0 ) {                 // 本关胜利
     //   TInt s = m_pNumTimer->GetLastTime();
         m_Score += m_pNumTimer->GetLastTime() / 1000 ;
         m_SoundPlayer->PassLeave();
         return 8888;
     }
 
 
 
 
 
 
     // 5 ，总计时器
     if ( m_pNumTimer->Render( aCallerGc, aBmp ) == -1 ) {   // 时间用完了,游戏结束
         m_SoundPlayer->Fail();
         return   -1414;
     }
     return 1;
}
 
TInt CChessBoard::GameOver ( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp, TBool aWin )
{
     m_Score = m_Score > 99999 ? 99999 : m_Score;
     if ( m_Score > m_HighScore ) {
         m_HighScore   = m_Score;
#ifdef  __WINS__
         CGFile* file = CGFile::NewL(_L("c://HiS.sc"), EFileWrite );
#else
         CGFile* file = CGFile::NewL(_L("HiS.sc"), EFileWrite );
#endif
         file->WriteL((TText8*) & m_Score, sizeof(m_Score));
         //m_GameState = TDoHiS;
         delete file;
         m_bGetHi = ETrue;
     }
 
     if ( aWin ) {
        
         m_pDlg->GameWin();
     }
     else {
        
         m_pDlg->Gameover();
     }
    
     m_pDlg->Render(aCallerGc, aBmp);
     if ( m_KeyHandler->IsDown(53) || m_KeyHandler->IsDown(167) ) {
         m_pDlg->Nothing();
         if ( m_bGetHi ) { // 获得最高分
              m_bGetHi = EFalse;
              return        -2;
         }   
         else {             // 没有超过最高分
              return        -1;
         }
     }
     return 0;
}
 
TInt CChessBoard::ShowSroce ( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp )
{
 
     m_pDlg->ShowS( m_Score );
     m_pDlg->Render(aCallerGc, aBmp);
 
     if ( m_KeyHandler->IsDown(53) || m_KeyHandler->IsDown(167) ) {
         m_pDlg->Nothing();
         //   m_GameState = TRun;
         return        -1414;
     }
     return 0;
}
 
 
 
 
TInt CChessBoard::ShowHiS( CFbsBitGc* aCallerGc, CFbsBitmap * aBmp )
{
     m_pDlg->ShowHiS();
     m_pDlg->Render( aCallerGc, aBmp );
 
     if ( m_KeyHandler->IsDown(53) || m_KeyHandler->IsDown(167) ) {
         m_pDlg->Nothing();
         return -1;
     }
 
     return 0;
 
}
 
TInt CChessBoard::ShowDoHiS( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp )
{
     m_pDlg->DoHiS( m_Score );
     m_pDlg->Render( aCallerGc, aBmp );
 
     if ( m_KeyHandler->IsDown(53) || m_KeyHandler->IsDown(167) ) {
         m_pDlg->Nothing();
         return -1;
     }
 
     return 0;
}
 
 
TInt CChessBoard::Win( CFbsBitGc* aCallerGc, CFbsBitmap* aBmp )
{
     m_Score = m_Score > 9999 ? 9999 : m_Score;
    
     if ( m_Score > m_HighScore ) {
         m_HighScore   = m_Score;
#ifdef  __WINS__
         CGFile* file = CGFile::NewL(_L("c://HiS.sc"), EFileWrite );
#else
         CGFile* file = CGFile::NewL(_L("HiS.sc"), EFileWrite );
#endif
         file->WriteL((TText8*) & m_Score, sizeof(m_Score));
         delete file;
         m_bGetHi = ETrue;
     }
 
 
 
     m_pDlg->PassLeave();
     m_pDlg->Render(aCallerGc, aBmp);
 
     if ( m_KeyHandler->IsDown(53) || m_KeyHandler->IsDown(167) ) {
         m_pDlg->Nothing();
         if ( m_bGetHi ) {
              m_pDlg->DoHiS(m_HighScore);
              m_bGetHi = EFalse;
              return -2;
         }
         else {
              m_pDlg->ShowS(m_Score);
              return   -1;
         }
     }
     return 0;
 
 
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
// 设置第几个关卡
void CChessBoard::SetLeave(TInt aLevel)
{
     m_Leave = aLevel;
}
 
 
// 新一轮的游戏开始
void CChessBoard::GameStart()
{
//-------------------------------------------------------------------------
     m_AliveChessList->Reset();
     switch( m_Leave ) {
         case 1:
              m_pNumTimer->Start( 200000 );
         //   m_pNumTimer->Start( 200000 );
              m_ShortTimer = new CShortTimer( 10000 );
              break;
 
         case 2:
              m_pNumTimer->Start( 190000 );
         //   m_pNumTimer->Start( 500000 );
              m_ShortTimer = new CShortTimer( 9000 );
              break;
 
         case 3:
              m_pNumTimer->Start( 170000 );
         //   m_pNumTimer->Start( 500000 );
              m_ShortTimer = new CShortTimer( 8000 );
              break;
 
     }
 
     for ( TInt i = 0; i < C_ChessNumX * C_ChessNumY; i ++ ) {
         m_chess[i] = new CChess( RandomChess(), i,     m_ChessImage, m_pAniTimer );
     }
 
     for ( i = 0; i < C_ChessNumX * C_ChessNumY; i ++ ) {
         m_AliveChessList->AppendL( m_chess[i] );
     }
 
     //
     m_TargetNum->ComputeTarNum(m_AliveChessList);
     m_ShortTimer->Play();
     m_BombChessList->Reset();
     m_WaitKillChessList->Reset();
}
 
// 过关
void CChessBoard::PassLeave()
{
//-------------------------------------------------------------------------
     m_Score = m_Score > 99999 ? 99999 : m_Score;
    
     if ( m_ShortTimer ) {
         delete   m_ShortTimer;
         m_ShortTimer = NULL;
     }
 
     m_AliveChessList->Reset();
     m_Cur->Reset();
 
 
     for ( TInt i = 0; i < C_ChessNumX * C_ChessNumY; i ++ ) {
         if ( m_chess[i] ) {
              delete m_chess[i];
              m_chess[i]    = NULL;
         }
     }
 
     m_Leave ++;
 
     GameStart();
}
 
 
// 根据关卡随即生成chess的分布
TInt CChessBoard::RandomChess()
{
     TInt index = 0;
     switch ( m_Leave ) {
     case 1:
         index = Math::Rand(m_iSeed) % 6; // 1 ~ 6
         break;
 
     case 2:
         index = Math::Rand(m_iSeed) % 9; // 1 ~ 9
         break;
 
     case 3:
         index = Math::Rand(m_iSeed) % 10;    // 1 ~ 9, *2
         break;
     }
 
     return m_NumsList[index];
}
 
// 根据消去的方块绘制爆炸效果
void CChessBoard::RenderBomb( CFbsBitmap* aBmp )
{
 
 
     TInt time = m_pAniTimer->GetTime();
 
     for ( TInt i = 0; i < m_BombChessList->Count(); i ++ ) {
         if ( time > 0 && time < 180 ) {
              m_BombChessList->At(i)->DrawBomb1(aBmp);
         }
         else if ( time >= 180 && time < 360 ) {
              m_BombChessList->At(i)->DrawBomb2(aBmp);
         }
         else if ( time >= 360 ) {
              m_pAniTimer->Stop();
         }
     }
 
}
 
void CChessBoard::Pause( )
{
     m_pAniTimer->Pause();       // 动画的Timer
     m_ShortTimer->Pause();      // 10 秒倒计时的Timer;
     m_pNumTimer->Pause ();      // 总共倒计时
     m_GameState = TPause;
}
 
// 从暂停中恢复。
void CChessBoard::Resume( )
{
     m_pAniTimer->Play();
     m_ShortTimer->Resume();
     m_pNumTimer->Resume();
     m_GameState = TResume;
}
 
//  开始新的游戏。
void CChessBoard::NewGame()
{
//   m_Leave = 0;
     m_Leave = 0;
     m_Score = 0;
     PassLeave();
}
 
 
 
 
void CChessBoard::EnableSound( TBool aAble )
{
     m_SoundPlayer->EnableSound( aAble );
}
 
 
 
 
 
 
goodsun2
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【状压DP】【cofun1373】中国象棋（cchess）
MYBHB_mio的博客
10-13 655
【cofun1373】中国象棋（cchess）Description 在N行M列的棋盘上，放若干个炮（可以是0个），使得没有任何一个炮可以攻击另一个炮。 请问有多少种放置方法，中国象棋中炮的行走方式大家应该很清楚吧.Input Format 两个整数n，m Output Format 方案总数 mod 9999973Sample Input 1 3 Sample Output 7Hin
不能真“生成代码”的“低代码”平台，不可能获得程序员的认可
冷兮雪的博客
06-28 3万+
注意，由于语言本身的限制，很容易被混淆，这里的应用是开发的“单个应用实例”，也就是“开发了什么就生成什么”，不是一大堆框架的代码。还有一些开源的例如：jeecg\若依\taskbuilder，做得还不错的，能够生成部分内部模块代码或者打包一个内部环境格式的文件，但是绝大部分都不能“真正生成代码”，像编程语言那样生成代码。然而，iVX的优势并不仅限于此。这样的好处是让这个语言“专心生成代码”，而不用去考虑后台资源能力，也就是说和“后台运行时资源解耦，什么高并发、安全、弹性计算... 都丢给云计算去做...”
CCHESS中国象棋
01-06
中国象棋——象棋概述、基本常 识、基本技巧、残局、开局、中局、名局赏析、附录，教学内容丰富，形式多样，让您轻轻松松掌握下象棋的要领。解压即可用。
cchess:cchess是一个Python版的中国象棋库
05-28
cchess cchess是一个Python版的中国象棋库，主要功能如下: ##棋盘显示 board_strs = board.text_view() print() for s in board_strs: print(s) #或者 board.print_board() ##走子(内部格式), 中文显示 move = board.copy().move((0,0),(0,1)) print(move.to_chinese()) ##走子(ICCS纵线格式),中文显示 move = board.copy().move_iccs('a0a1') print(move.to_chinese()) ##走子(中文格式,尚待完善),中文显示 move = board.copy().move_chinese('车九进一') print(move.to_chinese()) ##产生某个棋子
中国象棋软件-引擎实现（四）搜索算法
Luis
05-12 6904
 对于棋类软件的搜索算法经前人的努力已形成了较为成熟的Alpha-Beta搜索算法以及其它一些辅助增强算法。所以小生在自己的程序中直接借鉴了Alpha-Beta搜索算法并辅以了历史启发。对此两者王小春的《PC 游戏编程（人机博弈）》和ElephantBoard的主页 http://www.elephantbase.net/上都有非常详细的介绍，所以这里我只简单介绍一下算法的主体思想：首
低代码开发平台的优势及应用场景分析
想你依然心痛的博客
12-18 3万+
而近几年，经过低代码的快速发展，又衍生出一种新的概念，叫无代码开发（No-code），无代码是在低代码开发平台的基础上提出的，所以它主要面向的用户是业务人员，而不是IT专家。业务人员根据业务的实际需求，可以自行设计并使用应用程序，新需求可以自行增加，不依赖IT专家，没有严格的设计时和运行的界限，新需求即时更改，即时上线，且无需部署。对于初学者，低代码技术培训可以提供从入门到实战的全面学习——从低代码开发平台的搭建，到平台的基础功能和实战案例的开发，涵盖所有的技术细节和业务场景。
你真正了解低代码么？(国内低代码平台状况分析)
商务合作 | 共同学习 | 携手共进
04-14 3万+
国内低代码发展趋势解读。
Python代码整洁之道
最新发布
努力让自己发光，对的人才能迎着光而来
06-20 7万+
在软件开发中，代码的整洁性对于项目的长期成功至关重要。整洁的代码不仅易于阅读和理解，还更易于维护和扩展。Python以其简洁、易读和强大的功能而著称，但即使是Python代码，如果不加以注意，也可能变得混乱不堪。以下是一些建议，帮助你提高Python代码的整洁性。
给你们讲个笑话——低代码会取代程序员
xuxian的博客
04-19 4万+
低代码开发平台的普及，让很多公司对快速生成应用抱有很大期望。甚至有人认为，低代码开发平台未来会“干掉”开发者。这是真的吗？好久没时间分享了。今天来谈谈关于低代码的思考文章。你可以看看它，我希望它会帮助你。
CCHESS.EXE
03-29
客安装在智能手机上进行人机对抗，也看联网与朋友下棋
cchess单机软件
11-20
绝对智能 玩家可以试一下 一般手绝对办不来哦哦 不服的可以挑战大师级别
Cchess.exe
05-29
Cchess.exe
CChess_Setup(正版2012.11).exe
07-21
象棋棋谱，又能下象棋，又有古棋谱，是象棋爱好者的一大福音，棋谱还可以记录以往的对弈，方便简洁
CChess.exe
01-19
CChess.exe 中国象棋 脱机 局域网 对战 联机 可以在局域网内和同事玩中国象棋,界面美观,操作方便.
HTML圣诞树代码(动态音效)
热门推荐
qq_63108921的博客
12-19 18万+
<!DOCTYPE html> <html lang="en" > <head> <meta charset="UTF-8"> <title>圣诞树</title> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/5.0.0/normalize.min.css"> <...
代码整洁 vs 代码肮脏
程序员泥瓦匠
09-16 9万+
写出整洁的代码，是每个程序员的追求。《clean code》指出，要想写出好的代码，首先得知道什么是肮脏代码、什么是整洁代码；然后通过大量的刻意练习，才能真正写出整洁的代码。 WTF/min是衡量代码质量的唯一标准，Uncle Bob在书中称糟糕的代码为沼泽（wading），这只突出了我们是糟糕代码的受害者。国内有一个更适合的词汇：屎山，虽然不是很文雅但是更加客观，程序员既是受害者也是加害者。 对...
颜色代码对照表
Serendipitysyn的博客
11-24 18万+
颜色代码
36个漂亮的各类型网站源代码
12-17
本资源“36个漂亮的各类型网站源代码”提供了丰富的实例，可以帮助开发者理解和学习不同类型的网站布局，以便创建出更加吸引人的网页设计。 首先，让我们探讨一下“源码”的概念。源代码是程序员用编程语言编写的...
OWASP代码安全审查指南
"《代码安全审查》是一本详细介绍如何在企业开发过程中集成代码安全审查的书籍，涵盖了代码审查流程、安全漏洞成因分析，并提供了一系列实用的指导原则、检查清单和威胁建模示例。该书是OWASP（开放式网络应用安全...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值