So, doch schnell nen Blick auf deinen Code geworfen
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
void CMenue::Init ()
{
// Menüsprite erstellen
m_pSpriteMenue = new CSprite;
m_pSpriteMenue->Load ("Data/Hauptmenü.bmp", 0, 800,600);
m_pSpriteMenue->SetColorKey (255, 0, 255);
// Zeiger-Sprite erstellen
m_pSpritePoint = new CSprite;
m_pSpritePoint->Load ("Data/Zeiger.bmp", 0, 64, 64);
m_pSpritePoint->SetColorKey (255, 0, 255);
} // Init
|
Warum packst du das nicht in den Konstruktor? Der wird nunmal beim erstellen des Objektes aufgerufen!
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
void CMenue::Quit ()
{
// Hauptmenü-Sprite freigeben
if (m_pSpriteMenue != NULL)
{
delete (m_pSpriteMenue);
m_pSpriteMenue = NULL;
}
// Zeiger-Sprite freigeben
if (m_pSpritePoint != NULL)
{
delete (m_pSpritePoint);
m_pSpritePoint = NULL;
}
} // Quit
|
Das gehört in den Destruktor! Dann kannst du auch den Aufruf von Quit sparen, da der Destruktor immer (okay fast) beim Zerstören des Objektes aufgerufen wird.
delete NULL ist i.o. und macht einfach garnix.(Laut Standard ...) Von d.h. ist es sinnlos auf NULL zu prüfen!
Dann ist deine Funktion Position sehr kritisch!
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
int CMenue::Position ()
{
int Position=0;
if (Position==0)
{
return 0;
}
else if (Position==1)
{
return 1;
}
else if (Position==2)
{
return 2;
}
else
{
if (Position>2)
{
Position=2;
}
else if (Position<0)
{
Position=0;
}
}
return -2;
}
|
. Im Idealfall wird es auf int CMenue:
osition () { return 0; } optimiert. Das ist im Grunde alles was in deiner Funktion passiert
Wenn die Funktion abgearbeitet wird, wird das Objekt Position zerstört! (davon mal abgesehen das "Position" sowohl als Funktionsname als auch als Bezeichner zu nutzen nicht unbedingt so schlau ist
).
Dann
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
|
else
{
// Animation zurück zum Ausgangspunkt
/*Einfach Nichts tun...*/
m_fYPos+=0;
}
|
ehm ja, dann mach auch einfach nichts und lass den kompletten Ast weg!
Du kommentierst viel unnötig. Benutzt eindeutige Bezeichner für Variablen und Funktionen und kommentier nur Festewerte und komplexe algorithmen. Was selbsterklärend ist, muss nicht kommentiert werden!
Vllt auch werte die zusammengehören in ein std::pair packen ... z.B. bei positionen ...
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
#if !defined(MENU_HPP__INCLUDED)
#define MENU_HPP__INCLUDED
#if (_MSC_VER >= 1000)
#pragma once
#endif // (_MSC_VER >= 1000)
#include "Sprite.hpp"
#include "Shot.hpp"
#include <utility>
typedef std::pair<float, float> position_t;
class Menu
{
CSprite* m_background;
CSprite* m_pointer;
position_t m_position;
public:
Menu();
~Menu()
public:
void reset ();
int position ();
void render();
void update();
private:
void process_shooting();
};
#endif // MENU_HPP__INCLUDED
|
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
#include "Menu.hpp"
Menu::Menu()
: m_background(new CSprite), m_pointer(new CSprite)
{
m_background->Load("Data/Hauptmenü.bmp", 0, 800,600);
m_background->SetColorKey(255, 0, 255);
m_pointer->Load("Data/Zeiger.bmp", 0, 64, 64);
m_pointer->SetColorKey (255, 0, 255);
}
Menu::~Menu()
{
delete m_background;
delete m_pointer;
}
void Menu::reset()
{
// P(200.0f, 200.0f) start position
m_position = std::make_pair(200.0f, 200.0f);
}
int Menu::position()
{
// TODO: Funktion neu schreiben. Inkorrektes verhalten!
}
void Menu::render()
{
m_pointer->SetPos(m_position.first, m_position.second);
m_pointer->Render(m_fAnimPhase);
}
void Menu::update()
{
// move cursor
if (g_pFramework->KeyDown(SDLK_UP))
m_position.second += 10;
else if (g_pFramework->KeyDown (SDLK_DOWN))
m_position.second -= 10;
// check x coord to be valid
if (m_position.first < 200.f)
m_position.first = 200.f;
else if (m_position.first >= 240.f)
m_position.first = 240.f;
}
|
wobei ich an deiner Stelle mal das Klassendesign von Sprite überdenken würde und auch Menu nicht so statisch machen würde. Ließ die Größe deines Menüs aus der Datei aus usw., lass dir die zu ladende Datei als Parameter im Konstruktor angeben ... . Dann ist das alles ein wenig dynamischer!
spieleprogrammierer.de »
Spieleentwicklung und Programmierung »
C, C++, C#, Java und andere Programmiersprachen »
HIER runterladen. Zitat von »"glookie1"«
09.05.2024, 21:51
Zum Seitenanfang
