HowFastAll

2D Game Engine 만들기 – tutorial with SDL

Tim Jones | November 3rd, 2007 | 125 comments

 

Up to this point we have been laying the foundation for developing a game.

So far we've setup a basic structure to handle common routines,
we've setup a special class to handle events,
and we've also setup a class to handle a few surface functions.

In this tutorial we'll take all those things, combine them, and create a tic-tac-toe game.
Don't worry, things should be pretty simple.

Use the last tutorial to build off of.

이 시점에 우리는 게임을 개발하기 위한 토대를 세우고 있다.

지금까지 우리는 일반적인 루틴을 처리하는 기본 구조를 설정했습니다, ​​
우리는 이벤트를 처리하는 특별한 클래스를 설치했습니다, ​​
우리는 또한 몇 가지 표면 기능을 처리하는 클래스를 설정했습니다.

이 튜토리얼에서 우리는 모든 것들을 그들을 결합하고, tic-tac-toe게임을 만든다.
걱정하지 마세요, 일이 아주 간단합니다.

구축을 위해 마지막으로 튜토리얼을 사용합니다.

The first thing we are going to need to do is plan our game.
From experience, we know that tic-tac-toe has a 3x3 grid, where you place X's and O's.
So, we know that we will need 3 graphics, one for the grid, one for the X, and one for the O.

We don't need multiples of the X or O,
because we can draw them in the program as many times as we like.
Lets eliminate this first step.
Our grid is going to be 600x600, and our X's and O's will be 200x200 (1/3 of the area).

우리가 해야 할 것은 우선  우리 게임을 계획하는 것이다.
경험으로 부터, tic-tac-toe는 X와 O를 놓는, 3x3 격자를 가지고 있는 것을 알고 있다.

그래서,격자 하나,X 하나,그리고 O하나의 3개 그래픽이 필요하다는 것을 안다.

X와O가 여러 개 필요하지 않다, 왜냐면 프로그램에서 원하는 수 많큼 그것을 그릴수 있다

첫 번째 단계를 제거하실 수 있습니다.
우리의 격자는 600x600 될 것입니다, 그리고 X와 O는 200x200 (지역의 1 / 3)일것이다.

Now that we have our images, we are going to need a way to load them into our program.

Open up CApp.h and make some modifications.

Remove the Test Surface, and add three new surfaces.

지금 이미지를 가지고, 프로그램에 그들을 로드하는 방법이 필요 할것이다.
CApp.h을 열고 일부분을 수정합니다.
테스트 표면을 제거하고 세 개의 새로운 표면을 추가할 수 있습니다.

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

#ifndef _CAPP_H_ #define _CAPP_H_ #include <SDL.h> #include "CEvent.h" #include "CSurface.h" class CApp : public CEvent { private: bool Running; SDL_Surface* Surf_Display; private: SDL_Surface* Surf_Grid;     // grid image SDL_Surface* Surf_X;       // x image SDL_Surface* Surf_O;     // o image public: CApp(); int OnExecute(); public: bool OnInit(); void OnEvent(SDL_Event* Event); void OnExit(); void OnLoop(); void OnRender(); void OnCleanup(); }; #endif

Also, open up CApp.cpp and make some modifications.

Remove the Test Surface again, and add the three new ones again.

또한, CApp.cpp을 열고 일부분을 수정합니다. 

다시 테스트 표면을 제거하고 다시 세개의 새로운 것을 추가합니다.

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

#include "CApp.h" CApp::CApp() { Surf_Grid = NULL; Surf_X = NULL; Surf_O = NULL; Surf_Display = NULL; Running = true; } int CApp::OnExecute() { if(OnInit() == false) { return -1; } SDL_Event Event; while(Running) { while(SDL_PollEvent(&Event)) { OnEvent(&Event); } OnLoop(); OnRender(); } OnCleanup(); return 0; } int main(int argc, char* argv[]) { CApp theApp; return theApp.OnExecute(); }

And, you guessed it, open up CApp_OnCleanup.cpp to make some modifications there too.

Just like before, get rid of the Test Surface and add the three new ones.

그리고, 당신도짐작하듯이, CApp_OnCleanup.cpp을 열고 거기에 몇 가지 수정을 한다.

이전 처럼 그냥 테스트 표면을 제거하고 세개의 새로운것을 추가합니다.

1 2 3 4 5 6 7 8 9

#include "CApp.h" void CApp::OnCleanup() {   SDL_FreeSurface(Surf_Grid); SDL_FreeSurface(Surf_X); SDL_FreeSurface(Surf_O); SDL_FreeSurface(Surf_Display); SDL_Quit(); }

 

Now that we have the surfaces setup, lets load them into memory.

Open up CApp_OnInit.cpp, and make some changes.
Get rid of the test surface (again), and load the three new ones.
Be sure to put the correct filenames.
Also, change the dimensions of the window to 600x600, the size of the grid.
This make sure we don't have any blank space around the window we aren't using.

이제 우리는 표면 설정을 갖고 있고, 메모리에 그들을 로드할 수 있습니다.

CApp_OnInit.cpp을 열고, 일부 변경합니다.
테스트 표면 (다시) 없애 버리고, 그리고 세개의 새로운 것을 로드합니다.
올바른 파일 이름을 넣어주십시오.
또한, 그리드의 크기, 600x600로 창의 크기를 변경합니다.
이것은 윈도우 주변에 사용하지 않는 빈 공간이 갖지 않는 다는 것을 결정한다.

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include "CApp.h" bool CApp::OnInit() {   if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { return false; } if((Surf_Display = SDL_SetVideoMode(600, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) { return false; } if((Surf_Grid = CSurface::OnLoad("./gfx/grid.bmp")) == NULL) { return false; } if((Surf_X = CSurface::OnLoad("./gfx/x.bmp")) == NULL) { return false; } if((Surf_O = CSurface::OnLoad("./gfx/o.bmp")) == NULL) { return false; } return true; }

You may have noticed a change I made in the filenames.

I added ./gfx/ before the filename to specify which folder the graphics are in.

As games begin to grow it's very practical to have all the files in one folder.

Because of such, from here on, all images will be put in the gfx folder.

Now, let's get the grid showing up on the screen.

Open up CApp_OnRender.cpp and change the test surface rendering to make the grid render.

당신은 내가 파일 이름의 변경 사항을 발견 할 수 있습니다.

나는 그래픽 들어있는 폴더를 파일명으로 지정하기 전에 . /gfx/를 추가 했다

게임의 커지기 시작하기 전에 한 폴더에있는 모든 파일을을 갖는것은 아주 실용적이에요.

그러하기 때문에, 여기에서 부터, 모든 이미지는 gfx폴더에 넣어지게된다

자, 격자를 화면에 나타나게 하자.

CApp_OnRender.cpp을 열고, grid렌더링을 할 수있는 테스트 표면 렌더링을 변경합니다.

 

1 2 3 4 5 6 7

#include "CApp.h" void CApp::OnRender() {   CSurface::OnDraw(Surf_Display, Surf_Grid, 0, 0); SDL_Flip(Surf_Display); }

 

Try compiling your program, and if successful, you should see the grid show up.

Remember, there are basically 5 steps to using a surface:

declare it, set it to NULL, load it, draw it, and then free it.

It's good practice to learn all these 5 steps now,
because later on if you neglect one of these steps if can cause problems.

For example, neglecting to set a surface to NULL can cause undefined behavior,
or neglecting to free a surface can cause a memory leak.
프로그램을 컴파일 시도하고, 성공하면 그리드가 나타납니다.

기억할것은, 표면을 사용하여 기본적으로 5 단계가 있습니다

그것을 선언, NULL로 설정, 그것을 로드, 그것을 그리고, 그리고 그것을 해제한다.

문제를 일으킬 수 있는 것은, 단계 중 하나를 소홀히하면,
지금 모든 5 단계를 배울 것이 좋습니다.

예를 들어, NULL로 표면을 설정 무시하면 정의되지 않은 동작을 일으킬 수,
또는 표면 자유를 무시하면 메모리 누수가 발생할 수 있습니다.

You may have noticed something odd about the graphics we are using,

the X and O contain a pink background.

There is a reason for it, we are going to implement transparency onto these surfaces.

Basically, wherever there is pink, it will show through;

we will make the pink color transparent.

SDL offers a simple function to do this, SDL_SetColorKey.

To implement this, open up CSurface.h so we can add a new function.

당신은 우리가 사용할려는 그래픽 한테는 뭔가 이상한 것을 발견 할 수 있는데.

X와 O가 분홍색 배경을 포함하고 있다.

그 이유가 있다, 우리는 이러한 표면에 투명성을 구현하는 것입니다.

기본적으로, 핑크가 있는 곳이면 어디든지, 그것을 통해 표시됩니다,

우리는 핑크 색상을 투명하게 할것이다.

SDL은, SDL_SetColorKey로  간단한 기능을 제공합니다.

이것을 구현하려면, CSurface.h을 열어서, 새로운 기능을 추가 한다

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

#ifndef _CSURFACE_H_ #define _CSURFACE_H_ #include <SDL.h> class CSurface { public: CSurface(); public: static SDL_Surface* OnLoad(char* File); static bool OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y); static bool OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y, int X2, int Y2, int W, int H); static bool Transparent(SDL_Surface* Surf_Dest, int R, int G, int B); }; #endif

Now, to implement this function, open up CSurface.cpp and add the function:

이제,이 기능을 구현하려면, CSurface.cpp를 열고, 기능을 추가합니다 :

1 2 3 4 5 6 7 8 9

bool CSurface::Transparent(SDL_Surface* Surf_Dest, int R, int G, int B) { if(Surf_Dest == NULL) { return false; } SDL_SetColorKey(Surf_Dest, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB(Surf_Dest->format, R, G, B)); return true; }

Notice 3 extra arguments being passed besides the surface.

These are the 3 color values that we want to make transparent, it doesn't have to be just pink.

For instance, it we wanted red to be transparent it would be 255, 0, 0.

표면 이외에 전달되는 세가지 여분의 인수를 확인합니다.

이들은 우리가 투명하게 하려는 3가지 색상 값을 가지며, 단지 분홍색만 갖는거는 아니다.

예를 들어, 우리는 255, 0, 0 처럼 투명하게 하기 위해 빨간색을 원할 수 있다 .

This function first checks to see if we have a valid surface.

If so, we set a color key (transparency) for a color.

The first argument is the surface to apply the color key to,

the second is some flags telling SDL how to perform the operation,

and the third is the color to make transparent.

이 함수는 먼저 우리가 유효한 표면을 가지고 있는지 확인합니다.

그렇다면, 우리는 색상의 색상 키 (투명도)로 설정합니다.

첫 번째 인수가 색상 키를 적용하는 표면이며,

두 번째는 작업을 수행하는 방법에 SDL을 알려주는 몇 가지 플래그이고,

세 번째는 투명하게 하는 색상입니다.

 

The flags being applied are basic,

the first tells SDL to apply the color key to the source (the surface being passed)

and the second tells SDL to try to use RLE acceleration

(basically, try to make drawing later on faster).

The third argument is a little bit more complex; we are using SDL_MapRGB in order to create a color.

적용되는 플래그는 기본이고,

첫번째는 SDL의 소스 (표면이 전달되는)에 컬러 키를 적용하고,

두 번째는 (기본적으로, 나중에 빨리에 그림을 만들려고) RLE 가속을 사용하려고하는 SDL을 알려줍니다 알려줍니다.

세 번째 인수는 좀 더 복잡한 조금이다, 우리는 색깔을 만들기 위해 SDL_MapRGB를 사용하고 있습니다.

 

SDL_MapRGB takes a surface, and your requested color (R, G, B),

and tries to match it as close as it can to that surface.

You might be thinking why this is useful.

Not all surfaces have the same color palette.

Remember the old NES days where there was only a few colors that could be used?

Same idea here, SDL_MapRGB takes a color and matches it with the closest color on that surface palette.
SDL_MapRGB은 표면을 갖고, 그리고 요청 색상 (R, G, B) 소요되며,

가까이 그렇게 표면 수로 일치하려고 합니다.

왜 이것이 유용한지 이유를 생각할 수 있습니다.

모든 표면은 동일한 색상 팔레트 있습니다.

사용할 수 있는 몇가지 색깔이 있다는 것을 오래 전 NES 일 기억난는가 ?

여기도 같은 생각,  SDL_MapRGB는 색상을 갖고 표면 팔레트에 가까운 색상과 일치합니다.

Lets apply this new function to our surfaces now,

open up CApp_OnInit.cpp and make the following changes:

이제 표면이 새로운 기능을 적용할 수 있습니다 .

CApp_OnInit.cpp을 열고 다음과 같이 변경하십시오 :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include "CApp.h" bool CApp::OnInit() {   if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { return false; } if((Surf_Display = SDL_SetVideoMode(600, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) { return false; } if((Surf_Grid = CSurface::OnLoad("./gfx/grid.bmp")) == NULL) { return false; } if((Surf_X = CSurface::OnLoad("./gfx/x.bmp")) == NULL) { return false; } if((Surf_O = CSurface::OnLoad("./gfx/o.bmp")) == NULL) { return false; }  CSurface::Transparent(Surf_X, 255, 0, 255); CSurface::Transparent(Surf_O, 255, 0, 255); return true; }

Everything for the surfaces should be set.

The next thing we have to do is figure out a way to draw these X's and O's.

We can't just draw them everywhere on the grid

because they won't always be in the same spots.

What we are going to have to do is make an array of 9 containers,

the values in this array will tell us the values for each cell on the grid.

So, spot 0 would be the top left, 1 would be the top middle, 2 the top right, 3 the middle left, and so on.

Create this array by adding it to CApp.h:

표면에 대한 모든것을 설정해야 합니다.

우리가 해야 할 다음 것은 이러한 X와 O을 그릴 수있는 방법을 찾아야 한다.

왜냐하면 그들은 항상 같은 장소에 그리지 않을 것이기 때문입니다.

우리는 그리드 곳곳에 그들을 그릴 수 없습니다.

우리는 9개의 컨테이너의 배열을 만들어,

이 배열의 값은 우리에게 그리드에서 각 셀의 값을 알려줍니다.

그래서, 장소 0은 왼쪽 상단,1은 상단 중간, 2는 오른쪽 상단, 3은 중간 왼쪽, 등등이다.

CApp.h에 추가하여, 이 배열을 만듭니다

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

#ifndef _CAPP_H_ #define _CAPP_H_ #include <SDL.h> #include "CEvent.h" #include "CSurface.h" class CApp : public CEvent { private: bool Running; SDL_Surface* Surf_Display; private: SDL_Surface* Surf_Grid; SDL_Surface* Surf_X; SDL_Surface* Surf_O; private: int Grid[9]; public: CApp(); int OnExecute(); public: bool OnInit(); void OnEvent(SDL_Event* Event); void OnExit(); void OnLoop(); void OnRender(); void OnCleanup(); }; #endif

We know that each cell can have three possible values: Empty, X, and O.

These tell us what is currently in that cell.

To make things a little neater than having 0, 1, 2 as values,

we'll use an enum instead.

If you are unfamiliar with how an enum works, try finding a quick tutorial on them.

Just know that GRID_TYPE_NONE = 0, GRID_TYPE_X = 1, and GRID_TYPE_O = 2.

Go back to CApp.h and add the following underneath the Grid array:

각 칸은 세가지 가능한 값( 없다, X, 및 O )을 가질 수 있는 것을 알고 있다.

이것은 해당 칸에 현재 있는 것을 알려준다.

값으로 0, 1, 2 보다 조금 깔끔한 모양을 만들려면, 우리는 대신에 enum(열거)를 사용합니다.

Enum이 어떻게 작동하는지에 익숙하지 않다면, 빠르게 그에대해 튜토리얼을 찾도록 하세요.

그냥 알듯이 GRID_TYPE_NONE = 0, GRID_TYPE_X = 1, 그리고 GRID_TYPE_O = 2.

CApp.h로 이동하고 grid배열에 아래에 다음을 추가한다.

1 2 3 4 5

enum { GRID_TYPE_NONE = 0, GRID_TYPE_X, GRID_TYPE_O };

Note, up to this point I have been displaying practically all the code when I am referring to different files.

From here on, I expect you to know where code goes.

Most of the time I will tell you where to place it by, and sometimes I might display all the code.

Now that we have a way to know what a cell is, we're going to need a way to reset the board.

Let's create a new function at the bottom inside of CApp.h called Reset.

이 시점에서 ,나는 실제로 내가 다른 파일을 말할때는 모든 코드를 표시해왔다.

나는 코드가 어디로 가는지 알고있기를 기대하고 있습니다.

대부분의 시간을 내가 어디에 배치하는 것을 설명하고, 나도 가끔씩은 모든 코드를 보여 줬다.

이제 어떤cell인지 알 수 있는 방법을 가지고, 우리는 보드를 리셋하는 방법이 필요하다.

CApp.h의 하단 내부에 리셋하는 새로운 기능을 만들자.

1 2	public: void Reset();

Open up CApp.cpp and add the following function just before int main:

CApp.cpp을 열고 ,바로 int main() 바로 전에 다음 함수를 추가합니다 :

1 2 3 4 5

void CApp::Reset() { for(int i = 0;i < 9;i++) { Grid[i] = GRID_TYPE_NONE; } }

This loop will set every cell in the grid to GRID_TYPE_NONE,

meaning that all the cells are empty.

We're going to have to do this at the very beginning when our program is loaded,

so make a call to this function within the CApp_OnInit.cpp file:

이 루프는,모든 세포가 비었다는 의미로, GRID_TYPE_NONE으로그리드의 모든 세포를 설정한다.

우리의 프로그램이 처음에 로드될 때 시작 시점에 해야 하는 것을 위해,

CApp_OnInit.cpp 파일안에서 이 함수를 호출하게 한다:

1 2 3 4 5 6

//... CSurface::Transparent(Surf_X, 255, 0, 255); CSurface::Transparent(Surf_O, 255, 0, 255); Reset();

So far so good.

The next thing we are going to have to do is make the ability to place X's and O's on the screen.

Lets create a new function that will handle this.

Open up CApp.h again and add the function just below Reset.

지금까지 너무 좋다.

그 다음은 우리가 해야하는 건, 화면에 X와 O를 표시할 수있는 능력을 만드는 것입니다.

이 문제를 해결할 수 있는 새로운 기능을 만들 수 있습니다.

다시 CApp.h를 열고, 리셋 아래에 기능을 추가합니다.

1	void SetCell(int ID, int Type);

Now, open back up CApp.cpp and add the function:

이제 다시 CApp.cpp 열고, 함수를 추가합니다 :

1 2 3 4 5 6

void CApp::SetCell(int ID, int Type) { if(ID < 0 || ID >= 9) return;    // array size if(Type < 0 || Type > GRID_TYPE_O) return;    // type size Grid[ID] = Type; }

 

This function takes two arguments, the first is the cell ID to change,

and the second is the type to change it to.

We have to conditions here,

the first is to make sure we don't go outside the bounds of the array

(if we did it would likely crash our program),

and the second is to make sure we passed an appropriate type.

Simple enough.

 

Now, let's implement a way to draw the X's and O'.

Open up CApp_OnRender and add the following code just after the grid:

 

이 기능은 두 개의 인수를 갖는데, 첫번째는 변화는 셀 ID이며,

두 번째는 그것을 바꿀 수있는 유형입니다.

우리는 여기 조건에 있고,

첫 번째는 배열의 범위 밖으로 나가지 않도록 하는 것입니다,

(우리의 프로그램을 crash되는 것입니다)

그리고 두 번째는 우리가 적절한 형식을 전달되었는지 확인하는 것입니다.

아주 간단하다.

 

자, X와 O '를 그리는 방법을 구현하자.

CApp_OnRender을 열고, 그냥 그리드 뒤에 다음 코드를 추가합니다 :

1 2 3 4 5 6 7 8 9 10 11

for(int i = 0;i < 9;i++) { int X = (i % 3) * 200; int Y = (i / 3) * 200; if(Grid[i] == GRID_TYPE_X) { CSurface::OnDraw(Surf_Display,   Surf_X,   X, Y); } Else if(Grid[i] == GRID_TYPE_O) { CSurface::OnDraw(Surf_Display,   Surf_O,   X, Y); } }

This is a little bit more complex than we have been used to so far.

이것은 우리가 지금까지 사용해온 것 보다 약간 복잡한 하다.

 

Firstly, we are looping through each cell in the grid.

Next, we are translating that grid ID over to X and Y coordinates.

We do this in two different ways.

To find X, we take the remainder of i to 3.
첫째, 우리는 그리드의 각 세포를 통해 반복하고 있습니다.

다음, 우리는 X와 Y 좌표로 해당하는 그리드 ID를 변환하고 있습니다.

우리는 두 가지 방법으로 이 작업을 수행.

X를 찾으려면, 우리는 i의 3에 대한 나머지를 갖는다.

 

This will give us 0 when i is 0, 1 when i is 1, 2 when i is 2, 0 when i is 3, and so on.

We multiply it by 200 because each cell is 200x200 pixels.

To find Y, we divide by 3,

this causes Y to be 0 when i is 0, 1, 2,  Y to be 1 when i is 3, 4, 5, and so on.

We then multiply that by 200 as well.

 

이것이 i가 0일 때 0,  i가 1일때 1, i가 2일때 2, i가 3일때 0를 주는 기타등등이다.

각 cell은 200x200 픽셀이기 때문에, 우리는 200을 곱하면됩니다.

Y를 찾으려면, 우리는 3으로 나누고,

이것이 i가 0,1,2일떄  y가 0이 되고, i가 3,4,5일떄 Y는 1이 되는 기타등등이다.

그런 다음 200을 곱하면 됩니다.

 

I encourage you to really try to understand what is going on here

because this sort of method is used for tile based games.

당신이 진짜 무슨 일이 일어 났는지 이해하려고 하는 것이 좋습니다.

왜냐하면 타일 기반의 게임에 사용되는 방법이기 때문이다

Next, all we have to do is check the cell type, and then draw the correct surface at that cell.
다음, 우리가 할 일은 셀 유형을 확인하고, 다음 해당 셀에 올바른 표면을 그립니다.

Now that we have our surfaces drawing,

we'll need a way to communicate from the user to the computer.

We'll use mouse events for this.

When the users clicks a cell it will set the cell appropriately.

지금 우리가 표면에 그림을 가지고,

우리는 사용자의 컴퓨터와 통신할 수있는 방법이 필요합니다.

우리는 이에 대한 마우스 이벤트를 사용합니다.

사용자가 셀을 클릭했을 때 적절하게 세포를 설정합니다.

 

We are going to need to overload one of the CEvent functions for this.

Open up CApp.h and add the following function just below OnEvent and next to OnExit.

우리는 이에 대한 CEvent 기능 과부하 하나 필요할 것입니다.

CApp.h을 열고 그냥 OnEvent 및 OnExit 옆의 아래에 다음 함수를 추가합니다.

1	void OnLButtonDown(int mX, int mY);

Now, open up CApp_OnEvent.cpp and add the function:

이제 CApp_OnEvent.cpp를 열고, 기능을 추가합니다 :

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

void CApp::OnLButtonDown(int mX, int mY) { int ID = mX / 200; ID = ID + ((mY / 200) * 3); if(Grid[ID] != GRID_TYPE_NONE) {   // already used return; } if(CurrentPlayer == 0) { SetCell(ID, GRID_TYPE_X); CurrentPlayer = 1; }else{ SetCell(ID, GRID_TYPE_O); CurrentPlayer = 0; } }

First, we are doing the reverse of what we did with translating to X and Y from an ID,

this time we are translating to an ID.

We then make sure that that cell hasn't already been taken,

if it has, we return out of the function.

첫째, 우리는 우리가 ID로 변환하는 이 순간에,

ID에서 X와 Y에 변환의 방법의 반대로 하고 있습니다.

우리는 그런 다음 cell 이미 사용중인지 확인하고,

그것이 있다면, 우리는 함수는 return을 합니다.

 

Next, we are checking which players turn it is,

set the cell appropriately, and then switch turns.

CurrentPlayer is a new variable to specify whose turn it is, so we'll need to add this.

다음, 우리는 Player가 적절하게 cell를 설정하고,

다음 순서를 바꾸는 것을 설정하는 검사입니다.

CurrentPlayer 누구의 순서인지를 지정하는 새로운 변수이기 때문에, 우리는 이것을 추가해야합니다.

 

Open up CApp.h and add the variable below the grid array:

CApp.h을 열고 그리드 어레이 아래의 변수를 추가합니다 :

1	int CurrentPlayer;

Also, set the default value for this variable in CApp.cpp:

또한, CApp.cpp에서 , 이 변수에 대한 기본값을 설정합니다 :

1 2 3 4 5 6 7 8 9 10 11

CApp::CApp() { CurrentPlayer = 0; Surf_Grid = NULL; Surf_X = NULL; Surf_O = NULL; Surf_Display = NULL; Running = true; }

 

 

Try compiling the program and you should have a mostly working version of tic-tac-toe. Congratulations!
프로그램을 컴파일하려고, 당신은 tic-tac-toe의 대부분 작업 버전이 있어야 합니다.

축하합니다!

This is where you take the rest of it yourself.

We have a solid foundation for our game, and most the work done.

I encourage you to take this a step further.

너 자신을 그것의 나머지를 곳입니다.

우리는 게임을 위한 견고한 토대를 가지고 있고, 대부분의 작업은 완료했다.

난 당신이 한 걸음 더 나아가 이것을 받아보실 것을 권해드립니다.

 

Try adding a "X Won", "O Won", and "Draw" at the end of each game (extra images here).

Think, how are you going to check who won (a function for this purpose would fit well)?

 

추가보십시오, 각 게임의 끝 부분에 "X승" "O승”,그리고 "무승부” (여기에 추가 이미지).

어떻게 누가 이긴건지를 확인하는 것은, 생각해 보세요.(이 목적에 함수가 잘 맞는)?

 

Try adding a way to reset the game after it's done.

이 일을 후에 게임을 다시 설정하는 방법을 추가해보세요.

 

If you are brave, try to add some generic AI that will play against the user.

And if you are even braver,

try adding the ability to play player vs. player, or player vs. computer.

당신은 용기가 있는 경우, 사용자가 대결하는 몇 가지 일반적인 AI를 추가하는 것을 시도해라.

그리고 당신이 더 용기가 경우,

플레이어 대 플레이어 또는 컴퓨터 대 플레이어를  재생할 수있는 능력을 추가해보십시오.

When you are ready, and have a firm grasp of this tutorial,

move on to the next lesson to look at frame animation.

 

준비하고 있으며,이 튜토리얼의 확고한 이해를 가지면,

프레임 애니메이션에서 볼 수있는 다음 강의로 이동하십시오.