Zadania - Utworzyć klasę TimeCL
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!

Zadania - Utworzyć klasę TimeCL

AutorWiadomość
Temat założony przez niniejszego użytkownika
Zadania - Utworzyć klasę TimeCL
» 2008-01-01 15:21:24
Ja mam kilka pytań związanych z zadaniami młodszych programistów.
1. Czy wiedza z tego kursu wystarczy do tego zęby nim zostać?
2. Czy książka "C++ dla programistów gier" Wydanie II przyda się młodemu 
   programiście?
3. Ma ktoś może kod źródłowy przykładowego modułu?

Z góry dziękuje za informacje
P-185
Re: Zadania młodszych programistów
» 2008-01-01 16:08:45
[tutorial]Najważniejsze to są chęci wzięcia udziału w projekcie, czas i pozytywne nastawienie. Jeśli młodszy programista rozumie i potrafi posługiwać się całym materiałem jaki jest zawarty w kursie C++, który znajduje się na naszej stronie (pomijam tu znajomość bibliotek i obiektowość), to jak najbardziej będzie możliwość wzięcia udziału w projekcie.
Ja nie liczę na to, że znajdę 18 osób, które potrafią kodować, znają różne technologie i metody rozwiązywania problemów... Ten projekt ma być rozwojowy dla każdego, kto zechce wziąć w nim udział. Sporo czasu każdy z nas będzie poświęcał na szukanie rozwiązań w Internecie po to, aby wykonać dany moduł.
Jako, że programuję już dość długi czas dobrze wiem, że osoby zaczynające programowanie i poznające różne metody rozwiązywania problemów programistycznych bardzo chciałyby zrealizować jakiś duży projekt, jednak z braku doświadczenia praktycznie zawsze kończy się to niepowodzeniem.
Co do przykładowego modułu... to zaraz jakiś zamieszczę tylko muszę znaleźć.
[/tutorial]
P-186
Przykładowy moduł timeCL
» 2008-01-01 16:26:32
[tutorial]Moduł ten jest stary i dawno temu go pisałem, ale tak to mniej więcej będzie wyglądało.

Zadanie

Opis

Utworzyć klasę TimeCL do wirtualnego czasu wysokiej rozdzielczości (o dużej dokładności) - klasa ma działać jak stoper. W klasie muszą być dostępne funkcje: SetTime(); Pause(); Unpause();.

Planowane wykorzystywanie

Moduł będzie wykorzystywany między innymi przez fizykę gry.

Przykładowe rozwiązanie

Plik time.hpp

C/C++
/*************************** << http://ddt.pl >> ****************************/
#ifndef ddt_time_hpp
#define ddt_time_hpp
/****************************************************************************/
#include <windows.h>
/****************************************************************************/
namespace ddt
{
    /**************************************************************************/
    static class timeCL
    {
    private:
        LARGE_INTEGER mc_StartTimeH;
        double mc_StartTime;
        LARGE_INTEGER mc_TicksPerSecondH;
        LARGE_INTEGER mc_TimeH[ 3 ];
        double DiffrenceTime( void );
    protected:
        double mc_Time;
        bool mc_IsPaused;
    public:
        double * handle( void );
        double get( void );
        void set( double fTime );
        void update( void );
        void pause( void );
        void unpause( void );
        bool isPaused( void );
        timeCL( void );
        ~timeCL( void );
    } time;
    /**************************************************************************/
} //namespace ddt
/****************************************************************************/
#endif //ddt_time_hpp

Plik time.cpp

C/C++
/*************************** << http://ddt.pl >> ****************************/
#include "time.hpp"
/****************************************************************************/
namespace ddt
{
    /**************************************************************************/
    bool timeCL::isPaused( void )
    {
        return( mc_IsPaused );
    }
    /**************************************************************************/
    double timeCL::get( void )
    {
        return( mc_Time );
    }
    /**************************************************************************/
    double timeCL::DiffrenceTime( void )
    {
        if( mc_IsPaused == false )
        {
            double delta;
            for( int i = 0; i < 2; i++ ) mc_TimeH[ i ] = mc_TimeH[ i + 1 ];
           
            int tProtect = 0;
            while( !QueryPerformanceCounter( & mc_TimeH[ 2 ] ) &&( tProtect < 10 ) ) tProtect += 1;
           
            if( mc_TimeH[ 2 ].QuadPart > mc_TimeH[ 1 ].QuadPart )
            {
                delta = static_cast < double >( mc_TimeH[ 2 ].QuadPart ) - static_cast < double >( mc_StartTimeH.QuadPart );
                delta = delta / static_cast < double >( mc_TicksPerSecondH.QuadPart );
            } else
            {
                delta = static_cast < double >( mc_TimeH[ 1 ].QuadPart ) - static_cast < double >( mc_StartTimeH.QuadPart );
                delta = delta / static_cast < double >( mc_TicksPerSecondH.QuadPart );
                mc_StartTimeH = mc_TimeH[ 2 ];
                mc_StartTime += delta;
                delta = 0;
            }
            if( delta >= 60.0f )
            {
                mc_StartTime += delta;
                mc_StartTimeH = mc_TimeH[ 2 ];
                delta = 0;
            }
            return( delta );
        } else return( 0.0f );
       
    }
    /**************************************************************************/
    double * timeCL::handle( void )
    {
        return( & mc_Time );
    }
    /**************************************************************************/
    void timeCL::set( double fTime )
    {
        mc_StartTime = fTime;
        mc_Time = mc_StartTime;
        int tProtect = 0;
        while( !QueryPerformanceCounter( & mc_StartTimeH ) &&( tProtect < 10 ) ) tProtect += 1;
       
        for( int i = 0; i < 3; i++ ) mc_TimeH[ i ] = mc_StartTimeH;
       
        return;
    }
    /**************************************************************************/
    void timeCL::update( void )
    {
        double tTime = DiffrenceTime();
        mc_Time = mc_StartTime + tTime;
        return;
    }
    /**************************************************************************/
    void timeCL::pause( void )
    {
        if( mc_IsPaused == false )
        {
            double delta;
            for( int i = 0; i < 2; i++ ) mc_TimeH[ i ] = mc_TimeH[ i + 1 ];
           
            int tProtect = 0;
            while( !QueryPerformanceCounter( & mc_TimeH[ 2 ] ) &&( tProtect < 10 ) ) tProtect += 1;
           
            if( mc_TimeH[ 2 ].QuadPart > mc_TimeH[ 1 ].QuadPart )
            {
                delta = static_cast < double >( mc_TimeH[ 2 ].QuadPart ) - static_cast < double >( mc_StartTimeH.QuadPart );
                delta = delta / static_cast < double >( mc_TicksPerSecondH.QuadPart );
            } else
            {
                delta = static_cast < double >( mc_TimeH[ 1 ].QuadPart ) - static_cast < double >( mc_StartTimeH.QuadPart );
                delta = delta / static_cast < double >( mc_TicksPerSecondH.QuadPart );
                mc_StartTimeH = mc_TimeH[ 2 ];
                mc_StartTime += delta;
                delta = 0;
            }
            mc_StartTime += delta;
            mc_StartTimeH = mc_TimeH[ 2 ];
        }
        mc_IsPaused = true;
        return;
    }
    /**************************************************************************/
    void timeCL::unpause( void )
    {
        if( mc_IsPaused == true )
        {
            char tProtect = 0;
            while( !QueryPerformanceCounter( & mc_StartTimeH ) &&( tProtect < 10 ) ) tProtect += 1;
           
            for( int i = 0; i < 3; i++ ) mc_TimeH[ i ] = mc_StartTimeH;
           
        }
        mc_IsPaused = false;
        return;
    }
    /**************************************************************************/
    timeCL::timeCL( void )
    {
        QueryPerformanceFrequency( & mc_TicksPerSecondH );
        set( 0.0f );
        unpause();
        return;
    }
    /**************************************************************************/
    timeCL::~timeCL( void )
    {
        return;
    }
    /**************************************************************************/
} //namespace ddt
/****************************************************************************/

Program testujący działanie klasy TimeCL; plik main.cpp

C/C++
#include "time.hpp"
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
    unsigned char znak;
    do
    {
        if( !ddt::time.isPaused() ) cout <<*( ddt::time.handle() ) << endl;
       
        ddt::time.update();
        if( kbhit() )
        {
            znak = getch();
            switch( znak )
            {
            case 'p':
            case 'P':
                ddt::time.pause();
                cout << "P" << endl;
                break;
            case 'u':
            case 'U':
                ddt::time.unpause();
                cout << "U" << endl;
                break;
            }
        }
        Sleep( 10 );
    } while( znak != 27 );
   
    return( 0 );
}
[/tutorial]
P-187
Chyba się będę nadawał
» 2008-01-02 11:16:02
Jeśli rekrutacja zostanie przeprowadzona w zapowiedzianym terminie, to będę gotów uczestniczyć w nim. Do końca lutego powinienem mieć już opanowane (prawie perfect) 3 tomową książkę "Programowanie w tonacji C++" a jako dopełnienie "Od zara do gier kodera" i kurs zamieszczony na tej stronie. Mam nadzieję, że to wystarczy. Może jeszcze nie miałem okazji ukończyć żadnej gry (są w trakcie tworzenia), ale jest to spowodowane tym, iż chcę wyuczyć się pewnych nawyków przez tworzenie obszernej dokumentacji oraz stosowania abstrakcji proceduralnej. Dopiero po tym zabieram się do kodowania (co bardzo lubię). Dzięki dokumentacji, kodzenie jest proste i przyjemnie, bo szkielet już jest zobrazowany.
P-188
Zamykam temat
» 2008-01-02 14:55:32
Ok, to skoro wszystko jest jasne to zamykam temat :) Co do książek... fajnie, że planujecie przeczytać takie grube książki, ale nie forsujcie się byle by doczytać książkę bo później sił nie będziecie mieli na projekt :)
Nie zaniedbujcie też nauki w szkole/na uczelni teraz, bo później nie będziecie mieli czasu na wzięcie udziału w projekcie.
P-189
« 1 »
 Strona 1 z 1