Auto Tiling Kollisionen spielen verrückt

  • Auto Tiling Kollisionen spielen verrückt

    Servus gm-d Community,
    Ich habe vor kurzem das Layout von meinen Tileset sheets geändert, weshalb ich auch entsprechend das Script anpassen musste.
    Vorher hatte ich das Ganze mathematisch geordnet (Nach dem Binärsystem, Oben Links beginnend), nun allerdings in einem optisch schöneren und leichter zusammzustellbaren Format.

    Entsprechend musste ich meinen Code anpassen.

    Nun habe ich allerdings das Problem das die Kollisonsüberprüfungen eigenartige Ergebnisse liefern, weshalb auch das Tiling nicht mehr ganz will.
    Der wesentliche Unterschied ist, dass ich die Tilegröße von 32 auf 16 pixel reduziert habe, wofür ich mir allerdings extra ein Attribut bereit gestellt hatte.

    Ich denke mal nicht das es nötig ist, dass ihr euch jeden Fall einzeln anguckt, da diese an sich stimmen sollten.
    Das einzige Problem sind meine Kollisionen, wie der debug Modus schön zeigt.

    Ich hoffe, dass ihr irgendwo Logikfehler finden könnt.
    Spoiler anzeigen

    GML-Quellcode

    1. var dst, obj, U, D, L, R, UL, UR, DL, DR;
    3. dst = 16; //Distance between each other
    4. obj = object_index; //Only autotile with instances like yourself
    5. U = instance_position(x,y-dst,obj); //Up
    6. D = instance_position(x,y+dst,obj); //Down
    7. L = instance_position(x-dst,y,obj); //Left
    8. R = instance_position(x+dst,y,obj); //Right
    9. UL = instance_position(x-dst,y-dst,obj); //UpLeft
    10. UR = instance_position(x+dst,y-dst,obj); //UpRight
    11. DL = instance_position(x-dst,y+dst,obj); //DownLeft
    12. DR = instance_position(x+dst,y+dst,obj); //DownRight
    15. image_speed = 0; //Don't play the animation
    17. //Cases Start//
    19. // Block'o'9
    21. if (!U && D && !L && R && !UL && !UR && !DL && DR)
    22. {
    23. image_index = 0;
    24. }
    26. if (!U && (D) && (L) && (R) && !UL && !UR && (DL) && (DR))
    27. {
    28. image_index = 1;
    29. }
    31. if (!U && (D) && (L) && !R && !UL && !UR && (DL) && !DR)
    32. {
    33. image_index = 2;
    34. }
    36. if ((U) && (D) && !L && (R) && !UL && (UR) && !DL && (DR))
    37. {
    38. image_index = 15;
    39. }
    41. if ((U) && (D) && (L) && (R) && (UL) && (UR) && (DL) && (DR))
    42. {
    43. image_index = 16;
    44. }
    46. if ((U) && (D) && (L) && !R && (UL) && !UR && (DL) && !DR)
    47. {
    48. image_index = 17;
    49. }
    51. if ((U) && !D && !L && (R) && !UL && (UR) && !DL && !DR)
    52. {
    53. image_index = 30;
    54. }
    56. if ((U) && !D && (L) && (R) && (UL) && (UR) && !DL && !DR)
    57. {
    58. image_index = 31;
    59. }
    61. if((U) && !D && (L) && !R && (UL) && !UR && !DL && !DR)
    62. {
    63. image_index = 32;
    64. }
    66. //Platform Horizontal
    68. if (!U && !D && !L && (R) && !UL && !UR && !DL && !DR)
    69. {
    70. image_index = 3;
    71. }
    73. if (!U && !D && (L) && (R) && !UL && !UR && !DL && !DR)
    74. {
    75. image_index = 4;
    76. }
    78. if (!U && !D && (L) && !R && !UL && !UR && !DL && !DR)
    79. {
    80. image_index = 5;
    81. }
    83. //Edge + Inner Edge
    85. if (!U && (D) && !L && (R) && !UL && !UR && !DL && !DR)
    86. {
    87. image_index = 18;
    88. }
    90. if (!U && (D) && (L) && !R && !UL && !UR && !DL && !DR)
    91. {
    92. image_index = 19;
    93. }
    95. if ((U) && !D && !L && (R) && !UL && !UR && !DL && !DR)
    96. {
    97. image_index = 33;
    98. }
    100. if ((U) && !D && (L) && !R && !UL && !UR && !DL && !DR)
    101. {
    102. image_index = 34;
    103. }
    105. //image_index 35 is free
    107. //Single Platform
    109. if (!U && !D && !L && !R && !UL && !UR && !DL && !DR)
    110. {
    111. image_index = 20;
    112. }
    114. //Platform Vertical
    116. if (!U && (D) && !L && !R && !UL && !UR && !DL && !DR)
    117. {
    118. image_index = 6;
    119. }
    121. if ((U) && (D) && !L && !R && !UL && !UR && !DL && !DR)
    122. {
    123. image_index = 21;
    124. }
    126. if ((U) && !D && !L && !R && !UL && !UR && !DL && !DR)
    127. {
    128. image_index = 36;
    129. }
    131. //T Crossings
    132. if ((U) && (D) && (L) && !R && !UL && !UR && !DL && !DR)
    133. {
    134. image_index = 7;
    135. }
    137. if ((U) && (D) && (L) && !R && (UL) && !UR && !DL && !DR)
    138. {
    139. image_index = 8;
    140. }
    142. if ((U) && (D) && (L) && !R && !UL && !UR && (DL) && !DR)
    143. {
    144. image_index = 9;
    145. }
    147. if ((U) && !D && (L) && (R) && !UL && !UR && !DL && !DR)
    148. {
    149. image_index = 22;
    150. }
    152. if ((U) && !D && (L) && (R) && (UL) && !UR && !DL && !DR)
    153. {
    154. image_index = 23;
    155. }
    157. if ((U) && !D && (L) && (R) && !UL && (UR) && !DL && !DR)
    158. {
    159. image_index = 24;
    160. }
    162. if ((U) && (D) && !L && (R) && !UL && !UR && !DL && !DR)
    163. {
    164. image_index = 37;
    165. }
    167. if ((U) && (D) && !L && (R) && !UL && (UR) && !DL && !DR)
    168. {
    169. image_index = 38;
    170. }
    172. if ((U) && (D) && !L && (R) && !UL && !UR && !DL && (DR))
    173. {
    174. image_index = 39;
    175. }
    177. if (!U && (D) && (L) && (R) && !UL && !UR && !DL && !DR)
    178. {
    179. image_index = 52;
    180. }
    182. if (!U && (D) && (L) && (R) && !UL && !UR && (DL) && !DR)
    183. {
    184. image_index = 53;
    185. }
    187. if (!U && (D) && (L) && (R) &&!UL && !UR && !DL && (DR))
    188. {
    189. image_index = 54;
    190. }
    192. // image_index 10 is free
    193. // image_index 25 is free
    194. // image_index 40 is free
    195. // image_index 55 is free
    197. //Additional Inner Edges
    199. if ((U) && (D) && (L) && (R) && !UL && !UR && !DL && !DR)
    200. {
    201. image_index = 11;
    202. }
    204. if ((U) && (D) && (L) && (R) && (UL) && !UR && !DL && !DR)
    205. {
    206. image_index = 12;
    207. }
    209. if ((U) && (D) && (L) && (R) && !UL && (UR) && !DL && !DR)
    210. {
    211. image_index = 13;
    212. }
    214. if ((U) && (D) && (L) && (R) && (UL) && (UR) && !DL && !DR)
    215. {
    216. image_index = 14;
    217. }
    219. if ((U) && (D) && (L) && (R) && !UL && !UR && (DL) && !DR)
    220. {
    221. image_index = 26;
    222. }
    224. if ((U) && (D) && (L) && (R) && (UL) && !UR && (DL) && !DR)
    225. {
    226. image_index = 27;
    227. }
    229. if ((U) && (D) && (L) && (R) && !UL && (UR) && (DL) && !DR)
    230. {
    231. image_index = 28;
    232. }
    234. if ((U) && (D) && (L) && (R) && (UL) && (UR) && (DL) && !DR)
    235. {
    236. image_index = 29;
    237. }
    239. if ((U) && (D) && (L) && (R) && !UL && !UR && !DL && (DR))
    240. {
    241. image_index = 41;
    242. }
    244. if ((U) && (D) && (L) && (R) && (UL) && !UR && !DL && (DR))
    245. {
    246. image_index = 42;
    247. }
    249. if ((U) && (D) && (L) && (R) && !UL && (UR) && !DL && (DR))
    250. {
    251. image_index = 43;
    252. }
    254. if ((U) && (D) && (L) && (R) && (UL) && (UR) && !DL && (DR))
    255. {
    256. image_index = 44;
    257. }
    259. if ((U) && (D) && (L) && (R) && !UL && !UR && (DL) && (DR))
    260. {
    261. image_index = 56;
    262. }
    264. if ((U) && (D) && (L) && (R) && (UL) && !UR && (DL) && (DR))
    265. {
    266. image_index = 57;
    267. }
    269. if ((U) && (D) && (L) && (R) && !UL && (UR) && (DL) && (DR))
    270. {
    271. image_index = 58;
    272. }
    274. //image_index 59 is the same as 16
    276. // image_index 45-51 is free
    Alles anzeigen


    Ich rufe das Script nach einer Sekunde (room_speed) auf, um sicher zu gehen, dass alle Block Instanzen bereits platziert sind.


    EDIT: @instance_position: Das war jetzt bis zuletzt noch ein Versuch, in der Hoffnung dass andere Ergebnisse ausgespuckt werden. Jedoch wurde auch das nichts. Normalerweise habe ich place_meeting benutzt, wobei das ergebniss ja in beiden fallen logischer weise gleich sein muss.. Entweder null oder eben nicht null.

    MfG,
    Yivo

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

  • was spricht denn gegen eine Bitweise Errechnung der Tilepositionen?

    Den Artikel musste ich zwar tief aus meinen Erinnerungen holen, erklärt das Prinzip aber ziemlich gut und ist eigentlich leicht verständlich:
    saltgames.com/2010/a-bitwise-method-for-applying-tilemaps/
    Ist auch relativ leicht im Game Maker umsetzbar.

    Im übrigen ist Code, der über 200 Zeilen ausschließlich aus if Abfragen besteht, enorm überdimensioniert und ineffizient.

  • Ich bin gerade dabei sämtliche Tilesets an Leute zu verkaufen, welche allerdings nie mit den Bit Layout klar kommen.
    Klar, zum einen kann man sagen, dass sie wissen sollten, was sie kaufen, aber zum anderen wollte ich denen halt ein verständliches Format liefern, einfach nur um die Arbeit für beide Seiten zu erleichtern.
    Und ja, ich würde hier und da im Code noch eine Menge kürzen und verschachteln können, aber dafür wollte ich erstmal, dass eben das Grundlegende wieder funktioniert.
    Das verrückte daran ist ja, dass das Ganze vorher schon perfekt lief.
    Bei der abgeänderten Version spielen wiederrum die Kollisionen verrückt.

    MfG
    Yivo

    EDIT: Argh.. Mein Problem war ein dämlicher Denkfehler..
    In machen Fällen spielen die diagonalen Kollisionen überhaupt keine Rolle (z.B. bei einzelnen Plattformen), weshalb dann keine Abfrage zutraf und das Ergebnis wie entsprechend war.

    Somit sollten wir hier fertig sein ^^ Danke.

    MfG,
    Yivo

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von Yivo () aus folgendem Grund: Gramm0r