Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Klassen Design Hilfe

Werbeanzeige

anti-freak

Alter Hase

  • »anti-freak« ist der Autor dieses Themas

Beiträge: 635

  • Private Nachricht senden

1

04.09.2013, 12:32

Klassen Design Hilfe

Guten Tag,
ich habe ein kleines Problem, bei dem ich einen Schubs in die richtige Richtung benötige.
Es ist ein relativ großes und äußerst wichtiges Teilstück meines Projekts, welches ihr in meiner Signatur finden könnt.

Vorweg: Ich erwarte keine Komplettlösung, lediglich einen Fingerzeig, wie man sowas am geschicktesten Lösen kann. Allerdings benötigt es ein gewisses Grundverständnis von Qt, da das GUI eine Teilmenge des Problems darstellt.

Ich habe Prototype Klassen, die praktisch das Template für die im Spiel verwendeten Objecte darstellt. Diese Prototypen besitzen keine Logic, sind also reine Datenspeicher. Diese Prototypen sammel ich in einem Vector als shared_ptr, der in einer weiteren Klasse als Member besteht. Diese "Container" Klasse übernimmt ein paar Aufgaben, die hier allerdings nicht von belang sind. Wichtig ist nur, es muss sie geben.

Wie man bisher also erkennen kann, gibt es als oberste Schicht den Container, der wiederum einen Vector besitzt, welcher Smartpointer auf Prototypen speichert.
Da es allerdings nicht nur einen Prototyp gibt, sondern sehr sehr viele die von einander erben (alle besitzen mindestens eine ID und einen Namen), muss ich den Container als TemplateKlasse auslegen.

Jetzt kommen wir zur GUI. Ich sammel alle IDs und Namen und schiebe sie in ein QAbstraktItemModel. Dieses Model muss nun wieder ein Template sein, da es einen smart_pointer auf die Container Klasse besitzt. Das Model kann ich jetzt aber ohne weiteres in ein QListView oder sonst wo einfügen. Schwierig wird es allerdings wieder, wenn ich andere Daten von meinem Prototypen haben will, wie z.B. bei WorldObjecten die BoundingBox.
Hier strebe ich wieder eine Vererbung an, da die GUIs aufeinander aufbauen.
Jetzt ist es aber so, das:
1. Qt keine Templates in Verbindung mit Q_OBJECT mag
und 2. es für mich einfach nicht zufrieden stellend designed ist.

Jetzt zu meiner eigentlichen Frage:
Wie schaffe ich es also die Templates weitestgehend zu verbannen? Eine Union fällt komplett weg, mir zu Fehleranfällig und es soll später durchaus auch Interfaces nach außen geben.

Sacaldur

Community-Fossil

Beiträge: 2 301

Wohnort: Berlin

Beruf: FIAE

  • Private Nachricht senden

2

04.09.2013, 12:54

Ich finde, dass für das definieren des Klassendesigns der Zweck der verschiedenen Klassen _enorm_ wichtig ist, also auch der Zweck der Containerklasse, die du erwähnt hast. Welche Arten von Referenzen (Refernzen, Pointer, shared_ptr, unique_ptr) sich dann anbieten und ob Tamplates erforderlich sind, kann man danach wesentlich besser einschätzen. (Es kann auch ein anderes Forum gewesen sein, allerdings habe ich bereits miterlebt, dass jemand für Texturen (bzw. Verweise auf diese) eine redundante Speicherung und somit shared_ptr verwenden wollte, obwohl es auch möglich war, die Informationen nur einmal vorzuhalten und alle Aktionen darauf durchzuführen.)
Sind deine Prototypen verschiedene Klassen oder Objekte einer einzelnen Klasse? Was machen diese? Wofür dienen sie als Vorlage? Ich habe allgemein ein paar Probleme nachzuvollziehen, wie dein Code aussehen könnte oder was er am Ende machen soll.
Aber eine Frage habe ich zumindest noch: muss denn ein Template auch dann verwendet werden, wenn man nur Elemente verwenden will, die sich in der Vererbungshirarchie unterhalb einer bestimmte Klasse befinden? (Stichwort Polymorphie)
Spieleentwickler in Berlin? (Thema in diesem Forum)
---

Zitat von »Jonathan_Klein«

Es ist ja keine Schande etwas falsch zu machen, als Programmierer tu ich das täglich, [...].

anti-freak

Alter Hase

  • »anti-freak« ist der Autor dieses Themas

Beiträge: 635

  • Private Nachricht senden

3

04.09.2013, 13:22

Der Container ist, wie bereits erwähnt, nur für bestimmte Verwaltungsaufgaben erforderlich, die mir Vector nicht direkt anbietet. Er stellt einen bestimmten setter zur Verfügung, der mir den Vector gegebenen falls resized, ebenso wie er ID zu vector Index umwandelt (ID = Index+1). Ist allgemein nicht weiter spektakulär, nur eben ein Ebene die mir ein wenig Arbeit ab nimmt.
Der Vector ist im Container einfach nur ein Member. Der Container reicht bisher den Template Parameter an den Vector weiter.

Hier mal ein wenig Beispielcode:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

template <typename T>
class Container
{
protected:
    inline void setMaximumSize(uint32 uiMaxSize) { m_uiMaxSize = uiMaxSize; }

public:
    Container() : m_uiMaxSize(1000000)      // set maximum size to 1 million; User certainly has to go, that there is enough memory.
    {}

    virtual void clear() { m_Items.clear(); }

    const std::vector<std::shared_ptr<T>>& getItems() const { return m_Items; }
    virtual void setItem(uint32 ID, std::shared_ptr<T> &item)
    {
        if (ID)
        {
            try
            {
                if (--ID >= getSize())
                    resize(ID+1);
                m_Items.at(ID) = item;
            }
            catch (const std::length_error&) {}
        }
    }

    bool getItem(uint32 ID, std::shared_ptr<const T> &result) const
    {
        if (hasValidItem(ID))
        {
            result = m_Items.at(ID-1);
            return true;
        }
        return false;
    }

    bool getItem(uint32 ID, std::shared_ptr<T> &result)
    {
        std::shared_ptr<const T> temp;
        if (const_cast<const GapsContainer<T>&>(*this).getItem(ID, temp))
        {
            result = std::const_pointer_cast<T>(temp);
            return true;
        }
        return false;
    }

    inline bool hasValidItem(uint32 ID) const
    {
        return ID && --ID < getSize() && ID < getMaximumSize() && m_Items.at(ID);
    }

    inline uint32 getSize() const { return m_Items.size(); }
    inline uint32 getMaximumSize() const { return std::min(m_uiMaxSize, m_Items.max_size()); }
    virtual void resize(uint32 size)
    {
        if (size <= getMaximumSize())
            m_Items.resize(size);
        else
            throw std::length_error("The requested size is greater than the maximum.");
    }

private:
    uint32 m_uiMaxSize;

protected:
    std::vector<std::shared_ptr<T>> m_Items;
};

Das ist meine Cotainer Klasse. Nicht weiter spektakulär, wie ich finde. Poste sie nur der Vollständigkeit halber.

uint32 ist btw ein typedef für unsigned int.

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

class Prototype
{
public:
    Prototype(uint32 ID) : m_ID(ID) {}

    inline void setName(const QString &sName) { m_sName = sName; }
    inline QString getName() const { return m_sName; }
    inline uint32 getID() const { return m_ID; }
    inline void setID(uint32 ID) { m_ID = ID; }

private:
    uint32 m_ID;
    QString m_sName;
};

class WorldObjectPrototype : public Prototype
{
public:
   WorldObjectPrototype(uint32 ID = 0) : Prototype(ID), m_uiMovementSpeed(32) {}

   inline void setMovementSpeed(uint16 uiSpeed) { m_uiMovementSpeed = uiSpeed; }
   inline uint16 getMovementSpeed() const { return m_uiMovementSpeed; }

private:
   uint16 m_uiMovementSpeed;
};


Jetzt habe ich mit

C-/C++-Quelltext

 
1

typedef Container<WorldObjectPrototype> WorldObjectPrototypeContainer;

mir meine neue Database erstellt. Ist ja durchaus auch praktikabel, nur eben leider nicht weit genug gedacht. Weil spätestens bei der GUI muss ich dann hässliche workarounds zaubern.
Wie also vorgehen, wenn man redundanten Code verhindern möchte, aber sich gleichzeitig nicht zu sehr an Templates binden will?

Mir ist es auch durchaus bewusst, das ich Polymorphie einsetzen könnte, aber dann müsste ich eben wieder sicherstellen, das eben nur die gewünschten Daten im Container landen. Da man, soweit ich weiß, nicht sicherstellen kann, das eine virtual public Methode NICHT aufgerufen werden kann (zwecks Rückgabewert überschreiben), fällt das ja leider weg?! Oder irre ich mich und die Lösung ist einfacher als gedacht?

EDIT: Die Prototypen sind natürlich eine abgespeckte Variante. Allerdings sind sie, wie bereits erwähnt, reine Datenspeicher (mal nur Basistypen, ab und an auch Klassen/Structe).

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »anti-freak« (04.09.2013, 13:31)

Sacaldur

Community-Fossil

Beiträge: 2 301

Wohnort: Berlin

Beruf: FIAE

  • Private Nachricht senden

4

04.09.2013, 13:58

Ich hatte mir eher erhofft, dass du den Zweck schreibst, für den du den Code geschrieben hast (bspw. "das Sicherstellen, dass Texturen nur jeweils 1x geladen werden" oder "das Automatische Zwischenspeichern von Daten, wenn Änderungen stattfinden", also auf abstrakter Ebene). Code sollte für eine solche Beschreibung eigentlich nicht notwendig sein, aber da war ich mit meiner Aussage wohl auch ein wenig fehlleitend.

Jetzt finde ich die Bezeichnungen "Prototype" und "WorldObjectPrototype" noch nichtssagender als vorher. Ein Prototyp ist, soweit ich weiß, eine Vorlage oder ein erster Entwurf eines finalen Objekts. Objekte dieser Klasse (oder einer abgeleiteten Klasse) sind also "Prototypen" - wofür? Kann es sein, dass "Prototype" in deinen Klassennamen einfach ein wenig fehl am Platz ist? wäre sowas wie "WorldObject" nicht etwas passender? (Ich gehe einfach mal davon aus, dass Objekte dieser oder einer der abgeleiteten Klassen Objekte sind, die sich in der Spielwelt befinden sollen.)
Die Benennung der Klassen ist zwar nicht relevant für die funktionstüchtigkeit oder das Klassendesign, allerdings kann eine ungünstige Benennung zu Verständnisproblemen führen (die ich meinerseits als gegeben sehe).

Abgesehen davon: du schreibst zwar von Problemen mit Qt, allerdings sehe ich nicht, wo bei dir Qt ins Spiel kommt. Vlt. liegt es auch daran, dass ich bisher nicht mit QT gearbeitet habe und ich dadurch nicht automatisch auch die Methoden kenne, die häufig Probleme bereiten, aber auf Anhieb kann ich mir nicht vorstellen, wo Probleme zu Stande kommen oder wo du irgendwas von den Klassen anzeigen wollen würdest...
Spieleentwickler in Berlin? (Thema in diesem Forum)
---

Zitat von »Jonathan_Klein«

Es ist ja keine Schande etwas falsch zu machen, als Programmierer tu ich das täglich, [...].

anti-freak

Alter Hase

  • »anti-freak« ist der Autor dieses Themas

Beiträge: 635

  • Private Nachricht senden

5

04.09.2013, 14:24

Hatte ich das nicht beschrieben?
Ein Prototyp bei mir, ist genau das, was du beschreibst. Eine einmalige Vorlage für ein Object, was im Spiel verwendet wird. Es gibt im Spiel z.B. eine Klasse "WorldObject" die eben die Daten aus dem WorldObjectPrototype übernimmt und gegebenenfalls verarbeitet. Das Prototype ist lediglich zur Speicherung von Daten, die ich im Editor angebe, da.

Was ich damit erreichen möchte? Ich stelle dem Nutzer verschiedene Input Widgets (in der GUI) zur Verfügung, die er nach gewissen Regeln benutzen darf (wenn Zahlen gefordert werden, darf eben kein String eingegeben werden, etc. Ist allerdings eine andere Ebene). Den Input speichere ich dann im Prototype. Dieses Prototype kann, wie beschrieben, basis Typen als auch komplexere Typen speichern, je nachdem wie ich es definiere.
Jeder Prototype Typ wird in einem separatem Container gespeichert.
Mein Problem ist es jetzt einfach, dass ich das Template durch mein komplettes Projekt schleppen muss, da die GUI davon Kenntnis haben muss, und auch innerhalb des restlichen Projekts darauf zugegriffen werden muss.
Wie bereits erwähnt, ist es nicht möglich eine komplexe Qt GUI als Template zu nutzen, weswegen ich dazu schon workarounds schreiben musste, die in meinen Augen nicht sinnig/elegant sind.
Es stimmt, den Zusammenhang zwischen Qt und meinem Problem habe ich nicht sonderlich gut beschrieben.

Mein Kernproblem befindet sich aber außerhalb. Wichtig ist nur zu wissen, das ich statt eines Template Containers gerne einen Polymorphen Container hätte, weil dieser sich besser verwenden lässt.

Meine Idee war jetzt eine Ableitung der oben geposteten Container Klasse, die sicher stellt, das ich nur z.B. shared_ptr<WorldObjectPrototyp> übergebe, und mir eben solche auch wieder zurück gibt. Meines Wissens nach geht so etwas nicht, und zusätzlich müsste ich casten, was einigen auch wieder Tränen in die Augen treiben würde.

Sacaldur

Community-Fossil

Beiträge: 2 301

Wohnort: Berlin

Beruf: FIAE

  • Private Nachricht senden

6

04.09.2013, 15:57

Ich weiß nicht, an welcher Stelle unser Verständnis auseinander geht. Vermutlich liegt es wohl daran, dass bei dir diese "Prototypen" nicht als Vorlage für irgendetwas dienen und dann ohne Ende dupliziert/kopiert werden, sondern nur zur Speicherung der Daten dienen, die dann ausschließlich von anderen Klassen verarbeitet werden (bspw. eine für die Logik, wie Bewegung, und eine für Darstellung). Wenn das der Fall ist, solltest du dein Prototype und WorldObjectPrototype in AbstractModel/ModelBase/IModel und WorldObjectModel o. ä. umbenennen. Und du solltest dir Gedanken machen, ob es einen Grund für die Aufteilung gibt.

Warum verwendest du für jeden Typ (also für alle Objekte einer einzelnen Klasse) eine eigene Instanz deines Containers? Warum kannst du nicht einen einzigen (bspw. Container<Prototype>/Container<ModelBase>) verwenden?

Was den Zweck angeht:
Du hast ein Problem, weshalb du hier um Rat gefragt hast. Dieses Problem entsteht, weil du versuchst, eine Lösung für die eigentliche "Aufgabe"/"Anforderung"/... umzusetzen, dies aber so (noch) nicht funktioniert. Ich würde jetzt gerne eine Beschreibung der Aufgabe haben, bei deren Lösung du das Problem hast. Dazu sollte es nicht notwendig sein, auf irgendeine Programmiersprache einzugehen. Das könnte dann wie folgt aussehen: "Mein Charakter soll sich in seiner Umgebung bewegen, die tile-basiert ist und Objekte beinhaltet, die eine beliebige Größe haben und sich unabhängig vom Raster bewegen können.", "Wenn auf diesen Button geklickt wird, soll sich das nächste Menü von rechts nach links ins Bild schieben, während das vorherige sich zur linken Seite heraus schiebt", "Der Benutzer soll über die Oberfläche seine Objekttypen definieren können. Diese sollen in einer Hirarchie stehen, wobei die definierten Variablen an darunterliegende Typen weitergereicht werden können. Im Leveleditor des Tools soll er diese Typen nur noch in das Level ziehen müssen und kann dann deren Werte bestimmen. ..." usw.

"[Es ist nicht möglich], eine komplexe QT GUI als Template zu nutzen, [...]": vielleicht liegt es daran, dass ich mit den Templates in C++ bisher nie gearbeitet habe und meine Erfahrungen damit daher äußerst begrenzt sind, allerdings weiß ich nicht, was du damit ausdrücken willst. Du kannst aus einer komplexen GUI (also mehrere Objekte, die einander referenzieren) kein Template machen? (Das ist wohl eher weniger gemeint, da die Mechanismen der Templates sich, soweit ich weiß, auf Typen beziehen.)


Auch wenn ich nicht weiß, wie genau die Anforderungen lauten, würde ich einfach mal wild etwas in den Raum werfen:
Du könntest dir eine einzige Klasse schreiben, die die benötigten Variablen verwalten kann. Der muss lediglich mitgeteilt werden, was die Namen dieser sind und welche Typen diese haben, damit diese dann in einem assoziativen Array verwaltet werden können. Für die Definition, welche Variablen mit welchen Typen vorhanden sind, könnte es eine weitere Klasse geben.
Das Problem dabei ist allerdings, dass das Handling ziemlich unschön werden könnte, selbst wenn man das Speichern und Laden dieser Daten ersteinmal außen vor lässt.
Spieleentwickler in Berlin? (Thema in diesem Forum)
---

Zitat von »Jonathan_Klein«

Es ist ja keine Schande etwas falsch zu machen, als Programmierer tu ich das täglich, [...].

anti-freak

Alter Hase

  • »anti-freak« ist der Autor dieses Themas

Beiträge: 635

  • Private Nachricht senden

7

05.09.2013, 09:27

Irgendwie scheinst du nicht ganz zu verstehen, worauf ich hinaus will.

Zitat von »Sacaldur«

"[Es ist nicht möglich], eine komplexe QT GUI als Template zu nutzen, [...]": vielleicht liegt es daran, dass ich mit den Templates in C++ bisher nie gearbeitet habe und meine Erfahrungen damit daher äußerst begrenzt sind, allerdings weiß ich nicht, was du damit ausdrücken willst. Du kannst aus einer komplexen GUI (also mehrere Objekte, die einander referenzieren) kein Template machen? (Das ist wohl eher weniger gemeint, da die Mechanismen der Templates sich, soweit ich weiß, auf Typen beziehen.)

Als kurze Erklärung, WARUM ich in Qt keine (oder nur sehr beschränkt) Widgets als template nutzen kann:
Qt verwendet ein eigenes Signal/Slot System. Damit dieses ordnungsgemäß funktionieren kann, benötigt es in der Klasse, die solche signals/slots deklariert, das Makro Q_OBJECT. Dieses Makro kann nicht in Templateklassen benutzt werden. Da es das Grundprinzip ist, das Widgets über signals/slots kommunizieren, habe ich letztendlich einige davon und muss das Makro nutzen. Das ist der Grund, warum ich aus der Klasse kein Template machen kann.

Zitat von »Sacaldur«

Ich weiß nicht, an welcher Stelle unser Verständnis auseinander geht. Vermutlich liegt es wohl daran, dass bei dir diese "Prototypen" nicht als Vorlage für irgendetwas dienen und dann ohne Ende dupliziert/kopiert werden, sondern nur zur Speicherung der Daten dienen, die dann ausschließlich von anderen Klassen verarbeitet werden (bspw. eine für die Logik, wie Bewegung, und eine für Darstellung). Wenn das der Fall ist, solltest du dein Prototype und WorldObjectPrototype in AbstractModel/ModelBase/IModel und WorldObjectModel o. ä. umbenennen. Und du solltest dir Gedanken machen, ob es einen Grund für die Aufteilung gibt.

Es gibt sogar einen sehr guten Grund, für die Aufteilung. Ein WorldObject kann und macht mehr als ein WorldObjectPrototype. Es besitzt die Logiken und kapselt die Daten komplett anders. Während man auf ein Prototype relativ einfachen Zugriff auf alle Daten hat und diese manipulieren kann, gibt es bei WorldObjects viel mehr Restriktionen. Zusätzlich haben WorldObjects und WorldObjectsPrototype komplett unterschiedliche Aufgaben. Das eine ist dazu da, das andere möglichst einfach zu beschreiben, das andere ist für Bestandteil der GameLogic.
Beispielhaft nenne ich hier mal die Animationen. Während im Prototype lediglich eine ID auf die Animation gespeichert wird, hat das fertige WorldObject eine komplexe Klasse als Member.
Ich bin mit diesem Teil des Designs eigentlich recht zufrieden und habe nicht vor, das zu ändern. Ein Model/Prototyp macht eben nichts von alleine, sondern ist nur eine Schablone. Ob ich das jetzt Model oder Prototyp nenne ist meiner Meinung nach völlig egal. Wenn man sich ein wenig eingearbeitet hat, erkennt man die Zusammenhänge.

Zitat von »Sacaldur«

Warum verwendest du für jeden Typ (also für alle Objekte einer einzelnen Klasse) eine eigene Instanz deines Containers? Warum kannst du nicht einen einzigen (bspw. Container<Prototype>/Container<ModelBase>) verwenden?

Weil es von jedem Prototype Typ sehr, sehr viele gibt. Warum sollte ich die unterschiedlichen Typen alle in einen Container stopfen. Zusätzlich erfolgt der Zugriff über die ID, welche dem vector Index+1 entspricht. Würde ich jetzt alle zusammen in einen Container stopfen, wäre diese Art der Referenzierung nicht mehr so einfach möglich.
Uns deswegen nutze ich unterschiedliche Container und zusätzlich möchte ich sicher gehen, das in meinem WorldObjectPrototypeContainer auch wirklich nur WorldObjectPrototypes landen. Ebenso möchte ich bei der Anforderung eines solchen Objects nicht noch lange herum casten, um dann den eigentlichen Typ zu erhalten. Wie bereits beschrieben würde ich das sogar gerne so machen, aber ich kenne keine Möglichkeit, die mir erlaubt, eine public virtual Methode so zu überschreiben, das ich in keinem Fall die Basis Methode aufrufen kann. Soll heißen, wenn die Basis Klasse einen Prototype* erfordert, die abgeleitete Klasse aber ein WorldObjectPrototype* erfordert, kann ich immer noch nur ein Prototype* übergeben (oder liege ich hier falsch? Bin mir gerade gar nicht mehr so sicher...).

Zitat von »Sacaldur«

Was den Zweck angeht:
Du hast ein Problem, weshalb du hier um Rat gefragt hast. Dieses Problem entsteht, weil du versuchst, eine Lösung für die eigentliche "Aufgabe"/"Anforderung"/... umzusetzen, dies aber so (noch) nicht funktioniert. Ich würde jetzt gerne eine Beschreibung der Aufgabe haben, bei deren Lösung du das Problem hast. Dazu sollte es nicht notwendig sein, auf irgendeine Programmiersprache einzugehen. Das könnte dann wie folgt aussehen: "Mein Charakter soll sich in seiner Umgebung bewegen, die tile-basiert ist und Objekte beinhaltet, die eine beliebige Größe haben und sich unabhängig vom Raster bewegen können.", "Wenn auf diesen Button geklickt wird, soll sich das nächste Menü von rechts nach links ins Bild schieben, während das vorherige sich zur linken Seite heraus schiebt", "Der Benutzer soll über die Oberfläche seine Objekttypen definieren können. Diese sollen in einer Hirarchie stehen, wobei die definierten Variablen an darunterliegende Typen weitergereicht werden können. Im Leveleditor des Tools soll er diese Typen nur noch in das Level ziehen müssen und kann dann deren Werte bestimmen. ..." usw.

Mit einfachen Worten? Ich habe eine "Datenbank" (keine MySQL oder sonst was, einfach nur eine Klasse in der die vom Spiel benötigten Daten landen, die als XML Datei gespeichert wird), und diese soll über den Editor vom User in gewissen Grenzen manipulierbar sein. Das heißt, jeder Prototype Typ hat seinen eigenen Container, der vom User bis zu einem Maximum vergrößert und verkleinert werden kann.
Diese Daten aus der Datenbank werden zu Spielbeginn geladen und daraus werden die eigentlichen Objecte des Spiels generiert.
PS: Es funktioniert durchaus! Ich bin nur mit der Struktur nicht zufrieden und deswegen frage ich nach einer Möglichkeit, es besser zu machen.

Zitat von »Sacaldur«

Auch wenn ich nicht weiß, wie genau die Anforderungen lauten, würde ich einfach mal wild etwas in den Raum werfen:
Du könntest dir eine einzige Klasse schreiben, die die benötigten Variablen verwalten kann. Der muss lediglich mitgeteilt werden, was die Namen dieser sind und welche Typen diese haben, damit diese dann in einem assoziativen Array verwaltet werden können. Für die Definition, welche Variablen mit welchen Typen vorhanden sind, könnte es eine weitere Klasse geben.
Das Problem dabei ist allerdings, dass das Handling ziemlich unschön werden könnte, selbst wenn man das Speichern und Laden dieser Daten ersteinmal außen vor lässt.

Darüber habe ich auch schonmal nach gedacht, eine Map<string, Variant> zu basteln und dort alle Member zu lagern. Aber:
1. speichere ich nicht nur basis Typen
2. sollen diese Werte oft genutzt werden
Deswegen greife ich ungern auf eine Map zurück, weil das Performance mäßig ein großer Nachteil ist, und leider auch nicht ganz so flexiebel. Alternativ, wie du schon beschrieben hast, eine Klasse, die jeden geforderten Typ annehmen kann. Aber hier bliebe ebenso nur die Speicherung in einer Map. Über eine referenzierung per Enum hatte ich auch schon nachgedacht, aber hier bliebe das Problem, das ich die Prototype Klassen dann nicht polymorph gestalten könnte, da ich das enum in der Child Klasse nicht erweitern kann, und es damit in redundantem Code enden würde.

mfg

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »anti-freak« (05.09.2013, 09:34)

anti-freak

Alter Hase

  • »anti-freak« ist der Autor dieses Themas

Beiträge: 635

  • Private Nachricht senden

8

05.09.2013, 11:54

Nach dem letzten Post habe ich jetzt ein wenig herum probiert, und es scheint tatsächlich nicht mehr möglich zu sein, eine überschriebene public virtual methode aufzurufen (zumindest nicht ausversehen ;)). Das heißt, ich werde das so umsetzen, das ich mir einen Container<Prototype> als Basis verwende und für jeden Typ davon erbe, und dort die getItem und setItem Methoden überschreibe.
Entschuldige bitte die Verwirrung, die ich verursacht habe, letztendlich lag es nur an meiner Unkenntnis, bzw nicht genug herum probieren ;)

mfg

Werbeanzeige

Ähnliche Themen