bool CTrackedNodeMgr::LinkNodes( HTRACKEDNODE ChildID, HTRACKEDNODE ParentID )
{
	//make sure the nodes are valid
	if(!CheckValidity(ChildID) || !CheckValidity(ParentID))
		return false;

	ParentID->m_pChild = ChildID;
	return true;
}

int CWavFile::IsCanCombine(CString strPathL, CString strPathR)
{
	BOOL b = FALSE;
	DWORD m_dwDataSizeL = 0;
	DWORD m_dwDataSizeR = 0;

	memset(&m_formatL, 0, sizeof(WAVEFORMATEX));
	memset(&m_formatR, 0, sizeof(WAVEFORMATEX));
	ZeroMemory(&m_mmckinfoParent, sizeof(MMCKINFO));
	ZeroMemory(&m_mmckinfoSubChunk, sizeof(MMCKINFO));
	
	// Check Validity of the first(left channel) file
	m_dwDataSizeL = CheckValidity(m_hWaveFileL, strPathL, m_formatL);
	if(m_dwDataSizeL == -1)
	{
		MyMessageBox(_T("Invalid wave file: ") + strPathL, eERR_ERROR);
		return -1;
	}

	// Check Validity of the second(right channel) file
	m_dwDataSizeR = CheckValidity(m_hWaveFileR, strPathR, m_formatR);
	if(m_dwDataSizeR == -1)
	{
		MyMessageBox(_T("Invalid wave file: ") + strPathR, eERR_ERROR);
		return -1;
	}

	// All of them must be mono wave file
	if(!(m_formatL.nChannels == 1))
	{
		MyMessageBox(_T("Not a mono wave file: ") + strPathL, eERR_ERROR);
		return -1;
	}
	if(!(m_formatR.nChannels == 1))
	{
		MyMessageBox(_T("Not a mono wave file: ") + strPathR, eERR_ERROR);
		return -1;
	}

	// They must have the same bps
	if(!(m_formatL.wBitsPerSample == m_formatR.wBitsPerSample))
	{
		MyMessageBox(_T("They must have the same bps"), eERR_ERROR);
		return -1;
	}

	// They must have the same sps
	if(m_formatL.nSamplesPerSec != m_formatR.nSamplesPerSec)
	{
		MyMessageBox(_T("They must have the same sps"), eERR_ERROR);
		return -1;
	}

	return max(m_dwDataSizeL, m_dwDataSizeR);
}

bool CTrackedNodeMgr::LinkNodeOrientation(	HTRACKEDNODE ID,
											HTRACKEDNODE CopyFrom )
{
	//check the params and parent object
	if(!CheckValidity(ID) || !CheckValidity(CopyFrom))
		return false;

	//ok, setup the link pointer
	ID->m_pMimicNode = CopyFrom;

	//success
	return true;
}

GridDefinition::GridDefinition(const float xRange[2], const float yRange[2], float pRadius, float pSpacing)
	: xMin(xRange[0]), xMax(xRange[1]), yMin(yRange[0]), yMax(yRange[1]), radius(pRadius), spacing(pSpacing), recipSpacing(1.0/spacing)
{
	numX = (xMax - xMin >= MinRange && spacing >= MinSpacing) ? (uint32_t)((xMax - xMin) * recipSpacing) + 1 : 0;
	numY = (yMax - yMin >= MinRange && spacing >= MinSpacing) ? (uint32_t)((yMax - yMin) * recipSpacing) + 1 : 0;
	CheckValidity();
}

/********************************************************************

  Savcor IT Oy/JLM
  Borland TURBO C++ 3.0
  Declaration: Parse received message
  Call: ret=ParseMessage(ReceiveBuffer)
  Input:  char *ReceiveBuffer
  Returns:  char *ret
  01.12.2000 Initial coding  JLM

*********************************************************************/
 void ParseMessage(char *OutMes)
  {
  int i;
  int j=0;
  char token[BUFFER_SIZE];

  strcpy(OutMes,"");
  strcpy(tempbuf,"");

  for (i=1;i<(int)strlen(Message);i++)
    {		

    if (IsAlpha(Message[i]) && ( i < ((int)strlen(Message)-1)))
      token[j++]=Message[i];
    else
      {
       if (j>0)
        {
          token[j]=0;  // end of string
          strcpy(tempbuf,"");				
          CheckValidity(token); 
          if ( (!DispWithoutLabels) && (strlen(tempbuf)>0))
          {
           strcat(OutMes,token);
           strcat(OutMes,"=");
          }
          strcat(OutMes,tempbuf);
					//printf ("OutMes=%s\n",OutMes);
        }
       j=0;
			} // else
    }
  }

bool CTrackedNodeMgr::IsLookingAtTarget( HTRACKEDNODE ID)
{
	if(!CheckValidity(ID))
		return false;

	return ID->m_bLookingAtTarget;
}

bool CSettingString::SetValue(const std::string &value)
{
  CSingleLock lock(m_critical);

  if (value == m_value)
    return true;
    
  if (!CheckValidity(value))
    return false;

  std::string oldValue = m_value;
  m_value = value;

  if (!OnSettingChanging(this))
  {
    m_value = oldValue;

    // the setting couldn't be changed because one of the
    // callback handlers failed the OnSettingChanging()
    // callback so we need to let all the callback handlers
    // know that the setting hasn't changed
    OnSettingChanging(this);
    return false;
  }

  m_changed = m_value != m_default;
  OnSettingChanged(this);
  return true;
}

bool CTrackedNodeMgr::SetTarget( HTRACKEDNODE ID, HOBJECT hModel, HMODELNODE hNode, const LTVector& vOffset )
{
	if(!CheckValidity(ID))
		return false;

	//make sure that the model pointed to is not ourself, this can cause infinite
	//recursion
	assert(hModel != ID->m_hModel);

	//make sure that that is actually a valid model
	uint32 nType;
	if(m_pILTBase->Common()->GetObjectType(hModel, &nType) != LT_OK)
		return false;

	if(nType != OT_MODEL)
		return false;

	//make sure we have a valid node
	if(hNode == INVALID_MODEL_NODE)
		return false;

	//setup this target
	ID->m_eTrackMode	= CTrackedNode::TRACK_NODE;
	ID->m_hTrackObject	= hModel;
	ID->m_hTrackNode	= hNode;
	ID->m_vTrackOffset	= vOffset;

	//success
	return true;
}

bool CSettingNumber::SetValue(double value)
{
  CExclusiveLock lock(m_critical);

  if (value == m_value)
    return true;

  if (!CheckValidity(value))
    return false;

  double oldValue = m_value;
  m_value = value;

  if (!OnSettingChanging(this))
  {
    m_value = oldValue;

    // the setting couldn't be changed because one of the
    // callback handlers failed the OnSettingChanging()
    // callback so we need to let all the callback handlers
    // know that the setting hasn't changed
    OnSettingChanging(this);
    return false;
  }

  m_changed = m_value != m_default;
  OnSettingChanged(this);
  return true;
}

bool CTrackedNodeMgr::IsAtDiscomfort( HTRACKEDNODE ID)
{
	if(!CheckValidity(ID))
		return false;

	return ID->m_bInDiscomfort;
}

bool CTrackedNodeMgr::IsTracking( HTRACKEDNODE ID )
{
	if(!CheckValidity(ID))
		return false;

	return ID->m_bEnabled;
}

bool CTrackedNodeMgr::IsAtLimit( HTRACKEDNODE ID )
{
	if(!CheckValidity(ID))
		return false;

	return ID->m_bAtMaxThreshold;
}

//m_month setter w/ error checking
void cDate::SetMonth(uint8_t month)
{
	if (month <= 12 && month != 0)
	{
		m_month = month;
		CheckValidity();
	}
}

bool CSettingInt::CheckValidity(const std::string &value) const
{
  int iValue;
  if (!fromString(value, iValue))
    return false;

  return CheckValidity(iValue);
}

bool CTrackedNodeMgr::SetOrientOnAnim( HTRACKEDNODE ID, bool bTrackOnAnim )
{
	if(!CheckValidity(ID))
		return false;

	//just set the flag on the node
	ID->m_bOrientFromAnim = bTrackOnAnim;
	return true;
}

bool CTrackedNodeMgr::SetIgnoreParentAnimation( HTRACKEDNODE ID, bool bIgnoreParentAnimation )
{
	if(!CheckValidity(ID))
		return false;

	//just set the flag on the node
	ID->m_bIgnoreParentAnimation = bIgnoreParentAnimation;
	return true;
}

nsresult
nsIConstraintValidation::CheckValidity(bool* aValidity)
{
  NS_ENSURE_ARG_POINTER(aValidity);

  *aValidity = CheckValidity();

  return NS_OK;
}

bool CTrackedNodeMgr::SetAutoDisable( HTRACKEDNODE ID, bool bAutoDisable )
{
	if(!CheckValidity(ID))
		return false;

	//just set the flag on the node
	ID->m_bAutoDisable = bAutoDisable;
	return true;
}

bool CTrackedNodeMgr::SetTargetObject( HTRACKEDNODE ID, const LTVector& vPosition )
{
	if(!CheckValidity(ID))
		return false;

	//setup this target
	ID->m_eTrackMode	= CTrackedNode::TRACK_OBJSPACEPOS;
	ID->m_vTrackOffset	= vPosition;

	return true;
}

Trajectory PlanningProblem::RRT_APF_Solve(const ObstacleSet &ob_set,
                                           Trajectory &prior_plan,
                                           bool stop_when_collid)
{
    Trajectory *temp_trajec = new Trajectory();
    temp_trajec->appendState(initialState);

    for(int step = 1; step <= MAX_APF_STEP_TRY; step++) {
        // check reaching the goal state
        Station current_station = temp_trajec->getLastStation();
        if( (goal.minDistTo(current_station) < agent->radius() * 1) )
        {
            temp_trajec->appendState(goal.goal_point);
            planningResult = true;
            break;
        }

        Vector2D total_force;
        if( !pathHasCollision(current_station, goal.goal_point, ob_set) ) {
//            temp_trajec->appendState(goal.goal_point);
//            planningResult = true;
//            break;
            total_force += GoalAttractiveForce(current_station);
        }

//        else
        {
            Station next_goal = getNextStation(current_station, prior_plan);
            total_force += PathDirectedForce(current_station, prior_plan);
            vector<Vector2D> ob_forces = ObstacleForces(current_station, ob_set);
            Vector2D ob_total_force;
            for(uint i=0; i<ob_forces.size(); i++)  {
                ob_total_force += ob_forces[i];
            }
            if(!pathHasCollision(current_station, next_goal, ob_set)) {
                ob_total_force *= 0.2;
            }
            total_force += ob_total_force;
        }

        Station new_station;
        new_station = agent->step(current_station,
                                  (total_force.normalized()).to3D(),
                                  0.080 /*sec*/);
        temp_trajec->appendState(new_station);
        if(stop_when_collid) {
            if( !CheckValidity(new_station) ) {
                planningResult = false;
                break;
            }
        }
    }
    return *temp_trajec;
}