Suche Multiplayertutorial (bis 4 Spieler)

  • GM 8

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

  • Suche Multiplayertutorial (bis 4 Spieler)

    Hallo,

    ich suche ein Multiplayer(online) Tutorial, bisher habe ich nur das auf deutsch gefunden: GM 8 Simple Platform Online Multiplayer für 2 Spieler

    Es sollten bis 4 Spieler spielen können und es sollte eine Liste geben, in der gerade alle aktuellen Server laufen.
    Ein Chat wäre auch schön aber ist nicht notwendig. Ich hoffe ihr kennt ein Tutorial, dass meine Erwartungen erfüllen.


    MFG Dufner
    Husi012 hat mich nicht mehr in seiner Signatur, ich bin trotzdem noch fame.

  • Ich weiß nicht, ob du mit dem DLL's arbeiten willst oder auch mit der Standard-Funktion vom Game Maker.
    Ansonsten kannst du meinen Tutorial mal anschauen, ist nicht erklärbar gemacht worden, aber eigentlich sehr Simple. Dort kann man auch bis zur 4 Spielern spielen, allerdings müsstest du die Server-liste selber noch dazu erstellen.


    Du findest das Tutorial hier:

    Spoiler anzeigen
    http://www.gm-d.de/wbb/index.php/Thread/20946/

  • Ich würde nicht die mplay-Funktionen einfacher einstufen als die Verwendung der 39dll.
    Die 39dll ist nicht so Performance-lastig, weil du die Größe der Pakete, die von Clients an Server und umgekehrt, bestimmen kannst! Dadurch kann man sich viel Performance sparen.
    Zu dem finde ich die Verwendung der 39dll wirklich einfacher zu verstehen und kann dir diese eher ans Herz legen. Ich kenne keine Online-Engine oder gescheites Multiplayerspiel, das ohne die 39dll mit Game Maker erstellt wurde. Tutorials gibt es genug, auch hier im Forum wirst du ein paar finden. Was Online-Engine betrifft, wirst du dich warscheinlich an die Englische Game Maker Community, YouTube oder Google wenden dürfen. Soweit ich weiß gibt es in diesem Forum, auch nicht wirklich ein Tutorial über ein Multiplayer mit Unbegrenzten Clients, also nicht nur Zwei. Sowas könnte meiner Meinung auch mal nicht schaden, da ich mich sowieso über die Umsetzung interessiere.

  • Dufner schrieb:

    oke ^^ bevor ich mich da reinlese, weisst du ob erklärt wird, wie man es bis zu viert spielen kann und ob es auch computer, die sich bewegen synchroniesiert werden?

    Keine ahnung grade, les es dir doch einfach mal kurz durch?
    Und zum anderen, klar wieso auch nicht? Erklärt weis ich nicht, machbar ist es aber, wieso auch nicht.

  • Bei jedem schwartz geschriebenem code wo #... steht

    Quellcode

    1. #define dllinit
    2. /*
    3. Initializes the dll.
    4. Argument0: The dll filename. Set this argument to 0 if you want to use "39dll.dll"
    5. Argument1: Set to true to load socket functions
    6. Argument2: Set to true to load utilities.
    7. */
    8. global._39dll = argument0;
    9. if(is_real(argument0))global._39dll= "39dll.dll";
    10. external_call(external_define(global._39dll, "dllInit", dll_cdecl, ty_real, 0));
    11. //Buffer
    12. global._BufA = external_define(global._39dll, "writebyte", dll_cdecl, ty_real, 2, ty_real,ty_real);
    13. global._BufB = external_define(global._39dll, "writestring", dll_cdecl, ty_real, 2, ty_string, ty_real);
    14. global._BufC = external_define(global._39dll, "writeshort", dll_cdecl, ty_real, 2, ty_real, ty_real);
    15. global._BufD = external_define(global._39dll, "writeint", dll_cdecl, ty_real, 2, ty_real, ty_real);
    16. global._BufE = external_define(global._39dll, "writefloat", dll_cdecl, ty_real, 2, ty_real, ty_real);
    17. global._BufF = external_define(global._39dll, "writedouble", dll_cdecl, ty_real, 2, ty_real, ty_real);
    18. global._BufG = external_define(global._39dll, "readbyte", dll_cdecl, ty_real, 1, ty_real);
    19. global._BufH = external_define(global._39dll, "readstring", dll_cdecl, ty_string, 1, ty_real);
    20. global._BufI = external_define(global._39dll, "readshort", dll_cdecl, ty_real, 1, ty_real);
    21. global._BufJ = external_define(global._39dll, "readint", dll_cdecl, ty_real, 1, ty_real);
    22. global._BufK = external_define(global._39dll, "readfloat", dll_cdecl, ty_real, 1, ty_real);
    23. global._BufL = external_define(global._39dll, "readdouble", dll_cdecl, ty_real, 1, ty_real);
    24. global._BufM = external_define(global._39dll, "clearbuffer", dll_cdecl, ty_real, 1, ty_real);
    25. global._BufN = external_define(global._39dll, "setpos", dll_cdecl, ty_real, 2, ty_real, ty_real);
    26. global._BufO = external_define(global._39dll, "getpos", dll_cdecl, ty_real, 2, ty_real, ty_real);
    27. global._BufQ = external_define(global._39dll, "buffsize", dll_cdecl, ty_real, 1, ty_real);
    28. global._BufR = external_define(global._39dll, "writechars", dll_cdecl, ty_real, 2, ty_string, ty_real);
    29. global._BufS = external_define(global._39dll, "readchars", dll_cdecl, ty_string, 2, ty_real, ty_real);
    30. global._BufU = external_define(global._39dll, "createbuffer", dll_cdecl, ty_real, 0);
    31. global._BufX = external_define(global._39dll, "freebuffer", dll_cdecl, ty_real, 1, ty_real);
    32. global._BufY = external_define(global._39dll, "writeushort", dll_cdecl, ty_real, 2, ty_real, ty_real);
    33. global._BufZ = external_define(global._39dll, "writeuint", dll_cdecl, ty_real, 2, ty_real, ty_real);
    34. global._BufAA = external_define(global._39dll, "readushort", dll_cdecl, ty_real, 1, ty_real);
    35. global._BufAB = external_define(global._39dll, "readuint", dll_cdecl, ty_real, 1, ty_real);
    36. global._BufAC = external_define(global._39dll, "copybuffer", dll_cdecl, ty_real, 2, ty_real, ty_real);
    37. global._BufAD = external_define(global._39dll, "copybuffer2", dll_cdecl, ty_real,4 , ty_real, ty_real, ty_real, ty_real);
    38. global._BufAE = external_define(global._39dll, "bytesleft", dll_cdecl, ty_real, 1, ty_real);
    39. global._BufAF = external_define(global._39dll, "bufferexists", dll_cdecl, ty_real, 1, ty_real);
    40. global._BufAG = external_define(global._39dll, "readsep", dll_cdecl, ty_string, 2, ty_string, ty_real);
    41. if(argument1)
    42. {
    43. //Sockets
    44. global._SokA = external_define(global._39dll, "tcpconnect", dll_cdecl, ty_real, 3, ty_string, ty_real, ty_real);
    45. global._SokB = external_define(global._39dll, "tcplisten", dll_cdecl, ty_real, 3, ty_real, ty_real, ty_real);
    46. global._SokC = external_define(global._39dll, "tcpaccept", dll_cdecl, ty_real, 2, ty_real, ty_real);
    47. global._SokD = external_define(global._39dll, "sendmessage", dll_cdecl, ty_real, 4, ty_real, ty_string, ty_real, ty_real);
    48. global._SokE = external_define(global._39dll, "receivemessage", dll_cdecl, ty_real, 3, ty_real, ty_real, ty_real);
    49. global._SokF = external_define(global._39dll, "setsync", dll_cdecl, ty_real, 2, ty_real, ty_real);
    50. global._SokG = external_define(global._39dll, "setformat", dll_cdecl, ty_real, 3, ty_real, ty_real, ty_string);
    51. global._SokH = external_define(global._39dll, "udpconnect", dll_cdecl, ty_real, 2, ty_real, ty_real);
    52. global._SokI = external_define(global._39dll, "hostip", dll_cdecl, ty_string, 1, ty_string);
    53. global._SokJ = external_define(global._39dll, "lastinIP", dll_cdecl, ty_string, 0);
    54. global._SokK = external_define(global._39dll, "closesock", dll_cdecl, ty_real, 1, ty_real);
    55. global._SokL = external_define(global._39dll, "tcpip", dll_cdecl, ty_string, 1, ty_real);
    56. global._SokM = external_define(global._39dll, "socklasterror", dll_cdecl, ty_real, 0);
    57. global._SokN = external_define(global._39dll, "myhost", dll_cdecl, ty_string, 0);
    58. global._SokO = external_define(global._39dll, "compareip", dll_cdecl, ty_real, 2, ty_string, ty_string);
    59. global._SokP = external_define(global._39dll, "sockexit", dll_cdecl, ty_real, 0);
    60. global._SokQ = external_define(global._39dll, "sockstart", dll_cdecl, ty_real, 0);
    61. global._SokR = external_define(global._39dll, "getmacaddress", dll_cdecl, ty_string, 0);
    62. global._SokS = external_define(global._39dll, "peekmessage", dll_cdecl, ty_real, 3, ty_real, ty_real, ty_real);
    63. global._SokT = external_define(global._39dll, "setnagle", dll_cdecl, ty_real, 2, ty_real, ty_real);
    64. global._SokU = external_define(global._39dll, "tcpconnected", dll_cdecl, ty_real, 1, ty_real);
    65. global._SokX = external_define(global._39dll, "getsocketid", dll_cdecl, ty_real, 1, ty_real);
    66. global._SokY = external_define(global._39dll, "lastinPort", dll_cdecl, ty_real, 0);
    67. }
    68. if(argument2)
    69. {
    70. //File functions
    72. global._FilA = external_define(global._39dll, "fileopen", dll_cdecl, ty_real, 2, ty_string, ty_real);
    73. global._FilB = external_define(global._39dll, "fileclose", dll_cdecl, ty_real, 1, ty_real);
    74. global._FilC = external_define(global._39dll, "filewrite", dll_cdecl, ty_real, 2, ty_real, ty_real);
    75. global._FilD = external_define(global._39dll, "fileread", dll_cdecl, ty_real, 3, ty_real, ty_real, ty_real);
    76. global._FilE = external_define(global._39dll, "filepos", dll_cdecl, ty_real, 1, ty_real);
    77. global._FilF = external_define(global._39dll, "filesetpos", dll_cdecl, ty_real, 2, ty_real, ty_real);
    78. global._FilG = external_define(global._39dll, "filesize", dll_cdecl, ty_real, 1, ty_real);
    80. global._UtilA = external_define(global._39dll, "md5string", dll_cdecl, ty_string, 1, ty_string);
    81. global._UtilB = external_define(global._39dll, "md5buffer", dll_cdecl, ty_string, 1, ty_real);
    82. global._UtilC = external_define(global._39dll, "adler32", dll_cdecl, ty_real, 1, ty_real);
    83. global._UtilD = external_define(global._39dll, "bufferencrypt", dll_cdecl, ty_real, 2, ty_string, ty_real);
    84. global._UtilE = external_define(global._39dll, "iptouint", dll_cdecl, ty_real, 1, ty_string);
    85. global._UtilF = external_define(global._39dll, "uinttoip", dll_cdecl, ty_string, 1, ty_real);
    86. global._UtilG = external_define(global._39dll, "netconnected", dll_cdecl, ty_real, 0);
    88. }
    89. #define dllfree
    90. external_free(global._39dll);
    91. #define tcpconnect
    92. /*
    93. creates a socket and connects to the ip and port
    94. Argument0 = Ip to connect to.
    95. Argument1 = Port to connect to.
    96. Argument2 = Blocking(0)/Non-blocking(1)/Non-blocking++(2) mode.
    98. Set argument2 to 2 if you want it to be non-blocking and also not freeze
    99. the game while it is connecting. Use tcpconnected() to find out when it has
    100. connected
    101. */
    102. return external_call(global._SokA, argument0, argument1, argument2);
    103. #define tcplisten
    104. /*
    105. Creates a listening socket to monitor a certain port for incoming
    106. connections.
    107. Argument0 = Port to listen on
    108. Argument1 = Max amount of people allowed to be in the connected but not
    109. accepted list
    110. Argument2 = Blocking(0)/Non-Blocking(1) mode. Affects the tcpaccept script.
    112. returns the id of the socket or a negative error code.
    113. */
    114. return external_call(global._SokB, argument0, argument1, argument2);
    115. #define tcpaccept
    116. /*
    117. Accepts any incoming connections on a listening socket.
    118. Argument0 = Listening socket.
    119. Argument1 = Blocking/Non-Blocking mode.
    121. returns the id of a newly created socket or a negative number.
    122. */
    123. return external_call(global._SokC, argument0, argument1);
    124. #define tcpip
    125. //Returns the ip that the socket is connected to.
    126. //Argument 0 = socket id.
    127. return external_call(global._SokL, argument0);
    128. #define setnagle
    129. /*
    130. Turns on/off the naggle (TCP_NODELAY) algorithm.
    131. argument0 = socket id to affect
    132. argument1 = true/false (true means NODELAY, false means DELAY)
    133. */
    134. return external_call(global._SokT, argument0, argument1);
    135. #define tcpconnected
    136. /*
    137. argument0 = Socket id to check
    138. Returns true if the tcp socket is connected to a local/remote host.
    139. */
    140. return external_call(global._SokU, argument0);
    141. #define udpconnect
    142. /*
    143. Creates a udp socket.
    144. Argument0 = Port to use.
    145. Argument1 = Blocking/non-blocking mode.
    147. HOW TO SEND MESSAGES:
    148. sendmessage(sockid, "ip.to.send.to", portosendto, [bufferid]);
    149. */
    150. return external_call(global._SokH, argument0, argument1);
    151. #define sendmessage
    152. /*
    153. Sends the data in a buffer through the selected tcp or udp socket.
    154. Argument0 = Socket to send to.
    155. [Argument1] = Ip to send to (for udp sockets)
    156. [Argument2] = Port to send to (for udp socket)
    157. [Argument3]: The buffer id to send. Leave out this argument or set
    158. it to 0 to use the default buffer.
    160. Returns the amount of bytes sent + the bytes used to format the message
    161. NOTE:
    162. If you're sending over a tcp socket and dont want to use the default buffer
    163. than send a message like this:
    164. sendmessage(sockid, "", 0, bufferid);
    165. */
    166. return external_call(global._SokD, argument0, argument1, argument2, argument3);
    167. #define receivemessage
    168. /*
    169. Receives data from the selected tcp or udp socket and copies to the
    170. internal buffer.
    171. Argument0 = Socket to recieve from.
    172. [Argument1] = Amount of bytes to receive. Optional. Overrides the format
    173. mode if used.
    174. [Argument2]: The buffer id to receive to. Leave out this argument or set
    175. it to 0 to use the default buffer.
    177. returns the amount of bytes recieved
    178. NOTE:
    179. If you dont want to save the data to the defualt buffer, than do it like this:
    180. receivemessage(sockid, 0, bufferid);
    181. */
    182. return external_call(global._SokE, argument0, argument1, argument2);
    183. #define peekmessage
    184. /*
    185. Copies any data recieved on a specified socket to the internal buffer but
    186. does not remove it from the recv buffer.
    187. Argument0 = TCP or UDP socket to recieve from
    188. [Argument1] = Bytes to receive. Optional (otherwise receives as much as
    189. possible)
    190. [Argument2]: The buffer id to receive to. Leave out this argument or set
    191. it to 0 to use the default buffer.
    192. Returns amount of bytes recieved.
    194. NOTE:
    195. If you dont want to save the data to the defualt buffer, than do it like this:
    196. peekmessage(sockid, 0, bufferid);
    197. or peekmessage(sockid, bytestoreceive, bufferid);
    198. */
    199. return external_call(global._SokS, argument0, argument1, argument2);
    200. #define setformat
    201. /*
    202. When sending messages over a tcp socket the messages need to be seperated.
    203. The dll provides two methods of seperation.
    205. Method 0: Binary mode. Setting this mode makes every tcp message have a 2 byte
    206. integer attached at the front which represents the amount of data in that
    207. message. This is the default method and is reccomended in online games.
    209. Method 1: Text mode. Setting this mode makes every tcp message have a delimeter
    210. added at the end which is used to identify the end of the message. This is
    211. reccomended for text based protocols like irc.
    213. Method 2: No formatting. Only the data in the internal buffer is sent and
    214. no seperation methods are included.
    216. Argument0 = socket id
    217. Argument1 = method number
    218. [Argument2] = seperation string when using method 1.
    220. MAKE SURE THE CORRECT FORMAT MODE IS SET WHEN RECIEVING A MESSAGE THAT IS IN A
    221. SPECIFIC FORMAT.
    222. returns argument0
    223. */
    224. return external_call(global._SokG, argument0, argument1, argument2);
    225. #define lastinIP
    226. /*
    227. Returns the last incoming IP received from any of the sockets.
    228. It will return an IP from the following situations:
    229. 1. When you receive a message, lastinIP() will return the IP
    230. address of the person who sent that message.
    231. 2. When you've just accepted a connection with tcpaccept(), lastinIP()
    232. will return the ip address of the computer that was accepted.
    233. */
    234. return external_call(global._SokJ);
    235. #define lastinPort
    236. /*
    237. Returns the last incoming port number received from any of the sockets.
    238. It will return a port number from the following situations:
    239. 1. When you receive a message, lastinPort() will return the senders
    240. port number that theyre using to send the message.
    241. */
    242. return external_call(global._SokY);
    243. #define setsync
    244. /*
    245. Changes the blocking/non-blocking mode of a socket.
    247. Argument0 = Socket to change.
    248. Argument1 = Mode to set to. 0 = Blocking. 1 = Non-blocking.
    249. */
    250. return external_call(global._SokF, argument0, argument1);
    251. #define closesocket
    252. /*
    253. Disconnects and frees the selected socket.
    254. Argument0: socket id to close
    255. */
    256. return external_call(global._SokK, argument0);
    257. #define socklasterror
    258. //Returns the error code for the last socket related error.
    259. //It will be a negative number.
    260. return external_call(global._SokM);
    261. #define myhost
    262. //Returns your host name
    263. return external_call(global._SokN);
    264. #define compareip
    265. /*
    266. This script compares an ip to a masked ip. Will return true if they match.
    267. e.g 127.0.0.1 matches 127.0.0.*
    268. e.g 127.1.0.1 does not match 127.0.0.*
    269. Useful when banning hackers who have a dynamic ip.
    270. Argument0 = Ip
    271. Argument1 = Masked ip.
    272. */
    273. return external_call(global._SokO, argument1, argument0);
    274. #define sockexit
    275. //Call this when you want to free winsock. (The dll automatically does this
    276. //when you free the dll)
    277. return external_call(global._SokP);
    278. #define sockstart
    279. //Call this when you want to start winsock only after you have used sockexit()
    280. return external_call(global._SokQ);
    281. #define hostip
    282. /*
    283. Gets the ip of the specified host name.
    284. Argument0 = host name.
    286. returns the ip address.
    287. */return external_call(global._SokI, argument0);
    288. #define getsockid
    289. /*
    290. Argument0: Socket id to get the WINSOCK id from.
    291. returns: the WINSOCK id associated with the socket object.
    292. */
    293. return external_call(global._SokX, argument0);
    294. #define writebyte
    295. /*
    296. Write 1 byte. The value can be between 0 and 255
    297. Argument0 : value;
    298. [Argument1]: The buffer id to write too. Leave out this argument or set
    299. it to 0 to use the default buffer.
    300. */
    301. return external_call(global._BufA, argument0, argument1);
    302. #define writeshort
    303. /*
    304. Writes a 2 byte integer to the buffer. the value can be between
    305. -32768 and +32767
    306. Argument0 : value
    307. [Argument1]: The buffer id to write too. Leave out this argument or set
    308. it to 0 to use the default buffer.
    309. */
    310. return external_call(global._BufC, argument0, argument1);
    311. #define writeushort
    312. /*
    313. Writes a 2 byte UNSIGNED integer to the buffer. the value can be between
    314. 0 and +65536
    315. Argument0 : value
    316. [Argument1]: The buffer id to write too. Leave out this argument or set
    317. it to 0 to use the default buffer.
    318. */
    319. return external_call(global._BufY, argument0, argument1);
    320. #define writeint
    321. /*
    322. Writes a 4 byte integer to the internal buffer. The value can be between
    323. -2147483648 and +2147483647
    324. Argument0: value
    325. [Argument1]: The buffer id to write too. Leave out this argument or set
    326. it to 0 to use the default buffer.
    327. */
    328. return external_call(global._BufD, argument0, argument1);
    329. #define writeuint
    330. /*
    331. Writes a 4 byte UNSIGNED integer to the internal buffer. The value can be between
    332. 0 and +4294967296
    333. Argument0: value
    334. [Argument1]: The buffer id to write too. Leave out this argument or set
    335. it to 0 to use the default buffer.
    336. */
    337. return external_call(global._BufD, argument0, argument1);
    338. #define writefloat
    339. /*
    340. Writes a 4 byte real number (number that can contain a decimal place).
    341. Argument0: Value;
    342. [Argument1]: The buffer id to write too. Leave out this argument or set
    343. it to 0 to use the default buffer.
    344. */
    345. return external_call(global._BufE, argument0, argument1);
    346. #define writedouble
    347. /*
    348. Same as writefloat but the number can be much larger. It can write any number GM supports.
    349. Warning: It uses 8 bytes!!
    350. Argument0: value.
    351. [Argument1]: The buffer id to write too. Leave out this argument or set
    352. it to 0 to use the default buffer.
    353. */
    354. return external_call(global._BufF, argument0, argument1);
    355. #define writechars
    356. /*
    357. Writes a sequence of characters to the buffer.
    358. Argument0: String to write.
    359. [Argument1]: The buffer id to write too. Leave out this argument or set
    360. it to 0 to use the default buffer.
    361. */
    362. return external_call(global._BufR, argument0, argument1);
    363. #define writestring
    364. /*
    365. Write a null terminated string to the buffer
    366. Warning: DO NOT set argument1 to true like you would in the old method. Doing this
    367. will make it try and write to a buffer with the ID of 1 (1 = true)
    369. Argument0 = String to write.
    370. [Argument1]: The buffer id to write too. Leave out this argument or set
    371. it to 0 to use the default buffer.
    372. */
    373. return external_call(global._BufB, argument0, argument1);
    374. #define copybuffer
    375. /*
    376. appends one buffers data to the end of another
    377. Argument0 = destination buffer;
    378. Argument1 = Source buffer
    379. note: 0 is default buffer
    380. */
    381. return external_call(global._BufAC, argument0, argument1);
    382. #define copybuffer2
    383. /*
    384. appends PART of one buffers data to the end of another
    385. Argument0 = destination buffer;
    386. Argument1 = start pos in source buffer
    387. Argument2 = Number of bytes to copy from source
    388. Argument3 = source buffer
    389. */
    390. return external_call(global._BufAD, argument0, argument1, argument2, argument3);
    391. #define readbyte
    392. /*
    393. Returns a byte from the buffer.
    394. [Argument0]: The buffer id to read from. Leave out this argument or set
    395. it to 0 to use the default buffer.
    396. */
    397. return external_call(global._BufG, argument0);
    398. #define readshort
    399. /*
    400. Returns a short int from the buffer.
    401. [Argument0]: The buffer id to read from. Leave out this argument or set
    402. it to 0 to use the default buffer.
    403. */
    404. return external_call(global._BufI, argument0);
    405. #define readushort
    406. /*
    407. Returns a unsigned short int from the buffer.
    408. [Argument0]: The buffer id to read from. Leave out this argument or set
    409. it to 0 to use the default buffer.
    410. */
    411. return external_call(global._BufAA, argument0);
    412. #define readint
    413. /*
    414. Returns a int from the buffer.
    415. [Argument0]: The buffer id to read from. Leave out this argument or set
    416. it to 0 to use the default buffer.
    417. */
    418. return external_call(global._BufJ, argument0);
    419. #define readuint
    420. /*
    421. Returns a unsigned int from the buffer.
    422. [Argument0]: The buffer id to read from. Leave out this argument or set
    423. it to 0 to use the default buffer.
    424. */
    425. return external_call(global._BufAB, argument0);
    426. #define readfloat
    427. /*
    428. Returns a float from the buffer.
    429. [Argument0]: The buffer id to read from. Leave out this argument or set
    430. it to 0 to use the default buffer.
    431. */
    432. return external_call(global._BufK, argument0);
    433. #define readdouble
    434. /*
    435. Returns a double from the buffer.
    436. [Argument0]: The buffer id to read from. Leave out this argument or set
    437. it to 0 to use the default buffer.
    438. */
    439. return external_call(global._BufL, argument0);
    440. #define readchars
    441. /*
    442. Reads a sequence of characters from the buffer.
    443. Argument0: number of charactered to read
    444. [Argument0]: The buffer id to read from. Leave out this argument or set
    445. it to 0 to use the default buffer.
    446. */
    447. return external_call(global._BufS, argument0, argument1);
    448. #define readstring
    449. /*
    450. Returns a null terminated string from the buffer.
    451. [Argument0]: The buffer id to read from. Leave out this argument or set
    452. it to 0 to use the default buffer.
    453. */
    454. return external_call(global._BufH, argument0);
    455. #define readsep
    456. /*
    457. Finds a string in a buffer and returns the data before the string and increments the
    458. buffers readpos.
    459. Argument0: Seperator string.
    460. [Argument1]: The buffer id to read from. Leave out this argument or set
    461. it to 0 to use the default buffer.
    463. Example:
    464. writechars("Hello:World:");
    465. show_message(readsep(":")); //will display "Hello"
    466. show_message(readsep(":")); //will display "World"
    467. */
    468. return external_call(global._BufAG, argument0, argument1);
    469. #define readbit
    470. /*
    471. Reads the bit at a certain position in a number
    472. argument0 = number
    473. argument1 = bit position (0-7)
    474. returns the bit value (true/false)
    475. */
    476. return (argument0 & power(2, argument1))>0;
    477. #define buildbyte
    478. /*
    479. returns a byte based on true/false arguments
    480. argument0-argument7 = bit values
    481. */
    482. return argument0*128 + argument1*64 + argument2*32 + argument3*16 + argument4*8 + argument5*4 + argument6*2 + argument7*1;
    483. #define getpos
    484. /*
    485. Returns the read or write pos
    486. Argument0 = read/write. 0 = write pos. 1 = read pos
    487. [Argument1]: The buffer id to use. Leave out this argument or set
    488. it to 0 to use the default buffer.
    489. */
    490. return external_call(global._BufO, argument0, argument1);
    491. #define clearbuffer
    492. /*
    493. [Argument0]: The buffer id to use. Leave out this argument or set
    494. it to 0 to use the default buffer.
    495. */
    496. return external_call(global._BufM, argument0);
    497. #define buffsize
    498. /*
    499. Returns the amount of bytes in a buffer.
    500. [Argument0]: The buffer id to use. Leave out this argument or set
    501. it to 0 to use the default buffer.
    502. */
    503. return external_call(global._BufQ, argument0);
    504. #define setpos
    505. /*
    506. Sets the read/write pos in a buffer
    507. Argument0 = pos.
    508. [Argument1]: The buffer id to use. Leave out this argument or set
    509. it to 0 to use the default buffer.
    510. */
    511. return external_call(global._BufN, argument0, argument1);
    512. #define bytesleft
    513. /*
    514. Returns how much bytes are left to read. Buffsize-Buffreadpos.
    515. [Argument0]: The buffer id to check how many bytes are left. Leave out this argument or set
    516. it to 0 to use the default buffer.
    517. */
    518. return external_call(global._BufAE, argument0);
    519. #define createbuffer
    520. /*
    521. Creates a new buffer and returns the buffers ID
    522. */
    523. return external_call(global._BufU);
    524. #define freebuffer
    525. /*
    526. Frees (deletes) a buffer. You cannot free the default buffer (0)
    527. Argument0: buffer id
    528. */
    529. return external_call(global._BufX, argument0);
    530. #define bufferexists
    531. /*
    532. Returns true if the buffer exists
    533. Argument0: Buffer id to check if it exists.
    534. */
    535. return external_call(global._BufAF, argument0);
    536. #define md5string
    537. /*
    538. returns a md5 hash of argument0
    539. argument0 = string
    540. */
    541. return external_call(global._UtilA, argument0);
    542. #define md5buffer
    543. /*
    544. returns the MD5 hash of the data inside the buffer
    545. */
    546. return external_call(global._UtilB, argument0);
    547. #define bufferencrypt
    548. /*
    549. Encrypts the buffer with the RC4 encryption algorithm
    550. Argument0 = (string) password.
    551. */
    552. return external_call(global._UtilD, argument0, argument1);
    553. #define bufferdecrypt
    554. /*
    555. same as bufferencrypt but used to prevent confusion on how to decrypt.
    556. Argument0 = (string) password
    557. */
    558. return external_call(global._UtilD, argument0, argument1);
    559. #define fileopen
    560. /*
    561. Opens or creates a file for reading or writing.
    562. Argument0 = Filename.
    563. Argument1 = mode. 0 = reading, 1 = writing, 2 = both reading and writing
    564. Returns a file id.
    565. */
    566. return external_call(global._FilA, argument0, argument1);
    567. #define fileclose
    568. /*
    569. Closes a open file
    570. argument0 = file id
    571. */
    572. return external_call(global._FilB, argument0);
    573. #define filewrite
    574. /*
    575. Writes the data in a buffer into the open file.
    576. argument0 = file id
    577. [Argument1]: The buffer id to read from. Leave out this argument or set
    578. it to 0 to use the default buffer.
    579. */
    581. return external_call(global._FilC, argument0, argument1);
    582. #define fileread
    583. /*
    584. Reads bytes from the file and copies to the internal buffer (starting at the
    585. write position)
    586. Argument0 = file id.
    587. Argument1 = Number of bytes to read.
    588. [Argument2]: The buffer id to receive to. Leave out this argument or set
    589. it to 0 to use the default buffer.
    590. */
    591. return external_call(global._FilD, argument0, argument1, argument2);
    592. #define filepos
    593. /*
    594. argument0 = file id
    595. Returns the read/write pos in the open file.
    596. */
    597. return external_call(global._FilE, argument0);
    598. #define filesetpos
    599. /*
    600. Sets the read/write pos in the open file.
    601. argument0 = file id
    602. Argument1 = position to set to.
    603. */
    605. return external_call(global._FilF, argument0, argument1);
    606. #define filesize
    607. /*
    608. argument0 = file id
    609. Returns the size of the file in bytes.
    610. */
    612. return external_call(global._FilG, argument0);
    613. #define adler32
    614. /*
    615. This function creates checksum value of the data inside the buffer.
    616. This can be used for data verification.
    617. note: Checksums are similar to MD5 but faster and less accurate. It also
    618. returns a number not a string. Uses adler-32 checksum algorithm.
    619. The value can be sent as an unsigned int
    620. */
    621. return external_call(global._UtilC, argument0);
    622. #define getmacaddress
    623. /*
    624. returns the computers local MAC address. Do not just rely on this for player banning and the
    625. mac address can easily be spoofed.
    626. */
    627. return external_call(global._SokR);
    628. #define iptouint
    629. /*
    630. Converts a ip string (ie 202.13.23.1) to a number.
    631. The number is the right size to be written as a unsigned int
    632. in a buffer.
    633. argument0 = ip address
    634. returns: number
    635. */
    636. return external_call(global._UtilE, argument0);
    637. #define uinttoip
    638. /*
    639. Converts a number to a ip address.
    640. argument0 = number (integer)
    641. returns: ip address (string)
    642. */
    643. return external_call(global._UtilF, argument0);
    644. #define netconnected
    645. /*
    646. checks if the local computer is connected to the internet
    647. returns true if it is...
    648. */
    649. return external_call(global._UtilG);
    Alles anzeigen
    Husi012 hat mich nicht mehr in seiner Signatur, ich bin trotzdem noch fame.

  • Die *.gml Datei ist keine allmächtige Codedatei die du einfach in irgendein Objekt reinklatscht und magischerweiße dein Spiel zum Multiplayerspiel macht. Die 39dll gibt dir nur die Möglichkeit auf die Windows Sockets, also die Netzwerkfunktionen von Windows zuzugreifen, wie z.B. TCP oder UDP. Du kannst Daten zu anderen Computer über das Internet senden - mehr kann das Teil erstmal nicht.

    Du klingst so als ob du einfach das Tutorial kopieren willst und dann deine eigenen Sprites draufklatschen (wenn überhaupt), so funktioniert das aber nicht, spätetens wenn du neue Features einbauen willst (Schüsse, KI-Gegner... etc) kommt schon wieder eine Frage.

    Für die Serverliste brauchste btw einen externen Server der das ganze verwaltet (lässt sich sicher mit MySQL und PHP was zusammenskripten), evtl. dazu noch eine HTTP DLL um mit diesen Server zu kommunzieren, die 39dll kann das selbst auch, aber das wird dann ein Stück schwieriger.
    wupto.net/ Nicht meine Seite!
    We love Koalas.

    GM-D-Spam-o-Meter: 32%

  • henrik1235 schrieb:

    Die *.gml Datei ist keine allmächtige Codedatei die du einfach in irgendein Objekt reinklatscht und magischerweiße dein Spiel zum Multiplayerspiel macht. Die 39dll gibt dir nur die Möglichkeit auf die Windows Sockets, also die Netzwerkfunktionen von Windows zuzugreifen, wie z.B. TCP oder UDP. Du kannst Daten zu anderen Computer über das Internet senden - mehr kann das Teil erstmal nicht.

    Du klingst so als ob du einfach das Tutorial kopieren willst und dann deine eigenen Sprites draufklatschen (wenn überhaupt), so funktioniert das aber nicht, spätetens wenn du neue Features einbauen willst (Schüsse, KI-Gegner... etc) kommt schon wieder eine Frage.

    Für die Serverliste brauchste btw einen externen Server der das ganze verwaltet (lässt sich sicher mit MySQL und PHP was zusammenskripten), evtl. dazu noch eine HTTP DLL um mit diesen Server zu kommunzieren, die 39dll kann das selbst auch, aber das wird dann ein Stück schwieriger.



    schöne Worte ^^ nein, ich will es ja nicht einfach reinklatschen, denn wie du gesagt hast habe ich auch noch andere objekte, aber ich bräcuhte ein Tutorial, dass ich auch verstehe und am besten auf deutsch ist!


    Dieser Fehler kommt immer:


    ___________________________________________
    COMPILATION ERROR in Script: dllinit
    Error in code at line 1:
    #define dllinit
    ^
    at position 1: Unexpected symbol.
    Husi012 hat mich nicht mehr in seiner Signatur, ich bin trotzdem noch fame.

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

  • du musst die .gml datei nicht rauskopieren, du musst sie über den Game Maker rein importieren. Jedes #define beschreibt ein neues script und somit fallen dann die #define Zeilen weg und dir werden alle scripte automatisch angelegt. Wie du vielleicht gemerkt hast gibt es eine gm6 Vorlage im 39dll Ordner, mit der du glaub ich schon alles in ein leeres Game Maker Projekt reingeladen bekommst. Achte mal drauf. Weil STRG+C/V kannst du bei einer .gml datei nicht einfach so verwenden.