मैं स्वयं इस समस्या को गोग्लिंग करके यहां पहुंचा, लिंक किए गए लेखों को पढ़ा, और एक अपेक्षाकृत कॉम्पैक्ट समाधान का उत्पादन किया जो 47 टाइलों के सामान्य सेट को उत्पन्न करता है। इसे इस तरह से ऑटोटेल्ड सामग्री के लिए 2x3 टाइलसेट की आवश्यकता होती है:
शीर्ष बाईं ओर एक एकल-टाइल संस्करण के साथ, ऊपरी दाएं कोने में आंतरिक कोने, और तल पर चार बाहरी कोने टाइल (आप आरपीजी निर्माता से इस व्यवस्था को पहचान सकते हैं)।
चाल के लिए प्रत्येक "तार्किक" नक्शा टाइल को 4 आधा टाइलों में तोड़ना है। इसके अलावा, टाइलसेट में एक आधा-टाइल केवल उत्पन्न टाइल में उस स्थिति में हो सकती है , इसलिए शीर्ष-बाएं आधा टाइल का उपयोग केवल शीर्ष-बाईं स्थिति में किया जा सकता है।
इन प्रतिबंधों का मतलब है कि आपको केवल सभी 8 पड़ोसी टाइलों के बजाय, आधे टाइल वाले प्रति पूर्ण-टाइल पड़ोसियों की जांच करने की आवश्यकता है।
मैंने इसका परीक्षण करने के लिए इस विचार को जल्दी से लागू किया। यहां प्रूफ-ऑफ-कॉन्सेप्ट कोड (टाइपस्क्रिप्ट):
//const dirs = { N: 1, E: 2, S: 4, W:8, NE: 16, SE: 32, SW: 64, NW: 128 };
const edges = { A: 1+8+128, B: 1+2+16, C: 4+8+64, D: 4+2+32 };
const mapA = { 0:8, 128:8, 1:16, 8:10, 9:2, 137:18, 136:10, 129:16 };
const mapB = { 0:11, 16:11, 1:19, 2:9, 3:3, 19:17, 18:9, 17:19 };
const mapC = { 0:20, 64:20, 4:12, 8:22, 12:6, 76:14, 72:22, 68:12 };
const mapD = { 0:23, 32:23, 4:15, 2:21, 6:7, 38:13, 34:21, 36:15 };
export function GenerateAutotileMap(_map: number[][], _tile: integer): number[][]
{
var result = [];
for (var y=0; y < _map.length; y++) {
const row = _map[y];
const Y = y*2;
// half-tiles
result[Y] = [];
result[Y+1] = [];
// each row
for (var x=0; x < row.length; x++) {
// get the tile
const t = row[x];
const X = x*2;
if (t != _tile) continue;
// Check nearby tile materials.
const neighbors = (North(_map, x, y) == t? 1:0)
+ (East(_map, x, y) == t? 2:0)
+ (South(_map, x, y) == t? 4:0)
+ (West(_map, x, y) == t? 8:0)
+ (NorthEast(_map, x, y) == t? 16:0)
+ (SouthEast(_map, x, y) == t? 32:0)
+ (SouthWest(_map, x, y) == t? 64:0)
+ (NorthWest(_map, x, y) == t? 128:0);
// Isolated tile
if (neighbors == 0) {
result[Y][X] = 0;
result[Y][X+1] = 1;
result[Y+1][X] = 4;
result[Y+1][X+1] = 5;
continue;
}
// Find half-tiles.
result[Y][X] = mapA[neighbors & edges.A];
result[Y][X+1] = mapB[neighbors & edges.B];
result[Y+1][X] = mapC[neighbors & edges.C];
result[Y+1][X+1] = mapD[neighbors & edges.D];
}
}
return result;
}
स्पष्टीकरण:
Aटाइल का ऊपरी बाएँ भाग Bहै, ऊपर दाईं ओर Cहै, नीचे बाएँ भाग पर Dहै, नीचे दाईं ओर है।edges इनमें से प्रत्येक के लिए बिटमास्क रखती है, इसलिए हम केवल संबंधित पड़ोसी जानकारी हड़प सकते हैं।map* टाइल्स की छवि में ग्राफिक सूचकांकों के लिए पड़ोसी राज्यों की मैपिंग के शब्दकोश हैं (0..24)।
- चूंकि प्रत्येक अर्ध-टाइल 3 पड़ोसियों की जांच करती है, प्रत्येक में 2 ^ 3 = 8 राज्य होते हैं।
_tile ऑटोटाइलिंग के लिए लक्षित टाइल है। - चूंकि हमारी तार्किक टाइलें हमारी रेंडरिंग टाइल्स से दोगुनी हैं, इसलिए सभी ऑटोटाइल कॉर्ड्स (x, y) को रेंडरिंग मैप में दोगुना होना चाहिए।
वैसे भी, यहाँ परिणाम हैं (केवल एक टाइल के साथ, वैसे भी):