SDLTest/maze.c

   1 //vomitado por Eriiiiiic dominio público-púbico
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <time.h>
   6
   7 //declaraciones pendejas globales
   8 //dimensiones cabronas
   9 #define columnas 10
  10 #define renglones 5
  11
  12 //tamaño imbecil del laberinto a dibujar idiota
  13 #define mazeCol 21
  14 #define mazeRow 11
  15
  16 //puto laberinto y sus caminos
  17 int maze[renglones][columnas][4];
  18
  19 //inicialización de movimientos de mierda a dibujar
  20 int row[4];
  21 int column[4];
  22
  23
  24 //puto arreglo para dibujar un inutil laberinto con pinche ASCII
  25 int mazeDraw[mazeRow][mazeCol];
  26
  27 //puta posicion actual (x,y)
  28 int posMazeX = 1;
  29 int posMazeY = 0;
  30
  31 void init(){
  32
  33 srand(time(NULL));
  34
  35 for (int i = 0; i < renglones; i++){
  36         for (int j = 0; j < columnas; j++){
  37                 for (int k = 0; k < 4; k++){
  38                         maze[i][j][k] = -1;
  39                 }
  40         }
  41 }
  42
  43 //reglon (en x de la chingada)
  44 row[0] = -1;
  45 row[1] = 0;
  46 row[2] = 1;
  47 row[3] = 0;
  48 //columna (en y de la chingada)
  49 column[0] = 0;
  50 column[1] = 1;
  51 column[2] = 0;
  52 column[3] = -1;
  53
  54 for (int i = 0; i < mazeRow; i++){
  55         for (int j = 0; j < mazeCol; j++){
  56                 mazeDraw[i][j] = 0;
  57         }
  58 }
  59
  60 }
  61
  62 //vómito de laberinto
  63 void mazeFuck(int posX, int posY){
  64         //inicializa bandera de cagada validez
  65         int flag = 1;
  66         int x = 0;
  67         //mientras hayan movimeintos de mierda válidos
  68         while(flag){
  69
  70                 int valido[4];
  71                 int cuenta = 0;
  72                 //chequeo de casillas válidas imbecil
  73                 for (int i = 0; i < 4; i++){
  74                         //verifica que este adentro del maldito arreglo
  75                         if ( (posX + row[i] >= 0) && (posY + column[i] >= 0) &&
  76                                 (posX + row[i] < renglones) &&
  77                         (posY + column[i] < columnas) ){
  78                         //verifica que no este recorrida la puta posición
  79                                 if ( maze[posX + row[i]][posY + column[i]][0] == -1 ){
  80                                         //guarda movimientos de mierda válidos
  81                                         valido[cuenta++]=i;
  82                                 }
  83
  84                         }
  85                 }
  86                 // no me caso de poner comentarios de la verga
  87                 //si hay movimientos de mierda válidos
  88                 if (cuenta != 0){
  89                         //elige un valor de mierda válido al chile (random)
  90                         int movPos = valido[rand() % cuenta];
  91                         maze[posX][posY][x++] = movPos;
  92
  93                         //recursion!!!!
  94                         mazeFuck(posX + row[movPos], posY + column[movPos]);
  95
  96                 }else{
  97                         //si no hay, bla bla dice: "FLAG! no mames, eres falso, salte del puto while
  98                         flag = 0;
  99                 }
 100         }
 101 }
 102
 103
 104 void printMaze(){
 105         //la recorro a la puta
 106         for (int i = 0; i < mazeRow; i++){
 107                 for (int j = 0; j < mazeCol; j++){
 108                                 printf("%d", mazeDraw[i][j]);
 109                 }
 110                 printf("\n");
 111         }
 112 }
 113
 114 void printPath(){
 115         //la recorro a la puta
 116         for (int i = 0; i < renglones; i++){
 117                 for (int j = 0; j < columnas; j++){
 118                         for (int k = 0; k < columnas; k++){
 119                                 printf("%d", maze[i][j][k]);
 120                         }
 121                         printf("        ");
 122                 }
 123                 printf("\n");
 124         }
 125 }
 126
 127
 128 //dibuja perra!!!!
 129 void drawMaze(){
 130
 131         //genera el laberinto y sus caminos de la chingada
 132         mazeFuck(0, 0);
 133         //se inicializa con algun caracter cagada
 134         for (int i = 0; i < mazeRow; i++){
 135                 for (int j = 0; j < mazeCol;  j++){
 136                         mazeDraw[i][j] = 0;
 137                 }
 138         }
 139
 140         //harcodea entrada y salida, que pendejo y webon
 141         mazeDraw[1][0] = 1;
 142         mazeDraw[renglones - 2][columnas - 1]= 1;
 143
 144         //recorre al arreglo lameculos para dibujar el putillo recorrido
 145         for (int x = 0; x < renglones; x++){
 146                 for (int y = 0; y < columnas; y++){
 147                         for(int z = 0; z < 4; z++){
 148                                 //si el putin valor es -1 no tumba pared
 149                                 if(maze[x][y][z] != -1){
 150                                         //guarda el mierda de valor del movimiento
 151                                         int tempr = row[ maze[x][y][z] ];
 152                                         int tempc = column[ maze[x][y][z] ];
 153                                         int posR = 2*x + 1;
 154                                         int posC = 2*y + 1;
 155                                         //pinta caminillo hijo de puta en posicion actual, +1 y +2 en respecputamente
 156                                         mazeDraw[posR][posC] = 1;
 157                                         mazeDraw[ posR + tempr ][ posC + tempc ] = 1;
 158                                         mazeDraw[ posR + 2*tempr ][ posC + 2*tempc ] = 1;
 159                                 }
 160                         }
 161                 }
 162         }
 163
 164         //imprime el laberinto pinche cabron
 165         //printMaze();
 166 }
 167
 168 void main(){
 169         init();
 170         drawMaze();
 171         printPath();
 172 }