Komposition in C++ für ein Game

DocShoe

brotbernd schrieb:

Das ist sowas ähnliches wie Strategy.

... und heisst Factory Pattern.

brotbernd

DocShoe schrieb:

... und heisst Factory Pattern.

Hm, das musst Du mir jetzt aber erklären.
Ich hatte mich auf seinen Ansatz bezogen:

icarus2 schrieb:

class Moveable{ player_move(...); fast_move(...); };
class Sprite
{
private:
pointer_to_Moveable_fct

public:
void move(); // In dieser Methode wird dann die entsprechende move Methode aufgerufen.

set_move_fct(...)
}

DocShoe

Wenn ich das alles richtig verstanden habe gibt es ein Movement Objekt, das in diesem Beispiel 2 move Methoden hat: player_move und fast_move. Ich habe die beiden Methoden move_player und move_sprite genannt.

// Interface für Mover Klassen. Die Speicherverwaltung lasse ich aussen vor, 
// da kann man mit Sicherheit was Hübsches mit smart pointern basteln.
// Das Mover Objekt ist global, dass kann man sicher auch noch besser 
// unterbringen.

// Abstrakte Mover Klasse. Ein Mover Objekt enthält ein Set von 
// Methoden zum Bewegen von verschiedenen Objekten (hier: Player und Sprite).
struct IAbstractMover
{
   virtual ~IAbstractMover();

   virtual void move_player( Player& op ) = 0;
   virtual void move_sprite( Sprite& op ) = 0;
};

// konkrete Implementaion des Move Interface: Typ 1 Mover
struct CrawlSlowlyMover : public IAbstractMover
{
   void move_player( Player& op );
   void move_sprite( Sprite& op );
};

// konkrete Implementaion des Move Interface: Typ 2 Mover
struct RunReallyFastMover : public IAbstractMover
{
   void move_player( Player& op );
   void move_sprite( Sprite& op );
};

IAbstractMover* GlobalMover = new RunReallyFastMover ();

void f()
{
  Player p;
  Sprite s;

   // Player bewegen
   GlobalMover->move_player( p );

   // Sprite bewegen
   GlobalMover->move_fast( s );
}

So, und nachdem ich das alles hier geschrieben habe glaube ich, dass es vollkommener Murks ist. Es sei denn, OP möchte das Bewegungsverhalten aller Objekte global ändern, ansonsten ist das Strategy Pattern wohl die richtig Lösung :p Obwohl... wenn ich mir Beitrag #3 ansehe könnte er fast sowas haben wollen.

Normalerweise würde man für die Erzeugung des konkreten Mover Objektes eine Fabrik (IAbstractMoverFactory/CrawlSlowlyMoverFactory/RunReallyFastMoverFactory) benutzen, daher der Name Factory Pattern.

Edit: Nach 30 Sekunden Nachdenken ist mir aufgefallen, dass das alles großer Käse ist. Die Factory sollte eigentlich Player und Sprites mit entsprechenden Eigenschaften erzeugen, statt das Bewegungsverhalten zu bestimmen. Das konkrete Bewegungsverhalten kann man durch das Strategiemuster umsetzen. Es gäbe also verschiedene Factories, die zum Erstellen von Player/Sprite Objekten benutzt wird und je nach Factory Typ die Player/Sprite Objekte mit unterschiedlichen Move Eigenschaften ausstattet (gern per Strategy Pattern).
Ich lass den Blödsinn trotzdem mal stehen... hatte etwas wenig Schlaf letzte nacht.

brotbernd

DocShoe schrieb:

Edit: Nach 30 Sekunden Nachdenken ist mir aufgefallen, dass das alles großer Käse ist.

Ja also Dein Code ist weder Factory noch Strategy. Es ist... weiß nicht. kennich nicht
Im entferntesten hat es Ähnlichkeit mit Visitor. Dazu müssten Player und Sprite von Basexyz erben und der Mover würde etwas wie

struct CrawlSlowlyMover 
{
 void Move(Basexyz& x)
 {
   x.Accept(*this);
 }
 void Visit(Player& p)
 {
   MovePlayer(p);
 }
 void Visit(Sprite& s)
 {
   MoveSprite(s);
 }
...

Das würde aber auch nicht mehr Sinn machen

Vorrausgesetzt man kann das Bewegen aller Objekte in ein Strategieobjekt auslagern, ist das klassiche Strategiemuster wie schon gezeigt wurde ein ordentlicher Ansatz.

DocShoe

Können wir uns auf sowas einigen?

// forward declaration
class IAbstractMoveable;

struct IAbstractMover
{
   virtual~ IAbstractMover() 
   {
   };

   virtual void move( IAbstractMoveAble& Object ) = 0;
};

struct SlowMover : IAbstractMover
{
   void move( IAbstractMoveAble& Object )
   {
      // Objekt bewegt sich langsam
   }
};

struct NormalMover : IAbstractMover
{
   void move( IAbstractMoveable& Object )
   {
      // Objekt bewegt sich normal
   }
};

struct FastMover : IAbstractMover
{
   void move( IAbstractMoveAble& Object )
   {
      // Objekt bewegt sich schnell
   }
};

class IAbstractMoveable
{
   // Strategy Pattern: konkreter Mover übernimmt die Bewegung des Objekts
   IAbstractMover* Mover_;

public:
   IAbstractMoveable() : Mover_( 0 )
   {
   }

   virtual ~IAbstractMoveable() 
   {
   }

   void set_mover( IAbstractMover* Mover )
   {
      // neues Mover Objekt setzen
      Mover_ = Mover;
   }

   void move()
   {
      // Strategy Pattern: Mover Objekt ist für 
      // die tatsächliche Bewegung verantwortlich
     if( Mover_ ) Mover_->move( *this );
   }	
};

struct Player : public IAbstractMoveable
{
};

struct Spriter : public IAbstractMoveable
{
};

sruct IAbstractObjectFactory
{
   virtual ~IAbstractObjectFactory()
   {
   }

   virtual Player* create_player() = 0;
   virtual Sprite* create_sprite() = 0;
};  

struct EasyObjectFactory : IAbstractObjectFactory
{
   Player* create_player() 
   {
      Player* p = new Player(); 
      p->set_mover( new NormalMover() ); 
      return p;
   }

   Sprite* create_sprite()
   {
      Sprite* s = new Sprite();

      // Easy Mode: Sprites bewegen sich langsamer als der Spieler
      s->set_mover( new SlowMover() );
      return s;
   }
};

struct EasyObjectFactory : IAbstractObjectFactory
{
   Player* create_player() 
   {
      Player* p = new Player();
      p->set_mover( new NormalMover() );
      return p;
   }

   Sprite* create_sprite()
   {
      Sprite* s = new Sprite();

      // Normal Mode: Sprites bewegen sich genauso schnell wie der Spieler
      s->set_mover( new NormalMover() );
      return s;
   }
};

struct HardObjectFactory : IAbstractObjectFactory
{
   Player* create_player() 
   {
       Player* p = new Player();
       p->set_mover( new NormalMover() );
       return p;
   }

   Sprite* create_sprite()
   {
      Sprite* s = new Sprite();

      // Hard Mode: Sprites bewegen sich schneller als der Spieler
      s->set_mover( new FastMover() );
      return s;
   }
};

Das ist eigentlich das, worauf ich hinaus wollte. In Abhängigkeit des Schwierigkeitsgrades wird eine Objektfabrik erzeugt, die für die Erzeugung von Spielobjekten verantwortlich ist. Jedes erzeugte Spielobjekt erhält Defaulteigenschaften, die von der Objektfabrik abhängen, aber zu Laufzeit noch geändert werden können (z.B. Geschwindigkeitsbonus/-malus).

Ich bin vorhin davon ausgegangen, dass der OP für alle bestehenden Objekte das Bewegungsverhalten global ändern wollte, statt es individuell für einzelne Objekte zu ändern. Daher das Movement Objekt, das für die Bewegung aller Objekte eines bestimmten Typs verantwortlich ist und für jeden Objekttyp eine eigene move Methode anbietet. Mit Visitor Pattern hat das nichts zu tun, ist einfach nur eine Überladung für jeden bewegbaren Objekttypen. Das ist natürlich längst nicht so flexibel, da es die Bewegung für alle Objekte eines bestimmten Typs festlegt und keine individuelle Behandlung zulässt.

PS:
Resourcenmanagement habe ich aus Platzgründen ignoriert

brotbernd

Den Strategieteil hatten wir ja schon auf der 1.Seite. Aber jetzt sehe ich auch eine Fabrik (Allerdings nenn ich das Muster in dieser Form "Abstract Factory". "Factory" ist für mich anders). Ob diese Fabrik hier Sinn macht weiß ich allerdings nicht. Aber das kann ja der OP entscheiden. Auf jeden Fall noch ein weiterer guter Tipp.

Resourcenmanagement habe ich aus Platzgründen ignorier

Schreib doch statt

Player* p = new Player();

PlayerPtr p(new Player());

und behaupte alle xPtr sind eine typedef std::shared_ptr<x>...

Sonst kopiert das der ein oder andere Einsteiger und ignoriert auch einfach das Resourcenmanagement

icarus2

Gibt es gute Bücher wo diese verschiedenen Entwicklungsmuster beschrieben werden (Java oder C++). Ich kenne das Buch Entwicklungsmuster von Kopf bis Fuss (oder so ähnlich) und das fand ich gut (hatte es aber nur ausgeliehen und nur die ersten 2-3 Kapitel gelesen). Ist halt einfach für Java aber ich nehme an die grundlegenden Konzepte sind genau die gleichen oder?

drakon

Von dem Buch habe ich viel positives gehört. Ist also wahrscheinlich nicht schlecht.

Andernfalls gibt es ein Standardwerk von der "Gang of Four" über Design Patterns:
Design Patterns | ISBN: 9780201633610

icarus2

Danke schon mal

Wie wird das eigentlich an der ETH gemacht, Drako. Wird da auch ein Buch für angeschafft, in den Vorlesungen behandelt oder wie ist das da?

drakon

icarus2 schrieb:

Danke schon mal

Wie wird das eigentlich an der ETH gemacht, Drako. Wird da auch ein Buch für angeschafft, in den Vorlesungen behandelt oder wie ist das da?

Drakon bitteschön.

Also kaufen musst du dort grundsätzlich keinen Schulstoff. Vieles wird dir als Skript angeboten (wenn du sie bereits gedruckt und gebunden haben möchtest, dann kostet dich das ca 10.- ) oder die Bücher auch als .pdf. Man kann gewisse Bücher allerdings günstiger kaufen. Du kannst also auch gut alle Bücher und Skripts am PC nachlesen (was ich nicht unbedingt überall empfehle).
Wenn du willst kann ich dir ein paar Tipps für das erste Semester geben, was das Material anbelangt.

icarus2

Wups, kannte mal einen, der sich Drako nannte. Alte Gewohnheit

Ja, par Tipps zum Stoff wären wirklich gut. Ich fange ja im Herbst an. In welchem Semester bist du?

drakon

Ich bin im Moment im zweiten Semester.

Also gut. Ist zwar ein wenig OT, aber vielleicht auch für jemand anderen Interessant. (ich gehe mal davon aus, dass du Inf. studierst. - Das einzig wahre, gell Nexus. *duck* :))

Eprog (Einführung in die Programmierung): Wird kein Problem für dich sein und daher musst du das Buch (Englisch) von Meyer nicht unbedingt kaufen. Ich habs gemacht und durchgelsen. Wird viel _sehr_ grundlegendes erklärt, aber hin und wieder etwas interessantes, aber für den Stoff, den du können musst reicht viel weniger (die Vorlesung + Übungen + ein wenig was selber machen).
Mitschreiben der Vorlesung ist nicht notwendig, da es die Slides + Vorlesungsvideos/Audios gibt. (Von der trivialität des meisten, was er sagt mal abgesehen).

LinAlg (Lineare Algebra): Da gibts ein Skript (Deutsch), dass zu empfehlen ist. Es gibt afaik nicht einmal eine Onlineversion.
Hier lohnt sich das Mitschreiben, allerdings mit Ausnahmen. Wenn Dr. Kressner anfängt irgendwelche Algorithmen in Pseudocode an die Tafel zu schreiben oder versucht irgendwelche Verfahren hochmathematisch korrekt an die Tafel zu kritzeln, dann lehn dich zurück und hör auf das probieren abzuschreiben es bringt nichts. Die Verfahren werden in der Übung nochmal erklärt und sind nach ein paar mal sehr intuitiv zu machen (Gauss, Cholesky, Gram-Schmidt usw.), wenn man es ein paar mal gemacht hat. Das irgendwie auf Blatt mit Formel zu heften ist imo weitestgehend sinnlos. Ich kann die Algorithmen-Dinger im Skript jetzt auch nur Nachvollziehen, weil ich weiss wies geht sonst siehst du da nur i's, j's und Indexe.

DiskMat (Diskrete Mathematik): Gutes Skript (Englisch), unbedingt nehmen!
Mitschreiben lohnt sich auch hier. Prof. Maurer schreibt nicht so viel auf die Tafel und man kommt also sehr gut mit und kann angenehm zuhören und noch Zusatznotizen machen.

Analysis I: Hier scheiden sich die Geister was das Skript (Deutsch) anbelangt. Wenn man es sieht, dann ist man erstmal völlig erschlagen, denn es sind praktisch nur Formel drin (obwohl es ab nächstem Semester auch ein paar Grafiken drin hat). Dazu kommt noch, dass es auch sehr viele Beweise für Sachen drin hat, die wir (Informatiker) so gar nicht direkt beherrschen müssen und werden dann in einem völlig erschlagendem Tempo durchgemacht (Picard-Lindelöf mit Vorgeplänkel innerhalb 1h). Hier gilt dann auch eher, dass man sich entspannen sollte. Die Übungen sind dann viel angewandter.
Viele (wirklich sehr viele) sind irgendwann gar nicht mehr in die Vorlesung gekommen, sondern haben nur die Übungsstunden besucht eben weil die Vorlesung teilweise (oft?) nicht wirklich das wiederspiegelt, was du können musst. Ich bin eigl. immer gegangen, aber gelernt habe ich schon mehr ausserhalb der Vorlesung. Nicht zuletzt begeistert der Prof. mit seinem Engagement extrem und die raren, aber wirklich köstlichen (Nerd-)Jokes von ihm sind auch immer mal wieder ein Spass.
Versuch gar nicht erst mit Prof. Struwe mithalten zu wollen und alles von der Tafel abzuschreiben. Es ist schlichtweg nicht möglich. Zum Glück ist es auch nicht nötig, denn er schreibt praktisch das Skript 1:1 an die Tafel (ja wirklich und das auswendig ) und man hat so genug Zeit zuzuhören und sich weitere Notizen zu machen.

Falls du andere Professoren hast, dann kann es natürlich auch anders sein!
Uhh. Ich habe gerade nachgeschaut. Du hast 3 andere Profs, als wir hatten.. DiskMat, LinAlg und Analysis werden von einem anderen Prof. gehalten.. Das macht das ganze sehr relativ.
Naja. Was du auf jeden Fall davon mitnehmen kannst ist, dass du nicht um biegen und brechen alles mitschreiben musst, sondern dass du das sehr individuell betrachten musst und deinen Stil ggf. nach ein paar Wochen anpassen, damit du das beste aus der Vorlesung holen kannst.

icarus2

Vielen Dank für die Infos, war sehr interessant zu lesen.

Was mich noch interessieren würde:

- Programmiert man wirklich in Eiffel? ^^

- Wie schwierig und wie schnell gehts in der Mathematik voran? Ich hatte nicht Schwerpunktfach Mathemathik. Komplexe Zahlen und Differentialgleichungen lösen sagt mir deswegen nichts. Sollte man sich schon vorher damit beschäftigen oder hat man da im Studium noch genug Zeit?

Hey,

ich bin schon sehr lange in diesem Forum, da ich sehr gerne programmiere, aber beruflich strebe ich dieses nicht an und blicke eher einem Medizinstudium entgegen.

Da ich keine Eltern, Freunde, etc. habe die studiert haben kann ich mir darunter nicht viel vorstellen.
Besonders abgeschreckt haben mich oft Filme, wo man einem Professor reden sah und die Leute praktisch nur am Schreiben waren.

Ist das tatsächlich so extrem? Muss man alles abschreiben?

Es ist nicht so, dass ich faul bin, aber ich kann nicht ordentlich schreiben... Und wenn ich dann auch noch schnell schreiben müsste, dann kann ichs auch ganz lassen...

Das sind Dinge vor denen ich große Sorgen habe und daher sehr unsicher bin, ob ich überhaupt studieren werde.
Kannst du Drakon oder jemand anders mir da ein Tipp geben?

icarus2 schrieb:

Vielen Dank für die Infos, war sehr interessant zu lesen.

Was mich noch interessieren würde:

- Programmiert man wirklich in Eiffel? ^^

- Wie schwierig und wie schnell gehts in der Mathematik voran? Ich hatte nicht Schwerpunktfach Mathemathik. Komplexe Zahlen und Differentialgleichungen lösen sagt mir deswegen nichts. Sollte man sich schon vorher damit beschäftigen oder hat man da im Studium noch genug Zeit?

Ich bin zwar nicht Drakon, aber ich habe oft in diesem Forum gelesen, dass ein Informatikstudium (insbesondere an Universitäten) in den seltensten Fällen von Programmieren handelt. Es mag zwar ein paar Vorlesungen geben, aber das wars dann auch. Die Umsetzung der gelernten Dinge stehen dir demnach frei und somit auch die Programmiersprache.

Von anderen Posts habe ich gesehen, dass sogar ganze Projekte von Studenten umgesetzt werden. Hängt wohl sehr von der Universität ab.

Soweit ich weiß gibt es häufig Mathematik-Vorlesungen, die man freiwillig vor Beginn des eigentlichen Studiums besuchen kann, um sein Wissen aufzufrischen.

drakon

icarus2 schrieb:

- Programmiert man wirklich in Eiffel? ^^

Jap. Ansich finde ich die Sprache nicht schlecht. Hat sehr viele gute Sachen, auch wenn sie mir auf Dauer wohl zu puristisch ist.
Was wirklich nervig ist ist EifelStudio. Die IDE dazu. Unintuitiv, langsam und einfach mühsam..

- Wie schwierig und wie schnell gehts in der Mathematik voran? Ich hatte nicht Schwerpunktfach Mathemathik. Komplexe Zahlen und Differentialgleichungen lösen sagt mir deswegen nichts. Sollte man sich schon vorher damit beschäftigen oder hat man da im Studium noch genug Zeit?

Ist jetzt schwer zu sagen. Es geht schneller voran, als du dich bis jetzt gewohnt bist, aber das kannst du dir wahrscheinlich auch bereits gut vorstellen.
Die Schwierigkeit kommt wohl mit dem Tempo, denn wenn man mal etwas verstanden hat, dann ist es eigentlich relativ klar. Das ist ja das schöne an Mathematik. - Zusätzlich steckt man natürlich viel mehr Zeit auch in der Freizeit für Schulstoff. Bei mir ist es nicht selten vorgekommen, dass ich (da 1.5h Anfahrtsweg) von Morgen 6 Uhr bis Abends 9-10 irgendwie (direkt) beschäftigt war mit dem Stuidium. Also Vorlesung, Übung, Hausaufgaben.

Man sollte einfach nicht abhängen und immer brav die Übungsserien. Dort wird dir sicher sehr viel klarer, als während der Vorlesung oder der Übungsstunde (war auf jeden Fall bei mir so). Wichtig ist auch genügend während dem Semester zu machen, obwohl man in den ersten Semesterferien natürlich noch keine Prüfungen hat. Da hat niemand den ich kenne so viel gemacht, wie er eigentlich vor hatte. Den ganzen Stoff dann aufzuarbeiten wäre möglich, ist aber unwahrscheinlich.

Und noch was zur Beruhuigung für dich:
Ich wusste vor dem Studium nicht einamal, was Differentialgleichungen sind.
Hier noch einen Eintrag, den ich nach 2 Wochen geschrieben habe.
Achja: Und ja. Schwerpunkt Mathe bringt einem einen grossen Vorteil. Wir hatten Leute, die hatten anscheinend einen so guten Unterricht, dass sie selbst am Ende des ersten Semesters Teils Sachen bereits gemacht haben.

drakon

...... schrieb:

Hey,

ich bin schon sehr lange in diesem Forum, da ich sehr gerne programmiere, aber beruflich strebe ich dieses nicht an und blicke eher einem Medizinstudium entgegen.

Vielleicht wäre ein Informatik Master in Bioinformatics ja was für dich.

Da ich keine Eltern, Freunde, etc. habe die studiert haben kann ich mir darunter nicht viel vorstellen.
Besonders abgeschreckt haben mich oft Filme, wo man einem Professor reden sah und die Leute praktisch nur am Schreiben waren.

Ist das tatsächlich so extrem? Muss man alles abschreiben?

Wie ich oben bereits bei den Fächern geschrieben habe kommt es sehr drauf an was es für eine Vorlesung ist und bei welchem Professor.

Studieren heisst Vorlesungen besuchen (wo ein Typ in einem grossen Saal 2h redet), Übungen besuchen, was eher so ist, wie man Unterricht gewöhnt ist und Übungsaufgaben machen (Hausaufgaben).
Das, wovor du Angst hast macht (üblicherweise) also weniger als 50% aus und ist weit weniger erschreckend, als du denkst. Bei uns musst du eigentlich nicht wirklich etwas mitschreiben, weil vieles irgendwie anders zugänglich ist (Bücher, Präsentationen, Videos usw.) und ich benutze meine Mitschrift hauptsächlich als Gedankenstütze was wir alles behandelt haben und halt wichtige Notizen. Auch für den groben Überblick ist es sehr hilfreich.

Am besten wäre es aber, wenn du einfach mal eine Vorlesung besuchst. Die sind öffentlich und du kannst dann ja mit ein paar anderen Studenten des Faches, welches du studieren willst sprechen. Das Problem ist eben, dass es wirklich seehr unterschiedlich ist von Universität, Vorlesung und Professor.
Aber die meisten sehen es wohl ein, dass es nicht viel Sinn macht, wenn die Studenten einfach alles 1:1 kopieren und gestalten dementsprechend die Vorlesung auch so (mit Skripts oder zugänglichen PP Präsentationen).

Ich bin zwar nicht Drakon, aber ich habe oft in diesem Forum gelesen, dass ein Informatikstudium (insbesondere an Universitäten) in den seltensten Fällen von Programmieren handelt. Es mag zwar ein paar Vorlesungen geben, aber das wars dann auch. Die Umsetzung der gelernten Dinge stehen dir demnach frei und somit auch die Programmiersprache.

Von anderen Posts habe ich gesehen, dass sogar ganze Projekte von Studenten umgesetzt werden. Hängt wohl sehr von der Universität ab.

Das stimmt. An der ETH lernt man keine Programmiersprache, sondern die bekommt man halt so nebenbei mit (wobei es sich natürlich lohnt diese dann doch genau zu mit einem guten Buch seperat zu lernen). Ausnahmen gibt es natürlich, wie eben Eprog, welche natürlich auch sehr viel Eiffelprogrammierung enthält, aber ausgehend von der Sprache wird dann "erwartet", dass man sich selbst Java, C++ aneignen kann. Allerdings hatten wir selbst in der Vorlesung "Paralelle Programmierung", welche mit Java gemacht wird ein paar Stunden wirklich Java.
Aber in dem Sinne hast du Recht, dass man keine Vorlesung hat, welche sich mit hauptsächlich mit der Sprache beschäftigt. (ausser natürlich später, wo man dann "in-depth" Vorlesungen besuchen kann).

In Fachhochschulen werden eher direkt Sprachen gelehrt. Ich würde sowieso ein gutes Buch bevorzugen um eine Sprache zu lernen.

icarus2

Vielen Dank für die ausführlichen Antworten.

Ja, ich bin gespannt wie das ganze dann so läuft. Ich hatte nie Probleme mit der Mathematik im Gymnasium, hoffe, dass sich das im Studium nicht allzu sehr ändern wird. Komplexe Zahlen werde ich mir noch vor dem Studium beibringen, hab ein Buch gekauft dafür.

Wenigstens sollte das Programmieren im ersten Jahr kein Problem sein.

So, ich muss mal ins Bett, muss morgen arbeiten. Gn8

brotbernd

Oft gibt es in den Unis in den Semesterferien für die 1.Semester einen Mathekurs, da die Mathematik erfahrungsgemäß ein häufiger Knackpunkt ist (In vielen Fächern die auch nur irgendwas mit Zahlen zu tun haben). Ich hatte einen sehr guten Mathe LK in der Schule und im Studium damit überhaupt keine Probleme. Ich hatte aber Kommilitonen, die sich tatsächlich getraut haben ins Mashcinenbaustudium zu gehen und in der Schule Mathe abgewählt hatten (was bei uns überhaupt nicht ging).

Sonst zum Thema Vorlesungen besuchen & mitschrieben. In den ersten Semestern sitzen noch viele Studenten (je nach Uni 100te) brav in den Reihen und meißeln alles ab. Da sind auch noch öfter mal Tafel / Folien im Einsatz von denen es etwas abzuschreiben gibt. Im Hauptsstudium werden die Säle immer leerer. Es gibt immer mehr langweilige Powerpointvorträge bei denen man einschläft, da kann man seine Zeit sinnvoller in der Cafeteria verbringen :D. Naja es ist wirklich von Student zu Student (und Prof, Fach, Uni, Wetter) unterschiedlich. Die einen gehen in jede VL, die anderen nur in Übungen, und andere bringen sich alles selbst bei und gucken nur zu Prüfungen mal vorbei.

hustbaer

DocShoe schrieb:

Können wir uns auf sowas einigen?

// forward declaration
class IAbstractMoveable;

struct IAbstractMover
{
   virtual~ IAbstractMover() 
   {
   };
	
   virtual void move( IAbstractMoveAble& Object ) = 0;
};

struct SlowMover : IAbstractMover
{
   void move( IAbstractMoveAble& Object )
   {
      // Objekt bewegt sich langsam
   }
};

struct NormalMover : IAbstractMover
{
   void move( IAbstractMoveable& Object )
   {
      // Objekt bewegt sich normal
   }
};

struct FastMover : IAbstractMover
{
   void move( IAbstractMoveAble& Object )
   {
      // Objekt bewegt sich schnell
   }
};

class IAbstractMoveable
{
   // Strategy Pattern: konkreter Mover übernimmt die Bewegung des Objekts
   IAbstractMover* Mover_;

public:
   IAbstractMoveable() : Mover_( 0 )
   {
   }
	
   virtual ~IAbstractMoveable() 
   {
   }
	
   void set_mover( IAbstractMover* Mover )
   {
      // neues Mover Objekt setzen
      Mover_ = Mover;
   }
	  
   void move()
   {
      // Strategy Pattern: Mover Objekt ist für 
      // die tatsächliche Bewegung verantwortlich
     if( Mover_ ) Mover_->move( *this );
   }	
};

struct Player : public IAbstractMoveable
{
};

struct Spriter : public IAbstractMoveable
{
};

sruct IAbstractObjectFactory
{
   virtual ~IAbstractObjectFactory()
   {
   }

   virtual Player* create_player() = 0;
   virtual Sprite* create_sprite() = 0;
};  

struct EasyObjectFactory : IAbstractObjectFactory
{
   Player* create_player() 
   {
      Player* p = new Player(); 
      p->set_mover( new NormalMover() ); 
      return p;
   }

   Sprite* create_sprite()
   {
      Sprite* s = new Sprite();
		
      // Easy Mode: Sprites bewegen sich langsamer als der Spieler
      s->set_mover( new SlowMover() );
      return s;
   }
};
	
struct EasyObjectFactory : IAbstractObjectFactory
{
   Player* create_player() 
   {
      Player* p = new Player();
      p->set_mover( new NormalMover() );
      return p;
   }

   Sprite* create_sprite()
   {
      Sprite* s = new Sprite();

      // Normal Mode: Sprites bewegen sich genauso schnell wie der Spieler
      s->set_mover( new NormalMover() );
      return s;
   }
};
	
struct HardObjectFactory : IAbstractObjectFactory
{
   Player* create_player() 
   {
       Player* p = new Player();
       p->set_mover( new NormalMover() );
       return p;
   }

   Sprite* create_sprite()
   {
      Sprite* s = new Sprite();

      // Hard Mode: Sprites bewegen sich schneller als der Spieler
      s->set_mover( new FastMover() );
      return s;
   }
};

Sowas ähnliches wollte ich gerade vorschlagen.

Wobei ich den IAbstractMover lieber IPositionController nennen würde.
Das IAbstractMoveable würde ich zu Gunsten der Einfachkeit einsparen, und gleich eine (evtl. abstrakte) Klasse GameObject draus machen.

Und natürlich könnte man auch noch ein paar kleine strukturelle Änderungen vornehmen.
z.B. könnte man den IPositionController (kontrolliert nur die Position) gleich verallgemeinern zu einem IController (kontrolliert was ihm Freude macht).

Dadurch könnte man relativ einfach in der GameObject Klasse einen std::vector<IController*> (oder std::map<std::string, IController*> ) halten, und da alle möglichen Controller drinnen "sammeln".
Das IController Interface könnte dabei einfach so aussehen:

class GameObject { ... };

class IController
{
public:
    virtual void Update(GameTime time, GameObject& go) = 0;
};

Eine Andere Möglichkeit (die ich sogar schon verwendet habe :)), wäre, das "Ziel" des Controllers gänzlich generisch zu machen: der Controller bekommt nur einen Funktor über den er *irgendetwas* kontrollieren kann. Das kann dann ein GameObject sein oder auch ganz was anderes:

class IController
{
public:
    virtual void Update(GameTime time) = 0;
};

class PositionController : public IController
{
public:
    PositionController(boost::function<void(Point pos)> const& target) :
        m_target(target)
    {
    }

    void SetTarget(boost::function<void(Point pos)> const& target)
    {
        m_target = target;
    }

    virtual void Update(GameTime time)
    {
        Point pt = ...;
        m_target(pt);
    }

private:
    boost::function<void(Point pos)> m_target;
};