/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(); |
} |