最近在写自己的游戏引擎，主要是参考Quake和GoldSrc和SourceEngine2007，其中SourceEngine2007代码比较新一些。
对比了这几个引擎的代码，前两者代码比较简单，基于C代码风格编写的，SourceEngine2007则是基于C++代码风格对前两者的代码进行了一些封装和升级。
下文贴出的代码我会适当删除一些细节以保证良好的可读性。
首先“新建游戏”之后会进入 Host_NewGame 这个函数，这个函数负责启动游戏服务端，里面调用 NET_ListenSocket 开始监听端口。
void Host_NewGame()
{
NET_ListenSocket( NS_SERVER ); // activated server TCP socket
}
看到那行注释我还以为它用TCP，后来发现事情不对劲。
跟进 NET_ListenSocket 看看。
void NET_ListenSocket( int sock )
{
netsocket_t* netsock = &net_sockets[ sock ]; netsock->hUDP = NET_OpenSocket( net_interface, netsock->nPort ); struct sockaddr_in address; NET_StringToSockaddr( net_interface, &address ); address.sin_port = NET_HostToNetShort( netsock->nPort ); bind( netsock->hUDP, &address, sizeof( address ) );
}
首先它从 net_sockets 这个数组里取出了一个 netsocket_t ，这个数组是个全局变量。
// the 4 sockets, Server, Client, HLTV, Matchmaking
static netsocket_t net_sockets[ ];
这说明引擎内部固定使用四个 Socket 进行通信，索引取值如下：
enum
{
NS_CLIENT = , // client socket
NS_SERVER, // server socket
NS_HLTV,
NS_MATCHMAKING,
MAX_SOCKETS
};
回到 NET_ListenSocket 函数，接下来调用 NET_OpenSocket 创建一个 Socket 并将句柄保存到 netsock->hUDP 里。
接着调用 bind 就完成了 UDP 端口的监听。
最后 net_sockets[ NS_SERVER ] 就设置好了。
服务端 Socket 创建好了，怎么接收数据包呢？我们接着看。
void CBaseServer::RunFrame()
{
NET_ProcessSocket( NS_SERVER, this );
}
服务端创建好之后，游戏主循环就会不停地调用 CBaseServer::RunFrame 这个函数。
在 CBaseServer::RunFrame 里，调用 NET_ProcessSocket 这个函数来处理上面创建的服务端Socket。
void NET_ProcessSocket( int sock, IConnectionlessPacketHandler* handler )
{
while ( ( packet = NET_GetPacket ( sock, buffer ) ) != NULL )
{
// check for connectionless packet
if ( packet->header_byte == CONNECTIONLESS_HEADER )
{
handler->ProcessConnectionlessPacket( packet );
continue;
} // check for packets from connected clients
CNetChan* netchan = NET_FindNetChannel( sock, packet->from );
if ( netchan )
{
netchan->ProcessPacket( packet );
}
}
}
可以看到它内部有一个循环，循环调用 NET_GetPacket 读取 Socket 接收到的所有数据包。
- ConnectionlessPacket
你可以看到这里数据包分成两路处理，第一种是 ConnectionlessPacket ，翻译过来就是 无连接 数据包。
这种数据包是用来接收一些客户端请求的，比方说：PING，请求服务端信息，请求游戏信息，等等…
最最最重要的是，客户端尝试连接到服务端的时候，也是通过这种数据包进行握手（交互）协议的。
接收到这种数据包之后，就会调用 handler->ProcessConnectionlessPacket( packet ) 来把数据包交给 上层的 CBaseServer 来处理。
那个 handler 就是 上面传入 NET_ProcessSocket 的 this。
- NetChannel
这是另一种处理数据包的方式，主要用来跟已经连接的客户端进行数据交互。
例如把实体数据下发给客户端，或者接收客户端上传的数据。
首先我们关注 NET_FindNetChannel 这个函数。
CNetChan* NET_FindNetChannel( int sock, netadr_t& adr )
{
for ( int i = ; i < s_NetChannels.Count(); i++ )
{
CNetChan* chan = s_NetChannels[i]; // sockets must match
if ( sock != chan->GetSocket() )
continue; // and the IP:Port address
if ( adr.CompareAdr( chan->GetRemoteAddress() ) )
return chan;
} return NULL;
}
它遍历一个 s_NetChannels 数组，寻找一个特定的 NetChannel 并返回
我们看一下这个数组的定义：
static CUtlVector<CNetChan*> s_NetChannels;
可以看到它是个全局变量，也就是说有某处地方创建了 NetChannel 并保存在这个数组里。
但我们优先关注一下 NetChannel 到底是干什么的，以及它保存了什么数据。
class CNetChan
{
public:
void Setup( int sock, netadr_t* adr, char* name, INetChannelHandler* handler )
void ProcessPacket( netpacket_t* packet ); // NS_SERVER or NS_CLIENT index, depending on channel.
int m_Socket;
// Address this channel is talking to.
netadr_t remote_address;
// who registers and processes messages
INetChannelHandler* m_MessageHandler
}
首先它有一个成员 m_Socket 用来标识NetChannel是属于服务端还是客户端的。
然后还有个 remote_address 用来保存远程主机的网络地址。
注意了！NetChannel是服务端客户端都能使用的，所以对于服务端来说remote_address就是那些已连接的客户端的网络地址，
对于客户端来说remote_address就是已连上的服务端的网络地址。
我们再看s_NetChannels，很显然对于服务端来说，里面应该保存着一些用于跟客户端通信的NetChannel。
现在再看回 NET_ProcessSocket 函数里调用 NET_FindNetChannel 的地方，其实就是为了找出这个数据包是来自哪个客户端发来的。
确定了是哪个客户端发来的之后，自然是要处理这个数据包了。
netchan->ProcessPacket( packet );
数据包在 NetChannel 里处理成一种 Message 之后，就会把 Message 交给 handler 来处理。
void CNetChan::ProcessPacket( netpacket_t* packet )
{
m_MessageHandler->PacketStart(); m_MessageHandler->ProcessMessages( &msg ); m_MessageHandler->PacketEnd();
}
现在再回到上上面，我们现在好像还不知道 s_NetChannels 里的那些 NetChannel 是哪里的哪个谁创建的。
于是我找到了一个函数：
bool CBaseServer::ConnectClient( netadr_t& adr, int protocol, char* name, char* password )
{
if ( !CheckInfo() )
{
RejectConnection( "Bad Connection" );
return false;
} // get a free client slot
CBaseClient* client = GetFreeClient();
if ( !client )
{
RejectConnection( "Server Full" );
} // create network channel
INetChannel* netchan = NET_CreateNetChannel( NS_SERVER, adr, client ); // make sure client is reset and clear
client->Connect( name, netchan );
}
当一个客户端尝试连接到服务端的时候，服务端就会调用 CBaseServer::ConnectClient 来处理这个客户端。
如果再看 CBaseServer::ConnectClient 的上一层就是：
bool CBaseServer::ProcessConnectionlessPacket( netpacket_t* packet )
{
bf_read msg = packet->message; char cmd = msg.ReadChar(); switch ( cmd )
{
case C2S_CONNECT:
{
ConnectClient( packet->from, name, password );
}
}
}
所以 CBaseServer::ConnectClient 实际上就是处理客户端连接请求的函数。
我们再仔细看看它，如果客户端通过重重验证，那么服务端就会为客户端安排一个槽位，
如果没位置了，那就Sorry了。
安排好位置之后。就会调用 NET_CreateNetChannel 来给这个客户端创建一个 NetChannel 了。
CNetChan* NET_CreateNetChannel( int sock, netadr_t& address, INetChannelHandler* handler )
{
// create new channel
chan = new CNetChan(); s_NetChannels.AddToTail( chan ); chan->Setup( sock, address, handler ); return chan;
}
这个函数里创建一个 NetChannel 并保存到 s_Channels 里。
注意那个 handler ，就是上面的 CBaseClient* 所以 NetChannel 就会把 Message 交给 CBaseClient 来处理了。
NetChannel 小结：
- 处理来自 remote_address 的数据包
- 向 remote_address 发送数据包
事情到这已经差不多结束了。但我喜欢追究细节，所以我们回去看看 NET_GetPacket 是怎么干活的。
netpacket_t* NET_GetPacket( int sock )
{
// then check UDP data
netpacket_t* packet = NET_ReceiveDatagram( sock, &inpacket ); // ... return packet;
}
还有下层
bool NET_ReceiveDatagram ( int sock, netpacket_t* packet )
{
// Each socket has its own netpacket to allow multithreading
netpacket_t& inpacket = net_packets[sock]; int net_socket = net_sockets[sock].hUDP; int ret = recvfrom(net_socket, packet->data, NET_MAX_MESSAGE, , &from, &fromlen );
if ( ret > )
{
// convert the data to netpacket_t ...
// ...
}
}
就是调用 recvfrom 来读取数据了。
发送的部分比较简单，都是调用一两个函数就直接 sento 或者 send 发送到指定地址而已。