/* /____________________/Imagens Do Game: SpaceFox/____________________/
const uint8_t Mancha_3 []PROGMEM = {
0x00, 0x80, 0xC0, 0xC8, 0xC8, 0xEC, 0xEC, 0xE8, 0xE4, 0xC0, 0x90, 0xB0, 0xA0, 0x80, 0x20, 0x00,
0x00, 0x01, 0x03, 0x03, 0x03, 0x07, 0x07, 0x07, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x03, 0x03, 0x00
};
const uint8_t Mancha_2 []PROGMEM = {
0x00, 0x40, 0x70, 0x38, 0x38, 0x90, 0x90, 0xC0, 0xC8, 0x98, 0x9C, 0x98, 0x48, 0x00, 0x00, 0x00,
0x00, 0x20, 0x32, 0x16, 0x47, 0x77, 0x7B, 0x3F, 0x3F, 0x3F, 0x3F, 0x1F, 0x17, 0x06, 0x04, 0x00
};
const uint8_t Mancha_1 []PROGMEM = {
0x00, 0x28, 0x38, 0x78, 0xF0, 0xF0, 0xF2, 0xF2, 0xF3, 0x77, 0x77, 0x67, 0x0F, 0x0E, 0x0A, 0x00,
0x00, 0x00, 0x60, 0xF0, 0xE2, 0xF9, 0x79, 0x79, 0x38, 0x3C, 0x1C, 0x0D, 0x05, 0x31, 0x60, 0x20
};
const uint8_t Voo_Estatico []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xBC, 0x12, 0x04, 0x09, 0x09, 0x04, 0x12, 0xBC,
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x1D, 0x01, 0x1D, 0x02, 0x04,
0x3C, 0x43, 0x81, 0x80, 0x80, 0x81, 0x43, 0xBC, 0x04, 0x02, 0x1D, 0x01, 0x1D, 0x03, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x36, 0x41, 0xB8, 0x07, 0x18, 0x63, 0x8C, 0x70,
0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const uint8_t Voo_3 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0xA2, 0x04, 0x08, 0x09, 0x09, 0x08, 0x04, 0xA2,
0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1D, 0x03, 0x7D, 0x01, 0x5D, 0x02, 0x04,
0x3C, 0x43, 0x81, 0x80, 0x80, 0x81, 0x43, 0xBC, 0x04, 0x02, 0x1D, 0x01, 0x7D, 0x03, 0x9D, 0x03,
0x00, 0x82, 0x00, 0x08, 0x00, 0x80, 0x00, 0x78, 0x86, 0x71, 0x18, 0x27, 0xC0, 0x7B, 0x1C, 0x20,
0x21, 0x5E, 0x08, 0x00, 0x01, 0x00, 0x80, 0x00,
};
const uint8_t Voo_2 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0xA2, 0x12, 0x04, 0x09, 0x09, 0x04, 0x12, 0xA2,
0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x9D, 0x03, 0x7D, 0x01, 0x1D, 0x02, 0x04,
0x3C, 0x43, 0x81, 0x80, 0x80, 0x81, 0x43, 0xBC, 0x04, 0x02, 0x9D, 0x01, 0x7D, 0x03, 0x1D, 0x03,
0x00, 0x08, 0x00, 0x40, 0x00, 0x04, 0x00, 0x08, 0xB6, 0x41, 0x38, 0x07, 0x78, 0x83, 0x7C, 0x20,
0x3F, 0x40, 0x00, 0x00, 0x40, 0x00, 0x08, 0x00,
};
const uint8_t Voo_1 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xBC, 0x12, 0x04, 0x09, 0x09, 0x04, 0x12, 0xBC,
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1D, 0x03, 0x7D, 0x01, 0x9D, 0x02, 0x04,
0x3C, 0x43, 0x81, 0x80, 0x80, 0x81, 0x43, 0xBC, 0x04, 0x02, 0x1D, 0x01, 0x7D, 0x03, 0x1D, 0x03,
0x00, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x36, 0x41, 0xB8, 0x07, 0x18, 0x63, 0x8C, 0x70,
0x0F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00,
};
//------------------------------------------------------------/ */
//____________________/Imagens De Actions - Cuidados/____________________/
const uint8_t Olhos_c []PROGMEM = {
0x08, 0x1E, 0x11, 0x21, 0x10, 0x00, 0x00, 0x06, 0x00, 0x02, 0x01, 0x20, 0x40, 0x20, 0x20, 0x11
};
const uint8_t Olhos_b []PROGMEM = {
0x08, 0x0E, 0x19, 0x29, 0x18, 0x00, 0x00, 0x06, 0x00, 0x02, 0x01, 0x30, 0x50, 0x30, 0x10, 0x09
};
const uint8_t Olhos_a []PROGMEM = {
0x08, 0x0E, 0x1D, 0x25, 0x18, 0x00, 0x00, 0x06, 0x00, 0x02, 0x01, 0x30, 0x48, 0x38, 0x18, 0x09
};
const uint8_t head2 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x60, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x1C, 0x83, 0x83, 0x7C, 0x03, 0x0C, 0x10, 0x20,
0x20, 0x20, 0x10, 0x0C, 0xF6, 0x0B, 0x05, 0x07, 0x1C, 0xF0, 0xE0, 0x30, 0xE0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xF0, 0x08, 0x0E, 0x1D, 0x25, 0x18, 0x00, 0x00, 0x06, 0x00, 0x02, 0x01,
0x30, 0x48, 0x38, 0x18, 0x08, 0x01, 0x03, 0x86, 0x90, 0x78, 0xAF, 0x89, 0x02, 0x00, 0x00, 0x00,
0x00, 0x80, 0xE0, 0x90, 0x88, 0xE7, 0x02, 0x04, 0x0C, 0x08, 0x11, 0x13, 0x11, 0x10, 0x08, 0x08,
0x08, 0x04, 0x04, 0x06, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x93, 0x0D, 0x01, 0x01
};
const uint8_t head1 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x60, 0x90, 0xE0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x1C, 0x83, 0x80, 0x7F, 0x00, 0x03, 0x1C, 0x20,
0x20, 0x20, 0x20, 0xB0, 0x58, 0x2C, 0x14, 0x0A, 0x06, 0xF1, 0xBE, 0xE0, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xF0, 0x08, 0x0E, 0x1D, 0x25, 0x18, 0x00, 0x00, 0x06, 0x00, 0x02, 0x01,
0x30, 0x48, 0x38, 0x18, 0x09, 0x02, 0x06, 0x88, 0x87, 0x7C, 0xAA, 0x89, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0xE0, 0x90, 0x88, 0xE7, 0x02, 0x04, 0x0C, 0x08, 0x11, 0x13, 0x11, 0x10, 0x08, 0x08,
0x08, 0x04, 0x04, 0x06, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x93, 0x0D, 0x01, 0x01
};
const uint8_t corpo3 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0xE0, 0x90, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x9F, 0x0D, 0x01, 0x01,
0x01, 0x01, 0x01, 0x81, 0x41, 0x41, 0x22, 0x22, 0x02, 0x02, 0x04, 0x04, 0x0C, 0x18, 0x30, 0xE0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0xC0, 0x40, 0x20, 0x20, 0x10, 0x1A,
0x1E, 0x07, 0x88, 0x88, 0x50, 0x60, 0x70, 0x88, 0x08, 0x08, 0x08, 0x08, 0x0C, 0x08, 0x08, 0x10,
0x90, 0x60, 0x10, 0x10, 0x18, 0x0D, 0x07, 0x02, 0x02, 0x02, 0x03, 0x00, 0x71, 0x00, 0x00, 0x00,
0x78, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41,
0xF0, 0x8C, 0x82, 0x01, 0x01, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x10, 0x10, 0x10, 0x08, 0x04,
0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x12, 0x22, 0x21,
0x21, 0x20, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x04, 0x04, 0x04, 0x02, 0x01, 0x01, 0x00, 0x00
};
const uint8_t corpo2 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0xE0, 0x90, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x9F, 0x0D, 0x01, 0x01,
0x01, 0x01, 0x01, 0x81, 0x41, 0x41, 0x22, 0x22, 0x02, 0x02, 0x04, 0x04, 0x0C, 0x18, 0x30, 0xE0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x1A,
0x1E, 0x07, 0x88, 0x88, 0x50, 0x60, 0x70, 0x88, 0x08, 0x08, 0x08, 0x08, 0x0C, 0x08, 0x08, 0x10,
0x90, 0x60, 0x10, 0x10, 0x18, 0x0D, 0x07, 0x02, 0x02, 0x02, 0x03, 0x00, 0x71, 0x00, 0x00, 0x00,
0x78, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41,
0xF0, 0x8C, 0x82, 0x01, 0x01, 0x00, 0x00, 0x02, 0x05, 0x08, 0x08, 0x08, 0x08, 0x08, 0x04, 0x02,
0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x24, 0x22,
0x21, 0x20, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00
};
const uint8_t corpo1 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0xE0, 0x90, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x9F, 0x0D, 0x01, 0x01,
0x01, 0x01, 0x01, 0x81, 0x41, 0x41, 0x22, 0x22, 0x02, 0x02, 0x04, 0x04, 0x0C, 0x18, 0x30, 0xE0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x0A,
0x1E, 0x87, 0x88, 0x88, 0x50, 0x60, 0x70, 0x88, 0x08, 0x08, 0x08, 0x08, 0x0C, 0x08, 0x08, 0x10,
0x90, 0x60, 0x10, 0x10, 0x18, 0x0D, 0x07, 0x02, 0x02, 0x02, 0x03, 0x00, 0x71, 0x00, 0x00, 0x00,
0x20, 0xF8, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41,
0xF0, 0x8C, 0x82, 0x01, 0x01, 0x00, 0x00, 0x01, 0x02, 0x04, 0x04, 0x04, 0x04, 0x04, 0x02, 0x01,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x24,
0x22, 0x22, 0x21, 0x11, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00
};
const uint8_t cauda_4 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40,
0x40, 0x40, 0x40, 0x60, 0x20, 0xE0, 0x20, 0x20, 0x20, 0x20, 0x21, 0x3F, 0x31, 0x22, 0x26, 0xF8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0x30, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xB0, 0xC0, 0xC0, 0x60, 0x30, 0x10, 0x18, 0x08, 0x0C, 0xF4,
0xC0, 0x60, 0x10, 0x08, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x60, 0xB8, 0xFC, 0x1E, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7C, 0x03,
0xBA, 0x0F, 0x0B, 0x09, 0x11, 0x11, 0x31, 0x61, 0x41, 0x81, 0x81, 0x01, 0x03, 0x02, 0x02, 0x07,
0x0D, 0x0E, 0x09, 0x08, 0x08, 0x08, 0x18, 0x10, 0xD0, 0x70, 0x30, 0x30, 0x4C, 0xC3, 0x80, 0x00,
0x0F, 0x18, 0x30, 0x60, 0x40, 0x80, 0x80, 0x00, 0x00, 0x00, 0x01, 0x81, 0x42, 0x64, 0x28, 0x18,
0x18, 0x28, 0x48, 0x88, 0x88, 0x84, 0x04, 0x0E, 0x0F, 0x08, 0x18, 0x10, 0x20, 0xC0, 0x81, 0xF7
};
const uint8_t cauda_3 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x01, 0x06, 0x3C, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40,
0x20, 0x20, 0x30, 0x10, 0x1C, 0x1B, 0x08, 0x08, 0x18, 0x14, 0xE7, 0x64, 0x08, 0x08, 0x18, 0x10,
0x80, 0x00, 0x00, 0x00, 0x80, 0xC0, 0x20, 0x10, 0x0C, 0x06, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0xC0, 0x40, 0x20, 0x20, 0x20, 0x10, 0x10, 0xF3, 0x0E, 0x08, 0x08, 0x08, 0x0C,
0x3A, 0xC9, 0x09, 0x09, 0x0D, 0x0D, 0x0B, 0x15, 0x12, 0x12, 0x61, 0x81, 0x81, 0x02, 0x02, 0x02,
0x04, 0x0F, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10, 0xDC, 0x27, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x00, 0x03, 0x06, 0x18, 0x10, 0x20, 0x40, 0x80, 0x80, 0x00, 0x00, 0x00, 0xF1, 0x1A, 0x04, 0x18,
0x18, 0x28, 0x28, 0x48, 0x48, 0x48, 0x48, 0x48, 0x4F, 0xCC, 0x88, 0x0C, 0x04, 0x04, 0x02, 0x03
};
const uint8_t cauda_2 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81,
0x7F, 0x41, 0x81, 0x82, 0x84, 0x18, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x30, 0x0F,
0x00, 0x00, 0x00, 0x80, 0x80, 0x81, 0x41, 0x21, 0x2E, 0x10, 0x30, 0xD0, 0x90, 0x90, 0x20, 0x20,
0x80, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x40, 0x20, 0x10, 0x08, 0x04, 0x03, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x80, 0x80, 0x80, 0x80, 0xC0, 0x40, 0x60, 0x38, 0x26, 0x21, 0x10, 0x10, 0x08,
0x3A, 0xC9, 0x09, 0x09, 0x0D, 0x0D, 0x0B, 0x15, 0x10, 0x12, 0x12, 0x22, 0xA2, 0x62, 0x22, 0x44,
0x4C, 0x8E, 0x09, 0x16, 0x11, 0x10, 0x10, 0x18, 0x18, 0x28, 0x24, 0x44, 0x84, 0x02, 0x02, 0x82,
0x00, 0x00, 0x01, 0x03, 0x04, 0x08, 0x00, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20, 0x41, 0x4E, 0x50,
0x70, 0x40, 0x81, 0x81, 0x82, 0x84, 0x88, 0xD0, 0x70, 0x68, 0x24, 0x24, 0x02, 0x03, 0x01, 0x00
};
const uint8_t cauda_1 []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC7, 0x39, 0x01, 0x02, 0xC2,
0x24, 0x24, 0x28, 0x50, 0x60, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0E, 0xF2, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x78, 0x40, 0x20, 0x20, 0xA0, 0x60, 0x20, 0x40, 0x40,
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x20, 0x1F, 0x07, 0x02, 0x02,
0x02, 0x02, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x80, 0x60, 0x6C, 0x54, 0x43, 0x40, 0x40, 0x20,
0x3A, 0xC9, 0x09, 0x09, 0x25, 0x25, 0x23, 0x45, 0x40, 0x42, 0x42, 0x02, 0x82, 0x82, 0x82, 0x84,
0x08, 0x08, 0x08, 0x00, 0x14, 0x8A, 0x0F, 0x15, 0x14, 0x24, 0x22, 0x42, 0x82, 0x81, 0x81, 0x42,
0x00, 0x00, 0x01, 0x03, 0x04, 0x08, 0x00, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20, 0x41, 0x4E, 0x50,
0x71, 0x41, 0x21, 0x61, 0x02, 0x1B, 0x0C, 0x08, 0x0C, 0x06, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00
};
//------------------------------------------------------------//
//____________________/Imagens Complementares/____________________/
const uint8_t Generic_decoration_E []PROGMEM = {
0x63, 0x0B, 0x00, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xC6, 0xD0, 0x00, 0x40, 0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const uint8_t Generic_decoration_D [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x02, 0x00, 0x0B, 0x63,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x00, 0x40, 0x00, 0xD0, 0xC6
};
const uint8_t Heart_mini [] PROGMEM = {
0x0C, 0x1E, 0x3C, 0x78, 0x3C, 0x1E, 0x0C, 0x00,
};
const uint8_t Paw_mini [] PROGMEM = {
0x0C, 0x60, 0x76, 0x30, 0x76, 0x60, 0x0C, 0x00,
};
//------------------------------------------------------------//
//____________________/Imagens Do Menu/____________________/
const uint8_t N []PROGMEM = {
0x00, 0x00, 0xF8, 0xFC, 0xFC, 0xF8, 0xF0, 0xE0, 0x81, 0x00, 0xF8, 0xFC, 0xFC, 0xF8, 0x00, 0x00,
0x00, 0x00, 0x3F, 0x7F, 0x7F, 0x3F, 0x00, 0x07, 0x1F, 0x3C, 0x3F, 0x7F, 0x7F, 0x3F, 0x00, 0x00
};
const uint8_t Shop []PROGMEM = {
0x00, 0x00, 0x00, 0xC0, 0x20, 0x10, 0x10, 0xC8, 0xE8, 0x78, 0x38, 0x18, 0xC8, 0xE8, 0x78, 0x38,
0x18, 0xC8, 0xE8, 0x38, 0x18, 0x08, 0xF0, 0x00, 0x00, 0x04, 0x0B, 0xF0, 0x08, 0x14, 0x0F, 0x13,
0x08, 0x10, 0x0C, 0x17, 0x0B, 0x10, 0x08, 0x14, 0x0F, 0x13, 0x08, 0x10, 0xE8, 0x10, 0x0F, 0x00,
0x00, 0x00, 0x1E, 0x21, 0x3E, 0x22, 0x2A, 0x2A, 0x22, 0x32, 0x34, 0x14, 0x22, 0x2A, 0x22, 0x14,
0x22, 0x2A, 0x22, 0x2A, 0x23, 0x3E, 0x00, 0x00,
};
const uint8_t Play []PROGMEM = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0x78, 0xF0, 0x60, 0x60, 0x40, 0x80,
0xFF, 0x8B, 0x97, 0x8B, 0x47, 0x43, 0x45, 0x23, 0x21, 0x10, 0x11, 0x08, 0x04, 0x04, 0x02, 0x01
};
const uint8_t Menu_decoration_E []PROGMEM = {
0x63, 0x0B, 0x00, 0xC2, 0x60, 0x01, 0x31, 0x38, 0x00, 0x38, 0x30, 0x00, 0x60, 0xC0, 0x00, 0x01,
0xC6, 0xD0, 0x00, 0x40, 0x04, 0x8E, 0x8F, 0x07, 0x07, 0x07, 0x0F, 0x0E, 0x04, 0x00, 0x00, 0x00
};
const uint8_t Menu_decoration_D []PROGMEM = {
0x01, 0x00, 0xC0, 0x60, 0x00, 0x30, 0x38, 0x00, 0x38, 0x31, 0x01, 0x60, 0xC2, 0x00, 0x0B, 0x63,
0x00, 0x00, 0x00, 0x04, 0x0E, 0x0F, 0x07, 0x07, 0x07, 0x8F, 0x8E, 0x04, 0x40, 0x00, 0xD0, 0xC6
};
const uint8_t K []PROGMEM = {
0x00, 0x00, 0x00, 0xF8, 0xFC, 0xFC, 0xF8, 0xE1, 0xF0, 0x78, 0x3C, 0x1C, 0x0C, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x3F, 0x7F, 0x7F, 0x3F, 0x07, 0x0F, 0x1F, 0x3E, 0x7C, 0x78, 0x70, 0x00, 0x00
};
const uint8_t I []PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0xDD, 0xDD, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x7F, 0x7F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const uint8_t Config [] PROGMEM = {
0x00, 0x00, 0x20, 0x60, 0xC0, 0xEC, 0xF8, 0x70, 0x3C, 0x3C, 0x70, 0xF8, 0xEC, 0xC0, 0x60, 0x20,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x1B, 0x0F, 0xDF, 0x7C, 0x38,
0xF4, 0xF6, 0x3B, 0xBC, 0xFF, 0xFF, 0x73, 0x3B, 0xBC, 0x70, 0xF8, 0xD8, 0x80, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x1B, 0x1F, 0x0E, 0x1D,
0x3D, 0x0E, 0x07, 0x0F, 0x0D, 0x00, 0x00, 0x00,
};
const uint8_t Coolar [] PROGMEM = {
0x78, 0x78, 0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0xF0, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0xF9,
0x8B, 0x1B, 0x33, 0x37, 0x3B, 0x33, 0x1B, 0x8B, 0xF9, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x07, 0x05, 0x0C, 0x0C, 0x19, 0x10, 0x10, 0x19, 0x0C, 0x0C,
0x05, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const uint8_t Bluetooth [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
0x03, 0x07, 0x0E, 0x1C, 0x38, 0x78, 0xE0, 0xFF, 0xFF, 0x80, 0xC1, 0x61, 0x63, 0x36, 0x1C, 0x08,
0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0xFF, 0xFF, 0x01, 0x83, 0x86, 0xC6, 0x6C, 0x38, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00
};
const uint8_t Actions [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0xE0, 0xF0, 0xF8, 0x00, 0x00, 0xF8, 0xF0, 0xE0,
0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0F, 0xCF, 0xE7, 0xE0,
0xF0, 0xF1, 0xF8, 0xF8, 0xF8, 0xF8, 0xF1, 0xF0, 0xE0, 0xE7, 0xCF, 0x0F, 0x06, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0F, 0x0F, 0x07, 0x07, 0x03, 0x03, 0x07, 0x07, 0x0F,
0x0F, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
};
//------------------------------------------------------------//
//____________________/Imagens Shopping/____________________//
const uint8_t Xarope []PROGMEM = {
0xFF, 0x01, 0x09, 0x91, 0x41, 0x23, 0x11, 0x91, 0x89, 0x49, 0xA9, 0x99, 0x71, 0xC5, 0x0F, 0x05,
0x31, 0x31, 0xFD, 0xFD, 0x31, 0x31, 0x01, 0xFF, 0xFF, 0x00, 0x20, 0x03, 0x05, 0x0D, 0x35, 0xC2,
0xB2, 0x71, 0xF8, 0xF8, 0xFC, 0xFC, 0xF3, 0x4C, 0xB8, 0xE0, 0x08, 0x1C, 0x88, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x82, 0x87, 0x82, 0x80, 0xA0, 0x80, 0x81, 0x86, 0x85, 0x85, 0x85, 0xA2, 0x82, 0x81,
0x89, 0x80, 0x90, 0xB8, 0x90, 0x80, 0x80, 0xFF,
};
const uint8_t Torta []PROGMEM = {
0xFF, 0x05, 0x0F, 0x05, 0x01, 0x01, 0x91, 0x09, 0x01, 0x41, 0x01, 0x01, 0x01, 0x21, 0x71, 0x21,
0x01, 0x01, 0x01, 0x01, 0x11, 0x01, 0x01, 0xFF, 0xFF, 0xC0, 0x22, 0x55, 0x50, 0xE8, 0xE8, 0xE8,
0xE8, 0xF4, 0xF4, 0xF4, 0xF4, 0xF4, 0xF4, 0xE8, 0xE8, 0xE8, 0xE8, 0x51, 0x50, 0x20, 0xC0, 0xFF,
0xFF, 0x87, 0x88, 0x90, 0x90, 0xA0, 0xA0, 0xA0, 0xA0, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xA0,
0xA0, 0xA0, 0xA0, 0x90, 0x90, 0x88, 0x87, 0xFF,
};
const uint8_t SnowBall []PROGMEM = {
0xFF, 0x41, 0xA5, 0x41, 0x09, 0x15, 0xC9, 0xC1, 0xE1, 0xE5, 0xF1, 0xF1, 0xF1, 0xF1, 0xE1, 0xE1,
0xC1, 0xC1, 0x09, 0x55, 0x09, 0x01, 0x01, 0xFF, 0xFF, 0x08, 0x00, 0x00, 0x3C, 0xFF, 0xFF, 0x7F,
0xFF, 0xFF, 0x7F, 0xFF, 0x7F, 0xBF, 0x5F, 0xBF, 0x1F, 0x0F, 0xDF, 0x3C, 0x80, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x93, 0x84, 0x80, 0xA0, 0xD3, 0xA3, 0x86, 0x84, 0x89, 0x88, 0x89, 0x88, 0x84, 0xA4,
0x82, 0x83, 0x80, 0x81, 0x82, 0x81, 0x80, 0xFF,
};
const uint8_t Shop_Aux []PROGMEM = {
0x00, 0x00, 0x24, 0x18, 0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x24, 0x18, 0x18, 0x24, 0x00, 0x00,
0x00, 0x00, 0x24, 0x18, 0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x24, 0x18, 0x18, 0x24, 0x00, 0x00,
0x00, 0x00, 0x24, 0x18, 0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x24, 0x18, 0x18, 0x24, 0x00, 0x00
};
const uint8_t Picole []PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x81, 0x41, 0x21, 0x21, 0x21,
0x21, 0x41, 0x81, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB8,
0xE4, 0xC2, 0x81, 0x84, 0x52, 0x48, 0xA5, 0x50, 0x28, 0x14, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x8C, 0x8E, 0x87, 0x83, 0x81, 0x81, 0x82, 0x82, 0x81, 0x81, 0x80, 0x80,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t Shop_decoration_D []PROGMEM = {
0x01, 0x00, 0x00, 0x80, 0xE0, 0xF0, 0x70, 0x38, 0x38, 0x71, 0xF1, 0xE0, 0x82, 0x00, 0x0B, 0x63,
0x00, 0x00, 0x00, 0x01, 0x06, 0x09, 0x0A, 0x14, 0x14, 0x8A, 0x8B, 0x07, 0x41, 0x00, 0xD0, 0xC6
};
const uint8_t Shop_decoration_E []PROGMEM = {
0x63, 0x0B, 0x00, 0x82, 0xE0, 0xF1, 0x71, 0x38, 0x38, 0x70, 0xF0, 0xE0, 0x80, 0x00, 0x00, 0x01,
0xC6, 0xD0, 0x00, 0x41, 0x07, 0x8B, 0x8A, 0x14, 0x14, 0x0A, 0x09, 0x06, 0x01, 0x00, 0x00, 0x00
};
const uint8_t Bandeide [] PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x81, 0x41, 0x21, 0x11, 0x09,
0x09, 0x09, 0x11, 0xE1, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x30, 0x08,
0x24, 0x72, 0xF9, 0x7C, 0x3E, 0x9C, 0x48, 0x20, 0x10, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x87, 0x88, 0x90, 0x90, 0x90, 0x88, 0x84, 0x82, 0x81, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t Almiste [] PROGMEM = {
0xFF, 0x01, 0x55, 0xA9, 0x55, 0xA9, 0x55, 0xA9, 0xD5, 0xE9, 0x75, 0xB9, 0x75, 0xB9, 0x75, 0xE9,
0xD5, 0xA9, 0x55, 0xA9, 0x55, 0xA9, 0x01, 0xFF, 0xFF, 0x00, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA,
0x55, 0xAA, 0x55, 0xAA, 0x75, 0xBA, 0x5D, 0xAF, 0x57, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x00, 0xFF,
0xFF, 0x80, 0x95, 0xAA, 0x95, 0xAA, 0x95, 0xAA, 0x95, 0xAA, 0x95, 0xAE, 0x9F, 0xAE, 0x95, 0xAA,
0x95, 0xAA, 0x95, 0xAA, 0x95, 0xAA, 0x80, 0xFF,
};
const uint8_t Notes []PROGMEM = {
0xFF, 0x01, 0x01, 0x81, 0xE1, 0x21, 0x01, 0x01, 0x11, 0x01, 0x01, 0x81, 0xC1, 0xC1, 0xC9, 0xC1,
0x41, 0x01, 0x01, 0x01, 0x05, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x09, 0x01, 0x00, 0xC0, 0xE0,
0xB0, 0xD0, 0xD0, 0xFF, 0xFF, 0x01, 0x00, 0x18, 0x1E, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0xFF,
0xFF, 0x80, 0xB0, 0xBC, 0x84, 0x80, 0x81, 0x83, 0x87, 0x87, 0x87, 0x83, 0xA1, 0x80, 0x80, 0x80,
0x80, 0x8C, 0x8F, 0x81, 0x80, 0x88, 0x80, 0xFF,
};
const uint8_t Mimo []PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x21, 0x71, 0x21, 0x01, 0x01, 0x01, 0x01, 0x01, 0xC1, 0xE1, 0xE5, 0xC1,
0x01, 0x01, 0x01, 0x11, 0x39, 0x11, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x60, 0xF2, 0xF0,
0xF0, 0xF8, 0x7C, 0xBE, 0x5F, 0x2F, 0x17, 0x0B, 0x0B, 0x0F, 0x06, 0x00, 0x10, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x88, 0x9C, 0x88, 0x80, 0x80, 0x83, 0x85, 0x84, 0x83, 0x80, 0x80, 0x81, 0x80,
0x80, 0x80, 0x8C, 0x84, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t MilkShake []PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x81, 0xC1, 0xCF, 0xFD, 0xF1, 0xC1, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
0x81, 0x81, 0x81, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x7E, 0x80, 0x20,
0x43, 0xBF, 0x55, 0xA1, 0x51, 0xA1, 0x51, 0xA8, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x8F, 0x90, 0x95, 0x92, 0x95, 0x92, 0x95, 0x92, 0x95, 0x90,
0x8F, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t LuzDoLuar []PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x41, 0xF1, 0x41, 0x01, 0x01, 0x01, 0x01, 0x89, 0xC5, 0xC1, 0xC1, 0x81,
0x81, 0x01, 0x11, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x88, 0x00, 0x01, 0x00, 0xF0,
0xE0, 0xC0, 0x80, 0x80, 0x80, 0x81, 0xC3, 0xFF, 0xFF, 0xFF, 0x7C, 0x00, 0x01, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x90, 0x88, 0x80, 0x80, 0x81, 0x83, 0x87, 0x87, 0x87, 0x87, 0x87, 0x83,
0x83, 0x81, 0x80, 0x90, 0xB8, 0x90, 0x80, 0xFF,
};
const uint8_t ItenMist []PROGMEM = {
0xFF, 0x01, 0x55, 0xFD, 0x55, 0xFD, 0x55, 0xBD, 0xD5, 0xED, 0x75, 0xBD, 0x75, 0xBD, 0x75, 0xED,
0xD5, 0xBD, 0x55, 0xFD, 0x55, 0xFD, 0x01, 0xFF, 0xFF, 0x00, 0x55, 0xFF, 0x55, 0xFF, 0x55, 0xFE,
0x55, 0xFE, 0x55, 0xAF, 0x75, 0xBB, 0x5D, 0xEF, 0x57, 0xFA, 0x55, 0xFF, 0x55, 0xFF, 0x00, 0xFF,
0xFF, 0x80, 0x95, 0xBF, 0x95, 0xBF, 0x95, 0xBF, 0x95, 0xBB, 0x95, 0xAE, 0x9F, 0xAE, 0x95, 0xBB,
0x95, 0xBF, 0x95, 0xBF, 0x95, 0xBF, 0x80, 0xFF,
};
const uint8_t HotDog []PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xC1, 0x21, 0xD1, 0x31, 0x11, 0x09, 0xC9,
0x29, 0x31, 0x41, 0x81, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x40, 0xF0, 0xA8, 0x14, 0x8A, 0x4A,
0x25, 0x22, 0x11, 0x10, 0x08, 0x04, 0x83, 0x40, 0x20, 0x10, 0x0C, 0x03, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x82, 0x82, 0x81, 0x81, 0x80, 0x80,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t FusoBola [] PROGMEM = {
0xFF, 0x01, 0x55, 0x55, 0x55, 0x55, 0x15, 0x95, 0x55, 0x45, 0x25, 0x25, 0x21, 0x2D, 0x41, 0x5D,
0x81, 0x3D, 0x01, 0xFD, 0x01, 0xFD, 0x01, 0xFF, 0xFF, 0x00, 0xF5, 0x05, 0x81, 0x3C, 0xC3, 0x20,
0x20, 0x20, 0x10, 0x10, 0x18, 0x24, 0x4A, 0x52, 0x24, 0xDB, 0x3C, 0x81, 0xA0, 0xAF, 0x00, 0xFF,
0xFF, 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBC, 0x81, 0xBA, 0x82, 0xB4, 0x84, 0xA4, 0xA4, 0xA2, 0xAA,
0xA9, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0x80, 0xFF,
};
const uint8_t Frango [] PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x81, 0xC1, 0xE1, 0xE1, 0xE1, 0xE1, 0x61,
0xA1, 0x41, 0x81, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xDC,
0x7E, 0xFF, 0xDF, 0xAF, 0x97, 0x0B, 0x85, 0x42, 0x21, 0x14, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x87, 0x8F, 0x93, 0x91, 0x8D, 0x82, 0x81, 0x80, 0x81, 0x81, 0x81, 0x80, 0x80,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t Cupcake [] PROGMEM = {
0xFF, 0x01, 0x01, 0x81, 0x41, 0x21, 0x21, 0x11, 0x11, 0x39, 0x49, 0x45, 0x69, 0x39, 0x11, 0x11,
0x21, 0x21, 0x21, 0x41, 0x81, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x03, 0x3E, 0xC2, 0x02,
0x3C, 0xC4, 0x04, 0x6C, 0x94, 0x04, 0xE4, 0x1E, 0x02, 0xC2, 0x3E, 0x01, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x82, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
0x82, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t CopinhoAgua [] PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0xE1, 0x21, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x21, 0x21, 0xE1, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xC0,
0x19, 0xF4, 0xF0, 0xF2, 0xF4, 0xF8, 0xFA, 0x3C, 0xC0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x8F, 0x90, 0x97, 0x97, 0x97, 0x93, 0x97, 0x97, 0x90,
0x8F, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t Cookie [] PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0x81, 0xC1, 0x61, 0x71, 0x71, 0x19, 0x09, 0x09, 0x69, 0x71, 0x31,
0x21, 0x61, 0xC1, 0x81, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x7E, 0xC3, 0x0D, 0x8C,
0x00, 0x00, 0x60, 0x6C, 0x0C, 0x80, 0x80, 0x00, 0x03, 0x33, 0xB0, 0xF7, 0x3C, 0x00, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x80, 0x83, 0x87, 0x85, 0x84, 0x8E, 0x8E, 0x88, 0x88, 0x89, 0x8D, 0x84,
0x86, 0x83, 0x81, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
const uint8_t Cafe [] PROGMEM = {
0xFF, 0x01, 0x01, 0x01, 0x01, 0x81, 0xC1, 0x41, 0x41, 0x41, 0x21, 0xA1, 0xA1, 0x41, 0x41, 0x41,
0xC1, 0x81, 0x81, 0x81, 0x81, 0x01, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x3F, 0xE0, 0x81, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x81, 0xE1, 0x5F, 0x40, 0x60, 0x3F, 0x00, 0xFF,
0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82, 0x83, 0x83,
0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF,
};
//------------------------------------------------------------//
//____________________/Imagens Game_Vr/____________________//
//------------------------------------------------------------//
//------------------------------------------------------------//
/*
Nota:
ao definir coordenadas X Y na biblioteca OLED_i2c
X = define um ponto da esquerda para a direita
Y = Define um ponto de Cima para baixo
*/
// 0 1 2 3 4 5 6 7
//Função botão c d b e Y B A X
int botoes[8] = {46, 44, 38, 42, 36, 34, 31, 30}; //portas que serão definido os botões
int Bot[8] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; // Recebe o valor Atual do botão
int AnteBot[8] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; //Recebe o ultimo estado em que o botão esteve
int Map[] = {0, 0, 0}; //mapeia o potenciometro
int frente = 0; // 28
int re = 0; // 41
int esquerda = 0; // 64
int direita = 0; // 83
//____________________/Configurações do Menu/____________________/
//movimenta o cursor na tela
//menu posição 1 posição 2 psição 3
// x y x y x y
// 8/24 48/24 88/24
int Cursor[12][2] = {
{8, 24}, // 0 Movimenta o cursor no menu
{48, 24}, // 1 -
{88, 24}, // 2 -
{16, 19}, // 3 Movimenta o cursor em "Shop"
{48, 19}, // 4 -
{80, 19}, // 5 -
{9, 17}, // 6 movimenta o cursor no iventário
{9, 25}, // 7
{9, 33}, // 8
{9, 41}, // 9
{9, 49}, // 10
{9, 57} // 11
};
//Variáveis que desenham um bloco/cursor de duas camadas que mostra ao usuário qual icone ele poderá escolher
int Pxa = 48; //posição x da camada da externa do bloco de escolhas do menu
int Pya = 24; //posição y da camada da externa do bloco de escolhas do menu
int Pxb; //posição x da camada da interna do bloco de escolhas do menu
int Pyb; //posição y da camada da interna do bloco de escolhas do menu
String menuText[] = { //guarda as palavras que são escrutas no menu
"Acts", "Play", "Shop", "Conf", "Blue", "Info"
};
int Ptext[6][2] = { //usado para escrever as palavras de "menuText" no menu na posição correta
{17, 57},
{57, 57},
{97, 57},
{17, 57},
{57, 57},
{97, 57}
};
int Interface[] = {
Menu_decoration_E, //A
Menu_decoration_D, //B
K, I, N, //C
Actions, //D
Play, //E
Shop, //F
Config, //G
Bluetooth, //H
Coolar, //I
Shop_decoration_E, //J
Shop_decoration_D, //K
Shop_Aux //L
};
int Xyz [14][4] = { //coordenadas e tamanhos para interfaces
//X y tamanho
{0, 0, 16, 16}, //A Decorações do menu
{112, 0, 16, 16}, //B
{40, 0, 16, 16}, //C
{56, 0, 16, 16}, //C
{72, 0, 16, 16}, //C
{12, 28, 24, 24}, //D Ícones do menu
{56, 32, 16, 16}, //E
{92, 28, 24, 24}, //F
{12, 28, 24, 24}, //G
{56, 24, 16, 32}, //H
{92, 28, 24, 24}, //I
{0, 0, 16, 16}, //J Decorações da loja
{112, 0, 16, 16}, //K
{104, 24, 16, 24} //L
};
int Mgrade = 0; //controla a grade de icones do menu
int Pmenu = 1; //Define a escolha de uma função disponivel em "menu"
int Rmenu = 0; //Reseta o menu uma vez a cada mudança de escolha
int MenuSelect = 99; //usado para escolher uma das opções disponíveis no menu
//------------------------------------------------------------//
//____________________/Configurações De Actions - Cuidados/____________________/
int actions = 0; //alterna dentre a interface inicial de cuidados e o iventário
int Rivent = 1; //Atualiza o display sempre que um botão é apertado
int Pixel; //usado para aumentar linhas de carregamento
Neotimer Delay_line = Neotimer(10); //usado na animação de carregamento na opção de necessidades
String Itens[6][4] = { //desenha a grade de alimentos e itens no iventários
{"copo de Agua", "Picole", "Frango assado", "Fermento" }, //0
{"Cookie", "Cafe", "Milk-Shake", "Voce" }, //1
{"Bandeide", "Cupcake", "Cachorro quente", "Giant Water Baloon" }, //2
{"Bone-shaped cookie", "Xarope", "Luz do Luar", "Speed Stomach Potion" }, //3
{"Torta de Frango", "Bola de neve", "Notas Musicais", "Null Acids Potion " }, //4
{"FusoBola", "Comida Misteriosa", "Item Misterioso", "Regenerate Potion" } //5
};
/*
("Fome:", 0, ); // Escreve todas as necessidades em formato de lista
("Sede:", 1, ); //
("Frio:", 2, ); //
("Calor:", 3, ); //
("Doente:", 4, ); //
("Cansada:", 5, ); //
("Entediada", 6, ); //
Ações especiais = 7
*/
int Efeitos[6][4] = { //Numeração de efeitos para cada item no iventário
{1, 3, 0, 7},
{0, 2, 3, 7},
{4, 0, 0, 7},
{0, 4, 5, 7},
{0, 3, 6, 7},
{6, 7, 7, 4}
};
int pItem[12][2] = { //coordenadas que serão utilizadas para escrever as palavras em "Itens[][]" no iventário
{2, 16}, //0
{2, 24}, //1
{2, 32}, //2
{2, 40}, //3
{2, 48}, //4
{2, 56}, //5
{16, 16}, //6
{16, 24}, //7
{16, 32}, //8
{16, 40}, //9
{16, 48}, //10
{16, 56} //11
};
int Info[6][4] = { //quantidade de itens do iventário
{3, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{3, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
byte Necessidades[] = {1, 1, 1, 1, 1, 1, 1}; //alterna seu valor ao receber um comando como: 6N
int PIvent[] = {6, 0}; //controla a posição do cursor do iventário
int IventorySelect = 0; //seleciona um item/alimento do iventário
//tempo em milisegundos de animação para cada fragmento do personagem
Neotimer Delay_A = Neotimer(150); //olhos
Neotimer Delay_B = Neotimer(500); //cabeça
Neotimer Delay_C = Neotimer(100); //corpo
Neotimer Delay_D = Neotimer(60); //cauda
int ActFrames[] = {0, 0, 0, 0}; //faz a contagem de frames dos fragmentos do personagem
int ActFramesProg[] = {0, 0, 0, 0}; //programa os frames das animações
int ActFrameSave[] = {0, 0, 0, 0}; //Salva/guarda o valor do frame de cada fragmento do personagem para poder imprimi-lo
//a ordem é Kitsune[Linhas][Colunas]
int kitsune[4][4] = { //desenha Kin no display
// 0 1 2 3
{Olhos_a, Olhos_b, Olhos_c, 0}, // 0 anima os olhos
{head1, head2, 0, 0}, // 1 anima a cabeça do personagem
{corpo1, corpo2, corpo3, 0}, // 2 anima as patinhas do personagem
{cauda_1, cauda_2, cauda_3, cauda_4} // 3 anima as caudas do personagem
};
int KitXY[4][16] = { //informa as coordenadas e tamanhos do desenho
//a,b,c,d a - b = coodenada c - d = tamanho
//olhos cabeça corpo cauda
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
{53, 32, 16, 8, 48, 16, 32, 32, 32, 40, 64, 24, 96, 24, 32, 40},
{53, 32, 16, 8, 48, 16, 32, 32, 32, 40, 64, 24, 96, 24, 32, 40},
{53, 32, 16, 8, 0, 0, 0, 0, 32, 40, 64, 24, 96, 24, 32, 40},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 24, 32, 40}
};
//------------------------------------------------------------//
/* /____________________/Configurações do Game: SpaceFox/____________________/
int manchas[] = {Mancha_1, Mancha_2, Mancha_3}; //manchas do game SpaceFox
int voo[] = {Voo_Estatico, Voo_1, Voo_2, Voo_3}; //frames do personagem do game SpaceFox
Neotimer Delay_P = Neotimer(100);
//------------------------------------------------------------/ */
//____________________/Configurações do Shopping/____________________/
int Rshop = 1; //reseta o display a cada mudança de posição
int Pshop[] = {0, 0}; //define a escolha de uma função
int Sgrade[] = {0, 0}; //controla a grade de opções
int ShopSelect = 0; // verifica se o usuário pretende comprar algo
Neotimer delayBot = Neotimer(10); //delay utilizado para evitar repetições de ações ao apertar um botão
Neotimer delayTimeBot = Neotimer(1000); //delay que conta o tempo em que um botão foi pressionado para criar uma repetição de ações proposital
Neotimer delayTimeCm = Neotimer(1); //delay utilizado para controle de ações repetidas por segundo
int Bot_at[] = {0, 0, 0, 0, 0, 0, 0, 0}; //guarda um valor para cada botão quando os mesmos tão pressionados por muito tempo
int calculo[] = {0, 0}; //calculo de valore na loja {quantidade, resultados};
int Umoney[] = {10, 10}; // seu dinheiro {corações, patinhas};
int ShopDecor[3][6] = { //desenha a grade de alimentos e itens
{CopinhoAgua, Cookie, Bandeide, Mimo, Torta, FusoBola},
{Picole, Cafe, Cupcake, Xarope, SnowBall, Almiste},
{Frango, MilkShake, HotDog, LuzDoLuar, Notes, ItenMist}
};
int ShopPrice[3][6] = { //Valores de preço da loja
{0, 2, 3, 1, 1, 10},
{6, 8, 13, 5, 4, 20},
{15, 8, 13, 18, 10, 40}
};
int PricePositions[3][4] = {// coordenadas onde serão impresso os icones e valores da loja
//moedas valor
// x y x y
{8, 48, 17, 49}, //
{40, 48, 49, 49}, //
{72, 48, 81, 49} //
};
int AuxShop[3][8] = { //desenha o setor auxiliar da grade do shopping, usado para saber em qual linha da grade de alimentos o usuario está
{104, 24, 111, 31, 112, 24, 119, 31},
{104, 32, 111, 39, 112, 32, 119, 39},
{104, 40, 111, 47, 112, 40, 119, 47}
};
int ShopZYX[3][4] = { //coordenadas do cursor da loja (X - Y / 0X x 0Y)
{8, 24, 24, 24}, {40, 24, 24, 24}, {72, 24, 24, 24},
};
//------------------------------------------------------------//
#include "neotimer.h"
#include <OLED_I2C.h>
#include "Frames.h"
#include "V_Config.h"
//DEFINIÇÃO DE POTENCIOMETROS
#define PtcA A0
#define PtcB A2
OLED Display(SDA, SCL); //Cria uma instancia chamada "Display" ligado nas portas i2c padrão
extern uint8_t TinyFont[];// fonte miudinha
extern uint8_t SmallFont[]; //fonte nolmal
void setup() {
Display.begin(SSD1306_128X64); //inicia o Display
Serial.begin(115200); //Inicia o serial
Serial2.begin(115200); //Inicia o serial do bluetooth
pinMode(PtcA, INPUT); //Define as portas dos potenciometros como Entrada
pinMode(PtcB, INPUT); //
Serial.println("Iniciando...");
for (int i = 0; i <= 7; i++) { //cria um laço que se repete 8 vezes a partir do zero
pinMode(botoes[i], INPUT); //define as portas em "botoes[i]" como entrada
}
}
void loop() {
/* Mapeamento: Será feio o mapeamento de 2 potenciometros disponíveis no controle.
O mapeamento será feito duas vezes para que a leitura do potenciometro seja
muito mais precisa.
*/
int mip1 = analogRead(PtcA); //obtém a leitura do potenciometro "PtcA" e guarda em "mip1"
int mapA = map(mip1, 0, 1023, 0, 511); //mapeia os valores recebidos de "mip1" e guarda em mapA
Map[0] = map(mapA, 0, 511, 0, 180); //Mapeia os valores que foram guardados em "mapA" e guarda em "Map[0]"
int mip2 = analogRead(PtcB); //obtém a leitura do potenciometro "PtcA" e guarda em "mip2"
int mapB = map(mip2, 0, 1023, 0, 511); //mapeia os valores recebidos de "mip2" e guarda em mapB
Map[1] = map(mapB, 0, 511, 0, 180); //Mapeia os valores que foram guardados em "mapA" e guarda em "Map[1]"
for (int i = 0; i <= 7; i++) { //criará um laço que se repetirá 8 vezes
Bot[i] = digitalRead(botoes[i]); //Faz a leitura de um botão diferente a cada vez que o laço se repete e guarda em "Bot[]"
if (Bot[i] == HIGH) { //Verifica se o botão do laço atual foi pressionado e envia por serial o botão que foi apertado
Serial.print("Botao: ");
Serial.print(i); //Numero do botão é mesmo do laço atual, guardado em " i "
Serial.println("apertado!");
}
}
if (MenuSelect == 99) { // vai para o menu
Menu();
}
if (MenuSelect == 0) { // vai para Interagir
// Game_Vr();
interact();
}
if (MenuSelect == 1) { // vai para Play
play();
}
if (MenuSelect == 2) { // vai para Shop
shop();
}
if (MenuSelect == 3) { // vai para config
}
}
//____________________/Codigo do menu/____________________/
void Menu() {
if (Rmenu == 0) { // desenha o menu apenas uma vez por comando
Display.clrScr(); //Limpa o display
Display.setFont(TinyFont); //define a fonte para "Fonte miuda"
for (int i = 0; i <= 4; i++) { //laço que se repete 5 vezes
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]); //imprime uma decoração do menu a cada laço repetido
}
if (Mgrade == 0) { //verifica se está na primeira linha do menu
for (int i = 5; i <= 7; i++) { //laço que se repete 3 vezes para desenhar 3 ícones no menu
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]); //desenha um icone a cada laço repetido
int Set = i - 5; // obtem os valores 0, 1, 2.
Display.print(menuText[Set], Ptext[Set][0], Ptext[Set][1]); //escreve as palavras "Acts","Play","Shop" abaixo dos icones
}
}
if (Mgrade == 1) { //verifica se está na segunda linha do menu
for (int i = 8; i <= 10; i++) {
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]);
int Set = i - 5; //obtem os valores 3, 4, 5.
Display.print(menuText[Set], Ptext[Set][0], Ptext[Set][1]); //escreve as palavras "Conf","Blue","Info" abaixo dos icones
}
}
int Py1; //sem uso
int Py2; //recebe o valor de "PYa" para desenhar o bloco de escolha do cursor
int Px1; //sem uso
int Px2; //recebe o valor de "Pxa" para desenhar o bloco de escolha do cursor
Display.setPixel(15, 0); // desenha os pixesl que ficam
Display.setPixel(31, 0); // como decoração acima do
Display.setPixel(47, 0); // menu
Display.setPixel(63, 0); //
Display.setPixel(64, 0); //
Display.setPixel(80, 0); //
Display.setPixel(96, 0); //
Pxb = Pxa + 1; // Faz um ajuste de posicionamento para desenhar a camada interna do bloco/cursor de escolhas
Pyb = Pya + 1; // -
Px2 = Pxa + 31; // Faz um ajuste de posicionamento para desenhar a camada externa do bloco/cursor de escolhas
Py2 = Pya + 31; // -
Display.drawRoundRect(Pxa, Pya, Px2, Py2); //cria um desenho da camada externa do bloco/cursor de escolhas
Px2 = Pxa + 30; // Faz um ajuste de posicionamento para desenhar a camada interna do bloco/cursor de escolhas
Py2 = Pya + 30; // -
Display.drawRoundRect(Pxb, Pyb, Px2, Py2); //cria um desenho da camada interna do bloco/cursor de escolhas
Display.update(); //envia a imagem para o display
Rmenu = 1; //Desativa a impressão da interface do menu após concluir todos os processos
}
if (Bot[1] == HIGH && AnteBot[1] == LOW) { // verifica se o botão direito foi apertado para mover o cursor do menu para a direita
Pmenu++; //aumenta seu valor conforme o cursor vai indo para a direita
if (Pmenu == 6) { //verifica se o cursor chegou ao seu limite
Pmenu = 0; //retorna o cursor para o primeiro ícone do menu
Rmenu = 0; //reseta o menu
} else {
Rmenu = 0; //reseta o menu
}
if (Pmenu >= 0 && Pmenu <= 2) { //Verifica se o cursor está na primeira coluna de ícones
Mgrade = 0; //indica ao sistema para que seja desenhado os 3 primeiros ícones do menu
Pxa = Cursor[Pmenu][0]; //obtém as coodenadas para o cursor do menu
Pya = Cursor[Pmenu][1]; // -
} else if (Pmenu >= 3 && Pmenu <= 5) { //Verifica se o cursor está na segunda coluna de ícones
Mgrade = 1; //indica ao sistema para que seja desenhado os 3 segundos ícones do menu
int set = Pmenu - 3; // obtém os valores de Pmenu - 3, para que o cursor não saia da tela ou bugue
Pxa = Cursor[set][0]; //obtém as coodenadas para o cursor do menu
Pya = Cursor[set][1]; // -
}
}
AnteBot[1] = Bot[1];// guarda o estado anterior do botão
if (Bot[3] == HIGH && AnteBot[3] == LOW) { // verifica se o botão esquerdo foi apertado para mover o cursor do menu para a esquerda
Pmenu--; //diminui seu valor conforme o cursor vai indo para a direita
if (Pmenu == -1) { //verifica se o cursor chegou ao seu limite
Pmenu = 5; //envia o cursor para o ultimo ícone na segunda linha do menu
Rmenu = 0; //reseta o menu
} else {
Rmenu = 0; //reseta o menu
}
if (Pmenu >= 0 && Pmenu <= 2) { //Verifica se o cursor está na primeira coluna de ícones
Mgrade = 0; //indica ao sistema para que seja desenhado os 3 primeiros ícones do menu
Pxa = Cursor[Pmenu][0]; //obtém as coodenadas para o cursor do menu
Pya = Cursor[Pmenu][1]; // -
} else if (Pmenu >= 3 && Pmenu <= 5) { //Verifica se o cursor está na segunda coluna de ícones
Mgrade = 1; //indica ao sistema para que seja desenhado os 3 segundos ícones do menu
int set = Pmenu - 3; // obtém os valores de Pmenu - 3, para que o cursor não saia da tela ou bugue
Pxa = Cursor[set][0]; //obtém as coodenadas para o cursor do menu
Pya = Cursor[set][1]; // -
}
}
AnteBot[3] = Bot[3];// guarda o estado anterior do botão
if (Bot[6] == HIGH && AnteBot[6] == LOW) { //confirma a escolha no menu principal
MenuSelect = Pmenu; //guarda o valor do cursor em "Menuselect"
Rshop = 1; //reseta todas as opções antes de ir para alguma delas
Rivent = 1; //
Rmenu = 0; //reseta o menu
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[6] = Bot[6];// guarda o estado anterior do botão
}
void Configurar() { // sem uso
for (int i = 0; i <= 4; i++) { //imprime as decorações acima no menu
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]);
}
Display.setPixel(15, 0); //desenha um pixel
Display.setPixel(31, 0); //desenha um pixel
Display.setPixel(47, 0); //desenha um pixel
Display.setPixel(63, 0); //desenha um pixel
Display.setPixel(64, 0); //desenha um pixel
Display.setPixel(80, 0); //desenha um pixel
Display.setPixel(96, 0); //desenha um pixel
}
//------------------------------------------------------------//
//____________________/Codigo do Shop/____________________/
void shop() {
if (ShopSelect == 0) {
if (Rshop == 1) { // desenha o menu
Display.clrScr(); //limpa o display
Display.setFont(TinyFont); //seleciona a fonte miuda
for (int i = 11; i <= 13; i++) { //laço que se repete 3 vezes
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]); //desenha a decoração do shopping utilizando MenuDecor[] a cada repetição do laço
}
if (Pshop[0] >= 0 && Pshop[0] <= 2) { //Verifica se o cursor está dentre a primeira coluna de coisas da loja
Sgrade[0] = 0; // indica ao sistema que o cursor está entre a linha de alimentos
int set = Pshop[0] + 3; //Faz com que o cursor receba as coodenadas corretas em "Cursor[]"
Pxa = Cursor[set][0]; // guarda as coordenadas do cursor
Pya = Cursor[set][1]; // -
} else if (Pshop[0] >= 3 && Pshop[0] <= 5) { //Verifica se o cursor está desntre a segunda coluna de coisas da loja
Sgrade[0] = 1; // indica ao sistema que o cursor está entre a linha de itens
Pxa = Cursor[Pshop[0]][0]; // guarda as coordenadas do cursor
Pya = Cursor[Pshop[0]][1]; // -
}
Sgrade[1] = Pshop[1]; // Recebe e guarda comandos de "Pshop[1]" para alterar a linha de ícones da loja
if (Sgrade[0] == 0) { //verifica se o cursor está na primeira coluna de itens
for (int i = 0; i <= 2; i++) { //laço que se repete 3 vezes para desenhar 3 ícones diferentes
//coordenadas dos itens: [ X ] [ Y ] [ícones] [Linhas] [ tamanho ]
Display.drawBitmap(ShopZYX[i][0], ShopZYX[i][1], ShopDecor[Sgrade[1]][i], ShopZYX[i][2], ShopZYX[i][3]);
int set = Sgrade[1]; //Guarda em "set" o valor de "Sgrade[1]".
Display.drawRect(AuxShop[set][0], AuxShop[set][1], AuxShop[set][2], AuxShop[set][3]); //desenha o cursor do AuxShop
Display.drawBitmap(PricePositions[i][0], PricePositions[i][1], Heart_mini, 8, 8);//desenha os ícones das moedas
Display.printNumI(ShopPrice[Sgrade[1]][i], PricePositions[i][2], PricePositions[i][3]);//
}
} else if (Sgrade[0] == 1) { //verifica se o cursor está na segunda coluna de itens
for (int i = 3; i <= 5; i++) { //laço que se repete 3 vezes para desenhar 3 ícones diferentes
int set = i - 3; //Guarda em "set" os valores 0, 1 e 2, para que o cursor não saia da tela quando desenhado
//coordenadas dos itens: [ X ] [ Y ] [ícones] [Linhas] [ tamanho ]
Display.drawBitmap(ShopZYX[set][0], ShopZYX[set][1], ShopDecor[Sgrade[1]][i], ShopZYX[set][2], ShopZYX[set][3]);
Display.drawBitmap(PricePositions[set][0], PricePositions[set][1], Paw_mini, 8, 8);//desenha os ícones das moedas
Display.printNumI(ShopPrice[Sgrade[1]][i], PricePositions[set][2], PricePositions[set][3]);// escreve a quantidade de moedas necessário
set = Sgrade[1]; //Guarda em "set" o valor de "Sgrade[1]"
Display.drawRect(AuxShop[set][4], AuxShop[set][5], AuxShop[set][6], AuxShop[set][7]); //desenha o cursor do AuxShop
}
}
Display.setPixel(15, 0); // Desenha a decoração de pontilhados na interface de Shop
Display.setPixel(31, 0); // -
Display.setPixel(47, 0); // -
Display.setPixel(63, 0); // -
Display.setPixel(64, 0); // -
Display.setPixel(80, 0); // -
Display.setPixel(96, 0); // -
Display.drawLine(Pxa, Pya, Pxa + 7, Pya); // Desenha o cursor da loja
Display.drawLine(Pxa + 1, Pya + 1, Pxa + 6, Pya + 1); // -
Display.drawLine(Pxa + 2, Pya + 2, Pxa + 5, Pya + 2); // -
Display.drawLine(Pxa + 3, Pya + 3, Pxa + 4, Pya + 3); // -
Display.drawBitmap(19, 4, Heart_mini, 8, 8); //desenha os ícones das moedas
Display.drawBitmap(68, 4, Paw_mini, 8, 8); //
Display.printNumI(Umoney[0], 28, 6);// escreve a quantidade de moedas necessário
Display.printNumI(Umoney[1], 77, 6);// escreve a quantidade de moedas necessário
Display.update();// envia a imagem para o display
Rshop = 0; //Desativa a impressão da interface do shop após concluir todos os processos
}
if (Bot[6] == HIGH && AnteBot[6] == LOW) { //seleciona um item
ShopSelect = 1; //sai do menu shop
Rshop = 1; //inicia a impressão da interface
}
AnteBot[6] = Bot[6]; // guarda o estado anterior do botão
if (Bot[0] == HIGH && AnteBot[0] == LOW) { //move a setinha do menu para a Cima
Pshop[1]--; //diminui o valor de "Pshop[1]" para que seja impresso a linha de icones acima da linha atual até que chegue em 0
if (Pshop[1] == -1) {// verifica se "Pshop[1]" esta passou do limite sendo menor que 0
Pshop[1] = 2; // Guarda em "Pshop[1]" o valor máximo para que seja desenhada a ultima linha de ícones
Rshop = 1; // inicia a impressão da interface do shop
} else {
Rshop = 1; // inicia a impressão da interface do shop
}
}
AnteBot[0] = Bot[0]; // guarda o estado anterior do botão
if (Bot[2] == HIGH && AnteBot[2] == LOW) { //move a setinha do menu para a baixo
Pshop[1]++; //aumenta seu valor a cada vez que o botão é pressionado fazendo a linha de ícones abaixar
if (Pshop[1] == 3) { //Verifica se "Pshop[1]" está em seu limite
Pshop[1] = 0; // Zera "Pshop[1]" para voltar para a primeira linha
Rshop = 1; //Reinicia a impressão da interface do display
} else {
Rshop = 1; //Reinicia a impressão da interface do display
}
}
AnteBot[2] = Bot[2];// guarda o estado anterior do botão
if (Bot[1] == HIGH && AnteBot[1] == LOW) { //move a setinha do menu para a direita
Pshop[0]++; //alterna entre os ícones da loja para a cada vez que aumenta seu valor
if (Pshop[0] == 6) { //verifica o limite de "Pshop[0]"
Pshop[0] = 0; //Zera "Pshop[0]" para que o cursor não bugue/ultrapasse a tela
Rshop = 1; //Reinicia a impressão da interface do display
} else {
Rshop = 1; //Reinicia a impressão da interface do display
}
}
AnteBot[1] = Bot[1];// guarda o estado anterior do botão
if (Bot[3] == HIGH && AnteBot[3] == LOW) { //move a setinha do menu para a esquerda
Pshop[0]--; //diminui o valor de "Pshop[0]" para que o cursor ande da direita para a esquerda
if (Pshop[0] == -1) { //verifica se "Pshop[0]" é menor que o seu limite
Pshop[0] = 5; //Deixa "Pshop[0]" em seu limite máximo
Rshop = 1; //Reinicia a impressão da interface do display
} else {
Rshop = 1; //Reinicia a impressão da interface do display
}
}
AnteBot[3] = Bot[3];
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //Volta para o menu principal
Rmenu = 0; //reseta o menu ao voltar para ele
Pmenu = 1; //volta para o menu na posição "play"
MenuSelect = 99; //indica ao sistema para voltar ao menu
Pxa = 48; //envia as coordenadas que o cursor deverá estar ao voltar.
Pya = 24; // -
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
}
if (ShopSelect == 1) { // cria uma verificação de compra
if (Rshop == 1) { //reseta a impressão de interface
Display.clrScr(); //limpa o display
Display.setFont(TinyFont); //seleciona a fonte miuda
for (int i = 11; i <= 13; i++) { //laço que se repete 3 vezes
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]); //desenha a decoração do shopping utilizando MenuDecor[] a cada repetição do laço
}
Display.setPixel(15, 0); // Desenha a decoração de pontilhados na interface de Shop
Display.setPixel(31, 0); // -
Display.setPixel(47, 0); // -
Display.setPixel(63, 0); // -
Display.setPixel(64, 0); // -
Display.setPixel(80, 0); // -
Display.setPixel(96, 0); // -
Display.clrRect(0, 16, 127, 63); // limpa toda a área azul do display
Display.drawRoundRect(0, 16, 127, 63); // Desenha um retangulo arredondado
Display.print("Quantidade:", 9, 25); // escreve palavra "quantidade" na tela
Display.printNumI(calculo[0], 54, 25); // escreve o numero que será multiplicado
Display.print("x", 68, 25); // escreve "x" que representa a multiplicação
Display.printNumI(ShopPrice[Pshop[1]][Pshop[0]], 74, 25); // escreve o valor que será multiplicado
calculo[1] = calculo[0] * ShopPrice[Pshop[1]][Pshop[0]];
Display.print("Total:", 9, 33); // escreve palavra "Total" na tela
Display.printNumI(calculo[1], 33, 33); // escreve o valor total multiplicado
Display.print("A: Yes.", 64, 57); // escreve palavra "Total" na tela
Display.print("B: No.", 94, 57); // escreve palavra "Total" na tela
Display.drawBitmap(19, 4, Heart_mini, 8, 8); //desenha os ícones das moedas
Display.drawBitmap(68, 4, Paw_mini, 8, 8); //
Display.printNumI(Umoney[0], 28, 6); // escreve a quantidade de moedas necessário
Display.printNumI(Umoney[1], 77, 6); // escreve a quantidade de moedas necessário
Display.update();// envia a imagem para o display
Rshop = 0; //Desativa a impressão da interface do shop após concluir todos os processos
}
if (Bot[6] == HIGH && AnteBot[6] == LOW) { //compra um item
if (Umoney[Sgrade[0]] - calculo[1] >= 0) { //se o valor do "seu_dinheiro{coração/patinhas}" menos o "ValorTotalDeItens" for maior/igual a zero
if (Info[Pshop[0]][Pshop[1]] + calculo[0] <= 100) { //se a quantia de "Itens-antigos" mais a quantida de "Itens-novos" for menor/igual a 100(limite de itens)
Umoney[Sgrade[0]] = Umoney[Sgrade[0]] - calculo[1]; //diminui a quantidade de dinheiro
Rshop = 1; //Reinicia a impressão da interface do display
Info[Pshop[0]][Pshop[1]] = Info[Pshop[0]][Pshop[1]] + calculo[0]; //aumenta o a quantidade de um item especifico
}
} else {
ShopSelect = 0; //ativa o menu do shop
calculo[0] = 0; //limpa valores de Calculo
calculo[1] = 0; //
Rshop = 1; //Reinicia a impressão da interface do display
}
}
AnteBot[6] = Bot[6]; // guarda o estado anterior do botão
if (delayBot.repeat()) { //diminui o tempo de leitura para os botões para que o comando não tenha repetições desnecessárias
if (Bot[1] == HIGH && AnteBot[1] == LOW) { //aumenta a quantidade de itens a ser comprados
Rshop = 1; //Reinicia a impressão da interface do display
calculo[0]++;//aumenta o valor da quantidade de itens a serem comprados
if (calculo[0] >= 101) { //verifica se está acima do limite 100
calculo[0] = 0; //iguala a zero
}
delayTimeBot.repeatReset();//reseta a contagem de tempo para quando o botão pressionado por muito tempo
AnteBot[1] = HIGH; //altera o valor de AnteBot[0] para que a função não se repita
} else if (Bot[1] == HIGH) { //verifica se o botão ainda está pressionado
if (Bot_at[1] == HIGH && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente
Rshop = 1; //Reinicia a impressão da interface do display
calculo[0]++;//aumenta o valor da quantidade de itens a serem comprados
if (calculo[0] >= 101) { //verifica se está acima do limite 100
calculo[0] = 0; //iguala a zero
}
}
} else {
Bot_at[1] = 0; //desliga Bot_at[2] para que os comandos não se repita mais de uma vez ao pressionar o botão pela primeira vez
}
AnteBot[1] = Bot[1];// guarda o estado anterior do botão
if (Bot[3] == HIGH && AnteBot[3] == LOW) { //diminui a quantidade de itens a serem comprados
Rshop = 1; //Reinicia a impressão da interface do display
calculo[0]--;//diminui o valor de itens a serem comprados
if (calculo[0] <= -1) { //verifica se está abaixo do limite minimo 0
calculo[0] = 100; //
}
delayTimeBot.repeatReset();//reseta a contagem de tempo para quando o botão pressionado por muito tempo
AnteBot[3] = HIGH; //altera o valor de AnteBot[0] para que a função não se repita
} else if (Bot[3] == HIGH) { //verifica se o botão ainda está pressionado
if (Bot_at[3] == HIGH && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente
Rshop = 1; //Reinicia a impressão da interface do display
calculo[0]--;//diminui o valor de itens a serem comprados
if (calculo[0] <= -1) { //verifica se está abaixo do limite minimo 0
calculo[0] = 100; //
}
}
} else {
Bot_at[3] = 0; //desliga Bot_at[3] para que os comandos não se repita mais de uma vez ao pressionar o botão pela primeira vez
}
AnteBot[3] = Bot[3];// guarda o estado anterior do botão
}
if (delayTimeBot.repeat(1)) { //aguarda o tempo de 1 segundo após o botão ser pressionado
Bot_at[1] = 1; // guarda o valor 1 para que os comandos se repitam várias vezes até que o botão seja solto
Bot_at[3] = 1; //
}
/* ///////////////////////////////////////////////////////////////
if (Bot[3] == HIGH && AnteBot[3] == LOW) { //diminui a quantidade de itens a ser comprados
Rshop = 1; //Reinicia a impressão da interface do display
calculo[0]--;//aumenta o valor
if (calculo[0] <= -1){ //verifica se está abaixo do limite minimo 0
calculo[0] = 100; //
}
delayTimeBot.repeatReset();//reseta a contagem de tempo para quando o botão pressionado por muito tempo
AnteBot[3] = HIGH; //altera o valor de AnteBot[3] para que a função não se repita
}
AnteBot[3] = Bot[3];
if (Delay_bot1.repeat()){
if (Bot_in[0] == HIGH && Bot_at[0] == LOW){ //verifica se o botão foi apertado
Serial.print(".");
Delay.repeatReset(); //reseta a contagem de tempo para quando o botão pressionado por muito tempo
Bot_at[0] = HIGH; //altera o valor de Bot_at[0] para que a função não se repita
} else if (Bot_in[0] == HIGH){ //verifica se o mesmo botão ainda esta presionado
if (Bot_at[1] == 1 && Delay_bot.repeat()){ //verifica se o botão ficou pressionado por tempo suficiente para repetir ao comandos
Serial.print("A"); //repete os comandos varias vezes
}
} else { //caso o botão não estiver mais pressionado
Bot_at[1] = 0; //limpa o valor de Bot_at[1] para que os comandos não se repitam até a próxima vez que o botão for pressionado por muito tempo
}
Bot_at[0] = Bot_in[0];
if (Bot_in[2] == HIGH && Bot_at[2] == LOW){ //verifica se o botão foi apertado
Serial.print(",");
Delay.repeatReset(); //reseta a contagem de tempo para quando o botão pressionado por muito tempo
Bot_at[2] = HIGH; //altera o valor de Bot_at[0] para que a função não se repita
} else if (Bot_in[2] == HIGH){ //verifica se o mesmo botão ainda esta presionado
if (Bot_at[3] == 1 && Delay_bot.repeat()){ //verifica se o botão ficou pressionado por tempo suficiente para repetir ao comandos
Serial.print("B"); //repete os comandos varias vezes
}
} else { //caso o botão não estiver mais pressionado
Bot_at[3] = 0; //limpa o valor de Bot_at[1] para que os comandos não se repitam até a próxima vez que o botão for pressionado por muito tempo
}
Bot_at[2] = Bot_in[2];
}
if (Delay.repeat(1)){
Bot_at[1] = 1;
Bot_at[3] = 1;
}
//////////////////////////////////////////////////// */
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //Volta para o shop
ShopSelect = 0; //ativa o menu do shop
calculo[0] = 0; //limpa valores de Calculo
calculo[1] = 0; //
Rshop = 1; //Reinicia a impressão da interface do display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
}
}
//------------------------------------------------------------//
//____________________/Codigo do Interact/____________________/
void interact() {
if (Bot[4] == HIGH && AnteBot[4] == LOW) { // abre o inventário Y
actions = 1; // desliga as animações do personagem
}
AnteBot[4] = Bot[4]; //guarda o estado anterior do botão Y
if (actions == 0) { //modo de animação do personagem
if (Delay_D.repeat()) { //animação das caudas
if (ActFrames[3] == 4) { //Se "ActFrames[3]" for igual a 4, guardará o valor 0 em si
ActFrames[3] = 0;
ActFrameSave[3] = ActFrames[3]; //Guarda a sequencia atual de "ActFrames[3]" em "ActFrameSave[3]" para imprimi-lo depois
} else {
ActFrameSave[3] = ActFrames[3]; //Guarda a sequencia atual de "ActFrames[3]" em "ActFrameSave[3]" para imprimi-lo depois
}
ActFrames[3]++; //aumenta o valor de "ActFrames[]" para dar andamento na sequencia de frames da animação do personagem
}
if (Delay_C.repeat()) { //animação do corpo
if (ActFramesProg[2] == 0) {
ActFrameSave[2] = ActFrames[2]; //Guarda a sequencia atual de "ActFrames[]" em "ActFrameSave[]" para imprimi-lo depois
ActFrames[2]++; //aumenta o valor de "ActFrames[]" para dar andamento na sequencia de frames da animação do personagem
if (ActFrames[2] == 2) {
ActFramesProg[2] = 2;
}
} else if (ActFramesProg[2] == 2) {
ActFrameSave[2] = ActFrames[2]; //Guarda a sequencia atual de "ActFrames[]" em "ActFrameSave[]" para imprimi-lo depois
ActFrames[2]--; //diminui o valor de "ActFrames[]" para desfazer a sequencia de frames da animação do personagem
if (ActFrames[2] == 0) {
ActFramesProg[2] = 0;
}
}
}
if (Delay_B.repeat()) { //animação da cabeça
if (ActFramesProg[1] == 0) {
ActFrameSave[1] = ActFrames[1]; //Guarda a sequencia atual de "ActFrames[]" em "ActFrameSave[]" para imprimi-lo depois
ActFrames[1]++; //aumenta o valor de "ActFrames[]" para dar andamento na sequencia de frames da animação do personagem
if (ActFrames[1] == 1) {
ActFramesProg[1] = 1;
}
} else if (ActFramesProg[1] == 1) {
ActFrameSave[1] = ActFrames[1]; //Guarda a sequencia atual de "ActFrames[]" em "ActFrameSave[]" para imprimi-lo depois
ActFrames[1]--; //diminui o valor de "ActFrames[]" para desfazer a sequencia de frames da animação do personagem
if (ActFrames[1] == 0) {
ActFramesProg[1] = 0;
}
}
}
if (Delay_A.repeat()) { //animação dos olhos
if (ActFramesProg[0] == 0) {
ActFrameSave[0] = ActFrames[0]; //Guarda a sequencia atual de "ActFrames[]" em "ActFrameSave[]" para imprimi-lo depois
ActFrames[0]++; //aumenta o valor de "ActFrames[]" para dar andamento na sequencia de frames da animação do personagem
if (ActFrames[0] == 2) {
ActFramesProg[0] = 2;
}
} else if (ActFramesProg[0] == 2) {
ActFrameSave[0] = ActFrames[0]; //Guarda a sequencia atual de "ActFrames[]" em "ActFrameSave[]" para imprimi-lo depois
ActFrames[0]--; //diminui o valor de "ActFrames[]" para desfazer a sequencia de frames da animação do personagem
if (ActFrames[0] == 0) {
ActFramesProg[0] = 0;
}
}
}
Display.drawBitmap(KitXY[ActFrameSave[2]][8], KitXY[ActFrameSave[2]][9], kitsune[2][ActFrameSave[2]], KitXY[ActFrameSave[2]][10], KitXY[ActFrameSave[2]][11]); //imprime o movimento do corpo
Display.drawBitmap(KitXY[ActFrameSave[3]][12], KitXY[ActFrameSave[3]][13], kitsune[3][ActFrameSave[3]], KitXY[ActFrameSave[3]][14], KitXY[ActFrameSave[3]][15]); //imprime o movimento das caudas
Display.drawBitmap(KitXY[ActFrameSave[1]][4], KitXY[ActFrameSave[1]][5], kitsune[1][ActFrameSave[1]], KitXY[ActFrameSave[1]][6], KitXY[ActFrameSave[1]][7]); //imprime o movimento da cabeça
Display.drawBitmap(KitXY[ActFrameSave[0]][0], KitXY[ActFrameSave[0]][1], kitsune[0][ActFrameSave[0]], KitXY[ActFrameSave[0]][2], KitXY[ActFrameSave[0]][3]); //imprime o movimento dos olhos
Display.update();// atualiza do display
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //Volta para o menu principal
Rmenu = 0; //reseta o menu ao voltar para ele
Pmenu = 1; //volta para o menu na posição "play"
MenuSelect = 99; //indica ao sistema para voltar ao menu
Pxa = 48; //envia as coordenadas que o cursor deverá estar ao voltar.
Pya = 24; // -
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
if (Bot[7] == HIGH && AnteBot[7] == LOW) { //Volta para o menu principal
actions = 2;
Rivent = 1;
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[7] = Bot[7];// guarda o estado anterior do botão
}
if (actions == 1) { //inventário
if (Rivent == 1) {
Display.clrScr(); //limpa o display
Display.setFont(TinyFont); //define a fonte para "Fonte miuda"
Display.drawBitmap(0, 0, Generic_decoration_E, 16, 16); //impime as decorações da interface
Display.drawBitmap(111, 0, Generic_decoration_D, 16, 16); //-
Display.setPixel(15, 0); //Desenha os detalhes no ponto superior da interface do display
Display.setPixel(31, 0); //-
Display.setPixel(47, 0); //-
Display.setPixel(63, 0); //-
Display.setPixel(64, 0); //-
Display.setPixel(80, 0); //-
Display.setPixel(96, 0); //-
Display.drawBitmap(19, 4, Heart_mini, 8, 8); //desenha os ícones das moedas
Display.drawBitmap(68, 4, Paw_mini, 8, 8); //
Display.printNumI(Umoney[0], 28, 6);// escreve a quantidade de moedas necessário
Display.printNumI(Umoney[1], 77, 6);// escreve a quantidade de moedas necessário
for (int i = 0; i <= 5; i++) { // Escreve o nome de até 6 itens por vez
if (Info[i][PIvent[1]] != 0) {
int set = i + 6;
Display.printNumI(Info[i][PIvent[1]], pItem[i][0], pItem[i][1]); //escreve a quantidade de itens do iventário
Display.print(Itens[i][PIvent[1]], pItem[set][0], pItem[set][1]); //escreve o nome do item
} else {
Display.print("( ? )", pItem[i][0], pItem[i][1]);
}
}
Pxa = Cursor[PIvent[0]][0];
Pya = Cursor[PIvent[0]][1];
Pxb = Pxa + 5;
Pyb = Pya + 5;
Display.drawRect(Pxa, Pya, Pxb, Pyb);
Display.update();
Rivent = 0;
}
if (Bot[6] == HIGH && AnteBot[6] == LOW) { //seleciona um item no iventário
//botão de escolha de itens apertado:
if (Info[PIvent[0] - 6][PIvent[1]] >= 1) { //verifica se há pelo menos 1 item do tipo escolhido
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes: 0 1 2 3 4 5 6
if (Necessidades[i] == 1) { //verifica qual necessidade esta ativa: 0,0,1,0,0,0,0
if (Efeitos[PIvent[0] - 6][PIvent[1]] == i) { //verifica se o valor do "Efeito" do item é o mesmo da necessidade que esta ativada: Efeito = 2
actions = 2; //abre a lista de necessidades e fecha o iventário
Rivent = 1; //atualiza o display
IventorySelect = 1; //diz ao sistema que um item foi selecionado
Delay_line.repeatReset(); //reseta a contagem do delay
}
}
}
}
}
AnteBot[6] = Bot[6];// guarda o estado anterior do botão
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //Volta para o menu principal
actions = 0;
Rivent = 1;
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
if (Bot[0] == HIGH && AnteBot[0] == LOW) { //move a setinha do menu para a Cima
Rivent = 1; //atualiza a impressão do display
PIvent[0]--; //diminui o valor de PIvent[0] para alterar a posição do cursor(Subir)
if (PIvent[0] <= 5) { //verifica se PIvent[0] é menor que o limite minimo = 6
PIvent[0] = 11; //faz com que PIvent[0] seja igual seu limite Maximo = 11
PIvent[1]--; ////diminui o valor de PIvent[1] para alterar uma coluna de palavras(retroceder)
if (PIvent[1] <= -1) {
PIvent[1] = 3;
}
}
}
AnteBot[0] = Bot[0]; // guarda o estado anterior do botão
if (Bot[2] == HIGH && AnteBot[2] == LOW) { //move a setinha do iventário para a baixo
Rivent = 1; //atualiza a impressão do display
PIvent[0]++; //aumenta o valor de PIvent[0] para alterar a posição do cursor(Descer)
if (PIvent[0] >= 12 ) { //verifica se PIvent[0] ultrapassou o limite = 11
PIvent[0] = 6; //faz com que PIvent[0] seja igual seu limite minimo = 6
PIvent[1]++; //aumenta o valor de PIvent[1] para alterar uma coluna de palavras(avançar)
if (PIvent[1] >= 4) { //vefifica se PIvent[1] ultrapassou seu limite = 3
PIvent[1] = 0; //guarda em PIvent[1] o seu limite minimo = 0
}
}
}
AnteBot[2] = Bot[2];// guarda o estado anterior do botão
if (Bot[1] == HIGH && AnteBot[1] == LOW) { //botão direito, usado como atalho para avançar parte da lista do iventário
Rivent = 1; //atualiza a impressão do display
PIvent[1]++;
if (PIvent[1] == 4) {
PIvent[1] = 0;
}
}
AnteBot[1] = Bot[1];// guarda o estado anterior do botão
if (Bot[3] == HIGH && AnteBot[3] == LOW) { //move a setinha do menu para a esquerda
Rivent = 1; //atualiza a impressão do display
PIvent[1]--;
if (PIvent[1] == -1) {
PIvent[1] = 3;
}
}
AnteBot[3] = Bot[3];
}
if (actions == 2) { //lista de necessidades
if (Rivent == 1) {
Display.clrScr(); //Limpa o display
Display.setFont(TinyFont); //define a fonte para "Fonte miuda"
for (int i = 0; i <= 1; i++) { //laço que se repete 2 vezes
Display.drawBitmap(Xyz[i][0], Xyz[i][1], Interface[i], Xyz[i][2], Xyz[i][3]); //imprime uma decoração do menu a cada laço repetido
}
Display.setPixel(15, 0); // Desenha os detalhes no ponto superior da interface do display
Display.setPixel(31, 0); //-
Display.setPixel(47, 0); //-
Display.setPixel(63, 0); //-
Display.setPixel(64, 0); //-
Display.setPixel(80, 0); //-
Display.setPixel(96, 0); //-
Display.print("Fome:", 1, 18); // Escreve todas as necessidades em formato de lista
Display.print("Sede:", 1, 24); //
Display.print("Frio:", 1, 30); //
Display.print("Calor:", 1, 36); //
Display.print("Doente:", 1, 42); //
Display.print("Cansada:", 1, 48); //
Display.print("Entediada", 1, 54); //
int xy[7][2] = {// coordenadas usadas para escrever o valor das necessidades
{45, 18},
{45, 24},
{45, 30},
{45, 36},
{45, 42},
{45, 48},
{45, 54}
};
for (int i = 0; i <= 6; i++) { // laço que se repete 7 vezes
Display.printNumI(Necessidades[i], xy[i][0], xy[i][1]); //escreve se uma necessidade está ativa ou não
}
Display.setFont(SmallFont); //define a fonte para "Fonte pequena"
Display.print("NECESSIDADES", 29, 5); //
Rivent = 0;
Display.update();
}
if (IventorySelect == 1) { //verifica se houve uma seleção de itens
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes: 0 1 2 3 4 5 6
if (Necessidades[i] == 1) { //verifica qual necessidade esta ativa: 0,0,1,0,0,0,0
if (Efeitos[PIvent[0] - 6 ][PIvent[1]] == i) { //verifica se o valor do "Efeito" do item é o mesmo da necessidade que esta ativada: Efeito = 2
int xy[7][4] = {// coordenadas usadas para escrever o valor das necessidades
//0 1 2 3
{56, 18, 114, 22}, //fome
{56, 24, 114, 28}, //sede
{56, 30, 114, 34}, //frio
{56, 36, 114, 40}, //calor
{56, 42, 114, 46}, //doente
{56, 48, 114, 52}, //cansada
{56, 54, 114, 58} //entediada
};
// guarda as coordenadas da linha que foi escrito o nome da necessidade ativa
// para criar uma barra de carregamento nesssa mesma linha
Pxa = xy[i][0]; // pxa = 56
Pya = xy[i][1]; // pya = 18
Pxb = Pxa; // pxb = 56
Pyb = xy[i][3]; // pyb = 22
Display.drawLine(Pxa, Pya, Pxb, Pyb); //desenha a parede esquerda da barra de carregamento
Pya = xy[i][3]; // pya = 22
Pxb = xy[i][2]; // pxb = 114
Pyb = Pya; // pyb = 22
Display.drawLine(Pxa, Pya, Pxb, Pyb); //desenha a linha de baixo da barra de carregamento
Pxa = xy[i][0] + 2; //pxa = 56 + 2
Pya = xy[i][1] + 1; //pxa = 18 + 1
Pxa = Pxa + Pixel; // pxa = 58 + (01.2.3.4.5...)
Pxb = Pxa; // pxb = 58 + (01.2.3.4.5...)
Pyb = Pya + 1; // pyb = 19 + 1
Display.setPixel(Pxa, Pya); // desenha a linha de carregamento da barra de carregamento
Display.setPixel(Pxb, Pyb); //
if (Delay_line.repeat(55)) { //delay que se repete a cada 10 milisegundos
Pixel++; //aumenta o tamanho da linha de carregamento
Display.update(); //atualiza o display sem precisar resetar o mesmo
}
if (Pixel >= 55) { // verifica se a barra de carregamento terminou de carregar
Necessidades[i] = 0; //finaliza a necessidade
Serial2.print(i); Serial2.println("N"); //comando 0N. 1N. 2N. . . desliga tal necessidade no robo
Serial.print(i); Serial.print("N");//
Pixel = 0; //reseta "Pixel" para poder ser utilizado novamente
Rivent = 1; //reinicia a impressão da interface
Info[PIvent[0] - 6][PIvent[1]]--; //retira um item do iventário
IventorySelect = 0; //desativa a escolha do iventário
Umoney[0] = Umoney[0] + 10 + i; //recompensa o usuário pelos cuidados
Umoney[1] = Umoney[1] + 10 + i; //
}
}
}
}
}
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //Volta para o inicio de Actions
actions = 0;
Rivent = 1;
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
}
}
//------------------------------------------------------------//
int Mode = 0; //define um modo de controle
int Charge[] = {0, 0, 0}; //guarda valores dos potenciometros para criar a animação das barras de carregamento dos servos
int Start_C = 0; //permite ou não com que o controle envie comandos
int Sv = 0; //diz ao sistema qual servo dentre b - c será usado
int Vxa; //guarda os valores anteriores do potenciometro: Map[]
int Vya; //
int Vza; //
//____________________/Codigo de Play/____________________//
void play() {
if (Mode == 0) { // modo de comandos padrão
if (Rivent == 1) { // permite que o display seja atualizado (usa Rivent para economia de memória)
Display.clrScr(); //limpa o display
Display.setFont(TinyFont); //define a fonte para "Fonte miuda"
Display.print("Servo A", 9, 10); //escreve os servos disponíveis
Display.print("Servo B", 49, 10); //
Display.print("Servo C", 89, 10); //
Display.drawRect(42, 25, 86, 53); // desenha o bloco da lista
Display.print("Programe:Y", 45, 28); // escreve as opções disponíveis
Display.print("Voltar: B", 45, 34); //
Display.print("Servos: X", 45, 40); //
Display.print("Start_C: A", 45, 46); //
Display.drawLine(9, 17, 9, 20); // desenha barras de carregamento dos servos
Display.drawLine(9, 20, 34, 20); //
Display.drawLine(49, 17, 49, 20); //
Display.drawLine(49, 20, 74, 20); //
Display.drawLine(89, 17, 89, 20); //
Display.drawLine(89, 20, 114, 20); //
//22
Charge[0] = map(Map[0], 0, 180, 0, 22);
if (Sv == 0) {
Charge[1] = map(Map[1], 0, 180, 0, 22);
} else {
Charge[2] = map(Map[1], 0, 180, 0, 22);
}
for (int i = 0; i <= Charge[0]; i++) { // laço que se repete na mesma quantidade de Charge[]
Display.setPixel(11 + i, 18); // desenha a linha de carregamento do servo A
}
for (int i = 0; i <= Charge[1]; i++) { // laço que se repete na mesma quantidade de Charge[]
Display.setPixel(51 + i, 18); // desenha a linha de carregamento do servo B
}
for (int i = 0; i <= Charge[2]; i++) { // laço que se repete na mesma quantidade de Charge[]
Display.setPixel(91 + i, 18); // desenha a linha de carregamento do servo C
}
Rivent = 0; //desativa o as impressões de interface
Display.update(); // atualiza o display
}
if (Start_C == 1) { //verifica se o botão se segurança foi pressionado
if (Bot[0] == HIGH && Bot[1] == HIGH) { //frente + direita
Serial2.println("E");
Serial.println("E");
} else if (Bot[0] == HIGH && Bot[3] == HIGH) { //frente + esquerda
Serial2.println("Q");
Serial.println("Q");
} else if (Bot[0] == HIGH) { //frente
Serial2.println("W");
Serial.println("W");
} else if (Bot[2] == HIGH && Bot[1] == HIGH) { //ré + Direita
Serial2.println("C");
Serial.println("C");
} else if (Bot[2] == HIGH && Bot[3] == HIGH) { //ré + esquerda
Serial2.println("Z");
Serial.println("Z");
} else if (Bot[2] == HIGH) { //ré
Serial2.println("S");
Serial.println("S");
} else if (Bot[1] == HIGH) { //direita
Serial2.println("D");
Serial.println("D");
} else if (Bot[3] == HIGH) { //Esquerda
Serial2.println("A");
Serial.println("A");
}
if (Sv == 0) { //escolhe dentre dois servos
if (Map[1] != Vxa) { //verifica se o potenciometro foi movido
Serial2.print(Map[1]); //envia um valor de 0 a 180
Serial2.println("X"); //escolhe um servo-motor
Serial.print(Map[1]); //envia um valor de 0 a 180
Serial.println("X"); //escolhe um servo-motor
Rivent = 1; //atualiza as informações do display
Vxa = Map[1];
}
} else {
if (Map[1] != Vza) { //verifica se o potenciometro foi movido
Serial2.print(Map[1]); //envia um valor de 0 a 180
Serial2.println("H"); //escolhe um servo-motor
Serial.print(Map[1]); //envia um valor de 0 a 180
Serial.println("H"); //escolhe um servo-motor
Rivent = 1; //atualiza as informações do display
Vza = Map[1];
}
}
if (Map[0] != Vya) { //verifica se o potenciometro foi movido
Serial2.print(Map[0]); //envia um valor de 0 a 180
Serial2.println("Y"); //escolhe um servo-motor
Serial.print(Map[0]); //envia um valor de 0 a 180
Serial.println("Y"); //escolhe um servo-motor
Rivent = 1; //atualiza as informações do display
Vya = Map[0];
}
}//start c
if (Sv == 0) {
if (Map[1] != Vxa) { //verifica se o potenciometro foi movido
Rivent = 1; //atualiza as informações do display
Vxa = Map[1];
}
} else {
if (Map[1] != Vza) { //verifica se o potenciometro foi movido
Rivent = 1; //atualiza as informações do display
Vza = Map[1];
}
}
if (Map[0] != Vya) { //verifica se o potenciometro foi movido
Rivent = 1; //atualiza as informações do display
Vya = Map[0];
}
if (Bot[4] == HIGH && AnteBot[4] == LOW) { //ativa o modo de programação
Mode = 1; //altera o modo para programador
Rivent = 1; //atualiza as informações do display
Start_C = 0; //desativa o modo de comando simples
}
AnteBot[4] = Bot[4];
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //sai do modo de controle
Rmenu = 0; //reseta o menu ao voltar para ele
Pmenu = 1; //volta para o menu na posição "play"
MenuSelect = 99; //indica ao sistema para voltar ao menu
Pxa = 48; //envia as coordenadas que o cursor deverá estar ao voltar.
Pya = 24; // -
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];
if (delayBot.repeat()) {
if (Bot[6] == HIGH && AnteBot[6] == LOW) { //Botão de segurança, ativa ou desativa os comandos de controle intantaneamente
Start_C = !Start_C; //inverte Start_C para ativar/desativar o modo de comando
delayTimeBot.repeatReset();
AnteBot[6] = HIGH;
} else if (Bot[6] == HIGH) { //caso o botão ainda estiver pressionado
if (Bot_at[6] == 1 && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente
Mode = 2; //altera o modo de comando
Bot_at[6] = 0; //altera o valor de Bot_at[6] para garantir que o comando não se repita
}
} else {
Bot_at[6] = 0; //altera o valor de Bot_at[6] para garantir que o comando não se repita
}
AnteBot[6] = Bot[6]; //guarda o ultimo estado do botão em AnteBot[]
}
if (delayTimeBot.repeat(1)) { //aguarda o tempo de 1 segundo para enviar o novo comando
Bot_at[6] = 1; //guarda o valor 1 em bot_at[6] para que um novo comando seja enviado
}
if (Bot[7] == HIGH && AnteBot[7] == LOW) { //Altera um dos servos a ser controlado
Sv = !Sv;
}
AnteBot[7] = Bot[7];
}
if (Mode == 1) { //modo de comandos programável
// 1 1 1 1 1
// 0,1 2 3 4 5 6 7 8 9 10,11,12,13,14,15,16,17,18,19, 20,21,22,23,24,25,26,27,28,29
int linhas[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // linhas que guardarão os comandos
int Eyes[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // linhas que guardarão os comandos
int Eyes_Closed[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // linhas que guardarão os comandos
int Motor[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // linhas que guardarão os comandos
int Tempo[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // linhas que guardarão os comandos
int Pcomand[] = {0, 0}; //controla o cursor de comandos {A, B}
// A = Numero maximo de linhas que podem aparecer no display. Ex: 0 - 5, o cursor só poderá se mover dentre essas linhas
// B = Numero maximo de linhas que podem ser criado um programa, as mesmas se movimentam pois o limite do cursor é de 0 - 5
int P_x = 0;
int servo[30][3] = { //salva temporáriamente 30 ações para quaisquer servos motores
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}
};
String Parametros_txt[] = {
" ",
"Kin.time( );",
"Kin.eyes[ ]={ };",
"Kin.eyes_closed[ ]={ };",
"Kin.servo[ ][ ][ ];",
"Kin.engine( )={ };"
};
String motor_txt[] = {
"LOW",
"F+D",
"F+E",
"F..",
"R+D",
"R+E",
"R..",
"D..",
"E.."
};
String olhos_txt[] = {
"Desligado", //0 29
"OlhosCA", //1 14
"OlhosCB", //2 15
"Triste", //3 16
"Pacifica", //4 0
"Cansada", //5 3
"Sede", //6 6
"Fome", //7 9
"Brincar", //8 10
"Frio", //9 11
"Calor", //10 12
"Boiando", //11 13
"Feliz", //12 17
"Gentil", //13 20
"Brava", //14 23
"Corada" //15 26
};
int olhosFechados_txt[] = {
"Desligado", //29
"Comum", //14
"Cansada", //15
"Triste" //16
};
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
int eyeComand[] = {29, 14, 15, 16, 0, 3, 6, 9, 10, 11, 12, 13, 17, 20, 23, 26}; //valores que são enviados para Kin quando um olhar é escolhido
int Xy_txt[6][2] = { //coodenadas onde são impressas as linhas de código
{1, 16},
{1, 24},
{1, 32},
{1, 40},
{1, 48},
{1, 56}
};
int barra = 0; //usado para criar uma barra piscante de digitação de texto
int Rcomand = 1; //permite que um comando seja resetado
int MotorC = 0; //envia comandos para os motores
Neotimer Delay_Bar = Neotimer(500); //tempo que controla o Piscar das barra de digitação
Neotimer Delay_comand; //Delay usado no comando de tempo para aguardar um novo comando
// Neotimer Delay_BA = Neotimer(1); //delay de tempo para repetição de comandos (Modelo antigo)
// Neotimer Delay_BB = Neotimer(1000); //
int select = 0; //altera entre o modo de edição, inicia ou testa o programa criado
while (Mode == 1) {
int mip1 = analogRead(PtcA); //obtém a leitura de "PtcA" e guarda em "mip1"
int mapA = map(mip1, 0, 1023, 0, 511); //mapeia os valores recebidos de "mip1" e guarda em mapA
Map[0] = map(mapA, 0, 511, 0, 180); //Mapeia os valores que foram guardados em "mapA" e guarda em "Map"
int mip2 = analogRead(PtcB); //obtém a leitura de "PtcA" e guarda em "mip1"
int mapB = map(mip2, 0, 1023, 0, 511); //mapeia os valores recebidos de "mip1" e guarda em mapA
Map[1] = map(mapB, 0, 511, 0, 180); //Mapeia os valores que foram guardados em "mapA" e guarda em "Map"
for (int i = 0; i <= 7; i++) { //criará um laço que se repetirá 8 vezes
Bot[i] = digitalRead(botoes[i]); //Faz a leitura de um botão diferente a cada vez que o laço se repete e guarda em "Bot[]"
if (Bot[i] == HIGH) { //Verifica se o botão do laço atual foi pressionado e envia por serial o botão que foi apertado
Serial.print("Botao: ");
Serial.print(i); //Numero do botão é mesmo do laço atual, guardado em " i "
Serial.println("apertado!");
}
}
if (Rivent == 1) { //imprime grande parte da interface
Display.clrScr(); //limpa o display
Display.setFont(TinyFont); //define a fonte para "Fonte miuda"
for (int i = 0; i <= 5; i++) { //laço que se repete 6
int set = linhas[i + Pcomand[1]]; //soma o valor da das 6 linhas atuais com o valor de Pcomand[1] para criar um efeito de lista
Display.print(Parametros_txt[set], 2, Xy_txt[i][1]); //escreve até 6 palavras de comandos
if (linhas[i + Pcomand[1]] == 1) { //verifica se dentre a linha 0 e 5 há algum delay e escreve o valor do mesmo se houver
Display.printNumI(Tempo[i + Pcomand[1]], 38, Xy_txt[i][1]); //escreve o valor de tempo em milisegundos
}
if (linhas[i + Pcomand[1]] == 2) { //verifica se dentre a linha 0 e 5 há comandos de olhares
Display.printNumI(Eyes[i + Pcomand[1]], 38, Xy_txt[i][1]); //escreve um dos valores que representam um olhar diferente
Display.print(olhos_txt[Eyes[i + Pcomand[1]]], 58, Xy_txt[i][1]); //escreve o nome do olhar
}
if (linhas[i + Pcomand[1]] == 3) { //verifica se dentre a linha 0 e 5 há comandos para olhos fechados
Display.printNumI(Eyes_Closed[i + Pcomand[1]], 66, Xy_txt[i][1]); //escreve um dos valores que representam um olhar diferente
Display.print(olhosFechados_txt[Eyes_Closed[i + Pcomand[1]]], 86, Xy_txt[i][1]); //escreve o nome do olhar
}
if (linhas[i + Pcomand[1]] == 4) { //verifica se dentre a linha 0 e 5 há comandos para contole de servos
int xy[] = {42, 54, 74};
for (int ps = 0; ps <= 2; ps++) { //laço que se repete 3 vezes
Display.printNumI(servo[i + Pcomand[1]][ps], xy[ps], Xy_txt[i][1]); //escreve os valores do parametro de servos
}
}
if (linhas[i + Pcomand[1]] == 5) { //verifica se dentre a linha 0 e 5 há comandos para controle de motor
Display.printNumI(Motor[i + Pcomand[1]], 46, Xy_txt[i][1]); //escreve o valor de um comando
Display.print(motor_txt[Motor[i + Pcomand[1]]], 62, Xy_txt[i][1]); //escreve a definição desse comando
}
}
Display.setFont(SmallFont); //define a fonte para "Fonte miuda"
Display.print("Line:", 8, 4); //escreve a palavra "Line:"/ Linha
Display.printNumI(Pcomand[0] + Pcomand[1], 38, 4); //escreve em qual linha está o usuário
Rivent = 0; //desativa a impressão do display
Display.update(); //atualiza o display
}
if (Delay_Bar.repeat()) { //anima uma barra piscante de texto
if (barra == 1) {
Display.drawLine(0, Xy_txt[Pcomand[0]][1], 0, Xy_txt[Pcomand[0]][1] + 4);//desenha a barra de digitação
barra = 0; //diz ao sistema que a barra foi desenhada e que pode ser apagada
Display.update();//atualiza o display
} else {
Display.clrLine(0, Xy_txt[Pcomand[0]][1], 0, Xy_txt[Pcomand[0]][1] + 4);//apaga a barra de digitação
barra = 1; //diz ao sistema que a barra foi apagada e que pode ser re-desenhada
Display.update();//atualiza o display
}
}
if (select == 0) { //modo de seleção de linhas de comando
if (delayBot.repeat()) { //diminui o tempo dos botões para evitar repetição de comandos
if (Bot[0] == HIGH && AnteBot[0] == LOW) { //move a setinha do programador para a Cima e as linhas de código para baixo
Rivent = 1; //atualiza a impressão do display
Pcomand[0]--; //diminui o valor de Pcomand[0] para alterar a posição do cursor(Subir)
delayTimeBot.repeatReset(); //reseta a contagem de tempo para quando o botão pressionado por muito tempo
AnteBot[0] = HIGH; //altera o valor de AnteBot[0] para que a função não se repita
if (Pcomand[0] <= -1) { //verifica se Pcomand[0] é menor que o limite minimo = 0
Pcomand[0] = 0; //faz com que Pcomand[0] seja sempre o mesmo valor minimo de limite = 0
Pcomand[1]--; ////diminui o valor de Pcomand[1] para alterar uma coluna de palavras(retroceder)
if (Pcomand[1] <= -1) { //verifica se Pcomand[1] ultrapassou o limite minimo de linhas disponíveis
Pcomand[1] = 25; //guarda em Pcomand[1] o seu limite maximo = 29
Pcomand[0] = 5;
}
}
} else if (Bot[0] == HIGH) { //verifica se o mesmo botão ainda esta presionado
if (Bot_at[0] == 1 && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente para repetir os comandos
Rivent = 1; //atualiza a impressão do display
Pcomand[0]--; //diminui o valor de Pcomand[0] para alterar a posição do cursor(Subir)
if (Pcomand[0] <= -1) { //verifica se Pcomand[0] é menor que o limite minimo = 0
Pcomand[0] = 0; //faz com que Pcomand[0] seja sempre o mesmo valor minimo de limite = 0
Pcomand[1]--; ////diminui o valor de Pcomand[1] para alterar uma coluna de palavras(retroceder)
if (Pcomand[1] <= -1) { //verifica se Pcomand[1] ultrapassou o limite minimo de linhas disponíveis
Pcomand[1] = 25; //guarda em Pcomand[1] o seu limite maximo = 29
Pcomand[0] = 5;
}
}
}
} else { //caso o botão não estiver mais pressionado
Bot_at[0] = 0; //limpa o valor de Bot_at[0] para que os comandos não se repitam até a próxima vez que o botão for pressionado por muito tempo
}
AnteBot[0] = Bot[0]; // guarda o estado anterior do botão
if (Bot[2] == HIGH && AnteBot[2] == LOW) { //move a setinha do iventário para a baixo
Rivent = 1; //atualiza a impressão do display
Pcomand[0]++; //aumenta o valor de Pcomand[0] para alterar a posição do cursor(Descer)
delayTimeBot.repeatReset(); //reseta a contagem de tempo para quando o botão pressionado por muito tempo
AnteBot[2] = HIGH; //altera o valor de AnteBot[2] para que a função não se repita
if (Pcomand[0] >= 6 ) { //verifica se Pcomand[0] ultrapassou o limite = 6
Pcomand[0] = 5; //faz com que Pcomand[0] seja igual seu limite maximo = 5
Pcomand[1]++; //aumenta o valor de Pcomand[1] para alterar uma coluna de palavras(avançar)
if (Pcomand[1] >= 26) { //vefifica se Pcomand[1] ultrapassou seu limite = 25
Pcomand[1] = 0; //guarda em Pcomand[1] o seu limite minimo = 0
Pcomand[0] = 0; //guarda em Pcomand[0] o seu limite minimo = 0
}
}
} else if (Bot[2] == HIGH) { //verifica se o mesmo botão ainda esta presionado
if (Bot_at[2] == 1 && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente para repetir os comandos
Rivent = 1; //atualiza a impressão do display
Pcomand[0]++; //aumenta o valor de Pcomand[0] para alterar a posição do cursor(Descer)
if (Pcomand[0] >= 6 ) { //verifica se Pcomand[0] ultrapassou o limite = 6
Pcomand[0] = 5; //faz com que Pcomand[0] seja igual seu limite maximo = 5
Pcomand[1]++; //aumenta o valor de Pcomand[1] para alterar uma coluna de palavras(avançar)
if (Pcomand[1] >= 26) { //vefifica se Pcomand[1] ultrapassou seu limite = 25
Pcomand[1] = 0; //guarda em Pcomand[1] o seu limite minimo = 0
Pcomand[0] = 0; //guarda em Pcomand[0] o seu limite minimo = 0
}
}
}
} else {
Bot_at[2] = 0;//limpa o valor de Bot_at[2] para que os comandos não se repitam até a próxima vez que o botão for pressionado por muito tempo
}
AnteBot[2] = Bot[2];// guarda o estado anterior do botão
if (delayTimeBot.repeat(1)) { //aguarda o tempo de 1 segundo após o botão ser pressionado
Bot_at[0] = 1; // guarda o valor 1 para que os comandos se repitam várias vezes até que o botão seja solto
Bot_at[2] = 1; //
}
}
if (Bot[4] == HIGH && AnteBot[4] == LOW) { // inicia a execução dos comandos escolhidos
select = 1; //ativa a execução do programa
Rivent = 1; //atualiza as informações do display
}
AnteBot[4] = Bot[4];// guarda o estado anterior do botão
if (Bot[6] == HIGH && AnteBot[6] == LOW) { // seleciona um comando para editar
select = 2; //abre o modo de edição
Rivent = 1; //atualiza as informações do display
}
AnteBot[6] = Bot[6];// guarda o estado anterior do botão
if (Bot[7] == HIGH) { // testa um comando
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //controle de servos
String cmd[] = {"Y", "X", "H"};
int i = servo[Pcomand[0] + Pcomand[1]][2];//guarda na variável " i " o valor da terceira coluna de servo[][] = {0,0,1};
Serial2.print(i); //envia o valor da velocidade do servo
Serial2.println("V"); //envia o comando: Velocidade
i = servo[Pcomand[0] + Pcomand[1]][1]; //guarda na variável " i " o valor da segunda coluna de servo[][] = {0,1,0};
Serial2.print(i); //envia o valor da posição em que o servo deverá ficar
i = servo[Pcomand[0] + Pcomand[1]][0]; //guarda na variável " i " o valor da primeira coluna de servo[][] = {1,0,0};
Serial2.println(cmd[i]); //envia o comando que escolhe um servo-motor
Rivent = 1; //atualiza as informações do display
Pcomand[0]++;
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //controle de motores
MotorC = Motor[Pcomand[0] + Pcomand[1]]; //diz ao sistema qual comando enviar ao motores
Rivent = 1;//atualiza as informações do display
Pcomand[0]++;
}
if (MotorC == 1) { //frente + direita
Serial2.println("E");
Serial.println("E");
} else if (MotorC == 2) { //frente + esquerda
Serial2.println("Q");
Serial.println("Q");
} else if (MotorC == 3) { //frente
Serial2.println("W");
Serial.println("W");
} else if (MotorC == 4) { //ré + Direita
Serial2.println("C");
Serial.println("C");
} else if (MotorC == 5) { //ré + esquerda
Serial2.println("Z");
Serial.println("Z");
} else if (MotorC == 6) { //ré
Serial2.println("S");
Serial.println("S");
} else if (MotorC == 7) { //direita
Serial2.println("D");
Serial.println("D");
} else if (MotorC == 8) { //Esquerda
Serial2.println("A");
Serial.println("A");
}
}
if (Bot[5] == HIGH && AnteBot[5] == LOW) { // sai do modo de programa
select = 0;
Rivent = 1; //atualiza as informações do display
Mode = 0; //volta ao modo de comandos padrão
Display.clrScr();
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
}
if (select == 2) { //edita os comandos
if (delayBot.repeat()) {
if (Bot[0] == HIGH && AnteBot[0] == LOW) { //verifica se o botão foi apertado e aumenta os valores dos parametros
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //verifica se os parametros são de um delay para edita-los
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] + 50; //aumenta o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] >= 90050) { //verifica se o valor ultrapassou o limite = 90000
Tempo[Pcomand[0] + Pcomand[1]] = 90000;
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //edita os parametros dos olhos
Eyes[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos olhos
if (Eyes[Pcomand[0] + Pcomand[1]] >= 16) { //verifica se o valor ultrapassou o limite = 15
Eyes[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //edita os parametros dos olhos-fechados
Eyes_Closed[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos olhos-fechados
if (Eyes_Closed[Pcomand[0] + Pcomand[1]] >= 4) { //verifica se o valor ultrapassou o limite = 3
Eyes_Closed[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //edita os parametros dos servos
servo[Pcomand[0] + Pcomand[1]][P_x]++; //aumenta os parametros dos servos
if (servo[Pcomand[0] + Pcomand[1]][0] >= 3) { //verifica se o valor ultrapassou o limite = 2 /servos
servo[Pcomand[0] + Pcomand[1]][0] = 0;//zera o valor caso ultrapasse o limite
}
if (servo[Pcomand[0] + Pcomand[1]][1] >= 181) { //verifica se o valor ultrapassou o limite = 180 /posições
servo[Pcomand[0] + Pcomand[1]][1] = 0;//zera o valor caso ultrapasse o limite
}
if (servo[Pcomand[0] + Pcomand[1]][2] >= 256) { //verifica se o valor ultrapassou o limite = 255 /velocidades
servo[Pcomand[0] + Pcomand[1]][2] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //edita os parametros dos motores
Motor[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos motores
if (Motor[Pcomand[0] + Pcomand[1]] >= 9) { //verifica se o valor ultrapassou o limite = 8
Motor[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
Rivent = 1; //atualiza o display
delayTimeBot.repeatReset();
AnteBot[0] = HIGH;
} else if (Bot[0] == HIGH) { //verifica se o mesmo botão ainda esta presionado
if (Bot_at[0] == 1 && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente para repetir os comandos
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //verifica se os parametros são de um delay para edita-los
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] + 100; //aumenta o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] >= 90100) { //verifica se o valor ultrapassou o limite = 90000
Tempo[Pcomand[0] + Pcomand[1]] = 90000;
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //edita os parametros dos olhos
Eyes[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos olhos
if (Eyes[Pcomand[0] + Pcomand[1]] >= 16) { //verifica se o valor ultrapassou o limite = 15
Eyes[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //edita os parametros dos olhos-fechados
Eyes_Closed[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos olhos-fechados
if (Eyes_Closed[Pcomand[0] + Pcomand[1]] >= 4) { //verifica se o valor ultrapassou o limite = 3
Eyes_Closed[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //edita os parametros dos servos
servo[Pcomand[0] + Pcomand[1]][P_x]++; //aumenta os parametros dos servos
if (servo[Pcomand[0] + Pcomand[1]][0] >= 3) { //verifica se o valor ultrapassou o limite = 2 /servos
servo[Pcomand[0] + Pcomand[1]][0] = 0;//zera o valor caso ultrapasse o limite
}
if (servo[Pcomand[0] + Pcomand[1]][1] >= 181) { //verifica se o valor ultrapassou o limite = 180 /posições
servo[Pcomand[0] + Pcomand[1]][1] = 0;//zera o valor caso ultrapasse o limite
}
if (servo[Pcomand[0] + Pcomand[1]][2] >= 256) { //verifica se o valor ultrapassou o limite = 255 /velocidades
servo[Pcomand[0] + Pcomand[1]][2] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //edita os parametros dos motores
Motor[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos motores
if (Motor[Pcomand[0] + Pcomand[1]] >= 9) { //verifica se o valor ultrapassou o limite = 8
Motor[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
}
} else { //caso o botão não estiver mais pressionado
Bot_at[0] = 0; //limpa o valor de Bot_at[0] para que os comandos não se repitam até a próxima vez que o botão for pressionado por muito tempo
}
AnteBot[0] = Bot[0];// guarda o estado anterior do botão
if (Bot[2] == HIGH && AnteBot[2] == LOW) { //verifica se o botão foi apertado e diminui os valores dos parametros
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //edita os parametros de delay
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] - 50; //dimiui o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] <= -50) { //verifica se o valor é menor que o limite = 0
Tempo[Pcomand[0] + Pcomand[1]] = 0; //zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //edita os parametros dos olhos
Eyes[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos olhos
if (Eyes[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Eyes[Pcomand[0] + Pcomand[1]] = 13;//maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //edita os parametros dos olhos-fechados
Eyes_Closed[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos olhos-fechados
if (Eyes_Closed[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Eyes_Closed[Pcomand[0] + Pcomand[1]] = 3; //maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //edita os parametros dos servos
servo[Pcomand[0] + Pcomand[1]][P_x]--; //diminui os parametros dos servos
if (servo[Pcomand[0] + Pcomand[1]][0] <= -1) { //verifica se o valor é menor que o limite = 0 /servos
servo[Pcomand[0] + Pcomand[1]][0] = 2;//maximiza o valor caso seja menor que o limite
}
if (servo[Pcomand[0] + Pcomand[1]][1] <= -1) { //verifica se o valor é menor que o limite = 0 /posições
servo[Pcomand[0] + Pcomand[1]][1] = 180;//maximiza o valor caso seja menor que o limite
}
if (servo[Pcomand[0] + Pcomand[1]][2] <= -1) { //verifica se o valor é menor que o limite = 0 /velocidades
servo[Pcomand[0] + Pcomand[1]][2] = 255;//maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //edita os parametros dos motores
Motor[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos motores
if (Motor[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Motor[Pcomand[0] + Pcomand[1]] = 8;//maximiza o valor caso seja menor que o limite
}
}
Rivent = 1; //atualiza as informações do display
AnteBot[2] = HIGH; //altera o valor de AnteBot[2] para que a função não se repita
delayTimeBot.repeatReset(); //reseta a contagem de tempo para quando o botão pressionado por muito tempo
} else if (Bot[2] == HIGH) { //verifica se o mesmo botão ainda esta presionado
if (Bot_at[2] == 1 && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente para repetir os comandos
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //edita os parametros de delay
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] - 100; //dimiui o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] <= -50) { //verifica se o valor é menor que o limite = 0
Tempo[Pcomand[0] + Pcomand[1]] = 0; //zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //edita os parametros dos olhos
Eyes[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos olhos
if (Eyes[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Eyes[Pcomand[0] + Pcomand[1]] = 13;//maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //edita os parametros dos olhos-fechados
Eyes_Closed[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos olhos-fechados
if (Eyes_Closed[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Eyes_Closed[Pcomand[0] + Pcomand[1]] = 3; //maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //edita os parametros dos servos
servo[Pcomand[0] + Pcomand[1]][P_x]--; //diminui os parametros dos servos
if (servo[Pcomand[0] + Pcomand[1]][0] <= -1) { //verifica se o valor é menor que o limite = 0 /servos
servo[Pcomand[0] + Pcomand[1]][0] = 2;//maximiza o valor caso seja menor que o limite
}
if (servo[Pcomand[0] + Pcomand[1]][1] <= -1) { //verifica se o valor é menor que o limite = 0 /posições
servo[Pcomand[0] + Pcomand[1]][1] = 180;//maximiza o valor caso seja menor que o limite
}
if (servo[Pcomand[0] + Pcomand[1]][2] <= -1) { //verifica se o valor é menor que o limite = 0 /velocidades
servo[Pcomand[0] + Pcomand[1]][2] = 255;//maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //edita os parametros dos motores
Motor[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos motores
if (Motor[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Motor[Pcomand[0] + Pcomand[1]] = 8;//maximiza o valor caso seja menor que o limite
}
}
}
} else { //caso o botão não estiver mais pressionado
Bot_at[2] = 0; //limpa o valor de Bot_at[2] para que os comandos não se repitam até a próxima vez que o botão for pressionado por muito tempo
}
AnteBot[2] = Bot[2];// guarda o estado anterior do botão
}
if (delayTimeBot.repeat(1)) { //aguarda o tempo de 1 segundo após o botão ser pressionado
Bot_at[0] = 1; // guarda o valor 1 para que os comandos se repitam várias vezes até que o botão seja solto
Bot_at[2] = 1;
}
/*
if (Bot[0] == HIGH && AnteBot[0] == LOW) { // aumenta os valores dos parametros
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //edita os parametros de delay
if (Delay_BA.repeat(1)) { // 1 mili
Delay_BB.set(2000);
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] + 50; //aumenta o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] >= 90050) { //verifica se o valor ultrapassou o limite = 90000
Tempo[Pcomand[0] + Pcomand[1]] = 90000;
}
}
if (Delay_BB.repeat()) {
Delay_BB.set(1);
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] + 100; //aumenta o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] >= 90100) { //verifica se o valor ultrapassou o limite = 90000
Tempo[Pcomand[0] + Pcomand[1]] = 90000;
}
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //edita os parametros dos olhos
Eyes[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos olhos
if (Eyes[Pcomand[0] + Pcomand[1]] >= 16) { //verifica se o valor ultrapassou o limite = 15
Eyes[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //edita os parametros dos olhos-fechados
Eyes_Closed[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos olhos-fechados
if (Eyes_Closed[Pcomand[0] + Pcomand[1]] >= 4) { //verifica se o valor ultrapassou o limite = 3
Eyes_Closed[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //edita os parametros dos servos
servo[Pcomand[0] + Pcomand[1]][P_x]++; //aumenta os parametros dos servos
if (servo[Pcomand[0] + Pcomand[1]][0] >= 3) { //verifica se o valor ultrapassou o limite = 2 /servos
servo[Pcomand[0] + Pcomand[1]][0] = 0;//zera o valor caso ultrapasse o limite
}
if (servo[Pcomand[0] + Pcomand[1]][1] >= 181) { //verifica se o valor ultrapassou o limite = 180 /posições
servo[Pcomand[0] + Pcomand[1]][1] = 0;//zera o valor caso ultrapasse o limite
}
if (servo[Pcomand[0] + Pcomand[1]][2] >= 256) { //verifica se o valor ultrapassou o limite = 255 /velocidades
servo[Pcomand[0] + Pcomand[1]][2] = 0;//zera o valor caso ultrapasse o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //edita os parametros dos motores
Motor[Pcomand[0] + Pcomand[1]]++; //aumenta os parametros dos motores
if (Motor[Pcomand[0] + Pcomand[1]] >= 9) { //verifica se o valor ultrapassou o limite = 8
Motor[Pcomand[0] + Pcomand[1]] = 0;//zera o valor caso ultrapasse o limite
}
}
Rivent = 1; //atualiza o display
} else {
Delay_BB.set(2000); //reseta o valor de tempo do Delay_BB
Delay_BA.repeatReset(); //reseta a contagem de Delay_BA
}
if (linhas[Pcomand[0] + Pcomand[1]] != 1) {
AnteBot[0] = Bot[0];// guarda o estado anterior do botão
}
if (Bot[2] == HIGH && AnteBot[2] == LOW) { // diminui os valores dos parametros
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //edita os parametros de delay
if (Delay_BA.repeat(1)) { // 1 mili
Delay_BB.set(2000);
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] - 50; //dimiui o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] <= -50) { //verifica se o valor é menor que o limite = 0
Tempo[Pcomand[0] + Pcomand[1]] = 0; //zera o valor caso ultrapasse o limite
}
}
if (Delay_BB.repeat()) {
Delay_BB.set(1);
Tempo[Pcomand[0] + Pcomand[1]] = Tempo[Pcomand[0] + Pcomand[1]] - 100; //dimiui o tempo de 10 em 10 milisegundos
if (Tempo[Pcomand[0] + Pcomand[1]] <= -50) { //verifica se o valor é menor que o limite = 0
Tempo[Pcomand[0] + Pcomand[1]] = 0; //zera o valor caso ultrapasse o limite
}
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //edita os parametros dos olhos
Eyes[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos olhos
if (Eyes[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Eyes[Pcomand[0] + Pcomand[1]] = 13;//maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //edita os parametros dos olhos-fechados
Eyes_Closed[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos olhos-fechados
if (Eyes_Closed[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Eyes_Closed[Pcomand[0] + Pcomand[1]] = 3; //maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //edita os parametros dos servos
servo[Pcomand[0] + Pcomand[1]][P_x]--; //diminui os parametros dos servos
if (servo[Pcomand[0] + Pcomand[1]][0] <= -1) { //verifica se o valor é menor que o limite = 0 /servos
servo[Pcomand[0] + Pcomand[1]][0] = 2;//maximiza o valor caso seja menor que o limite
}
if (servo[Pcomand[0] + Pcomand[1]][1] <= -1) { //verifica se o valor é menor que o limite = 0 /posições
servo[Pcomand[0] + Pcomand[1]][1] = 180;//maximiza o valor caso seja menor que o limite
}
if (servo[Pcomand[0] + Pcomand[1]][2] <= -1) { //verifica se o valor é menor que o limite = 0 /velocidades
servo[Pcomand[0] + Pcomand[1]][2] = 255;//maximiza o valor caso seja menor que o limite
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //edita os parametros dos motores
Motor[Pcomand[0] + Pcomand[1]]--; //diminui os parametros dos motores
if (Motor[Pcomand[0] + Pcomand[1]] <= -1) { //verifica se o valor é menor que o limite = 0
Motor[Pcomand[0] + Pcomand[1]] = 8;//maximiza o valor caso seja menor que o limite
}
}
Rivent = 1; //atualiza as informações do display
} else {
Delay_BB.set(2000); //reseta o valor de tempo do Delay_BB
Delay_BA.repeatReset(); //reseta a contagem de Delay_BA
}
if (linhas[Pcomand[0] + Pcomand[1]] != 1) {
AnteBot[2] = Bot[2];// guarda o estado anterior do botão
} */
if (Bot[1] == HIGH && AnteBot[1] == LOW) { // Faz a troca de parametros (Avançar)
P_x++; //aumenta o valor de P_x para alterar parametros
if (P_x >= 3) {
P_x = 0; //reseta P_x ao ultrapassar o limite
}
}
AnteBot[1] = Bot[1];// guarda o estado anterior do botão
if (Bot[3] == HIGH && AnteBot[3] == LOW) { // Faz a troca de parametros (Voltar)
P_x--; //diminui o valor de P_x para alterar parametros
if (P_x <= -1) {
P_x = 2; //maximiza P_x ao ultrapassar o limite
}
}
AnteBot[3] = Bot[3];// guarda o estado anterior do botão
if (Bot[5] == HIGH && AnteBot[5] == LOW) { // sai do modo de edição
select = 0;
Rivent = 1; //atualiza as informações do display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
if (Bot[7] == HIGH && AnteBot[7] == LOW) { // troca o tipo de comando
linhas[Pcomand[0] + Pcomand[1]]++; //aumenta o valor de linhas[] para alterar o comando de uma linha específica
Rivent = 1; //atualiza as informações do display
if (linhas[Pcomand[0] + Pcomand[1]] >= 6) { //verifica se linhas[] é maior que 5
linhas[Pcomand[0] + Pcomand[1]] = 0; //zera linhas[] para reapresentar todos os comandos disponíveis
}
}
AnteBot[7] = Bot[7];// guarda o estado anterior do botão
}
if (select == 1) { //iniciar comandos
/*
oq deve acontecer aqui;
ao iniciar, a barra de escrita pode começar da linha em que esteve durante a programação
o sistema deverá saber em qual linha está e qual o comando que está naquela linha
deverá executar o comando e aumentar o valor de Pcomand[1] para passar para o próximo comando
o codigo os comandos finalizará assim que chegar em qualquer linha de código que esteja sem nenhum comando
*/
if (linhas[Pcomand[0] + Pcomand[1]] == 0) { //finaliza o modo de comandos automatico
select = 0;
Rivent = 1;
}
if (linhas[Pcomand[0] + Pcomand[1]] == 1) { //verifica se o comando é um delay
if (Rcomand == 1) {
Delay_comand.set(Tempo[Pcomand[0] + Pcomand[1]]);
Delay_comand.repeatReset();
Rcomand = 0;
}
if (Delay_comand.repeat(1)) {
Rivent = 1; //atualiza as informações do display
Rcomand = 1; //permite que outro comando seja configurado
Pcomand[0]++;
}
}
if (linhas[Pcomand[0] + Pcomand[1]] == 2) { //verifica se o comando muda o olhar
//Serial2.print(Eyes[Pcomand[0] + Pcomand[1]]); //envia o valor do comando
Serial2.print(eyeComand[Eyes[Pcomand[0] + Pcomand[1]]]); //envia o valor do comando
Serial2.println("O"); //envia o tipo de comando = olhos
Serial.print(eyeComand[Eyes[Pcomand[0] + Pcomand[1]]]); //envia o valor do comando
Serial.println("O"); //envia o tipo de comando = olhos
Pcomand[0]++;
Rivent = 1;//atualiza as informações do display
}
if (linhas[Pcomand[0] + Pcomand[1]] == 3) { //verifica se o comando muda o olhar quando fechado
Serial2.print(eyeComand[Eyes_Closed[Pcomand[0] + Pcomand[1]]]); //envia o valor do comando
Serial2.println("o"); //envia o tipo de comando = olhos fechados
Serial.print(eyeComand[Eyes_Closed[Pcomand[0] + Pcomand[1]]]); //envia o valor do comando
Serial.println("o"); //envia o tipo de comando = olhos fechados
Pcomand[0]++;
Rivent = 1;//atualiza as informações do display
}
if (linhas[Pcomand[0] + Pcomand[1]] == 4) { //controle de servos
String cmd[] = {"Y", "X", "H"};
int i = servo[Pcomand[0] + Pcomand[1]][2];//guarda na variável " i " o valor da terceira coluna de servo[][] = {0,0,1};
Serial2.print(i); //envia o valor da velocidade do servo
Serial2.println("V"); //envia o comando: Velocidade
Serial.print(i); //envia o valor da velocidade do servo
Serial.println("V"); //envia o comando: Velocidade
i = servo[Pcomand[0] + Pcomand[1]][1]; //guarda na variável " i " o valor da segunda coluna de servo[][] = {0,1,0};
Serial2.print(i); //envia o valor da posição em que o servo deverá ficar
Serial.print(i); //envia o valor da posição em que o servo deverá ficar
i = servo[Pcomand[0] + Pcomand[1]][0]; //guarda na variável " i " o valor da primeira coluna de servo[][] = {1,0,0};
Serial2.println(cmd[i]); //envia o comando que escolhe um servo-motor
Serial.println(cmd[i]); //envia o comando que escolhe um servo-motor
Rivent = 1; //atualiza as informações do display
Pcomand[0]++;
}
if (linhas[Pcomand[0] + Pcomand[1]] == 5) { //controle de motores
MotorC = Motor[Pcomand[0] + Pcomand[1]]; //diz ao sistema qual comando enviar ao motores
Rivent = 1;//atualiza as informações do display
Pcomand[0]++;
}
if (MotorC == 1) { //frente + direita
Serial2.println("E");
Serial.println("E");
} else if (MotorC == 2) { //frente + esquerda
Serial2.println("Q");
Serial.println("Q");
} else if (MotorC == 3) { //frente
Serial2.println("W");
Serial.println("W");
} else if (MotorC == 4) { //ré + Direita
Serial2.println("C");
Serial.println("C");
} else if (MotorC == 5) { //ré + esquerda
Serial2.println("Z");
Serial.println("Z");
} else if (MotorC == 6) { //ré
Serial2.println("S");
Serial.println("S");
} else if (MotorC == 7) { //direita
Serial2.println("D");
Serial.println("D");
} else if (MotorC == 8) { //Esquerda
Serial2.println("A");
Serial.println("A");
}
if (Bot[5] == HIGH && AnteBot[5] == LOW) { // sai do modo de execução
MotorC = 0; //desativa o envio de comandos dos motores
select = 0; //finaliza a programação de animações
Rivent = 1; //atualiza as informações do display
Display.update(); //atualiza o display
}
AnteBot[5] = Bot[5];// guarda o estado anterior do botão
if (Pcomand[0] >= 6 ) { //verifica se Pcomand[0] ultrapassou o limite = 6
Pcomand[0] = 0; //faz com que Pcomand[0] seja igual seu limite maximo = 5
Pcomand[1] = Pcomand[1] + 6; //aumenta o valor de Pcomand[1] para alterar uma coluna de palavras(avançar)
if (Pcomand[1] >= 25) { //vefifica se Pcomand[1] ultrapassou seu limite = 25
Pcomand[1] = 0; //guarda em Pcomand[1] o seu limite minimo = 0
Pcomand[0] = 0;
select = 0; //finaliza a programação de animações
}
}
}
}
/*
esquema de 30 linhas para fazer umna animação programável
i = valor que fará as linhas de código subirem ou descerem
comandos:
sem comando: 0
Delay: 1
Servos: 2
Motor: 3
olhos: 4
olhos fechados 5
parametros:
Kin.Time(time); //aumenta de 10 em 10 milisegundos
Kin.Eyes[00] = {nome / tipo};
Kin.Eyes-Closed[00] = {nome / tipo};
Kin.Servo[A][Angulo][velocidade];
Kin.Engine(comando) = {Frente + Direita};
função dos botões
Y = Iniciar / parar animação programada
B = cancelar / voltar
A = Editar / confirmar
X = Testar comando em tempo real
// 0,1 2 3 4 5 6 7 8 9 10,11,12,13,14,15,16,17,18,19, 20,21,22,23,24,25,26,27,28,29
linhas[] = {0,0,0,0,0,0,0,0,0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; linhas que guardarão os comandos comandos
linhas[0] = 0 + i;
linhas[1] = 1 + i;
linhas[2] = 2 + i;
linhas[3] = 3 + i;
linhas[4] = 4 + i;
linhas[5] = 5 + i;
linhas[6] = 6 + i;
*/
}
if (Mode == 2) { //modo de controle dos motores
//enviar comandos de posição default para a echo-kin
Serial.println("10V"); //comando de velocidade dos servos
Serial.println("Tl"); //comando "Trava ligada" usado para limitar o movimento do pescoço impedindo que danifique
Serial.println("150Y"); //comando para eixo Y da cabeça
Serial.println("90X"); //comando para eixo X do pescoço
Serial.println("65H"); //comando para eixo Y do pescoço
while (Mode == 2) {
for (int i = 0; i <= 7; i++) { //criará um laço que se repetirá 8 vezes
Bot[i] = digitalRead(botoes[i]); //Faz a leitura de um botão diferente a cada vez que o laço se repete e guarda em "Bot[]"
if (Bot[i] == HIGH) { //Verifica se o botão do laço atual foi pressionado e envia por serial o botão que foi apertado
// Serial.print("Botao: ");
// Serial.print(i); //Numero do botão é mesmo do laço atual, guardado em " i "
// Serial.println("apertado!");
}
}
int mip1 = analogRead(PtcA); //obtém a leitura do potenciometro "PtcA" e guarda em "mip1"
int mapA = map(mip1, 0, 1023, 0, 511); //mapeia os valores recebidos de "mip1" e guarda em mapA
Map[0] = map(mapA, 0, 511, 0, 255); //Mapeia os valores que foram guardados em "mapA" e guarda em "Map[0]"
int mip2 = analogRead(PtcB); //obtém a leitura do potenciometro "PtcA" e guarda em "mip2"
int mapB = map(mip2, 0, 1023, 0, 511); //mapeia os valores recebidos de "mip2" e guarda em mapB
Map[1] = map(mapB, 0, 511, 0, 255); //Mapeia os valores que foram guardados em "mapA" e guarda em "Map[1]"
if (Rivent == 1) { // permite que o display seja atualizado (usa Rivent para economia de memória)
Display.clrScr(); //limpa o display
Display.setFont(TinyFont); //define a fonte para "Fonte miuda"
Display.print("Servo A", 9, 10); //escreve os servos disponíveis
//Display.print("Servo B", 49, 10); //
Display.print("Servo C", 89, 10); //
Display.drawRect(42, 25, 86, 53); // desenha o bloco da lista
Display.print("Programe:Y", 45, 28); // escreve as opções disponíveis
Display.print("Voltar: B", 45, 34); //
Display.print("Servos: X", 45, 40); //
Display.print("Start_C: A", 45, 46); //
Display.drawLine(9, 17, 9, 20); // desenha barras de carregamento dos servos
Display.drawLine(9, 20, 34, 20); //
//Display.drawLine(49, 17, 49, 20); //
//Display.drawLine(49, 20, 74, 20); //
Display.drawLine(89, 17, 89, 20); //
Display.drawLine(89, 20, 114, 20); //
//22
Charge[0] = map(Map[0], 0, 255, 0, 22); //mapeia o potenciometro do servo A
Charge[2] = map(Map[1], 0, 255, 0, 22); //mapeia o potenciometro do servo C
for (int i = 0; i <= Charge[0]; i++) { // laço que se repete na mesma quantidade de Charge[]
Display.setPixel(11 + i, 18); // desenha a linha de carregamento do servo A
}
for (int i = 0; i <= Charge[2]; i++) { // laço que se repete na mesma quantidade de Charge[]
Display.setPixel(91 + i, 18); // desenha a linha de carregamento do servo C
}
Rivent = 0; //desativa o as impressões de interface
Display.update(); // atualiza o display
}
if (Bot[0] == HIGH && Bot[1] == HIGH) { //frente + direita
Serial2.println("E");
Serial.println("E");
Start_C = 1;
} else if (Bot[0] == HIGH && Bot[3] == HIGH) { //frente + esquerda
Serial2.println("Q");
Serial.println("Q");
Start_C = 1;
} else if (Bot[0] == HIGH) { //frente
Serial2.println("W");
Serial.println("W");
Start_C = 1;
} else if (Bot[2] == HIGH && Bot[1] == HIGH) { //ré + Direita
Serial2.println("C");
Serial.println("C");
Start_C = 1;
} else if (Bot[2] == HIGH && Bot[3] == HIGH) { //ré + esquerda
Serial2.println("Z");
Serial.println("Z");
Start_C = 1;
} else if (Bot[2] == HIGH) { //ré
Serial2.println("S");
Serial.println("S");
Start_C = 1;
} else if (Bot[1] == HIGH) { //direita
Serial2.println("D");
Serial.println("D");
Start_C = 1;
} else if (Bot[3] == HIGH) { //Esquerda
Serial2.println("A");
Serial.println("A");
Start_C = 1;
} else {
Start_C = 0; //comando default, impede que o valor dos potenciometros sejam enviados até que algum botão seja acionado
}
if (Start_C == 1) { //verifica se o botão se segurança foi pressionado
if (Map[1] != Vza) { //verifica se o potenciometro foi movido
Serial2.print(Map[1]); //envia um valor de 0 a 255
Serial2.println("vm"); //escolhe um sentido do motor
Serial.print(Map[1]); //envia um valor de 0 a 255
Serial.println("vm"); //escolhe um sentido do motor
Rivent = 1; //atualiza as informações do display
Vza = Map[1]; //guarda o novo valor do potenciometro em Vza para que o comando não se repita
}
}//start c
if (Map[1] != Vza) { //verifica se o potenciometro foi movido
Rivent = 1; //atualiza as informações do display
Vza = Map[1];
}
if (Map[0] != Vya) { //verifica se o potenciometro foi movido
Rivent = 1; //atualiza as informações do display
Vya = Map[0];
}
if (Bot[4] == HIGH && AnteBot[4] == LOW) { //ativa o modo de programação
Mode = 1; //altera o modo para programador
Rivent = 1; //atualiza as informações do display
Start_C = 0; //desativa o modo de comando simples
}
AnteBot[4] = Bot[4];
if (Bot[5] == HIGH && AnteBot[5] == LOW) { //sai do modo de controle
Rmenu = 0; //reseta o menu ao voltar para ele
Pmenu = 1; //volta para o menu na posição "play"
MenuSelect = 99; //indica ao sistema para voltar ao menu
Pxa = 48; //envia as coordenadas que o cursor deverá estar ao voltar.
Pya = 24; // -
Display.clrScr(); //limpa o display
Display.update(); //atualiza o display
Mode = 0; //faz com que o programa saida do modo de controle dos motores
}
AnteBot[5] = Bot[5];
if (delayBot.repeat()) {
if (Bot[6] == HIGH && AnteBot[6] == LOW) { //Botão de segurança, ativa ou desativa os comandos de controle intantaneamente
Serial2.print(Map[0]); //envia um valor de 0 a 255
Serial2.println("vc"); //escolhe um sentido do motor
Serial.print(Map[0]); //envia um valor de 0 a 255
Serial.println("vc"); //escolhe um sentido do motor
Rivent = 1; //atualiza as informações do display
delayTimeBot.repeatReset();
AnteBot[6] = HIGH;
} else if (Bot[6] == HIGH) { //caso o botão ainda estiver pressionado
if (Bot_at[6] == 1 && delayTimeCm.repeat()) { //verifica se o botão ficou pressionado por tempo suficiente
Mode = 0; //altera o modo de comando
Bot_at[6] = 0; //altera o valor de Bot_at[6] para garantir que o comando não se repita
}
} else {
Bot_at[6] = 0; //altera o valor de Bot_at[6] para garantir que o comando não se repita
}
AnteBot[6] = Bot[6]; //guarda o ultimo estado do botão em AnteBot[]
}
if (delayTimeBot.repeat(1)) { //aguarda o tempo de 1 segundo para enviar o novo comando
Bot_at[6] = 1; //guarda o valor 1 em bot_at[6] para que um novo comando seja enviado
}
/*if (Bot[7] == HIGH && AnteBot[7] == LOW) { //Altera um dos servos a ser controlado
Sv = !Sv;
}
AnteBot[7] = Bot[7];*/
}
}
}
//------------------------------------------------------------//