UpWrite

수학. 곱셈 공식과 인수 분해

라이피 (Lypi) — Thu, 16 Feb 2023 00:34:02 +0900

대수식을 간단하게 만들기 위해서 외워두어야 하는 공식들.

곱셈공식

복부호 동순

01) \( (a±b)^2 = a^2±2ab+b^2 \)

02) \( (a+b)(a-b) = a^2-b^2 \) 중요

03) \( (x+a)(x+b)(x+c) = x^3+(a+b+c)x^2+(ab+bc+ca)x + abc \)

04) \( (a+b+c)^2 = a^2+b^2+c^2+2(ab+bc+ca) \)

05) \( (a±b)^3 = a^3±3a^2b+3ab^2±b^3 \)

06) \( (a+b)(a^2-ab+b^2)=a^3+b^3 , (a-b)(a^2+ab+b^2)=a^3-b^3 \) 중요

07) \( (a+b+c)(a^2+b^2+c^2-ab-bc-ca) = a^3+b^3+c^3-3abc \)

08) \( (a^2+ab+b^2)(a^2-ab+b^2) = a^4+(ab)^2+b^4 \)

02)는 \(a^2-b^2\)을 인수분해할 때 사용된다.

03)는 3차식의 인수분해에 사용된다.

06)은 \(a^3±b^3\)을 인수분해할 때 사용된다.

11) \(a^2+b^2 = (a+b)^2-2ab = (a+b)(a-b)+2b^2 =(a-b)^2+2ab \)

12) \(a^3+b^3 = (a+b)^3-3ab(a+b) \)

인수분해

복부호동순

01) \( a^2±2ab+b^2 = (a±b)^2 \)

02) \( a^2-b^2 = (a+b)(a-b) \)

03) \( a^3+b^3 = (a+b)(a^2-ab+b^2) , a^3-b^3 = (a-b)(a^2+ab+b^2) \)

04) \( a^3 ± 3a^2b + 3ab^2 ± b^3) = (a±b)^3 \)

05) \( a^2+b^2+c^2+2(ab+bc+ca) = (a+b+c)^2 \)

06) \( a^4+(ab)^2+b^4 = (a^2+ab+b^2)(a^2-ab+b^2) \)

07) \( a^3+b^3+c^3 - 3abc = (a+b+c)(a^2+b^2+c^2-ab-bc-ca) \)

C&C++ a1 동적할당 연습

라이피 (Lypi) — Tue, 14 Feb 2023 23:19:28 +0900

#include <iostream>
#include <string.h>
using namespace std;

int main()
{
    char name0[100];
    int nameVolume = 1;
    char** nameList = new char*[nameVolume];
    int count = 0;

    while(true) {
        cout << "너의 이름에는 힘이 있다. 이름을 입력하라." << endl;
        cin >> name0;
        

        if(strcmp(name0, "EXIT") == 0) {
            return 0;
        }

        nameList[count] = new char[strlen(name0)+1];
        strcpy(nameList[count],name0);

        cout << "현재 저장된 이름의 갯수" << endl << count+1 << endl;
        cout << "현재 저장된 이름 목록" << endl;

        for (int i = 0; i <= count; i++) {
            cout << nameList[i] << endl;
        }

        if(count+1 >= nameVolume) {
            nameVolume++;
            char* tempList[nameVolume];
            memcpy(&tempList, &nameList, sizeof(nameList));
            nameList = new char*[nameVolume];
            memcpy(&nameList, &tempList, sizeof(tempList));

        }
        cout << "끝내려면 EXIT" << endl;
        count++;
    }

    for (int i = 0; i < count; i++) {
        delete nameList[i];
    }
    delete[] nameList;

    return 0;
}

◆ 버퍼에 문자열을 입력받고 이름의 길이만큼 문자열 배열을 동적할당 받는다.

◆ 이를 저장하기 위한 리스트를 1개씩 동적할당한다.

◆ 1개씩 하면 매번 새로운 이름을 입력할 때 마다 동적할당을 반복해야해서 퍼포먼스가 떨어지지만

◆ 이번에는 연습이니까 확인을 쉽게 하기 위해서 매번 해주도록 했다.

◆ 5개씩 하려고 하니까 세그멘테이션 오류가 떳다...

◆ 사실 C++을 쓰면 string과 Vector를 쓰면 해결될 문제.

◆ 물론 string과 Vector를 공부해야함...

C(&C++) 이론 20. 동적 할당

라이피 (Lypi) — Mon, 13 Feb 2023 18:38:15 +0900

내용 참고

C++ 기초플러스 4판 (성안당)

혼자 연구하는 C/C++ (Soen.kr/와우북스)

동적 할당

■ 동적 할당이란 프로그래밍 시점에서는 메모리가 얼마나 필요한지 알 수 없어 실행 중에 메모리를 할당하는 것을 말한다.

■ 예를 들어 주소록을 저장하는 배열을 만들어야 하는데, 몇명이나 저장해야 할지 모를 때 동적할당을 사용한다.

■ 동적할당 대신에 충분히 큰 배열을 만들어 놓으면 대처할 수는 있겠지만 이 경우에는 메모리 낭비가 극심할 것이다.

■ C언어에서는 동적할당을 위해서 malloc()과 free()라는 함수를 사용했다.

■ C++에서는 언어에서 지원하는 new와 delete라는 전용 연산자를 사용한다.

■ C++의 명령어가 더 사용이 편하고 직관적이기 때문에 주로 C++의 방법이 사용된다.

■ 여기서 free()와 delete는 할당받은 메모리를 반납하는 역할을 한다.

ⅰ. C언어의 경우

■ C언어에서 임의의 크기를 갖는 int형 배열을 동적할당하고 싶다면 아래와 같이 쓰면 된다.

int* pi;
int num;

pi = (int*)malloc(num * sizeof(int));

free(pi);

■ 일반 배열이면 변수인 num으로 크기 지정을 할 수 없기 때문에 동적할당을 해야한다.

■ malloc() 함수는 void형 포인터를 반환하므로 필요한 타입으로 캐스팅이 필요하다.

■ malloc() 함수의 인자로는 동적할당 받을 크기를 넣어줘야 하므로 갯수 * 타입의 크기를 계산해서 넣는다.

■ 마지막에 동적할당받은 메모리를 free() 함수로 반환한다.

■ free() 함수의 인자로 동적할당 받은 포인터를 넘기면 된다.

■ 위의 예제의 전체 코드는 아래와 같다.

#include <iostream>
using namespace std;

int main()
{
    int* pi;

    int num;
    cin >> num;

    pi = (int*)malloc(num * sizeof(int));

    for (int i = 1; i <= num; i++) {
        pi[i-1] = i;
        cout << pi[i-1] << endl;
    }

    free(pi);

    return 0;
}

■ num 변수에 임의의 수를 입력받아 int형 포인터인 pi에 그만큼의 사이즈를 동적할당 받았다.

■ 동적할당된 배열에는 간단하게 차례대로 1부터 num까지의 숫자를 저장한뒤 출력했다.

ⅱ. C++의 경우

■ C++에서 임의의 크기를 갖는 int형 배열을 동적할당하고 싶다면 아래와 같이 쓰면 된다.

int* pi;
int num;

pi = new int[num];

delete[] pi;

■ new 연산자의 뒤에 어떤 타입을 몇개 받을지 적어주면 끝이다.

■ 뒤에 타입을 적기 때문에 따로 캐스팅할 필요가 없으며, 크기 계산도 필요 없어졌다.

■ 주의할 점은 new int; 로 int형 한개를 동적할당 받는 경우에는 delete pi;로 반환하지만,

■ 위와 같이 new int[num];으로 임의의 갯수를 배열로 할당받는 경우에는 delete[] pi;로 반환해야 한다는 것이다.

■ new와 delete, new (타입)[]와 delete[]의 두쌍이 있다고 생각하는게 좋다.

■ delete를 빠트리거나 잘못 쓸 경우 컴파일 에러가 나지 않고, 메모리가 누수되므로 작성 시점에서 주의해야한다.

#include <iostream>
using namespace std;

int main()
{
    int* pi;

    int num;
    cin >> num;

    pi = new int[num];

    if (pi != NULL) {
        for (int i = 1; i <= num; i++) {
            pi[i-1] = i;
            cout << pi[i-1] << endl;
        }
    }

    delete[] pi;

    return 0;
}

■ 할당에 실패할 경우 null포인터를 반환하므로 위에서는 if문으로 예외처리를 해주었다.

C(&C++) 이론 19. 이중 포인터

라이피 (Lypi) — Sun, 12 Feb 2023 15:03:22 +0900

내용 참고

혼자 연구하는 C/C++ (Soen.kr/와우북스)

이중 포인터

■ 이중 포인터란 포인터를 가리키는 포인터라는 의미이다.

■ int** ppi; 라고 쓰면 이중 포인터가 되고, int*** pppi; 라고 쓰면 3중 포인터가 될 것이다.

■ 원한다면 10중 포인터나 그 이상도 만들 수 있지만 3중 포인터 이상은 딱히 의미가 없다.

■ T형 타입에 대한 T형 포인터를 만들 수 있다.

■ T형 포인터는 하나의 타입으로 인정된다.

■ 즉, T형 포인터에 대한 포인터를 만들 수 있다.

■ 이런식으로 사용할 수 있다.

#include <iostream>
using namespace std;

int main() 
{
  int i = 1234; 
  int* pi = &i; 
  int** ppi = &pi;
  
  cout << **ppi << endl;
}

■ 여기서 주의할 점은 int* pi = &i; 상태에서 int** ppi = π는 가능하지만, int** ppi = &&i;는 안된다는 것이다.

■ 포인터 안의 값을 읽어내는 * 연산자는 중복 사용이 가능하지만, 주소값을 저장하는 & 연산자는 중복 사용이 안된다.

■ 왜냐하면 &i 의 리턴값은 아직 메모리에 저장되지 않은 값일 뿐이기 때문이다.

■ 그래서 이 값을 int* pi; 라는 메모리 안에 담고 그 메모리 주소를 저장해야 한다.

■ 대신에 * 연산자는 주소값의 실제 위치에서 값을 뽑아오므로 int* pi; 안에 주소값이 있다면 연속으로 접근이 가능하다.

■ 이중 포인터는 문자열이나 배열처럼 그 자체가 포인터인 값을 이용할 때 유용하다.

#include <iostream>
#include <string.h>

using namespace std;

void InputName(char** pName) 
{
  *pName= new char;
  strcpy(*pName, "Cabin");
}

int main()
{
  char* name;
  
  InputName(&name);
  cout << name << endl;
  
  delete name;
}

■ void InputName(char** pName) 함수는 문자열인 char* 타입의 주소를 인자로 받는 함수이다.

■ *pName;은 인자로 받은 char* 타입을 의미하며 new로 char형을 동적할당하면 char* 값이 리턴된다.

■ 문자열인 char* 의 주소는 char** 타입이다.

■ 이 부분은 참조 호출이 필요한 부분이기 때문에 주소로 주고받아야 하는 것이다.

C(&C++) 이론 18. 포인터 응용

라이피 (Lypi) — Wed, 18 Jan 2023 18:09:25 +0900

내용 참고

혼자 연구하는 C/C++ (Soen.kr/와우북스)

포인터 응용

■ 포인터의 기본 개념은 단순한 만큼 파생될 수 있는 내용이 많다.

■ 특히 포인터와 메모리에 대한 내용과 이중 포인터, 포인터 배열, 배열 포인터, 함수 포인터 등이 중요하다.

■ 여기서는 *ptr++ 표현에 대한 내용과 void형 포인터에 대한 내용을 담았다.

**Ⅰ. *ptr++**

■ 처음보면 당황스러울 수 있는 표현이다. 차근차근 분석해보자.

ⅰ. 예제

#include <iostream>
using namespace std;

int main()
{
    int ar[] = {1,2,3,4,5};

    int arMAX = sizeof(ar)/sizeof(ar[0]);

    //배열의 이름은 상수 포인터로 배열의 첫번째 요소를 가리키지만, 
    //sizeof() 연산자에서는 배열 전체의 크기를 리턴한다.
    
    int* ptr;

    //*ptr++은 포인터의 값을 리턴하고 다음 요소로 하나씩 넘어간다.
    ptr = ar;  
    for (int i = 0; i < arMAX; i++) {
        cout << "ptr = " << *ptr++ << " ";
    } 
    cout << endl;

    //*ptr++을 풀어쓰면 다음과 같다.
    ptr = ar;  
    for (int i = 0; i < arMAX; i++) {
        cout << "ptr = " << *ptr << " ";
        ptr++;
    } 
    cout << endl;
}

ⅱ. 포인터로서의 배열의 이름과 sizeof()

■ 앞에서 언급했지만 배열의 이름은 포인터 상수이며, 배열의 첫번째 요소를 가리킨다.

■ 즉, int* ptr = ar; 과 int* ptr = &ar[0];은 같다.

■ 하지만 배열의 이름을 sizeof()로 계산하면 배열의 전체 크기가 나온다.

■ 그러므로 sizeof(ar)은 배열의 전체 크기를 반환하고 sizeof(ar[0])은 배열 요소 하나의 크기를 반환한다.

**ⅲ. (ptr)과 (ptr++)을 합치면 ptr++**

■ *ptr++; 는 1) *ptr;로 포인터 ptr이 가리키는 값을 리턴하고, 2) ptr++로 다음 주소의 요소로 이동한다.

■ 왜냐하면 후위 증감 연산자는 값이 리턴된 뒤에야 계산되기 때문이다.

■ 이 표현은 공식 문서 등에서도 많이 사용되는 표현이기 때문에 알아둘 필요가 있다.

Ⅱ. void형 포인터

■ C 및 C++에서 void는 타입이 없음을 나타내는 예약어이다.

■ 일반 변수를 선언할 때는 당연히 쓸 수 없고, 함수와 포인터에만 쓸 수 있다.

■ void형 포인터는 일반 포인터와는 다른 특성을 갖는다.

ⅰ. 임의의 대상체를 가리킬 수 있다.

■ void형 포인터는 일반 포인터와는 달리 임의의 대상체를 가리킬 수 있다.

■ 이때 명시적인 캐스팅은 필요로 하지 않는다.

■ 반대로 일반 포인터에 void형 포인터를 대입할 때는 반드시 명시적인 캐스팅을 해야한다. (C++ 기준)

ⅱ. 대상체의 값을 바로 가져올 수 없다.

■ void 포인터인 상태로는 대상체가 무슨 타입인지 모르기 때문이다.

■ 대신에 명시적 캐스팅을 한 상태에서는 대상체의 값을 가져올 수 있다.

#include <iostream>
using namespace std;

int main()
{
    void* vp;

    int i = 68;
    char c = 'k';
    float f = 0.1;

    vp = &i;
    //cout << *vp << endl; // 에러
    cout << *(int*)vp << endl;

    vp = &c;   
    cout << *(char*)vp << endl;

    vp = &f;
    cout << *(float*)vp << endl;
}

■ 이렇게 대상체의 타입을 정확하게 알고, 그 타입의 포인터로 캐스팅을 하면 사용할 수 있다.

ⅲ. 증감 연산자를 사용할 수 없다.

■ 대상체의 값을 가져올 수 없는 것과 같은 이유이다.

■ 대상체의 타입을 모르므로 얼마나 이동해야하는지 모르기 때문이다.

#include <iostream>
using namespace std;

int main()
{
    int ar[] = {1,2,3,4};

    int arMAX = sizeof(ar)/sizeof(ar[0]) - 1;

    void* vp = ar;

    for (int i = 0; i <= arMAX; i++) {
        cout << *(int*)vp << endl;      //윗 내용
        vp = (int*)vp + 1; //이번 내용
    }
}

■ void형 포인터를 이용하여 증감 연산자처럼 쓰고 싶으면 위의 방법밖에 없다.

ⅳ. 정리

■ void형 포인터는 대상체가 정해져 있지 않으므로 임의의 번지를 지정하는 것만 가능하다.

■ void형 포인터는 *연산자로 값을 읽거나, 증감 연산자를 사용하려면 반드시 명시적 캐스팅이 필요하다.

Ⅲ. NULL 포인터

ⅰ. 정의

■ null 포인터란 포인터에 저장된 주소값이 null, 즉 0인 포인터이다.

■ 주소값이 0이라는 소리는 절대 주소로 메모리 번호가 0인 위치이다.

■ #define NULL 0 이라는 명령어로 숫자 0 대신 NULL을 사용하는 것이 더 직관적이다.

■ 헤더파일에 정의되어 있으므로 직접 정의해야할 일은 거의 없을 것이다.

ⅱ. 실제 의미

■ 절대 번지가 0인 메모리는 시스템 영역이기 때문에 응용 프로그램에서 이 위치를 건드려서는 안된다.

■ 그래서 null 포인터는 에러를 나타내도록 약속되어 있다.

■ 포인터를 반환하는 함수들은 에러가 발생했을 때 이 NULL값을 리턴한다.

ⅳ. 예외 처리

■ null은 0이기 때문에 에러 상황에서 반환된 값을 그대로 사용하면 문제가 생길 여지가 있다.

■ 그래서 포인터를 반환하는 함수가 null을 반환하는지 확인하는 예외 처리를 할 필요가 있다.

■ 예를 들어 문자열의 특정 문자를 찾아서 변환하는 함수인 strchr() 함수의 경우를 보자.

#include <iostream>
#include <string.h>

int main() 
{
  char str[] = "korea";
  char *p;
  
  p = strchr(str,'s');
  //if(p != NULL) {
    *p = 'r';
  //}
  puts(str);
}

■ 8번째 줄에서 char형 포인터에 strchr() 함수의 반환값을 담고 있다.

■ "korea" 라는 문자열에는 's'가 없으므로 strchr() 함수는 null값을 반환할 것이다.

■ 여기서 if문으로 예외처리를 하지 않았다면 10번째 줄은 0번지의 값을 변경하려고 시도해서 런타임 에러가 발생한다.

C(&C++) 실습 13. 테트리스 개작

라이피 (Lypi) — Mon, 16 Jan 2023 18:55:05 +0900

출처

soen.kr

#include "Turboc.h"

//키 바인딩
#define LEFT 75
#define RIGHT 77
#define UP 72
#define DOWN 80
#define ESC 27
#define PGUP 73
#define PGDN 81

//게임판 좌 상단 좌표와 게임판의 넓이와 높이
#define BX 5
#define BY 1
#define BW 10
#define BH 20

void DrawScreen();
void DrawBoard();
bool ProcessKey();
void PrintBrick(bool show);
int GetAround(int x, int y, int b, int r);
bool MoveDown();
void TestFull();
void DrawNext();
void PrintInfo();

//좌표를 나타내는 구조체
struct Point {
	int x, y;
};

//벽돌 모양을 정의한 배열
//마지막에 전통 테트리스와 다른 3가지 모양이 추가되었다.
Point Shape[][4][4] = {
     { {0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2}, {0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2} },
     { {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1} },
     { {0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1}, {0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1} },
     { {0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1}, {0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1} },
     { {0,0,-1,0,1,0,-1,-1}, {0,0,0,-1,0,1,-1,1}, {0,0,-1,0,1,0,1,1}, {0,0,0,-1,0,1,1,-1} },
     { {0,0,1,0,-1,0,1,-1}, {0,0,0,1,0,-1,-1,-1}, {0,0,1,0,-1,0,-1,1}, {0,0,0,-1,0,1,1,1} },
     { {0,0,-1,0,1,0,0,1}, {0,0,0,-1,0,1,1,0}, {0,0,-1,0,1,0,0,-1}, {0,0,-1,0,0,-1,0,1} },
     { {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}},
     { {0,0,0,0,0,0,0,1}, {0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1}, {0,0,0,0,0,0,1,0}},
     { {0,0,0,0,0,-1,1,0},{0,0,0,0,-1,0,0,-1},{0,0,0,0,0,1,-1,0},{0,0,0,0,0,1,1,0} },
};

//게임판 상태 표시
enum {EMPTY, BRICK, WALL};
//게임판에 표시할 문자. 위의 열거형 값과 동일한 순서로 맞췄다.
const char* arTile[][3] = 
    { {". ","■", "□"}, 
      {"  ","■", "□"},
      {"  ","##", "||"},
      {". ","●", "▩"},
    };
//arTile[EMPTY] == ". " 이다.
int ttype = 0;

//외벽을 포함한 게임판의 상태를 기록한다.
//x축 y축의 순서이며 넓이가 x축에 기록되었으므로 
//반시계 방향으로 90도 돌아가게 기록될 것이다.
int board[BW + 2][BH + 2];

//이동중인 벽돌의 배열상의 현재 좌표이다.
//화면상의 좌표로 변환하려면 BX+nx*2, BY+ny식을 쓰면 된다. 
//벽돌 하나가 x축(넓이) 두칸, y축 (높이) 한칸을 차지하기 때문이다. 
//"::"이런 느낌이다.
int nx, ny;

//이동중인 벽돌의 번호와 회전번호를 나타낸다.
int brick, rot;

//다음에 나올 벽돌을 미리 저장한다.
int nbrick;

//점수와 총 벽돌 갯수
int score, bricksum;

int main() {

    setcursortype(NOCURSOR);
    randomize();

    while (3) {
    clrscr();

    //게임 초기화 (보드 배열을 초기화한다.)
    for (int x = 0; x < BW + 2; x++) {
        for (int y = 0; y < BH + 2; y++) {
            board[x][y] = (y == 0 || y == BH + 1 || x == 0 || x == BW + 1) ? WALL : EMPTY;
        }
    }
    //보드를 그린다.
    DrawScreen();
    int nFrame = 20;
    score = 0;
    bricksum = 0;

    nbrick = random(sizeof(Shape) / sizeof(Shape[0]));
        while (1) { //첫번째 루프
            bricksum++;
            brick = nbrick;
            //랜덤으로 새 벽돌 생성
            nbrick = random(sizeof(Shape) / sizeof(Shape[0]));
            DrawNext();
            nx = BW / 2;        //x좌표는 게임판 가운데
            ny = 3;             //y좌표는 위에서 3번째 (첫번째는 외벽임)
            rot = 0;           //회전 좌표는 첫번째로
            PrintBrick(true);   //벽돌을 그린다.

            //게임 종료 조건 확인
            //새로 생성한 벽돌의 주변이 공백이 아니라면 게임 오버이므로 루프를 탈출한다.
            //확실한 방법은 아니다.
            if (GetAround(nx, ny, brick, rot) != EMPTY) break;
            int nStay = nFrame;

            while (2) { //두번째 루프 
                //벽돌 하나를 처리하는 루프이다.

                //프레임이 지나면 벽돌을 내린다.
                //초당 한칸씩 내려온다.
                if (--nStay == 0) {
                    nStay = nFrame;
                    //MoveDown() 함수는 벽돌이 바닥에 닿으면 true를 리턴한다.
                    if (MoveDown()) break;
                }
                //키 입력 처리를 한다.
                //ProcessKey() 함수도 벽돌이 바닥에 닿으면 true를 리턴한다.
                if (ProcessKey()) break;

                //if문이 true가 되면 2번째 루프를 빠져나간다.

                //시간을 지연시킨다.
                //20fps이다.
                delay(1000 / nFrame);
            }
            if (bricksum % 10 == 0 && nFrame > 5) {
                nFrame--;
            }
        }

        //게임 오버 처리
        clrscr();
        gotoxy(30, 12); puts(" G A M E   O V E R");
        gotoxy(25, 14); puts("다시 시작하려면 Y를 누르세요.");
        if (tolower(_getch()) != 'y') break;
    }
    setcursortype(NORMALCURSOR);
}

//화면 전체를 그린다.
//게임판과 게임 이름, 벽까지 한번에 그림.
void DrawScreen()
{
    for (int x = 0; x < BW + 2; x++) {
        for (int y = 0; y < BH + 2; y++) {
            gotoxy(BX + x * 2, BY + y);
            puts(arTile[ttype][board[x][y]]);
        }
    }
    
    gotoxy(50, 3); puts("Tetris Ver 1.1");
    gotoxy(50, 5); puts("좌우:이동, 위:회전, 아래:내림");
    gotoxy(50, 6); puts("공백: 전부 내림, ESC : 종료");
    gotoxy(50, 7); puts("P:정지, PgUp, PgDn : 블럭 그림 변경");

    DrawNext();
    PrintInfo();

}

//안쪽 게임판만 그린다. 
//쌓이는 벽돌도 얘가 그린다.
void DrawBoard()
{
    for (int x = 1; x < BW + 1; x++) {
        for (int y = 1; y < BH + 1; y++) {
            gotoxy(BX + x * 2, BY + y);
            puts(arTile[ttype][board[x][y]]);
        }
    }
}

//키 입력을 처리한다.
//이동중인 벽돌이 바닥에 닿으면 true를 리턴한다.
bool ProcessKey() 
{
    int trot;

    if (_kbhit()) {
        int ch = _getch();
        if (ch == 0xE0 || ch == 0) {
            ch = _getch();
            switch (ch) {
            case LEFT:
                if (GetAround(nx - 1, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    nx--;
                    PrintBrick(true);
                }
                break;

            case RIGHT:
                if (GetAround(nx + 1, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    nx++;
                    PrintBrick(true);
                }
                break;

            case UP:
                trot = (rot == 3 ? 0 : rot + 1);
                if (GetAround(nx, ny, brick, trot) == EMPTY) {
                    PrintBrick(false);
                    rot = trot;
                    PrintBrick(true);
                }
                break;

            case DOWN:
                if (MoveDown()) {
                    return true;
                }
                break;

            case PGUP:
                ttype++;
                if (ttype == sizeof(arTile) / sizeof(arTile[0])) ttype = 0;
                DrawScreen();
                PrintBrick(true);
                break;

            case PGDN:
                if (ttype == 0) ttype = sizeof(arTile) / sizeof(arTile[0]);
                ttype--;
                DrawScreen();
                PrintBrick(true);
                break;
            }
        } else {
            switch (tolower(ch)) {
            case ' ':
                while (MoveDown() == false) { ; }
                return true;
            case ESC:
                clrscr();
                gotoxy(30, 12); puts(" G A M E   O V E R");
                exit(0);
            case 'p':
                clrscr();
                gotoxy(12, 10);
                puts("일시 중지 \n 다시 시작하려면 아무키나 누르세요");
                _getch();
                clrscr();
                DrawScreen();
                PrintBrick(true);
                break;
            }
        }
    }

    return false;
}

//이동중인 벽돌을 그리거나 삭제한다.
//전역 변수를 참조한다.
void PrintBrick(bool Show) 
{
    for (int i = 0; i < 4; i++) {
        gotoxy(BX + (Shape[brick][rot][i].x + nx) * 2, BY + Shape[brick][rot][i].y + ny);
        puts(arTile[ttype][Show ? BRICK : EMPTY]);
    }
}

//인수로 전달된 벽돌 주변에 뭐가 있는지 확인한다.
//이동중인 벽돌 주변을 확인하는게 아니다.
int GetAround(int x, int y, int b, int r) 
{
    int k = EMPTY;

    for (int i = 0; i < 4; i++) {
        k = max(k, board[x + Shape[b][r][i].x][y + Shape[b][r][i].y]);
    }

    return k;
}

//벽돌을 한칸 아래로 이동시킨다.
//만약 바닥에 닿았으면 TestFull()함수를 호출한 후 true를 리턴한다.
bool MoveDown()
{
    if (GetAround(nx, ny + 1, brick, rot) != EMPTY) {
        TestFull();
        return true;
    }

    PrintBrick(false);
    ny++;
    PrintBrick(true);
    return false;
}

//수평으로 다 채워진 줄을 찾아 삭제한다.
void TestFull() {
    int count = 0;
    static int arScore[] = { 0, 1, 3, 8, 20 };

    for (int i = 0; i < 4; i++) {
        board[nx + Shape[brick][rot][i].x][ny + Shape[brick][rot][i].y] = BRICK;
    }

    int x, y;
    for (y = 1; y < BH + 1; y++) {
        for (x = 1; x < BW + 1; x++) {
            if (board[x][y] != BRICK) break;
        }
        if (x == BW + 1) {
            count++;
            for (int ty = y; ty > 1; ty--) {
                for (x = 1; x < BW + 1; x++) {
                    board[x][ty] = board[x][ty - 1];
                }
            }
            DrawBoard();
            delay(200);
        }
    }

    score += arScore[count];
    PrintInfo();

}

void DrawNext() {
    for (int x = 50; x <= 70; x += 2) {
        for (int y = 12; y <= 18; y++) {
            gotoxy(x, y);
            puts(arTile[ttype][x == 50 || x == 70 || y == 12 || y == 18 ? WALL : EMPTY ]);
        }
    }

    for (int i = 0; i < 4; i++) {
        gotoxy(60 + (Shape[nbrick][0][i].x) * 2, 15 + Shape[nbrick][0][i].y);
        puts(arTile[ttype][BRICK]);
    }
}

void PrintInfo() {
    gotoxy(50, 9); printf("점수 : %d 점 \t", score);
    gotoxy(50, 10); printf("총벽돌 : %d 개", bricksum);
}

■ 강의의 내용에 따라 조금 바꿔보았다.

■ 다음 블럭을 알 수 있는 기능과 일시 정지 및 다시 하기, 점수 기능과 난이도 조절 기능을 넣었다.

C(&C++) 13. 테트리스 주석 추가

라이피 (Lypi) — Sat, 14 Jan 2023 16:46:39 +0900

출처

soen.kr

#include "Turboc.h"

//키 바인딩
#define LEFT 75
#define RIGHT 77
#define UP 72
#define DOWN 80
#define ESC 27

//게임판 좌 상단 좌표와 게임판의 넓이와 높이
#define BX 5
#define BY 1
#define BW 10
#define BH 20

void DrawScreen();
void DrawBoard();
bool ProcessKey();
void PrintBrick(bool show);
int GetAround(int x, int y, int b, int r);
bool MoveDown();
void TestFull();

struct Point {
	int x, y;
};

Point Shape[][4][4] = {
     { {0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2}, {0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2} },
     { {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1} },
     { {0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1}, {0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1} },
     { {0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1}, {0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1} },
     { {0,0,-1,0,1,0,-1,-1}, {0,0,0,-1,0,1,-1,1}, {0,0,-1,0,1,0,1,1}, {0,0,0,-1,0,1,1,-1} },
     { {0,0,1,0,-1,0,1,-1}, {0,0,0,1,0,-1,-1,-1}, {0,0,1,0,-1,0,-1,1}, {0,0,0,-1,0,1,1,1} },
     { {0,0,-1,0,1,0,0,1}, {0,0,0,-1,0,1,1,0}, {0,0,-1,0,1,0,0,-1}, {0,0,-1,0,0,-1,0,1} },
};

//게임판 상태 표시
enum {EMPTY, BRICK, WALL};
//게임판에 표시할 문자. 위의 열거형 값과 동일한 순서로 맞췄다.
const char* arTile[] = { ". ","■", "□" };
//arTile[EMPTY] == ". " 이다.

//외벽을 포함한 게임판의 상태를 기록한다.
//x축 y축의 순서이며 넓이가 x축에 기록되었으므로 
//반시계 방향으로 90도 돌아가게 기록될 것이다.
int board[BW + 2][BH + 2];

//이동중인 벽돌의 배열상의 현재 좌표이다.
//화면상의 좌표로 변환하려면 BX+nx*2, BY+ny식을 쓰면 된다. 
//벽돌 하나가 x축(넓이) 두칸, y축 (높이) 한칸을 차지하기 때문이다. 
//"::"이런 느낌이다.
int nx, ny;

//이동중인 벽돌의 번호와 회전번호를 나타낸다.
int brick, rot;

int main() {

    
    setcursortype(NOCURSOR);
    randomize();
    clrscr();

    //게임 초기화 (보드 배열을 초기화한다.)
    for (int x = 0; x < BW + 2; x++) {
        for (int y = 0; y < BH + 2; y++) {
            board[x][y] = (y == 0 || y == BH + 1 || x == 0 || x == BW + 1) ? WALL : EMPTY;
        }
    }
    //보드를 그린다.
    DrawScreen();
    int nFrame = 20;

    while (1) { //첫번째 루프
        //랜덤으로 새 벽돌 생성
        brick = random(sizeof(Shape) / sizeof(Shape[0]));
        nx = BW / 2;        //x좌표는 게임판 가운데
        ny = 3;             //y좌표는 위에서 3번째 (첫번째는 외벽임)
        rot = 0 ;           //회전 좌표는 첫번째로
        PrintBrick(true);   //벽돌을 그린다.

        //게임 종료 조건 확인
        //새로 생성한 벽돌의 주변이 공백이 아니라면 게임 오버이므로 루프를 탈출한다.
        //확실한 방법은 아니다.
        if (GetAround(nx, ny, brick, rot) != EMPTY) break;
        int nStay = nFrame;
        
        while (2) { //두번째 루프 
            //벽돌 하나를 처리하는 루프이다.

            //프레임이 지나면 벽돌을 내린다.
            //초당 한칸씩 내려온다.
            if (--nStay == 0) {
                nStay = nFrame;
                //MoveDown() 함수는 벽돌이 바닥에 닿으면 true를 리턴한다.
                if (MoveDown()) break;
            }
            //키 입력 처리를 한다.
            //ProcessKey() 함수도 벽돌이 바닥에 닿으면 true를 리턴한다.
            if (ProcessKey()) break;
            
            //if문이 true가 되면 2번째 루프를 빠져나간다.

            //시간을 지연시킨다.
            //20fps이다.
            delay(1000 / nFrame);
        }
    }

    //게임 오버 처리
    clrscr();
    gotoxy(30, 12); puts(" G A M E   O V E R");
    setcursortype(NORMALCURSOR);
}

//화면 전체를 그린다.
//게임판과 게임 이름, 벽까지 한번에 그림.
void DrawScreen()
{
    for (int x = 0; x < BW + 2; x++) {
        for (int y = 0; y < BH + 2; y++) {
            gotoxy(BX + x * 2, BY + y);
            puts(arTile[board[x][y]]);
        }
    }
    
    gotoxy(50, 3); puts("Tetris Ver 1.0");
    gotoxy(50, 5); puts("좌우:이동, 위:회전, 아래:내림");
    gotoxy(50, 6); puts("공백: 전부 내림");
}

//안쪽 게임판만 그린다. 
//쌓이는 벽돌도 얘가 그린다.
void DrawBoard()
{
    for (int x = 1; x < BW + 1; x++) {
        for (int y = 1; y < BH + 1; y++) {
            gotoxy(BX + x * 2, BY + y);
            puts(arTile[board[x][y]]);
        }
    }
}

//키 입력을 처리한다.
//이동중인 벽돌이 바닥에 닿으면 true를 리턴한다.
bool ProcessKey() 
{
    int trot;

    if (_kbhit()) {
        int ch = _getch();
        if (ch == 0xE0 || ch == 0) {
            ch = _getch();
            switch (ch) {
            case LEFT:
                if (GetAround(nx - 1, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    nx--;
                    PrintBrick(true);
                }
                break;

            case RIGHT:
                if (GetAround(nx + 1, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    nx++;
                    PrintBrick(true);
                }
                break;

            case UP:
                trot = (rot == 3 ? 0 : rot + 1);
                if (GetAround(nx, ny, brick, trot) == EMPTY) {
                    PrintBrick(false);
                    rot = trot;
                    PrintBrick(true);
                }
                break;

            case DOWN:
                if (MoveDown()) {
                    return true;
                }
                break;
            }
        } else {
            switch (ch) {
            case ' ':
                while (MoveDown() == false) { ; }
                return true;
            }
        }
    }

    return false;
}

//이동중인 벽돌을 그리거나 삭제한다.
//전역 변수를 참조한다.
void PrintBrick(bool Show) 
{
    for (int i = 0; i < 4; i++) {
        gotoxy(BX + (Shape[brick][rot][i].x + nx) * 2, BY + Shape[brick][rot][i].y + ny);
        puts(arTile[Show ? BRICK : EMPTY]);
    }
}

//인수로 전달된 벽돌 주변에 뭐가 있는지 확인한다.
//이동중인 벽돌 주변을 확인하는게 아니다.
int GetAround(int x, int y, int b, int r) 
{
    int k = EMPTY;

    for (int i = 0; i < 4; i++) {
        k = max(k, board[x + Shape[b][r][i].x][y + Shape[b][r][i].y]);
    }

    return k;
}

//벽돌을 한칸 아래로 이동시킨다.
//만약 바닥에 닿았으면 TestFull()함수를 호출한 후 true를 리턴한다.
bool MoveDown()
{
    if (GetAround(nx, ny + 1, brick, rot) != EMPTY) {
        TestFull();
        return true;
    }

    PrintBrick(false);
    ny++;
    PrintBrick(true);
    return false;
}

//수평으로 다 채워진 줄을 찾아 삭제한다.
void TestFull() {
    for (int i = 0; i < 4; i++) {
        board[nx + Shape[brick][rot][i].x][ny + Shape[brick][rot][i].y] = BRICK;
    }

    int x, y;
    for (y = 1; y < BH + 1; y++) {
        for (x = 1; x < BW + 1; x++) {
            if (board[x][y] != BRICK) break;
        }
        if (x == BW + 1) {
            for (int ty = y; ty > 1; ty--) {
                for (x = 1; x < BW + 1; x++) {
                    board[x][ty] = board[x][ty - 1];
                }
            }
            DrawBoard();
            delay(200);
        }
    }
}

■ 테트리스 코드에 주석을 추가했다.

C(&C++) 실습 12. 테트리스 1

라이피 (Lypi) — Fri, 13 Jan 2023 19:19:50 +0900

출처

soen.kr

#include "Turboc.h"

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

#define BX 5
#define BY 1
#define BW 10
#define BH 20

void DrawScreen();
void DrawBoard();
bool ProcessKey();
void PrintBrick(bool show);
int GetAround(int x, int y, int b, int r);
bool MoveDown();
void TestFull();

struct Point {
	int x, y;
};

Point Shape[][4][4] = {
     { {0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2}, {0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2} },
     { {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1} },
     { {0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1}, {0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1} },
     { {0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1}, {0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1} },
     { {0,0,-1,0,1,0,-1,-1}, {0,0,0,-1,0,1,-1,1}, {0,0,-1,0,1,0,1,1}, {0,0,0,-1,0,1,1,-1} },
     { {0,0,1,0,-1,0,1,-1}, {0,0,0,1,0,-1,-1,-1}, {0,0,1,0,-1,0,-1,1}, {0,0,0,-1,0,1,1,1} },
     { {0,0,-1,0,1,0,0,1}, {0,0,0,-1,0,1,1,0}, {0,0,-1,0,1,0,0,-1}, {0,0,-1,0,0,-1,0,1} },
};

enum {EMPTY, BRICK, WALL};
const char* arTile[] = { ". ","■", "□" };

int board[BW + 2][BH + 2];
int nx, ny;
int brick, rot;

int main() {

    int nFrame, nStay;

    setcursortype(NOCURSOR);
    randomize();
    clrscr();

    for (int x = 0; x < BW + 2; x++) {
        for (int y = 0; y < BH + 2; y++) {
            board[x][y] = (y == 0 || y == BH + 1 || x == 0 || x == BW + 1) ? WALL : EMPTY;
        }
    }

    DrawScreen();
    nFrame = 20;

    while (true) {
        brick = random(sizeof(Shape) / sizeof(Shape[0]));
        nx = BW / 2;
        ny = 3;
        rot = 0;
        PrintBrick(true);

        if (GetAround(nx, ny, brick, rot) != EMPTY) break;
        nStay = nFrame;
        
        while (true) {
            if (--nStay == 0) {
                nStay = nFrame;
                if (MoveDown()) break;
            }
            if (ProcessKey()) break;
            delay(1000 / 20);
        }
    }

    clrscr();
    gotoxy(30, 12); puts(" G A M E   O V E R");
    setcursortype(NORMALCURSOR);
}

void DrawScreen()
{
    for (int x = 0; x < BW + 2; x++) {
        for (int y = 0; y < BH + 2; y++) {
            gotoxy(BX + x * 2, BY + y);
            puts(arTile[board[x][y]]);
        }
    }
    
    gotoxy(50, 3); puts("Tetris Ver 1.0");
    gotoxy(50, 5); puts("좌우:이동, 위:회전, 아래:내림");
    gotoxy(50, 6); puts("공백: 전부 내림");
}

void DrawBoard()
{
    for (int x = 1; x < BW + 1; x++) {
        for (int y = 1; y < BH + 1; y++) {
            gotoxy(BX + x * 2, BY + y);
            puts(arTile[board[x][y]]);
        }
    }
}

bool ProcessKey() 
{
    int trot;

    if (_kbhit()) {
        int ch = _getch();
        if (ch == 0xE0 || ch == 0) {
            ch = _getch();
            switch (ch) {
            case LEFT:
                if (GetAround(nx - 1, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    nx--;
                    PrintBrick(true);
                }
                break;

            case RIGHT:
                if (GetAround(nx + 1, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    nx++;
                    PrintBrick(true);
                }
                break;

            case UP:
                trot = (rot == 3 ? 0 : rot + 1);
                if (GetAround(nx, ny, brick, rot) == EMPTY) {
                    PrintBrick(false);
                    rot = trot;
                    PrintBrick(true);
                }
                break;

            case DOWN:
                if (MoveDown()) {
                    return true;
                }
                break;
            }
        } else {
            switch (ch) {
            case ' ':
                while (MoveDown() == false) { ; }
                return true;
            }
        }
    }

    return false;
}

void PrintBrick(bool Show) 
{
    for (int i = 0; i < 4; i++) {
        gotoxy(BX + (Shape[brick][rot][i].x + nx) * 2, BY + Shape[brick][rot][i].y + ny);
        puts(arTile[Show ? BRICK : EMPTY]);
    }
}

int GetAround(int x, int y, int b, int r) 
{
    int k = EMPTY;

    for (int i = 0; i < 4; i++) {
        k = max(k, board[x + Shape[b][r][i].x][y + Shape[b][r][i].y]);
    }

    return k;
}

bool MoveDown()
{
    if (GetAround(nx, ny + 1, brick, rot) != EMPTY) {
        TestFull();
        return true;
    }

    PrintBrick(false);
    ny++;
    PrintBrick(true);
    return false;
}

void TestFull() {
    for (int i = 0; i < 4; i++) {
        board[nx + Shape[brick][rot][i].x][ny + Shape[brick][rot][i].y] = BRICK;
    }

    int x, y;
    for (y = 1; y < BH + 1; y++) {
        for (x = 1; x < BW + 1; x++) {
            if (board[x][y] != BRICK) break;
        }
        if (x == BW + 1) {
            for (int ty = y; ty > 1; ty--) {
                for (x = 1; x < BW + 1; x++) {
                    board[x][ty] = board[x][ty - 1];
                }
            }
            DrawBoard();
            delay(200);
        }
    }
}

■ 이번 예제는 기능이 함수들로 좀 쪼개져 있어서 나은 편이다.

■ 테트리스는 누구나 아는 게임이라 재밌다.

C(&C++) 실습 11. 슈팅 게임 일부 수정

라이피 (Lypi) — Fri, 13 Jan 2023 17:08:55 +0900

출처

soen.kr

#include "Turboc.h"

//특수키 바인딩
#define ESC			27

//MAX값 지정
#define MAXENEMY	10
#define MAXBALL		20
#define MAXBULLET	5

int fx;			//조종기의 x좌표
int Score;		//점수

//적 구조체
struct Enemy
{
	bool exist;
	int Type;
	int x, y;
	int Delta;
	int nFrame;
	int nStay;
};

//적 총알 구조체
struct Ball
{
	bool exist;
	int x, y;
	int nFrame;
	int nStay;
};

//조종기 총알 구조체
struct Bullet {
	bool exist;
	int x, y;
};

//적기 종류
const char *arEnemy[4] = { "--$--", "ZzTzZ", "oO@Oo", "<-&->"};

//키가 눌러져 있는지 확인하는 함수
bool IsKeyDown(int Key) { return ((GetAsyncKeyState(Key) & 0x8000) != 0); }

Enemy eCount[MAXENEMY];			//적 배열
Ball bCount[MAXBALL];			//적 총알 배열
Bullet bBullet[MAXBULLET];		//아군 총알 배열


int main() {
	int i, j;

	randomize();
	clrscr();
	fx = 40;
	Score = 0;
	setcursortype(NOCURSOR);

	int count = 0;
	while(true) {	//전체 무한 루프 시작



		//좌우 이동 처리
		//count 처리가 없으면 너무 빨리 움직인다.
		//if 처리는 화면 밖으로 나가지 않게 하기 위한 처리.
		//IsKeyDown함수도 키 입력을 확인하는 함수로 만들어져있는데
		//_kbhit() _getch()와 다른 점은 키를 누르고 있는 것도 연속된 입력으로 인식하고,
		//다른 키와 같이 누른 것도 인식한다는 것이다.
		if (count % 5 == 0) {
			if (IsKeyDown(VK_LEFT)) {
				if (fx > 3) { 
					gotoxy(fx - 3, 23);
					puts("　　　　");
					fx--; 
				}
			}
			if (IsKeyDown(VK_RIGHT)) {
				if (fx < 75) {
					gotoxy(fx - 3, 23);
					puts("　　　　");
					fx++; 
				}
			}
		}

		//키 입력 처리
		if (_kbhit()) {
			int ch = _getch();
			// 특수키가 눌린건지 확인
			// 특수키 종류를 확인해 볼 것
			if (ch == 0xE0 || ch == 0) {
				_getch();

			//아니라면 처리
			} else {
				switch (ch) {
				case ' ':
					//발사된 총알이 없다면
					// + 최대 총알 수 만큼 발사 가능
					//조종기의 x좌표를 기준으로 위쪽에 총알을 만든다.
					for (i = 0; i < MAXBULLET && bBullet[i].exist == true; i++) { ; }
					if (i != MAXBULLET) {
						bBullet[i].x = fx;
						bBullet[i].y = 23;
						bBullet[i].exist = true;
					}
					break;

				case ESC:
					//ESC키를 누르면 종료 처리 
					//goto문으로 되어 있어서 바꿨다.
					setcursortype(NORMALCURSOR);
					return 0;
				}
			}
		}

		//적군 생성 
		//1%의 확률인데 1초에 100프레임이므로 초당 하나 정도 만들어질 것이다.
		if (random(100) == 0) {
			//eCount안에서 exist가 false인 것을 찾는다
			for (i = 0; i < MAXENEMY && eCount[i].exist == true; i++) { ; }

			//루프가 끝까지 돌아서 끝난게 아닌지 확인한다.
			if (i != MAXENEMY) {
				//이동 방향을 결정하고 화면 끝으로 위치를 설정한다.
				if (random(2) == 1) {
					eCount[i].x = 5;
					eCount[i].Delta = 1;
				}
				else {
					eCount[i].x = 75;
					eCount[i].Delta = -1;
				}

				
				//무한 루프
				while(true) {
					int bFound = false;
					//세로 좌표를 랜덤으로 정한다.
					eCount[i].y = random(10) + 1;
					for (j = 0; j < MAXENEMY; j++) {
						//그 세로 좌표에 이미 적이 존재하는지 확인한다.
						if (eCount[j].exist == true && eCount[j].y == eCount[i].y) {
							bFound = true;
							break;
						}
					}
					//없다면 루프를 나간다.
					if (bFound == false) {
						break;
					}
				}
				//속도와 모양을 결정하고 존재 여부를 true로 한다.
				eCount[i].nFrame = eCount[i].nStay = random(6) + 1;
				eCount[i].Type = random(sizeof(arEnemy) / sizeof(arEnemy[0]));
				eCount[i].exist = true;
			}
		}

		// 조종기에서 발사한 총알을 이동시킨다.
		for (i = 0; i < MAXBULLET; i++) {
			if (bBullet[i].exist) {
				if (count % 3) break;
				gotoxy(bBullet[i].x, bBullet[i].y); _putch(' ');
				if (bBullet[i].y == 0) {
					bBullet[i].exist = false;
				}
				else {
					bBullet[i].y--;
					gotoxy(bBullet[i].x, bBullet[i].y); _putch('@');
				}
			}
		}

		//적군과 아군 총알이 충돌했는지 판정한다.
		//+ 충돌시 바로 사라지지 않고 잠시 시체가 남게 했다.
		for (i = 0; i < MAXENEMY; i++) {
			if (eCount[i].exist == false || eCount[i].Type == -1) continue;
			for(j=0; j<MAXBULLET; j++) {
				if (bBullet[j].exist == false) continue;
				if (eCount[i].y == bBullet[j].y && abs(eCount[i].x - bBullet[j].x) <= 2) {
					gotoxy(bBullet[j].x, bBullet[j].y); _putch(' ');
					bBullet[j].exist = false;
					eCount[i].Type = -1;
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts(".,:,.");
					Score += 7 - eCount[i].nFrame;
					eCount[i].nFrame = eCount[i].nStay = 50;
					break;
				}
			}
		}

		//적군 총알을 이동시킨다.
		for (i = 0; i < MAXBALL; i++) {
			if (bCount[i].exist == false) continue;
			if (--bCount[i].nStay == 0) {
				bCount[i].nStay = bCount[i].nFrame;
				gotoxy(bCount[i].x, bCount[i].y); _putch(' ');
				if (bCount[i].y >= 23) {
					bCount[i].exist = false;
				}
				else {
					if (random(5)) {
						if (bCount[i].x < fx) {
							bCount[i].x++;
						}
						else {
							bCount[i].x--;
						}
					}

					bCount[i].y++;
					gotoxy(bCount[i].x, bCount[i].y); _putch('*');
				}
			}
		}

		//적군 총알과 아군 조종기가 충돌했는지 판정한다.
		for (i = 0; i < MAXBALL; i++) {
			if (bCount[i].exist == false) continue;
			if (bCount[i].y == 23 && abs(bCount[i].x - fx) <= 2) {
				gotoxy(fx - 3, 21); puts("   .   ");
				gotoxy(fx - 3, 22); puts(".  .  .");
				gotoxy(fx - 3, 23); puts("..:V:..");
				delay(2000);

				//충돌했다면 게임을 종료한다.
				delay(500);
				setcursortype(NORMALCURSOR);
				return 0;
			}
		}

		//적군 이동 
		for (i = 0; i < MAXENEMY; i++) {

			if (eCount[i].exist == false) continue;

			if (--eCount[i].nStay == 0) {
				if (eCount[i].Type == -1) {
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts("　　　　　");
					eCount[i].exist = false;
					continue;
				}

				eCount[i].nStay = eCount[i].nFrame;
				
				//적군이 화면 밖에 있으면
				if (eCount[i].x >= 76 || eCount[i].x <= 4) {
					eCount[i].exist = false;
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts("　　　　");
				}
				else {
					//적군의 원래 이미지를 지우고 새로운 이미지를 그린다.
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts("　　　　");
					eCount[i].x += eCount[i].Delta;
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts(arEnemy[eCount[i].Type]);

					//1/40 확률로 총알을 발사한다.
					if (random(40) == 0) {
						for (j = 0; j < MAXBALL && bCount[j].exist == true; j++) { ; }
						if (j != MAXBALL) {
							bCount[j].x = eCount[i].x + 2;
							bCount[j].y = eCount[i].y + 1;
							bCount[j].nFrame = bCount[j].nStay = eCount[i].nFrame * 6;
							bCount[j].exist = true;
						}
					}
				}
			}
		}

		gotoxy(fx - 3, 23);
		puts("<<A>>");
		gotoxy(0, 24);
		printf("점수 = %d", Score);

		delay(10);

		count++; //루프 카운터 증가
	}
}

■ 사이트에 나온 내용에 따라 조금 바꿔보았다.

■ 클래스로 변경한게 아니고 기능을 조금 바꾼 정도이기 때문에 조금만 바꿔도 전체에 문제가 생길 수 있다.

C(&C++) 실습 10. 슈팅 게임

라이피 (Lypi) — Thu, 12 Jan 2023 17:44:42 +0900

출처

soen.kr

#include "Turboc.h"

//특수키 바인딩
#define ESC			27

//MAX값 지정
#define MAXENEMY	10
#define MAXBALL		20


int fx;			//조종기의 x좌표
int bx, by;		//아군 총알의 x,y좌표
int Score;		//점수

//적 구조체
struct Enemy
{
	bool exist;
	int Type;
	int x, y;
	int Delta;
	int nFrame;
	int nStay;
};

//적 총알 구조체
struct Ball
{
	bool exist;
	int x, y;
	int nFrame;
	int nStay;
};

//적기 종류
const char *arEnemy[4] = { "--$--", "ZzTzZ", "oO@Oo", "<-&->"};

//키가 눌러져 있는지 확인하는 함수
bool IsKeyDown(int Key) { return ((GetAsyncKeyState(Key) & 0x8000) != 0); }

Enemy eCount[MAXENEMY];			//적 배열
Ball bCount[MAXBALL];			//적 총알 배열

int main() {
	int i, j;

	randomize();
	clrscr();
	setcursortype(NOCURSOR);
	fx = 40;
	bx = -1;
	Score = 0;

	int count = 0;
	while(true) {	//전체 무한 루프 시작

		//좌우 이동 처리
		//count 처리가 없으면 너무 빨리 움직인다.
		//if 처리는 화면 밖으로 나가지 않게 하기 위한 처리.
		//IsKeyDown함수도 키 입력을 확인하는 함수로 만들어져있는데
		//_kbhit() _getch()와 다른 점은 키를 누르고 있는 것도 연속된 입력으로 인식하고,
		//다른 키와 같이 누른 것도 인식한다는 것이다.
		if (count % 5 == 0) {
			if (IsKeyDown(VK_LEFT)) {
				if (fx > 3) { 
					gotoxy(fx - 3, 23);
					puts("　　　　");
					fx--; 
				}
			}
			if (IsKeyDown(VK_RIGHT)) {
				if (fx < 75) {
					gotoxy(fx - 3, 23);
					puts("　　　　");
					fx++; 
				}
			}
		}

		//키 입력 처리
		if (_kbhit()) {
			int ch = _getch();
			// 특수키가 눌린건지 확인
			// 특수키 종류를 확인해 볼 것
			if (ch == 0xE0 || ch == 0) {
				_getch();

			//아니라면 처리
			} else {
				switch (ch) {
				case ' ':
					//발사된 총알이 없다면
					//조종기의 x좌표를 기준으로 위쪽에 총알을 만든다.
					if (bx == -1) {
						bx = fx;
						by = 23;
					}
					break;
				case ESC:
					//ESC키를 누르면 종료 처리 
					//goto문으로 되어 있어서 바꿨다.
					setcursortype(NORMALCURSOR);
					return 0;
				}
			}
		}

		//적군 생성 
		//1%의 확률인데 1초에 100프레임이므로 초당 하나 정도 만들어질 것이다.
		if (random(100) == 0) {
			//eCount안에서 exist가 false인 것을 찾는다
			for (i = 0; i < MAXENEMY && eCount[i].exist == true; i++) { ; }

			//루프가 끝까지 돌아서 끝난게 아닌지 확인한다.
			if (i != MAXENEMY) {
				//이동 방향을 결정하고 화면 끝으로 위치를 설정한다.
				if (random(2) == 1) {
					eCount[i].x = 5;
					eCount[i].Delta = 1;
				}
				else {
					eCount[i].x = 75;
					eCount[i].Delta = -1;
				}

				
				//무한 루프
				while(true) {
					int bFound = false;
					//세로 좌표를 랜덤으로 정한다.
					eCount[i].y = random(10) + 1;
					for (j = 0; j < MAXENEMY; j++) {
						//그 세로 좌표에 이미 적이 존재하는지 확인한다.
						if (eCount[j].exist == true && eCount[j].y == eCount[i].y) {
							bFound = true;
							break;
						}
					}
					//없다면 루프를 나간다.
					if (bFound == false) {
						break;
					}
				}
				//속도와 모양을 결정하고 존재 여부를 true로 한다.
				eCount[i].nFrame = eCount[i].nStay = random(6) + 1;
				eCount[i].Type = random(sizeof(arEnemy) / sizeof(arEnemy[0]));
				eCount[i].exist = true;
			}
		}

		// 조종기에서 발사한 총알을 이동시킨다.
		if (bx != -1) {
			gotoxy(bx, by); _putch(' ');
			if (by == 0) {
				bx = -1;
			}
			else {
				by--;
				gotoxy(bx, by); _putch('i');
			}
		}

		//적군과 아군 총알이 충돌했는지 판정한다.
		for (i = 0; i < MAXENEMY; i++) {
			if (eCount[i].exist == false) continue;
			if (eCount[i].y == by && abs(eCount[i].x - bx) <= 2) {
				gotoxy(bx, by); _putch(' ');
				bx = -1;
				eCount[i].exist = false;
				gotoxy(eCount[i].x - 3, eCount[i].y);
				puts("　　　　");
				Score += 7 - eCount[i].nFrame;
				break;
			}
		}

		//적군 총알을 이동시킨다.
		for (i = 0; i < MAXBALL; i++) {
			if (bCount[i].exist == false) continue;
			if (--bCount[i].nStay == 0) {
				bCount[i].nStay = bCount[i].nFrame;
				gotoxy(bCount[i].x, bCount[i].y); _putch(' ');
				if (bCount[i].y >= 23) {
					bCount[i].exist = false;
				}
				else {
					bCount[i].y++;
					gotoxy(bCount[i].x, bCount[i].y); _putch('*');
				}
			}
		}

		//적군 총알과 아군 조종기가 충돌했는지 판정한다.
		for (i = 0; i < MAXBALL; i++) {
			if (bCount[i].exist == false) continue;
			if (bCount[i].y == 23 && abs(bCount[i].x - fx) <= 2) {
				gotoxy(fx - 3, 21); puts("   .   ");
				gotoxy(fx - 3, 22); puts(".  .  .");
				gotoxy(fx - 3, 23); puts("..:V:..");
				delay(2000);

				//충돌했다면 게임을 종료한다.
				setcursortype(NORMALCURSOR);
				return 0;
			}
		}

		//적군 이동 
		for (i = 0; i < MAXENEMY; i++) {

			if (eCount[i].exist == false) continue;

			if (--eCount[i].nStay == 0) {
				eCount[i].nStay = eCount[i].nFrame;
				
				//적군이 화면 밖에 있으면
				if (eCount[i].x >= 76 || eCount[i].x <= 4) {
					eCount[i].exist = false;
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts("　　　　");
				}
				else {
					//적군의 원래 이미지를 지우고 새로운 이미지를 그린다.
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts("　　　　");
					eCount[i].x += eCount[i].Delta;
					gotoxy(eCount[i].x - 2, eCount[i].y);
					puts(arEnemy[eCount[i].Type]);

					//1/40 확률로 총알을 발사한다.
					if (random(40) == 0) {
						for (j = 0; j < MAXBALL && bCount[j].exist == true; j++) { ; }
						if (j != MAXBALL) {
							bCount[j].x = eCount[i].x + 2;
							bCount[j].y = eCount[i].y + 1;
							bCount[j].nFrame = bCount[j].nStay = eCount[i].nFrame * 6;
							bCount[j].exist = true;
						}
					}
				}
			}
		}

		gotoxy(fx - 3, 23);
		puts("<<A>>");
		gotoxy(0, 24);
		printf("점수 = %d", Score);

		delay(10);

		count++; //루프 카운터 증가
	}
}

■ 주석으로 쓸말은 다 쓴 것 같음.

■ C스타일로 만들어진 예제라서 통으로 움직인다.

■ C++스타일의 클래스로 재설계해보고 싶다.

UpWrite

수학. 곱셈 공식과 인수 분해

곱셈공식

인수분해

C&C++ a1 동적할당 연습

C(&C++) 이론 20. 동적 할당

동적 할당

ⅰ. C언어의 경우

ⅱ. C++의 경우

C(&C++) 이론 19. 이중 포인터

이중 포인터

C(&C++) 이론 18. 포인터 응용

포인터 응용

Ⅰ. *ptr++

ⅰ. 예제

ⅱ. 포인터로서의 배열의 이름과 sizeof()

ⅲ. (*ptr)과 (ptr++)을 합치면 *ptr++

Ⅱ. void형 포인터

ⅰ. 임의의 대상체를 가리킬 수 있다.

ⅱ. 대상체의 값을 바로 가져올 수 없다.

ⅲ. 증감 연산자를 사용할 수 없다.

ⅳ. 정리

Ⅲ. NULL 포인터

ⅰ. 정의

ⅱ. 실제 의미

ⅳ. 예외 처리

C(&C++) 실습 13. 테트리스 개작

C(&C++) 13. 테트리스 주석 추가

C(&C++) 실습 12. 테트리스 1

C(&C++) 실습 11. 슈팅 게임 일부 수정

C(&C++) 실습 10. 슈팅 게임

**Ⅰ. *ptr++**

**ⅲ. (ptr)과 (ptr++)을 합치면 ptr++**