Paso 6: Escribir algo de código
A escribir algo de código a grabar en nuestro tablero.
CÓDIGO
copiar y grabar este código en su placa
------------------------------------------------------------------------
#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 '.' / / usar el '.' carácter para la cabeza
#define SPRITE_JUMP_LOWER 4
#define SPRITE_TERRAIN_EMPTY ' ' / / usuario la ' ' carácter
#define SPRITE_TERRAIN_SOLID 5
#define SPRITE_TERRAIN_SOLID_RIGHT 6
#define SPRITE_TERRAIN_SOLID_LEFT 7
#define HERO_HORIZONTAL_POSITION 1 / / posición del héroe en pantalla Horizontal
#define TERRAIN_WIDTH 16
#define TERRAIN_EMPTY 0
#define TERRAIN_LOWER_BLOCK 1
#define TERRAIN_UPPER_BLOCK 2
#define HERO_POSITION_OFF 0 / / héroe es invisible
#define HERO_POSITION_RUN_LOWER_1 1 / / héroe se está ejecutando en la fila inferior (postura 1)
#define HERO_POSITION_RUN_LOWER_2 2 / / (pose 2)
#define HERO_POSITION_JUMP_1 3 / / a partir de un salto
#define HERO_POSITION_JUMP_2 4 / / mitad
#define HERO_POSITION_JUMP_3 5 / salto está en la fila superior
#define HERO_POSITION_JUMP_4 6 / salto está en la fila superior
#define HERO_POSITION_JUMP_5 7 / salto está en la fila superior
#define HERO_POSITION_JUMP_6 8 / salto está en la fila superior
#define HERO_POSITION_JUMP_7 9 / / mitad
#define HERO_POSITION_JUMP_8 10 / / sobre la tierra
#define HERO_POSITION_RUN_UPPER_1 11 / / héroe se está ejecutando en la fila superior (postura 1)
#define HERO_POSITION_RUN_UPPER_2 12 / / (pose 2)
LiquidCrystal lcd (11, 9, 6, 5, 4, 3);
Static char terrainUpper [TERRAIN_WIDTH + 1];
Static char terrainLower [TERRAIN_WIDTH + 1];
Static bool buttonPushed = false;
void initializeGraphics() {}
gráficos de estática bytes [] = {}
Posición de arranque 1
B01100,
B01100,
B00000,
B01110,
B11100,
B01100,
B11010,
B10011,
Posición de arranque 2
B01100,
B01100,
B00000,
B01100,
B01100,
B01100,
B01100,
B01110,
Salto
B01100,
B01100,
B00000,
B11110,
B01101,
B11111,
B10000,
B00000,
Salto inferior
B11110,
B01101,
B11111,
B10000,
B00000,
B00000,
B00000,
B00000,
Tierra
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
Derecho de tierra
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
Planta izquierda
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
};
int i;
Saltar con carácter 0, esto permite que lcd.print() ser utilizado para
rápidamente dibuje varios caracteres
para (i = 0; i < 7; ++ i) {}
lcd.createChar (i + 1 y gráficos [i * 8]);
}
para (i = 0; i < TERRAIN_WIDTH; ++ i) {}
terrainUpper [i] = SPRITE_TERRAIN_EMPTY;
terrainLower [i] = SPRITE_TERRAIN_EMPTY;
}
}
Deslice el terreno hacia la izquierda en incrementos de medio carácter
//
{} void advanceTerrain (char * terreno, newTerrain bytes)
para (int i = 0; i < TERRAIN_WIDTH; ++ i) {}
char actual = terreno [i];
¿char = siguiente (i == TERRAIN_WIDTH-1)? newTerrain: terreno [i + 1];
interruptor (corriente) {}
caso SPRITE_TERRAIN_EMPTY:
¿terreno [i] = (siguiente == SPRITE_TERRAIN_SOLID)? SPRITE_TERRAIN_SOLID_RIGHT: SPRITE_TERRAIN_EMPTY;
rotura;
caso SPRITE_TERRAIN_SOLID:
¿terreno [i] = (siguiente == SPRITE_TERRAIN_EMPTY)? SPRITE_TERRAIN_SOLID_LEFT: SPRITE_TERRAIN_SOLID;
rotura;
caso SPRITE_TERRAIN_SOLID_RIGHT:
terreno [i] = SPRITE_TERRAIN_SOLID;
rotura;
caso SPRITE_TERRAIN_SOLID_LEFT:
terreno [i] = SPRITE_TERRAIN_EMPTY;
rotura;
}
}
}
bool drawHero (posición de byte, char * terrainUpper, char * terrainLower, int sin signo de puntuación) {}
bool chocan = false;
char upperSave = terrainUpper [HERO_HORIZONTAL_POSITION];
char lowerSave = terrainLower [HERO_HORIZONTAL_POSITION];
superior del byte, más bajo;
(posición) {}
caso HERO_POSITION_OFF:
superior = inferior = SPRITE_TERRAIN_EMPTY;
rotura;
caso HERO_POSITION_RUN_LOWER_1:
alto = SPRITE_TERRAIN_EMPTY;
menor = SPRITE_RUN1;
rotura;
caso HERO_POSITION_RUN_LOWER_2:
alto = SPRITE_TERRAIN_EMPTY;
menor = SPRITE_RUN2;
rotura;
caso HERO_POSITION_JUMP_1:
caso HERO_POSITION_JUMP_8:
alto = SPRITE_TERRAIN_EMPTY;
menor = SPRITE_JUMP;
rotura;
caso HERO_POSITION_JUMP_2:
caso HERO_POSITION_JUMP_7:
alto = SPRITE_JUMP_UPPER;
menor = SPRITE_JUMP_LOWER;
rotura;
caso HERO_POSITION_JUMP_3:
caso HERO_POSITION_JUMP_4:
caso HERO_POSITION_JUMP_5:
caso HERO_POSITION_JUMP_6:
alto = SPRITE_JUMP;
menor = SPRITE_TERRAIN_EMPTY;
rotura;
caso HERO_POSITION_RUN_UPPER_1:
alto = SPRITE_RUN1;
menor = SPRITE_TERRAIN_EMPTY;
rotura;
caso HERO_POSITION_RUN_UPPER_2:
alto = SPRITE_RUN2;
menor = SPRITE_TERRAIN_EMPTY;
rotura;
}
Si (superior! = ' ') {}
terrainUpper [HERO_HORIZONTAL_POSITION] = superior;
¿chocar = (upperSave == SPRITE_TERRAIN_EMPTY)? false: true;
}
Si (menor! = ' ') {}
terrainLower [HERO_HORIZONTAL_POSITION] = más bajo;
¿chocan | = (lowerSave == SPRITE_TERRAIN_EMPTY)? false: true;
}
¿dígitos del byte = (puntaje > 9999)? ¿5: (puntuación > 999)? ¿4: (puntuación > 99)? ¿3: (puntuación > 9)? 2: 1;
Dibujar la escena
terrainUpper [TERRAIN_WIDTH] = '\0';
terrainLower [TERRAIN_WIDTH] = '\0';
char temp = terrainUpper [16-dígitos];
terrainUpper [16-dígitos] = '\0';
lcd.setCursor(0,0);
LCD.Print(terrainUpper);
terrainUpper [16-dígitos] = temp;
lcd.setCursor(0,1);
LCD.Print(terrainLower);
lcd.setCursor (16 - dígitos, 0);
LCD.Print(score);
terrainUpper [HERO_HORIZONTAL_POSITION] = upperSave;
terrainLower [HERO_HORIZONTAL_POSITION] = lowerSave;
regreso chocan;
}
El empuje del botón de la manija como una interrupción
void buttonPush() {}
buttonPushed = true;
}
void setup() {}
pinMode (PIN_READWRITE, salida);
digitalWrite (PIN_READWRITE, bajo);
pinMode (PIN_CONTRAST, salida);
digitalWrite (PIN_CONTRAST, bajo);
pinMode (PIN_BUTTON, entrada);
digitalWrite (PIN_BUTTON, alto);
pinMode (PIN_AUTOPLAY, salida);
digitalWrite (PIN_AUTOPLAY, alto);
Pin digital 2 mapas para interrumpir 0
attachInterrupt (0 / * PIN_BUTTON *, buttonPush, caer);
initializeGraphics();
LCD.Begin (16, 2);
}
void loop() {}
Static byte heroPos = HERO_POSITION_RUN_LOWER_1;
Static byte newTerrainType = TERRAIN_EMPTY;
Static byte newTerrainDuration = 1;
Static bool jugando = false;
Static bool blink = false;
Static unsigned int distancia = 0;
Si (! jugando) {}
¿drawhero((Blink)? HERO_POSITION_OFF: heroPos, terrainUpper, terrainLower, distancia >> 3);
Si {} (destello)
lcd.setCursor(0,0);
LCD.Print ("Press Start");
}
Delay(250);
parpadeo =! a parpadear;
Si (buttonPushed) {}
initializeGraphics();
heroPos = HERO_POSITION_RUN_LOWER_1;
jugando = true;
buttonPushed = false;
distancia = 0;
}
retorno;
}
Cambio terreno a la izquierda
¿advanceterrain (terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK? SPRITE_TERRAIN_SOLID: SPRITE_TERRAIN_EMPTY);
¿advanceterrain (terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK? SPRITE_TERRAIN_SOLID: SPRITE_TERRAIN_EMPTY);
Hacer nuevo terreno para entrar a la derecha
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, distancia >> 3)) {}
jugando = false; El héroe chocó con algo. Muy mal.
} 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;
} else if (heroPos == HERO_POSITION_RUN_UPPER_2) {}
heroPos = HERO_POSITION_RUN_UPPER_1;
} else {}
++ heroPos;
}
++ a distancia;
¿digitalWrite (PIN_AUTOPLAY, terrainLower [HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY? ALTO: BAJA);
}
Delay(100);
}
