Spielstrukturierungsfrage

[N_Gnom]

Also ich bin dabei einen kleinen 2D Shooter zu programmieren.

Mir geht es nun um die grundlegende Strukturierung des ganzen.

Mein Gedankengang war folgender...
Ich habe eine Struktur für den Playerpart.
Eine Liste für Gegner, welcher wiederum Listen untergeordnet sind was die Bewaffnung(also die Schüsse) der Gegner betrifft.

Nun soll es aber mehrere Gegnerarten geben, sollte ich da also einfach verschiedene Strukturen erstellen und diese in eine Liste einfügen und bei Bedarf dann füllen oder auch löschen?

Ich würde mich für eure Gedankengänge interessieren wie ihr sowas strukturieren würdet.

[Drago]

Für die verschiedenen Gegner brauchst du doch nicht noch mehr Listen, da du die ja anhand der Id identifizieren
kannst.

Code: Alles auswählen

;-----------------PSEUDOCODE--------------------

Global Feind1 = LoadSprite( #PB_Any........ )
Global Feind2 = LoadSprite( #PB_Any........ )


Structure attribute
     x.f
     y.f
     trans.f
     rotate.f
     angle.f
     speed.f
EndStructure

Global Player.Pos

Structure Enemy Extends attribute
     id.i
EndStructure

Global NewList Enemy.Enemy()

AddElement( Enemy() )

With Enemy()
     
     \id = Feind1
     \x = 512
     \y = 384
     u.s.w...............
     
     AddElement( Enemy() )
     \id =  Feind2
     \x = 0
     \y = 0
     u.s.w........
     
     EndWith

[STARGÅTE]

Also ich würde "Schüsse" nicht für jeden Gegener in einer eigenen Liste speichern,
sondern lieber in einer gemeinsammen Liste für alle "Schüsse".
Für die verschiedenen Gegnerarten würde ich ein paar Typen (strukturierten Variablen) definieren,
diese Typenadressen kannst du kann mit in den Gegner speichern, sodass du auf die verschiedenen Attribute zugreifen kannst.
Das spart etwas speicher, da nicht jeder Gegner seine Typ-Informationen selbst speichern muss, sondern von einer gemeinsammen Quelle beziehen kann.

[N_Gnom]

Also ich würde "Schüsse" nicht für jeden Gegener in einer eigenen Liste speichern,
sondern lieber in einer gemeinsammen Liste für alle "Schüsse".
Für die verschiedenen Gegnerarten würde ich ein paar Typen (strukturierten Variablen) definieren,
diese Typenadressen kannst du kann mit in den Gegner speichern, sodass du auf die verschiedenen Attribute zugreifen kannst.
Das spart etwas speicher, da nicht jeder Gegner seine Typ-Informationen selbst speichern muss, sondern von einer gemeinsammen Quelle beziehen kann.

Da die Schussanzahl und Art und Weise der Schüsse völlig unterschiedlich sind, abhängig vom Gegner, dachte ich das wäre so besser.

Und was Types sind weiß ich schon.
Für die Gegner dachte ich daher an eine Liste welche natürlich verschiedene Types bzw. Strukturvariablen beinhalten kann.

Oder versteh ich das jetzt falsch wie du das meinst?
Sonst müsstes du das etwas genauer erklären.

Also ich kann einfach eine Liste für alle Gegner erstellen die dann zeitabhängig erweitert bzw. verringert wird.

wenn jemand einen code posten will, für einen spieler, mehrere gegner die gleichzeitig auftauchen oder zu verschiedenen zeiten und unterschiedliche schüsse abfeuern...nur zu.ich bin ganz auge.
mir geht es nur um das theoretische verständnis.

[N_Gnom]

@Stargate und @all:
Könntest/Könntet Ihr mir vllt. einen kleinen Codeansatz dafür geben?

Also gehen wir von einem Playerschiff aus, zwei verschiedene Gegner und sagen wir mal 3 verschiedene Arten von Schüssen.

Wir würde so ein Grundgerüst nur dafür aussehen?
Also ich frage, weil ich ja nicht unnötig ein Gerüst bauen will, was später mal nix taugt wenn es zuviel zu verwalten gibt.

@Stargate: vorallem wie meinst du diesen Part: "Für die verschiedenen Gegnerarten würde ich ein paar Typen (strukturierten Variablen) definieren,
diese Typenadressen kannst du kann mit in den Gegner speichern, sodass du auf die verschiedenen Attribute zugreifen kannst."

Also erster Teil ist klar, Types bzw. Structure verschiedene Typen erstellen, aber was meinst du damit Typenadressen mit in den Gegnern speichern?

[STARGÅTE]

Also gehen wir von einem Playerschiff aus, zwei verschiedene Gegner und sagen wir mal 3 verschiedene Arten von Schüssen.

Also so würde ich das definieren, Spieler, Liste mit allen Gegnern, Liste mit allen Schüssen.

Code: Alles auswählen

Global Player.Player
Global NewList Enemy.Enemy()
Global NewList Bullet.Bullet()

Zur Struktur selbst am Beispiel von Bullet definiere ich alles was vorkommen könnte in der Struktur und den Typ von Schuss

Code: Alles auswählen

Structure Bullet
  *Type.BulletType
  X.f
  Y.f
  ...
EndStructure

Die Typen sehen so aus:

Code: Alles auswählen

Global Cool.BulletType
Cool\MaxSpeed = 10.0
Cool\Power = 12.0
Global Schwer.BulletType
Schwer\MaxSpeed = 1.0
Schwer\Power = 120.0

Beim erstellen der Bullets übergebe ich dann den jeweiligen Typ an das Bullet:

Code: Alles auswählen

AddElement(Bullet())
Bullet()\Type = @Cool

und kann dann später erfragen welcher Typ das ist: If Bullet()\Type = @Cool
und dann darauf reagieren.
Außerdem kann ich einfach über Bullet()\Type\Power die Kraft auslesen, jenachdem welcher Typ übergeben wurde.

[N_Gnom]

mit dem * und @ muss ich mich erstmal belesen.
* ist pointer klar, aber was ist @?

Ach auch ein pointer auf die struktur, oder?
Bin da noch recht neu in pb was so sachen betrifft.

[Bisonte]

Code: Alles auswählen

A = 10
Debug PeekI(@A) 

würde 10 ausgeben.

Ist also das @A nichts anderes als ein Zeiger auf die 10 im Speicher

[Danilo]

* ist pointer klar, aber was ist @?

Mit Zeigern greift man auf strukturierte Daten im Speicher zu, lesend und schreibend.
'@' ist der 'AddressOf'-Operator und gibt die Speicheradresse von Variablen, Prozeduren und Strings zurück.

Code: Alles auswählen

Macro AddressOf(var)
    @var
EndMacro


a = 10

Debug a
Debug AddressOf(a)


Debug "abc"
Debug AddressOf("abc")


Dim Array01.i(10)

For i = 0 To 9
    adresse = AddressOf( Array01(i) )
    Debug "Speicheradresse von Array01("+i+") = "+adresse+" ($"+Hex(adresse)+")"
Next


Procedure xyz()
    ProcedureReturn 123
EndProcedure

Debug xyz()
Debug AddressOf(xyz())