1. Epic GamesDeveloper
  3. Verse'te Kendi Oyun İçi Sıralamanı Oluşturma

Verse'te Kendi Oyun İçi Sıralamanı Oluşturma

Oyuncuların oyunlardaki istatistiklerini tutan bir oyun içi sıralama oluştur

Verse'te Kendi Oyun İçi Sıralamanı Oluşturma
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

Üst Öğe: learn-game-mechanics-in-unreal-editor-for-fortnite Order: Type: tutorial Tags: Verse Tags: Çok oyunculu Tags: Takım Tags: Harita Tags: Seçenek Tags: Oyun alanı Hero-image: leaderboards-hero.png Topic-image: leaderboards-topic.png Social-image: leaderboards-social.png Prereq: persistent-player-statistics-in-unreal-editor-for-fortnite

Bu eğitim, Kalıcı Oyuncu İstatistikleri bölümündeki kavramları temel aldığı için önce oraya bir göz at!

Sıralamalar rekabet oyunlarının başlıca unsurlarından biridir ve oyuncuların becerilerini sergilemesine ve adlarını duyurmasına olanak tanır. Sıralamalar oyuncuların bir ilerleme duygusu geliştirmesine yardımcı olur ve kendilerini zirveye tırmanırken görebilmeleri için oyuncuları sürekli olarak geri gelmeye teşvik eder.

Verse Sürekliliği, bu sıralamaları oluşturmana ve deneyimine rekabetçi bir boyut katmana olanak tanıyan araçlar sağlar. Kalıcı oyuncu istatistikleri eğitiminde, oyun oturumları arasında kalıcı hale getirilebilir verileri nasıl takip edebileceğini ve bu verileri farklı olaylara göre nasıl değiştirip güncelleyeceğini zaten görmüştün. Şimdi bu bilgileri uygulayarak tam yerel sıralamalar oluşturmayı, oyuncu istatistiklerini sıralamayı ve hepsini bir yarış oyununda bir araya getirmeyi öğreneceksin!

Kullanılan Verse Dili Özellikleri

  • Sınıf: Bu örnek, bir oyuncunun bir grup istatistiğini takip eden kalıcı hale getirilebilir bir Verse sınıfı oluşturur.

  • Oluşturucu: Oluşturucu, ilişkili olduğu sınıfın bir örneğini oluşturan özel bir fonksiyondur.

  • Weak_map: weak_map, üzerinde yineleme yapılamayan basit bir haritadır. Verse kalıcı verilerinin bir weak_map içinde saklanması gerekir.

Bölümü Ayarlama

Bu örnekte aşağıdaki nesne ve cihazlar kullanılır:

  • 3 adet Pano Cihazı: Bu cihazlar her bir oyuncunun yaşam süresi istatistiklerini gösterir ve bu istatistikleri, lobideki en iyi oyuncuları göstermek için yaşam süresi puanlarına göre sıralarsın.

  • 3 adet Oyuncu Referansı Cihazı: Pano cihazlarıyla birlikte kullanıldığında oyuncu referansları, en iyi performans gösteren oyuncularınızın adını öne çıkaracak, böylece diğer oyuncular oyun sırasında kimi gözetmeleri gerektiğini bilecek.

  • 3 adet Kontrol Noktası Cihazı: Bunlar oyuncuların yarışı tamamlamak için içinden hızlıca ilerlediği kontrol noktalarıdır.

  • 1 adet Yarış Yöneticisi Cihazı: Bu cihaz, oyuncuların yarışı ne zaman başlattığını ve bitirdiğini takip eder ve bitirme sırasına göre oyunculara puan ödülü verir.

  • 1 adet Malzeme Kamyonu Çıkma Yeri Cihazı: Bu cihaz, yarış sırasında kullanacağın aracı çıkarır ancak bunu deneyimine uygun herhangi bir araçla değiştirebilirsin.

Bölümünü ayarlamak için şu adımları izle:

Pano Cihazları ve Oyuncu Referansları

Oyuncu istatistiklerini göstermek için pano ve oyuncu referansı cihazlarının bir kombinasyonunu kullanacaksın. Her pano bir oyuncunun yaşam süresi istatistiklerini gösterirken oyuncu referansı o oyuncunun görsel bir temsilini gösterir. Bu öğeleri eklemek için aşağıdaki adımları izle:

  1. Bölümüne üç Oyuncu Referansı cihazı ekle ve bunları yan yana yerleştir.

  2. Her oyuncu referansı için Anahat Düzenleyicisi’nde seçim yap. Ayrıntılar panelindeki Kullanıcı Seçenekleri altında Özel Renk ayarını lobide birinci, ikinci ve üçüncü en iyi performansı gösteren oyuncuları göstermesini istediğin renkle değiştir. Bu örnekte altın, gümüş ve bronz renkleri kullanılıyor.

    Oyuncu Referansları

  3. Bölümüne üç Pano cihazı ekle ve her bir oyuncu referansının önüne bir tane yerleştir. Oyun başladığında Verse kullanarak bunları her bir oyuncunun istatistikleriyle güncelleyeceksin.

Kontrol Noktaları, Malzeme Kamyonu ve Yarış Yöneticisi

Bu bir yarış olduğu için yarışacağın bir şeyler olmalı! Ayrıca içinden geçeceğin kontrol noktaları ve oyun sırasında yarışı yönlendirecek bir yarış yöneticisine ihtiyacın olacak. Bu öğeleri eklemek için aşağıdaki adımları izle:

  1. Bölümüne üç Yarış Kontrol Noktası cihazı ekle. Bu cihazları, oyuncuların içinden geçmesini istediğin sırayla yerleştir. Her kontrol noktası için Anahat Düzenleyicisi’nde Kontrol Noktası Numarası’nın, oyuncuların kontrol noktaları arasından geçiş sırasıyla eşleştiğinden emin ol.

    Kontrol Noktası Ayarı

  2. Bölümüne bir Yarış Yöneticisi cihazı ekle. Bu cihaz, yarışı yürütecek ve oyuncuları kontrol noktalarına yönlendirecek. Daha sonra bu cihazdan RaceCompletedEvent() olayını dinleyerek bir oyuncunun yarışı ne zaman bitirdiğini öğreneceksin.

  3. Bölümüne bir Malzeme Kamyonu Çıkma Yeri cihazı ekle. Araç kullanmak isteğe bağlıdır ancak bu kılavuzda Pist Yarışı Şablonu’na uyacak bir malzeme kamyonu kullanılır ve oyunculara sürecekleri bir araç verilir.

İstatistikler Sekmende Değişiklik Yapma

Bu örnekte Kalıcı Oyuncu İstatistikleri bölümündeki player_stats_table dosyasının değiştirilmiş bir versiyonu kullanılıyor. Bu dosyanın görünümü o örnekteki dosyaya benzer ancak uygulamayı değiştiren bazı önemli farklılıkları vardır.

Oyuncu istatistikleri tablonu oluşturmak için aşağıdaki adımları izle:

  1. player_stats_table sınıfında:

    1. Losses istatistiğini kaldır.

    2. Score istatistiğini Points ile değiştir.

     # Her oyuncu için farklı kalıcı istatistikleri izler.
 player_stats_table<public>:= class<final><persistable>:

     # Geçerli istatistik tablosunun sürümü.
     Version<public>:int = 0

     # Bir oyuncunun puanları.
     Points<public>:int = 0

     # Bir oyuncu için Galibiyet sayısı.
     Wins<public>:int = 0

  2. Güncellenmiş istatistikleri yansıtmak için dosyandaki MakePlayerStatsTable() oluşturucu fonksiyonunu değiştir.

     # Önceki player_stats_table ile aynı değerlere sahip yeni bir player_stats_table oluşturur.
 MakePlayerStatsTable<constructor>(OldTable:player_stats_table)<transacts> := player_stats_table:
     Version := OldTable.Version
     Points := OldTable.Points
     Wins := OldTable.Wins

  3. player_stats_table.verse dosyana player_and_stats adlı yeni bir yapı ekle. Bu yapı bir player ve onun player_stats_table sınıfının referansını içerir ve her iki veriyi de tekrar tekrar almaya gerek kalmadan fonksiyonlarda kullanmana olanak tanır. Tamamlanmış player_and_stats yapın şu şekilde görünmelidir:

     # Bir oyuncuyu ve istatistiklerini bağımsız değişken olarak iletmek için yapı.
 player_and_stats<public> := struct:
     Player<public>:player
     StatsTable<public>:player_stats_table

İstatistikleri Yönetme

Tıpkı Kalıcı Oyuncu İstatistikleri eğitiminde olduğu gibi oyuncular için istatistik değişikliklerini yönetmek ve kaydetmek için bir yönetici dosyası kullanacaksın.

Değiştirdiğin player_stats_manager dosyasını derlemek için aşağıdaki adımları izle.

  1. InitializeAllPlayers() ve InitializePlayer() fonksiyon imzasını InitializeAllPlayerStats() ve InitializePlayerStat() olarak değiştir. Bu adlar, GetPlayerStat() fonksiyonuyla ilişkiyi daha iyi yansıtır. Güncellenmiş fonksiyonun şu şekilde görünmelidir:

     # Mevcut tüm oyuncular için istatistikleri başlat.
 InitializeAllPlayerStats<public>(Players:[]player):void =
     for (Player : Players):
         InitializePlayerStat(Player)

 # Belirtilen oyuncu için istatistikleri başlat.
 InitializePlayerStat<public>(Player:player):void=
     if:
         not PlayerStatsMap[Player]
         set PlayerStatsMap[Player] = player_stats_table{}
     else:
         Print("Oyuncu istatistikleri başlatılamıyor")

  2. AddScore() fonksiyon imzasını AddPoints() olarak değiştir. player_stats_table tablon artık bu değeri içermediğinden AddLoses() fonksiyonunu kaldır. Tamamlanmış player_stats_manager dosyan şu şekilde görünmelidir:

     # Bu dosya, her oyuncu için player_stats_tables’ı başlatan, güncelleyen ve döndüren
 # kodu yönetir. Ayrıca istatistikleri güncellemek için kullanılacak soyut bir stat_type sınıfı ve
 # istatistikleri görüntülerken kullanılacak StatType modülünü tanımlar.

 using { /Fortnite.com/Devices }
 using { /Verse.org/Simulation }
 using { /UnrealEngine.com/Temporary/Diagnostics }

 # Belirtilen aracı için player_stats_table’ı döndür.
 GetPlayerStats<public>(Agent:agent)<decides><transacts>:player_stats_table=
     var PlayerStats:player_stats_table = player_stats_table{}
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         set PlayerStats = MakePlayerStatsTable(PlayerStatsTable)
     PlayerStats

 # Mevcut tüm oyuncular için istatistikleri başlat.
 InitializeAllPlayerStats<public>(Players:[]player):void =
     for (Player : Players):
         InitializePlayerStat(Player)

 # Belirtilen oyuncu için istatistikleri başlat.
 InitializePlayerStat<public>(Player:player):void=
     if:
         not PlayerStatsMap[Player]
         set PlayerStatsMap[Player] = player_stats_table{}
     else:
         Print("Oyuncu istatistikleri başlatılamıyor")

 # Belirtilen aracının skoruna ekler ve her iki istatistik tablosunu da günceller
 # istatistikler tablosunu hem de bölümdeki panoyu günceller.
 AddPoints<public>(Agent:agent, NewPoints:int):void=
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         CurrentPoints := PlayerStatsTable.Points
         set PlayerStatsMap[Player] = player_stats_table:
             MakePlayerStatsTable<constructor>(PlayerStatsTable)
             Points := CurrentPoints + NewPoints
     else:
         Print("Oyuncu puanları kaydedilemiyor")

 # Belirtilen aracının galibiyetlerine ekler ve her iki istatistik tablosunu da günceller
 # istatistikler tablosunu hem de bölümdeki panoyu günceller.
 AddWin<public>(Agent:agent,  NewWins:int):void=
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         CurrentWins := PlayerStatsTable.Wins
         set PlayerStatsMap[Player] = player_stats_table:
             MakePlayerStatsTable<constructor>(PlayerStatsTable)
             Wins := CurrentWins + NewWins
     else:
         Print("Oyuncu galibiyetleri kaydedilemiyor")

Oyuncu Sıralamaları Oluşturma

Sıralamalarında oyuncu verilerini göstermek için birkaç şeye ihtiyacın olacak. Panolardaki metni ve oyuncu referansı cihazlarındaki oyuncuları güncellemenin bir yolunu bulmalısın. Ayrıca, en iyi oyuncuların sıralamanda en önde olmasını istediğin için bu cihazları sıralaman gerekir. Bu fonksiyonlar bölümdeki cihazları değiştirme gibi benzer bir hedefe sahip olduğundan fonksiyonları ortak bir dosyada gruplandırmak iyi bir fikirdir.

Bölüm içinde cihazlarını güncelleyen fonksiyonlar oluşturmak için aşağıdaki adımları izle:

  1. player_leaderboards.verse adlı yeni bir Verse dosyası oluştur. Bu dosya, bölüm içinde sıralamalarını güncellerken ortak kullanılan fonksiyonları depolar.

  2. Panodaki metin için bağımsız değişkenler geçirebileceğin bir mesaj kullanacaksın. CurrentPlayer, Points ve Wins, tüm message türlerini alan ve bir message olarak birleştirilmiş metin döndüren StatsMessage adlı yeni bir mesaj oluştur.

     # İstatistik panosunda gösterilecek mesaj.
 StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message=
     "{CurrentPlayer}:\n{Points}\n{Wins}"

  3. Her biri StatsMessage mesajına girdi ekleyen üç tane daha message değişkeni ekle. PlayerText mesajı bir Agent alır, PointsText mesajı bu aracının puanlarını alır ve WinsText mesajı bu aracının galibiyetlerini alır. StatsMessage, verilerini bölümde anlaşılır bir şekilde göstermek için bunların tümünden bir mesaj oluşturur.

     # İstatistik panosunda gösterilecek mesaj.
 StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message=
     "{CurrentPlayer}:\n{Points}\n{Wins}"
 PlayerText<localizes>(CurrentPlayer:agent):message = "Oyuncu {CurrentPlayer}"
 PointsText<localizes>(Points:int):message = "Toplam Puan {Points}"
 WinsText<localizes>(Wins:int):message = "{Wins} Toplam Galibiyet"

  4. Bir panoyu güncellemek için Oyuncu Kalıcı İstatistikleri eğitimindeki UpdateStatsBillboard() fonksiyonunu çağıracaksın. Bu fonksiyon, Verse cihazından ayrı bir dosyada tanımlandığı için hangi panoyu güncelleyeceğini belirtmek üzere ilave bir bağımsız değişken olarak bir StatsBillboard eklemen gerekir.

     # Belirtilen oyuncunun istatistiklerini görüntülemek için belirtilen pano cihazını günceller.
 UpdateStatsBillboard<public>(Player:agent, StatsBillboard:billboard_device):void=

  5. Öncelikle GetPlayerStats[] kullanarak bağımsız değişken olarak geçirilen oyuncu istatistiklerini al. Artık ayrı bir sınıf olmadığı için bir player_stats_manager referansına ihtiyacın yok. Sonra oyuncuyu ve CurrentPlayerStats fonksiyonundan Points ve Wins değerlerini kullanarak yeni bir StatsMessage oluştur. Son olarak bölüm içinde panoyu güncellemek için StatsBillboard üzerinde SetText() çağrısı yap. Tamamladığın UpdateStatsBillboard() fonksiyonu şunun gibi görünmelidir:

     # Belirtilen oyuncunun istatistiklerini görüntülemek için belirtilen pano cihazını günceller.
 UpdateStatsBillboard<public>(Player:agent, StatsBillboard:billboard_device):void=
     if:
         CurrentPlayerStats := GetPlayerStats[Player]
     then:
         PlayerStatsText := StatsMessage(
             PlayerText(Player),
             PointsText(CurrentPlayerStats.Points),
             WinsText(CurrentPlayerStats.Wins))
         StatsBillboard.SetText(PlayerStatsText)

Oyuncuları Sıralama ve En İyi Oyuncuyu Gösterme

Devam etmeden önce bu panoları nasıl sıralayacağını düşünmelisin. En fazla puana sahip oyuncu mu en üstte gösterilsin yoksa en çok galibiyet alan oyuncu mu? Farklı istatistiklere göre sıralamak istersen ne olacak? Bunları yönetmek için bir metoda ihtiyacın var; bu metot bir sıralama algoritmasıdır. Bir sıralama algoritması ve karşılaştırma fonksiyonu kullanarak hangi kriterlere göre sıralayacağını belirtebilirsin. Daha sonra panolarını ve oyuncu referanslarını sıralayarak deneyimindeki en iyi oyuncuları gösterebilirsin. Bu örnekte Birleştirme Sıralaması algoritması kullanılıyor ancak sen istediğini uygulamakta özgürsün.

Panolarına karşılaştırma ve sıralama ekleyerek bölümündeki cihazları güncellemek için aşağıdaki adımları izle.

  1. player_stats_table dosyana geri dönüp her istatistiğin için karşılaştırma fonksiyonları tanımlayacaksın. Bunların her biri bir Left ve Right player_and_stats yapısı alır ve onları belirli bir istatistiğe göre karşılaştırır. Bu fonksiyonlar <decides><transacts> değiştiricilerine sahiptir, dolayısıyla karşılaştırma başarısız olursa fonksiyon da başarısız olur. Örneğin, Left değerinin Right değerinden küçük olup olmadığını bildirir. **player_stats_table.verse** dosyana MorePointsComparison() adlı yeni bir fonksiyon ekle. Bu fonksiyon, Left.Points değerinin Right.Points değerinden büyük olup olmadığını kontrol eder ve büyük değilse başarısız olur. Başarılı olursa Left değerini döndürür.

     # Solun puanı Sağdan büyükse Left (Sol) döndürür.
 MorePointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:Left=
     Left.StatsTable.Points > Right.StatsTable.Points
     Sol

  2. Bu fonksiyonu, biri daha düşük puan karşılaştırması için, ikisi galibiyet karşılaştırması için olmak üzere üç kez kopyala. Karşılaştırma fonksiyonların şu şekilde görünmelidir:

     # Solun puanı Sağdan büyükse Left (Sol) döndürür.
 MorePointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
     Left.StatsTable.Points > Right.StatsTable.Points
     Sol

 # Solun puanı Sağdan küçükse Left (Sol) döndürür.
 LessPointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
     Left.StatsTable.Points < Right.StatsTable.Points
     Sol

 # Solun Podyum sayısı Sağdan büyükse Left (Sol) döndürür.
 MorePodiumsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
     Left.StatsTable.Points > Right.StatsTable.Points
     Sol

 # Solun Podyum sayısı Sağdan küçükse Left (Sol) döndürür.
 LessPodiumsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
     Left.StatsTable.Points < Right.StatsTable.Points
     Sol

  3. Birleştirme Sıralaması algoritmasını ekle. Bu algoritmayı ayrı bir dosyaya veya modüle yerleştirebilir ve sağlanan test dosyası üzerinde test edebilirsin.

  4. player_leaderboards’a geri dönüp UpdateStatsBillboards() adlı yeni bir fonksiyon ekle. Bu fonksiyon bir aracılar (oyuncu veya AI) dizisi ve bir pano dizisi alır, bunları sıralar ve bölümdeki her panoyu güncellemek için UpdateStatsBillboard() çağrısı yapar.

     # İstatistik panolarını her oyuncunun sahip olduğu yaşam boyu puan miktarına göre
 # sıralayarak güncelle.
 UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=

  5. UpdateStatsBillboards() fonksiyonu içinde PlayerAndStatsArray adında yeni bir player_and_stats dizi değişkeni başlat. Bunu, bir for ifadesinin sonucuna eşit olacak şekilde ayarla. Bu for ifadesinde, her agent için, o agent için olan player'ı al ve GetPlayerStats[] kullanılarak oyuncunun player_stats_table tablosunu getir. Ardından player ve onun istatistik tablosundan oluşturulmuş player_and_stats yapısını döndür.

     UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=
     var PlayerAndStatsArray:[]player_and_stats =
         for:
             Agent:Players
             Player := player[Agent]
             PlayerStats := GetPlayerStats[Player]
         do:
             player_and_stats:
                 Player := Player
                 StatsTable := PlayerStats

  6. PlayerAndStatsArray dizini sıralamak için, diziyi ve MorePointsComparison fonksiyonunu ileten MergeSort() çağrısının sonucuna göre yeni bir SortedPlayersAndStats değişkeni başlat. Bir for ifadesi içinde sıralamayı yaptıktan sonra, eleman dizinini PlayerIndex değişkeninde depolayarak SortedPlayerAndStats içindeki her elemanı yinele. PlayerIndex'i kullanarak StatsBillboards dizisi içine dizinle, ardından güncellenecek oyuncu ve panoyu ileterek UpdateStatsBillboard çağrısı yap. Tamamlanmış UpdateStatsBillboards() fonksiyonun şu şekilde görünmeli:

     # İstatistik panolarını her oyuncunun sahip olduğu yaşam boyu puan miktarına göre
 # sıralayarak güncelle.
 UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=
     var PlayerAndStatsArray:[]player_and_stats =
         for:
             Agent:Players
             Player := player[Agent]
             PlayerStats := GetPlayerStats[Player]
         do:
             player_and_stats:
                 Player := Player
                 StatsTable := PlayerStats

     # Oyuncuları, lobideki “En İyi” oyuncuyu belirleyen genel ölçüt olan toplam
     # puanlarına göre karşılaştırıp sırala. Burada karşılaştırma fonksiyonunu, deneyiminin ihtiyaçlarına
     # uyacak şekilde değiştirebilirsin.
     SortedPlayersAndStats := SortingAlgorithms.MergeSort(
         PlayerAndStatsArray,
         MorePointsComparison)
     for:
         PlayerIndex -> PlayerAndStats : SortedPlayersAndStats
         StatsBillboard := StatsBillboards[PlayerIndex]
     do:
         UpdateStatsBillboard(PlayerAndStats.Player, StatsBillboard)

  7. Oyuncu referanslarını güncellemek için UpdatePlayerReferences() adında buna benzer bir fonksiyon kullanacaksın. Bu fonksiyon panolar yerine player_reference_device dizisini alır ve sonda UpdateStatsBillboard() çağrısı yerine her oyuncu için oyuncu referansı cihazında Register() çağrısı yapar. Yukarıdaki değişiklikleri yaparak UpdateStatsBillboard() kodunu yeni bir UpdatePlayerReferences() fonksiyonuna kopyala. Tamamlanmış UpdatePlayerReferences() fonksiyonun şu şekilde görünmeli:

     # Oyuncu referansı cihazlarını her oyuncunun sahip olduğu yaşam boyu puan
 # miktarına göre sıralayarak güncelle.
 UpdatePlayerReferences<public>(Players:[]player, PlayerReferences:[]player_reference_device):void=
     var PlayerAndStatsArray:[]player_and_stats =
         for:
             Agent:Players
             Player := player[Agent]
             PlayerStats := GetPlayerStats[Player]
         do:
             player_and_stats:
                 Player := Player
                 StatsTable := PlayerStats
    
     # Oyuncuları, lobideki “En İyi” oyuncuyu belirleyen genel ölçüt olan toplam
     # puanlarına göre karşılaştırıp sırala. Burada karşılaştırma fonksiyonunu, deneyiminin ihtiyaçlarına
     # uyacak şekilde değiştirebilirsin.
     SortedPlayersAndStats := SortingAlgorithms.MergeSort(
         PlayerAndStatsArray,
         MorePointsComparison)
    
     for:
         PlayerIndex -> PlayerAndStats : SortedPlayersAndStats
         PlayerReference := PlayerReferences[PlayerIndex]
     do:
         PlayerReference.Register(PlayerAndStats.Player)

Bölümündeki Oyuncu Sıralamaları

Her şey hazır olduğuna göre, şimdi oyuncularını sahneye almanın zamanı geldi! Oyuncuların butonla etkileşime girdiklerinde puan kazanmalarını sağlayacak bir cihaz oluşturup oyuncu referanslarını ve panolarını en iyi oyuncuların önde ve ortada yer alacağı şekilde sıralayacaksın. Bölümünde oyuncu sıralamalarını test edecek bir Verse cihazı oluşturmak için aşağıdaki adımları izle:

  1. player_leaderboards_example adlı yeni bir Verse cihazı oluştur. Buna ilişkin adımlar için Verse Kullanarak Kendi Cihazını Oluştur bölümüne bakabilirsin.

  2. player_leaderboards_example class tanımının üst kısmına aşağıdaki alanları ekle:

    • PlayerReferences adlı düzenlenebilir bir Oyuncu Referansı cihazları dizisi. Bunlar, yarıştaki her oyuncunun görsel gösterimini sağlar.

        # Her oyuncunun görsel gösterimi.
  @editable
  PlayerReferences:[]player_reference_device = array{}

    • Leaderboards adlı düzenlenebilir bir Pano cihazları dizisi. Bunlar, bölümdeki bir panoda her bir oyuncunun istatistiklerini gösterir.

        # Her bir oyuncunun istatistiklerini gösteren panolar.
  @editable
  Leaderboards:[]billboard_device = array{}

    • RaceManager adlı düzenlenebilir bir Yarış Yöneticisi cihazı. Yarış Yöneticisi ile olaylara bağlanacak ve bir oyuncu yarışı bitirdiğinde haber alacaksın.

        # Oyuncuların yarışı ne zaman tamamladığını takip eder ve ilk sırada gelen oyuncu galibiyeti kazanır.
  @editable
  RaceManager:race_manager_device = race_manager_device{}

    • PlacementRequiredForWin adlı düzenlenebilir bir tamsayı. Bu, bir oyuncunun galibiyeti kazanabilmesi için yerleşmesi gereken sıradır.

        # Oyuncunun galibiyeti kazanabilmesi için yerleştiği sıranın buna eşit veya bundan küçük olması gerekir.
  @editable
  PlacementRequiredForWin:int = 1

    • PointsPerPlace adlı düzenlenebilir bir tamsayı dizisi. Bunlar, her oyuncunun yerleştiği sıraya göre kazandığı puan sayılarıdır.

        # Her yerleşilen sırada oyuncunun kazandığı puan sayısı.
  # Bunu, oyuncularına yerleştikleri sıraya göre istediğin miktarda puan
  # verecek şekilde ayarla.
  @editable
  PointsPerPlace:[]int = array{5, 3, 1}

    • CurrentFinishOrder adlı bir tamsayı değişkeni. Bu, yarışı yeni tamamlayan son oyuncunun yerleştiği sıradır.

        # Yarışı yeni bitiren oyuncunun yeri.
  # Yarışı bitiren ilk üç oyuncu bir galibiyet ödülü alacak.
  var CurrentFinishOrder:int = 0

Yerleşilen Sıraya Dayalı Puan Ödülleri

Bir oyuncu yarışı bitirdiğinde, istatistiklerini yerleştiği sırasına göre güncellemek istiyorsun. İyi bir sıraya yerleşen oyuncular daha fazla puan almalı, en iyi sıraya yerleşen oyuncularsa galibiyeti kazanmalı.

Yarışı bitiren oyunculara puan ödülü vermek için şu adımları takip et:

  1. Bunu yönetmek için player_leaderboards_example sınıf tanımına RecordPlayerFinish() adlı yeni bir fonksiyon ekle. Bu fonksiyon, puan ödülü verilecek oyuncuyu parametre olarak alır.

     # Bir oyuncu yarışı bitirdiğinde yerleştiği sırasına göre puan ödülü ver ve
 # yerleştiği sıra PlacementRequiredForWin değerinden iyiyse galibiyet ödülü ver.
 RecordPlayerFinish(Player:agent):void=

  2. RecordPlayerFinish() fonksiyonu içinde, geçerli CurrentFinishOrder değerini PlayerFinishOrder adlı yeni bir int ile alarak bu oyuncunun yerleştiği sırayı al. Ardından, bir sonraki bitiren oyuncunun aynı yere yerleşmemesi için CurrentFinishOrder değerini bir arttır.

     RecordPlayerFinish(Player:agent):void=
     PlayerFinishOrder:int = CurrentFinishOrder
     set CurrentFinishOrder += 1

  3. Şimdi sıra, puan ödüllerini vermeye geldi. Bu oyuncuya kaç puan verileceğini bilmek için, bir if ifadesinde PlayerFinishOrder kullanılarak PointsPerPlace dizisi içine dizinle. Ardından, o oyuncuya belirtilen miktarda puan vermek için AddPoints() fonksiyonunu çağır.

     set CurrentFinishOrder += 1
     if:
         PointsToAward := PointsPerPlace[PlayerFinishOrder]
     then:
         AddPoints(Player, PointsToAward)

  4. Oyuncunun yerleştiği sıra, galibiyeti kazanmaya yetecek kadar yüksekse istatistik tablosuna bir galibiyet kaydetmen gerekir. Başka bir if ifadesinde, PlayerFinishOrder değerinin PlacementRequiredToWin değerinden küçük olup olmadığını kontrol et. Küçükse oyuncuyu ve ona verilecek galibiyeti ileterek AddWin() fonksiyonunu çağır. Tamamlanmış RecordPlayerFinish() fonksiyonun şu şekilde görünmeli:

     # Bir oyuncu yarışı bitirdiğinde yerleştiği sırasına göre puan ödülü ver ve
 # yerleştiği sıra PlacementRequiredForWin değerinden iyiyse galibiyet ödülü ver.
 RecordPlayerFinish(Player:agent):void=
     PlayerFinishOrder:int = CurrentFinishOrder
     set CurrentFinishOrder += 1
     if:
         PointsToAward := PointsPerPlace[PlayerFinishOrder]
     then:
         AddPoints(Player, PointsToAward)

         # Oyuncunun bitirme sırası PlacementRequiredToWin değerinden küçük veya buna eşitse
         # galibiyetle ödüllendir ve bunu oyuncunun player_stats_table’ına kaydet.
         if:
             PlayerFinishOrder < PlacementRequiredForWin
         then:
             AddWin(Player, 1)

Oyuncuların Yarışı Bitirmesini Bekleme

Artık istatistik kaydın hazır olduğuna göre, bir oyuncu yarışı bitirdiğinde bunu öğrenmen ve oyuncunun istatistiklerini güncellemen gerekiyor. Bunu yapmak için yarış yöneticisinin RaceCompletedEvent() fonksiyonunu dinleyeceksin. Bu olay, herhangi bir oyuncu yarışı bitirdiğinde tetiklenir, dolayısıyla bunu bir asenkron fonksiyon içinde sürekli olarak dinlemen gerekir.

  1. player_leaderboards_example sınıf tanımına WaitForPlayerToFinishRace() adlı yeni bir fonksiyon ekle. Bu fonksiyon, bir oyuncuyu alır ve onun yarışı bitirmesini bekler.

     # Bir oyuncu yarışı bitirdiğinde istatistik tablosuna bir bitirme kaydet.
 WaitForPlayerToFinishRace(Player:agent)<suspends>:void=

  2. WaitForPlayerToFinishRace() fonksiyonu içinde, bir race ifadesinde iki döngü başlat. Bu döngülerden ilki oyuncunun yarışı bitirmesini bekleyecek, diğeriyse bir oyuncunun yarışı bitirmeden oturumdan ayrılması durumunda ne olacağını yönetecek. Bir oyuncu oyundan ayrıldığında döngünün sonsuza kadar devam etmesini istemeyiz, bu nedenle böyle bir durumda döngüden çıkmanın bir yolu olması gerekir.

     # Bir oyuncu yarışı bitirdiğinde istatistik tablosuna bir bitirme kaydet.
 WaitForPlayerToFinishRace(Player:agent)<suspends>:void=
     race:
         # Bu oyuncunun yarışı bitirmesini ve ardından bitirme kaydını yapmayı bekleme.
         loop:
         # Bu oyuncunun oyundan ayrılmasını bekliyor.
         loop:

  3. Birinci döngüde, RaceManager.RaceCompletedEvent olayını bekle ve sonucu FinishingPlayer adlı bir değişkende depola. Bu olay herhangi bir oyuncu yarışı bitirdiğinde tetiklendiğinden, kaydettiğin oyuncunun takip ettiğin oyuncu olduğundan emin olman gerekir. Bunun için FinishingPlayer değerini bu döngünün izlediği oyuncuyla karşılaştır. İki değer eşitse oyuncuyu RecordPlayerFinish() fonksiyonuna ilet ve döngüden çık.

     # Bu oyuncunun yarışı bitirmesini ve ardından bitirme kaydını yapmayı bekleme.
 loop:
     FinishingPlayer := RaceManager.RaceCompletedEvent.Await()
     if:
         FinishingPlayer = Player
     then:
         RecordPlayerFinish(Player)
         break

  4. İkinci döngüde PlayerRemovedEvent() oyun alanı olayını bekle. Öncekinde olduğu gibi, oyundan az önce ayrılan oyuncuyu al ve LeavingPlayer değişkeninde depola. Az önce ayrılan oyuncu bu döngünün beklediği oyuncuysa döngüden çık. Tamamlanmış WaitForPlayerToFinishRace() fonksiyonun şu şekilde görünmeli:

     # Bir oyuncu yarışı bitirdiğinde istatistik tablosuna bir bitirme kaydet.
 WaitForPlayerToFinishRace(Player:agent)<suspends>:void=
     race:
         # Bu oyuncunun yarışı bitirmesini ve ardından bitirme kaydını yapmayı bekleme.
         loop:
             FinishingPlayer := RaceManager.RaceCompletedEvent.Await()
             if:
                 FinishingPlayer = Player
             then:
                 RecordPlayerFinish(Player)
                 break

         # Bu oyuncunun oyundan ayrılmasını bekliyor.
         loop:
             LeavingPlayer := GetPlayspace().PlayerRemovedEvent().Await()
             if:
                 LeavingPlayer = Player
             then:
                 break

Tümünü Birbirine Bağlama

Fonksiyonlarını ayarladığına göre şimdi sıra bunları cihazlarına bağlayıp yarışa başlamaya geldi!

Mantığını cihazlarına bağlamak için şu adımları takip et:

  1. OnBegin() içinde, GetPlayers() fonksiyonunu kullanarak oyun alanındaki tüm oyuncuları al. Her oyuncunun player_stats_tables’ını ayarlamak için bu diziyi InitializeAllPlayerStats() fonksiyonuna geçir.

     # Cihaz, çalışmakta olan bir oyunda başlatıldığında çalışır
 OnBegin<override>()<suspends>:void=
     # Mevcut yarıştaki oyuncuları al ve her biri için bir player_stat_table
     # oluştur.
     Players := GetPlayspace().GetPlayers()
     InitializeAllPlayerStats(Players)

  2. Bölüm içi panoları her oyuncunun geçerli verileriyle güncellemek için Players ve Leaderboards dizilerini ileterek UpdateStatsBillboards() çağrısı yap. Ardından, bölüm içi referansları oyuncularla eşleşecek şekilde güncellemek için UpdatePlayerReferences() fonksiyonunu çağır. Son olarak, bir for ifadesinde, her oyuncu için bir WaitForPlayerToFinishRace() fonksiyonu oluştur. Tamamlanmış OnBegin() fonksiyonun şu şekilde görünmeli:

     # Cihaz, çalışmakta olan bir oyunda başlatıldığında çalışır
 OnBegin<override>()<suspends>:void=
     # Mevcut yarıştaki oyuncuları al ve her biri için bir player_stat_table
     # oluştur.
     Players := GetPlayspace().GetPlayers()
     InitializeAllPlayerStats(Players)
     UpdateStatsBillboards(Players, Leaderboards)
     UpdatePlayerReferences(Players, PlayerReferences)

     # Tüm oyuncuların yarışı bitirmesini bekle.
     for:
         Player:Players
     do:

         spawn{WaitForPlayerToFinishRace(Player)}

  3. Kodunu kaydet ve onu derle.

player_leaderboards_example cihazını bölümüne sürükle. Oyuncu referanslarını PlayerReferences dizisine atayıp sıranın kaydını tut. İlk dizindeki cihaz, en iyi oyuncunun oyuncu referansına, ikinci dizin ikinci en iyi oyuncunun oyuncu referansına vb. karşılık gelmelidir. Sıralamalar için de aynı şeyi yap; bunların oyuncu referansı cihazlarıyla uyumlu olduğundan emin ol. Yarış Yöneticisi cihazını da atamayı unutma!

Oyuncu Sıralamaları Cihazı Ayarları

Kalıcı Sıralamalarını Test Etme

Kalıcı verilerini bir editör oturumunda test edebilirsin ancak oturumu kapatıp yeniden başlattığında bu veriler sıfırlanır. Verilerinin oturumlar arasında kalıcı olmasını sağlamak için bir oynanış testi oturumu başlatman ve Ada Ayarları içindeki belirli ayarları değiştirmen gerekir. Kalıcı verileri hem editör hem de oynanış testi oturumlarında test etmek üzere adanı ayarlamayla ilgili bilgi almak için Kalıcı Verilerle Test Etme bölümünü incele ve Ada Ayarlarında belirli ayarları değiştir. Kalıcı verileri hem editör hem de oynanış testi oturumlarında test etmek üzere adanı ayarlamayla ilgili bilgi almak için Kalıcı Verilerle Test Etme bölümünü incele.

Oturumunu ayarladıktan sonra, bölümünü test ettiğinde yarışı bitiren oyunculara yerleştikleri sıraya göre puan verilmeli. Oyuncular, yerleştikleri sıra yeterince yüksekse galibiyetle ödüllendirilmeli ve bu istatistikler oyun oturumları arasında kalıcı olmalı. Oyuncular ve istatistikleri sıralanmalı, en fazla puanı olan oyuncu ilk sırada görünmeli.

Lobide sıralamalar

Kendi Kendine Yapabileceklerin

Bu kılavuzu tamamlayarak, bölümündeki oyuncuların kalıcı istatistiklerini gösteren sıralamaları nasıl oluşturacağını öğrendin. Ayrıca bu sıralamaların, en iyi oyuncuların kim olduğunu herkesin bilmesini sağlamak üzere nasıl sıralanacağını ve güncelleneceğini de öğrendin. Bu eğitimi kendi deneyimlerine uyarlamaya çalış ve en iyiden de iyisini ortaya çıkar!

Tam Kod

player_stats_table.verse

    # Bu dosya, kalıcı oyuncu istatistikleri koleksiyonu olan bir player_stats_table tanımlar.
    # Ayrıca, sıralama yaparken oyuncuları sıralamak için her istatistiğe göre istatistik tablolarını karşılaştırmaya yönelik
    # fonksiyonlar da içerir.

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation }
    using { /UnrealEngine.com/Temporary/Diagnostics }

    # Bir oyuncuyu ve istatistiklerini bağımsız değişken olarak iletmek için yapı.
    player_and_stats<public> := struct:
        Player<public>:player
        StatsTable<public>:player_stats_table

    # Her oyuncu için farklı kalıcı istatistikleri izler.
    player_stats_table<public>:= class<final><persistable>:

        # Geçerli istatistik tablosunun sürümü.
        Version<public>:int = 0

        # Bir oyuncunun puanları.
        Points<public>:int = 0

        # Bir oyuncu için Galibiyet sayısı.
        Wins<public>:int = 0

    # Solun puanı Sağdan büyükse Left (Sol) döndürür.
    MorePointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
        Left.StatsTable.Points > Right.StatsTable.Points
        Sol

    # Solun puanı Sağdan küçükse Left (Sol) döndürür.
    LessPointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
        Left.StatsTable.Points < Right.StatsTable.Points
        Sol

    # Solun Galibiyet sayısı Sağdan büyükse Left (Sol) döndürür.
    MoreWinsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
        Left.StatsTable.Points > Right.StatsTable.Points
        Sol

    # Solun Galibiyet sayısı Sağdan küçükse Left (Sol) döndürür.
    LessWinsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
        Left.StatsTable.Points < Right.StatsTable.Points
        Sol

    # Solun BestLapTime süresi Sağdan yavaşsa Left (Sol) döndürür.
    # Diğer istatistiklerden farklı olarak, daha küçük tur süresinin daha iyi olduğunu unutma.
    SlowerLapTimeComparison(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
        Left.StatsTable.Points > Right.StatsTable.Points
        Sol

    # Solun BestLapTime süresi Sağdan hızlıysa Left (Sol) döndürür.
    # Diğer istatistiklerden farklı olarak, daha küçük tur süresinin daha iyi olduğunu unutma.
    FasterLapTimeComparison(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
        Left.StatsTable.Points < Right.StatsTable.Points
        Sol

    # Önceki player_stats_table ile aynı değerlere sahip yeni bir player_stats_table oluşturur.
    MakePlayerStatsTable<constructor>(OldTable:player_stats_table)<transacts> := player_stats_table:
        Version := OldTable.Version
        Points := OldTable.Points
        Wins := OldTable.Wins

    # Oyuncuları, oyuncu istatistiklerinin bir tablosuyla eşleştirir.
    var PlayerStatsMap:weak_map(player, player_stats_table) = map{}

player_leaderboards.verse

    # Bu dosya, oyuncunun istatistiklerini görüntülemek için panoları, oyuncu referanslarını ve adadaki kullanıcı arayüzünü
    # oyuncu istatistikleri tablosundan güncelleyen kodu içerir. # Ayrıca galibiyetlerin ve puanların oyuncunun istatistik tablosuna
    # eklenmesini de yönetir.

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation}
    using { PlayerStatistics }

    # İstatistik panosunda gösterilecek mesaj.
    StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message=
        "{CurrentPlayer}:\n{Points}\n{Wins}"
    PlayerText<localizes>(CurrentPlayer:agent):message = "Oyuncu {CurrentPlayer}"
    PointsText<localizes>(Points:int):message = "Toplam Puan {Points}"
    WinsText<localizes>(Wins:int):message = "{Wins} Toplam Galibiyet"

    # Belirtilen oyuncunun istatistiklerini görüntülemek için belirtilen pano cihazını günceller.
    UpdateStatsBillboard<public>(Player:agent, StatsBillboard:billboard_device):void=
        if:
            CurrentPlayerStats := GetPlayerStats[Player]
        then:
            PlayerStatsText := StatsMessage(
                PlayerText(Player),
                PointsText(CurrentPlayerStats.Points),
                WinsText(CurrentPlayerStats.Wins))
            StatsBillboard.SetText(PlayerStatsText)

    # İstatistik panolarını her oyuncunun sahip olduğu yaşam boyu puan miktarına göre
    # sıralayarak güncelle.
    UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=
        var PlayerAndStatsArray:[]player_and_stats =
            for:
                Agent:Players
                Player := player[Agent]
                PlayerStats := GetPlayerStats[Player]
            do:
                player_and_stats:
                    Player := Player
                    StatsTable := PlayerStats

        # Oyuncuları, lobideki “En İyi” oyuncuyu belirleyen genel ölçüt olan toplam
        # puanlarına göre karşılaştırıp sırala. Burada karşılaştırma fonksiyonunu, deneyiminin ihtiyaçlarına
        # uyacak şekilde değiştirebilirsin.
        SortedPlayersAndStats := SortingAlgorithms.MergeSort(
            MorePointsComparison,    
            PlayerAndStatsArray)
        for:
            PlayerIndex -> PlayerAndStats : SortedPlayersAndStats
            StatsBillboard := StatsBillboards[PlayerIndex]
        do:
            UpdateStatsBillboard(PlayerAndStats.Player, StatsBillboard)

    # Oyuncu referansı cihazlarını her oyuncunun sahip olduğu yaşam boyu puan
    # miktarına göre sıralayarak güncelle.
    UpdatePlayerReferences<public>(Players:[]player, PlayerReferences:[]player_reference_device):void=
        var PlayerAndStatsArray:[]player_and_stats =
            for:
                Agent:Players
                Player := player[Agent]
                PlayerStats := GetPlayerStats[Player]
            do:
                player_and_stats:
                    Player := Player
                    StatsTable := PlayerStats

        # Oyuncuları, lobideki “En İyi” oyuncuyu belirleyen genel ölçüt olan toplam
        # puanlarına göre karşılaştırıp sırala. Burada karşılaştırma fonksiyonunu, deneyiminin ihtiyaçlarına
        # uyacak şekilde değiştirebilirsin.
        SortedPlayersAndStats := SortingAlgorithms.MergeSort(
            MorePointsComparison,    
            PlayerAndStatsArray)

        for:
            PlayerIndex -> PlayerAndStats : SortedPlayersAndStats
            PlayerReference := PlayerReferences[PlayerIndex]
        do:
            PlayerReference.Register(PlayerAndStats.Player)

player_stats_manager.verse

    # Bu dosya, her oyuncu için player_stats_tables’ı başlatan, güncelleyen ve döndüren
    # kodu yönetir. Ayrıca istatistikleri güncellemek için kullanılacak soyut bir stat_type sınıfı ve
    # istatistikleri görüntülerken kullanılacak StatType modülünü tanımlar.

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation }
    using { /UnrealEngine.com/Temporary/Diagnostics }

    # Belirtilen aracı için player_stats_table’ı döndür.
    GetPlayerStats<public>(Agent:agent)<decides><transacts>:player_stats_table=
        var PlayerStats:player_stats_table = player_stats_table{}
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            set PlayerStats = MakePlayerStatsTable(PlayerStatsTable)
        PlayerStats

    # Mevcut tüm oyuncular için istatistikleri başlat.
    InitializeAllPlayerStats<public>(Players:[]player):void =
        for (Player : Players):
            InitializePlayerStat(Player)

    # Belirtilen oyuncu için istatistikleri başlat.
    InitializePlayerStat<public>(Player:player):void=
        if:
            not PlayerStatsMap[Player]
            set PlayerStatsMap[Player] = player_stats_table{}
        else:
            Print("Oyuncu istatistikleri başlatılamıyor")

    # Belirtilen Aracının StatToAdd öğesine ekler ve hem PlayerStatsManager’daki
    # istatistikler tablosunu hem de bölümdeki panoyu günceller.
    AddPoints<public>(Agent:agent, NewPoints:int):void=
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            CurrentPoints := PlayerStatsTable.Points
            set PlayerStatsMap[Player] = player_stats_table:
                MakePlayerStatsTable<constructor>(PlayerStatsTable)
                Points := CurrentPoints + NewPoints
        else:
            Print("Oyuncu puanları kaydedilemiyor")

    # Belirtilen Aracının StatToAdd öğesine ekler ve hem PlayerStatsManager’daki
    # istatistikler tablosunu hem de bölümdeki panoyu günceller.
    AddWin<public>(Agent:agent,  NewWins:int):void=
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            CurrentWins := PlayerStatsTable.Wins
            set PlayerStatsMap[Player] = player_stats_table:
                MakePlayerStatsTable<constructor>(PlayerStatsTable)
                Wins := CurrentWins + NewWins
        else:
            Print("Oyuncu galibiyetleri kaydedilemiyor")

player_leaderboards_example.verse

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation }
    using { /UnrealEngine.com/Temporary/Diagnostics }
    using { PlayerStatistics }
    using { PlayerLeaderboard }

    # Verse cihazı oluşturma hakkında bilgi edinmek için bkz. https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse.

    # Bir bölüme yerleştirilebilen, Verse ile yazılmış bir Kreatif cihazı
    player_leaderboards_example := class(creative_device):
        # Her oyuncunun görsel gösterimi.
        @editable
        PlayerReferences:[]player_reference_device = array{}

        # Her bir oyuncunun istatistiklerini gösteren panolar.
        @editable
        Leaderboards:[]billboard_device = array{}

        # Oyuncuların yarışı ne zaman tamamladığını takip eder ve ilk sırada gelen oyuncu galibiyeti kazanır.
        @editable
        RaceManager:race_manager_device = race_manager_device{}

        # Oyuncunun galibiyeti kazanabilmesi için yerleştiği sıranın buna eşit veya bundan küçük olması gerekir.
        @editable
        PlacementRequiredForWin:int = 1

        # Her yerleşilen sırada oyuncunun kazandığı puan sayısı.
        # Bunu, oyuncularına yerleştikleri sıraya göre istediğin miktarda puan
        # verecek şekilde ayarla.
        @editable
        PointsPerPlace:[]int = array{5, 3, 1}

        # Yarışı yeni bitiren oyuncunun yeri.
        # Yarışı bitiren ilk üç oyuncu bir galibiyet ödülü alacak.
        var CurrentFinishOrder:int = 0

        # Cihaz, çalışmakta olan bir oyunda başlatıldığında çalışır
        OnBegin<override>()<suspends>:void=
            # Mevcut yarıştaki oyuncuları al ve her biri için bir player_stat_table
            # oluştur.
            Players := GetPlayspace().GetPlayers()
            InitializeAllPlayerStats(Players)
            UpdateStatsBillboards(Players, Leaderboards)
            UpdatePlayerReferences(Players, PlayerReferences)

            # Tüm oyuncuların yarışı bitirmesini bekle.
            for:
                Player:Players
            do:
                spawn{WaitForPlayerToFinishRace(Player)}

        # Bir oyuncu yarışı bitirdiğinde istatistik tablosuna bir bitirme kaydet.
        WaitForPlayerToFinishRace(Player:agent)<suspends>:void=
            race:
                # Bu oyuncunun yarışı bitirmesini ve ardından bitirme kaydını yapmayı bekleme.
                loop:
                    FinishingPlayer := RaceManager.RaceCompletedEvent.Await()
                    if:
                        FinishingPlayer = Player
                    then:
                        RecordPlayerFinish(Player)
                        break

                # Bu oyuncunun oyundan ayrılmasını bekliyor.
                loop:
                    LeavingPlayer := GetPlayspace().PlayerRemovedEvent().Await()
                    if:
                        LeavingPlayer = Player
                    then:
                        break

        # Bir oyuncu yarışı bitirdiğinde yerleştiği sırasına göre puan ödülü ver ve
        # yerleştiği sıra PlacementRequiredForWin değerinden iyiyse galibiyet ödülü ver.
        RecordPlayerFinish(Player:agent):void=
            PlayerFinishOrder:int = CurrentFinishOrder
            set CurrentFinishOrder += 1

            if:
                PointsToAward := PointsPerPlace[PlayerFinishOrder]
            then:
                AddPoints(Player, PointsToAward)

                # Oyuncunun bitirme sırası PlacementRequiredToWin değerinden küçük veya buna eşitse
                # galibiyetle ödüllendir ve bunu oyuncunun player_stats_table’ına kaydet.
                if:
                    PlayerFinishOrder < PlacementRequiredForWin
                then:
                    AddWin(Player, 1)

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page