First SHC commit. Ready to rock!

.gitignore

@@ -15,3 +15,10 @@
 *.exe
 *.out
 *.app
+
+#Casio SDK Settings
+Debug
+INIT
+SDCard
+*.g1a
+*.G1A

AddinInfo.txt

@@ -0,0 +1,12 @@
+//------------------------------------------------------------------
+// Addin-Application header control file, created with the CASIO SDK
+//------------------------------------------------------------------
+[OUTPUT]     : "HEXAGON.G1A"
+[BINDATA]    : "FXADDINror.bin"
+[DISPNAME]   : "hexagon"
+[APPNAME]    : "@HEXAGON"
+[VERSION]    : "01.00.0000"
+[APL_ICON]   : "MainIcon.bmp"
+[MODULE_NUM] : 0
+[MOD1_TITLE] : "hexagon"
+[MOD1_ICON]  : "eActivityIcon.bmp"

ECode.c

@@ -0,0 +1,766 @@
+/***********************************/
+/**          Easy Coding          **/
+/**Category : Snippets Collection **/
+/**@author Eiyeron                **/
+/**@contact eiyeron@gmail.com     **/
+/**@file ECode.c                  **/
+/**Version : 1.11                 **/
+/**Date of creation : 06/28/2011  **/
+/***********************************/
+
+
+#include "ECode.h"
+
+/******************************/
+/** Dependencies management  **/
+/******************************/
+
+#ifdef EASY_ALL
+	#define EASY_MODEL
+	#define EASY_STRING
+	#define EASY_2STR
+	#define EASY_2NUM
+	#define EASY_2HEX
+	#define EASY_BITS
+	#define EASY_KEYS
+	#define EASY_OTHERS
+
+#endif
+
+#ifdef EASY_MODEL
+	#define EASY_ISEMULATOR
+	#define EASY_ISG35P
+	#define EASY_ISG75
+	#define EASY_ISG85
+	#define EASY_ISG85SD
+	#define EASY_ISG95
+	#define EASY_MODELDETECTOR
+	#define EASY_HASSD
+#endif
+
+#ifdef EASY_STRING
+	#define EASY_TOLOWER
+	#define EASY_TOUPPER
+	#define EASY_STRMIRROR
+	#define EASY_STRROTATE
+	#define EASY_PRINTF
+	#define EASY_PRINTN
+#endif
+
+#ifdef EASY_2STR
+	#define EASY_CHAR2STR
+	#define EASY_UCHAR2STR
+	#define EASY_INT2STR
+	#define EASY_UINT2STR
+	#define EASY_FLOAT2STR
+#endif
+
+#ifdef EASY_2NUM
+	#define EASY_STR2CHAR
+	#define EASY_STR2UCHAR
+	#define EASY_STR2INT
+	#define EASY_STR2UINT
+#endif
+
+#ifdef EASY_2HEX
+	#define EASY_CHAR2HEX
+	#define EASY_INT2HEX
+#endif
+
+#ifdef EASY_BITS
+	#define EASY_READ_BIT_CHAR
+	#define EASY_UP_BIT_CHAR
+	#define EASY_DOWN_BIT_CHAR
+	#define EASY_INVERSE_BIT_CHAR
+	#define EASY_READ_BIT_INT
+	#define EASY_UP_BIT_INT
+	#define EASY_DOWN_BIT_INT
+	#define EASY_INVERSE_BIT_INT
+#endif
+
+#ifdef EASY_KEYS
+	#define EASY_KEY_DOWN
+	#define EASY_KEY_UP
+	#define EASY_ANY_KEY
+#endif
+
+#ifdef EASY_OTHERS
+	#define EASY_INPUT
+	#define EASY_NUMARRAY_CHAR
+	#define EASY_NUMARRAY_INT
+#endif
+
+#ifdef EASY_KEY_UP
+#define EASY_KEY_DOWN
+#endif
+
+#ifdef EASY_FLOAT2STR
+#define EASY_INT2STR
+#endif
+
+#ifdef EASY_INPUT
+#include "fxlib.h"
+#endif
+
+#ifdef EASY_PRINTF
+#include "fxlib.h"
+#endif
+
+#ifdef EASY_PRINTN
+#include "fxlib.h"
+#endif
+#include "fxlib.h"
+/***************/
+/** Functions **/
+/***************/
+
+static int SysCallCode[] = {0xD201422B,0x60F20000,0x80010070};
+static int (*SysCall)( int R4, int R5, int R6, int R7, int FNo ) = (void*)&SysCallCode; // Elles sont en static, car je ne vais pas encore publier la liste des syscalls "utiles"
+
+#ifdef EASY_ISEMULATOR
+char isEmulator()
+{
+	return !( *(int*)0x80000300 );
+}
+#endif
+
+#ifdef EASY_ISG35P
+char isG35p75()
+{
+	return ( *(int*)0x80000300 == 0x33363246 ) && ( *(char*)0x8024FEE0  == 0xB4393341);
+}
+#endif
+
+#ifdef EASY_ISG75
+char isG75()
+{
+	return ( *(int*)0x80000300 ==  0xFAE0FB2C && *(char*)0x8024FEE0 == 0x4BC8053F);
+}
+#endif
+
+#ifdef EASY_ISG85
+char isG85()
+{
+	return ( *(int*)0x80000300 == 0x80005D7C );
+}
+#endif
+
+#ifdef EASY_ISG85SD
+char isG85SD()
+{
+
+	return *(int*)((*SysCall)(0, 0, 0, 0, 1128));
+}
+#endif
+
+#ifdef EASY_ISG95
+char isG95()
+{
+	return ( *(int*)0x80000300 == 0x34393342 );
+}
+#endif
+
+#ifdef EASY_MODELDETECTOR
+Model modelDetector()
+{
+	int model = *(int*)0x80000300;
+
+	switch(model)
+	{
+		case 0 :
+		return EMULATOR;
+		break;
+
+		case 0x33363246:
+		if ( *(int*)0x8024FEE0  == 0xB4393341)
+			return G35;
+		else return UNDEFINED;
+		break;
+
+		case 0x34393542:
+			if((int*)((*SysCall)(0, 0, 0, 0, 1128))) return G75;
+			else return G75;
+		break;
+
+		case 0x80005D7C :
+			if((int*)((*SysCall)(0, 0, 0, 0, 1128))) return G85SD;
+			else return G85;
+		break;
+
+		case 0x34393342 :
+		return G95;
+		break;
+
+		default :
+		return UNDEFINED;
+		break;
+	}
+
+}
+#endif
+
+#ifdef EASY_HASSD
+char hasSD()
+{
+	return ( *(char*)((*SysCall)(0, 0, 0, 0, 1128)) );
+}
+#endif
+
+
+
+#ifdef EASY_TOLOWER/**						OK					*/
+unsigned char* toLower(unsigned char* str)
+{
+	int i;
+	for(i=0; str[i] != '\0'; i++)
+	{
+		if(str[i] >= 'A' && str[i] <= 'Z')
+			str[i] += 32;
+	}
+	return str;
+}
+#endif
+
+#ifdef EASY_TOUPPER/**						OK					*/
+unsigned char* toUpper(unsigned char* str)
+{
+	int i;
+	for(i=0; str[i] != '\0' ; i++)
+	{
+		if(str[i] >= 'a' && str[i] <= 'z')
+			str[i] -= 32;
+	}
+	return str;
+}
+#endif
+
+#ifdef EASY_STRMIRROR/**						OK					*/
+unsigned char* strMirror(unsigned char* str)
+{
+	int i, len;
+	unsigned char tmp;
+
+	for(len=0; str[len]!= '\0' ; len++);
+
+	for(i=0; i< (int) len/2; i++)
+	{
+		tmp = str[len-i-1];
+		str[len-i-1] = str[i];
+		str[i] = tmp;
+	}
+	return str;
+}
+#endif
+
+#ifdef EASY_STRROTATE /**						OK					*/
+unsigned char* strRotate(unsigned char* str, char mov)
+{
+	int i, len;
+	unsigned char tmp;
+
+	for(len=0; str[len]!= '\0' ; len++);
+
+	mov= mov%len;
+	if(mov < 0)
+		mov += len;
+	if(mov == 0)
+		return str;
+	while(mov)
+	{
+		tmp = str[len-1];
+		for(i=len-1;i>0;i--)
+			str[i] = str[i-1];
+		str[0] = tmp;
+		mov--;
+	}
+	return str;
+}
+#endif
+
+#ifdef EASY_PRINTF/**						OK					*/
+/*void printf(unsigned char x, unsigned char y, unsigned char* str, int mode)
+{
+	locate(x,y);
+	switch(mode)
+	{
+	case 0:
+	Print(str);
+	return;
+
+	case 1:
+	PrintRev(str);
+	return;
+	}
+}*/
+void printf(unsigned char x, unsigned char y, unsigned char* str, char mode)
+{
+	locate(x,y);
+	if(mode)
+		PrintRev(str);
+	else
+		Print(str);
+}
+#endif
+
+#ifdef EASY_PRINTN/**						OK					*/
+void printn(unsigned char x, unsigned char y, int n, char mode)
+{
+	unsigned char c[12];
+
+	intToStr(c, n);
+	locate(x,y);
+	if(mode)
+		PrintRev(c);
+	else
+		Print(c);
+}
+#endif
+
+
+
+#ifdef EASY_INT2STR/**						OK					*/
+unsigned char* intToStr(unsigned char* c, int n)
+{
+    if(n==0)
+    {
+        c[0] = '0';
+        c[1] = 0;
+    }
+    else
+    {
+        int i, l=0;
+        if(n<0)
+        {
+            c[0] = '-';
+            n = abs(n);
+            l++;
+        }
+        for(i=n ; i ; i/=10)
+            l++;
+        c[l] = 0;
+        for(i=n ; i ; i/=10)
+            c[--l] = i%10+'0';
+    }
+	return c;
+}
+#endif
+
+#ifdef EASY_UINT2STR/**						OK					*/
+unsigned char* uintToStr(unsigned char* c, unsigned int n)
+{
+    if(n==0)
+    {
+        c[0] = '0';
+        c[1] = 0;
+    }
+    else
+    {
+        unsigned int i, l=0;
+        for(i=n ; i ; i/=10)
+            l++;
+        c[l] = 0;
+        for(i=n ; i ; i/=10)
+            c[--l] = i%10+'0';
+    }
+	return c;
+}
+#endif
+
+#ifdef EASY_CHAR2STR/**						OK					*/
+unsigned char* charToStr(unsigned char* c, char n)
+{
+    if(n==0)
+    {
+        c[0] = '0';
+        c[1] = 0;
+    }
+    else
+    {
+        int i, l=0;
+        if(n<0)
+        {
+            c[0] = '-';
+            n = abs(n);
+            l++;
+        }
+        for(i=n ; i ; i/=10)
+            l++;
+        c[l] = 0;
+        for(i=n ; i ; i/=10)
+            c[--l] = i%10+'0';
+    }
+	return c;
+}
+#endif
+
+#ifdef EASY_UCHAR2STR/**						OK					*/
+unsigned char* ucharToStr(unsigned char* c, unsigned char n)
+{
+    if(n==0)
+    {
+        c[0] = '0';
+        c[1] = 0;
+    }
+    else
+    {
+        int i, l=0;
+        /*if(n<0)
+        {
+            c[0] = '-';
+            n = abs(n);
+            l++;
+        }*/
+        for(i=n ; i ; i/=10)
+            l++;
+        c[l] = 0;
+        for(i=n ; i ; i/=10)
+            c[--l] = i%10+'0';
+    }
+	return c;
+}
+#endif
+
+#ifdef EASY_FLOAT2STR
+unsigned char* floatToStr(unsigned char* c, float f, int precision)
+{
+	int i, n=0, index = 0;
+	if(f<0)
+	{
+		f *=-1;
+		c[0] = '-';
+		index++;
+	}
+
+	i = f;
+	intToStr((unsigned char*)((int)c+index), i);
+	while(c[index])
+		index++;
+	if(f-i) {
+		c[index] = '.';
+		index++;
+		i = f = (f-i)*10;
+		while(f && n<precision) {
+			c[index] = i;
+			index++;
+			n++;
+			i = f = (f-i)*10;
+		}
+		c[index+1] = 0;
+
+	}
+	return c;
+}
+#endif
+
+
+
+#ifdef EASY_STR2CHAR
+char strToChar(unsigned char* c)
+{
+	int i, start = 0;
+	char n = 0;
+	if(c[0] == '-')
+		start++;
+	for(i=start; c[i]; i++)
+	{
+		if(c[i]<='9' && c[i] >= '0')
+			n = n*10+c[i] - '0';
+	}
+	if(start)
+		n *= -1;
+	return n;
+}
+#endif
+
+#ifdef EASY_STR2UCHAR
+unsigned char strToUchar(unsigned char* c)
+{
+	int i = 0;
+	char n = 0;
+	for(i=0; c[i]; i++)
+	{
+		if(c[i]<='9' && c[i] >= '0')
+			n = n*10+c[i] - '0';
+	}
+	return n;
+}
+#endif
+
+#ifdef EASY_STR2INT
+int strToInt(unsigned char* c)
+{
+	int i,n = 0, start = 0;
+	if(c[0] == '-')
+		start++;
+	for(i=start; c[i]; i++)
+	{
+		if(c[i]<='9' && c[i] >= '0')
+			n = n*10+c[i] - '0';
+	}
+	if(start)
+		n *= -1;
+	return n;
+}
+#endif
+
+#ifdef EASY_STR2UINT
+unsigned int strToUint(unsigned char* c)
+{
+	int i,n = 0;
+	for(i=0; c[i]; i++)
+	{
+		if(c[i]<='9' && c[i] >= '0')
+			n = n*10+c[i] - '0';
+	}
+	return n;
+}
+#endif
+
+
+
+#ifdef EASY_CHAR2HEX
+char* charToHex(char* result, unsigned char hex) // Needs an 3-char array ("xx\0")
+{
+	char HEX1=hex/16;
+	char HEX2=hex%16;
+
+	if (HEX1<=9)
+		HEX1+='0';
+	else
+		HEX1=HEX1-10+'a';
+
+	if (HEX2<=9)
+		HEX2+='0';
+	else
+		HEX2=HEX2-10+'a';
+
+		result[0] = HEX1;
+		result[1] = HEX2;
+		result[2] = '\0';
+
+	return result;
+}
+#endif
+
+#ifdef EASY_INT2HEX
+char* intToHex(char* result, unsigned int hex) // Needs an 9-char array ("xxxxxxxx\0")
+{
+	int i;
+	for(i=0 ; i<8 ; i++)
+	{
+		result[7-i] = (hex&15) + ((hex&15)>9 ? 'A'-10 : '0');
+		hex >>= 4;
+	}
+	result[8] = '\0';
+	return result;
+}
+#endif
+
+
+
+#ifdef EASY_READ_BIT_CHAR
+char readBit_char(char num, char index)
+{
+	return !(num & 1<< (7 - index)) ==0;
+}
+#endif
+
+#ifdef EASY_INVERSE_BIT_CHAR
+char inverseBit_char(char num, char index)
+{
+	return num ^ 1<<7-index;
+}
+#endif
+
+#ifdef EASY_UP_BIT_CHAR
+char upBit_char(char num, char index)
+{
+	return num | 1<<7-index;
+}
+#endif
+
+#ifdef EASY_DOWN_BIT_CHAR
+char downBit_char(char num, char index)
+{
+	return num & (~(1<<(7-index)));
+}
+#endif
+
+#ifdef EASY_READ_BIT_INT
+char readBit_int(int num, char index)
+{
+	return (num & 1 << 31 - index)& 1;
+}
+#endif
+
+#ifdef EASY_INVERSE_BIT_INT
+int inverseBit_int(int num, char index)
+{
+	return num ^ 1<<31-index;
+}
+#endif
+
+#ifdef EASY_UP_BIT_INT
+int upBit_int(int num, char index)
+{
+	return num | 1<<31-index;
+}
+#endif
+
+#ifdef EASY_DOWN_BIT_INT
+int downBit_int(int num, char index)
+{
+	return num & (~1<<31-index);
+}
+#endif
+
+
+
+static void delay( void ) // Cette fonction n'est utilisée que pour KeyDown/Up, et elle n'est absolument pas utile ailleurs. D'où le static.
+{
+unsigned char i;
+  for (i=0;i<5;i++);
+}
+
+#ifdef EASY_KEY_DOWN
+unsigned char KeyDown( unsigned char code)
+{
+	int result=0;
+	short*PORTB_CTRL=(void*)0xA4000102;
+	short*PORTM_CTRL=(void*)0xA4000118;
+	char*PORTB=(void*)0xA4000122;
+	char*PORTM=(void*)0xA4000138;
+	char*PORTA=(void*)0xA4000120;
+	short smask;
+	char cmask;
+	unsigned char column, row;
+
+	column = code>>4;
+	row = code &0x0F;
+
+	smask = 0x0003 << (( row %8)*2);
+	cmask = ~( 1 << ( row %8) );
+	if ( row <8)
+	{
+		// configure port B as input, except for the "row to check"-bit, which has to be an output.
+		*PORTB_CTRL = 0xAAAA ^ smask;
+		// configure port M as input; port M is inactive with row < 8
+		*PORTM_CTRL = (*PORTM_CTRL & 0xFF00 ) | 0x00AA;
+		delay();
+		*PORTB = cmask;    // set the "row to check"-bit to 0 on port B
+		*PORTM = (*PORTM & 0xF0 ) | 0x0F;    // port M is inactive with row < 8
+	}
+	else
+	{
+		*PORTB_CTRL = 0xAAAA;  // configure port B as input; port B is inactive with row >= 8
+		// configure port M as input, except for the "row to check"-bit, which has to be an output.
+		*PORTM_CTRL = ((*PORTM_CTRL & 0xFF00 ) | 0x00AA)  ^ smask;
+		delay();
+		*PORTB = 0xFF;    // port B is inactive with row >= 8 (all to 1)
+		*PORTM = (*PORTM & 0xF0 ) | cmask;  // set the "row to check"-bit to 0
+	};
+	delay();
+	result = (~(*PORTA))>>column&1;   // a pressed key in the row-to-check draws the corresponding bit to 0
+	delay();
+	*PORTB_CTRL = 0xAAAA;
+	*PORTM_CTRL = (*PORTM_CTRL & 0xFF00 ) | 0x00AA;
+	delay();
+	*PORTB_CTRL = 0x5555;
+	*PORTM_CTRL = (*PORTM_CTRL & 0xFF00 ) | 0x0055;
+	delay();
+  return result;
+}
+#endif
+
+#ifdef EASY_KEY_UP
+unsigned char KeyUp(unsigned char code)
+{
+	return !(KeyDown(code));
+}
+#endif
+
+
+#ifdef EASY_ANY_KEY
+unsigned char AnyKey()
+{
+	return *((unsigned char*)0xA4000120)!=0xFF;
+}
+#endif
+
+
+
+#ifdef EASY_INPUT
+char* input(char* c, int x, int y, int longueur, char nb)
+{
+    int i, key, curseur=0;
+    char lettre;
+    locate(x, y);
+	Print("[");
+    locate(x+longueur+1, y);Print("]");
+    while(1)
+    {
+        locate(x+1, y);
+        Print(c);
+        if(strlen(c)<longueur) Print(" ");
+        Bdisp_DrawLineVRAM((x+curseur)*6, (y-1)*8, (x+curseur)*6, (y-1)*8+6);
+        Bdisp_DrawLineVRAM((x+curseur)*6+1, (y-1)*8, (x+curseur)*6+1, (y-1)*8+6);
+        GetKey(&key);
+        lettre=0;
+        switch(key)
+        {
+            case KEY_CTRL_LEFT: if(curseur) curseur--; break;
+            case KEY_CTRL_RIGHT: if(c[curseur]) curseur++; break;
+            case KEY_CTRL_DEL:
+                if(curseur)
+                {
+                    for(i=curseur ; i<longueur ; i++)
+                        c[i-1] = c[i];
+                    locate(x+curseur+1, y);Print(" ");
+                    curseur--;
+                }
+                else
+                {
+                    for(i=0 ; c[i] ; i++)
+                        c[i] = c[i+1];
+                }
+                break;
+            case KEY_CTRL_EXIT: c[0] = 0; return c;
+            case KEY_CTRL_QUIT: c[0] = 0; return c;
+            case KEY_CTRL_EXE: return c;
+            case KEY_CHAR_PLUS: lettre='+'; break;
+            case KEY_CHAR_MINUS: lettre='-'; break;
+            case KEY_CHAR_POW: lettre='^'; break;
+            case KEY_CTRL_XTT: lettre='X'; break;
+            default:
+                if(nb)
+                {
+                    if(key>='0' && key<='9')
+                        lettre=key;
+                }
+                else if(key>0 && key<256)
+                    lettre=key;
+        }
+        if(lettre && curseur<longueur)
+        {
+            for(i=longueur-1 ; i>=curseur ; i--)
+                c[i] = c[i-1];
+            c[curseur] = lettre;
+            curseur++;
+        }
+    }
+}
+#endif
+
+#ifdef EASY_NUMARRAY_CHAR
+int numArray_char(char* arr)
+{
+	return sizeof(arr);
+}
+#endif
+
+#ifdef EASY_NUMARRAY_INT
+int numArray_int(char* arr)
+{
+	return sizeof(arr)/4;
+}
+#endif

ECode.h

@@ -0,0 +1,216 @@
+/***********************************/
+/**          Easy Coding          **/
+/**Category : Snippets Collection **/
+/**@author Eiyeron                **/
+/**@contact eiyeron@gmail.com     **/
+/**@file ECode.h                  **/
+/**Version : 1.11                 **/
+/**Date of creation : 06/28/2011  **/
+/***********************************/
+
+#ifndef EASYCODE
+#define EASYCODE
+
+/****************************************************/
+/** uncomment #define EASY_of functions you want to use **/
+/****************************************************/
+
+// #define EASY_ALL	//define all functions
+// #define EASY_MODEL
+// #define EASY_STRING
+// #define EASY_2STR
+// #define EASY_2NUM
+// #deinfe EASY_ALL_2HEX
+// #define EASY_OPS_BITS
+#define EASY_KEYS_DETECTION
+// #define EASY_OTHERS
+
+/**MODEL DETECTION**/
+// #define EASY_ISEMULATOR
+// #define EASY_ISG35P
+// #define EASY_ISG75
+// #define EASY_ISG85P
+// #define EASY_ISG95
+// #define EASY_MODELDETECTOR
+
+/**STRING MANIUPLATION**/
+// #define EASY_TOLOWER
+// #define EASY_TOUPPER
+// #define EASY_STRMIRROR
+// #define EASY_STRROTATE
+// #define EASY_PRINTF
+// #define EASY_PRINTN
+
+/**TO STRING**/
+// #define EASY_CHAR2STR
+// #define EASY_UCHAR2STR
+#define EASY_INT2STR
+// #define EASY_UINT2STR
+// #define EASY_FLOAT2STR
+
+/**TO NUMBER**/
+// #define EASY_STR2CHAR
+// #define EASY_STR2UCHAR
+ #define EASY_STR2INT
+// #define EASY_STR2UINT
+
+/**TO HEX**/
+// #define EASY_CHAR2HEX
+// #define EASY_INT2HEX
+
+/**BITS OPERATIONS**/
+// #define EASY_READ_BIT_CHAR
+// #define EASY_UP_BIT_CHAR
+// #define EASY_DOWN_BIT_CHAR
+// #define EASY_INVERSE_BIT_CHAR
+// #define EASY_READ_BIT_INT
+// #define EASY_UP_BIT_INT
+// #define EASY_DOWN_BIT_INT
+// #define EASY_INVERSE_BIT_INT
+
+/**FAST KEYS DETECTION**/
+#define EASY_KEY_DOWN
+#define EASY_KEY_UP
+// #define EASY_ANY_KEY
+
+/**OTHERS**/
+ #define EASY_INPUT
+// #define EASY_NUMARRAY_CHAR
+// #define EASY_NUMARRAY_INT
+
+/**USEFUL VARIABLES**/
+// #define NULL 0
+// #define EXIT_SUCCESS 1
+
+
+/**************************/
+/** Functions prototypes **/
+/**************************/
+
+
+typedef enum {EMUlATOR, G35, G75, G85, G85SD, G95, UNDEFINED} Model;
+
+
+/**MODEL DETECTION**/
+char isEmulator();
+char isG35p75();
+char isG75();  // BESOIN DE LA VALEUR!!!
+char isG85();
+char isG85SD();
+char isG95();
+char hasSD();
+Model modelDetector();
+
+/**STRING MANIUPLATION**/
+char* toLower(unsigned char* str, unsigned int len);
+char* toUpper(unsigned char* str, unsigned int len);
+char* strMirror(unsigned char* str, unsigned int len);
+char* strRotate(unsigned char* str, unsigned int len, unsigned char mov);
+void printf(unsigned char x, unsigned char y, unsigned char str, int mode);
+void printn(unsigned char x, unsigned char y, int n, unsigned char mode);
+
+/**TO STRING OPERATIONS**/
+unsigned char* intToStr(unsigned char* c, int n);
+unsigned char* uintToStr(char* c, unsigned int n);
+unsigned char* charToStr(char* c, char n);
+unsigned char* ucharToStr(char* c, unsigned char n);
+unsigned char* floatToStr(char* c, float f, int pecision);
+
+/**TO NUMBER**/
+char strToChar(char* c);
+unsigned char strToUchar(char* c);
+int strToInt(unsigned char* c);
+unsigned int strToUint(char* c);
+
+/**TO HEX**/
+char* charToHex(char* result, unsigned char hex);
+char* intToHex(char* result, unsigned int hex);
+
+/**BITS OPERATIONS**/
+char readBit_char(char num, char index);
+char inverseBit_char(char num, char index);
+char upBit_char(char num, char index);
+char downBit_char(char num, char index);
+char readBit_int(int num, char index);
+int inverseBit_int(int num, char index);
+int upBit_int(int num, char index);
+int downBit_int(int num, char index);
+
+/**KEY DETECTION**/
+unsigned char KeyDown( unsigned char code);
+unsigned char KeyUp( unsigned char code);
+unsigned char AnyKey();
+
+
+/**OTHERS**/
+char* input(char* c, int x, int y, int longueur, char nb);
+int numArray_char(char* arr);
+int numArray_int(char* arr);
+
+
+/********************/
+/** Key Codes List **/
+/********************/
+
+
+#define K_F1	0x69
+#define K_F2	0x59
+#define K_F3	0x49
+#define K_F4	0x39
+#define K_F5	0x29
+#define K_F6	0x19
+
+#define K_SHIFT	0x68
+#define K_OPTN	0x58
+#define K_VARS	0x48
+#define K_MENU	0x38
+#define K_LEFT	0x28
+#define K_UP	0x18
+
+#define K_ALPHA	0x67
+#define K_SQR	0x57
+#define K_EXPO	0x47
+#define K_EXIT	0x37
+#define K_DOWN	0x27
+#define K_RIGHT	0x17
+
+#define K_THETA	0x66
+#define K_LOG	0x56
+#define K_LN	0x46
+#define K_SIN	0x36
+#define K_COS	0x26
+#define K_TAN	0x16
+
+#define K_FRAC	0x65
+#define K_FD	0x55
+#define K_LPAR	0x45
+#define K_RPAR	0x35
+#define K_COMMA	0x25
+#define K_STORE	0x15
+
+#define K_7 	0x64
+#define K_8		0x54
+#define K_9		0x44
+#define K_DEL	0x34
+
+#define K_4		0x63
+#define K_5		0x53
+#define K_6		0x43
+#define K_MULT	0x33
+#define K_DIV	0x23
+
+#define K_1		0x62
+#define K_2		0x52
+#define K_3		0x42
+#define K_PLUS	0x32
+#define K_MINUS	0x22
+
+#define K_0		0x61
+#define K_DOT	0x51
+#define K_EXP	0x41
+#define K_NEG	0x31
+#define K_EXE	0x21
+
+#define K_AC	0x00
+
+#endif //EASYCODE

FXSH_Build.bat

@@ -0,0 +1,22 @@
+@echo off
+rem Do not edit! This batch file is created by CASIO fx-9860G SDK.
+
+
+if exist HEXAGON.G1A  del HEXAGON.G1A
+
+cd debug
+if exist FXADDINror.bin  del FXADDINror.bin
+"C:\Program Files\CASIO\fx-9860G SDK\OS\SH\Bin\Hmake.exe" Addin.mak
+cd ..
+if not exist debug\FXADDINror.bin  goto error
+
+"C:\Program Files\CASIO\fx-9860G SDK\Tools\MakeAddinHeader363.exe" "Z:\home\adrien\Code\C\Casio\hexagon"
+if not exist HEXAGON.G1A  goto error
+echo Build has completed.
+goto end
+
+:error
+echo Build was not successful.
+
+:end
+

MonochromeLib.c

@@ -0,0 +1,1283 @@
+/*************************************************************/
+/** MonochromeLib - monochrome graphic library for fx-9860G **/
+/** MonochromeLib is free software                          **/
+/**                                                         **/
+/** @author Pierre "PierrotLL" Le Gall                      **/
+/** @contact legallpierre89@gmail.com                       **/
+/**                                                         **/
+/** @file MonochromeLib.c                                   **/
+/** Code file of MonochromeLib                              **/
+/**                                                         **/
+/** @date 06-17-2011                                        **/
+/*************************************************************/
+ 
+#include "MonochromeLib.h"
+#include <stdlib.h>
+
+
+/******************************/
+/** Dependencies management  **/
+/******************************/
+
+#ifdef ML_ALL
+#define ML_CLEAR_VRAM
+#define ML_CLEAR_SCREEN
+#define ML_DISPLAY_VRAM
+#define ML_SET_CONTRAST
+#define ML_GET_CONTRAST
+#define ML_PIXEL
+#define ML_POINT
+#define ML_PIXEL_TEST
+#define ML_LINE
+#define ML_HORIZONTAL_LINE
+#define ML_VERTICAL_LINE
+#define ML_RECTANGLE
+#define ML_POLYGONE
+#define ML_FILLED_POLYGONE
+#define ML_CIRCLE
+#define ML_FILLED_CIRCLE
+#define ML_ELLIPSE
+#define ML_ELLIPSE_IN_RECT
+#define ML_FILLED_ELLIPSE 
+#define ML_FILLED_ELLIPSE_IN_RECT
+#define ML_HORIZONTAL_SCROLL
+#define ML_VERTICAL_SCROLL
+#define ML_BMP_OR
+#define ML_BMP_AND
+#define ML_BMP_XOR
+#define ML_BMP_OR_CL
+#define ML_BMP_AND_CL
+#define ML_BMP_XOR_CL
+#define ML_BMP_8_OR
+#define ML_BMP_8_AND
+#define ML_BMP_8_XOR
+#define ML_BMP_8_OR_CL
+#define ML_BMP_8_AND_CL
+#define ML_BMP_8_XOR_CL
+#define ML_BMP_16_OR
+#define ML_BMP_16_AND
+#define ML_BMP_16_XOR
+#define ML_BMP_16_OR_CL
+#define ML_BMP_16_AND_CL
+#define ML_BMP_16_XOR_CL
+#endif
+
+#ifdef ML_POLYGONE
+#define ML_LINE
+#endif
+
+#ifdef ML_LINE
+#define ML_PIXEL
+#endif
+
+#ifdef ML_POINT
+#define ML_PIXEL
+#define ML_RECTANGLE
+#endif
+
+#ifdef ML_RECTANGLE
+#define ML_HORIZONTAL_LINE
+#endif
+
+#ifdef ML_FILLED_POLYGONE
+#define ML_HORIZONTAL_LINE
+#endif
+
+#ifdef ML_CIRCLE
+#define ML_PIXEL
+#endif
+
+#ifdef ML_FILLED_CIRCLE
+#define ML_HORIZONTAL_LINE
+#endif
+
+#ifdef ML_ELLIPSE_IN_RECT
+#define ML_ELLIPSE
+#endif
+
+#ifdef ML_ELLIPSE
+#define ML_PIXEL
+#endif
+
+#ifdef ML_FILLED_ELLIPSE_IN_RECT
+#define ML_FILLED_ELLIPSE
+#endif
+
+#ifdef ML_FILLED_ELLIPSE
+#define ML_HORIZONTAL_LINE
+#endif
+
+
+/***************/
+/** Functions **/
+/***************/
+
+#define sgn(x)	(x<0?-1:1)
+#define rnd(x)	((int)(x+0.5))
+
+//Thanks to Simon Lothar for this function
+int SysCallCode[] = {0xD201422B,0x60F20000,0x80010070};
+int (*SysCall)( int R4, int R5, int R6, int R7, int FNo ) = (void*)&SysCallCode;
+char* ML_vram_adress()
+{
+	return (char*)((*SysCall)(0, 0, 0, 0, 309));
+}
+
+#ifdef ML_CLEAR_VRAM
+void ML_clear_vram()
+{
+	int i, end, *pointer_long, vram;
+	char *pointer_byte;
+	vram = (int)ML_vram_adress();
+	end = 4-vram&3;
+	pointer_byte = (char*)vram;
+	for(i=0 ; i<end ; i++) pointer_byte[i] = 0;
+	pointer_long = (int*) (vram+end);
+	for(i=0 ; i<255 ; i++) pointer_long[i] = 0;
+	pointer_byte += 1020+end;
+	end = vram&3;
+	for(i=0 ; i<end ; i++) pointer_byte[i] = 0;
+}
+#endif
+
+#ifdef ML_CLEAR_SCREEN
+void ML_clear_screen()
+{
+	char *LCD_register_selector = (char*)0xB4000000, *LCD_data_register = (char*)0xB4010000;
+	int i, j;
+	for(i=0 ; i<64 ; i++) {
+		*LCD_register_selector = 4;
+		*LCD_data_register = i|192;
+		*LCD_register_selector = 4;
+		*LCD_data_register = 0;
+		*LCD_register_selector = 7;
+		for(j=0 ; j<16 ; j++) *LCD_data_register = 0;
+	}
+}
+#endif
+
+#ifdef ML_DISPLAY_VRAM
+void ML_display_vram()
+{
+	char *LCD_register_selector = (char*)0xB4000000, *LCD_data_register = (char*)0xB4010000, *vram;
+	int i, j;
+	vram = ML_vram_adress();
+	for(i=0 ; i<64 ; i++) {
+		*LCD_register_selector = 4;
+		*LCD_data_register = i|192;
+		*LCD_register_selector = 4;
+		*LCD_data_register = 0;
+		*LCD_register_selector = 7;
+		for(j=0 ; j<16 ; j++) *LCD_data_register = *vram++;
+	}
+}
+#endif
+
+#ifdef ML_SET_CONTRAST
+void ML_set_contrast(unsigned char contrast)
+{
+	char *LCD_register_selector = (char*)0xB4000000, *LCD_data_register = (char*)0xB4010000;
+	*LCD_register_selector = 6;
+	*LCD_data_register = contrast;
+}
+#endif
+
+#ifdef ML_GET_CONTRAST
+unsigned char ML_get_contrast()
+{
+	char *LCD_register_selector = (char*)0xB4000000, *LCD_data_register = (char*)0xB4010000;
+	*LCD_register_selector = 6;
+	return *LCD_data_register;
+}
+#endif
+
+#ifdef ML_PIXEL
+void ML_pixel(int x, int y, ML_Color color)
+{
+	char* vram = ML_vram_adress();
+	if(x<0 || x>127 || y<0 || y>63) return;
+	switch(color)
+	{
+		case BLACK:
+			vram[(y<<4)+(x>>3)] |= 128>>(x&7);
+			break;
+		case WHITE:
+			vram[(y<<4)+(x>>3)] &= ~(128>>(x&7));
+			break;
+		case XOR:
+			vram[(y<<4)+(x>>3)] ^= 128>>(x&7);
+			break;
+		case CHECKER:
+			if(y&1^x&1) vram[(y<<4)+(x>>3)] &= ~(128>>(x&7));
+			else vram[(y<<4)+(x>>3)] |= 128>>(x&7);
+			break;
+	}
+}
+#endif
+
+#ifdef ML_POINT
+void ML_point(int x, int y, int width, ML_Color color)
+{
+	if(width < 1) return;
+	if(width == 1) ML_pixel(x, y, color);
+	else
+	{
+		int padding, pair;
+		padding = width>>1;
+		pair = !(width&1);
+		ML_rectangle(x-padding+pair, y-padding+pair, x+padding, y+padding, 0, 0, color);
+	}
+}
+#endif
+
+#ifdef ML_PIXEL_TEST
+ML_Color ML_pixel_test(int x, int y)
+{
+	char *vram, byte;
+	if(x<0 || x>127 || y<0 || y>63) return TRANSPARENT;
+	vram = ML_vram_adress();
+	byte = 1<<(7-(x&7));
+	return (vram[(y<<4)+(x>>3)] & byte ? BLACK : WHITE);
+}
+#endif
+
+#ifdef ML_LINE
+void ML_line(int x1, int y1, int x2, int y2, ML_Color color)
+{
+	int i, x, y, dx, dy, sx, sy, cumul;
+	x = x1;
+	y = y1;
+	dx = x2 - x1;
+	dy = y2 - y1;
+	sx = sgn(dx);
+	sy = sgn(dy);
+	dx = abs(dx);
+	dy = abs(dy);
+	ML_pixel(x, y, color);
+	if(dx > dy)
+	{
+		cumul = dx / 2;
+		for(i=1 ; i<dx ; i++)
+		{
+			x += sx;
+			cumul += dy;
+			if(cumul > dx)
+			{
+				cumul -= dx;
+				y += sy;
+			}
+			ML_pixel(x, y, color);
+		}
+	}
+	else
+	{
+		cumul = dy / 2;
+		for(i=1 ; i<dy ; i++)
+		{
+			y += sy;
+			cumul += dx;
+			if(cumul > dy)
+			{
+				cumul -= dy;
+				x += sx;
+			}
+			ML_pixel(x, y, color);
+		}
+	}
+}
+#endif
+
+#ifdef ML_HORIZONTAL_LINE
+void ML_horizontal_line(int y, int x1, int x2, ML_Color color)
+{
+    int i;
+    char checker;
+    char* vram = ML_vram_adress();
+    if(y<0 || y>63 || (x1<0 && x2<0) || (x1>127 && x2>127)) return;
+    if(x1 > x2)
+    {
+    	i = x1;
+    	x1 = x2;
+    	x2 = i;
+    }
+    if(x1 < 0) x1 = 0;
+    if(x2 > 127) x2 = 127;
+    switch(color)
+    {
+    	case BLACK:
+			if(x1>>3 != x2>>3)
+			{
+				vram[(y<<4)+(x1>>3)] |= 255 >> (x1&7);
+				vram[(y<<4)+(x2>>3)] |= 255 << 7-(x2&7);
+				for(i=(x1>>3)+1 ; i<x2>>3 ; i++)
+					vram[(y<<4) + i] = 255;
+			}
+			else vram[(y<<4)+(x1>>3)] |= (255>>(x1%8 + 7-x2%8))<<(7-(x2&7));
+			break;
+		case WHITE:
+			if(x1>>3 != x2>>3)
+			{
+				vram[(y<<4)+(x1>>3)] &= 255 << 8-(x1&7);
+				vram[(y<<4)+(x2>>3)] &= 255 >> 1+(x2&7);
+				for(i=(x1>>3)+1 ; i<x2>>3 ; i++)
+					vram[(y<<4) + i] = 0;
+			}
+			else vram[(y<<4)+(x1>>3)] &= (255<<8-(x1&7)) | (255>>1+(x2&7));
+			break;
+		case XOR:
+			if(x1>>3 != x2>>3)
+			{
+				vram[(y<<4)+(x1>>3)] ^= 255 >> (x1&7);
+				vram[(y<<4)+(x2>>3)] ^= 255 << 7-(x2&7);
+				for(i=(x1>>3)+1 ; i<(x2>>3) ; i++)
+					vram[(y<<4) + i] ^= 255;
+			}
+			else vram[(y<<4)+(x1>>3)] ^= (255>>((x1&7) + 7-(x2&7)))<<(7-(x2&7));
+			break;
+		case CHECKER:
+			checker = (y&1 ? 85 : 170);
+			if(x1>>3 != x2>>3)
+			{
+				vram[(y<<4)+(x1>>3)] &= 255 << 8-(x1&7);
+				vram[(y<<4)+(x2>>3)] &= 255 >> 1+(x2&7);
+				vram[(y<<4)+(x1>>3)] |= checker & 255>>(x1&7);
+				vram[(y<<4)+(x2>>3)] |= checker & 255<<7-(x2&7);
+				for(i=(x1>>3)+1 ; i<x2>>3 ; i++)
+					vram[(y<<4) + i] = checker;
+			}
+			else
+			{
+				vram[(y<<4)+(x1>>3)] &= (255<<8-(x1&7)) | (255>>1+(x2&7));
+				vram[(y<<4)+(x1>>3)] |= checker & (255>>(x1%8 + 7-x2%8))<<(7-(x2&7));
+			}
+			break;
+    }
+}
+#endif
+
+#ifdef ML_VERTICAL_LINE
+void ML_vertical_line(int x, int y1, int y2, ML_Color color)
+{
+    int i, j;
+    char checker, byte, *vram = ML_vram_adress();
+	if(x<0 || x>127 || (y1<0 && y2<0) || (y1>63 && y2>63)) return;
+	if(y1 > y2)
+	{
+		int tmp = y1;
+		y1 = y2;
+		y2 = tmp;
+	}
+	if(y1 < 0) y1 = 0;
+	if(y2 > 63) y2 = 63;
+
+	i = (y1<<4)+(x>>3);
+	j = (y2<<4)+(x>>3);
+	switch(color)
+	{
+		case BLACK:
+			byte = 128>>(x&7);
+			for( ; i<=j ; i+=16)
+				vram[i] |= byte;
+			break;
+		case WHITE:
+			byte = ~(128>>(x&7));
+			for( ; i<=j ; i+=16)
+				vram[i] &= byte;
+			break;
+		case XOR:
+			byte = 128>>(x&7);
+			for( ; i<=j ; i+=16)
+				vram[i] ^= byte;
+			break;
+		case CHECKER:
+			byte = 128>>(x&7);
+			checker = y1&1^x&1;
+			for( ; i<=j ; i+=16)
+			{
+				if(checker) vram[i] &= ~byte;
+				else vram[i] |= byte;
+				checker = !checker;
+			}
+			break;
+	}
+}
+#endif
+
+#ifdef ML_RECTANGLE
+void ML_rectangle(int x1, int y1, int x2, int y2, int border_width, ML_Color border_color, ML_Color fill_color)
+{
+	int i;
+	if(x1 > x2)
+	{
+		i = x1;
+		x1 = x2;
+		x2 = i;
+	}
+	if(y1 > y2)
+	{
+		i = y1;
+		y1 = y2;
+		y2 = i;
+	}
+	if(border_width > (x2-x1)/2+1) border_width = (x2-x1)/2+1;
+	if(border_width > (y2-y1)/2+1) border_width = (y2-y1)/2+1;
+	if(border_color != TRANSPARENT && border_width > 0)
+	{
+		for(i=0 ; i<border_width ; i++)
+		{
+			ML_horizontal_line(y1+i, x1, x2, border_color);
+			ML_horizontal_line(y2-i, x1, x2, border_color);
+		}
+		for(i=y1+border_width ; i<=y2-border_width ; i++)
+		{
+			ML_horizontal_line(i, x1, x1+border_width-1, border_color);
+			ML_horizontal_line(i, x2-border_width+1, x2, border_color);
+		}
+	}
+	if(fill_color != TRANSPARENT)
+	{
+		for(i=y1+border_width ; i<=y2-border_width ; i++)
+			ML_horizontal_line(i, x1+border_width, x2-border_width, fill_color);
+	}
+}
+#endif
+
+#ifdef ML_POLYGONE
+void ML_polygone(int *x, int *y, int nb_vertices, ML_Color color)
+{
+	int i;
+	if(nb_vertices < 1) return;
+	for(i=0 ; i<nb_vertices-1 ; i++)
+		ML_line(x[i], y[i], x[i+1], y[i+1], color);
+	ML_line(x[i], y[i], x[0], y[0], color);
+}
+#endif
+
+#ifdef ML_FILLED_POLYGONE
+int ML_filled_polygone_quicksord_partition(int *t, int p, int r)
+{
+	int i, j, x, tmp;
+	j = p - 1;
+	x = t[r];
+	for(i=p ; i<r ; i++)
+	{
+		if(x > t[i])
+		{
+			j++;
+			tmp = t[j];
+			t[j] = t[i];
+			t[i] = tmp;
+		}
+	}
+	t[r] = t[j+1];
+	t[j+1] = x;
+	return j + 1;
+}
+
+void ML_filled_polygone_quicksord(int* t, int p, int r)
+{
+	int q;
+	if(p < r)
+	{
+		q = ML_filled_polygone_quicksord_partition(t, p, r);
+		ML_filled_polygone_quicksord(t, p, q-1);
+		ML_filled_polygone_quicksord(t, q+1, r);
+	}
+}
+
+
+void ML_filled_polygone(int *x, int *y, int nb_vertices, ML_Color color)
+{
+	int i, j, dx, dy, ymin, ymax;
+	int *cut_in_line, nb_cut;
+	if(nb_vertices < 3) return;
+	cut_in_line = malloc(nb_vertices*sizeof(int));
+	if(!cut_in_line) return;
+	ymin = ymax = y[0];
+	for(i=1 ; i<nb_vertices ; i++)
+	{
+		if(y[i] < ymin) ymin = y[i];
+		if(y[i] > ymax) ymax = y[i];
+	}
+	for(i=ymin ; i<=ymax ; i++)
+	{
+		nb_cut = 0;
+		for(j=0 ; j<nb_vertices ; j++)
+		{
+			if((y[j]<=i && y[(j+1)%nb_vertices]>=i) || (y[j]>=i && y[(j+1)%nb_vertices]<=i))
+			{
+				dy = abs(y[j]-y[(j+1)%nb_vertices]);
+				if(dy)
+				{
+					dx = x[(j+1)%nb_vertices]-x[j];
+					cut_in_line[nb_cut] = x[j] + rnd(abs(i-y[j]+sgn(i-y[j])/2)*dx/dy);
+					nb_cut++;
+				}
+			}
+		}
+		ML_filled_polygone_quicksord(cut_in_line, 0, nb_cut-1);
+		j = 0;
+		while(j<nb_cut-2 && cut_in_line[j]==cut_in_line[j+1]) j++;
+		while(j < nb_cut)
+		{
+			if(j == nb_cut-1) ML_horizontal_line(i, cut_in_line[j-1]+1, cut_in_line[j], color);
+			else
+			{
+				dx = 1;
+				while(j+dx<nb_cut-1 && cut_in_line[j+dx]==cut_in_line[j+dx+1]) dx++;
+				ML_horizontal_line(i, cut_in_line[j], cut_in_line[j+dx], color);
+				j += dx;
+			}
+			j++;
+		}
+	}
+	free(cut_in_line);
+}
+#endif
+
+#ifdef ML_CIRCLE
+void ML_circle(int x, int y, int radius, ML_Color color)
+{
+	int plot_x, plot_y, d;
+
+	if(radius < 0) return;
+	plot_x = 0;
+	plot_y = radius;
+	d = 1 - radius;
+
+	ML_pixel(x, y+plot_y, color);
+	if(radius)
+	{
+		ML_pixel(x, y-plot_y, color);
+		ML_pixel(x+plot_y, y, color);
+		ML_pixel(x-plot_y, y, color);
+	}
+	while(plot_y > plot_x)
+	{
+		if(d < 0)
+			d += 2*plot_x+3;
+		else
+		{
+			d += 2*(plot_x-plot_y)+5;
+			plot_y--;
+		}
+		plot_x++;
+		if(plot_y >= plot_x)
+		{
+			ML_pixel(x+plot_x, y+plot_y, color);
+			ML_pixel(x-plot_x, y+plot_y, color);
+			ML_pixel(x+plot_x, y-plot_y, color);
+			ML_pixel(x-plot_x, y-plot_y, color);
+		}
+		if(plot_y > plot_x)
+		{
+			ML_pixel(x+plot_y, y+plot_x, color);
+			ML_pixel(x-plot_y, y+plot_x, color);
+			ML_pixel(x+plot_y, y-plot_x, color);
+			ML_pixel(x-plot_y, y-plot_x, color);
+		}
+	}
+}
+#endif
+
+#ifdef ML_FILLED_CIRCLE
+void ML_filled_circle(int x, int y, int radius, ML_Color color)
+{
+	int plot_x, plot_y, d;
+
+	if(radius < 0) return;
+	plot_x = 0;
+	plot_y = radius;
+	d = 1 - radius;
+
+	ML_horizontal_line(y, x-plot_y, x+plot_y, color);
+	while(plot_y > plot_x)
+	{
+		if(d < 0)
+			d += 2*plot_x+3;
+		else {
+			d += 2*(plot_x-plot_y)+5;
+			plot_y--;
+			ML_horizontal_line(y+plot_y+1, x-plot_x, x+plot_x, color);
+			ML_horizontal_line(y-plot_y-1, x-plot_x, x+plot_x, color);
+		}
+		plot_x++;
+		if(plot_y >= plot_x)
+		{
+			ML_horizontal_line(y+plot_x, x-plot_y, x+plot_y, color);
+			ML_horizontal_line(y-plot_x, x-plot_y, x+plot_y, color);
+		}
+	}
+}
+#endif
+
+#ifdef ML_ELLIPSE
+void ML_ellipse(int x, int y, int radius1, int radius2, ML_Color color)
+{
+	int plot_x, plot_y;
+	float d1, d2;
+	if(radius1 < 1 || radius2 < 1) return;
+	plot_x = 0;
+	plot_y = radius2;
+	d1 = radius2*radius2 - radius1*radius1*radius2 + radius1*radius1/4;
+	ML_pixel(x, y+plot_y, color);
+	ML_pixel(x, y-plot_y, color);
+	while(radius1*radius1*(plot_y-.5) > radius2*radius2*(plot_x+1))
+	{
+		if(d1 < 0)
+		{
+			d1 += radius2*radius2*(2*plot_x+3);
+			plot_x++;
+		} else {
+			d1 += radius2*radius2*(2*plot_x+3) + radius1*radius1*(-2*plot_y+2);
+			plot_x++;
+			plot_y--;
+		}
+		ML_pixel(x+plot_x, y+plot_y, color);
+		ML_pixel(x-plot_x, y+plot_y, color);
+		ML_pixel(x+plot_x, y-plot_y, color);
+		ML_pixel(x-plot_x, y-plot_y, color);
+	}
+	d2 = radius2*radius2*(plot_x+.5)*(plot_x+.5) + radius1*radius1*(plot_y-1)*(plot_y-1) - radius1*radius1*radius2*radius2;
+	while(plot_y > 0)
+	{
+		if(d2 < 0)
+		{
+			d2 += radius2*radius2*(2*plot_x+2) + radius1*radius1*(-2*plot_y+3);
+			plot_y--;
+			plot_x++;
+		} else {
+			d2 += radius1*radius1*(-2*plot_y+3);
+			plot_y--;
+		}
+		ML_pixel(x+plot_x, y+plot_y, color);
+		ML_pixel(x-plot_x, y+plot_y, color);
+		if(plot_y > 0)
+		{
+			ML_pixel(x+plot_x, y-plot_y, color);
+			ML_pixel(x-plot_x, y-plot_y, color);
+		}
+	}
+}
+#endif
+
+#ifdef ML_ELLIPSE_IN_RECT
+void ML_ellipse_in_rect(int x1, int y1, int x2, int y2, ML_Color color)
+{
+	int radius1, radius2;
+	if(x1 > x2)
+	{
+		int tmp = x1;
+		x1 = x2;
+		x2 = tmp;
+	}
+	if(y1 > y2)
+	{
+		int tmp = y1;
+		y1 = y2;
+		y2 = tmp;
+	}
+	radius1 = (x2-x1)/2;
+	radius2 = (y2-y1)/2;
+	ML_ellipse(x1+radius1, y1+radius2, radius1, radius2, color);
+}
+#endif
+
+#ifdef ML_FILLED_ELLIPSE
+void ML_filled_ellipse(int x, int y, int radius1, int radius2, ML_Color color)
+{
+	int plot_x, plot_y;
+	float d1, d2;
+	if(radius1 < 1 || radius2 < 1) return;
+	plot_x = 0;
+	plot_y = radius2;
+	d1 = radius2*radius2 - radius1*radius1*radius2 + radius1*radius1/4;
+	while(radius1*radius1*(plot_y-.5) > radius2*radius2*(plot_x+1))
+	{
+		if(d1 < 0)
+		{
+			d1 += radius2*radius2*(2*plot_x+3);
+			plot_x++;
+		} else {
+			d1 += radius2*radius2*(2*plot_x+3) + radius1*radius1*(-2*plot_y+2);
+			ML_horizontal_line(y+plot_y, x-plot_x, x+plot_x, color);
+			ML_horizontal_line(y-plot_y, x-plot_x, x+plot_x, color);
+			plot_x++;
+			plot_y--;
+		}
+	}
+	ML_horizontal_line(y+plot_y, x-plot_x, x+plot_x, color);
+	ML_horizontal_line(y-plot_y, x-plot_x, x+plot_x, color);
+	d2 = radius2*radius2*(plot_x+.5)*(plot_x+.5) + radius1*radius1*(plot_y-1)*(plot_y-1) - radius1*radius1*radius2*radius2;
+	while(plot_y > 0)
+	{
+		if(d2 < 0)
+		{
+			d2 += radius2*radius2*(2*plot_x+2) + radius1*radius1*(-2*plot_y+3);
+			plot_y--;
+			plot_x++;
+		} else {
+			d2 += radius1*radius1*(-2*plot_y+3);
+			plot_y--;
+		}
+		ML_horizontal_line(y+plot_y, x-plot_x, x+plot_x, color);
+		if(plot_y > 0)
+			ML_horizontal_line(y-plot_y, x-plot_x, x+plot_x, color);
+	}
+}
+#endif
+
+#ifdef ML_FILLED_ELLIPSE_IN_RECT
+void ML_filled_ellipse_in_rect(int x1, int y1, int x2, int y2, ML_Color color)
+{
+	int radius1, radius2;
+	if(x1 > x2)
+	{
+		int tmp = x1;
+		x1 = x2;
+		x2 = tmp;
+	}
+	if(y1 > y2)
+	{
+		int tmp = y1;
+		y1 = y2;
+		y2 = tmp;
+	}
+	radius1 = (x2-x1)/2;
+	radius2 = (y2-y1)/2;
+	ML_filled_ellipse(x1+radius1, y1+radius2, radius1, radius2, color);
+}
+#endif
+
+#ifdef ML_HORIZONTAL_SCROLL
+void ML_horizontal_scroll(int scroll)
+{
+	int i, j;
+	unsigned char line[16], Bshift, next, *vram;
+	unsigned short word;
+	vram = ML_vram_adress();
+	scroll %= 128;
+	Bshift = 8-(scroll&7);
+	for(i=0 ; i<64 ; i++)
+	{
+		for(j=0 ; j<16 ; j++) line[j] = vram[(i<<4)+((j-(scroll>>3)+15)&15)];
+		next = line[15];
+		vram[(i<<4)+15] = 0;
+		for(j=15 ; j>0 ; j--)
+		{
+			word = next << Bshift;
+			next = line[j-1];
+			vram[(i<<4)+j] |= *((char*)&word+1);
+			vram[(i<<4)+j-1] = *((char*)&word);
+		}
+		word = next << Bshift;
+		vram[(i<<4)] |= *((char*)&word+1);
+		vram[(i<<4)+15] |= *((char*)&word);
+	}
+}
+#endif
+
+#ifdef ML_VERTICAL_SCROLL
+void ML_vertical_scroll(int scroll)
+{
+	int i, j;
+	char column[64], *vram = ML_vram_adress();
+	scroll %= 64;
+	for(i=0 ; i<16 ; i++)
+	{
+		for(j=0 ; j<64 ; j++) column[j] = vram[(j<<4)+i];
+		for(j=0 ; j<64 ; j++) vram[(j<<4)+i] = column[(j-scroll+64)&63];
+	}
+}
+#endif
+
+#ifdef ML_BMP_OR
+void ML_bmp_or(unsigned char *bmp, int x, int y, int width, int height)
+{
+	unsigned short line;
+	char shift, *screen, *p=(char*)&line;
+	int i, j, begin=0, end=height, real_width=(width-1>>3<<3)+8;
+	if(!bmp || x<0 || x>128-width || y<1-height || y>63 || width<1 || height<1) return;
+	if(y < 0) begin = -y;
+	if(y+height > 64) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		for(j=0 ; j<width-1>>3 ; j++)
+		{
+			line = bmp[i*(real_width>>3)+j]<<shift;
+			screen[j] |= *p;
+			if(shift!=8) screen[j+1] |= *(p+1);
+		}
+		line = (bmp[i*(real_width>>3)+j] & -1<<(real_width-width))<<shift;
+		screen[j] |= *p;
+		if(shift!=8 && x+real_width<129) screen[j+1] |= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_AND
+void ML_bmp_and(unsigned char *bmp, int x, int y, int width, int height)
+{
+	unsigned short line;
+	char shift, *screen, *p=(char*)&line;
+	int i, j, begin=0, end=height, real_width=(width-1>>3<<3)+8;
+	if(!bmp || x<0 || x>128-width || y<1-height || y>63 || width<1 || height<1) return;
+	if(y < 0) begin = -y;
+	if(y+height > 64) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		for(j=0 ; j<width-1>>3 ; j++)
+		{
+			line = ~((unsigned char)~bmp[i*(real_width>>3)+j]<<shift);
+			screen[j] &= *p;
+			if(shift!=8) screen[j+1] &= *(p+1);
+		}
+		line = ~((unsigned char)~(bmp[i*(real_width>>3)+j] | (unsigned char)-1>>8-(width&7))<<shift);
+		screen[j] &= *p;
+		if(shift!=8 && x+real_width<129) screen[j+1] &= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_XOR
+void ML_bmp_xor(unsigned char *bmp, int x, int y, int width, int height)
+{
+	unsigned short line;
+	char shift, *screen, *p=(char*)&line;
+	int i, j, begin=0, end=height, real_width=(width-1>>3<<3)+8;
+	if(!bmp || x<0 || x>128-width || y<1-height || y>63 || width<1 || height<1) return;
+	if(y < 0) begin = -y;
+	if(y+height > 64) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		for(j=0 ; j<width-1>>3 ; j++)
+		{
+			line = bmp[i*(real_width>>3)+j]<<shift;
+			screen[j] ^= *p;
+			if(shift!=8) screen[j+1] ^= *(p+1);
+		}
+		line = (bmp[i*(real_width>>3)+j] & -1<<(real_width-width))<<shift;
+		screen[j] ^= *p;
+		if(shift!=8 && x+real_width<129) screen[j+1] ^= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_OR_CL
+void ML_bmp_or_cl(unsigned char *bmp, int x, int y, int width, int height)
+{
+	unsigned short line;
+	char shift, *screen, *p;
+	int i, j, real_width, begin_x, end_x, begin_y, end_y;
+	char bool1=1, bool2=1, bool3;
+	if(!bmp || x<1-width || x>127 || y<1-height || y>63 || height<1 || width<1) return;
+	p = (char*)&line;
+	real_width = (width-1>>3<<3)+8;
+	if(y < 0) begin_y = -y;
+	else begin_y = 0;
+	if(y+height > 64) end_y = 64-y;
+	else end_y = height;
+	shift = 8-(x&7);
+	if(x<0)
+	{
+		begin_x = -x>>3;
+		if(shift != 8) bool1 = 0;
+	} else begin_x = 0;
+	if(x+real_width > 128) end_x = 15-(x>>3), bool2 = 0;
+	else end_x = real_width-1>>3;
+	bool3 = (end_x == real_width-1>>3);
+	screen = ML_vram_adress()+(y+begin_y<<4)+(x>>3);
+
+	for(i=begin_y ; i<end_y ; i++)
+	{
+		if(begin_x < end_x)
+		{
+			line = bmp[i*(real_width>>3)+begin_x] << shift;
+			if(bool1) screen[begin_x] |= *p;
+			if(shift!=8) screen[begin_x+1] |= *(p+1);
+			for(j=begin_x+1 ; j<end_x ; j++)
+			{
+				line = bmp[i*(real_width>>3)+j] << shift;
+				screen[j] |= *p;
+				if(shift!=8) screen[j+1] |= *(p+1);
+			}
+		}
+		line = bmp[i*(real_width>>3)+end_x];
+		if(bool3) line &= -1<<real_width-width;
+		line <<= shift;
+		if(begin_x < end_x || bool1) screen[end_x] |= *p;
+		if(bool2) screen[end_x+1] |= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_AND_CL
+void ML_bmp_and_cl(unsigned char *bmp, int x, int y, int width, int height)
+{
+	unsigned short line;
+	char shift, *screen, *p;
+	int i, j, real_width, begin_x, end_x, begin_y, end_y;
+	char bool1=1, bool2=1, bool3;
+	if(!bmp || x<1-width || x>127 || y<1-height || y>63 || height<1 || width<1) return;
+	p = (char*)&line;
+	real_width = (width-1>>3<<3)+8;
+	if(y < 0) begin_y = -y;
+	else begin_y = 0;
+	if(y+height > 64) end_y = 64-y;
+	else end_y = height;
+	shift = 8-(x&7);
+	if(x<0)
+	{
+		begin_x = -x>>3;
+		if(shift != 8) bool1 = 0;
+	} else begin_x = 0;
+	if(x+real_width > 128) end_x = 15-(x>>3), bool2 = 0;
+	else end_x = real_width-1>>3;
+	bool3 = (end_x == real_width-1>>3);
+	screen = ML_vram_adress()+(y+begin_y<<4)+(x>>3);
+
+	for(i=begin_y ; i<end_y ; i++)
+	{
+		if(begin_x < end_x)
+
+		{
+			line = ~((unsigned char)~bmp[i*(real_width>>3)+begin_x]<<shift);
+			if(bool1) screen[begin_x] &= *p;
+			if(shift!=8) screen[begin_x+1] &= *(p+1);
+			for(j=begin_x+1 ; j<end_x ; j++)
+			{
+				line = ~((unsigned char)~bmp[i*(real_width>>3)+j]<<shift);
+				screen[j] &= *p;
+				if(shift!=8) screen[j+1] &= *(p+1);
+			}
+		}
+		line = (unsigned char)~bmp[i*(real_width>>3)+end_x];
+		if(bool3) line &= -1<<real_width-width;
+		line = ~(line << shift);
+		if(begin_x < end_x || bool1) screen[end_x] &= *p;
+		if(bool2) screen[end_x+1] &= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_XOR_CL
+void ML_bmp_xor_cl(unsigned char *bmp, int x, int y, int width, int height)
+{
+	unsigned short line;
+	char shift, *screen, *p;
+	int i, j, real_width, begin_x, end_x, begin_y, end_y;
+	char bool1=1, bool2=1, bool3;
+	if(!bmp || x<1-width || x>127 || y<1-height || y>63 || height<1 || width<1) return;
+	p = (char*)&line;
+	real_width = (width-1>>3<<3)+8;
+	if(y < 0) begin_y = -y;
+	else begin_y = 0;
+	if(y+height > 64) end_y = 64-y;
+	else end_y = height;
+	shift = 8-(x&7);
+	if(x<0)
+	{
+		begin_x = -x>>3;
+		if(shift != 8) bool1 = 0;
+	} else begin_x = 0;
+	if(x+real_width > 128) end_x = 15-(x>>3), bool2 = 0;
+	else end_x = real_width-1>>3;
+	bool3 = (end_x == real_width-1>>3);
+	screen = ML_vram_adress()+(y+begin_y<<4)+(x>>3);
+
+	for(i=begin_y ; i<end_y ; i++)
+	{
+		if(begin_x < end_x)
+		{
+			line = bmp[i*(real_width>>3)+begin_x] << shift;
+			if(bool1) screen[begin_x] ^= *p;
+			if(shift!=8) screen[begin_x+1] ^= *(p+1);
+			for(j=begin_x+1 ; j<end_x ; j++)
+			{
+				line = bmp[i*(real_width>>3)+j] << shift;
+				screen[j] ^= *p;
+				if(shift!=8) screen[j+1] ^= *(p+1);
+			}
+		}
+		line = bmp[i*(real_width>>3)+end_x];
+		if(bool3) line &= -1<<real_width-width;
+		line <<= shift;
+		if(begin_x < end_x || bool1) screen[end_x] ^= *p;
+		if(bool2) screen[end_x+1] ^= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_8_OR
+void ML_bmp_8_or(unsigned char *bmp, int x, int y)
+{
+	unsigned short line;
+	char i, shift, begin=0, end=8, *screen, *p=(char*)&line;
+	if(!bmp || x<0 || x>120 || y<-7 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 56) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		screen[0] |= *p;
+		if(shift!=8) screen[1] |= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_8_AND
+void ML_bmp_8_and(unsigned char *bmp, int x, int y)
+{
+	unsigned short line;
+	char i, shift, begin=0, end=8, *screen, *p=(char*)&line;
+	if(!bmp || x<0 || x>120 || y<-7 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 56) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = ~((unsigned char)~bmp[i]<<shift);
+		screen[0] &= *p;
+		if(shift!=8) screen[1] &= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_8_XOR
+void ML_bmp_8_xor(unsigned char *bmp, int x, int y)
+{
+	unsigned short line;
+	char i, shift, begin=0, end=8, *screen, *p=(char*)&line;
+	if(!bmp || x<0 || x>120 || y<-7 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 56) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		screen[0] ^= *p;
+		if(shift<8) screen[1] ^= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_8_OR_CL
+void ML_bmp_8_or_cl(unsigned char *bmp, int x, int y)
+{
+	unsigned short line;
+	char i, shift, begin=0, end=8, bool1=1, bool2=1, *screen, *p=(char*)&line;
+	if(!bmp || x<-7 || x>127 || y<-7 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 56) end = 64-y;
+	shift = 8-(x&7);
+	if(x < 0) bool1 = 0;
+	if(x>120 || shift==8) bool2 = 0;
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		if(bool1) screen[0] |= *p;
+		if(bool2) screen[1] |= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_8_AND_CL
+void ML_bmp_8_and_cl(unsigned char *bmp, int x, int y)
+{
+	unsigned short line;
+	char i, shift, begin=0, end=8, bool1=1, bool2=1, *screen, *p=(char*)&line;
+	if(!bmp || x<-7 || x>127 || y<-7 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 56) end = 64-y;
+	shift = 8-(x&7);
+	if(x < 0) bool1 = 0;
+	if(x>120 || shift==8) bool2 = 0;
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = ~((unsigned char)~bmp[i]<<shift);
+		if(bool1) screen[0] &= *p;
+		if(bool2) screen[1] &= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_8_XOR_CL
+void ML_bmp_8_xor_cl(unsigned char *bmp, int x, int y)
+{
+	unsigned short line;
+	char i, shift, begin=0, end=8, bool1=1, bool2=1, *screen, *p=(char*)&line;
+	if(!bmp || x<-7 || x>127 || y<-7 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 56) end = 64-y;
+	shift = 8-(x&7);
+	if(x < 0) bool1 = 0;
+	if(x>120 || shift==8) bool2 = 0;
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		if(bool1) screen[0] ^= *p;
+		if(bool2) screen[1] ^= *(p+1);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_16_OR
+void ML_bmp_16_or(unsigned short *bmp, int x, int y)
+{
+	unsigned long line;
+	char i, shift, begin=0, end=16, *screen, *p=(char*)&line+1;
+	if(!bmp || x<0 || x>112 || y<-15 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 48) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		screen[0] |= *p;
+		screen[1] |= *(p+1);
+		if(shift!=8) screen[2] |= *(p+2);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_16_AND
+void ML_bmp_16_and(unsigned short *bmp, int x, int y)
+{
+	unsigned long line;
+	char i, shift, begin=0, end=16, *screen, *p=(char*)&line+1;
+	if(!bmp || x<0 || x>112 || y<-15 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 48) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = ~((unsigned short)~bmp[i]<<shift);
+		screen[0] &= *p;
+		screen[1] &= *(p+1);
+		if(shift!=8) screen[2] &= *(p+2);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_16_XOR
+void ML_bmp_16_xor(unsigned short *bmp, int x, int y)
+{
+	unsigned long line;
+	char i, shift, begin=0, end=16, *screen, *p=(char*)&line+1;
+	if(!bmp || x<0 || x>112 || y<-15 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 48) end = 64-y;
+	shift = 8-(x&7);
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		screen[0] ^= *p;
+		screen[1] ^= *(p+1);
+		if(shift!=8) screen[2] ^= *(p+2);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_16_OR_CL
+void ML_bmp_16_or_cl(unsigned short *bmp, int x, int y)
+{
+	unsigned long line;
+	char i, shift, begin=0, end=16, bool1=1, bool2=1, bool3=1, *screen, *p=(char*)&line+1;
+	if(!bmp || x<-15 || x>127 || y<-15 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 48) end = 64-y;
+	shift = 8-(x&7);
+	if(x < 0) bool1 = 0;
+	if(x<-8 || x>119) bool2 = 0;
+	if(x>111 || shift==8) bool3 = 0;
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		if(bool1) screen[0] |= *p;
+		if(bool2) screen[1] |= *(p+1);
+		if(bool3) screen[2] |= *(p+2);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_16_AND_CL
+void ML_bmp_16_and_cl(unsigned short *bmp, int x, int y)
+{
+	unsigned long line;
+	char i, shift, begin=0, end=16, bool1=1, bool2=1, bool3=1, *screen, *p=(char*)&line+1;
+	if(!bmp || x<-15 || x>127 || y<-15 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 48) end = 64-y;
+	shift = 8-(x&7);
+	if(x < 0) bool1 = 0;
+	if(x<-8 || x>119) bool2 = 0;
+	if(x>111 || shift==8) bool3 = 0;
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = ~((unsigned short)~bmp[i]<<shift);
+		if(bool1) screen[0] &= *p;
+		if(bool2) screen[1] &= *(p+1);
+		if(bool3) screen[2] &= *(p+2);
+		screen += 16;
+	}
+}
+#endif
+
+#ifdef ML_BMP_16_XOR_CL
+void ML_bmp_16_xor_cl(unsigned short *bmp, int x, int y)
+{
+	unsigned long line;
+	char i, shift, begin=0, end=16, bool1=1, bool2=1, bool3=1, *screen, *p=(char*)&line+1;
+	if(!bmp || x<-15 || x>127 || y<-15 || y>63) return;
+	if(y < 0) begin = -y;
+	if(y > 48) end = 64-y;
+	shift = 8-(x&7);
+	if(x < 0) bool1 = 0;
+	if(x<-8 || x>119) bool2 = 0;
+	if(x>111 || shift==8) bool3 = 0;
+	screen = ML_vram_adress()+(y+begin<<4)+(x>>3);
+	for(i=begin ; i<end ; i++)
+	{
+		line = bmp[i]<<shift;
+		if(bool1) screen[0] ^= *p;
+		if(bool2) screen[1] ^= *(p+1);
+		if(bool3) screen[2] ^= *(p+2);
+		screen += 16;
+	}
+}
+#endif
+

MonochromeLib.h

@@ -0,0 +1,149 @@
+/*************************************************************/
+/** MonochromeLib - monochrome graphic library for fx-9860G **/
+/** MonochromeLib is free software                          **/
+/**                                                         **/
+/** @author Pierre "PierrotLL" Le Gall                      **/
+/** @contact legallpierre89@gmail.com                       **/
+/**                                                         **/
+/** @file MonochromeLib.h                                   **/
+/** Include header for MonochromeLib                        **/
+/**                                                         **/
+/** @date 06-17-2011                                        **/
+/*************************************************************/
+
+#ifndef MONOCHROMELIB
+#define MONOCHROMELIB
+
+/****************************************************/
+/** uncomment #define of functions you want to use **/
+/****************************************************/
+
+//#define ML_ALL //Auto define all functions
+
+#define ML_CLEAR_VRAM
+#define ML_CLEAR_SCREEN
+#define ML_DISPLAY_VRAM
+
+#define ML_SET_CONTRAST
+//#define ML_GET_CONTRAST
+
+#define ML_PIXEL
+//#define ML_POINT
+//#define ML_PIXEL_TEST
+
+#define ML_LINE
+#define ML_HORIZONTAL_LINE
+#define ML_VERTICAL_LINE
+
+#define ML_RECTANGLE
+
+#define ML_POLYGONE
+#define ML_FILLED_POLYGONE
+
+#define ML_CIRCLE
+#define ML_FILLED_CIRCLE
+
+//#define ML_ELLIPSE
+//#define ML_ELLIPSE_IN_RECT
+//#define ML_FILLED_ELLIPSE
+//#define ML_FILLED_ELLIPSE_IN_RECT
+
+//#define ML_HORIZONTAL_SCROLL
+//#define ML_VERTICAL_SCROLL
+
+#define ML_BMP_OR
+//#define ML_BMP_AND
+//#define ML_BMP_XOR
+#define ML_BMP_OR_CL
+//#define ML_BMP_AND_CL
+//#define ML_BMP_XOR_CL
+
+//#define ML_BMP_8_OR
+//#define ML_BMP_8_AND
+//#define ML_BMP_8_XOR
+#define ML_BMP_8_OR_CL
+//#define ML_BMP_8_AND_CL
+//#define ML_BMP_8_XOR_CL
+
+//#define ML_BMP_16_OR
+//#define ML_BMP_16_AND
+//#define ML_BMP_16_XOR
+#define ML_BMP_16_OR_CL
+//#define ML_BMP_16_AND_CL
+//#define ML_BMP_16_XOR_CL
+
+
+
+/**************************/
+/** Functions prototypes **/
+/**************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONTRAST_MIN	130
+#define CONTRAST_NORMAL	168
+#define CONTRAST_MAX	190
+typedef enum {TRANSPARENT=-1, WHITE, BLACK, XOR, CHECKER} ML_Color;
+
+char* ML_vram_adress();
+
+void ML_clear_vram();
+void ML_clear_screen();
+void ML_display_vram();
+
+void ML_set_contrast(unsigned char contrast);
+unsigned char ML_get_contrast();
+
+void ML_pixel(int x, int y, ML_Color color);
+void ML_point(int x, int y, int width, ML_Color color);
+ML_Color ML_pixel_test(int x, int y);
+
+void ML_line(int x1, int y1, int x2, int y2, ML_Color color);
+void ML_horizontal_line(int y, int x1, int x2, ML_Color color);
+void ML_vertical_line(int x, int y1, int y2, ML_Color color);
+
+void ML_rectangle(int x1, int y1, int x2, int y2, int border_width, ML_Color border_color, ML_Color fill_color);
+
+void ML_polygone(int *x, int *y, int nb_vertices, ML_Color color);
+void ML_filled_polygone(int *x, int *y, int nb_vertices, ML_Color color);
+
+void ML_circle(int x, int y, int radius, ML_Color color);
+void ML_filled_circle(int x, int y, int radius, ML_Color color);
+
+void ML_ellipse(int x, int y, int radius1, int radius2, ML_Color color);
+void ML_ellipse_in_rect(int x1, int y1, int x2, int y2, ML_Color color);
+void ML_filled_ellipse(int x, int y, int radius1, int radius2, ML_Color color);
+void ML_filled_ellipse_in_rect(int x, int y, int radius1, int radius2, ML_Color color);
+
+void ML_horizontal_scroll(int scroll);
+void ML_vertical_scroll(int scroll);
+
+void ML_bmp_or(unsigned char *bmp, int x, int y, int width, int height);
+void ML_bmp_and(unsigned char *bmp, int x, int y, int width, int height);
+void ML_bmp_xor(unsigned char *bmp, int x, int y, int width, int height);
+void ML_bmp_or_cl(unsigned char *bmp, int x, int y, int width, int height);
+void ML_bmp_and_cl(unsigned char *bmp, int x, int y, int width, int height);
+void ML_bmp_xor_cl(unsigned char *bmp, int x, int y, int width, int height);
+
+void ML_bmp_8_or(unsigned char *bmp, int x, int y);
+void ML_bmp_8_and(unsigned char *bmp, int x, int y);
+void ML_bmp_8_xor(unsigned char *bmp, int x, int y);
+void ML_bmp_8_or_cl(unsigned char *bmp, int x, int y);
+void ML_bmp_8_and_cl(unsigned char *bmp, int x, int y);
+void ML_bmp_8_xor_cl(unsigned char *bmp, int x, int y);
+
+void ML_bmp_16_or(unsigned short *bmp, int x, int y);
+void ML_bmp_16_and(unsigned short *bmp, int x, int y);
+void ML_bmp_16_xor(unsigned short *bmp, int x, int y);
+void ML_bmp_16_or_cl(unsigned short *bmp, int x, int y);
+void ML_bmp_16_and_cl(unsigned short *bmp, int x, int y);
+void ML_bmp_16_xor_cl(unsigned short *bmp, int x, int y);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif //MONOCHROMELIB

README.md

@@ -1,4 +1,4 @@
-Super-Haxon-Casio
+Super-Hexagon-Casio
 =================
 
-Super-Haxon-Casio
+A port of Super Hexagon on Casio FX-9860G USB series.

Sources.def

@@ -0,0 +1,26 @@
+##########################################################################
+#	 Application Independent Definitions
+#	 This file is auto-generated by the SimSH simulator.
+#	 Do not change this file manually;
+#	 make the changes in the project file instead.
+##########################################################################
+
+##########################################################################
+#  Application
+
+#  File name of *.pva, *.abs, *.dbg files
+TARGET=hexagon
+
+#  PV Application Title (displayed in PV menu)
+TITLE="hexagon"
+
+#  Program version (ex 0100 -> 1.00)
+VERSION=0100
+
+#  Application sources
+FILE0=hexagon
+FILE1=ECode
+FILE2=MonochromeLib
+FILE3=syscall
+
+##########################################################################

hexagon.c

@@ -0,0 +1,171 @@
+#include "fxlib.h"
+#include "MonochromeLib.h"
+#include "math.h"
+#include "ECode.h"
+#include "stdlib.h"
+#include "struct.h"
+#include "wall.h"
+#include "syscall.h"
+
+#define FPS 60
+#define FRAME_TIME 1/FPS
+Line lines[6] = {{0, NULL, 0},{1, NULL, 60},{2, NULL, 120},{3, NULL, 180},{4, NULL, 240},{5, NULL, 300}};
+
+int player_angle=0;
+
+Camera cam = {64, 32, 0};
+
+Wall *list = NULL;
+
+float dAngle = 10;
+
+void drawPlayer();
+
+void drawDiagonal(int nb);
+
+int AddIn_main(int isAppli, unsigned short OptionNum)
+{
+    unsigned int fps = 0, frame = 0, tempsOrigine = RTC_GetTicks();
+    unsigned char fps_text[8] = {0};
+    srand(RTC_GetTicks());
+
+    //list = addWall(list, 128, 8, 1, 1);
+
+    while(KeyUp(K_EXIT)){
+        //fps
+        int current_frame_time = RTC_GetTicks();
+        if(RTC_GetTicks() - tempsOrigine >= 32 )//1/4 seconds
+        {
+            fps = frame*4;
+            frame = 0;
+            tempsOrigine = RTC_GetTicks();
+        }
+        frame++;
+
+        cam.angle = (int) (cam.angle + dAngle);
+        if(cam.angle >= 360)cam.angle = cam.angle - 359;
+        if(list != NULL){
+            update(list);
+            if(isColliding(list, player_angle) == true)
+            {
+                PrintMini(50, 0, "TOUCHE", MINI_OVER);
+            }
+            list = removeWall(list, 0);
+
+        }
+        if(rand() % 40 == 1)
+        {
+            list = addWall(list, 128, 8, 1, rand()%6);
+        }else if(rand() % 70 == 1)
+        {
+            int emptyRow = rand()%6;
+            int i = 0;
+            for(i = 0; i < 6; i++)
+                if(i != emptyRow)
+                    list = addWall(list, 128, 15, 1, i);
+        }
+        drawPlayer();
+        drawDiagonal(1);
+        drawDiagonal(2);
+        drawDiagonal(3);
+        intToStr(fps_text, fps);
+        PrintMini(0, 0, fps_text, MINI_OVER);
+        intToStr(fps_text, player_angle);
+        PrintMini(116, 0, fps_text, MINI_OVER);
+        if(list != NULL)
+            show(list, &cam);
+    
+        ML_display_vram();
+        ML_clear_vram();
+        if(KeyDown(K_LEFT))
+        {
+            player_angle-=15;
+        }
+        if(KeyDown(K_RIGHT))
+        {
+            player_angle+=15;
+        }
+        if(KeyDown(K_PLUS))
+        {
+            dAngle += 0.2;
+        }
+        if(KeyDown(K_MINUS))
+        {
+            dAngle -= 0.2;
+        }
+        if(player_angle < 0)
+            player_angle = 360 + player_angle;
+        player_angle = player_angle % 360;
+
+        if(player_angle > 360)
+        {
+            while(KeyUp(K_EXE))
+            {}
+        }
+        //while
+        Sleep(1/0.06);
+    }
+
+    return 1;
+}
+
+void drawPlayer()
+{
+    int x[6];
+    int y[6];
+    int i = 0;
+
+    for(i = 0; i++; i != 6)
+    {
+        int angle = i *60;
+        x[i] = 16*cos(PI*angle/180) + cam.cX;
+        y[i] = 16*sin(PI*angle/180) + cam.cY;
+    }
+    ML_filled_circle(cam.cX, cam.cY, 6, BLACK);
+    ML_filled_circle(9*cos( PI*(player_angle + cam.angle)/180) + cam.cX, 9*sin( PI*(player_angle+cam.angle)/180) + cam.cY, 1, BLACK);
+    
+}
+
+void drawDiagonal(int nb)
+{
+    int tmp_angle = 0;
+    float coeff = 0;
+    int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+
+    if(nb == 1)
+        tmp_angle = cam.angle + 60;
+    else if(nb == 2)
+        tmp_angle = cam.angle;
+    else if(nb == 3)
+        tmp_angle = 300 + cam.angle;
+    if(tmp_angle >= 360)tmp_angle = tmp_angle - 359;
+
+
+    coeff = sin(PI*tmp_angle / 180)/cos(PI * tmp_angle / 180);
+
+    x1 = -32/coeff;
+    y1 = -32;
+
+    x2 = 32/coeff;
+    y2 = 32;
+
+    if(abs(x1) > 64){
+        x1 = -64;
+        y1 = -64*coeff;
+
+        x2 = 64;
+        y2 = 64*coeff;
+    }
+        ML_line(x1 + cam.cX, y1 + cam.cY, x2 + cam.cX, y2 + cam.cY, BLACK);
+}
+
+#pragma section _BR_Size
+unsigned long BR_Size;
+#pragma section
+#pragma section _TOP
+int InitializeSystem(int isAppli, unsigned short OptionNum)
+{
+    return INIT_ADDIN_APPLICATION(isAppli, OptionNum);
+}
+#pragma section
+

hexagon.dlr

@@ -0,0 +1,149 @@
+[DLSimRunSpace]
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=45
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=25
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=29
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=29
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=31
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\MonochromeLib.c
+Line=265
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\MonochromeLib.c
+Line=281
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\MonochromeLib.c
+Line=276
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\MonochromeLib.c
+Line=276
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\MonochromeLib.c
+Line=261
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=25
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=45
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=31
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=40
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=119
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=121
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=112
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\hexagon.c
+Line=40
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=172
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=119
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=172
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=175
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=165
+Flags=00001012
+Sublevel=1
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=165
+Flags=00001012
+Sublevel=2
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=177
+Flags=00001012
+
+[Breakpoint]
+File=Z:\home\adrien\Code\C\Casio\hexagon\wall.c
+Line=164
+Flags=00001012

hexagon.dlw

@@ -0,0 +1,149 @@
+[DLSimWorkSpace]
+
+[_1]
+Type=5
+Order=0
+Top=495
+Left=1485
+Height=4740
+Width=5565
+State=0
+Flags=00000020
+Setting=297:1:MonochromeLib.c
+OptionA=0
+
+[_2]
+Type=1
+Order=1
+Top=150
+Left=10950
+Height=4740
+Width=5535
+State=0
+Flags=00000001
+OptionA=15
+OptionB=15
+
+[_3]
+Type=6
+Order=7
+Top=4740
+Left=7800
+Height=6390
+Width=5535
+State=0
+Flags=00000001
+OptionA=0
+
+[_4]
+Type=7
+Order=9
+Top=5280
+Left=13980
+Height=3165
+Width=5565
+State=16
+Flags=00000000
+OptionA=0
+
+[_5]
+Type=8
+Order=6
+Top=5535
+Left=2595
+Height=3225
+Width=5580
+State=0
+Flags=00000000
+OptionA=0
+
+[_6]
+Type=3
+Order=12
+Top=0
+Left=10788
+Height=6348
+Width=2232
+State=16
+Flags=00000000
+OptionA=0
+
+[_7]
+Type=2
+Order=11
+Top=6348
+Left=7800
+Height=3588
+Width=5220
+State=16
+Flags=00000000
+OptionA=0
+
+[_8]
+Type=17
+Order=4
+Top=15
+Left=-15
+Height=11115
+Width=2235
+State=0
+Flags=00000000
+OptionA=0
+
+[_9]
+Type=15
+Order=2
+Top=30
+Left=2130
+Height=6915
+Width=9915
+State=0
+Flags=00000000
+OptionA=0
+
+[_10]
+Type=14
+Order=8
+Top=1320
+Left=1320
+Height=6810
+Width=16890
+State=16
+Flags=00000020
+OptionA=0
+
+[_32]
+Type=16
+Order=10
+Top=2940
+Left=2370
+Height=4590
+Width=5595
+State=16
+Flags=00000020
+Setting=41:1:hexagon.c
+OptionA=0
+
+[_33]
+Type=16
+Order=5
+Top=2970
+Left=2970
+Height=3000
+Width=3915
+State=1
+Flags=00000020
+Setting=1:1:MonochromeLib.c
+OptionA=0
+
+[_34]
+Type=16
+Order=3
+Top=3600
+Left=5985
+Height=6885
+Width=17190
+State=0
+Flags=00000020
+Setting=166:1:wall.c
+OptionA=0

hexagon.g1w

@@ -0,0 +1,19 @@
+[DLSimProject]
+Name=hexagon
+Version=1.00.0000
+Model=:fx-9860G.dlm
+SourcePath=SRC
+MemoryPath=INIT
+MemCardPath=SDCard
+
+[Program1]
+Program=HEXAGON.G1A
+Debug=Debug\FXADDINror.dbg
+LoadAddress=80000000:90100000
+
+[Files]
+SourceFile=:hexagon.c
+SourceFile=:ECode.c
+SourceFile=:MonochromeLib.c
+SourceFile=:syscall.src
+SourceFile=:wall.c

struct.h

@@ -0,0 +1,36 @@
+#ifndef STRUCT_H
+#define STRUCT_H
+
+#define PI 3.14159265
+#define SIN_60 0.866025404
+#define COS_60 0.5
+#define abs(x) x>0 ? x : -x
+#define true 1
+#define false 0
+#define bool unsigned char
+
+typedef struct Camera Camera;
+typedef struct Wall Wall;
+typedef struct Line Line;
+
+struct Camera{
+    int cX;
+    int cY;
+    int angle;
+};
+
+struct Wall{
+    int d;
+    int h;
+    int id;
+    int line;
+
+    Wall *nxt;
+};
+
+struct Line{
+    int id;
+    Wall *list;
+    int angle;
+};
+#endif

syscall.h

@@ -0,0 +1,24 @@
+#ifndef _SERIAL
+#define _SERIAL
+
+int Serial_ReadByte(unsigned char *dest);
+int Serial_ReadBytes(unsigned char *dest, int max, short *size);
+int Serial_WriteByte(unsigned char byte);
+int Serial_WriteBytes(unsigned char *src, int size);
+int Serial_WriteByteFIFO(unsigned char byte);
+int Serial_GetRxBufferSize(void);
+int Serial_GetTxBufferFreeCapacity(void);
+int Serial_ClearReceiveBuffer(void);
+int Serial_ClearTransmitBuffer(void);
+int Serial_Open(unsigned char *conf);
+int Serial_Close(int mode);
+int Serial_Peek(int index, unsigned char *dest);
+int Serial_IsOpen(void);
+void RebootOS();
+int memcopy();
+char* VRam_Base();
+
+int RTC_GetTicks();
+
+#endif
+

syscall.src

@@ -0,0 +1,31 @@
+	.SECTION P,CODE,ALIGN=4
+
+	.MACRO SYSCALL FUNO, SYSCALLNAME, TAIL=nop
+	.export \SYSCALLNAME'
+\SYSCALLNAME'
+	mov.l #h'\FUNO, r0
+	mov.l #H'80010070, r2
+	jmp @r2
+	\TAIL'
+	.ENDM
+
+	SYSCALL 040C,	_Serial_ReadByte
+	SYSCALL 040D,	_Serial_ReadBytes
+	SYSCALL 040E,	_Serial_WriteByte
+	SYSCALL 040F,	_Serial_WriteBytes
+	SYSCALL 0410,	_Serial_WriteByteFIFO
+	SYSCALL 0411,	_Serial_GetRxBufferSize
+	SYSCALL 0412,	_Serial_GetTxBufferFreeCapacity
+	SYSCALL 0413,	_Serial_ClearReceiveBuffer
+	SYSCALL 0414,	_Serial_ClearTransmitBuffer
+	SYSCALL 0418,	_Serial_Open
+	SYSCALL 0419,	_Serial_Close
+	SYSCALL 0422,	_Serial_Peek
+	SYSCALL 0425,	_Serial_IsOpen
+	SYSCALL 0236,	_RebootOS
+	SYSCALL 0ACF,	_memcopy
+	SYSCALL 003B,	_RTC_GetTicks
+
+	SYSCALL 0135,	_VRam_Base
+
+	.end

wall.c

@@ -0,0 +1,208 @@
+#include "wall.h"
+
+Wall *addWall(Wall *list, int d, int h, int id, int line)
+{
+	Wall *tmp;
+	Wall *new;
+	tmp = list;		 
+
+	new = malloc(sizeof(Wall));
+	new->d = d;
+	new->h = h;
+	new->id = id;
+	new->line = line;
+	new->nxt = NULL;
+
+	if(list == NULL)		
+		return new;
+	else if(list != NULL)
+	{
+		while (tmp->nxt != NULL){
+			tmp = tmp->nxt;
+		}
+		tmp->nxt = new;
+		return list;
+	}
+
+}
+
+Wall *removeWall(Wall *list, int id)
+{
+	Wall *tmp1;
+	Wall *tmp2;
+
+	if(list->d <= 0)
+	{
+		if(list->nxt != NULL)
+			tmp1 = list->nxt;
+		else
+			tmp1 = NULL;
+		free(list);
+		return tmp1;
+	}
+	tmp1 = list;
+	do{
+		if(tmp1->nxt != NULL)
+		{
+			if(tmp1->nxt->d <= 0)
+			{
+				tmp2 = tmp1->nxt;
+				if(tmp1->nxt->nxt != NULL)
+					tmp1->nxt = tmp1->nxt->nxt;
+				else
+					tmp1->nxt = NULL;
+				free(tmp2);
+			}
+		}
+		tmp1 = tmp1->nxt;
+	}while(tmp1 != NULL);
+	return list;
+}
+
+void update(Wall *list)
+{
+	Wall *tmp;
+	tmp = list;
+
+	do{
+		if(tmp != NULL)
+		{
+			tmp->d-=1;
+		}
+		tmp = tmp->nxt;
+	}while(tmp != NULL);
+}
+
+int getSlopeIndex(int dot1, int dot2)
+{
+	if(dot2 - dot1 == 1)
+	{
+		return dot1;
+	}else if(dot2 - dot1 == -1){
+		return dot2;
+	}else return 3;
+}
+void show(Wall *list, Camera *cam)
+{
+	/*
+
+	0________________1
+	/        0       \
+  3/                  \1
+  /                    \
+3/______________________\2
+ 			2
+
+ 	*/
+	Wall *tmp;
+	tmp = list;
+	do{
+		if(tmp != NULL)
+		{
+			if(tmp->d + tmp->h< 64)
+			{
+				const float angle = PI * ((tmp->line)*60 +cam->angle) / 180;
+				const float cos1 = cos(angle);
+				const float cos2 = cos(angle + PI/3);
+				const float sin1 = sin(angle);
+				const float sin2 = sin(angle + PI/3);
+				int x[4];
+				int y[4];
+				float slopes[4];
+				int i = 0;
+				int j = 0;
+
+					int tmpInt = 0;
+					int x1=0, x2 = 0;
+					//finding the two active edges
+					int leftDotIndex = 0, rightDotIndex = 0, leftSlope=0, rightSlope=0;
+
+				x[0]=tmp->d * cos1 + 64;
+				x[1]=tmp->d * cos2 + 64;
+				x[2]= (tmp->h + tmp->d) * cos2 + 64;
+				x[3]=(tmp->h + tmp->d) * cos1 + 64;
+
+				y[0]=tmp->d * sin1 + 32;
+				y[1]=tmp->d * sin2 + 32;
+				y[2]= (tmp->h + tmp->d) * sin2 + 32;
+				y[3]=(tmp->h + tmp->d) * sin1 + 32;
+
+				/*slopes[0] = (y[1] - y[0])/(x[1]-x[0]);
+				slopes[1] = (y[2] - y[1])/(x[2]-x[1]);
+				slopes[2] = (y[3] - y[2])/(x[3]-x[2]);
+				slopes[3] = (y[0] - y[3])/(x[0]-x[3]);*/
+				/*for(i = 0; i < tmp->h; i+=0.5)
+				{
+					ML_line((tmp->d + i) * cos2 + 64, (tmp->d + i) * sin2 + 32, (tmp->d + i) * cos1 + 64, (tmp->d + i) * sin1 + 32, BLACK);
+				}*/
+
+
+/*					i = y[0];
+					j = y[0];
+
+					for(i = 0; i < 4; i++)
+						if(y[tmpInt] > y[i])
+							tmpInt = i;
+					i = tmpInt;
+					tmpInt = 0;
+					for(j = 0; j < 4; j++)
+						if(y[tmpInt] < y[j])
+							tmpInt = j;
+					j = tmpInt;
+					x1 = x[i];
+					x2 = x[i];
+
+					//i contains an index to the highest vertex and j the lowest
+					tmpInt = 0;
+					for(leftDotIndex = 0; leftDotIndex < 4; leftDotIndex ++)
+					{
+						if(leftDotIndex != i && leftDotIndex != j && (tmpInt == 0 || tmpInt > x[leftDotIndex]))
+							tmpInt = x[leftDotIndex];
+					}
+					for(rightDotIndex = 0; rightDotIndex == i || rightDotIndex == j || rightDotIndex == leftDotIndex; rightDotIndex ++)
+					{}						
+					
+					tmpInt = i;
+					while(i <= j)
+					{
+						//getting the active slopes' indexes
+						if(y[i] < y[leftDotIndex])
+							leftSlope = getSlopeIndex(i, leftDotIndex);
+						else leftSlope = getSlopeIndex(leftDotIndex, j);
+						if(y[i] < y[rightDotIndex])
+							rightSlope = getSlopeIndex(i, rightDotIndex);
+						else rightSlope = getSlopeIndex(rightDotIndex, j);
+
+						ML_horizontal_line(y[tmpInt] + i, x1, x2, BLACK);
+						ML_horizontal_line(y[tmpInt] + i, x2, x1, BLACK);
+						x1 = x1 - (1/slopes[leftSlope]);
+						x2 = x2 - (1/slopes[rightSlope]);
+						i++;
+					}*/
+				ML_filled_polygone(x, y, 4, BLACK);
+			}
+		}
+		tmp = tmp->nxt;
+	}while(tmp != NULL);
+}
+
+bool isColliding(Wall *list, int player_angle)
+{
+	Wall *tmp;
+	tmp = list;
+
+	do{
+		if(tmp != NULL)
+		{
+			if(tmp-> d <= 8)
+			{
+				if(tmp->line == (int)(player_angle/60)) //&& tmp->line * 60 + 60 > player_angle)
+				{
+					return true;
+				}
+			}
+		}
+		tmp = tmp->nxt;
+	}while(tmp != NULL);
+	return false;
+}

wall.h

@@ -0,0 +1,13 @@
+#ifndef WALL_H
+#define WALL_H
+
+#include "stdlib.h"
+#include "struct.h"
+#include "MonochromeLib.h"
+#include "math.h"
+Wall *addWall(Wall *list, int d, int h, int id, int line);//returns a new pointer to the first element
+Wall *removeWall(Wall *list, int id); //returns a new pointer to the first element
+void show(Wall *list, Camera *cam);
+void update(Wall *list);
+bool isColliding(Wall *list, int player_angle);
+#endif