#include <LiquidCrystal_I2C.h>
#include "fonctionsObjets.h"

void setup() 
{
initialise();
}

void loop() { 
  /* CONTROLE DES MOUVEMENTS SUR LES AXES DU JOYSTICK */
if (millis() > (perso.CompteurVitesse+perso.Vitesse))
{deplacementJoystick();}

if (millis() > (mechant.CompteurVitesse+mechant.Vitesse))
{mechantDeplacement();}

}

sketch.ino

diagram.json

#include <LiquidCrystal_I2C.h>
#include "graphismesObjets.h"
#include "structures.h"
#include "deplacementMechant.h"
int J1, J2;
int seuilActionBas = 15;
int seuilActionHaut = 1000;

LiquidCrystal_I2C lcd(0x27, 20, 4);
Perso perso;
Mechant mechant;
Clef clef;


void effacerCase()
{
 lcd.print(" ");
}
void mechantDeplacement() {
  
    // Mise à jour de la position
    int dx = deplacements[mechant.CompteurPosition - 1][0];
    int dy = deplacements[mechant.CompteurPosition - 1][1];

    // Effacer l'ancienne position
    lcd.setCursor(mechant.Position.colonne, mechant.Position.ligne);
    effacerCase();

    // Mettre à jour la position du méchant
    mechant.Position.colonne += dx;
    mechant.Position.ligne += dy;

    // Afficher à la nouvelle position
    lcd.setCursor(mechant.Position.colonne, mechant.Position.ligne);
    lcd.write(3);

    // Passer à la position suivante
    mechant.CompteurPosition++;
    if (mechant.CompteurPosition > 8) {
        mechant.CompteurPosition = 1;
    }

    // Mettre à jour le compteur de vitesse
    mechant.CompteurVitesse = millis();
}


void droite()
{
  perso.Position.colonne++;
  if (perso.Position.colonne > 19) {perso.Position.colonne = 19;} //on n'accepte le déplacement 
                                 //que dans les limites de l'écran
  lcd.setCursor(perso.Position.colonne,perso.Position.ligne);
  lcd.write(0);
  lcd.setCursor(perso.Position.colonne-1,perso.Position.ligne);
 effacerCase();
    }

void gauche()
{
  perso.Position.colonne--;
  if (perso.Position.colonne < 0) {perso.Position.colonne =0;}
  lcd.setCursor(perso.Position.colonne,perso.Position.ligne);
  lcd.write(0);
  lcd.setCursor(perso.Position.colonne+1,perso.Position.ligne);
  effacerCase();
  }

void bas()
{
  perso.Position.ligne++;
  if (perso.Position.ligne > 3) {perso.Position.ligne=3;}
  lcd.setCursor(perso.Position.colonne,perso.Position.ligne);
  lcd.write(0);
  lcd.setCursor(perso.Position.colonne,perso.Position.ligne-1);
  effacerCase();
}

void haut()
{
    perso.Position.ligne--;
    if (perso.Position.ligne < 0) {perso.Position.ligne=0;} 
  lcd.setCursor(perso.Position.colonne,perso.Position.ligne);
  lcd.write(0);
  lcd.setCursor(perso.Position.colonne,perso.Position.ligne+1);
  effacerCase();
  }

void initialise()
{
    lcd.init();
  lcd.backlight();
  lcd.createChar(0, persoGraphique);
  lcd.createChar(1, coeurGraphique);  
  lcd.createChar(3, mechantGraphique);  
  lcd.createChar(4, clefGraphique);  

  lcd.setCursor(perso.Position.colonne,perso.Position.ligne);
  lcd.write(0);

  lcd.setCursor(19,3); // on se positionne en bas à droite
  lcd.write(1); // on affiche un objet "coeur"

  lcd.setCursor(mechant.Position.colonne,mechant.Position.ligne);
  lcd.write(3);
  lcd.setCursor(clef.Position.colonne,clef.Position.ligne);
  lcd.write(4);
}

void deplacementJoystick()
{ 
  J1 = analogRead(0); J2 = analogRead(1);

if (J1 < seuilActionBas) {bas();perso.CompteurVitesse = millis();}
if (J1 > seuilActionHaut) {haut();perso.CompteurVitesse = millis();}
if (J2 < seuilActionBas) {droite();perso.CompteurVitesse = millis();}
if (J2 >seuilActionHaut) {gauche();perso.CompteurVitesse = millis();}
}



fonctionsObjets.h

byte persoGraphique[] = {
   B00000,
  B00000,
  B00100,
  B01110,
  B00100,
  B01110,
  B01110,
  B00100
};
byte coeurGraphique[] = {
  B01110,
  B01010,
  B01110,
  B00100,
  B00100,
  B01100,
  B00100,
  B00000
};
byte sablierGraphique[] = {
B00000,
  B01010,
  B10101,
  B10001,
  B01010,
  B00100,
  B00000,
  B00000
};
byte mechantGraphique[] = {
   B11111,
  B10101,
  B01110,
  B10101,
  B11111,
  B00100,
  B01010,
  B10001
};

byte portail[]=  {
 B10101,
  B11111,
  B10001,
  B10001,
  B10001,
  B11111,
  B01110,
  B11111
}; 

byte vide[] = {
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

const byte clefGraphique[] = {
  B00110,
  B00100,
  B00110,
  B00100,
  B00100,
  B01110,
  B01010,
  B01110
};

graphismesObjets.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
LiquidCrystal I2C


libraries.txt

struct Coordonnees{ int colonne;  int ligne;  };

struct Perso
{
Coordonnees Position{0,0};
int Vitesse = 100;
unsigned long CompteurVitesse=0;
};

struct Mechant
{
Coordonnees Position{14,1};
int Vitesse = 300;
unsigned long CompteurVitesse=0;
byte CompteurPosition = 1;
};

struct Clef
{
Coordonnees Position{14,2};
};



structures.h

// ================================
// Types de déplacements pour le méchant
// Chaque tableau contient 8 mouvements
// À la fin, le méchant revient à sa position initiale
// ================================

/* ======= Déplacement en LOSANGE ======= */
// Déplacement en forme de losange, le méchant effectue des mouvements diagonaux
const int deplacements[8][2] = {
    {1, 1},   // Bas-droite
    {-1, 1},  // Bas-gauche
    {-1, -1}, // Haut-gauche
    {1, -1},  // Haut-droite
    {1, 1},   // Bas-droite
    {-1, 1},  // Bas-gauche
    {-1, -1}, // Haut-gauche
    {1, -1}   // Haut-droite
};
/*

======= Déplacement en CARRÉ =======
// Déplacement en carré autour d'un point central
// Le méchant effectue des mouvements horizontaux et verticaux
const int deplacements[8][2] = {
    {1, 0},   // Droite
    {0, 1},   // Bas
    {0, 1},   // Bas
    {-1, 0},  // Gauche
    {-1, 0},  // Gauche
    {0, -1},  // Haut
    {0, -1},  // Haut
    {1, 0}    // Droite
};
*/

/*======= Déplacement en CERCLE =======
// Déplacement circulaire approximatif (mélange de diagonales et de lignes droites)
// Le méchant se déplace autour d'un point central
const int deplacements[8][2] = {
    {1, 0},   // Droite
    {1, 1},   // Bas-droite
    {0, 1},   // Bas
    {-1, 1},  // Bas-gauche
    {-1, 0},  // Gauche
    {-1, -1}, // Haut-gauche
    {0, -1},  // Haut
    {1, -1}   // Haut-droite
};
*/
/*
======= Déplacement en ANGLE =======
const int deplacements[8][2] = {
    {1, 0},   // Droite
    {-1, 0},  // Gauche
       {-1, 0},  // Gauche
    {0, 1},   // Bas
    {0, -1},  // Haut
    {1, 0},   // Droite
   {1, 0},   // Droite
    {-1, 0} // Gauche
    
};
*/

/*
======= Déplacement en ZIGZAG =======
// Déplacement en zigzag horizontal
// Le méchant avance en zigzag sur deux lignes
const int deplacements[8][2] = {
    {1, 1},   // Bas-droite
    {-1, 1},  // Bas-gauche
    {1, -1},  // Haut-droite
    {-1, -1}, // Haut-gauche
    {1, 1},   // Bas-droite
    {-1, 1},  // Bas-gauche
    {1, -1},  // Haut-droite
    {-1, -1}  // Haut-gauche
};
*/
