Automatisches Indexieren von Sprites in einem Array (autotiling x47)

    • Automatisches Indexieren von Sprites in einem Array (autotiling x47)

      Vorwort
      Dieses Tutorial befasst sich mit dem automatischen indexieren von Sprites in, z.B. einem Spiel wie Terraria.
      Zu erwähnen ist, dass dies nicht über gm-objekte geschieht sondern über einen Array. Ansonsten ist es ihr herkömmlicher autotiler.

      Notiz1: Der Code ist lange und sieht sehr Performance-unfreundlich aus, ist er aber nicht.
      Notiz2: Funktioniert nicht direkt mit Objekten, kann aber ohne zu grossen Aufwand angepasst werden. (Ich schliesse aber Empfehlungen aus)
      Notiz3: Dieser Autotiler funktioniert nicht in bit-weise, da Game Maker if-statements gegenüber normalen Berechnungen bevorzugt.
      So soll es im Normalfall eine bessere Performance zeigen. (Nicht getestet für den Worst-case!)

      Das Template
      Als erstes muss ein Template erstellt werden. Damit meine ich den Sprite mit seinen Sub-images. Für das Tutorial ist ein Sprite mit 47 Sub-images zu verwenden, Index 0 bis 46.
      Die Anordnung spielt eine grosse Rolle, sie sollte dem Beispiel entsprechen (Anti-kopier Qualität, aber hoffentlich erkennbar) der Abbildung unten:


      Das Setup
      Da es ein Script ist, muss es zuerst aufgerufen werden. Es soll in jeder Zelle des Arrays ausgeführt werden.

      Der Algorithmus
      Nun zum Code der diese Bildchen am richtigen Ort einsetzen soll:Der Algorithmus schaut alle Werte im Array um sich herum nach und vergleicht diese mit dem eigenen Wert. Der Algorithmus dieser Sache ist die Reihenfolge bei der diese Array-positionen angeschaut werden.Zur Zeit ist das der schnellste Weg ans Ziel:

      Quellcode

      1. ///scr_get_index(tile,x,y)
      2. var zero = argument0;
      3. var xpos = argument1;
      4. var ypos = argument2;
      6. var left = xpos-1;
      7. var right = xpos+1;
      8. var above = ypos-1;
      9. var below = ypos+1;
      11. //1+
      12. if (global.tiles[@ xpos, below] != zero)
      13. {
      14. //1-2+
      15. if (global.tiles[@ right, ypos] != zero)
      16. {
      17. //1-2-4+
      18. if (global.tiles[@ xpos, above] != zero)
      19. {
      20. //1-2-4-8
      21. if (global.tiles[@ left, ypos] != zero)
      22. {
      23. return (15);
      24. }
      25. else return (7);
      26. }
      27. else
      28. {
      29. //1-2-8
      30. if (global.tiles[@ left, ypos] != zero)
      31. {
      32. return (11);
      33. }
      34. else
      35. {
      36. //1-2-64
      37. if (global.tiles[@ left, above] != zero)
      38. {
      39. return (27);
      40. }
      41. else return (3);
      42. }
      43. }
      44. }
      45. else
      46. {
      47. //1-4+
      48. if (global.tiles[@ xpos, above] != zero)
      49. {
      50. //1-4-8
      51. if (global.tiles[@ left, ypos] != zero)
      52. {
      53. return (13);
      54. }
      55. else return (5);
      56. }
      57. else
      58. {
      59. //1-8+
      60. if (global.tiles[@ left, ypos] != zero)
      61. {
      62. //1-8-32
      63. if (global.tiles[@ right, above] != zero)
      64. {
      65. return (23);
      66. }
      67. else return (9);
      68. }
      69. else
      70. {
      71. //1-32
      72. if (global.tiles[@ right, above] != zero)
      73. {
      74. //1-32-64
      75. if (global.tiles[@ left, above] != zero)
      76. {
      77. return (43);
      78. }
      79. else return (21);
      80. }
      81. else
      82. {
      83. //1-64
      84. if (global.tiles[@ left, above] != zero)
      85. {
      86. return (25);
      87. }
      88. else return (1);
      89. }
      90. }
      91. }
      92. }
      93. }
      94. else
      95. {
      96. //2+
      97. if (global.tiles[@ right, ypos] != zero)
      98. {
      99. //2-4
      100. if (global.tiles[@ xpos, above] != zero)
      101. {
      102. //2-4-8
      103. if (global.tiles[@ left, ypos] != zero)
      104. {
      105. return (14);
      106. }
      107. else
      108. {
      109. //2-4-128
      110. if (global.tiles[@ left, below] != zero)
      111. {
      112. return (31);
      113. }
      114. else return (6);
      115. }
      116. }
      117. else
      118. {
      119. //2-8
      120. if (global.tiles[@ left, ypos] != zero)
      121. {
      122. return (10);
      123. }
      124. else
      125. {
      126. //2-64
      127. if (global.tiles[@ left, above] != zero)
      128. {
      129. //2-64-128
      130. if (global.tiles[@ left, below] != zero)
      131. {
      132. return (44);
      133. }
      134. else return (26);
      135. }
      136. else
      137. {
      138. //2-128
      139. if (global.tiles[@ left, below] != zero)
      140. {
      141. return (29);
      142. }
      143. else return (2);
      144. }
      145. }
      146. }
      147. }
      148. else
      149. {
      150. //4+
      151. if (global.tiles[@ xpos, above] != zero)
      152. {
      153. //4-8
      154. if (global.tiles[@ left, ypos] != zero)
      155. {
      156. //4-8-16
      157. if (global.tiles[@ right, below] != zero)
      158. {
      159. return (18);
      160. }
      161. else return (12);
      162. }
      163. else
      164. {
      165. //4-16
      166. if (global.tiles[@ right, below] != zero)
      167. {
      168. //4-16-128
      169. if (global.tiles[@ left, below] != zero)
      170. {
      171. return (37);
      172. }
      173. else return (17);
      174. }
      175. else
      176. {
      177. //4-128
      178. if (global.tiles[@ left, below] != zero)
      179. {
      180. return (30);
      181. }
      182. else return (4);
      183. }
      184. }
      185. }
      186. else
      187. {
      188. //8+
      189. if (global.tiles[@ left, ypos] != zero)
      190. {
      191. //8-16
      192. if (global.tiles[@ right, below] != zero)
      193. {
      194. //8-16-32
      195. if (global.tiles[@ right, above] != zero)
      196. {
      197. return (33);
      198. }
      199. else return (19);
      200. }
      201. else
      202. {
      203. //8-32)
      204. if (global.tiles[@ right, above] != zero)
      205. {
      206. return (22);
      207. }
      208. else return (8);
      209. }
      210. }
      211. //ONLY CORNERS
      212. else
      213. {
      214. //16+
      215. if (global.tiles[@ right, below] != zero)
      216. {
      217. //16-32
      218. if (global.tiles[@ right, above] != zero)
      219. {
      220. //16-32-64
      221. if (global.tiles[@ left, above] != zero)
      222. {
      223. //16-32-64-128
      224. if (global.tiles[@ left, below] != zero)
      225. {
      226. return (39);
      227. }
      228. else return (35);
      229. }
      230. else
      231. {
      232. //16-32-128
      233. if (global.tiles[@ left, below] != zero)
      234. {
      235. return (42);
      236. }
      237. else return (32);
      238. }
      239. }
      240. else
      241. {
      242. //16-64
      243. if (global.tiles[@ left, above] != zero)
      244. {
      245. //16-64-128
      246. if (global.tiles[@ left, below] != zero)
      247. {
      248. return (41);
      249. }
      250. else return (34);
      251. }
      252. else
      253. {
      254. //16-128
      255. if (global.tiles[@ left, below] != zero)
      256. {
      257. return (36);
      258. }
      259. else return (16);
      260. }
      261. }
      262. }
      263. else
      264. {
      265. //32+
      266. if (global.tiles[@ right, above] != zero)
      267. {
      268. //32-64
      269. if (global.tiles[@ left, above] != zero)
      270. {
      271. //32-64-128
      272. if (global.tiles[@ left, below] != zero)
      273. {
      274. return (40);
      275. }
      276. else return (46);
      277. }
      278. else
      279. {
      280. //32-128
      281. if (global.tiles[@ left, below] != zero)
      282. {
      283. return (38);
      284. }
      285. else return (20);
      286. }
      287. }
      288. else
      289. {
      290. //64+
      291. if (global.tiles[@ left, above] != zero)
      292. {
      293. //64-128
      294. if (global.tiles[@ left, below] != zero)
      295. {
      296. return (45);
      297. }
      298. else return (24);
      299. }
      300. else
      301. {
      302. //128+
      303. if (global.tiles[@ left, below] != zero)
      304. {
      305. return (28);
      306. }
      307. else return (0);
      308. }
      309. }
      310. }
      311. }
      312. }
      313. }
      314. }
      Alles anzeigen


      Bei Fragen und Feedback unbedingt melden.

    • Brodi schrieb:

      Sieht interessant aus.
      Wie benutzt man das?

      Hallo Brodi,
      Das Script muss man in einer doppel for-Schleife benutzen.
      Wenn du jetzt z.B. ein 2D Array hast und alle 1en im Array bedeuten das da ein Block ist und alle 0en bedeuten das da Luft ist.
      Wenn du den Sprite hast (spr_tileset_1), kannst du so vorgehen:

      GML-Quellcode

      1. surface_set_target(my_surface);
      2. draw_clear_alpha(0, 0);
      3. for (var i = 99; i >= 0; i--)
      4. {
      5. for (var j = 99; j >= 0; j--)
      6. {
      7. var cell = my_array[i, j];
      8. if (cell != 0)
      9. {
      10. var index = scr_get_index(cell, i, j);
      11. draw_sprite(spr_tileset_1, index, i * 16, j * 16);
      12. }
      13. }
      14. }
      15. surface_reset_target();
      Alles anzeigen

      Etwa so siehts bei mir aus.
      Natürlich gehört da noch viel mehr dazu, wie z.B. das Managen von Chunks oder das Entscheiden welcher Sprite in die Zelle geört usw.
      Hoffe das ist in irgend einer Art nützlich.

    • Brodi schrieb:

      Oh hoppla. Ehm, das übersteigt mein Verständnis. Aber ich bin sehr interessiert, dass auszuprobieren.
      Wie wäre es mit einem Tutorial von deinem Tutorial ;)


      Ich glaub das ist noch ein wenig zu früh für ein GML Novize. Das wird extrem kompliziert.

    • Brodi schrieb:

      ;(



      Oh je,
      aber wenn du unbedingt ein 5-seitiges überkompliziertes Tutorial lesen möchtest kann ich das schon machen.
      kleine Einsicht des Inhalts, es
      kommen vor:
      - Enums
      - Arrays
      - ds_lists
      - Buffer
      - For-Schleifen
      - Surfaces
      - Bitweise
      - Cellular Automata
      - noise Funktionen
      - Speichern und Laden
      - Grid Kollisionen
      - Shader

      vielleicht ändert das deine Einstellung ein wenig

    • Brodi schrieb:

      Ooh ja voll dabei und motiviert. :)
      Und das meiste von dem was du da Auflist ist nicht unbedingt Neuland - das kriege ich hin ;)


      Könnt aber ne Weile dauern bis ich dieses Tutorial geschrieben habe. Und es sind auch noch Bugs im Projekt selber die ich beheben muss.

    • Viele Tutorials kann man auch als ein eigenes schreiben, damit man alles nicht zig Mal wiederholen muss.
      Ich helfe dir bei anderen Tutorials gerne, wenn du möchtest :)
      Ein Bug ist mehr als nur ein Bug, es ist ein... Käfer!
      Egal, wie gut du eine Mauer baust, sie fällt um.... der klügere gibt nach :D

      Willst du mit mir auf Discord Chatten/Quatschen?
      Meine Husi's Tutorial Reihe

    • Ich arbeite gerade an einem neuen Auto-tiler, welcher auch Verbindungen mit anderen array-werten unterstützt. Daher kann es sein (bei Erfolg) das ich ein neues Tutorial schreiben muss. Das gilt auch fürs andere Tutorial mit den Binären Konstellationen. Dort gibt es auch schon eine neue Technik.