Rev 5225 | Rev 5291 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5225 | alpine | 1 | #include "rsgame.h" |
2 | |||
3 | #include "rsgametext.h" |
||
4 | |||
5 | #include "rsgamemenu.h" |
||
6 | |||
7 | #include "rsgamedraw.h" |
||
8 | |||
9 | #include "rskos.h" |
||
10 | |||
11 | #include "rsgentex.h" |
||
12 | #include "rssoundgen.h" |
||
13 | #include "rsnoise.h" |
||
14 | |||
15 | #include "rs/rsplatform.h" |
||
16 | |||
17 | |||
18 | #ifdef RS_USE_C_LIBS // linux version |
||
19 | #include |
||
20 | #include |
||
21 | #include |
||
22 | |||
23 | #include "rs/rskeyboard.h" |
||
24 | #endif |
||
25 | |||
26 | |||
5243 | alpine | 27 | |
5225 | alpine | 28 | rs_game_t game; |
29 | |||
30 | |||
31 | void texture_init(rs_texture_t *tex, int w, int h) { |
||
32 | tex->status = 1; |
||
33 | tex->w = w; |
||
34 | tex->h = h; |
||
35 | tex->data = malloc(w*h*4); // BGRA BGRA |
||
36 | }; |
||
37 | |||
38 | void texture_free(rs_texture_t *tex) { |
||
39 | free(tex->data); |
||
40 | tex->status = 0; |
||
41 | }; |
||
42 | |||
43 | void texture_clear(rs_texture_t *tex, unsigned int color) { |
||
44 | int i; |
||
45 | for (i = 0; i < tex->w * tex->h; i++) { |
||
46 | *((unsigned int*)(&tex->data[i*4])) = color; |
||
47 | }; |
||
48 | }; |
||
49 | |||
50 | void texture_draw(rs_texture_t *dest, rs_texture_t *src, int x, int y, int mode) { |
||
51 | |||
52 | int i; // y |
||
53 | int j; // x |
||
54 | int k; // color component |
||
55 | |||
56 | int istart = (y < 0) ? -y : 0; |
||
57 | int iend = src->h - (( (y + src->h) > dest->h) ? (y + src->h - dest->h) : 0); |
||
58 | |||
59 | int jstart = (x < 0) ? -x : 0; |
||
60 | int jend = src->w - (( (x + src->w) > dest->w) ? (x + src->w - dest->w) : 0); |
||
61 | |||
62 | int ishift = 0; |
||
63 | int jshift = 0; |
||
64 | |||
65 | float a; // alpha value |
||
66 | |||
67 | if (mode & DRAW_TILED_FLAG) { |
||
68 | jshift = x; |
||
69 | ishift = y; |
||
70 | x = y = istart = jstart = 0; |
||
71 | iend = dest->h; |
||
72 | jend = dest->w; |
||
73 | }; |
||
74 | |||
75 | mode = mode & DRAW_MODE_MASK; |
||
76 | |||
77 | int modvalue = (src->w*src->h*4); |
||
78 | |||
79 | if (mode == DRAW_MODE_REPLACE) { |
||
80 | for (i = istart; i < iend; i++) { |
||
81 | for (j = jstart; j < jend; j++) { |
||
82 | for (k = 0; k < 4; k++) { |
||
83 | dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] = src->data[ (4*(i*src->w + j) + k) % modvalue ]; |
||
84 | }; |
||
85 | }; |
||
86 | }; |
||
87 | } |
||
88 | else if (mode == DRAW_MODE_ADDITIVE) { |
||
89 | for (i = istart; i < iend; i++) { |
||
90 | for (j = jstart; j < jend; j++) { |
||
91 | for (k = 0; k < 3; k++) { // Alpha channel is not added |
||
92 | dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] = |
||
93 | clamp_byte( dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] + src->data[ (4*((i+ishift)*src->w + j + jshift) + k) % modvalue] ); |
||
94 | }; |
||
95 | }; |
||
96 | }; |
||
97 | } |
||
98 | else if (mode == DRAW_MODE_ALPHA) { |
||
99 | for (i = istart; i < iend; i++) { |
||
100 | for (j = jstart; j < jend; j++) { |
||
101 | for (k = 0; k < 3; k++) { |
||
102 | a = (1.0 * src->data[ (4*(i*src->w + j) + 3) % modvalue ] / 255.0); |
||
103 | dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] = |
||
104 | (unsigned char) ( (1.0-a) * dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] |
||
105 | + a*src->data[ (4*((i+ishift)*src->w + j + jshift) + k) % modvalue] ); |
||
106 | }; |
||
107 | }; |
||
108 | }; |
||
109 | }; |
||
110 | |||
111 | }; |
||
112 | |||
113 | |||
114 | |||
115 | void texture_set_pixel(rs_texture_t *tex, int x, int y, unsigned int color) { |
||
116 | *((unsigned int*) &tex->data[ 4 * ( (y)*tex->w + (x) ) + 0 ]) = color; |
||
117 | }; |
||
118 | |||
119 | void texture_draw_vline(rs_texture_t *tex, int x, int y, int l, unsigned int color) { |
||
120 | int i; |
||
121 | if (y+l >= tex->h) { |
||
122 | l = tex->h - y; |
||
123 | }; |
||
124 | for (i = 0; i < l; i++) { |
||
125 | *((unsigned int*) &tex->data[ 4 * ( (y+i)*tex->w + (x) ) + 0 ]) = color; |
||
126 | }; |
||
127 | }; |
||
128 | |||
129 | |||
130 | |||
131 | void soundbuf_init(rs_soundbuf_t *snd, int length_samples) { |
||
132 | snd->status = 1; |
||
133 | snd->length_samples = length_samples; |
||
134 | snd->data = malloc(length_samples*2); |
||
135 | rskos_snd_create_buffer(&snd->hbuf, snd->data, length_samples); |
||
136 | }; |
||
137 | |||
138 | void soundbuf_free(rs_soundbuf_t *snd) { |
||
139 | snd->status = 0; |
||
140 | free(snd->data); |
||
141 | }; |
||
142 | |||
143 | void soundbuf_fill(rs_soundbuf_t *snd, int amp, int freq_div) { |
||
144 | int i; |
||
145 | for (i = 0; i < snd->length_samples; i++) { |
||
146 | snd->data[i] = -amp/2 + amp/2*( ( (i % freq_div) > freq_div/2 ) ? 1 : 0 ); |
||
147 | }; |
||
148 | rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples); |
||
149 | }; |
||
150 | |||
151 | void soundbuf_sin(rs_soundbuf_t *snd, float freq) { |
||
152 | int i; |
||
153 | int amp = 29000; |
||
154 | for (i = 0; i < snd->length_samples; i++) { |
||
155 | snd->data[i] = ( 1.0 - 1.0*i/snd->length_samples ) * sin(freq*i) * amp; |
||
156 | }; |
||
157 | rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples); |
||
158 | }; |
||
159 | |||
160 | void soundbuf_sin_fade(rs_soundbuf_t *snd, float freq) { |
||
161 | int i; |
||
162 | int amp = 29000; |
||
163 | for (i = 0; i < snd->length_samples; i++) { |
||
164 | snd->data[i] = ( 1.0 - 1.0*i/snd->length_samples ) * sin( ( (1.0 - 0.48*i/snd->length_samples) * freq ) *i) * amp; |
||
165 | }; |
||
5243 | alpine | 166 | |
167 | |||
168 | /* |
||
169 | |||
170 | // ok |
||
171 | |||
172 | rs_sgen_init(2, snd->length_samples); |
||
173 | rs_sgen_func_pm(1, 880.0, 21.0, 0.3, 110.0, 0.3); |
||
174 | rs_sgen_func_normalize(1, 1.0); |
||
175 | rs_sgen_func_lowpass(0, 1, 1.0, 0.0, 1.0); |
||
176 | rs_sgen_wave_out(0); |
||
177 | |||
178 | memcpy(snd->data, rs_sgen_reg.wave_out, snd->length_samples*2 ); |
||
179 | |||
180 | rs_sgen_term(); |
||
181 | |||
182 | */ |
||
183 | |||
5225 | alpine | 184 | rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples); |
185 | }; |
||
186 | |||
187 | void soundbuf_play(rs_soundbuf_t *snd) { |
||
188 | rskos_snd_play(&snd->hbuf, 0); |
||
189 | }; |
||
190 | |||
191 | void soundbuf_stop(rs_soundbuf_t *snd) { |
||
192 | rskos_snd_stop(&snd->hbuf); |
||
193 | }; |
||
194 | |||
195 | |||
196 | |||
197 | unsigned char clamp_byte(int value) { |
||
198 | value = value * (1 - (value >> 31)); // negative to zero |
||
199 | return (value > 255) ? 255 : value; |
||
200 | }; |
||
201 | |||
202 | |||
203 | void game_reg_init() { |
||
204 | game.tx = 0; |
||
205 | game.ty = 0; |
||
206 | game.tz = 0; |
||
207 | |||
208 | int i; |
||
209 | for (i = 0; i < BULLETS_COUNT; i++) { |
||
210 | game.bullet_x[i] = 0; |
||
211 | game.bullet_y[i] = 0; |
||
212 | }; |
||
213 | game.bullet_index = 0; |
||
214 | |||
215 | game.status = STATUS_MENU; |
||
216 | |||
217 | game.window_scale = 2; |
||
5243 | alpine | 218 | #ifndef RS_KOS |
5225 | alpine | 219 | game.window_scale = 3; |
5243 | alpine | 220 | window_scale_str[3] = '3'; |
5225 | alpine | 221 | #endif |
222 | |||
223 | game.keyboard_state = 0; |
||
224 | |||
225 | game.menu_index = 0; |
||
226 | game.menu_item_index = 0; |
||
227 | }; |
||
228 | |||
229 | |||
230 | int is_key_pressed(int mask) { |
||
231 | return IS_BIT_SET(game.keyboard_state, mask) ? 1 : 0; |
||
232 | }; |
||
233 | |||
234 | |||
235 | void GameProcess() { |
||
236 | |||
237 | if (game.status == STATUS_PLAYING) { |
||
238 | |||
239 | // shoot |
||
240 | |||
241 | if ( (game.shoot_keypressed) || (is_key_pressed(RS_ATTACK_KEY_MASK)) ) { |
||
242 | |||
243 | game.shoot_delay ++; |
||
244 | |||
245 | if (game.shoot_delay > GAME_SHOOT_PERIOD) { |
||
246 | |||
247 | // if ( (game.tx > 0) && (game.ty > 5) && (game.tx < GAME_WIDTH-20) && (game.ty < GAME_HEIGHT-10) ) { |
||
248 | |||
249 | soundbuf_play(&game.sound_test1); |
||
250 | |||
251 | game.bullet_index++; |
||
252 | game.bullet_index %= BULLETS_COUNT; |
||
253 | game.bullet_x[game.bullet_index] = game.tx + 5; |
||
254 | game.bullet_y[game.bullet_index] = game.ty; |
||
255 | // }; |
||
256 | |||
257 | game.shoot_delay -= GAME_SHOOT_PERIOD; |
||
258 | game.shoot_keypressed = 0; |
||
259 | |||
260 | }; |
||
261 | }; |
||
262 | |||
263 | |||
264 | |||
265 | |||
266 | int speed = 4; |
||
267 | int bullet_speed = 11; |
||
268 | |||
269 | game.tx += speed * ( is_key_pressed(RS_ARROW_RIGHT_MASK) - is_key_pressed(RS_ARROW_LEFT_MASK) ); |
||
270 | game.ty += speed * ( is_key_pressed(RS_ARROW_DOWN_MASK) - is_key_pressed(RS_ARROW_UP_MASK) ); |
||
271 | |||
272 | game.tx = rs_clamp_i(game.tx, 5, GAME_WIDTH-25); |
||
273 | game.ty = rs_clamp_i(game.ty, 5, GAME_HEIGHT - 25); |
||
274 | |||
275 | game.tz += 1; |
||
276 | |||
277 | int i; |
||
278 | for (i = 0; i < BULLETS_COUNT; i++) { |
||
279 | if (game.bullet_y[i]) { |
||
280 | game.bullet_x[i] += bullet_speed; |
||
281 | if (game.bullet_x[i] > GAME_WIDTH) { |
||
282 | game.bullet_y[i] = 0; |
||
283 | }; |
||
284 | }; |
||
285 | }; |
||
286 | |||
287 | }; |
||
288 | |||
289 | game_draw(); |
||
290 | |||
291 | } |
||
292 | |||
293 | |||
294 | |||
295 | |||
296 | |||
297 | void GameInit() { |
||
298 | |||
299 | game_reg_init(); |
||
300 | |||
301 | game.scaled_framebuffer = malloc(GAME_WIDTH*game.window_scale * GAME_HEIGHT*game.window_scale * 3); |
||
302 | DEBUG10f("scaled framebuffer: %d (window_scale = %d) \n", game.window_scale * GAME_WIDTH * GAME_HEIGHT * 3, game.window_scale); |
||
303 | |||
304 | game_font_init(); |
||
305 | |||
306 | texture_init(&game.framebuffer, GAME_WIDTH, GAME_HEIGHT); |
||
307 | |||
308 | texture_init(&game.tex, 64, 64); |
||
309 | rs_gen_init(1, 64); |
||
310 | rs_gen_func_set(0, 0.0); |
||
311 | rs_gen_func_cell(0, 1200, 10, NULL, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0); |
||
312 | rs_gen_func_normalize(0, 0.0, 1.0); |
||
313 | rs_gen_func_posterize(0, 5); |
||
314 | rs_gen_tex_out_rgba(0, 0, 0, -1, 1.0, 1.0, 1.0, 1.0); |
||
315 | memcpy(game.tex.data, rs_gen_reg.tex_out, 64*64*4 ); |
||
316 | rs_gen_term(); |
||
317 | |||
318 | texture_init(&game.tex_clouds, 128, 128); |
||
319 | rs_gen_init(1, 128); |
||
320 | rs_gen_func_perlin(0, 8, 5, 0.5, 1100); |
||
321 | rs_gen_func_normalize(0, 0.0, 1.0); |
||
322 | rs_gen_func_posterize(0, 4); |
||
323 | rs_gen_func_normalize(0, 0.0, 0.50); |
||
324 | rs_gen_tex_out_rgba(0, 0, 0, -1, 0.9, 0.7, 0.5, 1.0); |
||
325 | memcpy(game.tex_clouds.data, rs_gen_reg.tex_out, 128*128*4 ); |
||
326 | rs_gen_term(); |
||
327 | |||
328 | texture_init(&game.tex_ground, GAME_WIDTH, 50); |
||
329 | |||
330 | |||
331 | |||
332 | int ship_size = 8; |
||
333 | |||
334 | // 16x8 |
||
335 | |||
336 | unsigned char tex_ship1_mask[] = { 0x10, 0x58, 0x7C, 0x7C, 0x3E, 0x1E, 0xBE, 0xFE }; |
||
337 | unsigned char tex_ship2_mask[] = { 0x7C, 0x7C, 0x7E, 0x7E, 0x3C, 0x3C, 0x1C, 0x18 }; |
||
338 | unsigned char tex_ship1_overlay_mask[] = { 0x10, 0x18, 0x1C, 0x1C, 0x1C, 0x1C, 0x8C, 0x84 }; |
||
339 | unsigned char tex_ship2_overlay_mask[] = { 0x00, 0x00, 0x20, 0x20, 0x30, 0x30, 0x10, 0x10 }; |
||
340 | |||
341 | texture_init(&game.tex_ship[0], ship_size, ship_size); |
||
342 | rs_gen_init(2, ship_size); |
||
343 | rs_gen_func_perlin(0, 8, 5, 0.5, 111); |
||
344 | rs_gen_func_normalize(0, 0.0, 1.0); |
||
345 | rs_gen_func_posterize(0, 2); |
||
346 | rs_gen_func_mult_add_value(0, 0, 0.3, 0.7); |
||
347 | |||
348 | rs_gen_func_set(1, 1.0); |
||
349 | rs_gen_func_apply_mask(1, tex_ship1_mask); |
||
350 | // rs_gen_func_mult_add_value(1, 1, 0.8, 0.2); |
||
351 | rs_gen_tex_out_rgba(0, 0, 0, 1, 0.8, 0.65, 0.66, 1.0); |
||
352 | memcpy(game.tex_ship[0].data, rs_gen_reg.tex_out, ship_size*ship_size*4 ); |
||
353 | rs_gen_term(); |
||
354 | |||
355 | texture_init(&game.tex_ship[1], ship_size, ship_size); |
||
356 | rs_gen_init(2, ship_size); |
||
357 | rs_gen_func_perlin(0, 8, 5, 0.5, 1100); |
||
358 | rs_gen_func_normalize(0, 0.0, 1.0); |
||
359 | rs_gen_func_posterize(0, 2); |
||
360 | rs_gen_func_mult_add_value(0, 0, 0.1, 0.9); |
||
361 | |||
362 | rs_gen_func_set(1, 1.0); |
||
363 | rs_gen_func_apply_mask(1, tex_ship1_overlay_mask); |
||
364 | // rs_gen_func_mult_add_value(1, 1, 0.8, 0.2); |
||
365 | rs_gen_tex_out_rgba(0, 0, 0, 1, 0.4, 0.3, 0.3, 1.0); |
||
366 | memcpy(game.tex_ship[1].data, rs_gen_reg.tex_out, ship_size*ship_size*4 ); |
||
367 | rs_gen_term(); |
||
368 | |||
369 | |||
370 | texture_init(&game.tex_ship[2], ship_size, ship_size); |
||
371 | rs_gen_init(2, ship_size); |
||
372 | rs_gen_func_perlin(0, 8, 5, 0.5, 111); |
||
373 | rs_gen_func_normalize(0, 0.0, 1.0); |
||
374 | rs_gen_func_posterize(0, 2); |
||
375 | rs_gen_func_mult_add_value(0, 0, 0.3, 0.7); |
||
376 | // rs_gen_func_set(0, 1.0); |
||
377 | rs_gen_func_set(1, 1.0); |
||
378 | rs_gen_func_apply_mask(1, tex_ship2_mask); |
||
379 | // rs_gen_func_mult_add_value(1, 1, 0.8, 0.2); |
||
380 | rs_gen_tex_out_rgba(0, 0, 0, 1, 0.8, 0.65, 0.66, 1.0); |
||
381 | memcpy(game.tex_ship[2].data, rs_gen_reg.tex_out, ship_size*ship_size*4 ); |
||
382 | rs_gen_term(); |
||
383 | |||
384 | texture_init(&game.tex_ship[3], ship_size, ship_size); |
||
385 | rs_gen_init(2, ship_size); |
||
386 | rs_gen_func_perlin(0, 8, 5, 0.5, 1100); |
||
387 | rs_gen_func_normalize(0, 0.0, 1.0); |
||
388 | rs_gen_func_posterize(0, 2); |
||
389 | rs_gen_func_mult_add_value(0, 0, 0.1, 0.9); |
||
390 | |||
391 | rs_gen_func_set(1, 1.0); |
||
392 | rs_gen_func_apply_mask(1, tex_ship2_overlay_mask); |
||
393 | // rs_gen_func_mult_add_value(1, 1, 0.8, 0.2); |
||
394 | rs_gen_tex_out_rgba(0, 0, 0, 1, 0.4, 0.3, 0.2, 1.0); |
||
395 | memcpy(game.tex_ship[3].data, rs_gen_reg.tex_out, ship_size*ship_size*4 ); |
||
396 | rs_gen_term(); |
||
397 | |||
398 | |||
399 | texture_init(&game.tex_gui_line, GAME_WIDTH, 13); |
||
400 | int i; |
||
401 | for (i = 0; i < GAME_WIDTH*13; i++) { |
||
402 | ( (unsigned int*) (game.tex_gui_line.data)) [i] = 0x668899AA; |
||
403 | }; |
||
404 | |||
405 | |||
406 | int rock_size = 32; |
||
407 | rs_gen_init(3, rock_size); |
||
408 | for (i = 0; i < ROCKS_COUNT; i++) { |
||
409 | |||
410 | DEBUG10f("loading %d ...\n", i); |
||
411 | |||
412 | texture_init(&(game.tex_rocks[i]), rock_size, rock_size); |
||
413 | |||
414 | DEBUG10f("loading %d z...\n", i); |
||
415 | |||
416 | rs_gen_func_set(0, 0.0); |
||
417 | rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5); |
||
418 | |||
419 | rs_gen_func_perlin(2, 33, 4, 0.5, 350+i); |
||
420 | rs_gen_func_normalize(2, 0.0, 1.0); |
||
421 | rs_gen_func_posterize(2, 4); |
||
422 | |||
423 | rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0); |
||
424 | rs_gen_func_posterize(1, 2); |
||
425 | rs_gen_func_normalize(1, 0.0, 1.0); |
||
426 | rs_gen_func_add(1, 1, 2, 1.0, 0.5); |
||
427 | rs_gen_func_normalize(1, 0.0, 1.0); |
||
428 | rs_gen_func_posterize(1, 4); |
||
429 | |||
430 | rs_gen_func_add(1, 0, 1, 1.0, 1.0); |
||
431 | rs_gen_func_normalize(1, 0.0, 1.0); |
||
432 | rs_gen_func_mult(1, 0, 1); |
||
433 | rs_gen_func_normalize(1, 0.0, 1.0); |
||
434 | rs_gen_func_posterize(1, 4); |
||
435 | rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0); |
||
436 | rs_gen_tex_out_rgba(1, 1, 1, -1, 0.5+ 0.03*(i%2), 0.7+ 0.03*(i%3) , 0.9, 1.0); |
||
437 | |||
438 | memcpy(game.tex_rocks[i].data, rs_gen_reg.tex_out, rock_size*rock_size*4 ); |
||
439 | }; |
||
440 | rs_gen_term(); |
||
441 | |||
442 | |||
5243 | alpine | 443 | #ifndef RS_KOS |
5225 | alpine | 444 | rs_audio_init(RS_AUDIO_FMT_MONO16, RS_AUDIO_FREQ_16000, 0); |
445 | #endif |
||
446 | |||
447 | soundbuf_init(&game.sound_test1, 2048); |
||
448 | // soundbuf_fill(&game.sound_test1, 2, 50); |
||
449 | soundbuf_sin_fade(&game.sound_test1, 0.7); |
||
450 | |||
451 | soundbuf_init(&game.sound_test2, 1024); |
||
452 | //soundbuf_fill(&game.sound_test2, 8, 40); |
||
453 | soundbuf_sin(&game.sound_test2, 0.48); |
||
454 | |||
455 | soundbuf_init(&game.sound_test3, 1024); |
||
456 | //soundbuf_fill(&game.sound_test3, 12, 60); |
||
457 | soundbuf_sin(&game.sound_test3, 0.24); |
||
458 | |||
459 | |||
460 | }; |
||
461 | |||
462 | |||
463 | void GameTerm() { |
||
464 | |||
465 | |||
466 | DEBUG10("--- Game Term ---"); |
||
467 | |||
5243 | alpine | 468 | #ifndef RS_KOS |
5225 | alpine | 469 | rs_audio_term(); |
470 | #endif |
||
471 | |||
472 | game_font_term(); |
||
473 | |||
474 | free(game.scaled_framebuffer); |
||
475 | |||
476 | texture_free(&game.framebuffer); |
||
477 | texture_free(&game.tex); |
||
478 | texture_free(&game.tex_clouds); |
||
479 | texture_free(&game.tex_ground); |
||
480 | |||
481 | texture_free(&game.tex_gui_line); |
||
482 | |||
483 | int i; |
||
484 | for (i = 0; i < ROCKS_COUNT; i++) { |
||
485 | texture_free(&game.tex_rocks[i]); |
||
486 | }; |
||
487 | |||
488 | soundbuf_free(&game.sound_test1); |
||
489 | soundbuf_free(&game.sound_test2); |
||
490 | soundbuf_free(&game.sound_test3); |
||
491 | |||
492 | |||
493 | }; |
||
494 | |||
495 | // ------------ #Event Functions ------------ |
||
496 | |||
497 | |||
498 | |||
499 | |||
500 | |||
501 | |||
502 | void GameKeyDown(int key, int first) { |
||
503 | |||
504 | |||
505 | switch (key) { |
||
506 | case RS_KEY_LEFT: |
||
507 | BIT_SET(game.keyboard_state, RS_ARROW_LEFT_MASK); |
||
508 | break; |
||
509 | case RS_KEY_RIGHT: |
||
510 | BIT_SET(game.keyboard_state, RS_ARROW_RIGHT_MASK); |
||
511 | break; |
||
512 | case RS_KEY_UP: |
||
513 | BIT_SET(game.keyboard_state, RS_ARROW_UP_MASK); |
||
514 | break; |
||
515 | case RS_KEY_DOWN: |
||
516 | BIT_SET(game.keyboard_state, RS_ARROW_DOWN_MASK); |
||
517 | break; |
||
518 | case RS_KEY_A: |
||
519 | BIT_SET(game.keyboard_state, RS_ATTACK_KEY_MASK); |
||
520 | game.shoot_keypressed = 1; |
||
521 | break; |
||
522 | }; |
||
523 | |||
524 | |||
525 | if (game.status == STATUS_MENU) { |
||
526 | |||
527 | switch (key) { |
||
528 | case RS_KEY_LEFT: |
||
529 | BIT_SET(game.keyboard_state, RS_ARROW_LEFT_MASK); |
||
530 | |||
531 | if ( (game.menu_index == MENU_SETTINGS) && (game.menu_item_index == MENU_ITEM_WINDOW_SCALE) ) { |
||
532 | game_change_window_scale(-1); |
||
5243 | alpine | 533 | game_ding(1); |
5225 | alpine | 534 | }; |
535 | |||
536 | //PlayBuffer(hBuff, 0); |
||
537 | break; |
||
538 | case RS_KEY_RIGHT: |
||
539 | BIT_SET(game.keyboard_state, RS_ARROW_RIGHT_MASK); |
||
540 | |||
541 | if ( (game.menu_index == MENU_SETTINGS) && (game.menu_item_index == MENU_ITEM_WINDOW_SCALE) ) { |
||
542 | game_change_window_scale(1); |
||
5243 | alpine | 543 | game_ding(1); |
5225 | alpine | 544 | }; |
545 | |||
546 | //StopBuffer(hBuff); |
||
547 | break; |
||
548 | case RS_KEY_UP: |
||
549 | BIT_SET(game.keyboard_state, RS_ARROW_UP_MASK); |
||
550 | menu_cursor_up(); |
||
551 | //ResetBuffer(hBuff, 0); |
||
552 | break; |
||
553 | case RS_KEY_DOWN: |
||
554 | BIT_SET(game.keyboard_state, RS_ARROW_DOWN_MASK); |
||
555 | menu_cursor_down(); |
||
556 | break; |
||
557 | case RS_KEY_RETURN: |
||
558 | menu_cursor_click(); |
||
559 | break; |
||
560 | case RS_KEY_ESCAPE: |
||
561 | menu_open(0); |
||
562 | break; |
||
563 | }; |
||
564 | |||
565 | }; |
||
566 | |||
567 | if (game.status == STATUS_PLAYING) { |
||
568 | switch (key) { |
||
569 | |||
570 | case RS_KEY_ESCAPE: |
||
571 | game.status = STATUS_MENU; |
||
572 | menu_open(0); |
||
573 | break; |
||
574 | case RS_KEY_A: |
||
575 | |||
576 | // if ( (game.tx > 0) && (game.ty > 5) && (game.tx < GAME_WIDTH-20) && (game.ty < GAME_HEIGHT-10) ) { |
||
577 | // |
||
578 | // soundbuf_play(&game.sound_test1); |
||
579 | // |
||
580 | // game.bullet_index++; |
||
581 | // game.bullet_index %= BULLETS_COUNT; |
||
582 | // game.bullet_x[game.bullet_index] = game.tx + 12; |
||
583 | // game.bullet_y[game.bullet_index] = game.ty + 3; |
||
584 | // }; |
||
585 | |||
586 | break; |
||
587 | |||
588 | }; |
||
589 | }; |
||
590 | |||
591 | }; |
||
592 | |||
593 | void GameKeyUp(int key) { |
||
594 | |||
595 | switch (key) { |
||
596 | case RS_KEY_LEFT: |
||
597 | BIT_CLEAR(game.keyboard_state, RS_ARROW_LEFT_MASK); |
||
598 | break; |
||
599 | case RS_KEY_RIGHT: |
||
600 | BIT_CLEAR(game.keyboard_state, RS_ARROW_RIGHT_MASK); |
||
601 | break; |
||
602 | case RS_KEY_UP: |
||
603 | BIT_CLEAR(game.keyboard_state, RS_ARROW_UP_MASK); |
||
604 | break; |
||
605 | case RS_KEY_DOWN: |
||
606 | BIT_CLEAR(game.keyboard_state, RS_ARROW_DOWN_MASK); |
||
607 | break; |
||
608 | case RS_KEY_A: |
||
609 | BIT_CLEAR(game.keyboard_state, RS_ATTACK_KEY_MASK); |
||
610 | break; |
||
611 | }; |
||
612 | |||
613 | }; |
||
614 | |||
5243 | alpine | 615 | void GameMouseDown(int x, int y) { |
616 | game.tx = x; |
||
617 | game.ty = y; |
||
618 | DEBUG10f("Mouse Down %d, %d \n", x, y); |
||
619 | }; |
||
5225 | alpine | 620 | |
5243 | alpine | 621 | void GameMouseUp(int x, int y) { |
622 | // |
||
623 | }; |
||
624 | |||
625 | |||
5225 | alpine | 626 | void game_change_window_scale(int d) { |
627 | int scale = window_scale_str[3] - '0'; |
||
628 | |||
629 | unsigned int w; |
||
630 | unsigned int h; |
||
631 | rskos_get_screen_size(&w, &h); |
||
632 | |||
633 | int max_scale = (w-20)/GAME_WIDTH; |
||
634 | if ( (h-20)/GAME_HEIGHT < max_scale ) { |
||
635 | max_scale = (h-20)/GAME_HEIGHT; |
||
636 | }; |
||
637 | |||
638 | scale += d; |
||
639 | if ( scale > max_scale) { |
||
640 | scale = 1; |
||
641 | } |
||
642 | else if (scale < 1) { |
||
643 | scale = max_scale; |
||
644 | }; |
||
645 | |||
646 | game.window_scale = scale; |
||
647 | |||
648 | free(game.scaled_framebuffer); |
||
649 | game.scaled_framebuffer = malloc(GAME_WIDTH*game.window_scale * GAME_HEIGHT*game.window_scale * 3); |
||
650 | |||
651 | |||
652 | rskos_resize_window( GAME_WIDTH * scale, GAME_HEIGHT * scale ); |
||
653 | |||
654 | window_scale_str[3] = scale + '0'; |
||
5243 | alpine | 655 | |
656 | |||
657 | |||
5225 | alpine | 658 | }; |
659 | |||
660 | void game_ding(int i) { |
||
661 | |||
662 | switch (i) { |
||
663 | case 0: |
||
664 | soundbuf_play(&game.sound_test2); |
||
665 | break; |
||
666 | case 1: |
||
667 | soundbuf_play(&game.sound_test3); |
||
668 | break; |
||
669 | }; |
||
670 | |||
671 | };>>>>>>>>>>>>>>>>>>>>>>>>>>> |