BlessRNG ან RNG-ის სიმართლის შემოწმება

თამაშების შემუშავებისას ხშირად საჭიროა რაღაც შემთხვევითობასთან დაკავშირება: Unity-ს ამისთვის აქვს საკუთარი Random და System.Random მის პარალელურად არსებობს. ერთხელ, ერთ-ერთ პროექტზე, ისეთი შთაბეჭდილება დამრჩა, რომ ორივეს შეუძლია განსხვავებულად იმუშაოს (თუმცა მათ ერთგვაროვანი განაწილება უნდა ჰქონდეთ).

იმ დროს დეტალებში არ ჩავუღრმავდით - საკმარისი იყო, რომ System.Random-ზე გადასვლამ ყველა პრობლემა მოაგვარა. ახლა გადავწყვიტეთ, უფრო დეტალურად გაგვეანალიზებინა ეს საკითხი და ჩაგვეტარებინა მცირე კვლევა: რამდენად „მიკერძოებულები“ ​​ან პროგნოზირებადებია RNG-ები და რომელი ავირჩიოთ. უფრო მეტიც, არაერთხელ მომისმენია ურთიერთგამომრიცხავი მოსაზრებები მათ „პატიოსნებასთან“ დაკავშირებით - მოდით, ვცადოთ გავარკვიოთ, როგორ შეედრება რეალური შედეგები დეკლარირებულ შედეგებს.

მოკლე საგანმანათლებლო პროგრამა თუ RNG სინამდვილეში RNG-ა?

თუ უკვე იცნობთ შემთხვევითი რიცხვების გენერატორებს, შეგიძლიათ გადახვიდეთ „ტესტირების“ განყოფილებაზე.

შემთხვევითი რიცხვები (RN) არის რიცხვების თანმიმდევრობა, რომელიც წარმოიქმნება რაიმე შემთხვევითი (ქაოტური) პროცესით, ენტროპიის წყარო. ანუ ეს არის თანმიმდევრობა, რომლის ელემენტები ერთმანეთთან არ არის დაკავშირებული რაიმე მათემატიკური კანონით - მათ არ აქვთ მიზეზ-შედეგობრივი კავშირი.

შემთხვევითი რიცხვების გენერატორს (RNG) ქმნის. როგორც ჩანს, ყველაფერი ელემენტარულია, მაგრამ თუ თეორიიდან პრაქტიკაზე გადავალთ, მაშინ სინამდვილეში, ასეთი თანმიმდევრობის გენერირების პროგრამული ალგორითმის დანერგვა არც ისე მარტივია.

მიზეზი თანამედროვე სამომხმარებლო ელექტრონიკაში სწორედ ამ ქაოსის არარსებობაა. მის გარეშე შემთხვევითი რიცხვები წყვეტენ შემთხვევითობას და მათი გენერატორი წინასწარ განსაზღვრული არგუმენტების ჩვეულებრივ ფუნქციად იქცევა. IT სფეროს რიგი სპეციალობებისთვის ეს სერიოზული პრობლემაა (მაგალითად, კრიპტოგრაფიისთვის), მაგრამ დანარჩენებისთვის სრულიად მისაღები გადაწყვეტა არსებობს.

აუცილებელია დაიწეროს ალგორითმი, რომელიც დააბრუნებს, თუ არა ჭეშმარიტად შემთხვევით რიცხვებს, მაშინ მათთან რაც შეიძლება ახლოს - ე.წ. ფსევდოშემთხვევით რიცხვებს (PRNG). ამ შემთხვევაში ალგორითმს ფსევდოშემთხვევითი რიცხვების გენერატორი (PRNG) ეწოდება.

PRNG-ის შესაქმნელად რამდენიმე ვარიანტი არსებობს, მაგრამ შემდეგი ყველასთვის აქტუალური იქნება:

1. საჭიროა წინასწარი ინიციალიზაცია.

   PRNG-ს ენტროპიის წყარო არ გააჩნია, ამიტომ მის გამოყენებამდე საჭიროა საწყისი მდგომარეობის მითითება. ის მითითებულია რიცხვის (ან ვექტორის) სახით და მას ეწოდება „თესლი“ (შემთხვევითი „თესლი“. ხშირად, „თესლად“ გამოიყენება პროცესორის ციკლის მრიცხველი ან სისტემის დროის რიცხვითი ეკვივალენტი.

2. თანმიმდევრობის რეპროდუცირებადობა.

   PRNG სრულიად დეტერმინისტულია, ამიტომ ინიციალიზაციის დროს მითითებული საწყისი ცვლადი ცალსახად განსაზღვრავს რიცხვების მთელ მომავალ თანმიმდევრობას. ეს ნიშნავს, რომ ერთი და იგივე საწყისი ცვლადით ინიციალიზებული ერთი PRNG (სხვადასხვა დროს, სხვადასხვა პროგრამაში, სხვადასხვა მოწყობილობაზე) წარმოქმნის იმავე თანმიმდევრობას.

ასევე უნდა იცოდეთ ალბათური განაწილება, რომელიც ახასიათებს PRNG-ს - რა რიცხვებს წარმოქმნის ის და რა ალბათობით. ყველაზე ხშირად, ეს არის ნორმალური ან ერთგვაროვანი განაწილება.

ნორმალური განაწილება (მარცხნივ) და ერთგვაროვანი განაწილება (მარჯვნივ)

დავუშვათ, რომ გვაქვს 24-გვერდიანი კამათელი. თუ მას ვისროლთ, 1-ის მიღების ალბათობა 24/XNUMX-ია (ისევე, როგორც ნებისმიერი სხვა რიცხვის მიღების ალბათობა). თუ ბევრჯერ ვისროლთ და შედეგებს ჩავწერთ, შევამჩნევთ, რომ ყველა გვერდი დაახლოებით ერთი და იგივე სიხშირით გამოდის. არსებითად, ეს კამათელი შეიძლება ჩაითვალოს ერთგვაროვნად განაწილებულ შემთხვევითი გენერირებული გენერიულად.

და თუ ერთდროულად 10 ასეთ კამათელს ისვრით და ჯამურ ქულას გამოთვლით, ის ერთგვაროვანი დარჩება? არა. ყველაზე ხშირად, ქულა 125 ქულასთან ახლოს იქნება, ანუ რაღაც საშუალო მნიშვნელობასთან. შედეგად, სროლამდეც კი შეგიძლიათ დაახლოებით შეაფასოთ მომავალი შედეგი.

მიზეზი ის არის, რომ საშუალო ქულის მისაღებად კომბინაციების უდიდესი რაოდენობაა. რაც უფრო შორს ვართ მისგან, მით ნაკლები კომბინაციაა - და, შესაბამისად, მით უფრო დაბალია გამოვარდნის ალბათობა. თუ ეს მონაცემები ვიზუალიზებულია, ისინი ბუნდოვნად დაემსგავსებიან ზარის ფორმას. ამიტომ, გარკვეული გადაჭიმვით, 10 კამათლის სისტემას შეიძლება ეწოდოს ნორმალური განაწილების მქონე RNG.

კიდევ ერთი მაგალითი, მაგრამ უკვე თვითმფრინავში - სამიზნეზე სროლა. მსროლელი იქნება შემთხვევითი გენერირების გენერატორი, რომელიც წარმოქმნის რიცხვების წყვილს (x, y), რომელიც გრაფიკზეა ნაჩვენები.

დამეთანხმებით, რომ მარცხენა ვარიანტი უფრო ახლოსაა რეალურ ცხოვრებასთან - ეს არის ნორმალური განაწილების მქონე გენერატორის ასლი. თუმცა, თუ საჭიროა ვარსკვლავების გაფანტვა ბნელ ცაზე, მაშინ სწორი ვარიანტი, რომელიც მიიღება ერთგვაროვანი განაწილების მქონე გენერატორის გამოყენებით, უფრო შესაფერისია. ზოგადად, გენერატორი აირჩიეთ მოცემული ამოცანის მიხედვით.

ახლა კი მოდით ვისაუბროთ შემთხვევითი რიცხვების მიმდევრობის ენტროპიაზე. მაგალითად, არსებობს მიმდევრობა, რომელიც ასე იწყება:

89, 93, 33, 32, 82, 21, 4, 42, 11, 8, 60, 95, 53, 30, 42, 19, 34, 35, 62, 23, 44, 38, 74, 36, 52, 18, 58, 79, 65, 45, 99, 90, 82, 20, 41, 13, 88, 76, 82, 24, 5, 54, 72, 19, 80, 2, 74, 36, 71, 9, …

ერთი შეხედვით, რამდენად შემთხვევითია ეს რიცხვები? დავიწყოთ განაწილების შემოწმებით.

ის თითქმის ერთგვაროვანს ჰგავს, მაგრამ თუ თანმიმდევრობას ერთდროულად ორ რიცხვს წაიკითხავთ და მათ სიბრტყეზე კოორდინატებად აღიქვამთ, ამას მიიღებთ:

ნიმუშები მკაფიოდ ჩანს. და რადგან თანმიმდევრობაში მონაცემები გარკვეული წესით არის დალაგებული (ანუ დაბალი ენტროპია აქვს), ამან შეიძლება წარმოქმნას სწორედ ეს „მიკერძოება“. სულ მცირე, ასეთი PRNG არც თუ ისე შესაფერისია სიბრტყეზე კოორდინატების გენერირებისთვის.

კიდევ ერთი თანმიმდევრობა:

42, 72, 17, 0, 30, 0, 15, 9, 47, 19, 35, 86, 40, 54, 97, 42, 69, 19, 20, 88, 4, 3, 67, 27, 42, 56, 17, 14, 20, 40, 80, 97, 1, 31, 69, 13, 88, 89, 76, 9, 4, 85, 17, 88, 70, 10, 42, 98, 96, 53, …

როგორც ჩანს, აქ ყველაფერი კარგადაა, თუნდაც ბრტყელ ზედაპირზე:

მოდით, შევხედოთ მოცულობას (წაიკითხეთ სამი რიცხვი):

და ისევ ნიმუშები. ოთხ განზომილებაში ვიზუალიზაციის აგება აღარ არის შესაძლებელი. თუმცა, ნიმუშები შეიძლება არსებობდეს როგორც ამ განზომილებაში, ასევე უფრო დიდ განზომილებებში.

იმავე კრიპტოგრაფიაში, სადაც PRNG-ებს ყველაზე მკაცრი მოთხოვნები ეკისრებათ, ასეთი სიტუაცია კატეგორიულად მიუღებელია. ამიტომ, მათი ხარისხის შესაფასებლად შემუშავებულია სპეციალური ალგორითმები, რომლებსაც ახლა არ შევეხებით. თემა ვრცელია და ცალკე სტატიას იმსახურებს.

ტესტირება

თუ რამე დანამდვილებით არ ვიცით, როგორ უნდა ვიმუშაოთ მასთან? უნდა გადავკვეთოთ თუ არა გზა, თუ არ ვიცით, რომელი შუქნიშანი იძლევა ამის საშუალებას? შედეგები შეიძლება განსხვავებული იყოს.

იგივე ეხება Unity-ში ცნობილ შემთხვევითობას. კარგია, თუ დოკუმენტაცია საჭირო დეტალებს ავლენს, მაგრამ სტატიის დასაწყისში ნახსენები ამბავი სწორედ სასურველი სპეციფიკის არარსებობის გამო მოხდა.

და ხელსაწყოს მუშაობის პრინციპის ცოდნის გარეშე, თქვენ ვერ შეძლებთ მის სწორად გამოყენებას. ზოგადად, დროა შეამოწმოთ და ჩაატაროთ ექსპერიმენტი, რათა საბოლოოდ დარწმუნდეთ, სულ მცირე, განაწილებაში მაინც.

გამოსავალი მარტივი და ეფექტური იყო - სტატისტიკის შეგროვება, ობიექტური მონაცემების მიღება და შედეგების დათვალიერება.

კვლევის საგანი

Unity-ში შემთხვევითი რიცხვების გენერირების რამდენიმე გზა არსებობს - ჩვენ ხუთი გამოვცადეთ.

1. System.Random.Next() მოცემული მნიშვნელობების დიაპაზონში მთელ რიცხვებს წარმოქმნის.
2. System.Random.NextDouble(). წარმოქმნის ორმაგი სიზუსტის რიცხვებს [0; 1) დიაპაზონში.
3. UnityEngine.Random.Range() გენერირებს ერთსიზუსტიან რიცხვებს (მცურავი რიცხვი) მოცემული მნიშვნელობების დიაპაზონში.
4. UnityEngine.Random.value წარმოქმნის ერთზუსტ რიცხვებს (მცურავი რიცხვი) [0; 1) დიაპაზონში.
5. Unity.Mathematics.Random.NextFloat(). ახალი Unity.Mathematics ბიბლიოთეკის ნაწილი. გენერირებას უკეთებს ერთზუსტი მცოცავ რიცხვებს მოცემული მნიშვნელობების დიაპაზონში.

დოკუმენტაციაში თითქმის ყველგან მითითებული იყო ერთგვაროვანი განაწილება, გარდა UnityEngine.Random.value-სა (სადაც განაწილება არ არის მითითებული, მაგრამ UnityEngine.Random.Range()-ის ანალოგიით, ერთგვაროვანი განაწილებაც იყო მოსალოდნელი) და Unity.Mathematics.Random.NextFloat()-ისა (რომელიც დაფუძნებულია xorshift ალგორითმზე, რაც ნიშნავს, რომ კვლავ უნდა ველოდოთ ერთგვაროვან განაწილებას).

სტანდარტულად, მოსალოდნელი შედეგები იყო დოკუმენტაციაში მითითებული.

მეთოდოლოგია

ჩვენ დავწერეთ პატარა აპლიკაცია, რომელიც თითოეული წარმოდგენილი მეთოდის გამოყენებით შემთხვევითი რიცხვების მიმდევრობას გენერირებდა და შედეგებს შემდგომი დამუშავებისთვის ინახავდა.

თითოეული თანმიმდევრობის სიგრძე 100 რიცხვია.
შემთხვევითი რიცხვითი მნიშვნელობების დიაპაზონია [0, 100).

მონაცემები შეგროვდა რამდენიმე სამიზნე პლატფორმიდან:

• Windows
  — Unity v2018.3.14f1, რედაქტორის რეჟიმი, Mono, .NET Standard 2.0
• macOS
  — Unity v2018.3.14f1, რედაქტორის რეჟიმი, Mono, .NET Standard 2.0
  — Unity v5.6.4p4, რედაქტორის რეჟიმი, Mono, .NET Standard 2.0
• Android
  — Unity v2018.3.14f1, მოწყობილობის აწყობა, Mono, .NET Standard 2.0
• iOS
  — Unity v2018.3.14f1, მოწყობილობაზე აგებული, il2cpp, .NET Standard 2.0

Реализация

შემთხვევითი რიცხვების გენერირების რამდენიმე განსხვავებული გზა გვაქვს. თითოეული მათგანისთვის ცალკე შეფუთვის კლასს დავწერთ, რომელიც უნდა უზრუნველყოფდეს:

1. მნიშვნელობების დიაპაზონის [მინ./მაქს.] დაყენების შესაძლებლობა. დაყენდება კონსტრუქტორის მეშვეობით.
2. მეთოდი, რომელიც აბრუნებს SC-ს. ტიპად ავირჩევთ float-ს, რადგან ის უფრო ზოგადია.
3. შედეგების მონიშვნის გენერირების მეთოდის სახელი. მოხერხებულობისთვის, ჩვენ დავაბრუნებთ კლასის სრულ სახელს + SC-ის გენერირებისთვის გამოყენებული მეთოდის სახელს, როგორც მნიშვნელობას.

პირველ რიგში, ჩვენ ვაცხადებთ აბსტრაქციას, რომელიც წარმოდგენილი იქნება IRandomGenerator ინტერფეისით:

namespace RandomDistribution
{
    public interface IRandomGenerator
    {
        string Name { get; }

        float Generate();
    }
}

System.Random.Next()-ის იმპლემენტაცია

ეს მეთოდი საშუალებას გაძლევთ დააყენოთ მნიშვნელობების დიაპაზონი, თუმცა ის აბრუნებს მთელ რიცხვებს და საჭიროა მცურავი რიცხვები. შეგიძლიათ უბრალოდ მთელი რიცხვი ინტერპრეტაცია გაუკეთოთ მცურავ რიცხვს, ან შეგიძლიათ გააფართოვოთ მნიშვნელობების დიაპაზონი რამდენიმე რიგითობით, კომპენსირებით მათ SC-ის თითოეულ თაობაზე. თქვენ მიიღებთ რაღაც ფიქსირებული წერტილის მსგავსს სიზუსტის მითითებული რიგითობით. ჩვენ გამოვიყენებთ ამ ვარიანტს, რადგან ის უფრო ახლოს არის რეალურ მცურავ რიცხვთან.

using System;

namespace RandomDistribution
{
    public class SystemIntegerRandomGenerator : IRandomGenerator
    {
        private const int DefaultFactor = 100000;
        
        private readonly Random _generator = new Random();
        private readonly int _min;
        private readonly int _max;
        private readonly int _factor;


        public string Name => "System.Random.Next()";


        public SystemIntegerRandomGenerator(float min, float max, int factor = DefaultFactor)
        {
            _min = (int)min * factor;
            _max = (int)max * factor;
            _factor = factor;
        }


        public float Generate() => (float)_generator.Next(_min, _max) / _factor;
    }
}

System.Random.NextDouble()-ის იმპლემენტაცია

აქ მოცემულია მნიშვნელობების ფიქსირებული დიაპაზონი [0; 1]. კონსტრუქტორში მითითებულ მნიშვნელობაზე მისი პროეცირებისთვის, ჩვენ ვიყენებთ მარტივ არითმეტიკას: X * (max − min) + min.

using System;

namespace RandomDistribution
{
    public class SystemDoubleRandomGenerator : IRandomGenerator
    {
        private readonly Random _generator = new Random();
        private readonly double _factor;
        private readonly float _min;


        public string Name => "System.Random.NextDouble()";


        public SystemDoubleRandomGenerator(float min, float max)
        {
            _factor = max - min;
            _min = min;
        }


        public float Generate() => (float)(_generator.NextDouble() * _factor) + _min;
    }
}

UnityEngine.Random.Range()-ის იმპლემენტაცია

სტატიკური კლასის UnityEngine.Random-ის ეს მეთოდი საშუალებას გაძლევთ მიუთითოთ მნიშვნელობების დიაპაზონი და აბრუნებს მცურავი ტიპის შემთხვევით რიცხვს. დამატებითი კონვერტაციები არ არის საჭირო.

using UnityEngine;

namespace RandomDistribution
{
    public class UnityRandomRangeGenerator : IRandomGenerator
    {
        private readonly float _min;
        private readonly float _max;


        public string Name => "UnityEngine.Random.Range()";


        public UnityRandomRangeGenerator(float min, float max)
        {
            _min = min;
            _max = max;
        }


        public float Generate() => Random.Range(_min, _max);
    }
}

UnityEngine.Random.value-ის იმპლემენტაცია

სტატიკური კლასის value თვისება UnityEngine.Random აბრუნებს float ტიპის შემთხვევით რიცხვს ფიქსირებული მნიშვნელობების დიაპაზონიდან [0; 1]. მოდით, ის მოცემულ დიაპაზონზე ისე გავაპროეცოთ, როგორც System.Random.NextDouble()-ის იმპლემენტაციის დროს.

using UnityEngine;

namespace RandomDistribution
{
    public class UnityRandomValueGenerator : IRandomGenerator
    {
        private readonly float _factor;
        private readonly float _min;


        public string Name => "UnityEngine.Random.value";


        public UnityRandomValueGenerator(float min, float max)
        {
            _factor = max - min;
            _min = min;
        }


        public float Generate() => (float)(Random.value * _factor) + _min;
    }
}

Unity.Mathematics.Random.NextFloat()-ის იმპლემენტაცია

Unity.Mathematics.Random კლასის NextFloat() მეთოდი აბრუნებს float ტიპის შემთხვევით რიცხვს და საშუალებას გაძლევთ მიუთითოთ მნიშვნელობების დიაპაზონი. ერთადერთი გაფრთხილება ის არის, რომ Unity.Mathematics.Random-ის თითოეული ეგზემპლარი უნდა იყოს ინიციალიზებული გარკვეული საწყისი წერტილით — ამ გზით ჩვენ თავიდან ავიცილებთ განმეორებადი მიმდევრობების გენერირებას.

using Unity.Mathematics;

namespace RandomDistribution
{
    public class UnityMathematicsRandomValueGenerator : IRandomGenerator
    {
        private Random _generator;
        private readonly float _min;
        private readonly float _max;


        public string Name => "Unity.Mathematics.Random.NextFloat()";


        public UnityMathematicsRandomValueGenerator(float min, float max)
        {
            _min = min;
            _max = max;
            _generator = new Random();
            _generator.InitState(unchecked((uint)System.DateTime.Now.Ticks));
        }


        public float Generate() => _generator.NextFloat(_min, _max);
    }
}

MainController-ის იმპლემენტაცია

IRandomGenerator-ის რამდენიმე იმპლემენტაცია მზადაა. შემდეგ, ჩვენ უნდა შევქმნათ თანმიმდევრობები და შევინახოთ მიღებული მონაცემთა ნაკრები დამუშავებისთვის. ამისათვის ჩვენ შევქმნით სცენას Unity-ში და პატარა MainController სკრიპტს, რომელიც შეასრულებს ყველა საჭირო სამუშაოს და ამავდროულად იქნება პასუხისმგებელი ინტერაქციაზე ინტერაქციაზე.

ჩვენ დავადგენთ მონაცემთა ნაკრების ზომას და SC მნიშვნელობების დიაპაზონს, ასევე შევიძენთ მეთოდს, რომელიც დააბრუნებს კონფიგურირებული და გამოსაყენებლად მზა გენერატორების მასივს.

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        private const int DefaultDatasetSize = 100000;

        public float MinValue = 0f;
        public float MaxValue = 100f;

        ...

        private IRandomGenerator[] CreateRandomGenerators()
        {
            return new IRandomGenerator[]
            {
                new SystemIntegerRandomGenerator(MinValue, MaxValue),
                new SystemDoubleRandomGenerator(MinValue, MaxValue),
                new UnityRandomRangeGenerator(MinValue, MaxValue),
                new UnityRandomValueGenerator(MinValue, MaxValue),
                new UnityMathematicsRandomValueGenerator(MinValue, MaxValue)
            };
        }

        ...
    }
}

ახლა ჩვენ ვქმნით მონაცემთა ნაკრებს. ამ შემთხვევაში, მონაცემთა გენერირება გაერთიანდება შედეგების ტექსტურ ნაკადში (csv ფორმატში) ჩაწერასთან. თითოეულ IrandomGenerator-ს აქვს საკუთარი ცალკე სვეტი მნიშვნელობების შესანახად, ხოლო პირველი ხაზი შეიცავს გენერატორის სახელს.

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        ...
		
        private void GenerateCsvDataSet(TextWriter writer, int dataSetSize, params IRandomGenerator[] generators)
        {
            const char separator = ',';
            int lastIdx = generators.Length - 1;

            // write header
            for (int j = 0; j <= lastIdx; j++)
            {
                writer.Write(generators[j].Name);
                if (j != lastIdx)
                    writer.Write(separator);
            }
            writer.WriteLine();

            // write data
            for (int i = 0; i <= dataSetSize; i++)
            {
                for (int j = 0; j <= lastIdx; j++)
                {
                    writer.Write(generators[j].Generate());
                    if (j != lastIdx)
                        writer.Write(separator);
                }

                if (i != dataSetSize)
                    writer.WriteLine();
            }
        }

        ...
    }
}

რჩება მხოლოდ GenerateCsvDataSet მეთოდის გამოძახება და შედეგის ფაილში შენახვა, ან მონაცემების ქსელში დაუყოვნებლივ გადატანა საბოლოო მოწყობილობიდან მიმღებზე. სერვერზე.

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        ...
		
        public void GenerateCsvDataSet(string path, int dataSetSize, params IRandomGenerator[] generators)
        {
            using (var writer = File.CreateText(path))
            {
                GenerateCsvDataSet(writer, dataSetSize, generators);
            }
        }


        public string GenerateCsvDataSet(int dataSetSize, params IRandomGenerator[] generators)
        {
            using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
            {
                GenerateCsvDataSet(writer, dataSetSize, generators);
                return writer.ToString();
            }
        }

        ...
    }
}

პროექტის წყაროები მდებარეობს გიტლაბი.

დასკვნები

არანაირი სასწაული არ მომხდარა. რასაც ველოდით, ის მივიღეთ - ყველა შემთხვევაში, თანაბარი განაწილება შეთქმულების ელემენტების გარეშე. ვერ ვხედავ აზრს პლატფორმებისთვის ცალკე გრაფიკების დამატებაში - ყველა მათგანი დაახლოებით ერთნაირ შედეგებს აჩვენებს.

რეალობა ასეთია:


ხუთივე გენერაციის მეთოდით სიბრტყეზე თანმიმდევრობების ვიზუალიზაცია:


და ვიზუალიზაცია 3D-ში. მხოლოდ System.Random.Next()-ის შედეგს დავტოვებ, რათა იდენტური კონტენტის ერთობლიობა არ გენერირდეს.


შესავალში მოთხრობილი ამბავი UnityEngine.Random-ის ნორმალური განაწილების შესახებ აღარ განმეორებულა: ან თავიდანვე არასწორი იყო, ან მას შემდეგ ძრავში რაღაც შეიცვალა. მაგრამ ახლა დარწმუნებულები ვართ.

წყარო: www.habr.com