TCP/IP 이해

Network 2015. 8. 26. 14:27


TCP/IP

미국에서 개발한 인터넷의 기본 통신 프로토콜, DOD Model(미국방성 모델)을

기반으로 개발되었다.


TCP : 연결지향형 프로토콜, 세션의 연결과 종료, 흐름제어, 패킷의 분할 및 재조립

IP : 비 연결지향형 프로토콜, 데이터 전송

OSI 7 Layer은 표준 기준을 잡는데 사용하고,

TCP/IP는 실직적으로 사용되는 프로토콜이다.



TCP/IP 와 OSI 7 Layer 비교





공통점


- 둘다 계층형 구조이다.


차이점


- OSI 7 Layer의 세션, 표현, 응용계층을 TCP/IP의 응용계층에서 처리한다.

​- OSI 7 Layer의 데이터링크, 물리계층을 TCP/IP의 네트워크 계층으로 표현.

​- TCP/IP는 인터넷 개발 이후 수십년간 운용 경험에 의해 신뢰도가 높은 반면,

OSI 7 Layer는 표준 참조 모델로, 구현의 경험이 거의 없어 신뢰도가 낮다.



TCP/IP Protocol



 

각 계층의 역할


Network Interface(네트워크 인터페이스) 계층


- 데이터를 전송하는 케이블에 프레임을 송수신, 인터페이스 카드 포함

- Cable, Connector, Bit



Internet(인터넷) 계층


- 주소 관리와 라우팅.

- IP : IP 어드레싱과 패킷 분해, 재조합 프로토콜

- ARP : 인터넷 계층 주소를 네트워크 인터페이스 계층의 주소로 변환

- ICMP : IP 패킷 전달의 오류 진단

- IGMP : IP 멀티캐스트 그룹 관리



Transport(전송) 계층


- Application 계층에 세션과 데이터그램 통신 서비스 제공

- TCP : 1대1 연결 지향 서비스로 높은 신뢰도의 통신 서비스를 제공한다.

에러 제어, 오류 재전송 으로 보장된 세그먼트 전달.

- 단점으로 연결 초기 설정 시간이 걸린다.


- UDP : 비연결 지향 서비스로 낮은 신뢰도의 서비스를 제공한다. 연결을 맺지 않으므로 시간이 걸리지 않으며, 재전송을 하지 않아 네트워크의 부하를 줄인다. 신뢰성보다는 고속성에 사용된다.

​- 단점으로 신뢰성이 낮다.



Application(응용) 계층

​- 응용 계층은 다른 계층의 서비스에 접근할 수 있게 어플리케이션을 제공, 데이터 교환을 위해 사용

- DNS : 호스트 이름을 IP주소로 변환

- HTTP : 웹 페이지 파일 전송

- FTP : 상호 파일 전송

- SMTP : 메일 메세지와 파일들을 전송

- Telnet : 네트워크 호스트에 원격 접속

- SNMP : 네트워크 장비를 모니터링 하고 제어, 관리 정보를 수집, 교환

- RIP : 라우팅 정보를 교환



'Network' 카테고리의 다른 글

ACL(Access Control List) 이란?  (0) 2015.09.18
NAT란?  (0) 2015.09.10
OSI 7 Layer 이해  (0) 2015.08.26
프록시란?  (0) 2015.08.20
서퍼팜과 DMZ의 이해와 차이점  (0) 2015.08.19
블로그 이미지

토유

개발일지

,

OSI 7 Layer 이해

Network 2015. 8. 26. 14:26

osi 7 Layer


- 국제 표준화 기구(ISO)에서1984년에 발표한 OSI 7 Layer는 일어나는 과정을

7단계로 구분해서 한눈에 들어올 수 있도록 만든 표준 모델이다.


(osi 7 layer 모델은 실질적으로 사용되지는 않고 참조용으로 쓰인다)



osi 7 Layer 장점


- 데이터의 흐름이 한눈에 보인다.

- Throuble shooting(문제 해결)이 쉽다.

- 네트워크 동작과정 이해

- 계층을 7 단계로 구분하고 각 층별로 표준화를 했기 때문에

여러 회사 장비를 사용해도 네트워크가 이상없이 돌아간다.





​크게는 Application 계층과 Data Flow 계층으로 나뉜다



OSI 7 Layer 각 계층별 구조와 역할

1계층 Phsical Layer​ (물리 계층)

- 네트워크 통신을 위한 물리적인 표준 정의

- 컴퓨터산의 전기적, 기계적, 절차적인 연결을 정의

(케이블 종류, 데이터 송수신 속도, 신호의 전기 전압 등)

- Physical 계층 장비 : 리피터, 허브

- 전송 단위 : Bit(비트)

- 프로토콜 : Ethernet(이더넷), RS-232C 등



2계층 Data link Layer (데이터 링크 계층)


- 물리적 계층을 통한 데이터 전송에 신뢰성 제공

- 물리적 주소(MAC)지정, 네트워크 토폴로지, 오류통지, 프레임의 순차적 전송,

흐름제어 등의 기능

- 로컬 네트워크에서 프레임을 안전하게 전송하는 것이 목적

- Data link 계층 장비 : Switch, Bridge

- 전송 단위 : Frame(프레임)

- 프로토콜 : MAC, PPP 등


3계층 Network Layer (네트워크 계층)



- Logical address (IP, IPX)를 담당하고, Packet의 이동 경로를 결정한다.

- 경로 선택, 라우팅, 논리적인 주소를 정의

- 라우팅 프로토콜을 이용해 최적 경로 설정

- Network 계층 장비 : Switch

- 전송 단위 : Packet(패킷)

- 프로토콜 : IP, ICMP



​4계층 Transport Layer (전송 계층)



- 전체 메시지를 발신지와 목적지에서 제어와 에러를 관리

- 패킷 전송에 오류가 있는지 확인하고 실패된 패킷을 재전송 해주는

신뢰성 있는 통신

- 주소 설정, 오류 및 흐름 제어, 다중화를 수행

- Transport 계층 장비 : Gateway, L4 Switch

- 전송 단위 : Segment(세그먼트)

- 프로토콜 : TCP, UDP 등



​5계층 Session Layer (세션 계층)


- 양 끝단의 프로세스가 통신을 관리하기 위한 방법 제공

- 전이중(Full-Duplex), 반이중(Half-Duplex), 동시송수신(Duplex) 방식으로

통신을 하는 호스트들 사이에 세션을 열고, 닫고, 관리하는 기능을 담당

- 프로토콜 : NetBIOS, SSH, TLS



​6계층 Presentation Layer (표현 계층)


- 전송하는 데이터의 Format을 결정

- 다양한 데이터 Format을 일관되게 상호 변환하고

압축, 암호화, 복호화 기능 수행

- 프로토콜 : ASCII, EBCDIC, 유니코드, GIF, JPEG, AVI, MPEG 등



​7계층 Application Layer (응용 계층)


- 사용자 인터페이스 역할을 담당

- 사용자와 가장 가까운 프로토콜 정의

- 프로토콜 : HTTP(80), FTP(21), Telnet(23), SMTP(25), DNS(53), TFTP(69) 등


'Network' 카테고리의 다른 글

NAT란?  (0) 2015.09.10
TCP/IP 이해  (0) 2015.08.26
프록시란?  (0) 2015.08.20
서퍼팜과 DMZ의 이해와 차이점  (0) 2015.08.19
EIGRP 와 OSPF의 차이점  (0) 2015.08.18
블로그 이미지

토유

개발일지

,

 

lotto.exe
다운로드

 

간단한 로또 프로그램 만들어보자

 

 do while과 srand함수를 사용

 

더보기

#include <stdio.h>

#include <stdlib.h>
#include <time.h>
#include <conio.h>

void main()
{
 int a, b, c, d, e, f, g;
 char ch;
 int i;

 srand(time_t(NULL));
 do
 {
  system("cls");
  printf("구매 횟수를 정하시오!:");
  scanf_s("%d", &g);

  for (i = 1; i <= g; i++)
  {
   a = rand() % 45 + 1;
   do
   {
    b = rand() % 45 + 1;
   } while (a == b);
   do
   {
    c = rand() % 45 + 1;
   } while (c == a || c == b);
   do
   {
    d = rand() % 45 + 1;
   } while (d == a || d == b || d == c);
   do
   {
    e = rand() % 45 + 1;
   } while (e == a || e == b || e == c || e == d);
   do
   {
    f = rand() % 45 + 1;
   } while (f == a || f == b || f == c || f == d || f == e);

   printf("%4d%4d%4d%4d%4d%4d\n", a, b, c, d, e, f);
  }
  printf("계속하려면 'y'를 누르세요!\n");
  ch = _getch();
 } while (ch == 'y');
}

 

 

로또 프로그램 실행 화면

 

 

 

 

처음 시작화면에서 출력할 로또 횟수를 입력한다.

 

 

 

입력한 횟수(10개) 만큼의 로또번호가 출력된다

출력 후에 y를 누르면 처음화면으로 돌아가고, y가 아닌것을 누르면 종료된다.

 


 

처음 화면에서 숫자를 입력하지 않으면 종료전 재시작 멘트가 나온다.

 

 

다들 일등 당첨 되세요~ ^^

 

'C언어' 카테고리의 다른 글

C언어 게임 만들기(5일차)  (0) 2015.08.26
C언어 게임 만들기(4일차)  (0) 2015.08.26
C언어 게임 만들기(3일차)  (0) 2015.08.26
C언어 게임 만들기(2일차)  (0) 2015.08.26
C언어 게임 만들기(1일차)  (0) 2015.08.26
블로그 이미지

토유

개발일지

,

 

snake__game.exe
다운로드

 

msvcr120d.dll
다운로드

5일차

 

 

최종 코드 수정

 

더보기

#include <stdio.h>

#include <conio.h>
#include <windows.h>
#include <stdlib.h>
#include <time.h>


int score=0; //-> 전역 변수로 설정

 

#define  UP  72
#define  LEFT 75
#define  RIGHT 77
#define  DOWN 80

 

#define  SUP 119;
#define  SLEFT 97;
#define  SDOWN 115;
#define  SRIGHT 100;

 

#define  ENTER 13


typedef enum { NOCURSOR, SOLIDCURSOR, NORMALCURSOR } CURSOR_TYPE;

 

void setcursortype(CURSOR_TYPE c){
 CONSOLE_CURSOR_INFO CurInfo;

 switch (c) {
 case NOCURSOR:
  CurInfo.dwSize = 1;
  CurInfo.bVisible = FALSE;
  break;
 case SOLIDCURSOR:
  CurInfo.dwSize = 100;
  CurInfo.bVisible = TRUE;
  break;
 case NORMALCURSOR:
  CurInfo.dwSize = 20;
  CurInfo.bVisible = TRUE;
  break;
 }
 SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CurInfo);
}

 

void textcolor(int color_number) //텍스트 칼라를 바꿔주는 함수
{
 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color_number);
}

 

void gotoxy(int x, int y)
{
 COORD pos = { x, y };
 SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);

}

 

void printmap()
{
 system("mode con: cols=81 lines=41");
 int i;
 system("cls");
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n");
 for (i = 1; i<39; i++)
 {
  printf("■                                                                            ■\n");
 }
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
}

 

void play()
{
 int direction = UP;
 int Y = 19;
 int X = 70;
 int TX = 70;
 int TY = 19;
 int Fheight, Fwidth;
 int eat = 0;
 int SnakeNStar[40][40] = { 0 };
 int UDRL[40][40] = { 0 };

 SnakeNStar[Y][X / 2] = 1;
 gotoxy(X, Y);
 textcolor(12);
 printf("■");

 while (1)
 {
  if (eat == 0)
  {
   srand((unsigned)time(NULL));
   Fheight = rand() % 38 + 1;
   Fwidth = (rand() % 38 + 1) * 2;
   SnakeNStar[Fheight][Fwidth / 2] = 2;
   gotoxy(Fwidth, Fheight);
   textcolor(14);
   printf("★");
   eat++;
  }
  fflush(stdin);
  if (_kbhit())
  {
   do
   {
    direction = _getch();
   } while (direction == 224);
  }


  if (direction == UP)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y - 1][X / 2] == 2)         // 만약 다음에 움직일 칸이 먹이라면
   {
    //SnakeNStar[Y][X / 2] = 0;            // 일단 현재칸을 0으로 만들고
    //gotoxy(X, Y);                     // 커서를 현재칸에 옮긴 뒤
    //printf("  ");                             // 공백을 채워준다.
    SnakeNStar[--Y][X / 2] = 1;         // 그리고 움직일 칸에 이동해서 1
    gotoxy(X, Y);                     // 커서를 움직일 칸에 이동 후
    textcolor(12);
    printf("■");                     // Snake를 그려줌
    Fheight = rand() % 38 + 1;               // 세로 랜덤값을 만들고
    Fwidth = (rand() % 38 + 1) * 2;            // 가로 랜덤값을 만듬
    score++;

    while (1)                        // 먹이가 생성될 때 까지 무한반복
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)   // 먹이가 생성될 자리가 공백이면
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;      // 먹이값을 채워준다.
      gotoxy(Fwidth, Fheight);               // 먹이 포인터를 이동한 후
      textcolor(14);
      printf("★");               // 먹이를 그림
      break;
     }
     else                                // 먹이가 생성될 자리가 공백이 아니면
     {
      Fheight = rand() % 38 + 1;         // 랜덤함수를 계속 돌린다.
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else if (SnakeNStar[Y - 1][X / 2] == 1)      // 내 몸에 부딫히면 뒤짐
   {
    system("cls");
    return;
   }
   else                              // 다음에 움직이는 칸이 공백이면
   {
    if (Y == 1)                        // 뒤지는 거
    {
     system("cls");
     return;
    }

    SnakeNStar[TY][TX / 2] = 0;            // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                     // 커서를 꼬리칸으로 이동
    printf("  ");                     // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }
    
    SnakeNStar[--Y][X / 2] = 1;            // 다음에 움직이는 칸에 뱀값을 집어넣고
    gotoxy(X, Y);                         // 커서를 다음칸으로 이동
    textcolor(12);
    printf("■");                                 // 뱀을 그려준다.


   }
  }

  else if (direction == DOWN)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y + 1][X / 2] == 2)
   {
    //SnakeNStar[Y][X / 2] = 0;
    //gotoxy(X, Y);
    //printf("  ");
    SnakeNStar[++Y][X / 2] = 0;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
    Fheight = rand() % 38 + 1;
    Fwidth = (rand() % 38 + 1) * 2;
    score 

while (1)
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;
      gotoxy(Fwidth, Fheight);
      textcolor(14);
      printf("★");
      break;
     }
     else
     {
      Fheight = rand() % 38 + 1;
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else if (SnakeNStar[Y + 1][X / 2] == 1)
   {
    system("cls");
    return;
   }
   else
   {
    if (Y == 38)
    {
     system("cls");
     return;
    }
    SnakeNStar[TY][TX / 2] = 0;            // 현재칸을 공백값으로 만들고
   gotoxy(TX, TY);                               // 커서를 현재칸으로 이동
    printf("  ");                                     // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }

    SnakeNStar[++Y][X / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");

   }
  }

  else if (direction == LEFT)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y][(X - 2) / 2] == 2)
   {
    //SnakeNStar[Y][X / 2] = 0;
    //gotoxy(X, Y);
    //printf("  ");
    SnakeNStar[Y][(X -= 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
    Fheight = rand() % 38 + 1;
    Fwidth = (rand() % 38 + 1) * 2;
    score++;

    while (1)
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;
      gotoxy(Fwidth, Fheight);
      textcolor(14);
      printf("★");
      break;
     }
     else
     {
      Fheight = rand() % 38 + 1;
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else if (SnakeNStar[Y][(X - 2) / 2] == 1)
   {
    system("cls");
    return;
   }
   else
   {
    if (X == 2)
    {
     system("cls");
     return;
    }
    SnakeNStar[TY][TX / 2] = 0;            // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                               // 커서를 현재칸으로 이동
    printf("  ");                                      // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }
    SnakeNStar[Y][(X -= 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
   }
  }

  if (direction == RIGHT)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y][(X + 2) / 2] == 2)
   {
    //SnakeNStar[Y][X / 2] = 0;
    //gotoxy(X, Y);
    //printf("  ");
    SnakeNStar[Y][(X += 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
    Fheight = rand() % 38 + 1;
    Fwidth = (rand() % 38 + 1) * 2;
    score++;

    while (1)
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;
      gotoxy(Fwidth, Fheight);
      textcolor(14);
      printf("★");
      break;
     }
     else
     {
      Fheight = rand() % 38 + 1;
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else if (SnakeNStar[Y][(X + 2) / 2] == 1)
   {
    system("cls");
    return;
   }
   else
   {
    if (X == 76)
    {
     system("cls");
     return;
    }
    SnakeNStar[TY][TX / 2] = 0;            // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                               // 커서를 현재칸으로 이동
    printf("  ");                                      // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }
    SnakeNStar[Y][(X += 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
   }
  }

  Sleep(90);
 }
}

/*void makestar()
{

}*/

int interface01()
{
 system("mode con: cols=150 lines=41");
 int updown = 1;
 int x = 10, y = 5;
 gotoxy(x, y);

 system("cls");
 fflush(stdin);

 system("color 0b"); //색 변경
 int i;
 system("cls");
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
 for (i = 1; i<39; i++)
 {
  printf("■                                                                                                                                                  ■");
 }
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
 // 맵
 textcolor(15);
 gotoxy(70, 10);
 printf(" SNAKE GAME\n");
 gotoxy(73, 13);
 printf(" MEUN\n");
 gotoxy(70, 16);
 printf(" GAME START \n");
 gotoxy(73, 17);
 printf("1인용");
 gotoxy(73, 18);
 printf("2인용(미완성)");
 gotoxy(73, 19);
 printf(" EXIT \n");
 gotoxy(65, 17);
 printf("▶");
 // 게임 시작 화면 인터페이스
 while (1)
 {
  switch (_getch())
  {
  case UP:
   gotoxy(65, 16 + updown);
   printf("  ");
   if (updown > 1)
   {
    updown--;
   }
   gotoxy(65, 16 + updown);
   printf("▶");
   break;
  case DOWN:
   gotoxy(65, 16 + updown);
   printf("  ");
   if (updown < 3)
   {
    updown++;
   }
   gotoxy(65, 16 + updown);
   printf("▶");
   break;
   //  game start , exit 선택
  case ENTER:
   if (updown == 1)
   {
    system("cls");
    return 1;
   }
   else if (updown == 2)
   {
    system("cls");
    return 2;
   }
   else
   {
    system("cls");
    gotoxy(70, 18);
    printf("안녕히가세요\n");
    Sleep(1000);
    exit(0);

   }

   //게임시작
  }
 }
}
void play2()
{
 /////////////////////////////////////////////////////////////1p
 int direction = UP;
 int Y = 19;
 int X = 70;
 int TX = 70;
 int TY = 19;
 int Fheight, Fwidth;
 int eat = 0;
 int SnakeNStar[40][40] = { 0 };
 int UDRL[40][40] = { 0 };

 SnakeNStar[Y][X / 2] = 1;
 gotoxy(X, Y);
 textcolor(12);
 printf("■");

 while (1)
 {
  if (eat == 0)
  {
   srand((unsigned)time(NULL));
   Fheight = rand() % 38 + 1;
   Fwidth = (rand() % 38 + 1) * 2;
   SnakeNStar[Fheight][Fwidth / 2] = 2;
   gotoxy(Fwidth, Fheight);
   textcolor(14);
   printf("★");
   eat++;
  }
  fflush(stdin);
  if (_kbhit())
  {
   do
   {
    direction = _getch();
   } while (direction == 224);
  }


  if (direction == UP)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y - 1][X / 2] == 2)         // 만약 다음에 움직일 칸이 먹이라면
   {
    //SnakeNStar[Y][X / 2] = 0;              // 일단 현재칸을 0으로 만들고
    //gotoxy(X, Y);                                 // 커서를 현재칸에 옮긴 뒤
    //printf("  ");                                    // 공백을 채워준다.
    SnakeNStar[--Y][X / 2] = 1;              // 그리고 움직일 칸에 이동해서 1
    gotoxy(X, Y);                                   // 커서를 움직일 칸에 이동 후
    textcolor(12);
    printf("■");                                      // Snake를 그려줌
    Fheight = rand() % 38 + 1;                 // 세로 랜덤값을 만들고
    Fwidth = (rand() % 38 + 1) * 2;          // 가로 랜덤값을 만듬

    while (1)                                        // 먹이가 생성될 때 까지 무한반복
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)   // 먹이가 생성될 자리가 공백이면
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;      // 먹이값을 채워준다.
      gotoxy(Fwidth, Fheight);               // 먹이 포인터를 이동한 후
      textcolor(14);
      printf("★");               // 먹이를 그림
      break;
     }
     else                                // 먹이가 생성될 자리가 공백이 아니면
     {
      Fheight = rand() % 38 + 1;         // 랜덤함수를 계속 돌린다.
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else                              // 다음에 움직이는 칸이 공백이면
   {
    if (Y == 1)                        // 죽는 것
    {
     system("cls");
     return;
    }

    //SnakeNStar[Y][X / 2] = 1;             // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                               // 커서를 꼬리칸으로 이동
    printf("  ");                                      // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }

    SnakeNStar[--Y][X / 2] = 1;            // 다음에 움직이는 칸에 뱀값을 집어넣고
    gotoxy(X, Y);                                  // 커서를 다음칸으로 이동
    textcolor(12);
    printf("■");                                     // 뱀을 그려준다.


   }
  }

  else if (direction == DOWN)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y + 1][X / 2] == 2)
   {
    //SnakeNStar[Y][X / 2] = 0;
    //gotoxy(X, Y);
    //printf("  ");
    SnakeNStar[++Y][X / 2] = 0;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
    Fheight = rand() % 38 + 1;
    Fwidth = (rand() % 38 + 1) * 2;

    while (1)
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;
      gotoxy(Fwidth, Fheight);
      textcolor(14);
      printf("★");
      break;
     }
     else
     {
      Fheight = rand() % 38 + 1;
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else
   {
    if (Y == 38)
    {
     system("cls");
     return;
    }
    //SnakeNStar[Y][X / 2] = 0;             // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                               // 커서를 현재칸으로 이동
    printf("  ");                                      // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }

    SnakeNStar[++Y][X / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");

   }
  }

  else if (direction == LEFT)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y][(X - 2) / 2] == 2)
   {
    //SnakeNStar[Y][X / 2] = 0;
    //gotoxy(X, Y);
    //printf("  ");
    SnakeNStar[Y][(X -= 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
    Fheight = rand() % 38 + 1;
    Fwidth = (rand() % 38 + 1) * 2;

    while (1)
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;
      gotoxy(Fwidth, Fheight);
      textcolor(14);
      printf("★");
      break;
     }
     else
     {
      Fheight = rand() % 38 + 1;
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else
   {
    if (X == 2)
    {
     system("cls");
     return;
    }
    //SnakeNStar[Y][X / 2] = 0;             // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                               // 커서를 현재칸으로 이동
    printf("  ");                                      // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }
    SnakeNStar[Y][(X -= 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
   }
  }

  if (direction == RIGHT)
  {
   UDRL[Y][X / 2] = direction;
   if (SnakeNStar[Y][(X + 2) / 2] == 2)
   {
    //SnakeNStar[Y][X / 2] = 0;
    //gotoxy(X, Y);
    //printf("  ");
    SnakeNStar[Y][(X += 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
    Fheight = rand() % 38 + 1;
    Fwidth = (rand() % 38 + 1) * 2;

    while (1)
    {
     if (SnakeNStar[Fheight][Fwidth / 2] != 1)
     {
      SnakeNStar[Fheight][Fwidth / 2] = 2;
      gotoxy(Fwidth, Fheight);
      textcolor(14);
      printf("★");
      break;
     }
     else
     {
      Fheight = rand() % 38 + 1;
      Fwidth = (rand() % 38 + 1) * 2;
     }
    }
   }
   else
   {
    if (X == 146)
    {
     system("cls");
     return;
    }
    //SnakeNStar[Y][X / 2] = 0;            // 현재칸을 공백값으로 만들고
    gotoxy(TX, TY);                              // 커서를 현재칸으로 이동
    printf("  ");                                     // 공백을 채워줌


    if (UDRL[TY][TX / 2] == UP)
    {
     TY--;
    }
    else if (UDRL[TY][TX / 2] == DOWN)
    {
     TY++;
    }
    else if (UDRL[TY][TX / 2] == RIGHT)
    {
     TX += 2;
    }
    else if (UDRL[TY][TX / 2] == LEFT)
    {
     TX -= 2;
    }
    SnakeNStar[Y][(X += 2) / 2] = 1;
    gotoxy(X, Y);
    textcolor(12);
    printf("■");
   }
  }


  Sleep(90);
 }
 //////////////////////////////////////////////////////////2p

}
void printmap2()
{
 system("mode con: cols=150 lines=41");
 int i;
 system("cls");
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
 for (i = 1; i<39; i++)
 {
  printf("■                                                                                                                                                  ■");
 }
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
}
void ending()
{

 system("color 0b");
 int updown = 1;
 system("mode con: cols=150 lines=41");
 int i;
 system("cls");
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
 for (i = 1; i < 39; i++)
 {
  printf("■                                                                                                                                                  ■");
 }
 printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");

 gotoxy(74, 13);
 printf("점수 : %d",score);
 score = 0;
 gotoxy(68, 15);
 printf("재시작 하시겠습니까?");
 gotoxy(75, 16);
 printf("EXIT");
 gotoxy(65, 15);
 printf("▶");
 ////
 while (1)
 {
  switch (_getch())
  {
  case UP:
   updown = 1;
   gotoxy(65, 16);
   printf("  ");
   gotoxy(65, 15);
   printf("▶");
   break;

  case DOWN:
   updown = 2;
   gotoxy(65, 15);
   printf("  ");
   gotoxy(65, 16);
   printf("▶");
   break;
   //  game start , exit 선택
  case ENTER:
   if (updown == 1)
   {
    system("cls");
    return ;
   }
   else
   {
    system("cls");
    gotoxy(70, 18);
    printf("안녕히가세요\n");
    Sleep(1000);
    exit(0);

   }
   //게임시작
  }
 }
}
 ///////////////////////////////////////////////////////////
 void main()
 {
  system("mode con: cols=150 lines=41"); //창 화면 크기
  setcursortype(NOCURSOR);
  while (1)
  {
   int RETN = interface01();

   if (RETN == 1)
   {
    printmap();
    play();
    ending(); -> 새로 추가한 함수
   }
   else if (RETN == 2)
   {
    printmap2();
    play2();
   }
   else if (RETN == 3)
    break;
  }
 }

 

수정한 부분

 

ending 인터페이스 추가, 점수 생성

 

게임에서 죽으면 처음으로 돌아가는 부분에 허무함도 느끼고 얼만큼 성장 게임이 끝났는지 수가 없어서 ending화면에 자신이 먹이를 먹은 만큼의 점수를 계산에 표시하는 점수 판을 생성하였다

 

 게임의 기본적인 틀을 다잡은

 같이 수업을 듣는 형들에게 배포 하였다

 

반응이 좋은 같다.

 

(수정 게임을 즐기고 있는 모습)

 

 

 

 

 

게임 인터페이스 소개

 

 

게임 시작화면.

 


 

1인용 , 2인용 , EXIT 3가지의 선택지로 구성되어 있으며

 

 

1인용을 선택하면

 

게임 실행 화면으로 이동된다.

 

 

1인용 게임 시작화면.

 

 

 

 

(먹이를 먹으면서 몸통을 늘려가는 과정)

 

벽에 닿거나, 머리가 몸통에 박으면 게임이 끝나게 된다.

 

 

뱀이 죽어서 게임이 끝나게 되면 점수 판이 표시되는 ending화면으로 이동된다.

  

ending 화면

 

 

 

 

먹이를 16 먹고 죽은 후에 1600점이 표시되는 것을 확인할 있다.

 

재시작과 EXIT두개의 선택지가 나오게 되는데, '재시작 하시겠습니까?' 누르게 되면

 

처음 시작화면으로 돌아가게 된다.(첫번째 사진)

 

EXIT 누르게 되면

 

게임 창을 나가게 되는 화면이 보여지면서 창이 닫혀진다.

 

EXIT화면

 

 

 

 

'안녕히가세요' 라는 문구가 나온 창이 닫히게 된다.

 

 

 

마지막 목표

 

  • 2인용 구현 => 어려움이 많을 같다.
  • 게임이 지루하지 않게 약간의 난이도(속도) 조절
  • 간단한 아이탬 제작
  • 게임 도중 아무 키나 누르면 게임이 일시 정지 되는 현상 수정

 

 게임 실행 파일 올려놨습니다

(32비트 버전은 호환이 안되요 ㅠㅠ)

 

​dll 파일이 없어 실행이 안되는 경우 msvcr120d.dll(첨부파일)을 받아

 

 

 

c: > windows > sysWOW64에 복사 후 실행

 

'C언어' 카테고리의 다른 글

C언어 로또 프로그램 만들기  (0) 2015.08.26
C언어 게임 만들기(4일차)  (0) 2015.08.26
C언어 게임 만들기(3일차)  (0) 2015.08.26
C언어 게임 만들기(2일차)  (0) 2015.08.26
C언어 게임 만들기(1일차)  (0) 2015.08.26
블로그 이미지

토유

개발일지

,

4일차


수정된 코드


코드 보기

#include <stdio.h>...

#define  UP  72...

void setcursortype(CURSOR_TYPE c)...

void textcolor(int color_number)...

gotoxy(int x, int y)...

void printmap()… // 생략

 

void play()

{

int direction = UP;

int Y = 19;

int X = 70;

int TX = 70;

int TY = 19;       // 꼬리의 좌표를 나타냄

int Fheight, Fwidth;

int eat = 0;

int length = 1;

int SnakeNStar[40][40] = { 0 };

int UDRL[40][40] = { 0 };

// 머리가 남긴 방향값의 자취를 기록함

 

SnakeNStar[Y][X / 2] = 1;

gotoxy(X, Y);

textcolor(12);

printf("");

 

while (1)

{

if (eat == 0)

{

srand((unsigned)time(NULL));

Fheight = rand() % 38 + 1;

Fwidth = (rand() % 38 + 1) * 2;

SnakeNStar[Fheight][Fwidth / 2] = 2;

gotoxy(Fwidth, Fheight);

textcolor(14);

printf("");

eat++;

}

fflush(stdin);

if (kbhit())

{

do

{

direction = _getch();

} while (direction == 224);

}

 

if (direction == UP)

{

UDRL[Y][X / 2] = direction;


if (SnakeNStar[Y - 1][X / 2] == 2)                                      // 만약 다음에 움직일 칸이 먹이라면

{

//SnakeNStar[Y][X / 2] = 0; 

// 일단 현재칸을 0으로 만들고

//gotoxy(X, Y);

 // 커서를 현재칸에 옮긴 뒤

//printf("  ");

 // 공백을 채워준다.

// 뱀이 머리밖에 없을 때의 코드이므로 지워줌

 

SnakeNStar[--Y][X / 2] = 1;                                     // 움직일 칸에 이동해서 1

gotoxy(X, Y);                                                        // 커서를 움직일 칸에 이동 후

textcolor(12);

printf("");                                                          // Snake를 그려줌

Fheight = rand() % 38 + 1;                                     // 세로 랜덤값을 만들고

Fwidth = (rand() % 38 + 1) * 2;                                // 가로 랜덤값을 만듬

 

while (1)                                                              // 먹이가 생성될 때 까지 무한반복

{

if (SnakeNStar[Fheight][Fwidth / 2] != 1)              // 먹이가 생성될 자리가 공백이면

{

SnakeNStar[Fheight][Fwidth / 2] = 2;            // 먹이값을 채워준다.

gotoxy(Fwidth, Fheight);                             // 먹이 포인터를 이동한 후

textcolor(14);

printf("");                                              // 먹이를 그림

break;

}

else                                // 먹이가 생성될 자리가 공백이 아니면

{

Fheight = rand() % 38 + 1;                        // 랜덤함수를 계속 돌린다.

Fwidth = (rand() % 38 + 1) * 2;

  }

 }

}

else                                                        // 다음에 움직이는 칸이 공백

{

if (Y == 1)                                        // 다음칸이 벽이면 죽음

{

system("cls");

return;

}

 

SnakeNStar[TY][TX / 2] = 0;

// 현재 꼬리칸을 공백값으로 만들고

gotoxy(TX, TY); 

// 커서를 꼬리칸으로 이동

printf("  ");

// 공백을 채워줌

// 먹이를 먹지 않고 움직일때 마다 머리가 한칸 늘어나므로 꼬리가 없어지게 만듬

 

if (UDRL[TY][TX / 2] == UP)

 

{

TY--;

}

else if (UDRL[TY][TX / 2] == DOWN)

{

TY++;

}

else if (UDRL[TY][TX / 2] == RIGHT)

{

TX += 2;

}

else if (UDRL[TY][TX / 2] == LEFT)

{

TX -= 2;

}  // 뱀머리 방향의 자취를 확인한 방향대로 꼬리 좌표값을 변경해준다.(머리가 칸을 지날때 위로 움직였었다면 꼬리좌표의 Y값을 -1해줌)

 

SnakeNStar[--Y][X / 2] = 1;                                // 다음에 움직이는 칸에 뱀값을 집어넣고

gotoxy(X, Y);                                                            // 커서를 다음칸으로 이동

textcolor(12);

printf("");                                                                    // 뱀을 그려준다.

}

}

else if (direction == DOWN)...

else if (direction == LEFT)...

else if (direction == RIGHT)… // 생략 (위와 같음)

 

Sleep(90);

}

}

 

int interface01()...

void main()…  // 생략

 

 


바뀐


  • 먹이를 먹으면 꼬리가 늘어나도록 했다.



다음 목표


  • 점수 시스템을 추가해서 도전의식이 생기도록 한다.
  • 2인용을 구현 ( 하나의 맵에서 경쟁 )


'C언어' 카테고리의 다른 글

C언어 로또 프로그램 만들기  (0) 2015.08.26
C언어 게임 만들기(5일차)  (0) 2015.08.26
C언어 게임 만들기(3일차)  (0) 2015.08.26
C언어 게임 만들기(2일차)  (0) 2015.08.26
C언어 게임 만들기(1일차)  (0) 2015.08.26
블로그 이미지

토유

개발일지

,

3일차


오류 해결

 

  • switch구문을 if문으로 수정
  • 위에서 아래로 먹이를 먹을 때 방향 전환
  • 약간의 버퍼와 완전히 먹지 않아도 먹이가 없어짐
  • 이전 먹이와 근접한 거리의 먹이를 먹었을 경우 다른 먹이가 생성되지 않음

 

 

 

현재 게임 진행 코드


코드 보기

#include <stdio.h>

#include <conio.h>
#include <windows.h>
#include <stdlib.h>
#include <time.h>

#define  UP  72
#define  LEFT 75
#define  RIGHT 77
#define  DOWN 80
#define  ENTER 13

 

void textcolor(int color_number) //텍스트 칼라를 바꿔주는 함수
{
   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color_number);
}

 

gotoxy(int x, int y)
{
   COORD pos = { x, y };
   SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);

 

}

 

typedef enum { NOCURSOR, SOLIDCURSOR, NORMALCURSOR } CURSOR_TYPE;
void setcursortype(CURSOR_TYPE c){
   CONSOLE_CURSOR_INFO CurInfo;

 

   switch (c) {
   case NOCURSOR:
      CurInfo.dwSize = 1;
      CurInfo.bVisible = FALSE;
      break;
   case SOLIDCURSOR:
      CurInfo.dwSize = 100;
      CurInfo.bVisible = TRUE;
      break;
   case NORMALCURSOR:
      CurInfo.dwSize = 20;
      CurInfo.bVisible = TRUE;
      break;
   }
   SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CurInfo);
}

 

void printmap()
{
   int i;
   system("cls");
   printf("
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
   for (i = 1; i<39; i++)
   {
      printf("
                                                                                                                                                  ");
   }
   printf("
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");  }

 

void play()
{
   int direction = UP;
   int width = 19;
   int height = 38;
   int FX, FY;
   int eat = 0;
   int length = 1;
   int SnakeNStar[40][40] = { 0 };
   int dead;

 

   SnakeNStar[width][height / 2] = 1;
   gotoxy(height, width);
   printf("
");

 

   while (1)
   {
      if (eat == 0)
      {
         srand((unsigned)time(NULL));
         FX = rand() % 38 + 1;
         FY = (rand() % 38 + 1) * 2;
         SnakeNStar[FX][FY / 2] = 2;
         gotoxy(FY, FX);
         textcolor(14);
         printf("
");
         eat++;
      }
      fflush(stdin);
      if (_kbhit())
      {
         direction = _getch();
      }
      if (direction == UP)
      {

 

         if (SnakeNStar[width - 1][height / 2] == 2)         

// 만약 다음에 움직일 칸이 먹이라면
         {
            SnakeNStar[width][height / 2] = 0;                

// 일단 현재칸을 0으로 만들고
            gotoxy(height, width);                                

// 커서를 현재칸에 옮긴 뒤
            printf("  ");                                              

// 공백을 채워준다.
            SnakeNStar[--width][height / 2] = 1;              

// 그리고 움직일 칸에 이동해서 1
            gotoxy(height, width);                                

// 커서를 움직일 칸에 이동 후
            textcolor(12);
            printf("
");                                                

// Snake를 그려줌
            FX = rand() % 38 + 1;                  // 세로 랜덤값을 만들고
            FY = (rand() % 38 + 1) * 2;            // 가로 랜덤값을 만듬

 

            while (1)                        // 먹이가 생성될 때 까지 무한반복
            {
               if (SnakeNStar[FX][FY / 2] != 1)  

// 먹이가 생성될 자리가 공백이면
               {
                  SnakeNStar[FX][FY / 2] = 2;     

// 먹이값을 채워준다.
                  gotoxy(FY, FX);                      

// 먹이 포인터를 이동한 후
                  textcolor(14);
                  printf("
");                           // 먹이를 그림
                  break;
               }
               else                                      

// 먹이가 생성될 자리가 공백이 아니면
               {
                  FX = rand() % 38 + 1;            

// 랜덤함수를 계속 돌린다.
                  FY = (rand() % 38 + 1) * 2;
               }
            }
         }
         else                                            

// 다음에 움직이는 칸이 공백이면
         {
            if (width == 1)
            {
               system("cls");
               return;
            }

 

            SnakeNStar[width][height / 2] = 0;            

// 현재칸을 공백값으로 만들고
            gotoxy(height, width);                           

// 커서를 현재칸으로 이동
            printf("  ");                                          

// 공백을 채워줌
            SnakeNStar[--width][height / 2] = 1;         

// 다음에 움직이는 칸에 뱀값을 집어넣고
            gotoxy(height, width);                          

// 커서를 다음칸으로 이동
            textcolor(12);
            printf("
");                                         

// 뱀을 그려준다.

 


         }
      }

 

      else if (direction == DOWN)
      {
         if (SnakeNStar[width + 1][height / 2] == 2)
         {
            SnakeNStar[width][height / 2] = 0;
            gotoxy(height, width);
            printf("  ");
            SnakeNStar[++width][height / 2] = 0;
            gotoxy(height, width);
            textcolor(12);
            printf("
");
            FX = rand() % 38 + 1;
            FY = (rand() % 38 + 1) * 2;

 

            while (1)
            {
               if (SnakeNStar[FX][FY / 2] != 1)
               {
                  SnakeNStar[FX][FY / 2] = 2;
                  gotoxy(FY, FX);
                  textcolor(14);
                  printf("
");
                  break;
               }
               else
               {
                  FX = rand() % 38 + 1;
                  FY = (rand() % 38 + 1) * 2;
               }
            }
         }
         else
         {
            if (width == 38)
            {
               system("cls");
               return;
            }
            SnakeNStar[width][height / 2] = 0;
            gotoxy(height, width);
            printf("  ");
            SnakeNStar[++width][height / 2] = 1;
            gotoxy(height, width);
            textcolor(12);
            printf("
");

 

         }
      }

 

      else if (direction == LEFT)
      {
         if (SnakeNStar[width][(height - 2) / 2] == 2)
         {
            SnakeNStar[width][height / 2] = 0;
            gotoxy(height, width);
            printf("  ");
            SnakeNStar[width][(height -= 2) / 2] = 1;
            gotoxy(height, width);
            textcolor(12);
            printf("
");
            FX = rand() % 38 + 1;
            FY = (rand() % 38 + 1) * 2;

 

            while (1)
            {
               if (SnakeNStar[FX][FY / 2] != 1)
               {
                  SnakeNStar[FX][FY / 2] = 2;
                  gotoxy(FY, FX);
                  textcolor(14);
                  printf("
");
                  break;
               }
               else
               {
                  FX = rand() % 38 + 1;
                  FY = (rand() % 38 + 1) * 2;
               }
            }
         }
         else
         {
            if (height == 2)
            {
               system("cls");
               return;
            }
            SnakeNStar[width][height / 2] = 0;
            gotoxy(height, width);
            printf("  ");
            SnakeNStar[width][(height -= 2) / 2] = 1;
            gotoxy(height, width);
            textcolor(12);
            printf("
");
         }
      }

 

      if (direction == RIGHT)
      {
         if (SnakeNStar[width][(height + 2) / 2] == 2)
         {
            SnakeNStar[width][height / 2] = 0;
            gotoxy(height, width);
            printf("  ");
            SnakeNStar[width][(height += 2) / 2] = 1;
            gotoxy(height, width);
            textcolor(12);
            printf("
");
            FX = rand() % 38 + 1;
            FY = (rand() % 38 + 1) * 2;

 

            while (1)
            {
               if (SnakeNStar[FX][FY / 2] != 1)
               {
                  SnakeNStar[FX][FY / 2] = 2;
                  gotoxy(FY, FX);
                  textcolor(14);
                  printf("
");
                  break;
               }
               else
               {
                  FX = rand() % 38 + 1;
                  FY = (rand() % 38 + 1) * 2;
               }
            }
         }
         else
         {
            if (height == 146)
            {
               system("cls");
               return;
            }
            SnakeNStar[width][height / 2] = 0;
            gotoxy(height, width);
            printf("  ");
            SnakeNStar[width][(height += 2) / 2] = 1;
            gotoxy(height, width);
            textcolor(12);
            printf("
");
         }
      }
      Sleep(60);
   }
}

 

void makestar()
{

 

}

 

int interface01()
{
   int updown = 1;
   int x = 10, y = 5;
   gotoxy(x, y);

 

   system("cls");
   fflush(stdin);

 

   system("color 0b"); //색 변경
   int i;
   system("cls");
   printf("
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
   for (i = 1; i<39; i++)
   {
      printf("
                                                                                                                                                  ");
   }
   printf("
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
   // 맵
   textcolor(15);
   gotoxy(70, 10);
   printf(" SNAKE GAME\n");
   gotoxy(73, 13);
   printf(" MEUN\n");
   gotoxy(70, 16);
   printf(" GAME START \n");
   gotoxy(73, 17);
   printf(" EXIT \n");
   gotoxy(65, 16);
   printf("
");
   //
게임 시작 화면 인터페이스
   while (1)
   {
      switch (_getch())
      {
      case UP:
         updown = 1;
         gotoxy(65, 17);
         printf("  ");
         gotoxy(65, 16);
         printf("
");
         break;

 

      case DOWN:
         updown = 2;
         gotoxy(65, 16);
         printf("  ");
         gotoxy(65, 17);
         printf("
");
         break;
         //  game start , exit 선택
      case ENTER:
         if (updown == 1)
         {
            system("cls");
            return 1;
         }
         else
         {
            system("cls");
            gotoxy(70, 18);
            printf("안녕히
가세요\n");
            Sleep(1000);
            exit(0);

 

         }
      }
   }
}

 

//////////////////////////////////////////////////
void main()
{
   system("mode con: cols=150 lines=41"); //창 화면 크
   setcursortype(NOCURSOR);
   while (1)
   {
      if (interface01())
      {
         printmap();
         play();
      }
      else
      {
         break;
      }
   }
}

 

 


수정된 부분

  • 벽에 닿으면 죽음
  • 커서 제거
  • 먹이와 뱀의 색깔 구분

 

새로운 오류 발견


  • 게임 진행 중 먹이가 갑자기 한 개 더 생기는 오류(원인 불명)

다음 목표

  • 뱀의 길이 증가
  •  ending 화면 생성
  • 뱀 한 마리 더 추가
  • 먹이 생성 범위 증가


'C언어' 카테고리의 다른 글

C언어 로또 프로그램 만들기  (0) 2015.08.26
C언어 게임 만들기(5일차)  (0) 2015.08.26
C언어 게임 만들기(4일차)  (0) 2015.08.26
C언어 게임 만들기(2일차)  (0) 2015.08.26
C언어 게임 만들기(1일차)  (0) 2015.08.26
블로그 이미지

토유

개발일지

,

2일차


처음 시작 화면 메뉴를 화살표로 선택 진입


코드 보기

#include< stdio.h>

#include< conio.h>

#include< windows.h>

#include< stdlib.h>

#include< time.h>

 

#define  UP  72

#define  LEFT 75

#define  RIGHT 77

#define  DOWN 80

#define  ENTER 13

 


void textcolor(int color_number) //텍스트 칼라를 바꿔주는 함수

{

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color_number);

}

 

gotoxy(int x,int y)

{

    COORD pos = ;

    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);

}

 

//게임 시작 화면의 문구를 원하는 위치에 출력하고, 선택하기 위해 좌표 값을 지정해주는
//gotoxy함수를 사용했다.

 


void interface01()

{

    int updown=1;

    int x=10,y=5;

    gotoxy(x,y);


    system("cls");

    fflush(stdin);


    system("mode con: cols=150 lines=41"); //창 화면 크기

    system("color 0b"); //색 변경

 

    int i;

        system("cls");

        printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");

         for(i=1; i<39; i++)

         {

            printf("                                                                                                                                                  ");

        }

            printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");


         // 게임 시작 화면 테두리

 

        textcolor(15);

        gotoxy(64,10);

        printf(" SNAKE GAME\n");

 

        gotoxy(67,13);  

        printf(" MEUN\n");

 

        gotoxy(64,16);  

        printf(" GAME START \n");

 

        gotoxy(67,17);  

        printf(" EXIT \n");

 

        gotoxy(59,16);

        printf("");


        // 게임 시작 화면 인터페이스

        while(1)

        {

            switch(getch())

        {

            case UP:

            updown=1;

            gotoxy(59,17);

            printf("  ");

            gotoxy(59,16);

            printf("");

            break;


            case DOWN:

            updown=2;

            gotoxy(59,16);

            printf("  ");

            gotoxy(59,17);

            printf("");

            break;

            //  game start , exit 선택

    //​ scanf 제외하고 enter 입력받아 화면을 이동하도록 설정


            case ENTER:

 

            if(updown==1)

            {

                system("cls");

            }

            else

            {

                system("cls");

                gotoxy(59,17);

                printf("안녕히 가세요\n");

                exit(0);

            }

 

        int i;

        system("cls");

        printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");

 

         for(i=1; i<39; i++)

         {

            printf("                                                                                                                                                  ");

        }

            printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"); 

 

            //게임시작

 


//게임 실행 코드가 삽입될 부분

            //////////////////////////////////////////////////

 


뱀 먹이 만들기


코드 보기

void play()


{

int direction = UP;

int X = 19;

int Y = 38;

int FX, FY;

int eat= 0 ;               //시작하자마자의 상태를 나타내주는 변수인데 이름이 부적절한 같다.

int length = 1;           //현재 뱀의 길이를 나타내주는 변수. 아직은 머리만 구현중이기에 쓸데는 없다.

int SnakeNStar[40][40] = { 0 };

//먹이와 뱀의 위치를 저장해놓는 배열이다.

//먹이와 뱀이 곂치지 않게 해주는 역할.

​//0 공백, 1 , 2 먹이이다.

 


SnakeNStar[X][Y/2] = 1;

gotoxy(Y, X);

printf("");


while (1)

{

if (eat == 0)

{

srand((unsigned)time(NULL));

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;

SnakeNStar[FX][FY / 2] = 2;

gotoxy(FY, FX);

printf("");

eat++;

}

//게임 시작 직후에 별을 하나 생성한다.


if (kbhit())

{

direction = getch();

}

switch (direction)

{

case UP:


   if (SnakeNStar[X-1][Y / 2] == 2)                         // 만약 다음에 움직일 칸이 먹이라면

 {

SnakeNStar[X][Y / 2] = 0;                                // 일단 현재칸을 0으로 만들고

gotoxy(Y, X);                                                // 커서를 현재칸에 옮긴 뒤

printf("  ");                                                   // 공백을 채워준다.

SnakeNStar[--X][Y / 2] = 1;                              // 그리고 움직일 칸에 이동해서 1

gotoxy(Y, X);                                                 // 커서를 움직일 칸에 이동 후

printf("");                                                   // Snake를 그려줌

FX = rand() % 38 + 1;                                     // 세로 랜덤값을 만들고

FY = (rand() % 38 + 1) * 2;                               // 가로 랜덤값을 만듬


while (1)                 // 먹이가 생성될 때 까지 무한반복

{

if (SnakeNStar[FX][FY / 2] != 1)                       // 먹이가 생성될 자리가 공백이면

{

SnakeNStar[FX][FY / 2] = 2;                // 먹이값을 채워준다.

gotoxy(FY, FX);                                // 먹이 포인터를 이동한 후

printf("");                                     // 먹이를 그림

break;

}

else                    // 먹이가 생성될 자리가 공백이 아니면

{

FX = rand() % 38 + 1;                        // 랜덤함수를 계속 돌린다.

FY = (rand() % 38 + 1) * 2;

}

}

}

else                                     // 다음에 움직이는 칸이 공백이면

{

SnakeNStar[X][Y / 2] = 0;                                // 현재칸을 공백값으로 만들고

gotoxy(Y, X);                                                // 커서를 현재칸으로 이동

printf("  ");                                                   // 공백을 채워줌

SnakeNStar[--X][Y / 2] = 1;                              // 다음에 움직이는 칸에 뱀값을 집어넣고

gotoxy(Y, X);                                                 // 커서를 다음칸으로 이동

printf("");                                                   // 뱀을 그려준다.

break;

}


case DOWN:


if (SnakeNStar[X + 1][Y / 2] == 2)

{

SnakeNStar[X][Y / 2] = 0;

gotoxy(Y, X);

printf("  ");

SnakeNStar[++X][Y / 2] = 1;

gotoxy(Y, X);

printf("");

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;


while (1)

{

if (SnakeNStar[FX][FY / 2] != 1)

{

SnakeNStar[FX][FY / 2] = 2;

gotoxy(FY, FX);

printf("");


break;

}

else

{

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;

}

}

}

else

{

SnakeNStar[X][Y / 2] = 0;

gotoxy(Y, X);

printf("  ");

SnakeNStar[++X][Y / 2] = 1;

gotoxy(Y, X);

printf("");

break;

}


case LEFE:


if (SnakeNStar[X][(Y - 2) / 2] == 2)

{

SnakeNStar[X][Y / 2] = 0;

gotoxy(Y, X);

printf("  ");

SnakeNStar[X][(Y-=2) / 2] = 1;

gotoxy(Y, X);

printf("");

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;


while (1)

{

if (SnakeNStar[FX][FY / 2] != 1)

{

SnakeNStar[FX][FY / 2] = 2;

gotoxy(FY, FX);

printf("");

break;

}

else

{

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;

}

}

}

else

{

SnakeNStar[X][Y / 2] = 0;

gotoxy(Y, X);

printf("  ");

SnakeNStar[X][(Y-=2) / 2] = 1;

gotoxy(Y, X);

printf("");

break;

}

 

case RIGHT:


if (SnakeNStar[X][(Y + 2) / 2] == 2)

{

SnakeNStar[X][Y / 2] = 0;

gotoxy(Y, X);

printf("  ");

SnakeNStar[X][(Y+=2) / 2] = 1;

gotoxy(Y, X);

printf("");

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;


while (1)

{

if (SnakeNStar[FX][FY / 2] != 1)

{

SnakeNStar[FX][FY / 2] = 2;

gotoxy(FY, FX);

printf("");

break;

}

else

{

FX = rand() % 38 + 1;

FY = (rand() % 38 + 1) * 2;

}

}

}

else

{

SnakeNStar[X][Y / 2] = 0;

gotoxy(Y, X);

printf("  ");

SnakeNStar[X][(Y+=2) / 2] = 1;

gotoxy(Y, X);

printf("");

}

}

Sleep(70);

}

}

 

void main()

{

system("mode con: cols=150 lines=41");

interface01();

play();

}


수정해야 부분

 

  • 화살표 부분 커서 제거
  • 먹이를 완전히 먹지않고 닿기만 해도 먹이가 없어짐 => 왼쪽에서 먹으면 그렇지 않은데 case LEFT 코드를 분석해야 .
  • 위에서 내려오며 먹이를 먹으면 왼쪽으로 한칸 이동함 => 코드를 입력한 같다.

  • 먹이가 이전 먹이와 가깝게 생기면 다음 먹이가 나오지 않음 => 먹이 생성 코드 수정.

  • 1일차의 대부분의 문제점

    •  

 

 

다음 목표

 

  • 게임 실행 부분 코드 삽입
  • 뱀이 벽에 닿으면 죽음
  • ​엔딩 화면 제작





'C언어' 카테고리의 다른 글

C언어 로또 프로그램 만들기  (0) 2015.08.26
C언어 게임 만들기(5일차)  (0) 2015.08.26
C언어 게임 만들기(4일차)  (0) 2015.08.26
C언어 게임 만들기(3일차)  (0) 2015.08.26
C언어 게임 만들기(1일차)  (0) 2015.08.26
블로그 이미지

토유

개발일지

,

c언어 게임 만들기 -snake game !!

1일차


기본 인터페이스와 뱀 머리 구현 해보기


게임 시작화면 틀 잡기

코드 보기

#include< stdio.h>

#include <Windows.h> 
#include <conio.h>

#define LEFT 75

#define RIGHT 77

#define UP 72

#define DOWN 80

//방향키의 아스키값을 미리 정의해 놓았다.


gotoxy(int x,int y) 
{
    COORD pos = ;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);


}


//게임 시작 화면의 문구를 원하는 위치에 출력하고, 선택하기 위해 좌표 값을 지정해주는
//gotoxy함수를 사용했다.



void interface01()
{
    int a;
    int x=10,y=5;
    gotoxy(x,y);
    
     system("cls");
     fflush(stdin);
 
    system("mode con: cols=150 lines=41"); //창 화면 크기 
    system("color 0b"); //색 변경 -> 민트색

    int i;
    system("cls");
    printf("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");

         for(i=1; i<39; i++)
         {
            printf("
                                                                                                                                                  ");
        }
            printf("
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■");
         //
게임 시작 화면 테두리



 
        textcolor(15); 
        gotoxy(64,10);
        printf(" SNAKE GAME \n");


        gotoxy(67,13);   
        printf(" MEUN\n");


        gotoxy(64,16);   
        printf(" GAME START = y\n");
        scanf("%c",&a);


        gotoxy(67,17);   
        printf(" EXIT = n\n");
        scanf("%c",&a);


        gotoxy(59,16);
        printf("
");


//처음 화면에 출력될 문구 설정
//y를 입력하면 게임시작, n을 입력하면 게임 종료를 설정


if(a==y)

{

System("cls");

Printf("게임 실행 부분");


}

//입력 값이 y 경우

if(a==n)


{

System("cls");

printf("게임 종료");


}

//입력 값이 n 경우

else

{

exit(0);

}


//나가기


scanf 함수를 이용해 y , n 입력 받아 해당 창으로 이동한다.

게임 실행 부분에는 게임 코드 삽입

 

 


뱀 머리 기본 설정


코드 보기

void play()


{

int direction = UP;

int X = 19;

int Y = 38;

//시작할때의 머리 위치와 움직이는 방향을 미리 정해놓았다.

 

gotoxy(Y, X);

printf("");

//뱀 머리 출력

while (1)        //일단은 계속 반복되도록 했다.

{

if (kbhit())      

{

direction = getch();

}

//반복 키보드입력이 있다면 값을 direction 넣는다.

 

if (direction == UP)

{

gotoxy(Y, X);

printf("  ");

gotoxy(Y, --X);

printf("");

}

else if (direction == DOWN)

{

gotoxy(Y, X);

printf("  ");

gotoxy(Y, ++X);

printf("");

}

else if (direction == LEFT)

{

gotoxy(Y, X);

printf("  ");

gotoxy(Y -= 2, X);

printf("");

}

else if (direction == RIGHT)

{

gotoxy(Y, X);

printf("  ");

gotoxy(Y += 2, X);

printf("");

}

//입력되어 있는 방향값으로 한칸씩 움직이게 했다.

Sleep(50);

//0.05 마다 움직이게 해놨다. 조금 빠른 같은데 이것으로 난이도를 조정 가능할 것이다.

}

}

void main()

{

system("mode con: cols=150 lines=41");

//콘솔 창의 크기를 고정시켰다.


 



interface01();

play();

//나중에 인터페이스 부분과 합쳐야 하기 때문에 메인함수는 최대한 간소화 했다.

}

 

 

수정해야 될 부분.


    방향키를 제외한 나머지 값이 입력되면 방향키가 입력될때까지 기다린다. => 조건문을 하나 달아주면 같다.

    방향키를 연속으로 여러 누르면 뱀이 느려진다.

    방향키를 누른 다음 한턴 쉬고 방향이 전환된다.    => kbhit getch말고 다른 방법이 있나 찾아봐야 같다.

        뱀이 벽을 뚫고 지나간다. => 벽에 닿으면 게임오버되게 만들어야 .

        'C언어' 카테고리의 다른 글

        C언어 로또 프로그램 만들기  (0) 2015.08.26
        C언어 게임 만들기(5일차)  (0) 2015.08.26
        C언어 게임 만들기(4일차)  (0) 2015.08.26
        C언어 게임 만들기(3일차)  (0) 2015.08.26
        C언어 게임 만들기(2일차)  (0) 2015.08.26
        블로그 이미지

        토유

        개발일지

        ,

        Stack Bof(Buffer overflow)란?


        버퍼 오버플로우란 사용자가 입력 값을 과도하게 넣어서 원래 사용하는 스택의 영역보다 더 많은 공간을 차지하고, 시스템이 써야하는 스택 까지 사용자의 입력 값으로덮어 씌우는것을 말한다. (리턴 주소가 있는 공간을 사용자 입력 값으로 채워버린다.)




        Bof 예문




        5바이트 크기를 할당후 strcpy함수를 사용해, 5바이트를 초과하는 문자열을 삽입해도 오류가 나지 않는다.



        취약 함수 : strcpy, strcat, gets, fscanf, scnaf 등 ..


        예문 출력 값



        Stack Buffer overflow 구조







        '해킹/보안' 카테고리의 다른 글

        SSL(Secure Socket Layer)이란?  (0) 2015.09.23
        랜섬웨어란?  (0) 2015.09.08
        방화벽 이해  (0) 2015.08.27
        DHCP Snooping 이해  (0) 2015.08.26
        스택 프레임 형성 과정  (0) 2015.08.21
        블로그 이미지

        토유

        개발일지

        ,

        스택 프레임이란?


        ESP가 아닌 EBP 레지스터를 사용하여 로컬 변수, 피라미터 복귀 주소에 접근하는 기법이다. ESP 레지스터의 값은 수시로 변경되기 때문에 정확한 위치를 참고 하기 위해 ESP값을 EBP에 저장후 사용하는 것이다.


        스택 프레임의 기본 구조.



        스택 프레임 형성 과정


        스택 버퍼오버플로우 공격이 가능한 코드를 하나 짜서 예를 들어보자






        ▼ 어셈블리



        사진을 보면 스택프레임 형성 기본 구조들을 볼 수 있다.




        '해킹/보안' 카테고리의 다른 글

        SSL(Secure Socket Layer)이란?  (0) 2015.09.23
        랜섬웨어란?  (0) 2015.09.08
        방화벽 이해  (0) 2015.08.27
        DHCP Snooping 이해  (0) 2015.08.26
        Buffer Overflow(버퍼 오버플로우)공격  (0) 2015.08.26
        블로그 이미지

        토유

        개발일지

        ,