PROJECT REPORT // WINAPI_DONT_STARVE

// GameObject.h - 컴포넌트 추가 및 획득 핵심 로직
template <typename T, typename... Args>
T* AddComponent(Args&&... args) {
    auto newComponent = std::make_unique<T>(this, std::forward<Args>(args)...);
    T* componentPtr = newComponent.get();
    m_components.push_back(std::move(newComponent));
    return componentPtr;
}

template <typename T>
T* GetComponent() const {
    for (const auto& component : m_components) {
        if (!component) continue;
        T* target = dynamic_cast<T*>(component.get());
        if (target) return target;
    }
    return nullptr;
}

// ObjectManager.h - 공간 분할 시스템의 선언부
class ObjectManager {
public:
    void UpdateObjectGrid(GameObject* pObj);
    void AddToGrid(GameObject* pObj);
    void RemoveFromGrid(GameObject* pObj);

private:
    // 256px 정사각형 셀 기준의 정적 그리드 크기 정의
    static constexpr int GRID_CELL_SIZE = 256;
    static constexpr int GRID_WIDTH = (MAP_WIDTH * TILE_SIZE / GRID_CELL_SIZE) + 2;
    static constexpr int GRID_HEIGHT = (MAP_HEIGHT * TILE_SIZE / GRID_CELL_SIZE) + 2;

    // 2D 공간 분할 그리드 (각 셀마다 속한 오브젝트 포인터 벡터 관리)
    std::vector<GameObject*> m_spatialGrid[GRID_WIDTH][GRID_HEIGHT];
    uint32_t m_spatialQueryStamp = 1;
};

// ObjectManager.cpp - 객체 생성 시 그리드 등록
void ObjectManager::AddToGrid(GameObject* pObj)
{
    if (!pObj || pObj->GetType() == GO_TYPE_UI) return;

    Gdiplus::RectF bounds = pObj->GetBounds();
    int x = (int)floor((bounds.X + bounds.Width * 0.5f) / GRID_CELL_SIZE);
    int y = (int)floor((bounds.Y + bounds.Height * 0.5f) / GRID_CELL_SIZE);

    x = (std::max<int>)(0, (std::min<int>)(GRID_WIDTH - 1, x));
    y = (std::max<int>)(0, (std::min<int>)(GRID_HEIGHT - 1, y));

    m_spatialGrid[x][y].push_back(pObj);
    pObj->SetGridCell(x, y);
}

// ObjectManager.cpp - 객체 소멸 시 그리드 제거
void ObjectManager::RemoveFromGrid(GameObject* pObj)
{
    if (!pObj) return;
    int x = pObj->GetGridCellX();
    int y = pObj->GetGridCellY();

    if (x >= 0 && x < GRID_WIDTH && y >= 0 && y < GRID_HEIGHT) {
        std::vector<GameObject*>& cell = m_spatialGrid[x][y];
        cell.erase(std::remove(cell.begin(), cell.end(), pObj), cell.end());
        pObj->SetGridCell(-1, -1);
    }
}

// SpriteSheet.cpp - CreateFromFile 핵심 슬라이싱 및 비트맵 공유 로직
std::shared_ptr<SpriteSheet> SpriteSheet::CreateFromFile(
    const std::wstring& filePath, int frameWidth, int frameHeight,
    int cols, int totalFrames, float pivotX, float pivotY, bool flipHorizontal)
{
    auto sheet = std::shared_ptr<SpriteSheet>(new SpriteSheet());
    auto bitmap = std::make_shared<Gdiplus::Bitmap>(filePath.c_str());
    if (bitmap->GetLastStatus() != Gdiplus::Ok) return nullptr;

    int sheetWidth = bitmap->GetWidth();
    int sheetHeight = bitmap->GetHeight();

    // frameWidth/frameHeight가 0이면 cols와 totalFrames로 동적 자동 계산
    int finalFrameWidth = frameWidth;
    int finalFrameHeight = frameHeight;
    if (finalFrameWidth <= 0 && cols > 0) {
        finalFrameWidth = sheetWidth / cols;
    }
    if (finalFrameHeight <= 0 && cols > 0 && totalFrames > 0) {
        int totalRows = (totalFrames + cols - 1) / cols;
        finalFrameHeight = sheetHeight / totalRows;
    }

    // 단일 원본 비트맵 포인터를 공유하며 33개 프레임의 UV sourceRect만 생성
    sheet->m_bitmap = bitmap;
    for (int i = 0; i < totalFrames; ++i) {
        int col = i % cols;
        int row = i / cols;

        Gdiplus::Rect sourceRect(col * finalFrameWidth, row * finalFrameHeight, 
                                 finalFrameWidth, finalFrameHeight);
        sheet->m_sprites.push_back(std::make_shared<Sprite>(bitmap, sourceRect, pivotX, pivotY));
    }
    return sheet;
}

// Player.cpp - 도끼질 애니메이션 설정 및 이벤트 콜백 바인딩
const int CHOP_HIT_FRAME = 4; // 도끼가 나무에 맞는 프레임

// 클립에 이벤트 프레임 등록
AnimationClip* clip = m_animator->GetAnimationClip((int)PlayerState::CHOP, dir);
if (clip) {
    clip->AddEventFrame(CHOP_HIT_FRAME, L"chop_hit");
    clip->AddEventFrame(CHOP_LAST_FRAME, L"chop_end");

    // 이벤트 콜백 람다 바인딩: 프레임 이벤트 검사 시 바인딩된 콜백 자동 실행
    clip->SetEventCallback([this](int frameIndex, const std::wstring& eventName) {
        if (eventName == L"chop_hit") {
            SoundManager::GetInstance()->PlaySFX(L"Resource/Sound/PlayerSound/Chop_tree.wav");
            this->OnChopHit(); // 타겟 나무에 데미지 적용
        }
        else if (eventName == L"chop_end") {
            this->OnChopEnd(); // 상태 전이
        }
    });
}

// DataManager.cpp - GameData/object_resource_overrides.txt 로드 및 id별 피벗/콜라이더 주입
void DataManager::Init()
{
    // 1. 코드 기본 테이블 로드
    for (size_t i = 0; i < DataTable::ObjectResourceCount; ++i) {
        const auto& entry = DataTable::ObjectResourceTable[i];
        m_objectResources[entry.id] = { entry.id, entry.baseDir, entry.imageName };
    }

    // 2. 에디터에서 저장된 오버라이드 텍스트 파일을 파싱하여 실시간 덮어쓰기
    ResourcePathUtils::ParseObjectResourceOverridesFile(L"GameData/object_resource_overrides.txt",
        [this](GameObjectID id, const ResourcePathUtils::ObjectResourceDef& overrideDef) {
            auto it = m_objectResources.find(id);
            if (it != m_objectResources.end()) {
                it->second.pivotX = overrideDef.pivotX;
                it->second.pivotY = overrideDef.pivotY;
                it->second.hasCollider = overrideDef.hasCollider;
                it->second.colliderType = overrideDef.colliderType;
                it->second.colliderOffsetX = overrideDef.colliderOffsetX;
                it->second.colliderOffsetY = overrideDef.colliderOffsetY;
                it->second.colliderWidth = overrideDef.colliderWidth;
                it->second.colliderHeight = overrideDef.colliderHeight;
                it->second.colliderRadius = overrideDef.colliderRadius;
            }
        });
}

// SceneManager.cpp - DataManager의 리소스 정보를 전달하며 맵 파싱 수행
bool SceneManager::ParseMapFile(const std::wstring& mapFileName, MapData& outMapData)
{
    auto getObjectResourceInfo = [](GameObjectID id) -> const ResourcePathUtils::ObjectResourceDef* {
        return DataManager::GetInstance()->GetObjectResourceInfo(id);
    };
    return ResourcePathUtils::ParseMapFileInto(mapFileName, outMapData, getObjectResourceInfo);
}

// Function.h - ParseMapFileInto: .dsm 텍스트 섹션 파싱 및 오브젝트 스폰
template<typename GetObjectResourceInfoFunc>
inline bool ParseMapFileInto(const std::wstring& mapFileName, MapData& outMapData, GetObjectResourceInfoFunc getObjectResourceInfo)
{
    std::wifstream file(mapFileName);
    if (!file.is_open()) return false;

    std::wstring line;
    enum Section { NONE, METADATA, PLAYER, TILES, OBJECTS } section = NONE;

    while (std::getline(file, line)) {
        if (line.empty() || line[0] == L'#') {
            if (line.find(L"# PLAYER") != std::wstring::npos) section = PLAYER;
            else if (line.find(L"# TILES") != std::wstring::npos) section = TILES;
            else if (line.find(L"# OBJECTS") != std::wstring::npos) section = OBJECTS;
            continue;
        }

        if (section == OBJECTS) {
            std::wstringstream ss(line);
            std::wstring idStr, xStr, yStr;
            if (std::getline(ss, idStr, L',') && std::getline(ss, xStr, L',') && std::getline(ss, yStr, L',')) {
                GameObjectID objID = EnumTables::GetGameObjectID(idStr.c_str());
                if (objID != GOID_NONE) {
                    const auto* pRes = getObjectResourceInfo(objID); // 에디터에서 수정한 피벗/콜라이더 획득
                    outMapData.gameObjects.push_back({ objID, std::stof(xStr), std::stof(yStr), pRes });
                }
            }
        }
    }
    file.close();
    return true;
}