1. 物体复制

  具体细节可参考官网内容:http://api.unrealengine.com/CHN/Gameplay/Networking/index.html

  这里只挑部分点来展开。

  首先,分为服务端和客户端。

  然后,先看在c++中的两个参数:bNetLoadOnClient和SetReplicates(true), 对应蓝图的参数如下图所示:

  

  Replicate的意思为复制。

  假设现在要生成一个物体(如果执行者是服务端时),如果这个物体的Replicate为true,则服务端和客户端都会生成;如果这个物体的Replicate为false,则只会在服务端生成,客户端不会生成。

  但如果执行者是客户端时,则无论物体的Replicate是否为true,服务端都不会生成这个物体。

  PS:

  1. 判断执行者是否为服务端可通过 if (GetWorld()->IsServer())来进行。

  2. 判断执行者是否为服务端通过HasAuthority()有时候是不准确的,例如当一个物体是由客户端生成的,此物体的HasAuthority()就会返回true。

  Net Load on Client意思大概是在加载地图时,这个物体是否在客户端中加载出来。

  如果地图上放置了一个物体,且这个物体的Net Load on Client为false,则客户端不会加载这个物体;反之则会。

 

2. 变量复制

  所谓变量复制就是,服务端的变量进行修改时,客户端的变量也跟着修改。

  实现很简单,只需在变量上加UPROPERTY(Replicated);或者在蓝图中,勾选Replicated,如下图所示:

  

  如果想实现,服务端修改某个变量后,自动触发某个事件,则需要在此变量上添加特别的东西,如:

//注意,OnRep_XXX中的XXX是要监测的变量。
UPROPERTY(ReplicatedUsing = OnRep_Deactivate)
    bool Deactivate;

//一旦变量Deactivate在服务端中进行修改,则会触发这个函数
UFUNCTION()
    void OnRep_Deactivate();

//在此例子中,变量Deactivate一旦在服务端被修改,客户端的OnRep_Deactivate()就会被调用,但服务端的这个函数不会被调用,需要特意去手动调用一下,如:
void AFireEffectActor::UpdateTimer()
{
    //更新数字
    if (CountDownTimer > 0) CountDownTimer -= 1;
    else
    {
        //修改变量,且通知修改事件
        Deactivate = !Deactivate;
        //修改事件函数只会在客户端运行,而服务端的则需要特意调用一下(如这里)
        OnRep_Deactivate();
    }
}

3. 服务端与客户端的信息交流

  学习资料:http://api.unrealengine.com/CHN/Gameplay/Networking/Actors/RPCs/index.html

  信息交流有3种方法:

  a. NetMulticast: 服务端广播,所有客户端能收到;客户端广播,只有该客户端能收到。

  b. Client:服务端发出通知,拥有这个人物的客户端都会调用此方法;客户端调用,则只有该客户端能调用。

  c. Server:客户端传递信息给服务端的方法;如果服务端调用则服务端能收到。

  以下将逐一讨论:

a. NetMulticast

.h:
UFUNCTION(NetMulticast, Reliable)
        void SpaceBarNetMulticast();

.cpp:
void ARPCCourseCharacter::SpaceBarNetMulticast_Implementation()
{
    //获取蓝图
    UClass* FireEffectClass = LoadClass<AActor>
        (NULL, TEXT("Blueprint'/Game/BP/UnReplicateFire.UnReplicateFire_C'"));
    //在玩家那生成物体
    GetWorld()->SpawnActor<AActor>(FireEffectClass, GetActorTransform());
}

 

  注意:

  1. Reliable是可靠的意思,意味着服务端发出的信息,客户端绝对能收到。

  2. 方法的实现要加后缀_Implementation。

 

b.Client

.h:
    //Client联网方法,服务端发出通知,拥有这个人物的客户端都会调用此方法。
    UFUNCTION(Client, Reliable)
        void KeyJClient(int32 InInt);

.cpp:
void ARPCCourseCharacter::KeyJEvent()
{
    if (GetWorld()->IsServer())
    {
        //获取所有ARPCCourseCharacter
        TArray<AActor*> ActArray;
        UGameplayStatics::GetAllActorsOfClass(
            GetWorld(), ARPCCourseCharacter::StaticClass(), ActArray);
        //呼叫所有ARPCCourseCharacter(除了自己)
        for (int i = 0; i < ActArray.Num(); ++i)
        {
            if (ActArray[i] != this)
            {
                Cast<ARPCCourseCharacter>(ActArray[i])->KeyJClient(i);
            }
        }
    }
}
void ARPCCourseCharacter::KeyJClient_Implementation(int32 InInt)
{
    ANumPad* NumPad = GetWorld()->SpawnActor<ANumPad>(ANumPad::StaticClass(),
        GetActorTransform());
    NumPad->AssignRenderText(FString::FromInt(InInt));
}

   注意,方法的实现要加后缀_Implementation。

 

c.Server

.h:
//H键绑定
    void KeyHEvent();

    //Server方法
    UFUNCTION(Server, Reliable, WithValidation)
        void KeyHServer(int32 InInt);

    //Serve方法逻辑
    void KeyHServer_Implementation(int32 InInt);

    //Serve方法数据验证(如果验证后的结果为true,KeyHServer可以正常运行;如果为false,则发出此信息的客户端被踢出房间,此客户端重新开了一局单机游戏)
    bool KeyHServer_Validate(int32 InInt);

.cpp:
    void ARPCCourseCharacter::KeyHEvent()
{
    //客户端执行
    if (!GetWorld()->IsServer()) KeyHServer(3);
}
    
    void ARPCCourseCharacter::KeyHServer_Implementation(int32 InInt)
{
    //生成数字
    ANumPad* NumPad = GetWorld()->SpawnActor<ANumPad>(ANumPad::StaticClass(),
        GetActorTransform());
    NumPad->AssignRenderText(FString::FromInt(InInt));
}

bool ARPCCourseCharacter::KeyHServer_Validate(int32 InInt)
{
    if (InInt > 0) return true;
    return false;
}

   注意:

  1. 方法的实现要加后缀_Implementation。

  2. 为预防玩家作弊,客户端传过来的信息要先进行验证,通过了才能被服务端接收。方法的验证要加后缀_Validate。

 

4.创建会话、登入与登出

  UE4的创建会话(Create Session),相当于创建房间。然后等客户端寻找房间并加入即可。如:

  

  

  GameMode只存在于服务端,不存在于客户端,因此登入与登出的行为在GameMode上做比较好。

.h:
    UCLASS(minimalapi)
class ARPCCourseGameMode : public AGameModeBase
{
    GENERATED_BODY()

public:
    ARPCCourseGameMode();

    //GameMode只存在于服务端!

    //用户登入
    virtual void PostLogin(APlayerController* NewPlayer) override;
    //用户登出
    virtual void Logout(AController* Exiting) override;

protected:

    //计算有多少个人加入了游戏
    int32 PlayerCount;
};

.cpp:
    ARPCCourseGameMode::ARPCCourseGameMode()
{
    PlayerControllerClass = ARPCController::StaticClass();

    //如果不给WorldSetting指定GameMode,游戏运行时会自动把创建项目时生成的项目名GameMode这个类给设置上去
    //如果创建的GameMode不指定PawnClass的话,会自动设定为ADefaultPawn类,所以这里必须设置为NULL
    DefaultPawnClass = NULL;
    PlayerCount = 0;
}

void ARPCCourseGameMode::PostLogin(APlayerController* NewPlayer)
{
    Super::PostLogin(NewPlayer);

    //如果这个控制器自带了一个Pawn,则摧毁它
    if (NewPlayer->GetPawn())
    {
        GetWorld()->DestroyActor(NewPlayer->GetPawn());
    }

    TArray<AActor*> ActArray;
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), 
        APlayerStart::StaticClass(), ActArray);
    if (ActArray.Num() > 0)
    {
        //人数+1
        PlayerCount++;
        //读取角色蓝图
        UClass* CharacterClass = LoadClass<ARPCCourseCharacter>
            (NULL, TEXT("Blueprint'/Game/ThirdPersonCPP/Blueprints/ThirdPersonCharacter.ThirdPersonCharacter_C'"));
        //生成角色,位置是PlayerStart或者它的右边
        ARPCCourseCharacter* NewCharacter = GetWorld()->SpawnActor<ARPCCourseCharacter>
            (CharacterClass, ActArray[0]->GetActorLocation()
                + FVector(0.f, PlayerCount*200.f, 0.f), ActArray[0]->GetActorRotation());
        //把玩家交给他对应的控制器
        NewPlayer->Possess(NewCharacter);

        DDH::Debug() << NewPlayer->GetName() << "Login" << DDH::Endl();
    }
}

void ARPCCourseGameMode::Logout(AController* Exiting)
{
    Super::Logout(Exiting);

    PlayerCount--;

    DDH::Debug() << Exiting->GetName() << "Logout" << DDH::Endl();
}

 

5.特殊的联机方法

  项目打包后,直接打开exe文件,此时游戏视为单机游戏(Standalone)。

  如果在exe的快捷方式后缀加上" ?listen"。则此时游戏视为监听模式(NM_ListenServer),如:

  

  如果在exe的快捷方式后缀加上"  127.0.0.1 -game",并且处于监听模式的游戏存在时(即已经打开了上面的RPCCourseServer),则此时游戏视为客户端,自动加入该游戏(NM_Client)。(重复打开,则重复添加客户端)如:

  

  如果直接打开原exe文件,按"~"调出控制面板后,输入“open 127.0.0.1”。则会加入已处于监听模式的游戏中,此时,此游戏成为客户端。

  

  如果在已处于监听模式的游戏中,按"~"调出控制面板后,输入“open 127.0.0.1”,则会关闭联网模式,所有游戏变为单机游戏。

  

6. 用C++创建、加入或摧毁会话

  首先要在build.cs中添加组件:

  

  由于GameInstance在游戏中一直存在,故创建会话等操作都在GameInstance中进行:

.h:
#include "CoreMinimal.h"
#include "Engine/GameInstance.h"

#include "../Plugins/Online/OnlineSubsystem/Source/Public/Interfaces/OnlineSessionInterface.h"
#include "IDelegateInstance.h"

#include "RPCInstance.generated.h"

class IOnlineSubsystem;
class APlayerController;

/**
 * 
 */
UCLASS()
class RPCCOURSE_API URPCInstance : public UGameInstance
{
    GENERATED_BODY()
    
public:

    URPCInstance();

    //指定玩家控制器
    void AssignPlayerController(APlayerController* InController);

    //创建会话
    void HostSession();

    //加入会话
    void ClientSession();

    //摧毁会话
    void DestroySession();

protected:

    //当创建会话结束后,调用这个函数
    void OnCreateSessionComplete(FName SessionName, bool bWasSuccessful);
    //当开始会话结束后,调用这个函数
    void OnStartSessionComplete(FName SessionName, bool bWasSuccessful);

    //加入服务器(会话Session)回调函数
    void OnFindSessionComplete(bool bWasSuccessful);
    void OnJoinSessionComplete(FName SessionName, EOnJoinSessionCompleteResult::Type Result);

    //销毁会话回调函数
    void OnDestroySessionComplete(FName SessionName, bool bWasSuccessful);

protected:

    APlayerController* PlayerController;

    //开启服务器委托
    FOnCreateSessionCompleteDelegate OnCreateSessionCompleteDelegate;
    FOnStartSessionCompleteDelegate OnStartSessionCompleteDelegate;

    //开启服务器委托句柄
    FDelegateHandle OnCreateSessionCompleteDelegateHandle;
    FDelegateHandle OnStartSessionCompleteDelegateHandle;

    //加入服务器委托
    FOnFindSessionsCompleteDelegate OnFindSessionsCompleteDelegate;
    FOnJoinSessionCompleteDelegate OnJoinSessionCompleteDelegate;

    //加入服务器委托句柄
    FDelegateHandle OnFindSessionsCompleteDelegateHandle;
    FDelegateHandle OnJoinSessionCompleteDelegateHandle;

    //销毁会话委托与句柄
    FOnDestroySessionCompleteDelegate OnDestroySessionCompleteDelegate;

    FDelegateHandle OnDestroySessionCompleteDelegateHandle;


    IOnlineSubsystem* OnlineSub;

    TSharedPtr<const FUniqueNetId> UserID;

    //保存寻找到的Sessions
    TSharedPtr<FOnlineSessionSearch> SearchObject;
};

.cpp:

#include "Public/RPCInstance.h"
#include "GameFramework/PlayerController.h"
#include "../Plugins/Online/OnlineSubsystem/Source/Public/Online.h"
#include "../Plugins/Online/OnlineSubsystemUtils/Source/OnlineSubsystemUtils/Public/OnlineSubsystemUtils.h"
#include "Public/RPCHelper.h"
#include "Kismet/GameplayStatics.h"

URPCInstance::URPCInstance()
{
    //绑定回调函数
    OnCreateSessionCompleteDelegate = FOnCreateSessionCompleteDelegate::
        CreateUObject(this, &URPCInstance::OnCreateSessionComplete);
    OnStartSessionCompleteDelegate = FOnStartSessionCompleteDelegate::
        CreateUObject(this, &URPCInstance::OnStartSessionComplete);
    OnFindSessionsCompleteDelegate = FOnFindSessionsCompleteDelegate::
        CreateUObject(this, &URPCInstance::OnFindSessionComplete);
    OnJoinSessionCompleteDelegate = FOnJoinSessionCompleteDelegate::
        CreateUObject(this, &URPCInstance::OnJoinSessionComplete);
    OnDestroySessionCompleteDelegate = FOnDestroySessionCompleteDelegate::
        CreateUObject(this, &URPCInstance::OnDestroySessionComplete);
}

void URPCInstance::AssignPlayerController(APlayerController* InController)
{
    PlayerController = InController;

    //获取OnlineSub
    //获取方式一:Online::GetSubsystem(GetWorld(), NAME_None),推荐使用这种
    //获取方式二:使用IOnlineSubsystem::Get(),直接获取可以createSession,但是joinSession后,客户端没有跳转场景
    OnlineSub = Online::GetSubsystem(PlayerController->GetWorld(), NAME_None);


    //获取UserID
    //获取方式一:UGameplayStatics::GetGameInstance(GetWorld())->GetLocalPlayers()[0]->GetPreferredUniqueNetId()
    if (GetLocalPlayers().Num() == 0)
        DDH::Debug() << "No LocalPlayer Exist, Can't Get UserID" << DDH::Endl();
    else
        UserID = (*GetLocalPlayers()[0]->GetPreferredUniqueNetId()).AsShared();
    //用宏定义,使编译器不对下面这段代码编译
#if 0 
    //获取方式二:使用PlayerState获取,打包后运行没问题,但在编辑器多窗口模式下,PlayerState不存在
    if (PlayerController->PlayerState)
        UserID = PlayerController->PlayerState->UniqueId.GetUniqueNetId();
    else
        DDH::Debug() << "No PlayerState Exist, Can't Get UserID" << DDH::Endl();
#endif

    //在这里直接获取Session运行时会报错,生命周期的问题

}

void URPCInstance::HostSession()
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //会话设置
            FOnlineSessionSettings Settings;
            //连接数
            Settings.NumPublicConnections = 10;
            Settings.bShouldAdvertise = true;
            Settings.bAllowJoinInProgress = true;
            //使用局域网
            Settings.bIsLANMatch = true;
            Settings.bUsesPresence = true;
            Settings.bAllowJoinViaPresence = true;
            //绑定委托
            OnCreateSessionCompleteDelegateHandle = Session
                ->AddOnCreateSessionCompleteDelegate_Handle
                (OnCreateSessionCompleteDelegate);
            //创建会话
            Session->CreateSession(*UserID, NAME_GameSession, Settings);
        }
    }
}

void URPCInstance::ClientSession()
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //实例化搜索结果指针并且设定参数
            SearchObject = MakeShareable(new FOnlineSessionSearch);
            //返回结果数
            SearchObject->MaxSearchResults = 10;
            //是否是局域网,就是IsLAN
            SearchObject->bIsLanQuery = true;
            SearchObject->QuerySettings.Set(SEARCH_PRESENCE, true,
                EOnlineComparisonOp::Equals);
            //绑定寻找会话委托
            OnFindSessionsCompleteDelegateHandle = Session->
                AddOnFindSessionsCompleteDelegate_Handle
                (OnFindSessionsCompleteDelegate);
            //进行会话寻找
            Session->FindSessions(*UserID, SearchObject.ToSharedRef());
        }
    }
}

void URPCInstance::OnCreateSessionComplete(FName SessionName, bool bWasSuccessful)
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //解绑创建会话完成回调函数
            Session->
                ClearOnCreateSessionCompleteDelegate_Handle
                (OnCreateSessionCompleteDelegateHandle);
            //判断创建会话是否成功
            if (bWasSuccessful)
            {
                DDH::Debug() << "CreatSession Succeed" << DDH::Endl();

                //绑定开启会话委托
                OnStartSessionCompleteDelegateHandle = Session->
                    AddOnStartSessionCompleteDelegate_Handle
                    (OnStartSessionCompleteDelegate);
                Session->StartSession(NAME_GameSession);
            }
            else
                DDH::Debug() << "CreateSession Failed" << DDH::Endl();
        }
    }
}

void URPCInstance::OnStartSessionComplete(FName SessionName, bool bWasSuccessful)
{
    DDH::Debug() << "StartSession Start" << DDH::Endl();
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //注销开启会话委托绑定
            Session->ClearOnStartSessionCompleteDelegate_Handle
            (OnStartSessionCompleteDelegateHandle);
            if (bWasSuccessful)
            {
                DDH::Debug() << "StartSession Succeed" << DDH::Endl();
                //服务端跳转场景
                UGameplayStatics::OpenLevel(PlayerController->GetWorld(),
                    FName("GameMap"), true, FString("listen"));
            }
            else
                DDH::Debug() << "StartSession Failed" << DDH::Endl();
        }
    }
}

void URPCInstance::OnJoinSessionComplete(FName SessionName, EOnJoinSessionCompleteResult::Type Result)
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //取消加入对话委托绑定
            Session->ClearOnJoinSessionCompleteDelegate_Handle
            (OnJoinSessionCompleteDelegateHandle);
            //如果加入成功
            if (Result == EOnJoinSessionCompleteResult::Success)
            {
                //传送玩家到新地图
                FString ConnectString;
                if (Session->GetResolvedConnectString(NAME_GameSession, ConnectString))
                {
                    DDH::Debug() << "Join Sessions Succeed" << DDH::Endl();
                    //客户端切换到服务器的关卡
                    PlayerController->ClientTravel(ConnectString, TRAVEL_Absolute);
                }
                else
                    DDH::Debug() << "Join Sessions Failed" << DDH::Endl();
            }
        }
    }
}



void URPCInstance::OnFindSessionComplete(bool bWasSuccessful)
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //取消寻找会话委托绑定
            Session->ClearOnStartSessionCompleteDelegate_Handle
            (OnStartSessionCompleteDelegateHandle);
            //如果寻找会话成功
            if (bWasSuccessful)
            {
                //如果收集的结果存在且大于1
                if (SearchObject.IsValid() && SearchObject->SearchResults.Num() > 0)
                {
                    DDH::Debug() << "Find Sessions Succeed" << DDH::Endl();
                    //绑定加入Session委托
                    OnJoinSessionCompleteDelegateHandle = Session
                        ->AddOnJoinSessionCompleteDelegate_Handle
                        (OnJoinSessionCompleteDelegate);
                    //执行加入会话
                    Session->JoinSession(*UserID, NAME_GameSession, SearchObject->SearchResults[0]);
                }
                else
                    DDH::Debug() << "Find Sessions Succeed But Num = 0" << DDH::Endl();
            }
            else
                DDH::Debug() << "Find Sessions Failed" << DDH::Endl();
        }
    }
}


void URPCInstance::OnDestroySessionComplete(FName SessionName, bool bWasSuccessful)
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //注销销毁会话委托
            Session->ClearOnDestroySessionCompleteDelegate_Handle
            (OnDestroySessionCompleteDelegateHandle);
            //其它逻辑。。。
        }
    }
}

void URPCInstance::DestroySession()
{
    if (OnlineSub)
    {
        IOnlineSessionPtr Session = OnlineSub->GetSessionInterface();
        if (Session.IsValid())
        {
            //绑定销毁会话委托
            OnDestroySessionCompleteDelegateHandle = Session->
                AddOnDestroySessionCompleteDelegate_Handle
                (OnDestroySessionCompleteDelegate);
            //执行销毁会话
            Session->DestroySession(NAME_GameSession);
        }
    }
}

 7.注意事项:

  必须满足一些要求才能充分发挥 RPC 的作用:

  1. 它们必须从 Actor 上调用。

  2. Actor 必须被复制。

  3. 如果 RPC 是从服务器调用并在客户端上执行,则只有实际拥有这个 Actor 的客户端才会执行函数。

  4. 如果 RPC 是从客户端调用并在服务器上执行,客户端就必须拥有调用 RPC 的 Actor。

  5. 多播 RPC 则是个例外:

    • 如果它们是从服务器调用,服务器将在本地和所有已连接的客户端上执行它们。

    • 如果它们是从客户端调用,则只在本地而非服务器上执行。

    • 现在,我们有了一个简单的多播事件限制机制:在特定 Actor 的网络更新期内,多播函数将不会复制两次以上。按长期计划,我们会对此进行改善,同时更好的支持跨通道流量管理与限制

  6. 关于可靠性(Reliable)

  

 

 

8.讨论:

1.在一个可复制的(Replicated)且一开始就在地图里的物体中,调用广播:

 

 

 结果:客户端和服务器都打印了。

  

 

2. 服务器生成一个可复制的物体,客户端会存在这个物体吗?

实验1.在服务器生成一个物体,物体设置为可复制的(Replicated),然后把这个物体广播出去。(在关卡蓝图中)

 

 

 结果:只有服务器存在石头,客户端不存在。

  

3. 服务器生成一个可复制的物体,且调用此物体的多播函数:

  

 

 

   

 

 结果:客户端和服务器都打印了。