int main(int argc, char* argv[])
{
//***************************VARIABLEN***********************************
SDL_Surface* buffer = NULL; //dient als Hintergrund
SDL_Surface* TestPicture = NULL; //Wird als Test Bild verwendet
SDL_Surface* testSurface = NULL;
SDL_Surface* SuperToll = NULL; //Test
SDL_Surface* SuperToll2 = NULL;
SDL_Surface* SuperToll3 = NULL;
SDL_Surface* SuperToll4 = NULL;
SDL_Surface* SuperToll5 = NULL;
SDL_Event Event; //Erstellt ein Event
SDL_Rect Rect;
SDL_Rect Rect2;
SDL_Rect Rect3;
SDL_Rect Rect4;
SDL_Rect Rect5;
bool GameIsRunning = true; //wird als Spielschleifenbedingung benutzt
float Time = SDL_GetTicks() / 1000.f;
//***************************VARIABLEN***********************************
//***************************KONSTANTEN**********************************
const int iBreite = 800;
const int iHoehe = 800;
const int iBpp = 32;
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER); //SDL_INIT_VIDEO initialisiert den "Video" modus.
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0 || SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) == NULL)
{
std::cout << "SDL konnte nicht initialisiert werden" << SDL_GetError() << std::endl;
}
buffer = SDL_SetVideoMode(iBreite, iHoehe, iBpp, SDL_HWSURFACE | SDL_DOUBLEBUF); //800 = Breite, 600 = Höhe, 32 = Bits pro Pixel, SDL_HWSURFACE = Sagt, dass das Surface in der Hardware verarbeitet wird.
//SDL_SWSURFACE geht auch, dabei wird aber das Surface in der Software verarbeitet. Lieber mit der Hardware verarbeiten lassen,
//Da es bei der Software zu einem "Flickern" kommen kann ( bei Bewegungen ). Diese werden hier mit SDL_DOUBLEBUF verhindert.
if(buffer < 0 || buffer == NULL)
{
std::cout << "Der Video Mode wurde nicht richtig gesetzt." << SDL_GetError() << std::endl;
}
SDL_WM_SetCaption("haha", NULL); //Gibt den Namen des Fensters an
Rect.x = 0;
Rect.y = 300;
Rect.w = 20;
Rect.h = 200;
Rect2.x = 300;
Rect2.y = 780;
Rect2.w = 200;
Rect2.h = 20;
Rect3.x = 780;
Rect3.y = 300;
Rect3.w = 20;
Rect3.h = 200;
Rect4.x = 300;
Rect4.y = 0;
Rect4.w = 200;
Rect4.h = 20;
Rect5.x = 380;
Rect5.y = 40;
Rect5.w = 20;
Rect5.h = 20;
while(GameIsRunning) //Führt den Inhalt der Schleife solange aus, bis GameIsRunning auf false gestellt wurde.
{
Rect5.y = 300;
Rect5.y -= 0.0981 * SDL_GetTicks();
if(Rect5.x <= (Rect4.x + 200) && Rect5.x >= Rect4.x && ((Rect5.y - 20) <= Rect4.y) ||
(Rect5.x <= (Rect2.x + 200) && Rect5.x >= Rect2.x && ((Rect5.y + 20) >= Rect2.y)) )
{
Rect5.y = 300;
Rect5.y += 0.0981 * SDL_GetTicks();
}
if(SDL_PollEvent ( &Event ))
{
if(Event.type == SDL_KEYDOWN)
{
switch(Event.key.keysym.sym)
{
case SDLK_ESCAPE:
{
GameIsRunning = false;
}break;
case SDLK_UP:
{
Rect.y -= 100.f;
Rect2.x += 100.f;
Rect3.y += 100.f;
Rect4.x -= 100.f;
if(Rect.y < 20 && Rect2.x > 580 && Rect3.y > 580 && Rect4.x < 20)
{
Rect.y = 20;
Rect2.x = 580;
Rect3.y = 580;
Rect4.x = 20;
}
}break;
case SDLK_DOWN:
{
Rect.y += 100.f;
Rect2.x -= 100.f;
Rect3.y -= 100.f;
Rect4.x += 100.f;
if(Rect.y > 580 && Rect2.x < 20 && Rect3.y < 20 && Rect4.x > 580)
{
Rect.y = 580;
Rect2.x = 20;
Rect3.y = 20;
Rect4.x = 580;
}
}break;
case SDLK_LEFT:
{
}break;
case SDLK_w:
{
}break;
}
}
else if(Event.type == SDL_QUIT)
{
GameIsRunning = false;
}
}
SuperToll = IMG_Load("t.png");
if(SuperToll < 0)
{
std::cout << "Bild konnte nicht geladen werden!" << SDL_GetError() << std::endl;
}
SuperToll2 = IMG_Load("t2.png");
if(SuperToll2 < 0)
{
std::cout << "Bild konnte nicht geladen werden!" << SDL_GetError() << std::endl;
}
SuperToll3 = IMG_Load("t.png");
if(SuperToll3 < 0)
{
std::cout << "Bild konnte nicht geladen werden!" << SDL_GetError() << std::endl;
}
SuperToll4 = IMG_Load("t2.png");
if(SuperToll4 < 0)
{
std::cout << "Bild konnte nicht geladen werden!" << SDL_GetError() << std::endl;
}
SuperToll5 = IMG_Load("t3.png");
if(SuperToll5 < 0)
{
std::cout << "Bild konnte nicht geladen werden!" << SDL_GetError() << std::endl;
}
TestPicture = IMG_Load("3-big.jpg"); //Hier wird dem Surface ein "Ziel" zugeordnet. In diesem Fall das Bild "yey.bmp". SDL_LoadBMP wird zum laden eines
if(TestPicture < 0 || TestPicture == NULL) //BMP Bildes verwendet. Mit IMG_Load werden andere Bildformate geladen.
{
std::cout << "Konnte Bild nicht laden: " << SDL_GetError() << std::endl;
}
SDL_BlitSurface(TestPicture, NULL, buffer, NULL);
SDL_BlitSurface(SuperToll, NULL, buffer, &Rect);
SDL_BlitSurface(SuperToll2, NULL, buffer, &Rect2); //Lässt das Bild abzeigen ÜBER dem Bildschirm(buffer).
SDL_BlitSurface(SuperToll3, NULL, buffer, &Rect3);
SDL_BlitSurface(SuperToll4, NULL, buffer, &Rect4);
SDL_BlitSurface(SuperToll5, NULL, buffer, &Rect5);
SDL_Flip(buffer); //Updated den Bildschirm. Möglich wäre auch : SDL_UpdateRect(buffer, 0,0,0,0);
}
SDL_FreeSurface(TestPicture); //Hiermit löschen wir das Bild und geben den Speicher wieder frei.
SDL_FreeSurface(testSurface);
SDL_FreeSurface(SuperToll);
SDL_Quit(); //Hiermit beendet man die SDL
return 0;
}