Subversion Repositories Kolibri OS

Rev

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