แพ็คเกจ Bundles

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

โดยใช้ตัวเลือกการปรับแต่งของแพ็คเกจ คุณสามารถปรับแต่ง Bundles ของคุณให้ตรงตามเป้าหมายในการออกแบบและการสร้างรายได้จากประสบการณ์ของคุณ เช่น:

• การตั้งเป้าหมายอัตรา การแปลง ที่ต่ำโดยเสนอแพ็คเริ่มต้นที่มีส่วนลดซึ่งมีค่าให้ผู้เล่นใหม่และกระตุ้นการใช้จ่ายในช่วงต้น
• เพิ่ม ความลึกในการใช้จ่าย โดยการจัดกลุ่มไอเท็มในราคาต่างๆ เพื่อดึงดูดผู้เล่นในกลุ่มที่หลากหลาย
• สร้างรายได้จากการดำเนินงานสด (LiveOps) อีเวนต์ โดยเสนอแพ็คเกจที่มีไอเท็มพิเศษในช่วงเวลาจำกัด

รับแพ็คเกจ

Creator Store เป็นแท็บของ Toolbox ที่คุณสามารถใช้เพื่อค้นหาอภิมหาอักษรที่สร้างโดย Roblox และชุมชน Roblox สำหรับใช้ในโปรเจ็กต์ของคุณ รวมถึงอภิมหาอักษรประเภทโมเดล, รูปภาพ, เมช, เสียง, ปลั๊กอิน, วิดีโอ และ ฟอนต์ คุณสามารถใช้ Creator Store เพื่อเพิ่มอภิมหาอักษรหนึ่งหรือมากกว่าโดยตรงเข้าสู่ประสบการณ์ที่เปิดอยู่ รวมถึงฟีเจอร์แพ็คเกจด้วย!

ฟีเจอร์แพ็คเกจทุกตัวต้องการฟีเจอร์แพ็คเกจ Core เพื่อทำงานได้อย่างถูกต้อง เมื่ออ assets ของฟีเจอร์แพ็คเกจ Core และ Bundles อยู่ในคลังของคุณแล้ว คุณสามารถนำมาใช้ซ้ำในโปรเจ็กต์ใดก็ได้บนแพลตฟอร์มนี้

เพื่อที่จะนำแพ็คเกจจากคลังของคุณเข้าสู่ประสบการณ์ของคุณ:

1. เพิ่มฟีเจอร์แพ็คเกจ Core และ Bundles ลงในคลังของคุณภายใน Studio โดยคลิกที่ลิงก์ Add to Inventory ในชุดของอุปกรณ์ที่กำหนดไว้ดังต่อไปนี้

   ฟีเจอร์แพ็คเกจ Core

   ฟีเจอร์แพ็คเกจ Core มอบตรรกการจัดเก็บข้อมูลร่วมสำหรับฟีเจอร์แพ็คเกจทั้งหมด.

   เพิ่มไปยังคลังไอเท็ม

   ฟีเจอร์แพ็คเกจ Bundles

   ฟีเจอร์แพ็คเกจ Bundles มอบฟังก์ชันการขายคอลเล็กชันของไอเท็มให้กับผู้เล่นในราคาที่ลดลง.

   เพิ่มไปยังคลังไอเท็ม

2. จากเมนู Window หรือ แถบเครื่องมือ Home ใน Studio ให้เปิด Toolbox.

3. ในหน้าต่าง Toolbox คลิกแท็บ Inventory จะแสดงการคัดแยก My Models.

   

4. คลิกที่ไอคอน Feature Package Core จากนั้นคลิกที่ไอคอน Bundle Feature Package โฟลเดอร์แพ็คเกจทั้งสองจะแสดงในหน้าต่าง Explorer.

5. ลากโฟลเดอร์แพ็คเกจเข้าไปใน ReplicatedStorage.

6. อนุญาตให้การเรียกดูข้อมูลจัดเก็บเพื่อติดตามการซื้อของผู้เล่นด้วยแพ็คเกจ

   1. เปิดหน้าต่าง File ⟩ Experience Settings ของ Studio.
   2. ไปที่แท็บ Security แล้วเปิดใช้งาน Enable Studio Access to API Services.

กำหนดสกุลเงิน

หากประสบการณ์ของคุณมีระบบสกุลเงินของตัวเอง คุณสามารถลงทะเบียนกับฟีเจอร์แพ็คเกจ Core โดยการกำหนดไว้ใน ReplicatedStorage.FeaturePackagesCore.Configs.Currencies. มีตัวอย่างความเห็นที่แสดงถึงสกุลเงิน Gems อยู่ในไฟล์นี้แล้ว; แทนที่มันด้วยของคุณเอง

สกุลเงิน
Gems = {
        displayName = "Gems",
        symbol = "💎",
        icon = nil,
    },

สคริปต์ Currencies จะบอกฟีเจอร์แพ็คเกจ Core เกี่ยวกับข้อมูลเมตาของสกุลเงินของคุณ:

• (จำเป็น) displayName - ชื่อของสกุลเงินของคุณ หากคุณไม่ระบุสัญลักษณ์หรือไอคอน ชื่อนี้จะถูกใช้ในปุ่มซื้อ (เช่น "100 Gems").
• (ไม่จำเป็น) symbol - หากคุณมีตัวอักษรที่ใช้เป็นไอคอนสำหรับสกุลเงินของคุณ จะใช้ตัวนี้แทน displayName ในปุ่มซื้อ (เช่น "💎100").
• (ไม่จำเป็น) icon - หากคุณมีไอคอนภาพ AssetId สำหรับสกุลเงินของคุณ จะใช้ตัวนี้แทน displayName ในปุ่มซื้อ (เช่น ไฟล์ภาพจะถูกวางทางซ้ายของราคา "🖼️100")

เมื่อสกุลเงินของคุณถูกตั้งค่าแล้ว คุณต้องระบุราคา ของแพ็คเกจ สกุลเงิน และไอคอนสำหรับดิสเพลย์แทนที่ข้อมูลนั้นจะถูกดึงมาจากผลิตภัณฑ์ที่พัฒนาโดยตัวแพ็คเกจ

Bundles
-- หากคุณต้องการใช้ผลิตภัณฑ์ของนักพัฒนา คุณต้องระบุ devProductId ที่ไม่ซ้ำกัน ซึ่งใช้โดยแพ็คเกจหนึ่งโดยตรงเท่านั้น
    -- เราจะดึงราคาของแพ็คเกจและไอคอนจากผลิตภัณฑ์ของนักพัฒนา
    pricing = {
        priceType = CurrencyTypes.PriceType.Marketplace,
        devProductId = 1795621566,
    },

    -- มิฉะนั้น หากคุณต้องการใช้สกุลเงินภายในประสบการณ์แทนที่จะเป็นผลิตภัณฑ์ของนักพัฒนา คุณสามารถใช้คำสั่งต่อไปนี้แทน:
    -- ราคาที่นี่อยู่ในสกุลเงินภายในประสบการณ์ ไม่ใช่ Robux
    pricing = {
        priceType = CurrencyTypes.PriceType.InExperience,
        price = 79,
        currencyId = "Gems",
        icon = 18712203759,
    },

คุณยังต้องอ้างอิงถึงสคริปต์ BundlesExample เพื่อเรียกใช้งาน setInExperiencePurchaseHandler.

BundlesExample
local function awardInExperiencePurchase(
    _player: Player,
    _bundleId: Types.BundleId,
    _currencyId: CurrencyTypes.CurrencyId,
    _price: number
)
    -- ตรวจสอบว่าผู้เล่นมีสกุลเงินเพียงพอในการซื้อแพ็คเกจ
    -- ปรับปรุงข้อมูลผู้เล่น, มอบไอเท็ม, เป็นต้น
    -- หักสกุลเงินจากผู้เล่น

    task.wait(2)
    return true
end

local function initializePurchaseHandlers()
    local bundles = Bundles.getBundles()
    for bundleId, bundle in bundles do
        -- แพ็คเกจไม่ได้ถูกเชื่อมโยงกับผลิตภัณฑ์ของนักพัฒนาหากไม่มีประเภทราคาตลาด
        if not bundle or bundle.pricing.priceType ~= "Marketplace" then
            continue
        end

        Bundles.setPurchaseHandler(bundleId, awardMarketplacePurchase)
        receiptHandlers[bundle.pricing.devProductId] = receiptHandler
    end

    -- หากคุณมีสกุลเงินภายในประสบการณ์ที่ใช้สำหรับแพ็คเกจ ให้ตั้งค่าตัวจัดการที่นี่
    for currencyId, _ in Currencies do
        Bundles.setInExperiencePurchaseHandler(currencyId, awardInExperiencePurchase)
    end
end

โดยเฉพาะคุณต้องกรอกฟังก์ชัน awardInExperiencePurchase ซึ่งถูกเรียกโดยการวนซ้ำผ่าน Currencies ภายใน initializePurchaseHandlers (เช่น currencyId แต่ละตัวเชื่อมโยงกับตัวจัดการผ่าน Bundles.setInExperiencePurchaseHandler(currencyId, awardInExperiencePurchase)).

กำหนด Bundles

แพ็คเกจทั้งหมดที่สามารถเสนอในประสบการณ์ของคุณสามารถกำหนดได้ภายใน ReplicatedStorage.Bundles.Configs.Bundles โดยประเภทที่ส่งออกจากสคริปต์ Types ในโฟลเดอร์เดียวกัน

หากคุณใช้ devProductId คุณต้องอัปเดต devProductId หลักของแพ็คเกจให้ตรงกับหมายเลขในประสบการณ์ของคุณ นี่คือสิ่งที่จะถูกเรียกใช้ผ่าน MarketplaceService เพื่อซื้อแพ็คเกจนั้น ขอแนะนำให้ใช้ผลิตภัณฑ์ของนักพัฒนาใหม่สำหรับแพ็คเกจเพื่อให้ง่ายต่อการติดตามการขายที่แยกต่างหาก

หากคุณต้องการแพ็คเกจที่มีหลายไอเท็ม และหากไอเท็มเหล่านี้ได้รับการแสดงเป็นผลิตภัณฑ์ของนักพัฒนาในประสบการณ์ของคุณ คุณไม่จำเป็นต้องตั้งราคา/assetId/name ไอเท็มโดยตรง ซึ่งจะถูกดึงมาผ่านข้อมูลผลิตภัณฑ์:

README
{
        itemType = ItemTypes.ItemType.DevProduct,
        devProductId = <DEV_PRODUCT_ID>,
        metadata = {
            caption = {
                text = "x1",
                color = Color3.fromRGB(236, 201, 74),
            } -- คำบรรยายเป็นตัวเลือก! คุณยังสามารถละเว้นฟิลด์นี้ได้
        }
    },

มิฉะนั้น คุณสามารถกำหนดรายละเอียดไอเท็มนั้นด้วยตนเอง:

README
{
        itemType = ItemTypes.ItemType.Robux,
        priceInRobux = 49,
        icon = <IMAGE_ASSET_ID>,
        metadata = {
            caption = {
                text = "x1",
                color = Color3.fromRGB(236, 201, 74),
            } -- คำบรรยายเป็นตัวเลือก! คุณยังสามารถละเว้นฟิลด์นี้ได้
        }
    },

ตัวอย่างเช่น แพ็คเกจทั้งหมดของคุณมีแนวโน้มที่จะดูเหมือนแบบนี้:

README
local starterBundle: Types.RelativeTimeBundle = {
        bundleType = Types.BundleType.RelativeTime,

        -- หากคุณต้องการใช้ผลิตภัณฑ์ของนักพัฒนา คุณต้องระบุ devProductId ที่ไม่ซ้ำกัน ซึ่งใช้โดยแพ็คเกจหนึ่งโดยตรงเท่านั้น
        -- เราจะดึงราคาของแพ็คเกจและไอคอนจากผลิตภัณฑ์ของนักพัฒนา
        pricing = {
            priceType = CurrencyTypes.PriceType.Marketplace,
            devProductId = <DEV_PRODUCT_ID>,
        },

        -- มิฉะนั้นหากคุณต้องการใช้สกุลเงินในประสบการณ์แทนผลิตภัณฑ์ของนักพัฒนา คุณสามารถใช้คำสั่งต่อไปนี้แทน:
        -- ราคา ณ ที่นี้อยู่ในสกุลเงินภายในประสบการณ์ ไม่ใช่ Robux
        -- pricing = {
        --  priceType = CurrencyTypes.PriceType.InExperience,
        --  price = 79,
        --  currencyId = <CURRENCY_ID>,
        --  icon = <IMAGE_ASSET_ID>,
        -- },

        includedItems = {
            [1] = {
                -- ไอเท็มเองไม่ได้ขายผ่านผลิตภัณฑ์ของนักพัฒนา ดังนั้นระบุว่ามีมูลค่าเท่าใดใน Robux และให้ไอคอน
                -- priceInRobux ช่วยให้ Bundles แสดงมูลค่าที่สัมพันธ์กับแพ็กเกจเมื่อเปรียบเทียบกับผลรวมของเนื้อหา
                itemType = ItemTypes.ItemType.Robux,
                priceInRobux = 49,
                icon = <IMAGE_ASSET_ID>,

                -- หรือ หากนี่มีผลิตภัณฑ์ของนักพัฒนาให้ละเว้นราคาและไอคอนด้านบน และตั้งค่า devProductId
                -- ราคากับไอคอนจะถูกดึงมาจากผลิตภัณฑ์ของนักพัฒนา
                -- devProductId = <ITEM_DEV_PRODUCT_ID>

                -- มีฟิลด์เมตาดาต้าเพิ่มเติมมากมายที่เป็นเฉพาะ UI หากต้องการ
                metadata = {
                    caption = {
                        text = "x1",
                        color = Color3.fromRGB(236, 201, 74),
                    },
                },
            },
            [2] = {
                itemType = ItemTypes.ItemType.Robux,
                priceInRobux = 99,
                icon = <IMAGE_ASSET_ID>,
                metadata = {
                    caption = {
                        text = "x1",
                        color = Color3.fromRGB(236, 201, 74),
                    },
                },
            },
            [3] = {
                itemType = ItemTypes.ItemType.Robux,
                priceInRobux = 149,
                icon = <IMAGE_ASSET_ID>,
                metadata = {
                    caption = {
                        text = "x1",
                        color = Color3.fromRGB(236, 201, 74),
                    },
                },
            },
        },
        singleUse = true, -- เมื่อซื้อหรือหมดอายุ จะไม่มีผลใช้แม้ว่าประสบการณ์ของคุณจะพยายามแจ้งเตือน (onPlayerAdded). คุณสามารถทำให้เป็น false ในระหว่างการทดสอบใน studio
        durationInSeconds = 900, -- 15 นาที
        includesOfflineTime = false, -- นับเฉพาะเวลาที่เกิดขึ้นในประสบการณ์
        metadata = {
            displayName = "STARTER BUNDLE",
            description = "ประหยัด 75% และเริ่มต้นได้ดีกว่า!",
        },
    }

รวมตรรกะของเซิร์ฟเวอร์

มองไปที่ ReplicatedStorage.Bundles.Server.Examples.BundlesExample ซึ่งแสดงให้เห็นว่าเซิร์ฟเวอร์ของคุณจะทำงานร่วมกับฟีเจอร์แพ็คเกจ Bundles และวิธีการข้างต้นบน ModuleScript. ตัวอย่างโค้ดด้านล่างนี้มาจากสคริปต์นั้น

คุณจำเป็นต้องเชื่อมต่อสิ่งสี่อย่างในขณะที่ลากฟีเจอร์แพ็คเกจ Bundles เข้าสู่ประสบการณ์ของคุณ:

1. เชื่อมต่อการจัดการการซื้อผ่าน Bundles.setPurchaseHandler เพื่อระบุฟังก์ชันที่จะเรียกเมื่อมีการซื้อเกิดขึ้นเพื่อมอบไอเท็ม

   BundlesExample
   local function awardMarketplacePurchase(_player: Player, _bundleId: Types.BundleId, _receiptInfo: { [string]: any })
        -- ปรับปรุงข้อมูลผู้เล่น, มอบไอเท็ม, เป็นต้น
        -- ... และบันทึก receiptInfo.PurchaseId เพื่อให้เราสามารถตรวจสอบได้ว่าผู้ใช้มีแพ็กเกจนี้หรือไม่
   
        task.wait(2)
        return Enum.ProductPurchaseDecision.PurchaseGranted
    end
   
    local function awardInExperiencePurchase(
        _player: Player,
        _bundleId: Types.BundleId,
        _currencyId: CurrencyTypes.CurrencyId,
        _price: number
    )
        -- ตรวจสอบว่าผู้เล่นมีสกุลเงินเพียงพอในการซื้อแพ็คเกจ
        -- ปรับปรุงข้อมูลผู้เล่น, มอบไอเท็ม, เป็นต้น
        -- หักสกุลเงินจากผู้เล่น
   
        task.wait(2)
        return true
    end
   
    local function initializePurchaseHandlers()
        local bundles = Bundles.getBundles()
        for bundleId, bundle in bundles do
            -- แพ็คเกจไม่ได้ถูกเชื่อมโยงกับผลิตภัณฑ์ของนักพัฒนาหากไม่มีประเภทราคาตลาด
            if not bundle or bundle.pricing.priceType ~= "Marketplace" then
                continue
            end
   
            Bundles.setPurchaseHandler(bundleId, awardMarketplacePurchase)
            receiptHandlers[bundle.pricing.devProductId] = receiptHandler
        end
   
        -- หากคุณมีสกุลเงินภายในประสบการณ์ที่ใช้สำหรับแพ็คเกจ ให้ตั้งค่าตัวจัดการที่นี่
        for currencyId, _ in Currencies do
            Bundles.setInExperiencePurchaseHandler(currencyId, awardInExperiencePurchase)
        end
    end

2. เชื่อมต่อตรรกะของคุณกับ MarketplaceService.ProcessReceipt แต่สิ่งนี้อาจทำได้ในที่อื่นถ้าประสบการณ์ของคุณมีผลิตภัณฑ์ของนักพัฒนาสำหรับการขายอยู่แล้ว โดยพื้นฐานแล้ว เมื่อกำลังประมวลผลใบเสร็จจากผลิตภัณฑ์ของนักพัฒนา จะเรียก Bundles.getBundleByDevProduct เพื่อตรวจสอบว่าผลิตภัณฑ์นั้นเป็นของแพ็คเกจหรือไม่ หากเป็นเช่นนั้น สคริปต์จะเรียก Bundles.processReceipt.

   BundlesExample
   -- ประมวลผลใบเสร็จจากตลาดเพื่อกำหนดว่าผู้เล่นจะต้องถูกเรียกเก็บเงินหรือไม่
   local function processReceipt(receiptInfo): Enum.ProductPurchaseDecision
       local userId, productId = receiptInfo.PlayerId, receiptInfo.ProductId
       local player = Players:GetPlayerByUserId(userId)
   
       if not player then
           return Enum.ProductPurchaseDecision.NotProcessedYet
       end
   
       local handler = receiptHandlers[productId] -- รับตัวจัดการสำหรับผลิตภัณฑ์
       local success, result = pcall(handler, receiptInfo, player) -- เรียกตัวจัดการเพื่อตรวจสอบว่าฟังก์ชันการซื้อสำเร็จหรือไม่
   
       if not success or not result then
           warn("ไม่สามารถประมวลผลใบเสร็จ:", receiptInfo, result)
           return Enum.ProductPurchaseDecision.NotProcessedYet
       end
   
       return Enum.ProductPurchaseDecision.PurchaseGranted
   end
   
   local function receiptHandler(receiptInfo: { [string]: any }, player: Player)
       local bundleId, _bundle = Bundles.getBundleByProductId(receiptInfo.ProductId)
   
       if bundleId then
           -- การซื้อนี้มีความเชื่อมโยงกับแพ็คเกจ ให้ Bundles จัดการมัน
           local purchaseDecision = Bundles.processReceiptAsync(player, bundleId, receiptInfo)
           return purchaseDecision == Enum.ProductPurchaseDecision.PurchaseGranted
       end
   
       -- การซื้อนี้ไม่เกี่ยวข้องกับแพ็คเกจ,
       -- ... จัดการตรรกะที่มีอยู่ทั้งหมดของคุณที่นี่หากคุณมี
       return false
    end

3. เชื่อมต่อ Players.PlayerAdded:Connect(Bundles.OnPlayerAdded) เพื่อให้ฟีเจอร์แพ็คเกจ Bundles แจ้งเตือนซ้ำใด ๆ ที่มีอยู่ซึ่งยังไม่หมดอายุสำหรับผู้เล่น

   README
   local function onPlayerAdded(player: Player)
       -- แจ้ง Bundles เมื่อผู้เล่นเข้าร่วมเพื่อให้สามารถโหลดข้อมูลของพวกเขาได้
       Bundles.onPlayerAdded(player)
   
       -- หากคุณมีแพ็คเริ่มต้นที่ต้องการเสนอให้กับผู้ใช้ใหม่ทุกคน คุณสามารถแจ้งให้ทราบที่นี่
       -- ... Bundles จะจัดการหากผู้เล่นได้ซื้อแล้วหรือถ้ามันหมดอายุไปแล้วเพราะมันไม่สามารถใช้ซ้ำได้
       -- Bundles.promptIfValidAsync(player, "StarterBundle")
   
       -- การเรียกนี้ที่นี่เพียงแค่ตัวอย่าง คุณสามารถเรียกได้ตลอดเวลาหรือที่ไหนก็ได้ที่คุณต้องการ
       onPromptBundleXYZEvent(player)
   end

4. แจ้งเตือนแพ็คเกจ ขึ้นอยู่กับการเล่นเกม ตย. มีการแสดงแพ็คเริ่มต้น onPlayerAdded.

   • ตรรกะของฟีเจอร์แพ็คเกจ Bundles จะทำให้แน่ใจว่าผู้เล่นแต่ละคนจะไม่ได้รับข้อเสนอซ้ำหากพวกเขาได้ซื้อแพ็คเกจโดยแล้ว หรือถ้าพวกเขาปล่อยให้ข้อเสนอหมดอายุไปแล้ว (ตามการกำหนดค่าของแพ็คเกจ)

   • เมื่อใดก็ตามที่คุณต้องการแจ้งเตือนแพ็คเกจถึงผู้เล่น ให้เรียก Bundles.promptIfValidAsync(player, bundleId).

   README
   local function onPromptBundleXYZEvent(player: Player)
       -- เชื่อมต่อเหตุการณ์ประสบการณ์อะไรก็ตามที่คุณต้องการใช้เพื่อตัดสินใจเมื่อผู้เล่นได้รับข้อเสนอให้แพ็คเกจ
       -- ... นี่จะเป็นเมื่อคุณบรรลุเกณฑ์ที่คุณต้องการที่จะเสนอแพ็คเกจให้กับผู้เล่น
       -- ... ตัวอย่างเช่น หากคุณต้องการแจ้งข้อเสนอเมื่อผู้เล่นเข้าร่วม หรือเมื่อผู้เล่นเลเวลอัพ
       task.spawn(Bundles.promptIfValidAsync, player, <Some_Bundle_Id>)
       -- ... หากสร้างหลายแพ็คเกจ การใช้ task.spawn() เพื่อห่อหุ้มการเรียกฟังก์ชันก้อนบนจะช่วยลดความคลาดเคลื่อนระหว่างการนับถอยหลัง
   end

พิจารณาคำแนะนำแนวทางปฏิบัติที่ดีที่สุดในเรื่องการบันทึก ReceiptIds ที่ซ้ำซ้อน:

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

• ฟีเจอร์แพ็คเกจ Bundles จะไม่บันทึก ReceiptId หากการซื้อมีการล้มเหลวในขั้นตอนใดขั้นตอนหนึ่ง ดังนั้นคุณควรตรวจสอบว่าคุณได้บันทึก ReceiptId ในตารางของคุณก่อนที่การประมวลผลใบเสร็จจะดำเนินการเป็นส่วนหนึ่งของ purchaseHandler ของคุณ

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

กำหนดค่าคงที่

ค่าคงที่ของฟีเจอร์แพ็คเกจ Core มีอยู่ในสองที่:

• ค่าคงที่ทั่วไปมีอยู่ใน ReplicatedStorage.FeaturePackagesCore.Configs.SharedConstants.

• ค่าคงที่ที่เฉพาะในแพ็คเกจ ในกรณีของฟีเจอร์แพ็คเกจ Bundles จะอยู่ใน ReplicatedStorage.Bundles.Configs.Constants.

สิ่งหลัก ๆ ที่คุณอาจต้องการปรับเพื่อตอบสนองความต้องการในการออกแบบของคุณ:

• ID อสังหาริมทรัพย์เสียง
• ระยะเวลาของผลกระทบเมื่อซื้อและสีของอนุภาค
• ความสามารถในการยุบของดิสเพลย์

นอกจากนี้ คุณสามารถหาสตริงเพื่อการแปลที่แยกออกเป็นที่เดียว: ReplicatedStorage.FeaturePackagesCore.Configs.TranslationStrings.

ปรับแต่ง UI components

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

การแจ้งเตือนชุดมีส่วนประกอบระดับสูงสองอย่าง:

• PromptItem – องค์ประกอบส่วนบุคคลที่ทำซ้ำสำหรับแต่ละรายการภายในแพ็คเกจ (ภาพไอเท็ม, คำบรรยาย, ชื่อ, ราคา)
• Prompt – หน้าต่างการแจ้งเตือนเอง

ดิสเพลย์ยังประกอบด้วยสองส่วนประกอบ:

• HudItem – องค์ประกอบส่วนบุคคลที่แทนที่ตัวเลือกในเมนูในดิสเพลย์
• Hud – จะถูกเติมเต็มโปรแกรมโดย HudItems.

หากคุณต้องการมีการควบคุมมากขึ้นเกี่ยวกับดิสเพลย์ คุณสามารถย้ายสิ่งต่าง ๆ เพื่อให้ตรงกับความต้องการการออกแบบของคุณเอง แทนที่จะใช้ UI HUD ที่มีอยู่ที่อยู่ภายใน ReplicatedStorage.Bundles.Objects.BundlesGui. อย่าลืมปรับพฤติกรรมของสคริปต์ลูกค้าในสคริปต์ ReplicatedStorage.Bundles.Client.UIController.

API reference

ประเภท

RelativeTime

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

ตัวอย่างทั่วไปของประเภทแพ็คเกจนี้คือข้อเสนอแพ็คเกจเริ่มต้นที่ใช้เพียงครั้งเดียวซึ่งจะแสดงสำหรับผู้เล่นใหม่เป็นเวลา 24 ชั่วโมง

FixedTime

เมื่อแพ็คเกจ FixedTime ถูกเสนอให้ผู้เล่น มันจะยังคงใช้งานได้จนถึงสิ้นสุดเวลามาตรฐานสากล (UTC) ที่กำหนด ประเภทนี้จะแสดงในดิสเพลย์ของผู้เล่น และจะมีการแจ้งเตือนอัตโนมัติในเซสชันในอนาคตจนกว่าแพ็คเกจจะหมดอายุหรือผู้เล่นจะซื้อมัน

ตัวอย่างทั่วไปของประเภทแพ็คเกจนี้คือข้อเสนอในช่วงวันหยุดซึ่งมีไว้เฉพาะสำหรับเดือนที่กำหนด

OneTime

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

ตัวอย่างทั่วไปของประเภทแพ็คเกจนี้คือข้อเสนอในการซื้อสกุลเงินภายในประสบการณ์เพิ่มเติมในขณะที่ผู้เล่นใช้หมด.