*/
/*
-resources.h: Free Prince : Output Devices Handler
+resources.c: Free Prince : Output Devices Handler
¯¯¯¯¯¯¯¯¯¯¯
Description:
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) {}
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)
* 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;
}
/* 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
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
}\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
* 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
\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
| 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
*/\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
| 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
(*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
}\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
(*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
\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
#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
*/\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
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
(*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
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
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
(*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
\***************************************************************/\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
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
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
\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
| 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
}\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
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
}\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
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
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
git / fp-git.git / commitdiff