Engine und Objekte?

[Samuel]

Tja so was, passt eigentlich in beide Bereiche, aber ich poste es mal hier.

Ich hab folgendes theoretisches Problem, was ich nicht lösen kann.
Ich hab eine Engine, die hat ne Methode, welche Objekte bewegt, sagen wir grob jedes Objekt wird auf der X Achse einfach addiert.
Dann hab 2 Objekte, die ich hin und her schleudern will, aber wie genau geht das?
Objekt 1 hat die Fähigkeit 1 mal vom Rand abzuprallen, und Objekt 2 hat die Fähigkeit 2 mal abzuprallen.
Das Abprallen soll von mir aus eine Klasse sein, die sagt wann welcher X wert nicht geht.

Mein Problem ist nun, wer was wie bewegt? Die Engine weiß wie man etwas bewegt, das Objekt weiß, wie es sich verhalten soll und die Klasse Level weiß wo die Grenzen sind. Wie würde so was ablaufen? Würde das jeweilige Objekt die Engine nutzen, oder bekommt die Engine das Objekt?
Wird so was in der Regel so gelöst, dass das Objekt die Engine nimmt und mit Parametern initialisiert?
Wenn ja was weiter, es wäre möglich, dass das Objekt dann einen Wert t wie Zeit an Engine gibt und die Engine gibt einen Positionswert zurück?
Wobei t ja irgendwie imaginär ist, einfach irgend ein Iterator der durch Intervall oder onEnterFrame bestimmt wird?

Laufen Engines so?
Anders rum kann ich mir nicht wirklich vorstellen, wie das gehen soll. Der andere Weg wäre dann, das Objekt wird der Engine übergeben, die Engine wird gestartet und läuft selbstständig und bewegt das übergebene Objekt? Wenn das die Lösung ist, wie steuert man dann das benutzerdefinierte Verhalten der Objekte? Woher weiß die Engine ob das Objekt einmal oder zweimal abprallen soll? Und kommt ein drittes Objekt, was auf einmal nicht nur abprallt, sondern auch noch sonst was tut, müsste man ja die Engine erweitern.

Was ist hier praktikabel? Meine erste Lösung?

[Omega Psi]

Also, ich bin da echt kein Pro... mein Anstz wäre intuitiv folgender:

Meine Enginge verwaltet die Objekte, überprüft also regelmässig, wo die sind und was die machen.

Die Objekte selbst tragen ihre Funktionalität mit sich. Diese Funktionalität wird von der Engine aufgerufen, wenn es von Nöten ist. Im Grunde genommen prüft meine Engine nur auf bestimmte Zustände und Ereignisse und lässt dann Funktionen der Objekte aufrufen... if ... else ... if ... else...

Also... sehr viel habe ich dazu also nicht beizutragen

[Samuel]

Hm, aber das Objekt weiß ja garnicht, wie es sich bewegt, nur dass es vielleicht mal abprallen muss, was ruf ich dann bei dem Objekt auf? Das Objekt weiß ganz sicher nicht, wie es sich bewegen muss.
Oder bewegt die Engine ein Objekt, bei Aufprall ruft die das Objekt auf, und dass kann ggf dann die Engine zur neuen Bewegung veranlassen? Hm, aber dann würde ein solches Verhalten ja verschachtelte Aktionen aufrufen.
Vor allem, wann bewegt die Engine dann die Objekte? Das weiß sie ja nicht

[Omega Psi]

Einem Objekt wird gesagt, wie es sich zu bewegen hat.

• Engine bewegt das Objekt über die Funktionen des Objektes.
• Wenn das Objekt eine bestimmte Markierung oder Zustand erreicht, ruft die Engine eine andere Funktion auf.

Es muss ja auch nciht die Engine ein Objekt zum Bewegen bringen, dies kann ja auch durch Interaktion den Benutzers mit den Objekten passieren.

[Samuel]

Aber wie ist der Zustand? Hat die Engine pausenlos einen Verweis der vorhanden Objekte?
Oder wird ein Objekt erst übergeben? Nur ist es verwirrend für mich, wenn eine Instanz der Engine ein Objekt bekommt, mit der Anweisung, es zu bewegen, die Engine bewegt es bis sie merkt, dass da ein Kontakt war, dann ruft sie quasi eine Methode des Objekts auf und wirft das Objekt aus der Liste?
Das Objekt prüft dann den Zustand und übergibt sich unter Umständen wieder selbst an die Engine mit neuen Bewegungsparametern?

[Omega Psi]

Hm, ich muss da mal eben drüber kauen...

Aber ich glaube, du denkst du kompliziert... oder ich zu simpel. Ein teil des Zustands ist ist beispielsweise die aktuelle Situation.

Die Engine verwaltet doch alle Objekte, muss also auch zwangläufig alle Objekte kennen. Die Engine weiss also immer, wie der komplette Zustand des Systems aussieht und wie sie in bestimmten Fällen zu reagieren hat, bzw welche Funktionen der Objekte sie aufrufen soll.

[fabulos79]

Zitat von Samuel

Mein Problem ist nun, wer was wie bewegt? Die Engine weiß wie man etwas bewegt, das Objekt weiß, wie es sich verhalten soll und die Klasse Level weiß wo die Grenzen sind. Wie würde so was ablaufen? Würde das jeweilige Objekt die Engine nutzen, oder bekommt die Engine das Objekt?
Wird so was in der Regel so gelöst, dass das Objekt die Engine nimmt und mit Parametern initialisiert?

Objektierung ist eine schöne Sache. Sie entspricht viel mehr dem menschlichen Denken als prozedurale Programmierung.
Objekte vereinen dabei Funktionen und Daten (wirst du sicher alles wissen).

Vergleich mit der Realität:
-> Auto, Pferd, Hund (klassische Objekte im Laiensinne) bewegen sich selber.
Einflussvariablen (etwa physikalische Größen) holen Sie sich von außen.
Dafür kann man weitere Klassen andoggen...
Bei ähnlichen Objekten Pferd, Hund macht auch die Nutzung von Prototypes Sinn.
Wenig sinnvoll ist das Bewegen von Objekten von außen. Stößt ObjektA mit ObjektB zusammen, so sollte ObjektA nicht ObjektB sagen "Beweg dich nach x,y" sondern vielmehr eine Kraft auf ObjektB übertragen. Mittels dieser erfahrenden Kraft kann ObjektB jetzt seine neue Bewegung selber kontrollieren.
Es gibt im Netz diverse Literatur zur OOP, die das viel besser und ausführlicher erklären kann als ich. Riskiere ruhig mal einen Blick.

Übrigens sind die meisten Empfehlungen "Richtlinien" und keine Regeln. Auch bei der OOP gibt es häufig verschiedene sinnvolle Wege zum Ziel.

[Samuel]

Danke, ich weiß was OOP ist
Aber ich kenne mich mit Engine programmierung nicht aus. Mir ist shcon klar, dass man ansich keine Objekte bewegt, sondern diese bitten, sich zu bewegen, aber bei einer Engine ist es nun mal, so, dass es keine Einfach bewegung gibt, wenn ich Gravitation auf einem der Monde des Jupiter simulieren will, so macht das die Engine, nicht jedoch jedes Objekt für sich. Und da wird niemand jedem Objekt die Gravitation beibringen.
Ich guck bei Zeiten, ob es Designpattern für solche Probleme gibt, aber ich bin bis jetzt einer antwort kein Stück näher :/

[Omega Psi]

Beispiel Gravitation:
Die Kräfte sind schon alle da, die Engine verwaltet diese nur. Sie schaut nach, ob und wo welche Kräfte auftreten und die einzelnen Planeten stellen Methoden zur Verfügung um Masse etc nach auss bereitzustellen. Die Engine stellt nun, je nachdem ob es sein muss oder nicht, die einzelnen Attribute die wichtig sind in Relation zu einander.

[Samuel]

Was immernoch keine Erklärung dafür ist, wer wen hat, bewegt, wer sich wem übergeben würde usw.

[Omega Psi]

Hier ein einfache Skizze einer Partikelsystems. Das mag vielleicht die einfachste Art einer Simulation, bzw einer Engine sein.

Die Engine erzeugt Partikel mit Initialwerten, nachdem das Objekt initialisiert wurde. Man könnte diese Werte auch schon im Konstruktor übergeben, und dann die move() aufrufen oder die ganz weglassen. etwas, was die Enigine nicht überprüft: Das alter des Partikels. Alle Partikel leben gleich lang. Werden aber zu unterschiedlichen Zeitpunkten erzeugt und haben alle eine andere Flugbahn. Die Engine könnte wäre aber auch dafür verantwortlich zu überprüfen, ob sich Partikel berühren.

[Samuel]

Hier hat aber Partice die Methode Move, woher kennt ein particle wie es sich zu bewegen hätte?
Ich mein wenn ich auf einmal eine andere Bewegung haben will, oder die Gravitation usw erhöhe, so muss dann ja jedes Particle eine Änderung erfahren (auch wenn es move erbt, so hat dennoch jedes Particle ein und die selbe methode)

Ps mit welchem Tool ist das gemacht?

[Omega Psi]

Das ist mit Fireworks gemacht

Die Methode Move wird auch immer gleich implementiert. Die Parameter x, y und fstellen dabei die Variablen Vektoren dar, die die Flugbahn beeinflussen. Diese werden intial in der Engine erzeugt in createParticle().

var engine:Engine = new Engine();
engine.run();
while(true) {
    engine.createParticle();
} 

class Engine {
    public function createParticle() {
        var p:Particle = new Particle();
        p.run();
        p.moveTo(Math.random(), Math.random(), Math.random());
    }
} 

In echt würde ich das kompakter coden, ist nur eine Demonstration wie Methoden verwendet werden könnten. Die Methode die() der Partikel beispielseweise würde nicht von der Engine, sondern in der run() der Partikel aufgerufen werden.

[Samuel]

Ergo ist dein Modell so aufgebaut, dass die Objekte sich selber bewegen? Ist das gängig?

[Omega Psi]

Naja, das hängt damit zusammen, dass die Bewegung an sich von nicht anderem Abhängig ist, als den Initialwerten.

Würde man nun sagen, ein Partikel beinflusst das Partikel in seiner direkten Nachbarschaft, wäre dem nicht mehr so. Dann würde ich dem Partikel eine Methode hinzufügen, um den Einfluss eines anderen Partikels geltend zu machen.

Die Engine würde dann schauen, wo sich die einzelnen Partikel befinden und dann die Funktionen aufrufen.

/* Code in der Engine. */
/* var particles = new Array + füllen geschah vorher. */
if ((this.particles[i]._x-this.particles[j]._x < =1) && (this.particles[i]._y-this.particles[j]._y <= 1)) {
    this.particles[i].isInfluencedByParticle(this.particles[j]);
    this.particles[j].isInfluencedByParticle(this.particles[i]);
}