final project: games console...university of colorado boulder ecen 2020 – applications of embedded...

University of Colorado Boulder

ECEN 2020 – Applications of Embedded Systems

Final Project: Portable Gaming Console

Dhruva Koley

Ruben Vargas

December 12, 2016

Dhruva Koley & Ruben Vargas ECEN 2020 12/12/16

1

Introduction

The purpose of this final project was to collate our knowledge and experience of object-

oriented C programming involving the MSP432 micro-controller and peripheral modules such as

the Boosterpack MKII. The objective of the project was to code and construct a games console

from the MSP432 and the Boosterpack MKII and be able to use the multiple inputs and outputs

provided by the Boosterpack to play a simple dungeon-crawler like game. Furthermore, a form

of logging was utilized in order to provide real-time feedback from both software and hardware.

It is important to understand that the MSP432 Launchpad development board has the

ability to connect to external circuit boards via GPIO (General Input/Output) pins, including that

of the Boosterpack MKII. The combination of these two boards expands the capabilities of the

MSP432 Launchpad. This allows us to use a built-in LCD screen, RGB LEDs, large push

buttons, and a buzzer to provide the needed multi-media I/O needed for a games console.

Figure 1. Displays both pieces of hardware utilized for the final project.

Modules

The project was split up into modules, involving both hardware and software

programming in order to compartmentalize and optimize the work needed to create and modify

said modules. The modules were as follows:


2

Figure 2. Shows the Software/Hardware Flow Diagram.

To further speed up coding, the TI driverlib and grlib library were used. This library allowed us

compress multiple lines of code into a single function and allowed us to utilize the LCD screen

using GPIO instead of using a custom SPI interface. In all modules, a canary function was used

to show if any module failed. This is displayed below:

volatile uint8_t canary = true;

int canary_test(void){

if(canary != true){

return -1;

}

return 0;

}

UART Logging

The first iteration of the logging module involved the use of a microSD shield connected

to the MSP432 LaunchPad via SPI (Serial Peripheral Interface Bus), a synchronous data bus.

There are three wires required for a Master device to communicate with a Slave device. A clock

from the Master device (SCK); A Master-Out Slave-In (MOSI) data wire to transmit data from a

Master to a Slave; and a Master-In Slave-Out (MISO) data wire to transmit data from a Slave to

the Master. This required a SPI interface with the Master device being the MSP432 and the Slave

device being the SparkFun microSD shield.


3

Figure 3. Exhibits the SparkFun microSD Shield

However, the microSD shield required another layer of software interfacing, namely a custom

FAT32 SD card read/write C library to write to a log file stored on a microSD card.

Unfortunately, we were unable to make this work and were forced to use UART via the

microUSB port on the MSP432 to a host computer with a terminal window. By using a custom

printf function in order to streamline transmitting strings of characters, we were able to display

which inputs and outputs were activated. They were also used as flavor text in the game to

provide more of an atmosphere as well as hints as to what to do next.

Figure 3 Visualization of transmitting incrementing bits via SPI


4

By further modifying the printf function, we were able to blink a red status LED every

time a printf function was called. That way, if the MSP432 was disconnected from a host

computer, we would be able to see some form of logging. In order to test UART capabilities the

following function was used:

int UART_TEST(void) {

canary_test();

/* Initialize values to display */

char *s = "printf test";

char c = '!';

int i = -12345;

unsigned u = 4321;

long int l = -123456780;

long unsigned n = 1098765432;

unsigned x = 0xABCD;

printf(EUSCI_A0_BASE, "...UART_TEST_START...\r\n");

printf(EUSCI_A0_BASE, "String %s\r\n", s);

printf(EUSCI_A0_BASE, "Char %c\r\n", c);

printf(EUSCI_A0_BASE, "Integer %i\r\n", i);

printf(EUSCI_A0_BASE, "Unsigned %u\r\n", u);

printf(EUSCI_A0_BASE, "Long %l\r\n", l);

printf(EUSCI_A0_BASE, "uNsigned loNg %n\r\n", n);

printf(EUSCI_A0_BASE, "heX %x\r\n", x);

printf(EUSCI_A0_BASE, "...UART_TEST_END...\r\n");

return 0;

}

Figure 4 UART log of the bootloader


5

Buzzer

The Boosterpack MKII has a built-in buzzer that operates on Pulse Width Modulation

(PWM) to create sounds at different frequencies. By modifying the duty cycle, you can change

the frequency of the sound. In order to create a tune, the us use of an if loop nested in a while

loop with an incrementing integer, that when it reaches a set integer, will break out of the while

loop. Inside the while loop are for loops (two per note) that have different duty cycles that toggle

the pin for the buzzer. The following code shows an example of a tune created in which

whenever the player shot a blaster, the sound effect would play:

int play_shoot() {

canary_test1();

printf(EUSCI_A0_BASE, "SHOOT_TUNE_START\r\n");

volatile uint16_t a2 = 0;

volatile uint16_t b2 = 0;

volatile uint16_t c2 = 0;

while (1) {

c2++;

if (c2 == 35) {

break;

}

for (a2 = 0; a2 < 1600; a2++);

GPIO_toggleOutputOnPin(GPIO_PORT_P2, GPIO_PIN7);

for (b2 = 0; b2 < 1400; b2++);


}

printf(EUSCI_A0_BASE, "SHOOT_TUNE_END\r\n");

return 0;

}

For one chord, three volatile unsigned 16-bit integers set to equal 0 were used. One for the

duration of the note and two for the two notes. The usage of two notes instead of one was due to

the increased perception of a melodious sound compared to one note. Three notes for a

traditional chord were eschewed due to a focus to reduce the load on processing time and code

size.

LCD Screen

Bitmap images were used to add more dimension to the game, allowing for complex

shapes to be displayed on the LCD screen, other than simple circles and rectangles. This was

done by uploading an image to a Texas Instruments Image Reformer and using the 2 color option

to convert it into a C array of hex values (bitmaps) in the proper structure to be passed into a

grlib library function.


6

Figure 5 Bitmap images converted to two colors and compressed to ≤ 128 pixels by 128 pixels.

The following is a segment of code utilized for outputting the detail rich images onto the LCD

screen:

const tImage Poly1BPP_COMP_RLE4=

{

IMAGE_FMT_1BPP_COMP_RLE4,

84,

84,

2,

palette_Poly1BPP_COMP_RLE4,

pixel_Poly1BPP_COMP_RLE4,

};

LEDs

The LED module was the simplest to code, utilizing only the driverlib library to optimize

coding by utilizing the GPIO functions to enable and toggle pin outputs. For loops nested in a

while loop (much like the structures used in the buzzer module) were used to blink the LEDs.

The following is the code used to configure the LED outputs.

int LED_START(void){

canary_test2();

GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN6);

GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6);












7

printf(EUSCI_A0_BASE, "LED_MODULE_ENABLED\r\n");

printf(EUSCI_A0_BASE, "LED_MODULE_OK\r\n...\r\n");

LED_TEST();

return 0;

}

Buttons/Game Design

For every game, there must be some aspect of control that are both simplistic and easy enough for the user to understand. We made use of the buttons used within the Educational

Boosterpack MKII. Originally, we wanted to design a game where the player had direct control

of a square. The player would utilize the joystick to move the square freely across the screen.

Essentially, the object of this game would have been to collect objects on screen, such as coins or

diamonds. We actually configured the joystick to perform this specific action. This code can be

seen below:

#ifdef Joy_Stick

//Code to Configure the JoyStick

signed int X_Value;

signed int Y_Value;

void configure_ADC() {

P6DIR &= ~BIT0; //X-Axis configured as input

P4DIR &= ~BIT4;//Y-Axis configured as input

P4SEL0 |= BIT4;// Set Pin 4.4 into Tertiary Mode



P6SEL1 |= BIT0;// Set Pin 6.0 into Tertiary Mode // Initialize the shared

reference module

REFCTL0 |= REFVSEL_0 | REFON;// Enable internal 1.2V reference

ADC14->CTL0 |= ADC14_CTL0_MSC | ADC14_CTL0_CONSEQ_1 | ADC14_CTL0_SHT0_5 |

ADC14_CTL0_ON | ADC14_CTL0_SHP;

ADC14->CTL1 |= ADC14_CTL1_RES_0;// Sets Joystick Resolution

ADC14->MCTL[0] = ADC14_MCTLN_INCH_9;//Y-Axis Mapped Channel

ADC14->MCTL[1] = ADC14_MCTLN_INCH_15 | ADC14_MCTLN_EOS;//X-Axis Mapped

Channel

ADC14->IER0 = ADC14_IER0_IE0 | ADC14_IER0_IE1;//Enable MCTL0/MEM0

Interrupts

while(!(REFCTL0 & REFGENRDY));// Wait for reference generator to settle

ADC14->CTL0 |= ADC14_CTL0_ENC;// Enable Conversions

NVIC_EnableIRQ(ADC14_IRQn);

} uint8_t sdata[];

void ADC14_IRQHandler() {

if (ADC14->IFGR0 & ADC14_IFGR0_IFG0) {

Y_Value = ADC14->MEM[0];

}

if(ADC14->IFGR0 & ADC14_IFGR0_IFG1) {

X_Value = ADC14->MEM[1];

} if(X_Value >= 8200 && Y_Value >= 8200 ) { //UR

uart_putchar(0x55);


8

uart_putchar(0x52);

}

if(X_Value < 8200 && Y_Value >= 8200 ) { //UL

uart_putchar(0x55);

uart_putchar(0x4C);

}

if(X_Value > 8200 && Y_Value < 8200 ) { //DR

uart_putchar(0x44);

uart_putchar(0x52);

}

if(X_Value < 8100 && Y_Value < 8100 ) { //DL

uart_putchar(0x44);

uart_putchar(0x4C);

}

}

The manner in which this would work is that the player would start at the center of the LCD

display. If the player wanted to move upwards, the values of x and y would be recorded and a

frame would be outputted onto the LCD screen of the square moving slightly upwards. We

essentially created table with four quadrants. The center was defined as the coordinate (8192,

8192). There would be a range in which if the values fell between a given interval, the player

would move up. There were four possible directions in which the player could move: up, down,

right, and left. All other directions were excluded for the purposes of accuracy.

Figure 6. Exhibits the X and Y coordinate system of the Joystick. It shows the planned possible

directions for the direct control of the movement of a pixelated square (our main character).


9

The problem with this was that the refresh rate was too slow and the movement of the square was

not fluid. Therefore, if we wanted to move the square upwards, there would be a series of frames

that performed this given action. Based on the values detected on the joystick, the square would

move up and one frame would be outputted for a given x and y coordinate. Not only did this

require multiple frames, but the rate in which the transition upward would occur was too clunky

and too slow. Transitions were not fluid and were often disjointed. The other problem with using

the joystick was the fact that it was difficult for it to be precise. Since we depended on its ability

to read and record its location using x and y values, these values would often fluctuate and not be

stable enough. This would cause the unintentional transition to other frames. Therefore, we

ended up scrapping that idea in favor of something more simplistic. We ended up developing a

sort of dungeon crawler where you would transition from screen to screen, gather new abilities,

solve puzzle elements, and give the player the opportunity to choose their own adventure and

outcome. Therefore, the use of the joystick in this new game was scrapped.

With that being said, we configured the buttons on the Boosterpack MKII and defined

each of them to perform a certain action. The code for the button configurations can be found at

the end of the lab report. Basically, what we ended up doing was having each button handle

different operations through the use of button handlers. In order to transition from screen to

screen, we also made use of counters. Therefore, every time a button would be pressed, the

button counter incremented. This made it possible to transition to different screen in the game.

We broke down the function of each button. The START button would be responsible

from transitioning from screen to screen. Button A allowed you to shoot. Button B allowed you

to perform a special attack. Button C also allowed you to perform a special attack different from

that of B. The SELECT button was another transitional button that we used to go from screen to

screen. The only difference is that this button would allow you to access an alternate path for the

game. We also implanted the RESET button to start the game all over. We also programmed our

game such that it would only allow the player to perform a certain action based upon the current

screen. In this manner, we incorporated certain puzzle elements in which you would have to

press certain buttons to continue on to the next screen.

Figure 7. Exhibits the button layout of our game console. Note that Button C is the button

directly attached to the joystick. Thus, by pressing the joystick, you press Button C. Also, the


10

START and SELECT buttons are located behind the Boosterpack MKII and are attached directly

to the MSP432 microcontroller.

In addition to the multiple screens created for the game, we wanted to make our game as

interactive as possible using the features of the Boosterpack MKII. We did this by incorporating

sounds using the buzzer, adding LED effects for certain screens or whenever an action button

was pressed (A, B, or C), and by incorporating more detailed images into the LCD screens.

Because we used the graphics library for the LCD display pretty heavily, it is important to

mention that it made the creation of rectangles and circles pretty easy. We were also able to

manipulate the color of both the background and the foreground pretty easily. Because of

technical limitations and our ability to easily create rectangles, we made our main character a

square. Any shape that was not a perfect square in the game would be known as an “Imperfect

Polygon”. These were made to be the enemies in game. With that being said, we created custom

images that gave more life to our game. These were centered around simple shapes such as

squares and rectangles.

Figure 8. Shows the cast of characters used in the game. These images were translated into

bitmaps and then converted to C bit arrays.

We found that if we utilized monochrome images, they would load up faster on the LCD

display. Hence, we only used images that consisted of one color. Also, images with less detail

had faster load times onto the screen.

External Power Supply

In addition to using the MSP432 microcontroller and the Educational Boosterpack MKII,

we also utilized an external Lithium ion battery pack to add a portability factor to our gaming

console. We also used a LiPo charger to charge the battery via a USB cable. We attached the

wires of the battery pack to the ground and 5 V pins on the MSP432 microcontroller. In this way,

we were able to take the game console anywhere without it having to be attached to a computer.


11

Figure 9. Shows the lithium ion battery pack attached to the pack of the MSP432 with the

Educational Boosterpack MKII.

Results

The game we chose to develop consisted of sound effects, LED effects, interrupts using

the buttons on the Boosterpack MKII, and about 50 different screens outputted on the LCD

display. The screens we developed varied in graphical complexity. The ones with more graphical

complexity took longer to load up. Therefore, only a small portion of our screens consisted of

more complex graphics. This was done to speed up the gameplay and to develop the screens at

an accelerated rate. The screens, along with some of its other interactions with the board are

shown in the figures below.

Figure 10. Shows the title screen of our game.


12

Figure 11. Shows game screens with less graphical complexity.

Figure 12. Shows game screens with more graphical complexity.

Figure 13. Shows game screens with the most graphical complexity.


13

Figure 14. Displays the LEDs activated on the MSP432 board. The red LED was activated every

time the START button was pressed. The green LED was activated every time the SELECT button

was pressed. These LEDs would also indicate that the logging for a specific action was

completed and printed out on the terminal via UART.

Figure 15. Exhibits the reaction every time button A was pressed. A blue LED would light up to

indicate that the player has selected the “Shoot” ability. Additionally, a unique “shooting”

sound effect would be outputted via the buzzer when button A was pressed.

Figure 16. Exhibits the reaction every time button B was pressed. A red LED would light up to

indicate that the player has selected the “Special” ability. Additionally, a unique “Special”

sound effect would be outputted via the buzzer when button B was pressed.


14

Figure 17. Exhibits the reaction every time button C was pressed. A purple LED would light up

to indicate that the player has selected the second “Special” ability. Additionally, a unique

“Special” sound effect would be outputted via the buzzer when button C was pressed.

Figure 18. Exhibits the final boss of the game. In addition to outputting a tune via the buzzer

whenever the boss appeared, a green LED would blink to signify the presence of the boss. The

LED effect adds to the interactivity of the game.

Figure 19. Shows the slide in which the player has the option to select the route they want to

take.


15

Figure 20. Exhibits the two possible outcomes of the games. The screen of the left is the result of

going through the START route. The screen to the right is the result of choosing the SELECT

route.

Figure 21. Shows the final screen of the game.

Conclusion

Overall, our objective to create a game console was met with success. Though we did not

make use of the joystick to move a pixel around as we originally intended, we managed to make

a game that used the features of the Boosterpack MKII. Additionally, the concepts of embedded

design were applied to this project. We had to think about the purpose of our system, the

hardware required, and the software component required to make it work. Essentially, we

synthesized all of the things that we learned in class and from previous labs such as the concept

of interrupts, timers, and serial communication, to build a functional system. Along the way, we

also learned more about special libraries that included functions to output graphics onto the LCD

display. We learned more about sound production using PWM and how to generate more

detailed images using C bit arrays. In terms of the difficulty of the project, we found that the

most difficult thing to do was getting the individual features of the Boosterpack MKII to act in

our desired manner. Therefore, configuring the LEDs, the buttons, and the buzzer, were the most

difficult things to accomplish. Not only configuring them, but handling them was difficult at the


16

beginning. We had to modify the code various times to get them to work properly. This portion

of the project was perhaps the most time consuming. Once we figured that out and configured

each piece of our hardware to behave in our desired manner, we went on to the actual design of

the game. After developing our own graphics library, our buzzer library, and our buttons library,

the actual game design stage of our project accounted for about 40% of our total time. Again, we

wanted to make the game as interactive as possible using the features of the Boosterpack MKII.

Thus, we used the LEDs, the buzzer, and provided detailed images from time to time, to add to

the overall game experience. In conclusion, the development and the execution of our final

project contributed to our overall understanding of what it takes to build and embedded system.

Appendix

The following code was used to set up UART communication. This code was essential for

logging:

#ifndef UART_UART_LOG_H_

#define UART_UART_LOG_H_ /* Standard Includes */

#include

#include

#include

#include "../uart/printf.h" volatile uint8_t canary = true; int canary_test(void){

if(canary != true){

return -1;

}

return 0;

} int configure_clocks(void) {

canary_test();

CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_3);

return 0;

/*CS->KEY = 0x695A;

CS->CTL0 = 0;

CS->CTL0 = 0x1000; //BITS 16-18 0b001 @ 3MHz // Select ACLK = REFO, SMCLK = MCLK = DCO

CS->CTL1 = CS_CTL1_SELA_2 | CS_CTL1_SELS_3 | CS_CTL1_SELM_3;

CS->KEY = 0;*/

} int configure_serial_port() {

canary_test();

// Port Op Mode Config

GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN1 |

GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION); //Frame Config

UCA0CTLW0 |= UCSWRST;

UCA0CTLW0 |= BIT7; //SMCLK, 8N1, LSB


17

UCA0BR0 = 0x1A; //115200 baud 0-8 bits

UCA0BR1 = 0x00; //115200 baud N = 3MHz/115200 = ~26

UCA0MCTLW = 0xF0;// Set first stage modulator bits (necessary as N>16)

BITS 7-4

UCA0CTLW0 &= ~UCSWRST; //Initialize eUSCI

UCA0IE |= UCRXIE; //Enable Rx NVIC->ISER[0] = 1


18

/*

* printf library for the MSP432

*

* Largely taken from and inspired from:

* http://www.msp430launchpad.com/2012/06/using-printf.html

* http://www.43oh.com/forum/viewtopic.php?f=10&t=1732

*

* See http://www.samlewis.me for an example implementation.

*/ #include "stdarg.h"

#include

#include "driverlib.h"

#include "led.h" void sendByte(uint32_t moduleInstance, char c)

{

UART_transmitData(moduleInstance, c);

} static const unsigned long dv[] = {

1000000000,// +0

100000000, // +1

10000000, // +2

1000000, // +3

100000, // +4

10000, // +5

1000, // +6

100, // +7

10, // +8

1, // +9

}; void puts(uint32_t moduleInstance, char *s) {

char c; while (c = *s++) {

sendByte(moduleInstance, c);

}

} void putc(uint32_t moduleInstance, unsigned b) {

sendByte(moduleInstance, b);

} static void xtoa(uint32_t moduleInstance, unsigned long x, const unsigned long

*dp) {

char c;

unsigned long d;

if (x) {

while (x < *dp)

++dp;

do {

d = *dp++;

c = '0';

while (x >= d)

++c, x -= d;


19

putc(moduleInstance, c);

} while (!(d & 1));

} else

putc(moduleInstance, '0');

} static void puth(uint32_t moduleInstance, unsigned n) {

static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',

'9', 'A', 'B', 'C', 'D', 'E', 'F' };

putc(moduleInstance, hex[n & 15]);

} void printf(uint32_t moduleInstance, char *format, ...)

{

char c;

int i;

long n; va_list a;

va_start(a, format);

while(c = *format++) {

if(c == '%') {

switch(c = *format++) {

case 's': // String

puts(moduleInstance, va_arg(a, char*));

break;

case 'c':// Char

putc(moduleInstance, va_arg(a, char));

break;

case 'i':// 16 bit Integer

case 'u':// 16 bit Unsigned

i = va_arg(a, int);

if(c == 'i' && i < 0) i = -i, putc(moduleInstance, '-');

xtoa(moduleInstance, (unsigned)i, dv + 5);

break;

case 'l':// 32 bit Long

case 'n':// 32 bit uNsigned loNg

n = va_arg(a, long);

if(c == 'l' && n < 0) n = -n, putc(moduleInstance, '-');

xtoa(moduleInstance, (unsigned long)n, dv);

break;

case 'x':// 16 bit heXadecimal

i = va_arg(a, int);

puth(moduleInstance, i >> 12);



puth(moduleInstance, i);

break;

case 0: return;

default: goto bad_fmt;

}

} else

bad_fmt: putc(moduleInstance, c);

}

va_end(a);

debug_led();

}


20

This is how the printf function was defined within its own header file:

#ifndef PRINTF_H_

#define PRINTF_H_

void printf(uint32_t moduleInstance, char *, ...);

#endif /* PRINTF_H_ */

The following code configures the LEDs on the MSP432:

#ifndef LED_LED_H_

#define LED_LED_H_ #include "driverlib.h"

#include "msp.h" void debug_led(void) {

volatile uint32_t xx = 0;

volatile uint32_t x = 0;

/* Configuring P1.0 as output */


while (1) {

x++;

if(x == 5){

break;

}

/* Delay Loop */

for (xx = 0; xx < 500; xx++) {

}


}

} #endif /* LED_LED_H_ */

The following code configures the RGB LED on the Boosterpack MKII:

#ifndef LED_LED_MAIN_H_

#define LED_LED_MAIN_H_ #include "driverlib.h"

#include "msp.h"

#include "uart_log.h" volatile uint8_t canary2 = true; int canary_test2(void){

if(canary2 != true){

printf(EUSCI_A0_BASE, "LED_ERROR\r\n");

return -1;

}

return 0;

} int LED_TEST(void) {


21

canary_test2();

volatile uint32_t xx = 0;

volatile uint32_t x = 0;

volatile uint32_t yy = 0;

volatile uint32_t y = 0;

volatile uint32_t zz = 0;

volatile uint32_t z = 0;

/* Configuring Main Board as output */

while (1) {

x++;

if(x == 5){

break;

}

/* Delay Loop */

for (xx = 0; xx < 500; xx++) {

}


}

while (1) {

y++;

if(y == 5){

break;

}

/* Delay Loop */

for (yy = 0; yy < 500; yy++) {

}


}

while (1) {

z++;

if(z == 5){

break;

}

/* Delay Loop */

for (zz = 0; zz < 500; zz++) {

}


}

volatile uint32_t xx1 = 0;

volatile uint32_t x1 = 0;

volatile uint32_t yy1 = 0;

volatile uint32_t y1 = 0;

volatile uint32_t zz1 = 0;

volatile uint32_t z1 = 0;

/* Configuring EduBMkII Board as output */

while (1) {

x1++;

if(x1 == 5){

break;

}

/* Delay Loop */

for (xx1 = 0; xx1 < 500; xx1++) {

}


}

while (1) {

y1++;


22

if(y1 == 5){

break;

}

/* Delay Loop */

for (yy1 = 0; yy1 < 500; yy1++) {

}


}

while (1) {

z1++;

if(z1 == 5){

break;

}

/* Delay Loop */

for (zz1 = 0; zz1 < 500; zz1++) {

}


}

return 0;

} int LED_START(void){

canary_test2();






GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN6); GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN0);





GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN2); printf(EUSCI_A0_BASE, "LED_MODULE_ENABLED\r\n");

printf(EUSCI_A0_BASE, "LED_MODULE_OK\r\n...\r\n");

LED_TEST();

return 0;

} #endif /* LED_LED_MAIN_H_ */

The following code is responsible for producing the images in our game. It specifies the

dimensions of the rectangles used as well as the more detailed images of our game using bit

arrays:

// The following code includes all of the graphics for our game

#ifndef IMAGES_H_

#define IMAGES_H_ #include


23

#include

#include

#include "uart_log.h"

#include Graphics_Context g_sContext;

Graphics_Display g_sDisplay;

Graphics_Rectangle g_sRectangle;

Graphics_Image g_sImage; const Graphics_Rectangle R1 = //Main screen rectangle (Poly the Blue Square)

{

44, //!< The minimum X coordinate of the rectangle.

44, //!< The minimum Y coordinate of the rectangle.

84, //!< The maximum X coordinate of the rectangle.

84 //!< The maximum Y coordinate of the rectangle.

}; const Graphics_Rectangle R2 = //Imperfect Polygon #1

{





}; const Graphics_Rectangle R3 = //Pixi Power_Up

{





}; const Graphics_Rectangle R4 =

{






{






{





};


24

const Graphics_Rectangle R7 =

{






{





}; const Graphics_Rectangle Stream =

{





}; const Graphics_Rectangle Bridge1 =

{





}; const Graphics_Rectangle Bridge2 =

{





}; const Graphics_Rectangle ARMY1 =

{






{





};


25

const Graphics_Rectangle ARMY3 =

{






{





}; const Graphics_Rectangle Wall =

{






{






{






{






{





};


26

const Graphics_Rectangle R13 =

{






{






{






{






{





}; const Graphics_Rectangle Guard_1 =

{





}; const Graphics_Rectangle Guard_2 =

{





}; const Graphics_Rectangle Ledge_1 =


27

{






{






{





}; const Graphics_Rectangle Pyramid_1 =

{






{






{






{






{


28






{





}; static const unsigned char pixel_Clone1BPP_COMP_RLE4[] =

{

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x51, 0x20, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x01,

0x20, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x01, 0x20, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0x01, 0x20, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x01, 0x20, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0x01, 0x20, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x01, 0x20, 0xf1, 0xf1, 0xf1,

0xe1, 0x30, 0xa1, 0x90, 0x61, 0x30, 0xf1, 0xf1, 0xf1, 0x30, 0xa1, 0x90, 0x61,

0x30, 0xf1, 0xf1, 0xf1, 0x30, 0xa1,

0x90, 0x61, 0x30, 0xf1, 0xf1, 0xf1, 0x60, 0x31, 0xd0, 0x31, 0x60, 0xd1, 0x20,

0xf1, 0xe1, 0x60, 0x31, 0xd0, 0x31, 0x60, 0xd1, 0x20, 0xf1, 0xe1, 0x60, 0x31,

0xd0, 0x31, 0x60, 0xd1, 0x20, 0xf1, 0xe1, 0x60, 0x31, 0xd0, 0x31, 0x60, 0xd1,

0x20, 0xf1, 0xe1, 0xf0, 0xf0, 0x30, 0xd1, 0x20, 0xf1, 0xe1, 0xf0, 0xf0, 0x30,

0xd1, 0x20, 0xf1, 0xe1, 0xf0, 0xf0, 0x30, 0xd1, 0x20, 0xf1, 0xe1, 0xf0, 0xf0,

0x30, 0xd1, 0x60, 0xf1, 0xa1, 0xf0, 0xf0, 0x30, 0xd1, 0x60, 0xf1, 0xa1, 0xf0,

0xf0, 0x30, 0xd1, 0x60, 0xf1, 0x71,

0x60, 0xa1, 0x50, 0x71, 0x90, 0x61, 0xa0, 0xf1, 0x71, 0x60, 0xa1, 0x50, 0x71,

0x90, 0x61, 0xa0, 0xf1, 0x71, 0x60, 0xa1, 0x50, 0x71, 0x90, 0x61, 0xa0, 0xf1,

0x71, 0x60, 0xa1, 0x50, 0x71, 0x90, 0x61, 0xa0, 0xf1, 0x71, 0x20, 0x31, 0xa0,

0x21, 0xa0, 0x21, 0x60, 0xf1, 0xf1, 0x91, 0x20, 0x31, 0xa0, 0x21, 0xa0, 0x21,

0x60, 0xf1, 0xf1, 0x91, 0x20, 0x31, 0xa0, 0x21, 0xa0, 0x21, 0x60, 0xf1, 0xf1,

0x91, 0x90, 0x71, 0x50, 0x71, 0x90, 0xa1, 0x60, 0xf1, 0x71, 0x90, 0x71, 0x50,

0x71, 0x90, 0xa1, 0x60, 0xf1, 0x71,

0x90, 0x71, 0x50, 0x71, 0x90, 0xa1, 0x60, 0xf1, 0x71, 0x90, 0x71, 0x50, 0x71,

0x90, 0xa1, 0x60, 0xf1, 0x71, 0x90, 0x71, 0x50, 0x71, 0x90, 0xa1, 0x60, 0xf1,

0x71, 0x90, 0x71, 0x50, 0x71, 0x90, 0xa1, 0x60, 0xf1, 0x71, 0x90, 0x71, 0x50,

0x71, 0x90, 0xa1, 0x60, 0xf1, 0x71, 0x90, 0x31, 0x90, 0x31, 0xd0, 0x61, 0xa0,

0xf1, 0x71, 0x90, 0x31, 0x90, 0x31, 0xd0, 0x61, 0xa0, 0xf1, 0x71, 0x90, 0x31,

0x90, 0x31, 0xd0, 0x61, 0xa0, 0xf1, 0x01, 0x20, 0x31, 0xf0, 0xf0, 0x90, 0x31,

0x90, 0xf1, 0x41, 0x20, 0x31, 0xf0,

0xf0, 0x90, 0x31, 0x90, 0xf1, 0x41, 0x20, 0x31, 0xf0, 0xf0, 0x90, 0x31, 0x90,

0xf1, 0x41, 0x20, 0x31, 0xf0, 0xf0, 0x90, 0x31, 0x90, 0xf1, 0x01, 0x60, 0x31,

0xf0, 0x40, 0x61, 0xd0, 0x31, 0x60, 0xf1, 0x31, 0x60, 0x31, 0xf0, 0x40, 0x61,

0xd0, 0x31, 0x60, 0xf1, 0x31, 0x60, 0x31, 0xf0, 0x40, 0x61, 0xd0, 0x31, 0x60,

0xf1, 0x01, 0x90, 0x31, 0x90, 0x71, 0xf0, 0x70, 0xf1, 0xb1, 0x90, 0x31, 0x90,

0x71, 0xf0, 0x70, 0xf1, 0xb1, 0x90, 0x31, 0x90, 0x71, 0xf0, 0x70, 0xf1, 0xb1,

0x60, 0x61, 0x60, 0xf1, 0x81, 0x90,

0xf1, 0xb1, 0x60, 0x61, 0x60, 0xf1, 0x81, 0x90, 0xf1, 0xb1, 0x60, 0x61, 0x60,

0xf1, 0x81, 0x90, 0xf1, 0xb1, 0x60, 0x61, 0x60, 0xf1, 0x81, 0x90, 0xf1, 0xb1,

0x90, 0x31, 0x60, 0x21, 0xf0, 0x10, 0x31, 0x90, 0xf1, 0xb1, 0x90, 0x31, 0x60,

0x21, 0xf0, 0x10, 0x31, 0x90, 0xf1, 0xb1, 0x90, 0x31, 0x60, 0x21, 0xf0, 0x10,

0x31, 0x90, 0xf1, 0xe1, 0x60, 0x31, 0x90, 0x31, 0xd0, 0x31, 0x90, 0xf1, 0xe1,


29

0x60, 0x31, 0x90, 0x31, 0xd0, 0x31, 0x90, 0xf1, 0xe1, 0x60, 0x31, 0x90, 0x31,

0xd0, 0x31, 0x90, 0xf1, 0xe1, 0x60,

0x31, 0x90, 0x31, 0xd0, 0x31, 0x90, 0xf1, 0xf1, 0x91, 0x90, 0xf1, 0x11, 0xd0,

0xf1, 0xf1, 0x91, 0x90, 0xf1, 0x11, 0xd0, 0xf1, 0xf1, 0x91, 0x90, 0xf1, 0x11,

0xd0, 0xf1, 0xf1, 0x91, 0xf0, 0xf0, 0x90, 0xf1, 0xf1, 0x91, 0xf0, 0xf0, 0x90,

0xf1, 0xf1, 0x91, 0xf0, 0xf0, 0x90, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,


0xf1, 0xf1, 0xf1, 0xf1, 0x31, 0xa0, 0x21, 0xa0, 0xf1, 0xf1, 0xf1, 0xa1, 0xa0,

0x21, 0xa0, 0xf1, 0xf1, 0xf1, 0xa1,

0xa0, 0x21, 0xa0, 0xf1, 0xf1, 0xf1, 0x31, 0xf0, 0x10, 0x21, 0xf0, 0x10, 0xf1,

0xf1, 0xc1, 0xf0, 0x10, 0x21, 0xf0, 0x10, 0xf1, 0xf1, 0xc1, 0xf0, 0x10, 0x21,

0xf0, 0x10, 0xf1, 0xf1, 0xc1, 0xf0, 0x10, 0x21, 0xf0, 0x10, 0xf1, 0xf1, 0xc1,

0xf0, 0x10, 0x21, 0xf0, 0x10, 0xf1, 0xf1, 0xc1, 0xf0, 0x10, 0x21, 0xf0, 0x10,

0xf1, 0xf1, 0xc1, 0xf0, 0x10, 0x21, 0xf0, 0x10, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x81,

}; static const unsigned long palette_Clone1BPP_COMP_RLE4[] =

{

0xFFFF00, 0xFFFFFF

}; const tImage Clone1BPP_COMP_RLE4 =

{


84,

84,

2,

palette_Clone1BPP_COMP_RLE4,

pixel_Clone1BPP_COMP_RLE4,

}; static const unsigned char pixel_Fairy1BPP_COMP_RLE4[] =

{






0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x40, 0xf1,

0xb1, 0xf0, 0x50, 0xf1, 0xb1, 0x50, 0xf1, 0xe1, 0x40, 0xf1, 0xb1, 0xf0, 0x50,

0xf1, 0xb1, 0x50, 0xf1, 0xe1, 0x40, 0xf1, 0xb1, 0xf0, 0x50, 0xf1, 0xb1, 0x50,

0xf1, 0xe1, 0x40, 0xf1, 0xb1, 0xf0, 0x50, 0xf1, 0xb1, 0x50, 0xf1, 0xe1, 0x40,

0xf1, 0xb1, 0xf0,

0x50, 0xf1, 0xb1, 0x50, 0xf1, 0x81, 0x50, 0x41, 0x50, 0xf1, 0xf0, 0xf0, 0x10,

0xf1, 0x01, 0x40, 0x51, 0x40, 0xf1, 0x31, 0x50, 0x41, 0x50, 0xf1, 0xf0, 0xf0,

0x10, 0xf1, 0x01, 0x40, 0x51, 0x40, 0xf1, 0x31, 0x50, 0x41, 0x50, 0xf1, 0xf0,

0xf0, 0x10, 0xf1, 0x01, 0x40, 0x51, 0x40, 0xf1, 0x31, 0x50, 0x41, 0x50, 0xf1,

0xf0, 0xf0, 0x10, 0xf1, 0x01, 0x40, 0x51, 0x40, 0xf1, 0x31, 0x50, 0x41, 0x50,

0xf1, 0xf0, 0xf0, 0x10, 0xf1, 0x01, 0x40, 0x51, 0x40, 0xf1, 0x31, 0x50, 0x41,

0x50, 0xf1, 0xf0, 0xf0, 0x10, 0xf1, 0x01, 0x40, 0x51, 0x40, 0xe1, 0x40, 0x51,

0x40, 0x51, 0x40, 0x51, 0xa0, 0x51, 0xa0, 0x41, 0xb0, 0x41, 0x50, 0x41, 0x50,

0x41, 0x50, 0x81, 0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0x51, 0xa0, 0x41,

0xb0, 0x41, 0x50,

0x41, 0x50, 0x41, 0x50, 0x81, 0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0x51,

0xa0, 0x41, 0xb0, 0x41, 0x50, 0x41, 0x50, 0x41, 0x50, 0x81, 0x40, 0x51, 0x40,

0x51, 0x40, 0x51, 0xa0, 0x51, 0xa0, 0x41, 0xb0, 0x41, 0x50, 0x41, 0x50, 0x41,


30

0x50, 0x81, 0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0x51, 0xa0, 0x41, 0xb0,

0x41, 0x50, 0x41, 0x50, 0x41, 0x50, 0x81, 0x40, 0x51, 0x40, 0x51, 0x40, 0x51,

0xa0, 0x51, 0xa0, 0x41, 0xb0, 0x41, 0x50, 0x41, 0x50, 0x41, 0x50, 0x81, 0xa0,

0x41, 0x50, 0x41, 0xf0, 0xf0, 0xf0, 0x70, 0x51, 0x40, 0x51, 0xa0, 0x81, 0xa0,



0x41, 0x50, 0x41,

0xf0, 0xf0, 0xf0, 0x70, 0x51, 0x40, 0x51, 0xa0, 0x81, 0xa0, 0x41, 0x50, 0x41,

0xf0, 0xf0, 0xf0, 0x70, 0x51, 0x40, 0x51, 0xa0, 0xd1, 0xf0, 0xf0, 0x60, 0x51,

0xa0, 0x41, 0xf0, 0xf0, 0x60, 0xf1, 0x31, 0xf0, 0xf0, 0x60, 0x51, 0xa0, 0x41,

0xf0, 0xf0, 0x60, 0xf1, 0x31, 0xf0, 0xf0, 0x60, 0x51, 0xa0, 0x41, 0xf0, 0xf0,

0x60, 0xf1, 0x31, 0xf0, 0xf0, 0x60, 0x51, 0xa0, 0x41, 0xf0, 0xf0, 0x60, 0xf1,

0x31, 0xf0, 0xf0, 0x60, 0x51, 0xa0, 0x41, 0xf0, 0xf0, 0x60, 0xf1, 0x31, 0xf0,

0xf0, 0x60, 0x51, 0xa0, 0x41, 0xf0, 0xf0, 0x60, 0xf1, 0x91, 0x40, 0x51, 0xf0,

0x50, 0x51, 0xa0, 0x41, 0xf0, 0x60, 0x41, 0x50, 0xf1, 0xe1, 0x40, 0x51, 0xf0,

0x50, 0x51, 0xa0, 0x41, 0xf0, 0x60, 0x41, 0x50, 0xf1, 0xe1, 0x40, 0x51, 0xf0,

0x50, 0x51, 0xa0,

0x41, 0xf0, 0x60, 0x41, 0x50, 0xf1, 0xe1, 0x40, 0x51, 0xf0, 0x50, 0x51, 0xa0,

0x41, 0xf0, 0x60, 0x41, 0x50, 0xf1, 0xe1, 0x40, 0x51, 0xf0, 0x50, 0x51, 0xa0,

0x41, 0xf0, 0x60, 0x41, 0x50, 0xf1, 0xe1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x80,

0xf1, 0xe1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x80, 0xf1, 0xe1, 0xf0, 0xf0, 0xf0,

0xf0, 0xf0, 0x80, 0xf1, 0xe1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x80, 0xf1, 0xe1,

0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x80, 0xf1, 0xe1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,

0x80, 0xf1, 0x81, 0xa0, 0x51, 0xf0, 0xf0, 0x00, 0xf1, 0x01, 0xf0, 0x00, 0x41,

0xa0, 0xf1, 0x31, 0xa0, 0x51, 0xf0, 0xf0, 0x00, 0xf1, 0x01, 0xf0, 0x00, 0x41,

0xa0, 0xf1, 0x31, 0xa0, 0x51, 0xf0, 0xf0, 0x00, 0xf1, 0x01, 0xf0, 0x00, 0x41,

0xa0, 0xf1, 0x31,

0xa0, 0x51, 0xf0, 0xf0, 0x00, 0xf1, 0x01, 0xf0, 0x00, 0x41, 0xa0, 0xf1, 0x31,

0xa0, 0x51, 0xf0, 0xf0, 0x00, 0xf1, 0x01, 0xf0, 0x00, 0x41, 0xa0, 0xf1, 0x31,

0xf0, 0x00, 0x41, 0xf0, 0xf0, 0xf0, 0x70, 0x51, 0xf0, 0xf1, 0x31, 0xf0, 0x00,

0x41, 0xf0, 0xf0, 0xf0, 0x70, 0x51, 0xf0, 0xf1, 0x31, 0xf0, 0x00, 0x41, 0xf0,

0xf0, 0xf0, 0x70, 0x51, 0xf0, 0xf1, 0x31, 0xf0, 0x00, 0x41, 0xf0, 0xf0, 0xf0,

0x70, 0x51, 0xf0, 0xf1, 0x31, 0xf0, 0x00, 0x41, 0xf0, 0xf0, 0xf0, 0x70, 0x51,

0xf0, 0xf1, 0x31, 0xf0, 0x00, 0x41, 0xf0, 0xf0, 0xf0, 0x70, 0x51, 0xf0, 0xe1,

0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0xf1, 0x51, 0xb0, 0x41, 0x50, 0x41,

0x50, 0x41, 0x50, 0x81, 0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0xf1, 0x51,

0xb0, 0x41, 0x50,

0x41, 0x50, 0x41, 0x50, 0x81, 0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0xf1,

0x51, 0xb0, 0x41, 0x50, 0x41, 0x50, 0x41, 0x50, 0x81, 0x40, 0x51, 0x40, 0x51,

0x40, 0x51, 0xa0, 0xf1, 0x51, 0xb0, 0x41, 0x50, 0x41, 0x50, 0x41, 0x50, 0x81,

0x40, 0x51, 0x40, 0x51, 0x40, 0x51, 0xa0, 0xf1, 0x51, 0xb0, 0x41, 0x50, 0x41,

0x50, 0x41, 0x50, 0x81, 0xa0, 0x41, 0x50, 0xf1, 0xf0, 0xf0, 0x10, 0xf1, 0x01,

0x40, 0x51, 0xa0, 0x81, 0xa0, 0x41, 0x50, 0xf1, 0xf0, 0xf0, 0x10, 0xf1, 0x01,




0x40, 0x51, 0xa0,

0x81, 0xa0, 0x41, 0x50, 0xf1, 0x01, 0xf0, 0xf0, 0x00, 0xf1, 0x01, 0x40, 0x51,

0xa0, 0xd1, 0xa0, 0xf1, 0xb1, 0xf0, 0x50, 0xf1, 0xb1, 0xa0, 0xf1, 0x31, 0xa0,

0xf1, 0xb1, 0xf0, 0x50, 0xf1, 0xb1, 0xa0, 0xf1, 0x31, 0xa0, 0xf1, 0xb1, 0xf0,

0x50, 0xf1, 0xb1, 0xa0, 0xf1, 0x31, 0xa0, 0xf1, 0xb1, 0xf0, 0x50, 0xf1, 0xb1,

0xa0, 0xf1, 0x31, 0xa0, 0xf1, 0xb1, 0xf0, 0x50, 0xf1, 0xb1, 0xa0, 0xf1, 0xf1,





0xf1, 0xf1, 0xf1,


31

0xf1, 0xf1, 0xf1, 0x11,

}; static const unsigned long palette_Fairy1BPP_COMP_RLE4[] =

{

0x800080, 0x000000

}; const tImage Fairy1BPP_COMP_RLE4 =

{


120,

84,

2,

palette_Fairy1BPP_COMP_RLE4,

pixel_Fairy1BPP_COMP_RLE4,

}; static const unsigned char pixel_Orange1BPP_COMP_RLE4[] =

{


0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x91, 0x30, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0xf1, 0xf1, 0xf1,

0xf1, 0xb1, 0x30, 0x31, 0x40, 0xf1, 0xf1, 0xf1, 0xf1, 0x61, 0x30, 0x31, 0x40,

0xf1, 0xf1, 0xf1, 0xf1, 0x61, 0x30, 0x31, 0x40, 0xf1, 0xf1, 0xf1, 0xf1, 0x61,

0x30, 0x31, 0x40, 0xf1, 0xf1, 0xf1,

0xf1, 0x21, 0x30, 0x31, 0x30, 0x41, 0x30, 0xf1, 0xf1, 0xf1, 0xe1, 0x30, 0x31,

0x30, 0x41, 0x30, 0xf1, 0xf1, 0xf1, 0xe1, 0x30, 0x31, 0x30, 0x41, 0x30, 0xf1,

0xf1, 0xf1, 0xe1, 0x30, 0x31, 0x30, 0x41, 0x30, 0xf1, 0xf1, 0xf1, 0xe1, 0x30,

0x31, 0x30, 0x41, 0x30, 0xf1, 0xf1, 0xf1, 0x11, 0xc0, 0x31, 0x30, 0x31, 0x40,

0x31, 0x80, 0xf1, 0xf1, 0x81, 0xc0, 0x31, 0x30, 0x31, 0x40, 0x31, 0x80, 0xf1,

0xf1, 0x81, 0xc0, 0x31, 0x30, 0x31, 0x40, 0x31, 0x80, 0xf1, 0xf1, 0x81, 0xc0,

0x31, 0x30, 0x31, 0x40, 0x31, 0x80,

0xf1, 0xf1, 0x81, 0xc0, 0x31, 0x30, 0x31, 0x40, 0x31, 0x80, 0xf1, 0xf1, 0x81,

0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0,

0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0,

0xa0, 0xf1, 0xf1, 0x81, 0x70, 0x81, 0x70, 0x81, 0x80, 0xf1, 0xf1, 0x81, 0x70,

0x81, 0x70, 0x81, 0x80, 0xf1, 0xf1, 0x81, 0x70, 0x81, 0x70, 0x81, 0x80, 0xf1,

0xf1, 0x81, 0x70, 0x81, 0x70, 0x81, 0x80, 0xf1, 0xb1, 0x30, 0x81, 0x70, 0x41,

0xb0, 0x41, 0xc0, 0xf1, 0xb1, 0x30,

0x81, 0x70, 0x41, 0xb0, 0x41, 0xc0, 0xf1, 0xb1, 0x30, 0x81, 0x70, 0x41, 0xb0,

0x41, 0xc0, 0xf1, 0xb1, 0x30, 0x81, 0x70, 0x41, 0xb0, 0x41, 0xc0, 0xf1, 0xb1,

0x30, 0x81, 0x70, 0x41, 0xb0, 0x41, 0xc0, 0xf1, 0x61, 0x80, 0x81, 0x70, 0x41,

0xb0, 0x41, 0xc0, 0x71, 0x30, 0xa1, 0x80, 0x81, 0x70, 0x41, 0xb0, 0x41, 0xc0,

0x71, 0x30, 0xa1, 0x80, 0x81, 0x70, 0x41, 0xb0, 0x41, 0xc0, 0x71, 0x30, 0xa1,

0x80, 0x81, 0x70, 0x41, 0xb0, 0x41, 0xc0, 0x71, 0x30, 0xa1, 0x80, 0x81, 0x70,

0x41, 0xb0, 0x41, 0xc0, 0x71, 0x30,

0xa1, 0x80, 0x81, 0xf0, 0xf0, 0xa0, 0x71, 0x80, 0x51, 0x80, 0x81, 0xf0, 0xf0,

0xa0, 0x71, 0x80, 0x51, 0x80, 0x81, 0xf0, 0xf0, 0xa0, 0x71, 0x80, 0x51, 0x80,

0x81, 0xf0, 0xf0, 0xa0, 0x71, 0x80, 0x51, 0x80, 0x81, 0xf0, 0xf0, 0xa0, 0x71,

0x80, 0xa1, 0x70, 0x41, 0xf0, 0x40, 0x81, 0xc0, 0x31, 0xc0, 0xa1, 0x70, 0x41,

0xf0, 0x40, 0x81, 0xc0, 0x31, 0xc0, 0xa1, 0x70, 0x41, 0xf0, 0x40, 0x81, 0xc0,

0x31, 0xc0, 0xa1, 0x70, 0x41, 0xf0, 0x40, 0x81, 0xc0, 0x31, 0xc0, 0xa1, 0x70,

0x41, 0xf0, 0x40, 0x71, 0xd0, 0x31,

0xc0, 0xf1, 0x71, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1,

0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1,


32

0x81, 0xc0, 0xf1, 0x01, 0xc0, 0xf1, 0xf1, 0x81, 0xc0, 0xf1, 0x01, 0xc0, 0xf1,

0xf1, 0x81, 0xc0, 0xf1, 0x01, 0xc0, 0xf1, 0xf1, 0x81, 0xc0, 0xf1, 0x01, 0xc0,

0xf1, 0xf1, 0x81, 0xc0, 0xf1, 0x01, 0xc0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0,

0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1,

0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1,

0xf1, 0x81, 0xf0, 0xf0, 0xa0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,


0xf1, 0xf1, 0xf1, 0x01, 0x80, 0x71, 0x80, 0xf1, 0xf1, 0xf1, 0x91, 0x80, 0x71,

0x80, 0xf1, 0xf1, 0xf1, 0x91, 0x80, 0x71, 0x80, 0xf1, 0xf1, 0xf1, 0x91, 0x80,

0x71, 0x80, 0xf1, 0xf1, 0xf1, 0x91, 0x80, 0x71, 0x80, 0xf1, 0xf1, 0xf1, 0x51,

0xc0, 0x71, 0xc0, 0xf1, 0xf1, 0xf1, 0x11, 0xc0, 0x71, 0xc0, 0xf1, 0xf1, 0xf1,

0x11, 0xc0, 0x71, 0xc0, 0xf1, 0xf1,

0xf1, 0x11, 0xc0, 0x71, 0xc0, 0xf1, 0xf1, 0xf1, 0x11, 0xc0, 0x71, 0xc0, 0xf1,


0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x01,

}; static const unsigned long palette_Orange1BPP_COMP_RLE4[] =

{

0xFFA500, 0x000000

}; const tImage Orange1BPP_COMP_RLE4 =

{


84,

84,

2,

palette_Orange1BPP_COMP_RLE4,

pixel_Orange1BPP_COMP_RLE4,

}; static const unsigned char pixel_Poly_Clone1BPP_COMP_RLE4[] =

{




0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x51, 0x30, 0x31, 0x30, 0xf1, 0xf1, 0xf1, 0xf1,

0x71, 0x30, 0x31, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0x71, 0x30, 0x31, 0x30, 0xf1,

0xf1, 0xf1, 0xf1, 0x71, 0x30, 0x31, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0x71, 0x30,

0x31, 0x30, 0xf1, 0xf1, 0xf1, 0xf1,

0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0x31, 0x30,

0x31, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0x31, 0x30, 0x31, 0x30, 0xf1, 0xf1,

0xf1, 0xf1, 0x30, 0x31, 0x30, 0x31, 0x30, 0xf1, 0xf1, 0xf1, 0x41, 0xa0, 0x31,

0x30, 0x31, 0x30, 0x31, 0x60, 0xf1, 0xf1, 0xd1, 0xa0, 0x31, 0x30, 0x31, 0x30,

0x31, 0x60, 0xf1, 0xf1, 0xd1, 0xa0, 0x31, 0x30, 0x31, 0x30, 0x31, 0x60, 0xf1,

0xf1, 0xd1, 0xa0, 0x31, 0x30, 0x31, 0x30, 0x31, 0x60, 0xf1, 0xf1, 0xd1, 0xa0,

0x31, 0x30, 0x31, 0x30, 0x31, 0x60,

0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1,

0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1,

0xd1, 0x70, 0x61, 0x70, 0x71, 0x60, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0x70, 0x71,

0x60, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0x70, 0x71, 0x60, 0xf1, 0xf1, 0xd1, 0x70,

0x61, 0x70, 0x71, 0x60, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0x70, 0x71, 0x60, 0xf1,

0xf1, 0x11, 0x30, 0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0xf1, 0xf1, 0x11, 0x30,

0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0,

0xf1, 0xf1, 0x11, 0x30, 0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0xf1, 0xf1, 0x11,

0x30, 0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0xf1, 0xd1, 0x70, 0x71, 0x70, 0x21,


33

0xb0, 0x31, 0xa0, 0x71, 0x30, 0xf1, 0x11, 0x70, 0x71, 0x70, 0x21, 0xb0, 0x31,

0xa0, 0x71, 0x30, 0xf1, 0x11, 0x70, 0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0x71,

0x30, 0xf1, 0x11, 0x70, 0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0x71, 0x30, 0xf1,

0x11, 0x70, 0x71, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0x71, 0x30, 0xf1, 0x11, 0x70,

0x71, 0xf0, 0xf0, 0x50, 0x71, 0x70,

0xd1, 0x70, 0x71, 0xf0, 0xf0, 0x50, 0x71, 0x70, 0xd1, 0x70, 0x71, 0xf0, 0xf0,

0x50, 0x71, 0x70, 0xd1, 0x70, 0x71, 0xf0, 0xf0, 0x50, 0x71, 0x70, 0xf1, 0x11,

0x70, 0x31, 0xf0, 0x20, 0x71, 0xa0, 0x31, 0xb0, 0xf1, 0x11, 0x70, 0x31, 0xf0,

0x20, 0x71, 0xa0, 0x31, 0xb0, 0xf1, 0x11, 0x70, 0x31, 0xf0, 0x20, 0x71, 0xa0,

0x31, 0xb0, 0xf1, 0x11, 0x70, 0x31, 0xf0, 0x20, 0x71, 0xa0, 0x31, 0xb0, 0xf1,

0x11, 0x70, 0x31, 0xf0, 0x20, 0x71, 0xa0, 0x31, 0xb0, 0xf1, 0xd1, 0xf0, 0xf0,

0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0,

0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50,

0xf1, 0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1,

0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1,

0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1,

0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0,

0xf0, 0x50, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x91,

0x60, 0x71, 0x70, 0xf1, 0xf1, 0xf1, 0xc1, 0x60, 0x71, 0x70, 0xf1, 0xf1, 0xf1,

0xc1, 0x60, 0x71, 0x70, 0xf1, 0xf1, 0xf1, 0xc1, 0x60, 0x71, 0x70, 0xf1, 0xf1,

0xf1, 0x81, 0xa0, 0x71, 0xa0, 0xf1, 0xf1, 0xf1, 0x51, 0xa0, 0x71, 0xa0, 0xf1,

0xf1, 0xf1, 0x51, 0xa0, 0x71, 0xa0, 0xf1, 0xf1, 0xf1, 0x51, 0xa0, 0x71, 0xa0,

0xf1, 0xf1, 0xf1, 0x51, 0xa0, 0x71, 0xa0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,



0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x21,

}; static const unsigned long palette_Poly_Clone1BPP_COMP_RLE4[] =

{

0xFFFF00, 0x000000

}; const tImage Poly_Clone1BPP_COMP_RLE4 =

{


84,

84,

2,

palette_Poly_Clone1BPP_COMP_RLE4,

pixel_Poly_Clone1BPP_COMP_RLE4,

}; static const unsigned char pixel_Final_Boss1BPP_COMP_RLE4[] =

{







0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,


34

0x51, 0xf0, 0xf0, 0xf0, 0xf0, 0x70, 0xb1, 0xf0, 0xf0, 0xf0, 0xf0, 0x70, 0xb1,

0xf0, 0xf0, 0xf0, 0xf0, 0x70, 0xb1, 0xf0, 0xf0, 0xf0, 0xf0, 0x70, 0xe1, 0xf0,

0xf0, 0xf0, 0xf0, 0x10, 0xf1, 0x11, 0xf0, 0xf0, 0xf0, 0xf0, 0x10, 0xf1, 0x11,

0xf0, 0xf0, 0xf0, 0xf0, 0x10, 0xf1, 0x11, 0xf0, 0xf0, 0xf0, 0xf0, 0x10, 0xf1,

0x41, 0xf0, 0x20, 0xf1, 0x51, 0xf0, 0x20, 0xf1, 0x71, 0xf0, 0x20, 0xf1, 0x51,

0xf0, 0x20, 0xf1, 0x71, 0xf0, 0x20, 0xf1, 0x51, 0xf0, 0x20, 0xf1, 0x71, 0xf0,

0x20, 0xf1, 0x51, 0xf0, 0x20, 0xf1,

0xa1, 0xc0, 0x81, 0x90, 0x81, 0xc0, 0xf1, 0xd1, 0xc0, 0x81, 0x90, 0x81, 0xc0,

0xf1, 0xd1, 0xc0, 0x81, 0x90, 0x81, 0xc0, 0xf1, 0xd1, 0xc0, 0x81, 0x90, 0x81,

0xc0, 0xf1, 0xf1, 0x01, 0x90, 0x51, 0x50, 0x31, 0x50, 0x51, 0x90, 0xf1, 0xf1,

0x31, 0x90, 0x51, 0x50, 0x31, 0x50, 0x51, 0x90, 0xf1, 0xf1, 0x31, 0x90, 0x51,

0x50, 0x31, 0x50, 0x51, 0x90, 0xf1, 0xf1, 0x31, 0x90, 0x51, 0x50, 0x31, 0x50,

0x51, 0x90, 0xf1, 0xf1, 0x31, 0xc0, 0x51, 0x90, 0x51, 0xc0, 0xf1, 0xf1, 0x31,

0xc0, 0x51, 0x90, 0x51, 0xc0, 0xf1,

0xf1, 0x31, 0xc0, 0x51, 0x90, 0x51, 0xc0, 0xf1, 0xf1, 0x31, 0xc0, 0x51, 0x90,

0x51, 0xc0, 0xf1, 0xf1, 0x71, 0xb0, 0xf1, 0xb0, 0xf1, 0xf1, 0xb1, 0xb0, 0xf1,

0xb0, 0xf1, 0xf1, 0xb1, 0xb0, 0xf1, 0xb0, 0xf1, 0xf1, 0xb1, 0xb0, 0xf1, 0xb0,

0xf1, 0xf1, 0xe1, 0xf0, 0xf0, 0x10, 0xf1, 0xf1, 0xf1, 0x11, 0xf0, 0xf0, 0x10,

0xf1, 0xf1, 0xf1, 0x11, 0xf0, 0xf0, 0x10, 0xf1, 0xf1, 0xf1, 0x11, 0xf0, 0xf0,

0x10, 0xf1, 0xf1, 0xf1, 0x11, 0xf0, 0xf0, 0x10, 0xf1, 0xf1, 0xf1, 0x41, 0xf0,

0xb0, 0xf1, 0xf1, 0xf1, 0x71, 0xf0,

0xb0, 0xf1, 0xf1, 0xf1, 0x71, 0xf0, 0xb0, 0xf1, 0xf1, 0xf1, 0x71, 0xf0, 0xb0,

0xf1, 0xf1, 0xf1, 0x71, 0xf0, 0xb0, 0xf1, 0xf1, 0xf1, 0x71, 0xf0, 0xb0, 0xf1,

0xf1, 0xf1, 0x71, 0xf0, 0xb0, 0xf1, 0xf1, 0xf1, 0x71, 0xf0, 0xb0, 0xf1, 0xf1,

0xf1, 0xa1, 0xf0, 0x50, 0xf1, 0xf1, 0xf1, 0xd1, 0xf0, 0x50, 0xf1, 0xf1, 0xf1,

0xd1, 0xf0, 0x50, 0xf1, 0xf1, 0xf1, 0xd1, 0xf0, 0x50, 0xf1, 0xf1, 0xf1, 0xf1,

0x01, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0x31, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0x31,

0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0x31,

0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0x31, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0x31, 0xf0,

0xf1, 0xf1, 0xf1, 0xf1, 0x31, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0x31, 0xf0, 0xf1,

0xf1, 0xf1, 0xf1, 0x61, 0x90, 0xf1, 0xf1, 0xf1, 0xf1, 0x91, 0x90, 0xf1, 0xf1,

0xf1, 0xf1, 0x91, 0x90, 0xf1, 0xf1, 0xf1, 0xf1, 0x91, 0x90, 0xf1, 0xf1, 0xf1,

0xf1, 0xc1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,



0xf1, 0xb1,

}; static const unsigned long palette_Final_Boss1BPP_COMP_RLE4[] =

{

0x008000, 0x000000

}; const tImage Final_Boss1BPP_COMP_RLE4 =

{


84,

84,

2,

palette_Final_Boss1BPP_COMP_RLE4,

pixel_Final_Boss1BPP_COMP_RLE4,

}; static const unsigned char pixel_Poly1BPP_COMP_RLE4[] =

{


35


0xf1, 0xf1, 0xf1, 0xf1, 0x91, 0xf0, 0x00, 0xf1, 0xf1, 0xf1, 0xf1, 0x21, 0xf0,

0x00, 0xf1, 0xf1, 0xf1, 0xf1, 0x21, 0xf0, 0x00, 0xf1, 0xf1, 0xf1, 0xf1, 0x21,

0xf0, 0x00, 0xf1, 0xf1, 0xf1, 0xf1, 0x21, 0xb0, 0xf1, 0xf1, 0xf1, 0xf1, 0x71,

0xb0, 0xf1, 0xf1, 0xf1, 0xf1, 0x71, 0xb0, 0xf1, 0xf1, 0xf1, 0xf1, 0x71, 0xb0,

0xf1, 0xf1, 0xf1, 0xf1, 0x71, 0xb0, 0xf1, 0xf1, 0xf1, 0xf1, 0x71, 0xf0, 0x80,

0xf1, 0xf1, 0xf1, 0xa1, 0xf0, 0x80,

0xf1, 0xf1, 0xf1, 0xa1, 0xf0, 0x80, 0xf1, 0xf1, 0xf1, 0xa1, 0xf0, 0x80, 0xf1,

0xf1, 0xf1, 0xa1, 0xf0, 0x80, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,


0xf1, 0xf1, 0xf1, 0x21, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80,

0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1,

0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1,

0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1,

0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1,

0x70, 0x71, 0x80, 0x71, 0x70, 0xf1, 0xf1, 0xa1, 0x70, 0x71, 0x80, 0x71, 0x70,

0xf1, 0xf1, 0xa1, 0x70, 0x71, 0x80, 0x71, 0x70, 0xf1, 0xf1, 0xa1, 0x70, 0x71,

0x80, 0x71, 0x70, 0xf1, 0xf1, 0xa1, 0x70, 0x71, 0x80, 0x71, 0x70, 0xf1, 0xd1,

0x30, 0x81, 0x70, 0x31, 0xc0, 0x31, 0xb0, 0xf1, 0xd1, 0x30, 0x81, 0x70, 0x31,

0xc0, 0x31, 0xb0, 0xf1, 0xd1, 0x30, 0x81, 0x70, 0x31, 0xc0, 0x31, 0xb0, 0xf1,

0xd1, 0x30, 0x81, 0x70, 0x31, 0xc0,

0x31, 0xb0, 0xf1, 0x91, 0x70, 0x81, 0x70, 0x71, 0x80, 0x71, 0x70, 0x71, 0x30,

0xd1, 0x70, 0x81, 0x70, 0x71, 0x80, 0x71, 0x70, 0x71, 0x40, 0xc1, 0x70, 0x81,

0x70, 0x71, 0x80, 0x71, 0x70, 0x71, 0x40, 0xc1, 0x70, 0x81, 0x70, 0x71, 0x80,

0x71, 0x70, 0x71, 0x40, 0xc1, 0x70, 0x81, 0x70, 0x71, 0x80, 0x71, 0x70, 0x71,

0x40, 0xc1, 0x70, 0x81, 0xf0, 0xf0, 0x80, 0x71, 0x80, 0x81, 0x70, 0x81, 0xf0,

0xf0, 0x80, 0x71, 0x80, 0x81, 0x70, 0x81, 0xf0, 0xf0, 0x80, 0x71, 0x80, 0x81,

0x70, 0x81, 0xf0, 0xf0, 0x80, 0x71,

0x80, 0x81, 0x70, 0x81, 0xf0, 0xf0, 0x80, 0x71, 0x80, 0xc1, 0x70, 0x41, 0xf0,

0x30, 0x81, 0xb0, 0x31, 0xc0, 0xc1, 0x70, 0x41, 0xf0, 0x30, 0x81, 0xb0, 0x31,

0xc0, 0xc1, 0x70, 0x41, 0xf0, 0x30, 0x81, 0xb0, 0x31, 0xc0, 0xc1, 0x70, 0x41,

0xf0, 0x30, 0x81, 0xb0, 0x31, 0xc0, 0xf1, 0x91, 0x70, 0x71, 0xf0, 0x80, 0xf1,

0xf1, 0xa1, 0x70, 0x71, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0x70, 0x71, 0xf0, 0x80,

0xf1, 0xf1, 0xa1, 0x70, 0x71, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0x70, 0x71, 0xf0,

0x80, 0xf1, 0xf1, 0xa1, 0xb0, 0xf1,

0x01, 0xb0, 0xf1, 0xf1, 0xa1, 0xb0, 0xf1, 0x01, 0xb0, 0xf1, 0xf1, 0xa1, 0xb0,

0xf1, 0x01, 0xb0, 0xf1, 0xf1, 0xa1, 0xb0, 0xf1, 0x01, 0xb0, 0xf1, 0xf1, 0xa1,

0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0,

0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0, 0x80, 0xf1, 0xf1, 0xa1, 0xf0, 0xf0,

0x80, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,


0xf1, 0xf1, 0xf1, 0xf1, 0x61, 0x70,

0x81, 0x70, 0xf1, 0xf1, 0xf1, 0xa1, 0x70, 0x81, 0x70, 0xf1, 0xf1, 0xf1, 0xa1,

0x70, 0x81, 0x70, 0xf1, 0xf1, 0xf1, 0xa1, 0x70, 0x81, 0x70, 0xf1, 0xf1, 0xf1,

0x61, 0xb0, 0x81, 0xb0, 0xf1, 0xf1, 0xf1, 0x21, 0xb0, 0x81, 0xb0, 0xf1, 0xf1,

0xf1, 0x21, 0xb0, 0x81, 0xb0, 0xf1, 0xf1, 0xf1, 0x21, 0xb0, 0x81, 0xb0, 0xf1,

0xf1, 0xf1, 0x21, 0xb0, 0x81, 0xb0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1,

0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xc1,

}; static const unsigned long palette_Poly1BPP_COMP_RLE4[] =

{

0x0000FF, 0xFFFFFF

}; const tImage Poly1BPP_COMP_RLE4 =

{


36


84,

84,

2,

palette_Poly1BPP_COMP_RLE4,

pixel_Poly1BPP_COMP_RLE4,

}; static const unsigned char pixel_Poly_Girl1BPP_COMP_RLE4[] =

{


0xf1, 0xf1, 0xf1, 0xf1, 0xc1, 0x20, 0xb1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0x01,

0x20, 0xb1, 0x30, 0xf1, 0xf1, 0xf1, 0xf1, 0x01, 0x20, 0xb1, 0x30, 0xf1, 0xf1,

0xf1, 0xf1, 0x01, 0x20, 0xb1, 0x30, 0xf1, 0xf1, 0xf1, 0xc1, 0x30, 0x21, 0x30,

0x31, 0x30, 0x31, 0x20, 0xf1, 0xf1, 0xf1, 0x91, 0x30, 0x21, 0x30, 0x31, 0x30,

0x31, 0x20, 0xf1, 0xf1, 0xf1, 0x91, 0x30, 0x21, 0x30, 0x31, 0x30, 0x31, 0x20,

0xf1, 0xf1, 0xf1, 0x91, 0x30, 0x21,

0x30, 0x31, 0x30, 0x31, 0x20, 0xf1, 0xf1, 0xf1, 0x91, 0xf0, 0x90, 0xf1, 0xf1,

0xf1, 0x91, 0xf0, 0x90, 0xf1, 0xf1, 0xf1, 0x91, 0xf0, 0x90, 0xf1, 0xf1, 0xf1,

0x91, 0xf0, 0x90, 0xf1, 0xf1, 0xf1, 0x91, 0xf0, 0x90, 0xf1, 0xf1, 0xf1, 0xd1,

0x60, 0x31, 0x70, 0xf1, 0xf1, 0xf1, 0xf1, 0x01, 0x60, 0x31, 0x70, 0xf1, 0xf1,

0xf1, 0xf1, 0x01, 0x60, 0x31, 0x70, 0xf1, 0xf1, 0xf1, 0xf1, 0x01, 0x60, 0x31,

0x70, 0xf1, 0xf1, 0xf1, 0x81, 0xa0, 0x31, 0xf0, 0x60, 0xf1, 0xf1, 0xd1, 0xa0,

0x31, 0xf0, 0x60, 0xf1, 0xf1, 0xd1,

0xa0, 0x31, 0xf0, 0x60, 0xf1, 0xf1, 0xd1, 0xa0, 0x31, 0xf0, 0x60, 0xf1, 0xf1,

0xd1, 0xb0, 0x21, 0xf0, 0x60, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1,

0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1,

0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0x70, 0x61, 0x70, 0xf1, 0xf1,

0xd1, 0x70, 0x61, 0x70, 0x61, 0x70, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0x70, 0x61,

0x70, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0x70, 0x61, 0x70, 0xf1, 0xf1, 0x21, 0x30,

0x61, 0x70, 0x21, 0xb0, 0x31, 0xa0,

0xf1, 0xf1, 0x21, 0x30, 0x61, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0xf1, 0xf1, 0x21,

0x30, 0x61, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0xf1, 0xf1, 0x21, 0x30, 0x61, 0x70,

0x21, 0xb0, 0x31, 0xa0, 0xf1, 0xf1, 0x21, 0x30, 0x61, 0x70, 0x21, 0xb0, 0x31,

0xa0, 0xf1, 0xe1, 0x70, 0x61, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0x61, 0x30, 0xf1,

0x31, 0x70, 0x61, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0x61, 0x30, 0xf1, 0x31, 0x70,

0x61, 0x70, 0x21, 0xb0, 0x31, 0xa0, 0x61, 0x30, 0xf1, 0x31, 0x70, 0x61, 0x70,

0x21, 0xb0, 0x31, 0xa0, 0x61, 0x30,

0xf1, 0x31, 0x70, 0x61, 0xf0, 0xf0, 0x50, 0x61, 0x70, 0xf1, 0x70, 0x61, 0xf0,

0xf0, 0x50, 0x61, 0x70, 0xf1, 0x70, 0x61, 0xf0, 0xf0, 0x50, 0x61, 0x70, 0xf1,

0x70, 0x61, 0xf0, 0xf0, 0x50, 0x61, 0x70, 0xf1, 0x31, 0x60, 0x31, 0xf0, 0x20,

0x71, 0xa0, 0x31, 0xa0, 0xf1, 0x31, 0x60, 0x31, 0xf0, 0x20, 0x71, 0xa0, 0x31,

0xa0, 0xf1, 0x31, 0x60, 0x31, 0xf0, 0x20, 0x71, 0xa0, 0x31, 0xa0, 0xf1, 0x31,

0x60, 0x31, 0xf0, 0x20, 0x71, 0xa0, 0x31, 0xa0, 0xf1, 0x31, 0x60, 0x31, 0xf0,

0x20, 0x71, 0xa0, 0x31, 0xa0, 0xf1,

0xe1, 0x70, 0x61, 0xf0, 0x60, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0xf0, 0x60, 0xf1,

0xf1, 0xd1, 0x70, 0x61, 0xf0, 0x60, 0xf1, 0xf1, 0xd1, 0x70, 0x61, 0xf0, 0x60,

0xf1, 0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1,

0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1, 0xd1, 0xa0, 0xf1, 0xa0, 0xf1, 0xf1,

0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1,

0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0, 0xf0, 0x50, 0xf1, 0xf1, 0xd1, 0xf0,

0xf0, 0x50, 0xf1, 0xf1, 0xf1, 0xf1,


0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0x51, 0x60, 0x71, 0x60, 0xf1, 0xf1,

0xf1, 0xd1, 0x60, 0x71, 0x60, 0xf1, 0xf1, 0xf1, 0xd1, 0x60, 0x71, 0x60, 0xf1,

0xf1, 0xf1, 0xd1, 0x60, 0x71, 0x60, 0xf1, 0xf1, 0xf1, 0xd1, 0x60, 0x71, 0x60,

0xf1, 0xf1, 0xf1, 0x91, 0xa0, 0x71, 0xa0, 0xf1, 0xf1, 0xf1, 0x51, 0xa0, 0x71,


37

0xa0, 0xf1, 0xf1, 0xf1, 0x51, 0xa0, 0x71, 0xa0, 0xf1, 0xf1, 0xf1, 0x51, 0xa0,

0x71, 0xa0, 0xf1, 0xf1, 0xf1, 0xf1,



0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xc1,

}; static const unsigned long palette_Poly_Girl1BPP_COMP_RLE4[] =

{

0xFF69B4, 0x000000

}; const tImage Poly_Girl1BPP_COMP_RLE4 =

{


84,

84,

2,

palette_Poly_Girl1BPP_COMP_RLE4,

pixel_Poly_Girl1BPP_COMP_RLE4,

}; static const unsigned char pixel_Hastur1BPP_COMP_RLE4[] =

{

0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x80, 0x21, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x90,

0x11, 0xc0, 0x01, 0xf0, 0xf0, 0xf0, 0xf0, 0xc0, 0x01, 0xf0, 0xf0, 0xf0, 0xe0,

0x01, 0xf0, 0xf0, 0x80, 0x01, 0xf0, 0xf0, 0xf0, 0x00, 0x01, 0x30, 0x01, 0xc0,

0x01, 0xf0, 0x10, 0x01, 0x20, 0x01, 0x90, 0x01, 0xf0, 0xf0, 0xf0, 0x01, 0xf0,

0xa0, 0x11, 0xc0, 0x01, 0xf0, 0xf0, 0x00, 0x01, 0xf0, 0xf0, 0xf0, 0x40, 0x01,

0xf0, 0x90, 0x01, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xa0, 0x01, 0xf0, 0xf0, 0x90,

0x11, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x70, 0x31, 0xf0, 0xf0, 0x90, 0x01, 0xd0,

0x01,

0x10, 0x11, 0xf0, 0x70, 0x21, 0x00, 0x11, 0xf0, 0xf0, 0x90, 0x01, 0xf0, 0xd0,

0x61, 0x50, 0x51, 0xf0, 0xf0, 0xf0, 0xf0, 0x90, 0x31, 0x60, 0x61, 0x40, 0x01,

0xb0, 0x01, 0x10, 0x11, 0x90, 0x01, 0xf0, 0xf0, 0xf1, 0x20, 0x31, 0x00, 0x11,

0x40, 0x11, 0xa0, 0x01, 0xd0, 0x01, 0xf0, 0xb0, 0xe1, 0x00, 0xc1, 0xf0, 0x10,

0x01, 0xf0, 0xd0, 0x11, 0xa0, 0x01, 0x50, 0xd1, 0x20, 0x61, 0xf0, 0x11, 0xf0,

0xf0, 0xf0, 0x80, 0x71, 0x10, 0x21, 0x00, 0x01, 0x00, 0x01, 0x50, 0x21, 0x60,

0x01, 0xf0, 0x50, 0x01, 0xf0, 0x70, 0x21, 0x90, 0x51, 0x10, 0x61, 0x60, 0x31,

0x30,

0x11, 0x50, 0x01, 0xb0, 0x51, 0x80, 0x01, 0x20, 0x01, 0x00, 0x91, 0x40, 0x61,

0x60, 0x41, 0xa0, 0x11, 0x10, 0x11, 0xf0, 0x21, 0x20, 0x11, 0x20, 0xf1, 0xf1,

0x61, 0x30, 0x21, 0x00, 0x11, 0x20, 0x01, 0x60, 0x31, 0xc0, 0xf1, 0xf1, 0x01,

0x30, 0x41, 0x40, 0x01, 0xb0, 0x21, 0x00, 0x31, 0x30, 0x21, 0xf0, 0x30, 0xf1,

0x51, 0x00, 0x01, 0x00, 0x71, 0xd0, 0x11, 0x40, 0x21, 0x30, 0xd1, 0x20, 0x01,

0x10, 0x61, 0x10, 0xf1, 0x71, 0x00, 0x01, 0xd0, 0x21, 0x50, 0x11, 0x40, 0x41,

0x10, 0xf1, 0x21, 0x00, 0x41, 0x30, 0xf1, 0xb1, 0x00, 0x21, 0x90, 0x71, 0x20,

0x51,

0x00, 0x11, 0x00, 0x91, 0x00, 0xf1, 0xf1, 0xf1, 0xf1, 0xb1, 0x10, 0x01, 0x00,

0xf1, 0xf1, 0xc1, 0x20, 0x01, 0x00, 0x11, 0x00, 0xf1, 0x81, 0x00, 0x21, 0x20,

0x01, 0x00, 0x01, 0x00, 0x11, 0x00, 0xf1, 0x71, 0x00, 0x01, 0x00, 0xf1, 0x01,

0x00, 0x41, 0x10, 0x01, 0x00, 0xf1, 0x11, 0x30, 0x61, 0x00, 0x01, 0x00, 0x01,

0x00, 0x21, 0x00, 0x01, 0x00, 0xf1, 0x11, 0x00, 0x61, 0x00, 0x21, 0x00, 0xb1,

0x90, 0x91, 0x10, 0xe1, 0x00, 0x11, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x20,

0xe1, 0x10, 0x21, 0x00, 0x01, 0x30, 0x11, 0x00, 0x21, 0x00, 0x61, 0xc0, 0x71,

0x20,


38

0xf1, 0x10, 0x11, 0x10, 0x11, 0x30, 0x11, 0x00, 0x01, 0x00, 0x91, 0x00, 0x11,

0x40, 0x01, 0x00, 0x31, 0x00, 0xa1, 0xb0, 0x61, 0x00, 0x21, 0x00, 0x01, 0x00,

0x51, 0x00, 0x91, 0x00, 0x31, 0x20, 0xd1, 0x60, 0x51, 0x00, 0xb1, 0xc0, 0x41,

0x10, 0xc1, 0x00, 0x81, 0x10, 0x01, 0x00, 0x01, 0x10, 0x01, 0x00, 0xc1, 0x20,

0x91, 0x00, 0xc1, 0xc0, 0x51, 0x20, 0x31, 0x00, 0x41, 0x00, 0x31, 0x00, 0x01,

0x00, 0x01, 0x00, 0x01, 0x60, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,

0x91, 0x00, 0x01, 0x10, 0xf1, 0x11, 0x00, 0x01, 0xd0, 0x01, 0x00, 0x41, 0x00,

0x11,

0x20, 0x31, 0x10, 0x51, 0xa0, 0x11, 0x10, 0x01, 0x00, 0xf1, 0x51, 0x10, 0x81,

0x00, 0x01, 0x40, 0x11, 0x00, 0x31, 0x30, 0x51, 0x20, 0x41, 0x20, 0x61, 0xa0,

0x11, 0x40, 0xf1, 0x00, 0x11, 0x10, 0x01, 0x00, 0x01, 0x00, 0x51, 0x00, 0x01,

0x30, 0x51, 0x20, 0x01, 0x50, 0x51, 0x10, 0x11, 0x10, 0x61, 0x00, 0x01, 0xa0,

0x11, 0x50, 0x71, 0x00, 0x01, 0x20, 0x21, 0x00, 0xb1, 0x00, 0x01, 0x30, 0x11,

0xf0, 0x00, 0x61, 0x20, 0x51, 0x00, 0x01, 0x90, 0x31, 0x40, 0x71, 0x00, 0x51,

0x00, 0x31, 0x00, 0x71, 0x00, 0x01, 0x40, 0x01, 0xf0, 0x30, 0x41, 0x10, 0x71,

0xd0,

0x01, 0x30, 0x31, 0x00, 0x31, 0x10, 0x01, 0x00, 0x01, 0x00, 0x21, 0x00, 0x91,

0x00, 0x11, 0xf0, 0x70, 0x21, 0x00, 0x21, 0x20, 0x01, 0x00, 0x31, 0xc0, 0x01,

0x00, 0x11, 0x30, 0x61, 0x10, 0x01, 0x00, 0x31, 0x00, 0x31, 0x00, 0x41, 0x00,

0x21, 0xf0, 0xb0, 0x31, 0x30, 0x71, 0x00, 0x01, 0x50, 0x21, 0x90, 0x11, 0x00,

0x21, 0x00, 0x21, 0x00, 0xa1, 0x00, 0x11, 0xf0, 0xd0, 0x41, 0x40, 0x01, 0x00,

0x01, 0x00, 0x21, 0x00, 0x01, 0x00, 0x01, 0x20, 0x01, 0x30, 0x01, 0x30, 0x01,

0x10, 0x51, 0x00, 0x01, 0x10, 0xb1, 0x00, 0x01, 0xf0, 0xf0, 0x31, 0x60, 0x11,

0x00,

0x41, 0x20, 0x11, 0x30, 0x01, 0x10, 0x01, 0x00, 0x01, 0x30, 0x11, 0x10, 0xf1,

0x01, 0x60, 0x01, 0xc0, 0x31, 0xa0, 0x01, 0x90, 0x41, 0x00, 0x01, 0x00, 0x01,

0x50, 0x01, 0x00, 0x01, 0x00, 0x01, 0x40, 0x91, 0x30, 0x31, 0x00, 0x01, 0xf0,

0x40, 0x41, 0xb0, 0x01, 0x80, 0x01, 0x00, 0x51, 0x70, 0x11, 0x50, 0x81, 0x40,

0x51, 0xf0, 0x80, 0x11, 0xb0, 0x21, 0x70, 0x51, 0x80, 0x11, 0x40, 0x61, 0x00,

0x01, 0x10, 0x11, 0x10, 0x41, 0xf0, 0x80, 0x21, 0xc0, 0x11, 0x50, 0x51, 0x30,

0x01, 0x40, 0x11, 0x40, 0x51, 0x00, 0x01, 0x00, 0x31, 0x00, 0x41, 0xf0, 0xb0,

0x11,

0xd0, 0x11, 0x40, 0x31, 0x30, 0x11, 0x50, 0x01, 0x40, 0x51, 0x00, 0x01, 0x00,

0x21, 0x00, 0x31, 0x00, 0x01, 0xf0, 0xc0, 0x11, 0xf0, 0x40, 0x21, 0x20, 0x11,

0x60, 0x11, 0x40, 0x51, 0x10, 0x71, 0x00, 0x01, 0xf0, 0x01, 0xc0, 0x01, 0x20,

0x21, 0xd0, 0x31, 0x10, 0x01, 0x80, 0x11, 0x40, 0x31, 0x00, 0x01, 0x00, 0xa1,

0x60, 0x01, 0x60, 0x11, 0xf0, 0x01, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x31, 0x10,

0x01, 0xf0, 0x01, 0x00, 0x31, 0x00, 0x21, 0x00, 0x01, 0x30, 0x01, 0x60, 0x01,

0x70, 0x11, 0xf0, 0x00, 0x11, 0x00, 0x11, 0xb0, 0x31, 0x10, 0x01, 0x80, 0x01,

0x50,

0x51, 0x10, 0x21, 0x20, 0x21, 0x60, 0x01, 0x80, 0x01, 0xf0, 0x20, 0x01, 0x00,

0x51, 0x30, 0x01, 0x00, 0x41, 0x10, 0x01, 0x40, 0x01, 0x30, 0x01, 0x60, 0x41,

0x10, 0x61, 0x70, 0x01, 0x80, 0x01, 0xf0, 0x30, 0x71, 0x00, 0xa1, 0x20, 0x01,

0x00, 0x11, 0xb0, 0x21, 0x00, 0x01, 0x40, 0x21, 0x80, 0x01, 0x80, 0x01, 0xf0,

0x50, 0x51, 0x80, 0x61, 0x00, 0x21, 0xa0, 0x21, 0x00, 0x01, 0x30, 0x11, 0xa0,

0x11, 0x70, 0x01, 0xf0, 0x50, 0x11, 0x00, 0x01, 0xc0, 0x01, 0x00, 0x01, 0x20,

0x31, 0x00, 0x01, 0x70, 0x51, 0x10, 0x01, 0x40, 0x01, 0x60, 0x01, 0x90, 0x01,

0xd0,

0x11, 0x50, 0x11, 0x30, 0x61, 0x20, 0x11, 0x40, 0x01, 0x00, 0x01, 0x00, 0x11,

0x50, 0x11, 0x20, 0x01, 0x00, 0x11, 0x40, 0x11, 0x10, 0x01, 0x40, 0x01, 0x80,

0x01, 0xf0, 0x01, 0x40, 0x01, 0x00, 0x01, 0x20, 0x01, 0x00, 0x21, 0x00, 0x01,

0x00, 0x01, 0x10, 0x31, 0x00, 0x11, 0x80, 0x21, 0xb0, 0x21, 0x00, 0x01, 0x50,

0x01, 0x80, 0x11, 0xf0, 0x01, 0x30, 0x01, 0x00, 0x11, 0x00, 0x81, 0x00, 0x01,

0x00, 0x41, 0x60, 0x61, 0x50, 0x01, 0x30, 0x41, 0x60, 0x11, 0x80, 0x01, 0x90,

0x01, 0x40, 0x11, 0xc0, 0x51, 0x00, 0x11, 0x00, 0x01, 0x20, 0x61, 0x00, 0x01,

0x00,


39

0x11, 0x40, 0x11, 0x20, 0x11, 0x00, 0x01,

final project: games console...university of colorado boulder ecen 2020 – applications of embedded...

Documents