Jeux et applications Arduino avec les écrans TFT tactiles 2.4 et 3.5 pouces

				
					/*
Site : www.atelierdelarobotique.fr
Date: 19/06/2026
Jeu de Dames
*/
#include <MCUFRIEND_kbv.h>
#include <Adafruit_GFX.h>
#include <TouchScreen.h>

MCUFRIEND_kbv tft;

// Pins tactiles courants pour shield TFT 2.4" Arduino Uno
#define YP A1
#define XM A2
#define YM 7
#define XP 6

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);

#define MINPRESSURE 10
#define MAXPRESSURE 1000

// Calibration tactile approximative
// À ajuster si le toucher est décalé
#define TS_MINX 199
#define TS_MAXX 922
#define TS_MINY 223
#define TS_MAXY 920

// Couleurs RGB565
#define BLACK       0x0000
#define WHITE       0xFFFF
#define RED         0xF800
#define GREEN       0x07E0
#define BLUE        0x001F
#define YELLOW      0xFFE0
#define GREY        0x8410
#define DARKSQUARE  0x7BEF
#define LIGHTSQUARE 0xEF5D

// Écran en paysage : 320 x 240
#define BOARD_X 0
#define BOARD_Y 0
#define CELL 30
#define BOARD_SIZE 240
#define PANEL_X 245

// Pièces
#define EMPTY 0
#define WHITE_MAN 1
#define WHITE_KING 2
#define BLACK_MAN -1
#define BLACK_KING -2

int8_t board[8][8];

bool whiteTurn = true;
int selectedX = -1;
int selectedY = -1;

void newGame();
void drawAll();
void drawBoard();
void drawPieces();
void drawPiece(int x, int y);
void drawPanel();
void convertTouch(TSPoint p, int &x, int &y);
void handleTouch(int sx, int sy);
bool isCurrentPlayerPiece(int8_t piece);
bool isOpponentPiece(int8_t piece);
bool tryMove(int fromX, int fromY, int toX, int toY);
void movePiece(int fromX, int fromY, int toX, int toY);
void promoteIfNeeded(int x, int y);
void checkWinner();
void showWinner(bool whiteWins);

void setup() {
  Serial.begin(9600);

  uint16_t ID = tft.readID();

  Serial.print(F("ID ecran : 0x"));
  Serial.println(ID, HEX);

  if (ID == 0xD3D3 || ID == 0xFFFF || ID == 0x0000) {
    ID = 0x9341;  // ILI9341 courant
  }

  tft.begin(ID);
  tft.setRotation(1);
  tft.fillScreen(BLACK);

  newGame();
}

void loop() {
  TSPoint p = ts.getPoint();

  // Important : les pins tactiles sont partagées avec le TFT
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);

  if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {
    int sx, sy;
    convertTouch(p, sx, sy);

    Serial.print(F("X="));
    Serial.print(sx);
    Serial.print(F(" Y="));
    Serial.print(sy);
    Serial.print(F(" P="));
    Serial.println(p.z);

    handleTouch(sx, sy);

    delay(180);
  }
}

void newGame() {
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 8; x++) {
      board[y][x] = EMPTY;
    }
  }

  // Noirs en haut
  for (int y = 0; y < 3; y++) {
    for (int x = 0; x < 8; x++) {
      if ((x + y) % 2 == 1) {
        board[y][x] = BLACK_MAN;
      }
    }
  }

  // Blancs en bas
  for (int y = 5; y < 8; y++) {
    for (int x = 0; x < 8; x++) {
      if ((x + y) % 2 == 1) {
        board[y][x] = WHITE_MAN;
      }
    }
  }

  whiteTurn = true;
  selectedX = -1;
  selectedY = -1;

  drawAll();
}

void drawAll() {
  tft.fillScreen(BLACK);
  drawBoard();
  drawPieces();
  drawPanel();
}

void drawBoard() {
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 8; x++) {
      uint16_t color;

      if ((x + y) % 2 == 0) {
        color = LIGHTSQUARE;
      } else {
        color = DARKSQUARE;
      }

      tft.fillRect(BOARD_X + x * CELL, BOARD_Y + y * CELL, CELL, CELL, color);
    }
  }

  tft.drawRect(BOARD_X, BOARD_Y, BOARD_SIZE, BOARD_SIZE, WHITE);
}

void drawPieces() {
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 8; x++) {
      drawPiece(x, y);
    }
  }

  if (selectedX >= 0 && selectedY >= 0) {
    int px = selectedX * CELL;
    int py = selectedY * CELL;

    tft.drawRect(px + 1, py + 1, CELL - 2, CELL - 2, YELLOW);
    tft.drawRect(px + 2, py + 2, CELL - 4, CELL - 4, YELLOW);
  }
}

void drawPiece(int x, int y) {
  int8_t piece = board[y][x];

  if (piece == EMPTY) return;

  int cx = BOARD_X + x * CELL + CELL / 2;
  int cy = BOARD_Y + y * CELL + CELL / 2;

  if (piece > 0) {
    // Pion blanc
    tft.fillCircle(cx, cy, 11, WHITE);
    tft.drawCircle(cx, cy, 11, BLACK);
  } else {
    // Pion noir
    tft.fillCircle(cx, cy, 11, BLACK);
    tft.drawCircle(cx, cy, 11, WHITE);
  }

  // Affichage des dames
  if (abs(piece) == 2) {
    tft.setTextSize(2);

    if (piece > 0) {
      tft.setTextColor(BLACK);
    } else {
      tft.setTextColor(WHITE);
    }

    tft.setCursor(cx - 6, cy - 8);
    tft.print(F("D"));
  }
}

void drawPanel() {
  tft.fillRect(PANEL_X, 0, 75, 240, BLACK);

  tft.setTextSize(1);
  tft.setTextColor(WHITE);
  tft.setCursor(PANEL_X + 5, 10);
  tft.println(F("DAMES"));

  tft.drawLine(PANEL_X, 30, 319, 30, WHITE);

  tft.setCursor(PANEL_X + 5, 45);
  tft.println(F("Tour:"));

  tft.setTextSize(2);
  tft.setCursor(PANEL_X + 5, 65);

  if (whiteTurn) {
    tft.setTextColor(WHITE);
    tft.println(F("BLANC"));
  } else {
    tft.setTextColor(RED);
    tft.println(F("NOIR"));
  }

  tft.setTextSize(1);
  tft.setTextColor(WHITE);
  tft.setCursor(PANEL_X + 5, 110);
  tft.println(F("Toucher"));
  tft.setCursor(PANEL_X + 5, 123);
  tft.println(F("piece"));
  tft.setCursor(PANEL_X + 5, 136);
  tft.println(F("puis case"));

  // Bouton nouvelle partie
  tft.fillRect(PANEL_X + 5, 190, 65, 35, BLUE);
  tft.drawRect(PANEL_X + 5, 190, 65, 35, WHITE);

  tft.setTextSize(1);
  tft.setTextColor(WHITE);
  tft.setCursor(PANEL_X + 18, 203);
  tft.println(F("NEW"));
}

/*void convertTouch(TSPoint p, int &x, int &y) {
  x = map(p.y, TS_MINY, TS_MAXY, 0, tft.width());
  y = map(p.x, TS_MINX, TS_MAXX, tft.height(), 0);

  x = constrain(x, 0, tft.width() - 1);
  y = constrain(y, 0, tft.height() - 1);
} */
void convertTouch(TSPoint p, int &x, int &y) {
  x = map(p.y, TS_MINY, TS_MAXY, tft.width(), 0);
  y = map(p.x, TS_MINX, TS_MAXX, tft.height(), 0);

  x = constrain(x, 0, tft.width() - 1);
  y = constrain(y, 0, tft.height() - 1);
}

void handleTouch(int sx, int sy) {
  // Bouton NEW
  if (sx >= PANEL_X + 5 && sx <= PANEL_X + 70 && sy >= 190 && sy <= 225) {
    newGame();
    return;
  }

  // Hors plateau
  if (sx < BOARD_X || sx >= BOARD_X + BOARD_SIZE || sy < BOARD_Y || sy >= BOARD_Y + BOARD_SIZE) {
    return;
  }

  int bx = (sx - BOARD_X) / CELL;
  int by = (sy - BOARD_Y) / CELL;

  if (bx < 0 || bx > 7 || by < 0 || by > 7) return;

  int8_t touchedPiece = board[by][bx];

  // Première sélection
  if (selectedX == -1 || selectedY == -1) {
    if (isCurrentPlayerPiece(touchedPiece)) {
      selectedX = bx;
      selectedY = by;
      drawAll();
    }
    return;
  }

  // Changer de pièce sélectionnée
  if (isCurrentPlayerPiece(touchedPiece)) {
    selectedX = bx;
    selectedY = by;
    drawAll();
    return;
  }

  // Tenter le déplacement
  if (tryMove(selectedX, selectedY, bx, by)) {
    selectedX = -1;
    selectedY = -1;

    whiteTurn = !whiteTurn;

    drawAll();
    checkWinner();
  } else {
    selectedX = -1;
    selectedY = -1;
    drawAll();
  }
}

bool isCurrentPlayerPiece(int8_t piece) {
  if (piece == EMPTY) return false;

  if (whiteTurn && piece > 0) return true;
  if (!whiteTurn && piece < 0) return true;

  return false;
}

bool isOpponentPiece(int8_t piece) {
  if (piece == EMPTY) return false;

  if (whiteTurn && piece < 0) return true;
  if (!whiteTurn && piece > 0) return true;

  return false;
}

int signInt(int v) {
  if (v > 0) return 1;
  if (v < 0) return -1;
  return 0;
}
bool tryMove(int fromX, int fromY, int toX, int toY) {
  if (toX < 0 || toX > 7 || toY < 0 || toY > 7) return false;
  if (board[toY][toX] != EMPTY) return false;

  int8_t piece = board[fromY][fromX];

  if (!isCurrentPlayerPiece(piece)) return false;

  int dx = toX - fromX;
  int dy = toY - fromY;

  int absDx = abs(dx);
  int absDy = abs(dy);

  bool isKing = abs(piece) == 2;

  // Les blancs montent, les noirs descendent
  int forward = whiteTurn ? -1 : 1;

  // -----------------------------------
  // DEPLACEMENT DES DAMES
  // -----------------------------------
  if (isKing) {
    // Une dame doit rester sur une diagonale
    if (absDx != absDy) return false;

    int stepX = signInt(dx);
    int stepY = signInt(dy);

    int x = fromX + stepX;
    int y = fromY + stepY;

    int opponentCount = 0;
    int opponentX = -1;
    int opponentY = -1;

    // On analyse toutes les cases entre depart et arrivee
    while (x != toX && y != toY) {
      int8_t current = board[y][x];

      if (current != EMPTY) {
        // Si c'est une piece a nous, mouvement impossible
        if (isCurrentPlayerPiece(current)) {
          return false;
        }

        // Si c'est une piece adverse
        if (isOpponentPiece(current)) {
          opponentCount++;
          opponentX = x;
          opponentY = y;

          // Une seule piece peut etre prise a la fois
          if (opponentCount > 1) {
            return false;
          }
        }
      }

      x += stepX;
      y += stepY;
    }

    // Deplacement simple de plusieurs cases
    if (opponentCount == 0) {
      movePiece(fromX, fromY, toX, toY);
      return true;
    }

    // Prise longue : une seule piece adverse sur la diagonale
    if (opponentCount == 1) {
      board[opponentY][opponentX] = EMPTY;
      movePiece(fromX, fromY, toX, toY);
      return true;
    }

    return false;
  }

  // -----------------------------------
  // DEPLACEMENT DES PIONS SIMPLES
  // -----------------------------------

  // Deplacement simple
  if (absDx == 1 && absDy == 1) {
    if (dy == forward) {
      movePiece(fromX, fromY, toX, toY);
      promoteIfNeeded(toX, toY);
      return true;
    }
  }

  // Prise simple
 /* if (absDx == 2 && absDy == 2) {
    int midX = (fromX + toX) / 2;
    int midY = (fromY + toY) / 2;

    if (isOpponentPiece(board[midY][midX])) {
      if (dy == 2 * forward) {
        board[midY][midX] = EMPTY;
        movePiece(fromX, fromY, toX, toY);
        promoteIfNeeded(toX, toY);
        return true;
      }
    }
  } */
  // Prise simple
if (absDx == 2 && absDy == 2) {
  int midX = (fromX + toX) / 2;
  int midY = (fromY + toY) / 2;

  if (isOpponentPiece(board[midY][midX])) {
    board[midY][midX] = EMPTY;
    movePiece(fromX, fromY, toX, toY);
    promoteIfNeeded(toX, toY);
    return true;
  }
}

  return false;
}

/*bool tryMove(int fromX, int fromY, int toX, int toY) {
  if (toX < 0 || toX > 7 || toY < 0 || toY > 7) return false;
  if (board[toY][toX] != EMPTY) return false;

  int8_t piece = board[fromY][fromX];

  if (!isCurrentPlayerPiece(piece)) return false;

  int dx = toX - fromX;
  int dy = toY - fromY;

  int absDx = abs(dx);
  int absDy = abs(dy);

  bool isKing = abs(piece) == 2;

  // Blancs montent, noirs descendent
  int forward = whiteTurn ? -1 : 1;

  // Déplacement simple
  if (absDx == 1 && absDy == 1) {
    if (isKing || dy == forward) {
      movePiece(fromX, fromY, toX, toY);
      promoteIfNeeded(toX, toY);
      return true;
    }
  }

  // Prise simple
  if (absDx == 2 && absDy == 2) {
    int midX = (fromX + toX) / 2;
    int midY = (fromY + toY) / 2;

    if (isOpponentPiece(board[midY][midX])) {
      if (isKing || dy == 2 * forward) {
        board[midY][midX] = EMPTY;
        movePiece(fromX, fromY, toX, toY);
        promoteIfNeeded(toX, toY);
        return true;
      }
    }
  }

  return false;
}*/

void movePiece(int fromX, int fromY, int toX, int toY) {
  board[toY][toX] = board[fromY][fromX];
  board[fromY][fromX] = EMPTY;
}

void promoteIfNeeded(int x, int y) {
  if (board[y][x] == WHITE_MAN && y == 0) {
    board[y][x] = WHITE_KING;
  }

  if (board[y][x] == BLACK_MAN && y == 7) {
    board[y][x] = BLACK_KING;
  }
}

void checkWinner() {
  int whiteCount = 0;
  int blackCount = 0;

  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 8; x++) {
      if (board[y][x] > 0) whiteCount++;
      if (board[y][x] < 0) blackCount++;
    }
  }

  if (whiteCount == 0) {
    showWinner(false);
  }

  if (blackCount == 0) {
    showWinner(true);
  }
}

void showWinner(bool whiteWins) {
  tft.fillRect(20, 80, 200, 80, BLUE);
  tft.drawRect(20, 80, 200, 80, WHITE);

  tft.setTextSize(2);
  tft.setTextColor(WHITE);
  tft.setCursor(45, 95);
  tft.println(F("VICTOIRE"));

  tft.setCursor(55, 125);

  if (whiteWins) {
    tft.println(F("BLANCS"));
  } else {
    tft.println(F("NOIRS"));
  }

  delay(2500);
  newGame();
}