नक्शा टाइलिंग एल्गोरिथ्म


153

नक्शा

मैं जावास्क्रिप्ट के साथ एक टाइल आधारित आरपीजी बना रहा हूं, पेरीलिन शोर ऊंचाई का उपयोग करके, फिर शोर की ऊंचाई के आधार पर एक टाइल प्रकार असाइन करना।

नक्शे कुछ इस तरह से दिखते हैं (न्यूनतम दृश्य में)।

यहाँ छवि विवरण दर्ज करें

मेरे पास एक काफी सरल एल्गोरिथ्म है जो छवि पर प्रत्येक पिक्सेल से रंग मूल्य निकालता है और इसे पूर्णांक (0-5) में परिवर्तित करता है, जो कि (0-255) के बीच के अपने पद पर निर्भर करता है जो टाइल शब्दकोश में एक टाइल से मेल खाती है। यह 200x200 सरणी तब क्लाइंट को दी जाती है।

इंजन तब सरणी में मानों से टाइलों को निर्धारित करता है और उन्हें कैनवास पर खींचता है। इसलिए, मैं दिलचस्प दुनिया के साथ अंत करता हूं, जिसमें यथार्थवादी दिखने की विशेषताएं हैं: पहाड़, समुद्र आदि।

अब अगली चीज जो मैं करना चाहता था वह था कि किसी प्रकार के सम्मिश्रण एल्गोरिथ्म को लागू किया जाए जिससे टाइलें उनके पड़ोसियों में आसानी से मिल जाए, अगर पड़ोसी एक ही प्रकार का नहीं है। ऊपर दिए गए उदाहरण का नक्शा वह है जो खिलाड़ी अपने न्यूनतम में देखता है। ऑनस्क्रीन वे सफेद आयत द्वारा चिह्नित अनुभाग का एक गाया संस्करण देखते हैं; जहाँ टाइल्स एकल रंगीन पिक्सेल के बजाय उनकी छवियों के साथ प्रदान की जाती हैं।

यह एक उदाहरण है कि उपयोगकर्ता मानचित्र में क्या देखेगा लेकिन यह उस स्थान के समान नहीं है जैसा कि ऊपर दिए गए व्यूपोर्ट में है!

यहाँ छवि विवरण दर्ज करें

यह इस दृष्टिकोण में है कि मैं चाहता हूं कि संक्रमण हो।

एल्गोरिथ्म

मैं एक साधारण एल्गोरिथ्म के साथ आया था, जो व्यूपोर्ट के भीतर नक्शे को आगे बढ़ाएगा और प्रत्येक टाइल के शीर्ष पर एक और छवि प्रदान करेगा, बशर्ते यह विभिन्न प्रकार की टाइल के बगल में हो। (नक्शा नहीं बदल रहा है! बस कुछ अतिरिक्त छवियों का प्रतिपादन।) एल्गोरिथ्म का विचार वर्तमान टाइल के पड़ोसियों को प्रोफाइल करना था:

एक टाइल प्रोफ़ाइल का एक उदाहरण

यह एक उदाहरण परिदृश्य है कि इंजन को प्रस्तुत करने के लिए क्या हो सकता है, वर्तमान टाइल के साथ जो एक्स के साथ चिह्नित है।

एक 3x3 सरणी बनाई गई है और इसके आस-पास के मानों को पढ़ा जाता है। इसलिए इस उदाहरण के लिए सरणी जैसा दिखेगा।

[
    [1,2,2]
    [1,2,2]
    [1,1,2]
];

मेरा विचार तब संभव टाइल विन्यास के लिए मामलों की एक श्रृंखला का काम करना था। बहुत ही सरल स्तर पर:

if(profile[0][1] != profile[1][1]){
     //draw a tile which is half sand and half transparent
     //Over the current tile -> profile[1][1]
     ...
}

जो यह परिणाम देता है:

परिणाम

जिसमें से एक संक्रमण के रूप में काम करता है [0][1]के लिए [1][1]है, लेकिन से नहीं [1][1]करने के लिए [2][1]है, जहां एक कठिन बढ़त बनी हुई है। तो मुझे लगा कि उस उदाहरण में एक कोने की टाइल का उपयोग करना होगा। मैंने दो 3x3 स्प्राइट शीट बनाईं, जो मुझे लगा कि टाइलों के सभी संभावित संयोजनों को पकड़ सकता है जिनकी आवश्यकता हो सकती है। फिर मैंने सभी टाइलों के लिए यह दोहराया कि खेल में हैं (सफेद क्षेत्र पारदर्शी हैं)। यह प्रत्येक प्रकार की टाइल के लिए 16 टाइलें होती है (प्रत्येक स्प्राइटशीट पर केंद्र टाइल का उपयोग नहीं किया जाता है।)

रेतSand2

आदर्श परिणाम

इसलिए, इन नई टाइलों और सही एल्गोरिदम के साथ, उदाहरण अनुभाग इस तरह दिखेगा:

सही बात

मेरे द्वारा किया गया हर प्रयास विफल रहा है, हालांकि एल्गोरिथ्म में हमेशा कुछ दोष होता है और पैटर्न अजीब होते हैं। मुझे सभी मामले सही नहीं लग रहे हैं और कुल मिलाकर यह ऐसा करने का एक खराब तरीका है।

एक तरकीब?

इसलिए, यदि कोई इस बारे में कोई वैकल्पिक समाधान प्रदान कर सकता है कि मैं इस प्रभाव को कैसे बना सकता हूं, या प्रोफाइलिंग एल्गोरिथ्म लिखने के लिए किस दिशा में जाना है, तो मैं बहुत आभारी रहूंगा!


7
इस लेख और इससे जुड़े लेखों पर एक नज़र डालें , विशेष रूप से यह एक । ब्लॉग में ही बहुत सारे विचार हैं जो एक शुरुआती बिंदु के रूप में काम कर सकते हैं। यहाँ एक अवलोकन है।
दारका

आपको अपने एल्गोरिथ्म को सरल बनाना चाहिए। इसे देखें: द्वि-आयामी-सेलुलर-ऑटोमेटा
user1097489

जवाबों:


117

इस एल्गोरिथ्म का मूल विचार सभी किनारों को खोजने के लिए पूर्व-प्रसंस्करण कदम का उपयोग करना है और फिर किनारे के आकार के अनुसार सही चौरसाई टाइल का चयन करना है।

पहला कदम सभी किनारों को खोजना होगा। एक्स के साथ चिह्नित एज टाइल्स के नीचे उदाहरण में, सभी हरे रंग की टाइलें हैं जो एक टेन टाइल के साथ एक या एक से अधिक आठ पड़ोसी टाइल हैं। विभिन्न प्रकार के भू-भाग के साथ यह स्थिति एक टाइल के किनारे की टाइल में तब्दील हो सकती है यदि इसमें निचले इलाके-संख्या के पड़ोसी हैं।

किनारे की टाइलें।

एक बार जब सभी एज टाइलों का पता लगाया जाता है, तो प्रत्येक एज टाइल के लिए सही स्मूथिंग टाइल का चयन करना है। यहाँ आपके चौरसाई टाइल्स का मेरा प्रतिनिधित्व है।

खिसकती टाइल्स।

ध्यान दें कि वास्तव में टाइल के कई अलग-अलग प्रकार नहीं हैं। हमें 3x3 चौकों में से एक से आठ बाहरी टाइलों की आवश्यकता होती है, लेकिन सीधे किनारे वाली टाइलें पहले वर्ग में पाए जाने के बाद से दूसरे से केवल चार कोने वाले वर्ग हैं। इसका मतलब है कि कुल 12 अलग-अलग मामले हैं जिनके बीच हमें अंतर करना चाहिए।

अब, एक किनारे की टाइल को देखते हुए, हम यह निर्धारित कर सकते हैं कि सीमा किस तरह से अपने चार निकटतम पड़ोसी टाइलों को देखकर बदल जाती है। एक्स के साथ एक बढ़त टाइल को चिह्नित करना ऊपर के रूप में हमारे पास निम्नलिखित छह अलग-अलग मामले हैं।

छह मामले।

इन मामलों का उपयोग संबंधित चौरसाई टाइल को निर्धारित करने के लिए किया जाता है और हम तदनुसार चौरसाई टाइल को संख्या दे सकते हैं।

संख्याओं के साथ चिकनी टाइलें।

प्रत्येक मामले के लिए अभी भी एक या बी का विकल्प है। यह इस बात पर निर्भर करता है कि घास किस तरफ है। इसे निर्धारित करने का एक तरीका सीमा के अभिविन्यास पर नज़र रखना हो सकता है, लेकिन ऐसा करने का सबसे सरल तरीका यह है कि किनारे के बगल में एक टाइल चुनें और देखें कि उसमें क्या रंग है। नीचे दी गई छवि दो मामलों 5 ए) और 5 बी) को दिखाती है, जिसे उदाहरण के लिए शीर्ष दाएं टाइल के रंग की जांच के बीच के बीच अंतर किया जा सकता है।

5 ए या 5 बी चुनना।

मूल उदाहरण के लिए अंतिम गणना तब इस तरह दिखेगी।

अंतिम गणना।

और संबंधित धार टाइल का चयन करने के बाद सीमा कुछ इस तरह दिखाई देगी।

अंतिम परिणाम।

अंतिम नोट के रूप में मैं कह सकता हूं कि यह तब तक काम करेगा जब तक सीमा कुछ हद तक नियमित न हो जाए। अधिक सटीक रूप से, किनारे की टाइलें जिनके पास बिल्कुल दो किनारे वाली टाइलें नहीं हैं, क्योंकि उनके पड़ोसियों को अलग से इलाज करना होगा। यह मानचित्र के किनारे पर किनारे की टाइलों के लिए होगा, जिसमें एक किनारे का पड़ोसी होगा और इलाके के बहुत संकीर्ण टुकड़ों के लिए जहां पड़ोसी किनारे की टाइलों की संख्या तीन या चार हो सकती है।


1
यह मेरे लिए बहुत अच्छा और बहुत मददगार है। मैं एक ऐसे मामले से निपट रहा हूं जहां कुछ टाइलें दूसरों में सीधे संक्रमण नहीं कर सकती हैं। उदाहरण के लिए, "गंदगी" टाइल "हल्की घास" और "हल्की घास" में संक्रमण कर सकती है और "मध्यम घास" में परिवर्तित हो सकती है। टिल्ड (mapeditor.org) इलाके के ब्रश के लिए कुछ प्रकार के पेड़ खोज को लागू करके इसे संभालने का एक बड़ा काम करता है; मैंने अभी तक इसे पुन: पेश करने में सक्षम होने के लिए, हालांकि।
क्ले

12

निम्नलिखित वर्ग एक धातु प्लेट का प्रतिनिधित्व करता है। शीर्ष दाएं कोने द्वारा "हीट वेंट" है। हम देख सकते हैं कि कैसे इस बिंदु का तापमान स्थिर रहता है, धातु की प्लेट प्रत्येक बिंदु पर एक स्थिर तापमान में परिवर्तित हो जाती है, शीर्ष के निकट स्वाभाविक रूप से गर्म होती है:

heatplate

प्रत्येक बिंदु पर तापमान खोजने की समस्या को "सीमा मूल्य समस्या" के रूप में हल किया जा सकता है। हालांकि, प्रत्येक बिंदु पर गर्मी का काम करने का सबसे सरल तरीका प्लेट को ग्रिड के रूप में मॉडल करना है। हम निरंतर तापमान पर ग्रिड पर बिंदुओं को जानते हैं। हम सभी अज्ञात बिंदुओं के तापमान को कमरे के तापमान के रूप में सेट करते हैं (जैसे कि वेंट केवल चालू किया गया था)। हम तब तक प्लेट में गर्मी फैलाते हैं जब तक हम अभिसरण तक नहीं पहुंच जाते हैं। यह पुनरावृत्ति द्वारा किया जाता है: हम प्रत्येक (i, j) बिंदु के माध्यम से पुनरावृति करते हैं। हमने बिंदु (i, j) = (बिंदु (i + 1, j) + बिंदु (i-1, j) + बिंदु (i, j + 1) + बिंदु (i, j-1)) / 4 [जब तक बिंदु (i, j) में स्थिर तापमान का हीट वेंट है]

यदि आप इसे अपनी समस्या पर लागू करते हैं, तो यह बहुत समान है, तापमान के बजाय औसत रंग। आपको शायद लगभग 5 पुनरावृत्तियों की आवश्यकता होगी। मैं 400x400 ग्रिड का उपयोग करने का सुझाव देता हूं। Thats 400x400x5 = 1 मिलियन से कम पुनरावृत्तियों जो तेजी से होगा। यदि आप केवल 5 पुनरावृत्तियों का उपयोग करते हैं, तो आपको संभवतः किसी भी बिंदु को निरंतर रंग रखने के बारे में चिंता करने की आवश्यकता नहीं होगी, क्योंकि वे अपने मूल से बहुत अधिक बदलाव नहीं करेंगे (वास्तव में रंग से दूरी 5 के भीतर केवल अंक रंग द्वारा प्रभावित हो सकते हैं)। छद्म कोड:

iterations = 5
for iteration in range(iterations):
    for i in range(400):
        for j in range(400):
            try:
                grid[i][j] = average(grid[i+1][j], grid[i-1][j],
                                     grid[i][j+1], grid[i][j+1])
            except IndexError:
                pass

क्या आप इसे थोड़ा और बढ़ा सकते हैं? im उत्सुक, और मैं आपकी व्याख्या नहीं समझ सकता। आपके द्वारा पुनरावृत्तियों को करने के बाद कोई औसत रंग मान का उपयोग कैसे करता है?
Chii

1
प्रत्येक ग्रिड बिंदु ग्रिड [i] [जे] को उचित रंग के एक छोटे आयत (या व्यक्तिगत पिक्सेल) के रूप में कैनवास पर खींचा जा सकता है।
रोबर्ट राजा

5

ठीक है, इसलिए पहला विचार यह है कि समस्या के लिए एक सही समाधान को स्वचालित करने के लिए कुछ बल्कि भावपूर्ण गणित की आवश्यकता होती है। इस तथ्य के आधार पर कि आप पहले से रेंडर टाइल छवियों का उल्लेख करते हैं, मेरा मानना ​​है कि पूर्ण प्रक्षेप समाधान यहां वारंट नहीं किया गया है।

दूसरी ओर, जैसा कि आपने कहा था, हाथ से नक्शा खत्म करने से अच्छा परिणाम आएगा ... लेकिन मैं यह भी मानता हूं कि ग्लिच को ठीक करने के लिए कोई भी मैनुअल प्रक्रिया भी एक विकल्प नहीं है।

यहां एक सरल एल्गोरिथ्म है जो एक आदर्श परिणाम नहीं देता है, लेकिन यह कम प्रयास के आधार पर बहुत फायदेमंद है।

इसके बजाय हर किनारे टाइल को मिश्रण करने की कोशिश करने के लिए, (जिसका अर्थ है कि आपको या तो आसन्न टाइल्स को सम्मिश्रण करने का परिणाम जानने की जरूरत है - प्रक्षेप, या आपको कई बार पूरे नक्शे को परिष्कृत करने की आवश्यकता है और पूर्व-निर्मित टाइल पर भरोसा नहीं कर सकते हैं) वैकल्पिक चेकर-बोर्ड पैटर्न में टाइलों को क्यों नहीं मिलाया जाता है?

[1] [*] [2]
[*] [1] [*]
[1] [*] [2]

Ie केवल ऊपर मैट्रिक्स में तारांकित टाइलों को सम्मिश्रित कर रहा है?

यह मानते हुए कि मूल्य में केवल अनुमत चरणों में एक-एक-समय है, आपके पास केवल कुछ टाइलें डिज़ाइन करने के लिए हैं ...

A    [1]      B    [2]      C    [1]      D    [2]      E    [1]           
 [1] [*] [1]   [1] [*] [1]   [1] [*] [2]   [1] [*] [2]   [1] [*] [1]   etc.
     [1]           [1]           [1]           [1]           [2]           

कुल 16 पैटर्न होंगे। यदि आप घूर्णी और परावर्तक समरूपता का लाभ उठाते हैं तो और भी कम होगा।

'ए' एक सादे [1] शैली की टाइल होगी। 'डी' एक विकर्ण होगा।

टाइल्स के कोनों पर छोटी-छोटी गड़बड़ियां होंगी, लेकिन ये आपके द्वारा दिए गए उदाहरण की तुलना में मामूली होंगे।

अगर मैं बाद में इस पोस्ट को छवियों के साथ अपडेट कर सकता हूं।


यह अच्छा लगता है, मुझे आपकी रुचि के बारे में बेहतर जानकारी प्राप्त करने के लिए इसे कुछ छवियों के साथ देखने में दिलचस्पी होगी।
डैन प्रिंस

मैं किसी भी चित्र को एक साथ नहीं रख सकता क्योंकि मेरे पास ऐसा सॉफ़्टवेयर नहीं है जो मुझे लगा कि मेरे पास है ... लेकिन मैं सोच रहा हूं और यह उतना अच्छा समाधान नहीं है जितना कि यह हो सकता है। आप विकर्ण संक्रमण कर सकते हैं, निश्चित रूप से, लेकिन अन्य संक्रमण वास्तव में इस चौरसाई एल्गोरिथ्म द्वारा मदद नहीं करते हैं। आप यह भी गारंटी नहीं दे सकते कि आपके नक्शे में कोई 90 डिग्री संक्रमण नहीं होगा। क्षमा करें, मुझे लगता है कि यह थोड़ा कम है।
परफेक्शनिस्ट

3

मैं कुछ इसी तरह के साथ खेल रहा था, यह कई कारणों से समाप्त नहीं हुआ था; लेकिन मूल रूप से यह 0 और 1 का एक मैट्रिक्स ले जाएगा, 0 जमीन और 1 जा रहा है और फ्लैश में एक भूलभुलैया जनरेटर आवेदन के लिए एक दीवार है। चूंकि एएस 3 जावास्क्रिप्ट के समान है, इसलिए जेएस में फिर से लिखना मुश्किल नहीं होगा।

var tileDimension:int = 20;
var levelNum:Array = new Array();

levelNum[0] = [1, 1, 1, 1, 1, 1, 1, 1, 1];
levelNum[1] = [1, 0, 0, 0, 0, 0, 0, 0, 1];
levelNum[2] = [1, 0, 1, 1, 1, 0, 1, 0, 1];
levelNum[3] = [1, 0, 1, 0, 1, 0, 1, 0, 1];
levelNum[4] = [1, 0, 1, 0, 0, 0, 1, 0, 1];
levelNum[5] = [1, 0, 0, 0, 0, 0, 0, 0, 1];
levelNum[6] = [1, 0, 1, 1, 1, 1, 0, 0, 1];
levelNum[7] = [1, 0, 0, 0, 0, 0, 0, 0, 1];
levelNum[8] = [1, 1, 1, 1, 1, 1, 1, 1, 1];

for (var rows:int = 0; rows < levelNum.length; rows++)
{
    for (var cols:int = 0; cols < levelNum[rows].length; cols++)
    {
        // set up neighbours
        var toprow:int = rows - 1;
        var bottomrow:int = rows + 1;

        var westN:int = cols - 1;
        var eastN:int = cols + 1;

        var rightMax =  levelNum[rows].length;
        var bottomMax = levelNum.length;

        var northwestTile =     (toprow != -1 && westN != -1) ? levelNum[toprow][westN] : 1;
        var northTile =         (toprow != -1) ? levelNum[toprow][cols] : 1;
        var northeastTile =     (toprow != -1 && eastN < rightMax) ? levelNum[toprow][eastN] : 1;

        var westTile =          (cols != 0) ? levelNum[rows][westN] : 1;
        var thistile =          levelNum[rows][cols];
        var eastTile =          (eastN == rightMax) ? 1 : levelNum[rows][eastN];

        var southwestTile =     (bottomrow != bottomMax && westN != -1) ? levelNum[bottomrow][westN] : 1;
        var southTile =         (bottomrow != bottomMax) ? levelNum[bottomrow][cols] : 1;
        var southeastTile =     (bottomrow != bottomMax && eastN < rightMax) ? levelNum[bottomrow][eastN] : 1;

        if (thistile == 1)
        {
            var w7:Wall7 = new Wall7();
            addChild(w7);
            pushTile(w7, cols, rows, 0);

            // wall 2 corners

            if      (northTile === 0 && northeastTile === 0 && eastTile === 1 && southeastTile === 1 && southTile === 1 && southwestTile === 0 && westTile === 0 && northwestTile === 0)
            {
                var w21:Wall2 = new Wall2();
                addChild(w21);
                pushTile(w21, cols, rows, 270);
            }

            else if (northTile === 0 && northeastTile === 0 && eastTile === 0 && southeastTile === 0 && southTile === 1 && southwestTile === 1 && westTile === 1 && northwestTile === 0)
            {
                var w22:Wall2 = new Wall2();
                addChild(w22);
                pushTile(w22, cols, rows, 0);
            }

            else if (northTile === 1 && northeastTile === 0 && eastTile === 0 && southeastTile === 0 && southTile === 0 && southwestTile === 0 && westTile === 1 && northwestTile === 1)
            {
                var w23:Wall2 = new Wall2();
                addChild(w23);
                pushTile(w23, cols, rows, 90);
            }

            else if (northTile === 1 && northeastTile === 1 && eastTile === 1 && southeastTile === 0 && southTile === 0 && southwestTile === 0 && westTile === 0 && northwestTile === 0)
            {
                var w24:Wall2 = new Wall2();
                addChild(w24);
                pushTile(w24, cols, rows, 180);
            }           

            //  wall 6 corners

            else if (northTile === 1 && northeastTile === 1 && eastTile === 1 && southeastTile === 0 && southTile === 1 && southwestTile === 1 && westTile === 1 && northwestTile === 1)
            {
                var w61:Wall6 = new Wall6();
                addChild(w61);
                pushTile(w61, cols, rows, 0); 
            }

            else if (northTile === 1 && northeastTile === 1 && eastTile === 1 && southeastTile === 1 && southTile === 1 && southwestTile === 0 && westTile === 1 && northwestTile === 1)
            {
                var w62:Wall6 = new Wall6();
                addChild(w62);
                pushTile(w62, cols, rows, 90); 
            }

            else if (northTile === 1 && northeastTile === 1 && eastTile === 1 && southeastTile === 1 && southTile === 1 && southwestTile === 1 && westTile === 1 && northwestTile === 0)
            {
                var w63:Wall6 = new Wall6();
                addChild(w63);
                pushTile(w63, cols, rows, 180);
            }

            else if (northTile === 1 && northeastTile === 0 && eastTile === 1 && southeastTile === 1 && southTile === 1 && southwestTile === 1 && westTile === 1 && northwestTile === 1)
            {
                var w64:Wall6 = new Wall6();
                addChild(w64);
                pushTile(w64, cols, rows, 270);
            }

            //  single wall tile

            else if (northTile === 0 && northeastTile === 0 && eastTile === 0 && southeastTile === 0 && southTile === 0 && southwestTile === 0 && westTile === 0 && northwestTile === 0)
            {
                var w5:Wall5 = new Wall5();
                addChild(w5);
                pushTile(w5, cols, rows, 0);
            }

            //  wall 3 walls

            else if (northTile === 0 && eastTile === 1 && southTile === 0 && westTile === 1)
            {
                var w3:Wall3 = new Wall3();
                addChild(w3);
                pushTile(w3, cols, rows, 0);
            }

            else if (northTile === 1 && eastTile === 0 && southTile === 1 && westTile === 0)
            {
                var w31:Wall3 = new Wall3();
                addChild(w31);
                pushTile(w31, cols, rows, 90);
            }

            //  wall 4 walls

            else if (northTile === 0 && eastTile === 0 && southTile === 1 && westTile === 0)
            {
                var w41:Wall4 = new Wall4();
                addChild(w41);
                pushTile(w41, cols, rows, 0);
            }

            else if (northTile === 1 && eastTile === 0 && southTile === 0 && westTile === 0)
            {
                var w42:Wall4 = new Wall4();
                addChild(w42);
                pushTile(w42, cols, rows, 180);
            }

            else if (northTile === 0 && northeastTile === 0 && eastTile === 1 && southeastTile === 0 && southTile === 0 && southwestTile === 0 && westTile === 0 && northwestTile === 0)
            {
                var w43:Wall4 = new Wall4();
                addChild(w43);
                pushTile(w43, cols, rows, 270);
            }

            else if (northTile === 0 && northeastTile === 0 && eastTile === 0 && southeastTile === 0 && southTile === 0 && southwestTile === 0 && westTile === 1 && northwestTile === 0)
            {
                var w44:Wall4 = new Wall4();
                addChild(w44);
                pushTile(w44, cols, rows, 90);
            }

            //  regular wall blocks

            else if (northTile === 1 && eastTile === 0 && southTile === 1 && westTile === 1)
            {
                var w11:Wall1 = new Wall1();
                addChild(w11);
                pushTile(w11, cols, rows, 90);
            }

            else if (northTile === 1 && eastTile === 1 && southTile === 1 && westTile === 0)
            {
                var w12:Wall1 = new Wall1();
                addChild(w12);
                pushTile(w12, cols, rows, 270);
            }

            else if (northTile === 0 && eastTile === 1 && southTile === 1 && westTile === 1)
            {
                var w13:Wall1 = new Wall1();
                addChild(w13);
                pushTile(w13, cols, rows, 0);
            }

            else if (northTile === 1 && eastTile === 1 && southTile === 0 && westTile === 1)
            {
                var w14:Wall1 = new Wall1();
                addChild(w14);
                pushTile(w14, cols, rows, 180);
            }

        }
        // debug === // trace('Top Left: ' + northwestTile + ' Top Middle: ' + northTile + ' Top Right: ' + northeastTile + ' Middle Left: ' + westTile + ' This: ' + levelNum[rows][cols] + ' Middle Right: ' + eastTile + ' Bottom Left: ' + southwestTile + ' Bottom Middle: ' + southTile + ' Bottom Right: ' + southeastTile);
    }
}

function pushTile(til:Object, tx:uint, ty:uint, degrees:uint):void
{
    til.x = tx * tileDimension;
    til.y = ty * tileDimension;
    if (degrees != 0) tileRotate(til, degrees);
}

function tileRotate(tile:Object, degrees:uint):void
{
    // http://www.flash-db.com/Board/index.php?topic=18625.0
    var midPoint:int = tileDimension/2;
    var point:Point=new Point(tile.x+midPoint, tile.y+midPoint);
    var m:Matrix=tile.transform.matrix;
    m.tx -= point.x;
    m.ty -= point.y;
    m.rotate (degrees*(Math.PI/180));
    m.tx += point.x;
    m.ty += point.y;
    tile.transform.matrix=m;
}

मूल रूप से यह जाँच करता है कि इसके चारों ओर हर टाइल बाएं से दाएं, ऊपर से नीचे तक जा रही है और मानती है कि किनारे की टाइलें हमेशा 1 होती हैं। मैंने एक कुंजी के रूप में उपयोग करने के लिए छवियों को फ़ाइल के रूप में निर्यात करने की स्वतंत्रता भी ली है:

दीवार की टाइलें

यह अधूरा है और शायद इसे प्राप्त करने के लिए एक हैकिंग तरीका है, लेकिन मैंने सोचा कि यह कुछ लाभ हो सकता है।

संपादित करें: उस कोड के परिणाम का स्क्रीनशॉट।

उत्पन्न परिणाम


1

मैं कुछ बातें सुझाऊंगा:

  • इससे कोई फर्क नहीं पड़ता कि "केंद्र" टाइल क्या सही है? यह 2 हो सकता है, लेकिन अगर अन्य सभी 1 हैं, तो यह 1 दिखाएगा?

  • यह केवल यही मायने रखता है कि कोने क्या हैं, जब ऊपर या बगल के तत्काल पड़ोसियों में अंतर होता है। यदि सभी तत्काल पड़ोसी 1 हैं, और एक कोने में 2 है, तो यह 1 दिखाएगा।

  • मैं शायद पड़ोसियों के सभी संभावित संयोजनों का पहले से अनुमान लगा लूंगा, पहले चार / नीचे के पड़ोसियों के मूल्यों को दर्शाने वाले ४ इंडेक्स सरणी और दूसरे को विकर्णों का संकेत देने वाला:

किनारों [एन] [ई] [एस] [डब्ल्यू] [एनई] [एसई] [एसडब्ल्यू] [एनडब्ल्यू] = जो भी स्प्राइट में ऑफसेट है

इसलिए आपके मामले में, [२] [२] [१] [१] [२] [२] [१] [१] = ४ (५ वां अंकुर)।

इस मामले में, [1] [१] [१] [१] १, [२] [२] [२] [२] २ होगा, और बाकी काम करना होगा। लेकिन एक विशेष टाइल के लिए खोज तुच्छ होगी।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.