forked from mirrors/kolyah35-minecraft-pe-0.6.1
Infinite world, LuaJIT mod API, WorldEdit port, skins and music
- Infinite world: streamed chunk cache, multi-region storage (old chunks.dat still loads), per-chunk entity/tile entity persistence, client chunk streaming, protocol version 10, view-distance server property - LuaJIT mod host (mods/, lua/prelude.lua) with events, commands, world and player API; WorldEdit command set ported to it (mods/worldedit) - /skin command, SetSkinPacket and bundled skins - OGG music player (data/music is ignored, tools/convert-music.ps1) - package-windows.ps1 builds client and dedicated server for Windows Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
db9f6c9f32
commit
110cb2a896
68 changed files with 5064 additions and 844 deletions
120
mods/README.md
Normal file
120
mods/README.md
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
# Lua mods (LuaJIT)
|
||||
|
||||
The game embeds **LuaJIT 2.1**. Mods run on the machine that hosts the world:
|
||||
the dedicated server (`MinecraftPE-server.exe`), a single player world, or a
|
||||
client that hosts a LAN game. A client that only joins a server runs no mods.
|
||||
|
||||
```
|
||||
mods/
|
||||
my_mod/
|
||||
main.lua <- loaded at startup (alphabetical order)
|
||||
other.lua <- require("other")
|
||||
tiny.lua <- a single file mod works too
|
||||
```
|
||||
|
||||
Every mod runs in its own environment (`MOD.name`, `MOD.dir` describe it), so
|
||||
globals do not leak between mods. `require("x")` loads `mods/<mod>/x.lua` first.
|
||||
The full Lua 5.1 standard library, `io`, `os`, `bit` and `ffi` are available –
|
||||
mods are trusted code, only install mods you trust.
|
||||
|
||||
## Events
|
||||
|
||||
```lua
|
||||
mc.on("start", function() end) -- all mods loaded, world is up
|
||||
mc.on("stop", function() end)
|
||||
mc.on("tick", function() end) -- 20 times per second
|
||||
mc.on("join", function(player) end)
|
||||
mc.on("leave", function(player) end)
|
||||
mc.on("chat", function(player, message) end) -- return false to cancel
|
||||
mc.on("block_break", function(player, x, y, z, tile) end)-- return false to cancel
|
||||
mc.on("use_item", function(player, x, y, z, face, itemId, itemData) end) -- right click on a block, false cancels
|
||||
```
|
||||
|
||||
## Commands
|
||||
|
||||
```lua
|
||||
mc.command("home", { description = "Go home", op = false }, function(ctx)
|
||||
ctx.player:teleport(0, 70, 0)
|
||||
return "Welcome home!" -- a returned string is sent to the player
|
||||
end)
|
||||
```
|
||||
|
||||
`ctx` has `player`, `args` (array of strings) and `name`. Names are what is typed
|
||||
after the first slash: `mc.command("/set", ...)` is `//set` in game. `op = true`
|
||||
restricts the command to operators (`ops.txt`).
|
||||
|
||||
## Players
|
||||
|
||||
`mc.players()`, `mc.player("name")`, `mc.broadcast(text)`
|
||||
|
||||
| method | |
|
||||
|---|---|
|
||||
| `p.name`, `p.id`, `p.data` | `data` is a free table for your mod |
|
||||
| `p:pos()` → x, y, z | feet position |
|
||||
| `p:block_pos()` → x, y, z | integer block of the feet |
|
||||
| `p:look()` → yaw, pitch | |
|
||||
| `p:facing()` → 0..3, dx, dz | south, west, north, east |
|
||||
| `p:teleport(x, y, z [, yaw, pitch])` | |
|
||||
| `p:say(text)` | private message |
|
||||
| `p:is_op()` | |
|
||||
| `p:held()` → id, data, count | |
|
||||
| `p:give(id [, count [, data]])` | |
|
||||
| `p:target([distance])` → x, y, z, face | block in the crosshair |
|
||||
| `p:gamemode()` | 0 survival, 1 creative |
|
||||
|
||||
## World
|
||||
|
||||
```lua
|
||||
mc.world.get_block(x, y, z) -- id, data
|
||||
mc.world.set_block(x, y, z, id, data) -- normal change (updates neighbours, notifies clients)
|
||||
mc.world.set_block(x, y, z, id, data, true) -- "silent": no updates; call mc.world.flush() afterwards
|
||||
mc.world.flush() -- relight + resend every chunk touched by silent writes
|
||||
mc.world.height(x, z) -- highest solid block, -1 if none
|
||||
mc.world.is_loaded(x, z) -- block coordinates
|
||||
mc.world.ensure_loaded(x, z, radiusInChunks)
|
||||
mc.world.spawn_mob(mc.mob.pig, x, y, z) -- returns entity id
|
||||
mc.world.drop_item(id, count, data, x, y, z)
|
||||
mc.world.explode(x, y, z, radius)
|
||||
mc.world.butcher(x, y, z, radius, includeFriendly) -- radius 0 = everywhere, returns count
|
||||
mc.world.get_time() / set_time(t) / seed()
|
||||
```
|
||||
|
||||
The world is infinite: chunks around players are generated, saved and unloaded
|
||||
on demand. Use `ensure_loaded` before touching far-away coordinates.
|
||||
|
||||
## Names and ids
|
||||
|
||||
`mc.block.parse("stone")`, `mc.block.parse("35:14")`, `mc.block.parse("red_wool")` → id, data
|
||||
`mc.block.name(id)`, `mc.item.wooden_axe`, `mc.mob.zombie`, …
|
||||
|
||||
## Scheduler and utilities
|
||||
|
||||
```lua
|
||||
local id = mc.after(40, function() ... end) -- ticks
|
||||
mc.every(20, function() ... end)
|
||||
mc.cancel(id)
|
||||
mc.log("text")
|
||||
mc.save_table("mods/data/x.lua", tbl) / mc.load_table(path, default)
|
||||
```
|
||||
|
||||
# Bundled mods
|
||||
|
||||
* **worldedit** – a port of EngineHub's WorldEdit command set (see below).
|
||||
* **hello** – the smallest possible example.
|
||||
|
||||
## WorldEdit
|
||||
|
||||
Give yourself the wand with `//wand` (a wooden axe): left click = position 1,
|
||||
right click = position 2. Operators only. Implemented commands:
|
||||
|
||||
`//wand //pos1 //pos2 //hpos1 //hpos2 //chunk //sel //expand //contract //shift //outset //inset //trim //size //count //distr`
|
||||
`//set //replace //overlay //center //naturalize //walls //faces //hollow //smooth //move //stack //line`
|
||||
`//sphere //hsphere //cyl //hcyl //cone //pyramid //hpyramid`
|
||||
`//copy //cut //paste //rotate //flip /clearclipboard /schematic save|load|list|delete`
|
||||
`/undo /redo /clearhistory //fill //fillr //drain /fixwater /fixlava /removeabove /removebelow /removenear /replacenear`
|
||||
`/snow /thaw /green /extinguish /butcher //limit /toggleplace /we`
|
||||
`/unstuck /ascend /descend /ceil /thru /jumpto /up`
|
||||
`/tool (repl, info, farwand, navwand, selwand, deltree, floodfill, none) /brush (sphere, cylinder, set, smooth, raise, lower, gravity, extinguish, butcher) /mask /material /range /size // /sp`
|
||||
|
||||
Patterns: `stone`, `35:14`, `red_wool`, `50%stone,50%dirt`. Masks: `stone,dirt`, `!air`,
|
||||
`#existing`, `#solid`. Flags work like in the original (`//sphere -h stone 5`).
|
||||
22
mods/hello.lua
Normal file
22
mods/hello.lua
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
-- The smallest mod: greets players and adds /hello and /where.
|
||||
|
||||
mc.on("join", function(player)
|
||||
player:say("Welcome, " .. player.name .. "! Lua mods are running on this world.")
|
||||
end)
|
||||
|
||||
mc.command("hello", { description = "Say hello" }, function(ctx)
|
||||
return "Hello, " .. ctx.player.name .. "!"
|
||||
end)
|
||||
|
||||
mc.command("where", { description = "Show your coordinates" }, function(ctx)
|
||||
local x, y, z = ctx.player:block_pos()
|
||||
return string.format("You are at %d, %d, %d", x, y, z)
|
||||
end)
|
||||
|
||||
mc.command("tp", { description = "Teleport: /tp <x> <y> <z>", usage = "/tp <x> <y> <z>", op = true }, function(ctx)
|
||||
local x, y, z = tonumber(ctx.args[1]), tonumber(ctx.args[2]), tonumber(ctx.args[3])
|
||||
if not (x and y and z) then return "Usage: /tp <x> <y> <z> (y = 0 puts you on the ground)" end
|
||||
if y <= 0 then mc.world.ensure_loaded(x, z, 1); y = mc.world.height(math.floor(x), math.floor(z)) + 1 end
|
||||
ctx.player:teleport(x + 0.5, y, z + 0.5)
|
||||
return string.format("Teleported to %d, %d, %d", x, y, z)
|
||||
end)
|
||||
450
mods/worldedit/lib.lua
Normal file
450
mods/worldedit/lib.lua
Normal file
|
|
@ -0,0 +1,450 @@
|
|||
-- WorldEdit for MinecraftPE: core library
|
||||
-- (edit sessions, patterns, masks, region helpers, shapes, history)
|
||||
|
||||
local L = {}
|
||||
|
||||
local floor, ceil, abs, min, max, sqrt = math.floor, math.ceil, math.abs, math.min, math.max, math.sqrt
|
||||
local get_block, set_block = mc.world.get_block, mc.world.set_block
|
||||
|
||||
L.DEFAULT_LIMIT = 5000000
|
||||
|
||||
-- =========================================================== player sessions
|
||||
local sessions = {}
|
||||
|
||||
function L.session(player)
|
||||
local s = sessions[player.name]
|
||||
if not s then
|
||||
s = {
|
||||
pos1 = nil, pos2 = nil,
|
||||
clipboard = nil,
|
||||
undo = {}, redo = {},
|
||||
limit = L.DEFAULT_LIMIT,
|
||||
tools = {}, -- item id -> { type = "repl"/"info"/"brush"/..., ... }
|
||||
superpick = nil, -- nil | "single" | "area" | "recursive"
|
||||
superpick_range = 3,
|
||||
brush_size = 5, brush_mask = nil, brush_material = nil, brush_range = 200,
|
||||
selector = "cuboid",
|
||||
}
|
||||
sessions[player.name] = s
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
-- ================================================================== helpers
|
||||
function L.region(s)
|
||||
if not s.pos1 or not s.pos2 then return nil end
|
||||
local a, b = s.pos1, s.pos2
|
||||
return {
|
||||
x0 = min(a[1], b[1]), y0 = min(a[2], b[2]), z0 = min(a[3], b[3]),
|
||||
x1 = max(a[1], b[1]), y1 = max(a[2], b[2]), z1 = max(a[3], b[3]),
|
||||
}
|
||||
end
|
||||
|
||||
function L.volume(r)
|
||||
return (r.x1 - r.x0 + 1) * (r.y1 - r.y0 + 1) * (r.z1 - r.z0 + 1)
|
||||
end
|
||||
|
||||
local function clampY(y) return max(0, min(127, y)) end
|
||||
L.clampY = clampY
|
||||
|
||||
--- Loads every chunk the region touches.
|
||||
function L.load_region(r)
|
||||
for cx = floor(r.x0 / 16), floor(r.x1 / 16) do
|
||||
for cz = floor(r.z0 / 16), floor(r.z1 / 16) do
|
||||
mc.world.ensure_loaded(cx * 16 + 8, cz * 16 + 8, 0)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local DIRS = {
|
||||
up = { 0, 1, 0 }, u = { 0, 1, 0 }, down = { 0, -1, 0 }, d = { 0, -1, 0 },
|
||||
north = { 0, 0, -1 }, n = { 0, 0, -1 }, south = { 0, 0, 1 }, s = { 0, 0, 1 },
|
||||
east = { 1, 0, 0 }, e = { 1, 0, 0 }, west = { -1, 0, 0 }, w = { -1, 0, 0 },
|
||||
}
|
||||
|
||||
--- Direction word -> unit vector. "me"/nil = where the player looks (incl. up/down)
|
||||
function L.direction(player, word)
|
||||
word = word and string.lower(word)
|
||||
if word and DIRS[word] then return DIRS[word] end
|
||||
local yaw, pitch = player:look()
|
||||
if pitch < -50 then return DIRS.up end
|
||||
if pitch > 50 then return DIRS.down end
|
||||
local _, dx, dz = player:facing()
|
||||
return { dx, 0, dz }
|
||||
end
|
||||
|
||||
--- Splits "-abc foo 5 -p 2" into flags and positional arguments.
|
||||
--- `valued` is a set of flags that take a value: { p = true }
|
||||
function L.parse(args, valued)
|
||||
local flags, pos = {}, {}
|
||||
local i = 1
|
||||
while i <= #args do
|
||||
local a = args[i]
|
||||
if a:match("^%-%a+$") and not tonumber(a) then
|
||||
for ch in a:sub(2):gmatch(".") do
|
||||
if valued and valued[ch] then
|
||||
i = i + 1
|
||||
flags[ch] = args[i]
|
||||
else
|
||||
flags[ch] = true
|
||||
end
|
||||
end
|
||||
else
|
||||
pos[#pos + 1] = a
|
||||
end
|
||||
i = i + 1
|
||||
end
|
||||
return flags, pos
|
||||
end
|
||||
|
||||
-- ================================================================== patterns
|
||||
-- "stone" "5%stone,5%dirt:1,air" "35:14"
|
||||
function L.pattern(text)
|
||||
if not text or text == "" then return nil, "No pattern given." end
|
||||
local entries, total = {}, 0
|
||||
for part in text:gmatch("[^,]+") do
|
||||
local weight, spec = part:match("^([%d%.]+)%%(.+)$")
|
||||
weight = tonumber(weight) or 1
|
||||
spec = spec or part
|
||||
local id, data = mc.block.parse(spec)
|
||||
if not id then return nil, "Unknown block: " .. spec end
|
||||
entries[#entries + 1] = { id = id, data = data, w = weight }
|
||||
total = total + weight
|
||||
end
|
||||
if #entries == 1 then
|
||||
local e = entries[1]
|
||||
return function() return e.id, e.data end, entries[1]
|
||||
end
|
||||
return function()
|
||||
local r = math.random() * total
|
||||
for _, e in ipairs(entries) do
|
||||
r = r - e.w
|
||||
if r <= 0 then return e.id, e.data end
|
||||
end
|
||||
local e = entries[#entries]
|
||||
return e.id, e.data
|
||||
end
|
||||
end
|
||||
|
||||
-- masks: "stone" "stone,dirt" "!air" "#existing" "#solid"
|
||||
function L.mask(text)
|
||||
if not text or text == "" then return nil end
|
||||
local negate = false
|
||||
if text:sub(1, 1) == "!" then negate = true; text = text:sub(2) end
|
||||
local test
|
||||
if text == "#existing" then
|
||||
test = function(id) return id ~= 0 end
|
||||
elseif text == "#solid" then
|
||||
test = function(id) return id ~= 0 and id ~= 8 and id ~= 9 and id ~= 10 and id ~= 11 end
|
||||
elseif text == "#air" then
|
||||
test = function(id) return id == 0 end
|
||||
else
|
||||
local set = {}
|
||||
for part in text:gmatch("[^,]+") do
|
||||
local id, data = mc.block.parse(part)
|
||||
if not id then return nil, "Unknown block: " .. part end
|
||||
set[#set + 1] = { id, data }
|
||||
end
|
||||
test = function(id, data)
|
||||
for _, e in ipairs(set) do
|
||||
if e[1] == id and (e[2] == nil or e[2] == data) then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
end
|
||||
if negate then return function(id, data) return not test(id, data) end end
|
||||
return test
|
||||
end
|
||||
|
||||
-- ============================================================== edit sessions
|
||||
local Edit = {}
|
||||
Edit.__index = Edit
|
||||
|
||||
function L.new_edit(session)
|
||||
return setmetatable({ s = session, entries = {}, index = {}, count = 0, limit = session.limit }, Edit)
|
||||
end
|
||||
|
||||
local OFFSET = 1000000
|
||||
|
||||
--- Sets a block (recording the old one for undo). Returns true when something changed.
|
||||
function Edit:set(x, y, z, id, data)
|
||||
if y < 0 or y > 127 then return false end
|
||||
data = data or 0
|
||||
local oid, od = get_block(x, y, z)
|
||||
if oid == id and od == data then return false end
|
||||
if self.limit >= 0 and self.count >= self.limit then
|
||||
self.overflow = true
|
||||
return false
|
||||
end
|
||||
if not self.bx then self.bx, self.bz = x, z end
|
||||
local key = ((x - self.bx + OFFSET) * 4000000 + (z - self.bz + OFFSET)) * 128 + y
|
||||
local e = self.index[key]
|
||||
if not e then
|
||||
e = { x, y, z, oid, od, id, data }
|
||||
self.index[key] = e
|
||||
self.entries[#self.entries + 1] = e
|
||||
else
|
||||
e[6], e[7] = id, data
|
||||
end
|
||||
self.count = self.count + 1
|
||||
set_block(x, y, z, id, data, true)
|
||||
return true
|
||||
end
|
||||
|
||||
function Edit:get(x, y, z)
|
||||
return get_block(x, y, z)
|
||||
end
|
||||
|
||||
--- Writes the pattern into the block
|
||||
function Edit:place(x, y, z, pattern)
|
||||
local id, data = pattern()
|
||||
return self:set(x, y, z, id, data)
|
||||
end
|
||||
|
||||
--- Finishes the edit: relights/resends the touched chunks and stores it in the history
|
||||
function Edit:commit()
|
||||
mc.world.flush()
|
||||
if #self.entries > 0 then
|
||||
local undo = self.s.undo
|
||||
undo[#undo + 1] = self.entries
|
||||
if #undo > 40 then table.remove(undo, 1) end
|
||||
self.s.redo = {}
|
||||
end
|
||||
return #self.entries
|
||||
end
|
||||
|
||||
local function apply_history(entries, reverse)
|
||||
local changed = 0
|
||||
if reverse then
|
||||
for i = #entries, 1, -1 do
|
||||
local e = entries[i]
|
||||
set_block(e[1], e[2], e[3], e[4], e[5], true)
|
||||
changed = changed + 1
|
||||
end
|
||||
else
|
||||
for i = 1, #entries do
|
||||
local e = entries[i]
|
||||
set_block(e[1], e[2], e[3], e[6], e[7], true)
|
||||
changed = changed + 1
|
||||
end
|
||||
end
|
||||
mc.world.flush()
|
||||
return changed
|
||||
end
|
||||
|
||||
function L.undo(s)
|
||||
local e = table.remove(s.undo)
|
||||
if not e then return nil end
|
||||
s.redo[#s.redo + 1] = e
|
||||
return apply_history(e, true)
|
||||
end
|
||||
|
||||
function L.redo(s)
|
||||
local e = table.remove(s.redo)
|
||||
if not e then return nil end
|
||||
s.undo[#s.undo + 1] = e
|
||||
return apply_history(e, false)
|
||||
end
|
||||
|
||||
-- ============================================================ region iteration
|
||||
function L.each(r, fn)
|
||||
for x = r.x0, r.x1 do
|
||||
for z = r.z0, r.z1 do
|
||||
for y = r.y0, r.y1 do
|
||||
fn(x, y, z)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function L.walls_and_faces(r, edit, pattern, floorAndCeil)
|
||||
L.each(r, function(x, y, z)
|
||||
local wall = x == r.x0 or x == r.x1 or z == r.z0 or z == r.z1
|
||||
local cap = y == r.y0 or y == r.y1
|
||||
if wall or (floorAndCeil and cap) then edit:place(x, y, z, pattern) end
|
||||
end)
|
||||
end
|
||||
|
||||
-- ================================================================== shapes
|
||||
local function lsq(x, y, z) return x * x + y * y + z * z end
|
||||
|
||||
--- WorldEdit's ellipsoid. (cx,cy,cz) is the centre block.
|
||||
function L.sphere(edit, cx, cy, cz, pattern, rx, ry, rz, filled)
|
||||
rx, ry, rz = rx + 0.5, ry + 0.5, rz + 0.5
|
||||
local irx, iry, irz = 1 / rx, 1 / ry, 1 / rz
|
||||
local crx, cry, crz = ceil(rx), ceil(ry), ceil(rz)
|
||||
local nextXn = 0
|
||||
for x = 0, crx do
|
||||
local xn = nextXn
|
||||
nextXn = (x + 1) * irx
|
||||
local nextYn = 0
|
||||
for y = 0, cry do
|
||||
local yn = nextYn
|
||||
nextYn = (y + 1) * iry
|
||||
local nextZn = 0
|
||||
for z = 0, crz do
|
||||
local zn = nextZn
|
||||
nextZn = (z + 1) * irz
|
||||
if lsq(xn, yn, zn) > 1 then break end
|
||||
local skip = false
|
||||
if not filled then
|
||||
if lsq(nextXn, yn, zn) <= 1 and lsq(xn, nextYn, zn) <= 1 and lsq(xn, yn, nextZn) <= 1 then
|
||||
skip = true
|
||||
end
|
||||
end
|
||||
if not skip then
|
||||
for sx = -1, 1, 2 do
|
||||
for sy = -1, 1, 2 do
|
||||
for sz = -1, 1, 2 do
|
||||
if (x ~= 0 or sx == 1) and (y ~= 0 or sy == 1) and (z ~= 0 or sz == 1) then
|
||||
edit:place(cx + sx * x, cy + sy * y, cz + sz * z, pattern)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function L.cylinder(edit, cx, cy, cz, pattern, rx, rz, height, filled)
|
||||
rx, rz = rx + 0.5, rz + 0.5
|
||||
if height == 0 then return end
|
||||
local irx, irz = 1 / rx, 1 / rz
|
||||
local crx, crz = ceil(rx), ceil(rz)
|
||||
local ys, ye = cy, cy + height - 1
|
||||
if height < 0 then ys, ye = cy + height + 1, cy end
|
||||
local nextXn = 0
|
||||
for x = 0, crx do
|
||||
local xn = nextXn
|
||||
nextXn = (x + 1) * irx
|
||||
local nextZn = 0
|
||||
for z = 0, crz do
|
||||
local zn = nextZn
|
||||
nextZn = (z + 1) * irz
|
||||
if lsq(xn, 0, zn) > 1 then break end
|
||||
local skip = false
|
||||
if not filled then
|
||||
if lsq(nextXn, 0, zn) <= 1 and lsq(xn, 0, nextZn) <= 1 then skip = true end
|
||||
end
|
||||
if not skip then
|
||||
for sx = -1, 1, 2 do
|
||||
for sz = -1, 1, 2 do
|
||||
if (x ~= 0 or sx == 1) and (z ~= 0 or sz == 1) then
|
||||
for y = ys, ye do
|
||||
edit:place(cx + sx * x, y, cz + sz * z, pattern)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function L.cone(edit, cx, cy, cz, pattern, rx, rz, height, filled)
|
||||
for h = 0, height - 1 do
|
||||
local f = 1 - h / height
|
||||
L.cylinder(edit, cx, cy + h, cz, pattern, max(0, rx * f), max(0, rz * f), 1, filled)
|
||||
end
|
||||
end
|
||||
|
||||
function L.pyramid(edit, cx, cy, cz, pattern, size, filled)
|
||||
local height = size
|
||||
for y = 0, height do
|
||||
size = size - 1
|
||||
for x = 0, size do
|
||||
for z = 0, size do
|
||||
if (filled and z <= size and x <= size) or z == size or x == size then
|
||||
edit:place(cx + x, cy + y, cz + z, pattern)
|
||||
edit:place(cx - x, cy + y, cz + z, pattern)
|
||||
edit:place(cx + x, cy + y, cz - z, pattern)
|
||||
edit:place(cx - x, cy + y, cz - z, pattern)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- Line through block space; thickness > 0 puts a sphere of that radius on every point.
|
||||
function L.line(edit, a, b, pattern, radius, filled)
|
||||
local dx, dy, dz = b[1] - a[1], b[2] - a[2], b[3] - a[3]
|
||||
local steps = max(abs(dx), abs(dy), abs(dz))
|
||||
local seen = {}
|
||||
for i = 0, steps do
|
||||
local t = steps == 0 and 0 or i / steps
|
||||
local x = floor(a[1] + dx * t + 0.5)
|
||||
local y = floor(a[2] + dy * t + 0.5)
|
||||
local z = floor(a[3] + dz * t + 0.5)
|
||||
if radius and radius > 0 then
|
||||
L.sphere(edit, x, y, z, pattern, radius, radius, radius, filled ~= false)
|
||||
else
|
||||
edit:place(x, y, z, pattern)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- ============================================================== block helpers
|
||||
local function is_air(id) return id == 0 end
|
||||
local LIQUID = { [8] = true, [9] = true, [10] = true, [11] = true }
|
||||
function L.is_liquid(id) return LIQUID[id] == true end
|
||||
function L.is_air(id) return is_air(id) end
|
||||
|
||||
--- Top block (y) that is not air within [y0, y1] for the column, or nil
|
||||
function L.top_existing(x, z, y0, y1)
|
||||
for y = y1, y0, -1 do
|
||||
if get_block(x, y, z) ~= 0 then return y end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
--- Top solid (non liquid/plant) block y in the column
|
||||
local PLANTS = { [6] = true, [31] = true, [37] = true, [38] = true, [39] = true, [40] = true, [50] = true,
|
||||
[51] = true, [59] = true, [83] = true, [78] = true, [81] = false, [18] = false }
|
||||
function L.top_ground(x, z, y0, y1)
|
||||
for y = y1, y0, -1 do
|
||||
local id = get_block(x, y, z)
|
||||
if id ~= 0 and not LIQUID[id] and not PLANTS[id] and id ~= 17 and id ~= 18 then return y end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- ======================================================== rotation of block data
|
||||
-- data values that point in a direction, rotated 90 degrees clockwise (y axis)
|
||||
local ROT = {
|
||||
stairs = { [0] = 2, [1] = 3, [2] = 1, [3] = 0 }, -- east,west,south,north
|
||||
torch = { [1] = 3, [2] = 4, [3] = 2, [4] = 1 },
|
||||
ladder = { [2] = 5, [3] = 4, [4] = 2, [5] = 3 }, -- chest, furnace, ladder, signs
|
||||
door = { [0] = 1, [1] = 2, [2] = 3, [3] = 0 },
|
||||
trapdoor = { [0] = 3, [1] = 2, [2] = 0, [3] = 1 },
|
||||
}
|
||||
local KIND = {
|
||||
[53] = "stairs", [67] = "stairs", [108] = "stairs", [109] = "stairs", [114] = "stairs", [128] = "stairs",
|
||||
[156] = "stairs",
|
||||
[50] = "torch", [75] = "torch", [76] = "torch",
|
||||
[65] = "ladder", [54] = "ladder", [61] = "ladder", [62] = "ladder", [68] = "ladder", [86] = "ladder",
|
||||
[91] = "ladder",
|
||||
[64] = "door", [71] = "door", [107] = "door",
|
||||
[96] = "trapdoor",
|
||||
}
|
||||
|
||||
function L.rotate_data(id, data, turns)
|
||||
local kind = KIND[id]
|
||||
if not kind then return data end
|
||||
local map = ROT[kind]
|
||||
turns = turns % 4
|
||||
for _ = 1, turns do
|
||||
local flags, d = 0, data
|
||||
if kind == "stairs" then
|
||||
flags = bit.band(d, 4); d = bit.band(d, 3)
|
||||
elseif kind == "door" or kind == "trapdoor" then
|
||||
flags = bit.band(d, bit.bnot(3)); d = bit.band(d, 3)
|
||||
end
|
||||
d = map[d] or d
|
||||
data = bit.bor(d, flags)
|
||||
end
|
||||
return data
|
||||
end
|
||||
|
||||
return L
|
||||
1574
mods/worldedit/main.lua
Normal file
1574
mods/worldedit/main.lua
Normal file
File diff suppressed because it is too large
Load diff
Loading…
Add table
Add a link
Reference in a new issue