diff --git a/src/game/g_net.pas b/src/game/g_net.pas
index 907a5beefd437b163adaf1ef934dbc29c55fee58..83c8398991ff1ed0429f97212a1f80df69f55440 100644 (file)
--- a/src/game/g_net.pas
+++ b/src/game/g_net.pas
e_log, e_msg, ENet, Classes, MAPDEF{$IFDEF USE_MINIUPNPC}, miniupnpc;{$ELSE};{$ENDIF}
const
- NET_PROTOCOL_VER = 180;
+ NET_PROTOCOL_VER = 181;
NET_MAXCLIENTS = 24;
NET_CHANS = 11;
NET_EVERYONE = -1;
+ NET_UNRELIABLE = 0;
+ NET_RELIABLE = 1;
+
NET_DISC_NONE: enet_uint32 = 0;
NET_DISC_PROTOCOL: enet_uint32 = 1;
NET_DISC_VERSION: enet_uint32 = 2;
type
TNetClient = record
- ID: Byte;
- Used: Boolean;
- State: Byte;
- Peer: pENetPeer;
- Player: Word;
+ ID: Byte;
+ Used: Boolean;
+ State: Byte;
+ Peer: pENetPeer;
+ Player: Word;
RequestedFullUpdate: Boolean;
RCONAuth: Boolean;
Voted: Boolean;
+ NetOut: array [0..1] of TMsg;
end;
TBanRecord = record
IP: LongWord;
NetClientPort: Word = 25666;
NetIn, NetOut: TMsg;
+ NetBuf: array [0..1] of TMsg;
NetClients: array of TNetClient;
NetClientCount: Byte = 0;
begin
NetIn.Clear();
NetOut.Clear();
+ NetBuf[NET_UNRELIABLE].Clear();
+ NetBuf[NET_RELIABLE].Clear();
SetLength(NetClients, 0);
NetPeer := nil;
NetHost := nil;
end;
procedure g_Net_Flush();
+var
+ T: Integer;
+ P: pENetPacket;
+ F, Chan: enet_uint32;
+ I: Integer;
begin
- enet_host_flush(NetHost);
+ F := 0;
+ Chan := NET_CHAN_GAME;
+
+ if NetMode = NET_SERVER then
+ for T := NET_UNRELIABLE to NET_RELIABLE do
+ begin
+ if NetBuf[T].CurSize > 0 then
+ begin
+ P := enet_packet_create(NetBuf[T].Data, NetBuf[T].CurSize, F);
+ if not Assigned(P) then continue;
+ enet_host_broadcast(NetHost, Chan, P);
+ NetBuf[T].Clear();
+ end;
+
+ for I := Low(NetClients) to High(NetClients) do
+ begin
+ if not NetClients[I].Used then continue;
+ if NetClients[I].NetOut[T].CurSize <= 0 then continue;
+ P := enet_packet_create(NetClients[I].NetOut[T].Data, NetClients[I].NetOut[T].CurSize, F);
+ if not Assigned(P) then continue;
+ enet_peer_send(NetClients[I].Peer, Chan, P);
+ NetClients[I].NetOut[T].Clear();
+ end;
+
+ // next and last iteration is always RELIABLE
+ F := LongWord(ENET_PACKET_FLAG_RELIABLE);
+ Chan := NET_CHAN_IMPORTANT;
+ end
+ else if NetMode = NET_CLIENT then
+ for T := NET_UNRELIABLE to NET_RELIABLE do
+ begin
+ if NetBuf[T].CurSize > 0 then
+ begin
+ P := enet_packet_create(NetBuf[T].Data, NetBuf[T].CurSize, F);
+ if not Assigned(P) then continue;
+ enet_peer_send(NetPeer, Chan, P);
+ NetBuf[T].Clear();
+ end;
+ // next and last iteration is always RELIABLE
+ F := LongWord(ENET_PACKET_FLAG_RELIABLE);
+ Chan := NET_CHAN_IMPORTANT;
+ end;
end;
procedure g_Net_Cleanup();
begin
NetIn.Clear();
NetOut.Clear();
+ NetBuf[NET_UNRELIABLE].Clear();
+ NetBuf[NET_RELIABLE].Clear();
SetLength(NetClients, 0);
NetClientCount := 0;
NetMode := NET_SERVER;
NetOut.Clear();
+ NetBuf[NET_UNRELIABLE].Clear();
+ NetBuf[NET_RELIABLE].Clear();
if NetDump then
g_Net_DumpStart();
enet_peer_reset(NetClients[I].Peer);
NetClients[I].Peer := nil;
NetClients[I].Used := False;
+ NetClients[I].NetOut[NET_UNRELIABLE].Free();
+ NetClients[I].NetOut[NET_RELIABLE].Free();
end;
if (NetMPeer <> nil) and (NetMHost <> nil) then g_Net_Slist_Disconnect;
procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
var
- P: pENetPacket;
- F: enet_uint32;
+ T: Integer;
begin
if (Reliable) then
- F := LongWord(ENET_PACKET_FLAG_RELIABLE)
+ T := NET_RELIABLE
else
- F := 0;
+ T := NET_UNRELIABLE;
if (ID >= 0) then
begin
if ID > High(NetClients) then Exit;
if NetClients[ID].Peer = nil then Exit;
-
- P := enet_packet_create(NetOut.Data, NetOut.CurSize, F);
- if not Assigned(P) then Exit;
-
- enet_peer_send(NetClients[ID].Peer, Chan, P);
+ // write size first
+ NetClients[ID].NetOut[T].Write(Integer(NetOut.CurSize));
+ NetClients[ID].NetOut[T].Write(NetOut);
end
else
begin
- P := enet_packet_create(NetOut.Data, NetOut.CurSize, F);
- if not Assigned(P) then Exit;
-
- enet_host_broadcast(NetHost, Chan, P);
+ // write size first
+ NetBuf[T].Write(Integer(NetOut.CurSize));
+ NetBuf[T].Write(NetOut);
end;
if NetDump then g_Net_DumpSendBuffer();
- g_Net_Flush();
NetOut.Clear();
end;
Byte(NetClients[ID].Peer^.data^) := ID;
NetClients[ID].State := NET_STATE_AUTH;
NetClients[ID].RCONAuth := False;
+ NetClients[ID].NetOut[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
+ NetClients[ID].NetOut[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
enet_peer_timeout(NetEvent.peer, ENET_PEER_TIMEOUT_LIMIT * 2, ENET_PEER_TIMEOUT_MINIMUM * 2, ENET_PEER_TIMEOUT_MAXIMUM * 2);
TC := @NetClients[ID];
if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
- g_Net_HostMsgHandler(TC, NetEvent.packet);
+ g_Net_Host_HandlePacket(TC, NetEvent.packet, g_Net_HostMsgHandler);
end;
ENET_EVENT_TYPE_DISCONNECT:
TC^.Peer := nil;
TC^.Player := 0;
TC^.RequestedFullUpdate := False;
+ TC^.NetOut[NET_UNRELIABLE].Free();
+ TC^.NetOut[NET_RELIABLE].Free();
FreeMemory(NetEvent.peer^.data);
NetEvent.peer^.data := nil;
procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
var
- P: pENetPacket;
- F: enet_uint32;
+ T: Integer;
begin
if (Reliable) then
- F := LongWord(ENET_PACKET_FLAG_RELIABLE)
+ T := NET_RELIABLE
else
- F := 0;
+ T := NET_UNRELIABLE;
- P := enet_packet_create(NetOut.Data, NetOut.CurSize, F);
- if not Assigned(P) then Exit;
+ // write size first
+ NetBuf[T].Write(Integer(NetOut.CurSize));
+ NetBuf[T].Write(NetOut);
- enet_peer_send(NetPeer, Chan, P);
if NetDump then g_Net_DumpSendBuffer();
- g_Net_Flush();
NetOut.Clear();
+ g_Net_Flush(); // FIXME: for now, send immediately
end;
function g_Net_Client_Update(): enet_size_t;
ENET_EVENT_TYPE_RECEIVE:
begin
if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
- g_Net_ClientMsgHandler(NetEvent.packet);
+ g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientMsgHandler);
end;
ENET_EVENT_TYPE_DISCONNECT:
ENET_EVENT_TYPE_RECEIVE:
begin
if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
- g_Net_ClientLightMsgHandler(NetEvent.packet);
+ g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientLightMsgHandler);
end;
ENET_EVENT_TYPE_DISCONNECT:
g_Net_DownloadTimeout := 60;
NetIn.Alloc(NET_BUFSIZE);
NetOut.Alloc(NET_BUFSIZE);
+ NetBuf[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
+ NetBuf[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
finalization
NetIn.Free();
NetOut.Free();
+ NetBuf[NET_UNRELIABLE].Free();
+ NetBuf[NET_RELIABLE].Free();
end.