अद्यतन: नक्शा प्रतिपादन एल्गोरिदम सही, और अधिक चित्रण, प्रारूप बदल दिया।
शायद स्क्रीन पर टाइल्स मानचित्रण के लिए "zig-zag" तकनीक के लिए लाभ में कहा जा सकता है कि टाइल के x और y निर्देशांक ऊर्ध्वाधर और क्षैतिज अक्ष पर कर रहे हैं।
"एक हीरे में आकर्षित" दृष्टिकोण:
एक सममितीय मानचित्र का उपयोग "एक हीरे में ड्राइंग" है, जो मेरा मानना है कि सिर्फ दो से अधिक एक नेस्टेड for -loop का उपयोग करके नक्शा प्रतिपादन के लिए संदर्भित करता ड्राइंग तक इस उदाहरण के रूप में आयामी सरणी,:
tile_map[][] = [[...],...]
for (cellY = 0; cellY < tile_map.size; cellY++):
for (cellX = 0; cellX < tile_map[cellY].size cellX++):
draw(
tile_map[cellX][cellY],
screenX = (cellX * tile_width/2) + (cellY * tile_width/2)
screenY = (cellY * tile_height/2) - (cellX * tile_height/2)
)
लाभ:
लाभ दृष्टिकोण करने के लिए है यह है कि एक साधारण नेस्टेड for - काफी सीधे आगे तर्क के साथ लूप जो सभी टाइल्स में लगातार काम करता है।
नुकसान: कि दृष्टिकोण को
एक नकारात्मक पक्ष यह है कि नक्शे पर टाइल्स की x और y निर्देशांक विकर्ण लाइनों में वृद्धि होगी, इसे और अधिक मुश्किल बना सकता है जो नेत्रहीन स्क्रीन पर स्थान मैप करने के लिए है एक सरणी के रूप में प्रतिनिधित्व नक्शा करने के लिए:
हालांकि, वहाँ ऊपर के उदाहरण कोड को लागू करने के लिए एक ख़तरा होने जा रहा है - प्रतिपादन आदेश टाइल्स का कारण होगा कि कुछ टाइल्स के पीछे होने की अपेक्षा की जाती है सामने टाइल्स के ऊपर बनाए जा रहे हैं:
इस समस्या में संशोधन करने के लिए, आंतरिक for -loop के आदेश वापस ले लिया जाना चाहिए - उच्चतम मूल्य से शुरू , और कम मूल्य की ओर प्रतिपादन:
tile_map[][] = [[...],...]
for (i = 0; i < tile_map.size; i++):
for (j = tile_map[i].size; j >= 0; j--): // Changed loop condition here.
draw(
tile_map[i][j],
x = (j * tile_width/2) + (i * tile_width/2)
y = (i * tile_height/2) - (j * tile_height/2)
)
ऊपर फिक्स के साथ
, नक्शे का प्रतिपादन सही किया जाना चाहिए:
"zig-zag" दृष्टिकोण:
लाभ:
शायद "zig-zag" दृष्टिकोण का लाभ यह है कि प्रदान की गई नक्शा एक छोटे से अधिक खड़ी कॉम्पैक्ट प्रतीत हो सकता है है "हीरा" दृष्टिकोण:
नुकसान:
टेढ़े-मेढ़ी तकनीक को लागू करने की कोशिश कर रहा से, नुकसान हो सकता है कि यह एक छोटा सा कठिन है प्रतिपादन कोड लिखने के लिए है, क्योंकि यह एक सरणी में प्रत्येक तत्व पर एक नेस्टेड for -loop के रूप में सरल रूप में नहीं लिखा जा सकता है:
नोट:: चित्र शामिल
tile_map[][] = [[...],...]
for (i = 0; i < tile_map.size; i++):
if i is odd:
offset_x = tile_width/2
else:
offset_x = 0
for (j = 0; j < tile_map[i].size; j++):
draw(
tile_map[i][j],
x = (j * tile_width) + offset_x,
y = i * tile_height/2
)
इसके अलावा, यह प्रतिपादन आदेश के कंपित प्रकृति के कारण एक छोटा सा मुश्किल यह पता लगाने की एक टाइल का समन्वय करने की कोशिश करना हो सकता है इस मै रों जवाब है, प्रस्तुत टाइल प्रतिपादन कोड का एक जावा कार्यान्वयन के साथ बनाए गए थे नक्शे के रूप में निम्नलिखित int सरणी के साथ:
tileMap = new int[][] {
{0, 1, 2, 3},
{3, 2, 1, 0},
{0, 0, 1, 1},
{2, 2, 3, 3}
};
टाइल चित्र हैं:
tileImage[0] -> एक बॉक्स के अंदर के साथ एक बॉक्स।tileImage[1] -> एक काला बॉक्स।tileImage[2] -> एक सफेद बॉक्स।tileImage[3] -> इसमें एक लंबा ग्रे ऑब्जेक्ट वाला एक बॉक्स।
टाइल चौड़ाई पर एक नोट और हाइट्स
चर tile_width और tile_height जो ऊपर कोड उदाहरण में उपयोग किया जाता चौड़ाई और छवि टाइल का प्रतिनिधित्व करने में जमीन टाइल की ऊंचाई का संदर्भ लें:
छवि के आयामों का उपयोग करना काम करेंगे, जब तक छवि आयाम और टाइल आयाम मैच के रूप में। अन्यथा, टाइल मानचित्र को टाइल्स के बीच अंतराल के साथ प्रस्तुत किया जा सकता है।
आपने चित्रों को भी खींचा। यह प्रयास है। – zaratustra
चीयर्स कोबर्ड। मैं वर्तमान खेल के लिए हीरा दृष्टिकोण का उपयोग कर रहा हूं, मैं विकास कर रहा हूं और यह एक इलाज कर रहा है। एक बार फिर धन्यवाद। –
चीजों को सुनने के लिए खुशी हुई है :) शुभकामनाएँ! – coobird