}

BOOL cCharacterController::SetAction(sCharacter *Character,   \
                                     long Action,             \
                                     long AddTime)
{
  long MeshNum;

  // Error checking
  if(Character == NULL)
    return FALSE;

  // Make sure attack, spell, and item has supporting charge
  if(Action == CHAR_ATTACK || Action == CHAR_SPELL ||
     Action == CHAR_ITEM) {
    if(Character->Charge < 100.0f)
      return FALSE;
  }

  // Set action
  Character->Action = Action;

  // Play sound effect
  ActionSound(Character);

  // Get mesh number
  MeshNum = Character->Def.MeshNum;

  // Set action time (or set to 1 is addtime = -1)
  if(AddTime == -1)
    Character->ActionTimer = 1;
  else
    Character->ActionTimer = AddTime +                        \
                m_Meshes[MeshNum].Animation.GetLength(        \
                m_Animations[Action].Name) * 30;

  return TRUE;
}

BOOL cCharacterController::SetDistance(                       \
               long IDNum, float Distance)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->Distance = Distance;
  return TRUE;
}

float cCharacterController::GetDistance(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return 0.0f;
  return CharPtr->Distance;
}

BOOL cCharacterController::SetRoute(long IDNum,               \
                                    long NumPoints,           \
                                    sRoutePoint *Route)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Free old route
  delete [] CharPtr->Route;
  CharPtr->Route = NULL;

  // Set new route
  if((CharPtr->NumPoints = NumPoints) != NULL) {
    CharPtr->Route = new sRoutePoint[NumPoints];
    memcpy(CharPtr->Route,Route,NumPoints*sizeof(sRoutePoint));
    CharPtr->CurrentPoint = 0;
  }

  return TRUE;
}

BOOL cCharacterController::SetScript(long IDNum,              \
                                     char *ScriptFilename)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new script
  strcpy(CharPtr->ScriptFilename, ScriptFilename);
  return TRUE;
}

char *cCharacterController::GetScript(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return NULL;
  return CharPtr->ScriptFilename;
}

BOOL cCharacterController::SetEnable(long IDNum, BOOL Enabled)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->Enabled = Enabled;
  return TRUE;
}

BOOL cCharacterController::GetEnable(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;
  return CharPtr->Enabled;
}

BOOL cCharacterController::SetMessage(sCharacter *Character,  \
                                   char *Text, long Timer,    \
                                   D3DCOLOR Color)
{
  strcpy(Character->Message, Text);
  Character->MessageTimer = Timer;
  Character->MessageColor = Color;

  return TRUE;
}

BOOL cCharacterController::Move(                              \
               long IDNum,                                    \
               float XPos, float YPos, float ZPos)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new values
  CharPtr->XPos = XPos;
  CharPtr->YPos = YPos;
  CharPtr->ZPos = ZPos;
  return TRUE;
}

BOOL cCharacterController::GetPosition(                       \
               long IDNum,                                    \
               float *XPos, float *YPos, float *ZPos)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  if(XPos != NULL)
    *XPos = CharPtr->XPos;
  if(YPos != NULL)
    *YPos = CharPtr->YPos;
  if(ZPos != NULL)
    *ZPos = CharPtr->ZPos;

  return TRUE;
}

BOOL cCharacterController::SetBounds(                         \
               long IDNum,                                    \
               float MinX, float MinY, float MinZ,            \
               float MaxX, float MaxY, float MaxZ)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new values
  CharPtr->MinX = min(MinX, MaxX);
  CharPtr->MinY = min(MinY, MaxY);
  CharPtr->MinZ = min(MinZ, MaxZ);
  CharPtr->MaxX = max(MinX, MaxX);
  CharPtr->MaxY = max(MinY, MaxY);
  CharPtr->MaxZ = max(MinZ, MaxZ);

  return TRUE;
}   

BOOL cCharacterController::GetBounds(                         \
               long IDNum,                                    \
               float *MinX, float *MinY, float *MinZ,         \
               float *MaxX, float *MaxY, float *MaxZ)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  if(MinX != NULL)
    *MinX = CharPtr->MinX;
  if(MinY != NULL)
    *MinY = CharPtr->MinY;
  if(MinZ != NULL)
    *MinZ = CharPtr->MinZ;
  if(MaxX != NULL)
    *MaxX = CharPtr->MaxX;
  if(MaxY != NULL)
    *MaxY = CharPtr->MaxY;
  if(MaxZ != NULL)
    *MaxZ = CharPtr->MaxZ;

  return TRUE;
}

BOOL cCharacterController::SetType(long IDNum, long Type)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->Type = Type;
  return TRUE;
}

long cCharacterController::GetType(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return 0;
  return CharPtr->Type;
}

BOOL cCharacterController::SetAI(long IDNum, long Type)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->AI = Type;
  return TRUE;
}

long cCharacterController::GetAI(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return 0;
  return CharPtr->AI;
}

BOOL cCharacterController::SetTargetCharacter(long IDNum,     \
                                              long TargetNum)
{
  sCharacter *CharPtr, *CharTarget;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Clear if TargetNum == -1
  if(TargetNum == -1)
    CharPtr->TargetChar = NULL;
  else {
    // Scan through list and target 1st TargetNum found
    CharTarget = m_CharacterParent;
    while(CharTarget != NULL) {
      if(CharTarget->ID == TargetNum) {
        CharPtr->TargetChar = CharTarget;
        break;
      }
      CharTarget = CharTarget->Next;
    }

    // Clear target if not found in list
    if(CharTarget == NULL)
      CharPtr->TargetChar = NULL;
  }
  return TRUE;
}

BOOL cCharacterController::CharUpdate(                        \
               sCharacter *Character, long Elapsed,           \
               float *XMove, float *YMove, float *ZMove)
{
  float MoveX, MoveY, MoveZ, Speed;
  float XDiff, YDiff, ZDiff, Dist, Radius;
  float y1, y2;
  long  i, SpellNum;
  BOOL SpellCast;
  sCharacter *CharPtr;

  // Error checking
  if(Character == NULL)
    return FALSE;

  // Clear movements and action
  MoveX = MoveY = MoveZ = 0.0f;

  // Calculate movement speed
  Speed = (float)Elapsed / 1000.0f * GetSpeed(Character);

  // Move character based on their type
  switch(Character->AI) {
    case CHAR_STAND:
      break;
      
    case CHAR_WANDER:
      // Calculate new distance and direction if needed
      Character->Distance -= Elapsed;

      if(Character->Distance <= 0.0f) {

        // Calculate a new distance to travel
        Character->Distance = (float)(rand() % 2000) + 2000.0f;

        // Calculate a new direction
        Character->Direction = (float)(rand()%360)*0.01744444f;
      }

      // Process walk or stand still
      if(Character->Distance > 1000.0f) {
        MoveX = (float)sin(Character->Direction) * Speed;
        MoveZ = (float)cos(Character->Direction) * Speed;
        Character->Action = CHAR_MOVE;
      } else {
        // Stand still for one second
        Character->Action = CHAR_IDLE;
      }

      break;

    case CHAR_ROUTE:
      // Determine if character has reached point
      XDiff = (float)fabs(Character->XPos -                   \
              Character->Route[Character->CurrentPoint].XPos);
      YDiff = (float)fabs(Character->YPos -                   \
              Character->Route[Character->CurrentPoint].YPos);
      ZDiff = (float)fabs(Character->ZPos -                   \
              Character->Route[Character->CurrentPoint].ZPos);
      Dist = XDiff*XDiff + YDiff*YDiff + ZDiff*ZDiff;

      Radius = GetXZRadius(Character) * 0.25f;
      
      // Go to next point if reached
      if(Dist < (Radius*Radius)) {
        Character->CurrentPoint++;
        if(Character->CurrentPoint >= Character->NumPoints)
          Character->CurrentPoint = 0;

        // Calculate new differences and distance
        XDiff = (float)fabs(Character->XPos -                 \
              Character->Route[Character->CurrentPoint].XPos);
        YDiff = (float)fabs(Character->YPos -                 \
              Character->Route[Character->CurrentPoint].YPos);
        ZDiff = (float)fabs(Character->ZPos -                 \
              Character->Route[Character->CurrentPoint].ZPos);
        Dist = XDiff*XDiff + YDiff*YDiff + ZDiff*ZDiff;
      }

      // Setup movement towards target
      Dist = (float)sqrt(Dist);
      if(Speed > Dist)
        Speed = Dist;

      MoveX=(Character->Route[Character->CurrentPoint].XPos - \
              Character->XPos) / Dist * Speed;
      MoveZ=(Character->Route[Character->CurrentPoint].ZPos - \
              Character->ZPos) / Dist * Speed;

      // Set new direction
      Character->Direction = (float)atan2(MoveX, MoveZ);

      // Set new action
      Character->Action = CHAR_MOVE;

      break;

    case CHAR_FOLLOW:
      if(Character->TargetChar != NULL) {

        // Check distance between characters
        XDiff = (float)fabs(Character->XPos -                 \
                            Character->TargetChar->XPos);
        YDiff = (float)fabs(Character->YPos -                 \
                            Character->TargetChar->YPos);
        ZDiff = (float)fabs(Character->ZPos -                 \
                            Character->TargetChar->ZPos);
        Dist = XDiff*XDiff + YDiff*YDiff + ZDiff*ZDiff;

        // Update if further then distance
        if(Dist > (Character->Distance*Character->Distance)) {

          // Setup movement towards target
          Dist = (float)sqrt(Dist);
          if(Speed > Dist)
            Speed = Dist;
          MoveX = (Character->TargetChar->XPos -              \
                 Character->XPos) / Dist * Speed;
          MoveZ = (Character->TargetChar->ZPos -              \
                 Character->ZPos) / Dist * Speed;

          // Set new direction
          Character->Direction = (float)atan2(MoveX, MoveZ);

          // Set new action
          Character->Action = CHAR_MOVE;
        }
      }

      break;

    case CHAR_EVADE:
      if(Character->TargetChar != NULL) {

        // Check distance between characters
        XDiff = (float)fabs(Character->XPos -                 \
                            Character->TargetChar->XPos);
        YDiff = (float)fabs(Character->YPos -                 \