git » fp-git.git » commit 59760f5

diff --git a/FP/src/include/map_defs.h b/FP/src/include/map_defs.h
index 3966701..77b1793 100644
--- a/FP/src/include/map_defs.h
+++ b/FP/src/include/map_defs.h
@@ -42,9 +42,7 @@ Len	Offs	BlockName & Description
 
 #define MAPS_MAX_SCREENS    24
 #define MAPS_MAX_LENGTH     49
-//MAPS_MAX_SCREENS*2+1
 #define MAPS_LINKMAP_CENTER 24
-//(char)(MAPS_MAX_SCREENS*2+1)/2
 
 #define MAPS_DIRECTION_RIGHT 0x00
 #define MAPS_DIRECTION_LEFT  0xFF
@@ -79,7 +77,6 @@ Len	Offs	BlockName & Description
 #define MAPS_BLOCK_OFFSET_UNKNOWN_7         2288
 #define MAPS_BLOCK_SIZEOF_GATE_1            18
 #define MAPS_BLOCK_SIZEOF_GATE              18
-//256
 #define MAPS_BLOCK_OFFSET_GATE_1            1441
 #define MAPS_BLOCK_SIZEOF_GATE_2            18
 #define MAPS_BLOCK_OFFSET_GATE_2            1697
@@ -87,15 +84,15 @@ Len	Offs	BlockName & Description
 
 
 
-//Constantes copadas
+/* Constantes copadas */
 #define MAPS_sUp			2
 #define MAPS_sDown		3
 #define MAPS_sLeft		0
 #define MAPS_sRight		1
 
-//Definicion de cosas:
+/* Definicion de cosas: */
 
-//WALLS
+/* WALLS */
 #define MAPS_OBJ_ANT_1 0x13
 #define MAPS_OBJ_ANT_2 0x33
 #define MAPS_OBJ_BAL_1 0x01
@@ -130,7 +127,7 @@ Len	Offs	BlockName & Description
 #define MAPS_OBJ_VEN_L 0x37
 #define MAPS_OBJ_VEN_R 0x38
 
-//BACKS
+/* BACKS */
 #define MAPS_BCK_VEN_R 0x00
 #define MAPS_BCK_BRK_1 0x01
 #define MAPS_BCK_BRK_2 0x02
diff --git a/FP/src/include/output.h b/FP/src/include/output.h
index 07455d0..2ace89b 100644
--- a/FP/src/include/output.h
+++ b/FP/src/include/output.h
@@ -38,6 +38,8 @@ resources.h: Free Prince : Output Devices Handler
 #ifndef _OUTPUT_H_
 #define _OUTPUT_H_
 
+#include <SDL/SDL.h>	/* SDL stuff */
+
 /* Text Primitives*/
 void outputDrawText(const char* text, int x, int y);
 void outputDrawMessage(const char* text); 
@@ -59,19 +61,19 @@ void outputFreeBitmap(void* image);
 	*/
 
  /* Graph: Primitives for the kernel */
-void outputDrawBitmap(void* image,int x, int y);
+void outputDrawBitmap(SDL_Surface *screen, void* image,int x, int y);
  /* Draws an abstract image
 	*/
 
-void outputClearScreen();
+void outputClearScreen(SDL_Surface *screen);
  /* Crears the screen
 	*/
 
 /* Initialization */
-void outputInit();
+SDL_Surface *outputInit();
 /* This function must be called before starting using the output functions
- * it will initialize the screen and the output module
- */
+ * it will initialize the screen and the output module. Returns a pointer
+ * to the initialized screen, or NULL if an error occurs. */
 
 void outputStop();
 /* Finish all output modes, including the screen mode
diff --git a/FP/src/include/resources.h b/FP/src/include/resources.h
index 9a4298e..8aa6759 100644
--- a/FP/src/include/resources.h
+++ b/FP/src/include/resources.h
@@ -35,19 +35,6 @@ resources.h: Free Prince : Resource Handler
 
 #include "config.h"
 
-//int resOpenFile(const char* file); 
-	/* Opens file, loads the data into memory, closes the file and
-	 * returns an ID number (data descriptor) for the new structure. */
-//resCloseFile(int dd); /* dd = data descriptor */
-	/* Frees the data from memory. */
-//resCloseAllFiles();
-
-/* Functions for getting data previously loaded into memory. Each dd points
- * to an array of elements, and resId indicates the index in this array. */
-//tMidi resGetMidi(int dd, int resId);
-//tWave resGetWave(int dd, int resId);
-//tImage resGetImage(int dd, int resId);
-
 typedef enum {eImages=2,eWave,eMidi,eLevels}tDataType;
 
 #define MAX_FILENAME_SIZE        260
diff --git a/FP/src/ker/kernel.c b/FP/src/ker/kernel.c
index 113256c..fc15541 100644
--- a/FP/src/ker/kernel.c
+++ b/FP/src/ker/kernel.c
@@ -30,6 +30,7 @@ resources.h: Princed Resources : Resource Handler headers
   DO NOT remove this copyright notice
 */
 
+#include <SDL/SDL.h>
 #include "kernel.h"
 #include "resources.h"
 #include "output.h"
@@ -38,33 +39,41 @@ int kernel(int optionflag,int level) {
 /* levels=-1 is default
  * levels from 0 to n is the level number
  *  
- * optionflag may be read using hasFlag(name_flag); Note that the variable must be called optionflag
+ * optionflag may be read using hasFlag(name_flag); Note that the variable
+ * must be called optionflag
  */
 	
 	tData* testResource;
+	SDL_Surface *screen;
 	int i;
 	
-	outputInit();
-	printf("Hello, I'm a dummy kernel, I was called to do the stuff\nwith '%x' options and go to the level '%d'\n",optionflag,level);
-	testResource=resLoad(RES_ANIM_RUN_LEFT);	
-	
-	/* How to use a resource */
+	screen = outputInit();
+
+	if (!screen) {
+		fprintf(stderr, "Unable to initialize screen: %s\n", SDL_GetError());
+		exit(1);
+	}
+
+	testResource=resLoad(RES_ANIM_RUN_LEFT);
 	if (!testResource) {
 		printf("The resource couldn't be loaded!\n");
 		exit(1);
 	}
-	
+
 	printf("Resource number: %d. Frames: %d. Type: %d.\n",
 		RES_ANIM_RUN_LEFT,
 		testResource->frames,
 		testResource->type
 	);
-	
+
 	for (i=0;i<testResource->frames;i++) {
 		printf("frame %d\n",i);
-		outputDrawBitmap(testResource->pFrames[i],3,3);
+		outputDrawBitmap(screen, testResource->pFrames[i], 3, 3);
+		SDL_UpdateRect(screen, 0, 0, 320, 200);
+		outputClearScreen(screen);
+		getchar();
 	}
-	
+
 	outputStop();
 	return 0;
 }
diff --git a/FP/src/main.c b/FP/src/main.c
index b21a666..e7cf985 100644
--- a/FP/src/main.c
+++ b/FP/src/main.c
@@ -36,6 +36,7 @@ main.c: FreePrince : Main function - parsing
 #include "kernel.h"
 #include "main.h"
 #include <stdio.h>
+#include <stdlib.h> /* atoi */
 
 /***************************************************************\
 |      Standard executable command line parsing function        |
diff --git a/FP/src/out/output.c b/FP/src/out/output.c
index 2ca3bf3..ac5497f 100644
--- a/FP/src/out/output.c
+++ b/FP/src/out/output.c
@@ -19,7 +19,7 @@
 */
 
 /*
-resources.h: Free Prince : Output Devices Handler
+resources.c: Free Prince : Output Devices Handler
 \xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf
 
  Description: 
@@ -35,11 +35,9 @@ resources.h: Free Prince : Output Devices Handler
   DO NOT remove this copyright notice
 */
 
-#ifndef _OUTPUT_H_
-#define _OUTPUT_H_
-
-#include "resources.h" /* tMemory structure */
 #include <stdlib.h> /* malloc */
+#include "resources.h" /* tMemory structure */
+#include "output.h" /* tMemory structure */
 
 /* Text Primitives*/
 void outputDrawText(const char* text, int x, int y) {}
@@ -49,35 +47,84 @@ void outputDrawMessage(const char* text) {}
 void outputPlayWav(tMemory sound) {} /* Starts the reproduction of the sample and returns */
 void outputPlayMid(tMemory music) {} /* Starts the music reproduction and returns */
 
-/* Graph */
+/* Graphics */
+
+void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
+/* Set the pixel at (x, y) to the given value
+ * NOTE: The surface must be locked before calling this!*/
+{
+	int bpp = surface->format->BytesPerPixel;
+				/* Here p is the address to the pixel we want to set */
+	Uint8 *p = (Uint8 *) surface->pixels + y * surface->pitch + x * bpp;
+
+	switch (bpp) {
+	case 1:
+		*p = pixel;
+		break;
+
+	case 2:
+		*(Uint16 *) p = pixel;
+		break;
+
+	case 3:
+		if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+		p[0] = (pixel >> 16) & 0xff;
+		p[1] = (pixel >> 8) & 0xff;
+		p[2] = pixel & 0xff;
+		} else {
+		p[0] = pixel & 0xff;
+		p[1] = (pixel >> 8) & 0xff;
+		p[2] = (pixel >> 16) & 0xff;
+		}
+		break;
 
-/* Define a dummy private structure */
-typedef struct {
-	char* picture;
-	unsigned char palette[3*16];
-	int h,w;
-}SDL_very_cool_structure;
+	case 4:
+		*(Uint32 *) p = pixel;
+		break;
+	}
+}
 
 
- /* Graph: Primitives for resources module */
-void* outputLoadBitmap(const unsigned char* data, int size, const unsigned char* palette, int h,int w,int invert, int firstColorTransparent) {
- /* Returns an abstract object allocated in memory using the data information ti build it
-	* invert is 0 when no invertion is needed and non-zero when an inversion is performed
-	*/
+/* Graphics: Primitives for resources module */
+void* outputLoadBitmap(const unsigned char* data, int size, 
+		const unsigned char* palette, int h, int w, int invert, 
+		int firstColorTransparent) {
+ /* Returns an abstract object allocated in memory using the data 
+  * information ti build it invert is 0 when no invertion is needed and 
+  * non-zero when an inversion is performed	*/
 
 	/* Dummy function */
-	SDL_very_cool_structure* result;
-	static char printed[]=" *+@#$%&=|SVHG/OP";
+	SDL_Surface* result;
 	int i,j;
-	
-	result=(SDL_very_cool_structure*)malloc(sizeof(SDL_very_cool_structure));
-	
+	Uint32 rmask, gmask, bmask, amask;
+
 	printf("outputLoadBitmap: I'm creating an SDL structure :p\n");
-	printf("outputLoadBitmap: invert=%d. transparent=%d. size=%d\n",invert,firstColorTransparent,size);
+	printf("outputLoadBitmap: invert=%d. transparent=%d. size=%d\n",
+			invert, firstColorTransparent, size);
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+	rmask = 0xff000000;
+	gmask = 0x00ff0000;
+	bmask = 0x0000ff00;
+	amask = 0x000000ff;
+#else
+	rmask = 0x000000ff;
+	gmask = 0x0000ff00;
+	bmask = 0x00ff0000;
+	amask = 0xff000000;
+#endif
 
+	result = SDL_CreateRGBSurface(0, w, h, 8, rmask, gmask, bmask, amask);
+	if (!result)
+	{
+		fprintf(stderr, "CreateRGBSurface failed: %s\n", SDL_GetError());
+		exit(1);
+	}
+	
 	/* Notes:
 	 * - the image is serialized
-	 *    this means that the last bits in the row to complete a full byte are garbage
+	 *    this means that the last bits in the row to complete a full byte
+	 *    are garbage
 	 * - there are 2 types of images:
 	 *    1 bit/pixel (b/w)
 	 *    4 bit/pixel (16 cols)
@@ -87,19 +134,28 @@ void* outputLoadBitmap(const unsigned char* data, int size, const unsigned char*
 	 *    we have to add 1 because of the serialization
 	 *    division by 2 is because 4bpp are 2 pixel/byte (0.5 byte/pixel)
 	 */
-	w=(w+1)/2;
-	result->picture=malloc(h*w*4+10);
-	result->w=w;
-	result->h=h;
-					
-	for (i=0,j=0;i<h*w;i++) { /* transform a 4 bpp array into an ASCII draw 16 bpp*/
-		result->picture[j++]=printed[data[i]>>4];
-		result->picture[j++]=printed[data[i]>>4];
-		result->picture[j++]=printed[data[i]&0x0f];
-		result->picture[j++]=printed[data[i]&0x0f];
+	w = (w + 1) / 2;
+
+	/* Lock the screen for direct access to the pixels */
+	if (SDL_MUSTLOCK(result)) {
+		if (SDL_LockSurface(result) < 0) {
+			fprintf(stderr, "Can't lock surface: %s\n", SDL_GetError());
+			exit(1);
+		}
+	}
+
+	for (i = 0; i < w; i++) {
+		for (j = 0; j < h; j++) {
+			putpixel(result, i, j, 
+					SDL_MapRGB(result->format, 0xff, 0xff, 0x00));
+		}
 	}
 	
-	memcpy(result->palette,palette,3*16); /* copy palette */
+	if (SDL_MUSTLOCK(result)) {
+		SDL_UnlockSurface(result);
+	}
+
+/*	memcpy(result->palette, palette, 3 * 16); * copy palette */
 
 	return (void*)result;
 }
@@ -108,56 +164,29 @@ void outputFreeBitmap(void* image) {}
  /* Frees the abstract object created by the loadBitmap function
 	*/
 
- /* Graph: Primitives for the kernel */
-void outputDrawBitmap(void* image,int x, int y) {
- /* Draws an abstract image
-	*/
-
-#define myImage ((SDL_very_cool_structure*)image)
-				
-	int h,w,i,j;		
-	w=myImage->w*4;
-	h=myImage->h;
-	
-	/* Draw image */
-	for (i=0;i<y;i++) printf("\n");
-	for (i=0;i<h;i++) {
-		for (j=0;j<x;j++) printf(" ");
-		for (j=0;j<w;j++) {
-			printf("%c",
-				myImage->picture[i*w+j]
-			);
-		}
-		printf("\n");
-	}
-	
-	/* show palette */
-	for (i=0;i<16;i++) {
-		printf("rgb[%d]=(%d,%d,%d) #%02x%02x%02x\n",
-			i+1,
-			myImage->palette[3*i],
-			myImage->palette[3*i+1],
-			myImage->palette[3*i+2],
-			(myImage->palette[3*i])<<2,
-			(myImage->palette[3*i+1])<<2,
-			(myImage->palette[3*i+2])<<2
-		);
-	}
-
+/* Graphics: Primitives for the kernel */
+void outputDrawBitmap(SDL_Surface *screen, void* image, int x, int y) {
+/* Draws an abstract image */
+	SDL_Surface *s = (SDL_Surface *)image;
+	/* SDL_Rect destrect = {x, y, s->w, s->h};*/ 
+	SDL_BlitSurface(s, NULL, screen, NULL);
 }
 
-void outputClearScreen() {}
- /* Crears the screen
-	*/
+void outputClearScreen(SDL_Surface *screen) {
+}
 
 /* Initialization */
-void outputInit() {}
-/* This function must be called before starting using the output functions
- * it will initialize the screen and the output module
- */
+SDL_Surface *outputInit() 
+{
+	SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO);
+	atexit(outputStop);
+	return SDL_SetVideoMode(320, 200, 8, 0);
+}
 
-void outputStop() {}
+void outputStop()
 /* Finish all output modes, including the screen mode
  */
+{
+	SDL_Quit();
+}
 
-#endif
diff --git a/FP/src/res/compress.c b/FP/src/res/compress.c
index 4f45131..916659c 100644
--- a/FP/src/res/compress.c
+++ b/FP/src/res/compress.c
@@ -36,7 +36,7 @@ compress.c: Princed Resources : Image Compression Library
 #include <string.h>
 #include "compress.h"
 #include "memory.h"
-//#include "pr.h"
+/*#include "pr.h"*/
 #include "disk.h" /* array2short */
 
 /***************************************************************\
@@ -215,9 +215,9 @@ int mExpandGraphic(const unsigned char* data,tImage *image, int dataSizeInBytes)
 	int result;
 
 	data++;
-	image->height=array2short(data);//((unsigned char)data[0])+((unsigned char)data[1]<<8);data+=2;
+	image->height=array2short(data);/*((unsigned char)data[0])+((unsigned char)data[1]<<8);data+=2;*/
 	data+=2;
-	image->width =array2short(data);//((unsigned char)data[0])+((unsigned char)data[1]<<8);data+=2;
+	image->width =array2short(data);/*((unsigned char)data[0])+((unsigned char)data[1]<<8);data+=2;*/
 	data+=2;
 
 	if (*(data++)) return COMPRESS_RESULT_FATAL; /* Verify format */
diff --git a/FP/src/res/config.c b/FP/src/res/config.c
index bfe0176..21027ee 100644
--- a/FP/src/res/config.c
+++ b/FP/src/res/config.c
@@ -34,20 +34,21 @@ config.c: Free Prince : Configuration Handler
 #include "freeprince.h"
 #include <stdlib.h>
 #include "resources.h"
+#include "dat.h"
 
 static tMemory options[CONFIG_MAX_ITEMS];
 
 int configInit() {
 	int id;
-	unsigned char* aux;
+	/*unsigned char* aux;*/
 					
 	for (id=0;id<CONFIG_MAX_ITEMS;id++) {
 		options[id].size=-1;
 		options[id].array=NULL;
 	}
-
+#if 0
 	/* READ INDEX */
-	if (!mReadBeginDatFile(&id,FP_CONFIG_FILE)) return -1;
+	if (!mReadBeginDatFile((unsigned short int *)&id,FP_CONFIG_FILE)) return -1;
 	for (id=0;id<DATA_END_ITEMS;id++) {
 		if (res_getDataById(id,DATA_END_ITEMS,options+id)) {
 			aux=options[id].array;
@@ -57,13 +58,13 @@ int configInit() {
 			return -3;
 		}
 	}
-
+#endif
 	mReadCloseDatFile();
 	return 0;
 }
 
 void configStop() {
-	//use CONFIG_FILE from freeprince.h
+	/*use CONFIG_FILE from freeprince.h*/
 	int i;
 
 	for (i=0;i<CONFIG_MAX_ITEMS;i++) {
diff --git a/FP/src/res/dat.c b/FP/src/res/dat.c
index 05e40b8..b4a2f57 100644
--- a/FP/src/res/dat.c
+++ b/FP/src/res/dat.c
@@ -32,6 +32,7 @@ dat.c: Princed Resources : DAT library
 */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include "disk.h"
@@ -64,13 +65,21 @@ int mReadBeginDatFile(unsigned short int *numberOfItems,const char* vFiledat){
 			1 Ok
 	*/
 
-	int ok;
 	unsigned char* readDatFilePoint;
 
 	/* Open file */
 	readDatFileSize=mLoadFileArray(vFiledat,&readDatFile);
-	if (!readDatFileSize) return 0;
-	if (readDatFileSize<=6) {free(readDatFile);return 0;}
+	if (!readDatFileSize) 
+	{
+		fprintf(stderr, "mReadBeginDatFile: %s not found\n", vFiledat);
+		return 0;
+	}
+	if (readDatFileSize<=6)
+	{
+		fprintf(stderr, "mReadBeginDatFile: File too short\n");
+		free(readDatFile);
+		return 0;
+	}
 
 	readDatFilePoint=readDatFile;
 
@@ -80,6 +89,7 @@ int mReadBeginDatFile(unsigned short int *numberOfItems,const char* vFiledat){
 	indexSize=array2short(readDatFilePoint);
 
 	if ((indexOffset>readDatFileSize)&&((indexOffset+indexSize)!=readDatFileSize)) {
+		fprintf(stderr, "mReadBeginDatFile: Invalid format\n");
 		free(readDatFile);
 		return 0; /* this is not a valid prince dat file */
 	}
@@ -105,11 +115,10 @@ int mReadFileInDatFile(int k,unsigned char* *data,unsigned long  int *size) {
 	unsigned short int id;
 
 	/* for each archived file the index is read */
-	id=    array2short(indexPointer+ofk+k*recordSize);//(indexPointer[ofk+k*recordSize])+(indexPointer[ofk+k*recordSize+1]<<8);
-	//printf("a ver: %d %d\n",id,(indexPointer[ofk+k*recordSize])+(indexPointer[ofk+k*recordSize+1]<<8));
+	id=array2short(indexPointer+ofk+k*recordSize);
 	
-	offset=array2long(indexPointer+ofk+k*recordSize+2);//indexPointer[ofk+k*recordSize+2])+(indexPointer[ofk+k*recordSize+3]<<8)+(indexPointer[ofk+k*recordSize+4]<<16)+(indexPointer[ofk+k*recordSize+5]<<24);
-	*size= array2short(indexPointer+ofk+k*recordSize+6);//indexPointer[ofk+k*recordSize+6])+(indexPointer[ofk+k*recordSize+7]<<8)+1;
+	offset=array2long(indexPointer+ofk+k*recordSize+2);
+	*size= array2short(indexPointer+ofk+k*recordSize+6);
 	if ((!pop1)&&(!(indexPointer[ofk+k*recordSize+8]==0x40)&&(!indexPointer[ofk+k*recordSize+9])&&(!indexPointer[ofk+k*recordSize+10]))) return -1;
 	if (offset+indexSize>readDatFileSize) return -1;
 	*data=readDatFile+offset;
@@ -130,7 +139,7 @@ int mReadInitResource(tResource** res,const unsigned char* data,long size) {
 		(*res)->offset=(unsigned short)offset; /* TODO delete this line */
 		/* (*res)->type=verifyHeader(data,(unsigned short int)size); */
 	} else { /* If resource type is invalid or 0, the type will be decided by PR */
-		if (!((*res)->type)) (*res)->type=0;//verifyHeader(data,(unsigned short int)size);
+		if (!((*res)->type)) (*res)->type=0; /*verifyHeader(data,(unsigned short int)size);*/
 	}
 	return 0;
 }
diff --git a/FP/src/res/disk.c b/FP/src/res/disk.c
index e5b3074..3053709 100644
--- a/FP/src/res/disk.c
+++ b/FP/src/res/disk.c
@@ -40,12 +40,12 @@ disk.c: Princed Resources : Disk Access & File handling functions
 #include "memory.h"
 #include <string.h>
 #include "disk.h"
-//#include "xmlparse.h" /* equalsIgnoreCase */
 #define IGNORERECURSIVEFUNCTIONS
 #define UNIX
 
 #include <sys/types.h>
 #include <sys/stat.h>
+
 #include "resources.h"
 
 #ifdef UNIX
@@ -174,7 +174,7 @@ int writeClose(FILE* fp,int dontSave,int optionflag,const char* backupExtension)
 	char* fileName;
 	unsigned long int size;
 
-	//if (getFromOpenFilesList(fp,&fileName,&content,&size)) {
+	/*if (getFromOpenFilesList(fp,&fileName,&content,&size)) {*/
 		if (dontSave) {
 			fclose(fp);
 			if (size) {
@@ -184,7 +184,7 @@ int writeClose(FILE* fp,int dontSave,int optionflag,const char* backupExtension)
 			} else {
 				remove(fileName);
 			}
-		//}
+		/*}*/
 #if 0
 		else {
 			/* File Existed before and we need to back it up */
@@ -244,8 +244,8 @@ int writeOpen(const char* vFileext, FILE* *fp, int optionflag) {
 		if not, we need to know the name in case we need to delete it
 	*/
 
-//	addFileToOpenFilesList(file,hasFlag(backup_flag));
-	result=((*fp=fopen(file,"wb"))!=NULL);// addPointerToOpenFilesList(*fp);
+/*	addFileToOpenFilesList(file,hasFlag(backup_flag));*/
+	result=((*fp=fopen(file,"wb"))!=NULL);/* addPointerToOpenFilesList(*fp);*/
 	return result;
 }
 
@@ -272,7 +272,7 @@ int writeData(const unsigned char* data, int ignoreChars, char* vFileext, int si
 	/* Verify parameters */
 	size-=ignoreChars;
 	if (size<0) return 0;
-	//if (size==0) return 1; /* Wrote 0 bytes */
+	/*if (size==0) return 1; * Wrote 0 bytes */
 
 	/* Save file */
 	ok=writeOpen(vFileext,&target,optionflag);
@@ -293,8 +293,8 @@ int mLoadFileArray(const char* vFile,unsigned char** array) {
 	int  aux;
 
 	/* Open the file */
-	fp=fopen(repairFolders(vFile),"rb");
 	if ((fp=fopen(repairFolders(vFile),"rb"))==NULL) {
+		fprintf(stderr, "mLoadFileArray: Unable to open file\n");
 		return 0;
 	} else {
 		/* get file size */
@@ -303,6 +303,7 @@ int mLoadFileArray(const char* vFile,unsigned char** array) {
 		if ( !aux || (aux>SIZE_OF_FILE) || ( ((*array=(unsigned char*)malloc(sizeof(char)*aux))==NULL) ) ) {
 			/* if the file was null or bigger than the max size or couldn't allocate the file in memory */
 			fclose(fp);
+			fprintf(stderr, "mLoadFileArray: Wrong size\n");
 			return 0;
 		} else {
 			/* if the file was successfully open */
@@ -372,7 +373,7 @@ whatIs isDir(const char *path) {
 	struct stat buf;
 
 	if(stat(path,&buf)==-1) return eNotFound;
-	return (S_IFDIR&buf.st_mode)?eDirectory:eFile;
+	return (S_ISDIR(buf.st_mode))?eDirectory:eFile;
 }
 
 #ifndef IGNORERECURSIVEFUNCTIONS
diff --git a/FP/src/res/maps.c b/FP/src/res/maps.c
index bb81357..b0bfebc 100644
--- a/FP/src/res/maps.c
+++ b/FP/src/res/maps.c
@@ -35,7 +35,7 @@ maps.c: Freeprince : Map handling library
 static unsigned char* slevel;
 static int sscreen;
 
-//Privates
+/* Privates */
 
 void maps_getStartPosition(int* pantalla, int* p, int *b,tDirection *sentido,tDirection *sentido2) {
 	int valor;
@@ -49,20 +49,20 @@ void maps_getStartPosition(int* pantalla, int* p, int *b,tDirection *sentido,tDi
 }
 
 void maps_getGuard(int pantalla,int *p,int *b,int *skill,int *color,tDirection *sentido,int *exists) {
-	//Posicion
+	/* Posicion */
 	unsigned char valor=(slevel[(MAPS_BLOCK_OFFSET_GUARD_POSITION+sscreen-1)]);
 	*exists = (valor<30);
 	*b      = (valor%10);
 	*p      = (valor/10);
-	//sentido
+	/* sentido */
 	*sentido=slevel[MAPS_BLOCK_OFFSET_GUARD_DIRECTION+pantalla-1]?eRight:eLeft;
-	//skill
+	/* skill */
 	*skill  =slevel[MAPS_BLOCK_OFFSET_GUARD_SKILL+pantalla-1];
-	//Color
+	/* Color */
 	*color  =slevel[MAPS_BLOCK_OFFSET_GUARD_COLOR+pantalla-1];
 }
 
-//Publics
+/* Publics */
 
 int levelUse(void* level) {
 /* Sets the level for future use using the resource given
@@ -71,10 +71,10 @@ int levelUse(void* level) {
  * Return 0 on success
  */
 	
-	//Remember level
+	/* Remember level */
 	slevel=level;
 
-	//Set start screen
+	/* Set start screen */
 	sscreen=slevel[MAPS_BLOCK_OFFSET_START_POSITION];
 
 	printf("levelUse: using new level\n");	
@@ -126,8 +126,8 @@ int levelGetDoorMap(/* TODO: idem */);
 
 int levelGetStarPosition(int* screen, int* position) {
 /* TODO: define position as an int or using x,y coordinate system*/
-	//maps_getStartPosition(screen, position, int *b,tDirection *sentido,tDirection *sentido2);
-
+	/* maps_getStartPosition(screen, position, int *b,tDirection *sentido,tDirection *sentido2); */
+	return 0;
 }
 
 int levelGetInformation(int *thisScreen, unsigned char* LRUDscreens, unsigned char* cornerScreens) {
@@ -143,31 +143,31 @@ int levelGetInformation(int *thisScreen, unsigned char* LRUDscreens, unsigned ch
 |                           Prototipos                          |
 \***************************************************************/
 
-	//File management procedures
+	/* File management procedures */
 	char mLoadPED(char* vFile,tLevel* lev);
-	char mLoadDAT(char* vFile,tLevel* lev,char levelNumber); //Tested 5
-	char mSavePED(char* vFile,tLevel* lev); //Tested 8
-	char mSaveDAT(char* vFile,tLevel* lev); //Tested 3
+	char mLoadDAT(char* vFile,tLevel* lev,char levelNumber); /* Tested 5 */
+	char mSavePED(char* vFile,tLevel* lev); /* Tested 8 */
+	char mSaveDAT(char* vFile,tLevel* lev); /* Tested 3 */
 
-	//char mChangeLevel(tLevel* lev,char newLevel); //0 si no hay cambios; si hay cambios en paredes devuelve la camtidad de paredes cambiadas
-	//char mAllowedOn(char levelnumber,char wall); //1 si wall es permitido en levelnumber; 0 si no
+	/* char mChangeLevel(tLevel* lev,char newLevel); //0 si no hay cambios; si hay cambios en paredes devuelve la camtidad de paredes cambiadas */
+	/* char mAllowedOn(char levelnumber,char wall); //1 si wall es permitido en levelnumber; 0 si no */
 
-	//Information methods
+	/* Information methods */
 	void mSetText (tLevel* lev,char* text);
 	void mGetText (tLevel* lev,char* text);
 
-	//tLevel Set methods
+	/* tLevel Set methods */
 	void mSetWall (tLevel* lev,char pantalla,char p,char b,char valor);
 	void mSetLink (tLevel* lev,char pantalla,char tipo,char valor);
 	void mSetGuard(tLevel* lev,char pantalla,char p,char b,char vidas,char color,char sentido,char erase);
 	void mSetBack (tLevel* lev,char pantalla,char p,char b,char valor);
-	//tLevel Get Methods
+	/* tLevel Get Methods */
 	char mGetWall (tLevel* lev,char pantalla,char p,char b);
 	char mGetLink (tLevel* lev,char pantalla,char tipo);
 	void mGetGuard(tLevel* lev,char pantalla,char* p,char* b,char* vidas,char* color,char* sentido,char* erase);
 	char mGetBack (tLevel* lev,char pantalla,char p,char b);
 
-	//Gate handling Methods
+	/* Gate handling Methods */
 	/*
 	Public:
 	mCreateEventList
@@ -183,22 +183,22 @@ int levelGetInformation(int *thisScreen, unsigned char* LRUDscreens, unsigned ch
 	*/
 
 
-	//Screen Links Handling Methods
+	/* Screen Links Handling Methods */
 	char mGetScreen    (tLevel* lev, char i,char j, char* error);
 	void mGetMainScreen(tLevel* lev, char* i,char* j);
 	void mRemScreen    (tLevel* lev, char i,char j, char* error);
 	void mAddScreen    (tLevel* lev, char i,char j, char* error);
 	void mGetSize      (tLevel* lev, char* i,char* j);
 	char mGetScrCount  (tLevel* lev);
-		//Nota: si mGetScrCount(lev) es 24, entonces el nivel esta lleno
+		/* Nota: si mGetScrCount(lev) es 24, entonces el nivel esta lleno */
 	void mCpyScreen    (tLevel* lev, char fromi,char fromj,char toi,char toj, char* error);
 
-	//Start position handling
+	/* Start position handling */
 	void mGetStartPosition(tLevel* lev,char* pantalla, char* p, char *b,char *sentido,char *sentido2);
 	void mSetStartPosition(tLevel* lev,char pantalla, char p, char b,char sentido,char sentido2);
 	void mGetDebugPosition(tLevel* lev,char* pantalla, char* p, char *b,char *sentido);
 	void mSetDebugPosition(tLevel* lev,char pantalla, char p, char b,char sentido);
-		//Nota: DebugPosition puede no existir en lev, en ese caso la convension es no existe si pantalla igual a 0, de lo contrario existe y la pantalla inicial es pantalla
+		/* Nota: DebugPosition puede no existir en lev, en ese caso la convension es no existe si pantalla igual a 0, de lo contrario existe y la pantalla inicial es pantalla */
 
 /***************************************************************\
 |                  I M P L E M E N T A T I O N                  |
@@ -231,14 +231,14 @@ void mGetArray(tLevel* lev, char *pos,int from,int length) {
 |                         Gate handling                         |
 \***************************************************************/
 
-//Privados
-void getRawEvent(tLevel* lev,char id,tGateEvent* event) { //private
+/* Privados */
+void getRawEvent(tLevel* lev,char id,tGateEvent* event) { /* private */
 	unsigned char x1,x2,valor;
 	(*event).pos[0]  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GATE_1+id];
 	(*event).pos[1]  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GATE_2+id];
 }
 
-void setRawEvent(tLevel* lev,char id,tGateEvent* event) { //private
+void setRawEvent(tLevel* lev,char id,tGateEvent* event) { /* private */
 	unsigned char x1,x2,validate;
 	x1=(*event).pos[0];
 	x2=(*event).pos[1];
@@ -249,13 +249,13 @@ void setRawEvent(tLevel* lev,char id,tGateEvent* event) { //private
 	(*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_WALL]+=validate;
 }
 
-//Privado, pero publico dentro de maps.c
+/* Privado, pero publico dentro de maps.c */
 void mLoadEventList(tLevel* lev) {
-	//Esta funcion carga el TDA con los datos que lee del rigido
+	/* Esta funcion carga el TDA con los datos que lee del rigido */
 	char a=0;
 	char b=0;
 
-	//Cargar gateList con las asociaciones del mapa
+	/* Cargar gateList con las asociaciones del mapa */
 	int j=0;
 	for (int i=0;i<MAPS_BLOCK_SIZEOF_WALL;i++) {
 		switch ((*lev).levelArray[MAPS_BLOCK_OFFSET_WALL+i]) {
@@ -267,7 +267,7 @@ void mLoadEventList(tLevel* lev) {
 	}
 	(*lev).gateList.size=j;
 
-	//Cargar gateTDA con datos de la tabla
+	/* Cargar gateTDA con datos de la tabla */
 	j=0;
 	for (tGateEvent evento;j<MAPS_BLOCK_SIZEOF_GATE;j++) {
 		getRawEvent(lev,j,&evento);
@@ -283,7 +283,7 @@ void mLoadEventList(tLevel* lev) {
 	(*lev).gateTDA.size=a;
 }
 
-//mSevEventList private functions
+/* mSevEventList private functions */
 
 void anularEvento(tGateEvent *e) {
 	(*e).pos[0]=0;
@@ -316,7 +316,7 @@ char belongsToDiskList(tLevel* lev, tGateRow *fila,int i) {
 
 	char total=0;
 	char pertenece;
-	//recorrer la lista de eventos
+	/* recorrer la lista de eventos */
 	for (int k=i;((*lev).gateEvents.event[k].pos[0]<(0x80));k++) {
 		total++;
 		pertenece=0;
@@ -342,10 +342,10 @@ void apuntar(tLevel* lev,unsigned char i) {
 #define MAPS_GATE_SINGLE_EVENT    0
 #define MAPS_GATE_MULTIPLE_EVENT  1
 char intertLeft(tLevel* lev,tGateRow fila,int inicioFila,int numeroFila,char mode) {
-	//Esta funcion inserta en gateEvents el o los eventos de fila que no estan insertados
-	//Por cada insersion deben ser modificados los ids correspondientes en la gateList
-	//devuelve 1 si entro
-	//devuelve 0 en caso de superarse lso 256 bytes
+	/* Esta funcion inserta en gateEvents el o los eventos de fila que no estan insertados */
+	/* Por cada insersion deben ser modificados los ids correspondientes en la gateList */
+	/* devuelve 1 si entro */
+	/* devuelve 0 en caso de superarse lso 256 bytes */
 
 	/*
 	 1) En caso de MULTIPLE EVENT los elementos de la fila
@@ -384,27 +384,27 @@ char intertLeft(tLevel* lev,tGateRow fila,int inicioFila,int numeroFila,char mod
 	*/
 
 	for (j=0;(j<fila.size);j++) {
-		if (fila.event[j].pos[0]) { //Para cada evento nonulo de la fila
-			//Adelantar todos los eventos posteriores a inicioFila
+		if (fila.event[j].pos[0]) { /* Para cada evento nonulo de la fila */
+			/* Adelantar todos los eventos posteriores a inicioFila */
 			for (int k=(*lev).gateEvents.size;k>inicioFila;k--) {
 				(*lev).gateEvents.event[k+1]=(*lev).gateEvents.event[k];
 			}
 
-			//Insertar (*fila).event[j] en la gateEvents en la posicion generada en inicioFila.
-			//Se tendra en cuenta el flag de de fin de lista
+			/* Insertar (*fila).event[j] en la gateEvents en la posicion generada en inicioFila. */
+			/* Se tendra en cuenta el flag de de fin de lista */
 			(*lev).gateEvents.event[inicioFila]=setFlag(fila.event[j],c);
 
-			//El flag del fin de lista se cancela
+			/* El flag del fin de lista se cancela */
 			c=0;
 
-			//Incrementar la cantidad de eventos de la gateEvent, en caso de no poder abortar
+			/* Incrementar la cantidad de eventos de la gateEvent, en caso de no poder abortar */
 			if ((*lev).gateEvents.size==255) {
 				return 0;
 			} else {
 				(*lev).gateEvents.size++;
 			}
 
-			//Finalmente se debe recorrer la gate list e incrementar el contenido que supere a inicioFila
+			/* Finalmente se debe recorrer la gate list e incrementar el contenido que supere a inicioFila */
 			for (int k=0;k<(*lev).gateList.size;k++) {
 				if ((*lev).gateList.item[k].id>=inicioFila)
 					((*lev).gateList.item[k].id)++;
@@ -414,13 +414,13 @@ char intertLeft(tLevel* lev,tGateRow fila,int inicioFila,int numeroFila,char mod
 	return 1;
 }
 
-//Main function
+/* Main function */
 char mSaveEventList(tLevel* lev) {
-	//Lee el TDA, optimiza el espacio que ocupan los datos y lo guardaen disco
-	//devuelve 1 en caso de que entre en disco
-	//devuelve 0 en caso de que no hayan entrado los datos en disco
+	/* Lee el TDA, optimiza el espacio que ocupan los datos y lo guardaen disco */
+	/* devuelve 1 en caso de que entre en disco */
+	/* devuelve 0 en caso de que no hayan entrado los datos en disco */
 
-	//Inicializar variables
+	/* Inicializar variables */
 	unsigned char n=(*lev).gateTDA.size;
 	unsigned char c=1;
 	char x;
@@ -428,14 +428,14 @@ char mSaveEventList(tLevel* lev) {
 	(*lev).gateEvents.size=0;
 	(*lev).gateList.size=0;
 
-	//Generar a partir de gateTDA la lista de eventos gateEventList y de asociaciones gateList
-	while (n) { //Para todos los elementos
-		for (int k=0;k<(*lev).gateTDA.size;k++) { //Recorrer filas de gateTDA
-			if (obtenerFila(&fila,c,k,lev)) {  //mietras haya elementos con tamagno=c sin procesar fila=(*lev).gateTDA.row[n] where fila=(*lev).gateTDA.row[n].size=c;
-				//entra con fila seteada en la fila k con c elementos adentro.
+	/* Generar a partir de gateTDA la lista de eventos gateEventList y de asociaciones gateList */
+	while (n) { /* Para todos los elementos */
+		for (int k=0;k<(*lev).gateTDA.size;k++) { /* Recorrer filas de gateTDA */
+			if (obtenerFila(&fila,c,k,lev)) {  /* mietras haya elementos con tamagno=c sin procesar fila=(*lev).gateTDA.row[n] where fila=(*lev).gateTDA.row[n].size=c; */
+				/* entra con fila seteada en la fila k con c elementos adentro. */
 				n--;
 				x=0;
-				for (int i=0;((i<(*lev).gateEvents.size) && (!x));i++) { //recorrer lo ya creado de gateEvents
+				for (int i=0;((i<(*lev).gateEvents.size) && (!x));i++) { /* recorrer lo ya creado de gateEvents */
 					x=belongsToDiskList(lev,&fila,i);
 					switch (x) {
 						case MAPS_GATE_BELONGS:
@@ -466,8 +466,8 @@ char mSaveEventList(tLevel* lev) {
 		c++;
 	}
 
-	//Guardar gateEvents y gateList en el formato.
-	//gateList
+	/* Guardar gateEvents y gateList en el formato. */
+	/* gateList */
 	for (int i=0;i<(*lev).gateEvents.size;i++) {
 		setRawEvent(lev,i,&((*lev).gateEvents.event[i]));
 	}
@@ -492,7 +492,7 @@ void getGateAsociation(tLevel* lev,char id,char* scr,char* p,char* b, char *term
 	valor     =(x1%(0x20));
 	*b        =(valor%10);
 	*p        =(valor/10);
-	*termino  =(x1/(0x80)); //c=(Se pasa a la siguiente)?0:1
+	*termino  =(x1/(0x80)); /* c=(Se pasa a la siguiente)?0:1 */
 }
 
 void setGateAsociation(tLevel* lev,char id,char scr,char p,char b, char termino) {
@@ -507,7 +507,7 @@ void setGateAsociation(tLevel* lev,char id,char scr,char p,char b, char termino)
 	(*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_WALL]+=validate;
 }
 
-void shiftEventId(tLevel* lev,char from,char delta) { //private
+void shiftEventId(tLevel* lev,char from,char delta) { /* private */
 	char validate=0;
 	char aux;
 	for (int i=0;i<MAPS_BLOCK_SIZEOF_WALL;i++) {
@@ -539,7 +539,7 @@ void insertEvent(tLevel* lev,char id,char scr,char p,char b) {
 \***************************************************************/
 
 #define MAPS_BLOCK_OFFSET_START_POSITION_SIZE3 3
-//Actualmente guarda 1+MAPS_BLOCK_SIZEOF_UNKNOWN_1+MAPS_BLOCK_SIZEOF_UNKNOWN_2+MAPS_BLOCK_SIZEOF_UNKNOWN_4+unk_5+unk_6+unk_7 = 564 caracteres. *text debe medir 565 incluyendo el caracter nulo.
+/* Actualmente guarda 1+MAPS_BLOCK_SIZEOF_UNKNOWN_1+MAPS_BLOCK_SIZEOF_UNKNOWN_2+MAPS_BLOCK_SIZEOF_UNKNOWN_4+unk_5+unk_6+unk_7 = 564 caracteres. *text debe medir 565 incluyendo el caracter nulo. */
 void mSetText (tLevel* lev,char* text) {
 	mSetArray(lev,text,MAPS_BLOCK_OFFSET_START_POSITION+MAPS_BLOCK_OFFSET_START_POSITION_SIZE3,1,MAPS_BLOCK_OFFSET_VALIDATOR_LINK);
 	mSetArray(lev,&(text[1]),MAPS_BLOCK_OFFSET_UNKNOWN_1,MAPS_BLOCK_SIZEOF_UNKNOWN_1,MAPS_BLOCK_OFFSET_VALIDATOR_WALL);
@@ -588,16 +588,16 @@ void mSetStartPosition(tLevel* lev,char pantalla, char p, char b,char sentido,ch
 	int location=MAPS_BLOCK_OFFSET_START_POSITION;
 	unsigned char offsetval=0;
 
-	//pantalla
+	/* pantalla */
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location++]=valor;
 
-	//Posicion
+	/* Posicion */
 	valor     =p*10+b;
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location++]=valor;
 
-	//sentidos
+	/* sentidos */
 	valor     =sentido?MAPS_DIRECTION_RIGHT:MAPS_DIRECTION_LEFT;
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location]=valor;
@@ -607,7 +607,7 @@ void mSetStartPosition(tLevel* lev,char pantalla, char p, char b,char sentido,ch
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location]=valor;
 
-	//Validacion
+	/* Validacion */
 	(*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_LINK]+=offsetval;
 }
 
@@ -637,42 +637,42 @@ void mSetBack (tLevel* lev,char pantalla,char p,char b,char valor) {
 
 void mSetGuard(tLevel* lev,char pantalla,char p,char b,char vidas,char color,char sentido,char erase) {
 
-	//Posicion
+	/* Posicion */
 	unsigned char valor=erase?30:p*10+b;
 	int location=MAPS_BLOCK_OFFSET_GUARD_POSITION-1+pantalla;
 	unsigned char offsetval=((*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_LINK]+(256-valor)+(*lev).levelArray[location]);
 	(*lev).levelArray[location]=valor;
-	//sentido
+	/* sentido */
 	valor     =sentido?MAPS_DIRECTION_RIGHT:MAPS_DIRECTION_LEFT;
 	location  =MAPS_BLOCK_OFFSET_GUARD_DIRECTION-1+pantalla;
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location]=valor;
-	//skill
+	/* skill */
 	valor     =erase?1:vidas;
 	location  =MAPS_BLOCK_OFFSET_GUARD_SKILL-1+pantalla;
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location]=valor;
-	//Color
+	/* Color */
 	valor     =erase?0:color;
 	location  =MAPS_BLOCK_OFFSET_GUARD_COLOR-1+pantalla;
 	offsetval+=(256-valor)+(*lev).levelArray[location];
 	(*lev).levelArray[location]=valor;
 
-	//Validar
+	/* Validar */
 	(*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_LINK]=offsetval/*+(256-valor)+(*lev).levelArray[location]*/;
 }
 
 void mGetGuard(tLevel* lev,char pantalla,char* p,char* b,char* vidas,char* color,char* sentido,char* exists) {
-	//Posicion
+	/* Posicion */
 	unsigned char valor=((*lev).levelArray[(MAPS_BLOCK_OFFSET_GUARD_POSITION-1+pantalla)]);
 	*exists = (valor<30);
 	*b      = (valor%10);
 	*p      = (valor/10);
-	//sentido
+	/* sentido */
 	*sentido=!(*lev).levelArray[MAPS_BLOCK_OFFSET_GUARD_DIRECTION-1+pantalla];
-	//skill
+	/* skill */
 	*vidas  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GUARD_SKILL-1+pantalla];
-	//Color
+	/* Color */
 	*color  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GUARD_COLOR-1+pantalla];
 }
 
@@ -680,8 +680,8 @@ void mGetGuard(tLevel* lev,char pantalla,char* p,char* b,char* vidas,char* color
 |                     Screen Link Handling                      |
 \***************************************************************/
 
-//Recursive mapping sub procedures
-void mRecLink(char i, char j, tLevel* lev); //prototype
+/* Recursive mapping sub procedures */
+void mRecLink(char i, char j, tLevel* lev); /* prototype */
 void mRecIndirect(char i, char j, tLevel* lev, char scr, char pos) {
 	char aux;
 	char auxb;
@@ -758,24 +758,24 @@ void mCalcularLimRight (tLevel* lev) {
 }
 
 
-//	Main mCreateLinkMap
-void mCreateLinkMap(tLevel* lev) { //private
+/* 	Main mCreateLinkMap */
+void mCreateLinkMap(tLevel* lev) { /* private */
 	char	i,j,start;
 
-	//Initialize arrays
+	/* Initialize arrays */
 	for (j=0;j<MAPS_MAX_LENGTH;j++)
 		for (i=0;i<MAPS_MAX_LENGTH;(*lev).handledLinks.linkMap[i++][j]=255);
 	for (j=1;j<=MAPS_MAX_SCREENS;(*lev).handledLinks.linkList[j++]=0);
 
-	//Inicializar start en la pantalla de inicio
+	/* Inicializar start en la pantalla de inicio */
 	mGetStartPosition(lev,&start,&i,&i,&i,&i);
 	(*lev).handledLinks.linkMap[MAPS_LINKMAP_CENTER][MAPS_LINKMAP_CENTER]=start;
 	(*lev).handledLinks.linkList[start]=1;
 
-	//Start Recursive Mapper
+	/* Start Recursive Mapper */
 	mRecLink(MAPS_LINKMAP_CENTER,MAPS_LINKMAP_CENTER,lev);
 
-	//Buscar limites del nivel
+	/* Buscar limites del nivel */
 	mCalcularLimUp   (lev);
 	mCalcularLimDown (lev);
 	mCalcularLimLeft (lev);
@@ -818,41 +818,41 @@ void mAddScreen    (tLevel* lev, char i,char j, char* error) {
 		if ((*lev).handledLinks.linkList[l]) {
 			*error=1;
 		} else {
-			//Pedir pantalla
+			/* Pedir pantalla */
 			(*lev).handledLinks.linkList[l]=1;
 
 			i+=(*lev).handledLinks.limLeft;
 			j+=(*lev).handledLinks.limUp;
 
-			//En caso de agregar una pantalla en alguno de los bordes, estos se amplian
+			/* En caso de agregar una pantalla en alguno de los bordes, estos se amplian */
 			if ((*lev).handledLinks.limLeft=i) (*lev).handledLinks.limLeft--;
 			if ((*lev).handledLinks.limUp=j) (*lev).handledLinks.limUp--;
 			if ((*lev).handledLinks.limRight=i) (*lev).handledLinks.limRight++;
 			if ((*lev).handledLinks.limDown=j) (*lev).handledLinks.limDown++;
 
 
-			//Poner 0 alrededor de l
+			/* Poner 0 alrededor de l */
 			(*lev).handledLinks.linkMap[i][j-1]%=255;
 			(*lev).handledLinks.linkMap[i][j+1]%=255;
 			(*lev).handledLinks.linkMap[i+1][j]%=255;
 			(*lev).handledLinks.linkMap[i-1][j]%=255;
 
-			//Poner l en l
+			/* Poner l en l */
 			(*lev).handledLinks.linkMap[i][j]=l;
 
-			//Setear links desde l a las 4 pantallas adyacentes
+			/* Setear links desde l a las 4 pantallas adyacentes */
 			mSetLink (lev,l,MAPS_sUp,(*lev).handledLinks.linkMap[i][j-1]);
 			mSetLink (lev,l,MAPS_sDown,(*lev).handledLinks.linkMap[i][j+1]);
 			mSetLink (lev,l,MAPS_sRight,(*lev).handledLinks.linkMap[i+1][j]);
 			mSetLink (lev,l,MAPS_sLeft,(*lev).handledLinks.linkMap[i-1][j]);
 
-			//Setear links desde las 4 pantallas adyacentes a l
+			/* Setear links desde las 4 pantallas adyacentes a l */
 			mSetLink (lev,(*lev).handledLinks.linkMap[i][j+1],MAPS_sUp,l);
 			mSetLink (lev,(*lev).handledLinks.linkMap[i][j-1],MAPS_sDown,l);
 			mSetLink (lev,(*lev).handledLinks.linkMap[i-1][j],MAPS_sRight,l);
 			mSetLink (lev,(*lev).handledLinks.linkMap[i+1][j],MAPS_sLeft,l);
 
-			//Limpiar contenido de la pantalla l
+			/* Limpiar contenido de la pantalla l */
 			for (i=0;i<3;i++) {
 				for (j=0;j<10;j++) {
 					mSetWall(lev,l,i,j,0);
@@ -860,7 +860,7 @@ void mAddScreen    (tLevel* lev, char i,char j, char* error) {
 				}
 			}
 			mSetGuard(lev,l,1,1,1,1,1,1);
-			//Listo, ya cree la pantalla y la linkie
+			/* Listo, ya cree la pantalla y la linkie */
 		}
 	}
 }
@@ -873,23 +873,23 @@ void mRemScreen    (tLevel* lev, char i,char j, char* error) {
 	unsigned char l=mGetScreen(lev,i,j,error);
 	*error=*error || (!l);
 	if (!*error) {
-		//Liberar pantalla
+		/* Liberar pantalla */
 		(*lev).handledLinks.linkList[l]=0;
 
-		//Seteo posiciones absolutas
+		/* Seteo posiciones absolutas */
 		i+=(*lev).handledLinks.limLeft;
 		j+=(*lev).handledLinks.limUp;
 
-		//Poner 0 en l
+		/* Poner 0 en l */
 		(*lev).handledLinks.linkMap[i][j]=0;
 
-		//En caso de remover una pantalla en alguno de los bordes, estos se recalculan
+		/* En caso de remover una pantalla en alguno de los bordes, estos se recalculan */
 		if ((*lev).handledLinks.limLeft=i) 	mCalcularLimLeft(lev);
 		if ((*lev).handledLinks.limUp=j)    mCalcularLimUp(lev);
 		if ((*lev).handledLinks.limRight=i) mCalcularLimRight(lev);
 		if ((*lev).handledLinks.limDown=j)  mCalcularLimDown(lev);
 
-		//Borrar links desds las 4 pantallas adyacentes a l
+		/* Borrar links desds las 4 pantallas adyacentes a l */
 		mSetLink (lev,(*lev).handledLinks.linkMap[i][j+1],MAPS_sLeft,0);
 		mSetLink (lev,(*lev).handledLinks.linkMap[i][j-1],MAPS_sRight,0);
 		mSetLink (lev,(*lev).handledLinks.linkMap[i-1][j],MAPS_sDown,0);
@@ -901,27 +901,27 @@ void mCpyScreen    (tLevel* lev, char fromi,char fromj,char toi,char toj, char*
 	char fromscr,toscr,i,j,k,l;
 	char sentido,existe;
 
-	//Verificar que la pantalla source y la pantalla target existan
-	fromscr=mGetScreen(lev,fromi,fromj,error); //Verifico que existe la pantalla from
+	/* Verificar que la pantalla source y la pantalla target existan */
+	fromscr=mGetScreen(lev,fromi,fromj,error); /* Verifico que existe la pantalla from */
 	*error=(*error || fromscr);
-	if (!*error) { //Verifico que existe la pantalla to
+	if (!*error) { /* Verifico que existe la pantalla to */
 		toscr=mGetScreen(lev,toi,toj,error);
 		*error=(*error || toscr);
 	}
-	if (!*error) { //Si existen ambas pantallas
-		//Copiar contenido de la pantalla from a la pantalla to:
+	if (!*error) { /* Si existen ambas pantallas */
+		/* Copiar contenido de la pantalla from a la pantalla to: */
 
-		//Copiar wall y back
+		/* Copiar wall y back */
 		char contenido[30];
 		mGetArray(lev,contenido,MAPS_BLOCK_OFFSET_WALL-30+fromscr*30,30);
 		mSetArray(lev,contenido,MAPS_BLOCK_OFFSET_WALL-30+toscr*30,30,MAPS_BLOCK_OFFSET_VALIDATOR_WALL);
 		mGetArray(lev,contenido,MAPS_BLOCK_OFFSET_BACK-30+fromscr*30,30);
 		mSetArray(lev,contenido,MAPS_BLOCK_OFFSET_BACK-30+toscr*30,30,MAPS_BLOCK_OFFSET_VALIDATOR_WALL);
 
-		//Copiar Guards
+		/* Copiar Guards */
 		mGetGuard(lev,fromscr,&i,&j,&k,&l,&sentido,&existe);
 		mSetGuard(lev,toscr,i,j,k,l,sentido,existe);
-		//Listo, ya se copio el contenido y el guardia
+		/* Listo, ya se copio el contenido y el guardia */
 	}
 }
 
diff --git a/FP/src/res/resources.c b/FP/src/res/resources.c
index e1dca3c..f0d4320 100644
--- a/FP/src/res/resources.c
+++ b/FP/src/res/resources.c
@@ -34,9 +34,11 @@ resources.c: Princed Resources : DAT Extractor
 */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include "freeprince.h"
 #include "resources.h"
+#include "output.h"
 
 #include "compress.h"
 
@@ -61,7 +63,7 @@ tData* res_createData(int nFrames,int type) {
 		case RES_TYPE_IMG_TR_RIGHT:
 		case RES_TYPE_IMG_BL_LEFT:
 		case RES_TYPE_IMG_BL_RIGHT:
-			result->type=eImages;//res_getVirtualTypeFromReal(res_getIdxType);
+			result->type=eImages;/*res_getVirtualTypeFromReal(res_getIdxType);*/
 			nFrames--;
 			break;
 	}
@@ -82,13 +84,12 @@ void res_createFrames(tMemory data,int type,void** returnValue,int number) {
 		case RES_TYPE_IMG_BL_LEFT:
 		case RES_TYPE_IMG_BL_RIGHT:
 			if (!number) {
-				//loadPalette;
 				if (data.size!=100) {
 					printf("Fatal error: res_createFrames: invalid palette\n");
 					exit(1);
 				}
 				memcpy(image.pal,data.array+5,16*3);
-				printf("res_createFrames: Remembering palette\n",number,type);
+				printf("res_createFrames: Remembering palette\n");
 				return;
 			} else {
 				number--;
@@ -101,8 +102,6 @@ void res_createFrames(tMemory data,int type,void** returnValue,int number) {
 				(type==RES_TYPE_IMG_TR_RIGHT||type==RES_TYPE_IMG_TR_LEFT)
 			);
 			 
-			//result=(tMemory*)malloc(sizeof(tMemory)); /* both sides are void* :)  */
-			//*result=(tMemory)data;
 			printf("res_createFrames: Allocating frame[%d]=? (image type %d)\n",number,type);
 			break;
 		case RES_TYPE_SND_MIDI:
@@ -112,7 +111,7 @@ void res_createFrames(tMemory data,int type,void** returnValue,int number) {
 			result=(tMemory*)malloc(sizeof(tMemory)); /* both sides are void* :)  */
 			/* TODO: data->array must be copied or it wont be available after the file is closed */
 			*result=(tMemory)data;
-			printf("res_createFrames: Allocating resource[%d]=@%p (type %d, size %d)\n",number,type,data.array,data.size);
+			printf("res_createFrames: Allocating resource[%d]\n",number);
 			
 			break;
 	}
@@ -134,8 +133,10 @@ int res_getDataById(int id,int maxItems,tMemory* result) {
 	
 	/* main loop */
 	for (indexNumber=0;indexNumber<maxItems;indexNumber++) {
-		gotId=mReadFileInDatFile((indexNumber+id-DATA_START_ITEMS)%maxItems,&(result->array),&(result->size));
-		//printf("Debug: res_getData: indexNumber=%d gotId=%d id=%d\n",indexNumber,gotId,id);
+		gotId=mReadFileInDatFile(
+				(indexNumber+id-DATA_START_ITEMS)%maxItems,
+				&(result->array),
+				(unsigned long *)&(result->size));
 		if (gotId==id) break;
 	}
 	
@@ -162,7 +163,7 @@ int res_getDataByArray(short int* id,int maxItems,void** result,int ids,int type
 			gotId=mReadFileInDatFile(
 				indexNumber,
 				&(data.array),
-				&(data.size)
+				(unsigned long *)&(data.size)
 			);
 			if (gotId==id[i]) {
 				res_createFrames(data,type,result,i);
@@ -194,7 +195,7 @@ tData* resLoad(int id) {
 	tData* result;
 	int i;
 	char file1[25];
-	char file2[25];
+	/*char file2[25];*/
 	short int* frames;
 	int nFrames;
 	tMemory index;
@@ -218,6 +219,8 @@ tData* resLoad(int id) {
 		frames[i]=res_getIdxFrames[i];
 	}
 
+	strncpy(file1,res_getIdxFile1,14);
+	
 	mReadCloseDatFile();
 
 	/* READ FILE */
@@ -226,7 +229,7 @@ tData* resLoad(int id) {
 		printf("frames[%d]=%d\n",i,frames[i]);
 	}
 	
-	if (!mReadBeginDatFile(&numberOfItems,res_getIdxFile1)) {
+	if (!mReadBeginDatFile(&numberOfItems,file1)) {
 		printf("Fatal Error: resLoad: resource file not found!\n");
 		free(frames);
 		return NULL;