PureBoard

Ich habe gestern versucht den Enumeration Befehl mit einer Schleife zu verwenden, bin aber recht gescheitert.

Es sind etliche Sprites, die dort ihre Konstante bekommen sollen. Mal abgesehen davon ob es sinnvoll ist, das so zu machen, würde mich interessieren, ob überhaupt ein Handling von Konstanten als Ausdruck (somit Verarbeitung in Schleifen) möglich ist.


Ich hatte zB probiert:
for i=0 to 7
#sprite_i
next

Dass das nicht gehen kann, leutet irgendwie ein, die Konstante #sprite_i ist nach dem ersten Durchlauf erklärt und das "i" hat zu dem "i" der Schleife gar keinen Bezug. Ich habe auch ein paar andere Wege versucht, ging aber alles schief. zB zuerst einen string zu machen aus "#sprite_"+str(i), aber das ging wohl so auch nicht, denn dann hatte ich immer noch keine Konstante, nur eine verwirrende Schreibweise...
Im Handbuch habe ich nichts gefunden wie man in Konstanten einen Ausdruck benutzen könnte.

Vielleicht ist es auch in sich ein unlogischer Gedanke, Konstanten wie Variablen verarbeiten zu wollen...oder hat jemand eine Idee dazu?

Gruss
Mipooh

mipooh hat geschrieben:Vielleicht ist es auch in sich ein unlogischer Gedanke, Konstanten wie Variablen verarbeiten zu wollen...oder hat jemand eine Idee dazu?

Du gibst Dir quasi selbst die richtige Antwort !

Konstanten sind "konstant", also zur Laufzeit des Programms nicht mehr veränderbar.

Daher werden diese in einem PureBasic-Code in der Regel am Anfang deklariert (einzeln mit #Konstante = 10 oder mit Enumeration-"Aufzählungen", siehe dazu die Hilfe).

Veränderbare "Speicherplätze" für Zahlenwerte sind die Variablen mit ihren unterschiedlichen Typen, also ohne das #.

...aber wenn ich Dich richtig verstehe, bringen Dich Variablen bei Deiner Problem-
stellung auch nicht weiter. Versuchst Du Variablen dynamisch zu erzeugen,
so wie das z.B. in JavaScript mittels eval() (evil eval) möglich ist?

Ich weiß nicht genau, wofür Du das brauchst, aber vielleicht hilft die #PB_Any etwas ? Dann brauchst Du nicht allen Sprites eine Konstante geben, sondern kannst deren Rückgabewert als Identifier nutzen, und diese bei vielen Sprites z.B. in einem Array speichern.

@mipooh

Der erste Aspekt Deines Problems betrifft die Compile-Zeit.
Da müssen die Konstanten ihre Namen bekommen damit ihnen die Enumeration Werte zuweisen kann.
Es wäre also zu fragen, ob dafür nicht etwa eine solche Konstruktion geschaffen werden kann :

#sprite_1 To #sprite_32

Der zweite Aspekt betrifft die Laufzeit des Programmes. Da kann man sehr wohl die per Enumeration festgelegten Werte in Schleifen verwenden :

For idx = #sprite_1 To #sprite_32
FreeSprite(idx)
Next

ich verstehe nicht ganz, wozu hier ein enum auf die konstanten gebraucht wird...

schreib doch einfach die zahlen null bis sieben...
in meinen augen ist es unnütz, hier konstanten zu verwenden...

du brauchst doch maximal ne anfangs-zahl, wenn deine sprites eh aufeinanderfolgen...

also
#SpriteTable = Wasauchimmer

DisplaySprite(#SpriteTable + Nr, ....

@Kaeru Gaman

In der Enumeration steht zB. :

#Auchschonwas
#Sprite_Table
#Nochetwas1
#Nochetwas2

Wo landet dann wohl #Sprite_Table + Nr ???

Das würde nur funktionieren, wenn Sprites eine eigene Enumerationsfolge hätten. Ist das so?

> Das würde nur funktionieren, wenn Sprites eine eigene Enumerationsfolge hätten. Ist das so?

also ich würde es halt so machen, ich arbeite eh nicht mit enums oder vielen konstanten...

meine sprites sind nach themen gruppiert, also, z.b. 100-116, 120-136, 200-287 etc...

im grunde ist meine spritenr. schon fast ein sprechender code,
ich brauche da keine konstantennamen an der stelle...

(die einzige konstante, die ich häufig verwende ist #pi oder derivate davon.)

Also entstanden war das Ganze aus der Erweiterung bzw dem Herumspielen des Codes aus dem Tutorial für Spiele (Spiele für Fortgeschrittene).
Dort wurde enumeration verwendet um die wenigen Sprites zu einer Liste zuzuordnen.
Die Begründung war soweit ok und dann habe ich Sprites ausgewechselt und musste wegen vieler Einzelbilder auf einmal eine Menge Sprites zuordnen.
Da die quasi durchnumeriert waren, kam ich auf die Idee das durch eine Schleife zu tun. Was ja bekanntlich nicht ging...

enumeration
sprite_1 to sprite_50
endenumeration

geht ja nun mal nicht.

Meine Lösung war letztlich mit Variablen zu arbeiten bzw mehreren Dim Deklarationen. (Es waren mehrere Bildfolgen für verschiedene animierte Sprites.)
Diese Lösung gefällt mir auch ganz gut: #sprite_1 To #sprite_32
War gar nicht auf die Idee gekommen, dass nach enumeration alle diese #sprite_x -Werte ja aufeinanderfolgende Zahlen sind und ich sie direkt als Zähler in der Schleife einsetzen kann.

Wonach ich gesucht hätte, das wäre die Möglichkeit, Konstanten dadurch zu verwenden, dass ich sie als Ausdruck schreibe. Ich wollte sie nicht verändern, sondern lediglich "schleifengerechter" schreiben bzw sie ja bereits durch eine Schleife erzeugen...aber die Lösung ist klar. Wenn sie aufeinanderfolgen, sind sie die Zähler der Schleife.

PB_ANY zu verwenden erscheint mir aufwändiger als andere Lösungen, da man dazu ja zusätzlich die Rückgabewerte braucht.

Na zumindest waren alle Eure Anregungen eine Überlegung wert. Enumeration für Sprites zu verwenden erscheint mir ab einer gewissen Menge keine gute Idee mehr...

Vielen Dank,
Mipooh

mipooh hat geschrieben:enumeration
sprite_1 to sprite_50
endenumeration

geht ja nun mal nicht.

Ja, ist auch irgendwie klar.

Sonst müsste eine einheitliche Regel definiert werden, die aus den Namen der Konstanten (oder Variablen) automatisch den Bereich von-bis rausfiltert.

Das würde hier bedeuten: alles was nach dem "_" steht, muss eine Zahl sein und die müsste der Compiler ausfiltern (im Beispiel 1 und 50) und daraus den Bereich und die Anzahl der zu deklarierenden Konstanten/Variablen definieren.

Ob das so sinnvoll ist ? Am Ende möchte jeder seine eigene Art und Weise der Namenskonventionen festlegen und jede soll der Compiler unterstützen...