flyable.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2007-2015 Joerg Henrichs
//
//  Linear item-kart intersection function written by
//  Copyright (C) 2009-2015 David Mikos.
//
//  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_FLYABLE_HPP
#define HEADER_FLYABLE_HPP
 
#include "items/powerup_manager.hpp"
#include "karts/moveable.hpp"
#include "network/rewinder.hpp"
#include "tracks/terrain_info.hpp"
#include "utils/cpp2011.hpp"
 
#include <irrString.h>
namespace irr
{
    namespace scene { class IMesh; }
}
using namespace irr;
 
class AbstractKart;
class AbstractKartAnimation;
class HitEffect;
class PhysicalObject;
class SFXBase;
class XMLNode;
 
class Flyable : public Moveable, public TerrainInfo,
                public Rewinder
{
private:
    bool              m_has_hit_something;
 
    bool              m_adjust_up_velocity;
 
    Vec3              m_position_offset;
 
    bool              m_do_terrain_info;
 
    /* Used in network to restore previous gravity in compressed form. */
    uint32_t          m_compressed_gravity_vector;
 
    AbstractKartAnimation *m_animation;
 
protected:
    AbstractKart*     m_owner;
 
    PowerupManager::PowerupType
                      m_type;
 
    btCollisionShape *m_shape;
 
    float             m_max_height;
 
    float             m_min_height;
 
    float             m_average_height;
 
    float             m_force_updown;
 
    float             m_speed;
 
    const float       m_mass;
 
    Vec3              m_extend;
 
    uint16_t          m_ticks_since_thrown;
 
    /* True if this flyable exists in server, and will trigger a rewind.
     * For each local state it will reset it to false and call moveToInfinity,
     * and for each restoreState it will set it to true. Also when re-fire the
     * flyable during rewind it will set to true too. */
    bool              m_has_server_state;
 
    bool              m_owner_has_temporary_immunity;
 
    /* Set to true once when onDeleteFlyable, this is used to create HitEffect
     * only once. */
    bool              m_deleted_once;
 
    /* Save the locally detected deleted ticks, if the confirmed state world
     * ticks in computeError > this, the flyable can be deleted in client. */
    int               m_last_deleted_ticks;
 
    // The flyable class stores the values for each flyable type, e.g.
    // speed, min_height, max_height. These variables must be static,
    // so we need arrays of these variables to have different values
    // for bowling balls, missiles, ...
 
    static float      m_st_speed[PowerupManager::POWERUP_MAX];
 
    static scene::IMesh *m_st_model[PowerupManager::POWERUP_MAX];
 
    static float      m_st_min_height[PowerupManager::POWERUP_MAX];
 
    static float      m_st_max_height[PowerupManager::POWERUP_MAX];
 
    static float      m_st_force_updown[PowerupManager::POWERUP_MAX];
 
    static Vec3       m_st_extend[PowerupManager::POWERUP_MAX];
 
    int               m_max_lifespan;
 
    /* For debugging purpose */
    int               m_created_ticks;
 
    void              getClosestKart(const AbstractKart **minKart,
                                     float *minDistSquared,
                                     Vec3 *minDelta,
                                     const AbstractKart* inFrontOf=NULL,
                                     const bool backwards=false) const;
 
    void getLinearKartItemIntersection(const Vec3 &origin,
                                       const AbstractKart *target_kart,
                                       float item_XY_velocity, float gravity,
                                       float forw_offset,
                                       float *fire_angle, float *up_velocity);
 
 
    void              createPhysics(float y_offset,
                                    const Vec3 &velocity,
                                    btCollisionShape *shape,
                                    float restitution,
                                    const btVector3& gravity=btVector3(0.0f,0.0f,0.0f),
                                    const bool rotates=false,
                                    const bool turn_around=false,
                                    const btTransform* customDirection=NULL);
 
    void              moveToInfinity(bool set_moveable_trans = true);
    void              removePhysics();
    void              fixSFXSplitscreen(SFXBase* sfx);
public:
 
                 Flyable     (AbstractKart* kart,
                              PowerupManager::PowerupType type,
                              float mass=1.0f);
    virtual     ~Flyable     ();
    static void  init        (const XMLNode &node, scene::IMesh *model,
                              PowerupManager::PowerupType type);
    void                      updateGraphics(float dt) OVERRIDE;
    virtual bool              updateAndDelete(int ticks);
    virtual void              setAnimation(AbstractKartAnimation *animation);
    virtual HitEffect*        getHitEffect() const;
    bool                      isOwnerImmunity(const AbstractKart *kart_hit) const;
    virtual bool              hit(AbstractKart* kart, PhysicalObject* obj=NULL);
    void                      explode(AbstractKart* kart, PhysicalObject* obj=NULL,
                                      bool secondary_hits=true);
    unsigned int              getOwnerId();
    // ------------------------------------------------------------------------
    bool hasAnimation() const { return m_animation != NULL;  }
    // ------------------------------------------------------------------------
    void         setAdjustUpVelocity(bool f) { m_adjust_up_velocity = f; }
    // ------------------------------------------------------------------------
    void         setPositionOffset(const Vec3 &o) {m_position_offset = o; }
    // ------------------------------------------------------------------------
    virtual void hitTrack    () {};
    // ------------------------------------------------------------------------
    bool         hasHit      () { return m_has_hit_something; }
    // ------------------------------------------------------------------------
    void         setHasHit   () { m_has_hit_something = true; }
    // ------------------------------------------------------------------------
    void         reset() OVERRIDE { Moveable::reset();          }
    // ------------------------------------------------------------------------
    PowerupManager::PowerupType getType() const {return m_type;}
 
    // ------------------------------------------------------------------------
    AbstractKart *getOwner() const { return m_owner;}  
    // ------------------------------------------------------------------------
    void setDoTerrainInfo(bool d) { m_do_terrain_info = d; }
    // ------------------------------------------------------------------------
    const Vec3 &getExtend() const { return m_extend;  }
    // ------------------------------------------------------------------------
    void addForRewind(const std::string& uid);
    // ------------------------------------------------------------------------
    virtual void undoEvent(BareNetworkString *buffer) OVERRIDE {}
    // ------------------------------------------------------------------------
    virtual void rewindToEvent(BareNetworkString *buffer) OVERRIDE {}
    // ------------------------------------------------------------------------
    virtual void undoState(BareNetworkString *buffer) OVERRIDE {}
    // ------------------------------------------------------------------------
    virtual void saveTransform() OVERRIDE;
    // ------------------------------------------------------------------------
    virtual void computeError() OVERRIDE;
    // ------------------------------------------------------------------------
    virtual BareNetworkString* saveState(std::vector<std::string>* ru)
        OVERRIDE;
    // ------------------------------------------------------------------------
    virtual void restoreState(BareNetworkString *buffer, int count) OVERRIDE;
    // ------------------------------------------------------------------------
    /* Return true if still in game state, or otherwise can be deleted. */
    bool hasServerState() const                  { return m_has_server_state; }
    // ------------------------------------------------------------------------
    virtual void onFireFlyable();
    // ------------------------------------------------------------------------
    virtual void onDeleteFlyable();
    // ------------------------------------------------------------------------
    void setCreatedTicks(int ticks)                { m_created_ticks = ticks; }
};   // Flyable
 
#endif