arena_ai.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2016 SuperTuxKart-Team
//
//  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_ARENA_AI_HPP
#define HEADER_ARENA_AI_HPP
 
#include "karts/controller/ai_base_controller.hpp"
#include "race/race_manager.hpp"
 
#undef AI_DEBUG
#ifdef AI_DEBUG
#include "graphics/irr_driver.hpp"
#endif
 
class ArenaGraph;
class ItemManager;
 
namespace irr
{
    namespace scene { class ISceneNode; }
}
 
class ArenaAI : public AIBaseController
{
protected:
    ItemManager* m_item_manager;
 
    ArenaGraph* m_graph;
 
    AbstractKart *m_closest_kart;
 
    int m_closest_kart_node;
 
    Vec3 m_closest_kart_point;
 
    RaceManager::Difficulty m_cur_difficulty;
 
    irr::scene::ISceneNode *m_debug_sphere;
 
    irr::scene::ISceneNode *m_debug_sphere_next;
 
    int m_target_node;
 
    Vec3 m_target_point;
 
    bool m_mini_skid;
 
    // ------------------------------------------------------------------------
    void          tryCollectItem(Vec3* aim_point, int* target_node) const;
    // ------------------------------------------------------------------------
    virtual void  findClosestKart(bool consider_difficulty, bool find_sta) = 0;
 
private:
    Vec3 m_target_point_lc;
 
    Vec3 m_reverse_point;
 
    bool m_is_stuck;
 
    bool m_is_uturn;
 
    std::set<int> m_on_node;
 
    float m_time_since_last_shot;
 
    float m_ticks_since_reversing;
 
    float m_time_since_driving;
 
    float m_time_since_uturn;
 
    int m_ticks_since_off_road;
 
    float m_turn_radius;
 
    float m_steering_angle;
 
    Vec3 m_current_forward_point;
 
    int m_current_forward_node;
 
    void          configSpeed();
    // ------------------------------------------------------------------------
    void          configSteering();
    // ------------------------------------------------------------------------
    void          checkIfStuck(const float dt);
    // ------------------------------------------------------------------------
    void          determinePath(int forward, std::vector<int>* path);
    // ------------------------------------------------------------------------
    void          doSkiddingTest();
    // ------------------------------------------------------------------------
    void          doUTurn(const float dt);
    // ------------------------------------------------------------------------
    bool          gettingUnstuck(int ticks);
    // ------------------------------------------------------------------------
    bool          updateAimingPosition(Vec3* target_point);
    // ------------------------------------------------------------------------
    void          useItems(const float dt);
    // ------------------------------------------------------------------------
    virtual bool  canSkid(float steer_fraction) OVERRIDE
                                                        { return m_mini_skid; }
    // ------------------------------------------------------------------------
    virtual void  findTarget() = 0;
    // ------------------------------------------------------------------------
    virtual bool  forceBraking()                              { return false; }
    // ------------------------------------------------------------------------
    virtual int   getCurrentNode() const = 0;
    // ------------------------------------------------------------------------
    virtual float getKartDistance(const AbstractKart* kart) const = 0;
    // ------------------------------------------------------------------------
    virtual bool  ignorePathFinding()                         { return false; }
    // ------------------------------------------------------------------------
    virtual bool  isWaiting() const = 0;
    // ------------------------------------------------------------------------
    virtual bool  isKartOnRoad() const = 0;
    // ------------------------------------------------------------------------
    virtual void  resetAfterStop() {}
 
public:
                 ArenaAI(AbstractKart *kart);
    // ------------------------------------------------------------------------
    virtual     ~ArenaAI() {}
    // ------------------------------------------------------------------------
    virtual void update(int ticks) OVERRIDE;
    // ------------------------------------------------------------------------
    virtual void reset() OVERRIDE;
    // ------------------------------------------------------------------------
    virtual void newLap(int lap) OVERRIDE {}
 
};
 
#endif