ข้ามไปที่เนื้อหา

ตัวแปรที่ปลอดภัย

บทนำ

หน้านี้อธิบายฟีเจอร์ตัวแปรที่ปลอดภัยของ Hercules.
ก่อนที่จะใช้ฟีเจอร์ตัวแปรที่ปลอดภัย คุณต้องตั้งค่า Hive SDK ก่อน.
ตัวแปรที่ปลอดภัยมีลักษณะดังต่อไปนี้:

  • มันเป็นค่าที่เข้ารหัสในหน่วยความจำเพื่อไม่ให้สามารถเรียกคืนได้โดยเครื่องมือภายนอก
  • แม้ว่าค่าที่เข้ารหัสจะถูกดัดแปลง จะมีการตรวจสอบเมื่อมันถูกอ่าน
  • ภาษาโปรแกรมที่รองรับ ได้แก่ C/C++ และ C# (Unity)

วิธีการใช้ตัวแปรที่ปลอดภัย

C# (Unity)

  • โดยพื้นฐานแล้ว ประเภทข้อมูลที่มีใน C# สามารถใช้เป็นคลาส Generic ได้
  • มีประเภทข้อมูลที่ปลอดภัยซึ่งตรงกับแต่ละประเภทข้อมูลดังนี้
  • เนื่องจากประเภทพื้นฐานทั้งหมดจะถูกแปลงเป็นประเภท 8 ไบต์ จึงแนะนำให้ใช้ประเภท 8 ไบต์ เช่น การใช้ long แทน int และ double แทน float
ประเภทพื้นฐาน ประเภทที่ปลอดภัย ประเภทพื้นฐาน ประเภทที่ปลอดภัย
bool HerculesVar<bool> int HerculesVar<int>
char HerculesVar<char> uint HerculesVar<uint>
sbyte HerculesVar<sbyte> long HerculesVar<long>
byte HerculesVar<byte> ulong HerculesVar<ulong>
short HerculesVar<short> float HerculesVar<float>
ushort HerculesVar<ushort> double HerculesVar<double>
string HerculesString 
// โค้ดทั้งสองด้านล่างทำสิ่งเดียวกันและจัดสรรวัตถุใหม่
HerculesVar x = 100;
HerculesVar y = new HerculesVar(100);

// ค่าจะถูกคัดลอกจากตัวแปรที่ปลอดภัยไปยังตัวแปรปกติ
int a = x;
// วัตถุเก่าที่จัดสรรให้กับ y จะถูกปล่อยและวัตถุใหม่จะถูกจัดสรรใหม่ให้กับ y
y = 300;
// เปลี่ยนค่าของ y (y ควรได้รับการกำหนดค่าแล้วด้วยวัตถุ และการจัดสรรประเภทนี้เร็วกว่าข้างต้น)
y.Set(300);

// y ถูกกำหนดค่าใหม่เป็นค่าของ x. ทั้ง x และ y เริ่มอ้างอิงไปยังวัตถุที่แตกต่างจากวัตถุเดิมที่กำหนดให้กับ x.    
y = (int)x;

// คำเตือน: y จะอ้างถึง x หากคุณใช้ฟังก์ชัน Set ค่าทั้งสองจะถูกแทนที่
// หากเกิดข้อผิดพลาดในการสร้างเมื่อดำเนินการกับตัวแปรประเภทไม่ลงนามโดยตรง
// U จะต้องระบุหลังจากค่าคงที่หรือคุณควรใช้การแคสต์แบบชัดเจน (เช่น 1U หรือ (uint)1)
// สำหรับค่าที่มีการอัปเดตบ่อยครั้ง การใช้รูปแบบ obj.Set(v); จะมีประสิทธิภาพดีกว่า
y = x;

// สตริงสามารถใช้ได้แบบนี้: สตริงในหน่วยความจำเท่านั้นที่ได้รับการป้องกัน。
// เมื่อกำหนดสตริงคงที่เช่น “TEST” สตริงต้นฉบับอาจถูกเปิดเผยต่อโค้ด。
HerculesString securityString = <A string value downloaded from the server or generated dynamically>;
string plainString = securityString;

iOS, Android

  • ในกรณีของ C เมื่อใดก็ตามที่คุณบันทึกหรืออ่านค่าของตัวแปร คุณต้องเรียก API โดยตรง ดังนั้นจึงแนะนำให้ใช้ C++ C++ มีคลาสเทมเพลตที่กำหนดไว้
  • หากเป็นไปได้ แนะนำให้ใช้ตัวแปรที่ปลอดภัยเป็นตัวแปรทั่วโลกหรือใช้หลังจากวางไว้ในที่ที่การจัดสรรและการปล่อยไม่เกิดขึ้นบ่อยเกินไป
  • อย่าวางคำสั่ง include ภายในบล็อก "C" ที่เป็น exteren
  • ควรใช้หลังจากที่ Hive SDK ถูกเริ่มต้นแล้ว
#include "Hercules.h"

class CUserInfo {
public:
    CHercules hp;
    CHercules mp;
    CHercules critical;
};

// หากมันถูกใช้เป็นตัวแปรทั่วโลก จะเกิดปัญหาขึ้นเพราะตัวแปรจะพยายามถูกเริ่มต้นก่อนที่ Hive SDK จะถูกเริ่มต้น
// CHercules g_temp;

// เมื่อใช้เป็นตัวแปรทั่วโลก ให้ประกาศในรูปแบบของพอยน์เตอร์ดังนี้
CUserInfo *g_user;
CHercules *g_var;
CHerculesString *g_string;

void BeginBattle() {
    // สร้างตัวแปรที่ปลอดภัย (ตัวอย่าง: ที่จุดเริ่มต้นของการต่อสู้ในเกม)
    g_user = new CUserInfo;
    g_var = new CHercules;
    g_string = new CHerculesString(<A string value downloaded from the server or generated dynamically>);
}

void EndBattle() {
    // ลบตัวแปรที่ปลอดภัย (ตัวอย่าง: ที่สิ้นสุดการต่อสู้ในเกม)
    delete g_user;
    delete g_var;
    delete g_string;
    g_user = nullptr;
    …
}

void Sample()
{
    // Assignments can be made in any form as shown below.
    int localvar = 0;
    CHercules x = localvar;
    *g_var = localvar;
    *g_var = x + 2;
    g_user->hp = 100;

    // เมื่อกำหนดสตริงคงที่เช่น “TEST” สตริงต้นฉบับอาจถูกเปิดเผยต่อโค้ด
    CHerculesString localString1 = <A new string downloaded from the server or generated dynamically>; // เริ่มต้นด้วยสตริง
    CHerculesString localString2 = *g_securityString; // เริ่มต้นด้วยวัตถุ CHerculesString
    std::string localString = *g_securityString; // CHerculesString เป็น std::string
    localString2 = localString1; // CHerculesString เป็น CHerculesString
    localString1 = localString.c_str(); // std::string เป็น CHerculesString
}

#include "Hercules.h"

HERCULES g_x;
HERCULES g_y;
HERCULES g_str;

void StartApp() {
    // สร้างตัวแปรที่ปลอดภัย
    // สามารถใช้ได้โดยการใส่ประเภทพื้นฐานและตัวแปรโครงสร้าง
    int var = 0;
    g_x = HerculesAddVar(&var, sizeof(var));
    g_y = HerculesAddVar(&var, sizeof(var));

    // เมื่อกำหนดสตริงคงที่เช่น “TEST” สตริงต้นฉบับอาจถูกเปิดเผยต่อโค้ด
    g_str = HerculesAddString(<A string downloaded from the server or generated dynamically>);
}

void Sample()
{
    // รับค่าของ x และเก็บไว้ใน y ในขณะนี้ พารามิเตอร์ที่สองที่ตั้งไว้ในแต่ละฟังก์ชัน
    // ต้องเป็นตัวแปรที่มีขนาดเท่ากับขนาดที่ตั้งไว้เมื่อเรียกใช้ HerculesAddVar.
    int var;
    HerculesGetVar(g_x, &var);
    HerculesSetVar(g_y, &var);

    // หลังจากที่คุณได้รับสตริงที่ปลอดภัยเป็นสตริงปกติแล้ว คุณต้องปล่อยมันด้วยฟังก์ชัน HerculesFreeMem。
    char *str = HerculesGetString(g_str);
    HerculesFreeMem(str);

    // ก่อนที่จะกำหนดตัวแปรสตริงใหม่ จะต้องลบมันออกโดยใช้ฟังก์ชัน HerculesRemoveVar
    HerculesRemoveVar(g_str);
    g_str = HerculesAddString(<A new string downloaded from the server or generated dynamically>);
}

อ้างอิง (C++)

  • ใช้เมื่อมีการกำหนดค่าตัวแปรที่ปลอดภัยด้วยค่า (สถานะที่วัตถุถูกจัดสรร)
  • ใช้เป็นการกำหนดผลลัพธ์สุดท้ายซึ่งถูกสร้างขึ้นหลังจากการคำนวณที่จำเป็นทั้งหมดเสร็จสิ้น
  • โปรดดูตัวอย่างด้านล่าง (C++ มีการโอเวอร์โหลดตัวดำเนินการ)
// CHercules *securityVar = ...

int sum = 0;
int values[5] = {5, 4, 6, 8, 11};

for(int i = 0; i < 5; i++)
    sum += values[i];

*securityVar += sum;

// CHercules *securityVar = ...

int values[5] = {5, 4, 6, 8, 11};

for(int i = 0; i < 5; i++)
    *securityVar += values[i];