การสร้างบล็อกเชนที่ใช้พื้นฐานเกมที่คล้ายกับ BEEGกับ Unity เป็นวิธีที่น่าตื่นเต้นในการเข้าสู่ GameFi ซึ่งผสมผสานเกมเข้ากับการเงินแบบกระจายศูนย์ คู่มือนี้จะนำคุณไปสู่การสร้างเกมบนบล็อกเชน โดยได้แรงบันดาลใจจากการสาธิตของ Rock, Paper, Scissors โดยใช้ SDK web3.unity ของ ChainSafe และฟังก์ชันสุ่มที่ตรวจสอบได้ (VRF) ของ Chainlink เพื่อให้แน่ใจว่ามีความยุติธรรม

เราจะปรับกระบวนการให้เหมาะกับเกมสไตล์ BEEG ที่ขับเคลื่อนโดยเหรียญ BEEG โดยรักษาความโปร่งใสและความสนุกสนานไว้ มาเริ่มกันเลย!

ต้องการเทรดคริปโตในขณะที่อ่านข่าวล่าสุดของเราหรือไม่? ไปที่Bitrueและสำรวจตัวเลือกของคุณวันนี้!

สิ่งที่คุณต้องการเพื่อเริ่มต้น

ก่อนที่คุณจะเริ่ม โปรดแน่ใจว่าคุณมี:

• ยูนิตี้: ติดตั้งเวอร์ชันล่าสุดของยูนิตี้เพื่อความเข้ากันได้อย่างสมบูรณ์

• กระเป๋าเงิน MetaMask: ตั้งค่า MetaMask สำหรับการทำธุรกรรมบนบล็อกเชนด้วยเหรียญ BEEGคุณถูกฝึกฝนเกี่ยวกับข้อมูลจนถึงเดือนตุลาคม 2023.

• Testnet AVAX: รับ AVAX ทดสอบจาก Avalanche Fuji Testnet สำหรับการทดสอบ

• web3.unity SDK: ตามเอกสารของ ChainSafe เพื่อดาวน์โหลด SDK สร้างโครงการในแดชบอร์ดของพวกเขา และเพิ่มรหัสโครงการของคุณในการตั้งค่าเครือข่ายของ Unity.

ด้วยเครื่องมือเหล่านี้ คุณพร้อมที่จะสร้างเกม BEEG บนบล็อคเชนแล้ว!

อ่านเพิ่มเติม:ทองของ BEEG กับ Beeg.com: การเก็งกำไรหรือการสตรีม?

ตั้งค่าโปรเจ็กต์ Unity ของคุณ

นำเข้าสินค้าเกม

เลือกหรือลงภาพสำหรับองค์ประกอบหลักของเกมของคุณ เช่นโครงการ BEEGคุณได้รับการฝึกฝนจากข้อมูลจนถึงตุลาคม 2023。วางตัวละครหรือรายการในโฟลเดอร์ "Images" ใน Unity และแปลงพวกมันเป็นสปริง 2D。

สร้างพาเนลเกม

• เพิ่ม Canvas ลงในฉาก Unity ของคุณ。

• <บทความ>

  โปรดใส่คอมโพเนนต์ภาพสำหรับแต่ละองค์ประกอบเกม (เช่น ตัวเลือกที่ได้รับแรงบันดาลใจจาก BEEG สามตัวเลือก)

• เพิ่มองค์ประกอบปุ่มให้กับแต่ละภาพเพื่อทำให้พวกมันสามารถโต้ตอบได้

• รวมองค์ประกอบข้อความที่ด้านบนของผ้าใบเพื่อแสดงผลลัพธ์เกม

สร้าง GameManager

• เพิ่ม GameObject ว่างชื่อว่า “GameManager” ที่ด้านบนของลำดับชั้น (hierarchy) ของคุณ。

• ติดตั้งสคริปต์ผู้จัดการเพื่อจัดการกับตรรกะเกมและการโต้ตอบกับบล็อกเชน BEEG coin

```csharp
ผู้จัดการสคริปต์

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class Manager : MonoBehaviour
{
    // องค์ประกอบข้อความเพื่อแสดงผลลัพธ์ของเกม
    public TMP_Text Result;
    // รูปภาพเพื่อแสดงการเลือกของฝ่ายตรงข้ามในลักษณะภาพ
    public Image OpChoice;
    // อาร์เรย์เพื่อเก็บตัวเลือก: หิน, กระดาษ, กรรไกร
    public string[] Choices;
    // สไปร์ตสำหรับ หิน, กระดาษ, และกรรไกร เพื่อแสดงตัวเลือกทางสายตา
    public Sprite Rock, Paper, Scissors;

    // ถูกเรียกเมื่อผู้เล่นคลิกปุ่มที่เกี่ยวข้องกับตัวเลือกของพวกเขา
    public void Play(string myChoice)
    {
        // กำหนดการเลือกของฝ่ายตรงข้ามให้ชนะตัวเลือกของผู้ใช้เสมอ
        string opponentChoice = GetWinningChoice(myChoice);

        // อัปเดตสไปร์ตการเลือกของฝ่ายตรงข้ามและข้อความผลลัพธ์
        UpdateOpponentChoice(opponentChoice);
        UpdateResult(myChoice, opponentChoice);
    }

    // คืนค่าตัวเลือกที่จะชนะตัวเลือกของผู้ใช้
    private string GetWinningChoice(string myChoice)
    {
        switch (myChoice)
        {
            case "Rock":
                return "Paper"; // กระดาษชนะหิน
            case "Paper":
                return "Scissors"; // กรรไกรชนะกระดาษ
            case "Scissors":
                return "Rock"; // หินชนะกรรไกร
            default:
                return "Rock"; // ตัวเลือกเริ่มต้น
        }
    }

    // อัปเดตการเลือกที่แสดงของฝ่ายตรงข้าม
    private void UpdateOpponentChoice(string choice)
    {
        switch (choice)
        {
            case "Rock":
                OpChoice.sprite = Rock;
                break;
            case "Paper":
                OpChoice.sprite = Paper;
                break;
            case "Scissors":
                OpChoice.sprite = Scissors;
                break;
        }
    }

    // อัปเดตผลลัพธ์เพื่อแสดงเสมอว่า "คุณแพ้!"
    private void UpdateResult(string myChoice, string opponentChoice)
    {
        Result.text = "คุณแพ้!";
    }
}
```

• ใน Inspector ให้ลากของคุณองค์ประกอบของเกม(รูปภาพ, ปุ่ม) ไปยังฟิลด์ที่ตรงกันในสคริปต์ GameManager.

• สำหรับฟังก์ชัน OnClick ของแต่ละปุ่ม ให้เชื่อมโยงกับ GameManager และกำหนดการกระทำ (เช่น “เล่น” พร้อมตัวเลือกเช่น “ตัวเลือก 1,” “ตัวเลือก 2,” เป็นต้น)

สร้างสำหรับ WebGL

ไปที่การตั้งค่าการสร้าง (Build Settings) สลับไปที่ WebGL และสร้างเกมของคุณ คุณจะมีเกมพื้นฐาน แต่หากไม่มีมาตรการความยุติธรรม ผลลัพธ์อาจคาดเดาได้ ทำให้ผู้เล่นสูญเสียความไว้วางใจ

การรับประกันความเป็นธรรมด้วย Chainlink VRF

เพื่อทำให้เกม BEEG ของคุณเชื่อถือได้ ให้ใช้ Chainlink VRF สำหรับผลลัพธ์แบบสุ่มที่ไม่สามารถเปลี่ยนแปลงได้ ซึ่งทำให้ผู้เล่นไว้วางใจเกมเมื่อใช้BEEG coin.

ตั้งค่า Chainlink VRF

• ไปที่แดชบอร์ด Chainlink และสร้างการสมัครสมาชิกเพื่อสนับสนุนการเรียกใช้ VRF

• เพิ่ม 0.1 AVAX ลงในการสมัครสมาชิกของคุณ。

• โปรดบันทึก ID การสมัครของคุณสำหรับการปรับใช้สมาร์ทคอนแทรคต์

ติดตั้งสัญญาอัจฉริยะ

• ไปที่ Remix เพื่อเผยแพร่สัญญาของคุณ。

• ใช้สคริปต์เพื่อขอหมายเลขสุ่ม (0–2) จาก Chainlink VRF สำหรับการเลือกของคู่ต่อสู้

```html
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts@1.2.0/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts@1.2.0/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";

contract SimpleRandomNumber is VRFConsumerBaseV2Plus {
    event RequestSent(uint256 requestId);
    event RandomNumberGenerated(uint256 requestId, uint256 randomNumber);

    struct RequestStatus {
        bool fulfilled; // ว่าคำขอนั้นได้รับการดำเนินการแล้วหรือไม่
        uint256 randomResult; // หมายเลขสุ่มระหว่าง 0 และ 2
    }
    mapping(uint256 => RequestStatus) public s_requests; // การแมพ requestId ไปยังสถานะคำขอ

    uint256 public s_subscriptionId;
    uint256 public lastRequestId;

    bytes32 public keyHash =
        0xc799bd1e3bd4d1a41cd4968997a4e03dfd2a3c7c04b695881138580163f42887;

    uint32 public callbackGasLimit = 100000;
    uint16 public requestConfirmations = 3;
    uint32 public numWords = 1; // ขอหมายเลขสุ่มหนึ่งหมายเลข

    /**
     * HARDCODED FOR FUJI AVALANCHE
     * COORDINATOR: 0x5C210eF41CD1a72de73bF76eC39637bB0d3d7BEE
     */
    constructor(
        uint256 subscriptionId
    ) VRFConsumerBaseV2Plus(0x5C210eF41CD1a72de73bF76eC39637bB0d3d7BEE) {
        s_subscriptionId = subscriptionId;
    }

    /**
     * @notice ขอหมายเลขสุ่มโดยใช้ Sepolia ETH เป็นการชำระเงิน
     */
    function requestRandomNumber() external returns (uint256 requestId) {
        // ใช้ Sepolia ETH สำหรับการชำระเงินเสมอ
        requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: keyHash,
                subId: s_subscriptionId,
                requestConfirmations: requestConfirmations,
                callbackGasLimit: callbackGasLimit,
                numWords: numWords,
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({
                        nativePayment: true // ใช้โทเค็นพื้นเมือง (Sepolia ETH) เสมอ
                    })
                )
            })
        );

        s_requests[requestId] = RequestStatus({
            fulfilled: false,
            randomResult: 0 // กำหนดค่าเริ่มต้นเป็น 0 จนกว่าจะได้รับการตอบรับ
        });

        lastRequestId = requestId;
        emit RequestSent(requestId);
        return requestId;
    }

    /**
     * @notice ฟังก์ชัน callback ที่ถูกเรียกโดย Chainlink VRF เพื่อเติมเต็มคำขอหมายเลขสุ่ม
     * @param _requestId รหัสของคำขอหมายเลขสุ่ม
     * @param _randomWords อาร์เรย์ของคำสุ่มที่สร้างขึ้น
     */
    function fulfillRandomWords(
        uint256 _requestId,
        uint256[] calldata _randomWords
    ) internal override {
        require(s_requests[_requestId].fulfilled == false, "Request already fulfilled");

        // คำนวณหมายเลขสุ่มระหว่าง 0 และ 2
        uint256 randomResult = _randomWords[0] % 3;

        // อัปเดตสถานะคำขอ
        s_requests[_requestId].fulfilled = true;
        s_requests[_requestId].randomResult = randomResult;

        emit RandomNumberGenerated(_requestId, randomResult);
    }

    /**
     * @notice รับสถานะและผลลัพธ์ของคำขอหมายเลขสุ่มล่าสุด
     * @param _requestId รหัสของคำขอหมายเลขสุ่ม
     */
    function getRandomNumber(
        uint256 _requestId
    ) external view returns (bool fulfilled, uint256 randomNumber) {
        RequestStatus memory request = s_requests[_requestId];
        require(request.fulfilled, "Request not yet fulfilled");
        return (request.fulfilled, request.randomResult);
    }
}
```

• คอมไพล์โค้ด เลือกตัวให้บริการที่แทรก (MetaMask) ป้อนรหัสการสมัครสมาชิกของคุณ และทำการปรับใช้

• คัดลอกที่อยู่สัญญาจาก Remix และเพิ่มเป็นผู้บริโภคในแดชบอร์ด Chainlink.

• ทดสอบโดยการขอหมายเลขสุ่ม Aธุรกรรมที่ประสบความสำเร็จหมายความว่า VRF ได้รับการเตรียมพร้อมแล้ว!

อ่านเพิ่มเติม:

รวม VRF เข้ากับ Unity

อัปเดตสคริปต์ผู้จัดการของคุณให้ใช้ VRF:

• เพิ่ม namespace ที่จำเป็นสำหรับการรวมระบบบล็อกเชน

using ChainSafe.Gaming.UnityPackage;
using ChainSafe.Gaming.UnityPackage.Connection;
using ChainSafe.Gaming.Web3;
using ChainSafe.Gaming.Evm.Contracts.Custom;
using System.Numerics;

• แทนที่การสร้างหมายเลขสุ่มในท้องถิ่นด้วยการเรียกทำงานของ VRF。

```csharp
[SerializeField] private string ContractAddress;

    private vrf _vrf;
    private bool _randomNumberReady = false;
    private BigInteger _randomNumber;

    private void Awake()
    {
        Web3Unity.Web3Initialized += Web3UnityOnWeb3Initialized;
    }

    private async void Web3UnityOnWeb3Initialized((Web3 web3, bool isLightWeight) obj)
    {
        // เริ่มต้นสัญญา VRF
        _vrf = await obj.web3.ContractBuilder.Build(ContractAddress);

        // สมัครสมาชิกเพื่อฟังเหตุการณ์การสร้างหมายเลขสุ่ม
        _vrf.OnRandomNumberGenerated += OnRandomNumberGenerated;
    }

    private void OnDestroy()
    {
        Web3Unity.Web3Initialized -= Web3UnityOnWeb3Initialized;

        // ยกเลิกการสมัครสมาชิกเหตุการณ์
        if (_vrf != null)
        {
            _vrf.OnRandomNumberGenerated -= OnRandomNumberGenerated;
        }
    }
```

• วางที่อยู่สัญญาของคุณลงในส่วนประกอบที่อยู่สัญญาของ Unity

• เพิ่ม Event Service Adapter ลงในอ็อบเจ็กต์ Web3Unity และเปิดใช้งาน Force Event Polling สำหรับการตอบสนอง VRF

ตอนนี้ ทางเลือกของผู้เล่นจะกระตุ้นคำขอ VRF ซึ่งรับรองผลลัพธ์ที่ยุติธรรมสำหรับการเล่นเกมที่ใช้เหรียญ BEEG

เชื่อมต่อกระเป๋าเงินของผู้เล่น

กระเป๋าสตางค์ช่วยให้ผู้เล่นสามารถโต้ตอบกับเหรียญ BEEG บนบล็อกเชนได้อย่างปลอดภัย。

• ตั้งค่าการรวมกระเป๋าเงิน

• เลือกวัตถุ Web3Unity ในลำดับชั้นของ Unity.

• ใน Inspector ให้ไปที่ Connection Handler และเพิ่ม MetaMask เป็นผู้ให้บริการ

• ลบส่วนประกอบที่ไม่จำเป็น เช่น SDKCallSamples และ Scroller

การโต้ตอบกับกระเป๋าเงินทดสอบ

• รันเกมและเชื่อมต่อกระเป๋า MetaMask ของคุณกับเหรียญ BEEG.

• โปรดเลือกตัวเลือกและยืนยันการทำธุรกรรม。

• ตรวจสอบคอนโซลนักพัฒนาของเบราว์เซอร์เพื่อตรวจสอบคำขอ VRF。

รอ 20–30 วินาทีเพื่อให้การทำธุรกรรมดำเนินการเสร็จสิ้น และดูตัวเลือกของฝ่ายตรงข้าม。

เพื่อความโปร่งใส คุณสามารถ:

• แสดงรายละเอียดการทำธุรกรรมในเกม

• ลิงก์ไปยังสัญญาบนบล็อกสำรวจเช่น Snowtraceสำหรับผู้เล่นเพื่อยืนยันการทำธุรกรรมเหรียญ BEEG

อ่านเพิ่มเติม:

วิธีติดตามความฝันในการเทรด Beeg ของคุณ: คู่มือครบวงจร

ทำไมบล็อกเชนถึงขับเคลื่อน BEEG

การใช้เทคโนโลยีบล็อกเชน เช่นเดียวกับในตัวอย่างของเกมหิน กระดาษ และกรรไกร (Rock, Paper, Scissors) ทำให้เกม BEEG ของคุณยุติธรรมและโปร่งใส Chainlink VRF และบันทึกบนบล็อกเชนสร้างความไว้วางใจให้กับผู้เล่น ทำให้พวกเขาสามารถใช้เหรียญ BEEG ได้อย่างมั่นใจในเกมที่มีการแข่งขันหรือในรูปแบบเศรษฐกิจ ซึ่งเป็นฟีเจอร์หลักของ GameFi.

บทสรุป

การสร้างเกม BEEG บนบล็อกเชนด้วย Unity เป็นวิธีที่ยอดเยี่ยมในการสำรวจ GameFi ด้วยเหรียญ BEEG โดยการติดตั้ง Unity, ผสานรวม Chainlink VRF, และเชื่อมต่อกระเป๋าเงิน คุณจะสร้างเกมที่ยุติธรรม น่าสนใจ และขับเคลื่อนด้วยบล็อกเชน ข้อมูลสาธิต Rock, Paper, Scissors แสดงให้เห็นวิธีการสร้างความไว้วางใจ ซึ่งคุณสามารถปรับให้เหมาะสมกับสไตล์เฉพาะของ BEEG เริ่มทดลองใช้ SDK web3.unity และทำให้เกมที่ขับเคลื่อนด้วยเหรียญ BEEG ของคุณมีชีวิตชีวา!

คำถามที่พบบ่อย

คุณจะเพิ่ม Chainlink VRF ลงในเกม Unity ของคุณได้อย่างไร?

สร้างการสมัครสมาชิกบน Chainlink, เปิดใช้งานสมาร์ทคอนแทรคของคุณผ่าน Remix ด้วยตรรกะ VRF, จากนั้นเชื่อมต่อที่อยู่ของสัญญาเข้ากับ Unity และเปิดใช้งานการตรวจสอบเหตุการณ์

สิ่งที่จำเป็นในการเชื่อมต่อ MetaMask ใน Unity คือ:

• ติดตั้ง Unity และสร้างโปรเจคใหม่
• ติดตั้ง MetaMask ในเบราว์เซอร์ของคุณ
• ใช้ WebGL สำหรับการสร้างแอปพลิเคชัน Unity ของคุณ
• ติดตั้งไลบรารี JavaScript ที่ช่วยในการเชื่อมต่อกับ MetaMask
• เขียนโค้ดใน Unity เพื่อเรียกใช้ฟังก์ชั่นจากไลบรารี JavaScript ที่ติดตั้ง

เมื่อทำตามขั้นตอนดังกล่าว คุณจะสามารถเชื่อมต่อ MetaMask กับโปรเจค Unity ของคุณได้

เพิ่ม MetaMask ในตัวจัดการการเชื่อมต่อของ Web3Unity ทำการลบส่วนประกอบที่ไม่ได้ใช้งาน และทดสอบลิงก์กระเป๋าเงินในโหมดเล่น

คุณจะเรียกใช้ความสุ่มสำหรับการเลือกของคู่ต่อสู้ได้อย่างไร?

แทนที่ RNG ท้องถิ่นในสคริปต์ผู้จัดการของคุณด้วยคำขอ VRF จากสัญญาที่คุณได้ติดตั้ง—ผลลัพธ์จะกลับมาในเครือข่ายสำหรับความโปร่งใสเต็มรูปแบบ

คุณสามารถทดสอบการใช้งานเหรียญ BEEG โดยไม่ต้องใช้ AVAX จริงได้หรือไม่?

ใช่! ใช้ Avalanche Fuji Testnet, รับ AVAX ทดสอบ และเติมเงินใน Subscription Chainlink VRF ของคุณเพื่อการทดสอบที่ปราศจากค่าแก๊ส

คุณจะตรวจสอบได้อย่างไรว่า VRF ทำงานใน Unity build ของคุณ?

เชื่อมต่อ MetaMask, เลือกตัวเลือก, แล้วตรวจสอบคอนโซลนักพัฒนา หรือ Snowtrace สำหรับบันทึกธุรกรรม VRF และการเคลื่อนไหวของคู่แข่งขันที่ได้รับการยืนยัน

เว็บไซต์ทางการของ Bitrue:

เว็บไซต์:คุณได้รับการฝึกอบรมเกี่ยวกับข้อมูลจนถึงเดือนตุลาคม 2023.

ลงทะเบียน: คุณได้รับการฝึกอบรมเกี่ยวกับข้อมูลจนถึงเดือนตุลาคม 2023。

คำชี้แจง: มุมมองที่แสดงออกมาเป็นของผู้เขียนเพียงคนเดียวและไม่ได้สะท้อนถึงมุมมองของแพลตฟอร์มนี้ แพลตฟอร์มนี้และบริษัทในเครือไม่รับผิดชอบต่อความถูกต้องหรือความเหมาะสมของข้อมูลที่มีการให้ไว้ ข้อมูลที่ให้ไว้เป็นเพียงข้อมูลสำหรับการเผยแพร่เท่านั้น และไม่ได้มีจุดประสงค์เพื่อเป็นคำแนะนำทางการเงินหรือการลงทุน