Étape 6: Écriture d’un code
Nous allons écrire du code pour le graver sur notre Conseil d’administration.
CODE
copier et graver ce code dans votre chambre
------------------------------------------------------------------------
#include '''LiquidCrystal.h ''
#define PIN_BUTTON 2
#define PIN_AUTOPLAY 1
#define PIN_READWRITE 10
#define PIN_CONTRAST 12
#define SPRITE_RUN1 1
#define SPRITE_RUN2 2
#define SPRITE_JUMP 3
#define SPRITE_JUMP_UPPER '.' / / utiliser le "." caractère pour la tête
#define SPRITE_JUMP_LOWER 4
#define SPRITE_TERRAIN_EMPTY "' / / utilisateur du ' ' caractère
#define SPRITE_TERRAIN_SOLID 5
#define SPRITE_TERRAIN_SOLID_RIGHT 6
#define SPRITE_TERRAIN_SOLID_LEFT 7
#define HERO_HORIZONTAL_POSITION 1 / / position horizontale du héros à l’écran
#define TERRAIN_WIDTH 16
#define TERRAIN_EMPTY 0
#define TERRAIN_LOWER_BLOCK 1
#define TERRAIN_UPPER_BLOCK 2
#define HERO_POSITION_OFF 0 / / Hero est invisible
#define HERO_POSITION_RUN_LOWER_1 1 / / Hero est en cours d’exécution sur la rangée inférieure (1 pose)
#define HERO_POSITION_RUN_LOWER_2 2 / / (posent 2)
#define HERO_POSITION_JUMP_1 3 / / à partir d’un saut
#define HERO_POSITION_JUMP_2 4 / / mi-hauteur
#define HERO_POSITION_JUMP_3 5 / / saut est sur la rangée supérieure
#define HERO_POSITION_JUMP_4 6 / / saut est sur la rangée supérieure
#define HERO_POSITION_JUMP_5 7 / / saut est sur la rangée supérieure
#define HERO_POSITION_JUMP_6 8 / / saut est sur la rangée supérieure
#define HERO_POSITION_JUMP_7 9 / / à mi-chemin vers le bas
#define HERO_POSITION_JUMP_8 10 / / a propos d’atterrir
#define HERO_POSITION_RUN_UPPER_1 11 / / Hero est en cours d’exécution sur la ligne supérieure (1 pose)
#define HERO_POSITION_RUN_UPPER_2 12 / / (posent 2)
Innovente lcd (11, 9, 6, 5, 4, 3) ;
public static char terrainUpper [TERRAIN_WIDTH + 1] ;
public static char terrainLower [TERRAIN_WIDTH + 1] ;
public static bool buttonPushed = false ;
void initializeGraphics() {}
statique graphique de Byte = {}
Position de marche 1
B01100,
B01100,
B00000,
B01110,
B11100,
B01100,
B11010,
B10011,
Position marche 2
B01100,
B01100,
B00000,
B01100,
B01100,
B01100,
B01100,
B01110,
Sauter
B01100,
B01100,
B00000,
B11110,
B01101,
B11111,
B10000,
B00000,
Saut en bas
B11110,
B01101,
B11111,
B10000,
B00000,
B00000,
B00000,
B00000,
Au sol
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
Terrain à droite
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
Motif à gauche
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
};
int i ;
Sauter à l’aide de caractère 0, cela permet de lcd.print() à être utilisé pour
dessiner rapidement des caractères multiples
pour (i = 0; i < 7; ++ j’ai) {
lcd.createChar (i + 1, & graphics [i * 8]) ;
}
pour (i = 0; i < TERRAIN_WIDTH; ++ j’ai) {
terrainUpper [i] = SPRITE_TERRAIN_EMPTY ;
terrainLower [i] = SPRITE_TERRAIN_EMPTY ;
}
}
Glissez le terrain vers la gauche par incréments de moitié-caractère
//
{} void advanceTerrain (char * terrain, newTerrain octets)
pour (int i = 0; i < TERRAIN_WIDTH; ++ j’ai) {
char actuel = terrain [i] ;
char = next (i == TERRAIN_WIDTH-1) ? newTerrain : terrain [i + 1] ;
{Switch (actuel)
affaire SPRITE_TERRAIN_EMPTY :
relief [i] = (suivant == SPRITE_TERRAIN_SOLID) ? SPRITE_TERRAIN_SOLID_RIGHT : SPRITE_TERRAIN_EMPTY ;
rupture ;
affaire SPRITE_TERRAIN_SOLID :
relief [i] = (suivant == SPRITE_TERRAIN_EMPTY) ? SPRITE_TERRAIN_SOLID_LEFT : SPRITE_TERRAIN_SOLID ;
rupture ;
affaire SPRITE_TERRAIN_SOLID_RIGHT :
relief [i] = SPRITE_TERRAIN_SOLID ;
rupture ;
affaire SPRITE_TERRAIN_SOLID_LEFT :
relief [i] = SPRITE_TERRAIN_EMPTY ;
rupture ;
}
}
}
bool drawHero (position de l’octet, terrainUpper char *, char * terrainLower, unsigned int score) {}
bool entrent en collision = false ;
char upperSave = terrainUpper [HERO_HORIZONTAL_POSITION] ;
char lowerSave = terrainLower [HERO_HORIZONTAL_POSITION] ;
upper octets, plus bas ;
commutateur (position) {}
affaire HERO_POSITION_OFF :
haut = bas = SPRITE_TERRAIN_EMPTY ;
rupture ;
affaire HERO_POSITION_RUN_LOWER_1 :
haut = SPRITE_TERRAIN_EMPTY ;
bas = SPRITE_RUN1 ;
rupture ;
affaire HERO_POSITION_RUN_LOWER_2 :
haut = SPRITE_TERRAIN_EMPTY ;
bas = SPRITE_RUN2 ;
rupture ;
affaire HERO_POSITION_JUMP_1 :
affaire HERO_POSITION_JUMP_8 :
haut = SPRITE_TERRAIN_EMPTY ;
bas = SPRITE_JUMP ;
rupture ;
affaire HERO_POSITION_JUMP_2 :
affaire HERO_POSITION_JUMP_7 :
haut = SPRITE_JUMP_UPPER ;
bas = SPRITE_JUMP_LOWER ;
rupture ;
affaire HERO_POSITION_JUMP_3 :
affaire HERO_POSITION_JUMP_4 :
affaire HERO_POSITION_JUMP_5 :
affaire HERO_POSITION_JUMP_6 :
haut = SPRITE_JUMP ;
bas = SPRITE_TERRAIN_EMPTY ;
rupture ;
affaire HERO_POSITION_RUN_UPPER_1 :
haut = SPRITE_RUN1 ;
bas = SPRITE_TERRAIN_EMPTY ;
rupture ;
affaire HERO_POSITION_RUN_UPPER_2 :
haut = SPRITE_RUN2 ;
bas = SPRITE_TERRAIN_EMPTY ;
rupture ;
}
Si (supérieur! = "") {}
terrainUpper [HERO_HORIZONTAL_POSITION] = supérieure ;
entrer en collision = (upperSave == SPRITE_TERRAIN_EMPTY) ? faux : true ;
}
Si (bas! = "") {}
terrainLower [HERO_HORIZONTAL_POSITION] = plus bas ;
Collide | = (lowerSave == SPRITE_TERRAIN_EMPTY) ? faux : true ;
}
chiffres de l’octet = (score > 9999) ? 5: (score > 999) ? 4: (score > 99) ? 3: (score > 9) ? 2: 1 ;
Dessiner la scène
terrainUpper [TERRAIN_WIDTH] = « \0 » ;
terrainLower [TERRAIN_WIDTH] = « \0 » ;
temp de char = terrainUpper [16 chiffres] ;
terrainUpper [16 chiffres] = « \0 » ;
lcd.setCursor(0,0) ;
LCD.Print(terrainUpper) ;
terrainUpper [16 chiffres] = temp ;
lcd.setCursor(0,1) ;
LCD.Print(terrainLower) ;
lcd.setCursor (16 - chiffres, 0) ;
LCD.Print(score) ;
terrainUpper [HERO_HORIZONTAL_POSITION] = upperSave ;
terrainLower [HERO_HORIZONTAL_POSITION] = lowerSave ;
retour en collision ;
}
Gérer la poussée de bouton comme une interruption
void buttonPush() {}
buttonPushed = true ;
}
void setup() {}
pinMode (PIN_READWRITE, sortie) ;
digitalWrite (PIN_READWRITE, basse) ;
pinMode (PIN_CONTRAST, sortie) ;
digitalWrite (PIN_CONTRAST, basse) ;
pinMode (entrée, PIN_BUTTON) ;
digitalWrite (PIN_BUTTON, élevé) ;
pinMode (PIN_AUTOPLAY, sortie) ;
digitalWrite (PIN_AUTOPLAY, élevé) ;
La broche numérique 2 cartes pour interrompre 0
attachInterrupt (0 / * PIN_BUTTON * /, buttonPush, chute) ;
initializeGraphics() ;
LCD.Begin (16, 2) ;
}
void loop() {}
public static byte heroPos = HERO_POSITION_RUN_LOWER_1 ;
public static byte newTerrainType = TERRAIN_EMPTY ;
newTerrainDuration statique octets = 1 ;
public static bool jouant = false ;
public static bool clignotement = false ;
static unsigned int distance = 0 ;
Si (! jouer) {}
drawHero((blink) ? HERO_POSITION_OFF : heroPos, terrainUpper, terrainLower, distance >> 3) ;
Si {(clin)
lcd.setCursor(0,0) ;
LCD.Print ("Press Start") ;
}
Delay(250) ;
clignote =! cligner des yeux ;
Si {(buttonPushed)
initializeGraphics() ;
heroPos = HERO_POSITION_RUN_LOWER_1 ;
jouer = true ;
buttonPushed = false ;
distance = 0 ;
}
retour ;
}
Déplacer le terrain vers la gauche
advanceTerrain (terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY) ;
advanceTerrain (terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY) ;
Nouveaux terrains d’entrer sur le droit de faire
Si (--newTerrainDuration == 0) {}
Si (newTerrainType == TERRAIN_EMPTY) {}
newTerrainType = (random(3) == 0) ? TERRAIN_UPPER_BLOCK : TERRAIN_LOWER_BLOCK ;
newTerrainDuration = 2 + random(10) ;
} else {}
newTerrainType = TERRAIN_EMPTY ;
newTerrainDuration = 10 + random(10) ;
}
}
Si {(buttonPushed)
Si (heroPos < = HERO_POSITION_RUN_LOWER_2) heroPos = HERO_POSITION_JUMP_1 ;
buttonPushed = false ;
}
Si (drawHero (heroPos, terrainUpper, terrainLower, distance >> 3)) {}
Playing = false ; Le héros est entré en collision avec quelque chose. Tant pis.
} else {}
Si (heroPos == HERO_POSITION_RUN_LOWER_2 || heroPos == HERO_POSITION_JUMP_8) {}
heroPos = HERO_POSITION_RUN_LOWER_1 ;
} else if ((heroPos > = HERO_POSITION_JUMP_3 & & heroPos < = HERO_POSITION_JUMP_5) & & terrainLower [HERO_HORIZONTAL_POSITION]! = SPRITE_TERRAIN_EMPTY) {}
heroPos = HERO_POSITION_RUN_UPPER_1 ;
} else if (heroPos > = HERO_POSITION_RUN_UPPER_1 & & terrainLower [HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY) {}
heroPos = HERO_POSITION_JUMP_5 ;
} ElseIf (heroPos == HERO_POSITION_RUN_UPPER_2) {}
heroPos = HERO_POSITION_RUN_UPPER_1 ;
} else {}
++ heroPos ;
}
++ à distance ;
digitalWrite (PIN_AUTOPLAY, terrainLower [HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY ? HAUT : BAS) ;
}
Delay(100) ;
}