自学教程：C++ ENET_NET_TO_HOST_16函数代码示例

intenet_socket_get_address (ENetSocket socket, ENetAddress * address){    struct sockaddr_in sin;    socklen_t sinLength = sizeof (struct sockaddr_in);    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)      return -1;    address -> host = (enet_uint32) sin.sin_addr.s_addr;    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);    return 0;}

intenet_address_set_host (ENetAddress * address, const char * name){    struct addrinfo * result_box;    int error_code;    error_code = getaddrinfo(name, NULL, &hints, &result_box);    if (error_code != 0) return error_code;    if (result_box == NULL) return -1;    memcopy(&address, result_box -> ai_addr, result_box -> ai_addrlen);    address -> port = ENET_NET_TO_HOST_16 (address -> port);    return error_code;}

ENetSocketenet_socket_accept (ENetSocket socket, ENetAddress * address){    SOCKET result;    // only call enet_address_get_size if ptr is valid    int length = address != NULL ? enet_address_get_size (address) : 0;    result = accept (socket,                     address != NULL ? (struct sockaddr *) address : NULL,                     address != NULL ? & length : NULL);    if (result == INVALID_SOCKET)      return ENET_SOCKET_NULL;    if (address != NULL)        address -> port = ENET_NET_TO_HOST_16 (address -> port);    return result;}

intenet_socket_receive (ENetSocket socket,                     ENetAddress * address,                     ENetBuffer * buffers,                     size_t bufferCount){    struct msghdr msgHdr;    struct sockaddr_in sin;    int recvLength;    memset (& msgHdr, 0, sizeof (struct msghdr));    if (address != NULL)    {        msgHdr.msg_name = & sin;        msgHdr.msg_namelen = sizeof (struct sockaddr_in);    }    msgHdr.msg_iov = (struct iovec *) buffers;    msgHdr.msg_iovlen = bufferCount;    recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);    if (recvLength == -1)    {       if (errno == EWOULDBLOCK)         return 0;       return -1;    }#ifdef HAS_MSGHDR_FLAGS    if (msgHdr.msg_flags & MSG_TRUNC)      return -1;#endif    if (address != NULL)    {        address -> host = (enet_uint32) sin.sin_addr.s_addr;        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);    }    return recvLength;}

intenet_socket_receive (ENetSocket socket,                     ENetAddress * address,                     ENetBuffer * buffers,                     size_t bufferCount){    INT sinLength = sizeof (struct sockaddr_in);    DWORD flags = 0,          recvLength;    struct sockaddr_in sin;	memset(&sin, 0, sizeof sin);    if (WSARecvFrom (socket,                     (LPWSABUF) buffers,                     (DWORD) bufferCount,                     & recvLength,                     & flags,                     address != NULL ? (struct sockaddr *) & sin : NULL,                     address != NULL ? & sinLength : NULL,                     NULL,                     NULL) == SOCKET_ERROR)    {       switch (WSAGetLastError ())       {       case WSAEWOULDBLOCK:       case WSAECONNRESET:          return 0;       }       return -1;    }    if (flags & MSG_PARTIAL)      return -1;    if (address != NULL)    {        address -> host = (enet_uint32) sin.sin_addr.s_addr;        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);    }    return (int) recvLength;}

ENetSocketenet_socket_accept (ENetSocket socket, ENetAddress * address){    int result;    // only call enet_address_get_size if ptr is valid    socklen_t length = sizeof (struct sockaddr_in6);    result = accept (socket,                     address != NULL ? (struct sockaddr *) & address : NULL,                     address != NULL ? & length : NULL);    if (result == -1)        return ENET_SOCKET_NULL;    if (address != NULL)        address -> port = ENET_NET_TO_HOST_16 (address -> port);    return result;}

ENetSocketenet_socket_accept (ENetSocket socket, ENetAddress * address){    SOCKET result;    struct sockaddr_in sin;    int sinLength = sizeof (struct sockaddr_in);    result = accept (socket,                      address != NULL ? (struct sockaddr *) & sin : NULL,                      address != NULL ? & sinLength : NULL);    if (result == INVALID_SOCKET)      return ENET_SOCKET_NULL;    if (address != NULL)    {        address -> host = (enet_uint32) sin.sin_addr.s_addr;        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);    }    return result;}

intenet_address_set_host (ENetAddress * address, const char * name){    struct addrinfo * resultList;    int error_code;    error_code = getaddrinfo(name, NULL, &hints, &resultList);    if (error_code != 0)    {      if (resultList != NULL)        freeaddrinfo (resultList);      return error_code;    }    if (resultList == NULL) return -1;	// We simply grab the first information (IPv6 is sorted first so we get IPv6 information when IPv6 is enabled!	memcpy(address, resultList->ai_addr, resultList->ai_addrlen);    address -> port = ENET_NET_TO_HOST_16 (address -> port);    freeaddrinfo (resultList);    return error_code;}

intenet_socket_receive (ENetSocket socket,                     ENetAddress * address,                     ENetBuffer * buffers,                     size_t bufferCount){    INT length = sizeof (struct sockaddr_in6);    DWORD flags = 0,          recvLength;    if (WSARecvFrom (socket,                     (LPWSABUF) buffers,                     (DWORD) bufferCount,                     & recvLength,                     & flags,                     address != NULL ? (struct sockaddr *) address : NULL,                     address != NULL ? & length : NULL,                     NULL,                     NULL) == SOCKET_ERROR)    {       switch (WSAGetLastError ())       {       case WSAEWOULDBLOCK:       case WSAECONNRESET:          return 0;       }       return -1;    }    if (flags & MSG_PARTIAL)      return -1;    if (address != NULL)        address -> port = ENET_NET_TO_HOST_16 (address -> port);    return (int) recvLength;}

ENetIncomingCommand *enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 fragmentCount){    static ENetIncomingCommand dummyCommand;    ENetChannel * channel = & peer -> channels [command -> header.channelID];    enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber;    enet_uint16 reliableWindow, currentWindow;    ENetIncomingCommand * incomingCommand;    ENetListIterator currentCommand;    if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)      goto freePacket;    if ((command -> header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)    {        reliableSequenceNumber = command -> header.reliableSequenceNumber;        reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;        currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;        if (reliableSequenceNumber < channel -> incomingReliableSequenceNumber)           reliableWindow += ENET_PEER_RELIABLE_WINDOWS;        if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)          goto freePacket;    }                        switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK)    {    case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:    case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:       if (reliableSequenceNumber == channel -> incomingReliableSequenceNumber)           goto freePacket;              for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));            currentCommand != enet_list_end (& channel -> incomingReliableCommands);            currentCommand = enet_list_previous (currentCommand))       {          incomingCommand = (ENetIncomingCommand *) currentCommand;          if (reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)          {             if (incomingCommand -> reliableSequenceNumber < channel -> incomingReliableSequenceNumber)               continue;          }          else          if (incomingCommand -> reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)            break;          if (incomingCommand -> reliableSequenceNumber <= reliableSequenceNumber)          {             if (incomingCommand -> reliableSequenceNumber < reliableSequenceNumber)               break;             goto freePacket;          }       }       break;    case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:       unreliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendUnreliable.unreliableSequenceNumber);       if (reliableSequenceNumber == channel -> incomingReliableSequenceNumber &&           unreliableSequenceNumber <= channel -> incomingUnreliableSequenceNumber)           goto freePacket;       for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingUnreliableCommands));            currentCommand != enet_list_end (& channel -> incomingUnreliableCommands);            currentCommand = enet_list_previous (currentCommand))       {          incomingCommand = (ENetIncomingCommand *) currentCommand;          if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE)            continue;          if (reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)          {             if (incomingCommand -> reliableSequenceNumber < channel -> incomingReliableSequenceNumber)               continue;          }          else          if (incomingCommand -> reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)            break;          if (incomingCommand -> reliableSequenceNumber < reliableSequenceNumber)            break;          if (incomingCommand -> reliableSequenceNumber > reliableSequenceNumber)            continue;          if (incomingCommand -> unreliableSequenceNumber <= unreliableSequenceNumber)          {             if (incomingCommand -> unreliableSequenceNumber < unreliableSequenceNumber)               break;             goto freePacket;          }       }       break;//.........这里部分代码省略.........

static intenet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event){    ENetProtocolHeader * header;    ENetProtocol * command;    ENetPeer * peer;    enet_uint8 * currentData;    size_t commandCount;    if (host -> receivedDataLength < sizeof (ENetProtocolHeader))      return 0;    header = (ENetProtocolHeader *) host -> receivedData;    header -> peerID = ENET_NET_TO_HOST_16 (header -> peerID);    header -> sentTime = ENET_NET_TO_HOST_32 (header -> sentTime);    if (header -> peerID == 0xFFFF)      peer = NULL;    else    if (header -> peerID >= host -> peerCount)      return 0;    else    {       peer = & host -> peers [header -> peerID];       if (peer -> state == ENET_PEER_STATE_DISCONNECTED ||           peer -> state == ENET_PEER_STATE_ZOMBIE ||           host -> receivedAddress.host != peer -> address.host ||           header -> challenge != peer -> challenge)         return 0;       else         peer -> address.port = host -> receivedAddress.port;    }    if (peer != NULL)      peer -> incomingDataTotal += host -> receivedDataLength;    commandCount = header -> commandCount;    currentData = host -> receivedData + sizeof (ENetProtocolHeader);    while (commandCount > 0 &&           currentData < & host -> receivedData [host -> receivedDataLength])    {       command = (ENetProtocol *) currentData;       if (currentData + sizeof (ENetProtocolCommandHeader) > & host -> receivedData [host -> receivedDataLength])         return 0;       command -> header.commandLength = ENET_NET_TO_HOST_32 (command -> header.commandLength);       if (currentData + command -> header.commandLength > & host -> receivedData [host -> receivedDataLength])         return 0;       -- commandCount;       currentData += command -> header.commandLength;       if (peer == NULL)       {          if (command -> header.command != ENET_PROTOCOL_COMMAND_CONNECT)            return 0;       }       command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> header.reliableSequenceNumber);       switch (command -> header.command)       {       case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:          enet_protocol_handle_acknowledge (host, event, peer, command);          break;       case ENET_PROTOCOL_COMMAND_CONNECT:          peer = enet_protocol_handle_connect (host, header, command);          break;       case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:          enet_protocol_handle_verify_connect (host, event, peer, command);          break;       case ENET_PROTOCOL_COMMAND_DISCONNECT:          enet_protocol_handle_disconnect (host, peer, command);          break;       case ENET_PROTOCOL_COMMAND_PING:          enet_protocol_handle_ping (host, peer, command);          break;       case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:          enet_protocol_handle_send_reliable (host, peer, command);          break;       case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:          enet_protocol_handle_send_unreliable (host, peer, command);//.........这里部分代码省略.........

static ENetPeer *enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header, const ENetProtocol * command){    enet_uint16 mtu;    enet_uint32 windowSize;    ENetChannel * channel;    size_t channelCount;    ENetPeer * currentPeer;    ENetProtocol verifyCommand;    if (command -> header.commandLength < sizeof (ENetProtocolConnect))      return NULL;    channelCount = ENET_NET_TO_HOST_32 (command -> connect.channelCount);    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT ||        channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)      return NULL;    for (currentPeer = host -> peers;         currentPeer < & host -> peers [host -> peerCount];         ++ currentPeer)    {        if (currentPeer -> state != ENET_PEER_STATE_DISCONNECTED &&            currentPeer -> address.host == host -> receivedAddress.host &&            currentPeer -> address.port == host -> receivedAddress.port &&            currentPeer -> challenge == header -> challenge)          return NULL;    }    for (currentPeer = host -> peers;         currentPeer < & host -> peers [host -> peerCount];         ++ currentPeer)    {        if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)          break;    }    if (currentPeer >= & host -> peers [host -> peerCount])      return NULL;    currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;    currentPeer -> challenge = header -> challenge;    currentPeer -> address = host -> receivedAddress;    currentPeer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);    currentPeer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);    currentPeer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);    currentPeer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval);    currentPeer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration);    currentPeer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration);    currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));    currentPeer -> channelCount = channelCount;    for (channel = currentPeer -> channels;         channel < & currentPeer -> channels [channelCount];         ++ channel)    {        channel -> outgoingReliableSequenceNumber = 0;        channel -> outgoingUnreliableSequenceNumber = 0;        channel -> incomingReliableSequenceNumber = 0;        channel -> incomingUnreliableSequenceNumber = 0;        enet_list_clear (& channel -> incomingReliableCommands);        enet_list_clear (& channel -> incomingUnreliableCommands);    }    mtu = ENET_NET_TO_HOST_16 (command -> connect.mtu);    if (mtu < ENET_PROTOCOL_MINIMUM_MTU)      mtu = ENET_PROTOCOL_MINIMUM_MTU;    else    if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)      mtu = ENET_PROTOCOL_MAXIMUM_MTU;    currentPeer -> mtu = mtu;    if (host -> outgoingBandwidth == 0 &&        currentPeer -> incomingBandwidth == 0)      currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;    else      currentPeer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, currentPeer -> incomingBandwidth) /                                    ENET_PEER_WINDOW_SIZE_SCALE) *                                      ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;    if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)      currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;    else    if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)      currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;    if (host -> incomingBandwidth == 0)      windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;    else      windowSize = (host -> incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) *                     ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;    if (windowSize > ENET_NET_TO_HOST_32 (command -> connect.windowSize))      windowSize = ENET_NET_TO_HOST_32 (command -> connect.windowSize);    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)//.........这里部分代码省略.........

// server side processing of updates: does very little and most state is tracked// client only could be extended to move more gameplay to server (at expense of// lag)void process(ENetPacket * packet, int sender) { // sender may be -1  const u16 len = *(u16*) packet->data;  if (ENET_NET_TO_HOST_16(len)!=packet->dataLength) {    disconnect_client(sender, "packet length");    return;  }  u8 *end = packet->data+packet->dataLength;  u8 *p = packet->data+2;  char text[MAXTRANS];  int cn = -1, type;  while (p<end) switch (type = getint(p)) {    case SV_TEXT:      sgetstr();    break;    case SV_INITC2S:      sgetstr();      strcpy_s(clients[cn].name, text);      sgetstr();      getint(p);    break;    case SV_MAPCHANGE: {      sgetstr();      int reqmode = getint(p);      if (reqmode<0) reqmode = 0;      if (smapname[0] && !mapreload && !vote(text, reqmode, sender)) return;      mapreload = false;      mode = reqmode;      minremain = mode&1 ? 15 : 10;      mapend = lastsec+minremain*60;      interm = 0;      strcpy_s(smapname, text);      resetitems();      sender = -1;    }    break;    case SV_ITEMLIST: {      int n;      while ((n = getint(p))!=-1) if (notgotitems) {        server_entity se = { false, 0 };        while (sents.size()<=n) sents.push_back(se);        sents[n].spawned = true;      }      notgotitems = false;    }    break;    case SV_ITEMPICKUP: {      const int n = getint(p);      pickup(n, getint(p), sender);    }    break;    case SV_PING:      send2(false, cn, SV_PONG, getint(p));    break;    case SV_POS: {      cn = getint(p);      if (cn<0 || cn>=clients.size() || clients[cn].type==ST_EMPTY) {        disconnect_client(sender, "client num");        return;      }      int size = msgsizelookup(type);      assert(size!=-1);      loopi(size-2) getint(p);    }    break;    case SV_SENDMAP: {      sgetstr();      const auto mapsize = getint(p);      sendmaps(sender, text, mapsize, p);    }    return;    case SV_RECVMAP:      send(sender, recvmap(sender));    return;    case SV_EXT:   // allows for new features that require no server updates       for (int n = getint(p); n; n--) getint(p);    break;    default: {      const int size = msgsizelookup(type);      if (size==-1) { disconnect_client(sender, "tag type"); return; };      loopi(size-1) getint(p);    }  }  if (p>end) { disconnect_client(sender, "end of packet"); return; };  multicast(packet, sender);}

void localservertoclient(uchar *buf, int len)   // processes any updates from the server{	if(ENET_NET_TO_HOST_16(*(ushort *)buf)!=len) neterr("packet length");	incomingdemodata(buf, len);	uchar *end = buf+len;	uchar *p = buf+2;	char text[MAXTRANS];	int cn = -1, type;	dynent *d = NULL;	bool mapchanged = false;	while(p<end) switch(type = getint(p))	{		case SV_INITS2C:                    // welcome messsage from the server			{				cn = getint(p);				int prot = getint(p);				if(prot!=PROTOCOL_VERSION)				{					conoutf("you are using a different game protocol (you: %d, server: %d)", PROTOCOL_VERSION, prot);					disconnect();					return;				};				toservermap[0] = 0;				clientnum = cn;                 // we are now fully connected				if(!getint(p)) strcpy_s(toservermap, getclientmap());   // we are the first client on this server, set map				sgetstr();				if(text[0] && strcmp(text, clientpassword))				{					conoutf("you need to set the correct password to join this server!");					disconnect();					return;				};				if(getint(p)==1)				{					conoutf("server is FULL, disconnecting..");				};				break;			};		case SV_POS:                        // position of another client			{				cn = getint(p);				d = getclient(cn);				if(!d) return;				d->o.x   = getint(p)/DMF;				d->o.y   = getint(p)/DMF;				d->o.z   = getint(p)/DMF;				d->yaw   = getint(p)/DAF;				d->pitch = getint(p)/DAF;				d->roll  = getint(p)/DAF;				d->vel.x = getint(p)/DVF;				d->vel.y = getint(p)/DVF;				d->vel.z = getint(p)/DVF;				int f = getint(p);				d->strafe = (f&3)==3 ? -1 : f&3;				f >>= 2;				d->move = (f&3)==3 ? -1 : f&3;				d->onfloor = (f>>2)&1;				int state = f>>3;				if(state==CS_DEAD && d->state!=CS_DEAD) d->lastaction = lastmillis;				d->state = state;				if(!demoplayback) updatepos(d);				break;			};		case SV_SOUND:			playsound(getint(p), &d->o);			break;		case SV_TEXT:			sgetstr();			conoutf("%s:/f %s", d->name, text);			break;		case SV_MAPCHANGE:			sgetstr();			changemapserv(text, getint(p));			mapchanged = true;			break;		case SV_ITEMLIST:			{				int n;				if(mapchanged) { senditemstoserver = false; resetspawns(); };				while((n = getint(p))!=-1) if(mapchanged) setspawn(n, true);				break;			};		case SV_MAPRELOAD:          // server requests next map			{				getint(p);				sprintf_sd(nextmapalias)("nextmap_%s", getclientmap());				char *map = getalias(nextmapalias);     // look up map in the cycle				changemap(map ? map : getclientmap());				break;			};		case SV_INITC2S:            // another client either connected or changed name/team//.........这里部分代码省略.........

void localservertoclient(uchar *buf, int len) // processes any updates from the server{	if (ENET_NET_TO_HOST_16(*(ushort *)buf) != len)		neterr("packet length");	incomingdemodata(buf, len);	uchar *end = buf + len;	uchar *p = buf + 2;	char text[MAXTRANS];	int cn = -1, type;	Sprite *spr = NULL;	bool mapchanged = false;	while (p < end)		switch (type = getint(p)) {		case SV_INITS2C:                    // welcome messsage from the server		{			cn = getint(p);			int prot = getint(p);			if (prot != PROTOCOL_VERSION) {				conoutf( "you are using a different game protocol (you: %d, server: %d)", PROTOCOL_VERSION, prot);				disconnect();				return;			};			toservermap = "";			clientnum = cn;                 // we are now fully connected			if (!getint(p)) {				toservermap = getclientmap(); // we are the first client on this server, set map			}			sgetstr();			if (text[0] && strcmp(text, clientpassword)) {				conoutf( "you need to set the correct password to join this server!");				disconnect();				return;			};			if (getint(p) == 1) {				conoutf("server is FULL, disconnecting..");			};			break;		}		case SV_POS:                        // position of another client		{			cn = getint(p);			spr = getclient(cn);			if (!spr)				return;			spr->o.x = getint(p) / DMF;			spr->o.y = getint(p) / DMF;			spr->o.z = getint(p) / DMF;			spr->yaw = getint(p) / DAF;			spr->pitch = getint(p) / DAF;			spr->roll = getint(p) / DAF;			spr->vel.x = getint(p) / DVF;			spr->vel.y = getint(p) / DVF;			spr->vel.z = getint(p) / DVF;			int f = getint(p);			spr->strafe = (f & 3) == 3 ? -1 : f & 3;			f >>= 2;			spr->move = (f & 3) == 3 ? -1 : f & 3;			spr->onfloor = (f >> 2) & 1;			int state = f >> 3;			if (state == CS_DEAD && spr->state != CS_DEAD)				spr->lastaction = lastmillis;			spr->state = state;			if (!demoplayback)				updatepos(spr);			break;		}		case SV_SOUND:			playsound(getint(p), &spr->o);			break;		case SV_TEXT:			sgetstr();			conoutf("%s:/f %s", spr->name, text);			break;		case SV_MAPCHANGE:			sgetstr();			changemapserv(text, getint(p));			mapchanged = true;			break;		case SV_ITEMLIST: {			int n;			if (mapchanged) {				senditemstoserver = false;				resetspawns();			};			while ((n = getint(p)) != -1) {				if (mapchanged)					setspawn(n, true);			}			break;		}		case SV_MAPRELOAD:          // server requests next map		{			getint(p);			std::string nextmapalias = std::string("nextmap_") + getclientmap();			std::string map = getalias(nextmapalias);     // look up map in the cycle			changemap(map.empty() ? getclientmap() : map);//.........这里部分代码省略.........