ID in meiner Kugel Klasse?

[Raidenkk]

Hey,
mein nächstes Spiel soll ein Spiel werden wo es Ziel ist 3 gleichfarbige Kugeln nebeneinander zu kriegen und somit zu Zerstören.
Jetzt sitze ich hier an der Klasse meier Kugeln und bin mich am Fragen ob es schlau währe jede Kugel eine ID zu verpassen.
Währe dem so? oder ist es einfach sinnlos in meinem Spiel IDs für jegliche Kugel zu machen?

CKugel.hpp

Code: Alles auswählen

// ############################################
//	Headerdatei: CKugel.hpp
// ############################################

class CKugel
{
	private:
		// Membervariablen
		int m_Farbe;	// Kugel Farbe
		int m_X;		// X-Koordianten
		int m_Y;		// Y-Koordinaten

	public:
		// Memberfunktionen
		CKugel (int Farbe, float X, float Y);				
}

CKugel.cpp

Code: Alles auswählen

// ############################################
//	Quelldatei: CKugel.cpp
// ############################################

#include <SFML\Graphics.hpp>
#include "CKugel.hpp"
#include <iostream>

using namespace std;


// Konstruktor
CKugel::CKugel (int Farbe, float X, float Y)
{
	// Startwerte setzen
	m_Farbe = Farbe;
	m_X = X;
	m_Y = Y;
}

Ich habe nebenbei mal meine derzeitige Klasse gepostet damit ihr mir vielleicht Tipps geben könntet.

MFG:
Kevin/Raidenkk

[kaiserludi]

Was spricht dagegen, mit dem Hinzufügen der ID zu warten, bis du sie für irgendwas brauchst? Falls das nie der Fall sein sollte, wird sie dann eben nie hinzugefügt.

[dot]

Müssen die Kugeln tatsächlich als Objekte einer Klasse modelliert werden? Der Projektbeschreibung nach, wäre ein einfaches Array aus int evtl. ausreichend!?

[Raidenkk]

Ja klar würde es ausreichen einfach arrays zu nehmen und die voll zu hauen aber da ich noch ein noob bin was klassen angeht würde ich Klassen sehr gerne genau jetzt verwenden :P

EDIT:
Ehm noch eine kleine Frage ich müsste jetzt für jedes Bild in meiner main.cpp folgendes schreiben um ein Sprite zu machen.

sf::Image Image_Kugel_Blau;
Image_Kugel_Blau.Loadfromfile ("gfx/Kugel_Blau.png");

sf::Sprite Sprite_Kugel_Blau;
Sprite_Kugel_Blau.SetImage (Image_Kugel_Blau);

nur ist das nervig weil das daten laden total meine main.cpp zuballert jemand eine Idee wie ich das besser meistern könnte?

[dot]

Ja klar würde es ausreichen einfach arrays zu nehmen und die voll zu hauen aber da ich noch ein noob bin was klassen angeht würde ich Klassen sehr gerne genau jetzt verwenden :P

Klassen zu verwenden einfach nur um Klassen zu verwenden, ist jetzt aber nicht grad die beste Idee ;)

[...] nur ist das nervig weil das daten laden total meine main.cpp zuballert jemand eine Idee wie ich das besser meistern könnte?

Wie wärs wenn du das in einer Klasse kapselst ;)

[Raidenkk]

Hmm ich würde jetzt sicher sagen gute idee nur kann ich mir kein Bild machen wie das aussehen soll dieses Klasse kapseln :P

[kaiserludi]

Was mir gerade noch auffällt: Brauchen die Positionsdaten wirklich Nachkommastellen? Bei den meisten Spielen dieser Art hat man doch feste Spielfelder wie z.B. 20x20. Da interessiert es doch weniger, auf welcher Position auf der X-Achse und Y-Achse die Kugel ist, sondern mehr, in welchem der möglichen Felder sie sich befindet: Also z.B. das Feld x3/y10. Entsprechend sollte doch ein unsigned char oder schlimmstenfalls ein unsigned short völlig ausreichen: Du sparst entsprechend pro Kuel zum einen 6 Byte, zum anderen ist Itegerarithmetik in der Regel schneller als Floating Point Arithmetik. Wird in deinem Fall vermutlich keine Rolle spielen, da ich annehme, dass du das Spiel nicht für Geräte entwickelst, die du damit an ihre Grenzen bringst, aber es ist trotzdem sinnvoll, sich anzugewöhnen, den Datentypen zu verwenden, den man auch wirklich braucht.

[BeRsErKeR]

Was mir gerade noch auffällt: Brauchen die Positionsdaten wirklich Nachkommastellen? Bei den meisten Spielen dieser Art hat man doch feste Spielfelder wie z.B. 20x20. Da interessiert es doch weniger, auf welcher Position auf der X-Achse und Y-Achse die Kugel ist, sondern mehr, in welchem der möglichen Felder sie sich befindet: Also z.B. das Feld x3/y10. Entsprechend sollte doch ein unsigned char oder schlimmstenfalls ein unsigned short völlig ausreichen: Du sparst entsprechend pro Kuel zum einen 6 Byte, zum anderen ist Itegerarithmetik in der Regel schneller als Floating Point Arithmetik. Wird in deinem Fall vermutlich keine Rolle spielen, da ich annehme, dass du das Spiel nicht für Geräte entwickelst, die du damit an ihre Grenzen bringst, aber es ist trotzdem sinnvoll, sich anzugewöhnen, den Datentypen zu verwenden, den man auch wirklich braucht.

Also mit "Int statt Float" gebe ich dir recht, aber nicht zwangsläufig mit unsigned char bzw. unsigned short. Ich habe gelernt, dass man sich viel zu viele Gedanken über Datentyp-Größen macht und sich somit meist viel zu sehr einschränkt. Es schadet in der Regel nicht für alle möglichen Sachen einfache ints bzw. unsigned ints zu nutzen. Entscheidend sind solche speziellen Datentypen wie unsigned char und unsigned short eigentlich eher beim Lesen von Daten aus einer bzw. Schreiben von Daten in eine Datei. Die paar Bytes tun nicht weh und erübrigen ggf. Umhergecaste (z.B. wenn man Libs nutzt die halt einen anderen Typ nutzen, etc). Im Großteil aller Fälle sind das eh temporäre oder statische Daten.

Eine Ausnahme bildet natürlich ein Fall bei dem es wirklich viel ausmacht (bei riesigen Datenmengen oder kleinem System), aber gerade am Anfang und für so ein kleines Projekt muss man da nicht auf spezielle Typen zurückgreifen. Eine weitere Ausnahme ist, wenn die Variable Daten einer gewissen Größe halten muss, die eventuell ein int nicht fassen kann.

Ich habe Jahre lang immer wieder genau auf die Größen geachtet. Alles mögliche in unsigned char, unsigned short oder unsigned long gepackt (wobei die Größen übrigens auch keineswegs wohldefiniert sind, aber es gibt ja compilerabhängige Ersatztypen bzw. typedefs). Aber den Aufwand ist es nicht wert. Man spart eigentlich nichts und wenn die Daten dann irgendwann doch mal größer werden, muss man wieder nachpflegen. Ein gutes Beispiel ist auch die STL oder viele Standardfunktionen aus C/C++ die fast ausnahmslos Typen wie int oder size_t nutzen, welche plattformabhängig sind. Eine sizeof-Aufruf wird beispielsweise auch eher Werte liefern, die in kleinere Datentypen passen würden.