CPU-Auslastung

Werbeanzeige

Gotbread

Alter Hase

Beiträge: 421

Beruf: Student (Etechnik) + Hiwi

08.01.2009, 17:42

versuch das mal so

C-/C++-Quelltext

void render();

bool exitflag = false;
MSG msg;
DWORD ticks = GetTickCount();
float maxFPS = 60;
float stime = 0.f;

while (!exitflag)
{
    while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    if (msg.message == WM_QUIT)
        exitflag = true;

    ticks = GetTickCount() - ticks;
    stime += static_cast<float>(ticks) * 0.001f;
    if (stime > 1.f / maxFPS)
    {
        stime -= 1.f / maxFPS;
        render();
    }
    else
        Sleep(static_cast<DWORD>(1.f / maxFPS) - ticks);
}
void render()
{
    hier die ganze spiellogik
}

(ungetestet)

Mfg Goti
www.gotbread.bplaced.net
viele tolle spiele kostenlos, viele hardware-basteleien

"Es ist nicht undicht, es läuft über" - Homer Simpson

Zum Seitenanfang

Thunaer

Frischling

Beiträge: 14

08.01.2009, 19:40

Wieder 100% Systemleistung, aber eine feste Framrate, was ich eig nicht unbedingt wollte...
Ich glaube ich gebe es einfach auf...

Zum Seitenanfang

Beneroth

Alter Hase

Beiträge: 969

Wohnort: Schweiz

Beruf: Software Entwickler

08.01.2009, 22:35

Warum bringt ihr hier alles Windows-Lösungen?
Das kriegt man doch auch mit SDL so hin!
Und das wäre sicher besser, weil kein Gemisch und Code noch auf anderen Systemen compilierbar ist...

Thunaer
Lade Dir hier mal die SDL-Doku runter!

SDL_GetTicks() hast Du ja am Anfang schon benutzt, bleib doch dabei!

Dann gibt es noch die Funktion void SDL_Delay(Uint32 ms);
Die macht etwa das gleiche wie Sleep() (bzw. unter windows vermutlich sogar Sleep).

Wenn Du die CPU entlasten willst musst du sowas einsetzen (soviel ich weiss),
eben zum Beispiel so am Ende der Schleife:

C-/C++-Quelltext

while(done==0)
    {
        if(frame.KeyDown(SDLK_ESCAPE))
        {
            done=1;
        }
        if(frame.KeyDown(SDLK_UP))
        {
            if((SDL_GetTicks()-last)/250>=0.1){
                if(spielfeld.check_valid(m_block_now->get_next(), m_block_now->x, m_block_now->y, false))
                {
                    m_block_now->rotate();
                    last=SDL_GetTicks();
                }
            }
        }
        if(frame.KeyDown(SDLK_DOWN))
        {
            if((SDL_GetTicks()-lastdown)/100>=0.1){
                lastdown=SDL_GetTicks();
                tick=SDL_GetTicks();
                if(spielfeld.check_valid(&m_block_now->klotz[0][0], m_block_now->x, ((m_block_now->y)+1), true))
                {
                    m_block_now->y+=1;
                    if(m_block_now->y > 19)
                    {
                        m_block_now->y=19;   
                    }
                }
            }
        }
        if(frame.KeyDown(SDLK_LEFT))
        {
            if((SDL_GetTicks()-last)/150>=0.1){
                last=SDL_GetTicks();
                if(spielfeld.check_valid(&m_block_now->klotz[0][0], ((m_block_now->x)-1), m_block_now->y, false))
                {
                    m_block_now->x-=1;
                    if(m_block_now->x<0)
                    {
                        m_block_now->x=0;
                    }
                }
            }
        }
        if(frame.KeyDown(SDLK_RIGHT))
        {
            if((SDL_GetTicks()-last)/150>=0.1){
                last=SDL_GetTicks();
                if(spielfeld.check_valid(&m_block_now->klotz[0][0], ((m_block_now->x)+1), m_block_now->y, false))
                {
                    m_block_now->x+=1;
                }
            }
        }
        if(frame.KeyDown(SDLK_RCTRL))
        {
            if((SDL_GetTicks()-last)/100>=0.1){
                if(spielfeld.check_valid(&m_block_now->klotz[0][0], m_block_now->x, ((m_block_now->y)-1), false))
                {
                    last=SDL_GetTicks();
                    m_block_now->y-=1;
                }
            }
        }
        if((SDL_GetTicks()-tick)/speed>=0.1){
            tick=SDL_GetTicks();
            if(spielfeld.check_valid(&m_block_now->klotz[0][0], m_block_now->x, ((m_block_now->y)+1), true)&&(m_block_now->y < 20))
            {
                m_block_now->y+=1;
            }
            else
            {
                spielfeld.insert(&m_block_now->klotz[0][0], m_block_now->x, m_block_now->y, m_block_now->ID);
                /*spielfeld.checkrows(&reihen[0]);
                for(int z=0; z<4; z++)
                {
                    cout<<"reihen["<<z<<"]="<<reihen[z]<<"\n";
                }
                spielfeld.delrows(reihen[0], reihen[1], reihen[2], reihen[3]);*/
                next_block();
            }
        }
        //m_klotz_img->SetPos(m_block_now->x, m_block_now->y);

       
        frame.Update();
        frame.Slock();
        background->Render(frame.GetScreen());
        show(frame.GetScreen(), &m_block_now->klotz[0][0], m_block_now->x, m_block_now->y, m_block_now->ID);
        show(frame.GetScreen(), &m_block_next->klotz[0][0], 13, 0, m_block_next->ID);
        spielfeld.show(frame.GetScreen());
        frame.Flip();

       SDL_Delay(10);

    }

Ich habe in meinem Projekt in mehreren Threads so etwas ähnliches, und da hatte ich auch bei Belastung immer 0% angezeigt im Taskmanager unter Windows.
Den Wert den Du wartest in SDL_Delay() kannst Du natürlich auch als Variable halten und je nach Bedürfniss anpassen.

Dies kann natürlich eine feste (minimal-) Zeit pro Frame ergeben, wenn Du pech hast auch bewirken dass das Programm flackert oder manchmal langsam reagiert -> das musst du aber ausprobieren, am besten auf verschiedenen Computern.

Eine Lösung wäre dass du zwei Schleifen oder Threads hast, bei der jeweils eine die Spiellogik macht und dann wieder anhält, also nur ab und zu (oder in regelmässigen Zeitabständen) aktiv ist, und eine zweite kurze die nur schaut ob ein SDL_Event eingetroffen ist und falls ja die Logik-Behandlung startet.

Probiers mal aus und dann sag mal wie du es machen möchstest, dann können wir das zusammen mal ansehen