Odor.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "IMovableItemCallback.h"
#include "ISimGUICallback.h"
#include "AnimatBase.h"

#include "Node.h"
#include "IPhysicsMovableItem.h"
#include "IPhysicsBody.h"
#include "BoundingBox.h"
#include "MovableItem.h"
#include "BodyPart.h"
#include "Joint.h"
#include "ReceptiveField.h"
#include "ContactSensor.h"
#include "RigidBody.h"
#include "Structure.h"
#include "Organism.h"
#include "ActivatedItem.h"
#include "ActivatedItemMgr.h"
#include "DataChartMgr.h"
#include "ExternalStimuliMgr.h"
#include "KeyFrame.h"
#include "SimulationRecorder.h"
#include "OdorType.h"
#include "Odor.h"
#include "Light.h"
#include "LightManager.h"
#include "Simulator.h"


namespace AnimatSim
{
        namespace Environment
        {
Odor::Odor(RigidBody *lpParent)
{
        m_lpParent = lpParent;
        m_lpOdorType = NULL;
        m_fltQuantity = 100;
        m_bUseFoodQuantity = false;
        m_bEnabled = true;
}

Odor::~Odor()
{

try
{
        m_lpParent = NULL;
}
catch(...)
{Std_TraceMsg(0, "Caught Error in desctructor of Odor\r\n", "", -1, false, true);}
}

bool Odor::Enabled()
{return m_bEnabled;}

void Odor::Enabled(bool bVal)
{
        m_bEnabled = bVal;
}

void Odor::SetOdorType(std::string strType)
{
        //Now lets find the odor type for this odor and add this one to it.
        m_lpOdorType = m_lpSim->FindOdorType(strType);
        m_lpOdorType->AddOdorSource(this);
}

OdorType  *Odor::GetOdorType() {return m_lpOdorType;}

void Odor::Quantity(float fltVal) 
{
        Std_IsAboveMin((float) 0, m_fltQuantity, true, "Quantity");
        m_fltQuantity = fltVal;
}

float Odor::Quantity() 
{
        if(m_bUseFoodQuantity)
                return m_lpParent->FoodQuantity();
        else
                return m_fltQuantity;
};

bool Odor::UseFoodQuantity() {return m_bUseFoodQuantity;}

void Odor::UseFoodQuantity(bool bVal) {m_bUseFoodQuantity = bVal;}

float Odor::CalculateOdorValue(OdorType *lpType, CStdFPoint &oSensorPos)
{
        if(!m_lpParent || !m_bEnabled) return 0;

        CStdFPoint oOdorPos = m_lpParent->GetCurrentPosition();

        float fltDist = Std_CalculateDistance(oOdorPos, oSensorPos);
        float fltVal = (this->Quantity() * lpType->DiffusionConstant()) / (fltDist * fltDist); 
        
        return fltVal;
}

bool Odor::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);

        if(AnimatBase::SetData(strType, strValue, false))
                return true;

        if(strType == "ENABLED")
        {
                Enabled(Std_ToBool(strValue));
                return true;
        }

        if(strType == "QUANTITY")
        {
                Quantity(atof(strValue.c_str()));
                return true;
        }

        if(strType == "USEFOODQUANTITY")
        {
                UseFoodQuantity(Std_ToBool(strValue));
                return true;
        }

        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "Data Type", strDataType);

        return false;
}

void Odor::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("Enabled", AnimatPropertyType::Boolean, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("Quantity", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("UseFoodQuantity", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
}

void Odor::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);

        oXml.IntoElem();  //Into Odor Element

        SetOdorType(oXml.GetChildString("OdorTypeID"));
        Quantity(oXml.GetChildFloat("Quantity", m_fltQuantity));
        UseFoodQuantity(oXml.GetChildBool("UseFoodQuantity", m_bUseFoodQuantity));
        Enabled(oXml.GetChildBool("Enabled", m_bEnabled));

        oXml.OutOfElem(); //OutOf Odor Element
}

        }                       // Environment
}                       //AnimatSim