C 언어 바둑

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* ALEX_LEE 바둑 c 언어 애플릿 */

/* o(∩_∩)o ... c 언어를 복습하는 데 사용할 수 있는 애플릿 */

/* 내 블로그: hi.baidu.com/alexlee321*/

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

# include & ltstdio.h & gt

# include & ltbios.h & gt

# include & ltctype.h & gt

# include & ltconio.h & gt

# include & ltdos.h & gt

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* 기호 상수 정의 */

/* 바둑판을 그리는 데 필요한 탭 정의 */

#define CROSSRU 0xbf /* 오른쪽 위 모서리 */

#define CROSSLU 0xda /* 왼쪽 위 모서리 */

# 교차 0xc0 /* 왼쪽 아래 구석 정의 */

#define CROSSRD 0xd9 /* 오른쪽 아래 */

# 교차 0xc3 /* left */

#define CROSSR 0xb4 /* Right */

#define CROSSU 0xc2 /* Above */

# 아래 cross d 0xc 1/*/

# 교차 정의 0xc5 /* 교차 */

/* 화면에서 체스판의 왼쪽 위 모서리 위치 정의 */

# MAPXOFT 5 정의

# MAPYOFT 2 정의

/* 플레이어 1 에 대한 운영 키 정의 */

# defineplay1up0x1157/* 위로 -'w' */

# defineplay1down0x1f53/* 아래로 -'s' */

# defineplay1left0x1E41/* 왼쪽으로 이동 -'a' */

# defineplay1right 0x2044/* move right-'d' */

# defineplay1do 0x3920/* move-spacebar */

/* 플레이어 2 의 작동 키 코드 정의 */

#define PLAY2UP 0x4800/* 위로 화살표 키 위로 */

#define PLAY2DOWN 0x5000/* 아래로 이동-화살표 키 down*/

#define PLAY2LEFT 0x4b00/* 왼쪽 화살표 left*/

#define PLAY2RIGHT 0x4d00/* 오른쪽으로 이동-화살표 키 오른쪽 */

# defineplay2 do 0x1c0d/* move-enter */

/* 게임 중간에 나가시려면 Esc */

# 이스케이프 0x0 1 1b 정의

/* 체스판의 교차 상태를 정의합니다. 즉, 해당 점에 체스말이 있는지 여부 */

/* 만약 바둑말이 있다면, 너도 어느 플레이어의 바둑인지 지적할 수 있을 거야 */

#define CHESSNULL 0 // 체스 조각 없음.

# define ches 1' O '// 1 번 플레이어의 체스 조각

# 바둑돌 2 'X'// 선수 2 를 정의하는 바둑돌

/* 키 범주 정의 */

#define 키 EXIT 0/* exit 키 */

# definekeyfallches1/* dropkey */

#define KEYMOVECURSOR 2/* 커서 키 */

#define KEYINVALID 3/* 잘못된 키 */

/* 기호 상수 정의: true, false-true 는 1, false 는 0 */

# 참 정의 1

# false 0 정의

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* 데이터 구조 정의 */

/* 검사기 교차 좌표의 데이터 구조 */

구조점

{

Int x, y;

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* 사용자 정의 함수 프로토타입에 대한 설명 */

Voidinit (void);

Intgetkey (void);

Intcheck key (intpress);

Intchange order (void);

Int ChessGo(int Order, struct point cursor);

Void do error (void);

Void DoOK (유효하지 않음);

Void do win (intorder) ：

Void MoveCursor(int Order, int press) ：

Void DrawCross(int x, int y) ：

Void drawmap (void);

Int JudgeWin(int Order, struct point cursor);

Int JudgeWinLine(int Order, struct point 커서, int direction);

Void showordermsg (intorder);

Void 혼란 (void);

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* 글로벌 변수 정의 */

Int gPlayOrder/* 는 현재 기사 */

구조점 gCursor/* 체스판 위의 커서 위치 */

Char gchessboard [19] [19]; /* 체스판의 각 점 상태를 기록하는 데 사용됩니다 */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* 주 함수 */

Void main ()

{

Int press

Int bOutWhile = FALSE/* 종료 루프 플래그 */

Init (); /* 초기화 이미지, 데이터 */

While( 1)

{

Press = getkey (); /* 사용자의 키 값 가져오기 */

스위치 (CheckKey(press))/* 키 유형 결정 */

{

/* 는 종료 키 */

케이스 키 종료:

Clr SCR (); /* 화면 비우기 */

BOutWhile = TRUE

깨뜨리다

/* 는 하강 키입니다 */

Case KEYFALLCHESS:

If (chess go (gplayorder, gcursor) = = false)/* chess */

Doerror (); /* 운동 중 오류 */

기타

{

Dook (); /* 올바른 이동 */

/* 현재 기사가 이기면 */

If(JudgeWin(gPlayOrder, gCursor)==TRUE)

{

도윈 (gplayorder);

BOutWhile = TRUE/* 종료 루프 플래그가 true */

}

/* 그렇지 않으면 */

기타

/* 교환 기사 */

Changeorder ();

}

깨뜨리다

/* 는 커서 이동 키 */

Case KEYMOVECURSOR:

MoveCursor(gPlayOrder, press);

깨뜨리다

/* 는 잘못된 키입니다 */

사례 키가 잘못되었습니다.

깨뜨리다

}

If(bOutWhile==TRUE)

깨뜨리다

}

/* 게임 종료 */

Endgame ();

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

/* 인터페이스 초기화, 데이터 초기화 */

Void 초기화 (void)

{

Int I, j;

Char *Msg[]=

{

플레이어1키: ",

위-아래,

"돈-s" 입니다.

"왼쪽-a" 입니다.

"오른쪽 -d" 입니다.

"DO-space" 입니다.

"",

"플레이어 2 키",

"위로" 입니다.

아래로-아래로,

왼쪽-왼쪽,

오른쪽-오른쪽,

"DO-ENTER" 입니다.

"",

"게임 종료:",

"ESC",

비어 있습니다.

}

/* 첫 번째 플레이어는 플레이어 1 */

Gplayorder = ches1;

/* 보드 데이터가 0 입니다. 즉, 보드의 각 점 시작 부분에 조각이 없습니다. */

For(I = 0；; 나< 19; I++)

For(j = 0；; J< 19; J++)

Gchessboard [I] [j] = chessnull;

/* 초기 커서 위치 */

Gcursor.x = gcursor.y = 0;

/* 바둑판 그리기 */

Textmode (C40);

Drawmap ();

/* 작업 키 설명 표시 */

I = 0；;

Textcolor (갈색);

While(Msg[i]! = 비어 있음)

{

Gotoxy (25,3+I);

Cpu ts (msg [I]);

I++；+;

}

/* 현재 기사 표시 */

Showordermsg (gplayorder);

/* 보드 왼쪽 위 구석으로 커서를 이동합니다 */

Gotoxy(gCursor.x+MAPXOFT, gcursor.y+mapyoft);

}

/* 바둑판 그리기 */

Void 지도 그리기 (void)

{

Int I, j;

Clr SCR ();

For(I = 0；; 나< 19; I++)

For(j = 0；; J< 19; J++)

드류 크로스 (I, j);

}

/* 체스판에 교차점을 그립니다 */

Void DrawCross(int x, int y)

{

Gotoxy(x+MAPXOFT, y+mapyoft);

/* 교차는 1 호 플레이어의 체스말 */

If (gchessboard [x] [y] = = chess1)

{

Textcolor (연한 파란색);

Putch (ches1);

반환;

}

/* 교차점은 참가자 2 의 체스입니다 */

If(gChessBoard[x][y]==CHESS2)

{

Textcolor (연한 파란색);

Putch (chess2);

반환;

}

텍스트 색상 (녹색);

/* 왼쪽 위 구석의 교차점 */

If(x = = 0 & amp；; & ampy==0)

{

풋치 (크로스루);

반환;

}

/* 왼쪽 아래 구석의 교차점 */

If(x = = 0 & amp；; & ampy== 18)

{

Putch (크로스 LD);

반환;

}

/* 오른쪽 위 교차점 */

If (x = =18 & & ampy==0)

{

퍼치 (크로스루);

반환;

}

/* 오른쪽 아래 교차점 */

If (x = =18 & & ampy== 18)

{

Putch (crossrd);

반환;

}

/* 왼쪽 경계 교차점 */

(x==0) 인 경우

{

Putch (크로스 l);

반환;

}

/* 오른쪽 경계 교차점 */

다음 경우 (x== 18)

{

Putch (crossr);

반환;

}

/* 위쪽 경계 교차점 */

(y==0) 인 경우

{

Putch (crossu);

반환;

}

/* 하한 경계 교차점 */

If(y== 18)

{

Putch (crossd);

반환;

}

/* 검사기 중간의 교차점 */

푸치 (십자가);

}

/* 교환 기사 */

Int ChangeOrder(void)

{

If(gPlayOrder = = ches 1)

GPlayOrder = CHESS2

기타

Gplayorder = ches1;

리턴 (gplayorder);

}

/* 키 가져오기 */

Int GetKey(void)

{

Char lowbyte

Int press

While (bioskey( 1) == 0)

을 눌러 섹션을 인쇄할 수도 있습니다 /* 사용자가 키를 누르지 않으면 루프가 비어 있습니다 */

= bioskey (0) 를 누릅니다.

낮은 바이트 = & amp0xff 누르기

뉴스 = 뉴스 & amp0xff00+toupper (lowbyte);

반환 (누르기);

}

/* 오류 처리 */

Void 오류 (void)

{

소리 (1200);

지연 (50);

Nosound ();

}

/* 바둑 처리 */

Void DoWin (정수 순서)

{

소리 (1500); 지연 (100);

소리 (0); 지연 (50);

소리 (800); 지연 (100);

소리 (0); 지연 (50);

소리 (1500); 지연 (100);

소리 (0); 지연 (50);

소리 (800); 지연 (100);

소리 (0); 지연 (50);

Nosound ();

Textcolor (빨간색+깜박임);

고톡시 (25, 20);

If(Order = = ches 1)

Cputs ("플레이어1승리!" " );

기타

CPUTS ("플레이어 2 가 이겼다!" " );

Gotoxy (25,21);

Cputs(" \ \<；; +> /");

Getch ();

}

/* 바둑 */

Int ChessGo(int Order, 구조 포인터 커서)

{

/* 교차에 바둑말이 있는지 판단한다 */

If (gchessboard [cursor.x] [cursor.y] = = chessnull)

{

/* 바둑말이 없으면 움직일 수 있다 */

Gotoxy(Cursor.x+MAPXOFT, cursor.y+mapyoft);

Textcolor (연한 파란색);

Putch (주문);

Gotoxy(Cursor.x+MAPXOFT, cursor.y+mapyoft);

Gchessboard [cursor.x] [cursor.y] = order;

TRUE 를 반환합니다

}

기타

FALSE 를 반환합니다

}

/* 다음 바둑 후 현재 바둑 선수가 이길지 판단한다 */

Int JudgeWin(int Order, struct point 커서)

{

Int I；;

For(I = 0；; 나<4; I++)

/* 지정된 방향에 5 개의 연속 체스말이 있는지 확인 */

If(JudgeWinLine(Order, Cursor, I))

TRUE 를 반환합니다

FALSE 를 반환합니다

}

/* 지정된 방향에 5 개의 연속 체스말이 있는지 확인 */

Int 판단선 (int 순서, 구조점 커서, int 방향)

{

Int I；;

구조물 점 위치;

Constinttestnum = 5;

Int 개수

스위치 (방향)

{

상황 0:/* 수평 방향 */

Pos.x = cursor.x-(testnum-1);

Pos.y = cursor.y;

Dpos.x =1;

Dpos.y = 0;

깨뜨리다

시나리오 1:/* 수직 방향 */

Pos.x = cursor.x;

Pos.y = cursor.y-(testnum-1);

Dpos.x = 0;

Dpos.y =1;

깨뜨리다

시나리오 2:/* 왼쪽에서 오른쪽으로 기울어진 방향 */

Pos.x = cursor.x-(testnum-1);

Pos.y = cursor.y+(testnum-1);

Dpos.x =1;

Dpos.y =-1;

깨뜨리다

사례 3:/* 왼쪽 위에서 오른쪽 아래까지의 기울기 방향 */

Pos.x = cursor.x-(testnum-1);

Pos.y = cursor.y-(testnum-1);

Dpos.x =1;

Dpos.y =1;

깨뜨리다

}

Count = 0；;

For(I = 0；; 나 & lttestnum * 2+1; I++)

{

(위치> = 0& & amppos.x & lt =18) 인 경우. & amppos.y & gt= 0 & amp& amp 위치<= 18)

{

If(gChessBoard[ 위치 x][ 위치 y]= = 순서)

{

Count++；+;

If(count & gt；; =testnum)

TRUE 를 반환합니다

}

기타

Count = 0；;

}

Pos.x+= dpos.x;

Pos.y+= dpos.y;

}

FALSE 를 반환합니다

}

/* 커서 이동 */

Void MoveCursor(int Order, int press)

{

스위치 (누르기)

{

사례 연구 1 이상:

If (order = = ches1& & ampgCursor.y & gt0)

Gcursor.y-;

깨뜨리다

사례 연구 1 다운로드:

If (order = = ches1& & ampgCursor.y & lt 18)

Gcursor.y++;

깨뜨리다

사례 연구 1 왼쪽:

If (order = = ches1& & ampgCursor.x & gt0)

Gcursor.x-;

깨뜨리다

사례 연구 1 오른쪽:

If (order = = ches1& & ampgCursor.x & lt 18)

Gcursor.x++;

깨뜨리다

사례 프레젠테이션 2:

If (order = = chess2 & & ampgCursor.y & gt0)

Gcursor.y-;

깨뜨리다

사례 재생 2 다운로드:

If (order = = chess2 & & ampgCursor.y & lt 18)

Gcursor.y++;

깨뜨리다

사례 연구 2 왼쪽:

If (order = = chess2 & & ampgCursor.x & gt0)

Gcursor.x-;

깨뜨리다

사례 연구 2 정확함:

If (order = = chess2 & & ampgCursor.x & lt 18)

Gcursor.x++;

깨뜨리다

}

Gotoxy(gCursor.x+MAPXOFT, gcursor.y+mapyoft);

}

/* 게임 종료 처리 */

Void 잔여물 (void)

{

Textmode (c80);

}

/* 현재 기사 표시 */

Void ShowOrderMsg(int Order)

{

Gotoxy(6, mapyoft+20);

Textcolor (밝은 빨간색);

If(Order = = ches 1)

Cputs ("플레이어1go!" " );

기타

Cputs("Player2 go! "" );

Gotoxy(gCursor.x+MAPXOFT, gcursor.y+mapyoft);

}

/* 올바르게 작동하는 코어 */

Void DoOK (유효하지 않음)

{

소리 (500);

지연 (70);

소리 (600);

지연 (50);

소리 (1000);

지연 (100);

Nosound ();

}

/* 사용자의 키 범주 확인 */

Int CheckKey(int press)

{

If (= = ESC 키를 누름)

Enter exit；; /* 는 종료 키 */

기타

만약

((press = = play1do & & ampgplayorder = = ches1) | |

(press = = play2do & amp & ampgplayorder = = chess2)

) 을 참조하십시오

반환 키 fallchess/* 는 드롭 키 */

기타

만약

(press = = play1up | | press = = play1down | |

Press==PLAY 1LEFT ||

Press = = play2up | | press = = play2down | |

Press = = play 2 왼쪽 | | press = = play 2 오른쪽

) 을 참조하십시오

반환 KEYMOVECURSOR/* 는 커서 이동 키 */

기타

Return 키가 잘못되었습니다. /* 잘못된 키 */

}