JAVA 공부하느라 잊고 있었던, C의 스네이크 게임을 심심해서 전각문자로 바꾸어서 출력하도록 변경하였습니다.


전각 문자로 변경을 하여서 그래픽이 많이 개선되었습니다.

다음은 소스코드입니다. C4Droid로 컴파일 시 성공을 장담할 수 없습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
/*
_WINDOW : 윈도우
_C4DROID : 안드로이드 C4Droid 기준
*/
#define _WINDOW
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
#ifdef _WINDOW
#include <Windows.h>
#include <conio.h>
#endif
#ifdef _C4DROID
#include <conio.h>
#endif
 
/*상수 정의*/
#define EMPTY 0
#define WALL 1
#define SNAKE 2
#define FOOD 3
 
#define UP 0
#define DOWN 1
#define LEFT 2
#define RIGHT 3
 
/*각종 구조체*/
typedef struct Pos {
    int x;
    int y;
}Pos;
 
typedef struct Map {
    int** map;
    int max_height;
    int max_width;
 
    int food_count;
    Pos food;
}Map;
 
typedef struct Snake {
    Pos head;
    Pos* bodys;
    int body_length;
    int way;
}Snake;
 
/*함수 선언*/
void intro(void);                                    //인트로 출력 함수
void gameStart(Map* map, Snake* snake);                //게임 시작 함수
 
Pos setPos(int x, int y);                            //편의를 위한 좌표 반환 함수
 
void initMap(Map* map, int height, int width);        //맵 기본 설정
void setWall(Map* map);                                //벽을 설정함
void printMap(const Map* map, const Snake* snake);    //맵 출력
char* getObjectSymbol(int code);                    //각 오브젝트 코드별 문자를 반환(아스키코드 내에서만 가능)
void mapReflesh(Map* map, const Snake* snake);        //맵에 오브젝트들을 새로고침 함.
void placeFood(Map *map);                            //맵에 푸드를 배치함.
 
void initSnake(Snake* snake, int default_length);    //스네이크 기본 설정
int moveSnake(Map* map, Snake* snake);                //스네이크 이동
void snakeKeyEvent(Snake* snake);                    //스네이크 이동 경로 변경
void addSnakeBody(Snake* snake);                    //스네이크 몸 길이 증가
void eatFood(Map* map, Snake* snake);                //스네이크가 음식을 먹음
 
int main(void)
{
    const int MAP_MAX_HEIGHT = 20;
    const int MAP_MAX_WIDTH = 20;
 
 
    Map map;    //맵
    Snake snake;    //스네이크
 
    srand(time(NULL));
 
    while (1)
    {
        intro();
        initMap(&map, MAP_MAX_HEIGHT, MAP_MAX_WIDTH);
        initSnake(&snake, 5);
 
        gameStart(&map, &snake);
    }
 
    return 0;
}
 
void intro(void)
{
#ifdef _WINDOW
    system("cls");
#endif
#ifdef _C4DROID
    clrscr();
#endif
    printf("==[ C로 만든 텍스트 스네이크 게임 ]==\n");
    printf("\n아무 키나 누르면 시작합니다.\n");
#ifdef _WINDOW
    _getch();
#endif
#ifdef _C4DROID
    getch();
#endif
}
 
/*Pos 관련 함수 정의*/
Pos setPos(int x, int y)
{
    Pos pos;
    pos.x = x;
    pos.y = y;
 
    return pos;
}
 
/*게임 관련 함수 정의*/
void gameStart(Map* map, Snake* snake)
{
    while (1)
    {
        snakeKeyEvent(snake);
 
        switch (moveSnake(map, snake))
        {
        case -1:
            printf("알 수 없는 오류 발생");
            break;
 
        case 1://사망
            printf("이런 머리를 박고 사망하였습니다.\n");
            /*메모리 반환*/
            free(snake->bodys);
#ifdef _DEBUG
            printf("[Debug] snake.bodys 메모리 반환 완료\n");
#endif
 
            free(map->map);
#ifdef _DEBUG
            printf("[Debug] map.map 메모리 반환 완료\n");
#endif
#ifdef _WINDOW
            _getch();
#endif
#ifdef _C4DROID
            getch();
#endif
            return;
        }
        placeFood(map);
        mapReflesh(map, snake);
        printMap(map, snake);
#ifdef _WINDOW
        Sleep(80);
#endif
#ifdef _C4DROID
        usleep(100000);
#endif
    }
}
/***************************
* 맵 관련 함수 정의
****************************/
void setWall(Map *map)
{
    int i;
 
    /*상단 벽면 설정*/
    for (i = 0; i < map->max_width; i++)
        map->map[i][0= WALL;
    /*좌측 벽면 설정*/
    for (i = 0; i < map->max_height; i++)
        map->map[0][i] = WALL;
    /*하단 벽면 설정*/
    for (i = 0; i < map->max_width; i++)
        map->map[i][map->max_height - 1= WALL;
    /*우측 벽면 설정*/
    for (i = 0; i < map->max_height; i++)
        map->map[map->max_width - 1][i] = WALL;
}
 
void printMap(const Map* map, const Snake* snake)
{
    int i, j;
 
#ifdef _WINDOW
    system("cls");
#endif
#ifdef _C4DROID
    clrscr();
#endif
    for (i = 0; i < map->max_height; i++)
    {
        for (j = 0; j < map->max_width; j++)
            printf("%s", getObjectSymbol(map->map[j][i]));
        /*추가 출력*/
        switch (i)
        {
        case 0:
            printf(" - 길이 : %d", snake->body_length + 1);
            break;
#ifdef _DEBUG
        case 1:
            printf(" - D:헤드 좌표 : (%d, %d)", snake->head.x, snake->head.y);
            break;
        case 2:
            printf(" - D:진행 방향 : %d", snake->way);
            break;
#endif
        }
        putchar('\n');
    }
}
 
char* getObjectSymbol(int code)
{
    switch (code)
    {
    case EMPTY:
        return "  ";
    case WALL:
        return "■";
    case SNAKE:
        return "○";
    case FOOD:
        return "★";
    default:
        return 'E';
    }
}
 
void initMap(Map* map, int height, int width)
{
    int i;
    map->max_height = height;
    map->max_width = width;
    map->food_count = 0;
    map->map = (int**)malloc(sizeof(int** width);
 
    for (i = 0; i < width; i++)
    {
        map->map[i] = (int*)malloc(sizeof(int* height);
    }
}
 
void mapReflesh(Map* map, const Snake* snake)
{
    int i, j;
    /*비움*/
    for (i = 0; i < map->max_width; i++)
    {
        for (j = 0; j < map->max_height; j++)
        {
            map->map[i][j] = EMPTY;
        }
    }
 
    /*벽 표시*/
    setWall(map);
 
    /*스네이크 표시*/
    map->map[snake->head.x][snake->head.y] = SNAKE;
    for (i = 0; i < snake->body_length; i++)
    {
        map->map[snake->bodys[i].x][snake->bodys[i].y] = SNAKE;
    }
 
    /*푸드 표시*/
    map->map[map->food.x][map->food.y] = FOOD;
}
 
void placeFood(Map *map)
{
    if (map->food_count == 0)
    {
        do
        {
            map->food = setPos((rand() % (map->max_width - 2+ 1), (rand() % (map->max_height - 2+ 1));
            map->food_count = 1;
        } while (map->map[map->food.x][map->food.y] == SNAKE);
    }
}
 
/*****************************
* 스네이크 관련 함수 정의
******************************/
void initSnake(Snake* snake, int default_length)
{
    int i;
 
    snake->way = RIGHT;
    snake->head = setPos(44);
 
    snake->bodys = (Pos*)malloc(sizeof(Pos) * default_length);
    snake->body_length = default_length;
 
    for (i = 0; i < default_length; i++)
    {
        snake->bodys[i] = snake->head;
    }
}
 
int moveSnake(Map* map, Snake* snake)
{
    int i;
    int x = snake->head.x, y = snake->head.y;    //뱀 헤드 좌표의 임시 변수
    Pos temp_pos;
    Pos temp_pos2;
 
    temp_pos = snake->head;
    switch (snake->way)
    {
    case UP:
        switch (map->map[x][y - 1])
        {
        case FOOD: eatFood(map, snake);
        case 0:
            snake->head.y--;
            break;
        case 1:
        case 2:
            return 1;
        }
        break;
 
    case DOWN:
        switch (map->map[x][y + 1])
        {
        case FOOD: eatFood(map, snake);
        case 0:
            snake->head.y++;
            break;
        case 1:
        case 2:
            return 1;
        }
        break;
 
    case LEFT:
        switch (map->map[x - 1][y])
        {
        case FOOD: eatFood(map, snake);
        case 0:
            snake->head.x--;
            break;
        case 1:
        case 2:
            return 1;
        }
        break;
 
    case RIGHT:
        switch (map->map[x + 1][y])
        {
        case FOOD: eatFood(map, snake);
        case 0:
            snake->head.x++;
            break;
        case 1:
        case 2:
            return 1;
        }
        break;
    default:
        return -1;
    }
 
    for (i = 0; i<snake->body_length; i++)
    {
        temp_pos2 = snake->bodys[i];
        snake->bodys[i] = temp_pos;
 
        temp_pos = temp_pos2;
    }
    return 0;
}
 
void snakeKeyEvent(Snake * snake)
{
#ifdef _WINDOW
    if (_kbhit())
    {
        switch (_getch())
        {
        case 'w':
        case 'W':
            if (!(snake->way == DOWN))
                snake->way = UP;
            break;
        case 'a':
        case 'A':
            if (!(snake->way == RIGHT))
                snake->way = LEFT;
            break;
        case 's':
        case 'S':
            if (!(snake->way == UP))
                snake->way = DOWN;
            break;
        case 'd':
        case 'D':
            if (!(snake->way == LEFT))
                snake->way = RIGHT;
            break;
        case 'p':
        case 'P':
            getchar();
        }
    }
#endif
#ifdef C4DROID
    if (kbhit())
    {
        switch (getch())
        {
        case 'w':
        case 'W':
            if (!(snake->way == DOWN))
                snake->way = UP;
            break;
        case 'a':
        case 'A':
            if (!(snake->way == RIGHT))
                snake->way = LEFT;
            break;
        case 's':
        case 'S':
            if (!(snake->way == UP))
                snake->way = DOWN;
            break;
        case 'd':
        case 'D':
            if (!(snake->way == LEFT))
                snake->way = RIGHT;
            break;
        case 'p':
        case 'P':
            getchar();
        }
    }
#endif
}
 
void addSnakeBody(Snake* snake)
{
    snake->body_length++;
    snake->bodys = (Pos*)realloc(snake->bodys, sizeof(Pos) * snake->body_length);
}
 
void eatFood(Map* map, Snake* snake)
{
    map->food_count = 0;
    addSnakeBody(snake);
}
 
cs

전각문자를 위한 수정 외에는 별 수정이 없습니다. 또한 맨 위에 실행 화면은 _DEBUG 매크로를 적용한 실행 상태이며, 일반적인 컴파일 시에 _DEBUG 매크로를 지정하지 않으셔도 무방하며,

윈도우의 실행을 전제로 하고 개발을 한 프로그램입니다.


위는 플레이 영상(출력과 지우기를 반복하는 방식이라서 깜빡임이 잘보입니다 ㅠㅠ)



댓글 작성