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

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

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

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

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

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

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

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

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

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

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

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

2. თანმიმდევრობის განმეორებადობა.

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

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

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

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

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

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

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

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

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

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() (სადაც The Base-ში არის xorshift ალგორითმი, რაც ნიშნავს, რომ კვლავ უნდა დაელოდოთ ერთგვაროვან განაწილებას).

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

მეთოდოლოგია

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

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

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

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

Реализация

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

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

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

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

        float Generate();
    }
}

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

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

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 სტატიკური კლასის ეს მეთოდი საშუალებას გაძლევთ დააყენოთ მნიშვნელობების დიაპაზონი და დააბრუნოთ float ტიპის. თქვენ არ გჭირდებათ რაიმე დამატებითი ტრანსფორმაციის გაკეთება.

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-ის იმპლემენტაცია

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-ის რამდენიმე იმპლემენტაცია მზად არის. შემდეგი, თქვენ უნდა შექმნათ თანმიმდევრობები და შეინახოთ მიღებული მონაცემთა ნაკრები დამუშავებისთვის. ამისათვის ჩვენ შევქმნით სცენას და პატარა MainController სკრიპტს Unity-ში, რომელიც შეასრულებს ყველა საჭირო სამუშაოს და ამავე დროს იქნება პასუხისმგებელი UI-სთან ინტერაქციაზე.

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

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