Ahora compila con -Wall -pedantic -ansi
authordessaya <dessaya>
Sat, 26 Jun 2004 01:49:18 +0000 (01:49 +0000)
committerdessaya <dessaya>
Sat, 26 Jun 2004 01:49:18 +0000 (01:49 +0000)
12 files changed:
FP/src/include/map_defs.h
FP/src/include/output.h
FP/src/include/resources.h
FP/src/ker/kernel.c
FP/src/main.c
FP/src/out/output.c
FP/src/res/compress.c
FP/src/res/config.c
FP/src/res/dat.c
FP/src/res/disk.c
FP/src/res/maps.c
FP/src/res/resources.c

index 396670159e1fb46e1ac84a922d7a26977f8409c7..77b1793441631bd47b391b035bb0d6158aae7371 100644 (file)
@@ -42,9 +42,7 @@ Len   Offs    BlockName & Description
 \r
 #define MAPS_MAX_SCREENS    24\r
 #define MAPS_MAX_LENGTH     49\r
-//MAPS_MAX_SCREENS*2+1\r
 #define MAPS_LINKMAP_CENTER 24\r
-//(char)(MAPS_MAX_SCREENS*2+1)/2\r
 \r
 #define MAPS_DIRECTION_RIGHT 0x00\r
 #define MAPS_DIRECTION_LEFT  0xFF\r
@@ -79,7 +77,6 @@ Len   Offs    BlockName & Description
 #define MAPS_BLOCK_OFFSET_UNKNOWN_7         2288\r
 #define MAPS_BLOCK_SIZEOF_GATE_1            18\r
 #define MAPS_BLOCK_SIZEOF_GATE              18\r
-//256\r
 #define MAPS_BLOCK_OFFSET_GATE_1            1441\r
 #define MAPS_BLOCK_SIZEOF_GATE_2            18\r
 #define MAPS_BLOCK_OFFSET_GATE_2            1697\r
@@ -87,15 +84,15 @@ Len Offs    BlockName & Description
 \r
 \r
 \r
-//Constantes copadas\r
+/* Constantes copadas */\r
 #define MAPS_sUp                       2\r
 #define MAPS_sDown             3\r
 #define MAPS_sLeft             0\r
 #define MAPS_sRight            1\r
 \r
-//Definicion de cosas:\r
+/* Definicion de cosas: */\r
 \r
-//WALLS\r
+/* WALLS */\r
 #define MAPS_OBJ_ANT_1 0x13\r
 #define MAPS_OBJ_ANT_2 0x33\r
 #define MAPS_OBJ_BAL_1 0x01\r
@@ -130,7 +127,7 @@ Len Offs    BlockName & Description
 #define MAPS_OBJ_VEN_L 0x37\r
 #define MAPS_OBJ_VEN_R 0x38\r
 \r
-//BACKS\r
+/* BACKS */\r
 #define MAPS_BCK_VEN_R 0x00\r
 #define MAPS_BCK_BRK_1 0x01\r
 #define MAPS_BCK_BRK_2 0x02\r
index 07455d0c05fd31cfcdbf126b8251768f777496b5..2ace89b15c4efbdb11133049acdb2efe04b36df2 100644 (file)
@@ -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
index 9a4298e16aa9ce77d205bcdd74ae2ef34ff52994..8aa67595e0f51da6e8f22381062b4fbf82ba393a 100644 (file)
@@ -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
index 113256c4c52f58c3b1372a44fc9e2cb414ebe4ef..fc15541ef8fee57a79582b7200466acefd184b10 100644 (file)
@@ -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;
 }
index b21a666fa1de38d32dbb3777f2d8262d3c1ba175..e7cf98587badc262408302846d7b6aa2d8906bb3 100644 (file)
@@ -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        |
index 2ca3bf33d1b8b595e9dd6a4884fbe4cb4074cb77..ac5497f0bca49596042501c0195a8ca964a226ca 100644 (file)
@@ -19,7 +19,7 @@
 */
 
 /*
-resources.h: Free Prince : Output Devices Handler
+resources.c: Free Prince : Output Devices Handler
 ¯¯¯¯¯¯¯¯¯¯¯
 
  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
index 4f45131bd06f2d3ffae4596cdb41052559a88996..916659cc4c81087a90f7ffbc1016a16c7bad02ce 100644 (file)
@@ -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 */
index bfe017654f1db183d838988b4eb9c63056260bd2..21027eef20ad8082514952da8e8e985edaac02f3 100644 (file)
@@ -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++) {
index 05e40b8938ad0f2e5e25f6e7fc80f0635b4e6aaa..b4a2f5728d8af1bb0144183062dffa27af8adc3c 100644 (file)
@@ -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;
 }
index e5b3074da129a65de711b73f0bc8c2e9b28bc6ee..30537090705859ba1cb6da3684ff07d54afaf42e 100644 (file)
@@ -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
index bb813572de9d3d8632b75e018a84fd610deaa80b..b0bfebc4a15e2ea65c54cabf1e8ec0463feea16f 100644 (file)
@@ -35,7 +35,7 @@ maps.c: Freeprince : Map handling library
 static unsigned char* slevel;\r
 static int sscreen;\r
 \r
-//Privates\r
+/* Privates */\r
 \r
 void maps_getStartPosition(int* pantalla, int* p, int *b,tDirection *sentido,tDirection *sentido2) {\r
        int valor;\r
@@ -49,20 +49,20 @@ void maps_getStartPosition(int* pantalla, int* p, int *b,tDirection *sentido,tDi
 }\r
 \r
 void maps_getGuard(int pantalla,int *p,int *b,int *skill,int *color,tDirection *sentido,int *exists) {\r
-       //Posicion\r
+       /* Posicion */\r
        unsigned char valor=(slevel[(MAPS_BLOCK_OFFSET_GUARD_POSITION+sscreen-1)]);\r
        *exists = (valor<30);\r
        *b      = (valor%10);\r
        *p      = (valor/10);\r
-       //sentido\r
+       /* sentido */\r
        *sentido=slevel[MAPS_BLOCK_OFFSET_GUARD_DIRECTION+pantalla-1]?eRight:eLeft;\r
-       //skill\r
+       /* skill */\r
        *skill  =slevel[MAPS_BLOCK_OFFSET_GUARD_SKILL+pantalla-1];\r
-       //Color\r
+       /* Color */\r
        *color  =slevel[MAPS_BLOCK_OFFSET_GUARD_COLOR+pantalla-1];\r
 }\r
 \r
-//Publics\r
+/* Publics */\r
 \r
 int levelUse(void* level) {\r
 /* Sets the level for future use using the resource given\r
@@ -71,10 +71,10 @@ int levelUse(void* level) {
  * Return 0 on success\r
  */\r
        \r
-       //Remember level\r
+       /* Remember level */\r
        slevel=level;\r
 \r
-       //Set start screen\r
+       /* Set start screen */\r
        sscreen=slevel[MAPS_BLOCK_OFFSET_START_POSITION];\r
 \r
        printf("levelUse: using new level\n");  \r
@@ -126,8 +126,8 @@ int levelGetDoorMap(/* TODO: idem */);
 \r
 int levelGetStarPosition(int* screen, int* position) {\r
 /* TODO: define position as an int or using x,y coordinate system*/\r
-       //maps_getStartPosition(screen, position, int *b,tDirection *sentido,tDirection *sentido2);\r
-\r
+       /* maps_getStartPosition(screen, position, int *b,tDirection *sentido,tDirection *sentido2); */\r
+       return 0;\r
 }\r
 \r
 int levelGetInformation(int *thisScreen, unsigned char* LRUDscreens, unsigned char* cornerScreens) {\r
@@ -143,31 +143,31 @@ int levelGetInformation(int *thisScreen, unsigned char* LRUDscreens, unsigned ch
 |                           Prototipos                          |\r
 \***************************************************************/\r
 \r
-       //File management procedures\r
+       /* File management procedures */\r
        char mLoadPED(char* vFile,tLevel* lev);\r
-       char mLoadDAT(char* vFile,tLevel* lev,char levelNumber); //Tested 5\r
-       char mSavePED(char* vFile,tLevel* lev); //Tested 8\r
-       char mSaveDAT(char* vFile,tLevel* lev); //Tested 3\r
+       char mLoadDAT(char* vFile,tLevel* lev,char levelNumber); /* Tested 5 */\r
+       char mSavePED(char* vFile,tLevel* lev); /* Tested 8 */\r
+       char mSaveDAT(char* vFile,tLevel* lev); /* Tested 3 */\r
 \r
-       //char mChangeLevel(tLevel* lev,char newLevel); //0 si no hay cambios; si hay cambios en paredes devuelve la camtidad de paredes cambiadas\r
-       //char mAllowedOn(char levelnumber,char wall); //1 si wall es permitido en levelnumber; 0 si no\r
+       /* char mChangeLevel(tLevel* lev,char newLevel); //0 si no hay cambios; si hay cambios en paredes devuelve la camtidad de paredes cambiadas */\r
+       /* char mAllowedOn(char levelnumber,char wall); //1 si wall es permitido en levelnumber; 0 si no */\r
 \r
-       //Information methods\r
+       /* Information methods */\r
        void mSetText (tLevel* lev,char* text);\r
        void mGetText (tLevel* lev,char* text);\r
 \r
-       //tLevel Set methods\r
+       /* tLevel Set methods */\r
        void mSetWall (tLevel* lev,char pantalla,char p,char b,char valor);\r
        void mSetLink (tLevel* lev,char pantalla,char tipo,char valor);\r
        void mSetGuard(tLevel* lev,char pantalla,char p,char b,char vidas,char color,char sentido,char erase);\r
        void mSetBack (tLevel* lev,char pantalla,char p,char b,char valor);\r
-       //tLevel Get Methods\r
+       /* tLevel Get Methods */\r
        char mGetWall (tLevel* lev,char pantalla,char p,char b);\r
        char mGetLink (tLevel* lev,char pantalla,char tipo);\r
        void mGetGuard(tLevel* lev,char pantalla,char* p,char* b,char* vidas,char* color,char* sentido,char* erase);\r
        char mGetBack (tLevel* lev,char pantalla,char p,char b);\r
 \r
-       //Gate handling Methods\r
+       /* Gate handling Methods */\r
        /*\r
        Public:\r
        mCreateEventList\r
@@ -183,22 +183,22 @@ int levelGetInformation(int *thisScreen, unsigned char* LRUDscreens, unsigned ch
        */\r
 \r
 \r
-       //Screen Links Handling Methods\r
+       /* Screen Links Handling Methods */\r
        char mGetScreen    (tLevel* lev, char i,char j, char* error);\r
        void mGetMainScreen(tLevel* lev, char* i,char* j);\r
        void mRemScreen    (tLevel* lev, char i,char j, char* error);\r
        void mAddScreen    (tLevel* lev, char i,char j, char* error);\r
        void mGetSize      (tLevel* lev, char* i,char* j);\r
        char mGetScrCount  (tLevel* lev);\r
-               //Nota: si mGetScrCount(lev) es 24, entonces el nivel esta lleno\r
+               /* Nota: si mGetScrCount(lev) es 24, entonces el nivel esta lleno */\r
        void mCpyScreen    (tLevel* lev, char fromi,char fromj,char toi,char toj, char* error);\r
 \r
-       //Start position handling\r
+       /* Start position handling */\r
        void mGetStartPosition(tLevel* lev,char* pantalla, char* p, char *b,char *sentido,char *sentido2);\r
        void mSetStartPosition(tLevel* lev,char pantalla, char p, char b,char sentido,char sentido2);\r
        void mGetDebugPosition(tLevel* lev,char* pantalla, char* p, char *b,char *sentido);\r
        void mSetDebugPosition(tLevel* lev,char pantalla, char p, char b,char sentido);\r
-               //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\r
+               /* 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 */\r
 \r
 /***************************************************************\\r
 |                  I M P L E M E N T A T I O N                  |\r
@@ -231,14 +231,14 @@ void mGetArray(tLevel* lev, char *pos,int from,int length) {
 |                         Gate handling                         |\r
 \***************************************************************/\r
 \r
-//Privados\r
-void getRawEvent(tLevel* lev,char id,tGateEvent* event) { //private\r
+/* Privados */\r
+void getRawEvent(tLevel* lev,char id,tGateEvent* event) { /* private */\r
        unsigned char x1,x2,valor;\r
        (*event).pos[0]  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GATE_1+id];\r
        (*event).pos[1]  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GATE_2+id];\r
 }\r
 \r
-void setRawEvent(tLevel* lev,char id,tGateEvent* event) { //private\r
+void setRawEvent(tLevel* lev,char id,tGateEvent* event) { /* private */\r
        unsigned char x1,x2,validate;\r
        x1=(*event).pos[0];\r
        x2=(*event).pos[1];\r
@@ -249,13 +249,13 @@ void setRawEvent(tLevel* lev,char id,tGateEvent* event) { //private
        (*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_WALL]+=validate;\r
 }\r
 \r
-//Privado, pero publico dentro de maps.c\r
+/* Privado, pero publico dentro de maps.c */\r
 void mLoadEventList(tLevel* lev) {\r
-       //Esta funcion carga el TDA con los datos que lee del rigido\r
+       /* Esta funcion carga el TDA con los datos que lee del rigido */\r
        char a=0;\r
        char b=0;\r
 \r
-       //Cargar gateList con las asociaciones del mapa\r
+       /* Cargar gateList con las asociaciones del mapa */\r
        int j=0;\r
        for (int i=0;i<MAPS_BLOCK_SIZEOF_WALL;i++) {\r
                switch ((*lev).levelArray[MAPS_BLOCK_OFFSET_WALL+i]) {\r
@@ -267,7 +267,7 @@ void mLoadEventList(tLevel* lev) {
        }\r
        (*lev).gateList.size=j;\r
 \r
-       //Cargar gateTDA con datos de la tabla\r
+       /* Cargar gateTDA con datos de la tabla */\r
        j=0;\r
        for (tGateEvent evento;j<MAPS_BLOCK_SIZEOF_GATE;j++) {\r
                getRawEvent(lev,j,&evento);\r
@@ -283,7 +283,7 @@ void mLoadEventList(tLevel* lev) {
        (*lev).gateTDA.size=a;\r
 }\r
 \r
-//mSevEventList private functions\r
+/* mSevEventList private functions */\r
 \r
 void anularEvento(tGateEvent *e) {\r
        (*e).pos[0]=0;\r
@@ -316,7 +316,7 @@ char belongsToDiskList(tLevel* lev, tGateRow *fila,int i) {
 \r
        char total=0;\r
        char pertenece;\r
-       //recorrer la lista de eventos\r
+       /* recorrer la lista de eventos */\r
        for (int k=i;((*lev).gateEvents.event[k].pos[0]<(0x80));k++) {\r
                total++;\r
                pertenece=0;\r
@@ -342,10 +342,10 @@ void apuntar(tLevel* lev,unsigned char i) {
 #define MAPS_GATE_SINGLE_EVENT    0\r
 #define MAPS_GATE_MULTIPLE_EVENT  1\r
 char intertLeft(tLevel* lev,tGateRow fila,int inicioFila,int numeroFila,char mode) {\r
-       //Esta funcion inserta en gateEvents el o los eventos de fila que no estan insertados\r
-       //Por cada insersion deben ser modificados los ids correspondientes en la gateList\r
-       //devuelve 1 si entro\r
-       //devuelve 0 en caso de superarse lso 256 bytes\r
+       /* Esta funcion inserta en gateEvents el o los eventos de fila que no estan insertados */\r
+       /* Por cada insersion deben ser modificados los ids correspondientes en la gateList */\r
+       /* devuelve 1 si entro */\r
+       /* devuelve 0 en caso de superarse lso 256 bytes */\r
 \r
        /*\r
         1) En caso de MULTIPLE EVENT los elementos de la fila\r
@@ -384,27 +384,27 @@ char intertLeft(tLevel* lev,tGateRow fila,int inicioFila,int numeroFila,char mod
        */\r
 \r
        for (j=0;(j<fila.size);j++) {\r
-               if (fila.event[j].pos[0]) { //Para cada evento nonulo de la fila\r
-                       //Adelantar todos los eventos posteriores a inicioFila\r
+               if (fila.event[j].pos[0]) { /* Para cada evento nonulo de la fila */\r
+                       /* Adelantar todos los eventos posteriores a inicioFila */\r
                        for (int k=(*lev).gateEvents.size;k>inicioFila;k--) {\r
                                (*lev).gateEvents.event[k+1]=(*lev).gateEvents.event[k];\r
                        }\r
 \r
-                       //Insertar (*fila).event[j] en la gateEvents en la posicion generada en inicioFila.\r
-                       //Se tendra en cuenta el flag de de fin de lista\r
+                       /* Insertar (*fila).event[j] en la gateEvents en la posicion generada en inicioFila. */\r
+                       /* Se tendra en cuenta el flag de de fin de lista */\r
                        (*lev).gateEvents.event[inicioFila]=setFlag(fila.event[j],c);\r
 \r
-                       //El flag del fin de lista se cancela\r
+                       /* El flag del fin de lista se cancela */\r
                        c=0;\r
 \r
-                       //Incrementar la cantidad de eventos de la gateEvent, en caso de no poder abortar\r
+                       /* Incrementar la cantidad de eventos de la gateEvent, en caso de no poder abortar */\r
                        if ((*lev).gateEvents.size==255) {\r
                                return 0;\r
                        } else {\r
                                (*lev).gateEvents.size++;\r
                        }\r
 \r
-                       //Finalmente se debe recorrer la gate list e incrementar el contenido que supere a inicioFila\r
+                       /* Finalmente se debe recorrer la gate list e incrementar el contenido que supere a inicioFila */\r
                        for (int k=0;k<(*lev).gateList.size;k++) {\r
                                if ((*lev).gateList.item[k].id>=inicioFila)\r
                                        ((*lev).gateList.item[k].id)++;\r
@@ -414,13 +414,13 @@ char intertLeft(tLevel* lev,tGateRow fila,int inicioFila,int numeroFila,char mod
        return 1;\r
 }\r
 \r
-//Main function\r
+/* Main function */\r
 char mSaveEventList(tLevel* lev) {\r
-       //Lee el TDA, optimiza el espacio que ocupan los datos y lo guardaen disco\r
-       //devuelve 1 en caso de que entre en disco\r
-       //devuelve 0 en caso de que no hayan entrado los datos en disco\r
+       /* Lee el TDA, optimiza el espacio que ocupan los datos y lo guardaen disco */\r
+       /* devuelve 1 en caso de que entre en disco */\r
+       /* devuelve 0 en caso de que no hayan entrado los datos en disco */\r
 \r
-       //Inicializar variables\r
+       /* Inicializar variables */\r
        unsigned char n=(*lev).gateTDA.size;\r
        unsigned char c=1;\r
        char x;\r
@@ -428,14 +428,14 @@ char mSaveEventList(tLevel* lev) {
        (*lev).gateEvents.size=0;\r
        (*lev).gateList.size=0;\r
 \r
-       //Generar a partir de gateTDA la lista de eventos gateEventList y de asociaciones gateList\r
-       while (n) { //Para todos los elementos\r
-               for (int k=0;k<(*lev).gateTDA.size;k++) { //Recorrer filas de gateTDA\r
-                       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;\r
-                               //entra con fila seteada en la fila k con c elementos adentro.\r
+       /* Generar a partir de gateTDA la lista de eventos gateEventList y de asociaciones gateList */\r
+       while (n) { /* Para todos los elementos */\r
+               for (int k=0;k<(*lev).gateTDA.size;k++) { /* Recorrer filas de gateTDA */\r
+                       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; */\r
+                               /* entra con fila seteada en la fila k con c elementos adentro. */\r
                                n--;\r
                                x=0;\r
-                               for (int i=0;((i<(*lev).gateEvents.size) && (!x));i++) { //recorrer lo ya creado de gateEvents\r
+                               for (int i=0;((i<(*lev).gateEvents.size) && (!x));i++) { /* recorrer lo ya creado de gateEvents */\r
                                        x=belongsToDiskList(lev,&fila,i);\r
                                        switch (x) {\r
                                                case MAPS_GATE_BELONGS:\r
@@ -466,8 +466,8 @@ char mSaveEventList(tLevel* lev) {
                c++;\r
        }\r
 \r
-       //Guardar gateEvents y gateList en el formato.\r
-       //gateList\r
+       /* Guardar gateEvents y gateList en el formato. */\r
+       /* gateList */\r
        for (int i=0;i<(*lev).gateEvents.size;i++) {\r
                setRawEvent(lev,i,&((*lev).gateEvents.event[i]));\r
        }\r
@@ -492,7 +492,7 @@ void getGateAsociation(tLevel* lev,char id,char* scr,char* p,char* b, char *term
        valor     =(x1%(0x20));\r
        *b        =(valor%10);\r
        *p        =(valor/10);\r
-       *termino  =(x1/(0x80)); //c=(Se pasa a la siguiente)?0:1\r
+       *termino  =(x1/(0x80)); /* c=(Se pasa a la siguiente)?0:1 */\r
 }\r
 \r
 void setGateAsociation(tLevel* lev,char id,char scr,char p,char b, char termino) {\r
@@ -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;\r
 }\r
 \r
-void shiftEventId(tLevel* lev,char from,char delta) { //private\r
+void shiftEventId(tLevel* lev,char from,char delta) { /* private */\r
        char validate=0;\r
        char aux;\r
        for (int i=0;i<MAPS_BLOCK_SIZEOF_WALL;i++) {\r
@@ -539,7 +539,7 @@ void insertEvent(tLevel* lev,char id,char scr,char p,char b) {
 \***************************************************************/\r
 \r
 #define MAPS_BLOCK_OFFSET_START_POSITION_SIZE3 3\r
-//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.\r
+/* 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. */\r
 void mSetText (tLevel* lev,char* text) {\r
        mSetArray(lev,text,MAPS_BLOCK_OFFSET_START_POSITION+MAPS_BLOCK_OFFSET_START_POSITION_SIZE3,1,MAPS_BLOCK_OFFSET_VALIDATOR_LINK);\r
        mSetArray(lev,&(text[1]),MAPS_BLOCK_OFFSET_UNKNOWN_1,MAPS_BLOCK_SIZEOF_UNKNOWN_1,MAPS_BLOCK_OFFSET_VALIDATOR_WALL);\r
@@ -588,16 +588,16 @@ void mSetStartPosition(tLevel* lev,char pantalla, char p, char b,char sentido,ch
        int location=MAPS_BLOCK_OFFSET_START_POSITION;\r
        unsigned char offsetval=0;\r
 \r
-       //pantalla\r
+       /* pantalla */\r
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location++]=valor;\r
 \r
-       //Posicion\r
+       /* Posicion */\r
        valor     =p*10+b;\r
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location++]=valor;\r
 \r
-       //sentidos\r
+       /* sentidos */\r
        valor     =sentido?MAPS_DIRECTION_RIGHT:MAPS_DIRECTION_LEFT;\r
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location]=valor;\r
@@ -607,7 +607,7 @@ void mSetStartPosition(tLevel* lev,char pantalla, char p, char b,char sentido,ch
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location]=valor;\r
 \r
-       //Validacion\r
+       /* Validacion */\r
        (*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_LINK]+=offsetval;\r
 }\r
 \r
@@ -637,42 +637,42 @@ void mSetBack (tLevel* lev,char pantalla,char p,char b,char valor) {
 \r
 void mSetGuard(tLevel* lev,char pantalla,char p,char b,char vidas,char color,char sentido,char erase) {\r
 \r
-       //Posicion\r
+       /* Posicion */\r
        unsigned char valor=erase?30:p*10+b;\r
        int location=MAPS_BLOCK_OFFSET_GUARD_POSITION-1+pantalla;\r
        unsigned char offsetval=((*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_LINK]+(256-valor)+(*lev).levelArray[location]);\r
        (*lev).levelArray[location]=valor;\r
-       //sentido\r
+       /* sentido */\r
        valor     =sentido?MAPS_DIRECTION_RIGHT:MAPS_DIRECTION_LEFT;\r
        location  =MAPS_BLOCK_OFFSET_GUARD_DIRECTION-1+pantalla;\r
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location]=valor;\r
-       //skill\r
+       /* skill */\r
        valor     =erase?1:vidas;\r
        location  =MAPS_BLOCK_OFFSET_GUARD_SKILL-1+pantalla;\r
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location]=valor;\r
-       //Color\r
+       /* Color */\r
        valor     =erase?0:color;\r
        location  =MAPS_BLOCK_OFFSET_GUARD_COLOR-1+pantalla;\r
        offsetval+=(256-valor)+(*lev).levelArray[location];\r
        (*lev).levelArray[location]=valor;\r
 \r
-       //Validar\r
+       /* Validar */\r
        (*lev).levelArray[MAPS_BLOCK_OFFSET_VALIDATOR_LINK]=offsetval/*+(256-valor)+(*lev).levelArray[location]*/;\r
 }\r
 \r
 void mGetGuard(tLevel* lev,char pantalla,char* p,char* b,char* vidas,char* color,char* sentido,char* exists) {\r
-       //Posicion\r
+       /* Posicion */\r
        unsigned char valor=((*lev).levelArray[(MAPS_BLOCK_OFFSET_GUARD_POSITION-1+pantalla)]);\r
        *exists = (valor<30);\r
        *b      = (valor%10);\r
        *p      = (valor/10);\r
-       //sentido\r
+       /* sentido */\r
        *sentido=!(*lev).levelArray[MAPS_BLOCK_OFFSET_GUARD_DIRECTION-1+pantalla];\r
-       //skill\r
+       /* skill */\r
        *vidas  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GUARD_SKILL-1+pantalla];\r
-       //Color\r
+       /* Color */\r
        *color  =(*lev).levelArray[MAPS_BLOCK_OFFSET_GUARD_COLOR-1+pantalla];\r
 }\r
 \r
@@ -680,8 +680,8 @@ void mGetGuard(tLevel* lev,char pantalla,char* p,char* b,char* vidas,char* color
 |                     Screen Link Handling                      |\r
 \***************************************************************/\r
 \r
-//Recursive mapping sub procedures\r
-void mRecLink(char i, char j, tLevel* lev); //prototype\r
+/* Recursive mapping sub procedures */\r
+void mRecLink(char i, char j, tLevel* lev); /* prototype */\r
 void mRecIndirect(char i, char j, tLevel* lev, char scr, char pos) {\r
        char aux;\r
        char auxb;\r
@@ -758,24 +758,24 @@ void mCalcularLimRight (tLevel* lev) {
 }\r
 \r
 \r
-//     Main mCreateLinkMap\r
-void mCreateLinkMap(tLevel* lev) { //private\r
+/*     Main mCreateLinkMap */\r
+void mCreateLinkMap(tLevel* lev) { /* private */\r
        char    i,j,start;\r
 \r
-       //Initialize arrays\r
+       /* Initialize arrays */\r
        for (j=0;j<MAPS_MAX_LENGTH;j++)\r
                for (i=0;i<MAPS_MAX_LENGTH;(*lev).handledLinks.linkMap[i++][j]=255);\r
        for (j=1;j<=MAPS_MAX_SCREENS;(*lev).handledLinks.linkList[j++]=0);\r
 \r
-       //Inicializar start en la pantalla de inicio\r
+       /* Inicializar start en la pantalla de inicio */\r
        mGetStartPosition(lev,&start,&i,&i,&i,&i);\r
        (*lev).handledLinks.linkMap[MAPS_LINKMAP_CENTER][MAPS_LINKMAP_CENTER]=start;\r
        (*lev).handledLinks.linkList[start]=1;\r
 \r
-       //Start Recursive Mapper\r
+       /* Start Recursive Mapper */\r
        mRecLink(MAPS_LINKMAP_CENTER,MAPS_LINKMAP_CENTER,lev);\r
 \r
-       //Buscar limites del nivel\r
+       /* Buscar limites del nivel */\r
        mCalcularLimUp   (lev);\r
        mCalcularLimDown (lev);\r
        mCalcularLimLeft (lev);\r
@@ -818,41 +818,41 @@ void mAddScreen    (tLevel* lev, char i,char j, char* error) {
                if ((*lev).handledLinks.linkList[l]) {\r
                        *error=1;\r
                } else {\r
-                       //Pedir pantalla\r
+                       /* Pedir pantalla */\r
                        (*lev).handledLinks.linkList[l]=1;\r
 \r
                        i+=(*lev).handledLinks.limLeft;\r
                        j+=(*lev).handledLinks.limUp;\r
 \r
-                       //En caso de agregar una pantalla en alguno de los bordes, estos se amplian\r
+                       /* En caso de agregar una pantalla en alguno de los bordes, estos se amplian */\r
                        if ((*lev).handledLinks.limLeft=i) (*lev).handledLinks.limLeft--;\r
                        if ((*lev).handledLinks.limUp=j) (*lev).handledLinks.limUp--;\r
                        if ((*lev).handledLinks.limRight=i) (*lev).handledLinks.limRight++;\r
                        if ((*lev).handledLinks.limDown=j) (*lev).handledLinks.limDown++;\r
 \r
 \r
-                       //Poner 0 alrededor de l\r
+                       /* Poner 0 alrededor de l */\r
                        (*lev).handledLinks.linkMap[i][j-1]%=255;\r
                        (*lev).handledLinks.linkMap[i][j+1]%=255;\r
                        (*lev).handledLinks.linkMap[i+1][j]%=255;\r
                        (*lev).handledLinks.linkMap[i-1][j]%=255;\r
 \r
-                       //Poner l en l\r
+                       /* Poner l en l */\r
                        (*lev).handledLinks.linkMap[i][j]=l;\r
 \r
-                       //Setear links desde l a las 4 pantallas adyacentes\r
+                       /* Setear links desde l a las 4 pantallas adyacentes */\r
                        mSetLink (lev,l,MAPS_sUp,(*lev).handledLinks.linkMap[i][j-1]);\r
                        mSetLink (lev,l,MAPS_sDown,(*lev).handledLinks.linkMap[i][j+1]);\r
                        mSetLink (lev,l,MAPS_sRight,(*lev).handledLinks.linkMap[i+1][j]);\r
                        mSetLink (lev,l,MAPS_sLeft,(*lev).handledLinks.linkMap[i-1][j]);\r
 \r
-                       //Setear links desde las 4 pantallas adyacentes a l\r
+                       /* Setear links desde las 4 pantallas adyacentes a l */\r
                        mSetLink (lev,(*lev).handledLinks.linkMap[i][j+1],MAPS_sUp,l);\r
                        mSetLink (lev,(*lev).handledLinks.linkMap[i][j-1],MAPS_sDown,l);\r
                        mSetLink (lev,(*lev).handledLinks.linkMap[i-1][j],MAPS_sRight,l);\r
                        mSetLink (lev,(*lev).handledLinks.linkMap[i+1][j],MAPS_sLeft,l);\r
 \r
-                       //Limpiar contenido de la pantalla l\r
+                       /* Limpiar contenido de la pantalla l */\r
                        for (i=0;i<3;i++) {\r
                                for (j=0;j<10;j++) {\r
                                        mSetWall(lev,l,i,j,0);\r
@@ -860,7 +860,7 @@ void mAddScreen    (tLevel* lev, char i,char j, char* error) {
                                }\r
                        }\r
                        mSetGuard(lev,l,1,1,1,1,1,1);\r
-                       //Listo, ya cree la pantalla y la linkie\r
+                       /* Listo, ya cree la pantalla y la linkie */\r
                }\r
        }\r
 }\r
@@ -873,23 +873,23 @@ void mRemScreen    (tLevel* lev, char i,char j, char* error) {
        unsigned char l=mGetScreen(lev,i,j,error);\r
        *error=*error || (!l);\r
        if (!*error) {\r
-               //Liberar pantalla\r
+               /* Liberar pantalla */\r
                (*lev).handledLinks.linkList[l]=0;\r
 \r
-               //Seteo posiciones absolutas\r
+               /* Seteo posiciones absolutas */\r
                i+=(*lev).handledLinks.limLeft;\r
                j+=(*lev).handledLinks.limUp;\r
 \r
-               //Poner 0 en l\r
+               /* Poner 0 en l */\r
                (*lev).handledLinks.linkMap[i][j]=0;\r
 \r
-               //En caso de remover una pantalla en alguno de los bordes, estos se recalculan\r
+               /* En caso de remover una pantalla en alguno de los bordes, estos se recalculan */\r
                if ((*lev).handledLinks.limLeft=i)      mCalcularLimLeft(lev);\r
                if ((*lev).handledLinks.limUp=j)    mCalcularLimUp(lev);\r
                if ((*lev).handledLinks.limRight=i) mCalcularLimRight(lev);\r
                if ((*lev).handledLinks.limDown=j)  mCalcularLimDown(lev);\r
 \r
-               //Borrar links desds las 4 pantallas adyacentes a l\r
+               /* Borrar links desds las 4 pantallas adyacentes a l */\r
                mSetLink (lev,(*lev).handledLinks.linkMap[i][j+1],MAPS_sLeft,0);\r
                mSetLink (lev,(*lev).handledLinks.linkMap[i][j-1],MAPS_sRight,0);\r
                mSetLink (lev,(*lev).handledLinks.linkMap[i-1][j],MAPS_sDown,0);\r
@@ -901,27 +901,27 @@ void mCpyScreen    (tLevel* lev, char fromi,char fromj,char toi,char toj, char*
        char fromscr,toscr,i,j,k,l;\r
        char sentido,existe;\r
 \r
-       //Verificar que la pantalla source y la pantalla target existan\r
-       fromscr=mGetScreen(lev,fromi,fromj,error); //Verifico que existe la pantalla from\r
+       /* Verificar que la pantalla source y la pantalla target existan */\r
+       fromscr=mGetScreen(lev,fromi,fromj,error); /* Verifico que existe la pantalla from */\r
        *error=(*error || fromscr);\r
-       if (!*error) { //Verifico que existe la pantalla to\r
+       if (!*error) { /* Verifico que existe la pantalla to */\r
                toscr=mGetScreen(lev,toi,toj,error);\r
                *error=(*error || toscr);\r
        }\r
-       if (!*error) { //Si existen ambas pantallas\r
-               //Copiar contenido de la pantalla from a la pantalla to:\r
+       if (!*error) { /* Si existen ambas pantallas */\r
+               /* Copiar contenido de la pantalla from a la pantalla to: */\r
 \r
-               //Copiar wall y back\r
+               /* Copiar wall y back */\r
                char contenido[30];\r
                mGetArray(lev,contenido,MAPS_BLOCK_OFFSET_WALL-30+fromscr*30,30);\r
                mSetArray(lev,contenido,MAPS_BLOCK_OFFSET_WALL-30+toscr*30,30,MAPS_BLOCK_OFFSET_VALIDATOR_WALL);\r
                mGetArray(lev,contenido,MAPS_BLOCK_OFFSET_BACK-30+fromscr*30,30);\r
                mSetArray(lev,contenido,MAPS_BLOCK_OFFSET_BACK-30+toscr*30,30,MAPS_BLOCK_OFFSET_VALIDATOR_WALL);\r
 \r
-               //Copiar Guards\r
+               /* Copiar Guards */\r
                mGetGuard(lev,fromscr,&i,&j,&k,&l,&sentido,&existe);\r
                mSetGuard(lev,toscr,i,j,k,l,sentido,existe);\r
-               //Listo, ya se copio el contenido y el guardia\r
+               /* Listo, ya se copio el contenido y el guardia */\r
        }\r
 }\r
 \r
index e1dca3c2561972f247525822230a602877bc5e85..f0d4320e5f00658c9ef921cbd1aeb9a3837ed5d0 100644 (file)
@@ -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;