Sprites laden und anzeigen

Checkmateing · 5. Dezember 2010, 13:04

Wie manche sicher wissen, habe ich ein Schiffeversenken-Spiel erstellt.
Nun habe ich aber vor, ein neues Game zu machen - Mit Sprites.
Ja, nun fehlen mir DENKE ich die Befehle und so weiter.
In meinem Buch steht da was von:

Sprite.hpp

Quellcode

#ifndef SPRITE_HPP //mal ein Kommentar von mir, was macht #ifndef eigentlich?
#define SPRITE_HPP
#include "Framework.hpp"
class CSprite
{
public:
CSprite ();
~CSprite ();
void Load (const string sFilename);
void Load (const string sFilename, int NumFrames,
int FrameWidth, int FrameHeight);
void SetColorKey (int R, int G, int B);
void SetPos (float fXPos, float fYPos);
void Render ();
void Render (float fFrameNumber);
SDL_Rect GetRect () {return m_Rect;}
private:
SDL_Surface *m_pScreen; // Zeiger auf den Screen des Frameworks
SDL_Surface *m_pImage; // Das eigentliche Bild des Sprites
SDL_Rect m_Rect; // Rect des Sprites
SDL_Rect m_FrameRect; // Ausschnitt für Animationsphase
int m_NumFrames; // Anzahl der Animationsphasen
int m_FrameWidth; // Breite einer Animationsphase
int m_FrameHeight; // Höhe einer Animationsphase
int m_NumFramesX; // Wie viele Anim-Phasen in X-Richtung?
};
#endif

Alles anzeigen

Sprite.cpp

Quellcode

#include "Sprite.hpp"
// Konstruktor
//
// Aufgabe: Zeiger auf Screen holen
//
CSprite::CSprite ()
{
// Zeiger auf Screen holen
m_pScreen = g_pFramework->GetScreen ();
} // Konstruktor
// Destruktor
//
// Aufgabe: Surface des Sprites freigeben
//
CSprite::~CSprite ()
{
// Surface freigeben
SDL_FreeSurface (m_pImage);
} // Destruktor
// Load
//
// Aufgabe: Einfaches, nicht animiertes Sprite laden
//
void CSprite::Load (const string sFilename)
{
// Bitmap laden
m_pImage = SDL_LoadBMP (sFilename.c_str () );
// Prüfen, ob alles glatt ging
if (m_pImage == NULL)
{
cout << "Fehler beim Laden von: " << sFilename.c_str ();
cout << endl;
cout << "Fehlermeldung: " << SDL_GetError () << endl;
// Framework herunterfahren
g_pFramework->Quit ();
// Gesamtes Spiel beenden
exit (1);
}
// Rect initialisieren
m_Rect.x = 0;
m_Rect.y = 0;
m_Rect.w = m_pImage->w;
m_Rect.h = m_pImage->h;
} // Load
// Load
//
// Aufgabe: Animiertes Sprite laden
//
void CSprite::Load (const string sFilename, int NumFrames,
int FrameWidth, int FrameHeight)
{
// Bitmap laden
Load (sFilename);
// Rect für Animationsphase initialisieren
m_NumFrames = NumFrames;
m_FrameWidth = FrameWidth;
m_FrameHeight = FrameHeight;
m_FrameRect.w = FrameWidth;
m_FrameRect.h = FrameHeight;
m_NumFramesX = m_pImage->w / m_FrameWidth;
} // Load
// SetColorKey
//
// Aufgabe: Transparente Farbe festlegen
//
void CSprite::SetColorKey (int R, int G, int B)
{
// Colorkey einstellen
SDL_SetColorKey (m_pImage, SDL_SRCCOLORKEY,
SDL_MapRGB (m_pImage->format, R, G, B) );
} // SetColorKey
// SetPos
//
// Aufgabe: Position des Sprites festlegen
//
void CSprite::SetPos (float fXPos, float fYPos)
{
// Rect updaten
m_Rect.x = static_cast<int>(fXPos);
m_Rect.y = static_cast<int>(fYPos);
} // SetPos
// Render
//
// Aufgabe: Sprite rendern (ohne Animation)
//
void CSprite::Render ()
{
// Sprite rendern
SDL_BlitSurface (m_pImage, NULL, m_pScreen, &m_Rect);
} // Render
// Render
//
// Aufgabe: Ausschnitt des Sprites rendern (Animationsphase)
//
void CSprite::Render (float fFrameNumber)
{
// Ausschnitt der aktuellen Animationsphase berechnen
//
// Spalte berechnen
int Column = static_cast<int>(fFrameNumber)%m_NumFramesX;
// Zeile berechnen
int Row = static_cast<int>(fFrameNumber)/m_NumFramesX;
// Rect berechnen
m_FrameRect.x = Column * m_FrameWidth;
m_FrameRect.y = Row * m_FrameHeight;
// Ausschnitt rendern
SDL_BlitSurface (m_pImage, &m_FrameRect, m_pScreen, &m_Rect);
} // Render

Alles anzeigen

Sagt mir mal bitte, wo da der Sprite geladen wird? Sicher, ich sehe auch den Abschnitt wo es geladen wird, aber wo ist da bitte der Name des *.bmp Files?
ich sehe auch das dieser in sFilename zu sein scheint.
Könnte mir vielleicht wer ein "besseres" Beispiel geben um einen Sprite einer Klasse zuzuordnen, zu laden und an zu zeigen?

PS: Ja, es gibt noch Framework.hpp und Framework.cpp aber dort wird der Name auch nicht bestimmt.

bcc-fan · 5. Dezember 2010, 15:36

In welcher deiner Dateien steht denn

Quellcode

int main () // oder
int main (void) // oder ähnliches

MfG bcc-fan

Checkmateing · 5. Dezember 2010, 16:13

In der main.cpp
Soll ich mal alle Codes posten?
Ich fand es bisschen lang, deshalb hab ich nur die Sprite.hpp und die Sprite.cpp vom BUCH gepostet. Das war nur ein Beispiel. ich möchte nicht mit dem Game anfangen, ehe ich nicht genau weiß wie ich einen Sprite laden kann....

pocky · 5. Dezember 2010, 18:48

Du hast da nur ein Klasse für Sprites erstellt...
Durch abtippen lernst du rein gar nichts, selbst denken und schreiben, dann verstehst du auch was das alles soll
Du könntest damit ein Sprite erstellen, und dann mit

sprite.Load("einbild.bmp");

ein Bild laden. (wobei "sprite" hier ein element der Klasse CSprite sein muss)

Wobei ich dir rate da SDL_Image zu verwenden, dann kannst du statt SDL_LoadBMP -> IMG_Load verwenden, was auch jpg, png, tiff etc laden kann

Checkmateing · 5. Dezember 2010, 19:40

Man versteht zwar immer noch nicht das es nur ein Beispiel nicht bezogen auf mein Game ist, aber dein Post bringt mich eine Ecke weiter.
Gibt es noch einfachere Wege?

pocky · 6. Dezember 2010, 18:30

Einfachere Wege für was?

Checkmateing · 6. Dezember 2010, 21:43

Um den Sprite zu laden, zuzuordnen und anzeigen zu lassen.

pocky · 7. Dezember 2010, 17:14

Selbst ne einfachere Klasse schreiben wäre wohl das einfachste

Checkmateing · 7. Dezember 2010, 19:40

Meinte ich nicht, aber danke

pocky · 7. Dezember 2010, 21:02

Naja, was ist denn einfach als

spriteclass sprite;

sprite.load("blub.png");
sprite.pos(100,100);
sprite.draw(screen);

einfacher gehtz ja wohl net

das zeug was des macht, muss man ja nur einmal schreiben

Checkmateing · 7. Dezember 2010, 21:06

sprite.draw kannte ich nicht.
Da gehts schon los

pocky · 8. Dezember 2010, 07:48

das war auch nur ne pseudeklasse, die nichts mit deiner zu tun hat, bei deiner da oben geht das so:

CSprite sprite;
sprite.Load("bild.bmp");
sprite.SetPos(13, 37);
sprite.Render();

also eig genauso, nur halt andere namen
also doch sehr bequem
man kann sich nur eines sparen, und zwar wenn man das Load gleich mit in den Konstruktor nimmt, dann spart man sich die sprite.Load Zeile, dafür ist die Initialisierung des Klassenvariable etwas länger

Sprites laden und anzeigen

Sprites laden und anzeigen

Quellcode

Quellcode

Quellcode

Teilen

Benutzer online 1

Tags