Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 5234 → Rev 5235

/programs/games/marblematch3/game/rs/rsbits.h
0,0 → 1,11
#ifndef RSBITS_H_INCLUDED
#define RSBITS_H_INCLUDED
 
#define BIT_SET(var,mask) { var |= (mask); }
#define BIT_CLEAR(var,mask) { var &= ~(mask); }
#define BIT_TOGGLE(var,mask) { var ^= (mask); }
 
#define IS_BIT_SET(var,mask) ( (var) & (mask) )
#define IS_BIT_CLEARED(var,mask) (!( (var) & (mask) ))
 
#endif // RSBITS_H_INCLUDED
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/programs/games/marblematch3/game/rs/rsdebug.h
0,0 → 1,22
#ifndef RSDEBUG_H_INCLUDED
#define RSDEBUG_H_INCLUDED
 
// KolibriOS Placeholders
 
#define DEBUG10(a)
#define DEBUG10f(...)
 
#define DEBUG20(a)
#define DEBUG20f(...)
 
#define DEBUG30(a)
#define DEBUG30f(...)
 
 
#define DEBUGR(a)
#define DEBUGRf(...)
 
 
 
 
#endif // RSDEBUG_H_INCLUDED
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/programs/games/marblematch3/game/rs/rsmicrolibc.c
0,0 → 1,174
#include "rsmicrolibc.h"
 
// some math and string functions
 
double sqrt( double val ) {
double result ;
asm volatile ( "fld %1;"
"fsqrt;"
"fstp %0;" : "=g" (result) : "g" (val)
) ;
return result;
};
 
float sqrtf( float f ) {
return (float) sqrtf(f);
};
 
 
double sin(double val)
{
double result ;
asm volatile ( "fld %1;"
"fsin;"
"fstp %0;" : "=g" (result) : "g" (val)
) ;
return result;
}
 
double cos(double val)
{
double result ;
asm volatile ( "fld %1;"
"fcos;"
"fstp %0;" : "=g" (result) : "g" (val)
) ;
return result;
}
 
 
double exp (double x)
{
double result;
asm ("fldl2e; "
"fmulp; "
"fld %%st; "
"frndint; "
"fsub %%st,%%st(1); "
"fxch;"
"fchs; "
"f2xm1; "
"fld1; "
"faddp; "
"fxch; "
"fld1; "
"fscale; "
"fstp %%st(1); "
"fmulp" : "=t"(result) : "0"(x));
return result;
}
 
float expf(float x) {
return (float)(exp(x));
};
 
 
 
 
double log(double Power)
{
// From here: http://www.codeproject.com/Tips/311714/Natural-Logarithms-and-Exponent
double N, P, L, R, A, E;
E = 2.71828182845905;
P = Power;
N = 0.0;
 
// This speeds up the convergence by calculating the integral
while(P >= E)
{
P /= E;
N++;
}
N += (P / E);
P = Power;
do
{
A = N;
L = (P / (exp(N - 1.0)));
R = ((N - 1.0) * E);
N = ((L + R) / E);
} while (!( fabs(N-A)<0.01 ));
return N;
}
 
float logf(float x) {
return (float)(log(x));
};
 
double pow(double x, double p) {
if (x < 0.001) {
return 0.0;
};
return exp(p * log(x));
};
float powf(float x, float p) {
return expf(p * logf(x));
};
 
 
 
 
int abs(int x) {
return (x>0) ? x : -x;
};
double fabs(double x) {
return (x>0) ? x : -x;
};
 
double floor(double x) {
return (double)((int)x); // <--------- only positive!
};
 
double round(double x) {
return floor(x+0.5);
};
float roundf(float x) {
return (float)round(x);
};
 
 
 
 
void* malloc(unsigned s)
{
asm ("int $0x40"::"a"(68), "b"(12), "c"(s) );
}
 
 
void free(void *p)
{
asm ("int $0x40"::"a"(68), "b"(13), "c"(p) );
}
 
void* memset(void *mem, int c, unsigned size)
{
unsigned i;
 
for ( i = 0; i < size; i++ )
*((char *)mem+i) = (char) c;
 
return NULL;
}
 
 
void* memcpy(void *dst, const void *src, unsigned size)
{
 
unsigned i;
 
for ( i = 0; i < size; i++)
*(char *)(dst+i) = *(char *)(src+i);
 
return NULL;
}
 
 
 
 
/programs/games/marblematch3/game/rs/rsmicrolibc.h
0,0 → 1,53
#ifndef RS_MICROLIBC_FOR_KOLIBRI_H
#define RS_MICROLIBC_FOR_KOLIBRI_H
 
// some math and string functions
 
#ifndef NULL
#define NULL ((void*)0)
#endif
 
#ifndef uint32_t
#define uint32_t unsigned int
#endif
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
 
 
double sqrt( double val );
float sqrtf( float f );
 
double sin(double x);
float sinf(float x);
 
double cos(double x);
float cosf(float x);
 
double pow(double x, double p);
float powf(float x, float p);
 
double exp(double x);
float expf(float x);
 
double log(double x);
float logf(float x);
 
int abs(int x);
double fabs(double x);
 
double floor(double x);
 
double round(double x);
float roundf(float x);
 
 
void* malloc(unsigned size);
void free(void* pointer);
 
void* memset(void *mem, int c, unsigned size);
void* memcpy(void *dst, const void *src, unsigned size);
 
#endif
/programs/games/marblematch3/game/rs/rsmx.c
0,0 → 1,192
#include "rsmx.h"
 
#ifdef RS_USE_C_LIBS
#include <string.h>
#include <math.h>
#else
#include "rsplatform.h"
#endif
 
#include "rsdebug.h"
 
// Some matrix and vector stuff
// by Roman Shuvalov
 
 
rs_vec3_t rs_vec3_sub(rs_vec3_t v1, rs_vec3_t v2) {
return rs_vec3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
};
 
rs_vec3_t rs_vec3_add(rs_vec3_t v1, rs_vec3_t v2) {
return rs_vec3( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z );
};
 
rs_vec3_t rs_vec3_mult(rs_vec3_t v, float s) {
return rs_vec3( v.x * s, v.y * s, v.z * s );
};
 
 
rs_vec4_t rs_vec4_sub(rs_vec4_t v1, rs_vec4_t v2) {
rs_vec4_t dest;
dest.x = v1.x - v2.x;
dest.y = v1.y - v2.y;
dest.z = v1.z - v2.z;
dest.w = v1.z - v2.w;
return dest;
};
 
 
rs_vec4_t rs_vec4(float x, float y, float z, float w) {
rs_vec4_t r;
r.x = x;
r.y = y;
r.z = z;
r.w = w;
return r;
};
 
rs_vec3_t rs_vec3(float x, float y, float z) {
rs_vec3_t r;
r.x = x;
r.y = y;
r.z = z;
return r;
};
 
 
 
 
 
 
float rs_vec4_length_sqr(rs_vec4_t src) {
return src.x*src.x + src.y*src.y + src.z*src.z + src.w*src.w;
};
 
float rs_vec3_length_sqr(rs_vec3_t src) {
return src.x*src.x + src.y*src.y + src.z*src.z;
};
 
 
 
 
float rs_vec4_length(rs_vec4_t v) {
return sqrtf( rs_vec4_length_sqr(v) );
};
 
float rs_vec3_length(rs_vec3_t v) {
return sqrtf( rs_vec3_length_sqr(v) );
};
 
 
 
 
rs_vec3_t rs_vec3_normalize(rs_vec3_t v) {
float s = rs_vec3_length(v);
if (s > 0.00001) {
return rs_vec3( v.x / s, v.y / s, v.z / s );
}
return rs_vec3(0.0, 0.0, 0.0);
};
 
 
 
float rs_vec4_dot(rs_vec4_t v1, rs_vec4_t v2) {
return ( (v1.x) * (v2.x) ) + (v1.y * v2.y) + (v1.z * v2.z) + (v1.w * v2.w);
};
 
float rs_vec3_dot(rs_vec3_t v1, rs_vec3_t v2) {
return (v1.x) * (v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
};
 
 
 
 
rs_vec3_t rs_vec3_cross(rs_vec3_t u, rs_vec3_t v) {
rs_vec3_t d;
 
d.x = u.y * v.z - u.z * v.y;
d.y = u.z * v.x - u.x * v.z;
d.z = u.x * v.y - u.y * v.x;
 
return d;
 
};
 
 
 
float rs_vec4_angle(rs_vec4_t u, rs_vec4_t v) {
return rs_vec4_dot(u, v) / (rs_vec4_length(u) * rs_vec4_length(v) );
};
 
float rs_vec3_cos_angle(rs_vec3_t u, rs_vec3_t v) {
float ret = rs_vec3_dot(u, v) / (rs_vec3_length(u) * rs_vec3_length(v) );
return ret;
};
 
float rs_vec3_distance_sqr(rs_vec3_t u, rs_vec3_t v) {
return rs_vec3_length_sqr( rs_vec3(u.x - v.x, u.y - v.y, u.z - v.z) );
};
 
 
float rs_clamp(float x, float min1, float max1) {
if (x < min1) {
return min1;
};
if (x > max1) {
return max1;
};
return x;
};
 
int rs_clamp_i(int x, int min1, int max1) {
if (x < min1) {
return min1;
};
if (x > max1) {
return max1;
};
return x;
};
 
float rs_exp_interpolate(float v_from, float v_to, float dt) {
return v_from + ( v_to - v_from ) * ( 1 - exp(-dt/1.0) );
};
 
float rs_max(float x, float y) {
return x > y ? x : y;
};
 
float rs_min(float x, float y) {
return x < y ? x : y;
};
 
float rs_sign(float f) {
return (f >= 0.0) ? 1.0 : -1.0;
};
 
float rs_pow(float f, float p) {
return rs_sign(f) * pow( fabs(f), p );
};
 
float rs_clamp_angle(float f) { // !!!! only one iteration
if (f > 2.0*M_PI) {
return f - 2.0*M_PI;
};
if (f < -2.0*M_PI) {
return f + 2.0*M_PI;
};
return f;
};
 
float rs_linear_interpolate(float v_from, float v_to, float t) {
return v_from*(1.0-t) + v_to*t;
};
 
float rs_fract(float f) {
float r = floor(f);
return f - r;
};
 
 
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/programs/games/marblematch3/game/rs/rsmx.h
0,0 → 1,104
#ifndef rs_mx_t_H_INCLUDED
#define rs_mx_t_H_INCLUDED
 
// Some matrix and vector stuff
// by Roman Shuvalov
 
#define RS_SQR(x) ((x)*(x))
 
 
// actual period is 1024 ms (1.024 sec)
#define RS_TIME_KOEF_SEC (M_PI * 2.0 * 64.0 / 65536.0)
 
 
 
typedef struct {
union {
struct {
float x;
float y;
float z;
};
float v[3];
};
 
} rs_vec3_t;
 
 
typedef struct {
union {
struct {
float x;
float y;
float z;
float w;
};
float v[4];
};
 
} rs_vec4_t;
 
 
 
 
 
 
rs_vec3_t rs_vec3_sub(rs_vec3_t v1, rs_vec3_t v2);
 
rs_vec3_t rs_vec3_add(rs_vec3_t v1, rs_vec3_t v2);
 
rs_vec3_t rs_vec3_mult(rs_vec3_t v, float s);
 
 
rs_vec4_t rs_vec4_sub(rs_vec4_t v1, rs_vec4_t v2);
 
void rs_vec4_add(rs_vec4_t dest, rs_vec4_t v1, rs_vec4_t v2);
 
rs_vec4_t rs_vec4(float x, float y, float z, float w);
 
rs_vec3_t rs_vec3(float x, float y, float z);
 
 
 
 
float rs_vec4_length_sqr(rs_vec4_t src);
float rs_vec3_length_sqr(rs_vec3_t src);
 
 
 
float rs_vec4_length(rs_vec4_t v);
float rs_vec3_length(rs_vec3_t v);
 
float rs_vec4_dot(rs_vec4_t v1, rs_vec4_t v2);
float rs_vec3_dot(rs_vec3_t v1, rs_vec3_t v2);
 
 
rs_vec3_t rs_vec3_cross(rs_vec3_t u, rs_vec3_t v);
 
rs_vec3_t rs_vec3_normalize(rs_vec3_t v);
 
float rs_vec4_angle(rs_vec4_t u, rs_vec4_t v);
 
float rs_vec3_cos_angle(rs_vec3_t u, rs_vec3_t v);
 
 
 
float rs_vec3_distance_sqr(rs_vec3_t u, rs_vec3_t v);
 
float rs_clamp(float x, float min1, float max1);
int rs_clamp_i(int x, int min1, int max1);
 
float rs_max(float x, float y);
float rs_min(float x, float y);
 
float rs_sign(float f);
float rs_pow(float f, float p);
float rs_fract(float f);
 
float rs_exp_interpolate(float v_from, float v_to, float dt);
float rs_linear_interpolate(float v_from, float v_to, float t);
 
 
float rs_clamp_angle(float f);
 
#endif // rs_mx_t_H_INCLUDED
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/programs/games/marblematch3/game/rs/rsplatform.h
0,0 → 1,92
#ifndef RS_PLATFORM_FOR_KOLIBRI_H
#define RS_PLATFORM_FOR_KOLIBRI_H
 
#include "../../system/sound.h"
#include "../../system/kolibri.h"
#include "rsmicrolibc.h"
 
 
#ifndef uint32_t
#define uint32_t unsigned int
#endif
 
 
#define RS_KEY_DOWN 80
#define RS_KEY_UP 72
#define RS_KEY_LEFT 75
#define RS_KEY_RIGHT 77
 
#define RS_KEY_RETURN 28
#define RS_KEY_ESCAPE 1
#define RS_KEY_SPACE 57
#define RS_KEY_CONTROL_L 29
 
#define RS_KEY_1 2
#define RS_KEY_2 3
#define RS_KEY_3 4
#define RS_KEY_4 5
#define RS_KEY_5 6
#define RS_KEY_6 7
#define RS_KEY_7 8
#define RS_KEY_8 9
#define RS_KEY_9 10
#define RS_KEY_0 11
 
#define RS_KEY_P 25
 
#define RS_KEY_A 30
#define RS_KEY_S 31
#define RS_KEY_Z 44
#define RS_KEY_X 45
 
 
unsigned int get_time();
 
 
typedef void RSFUNC0();
/*typedef void RSFUNC1i(int);
typedef void RSFUNC2i(int,int);
typedef void RSFUNC1i1f(int,float); */
 
typedef RSFUNC0 *PRSFUNC0;
/*typedef RSFUNC1i *PRSFUNC1i;
typedef RSFUNC2i *PRSFUNC2i;
typedef RSFUNC1i1f *PRSFUNC1i1f;*/
 
/*
void NullFunc0();
void NullFunc1i(int i);
void NullFunc2i(int i, int j);
void NullFunc1i1f(int i, float f);
 
*/
 
typedef struct rs_app_t {
 
unsigned short app_time;
unsigned short delta_time;
/*
 
PRSFUNC2i OnKeyDown;
PRSFUNC1i OnKeyUp;
PRSFUNC2i OnMouseDown;
PRSFUNC2i OnMouseUp;
 
PRSFUNC0 OnAppProcess;
PRSFUNC0 rsAppOnInitDisplay;
PRSFUNC0 rsAppOnTermDisplay;
*/
 
} rs_app_t;
 
extern rs_app_t rs_app;
 
//void rsAppZero();
 
 
 
#endif
/programs/games/marblematch3/game/rs/rsplatform_kos.c
0,0 → 1,269
#include "rsplatform.h"
 
rs_app_t rs_app;
 
 
 
 
// set this macro to zero (0) if bug is fixed
#define FIX_MENUETOS_LEGACY_ONE_PIXEL_BORDER_GAP_BUG (-1)
 
// Fixed frame rate, set to 25
#define GAME_REQUIRED_FPS 25
 
 
 
//extern char PATH[256];
//extern char PARAM[256];
 
int window_width, window_height;
 
int fps = 0;
int dt = 1;
int draw_dt = 1;
int area_width = 160;
int area_height = 160;
 
int w_plus = 0;
 
 
 
 
 
#define BIT_SET(var,mask) { var |= (mask); }
#define BIT_CLEAR(var,mask) { var &= ~(mask); }
#define BIT_TOGGLE(var,mask) { var ^= (mask); }
 
#define IS_BIT_SET(var,mask) ( (var) & (mask) )
#define IS_BIT_CLEARED(var,mask) (!( (var) & (mask) ))
 
 
void BoardPuts(const char *s)
{
unsigned int i = 0;
while(*(s + i))
{
asm volatile ("int $0x40"::"a"(63), "b"(1), "c"(*(s + i)));
i++;
}
}
 
void board_write_integer(const char *s, int i) {
 
char tmp[16];
 
};
 
 
void kol_wnd_resize(unsigned w, unsigned h)
{
asm volatile ("int $0x40"::"a"(67), "b"(-1), "c"(-1), "d"(w), "S"(h));
}
 
 
 
 
void wnd_draw()
{
 
char tmp[] = "Fps:000 | Marble Match-3 Beta by Roman Shuvalov";
kol_paint_start();
 
tmp[4] = '0' + ( (fps/100) % 10 );
tmp[5] = '0' + ( (fps/10) % 10 );
tmp[6] = '0' + ( (fps) % 10 );
 
kol_wnd_define(100, 100, window_width, window_height, 0x74ddddff, 0x34ddddff, "Heliothryx");
kol_wnd_caption(tmp);
 
GameProcess();
 
//kol_btn_define(10, 10, 120, 20, 2, 0xccccee);
//kol_paint_string(20, 15, "Hello World", 0x902222ff);
 
kol_paint_end();
 
}
 
 
unsigned int get_time() {
return (unsigned int) ((kol_system_time_get()*10));
};
 
 
/// ===========================================================
 
void kol_main()
{
 
BoardPuts("Hello, Heliothryx!\n");
int err;
int version =-1;
if((err = InitSound(&version)) !=0 ){
BoardPuts("Sound Error 1\n");
};
if( (SOUND_VERSION>(version&0xFFFF)) ||
(SOUND_VERSION<(version >> 16))){
BoardPuts("Sound Error 2\n");
}
 
 
unsigned event;
unsigned key;
unsigned key_up;
unsigned btn, btn_state;
unsigned pos, x, y;
int gx, gy;
 
//srand(kol_system_time_get());
 
kol_event_mask(0xC0000027); // mouse and keyboard
kol_key_mode_set(1);
area_width = 512;
area_height = 512;
 
// Initializing variables
window_width = FIX_MENUETOS_LEGACY_ONE_PIXEL_BORDER_GAP_BUG + area_width + 10; // 2 x 5px border
window_height = FIX_MENUETOS_LEGACY_ONE_PIXEL_BORDER_GAP_BUG + kol_skin_height() + area_height + 5; // bottom 5px border
 
//rs_main_init();
GameInit();
 
wnd_draw();
 
fps = 0;
unsigned int tick_start = kol_time_tick();
unsigned int tick_current = tick_start;
unsigned int tick_last = tick_start;
unsigned int fps_counter = 0;
int wait_time;
int already_drawn = 0;
float xf;
float xfs;
int xfs_i;
while (1) {
tick_last = tick_current;
tick_current = kol_time_tick();
dt = tick_current - tick_last;
tick_last = tick_current;
already_drawn = 0;
while (( event = kol_event_wait_time(1) )) {
//while (( event = kol_event_wait() )) {
switch (event) {
case 1:
wnd_draw(); // <--- need to clear event!
already_drawn = 1;
break;
 
case 2:
key = kol_key_get();
key = (key & 0xff00)>>8;
key_up = key & 0x80;
key = key & 0x7F;
if (key_up) {
GameKeyUp(key);
//rs_app.OnKeyUp(key);
}
else {
GameKeyDown(key);
//rs_app.OnKeyDown(key, 1);
};
break;
case 3:
switch ((kol_btn_get() & 0xff00)>>8)
{
case 1: // close button
kol_exit();
case 2: // 'new' button
//init_board();
//wnd_draw();
break;
}
break;
case 6:
btn = kol_mouse_btn() & 1; // read mouse button (only left)
pos = kol_mouse_posw(); // read mouse position
x = pos / 65536;
y = pos % 65536;
/*if (x > window_width)
x=0;
if (y > window_height)
y=0;*/
if (btn && (!btn_state)) {
//rs_app.OnMouseDown(x,y);
GameMouseDown(x, y);
BoardPuts("MouseDown!\n");
}
else if ( (!btn) && btn_state ) {
//rs_app.OnMouseUp(x,y);
GameMouseUp(x, y);
}
else {
//GameMouseMove(x, y);
};
btn_state = btn;
break;
}
};
if (!already_drawn) {
wnd_draw();
};
fps_counter++;
tick_current = kol_time_tick();
if (tick_current > tick_start+100) {
fps = fps_counter;
fps_counter = 0;
tick_start += 100;
};
draw_dt = tick_current - tick_last;
wait_time = (100/GAME_REQUIRED_FPS) - draw_dt;
if (wait_time <= 0) {
wait_time = 1;
};
kol_sleep(wait_time);
 
 
}
 
GameTerm();
 
kol_exit();
}