88 lines
2.5 KiB
GDScript
88 lines
2.5 KiB
GDScript
extends Node
|
|
|
|
#Master list of chunks
|
|
var _chunks: Array[Chunk] = []
|
|
|
|
#Create some test samples - these samples must ALWAYS be 9-elements long, 5th element is the result
|
|
#var _samples: Array[PackedInt32Array] = [
|
|
#[1,1,1, 1,1,1, 1,1,1],
|
|
#]
|
|
|
|
@onready
|
|
var wfc: Node = get_node("../Generator")
|
|
|
|
@onready
|
|
var map: TileMapLayer = get_node("../TileMapLayer")
|
|
|
|
func _ready() -> void:
|
|
var ruleset: PackedInt32Array = read_sample_ruleset("sample2.png")
|
|
var samples: Array[PackedInt32Array] = parse_samples_from_ruleset(ruleset)
|
|
var c: Chunk = wfc.generate_chunk_at(0,0,_chunks,samples)
|
|
#TODO: build a visual layout for the results
|
|
#TODO: handle the chunk-edges
|
|
|
|
#print(ruleset)
|
|
#print(samples)
|
|
print(c.data)
|
|
draw_map_data(c)
|
|
|
|
## Read the png file, and parse it to a useable ruleset
|
|
func read_sample_ruleset(filename: String) -> PackedInt32Array:
|
|
var img: Image = Image.load_from_file(filename)
|
|
var png: PackedByteArray = img.get_data()
|
|
var hex: PackedInt32Array = []
|
|
|
|
@warning_ignore("integer_division")
|
|
var size: int = (png.size() / 3)
|
|
hex.resize(size)
|
|
|
|
#print(png)
|
|
for i in range(size): #the file is assumed to be in RGB format
|
|
hex[i] = (png[i * 3] << 16) | (png[i * 3 + 1] << 8) | (png[i * 3 + 2] << 0)
|
|
#print(i, "(", hex[i], "): ", png[i * 3], ",", png[i * 3 + 1], ",", png[i * 3 + 2])
|
|
return hex
|
|
|
|
func parse_samples_from_ruleset(ruleset: PackedInt32Array) -> Array[PackedInt32Array]:
|
|
#for now, assume the ruleset is 8x8
|
|
const RULESET_WIDTH: int = 8
|
|
const RULESET_HEIGHT: int = 8
|
|
|
|
#using a custom container type
|
|
var samples: Set = Set.new()
|
|
|
|
for x in range(1, RULESET_WIDTH-1):
|
|
for y in range(1, RULESET_HEIGHT-1):
|
|
var sample: PackedInt32Array = [
|
|
ruleset[(y -1) * RULESET_WIDTH + (x -1)],
|
|
ruleset[(y -1) * RULESET_WIDTH + (x )],
|
|
ruleset[(y -1) * RULESET_WIDTH + (x +1)],
|
|
|
|
ruleset[(y ) * RULESET_WIDTH + (x -1)],
|
|
ruleset[(y ) * RULESET_WIDTH + (x )],
|
|
ruleset[(y ) * RULESET_WIDTH + (x +1)],
|
|
|
|
ruleset[(y +1) * RULESET_WIDTH + (x -1)],
|
|
ruleset[(y +1) * RULESET_WIDTH + (x )],
|
|
ruleset[(y +1) * RULESET_WIDTH + (x +1)],
|
|
]
|
|
|
|
samples.add(sample)
|
|
|
|
var result: Array[PackedInt32Array] = []
|
|
result.assign(samples.elements())
|
|
return result
|
|
|
|
func draw_map_data(chunk: Chunk) -> void:
|
|
#hacky
|
|
var fix = func(x) -> int:
|
|
match x:
|
|
0x000000: return 0
|
|
0xFF0000: return 1
|
|
0x00FF00: return 2
|
|
0x0000FF: return 3
|
|
_: return -1
|
|
|
|
for x in range(Chunk.CHUNK_WIDTH):
|
|
for y in range(Chunk.CHUNK_HEIGHT):
|
|
map.set_cell(Vector2i(x, y), fix.call(chunk.data[y * Chunk.CHUNK_WIDTH + x]), Vector2i.ZERO)
|