Subversion Repositories Kolibri OS

Rev

Rev 5315 | 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_update(rs_soundbuf_t *snd) {
  189.     rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
  190. };
  191.  
  192. void soundbuf_free(rs_soundbuf_t *snd) {
  193.     snd->status = 0;
  194.     free(snd->data);
  195. };
  196.  
  197. void soundbuf_fill(rs_soundbuf_t *snd, int amp, int freq_div) {
  198.     int i;
  199.     for (i = 0; i < snd->length_samples; i++) {
  200.                 snd->data[i] = -amp/2 + amp/2*( ( (i % freq_div) > freq_div/2 ) ? 1 : 0 );
  201.         };
  202.         rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
  203. };
  204.  
  205. void soundbuf_sin(rs_soundbuf_t *snd, float freq) {
  206.     int i;
  207.     int amp = 19000;
  208.     for (i = 0; i < snd->length_samples; i++) {
  209.                 snd->data[i] = ( 1.0 - 1.0*i/snd->length_samples ) * sin(freq*i) * amp;
  210.         };
  211.         rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
  212. };
  213.  
  214. void soundbuf_sin_fade(rs_soundbuf_t *snd, float freq) {
  215.     int i;
  216.     int amp = 19000;
  217.     for (i = 0; i < snd->length_samples; i++) {
  218.                 snd->data[i] = ( 1.0 - 1.0*i/snd->length_samples ) * sin( ( (1.0 - 0.48*i/snd->length_samples) * freq ) *i) * amp;
  219.         };
  220.        
  221.        
  222.         /*
  223.        
  224.         // ok
  225.        
  226.         rs_sgen_init(2, snd->length_samples);
  227.         rs_sgen_func_pm(1, 880.0, 21.0, 0.3, 110.0, 0.3);
  228.         rs_sgen_func_normalize(1, 1.0);
  229.         rs_sgen_func_lowpass(0, 1, 1.0, 0.0, 1.0);
  230.         rs_sgen_wave_out(0);
  231.        
  232.         memcpy(snd->data, rs_sgen_reg.wave_out, snd->length_samples*2 );
  233.        
  234.         rs_sgen_term();
  235.        
  236.         */
  237.        
  238.         rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
  239. };
  240.  
  241. void soundbuf_play(rs_soundbuf_t *snd, int mode) {
  242.     rskos_snd_play(&snd->hbuf, mode);
  243. };
  244.  
  245. void soundbuf_stop(rs_soundbuf_t *snd) {
  246.     rskos_snd_stop(&snd->hbuf);
  247. };
  248.  
  249. void soundbuf_loop_check(rs_soundbuf_t *snd) {
  250.     rskos_snd_check_loop(&snd->hbuf);
  251. };
  252.  
  253.  
  254.  
  255. unsigned char clamp_byte(int value) {
  256.     value = value * (1 - (value >> 31)); // negative to zero
  257.     return (value > 255) ? 255 : value;
  258. };
  259.  
  260.  
  261. void game_reg_init() {
  262. //    game.tx = 0;
  263. //    game.ty = 0;
  264. //    game.tz = 0;
  265.    
  266.     game.player_x = 0;
  267.     game.player_y = 0;
  268.     game.tz = 0;
  269.    
  270.     game.bg_color = COLOR_BLACK;
  271.  
  272. //    int i;
  273. //    for (i = 0; i < BULLETS_COUNT; i++) {
  274. //        game.bullet_x[i] = 0;
  275. //        game.bullet_y[i] = 0;
  276. //    };
  277. //    game.bullet_index = 0;
  278.  
  279.     game.objs = malloc( sizeof(game_obj_t) * GAME_OBJS_MAX_COUNT );
  280.    
  281.     game.status = STATUS_MENU;
  282.    
  283.     game.window_scale = 2;
  284.     #ifndef RS_KOS
  285.         game.window_scale = 3;
  286.         window_scale_str[3] = '3';
  287.     #endif
  288.    
  289.     game.keyboard_state = 0;
  290.    
  291.     game.menu_index = 0;
  292.     game.menu_item_index = 0;
  293. };
  294.  
  295.  
  296. int is_key_pressed(int mask) {
  297.     return IS_BIT_SET(game.keyboard_state, mask) ? 1 : 0;
  298. };
  299.  
  300.  
  301. int seed = 0;
  302.  
  303. unsigned short rs_rand() {
  304.     seed += 1000;
  305.     seed %= 56789;
  306.    
  307.     // from here, http://www.cplusplus.com/forum/general/85758/
  308.     // koef. changed
  309.     int n = rskos_get_time() + seed * 57 * 5; // no *2
  310.     n = (n << 13) ^ n;
  311.     return (n * (n * n * 15731 + 789221) + 1376312589) & 0xFFFF;
  312.    
  313. };
  314.  
  315.  
  316.  
  317.  
  318. void GameInit() {
  319.  
  320.     game_reg_init();
  321.    
  322.     game.scaled_framebuffer = malloc(GAME_WIDTH*game.window_scale * GAME_HEIGHT*game.window_scale * 3);
  323.     DEBUG10f("scaled framebuffer: %d (window_scale = %d) \n", game.window_scale * GAME_WIDTH * GAME_HEIGHT * 3, game.window_scale);
  324.    
  325.     game_font_init();
  326.    
  327.     texture_init(&game.framebuffer, GAME_WIDTH, GAME_HEIGHT);
  328.    
  329.     texture_init(&game.tex, 64, 64);
  330.     rs_gen_init(1, 64);
  331.     rs_gen_func_set(0, 0.0);
  332.     rs_gen_func_cell(0, 1200, 10, NULL, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0);
  333.     rs_gen_func_normalize(0, 0.0, 1.0);
  334.     rs_gen_func_posterize(0, 5);
  335.     rs_gen_tex_out_rgba(0, 0, 0, -1, 1.0, 1.0, 1.0, 1.0);
  336.     memcpy(game.tex.data, rs_gen_reg.tex_out, 64*64*4 );
  337.     rs_gen_term();
  338.    
  339.     texture_init(&game.tex_clouds, 128, 128);
  340.     rs_gen_init(1, 128);
  341.     rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
  342.     rs_gen_func_normalize(0, 0.0, 1.0);
  343.     rs_gen_func_posterize(0, 4);
  344.     rs_gen_func_normalize(0, 0.0, 0.50);
  345.     rs_gen_tex_out_rgba(0, 0, 0, -1, 0.9, 0.7, 0.5, 1.0);
  346.     memcpy(game.tex_clouds.data, rs_gen_reg.tex_out, 128*128*4 );
  347.     rs_gen_term();
  348.    
  349.     texture_init(&game.tex_ground, GAME_WIDTH, 50);
  350.    
  351.    
  352.    
  353.     int ship_size = 8;
  354.    
  355.     // 16x8
  356.    
  357.     unsigned char tex_ship1_mask[] = { 0x10, 0x58, 0x7C, 0x7C, 0x3E, 0x1E, 0xBE, 0xFE };
  358.     unsigned char tex_ship2_mask[] = { 0x7C, 0x7C, 0x7E, 0x7E, 0x3C, 0x3C, 0x1C, 0x18 };
  359.     unsigned char tex_ship1_overlay_mask[] = { 0x10, 0x18, 0x1C, 0x1C, 0x1C, 0x1C, 0x8C, 0x84 };
  360.     unsigned char tex_ship2_overlay_mask[] = { 0x00, 0x00, 0x20, 0x20, 0x30, 0x30, 0x10, 0x10 };
  361.    
  362.     texture_init(&game.tex_ship[0], ship_size, ship_size);
  363.     rs_gen_init(2, ship_size);
  364.     rs_gen_func_perlin(0, 8, 5, 0.5, 111);
  365.     rs_gen_func_normalize(0, 0.0, 1.0);
  366.     rs_gen_func_posterize(0, 2);
  367.     rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);
  368.  
  369.     rs_gen_func_set(1, 1.0);
  370.     rs_gen_func_apply_mask(1, tex_ship1_mask);
  371. //    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
  372.     rs_gen_tex_out_rgba(0, 0, 0, 1, 0.8, 0.65, 0.66, 1.0);
  373.     memcpy(game.tex_ship[0].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
  374.     rs_gen_term();
  375.    
  376.     texture_init(&game.tex_ship[1], ship_size, ship_size);
  377.     rs_gen_init(2, ship_size);
  378.     rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
  379.     rs_gen_func_normalize(0, 0.0, 1.0);
  380.     rs_gen_func_posterize(0, 2);
  381.     rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);
  382.  
  383.     rs_gen_func_set(1, 1.0);
  384.     rs_gen_func_apply_mask(1, tex_ship1_overlay_mask);
  385. //    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
  386.     rs_gen_tex_out_rgba(0, 0, 0, 1, 0.4, 0.3, 0.3, 1.0);
  387.     memcpy(game.tex_ship[1].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
  388.     rs_gen_term();
  389.    
  390.    
  391.     texture_init(&game.tex_ship[2], ship_size, ship_size);
  392.     rs_gen_init(2, ship_size);
  393.     rs_gen_func_perlin(0, 8, 5, 0.5, 111);
  394.     rs_gen_func_normalize(0, 0.0, 1.0);
  395.     rs_gen_func_posterize(0, 2);
  396.     rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);
  397. //    rs_gen_func_set(0, 1.0);
  398.     rs_gen_func_set(1, 1.0);
  399.     rs_gen_func_apply_mask(1, tex_ship2_mask);
  400. //    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
  401.     rs_gen_tex_out_rgba(0, 0, 0, 1, 0.8, 0.65, 0.66, 1.0);
  402.     memcpy(game.tex_ship[2].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
  403.     rs_gen_term();
  404.    
  405.     texture_init(&game.tex_ship[3], ship_size, ship_size);
  406.     rs_gen_init(2, ship_size);
  407.     rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
  408.     rs_gen_func_normalize(0, 0.0, 1.0);
  409.     rs_gen_func_posterize(0, 2);
  410.     rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);
  411.  
  412.     rs_gen_func_set(1, 1.0);
  413.     rs_gen_func_apply_mask(1, tex_ship2_overlay_mask);
  414. //    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
  415.     rs_gen_tex_out_rgba(0, 0, 0, 1, 0.4, 0.3, 0.2, 1.0);
  416.     memcpy(game.tex_ship[3].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
  417.     rs_gen_term();
  418.    
  419.    
  420.     texture_init(&game.tex_gui_line, GAME_WIDTH, 13);
  421.     int i;
  422.     for (i = 0; i < GAME_WIDTH*13; i++) {
  423.         ( (unsigned int*) (game.tex_gui_line.data)) [i] = 0x668899AA;
  424.     };
  425.    
  426.    
  427.     int rock_size = 32;
  428.     rs_gen_init(3, rock_size);
  429.     for (i = 0; i < ROCKS_COUNT; i++) {
  430.    
  431.         texture_init(&(game.tex_rocks[i]), rock_size, rock_size);
  432.  
  433.         rs_gen_func_set(0, 0.0);
  434.         rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5);
  435.  
  436.         rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);
  437.         rs_gen_func_normalize(2, 0.0, 1.0);
  438.         rs_gen_func_posterize(2, 4);
  439.        
  440.         rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0);
  441.         rs_gen_func_posterize(1, 2);
  442.         rs_gen_func_normalize(1, 0.0, 1.0);
  443.         rs_gen_func_add(1, 1, 2, 1.0, 0.5);
  444.         rs_gen_func_normalize(1, 0.0, 1.0);
  445.         rs_gen_func_posterize(1, 4);
  446.  
  447.         rs_gen_func_add(1, 0, 1, 1.0, 1.0);
  448.         rs_gen_func_normalize(1, 0.0, 1.0);
  449.         rs_gen_func_mult(1, 0, 1);
  450.         rs_gen_func_normalize(1, 0.0, 1.0);
  451.         rs_gen_func_posterize(1, 4);
  452.         rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0);
  453.         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);
  454.  
  455.         memcpy(game.tex_rocks[i].data, rs_gen_reg.tex_out, rock_size*rock_size*4 );
  456.     };
  457.     rs_gen_term();
  458.    
  459.    
  460.     rock_size = 16;
  461.     rs_gen_init(3, rock_size);
  462.     for (i = 0; i < MINIROCKS_COUNT; i++) {
  463.    
  464.         texture_init(&(game.tex_minirocks[i]), rock_size, rock_size);
  465.  
  466.         rs_gen_func_set(0, 0.0);
  467.         rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5);
  468.  
  469.         rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);
  470.         rs_gen_func_normalize(2, 0.0, 1.0);
  471.         rs_gen_func_posterize(2, 4);
  472.        
  473.         rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0);
  474.         rs_gen_func_posterize(1, 2);
  475.         rs_gen_func_normalize(1, 0.0, 1.0);
  476.         rs_gen_func_add(1, 1, 2, 1.0, 0.5);
  477.         rs_gen_func_normalize(1, 0.0, 1.0);
  478.         rs_gen_func_posterize(1, 4);
  479.  
  480.         rs_gen_func_add(1, 0, 1, 1.0, 1.0);
  481.         rs_gen_func_normalize(1, 0.0, 1.0);
  482.         rs_gen_func_mult(1, 0, 1);
  483.         rs_gen_func_normalize(1, 0.0, 1.0);
  484.         rs_gen_func_posterize(1, 4);
  485.         rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0);
  486.         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);
  487.  
  488.         memcpy(game.tex_minirocks[i].data, rs_gen_reg.tex_out, rock_size*rock_size*4 );
  489.     };
  490.     rs_gen_term();
  491.    
  492.    
  493.    
  494.    
  495.     rs_gen_init(3, EXPLOSION_RADIUS*2);
  496.     for (i = 0; i < EXPLOSIONS_COUNT; i++) {
  497.            
  498.         texture_init(&(game.tex_explosions[i]), EXPLOSION_RADIUS*2, EXPLOSION_RADIUS*2);
  499.  
  500.         rs_gen_func_set(0, 1.0);
  501. //        rs_gen_func_radial(0, 0.5, 0.5, 0.3 + 0.5*i/EXPLOSION_FRAMES_COUNT, 0.975, 4.0);
  502. //        rs_gen_func_set(0, 1.0);
  503.  
  504.         rs_gen_func_perlin(2, 10 + i, 7, 0.5, 100 + i*1000);
  505.         rs_gen_func_normalize(2, 0.0, 1.0);
  506.  
  507.         rs_gen_func_set(1, 0.0);
  508.         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);
  509.        
  510.         rs_gen_func_add(0, 0, 2, 1.0, -0.8);
  511.  
  512.         rs_gen_tex_out_rgba_set( 0.0, 0.0, 0.0, 0.0);
  513.         rs_gen_tex_out_rgba(0, 0, 0, 1, 0.5*i/EXPLOSIONS_COUNT, 1.0 - 0.7*i/EXPLOSIONS_COUNT, 1.0, 1.0);
  514.  
  515.         memcpy(game.tex_explosions[i].data, rs_gen_reg.tex_out, EXPLOSION_RADIUS*2*EXPLOSION_RADIUS*2*4 );
  516.     };
  517.     rs_gen_term();
  518.    
  519.    
  520.    
  521.     rs_gen_init(3, HUGE_EXPLOSION_RADIUS*2);
  522.     for (i = 0; i < HUGE_EXPLOSIONS_COUNT; i++) {
  523.            
  524.         texture_init(&(game.tex_huge_explosions[i]), HUGE_EXPLOSION_RADIUS*2, HUGE_EXPLOSION_RADIUS*2);
  525.  
  526.         rs_gen_func_set(0, 1.0);
  527. //        rs_gen_func_radial(0, 0.5, 0.5, 0.3 + 0.5*i/EXPLOSION_FRAMES_COUNT, 0.975, 4.0);
  528. //        rs_gen_func_set(0, 1.0);
  529.  
  530.         rs_gen_func_perlin(2, 10 + i, 7, 0.5, 500 + i*2000);
  531.         rs_gen_func_normalize(2, 0.0, 1.0);
  532.  
  533.         rs_gen_func_set(1, 0.0);
  534.         rs_gen_func_radial(1, 0.5, 0.5, 0.1 + 0.4*i/HUGE_EXPLOSIONS_COUNT, 1.0 - 1.0*i/HUGE_EXPLOSIONS_COUNT, 2.5 + i%5);
  535.        
  536.         rs_gen_func_add(0, 0, 2, 1.0, -0.8);
  537.  
  538.         rs_gen_tex_out_rgba_set( 0.0, 0.0, 0.0, 0.0);
  539.         rs_gen_tex_out_rgba(0, 0, 0, 1, 0.88*i/HUGE_EXPLOSIONS_COUNT, 0.8 - 0.8*i/HUGE_EXPLOSIONS_COUNT, 1.0, 1.0);
  540.  
  541.         memcpy(game.tex_huge_explosions[i].data, rs_gen_reg.tex_out, HUGE_EXPLOSION_RADIUS*2*HUGE_EXPLOSION_RADIUS*2*4 );
  542.     };
  543.     rs_gen_term();
  544.    
  545.    
  546.  
  547.     #ifndef RS_KOS
  548.         rs_audio_init(RS_AUDIO_FMT_MONO16, RS_AUDIO_FREQ_16000, 2);
  549.     #endif
  550.  
  551.     soundbuf_init(&game.sound_shoot, 1536);
  552.  
  553.         rs_sgen_init(2, game.sound_shoot.length_samples);
  554.         rs_sgen_func_pm(1, 2900.0, 1.70, 65.0, 17.0, 1.0);
  555.         rs_sgen_func_normalize(1, 0.6);
  556. //      rs_sgen_func_lowpass(0, 1, 1.0, 0.0, 4.0);
  557.         rs_sgen_func_highpass(0, 1, 1.0, 0.0, 3.0);
  558.  
  559.         rs_sgen_wave_out(0);
  560.        
  561.         memcpy(game.sound_shoot.data, (unsigned char*) rs_sgen_reg.wave_out, game.sound_shoot.length_samples*2 );
  562.        
  563.         rs_sgen_term();
  564.     soundbuf_update(&game.sound_shoot);
  565.    
  566.    
  567.    
  568.     soundbuf_init(&game.sound_turret_shoot, 4096);
  569.         rs_sgen_init(2, game.sound_turret_shoot.length_samples);
  570.         rs_sgen_func_pm(1, 227.0, 4.70, 555.0, 150.0, 0.01);
  571.         rs_sgen_func_normalize(1, 0.6);
  572. //      rs_sgen_func_highpass(0, 1, 1.0, 0.0, 3.0);
  573.         rs_sgen_func_lowpass(0, 1, 1.0, 0.0, 3.0);
  574.  
  575.         rs_sgen_wave_out(0);
  576.        
  577.         memcpy(game.sound_turret_shoot.data, (unsigned char*) rs_sgen_reg.wave_out, game.sound_turret_shoot.length_samples*2 );
  578.        
  579.         rs_sgen_term();
  580.     soundbuf_update(&game.sound_turret_shoot);
  581.    
  582.    
  583.      
  584.    
  585.    
  586.    
  587.    
  588.    
  589.  
  590.     soundbuf_init(&game.sound_test2, 1024);
  591.     //soundbuf_fill(&game.sound_test2, 8, 40);
  592.     soundbuf_sin(&game.sound_test2, 0.48);
  593.  
  594.     soundbuf_init(&game.sound_test3, 1024);
  595.     //soundbuf_fill(&game.sound_test3, 12, 60);
  596.     soundbuf_sin(&game.sound_test3, 0.24);
  597.  
  598.  
  599.  
  600.    
  601.    
  602.     int soundlen = 55000;
  603.            
  604. //    int freqs[SOUND_EXPLOSIONS_COUNT] = { 440, 523, 587, 698, 783, 880, 1046, 1174 };
  605.    
  606.     for (i = 0; i < SOUND_EXPLOSIONS_COUNT; i++) {
  607.  
  608.         soundbuf_init(&game.sound_explosions[i], soundlen);
  609.  
  610.         rs_sgen_init(3, soundlen);
  611.  
  612.         rs_sgen_func_noise(2, 1000);
  613.         //rs_sgen_func_phaser(0, 2, 0.9, 15.2 + 1.0*i/SOUND_EXPLOSIONS_COUNT, 6.0, 3.0, 2000.0, 1.73);
  614.         rs_sgen_func_phaser(0, 2, 0.9, 16.2 + 0.5*i/SOUND_EXPLOSIONS_COUNT, 6.0, 3.0, 900.0, 0.93);
  615.         rs_sgen_func_normalize(0, 1.0);
  616.  
  617.         rs_sgen_func_lowpass(2, 0, 0.6, 0.0, 20.0);
  618.         rs_sgen_func_normalize(2, 0.5);
  619.  
  620.         rs_sgen_wave_out(2);
  621.  
  622.         memcpy(game.sound_explosions[i].data, (unsigned char*) rs_sgen_reg.wave_out, soundlen*2);
  623.         soundbuf_update(&game.sound_explosions[i]);
  624.  
  625.         rs_sgen_term();
  626.    
  627.     };
  628.    
  629.    
  630.    
  631.     soundlen = 95000;
  632.    
  633.     soundbuf_init(&game.sound_huge_explosion, soundlen);
  634.  
  635.     rs_sgen_init(3, soundlen);
  636.  
  637.     rs_sgen_func_noise(2, 1000);
  638.     //rs_sgen_func_phaser(0, 2, 0.9, 15.2 + 1.0*i/SOUND_EXPLOSIONS_COUNT, 6.0, 3.0, 2000.0, 1.73);
  639.     rs_sgen_func_phaser(0, 2, 0.9, 16.2 + 0.5, 6.0, 3.0, 100.0, 0.53);
  640.     rs_sgen_func_normalize(0, 1.0);
  641.  
  642.     rs_sgen_func_lowpass(2, 0, 0.8, 0.0, 10.0);
  643.     rs_sgen_func_normalize(2, 0.5);
  644.  
  645.     rs_sgen_wave_out(2);
  646.  
  647.     memcpy(game.sound_huge_explosion.data, (unsigned char*) rs_sgen_reg.wave_out, soundlen*2);
  648.     soundbuf_update(&game.sound_huge_explosion);
  649.  
  650.     rs_sgen_term();
  651.    
  652.    
  653.    
  654.    
  655.    
  656.    
  657.    
  658.    
  659.  
  660.     soundlen = 17888;
  661.  
  662.     soundbuf_init(&game.sound_hit, soundlen);
  663.  
  664.     rs_sgen_init(3, soundlen);
  665.  
  666.     rs_sgen_func_noise(2, 1000);
  667.     rs_sgen_func_phaser(0, 2, 0.9, 11.5, 16.0, 13.0, 1300.0, 1.93);
  668.     rs_sgen_func_normalize(0, 1.0);
  669.  
  670.     rs_sgen_func_highpass(2, 0, 1.0, 0.3, 20.0);
  671.     rs_sgen_func_normalize(2, 0.5);
  672.  
  673.     rs_sgen_wave_out(2);
  674.  
  675.     memcpy(game.sound_hit.data, (unsigned char*) rs_sgen_reg.wave_out, soundlen*2);
  676.     soundbuf_update(&game.sound_hit);
  677.  
  678.     rs_sgen_term();
  679.    
  680.    
  681.    
  682.  
  683.     #define NOTE(i) ( 3 << ( (i)/12) ) / ( 24 - ( (i) % 12) )
  684.     int amp = 70;
  685.     int t_shift = 0;
  686.     int t;
  687.  
  688.     soundlen = 128 * 1024;
  689.    
  690.  
  691.  
  692.     soundbuf_init(&game.sound_music, soundlen);
  693.    
  694.     for (t = t_shift; t < soundlen+t_shift; t++) {
  695.         game.sound_music.data[t-t_shift] = (0xFF &
  696.             (                                        
  697.                 ((t>>11) | (t>>7) | ( t>>5) | (t))
  698.  
  699.             )                                  
  700.         ) * amp;
  701.     };
  702.    
  703.     soundbuf_update(&game.sound_music);
  704.    
  705.    
  706.    
  707. //    int d[4] = { 5, 6, 1, 2 };
  708.    
  709.    
  710. //    soundbuf_init(&game.sound_music2, soundlen);
  711. //    
  712. //    for (t = t_shift; t < soundlen+t_shift; t++) {
  713. //            
  714. ////        y = 1 + (t & 16383);
  715. ////        x = (t * c[ (t>>13) & 3 ] / 24) & 127;
  716. //            
  717. //        game.sound_music2.data[t-t_shift] = (0xFF &
  718. //            (                                        
  719. //           //( t*5 & t >> 7 ) | ( t*2 & t >> 10 )
  720. //                                                    
  721. //           // ( ((t*t*t/1000000 + t) % 127) | t>>4 | t>>5 | (t%127) ) + ( (t>>16) | t )
  722. //          
  723. ////           ((t>>11) | (t>>7) | ( t>>5) | (t))
  724. ////           //+
  725. ////           //(( (t*5) >>12) & ( (t*3)>>19))
  726. //            
  727. ////                (3000 / y) * 35
  728. ////             + x*y*40000
  729. ////             + ( ( ((t>>8) & (t>>10)) | (t >> 14) | x) & 63 )
  730. //                                
  731. //                 // (  ((6 * t / d[ (t>>13) & 15 ] ) & 127) * 10000 )
  732. //                 //|( ( t>>3 ) )                
  733. //            
  734. //                    (t*NOTE( d[ (t>>13) & 3 ] )*10000)
  735. //                    | ((t>>6)*20000)
  736. //            
  737. //             )
  738. //                                                    
  739. //        ) * amp;
  740. //    };
  741. //    
  742. //    soundbuf_update(&game.sound_music2);
  743.    
  744.    
  745.     soundbuf_play( &game.sound_music, SND_MODE_LOOP );    
  746.    
  747.  
  748. };
  749.  
  750.  
  751. void GameTerm() {
  752.  
  753.  
  754.     DEBUG10("--- Game Term ---");
  755.  
  756.     #ifndef RS_KOS
  757.         rs_audio_term();
  758.     #endif
  759.  
  760.     game_font_term();
  761.    
  762.     free(game.scaled_framebuffer);
  763.    
  764.     free(game.objs);
  765.    
  766.     texture_free(&game.framebuffer);
  767.     texture_free(&game.tex);
  768.     texture_free(&game.tex_clouds);
  769.     texture_free(&game.tex_ground);
  770.    
  771.     texture_free(&game.tex_gui_line);
  772.    
  773.     int i;
  774.     for (i = 0; i < ROCKS_COUNT; i++) {
  775.         texture_free(&game.tex_rocks[i]);
  776.     };
  777.    
  778.     soundbuf_free(&game.sound_huge_explosion);
  779.     soundbuf_free(&game.sound_hit);
  780.     soundbuf_free(&game.sound_music);
  781.    
  782.     for (i = 0; i < SOUND_EXPLOSIONS_COUNT; i++) {
  783.         soundbuf_free(&game.sound_explosions[i]);
  784.     };
  785.    
  786.    
  787.     soundbuf_free(&game.sound_shoot);
  788.     soundbuf_free(&game.sound_turret_shoot);
  789.     soundbuf_free(&game.sound_test2);
  790.     soundbuf_free(&game.sound_test3);
  791.    
  792.  
  793. };
  794.  
  795. // ------------ #Event Functions ------------
  796.  
  797.  
  798.  
  799.  
  800.  
  801.  
  802. void GameKeyDown(int key) {
  803.    
  804.    
  805.     switch (key) {
  806.         case RS_KEY_LEFT:
  807.             BIT_SET(game.keyboard_state, RS_ARROW_LEFT_MASK);
  808.             break;
  809.         case RS_KEY_RIGHT:
  810.             BIT_SET(game.keyboard_state, RS_ARROW_RIGHT_MASK);
  811.             break;
  812.         case RS_KEY_UP:
  813.             BIT_SET(game.keyboard_state, RS_ARROW_UP_MASK);
  814.             break;
  815.         case RS_KEY_DOWN:
  816.             BIT_SET(game.keyboard_state, RS_ARROW_DOWN_MASK);
  817.             break;
  818.         case RS_KEY_A:
  819.             BIT_SET(game.keyboard_state, RS_ATTACK_KEY_MASK);
  820.             game.shoot_keypressed = 1;
  821.            
  822. //            soundbuf_loop_check( &game.sound_music );
  823.            
  824.             break;
  825.            
  826.        
  827.        
  828.         case RS_KEY_SPACE:
  829.                 soundbuf_play( &game.sound_huge_explosion, 0 );
  830.             break;
  831.        
  832.         #ifdef RS_LINUX
  833.            
  834.         case RS_KEY_Z:
  835. //                soundbuf_stop( &game.sound_music );
  836. //                soundbuf_play( &game.sound_music2, 0 );
  837.                 game.stage = 7;
  838.                 break;
  839.            
  840.         #endif
  841.        
  842.  
  843.            
  844.     };
  845.    
  846.    
  847.     if (game.status == STATUS_MENU) {
  848.    
  849.         switch (key) {
  850.             case RS_KEY_LEFT:
  851.                 BIT_SET(game.keyboard_state, RS_ARROW_LEFT_MASK);
  852.  
  853.                 if ( (game.menu_index == MENU_SETTINGS) && (game.menu_item_index == MENU_ITEM_WINDOW_SCALE) ) {
  854.                     game_change_window_scale(-1);
  855.                     game_ding(1);
  856.                 };
  857.  
  858.                 //PlayBuffer(hBuff, 0);
  859.                 break;
  860.             case RS_KEY_RIGHT:
  861.                 BIT_SET(game.keyboard_state, RS_ARROW_RIGHT_MASK);
  862.                
  863.                 if ( (game.menu_index == MENU_SETTINGS) && (game.menu_item_index == MENU_ITEM_WINDOW_SCALE) ) {
  864.                     game_change_window_scale(1);
  865.                     game_ding(1);
  866.                 };
  867.  
  868.                 //StopBuffer(hBuff);
  869.                 break;
  870.             case RS_KEY_UP:
  871.                 BIT_SET(game.keyboard_state, RS_ARROW_UP_MASK);
  872.                 menu_cursor_up();
  873.                 //ResetBuffer(hBuff, 0);
  874.                 break;
  875.             case RS_KEY_DOWN:
  876.                 BIT_SET(game.keyboard_state, RS_ARROW_DOWN_MASK);
  877.                 menu_cursor_down();
  878.                 break;
  879.             case RS_KEY_RETURN:
  880.                 menu_cursor_click();
  881.                 break;
  882.             case RS_KEY_ESCAPE:
  883.                 if (game.menu_index != MENU_PAUSE) {
  884.                     menu_open(0);
  885.                 }
  886.                 else {
  887.                     game.status = STATUS_PLAYING;
  888.                     return;
  889.                 };
  890.                 break;
  891.         };
  892.  
  893.     };
  894.    
  895.     if (game.status == STATUS_PLAYING) {
  896.         switch (key) {
  897.            
  898.             case RS_KEY_ESCAPE:
  899.                 game.status = STATUS_MENU;
  900.                 menu_open(MENU_PAUSE);
  901.                 break;
  902.             case RS_KEY_SPACE:
  903.                
  904.                
  905.                 //game_obj_add( game_obj( OBJ_EXPLOSION, 0, 0, 0, game.tx + 80, game.ty - 10, 0, 0.0 ) );
  906.                
  907. //                game_obj_add( game_obj( OBJ_ROCK, 0, 0, 32, game.tx + 80, game.ty - 10, 0, 0.0 ) );
  908.                
  909.                 break;
  910.            
  911.         };
  912.     };
  913.  
  914. };
  915.  
  916. void GameKeyUp(int key) {
  917.  
  918.     switch (key) {
  919.         case RS_KEY_LEFT:
  920.             BIT_CLEAR(game.keyboard_state, RS_ARROW_LEFT_MASK);
  921.             break;
  922.         case RS_KEY_RIGHT:
  923.             BIT_CLEAR(game.keyboard_state, RS_ARROW_RIGHT_MASK);
  924.             break;
  925.         case RS_KEY_UP:
  926.             BIT_CLEAR(game.keyboard_state, RS_ARROW_UP_MASK);
  927.             break;
  928.         case RS_KEY_DOWN:
  929.             BIT_CLEAR(game.keyboard_state, RS_ARROW_DOWN_MASK);
  930.             break;
  931.         case RS_KEY_A:
  932.             BIT_CLEAR(game.keyboard_state, RS_ATTACK_KEY_MASK);
  933.             break;
  934.     };
  935.  
  936. };
  937.  
  938. void GameMouseDown(int x, int y) {
  939. //    game.tx = x;
  940. //    game.ty = y;
  941.     DEBUG10f("Mouse Down %d, %d \n", x, y);
  942. };
  943.  
  944. void GameMouseUp(int x, int y) {
  945.     //
  946. };
  947.  
  948.  
  949. void game_change_window_scale(int d) {
  950.     int scale = window_scale_str[3] - '0';
  951.    
  952.     unsigned int w;
  953.     unsigned int h;
  954.     rskos_get_screen_size(&w, &h);
  955.    
  956.     int max_scale = (w-20)/GAME_WIDTH;
  957.     if ( (h-20)/GAME_HEIGHT < max_scale ) {
  958.         max_scale = (h-20)/GAME_HEIGHT;
  959.     };
  960.    
  961.     scale += d;
  962.     if ( scale > max_scale) {
  963.         scale = 1;
  964.     }
  965.     else if (scale < 1) {
  966.         scale = max_scale;
  967.     };
  968.    
  969.     game.window_scale = scale;
  970.    
  971.     free(game.scaled_framebuffer);
  972.     game.scaled_framebuffer = malloc(GAME_WIDTH*game.window_scale * GAME_HEIGHT*game.window_scale * 3);
  973.    
  974.    
  975.     rskos_resize_window( GAME_WIDTH * scale, GAME_HEIGHT * scale );
  976.  
  977.     window_scale_str[3] = scale + '0';
  978.    
  979.    
  980.    
  981. };
  982.  
  983. void game_ding(int i) {
  984.    
  985.     switch (i) {
  986.         case 0:
  987.             soundbuf_play(&game.sound_test2, 0);
  988.             break;
  989.         case 1:
  990.             soundbuf_play(&game.sound_test3, 0);
  991.             break;
  992.     };
  993.    
  994. };
  995.