src/ai/ai_movement_module.cpp

Go to the documentation of this file.

/******************************************************************************
 *  Wormux is a convivial mass murder game.
 *  Copyright (C) 2001-2004 Lawrence Azzoug.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 ******************************************************************************
 * Artificial intelligence Movement module
 *****************************************************************************/

#include <iostream>
#include "../include/action_handler.h"
#include "../character/body.h"
#include "../character/move.h"
#include "../interface/game_msg.h"
#include "../map/map.h"
#include "../team/macro.h"
#include "../team/teams_list.h"
#include "../tool/error.h"
#include "../tool/math_tools.h"
#include "../tool/string_tools.h"

#include "ai_movement_module.h"

// TODO: 
// - Be sure to not go out of the map
// - Fix hole detection
// - Do not go back on the shoot position !


// =================================================
// Go on !
// =================================================
void AIMovementModule::MakeStep()
{
  if(ActiveCharacter().IsImmobile()) {
    if (ActiveCharacter().GetDirection() == Body::DIRECTION_RIGHT) {
      MoveCharacterRight(ActiveCharacter());
    }  else {
      MoveCharacterLeft(ActiveCharacter());
    }
  }
}

// =================================================
// Compute obstacle height (barrier or hole)
// Return true if sure that it does not need to jump
// or to use parachute
// =================================================
bool AIMovementModule::ObstacleHeight(int& height)
{
  if (ComputeHeightMovement(ActiveCharacter(), height, false))
    return true;

  int y_floor=ActiveCharacter().GetY();
  if (height < 0) {

    for (height = -15; height >= -150 ; height--) {
      if ( ActiveCharacter().IsInVacuum( Point2i(ActiveCharacter().GetDirection(), height) ) ) {
        break;
      }
    }

  } else {

    // Compute exact whole size
    for (height = 15; height <= 150 ; height++){
      if ( !ActiveCharacter().IsInVacuum(Point2i(ActiveCharacter().GetDirection(), height))
          ||  ActiveCharacter().FootsOnFloor(y_floor+height)){
        break;
      }
    }

  }
  return false;
}

bool AIMovementModule::RiskGoingOutOfMap()
{
  if ( ActiveCharacter().GetDirection() == Body::DIRECTION_LEFT &&
       ActiveCharacter().GetX() <= 5 ) {
    return true;
  } else if ( ActiveCharacter().GetDirection() == Body::DIRECTION_RIGHT &&
              world.GetWidth() - 5 <= ActiveCharacter().GetX() + ActiveCharacter().GetSize().GetX() ) {
    return true;
  }

  return false;
}

// =================================================
// A jump is made of many movement :
// 1) Decect collision and prepare to go back
// 2) Go back, then when far enought of the obstacle
// 3) Jump!
// 4) Detect when on the ground! 
// =================================================

void AIMovementModule::PrepareJump()
{
  ActiveCharacter().body->StartWalk();
  
  current_movement = BACK_TO_JUMP;
  time_at_last_position = m_current_time;

  InverseDirection();
}

void AIMovementModule::GoBackToJump()
{
  assert(current_movement = BACK_TO_JUMP);

  MakeStep();

  int height;
  bool blocked = !(ObstacleHeight(height));

  if ( abs(last_position.GetX() - ActiveCharacter().GetPosition().GetX()) >= 20
       || time_at_last_position +1 < m_current_time
       || blocked) {
    //it's time to jump!
    InverseDirection();
    Jump();
  }
}

void AIMovementModule::Jump()
{
  //  GameMessages::GetInstance()->Add("try to jump!");
  current_movement = JUMPING;
  ActionHandler::GetInstance()->NewAction (new Action(Action::ACTION_HIGH_JUMP));
}

void AIMovementModule::EndOfJump()
{
  assert(current_movement = JUMPING);

  //GameMessages::GetInstance()->Add("finished to jump");
  
  
  if ( last_position.GetX() == ActiveCharacter().GetPosition().GetX() ) {
    // we have not moved since last movement
    StopMoving();
    
  } else {
    // No more blocked !!
    current_movement = WALKING;
  }  
}


// =================================================
// The walking methods
// Walk() is responsible to detect obstacles
// =================================================

void AIMovementModule::Walk()
{
  // Animate skin
  if ( current_movement != WALKING ) {
    ActiveCharacter().InitMouvementDG(100);
    ActiveCharacter().body->StartWalk();
    current_movement = WALKING;
  }

  MakeStep();

  int height;
  bool blocked = !(ObstacleHeight(height));

  // we are blocked, what next ?
  if ( blocked ) {

    if ( last_blocked_position.GetX() != ActiveCharacter().GetPosition().GetX() ) {
      
      last_blocked_position = ActiveCharacter().GetPosition();
      
      if (height < 0 ) {
        // There's a barrier
        
        if (height >= -80) { // we can try to jump!
          PrepareJump();
          return; // do not update position
        } else { // it's too high!
          //      GameMessages::GetInstance()->Add("It's too high!!");
          InverseDirection();
        }
      } else {
        // There's a hole
        
        if (height >= 100) { // it's too deep, go back!!
          //      GameMessages::GetInstance()->Add("It's too deep!" + ulong2str(height));
          InverseDirection();
        }
      }
    } else {
      // already have been blocked here...
      InverseDirection();
    }
  }

  // Inverse direction if there is a risk to go out of the map
  if (RiskGoingOutOfMap()) {
    InverseDirection();
  }

  // Update position if we are not jumping
  last_position = ActiveCharacter().GetPosition();
  time_at_last_position = m_current_time;
}

void AIMovementModule::StopWalking()
{
  current_movement = NO_MOVEMENT;
  ActiveCharacter().body->StopWalk();
}


// =================================================
// Invert walking direction
// =================================================
void AIMovementModule::InverseDirection()
{
  if (ActiveCharacter().GetDirection() == Body::DIRECTION_RIGHT) {
    ActiveCharacter().SetDirection(Body::DIRECTION_LEFT);
  } else {
    ActiveCharacter().SetDirection(Body::DIRECTION_RIGHT);
  }
}

// =================================================
// Public method updating the movement
// =================================================
void AIMovementModule::Move(uint current_time)
{
  m_current_time = current_time;

  // are we on the ground ?
  if ( ActiveCharacter().FootsInVacuum() ) { // No!
    return;
  }

  switch (current_movement) {

  case NO_MOVEMENT:
    // Begin to walk
    Walk();
    break;

  case WALKING:
    // Continue to walk
    Walk();
    break;

  case BACK_TO_JUMP:
    // Go back to have enough place to jump
    GoBackToJump();
    break;

  case JUMPING:
    EndOfJump();
 
    break;
  default:
    break;
  }
}

void AIMovementModule::StopMoving()
{
  //  GameMessages::GetInstance()->Add("stop moving");
  StopWalking();
  //m_step++;
}

// =================================================
// Initialize Movement module when changing 
// character to control
// =================================================
void AIMovementModule::BeginTurn()
{
  current_movement = NO_MOVEMENT;
  time_at_last_position = 0;
  last_position = Point2i(0,0);
  last_blocked_position = Point2i(0,0);
}

AIMovementModule::AIMovementModule()
{
  std::cout << "o Artificial Intelligence Movement module initialization" << std::endl;
}

---