API tools faq
paste
Guest User

Untitled

a guest
Jul 17th, 2018
67
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 30.89 KB | None | 0 0
raw download clone embed print report
  1. /*********************************************************************
  2. *
  3. * main.c
  4. *
  5. ********************************************************************/
  6.  
  7. #include "myLib.h"
  8. #include "bb.h"
  9. #include "b1.h"
  10. #include "b2.h"
  11. #include "b3.h"
  12. #include "music2.h"
  13. #include "ding.h"
  14. #include "monkey.h"
  15. #include <stdio.h>
  16.  
  17. #define MASKCOL (0x1FF)
  18. #define MASKROW (0XFF)
  19. #define MAXWIDTH 239
  20. #define MAXHEIGHT 159
  21. #define NUMSPRITES 20
  22. #define B1 1
  23. #define B2 2
  24. #define B3 3
  25.  
  26. int buttons;
  27. int lastButtons;
  28. int playSound;
  29. int playing;
  30. int downSprite;
  31.  
  32. #define DOWN_STILL 0
  33. #define DOWN_WALKING 1
  34. #define UP_STILL 2
  35. #define UP_WALKING 3
  36. #define RIGHT_STILL 4
  37. #define RIGHT_WALKING 5
  38. #define LEFT_STILL 6
  39. #define LEFT_WALKING 7
  40. int previousSpriteState;
  41. int spriteState = DOWN_STILL;
  42. int walkCounter = 0;
  43.  
  44. int hOff=0;
  45. int vOff=0;
  46.  
  47. OBJ_ATTR shadowOAM[128];
  48.  
  49. int monkeyRow = 120; //this is where pikachu is on the visible part of the map
  50. int monkeyCol = 119;
  51. int monkeyBigRow; //this is where pikachu is on the entire map
  52. int monkeyBigCol;
  53.  
  54. void ham_VBAText(char* str, ...);
  55.  
  56. // Prototypes
  57. void setupInterrupts(void); // Turns on interrupt
  58. void enableVBlankInterrupt(); // get interrupts from VBlank
  59. void interruptHandler(void); // Function that gets called when interrupt occurs
  60. // void is the same as having it blank or closed
  61.  
  62. int vblankcount = 0; // public variable that keeps track of current variable
  63. // updated every time interruptHandler is called
  64. int timerinterval = -((1<<24) / MUSIC2FREQ); // time between samples
  65. int timerinterval2 = -((1<<24) / DINGFREQ);
  66.  
  67. int start; // vblankcount when we start the music
  68. int start2;
  69.  
  70. int numvblanks = VBLANKFREQ*MUSIC2LEN/MUSIC2FREQ; // how long our sound is in vblanks
  71. int numvblanks2 = VBLANKFREQ*DINGLEN/DINGFREQ;
  72.  
  73. /*int spriteCol;
  74. int rDel;
  75. int cDel;
  76.  
  77. int sprite1;
  78. int sprite2;
  79. int sprite3;*/
  80.  
  81. int row1;
  82. int row2;
  83. int row3;
  84. int row4;
  85. int col1;
  86. int col2;
  87. int col3;
  88. int col4;
  89. int vel1;
  90. int vel2;
  91. int vel3;
  92. int vel4;
  93.  
  94. int bRow1;
  95. int bRow2;
  96. int bCol1;
  97. int bCol2;
  98. int bVel1;
  99. int bVel2;
  100.  
  101.  
  102. int main(void)
  103. {
  104. /*sprite1 = rand()%19+1;
  105. sprite2 = rand()%19+1;
  106. sprite3 = rand()%19+1;
  107.  
  108. spriteCol = rand()%240;
  109. rDel = rand()%2;
  110. cDel = spriteCol;*/
  111.  
  112. row1 = 0;
  113. row2 = 0;
  114. row3 = 0;
  115. row4 = 0;
  116. col1 = rand()%60;
  117. col2 = rand()%120+60;
  118. col3 = rand()%180+120;
  119. col4 = rand()%240+180;
  120. vel1 = rand()%2+1;
  121. vel2 = rand()%2+1;
  122. vel3 = rand()%2+1;
  123. vel4 = rand()%2+1;
  124.  
  125. bRow1 = 0;
  126. bRow2 = 0;
  127. bCol1 = rand()%240;
  128. bCol2 = rand()%240;
  129. bVel1 = rand()%2+1;
  130. bVel2 = rand()%2+1;
  131.  
  132. int i;
  133. int state = B1;
  134. playSound = 1;
  135.  
  136. /*Sprite sprites[NUMSPRITES] =
  137. {{0,rand()%240,SPRITEOFFSET16(5,0),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  138. {0,rand()%240,SPRITEOFFSET16(5,2),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  139. {0,rand()%240,SPRITEOFFSET16(5,4),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  140. {0,rand()%240,SPRITEOFFSET16(5,6),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  141. {0,rand()%240,SPRITEOFFSET16(5,8),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  142. {0,rand()%240,SPRITEOFFSET16(5,10),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  143. {0,rand()%240,SPRITEOFFSET16(5,12),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  144. {0,rand()%240,SPRITEOFFSET16(5,14),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  145. {0,rand()%240,SPRITEOFFSET16(5,16),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  146. {0,rand()%240,SPRITEOFFSET16(5,18),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  147. {0,rand()%240,SPRITEOFFSET16(7,0),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  148. {0,rand()%240,SPRITEOFFSET16(7,2),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  149. {0,rand()%240,SPRITEOFFSET16(7,4),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  150. {0,rand()%240,SPRITEOFFSET16(7,6),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  151. {0,rand()%240,SPRITEOFFSET16(7,8),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  152. {0,rand()%240,SPRITEOFFSET16(7,10),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  153. {0,rand()%240,SPRITEOFFSET16(7,12),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  154. {0,rand()%240,SPRITEOFFSET16(7,14),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  155. {0,rand()%240,SPRITEOFFSET16(7,16),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel},
  156. {0,rand()%240,SPRITEOFFSET16(7,18),ATTR0_SQUARE,ATTR1_SIZE16,16,16,rand()%2+1,cDel}};*/
  157.  
  158. dmaTransfer(&CHARBLOCKBASE[4], monkeyTiles, 32768/2, DMA_ON);
  159.  
  160. for(i=0; i<128; i++)
  161. {
  162. OAM[i].attr0 |= ATTR0_HIDE;
  163. }
  164.  
  165. setupInterrupts(); // only need to setup once
  166.  
  167. // Enable sound (Master control)
  168. REG_SOUNDCNT_X = SND_ENABLED;
  169.  
  170. // enable and reset Direct Sound channel A, at full volume,
  171. // using Timer 0 to determine frequency
  172. REG_SOUNDCNT_H = SND_OUTPUT_RATIO_100 | // volume 100%
  173. DSA_OUTPUT_RATIO_100 | // volume of channel A to 100%
  174. DSB_OUTPUT_RATIO_100 |
  175. DSA_OUTPUT_TO_BOTH | // both speaker
  176. DSB_OUTPUT_TO_BOTH |
  177. DSA_TIMER0 | // timer 0
  178. DSB_TIMER1 |
  179. DSB_FIFO_RESET |
  180. DSA_FIFO_RESET; // flag that it need to be reset when empty
  181.  
  182. // we don’t want to mess with sound channels 1-4
  183. REG_SOUNDCNT_L = 0;
  184.  
  185. /*****************************************************************
  186. *
  187. * Step 1 -- Store Tile Images
  188. *
  189. ****************************************************************/
  190. DMA[3].src = b1Tiles;
  191. DMA[3].dst = CHARBLOCKBASE;
  192. DMA[3].cnt = b1TilesLen/2 | DMA_ON;
  193. /*****************************************************************
  194. *
  195. * Step 2 -- Store map
  196. *
  197. ****************************************************************/
  198. DMA[3].src = b1Map;
  199. DMA[3].dst = SCREENBLOCKBASE + 27;
  200. DMA[3].cnt = b1MapLen/2 | DMA_ON;
  201.  
  202. /*****************************************************************
  203. *
  204. * Step 3 -- Store palette
  205. *
  206. ****************************************************************/
  207. DMA[3].src = b1Pal;
  208. DMA[3].dst = PALETTE;
  209. DMA[3].cnt = b1PalLen/2 | DMA_ON;
  210.  
  211. /*****************************************************************
  212. *
  213. * Step 4 -- Set image controls
  214. *
  215. ****************************************************************/
  216. REG_DISPCTL = MODE0 | BG0_ENABLE | SPRITE_ENABLE;
  217. REG_BG0HOFS = 0;
  218. REG_BG0VOFS = 0;
  219.  
  220. REG_BG0CNT = BG_4BPP | BG_REG_64x64 | BG_SIZE1 | SBB(27) | COLOR256 | CBB(0);
  221.  
  222. shadowOAM[0].attr0 = monkeyRow | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  223. shadowOAM[0].attr1 = monkeyCol | ATTR1_SIZE32;
  224. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,0)) | (0 << 12);
  225.  
  226. shadowOAM[1].attr0 = row1 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  227. shadowOAM[1].attr1 = col1 | ATTR1_SIZE16;
  228. shadowOAM[1].attr2 = (SPRITEOFFSET16(7,0)) | (0 << 12);
  229.  
  230. shadowOAM[2].attr0 = row2 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  231. shadowOAM[2].attr1 = col2 | ATTR1_SIZE16;
  232. shadowOAM[2].attr2 = (SPRITEOFFSET16(7,6)) | (0 << 12);
  233.  
  234. shadowOAM[3].attr0 = row3 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  235. shadowOAM[3].attr1 = col3 | ATTR1_SIZE16;
  236. shadowOAM[3].attr2 = (SPRITEOFFSET16(5,14)) | (0 << 12);
  237.  
  238. shadowOAM[4].attr0 = row4 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  239. shadowOAM[4].attr1 = col4 | ATTR1_SIZE16;
  240. shadowOAM[4].attr2 = (SPRITEOFFSET16(7,14)) | (0 << 12);
  241.  
  242. shadowOAM[5].attr0 = bRow1 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  243. shadowOAM[5].attr1 = bCol1 | ATTR1_SIZE16;
  244. shadowOAM[5].attr2 = (SPRITEOFFSET16(5,20)) | (0 << 12);
  245.  
  246. shadowOAM[6].attr0 = bRow2 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  247. shadowOAM[6].attr1 = bCol2 | ATTR1_SIZE16;
  248. shadowOAM[6].attr2 = (SPRITEOFFSET16(7,20)) | (0 << 12);
  249.  
  250. /*shadowOAM[sprite1].attr0 = (sprites[sprite1].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  251. shadowOAM[sprite1].attr1 = (sprites[sprite1].col & MASKCOL) | ATTR1_SIZE16;
  252. shadowOAM[sprite1].attr2 = sprites[sprite1].start;
  253.  
  254. shadowOAM[sprite2].attr0 = (sprites[sprite2].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  255. shadowOAM[sprite2].attr1 = (sprites[sprite2].col & MASKCOL) | ATTR1_SIZE16;
  256. shadowOAM[sprite2].attr2 = sprites[sprite2].start;
  257.  
  258. shadowOAM[sprite3].attr0 = (sprites[sprite3].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  259. shadowOAM[sprite3].attr1 = (sprites[sprite3].col & MASKCOL) | ATTR1_SIZE16;
  260. shadowOAM[sprite3].attr2 = sprites[sprite3].start;*/
  261.  
  262. OAM[0] = shadowOAM[0];
  263. OAM[1] = shadowOAM[1];
  264. OAM[2] = shadowOAM[2];
  265. OAM[3] = shadowOAM[3];
  266. OAM[4] = shadowOAM[4];
  267. OAM[5] = shadowOAM[5];
  268. OAM[6] = shadowOAM[6];
  269.  
  270. /*OAM[sprite1] = shadowOAM[sprite1];
  271. OAM[sprite2] = shadowOAM[sprite2];
  272. OAM[sprite3] = shadowOAM[sprite3];*/
  273.  
  274.  
  275. if (BUTTON_HELD(BUTTON_LEFT))
  276. {
  277. spriteState = LEFT_WALKING;
  278.  
  279. if(monkeyCol > 0)
  280. {
  281. monkeyCol--;
  282. }
  283.  
  284. }
  285.  
  286. if (BUTTON_HELD(BUTTON_RIGHT))
  287. {
  288. spriteState = RIGHT_WALKING;
  289.  
  290. if(monkeyCol < 220)
  291. {
  292. monkeyCol++;
  293. }
  294. }
  295.  
  296. if(!BUTTON_HELD(BUTTON_LEFT) && !BUTTON_HELD(BUTTON_RIGHT) && !BUTTON_HELD(BUTTON_UP) && !BUTTON_HELD(BUTTON_DOWN))
  297. {
  298. spriteState = DOWN_STILL;
  299. }
  300.  
  301.  
  302. DMA[3].src = monkeyPal;
  303. DMA[3].dst = SPRITE_PALETTE;
  304. DMA[3].cnt = 256 | DMA_ON;
  305.  
  306. while(1)
  307. {
  308. lastButtons = buttons;
  309. buttons = ~(*rawButtons);
  310.  
  311. previousSpriteState = spriteState;
  312.  
  313. //3 falling objects on screen at one time
  314.  
  315. /*shadowOAM[sprite1].attr0 = (sprites[sprite1].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  316. shadowOAM[sprite1].attr1 = (sprites[sprite1].col & MASKCOL) | ATTR1_SIZE16;
  317. shadowOAM[sprite1].attr2 = sprites[sprite1].start;
  318.  
  319. shadowOAM[sprite2].attr0 = (sprites[sprite2].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  320. shadowOAM[sprite2].attr1 = (sprites[sprite2].col & MASKCOL) | ATTR1_SIZE16;
  321. shadowOAM[sprite2].attr2 = sprites[sprite2].start;
  322.  
  323. shadowOAM[sprite3].attr0 = (sprites[sprite3].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  324. shadowOAM[sprite3].attr1 = (sprites[sprite3].col & MASKCOL) | ATTR1_SIZE16;
  325. shadowOAM[sprite3].attr2 = sprites[sprite3].start;*/
  326.  
  327. shadowOAM[0].attr0 = monkeyRow | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  328. shadowOAM[0].attr1 = monkeyCol | ATTR1_SIZE32;
  329. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,0)) | (0 << 12);
  330.  
  331. shadowOAM[1].attr0 = row1 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  332. shadowOAM[1].attr1 = col1 | ATTR1_SIZE16;
  333. shadowOAM[1].attr2 = (SPRITEOFFSET16(7,0)) | (0 << 12);
  334.  
  335. shadowOAM[2].attr0 = row2 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  336. shadowOAM[2].attr1 = col2 | ATTR1_SIZE16;
  337. shadowOAM[2].attr2 = (SPRITEOFFSET16(7,6)) | (0 << 12);
  338.  
  339. shadowOAM[3].attr0 = row3 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  340. shadowOAM[3].attr1 = col3 | ATTR1_SIZE16;
  341. shadowOAM[3].attr2 = (SPRITEOFFSET16(5,14)) | (0 << 12);
  342.  
  343. shadowOAM[4].attr0 = row4 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  344. shadowOAM[4].attr1 = col4 | ATTR1_SIZE16;
  345. shadowOAM[4].attr2 = (SPRITEOFFSET16(7,14)) | (0 << 12);
  346.  
  347. shadowOAM[5].attr0 = bRow1 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  348. shadowOAM[5].attr1 = bCol1 | ATTR1_SIZE16;
  349. shadowOAM[5].attr2 = (SPRITEOFFSET16(5,20)) | (0 << 12);
  350.  
  351. shadowOAM[6].attr0 = bRow2 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  352. shadowOAM[6].attr1 = bCol2 | ATTR1_SIZE16;
  353. shadowOAM[6].attr2 = (SPRITEOFFSET16(7,20)) | (0 << 12);
  354.  
  355. //Moves objects down
  356.  
  357. /*sprites[sprite1].row += sprites[sprite1].rdel;
  358. sprites[sprite2].row += sprites[sprite2].rdel;
  359. sprites[sprite3].row += sprites[sprite3].rdel;*/
  360.  
  361. row1 += vel1;
  362. row2 += vel2;
  363. row3 += vel3;
  364. row4 += vel4;
  365. bRow1 += bVel1;
  366. bRow2 += bVel2;
  367.  
  368. //Changes object and row/column whenever objects reach the bottom of screen
  369.  
  370. /*if(sprites[sprite1].row >= 160)
  371. {
  372. sprites[sprite1].row = 0;
  373. sprites[sprite1].col = rand()%240;
  374. sprite1 = rand()%20+1;
  375. }
  376.  
  377. if(sprites[sprite2].row >= 160)
  378. {
  379.  
  380. sprites[sprite2].row = 0;
  381. sprites[sprite2].col = rand()%240;
  382. sprite2 = rand()%20+1;
  383. }
  384.  
  385. if(sprites[sprite3].row >= 160)
  386. {
  387.  
  388. sprites[sprite3].row = 0;
  389. sprites[sprite3].col = rand()%240;
  390. sprite3 = rand()%20+1;
  391. }*/
  392.  
  393. if(row1 >= 160)
  394. {
  395. row1 = 0;
  396. col1 = rand()%60;
  397. }
  398.  
  399. if(row2 >= 160)
  400. {
  401. row2 = 0;
  402. col2 = rand()%120+60;
  403. }
  404.  
  405. if(row3 >= 160)
  406. {
  407. row3 = 0;
  408. col3 = rand()%180+120;
  409. }
  410.  
  411. if(row4 >= 160)
  412. {
  413. row4 = 0;
  414. col4 = rand()%240+180;
  415. }
  416.  
  417. if(bRow1 >= 160)
  418. {
  419. bRow1 = 0;
  420. bCol1 = rand()%240;
  421. }
  422.  
  423. if(bRow2 >= 160)
  424. {
  425. bRow2 = 0;
  426. bCol2 = rand()%240;
  427. }
  428.  
  429.  
  430. //Collects and hides object when it is caught
  431.  
  432. /*if(((sprites[sprite1].row + 16) == monkeyRow) && ((sprites[sprite1].col + 16) == monkeyCol) && ((sprites[sprite1].row) == monkeyRow + 32) && ((sprites[sprite1].col) == monkeyCol + 32))
  433. {
  434. shadowOAM[sprite1].attr0 = ATTR0_HIDE;
  435. }
  436.  
  437. if(((sprites[sprite1].row + 16) == monkeyRow) && ((sprites[sprite1].col + 16) == monkeyCol) && ((sprites[sprite1].row) == monkeyRow + 32) && ((sprites[sprite1].col) == monkeyCol + 32))
  438. {
  439. shadowOAM[sprite2].attr0 = ATTR0_HIDE;
  440. }
  441.  
  442. if(((sprites[sprite1].row + 16) == monkeyRow) && ((sprites[sprite1].col + 16) == monkeyCol) && ((sprites[sprite1].row) == monkeyRow + 32) && ((sprites[sprite1].col) == monkeyCol + 32))
  443. {
  444. shadowOAM[sprite3].attr0 = ATTR0_HIDE;
  445. }*/
  446.  
  447. if(((row1 + 16) > monkeyRow) && ((col1 + 16) > monkeyCol)
  448. && (row1 < monkeyRow + 32) && (col1 < monkeyCol + 32))
  449. {
  450. playing = 0;
  451.  
  452. // Make sure sound is stopped
  453. REG_TM1CNT = 0; // Timer off
  454. DMA[2].cnt = 0; // DMA off
  455.  
  456. // Now play it
  457. REG_TM1D = timerinterval2; // Set timer to go off every timer interval
  458. REG_TM1CNT = TIMER_ON; // Turn Timer on
  459.  
  460. // use DMA 1 if you are using timer 0 (for sound channel A)
  461. DMA[2].src = ding; // set source to sound
  462. DMA[2].dst = REG_FIFO_B; // Transfer sound data into FIFO A
  463. DMA[2].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  464. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  465. DMA_DESTINATION_FIXED; // destination will not change
  466.  
  467. start2 = vblankcount; // set start to VBlank
  468.  
  469. //shadowOAM[1].attr0 = ATTR0_HIDE;
  470. row1 = 0;
  471. col1 = rand()%60;
  472. }
  473.  
  474. if(((row2 + 16) > monkeyRow) && ((col2 + 16) > monkeyCol)
  475. && (row2 < monkeyRow + 32) && (col2 < monkeyCol + 32))
  476. {
  477. playing = 0;
  478.  
  479. // Make sure sound is stopped
  480. REG_TM1CNT = 0; // Timer off
  481. DMA[2].cnt = 0; // DMA off
  482.  
  483. // Now play it
  484. REG_TM1D = timerinterval2; // Set timer to go off every timer interval
  485. REG_TM1CNT = TIMER_ON; // Turn Timer on
  486.  
  487. // use DMA 1 if you are using timer 0 (for sound channel A)
  488. DMA[2].src = ding; // set source to sound
  489. DMA[2].dst = REG_FIFO_B; // Transfer sound data into FIFO A
  490. DMA[2].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  491. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  492. DMA_DESTINATION_FIXED; // destination will not change
  493.  
  494. start2 = vblankcount; // set start to VBlank
  495.  
  496. //shadowOAM[2].attr0 = ATTR0_HIDE;
  497. row2 = 0;
  498. col2 = rand()%120+60;
  499. }
  500.  
  501. if(((row3 + 16) > monkeyRow) && ((col3 + 16) > monkeyCol)
  502. && (row3 < monkeyRow + 32) && (col3 < monkeyCol + 32))
  503. {
  504. playing = 0;
  505.  
  506. // Make sure sound is stopped
  507. REG_TM1CNT = 0; // Timer off
  508. DMA[2].cnt = 0; // DMA off
  509.  
  510. // Now play it
  511. REG_TM1D = timerinterval2; // Set timer to go off every timer interval
  512. REG_TM1CNT = TIMER_ON; // Turn Timer on
  513.  
  514. // use DMA 1 if you are using timer 0 (for sound channel A)
  515. DMA[2].src = ding; // set source to sound
  516. DMA[2].dst = REG_FIFO_B; // Transfer sound data into FIFO A
  517. DMA[2].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  518. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  519. DMA_DESTINATION_FIXED; // destination will not change
  520.  
  521. start2 = vblankcount; // set start to VBlank
  522.  
  523. //shadowOAM[3].attr0 = ATTR0_HIDE;
  524. row3 = 0;
  525. col3 = rand()%180+120;
  526. }
  527.  
  528. if(((bRow1 + 16) > monkeyRow) && ((bCol1 + 16) > monkeyCol)
  529. && (bRow1 < monkeyRow + 32) && (bCol1 < monkeyCol + 32))
  530. {
  531. bRow1 = 0;
  532. bCol1 = rand()%240;
  533. }
  534.  
  535. if(((bRow2 + 16) > monkeyRow) && ((bCol2 + 16) > monkeyCol)
  536. && (bRow2 < monkeyRow + 32) && (bCol2 < monkeyCol + 32))
  537. {
  538. bRow2 = 0;
  539. bCol2 = rand()%240;
  540. }
  541.  
  542. if (BUTTON_HELD(BUTTON_LEFT))
  543. {
  544. spriteState = LEFT_WALKING;
  545.  
  546. if(monkeyCol > 0)
  547. {
  548. monkeyCol--;
  549. }
  550.  
  551. }
  552.  
  553. if (BUTTON_HELD(BUTTON_RIGHT))
  554. {
  555. spriteState = RIGHT_WALKING;
  556.  
  557. if(monkeyCol < 220)
  558. {
  559. monkeyCol++;
  560. }
  561. }
  562.  
  563. if(!BUTTON_HELD(BUTTON_LEFT) && !BUTTON_HELD(BUTTON_RIGHT) && !BUTTON_HELD(BUTTON_UP) && !BUTTON_HELD(BUTTON_DOWN))
  564. {
  565. spriteState = DOWN_STILL;
  566. }
  567.  
  568. switch(spriteState)
  569. {
  570. case 0: //DOWN
  571. {
  572. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,0));
  573. break;
  574. }
  575. case 1: //WALKING
  576. {
  577. break;
  578. }
  579. case 2: //UP
  580. {
  581. break;
  582. }
  583. case 3: //WALKING
  584. {
  585. break;
  586. }
  587. case 4: //RIGHT
  588. {
  589. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,12));
  590. break;
  591. }
  592. case 5: //WALKING
  593. {
  594. if(previousSpriteState != RIGHT_WALKING)
  595. walkCounter = 0;
  596. if(walkCounter < 6)
  597. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,16));
  598. else if(walkCounter >= 6 && walkCounter < 12)
  599. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,12));
  600. walkCounter ++;
  601. if(walkCounter >=12)
  602. walkCounter = 0;
  603. break;
  604. }
  605. case 6: //LEFT
  606. {
  607. shadowOAM[0].attr2 = (SPRITEOFFSET16(0,4));
  608. break;
  609. }
  610. case 7: //WALKING
  611. {
  612. if(previousSpriteState != LEFT_WALKING)
  613. walkCounter = 0;
  614. if(walkCounter < 6)
  615. shadowOAM[0].attr2 = SPRITEOFFSET16(0,8);
  616. else if(walkCounter >= 6 && walkCounter < 12)
  617. shadowOAM[0].attr2 = SPRITEOFFSET16(0,4);
  618. walkCounter ++;
  619. if(walkCounter >=12)
  620. walkCounter = 0;
  621. break;
  622. }
  623. }
  624.  
  625. if(!playing && playSound)
  626. {
  627. // Make sure sound is stopped
  628. REG_TM0CNT = 0; // Timer off
  629. DMA[1].cnt = 0; // DMA off
  630.  
  631. // Now play it
  632. REG_TM0D = timerinterval; // Set timer to go off every timer interval
  633. REG_TM0CNT = TIMER_ON; // Turn Timer on
  634.  
  635. // use DMA 1 if you are using timer 0 (for sound channel A)
  636. DMA[1].src = music2; // set source to sound
  637. DMA[1].dst = REG_FIFO_A; // Transfer sound data into FIFO A
  638. DMA[1].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  639. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  640. DMA_DESTINATION_FIXED; // destination will not change
  641.  
  642. start = vblankcount; // set start to VBlank
  643.  
  644. playing = 1;
  645. }
  646.  
  647. switch(state)
  648. {
  649. case B1:
  650. {
  651.  
  652. /*if(BUTTON_PRESSED(BUTTON_SELECT))
  653. {
  654. playing = 0;
  655.  
  656. // Make sure sound is stopped
  657. REG_TM1CNT = 0; // Timer off
  658. DMA[2].cnt = 0; // DMA off
  659.  
  660. // Now play it
  661. REG_TM1D = timerinterval2; // Set timer to go off every timer interval
  662. REG_TM1CNT = TIMER_ON; // Turn Timer on
  663.  
  664. // use DMA 1 if you are using timer 0 (for sound channel A)
  665. DMA[2].src = ding; // set source to sound
  666. DMA[2].dst = REG_FIFO_B; // Transfer sound data into FIFO A
  667. DMA[2].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  668. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  669. DMA_DESTINATION_FIXED; // destination will not change
  670.  
  671. start2 = vblankcount; // set start to VBlank
  672.  
  673. }*/
  674.  
  675. if (BUTTON_HELD(BUTTON_LEFT))
  676. {
  677. spriteState = LEFT_WALKING;
  678.  
  679. if(monkeyCol > 0)
  680. {
  681. monkeyCol--;
  682. }
  683. }
  684.  
  685. if (BUTTON_HELD(BUTTON_RIGHT))
  686. {
  687. spriteState = RIGHT_WALKING;
  688.  
  689. if(monkeyCol < 220)
  690. {
  691. monkeyCol++;
  692. }
  693. }
  694.  
  695. if(!BUTTON_HELD(BUTTON_LEFT) && !BUTTON_HELD(BUTTON_RIGHT) && !BUTTON_HELD(BUTTON_UP) && !BUTTON_HELD(BUTTON_DOWN))
  696. {
  697. spriteState = DOWN_STILL;
  698. }
  699.  
  700. if(BUTTON_PRESSED(BUTTON_START))
  701. {
  702. /*****************************************************************
  703. *
  704. * Step 1 -- Store Tile Images
  705. *
  706. ****************************************************************/
  707. DMA[3].src = b2Tiles;
  708. DMA[3].dst = CHARBLOCKBASE;
  709. DMA[3].cnt = b2TilesLen/2 | DMA_ON;
  710.  
  711. /*****************************************************************
  712. *
  713. * Step 2 -- Store map
  714. *
  715. ****************************************************************/
  716. DMA[3].src = b2Map;
  717. DMA[3].dst = SCREENBLOCKBASE + 27;
  718. DMA[3].cnt = b2MapLen/2 | DMA_ON;
  719.  
  720. /*****************************************************************
  721. *
  722. * Step 3 -- Store palette
  723. *
  724. ****************************************************************/
  725. DMA[3].src = b2Pal;
  726. DMA[3].dst = PALETTE;
  727. DMA[3].cnt = b2PalLen/2 | DMA_ON;
  728.  
  729. /*****************************************************************
  730. *
  731. * Step 4 -- Set image controls
  732. *
  733. ****************************************************************/
  734. REG_DISPCTL = MODE0 | BG0_ENABLE | SPRITE_ENABLE;
  735. REG_BG0HOFS = 0;
  736. REG_BG0VOFS = 0;
  737.  
  738. REG_BG0CNT = BG_SIZE1 | SBB(27) | COLOR256 | CBB(0);
  739.  
  740. state = B2;
  741. }
  742.  
  743. break;
  744. }
  745.  
  746. case B2:
  747. {
  748. /*if(BUTTON_PRESSED(BUTTON_SELECT))
  749. {
  750. playing = 0;
  751.  
  752. // Make sure sound is stopped
  753. REG_TM1CNT = 0; // Timer off
  754. DMA[2].cnt = 0; // DMA off
  755.  
  756. // Now play it
  757. REG_TM1D = timerinterval2; // Set timer to go off every timer interval
  758. REG_TM1CNT = TIMER_ON; // Turn Timer on
  759.  
  760. // use DMA 1 if you are using timer 0 (for sound channel A)
  761. DMA[2].src = ding; // set source to sound
  762. DMA[2].dst = REG_FIFO_B; // Transfer sound data into FIFO A
  763. DMA[2].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  764. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  765. DMA_DESTINATION_FIXED; // destination will not change
  766.  
  767. start2 = vblankcount; // set start to VBlank
  768.  
  769. }*/
  770.  
  771. if (BUTTON_HELD(BUTTON_LEFT))
  772. {
  773. spriteState = LEFT_WALKING;
  774.  
  775. if(monkeyCol > 0)
  776. {
  777. monkeyCol--;
  778. }
  779. }
  780.  
  781. if (BUTTON_HELD(BUTTON_RIGHT))
  782. {
  783. spriteState = RIGHT_WALKING;
  784.  
  785. if(monkeyCol < 220)
  786. {
  787. monkeyCol++;
  788. }
  789. }
  790.  
  791. if(!BUTTON_HELD(BUTTON_LEFT) && !BUTTON_HELD(BUTTON_RIGHT) && !BUTTON_HELD(BUTTON_UP) && !BUTTON_HELD(BUTTON_DOWN))
  792. {
  793. spriteState = DOWN_STILL;
  794. }
  795.  
  796. if(BUTTON_PRESSED(BUTTON_START))
  797. {
  798. /*****************************************************************
  799. *
  800. * Step 1 -- Store Tile Images
  801. *
  802. ****************************************************************/
  803. DMA[3].src = b1Tiles;
  804. DMA[3].dst = CHARBLOCKBASE;
  805. DMA[3].cnt = b1TilesLen/2 | DMA_ON;
  806. /*****************************************************************
  807. *
  808. * Step 2 -- Store map
  809. *
  810. ****************************************************************/
  811. DMA[3].src = b1Map;
  812. DMA[3].dst = SCREENBLOCKBASE + 27;
  813. DMA[3].cnt = b1MapLen/2 | DMA_ON;
  814.  
  815. /*****************************************************************
  816. *
  817. * Step 3 -- Store palette
  818. *
  819. ****************************************************************/
  820. DMA[3].src = b1Pal;
  821. DMA[3].dst = PALETTE;
  822. DMA[3].cnt = b1PalLen/2 | DMA_ON;
  823.  
  824. /*****************************************************************
  825. *
  826. * Step 4 -- Set image controls
  827. *
  828. ****************************************************************/
  829. REG_DISPCTL = MODE0 | BG0_ENABLE | SPRITE_ENABLE;
  830. REG_BG0HOFS = 0;
  831. REG_BG0VOFS = 0;
  832.  
  833. REG_BG0CNT = BG_SIZE1 | SBB(27) | COLOR256 | CBB(0);
  834.  
  835. state = B3;
  836. }
  837.  
  838. break;
  839. }
  840.  
  841. case B3:
  842. {
  843. /*if(BUTTON_PRESSED(BUTTON_SELECT))
  844. {
  845. playing = 0;
  846.  
  847. // Make sure sound is stopped
  848. REG_TM1CNT = 0; // Timer off
  849. DMA[2].cnt = 0; // DMA off
  850.  
  851. // Now play it
  852. REG_TM1D = timerinterval2; // Set timer to go off every timer interval
  853. REG_TM1CNT = TIMER_ON; // Turn Timer on
  854.  
  855. // use DMA 1 if you are using timer 0 (for sound channel A)
  856. DMA[2].src = ding; // set source to sound
  857. DMA[2].dst = REG_FIFO_B; // Transfer sound data into FIFO A
  858. DMA[2].cnt = DMA_ON | START_ON_FIFO_EMPTY | // if the FIFO queue is empty DMA
  859. DMA_32 | DMA_REPEAT | // transfer 32 bits at a time and keep repeating
  860. DMA_DESTINATION_FIXED; // destination will not change
  861.  
  862. start2 = vblankcount; // set start to VBlank
  863.  
  864. }*/
  865.  
  866. if (BUTTON_HELD(BUTTON_LEFT))
  867. {
  868. spriteState = LEFT_WALKING;
  869.  
  870. if(monkeyCol > 0)
  871. {
  872. monkeyCol--;
  873. }
  874. }
  875.  
  876. if (BUTTON_HELD(BUTTON_RIGHT))
  877. {
  878. spriteState = RIGHT_WALKING;
  879.  
  880. if(monkeyCol < 220)
  881. {
  882. monkeyCol++;
  883. }
  884. }
  885.  
  886. if(!BUTTON_HELD(BUTTON_LEFT) && !BUTTON_HELD(BUTTON_RIGHT) && !BUTTON_HELD(BUTTON_UP) && !BUTTON_HELD(BUTTON_DOWN))
  887. {
  888. spriteState = DOWN_STILL;
  889. }
  890. if(BUTTON_PRESSED(BUTTON_START))
  891. {
  892. /*****************************************************************
  893. *
  894. * Step 1 -- Store Tile Images
  895. *
  896. ****************************************************************/
  897. DMA[3].src = bbTiles;
  898. DMA[3].dst = CHARBLOCKBASE;
  899. DMA[3].cnt = bbTilesLen/2 | DMA_ON;
  900.  
  901. /*****************************************************************
  902. *
  903. * Step 2 -- Store map
  904. *
  905. ****************************************************************/
  906. DMA[3].src = bbMap;
  907. DMA[3].dst = SCREENBLOCKBASE + 27;
  908. DMA[3].cnt = bbMapLen/2 | DMA_ON;
  909.  
  910. /*****************************************************************
  911. *
  912. * Step 3 -- Store palette
  913. *
  914. ****************************************************************/
  915. DMA[3].src = bbPal;
  916. DMA[3].dst = PALETTE;
  917. DMA[3].cnt = bbPalLen/2 | DMA_ON;
  918.  
  919. /*****************************************************************
  920. *
  921. * Step 4 -- Set image controls
  922. *
  923. ****************************************************************/
  924. REG_DISPCTL = MODE0 | BG0_ENABLE | SPRITE_ENABLE;
  925. REG_BG0HOFS = 0;
  926. REG_BG0VOFS = 0;
  927.  
  928. REG_BG0CNT = BG_SIZE1 | SBB(27) | COLOR256 | CBB(0);
  929.  
  930. state = B1;
  931. }
  932.  
  933. break;
  934. }
  935. }
  936.  
  937. shadowOAM[0].attr0 = monkeyRow | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  938. shadowOAM[0].attr1 = monkeyCol | ATTR1_SIZE32;
  939.  
  940. /*shadowOAM[sprite1].attr0 = (sprites[sprite1].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  941. shadowOAM[sprite1].attr1 = (sprites[sprite1].col & MASKCOL) | ATTR1_SIZE16;
  942. shadowOAM[sprite2].attr0 = (sprites[sprite2].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  943. shadowOAM[sprite2].attr1 = (sprites[sprite2].col & MASKCOL) | ATTR1_SIZE16;
  944. shadowOAM[sprite3].attr0 = (sprites[sprite3].row & MASKROW) | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  945. shadowOAM[sprite3].attr1 = (sprites[sprite3].col & MASKCOL) | ATTR1_SIZE16;*/
  946.  
  947. shadowOAM[1].attr0 = row1 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  948. shadowOAM[1].attr1 = col1 | ATTR1_SIZE16;
  949.  
  950. shadowOAM[2].attr0 = row2 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  951. shadowOAM[2].attr1 = col2 | ATTR1_SIZE16;
  952.  
  953. shadowOAM[3].attr0 = row3 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  954. shadowOAM[3].attr1 = col3 | ATTR1_SIZE16;
  955.  
  956. shadowOAM[5].attr0 = bRow1 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  957. shadowOAM[5].attr1 = bCol1 | ATTR1_SIZE16;
  958.  
  959. shadowOAM[6].attr0 = bRow2 | ATTR0_REGULAR | ATTR0_NORMAL | ATTR0_4BPP | ATTR0_SQUARE;
  960. shadowOAM[6].attr1 = bCol2 | ATTR1_SIZE16;
  961.  
  962. OAM[0] = shadowOAM[0];
  963.  
  964. /*OAM[sprite1] = shadowOAM[sprite1];
  965. OAM[sprite2] = shadowOAM[sprite2];
  966. OAM[sprite3] = shadowOAM[sprite3];*/
  967.  
  968. OAM[1] = shadowOAM[1];
  969. OAM[2] = shadowOAM[2];
  970. OAM[3] = shadowOAM[3];
  971. OAM[4] = shadowOAM[4];
  972. OAM[5] = shadowOAM[5];
  973. OAM[6] = shadowOAM[6];
  974.  
  975. waitForVblank();
  976.  
  977. // Update the offset registers.
  978. monkeyBigRow = monkeyRow + vOff;
  979. monkeyBigCol = monkeyCol + hOff;
  980. ham_VBAText("(%d,%d) hOff: %d vOff: %d\n", monkeyBigCol, monkeyBigRow, hOff, vOff);
  981. REG_BG0HOFS = hOff;
  982. REG_BG0VOFS = vOff;
  983. }
  984.  
  985. return 0;
  986. }
  987.  
  988. void setupInterrupts(void)
  989. {
  990. REG_IME = 0x0; // disable interrupts
  991. REG_INTERRUPT = (u32)interruptHandler; // set int handler
  992. enableVBlankInterrupt(); // Function to enable vb ints
  993. REG_IME = 0x1; // Enable interrupts
  994. }
  995. void enableVBlankInterrupt()
  996. {
  997. REG_DISPSTAT |= INT_VBLANK_ENABLE; // Make display generate vblank interrupts
  998. // This is the sender
  999. REG_IE = REG_IE | INT_VB; // Enable vblank interrupt detection
  1000. // This is the receiver
  1001. }
  1002.  
  1003. void interruptHandler(void)
  1004. {
  1005. REG_IME = 0; //disable interrupts
  1006.  
  1007. // Check which event happened,
  1008. // and do something if you care about it
  1009. if (REG_IF == INT_VB)
  1010. {
  1011. // A vblank happened, increment counter
  1012. vblankcount++; // Static declared elsewhere
  1013. if( (vblankcount - start) >= numvblanks)
  1014. {
  1015. // Make sure sound is stopped
  1016. REG_TM0CNT = 0; // Timer off
  1017. DMA[1].cnt = 0; // DMA off
  1018. playing = 0;
  1019. }
  1020.  
  1021. if( (vblankcount - start2) >= numvblanks2)
  1022. {
  1023. // Make sure sound is stopped
  1024. REG_TM1CNT = 0; // Timer off
  1025. DMA[2].cnt = 0; // DMA off
  1026. }
  1027.  
  1028. }
  1029. REG_IF = REG_IF; // Tell GBA that interrupt has
  1030. // been handled
  1031. REG_IME = 1; // enable interrupts
  1032. }
  1033.  
  1034. void dmaTransfer(void *destination, const void *source, u32 chunks, u32 mode)
  1035. {
  1036. DMA_MEMORY[3].source = source;
  1037. DMA_MEMORY[3].destination = destination;
  1038. DMA_MEMORY[3].control = chunks | mode;
  1039. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!