spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

class TimeFrame
{
private:
    DWORD loopStart, loopEnd;
    float Time;

    void CalculateTime();

public:
    TimeFrame ();
    ~TimeFrame ();

    void SetStart();
    void SetEnd();
    void MoveGame(HWND hWnd);
    void RenderGame(HWND hWnd);
    void InitGame(HWND hWnd);
};

C-/C++-Quelltext

//Globale Spielvariablen

list<BackgroundStars> BackgroundStarsList;

//Ermitteln der Auflösung

static int cxClient = GetSystemMetrics(SM_CXSCREEN);
static int cyClient = GetSystemMetrics(SM_CYSCREEN);
static int cxChar, cyChar, cxCaps;

TimeFrame::TimeFrame ()
{
    Time = 0.0f;
}
TimeFrame::~TimeFrame ()
{

}

//PRIVATE

void TimeFrame::CalculateTime()
{
    Time = (float)(loopEnd - loopStart) / 1000.0f;
}

void TimeFrame::SetStart()
{
    loopStart = timeGetTime(); //Benötigt winmm.lib LINKER

}

void TimeFrame::SetEnd()
{
    loopEnd = timeGetTime(); //Benötigt winmm.lib LINKER

    CalculateTime(); //Berechnet benötigte Zeit für Messageloop

}

void TimeFrame::MoveGame(HWND hWnd)
{
    //Bewegung der Objekte um einen mit Time multiplizierten Wert BEISPIEL FUNKTIONIERT

    /*list<BackgroundStars>::iterator j;
    for (j = BackgroundStarsList.begin(); j != BackgroundStarsList.end(); j++)
    {

        j->SetXY(j->GetX() + 10 * Time, j->GetY());
        
        if (j->GetX() >= cxClient)
            j->SetXY(0, j->GetY());
    }*/

    //???????????????????????????????????????????????????????????????????

    list<BackgroundStars>::iterator j;
    for (j = BackgroundStarsList.begin(); j != BackgroundStarsList.end(); j++)
    {
        float XYarr[2], Mittearr[2];
        XYarr[0] = j->GetX();
        XYarr[1] = j->GetY();
        Mittearr[0] = (float)cxClient / 2;
        Mittearr[1] = (float)cyClient / 2;

        float x, y;

        DreheUmPunkt(Time, 10, XYarr, Mittearr, x, y); //x, y = Referenz


        j->SetXY(x, y);
    }
    //??????????????????????????????????????????????????????????????????????

}

void TimeFrame::RenderGame(HWND hWnd)
{
    //Zeichnen der Objekte um einen mit fTime multiplizierten Wert

    HDC             hdc;
    HBRUSH          hBrush;
    PAINTSTRUCT     ps;
    RECT            rect;

    //Zeichnen Hintergrund-Objekte

    list<BackgroundStars>::iterator j;
    for (j = BackgroundStarsList.begin(); j != BackgroundStarsList.end(); j++)
    {
        rect.bottom = (int)j->GetY()+1;
        rect.top = (int)j->GetY()-1;
        rect.right = (int)j->GetX()+1;
        rect.left = (int)j->GetX()-1;
        InvalidateRect(hWnd, &rect, TRUE);
        hdc = BeginPaint(hWnd, &ps);
        SetPixel(hdc, (int)j->GetX(), (int)j->GetY(), RGB(j->GetColor(), j->GetColor(), j->GetColor()));
        EndPaint(hWnd, &ps);
    }

    /* GEHÖRT ZU BEISPIEL FUNKTIONIERT
    rect.bottom = cyClient;
    rect.top = 0;
    rect.right = cxClient;
    rect.left = cxClient - 1;
    InvalidateRect(hWnd, &rect, TRUE);
    hdc = BeginPaint(hWnd, &ps);
    hBrush = CreateSolidBrush (RGB (0,0,0));
    FillRect (hdc, &rect, hBrush);
    EndPaint(hWnd, &ps);*/
}

void TimeFrame::InitGame(HWND hWnd)
{
    TEXTMETRIC      tm;
    HDC             hdc;

    //Startwert für Zufallsvariablen

    srand ((unsigned int)time(NULL));

    hdc = GetDC(hWnd);
    GetTextMetrics(hdc, &tm);
    cxChar = tm.tmAveCharWidth;
    cyChar = tm.tmHeight + tm.tmExternalLeading;
    cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2;
    ReleaseDC(hWnd, hdc);

    //Initialisieren der Hintergrundsterne

    BackgroundStars* BStars;
    float BStarX, BStarY;
    int BStarC;
    int Stars = rand() % 500 + 501;
    for (int i=0; i <= Stars; i++)
    {
        BStarX = (float)(rand() % cxClient);
        BStarY = (float)(rand() % cyClient);
        BStarC = rand() % 256;
        BStars = new BackgroundStars(BStarX, BStarY, BStarC);
        BackgroundStarsList.push_back(*BStars);
    }
}

C-/C++-Quelltext

void DreheUmPunkt(float Time, float Speed, float O[2], float M[2], float &x, float &y)
{
    Vektor2D *Vektor;
    Vektor = new Vektor2D(O, M);

    x = Vektor->GetLength() * cosf (Time * Speed + Vektor->GetAngle()) + M[0];
    y = Vektor->GetLength() * sinf (Time * Speed + Vektor->GetAngle()) + M[1];

    delete Vektor;
}

C-/C++-Quelltext

class Vektor2D
{
private:
    float x;
    float y;
    float length;
    float angle;
    float xN;
    float yN;

    void VektorLength();
    void VektorAngle();

public:
    Vektor2D(float O[2], float M[2]);
    ~Vektor2D();
    void SetLength(float nlength);
    float GetAngle();
    float GetLength();
    float GetX();
    float GetY();
    float GetXN();
    float GetYN();
};

C-/C++-Quelltext

Vektor2D::Vektor2D(float O[2], float M[2])
{
    x = O[0] - M[0];
    y = O[1] - M[1];
    VektorLength();
    xN = x / length;
    yN = y / length;
    VektorAngle();
}

Vektor2D::~Vektor2D()
{

}

void Vektor2D::VektorLength()
{
    length = sqrtf(x * x + y * y);
}

void Vektor2D::SetLength(float nlength)
{
    length = nlength;
    x = xN * nlength;
    y = yN * nlength;
}

void Vektor2D::VektorAngle()
{
    //Winkel zwischen Vektor und X-Achse [1,0]

    angle = acosf((x * 1 + y * 0) / sqrtf((x * x + y * y) * (1 * 1 + 0 * 0)));
}

float Vektor2D::GetLength()
{
    return length;
}

float Vektor2D::GetAngle()
{
    return angle;
}

float Vektor2D::GetX()
{
    return x;
}

float Vektor2D::GetY()
{
    return y;
}

float Vektor2D::GetXN()
{
    return xN;
}

float Vektor2D::GetYN()
{
    return yN;
}

C-/C++-Quelltext

class BackgroundStars
{
private:
    int Color;
    float x;
    float y;

public:
    BackgroundStars(float ix, float iy, int iColor);
    ~BackgroundStars();

    void SetXY(float ix, float iy);
    float GetX();
    float GetY();
    int GetColor();
};

C-/C++-Quelltext

BackgroundStars::BackgroundStars(float ix, float iy, int iColor)
{
    x = ix;
    y = iy;
    Color = iColor;
}

BackgroundStars::~BackgroundStars()
{

}

float BackgroundStars::GetX()
{
    return x;
}

float BackgroundStars::GetY()
{
    return y;
}

int BackgroundStars::GetColor()
{
    return Color;
}

void BackgroundStars::SetXY(float ix, float iy)
{
    x = ix;
    y = iy;
}

C-/C++-Quelltext

#include <windows.h>        //Windows Bibliotheken

#include <stdlib.h>         //Für Zufallszahlen

#include <stdio.h>          //Standard Input-Output

#include <time.h>           //Zufallszahlen

#include <cmath>
#include <list>         //Ermöglicht den Gebracuh von Listen


using namespace std;

C-/C++-Quelltext

int APIENTRY _tWinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
    //Erstellen des Window-Handles

    HWND hWnd;

    //Initialisieren des Fensters

    if (!initMainWindow(hWnd, hInstance)) return 0;

    //Erzeugen des Spielobjektes

    TimeFrame Game;

    //Initialisieren des Spielobjektes

    Game.InitGame(hWnd);

    //Haupt Nachrichtenschleife

    MSG msg = {0};
    while (WM_QUIT != msg.message)
    {
        Game.SetStart(); //Zeit bestimmen


        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) == TRUE)
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        Game.MoveGame(hWnd); //Bewegen der Objekte

        Game.RenderGame(hWnd); //Zeichnen der Objekte


        Game.SetEnd(); //Zeit bestimmen und Differenz berechnen

    }

    //Ausstiegspunkt des Programms

    return (int) msg.wParam;
}

C-/C++-Quelltext

void DreheUmPunkt(float Time, float Speed, float O[2], float M[2], float &x, float &y)
{
    Vektor2D *Vektor;
    Vektor = new Vektor2D(O, M);

    x = Vektor->GetLength() * cosf (Time * Speed + Vektor->GetAngle()) + M[0];
    y = Vektor->GetLength() * sinf (Time * Speed + Vektor->GetAngle()) + M[1];

    delete Vektor;
}

C-/C++-Quelltext

void DreheUmPunkt(float Time, float Speed, float O[2], float M[2], float &x, float &y)
{
    x = (int)((O[0] - M[0]) * cosf(Time * Speed) - (O[1] - M[1]) * sinf(Time * Speed)) + M[0];
    y = (int)((O[0] - M[0]) * sinf(Time * Speed) + (O[1] - M[1]) * cosf(Time * Speed)) + M[1];
}