मुझे नहीं पता कि कुंजी इसके लिए सही शब्द है, लेकिन मैंने डायमंड-स्क्वायर एल्गोरिथम का एक संस्करण लागू किया और मैं सोच रहा था कि क्या वर्तमान आउटपुट को "सेव" करने का कोई तरीका है और इसे एक सरल (6 से 10) का उपयोग करके फिर से बनाना है। अक्षर) कुंजी। अब तक मैंने केवल यही सोचा है कि इसे एकल संख्या/स्ट्रिंग के रूप में सहेजा जाए जिसमें प्रत्येक सेल का आउटपुट मान हो, लेकिन 17X17 ग्रिड के लिए मेरे पास कम से कम 289 वर्ण लंबा अनुक्रम होगा (यह मानते हुए कि आउटपुट प्रति सेल एक अंक है) .

चूंकि एल्गोरिदम यादृच्छिक है, इसलिए मैं इसे करने के बेहतर तरीके के बारे में नहीं सोच सकता। यदि यह असंभव है तो क्या आप मुझे उपयोग करने के लिए बेहतर एल्गोरिदम के बारे में बता सकते हैं। शुक्रिया :)

पीएस: मैं एकता 3 डी और सी # का उपयोग कर रहा हूं

0
AntoineO 26 सितंबर 2018, 15:07

2 जवाब

सबसे बढ़िया उत्तर

मुझे यह टिप्पणी पसंद आई कि मैंने Random.InitState का उपयोग किया और एकता प्रदान की और सब कुछ ठीक काम कर रहा है। एक बार फिर धन्यवाद!

UnityEngine.Random.InitState(seed);

मैं अपनी इच्छानुसार बीज को नियंत्रित कर सकता हूं और यह मुझे उसी बीज के लिए वही नक्शा देता है।

0
AntoineO 27 सितंबर 2018, 00:21

निम्न वर्ग प्रक्रियात्मक गुफा निर्माण के लिए एकता ट्यूटोरियल से है, लेकिन ive ने इसे शामिल किया क्योंकि इसमें आपके लिए आवश्यक मूल तत्व शामिल हैं। यह एक नक्शा बनाने के लिए एक बीज का उपयोग करता है, वही बीज उसी मानचित्र को पुन: उत्पन्न करेगा .... आप अपनी पीढ़ी की प्रक्रिया में एक बीज का उपयोग कर सकते हैं, भले ही वह यादृच्छिक हो, तो आप उस बीज को उस मानचित्र पर वापस जाने के लिए हमेशा पुन: उपयोग कर सकते हैं।

 using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using System;

    public class MapGenerator : MonoBehaviour {
        public int width;
        public int height;

        public string seed;
        public bool useRandomSeed;

        [Range(0,100)]
        public int randomFillPercent;
        int[,] map;

        private void Start()
        {
            GenerateMap();
        }

        void GenerateMap()
        {
            map = new int[width, height];
            RandomFillMap();

            for (int i = 0; i < 5; i++)
            {
                SmoothMap();
            }
        }
        void RandomFillMap()
        {
            if (useRandomSeed)
            {
                seed = Time.time.ToString();
            }
            System.Random prng = new System.Random(seed.GetHashCode());
            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    if (x == 0 || x == width - 1 || y == 0 || y == height - 1)
                    {
                        map[x, y] = 1;
                    }
                    else
                    {
                        map[x, y] = (prng.Next(0, 100) < randomFillPercent) ? 1 : 0;
                    }
                }

            }
        }
        private void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                GenerateMap();
            }
        }
        void SmoothMap()
        {
            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    int neighborWallTiles = GetSurroundingWallCount(x, y);
                    if (neighborWallTiles > 4)
                    {
                        map[x, y] = 1;
                    }
                    else if (neighborWallTiles<4)
                    {
                        map[x, y] = 0;
                    }

                }
            }
                }

        int GetSurroundingWallCount(int gridx, int gridy)
        {
            int wallcount = 0;
            for(int neighborx=gridx-1; neighborx<=gridx + 1; neighborx++)
            {
                for (int neighbory = gridy - 1; neighbory <= gridy + 1; neighbory++)
                {
                    if (neighborx >= 0 && neighborx < width && neighbory >= 0 && neighbory < height)
                    {

                        if (neighborx != gridx || neighbory != gridy)
                        {
                            wallcount += map[neighborx, neighbory];
                        }
                    }
                    else
                    {
                        wallcount++;
                    }

                }
            }
            return wallcount;
        }

            void OnDrawGizmos()
            {
                if (map != null)
                {
                    for (int x = 0; x < width; x++)
                    {
                        for (int y = 0; y < height; y++)
                        {
                        Gizmos.color = (map[x, y] == 1) ? Color.black : Color.white;
                        Vector3 pos = new Vector3(-width / 2 + x + .5f, 0, -height / 2 + y + .5f);
                        Gizmos.DrawCube(pos, Vector3.one);
                        }
                    }
                }

        }

    }
0
PrinceOfRavens 26 सितंबर 2018, 18:22