WebSVN – Kolibri OS – Diff – /programs/games/heliothryx/game/rsgame.c


#include "rsgame.h"
 
#include "rsgametext.h"
 
#include "rsgamemenu.h"
 
#include "rsgamedraw.h"
 
#include "rskos.h"
 
#include "rsgentex.h"
#include "rssoundgen.h"
#include "rsnoise.h"
 
#include "rs/rsplatform.h"
 
 
#ifdef RS_USE_C_LIBS // linux version
    #include 
    #include  
    #include 
    
    #include "rs/rskeyboard.h"
#endif
 
 
 
rs_game_t game;
 
 
game_obj_t game_obj(int obj_type, int flags, int tag, int radius, float x, float y, int t, float f) {
    game_obj_t obj;
    obj.obj_type = obj_type;
    obj.flags = flags;
    obj.tag = tag;
    obj.radius = radius;
    obj.x = x;
    obj.y = y;
    obj.t = t;
    obj.f = f;
    return obj;
};
 
int game_obj_add(game_obj_t obj) {
    if (game.objs_count < GAME_OBJS_MAX_COUNT) {
        game.objs[game.objs_count++] = obj;
        return game.objs_count-1;    
    };
    #ifdef RS_LINUX
        DEBUG10("Error, max objects count is reached");
    #endif
    return 0; // Max objects count is reached
};
 
void game_obj_remove(int index) {
    if (index == game.objs_count - 1) {
        game.objs_count--;
        return;
    };
    game.objs[index] = game.objs[ game.objs_count-1 ];
    game.objs_count--;
};
 
 
 
 
 
 
 
 
 
void texture_init(rs_texture_t *tex, int w, int h) {
    tex->status = 1;
    tex->w = w;
    tex->h = h;
    tex->data = malloc(w*h*4); // BGRA BGRA
};
 
void texture_free(rs_texture_t *tex) {
    free(tex->data);
    tex->status = 0;
};
 
void texture_clear(rs_texture_t *tex, unsigned int color) {
    int i;
    for (i = 0; i < tex->w * tex->h; i++) {
        *((unsigned int*)(&tex->data[i*4])) = color;
    };
};
 
void texture_draw(rs_texture_t *dest, rs_texture_t *src, int x, int y, int mode) {
    
    int i; // y
    int j; // x
    int k; // color component
    
    int istart = (y < 0) ? -y : 0;
    int iend = src->h - (( (y + src->h) > dest->h) ? (y + src->h - dest->h) : 0);
    
    int jstart = (x < 0) ? -x : 0;
    int jend = src->w - (( (x + src->w) > dest->w) ? (x + src->w - dest->w) : 0);
    
    int ishift = 0;
    int jshift = 0;
    
    float a; // alpha value
    
    if (mode & DRAW_TILED_FLAG) {
        jshift = x;
        ishift = y;
        x = y = istart = jstart = 0;
        iend = dest->h;
        jend = dest->w;
    };
    
    mode = mode & DRAW_MODE_MASK;
    
    int modvalue = (src->w*src->h*4); 
    
    if (mode == DRAW_MODE_REPLACE) {
        for (i = istart; i < iend; i++) {
            for (j = jstart; j < jend; j++) {
                for (k = 0; k < 4; k++) {
                    dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] = src->data[ (4*(i*src->w + j) + k) % modvalue ];
                };
            };
        };
    }
    else if (mode == DRAW_MODE_ADDITIVE) {
        for (i = istart; i < iend; i++) {
            for (j = jstart; j < jend; j++) {
                for (k = 0; k < 3; k++) { // Alpha channel is not added
                    dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] = 
                        clamp_byte( dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] + src->data[ (4*((i+ishift)*src->w + j + jshift) + k) % modvalue] );
                };
            };
        };
    }
    else if (mode == DRAW_MODE_ALPHA) {
        for (i = istart; i < iend; i++) {
            for (j = jstart; j < jend; j++) {
                for (k = 0; k < 3; k++) {
                    a = (1.0 * src->data[ (4*(i*src->w + j) + 3) % modvalue ] / 255.0);
                    dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] = 
                         (unsigned char) ( (1.0-a) * dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] 
                                          + a*src->data[ (4*((i+ishift)*src->w + j + jshift) + k) % modvalue] );
                };
            };
        };
    };
    
};
 
 
 
void texture_set_pixel(rs_texture_t *tex, int x, int y, unsigned int color) {
    *((unsigned int*) &tex->data[ 4 * ( (y)*tex->w + (x) ) + 0 ]) = color;
};
 
void texture_draw_vline(rs_texture_t *tex, int x, int y, int l, unsigned int color) {
    int i;
    if (y+l >= tex->h) {
        l = tex->h - y;
    };
    
    if (x < 0) {
        return;
    };
    
    if (x >= tex->w) {
        return;
    };
    
    for (i = 0; i < l; i++) {
        *((unsigned int*) &tex->data[ 4 * ( (y+i)*tex->w + (x) ) + 0 ]) = color;
    };    
};
 
 
 
void soundbuf_init(rs_soundbuf_t *snd, int length_samples) {
    snd->status = 1;
    snd->length_samples = length_samples;
    snd->data = malloc(length_samples*2);
    rskos_snd_create_buffer(&snd->hbuf, snd->data, length_samples);
};
 
void soundbuf_update(rs_soundbuf_t *snd) {
    rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
};
 
void soundbuf_free(rs_soundbuf_t *snd) {
    snd->status = 0;
    free(snd->data);
};
 
void soundbuf_fill(rs_soundbuf_t *snd, int amp, int freq_div) {
    int i;
    for (i = 0; i < snd->length_samples; i++) {
		snd->data[i] = -amp/2 + amp/2*( ( (i % freq_div) > freq_div/2 ) ? 1 : 0 );
	};
	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
};
 
void soundbuf_sin(rs_soundbuf_t *snd, float freq) {
    int i;
    int amp = 19000;
    for (i = 0; i < snd->length_samples; i++) {
		snd->data[i] = ( 1.0 - 1.0*i/snd->length_samples ) * sin(freq*i) * amp;
	};
	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
};
 
void soundbuf_sin_fade(rs_soundbuf_t *snd, float freq) {
    int i;
    int amp = 19000;
    for (i = 0; i < snd->length_samples; i++) {
		snd->data[i] = ( 1.0 - 1.0*i/snd->length_samples ) * sin( ( (1.0 - 0.48*i/snd->length_samples) * freq ) *i) * amp;
	};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	
	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
};
 
void soundbuf_play(rs_soundbuf_t *snd, int mode) {
    rskos_snd_play(&snd->hbuf, mode);
};
 
void soundbuf_stop(rs_soundbuf_t *snd) {
    rskos_snd_stop(&snd->hbuf);
};
 
void soundbuf_loop_check(rs_soundbuf_t *snd) {
    rskos_snd_check_loop(&snd->hbuf);
};
 
 
 
unsigned char clamp_byte(int value) {
    value = value * (1 - (value >> 31)); // negative to zero
    return (value > 255) ? 255 : value;
};
 
 
void game_reg_init() {
 
 
 
    
    game.player_x = 0;
    game.player_y = 0;
    game.tz = 0;
    
    game.bg_color = COLOR_BLACK;
 
 
 
 
 
 
 
 
    game.objs = malloc( sizeof(game_obj_t) * GAME_OBJS_MAX_COUNT ); 
    
    game.status = STATUS_MENU;
    
    game.window_scale = 2;
    #ifndef RS_KOS
        game.window_scale = 3;
        window_scale_str[3] = '3'; 
    #endif
    
    game.keyboard_state = 0;
    
    game.menu_index = 0;
    game.menu_item_index = 0;
};
 
 
int is_key_pressed(int mask) {
    return IS_BIT_SET(game.keyboard_state, mask) ? 1 : 0;
};
 
 
int seed = 0;
 
unsigned short rs_rand() {
    seed += 1000;
    seed %= 56789;
    
    // from here, http://www.cplusplus.com/forum/general/85758/
    // koef. changed
    int n = rskos_get_time() + seed * 57 * 5; // no *2
    n = (n << 13) ^ n;
    return (n * (n * n * 15731 + 789221) + 1376312589) & 0xFFFF;
    
};
 
 
 
 
void GameInit() {
 
    game_reg_init();
    
    game.scaled_framebuffer = malloc(GAME_WIDTH*game.window_scale * GAME_HEIGHT*game.window_scale * 3);
    DEBUG10f("scaled framebuffer: %d (window_scale = %d) \n", game.window_scale * GAME_WIDTH * GAME_HEIGHT * 3, game.window_scale);
    
    game_font_init();
    
    texture_init(&game.framebuffer, GAME_WIDTH, GAME_HEIGHT);
    
    texture_init(&game.tex, 64, 64);
    rs_gen_init(1, 64);
    rs_gen_func_set(0, 0.0);
    rs_gen_func_cell(0, 1200, 10, NULL, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0);
    rs_gen_func_normalize(0, 0.0, 1.0);
    rs_gen_func_posterize(0, 5);
    rs_gen_tex_out_rgba(0, 0, 0, -1, 1.0, 1.0, 1.0, 1.0);
    memcpy(game.tex.data, rs_gen_reg.tex_out, 64*64*4 );
    rs_gen_term();
    
    texture_init(&game.tex_clouds, 128, 128);
    rs_gen_init(1, 128);
    rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
    rs_gen_func_normalize(0, 0.0, 1.0);
    rs_gen_func_posterize(0, 4);
    rs_gen_func_normalize(0, 0.0, 0.50);
    rs_gen_tex_out_rgba(0, 0, 0, -1, 0.9, 0.7, 0.5, 1.0);
    memcpy(game.tex_clouds.data, rs_gen_reg.tex_out, 128*128*4 );
    rs_gen_term();
    
    texture_init(&game.tex_ground, GAME_WIDTH, 50);
    
    
    
    int ship_size = 8;
    
    // 16x8
    
    unsigned char tex_ship1_mask[] = { 0x10, 0x58, 0x7C, 0x7C, 0x3E, 0x1E, 0xBE, 0xFE };
    unsigned char tex_ship2_mask[] = { 0x7C, 0x7C, 0x7E, 0x7E, 0x3C, 0x3C, 0x1C, 0x18 };
    unsigned char tex_ship1_overlay_mask[] = { 0x10, 0x18, 0x1C, 0x1C, 0x1C, 0x1C, 0x8C, 0x84 };
    unsigned char tex_ship2_overlay_mask[] = { 0x00, 0x00, 0x20, 0x20, 0x30, 0x30, 0x10, 0x10 };
    
    texture_init(&game.tex_ship[0], ship_size, ship_size);
    rs_gen_init(2, ship_size);
    rs_gen_func_perlin(0, 8, 5, 0.5, 111);
    rs_gen_func_normalize(0, 0.0, 1.0);
    rs_gen_func_posterize(0, 2);
    rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);
 
    rs_gen_func_set(1, 1.0);
    rs_gen_func_apply_mask(1, tex_ship1_mask);
//    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
    rs_gen_tex_out_rgba(0, 0, 0, 1, 0.8, 0.65, 0.66, 1.0);
    memcpy(game.tex_ship[0].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
    rs_gen_term();
    
    texture_init(&game.tex_ship[1], ship_size, ship_size);
    rs_gen_init(2, ship_size);
    rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
    rs_gen_func_normalize(0, 0.0, 1.0);
    rs_gen_func_posterize(0, 2);
    rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);
 
    rs_gen_func_set(1, 1.0);
    rs_gen_func_apply_mask(1, tex_ship1_overlay_mask);
//    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
    rs_gen_tex_out_rgba(0, 0, 0, 1, 0.4, 0.3, 0.3, 1.0);
    memcpy(game.tex_ship[1].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
    rs_gen_term();
    
    
    texture_init(&game.tex_ship[2], ship_size, ship_size);
    rs_gen_init(2, ship_size);
    rs_gen_func_perlin(0, 8, 5, 0.5, 111);
    rs_gen_func_normalize(0, 0.0, 1.0);
    rs_gen_func_posterize(0, 2);
    rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);
//    rs_gen_func_set(0, 1.0);
    rs_gen_func_set(1, 1.0);
    rs_gen_func_apply_mask(1, tex_ship2_mask);
//    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
    rs_gen_tex_out_rgba(0, 0, 0, 1, 0.8, 0.65, 0.66, 1.0);
    memcpy(game.tex_ship[2].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
    rs_gen_term();
    
    texture_init(&game.tex_ship[3], ship_size, ship_size);
    rs_gen_init(2, ship_size);
    rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
    rs_gen_func_normalize(0, 0.0, 1.0);
    rs_gen_func_posterize(0, 2);
    rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);
 
    rs_gen_func_set(1, 1.0);
    rs_gen_func_apply_mask(1, tex_ship2_overlay_mask);
//    rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);
    rs_gen_tex_out_rgba(0, 0, 0, 1, 0.4, 0.3, 0.2, 1.0);
    memcpy(game.tex_ship[3].data, rs_gen_reg.tex_out, ship_size*ship_size*4 );
    rs_gen_term(); 
    
    
    texture_init(&game.tex_gui_line, GAME_WIDTH, 13);
    int i;
    for (i = 0; i < GAME_WIDTH*13; i++) {
        ( (unsigned int*) (game.tex_gui_line.data)) [i] = 0x668899AA;
    };
    
    
    int rock_size = 32;
    rs_gen_init(3, rock_size);
    for (i = 0; i < ROCKS_COUNT; i++) {
    
        texture_init(&(game.tex_rocks[i]), rock_size, rock_size);
 
        rs_gen_func_set(0, 0.0);
        rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5);
 
        rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);
        rs_gen_func_normalize(2, 0.0, 1.0);
        rs_gen_func_posterize(2, 4);
        
        rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0);
        rs_gen_func_posterize(1, 2);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_add(1, 1, 2, 1.0, 0.5);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_posterize(1, 4);
 
        rs_gen_func_add(1, 0, 1, 1.0, 1.0);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_mult(1, 0, 1);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_posterize(1, 4);
        rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0);
        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);
 
        memcpy(game.tex_rocks[i].data, rs_gen_reg.tex_out, rock_size*rock_size*4 );
    };
    rs_gen_term();
    
    
    rock_size = 16;
    rs_gen_init(3, rock_size);
    for (i = 0; i < MINIROCKS_COUNT; i++) {
    
        texture_init(&(game.tex_minirocks[i]), rock_size, rock_size);
 
        rs_gen_func_set(0, 0.0);
        rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5);
 
        rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);
        rs_gen_func_normalize(2, 0.0, 1.0);
        rs_gen_func_posterize(2, 4);
        
        rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0);
        rs_gen_func_posterize(1, 2);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_add(1, 1, 2, 1.0, 0.5);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_posterize(1, 4);
 
        rs_gen_func_add(1, 0, 1, 1.0, 1.0);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_mult(1, 0, 1);
        rs_gen_func_normalize(1, 0.0, 1.0);
        rs_gen_func_posterize(1, 4);
        rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0);
        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);
 
        memcpy(game.tex_minirocks[i].data, rs_gen_reg.tex_out, rock_size*rock_size*4 );
    };
    rs_gen_term();
    
    
    
    
    rs_gen_init(3, EXPLOSION_RADIUS*2);
    for (i = 0; i < EXPLOSIONS_COUNT; i++) {
            
        texture_init(&(game.tex_explosions[i]), EXPLOSION_RADIUS*2, EXPLOSION_RADIUS*2);
 
        rs_gen_func_set(0, 1.0);
//        rs_gen_func_radial(0, 0.5, 0.5, 0.3 + 0.5*i/EXPLOSION_FRAMES_COUNT, 0.975, 4.0);
//        rs_gen_func_set(0, 1.0);
 
        rs_gen_func_perlin(2, 10 + i, 7, 0.5, 100 + i*1000);
        rs_gen_func_normalize(2, 0.0, 1.0);
 
        rs_gen_func_set(1, 0.0);
        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);
        
        rs_gen_func_add(0, 0, 2, 1.0, -0.8);
 
        rs_gen_tex_out_rgba_set( 0.0, 0.0, 0.0, 0.0);
        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);
 
        memcpy(game.tex_explosions[i].data, rs_gen_reg.tex_out, EXPLOSION_RADIUS*2*EXPLOSION_RADIUS*2*4 );
    };
    rs_gen_term();
    
    
    
    rs_gen_init(3, HUGE_EXPLOSION_RADIUS*2);
    for (i = 0; i < HUGE_EXPLOSIONS_COUNT; i++) {
            
        texture_init(&(game.tex_huge_explosions[i]), HUGE_EXPLOSION_RADIUS*2, HUGE_EXPLOSION_RADIUS*2);
 
        rs_gen_func_set(0, 1.0);
//        rs_gen_func_radial(0, 0.5, 0.5, 0.3 + 0.5*i/EXPLOSION_FRAMES_COUNT, 0.975, 4.0);
//        rs_gen_func_set(0, 1.0);
 
        rs_gen_func_perlin(2, 10 + i, 7, 0.5, 500 + i*2000);
        rs_gen_func_normalize(2, 0.0, 1.0);
 
        rs_gen_func_set(1, 0.0);
        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);
        
        rs_gen_func_add(0, 0, 2, 1.0, -0.8);
 
        rs_gen_tex_out_rgba_set( 0.0, 0.0, 0.0, 0.0);
        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);
 
        memcpy(game.tex_huge_explosions[i].data, rs_gen_reg.tex_out, HUGE_EXPLOSION_RADIUS*2*HUGE_EXPLOSION_RADIUS*2*4 );
    };
    rs_gen_term();
    
    
 
    #ifndef RS_KOS
        rs_audio_init(RS_AUDIO_FMT_MONO16, RS_AUDIO_FREQ_16000, 2); 
    #endif
 
    soundbuf_init(&game.sound_shoot, 1536);
 
	rs_sgen_init(2, game.sound_shoot.length_samples);
	rs_sgen_func_pm(1, 2900.0, 1.70, 65.0, 17.0, 1.0);
	rs_sgen_func_normalize(1, 0.6);
//	rs_sgen_func_lowpass(0, 1, 1.0, 0.0, 4.0);
	rs_sgen_func_highpass(0, 1, 1.0, 0.0, 3.0);
 
	rs_sgen_wave_out(0);
	
	memcpy(game.sound_shoot.data, (unsigned char*) rs_sgen_reg.wave_out, game.sound_shoot.length_samples*2 );
	
	rs_sgen_term();
    soundbuf_update(&game.sound_shoot);
    
    
    
    soundbuf_init(&game.sound_turret_shoot, 4096);
	rs_sgen_init(2, game.sound_turret_shoot.length_samples);
	rs_sgen_func_pm(1, 227.0, 4.70, 555.0, 150.0, 0.01);
	rs_sgen_func_normalize(1, 0.6);
//	rs_sgen_func_highpass(0, 1, 1.0, 0.0, 3.0);
	rs_sgen_func_lowpass(0, 1, 1.0, 0.0, 3.0);
 
	rs_sgen_wave_out(0);
	
	memcpy(game.sound_turret_shoot.data, (unsigned char*) rs_sgen_reg.wave_out, game.sound_turret_shoot.length_samples*2 );
	
	rs_sgen_term();
    soundbuf_update(&game.sound_turret_shoot);
    
    
     
    
    
    
    
    
 
    soundbuf_init(&game.sound_test2, 1024);
    //soundbuf_fill(&game.sound_test2, 8, 40);
    soundbuf_sin(&game.sound_test2, 0.48);
 
    soundbuf_init(&game.sound_test3, 1024);
    //soundbuf_fill(&game.sound_test3, 12, 60);
    soundbuf_sin(&game.sound_test3, 0.24);
 
 
 
    
    
    int soundlen = 55000;
            
//    int freqs[SOUND_EXPLOSIONS_COUNT] = { 440, 523, 587, 698, 783, 880, 1046, 1174 };
    
    for (i = 0; i < SOUND_EXPLOSIONS_COUNT; i++) {
 
        soundbuf_init(&game.sound_explosions[i], soundlen);
 
        rs_sgen_init(3, soundlen);
 
        rs_sgen_func_noise(2, 1000);
        //rs_sgen_func_phaser(0, 2, 0.9, 15.2 + 1.0*i/SOUND_EXPLOSIONS_COUNT, 6.0, 3.0, 2000.0, 1.73); 
        rs_sgen_func_phaser(0, 2, 0.9, 16.2 + 0.5*i/SOUND_EXPLOSIONS_COUNT, 6.0, 3.0, 900.0, 0.93); 
        rs_sgen_func_normalize(0, 1.0);
 
        rs_sgen_func_lowpass(2, 0, 0.6, 0.0, 20.0);
        rs_sgen_func_normalize(2, 0.5);
 
        rs_sgen_wave_out(2);
 
        memcpy(game.sound_explosions[i].data, (unsigned char*) rs_sgen_reg.wave_out, soundlen*2);
        soundbuf_update(&game.sound_explosions[i]);
 
        rs_sgen_term();
    
    };
    
    
    
    soundlen = 95000;
    
    soundbuf_init(&game.sound_huge_explosion, soundlen);
 
    rs_sgen_init(3, soundlen);
 
    rs_sgen_func_noise(2, 1000);
    //rs_sgen_func_phaser(0, 2, 0.9, 15.2 + 1.0*i/SOUND_EXPLOSIONS_COUNT, 6.0, 3.0, 2000.0, 1.73); 
    rs_sgen_func_phaser(0, 2, 0.9, 16.2 + 0.5, 6.0, 3.0, 100.0, 0.53); 
    rs_sgen_func_normalize(0, 1.0);
 
    rs_sgen_func_lowpass(2, 0, 0.8, 0.0, 10.0);
    rs_sgen_func_normalize(2, 0.5);
 
    rs_sgen_wave_out(2);
 
    memcpy(game.sound_huge_explosion.data, (unsigned char*) rs_sgen_reg.wave_out, soundlen*2);
    soundbuf_update(&game.sound_huge_explosion);
 
    rs_sgen_term();
    
    
    
    
    
    
    
    
 
    soundlen = 17888;
 
    soundbuf_init(&game.sound_hit, soundlen);
 
    rs_sgen_init(3, soundlen);
 
    rs_sgen_func_noise(2, 1000);
    rs_sgen_func_phaser(0, 2, 0.9, 11.5, 16.0, 13.0, 1300.0, 1.93); 
    rs_sgen_func_normalize(0, 1.0);
 
    rs_sgen_func_highpass(2, 0, 1.0, 0.3, 20.0);
    rs_sgen_func_normalize(2, 0.5);
 
    rs_sgen_wave_out(2);
 
    memcpy(game.sound_hit.data, (unsigned char*) rs_sgen_reg.wave_out, soundlen*2);
    soundbuf_update(&game.sound_hit);
 
    rs_sgen_term();
    
    
    
 
    #define NOTE(i) ( 3 << ( (i)/12) ) / ( 24 - ( (i) % 12) )
    int amp = 70;
    int t_shift = 0;
    int t;
 
    soundlen = 128 * 1024; 
    
 
 
    soundbuf_init(&game.sound_music, soundlen);
    
    for (t = t_shift; t < soundlen+t_shift; t++) {
        game.sound_music.data[t-t_shift] = (0xFF & 
            (                                        
                ((t>>11) | (t>>7) | ( t>>5) | (t))
 
            )                                   
        ) * amp;
    };
    
    soundbuf_update(&game.sound_music);
    
    
    
//    int d[4] = { 5, 6, 1, 2 };
    
    
//    soundbuf_init(&game.sound_music2, soundlen);
//    
//    for (t = t_shift; t < soundlen+t_shift; t++) {
//            
////        y = 1 + (t & 16383);
////        x = (t * c[ (t>>13) & 3 ] / 24) & 127;
//            
//        game.sound_music2.data[t-t_shift] = (0xFF & 
//            (                                        
//           //( t*5 & t >> 7 ) | ( t*2 & t >> 10 )
//                                                    
//           // ( ((t*t*t/1000000 + t) % 127) | t>>4 | t>>5 | (t%127) ) + ( (t>>16) | t )
//           
////           ((t>>11) | (t>>7) | ( t>>5) | (t))
////           //+ 
////           //(( (t*5) >>12) & ( (t*3)>>19))
//             
////                (3000 / y) * 35
////             + x*y*40000
////             + ( ( ((t>>8) & (t>>10)) | (t >> 14) | x) & 63 )
//                                
//                 // (  ((6 * t / d[ (t>>13) & 15 ] ) & 127) * 10000 ) 
//                 //|( ( t>>3 ) )                
//             
//                    (t*NOTE( d[ (t>>13) & 3 ] )*10000)
//                    | ((t>>6)*20000) 
//             
//             )
//                                                    
//        ) * amp;
//    };
//    
//    soundbuf_update(&game.sound_music2);
    
    
    soundbuf_play( &game.sound_music, SND_MODE_LOOP );    
    
 
};
 
 
void GameTerm() {
 
 
    DEBUG10("--- Game Term ---");
 
    #ifndef RS_KOS
        rs_audio_term();
    #endif
 
    game_font_term();
    
    free(game.scaled_framebuffer);
    
    free(game.objs);
    
    texture_free(&game.framebuffer);
    texture_free(&game.tex);
    texture_free(&game.tex_clouds);
    texture_free(&game.tex_ground);
    
    texture_free(&game.tex_gui_line);
    
    int i;
    for (i = 0; i < ROCKS_COUNT; i++) {
        texture_free(&game.tex_rocks[i]);
    };
    
    soundbuf_free(&game.sound_huge_explosion);
    soundbuf_free(&game.sound_hit);
    soundbuf_free(&game.sound_music);
    
    for (i = 0; i < SOUND_EXPLOSIONS_COUNT; i++) {
        soundbuf_free(&game.sound_explosions[i]);
    };
    
    
    soundbuf_free(&game.sound_shoot);
    soundbuf_free(&game.sound_turret_shoot);
    soundbuf_free(&game.sound_test2);
    soundbuf_free(&game.sound_test3);
    
 
};
 
// ------------ #Event Functions ------------
 
 
 
 
 
 
void GameKeyDown(int key) {
    
    
    switch (key) {
        case RS_KEY_LEFT:
            BIT_SET(game.keyboard_state, RS_ARROW_LEFT_MASK);
            break;
        case RS_KEY_RIGHT:
            BIT_SET(game.keyboard_state, RS_ARROW_RIGHT_MASK);
            break;
        case RS_KEY_UP:
            BIT_SET(game.keyboard_state, RS_ARROW_UP_MASK);
            break;
        case RS_KEY_DOWN:
            BIT_SET(game.keyboard_state, RS_ARROW_DOWN_MASK);
            break;
        case RS_KEY_A:
            BIT_SET(game.keyboard_state, RS_ATTACK_KEY_MASK);
            game.shoot_keypressed = 1;
            
//            soundbuf_loop_check( &game.sound_music );
            
            break;
            
        
        
        case RS_KEY_SPACE:
                soundbuf_play( &game.sound_huge_explosion, 0 );
            break;
        
        #ifdef RS_LINUX
            
        case RS_KEY_Z:
//                soundbuf_stop( &game.sound_music );
//                soundbuf_play( &game.sound_music2, 0 );
                game.stage = 7;
                break;
            
        #endif
        
 
            
    };
    
    
    if (game.status == STATUS_MENU) {
    
        switch (key) {
            case RS_KEY_LEFT:
                BIT_SET(game.keyboard_state, RS_ARROW_LEFT_MASK);
 
                if ( (game.menu_index == MENU_SETTINGS) && (game.menu_item_index == MENU_ITEM_WINDOW_SCALE) ) {
                    game_change_window_scale(-1);
                    game_ding(1);
                };
 
                //PlayBuffer(hBuff, 0);
                break;
            case RS_KEY_RIGHT:
                BIT_SET(game.keyboard_state, RS_ARROW_RIGHT_MASK);
                
                if ( (game.menu_index == MENU_SETTINGS) && (game.menu_item_index == MENU_ITEM_WINDOW_SCALE) ) {
                    game_change_window_scale(1);
                    game_ding(1);
                };
 
                //StopBuffer(hBuff);
                break;
            case RS_KEY_UP:
                BIT_SET(game.keyboard_state, RS_ARROW_UP_MASK);
                menu_cursor_up();
                //ResetBuffer(hBuff, 0);
                break;
            case RS_KEY_DOWN:
                BIT_SET(game.keyboard_state, RS_ARROW_DOWN_MASK);
                menu_cursor_down();
                break;
            case RS_KEY_RETURN:
                menu_cursor_click();
                break;
            case RS_KEY_ESCAPE:
                if (game.menu_index != MENU_PAUSE) {
                    menu_open(0);
                }
                else {
                    game.status = STATUS_PLAYING;
                    return;
                };
                break;
        };
 
    };
    
    if (game.status == STATUS_PLAYING) {
        switch (key) {
            
            case RS_KEY_ESCAPE:
                game.status = STATUS_MENU;
                menu_open(MENU_PAUSE);
                break;
            case RS_KEY_SPACE:
                
                
                //game_obj_add( game_obj( OBJ_EXPLOSION, 0, 0, 0, game.tx + 80, game.ty - 10, 0, 0.0 ) );
                
//                game_obj_add( game_obj( OBJ_ROCK, 0, 0, 32, game.tx + 80, game.ty - 10, 0, 0.0 ) );
                
                break;
            
        };
    };
 
};
 
void GameKeyUp(int key) {
 
    switch (key) {
        case RS_KEY_LEFT:
            BIT_CLEAR(game.keyboard_state, RS_ARROW_LEFT_MASK);
            break;
        case RS_KEY_RIGHT:
            BIT_CLEAR(game.keyboard_state, RS_ARROW_RIGHT_MASK);
            break;
        case RS_KEY_UP:
            BIT_CLEAR(game.keyboard_state, RS_ARROW_UP_MASK);
            break;
        case RS_KEY_DOWN:
            BIT_CLEAR(game.keyboard_state, RS_ARROW_DOWN_MASK);
            break;
        case RS_KEY_A:
            BIT_CLEAR(game.keyboard_state, RS_ATTACK_KEY_MASK);
            break;
    };
 
};
 
void GameMouseDown(int x, int y) {
//    game.tx = x;
//    game.ty = y;
    DEBUG10f("Mouse Down %d, %d \n", x, y);
};
 
void GameMouseUp(int x, int y) {
    //
};
 
 
void game_change_window_scale(int d) {
    int scale = window_scale_str[3] - '0';
    
    unsigned int w;
    unsigned int h;
    rskos_get_screen_size(&w, &h);
    
    int max_scale = (w-20)/GAME_WIDTH;
    if ( (h-20)/GAME_HEIGHT < max_scale ) {
        max_scale = (h-20)/GAME_HEIGHT;
    };
    
    scale += d;
    if ( scale > max_scale) {
        scale = 1;
    }
    else if (scale < 1) {
        scale = max_scale;
    };
    
    game.window_scale = scale;
    
    free(game.scaled_framebuffer);
    game.scaled_framebuffer = malloc(GAME_WIDTH*game.window_scale * GAME_HEIGHT*game.window_scale * 3);
    
    
    rskos_resize_window( GAME_WIDTH * scale, GAME_HEIGHT * scale );
 
    window_scale_str[3] = scale + '0';
    
    
    
};
 
void game_ding(int i) {
    
    switch (i) {
        case 0:
            soundbuf_play(&game.sound_test2, 0);
            break;
        case 1:
            soundbuf_play(&game.sound_test3, 0);
            break;
    };
    
};

Rev 5316	Rev 5322
1	#include "rsgame.h"	1	#include "rsgame.h"
2		2
3	#include "rsgametext.h"	3	#include "rsgametext.h"
4		4
5	#include "rsgamemenu.h"	5	#include "rsgamemenu.h"
6		6
7	#include "rsgamedraw.h"	7	#include "rsgamedraw.h"
8		8
9	#include "rskos.h"	9	#include "rskos.h"
10		10
11	#include "rsgentex.h"	11	#include "rsgentex.h"
12	#include "rssoundgen.h"	12	#include "rssoundgen.h"
13	#include "rsnoise.h"	13	#include "rsnoise.h"
14		14
15	#include "rs/rsplatform.h"	15	#include "rs/rsplatform.h"
16		16
17		17
18	#ifdef RS_USE_C_LIBS // linux version	18	#ifdef RS_USE_C_LIBS // linux version
19	#include	19	#include
20	#include	20	#include
21	#include	21	#include
22		22
23	#include "rs/rskeyboard.h"	23	#include "rs/rskeyboard.h"
24	#endif	24	#endif
25		25
26		26
27		27
28	rs_game_t game;	28	rs_game_t game;
29		29
30		30
31	game_obj_t game_obj(int obj_type, int flags, int tag, int radius, float x, float y, int t, float f) {	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;	32	game_obj_t obj;
33	obj.obj_type = obj_type;	33	obj.obj_type = obj_type;
34	obj.flags = flags;	34	obj.flags = flags;
35	obj.tag = tag;	35	obj.tag = tag;
36	obj.radius = radius;	36	obj.radius = radius;
37	obj.x = x;	37	obj.x = x;
38	obj.y = y;	38	obj.y = y;
39	obj.t = t;	39	obj.t = t;
40	obj.f = f;	40	obj.f = f;
41	return obj;	41	return obj;
42	};	42	};
43		43
44	int game_obj_add(game_obj_t obj) {	44	int game_obj_add(game_obj_t obj) {
45	if (game.objs_count < GAME_OBJS_MAX_COUNT) {	45	if (game.objs_count < GAME_OBJS_MAX_COUNT) {
46	game.objs[game.objs_count++] = obj;	46	game.objs[game.objs_count++] = obj;
47	return game.objs_count-1;	47	return game.objs_count-1;
48	};	48	};
49	#ifdef RS_LINUX	49	#ifdef RS_LINUX
50	DEBUG10("Error, max objects count is reached");	50	DEBUG10("Error, max objects count is reached");
51	#endif	51	#endif
52	return 0; // Max objects count is reached	52	return 0; // Max objects count is reached
53	};	53	};
54		54
55	void game_obj_remove(int index) {	55	void game_obj_remove(int index) {
56	if (index == game.objs_count - 1) {	56	if (index == game.objs_count - 1) {
57	game.objs_count--;	57	game.objs_count--;
58	return;	58	return;
59	};	59	};
60	game.objs[index] = game.objs[ game.objs_count-1 ];	60	game.objs[index] = game.objs[ game.objs_count-1 ];
61	game.objs_count--;	61	game.objs_count--;
62	};	62	};
63		63
64		64
65		65
66		66
67		67
68		68
69		69
70		70
71		71
72	void texture_init(rs_texture_t *tex, int w, int h) {	72	void texture_init(rs_texture_t *tex, int w, int h) {
73	tex->status = 1;	73	tex->status = 1;
74	tex->w = w;	74	tex->w = w;
75	tex->h = h;	75	tex->h = h;
76	tex->data = malloc(wh4); // BGRA BGRA	76	tex->data = malloc(wh4); // BGRA BGRA
77	};	77	};
78		78
79	void texture_free(rs_texture_t *tex) {	79	void texture_free(rs_texture_t *tex) {
80	free(tex->data);	80	free(tex->data);
81	tex->status = 0;	81	tex->status = 0;
82	};	82	};
83		83
84	void texture_clear(rs_texture_t *tex, unsigned int color) {	84	void texture_clear(rs_texture_t *tex, unsigned int color) {
85	int i;	85	int i;
86	for (i = 0; i < tex->w * tex->h; i++) {	86	for (i = 0; i < tex->w * tex->h; i++) {
87	((unsigned int)(&tex->data[i*4])) = color;	87	((unsigned int)(&tex->data[i*4])) = color;
88	};	88	};
89	};	89	};
90		90
91	void texture_draw(rs_texture_t dest, rs_texture_t src, int x, int y, int mode) {	91	void texture_draw(rs_texture_t dest, rs_texture_t src, int x, int y, int mode) {
92		92
93	int i; // y	93	int i; // y
94	int j; // x	94	int j; // x
95	int k; // color component	95	int k; // color component
96		96
97	int istart = (y < 0) ? -y : 0;	97	int istart = (y < 0) ? -y : 0;
98	int iend = src->h - (( (y + src->h) > dest->h) ? (y + src->h - dest->h) : 0);	98	int iend = src->h - (( (y + src->h) > dest->h) ? (y + src->h - dest->h) : 0);
99		99
100	int jstart = (x < 0) ? -x : 0;	100	int jstart = (x < 0) ? -x : 0;
101	int jend = src->w - (( (x + src->w) > dest->w) ? (x + src->w - dest->w) : 0);	101	int jend = src->w - (( (x + src->w) > dest->w) ? (x + src->w - dest->w) : 0);
102		102
103	int ishift = 0;	103	int ishift = 0;
104	int jshift = 0;	104	int jshift = 0;
105		105
106	float a; // alpha value	106	float a; // alpha value
107		107
108	if (mode & DRAW_TILED_FLAG) {	108	if (mode & DRAW_TILED_FLAG) {
109	jshift = x;	109	jshift = x;
110	ishift = y;	110	ishift = y;
111	x = y = istart = jstart = 0;	111	x = y = istart = jstart = 0;
112	iend = dest->h;	112	iend = dest->h;
113	jend = dest->w;	113	jend = dest->w;
114	};	114	};
115		115
116	mode = mode & DRAW_MODE_MASK;	116	mode = mode & DRAW_MODE_MASK;
117		117
118	int modvalue = (src->wsrc->h4);	118	int modvalue = (src->wsrc->h4);
119		119
120	if (mode == DRAW_MODE_REPLACE) {	120	if (mode == DRAW_MODE_REPLACE) {
121	for (i = istart; i < iend; i++) {	121	for (i = istart; i < iend; i++) {
122	for (j = jstart; j < jend; j++) {	122	for (j = jstart; j < jend; j++) {
123	for (k = 0; k < 4; k++) {	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 ];	124	dest->data[ 4 * ( (y+i)dest->w + (x+j) ) + k ] = src->data[ (4(i*src->w + j) + k) % modvalue ];
125	};	125	};
126	};	126	};
127	};	127	};
128	}	128	}
129	else if (mode == DRAW_MODE_ADDITIVE) {	129	else if (mode == DRAW_MODE_ADDITIVE) {
130	for (i = istart; i < iend; i++) {	130	for (i = istart; i < iend; i++) {
131	for (j = jstart; j < jend; j++) {	131	for (j = jstart; j < jend; j++) {
132	for (k = 0; k < 3; k++) { // Alpha channel is not added	132	for (k = 0; k < 3; k++) { // Alpha channel is not added
133	dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] =	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] );	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	};	135	};
136	};	136	};
137	};	137	};
138	}	138	}
139	else if (mode == DRAW_MODE_ALPHA) {	139	else if (mode == DRAW_MODE_ALPHA) {
140	for (i = istart; i < iend; i++) {	140	for (i = istart; i < iend; i++) {
141	for (j = jstart; j < jend; j++) {	141	for (j = jstart; j < jend; j++) {
142	for (k = 0; k < 3; k++) {	142	for (k = 0; k < 3; k++) {
143	a = (1.0 * src->data[ (4(isrc->w + j) + 3) % modvalue ] / 255.0);	143	a = (1.0 * src->data[ (4(isrc->w + j) + 3) % modvalue ] / 255.0);
144	dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ] =	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 ]	145	(unsigned char) ( (1.0-a) * dest->data[ 4 * ( (y+i)*dest->w + (x+j) ) + k ]
146	+ asrc->data[ (4((i+ishift)*src->w + j + jshift) + k) % modvalue] );	146	+ asrc->data[ (4((i+ishift)*src->w + j + jshift) + k) % modvalue] );
147	};	147	};
148	};	148	};
149	};	149	};
150	};	150	};
151		151
152	};	152	};
153		153
154		154
155		155
156	void texture_set_pixel(rs_texture_t *tex, int x, int y, unsigned int color) {	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;	157	((unsigned int) &tex->data[ 4 * ( (y)*tex->w + (x) ) + 0 ]) = color;
158	};	158	};
159		159
160	void texture_draw_vline(rs_texture_t *tex, int x, int y, int l, unsigned int color) {	160	void texture_draw_vline(rs_texture_t *tex, int x, int y, int l, unsigned int color) {
161	int i;	161	int i;
162	if (y+l >= tex->h) {	162	if (y+l >= tex->h) {
163	l = tex->h - y;	163	l = tex->h - y;
164	};	164	};
165		165
166	if (x < 0) {	166	if (x < 0) {
167	return;	167	return;
168	};	168	};
169		169
170	if (x >= tex->w) {	170	if (x >= tex->w) {
171	return;	171	return;
172	};	172	};
173		173
174	for (i = 0; i < l; i++) {	174	for (i = 0; i < l; i++) {
175	((unsigned int) &tex->data[ 4 * ( (y+i)*tex->w + (x) ) + 0 ]) = color;	175	((unsigned int) &tex->data[ 4 * ( (y+i)*tex->w + (x) ) + 0 ]) = color;
176	};	176	};
177	};	177	};
178		178
179		179
180		180
181	void soundbuf_init(rs_soundbuf_t *snd, int length_samples) {	181	void soundbuf_init(rs_soundbuf_t *snd, int length_samples) {
182	snd->status = 1;	182	snd->status = 1;
183	snd->length_samples = length_samples;	183	snd->length_samples = length_samples;
184	snd->data = malloc(length_samples*2);	184	snd->data = malloc(length_samples*2);
185	rskos_snd_create_buffer(&snd->hbuf, snd->data, length_samples);	185	rskos_snd_create_buffer(&snd->hbuf, snd->data, length_samples);
186	};	186	};
187		187
188	void soundbuf_update(rs_soundbuf_t *snd) {	188	void soundbuf_update(rs_soundbuf_t *snd) {
189	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);	189	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
190	};	190	};
191		191
192	void soundbuf_free(rs_soundbuf_t *snd) {	192	void soundbuf_free(rs_soundbuf_t *snd) {
193	snd->status = 0;	193	snd->status = 0;
194	free(snd->data);	194	free(snd->data);
195	};	195	};
196		196
197	void soundbuf_fill(rs_soundbuf_t *snd, int amp, int freq_div) {	197	void soundbuf_fill(rs_soundbuf_t *snd, int amp, int freq_div) {
198	int i;	198	int i;
199	for (i = 0; i < snd->length_samples; 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 );	200	snd->data[i] = -amp/2 + amp/2*( ( (i % freq_div) > freq_div/2 ) ? 1 : 0 );
201	};	201	};
202	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);	202	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
203	};	203	};
204		204
205	void soundbuf_sin(rs_soundbuf_t *snd, float freq) {	205	void soundbuf_sin(rs_soundbuf_t *snd, float freq) {
206	int i;	206	int i;
207	int amp = 19000;	207	int amp = 19000;
208	for (i = 0; i < snd->length_samples; i++) {	208	for (i = 0; i < snd->length_samples; i++) {
209	snd->data[i] = ( 1.0 - 1.0i/snd->length_samples ) sin(freqi) amp;	209	snd->data[i] = ( 1.0 - 1.0i/snd->length_samples ) sin(freqi) amp;
210	};	210	};
211	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);	211	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
212	};	212	};
213		213
214	void soundbuf_sin_fade(rs_soundbuf_t *snd, float freq) {	214	void soundbuf_sin_fade(rs_soundbuf_t *snd, float freq) {
215	int i;	215	int i;
216	int amp = 19000;	216	int amp = 19000;
217	for (i = 0; i < snd->length_samples; i++) {	217	for (i = 0; i < snd->length_samples; i++) {
218	snd->data[i] = ( 1.0 - 1.0i/snd->length_samples ) sin( ( (1.0 - 0.48i/snd->length_samples) freq ) i) amp;	218	snd->data[i] = ( 1.0 - 1.0i/snd->length_samples ) sin( ( (1.0 - 0.48i/snd->length_samples) freq ) i) amp;
219	};	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		220
238	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);	221	rskos_snd_update_buffer(&snd->hbuf, snd->data, snd->length_samples);
239	};	222	};
240		223
241	void soundbuf_play(rs_soundbuf_t *snd, int mode) {	224	void soundbuf_play(rs_soundbuf_t *snd, int mode) {
242	rskos_snd_play(&snd->hbuf, mode);	225	rskos_snd_play(&snd->hbuf, mode);
243	};	226	};
244		227
245	void soundbuf_stop(rs_soundbuf_t *snd) {	228	void soundbuf_stop(rs_soundbuf_t *snd) {
246	rskos_snd_stop(&snd->hbuf);	229	rskos_snd_stop(&snd->hbuf);
247	};	230	};
248		231
249	void soundbuf_loop_check(rs_soundbuf_t *snd) {	232	void soundbuf_loop_check(rs_soundbuf_t *snd) {
250	rskos_snd_check_loop(&snd->hbuf);	233	rskos_snd_check_loop(&snd->hbuf);
251	};	234	};
252		235
253		236
254		237
255	unsigned char clamp_byte(int value) {	238	unsigned char clamp_byte(int value) {
256	value = value * (1 - (value >> 31)); // negative to zero	239	value = value * (1 - (value >> 31)); // negative to zero
257	return (value > 255) ? 255 : value;	240	return (value > 255) ? 255 : value;
258	};	241	};
259		242
260		243
261	void game_reg_init() {	244	void game_reg_init() {
262	// game.tx = 0;	-
263	// game.ty = 0;	-
264	// game.tz = 0;	-
265		245
266	game.player_x = 0;	246	game.player_x = 0;
267	game.player_y = 0;	247	game.player_y = 0;
268	game.tz = 0;	248	game.tz = 0;
269		249
270	game.bg_color = COLOR_BLACK;	250	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		251
279	game.objs = malloc( sizeof(game_obj_t) * GAME_OBJS_MAX_COUNT );	252	game.objs = malloc( sizeof(game_obj_t) * GAME_OBJS_MAX_COUNT );
280		253
281	game.status = STATUS_MENU;	254	game.status = STATUS_MENU;
282		255
283	game.window_scale = 2;	256	game.window_scale = 2;
284	#ifndef RS_KOS	257	#ifndef RS_KOS
285	game.window_scale = 3;	258	game.window_scale = 3;
286	window_scale_str[3] = '3';	259	window_scale_str[3] = '3';
287	#endif	260	#endif
288		261
289	game.keyboard_state = 0;	262	game.keyboard_state = 0;
290		263
291	game.menu_index = 0;	264	game.menu_index = 0;
292	game.menu_item_index = 0;	265	game.menu_item_index = 0;
293	};	266	};
294		267
295		268
296	int is_key_pressed(int mask) {	269	int is_key_pressed(int mask) {
297	return IS_BIT_SET(game.keyboard_state, mask) ? 1 : 0;	270	return IS_BIT_SET(game.keyboard_state, mask) ? 1 : 0;
298	};	271	};
299		272
300		273
301	int seed = 0;	274	int seed = 0;
302		275
303	unsigned short rs_rand() {	276	unsigned short rs_rand() {
304	seed += 1000;	277	seed += 1000;
305	seed %= 56789;	278	seed %= 56789;
306		279
307	// from here, http://www.cplusplus.com/forum/general/85758/	280	// from here, http://www.cplusplus.com/forum/general/85758/
308	// koef. changed	281	// koef. changed
309	int n = rskos_get_time() + seed * 57 * 5; // no *2	282	int n = rskos_get_time() + seed * 57 * 5; // no *2
310	n = (n << 13) ^ n;	283	n = (n << 13) ^ n;
311	return (n * (n * n * 15731 + 789221) + 1376312589) & 0xFFFF;	284	return (n * (n * n * 15731 + 789221) + 1376312589) & 0xFFFF;
312		285
313	};	286	};
314		287
315		288
316		289
317		290
318	void GameInit() {	291	void GameInit() {
319		292
320	game_reg_init();	293	game_reg_init();
321		294
322	game.scaled_framebuffer = malloc(GAME_WIDTHgame.window_scale GAME_HEIGHTgame.window_scale 3);	295	game.scaled_framebuffer = malloc(GAME_WIDTHgame.window_scale GAME_HEIGHTgame.window_scale 3);
323	DEBUG10f("scaled framebuffer: %d (window_scale = %d) \n", game.window_scale * GAME_WIDTH * GAME_HEIGHT * 3, game.window_scale);	296	DEBUG10f("scaled framebuffer: %d (window_scale = %d) \n", game.window_scale * GAME_WIDTH * GAME_HEIGHT * 3, game.window_scale);
324		297
325	game_font_init();	298	game_font_init();
326		299
327	texture_init(&game.framebuffer, GAME_WIDTH, GAME_HEIGHT);	300	texture_init(&game.framebuffer, GAME_WIDTH, GAME_HEIGHT);
328		301
329	texture_init(&game.tex, 64, 64);	302	texture_init(&game.tex, 64, 64);
330	rs_gen_init(1, 64);	303	rs_gen_init(1, 64);
331	rs_gen_func_set(0, 0.0);	304	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);	305	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);	306	rs_gen_func_normalize(0, 0.0, 1.0);
334	rs_gen_func_posterize(0, 5);	307	rs_gen_func_posterize(0, 5);
335	rs_gen_tex_out_rgba(0, 0, 0, -1, 1.0, 1.0, 1.0, 1.0);	308	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, 64644 );	309	memcpy(game.tex.data, rs_gen_reg.tex_out, 64644 );
337	rs_gen_term();	310	rs_gen_term();
338		311
339	texture_init(&game.tex_clouds, 128, 128);	312	texture_init(&game.tex_clouds, 128, 128);
340	rs_gen_init(1, 128);	313	rs_gen_init(1, 128);
341	rs_gen_func_perlin(0, 8, 5, 0.5, 1100);	314	rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
342	rs_gen_func_normalize(0, 0.0, 1.0);	315	rs_gen_func_normalize(0, 0.0, 1.0);
343	rs_gen_func_posterize(0, 4);	316	rs_gen_func_posterize(0, 4);
344	rs_gen_func_normalize(0, 0.0, 0.50);	317	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);	318	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, 1281284 );	319	memcpy(game.tex_clouds.data, rs_gen_reg.tex_out, 1281284 );
347	rs_gen_term();	320	rs_gen_term();
348		321
349	texture_init(&game.tex_ground, GAME_WIDTH, 50);	322	texture_init(&game.tex_ground, GAME_WIDTH, 50);
350		323
351		324
352		325
353	int ship_size = 8;	326	int ship_size = 8;
354		327
355	// 16x8	328	// 16x8
356		329
357	unsigned char tex_ship1_mask[] = { 0x10, 0x58, 0x7C, 0x7C, 0x3E, 0x1E, 0xBE, 0xFE };	330	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 };	331	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 };	332	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 };	333	unsigned char tex_ship2_overlay_mask[] = { 0x00, 0x00, 0x20, 0x20, 0x30, 0x30, 0x10, 0x10 };
361		334
362	texture_init(&game.tex_ship[0], ship_size, ship_size);	335	texture_init(&game.tex_ship[0], ship_size, ship_size);
363	rs_gen_init(2, ship_size);	336	rs_gen_init(2, ship_size);
364	rs_gen_func_perlin(0, 8, 5, 0.5, 111);	337	rs_gen_func_perlin(0, 8, 5, 0.5, 111);
365	rs_gen_func_normalize(0, 0.0, 1.0);	338	rs_gen_func_normalize(0, 0.0, 1.0);
366	rs_gen_func_posterize(0, 2);	339	rs_gen_func_posterize(0, 2);
367	rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);	340	rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);
368		341
369	rs_gen_func_set(1, 1.0);	342	rs_gen_func_set(1, 1.0);
370	rs_gen_func_apply_mask(1, tex_ship1_mask);	343	rs_gen_func_apply_mask(1, tex_ship1_mask);
371	// rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);	344	// 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);	345	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_sizeship_size4 );	346	memcpy(game.tex_ship[0].data, rs_gen_reg.tex_out, ship_sizeship_size4 );
374	rs_gen_term();	347	rs_gen_term();
375		348
376	texture_init(&game.tex_ship[1], ship_size, ship_size);	349	texture_init(&game.tex_ship[1], ship_size, ship_size);
377	rs_gen_init(2, ship_size);	350	rs_gen_init(2, ship_size);
378	rs_gen_func_perlin(0, 8, 5, 0.5, 1100);	351	rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
379	rs_gen_func_normalize(0, 0.0, 1.0);	352	rs_gen_func_normalize(0, 0.0, 1.0);
380	rs_gen_func_posterize(0, 2);	353	rs_gen_func_posterize(0, 2);
381	rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);	354	rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);
382		355
383	rs_gen_func_set(1, 1.0);	356	rs_gen_func_set(1, 1.0);
384	rs_gen_func_apply_mask(1, tex_ship1_overlay_mask);	357	rs_gen_func_apply_mask(1, tex_ship1_overlay_mask);
385	// rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);	358	// 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);	359	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_sizeship_size4 );	360	memcpy(game.tex_ship[1].data, rs_gen_reg.tex_out, ship_sizeship_size4 );
388	rs_gen_term();	361	rs_gen_term();
389		362
390		363
391	texture_init(&game.tex_ship[2], ship_size, ship_size);	364	texture_init(&game.tex_ship[2], ship_size, ship_size);
392	rs_gen_init(2, ship_size);	365	rs_gen_init(2, ship_size);
393	rs_gen_func_perlin(0, 8, 5, 0.5, 111);	366	rs_gen_func_perlin(0, 8, 5, 0.5, 111);
394	rs_gen_func_normalize(0, 0.0, 1.0);	367	rs_gen_func_normalize(0, 0.0, 1.0);
395	rs_gen_func_posterize(0, 2);	368	rs_gen_func_posterize(0, 2);
396	rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);	369	rs_gen_func_mult_add_value(0, 0, 0.3, 0.7);
397	// rs_gen_func_set(0, 1.0);	370	// rs_gen_func_set(0, 1.0);
398	rs_gen_func_set(1, 1.0);	371	rs_gen_func_set(1, 1.0);
399	rs_gen_func_apply_mask(1, tex_ship2_mask);	372	rs_gen_func_apply_mask(1, tex_ship2_mask);
400	// rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);	373	// 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);	374	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_sizeship_size4 );	375	memcpy(game.tex_ship[2].data, rs_gen_reg.tex_out, ship_sizeship_size4 );
403	rs_gen_term();	376	rs_gen_term();
404		377
405	texture_init(&game.tex_ship[3], ship_size, ship_size);	378	texture_init(&game.tex_ship[3], ship_size, ship_size);
406	rs_gen_init(2, ship_size);	379	rs_gen_init(2, ship_size);
407	rs_gen_func_perlin(0, 8, 5, 0.5, 1100);	380	rs_gen_func_perlin(0, 8, 5, 0.5, 1100);
408	rs_gen_func_normalize(0, 0.0, 1.0);	381	rs_gen_func_normalize(0, 0.0, 1.0);
409	rs_gen_func_posterize(0, 2);	382	rs_gen_func_posterize(0, 2);
410	rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);	383	rs_gen_func_mult_add_value(0, 0, 0.1, 0.9);
411		384
412	rs_gen_func_set(1, 1.0);	385	rs_gen_func_set(1, 1.0);
413	rs_gen_func_apply_mask(1, tex_ship2_overlay_mask);	386	rs_gen_func_apply_mask(1, tex_ship2_overlay_mask);
414	// rs_gen_func_mult_add_value(1, 1, 0.8, 0.2);	387	// 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);	388	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_sizeship_size4 );	389	memcpy(game.tex_ship[3].data, rs_gen_reg.tex_out, ship_sizeship_size4 );
417	rs_gen_term();	390	rs_gen_term();
418		391
419		392
420	texture_init(&game.tex_gui_line, GAME_WIDTH, 13);	393	texture_init(&game.tex_gui_line, GAME_WIDTH, 13);
421	int i;	394	int i;
422	for (i = 0; i < GAME_WIDTH*13; i++) {	395	for (i = 0; i < GAME_WIDTH*13; i++) {
423	( (unsigned int*) (game.tex_gui_line.data)) [i] = 0x668899AA;	396	( (unsigned int*) (game.tex_gui_line.data)) [i] = 0x668899AA;
424	};	397	};
425		398
426		399
427	int rock_size = 32;	400	int rock_size = 32;
428	rs_gen_init(3, rock_size);	401	rs_gen_init(3, rock_size);
429	for (i = 0; i < ROCKS_COUNT; i++) {	402	for (i = 0; i < ROCKS_COUNT; i++) {
430		403
431	texture_init(&(game.tex_rocks[i]), rock_size, rock_size);	404	texture_init(&(game.tex_rocks[i]), rock_size, rock_size);
432		405
433	rs_gen_func_set(0, 0.0);	406	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);	407	rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5);
435		408
436	rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);	409	rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);
437	rs_gen_func_normalize(2, 0.0, 1.0);	410	rs_gen_func_normalize(2, 0.0, 1.0);
438	rs_gen_func_posterize(2, 4);	411	rs_gen_func_posterize(2, 4);
439		412
440	rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0);	413	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);	414	rs_gen_func_posterize(1, 2);
442	rs_gen_func_normalize(1, 0.0, 1.0);	415	rs_gen_func_normalize(1, 0.0, 1.0);
443	rs_gen_func_add(1, 1, 2, 1.0, 0.5);	416	rs_gen_func_add(1, 1, 2, 1.0, 0.5);
444	rs_gen_func_normalize(1, 0.0, 1.0);	417	rs_gen_func_normalize(1, 0.0, 1.0);
445	rs_gen_func_posterize(1, 4);	418	rs_gen_func_posterize(1, 4);
446		419
447	rs_gen_func_add(1, 0, 1, 1.0, 1.0);	420	rs_gen_func_add(1, 0, 1, 1.0, 1.0);
448	rs_gen_func_normalize(1, 0.0, 1.0);	421	rs_gen_func_normalize(1, 0.0, 1.0);
449	rs_gen_func_mult(1, 0, 1);	422	rs_gen_func_mult(1, 0, 1);
450	rs_gen_func_normalize(1, 0.0, 1.0);	423	rs_gen_func_normalize(1, 0.0, 1.0);
451	rs_gen_func_posterize(1, 4);	424	rs_gen_func_posterize(1, 4);
452	rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0);	425	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);	426	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		427
455	memcpy(game.tex_rocks[i].data, rs_gen_reg.tex_out, rock_sizerock_size4 );	428	memcpy(game.tex_rocks[i].data, rs_gen_reg.tex_out, rock_sizerock_size4 );
456	};	429	};
457	rs_gen_term();	430	rs_gen_term();
458		431
459		432
460	rock_size = 16;	433	rock_size = 16;
461	rs_gen_init(3, rock_size);	434	rs_gen_init(3, rock_size);
462	for (i = 0; i < MINIROCKS_COUNT; i++) {	435	for (i = 0; i < MINIROCKS_COUNT; i++) {
463		436
464	texture_init(&(game.tex_minirocks[i]), rock_size, rock_size);	437	texture_init(&(game.tex_minirocks[i]), rock_size, rock_size);
465		438
466	rs_gen_func_set(0, 0.0);	439	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);	440	rs_gen_func_radial(0, 0.5, 0.5, 0.5, 0.75, 2.5 + i%5);
468		441
469	rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);	442	rs_gen_func_perlin(2, 33, 4, 0.5, 350+i);
470	rs_gen_func_normalize(2, 0.0, 1.0);	443	rs_gen_func_normalize(2, 0.0, 1.0);
471	rs_gen_func_posterize(2, 4);	444	rs_gen_func_posterize(2, 4);
472		445
473	rs_gen_func_cell(1, 410+i, 50, NULL, -2.0, 1.0, 1.0, 1.0, 0.0, 1.0);	446	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);	447	rs_gen_func_posterize(1, 2);
475	rs_gen_func_normalize(1, 0.0, 1.0);	448	rs_gen_func_normalize(1, 0.0, 1.0);
476	rs_gen_func_add(1, 1, 2, 1.0, 0.5);	449	rs_gen_func_add(1, 1, 2, 1.0, 0.5);
477	rs_gen_func_normalize(1, 0.0, 1.0);	450	rs_gen_func_normalize(1, 0.0, 1.0);
478	rs_gen_func_posterize(1, 4);	451	rs_gen_func_posterize(1, 4);
479		452
480	rs_gen_func_add(1, 0, 1, 1.0, 1.0);	453	rs_gen_func_add(1, 0, 1, 1.0, 1.0);
481	rs_gen_func_normalize(1, 0.0, 1.0);	454	rs_gen_func_normalize(1, 0.0, 1.0);
482	rs_gen_func_mult(1, 0, 1);	455	rs_gen_func_mult(1, 0, 1);
483	rs_gen_func_normalize(1, 0.0, 1.0);	456	rs_gen_func_normalize(1, 0.0, 1.0);
484	rs_gen_func_posterize(1, 4);	457	rs_gen_func_posterize(1, 4);
485	rs_gen_tex_out_rgba_set(0.0, 0.0, 0.0, 0.0);	458	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);	459	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		460
488	memcpy(game.tex_minirocks[i].data, rs_gen_reg.tex_out, rock_sizerock_size4 );	461	memcpy(game.tex_minirocks[i].data, rs_gen_reg.tex_out, rock_sizerock_size4 );
489	};	462	};
490	rs_gen_term();	463	rs_gen_term();
491		464
492		465
493		466
494		467
495	rs_gen_init(3, EXPLOSION_RADIUS*2);	468	rs_gen_init(3, EXPLOSION_RADIUS*2);
496	for (i = 0; i < EXPLOSIONS_COUNT; i++) {	469	for (i = 0; i < EXPLOSIONS_COUNT; i++) {
497		470
498	texture_init(&(game.tex_explosions[i]), EXPLOSION_RADIUS2, EXPLOSION_RADIUS2);	471	texture_init(&(game.tex_explosions[i]), EXPLOSION_RADIUS2, EXPLOSION_RADIUS2);
499		472
500	rs_gen_func_set(0, 1.0);	473	rs_gen_func_set(0, 1.0);

Subversion Repositories Kolibri OS

(root)/programs/games/heliothryx/game/rsgame.c – Rev 5316 → 5322