Mehrdimensionale Arrays (3 oder 4 Dimensionen)

Schattenphoenix · 4. Januar 2009, 17:54

Ich wollte mal fragen, ob zufällig jemand ein Script oder wahrscheinlich eher eine DLL hat um 3 oder 4 dimensionale Arrays zu verwenden?

Es würde viele sachen vereinfachen für mein derzeitiges Projekt und ich dachte, dass es für Leute, die eine höhere Sprache (c++ o.ä.) beherrschen nicht sonderlich umständlich sein sollte, so etwas zu schreiben.
Demnach denke ich wird schon irgendwo eine kursieren, jedoch konnte ich keine finden.

Also nochmal, hat zufällig jemand eine solche DLL parat oder kann evtl. eine für mich schreiben?

Danke im vorraus

EDIT: Ausserdem wäre es nett, wenn jemand eine Idee hätte, wie man die Array-Maximalgröße umgehen kann, da ich jetzt eine Möglichkeit habe, 3d Arrays zu erstellen, welches jedoch schnell an die grenze von 32000 Werten pro Array stößt.

EDIT2: Nvm. hab den Leistungs- und Speicherbedarf unterschätzt.

Dragoon · 4. Januar 2009, 18:47

Sag uns lieber mal warum du denkst 4-dimensionale Arrays zu benötigen, meistens reichen 2 Dimensionen locker aus.
Es wird übrigens nicht möglich sein eine solche DLL zu verwenden, irgendwie müssen die Daten irgendwann wieder in den GM und dann hast du wieder nur 2-dimensionale Arrays.

Schattenphoenix · 4. Januar 2009, 21:46

Ich hatte vor in dem 3-dimensionalem Array Koordinaten zu speichern die an einem Grid ausgerichtet sind.

Und dieses Array würde ich abfragen um mit 1 Objekt Kollisionen und Draw-Events zu verwalten.

Es geht genauer gesagt um Blöcke, die in diesem Raster liegen sollen und ich dachte es wäre relativ einfach das ganze so zu machen indem ich die Position des Blockes mit floor(x/16) floor(y/16) und floor(z/16) ins array zu stecken.

Da es eh Würfel sind, könnte man so auch Kollisionen leicht handhaben indem man die Koordinaten von Schüssen über rund x,y,z geteilt durch 16 ins Grid steckt und schaut, ob dort etwas ist.

3 Dimensional würde für Positionen reichen, 4 Dimensional wäre mir aber lieber um auch Eigenschaften der Blöcke dort drin zu speichern.

Dann wäre dimension1 = x, dimension2 = y, dimension3 = z und dimension4 wären eigenschaften von 0 bis irgendwas.
Das würde sich über ID's lösen lassen.

Lange Rede, garkein Sinn, fakt ist, dass ich auf jeden Fall einen nutzen hab... und ich bin mir relativ sicher, dass es so am leichtesten und bequemsten geht.

knuckles12 · 5. Januar 2009, 12:13

muste halt 16 2 dimensionale arrays erstellen.
anders geht das mit dem gm nicht, wie dragoon schon erwähnt hat.

-kn12

Dragoon · 5. Januar 2009, 14:39

Das könntest du mit einem Grid lösen. Erst erstellst du ein Grid für die x und y Koordinaten (ds_grid_create(room_width/16,room_height/16)) und dann kannst du in dieses eine Liste in jede Zelle einfügen.
Übringens kannst du dir eine Dimension sparen wenn du nur x,y,z verwendest, dann im Array aber gleich die 'Art' des Blockes einfügst.

Phoenix · 5. Januar 2009, 15:16

Ich glaube, dass "Schachteln" helfen sollte ( zb. ArrayEins [ ArrayZwei [ 0 , 0 ] , ArrayDrei [ 0 , 0 ]] )

EDIT: Nr 100 :sauf:

MewX · 5. Januar 2009, 16:06

Wie soll so eine Schachtel praktisch funktionieren?

CAS · 5. Januar 2009, 20:58

Wieviel Speicher kostet eine Instanz? Und wie wirken sich Objekte ohne jedes Event, auch ohne Draw Event, auf die Performance aus?
Ansonsten könnte man sich, wenn man die Datenstrukturen des GM nicht mag (siehe hier, und weiß, welche Ausmaße das Array maximal annimmt, mit folgender Krücke helfen:

1.: Man erstelle sich ein Objekt, und nenne das Entsprechend, z.b. obj_container.
2.: Man legt sich sein Array an:

GML-Quellcode

for( i:=0; i<x_len; i+=1 )
{
for( j:=0; j<y_len; j+=1 )
{
array[i,j]=instance_create(0,0,obj_container);
}
}

3.: Man greift auf sein Array zu:

GML-Quellcode

array[a,b].array1[c,d]=foo;

Dabei kann man, falls man mehrere Objekte dieser Sorte benötigt, diese Objekte gleich recyclen:

GML-Quellcode

array[a,b].array2[c,d]=foo;

Und wenn man zwischendurch mal eine Dimension weniger braucht, lässt man am Ende einfach eine Dimension weg:

GML-Quellcode

array[a,b].array3[code=c]=foo;

Wichtig ist hierbei, dass a und b immer im Intervall [0;max_x) bzw. [0;max_y) liegen.

Falls man nur 3-Dimensionale Arrays braucht, sollte man aber besser array[a].array1[b,c] als array[a,b].array1[code=c] verwenden, da dabei weniger Objekte erzeugt werden müssen (vorhin war letzteres nur deshalb angebrachter, da die Objekte ja ohnehin schon erzeugt wurden).

Falls einem 4 Dimensionen immer noch nicht ausreichen, kann man dieses Spielchen weiter treiben:
[gml]array[a,b].array1[c,d].array1[e,f].array1[g,h]... usw.

Hierbei muss man aber schön darauf achten, alle 2 Dimensionen erst Instanzen zu erzeugen, bevor man weiter macht, wobei der Speicherbedarf exponentiell wächst.

Schattenphoenix · 5. Januar 2009, 23:40

Das mit den Schachteln funktioniert irgendwie, ich hab im Internet nochmal genauer geschaut und eine extension gefunden, die sachen verschachtelt (obwohl glaube ich in der Hilfe irgendwo steht, dass der GM keine Arrays in Arrays unterstützt).

Das, was ich damit im Endeffekt bewirken wollte, ist, dass ein Objekt alle Blöcke mit einem mal verwaltet.
Das Problematische dabei ist, dass er in jedem Step ein Array von bis zu 32000 Werten KOMPLETT durchgehen muss, um sie alle zu zeichnen.
Das Bewirkt automatisch extreme Performance Probleme (3D Array mir 3-Fach geschachtelter FOR-Schleife auslesen).

Nun werd ich nochmal schauen, dass ich es ein wenig anders verwalte. Vllt fällt mir noch was tolles ein.
Ne möglichkeit wäre es, ein 2D Array zusätzlich zu nehmen, indem man die "Wirklich aktiven bzw. vorhandenen Blöcke" gelistet sind mit der jeweiligen position etc.

Dann könnte man zwischendurch das komplette aktuallisieren und es würde weniger Leistung fressen.

Werd ma schaun, wie ich das mache. im Theoretischen klappt es schon und ich werd nachher mal die gmk dazu hochladen. Editier ich dann hier rein

EDIT: Is jetzt drin. Warum kann man eigentlich keine gm6, gmk und ähnliche direkt hochladen?

MewX · 6. Januar 2009, 18:43

Deine hochgeladene Datei benötigt die Extension...

Aber wie auch immer, ich denke, wenn man wirklich wirklich einen 3D-Array braucht, macht man besser das hier:

GML-Quellcode

execute_string("variablenname"+string(x)+"["+string(y)+","+string(depth)+"] = "+string(zahl));

Ne andere Möglichkeit wäre für jeden Array ein Objekt zu erstellen mit lokalen Variablen und deren Arrays in einer Map zu speichern. Die könnten dann wiederum Maps mit Ids von anderen Objekten und... lassen wir das.

blubberblub · 6. Januar 2009, 19:58

Ohne jetzt die ganzen Replies zu studieren(nur überflogen =P), fällt mir doch ganz spontan ds_list_create ein..

GML-Quellcode

x=ds_list_create()
ds_list_find_value(x,y)=ds_list_create()
ds_list_find_value(y,z)=ds_list_create

so halt

Dragoon · 7. Januar 2009, 11:50

Ich hab mal meinen Lösungsweg in drei Scripte umgewandelt:
scr_init(room_width,room_height,room_depth) //Breite, Höhe und Tiefe des Raumes

GML-Quellcode

var ix,iy,i;
gr_xy=ds_grid_create(argument0/16,argument1/16);
for(ix=0;ix<ds_grid_width(gr_xy);ix+=1)
{
for(iy=0;iy<ds_grid_height(gr_xy);iy+=1)
{
lsid=ds_list_create();
for(i=0;i<argument2/16;i+=1)
{
ds_list_add(lsid,0);
}
ds_grid_set(gr_xy,ix,iy,lsid);
}
}

Alles anzeigen

scr_set(x,y,z,kind) //x,y,z und die Art des zu setzenden Steines

GML-Quellcode

{
ds_list_replace(ds_grid_get(gr_xy,floor(argument0/16),floor(argument1/16)),floor(argument2/16),argument3);
}

scr_get(x,y,z) //x,y,z der abzufragenden Stelle (gibt die Art des dortigen Steines oder 0 zurück)

GML-Quellcode

{
return ds_list_find_value(ds_grid_get(gr_xy,floor(argument0/16),floor(argument1/16)),floor(argument2/16));
}

EDIT: Fehler im Code behoben, natürlich muss es ds_grid_height(...) heissen.

Schattenphoenix · 7. Januar 2009, 20:29

Ist die Extension nicht in der Datei enthalten?

Zur not ist sie hier nochmal...

@Dragoon: Werd ich bei gelegenheit nochmal genauer drüberschauen. Ich weiss nicht ob man in Extensions reinschauen kann, aber wenn ich Fehler verursache, zeigt er mir Teile des Codes in der Extension und da hab ich gesehen, dass es über 2Dimensionale Arrays läuft, die jeweils 2 verschiedene 2D arrays beinhalten. Irgendwie so zumindest.

GML-Quellcode

var ix,iy,i;

gr_xy=ds_grid_create(argument0/16,argument1/16);

for(ix=0;ix<ds_grid_width(gr_xy);ix+=1)

{

for(iy=0;iy<ds_grid_width(gr_xy);iy+=1)

{

lsid=ds_list_create();

for(i=0;i<argument2/16;i+=1)

{

ds_list_add(lsid,0);

}

ds_grid_set(gr_xy,ix,iy,lsid);

}

}

Alles anzeigen

Ich weiss nicht, obs an mir liegt... aber könnte es sein, dass du 2 mal die width des gleichen grids abfragst?
Müsstest du dann nich ds_grid_height im 2. nehmen?
Zumindest entzieht sich das meiner verständnis.

Sonst sieht es relativ solide aus. (Noch ungetestet)