wip: rework placement logic

tree.lua

 local leds = {
-    30,
-    20,
-    10,
-    5,
-    2,
+    32,
+    28,
+    16,
+    8,
+    4,
 }
 
 local height_increment = 3
-local size = (#leds + 1) * 2
 
-local function place_tree(pos)
-    local set = {}
-    local iled = 0
-    local blocks_per_layer = {}
-    for iy = 0, size - 1 do
-        blocks_per_layer[iy] = 0
-        for ix = iy, size - 1 - iy do
-            for iz = iy, size - 1 - iy do
-                for h = 0, height_increment - 1 do
-                    table.insert(set, {x = pos.x + ix, y = pos.y + iy * height_increment + h, z = pos.z + iz})
-                    iled = iled + 1
-                    blocks_per_layer[iy] = blocks_per_layer[iy] + 1
+local function breite(n)
+    return n / 4
+end
+
+local function is_led(center, breite, pos)
+    if math.abs(center.x - pos.x) >= (breite - 1) / 2 and math.abs(center.z - pos.z) >= (breite - 1) / 2 then
+        return false
+    end
+    if math.abs(center.x - pos.x) == (breite - 1) / 2 then
+        return math.abs(center.z - pos.z) % 2 == 0
+    end
+    if math.abs(center.z - pos.z) == (breite - 1) / 2 then
+        return math.abs(center.x - pos.x) % 2 == 0
+    end
+end
+
+local function place_layer(center, breite)
+    breite = breite * 2 + 1
+    local needles = {}
+    local leds = {}
+    local max_offset = math.ceil(breite / 2)
+    for y = -height_increment / 2, height_increment / 2 do
+        for x = -max_offset, max_offset do
+            for z = -max_offset, max_offset do
+                local pos = vector.new({x = center.x + x, y = center.y + y, z = center.z + z})
+                table.insert(needles, pos)
+                if is_led(center, breite, pos) then
+                    table.insert(leds, pos)
                 end
             end
         end
-        blocks_per_layer[iy] = blocks_per_layer[iy] / height_increment
-        blocks_per_layer[iy] = math.sqrt(blocks_per_layer[iy]) * 4 - 4
     end
-    minetest.bulk_set_node(set, {name = "ledtree:pine_needles"})
-
-    local loop_run = 0
-    local id = 0
-    for iy = 0, size - 1 do
-        loop_run = loop_run + 1
-
-        if loop_run <= #leds then
-            local led_count = leds[iy + 1]
-            local led_per_side = math.ceil(led_count / 4)
-
-            local layer_size = size - 2 * iy
-            local led_index = 1
-
-            for ix = iy, iy + layer_size - 1 do
-                for iz = iy, iy + layer_size - 1 do
-                    if led_index <= led_count then
-                        local led_pos = {}
-
-                        if (ix == iy or ix == iy + layer_size - 1 or iz == iy or iz == iy + layer_size - 1) then
-                            if not ((ix == iy and iz == iy) or (ix == iy and iz == iy + layer_size - 1) or
-                                    (ix == iy + layer_size - 1 and iz == iy) or (ix == iy + layer_size - 1 and iz == iy + layer_size - 1)) then
-                                led_pos.x = pos.x + ix
-                                led_pos.z = pos.z + iz
-
-                                led_pos.y = pos.y + iy * height_increment + math.floor(height_increment / 2)
+    core.bulk_set_node(needles, {name = "ledtree:pine_needles"})
+    return leds
+end
 
-                                core.set_node({x = led_pos.x, y = led_pos.y, z = led_pos.z}, {name = "ledtree:led"..id.."_red"})
-                                id = id + 1
+local function place_leds(led_index, leds)
+    for i = 1, #leds do
+        core.set_node(leds[i], {name = "ledtree:led"..led_index.."_red"})
+        led_index = led_index + 1
+    end
+    return led_index
+end
 
-                                led_index = led_index + 1
-                            end
-                        end
-                    end
-                end
-            end
-        end
+local function place_tree(pos)
+    local led_index = 0
+    for index = 1, #leds do
+        local l = leds[index]
+        local layer_center = vector.new(pos.x, pos.y + index * height_increment - height_increment / 2, pos.z)
+        local leds = place_layer(layer_center, breite(l))
+        led_index = place_leds(led_index, leds)
     end
 end