
#include "Tdetector.h"

static std::string  p_path = "donnees/";

// -----------------------
// --- le constructeur ---
// -----------------------

Tdetector::Tdetector()
{
    // bloque les detecteurs non initialisés
	m_state = DET_ALWAY_OFF;
}

// ----------------------
// --- le destructeur ---
// ----------------------

Tdetector::~Tdetector()
{
    //
}


// --------------------
// --- les méthodes ---
// --------------------

void Tdetector::create(std::string& flux)
{
    std::vector<std::string> strList;

    ECO_strCut(strList, flux, ' ');

    m_code = strList[0];
    // 1 sep
    m_pos.x = ECO_strToFloat(strList[2]);
    m_pos.y = ECO_strToFloat(strList[3]);
    m_pos.z = ECO_strToFloat(strList[4]);
    m_radius = ECO_strToFloat(strList[5]);
    // 6
    m_state = ECO_strToInt(strList[7]);
    m_action = ECO_strToInt(strList[8]);
    // 9
    m_soundFile = strList[10];
    m_loop = ECO_strToInt(strList[11]);
    // 12

    //ECO_error_set("%s", m_soundFile.c_str());
    _composition();
}

void Tdetector::create(std::ifstream& flux)
{
    std::string sep;

    flux >> m_code >> sep;
    flux >> m_pos.x >> m_pos.y >> m_pos.z >> m_radius >> sep;
    flux >> m_state >> m_action >> sep >> m_soundFile >> m_loop >> sep;

    _composition();
}

void Tdetector::_composition()
{
    //ECO_error_set(m_soundFile.c_str());
    if (m_soundFile != "null")
    {
        setSound(PATH_MESH + m_soundFile, m_loop);
    }
}




std::string Tdetector::getAction()
{
    return m_action;
}

std::string Tdetector::getCode()
{
    return m_code;
}

// true en entrant
// if (detecteur.getIn() => detecteur.getAction + detecteur.getcible
bool Tdetector::getIn(OVec3_f& posSrc)
{
    if (m_state < DET_ON) return false;

    float dist = ECO_distanceVF(posSrc, m_pos);

    if (dist < m_radius)
    {
        // attribue un canal si le son si arrive près de la source
        // décharge le son dès que l'on s'éloigne
        // 100*2 = boost le son pour qu'il soit audible dès la limite atteinte
        if (m_sound.exist())
        {
            if (!m_sound.getPlay())
            {
				m_sound.play();
			}
			m_sound.setVolumeI(((m_radius - dist) / m_radius) * 200);
		}
        return true;
    }
    else
    {
        m_sound.stop();
    }

    return false;
}

OVec3_f& Tdetector::getPos()
{
    return m_pos;
}

int Tdetector::getState()
{
    return m_state;
}




void Tdetector::pause(bool mode)
{
    //if (type != DET_DETECTEUR) return false;
    if (m_sound.exist()) m_sound.pause(mode);
}




void Tdetector::save(std::ofstream& flux)
{
    flux << "det ";
    flux << m_code << " / ";
    flux << m_pos.x << " " << m_pos.y << " " << m_pos.z <<  " " << m_radius << " / ";
    flux << m_state << " " << m_action << " / " << m_soundFile << " " << m_loop << " /" << std::endl;
}

void Tdetector::setPos(OVec3_f& pos)
{
    m_pos = pos;
}

// ne lance pas le son !
void Tdetector::setSound(std::string file, int loop, bool play)
{
    if (ECO_fileExist(file))
    {
        //ECO_error_set("ok son detecteur %s", file.c_str());
        m_loop = loop;
        if (m_loop > 0)
        {
            m_sound.create(file, OSOUND_EFFECTS, OSOUND_LOOP);
        }
        else
        {
            m_sound.create(file);
        }
        m_state = DET_ON;
        if (play) m_sound.play();
        return;
    }

    m_sound.stop();
    m_state = DET_ALWAY_OFF;    // on fait appel à un detecteur mal initialisé
    //ECO_error_set("echec detecteur %s > Tdetector.setSound", file.c_str());
}

void Tdetector::setState(int value)
{
    if (m_state == DET_ALWAY_OFF) return;

    m_state = value;

    if (m_state < DET_ON)
    {
        //if (m_loop == 0) m_sound.stop();
        m_sound.stop();
    }
    // play avec distance
}

// propriete

void Tdetector::P_setPath(std::string path)
{
    p_path = path;
}






