Klassen kommunizieren lassen

[haiyyu]

Hallo Leute.

Ich programmiere gerade ein kleines Spiel und mir stellt sich die Frage, wie ich zwei Klassen am besten miteinander kommunizieren lassen soll.
Grundsätzlich würde es ja dann nicht in diese Kategorie gehören, jedoch bezieht es sich nicht nur auf das Programmieren von Spielen.

Der Aufbau sieht folgendermaßen aus:

Ich habe eine Game-Klasse, die ungefähr so aussieht:

public class Game
{
 private ArrayList<GameObject> objects;
 
 public Game()
 {
  objects = new ArrayList<GameObject>();
 }

 public void onTick()
 {
  for (GameObject object: objects)
  {
   object.onTick()
  }
 }

 public void start()
 {
  // ...
 }

 // Restliche Teile des Codes sind im Moment nicht relevant.
}

Natürlich gibt es noch einen Thread, der das onTick()-Event in einem bestimmten Intervall aufruft.

Nun habe ich ein GameObject-Interface, das ungefähr wie folgt aussieht:

public interface GameObject
{
 void onCreate()
 void onTick()
 void onDraw(Canvas c) // irrelevant
}

Nun kann ich mir einige Objekte schreiben, die jeweils etwas anderes machen, und diese im Konstruktor meiner Game-Klasse hinzufügen, wo sie erstmal nichts machen, bis ich die start()-Methode aufrufe.

Die Game-Klasse kann nun problemlos dem GameObject sagen, was es zu tun gibt, indem es seine Methoden aufruft (zeichnen, etc.)#

Was aber, wenn ich bspw. will, dass ein GameObject sich nach sagen wir 20 Ticks zerstört?
So würde der erste Ansatz aussehen:

public class SelfDestroyingObject implements GameObject
{
 private int ticks;
 
 public void onCreate()
 {
  ticks = 0;
 }

 public void onTick()
 {
  if (ticks == 20)
  {
   // ?
   return;
  }
  ticks++;
 }
}

Nun könnte ich im Interface noch ein Flag "destroyMe" (bspw.) oder einen Listener hinzufügen, aber gibt es dafür auch bessere Wege?
Möchte nämlich nicht irgendeinen Wurschtelcode benutzen, wenns doch eigentlich viel besser ginge.

Also, was ich machen will, ist kurz beschrieben folgendes:

Ich habe eine Game-Klasse mit einer Liste von GameObjects. Die Game-Klasse kann problemlos deren Methoden aufrufen, jedoch wissen die GameObjects nichts von der Game-Klasse. Was ist die beste Methode, ein GameObject die Game-Klasse zu bitten, es zu zerstören?

Ich hoffe, das war einigermaßen verständlich von mir erklärt.

Danke schonmal!

 

[bygones]

was soll denn die Game Klasse machen wenn das GameObject zerstoert werden soll ?

simpelsten loesung ist ein passender Rueckgabewert von onTick()

ansonsten eine methode im interface die abfraegt ob ein Object noch am leben ist, Game fraegt dies ab und reagiert darauf, wenn es nicht mehr das fall ist. Das GameObject selber setzt dann je nach Bedingung ob es weiter Leben soll oder nicht

 

[haiyyu]

Die Game-Klasse soll das GameObject dann einfach von der objects-Liste löschen.

Das mit dem Rückgabewert des onTick-Events und der Methode habe ich mir auch schon gedacht, jedoch soll das Ganze ja nicht nur zum Zerstören funktionieren.

Wäre es vielleicht besser, wenn ich das Ganze so aussehen lassen würde:

public class SomeObject implements GameObject
{

 private int counter;
 private Game game;

 public void onCreate(Game game)
 {
  counter = 0;
  this.game = game;
 }

 public void onTick()
 {
  if (counter == 20)
  {
   game.getObjects().remove(this);
   return;
  }
  counter++;
 }

}

So könnte mein GameObject auch bspw. andere GameObjects löschen und die Public Propertys und Funktionen der Game-Klasse verwenden (was es ja auch können soll).
Allerdings hörte ich irgendwo mal, dass das unsauber sei.
Kann mir einer sagen, warum man das vermeiden sollte? Oder ist das Quatsch?

Danke für die bisherige Hilfe.

 

[bERt0r]

Das würde so glaube ich nicht Funktionieren, weil du bei deiner for schleife dann eine Cuncurrency Exception bekommst.

public void onTick()
 {
  for (GameObject object: objects)
  {
   object.onTick()
  }
 }

Wenn du das so machen willst, brauchst du eine Colletion die threadsafe ist.

Was mir noch einfallen würde, wäre sich selber so eine Art kleine Garbage Collection anzuschaffen. Wenn dein Objekt seinen letzten Tick hat, fügt es sich einer "GarbageListe" in der Game Klasse hinzu und alle paar Ticks (oder sogar jeden Tick wenn die Performance das zulässt) machst du ein objects.removeAll(garbageList) in deinem Thread, nachdem du die alle Objekte durchgetickt hast.