Wtf-rate my code

ZippoLag

Hi there, a year or so ago I saw myself orced to learn C using the most horrible compiler ever, now, I don't remember exactly what was it -I think it was some obscure/broken Borland C++ compiler- but it featured some C++ features and some others not, at least I could use // coments, but still the thing was weird, for example, it didn't like you to store input directly on an element of an array of some structures using scanf, so the following for example would throw an error:

i=1;
scanf(" %c", myarray[i].mychar);

while this would compile/run just fine:

scanf(" %c", myarray[1].mychar);

But enough justifying, the reason of me summoning you here, is that I've recently stumbled upon a dark piece of code I made back then, I commited the sin of friggin' writing a Pacman "clone" on that compiler, but as I started writing the thing, I started to stumble upon some of it's limitations, and some other times I jsut got stuck on debugging some things that now look really stupid to me, but at the time were like trying to walk trhu a brick wall.
So now what I would like you to do, is kill some of your spare time and look at this piece of crap, and tell me, what do you think is the worse piece of all the code.

Note: yup, all comments and functions are named in spanish, some comments -about 1/3- are "angry comments" left behind when I couldn't make something work right and I just invented some workaound, I'm not sure if you would need me to at least translate the comments so you can have an idea of what each piece of code is supposed to be doing, but as the path of the smaller effort is to leave the code 'as is' I will not translate them unless I'm asked.
I know it looks long, but anyway, I hope you have appetite for some spaghetti.

Without further ado, Teh Code:

/*------------------------------------------------------------------------*/
/*-----------------------------------PACOMAN------------------------------*/
/*------------------------------------------------------------------------*/

#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <dos.h>
#include <stdlib.h>


/* CONSTANTES SIMBOLICAS*/
	   /* VERSION */
#define PACOVER "v0.5a"
#define COMPATIVERSION 'a' //a:casa //b:notebook hp //->necesario puesto que el ASCII de las notebooks hp aparentemente difiere de el de la maquina de mi casa en algunos caracteres

	   /* SONIDO */
//#define CONWAKA 1       //hace *wakawakawaka* cuando se mueve?
//#define CONTWEET 1      //hace *tweet* cuando come un fantasma?
//#define CONMUSICAMUERTE //hace priiiiibuuukacua

	    /* SIMBOLOS DEL MAPA */
#define PVAI 185   //¹:185   pared vertical abierta a la izquierda
#define PVER 186   //º:186   pared vertical
#define ECSD 187   //»:187   esquina cerrada superior derecha
#define ECID 188   //¼:188   esquina cerrada inferior derecha
#define ECSI 201   //É:201   esquina cerrada superior izquierda
#define ECII 200   //È:200   esquina cerrada inferior izquierda
#define TINV 202   //Ê:202   T abierta invertida
#define TCOM 203   //Ë:203   T abierta
#define PVAD 204   //Ì:204   pared vertical abierta a la derecha
#define PHZN 205   //Í:205   pared horizontal
#define CRUZ 206   //Î:206   + (cruz abierta)
#define SPFN 126   //~:126   spawn fantasma <-requiere un espacio vacio arriba //cuenta como pared //SOLO PUEDE HABER UNO POR MAPA
#define PACO   2   //:2     paco /spawn paco //SOLO PUEDE HABER UNO EN EL MAPA

#if COMPATIVERSION=='a' //si estamos en modo compatibilidad con la pc de mi casa
#define PAST 250   //ú:250   pastilla
#define SPAS 155   //›:155   super pastilla
#define FANT 169   //©:169   fantasma
#elif COMPATIVERSION=='b' //si estamos en modo compatibilidad con las notebooks hp
#define PAST 249   //ù:249   pastilla
#define SPAS 236   //ì:236   super pastilla
#define FANT 234   //ê:234   fantasma
#endif

/* TIPOS DE DATOS */

struct ente{
	    char q;          //su simbolo
	    int x;           //su posicion en x
	    int y;           //su posicion en y
	    int dir;         //la direccion en la que se mueve //0 no se mueve
	    int vel;         //la velocidad a la que se mueve  //0 no se mueve
	    int def_vel;     //la velocidad estandar del ente
	    int dopa_vel;    //la velocidad del ente cuando el paco esta dopado
	    int def_color;   //su color normal
	    int color;       //el color que posee actualmente
	    int dopa_color;  //su color cuando el paco esta dopado
	   };


/* CONSTANTES GLOBALES */

 const int POS_INI_X=1; //comienzo del mapa en x
 const int POS_INI_Y=3; //comienzo del mapa en y

 const int PAREDES[12]={PVAI, PVER, ECSD, ECID, ECSI, ECII, TINV, TCOM, PVAD, PHZN, CRUZ, SPFN}; //todos los caracteres que no son caminables

 enum DIRECCIONES{QUIETO=0,ARR,IZQ,ABA,DER}; //las 4 posibles direcciones de movimiento
 const int MAX_DIR=DER;
 enum VELOCIDADES{        NORMAL=1,RAPIDO}; //las posibles velocidades (es valida la direccion QUIETO como velocidad 0)
 const int MAX_VEL=RAPIDO;

 const char MOV_AR='w';
 const char MOV_IZ='a';
 const char MOV_AB='s';
 const char MOV_DE='d';
 const char SALIR='k';
 const char PAUSA='p';

 enum  ERRORES{PSNF=0,FSNF,PANF,SPANF,MFDG,FMNE}; //los distintos codigos de error

 const int ANCHOMAPA=22; //1 espacio extra para el caracter de fin de cadena
 const int ALTOMAPA=21;  //OjO, el mapa no debe tener mas de 20 de altura o no entra en la pantalla todo

 const int MAXFANTASMAS=4; //la maxima cantidad de fantasmas simultaneos //nota, no puede ser mayor a (MAX_FANT_COLOR-MIN_FANT_COLOR)

 const int MAX_VEL_FANT=NORMAL; //la maxima velocidad posible para los fantasmas
 const int MIN_FANT_COLOR=GREEN; //el color mas bajo asignable a un fantasma
 const int MAX_FANT_COLOR=DARKGRAY; //el color mas alto asignable a un fantasma
 const int FANT_DOPA_COLOR=LIGHTBLUE+BLINK; //el color de los fantasmas cuando el paco esta dopado

 const int PACO_DEF_COLOR=YELLOW; //el color normal del paco
 const int PACO_DOPA_COLOR=YELLOW; //el color dopado del paco
 const int PACO_DEF_DIR=ARR; //direccion en la que comienza moviendoce el paco
 const int PACO_DEF_VEL=NORMAL; //velocidad estandar del paco //nota: dado mi estilo vago de programacion, el paco no deberia tener una velocidad mayor a 1, de lo contrarios pueden darse errores con las verificaciones de coliciones con los fantasmas, los fantasmas por otro lado pueden ser tan rapidos como se quiera.

 const int COLOR_TEXTO=WHITE;
 const int COLOR_MAPA=RED;
 const int COLOR_PASTILLAS=YELLOW;
 const int COLOR_PUNTAJE_OBT=CYAN;

 const int PUNTAJE_PASTILLA=1;
 const int PUNTAJE_SUP_PAST=10;
 const int PUNTAJE_FANTASMA=100;

 const int LAPSO_ENTRE_FANTASMAS=13; //el tiempo en segundos entre que sale un fatasma y el siguiente
 const int DURACION_DOPA=30; //duracion de la superpastilla en segundos
 const int DEF_VIDAS=1; //vidas con las que comienza la partida el jugador
 const int HSFPS=75; //la cantidad de centesimas de segundo a esperar antes del siguiente cuadro

 const char CHARNULO=' ';

#ifdef CONWAKA //faa, fanatico de la performance :P
 const int FREC_DOPADO=100;     //default:100
 const int MIN_FREC_WAKA=300;   //default:300
 const int MAX_FREC_WAKA=600;   //default:600
 const int MIN_INTER_WAKA=600;  //default:600
 const int MAX_INTER_WAKA=1200; //default:1200
 int g_sonando=0; //es constante, pero ni ganas de hacer otro ifdef-endif
 int g_suena_mueve=0; //para que solo suene si se esta moviendo el paco
#endif

/* VARIABLES GLOBALES */
 int g_puntaje=0;       //puntaje del jugador
 int g_vidas=DEF_VIDAS; //vidas del jugador
 int g_killing_spree=0; //bonus por cantidad de fantasmas comidos en una misma sesion de dopaje //aumenta el puntaje que entrega comerse a un fantasma
 int g_pastillas=0;     //la cantidad de pastillas que faltan comer
 int g_super_pastillas=0;
 int g_cant_fant=0; //la cantidad de fantasmas que hay dando vuelta

 int g_fin_del_juego=0; //cuando sea !=0 terminar  el juego
 int g_dopado=0; //para saber si hay activa una superpastilla

 struct time g_t_com_dopa; //comienzo del dopaje
 struct time g_t_com_juego; //comienzo del juego

 int g_color_fantasma_muerto=-1; //soy un limado (no, no voy a explicar para que es esto, es bastante autoexplicativo, mira en el main sino) //nota: esto sirve solo porque no puede haber 2 fantasmas con el mismo color

 char pastillas[ALTOMAPA][ANCHOMAPA];
 char MAPA001[ALTOMAPA][ANCHOMAPA]={ //el mapa cargado, si bien no es constante me resulta comodo ponerlo en mayuscula
		   /**/" ",/**/       "ÉÍÍÍÍÍ»       ÉÍÍÍÍÍ»", //NOTA, el agregado de una linea vacia al comienzo es por el bug raro que aparecio al separar las pastillas en otra capa, el porque del bug me sigue eludiendo
				      "º21111ÈÍÍÍÍÍÍÍ¼11112º",
				      "º1ÉÍ»11111111111ÉÍ»1º",
				      "º1º ÈÍÍÍÍ»1ÉÍÍÍÍ¼ º1º",
				      "º1ÈËÍËÍÍÍ¼1ÈÍÍÍËÍË¼1º",
				      "º11ÈÍ¼111121111ÈÍ¼11º",
				      "È»11111ÉÍÍ~ÍÍ»11111É¼",
				      " ÈÍÍÍ»1ÈÍÍÍÍÍ¼1ÉÍÍÍ¼ ",
				      "   ÉÍ¼111111111ÈÍ»   ",
				      " ÉÍ¼111ÉÍ»1ÉÍ»111ÈÍ» ",
				      "É¼111ÉÍÎÍ¹1ÌÍÎÍ»111È»",
				      "º11ÉÍ¼ º º1º º ÈÍ»11º",
				      "º1É¼   º º1º º   È»1º",
				      "º1ÌÍÍÍÍÊÍ¹1ÌÍÊÍÍÍÍ¹1º",
				      "º1º      º1º      º1º",
				      "º1º      º1º      º1º",
				      "º1ÈÍ»  ÉÍ¼1ÈÍ»  ÉÍ¼1º",
				      "º111ÈÍÍ¼1111ÈÍÍ¼111º",
				      "ÈÍ»211111ÉÍ»111112ÉÍ¼",
				      "  ÈÍÍÍÍÍÍ¼ ÈÍÍÍÍÍÍ¼  ",};


/*PROTOTIPO DE FUNCIONES */

void muestra_titulo(); //limpia la pantalla y muestra el titulo del juego
void muestra_mapa(); //imprime el mapa en pantalla
void muestra_pastillas(); //actualiza las pastillas
void muestra_puntaje_y_vidas(); //muestra las vidas y el puntaje del jugador denajo del mapa
void muestra_instrucciones(); //muestra las teclas de manejo al fondo de la pantalla
void muestra_ente(struct ente); //dibuja al ente que se le pasa en su posicion correspondiente y con su correspondiente color

struct ente buscar_ente(char);     //busca un cierto caracter en el mapa y lo devuelve como ente
int buscar_spawn_paco(struct ente&); //busca el caracter de spawn del paco
int buscar_spawn_fantasma(struct ente&); //busca el caracter de spawn de fantasmas
void buscar_pastillas(); //busca las pastillas, las convierte al caracter segun la version y las carga en el arreglo (limpiando el mapa), guardando la cantidad ademas, obvio

void crear_paco(struct ente &paco, struct ente spawn); //crea al ente paco en la posicion dada por su ente spawn
void crear_fant(struct ente &fant, int&, struct ente spawn); //crea un ente fantasma arriba de la puerta o punto de spawn de fantasma

void recibir_input(struct ente&); //recibe input desde el teclado y lo interpreta
void modif_dir_ente(int nuevadir,struct ente&); //modifica la direccion del ente dado
void mover_ente(struct ente&,struct ente otto); //mueve a un ente en la direccion dada y con su velocidad propia (si es posible) /nota: el chocarse contra una pared termina el movimiento hasta el siguiente cuadro //verifica la coliciones con el ente "otto" //nota: uso "otto" porque "aux" ya era otra cosa en la funcion, y "dummy" tom‚ por costumbre que sea un ente vacio, asi que este ente auxiliar generico se lama "otto"
int valid_mov(struct ente, struct ente otto); //verifica que sea valido mover al ente/ devuelve la cantidad de espacios que se movera en la direccion dada //verfica las coliciones con el ente "otto"

void comer_pastilla(int x, int y); //elimina la pastilla del mapa en la posicion dada, suma el puntaje y llama a la funcion que comienza el dopaje en caso de que haya sido una super pastilla

void err(int); //maneja los errores del programa

/* MAIN */

int main()
{
 gettime(&g_t_com_juego);
 /* CONSTANTES LOCALES DE MAIN*/

 /* VARIABLES LOCALES DE MAIN*/

 int i=0,j=0; //indices genericos

#ifdef CONWAKA //se, ya lime con esto, asi que la hago completa
 int sonando; //para alternar el sonido producido..
#endif

 struct ente punto_spawn_paco;
 struct ente punto_spawn_fantasma;
 struct ente paco;
 struct ente fantasmas[MAXFANTASMAS];
 struct ente dummy; dummy.q=CHARNULO; dummy.x=0; dummy.y=0; //ver para que lo uso en la funcion de movimiento, validacion de movimiento y entonces coliciones

 int ult_color_fant=MIN_FANT_COLOR; //el color asignado al ultimo fantasma que fue creado
 int imprimir_puntaje=0;

 struct time t_com_bucle; //variable para buclear mientras que el usuario realice un input
 struct time t_ultimo_fant; //cuando se cre¢ el ultimo fantasma
 struct time t_aux;
 //int t_hudif=0;
 int t_sedif=0;

 /* INICIO DEL PROGRAMA */

 srand(time(0)); //inicializa el generador de numeros aleatorios

 muestra_titulo(); //muestra *PACOMAN vX.X*
 if(buscar_spawn_paco(punto_spawn_paco))                 {err(PSNF);  return PSNF; }
 if(buscar_spawn_fantasma(punto_spawn_fantasma))         {err(FSNF);  return FSNF; }
 buscar_pastillas(); if(!g_pastillas)                    {err(PANF);  return PANF; }
 if(MAXFANTASMAS > MAX_FANT_COLOR-MIN_FANT_COLOR)        {err(MFDG);  return MFDG; }
 crear_paco(paco, punto_spawn_paco);
 crear_fant(fantasmas[g_cant_fant],ult_color_fant,punto_spawn_fantasma);
 gettime(&t_ultimo_fant);    /* creamos un fantasma si ya es hora */
 do
  {
   gettime(&t_aux);
   t_sedif=t_aux.ti_sec-g_t_com_dopa.ti_sec;
   (t_sedif<0)?t_sedif=-t_sedif:1;
   if(t_sedif>=DURACION_DOPA)
    {
     g_dopado=0;
     g_killing_spree=0;
    }
   if(g_cant_fant<MAXFANTASMAS && !g_dopado)  //solo se crean fantasmas si no se llego al maximo y si el paco no esta dopado, para evitar que "campee"
    {
     gettime(&t_aux);
     t_sedif=t_aux.ti_sec-t_ultimo_fant.ti_sec;
     (t_sedif<0)?t_sedif=-t_sedif:1;
     if(t_sedif>=LAPSO_ENTRE_FANTASMAS)
      {
       crear_fant(fantasmas[g_cant_fant],ult_color_fant,punto_spawn_fantasma);
       gettime(&t_ultimo_fant);
      }
    }
   muestra_titulo();
   muestra_mapa();
   muestra_pastillas();
   muestra_ente(paco);
   for (i=0;i<g_cant_fant;i++)
    muestra_ente(fantasmas[i]);
   muestra_puntaje_y_vidas();
   muestra_instrucciones();
   if(imprimir_puntaje)
    {
     textcolor(COLOR_PUNTAJE_OBT);
     gotoxy(POS_INI_X+paco.y,POS_INI_Y+paco.x);
     cprintf("%d!!",PUNTAJE_FANTASMA*g_killing_spree);
#ifdef CONTWEET
     printf("\a\a\a");
#endif
     textcolor(WHITE);
     imprimir_puntaje=0;
    }
   gettime(&t_com_bucle);
   // gotoxy(1,13); printf("\n%d %d",paco.x,paco.y); //que muestre la posicion para debuggear mas facil
   do //bucle para input/espera a siguiente cuadro para no actualizar muchas veces por segundo que queda feo
    {
#ifdef CONWAKA
     if (g_suena_mueve)
      {
       if(!g_dopado)
	if(g_sonando>MIN_INTER_WAKA){sound(MIN_FREC_WAKA); g_sonando++; if(g_sonando>MAX_INTER_WAKA)g_sonando=0;}//wakawakawakawaka..
	 else{sound(MAX_FREC_WAKA); g_sonando++;}
	else sound(FREC_DOPADO);
      }
#endif
     recibir_input(paco);
     gettime(&t_aux);
     /*t_hudif=t_aux.ti_hund-t_com_bucle.ti_hund;
     (t_hudif<0)?t_hudif=-t_hudif:1;*/
     t_sedif=t_aux.ti_sec-t_com_bucle.ti_sec;
     (t_sedif<0)?t_sedif=-t_sedif:1;
    }while(/*t_hudif<HSFPS&&*/t_sedif<1);
   mover_ente(paco, dummy); //mando a dummy porque no tengo nada que pasarle, las coliciones del paco con los fantasmas se verfican al mover los fantasmas nomas
   for (i=0;i<g_cant_fant;i++)
    {
     mover_ente(fantasmas[i], paco);
     if(g_color_fantasma_muerto!=-1) //elimina al fantasma muerto, muestra y suma puntaje y usa el intervalo de tiempo para crear otro fantasma
      {
       i=-1;
       do
	{
	 i++;
	}while(fantasmas[i].color!=g_color_fantasma_muerto /*&& i<g_cant_fant*/);  //por alguna razon si le agrego la condicion que dej‚ comentada no anda
       if(fantasmas[i].color!=g_color_fantasma_muerto) {err(FMNE); return FMNE;} //porlas
       for(j=i;j<g_cant_fant-1;j++) //mueve todos los fantasmas que estan despues del muerto para eliminarlo
	{
	 fantasmas[j]=fantasmas[j+1];
	}
       g_cant_fant--;
       fantasmas[g_cant_fant].color=WHITE; //simplemente un color ilegal para fantasmas, para que no quede tanta basura (paranoia?)
       g_killing_spree++;
       g_puntaje+=PUNTAJE_FANTASMA*g_killing_spree;
       g_color_fantasma_muerto=-1;
       gettime(&t_ultimo_fant);
       imprimir_puntaje=1;
      }
    }
  }while(!g_fin_del_juego);

#ifdef CONWAKA
 nosound(); //detiene el wakawaka
#endif

#ifdef CONMUSICAMUERTE
 if(g_fin_del_juego==2)
  {
   for(i=500;i>100;i--)
    {
     sound(i);
     delay(5);
    }
   nosound();
   sound(700);
   delay(300);
   nosound();
   sound(700);
   delay(300);
   nosound();
  }
#endif

 muestra_titulo();
 muestra_mapa();
 muestra_pastillas();
// muestra_ente(paco);
 for (i=0;i<g_cant_fant;i++)
  muestra_ente(fantasmas[i]);
 muestra_puntaje_y_vidas();
 switch (g_fin_del_juego)
  {
   case 1: printf("\nGANASTE!!"); break;
   case 2: printf("\nperdiste.. y bueh.."); break;
   case 3: printf("\naah, cobarde, no lograste terminar la partida"); break;
  }

 while(!kbhit());
 return 0;

 /* FIN DEL PROGRAMA */

}

/* DEFINICION DE FUNCIONES  */

void mover_ente(struct ente &pj, struct ente otto) //MUEVE AL ENTE EN LA DIRECCION DADA SEGUN SU VELOCIDAD Y SEGUN SEA POSIBLE. CONTROLA EL MOVIMIENTO DE LOS FANTASMAS, EL WAKAWAKA, Y NO ME ACUERDO SI ALGO MAS /nota: esta funcion tb quedo demasiado grande creo
{
 int cant=0, dir=0, ban=0;
 char aux=CHARNULO;
 if(pj.dir>QUIETO && pj.vel>QUIETO)
  {
   cant=valid_mov(pj, otto);
   if (cant>0)
   {
    switch (pj.dir)
     {
      case ARR: pj.x-=cant; break;
      case ABA: pj.x+=cant; break;
      case IZQ: pj.y-=cant; break;
      case DER: pj.y+=cant; break;
     }
   }
  }
 if(pj.q==(char)FANT)     /* controla el movimiento de los fanasmas.. tengo que pensar algo menos frutal.. quizas que sigan al paco.. nose..*/
  {
   switch (pj.dir)
    {
     case ARR: aux=MAPA001[pj.x-1][pj.y]; break;
     case ABA: aux=MAPA001[pj.x+1][pj.y]; break;
     case IZQ: aux=MAPA001[pj.x][pj.y-1]; break;
     case DER: aux=MAPA001[pj.x][pj.y+1]; break;
    }
   if(cant<pj.vel || aux!=CHARNULO)
    {
     dir=pj.dir;
     do
      {
       pj.dir=rand()%MAX_DIR +1;
       switch (pj.dir)
	{
	 case ARR: aux=MAPA001[pj.x-1][pj.y]; break;
	 case ABA: aux=MAPA001[pj.x+1][pj.y]; break;
	 case IZQ: aux=MAPA001[pj.x][pj.y-1]; break;
	 case DER: aux=MAPA001[pj.x][pj.y+1]; break;
	}
      }while(pj.dir==dir && aux!=CHARNULO);
    }
  }
#ifdef CONWAKA
 if(pj.q==(char)PACO)
  if(cant>0)
    g_suena_mueve=1;
  else
   {
    nosound(); //solo debe sonar si se esta moviendo el paco
    g_suena_mueve=0;
   }
#endif
 return;
}

int valid_mov(struct ente pj, struct ente otto) //DEVUELVE CUANTOS CUADROS SE PUEDE MOVER EN LA DIRECCION DADA SIN CHOCARSE /CALCULA LAS COLICIONES DE SER NECESARIO/nota: es un monstro esta funcion ahora
{
 char aux;
 int i=0, cant=0, ban=0;
 int x=pj.x, y=pj.y;
 if(pj.q==(char)FANT && otto.q==(char)PACO)
  if(x==otto.x && y==otto.y)
   if(!g_dopado)
    {
     g_vidas--;
     /* TERMINAR RONDA*/
     if(g_vidas==0) g_fin_del_juego=2; //cuando lo termine posta (cuando implemente varias rondas) esto ya no iria aca
     return 0; //si colisionaron ahi sin moverse devuelve cero
    }
   else
    {
     g_color_fantasma_muerto=pj.color;
    }
 do
  {
   i++;
   switch (pj.dir)
    {
     case ARR: x=pj.x-i; break;
     case ABA: x=pj.x+i; break;
     case IZQ: y=pj.y-i; break;
     case DER: y=pj.y+i; break;
    }
   aux=MAPA001[x][y];
   if(aux!=CHARNULO)  //un ente solo puede caminar a traves de espacio vacio (o pastillas, pero est n en otra matriz)
    ban=1;
   else
    {
     cant=i;
     if((pj.q==(char)PACO) && (pastillas[x][y]!=CHARNULO))
      comer_pastilla(x,y);
     if(pj.q==(char)FANT && otto.q==(char)PACO)
      if(x==otto.x && y==otto.y)
       if(!g_dopado)
	{
	 g_vidas--;
	 /* To Do: TERMINAR RONDA*/
	 if(g_vidas==0) g_fin_del_juego=2; //cuando lo termine posta (cuando implemente varias rondas) esto ya no iria aca
	 return 0; //para que salga sin hacer nada mas
	}
       else
	{
	 g_color_fantasma_muerto=pj.color;
	}
    }
  }while(i<pj.vel && ban==0);
 return (cant);
}

void comer_pastilla(int x, int y) //se come una pastilla y hace lo que tenga que hacer
{
 switch (pastillas[x][y])
  {
   case (char)PAST: g_puntaje+=PUNTAJE_PASTILLA; g_pastillas--; break;
   case (char)SPAS: g_puntaje+=PUNTAJE_SUP_PAST; g_super_pastillas--; gettime(&g_t_com_dopa); g_dopado=1; /* DOPAJE!! */ break;
  }
 pastillas[x][y]=CHARNULO;
 if (g_pastillas==0 && g_super_pastillas==0) g_fin_del_juego=1;
 return;
}

void recibir_input(struct ente &paco) //verfica si se ha pulsado una tecla y realiza la accion que corresponda
{
 int tecla;
 if(kbhit())
  {
   tecla=getch();
   if (tecla==MOV_AR||tecla==MOV_IZ||tecla==MOV_AB||tecla==MOV_DE)
    modif_dir_ente(tecla, paco);
   else
    if (tecla==PAUSA)
     /*p*/;
    else
     if (tecla==SALIR)
      g_fin_del_juego=3;
  }
 return;
}

void modif_dir_ente(int nuevadir, struct ente &pj) //cambia la direccion del ente por la dada
{
 char aux=CHARNULO;
 int dirant=pj.dir;
 switch (nuevadir)
  {
   case MOV_AR: pj.dir=ARR; break;
   case MOV_AB: pj.dir=ABA; break;
   case MOV_IZ: pj.dir=IZQ; break;
   case MOV_DE: pj.dir=DER; break;
  }
 switch (pj.dir)
  {
   case ARR: aux=MAPA001[pj.x-1][pj.y]; break;
   case ABA: aux=MAPA001[pj.x+1][pj.y]; break;
   case IZQ: aux=MAPA001[pj.x][pj.y-1]; break;
   case DER: aux=MAPA001[pj.x][pj.y+1]; break;
  }
 if (aux!=CHARNULO) pj.dir=dirant;
 return;
}

struct ente buscar_ente(char coso) /* DEVUELVE UN ENTE CON EL CARACTER BUSCADO EN SU POSICION (soy malo con las descripciones..)*/
{
 struct ente esto;
 int i=0, j=0;
 for(i=0;i<ALTOMAPA;i++)
  for(j=0;j<ANCHOMAPA;j++)
   if(MAPA001[i][j]==coso)
    {
     esto.q=coso;
     esto.x=i;
     esto.y=j;
     esto.dir=QUIETO;
     esto.vel=esto.def_vel=QUIETO;
     esto.dopa_color=esto.color=esto.def_color=WHITE;
     return esto;
    }
 esto.q='0';
 return esto;
}

int buscar_spawn_paco(struct ente &paco) /* BUSCA EL PUNTO DE SPAWN DEL PACO */
{
 paco=buscar_ente((char)PACO);
 if (paco.q=='0') return 1;
  else
   {
    MAPA001[paco.x][paco.y]=CHARNULO; // quita el simbolo de spawn del mapa
    return 0;
   }
}

int buscar_spawn_fantasma(struct ente &fant) /* BUSCA EL PUNTO DE SPAWN DE LOS FANTASMAS */
{
 fant=buscar_ente((char)SPFN);
 if (fant.q=='0') return 1;
  else return 0;
}

void buscar_pastillas() /* BUSCA TODAS LAS PASTILLAS EN EL MAPA Y LAS CARGA */
{
 int i=0,j=0;
 char aux=CHARNULO;
 for(i=0;i<=ALTOMAPA;i++)
  for(j=0;j<ANCHOMAPA;j++)
   {
    switch(MAPA001[i][j])
     {
      case '1': pastillas[i][j]=(char)PAST;
		g_pastillas++;
		MAPA001[i][j]=CHARNULO;
	       break;
      case '2': pastillas[i][j]=(char)SPAS;
		g_super_pastillas++;
		MAPA001[i][j]=CHARNULO;
	       break;
      default:  pastillas[i][j]=CHARNULO;
	       break;
     }
   }
 return;
}

void crear_fant(struct ente &fantasma, int& color, struct ente spawn) /*CREA E INICIALIZA A UN FANTASMA*/
{
char aux=MAPA001[spawn.x-1][spawn.y];
 if (g_cant_fant<MAXFANTASMAS)
  if(aux==CHARNULO)
   {
    fantasma.q=(char)FANT;
    fantasma.x=spawn.x-1; //osea que lo crea una posicion arriba de el punto de spawn
    fantasma.y=spawn.y;
    fantasma.dir=rand()%4 +1; //sin el +1 podria dar 0, que es quieto
    fantasma.vel=fantasma.def_vel=rand()%MAX_VEL_FANT +1; //sin el +1 podria dar 0, que es el quieto
    color++;
    fantasma.color=fantasma.def_color=color;
    fantasma.dopa_color=FANT_DOPA_COLOR;
    g_cant_fant++;
   }
  //else /*no se pudo crear el fantasma debido a que el espacio sobre el punto de spawn estaba ocupado */
 //else /*no se pudo crear el fantasma debido a que ya se ha llegado al maximo de fantasmas*/
 return;
}

void crear_paco(struct ente &paco, struct ente spawn) /*CREA E INICIALIZA AL PACO*/
{
 paco.q=(char)PACO;
 paco.x=spawn.x;
 paco.y=spawn.y;
 paco.dir=PACO_DEF_DIR;
 paco.vel=paco.def_vel=PACO_DEF_VEL;
 paco.color=paco.def_color=PACO_DEF_COLOR;
 paco.dopa_color=PACO_DOPA_COLOR;
 return;
}


void err(int horror)              /* MANEJA LOS ERROES DEL PROGRAMA */
{
 clrscr();
 switch(horror)
  {
   case PSNF:  printf("\n\nERROR %d: no se encontro el punto de spawn del paco en el mapa",PSNF); break;
   case FSNF:  printf("\n\nERROR %d: no se encontro el punto de spawn del fantasma en el mapa",FSNF); break;
   case PANF:  printf("\n\nERROR %d: no se encontro ninguna pastilla en el mapa",PANF); break;
   case SPANF: printf("\n\nERROR %d: no se encontro ninguna superpastilla en el mapa",SPANF); break;
   case MFDG:  printf("\n\nERROR %d: el maximo de fantasmas existentes es mayor a la cantidad de colores posibles",MFDG); break;
   case FMNE:  printf("\n\nERROR %d: sucedio fruta al tratar de matar un fantasma",FMNE); break;
  }
 getche();
 return;
}

void muestra_titulo()   /* LIMPIA LA PANTALLA Y MUESTRA EL TITULO */
{
 textbackground(BLACK);
 textcolor(WHITE);
 clrscr();
 textbackground(BLUE);
 textcolor(YELLOW);
 //gotoxy(20,1); cprintf("*******************************");
 gotoxy(22,2); cprintf("******                   ******");
 //gotoxy(20,3); cprintf("*******************************");
 textcolor(YELLOW + BLINK);
 gotoxy(29,2); cprintf("PACOMAN %s",PACOVER);
 gotoxy(POS_INI_X,POS_INI_Y);//deja el cursor en un lugar comodo para continuar con el juego
 textbackground(BLACK); //deja el fondo estandar
 textcolor(WHITE);      //deja la fuente estandar
 return;
}

void muestra_mapa()     /* MUESTRA EL MAPA EN PANTALLA */
{
 textcolor(COLOR_MAPA);
 gotoxy(POS_INI_X,POS_INI_Y);
 int i=0, j=0;
 for(i=0;i<ALTOMAPA;i++)
  {
   for(j=0;j<ANCHOMAPA;j++)
    {
     cprintf("%c",MAPA001[i][j]);
    }
   printf("\n");
  }
 textcolor(WHITE);
 return;
}

void muestra_pastillas()     /* MUESTRA LAS PASTILLAS EN PANTALLA */
{
 textcolor(COLOR_PASTILLAS);
 int i=0, j=0;
 for(i=0;i<ALTOMAPA;i++)
  {
   for(j=0;j<ANCHOMAPA;j++)
    {
     if(pastillas[i][j]!=CHARNULO) //PORUQE ENTRA SI ES FALSO?!?!?
      {
       gotoxy(POS_INI_X+j,POS_INI_Y+i);
       cprintf("%c",pastillas[i][j]);
      }
    }
  }
 textcolor(WHITE);
 return;
}

void muestra_puntaje_y_vidas()
{
 textcolor(COLOR_TEXTO);
 gotoxy(POS_INI_X,POS_INI_Y+ALTOMAPA); //justo debajo del mapa
 printf("PUNTAJE: %d\t\tVIDAS: %d", g_puntaje, g_vidas);
 textcolor(WHITE);
 return;
}

void muestra_instrucciones()
{
 textcolor(COLOR_TEXTO);
 gotoxy(POS_INI_X,POS_INI_Y+ALTOMAPA+1); //debajo del puntaje
 cprintf("Movimiento: Arriba:\'%c\' Izquierda:'\%c' Abajo:\'%c\' Derecha\'%c\' Salir:\'%c\'", MOV_AR, MOV_IZ, MOV_AB, MOV_DE, SALIR/*, PAUSA*/);
 textcolor(WHITE);
 return;
}

void muestra_ente(struct ente pj) /* MUESTRA AL ENTE DADO EN SU POSICION Y CON SU COLOR */
{
 if(g_dopado)
  textcolor(pj.dopa_color);
 else
  textcolor(pj.color);           //el color adecuado para el ente
 gotoxy(POS_INI_X+pj.y,POS_INI_Y+pj.x); //en las posicion adecuada dentro del mapa //nota:las x y las y cambiadas porque ni ganas de modificar todo el resto del codigo
 cprintf("%c",pj.q);
 textcolor(WHITE); // para continuar tranquilo con el resto del programa
 return;
}

/*Teh end*/

BTW, I will not accept a "TRWTF is that all the code is in spanish" type of answer.

PS: yeah, I realize I'm "redrawing" everything on the screen and that it actually has a performance hit in some not-so-old computers (I remember a sort of matrix-effect happening when executed full screen on a hp notebook with a 1GHz proccessor). Plus the game runs at a solid 1 FPS, nice uh?

ZippoLag

Holy crap!

I've just spent the last 5 minutes reading this again and, not only I have noticed some stuff that I didn't remember, but I actually now hope that no one in the forums knows spanish or I¡ll be really embarrassed :S:S

Hitsuji

OK I'm a little drunk atm but:

Bar TRWTF of it being in spanish, I would initially just say add some whitespace. The extra return characters do help logically break up code and make it a lot more readable.

secondly I dislike things like paco.vel=paco.def_vel=PACO_DEF_VEL;

much easier to read:

paco.vel = PACO_DEF_VEL;

paco.def_vel = PACO_DEF_VEL;

yes in theory it should compile/run better, but you shoud be able to rely on the compiler to optimise such code.

Secondy, since I can't really be too arsed to completely go over the code why the hell does two members of a struct/class have to be set to the same value? Although i'm guessing def == default.

With your comments some can be put before the code (particularly before functions). Much mre readble, I initially browsed through and thought there are no comments, then saw them afterwards.

Code like (t_sedif<0)?t_sedif=-t_sedif:1; is more readable as

(t_sedif < 0) ? t_sedif = -t_sedif : 1;

The whitespace helps alot.

Just remember readabilty is one of the most important thing when it comes to code.

Hitsuji

More drunken rants:

ok things like:

//gotoxy(20,1); cprintf("*******************************");
gotoxy(22,2); cprintf("****** ******");
//gotoxy(20,3); cprintf("*******************************");

is not good unless you give a reason to coment out such code

AND with tools availabe to us these days such as intellisence i always try to use names such as default over def

ZippoLag

@Hitsuji said:

*burp*

lmao, maybe you should be sleeping rather than reading TDWTF?

anyway, 'def' is for 'deault', I assign it to 2 different vars because one is the one that I use when I have to make the pacoman move, and the other is the default speed, you see, there's also another speed, the speed when the pacoman is high on pills.

I usually use withspce an comments properly, but the damn blue screen and yellow letters had me a bit crazy at the moment I guess.

those commented printf's were for .. displaying the title of the game I think, it makes sense if you compile/run this thing. Also if you open it in some old DOS based C/C++ compiler -like the one I used- the code atually looks pretier.-

ps: intellisece?! BLUE SCREEN AND YELLOW LETTERS MATE!

ps2: idk why I yelled, I hope you tell me the worse WTF you can find there when you wake up fresh. Anyway, thanks.-

Hitsuji

And this post because HTML view is now disabled when posting apparently.

Particularly with c++ or c if i was initialising a set of variables at once or even just setting then i would try to align the operators, again for readiblity, such as instead of:

    fantasma.q=(char)FANT;
    fantasma.x=spawn.x-1; //osea que lo crea una posicion arriba de el punto de spawn
    fantasma.y=spawn.y;
    fantasma.dir=rand()%4 +1; //sin el +1 podria dar 0, que es quieto
    fantasma.vel=fantasma.def_vel=rand()%MAX_VEL_FANT +1; //sin el +1 podria dar 0, que es el quieto
    color++;
    fantasma.color=fantasma.def_color=color;
    fantasma.dopa_color=FANT_DOPA_COLOR;




I always prefer:




    color++;
    fantasma.q           = (char) FANT;
    fantasma.x           = spawn.x - 1;                                                        //osea que lo crea una posicion arriba de el punto de spawn
    fantasma.y           = spawn.y;
    fantasma.dir         = (rand() % 4) + 1;                                                    //sin el +1 podria dar 0, que es quieto
    fantasma.vel         = (rand() % MAX_VEL_FANT) + 1;
    fantasma.def_vel     = (rand() % MAX_VEL_FANT) + 1;   //sin el +1 podria dar 0, que es el quieto
    fantasma.color       = color;
    fantasma.def_color   = color;
    fantasma.dopa_color  = FANT_DOPA_COLOR;

ZippoLag

mhmh yup, ~~I guess that's more readable~~ that's quite easier to read, but still, the original code was not wtf-worthy.-

morbiuswilters

FUCK. Sites like pastebin will let you throw up large sections of code and they have syntax highlighting so you don't need to make a 5 page post into the thread.

ZippoLag

I wasn't really sure how to post it, ifupload the .cpp file into rpidshare or what, I would normally use a spoiler tag, but I don't think this forum has them?

ZippoLag

there, If there were a magic/ninja way to edit my first post, I would delete all that code and simply point to this:

PASTEBIN PASTEBIN PASTEBIN

morbiuswilters

@ZippoLag said:

there, If there were a magic/ninja way to edit my first post, I would delete all that code and simply point to this:

PASTEBIN PASTEBIN PASTEBIN

It's cool, just keep it in mind for future reference. I'm not going to pore over half a dozen pages of code with no syntax highlighting. If your code snippet is longer than a dozen or so lines, consider linking to an external source.

CodeWhisperer

@ZippoLag said:

#ifdef CONWAKA
nosound(); //detiene el wakawaka
#endif

That gave me a much-needed laugh for the day, thanks :)

-cw

ZippoLag

@morbiuswilters said:

It's cool, just keep it in mind for future reference. I'm not going to pore over half a dozen pages of code with no syntax highlighting. If your code snippet is longer than a dozen or so lines, consider linking to an external source.

Noted for the future.

@CodeWhisperer said:

@ZippoLag said:
#ifdef CONWAKA
nosound(); //detiene el wakawaka
#endif

That gave me a much-needed laugh for the day, thanks :)

-cw

there are one or two purposedly humoristic lines around the code, I'm glad you found that one -tho it's actually functional code-.

This afternoon or tomorrow I'll try and translate th whole thing -code & comments- so this post can actually be understood by someone, I of course will limit myself to the lineal translation and not remove/add any wtfish code.

ZippoLag

alrighty then, I've translated the comments in case anyone wishes to see it.

HERE

ps: I DO NOT CLAIM MY PACOMAN TO BE BETTER THAN THE ORIGINAL PACMAN. Just in case anyone was thinking I'm morphing into some kind of spetate.

antred

You're using deprecated headers. Should be:

#include <cstring>
#include <cstdio>
#include <cstdlib>