CTileManager

#include    <tgSystem.h>
#include    "CTile.h"

#include    "CTileManager.h"
#include    "CLevelEditor.h"
#include    "Managers/CModelManager.h"
#include    "Managers/CLightManager.h"
#include    "CPhysicsManager.h"
#include    "tgCTextureManager.h"
#include    "GameStateMachine/CGameStates.h"
#include    "tgCFileSystem.h"
#include <tgMemoryDisable.h>
#include <fstream>
#include <ctime>
#include <string>
#include <tgMemoryEnable.h>
#include "CStringParser.h"
#include "Managers/CWorldManager.h"

std::vector<tgCString> CTileManager::GetFilesInFolders(std::string folder)
{
#if defined(TG_WINDOWS)

    std::vector<tgCString> names;
    char search_path[200];
    sprintf(search_path, "%s/*.*", folder.c_str());
    WIN32_FIND_DATA fd;
    HANDLE hFind = ::FindFirstFile(search_path, &fd);
    if(hFind != INVALID_HANDLE_VALUE) {
        do {
            // read all (real) files in current folder
            // , delete '!' read other 2 default folder . and ..
            if(! (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
                names.push_back(fd.cFileName);
            }
        }while(::FindNextFile(hFind, &fd));
        ::FindClose(hFind);
    }
    return names;
#endif
}

CTileManager::CTileManager( )
{

    m_SizeX = 16;
    m_SizeY = 14;

    m_Spacing = 2.0f;
    m_StartingPos = tgCV3D(0.0f, 0.0f, 0.0f);

    m_TileDestructionMode = DESTRUCTIONMODE_FALLING;

    // If not level editor, load selected level.
    if( !CGameStates::GetInstance().GetStateMenu()->GetIsEditor() || CGameStates::GetInstance().GetStateMenu()->GetIsEditingLevel() ){
        LoadLevel();
    }
    else{
        for (tgUInt32 i = 0; i < (m_SizeX * m_SizeY); i++)
        {
            AddTile(i, CGameStates::GetInstance().GetStateMenu()->GetSelectedTheme());
        }
    }

    CPhysicsManager::GetInstance().GetWorld()->optimizeBroadPhase();

}

CTileManager::~CTileManager( void )
{

    for (tgUInt32 i = 0; i < m_Tiles.size(); i++)
    {
        delete m_Tiles[i];
    }


}


tgBool CTileManager::LoadLevel( void ){
    tgCString FileName = "";

#if defined(TG_WINDOWS)
    SGameInfo GameInfo;

    GameInfo = CGameStates::GetInstance().GetStateCharSel()->GetGameInfo();
    tgCString LevelName = "";

    if(GameInfo.SelectedLevel == 0){
        LevelName = "FUMP_Level_1.txt";
    }
    if(GameInfo.SelectedLevel == 1){
        LevelName = "FUMP_Level_2.txt";
    }
    if(GameInfo.SelectedLevel == 2){
        LevelName = "FUMP_Level_3.txt";
    }
    if(GameInfo.SelectedLevel == 3){
        LevelName = "FUMP_Level_4.txt";
    }
    if(CGameStates::GetInstance().GetStateGame()->GetPlayFromDebugMenu())
        FileName = tgCString("data/levels/%s", GetFilesInFolders("data/levels").at(CGameStates::GetInstance().GetStateGame()->GetSelectedLevel()-1).String());
    else if(CGameStates::GetInstance().GetStateGame()->GetPlayFromCharacterSelect())
        FileName = tgCString("data/levels/%s", LevelName.String());
    else
        FileName = tgCString("data/levels/%s", GetFilesInFolders("data/levels").at(0).String());

#elif defined(TG_PS4)
    tgUInt8*    pData   = NULL;
    tgUInt32    Size    = 0;
    SGameInfo GameInfo;

    GameInfo = CGameStates::GetInstance().GetStateCharSel()->GetGameInfo();
    tgCString LevelName = "";

    if(GameInfo.SelectedLevel == 0){
        LevelName = "FUMP_Level_1.txt";
    }
    if(GameInfo.SelectedLevel == 1){
        LevelName = "FUMP_Level_2.txt";
    }
    if(GameInfo.SelectedLevel == 2){
        LevelName = "FUMP_Level_3.txt";
    }
    if(GameInfo.SelectedLevel == 3){
        LevelName = "FUMP_Level_4.txt";
    }

    if(CGameStates::GetInstance().GetStateGame()->GetPlayFromCharacterSelect())
        FileName = tgCString("/app0/data/levels/%s", LevelName.String());
    else
        FileName = tgCString("/app0/data/levels/PERFORMANCE_TEST_LEVEL.txt");
#endif

    std::string Line;
    size_t Pos = 0;
    size_t Pos1 = 1;

    tgUInt32 Index = 0;
    std::string Delimiter = "|";
    std::string DimensionDelimiter = "x";

    std::ifstream LevelFile;
    std::string Tile;

    LevelFile.open(FileName.String());
    // Loop through file, split strings by delimiter and get type and pos
    if (LevelFile.is_open())
    {
        while ( getline (LevelFile,Line) )
        {
            if((Pos = Line.find(DimensionDelimiter) != std::string::npos)){
                if(Line.length() < 3)
                    m_SizeX = std::stoi(Line.substr(0, Pos));
                else if(Line.length() < 6)
                {
                    m_SizeX = std::stoi(Line.substr(0, Pos) + Line.substr(1, Pos));
                    if(Line.length() >= 4)
                        m_Theme = std::stoi(Line.substr(3, Pos));
                    else
                        m_Theme = 0;
                }
            }
            while ((Pos = Line.find(Delimiter)) != std::string::npos) {
                Tile = Line.substr(0, Pos);
                AddTileFromFile(Index, std::stoi(Tile), m_Theme);
                Line.erase(0, Pos + Delimiter.length());
                Index++;
            }
        }
        LevelFile.close();
    }
    return true;

}

void CTileManager::AddTile( tgUInt32 Index, tgUInt32 Theme  )
{
    tgUInt32 Row, Col;
    Col = Index % m_SizeX;
    Row = Index / m_SizeX;
    tgCV3D Position = tgCV3D(-(m_StartingPos.x + ((Index * m_Spacing) - (Row * (m_Spacing * m_SizeX)))), m_StartingPos.y, (Row * m_Spacing));

    CTile *Tile = new CTile(Position, 1.0f, 1.0f, 0, Theme);

    m_Tiles.push_back(Tile);
}

void CTileManager::AddTileFromFile( tgUInt32 Index, tgUInt32 Type, tgUInt32 Theme )
{
    tgUInt32 Row, Col;
    Col = Index % m_SizeX;
    Row = Index / m_SizeX;
    tgCV3D Position = tgCV3D(-(m_StartingPos.x + ((Index * m_Spacing) - (Row * (m_Spacing * m_SizeX)))), m_StartingPos.y, (Row * m_Spacing));

    CTile *Tile = new CTile(Position, 1.0f, 1.0f, Type, Theme);
    m_Tiles.push_back(Tile);

}

void CTileManager::Update( tgFloat DeltaTime )
{
    for (tgUInt32 i = 0; i < m_Tiles.size(); i++)
    {
        m_Tiles[i]->Update(DeltaTime);
    }
}

void CTileManager::RandomTileFall(  )
{
    for (tgUInt32 i = 0; i < m_Tiles.size(); i++)
    {
        m_Tiles[i]->GetWorld()->setBodyMotionType(m_Tiles[i]->GetBodyID(), hknpMotionType::DYNAMIC);
    }
}

void CTileManager::ApplyForceToAllTiles(  )
{
    for (tgUInt32 i = 0; i < m_Tiles.size(); i++)
    {

        m_Tiles[i]->GetWorld()->applyBodyLinearImpulse(m_Tiles[i]->GetBodyID(), hkVector4(tgMathRandom(-120.0f, 120.0f), 120.0f, tgMathRandom(-120.0f, 120.0f)));
    }
}

void CTileManager::Render( void )
{
    const CLightManager::SLight*    pLightArray     = CLightManager::GetInstance().GetLightArray();
    tgCLightManager&                rLightManager   = tgCLightManager::GetInstance();
    CLightManager&  LightManager        = CLightManager::GetInstance();


    // Render all solid meshes
    for( tgUInt32 LightIndex = 0; LightIndex < MAX_NUM_LIGHTS; ++LightIndex )
    {
        if( pLightArray[ LightIndex ].pLight )
        {
            rLightManager.SetCurrentLight( *pLightArray[ LightIndex ].pLight );

            for (tgUInt32 i = 0; i < m_Tiles.size(); i++)
            {
                m_Tiles[i]->Render();
            }

        }
    }


}