nakama unreal
v2.10.0
Nakama เป็นเซิร์ฟเวอร์โอเพนซอร์ซที่ออกแบบมาเพื่อเพิ่มพลังให้กับเกมและแอพที่ทันสมัย คุณสมบัติรวมถึงบัญชีผู้ใช้, แชท, โซเชียล, ผู้จับคู่, ผู้เล่นหลายคนแบบเรียลไทม์และอื่น ๆ อีกมากมาย
ไคลเอนต์นี้ใช้ตัวเลือก API และซ็อกเก็ตเต็มรูปแบบกับเซิร์ฟเวอร์ มันเขียนใน C ++ โดยมีการพึ่งพาน้อยที่สุดเพื่อสนับสนุน Unreal 4 และ 5
หากคุณประสบปัญหาใด ๆ กับลูกค้าจะมีประโยชน์ในการเปิดใช้งานบันทึกการดีบักและเปิดปัญหา
เอกสารฉบับเต็มคือออนไลน์ - https://heroiclabs.com/docs
ปลั๊กอินนี้ยังสามารถใช้สำหรับโปรแกรมเมอร์ที่ชอบ C ++ หรือพิมพ์เขียว ตัวแปรและฟังก์ชั่นทั้งหมดสัมผัสกับประเภทที่ใช้โดยเครื่องยนต์ Unreal (uproperties, ustruct, ufunctions ฯลฯ )
ปลั๊กอินแบ่งออกเป็นสามโมดูลซึ่งสามารถดึงได้ขึ้นอยู่กับความต้องการของคุณ
NakamaUnreal โมดูลที่ใช้ C ++ ที่แนะนำสำหรับการใช้ Nakama ใน Unrealengine สิ่งนี้รวมเข้ากับประเภทดั้งเดิมของ Unreal และ UobjectsNakamaBlueprints สำหรับผู้ใช้ที่ต้องการใช้พิมพ์เขียวในโครงการของพวกเขาNakamaCore สำหรับผู้ใช้ที่อพยพจากไคลเอนต์ Pre-V2.6.0 Unreal และต้องการเปลี่ยนแปลงน้อยที่สุดหรือใช้ C ++ API ระดับล่างของเราโดยไม่มีประเภทที่ไม่จริง: (https://github.com/heroiclabs/nakama-cpp)เนื่องจาก
NakamaCoreใช้ไลบรารี prebuilt คุณอาจพบปัญหาการสร้างเนื่องจากความแตกต่างในเครื่องมือของ Unreal จากเครื่องมือ C ++ มาตรฐาน นี่คือเหตุผลที่NakamaUnrealเป็นโมดูลที่เราแนะนำ
ไคลเอนต์จะถูกส่งต่อในเอกสารนี้เป็น ไคลเอนต์เรียลไทม์ และ ไคลเอนต์เริ่มต้น ซึ่งไคลเอนต์เรียลไทม์คือซ็อกเก็ตและไคลเอนต์เริ่มต้นใช้ REST API เพื่อสื่อสารกับ Nakama
คุณจะต้องตั้งค่าเซิร์ฟเวอร์และฐานข้อมูลก่อนที่คุณจะสามารถเชื่อมต่อกับไคลเอนต์ วิธีที่ง่ายที่สุดคือการใช้ Docker แต่ดูเอกสารเซิร์ฟเวอร์สำหรับตัวเลือกอื่น ๆ
ในการเริ่มต้นใช้ Nakama ใน Unreal คุณจะต้องมีสิ่งต่อไปนี้:
นอกจากนี้โปรดตรวจสอบให้แน่ใจว่าโครงการ Unreal ของคุณเป็นโครงการ C ++ หากเป็นพิมพ์เขียวเท่านั้นคุณสามารถเพิ่มไฟล์ C ++ ใหม่ลงในโครงการของคุณใน Unreal Editor ผ่านทาง "ไฟล์ -> คลาส C ++ ใหม่" ตั้งค่าเป็นส่วนตัวและตั้งชื่อตามสิ่งที่คุณต้องการ การมีไฟล์นี้ในโครงการของคุณช่วยให้ไม่ได้รวบรวมปลั๊กอิน
ในการใช้ Nakama ในโครงการ Unreal ของคุณคุณจะต้องดาวน์โหลดปลั๊กอินของเราจาก Unreal Marketplace หรือคัดลอกไฟล์ Nakama-Unreal ที่คุณดาวน์โหลดไปยังสถานที่ที่เหมาะสม ที่จะทำหลัง:
C:\MyUnrealProject\ ) ใน Explorer หรือ FinderPlugins ปลั๊กอินที่นี่Nakama จาก Nakama-Unreal และใส่ไว้ในโฟลเดอร์ Plugins ทางเลือก: คุณสามารถใส่ปลั๊กอินภายในโฟลเดอร์ปลั๊กอิน Unreal Engine ของคุณ (ตัวอย่างเช่น C:Program FilesEpic GamesUE_4.26EnginePluginsMarketplace ) เพื่อใช้ปลั๊กอินในหลายโครงการ
ณ จุดนี้คุณทำเสร็จแล้ว รีสตาร์ทไม่จริง หลังจากรวบรวมสิ่งต่าง ๆ ให้เปิดปลั๊กอิน edit-> และเลื่อนไปที่ด้านล่าง หากทุกอย่างเป็นไปด้วยดีคุณควรเห็น Heroiclabs.nakama ที่ระบุว่าเป็นปลั๊กอิน
ลูกค้า
คุณต้องตัดสินใจว่าคุณต้องการสร้างและเก็บบันทึกลูกค้าเหล่านี้ที่ไหน
การประชุม
เซสชั่นเป็น uobjects แบบพกพาที่มีตัวชี้เซสชันและโครงสร้างที่มีข้อมูลจริงในเซสชันเช่นโทเค็นข้อมูลผู้ใช้ข้อมูลหมดอายุ นอกจากนี้ยังมีฟังก์ชั่นยูทิลิตี้บางอย่างที่มาพร้อมกับวัตถุเซสชันเช่นรับตัวแปรเฉพาะหรือกู้คืนเซสชัน
ระบบเห็บ
โดยปกติคุณจะต้องจัดการกับการติ๊กบนพื้นฐาน C ++ โชคดีที่สิ่งนี้จะทำโดยอัตโนมัติภายใต้ฮูดในปลั๊กอินนี้หลังจากที่คุณสร้างไคลเอนต์ เมื่อคุณสร้างไคลเอนต์คุณสามารถกำหนดช่วงเวลาที่ติ๊กได้โดยค่าเริ่มต้นจะถูกตั้งค่าเป็น 0 ซึ่งหมายความว่าจะทำเครื่องหมายทุกเฟรมหากคุณต้องการให้ติ๊กทุก ๆ 50ms คุณต้องตั้งค่าเป็น 0.05 เพื่อให้ติ๊กทุกวินาทีนี้จะเป็น 1
ด้านล่างเป็นตัวอย่างง่ายๆของการตั้งค่าไคลเอนต์เริ่มต้นการรับรองความถูกต้องตั้งค่าไคลเอนต์เรียลไทม์และเข้าร่วมห้องแชท ในตัวอย่างเราจะใส่ทุกอย่างในคลาส AACTACT ที่ว่างเปล่าที่อยู่ในระดับ
อย่าลืมเพิ่ม nakamaunreal ให้กับการพึ่งพาส่วนตัวของคุณภายใต้ไฟล์โครงการ build.cs ของคุณ ตัวอย่างเช่น:
PrivateDependencyModuleNames . AddRange ( new string [ ] { "NakamaUnreal" } ) ;เริ่มต้นด้วยตัวแปรสาธารณะส่วนหัวเรากำลังใช้นักแสดงว่างเปล่าที่จะอยู่ในฉากในตัวอย่างนี้ Unreal Engine ใช้ระบบสะท้อนแสงที่ให้ข้อมูลเมตาเกี่ยวกับชั้นเรียนและช่วยให้มีคุณสมบัติขั้นสูงเช่นการสื่อสารพิมพ์เขียว/C ++, Serialization และอื่น ๆ เมื่อทำงานกับวัตถุ Nakama หรือคลาสที่ได้มาจาก Uobject ใด ๆ มันเป็นสิ่งสำคัญที่จะทำเครื่องหมายพวกเขาโดยใช้ระบบการสะท้อนแสงที่ไม่จริง สิ่งนี้ทำได้โดยใช้มาโครเช่น Ufunction () และ Uproperty ()
UPROPERTY ()
UNakamaClient* NakamaClient;
UPROPERTY ()
UNakamaRealtimeClient* NakamaRealtimeClient;
UPROPERTY ()
UNakamaSession* UserSession;
UFUNCTION ()
void OnAuthenticationSuccess(UNakamaSession* LoginData);
UFUNCTION ()
void OnAuthenticationError( const FNakamaError& Error);
UFUNCTION ()
void OnRealtimeClientConnectSuccess();
UFUNCTION ()
void OnRealtimeClientConnectError( const FNakamaRtError& ErrorData);
// Initialize client and authenticate here
virtual void BeginPlay () override ;ตัวอย่างเช่นหากคุณต้องการให้วัตถุ Nakama พร้อมใช้งานสำหรับการจัดการภายในตัวแก้ไขพิมพ์เขียวคุณจะทำเครื่องหมายด้วย uproperty ()
UPROPERTY (BlueprintReadWrite, EditAnywhere, Category= " Nakama " )
UNakamaClient* NakamaClientInstance;ด้วยการใช้ตัวระบุ BluePrinTreadWrite ตัวแปร NakamaclientInstance จะกลายเป็นทั้งอ่านได้และเขียนได้ในพิมพ์เขียว
จากนั้นภายในการเล่นเริ่มต้นเราตั้งค่าไคลเอนต์เริ่มต้นรับรองความถูกต้องและผูกมัดผู้ได้รับมอบหมาย
// Called when the game starts or when spawned
void AMyActor::BeginPlay ()
{
Super::BeginPlay ();
// Default Client Parameters
FString ServerKey = TEXT ( " defaultkey " );
FString Host = TEXT ( " 127.0.0.1 " );
int32 Port = 7350 ;
bool bUseSSL = false ;
bool bEnableDebug = true ;
// Setup Default Client
NakamaClient = UNakamaClient::CreateDefaultClient (ServerKey, Host, Port, bUseSSL, bEnableDebug);
// Authentication Parameters
FString Email = TEXT ( " [email protected] " );
FString Password = TEXT ( " verysecretpassword " );
FString Username = TEXT ( " debug-user " );
TMap<FString, FString> Variables;
// Setup Delegates of same type and bind them to local functions
FOnAuthUpdate AuthenticationSuccessDelegate;
AuthenticationSuccessDelegate. AddDynamic ( this , &AMyActor::OnAuthenticationSuccess);
FOnError AuthenticationErrorDelegate;
AuthenticationErrorDelegate. AddDynamic ( this , &AMyActor::OnAuthenticationError);
NakamaClient-> AuthenticateEmail (Email, Password, Username, true , Variables, AuthenticationSuccessDelegate, AuthenticationErrorDelegate);
}จากนั้นการตอบสนองของการโทรกลับการรับรองความถูกต้อง
void AMyActor::OnAuthenticationSuccess (UNakamaSession* LoginData)
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Green, FString::Printf ( TEXT ( " Authenticated As %s " ), *LoginData-> SessionData . Username ));
UserSession = LoginData;
// Setup Delegates of same type and bind them to local functions
FOnRealtimeClientConnected ConnectionSuccessDelegate;
ConnectionSuccessDelegate. AddDynamic ( this , &AMyActor::OnRealtimeClientConnectSuccess);
FOnRealtimeClientConnectionError ConnectionErrorDelegate;
ConnectionErrorDelegate. AddDynamic ( this , &AMyActor::OnRealtimeClientConnectError);
// This is our realtime client (socket) ready to use
NakamaRealtimeClient = NakamaClient-> SetupRealtimeClient ();
// Remember to Connect
bool bCreateStatus = true ;
NakamaRealtimeClient-> Connect (UserSession, bCreateStatus, ConnectionSuccessDelegate, ConnectionErrorDelegate);
}
void AMyActor::OnAuthenticationError ( const FNakamaError& Error)
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Red, FString::Printf ( TEXT ( " Failed to Authenticate: %s " ), *Error. Message ));
}และในที่สุดการโทรกลับไคลเอนต์เรียลไทม์ที่ถูกแทนที่คุณสามารถใช้ไคลเอนต์เรียลไทม์ได้แล้ว
void AMyActor::OnRealtimeClientConnectSuccess ()
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Green, FString ( TEXT ( " Socket Setup Success! " )));
// Example of Joining Chat without callbacks
NakamaRealtimeClient-> JoinChat ( " Heroes " , ENakamaChannelType::ROOM, true , false , {}, {});
}
void AMyActor::OnRealtimeClientConnectError ( const FNakamaRtError& ErrorData)
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Red, FString ( TEXT ( " Socket Setup Failed! " )));
}หากคุณตั้งค่าทุกอย่างอย่างถูกต้องให้สร้างเวอร์ชันพิมพ์เขียวของนักแสดงนี้และวางไว้ในระดับที่คุณจะเห็นข้อความบนหน้าจอบอกว่าคุณได้รับการรับรองความถูกต้องชื่อผู้ใช้ของคุณและข้อความเชื่อมต่อซ็อกเก็ต
Nakama Unreal Release ล่าสุดนำเสนอความยืดหยุ่นในการใช้ Dynamic Multicast Delegates หรือ Lambdas (TFunctions) สำหรับการจัดการฟังก์ชั่นและกิจกรรม นี่คือการเปรียบเทียบและแนวทางสั้น ๆ เกี่ยวกับวิธีการใช้งาน:
AddDynamic ระบุประเภทการโทรกลับที่คุณต้องการ (ไม่ว่าจะเป็น delegate หรือ lambda ) ในพารามิเตอร์ Success และ Error ของฟังก์ชันนากามาที่เกี่ยวข้อง
นี่คือการสาธิตการใช้ lambdas เป็นทางเลือกแทน delegates :
// Define success callback with a lambda
auto successCallback = [&](UNakamaSession* session)
{
UE_LOG (LogTemp, Warning, TEXT ( " Session Token: %s " ), *Session-> GetAuthToken ());
UE_LOG (LogTemp, Warning, TEXT ( " Username: %s " ), *Session-> GetUsername ());
};
// Define error callback with a lambda
auto errorCallback = [&]( const FNakamaError& Error)
{
UE_LOG (LogTemp, Warning, TEXT ( " Error Code: %d " ), Error. Code );
};
// Execute the AuthenticateEmail function with lambdas
Client-> AuthenticateEmail (TEXT( " [email protected] " ), TEXT( " verysecretpassword " ), TEXT( " debug-user " ), true, {}, successCallback, errorCallback);เมื่อเริ่มต้นการเริ่มต้นลูกค้าเรียลไทม์ของคุณสิ่งสำคัญคือการสร้างผู้ฟังเหตุการณ์สำหรับเหตุการณ์ที่สำคัญในเกมที่สำคัญตั้งแต่ข้อความช่องและการแจ้งเตือนไปจนถึงการโต้ตอบของพรรค Nakama Unreal ให้ความยืดหยุ่นโดยอนุญาตให้ทั้งแลมบ์ดาและผู้ได้รับมอบหมายเพื่อจุดประสงค์นี้
// Start by creating a Realtime Client:
UNakamaRealtimeClient* Socket = NakamaClient-> SetupRealtimeClient ();
// When using delegates, you need to declare functions that match the delegate's signature:
Socket->ChannelMessageReceived.AddDynamic( this , &ANakamaActor::OnChannelMessageReceived);
Socket->NotificationReceived.AddDynamic( this , &ANakamaActor::OnNotificationReceived);
// Lambdas offer a concise way to define event handlers directly in-line:
// Note: A lambda can be bound only once.
Socket-> SetChannelMessageCallback ( []( const FNakamaChannelMessage& ChannelMessage)
{
UE_LOG (LogTemp, Warning, TEXT ( " Channel Message: %s " ), *ChannelMessage. Content );
});
Socket-> SetNotificationsCallback ( []( const FNakamaNotificationList& NotificationList)
{
UE_LOG (LogTemp, Warning, TEXT ( " Notifications: %d " ), NotificationList. Notifications . Num ());
for ( auto & Notification : NotificationList. Notifications )
{
UE_LOG (LogTemp, Warning, TEXT ( " Notification: %s " ), *Notification. Content );
}
});
// Establish a connection to start receiving events.
// Optional success and error callbacks (either lambdas or delegates) can be provided:
Socket-> Connect (Session, true );การใช้งานฟังก์ชั่นอาจมีลักษณะเช่นนี้:
void ANakamaActor::OnChannelMessageReceived ( const FNakamaChannelMessage& ChannelMessage)
{
UE_LOG (LogTemp, Warning, TEXT ( " Channel Message: %s " ), *ChannelMessage. Content );
}
void ANakamaActor::OnNotificationReceived ( const FNakamaNotificationList& Notifications)
{
for ( auto NotificationData : Notifications. Notifications )
{
UE_LOG (LogTemp, Warning, TEXT ( " Notification: %s " ), *NotificationData. Content );
}
}NakamaBlueprintsในส่วนนี้คุณจะได้เรียนรู้วิธีการสร้างและจัดการลูกค้า Nakama ด้วยตนเองที่จัดทำโดยปลั๊กอินนี้ทั้งหมดในพิมพ์เขียวทั้งหมด
มันขึ้นอยู่กับคุณที่จะสร้างและจัดเก็บการอ้างอิงไปยังลูกค้าสิ่งนี้สามารถทำได้ในนักแสดงส่วนประกอบตัวละครตัวละครเกม ฯลฯ สถานที่ที่ดีในการวางลูกค้าอยู่ในคอนโทรลเลอร์ผู้เล่นหรืออินสแตนซ์เกม
เริ่มต้นด้วยการเพิ่มโหนด ไคลเอนต์เริ่มต้น ซึ่งเป็นส่วนหนึ่งของไลบรารี Nakama
มันเป็นวิธีปฏิบัติที่ดีในการโปรโมตลูกค้าไปสู่ตัวแปรเพื่อให้คุณสามารถเข้าถึงสถานที่อื่น ๆ ในกราฟพิมพ์เขียวของคุณ
ตอนนี้คุณพร้อมที่จะรับรองความถูกต้องโดยใช้หนึ่งในประเภทการตรวจสอบความถูกต้องของ Nakama ที่ให้ไว้ในตัวอย่างนี้เราจะตรวจสอบด้วยอีเมลและรหัสผ่านโดยปกติคุณจะตั้งค่าพิมพ์เขียววิดเจ็ตและส่งผ่านอินพุตจาก UI ไปยังโหนดการตรวจสอบสิทธิ์และตรวจสอบสิทธิ์โดยกดปุ่มเข้าสู่ระบบ
อย่างที่คุณเห็นสิ่งนี้จะส่งคืนวัตถุเซสชันที่จะส่งผ่านไปยังฟังก์ชั่นอื่น ๆ ตรวจสอบให้แน่ใจว่าได้โปรโมตวัตถุเซสชันสำหรับการใช้งานในภายหลัง ด้วยปลั๊กอินนี้คุณอาจมีหลายเซสชันต่ออินสแตนซ์ที่ไม่จริงมันขึ้นอยู่กับคุณที่จะเก็บบันทึกและตัดสินใจว่าคุณต้องการใช้เซสชันอย่างไร ต้องเชื่อมต่อตัวแปรตัวแปร แต่คุณสามารถปล่อยให้แผนที่สตริงว่างเปล่าหากคุณไม่ต้องการใช้ตัวแปรที่กำหนดเอง
หลังจากที่คุณสร้างไคลเอนต์เริ่มต้นแล้วคุณจะสามารถตั้งค่าไคลเอนต์เรียลไทม์หนึ่งรายการขึ้นไป (ซ็อกเก็ต) ที่โต้ตอบกับเซิร์ฟเวอร์ได้
ลากออกจาก nakamaclient ที่คุณสร้างขึ้นก่อนหน้านี้และเรียกใช้ฟังก์ชัน ไคลเอนต์การตั้งค่าเรียลไทม์
อย่าลืมจัดเตรียมเซสชันผู้ใช้จากการรับรองความถูกต้องที่ประสบความสำเร็จก่อนหน้านี้จากนั้นผูกเหตุการณ์ที่กำหนดเองกับความสำเร็จและการโทรกลับข้อผิดพลาด ไคลเอนต์เรียลไทม์จะถูกส่งคืนจากโหนดนี้และพร้อมที่จะใช้ในการสื่อสารกับเซิร์ฟเวอร์ Nakama ตอนนี้คุณสามารถใช้คุณสมบัติเช่นการแชทและผู้จับคู่
หลังจากสร้างไคลเอนต์เรียลไทม์ของคุณแล้วคุณพร้อมที่จะผูกกับเหตุการณ์ '
หลังจากตั้งค่าผู้ฟังเฉพาะของคุณคุณพร้อมที่จะผูกกับการโทรกลับ
สร้างเหตุการณ์ที่กำหนดเองและตั้งชื่อที่มีความหมาย
ในตัวอย่างด้านล่างเราตั้งค่าผู้ฟังเพื่อรับการแจ้งเตือนจากนั้นเราเชื่อมโยงกับเหตุการณ์วนซ้ำการแจ้งเตือนและพิมพ์เป็นสตริงดีบั๊กบนหน้าจอ
ในตัวอย่างถัดไปที่เราฟังเหตุการณ์ที่จับคู่ Matchmake จากนั้นผูกกับมันและจัดการกับการตอบกลับโดยเข้าร่วมการแข่งขันกับโทเค็นที่ส่งคืนซึ่งจะส่งคืนการแข่งขันรวมถึง ID จับคู่, presences, ฉลากและอื่น ๆ
ตามที่อธิบายไว้ก่อนหน้านี้เมื่อคุณรับรองความถูกต้องกับ Nakama คุณจะได้รับวัตถุเซสชันซึ่งคุณควรจัดเก็บที่ไหนสักแห่งที่สามารถเข้าถึงได้ง่ายในพิมพ์เขียวของคุณเนื่องจากโหนดจำนวนมากในปลั๊กอินนี้ต้องใช้วัตถุเซสชันเป็นอินพุตเป็นฟังก์ชัน
วัตถุเซสชันมีการอ้างอิงเซสชันจริงและโครงสร้างที่มีข้อมูลที่อ่านได้ในพิมพ์เขียว ลากออกจากเซสชันและรับข้อมูลเซสชัน
นอกจากนี้ยังมีวิธีการจัดการเซสชันเพิ่มเติมเช่นการกู้คืนเซสชันและตรวจสอบว่าเซสชันหมดอายุแล้ว
ขอแนะนำให้จัดเก็บโทเค็น Auth จากเซสชันและตรวจสอบเมื่อเริ่มต้นว่าหมดอายุหรือไม่ หากโทเค็นหมดอายุคุณต้อง reuthenticate เวลาหมดอายุของโทเค็นสามารถเปลี่ยนแปลงได้เป็นการตั้งค่าในเซิร์ฟเวอร์
ไคลเอนต์รวมถึง API ในตัวจำนวนมากสำหรับคุณสมบัติต่าง ๆ ของเซิร์ฟเวอร์เกม สิ่งเหล่านี้สามารถเข้าถึงได้ด้วยวิธีการ Async ซึ่งส่งคืนความสำเร็จและการโทรกลับข้อผิดพลาด พวกเขายังสามารถเรียกตรรกะที่กำหนดเองเป็นฟังก์ชั่น RPC บนเซิร์ฟเวอร์ คำขอทั้งหมดจะถูกส่งด้วยวัตถุเซสชันที่อนุญาตให้ลูกค้า
โหนด RPC สามารถใช้เพื่อเรียกใช้ฟังก์ชันการทำงานเฉพาะบนเซิร์ฟเวอร์น้ำหนักบรรทุกควรอยู่ในรูปแบบ JSON
ก้าวไปข้างหน้าคุณควรพร้อมที่จะใช้ฟังก์ชั่นทั้งหมดของ Nakama เพื่อเพิ่มพลังเกมหรือแอพที่สร้างขึ้นด้วยเอ็นจิ้น Unreal ที่ยอดเยี่ยมของคุณทำในพิมพ์เขียวทั้งหมด โปรดดูเอกสารอย่างเป็นทางการที่ https://heroiclabs.com/docs แม้ว่าเอกสารบางอย่างจะอธิบายไว้ใน C ++ ฟังก์ชันหลักเดียวกันนี้ใช้กับการใช้งานพิมพ์เขียว
เคอร์เซอร์ใช้เพื่อเพิ่มฟังก์ชั่นการเพจในบางโหนดเช่นรายชื่อเพื่อนและบันทึกลีดเดอร์บอร์ด เมื่อมีข้อมูลเพิ่มเติมที่จะเรียกคืนสตริงเคอร์เซอร์จะถูกส่งกลับในการโทรกลับที่ประสบความสำเร็จ คุณสามารถจัดเก็บเคอร์เซอร์นี้เป็นสตริงและใช้ในภายหลังเช่นเมื่อบุคคลคลิกปุ่ม "เพิ่มเติม" หรือใช้ทันทีเพื่อดึงข้อมูลเพิ่มเติม ดูตัวอย่างด้านล่าง
โดยค่าเริ่มต้นการบันทึกจะถูกปิดใช้งาน อย่างไรก็ตามเมื่อสร้างไคลเอนต์คุณมีตัวเลือกใน Enable Debug อนุญาตให้บันทึกการเขียนโดยใช้หมวดหมู่บันทึกการดีบัก คุณยังสามารถควบคุมการบันทึกด้วยตนเองได้
การเปิดใช้งานการบันทึกจากพิมพ์เขียว: 
การเปิดใช้งานการบันทึกจาก C ++
ในการเปิดใช้งานการบันทึกผ่าน C ++ ให้รวมไฟล์ส่วนหัวต่อไปนี้:
# include " NakamaLogger.h "ต่อมาเพื่อสลับการบันทึกใช้:
UNakamaLogger::EnableLogging ( true );ในการตั้งค่าระดับบันทึกให้ใช้:
UNakamaLogger::SetLogLevel (ENakamaLogLevel::Debug);หมวดหมู่บันทึกมีดังนี้:
Debug เขียนบันทึกทั้งหมด
Info เขียนบันทึกพร้อม Info Warn Error และระดับการบันทึก Fatal
Warn เขียนบันทึกด้วย Warn Error และระดับการบันทึก Fatal
Error เขียนบันทึกที่มี Error และระดับการบันทึก Fatal
Fatal เขียนบันทึกเฉพาะด้วยระดับการบันทึก Fatal
ที่เก็บนี้รวมถึงห้องทดสอบเพื่อทดสอบคุณสมบัติต่าง ๆ ของ Nakama สำหรับ Unreal การทดสอบสามารถเรียกใช้ในโปรแกรมแก้ไขได้จากบรรทัดคำสั่งและมีโครงการ BlueprintsTest ที่มีเอกสารแยกต่างหากหากคุณต้องการเรียกใช้การทดสอบเดียวกันในพิมพ์เขียว
Nakama ลงในไดเร็กทอรี Plugins ภายในโครงการFunctional Testing Editor ใน Unreal Under Edit -> Plugins จากนั้นรีสตาร์ทตัวแก้ไขTool -> TestAutomationStart Tests
การทดสอบสามารถเรียกใช้ทั้งในแพคเกจและใช้เวอร์ชันบรรทัดคำสั่งของตัวแก้ไข Unreal
สำหรับการทดสอบตามคำสั่งบรรทัดทั้งหมดเริ่มต้นด้วยการทำขั้นตอนเหล่านี้:
Nakama ในไดเรกทอรี Plugins ภายในโครงการNakama สำหรับโครงการWindows - Editor:
เพื่อสร้างการทดสอบ Run:
" <Path_To_Unreal_Engine>EngineBuildBatchFilesBuild.bat " < YourProjectName > Editor Win64 Development -Project= " <Path_To_Your_Project><YourProjectName>.uproject "ในการเรียกใช้การทดสอบ Run:
" <Path_To_Unreal_Engine>EngineBinariesWin64UnrealEditor-Cmd.exe " " <Path_To_Your_Project><YourProjectName>.uproject " -ExecCmds= " Automation RunTests <YourTestName> " -log -NullRHI -verbose -unattended -ReportOutputPath= " <Path_To_Store_Report> " หากคุณต้องการเรียกใช้การทดสอบทั้งหมดแทนที่ <YourTestName> ด้วย Nakama.Base หากคุณระบุ ReportOutputPath คุณจะได้รับภาพรวม JSON logfile บันทึกจะถูกเก็บไว้ภายในไดเรกทอรี Saved/Logs
Windows - แพคเกจ:
เพื่อสร้างการทดสอบ Run:
" <Path_To_Unreal_Engine>/Engine/Build/BatchFiles/RunUAT.sh " BuildCookRun -targetconfig=Debug -project= " <Path_To_Your_Project><YourProjectName>.uproject " -noP4 -installed -utf8output -build -cook -stage -package -verbose -stdout -nohostplatform -useshellexecuteในการเรียกใช้การทดสอบ Run:
./ < YourProjectName > /Saved/StagedBuilds/Windows/ < YourProjectName > .exe -nullrhi -verbose -ExecCmds= " Automation RunTests Nakama.Base " -logMAC - แพคเกจ:
เพื่อสร้างการทดสอบ Run:
" <Path_To_Unreal_Engine>/Engine/Build/BatchFiles/RunUAT.sh " BuildCookRun -project= " <Path_To_Your_Project><YourProjectName>.uproject " -targetConfig=Debug -noP4 -platform=Mac -Architecture_Mac=arm64 -targetconfig=Debug -installed -unrealexe=UnrealEditor -utf8output -build -cook -stage -package -verboseในการเรียกใช้การทดสอบ Run:
./ < YourProjectName > /Binaries/Mac/ < YourProjectName > .app/Contents/MacOS/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logLinux - แพคเกจ:
เพื่อสร้างการทดสอบ Run:
" <Path_To_Unreal_Engine>/Engine/Build/BatchFiles/RunUAT.sh " BuildCookRun -project= " <Path_To_Your_Project><YourProjectName>.uproject " -clientconfig=Test -noP4 -platform=Linux -targetconfig=Debug -installed -utf8output -build -cook -stage -package -verboseในการเรียกใช้การทดสอบ Run:
./ < YourProjectName > /Binaries/Linux/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logพารามิเตอร์ผ่าน
พารามิเตอร์เช่นชื่อโฮสต์พอร์ตและคีย์เซิร์ฟเวอร์สามารถส่งผ่านเป็นอาร์กิวเมนต์บรรทัดคำสั่งนี่คือตัวอย่าง:
-hostname= " 127.0.0.1 " -port=7350 -serverkey= " defaultkey " -serverhttpkey= " defaulthttpkey " -timeout=45 -useSSLคุณสมบัติบางอย่างของปลั๊กอินนี้ขึ้นอยู่กับ JSON เช่นการส่งข้อความแชทและการจัดเก็บข้อมูลโดยใช้วัตถุจัดเก็บข้อมูล ดังนั้นจึงขอแนะนำว่าหากคุณใช้พิมพ์เขียวล้วนๆที่คุณพบปลั๊กอินที่สามารถสร้างและแยกวิเคราะห์สตริง JSON เช่น Varest
เมื่อคุณพัฒนาภายในตัวแก้ไขคุณสามารถเรียกใช้อินสแตนซ์ที่ไม่จริงได้หลายครั้งโดยใช้พาย (เล่นในตัวแก้ไข) และสามารถตรวจสอบสิทธิ์โดยใช้บัญชีแยกต่างหากซึ่งมีประโยชน์มากเมื่อทดสอบฟังก์ชันการทำงานที่ต้องใช้ผู้เล่นหลายคนเช่นแชทผู้เล่นหลายคนแบบเรียลไทม์
ในส่วนการติดตั้งของเอกสารนี้เราเพิ่ม C ++ ลงในโครงการของเรานี่เป็นเพียงเพื่อให้สามารถรวบรวมปลั๊กอินได้คุณยังสามารถใช้พิมพ์เขียวได้เท่านั้น
มาพร้อมกับปลั๊กอินนี้เป็นโครงการตัวอย่างที่พัฒนาขึ้นในพิมพ์เขียวบริสุทธิ์ที่แสดงคุณสมบัติหลักของนากามาเกือบทั้งหมด
แผนงานการพัฒนาได้รับการจัดการเป็นปัญหาของ GitHub และยินดีต้อนรับคำขอดึง หากคุณสนใจที่จะปรับปรุงรหัสโปรดเปิดปัญหาเพื่อหารือเกี่ยวกับการเปลี่ยนแปลงหรือลดลงและหารือในฟอรัมชุมชน
โมดูล Unreal ขึ้นอยู่กับ C ++ SDK ทั่วไปทั่วไป
เราใช้ VCPKG เพื่อติดตั้ง Nakama-SDK สำหรับ Toolchain ที่กำหนดไว้ก่อนที่จะวางไว้ในไดเรกทอรี NakamaCore/libnakama :
ARM64-OSX: vcpkg install --overlay-triplets=./triplets --host-triplet=arm64-osx-release-heroic --triplet=arm64-osx-release-heroic
X64-Windows: vcpkg install --overlay-triplets=./triplets --host-triplet=x64-windows-heroic --triplet=x64-windows-heroic
ARM64-Windows: vcpkg install --overlay-triplets=./triplets --host-triplet=arm64-windows-heroic --triplet=arm64-windows-heroic
x64-linux: vcpkg install --overlay-triplets=./triplets --host-triplet=x64-linux-release-heroic --triplet=x64-linux-release-heroic
จากนั้นคัดลอกห้องสมุดจาก VCPKG_INSTELLED ลงในไดเรกทอรี Libnakama และส่วนหัวไปยัง NakamaCore/Public/nakama-cpp
จากนั้นคุณสามารถรวบรวมปลั๊กอินจากบรรทัดคำสั่งผ่านธง -Rocket หากคุณติดโปรแกรมแก้ไขผ่านตัวเรียกใช้งานมหากาพย์ อย่างไรก็ตามการใช้การแจกจ่ายตัวเรียกใช้งาน EPIC ไม่แนะนำอย่างน้อยสำหรับการเรียกใช้บรรทัดคำสั่ง
Windows:
${UNREAL_ENGINE} /Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin= " ${NAKAMA_UNREAL} /Nakama/Nakama.uplugin " -TargetPlatforms=Win64 -package= ${NAKAMA_UNREAL} /Out/NakamaMac:
${UNREAL_ENGINE} /Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin= " ${NAKAMA_UNREAL} /Nakama/Nakama.uplugin " -TargetPlatforms=Mac -package= ${NAKAMA_UNREAL} /Out/Nakama -Architecture_Mac=arm64 สำหรับ iOS ให้ผ่าน iOS ไปยัง TargetPlatforms
หากต้องการดูรายการคำสั่งอัตโนมัติทั้งหมดให้เรียกใช้:
${UNREAL_ENGINE}/Engine/Build/BatchFiles/RunUAT.sh -List
Linux:
${UNREAL_ENGINE}/Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin="${NAKAMA_UNREAL}/Nakama/Nakama.uplugin" -TargetPlatforms=Linux -package=${NAKAMA_UNREAL}/Out/Nakama
คุณสามารถค้นหาคู่มือไคลเอนต์ Nakama Unreal ได้ที่นี่
โครงการนี้ได้รับใบอนุญาตภายใต้ใบอนุญาต Apache-2
