Subversion Repositories Kolibri OS

Rev

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