fr:sources:cpp_pclock [SFML Wiki]

Cette classe est une amélioration au morceau de code tapé par Hiura, ajoutant un système de pause à la classe sf::Clock. J'ai trouvé l'idée très intéressante, et je pense qu'elle peut être poussée un peu plus loin en fournissant plus d'outils. J'ai donc repris et retravaillé le code de base pour ajouter diverses fonctions (retour arrière, saut en avant, récupération du temps auquel à eu lieu la pause…).

PClock.hpp

/////////////////////////////////////////////////////////////////////////////////
/// @file PClock.hpp
/// PClock
/// Copyright (C) 2009 Marco Antognini (hiura@romandie.com)
/// Modified by : Furanku
/// License : CC-BY-SA 3.0
///     You can find the full legal code at
///     http://creativecommons.org/licenses/by-sa/3.0/
///
///     Original source code available at :
///     http://hiura.tuxfamily.org/wiki/doku.php?id=cpp:sf:pausableclock
/////////////////////////////////////////////////////////////////////////////////
 
#ifndef PClock_H
#define PClock_H
 
#include <vector>
#include <SFML/System.hpp>
 
///////////////////////////////////////////////////
/// @namespace sftools
/// Outils bases sur la bibliotheque SFML
///////////////////////////////////////////////////
namespace sftools
{
 
//////////////////////////////////////////////////
/// @class PClock
/// @brief Chronometre base sur sf::Clock
//////////////////////////////////////////////////
class PClock
{
    public:
 
        //////////////////////////////////////////////////
        /// @brief Constructeur par defaut
        //////////////////////////////////////////////////
        PClock();
 
 
        //////////////////////////////////////////////////
        /// Demarre la chronometre
        /// @see IsStarted()
        //////////////////////////////////////////////////
        void Start();
 
 
        //////////////////////////////////////////////////
        /// Stoppe le chronometre
        /// @see IsStopped()
        //////////////////////////////////////////////////
        void Stop();
 
 
        //////////////////////////////////////////////////
        /// Reinitialise le chronometre
        //////////////////////////////////////////////////
        void Reset();
 
 
        //////////////////////////////////////////////////
        /// Met en pause le chronometre
        /// @param pause Booleen signalant la mise en pause
        /// @see IsPaused()
        //////////////////////////////////////////////////
        void Pause(const bool pause=true);
 
 
        //////////////////////////////////////////////////
        /// Deduit timeRewind au temps actuel du chronometre
        /// @param timeRewind Temps a deduire
        //////////////////////////////////////////////////
        void Rewind(float timeRewind);
 
 
        //////////////////////////////////////////////////
        /// Ajoute timeForward au temps actuel du chronometre
        /// @param timeForward Temps a ajouter
        //////////////////////////////////////////////////
        void Forward(float timeForward);
 
 
 
        //////////////////////////////////////////////////
        /// Autorise ou non la sauvegarde des temps de pause
        /// @see ClearStored(), GetStoredPause()
        //////////////////////////////////////////////////
        void StorePause(const bool toStore);
 
 
        //////////////////////////////////////////////////
        /// Sauvegarde le temps courant
        /// @see GetStoredTime(), ClearStoredTime(), ClearStored()
        //////////////////////////////////////////////////
        void StoreCurrentTime();
 
 
        //////////////////////////////////////////////////
        /// Supprime l'ensemble des sauvegardes
        /// @see StoreCurrentTime(), StorePause()
        //////////////////////////////////////////////////
        void ClearStored();
 
 
        //////////////////////////////////////////////////
        /// Supprime l'ensemble des temps sauvegardes
        /// @see StoreCurrentTime(), GetStoredTime()
        //////////////////////////////////////////////////
        void ClearStoredTime();
 
 
        //////////////////////////////////////////////////
        /// Supprime l'ensemble des temps de pause sauvegardes
        /// @see StorePause(), GetStoredPause()
        //////////////////////////////////////////////////
        void ClearStoredPause();
 
 
 
        //////////////////////////////////////////////////
        /// Indique si le chronometre est demarre
        /// @return TRUE : chronometre demarre
        /// @return FALSE : chronometre non-demarre
        /// @see Start()
        //////////////////////////////////////////////////
        bool IsStarted() const;
 
 
        //////////////////////////////////////////////////
        /// Indique si le chronometre est arrete
        /// @return TRUE : chronometre arrete
        /// @return FALSE : chronometre en fonctionnement
        /// @see Stop()
        //////////////////////////////////////////////////
        bool IsStopped() const;
 
 
        //////////////////////////////////////////////////
        /// Indique si le chronometre est en pause
        /// @return TRUE : chronometre en pause
        /// @return FALSE : chronometre en fonctionnement
        /// @see Pause()
        //////////////////////////////////////////////////
        bool IsPaused() const;
 
 
 
        //////////////////////////////////////////////////
        /// Recupere le temps actuel du chronometre
        /// @return Temps ecoule depuis Start(), en secondes
        //////////////////////////////////////////////////
        float GetCurrentTime();
 
 
        //////////////////////////////////////////////////
        /// Recupere le moment auquel la dernier Pause() a eu lieue
        /// @return Temps (moment) de la derniere Pause(), en secondes
        //////////////////////////////////////////////////
        float GetLastPause() const;
 
 
        //////////////////////////////////////////////////
        /// Recupere les temps sauvegardes
        /// @return Tableau des temps sauvegardes
        /// @see StoreTime(), ClearStoredTime()
        //////////////////////////////////////////////////
        const std::vector<float>& GetStoredTime() const;
 
 
        //////////////////////////////////////////////////
        /// Recupere les temps de pause sauvegardes
        /// @return Tableau des temps de pause sauvegardes
        /// @see StorePause(), GetLastPause(), ClearStoredPause()
        //////////////////////////////////////////////////
        const std::vector<float>& GetStoredPause() const;
 
 
    private:
        sf::Clock m_clock;
        std::vector<float> m_storedTime;
        std::vector<float>* m_storedPausedTime; ///< Allocation dynamique
 
        float m_currentTime;
        float m_lastPause;
 
        bool m_started;
        bool m_stopped;
        bool m_paused;
        bool m_storePause;
 
};
 
} // End namespace sftools
 
#endif // PClock_H

PClock.cpp

#include "PClock.hpp"
 
using namespace sftools;
 
//////////////////////////////////////////////
/// Constructeur
/////////////////////////////////////////////
PClock::PClock() :
m_storedPausedTime(NULL), m_currentTime(0.f), m_lastPause(0.f), m_started(false), m_stopped(true), m_paused(false), m_storePause(false)
{
 
}
 
 
 
//////////////////////////////////////////////
/// void Start()
/////////////////////////////////////////////
void PClock::Start()
{
    if(m_stopped) // Si le chrono a été stoppé
    {
        m_clock.Reset();
        m_started = true;
        m_stopped = false;
    }
}
 
 
//////////////////////////////////////////////
/// void Stop()
/////////////////////////////////////////////
void PClock::Stop()
{
    m_started = false;
    m_stopped = true;
}
 
 
//////////////////////////////////////////////
/// void Reset()
/////////////////////////////////////////////
void PClock::Reset()
{
    if(m_started) // Si le chrono a été démarré
    {
        m_clock.Reset();
        m_currentTime = 0.f;
		m_lastPause = 0.f;
    }
}
 
 
//////////////////////////////////////////////
/// void Pause(bool)
/////////////////////////////////////////////
void PClock::Pause(const bool pause)
{
    if(pause) // Si l'on met le chrono en pause
    {
        if(!m_storePause) // On ne stocke pas les temps de pause
        {
            m_lastPause = GetCurrentTime();
        }
 
 
        else
        {
            m_storedPausedTime->push_back(GetCurrentTime());
        }
 
        m_paused = true;
    }
 
 
    else
    {
        if(!m_storePause)
        {
            m_currentTime = m_lastPause; // On récupère le temps où l'on avait fait la "pause"
        }
 
        else
        {
            m_currentTime = m_storedPausedTime->back();
        }
 
        m_paused = false;
        m_clock.Reset();
    }
}
 
 
//////////////////////////////////////////////
/// void Rewind(float)
/////////////////////////////////////////////
void PClock::Rewind(float timeRewind) // Retour arrière (dans le temps)
{
    m_currentTime = m_clock.GetElapsedTime() - timeRewind;
 
	if(m_currentTime < 0.f)
		m_currentTime = 0.f;
 
    m_clock.Reset();
}
 
 
//////////////////////////////////////////////
/// void Forward(float)
/////////////////////////////////////////////
void PClock::Forward(float timeForward) // Saut avant (dans le temps)
{
	Rewind(-timeForward);
}
 
 
 
//////////////////////////////////////////////
/// void StorePause(bool)
/////////////////////////////////////////////
void PClock::StorePause(const bool toStore)
{
    if(!toStore)
    {
        delete m_storedPausedTime;
        m_storePause = false;
    }
 
    else
    {
        m_storedPausedTime = new std::vector<float>;
        m_storePause = true;
    }
}
 
 
//////////////////////////////////////////////
/// void StoreCurrentTime()
/////////////////////////////////////////////
void PClock::StoreCurrentTime()
{
    m_storedTime.push_back(GetCurrentTime());
}
 
 
 
//////////////////////////////////////////////
/// void ClearStored()
/////////////////////////////////////////////
void PClock::ClearStored()
{
    m_storedTime.clear();
 
    if(!m_storePause)
        m_lastPause = 0.f;
 
    else
        m_storedPausedTime->clear();
}
 
 
//////////////////////////////////////////////
/// void ClearStoredTime()
/////////////////////////////////////////////
void PClock::ClearStoredTime()
{
    m_storedTime.clear();
}
 
 
//////////////////////////////////////////////
/// void ClearStoredPause()
/////////////////////////////////////////////
void PClock::ClearStoredPause()
{
    if(!m_storePause)
        m_lastPause = 0.f;
 
    else
        m_storedPausedTime->clear();
}
 
 
 
//////////////////////////////////////////////
/// bool IsStarted()
/////////////////////////////////////////////
bool PClock::IsStarted() const
{
    return m_started;
}
 
 
//////////////////////////////////////////////
/// bool IsStopped()
/////////////////////////////////////////////
bool PClock::IsStopped() const
{
    return m_stopped;
}
 
 
//////////////////////////////////////////////
/// bool IsPaused()
/////////////////////////////////////////////
bool PClock::IsPaused() const
{
    return m_paused;
}
 
 
 
//////////////////////////////////////////////
/// float GetCurrentTime()
/////////////////////////////////////////////
float PClock::GetCurrentTime()
{
    if(m_paused)
    {
        return m_lastPause;
    }
 
    else
    {
		m_currentTime += m_clock.GetElapsedTime();
        m_clock.Reset();
        return m_currentTime;
    }
}
 
 
//////////////////////////////////////////////
/// float GetLastPause()
/////////////////////////////////////////////
float PClock::GetLastPause() const
{
    if(!m_storePause)
        return m_lastPause;
 
    else
        return m_storedPausedTime->back();
}
 
 
//////////////////////////////////////////////
/// std::vector<float>& GetStoredTime()
/////////////////////////////////////////////
const std::vector<float>& PClock::GetStoredTime() const
{
    return m_storedTime;
}
 
 
//////////////////////////////////////////////
/// std::vector<float>& GetStoredPause()
/////////////////////////////////////////////
const std::vector<float>& PClock::GetStoredPause() const
{
    return *m_storedPausedTime;
}

Commentaires

Merci à Hiura pour ses conseils ;-)

Si vous avez une remarque quelconque, vous pouvez poster sur le forum à cette adresse : Forum SFML (FR). J'ai aussi mis en ligne la documentation de la classe (ce qui explique les nombreux commentaires). Elle est disponible ici.