Mercurial > hg > pub > prymula > com

comparison arkanoid/arkanoid.c @ 0:2787f5e749ae

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
INIT
author prymula <prymula76@outlook.com>
date Thu, 21 Sep 2023 22:33:57 +0200
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:2787f5e749ae
1 /*
2 arkanoid - moja implementacja klasyka
3 wymaga: SDL2, SDL_TTF2
4 09-01-2021
5 licencja: Public Domain
6 edytor: VS Code
7 utworzono na platformie: Windows 10 - MinGW32
8 */
9
10 #include "arkanoid.h"
11 #include "levels.h"
12
13 Kafel kafle[8][8];
14 SDL_Surface * gumka_kafla;
15 SDL_Window *gWindow=NULL;
16 SDL_Renderer * renderer=NULL;
17 SDL_Texture * tex_screen=NULL;
18
19 int liczba_kafli=0;
20 int wynik, najlepszy, poziom, zycia;
21
22 void rysuj_obrazek (int x, int y, SDL_Surface * obrazek, int przezroczystosc);
23 SDL_Surface * utworz_powierzchnie(int sz, int w, int r, int g, int b);
24
25 SDL_Rect set_rect(int x, int y, int w, int h)
26 {
27 SDL_Rect rect;
28 rect.x = x;
29 rect.y = y;
30 rect.w = w;
31 rect.h = h;
32 return rect;
33 }
34
35 Uint32 getpixel(SDL_Surface *surface, int x, int y)
36 {
37 int bpp = surface->format->BytesPerPixel;
38 /* Here p is the address to the pixel we want to retrieve */
39 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
40
41 switch(bpp) {
42 case 1:
43 return *p;
44 case 2:
45 return *(Uint16 *)p;
46 case 3:
47 if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
48 return p[0] << 16 | p[1] << 8 | p[2];
49 else
50 return p[0] | p[1] << 8 | p[2] << 16;
51 case 4:
52 return *(Uint32 *)p;
53 default:
54 return 0;
55 }
56 }
57
58
59
60 void putpixel(SDL_Surface *surface, int x, int y, Uint8 R, Uint8 G, Uint8 B)
61 {
62 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x *
63 surface->format->BytesPerPixel;
64 if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
65 {
66 p[0] = R;
67 p[1] = G;
68 p[2] = B;
69 }
70 else
71 {
72 p[0] = B;
73 p[1] = G;
74 p[2] = R;
75 }
76 }
77
78 SDL_Surface * preparuj_tekst(int r, int b, int g, char *bufor) {
79
80 SDL_Color fgcolor;
81
82 fgcolor.r = r;
83 fgcolor.b = b;
84 fgcolor.g = g;
85
86 return TTF_RenderText_Solid(font_panel, bufor, fgcolor);
87 }
88
89
90 void print_text(int r, int g, int b, char *c, int x, int y, int z) {
91
92 SDL_Surface * obraz_info;
93 SDL_Surface * gum_info;
94 SDL_Rect zrodlo, cel;
95
96 obraz_info = (SDL_Surface *) preparuj_tekst(r, g, b, c);
97
98 // chce wymazac napis
99 //cel = set_rect(obraz_info->clip_rect.x, obraz_info->clip_rect.y,
100 // obraz_info->w, obraz_info->h);
101 cel = set_rect(x, y,
102 obraz_info->w, obraz_info->h);
103 zrodlo = set_rect(0, 0, obraz_info->w, obraz_info->h);
104 gum_info=utworz_powierzchnie(obraz_info->w, obraz_info->h, 65, 190, 215);
105
106 SDL_BlitSurface(gum_info, &zrodlo, obraz, &cel);
107 SDL_FreeSurface(gum_info);
108
109 rysuj_obrazek(x, y, obraz_info, 1);
110 SDL_FreeSurface(obraz_info);
111 }
112
113
114 SDL_Surface * ustaw_kolor (Kolor kol) {
115
116 SDL_Surface * kafel;
117 SDL_Rect cel;
118
119 kafel = SDL_CreateRGBSurface(SDL_SWSURFACE, XKAFLA, YKAFLA,16,0,0,0,0);
120 cel = set_rect(0, 0, XKAFLA, YKAFLA);
121 SDL_FillRect(kafel, &cel, SDL_MapRGB(kafel->format, kol.r, kol.g, kol.b));
122
123 return kafel;
124
125 }
126
127 void ustaw_kolor_tla(void) {
128
129 SDL_Rect przez;
130 //obraz->clip_rect.x=0;
131 //obraz->clip_rect.y=0;
132 //obraz->clip_rect.w=640;
133 //obraz->clip_rect.h=480;
134 asm("nop");
135 przez = set_rect(0, 0, obraz->w, obraz->h);
136 //przez = set_rect(0, 0, 640, 480);
137
138 SDL_FillRect(obraz, &przez, SDL_MapRGB(obraz->format,65,190,215));
139 //SDL_Flip(obraz);
140 SDL_RenderPresent ( renderer );
141 }
142
143 void erase (RuchomyObiekt *p){
144
145 SDL_Rect zrodlo, cel;
146
147 cel = set_rect(p->px, p->py, p->gumka->w, p->gumka->h);
148 zrodlo = set_rect(0, 0, p->gumka->w, p->gumka->h);
149 SDL_BlitSurface(p->gumka,&zrodlo,obraz,&cel);
150 }
151
152
153 void przerysuj(RuchomyObiekt *p) {
154 SDL_Rect zrodlo, cel;
155 // wymazuje stara pozycje
156 cel = set_rect(p->px, p->py, p->gumka->w, p->gumka->h);
157 zrodlo = set_rect(0, 0, p->gumka->w, p->gumka->h);
158 SDL_BlitSurface(p->gumka,&zrodlo,obraz,&cel);
159 // rysuje na nowej pozycji
160 cel = set_rect(p->ax, p->ay, p->obraz->w, p->obraz->h);
161 zrodlo = set_rect(0, 0, p->obraz->w, p->obraz->h);
162 SDL_BlitSurface(p->obraz,&zrodlo,obraz,&cel);
163
164 }
165
166 void rysuj_obrazek (int x, int y, SDL_Surface * obrazek, int przezroczystosc) {
167
168 SDL_Rect srcrect, destrect;
169
170 if (przezroczystosc) SDL_SetColorKey(obrazek,SDL_TRUE,getpixel(obrazek,0,0));
171
172 destrect = set_rect(x, y, obrazek->w, obrazek->h);
173 srcrect = set_rect(0,0,obrazek->w, obrazek->h);
174 SDL_BlitSurface(obrazek,&srcrect,obraz,&destrect);
175 }
176
177
178 SDL_Surface * utworz_powierzchnie(int sz, int w, int r, int g, int b) {
179
180 SDL_Surface * powierzchnia;
181 SDL_Rect cel;
182
183 powierzchnia = SDL_CreateRGBSurface(SDL_SWSURFACE, sz, w,16,0,0,0,0);
184 cel = set_rect(0, 0, sz, w);
185 SDL_FillRect(powierzchnia, &cel, SDL_MapRGB(powierzchnia->format, r, g, b));
186
187 return powierzchnia;
188 }
189
190 Uint32 ruch_pilki(Uint32 interval, void *param)
191 {
192 SDL_Rect zrodlo, cel;
193 Teczka * t = (Teczka *) param;
194 int i, j;
195
196 przerysuj(t->pilka);
197
198 if (t->pilka->ax <= 5) t->pilka->kx=5;
199 if (t->pilka->ax >= 605) t->pilka->kx=-5;
200 if (t->pilka->ay <=30) t->pilka->ky=5;
201
202 /* odpicie przez paletke */
203 if (t->pilka->ax+XPILKI >= t->paletka->ax && (t->pilka->ax) <= (t->paletka->ax+XPALETKI) &&
204 t->pilka->ay >= 420) {
205
206 /* odbicie lewym brzegiem */
207 if (t->pilka->ax >= t->paletka->ax && t->pilka->ax <= t->paletka->ax+30) {
208 t->pilka->kx=-5;
209 printf ("kx = -5\n");
210
211 }
212 /* odbicie lewym srodkiem */
213 else if (t->pilka->ax >= t->paletka->ax+30 && t->pilka->ax <= t->paletka->ax+60) {
214 t->pilka->kx=-2;
215 printf ("kx = -2\n");
216 }
217 /* odbicie prawym srodkiem */
218 else if (t->pilka->ax >= t->paletka->ax+60 && t->pilka->ax <= t->paletka->ax+90) {
219 t->pilka->kx=2;
220 printf ("kx = 2\n");
221 }
222 /* odbicie prawym brzegiem */
223 else if (t->pilka->ax >= t->paletka->ax+90 && t->pilka->ax <= t->paletka->ax+120) {
224 // t->pilka->kx=-5;
225 t->pilka->kx=5;
226 printf ("kx = 5\n");
227
228 }
229
230 /* odbijamy od paletki */
231 t->pilka->ky=-5;
232 }
233
234 int flaga_zmiany=0; // zapobiega przebijaniu sie pilki przez kafle
235 /* reakcje pilki z kaflami */
236 for (i=0; i<8; i++) {
237
238 for (j=0; j<8; j++) {
239 if (kafle[i][j].obraz != NULL) {
240
241 if (t->pilka->ay+YPILKI >= kafle[i][j].y &&
242 t->pilka->ay <= kafle[i][j].y+YKAFLA &&
243 t->pilka->ax >= kafle[i][j].x-XPILKI &&
244 t->pilka->ax <= kafle[i][j].x+XKAFLA) {
245 #define XTOL 1
246 // #define YTOL 3
247 printf ("twardosc: %d\n", kafle[i][j].twardosc);
248 if (kafle[i][j].twardosc !=2) {
249 rysuj_obrazek(kafle[i][j].x, kafle[i][j].y, gumka_kafla, 0);
250 kafle[i][j].obraz=NULL;
251 // w ktora strone znikajacy kafel odbije pilke
252
253 // lewy przeg kafla
254
255 printf ("ax: %d kafel %d \n", t->pilka->ax, kafle[i][j].x+XKAFLA);
256
257 if (t->pilka->ay+YPILKI >= kafle[i][j].y &&
258 t->pilka->ay <= kafle[i][j].y+YKAFLA &&
259 t->pilka->ax >= kafle[i][j].x-XPILKI &&
260 t->pilka->ax <= kafle[i][j].x-XPILKI+XTOL) {
261
262 if (!flaga_zmiany) {
263 t->pilka->kx = -5;
264 flaga_zmiany=1;
265 }
266
267 printf ("lewy bok\n");
268 liczba_kafli--;
269 wynik+=PUNKTY;
270 //
271 }
272 // prawy przeg kafla
273 else if (t->pilka->ay+YPILKI >= kafle[i][j].y &&
274 t->pilka->ay <= kafle[i][j].y+YKAFLA &&
275 t->pilka->ax <= kafle[i][j].x+XKAFLA &&
276 t->pilka->ax >= kafle[i][j].x+XKAFLA-XTOL) {
277
278 if (!flaga_zmiany) {
279 t->pilka->kx = 5;
280 flaga_zmiany=1;
281 }
282 printf ("prawy bok\n");
283 liczba_kafli--;
284 wynik+=PUNKTY;
285 //
286 }
287 else if (t->pilka->ky == 5) {
288 if (!flaga_zmiany) {
289 t->pilka->ky =-5;
290 flaga_zmiany=1;
291 }
292 printf ("zmina kirunku: do gory (%d)\n", t->pilka->ay);
293 liczba_kafli--;
294 wynik+=PUNKTY;
295 }
296 else if (t->pilka->ky == -5) {
297 if (!flaga_zmiany) {
298 t->pilka->ky =5;
299 flaga_zmiany=1;
300 }
301 printf ("zmina kirunku: na dól %d \n", t->pilka->ay );
302 liczba_kafli--;
303 wynik+=PUNKTY;
304 }
305
306
307 printf ("\n\nliczba kafli: %d\n", liczba_kafli);
308 }
309 /* jesli twardosc 2 */
310 else {
311 if (t->pilka->ay+YPILKI >= kafle[i][j].y &&
312 t->pilka->ay <= kafle[i][j].y+YKAFLA &&
313 t->pilka->ax >= kafle[i][j].x-XPILKI &&
314 t->pilka->ax <= kafle[i][j].x-XPILKI+XTOL) {
315
316 if (!flaga_zmiany) {
317 t->pilka->kx = -5;
318 flaga_zmiany=1;
319 }
320 printf ("lewy bok\n");
321 // liczba_kafli--;
322 kafle[i][j].twardosc=1;
323 //
324 }
325 // prawy przeg kafla
326 else if (t->pilka->ay+YPILKI >= kafle[i][j].y &&
327 t->pilka->ay <= kafle[i][j].y+YKAFLA &&
328 t->pilka->ax <= kafle[i][j].x+XKAFLA &&
329 t->pilka->ax >= kafle[i][j].x+XKAFLA-XTOL) {
330
331 if (!flaga_zmiany) {
332 t->pilka->kx = 5;
333 flaga_zmiany=1;
334 }
335
336 printf ("prawy bok\n");
337 // liczba_kafli--;
338 kafle[i][j].twardosc=1;
339 //
340 }
341
342 else if (t->pilka->ky == 5) {
343 if (!flaga_zmiany) {
344 t->pilka->ky =-5;
345 flaga_zmiany=1;
346 }
347 printf ("zmina kirunku: do gory (%d)\n", t->pilka->ay);
348 liczba_kafli--;
349 }
350 else if (t->pilka->ky == -5) {
351 if (!flaga_zmiany) {
352 t->pilka->ky =5;
353 flaga_zmiany=1;
354 }
355 printf ("zmina kirunku: na dól %d \n", t->pilka->ay );
356 liczba_kafli--;
357 }
358 printf("opuszczam Twardosc 2\n");
359 }
360
361 }
362 }
363 }
364 }
365
366
367
368 t->pilka->px=t->pilka->ax;
369 t->pilka->py=t->pilka->ay;
370 t->pilka->ax+=t->pilka->kx;
371 t->pilka->ay+=t->pilka->ky;
372
373 //return interval;
374 }
375
376
377
378 /* poziom liczymy od zera */
379 void zaladuj_poziom(SDL_Surface ** kolor_kafla, int poziom) {
380
381 int i, j, l, x, y;
382
383 printf ("bede rysowac poziom: %d\n", poziom);
384 /* dane odczytwane beda dla poziomu 'level' */
385 l = poziom*8;
386 liczba_kafli=0;
387 x=0;
388 y=30;
389 // wiersze
390 for (i=0; i < 8; ++i) {
391 // kolumny
392 for (j = 0; j < 8; ++j) {
393
394 printf ("levels -%d-", levels[i+l][j]);
395 /* jesli pole rozne od zera to jakis kafel */
396 if (levels[i+l][j] != 48) {
397 kafle[i][j].obraz= kolor_kafla[levels[i+l][j]-48];
398
399 if (levels[i+l][j] != 52) kafle[i][j].twardosc=1;
400 else kafle[i][j].twardosc=2;
401
402 kafle[i][j].x = x;
403 kafle[i][j].y = y;
404 liczba_kafli++;
405 }
406 else {
407 kafle[i][j].obraz= NULL;
408 }
409 x+=XKAFLA;
410 }
411 x=0;
412 y+=YKAFLA;
413
414 putchar('\n');
415 // if (i == 19) putchar('\n');
416 }
417
418 }
419
420 void wyswietl_kafle(void) {
421
422 int i, j;
423 SDL_Rect zrodlo, cel;
424
425 for (i=0; i < 8; ++i) {
426
427 for (j = 0; j < 8; ++j) {
428
429 if (kafle[i][j].obraz != NULL) {
430 printf ("rysuje\n");
431 cel = set_rect(kafle[i][j].x, kafle[i][j].y, kafle[i][j].obraz->w, kafle[i][j].obraz->h);
432 zrodlo = set_rect(0, 0, kafle[i][j].obraz->w, kafle[i][j].obraz->h);
433 SDL_BlitSurface(kafle[i][j].obraz, &zrodlo, obraz, &cel);
434
435 }
436 //else printf ("Kafle nie maja przydzielonego obrazu\n");
437 }
438 }
439 }
440
441 SDL_Surface * utworz_kafle(SDL_Surface ** tab) {
442 int i;
443 Kolor kolory[4] = {{62, 246, 26}, // zielony
444 {246, 26, 202}, // filoet
445 {26, 36, 246}, // indygo
446 {246, 26, 52}}; // czerwony
447 // {253, 157, 79} // pomaranczowy
448 for (i=0; i<8; i++) {
449 tab[i] = ustaw_kolor(kolory[i]);
450 }
451
452 }
453
454 SDL_bool end() {
455 SDL_Rect zrodlo, cel;
456 char txt1[30] = "G A M E O V E R";
457 char txt2[10] = "Wynik";
458 char txt3[24];
459 ustaw_kolor_tla();
460
461 print_text(0, 0, 0, txt1, 200, 200, 10);
462 print_text(234, 0, 0, txt2, 250, 250, 10);
463 sprintf (txt3, "%d", wynik);
464 print_text(33, 249, 11, txt3, 260, 300, 10);
465
466 cel = set_rect(0, 0, obraz->w, obraz->h);
467 zrodlo = set_rect(0, 0, obraz->w, obraz->h);
468 tex_screen = SDL_CreateTextureFromSurface(renderer, obraz);
469 SDL_RenderClear ( renderer );
470 SDL_RenderCopy(renderer, tex_screen,&zrodlo,&cel);
471 SDL_RenderPresent(renderer);
472 SDL_DestroyTexture(tex_screen);
473
474 sleep(5);
475 return SDL_TRUE;
476 }
477
478 SDL_bool file_exist(){
479 char *file;
480
481 #if WINDOWS
482 char * FILE_NAME = "\\arkanoid.txt";
483 char * HOME = "HOMEPATH";
484
485 #elif LINUX
486 char * FILE_NAME = "/.arkanoid.txt";
487 char * HOME = "HOME";
488 #endif
489
490
491 if (!getenv(HOME)) exit (1);
492
493 file=(char *)malloc(strlen(getenv(HOME))+strlen(FILE_NAME)+1);
494
495 strcpy(file, getenv(HOME));
496 strcat(file, FILE_NAME);
497 printf("1");
498
499 if (access(file, F_OK)==0){
500 printf("PLIK istnieje %s",file);
501 free(file);
502 return SDL_TRUE;
503 }
504 printf("PLIK nie istnieje %s",file);
505 free(file);
506 return SDL_FALSE;
507
508 }
509
510 void save_hiscore(){
511 char *file;
512
513 #if WINDOWS
514 char * FILE_NAME = "\\arkanoid.txt";
515 char * HOME = "HOMEPATH";
516
517 #elif LINUX
518 char * FILE_NAME = "/.arkanoid.txt";
519 char * HOME = "HOME";
520 #endif
521
522
523 char bufor[48];
524
525 if (!getenv(HOME)) exit (1);
526
527
528 //file=(char *)malloc(strlen(getenv(HOME)+strlen(FILE_NAME)+1));
529 file=(char *)malloc(strlen(getenv(HOME))+strlen(FILE_NAME)+1);
530
531 strcpy(file, getenv(HOME));
532 strcat(file, FILE_NAME);
533
534 sprintf(bufor,"%d",najlepszy);
535
536 FILE * f = fopen(file, "w");
537 fwrite(bufor, sizeof(char), strlen(bufor), f);
538 fclose(f);
539 printf ("Zapisałem: %s\n", file);
540 free(file);
541
542
543
544 }
545
546 void load_hiscore(){
547 char *file;
548
549 #if WINDOWS
550 char * FILE_NAME = "\\arkanoid.txt";
551 char * HOME = "HOMEPATH";
552
553 #elif LINUX
554 char * FILE_NAME = "/.arkanoid.txt";
555 char * HOME = "HOME";
556 #endif
557
558
559 char bufor[48];
560
561 if (!getenv(HOME)) exit (1);
562
563 //file=(char *)malloc(strlen(getenv(HOME)+strlen(FILE_NAME)+1));
564 file=(char *)malloc(strlen(getenv(HOME))+strlen(FILE_NAME)+1);
565
566 strcpy(file, getenv(HOME));
567 strcat(file, FILE_NAME);
568
569 FILE * f = fopen(file, "r");
570 fscanf(f, "%s", bufor);
571 fclose(f);
572 free(file);
573
574 najlepszy=atoi(bufor);
575
576 // najlepszy=0;
577 }
578
579
580
581
582 SDL_bool gra () {
583
584 int wykonano, rozpoczecie;
585 int px, py, kx, ky;
586 char bufor[50];
587 SDL_bool quit=SDL_TRUE;
588
589 SDL_Surface * tablica_kolorow_kafli[4];
590 SDL_TimerID uchwyt_pilki;
591 Uint32 predkosc_pilki=50, czas_zwloki=50;
592 RuchomyObiekt pilka, paletka;
593 Teczka teczka;
594 // Teczka2 teczka2;
595 // Kafel kafle[4][8];
596 int powolna_paletka=0, pauza=0;
597 SDL_Rect zrodlo, cel;
598 char level_bufor[24], score_bufor[24], lives_bufor[24], hi_bufor[24];
599
600 wynik=000;
601 pilka.ax=640/2-XPILKI/2;
602 pilka.ay=420;
603 pilka.px=pilka.ax;
604 pilka.py=pilka.ay;
605 pilka.kx=-5;
606 pilka.ky=-5;
607
608 zycia=2;
609 poziom=1;
610 //najlepszy=1000;
611
612 asm("nop");
613 ustaw_kolor_tla();
614
615 pilka.obraz=utworz_pilke();
616 //pilka.obraz = SDL_LoadBMP("ball.bmp");
617 //pilka.gumka=utworz_powierzchnie(XPILKI, YPILKI, 65, 190, 215);
618 #if WINDOWS
619 pilka.gumka = SDL_LoadBMP("icon/gumka_arkanoid.bmp");
620 #elif LINUX
621 pilka.gumka = SDL_LoadBMP("/usr/share/pixmaps/gumka_arkanoid.bmp");
622 #endif
623
624 SDL_SetColorKey(pilka.gumka,SDL_TRUE,getpixel(pilka.gumka,0,0));
625 rysuj_obrazek(pilka.ax, pilka.ay, pilka.obraz, 1); // colorskey powinno byc 1
626
627 paletka.ax=640/2-XPALETKI/2;
628 paletka.ay=450;
629 // paletka.px=paletka.ax;
630 paletka.py=paletka.ay;
631
632 paletka.obraz=utworz_powierzchnie(XPALETKI, YPALETKI, 0, 0, 0);
633 paletka.gumka=utworz_powierzchnie(XPALETKI, YPALETKI, 65, 190, 215);
634
635 rysuj_obrazek(paletka.ax, paletka.ay, paletka.obraz, 0);
636
637
638 teczka.pilka=&pilka;
639 teczka.paletka=&paletka;
640
641 utworz_kafle(tablica_kolorow_kafli);
642 zaladuj_poziom(tablica_kolorow_kafli, poziom-1);
643 wyswietl_kafle();
644 gumka_kafla=utworz_powierzchnie(XKAFLA, YKAFLA, 65, 190, 215);
645
646 rozpoczecie = wykonano = 0;
647
648 sprintf (level_bufor, "%d", poziom);
649 print_text(253, 255, 100, level_bufor, 250, 0, 2);
650 sprintf (lives_bufor, "%d", zycia);
651 print_text(33, 249, 11, lives_bufor, 400, 0, 2);
652 sprintf (hi_bufor, "%d", najlepszy);
653 print_text(249, 33, 11, hi_bufor, 550, 0, 3);
654
655 //SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
656
657 while(!wykonano) {
658
659 SDL_Event event;
660 // SDL_KeyboardEvent zd_klawiszy;
661
662
663 if (pilka.ax+pilka.obraz->w <= 0){
664 pilka.ax=640;
665 }
666
667 while (SDL_PollEvent (&event)) {
668
669 switch (event.type) {
670
671 case SDL_KEYDOWN:
672 printf("Naciśnięto klawisz: %s\n", SDL_GetKeyName(event.key.keysym.sym));
673
674 if (event.key.keysym.sym==SDLK_ESCAPE)
675 wykonano = 1;
676
677 if (event.key.keysym.sym==SDLK_SPACE && !rozpoczecie) {
678 // teczka.poprzedni_y=pilka.ay;
679 // uchwyt_pilki = SDL_AddTimer(predkosc_pilki, ruch_pilki, &teczka);
680 rozpoczecie = 1;
681 }
682
683 //printf("powolna_paleka: %d", powolna_paletka);
684 if (event.key.keysym.sym==SDLK_LEFT && paletka.ax>0) {
685 printf("PALETKA LEWA\n");
686 if(powolna_paletka>=1) {
687 paletka.px=paletka.ax;
688 paletka.ax-=10;
689 przerysuj(&paletka);
690 if (!rozpoczecie) {
691 pilka.px=pilka.ax;
692 pilka.ax-=10;
693 przerysuj(&pilka);
694 }
695 powolna_paletka=0;
696 }
697 }
698 if (event.key.keysym.sym==SDLK_RIGHT && paletka.ax<(640-XPALETKI)) {
699 if(powolna_paletka>=1) {
700 paletka.px=paletka.ax;
701 paletka.ax+=10;
702 przerysuj(&paletka);
703 if (!rozpoczecie) {
704 pilka.px=pilka.ax;
705 pilka.ax+=10;
706 przerysuj(&pilka);
707 }
708 powolna_paletka=0;
709 }
710 }
711 if (event.key.keysym.sym==SDLK_r) {
712 wyswietl_kafle();
713 sprintf (score_bufor, "%d", wynik);
714 print_text(255, 255, 255, score_bufor, 10, 0, 3);
715 sprintf (level_bufor, "%d", poziom);
716 print_text(253, 255, 100, level_bufor, 250, 0, 2);
717 sprintf (lives_bufor, "%d", zycia);
718 print_text(33, 249, 11, lives_bufor, 400, 0, 2);
719 sprintf (hi_bufor, "%d", najlepszy);
720 print_text(249, 33, 11, hi_bufor, 550, 0, 3);
721 przerysuj(&paletka);
722 przerysuj(&pilka);
723 }
724
725 break;
726
727 case SDL_QUIT:
728 if (wynik>najlepszy){
729 najlepszy=wynik;
730 save_hiscore();
731 }
732 SDL_DestroyTexture(tex_screen);
733 SDL_DestroyRenderer(renderer);
734 SDL_DestroyWindow(gWindow);
735 exit(0);
736 break;
737
738 case SDL_MOUSEMOTION:
739 break;
740
741 case SDL_MOUSEBUTTONDOWN:
742 //if (!pauza) pauza=1;
743 //else pauza=0;
744 break;
745
746 case SDL_MOUSEBUTTONUP:
747 break;
748
749 default:
750 break;
751 }
752
753 }
754
755 if (pilka.ay+pilka.obraz->h>=480){
756 printf("Nowe rozdanie!\n\n\n");
757 if(--zycia == -1){
758 wykonano=1;
759 quit=SDL_TRUE;
760 goto label;
761 }
762
763 //erase (&paletka);
764 //erase (&pilka);
765 // wymazujemy caly ekran, erase(&paletka) nie wymazuje dokladnie
766 ustaw_kolor_tla();
767 wyswietl_kafle();
768 //pisz_info(253, 255, 100, poziom, 250, 0, 2);
769 //pisz_info(33, 249, 11, zycia, 400, 0, 2);
770 //pisz_info(249, 33, 11, najlepszy, 550, 0, 3);
771 sprintf (level_bufor, "%d", poziom);
772 print_text(253, 255, 100, level_bufor, 250, 0, 2);
773 sprintf (lives_bufor, "%d", zycia);
774 print_text(33, 249, 11, lives_bufor, 400, 0, 2);
775 sprintf (hi_bufor, "%d", najlepszy);
776 print_text(249, 33, 11, hi_bufor, 550, 0, 3);
777 rozpoczecie=0;
778 pilka.ax=640/2-XPILKI/2;
779 pilka.ay=420;
780 pilka.px=pilka.ax;
781 pilka.py=pilka.ay;
782 pilka.kx=-5;
783 pilka.ky=-5;
784 paletka.ax=640/2-XPALETKI/2;
785 paletka.ay=450;
786 // paletka.px=paletka.ax;
787 paletka.py=paletka.ay;
788
789 if(powolna_paletka>=1) {
790 paletka.px=paletka.ax;
791 paletka.ax-=10;
792 przerysuj(&paletka);
793 if (!rozpoczecie) {
794 pilka.px=pilka.ax;
795 pilka.ax-=10;
796 przerysuj(&pilka);
797 }
798 powolna_paletka=0;
799 }
800 }
801 // zapobiega wywietleniu -1 zycia
802 label:
803
804 //pisz_info(255, 255, 255, wynik, 0, 0, 4);
805 sprintf (score_bufor, "%d", wynik);
806 print_text(255, 255, 255, score_bufor, 10, 0, 3);
807
808
809 if (rozpoczecie) {
810 if(!pauza) {
811
812 ruch_pilki(0, &teczka);
813 }
814 }
815 powolna_paletka+=1;
816
817
818 if (!liczba_kafli) {
819 printf ("poziom zaliczony\n");
820 if (pilka.py>300 && poziom<8) {
821 poziom++;
822 printf ("rysuj nowy poziom liczba kafli przed: %d\n", liczba_kafli);
823 zaladuj_poziom(tablica_kolorow_kafli, poziom-1);
824 wyswietl_kafle();
825 sprintf (level_bufor, "%d", poziom);
826 print_text(253, 255, 100, level_bufor, 250, 0, 2);
827 printf("liczba kafli po: %d\n", liczba_kafli);
828 //pisz_info(253, 255, 100, poziom, 180, 0, 1);
829 }
830 else if (pilka.py>300 && poziom>=8){
831 poziom=1;
832 zaladuj_poziom(tablica_kolorow_kafli, poziom-1);
833 wyswietl_kafle();
834 sprintf (level_bufor, "%d", poziom);
835 print_text(253, 255, 100, level_bufor, 250, 0, 2);
836 printf("liczba kafli po: %d\n", liczba_kafli);
837 //wykonano=1;
838 }
839 // teczka2.czas=&zwloka;
840 // uchwyt_pilki = SDL_AddTimer(czas_zwloki, zwloka_dla_pilki, &teczka2);
841 }
842
843
844
845 cel = set_rect(0, 0, obraz->w, obraz->h);
846 zrodlo = set_rect(0, 0, obraz->w, obraz->h);
847 tex_screen = SDL_CreateTextureFromSurface(renderer, obraz);
848 SDL_RenderClear ( renderer );
849 SDL_RenderCopy(renderer, tex_screen,&zrodlo,&cel);
850 SDL_RenderPresent(renderer);
851 SDL_DestroyTexture(tex_screen);
852
853 SDL_Delay(40);
854 //SDL_Delay(500);
855 }
856 if (wynik>najlepszy){
857 najlepszy=wynik;
858 save_hiscore();
859 }
860 // SDL_RemoveTimer(uchwyt_pilki);
861 /* przywrocenie orginalnych ustawien */
862 //SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
863 return quit;
864 }
865
866
867
868 int main (int argc, char ** argv) {
869
870
871
872 if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
873 {
874 printf ("Nie mozna zainicjowac SDL: %s\n", SDL_GetError ());
875 exit (1);
876 }
877 atexit (SDL_Quit);
878
879 gWindow = SDL_CreateWindow( "Arkanoid", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_SHOWN );
880 if( gWindow == NULL )
881 {
882 printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
883 exit(1);
884 }
885 else
886 {
887 renderer = SDL_CreateRenderer(gWindow, -1,0);
888 SDL_SetRenderDrawColor ( renderer ,65, 190, 215 , 255 );
889 SDL_RenderClear ( renderer );
890 //Get window surface
891 obraz = SDL_GetWindowSurface( gWindow );
892
893 }
894
895
896 /* inicjalizacja fontow */
897 if(TTF_Init()==-1) {
898 printf("TTF_Init: %s\n", TTF_GetError());
899 exit(2);
900 }
901 atexit (TTF_Quit);
902
903
904
905 #if WINDOWS
906 #define NAZWAFONTU "SpicyRice.ttf"
907 #elif LINUX
908 //#define NAZWAFONTU "/usr/share/fonts/SpicyRice.ttf"
909 #define NAZWAFONTU "/usr/share/arkanoid/SpicyRice.ttf"
910 #endif
911
912 if((font_panel = TTF_OpenFont(NAZWAFONTU, WIELKOSCFONTU)) == NULL) {
913 printf("TTF_OpenFont: %s\n", TTF_GetError());
914 exit(1);
915 }
916 if (file_exist()){
917 load_hiscore();
918 }
919 else {
920 najlepszy=0;
921 }
922 while(SDL_TRUE){
923 if (gra()==SDL_TRUE){
924 if (end()==SDL_TRUE){
925 printf ("\n\nkontynuje\n");
926 continue;
927 }
928 else break;
929 }
930 }
931 printf ("\n\nwychodze\n");
932 SDL_DestroyTexture(tex_screen);
933 SDL_DestroyRenderer(renderer);
934 SDL_DestroyWindow(gWindow);
935 return 0;
936 }
937 // vi: sw=4: ts=4