CS2110-Homework 10 GBA Solved

The goal of this assignment is to make an interactive C program (e.g. a game, an interactive storybook, an application of other sorts) that will run on the GBA emulator. Your program should include everything in the requirements and be written neatly and efficiently. Your code should be something different from lecture code, since in this homework you will be creating your own program, but keep the core setup with videoBuffer, MODE 3, waitForVBlank, etc.

Prototypes, #defines, and extern declarations should be put into header files such as logic.h, graphics.h, or gba.h. It is also optional for you to use other .c/.h files to organize your logic if you wish, just make sure you include them in submission and Makefile.

1         Assignment Details
1.1        Content Requirements
•   You must use 3 distinct images in your program, all drawn with DMA.

–    Two full screened images sized 240 x 160. One of these images should be the first screen displayed when first running your program.

–    A third image which will be used during the course of your program. The width of this image may not be 240 and the height of this image may not be 160.

–    Note: all images should be included in your submission

•   You must be able to reset the program to the title screen AT ANY TIME using the select key

•   Button input should visibly and clearly affect the flow of the program

•   You must have 2-dimensional movement of at least one entity. One entity moving up/down and another moving left/right alone does not count.

•   You should implement some form of object collision. For programs where application of this rule is more of a gray area (like Minesweeper), core functionality will take the place of this criteria, such as the numbers for Minesweeper tiles calculated correctly, accurate control, etc.

•   You must implement waitForVBlank.

•   Use text to show progression in your program.

•   There must be no tearing in your program. Make your code as efficient as possible!

1.2        Code Style Requirements
•   Must be in Mode 3 unless you’re absolutely sure you want to try something else, without TA support.

•   You must also implement a drawImage function with DMA.

Put your prototypes, struct declarations and typedefs in header files. Do not put functions in header files.

•   You must use at least one struct.

•   Include a readme.txt file with your submission that briefly explains the program and the controls.

•   Do not include .c files into other files. Only .h files should be included and .h files should contain no functional code.

1.3        What to Make?
You may either create your own program the way you wish it to be as long as it covers the requirements, or you can make programs that have been made before with you own code. However, your assignment must be yours entirely and not based on anyone else’s code. This also means that you are not allowed to base your program off the code posted from lecture. Programs that are lecture code that have been slightly modified are subject to heavy penalties. Here are some previous programs that you can either create or use as inspiration:

Hint: It’s better to be creative and come up with something new than reuse these!

Galaga:

•  Use text to show lives

•  Game ends when all lives are lost. Level ends when all aliens are gone.

•  Different types of aliens: there should be one type of alien that rushes towards the ship and attacks it

•  Smooth movement (aliens and player) The World’s Hardest Game:

•  Smooth motion for enemies and player (no jumping around)

•  Constriction to the boundaries of the level

•  Enemies moving at different speeds and in different directions

•  Sensible, repeating patterns of enemy motion

•  Enemies and the Player represented by Structs Flyswatter:

•  Images of yellow jackets or flies moving smoothly across the screen

•  Player controlled flyswatter or net to catch the flies

•  Score counter to keep track of how many flies have been swatted

•  Fullscreen image for title screen and game background

•  Enemies and the Player represented by Structs

Interactive Storybook:

Recreate a story from a movie or a book using the GBA

•  Use text to narrate what is currently happening in the scene

•  Use the controls to advance to the next scene or control a character within the scene

•  Satisfy the collision requirement by having a cursor etc. element whose position needs to be used to calculate where it’s pointing.

•  Smooth movement (for any moving characters or objects)

•  Start off with a full screen title image and end with a full screen credits image Data Visualization App:

•  Use the GBA to visualize a dataset that you can include in your code. Can be a 2d plot.

•  Use text to draw the scale of the axes.

•  Use a cursor and apply collision calculation to click and zoom on individual datapoints.

•  Implement zooming etc. animations without tearing.

2         Warnings
•   Do not use floats or doubles in your code. Doing so will slow your code down greatly. The ARM7 processor the GBA uses does not have a Floating Point Unit which means floating point operations are slow and are done in software, not hardware. Anywhere you use floats, gcc has to insert assembly code to convert integers to that format. If you do need such things then you should look into fixed point math.

•   Only call waitForVBlank once per iteration of your main loop

•   Keep your code efficient. If an O(1) solution exists to an algorithm and you are using an O(n2) algorithm then that’s bad (for larger values of n)! For example, do not pass large structs directly to functions but pass pointers instead so that only a single pointer needs to be copied onto the stack rather than the full struct.

•   If you use more advanced GBA features like sprites or sound, making them work is your responsibility; we (the TAs) can not help you.

3         Deliverables
Please run make submit and upload submission.tar.gz to Gradescope under the Homework 10 assignment.

This includes all .c and .h files needed for your program to compile. Do not submit any compiled files. You can use make clean to remove any compiled files. (make submit will do this automatically.) Gradescope will confirm that your Makefile produces a valid .gba file when make is run.

Download and test your submission to make sure you submitted the right files. The Gradescope tester just checks that you submitted compiling code — not that you submitted what you thought you did.

3.1        Building and Running your Code
To build your code and run the GBA emulator, run

$ make emu

3.2        Images
As a requirement, you must use at least 3 images in your program and you must draw them all. To use images on the GBA, you will first have to convert them into the suitable format. We recommend using a tool called nin10kit, which you installed with the command above.

You can read about nin10kit in the nin10kit documentation (there are pictures!):

https://github.com/TricksterGuy/nin10kit/raw/master/readme.pdf nin10kit reads in, converts, and exports image files into C arrays in .c/.h files ready to be copied to the GBA video buffer by your implementation of drawImage! It also supports resizing images before they are exported.

You want to use Mode 3 since this assignment requires it, so to convert a picture of smelly festering garbage into GBA pixel format in garbage.c and garbage.h, resizing it to 50 horizontal by 37 vertical pixels, you would run nin10kit like

$ cd images/

$ nin10kit --mode=3 --resize=50x37 garbage garbage.png This creates a garbage.h file in images/ containing

extern const unsigned short garbage[1850];

#define GARBAGE_SIZE 3700

#define GARBAGE_LENGTH 1850

#define GARBAGE_WIDTH 50

#define GARBAGE_HEIGHT 37

which you can use in your program by saying #include "images/garbage.h".

The images/garbage.c generated, which you should add to the Makefile under OFILES as images/garbage.o if you plan to use it, contains all of the pixel data in a huge array:

const unsigned short garbage[1850] =

{

0x7fff,0x7fff,0x7fff,0x7fff,0x7fff, // ...

0x7fff,0x7fff,0x7fff,0x7fff,0x7fff, // ... // ...

0x7fff,0x7fff,0x7fff,0x7fff,0x7fff, // ...

0x7fff,0x7fff,0x7fff,0x7fff,0x7fff, // ...

};

We’ve included garbage.png, garbage.c, and garbage.h in images/ directory in the homework tarball so you can check them out yourself. To draw the garbage in your own game, you can pass the array, width, height to your drawImage like drawImage(10, 20, GARBAGE WIDTH, GARBAGE  HEIGHT, garbage) (to draw at row 10 and column 20). The next section will cover drawImage in more detail.

3.3        DMA / drawImage
In your program, you must use DMA to implement image drawing.

Drawing to the GBA screen follows the same guidelines as the graphics functions you had to implement for HW9. The GBA screen is represented with a short pointer declared as videoBuffer in the gba.h file. The pointer represents the first pixel in a 240 by 160 screen that has been flattened into a one dimensional array. Each pixel is a short and has a red, green, and blue portion just like the pixels in HW9. With a little modification (Hint: include the graphics and geometry header files and use videoBuffer as the screen buffer), you should be able to use the same code you implemented in HW9 to draw to the GBA screen. Note that those functions do not use DMA and thus are considerably slower than the ones you will implement for this assignment.

DMA stands for Direct Memory Access and may be used to make your rendering code run much faster. If you want to read up on DMA before it is covered in lecture, you may read these pages from Tonc. http://www.coranac.com/tonc/text/dma.htm (Up until 14.3.2).

If you want to wait, then you can choose to implement drawImage without DMA and then when you learn DMA rewrite it using DMA. Your final answer for drawImage must use DMA.

You must not use DMA to do one pixel copies (Doing this defeats the purpose of DMA and is slower than just using setPixel!). Solutions that do this will receive no credit for that function. When drawing an image, you should know that DMA acts as a for loop, but it is done in hardware. You should call DMA for each row of the image and let DMA handle drawing all of the columns in that row of the image.

For drawing a fullscreen image, a single DMA call suffices. Why? Try implementing this in your code.

3.4        GBA Controls
Here are the inputs from the GameBoy based on the keyboard we’ve configured for the recommended emulator mednafen (these are the same as the default controls for vbam, an alternate emulator):

Gameboy
Keyboard
Start
Enter
Select
Backspace
A
Z
B
X
L
A
R
S
The directional arrows are mapped to the same directional arrows on the keyboard.