max_speed.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  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_MAX_SPEED_HPP
#define HEADER_MAX_SPEED_HPP
 
#include "utils/types.hpp"
#include <limits>
 
class AbstractKart;
class BareNetworkString;
 
class MaxSpeed
{
friend class KartRewinder;
public:
    enum  {MS_INCREASE_MIN,
           MS_INCREASE_ZIPPER = MS_INCREASE_MIN,
           MS_INCREASE_SLIPSTREAM,
           MS_INCREASE_NITRO,
           MS_INCREASE_RUBBER,
           MS_INCREASE_SKIDDING,
           MS_INCREASE_RED_SKIDDING,
           MS_INCREASE_MAX};
 
    enum {MS_DECREASE_MIN,
          MS_DECREASE_TERRAIN = MS_DECREASE_MIN,
          MS_DECREASE_AI,
          MS_DECREASE_BUBBLE,
          MS_DECREASE_SQUASH,
          MS_DECREASE_MAX};
 
private:
    AbstractKart *m_kart;
 
    float m_current_max_speed;
 
    float m_add_engine_force;
 
    float m_min_speed;
 
    // ------------------------------------------------------------------------
    class SpeedIncrease
    {
    public:
        uint16_t m_max_add_speed;
        int16_t m_duration;
        int16_t m_fade_out_time;
        float m_current_speedup;
        uint16_t m_engine_force;
        SpeedIncrease()
        {
            reset();
        }   // SpeedIncrease
        // --------------------------------------------------------------------
        void reset()
        {
            m_max_add_speed   = 0;
            m_duration        = std::numeric_limits<int16_t>::min();
            m_fade_out_time   = 0;
            m_current_speedup = 0;
            m_engine_force    = 0;
        }   // reset
        // --------------------------------------------------------------------
        void update(int ticks);
        void saveState(BareNetworkString *buffer) const;
        void rewindTo(BareNetworkString *buffer, bool is_active);
        // --------------------------------------------------------------------
        float getSpeedIncrease() const {return m_current_speedup;}
        // --------------------------------------------------------------------
        int getTimeLeft() const      {return m_duration;       }
        // --------------------------------------------------------------------
        float getEngineForce() const
        {
            return m_duration > 0 ? (float)m_engine_force / 10.0f : 0;
        }   // getEngineForce
        // --------------------------------------------------------------------
        bool isActive() const { return m_duration > -m_fade_out_time; }
    };   // SpeedIncrease
 
    // ------------------------------------------------------------------------
    class SpeedDecrease
    {
    public:
        uint16_t m_max_speed_fraction;
        float m_current_fraction;
 
        int16_t m_fade_in_ticks;
 
        int16_t m_duration;
 
        SpeedDecrease()
        {
            reset();
        }   // SpeedDecrease
        // --------------------------------------------------------------------
        void reset()
        {
            m_max_speed_fraction = 1000;
            m_current_fraction   = 1.0f;
            m_fade_in_ticks      = 0;
            m_duration           = 0;
        }   //reset
        // --------------------------------------------------------------------
        void update(int ticks);
        void saveState(BareNetworkString *buffer) const;
        void rewindTo(BareNetworkString *buffer, bool is_active);
        // --------------------------------------------------------------------
        float getSlowdownFraction() const        { return m_current_fraction; }
        // --------------------------------------------------------------------
        int getTimeLeft() const                          { return m_duration; }
        // --------------------------------------------------------------------
        bool isActive() const    { return m_duration > 0 || m_duration <= -1; }
    };   // SpeedDecrease
 
    // ------------------------------------------------------------------------
    SpeedDecrease  m_speed_decrease[MS_DECREASE_MAX];
 
    SpeedIncrease  m_speed_increase[MS_INCREASE_MAX];
 
 
public:
          MaxSpeed(AbstractKart *kart);
 
    void  increaseMaxSpeed(unsigned int category, float add_speed,
                           float engine_force, int duration,
                           int fade_out_time);
    void  instantSpeedIncrease(unsigned int category,
                               float add_speed, float speed_boost,
                               float engine_force, int duration,
                               int fade_out_time);
    void  setSlowdown(unsigned int category, float max_speed_fraction,
                      int fade_in_time, int duration=-1);
    int   getSpeedIncreaseTicksLeft(unsigned int category);
    int   isSpeedIncreaseActive(unsigned int category);
    int   isSpeedDecreaseActive(unsigned int category);
    void  update(int ticks);
    void  reset();
    void  saveState(BareNetworkString *buffer) const;
    void  rewindTo(BareNetworkString *buffer);
    // ------------------------------------------------------------------------
    void setMinSpeed(float s) { m_min_speed = s; }
    // ------------------------------------------------------------------------
    float getCurrentMaxSpeed() const { return m_current_max_speed; }
    // ------------------------------------------------------------------------
    float getCurrentAdditionalEngineForce() const { return m_add_engine_force;}
};   // MaxSpeed
#endif