ActivatedItem.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 "KeyFrame.h"
#include "OdorType.h"
#include "Odor.h"
#include "Light.h"
#include "LightManager.h"
#include "Simulator.h"

namespace AnimatSim
{
ActivatedItem::ActivatedItem()
{
        m_bEnabled = true;
        m_lStartSlice = 0;
        m_lEndSlice = 0;
        m_fltStartTime = 0;
        m_fltEndTime = 0;
        m_bLoadedTime = false;
        m_iStepInterval = 1;
        m_iStepIntervalCount = 1;
        m_bAlwaysActive = false;
        m_bInitialized = false;
        m_bIsActivated = false;
}

ActivatedItem::~ActivatedItem()
{

}

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

void ActivatedItem::Enabled(bool bVal)
{
        m_bEnabled = bVal;

        if(m_lpSim->Paused() && m_lpSim->TimeSlice() > 0)
        {
                if(!m_bEnabled && IsActivated())
                        Deactivate();
                else if(m_bEnabled && !IsActivated() && NeedToActivate())
                        Activate();
        }
}

bool ActivatedItem::LoadedTime()
{return m_bLoadedTime;}

void ActivatedItem::LoadedTime(bool bVal)
{m_bLoadedTime = bVal;}

long ActivatedItem::StartSlice()
{return m_lStartSlice;}

void ActivatedItem::StartSlice(long lVal, bool bReInit)
{
        Std_IsAboveMin((long) -1, lVal, true, "StartSlice");
        Std_IsBelowMax(m_lEndSlice, lVal, true, "StartSlice");

        m_lStartSlice = lVal;
        m_fltStartTime = m_lStartSlice* m_lpSim->TimeStep();
}

long ActivatedItem::EndSlice()
{return m_lEndSlice;}

void ActivatedItem::EndSlice(long lVal, bool bReInit)
{
        Std_IsAboveMin((long) -1, lVal, true, "EndSlice");
        Std_IsAboveMin(m_lStartSlice, lVal, true, "EndSlice");

        m_lEndSlice = lVal;
        m_fltEndTime = m_lEndSlice* m_lpSim->TimeStep();
}

float ActivatedItem::StartTime()
{return m_fltStartTime;}

void ActivatedItem::StartTime(float fltVal, bool bReInit)
{
        Std_IsAboveMin((float) -1, fltVal, true, "StartTime");
        Std_IsBelowMax(m_fltEndTime, fltVal, true, "StartTime");

        m_fltStartTime = fltVal;
        m_lStartSlice = (long) (m_fltStartTime / m_lpSim->TimeStep() + 0.5);
}

float ActivatedItem::EndTime()
{return m_fltEndTime;}

void ActivatedItem::EndTime(float fltVal, bool bReInit)
{
        Std_IsAboveMin((float) -1, fltVal, true, "EndTime");
        Std_IsAboveMin(m_fltStartTime, fltVal, true, "EndTime");

        m_fltEndTime = fltVal;
        m_lEndSlice = (long) (m_fltEndTime / m_lpSim->TimeStep() + 0.5);
}

int ActivatedItem::StepInterval()
{return m_iStepInterval;}

void ActivatedItem::StepInterval(int iVal)
{
        Std_IsAboveMin((int) 0, iVal, true, "StepInterval");

        m_iStepInterval = iVal;
}

int ActivatedItem::StepIntervalCount()
{return m_iStepIntervalCount;}

void ActivatedItem::StepIntervalCount(int iVal)
{m_iStepIntervalCount = iVal;}

bool ActivatedItem::AlwaysActive()
{return m_bAlwaysActive;}

void ActivatedItem::AlwaysActive(bool bVal)
{m_bAlwaysActive = bVal;}

bool ActivatedItem::IsActivated() {return m_bIsActivated;}

bool ActivatedItem::IsInitialized() {return m_bInitialized;}

bool ActivatedItem::NeedToActivate()
{
        if(!m_bIsActivated && m_bEnabled && (m_bAlwaysActive || (m_lStartSlice <= m_lpSim->TimeSlice() && m_lEndSlice >= m_lpSim->TimeSlice())))
                return true;
        return false;
}

bool ActivatedItem::NeedToDeactivate()
{
        if(m_bIsActivated && !m_bEnabled)
                return true;

        if(m_bIsActivated && !m_bAlwaysActive && !(m_lStartSlice <= m_lpSim->TimeSlice() && m_lEndSlice >= m_lpSim->TimeSlice()) )
                return true;
        return false;
}

void ActivatedItem::Activate()
{
        m_bIsActivated = true;
}

void ActivatedItem::Deactivate()
{
        m_bIsActivated = false;
}

void ActivatedItem::ResetSimulation()
{
        m_bIsActivated = false;
}

bool ActivatedItem::Overlaps(ActivatedItem *lpItem)
{
        if( (lpItem->StartSlice() >= this->StartSlice()) && (lpItem->StartSlice() <= this->EndSlice()) )
                return true;

        if( (lpItem->EndSlice() >= this->StartSlice()) && (lpItem->EndSlice() <= this->EndSlice()) )
                return true;

        return false;
}


void ActivatedItem::Initialize()
{
        AnimatBase::Initialize();
        SetSliceData();
        m_bInitialized = true;
}

void ActivatedItem::SetSliceData()
{
        if(m_bLoadedTime)
        {
                m_lStartSlice = (long) (m_fltStartTime / m_lpSim->TimeStep() + 0.5);
                m_lEndSlice = (long) (m_fltEndTime / m_lpSim->TimeStep() + 0.5);

                Std_IsAboveMin((long) -1, m_lStartSlice, true, "StartSlice");
                Std_IsAboveMin(m_lStartSlice, m_lEndSlice, true, "EndSlice");
        }
        else
        {
                m_fltStartTime = m_lStartSlice * m_lpSim->TimeStep();
                m_fltEndTime = m_lEndSlice * m_lpSim->TimeStep();
        }
}

void ActivatedItem::ReInitialize()
{
        if(!m_bInitialized)
                Initialize();
        else
                SetSliceData();
}

void ActivatedItem::TimeStepModified()
{
        ReInitialize();
}

bool ActivatedItem::NeedToStep()
{
        if(m_iStepInterval <= 1)
                return true;
        else if(m_iStepIntervalCount == -1 || m_iStepIntervalCount == m_iStepInterval)
        {
                m_iStepIntervalCount = 1;
                return true;
        }
        else
        {
                m_iStepIntervalCount++;
                return false;
        }
}

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

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

        if(strType == "STARTTIME")
        {
                StartTime((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "ENDTIME")
        {
                EndTime((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "ALWAYSACTIVE")
        {
                AlwaysActive(Std_ToBool(strValue));
                return true;
        }

        if(strType == "STEPINTERVAL")
        {
                StepInterval((float) atoi(strValue.c_str()));
                return true;
        }

        if(strType == "ENABLED")
        {
                Enabled(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 ActivatedItem::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);

        oXml.IntoElem();  //Into Item Element

        //Do not call the mutator here because it will run code we do not want to run on load.
        m_bEnabled = oXml.GetChildBool("Enabled", "True");

        if(oXml.FindChildElement("StartTime", false))
        {
                m_bLoadedTime = true;
                EndTime(oXml.GetChildFloat("EndTime"), false);
                StartTime(oXml.GetChildFloat("StartTime"), false);
        }
        else
        {
                m_bLoadedTime = false;
                EndSlice(oXml.GetChildLong("EndSlice"), false);
                StartSlice(oXml.GetChildLong("StartSlice"), false);
        }

        StepInterval(oXml.GetChildInt("StepInterval", m_iStepInterval));
        AlwaysActive(oXml.GetChildBool("AlwaysActive", m_bAlwaysActive));

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

bool LessThanActivatedItemCompare(ActivatedItem *lpItem1, ActivatedItem *lpItem2)
{
        return lpItem1->operator<(lpItem2);
}


}                       //AnimatSim