Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1664 | pj | 1 | |
2 | #include <kernel/kern.h> |
||
3 | #include <drivers/glib.h> |
||
4 | #include <drivers/keyb.h> |
||
5 | #include <semaphore.h> |
||
6 | #include <stdlib.h> |
||
7 | #include <math.h> |
||
8 | |||
9 | #define ESC 27 |
||
10 | |||
11 | #define XMIN 0 |
||
12 | #define YMIN 0 |
||
13 | #define XMAX 640 |
||
14 | #define YMAX 480 |
||
15 | |||
16 | #define T_XMIN 120 |
||
17 | #define T_XMAX 560 |
||
18 | #define T_YMIN 150 |
||
19 | #define T_YMAX 450 |
||
20 | |||
21 | #define RXMIN 20 |
||
22 | #define RYMIN 10 |
||
23 | |||
24 | #define PIX_RATE 2 |
||
25 | #define BACKGROUND 7 |
||
26 | #define FOREGROUND 14 |
||
27 | #define T_BACKGROUND 9 |
||
28 | #define LEVEL 1 |
||
29 | #define PLAYER 2 |
||
30 | #define R_MAX 10 |
||
31 | |||
32 | #define FISHGROUP 1 |
||
33 | #define CROCGROUP 2 |
||
34 | #define RHGROUP 3 |
||
35 | #define HOOKGROUP 4 |
||
36 | |||
37 | #define C_DISTANCE 2 |
||
38 | |||
39 | int DEF_COLOR[] = {0,3,4,5,6,7,8,10,11,12,13,14,15}; |
||
40 | //double tick = 1.0; |
||
41 | PID p1, p2; |
||
42 | sem_t mutex, fmutex; |
||
43 | |||
44 | int FISH_PERIOD = 80000; |
||
45 | int FISH_WCET = 5000; |
||
46 | |||
47 | int CROC_PERIOD = 60000; |
||
48 | int CROC_WCET = 3000; |
||
49 | |||
50 | int ROD_PERIOD = 40000; |
||
51 | int ROD_WCET = 2000; |
||
52 | |||
53 | int HOOK_PERIOD = 30000; |
||
54 | int HOOK_WCET = 2000; |
||
55 | |||
56 | int BUBBLE_PERIOD = 90000; |
||
57 | int BUBBLE_WCET = 4000; |
||
58 | |||
59 | int TIME_PERIOD = 1000000; |
||
60 | int TIME_WCET = 7000; |
||
61 | |||
62 | int disp_x, disp_y; |
||
63 | int char_pix; |
||
64 | int player = 1; |
||
65 | int esc_s = -1; |
||
66 | int bubble_c = 5; |
||
67 | |||
68 | const int KEY_UP = 1; |
||
69 | const int KEY_DOWN = 2; |
||
70 | const int KEY_LEFT = 3; |
||
71 | const int KEY_RIGHT = 4; |
||
72 | |||
73 | enum { |
||
74 | LEFT = 75, /* Left arrow key */ |
||
75 | UP = 72, /* Up arrow key */ |
||
76 | RIGHT = 77, /* Right arrow key */ |
||
77 | DOWN = 80 /* Down arrow key */ |
||
78 | }; |
||
79 | |||
80 | struct p_cordinates { |
||
81 | int x; |
||
82 | int y; |
||
83 | }; |
||
84 | |||
85 | struct score { |
||
86 | int points; |
||
87 | int r_time; |
||
88 | int f_count; |
||
89 | int c4; |
||
90 | }; |
||
91 | |||
92 | struct p_color { |
||
93 | int c1; |
||
94 | int c2; |
||
95 | int c3; |
||
96 | int c4; |
||
97 | }; |
||
98 | |||
99 | struct p_props { |
||
100 | struct p_cordinates pos; |
||
101 | int size; |
||
102 | int velocity; |
||
103 | int hooked ; |
||
104 | struct p_color color; |
||
105 | int direction; |
||
106 | }; |
||
107 | |||
108 | struct p_hook { |
||
109 | struct p_cordinates h_pos; |
||
110 | struct p_cordinates r1_pos; |
||
111 | struct p_cordinates r2_pos; |
||
112 | struct p_props* f_pos; |
||
113 | struct p_color color; |
||
114 | struct score score; |
||
115 | int empty; |
||
116 | }; |
||
117 | |||
118 | struct p_game { |
||
119 | int level; |
||
120 | int player; |
||
121 | int fish_c; |
||
122 | int croc_c; |
||
123 | struct p_hook hook[2]; |
||
124 | }; |
||
125 | |||
126 | struct p_game game; |
||
127 | |||
128 | /******************************************************************/ |
||
129 | |||
130 | inline void init_fish_rod(int rod) { |
||
131 | game.hook[rod].h_pos.x = T_XMIN + RXMIN; |
||
132 | game.hook[rod].h_pos.y = T_YMIN + RYMIN; |
||
133 | game.hook[rod].r1_pos.x = T_XMIN; |
||
134 | game.hook[rod].r1_pos.y = T_YMIN + RYMIN; |
||
135 | game.hook[rod].r2_pos.x = T_XMIN + RXMIN; |
||
136 | game.hook[rod].r2_pos.y = T_YMIN + RYMIN; |
||
137 | game.hook[rod].empty = -1; |
||
138 | game.hook[rod].color.c1 = 0; |
||
139 | game.hook[rod].color.c2 = 15; |
||
140 | game.hook[rod].color.c3 = 4; |
||
141 | game.hook[rod].color.c4 = 14; |
||
142 | game.hook[rod].score.points = 0; |
||
143 | game.hook[rod].score.r_time = 0; |
||
144 | game.hook[rod].score.f_count = 0; |
||
145 | } |
||
146 | |||
147 | /*----------------------------------------------------------------*/ |
||
148 | |||
149 | inline void init_game() { |
||
150 | game.level = LEVEL; |
||
151 | game.player = 1; |
||
152 | game.fish_c = 8; |
||
153 | game.croc_c = 3; |
||
154 | init_fish_rod(0); |
||
155 | } |
||
156 | |||
157 | /******************************************************************/ |
||
158 | |||
159 | inline void set_fish_pos(struct p_cordinates* f_pos, int x, int y) { |
||
160 | sem_wait(&fmutex); |
||
161 | f_pos->x = x; |
||
162 | f_pos->y = y; |
||
163 | sem_post(&fmutex); |
||
164 | } |
||
165 | |||
166 | /*----------------------------------------------------------------*/ |
||
167 | |||
168 | inline struct p_cordinates* get_hook_pos(int rod) { |
||
169 | return &game.hook[rod].h_pos; |
||
170 | } |
||
171 | |||
172 | /*----------------------------------------------------------------*/ |
||
173 | |||
174 | inline int is_hooked(rod) { |
||
175 | return game.hook[rod].empty; |
||
176 | } |
||
177 | |||
178 | /*----------------------------------------------------------------*/ |
||
179 | |||
180 | inline int calc_dist(struct p_cordinates* d1, int size, int direction) { |
||
181 | struct p_cordinates* d2; |
||
182 | int ret_val = -1; |
||
183 | int range = size * direction; |
||
184 | int i, x, y; |
||
185 | for (i=0; i<player; i++) { |
||
186 | if(is_hooked(i) < 0) { |
||
187 | d2 = get_hook_pos(i); |
||
188 | x = (d1->x + range - d2->x) * (d1->x + range - d2->x); |
||
189 | y = (d1->y - d2->y) * (d1->y - d2->y); |
||
190 | |||
191 | if(sqrt(x + y) <= C_DISTANCE) { |
||
192 | ret_val = i; |
||
193 | break; |
||
194 | } |
||
195 | } |
||
196 | } |
||
197 | return ret_val; |
||
198 | } |
||
199 | |||
200 | /*----------------------------------------------------------------*/ |
||
201 | |||
202 | inline int calc_area(struct p_cordinates* d1, int size, int direction) { |
||
203 | struct p_cordinates* d2; |
||
204 | int ret_val = -1; |
||
205 | int i, x1, x2, y1, y2; |
||
206 | for (i=0; i<player; i++) { |
||
207 | if(is_hooked(i) > 0) { |
||
208 | d2 = get_hook_pos(i); |
||
209 | y1 = d1->y - size; |
||
210 | y2 = d1->y + size; |
||
211 | if(direction < 0) { |
||
212 | x1 = d1->x + size /2; |
||
213 | x2 = d1->x + 4 * size; |
||
214 | } |
||
215 | else |
||
216 | { |
||
217 | x1 = d1->x - 4 * size; |
||
218 | x2 = d1->x + size /2; |
||
219 | } |
||
220 | /* |
||
221 | char str[50]; |
||
222 | sprintf(str, "x=%d : x1=%d : x2=%d : y=%d : y1=%d : y2=%d", d2->x, x1, x2, d2->y, y1, y2); |
||
223 | grx_text(str, 100, 450, FOREGROUND, 0); |
||
224 | */ |
||
225 | if((d2->x > x1) & (d2->x < x2) & (d2->y > y1) & (d2->y < y2)) { |
||
226 | /* |
||
227 | sprintf(str, "x=%d : x1=%d : x2=%d : y=%d : y1=%d : y2=%d", d2->x, x1, x2, d2->y, y1, y2); |
||
228 | grx_text(str, 100, 400, FOREGROUND, 0); |
||
229 | */ |
||
230 | ret_val = i; |
||
231 | break; |
||
232 | } |
||
233 | } |
||
234 | } |
||
235 | return ret_val; |
||
236 | } |
||
237 | |||
238 | /******************************************************************/ |
||
239 | |||
240 | void draw_end() |
||
241 | { |
||
242 | sem_wait(&mutex); |
||
243 | grx_box(XMAX/3, YMAX/3, (XMAX/4)*3, YMAX/2, 0); |
||
244 | grx_box(XMAX/3 + 2, YMAX/3 + 2 , (XMAX/4)*3 - 2, YMAX/2 - 2, BACKGROUND); |
||
245 | grx_box(XMAX/3 + 4, YMAX/3 + 4 , (XMAX/4)*3 - 4, YMAX/2 - 4, 0); |
||
246 | grx_text("Thank You For 'Fishing'...", (XMAX/3 + 20), YMAX/3 + 20 , FOREGROUND, 0); |
||
247 | // grx_text("**************************", (XMAX/3 + 20), YMAX/3 + 40 , FOREGROUND, 0); |
||
248 | grx_text("Press 'ESC' To Exit...", (XMAX/3 + 20), YMAX/3 + 40 , FOREGROUND, 0); |
||
249 | sem_post(&mutex); |
||
250 | } |
||
251 | |||
252 | /*----------------------------------------------------------------*/ |
||
253 | |||
254 | inline void g_clear(struct p_cordinates* rp, int size, int color) |
||
255 | { |
||
256 | sem_wait(&mutex); |
||
257 | grx_disc(rp->x, rp->y, size, color); |
||
258 | sem_post(&mutex); |
||
259 | } |
||
260 | |||
261 | /*----------------------------------------------------------------*/ |
||
262 | |||
263 | inline void draw_rh(int key_pressed) { |
||
264 | int rod = 0; |
||
265 | // int temp = 0; |
||
266 | // char str[10]; |
||
267 | |||
268 | if(key_pressed == KEY_UP) { |
||
269 | if((game.hook[rod].empty < 0) & (game.hook[rod].h_pos.y > (T_YMIN + RYMIN))) { |
||
270 | game.hook[rod].h_pos.y -= PIX_RATE; |
||
271 | /* |
||
272 | grx_text("UP...", 490, 0, FOREGROUND, 0); |
||
273 | temp = game.hook[rod].h_pos.y; |
||
274 | sprintf(str, "%d", temp); |
||
275 | grx_text(str, 550, 0, FOREGROUND, 0); |
||
276 | */ |
||
277 | } |
||
278 | } |
||
279 | else if (key_pressed == KEY_DOWN) { |
||
280 | if((game.hook[rod].empty < 0) & (game.hook[rod].h_pos.y < (T_YMAX - RYMIN))) { |
||
281 | game.hook[rod].h_pos.y += PIX_RATE; |
||
282 | /* |
||
283 | grx_text("DOWN...", 490, 0, FOREGROUND, 0); |
||
284 | temp = game.hook[rod].h_pos.y; |
||
285 | sprintf(str, "%d", temp); |
||
286 | grx_text(str, 550, 0, FOREGROUND, 0); |
||
287 | */ |
||
288 | |||
289 | // TESTING THE HOOK RETURN WITH FISH. |
||
290 | // if(game.hook[rod].h_pos.y > 300){ |
||
291 | // game.hook[rod].empty = 1; |
||
292 | // } |
||
293 | } |
||
294 | } |
||
295 | else if (key_pressed == KEY_LEFT) { |
||
296 | if(game.hook[rod].r2_pos.x > (T_XMIN + RXMIN)) { |
||
297 | game.hook[rod].r2_pos.x -= (PIX_RATE * 2); |
||
298 | /* |
||
299 | grx_text("LEFT...", 490, 0, FOREGROUND, 0); |
||
300 | temp = game.hook[rod].r2_pos.x; |
||
301 | sprintf(str, "%d", temp); |
||
302 | grx_text(str, 550, 0, FOREGROUND, 0); |
||
303 | */ |
||
304 | } |
||
305 | } |
||
306 | else if (key_pressed == KEY_RIGHT) { |
||
307 | if(game.hook[rod].r2_pos.x < (T_XMAX - RXMIN)) { |
||
308 | game.hook[rod].r2_pos.x += (PIX_RATE * 2); |
||
309 | /* |
||
310 | grx_text("RIGHT...", 490, 0, FOREGROUND, 0); |
||
311 | temp = game.hook[rod].r2_pos.x; |
||
312 | sprintf(str, "%d", temp); |
||
313 | grx_text(str, 550, 0, FOREGROUND, 0); |
||
314 | */ |
||
315 | } |
||
316 | } |
||
317 | } |
||
318 | |||
319 | /*----------------------------------------------------------------*/ |
||
320 | |||
321 | void draw_bubble(struct p_props* fp) |
||
322 | { |
||
323 | sem_wait(&mutex); |
||
324 | grx_circle(fp->pos.x, fp->pos.y, fp->size, fp->color.c1); |
||
325 | sem_post(&mutex); |
||
326 | } |
||
327 | |||
328 | /*----------------------------------------------------------------*/ |
||
329 | |||
330 | inline void draw_croc(struct p_props* cp, int direction) |
||
331 | { |
||
332 | sem_wait(&mutex); |
||
333 | |||
334 | int tlen = cp->size/4; |
||
335 | if(direction == -1) { |
||
336 | grx_disc(cp->pos.x, cp->pos.y, cp->size, cp->color.c1); |
||
337 | grx_disc(cp->pos.x - cp->size, cp->pos.y, cp->size, cp->color.c2); |
||
338 | grx_box(cp->pos.x, cp->pos.y - tlen, cp->pos.x + (cp->size * 2), cp->pos.y + tlen, cp->color.c1); |
||
339 | grx_box(cp->pos.x + (cp->size * 2), cp->pos.y - cp->size, cp->pos.x + (cp->size * 4), cp->pos.y + cp->size, cp->color.c1); |
||
340 | grx_disc(cp->pos.x + (cp->size * 4), cp->pos.y, cp->size, cp->color.c2); |
||
341 | } |
||
342 | else { |
||
343 | grx_disc(cp->pos.x, cp->pos.y, cp->size, cp->color.c1); |
||
344 | grx_disc(cp->pos.x + cp->size, cp->pos.y, cp->size, cp->color.c2); |
||
345 | grx_box(cp->pos.x - (cp->size * 2), cp->pos.y - tlen, cp->pos.x, cp->pos.y + tlen, cp->color.c1); |
||
346 | grx_box(cp->pos.x - (cp->size * 4), cp->pos.y - cp->size, cp->pos.x - (cp->size * 2), cp->pos.y + cp->size, cp->color.c1); |
||
347 | grx_disc(cp->pos.x - (cp->size * 4), cp->pos.y, cp->size, cp->color.c2); |
||
348 | } |
||
349 | sem_post(&mutex); |
||
350 | } |
||
351 | |||
352 | /*----------------------------------------------------------------*/ |
||
353 | |||
354 | inline void draw_f(struct p_cordinates* fp, struct p_color* color, int size, int direction) |
||
355 | { |
||
356 | // char str[50]; |
||
357 | // int tmp; |
||
358 | sem_wait(&mutex); |
||
359 | int tlen = size * 2; |
||
360 | if(direction == -1) { |
||
361 | grx_disc(fp->x, fp->y, size, color->c1); |
||
362 | grx_disc(fp->x + size, fp->y, size, color->c2); |
||
363 | grx_disc(fp->x + tlen, fp->y, size, color->c3); |
||
364 | } |
||
365 | else { |
||
366 | grx_disc(fp->x, fp->y, size, color->c1); |
||
367 | grx_disc(fp->x - size, fp->y, size, color->c2); |
||
368 | grx_disc(fp->x - tlen, fp->y, size, color->c3); |
||
369 | } |
||
370 | // tmp = calc_dist(&(fp->pos), fp->size); |
||
371 | // sprintf(str, "%d", tmp); |
||
372 | // grx_text(str, fp->pos.x, fp->pos.y, T_BACKGROUND, 14); |
||
373 | sem_post(&mutex); |
||
374 | } |
||
375 | |||
376 | /*----------------------------------------------------------------*/ |
||
377 | |||
378 | inline void draw_fish(struct p_props* fp) |
||
379 | { |
||
380 | draw_f(&fp->pos, &fp->color, fp->size, fp->direction); |
||
381 | } |
||
382 | |||
383 | /*----------------------------------------------------------------*/ |
||
384 | |||
385 | inline void draw_rod(struct p_hook* rp, int direction) |
||
386 | { |
||
387 | sem_wait(&mutex); |
||
388 | grx_line(rp->r1_pos.x, rp->r1_pos.y, rp->r2_pos.x, rp->r2_pos.y, rp->color.c1); |
||
389 | grx_disc(rp->r2_pos.x, rp->r2_pos.y, 2, rp->color.c2); |
||
390 | sem_post(&mutex); |
||
391 | } |
||
392 | |||
393 | /*----------------------------------------------------------------*/ |
||
394 | |||
395 | inline void draw_hook(struct p_hook* rp, int direction) |
||
396 | { |
||
397 | sem_wait(&mutex); |
||
398 | |||
399 | if(rp->r2_pos.x < rp->h_pos.x) { |
||
400 | grx_line(rp->r2_pos.x, rp->r2_pos.y, rp->h_pos.x, rp->h_pos.y, rp->color.c1); |
||
401 | grx_line(rp->h_pos.x - 2, rp->h_pos.y - 2, rp->h_pos.x, rp->h_pos.y, rp->color.c3); |
||
402 | } |
||
403 | else { |
||
404 | grx_line(rp->h_pos.x, rp->h_pos.y, rp->r2_pos.x, rp->r2_pos.y, rp->color.c1); |
||
405 | grx_line(rp->h_pos.x, rp->h_pos.y, rp->h_pos.x + 2, rp->h_pos.y + 2, rp->color.c3); |
||
406 | } |
||
407 | grx_disc(rp->h_pos.x, rp->h_pos.y, 1, rp->color.c2); |
||
408 | sem_post(&mutex); |
||
409 | } |
||
410 | |||
411 | /******************************************************************/ |
||
412 | |||
413 | void end_game(void *arg) { |
||
414 | grx_close(); |
||
415 | cprintf("Ciao...\n"); |
||
416 | } |
||
417 | |||
418 | /*----------------------------------------------------------------*/ |
||
419 | |||
420 | inline void disp_score(int rod) { |
||
421 | char str[4]; |
||
422 | sem_wait(&mutex); |
||
423 | // grx_text("FISHES : 0", disp_x*3, disp_y + 50, FOREGROUND, 0); |
||
424 | sprintf(str, "%d", game.hook[rod].score.f_count); |
||
425 | grx_text(str, disp_x*3 + 65, disp_y + 50, FOREGROUND, 0); |
||
426 | // grx_text("LEVEL : '1'", disp_x*2, disp_y + 30, FOREGROUND, 0); |
||
427 | sprintf(str, "%d", game.level); |
||
428 | grx_text(str, disp_x*2 + 70, disp_y + 30, FOREGROUND, 0); |
||
429 | // grx_text("TIME LEFT : 01:00", disp_x*3, disp_y + 30, FOREGROUND, 0); |
||
430 | // sprintf(str, "%d", game.level); |
||
431 | // grx_text("SCORE : 0", disp_x*2, disp_y + 50, FOREGROUND, 0); |
||
432 | sprintf(str, "%d", game.hook[rod].score.points); |
||
433 | grx_text(str, disp_x*2 + 65, disp_y + 50, FOREGROUND, 0); |
||
434 | sem_post(&mutex); |
||
435 | } |
||
436 | |||
437 | /*----------------------------------------------------------------*/ |
||
438 | |||
439 | inline void set_score(int rod) { |
||
440 | game.hook[rod].score.f_count += 1; |
||
441 | game.hook[rod].score.points += 1; |
||
442 | disp_score(rod); |
||
443 | // game.hook[rod].score.r_time = 0; |
||
444 | } |
||
445 | |||
446 | /****************************************************************/ |
||
447 | |||
448 | TASK hook_t(void *arg) { |
||
449 | int rod = (int)arg; |
||
450 | struct p_hook* rp = &game.hook[rod]; |
||
451 | struct p_hook prp; |
||
452 | int direction = 1; |
||
453 | prp.color.c1 = T_BACKGROUND; |
||
454 | prp.color.c2 = T_BACKGROUND; |
||
455 | prp.color.c3 = T_BACKGROUND; |
||
456 | prp.r2_pos.x = rp->r2_pos.x; |
||
457 | prp.r2_pos.y = rp->r2_pos.y; |
||
458 | prp.h_pos.x = rp->h_pos.x; |
||
459 | prp.h_pos.y = rp->h_pos.y; |
||
460 | |||
461 | while (1) { |
||
462 | if(game.hook[rod].empty > 0) { |
||
463 | if(rp->h_pos.y > (T_YMIN + RYMIN)) { |
||
464 | rp->h_pos.y -= game.level; |
||
465 | draw_f(&rp->h_pos, &prp.color, rp->f_pos->size, rp->f_pos->direction); |
||
466 | // rp->f_pos->pos.x = rp->h_pos.x; |
||
467 | // rp->f_pos->pos.y = rp->h_pos.y; |
||
468 | set_fish_pos(&rp->f_pos->pos, rp->h_pos.x, rp->h_pos.y); |
||
469 | } |
||
470 | else |
||
471 | { |
||
472 | set_score(rod); |
||
473 | rp->empty = -1; |
||
474 | rp->f_pos->hooked = -1; |
||
475 | set_fish_pos(&rp->f_pos->pos, T_XMIN + (rp->f_pos->size * 3), T_YMIN + (RYMIN * 2) + ((T_YMAX - T_YMIN) / game.fish_c) * (rand()%(game.fish_c - 1))); |
||
476 | rp->f_pos = 0; |
||
477 | } |
||
478 | } |
||
479 | draw_hook(&prp, direction); |
||
480 | prp.h_pos.x = rp->h_pos.x; |
||
481 | prp.h_pos.y = rp->h_pos.y; |
||
482 | prp.r2_pos.x = rp->r2_pos.x; |
||
483 | rp->h_pos.x = rp->r2_pos.x; |
||
484 | draw_hook(rp, direction); |
||
485 | |||
486 | task_endcycle(); |
||
487 | } |
||
488 | } |
||
489 | |||
490 | /*----------------------------------------------------------------*/ |
||
491 | |||
492 | TASK rod_t(void *arg) { |
||
493 | int rod = (int)arg; |
||
494 | struct p_hook* rp = &game.hook[rod]; |
||
495 | struct p_hook prp; |
||
496 | int direction = 1; |
||
497 | prp.color.c1 = T_BACKGROUND; |
||
498 | prp.color.c2 = T_BACKGROUND; |
||
499 | prp.r1_pos.x = rp->r1_pos.x; |
||
500 | prp.r1_pos.y = rp->r1_pos.y; |
||
501 | prp.r2_pos.x = rp->r2_pos.x; |
||
502 | prp.r2_pos.y = rp->r2_pos.y; |
||
503 | |||
504 | while (1) { |
||
505 | draw_rod(&prp, direction); |
||
506 | prp.r2_pos.x = rp->r2_pos.x; |
||
507 | draw_rod(rp, direction); |
||
508 | |||
509 | task_endcycle(); |
||
510 | } |
||
511 | } |
||
512 | |||
513 | /*----------------------------------------------------------------*/ |
||
514 | |||
515 | TASK fish_t(void *arg) { |
||
516 | struct p_props fp; |
||
517 | struct p_props pfp; |
||
518 | // int fp.direction = 1; |
||
519 | // int p_direction = 1; |
||
520 | int s_player = -1; |
||
521 | fp.color.c1 = DEF_COLOR[rand()%12]; |
||
522 | fp.color.c2 = DEF_COLOR[rand()%12]; |
||
523 | fp.color.c3 = T_BACKGROUND; |
||
524 | fp.color.c4 = DEF_COLOR[rand()%12]; |
||
525 | fp.size = (rand()%10)+3; |
||
526 | fp.hooked = -1; |
||
527 | fp.pos.x = T_XMIN + (fp.size * 3); |
||
528 | fp.pos.y = T_YMIN + (RYMIN * 2) + ((T_YMAX - T_YMIN) / game.fish_c) * (rand()%(game.fish_c - 1)); |
||
529 | // set_fish_pos(&fp.pos, T_XMIN + (fp.size * 3), T_YMIN + (RYMIN * 2) + ((T_YMAX - T_YMIN) / game.fish_c) * (rand()%(game.fish_c - 1))); |
||
530 | fp.direction = 1; |
||
531 | pfp.pos.y = fp.pos.y; |
||
532 | pfp.color.c1 = T_BACKGROUND; |
||
533 | pfp.color.c2 = T_BACKGROUND; |
||
534 | pfp.color.c3 = T_BACKGROUND; |
||
535 | pfp.color.c4 = T_BACKGROUND; |
||
536 | pfp.size = fp.size; |
||
537 | |||
538 | if((rand()%10)>5) { |
||
539 | fp.direction *= -1; |
||
540 | fp.pos.x = T_XMAX - (fp.size * 3); |
||
541 | } |
||
542 | fp.pos.x += fp.direction * ((rand()%3) + PIX_RATE); |
||
543 | pfp.pos.x = fp.pos.x; |
||
544 | |||
545 | // char str[40]; |
||
546 | |||
547 | while (esc_s < 0) { |
||
548 | if(fp.hooked < 0) { |
||
549 | s_player = calc_dist(&fp.pos, fp.size, fp.direction); |
||
550 | if(s_player >= 0) { |
||
551 | game.hook[s_player].f_pos = &fp; |
||
552 | game.hook[s_player].empty = 1; |
||
553 | fp.hooked = 1; |
||
554 | } |
||
555 | else |
||
556 | { |
||
557 | fp.pos.x += fp.direction * PIX_RATE; |
||
558 | fp.hooked = -1; |
||
559 | if((fp.pos.x >= (T_XMAX - fp.size)) || (fp.pos.x <= (T_XMIN + fp.size))) { |
||
560 | fp.direction *= -1; |
||
561 | fp.pos.x += fp.direction * fp.size * 3; |
||
562 | // pfp.pos.x = fp.pos.x; |
||
563 | } |
||
564 | } |
||
565 | } |
||
566 | // grx_text("AM HERE...", 0, 465, FOREGROUND, 0); |
||
567 | draw_fish(&pfp); |
||
568 | draw_fish(&fp); |
||
569 | pfp.pos.x = fp.pos.x; |
||
570 | pfp.direction = fp.direction; |
||
571 | task_endcycle(); |
||
572 | } |
||
573 | } |
||
574 | |||
575 | /*----------------------------------------------------------------*/ |
||
576 | |||
577 | TASK croc_t(void *arg) { |
||
578 | struct p_props cp; |
||
579 | struct p_props pcp; |
||
580 | // int cp.direction=1; |
||
581 | int p_direction=1; |
||
582 | int s_player = -1; |
||
583 | cp.color.c1 = 2; |
||
584 | cp.color.c2 = T_BACKGROUND; |
||
585 | cp.size = 10; |
||
586 | cp.pos.x = T_XMIN + (cp.size * 6); |
||
587 | cp.pos.y = T_YMIN + (RYMIN * 2) + ((T_YMAX - T_YMIN - 100) / (game.fish_c - 3)) * (rand()%(game.fish_c - 3)); |
||
588 | cp.direction=1; |
||
589 | pcp.pos.y = cp.pos.y; |
||
590 | pcp.color.c1 = T_BACKGROUND; |
||
591 | pcp.color.c2 = T_BACKGROUND; |
||
592 | pcp.size = cp.size; |
||
593 | |||
594 | if((rand()%10)>5) { |
||
595 | cp.direction *= -1; |
||
596 | cp.pos.x = T_XMAX - (cp.size * 6); |
||
597 | } |
||
598 | cp.pos.x += cp.direction * ((rand()%3) + PIX_RATE); |
||
599 | pcp.pos.x = cp.pos.x; |
||
600 | |||
601 | while (esc_s < 0) { |
||
602 | s_player = calc_area(&cp.pos, cp.size, cp.direction); |
||
603 | char str[40]; |
||
604 | sprintf(str, "%d", s_player); |
||
605 | grx_text(str, 0, 450, FOREGROUND, 0); |
||
606 | if(s_player >= 0) { |
||
607 | grx_text("IN 1...", 0, 525, FOREGROUND, 0); |
||
608 | game.hook[s_player].empty = -1; |
||
609 | game.hook[s_player].f_pos->hooked = -1; |
||
610 | set_fish_pos(&game.hook[s_player].f_pos->pos, T_XMIN + (game.hook[s_player].f_pos->size * 3), T_YMIN + (RYMIN * 2) + ((T_YMAX - T_YMIN) / game.fish_c) * (rand()%(game.fish_c - 1))); |
||
611 | } |
||
612 | cp.pos.x += cp.direction * PIX_RATE; |
||
613 | if((cp.pos.x >= (T_XMAX - (cp.size * 2))) || (cp.pos.x <= (T_XMIN + (cp.size * 2)))) { |
||
614 | cp.direction *= -1; |
||
615 | cp.pos.x += cp.direction * cp.size * 6; |
||
616 | // pcp.pos.x = cp.pos.x; |
||
617 | } |
||
618 | |||
619 | draw_croc(&pcp, p_direction); |
||
620 | draw_croc(&cp, cp.direction); |
||
621 | p_direction = cp.direction; |
||
622 | pcp.pos.x = cp.pos.x; |
||
623 | |||
624 | task_endcycle(); |
||
625 | } |
||
626 | } |
||
627 | |||
628 | /*----------------------------------------------------------------*/ |
||
629 | |||
630 | TASK timeinterval_t(void *arg) { |
||
631 | struct timespec actual_timer; |
||
632 | int max_time = *((int *)arg); |
||
633 | |||
634 | int temp_sec = 0; |
||
635 | long sec,min; |
||
636 | char str[5]; |
||
637 | int len; |
||
638 | TIME seme; |
||
639 | //max_time = 2; |
||
640 | |||
641 | while(max_time > 0){ |
||
642 | sys_gettime(&actual_timer); |
||
643 | sec = actual_timer.tv_sec; |
||
644 | min = sec / 60; |
||
645 | sec %= 60; |
||
646 | temp_sec = 60 - sec - 1; |
||
647 | //if (temp_sec == 60){ |
||
648 | if (sec == 59 ){ |
||
649 | max_time--; |
||
650 | } |
||
651 | sprintf(str,"%02d:%02d",max_time,temp_sec); |
||
652 | len = strlen(str); |
||
653 | str[len] = '\0'; |
||
654 | sem_wait(&mutex); |
||
655 | // grx_text(str ,10, 50, RED, 0); |
||
656 | grx_text(str, disp_x*3 + 90, disp_y + 30, FOREGROUND, 0); |
||
657 | sem_post(&mutex); |
||
658 | task_endcycle(); |
||
659 | } |
||
660 | grx_text("Time Over" ,10, 70, RED, 0); |
||
661 | esc_s = 1; |
||
662 | draw_end(); |
||
663 | } |
||
664 | |||
665 | /*----------------------------------------------------------------*/ |
||
666 | |||
667 | TASK bubble_t(void *arg) { |
||
668 | struct p_props bp; |
||
669 | struct p_props pbp; |
||
670 | int direction=1; |
||
671 | int idelay; |
||
672 | bp.color.c1 = WHITE; |
||
673 | bp.color.c2 = BACKGROUND; |
||
674 | bp.size = 4; |
||
675 | int xval = rand()%9; |
||
676 | bp.pos.x = pbp.pos.x = T_XMIN + ((int)((T_XMAX-T_XMIN)/8 )) * xval; |
||
677 | bp.pos.y = T_YMAX - (bp.size * 2); |
||
678 | pbp.pos.y = bp.pos.y; |
||
679 | pbp.color.c1 = BACKGROUND; |
||
680 | pbp.color.c2 = BACKGROUND; |
||
681 | pbp.size = bp.size; |
||
682 | |||
683 | while (1) { |
||
684 | bp.pos.y -= PIX_RATE*(rand()%3) + 1 ; |
||
685 | if(bp.pos.y <= (T_YMIN + bp.size) ) { |
||
686 | for(idelay=0;idelay<999999;idelay++); |
||
687 | draw_bubble(&pbp); |
||
688 | xval = rand()%9; |
||
689 | bp.pos.x = pbp.pos.x = T_XMIN + ((int)((T_XMAX-T_XMIN)/8 )) * xval; |
||
690 | bp.pos.y = T_YMAX - (bp.size * 2); |
||
691 | pbp.pos.y = bp.pos.y; |
||
692 | } |
||
693 | |||
694 | draw_bubble(&pbp); |
||
695 | draw_bubble(&bp); |
||
696 | pbp.pos.y = bp.pos.y; |
||
697 | pbp.pos.x = bp.pos.x; |
||
698 | task_endcycle(); |
||
699 | } |
||
700 | } |
||
701 | |||
702 | /****************************************************************/ |
||
703 | |||
704 | void create_fish() { |
||
705 | SOFT_TASK_MODEL m1; |
||
706 | PID p1; |
||
707 | int count = 0; |
||
708 | int i = 0; |
||
709 | do { |
||
710 | soft_task_default_model (m1); |
||
711 | soft_task_def_level (m1, 1); |
||
712 | soft_task_def_ctrl_jet (m1); |
||
713 | soft_task_def_arg (m1, (void *)i); |
||
714 | soft_task_def_met (m1, FISH_WCET); |
||
715 | soft_task_def_period (m1, FISH_PERIOD); |
||
716 | soft_task_def_group (m1, FISHGROUP); |
||
717 | soft_task_def_usemath (m1); |
||
718 | p1 = task_create("fish", fish_t, &m1, NULL); |
||
719 | if (p1 == NIL) { |
||
720 | grx_close(); |
||
721 | perror("Could not create task <fish>"); |
||
722 | sys_abort(1); |
||
723 | } |
||
724 | task_activate(p1); |
||
725 | count++; |
||
726 | }while(count < game.fish_c); |
||
727 | } |
||
728 | |||
729 | /*----------------------------------------------------------------*/ |
||
730 | |||
731 | void create_croc() { |
||
732 | SOFT_TASK_MODEL m1; |
||
733 | PID p1; |
||
734 | int count = 0; |
||
735 | int i = 0; |
||
736 | do { |
||
737 | soft_task_default_model (m1); |
||
738 | soft_task_def_level (m1, 1); |
||
739 | soft_task_def_ctrl_jet (m1); |
||
740 | soft_task_def_arg (m1, (void *)i); |
||
741 | soft_task_def_met (m1, CROC_WCET); |
||
742 | soft_task_def_period (m1, CROC_PERIOD); |
||
743 | soft_task_def_group (m1, CROCGROUP); |
||
744 | soft_task_def_usemath (m1); |
||
745 | p1 = task_create("croc", croc_t, &m1, NULL); |
||
746 | if (p1 == NIL) { |
||
747 | grx_close(); |
||
748 | perror("Could not create task <croc>"); |
||
749 | sys_abort(1); |
||
750 | } |
||
751 | int delay = 0; |
||
752 | while(delay <= 500){ |
||
753 | delay++; |
||
754 | } |
||
755 | task_activate(p1); |
||
756 | count++; |
||
757 | }while(count <= game.croc_c); |
||
758 | } |
||
759 | |||
760 | /*----------------------------------------------------------------*/ |
||
761 | |||
762 | void create_rod() { |
||
763 | SOFT_TASK_MODEL m1; |
||
764 | PID p1; |
||
765 | int count = 0; |
||
766 | int i = 0; |
||
767 | do { |
||
768 | soft_task_default_model (m1); |
||
769 | soft_task_def_level (m1, 1); |
||
770 | soft_task_def_ctrl_jet (m1); |
||
771 | soft_task_def_arg (m1, (void *)i); |
||
772 | soft_task_def_met (m1, ROD_WCET); |
||
773 | soft_task_def_period (m1, ROD_PERIOD); |
||
774 | soft_task_def_group (m1, RHGROUP); |
||
775 | soft_task_def_usemath (m1); |
||
776 | p1 = task_create("rod", rod_t, &m1, NULL); |
||
777 | if (p1 == NIL) { |
||
778 | grx_close(); |
||
779 | perror("Could not create task <rod>"); |
||
780 | sys_abort(1); |
||
781 | } |
||
782 | int delay = 0; |
||
783 | while(delay <= 500){ |
||
784 | delay++; |
||
785 | } |
||
786 | task_activate(p1); |
||
787 | count++; |
||
788 | }while(count < player); |
||
789 | } |
||
790 | |||
791 | /*----------------------------------------------------------------*/ |
||
792 | |||
793 | void create_hook() { |
||
794 | SOFT_TASK_MODEL m1; |
||
795 | PID p1; |
||
796 | int count = 0; |
||
797 | int i = 0; |
||
798 | do { |
||
799 | soft_task_default_model (m1); |
||
800 | soft_task_def_level (m1, 1); |
||
801 | soft_task_def_ctrl_jet (m1); |
||
802 | soft_task_def_arg (m1, (void *)i); |
||
803 | soft_task_def_met (m1, HOOK_WCET); |
||
804 | soft_task_def_period (m1, HOOK_PERIOD); |
||
805 | soft_task_def_group (m1, HOOKGROUP); |
||
806 | soft_task_def_usemath (m1); |
||
807 | p1 = task_create("hook", hook_t, &m1, NULL); |
||
808 | if (p1 == NIL) { |
||
809 | grx_close(); |
||
810 | perror("Could not create task <hook>"); |
||
811 | sys_abort(1); |
||
812 | } |
||
813 | int delay = 0; |
||
814 | while(delay <= 500){ |
||
815 | delay++; |
||
816 | } |
||
817 | task_activate(p1); |
||
818 | count++; |
||
819 | }while(count < player); |
||
820 | } |
||
821 | |||
822 | /*----------------------------------------------------------------*/ |
||
823 | |||
824 | void create_bubble() { |
||
825 | SOFT_TASK_MODEL s1; |
||
826 | |||
827 | PID p1; |
||
828 | int count = 0; |
||
829 | int i = 0; |
||
830 | |||
831 | do { |
||
832 | soft_task_default_model(s1); |
||
833 | soft_task_def_level(s1,1); |
||
834 | soft_task_def_ctrl_jet (s1); |
||
835 | soft_task_def_arg(s1, (void *)i); |
||
836 | soft_task_def_met(s1, BUBBLE_WCET); |
||
837 | soft_task_def_period(s1,BUBBLE_PERIOD); |
||
838 | soft_task_def_usemath(s1); |
||
839 | p1 = task_create("bubble", bubble_t, &s1, NULL); |
||
840 | if (p1 == NIL) { |
||
841 | grx_close(); |
||
842 | perror("Could not create task <bubble>"); |
||
843 | sys_abort(1); |
||
844 | } |
||
845 | task_activate(p1); |
||
846 | count++; |
||
847 | }while(count <= bubble_c); |
||
848 | } |
||
849 | |||
850 | /*----------------------------------------------------------------*/ |
||
851 | |||
852 | void create_timer(int max_time) { |
||
853 | SOFT_TASK_MODEL s1; |
||
854 | PID p1; |
||
855 | int i = max_time; |
||
856 | void *p = &i; |
||
857 | soft_task_default_model(s1); |
||
858 | soft_task_def_level(s1,1); |
||
859 | soft_task_def_ctrl_jet (s1); |
||
860 | soft_task_def_arg(s1, p); |
||
861 | soft_task_def_met(s1, TIME_WCET); |
||
862 | soft_task_def_period(s1,TIME_PERIOD); |
||
863 | soft_task_def_usemath(s1); |
||
864 | p1 = task_create("timer", timeinterval_t, &s1, NULL); |
||
865 | if (p1 == NIL) { |
||
866 | grx_close(); |
||
867 | perror("Could not create task <timer>"); |
||
868 | sys_abort(1); |
||
869 | } |
||
870 | task_activate(p1); |
||
871 | } |
||
872 | |||
873 | /****************************************************************/ |
||
874 | |||
875 | void init_display() { |
||
876 | /* graphic card Initialization */ |
||
877 | if (grx_init() < 1) { |
||
878 | sys_abort(1); |
||
879 | } |
||
880 | |||
881 | if (grx_open(XMAX, YMAX, 8) < 0) { |
||
882 | cprintf("GRX Err\n"); |
||
883 | sys_abort(1); |
||
884 | } |
||
885 | sem_wait(&mutex); |
||
886 | disp_x = (XMAX - XMIN)/6; |
||
887 | disp_y = (T_YMIN - YMIN)/8; |
||
888 | char_pix = 12; |
||
889 | |||
890 | // Initial Screen. |
||
891 | grx_box(XMIN, YMIN, XMAX, YMAX, BACKGROUND); |
||
892 | grx_box(disp_x, disp_y, (disp_x)*5, (disp_y)*6, 0); |
||
893 | grx_box(disp_x + 2, disp_y + 2, (disp_x)*5 - 2, (disp_y)*6 - 2, BACKGROUND); |
||
894 | grx_box(disp_x + 4, disp_y + 4, (disp_x)*5 - 4, (disp_y)*6 - 4, 0); |
||
895 | grx_text("ENJOY FISHING", disp_x*3 - (char_pix * 6), disp_y + 10, FOREGROUND, 0); |
||
896 | grx_text("LEVEL : '1'", disp_x*2, disp_y + 30, FOREGROUND, 0); |
||
897 | grx_text("TIME LEFT :", disp_x*3, disp_y + 30, FOREGROUND, 0); |
||
898 | grx_text("FISHES : ", disp_x*3, disp_y + 50, FOREGROUND, 0); |
||
899 | grx_text("SCORE : ", disp_x*2, disp_y + 50, FOREGROUND, 0); |
||
900 | grx_text("Press 'ESC' to Exit...", disp_x*3 - (char_pix * 6), disp_y*6 - char_pix - 3, FOREGROUND, 0); |
||
901 | |||
902 | // Tank Draw. |
||
903 | grx_box(T_XMIN - 4, T_YMIN - 4, T_XMAX + 4, T_YMAX + 4, 0); |
||
904 | grx_rect(T_XMIN - 3, T_YMIN - 3, T_XMAX + 3, T_YMAX + 3, 0); |
||
905 | grx_box(T_XMIN - 1, T_YMIN - 1, T_XMAX + 1, T_YMAX + 1 , T_BACKGROUND); |
||
906 | |||
907 | // disp_x = disp_x * 2; |
||
908 | // disp_y = disp_y + 25; |
||
909 | sem_post(&mutex); |
||
910 | } |
||
911 | |||
912 | /****************************************************************/ |
||
913 | |||
914 | int main(int argc, char **argv) { |
||
915 | char c; /* character from keyboard */ |
||
916 | TIME seme; /* used to init the random seed */ |
||
917 | |||
918 | sys_atrunlevel(end_game, NULL, RUNLEVEL_BEFORE_EXIT); |
||
919 | |||
920 | init_display(); |
||
921 | seme = sys_gettime(NULL); |
||
922 | srand(seme); |
||
923 | |||
924 | init_game(); |
||
925 | create_fish(); |
||
926 | create_croc(); |
||
927 | create_rod(); |
||
928 | create_hook(); |
||
929 | // create_bubble(); |
||
930 | create_timer(2); // Pass the upper limit in minutes |
||
931 | |||
932 | KEY_EVT k; |
||
933 | k.ascii = 0; |
||
934 | |||
935 | do { |
||
936 | keyb_getcode(&k, BLOCK); |
||
937 | |||
938 | switch (k.scan) { |
||
939 | case LEFT : |
||
940 | draw_rh(KEY_LEFT); |
||
941 | break; |
||
942 | case UP : |
||
943 | draw_rh(KEY_UP); |
||
944 | break; |
||
945 | case RIGHT : |
||
946 | draw_rh(KEY_RIGHT); |
||
947 | break; |
||
948 | case DOWN : |
||
949 | draw_rh(KEY_DOWN); |
||
950 | break; |
||
951 | } |
||
952 | }while (k.ascii != ESC); |
||
953 | esc_s = 1; |
||
954 | draw_end(); |
||
955 | |||
956 | while((c = keyb_getch(BLOCK)) != ESC){ |
||
957 | } |
||
958 | |||
959 | sys_end(); |
||
960 | return 0; |
||
961 | } |
||
962 | |||
963 | /******************************************************************/ |