Tile Layer als Kollision verwenden?

  • GM 8

  • Tile Layer als Kollision verwenden?

    GM Studio Professional

    Tagchen allerseits =)

    Ich denke über eine alternative Methode für die Kollisionen in einem 2D Jump N Run nach. Bisher kenne ich es nur, dass man mit unsichtbaren Objekten die Kollisionselemente wie Boden, Decke, Wand etc. platziert. Bei großen Leveln kommen dann viele Objekte zusammen.

    Ich würd gern wissen ob man sich diese Methode sparen kann. Wenn ich mit meinem Tileset das Level gestalte habe ich ja mehrere Layer bzw. ich kann mehrere nutzen. Kann man alle gesetzten Tiles eines bestimmten Layers als Kollisionselement nehmen? Also überall wo Tiles in Layer 100030 platziert sind gibt es Kollision. Anhand der platzierten Grafiken sagen worauf der Spieler sich bewegen kann. So müsste man nur einen Code schreiben, der diese Funktion bestimmt und nicht tasuend Objekte für die Kollision platzieren.

    Geht das? Wäre das möglich? Würd mich riesig freuen wenn da jemand weiterhelfen kann.

    Besten Dank :)

  • Hey MegaManXL

    natürlich geht dies,... und ich verwende es auch sehr häufig.
    Allerdings funktioniert das nur mit Rechteckigen Formen,... weil das Tile keine Kollisionsmaske besitzt und deshalb immer den kompletten Tile (egal ob Transparent oder nicht) prüft,... umgehen kannst du dies nur indem du die Tiles kleiner machst und dann ne Pixelkante legst :P,...

    Die Funktion mit der man dies machen kann heißt

    GML-Quellcode

    1. tile_layer_find(depth,x,y)


    würde dir empfehlen einfach die Wand/Decke/Boden auf jeweils ne andere Depth zu legen und dann ne Fallunterscheidung durchzuführen,....

    Ob die Funktion allerdings schneller ist als das ganze mit Objekten zu machen, kann ich dir net garantieren,... aber rein vom Gefühl her müsste es gerade bei großen Räumen deutlich schneller gehen

    Ne andere Alternative wäre folgendes
    Du erstellst dir ein Script welches am Anfang alle Tiles der Map durchläuft und ne Collisionsmap erzeugt
    Spoiler anzeigen

    GML-Quellcode

    1. ///CreateCollisionMap
    2. var xx,yy,i,t,top,left,s;
    4. global.mapsize=floor(room_width/32)*floor(room_height/32);
    6. // Loop through the tile map, and find the tiles, then place them
    7. // in the "simple" collision map.
    8. for( yy=0;yy<room_height;yy+=32)
    9. {
    10. s="";
    11. for( xx=0;xx<room_width;xx+=32)
    12. {
    13. i = (xx/32)+((yy/32)*(room_width/32));
    14. global.map[i]=-1;
    15. t = tile_layer_find(10,xx,yy);
    16. if( t>=0 )
    17. {
    18. s = s+"1";
    19. left = tile_get_left(t);
    20. global.map[i]=left/32;
    21. }else
    22. s = s+"_";
    23. }
    24. show_debug_message(s);
    25. }
    Alles anzeigen


    Anschließend prüfst du bei jeder Bewegung ob du Collidierst

    STEP:
    Spoiler anzeigen

    GML-Quellcode

    1. /// Process the player (move+collision)
    2. var xx,yy,c1,c2;
    4. /// Do payer "jump"
    5. if( !jump )
    6. {
    7. if( keys[JUMP_KEY] ) {
    8. grav=-8;
    9. jump=true;
    10. }
    11. }
    15. // Apply gravity (and jumping)
    16. y = y+grav;
    17. grav+=0.4;
    18. if( grav>=10 ) grav=10;
    20. // If falling, check UNDER the player
    21. if( grav<0 )
    22. {
    23. if( dir=1){
    24. sprite_index = jump_right;
    25. }else{
    26. sprite_index = jump_left;
    27. }
    28. c2 = -1;
    29. c1 = GetCollision(x,y);
    30. if( (x&$1f)>0 ) {
    31. c2=GetCollision(x+32,y);
    32. }
    33. if( c1>=0 || c2>=0 )
    34. {
    35. grav=0;
    36. y = (y&$ffffffe0)+32;
    37. }
    38. }
    39. else{
    40. // Otherwise, check above player
    41. if( jump )
    42. {
    43. if( dir=1){
    44. sprite_index = fall_right;
    45. }else{
    46. sprite_index = fall_left;
    47. }
    48. }else{
    49. grav=0;
    50. jump=true;
    51. }
    52. c2 = -1;
    53. c1 = GetCollision(x,y+32);
    54. if( (x&$1f)>0 ) {
    55. c2=GetCollision(x+32,y+32);
    56. }
    57. if( c1>=0 || c2>=0 )
    58. {
    59. y = (y&$ffffffe0);
    60. jump=0;
    62. if( dir=1){
    63. sprite_index = walk_right;
    64. }else{
    65. sprite_index = walk_left;
    66. }
    67. }
    68. }
    73. // If moving left, check LEFT collision
    74. if( keys[LEFT_KEY] )
    75. {
    76. dir=-1;
    77. if(!jump){
    78. sprite_index = walk_left;
    79. }
    80. x=x-xspeed;
    81. c2=-1;
    82. c1 = GetCollision(x,y);
    83. if( (y&$1f)>0 ) c2=GetCollision(x,y+32);
    84. if( c1>=0 ) || ( c2>=0 )
    85. {
    86. x = (x&$ffffffe0)+32;
    87. }
    88. }else if(keys[RIGHT_KEY] )
    89. {
    90. // Otherwise, check collision to the right
    91. dir=1;
    92. if(!jump){
    93. sprite_index = walk_right;
    94. }
    95. x=x+xspeed;
    96. c2 = -1;
    97. c1 = GetCollision(x+32,y);
    98. if( (y&$1f)>0 ) c2=GetCollision(x+32,y+32);
    99. if( c1>=0 ) || ( c2>=0 )
    100. {
    101. x = (x&$ffffffe0);
    102. }
    103. } else {
    104. // If standing still, don't animate
    105. image_index =0;
    106. }
    Alles anzeigen


    Das Script welches die Aktuellen Koordinaten prüft

    Script GetCollision
    Spoiler anzeigen

    GML-Quellcode

    1. ///GetCollision
    2. // argument0 = X coordinate to get tile (in pixels, not tiles)
    3. // argument1 = Y coordinate to get tile (in pixels, not tiles)
    4. //
    5. if( argument0>=room_width ) return -1;
    6. if( argument1>=room_height ) return -1;
    7. if( argument0<0) return -1;
    8. if( argument1<0) return -1;
    10. var xx,yy;
    12. xx = floor(argument0/32) + (floor(argument1/32) * floor(room_width/32));
    13. if( global.mapsize<xx ) return -1;
    14. return global.map[ xx ];
    Alles anzeigen



    Ich habe dieses Beispiel mal in einem Game Maker Tutorial gefunden und dachte vielleicht hilft es dir ja weiter ^^

    Grüße Blayde

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Blayde ()

  • DAS ist wunderbar!

    In MegaMan ist jedes Tile 16x16 Pixel groß. Da bedeuten Wand, Boden, Decke alle das selbe -> Kollision. Und es gibt in diesem Fall nirgends Tiles, die halbtransparent sind und für den Kollisionslayer benutzt werden. Rein für das Design wo es nicht um Kollision geht in anderen Layern gibts natürlich auch teils transparente Tiles. Bei diesem Spiel bedeutet es also: Wenn da ein Tile platziert ist dann ist es immer 16x16 Pixel groß, quadratisch.

    Das bedeutet ich kann sogar unterschiedliche Kollisionslayer machen oder? In einem zweiten Layer würde ich dann Stacheln setzen, die MegaMan bei der Berührung sofort zerstören. Ein anderer Layer gilt dann für Leitern an den MegaMan hoch und runter klettern kann. Noch ein Layer für Wasser in die Gravitation und Bewegungsgeschwindigkeit anders sind usw ....

    Das beste wäre dann ich verwende für jedes Level die gleiche Layer-Struktur oder? Also Layer 100030 immer für die normale Kollision. Layer 100040 für Stacheln usw...

    Seh ich das so richtig? Ich finde diese Vorgehensweise wesentlich eleganter als zighundert Kollisionsblöcke zu setzen.

  • Atomicmaster schrieb:

    Und es sollte natürlich machbar sein verschiedene Kollisionslayer zu machen.


    Das ist perfekt! Dann brauch ich mir keine unnützen Gedanken mehr über Kollisionsobjekte zu machen. Mein Bauchgefühl sagt mir ohnehin, dass es mit der Layermethode besser läuft.