item.hpp

//  SuperTuxKart - a fun racing game with go-kart
//
//  Copyright (C) 2004-2015 Steve Baker <sjbaker1@airmail.net>
//  Copyright (C) 2006-2015 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_ITEM_HPP
#define HEADER_ITEM_HPP

#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include "utils/log.hpp"
#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"

#include <line3d.h>

class BareNetworkString;
class AbstractKart;
class LODNode;

namespace irr
{
    namespace scene { class IMesh; class ISceneNode; }
}
using namespace irr;

// ============================================================================
class ItemState
{
    LEAK_CHECK();
public:
    enum ItemType
    {
        ITEM_FIRST,
        ITEM_BONUS_BOX = ITEM_FIRST,
        ITEM_BANANA,
        ITEM_NITRO_BIG,
        ITEM_NITRO_SMALL,
        ITEM_BUBBLEGUM,
        ITEM_BUBBLEGUM_NOLOK,

        ITEM_EASTER_EGG,
        ITEM_LAST = ITEM_EASTER_EGG,
        ITEM_COUNT,
        ITEM_NONE
    };

private:
    ItemType m_type;

    ItemType m_original_type;

    int m_ticks_till_return;

    int  m_item_id;

    int m_deactive_ticks;

    int m_used_up_counter;

    Vec3 m_xyz;

    btQuaternion m_original_rotation;

    const AbstractKart *m_previous_owner;

protected:

    friend class ItemManager;
    friend class NetworkItemManager;
    // ------------------------------------------------------------------------
    virtual void setType(ItemType type) { m_type = type; }
    // ------------------------------------------------------------------------
    // Some convenient functions for the AI only
    friend class SkiddingAI;
    friend class TestAI;
    bool hitLine(const core::line3df &line,
                 const AbstractKart *kart = NULL) const
    {
        if (getPreviousOwner() == kart && getDeactivatedTicks() > 0)
            return false;

        Vec3 closest = line.getClosestPoint(getXYZ().toIrrVector());
        return hitKart(closest, kart);
    }   // hitLine

public:
    // ------------------------------------------------------------------------
         ItemState(ItemType type, const AbstractKart *owner=NULL, int id = -1);
    // ------------------------------------------------------------------------
         ItemState(const BareNetworkString& buffer);
    // ------------------------------------------------------------------------
    void initItem(ItemType type, const Vec3& xyz, const Vec3& normal);
    void update(int ticks);
    void setDisappearCounter();
    virtual void collected(const AbstractKart *kart);
    // ------------------------------------------------------------------------
    virtual ~ItemState() {}
         
    // -----------------------------------------------------------------------
    virtual void updateGraphics(float dt)
    {
        Log::fatal("ItemState", "updateGraphics() called for ItemState.");
    }   // updateGraphics

    // -----------------------------------------------------------------------
    virtual bool hitKart(const Vec3 &xyz,
                         const AbstractKart *kart = NULL) const
    {
        Log::fatal("ItemState", "hitKart() called for ItemState.");
        return false;
    }   // hitKart

    // -----------------------------------------------------------------------
    virtual int getGraphNode() const 
    {
        Log::fatal("ItemState", "getGraphNode() called for ItemState.");
        return 0;
    }   // getGraphNode

    // -----------------------------------------------------------------------
    virtual const Vec3 *getAvoidancePoint(bool left) const
    {
        Log::fatal("ItemState", "getAvoidancePoint() called for ItemState.");
        // Return doesn't matter, fatal aborts
        return &m_xyz;
    }   // getAvoidancePoint

    // -----------------------------------------------------------------------
    virtual float getDistanceFromCenter() const
    {
        Log::fatal("itemState",
                   "getDistanceFromCentre() called for ItemState.");
        return 0;
    }   // getDistanceFromCentre

    // -----------------------------------------------------------------------
    virtual void reset()
    {
        m_deactive_ticks    = 0;
        m_ticks_till_return = 0;
        setDisappearCounter();
        // If the item was switched:
        if (m_original_type != ITEM_NONE)
        {
            setType(m_original_type);
            m_original_type = ITEM_NONE;
        }
    }   // reset

    // -----------------------------------------------------------------------
    virtual void switchTo(ItemType type)
    {
        // triggers and easter eggs should not be switched
        if (m_type == ITEM_EASTER_EGG) return;
        m_original_type = m_type;
        setType(type);
        return;
    }   // switchTo

    // ------------------------------------------------------------------------
    virtual bool switchBack()
    {
        // If the item is not switched, do nothing. This can happen if a bubble
        // gum is dropped while items are switched - when switching back, this
        // bubble gum has no original type.
        if (m_original_type == ITEM_NONE)
            return true;
        setType(m_original_type);
        m_original_type = ITEM_NONE;
        return false;
    }   // switchBack

    // ------------------------------------------------------------------------
    bool isNegativeItem() const
    {
        return m_type == ITEM_BANANA || m_type == ITEM_BUBBLEGUM ||
               m_type == ITEM_BUBBLEGUM_NOLOK;
    }
    // ------------------------------------------------------------------------
    void setTicksTillReturn(int t) { m_ticks_till_return = t; }
    // ------------------------------------------------------------------------
    int getTicksTillReturn() const { return m_ticks_till_return; }
    // ------------------------------------------------------------------------
    bool isAvailable() const { return m_ticks_till_return <= 0; }
    // ------------------------------------------------------------------------
    ItemType getType() const { return m_type; }
    // ------------------------------------------------------------------------
    ItemType getGrahpicalType() const;
    // ------------------------------------------------------------------------
    ItemType getOriginalType() const { return m_original_type; }
    // ------------------------------------------------------------------------
    void setItemId(unsigned int n) { m_item_id = n; }
    // ------------------------------------------------------------------------
    unsigned int getItemId() const { return m_item_id; }
    // ------------------------------------------------------------------------
    bool isUsedUp() const { return m_used_up_counter == 0; }
    // ------------------------------------------------------------------------
    bool canBeUsedUp()  const { return m_used_up_counter>-1; }
    // ------------------------------------------------------------------------
    int getDeactivatedTicks() const { return m_deactive_ticks; }
    // ------------------------------------------------------------------------
    void setDeactivatedTicks(int ticks) { m_deactive_ticks = ticks; }
    // ------------------------------------------------------------------------
    const AbstractKart *getPreviousOwner() const { return m_previous_owner; }
    // ------------------------------------------------------------------------
    void setXYZ(const Vec3& xyz) { m_xyz = xyz; }
    // ------------------------------------------------------------------------
    const Vec3& getXYZ() const { return m_xyz; }
    // ------------------------------------------------------------------------
    const Vec3 getNormal() const
    {
        return quatRotate(m_original_rotation, Vec3(0.0f, 1.0f, 0.0f));
    }
    // ------------------------------------------------------------------------
    const btQuaternion& getOriginalRotation() const
    {
        return m_original_rotation;
    }
    // ------------------------------------------------------------------------
    void saveCompleteState(BareNetworkString* buffer) const;
};   // class ItemState

// ============================================================================
class Item : public ItemState, public NoCopy
{

private:
    LODNode *m_node;

    ItemType m_graphical_type;

    std::vector<scene::ISceneNode*> m_spark_nodes;

    scene::ISceneNode* m_icon_node;

    bool m_was_available_previously;

    float m_distance_2;

    int m_graph_node;

    float m_distance_from_center;

    int m_animation_start_ticks;

    Vec3 *m_avoidance_points[2];

    void          initItem(ItemType type, const Vec3 &xyz, const Vec3 &normal);
    void          setMesh(scene::IMesh* mesh, scene::IMesh* lowres_mesh);
    void          handleNewMesh(ItemType type);

public:
                  Item(ItemType type, const Vec3& xyz, const Vec3& normal,
                       scene::IMesh* mesh, scene::IMesh* lowres_mesh,
                       const std::string& icon, const AbstractKart *owner);
    virtual       ~Item ();
    virtual void  updateGraphics(float dt) OVERRIDE;
    virtual void  reset() OVERRIDE;

    //-------------------------------------------------------------------------
    virtual void collected(const AbstractKart *kart)  OVERRIDE
    {
        ItemState::collected(kart);
    }   // isCollected
    //-------------------------------------------------------------------------
    virtual bool switchBack() OVERRIDE
    {
        if (ItemState::switchBack())
            return true;
        return false;
    }   // switchBack
    // ------------------------------------------------------------------------
    virtual bool hitKart(const Vec3 &xyz, const AbstractKart *kart=NULL) const
        OVERRIDE
    {
        if (getPreviousOwner() == kart && getDeactivatedTicks() > 0)
            return false;
        Vec3 lc = quatRotate(getOriginalRotation(), xyz - getXYZ());
        // Don't be too strict if the kart is a bit above the item
        lc.setY(lc.getY() / 2.0f);
        return lc.length2() < m_distance_2;
    }   // hitKart
    // ------------------------------------------------------------------------
    bool rotating() const               { return getType() != ITEM_BUBBLEGUM; }

public:
    // ------------------------------------------------------------------------
    virtual int getGraphNode() const OVERRIDE { return m_graph_node; }
    // ------------------------------------------------------------------------
    virtual float getDistanceFromCenter() const OVERRIDE
    {
        return m_distance_from_center;
    }   // getDistanceFromCenter
    // ------------------------------------------------------------------------
    virtual const Vec3 *getAvoidancePoint(bool left) const OVERRIDE
    {
        if(left) return m_avoidance_points[0];
        return m_avoidance_points[1];
    }   // getAvoidancePoint
    // ------------------------------------------------------------------------
    scene::ISceneNode *getSceneNode()
    {
        return (scene::ISceneNode *) m_node;
    }
};   // class Item

#endif