WIN32 Collider, EventManager, Scene변경
카테고리: WINAPI
15일차
- Default
- Client.h
- framework.h
- Resouce.h
- targetver.h
- Engine
1. Header
**1. define.h**
2. struct.h
**3. func.h
4. func.cpp**
2. Core
1. CCore.cpp
**** 2. CCore.h
3. Manager
1. KeyMgr
1. CkeyMgr.cpp
2. CkeyMgr.h
2. TimeMgr
1. CTimeMgr.cpp
2. CTimeMgr.h
3. SceneMgr
1. CSceneMgr.cpp
2. CSceneMgr.h
4. PathMgr
1. CPathMgr.cpp
2. CPathMgr.h
5. ResMgr
1. CResMgr.cpp
2. CResMgr.h
**6. CollisionMgr
1. CCollisionMgr.cpp**
2. CCollisionMgr.h
**7. EventMgr
1. CEventMgr.cpp**
2. CEventMgr.h
4. Object
**1. Monser
1. CMonster.cpp
2. CMonster.h
2. Missle
1. Missile.cpp
2. Missile.h
3. Player
1. CPlayer.cpp
2. Cplayer.h
1. CObject.cpp**
**2. CObject.h**
5. Scene
**1. Scene_Start
1. CScene_Start.cpp
2. CScene_Start.h**
**2. Scene_Tool
1. CScene_Tool.cpp
2. CScene_Tool.h**
**3. CScene.cpp
4. CScene.h**
6. Resource
1. Sound
2. Texture
1. CTexture.cpp
2. CTexture.h
3. CRes.cpp
4. CRes.h
7. Component
1. CCollider.cpp
2. CCollider.h
8. Module
1. SelectGDI.cpp
2. SelectGDI.h
- 리소스 파일
- main.cpp
- pch.h.
- 오늘 한 것은 EventMgr를 좀 마무리하고, 씬 체인지, 오브젝트(복사, 생성)등을 했다. 수정된 부분이 많기 때문에 세심하게 봐주시면 좋을 것 같다.
- define.h
#define CLONE(type) type* Clone() {return new type(*this);}
- 오브젝트를 CLONE하기 위한 매크로를 추가했다
- func.h
#pragma once
class CObject;
void CreateObject(CObject* _pObj, GROUP_TYPE _eGroup);
void DeleteObject(CObject* _pObj);
//씬을 바꿀 때, 기존 씬에 있던 포인터나 그런 거.
//한 프레임은 작업을 마무리하고, Scene을 업데이트 해야만 함.
//여기서 해줄 건 이벤트 등록. 다음 프레임부터 다음 씬으로 가도록 이벤트를 넣어준다.
void ChangeScene(SCENE_TYPE _eNext);
template<typename T>
void Safe_Delete_Vec(vector<T>& _vec);
//템플릿은 헤더에 구현해야만 함.
template<typename T>
inline void Safe_Delete_Vec(vector<T>& _vec)
{
for (auto& Obj : _vec) {
if (Obj != nullptr) {
delete Obj;
Obj = nullptr;
}
}
_vec.clear();
}
- func.cpp
#include "pch.h"
#include "func.h"
#include "CObject.h"
#include "CEventMgr.h"
void CreateObject(CObject* _pObj, GROUP_TYPE _eGroup)
{
tEvent createEvn = {};
createEvn.eEven = EVENT_TYPE::CREATE_OBJECT;
createEvn.lParam = (DWORD_PTR)_pObj;
createEvn.wParam = (DWORD_PTR)_eGroup;
CEventMgr::GetInstance()->AddEvent(createEvn);
}
void DeleteObject(CObject* _pObj)
{
tEvent deleteEvn = {};
deleteEvn.eEven = EVENT_TYPE::DELETE_OBJECT;
deleteEvn.lParam = (DWORD_PTR)_pObj;
CEventMgr::GetInstance()->AddEvent(deleteEvn);
}
void ChangeScene(SCENE_TYPE _eNext)
{
tEvent changeEvn = {};
changeEvn.eEven = EVENT_TYPE::SCENE_CHANGE;
changeEvn.lParam = (DWORD_PTR)_eNext;
CEventMgr::GetInstance()->AddEvent(changeEvn);
}
- CCollisionMgr.cpp
void CCollisionMgr::CollisionGroupUpdate(GROUP_TYPE _eLeft, GROUP_TYPE _eRight)
{
CScene* pCurScene = CSceneMgr::GetInstance()->GetCurScene();
//우리가 하려는 의도랑 조금 어긋나는 부분이 있음.
//반환타입이 참조이니, 우리가 레퍼런스를 가져온 것.
//vecLeft는 주소값의 복사본(지역변수)임. 따라서 &로 받아야함.
const vector<CObject*>& vecLeft = pCurScene->GetGroupObject(_eLeft);
const vector<CObject*>& vecRight = pCurScene->GetGroupObject(_eRight);
unordered_map<ULONGLONG, bool>::iterator colliderMapIter;
for (auto leftIDX = 0; leftIDX < vecLeft.size(); leftIDX++) {
//충돌체를 보유하지 않는 경우
if (nullptr == vecLeft[leftIDX]->GetCollider()) continue;
for (auto rightIDX = 0; rightIDX < vecRight.size(); rightIDX++) {
//충돌체를 보유하지 않는 경우. or 자기 자신과의 충돌인 경우.
if (nullptr == vecRight[rightIDX]->GetCollider() || vecLeft[leftIDX] == vecRight[rightIDX]) continue;
CCollider* pLeftCollider = vecLeft[leftIDX]->GetCollider();
CCollider* pRightCollider = vecRight[rightIDX]->GetCollider();
//충돌체들 간의 조합 ID
COOLIDER_ID ID;
ID.Left_id = pLeftCollider->GetID();
ID.Right_id = pRightCollider->GetID();
colliderMapIter = m_mapColInfo.find(ID.ID);
//충돌 정보가 미 등록 상태인 경우 등록(충돌하지 않았다. 로)
if (colliderMapIter == m_mapColInfo.end()) {
//두 조합의 검사를 최초로 했을 경우.
m_mapColInfo.insert(make_pair(ID.ID, false));
colliderMapIter = m_mapColInfo.find(ID.ID);
}
//현재 충돌한 경우.
if (IsCollision(pLeftCollider, pRightCollider)) {
if (colliderMapIter->second == false) {
//이번 프레임에 막 충돌한 경우.
//하필 이제 삭제될 때, 충돌할 때. 그 충돌은 없었던 것이 됨.
if (!vecLeft[leftIDX]->IsDead() && !vecRight[rightIDX]->IsDead()) {
pLeftCollider->OnCollisionEnter(vecRight[rightIDX]->GetCollider());
pRightCollider->OnCollisionEnter(vecLeft[leftIDX]->GetCollider());
colliderMapIter->second = true;
}
}
else if (colliderMapIter->second == true) {
//이전 프레임에도 충돌하고 있었을 경우.
//이제 죽는 애는 충돌에서 벗어났다고 명시적으로 해줌.
if (vecLeft[leftIDX]->IsDead() || vecRight[rightIDX]->IsDead()) {
pLeftCollider->OnCollisionExit(vecRight[rightIDX]->GetCollider());
pRightCollider->OnCollisionExit(vecLeft[leftIDX]->GetCollider());
colliderMapIter->second = false;
}
else {
pLeftCollider->OnCollision(vecRight[rightIDX]->GetCollider());
pRightCollider->OnCollision(vecLeft[leftIDX]->GetCollider());
}
}
}
else {
//충돌하지 않은 경우.
if (colliderMapIter->second == true) {
//막 지금 충돌에서 벗어난 경우.
pLeftCollider->OnCollisionExit(vecRight[rightIDX]->GetCollider());
pRightCollider->OnCollisionExit(vecLeft[leftIDX]->GetCollider());
colliderMapIter->second = false;
}
}
}
}
}
- 충돌처리에 로직을 추가했다. 충돌했을 때, 그 오브젝트가 삭제되기 준비중(Alive)일때의 경우를 넣어놓았다.
2.CEventMgr.cpp
#include "pch.h"
#include "CEventMgr.h"
#include "CObject.h"
#include "CSceneMgr.h"
#include "CScene.h"
CEventMgr::CEventMgr()
: m_vecEvent{}
{
}
CEventMgr::~CEventMgr() {
}
void CEventMgr::update()
{
//==================================================
//이전 프레임에서 등록해준 Dead Object들을 삭제한다.
//==================================================
for (auto deadObjectPtr : m_vecDeadScheduled) {
delete deadObjectPtr;
}
m_vecDeadScheduled.clear();
// ===============
// Event 처리.
// ===============
for (const auto& event_node : m_vecEvent) {
Excute(event_node);
}
m_vecEvent.clear();
}
void CEventMgr::Excute(const tEvent& _eve)
{
switch (_eve.eEven) {
case EVENT_TYPE::CREATE_OBJECT:
{
// lParam : Object Address
// wParam : Group Type
CObject* pNewObj = (CObject*)_eve.lParam;
GROUP_TYPE eType = (GROUP_TYPE)_eve.wParam;
CSceneMgr::GetInstance()->GetCurScene()->AddObject(pNewObj, eType);
}
break;
case EVENT_TYPE::DELETE_OBJECT:
{
// lParam : Object Address
// wParam : NULL
// Object를 Dead 상태로 변경하고 -> 삭제 예정 오브젝트들을 모아둔다.
CObject* pDeleteObj = (CObject*)_eve.lParam;
pDeleteObj->SetDead();
m_vecDeadScheduled.push_back(pDeleteObj);
}
break;
case EVENT_TYPE::SCENE_CHANGE:
// lParam : Next Scene Type
// wParam : NULL
CSceneMgr::GetInstance()->ChangeScene((SCENE_TYPE)_eve.lParam);
break;
}
}
- CSceneMgr.h
#pragma once
class CScene;
class CSceneMgr
{
SINGLE(CSceneMgr)
private:
CScene* m_arrScene[(UINT)SCENE_TYPE::END]; //모든 씬에 대한 정보를 다 가짐
CScene* m_pCurScene; //현재 씬
public:
void init();
void update();
void render(HDC _dc);
public:
CScene* GetCurScene() { return m_pCurScene; }
private:
void ChangeScene(SCENE_TYPE _eNext);
friend class CEventMgr;
};
- ChangeScene으로 CEventmgr만 사용할 수 있게 해놓는다.
- CSceneMgr.cpp
//씬을 바꿀 때, 기존 씬에 있던 포인터나 그런 거.
//한 프레임은 작업을 마무리하고, Scene을 업데이트 해야만 함.
//여기서 해줄 건 이벤트 등록. 다음 프레임부터 다음 씬으로 가도록 이벤트를 넣어준다.
void CSceneMgr::ChangeScene(SCENE_TYPE _eNext)
{
m_pCurScene->Exit();
m_pCurScene = m_arrScene[(UINT)_eNext];
m_pCurScene->Enter();
}
- 씬의 종료함수 Exit()를 추가하고, 현재 씬을 바꿔준 후에, 바꾼 현재씬의 Enter함수를 추가한다.
- CObject.h
#pragma once
//오브젝트라는 건, 가장 부모격인 녀석. 오브젝트마다 성향이 있음
//어떤 건 UI, 어떤 건 캐릭터...
//오브젝트를 일괄적으로 관리할 녀석이 필요함. -> Scene
//이 오브젝트는 부모 클래스. -> 상속받은 오브젝트도 Scene의 업데이트 시점에
//부모쪽에 구현되어있는 update뿐만 아니라, 각 오브젝트(자식)들 마다의 update를 하고 싶음
//충돌할 오브젝트, 충돌하지 않을 오브젝트(UI, 배경등등...) <- 이런 식으로 계속 트리처럼 나누는 건 예외가 있을수도 있음.
// 따라서 부품기반의 구조가 필요함(컴포넌트 구조)
//구조의
class CCollider;
class CObject
{
private:
wstring m_ObjName;
Vec2 m_vPos;
Vec2 m_vScale;
CCollider* m_pCollider;
bool m_bAlive; //자기 자신이 활성화 or 비활성화. (삭제 전용)
bool m_bEnable; //일시적인 활성화 or 비활성화.
public:
void SetPos(Vec2 _vPos) { m_vPos = _vPos; }
void SetScale(Vec2 _vScale) { m_vScale = _vScale; }
Vec2 GetPos() { return m_vPos; }
Vec2 GetScale() { return m_vScale; }
void SetName(const wstring& _strName) { m_ObjName = _strName; }
const wstring& GetName() { return m_ObjName; }
CCollider* GetCollider() { return m_pCollider; }
void CreateCollider();
virtual void OnCollision(CCollider* _pOther) {};
virtual void OnCollisionEnter(CCollider* _pOther) {};
virtual void OnCollisionExit(CCollider* _pOther) {};
bool IsDead() {
return !m_bAlive;
}
private:
void SetDead() { m_bAlive = false; }
public:
virtual void update() = 0;
//부모에서 함수의 구현이 끝나게, 자식에서 오버라이딩 못하게 막기.
virtual void finalupdate() final;
virtual void render(HDC _dc);
void component_render(HDC _dc);
virtual CObject* Clone() = 0;
public:
CObject();
CObject(const CObject& _origin);
virtual ~CObject();
//복사 생성자의 문제. -> 단순히 복사만 하면 m_pCollider의 주소가 그대로 복사됨.
//따라서 m_pCollider을 따로 만들어줘야 함.
//m_bAlive도 가져올 필요는 없음.
friend class CEventMgr;
};
- 복사 생성자, Clone함수를 만들었다. Clone함수는 순수 가상함수라서 받는 클래스에서 따로 구현해야만 한다.
6.CObject.cpp
CObject::CObject(const CObject& _origin)
: m_ObjName(_origin.m_ObjName)
, m_vPos(_origin.m_vPos)
, m_vScale(_origin.m_vScale)
, m_pCollider(nullptr)
, m_bAlive(true)
, m_bEnable(true)
{
m_pCollider = new CCollider(*_origin.m_pCollider);
m_pCollider->m_pOwner = this;
}
- 복사 생성자를 구현했다. 각 오브젝트마다 콜라이더는 따로 존재해야 하므로 새로 생성해준다.
- CPlayer.h, CMonster.h, CMissile.h
#pragma once
#include "CObject.h"
class CTexture;
class CPlayer :
public CObject
{
private:
CTexture* m_pTex;
public:
virtual void update();
virtual void render(HDC _dc);
private:
void CreateMissile();
**//플레이어 오브젝트는 복사되면
CLONE(CPlayer)**
public:
CPlayer();
~CPlayer();
};
- 볼드 처리 해놓은대로 자신을 복사해서 줄 수 있는 CLONE매크로를 넣어주었다.
- CMissile.cpp
#include "pch.h"
#include "CMissile.h"
#include "CTimeMgr.h"
#include "CCollider.h"
CMissile::CMissile()
:m_vDir(Vec2(1.f,0.f))
,m_fTheta(PI / 4.f)
{
m_vDir.Normalize();
CreateCollider();
GetCollider()->SetScale(Vec2(15.f, 15.f));
}
CMissile::~CMissile()
{
}
void CMissile::update()
{
Vec2 vPos = GetPos();
//일시정지, 중단점 걸었을 때 정상적으로 가기.
vPos.x += 600.f * fDT * m_vDir.x;
vPos.y += 600.f * fDT * m_vDir.y;
SetPos(vPos);
}
void CMissile::render(HDC _dc)
{
Vec2 vPos = GetPos();
Vec2 vScale = GetScale();
//부모 클래스 만들기.
//CObject::render(_dc);
Ellipse(_dc, (int)(vPos.x - vScale.x / 2.f), (int)(vPos.y - vScale.y / 2.f),
(int)(vPos.x + vScale.x / 2.f), (int)(vPos.y + vScale.y / 2.f));
component_render(_dc);
}
void CMissile::OnCollisionEnter(CCollider* _pOther)
{
CObject* pOtherObj = _pOther->GetObj();
if (pOtherObj->GetName() == L"Monster") {
DeleteObject(this);
}
}
- 몬스터와 충돌하였을 경우의 처리를 했다.
- CMonster.cpp
#include "pch.h"
#include "CMonster.h"
#include "CTimeMgr.h"
#include "CCollider.h"
CMonster::CMonster()
: m_fSpeed(100.f)
, m_vCenterPos(Vec2(0.f, 0.f))
, m_fMaxMoveDistance(50.f)
, m_iDir(1)
, m_iHP(5)
{
CreateCollider();
GetCollider()->SetScale(Vec2(45.f, 45.f));
}
CMonster::~CMonster()
{
}
void CMonster::update()
{
return;
Vec2 vCurPos = GetPos();
//진행 방향으로 시간당 m_fSpeed만큼 이동.
vCurPos.x += fDT * m_fSpeed * m_iDir;
//배회 거리 기준점을 넘어섰는지 확인.
//부들부들 거릴때가 있음... 한번에 크게(105) 넘어섰는데,
//다음 프레임에 조금밖에(-1) 못 되돌아 갔을때.
float fDistance = abs(m_vCenterPos.x - vCurPos.x) - m_fMaxMoveDistance;
if (0.f < fDistance) {
m_iDir *= -1;
vCurPos.x += fDT * m_fSpeed * m_iDir;
}
SetPos(vCurPos);
}
void CMonster::OnCollision(CCollider* _pOther)
{
}
void CMonster::OnCollisionEnter(CCollider* _pOther)
{
CObject* pOtherObj = _pOther->GetObj();
if (pOtherObj->GetName() == L"Missile_Player") {
m_iHP -= 1;
if(m_iHP <= 0)
DeleteObject(this);
}
}
void CMonster::OnCollisionExit(CCollider* _pOther)
{
}
- 체력을 주어서, 제력이 다 떨어지면 사라지도록 만들었다.
- CScene.h
#pragma once
//전방선언하는 이유는 컴파일 속도에 영향을 주지 않기 위해.
class CObject;
class CScene
{
private:
vector<CObject*> m_arrObj[(UINT)GROUP_TYPE::END]; //벡터 안에 모든 오브젝트 집어 넣겠다. 이런 특성(요소)를 가진만큼 나눠주기.
//달리말하면 그룹 갯수만큼 나눠주기.
wstring m_strName; //Scene 이름
public:
void SetName(const wstring& _strName) { m_strName = _strName; }
const wstring& GetName() { return m_strName; }
virtual void update();
virtual void finalupdate();
virtual void render(HDC _dc);
virtual void Enter() = 0; //해당 Scene에 진입 시 호출.
virtual void Exit() = 0; //해당 Scene에 탈출 시 호출.
public:
//클래스는 헤더에 구현하면 인라인 처리가 됨.
//따라서 함수 호출 비용이 사라짐.
void AddObject(CObject* _pObj, GROUP_TYPE _eType)
{
m_arrObj[(UINT)_eType].push_back(_pObj);
}
const vector<CObject*>& GetGroupObject(GROUP_TYPE _eType)
{
return m_arrObj[(UINT)_eType];
}
void DeleteGroup(GROUP_TYPE _eGroup);
void DeleteAll();
public:
CScene();
//소멸자의 가상함수 해줘야함. 씬 매니저가 모든 Scene을 부모 포인터로 관리함.
// CSceneMgr에서 씬을 소멸시킬때, 소멸자는 부모인 CScene만 호출됨.
virtual ~CScene();
};
- 씬을 변경할 때, 그 그룹이나 모든 오브젝트를 삭제하는 함수를 만들었다.
- CScene.cpp
#include "pch.h"
#include "CScene.h"
#include "CObject.h"
#include "func.h"
CScene::CScene()
{
}
CScene::~CScene()
{
for (UINT typeIDX = 0; typeIDX < (UINT)GROUP_TYPE::END; typeIDX++) {
for (size_t objIDX = 0; objIDX < m_arrObj[typeIDX].size(); objIDX++) {
//m_arrObj[그룹][물체] 삭제.
delete m_arrObj[typeIDX][objIDX];
}
//씬이 사라지면, 그 씬의 벡터들도 다 사라짐.
//STL의 RAII가 알아서 삭제하기 때문.
}
}
void CScene::update()
{
for (UINT typeIDX = 0; typeIDX < (UINT)GROUP_TYPE::END; typeIDX++) {
for (size_t objIDX = 0; objIDX < m_arrObj[typeIDX].size(); objIDX++) {
if (!m_arrObj[typeIDX][objIDX]->IsDead()) {
m_arrObj[typeIDX][objIDX]->update();
}
}
}
}
//움직이고 했던 걸, 마지막으로 업데이트 함.
//충돌체가 플레이어 따라가게 함, 충돌 처리.
void CScene::finalupdate()
{
for (UINT typeIDX = 0; typeIDX < (UINT)GROUP_TYPE::END; typeIDX++) {
for (size_t objIDX = 0; objIDX < m_arrObj[typeIDX].size(); objIDX++) {
//Final Update는 돌려줌. 내부적으로 Component들의 마무리 단계 업데이트(충돌처리나, 참조관계등)
m_arrObj[typeIDX][objIDX]->finalupdate();
}
}
}
void CScene::render(HDC _dc)
{
for (UINT typeIDX = 0; typeIDX < (UINT)GROUP_TYPE::END; typeIDX++) {
auto ObjVecIter = m_arrObj[typeIDX].begin();
for (; ObjVecIter != m_arrObj[typeIDX].end();) {
if (!(*ObjVecIter)->IsDead()) {
(*ObjVecIter)->render(_dc);
ObjVecIter++;
}
else {
//Dead상태일 경우엔 렌더링에서 삭제하기.
ObjVecIter = m_arrObj[typeIDX].erase(ObjVecIter);
}
}
}
}
void CScene::DeleteGroup(GROUP_TYPE _eGroup)
{
Safe_Delete_Vec<CObject*>(m_arrObj[(UINT)_eGroup]);
}
void CScene::DeleteAll()
{
for (UINT GroupIdx = 0; GroupIdx < (UINT)GROUP_TYPE::END; GroupIdx++) {
DeleteGroup((GROUP_TYPE)GroupIdx);
}
}
- 입력받은 그룹을 삭제하는 DeleteGroup 함수, 모든 오브젝트를 다 삭제하는 DeleteAll 함수를 만들었다.
- CScene_Tool.h
#pragma once
#include "CScene.h"
class CScene_Tool :
public CScene
{
private:
public:
virtual void update();
virtual void Enter();
virtual void Exit();
public:
CScene_Tool();
~CScene_Tool();
};
- CScene_Tool.cpp
#include "pch.h"
#include "CScene_Tool.h"
#include "CkeyMgr.h"
#include "CSceneMgr.h"
CScene_Tool::CScene_Tool()
{
}
CScene_Tool::~CScene_Tool()
{
}
void CScene_Tool::update()
{
//부모쪽 기능 호출.
CScene::update();
if (KEY_TAP(KEY::ENTER)) {
ChangeScene(SCENE_TYPE::START);
}
}
void CScene_Tool::Enter()
{
}
void CScene_Tool::Exit()
{
}
- 엔터를 눌러 씬 체인지를 한다.
- CScene_Start.cpp
#include "pch.h"
#include "CScene_start.h"
#include "CObject.h"
#include "CCore.h"
#include "CTexture.h"
#include "CPlayer.h"
#include "CMonster.h"
#include "CCollisionMgr.h"
#include "CPathMgr.h"
#include "CkeyMgr.h"
#include "CSceneMgr.h"
CScene_Start::CScene_Start()
{
}
CScene_Start::~CScene_Start()
{
}
void CScene_Start::update()
{
//부모쪽 기능 호출.
CScene::update();
if (KEY_TAP(KEY::ENTER)) {
ChangeScene(SCENE_TYPE::TOOL);
}
}
void CScene_Start::Enter()
{
//Object 추가.
//실제 생성된 객체는 플레이어, 주소를 받은 건 부모 클래스.
CObject* pObj = new CPlayer;
pObj->SetPos(Vec2(640.f, 384.f));
pObj->SetScale(Vec2(100.f, 100.f));
AddObject(pObj, GROUP_TYPE::PLAYER);
CObject* pOtherPlayer = pObj->Clone();
pOtherPlayer->SetPos(Vec2(740.f, 384.f));
AddObject(pOtherPlayer, GROUP_TYPE::PLAYER);
//몬스터 배치.
int iMonCount = 3;
float fMoveDist = 25.f;
float fObjScale = 50.f;
Vec2 vResolution = CCore::GetInstance()->GetResolution();
CMonster* pMonsterObj = nullptr;
float fTerm = (vResolution.x - ((fMoveDist + fObjScale / 2.f) * 2)) / (float)(iMonCount - 1);
for (int idx = 0; idx < iMonCount; idx++) {
//Monster Object 추가.
pMonsterObj = new CMonster;
pMonsterObj->SetName(L"Monster");
pMonsterObj->SetPos(Vec2((fMoveDist + fObjScale / 2.f) + (float)idx * fTerm, 50.f));
pMonsterObj->SetCenterPos(pMonsterObj->GetPos());
pMonsterObj->SetMaxMoveDistance(fMoveDist);
pMonsterObj->SetScale(Vec2(fObjScale, fObjScale));
AddObject(pMonsterObj, GROUP_TYPE::MONSTER);
}
//충돌 지점.
//Player 그룹과 Monster그룹간의 충돌 체크
//update에서 로직, finalupdate에서 최종 움직임 완료
//이제 새로운 충돌이 발생할수도 있음.
CCollisionMgr::GetInstance()->CheckGroup(GROUP_TYPE::PLAYER, GROUP_TYPE::MONSTER);
CCollisionMgr::GetInstance()->CheckGroup(GROUP_TYPE::PROJ_PLAYER, GROUP_TYPE::MONSTER);
}
void CScene_Start::Exit()
{
//나갈때 전부 삭제해줘야함.
DeleteAll();
//충돌도 전부 초기화 해주기.
CCollisionMgr::GetInstance()->Reset();
}
- Exit함수 구현, 플레이어를 하나 더 Clone을 써서 만드는 코드를 추가했다.
댓글 남기기