int enet_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; }
int enet_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; }
ENetSocket enet_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; }
int enet_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; }
int enet_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; }
ENetSocket enet_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; }
ENetSocket enet_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; }
int enet_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; }
int enet_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; case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED: currentCommand = enet_list_end (& channel -> incomingUnreliableCommands); break; default: goto freePacket; } incomingCommand = (ENetIncomingCommand *) enet_malloc (sizeof (ENetIncomingCommand)); if (incomingCommand == NULL) goto notifyError; incomingCommand -> reliableSequenceNumber = command -> header.reliableSequenceNumber; incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF; incomingCommand -> command = * command; incomingCommand -> fragmentCount = fragmentCount; incomingCommand -> fragmentsRemaining = fragmentCount; incomingCommand -> packet = packet; incomingCommand -> fragments = NULL; if (fragmentCount > 0) { incomingCommand -> fragments = (enet_uint32 *) enet_malloc ((fragmentCount + 31) / 32 * sizeof (enet_uint32)); if (incomingCommand -> fragments == NULL) { enet_free (incomingCommand); goto notifyError; } memset (incomingCommand -> fragments, 0, (fragmentCount + 31) / 32 * sizeof (enet_uint32)); } if (packet != NULL) ++ packet -> referenceCount; enet_list_insert (enet_list_next (currentCommand), incomingCommand); switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK) { case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT: case ENET_PROTOCOL_COMMAND_SEND_RELIABLE: enet_peer_dispatch_incoming_reliable_commands (peer, channel); break; default: enet_peer_dispatch_incoming_unreliable_commands (peer, channel); break; } return incomingCommand; freePacket: if (fragmentCount > 0) goto notifyError; if (packet != NULL && packet -> referenceCount == 0) enet_packet_destroy (packet); return & dummyCommand; notifyError: if (packet != NULL && packet -> referenceCount == 0) enet_packet_destroy (packet); return NULL; }
static int enet_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); break; case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT: enet_protocol_handle_send_fragment (host, peer, command); break; case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT: enet_protocol_handle_bandwidth_limit (host, peer, command); break; case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE: enet_protocol_handle_throttle_configure (host, peer, command); break; default: break; } if (peer != NULL && (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) != 0) { switch (peer -> state) { case ENET_PEER_STATE_DISCONNECTING: break; case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT: if (command -> header.command != ENET_PROTOCOL_COMMAND_DISCONNECT) break; default: enet_peer_queue_acknowledgement (peer, command, header -> sentTime); break; } } } if (event -> type != ENET_EVENT_TYPE_NONE) return 1; return 0; }
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) windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE; else if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT; verifyCommand.header.channelID = 0xFF; verifyCommand.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; verifyCommand.header.commandLength = sizeof (ENetProtocolVerifyConnect); verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID); verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu); verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize); verifyCommand.verifyConnect.channelCount = ENET_HOST_TO_NET_32 (channelCount); verifyCommand.verifyConnect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth); verifyCommand.verifyConnect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth); verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval); verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration); verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration); enet_peer_queue_outgoing_command (currentPeer, & verifyCommand, NULL, 0, 0); return currentPeer; }
// 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 { sgetstr(); if(d->name[0]) // already connected { if(strcmp(d->name, text)) conoutf("%s is now known as %s", d->name, text); } else // new client { c2sinit = false; // send new players my info again conoutf("connected: %s", text); }; strcpy_s(d->name, text); sgetstr(); strcpy_s(d->team, text); d->lifesequence = getint(p); break; }; case SV_CDIS: cn = getint(p); if(!(d = getclient(cn))) break; conoutf("player %s disconnected", d->name[0] ? d->name : "[incompatible client]"); zapdynent(players[cn]); break; case SV_SHOT: { int gun = getint(p); vec s, e; s.x = getint(p)/DMF; s.y = getint(p)/DMF; s.z = getint(p)/DMF; e.x = getint(p)/DMF; e.y = getint(p)/DMF; e.z = getint(p)/DMF; if(gun==GUN_SG) createrays(s, e); shootv(gun, s, e, d); break; }; case SV_DAMAGE: { int target = getint(p); int damage = getint(p); int ls = getint(p); if(target==clientnum) { if(ls==player1->lifesequence) selfdamage(damage, cn, d); } else playsound(S_PAIN1+rnd(5), &getclient(target)->o); break; }; case SV_DIED: { int actor = getint(p); if(actor==cn) { conoutf("%s suicided", d->name); } else if(actor==clientnum) { int frags; if(isteam(player1->team, d->team)) { frags = -1; conoutf("you fragged a teammate (%s)", d->name); } else { frags = 1; conoutf("you fragged %s", d->name); }; addmsg(1, 2, SV_FRAGS, player1->frags += frags); } else { dynent *a = getclient(actor); if(a) { if(isteam(a->team, d->name)) { conoutf("%s fragged his teammate (%s)", a->name, d->name); } else { conoutf("%s fragged %s", a->name, d->name); }; }; }; playsound(S_DIE1+rnd(2), &d->o); d->lifesequence++; break; }; case SV_FRAGS: players[cn]->frags = getint(p); break; case SV_ITEMPICKUP: setspawn(getint(p), false); getint(p); break; case SV_ITEMSPAWN: { uint i = getint(p); setspawn(i, true); if(i>=(uint)ents.length()) break; vec v = { ents[i].x, ents[i].y, ents[i].z }; playsound(S_ITEMSPAWN, &v); break; }; case SV_ITEMACC: // server acknowledges that I picked up this item realpickup(getint(p), player1); break; case SV_PING: getint(p); break; case SV_PONG: addmsg(0, 2, SV_CLIENTPING, player1->ping = (player1->ping*5+lastmillis-getint(p))/6); break; case SV_CLIENTPING: players[cn]->ping = getint(p); break; case SV_GAMEMODE: nextmode = getint(p); break; case SV_TIMEUP: timeupdate(getint(p)); break; case SV_RECVMAP: { sgetstr(); conoutf("received map \"%s\" from server, reloading..", text); int mapsize = getint(p); writemap(text, mapsize, p); p += mapsize; changemapserv(text, gamemode); break; }; case SV_SERVMSG: sgetstr(); conoutf("%s", text); break; case SV_EXT: // so we can messages without breaking previous clients/servers, if necessary { for(int n = getint(p); n; n--) getint(p); break; }; default: neterr("type"); return; }; };
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); break; } case SV_INITC2S: // another client either connected or changed name/team { sgetstr(); if (spr->name[0]) { // already connected if (strcmp(spr->name, text)) conoutf("%s is now known as %s", spr->name, text); } else { // new client c2sinit = false; // send new players my info again conoutf("connected: %s", text); }; strcpy_s(spr->name, text); sgetstr(); strcpy_s(spr->team, text); spr->lifesequence = getint(p); break; } case SV_CDIS: cn = getint(p); if (!(spr = getclient(cn))) break; conoutf("player %s disconnected", spr->name[0] ? spr->name : "[incompatible client]"); zapSprite(players[cn]); break; case SV_SHOT: { int gun = getint(p); Vec3 s, e; s.x = getint(p) / DMF; s.y = getint(p) / DMF; s.z = getint(p) / DMF; e.x = getint(p) / DMF; e.y = getint(p) / DMF; e.z = getint(p) / DMF; if (gun == GUN_SG) createrays(s, e); shootv(gun, s, e, spr); break; } case SV_DAMAGE: { int target = getint(p); int damage = getint(p); int ls = getint(p); if (target == clientnum) { if (ls == player1->lifesequence) selfdamage(damage, cn, spr); } else playsound(S_PAIN1 + rnd(5), &getclient(target)->o); break; } case SV_DIED: { int actor = getint(p); if (actor == cn) { conoutf("%s suicided", spr->name); } else if (actor == clientnum) { int frags; if (isteam(player1->team, spr->team)) { frags = -1; conoutf("you fragged a teammate (%s)", spr->name); } else { frags = 1; conoutf("you fragged %s", spr->name); }; addmsg(1, 2, SV_FRAGS, player1->frags += frags); } else { Sprite *a = getclient(actor); if (a) { if (isteam(a->team, spr->name)) { conoutf("%s fragged his teammate (%s)", a->name, spr->name); } else { conoutf("%s fragged %s", a->name, spr->name); }; }; }; playsound(S_DIE1 + rnd(2), &spr->o); spr->lifesequence++; break; } case SV_FRAGS: players[cn]->frags = getint(p); break; case SV_ITEMPICKUP: setspawn(getint(p), false); getint(p); break; case SV_ITEMSPAWN: { int i = getint(p); setspawn(i, true); if (i >= entityList.size()) break; Vec3 v = { entityList[i].x, entityList[i].y, entityList[i].z }; playsound(S_ITEMSPAWN, &v); break; } case SV_ITEMACC: // server acknowledges that I picked up this item realpickup(getint(p), player1); break; case SV_EDITH: // coop editing messages, should be extended to include all possible editing ops case SV_EDITT: case SV_EDITS: case SV_EDITD: case SV_EDITE: { int x = getint(p); int y = getint(p); int xs = getint(p); int ys = getint(p); int v = getint(p); Rect b = { x, y, xs, ys }; switch (type) { case SV_EDITH: editheightxy(v != 0, getint(p), b); break; case SV_EDITT: edittexxy(v, getint(p), b); break; case SV_EDITS: edittypexy(v, b); break; case SV_EDITD: setvdeltaxy(v, b); break; case SV_EDITE: editequalisexy(v != 0, b); break; }; break; } case SV_EDITENT: // coop edit of ent { int i = getint(p); while (entityList.size() <= i) { entityList.emplace_back(Entity()); entityList.back().type = NOTUSED; } int to = entityList[i].type; entityList[i].type = getint(p); entityList[i].x = getint(p); entityList[i].y = getint(p); entityList[i].z = getint(p); entityList[i].attr1 = getint(p); entityList[i].attr2 = getint(p); entityList[i].attr3 = getint(p); entityList[i].attr4 = getint(p); entityList[i].spawned = false; if (entityList[i].type == LIGHT || to == LIGHT) calclight(); break; } case SV_PING: getint(p); break; case SV_PONG: addmsg(0, 2, SV_CLIENTPING, player1->ping = (player1->ping * 5 + lastmillis - getint(p)) / 6); break; case SV_CLIENTPING: players[cn]->ping = getint(p); break; case SV_GAMEMODE: nextmode = getint(p); break; case SV_TIMEUP: timeupdate(getint(p)); break; case SV_RECVMAP: { sgetstr(); conoutf("received map \"%s\" from server, reloading..", text); int mapsize = getint(p); writemap(text, mapsize, p); p += mapsize; changemapserv(text, gamemode); break; } case SV_SERVMSG: sgetstr(); conoutf("%s", text); break; case SV_EXT: // so we can messages without breaking previous clients/servers, if necessary { for (int n = getint(p); n; n--) getint(p); break; } default: neterr("type"); return; } }