SonicShooter 의 public 함수중 하나인 Move 함수의 매개변수를 Vector<2>로 변환하여 2개의 값을 받아온다.

그 후, SonicShooter.h에 MoveSpeed를 정의해준다.

#pragma once

#include "Engine/Rendering.h"

class Sonic; // 전방선언 해준다.

// 손가락모양 총 모양을 구현한다.
class SonicShooter
{
public:
	SonicShooter(void (* const way)(Sonic* const)); // 함수의 주소를 받는 함수 포인터. 주소를 저장하거나 매개변수. way

	bool Update();

	void Move(Vector<2> const direction);

	//void Shoot();
	Sonic* Shoot();

protected:
	Engine::Rendering::Image::Component Skin;

	float const MoveSpeed = 750;

	void(* const Way)(Sonic* const); // 그때그때 다른 함수를 할당해주려고 사용 동적 바인딩 한다.
	// 내가 사용할 함수를 갱신하면서 저장하는 함수 포인터 배열을 계속 참조하여 오버라이딩된 자식클래스를 가리키는 것 처럼 계속해서 다음으로 넘어가면서
	// 런타임 중에 결정이 되는 함수포인터배열 이 동적 바인딩으로 일정하게 참조하게 된다.

};

TempGame에서의 Vector<2> 를 추가하여 작업한다.

direction을 생성한 후, 배열 형태로 X와 Y형을 받아와 작업을 한 뒤,

Shooter->Move 를 통해 위치좌표값을 반영해준다.

void TempGame::Update()
{
	std::string time = "World Time : " + std::to_string(Engine::Time::Get::Elapsed()); // 경과된 시간
	std::string time2 = "Delta Time : " + std::to_string(Engine::Time::Get::Delta()); // 델타 시간

	WorldTime.Text = time.data();
	SomeTime.Text = time2.data();

	WorldTime.Render();
	SomeTime.Render();

	Camera.Sight[0] += 16 * 4 * - Engine::Input::Get::Wheel::V(); // 적당히 상수값을 준다.
	Camera.Sight[1] += 9 * 4 * - Engine::Input::Get::Wheel::V(); // 적당히 상수값을 준다. 휠드레그 해주었을 때 양수 음수 체크하는것.
	Camera.Set(); // 시야 변경에 대한 내용을 적용 시켜준다.

	std::vector<Sonic*>::iterator i = Sonics.begin();
	
	while (i != Sonics.end())
	{
		if ((**i).Update() == true)
		{
		// 다음 원소가 존재할 경우,
			 i = i+1;
		}
		else
		{
			delete(*i);
			i = Sonics.erase(i);
		}
	}

	Shooter->Update();

	Vector<2> direction{};

	if (Engine::Input::Get::Key::Press(VK_LEFT))	direction[0] -= 1;
	if (Engine::Input::Get::Key::Press(VK_RIGHT))	direction[0] += 1;
	if (Engine::Input::Get::Key::Press(VK_UP))		direction[1] += 1;
	if (Engine::Input::Get::Key::Press(VK_DOWN))	direction[1] -= 1;

	if(direction[0] != 0 and direction[1] != 0)
		direction = Normalize(direction);

	Shooter->Move(direction);

	//if (Engine::Input::Get::Key::Down(VK_SPACE)) // Space가 눌렸을때 한번만
	//	Shooter->Shoot(); // 발사체 발사 함수구조 순서 = SonicShooter(Add) -> Add -> Shoot() -> Sonics

	if (Engine::Input::Get::Key::Press(VK_SPACE)) // Space가 눌렸을때 한번만
		Sonics.push_back(Shooter->Shoot());


}

SonicShooter::Move에 매개변수를 변호나해준 다음, Vector<2>형 boundary 를 생성한다음에 초기 위치값을 보정해준다.

그 후, Skin.Location[i] 번째에 받아온 boundary값을 대입하여 기입해준다.

std::clamp를 사용하는데,

이 함수는 받아온 값이 설정해놓은 값보다 크거나 작은 경우, 설정해놓은 값으로 반환해준다.

std::clamp(입력수, 최소수, 최대수)

void SonicShooter::Move(Vector<2> const direction)
{
    Vector<2> const boundary{ (1280 - Skin.Length[0]) * 0.5f, (720 - Skin.Length[1]) * 0.5f };

    for(int i = 0 ; i < 2; i ++)
        Skin.Location[i] = std::clamp(Skin.Location[i] + direction[i] * 
        MoveSpeed * Engine::Time::Get::Delta(), -boundary[i], boundary[i]);
}

#pragma comment(linker, "/Subsystem:Windows")

// 윈도우 운영체제에서 실행될 것 을 알려주는 것
#pragma comment(lib, "D3D11.lib")// 라이브러리 의 다이렉트3 11 의 라이브러리를 사용할 것 이다.
#pragma comment(lib, "FreeImage.lib") // 우리가 넣은 에셋 파일들 사용할 것 임을 암시
#pragma comment(lib, "Engine.lib") // 우리가 넣은 엔진의 라이브러리 를 사용한다.

#include "Engine/Initialize.h"
#include "TempGame.h"

namespace Engine
{
	Game* Initialize()
	{
		return new TempGame;
	}
}

Game* Initialize() 를 선언한 뒤 리턴으로 TmepGame을 반환한다.

#pragma once

namespace Engine
{
    class Game abstract
    {
    public:
        virtual void  Start() abstract;
        virtual void Update() abstract;
        virtual void    End() abstract;
    };
}

Game* Initialize() 는 실행 시 인터페이스로 Game을 사용하게된다.

#pragma once

#include "Engine/Game.h"
#include "Engine/Rendering.h"
#include <vector>

class Sonic;
class SonicShooter;

class TempGame : public Engine::Game
{
public:
	void  Start() override;
	void Update() override;
	void    End() override;

private:
	static void Add(Sonic* const sonic);

private:
	Engine::Rendering::Camera Camera;

	SonicShooter* Shooter;

	static std::vector<Sonic*> Sonics;
};

인터페이스를 상속받는 자식함수로 TempGame을 사용하여, Start와 Update, End를 상속받아 활용하게 된다.

#include "TempGame.h"
#include "Engine/Input.h"

#include "Sonic.h"
#include "SonicShooter.h"


std::vector<Sonic*> TempGame::Sonics;

void TempGame::Start()
{
	Camera.Sight = { 1280, 720 }; // 화면에 소닉이 어떻게 보여질 것 인지
	Shooter = new SonicShooter(Add); // 시작 시 배열에 박아준다.
}

void TempGame::Update()
{
	Camera.Sight[0] += 16 * 4 * - Engine::Input::Get::Wheel::V(); // 적당히 상수값을 준다.
	Camera.Sight[1] += 9 * 4 * - Engine::Input::Get::Wheel::V(); // 적당히 상수값을 준다. 휠드레그 해주었을 때 양수 음수 체크하는것.
	Camera.Set(); // 시야 변경에 대한 내용을 적용 시켜준다.

	for (Sonic* const sonic : Sonics)
		sonic->Update();

	Shooter->Update();

	if (Engine::Input::Get::Key::Press('W')) // W키가 눌렸을 때
		Shooter->Move(+0.0625f); // 속도를 조정해주는것

	if (Engine::Input::Get::Key::Press('S')) // S키가 눌렸을 때
		Shooter->Move(-0.0625f); // 속도를 조정해주는것

	if (Engine::Input::Get::Key::Down(VK_SPACE)) // Space가 눌렸을때 한번만
		Shooter->Shoot(); // 발사체 발사 함수구조 순서 = SonicShooter(Add) -> Add -> Shoot() -> Sonics


}

void TempGame::End()
{
	delete(Shooter);

	for (Sonic* const sonic : Sonics)
		delete(sonic);
}

void TempGame::Add(Sonic* const sonic)
{
	Sonics.push_back(sonic);
}

각 함수는 Engine에 있는 설정을 사용하게된다.

#pragma once

#include "Vector.h"

namespace Engine::Rendering
{
    class Camera final
    {
    public:
        void Set() const;

    public:
        Vector<2> Location = { 0.0f, 0.0f };
        Vector<2> Sight    = { 0.0f, 0.0f };
        float     Angle    = { 0.0f };
    };

    namespace Text
    {
        class Component final
        {
        public:
            void Render();

        public:
            char const * Text = nullptr;

            struct
            {
                char const * Name       = nullptr;
                int          Size       = 0;
                bool         Bold       = false;
                bool         Italic     = false;
                bool         Underlined = false;
                bool         StructOut  = false;
            }
            Font;

            struct
            {
                unsigned char Red   = 0;
                unsigned char Green = 0;
                unsigned char Blue  = 0;
            }
            Color;

        public:
            Vector<2> Location = { 0.0f, 0.0f };
            Vector<2> Length   = { 0.0f, 0.0f };
            float     Angle    = { 0.0f };
        };
    }

    namespace Image
    {
        class Component final
        {
        public:
            void Render();

        public:
            char const * Name = nullptr;

        public:
            Vector<2> Location = { 0.0f, 0.0f };
            Vector<2> Length   = { 0.0f, 0.0f };
            float     Angle    = { 0.0f };
        };
    }

    namespace Animation
    {
        class Component final
        {
        public:
            void Render();

        public:
            char const * Name       = nullptr;
            float        Playback   = 0.0f; //애니메이션 컴포넌트의 재생 위치 => 특정 프레임 표시
            float        Duration   = 0.0f; //일정한 시간 간격 나타냄 => 애니메이션이 얼마나 실행되는 지
            bool         Repeatable = false; //반복 가능한지 여부
            bool         Flipped    = false; //뒤집혀 있는지 여부

        public:
            Vector<2> Location = { 0.0f, 0.0f };
            Vector<2> Length   = { 0.0f, 0.0f };
            float     Angle    = { 0.0f };
        };
    }
}

Rendering.h 에 대한 내용속 의 Camera를 사용하게 된다.

즉, 인터페이스 에 대한 상속을 활용하여, 각 함수마다 공통적으로 사용하게 될 변수들은 Engine에 작성하여 호출 사용하게 되고. 각 실행작업은 lib을 활용하여 참조역활을 수행할 수 있게된다.

실행예시

스페이스바 를 누르면 발사체가 손에서 발사된다.

윈도우 API를 활용하여 2D게임의 코딩을 기초적으로 진행한다.

발사하는 손가락과 발사되는 투사체를 구현하는 코드를 진행.

발사되는 투사체

#include "Sonic.h"
#include "Engine/Time.h"

Sonic::Sonic(Vector<2> const location)
{
	Skin.Name = "Animation/Sonic_Run";
	Skin.Length = { 144, 144 };
	Skin.Location = location;
	Skin.Duration = 0.125f; // 0.125마다 반복되게
	Skin.Repeatable = true;
}

bool Sonic::Update()
{
	// 업데이트 할 떄마다 이미지를 업데이트 해줌
	Skin.Render();
	// 케릭터가 화면 범위를 벗어났을 때 몸을 없애주는것
	//if ((640 + Skin.Length[0] * 0.5) <= (Skin.Location[0] += 0.125f)) // 화면을 중간이상 벗어났을 때, flase 아니면 true를 반환한다.
	//	return false;
	//else
	//	return true;

	return (Skin.Location[0] += 1280 * Engine::Time::Get::Delta() <= (640 + Skin.Length[0] * 0.5f));
	// Delta = 시간에 대한 함수. 이전에 지나간 시간을 찍는다.
	// 화면의 크기 * 경과한 시간. 이, S
}

#pragma once

#include "Engine/Rendering.h"

class Sonic
{
public:
	Sonic(Vector<2> const location); // 수학적 의미의 벡터. 알던 벡터의 위치값이 아니라 2개의 xy좌표만을 가지는 벡터위치값을 이야기한다.

	bool Update(); // 업데이트 되면서 동작한다.
private:
	Engine::Rendering::Animation::Component Skin; // 케릭터의 외관을 받아오는 컴포넌트를 받아온것. 구성 요소에서 사용이 가능한 독립적인 부분을 나타냄
};

발사하는 주체

#pragma once

#include "Engine/Rendering.h"

class Sonic; // 전방선언 해준다.

// 손가락모양 총 모양을 구현한다.
class SonicShooter
{
public:
	SonicShooter(void (* const way)(Sonic* const)); // 함수의 주소를 받는 함수 포인터. 주소를 저장하거나 매개변수. way

	bool Update();

	void Move(float const distance);

	void Shoot();

private:
	Engine::Rendering::Image::Component Skin;

	void(* const Way)(Sonic* const); // 그때그때 다른 함수를 할당해주려고 사용 동적 바인딩 한다.
	// 내가 사용할 함수를 갱신하면서 저장하는 함수 포인터 배열을 계속 참조하여 오버라이딩된 자식클래스를 가리키는 것 처럼 계속해서 다음으로 넘어가면서
	// 런타임 중에 결정이 되는 함수포인터배열 이 동적 바인딩으로 일정하게 참조하게 된다.

};

#include "Sonic.h"
#include "SonicShooter.h"

SonicShooter::SonicShooter(void(* const way)(Sonic* const))
    :Way{ way }
{
    Skin.Name = "Image/Direction";
    Skin.Length = { 128, 128 };
    Skin.Location = { -575, 250 };
}

bool SonicShooter::Update()
{
    Skin.Render();
    return true;
}

void SonicShooter::Move(float const distance)
{
    Skin.Location[1] += distance;
}

void SonicShooter::Shoot()
{
    Way(new Sonic(Skin.Location));
}

이 경우, 발사된 이후의 투사체를 관리하는 배열이 필요하다.

발사된 이후의 투사체를 전부 관리해야. 충돌판정을 확인할 수 있기 때문.

발사된 이후의 투사체를 관리하는 코드

#pragma once

#include "Engine/Game.h"
#include "Engine/Rendering.h"
#include <vector>

class Sonic;
class SonicShooter;

class TempGame : public Engine::Game
{
public:
	void  Start() override;
	void Update() override;
	void    End() override;

private:
	static void Add(Sonic* const sonic);

private:
	Engine::Rendering::Camera Camera;

	SonicShooter* Shooter;

	static std::vector<Sonic*> Sonics;
};

#include "TempGame.h"

void TempGame::Start()
{
}

void TempGame::Update()
{
}

void TempGame::End()
{
}

void TempGame::Add(Sonic* const sonic)
{
}

Delta Time 

게임개발에서 사용되는 중요한 개념이다.

게임의 원활한 실행과 시간에 따른 일관성을 유지하는 데 사용되며, 게임의 프레임 속도와 상호작용을 조정하는 데 도움을 준다.

• Delta TIme 의 사용 목적
  1. 게임엔진이 한 프레임에서 다음 프레임으로 전환할 때 소요되는 시간 간격을 나타낸다.
  2. 게임의 물리엔진, 애니메이션, 이동, 상호작용 등과 관련된 작업에 적용된다.
  3. 게임의 프레임 속도를 조정함으로써 각각의 플랫폼과 하드웨어에서 일관된 속도로 실행되도록 한다.
• 사용 예 :
  1. 에니메이션, 이동, 물리엔진
     [ 1초간 동작하는 에니메이션의 경우, 프레임당 시간으로 계산하여. 한 프레임당 움직이는 속도를 조정한다. ]
     1초간 1M를 가는 동작을 할 시. 30프레임 기준으로 작성하게 된다고 가정해 보자. 그렇게되면
     
     60프레임의 하드웨어 환경에서 동작 시 속도가 1초당 2M를 이동하게 되어 버린다.
     30프레임동안 1M를 이동하게 만들어지는 코드가 하드웨어 환경이 60프레임으로 바뀌게 되면,
     60프레임 시 30프레임의 두배의 동작을 수행하기 때문이다.
     
     만약 30프레임 기준, 한 프레임당 0.03333... 초가 지나게 됨 으로 등속운동 시간을 계산하여
     1초당 1M를 이동하는 것을
     한 프레임당 1*Delta_Time() 을 해주면 된다.
     30프레임 기준 0.0333.. 60프레임 기준 0.01333...
     
     Object_Speed = 1 Meter/Seconde
     Object_Speed = 1*Delta_Time() Meter/Frame
     
     

요약

DeltaTime은 소프트웨어 동작 시. 하드웨어의 일괄적이지 않은 속도차이를 보정하기 위해서 사용되며,

전 프레임이 사라진 후 -> 현재 프레임이 나타난 즉시 사이의 시간을 구해주는 함수이다.

Delta Time 

게임개발에서 사용되는 중요한 개념이다.

게임의 원활한 실행과 시간에 따른 일관성을 유지하는 데 사용되며, 게임의 프레임 속도와 상호작용을 조정하는 데 도움을 준다.

• Delta TIme 의 사용 목적
  1. 게임엔진이 한 프레임에서 다음 프레임으로 전환할 때 소요되는 시간 간격을 나타낸다.
  2. 게임의 물리엔진, 애니메이션, 이동, 상호작용 등과 관련된 작업에 적용된다.
  3. 게임의 프레임 속도를 조정함으로써 각각의 플랫폼과 하드웨어에서 일관된 속도로 실행되도록 한다.
• 사용 예 :
  1. 에니메이션, 이동, 물리엔진
     [ 1초간 동작하는 에니메이션의 경우, 프레임당 시간으로 계산하여. 한 프레임당 움직이는 속도를 조정한다. ]
     1초간 1M를 가는 동작을 할 시. 30프레임 기준으로 작성하게 된다고 가정해 보자. 그렇게되면
     
     60프레임의 하드웨어 환경에서 동작 시 속도가 1초당 2M를 이동하게 되어 버린다.
     30프레임동안 1M를 이동하게 만들어지는 코드가 하드웨어 환경이 60프레임으로 바뀌게 되면,
     60프레임 시 30프레임의 두배의 동작을 수행하기 때문이다.
     
     만약 30프레임 기준, 한 프레임당 0.03333... 초가 지나게 됨 으로 등속운동 시간을 계산하여.
     
     1초당 1M를 이동하는 것을
     한 프레임당 1*Delta_Time() 을 해주면 된다. 30프레임 기준 0.0333.. 60프레임 기준 0.01333...
     
     Object_Speed = 1 Meter/Seconde
     Object_Speed = 1*Delta_Time() Meter/Frame
     
     

요약

DeltaTime은 소프트웨어 동작 시. 하드웨어의 일괄적이지 않은 속도차이를 보정하기 위해서 사용되며,

전 프레임이 사라진 후 -> 현재 프레임이 나타난 즉시 사이의 시간을 구해주는 함수이다.

이미지 저장 -> 포토샵 새로만들기 -> 폭발 이미지 확인.

폭발 이미지의 사이즈 대로 이미지 자르기 -> 배경내용 투명으로 같은 사이즈로 포토샵 파일 새로만들기

-> 이미지를 길게 잘라서 붙여넣기

가져온 이미지는 폭발 임으로 중앙이 아닌 바닥을 기준으로 맞춰준다.

그 후 Y좌표를 띄워주면서 부드러운 모션을 확인한다.

새 안내선 레이아웃을 만든다 -> 여백은 주지 않고 만든다 -> 열은 각 객체의 개수대로. -> 간격은 0으로

12 -> 2 로 분할한다.

픽셀기준 X축으로 검사하여 각 줄을 자른다.

픽셀 기준 Y축으로 검사한다. Y축기준으로 픽셀의 단위를 자른다.

X축과 Y축의 절삭값을 이미지 1개의 사이즈로 한다.

NULL픽셀을 자를 때 여유픽셀을 몃개 건너뛰는지?

ex(폭발 이미지를 자를 때 떨어져 있는 픽셀을 몃개까지 자르는지) 에대한 값을 산정한다.

위 이미지는 X축 간 여분을 2로 주고, 각 레이어의 X사이즈를 32로, Y를 52로 주었다.

절삭한 이미지를 각 파일, PNG로 저장한다.

좌표도가 없는. 중심축 기준으로 정렬된 이미지

XY좌표간. 이미지 출력 시 부드러운 이미지출력이 가능한 정렬된 이미지