不卡无码视频,亚洲精品成a人在线观看夫,内射在线Chinese,精品国产乱码久久久ea7,亚洲V∧在线观看精品,伊人成人网站,久久久久久高清毛片一级,av免费在线观看

每天一個C語言小項目，提升你的編程能力！

這是個益智游戲，規則很簡單，按上、下、左、右鍵，使游戲區域的所有方塊向該方向滑動，每次滑動時，相碰的兩個相同數字會合并。同時，空白的地方也會在隨機出現一個數字方塊（2 或者 4）。游戲目標，是想辦法合成 2048 這個數字方塊。

簡單了解游戲后我們就來試試吧！（直接上源碼，大家可以看注釋）

代碼展示：

/*
項目名稱：2048
開發工具：Visual Studio 2019，EasyX 20190415(beta)
作者：洛楓
*/


#include 
#include 
#include 
#include 
#include 
#include 


#pragma comment( lib, "MSIMG32.LIB")




// 方塊的狀態
enum State
{
  EXIST,    // 存在
  DESTORY    // 銷毀
};




// 二維向量，用于表示位置或者大小
struct Vector2
{
  float x;
  float y;
};




// 符號函數
int sgn(float d)
{
  if (d < 0)  return -1;
  if (d > 0)  return  1;
  return 0;
}




class Block
{
private:
  State  currentState;    // 當前的狀態
  State  targetState;    // 移動后的狀態
  Vector2  size;
  Vector2  currentPos;      // 當前位置
  Vector2  targetPos;      // 目標位置
  IMAGE  *img;
  IMAGE  *newImg;
  float  deltaPos;      // 每秒移動多少位置
  float  deltaSize;      // 每秒變大多少
  float  animationSpeed;    // 動畫速度




public:
  Block(const Vector2 &pos, IMAGE *img)
  {
    currentPos = targetPos = pos;
    currentState = targetState = EXIST;
    size = { 50,50 };
    this->img = this->newImg = img;


    deltaPos = 100;
    deltaSize = 40;
    animationSpeed = 20.0f;
  }




  void update(float deltaTime)
{
    // 改變方塊大小（圖片剛生成時的由小到大的動畫）
    if (size.x < img->getwidth())
    {
      size.x = size.y = size.x + deltaSize * deltaTime * animationSpeed / 2;
      if (size.x > img->getwidth())
      {
        size.x = size.y = (float)img->getwidth();
      }
    }


    // 更新方塊位置
    if (currentPos.x != targetPos.x || currentPos.y != targetPos.y)
    {
      int directionX = sgn(targetPos.x - currentPos.x);
      int directionY = sgn(targetPos.y - currentPos.y);


      currentPos.x += deltaPos * directionX * deltaTime * animationSpeed;
      // 相距小于 5 視為在同一位置
      if (fabs(currentPos.x - targetPos.x) < 5)
      {
        currentPos.x = targetPos.x;
      }


      currentPos.y += deltaPos * directionY * deltaTime * animationSpeed;
      if (fabs(currentPos.y - targetPos.y) < 5)
      {
        currentPos.y = targetPos.y;
      }
    }
    if (currentPos.x == targetPos.x &¤tPos.y == targetPos.y)
    {
      currentState = targetState;
      img = newImg;
    }
  }




  void draw()
{
    TransparentBlt(GetImageHDC(NULL), int(currentPos.x + (90 - size.x) / 2), int(currentPos.y + (90 - size.y) / 2),
      (int)size.x, (int)size.y, GetImageHDC(img), 0, 0, img->getwidth(), img->getheight(), BLACK);
  }




  // 把方塊從當前位置移動到目標位置，移動后改變狀態
  void MoveTo(const Vector2 &pos, IMAGE *newImg, State state = EXIST)
{
    targetPos = pos;
    targetState = state;
    this->newImg = newImg;
  }




  State getState()
{
    return currentState;
  }
};






int    map[4][4];        // 4 * 4 地圖
Block  *blockMap[4][4];    // 方塊索引
int    score;          // 得分
int    maxScore;        // 最高得分
int    currentMaxBlock;    // 當前最大方塊
int    maxBlock;        // 歷史最大方塊
int    gameLoop;        // 游戲循環
float  keyTime = 0;      // 按鍵間隔
std::map<int, IMAGE> image;    // 存儲所有數字圖像
bool  gameOver = false;    // 游戲是否結束
float  overTime;        // 游戲結束后不會立刻退出循環，而是等待 0.5s 更新動畫




// 判斷是否有可移動的方式，有返回 1 ，沒有返回 0
// 檢測思路：如果碰到為 0 的格子，或者兩個相鄰的格子數字相等，則返回 1
int Judge()
{
  // 橫向檢測
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      if (map[i][j] == 0 || map[i][j] == map[i][j + 1] || map[i][j + 1] == 0)
        return 1;
    }
  }


  // 縱向檢測
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      if (map[j][i] == 0 || map[j][i] == map[j + 1][i] || map[j + 1][i] == 0)
        return 1;
    }
  }


  return 0;
}




// 上移
void Up()
{
  int moveFlag = 0;  // 記錄是否進行過移動
  int mergeFlag = 0;  // 記錄是否合并過


  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      int k, z;


      // 找到一個不為 0 的方塊向上移動，并判斷是否可以和下邊的方塊合并
      for (k = j; k < 4; k++)
        if (map[k][i] != 0)
          break;


      // 尋找右邊不為 0 的方塊
      for (z = k + 1; z < 4; z++)
        if (map[z][i] != 0)
          break;


      // 當前行有非 0 方塊
      if (k < 4)
      {
        if (z < 4 && map[k][i] == map[z][i])
        {
          // 可以合并
          int value = map[k][i] + map[z][i];
          map[k][i] = map[z][i] = 0;
          map[j][i] = value;


          // 開啟動畫
          Block *temp = blockMap[k][i];
          blockMap[k][i] = NULL;
          blockMap[j][i] = temp;
          blockMap[j][i]->MoveTo({ 25.0f + 100 * i,225.0f + 100 * j }, &image[map[j][i]]);
          blockMap[z][i]->MoveTo({ 25.0f + 100 * i,225.0f + 100 * (j + 1) }, &image[map[z][i]], DESTORY);


          // 更新分數
          score += map[j][i];
          if (score > maxScore) maxScore = score;


          // 更新方塊
          if (value > currentMaxBlock) currentMaxBlock = value;
          if (currentMaxBlock > maxBlock) maxBlock = currentMaxBlock;


          mergeFlag = 1;
        }
        else
        {
          // 不可以合并
          int value = map[k][i];
          map[k][i] = 0;
          map[j][i] = value;


          // 判斷是否可以移動
          if (k != j)
          {
            moveFlag = 1;


            // 開啟動畫
            Block *temp = blockMap[k][i];
            blockMap[k][i] = NULL;
            blockMap[j][i] = temp;
            blockMap[j][i]->MoveTo({ 25.0f + 100 * i,225.0f + 100 * j }, &image[map[j][i]]);
          }
        }
      }
      else    // 判斷下一行
      {
        break;
      }
    }
  }


  // 如果發生了移動或合并，隨機生成一個 2 或 4
  if (moveFlag || mergeFlag)
  {
    int index;  // 隨機位置的索引


    // 直到隨機到一個空位置退出循環
    do
    {
      index = rand() % 4;
    } while (map[3][index] != 0);


    // 80% 生成 2 , 20% 生成 4
    int num = rand() % 10;
    if (num < 8)
    {
      map[3][index] = 2;
      blockMap[3][index] = new Block({ 25.0f + 100 * index, 225.0f + 100 * 3 }, &image[2]);
    }
    else
    {
      map[3][index] = 4;
      blockMap[3][index] = new Block({ 25.0f + 100 * index, 225.0f + 100 * 3 }, &image[4]);
    }
  }
}




// 下移
void Down()
{
  int moveFlag = 0;  // 記錄是否進行過移動
  int mergeFlag = 0;  // 記錄是否合并過


  for (int i = 0; i < 4; i++)
  {
    for (int j = 3; j > 0; j--)
    {
      int k, z;


      // 找到一個不為 0 的方塊向下移動，并判斷是否可以和上邊的方塊合并
      for (k = j; k >= 0; k--)
        if (map[k][i] != 0)
          break;


      // 尋找右邊不為 0 的方塊
      for (z = k - 1; z >= 0; z--)
        if (map[z][i] != 0)
          break;


      // 當前行有非 0 方塊
      if (k >= 0)
      {
        if (z >= 0 && map[k][i] == map[z][i])
        {
          // 可以合并
          int value = map[k][i] + map[z][i];
          map[k][i] = map[z][i] = 0;
          map[j][i] = value;


          // 開啟動畫
          Block *temp = blockMap[k][i];
          blockMap[k][i] = NULL;
          blockMap[j][i] = temp;
          blockMap[j][i]->MoveTo({ 25.0f + 100 * i,225.0f + 100 * j }, &image[map[j][i]]);
          blockMap[z][i]->MoveTo({ 25.0f + 100 * i,225.0f + 100 * (j - 1) }, &image[map[z][i]], DESTORY);


          // 更新分數
          score += map[j][i];
          if (score > maxScore) maxScore = score;


          // 更新方塊
          if (value > currentMaxBlock) currentMaxBlock = value;
          if (currentMaxBlock > maxBlock) maxBlock = currentMaxBlock;


          mergeFlag = 1;
        }
        else
        {
          // 不可以合并
          int value = map[k][i];
          map[k][i] = 0;
          map[j][i] = value;


          // 判斷是否可以移動
          if (k != j)
          {
            moveFlag = 1;
            // 開啟動畫
            Block *temp = blockMap[k][i];
            blockMap[k][i] = NULL;
            blockMap[j][i] = temp;
            blockMap[j][i]->MoveTo({ 25.0f + 100 * i,225.0f + 100 * j }, &image[map[j][i]]);
          }
        }
      }
      else    // 判斷下一行
      {
        break;
      }
    }
  }


  // 如果發生了移動或合并，隨機生成一個 2 或 4
  if (moveFlag || mergeFlag)
  {
    int index;  // 隨機位置的索引


    // 直到隨機到一個為 0 的位置退出循環
    do
    {
      index = rand() % 4;
    } while (map[0][index] != 0);


    // 80% 生成 2 , 20% 生成 4
    int num = rand() % 10;
    if (num < 8)
    {
      map[0][index] = 2;
      blockMap[0][index] = new Block({ 25.0f + 100 * index,225.0f + 100 * 0 }, &image[2]);
    }
    else
    {
      map[0][index] = 4;
      blockMap[0][index] = new Block({ 25.0f + 100 * index,225.0f + 100 * 0 }, &image[4]);
    }
  }
}




// 左移
void Left()
{
  int moveFlag = 0;  // 記錄是否進行過移動
  int mergeFlag = 0;  // 記錄是否合并過


  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      int k, z;


      // 找到一個不為 0 的方塊向左移動，并判斷是否可以和右邊的方塊合并
      for (k = j; k < 4; k++)
        if (map[i][k] != 0)
          break;


      // 尋找右邊不為 0 的方塊
      for (z = k + 1; z < 4; z++)
        if (map[i][z] != 0)
          break;


      // 當前行有非 0 方塊
      if (k < 4)
      {
        if (z < 4 && map[i][k] == map[i][z])
        {
          // 可以合并
          int value = map[i][k] + map[i][z];
          map[i][k] = map[i][z] = 0;
          map[i][j] = value;


          // 開啟動畫
          Block *temp = blockMap[i][k];
          blockMap[i][k] = NULL;
          blockMap[i][j] = temp;
          blockMap[i][j]->MoveTo({ 25.0f + 100 * j,225.0f + 100 * i }, &image[value]);
          blockMap[i][z]->MoveTo({ 25.0f + 100 * (j + 1),225.0f + 100 * i }, &image[map[z][i]], DESTORY);


          // 更新分數
          score += map[i][j];
          if (score > maxScore) maxScore = score;


          // 更新方塊
          if (value > currentMaxBlock) currentMaxBlock = value;
          if (currentMaxBlock > maxBlock) maxBlock = currentMaxBlock;


          mergeFlag = 1;
        }
        else
        {
          // 不可以合并
          int value = map[i][k];
          map[i][k] = 0;
          map[i][j] = value;


          // 判斷是否可以移動
          if (k != j)
          {
            moveFlag = 1;
            // 開啟動畫
            Block *temp = blockMap[i][k];
            blockMap[i][k] = NULL;
            blockMap[i][j] = temp;
            blockMap[i][j]->MoveTo({ 25.0f + 100 * j,225.0f + 100 * i }, &image[value]);
          }
        }
      }
      else    // 判斷下一行
      {
        break;
      }
    }
  }


  // 如果發生了移動或合并，隨機生成一個 2 或 4
  if (moveFlag || mergeFlag)
  {


    int index;  // 隨機位置的索引


    // 直到隨機到一個為 0 的位置退出循環
    do
    {
      index = rand() % 4;
    } while (map[index][3] != 0);


    // 80% 生成 2 , 20% 生成 4
    int num = rand() % 10;
    if (num < 8)
    {
      map[index][3] = 2;
      blockMap[index][3] = new Block({ 25.0f + 100 * 3,225.0f + 100 * index }, &image[2]);
    }
    else
    {
      map[index][3] = 4;
      blockMap[index][3] = new Block({ 25.0f + 100 * 3,225.0f + 100 * index }, &image[4]);
    }
  }
}




// 右移
void Right()
{
  int moveFlag = 0;  // 記錄是否進行過移動
  int mergeFlag = 0;  // 記錄是否合并過


  for (int i = 0; i < 4; i++)
  {
    for (int j = 3; j > 0; j--)
    {
      int k, z;


      // 找到一個不為 0 的方塊向右移動，并判斷是否可以和左邊的方塊合并
      for (k = j; k >= 0; k--)
        if (map[i][k] != 0)
          break;


      // 尋找右邊不為 0 的方塊
      for (z = k - 1; z >= 0; z--)
        if (map[i][z] != 0)
          break;


      // 當前行有非 0 方塊
      if (k >= 0)
      {
        if (z >= 0 && map[i][k] == map[i][z])
        {
          // 可以合并
          int value = map[i][k] + map[i][z];
          map[i][k] = map[i][z] = 0;
          map[i][j] = value;


          // 開啟動畫
          Block *temp = blockMap[i][k];
          blockMap[i][k] = NULL;
          blockMap[i][j] = temp;
          blockMap[i][j]->MoveTo({ 25.0f + 100 * j,225.0f + 100 * i }, &image[value]);
          blockMap[i][z]->MoveTo({ 25.0f + 100 * (j - 1),225.0f + 100 * i }, &image[map[z][i]], DESTORY);


          // 更新分數
          score += map[i][j];
          if (score > maxScore) maxScore = score;


          // 更新方塊
          if (value > currentMaxBlock) currentMaxBlock = value;
          if (currentMaxBlock > maxBlock) maxBlock = currentMaxBlock;


          mergeFlag = 1;
        }
        else
        {
          // 不可以合并
          int value = map[i][k];
          map[i][k] = 0;
          map[i][j] = value;


          // 判斷是否可以移動
          if (k != j)
          {
            moveFlag = 1;
            // 開啟動畫
            Block *temp = blockMap[i][k];
            blockMap[i][k] = NULL;
            blockMap[i][j] = temp;
            blockMap[i][j]->MoveTo({ 25.0f + 100 * j,225.0f + 100 * i }, &image[value]);
          }
        }
      }
      else    // 判斷下一行
      {
        break;
      }
    }
  }


  // 如果發生了移動或合并，隨機生成一個 2 或 4
  if (moveFlag || mergeFlag)
  {
    int index;  // 隨機位置的索引
    do
    {
      index = rand() % 4;
    } while (map[index][0] != 0);


    // 80% 生成 2 , 20% 生成 4
    int num = rand() % 10;
    if (num < 8)
    {
      map[index][0] = 2;
      blockMap[index][0] = new Block({ 25.0f + 100 * 0,225.0f + 100 * index }, &image[2]);
    }
    else
    {
      map[index][0] = 4;
      blockMap[index][0] = new Block({ 25.0f + 100 * 0,225.0f + 100 * index }, &image[4]);
    }
  }
}




void Update(float deltaTime)
{
  // 更新方塊
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 4; j++)
    {
      if (blockMap[i][j] != NULL)
      {
        blockMap[i][j]->update(deltaTime);
        if (blockMap[i][j]->getState() == DESTORY)
        {
          delete blockMap[i][j];
          blockMap[i][j] = NULL;
        }
      }
    }
  }


  if (gameOver)
  {
    overTime -= deltaTime;
    if (overTime <= 0)
      gameLoop = 0;
  }


  keyTime += deltaTime;
  // 0.2s 可以按鍵一次
  if (keyTime < 0.2f || gameOver)
    return;


  if ((GetAsyncKeyState(VK_UP) & 0x8000) || (GetAsyncKeyState('W') & 0x8000))      // 上
  {
    Up();
    if (!Judge())
    {
      gameOver = true;
    }
    keyTime = 0;
  }
  else if ((GetAsyncKeyState(VK_DOWN) & 0x8000) || (GetAsyncKeyState('S') & 0x8000))  // 下
  {
    Down();
    if (!Judge())
    {
      gameOver = true;
    }
    keyTime = 0;
  }
  else if ((GetAsyncKeyState(VK_LEFT) & 0x8000) || (GetAsyncKeyState('A') & 0x8000))  // 左
  {
    Left();
    if (!Judge())
    {
      gameOver = true;
    }
    keyTime = 0;
  }
  else if ((GetAsyncKeyState(VK_RIGHT) & 0x8000) || (GetAsyncKeyState('D') & 0x8000))  // 右
  {
    Right();
    if (!Judge())
    {
      gameOver = true;
    }
    keyTime = 0;
  }
}




// 設置文字樣式和顏色
void settext(int height, int weight, UINT color)
{
  settextstyle(height, 0, _T("Arial"), 0, 0, weight, false, false, false, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
    CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH);
  settextcolor(color);
}




// 在指定矩形區域內居中輸出字符串
void printtext(LPCTSTR s, int left, int top, int right, int width)
{
  RECT r = { left, top, right, width };
  drawtext(s, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
}




// 繪制界面
void Draw()
{
  // 歷史最大方塊
  TransparentBlt(GetImageHDC(NULL), 12, 30, 90, 90, GetImageHDC(&image[maxBlock]), 0, 0, 90, 90, 0x9eaebb);


  setfillcolor(0x9eaebb);
  // 繪制當前分數
  solidroundrect(112, 30, 264, 119, 10, 10);
  settext(28, 800, 0xdbe6ee);
  printtext(_T("SCORE"), 112, 40, 264, 69);
  std::wstringstream ss;
  ss << score;
  settext(44, 800, WHITE);
  printtext(ss.str().c_str(), 112, 70, 264, 114);
  ss.str(_T(""));


  // 繪制最高分數
  solidroundrect(275, 30, 427, 119, 10, 10);
  settext(28, 800, 0xdbe6ee);
  printtext(_T("BEST"), 275, 40, 427, 69);
  ss << maxScore;
  settext(44, 800, WHITE);
  printtext(ss.str().c_str(), 275, 70, 427, 114);
  ss.str(_T(""));


  // 繪制提示信息
  settextcolor(BLACK);
  ss << "Join the numbers and get to the " << currentMaxBlock * 2 << " tile!";
  settext(24, 800, 0x707b83);
  printtext(ss.str().c_str(), 0, 120, 439, 211);


  // 繪制方塊底板
  solidroundrect(12, 212, 427, 627, 10, 10);


  // 繪制方塊
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 4; j++)
    {
      putimage(25 + 100 * j, 225 + 100 * i, &image[0]);
    }
  }
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 4; j++)
    {
      if (blockMap[i][j] != NULL)
        blockMap[i][j]->draw();
    }
  }
}




// 初始化游戲
void Init()
{
  srand((unsigned int)time(NULL));    // 初始化隨機數種子


  memset(map, 0, 4 * 4 * sizeof(int));  // 把地圖初始化為 0
  memset(blockMap, 0, 4 * 4 * sizeof(Block*));


  score = 0;
  gameLoop = 1;
  gameOver = false;
  overTime = 0.5f;
  currentMaxBlock = 2;
  map[0][0] = 2;
  map[0][1] = 2;
  blockMap[0][0] = new Block({ 25,225 }, &image[2]);
  blockMap[0][1] = new Block({ 125,225 }, &image[2]);


  setbkcolor(WHITE);
  setbkmode(TRANSPARENT);
}




// 游戲結束界面 返回 1 表示繼續游戲 返回 0 表示結束游戲
int OverInterface()
{
  // 保存最高紀錄
  std::wstringstream ss;
  ss << maxScore;
  WritePrivateProfileString(_T("2048"), _T("MaxScore"), ss.str().c_str(), _T(".\data.ini"));
  ss.str(_T(""));
  ss << maxBlock;
  WritePrivateProfileString(_T("2048"), _T("MaxBlock"), ss.str().c_str(), _T(".\data.ini"));


  setbkmode(TRANSPARENT);
  setbkcolor(0x8eecff);
  cleardevice();


  // Game Over
  settext(60, 1000, 0x696f78);
  printtext(_T("Game Over!"), 0, 0, 439, 199);


  // 繪制最大方塊
  TransparentBlt(GetImageHDC(NULL), 175, 150, 90, 90, GetImageHDC(&image[currentMaxBlock]), 0, 0, 90, 90, 0x9eaebb);


  // ReStart
  setfillcolor(0x9dadba);
  solidroundrect(120, 310, 319, 389, 10, 10);
  settext(36, 1000, WHITE);
  printtext(_T("ReStart"), 120, 310, 319, 389);
  // Exit
  solidroundrect(120, 460, 319, 539, 10, 10);
  printtext(_T("Exit"), 120, 460, 319, 539);


  FlushBatchDraw();


  FlushMouseMsgBuffer();


  while (1)
  {
    while (MouseHit())
    {
      MOUSEMSG msg = GetMouseMsg();
      if (msg.mkLButton)
      {
        int x = msg.x;
        int y = msg.y;
        if (x >= 120 && x <= 319 && y >= 310 && y <= 389)
          return 1;
        if (x >= 120 && x <= 319 && y >= 460 && y <= 539)
          return 0;
      }
    }
    Sleep(100);
  }
  return 1;
}




// 釋放內存
void FreeMem()
{
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
      if (blockMap[i][j] != NULL)
        delete blockMap[i][j];
}




// 用于生成方塊圖片
//    img:    方塊圖片指針
//    num:    方塊上的數字
//    imgColor:  方塊顏色
//    fontSize:  字體大小
//    fontColor:  字體顏色  
void CreateImage(IMAGE *img, LPCTSTR num, COLORREF imgColor, int fontSize, COLORREF fontColor)
{
  SetWorkingImage(img);
  setbkmode(TRANSPARENT);
  setbkcolor(0x9eaebb);
  settext(fontSize, 1000, fontColor);
  setfillcolor(imgColor);
  settextcolor(fontColor);


  cleardevice();


  solidroundrect(0, 0, img->getwidth() - 1, img->getheight() - 1, 10, 10);


  RECT r = { 0,0,img->getwidth() - 1,img->getheight() - 1 };
  drawtext(num, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
}


// 繪制圖片緩存
void Load()
{
  IMAGE temp(90, 90);


  CreateImage(&temp, _T(""),     0xb5becc, 72, WHITE);    image[0] = temp;
  CreateImage(&temp, _T("2"),    0xdbe6ee, 72, 0x707b83);    image[2] = temp;
  CreateImage(&temp, _T("4"),    0xc7e1ed, 72, 0x707b83);    image[4] = temp;
  CreateImage(&temp, _T("8"),    0x78b2f4, 72, WHITE);    image[8] = temp;
  CreateImage(&temp, _T("16"),   0x538ded, 72, WHITE);    image[16] = temp;
  CreateImage(&temp, _T("32"),   0x607df6, 72, WHITE);    image[32] = temp;
  CreateImage(&temp, _T("64"),   0x3958e9, 72, WHITE);    image[64] = temp;
  CreateImage(&temp, _T("128"),  0x6bd9f5, 56, WHITE);    image[128] = temp;
  CreateImage(&temp, _T("256"),  0x4bd0f2, 56, WHITE);    image[256] = temp;
  CreateImage(&temp, _T("512"),  0x2ac0e4, 56, WHITE);    image[512] = temp;
  CreateImage(&temp, _T("1024"), 0x13b8e3, 40, WHITE);    image[1024] = temp;
  CreateImage(&temp, _T("2048"), 0x00c5eb, 40, WHITE);    image[2048] = temp;
  CreateImage(&temp, _T("4096"), 0x3958e9, 40, WHITE);    image[4096] = temp;
  CreateImage(&temp, _T("8192"), 0x3958e9, 40, WHITE);    image[8192] = temp;


  SetWorkingImage(NULL);
}




// 主函數
int main()
{
  float deltaTime = 0;  // 每幀耗時


  initgraph(440, 650);
  Load();
  BeginBatchDraw();


  maxScore = 0;


  // 讀取最高分
  maxScore = GetPrivateProfileInt(_T("2048"), _T("MaxScore"), 0, _T(".\data.ini"));
  // 讀取最大方塊
  maxBlock = GetPrivateProfileInt(_T("2048"), _T("MaxBlock"), 2, _T(".\data.ini"));


  while (1)
  {
    Init();


    while (gameLoop)
    {
      clock_t start = clock();


      cleardevice();
      Update(deltaTime);
      Draw();
      FlushBatchDraw();
      Sleep(1);


      clock_t end = clock();
      deltaTime = (end - start) / 1000.0f;
    }


    FreeMem();


    if (OverInterface() == 0)
      break;


    FlushMouseMsgBuffer();
  }


  closegraph();
}

編輯：何安

聲明：本文內容及配圖由入駐作者撰寫或者入駐合作網站授權轉載。文章觀點僅代表作者本人，不代表電子發燒友網立場。文章及其配圖僅供工程師學習之用，如有內容侵權或者其他違規問題，請聯系本站處理。舉報投訴

編程

編程

+關注

關注
88

文章
3595

瀏覽量
93600
代碼

代碼

+關注

關注
30

文章
4750

瀏覽量
68357

原文標題：C/C++項目實戰：《2048》，900行源碼帶你完美實現經典數字游戲！

文章出處：【微信號：cyuyanxuexi，微信公眾號：C語言編程學習基地】歡迎添加關注！文章轉載請注明出處。

C語言實現：見縫插針游戲！代碼思路+源碼分享

見縫插圓我們昨天已經用C語言實現了，今天將實現一個見縫插針的游戲。

發表于 12-05 11:02 ?704次閱讀

采用單片機來實現的智能俄羅斯方塊游戲

游戲，該設計選用的處理器型號為AT89C51的單片機。重點從軟件工程角度論述了俄羅斯方塊模型構造，圖形旋轉，坐標變換，雙人游戲中多任務實時操作的設計方法與

發表于 11-19 08:26

基于c#的游戲設計_俄羅斯方塊論文終結版

基于c#的游戲設計——俄羅斯方塊，內容包括源代碼的詳細介紹，源代碼，功能以及怎么實現等。

發表于 11-25 14:34 ?0次下載

C語言教程之猜數字游戲問題

C語言教程之猜數字游戲問題，很好的C語言資料，快來學習吧。

發表于 04-25 15:03 ?0次下載

用C語言實現數字濾波

用C語言實現數字濾波。對數值進行精度調整，下面給出幾種常用的數字濾波方法的C

發表于 07-26 15:44 ?10次下載

俄羅斯方塊游戲設計原理

俄羅斯方塊游戲是VHDL 應用于復雜數字系統的一個經典設計，本章將詳細介紹該游戲的設計原理和設計方法。其中包括系統構成、系統設計原理和系統各個模塊的

發表于 09-01 17:24 ?0次下載

通過AT89S52單片機來實現俄羅斯方塊游戲的設計詳細中文概述

本設計是通過AT89S52單片機來實現俄羅斯方塊游戲的設計，使用C語言進行編程，并通過Proteus來進行仿真。

發表于 06-07 08:00 ?18次下載

如何用C語言實現掃雷游戲項目

這篇文章主要為大家詳細介紹了 C語言實現——《掃雷游戲項目》，文中示例代碼介紹的非常詳細，具有一定的參考價值,感興趣的小伙伴們可以參考一下！ ? 游戲介紹：

發表于 11-11 14:12 ?1208次閱讀

基于51單片機的俄羅斯方塊游戲

俄羅斯方塊游戲，該設計選用的處理器型號為AT89C51的單片機。重點從軟件工程角度論述了俄羅斯方塊模型構造，圖形旋轉，坐標變換，雙人游戲中多

發表于 11-13 10:21 ?57次下載

如何用C語言實現2048項目

? 這篇文章主要為大家詳細介紹了 C語言實現——《2048項目》文中示例代碼介紹的非常詳細，具有一定的參考價值,感興趣的小伙伴們可以參考一下！ ? ? 游戲介紹：《

發表于 11-21 16:45 ?2384次閱讀

qt用C++寫的2048小游戲源代碼

qt用C++寫的2048小游戲源代碼

發表于 09-27 11:48 ?1次下載

C語言實現《別碰白塊》小游戲！全部代碼+思路注釋

今天我們將用C語言實現一個小球跳躍躲避方塊的游戲。

發表于 12-08 09:06 ?1266次閱讀

基于FPGA的2048小游戲實現案例

這周末調試《車牌識別算法》遇到點問題，“無聊”中用FPGA搞個2048小游戲玩玩。

發表于 09-08 10:01 ?1350次閱讀

精品国产人成在线_亚洲高清无码在线观看_国产在线视频国产永久2021_国产AV综合第一页一个的一区免费影院黑人_最近中文字幕MV高清在线视频

搜索歷史

用C語言完美實現2048數字方塊游戲

評論

C語言實現：見縫插針游戲！代碼思路+源碼分享

基于js實現2048小游戲

如何用C語言實現一款猜數字游戲

采用單片機來實現的智能俄羅斯方塊游戲

基于c#的游戲設計_俄羅斯方塊論文終結版

C語言教程之猜數字游戲問題

用C語言實現數字濾波

俄羅斯方塊游戲設計原理

通過AT89S52單片機來實現俄羅斯方塊游戲的設計詳細中文概述

如何用C語言實現掃雷游戲項目

基于51單片機的俄羅斯方塊游戲

如何用C語言實現2048項目

qt用C++寫的2048小游戲源代碼

C語言實現《別碰白塊》小游戲！全部代碼+思路注釋

基于FPGA的2048小游戲實現案例