skidding_ai.hpp

 
//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2004-2015  Steve Baker <sjbaker1@airmail.net>
//  Copyright (C) 2006-2015  Eduardo Hernandez Munoz
//  Copyright (C) 2010-2015  Joerg Henrichs
//
//  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 3
//  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.
 
#ifndef HEADER_SKIDDING_AI_HPP
#define HEADER_SKIDDING_AI_HPP
 
// Some debugging features for the AI. For example you can visualise the
// point the AI is aiming at, or visualise the curve the AI is predicting.
// It works best with just 1 AI kart, so set the number of karts
// to 2 in main.cpp with quickstart and run supertuxkart with the arg -N.
// Or use --profile-laps=99 and run just one AI. Using the debug camera
// (top view) is useful, too
 
#ifdef DEBUG
   // Enable AI graphical debugging
#  undef AI_DEBUG
   // Shows left and right lines when using new findNonCrashing function
#  undef AI_DEBUG_NEW_FIND_NON_CRASHING
   // Show the predicted turn circles
#  undef AI_DEBUG_CIRCLES
   // Show the heading of the kart
#  undef AI_DEBUG_KART_HEADING
   // Shows line from kart to its aim point
#  undef AI_DEBUG_KART_AIM
#endif
 
 
#include "karts/controller/ai_base_lap_controller.hpp"
#include "race/race_manager.hpp"
#include "tracks/drive_node.hpp"
#include "utils/random_generator.hpp"
 
#include <line3d.h>
 
class ItemManager;
class ItemState;
class LinearWorld;
class Track;
 
namespace irr
{
    namespace scene
    {
        class ISceneNode;
    }
}
 
class SkiddingAI : public AIBaseLapController
{
private:
 
    class CrashTypes
    {
        public:
 
        bool m_road; //true if we are going to 'crash' with the bounds of the road
        int m_kart; //-1 if no crash, pos numbers are the kart it crashes with
        CrashTypes() : m_road(false), m_kart(-1) {};
        void clear() {m_road = false; m_kart = -1;}
    } m_crashes;
 
    RaceManager::AISuperPower m_superpower;
 
    /*General purpose variables*/
 
    AbstractKart *m_kart_ahead;
 
    float m_distance_ahead;
 
    AbstractKart *m_kart_behind;
 
    float m_distance_behind;
 
    float m_distance_leader;
 
 
    int m_start_delay;
 
    float m_time_since_last_shot;
 
    float m_time_since_stuck;
 
    int m_start_kart_crash_direction;
 
    DriveNode::DirectionType m_current_track_direction;
 
    float m_current_curve_radius;
 
    Vec3  m_curve_center;
 
    unsigned int m_last_direction_node;
 
    const ItemState *m_item_to_collect;
 
    bool m_avoid_item_close;
 
    float m_distance_to_player;
 
    int m_num_players_ahead;
 
    bool m_burster;
 
    RandomGenerator m_random_skid;
 
    enum {SKID_PROBAB_NOT_YET, SKID_PROBAB_NO_SKID, SKID_PROBAB_SKID}
          m_skid_probability_state;
 
    enum SkillType {ITEM_SKILL, NITRO_SKILL};
 
    const ItemState *m_last_item_random;
 
    bool m_really_collect_item;
 
    RandomGenerator m_random_collect_item;
 
    enum {PSA_DEFAULT, PSA_NEW}
          m_point_selection_algorithm;
 
    ItemManager* m_item_manager;
#ifdef AI_DEBUG
    ShowCurve **m_curve;
 
    irr::scene::ISceneNode *m_debug_sphere[4];
 
    irr::scene::ISceneNode *m_item_sphere;
#endif
 
 
    /*Functions called directly from update(). They all represent an action
     *that can be done, and end up setting their respective m_controls
     *variable, except handle_race_start() that isn't associated with any
     *specific action (more like, associated with inaction).
     */
    void  handleRaceStart();
    void  handleAccelerationAndBraking(int ticks);
    void  handleSteering(float dt);
    int   computeSkill(SkillType type);
    void  handleItems(const float dt, const Vec3 *aim_point,
                                int last_node, int item_skill);
    void  handleBubblegum(int item_skill,
                          const std::vector<const ItemState *> &items_to_collect,
                          const std::vector<const ItemState *> &items_to_avoid);
    void  handleCake(int item_skill);
    void  handleBowling(int item_skill);
    void  handleSwatter(int item_skill);
    void  handleSwitch(int item_skill,
                       const std::vector<const ItemState *> &items_to_collect,
                       const std::vector<const ItemState *> &items_to_avoid);
    void  handleRescue(const float dt);
    void  handleBraking(float max_turn_speed, float min_speed);
    void  handleNitroAndZipper(float max_safe_speed);
    void  computeNearestKarts();
    void  handleItemCollectionAndAvoidance(Vec3 *aim_point,
                                           int last_node);
    bool  handleSelectedItem(Vec3 kart_aim_direction, Vec3 *aim_point);
    bool  steerToAvoid(const std::vector<const ItemState *> &items_to_avoid,
                       const core::line3df &line_to_target,
                       Vec3 *aim_point);
    bool  hitBadItemWhenAimAt(const ItemState *item,
                              const std::vector<const ItemState *> &items_to_avoid);
    void  evaluateItems(const ItemState *item, Vec3 kart_aim_direction,
                        std::vector<const ItemState *> *items_to_avoid,
                        std::vector<const ItemState *> *items_to_collect);
 
    void  checkCrashes(const Vec3& pos);
    void  findNonCrashingPointNew(Vec3 *result, int *last_node);
    void  findNonCrashingPoint(Vec3 *result, int *last_node);
 
    void  determineTrackDirection();
    virtual bool canSkid(float steer_fraction);
    virtual void setSteering(float angle, float dt);
    void handleCurve();
 
protected:
    virtual unsigned int getNextSector(unsigned int index);
 
public:
                 SkiddingAI(AbstractKart *kart);
                ~SkiddingAI();
    virtual void update      (int ticks);
    virtual void reset       ();
    virtual const irr::core::stringw& getNamePostfix() const;
};
 
#endif
 
/* EOF */