Teamspeak 3 "Fernsteuern"

  • VB.NET

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von KaskadekingDE.

    Teamspeak 3 "Fernsteuern"

    Hallo liebe Coder,

    Ich möchte gerne eine Form erstellen die sich mit Teamspeak 3 verbindet. Undzwar möchte ich da die Namen sehen die in meinem Chanel sind Nicht mehr nicht weniger:)

    Gibt es da eine Möglichkeit ??

    Da ich nicht so der Profi bin, bitte ich um etwas "einfachere" Sprache bzw. Beispiele mit Codes :)

    Gruß, Tom :P
    Moin,

    ich bin mir sicher, dass die SDK einbindbare Binaries enthält, die Du nutzen kannst.
    Im Netz kursieren doch bestimmt auch Themen und Infos darüber, oder?

    Grüße
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:
    Hab mir mal das SDK herruntergeladen. Da sind sogar C#-Samples drin:

    Callback

    Quellcode

    1. /*
    2. * TeamSpeak 3 client minimal sample C#
    3. *
    4. * Copyright (c) 2007-2010 TeamSpeak-Systems
    5. */
    6. using System;
    7. using ts3client_minimal_sample;
    8. using System.Runtime.InteropServices;
    9. using anyID = System.UInt16;
    10. using uint64 = System.UInt64;
    11. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    12. public delegate void onConnectStatusChangeEvent_type(uint64 serverConnectionHandlerID, int newStatus, uint errorNumber);
    13. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    14. public delegate void onServerProtocolVersionEvent_type(uint64 serverConnectionHandlerID, int protocolVersion);
    15. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    16. public delegate void onNewChannelEvent_type(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID);
    17. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    18. public delegate void onNewChannelCreatedEvent_type(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID, anyID invokerID, string invokerName, string invokerUniqueIdentifier);
    19. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    20. public delegate void onDelChannelEvent_type(uint64 serverConnectionHandlerID, uint64 channelID, anyID invokerID, string invokerName, string invokerUniqueIdentifier);
    21. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    22. public delegate void onChannelMoveEvent_type(uint64 serverConnectionHandlerID, uint64 channelID, uint64 newChannelParentID, anyID invokerID, string invokerName, string invokerUniqueIdentifier);
    23. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    24. public delegate void onUpdateChannelEvent_type(uint64 serverConnectionHandlerID, uint64 channelID);
    25. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    26. public delegate void onUpdateChannelEditedEvent_type(uint64 serverConnectionHandlerID, uint64 channelID, anyID invokerID, string invokerName, string invokerUniqueIdentifier);
    27. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    28. public delegate void onUpdateClientEvent_type(uint64 serverConnectionHandlerID, anyID clientID);
    29. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    30. public delegate void onClientMoveEvent_type(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, string moveMessage);
    31. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    32. public delegate void onClientMoveSubscriptionEvent_type(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility);
    33. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    34. public delegate void onClientMoveTimeoutEvent_type(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, string timeoutMessage);
    35. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    36. public delegate void onClientMoveMovedEvent_type(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, anyID moverID, string moverName, string moverUniqueIdentifier, string moveMessage);
    37. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    38. public delegate void onClientKickFromChannelEvent_type(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, anyID kickerID, string kickerName, string kickerUniqueIdentifier, string kickMessage);
    39. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    40. public delegate void onClientKickFromServerEvent_type(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, anyID kickerID, string kickerName, string kickerUniqueIdentifier, string kickMessage);
    41. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    42. public delegate void onClientIDsEvent_type(uint64 serverConnectionHandlerID, string uniqueClientIdentifier, anyID clientID, string clientName);
    43. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    44. public delegate void onClientIDsFinishedEvent_type(uint64 serverConnectionHandlerID);
    45. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    46. public delegate void onServerEditedEvent_type(uint64 serverConnectionHandlerID, anyID editerID, string editerName, string editerUniqueIdentifier);
    47. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    48. public delegate void onServerUpdatedEvent_type(uint64 serverConnectionHandlerID);
    49. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    50. public delegate void onServerErrorEvent_type(uint64 serverConnectionHandlerID, string errorMessage, uint error, string returnCode, string extraMessage);
    51. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    52. public delegate void onServerStopEvent_type(uint64 serverConnectionHandlerID, string shutdownMessage);
    53. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    54. public delegate void onTextMessageEvent_type(uint64 serverConnectionHandlerID, anyID targetMode, anyID toID, anyID fromID, string fromName, string fromUniqueIdentifier, string message);
    55. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    56. public delegate void onTalkStatusChangeEvent_type(uint64 serverConnectionHandlerID, int status, int isReceivedWhisper, anyID clientID);
    57. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    58. public delegate void onIgnoredWhisperEvent_type(uint64 serverConnectionHandlerID, anyID clientID);
    59. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    60. public delegate void onConnectionInfoEvent_type(uint64 serverConnectionHandlerID, anyID clientID);
    61. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    62. public delegate void onServerConnectionInfoEvent_type(uint64 serverConnectionHandlerID);
    63. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    64. public delegate void onChannelSubscribeEvent_type(uint64 serverConnectionHandlerID, uint64 channelID);
    65. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    66. public delegate void onChannelSubscribeFinishedEvent_type(uint64 serverConnectionHandlerID);
    67. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    68. public delegate void onChannelUnsubscribeEvent_type(uint64 serverConnectionHandlerID, uint64 channelID);
    69. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    70. public delegate void onChannelUnsubscribeFinishedEvent_type(uint64 serverConnectionHandlerID);
    71. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    72. public delegate void onChannelDescriptionUpdateEvent_type(uint64 serverConnectionHandlerID, uint64 channelID);
    73. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    74. public delegate void onChannelPasswordChangedEvent_type(uint64 serverConnectionHandlerID, uint64 channelID);
    75. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    76. public delegate void onPlaybackShutdownCompleteEvent_type(uint64 serverConnectionHandlerID);
    77. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    78. /* Sound editing functions implemented in this sample
    79. onSoundDeviceListChangedEvent
    80. onEditPlaybackVoiceDataEvent
    81. onEditPostProcessVoiceDataEvent
    82. onEditMixedPlaybackVoiceDataEvent
    83. onEditCapturedVoiceDataEvent
    84. onCustom3dRolloffCalculationClientEvent
    85. onCustom3dRolloffCalculationWaveEvent */
    86. public delegate void onUserLoggingMessageEvent_type(string logmessage, int logLevel, string logChannel, uint64 logID, string logTime, string completeLogString);
    87. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    88. public delegate void onVoiceRecordDataEvent_type(float[] data, uint dataSize);
    89. /* Not implemented in this sample
    90. onCustomPacketEncryptEvent
    91. onCustomPacketDecryptEvent*/
    92. /* for rare, but unused in SDK */
    93. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    94. public delegate void dummy1_type();
    95. /* for rare, but unused in SDK */
    96. [StructLayout(LayoutKind.Sequential)]
    97. public struct client_callbackrare_struct {
    98. public dummy1_type dummy1_delegate;
    99. public dummy1_type dummy2_delegate;
    100. public dummy1_type dummy3_delegate;
    101. public dummy1_type dummy4_delegate;
    102. public dummy1_type dummy5_delegate;
    103. public dummy1_type dummy6_delegate;
    104. public dummy1_type dummy7_delegate;
    105. public dummy1_type dummy8_delegate;
    106. public dummy1_type dummy9_delegate;
    107. public dummy1_type dummy10_delegate;
    108. public dummy1_type dummy11_delegate;
    109. public dummy1_type dummy12_delegate;
    110. public dummy1_type dummy13_delegate;
    111. public dummy1_type dummy14_delegate;
    112. public dummy1_type dummy15_delegate;
    113. public dummy1_type dummy16_delegate;
    114. public dummy1_type dummy17_delegate;
    115. public dummy1_type dummy18_delegate;
    116. public dummy1_type dummy19_delegate;
    117. public dummy1_type dummy20_delegate;
    118. public dummy1_type dummy21_delegate;
    119. public dummy1_type dummy22_delegate;
    120. public dummy1_type dummy23_delegate;
    121. public dummy1_type dummy24_delegate;
    122. public dummy1_type dummy25_delegate;
    123. public dummy1_type dummy26_delegate;
    124. public dummy1_type dummy27_delegate;
    125. }
    126. [StructLayout(LayoutKind.Sequential)]
    127. public struct client_callback_struct {
    128. public onConnectStatusChangeEvent_type onConnectStatusChangeEvent_delegate;
    129. public onServerProtocolVersionEvent_type onServerProtocolVersionEvent_delegate;
    130. public onNewChannelEvent_type onNewChannelEvent_delegate;
    131. public onNewChannelCreatedEvent_type onNewChannelCreatedEvent_delegate;
    132. public onDelChannelEvent_type onDelChannelEvent_delegate;
    133. public onChannelMoveEvent_type onChannelMoveEvent_delegate;
    134. public onUpdateChannelEvent_type onUpdateChannelEvent_delegate;
    135. public onUpdateChannelEditedEvent_type onUpdateChannelEditedEvent_delegate;
    136. public onUpdateClientEvent_type onUpdateClientEvent_delegate;
    137. public onClientMoveEvent_type onClientMoveEvent_delegate;
    138. public onClientMoveSubscriptionEvent_type onClientMoveSubscriptionEvent_delegate;
    139. public onClientMoveTimeoutEvent_type onClientMoveTimeoutEvent_delegate;
    140. public onClientMoveMovedEvent_type onClientMoveMovedEvent_delegate;
    141. public onClientKickFromChannelEvent_type onClientKickFromChannelEvent_delegate;
    142. public onClientKickFromServerEvent_type onClientKickFromServerEvent_delegate;
    143. public onClientIDsEvent_type onClientIDsEvent_delegate;
    144. public onClientIDsFinishedEvent_type onClientIDsFinishedEvent_delegate;
    145. public onServerEditedEvent_type onServerEditedEvent_delegate;
    146. public onServerUpdatedEvent_type onServerUpdatedEvent_delegate;
    147. public onServerErrorEvent_type onServerErrorEvent_delegate;
    148. public onServerStopEvent_type onServerStopEvent_delegate;
    149. public onTextMessageEvent_type onTextMessageEvent_delegate;
    150. public onTalkStatusChangeEvent_type onTalkStatusChangeEvent_delegate;
    151. public onIgnoredWhisperEvent_type onIgnoredWhisperEvent_delegate;
    152. public onConnectionInfoEvent_type onConnectionInfoEvent_delegate;
    153. public onServerConnectionInfoEvent_type onServerConnectionInfoEvent_delegate;
    154. public onChannelSubscribeEvent_type onChannelSubscribeEvent_delegate;
    155. public onChannelSubscribeFinishedEvent_type onChannelSubscribeFinishedEvent_delegate;
    156. public onChannelUnsubscribeEvent_type onChannelUnsubscribeEvent_delegate;
    157. public onChannelUnsubscribeFinishedEvent_type onChannelUnsubscribeFinishedEvent_delegate;
    158. public onChannelDescriptionUpdateEvent_type onChannelDescriptionUpdateEvent_delegate;
    159. public onChannelPasswordChangedEvent_type onChannelPasswordChangedEvent_delegate;
    160. public onPlaybackShutdownCompleteEvent_type onPlaybackShutdownCompleteEvent_delegate;
    161. public dummy1_type dummy100_delegate;
    162. public dummy1_type dummy101_delegate;
    163. public dummy1_type dummy102_delegate;
    164. public dummy1_type dummy103_delegate;
    165. public dummy1_type dummy104_delegate;
    166. public dummy1_type dummy105_delegate;
    167. public dummy1_type dummy106_delegate;
    168. public onUserLoggingMessageEvent_type onUserLoggingMessageEvent_delegate;
    169. public dummy1_type dummy107_delegate;
    170. public dummy1_type dummy108_delegate;
    171. }
    172. public static class callback {
    173. /*
    174. * Callback for connection status change.
    175. * Connection status switches through the states STATUS_DISCONNECTED, STATUS_CONNECTING, STATUS_CONNECTED and STATUS_CONNECTION_ESTABLISHED.
    176. *
    177. * Parameters:
    178. * serverConnectionHandlerID - Server connection handler ID
    179. * newStatus - New connection status, see the enum ConnectStatus in clientlib_publicdefinitions.h
    180. * errorNumber - Error code. Should be zero when connecting or actively disconnection.
    181. * Contains error state when losing connection.
    182. */
    183. public static void onConnectStatusChangeEvent(uint64 serverConnectionHandlerID, int newStatus, uint errorNumber)
    184. {
    185. Console.WriteLine("Connect status changed: {0} {1} {2}", serverConnectionHandlerID, newStatus, errorNumber);
    186. /* Failed to connect ? */
    187. if (newStatus == (int)ConnectStatus.STATUS_DISCONNECTED && errorNumber == public_errors.ERROR_failed_connection_initialisation) {
    188. Console.WriteLine("Looks like there is no server running, terminate!");
    189. Console.ReadLine();
    190. System.Environment.Exit(-1);
    191. }
    192. }
    193. public static void onServerProtocolVersionEvent(uint64 serverConnectionHandlerID, int protocolVersion)
    194. {
    195. Console.WriteLine("Server protocol version: {0} {1}", serverConnectionHandlerID, protocolVersion);
    196. }
    197. /*
    198. * Callback for current channels being announced to the client after connecting to a server.
    199. *
    200. * Parameters:
    201. * serverConnectionHandlerID - Server connection handler ID
    202. * channelID - ID of the announced channel
    203. * channelParentID - ID of the parent channel
    204. */
    205. public static void onNewChannelEvent(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID)
    206. {
    207. string name;
    208. string errormsg;
    209. uint error;
    210. IntPtr namePtr = IntPtr.Zero;
    211. Console.WriteLine("onNewChannelEvent: {0} {1} {2}", serverConnectionHandlerID, channelID, channelParentID);
    212. error = ts3client.ts3client_getChannelVariableAsString(serverConnectionHandlerID, channelID, ChannelProperties.CHANNEL_NAME, out namePtr);
    213. if (error == public_errors.ERROR_ok) {
    214. name = Marshal.PtrToStringAnsi(namePtr);
    215. Console.WriteLine("New channel: {0} {1}", channelID, name);
    216. ts3client.ts3client_freeMemory(namePtr); /* Release dynamically allocated memory only if function succeeded */
    217. } else {
    218. IntPtr errormsgPtr = IntPtr.Zero;
    219. if (ts3client.ts3client_getErrorMessage(error, errormsgPtr) == public_errors.ERROR_ok) {
    220. errormsg = Marshal.PtrToStringAnsi(errormsgPtr);
    221. Console.WriteLine("Error getting channel name in onNewChannelEvent: {0}", errormsg);
    222. ts3client.ts3client_freeMemory(errormsgPtr);
    223. }
    224. }
    225. }
    226. /*
    227. * Callback for just created channels.
    228. *
    229. * Parameters:
    230. * serverConnectionHandlerID - Server connection handler ID
    231. * channelID - ID of the announced channel
    232. * channelParentID - ID of the parent channel
    233. * invokerID - ID of the client who created the channel
    234. * invokerName - Name of the client who created the channel
    235. */
    236. public static void onNewChannelCreatedEvent(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID, anyID invokerID, string invokerName, string invokerUniqueIdentifier)
    237. {
    238. string name;
    239. IntPtr namePtr = IntPtr.Zero;
    240. /* Query channel name from channel ID */
    241. uint error = ts3client.ts3client_getChannelVariableAsString(serverConnectionHandlerID, channelID, ChannelProperties.CHANNEL_NAME, out namePtr);
    242. if (error != public_errors.ERROR_ok) {
    243. return;
    244. }
    245. name = Marshal.PtrToStringAnsi(namePtr);
    246. Console.WriteLine("New channel created: {0}", name);
    247. ts3client.ts3client_freeMemory(namePtr); /* Release dynamically allocated memory only if function succeeded */
    248. }
    249. /*
    250. * Callback when a channel was deleted.
    251. *
    252. * Parameters:
    253. * serverConnectionHandlerID - Server connection handler ID
    254. * channelID - ID of the deleted channel
    255. * invokerID - ID of the client who deleted the channel
    256. * invokerName - Name of the client who deleted the channel
    257. */
    258. public static void onDelChannelEvent(uint64 serverConnectionHandlerID, uint64 channelID, anyID invokerID, string invokerName, string invokerUniqueIdentifier)
    259. {
    260. Console.WriteLine("Channel ID {0} deleted by {1} ({2})", channelID, invokerName, invokerID);
    261. }
    262. /*
    263. * Called when a client joins, leaves or moves to another channel.
    264. *
    265. * Parameters:
    266. * serverConnectionHandlerID - Server connection handler ID
    267. * clientID - ID of the moved client
    268. * oldChannelID - ID of the old channel left by the client
    269. * newChannelID - ID of the new channel joined by the client
    270. * visibility - Visibility of the moved client. See the enum Visibility in clientlib_publicdefinitions.h
    271. * Values: ENTER_VISIBILITY, RETAIN_VISIBILITY, LEAVE_VISIBILITY
    272. */
    273. public static void onClientMoveEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, string moveMessage)
    274. {
    275. Console.WriteLine("ClientID {0} moves from channel {1} to {2} with message {3}", clientID, oldChannelID, newChannelID, moveMessage);
    276. }
    277. /*
    278. * Callback for other clients in current and subscribed channels being announced to the client.
    279. *
    280. * Parameters:
    281. * serverConnectionHandlerID - Server connection handler ID
    282. * clientID - ID of the announced client
    283. * oldChannelID - ID of the subscribed channel where the client left visibility
    284. * newChannelID - ID of the subscribed channel where the client entered visibility
    285. * visibility - Visibility of the announced client. See the enum Visibility in clientlib_publicdefinitions.h
    286. * Values: ENTER_VISIBILITY, RETAIN_VISIBILITY, LEAVE_VISIBILITY
    287. */
    288. public static void onClientMoveSubscriptionEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility)
    289. {
    290. string name;
    291. IntPtr namePtr = IntPtr.Zero;
    292. /* Query client nickname from ID */
    293. uint error = ts3client.ts3client_getClientVariableAsString(serverConnectionHandlerID, clientID, ClientProperties.CLIENT_NICKNAME, out namePtr);
    294. if (error != public_errors.ERROR_ok) {
    295. return;
    296. }
    297. name = Marshal.PtrToStringAnsi(namePtr);
    298. Console.WriteLine("New client: {0}", name);
    299. ts3client.ts3client_freeMemory(namePtr); /* Release dynamically allocated memory only if function succeeded */
    300. }
    301. /*
    302. * Called when a client drops his connection.
    303. *
    304. * Parameters:
    305. * serverConnectionHandlerID - Server connection handler ID
    306. * clientID - ID of the moved client
    307. * oldChannelID - ID of the channel the leaving client was previously member of
    308. * newChannelID - 0, as client is leaving
    309. * visibility - Always LEAVE_VISIBILITY
    310. * timeoutMessage - Optional message giving the reason for the timeout
    311. */
    312. public static void onClientMoveTimeoutEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, string timeoutMessage)
    313. {
    314. Console.WriteLine("ClientID {0} timeouts with message {1}", clientID, timeoutMessage);
    315. }
    316. /*
    317. * This event is called when a client starts or stops talking.
    318. *
    319. * Parameters:
    320. * serverConnectionHandlerID - Server connection handler ID
    321. * status - 1 if client starts talking, 0 if client stops talking
    322. * isReceivedWhisper - 1 if this event was caused by whispering, 0 if caused by normal talking
    323. * clientID - ID of the client who announced the talk status change
    324. */
    325. public static void onTalkStatusChangeEvent(uint64 serverConnectionHandlerID, int status, int isReceivedWhisper, anyID clientID) {
    326. string name;
    327. IntPtr namePtr = IntPtr.Zero;
    328. /* Query client nickname from ID */
    329. uint error = ts3client.ts3client_getClientVariableAsString(serverConnectionHandlerID, clientID, ClientProperties.CLIENT_NICKNAME, out namePtr);
    330. if (error != public_errors.ERROR_ok) {
    331. return;
    332. }
    333. name = Marshal.PtrToStringAnsi(namePtr);
    334. if (status == (int)TalkStatus.STATUS_TALKING) {
    335. Console.WriteLine("Client \"{0}\" starts talking.", name);
    336. } else {
    337. Console.WriteLine("Client \"{0}\" stops talking.", name);
    338. }
    339. ts3client.ts3client_freeMemory(namePtr); /* Release dynamically allocated memory only if function succeeded */
    340. }
    341. public static void onIgnoredWhisperEvent(uint64 serverConnectionHandlerID, anyID clientID)
    342. {
    343. Console.WriteLine("Ignored whisper: {0} {1}", serverConnectionHandlerID, clientID);
    344. }
    345. public static void onServerErrorEvent(uint64 serverConnectionHandlerID, string errorMessage, uint error, string returnCode, string extraMessage) {
    346. Console.WriteLine("Error for server {0}: {1}", serverConnectionHandlerID, errorMessage);
    347. }
    348. public static void onServerStopEvent(uint64 serverConnectionHandlerID, string shutdownMessage) {
    349. Console.WriteLine("Server {0} stopping: {1}", serverConnectionHandlerID, shutdownMessage);
    350. }
    351. }


    Das kannst du ganz einfach mit einen Converter nach VB.NET übersetzen. (Edit: Irgendwie geht grad der C# BB-Code nicht ^^)
    KaskadekingDE on GitHub :)
    Bitte keine Fragen über Programmierung per PN! Dafür ist das Forum hier.

    Who cares? ¯\_(ツ)_/¯
    ich hab mir dieses SDK auch mal angekuckt...
    es ist wirklich unter allerster sau! es ist nicht mal eine dou zu finden!
    lade dir hier sdk client all plattforms runter
    teamspeak.com/index.php?page=downloads
    sdk plugins ist nur ein client für deinen client! und somit nicht das was du willst (glaube ich)
    du willst dir einen komplett eigene client basteln richtig?

    eine doku habe ich leider nicht gefunden! auch keine Beispiele für einen eigenen Client mit UI ...

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „MVN050“ ()