Subversion Repositories Kolibri OS

Rev

Rev 5225 | Rev 5291 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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 <math.h>
  20.     #include <stdlib.h>
  21.     #include <string.h>
  22.    
  23.     #include "rs/rskeyboard.h"
  24. #endif
  25.  
  26.  
  27.  
  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.         };
  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.        
  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;
  218.     #ifndef RS_KOS
  219.         game.window_scale = 3;
  220.         window_scale_str[3] = '3';
  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.  
  443.     #ifndef RS_KOS
  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.  
  468.     #ifndef RS_KOS
  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);
  533.                     game_ding(1);
  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);
  543.                     game_ding(1);
  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.  
  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. };
  620.  
  621. void GameMouseUp(int x, int y) {
  622.     //
  623. };
  624.  
  625.  
  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';
  655.    
  656.    
  657.    
  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. };
  672.