Richard Ellingworth / Gameduino

Library for communicating with a Gameduino shield. Provides colour VGA display, hardware sprites with collision detection and stero sound. See http://excamera.com/sphinx/gameduino/ for more details.

Dependents:   GameduinoTest SimpleGameduinoTest RobotRic

Note that to use this library you must also import the CommonTypes library because this library uses it.

To get an mbed talking to a Gameduino shield all you really have to do is connect the Gameduino to the SPI bus. I did it using an LPC11U24 mbed and wired it to the Gameduino as follows:

  • mbed pin...................Gameduino pin
  • 5 (MOSI)...................11 (MOSI)
  • 6 (MISO)...................12 (MISO)
  • 7 (SCK)....................13 (SCK)
  • 8..........................9 (SEL)
  • 40 (VOUT)..................5V and 3.3V
  • 1 (GND)....................GND

mbed pins 5, 6 and 7 make up the SPI datalink. mbed pin 8 should be configured as a digital output and is driven low to communicate with the Gameduino.

Probably best to run the whole lot off a regulated 5V supply rather than relying on the 5V supply from the USB cable. I have had problems with the mbed's 3.3V VOUT supply. If the USB voltage is very low (nearer 4V than 5V) then the mbed's 3.3V regulator won't work properly and can't provide much current. I struggled to draw 10 mA for an LED. These problems go away if you power everything off an external 5V supply. It also means you can unplug the mbed from your computer of course.

Mounting the Gameduino is a bit awkward. I put it on some stripboard using 3 SIL sockets designed for an Arduino. Then I mounted the mbed alongside using two 20 pin SIL sockets. Unfortunately Arduino shields like the Gameduino don't fit nicely on a 0.1 inch grid (like the mbed does) so some connections have to be made using flying wires.

Here are some screenshots:

/media/uploads/RichardE/_scaled_img_0055_compressed.jpg

/media/uploads/RichardE/_scaled_img_0057_compressed.jpg

The code for generating this last display is found here:

Import programGameduinoTest

More complicated test program that generates text, coloured sprites and sound.

Last commit 18 Nov 2012 by Richard Ellingworth

Here's the games console:

/media/uploads/RichardE/_scaled_img_0058_compressed.jpg

and the insides. Don't worry about the cables and the 8 pin chips. You don't need them if all you want is a display. They are an RS485 chip and a serial EEPROM.

/media/uploads/RichardE/_scaled_img_0059_compressed.jpg

Gameduino.cpp@0:d199d2362859, 2012-11-07 (annotated)

Committer:
RichardE
Date:
Wed Nov 07 21:48:11 2012 +0000
Revision:
0:d199d2362859
Child:
3:a1c856358996
For communication with a Gameduino shield which provides a colour VGA display, sprites with hardware collision detection and stereo sound.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
RichardE 0:d199d2362859 1 /*
RichardE 0:d199d2362859 2 * SOURCE FILE : Gameduino.cpp
RichardE 0:d199d2362859 3 *
RichardE 0:d199d2362859 4 * Definition of class Gameduino.
RichardE 0:d199d2362859 5 * Each instance of this class allows communication with
RichardE 0:d199d2362859 6 * a Gameduino shield over an SPI communications link.
RichardE 0:d199d2362859 7 *
RichardE 0:d199d2362859 8 */
RichardE 0:d199d2362859 9
RichardE 0:d199d2362859 10 #include "Gameduino.h" // this module's prototypes
RichardE 0:d199d2362859 11 #include "font8x8.h" // default font
RichardE 0:d199d2362859 12
RichardE 0:d199d2362859 13 /***************/
RichardE 0:d199d2362859 14 /* CONSTRUCTOR */
RichardE 0:d199d2362859 15 /***************/
RichardE 0:d199d2362859 16 // Pass pointer to SPI datalink in spi.
RichardE 0:d199d2362859 17 // Pass pointer to chip select in cs.
RichardE 0:d199d2362859 18 Gameduino::Gameduino( SPI *spi, DigitalOut *cs ) :
RichardE 0:d199d2362859 19 spi( spi ),
RichardE 0:d199d2362859 20 cs( cs ),
RichardE 0:d199d2362859 21 spr( 0 )
RichardE 0:d199d2362859 22 {
RichardE 0:d199d2362859 23 }
RichardE 0:d199d2362859 24
RichardE 0:d199d2362859 25 /**************/
RichardE 0:d199d2362859 26 /* DESTRUCTOR */
RichardE 0:d199d2362859 27 /**************/
RichardE 0:d199d2362859 28 Gameduino::~Gameduino() {
RichardE 0:d199d2362859 29 }
RichardE 0:d199d2362859 30
RichardE 0:d199d2362859 31 /*****************************************************/
RichardE 0:d199d2362859 32 /* INITIALISE CONNECTION TO ADAPTER AND RESET THINGS */
RichardE 0:d199d2362859 33 /*****************************************************/
RichardE 0:d199d2362859 34 void Gameduino::begin( void ) {
RichardE 0:d199d2362859 35 // Wait a bit to allow Gameduino to boot.
RichardE 0:d199d2362859 36 wait_ms( 250 );
RichardE 0:d199d2362859 37 // Deselect the Gameduino.
RichardE 0:d199d2362859 38 *cs = 1;
RichardE 0:d199d2362859 39 wr( J1_RESET, 1 ); // HALT coprocessor
RichardE 0:d199d2362859 40 wr( VIDEO_MODE, MODE_800x600_72 );
RichardE 0:d199d2362859 41 __wstart( RAM_SPR ); // Hide all sprites
RichardE 0:d199d2362859 42 for( int i = 0; i < 512; i++ ) {
RichardE 0:d199d2362859 43 xhide();
RichardE 0:d199d2362859 44 }
RichardE 0:d199d2362859 45 __end();
RichardE 0:d199d2362859 46 fill( RAM_PIC, 0, 1024 * 10 ); // Zero all character RAM
RichardE 0:d199d2362859 47 fill( RAM_SPRPAL, 0, 2048 ); // Sprite palletes black
RichardE 0:d199d2362859 48 fill( RAM_SPRIMG, 0, 64 * 256 );// Clear all sprite data
RichardE 0:d199d2362859 49 fill( VOICES, 0, 256 ); // Silence
RichardE 0:d199d2362859 50 fill( PALETTE16A, 0, 128 ); // Black 16-, 4-palletes and COMM
RichardE 0:d199d2362859 51 wr16( SCROLL_X, 0 );
RichardE 0:d199d2362859 52 wr16( SCROLL_Y, 0 );
RichardE 0:d199d2362859 53 wr( JK_MODE, 0 );
RichardE 0:d199d2362859 54 wr( SPR_DISABLE, 0 );
RichardE 0:d199d2362859 55 wr( SPR_PAGE, 0 );
RichardE 0:d199d2362859 56 wr( IOMODE, 0 );
RichardE 0:d199d2362859 57 wr16( BG_COLOR, 0 );
RichardE 0:d199d2362859 58 wr16( SAMPLE_L, 0 );
RichardE 0:d199d2362859 59 wr16( SAMPLE_R, 0 );
RichardE 0:d199d2362859 60 wr16( SCREENSHOT_Y, 0 );
RichardE 0:d199d2362859 61 wr( MODULATOR, 64 );
RichardE 0:d199d2362859 62 }
RichardE 0:d199d2362859 63
RichardE 0:d199d2362859 64 static const UInt8 stretch[16] = {
RichardE 0:d199d2362859 65 0x00, 0x03, 0x0c, 0x0f,
RichardE 0:d199d2362859 66 0x30, 0x33, 0x3c, 0x3f,
RichardE 0:d199d2362859 67 0xc0, 0xc3, 0xcc, 0xcf,
RichardE 0:d199d2362859 68 0xf0, 0xf3, 0xfc, 0xff
RichardE 0:d199d2362859 69 };
RichardE 0:d199d2362859 70
RichardE 0:d199d2362859 71 /***********************************************/
RichardE 0:d199d2362859 72 /* SET DEFAULT ASCII CHARACTER SET AND PALETTE */
RichardE 0:d199d2362859 73 /***********************************************/
RichardE 0:d199d2362859 74 void Gameduino::ascii( void ) {
RichardE 0:d199d2362859 75 UInt8 b, h, l;
RichardE 0:d199d2362859 76 UInt16 address;
RichardE 0:d199d2362859 77 const UInt8 *ptr = font8x8;
RichardE 0:d199d2362859 78 for( UInt16 i = 0; i < 768; ++i ) {
RichardE 0:d199d2362859 79 b = *ptr++;
RichardE 0:d199d2362859 80 h = stretch[ b >> 4 ];
RichardE 0:d199d2362859 81 l = stretch[ b & 0xf ];
RichardE 0:d199d2362859 82 address = RAM_CHR + ( ' ' << 4 ) + ( i << 1 );
RichardE 0:d199d2362859 83 wr( address++, h );
RichardE 0:d199d2362859 84 wr( address, l );
RichardE 0:d199d2362859 85 }
RichardE 0:d199d2362859 86 for( UInt16 i = 0x20; i < 0x80; ++ i) {
RichardE 0:d199d2362859 87 setpal( 4 * i + 0, TRANSPARENT );
RichardE 0:d199d2362859 88 setpal( 4 * i + 3, RGB (255, 255, 255 ) );
RichardE 0:d199d2362859 89 }
RichardE 0:d199d2362859 90 fill( RAM_PIC, ' ', 4096 );
RichardE 0:d199d2362859 91 }
RichardE 0:d199d2362859 92
RichardE 0:d199d2362859 93 /****************************/
RichardE 0:d199d2362859 94 /* START AN SPI TRANSACTION */
RichardE 0:d199d2362859 95 /****************************/
RichardE 0:d199d2362859 96 // Pass address to read or write to in address.
RichardE 0:d199d2362859 97 // Bit 15 must be set for a write.
RichardE 0:d199d2362859 98 void Gameduino::__start( UInt16 address ) {
RichardE 0:d199d2362859 99 *cs = 0; // select Gameduino
RichardE 0:d199d2362859 100 spi->write( ( address >> 8 ) & 0xFF ); // send bits 8 to 15 of address
RichardE 0:d199d2362859 101 spi->write( address & 0xFF ); // send bits 0 to 7 of address
RichardE 0:d199d2362859 102 }
RichardE 0:d199d2362859 103
RichardE 0:d199d2362859 104 /**********************************/
RichardE 0:d199d2362859 105 /* START AN SPI WRITE TRANSACTION */
RichardE 0:d199d2362859 106 /**********************************/
RichardE 0:d199d2362859 107 // Pass address write to in address.
RichardE 0:d199d2362859 108 void Gameduino::__wstart( UInt16 address ) {
RichardE 0:d199d2362859 109 __start( 0x8000 | address );
RichardE 0:d199d2362859 110 }
RichardE 0:d199d2362859 111
RichardE 0:d199d2362859 112 /******************************/
RichardE 0:d199d2362859 113 /* START A SPRITE TRANSACTION */
RichardE 0:d199d2362859 114 /******************************/
RichardE 0:d199d2362859 115 // Use this before calling xhide, xsprite or TransferSprite.
RichardE 0:d199d2362859 116 // Pass sprite number to start at in sprnum.
RichardE 0:d199d2362859 117 void Gameduino::__wstartspr( UInt8 sprnum ) {
RichardE 0:d199d2362859 118 __wstart( RAM_SPR + ( sprnum << 2 ) );
RichardE 0:d199d2362859 119 spr = 0;
RichardE 0:d199d2362859 120 }
RichardE 0:d199d2362859 121
RichardE 0:d199d2362859 122 /*************************/
RichardE 0:d199d2362859 123 /* TRANSFER BYTE VIA SPI */
RichardE 0:d199d2362859 124 /*************************/
RichardE 0:d199d2362859 125 // Use only after a call to __start or __wstart.
RichardE 0:d199d2362859 126 // Pass data to send in data.
RichardE 0:d199d2362859 127 UInt8 Gameduino::__tr8( UInt8 data ) {
RichardE 0:d199d2362859 128 return (UInt8)spi->write( data );
RichardE 0:d199d2362859 129 }
RichardE 0:d199d2362859 130
RichardE 0:d199d2362859 131 /********************************/
RichardE 0:d199d2362859 132 /* TRANSFER 16 BIT WORD VIA SPI */
RichardE 0:d199d2362859 133 /********************************/
RichardE 0:d199d2362859 134 // Use only after a call to __start or __wstart.
RichardE 0:d199d2362859 135 // Pass data to send in data.
RichardE 0:d199d2362859 136 UInt8 Gameduino::__tr16( UInt16 data ) {
RichardE 0:d199d2362859 137 UInt16 result;
RichardE 0:d199d2362859 138 result = spi->write( data & 0xFF ); // send and get bits 0 to 7
RichardE 0:d199d2362859 139 result |= ( spi->write( ( data >> 8 ) & 0xFF ) << 8 ); // send and get bits 8 to 15
RichardE 0:d199d2362859 140 return result; // return word read
RichardE 0:d199d2362859 141 }
RichardE 0:d199d2362859 142
RichardE 0:d199d2362859 143 /**************************/
RichardE 0:d199d2362859 144 /* END AN SPI TRANSACTION */
RichardE 0:d199d2362859 145 /**************************/
RichardE 0:d199d2362859 146 void Gameduino::__end( void ) {
RichardE 0:d199d2362859 147 *cs = 1; // deselect Gameduino
RichardE 0:d199d2362859 148 }
RichardE 0:d199d2362859 149
RichardE 0:d199d2362859 150 /***************/
RichardE 0:d199d2362859 151 /* READ A BYTE */
RichardE 0:d199d2362859 152 /***************/
RichardE 0:d199d2362859 153 // Pass address in Gameduino memory to read from.
RichardE 0:d199d2362859 154 // Returns byte at that address.
RichardE 0:d199d2362859 155 UInt8 Gameduino::rd( UInt16 address ) {
RichardE 0:d199d2362859 156 __start( address ); // start SPI read operation
RichardE 0:d199d2362859 157 UInt8 data = __tr8( 0 ); // read byte from Gameduino
RichardE 0:d199d2362859 158 __end(); // end of SPI operation
RichardE 0:d199d2362859 159 return data; // return byte read
RichardE 0:d199d2362859 160 }
RichardE 0:d199d2362859 161
RichardE 0:d199d2362859 162 /**********************/
RichardE 0:d199d2362859 163 /* READ A 16 BIT WORD */
RichardE 0:d199d2362859 164 /**********************/
RichardE 0:d199d2362859 165 // Pass address in Gameduino memory to read from.
RichardE 0:d199d2362859 166 // Returns byte at that address.
RichardE 0:d199d2362859 167 UInt16 Gameduino::rd16( UInt16 address ) {
RichardE 0:d199d2362859 168 __start( address ); // start SPI read operation
RichardE 0:d199d2362859 169 UInt16 data = __tr16( 0 );
RichardE 0:d199d2362859 170 __end(); // end of SPI operation
RichardE 0:d199d2362859 171 return data; // return word read
RichardE 0:d199d2362859 172 }
RichardE 0:d199d2362859 173
RichardE 0:d199d2362859 174 /****************/
RichardE 0:d199d2362859 175 /* WRITE A BYTE */
RichardE 0:d199d2362859 176 /****************/
RichardE 0:d199d2362859 177 // Pass address to write to in address.
RichardE 0:d199d2362859 178 // Pass data to write in data.
RichardE 0:d199d2362859 179 void Gameduino::wr( UInt16 address, UInt8 data ) {
RichardE 0:d199d2362859 180 __wstart( address ); // start SPI write operation
RichardE 0:d199d2362859 181 __tr8( data );
RichardE 0:d199d2362859 182 __end(); // end of SPI operation
RichardE 0:d199d2362859 183 }
RichardE 0:d199d2362859 184
RichardE 0:d199d2362859 185 /***********************/
RichardE 0:d199d2362859 186 /* WRITE A 16 BIT WORD */
RichardE 0:d199d2362859 187 /***********************/
RichardE 0:d199d2362859 188 // Pass address to write to in address.
RichardE 0:d199d2362859 189 // Pass data to write in data.
RichardE 0:d199d2362859 190 void Gameduino::wr16( UInt16 address, UInt16 data ) {
RichardE 0:d199d2362859 191 __wstart( address );
RichardE 0:d199d2362859 192 __tr16( data );
RichardE 0:d199d2362859 193 __end();
RichardE 0:d199d2362859 194 }
RichardE 0:d199d2362859 195
RichardE 0:d199d2362859 196 /*********************************/
RichardE 0:d199d2362859 197 /* FILL AREA OF GAMEDUINO MEMORY */
RichardE 0:d199d2362859 198 /*********************************/
RichardE 0:d199d2362859 199 // Pass address to write to in address.
RichardE 0:d199d2362859 200 // Pass data to write to entire area in data.
RichardE 0:d199d2362859 201 // Pass number of bytes to write in count.
RichardE 0:d199d2362859 202 void Gameduino::fill( UInt16 address, UInt8 data, UInt16 count ) {
RichardE 0:d199d2362859 203 __wstart( address );
RichardE 0:d199d2362859 204 while( count-- ) {
RichardE 0:d199d2362859 205 __tr8( data );
RichardE 0:d199d2362859 206 }
RichardE 0:d199d2362859 207 __end();
RichardE 0:d199d2362859 208 }
RichardE 0:d199d2362859 209
RichardE 0:d199d2362859 210 /***********************************/
RichardE 0:d199d2362859 211 /* COPY DATA INTO GAMEDUINO MEMORY */
RichardE 0:d199d2362859 212 /***********************************/
RichardE 0:d199d2362859 213 // Pass address to write to in address.
RichardE 0:d199d2362859 214 // Pass pointer to source of data in src.
RichardE 0:d199d2362859 215 // Pass number of bytes to copy in count.
RichardE 0:d199d2362859 216 void Gameduino::copy( UInt16 address, const UInt8 *src, UInt16 count ) {
RichardE 0:d199d2362859 217 __wstart( address );
RichardE 0:d199d2362859 218 while( count-- ) {
RichardE 0:d199d2362859 219 __tr8( *src++ );
RichardE 0:d199d2362859 220 }
RichardE 0:d199d2362859 221 __end();
RichardE 0:d199d2362859 222 }
RichardE 0:d199d2362859 223
RichardE 0:d199d2362859 224 /*****************/
RichardE 0:d199d2362859 225 /* HIDE A SPRITE */
RichardE 0:d199d2362859 226 /*****************/
RichardE 0:d199d2362859 227 // Use only after specifying address to write to.
RichardE 0:d199d2362859 228 // Basically just writes 400 twice to SPI.
RichardE 0:d199d2362859 229 void Gameduino::xhide( void ) {
RichardE 0:d199d2362859 230 __tr16( 400 );
RichardE 0:d199d2362859 231 __tr16( 400 );
RichardE 0:d199d2362859 232 spr++;
RichardE 0:d199d2362859 233 }
RichardE 0:d199d2362859 234
RichardE 0:d199d2362859 235 /****************************************/
RichardE 0:d199d2362859 236 /* SEND SPRITE INFORMATION TO GAMEDUINO */
RichardE 0:d199d2362859 237 /****************************************/
RichardE 0:d199d2362859 238 // Use only after specifying address to write to.
RichardE 0:d199d2362859 239 // Pass coordinates in x and y.
RichardE 0:d199d2362859 240 // Pass sprite image number in image.
RichardE 0:d199d2362859 241 // Pass palette selection information in palette (use 0 for 256 colour palette).
RichardE 0:d199d2362859 242 // Pass rotation and flip setting in rot.
RichardE 0:d199d2362859 243 // Pass JK collision information in jk (0 or 1).
RichardE 0:d199d2362859 244 void Gameduino::TransferSprite( Int16 x, Int16 y, UInt8 image, UInt8 palette, Rotation rot, UInt8 jk ) {
RichardE 0:d199d2362859 245 __tr8( x & 0xFF );
RichardE 0:d199d2362859 246 __tr8( ( palette << 4 ) | ( rot << 1 ) | ( ( x >> 8 ) & 1 ) );
RichardE 0:d199d2362859 247 __tr8( y & 0xFF );
RichardE 0:d199d2362859 248 __tr8( ( jk << 7 ) | ( image << 1 ) | ( ( y >> 8 ) & 1 ) );
RichardE 0:d199d2362859 249 }
RichardE 0:d199d2362859 250
RichardE 0:d199d2362859 251 /**************************************************************************/
RichardE 0:d199d2362859 252 /* DRAW A SPRITE AT AN OFFSET FROM AN ORIGIN TAKING INTO ACCOUNT ROTATION */
RichardE 0:d199d2362859 253 /**************************************************************************/
RichardE 0:d199d2362859 254 // Use only after specifying address to write to.
RichardE 0:d199d2362859 255 // Pass origin coordinates in ox and oy.
RichardE 0:d199d2362859 256 // Pass offset from origin in x and y.
RichardE 0:d199d2362859 257 // Pass sprite image number in image.
RichardE 0:d199d2362859 258 // Pass palette selection information in palette (use 0 for 256 colour palette).
RichardE 0:d199d2362859 259 // Pass rotation and flip setting in rot.
RichardE 0:d199d2362859 260 // Pass JK collision information in jk (0 or 1).
RichardE 0:d199d2362859 261 void Gameduino::xsprite( Int16 ox, Int16 oy, Int8 x, Int8 y, UInt8 image, UInt8 palette, Rotation rot, UInt8 jk ) {
RichardE 0:d199d2362859 262 if( rot & 2 ) {
RichardE 0:d199d2362859 263 // Flip X.
RichardE 0:d199d2362859 264 x = -16 - x;
RichardE 0:d199d2362859 265 }
RichardE 0:d199d2362859 266 if( rot & 4 ) {
RichardE 0:d199d2362859 267 // Flip Y.
RichardE 0:d199d2362859 268 y = -16 - y;
RichardE 0:d199d2362859 269 }
RichardE 0:d199d2362859 270 if( rot & 1 ) {
RichardE 0:d199d2362859 271 // Swap X and Y.
RichardE 0:d199d2362859 272 int s;
RichardE 0:d199d2362859 273 s = x; x = y; y = s;
RichardE 0:d199d2362859 274 }
RichardE 0:d199d2362859 275 ox += x;
RichardE 0:d199d2362859 276 oy += y;
RichardE 0:d199d2362859 277 TransferSprite( ox, oy, image, palette, rot, jk );
RichardE 0:d199d2362859 278 spr++;
RichardE 0:d199d2362859 279 }
RichardE 0:d199d2362859 280
RichardE 0:d199d2362859 281 /***********************/
RichardE 0:d199d2362859 282 /* CONSTRUCT RGB VALUE */
RichardE 0:d199d2362859 283 /***********************/
RichardE 0:d199d2362859 284 // Pass red level in r.
RichardE 0:d199d2362859 285 // Pass green level in g.
RichardE 0:d199d2362859 286 // Pass blue level in b.
RichardE 0:d199d2362859 287 // Returns RGB value.
RichardE 0:d199d2362859 288 UInt16 Gameduino::RGB( UInt8 r, UInt8 g, UInt8 b ) {
RichardE 0:d199d2362859 289 return ((((r) >> 3) << 10) | (((g) >> 3) << 5) | ((b) >> 3));
RichardE 0:d199d2362859 290 }
RichardE 0:d199d2362859 291
RichardE 0:d199d2362859 292 /*********************/
RichardE 0:d199d2362859 293 /* SET PALETTE ENTRY */
RichardE 0:d199d2362859 294 /*********************/
RichardE 0:d199d2362859 295 // Pass pallete entry to set in pal.
RichardE 0:d199d2362859 296 // Pass RGB value to store in rgb.
RichardE 0:d199d2362859 297 void Gameduino::setpal( UInt16 pal, UInt16 rgb ) {
RichardE 0:d199d2362859 298 wr16( RAM_PAL + ( pal << 1 ), rgb );
RichardE 0:d199d2362859 299 }
RichardE 0:d199d2362859 300
RichardE 0:d199d2362859 301 /***********************************/
RichardE 0:d199d2362859 302 /* WRITE TEXT AT GIVEN COORDINATES */
RichardE 0:d199d2362859 303 /***********************************/
RichardE 0:d199d2362859 304 // Pass X coordinate in x.
RichardE 0:d199d2362859 305 // Pass Y coordinate in y.
RichardE 0:d199d2362859 306 // Pass pointer to zero terminated text in s.
RichardE 0:d199d2362859 307 void Gameduino::putstr( UInt8 x, UInt8 y, const char *s ) {
RichardE 0:d199d2362859 308 __wstart( RAM_PIC + ( y << 6 ) + x );
RichardE 0:d199d2362859 309 while( *s ) {
RichardE 0:d199d2362859 310 __tr8( *s++ );
RichardE 0:d199d2362859 311 }
RichardE 0:d199d2362859 312 __end();
RichardE 0:d199d2362859 313 }
RichardE 0:d199d2362859 314
RichardE 0:d199d2362859 315 /*********************/
RichardE 0:d199d2362859 316 /* POSITION A SPRITE */
RichardE 0:d199d2362859 317 /*********************/
RichardE 0:d199d2362859 318 // Pass sprite number in spr.
RichardE 0:d199d2362859 319 // Pass X and Y coordinates in x and y.
RichardE 0:d199d2362859 320 // Pass sprite image number in image.
RichardE 0:d199d2362859 321 // Pass palette selection information in palette (use 0 for 256 colour palette).
RichardE 0:d199d2362859 322 // Pass rotation and flip setting in rot.
RichardE 0:d199d2362859 323 // Pass JK collision information in jk (0 or 1).
RichardE 0:d199d2362859 324 void Gameduino::sprite( UInt8 spr, Int16 x, Int16 y, UInt8 image, UInt8 palette, Rotation rot, UInt8 jk ) {
RichardE 0:d199d2362859 325 __wstart( RAM_SPR + ( spr << 2 ) );
RichardE 0:d199d2362859 326 TransferSprite( x, y, image, palette, rot, jk );
RichardE 0:d199d2362859 327 __end();
RichardE 0:d199d2362859 328 }
RichardE 0:d199d2362859 329
RichardE 0:d199d2362859 330 /***********************************/
RichardE 0:d199d2362859 331 /* DRAW 4 SPRITES AS A 2 X 2 BLOCK */
RichardE 0:d199d2362859 332 /***********************************/
RichardE 0:d199d2362859 333 // Pass sprite number for first sprite in spr.
RichardE 0:d199d2362859 334 // Pass X and Y coordinates in x and y. These are coordinates of centre of group.
RichardE 0:d199d2362859 335 // Pass sprite image number for first image in image.
RichardE 0:d199d2362859 336 // Pass palette selection information in palette (use 0 for 256 colour palette).
RichardE 0:d199d2362859 337 // Pass rotation and flip setting in rot.
RichardE 0:d199d2362859 338 // Pass JK collision information in jk (0 or 1).
RichardE 0:d199d2362859 339 void Gameduino::sprite2x2( UInt8 spr, Int16 x, Int16 y, UInt8 image, UInt8 palette, Rotation rot, UInt8 jk ) {
RichardE 0:d199d2362859 340 __wstart( RAM_SPR + ( spr << 2 ) );
RichardE 0:d199d2362859 341 xsprite( x, y, -16, -16, image + 0, palette, rot, jk );
RichardE 0:d199d2362859 342 xsprite( x, y, 0, -16, image + 1, palette, rot, jk );
RichardE 0:d199d2362859 343 xsprite( x, y, -16, 0, image + 2, palette, rot, jk );
RichardE 0:d199d2362859 344 xsprite( x, y, 0, 0, image + 3, palette, rot, jk );
RichardE 0:d199d2362859 345 __end();
RichardE 0:d199d2362859 346 }
RichardE 0:d199d2362859 347
RichardE 0:d199d2362859 348 /**************************************************/
RichardE 0:d199d2362859 349 /* PLOT A NUMBER OF SPRITES RELATIVE TO AN ORIGIN */
RichardE 0:d199d2362859 350 /**************************************************/
RichardE 0:d199d2362859 351 // Use only after calling __wstartspr.
RichardE 0:d199d2362859 352 // Pass X and Y coordinates of origin in ox and oy.
RichardE 0:d199d2362859 353 // Pass pointer to an array of sprplot structures in psp.
RichardE 0:d199d2362859 354 // Pass number of structures in array in count.
RichardE 0:d199d2362859 355 // Pass rotation and flip setting in rot.
RichardE 0:d199d2362859 356 // Pass JK collision information in jk (0 or 1).
RichardE 0:d199d2362859 357 void Gameduino::plots( Int16 ox, Int16 oy, const sprplot *psp, UInt8 count, Rotation rot, UInt8 jk ) {
RichardE 0:d199d2362859 358 while( count-- ) {
RichardE 0:d199d2362859 359 xsprite( ox, oy, psp->x, psp->y, psp->image, psp->palette, rot, jk );
RichardE 0:d199d2362859 360 psp++;
RichardE 0:d199d2362859 361 }
RichardE 0:d199d2362859 362 }
RichardE 0:d199d2362859 363
RichardE 0:d199d2362859 364 /******************************/
RichardE 0:d199d2362859 365 /* WAIT FOR VERTICAL BLANKING */
RichardE 0:d199d2362859 366 /******************************/
RichardE 0:d199d2362859 367 void Gameduino::waitvblank( void ) {
RichardE 0:d199d2362859 368 // Wait until VBLANK register is zero.
RichardE 0:d199d2362859 369 while( rd( VBLANK ) ) {
RichardE 0:d199d2362859 370 // do nothing.
RichardE 0:d199d2362859 371 }
RichardE 0:d199d2362859 372 // Wait until VBLANK register is non-zero.
RichardE 0:d199d2362859 373 while( ! rd( VBLANK ) ) {
RichardE 0:d199d2362859 374 // do nothing.
RichardE 0:d199d2362859 375 }
RichardE 0:d199d2362859 376 // Exit just at the moment VBLANK goes from zero to non-zero.
RichardE 0:d199d2362859 377 }
RichardE 0:d199d2362859 378
RichardE 0:d199d2362859 379 /****************/
RichardE 0:d199d2362859 380 /* MAKE A NOISE */
RichardE 0:d199d2362859 381 /****************/
RichardE 0:d199d2362859 382 // Pass voice number in v.
RichardE 0:d199d2362859 383 // Pass waveform type in wave.
RichardE 0:d199d2362859 384 // Pass frequency in quarter Hz (so 100 Hz is 400) in freq.
RichardE 0:d199d2362859 385 // Pass amplitude for left channel in lamp.
RichardE 0:d199d2362859 386 // Pass amplitude for right channel in ramp.
RichardE 0:d199d2362859 387 void Gameduino::voice( UInt8 v, WaveForm wave, UInt16 freq, UInt8 lamp, UInt8 ramp ) {
RichardE 0:d199d2362859 388 __wstart( VOICES + ( v << 2 ) );
RichardE 0:d199d2362859 389 __tr8( freq & 0xFF );
RichardE 0:d199d2362859 390 __tr8( ( ( freq >> 8 ) & 0xFF ) | ( wave << 7 ) );
RichardE 0:d199d2362859 391 __tr8( lamp );
RichardE 0:d199d2362859 392 __tr8( ramp );
RichardE 0:d199d2362859 393 __end();
RichardE 0:d199d2362859 394 }