少年修仙传客户端基础资源
hch
2024-04-01 d01413b00ef631ac20347716b23818b0b811f65f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
#include "w32socket.h"
#include "w32socket-internals.h"
 
#if defined(PLATFORM_UNITY) && defined(UNITY_USE_PLATFORM_STUBS)
 
#ifdef NO_HAVE_TRANSMIT_FILE_BUFFERS
 
typedef struct {
    gpointer Head;
    guint32 HeadLength;
    gpointer Tail;
    guint32 TailLength;
} TRANSMIT_FILE_BUFFERS;
 
#endif
 
gboolean
ves_icall_System_Net_Sockets_Socket_SupportPortReuse (MonoProtocolType proto, MonoError* error)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_System_Net_Dns_GetHostByName_internal (MonoStringHandle host, MonoStringHandleOut h_name, MonoArrayHandleOut h_aliases, MonoArrayHandleOut h_addr_list, gint32 hint, MonoError *error)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
void
mono_w32socket_initialize (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
}
 
void
mono_w32socket_cleanup (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
}
 
SOCKET mono_w32socket_accept (SOCKET s, struct sockaddr *addr, socklen_t *addrlen, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return INVALID_SOCKET;
}
 
int mono_w32socket_connect (SOCKET s, const struct sockaddr *name, int namelen, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
int mono_w32socket_recv (SOCKET s, char *buf, int len, int flags, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
int mono_w32socket_recvfrom (SOCKET s, char *buf, int len, int flags, struct sockaddr *from, socklen_t *fromlen, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
int mono_w32socket_recvbuffers (SOCKET s, WSABUF *lpBuffers, guint32 dwBufferCount, guint32 *lpNumberOfBytesRecvd, guint32 *lpFlags, gpointer lpOverlapped, gpointer lpCompletionRoutine, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
int mono_w32socket_send (SOCKET s, char *buf, int len, int flags, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
int mono_w32socket_sendto (SOCKET s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
int mono_w32socket_sendbuffers (SOCKET s, WSABUF *lpBuffers, guint32 dwBufferCount, guint32 *lpNumberOfBytesRecvd, guint32 lpFlags, gpointer lpOverlapped, gpointer lpCompletionRoutine, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
BOOL mono_w32socket_transmit_file (SOCKET hSocket, gpointer hFile, TRANSMIT_FILE_BUFFERS *lpTransmitBuffers, guint32 dwReserved, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
gint
mono_w32socket_disconnect (SOCKET sock, gboolean reuse)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_set_blocking (SOCKET sock, gboolean blocking)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_get_available (SOCKET sock, guint64 *amount)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
void
mono_w32socket_set_last_error (gint32 error)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
}
 
gint32
mono_w32socket_get_last_error (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint32
mono_w32socket_convert_error (gint error)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_bind (SOCKET sock, struct sockaddr *addr, socklen_t addrlen)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_getpeername (SOCKET sock, struct sockaddr *name, socklen_t *namelen)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_getsockname (SOCKET sock, struct sockaddr *name, socklen_t *namelen)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_getsockopt (SOCKET sock, gint level, gint optname, gpointer optval, socklen_t *optlen)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_setsockopt (SOCKET sock, gint level, gint optname, const gpointer optval, socklen_t optlen)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_listen (SOCKET sock, gint backlog)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gint
mono_w32socket_shutdown (SOCKET sock, gint how)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
SOCKET
mono_w32socket_socket (int domain, int type, int protocol)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return INVALID_SOCKET;
}
 
gboolean
mono_w32socket_close (SOCKET sock)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
#endif /* PLATFORM_UNITY && UNITY_USE_PLATFORM_STUBS */