1. Epic GamesDeveloper
  3. Çok Oyunculu Takım Dengeleme

Çok Oyunculu Takım Dengeleme

Çalışma zamanında ve bir oyuncu oyuna katıldığında Verse kullanarak takımları dengele.

Çok Oyunculu Takım Dengeleme

Üst Öğe: learn-game-mechanics-in-unreal-editor-for-fortnite Order: Type: tutorial Tags: Verse Tags: Çok oyunculu Tags: Takım Tags: Seçenek Tags: Oyun alanı Hero-image: BannerImage.png Topic-image: TopicImage.png Social-image: SocialMedia.png Prereq:

Çok oyunculu oyunlarda oyuncu takımları bir hedefe ulaşmak için rekabet eder ya da işbirliği yapar. Her takımdaki oyuncu sayısı, oynanışı çarpıcı biçimde etkileyebilir ve birçok geliştirici, eğlenceli deneyimler yaratmak için belirli oyuncu oranlarını seçer.

Takım dengeleme, belirli bir orana uyarak oyuncuları takımlara ayırır. Çoğu çok oyunculu oyun, hiçbir takımın avantajlı olmaması için takımları eşit olacak şekilde dengeler. Bazı oyunlar, aşırı güçlü bir oyuncunun karşısına dört oyuncu koymak gibi dengesiz senaryoları kasıtlı olarak oluşturur. Kurulumdan bağımsız olarak takım dengesi, birden fazla oyuncu takımı için ilgi çekici deneyimler yaratmanın ayrılmaz bir parçasıdır.

Sürmekte Olan Oyuna Katılma

Bu kılavuzu tamamlayarak çalışma zamanında ve oyuna yeni bir oyuncunun katıldığı her durumda oyuncu takımlarını dinamik olarak dengelemeyi öğreneceksin. Tam kod, referans olması için bu kılavuzun sonuna eklenmiştir.

Kullanılan Verse Dili Özellikleri

  • array: Bu cihaz her takımın bir referansını depolamak için dizileri kullanır.

  • option: Bu cihaz, oyuncunun bulunduğu takımdan daha az oyuncuya sahip bir takım olup olmadığını belirlemek için seçenekleri kullanır.

  • for: for ifadesi ile cihazın kullandığı dizileri yineleyebilirsin.

  • if: if ifadesi, oyuncuların takım boyutlarına göre yeni bir takıma geçmesinin gerekli olup olmadığını kontrol etmek için kullanılır.

  • failure: Hata bağlamları, dizilere erişmek ve programın akışını kontrol etmek için kullanılır.

Kullanılan Verse API’ları

  • Abone Olunabilir: Sürmekte olan bir oyuna yeni bir oyuncu katıldığında takımları dinamik olarak yeniden dengelemek için PlayerAddedEvent() olayına abone olursun.

  • Takımlar: Takım sınıfı takımlara oyuncu ekler, takımlardan oyuncu kaldırır ve alır.7 Bu eğitimde oyuncuları ve takım görevlerini doğrudan yönlendirmek için takım sınıfını kullanacaksın.

  • Oyun Alanı: Oyun alanı, oyuna katılan ve oyundan ayrılan oyuncularla ilgili abone olunabilir olayları takip eder. Aynı zamanda oyuncu ve takımların listelerini alır ve belirli bir oyuncunun takımını bulur. Bu eğitimde birden fazla oyun alanı olayına abone olacak, doğrudan yönetebilmek için oyuncuları ve takımları oyun alanı yöntemlerini kullanarak alacaksın.

Bölümü Ayarlama

Bu örnekte aşağıdaki cihaz kullanılıyor.

4 adet Oyuncu Doğma Karesi cihazı: Bu cihaz, oyuncunun oyun başlangıcında nerede doğacağını belirler.

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

  1. Seviyeye bir oyuncu doğma karesi ekle.

  2. Anahat düzenleyiciden doğma karesini seç ve ayrıntılar panelini aç.

  3. Ayrıntılar panelindeki Kullanıcı Seçenekleri altında:

    • Oyuncu Takımı’nı 1 değerine sahip Takım Dizini olarak ayarla

    • Oyunda Görünür seçeneğini etkinleştir

    Büyütmek için görsele tıkla.

  4. Doğma karesini kopyala ve ilk doğma karesinin yanına yerleştir.

  5. Her iki doğma karesini de çoğalt ve ilk doğma kareleri grubundan uzakta bir yere yerleştir. 2. takımın oyuncularının burada doğar.

  6. Çoğaltılan doğma karelerini seç ve ayrıntılar panelindeki kullanıcı seçenekleri bölümünün altından her iki doğma karesinin takım dizini değerini 2 olarak değiştir.

  7. Anahat Düzenleyici'de Ada Ayarları Cihazını seçerek Ayrıntılar panelini aç. Kullanıcı Seçenekleri - Oyun Kuralları altında:

    • Takımlar'ı, değeri 2 olan Takım Dizini olarak ayarla. Bu örnekte iki takım kullanılıyor ancak dilediğin sayıda takımın olabilir.

    • Takım Boyutu'nu Dinamik olarak ayarla. Bu ayarla Verse kodun takım dengeleme işini devralabilir.

    • Oyun devam ederken yeni oyuncuların oyuna katılabilmesi için Sürmekte Olan Oyuna Katılma değerini Doğma olarak ayarla.

    Büyütmek için görsele tıkla.

  8. Verse Gezgini kullanarak team_multiplayer_balancing adlı yeni bir Verse cihazı oluştur ve bunu bölüme sürükle. (Verse’te yeni bir cihazın nasıl oluşturulacağını öğrenmek için Verse Kullanarak Kendi Cihazını Yarat bölümüne bakabilirsin.)

Bölümün şu kuruluma benzer şekilde görünmelidir:

Tamamlanan Bölüm Kurulumu

Takımları Eşit Olarak Ayırma

Oyun Başlangıcında Takımları Dengeleme

Bu adımda oyun başlangıcında ve oyuna yeni bir oyuncu katıldığında oyuncuların takımlara nasıl eşit olarak ayrılacağı gösteriliyor.

  1. Verse Gezgini menüsünü aç ve team_multiplayer_balancing.verse bölümüne çift tıklayarak kodu Visual Studio Code ile aç.

  2. team_multiplayer_balancing sınıf tanımında oyuncuların bulunduğu her bir takımda referansları depolayacak Teams adlı bir değişken team dizisi ekle.

     team_multiplayer_balance := class(creative_device):
     # GetTeams() ile bulunan takımları barındırır 
     var Teams : []team = array{}

  3. OnBegin() fonksiyonunda Teams dizisini daha önce ada ayarları menüsünde ayarlanan takımlarla eşleşecek şekilde güncelle. Oyun alanındaki tüm takımları almak için fort_team_collection API’ından GetTeams() fonksiyonunu çağır.

     OnBegin<override>()<suspends>:void=
     Print("Verse Device Started!")
     set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()

  4. GetPlayers() fonksiyonunu çağırarak oyundaki tüm oyuncuları bul ve AllPlayers adlı bir oyuncu dizisine kaydet.

     OnBegin<override>()<suspends>:void=
     Print("Verse Device Started!")
     set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()
     AllPlayers := GetPlayspace().GetPlayers()

  5. Tüm oyuncuların listesini yinele ve aynı sayıda oyuncuya sahip takımlar oluştur. Bir oyuncunun o anda bulunduğu takımı başka bir takımla karşılaştırıp oyuncu için en uygun takım olup olmadığını belirleyebilirsin. Bu durumda GetTeam[] fonksiyonunu kullanarak oyun başladığında oyuncunun otomatik olarak atandığı takımı kullanabilirsin (çünkü oyuncular birden fazla takımın olduğu oyun modlarında bir takıma dahil olmak zorundadır). GetTeam[] fonksiyonu, aracı türünde bir parametre gerektirir fakat oyuncu bir aracı alt sınıfı olduğundan bir oyuncuyu tür dönüştürme yapmadan geçirebilirsin.

     AllPlayers := GetPlayspace().GetPlayers()
 for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
     # Takımlar dengeli değilse Oyuncuları yeni bir takıma ata

    Takım bir iç sınıf olduğundan başlatılamaz ve yalnızca var olan bir takım objesinin referansı olarak kullanılabilir.

  6. Tüm takımlar dengelenene kadar oyuncuları en az sayıda oyuncuya sahip takıma ataman gerekir. Bunu yapmak için her bir oyuncuyu ve sonra her bir takımı bir for döngüsü kullanarak kontrol etmen gerekir. Biri oyuncuları yinelemek ve diğeri takımları yinelemek üzere iki for döngüsü kullanabilirsin ancak bu örnekte takım for döngüsünü kendi yöntemi içine çıkaracaksın. Her bir oyuncunun referansını ve sonra oyuncuların bulunduğu her bir takımın referansını CurrentTeam adlı bir sabite alarak oyuncu for döngüsünü ayarla.

    • TeamSize adlı yeni bir değişken tamsayı oluştur ve 0 ile başlat, ardından bu oyuncunun o anda bulunduğu takımın boyutuna eşit olacak şekilde ayarla. GetAgents[] başarısız olabilir ifade olduğundan bu kümeyi bir if ifadesi içine almalısın.

        for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
      # Takımlar dengeli değilse Oyuncuları yeni bir takıma ata
      var TeamSize : int = 0
      if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length):
          Print("Size of this player's starting team is {TeamSize}")
    • FindSmallestTeam() adlı bir metot oluştur. Bu metot, TeamSizeı bir bağımsız değişken olarak geçirdiğinde isteğe bağlı bir takım (?team) döndürür ve en az sayıda oyuncuya sahip takımı bulma ve döndürme işlemlerini üstlenir. FindSmallestTeam() içinde SmallestTeam adlı yeni bir takım seçeneği başlat. FindSmallestTeam() işlevini çağırdığında oyuncu zaten en küçük takımda olabileceğinden burada bir seçenek kullanacaksın.

    • SmallestTeam seçeneğin varsayılan olarak false olduğundan daha küçük bir takım bulunmazsa false olarak kalır. FindSmallestTeam() işlevi false değerini döndürürse belirtilen oyuncunun zaten en küçük takımda olduğunu kesin olarak bilirsin. Ayrıca CurrentTeamSize değişken tamsayısını TeamSize değeri ile başlatman gerekir. Daha az oyuncuya sahip başka bir takımın boyutuna güncellenebilmesi için CurrentTeamSize değerinin değişken olması gerekir.

        FindSmallestTeam(CurrentTeamSize : int) : ?team=
      var SmallestTeam : ?team = false     
      var TeamSize : int = CurrentTeamSize

    • TeamSize değeri SmallestTeam boyutunu takip ettiğinden bu değeri her takımın boyutuyla karşılaştırman gerekir. Her bir takımı yinele ve takımların boyutunu CandidateTeamSize adlı yerel tamsayı olarak al. CandidateTeamSize değeri TeamSize değerinden küçükse SmallestTeam değerini bu takıma, TeamSize değerini ise bu takımın boyutuna ayarla.

      TeamSize > CandidateTeamSize koşulu for döngüsünün parantezi içinde kontrol edildiğinden bir filtre koşuludur. Filtre koşulu kullanmak, döngünün içindeki kodun yalnızca filtre koşulu başarılı olursa çalışmasını garanti eder. Bu da SmallestTeam değerinin, bulunması halinde en az oyuncuya sahip takıma ayarlanmasını garanti eder. Daha az oyuncuya sahip bir takım bulunamazsa SmallestTeam değeri false olarak kalır.

      Son olarak tüm takımlar kontrol edildikten sonra SmallestTeam değeri döndürülür.

       for(Team : Teams, CandidateTeamSize := GetPlayspace().GetTeamCollection().GetAgents[Team].Length, TeamSize > CandidateTeamSize):
  set SmallestTeam = option{Team}
  set TeamSize = CandidateTeamSize
  Print("Found a team with less players: {CandidateTeamSize}")               
 return SmallestTeam

    • OnBegin() yönteminde for döngüsünün içinde SmallestTeam adlı yeni bir takım seçeneği oluştur ve bağımsız değişken olarak TeamSize geçirildiğinde FindSmallestTeam() değeriyle başlat.

        SmallestTeam : ?team = FindSmallestTeam(TeamSize)

    • Ardından SmallestTeam isteğe bağlı değişkenindeki değere erişmeyi dene. Değer false ise oyuncu zaten en küçük takımdadır ve bir atama gerekli değildir. Aksi takdirde oyuncuyu yeni takımına ataman gerekir. Birçok yöntem bir seçeneği bağımsız değişken olarak doğrudan geçirmemize izin vermediğinden değeri TeamToAssign yerel değişkenine çıkarmak zorundasın. AddToTeam[player, team] kullanarak bir oyuncuyu bu takıma atamayı deneyebilirsin. Bir oyuncuyu zaten ait olduğu takıma atamayı denersen bu atamanın başarısız olacağını unutma. Bunun herhangi bir negatif etkisi olmaz ancak for döngüsü yalnızca bir sonraki oyuncuya yinelenir ve birinci oyuncuyu ilk takımında bırakır.

        if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
      Print("Attempting to assign player to a new team")

  7. OnBegin() aşağıdaki kod bloğu gibi görünmelidir.

    
 OnBegin<override>()<suspends> : void =
     Print("Verse Device Started!")
     set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()
     Print("Beginning to Assign Players")
     Playspace := GetPlayspace()
     AllPlayers := Playspace.GetPlayers()
     for (TeamPlayer : AllPlayers, CurrentTeam := Playspace.GetTeamCollection().GetTeam[TeamPlayer]):
         var TeamSize : int = 0
         if(set TeamSize = Playspace.GetTeamCollection().GetAgents[CurrentTeam].Length):
             Print("Size of this player's starting team is {TeamSize}")     
         SmallestTeam : ?team = FindSmallestTeam(TeamSize)
         if (TeamToAssign := SmallestTeam?, Playspace.GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
             Print("Attempting to assign player to a new team")

Oyun Sırasında Katılan Oyuncu

Takımları sürmekte olan bir oyun için de otomatik dengeleyebilmek istediğinden yeni bir oyuncu katıldığında başlatılan olaya abone olman gerekir. Yeni yazdığın tüm kodları tekrarlamak istemeyeceğinden bir ortak yönteme yeniden düzenleyebilirsin.

  1. BalanceTeams() adlı bir metot oluştur ve GetTeams() metodunu kullanıp Teams değişkenini ayarladıktan sonraki tüm kodu taşı. Bu metot, OnBegin() metodu içinde çağrılır, böylece oyun başladığında takımların dengeli olması sağlanır. BalanceTeams() aşağıdaki gibi görünmelidir.

     BalanceTeams() : void =
     AllPlayers := GetPlayspace().GetPlayers()
     for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
         var TeamSize : int = 0
         if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length):
             Print("Size of this player's starting team is {TeamSize}")          
         SmallestTeam : ?team = FindSmallestTeam(TeamSize)
         if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
             Print("Attempting to assign player to a new team")

  2. BalanceTeams() metoduna bir çağrı içeren OnPlayerAdded() adlı başka bir metot oluştur. player değişkenini kullanmayacak olsan da bu değişken, metot tanımı için gereklidir çünkü PlayerAddedEvent() olayına bu yöntemi kullanarak abone olursun. Abone olunabilir olaylar hakkında daha ayrıntılı bilgi için cihaz etkileşimlerinin kodlanması sayfasına bakabilirsin.

     OnPlayerAdded(InPlayer : player) : void =
 Print("A new Player joined, assigning them to a team!")
 BalanceTeams()

  3. OnBegin() yönteminde OnPlayerAdded kullanarak PlayerAddedEvent() olayına abone ol. Şimdi oyuna bir oyuncu katıldığında OnPlayerAdded işlevi, takımları otomatik olarak dengelemek için BalanceTeams() yöntemini çağırır.

     OnBegin<override>()<suspends> : void =
         GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
         Print("Beginning to balance teams")
         BalanceTeams()

  4. Kodu Visual Studio Code’a kaydet ve Verse Kodu Oluştur butonuna tıklayarak kodunu derle.

  5. Bölümün oynanış testini yapmak için UEFN araç çubuğunda Oturumu Başlata tıkla.

Bölümüne oynanış testi uygulamak için her bir takımın boyutunu ve kodun yazdırılan çıktı günlüğünde bulduğu daha küçük takımları görebilmen gerekir. Oyuncular takımlar arasında eşit olarak dağıtılmış olmalı ve oyuna katılan her yeni oyuncu bu eşitlenmiş dengeyi korumalıdır.

Sürmekte Olan Oyuna Katılma

Tam Kod

Aşağıdaki kod, oyuncu takımlarını otomatik olarak dengeleyen bir cihazın tam kodudur.

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

    team_multiplayer_balance := class(creative_device):
        # GetTeams() ile bulunan takımları barındırır
        var Teams : []team = array{}
        OnBegin<override>()<suspends> : void =

            Print("Verse Device Started!")
            set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()
            AllPlayers := GetPlayspace().GetPlayers()
            #Yeni bir oyuncu oyuna katıldığında takımların yeniden dengelenmesine olanak tanıyan PlayerAddedEvent olayına abone ol
            Self.GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
            Print("Beginning to balance teams")
            BalanceTeams()

        # Oyuna katılan yeni bir oyuncuyu işler

        OnPlayerAdded(InPlayer : player) : void =
            Print("A new Player joined, assigning them to a team!")
            BalanceTeams()            

        <#
        Her oyuncu için, oyuncunun takımındaki oyuncu sayısını bul. Takım listesini yinele
        ve en az sayıda oyuncuya sahip takıma ya da
        eşitlik varsa başladığı takıma oyuncuyu ata.
        #>

        BalanceTeams() : void =
            AllPlayers := GetPlayspace().GetPlayers()
            for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
                # Takımlar dengeli değilse Oyuncuları yeni bir takıma ata
                var TeamSize:int = 0

                if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length):
                    Print("Size of this player's starting team is {TeamSize}")

                SmallestTeam : ?team = FindSmallestTeam(TeamSize)
                if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
                    Print("Attempting to assign player to a new team")

        FindSmallestTeam(CurrentTeamSize : int) : ?team =
            var SmallestTeam : ?team = false
            var TeamSize : int = CurrentTeamSize

            <#
            Her takım için takımdaki oyuncu sayısını al. SmallestTeam değerinden az sayıda oyuncu varsa
            SmallestTeam değerini Team olarak ayarla ve TeamSize değerini yeni Takımdaki oyuncu sayısına güncelle
            #>

            for(Team : Teams, CandidateTeamSize := GetPlayspace().GetTeamCollection().GetAgents[Team].Length, TeamSize > CandidateTeamSize):
                set SmallestTeam = option{Team}
                set TeamSize = CandidateTeamSize
                Print("Found a team with less players: {CandidateTeamSize}")
            return SmallestTeam

Kendi Kendine Yapabileceklerin

Bu kılavuzu tamamlayarak oyuncu takımlarını otomatik olarak dengeleyen bir cihazı Verse kullanarak oluşturmayı öğrenmiş oldun.

Öğrendiklerini kullanarak bir oyuncuya karşı dört oyuncu gibi asimetrik oyun modları için kasıtlı olarak dengesi bozulmuş takımlar oluşturmayı dene.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page