Auto tiling

  • GM 8

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Auto tiling

    Hey zusammen,
    zurzeit sitze ich an einem kleinen Projekt und komme nicht so recht weiter. Um genauer zu sein Klebe ich beim Auto tiling fest. Ich hab ein zwei dimensionales Array das je nach tileset bzw. Id die Werte speichert.. Aber weiter komm ich schon nicht mehr :-/ hat jemand Ahnung wie man generell so ein Auto tiling codet? Also ich will genau so was hier hin bekommen:


    Ich habe zwar schon im yoyogames Forum was gefunden, aber ich will es selbst hin bekommen, zum Verständnis wie das geht :)

    Edit: Klasse wäre wenn sich das ganze rein im Array abspielt, also ohne Instanzen bzw. Kollisionen zu überprüfen! :)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von darulaz ()

  • Hier hilft dir ein 2D Array was den Breite-index von "room_width/tile_width" und "room_height/tile_height" hat.
    jetzt machste das nach einem Zahlenmuster/Raster/Grid:

    GML-Quellcode

    1. //0 = Tile ID "Erde"
    2. //1 = Tile ID "Gras"
    3. //2 = Tile ID "Gras linker Rand"
    4. //3 = ... usw.

    Sagen wir mal, deine Map ist 10x5 Tiles in den Dimensionen:

    Quellcode

    1. 0000000000
    2. 0000000000
    3. 0000000000
    4. 0000000000
    5. 0000000000
    6. //jede Null ist ein Platz/Tile

    ...und jede Position ist ein Tile ID aus deinem 2 dimensionalem 10x5 Array:

    Quellcode

    1. 0000000000
    2. 0000000000
    3. 0000010000
    4. 0000000000
    5. 0000000000
    6. //Die "1" in diesem Grid ist zu finden unter Array[x6,y3]=1;

    Jetzt beginnt die Mathematik:
    - Dein Cursor mit dem Tile entspricht der Position Array[xMouse,yMouse]:
    [kurzer Edit hier: Meine Rechnung ergab nich viel Sinn :P]

    GML-Quellcode

    1. ax = round(mouse_x/tile_width);
    2. ay = round(mouse_y/tile_height);

    ...Da'de jetzt weisst, wo deine Mouse sich im Raster/Grid befindet, kannste das jetzt transferieren zu deinem Array, sobald du ein Tile setzt:
    [Click Event]

    GML-Quellcode

    1. Array[ax,ay]=TileID; //das bedeutet folgendes: Im Map-Array/Raster/Grid wird jetzt die TileID eingetragen. sprich 1 fuer Gras.

    Natuerlich musste auch hergehen, und ABFRAGEN, was fuer Tiles mit welcher ID drum herumgesetzt wurden. Ich mach jetzt hier blos'n kleines Beispiel:

    GML-Quellcode

    1. if (Array[ax-1,ay]==TileID"Erde") //Array[ax-1,ay] ist logischer weise 1 Schritt nach links von deiner Maus-GridPosition . Ein Schritt nach Rechts waere dann: Array[ax+1,ay].
    2. {
    3. Array[ax-1,ay]=TileID"GrasRandLinks";
    4. };

    Ich hoffe, du hast genug Kenntnisse vorneweg, um dieses System zu verstehen. Ansonsten, einfach mal nach'nem fertig-geschriebenen Map-Editor nachgooogeln. :)

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von Nightrage ()

  • Ich kann dir GARANTIEREN, dass du um eine Abfrage NICHT herumkommst ^^
    Der Code muss schliesslich berechnen, was zutun is "WENN (IF)" nur Erde um ein einzigem Tile ist... soll er nun Raender machen, oder nur teilweise, oder gar nix. Da is nichts ohne Abfrage zu machen.
    Und wenn'de's doch hinbekommst, geht dabei Flexibilitaet drauf, da wett ich was.
    Wenn es um exceptions und random conditions geht ist eine if-Construction oftmals die ERSTE Wahl.
    Wenn nich, dann belehrt mich eines Anderem. Aber ich bleib dabei, Abfrage ist ein must have .

    Und ausserdem, kannste das mit einer einzigsten Zeile an Code machen, wenn du klickst:

    Quellcode

    1. tile_place(ID);

    und im Script steht dann:

    GML-Quellcode

    1. //tile_place(argument0-TileID);
    2. //links
    3. if (array[ax-1,ay]==TileErde)
    4. {
    5. array[ax-1,ay]=tile[argument0,RandLinks];
    6. };
    7. //rechts
    8. if (array[ax+1,ay]==TileErde)
    9. {
    10. array[ax+1,ay]=tile[argument0,RandRechts];
    11. };
    12. //oben
    13. if (array[ax,ay-1]==TileErde)
    14. {
    15. array[ax,ay-1]=tile[argument0,RandOben];
    16. };
    17. //unten
    18. if (array[ax,ay+1]==TileErde)
    19. {
    20. array[ax,ay+1]=tile[argument0,RandUnten];
    21. };
    22. //oben links
    23. if (array[ax-1,ay-1]==TileErde)
    24. {
    25. array[ax-1,ay-1]=tile[argument0,RandLinks];
    26. };
    27. //oben rechts
    28. if (array[ax+1,ay-1]==TileErde)
    29. {
    30. array[ax+1,ay-1]=tile[argument0,RandRechts];
    31. };
    32. //und dann noch die zwei unteren Ecken abfragen, und die Mitten(oben und unten).
    Alles anzeigen

    als Beispiel.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Nightrage ()

  • bin mir nicht sicher, ob das das richtige ist, ich hatte aber mal das gleiche problem
    Mit der Letzten antowort, kannst du das mit nur 4 if abfragen, für ALLE situationen, die mit blöcken die links rechts oben unten davon sind, lösen.

    Ich hätte eine Möglichkeit die sehr viel schneller ist und einfach. Dazu bracht man jedoch 15 Bilder. GML

    GML-Quellcode

    1. var bildindex,xx,yy;
    3. xx=floor(x/16)
    4. yy=floor(y/16)
    5. bildindex = 0
    6. image_speed=0
    8. if(ds_grid_get(variable_global_get("map_0"),xx-1,yy)!="") bildindex += 1
    9. if(ds_grid_get(variable_global_get("map_0"),xx+1,yy)!="") bildindex += 2
    10. if(ds_grid_get(variable_global_get("map_0"),xx,yy-1)!="") bildindex += 4
    11. if(ds_grid_get(variable_global_get("map_0"),xx,yy+1)!="") bildindex += 8
    13. image_index = bildindex
    Alles anzeigen


    Es funktioniert im Bytesystem. Es prüft nur oben, unten und links, rechts da alles andere in diesem Fall überflüssig währe. Ansonsten bräuchte man 255 Bilder für jede Situation. Die Bilder müssen in die richtige Reihenfolge gebracht werden, welche sich ergeben. Einfach mal anstatt des Sprites den image_index drawen lassen, so kann man sehen welches Bild für diese Nummer benötigt wird.


    Das müsste doch eigentlich auf deins übertragbar sein?

  • Das geht definitiv auch ohne if-abfragen. Und zwar mit logischen Verknüpfungen.

    Bei mir sah das in etwa so aus:

    GML-Quellcode

    1. return
    2. 1*ds_grid_get(map,h+1,v)
    3. 2*ds_grid_get(map,h,v-1)
    4. 4*ds_grid_get(map,h-1,v)
    5. 8*ds_grid_get(map,h,v+1);

    Das Ergebnis war eins von 16 Sprite-Subimages (die sollten natürlich in der richtigen Reihenfolge vorliegen).
    Mit Tiles ist es etwas anders weil man keinen Sub-Index hat, aber den kannst Du ja selber anlegen.