　　如果 accept 函数执行成功，将创建一个可以与远程主机通信的新socket。这个新socket被绑定到与监听socket相同的端口号上。当操作系统收到一个目的端口是该绑定端口的数据包时，它使用源地址、源端口来确定哪个socket应该接收这个数据。

　　监听 socket 没有连接任何主机，仅仅扮演调度者的角度。使用监听 socket 给远程主机发送数据，将会失败。

　　如果没有新连接，accept函数将阻塞，直到有新连接或超时。

23、TCP 中 Client 使用 connect() 函数连接服务器。connect() 函数将阻塞调用线程，直到连接被接受或超时。

int connect(SOCKET sock, const sockaddr *addr, int addrlen);

　　send() 函数，调用成功返回发送大小。如果缓冲区大小小于 len，则返回的值会比 len 小。如果缓冲区空间已满，则send()函数将阻塞，直到超时或有了空闲缓冲空间。注意，send()函数的返回成功，只表示数据已经插入队列等待发送，并不表示已经发送出去了。

int send(SOCKET sock, const char *buf, int len, int flags)

　　recv()函数，当len非0，而返回值为0时，说明对方主机发送了FIN包。当len为0，而返回值为0时，说明socket上有可读的数据。如果socket上没有数据可读，recv()函数将阻塞。

24、TCP、UDP socket 需要注意的地方。

　　可以在 tcp socket 上使用 sendto、recvfrom函数，但是地址参数将被忽略。在一些平台上，udp socket 上可以调用 connect 函数，以和远程地址绑定。

25、windows下使用 ioctrlsocket()设置 socket 选项。cmd的取值如 FIONBIO，argp任意非零值开启非阻塞，0将阻止开启。

int ioctrlsocket(SOCKET sock, long cmd, u_long* argp);

　　posix 兼容的操作系统下，使用 fcntl 函数。必须先用 cmd 为 F_GETFL 获取状态，将取到的状态与 O_NONBLOCK按位或运算，再使用 F_SETFL cmd 进行更新。

int fcntl(int sock, int cmd, ...);

26、Select > 非阻塞IO > 多线程

　　select函数如下：

27、一个简单的TCP服务器循环。

void DoTCPLoop()
{
    // 1. 创建
    TCPSocketPtr listenSocket = SocketUtil::CreateTCPSocket(INET);
    
    // 2. Bind
    SocketAddress receivingAddress(INADDR_ANY, 48000);
    if (listenSocket->Bind(receivingAddres)!=NO_ERROR)
    {
        return;
    }
    
    // 3. Read Pending Socket
    vector<TCPSocketPtr> readBlockSockets;
    readBlockSockets.push_back(listenSocket);
    
    vector<TCPSocketPtr> readableSockets;
    
    while(gIsGameRunning)
    {
        // 4. Select
        if (SocketUtil::Select(&readBlockSockets, &readableSockets, 
                                nullptr, nulllptr, nullptr, nullptr))
        {
            // 5. 遍历 ReadableSockets
            for (const TCPSocketPtr& socket: readableSockets)
            {
                if (socket == listenSocket)
                {
                    SocketAddress newClientAddress;
                    auto newSocket = listenSocket->Accept(newClientAddress);
                    // 6. 加入 Read Pending Socket
                    readBlockSockets.push_back(newSocket);
                    ProcessNewClient(newSocket, newClientAddress);
                }
                else
                {
                    // it's a regular socket-process the data...
                    char segment[GOOD_SEGMENT_SIZE];
                    // 7. Process Client Request
                    int dataReceived = socket->Receive(segment, GOOD_SEGMENT_INT);
                    if(dataReceived>0){
                        ProcessDataFromClient(socket, segment, dataReceived);
                    }
                }
            }
        }
    }
    
}

View Code

28、setsockopt

int setsockotp(SOCKET sock, int level, int optname, const char *optval, int optlen);

　　包括以下常用选项：

　　1）SO_REUSEADDR

　　2）SO_KEEPALIVE

　　3）TCP_NODELAY
　　　　

29、压缩

　　1）稀疏数组压缩。

　　2）熵编码。用某个较短的值代替较长的值。

　　3）定点。用离散值代表连续值。

30、基本的反射系统。

　　1）先定义基本类型。

enum EPrimitiveType
{
    EPT_Int,
    EPT_String,
    EPT_Float
};

　　2）成员变量的封装。

class MemberVariable
{
public:
    MemberVariable(const char* inName, EPrimitiveType inPrimitiveType, uint32_t inOffset):
                    mName(inName),mPrimitiveType(inPrimitiveType),mOffset(inOffset){}
                    
    EPrimitiveType GetPrimitiveType() const {return mPrimitiveTYpe;}
    uint32_t GetOffset() const {return mOffset;}
    
private:
    std::string     mName;
    EPrimitiveType     mPrimitiveType;
    uint32_t        mOffset;
}

　　3）成员变量容器。

class DataType
{
public:
    DataType(std::initializer_list<const MemberVariable&> inMVs):
    mMemberVariables(inMVs){}
    
    const std::vector<MemberVariable>& GetMemberVariables() const
    {
        return mMemberVariables;
    }
    
private:
    std::vector<MemberVariable> mMemberVariables;
}

31、基于基本的反射系统的简单序列化函数。

// inData: 对象指针
// inDataType: 对象成员列表
void Serialize(MemoryStream* inMemoryStream,const DataType* inDataType, uint8_t* inData)
{
    for(auto& mv:inDataType->GetMemberVariables())
    {
        void* mvData = inData + mv.GetOffset();
        switch(mv.GetPrimitiveType())
        {
            EPT_Int:
                inMemoryStream->Serialize(*(int*)mvData);
                break;
            EPT_String:
                inMemoryStream->Serialize(*(std::string*)mvData);
                break;
            EPT_Float:
                inMemoryStream->Serialize(*(float*)mvData);
                break;
        }
    }
}

32、传输对象三步曲。从一台主机向另一台主机传输对象的行为称为复制（replication）。

　　1）对象ID。LinkingContext

　　2）类ID。ObjectCreationRegistry

　　3）对数数据的序列化。

33、游戏状态的增量更新，包含三种操作：增、改、删。

enum ReplicationAction
{
    RA_Create,
    RA_Update,
    RA_Destroy,
    RA_MAX
}

34、服务器客户端代码分离。

35、RPC框架中，每一个 RPC Function 都对应一个 RCPUnwrapFunc，如：

　　RPCManager 会使用到上面的 RCPUnwrapFunc。

class RPCManager
{
public:
    void RegisterUnwrapFunction(uint32_t inName, RPCUnwrapFunc inFunc)
    {
        assert(mNameToRPCTable, find(inName)==mNameToRPCTable.end());
        mNameToRPCTable[inName]=inFunc;
    }
    
    void ProcessRPC(InputMemoryBitStream& inStream)
    {
        uint32_t name;
        inSteram.Read(name);
        mNameToRPCTable[name](inStream);
    }
    
    unordered_map<uint32_t, RPCUnwrapFunc> mNameToRPCTable;
}

View Code

　　下面是一个 RCPUnwrapFUnc 的示例。

void UnwrapPlaySound(InputMemoryBitStream& inStream)
{
    string soundName;
    Vector3 location;
    float volume;
    
    // 此处解参数
    inStream.Read(soundName);
    inStream.Read(location);
    inStream.Read(volume);
    
    // 此处调用真正的函数
    PlaySound(soundName, location, volume);
}

void RegisterRPCs(RPCManager* inRPCManager)
{
    inRPCManager->RegisterUnwrapFunction('PSND', UnwrapPlaySound);
}

View Code

37、对等网络中，主对等体的主要目的是提供游戏中已知的对等体的IP地址。除了这一个特例，主对等体与其他对等体行为一致。所以如果主对等体断开了，游戏仍然可以继续。

38、

39、

40、

posted on 2019-07-28 23:31 Tekkaman 阅读(1612) 评论(0) 编辑收藏举报

刷新页面返回顶部

导航