Flare random collision map

/*

1st: A simple cave map radomly generated. Blank fields are the room, zeros are caverock

Array printout:
      0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18

0     0  0  0  0  0  0  0  0  0     0  0  0  0  0  0  0  0  0
1     0  0  0  0  0  0  0                 0  0  0  0  0  0  0
2     0  0  0  0  0  0  0                 0  0  0  0  0  0  0
3     0  0  0  0  0  0  0     0  0  0  0  0  0  0  0  0  0  0
4     0  0  0  0  0  0  0     0  0  0  0  0  0  0  0  0  0  0
5     0  0  0  0  0  0              0  0  0  0  0  0  0  0  0
6     0  0  0  0  0  0              0  0  0  0  0  0  0  0  0
7     0  0  0  0  0  0              0  0  0  0  0  0  0  0  0
8     0  0  0  0  0  0              0  0  0  0  0  0  0  0  0
9     0  0  0  0  0  0     0  0  0  0  0  0  0  0  0  0  0  0
10    0  0  0  0  0  0     0  0  0  0  0  0  0  0  0  0  0  0
11    0  0  0  0              0  0  0  0  0  0  0  0  0  0  0
12    0  0  0  0              0  0  0  0  0  0  0  0  0  0  0
13    0  0  0  0                 0  0  0  0  0  0  0  0  0  0
14    0  0  0  0                 0  0  0  0  0  0  0  0  0  0
15    0  0  0  0     0  0  0  0  0  0  0  0  0  0  0  0  0  0
16    0  0  0  0     0  0  0  0  0  0  0  0  0  0  0  0  0  0

2nd: It identifies the wall tiles (1) in general

Array printout:
      0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18

0     0  0  0  0  0  0  1  1  1     1  1  1  0  0  0  0  0  0
1     0  0  0  0  0  0  1                 1  0  0  0  0  0  0
2     0  0  0  0  0  0  1                 1  0  0  0  0  0  0
3     0  0  0  0  0  0  1     1  1  1  1  1  0  0  0  0  0  0
4     0  0  0  0  0  1  1     1  1  1  0  0  0  0  0  0  0  0
5     0  0  0  0  0  1              1  0  0  0  0  0  0  0  0
6     0  0  0  0  0  1              1  0  0  0  0  0  0  0  0
7     0  0  0  0  0  1              1  0  0  0  0  0  0  0  0
8     0  0  0  0  0  1              1  0  0  0  0  0  0  0  0
9     0  0  0  0  0  1     1  1  1  1  0  0  0  0  0  0  0  0
10    0  0  0  1  1  1     1  1  0  0  0  0  0  0  0  0  0  0
11    0  0  0  1              1  0  0  0  0  0  0  0  0  0  0
12    0  0  0  1              1  1  0  0  0  0  0  0  0  0  0
13    0  0  0  1                 1  0  0  0  0  0  0  0  0  0
14    0  0  0  1                 1  0  0  0  0  0  0  0  0  0
15    0  0  0  1     1  1  1  1  1  0  0  0  0  0  0  0  0  0
16    0  0  0  1     1  0  0  0  0  0  0  0  0  0  0  0  0  0

3rd: Wall tiles are sorted by their tile type (straight/edges, facing up/down etc). Still a bit buggy though.

Array printout:
      0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18

0                       U  w  j     i  w  u
1                       L                 R
2                       L                 R
3                       L     I  W  W  W  d
4                    U  j     i  w  R
5                    L              R
6                    L              R
7                    L              R
8                    L              R
9                    L     I  W  W  d
10             U  w  j     i  R
11             L              R
12             L              i  u
13             L                 R
14             L                 R
15             L     I  W  W  W  d
16             D     R
*/
//code starts here:

#include <iostream>
#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */
using namespace std;

const int MaxX=19;
const int MaxY=17;


void printMyArray(char text[MaxX][MaxY])
{
    int x, y;
    cout << "Array printout:";
    cout << endl;
    // Axis descr
    cout << "      0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18" << endl;
    cout << endl;
    for (y=0; y<MaxY; y++)
    {
        if (y<10)
            cout << y << "   ";
        else
            cout << y << "  ";

        // MapOne Anzeige
        for (x=0; x<MaxX; x++)
        {
            cout << "  " << text[x][y];
        }
        cout << endl;
    }
    cout << endl;
}

int main()
{
    char MapGen[MaxX][MaxY];
    char MapOne[MaxX][MaxY];
    char MapTwo[MaxX][MaxY];
    int x, y;
    int tunnelsize;
    int varyStart;
    int i, j;
    int beginEdit;
    int start;
    char roomSpace = ' ';

    /* initialize random seed: */
    srand (time(NULL));

    // fill Maps
    for (y=0; y<MaxY; y++)
    {
        for (x=0; x<MaxX; x++)
        {
            MapGen[x][y] = '0';
            MapOne[x][y] = '0';
        }
    }

    // Legend:
    // 1 = Wall
    // " " = Room
    // 0 = Void

    // ======================================
    // Simple cave generation on my MapGen
    // ======================================
    MapGen[9][0] = roomSpace;

    for (y=1; y<MaxY-2; y++)
    {
        beginEdit=0;
            for (x=0; x<MaxX; x++)
            {
                // connect to previous cave space
                if(MapGen[x][y-1]==roomSpace && beginEdit==0)
                {
                    tunnelsize = rand() % 5;
                    cout << tunnelsize;
                    varyStart = rand() % 5;
                    if(tunnelsize>varyStart)
                        start=x-tunnelsize+varyStart;
                    else
                        start=x;

                    for (i=0; i<tunnelsize+1; i++)
                        {
                            if ( start+i <MaxX-1 && start+i > 1)
                            {
                                MapGen[start+i][y]= roomSpace;
                                MapGen[start+i][y+1]= roomSpace;
                            }
                        }
                    y=y+1;
                    beginEdit=1;
                }
            }
    }

    // y==MaxY
    for (x=0; x<MaxX; x++)
        {
            if(MapGen[x][MaxY-3]==roomSpace)
                {
                    MapGen[x][MaxY-2]= roomSpace;
                    MapGen[x][MaxY-1]= roomSpace;
                    break;
                }
        }


    cout << "MapGen" << endl;
    printMyArray(MapGen);

    // MapGen gets some Walls
    for (y=0; y<MaxY; y++)
    {
        for (x=0; x<MaxX; x++)
        {
            // First line (careful about <0 )
            if( MapGen[x][y]=='0' && y==0 )
            {
                if ( MapGen[x+1][y]==roomSpace ||  MapGen[x-1][y]==roomSpace ||  MapGen[x][y+1]==roomSpace )
                        MapOne[x][y]='1';
                if ( MapGen[x+1][y+1]==roomSpace || MapGen[x-1][y+1]==roomSpace )
                        MapOne[x][y]='1';
            }
            // last line (careful about >MaxY )
            else if( MapGen[x][y]=='0' && y==MaxY-1 )
            {
                if ( MapGen[x+1][y]==roomSpace || MapGen[x-1][y]==roomSpace || MapGen[x][y-1]==roomSpace)
                        MapOne[x][y]='1';
                if ( MapGen[x-1][y-1]==roomSpace ||  MapGen[x+1][y-1]==roomSpace)
                        MapOne[x][y]='1';
            }
            // all other lines / Walls
            else if( MapGen[x][y]=='0' && y!=MaxY && y!=0 )
            {
                if ( MapGen[x+1][y]==roomSpace ||  MapGen[x-1][y]==roomSpace ||  MapGen[x][y+1]==roomSpace ||  MapGen[x][y-1]==roomSpace)
                        MapOne[x][y]='1';
                if ( MapGen[x+1][y+1]==roomSpace ||  MapGen[x-1][y-1]==roomSpace ||  MapGen[x-1][y+1]==roomSpace ||  MapGen[x+1][y-1]==roomSpace)
                        MapOne[x][y]='1';
            }
            if(MapGen[x][y]==roomSpace)
                MapOne[x][y]=roomSpace;
        }
    }

    cout << "MapOne" << endl;
    printMyArray(MapOne);


    // ======================================
    // Change MapOne to Wall Map aka MapTwo
    // ======================================
    for (y=0; y<MaxY; y++)
    {
        for (x=0; x<MaxX; x++)
        {
            if(MapOne[x][y]=='1')
            {
                // Wall left (left is void)
                if(MapOne[x-1][y]=='0')
                {
                    //Wall Edge left up
                    if(MapOne[x][y-1]=='0')
                        MapTwo[x][y]='U';
                    // Wall Edge left down
                    if(MapOne[x][y+1]=='0')
                        MapTwo[x][y]='D';
                    // Wall left
                    if(MapOne[x][y+1]!='0' && MapOne[x][y-1]!='0')
                        MapTwo[x][y]='L';
                }

                // Wall right (right is void)
                if(MapOne[x+1][y]=='0')
                {
                    //Wall Edge right up
                    if(MapOne[x][y-1]=='0')
                        MapTwo[x][y]='u';
                    // Wall Edge right down
                    if(MapOne[x][y+1]=='0')
                        MapTwo[x][y]='d';
                    // Wall right
                    if(MapOne[x][y+1]!='0' && MapOne[x][y-1]!='0')
                        MapTwo[x][y]='R';
                }
                // Wall up (down is room, left right is wall)
                if( MapOne[x][y+1]==roomSpace && MapOne[x+1][y]=='1' && MapOne[x-1][y]=='1' )
                    MapTwo[x][y]='w';
                // Wall down (up is room, left right is wall)
                if( MapOne[x][y-1]==roomSpace && MapOne[x+1][y]=='1' && MapOne[x-1][y]=='1' )
                    MapTwo[x][y]='W';

                // Wall INVERTED Edge left up
                if( MapOne[x-1][y-1]==roomSpace && MapOne[x][y-1]==roomSpace && MapOne[x-1][y]==roomSpace )
                    MapTwo[x][y]='I';
                // Wall INVERTED Edge left down
                if( MapOne[x-1][y+1]==roomSpace && MapOne[x][y+1]==roomSpace && MapOne[x-1][y]==roomSpace )
                    MapTwo[x][y]='i';
                // Wall INVERTED Edge right up
                if( MapOne[x+1][y-1]==roomSpace && MapOne[x][y-1]==roomSpace && MapOne[x+1][y]==roomSpace )
                    MapTwo[x][y]='J';
                // Wall INVERTED Edge right down
                if( MapOne[x+1][y+1]==roomSpace && MapOne[x][y+1]==roomSpace && MapOne[x+1][y]==roomSpace )
                    MapTwo[x][y]='j';
            }
            else
            {
                MapTwo[x][y]=' ';
            }
        }
    }

    // MapTwo Anzeige
    cout << "MapTwo" << endl;
    printMyArray(MapTwo);
    return 0;
}