快樂俄羅斯方塊

Code

1. # # #include <Wire.h>

2. #include <LiquidCrystal_I2C.h>

3. #include <LedControl.h>

4. // ==========================================

5. // [硬體設定區]

6. // ==========================================

7. // 矩陣方向修正 (若圖案顛倒請改這裡)

8. const bool ROTATE_MATRIX = false; 

9. const bool INVERT_X = false;      

10. // 接腳定義 (DIN=12, CLK=11, CS=10)

11. LedControl lc = LedControl(12, 11, 10, 1);

12. LiquidCrystal_I2C lcd(0x27, 16, 2);

13. const int PIN_X = A0;      // 搖桿 X

14. const int PIN_Y = A2;      // 搖桿 Y

15. const int PIN_POT = A1;    // 可變電阻 (調速)

16. // ==========================================

17. // [遊戲變數]

18. // ==========================================

19. byte board[8][8] = {0};    // 0=空, 1=有方塊

20. int curX = 3, curY = -2;  

21. int curPiece, curRot;     

22. int gamePhase = 0;         // 0:待機, 1:倒數, 2:遊戲中

23. unsigned long lastFallTime = 0;

24. unsigned long startTime = 0;

25. unsigned long lastLcdUpdate = 0; // 新增：控制螢幕刷新頻率

26. int dropSpeed = 500;      

27. // 7 種方塊定義

28. const byte blocks[7][4][4][4] = {

29.  { { {0,0,0,0}, {1,1,1,1}, {0,0,0,0}, {0,0,0,0} }, { {0,0,1,0}, {0,0,1,0}, {0,0,1,0}, {0,0,1,0} }, { {0,0,0,0}, {1,1,1,1}, {0,0,0,0}, {0,0,0,0} }, { {0,0,1,0}, {0,0,1,0}, {0,0,1,0}, {0,0,1,0} } }, // I

30.  { { {1,0,0,0}, {1,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,1,0}, {0,1,0,0}, {0,1,0,0}, {0,0,0,0} }, { {0,0,0,0}, {1,1,1,0}, {0,0,1,0}, {0,0,0,0} }, { {0,1,0,0}, {0,1,0,0}, {1,1,0,0}, {0,0,0,0} } }, // J

31.  { { {0,0,1,0}, {1,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,0,0}, {0,1,0,0}, {0,1,1,0}, {0,0,0,0} }, { {0,0,0,0}, {1,1,1,0}, {1,0,0,0}, {0,0,0,0} }, { {1,1,0,0}, {0,1,0,0}, {0,1,0,0}, {0,0,0,0} } }, // L

32.  { { {0,1,1,0}, {0,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,1,0}, {0,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,1,0}, {0,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,1,0}, {0,1,1,0}, {0,0,0,0}, {0,0,0,0} } }, // O

33.  { { {0,1,1,0}, {1,1,0,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,0,0}, {0,1,1,0}, {0,0,1,0}, {0,0,0,0} }, { {0,1,1,0}, {1,1,0,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,0,0}, {0,1,1,0}, {0,0,1,0}, {0,0,0,0} } }, // S

34.  { { {0,1,0,0}, {1,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,1,0,0}, {0,1,1,0}, {0,1,0,0}, {0,0,0,0} }, { {0,0,0,0}, {1,1,1,0}, {0,1,0,0}, {0,0,0,0} }, { {0,1,0,0}, {1,1,0,0}, {0,1,0,0}, {0,0,0,0} } }, // T

35.  { { {1,1,0,0}, {0,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,0,1,0}, {0,1,1,0}, {0,1,0,0}, {0,0,0,0} }, { {1,1,0,0}, {0,1,1,0}, {0,0,0,0}, {0,0,0,0} }, { {0,0,1,0}, {0,1,1,0}, {0,1,0,0}, {0,0,0,0} } }  // Z

36. };

37. void setup() {

38.  lcd.init();

39.  lcd.backlight();

40.  lc.shutdown(0, false);

41.  lc.setIntensity(0, 5);

42.  lc.clearDisplay(0);

43.  // 硬體開機檢測

44.  for(int i=0; i<2; i++){

45.    for(int r=0; r<8; r++) lc.setRow(0, r, 255);

46.    delay(100);

47.    lc.clearDisplay(0);

48.    delay(100);

49.  }

50.  resetToStandby();

51.  randomSeed(analogRead(A5));

52. }

53. void loop() {

54.  // 隨時讀取速度

55.  // 地圖映射：0~1023 對應到 1000ms(慢) ~ 50ms(極快)

56.  int potVal = analogRead(PIN_POT);

57.  dropSpeed = map(potVal, 0, 1023, 1000, 50);

58.  switch (gamePhase) {

59.    case 0: // 待機

60.      lcd.setCursor(0, 0); lcd.print("  TETRIS READY  ");

61.      lcd.setCursor(0, 1); lcd.print("Move to start   ");

62.      // 搖桿觸發

63.      if (abs(analogRead(PIN_X) - 512) > 200 || abs(analogRead(PIN_Y) - 512) > 200) {

64.        startCountdown();

65.      }

66.      break;

67.    case 2: // 遊戲中

68.      runGameLoop();

69.      break;

70.    // case 3 (死亡狀態) 邏輯在 doGameOver 函式

71.  }

72. }

73. // 倒數計時

74. void startCountdown() {

75.  gamePhase = 1;

76.  for(int i=3; i>0; i--) {

77.    lcd.clear();

78.    lcd.setCursor(7, 0); lcd.print(i);

79.    delay(1000);

80.  }

81.  lcd.clear();

82.  lcd.setCursor(6, 0); lcd.print("GO!");

83.  delay(500);

84.  // 遊戲開始

85.  gamePhase = 2;

86.  memset(board, 0, sizeof(board));

87.  startTime = millis();

88.  lcd.clear();

89.  spawnBlock();

90. }

91. // 遊戲主迴圈

92. void runGameLoop() {

93.  unsigned long now = millis();

94.  // === 效能優化關鍵：每 200ms 才更新一次螢幕 ===

95.  // 這樣 Arduino 才有時間去處理極速下落

96.  if (now - lastLcdUpdate > 200) {

97.    lcd.setCursor(0, 0);

98.    lcd.print("Spd:"); lcd.print(dropSpeed); lcd.print("ms   ");

99.    lcd.setCursor(0, 1);

100.    lcd.print("Time:"); lcd.print((now - startTime) / 1000); lcd.print("s");

101.    lastLcdUpdate = now;

102.  }

103.  // 搖桿操作

104.  static unsigned long lastMove = 0;

105.  if (now - lastMove > 150) {

106.    int xVal = analogRead(PIN_X);

107.    int yVal = analogRead(PIN_Y);

108.    if (xVal < 200) moveBlock(-1, 0);

109.    if (xVal > 800) moveBlock(1, 0); 

110.    if (yVal < 200) rotateBlock();   

111.    if (yVal > 800) { // 下推加速

112.      if (!checkCollision(curX, curY + 1, curRot)) curY++;

113.    }

114.    lastMove = now;

115.  }

116.  // 自動下落 (這裡現在不會被 LCD 拖慢了)

117.  if (now - lastFallTime > dropSpeed) {

118.    if (!checkCollision(curX, curY + 1, curRot)) {

119.      curY++;

120.    } else {

121.      // 到底固定

122.      if (!lockBlock()) {

123.        doGameOver(); // 溢出 -> 死亡

124.        return;

125.      }

126.      clearLines();

127.      if (!spawnBlock()) {

128.        doGameOver(); // 無法生成 -> 死亡

129.        return;

130.      }

131.    }

132.    lastFallTime = now;

133.  }

134.  drawGame();

135. }

136. // 產生新方塊

137. bool spawnBlock() {

138.  curPiece = random(0, 7);

139.  curRot = 0;

140.  curX = 2; curY = -3;

141.  return !checkCollision(curX, curY, curRot);

142. }

143. void moveBlock(int dx, int dy) {

144.  if (!checkCollision(curX + dx, curY + dy, curRot)) { curX += dx; curY += dy; }

145. }

146. void rotateBlock() {

147.  int nextRot = (curRot + 1) % 4;

148.  if (!checkCollision(curX, curY, nextRot)) { curRot = nextRot; }

149. }

150. bool checkCollision(int x, int y, int rot) {

151.  for (int r = 0; r < 4; r++) {

152.    for (int c = 0; c < 4; c++) {

153.      if (blocks[curPiece][rot][r][c]) {

154.        int realX = x + c;

155.        int realY = y + r;

156.        if (realX < 0 || realX > 7) return true;

157.        if (realY > 7) return true;             

158.        if (realY >= 0 && board[realY][realX]) return true;

159.      }

160.    }

161.  }

162.  return false;

163. }

164. bool lockBlock() {

165.  bool overflow = false;

166.  for (int r = 0; r < 4; r++) {

167.    for (int c = 0; c < 4; c++) {

168.      if (blocks[curPiece][curRot][r][c]) {

169.        int realX = curX + c;

170.        int realY = curY + r;

171.        if (realY < 0) overflow = true;

172.        else if (realY <= 7 && realX >= 0 && realX <= 7) board[realY][realX] = 1;

173.      }

174.    }

175.  }

176.  return !overflow;

177. }

178. void clearLines() {

179.  for (int y = 7; y >= 0; y--) {

180.    bool full = true;

181.    for (int x = 0; x < 8; x++) if (!board[y][x]) full = false;

182.    if (full) {

183.      for (int k = y; k > 0; k--) {

184.        for (int x = 0; x < 8; x++) board[k][x] = board[k-1][x];

185.      }

186.      for (int x = 0; x < 8; x++) board[0][x] = 0;

187.      y++;

188.    }

189.  }

190. }

191. void doGameOver() {

192.  gamePhase = 3; // 停止遊戲迴圈 (LCD 時間此刻凍結)

193.  // 1. 矩陣模組閃爍三次

194.  for(int i=0; i<3; i++) {

195.    for(int r=0; r<8; r++) lc.setRow(0, r, 255);

196.    delay(200);

197.    lc.clearDisplay(0);

198.    delay(200);

199.  }

200.  lc.clearDisplay(0); // 歸零

201.  // 2. 停頓一秒 (LCD 仍顯示時間)

202.  delay(1000);

203.  // 3. 顯示 GAME OVER

204.  lcd.clear();

205.  lcd.setCursor(3, 0);

206.  lcd.print("GAME OVER");

207.  // 4. 停留 3 秒

208.  delay(3000);

209.  // 5. 回待機

210.  resetToStandby();

211. }

212. void resetToStandby() {

213.  gamePhase = 0;

214.  lc.clearDisplay(0);

215. }

216. // 繪圖

217. void drawGame() {

218.  lc.clearDisplay(0);

219.  for (int y = 0; y < 8; y++) {

220.    for (int x = 0; x < 8; x++) {

221.      if (board[y][x]) safeSetLed(y, x, true);

222.    }

223.  }

224.  for (int r = 0; r < 4; r++) {

225.    for (int c = 0; c < 4; c++) {

226.      if (blocks[curPiece][curRot][r][c]) {

227.        int realY = curY + r;

228.        int realX = curX + c;

229.        if (realY >= 0 && realY <= 7 && realX >= 0 && realX <= 7) safeSetLed(realY, realX, true);

230.      }

231.    }

232.  }

233. }

234. void safeSetLed(int row, int col, bool state) {

235.  int finalRow = row;

236.  int finalCol = col;

237.  if (ROTATE_MATRIX) { finalRow = col; finalCol = 7 - row; }

238.  if (INVERT_X) { finalCol = 7 - finalCol; }

239.  lc.setLed(0, finalRow, finalCol, state);

240. }