API tools faq
paste
Advertisement
Razzim

Systemy Arkanoid

Razzim
Jan 25th, 2016
129
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.96 KB | None | 0 0
raw download clone embed print report
  1. /******************************************************************************/
  2. /* BLINKY.C: LED Flasher */
  3. /******************************************************************************/
  4. // Program zmodyfikowany do potrzeb laboratorium IISI Systemy Wbudowane
  5. /* This file is part of the uVision/ARM development tools. */
  6. /* Copyright (c) 2005-2006 Keil Software. All rights reserved. */
  7. /* This software may only be used under the terms of a valid, current, */
  8. /* end user licence from KEIL for a compatible version of KEIL software */
  9. /* development tools. Nothing else gives you the right to use this software. */
  10. /******************************************************************************/
  11.  
  12. #define uint16_t unsigned int;
  13.  
  14. #include <AT91SAM7X256.H> /* AT91SAMT7X256 definitions */
  15. #include "lcd.h"
  16. #include <string.h>
  17. #include <math.h>
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. #include "adc.h"
  21.  
  22. // deklaracje
  23. extern void InitSpi(void);
  24. extern void InitLcd(void);
  25. extern void LCDClearScreen(void);
  26.  
  27. extern void WriteSpiCommand(unsigned int data);
  28. extern void WriteSpiData(unsigned int data);
  29.  
  30. extern void LCDClearScreen(void);
  31. extern void LCDSetXY(int x, int y);
  32. extern void LCDSetPixel(int x, int y, int color);
  33. extern void LCDSetLine(int x1, int y1, int x2, int y2, int color);
  34. extern void LCDSetRect(int x0, int y0, int x1, int y1, unsigned char fill, int color);
  35. extern void LCDSetCircle(int x0, int y0, int radius, int color);
  36. extern void LCDPutChar(char c, int x, int y, int size, int fcolor, int bcolor);
  37. extern void LCDPutString (char *lcd_string, const char *font_style, unsigned char x, unsigned char y,
  38. unsigned char fcolor, unsigned char bcolor);
  39. extern void LCDPutStr(char *pString, int x, int y, int Size, int fColor, int bColor);
  40. extern void Delay (unsigned long a);
  41.  
  42.  
  43. /********************** Makra i zmienne globalne **************************/
  44. // ARM7X256 Leds Definition
  45.  
  46.  
  47. //maska dla pinow do ktorych podlaczone sa diody, którymi bedziemy sterowac
  48. #define LEDS_MASK (AT91C_PIO_PB20)
  49.  
  50.  
  51. //konfiguracja wybranych linii PIO
  52. //linie pracuja jako GPIO sterowane przez uzutkownika (a nie przez peryferia) = PIO_PER
  53. //ustawienie pinow jako wyjscia = PIO_OER
  54. //odblokowanie mozliwosc zapisu za pomoca rejestru ODSR = PIO_OWER
  55. #define LED_INIT {AT91C_BASE_PIOB->PIO_PER = LEDS_MASK; AT91C_BASE_PIOB->PIO_OER = LEDS_MASK; AT91C_BASE_PIOB->PIO_OWER = LEDS_MASK;}
  56.  
  57.  
  58. //definicja ustawiania stanu niskiego wyjscia PB20 = zgaszenie podswietlenia LED wyswietlacza LCD
  59. #define LED_BCK_OFF AT91C_BASE_PIOB->PIO_CODR = AT91C_PIO_PB20
  60. //definicja ustawiania stanu wysokiego wyjscia PB20 = zalaczenie podswietlenia LED wyswietlacza LCD
  61. #define LED_BCK_ON AT91C_BASE_PIOB->PIO_SODR = AT91C_PIO_PB20
  62.  
  63.  
  64.  
  65. #define LEDS_OFF AT91C_BASE_PIOB->PIO_CODR = LEDS_MASK
  66. //definicja ustawiania stanu wysokiego wyjscia PB20 = zalaczenie podswietlenia LED wyswietlacza LCD
  67. #define LEDS_ON AT91C_BASE_PIOB->PIO_SODR = LEDS_MASK
  68.  
  69.  
  70.  
  71.  
  72.  
  73. //Inputs
  74. #define LEFT_KEY_DOWN (((AT91C_BASE_PIOB->PIO_PDSR) & AT91C_PIO_PB24)==0)
  75. #define RIGHT_KEY_DOWN (((AT91C_BASE_PIOB->PIO_PDSR) & AT91C_PIO_PB25)==0)
  76. #define LEFT_STICK (((AT91C_BASE_PIOA->PIO_PDSR) & AT91C_PIO_PB7)==0)
  77.  
  78. #define INPUTS_INIT {AT91C_BASE_PIOB->PIO_PER = (AT91C_PIO_PB24|AT91C_PIO_PB25); AT91C_BASE_PIOB->PIO_ODR = (AT91C_PIO_PB24|AT91C_PIO_PB25); }
  79.  
  80. /**************************GRA***************************/
  81.  
  82. #define JOYSTICK_LEFT ( ( (AT91C_BASE_PIOA->PIO_PDSR) & AT91C_PIO_PA7 ) == 0 )
  83. #define JOYSTICK_DOWN ( ( (AT91C_BASE_PIOA->PIO_PDSR) & AT91C_PIO_PA8 ) == 0 )
  84. #define JOYSTICK_UP ( ( (AT91C_BASE_PIOA->PIO_PDSR) & AT91C_PIO_PA9 ) == 0 )
  85. #define JOYSTICK_RIGHT ( ( (AT91C_BASE_PIOA->PIO_PDSR) & AT91C_PIO_PA14 ) == 0 )
  86. #define JOYSTICK_HIT ( ( (AT91C_BASE_PIOA->PIO_PDSR) & AT91C_PIO_PA23 ) == 0 )
  87.  
  88. const unsigned char BACKGROUND_COLOR = CYAN ;
  89.  
  90. void showStatusBar(int);
  91.  
  92. enum
  93. {
  94. REDRAW=1,
  95. DO_NOT_REDRAW=2
  96. };
  97.  
  98. enum
  99. {
  100. X = 1,
  101. Y = 0
  102. } ;
  103.  
  104. void delay(unsigned int time)
  105. {
  106. unsigned int i = 0;
  107. time *= 1000 ;
  108. for( i=0; i<time; ++i ) {}
  109. }
  110.  
  111. /****** GRA ******/
  112.  
  113. //Kulka
  114. typedef struct Kulka
  115. {
  116. int kX ; // = 0;
  117. int kY ; // = 0;
  118. int kRadius ; // = 3 ;
  119. unsigned char kColor ; // = BLACK ;
  120. int kRuch;
  121. } Kulka ;
  122.  
  123. Kulka k = {130/2, 130/2, 3, BLACK};
  124.  
  125. //Gracz/deska
  126. typedef struct Gracz
  127. {
  128. int X;
  129. int pkt;
  130. } Gracz;
  131.  
  132. Gracz p = {130/2, 0};
  133.  
  134. static const int ROZMIAR_DESKI;
  135.  
  136. //Klocek
  137. typedef struct Brick
  138. {
  139. int X;
  140. int Y;
  141. int stan;
  142. } Brick;
  143.  
  144. Brick b1 = {30,30,1};
  145.  
  146. Brick b2 = {60,30,1};
  147.  
  148. Brick b3 = {90,30,1};
  149.  
  150. // stan menu
  151. int isMenuOpen = 0;
  152.  
  153. // czas rozpoczecia gry
  154. unsigned int startTime = 0 ;
  155. unsigned int overallPauseTime = 0;
  156. unsigned int singlePauseTime = 0;
  157.  
  158. // szybkosc gry
  159. unsigned int gameSpeed = 550 ;
  160.  
  161. /****** INTERFEJS ******/
  162.  
  163. // rozmiary ekranu
  164. static const int SCREEN_X_BEG = 0 ;
  165. static const int SCREEN_X_END = 131 ;
  166. static const int SCREEN_Y_BEG = 0 ;
  167. static const int SCREEN_Y_END = 131 ;
  168.  
  169. //rozmiary menu
  170. static const int X_BEG = 121 ;
  171. static const int Y_BEG = 10 ;
  172. static const int X_END = 10 ;
  173. static const int Y_END = 121 ;
  174.  
  175. //czcionka
  176. static const int SFONT_SIZE[2] = {6,8} ; // small font size (y,x)
  177. static const int MFONT_SIZE[2] = {8,8} ; // medium font size (y,x)
  178. static const int LFONT_SIZE[2] = {8,16} ; // large font size (y,x)
  179.  
  180. //pasek stanu
  181. static const int STATUS_BAR_HEIGHT = 15 ;
  182.  
  183. void showGameTime_Pos(int x, int y)
  184. {
  185. char liczba[10] ;
  186.  
  187. unsigned int time = ((*AT91C_RTTC_RTVR) - startTime) - overallPauseTime;
  188. unsigned int min = time/60 ;
  189. unsigned int sec = time%60 ;
  190.  
  191. if( (min<10) && (sec<10) )
  192. sprintf( liczba, "0%d:0%d", min, sec ) ;
  193. else if( (min<10) )
  194. sprintf( liczba, "0%d:%d", min, sec ) ;
  195. else if( (sec<10) )
  196. sprintf( liczba, "%d:0%d", min, sec ) ;
  197. else
  198. sprintf( liczba, "%d:%d", min, sec ) ;
  199.  
  200. LCDPutStr( liczba, x , y, MEDIUM, ORANGE, BLACK ) ;
  201. }
  202.  
  203. void showCredits(void)
  204. {
  205. const unsigned int X_END_WIN = X_END+30 ; // 40
  206. const unsigned int X_BEG_WIN = X_BEG-30 ; // 91
  207. const unsigned int Y_END_WIN = Y_END-2 ; // 119
  208. const unsigned int Y_BEG_WIN = Y_BEG+2 ; // 12
  209.  
  210. unsigned int i ;
  211. int offsetX ;
  212. int offsetY ;
  213. int len;
  214.  
  215. char* authors[2] = {"T. Wreczycki"} ;
  216.  
  217. LCDSetRect( X_END_WIN , Y_BEG_WIN , X_BEG_WIN , Y_END_WIN , FILL, BLACK ) ;
  218.  
  219. for(i = 0; i < 2; ++i)
  220. {
  221. len = strlen(authors[i]) ;
  222. offsetY = len * MFONT_SIZE[ Y ] ;
  223. offsetY = Y_BEG_WIN + ((Y_END_WIN-Y_BEG_WIN)-offsetY)/2 ;
  224.  
  225. offsetX = X_END_WIN + 10 + i * MFONT_SIZE[ X ] + i*10 ;
  226.  
  227. LCDPutStr( authors[i], offsetX , offsetY, MEDIUM, ORANGE, BLACK ) ;
  228. }
  229.  
  230. //delay( 10000 ) ;
  231.  
  232. LCDSetRect( X_END_WIN , Y_BEG_WIN , X_BEG_WIN , Y_END_WIN, FILL, RED ) ;
  233. }
  234.  
  235. void newGame (void)
  236. {
  237. p.X = 130/2;
  238. p.pkt = 0 ;
  239.  
  240. k.kX = 0;
  241. k.kY = 0;
  242.  
  243. b1.stan=1;
  244. b2.stan=1;
  245. b3.stan=1;
  246.  
  247. gameSpeed = 550 ;
  248. startTime = *AT91C_RTTC_RTVR ;
  249. overallPauseTime = 0;
  250. singlePauseTime = 0;
  251.  
  252. srand( startTime ) ;
  253.  
  254. // odrysuj ekran z tlem
  255. showStatusBar(REDRAW);
  256. LCDSetRect( SCREEN_X_BEG + STATUS_BAR_HEIGHT, SCREEN_Y_BEG , SCREEN_X_END , SCREEN_Y_END , FILL , BACKGROUND_COLOR );
  257. }
  258.  
  259. void showPoints (void)
  260. {
  261. const unsigned int X_END_WIN = X_END+30 ; // 40
  262. const unsigned int X_BEG_WIN = X_BEG-30 ; // 91
  263. const unsigned int Y_END_WIN = Y_END-30 ; // 91
  264. const unsigned int Y_BEG_WIN = Y_BEG+30 ; // 40
  265.  
  266. char liczba[10] ;
  267.  
  268. int offsetX ;
  269. int offsetY ;
  270. int len ;
  271.  
  272. LCDSetRect( X_END_WIN , Y_BEG_WIN , X_BEG_WIN , Y_END_WIN , FILL, BLACK ) ;
  273.  
  274. sprintf( liczba, "%d", p.pkt ) ;
  275.  
  276. len = strlen(liczba) ;
  277. offsetY = len * MFONT_SIZE[ Y ] ;
  278. offsetY = Y_BEG_WIN + ((Y_END_WIN-Y_BEG_WIN)-offsetY)/2 ;
  279.  
  280. offsetX = MFONT_SIZE[ X ] ;
  281. offsetX = X_BEG_WIN + ((X_END_WIN-X_BEG_WIN)-offsetX)/2 ;
  282.  
  283. LCDPutStr( liczba, offsetX , offsetY, MEDIUM, ORANGE, BLACK ) ;
  284. delay( 10000 ) ;
  285.  
  286. LCDSetRect( X_END_WIN , Y_BEG_WIN , X_BEG_WIN , Y_END_WIN, FILL, RED ) ;
  287. }
  288.  
  289. void showPoints_Pos(int x, int yEnd)
  290. {
  291. char liczba[5];
  292. unsigned int yBeg;
  293. unsigned int len;
  294.  
  295. sprintf(liczba, "%d", p.pkt);
  296.  
  297. len = strlen(liczba);
  298. yBeg = yEnd - (len * MFONT_SIZE[ Y ]);
  299.  
  300. LCDPutStr( liczba, x , yBeg, MEDIUM, ORANGE, BLACK ) ;
  301. }
  302.  
  303. void menu(void)
  304. {
  305. static const char * title = "Arkanoid" ;
  306. static const int MENU_ENTRIES = 3 ;
  307. static const char * menuEntry[MENU_ENTRIES] = { "AUTORZY", "ILOSC PUNKTOW", "NOWA GRA" } ;
  308.  
  309. int len ;
  310. int offsetX ;
  311. int offsetY ;
  312.  
  313. int currentMenuEntryPos ;
  314.  
  315. unsigned int i ;
  316. unsigned char backgroundColor ;
  317.  
  318. singlePauseTime = *AT91C_RTTC_RTVR ;
  319.  
  320. // tlo menu
  321. LCDSetRect ( X_BEG , Y_BEG , X_END , Y_END , FILL , RED );
  322.  
  323. len = strlen(title) ;
  324. offsetY = len * LFONT_SIZE[ Y ] ;
  325. offsetY = Y_BEG + ((Y_END-Y_BEG)-offsetY)/2 ;
  326. LCDPutStr( (char*)title, X_END, offsetY, LARGE, ORANGE, BLACK);
  327.  
  328. currentMenuEntryPos = 0;
  329. while(1)
  330. {
  331. for( i = 0; i < MENU_ENTRIES; ++i )
  332. {
  333. if( i == currentMenuEntryPos )
  334. backgroundColor = GREEN ;
  335. else
  336. backgroundColor = BLACK ;
  337.  
  338. len = strlen(menuEntry[i]) ;
  339. offsetY = len * MFONT_SIZE[ Y ] ;
  340. offsetY = Y_BEG + ((Y_END-Y_BEG)-offsetY)/2 ;
  341. offsetX = (X_END + 40) + i*10 ;
  342. LCDPutStr( (char*)menuEntry[i], offsetX, offsetY, MEDIUM, ORANGE, backgroundColor);
  343. }
  344.  
  345. //delay(200);
  346. if ( LEFT_KEY_DOWN )
  347. {
  348. isMenuOpen = ~isMenuOpen;
  349. while( LEFT_KEY_DOWN ) {}
  350. break ;
  351. } // ?? delay(200);
  352. else if ( JOYSTICK_UP )
  353. {
  354. --currentMenuEntryPos ;
  355. if( currentMenuEntryPos < 0 )
  356. currentMenuEntryPos = 0 ;
  357.  
  358. while( JOYSTICK_UP ) {}
  359. }
  360. else if ( JOYSTICK_DOWN )
  361. {
  362. ++currentMenuEntryPos ;
  363. if( currentMenuEntryPos >= MENU_ENTRIES )
  364. currentMenuEntryPos = MENU_ENTRIES-1 ;
  365.  
  366. while( JOYSTICK_DOWN ) {}
  367. }
  368. else if ( JOYSTICK_RIGHT )
  369. {
  370. switch( currentMenuEntryPos )
  371. {
  372. case 0:
  373. showCredits() ;
  374. break ;
  375.  
  376. case 1:
  377. showPoints() ;
  378. isMenuOpen = ~isMenuOpen;
  379. while( JOYSTICK_RIGHT ) {}
  380. break ;
  381.  
  382. case 2:
  383. newGame() ;
  384. isMenuOpen = ~isMenuOpen;
  385. while( JOYSTICK_RIGHT ) {}
  386. return ;
  387.  
  388. default:
  389. break ;
  390. }
  391. }
  392. }
  393.  
  394. singlePauseTime = *AT91C_RTTC_RTVR - singlePauseTime;
  395. overallPauseTime += singlePauseTime;
  396. }
  397.  
  398. int changeSpeed(void)
  399. {
  400. int trim_val = GetAdcChanel(ADC_CHN_7);
  401.  
  402. trim_val=(trim_val >> 2);
  403.  
  404. return trim_val;
  405. }
  406.  
  407. void defeat(void)
  408. {
  409. int len ;
  410. unsigned int offsetY ;
  411. unsigned int offsetX ;
  412. const unsigned int NOTIFICATIONS_NUMBER = 2 ;
  413. const char* notification[NOTIFICATIONS_NUMBER] = {"PORAZKA!", "SPROBOJ PONOWNIE"} ;
  414. char gamePointsInfo [18] ;
  415.  
  416. len = strlen( notification[0] ) ;
  417. offsetY = len * LFONT_SIZE[ Y ] ;
  418. offsetY = Y_BEG + ((Y_END-Y_BEG)-offsetY)/2 ;
  419.  
  420. // sprawdzic pozniszy fragment - te wyliczenia moga byc niepewne
  421. offsetX = LFONT_SIZE[ X ] ;
  422. offsetX = X_END + ((X_BEG-X_END)-offsetX)/2 ;
  423.  
  424. LCDPutStr( (char*)notification[0], (offsetX-8) , offsetY, LARGE, RED, BLACK);
  425.  
  426. len = strlen( notification[1] ) ;
  427. offsetY = len * MFONT_SIZE[ Y ] ;
  428. offsetY = Y_BEG + ((Y_END-Y_BEG)-offsetY)/2 ;
  429.  
  430. // sprawdzic pozniszy fragment - te wyliczenia moga byc niepewne
  431. offsetX = LFONT_SIZE[ X ] ;
  432. offsetX = X_END + ((X_BEG-X_END)-offsetX)/2 ;
  433.  
  434. LCDPutStr( (char*)notification[1], (offsetX +12) , offsetY, MEDIUM, RED, BLACK);
  435.  
  436. sprintf( gamePointsInfo , "Punkty: %d" , p.pkt ) ;
  437.  
  438. len = strlen( gamePointsInfo ) ;
  439. offsetY = len * LFONT_SIZE[ Y ] ;
  440. offsetY = Y_BEG + ((Y_END-Y_BEG)-offsetY)/2 ;
  441.  
  442. // sprawdzic pozniszy fragment - te wyliczenia moga byc niepewne
  443. offsetX = LFONT_SIZE[ X ] ;
  444. offsetX = X_END + ((X_BEG-X_END)-offsetX)/2 ;
  445.  
  446.  
  447. LCDPutStr( gamePointsInfo , (offsetX + 24) , offsetY , LARGE , RED , BLACK ) ;
  448.  
  449. delay(50000) ;
  450.  
  451. newGame() ;
  452. }
  453.  
  454.  
  455. void showStatusBar( int redraw )
  456. {
  457. if(redraw == REDRAW)
  458. LCDSetRect( SCREEN_X_BEG , SCREEN_Y_BEG , STATUS_BAR_HEIGHT , SCREEN_Y_END , FILL , BLACK );
  459.  
  460. showGameTime_Pos(2,2);
  461. showPoints_Pos(2,129);
  462. }
  463.  
  464. void displayDeska(void)
  465. {
  466. LCDSetRect ( p.X-10, p.X+10, 0, 5, FILL, BLACK);
  467. }
  468.  
  469. void eraseDeska(void)
  470. {
  471. LCDSetRect ( p.X-10, p.X+10, 0, 5, FILL, BACKGROUND_COLOR);
  472. }
  473.  
  474. void lgKulka(void)
  475. {
  476. k.kX -= 5;
  477. k.kY += 5;
  478. k.kRuch = 1;
  479. }
  480.  
  481. void pgKulka(void)
  482. {
  483. k.kX += 5;
  484. k.kY += 5;
  485. k.kRuch = 2;
  486. }
  487.  
  488. void ldKulka(void)
  489. {
  490. k.kX -= 5;
  491. k.kY -= 5;
  492. k.kRuch = 3;
  493. }
  494.  
  495. void pdKulka(void)
  496. {
  497. k.kX += 5;
  498. k.kY -= 5;
  499. k.kRuch = 4;
  500. }
  501.  
  502. void moveKulka(void)
  503. {
  504. static const int LEFT_EDGE = SCREEN_Y_BEG ;
  505. static const int RIGHT_EDGE = SCREEN_Y_END -1 ;
  506. static const int BOTTOM_EDGE = SCREEN_X_END -1 -5 ;
  507. static const int UPPER_EDGE = STATUS_BAR_HEIGHT ;
  508.  
  509. LCDSetCircle( k.kX , k.kY , k.kRadius, BACKGROUND_COLOR);
  510.  
  511. if (k.kX == LEFT_EDGE)
  512. {
  513. if (k.kRuch == 1)
  514. {
  515. pgKulka();
  516. }
  517. else if (k.kRuch == 3)
  518. {
  519. pdKulka();
  520. }
  521. }
  522.  
  523. else if (k.kX == RIGHT_EDGE)
  524. {
  525. if (k.kRuch == 2)
  526. {
  527. lgKulka();
  528. }
  529. else if (k.kRuch == 4)
  530. {
  531. ldKulka();
  532. }
  533. }
  534.  
  535. //brick 1
  536. else if (k.kY >= b1.Y - 10 && k.kY <= b1.Y + 10 && k.kX >= b1.X - 10 && k.kX <= b1.X + 10)
  537. {
  538. if (k.kRuch == 1)
  539. {
  540. ldKulka();
  541. }
  542. else if (k.kRuch == 2)
  543. {
  544. pdKulka();
  545. }
  546. b1.stan=0;
  547. }
  548.  
  549. //brick 2
  550. else if (k.kY >= b2.Y - 10 && k.kY <= b2.Y + 10 && k.kX >= b2.X - 10 && k.kX <= b2.X + 10)
  551. {
  552. if (k.kRuch == 1)
  553. {
  554. ldKulka();
  555. }
  556. else if (k.kRuch == 2)
  557. {
  558. pdKulka();
  559. }
  560. b2.stan=0;
  561. }
  562.  
  563. //brick 3
  564. else if (k.kY >= b3.Y - 10 && k.kY <= b3.Y + 10 && k.kX >= b3.X - 10 && k.kX <= b3.X + 10)
  565. {
  566. if (k.kRuch == 1)
  567. {
  568. ldKulka();
  569. }
  570. else if (k.kRuch == 2)
  571. {
  572. pdKulka();
  573. }
  574. b3.stan=0;
  575. }
  576.  
  577. else if (k.kY == UPPER_EDGE)
  578. {
  579. if (k.kRuch == 1)
  580. {
  581. ldKulka();
  582. }
  583. else if (k.kRuch == 2)
  584. {
  585. pdKulka();
  586. }
  587. }
  588.  
  589. else if (k.kY == BOTTOM_EDGE)
  590. {
  591. if (k.kX >= p.X - 10 && k.kX <= p.X +10)
  592. {
  593. if (k.kRuch == 3)
  594. {
  595. lgKulka();
  596. }
  597. else if (k.kRuch == 4)
  598. {
  599. pgKulka();
  600. }
  601. }
  602. else defeat();
  603. }
  604.  
  605. else if (k.kRuch == 1)
  606. {
  607. lgKulka();
  608. }
  609.  
  610. else if (k.kRuch == 2)
  611. {
  612. pgKulka();
  613. }
  614.  
  615. else if (k.kRuch == 2)
  616. {
  617. ldKulka();
  618. }
  619.  
  620. else if (k.kRuch == 2)
  621. {
  622. pdKulka();
  623. }
  624.  
  625. LCDSetCircle( k.kX , k.kY , k.kRadius, k.kColor);
  626. }
  627.  
  628. void drawBrick(void)
  629. {
  630. if (b1.stan == 1)
  631. {
  632. LCDSetRect( b1.X -10 , b1.X +10 , b1.Y -10 , b1.Y +10 , FILL , BLACK );
  633. }
  634. else
  635. {
  636. LCDSetRect( b1.X -10 , b1.X +10 , b1.Y -10 , b1.Y +10 , FILL , BACKGROUND_COLOR );
  637. }
  638.  
  639. if (b2.stan == 1)
  640. {
  641. LCDSetRect( b2.X -10 , b2.X +10 , b2.Y -10 , b2.Y +10 , FILL , BLACK );
  642. }
  643. else
  644. {
  645. LCDSetRect( b2.X -10 , b2.X +10 , b2.Y -10 , b2.Y +10 , FILL , BACKGROUND_COLOR );
  646. }
  647.  
  648. if (b3.stan ==1)
  649. {
  650. LCDSetRect( b3.X -10 , b3.X +10 , b3.Y -10 , b3.Y +10 , FILL , BLACK );
  651. }
  652. else
  653. {
  654. LCDSetRect( b3.X -10 , b3.X +10 , b3.Y -10 , b3.Y +10 , FILL , BACKGROUND_COLOR );
  655. }
  656. }
  657.  
  658. /*********************************************************/
  659.  
  660. //
  661. // Main Program
  662. //
  663.  
  664. int main (void)
  665. {
  666. unsigned i;
  667.  
  668. // Enable the Clock of the PIO
  669. AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOB) | (1 << AT91C_ID_PIOA);
  670.  
  671. LED_INIT;
  672.  
  673. InitADC();
  674.  
  675. AT91C_BASE_PIOB->PIO_ODR = (AT91C_PIO_PB24|AT91C_PIO_PB25); //keys SW1 i SW2 - jako wejscia
  676.  
  677. // ustawienie prescaler'a na odmierzanie 1 sekundy
  678. *AT91C_RTTC_RTMR |= 0x8000 ;
  679.  
  680. // inicjalizacja funkcji losujacej
  681. //srand( seed ) ;
  682.  
  683. // Initialize SPI interface to LCD
  684. InitSpi();
  685.  
  686. // Init LCD
  687. InitLcd();
  688.  
  689. // Voltage control (contrast setting)
  690. WriteSpiCommand(VOLCTR);
  691. WriteSpiData(-20); // P1 = 32 volume value (experiment with this value to get the best contrast)
  692. WriteSpiData(3); // P2 = 3 resistance ratio (only value that works)
  693.  
  694. // clear the screen
  695. LCDClearScreen();
  696.  
  697. // rozpoczecie nowej gry
  698. newGame();
  699.  
  700. while(1)
  701. {
  702. if ( JOYSTICK_LEFT )
  703. {
  704. if( p.X >= 0 )
  705. {
  706. eraseDeska();
  707. p.X -= 5 ;
  708. }
  709. }
  710. else if ( JOYSTICK_RIGHT )
  711. {
  712. if( p.X <= 130 )
  713. {
  714. eraseDeska();
  715. p.X += 5 ;
  716. }
  717. }
  718.  
  719. else if ( LEFT_KEY_DOWN )
  720. {
  721. //delay(200);
  722. isMenuOpen = ~isMenuOpen;
  723. //delay(200);
  724. while( LEFT_KEY_DOWN ) {}
  725. }
  726.  
  727. if ( isMenuOpen )
  728. {
  729. menu();
  730.  
  731. showStatusBar(REDRAW);
  732. LCDSetRect( SCREEN_X_BEG + STATUS_BAR_HEIGHT, SCREEN_Y_BEG , SCREEN_X_END , SCREEN_Y_END , FILL , BACKGROUND_COLOR );
  733. }
  734.  
  735. drawBrick();
  736.  
  737. displayDeska();
  738.  
  739. moveKulka();
  740.  
  741. showStatusBar(DO_NOT_REDRAW);
  742.  
  743. delay(gameSpeed - changeSpeed() );
  744. }
  745. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!