multi-generation of maps

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

int mapid, maxa, maxb, a, b;
int pa, pb, paa, pbb;
int over = 0;
int map[35][21][20];
int wall_list[21][20];
int road_list[210];
int road_count = 0;

// 미로 생성 관련 함수 :
// int mapprnt(), int mapprnt_p(), int wall_check(int a, int b, int type)
// int outer_check(int a, int b), int road(int a, int b), int mazegen(int ma, int mb)
int mapprnt(int id)
// map[mapid][a][b] 에 대한 전체 맵 출력.
{
    int a,b;
    for (a = 1 ; a < sizeof(map[0]) / sizeof(map[0][0]) ; a++)
    { // 헤더 부분을 출력하지 않도록 a = 1 로 설정
        for (b = 0; b < sizeof(map[0][0]) / sizeof(map[0][0][0]) ; b++)
        {
            switch (map[id][a][b])
            {
                case 0 : printf ("  "); break;
                case 1 : printf ("[]"); break;
                case 2 : printf ("M "); break;
                case 3 : printf ("UP"); break;
                case 4 : printf ("DN"); break;
                case 8 : printf ("# "); break;
                default :
                if (map[id][a][b] >= 100 && map[id][a][b] < 200)
                {
                    printf ("@ ");
                }
                if (map[id][a][b] >= 1000)
                {
                    printf ("%% ");
                }
                break;
            }
        }
        printf ("\n");
    }
    printf ("\n");
    return 0;
}
int mapprnt_p(int id)
// map[mapid][a][b] 에 대한 전체 맵 출력. 플레이어 4방향 3칸까지만 보이게 출력.
// 나머지 보이지 않는 영역은 || 로 표시한다.
{
    int a,b;
    for (a = 1 ; a < sizeof(map[0]) / sizeof(map[0][0]) ; a++)
    { // 헤더 부분을 출력하지 않도록 a = 1 로 설정
        for (b = 0; b < sizeof(map[0][0]) / sizeof(map[0][0][0]) ; b++)
        {
            if (a >= pa-3 && a <= pa+3 && b >= pb-3 && b <= pb+3)
            {
                switch (map[id][a][b])
                {
                    case 0 : printf ("  "); break;
                    case 1 : printf ("[]"); break;
                    case 2 : printf ("M "); break;
                    case 3 : printf ("UP"); break;
                    case 4 : printf ("DN"); break;
                    case 8 : printf ("# "); break;
                    default :
                    if (map[id][a][b] >= 100 && map[id][a][b] < 200)
                    {
                        printf ("@ ");
                    }
                    if (map[id][a][b] >= 1000)
                    {
                        printf ("%% ");
                    }
                    break;
                }
            }
            else
            {
                printf ("||");
            }
        }
        printf ("\n");
    }
    printf ("\n");
    return 0;
}
int mapp (int id, int sight)
{
    switch (sight)
    {
        case 0 : mapprnt_p(id); break;
        case 1 : mapprnt(id); break;
    }
    return 0;
}
int wall_check(int id, int a, int b, int type)
// 선택된 좌표 a,b 의 주변 벽이 몇 개인지 세어 그 수를 반환함.
// type = 1이면 주변 벽들을 벽 리스트에 저장함.
// type = 2이면 외곽 벽의 개수를 반환함.
{
    if (type != 2)
    {
        int count = 0;
        if (map[id][a][b+1] == 1)
        {
            count++;
            if (type == 1 && wall_list[a][b+1] != 2)
            {
                wall_list[a][b+1] = 1;
            }
        }
        if (map[id][a][b-1] == 1)
        {
            count++;
            if (type == 1 && wall_list[a][b-1] != 2)
            {
                wall_list[a][b-1] = 1;
            }
        }
        if (map[id][a+1][b] == 1)
        {
            count++;
            if (type == 1 && wall_list[a+1][b] != 2)
            {
                wall_list[a+1][b] = 1;
            }
        }
        if (map[id][a-1][b] == 1)
        {
            count++;
            if (type == 1 && wall_list[a-1][b] != 2)
            {
                wall_list[a-1][b] = 1;
            }
        }
        return count;
    }
    else if (type == 2)
    {
        int outer_count = 0;
        if (wall_list[a][b+1] == 2)
        {
            outer_count++;
        }
        if (wall_list[a][b-1] == 2)
        {
            outer_count++;
        }
        if (wall_list[a+1][b] == 2)
        {
            outer_count++;
        }
        if (wall_list[a-1][b] == 2)
        {
            outer_count++;
        }
    return outer_count;
    }
}

int outer_check(int a, int b)
// 선택된 좌표 a,b 의 주변 외곽이 몇 개인지 세어 그 수를 반환함.
{
    int count = 0;
    if (wall_list[a][b+1] == 2)
    {
        count++;
    }
    if (wall_list[a][b-1] == 2)
    {
        count++;
    }
    if (wall_list[a+1][b] == 2)
    {
        count++;
    }
    if (wall_list[a-1][b] == 2)
    {
        count++;
    }
    return count;
}

int road(int id, int a, int b)
// 현 좌표가 길이면 길 리스트에 저장함.
// (a, b) 를 a*100 + b 형태로 저장한다. [(2,3) 의 경우 203으로 저장됨]
{
    if (map[id][a][b] == 0)
    {
        road_list[road_count] = a*100 + b;
    }
    road_count++;
}

int mazegen(int id, int ma, int mb)
// 미로 생성 함수. Prim's Algorithm 에 의해 미로를 랜덤으로 생성한다.
{
    int temp_a, temp_b, done, s_i, s_j, s_k, s_l;
    map[id][0][0] = 1; // 맵 헤더의 랜덤 생성 여부에 체크
    do
    {
        done = 0;
        switch (rand() % 4)
        {
            case 0 : temp_a = ma-1; temp_b = mb; s_i = 1; break;
            case 1 : temp_a = ma; temp_b = mb+1; s_l = 1; break;
            case 2 : temp_a = ma+1; temp_b = mb; s_k = 1; break;
            case 3 : temp_a = ma; temp_b = mb-1; s_j = 1; break;
        }
        if (map[id][temp_a][temp_b] == 1 && wall_list[temp_a][temp_b] != 2)
        {
            if (wall_check(id, temp_a, temp_b, 0) == 3)
            {
                map[id][temp_a][temp_b] = 0;
                wall_list[temp_a][temp_b] = 0;
                ma = temp_a; mb = temp_b;
                wall_check(id,ma,mb,1);
                road (id,ma,mb);
                s_i = 0; s_l = 0; s_k = 0; s_j = 0;
            }
        }
        else if (temp_a != ma && temp_b != mb)
        {
            temp_a = ma; temp_b = mb;
        }
        else
        {
        }
        if (s_i == 1 && s_j == 1 && s_k == 1 && s_l == 1)
        {
            done = 1;
        }
        if (wall_check(id, temp_a, temp_b, 2) != 0)
        {
            done = 1;
        }

    } while (done == 0);
    return 0;
}

int move()
// 플레이어 캐릭터 (@) 의 이동 관련 함수.
// i : UP, j : LEFT, k : DOWN, l : RIGHT, Q : QUIT 에 대응.
// 여기선 getch() 를 쓸 수 없으니 scanf("%c", &key); 로 대신한다.
{
    char key;
    scanf("%c", &key);
    switch ((int)key)
    {
        case 105 :
            paa = pa-1; pbb = pb; break;
        case 106 :
            paa = pa; pbb = pb-1; break;
        case 107 :
            paa = pa+1; pbb = pb; break;
        case 108 :
            paa = pa; pbb = pb+1; break;
        case 81 :
            printf ("Quit\n"); over = 1; break;
    }
    if (map[mapid][paa][pbb] != 1 && paa >= 1 && paa < sizeof(map[0]) / sizeof(map[0][0]) && pbb >= 0 && pbb < sizeof(map[0][0]) / sizeof(map[0][0][0]))
    {
        if (map[mapid][paa][pbb] == 8)
        {
            printf ("* : That's Portal!\n");
            mapid++;
        }
        if (pa != paa || pb != pbb)
        {
            map[mapid][paa][pbb] += 100;
            map[mapid][pa][pb] = map[mapid][pa][pb] % 100;
        }
        pa = paa; pb = pbb;
    }
    else
    {
        printf ("* : can't move\n");
        paa = pa; pbb = pb;
    }
    mapprnt(mapid);
    return 0;
}

int e_move(int id, int e_a, int e_b)
{
    int temp_a, temp_b;
    switch (rand() % 4) //랜덤 이동
    {
        case 0 :
            temp_a = e_a - 1; temp_b = e_b; break;
        case 1 :
            temp_a = e_a + 1; temp_b = e_b; break;
        case 2 :
            temp_a = e_a; temp_b = e_b + 1; break;
        case 3 :
            temp_a = e_a; temp_b = e_b - 1; break;
    }
    if (map[id][temp_a][temp_b] != 1 && temp_a >= 1 && temp_a < sizeof(map[0]) / sizeof(map[0][0]) && temp_b >= 0 && temp_b < sizeof(map[0][0]) / sizeof(map[0][0][0]))
    {
        if (e_a != temp_a || e_b != temp_b)
        {
            map[id][temp_a][temp_b] += 1000;
            map[id][e_a][e_b] = map[id][e_a][e_b] % 1000;
        }
        e_a = temp_a; e_b = temp_b;
    }
    else
    {
        temp_a = e_a; temp_b = e_b;
    }
    return e_a * 100 + e_b;
}

int mapgen()
{
    int i,j,k;
    int w_i, w_k;
    int m,n;
    int ra, rb;
    int up, dn;
    int up_a, up_b, dn_a, dn_b;
    int mazegen_count;

    for (i = 0 ; i < sizeof(map) / sizeof(map[0]) ; i++)
    { // 한 개의 맵

        for (m = 0 ; m < sizeof(wall_list) / sizeof(wall_list[0]) ; m++)
        {
            for (n = 0 ; n < sizeof(wall_list[0]) / sizeof(wall_list[0][0]) ; n++)
            {
                wall_list[m][n] = 0;
            }
        }
        mazegen_count = 0;
        road_count = 0;
        memset(road_list, 0, sizeof(road_list) / sizeof(road_list[0]));

        if ((rand() % 100) < 70)
        {
            for (j = 0 ; j < sizeof(map[0]) / sizeof(map[0][0]) ; j++)
            {
                for (k = 0 ; k < sizeof(map[0][0]) / sizeof(map[0][0][0]) ; k++)
                {
                    if (j == 0)
                    {
                        map[i][j][k] = 0;
                    }
                    else
                    {
                        map[i][j][k] = 1;
                    }
                }
            }
            map[i][0][0] = 0;
            maxa = (sizeof(map[0]) / sizeof(map[0][0])) - 1;
            maxb = sizeof(map[0][0]) / sizeof(map[0][0][0]);
            int wmaxa = (sizeof(wall_list) / sizeof(wall_list[0]));
            int wmaxb = sizeof(wall_list[0]) / sizeof(wall_list[0][0]);
            // outer wall을 2로 하여 wall_list에 저장 {
            for (w_k=0 ; w_k<wmaxb ; w_k++)
            {
                wall_list[1][w_k] = 2;
            }
            for (w_i=0 ; w_i<wmaxa ; w_i++)
            {
                wall_list[w_i][0] = 2;
            }
            for (w_k=0 ; w_k<wmaxb ; w_k++)
            {
                wall_list[wmaxa-1][w_k] = 2;
            }
            for (w_i=0 ; w_i<wmaxa ; w_i++)
            {
                wall_list[w_i][wmaxb-1] = 2;
            }
            //}
            ra = rand() % (maxa - 4); rb = rand() % (maxb - 4);
            map[i][ra+2][rb+2] = 0;
            a = ra+2; b = rb+2;
            wall_check(i,a,b,1);
            road(i,a,b);
            mazegen(i,a,b);
            while (road_count < ((maxa-2) * (maxb-2) + 4) / 2 || mazegen_count < (maxa-2 * maxb-2) / 2)
            {
                mazegen(i, road_list[rand() % road_count] / 100, road_list[rand() % road_count] % 100);
                mazegen_count++;
            }
            up = road_list[rand() % road_count];
            dn = road_list[rand() % road_count];
            up_a = up / 100;
            up_b = up % 100;
            dn_a = dn / 100;
            dn_b = dn % 100;
            map[i][up_a][up_b] = 3;
            map[i][dn_a][dn_b] = 4;
            map[i][0][1] = dn_a;
            map[i][0][2] = dn_b;
            map[i][0][3] = up_a;
            map[i][0][4] = up_b;
        }
        else if ((rand() % 100) >= 70)
        {
            for (j = 0 ; j < sizeof(map[0]) / sizeof(map[0][0]) ; j++)
            {
                for (k = 0 ; k < sizeof(map[0][0]) / sizeof(map[0][0][0]) ; k++)
                {
                    map[i][j][k] = 0;
                }
            }
            map[i][0][0] = 1;
        }
        printf ("mapid : %d\n", i);
        mapp(i,1);
    }
    return 0;
}

int main(void) {
    int pl;
    mapgen();
    mapid = 0;
    srand(time(NULL));
    // 플레이어 좌표 임의설정
    pl = road_list[rand() % road_count];
    pa = pl / 100;
    pb = pl % 100;
    // 플레이어 좌표를 @로 표시
    map[mapid][pa][pb] += 100;
    mapp(mapid,1);
    printf("%d %d %d %d %d", map[mapid][0][0], map[mapid][0][1], map[mapid][0][2], map[mapid][0][3], map[mapid][0][4]);


    return 0;
}