From 5897870725704d039a7f836e744e5b60a541987d Mon Sep 17 00:00:00 2001 From: Aran Roig Date: Wed, 7 Oct 2026 19:13:25 +0200 Subject: [PATCH] Shell and folders --- AGENTS.md | 3 +- docs/lua-api.md | 64 +- .../com/aranroig/client/CodecraftClient.java | 32 + .../client/editor/CompletionProvider.java | 207 +----- .../client/editor/EditorDocsPanel.java | 2 +- .../client/editor/EditorFileTree.java | 515 +++++++++++++- .../client/editor/EditorFileView.java | 294 +++++++- .../aranroig/client/editor/EditorManager.java | 553 ++++++++++++++- .../aranroig/client/editor/EditorPane.java | 34 + .../client/editor/EditorPaneContainer.java | 633 ++++++++++++++++++ .../aranroig/client/editor/EditorScreen.java | 40 +- .../client/editor/EditorTerminalPane.java | 308 +++++++++ .../aranroig/client/editor/EditorTopBar.java | 92 ++- .../aranroig/client/editor/EventsLibrary.java | 30 + .../aranroig/client/editor/LiveDocument.java | 109 +++ .../aranroig/client/editor/LuaLibrary.java | 21 + .../aranroig/client/editor/LuaSnippets.java | 85 +++ .../client/editor/LuaStandardLibraries.java | 120 ++++ .../client/editor/TerminalEmulator.java | 629 +++++++++++++++++ .../client/editor/TextEditorScreen.java | 24 +- .../com/aranroig/client/editor/Widget.java | 6 +- .../aranroig/client/editor/WorldLibrary.java | 26 + src/main/java/com/aranroig/Codecraft.java | 155 +++-- .../java/com/aranroig/SavedProjectData.java | 27 +- .../com/aranroig/collab/DocumentManager.java | 453 +++++++++++++ .../java/com/aranroig/docs/LuaApiDocs.java | 223 +++--- src/main/java/com/aranroig/editor/Edit.java | 338 ++++++++++ .../java/com/aranroig/editor/EditorFile.java | 4 + .../com/aranroig/editor/EditorPresence.java | 43 ++ .../java/com/aranroig/editor/ProjectPath.java | 55 ++ .../com/aranroig/listeners/EventsApi.java | 55 ++ .../com/aranroig/listeners/GameEvent.java | 49 ++ .../com/aranroig/listeners/ScriptRuntime.java | 119 ++++ .../listeners/ScriptRuntimeManager.java | 186 +++++ .../ClientboundDocumentEditPayload.java | 41 ++ .../ClientboundDocumentStatePayload.java | 39 ++ .../payloads/ClientboundEditAckPayload.java | 44 ++ .../payloads/ClientboundPresencePayload.java | 39 ++ .../ClientboundRenameFilePayload.java | 36 + .../ClientboundShellClosedPayload.java | 31 + .../ClientboundShellOutputPayload.java | 32 + .../ServerboundCloseEditorPayload.java | 27 + .../ServerboundCloseShellPayload.java | 26 + .../payloads/ServerboundCursorPayload.java | 38 ++ .../payloads/ServerboundEditPayload.java | 40 ++ .../ServerboundOpenDocumentPayload.java | 35 + .../ServerboundRenameFilePayload.java | 37 + .../ServerboundShellInputPayload.java | 34 + .../ServerboundShellResizePayload.java | 37 + .../ServerboundSpawnShellPayload.java | 34 + .../java/com/aranroig/shell/ShellManager.java | 115 ++++ .../java/com/aranroig/shell/ShellSession.java | 535 +++++++++++++++ .../data/codecraft/docs/lua-api.json | 322 +++++++++ 53 files changed, 6626 insertions(+), 450 deletions(-) create mode 100644 src/client/java/com/aranroig/client/editor/EditorPane.java create mode 100644 src/client/java/com/aranroig/client/editor/EditorPaneContainer.java create mode 100644 src/client/java/com/aranroig/client/editor/EditorTerminalPane.java create mode 100644 src/client/java/com/aranroig/client/editor/EventsLibrary.java create mode 100644 src/client/java/com/aranroig/client/editor/LiveDocument.java create mode 100644 src/client/java/com/aranroig/client/editor/LuaLibrary.java create mode 100644 src/client/java/com/aranroig/client/editor/LuaSnippets.java create mode 100644 src/client/java/com/aranroig/client/editor/LuaStandardLibraries.java create mode 100644 src/client/java/com/aranroig/client/editor/TerminalEmulator.java create mode 100644 src/client/java/com/aranroig/client/editor/WorldLibrary.java create mode 100644 src/main/java/com/aranroig/collab/DocumentManager.java create mode 100644 src/main/java/com/aranroig/editor/Edit.java create mode 100644 src/main/java/com/aranroig/editor/EditorPresence.java create mode 100644 src/main/java/com/aranroig/editor/ProjectPath.java create mode 100644 src/main/java/com/aranroig/listeners/EventsApi.java create mode 100644 src/main/java/com/aranroig/listeners/GameEvent.java create mode 100644 src/main/java/com/aranroig/listeners/ScriptRuntime.java create mode 100644 src/main/java/com/aranroig/listeners/ScriptRuntimeManager.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundDocumentEditPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundDocumentStatePayload.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundEditAckPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundPresencePayload.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundRenameFilePayload.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundShellClosedPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ClientboundShellOutputPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundCloseEditorPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundCloseShellPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundCursorPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundEditPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundOpenDocumentPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundRenameFilePayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundShellInputPayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundShellResizePayload.java create mode 100644 src/main/java/com/aranroig/payloads/ServerboundSpawnShellPayload.java create mode 100644 src/main/java/com/aranroig/shell/ShellManager.java create mode 100644 src/main/java/com/aranroig/shell/ShellSession.java create mode 100644 src/main/resources/data/codecraft/docs/lua-api.json diff --git a/AGENTS.md b/AGENTS.md index 6e72b50..1e4faf1 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -28,13 +28,14 @@ Flow: client editor → custom payloads → server → persisted project. - **Networking** (`com.aranroig.payloads`): one record per message implementing `CustomPacketPayload` with a static `TYPE` and `StreamCodec`. Serverbound payloads must be registered in `Codecraft.onInitialize()` via `PayloadTypeRegistry.serverboundPlay().register(...)`, and received with `ServerPlayNetworking.registerGlobalReceiver(...)`. - **Persistence** (`SavedProjectData`): a `SavedData` stored in the overworld (`saved_project_data`). Holds the list of `EditorFile`s that make up the user's project. -- **Editor UI** (`com.aranroig.client.editor`): a custom immediate-mode-ish GUI system, not vanilla widgets. `EditorScreen` routes key/mouse input to `Widget`s by hit-testing (`inside()`) and z-index. `EditorManager` owns the widgets and editor actions (save/run/etc.); `EditorFileTree`, `EditorTopBar`, `EditorFileView` are the three panels. `EditorFileView` is the actual text editor; `LuaHighlighter` tokenizes lines into colored `Span`s and `CompletionProvider` handles autocomplete. +- **Editor UI** (`com.aranroig.client.editor`): a custom immediate-mode-ish GUI system, not vanilla widgets. `EditorScreen` routes key/mouse input to `Widget`s by hit-testing (`inside()`) and z-index; scrolling goes to the widget under the mouse. `EditorManager` owns the widgets and editor actions (save/run/etc.); `EditorFileTree`, `EditorTopBar`, `EditorPaneContainer` are the three panels. `EditorPaneContainer` tiles the editing area into one or more `EditorFileView` panes (split right/below from the pane headers, the View menu, or Ctrl+\ / Ctrl+Shift+\), each header naming its file; the sashes between panes drag to resize them, and the "active pane" (last pane clicked) is where files from the tree open and where saving applies. `EditorFileView` is the actual text editor; `LuaHighlighter` tokenizes lines into colored `Span`s and `CompletionProvider` handles autocomplete. - **Lua runtime**: `EditorManager.run()` sends a `ServerboundRunCodePayload` with the entrypoint name; the server handler in `Codecraft.java` is a TODO (currently just prints). Example of embedding: `Lua l = new LuaJ(); l.register("print", Logger.print()); l.run(code);` — `com.aranroig.client.wrapper.Logger` adapts a `LuaFunction` to print into the player chat. Decide carefully whether Lua runs client- or server-side; server-side is the apparent direction. ## Conventions - Use `Codecraft.id(path)` / `Identifier.fromNamespaceAndPath(MOD_ID, path)` for all ids, and the `Codecraft.LOGGER` (slf4j) instead of `System.out.println` for new logging. - Data classes that cross both persistence and network layers (see `EditorFile`) carry both a Mojang `Codec` and a `StreamCodec`; `RunInfo` currently only has a stream codec. +- A file's name is the **path** it lives at: `lib/gui/theme`, `/`-separated, no extension. `com.aranroig.editor.ProjectPath` is the only thing that reads one; to the server and to the live-document map a name is still an opaque unique key. `EditorFileTree` groups by the folders in those names (folders exist while something is in them, and folding one is client-side view state on `EditorManager`), and `ProjectPath.ENTRYPOINT` (`main`) is what a run executes. - Records are used for payloads/simple data; match the style of the file you're editing (entrypoint classes from the Fabric template use tabs, editor code uses 4 spaces). - Translation keys follow `key.codecraft.*` / `key.category.codecraft.*`. - Mixin configs: `codecraft.mixins.json` (common, package `com.aranroig.mixin`) and `codecraft.client.mixins.json` (client). `ExampleMixin` / `ExampleClientMixin` are template leftovers. diff --git a/docs/lua-api.md b/docs/lua-api.md index f89a026..684c6b6 100644 --- a/docs/lua-api.md +++ b/docs/lua-api.md @@ -9,7 +9,8 @@ This same documentation is browsable in-game from the editor: Because a script runs on the server thread from start to finish, everything it does happens at once and the game waits for it to finish. Loops that place millions of -blocks will freeze the server, so keep them reasonable. +blocks will freeze the server, so keep them reasonable. A script can also keep +listening *after* it has finished, with [events](#events). ```lua print("hello, player!") @@ -91,6 +92,67 @@ if block ~= "minecraft:air" then end ``` +## Events + +Listeners let a script react to the game *after* it has finished running. Register one +with `events.on_(callback)`; from then on the callback runs whenever the event +happens. + +| Registration | Callback signature | +| ----------------------------------- | ----------------------------------------------------------- | +| `events.on_use_item(cb)` | `cb(player, item, count, hand)` | +| `events.on_break_block(cb)` | `cb(player, x, y, z, block)` | +| `events.on_chat(cb)` | `cb(player, message)` | +| `events.on_player_join(cb)` | `cb(player)` | +| `events.on_player_leave(cb)` | `cb(player)` | +| `events.on_tick(cb)` | `cb(tick)` | + +`player` is always the name of the player who caused the event. Other values depend on +the event: + +- **on_use_item** — fires when a player right-clicks to use the item in their hand: + `item` is the item id (`"minecraft:stick"`), `count` the stack size, and `hand` + `"main"` or `"off"`. An empty hand does not fire. The click still does whatever it + would normally do — the listener only observes it. +- **on_break_block** — fires *after* the block is broken (`x, y, z` now hold air), + with the id of the block that was there. +- **on_chat** — fires with the plain text of the message. The message is sent to chat + as usual. +- **on_player_join / on_player_leave** — fire when a player joins or leaves, including + the running player themselves. +- **on_tick** — fires at the end of every server tick with the tick counter, a whole + number that grows by one every tick (20 ticks per second). Keep tick callbacks + cheap: they run twenty times a second, and a slow one lags the whole server. + +Callbacks run on the server thread and have the same powers as the script that +registered them — they can call `print` and the `world` functions. An error inside a +callback is printed to the owner's chat; it never stops the game or the other +listeners. + +```lua +events.on_use_item(function(player, item, count, hand) + if item == "minecraft:stick" then + print(player .. " waved a stick (" .. hand .. " hand)") + end +end) + +events.on_break_block(function(player, x, y, z, block) + if block == "minecraft:diamond_ore" then + print(player .. " struck diamond at " .. x .. ", " .. y .. ", " .. z) + end +end) +``` + +### Listening resets + +Pressing **Run Script** replaces the previous run completely: all listeners from the +previous run are dropped, and only the ones the new run registers are active. If a run +registers none, the old listeners go quiet. Likewise, when the running player +disconnects their script stops with them — a script cannot outlive its owner. + +If you run the same script twice, its listeners are *not* doubled — each run starts +from a clean slate. + ## Examples A pillar four blocks tall: diff --git a/src/client/java/com/aranroig/client/CodecraftClient.java b/src/client/java/com/aranroig/client/CodecraftClient.java index 646289b..0c4dc92 100644 --- a/src/client/java/com/aranroig/client/CodecraftClient.java +++ b/src/client/java/com/aranroig/client/CodecraftClient.java @@ -2,8 +2,15 @@ package com.aranroig.client; import com.aranroig.Codecraft; import com.aranroig.client.editor.EditorManager; +import com.aranroig.payloads.ClientboundDocumentEditPayload; +import com.aranroig.payloads.ClientboundDocumentStatePayload; +import com.aranroig.payloads.ClientboundEditAckPayload; +import com.aranroig.payloads.ClientboundPresencePayload; import com.aranroig.payloads.ClientboundProjectFilesPayload; +import com.aranroig.payloads.ClientboundRenameFilePayload; import com.aranroig.payloads.ClientboundSaveCodePayload; +import com.aranroig.payloads.ClientboundShellClosedPayload; +import com.aranroig.payloads.ClientboundShellOutputPayload; import com.mojang.blaze3d.platform.InputConstants; import net.fabricmc.api.ClientModInitializer; import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; @@ -44,6 +51,31 @@ public class CodecraftClient implements ClientModInitializer { ClientPlayNetworking.registerGlobalReceiver(ClientboundSaveCodePayload.TYPE, (payload, context) -> editorOverlay.upsertFile(payload.data())); + ClientPlayNetworking.registerGlobalReceiver(ClientboundRenameFilePayload.TYPE, (payload, context) -> + editorOverlay.applyFileRename(payload.oldName(), payload.newName())); + + // Live editing: the server's copy of a file, other players' edits, the + // ack of our own, and who else is in the file with us. + ClientPlayNetworking.registerGlobalReceiver(ClientboundDocumentStatePayload.TYPE, (payload, context) -> + editorOverlay.applyDocumentState(payload.file(), payload.text(), payload.version())); + + ClientPlayNetworking.registerGlobalReceiver(ClientboundDocumentEditPayload.TYPE, (payload, context) -> + editorOverlay.applyRemoteDocumentEdit(payload.file(), payload.version(), payload.edit())); + + ClientPlayNetworking.registerGlobalReceiver(ClientboundEditAckPayload.TYPE, (payload, context) -> + editorOverlay.applyEditAck(payload.file(), payload.version(), payload.textHash(), payload.textLength())); + + ClientPlayNetworking.registerGlobalReceiver(ClientboundPresencePayload.TYPE, (payload, context) -> + editorOverlay.applyPresence(payload.file(), payload.editors())); + + // The terminal pane: what the server's shell printed, and the news + // that it stopped. + ClientPlayNetworking.registerGlobalReceiver(ClientboundShellOutputPayload.TYPE, (payload, context) -> + editorOverlay.applyShellOutput(payload.text())); + + ClientPlayNetworking.registerGlobalReceiver(ClientboundShellClosedPayload.TYPE, (payload, context) -> + editorOverlay.applyShellClosed(payload.reason())); + ClientTickEvents.END_CLIENT_TICK.register(client -> { while(openEditor.consumeClick()){ if(client.player != null) { diff --git a/src/client/java/com/aranroig/client/editor/CompletionProvider.java b/src/client/java/com/aranroig/client/editor/CompletionProvider.java index 7543425..d47c9bb 100644 --- a/src/client/java/com/aranroig/client/editor/CompletionProvider.java +++ b/src/client/java/com/aranroig/client/editor/CompletionProvider.java @@ -8,9 +8,11 @@ import java.util.regex.Pattern; * Generates autocomplete suggestions for Lua code given the current text * buffer and cursor position. The provider combines: *
    - *
  1. A static list of Lua keywords, built-in globals, and standard library members.
  2. + *
  3. A static list of Lua keywords, built-in globals, and + * {@link LuaSnippets snippets}.
  4. *
  5. Words already present in the buffer (user-defined functions/variables).
  6. - *
  7. Library member completion after a "." or ":" trigger.
  8. + *
  9. Library member completion after a "." or ":" trigger, backed by the + * {@link LuaLibrary} instances loaded in {@link #registerLibraries()}.
  10. *
* * None of this requires a real LSP – it is "good-enough" IDE-lite completion @@ -48,194 +50,33 @@ public class CompletionProvider { // ── Built-in global tables (as types) ──────────────────────────── for (String lib : new String[]{ "string", "table", "math", "io", "os", "coroutine", - "package", "utf8", "debug", "_G", "_VERSION", "world" + "package", "utf8", "debug", "_G", "_VERSION", "world", "events" }) items.add(CompletionItem.type(lib)); // ── Common snippets ─────────────────────────────────────────────── - items.add(CompletionItem.snippet("fun", - "function ()\n \nend", - "anonymous function")); - items.add(CompletionItem.snippet("function", - "function name()\n \nend", - "named function")); - items.add(CompletionItem.snippet("lfun", - "local function name()\n \nend", - "local function")); - items.add(CompletionItem.snippet("if", - "if then\n \nend", - "if block")); - items.add(CompletionItem.snippet("ifel", - "if then\n \nelse\n \nend", - "if / else")); - items.add(CompletionItem.snippet("ifelseif", - "if then\n \nelseif then\n \nelse\n \nend", - "if / elseif / else")); - items.add(CompletionItem.snippet("for", - "for i = 1, do\n \nend", - "numeric for")); - items.add(CompletionItem.snippet("forin", - "for k, v in pairs() do\n \nend", - "generic for (pairs)")); - items.add(CompletionItem.snippet("fori", - "for i, v in ipairs() do\n \nend", - "generic for (ipairs)")); - items.add(CompletionItem.snippet("while", - "while do\n \nend", - "while loop")); - items.add(CompletionItem.snippet("repeat", - "repeat\n \nuntil ", - "repeat / until")); - items.add(CompletionItem.snippet("pcall", - "local ok, err = pcall(function()\n \nend)", - "protected call")); - items.add(CompletionItem.snippet("class", - "local ClassName = {}\nClassName.__index = ClassName\n\nfunction ClassName.new()\n local self = setmetatable({}, ClassName)\n return self\nend\n\nreturn ClassName", - "OOP class template")); - items.add(CompletionItem.snippet("require", - "local = require(\"\")", - "require module")); - items.add(CompletionItem.snippet("print", - "print()", - "print(…)")); - items.add(CompletionItem.snippet("setblock", - "world.set_block(, , , \"minecraft:stone\")", - "world.set_block(…)")); - items.add(CompletionItem.snippet("removeblock", - "world.remove_block(, , )", - "world.remove_block(…)")); - items.add(CompletionItem.snippet("getblock", - "local block = world.get_block(, , )", - "world.get_block(…)")); - items.add(CompletionItem.snippet("local", - "local = ", - "local variable")); - items.add(CompletionItem.snippet("return", - "return ", - "return statement")); + items.addAll(LuaSnippets.all()); STATIC_ITEMS = Collections.unmodifiableList(items); - // ── Library member tables ───────────────────────────────────────── - Map> libs = new LinkedHashMap<>(); + LIBRARY_MEMBERS = Collections.unmodifiableMap(registerLibraries()); + } - // string.* - List stringLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"byte", "byte(", "string.byte(s [,i [,j]])"}, - {"char", "char(", "string.char(…)"}, - {"dump", "dump(", "string.dump(func)"}, - {"find", "find(", "string.find(s, pattern [,init])"}, - {"format", "format(", "string.format(fmt, …)"}, - {"gmatch", "gmatch(", "string.gmatch(s, pattern)"}, - {"gsub", "gsub(", "string.gsub(s, pattern, repl)"}, - {"len", "len(", "string.len(s)"}, - {"lower", "lower(", "string.lower(s)"}, - {"match", "match(", "string.match(s, pattern [,init])"}, - {"rep", "rep(", "string.rep(s, n [,sep])"}, - {"reverse", "reverse(", "string.reverse(s)"}, - {"sub", "sub(", "string.sub(s, i [,j])"}, - {"upper", "upper(", "string.upper(s)"}, - }) stringLib.add(CompletionItem.method(m[0] + "(", m[1])); - libs.put("string", stringLib); + /** + * Loads the libraries whose members are offered after a dot or colon. + * To expose a new codecraft-provided table in the autocomplete popup, + * implement {@link LuaLibrary} and add an instance here. + */ + private static Map> registerLibraries() { + List libraries = new ArrayList<>(); + libraries.addAll(LuaStandardLibraries.all()); // Lua's own standard library + libraries.add(new WorldLibrary()); // block access provided by codecraft + libraries.add(new EventsLibrary()); // game event listeners provided by codecraft - // table.* - List tableLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"concat", "concat(", "table.concat(t [,sep [,i [,j]]])"}, - {"insert", "insert(", "table.insert(t [,pos], value)"}, - {"move", "move(", "table.move(a1, f, e, t [,a2])"}, - {"pack", "pack(", "table.pack(…)"}, - {"remove", "remove(", "table.remove(t [,pos])"}, - {"sort", "sort(", "table.sort(t [,comp])"}, - {"unpack", "unpack(", "table.unpack(t [,i [,j]])"}, - }) tableLib.add(CompletionItem.method(m[0] + "(", m[1])); - libs.put("table", tableLib); - - // math.* - List mathLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"abs", "abs(", "math.abs(x)"}, - {"ceil", "ceil(", "math.ceil(x)"}, - {"cos", "cos(", "math.cos(x)"}, - {"exp", "exp(", "math.exp(x)"}, - {"floor", "floor(", "math.floor(x)"}, - {"fmod", "fmod(", "math.fmod(x, y)"}, - {"log", "log(", "math.log(x [,base])"}, - {"max", "max(", "math.max(x, …)"}, - {"min", "min(", "math.min(x, …)"}, - {"modf", "modf(", "math.modf(x)"}, - {"pow", "pow(", "math.pow(x, y)"}, - {"random", "random(", "math.random([m [,n]])"}, - {"randomseed", "randomseed(", "math.randomseed(x)"}, - {"sin", "sin(", "math.sin(x)"}, - {"sqrt", "sqrt(", "math.sqrt(x)"}, - {"tan", "tan(", "math.tan(x)"}, - {"tointeger", "tointeger(", "math.tointeger(x)"}, - {"type", "type(", "math.type(x)"}, - {"huge", "huge", "math.huge (∞)"}, - {"pi", "pi", "math.pi"}, - {"maxinteger", "maxinteger", "math.maxinteger"}, - {"mininteger", "mininteger", "math.mininteger"}, - }) mathLib.add(CompletionItem.method(m[0], m[1])); - libs.put("math", mathLib); - - // io.* - List ioLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"close", "close(", "io.close([file])"}, - {"flush", "flush()", "io.flush()"}, - {"input", "input(", "io.input([file])"}, - {"lines", "lines(", "io.lines([filename])"}, - {"open", "open(", "io.open(filename [,mode])"}, - {"output", "output(", "io.output([file])"}, - {"popen", "popen(", "io.popen(prog [,mode])"}, - {"read", "read(", "io.read(…)"}, - {"tmpfile", "tmpfile()", "io.tmpfile()"}, - {"type", "type(", "io.type(obj)"}, - {"write", "write(", "io.write(…)"}, - }) ioLib.add(CompletionItem.method(m[0], m[1])); - libs.put("io", ioLib); - - // os.* - List osLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"clock", "clock()", "os.clock()"}, - {"date", "date(", "os.date([format [,time]])"}, - {"difftime", "difftime(", "os.difftime(t2, t1)"}, - {"execute", "execute(", "os.execute([command])"}, - {"exit", "exit(", "os.exit([code])"}, - {"getenv", "getenv(", "os.getenv(varname)"}, - {"remove", "remove(", "os.remove(filename)"}, - {"rename", "rename(", "os.rename(oldname, newname)"}, - {"setlocale","setlocale(","os.setlocale(locale [,category])"}, - {"time", "time(", "os.time([table])"}, - {"tmpname", "tmpname()", "os.tmpname()"}, - }) osLib.add(CompletionItem.method(m[0], m[1])); - libs.put("os", osLib); - - // coroutine.* - List coLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"create", "create(", "coroutine.create(f)"}, - {"isyieldable", "isyieldable()", "coroutine.isyieldable()"}, - {"resume", "resume(", "coroutine.resume(co [,…])"}, - {"running", "running()", "coroutine.running()"}, - {"status", "status(", "coroutine.status(co)"}, - {"wrap", "wrap(", "coroutine.wrap(f)"}, - {"yield", "yield(", "coroutine.yield(…)"}, - }) coLib.add(CompletionItem.method(m[0], m[1])); - libs.put("coroutine", coLib); - - // world.* — block access provided by codecraft itself - List worldLib = new ArrayList<>(); - for (String[] m : new String[][]{ - {"set_block", "set_block(", "world.set_block(x, y, z, \"minecraft:stone\")"}, - {"remove_block", "remove_block(", "world.remove_block(x, y, z [,drops])"}, - {"get_block", "get_block(", "world.get_block(x, y, z)"}, - }) worldLib.add(CompletionItem.method(m[0], m[1])); - libs.put("world", worldLib); - - LIBRARY_MEMBERS = Collections.unmodifiableMap(libs); + Map> members = new LinkedHashMap<>(); + for (LuaLibrary library : libraries) { + members.put(library.name(), library.members()); + } + return members; } // Lua identifier chars (no $ unlike Java) @@ -351,4 +192,4 @@ public class CompletionProvider { if (i + 1 >= nameEnd) return null; // nothing before the separator return buffer.substring(i + 1, nameEnd); } -} \ No newline at end of file +} diff --git a/src/client/java/com/aranroig/client/editor/EditorDocsPanel.java b/src/client/java/com/aranroig/client/editor/EditorDocsPanel.java index 0979c69..599340e 100644 --- a/src/client/java/com/aranroig/client/editor/EditorDocsPanel.java +++ b/src/client/java/com/aranroig/client/editor/EditorDocsPanel.java @@ -442,7 +442,7 @@ public class EditorDocsPanel extends Widget { // ── Input handling ──────────────────────────────────────────────────── @Override - public boolean handleMouseClicked(MouseButtonEvent event) { + public boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick) { if (!visible) return false; int mx = (int) event.x(); int my = (int) event.y(); diff --git a/src/client/java/com/aranroig/client/editor/EditorFileTree.java b/src/client/java/com/aranroig/client/editor/EditorFileTree.java index 9ad98ec..d3c2ec7 100644 --- a/src/client/java/com/aranroig/client/editor/EditorFileTree.java +++ b/src/client/java/com/aranroig/client/editor/EditorFileTree.java @@ -1,57 +1,400 @@ package com.aranroig.client.editor; import com.aranroig.editor.EditorFile; +import com.aranroig.editor.EditorPresence; +import com.aranroig.editor.ProjectPath; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GuiGraphicsExtractor; import net.minecraft.client.input.CharacterEvent; import net.minecraft.client.input.KeyEvent; import net.minecraft.client.input.MouseButtonEvent; +import net.minecraft.util.Mth; import org.jspecify.annotations.NonNull; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; +/** + * The sidebar: the project's files, grouped into the folders their names carry. + * A folder folds away with a click on its row, a file opens with a click on its + * own, and double-clicking a file renames it where it is listed. + */ public class EditorFileTree extends Widget { private static final int COLOR_TEXT = 0xFFFFFFFF; - private static final int COLOR_BACKGROUND = 0xFF202020; + private static final int COLOR_BACKGROUND = 0xFF202020; + private static final int COLOR_RENAME_BG = 0xFF3A3A3A; + private static final int COLOR_ROW_OPEN = 0xFF2E2E2E; + private static final int COLOR_ROW_FOLDER = 0xFF2A3138; + + // Folder amber, file paper-grey; the darker shade draws the lines of both. + private static final int COLOR_FOLDER = 0xFFC79A55; + private static final int COLOR_FOLDER_OPEN = 0xFFE8BC6E; + private static final int COLOR_FOLDER_SEAM = 0xFF8A683A; + private static final int COLOR_FILE = 0xFFA9BCCB; + private static final int COLOR_FILE_LINES = 0xFF5F7484; + private static final int COLOR_CHEVRON = 0xFFB4B4B4; + + private static final int MAX_NAME_LENGTH = 64; + + private static final int PADDING_X = 3; + private static final int INDENT = 8; + private static final int ICON_WIDTH = 8; + private static final int ICON_GAP = 5; + private static final int CHEVRON_WIDTH = 7; + private static final int CHEVRON_GAP = 2; + private static final int PRESENCE_GUTTER = 6; + private static final int SCROLL_STEP = 3; + + // ── Icons ───────────────────────────────────────────────────────────── + // Pixel patterns rather than textures: '#' is the icon's colour, '-' a + // darker line of it, '.' nothing. They are a screen pixel each, so they stay + // sharp at any GUI scale. + + private static final String[] ICON_FILE = { + ".######.", + ".#----#.", + ".######.", + ".#----#.", + ".######.", + ".#----#.", + ".######.", + }; + + /** A folder: tab on the left, lid just under the top edge. */ + private static final String[] ICON_FOLDER = { + "###.....", + "########", + "#------#", + "########", + ".######.", + }; + + /** Pointing right: the folder is folded. */ + private static final String[] ICON_COLLAPSED = { + "#...", + ".#..", + "..#.", + "...#", + "..#.", + ".#..", + "#...", + }; + + /** Pointing down: the folder is unfolded and what is in it is listed. */ + private static final String[] ICON_EXPANDED = { + "#.....#", + ".#...#.", + "..#.#..", + "...#...", + }; + + /** Siblings of the same folder, alphabetically whatever their case is. */ + private static final Comparator BY_NAME = (a, b) -> { + int order = a.compareToIgnoreCase(b); + return order != 0 ? order : a.compareTo(b); + }; public EditorFileTree(EditorManager editorManager) { super(editorManager); } + // ── The tree as rows ────────────────────────────────────────────────── + + /** + * One line of the sidebar: a folder, or a file with its {@code file} next to + * it. {@code path} is the file's path or the folder's, and it is the key the + * fold state, the presence stripes and the rename field all work with. + * A row marked {@code creating} is the field a new folder is being typed into, + * which is drawn as a text field and stands for no file or folder of its own. + */ + private record Row(String path, String label, int depth, EditorFile file, boolean creating) { + boolean isFolder() { + return file == null; + } + } + + /** What the sidebar looks like right now, top to bottom, folded folders left out. */ + private List rows = List.of(); + + /** Pixels of content scrolled out of view at the top. */ + private int scroll; + + /** + * Groups the files by the folder in their name and walks that structure into + * the rows to draw: the folders of a folder first, then its files, each in + * alphabetical order. A folded folder stops the walk there, so what is hidden + * is not even a row to click on. + */ + private List buildRows() { + Map> filesByFolder = new HashMap<>(); + Map> childrenByFolder = new HashMap<>(); + + for (EditorFile file : editorManager.getFiles()) { + String folder = ProjectPath.folderOf(file.getName()); + filesByFolder.computeIfAbsent(folder, key -> new ArrayList<>()).add(file); + + // Register that folder with every folder above it: a folder holding + // nothing but folders is a folder all the same. + registerWithAncestors(folder, childrenByFolder); + } + + // Folders made from the sidebar that nothing lives in yet: they carry no + // file to spell their path, so they are added here and read back out of + // {@link EditorManager} every rebuild, which keeps them in place across + // an editor close and open. + for (String folder : editorManager.getCustomFolders()) { + registerWithAncestors(folder, childrenByFolder); + } + + rows = new ArrayList<>(); + appendContents("", 0, rows, filesByFolder, childrenByFolder); + clampScroll(rows); + return rows; + } + + /** Lists {@code folder} (and each folder above it) among its parent's children. */ + private static void registerWithAncestors(String folder, Map> childrenByFolder) { + for (String current = folder; !current.isEmpty(); current = ProjectPath.folderOf(current)) { + childrenByFolder + .computeIfAbsent(ProjectPath.folderOf(current), key -> new TreeSet<>(BY_NAME)) + .add(current); + } + } + + private void appendContents(String folder, int depth, List rows, + Map> filesByFolder, + Map> childrenByFolder) { + // A new folder is typed in right at the top of the folder it is being + // made in, as its first child. + if (creatingFolder && folder.equals(newFolderParent)) { + rows.add(new Row("", "", depth, null, true)); + } + + for (String child : childrenByFolder.getOrDefault(folder, Set.of())) { + rows.add(new Row(child, ProjectPath.displayNameOf(child), depth, null, false)); + if (!editorManager.isFolderFolded(child)) { + appendContents(child, depth + 1, rows, filesByFolder, childrenByFolder); + } + } + + List files = filesByFolder.get(folder); + if (files == null) return; + + files.sort(Comparator.comparing((EditorFile file) -> ProjectPath.displayNameOf(file.getName()), BY_NAME)); + for (EditorFile file : files) { + rows.add(new Row(file.getName(), ProjectPath.displayNameOf(file.getName()), depth, file, false)); + } + } + + // ── Drawing ─────────────────────────────────────────────────────────── + public void draw(@NonNull GuiGraphicsExtractor graphics, int mouseX, int mouseY, double delta) { graphics.fill(getStartX(), getStartY(), getEndX(), getEndY(), COLOR_BACKGROUND); Font font = editorScreen.getFont(); int lineH = font.lineHeight; - List files = editorManager.getFiles(); - for(int i = 0; i < files.size(); i++) { - graphics.text(font, files.get(i).getName(), getStartX(), getStartY() + i * lineH, COLOR_TEXT, true); + graphics.enableScissor(getStartX(), getStartY(), getEndX(), getEndY()); + int y = getStartY() - scroll; + for (Row row : buildRows()) { + if (y >= getEndY()) break; // the rest of the list is scrolled below + + drawRow(graphics, font, row, y, lineH); + y += lineH; + } + graphics.disableScissor(); + } + + private void drawRow(GuiGraphicsExtractor graphics, Font font, Row row, int y, int lineH) { + // A new folder being named takes the whole row for itself, like a rename. + if (row.creating()) { + int textX = getStartX() + PADDING_X + INDENT * row.depth(); + drawField(graphics, font, newFolderText, textX, y, lineH); + return; + } + + EditorFile openFile = editorManager.getCurrentFile(); + + // Compared by name, not by object: the list the server sent holds its own + // copy of the file the view is editing. + boolean isOpenFile = row.file != null && openFile != null && row.file.getName().equals(openFile.getName()); + + if (isOpenFile) graphics.fill(getStartX(), y, getEndX(), y + lineH, COLOR_ROW_OPEN); + else if (row.isFolder() && editorManager.getSelectedFolder().equals(row.path())) + graphics.fill(getStartX(), y, getEndX(), y + lineH, COLOR_ROW_FOLDER); + + // A coloured stripe beside a file means somebody else has it open. + // Up to three of them fit; more than that just keeps the first. + List editors = row.isFolder() ? List.of() : editorManager.presenceFor(row.path()); + + // Where the label of the row starts, worked out before anything is drawn: + // the field of a name being renamed lines up with it. The presence gutter + // is reserved for every file, edited or not, so all file names line up + // whether or not somebody has one open (an empty gutter stands in for the + // stripes). The icon always reserves it too, so the label must match. + int textX = getStartX() + PADDING_X + INDENT * row.depth(); + if (!row.isFolder()) textX += PRESENCE_GUTTER; + if (row.isFolder()) textX += CHEVRON_WIDTH + CHEVRON_GAP; + textX += ICON_WIDTH + ICON_GAP; + + // A name being typed takes the whole row for itself: the field covers the + // icon, so nothing is drawn under the text. Only while a rename is open — + // folder rows have no file, and null would match the null of "not + // renaming" and draw every folder as a stale text field. + if (renamingFile != null && row.file == renamingFile) { + drawField(graphics, font, renameText, textX, y, lineH); + return; + } + + int x = getStartX() + PADDING_X + INDENT * row.depth(); + + if (row.isFolder()) { + boolean folded = editorManager.isFolderFolded(row.path()); + drawIcon(graphics, folded ? ICON_COLLAPSED : ICON_EXPANDED, x, y, lineH, COLOR_CHEVRON, COLOR_CHEVRON); + x += CHEVRON_WIDTH + CHEVRON_GAP; + + drawIcon(graphics, ICON_FOLDER, x, y, lineH, + folded ? COLOR_FOLDER : COLOR_FOLDER_OPEN, COLOR_FOLDER_SEAM); + } else { + for (int c = 0; c < Math.min(3, editors.size()); c++) { + graphics.fill(x + c, y + 2, x + c + 1, y + lineH - 2, editors.get(c).color()); + } + x += PRESENCE_GUTTER; + + drawIcon(graphics, ICON_FILE, x, y, lineH, COLOR_FILE, COLOR_FILE_LINES); + } + + graphics.text(font, row.label(), textX, y, COLOR_TEXT, true); + } + + /** Centres a glyph in the row and paints it pixel by pixel. */ + private static void drawIcon(GuiGraphicsExtractor graphics, String[] glyph, int x, int y, int lineH, + int colour, int lineColour) { + y += (lineH - glyph.length) / 2; + + for (int row = 0; row < glyph.length; row++) { + String pixels = glyph[row]; + for (int column = 0; column < pixels.length(); column++) { + char pixel = pixels.charAt(column); + if (pixel == '.') continue; + + int pixelColour = pixel == '#' ? colour : lineColour; + graphics.fill(x + column, y + row, x + column + 1, y + row + 1, pixelColour); + } } } + /** + * A row turned into a text field: it fills the panel, and the caret sits at + * the end of what is typed. Used both to rename a file and to name a new + * folder, so the text is passed in rather than read from one fixed field. + */ + private void drawField(GuiGraphicsExtractor graphics, Font font, CharSequence text, int textX, int y, int lineH) { + graphics.fill(getStartX(), y, getEndX(), y + lineH, COLOR_RENAME_BG); + + // As the name grows, keep its end inside the panel like a real field does. + String shown = text + "|"; + int maxWidth = getEndX() - textX - 2; + int from = 0; + while (from < shown.length() - 1 && font.width(shown.substring(from)) > maxWidth) from++; + + graphics.text(font, shown.substring(from), textX, y, COLOR_TEXT, false); + } + + // ── Input ───────────────────────────────────────────────────────────── + @Override public boolean handleKeyPressed(KeyEvent event) { + if (renamingFile != null) { + switch (event.key()) { + case 256 -> renamingFile = null; // Escape — discard the rename + case 257 -> commitRename(); // Enter + case 259 -> { // Backspace + if (!renameText.isEmpty()) renameText.deleteCharAt(renameText.length() - 1); + } + } + // While a name is being typed, every key belongs to the name field. + return true; + } + + if (creatingFolder) { + switch (event.key()) { + case 256 -> creatingFolder = false; // Escape — discard the folder + case 257 -> commitNewFolder(); // Enter + case 259 -> { // Backspace + if (!newFolderText.isEmpty()) newFolderText.deleteCharAt(newFolderText.length() - 1); + } + } + return true; + } + return false; } @Override public boolean handleCharTyped(CharacterEvent event) { - return false; + StringBuilder into = renamingFile != null ? renameText : (creatingFolder ? newFolderText : null); + if (into == null) return false; + + int codePoint = event.codepoint(); + // Printable characters go into the name. A '/' goes in too: it names the + // folders to nest inside, which is how a folder comes to exist. + if (codePoint >= 32 && codePoint != 127 && codePoint != '\\' + && into.length() < MAX_NAME_LENGTH) { + into.appendCodePoint(codePoint); + } + return true; } @Override - public boolean handleMouseClicked(MouseButtonEvent event) { - Font font = editorScreen.getFont(); - int index = (int) ((event.y() - getStartY()) / font.lineHeight); - List files = editorManager.getFiles(); - - if (index >= 0 && index < files.size()) { - editorManager.openFile(files.get(index)); + public boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick) { + // Clicking anything applies the name being typed first, and that click is + // spent on applying it: like a file explorer, one click closes the field + // and the next one opens whatever is under the mouse. + if (renamingFile != null) { + commitRename(); return true; } - return false; + if (creatingFolder) { + commitNewFolder(); + return true; + } + + Font font = editorScreen.getFont(); + int index = (int) ((event.y() - getStartY() + scroll) / font.lineHeight); + if (event.y() < getStartY() || index < 0 || index >= rows.size()) return false; + + Row row = rows.get(index); + + if (row.isFolder()) { + // Where new files go, and which folder is being talked about: the + // click that says so also folds it or unfolds it. + editorManager.setSelectedFolder(row.path()); + editorManager.toggleFolderFolded(row.path()); + return true; + } + + editorManager.setSelectedFolder(ProjectPath.folderOf(row.path())); + + if (doubleClick) { + startRename(row.file()); + return true; + } + + editorManager.openFile(row.file()); + return true; + } + + @Override + public void handleFocusLost() { + if (renamingFile != null) commitRename(); + if (creatingFolder) commitNewFolder(); } @Override @@ -66,6 +409,152 @@ public class EditorFileTree extends Widget { @Override public boolean handleMouseScrolled(double scrollY) { + int content = rows.size() * editorScreen.getFont().lineHeight; + int visible = getEndY() - getStartY(); + if (content <= visible) return false; + + scroll = Mth.clamp((int) (scroll - scrollY * SCROLL_STEP), 0, content - visible); + return true; + } + + /** Stops the list from being scrolled past either end after the files changed. */ + private void clampScroll(List rows) { + int content = rows.size() * editorScreen.getFont().lineHeight; + scroll = Mth.clamp(scroll, 0, Math.max(0, content - (getEndY() - getStartY()))); + } + + // ── Inline rename ───────────────────────────────────────────────────── + // Double-click a file to rename it right where it is listed: what is typed + // replaces its name. Enter or clicking anywhere applies it, like a file + // explorer applying on focus loss; Escape discards it. + // + // What is typed is a path, so it also says where the file ends up: that is + // how a folder is made, since a folder is nothing but files whose name runs + // through it. + + /** The file whose name is being edited right now (null = not renaming). */ + private EditorFile renamingFile; + private StringBuilder renameText = new StringBuilder(); + + private void startRename(EditorFile file) { + renamingFile = file; + renameText = new StringBuilder(ProjectPath.displayNameOf(file.getName())); + } + + private void commitRename() { + EditorFile file = renamingFile; + renamingFile = null; + + // Only a file still in the project can be renamed: if the list was + // refreshed from the server meanwhile, what is typed simply goes away. + if (file == null || !editorManager.getFiles().contains(file)) return; + + String typed = renameText.toString().trim(); + if (typed.isEmpty()) return; + + // A leading '/' counts from the root of the project, anything else from + // the folder the file is in. A trailing one keeps the name and only moves + // the file into the folders in front of it, and doubled slashes read as + // one. So `lib/net` moves `main` to `lib/main`. + String folder = typed.startsWith("/") ? "" : ProjectPath.folderOf(file.getName()); + if (typed.endsWith("/")) typed += ProjectPath.displayNameOf(file.getName()); + + String newName = resolveSegments(folder, typed); + if (newName.isEmpty()) return; + + editorManager.renameFile(file, newName); + + // The file the player just moved or named stays where they can see it, + // even when it landed in a folder that was folded. + editorManager.unfoldFolder(ProjectPath.folderOf(newName)); + } + + /** + * Joins what was typed onto {@code folder} into one clean path: empty pieces + * (leading, doubled or trailing slashes) drop out, and {@code folder} may be + * the project root. Returns the empty string when nothing is left to name. + */ + private static String resolveSegments(String folder, String typed) { + StringBuilder path = new StringBuilder(); + for (String segment : typed.split("/")) { + String trimmed = segment.trim(); + if (trimmed.isEmpty()) continue; + if (!path.isEmpty()) path.append(ProjectPath.SEPARATOR); + path.append(trimmed); + } + return path.isEmpty() ? "" : ProjectPath.resolve(folder, path.toString()); + } + + // ── New folders ─────────────────────────────────────────────────────── + // A folder is a folder whether or not anything lives in it, but the project + // only stores file paths — an empty folder has no file to spell its name with. + // So a folder made from the sidebar is kept as this player's view of the + // project, alongside the fold state, and reads back into the tree every + // rebuild. Once a file lands in it the path carries the folder on its own. + + /** True while a new folder is being named in the sidebar. */ + private boolean creatingFolder; + /** The folder the new one is being made inside ("" = the project root). */ + private String newFolderParent = ""; + private StringBuilder newFolderText = new StringBuilder(); + + /** + * Opens a field for a new folder inside the folder the sidebar has picked + * (the project root when none is). It is prefilled with a name the project + * does not use yet, and every folder above that one is unfolded so the field + * is not drawn hidden inside a folded parent. + */ + public void startNewFolder() { + renamingFile = null; + creatingFolder = true; + newFolderParent = editorManager.getSelectedFolder(); + + for (String folder = newFolderParent; !folder.isEmpty(); folder = ProjectPath.folderOf(folder)) { + editorManager.unfoldFolder(folder); + } + newFolderText = new StringBuilder(uniqueFolderName(newFolderParent)); + } + + /** A leaf name for a new folder inside {@code parent} that nobody has taken. */ + private String uniqueFolderName(String parent) { + String path = ProjectPath.resolve(parent, "new-folder"); + for (int i = 2; folderTaken(path); i++) { + path = ProjectPath.resolve(parent, "new-folder-" + i); + } + return ProjectPath.displayNameOf(path); + } + + /** Whether {@code path} already names a folder, or a file lives in it. */ + private boolean folderTaken(String path) { + if (editorManager.getCustomFolders().contains(path)) return true; + + String inside = path + ProjectPath.SEPARATOR; + for (EditorFile file : editorManager.getFiles()) { + if (ProjectPath.folderOf(file.getName()).equals(path) || file.getName().startsWith(inside)) return true; + } + for (String folder : editorManager.getCustomFolders()) { + if (folder.startsWith(inside)) return true; + } return false; } + + private void commitNewFolder() { + creatingFolder = false; + + String typed = newFolderText.toString().trim(); + if (typed.isEmpty()) return; + + // A leading '/' names from the root; anything else nests inside the folder + // that was picked. + String folder = typed.startsWith("/") ? "" : newFolderParent; + String path = resolveSegments(folder, typed); + if (path.isEmpty()) return; + + editorManager.createFolder(path); + + // The new folder is where new files go, and it is shown open. Naming one + // that already exists just points at it: the tree keeps no duplicates. + editorManager.setSelectedFolder(path); + editorManager.unfoldFolder(path); + } } diff --git a/src/client/java/com/aranroig/client/editor/EditorFileView.java b/src/client/java/com/aranroig/client/editor/EditorFileView.java index c8cc5e2..917e180 100644 --- a/src/client/java/com/aranroig/client/editor/EditorFileView.java +++ b/src/client/java/com/aranroig/client/editor/EditorFileView.java @@ -1,8 +1,8 @@ package com.aranroig.client.editor; +import com.aranroig.editor.Edit; import com.aranroig.editor.EditorFile; -import com.aranroig.payloads.ServerboundSaveCodePayload; -import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking; +import com.aranroig.editor.EditorPresence; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GuiGraphicsExtractor; @@ -14,7 +14,7 @@ import org.jspecify.annotations.NonNull; import java.util.Collections; import java.util.List; -public class EditorFileView extends Widget { +public class EditorFileView extends EditorPane { private StringBuilder text = new StringBuilder(); @@ -29,6 +29,13 @@ public class EditorFileView extends Widget { super(editorManager); } + /** The header shows the name of the file this pane is editing. */ + @Override + public String paneTitle() { + EditorFile file = getCurrentEditorFile(); + return file == null ? "(no file)" : file.getName(); + } + // ── Scroll state ────────────────────────────────────────────────────── private int scrollX = 0; private int scrollY = 0; @@ -45,6 +52,7 @@ public class EditorFileView extends Widget { // ── Colors ──────────────────────────────────────────────────────────── private static final int COLOR_TEXT = 0xFFFFFFFF; private static final int COLOR_CURSOR = 0xFFFFFFFF; + private static final int COLOR_CURSOR_DIM = 0x66FFFFFF; private static final int COLOR_SELECTION = 0x664466FF; private static final int COLOR_GUTTER_BG = 0xFF252525; private static final int COLOR_GUTTER_TEXT = 0xFF888888; @@ -198,11 +206,88 @@ public class EditorFileView extends Widget { if (selectionAnchor < 0) return; int lo = Math.min(selectionAnchor, cursorPos); int hi = Math.max(selectionAnchor, cursorPos); - text.delete(lo, hi); + applyLocalEdit(lo, hi - lo, ""); cursorPos = lo; selectionAnchor = -1; } + // ── Live editing ────────────────────────────────────────────────────── + + /** + * The only place the buffer changes because the local player asked for it: + * applies the change here and reports it to {@link EditorManager}, which + * forwards it to the server so everyone else editing this file sees it. + * Every keystroke goes through this, so the shared copy of the file stays + * complete without waiting for a save. + */ + private void applyLocalEdit(int position, int deleteLength, String insert) { + int start = Math.max(0, Math.min(position, text.length())); + int end = Math.max(start, Math.min(start + deleteLength, text.length())); + text.replace(start, end, insert); + + if (currentEditorFile != null) { + editorManager.submitEdit(currentEditorFile, text.toString(), start, end - start, insert); + } + } + + /** + * Applies an edit another player made to this pane's file. The edit is + * already merged with the edits of our own that were still in flight (see + * {@link EditorManager#applyRemoteDocumentEdit}); our caret and selection + * ride along with the text around them so typing next to someone does not + * yank the caret away. The same merged edit may land in several panes at + * once when the same file is open twice. + */ + public void applyIntegratedRemoteEdit(Edit edit) { + if (edit.baseLength() > text.length() + 1) { + // The edit reaches past the end of our copy: the two documents have + // drifted apart. Ask for the real text. + editorManager.requestDocumentSync(currentEditorFile); + } + + int newCursor = edit.shiftPosition(cursorPos); + if (selectionAnchor >= 0) selectionAnchor = edit.shiftPosition(selectionAnchor); + + text = new StringBuilder(edit.apply(text.toString())); + cursorPos = Math.min(newCursor, text.length()); + if (selectionAnchor > text.length()) selectionAnchor = text.length(); + + dismissCompletions(); + } + + /** + * Whether the buffer still matches what the server says the file holds, as + * reported by an edit ack. A mismatch means our merge went wrong somewhere, + * and the answer is to take the server's copy rather than keep diverging. + */ + public boolean matchesServerText(int textHash, int textLength) { + return text.length() == textLength && text.toString().hashCode() == textHash; + } + + /** True when {@code name} is the file currently open in this view. */ + public boolean isEditing(String name) { + return currentEditorFile != null && currentEditorFile.getName().equals(name); + } + + /** + * Adopts the server's copy of the open file, keeping the caret as close to + * where it was as the new text allows. + */ + public void loadServerText(String serverText) { + text = new StringBuilder(serverText); + cursorPos = Math.min(cursorPos, text.length()); + if (selectionAnchor > text.length()) selectionAnchor = text.length(); + if (currentEditorFile != null) currentEditorFile.setText(serverText); + dismissCompletions(); + } + + /** Who else has this file open, and where their carets are. */ + private List remoteEditors = Collections.emptyList(); + + public void setRemoteEditors(List editors) { + remoteEditors = editors; + } + // ── Autocomplete helpers ────────────────────────────────────────────── /** Refresh the completion list after every text or cursor change. */ @@ -231,7 +316,7 @@ public class EditorFileView extends Widget { String prefix = completionProvider.extractPrefix(text.toString(), cursorPos); int prefixStart = cursorPos - prefix.length(); - text.replace(prefixStart, cursorPos, item.insert()); + applyLocalEdit(prefixStart, cursorPos - prefixStart, item.insert()); cursorPos = prefixStart + item.insert().length(); selectionAnchor = -1; dismissCompletions(); @@ -359,28 +444,16 @@ public class EditorFileView extends Widget { int firstLine = Math.max(0, scrollY / lineH); int lastLine = Math.min(lines.length - 1, (scrollY + textAreaHeight()) / lineH + 1); - // Selection highlight + // Selection highlight: ours, then everybody else's in their own colour if (hasSelection()) { - int lo = Math.min(selectionAnchor, cursorPos); - int hi = Math.max(selectionAnchor, cursorPos); - - int[] loLC = offsetToLineCol(lo); - int[] hiLC = offsetToLineCol(hi); - - for (int ln = Math.max(loLC[0], firstLine); ln <= Math.min(hiLC[0], lastLine); ln++) { - String lineText = lines[ln]; - int colStart = (ln == loLC[0]) ? loLC[1] : 0; - int colEnd = (ln == hiLC[0]) ? hiLC[1] : lineText.length(); - - int x0 = textAreaX() + widthUpTo(lineText, colStart) - scrollX; - int x1 = textAreaX() + widthUpTo(lineText, colEnd) - scrollX; - if (x1 == x0) x1 = x0 + 2; - x0 = Math.max(x0, textAreaX()); - x1 = Math.min(x1, end_x); - - int screenY = start_y + ln * lineH - scrollY; - graphics.fill(x0, screenY, x1, screenY + lineH, COLOR_SELECTION); - } + drawSelection(graphics, lines, lineH, firstLine, lastLine, end_x, + Math.min(selectionAnchor, cursorPos), Math.max(selectionAnchor, cursorPos), COLOR_SELECTION); + } + for (EditorPresence editor : remoteEditors) { + if (!editor.hasSelection()) continue; + drawSelection(graphics, lines, lineH, firstLine, lastLine, end_x, + Math.min(editor.cursor(), editor.anchor()), Math.max(editor.cursor(), editor.anchor()), + transparent(editor.color(), 0x4D)); } // Line numbers + text @@ -397,9 +470,15 @@ public class EditorFileView extends Widget { drawHighlightedLine(graphics, lines[i], textAreaX() - scrollX, screenY, lineInMultiline); } - // Blinking cursor - boolean showCursor = (System.currentTimeMillis() / 500) % 2 == 0; - if (showCursor) { + // Other players' carets in this file, each in the colour the server gave them + for (EditorPresence editor : remoteEditors) { + drawRemoteCaret(graphics, lines, lineH, start_y, end_y, editor); + } + + // Caret: blinking in the pane holding the keyboard, a dim line in the + // others, so several panes make it clear which one typing goes to. + boolean focusedPane = editorScreen.selectedWidget == this; + if (currentEditorFile != null && (focusedPane ? (System.currentTimeMillis() / 500) % 2 == 0 : true)) { int[] lc = offsetToLineCol(cursorPos); int ln = lc[0]; int col = lc[1]; @@ -411,7 +490,8 @@ public class EditorFileView extends Widget { int cursorY = start_y + ln * lineH - scrollY; if (cursorX >= textAreaX() && cursorX <= end_x) { - graphics.fill(cursorX, cursorY, cursorX + 1, cursorY + lineH, COLOR_CURSOR); + graphics.fill(cursorX, cursorY, cursorX + 1, cursorY + lineH, + focusedPane ? COLOR_CURSOR : COLOR_CURSOR_DIM); } } @@ -421,6 +501,65 @@ public class EditorFileView extends Widget { if (isPopupVisible()) { drawCompletionPopup(graphics, mouseX, mouseY); } + + // Let everyone else know where our caret ended up. + sendCursorIfMoved(); + } + + /** Tints the [lo, hi) range of the buffer, clipped to the visible lines. */ + private void drawSelection(GuiGraphicsExtractor graphics, String[] lines, int lineH, + int firstLine, int lastLine, int end_x, int lo, int hi, int color) { + int[] loLC = offsetToLineCol(lo); + int[] hiLC = offsetToLineCol(hi); + + for (int ln = Math.max(loLC[0], firstLine); ln <= Math.min(hiLC[0], lastLine); ln++) { + String lineText = lines[ln]; + int colStart = (ln == loLC[0]) ? loLC[1] : 0; + int colEnd = (ln == hiLC[0]) ? hiLC[1] : lineText.length(); + + int x0 = textAreaX() + widthUpTo(lineText, colStart) - scrollX; + int x1 = textAreaX() + widthUpTo(lineText, colEnd) - scrollX; + if (x1 == x0) x1 = x0 + 2; + x0 = Math.max(x0, textAreaX()); + x1 = Math.min(x1, end_x); + + int screenY = getStartY() + ln * lineH - scrollY; + graphics.fill(x0, screenY, x1, screenY + lineH, color); + } + } + + /** + * Draws one remote player's caret, in the colour the server assigned them, + * with their name next to it so several people in the same file are + * distinguishable. Anything outside the text area is clipped by the scissor + * the widget already has on. + */ + private void drawRemoteCaret(GuiGraphicsExtractor graphics, String[] lines, int lineH, + int start_y, int end_y, EditorPresence editor) { + int[] lc = offsetToLineCol(editor.cursor()); + int ln = Math.min(lc[0], lines.length - 1); + String lineText = lines[ln]; + + int x = textAreaX() + widthUpTo(lineText, Math.min(lc[1], lineText.length())) - scrollX; + int y = start_y + ln * lineH - scrollY; + if (y + lineH < start_y || y > end_y) return; // scrolled out of sight + + graphics.fill(x, y, x + 1, y + lineH, editor.color()); + + String name = editor.name(); + int nameW = font.width(name); + int tagX = Math.max(textAreaX(), Math.min(x - 1, getEndX() - nameW - 5)); + int tagY = y - font.lineHeight - 2; + if (tagY < start_y) tagY = Math.min(y + lineH + 1, end_y - font.lineHeight - 2); + + graphics.fill(tagX, tagY, tagX + nameW + 5, tagY + font.lineHeight + 2, 0xC0000000); + graphics.fill(tagX, tagY, tagX + 2, tagY + font.lineHeight + 2, editor.color()); + graphics.text(font, name, tagX + 4, tagY + 1, 0xFFFFFFFF, false); + } + + /** Same colour, with a given alpha instead of opaque. */ + private static int transparent(int rgb, int alpha) { + return (alpha << 24) | (rgb & 0x00FFFFFF); } private void drawCompletionPopup(@NonNull GuiGraphicsExtractor graphics, int mouseX, int mouseY) { @@ -510,7 +649,10 @@ public class EditorFileView extends Widget { // ── Input handlers ──────────────────────────────────────────────────── - public boolean handleMouseClicked(MouseButtonEvent event) { + public boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick) { + // The pane under the click is the one being worked in from now on. + editorManager.setActivePane(this); + // Check if clicking inside the popup if (isPopupVisible()) { int[] origin = popupOrigin(); @@ -567,11 +709,19 @@ public class EditorFileView extends Widget { return true; } + /** Clicking another pane takes the keyboard: nothing to complete here any more. */ + @Override + public void handleFocusLost() { + dismissCompletions(); + } + public boolean handleCharTyped(CharacterEvent event) { + if (currentEditorFile == null) return false; // an empty pane holds nothing to type into + int codePoint = event.codepoint(); if (codePoint >= 32 && codePoint != 127) { if (hasSelection()) deleteSelection(); - text.insert(cursorPos, Character.toString(codePoint)); + applyLocalEdit(cursorPos, 0, Character.toString(codePoint)); cursorPos += Character.charCount(codePoint); selectionAnchor = -1; scrollToCursor(); @@ -588,6 +738,10 @@ public class EditorFileView extends Widget { } public boolean handleKeyPressed(KeyEvent event) { + // An empty pane holds nothing to edit; the screen keeps its keys + // (Escape still closes it). + if (currentEditorFile == null) return false; + int key = event.key(); boolean shift = event.hasShiftDown(); boolean ctrl = event.hasControlDown(); @@ -624,7 +778,7 @@ public class EditorFileView extends Widget { switch (key) { case 257 -> { // Enter if (hasSelection()) deleteSelection(); - text.insert(cursorPos, '\n'); + applyLocalEdit(cursorPos, 0, "\n"); cursorPos++; selectionAnchor = -1; scrollToCursor(); @@ -633,7 +787,7 @@ public class EditorFileView extends Widget { } case 258 -> { // Tab (no popup) if (hasSelection()) deleteSelection(); - text.insert(cursorPos, '\t'); + applyLocalEdit(cursorPos, 0, "\t"); cursorPos++; selectionAnchor = -1; scrollToCursor(); @@ -642,7 +796,7 @@ public class EditorFileView extends Widget { } case 259 -> { // Backspace if (hasSelection()) { deleteSelection(); } - else if (cursorPos > 0) { text.deleteCharAt(--cursorPos); } + else if (cursorPos > 0) { applyLocalEdit(cursorPos - 1, 1, ""); cursorPos--; } selectionAnchor = -1; scrollToCursor(); updateCompletions(); // re-compute after deletion @@ -650,7 +804,7 @@ public class EditorFileView extends Widget { } case 261 -> { // Delete if (hasSelection()) { deleteSelection(); } - else if (cursorPos < text.length()) { text.deleteCharAt(cursorPos); } + else if (cursorPos < text.length()) { applyLocalEdit(cursorPos, 1, ""); } selectionAnchor = -1; scrollToCursor(); updateCompletions(); @@ -753,7 +907,7 @@ public class EditorFileView extends Widget { if (ctrl) { if (hasSelection()) deleteSelection(); String clip = minecraft.keyboardHandler.getClipboard(); - text.insert(cursorPos, clip); + applyLocalEdit(cursorPos, 0, clip); cursorPos += clip.length(); selectionAnchor = -1; scrollToCursor(); @@ -764,6 +918,13 @@ public class EditorFileView extends Widget { case 83 -> { // Ctrl+S saveEditorFile(); } + case 92 -> { // Ctrl+\ splits the area right; Ctrl+Shift+\ splits below + if (ctrl) { + if (shift) editorManager.splitBelow(); + else editorManager.splitRight(); + return true; + } + } case 291 -> { // F1 — open the docs on the word under the cursor editorManager.openDocsAt(wordUnderCursor()); return true; @@ -802,9 +963,68 @@ public class EditorFileView extends Widget { } public void setEditorFile(EditorFile currentEditorFile) { + boolean sameFile = this.currentEditorFile != null + && this.currentEditorFile.getName().equals(currentEditorFile.getName()); + this.currentEditorFile = currentEditorFile; text = new StringBuilder(currentEditorFile.getText()); dismissCompletions(); + + if (!sameFile) { + // Caret and scroll belonged to the file we just left. + cursorPos = 0; + selectionAnchor = -1; + scrollX = 0; + scrollY = 0; + } + + // Join this file's live session (and re-show who is in it). + editorManager.onDocumentOpened(this, currentEditorFile); + } + + /** + * Empties this pane: it shows no file and holds nothing to edit. Used when + * its pane is closed; the file itself stays in the project and in any other + * pane showing it. + */ + public void clearFile() { + currentEditorFile = null; + text = new StringBuilder(); + cursorPos = 0; + selectionAnchor = -1; + scrollX = 0; + scrollY = 0; + remoteEditors = Collections.emptyList(); + dismissCompletions(); + } + + // ── Presence ────────────────────────────────────────────────────────── + + /** Caret and selection as last reported to the server, and when that was. */ + private int sentCursor = Integer.MIN_VALUE; + private int sentAnchor = Integer.MIN_VALUE; + private long lastCursorSent; + + /** Roughly 16 caret updates a second; dragging selects far more often than that. */ + private static final long CURSOR_SEND_INTERVAL_MS = 60; + + /** + * Reports our caret to the other editors, coalescing the burst of moves a + * drag-select produces. Only the change that is on screen at the end of the + * interval is worth sending. + */ + private void sendCursorIfMoved() { + if (currentEditorFile == null) return; + if (cursorPos == sentCursor && selectionAnchor == sentAnchor) return; + + long now = System.currentTimeMillis(); + if (now - lastCursorSent < CURSOR_SEND_INTERVAL_MS) return; + + sentCursor = cursorPos; + sentAnchor = selectionAnchor; + lastCursorSent = now; + + editorManager.sendCursor(currentEditorFile.getName(), cursorPos, selectionAnchor); } public void saveEditorFile() { diff --git a/src/client/java/com/aranroig/client/editor/EditorManager.java b/src/client/java/com/aranroig/client/editor/EditorManager.java index 9aa54c9..630ed12 100644 --- a/src/client/java/com/aranroig/client/editor/EditorManager.java +++ b/src/client/java/com/aranroig/client/editor/EditorManager.java @@ -1,19 +1,36 @@ package com.aranroig.client.editor; -import com.aranroig.SavedProjectData; +import com.aranroig.Codecraft; import com.aranroig.client.wrapper.Logger; +import com.aranroig.editor.Edit; import com.aranroig.editor.EditorFile; +import com.aranroig.editor.EditorPresence; +import com.aranroig.editor.ProjectPath; import com.aranroig.editor.RunInfo; +import com.aranroig.payloads.ServerboundCloseEditorPayload; +import com.aranroig.payloads.ServerboundCloseShellPayload; +import com.aranroig.payloads.ServerboundCursorPayload; +import com.aranroig.payloads.ServerboundEditPayload; +import com.aranroig.payloads.ServerboundOpenDocumentPayload; +import com.aranroig.payloads.ServerboundRenameFilePayload; import com.aranroig.payloads.ServerboundRequestProjectPayload; import com.aranroig.payloads.ServerboundRunCodePayload; import com.aranroig.payloads.ServerboundSaveCodePayload; +import com.aranroig.payloads.ServerboundShellInputPayload; +import com.aranroig.payloads.ServerboundShellResizePayload; +import com.aranroig.payloads.ServerboundSpawnShellPayload; import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking; import net.minecraft.client.Minecraft; import party.iroiro.luajava.Lua; import party.iroiro.luajava.luaj.LuaJ; import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; public class EditorManager { @@ -21,18 +38,45 @@ public class EditorManager { EditorFileTree editorFileTree; EditorTopBar editorTopBar; - EditorFileView editorFileView; + EditorPaneContainer paneContainer; EditorDocsPanel editorDocsPanel; + EditorTerminalPane editorTerminal; List files = new ArrayList<>(); + /** + * Folders the player has folded in the sidebar. Where the project on disk + * stops being a flat list of paths and becomes a tree is the player's + * business, not the project's, so this stays on this side of the network. + */ + private final Set foldedFolders = new HashSet<>(); + + /** + * Folders the player has made in the sidebar that nothing lives in yet. Like + * the fold state these are the player's view of the project: the server only + * stores file paths, so a folder with no file in it has no path to be stored + * by. Once a file is created inside one the path carries the folder itself, + * and it needs nothing kept here any more. + */ + private final Set customFolders = new HashSet<>(); + + /** The folder new files are created in: the last one clicked in the sidebar. */ + private String selectedFolder = ""; + + /** Live-editing state per file: which version we hold and what is in flight. */ + private final Map liveDocs = new HashMap<>(); + + /** Who is in which file, as the server last told us. */ + private final Map> presenceByFile = new HashMap<>(); + public EditorManager() { client = Minecraft.getInstance(); editorFileTree = new EditorFileTree(this); editorTopBar = new EditorTopBar(this); - editorFileView = new EditorFileView(this); + paneContainer = new EditorPaneContainer(this); editorDocsPanel = new EditorDocsPanel(this); + editorTerminal = new EditorTerminalPane(this); } public List getFiles() { @@ -45,7 +89,7 @@ public class EditorManager { public void toggleVisible() { requestProjectFiles(); - TextEditorScreen textEditorScreen = new TextEditorScreen(); + TextEditorScreen textEditorScreen = new TextEditorScreen(this); // Populate screen with widgets editorFileTree.setSize(0, TOP_BAR_HEIGHT, FILE_RENDER_WIDTH_SIZE, -1); @@ -55,11 +99,9 @@ public class EditorManager { editorTopBar.setZIndex(1); editorTopBar.addToEditorScreen(textEditorScreen); - editorFileView.setSize(FILE_RENDER_WIDTH_SIZE, TOP_BAR_HEIGHT, -1, -1); - if (!files.isEmpty()) { - editorFileView.setEditorFile(files.getFirst()); - } - editorFileView.addToEditorScreen(textEditorScreen); + paneContainer.setSize(FILE_RENDER_WIDTH_SIZE, TOP_BAR_HEIGHT, -1, -1); + paneContainer.addToEditorScreen(textEditorScreen); // attaches every pane too + paneContainer.openInitialFile(); // Full-screen modal docs layer, above every other widget; hidden until opened. editorDocsPanel.setSize(0, 0, -1, -1); @@ -70,11 +112,18 @@ public class EditorManager { editorDocsPanel.close(); // Focus the text editor so typing works immediately on open. - textEditorScreen.selectedWidget = editorFileView; + textEditorScreen.selectedWidget = paneContainer.activePane(); + // Remembered before showing it: opening the editor again replaces the + // screen, and the screen being replaced must not end the session of the + // one that is taking its place. + currentScreen = textEditorScreen; client.setScreenAndShow(textEditorScreen); } + /** The editor screen currently on screen, if any. */ + private TextEditorScreen currentScreen; + /** Opens the Lua API documentation panel (top bar: Help → Lua API Documentation). */ public void openDocs() { editorDocsPanel.open(); @@ -90,7 +139,7 @@ public class EditorManager { /** Asks the server for the current project files; the reply lands in {@link #setFiles(List)}. */ public void requestProjectFiles() { - if (client.player == null) return; + if (!connected()) return; ClientPlayNetworking.send(new ServerboundRequestProjectPayload()); } @@ -98,13 +147,22 @@ public class EditorManager { public void setFiles(List newFiles) { files = new ArrayList<>(newFiles); - EditorFile current = editorFileView.getCurrentEditorFile(); - EditorFile target = current != null ? findFile(current.getName()) : null; - if (target == null && !files.isEmpty()) { - target = files.getFirst(); - } - if (target != null) { - editorFileView.setEditorFile(target); + // Each pane keeps showing the file it was showing, refreshed from the + // server's copy of it — which is what carries the text. A pane whose + // file is gone falls back to the project's first one, like the single + // view always did. + for (EditorPane pane : paneContainer.panes()) { + if (!(pane instanceof EditorFileView view)) continue; + + EditorFile current = view.getCurrentEditorFile(); + if (current == null && view != paneContainer.activePane()) continue; + + EditorFile target = current != null ? findFile(current.getName()) : null; + if (target == null) { + if (files.isEmpty()) continue; + target = files.getFirst(); + } + view.setEditorFile(target); } } @@ -113,8 +171,9 @@ public class EditorManager { EditorFile existing = findFile(file.getName()); if (existing == null) { files.add(file); - } else if (existing != editorFileView.getCurrentEditorFile()) { - // Don't clobber text the user is currently editing. + } else if (!isDisplayed(file.getName())) { + // Don't clobber text the user is editing in a pane: a displayed + // file arrives edit by edit through the live session instead. existing.setText(file.getText()); } } @@ -126,29 +185,473 @@ public class EditorManager { return null; } + /** Called on the client thread when the server renamed one of the project files. */ + public void applyFileRename(String oldName, String newName) { + renameEntry(liveDocs, oldName, newName); + renameEntry(presenceByFile, oldName, newName); + + EditorFile file = findFile(oldName); + if (file != null) file.setName(newName); + + // The panes hold this same object, so they already edit the renamed + // file; only the presence display, keyed by the old name, must refresh. + refreshPresenceInPanes(newName); + } + public void openFile(EditorFile file) { - editorFileView.setEditorFile(file); + // Files always open in a file pane: the shell keeps whatever is docked + // where it is docked. + EditorFileView pane = paneContainer.activeFilePane(); + if (pane == null) pane = paneContainer.firstFilePane(); + if (pane == null) { + // Only the shell was left; open a file pane beside it again. + pane = new EditorFileView(this); + paneContainer.dockPane(pane, paneContainer.activePane(), EditorPaneContainer.Orientation.HORIZONTAL); + } + pane.setEditorFile(file); + + // Clicking a file in the tree means you want to be typing in it. + if (currentScreen != null) currentScreen.selectedWidget = pane; } + /** The file the active pane is showing, or null while nothing is open. */ + public EditorFile getCurrentFile() { + EditorFileView pane = paneContainer.activeFilePane(); + return pane == null ? null : pane.getCurrentEditorFile(); + } + + /** The pane files open in and typing belongs to, if that pane is a file view. */ + EditorFileView activePane() { + return paneContainer.activeFilePane(); + } + + /** Every pane showing {@code name} — the same file can be open in two of them. */ + private List panesEditing(String name) { + List showing = new ArrayList<>(); + for (EditorPane pane : paneContainer.panes()) { + if (pane instanceof EditorFileView view && view.isEditing(name)) showing.add(view); + } + return showing; + } + + /** Whether any pane is showing {@code name}. */ + private boolean isDisplayed(String name) { + return !panesEditing(name).isEmpty(); + } + + /** Re-shows who is in {@code name} in every pane that has it open. */ + private void refreshPresenceInPanes(String name) { + for (EditorFileView pane : panesEditing(name)) { + pane.setRemoteEditors(presenceFor(name)); + } + } + + // ── Folders ─────────────────────────────────────────────────────────── + // Folders are not stored anywhere: they are the paths the file names carry, + // and the sidebar groups by them. Which of them is folded, and which one new + // files land in, is only this player's view of the project. + + /** Whether the sidebar is showing {@code folder} folded. */ + public boolean isFolderFolded(String folder) { + return foldedFolders.contains(folder); + } + + public void toggleFolderFolded(String folder) { + if (!foldedFolders.remove(folder)) foldedFolders.add(folder); + } + + /** Shows a folder again, so something put inside it is not hidden by it. */ + public void unfoldFolder(String folder) { + foldedFolders.remove(folder); + } + + /** The folder new files are created in; the project root when none is picked. */ + public String getSelectedFolder() { + return selectedFolder; + } + + public void setSelectedFolder(String folder) { + selectedFolder = folder == null ? "" : folder; + } + + /** Folders made in the sidebar that nothing lives in yet; see {@link #customFolders}. */ + public Set getCustomFolders() { + return customFolders; + } + + /** + * Makes {@code path} show up in the sidebar as a folder of its own, before + * anything is put in it. Folders are not sent anywhere: like the rest of the + * tree this is this player's view, and the folder becomes real on the server + * the moment a file is saved inside it. + */ + public void createFolder(String path) { + if (path == null || path.isEmpty()) return; + customFolders.add(path); + } + + // ── Live editing ────────────────────────────────────────────────────── + // The server keeps the authoritative copy of every open file. Everything + // the player types goes to it as an edit against a known version, and + // everything everyone else types comes back and is merged into the buffer, + // which is what makes the file shared rather than merely synced on save. + + /** + * Joins the live session of the file a pane just switched to, and shows + * whoever is already in it. + */ + public void onDocumentOpened(EditorFileView pane, EditorFile file) { + pane.setRemoteEditors(presenceFor(file.getName())); + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundOpenDocumentPayload(file.getName())); + } + + /** + * Leaves every live session. Only the screen that is actually on screen can + * end it: when the editor is reopened, the screen being thrown away closes + * after the new one has already joined again. + */ + public void onEditorClosed(TextEditorScreen closed) { + if (closed != currentScreen) return; + currentScreen = null; + + presenceByFile.clear(); + for (EditorPane pane : paneContainer.panes()) + if (pane instanceof EditorFileView view) view.setRemoteEditors(List.of()); + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundCloseEditorPayload()); + } + + /** + * Forwards one local edit of the open file. The buffer has already been + * changed (typing has to feel instant); this records it as in flight and + * sends it with the version it was written against. + */ + public void submitEdit(EditorFile file, String buffer, int position, int deleteLength, String insert) { + file.setText(buffer); + if (!connected()) return; + + LiveDocument doc = liveDocument(file.getName()); + Edit edit = doc.submit(position, deleteLength, insert); + if (edit == null) return; // the change amounted to nothing + ClientPlayNetworking.send(new ServerboundEditPayload(file.getName(), doc.base(), edit)); + } + + /** + * Someone else's edit of a file we are watching. Every pane showing that + * file gets it; if no pane shows it, it is merged into our stored copy of + * it instead. The merge with our in-flight edits happens once per message + * — applying it to several panes shares that one result, so the second pane + * of the same file never transforms against the first pane's work. + */ + public void applyRemoteDocumentEdit(String file, int version, Edit edit) { + Edit merged = liveDocument(file).integrateRemote(version, edit); + + List showing = panesEditing(file); + if (!showing.isEmpty()) { + for (EditorFileView pane : showing) pane.applyIntegratedRemoteEdit(merged); + return; + } + + EditorFile data = findFile(file); + if (data != null) { + data.setText(merged.apply(data.getText())); + } + } + + /** + * The server applied one of our edits; the document is now at + * {@code version}, holding {@code textLength} characters that hash to + * {@code textHash}. Once nothing of ours is in flight any more we can + * compare that against our buffer, and if they disagree the two copies + * drifted apart and ours has to come from the server. + */ + public void applyEditAck(String file, int version, int textHash, int textLength) { + LiveDocument doc = liveDocument(file); + doc.onAck(version); + + if (!doc.isSynced()) return; + + boolean inSync; + List showing = panesEditing(file); + if (!showing.isEmpty()) { + inSync = true; + for (EditorFileView pane : showing) { + inSync &= pane.matchesServerText(textHash, textLength); + } + } else { + EditorFile data = findFile(file); + inSync = data == null + || (data.getText().length() == textLength && data.getText().hashCode() == textHash); + } + + if (!inSync) { + Codecraft.LOGGER.warn("Live copy of {} no longer matches the server; fetching it again", file); + requestDocumentSync(findFile(file)); + } + } + + /** + * The server's authoritative copy of a file, sent when we join it and again + * when it decides our copy is too far behind to merge into. + */ + public void applyDocumentState(String file, String text, int version) { + LiveDocument doc = liveDocument(file); + List showing = panesEditing(file); + + if (!showing.isEmpty() && !doc.isSynced() && version <= doc.base()) { + // This snapshot cannot contain what we are still typing, so taking + // it now would throw those keystrokes away. Once they are acked the + // check in applyEditAck asks for a snapshot that does contain them. + return; + } + + doc.resetTo(version); + if (!showing.isEmpty()) { + for (EditorFileView pane : showing) pane.loadServerText(text); + } else { + EditorFile data = findFile(file); + if (data != null) data.setText(text); + } + } + + /** Asks for the authoritative copy of a file again. */ + public void requestDocumentSync(EditorFile file) { + if (file == null || !connected()) return; + ClientPlayNetworking.send(new ServerboundOpenDocumentPayload(file.getName())); + } + + /** Sends our caret position to the other editors of {@code file}. */ + public void sendCursor(String file, int cursor, int anchor) { + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundCursorPayload(file, cursor, anchor)); + } + + /** Called by the server when players join, leave or move inside {@code file}. */ + public void applyPresence(String file, List editors) { + if (editors.isEmpty()) presenceByFile.remove(file); + else presenceByFile.put(file, List.copyOf(editors)); + + refreshPresenceInPanes(file); + } + + /** Who the server says is editing {@code file}. */ + public List presenceFor(String file) { + return presenceByFile.getOrDefault(file, List.of()); + } + + /** Who is sharing the file the active pane is showing right now. */ + public List collaborators() { + EditorFile current = getCurrentFile(); + return current == null ? List.of() : presenceFor(current.getName()); + } + + private LiveDocument liveDocument(String file) { + return liveDocs.computeIfAbsent(file, + name -> new LiveDocument(client.player != null ? client.player.getUUID() : new UUID(0L, 0L))); + } + + /** Moves one entry of a per-file map to the file's new name. */ + private static void renameEntry(Map byName, String oldName, String newName) { + T entry = byName.remove(oldName); + if (entry != null) byName.put(newName, entry); + } + + private boolean connected() { + return client.getConnection() != null; + } + + // ── Editor actions ──────────────────────────────────────────────────── + + /** + * Creates an empty file in the folder the sidebar has picked, with a name + * nobody in the project has taken yet, opens it in the view and saves it, so + * it exists on the server and shows up in the other editors' file lists + * right away. + */ public void newFile() { + String folder = selectedFolder; + // Otherwise a file made inside a folder the player cannot see is only + // in the editor, and the sidebar looks like nothing happened. + unfoldFolder(folder); + + EditorFile file = new EditorFile(uniqueFileName(folder), ""); + files.add(file); + openFile(file); + save(); } + /** + * Opens the sidebar's inline field to name a new folder inside the one that + * is picked, and hands the keyboard to the tree so the name can be typed. + * Nothing is added to the project: an empty folder is only this player's + * view until a file is put in it. + */ + public void newFolder() { + editorFileTree.startNewFolder(); + if (currentScreen != null) currentScreen.selectedWidget = editorFileTree; + } + + /** + * A name for a new file inside {@code folder} that nobody in the project has + * taken. Names carry no extension — the sidebar shows the name as it is — + * and the folder is part of the name, which is what makes a file land inside it. + */ + private String uniqueFileName(String folder) { + String name = ProjectPath.resolve(folder, "untitled"); + for (int i = 2; findFile(name) != null; i++) { + name = ProjectPath.resolve(folder, "untitled-" + i); + } + return name; + } + + /** + * Renames a file of the project, refused if the new name is empty or taken. + * Our list and the live-editing bookkeeping follow the new name — the live + * document keeps its version, so editing carries on uninterrupted — and + * the server renames its copy and tells everyone else. + */ + public void renameFile(EditorFile file, String newName) { + if (file == null || newName.isEmpty() || newName.equals(file.getName())) return; + if (findFile(newName) != null) return; + + String oldName = file.getName(); + renameEntry(liveDocs, oldName, newName); + renameEntry(presenceByFile, oldName, newName); + file.setName(newName); + + // The panes hold this same object, so they already edit the renamed + // file; only the presence display, keyed by the old name, must refresh. + refreshPresenceInPanes(newName); + + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundRenameFilePayload(oldName, newName)); + } + + /** + * Flushes the buffer to the project. Everything typed is already with the + * server, so this is mostly the deliberate "put the whole file down" that + * also makes a brand-new file exist on it. + */ public void save() { - EditorFile currentEditorFile = editorFileView.getCurrentEditorFile(); + EditorFileView pane = activePane(); + if (pane == null) return; // the shell, if it is all that is focused, has nothing to save + EditorFile currentEditorFile = pane.getCurrentEditorFile(); if (currentEditorFile == null) return; - editorFileView.writeChanges(); + pane.writeChanges(); ServerboundSaveCodePayload payload = new ServerboundSaveCodePayload(currentEditorFile); + if (!connected()) return; ClientPlayNetworking.send(payload); } + // ── Pane actions ────────────────────────────────────────────────────── + + /** Splits the active pane, editing area and all: two panes side by side. */ + public void splitRight() { + paneContainer.split(EditorPaneContainer.Orientation.HORIZONTAL, paneContainer.activePane()); + } + + /** Splits the active pane into one above the other. */ + public void splitBelow() { + paneContainer.split(EditorPaneContainer.Orientation.VERTICAL, paneContainer.activePane()); + } + + /** Closes the active pane; the last one standing just empties instead. */ + public void closeActivePane() { + paneContainer.closePane(paneContainer.activePane()); + } + + /** The pane a click landed in: where files open and typing goes from now on. */ + public void setActivePane(EditorPane pane) { + paneContainer.setActivePane(pane); + } + + // ── The server shell ────────────────────────────────────────────────── + // The server runs a real bash for this player; the terminal pane is its + // view. Pressing the top bar's Shell button docks the pane (under the pane + // in focus, IDE-style) and asks for the shell; closing the pane's header + // kills it again. + + /** Whether the shell is running on the server, as far as this client knows. */ + private boolean shellAlive = false; + + /** Whether the terminal pane is tiled into the editing area right now. */ + public boolean isShellOpen() { + return paneContainer.panes().contains(editorTerminal); + } + + /** + * The Shell button: shows the terminal pane — docked below whatever pane + * was in focus the first time — spawns a shell for it if none is running, + * and gives it the keyboard. Pressing it again with the shell up just + * brings the same pane back to focus; only the pane's own close button + * ends the shell. + */ + public void toggleShell() { + paneContainer.dockPane(editorTerminal, paneContainer.activePane(), + EditorPaneContainer.Orientation.VERTICAL); + if (currentScreen != null) currentScreen.selectedWidget = editorTerminal; + + if (!connected()) { + editorTerminal.markClosed("no server connection: no shell to spawn"); + return; + } + if (!shellAlive) { + editorTerminal.announce("starting a shell on the server..."); + ClientPlayNetworking.send(new ServerboundSpawnShellPayload( + editorTerminal.terminalRows(), editorTerminal.terminalCols())); + } + } + + /** Called by the terminal pane when its header closes: the shell goes with it. */ + public void closeShell() { + shellAlive = false; + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundCloseShellPayload()); + } + + /** + * Sends raw terminal input — a keystroke, Ctrl-C's {@code \u0003}, an + * arrow key's escape sequence, a status answer the emulator owes it — to + * the pseudo-terminal, which interprets all of that itself. + */ + public void sendShellControl(String bytes) { + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundShellInputPayload(bytes)); + } + + /** + * Tells the server the terminal pane's grid changed size: it moves the + * pseudo-terminal's window itself — an ioctl, not keystrokes — so a + * full-screen program in the foreground is signalled and reflows while + * it runs, the way a real window resize signals one. + */ + public void sendShellResize(int rows, int cols) { + if (!connected()) return; + ClientPlayNetworking.send(new ServerboundShellResizePayload(rows, cols)); + } + + /** Called on the client thread with everything the shell printed. */ + public void applyShellOutput(String text) { + editorTerminal.appendOutput(text); + } + + /** Called on the client thread when the shell exited or could not start. */ + public void applyShellClosed(String reason) { + shellAlive = false; + editorTerminal.markClosed(reason); + } + public void undo() { } public void run() { - RunInfo runInfo = new RunInfo("main.lua"); + // The project's entrypoint is the file named `main`, at the root. + RunInfo runInfo = new RunInfo(ProjectPath.ENTRYPOINT); ServerboundRunCodePayload payload = new ServerboundRunCodePayload(runInfo); + if (!connected()) return; ClientPlayNetworking.send(payload); /* String code = files.getFirst().getText(); @@ -166,4 +669,4 @@ public class EditorManager { public void stop() { } -} \ No newline at end of file +} diff --git a/src/client/java/com/aranroig/client/editor/EditorPane.java b/src/client/java/com/aranroig/client/editor/EditorPane.java new file mode 100644 index 0000000..e011ecd --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/EditorPane.java @@ -0,0 +1,34 @@ +package com.aranroig.client.editor; + +/** + * Something that lives in the editor's pane area: a file being edited + * ({@link EditorFileView}) or the server shell ({@link EditorTerminalPane}). + * + *

{@link EditorPaneContainer} treats every pane the same way — a header + * with the title and a close button, draggable sashes around it — so anything + * that wants to be a pane only has to say what its header reads and, when it + * does not want the split buttons or has something to clean up on close, + * override the small hooks here.

+ */ +public abstract class EditorPane extends Widget { + + protected EditorPane(EditorManager editorManager) { + super(editorManager); + } + + /** The text of the header above this pane. */ + public abstract String paneTitle(); + + /** + * Whether the header offers the split-right / split-below buttons. File + * panes can be split; the shell is one shell, so its header only holds the + * close button. + */ + public boolean showSplitButtons() { + return true; + } + + /** The header's close button was pressed and this pane is going away. */ + public void onPaneClosed() { + } +} diff --git a/src/client/java/com/aranroig/client/editor/EditorPaneContainer.java b/src/client/java/com/aranroig/client/editor/EditorPaneContainer.java new file mode 100644 index 0000000..0eaea72 --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/EditorPaneContainer.java @@ -0,0 +1,633 @@ +package com.aranroig.client.editor; + +import com.aranroig.editor.EditorFile; +import net.minecraft.client.gui.Font; +import net.minecraft.client.gui.GuiGraphicsExtractor; +import net.minecraft.client.input.CharacterEvent; +import net.minecraft.client.input.KeyEvent; +import net.minecraft.client.input.MouseButtonEvent; +import net.minecraft.util.Mth; +import org.jspecify.annotations.NonNull; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * The editing area: one or more {@link EditorPane} panes tiled side by side + * and stacked — file views and, when opened, the shell — each with a header + * naming what it shows. The header of a pane splits it again (right or below) + * or closes it, and the strips between panes drag to resize them. + * + *

The layout is a tree of splits: a node is either a leaf showing one pane + * or a branch placing its children in a row ({@link Orientation#HORIZONTAL}, + * with vertical sashes) or a column, each child holding a weight that a sash + * drag moves between its neighbours.

+ * + *

The panes are widgets of the screen in their own right; this widget only + * answers for its headers and sashes — {@link #inside} is false anywhere else — + * so a click on a pane's text reaches that pane directly, and the keyboard + * belongs to whichever pane was last clicked.

+ */ +public class EditorPaneContainer extends Widget { + + /** HORIZONTAL: the children of the split sit side by side, the sash between them is vertical. */ + public enum Orientation { HORIZONTAL, VERTICAL } + + // ── The layout tree ─────────────────────────────────────────────────── + + private static class Node { } + + private static final class Leaf extends Node { + final EditorPane view; + Leaf(EditorPane view) { this.view = view; } + } + + private static final class Branch extends Node { + final Orientation orientation; + final List children = new ArrayList<>(); + /** Size of each child relative to their sum: what dragging a sash moves around. */ + final List weights = new ArrayList<>(); + + Branch(Orientation orientation) { this.orientation = orientation; } + + double weightsSum() { + double sum = 0; + for (double weight : weights) sum += weight; + return sum; + } + } + + /** Where a pane header ended up, and whose pane it heads. */ + private record HeaderHit(Leaf leaf, int x0, int y0, int x1, int y1) {} + + /** + * Where the strip between two children of a split ended up: the thing that + * drags to resize them. It carries the branch's measurements so a drag can + * convert pixels into weights without re-reading a layout that has since + * moved underneath it. + */ + private record SashHit(Branch branch, int index, boolean horizontal, + int x0, int y0, int x1, int y1, int available, double weightsSum) {} + + private final List headerLayouts = new ArrayList<>(); + private final List sashLayouts = new ArrayList<>(); + + private Node root; + private final List panes = new ArrayList<>(); + + /** The pane new files open in, and the one the player is working in. */ + private EditorPane activePane; + + /** The sash the mouse is holding on to, and where the last drag event was. */ + private Branch dragBranch; + private int dragIndex; + private int dragAvailable; + private double dragWeightsSum; + private int lastDragX, lastDragY; + + // ── Look ────────────────────────────────────────────────────────────── + + private static final int HEADER_HEIGHT = 12; + private static final int SASH_THICKNESS = 3; + private static final int MIN_PANE_WIDTH = 80; + private static final int MIN_PANE_HEIGHT = 30; + + private static final int BUTTON_SIZE = 12; + + /** The header buttons, right to left. */ + private static final int BTN_CLOSE = 0; + private static final int BTN_SPLIT_BELOW = 1; + private static final int BTN_SPLIT_RIGHT = 2; + private static final int BUTTON_COUNT = 3; + + private static final int COLOR_BACKGROUND = 0xFF303030; + private static final int COLOR_HEADER = 0xFF262626; + private static final int COLOR_HEADER_ACTIVE = 0xFF3C3C3C; + private static final int COLOR_HEADER_TEXT = 0xFFFFFFFF; + private static final int COLOR_HEADER_DIM = 0xFF9A9A9A; + private static final int COLOR_ACTIVE_ACCENT = 0xFF44688A; + private static final int COLOR_SASH = 0xFF444444; + private static final int COLOR_SASH_HOVER = 0xFF6A9BD5; + private static final int COLOR_BUTTON_HOVER = 0xFF4A4A4A; + private static final int COLOR_BUTTON_CLOSE = 0xFF7A3D3D; + private static final int COLOR_ICON = 0xFFCCCCCC; + + // Pixel patterns like the sidebar's icons: '#' is the icon's colour, '.' nothing. + private static final String[] ICON_SPLIT_SIDE = { + "#######", + "#.....#", + "#..#..#", + "#..#..#", + "#..#..#", + "#.....#", + "#######", + }; + + private static final String[] ICON_SPLIT_STACKED = { + "#######", + "#.....#", + "#.....#", + "#######", + "#.....#", + "#.....#", + "#######", + }; + + private static final String[] ICON_CLOSE = { + "#.....#", + ".#...#.", + "..#.#..", + "...#...", + "..#.#..", + ".#...#.", + "#.....#", + }; + + public EditorPaneContainer(EditorManager editorManager) { + super(editorManager); + + EditorFileView first = new EditorFileView(editorManager); + panes.add(first); + activePane = first; + root = new Leaf(first); + } + + // ── Panes ───────────────────────────────────────────────────────────── + + /** Every pane, whatever order they sit in. */ + List panes() { + return Collections.unmodifiableList(panes); + } + + EditorPane activePane() { + return activePane; + } + + /** The file pane files open in: the active one if it edits a file. */ + EditorFileView activeFilePane() { + return activePane instanceof EditorFileView view ? view : null; + } + + void setActivePane(EditorPane pane) { + if (pane != null) activePane = pane; + } + + @Override + public void addToEditorScreen(EditorScreen screen) { + super.addToEditorScreen(screen); + for (EditorPane pane : panes) pane.addToEditorScreen(screen); + relayout(); + } + + /** Puts the project's first file in the pane that has none, for the initial open. */ + void openInitialFile() { + EditorFileView pane = activeFilePane() != null ? activeFilePane() : firstFilePane(); + if (pane != null && pane.getCurrentEditorFile() == null && !editorManager.getFiles().isEmpty()) + pane.setEditorFile(editorManager.getFiles().getFirst()); + } + + /** The first pane editing a file, whatever the active one is. */ + EditorFileView firstFilePane() { + for (EditorPane pane : panes) + if (pane instanceof EditorFileView view) return view; + return null; + } + + // ── Splitting, docking and closing ──────────────────────────────────── + + /** + * Splits {@code source}'s area in two with a new file pane: it starts on + * the same file the source was showing, becomes the active pane, and takes + * the keyboard — what is opened from the tree next lands in it. + */ + void split(Orientation orientation, EditorPane source) { + EditorFileView fresh = new EditorFileView(editorManager); + dockLeaf(fresh, source, orientation); + + EditorFile file = source instanceof EditorFileView view ? view.getCurrentEditorFile() : null; + if (file != null) fresh.setEditorFile(file); + + if (editorScreen != null) editorScreen.selectedWidget = fresh; + } + + /** + * Docks an existing pane — the shell, which stays the same one however + * often it is opened — beside {@code source}, and gives it the focus. A + * pane that is already docked is only focused again. + */ + void dockPane(EditorPane pane, EditorPane source, Orientation orientation) { + if (panes.contains(pane)) { + setActivePane(pane); + if (editorScreen != null) editorScreen.selectedWidget = pane; + return; + } + dockLeaf(pane, source, orientation); + if (editorScreen != null) editorScreen.selectedWidget = pane; + } + + /** Puts {@code pane} in the tree beside {@code source} and makes it active. */ + private void dockLeaf(EditorPane pane, EditorPane source, Orientation orientation) { + panes.add(pane); + if (editorScreen != null) pane.addToEditorScreen(editorScreen); + + Leaf freshLeaf = new Leaf(pane); + Leaf sourceLeaf = findLeaf(source); + + if (sourceLeaf == null || root == sourceLeaf) { + Branch branch = new Branch(orientation); + branch.children.add(root); branch.weights.add(1.0); + branch.children.add(freshLeaf); branch.weights.add(1.0); + root = branch; + } else { + Branch parent = findParent(sourceLeaf); + int index = parent.children.indexOf(sourceLeaf); + if (parent.orientation == orientation) { + // Another pane joins the same row or column: everyone in it shrinks. + parent.children.add(index + 1, freshLeaf); + parent.weights.add(index + 1, parent.weights.get(index)); + } else { + Branch branch = new Branch(orientation); + branch.children.add(sourceLeaf); branch.weights.add(1.0); + branch.children.add(freshLeaf); branch.weights.add(1.0); + parent.children.set(index, branch); + } + } + + setActivePane(pane); + relayout(); + } + + /** Closes one pane and gives its area back to its neighbours. */ + void closePane(EditorPane pane) { + if (pane == null) return; + + // The last pane does not go away: a file pane just empties instead. + // Closing the shell while it is all there is leaves an empty file pane + // behind, so the area is never left with nothing to edit at all. + if (panes.size() <= 1) { + if (pane instanceof EditorFileView view) { + view.clearFile(); + return; + } + + EditorFileView fresh = new EditorFileView(editorManager); + panes.set(0, fresh); + root = new Leaf(fresh); + setActivePane(fresh); + if (editorScreen != null) { + editorScreen.removeWidget(pane); + fresh.addToEditorScreen(editorScreen); + editorScreen.selectedWidget = fresh; + } + pane.onPaneClosed(); + relayout(); + return; + } + + Leaf leaf = findLeaf(pane); + Branch parent = leaf == null ? null : findParent(leaf); + if (parent == null) return; + + int index = parent.children.indexOf(leaf); + parent.children.remove(index); + parent.weights.remove(index); + + Node replacement = parent; + if (parent.children.size() == 1) { + // A split with one child left is no split: the child takes the + // branch's own place, and the size it had, in the grandparent's row. + replacement = parent.children.get(0); + Branch grandParent = findParent(parent); + if (grandParent == null) root = replacement; + else grandParent.children.set(grandParent.children.indexOf(parent), replacement); + } + + panes.remove(pane); + if (pane instanceof EditorFileView view) view.clearFile(); + if (editorScreen != null) editorScreen.removeWidget(pane); + pane.onPaneClosed(); + + if (activePane == pane) setActivePane(firstLeafView(replacement)); + if (editorScreen != null && editorScreen.selectedWidget == pane) + editorScreen.selectedWidget = activePane; + + relayout(); + } + + private Leaf findLeaf(EditorPane view) { + return findLeaf(root, view); + } + + private static Leaf findLeaf(Node node, EditorPane view) { + if (node instanceof Leaf leaf) return leaf.view == view ? leaf : null; + + for (Node child : ((Branch) node).children) { + Leaf found = findLeaf(child, view); + if (found != null) return found; + } + return null; + } + + private Branch findParent(Node target) { + return findParent(root, target); + } + + private static Branch findParent(Node node, Node target) { + if (!(node instanceof Branch branch)) return null; + if (branch.children.contains(target)) return branch; + + for (Node child : branch.children) { + Branch found = findParent(child, target); + if (found != null) return found; + } + return null; + } + + private static EditorPane firstLeafView(Node node) { + if (node instanceof Leaf leaf) return leaf.view; + return firstLeafView(((Branch) node).children.get(0)); + } + + // ── Layout ──────────────────────────────────────────────────────────── + + /** Places every pane and sash again, and records the headers and sashes for hit-testing. */ + private void relayout() { + headerLayouts.clear(); + sashLayouts.clear(); + if (editorScreen == null || root == null) return; + layoutNode(root, getStartX(), getStartY(), getEndX(), getEndY()); + } + + private void layoutNode(Node node, int x0, int y0, int x1, int y1) { + if (node instanceof Leaf leaf) { + // The header belongs to this container; the pane gets what is left. + leaf.view.setSize(x0, y0 + HEADER_HEIGHT, x1, y1); + headerLayouts.add(new HeaderHit(leaf, x0, y0, x1, y0 + HEADER_HEIGHT)); + return; + } + + Branch branch = (Branch) node; + boolean horizontal = branch.orientation == Orientation.HORIZONTAL; + int count = branch.children.size(); + int total = horizontal ? x1 - x0 : y1 - y0; + int gaps = SASH_THICKNESS * (count - 1); + int available = Math.max(0, total - gaps); + double sum = branch.weightsSum(); + if (sum <= 0) sum = count; + + int pos = horizontal ? x0 : y0; + int placed = 0; + for (int i = 0; i < count; i++) { + int extent = (i == count - 1) + ? available - placed + : (int) Math.round(available * branch.weights.get(i) / sum); + extent = Math.max(0, extent); + + if (i > 0) { + sashLayouts.add(new SashHit(branch, i - 1, horizontal, + horizontal ? pos : x0, horizontal ? y0 : pos, + horizontal ? pos + SASH_THICKNESS : x1, horizontal ? y1 : pos + SASH_THICKNESS, + available, sum)); + pos += SASH_THICKNESS; + } + + if (horizontal) layoutNode(branch.children.get(i), pos, y0, pos + extent, y1); + else layoutNode(branch.children.get(i), x0, pos, x1, pos + extent); + + pos += extent; + placed += extent; + } + } + + /** + * Moves the sash being dragged by {@code movedX}/{@code movedY} pixels: the + * neighbour before it grows and the one after shrinks by the same amount, + * until either would come under its minimum size. + */ + private void resizeSash(int movedX, int movedY) { + if (dragBranch == null || dragAvailable <= 0 || dragWeightsSum <= 0) return; + + boolean horizontal = dragBranch.orientation == Orientation.HORIZONTAL; + int moved = horizontal ? movedX : movedY; + if (moved == 0) return; + + double sum = dragWeightsSum; + double weightA = dragBranch.weights.get(dragIndex); + double weightB = dragBranch.weights.get(dragIndex + 1); + double extentA = dragAvailable * weightA / sum; + double extentB = dragAvailable * weightB / sum; + + double min = horizontal ? MIN_PANE_WIDTH : MIN_PANE_HEIGHT; + double delta = Mth.clamp(moved, -(extentA - min), extentB - min); + if (delta == 0) return; + + dragBranch.weights.set(dragIndex, (extentA + delta) * sum / dragAvailable); + dragBranch.weights.set(dragIndex + 1, (extentB - delta) * sum / dragAvailable); + } + + // ── Hit tests ───────────────────────────────────────────────────────── + + /** Only headers and sashes answer to the mouse: the rest of the area is panes. */ + @Override + public boolean inside(double x, double y) { + return sashAt((int) x, (int) y) != null || headerAt((int) x, (int) y) != null; + } + + private SashHit sashAt(int x, int y) { + for (SashHit sash : sashLayouts) + if (inRect(x, y, sash.x0(), sash.y0(), sash.x1(), sash.y1())) return sash; + return null; + } + + private HeaderHit headerAt(int x, int y) { + for (HeaderHit header : headerLayouts) + if (inRect(x, y, header.x0(), header.y0(), header.x1(), header.y1())) return header; + return null; + } + + /** + * How many buttons this pane's header has, counted from the right: the + * close button always, the two split buttons only on panes that can be + * tiled. + */ + private static int buttonCount(EditorPane pane) { + return pane.showSplitButtons() ? BUTTON_COUNT : 1; + } + + /** The {@code button} of this header, right to left: x0, y0, x1, y1. */ + private static int[] buttonRect(HeaderHit header, int button) { + int x1 = header.x1() - 2 - BUTTON_SIZE * button; + return new int[]{x1 - BUTTON_SIZE, header.y0(), x1, header.y1()}; + } + + private static boolean inRect(int x, int y, int x0, int y0, int x1, int y1) { + return x >= x0 && x < x1 && y >= y0 && y < y1; + } + + // ── Draw ────────────────────────────────────────────────────────────── + + @Override + public void draw(@NonNull GuiGraphicsExtractor graphics, int mouseX, int mouseY, double delta) { + relayout(); + + // The panes paint their own areas; this is what the headers and the + // sashes sit on, so nothing of the world shows between them. + graphics.fill(getStartX(), getStartY(), getEndX(), getEndY(), COLOR_BACKGROUND); + + Font font = editorScreen.getFont(); + + for (SashHit sash : sashLayouts) { + boolean grabbing = dragBranch == sash.branch && dragIndex == sash.index; + int colour = (grabbing || inRect(mouseX, mouseY, sash.x0(), sash.y0(), sash.x1(), sash.y1())) + ? COLOR_SASH_HOVER : COLOR_SASH; + if (sash.horizontal()) { + int line = (sash.x0() + sash.x1()) / 2; + graphics.fill(line, sash.y0(), line + 1, sash.y1(), colour); + } else { + int line = (sash.y0() + sash.y1()) / 2; + graphics.fill(sash.x0(), line, sash.x1(), line + 1, colour); + } + } + + for (HeaderHit header : headerLayouts) drawHeader(graphics, font, header, mouseX, mouseY); + } + + private void drawHeader(GuiGraphicsExtractor graphics, Font font, HeaderHit header, int mouseX, int mouseY) { + EditorPane view = header.leaf().view; + boolean active = view == activePane; + int buttons = buttonCount(view); + + graphics.fill(header.x0(), header.y0(), header.x1(), header.y1(), + active ? COLOR_HEADER_ACTIVE : COLOR_HEADER); + if (active) + graphics.fill(header.x0(), header.y1() - 1, header.x1(), header.y1(), COLOR_ACTIVE_ACCENT); + + int labelWidth = header.x1() - header.x0() - 8 - BUTTON_SIZE * buttons; + String name = truncateToFit(font, view.paneTitle(), labelWidth); + graphics.text(font, name, header.x0() + 4, header.y0() + 2, + active ? COLOR_HEADER_TEXT : COLOR_HEADER_DIM, false); + + // Hovered button gets a background before any icon is drawn. + for (int button = 0; button < buttons; button++) { + int[] rect = buttonRect(header, button); + if (inRect(mouseX, mouseY, rect[0], rect[1], rect[2], rect[3])) + graphics.fill(rect[0], rect[1], rect[2], rect[3], + button == BTN_CLOSE ? COLOR_BUTTON_CLOSE : COLOR_BUTTON_HOVER); + } + + for (int button = 0; button < buttons; button++) { + String[] glyph = switch (button) { + case BTN_CLOSE -> ICON_CLOSE; + case BTN_SPLIT_BELOW -> ICON_SPLIT_STACKED; + default -> ICON_SPLIT_SIDE; + }; + int[] rect = buttonRect(header, button); + drawIcon(graphics, glyph, + rect[0] + (BUTTON_SIZE - glyph[0].length()) / 2, + rect[1] + (BUTTON_SIZE - glyph.length) / 2, + COLOR_ICON); + } + } + + private static String truncateToFit(Font font, String text, int maxWidth) { + if (font.width(text) <= maxWidth) return text; + for (int i = text.length() - 1; i > 0; i--) { + String cut = text.substring(0, i) + ".."; + if (font.width(cut) <= maxWidth) return cut; + } + return ""; + } + + private static void drawIcon(GuiGraphicsExtractor graphics, String[] glyph, int x, int y, int colour) { + for (int row = 0; row < glyph.length; row++) { + String pixels = glyph[row]; + for (int column = 0; column < pixels.length(); column++) { + if (pixels.charAt(column) != '#') continue; + graphics.fill(x + column, y + row, x + column + 1, y + row + 1, colour); + } + } + } + + // ── Input ───────────────────────────────────────────────────────────── + + @Override + public boolean handleKeyPressed(KeyEvent event) { + return false; + } + + @Override + public boolean handleCharTyped(CharacterEvent event) { + return false; + } + + @Override + public boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick) { + if (event.button() != 0) return false; + + int mx = (int) event.x(); + int my = (int) event.y(); + + SashHit sash = sashAt(mx, my); + if (sash != null) { + dragBranch = sash.branch; + dragIndex = sash.index; + dragAvailable = sash.available; + dragWeightsSum = sash.weightsSum; + lastDragX = mx; + lastDragY = my; + return true; + } + + HeaderHit header = headerAt(mx, my); + if (header == null) return false; + + int buttons = buttonCount(header.leaf().view); + for (int button = 0; button < buttons; button++) { + int[] rect = buttonRect(header, button); + if (!inRect(mx, my, rect[0], rect[1], rect[2], rect[3])) continue; + + switch (button) { + case BTN_CLOSE -> closePane(header.leaf().view); + case BTN_SPLIT_BELOW -> split(Orientation.VERTICAL, header.leaf().view); + case BTN_SPLIT_RIGHT -> split(Orientation.HORIZONTAL, header.leaf().view); + } + return true; + } + + // A click on a header picks that pane: files opened from the tree go + // there, and the keyboard follows it. + setActivePane(header.leaf().view); + if (editorScreen != null) editorScreen.selectedWidget = header.leaf().view; + return true; + } + + @Override + public boolean handleMouseDragged(MouseButtonEvent event) { + if (dragBranch == null) return false; + + int mx = (int) event.x(); + int my = (int) event.y(); + resizeSash(mx - lastDragX, my - lastDragY); + lastDragX = mx; + lastDragY = my; + relayout(); + return true; + } + + @Override + public boolean handleMouseReleased(MouseButtonEvent event) { + if (dragBranch == null) return false; + + dragBranch = null; + // The keyboard goes back where it was before the sash took it. + if (editorScreen != null && editorScreen.selectedWidget == this) + editorScreen.selectedWidget = activePane; + return true; + } + + @Override + public boolean handleMouseScrolled(double scrollY) { + return false; + } +} diff --git a/src/client/java/com/aranroig/client/editor/EditorScreen.java b/src/client/java/com/aranroig/client/editor/EditorScreen.java index 3de9c3b..e98dcc2 100644 --- a/src/client/java/com/aranroig/client/editor/EditorScreen.java +++ b/src/client/java/com/aranroig/client/editor/EditorScreen.java @@ -25,6 +25,16 @@ public abstract class EditorScreen extends Screen { widgets.add(widget); } + /** + * Drops a widget from this screen: it stops being drawn and can no longer + * be clicked. Used when a pane closes, so its area is left to the panes + * that take it over. + */ + public void removeWidget(Widget widget){ + widgets.remove(widget); + if(selectedWidget == widget) selectedWidget = null; + } + @Override public boolean keyPressed(KeyEvent event) { if(selectedWidget != null){ @@ -51,11 +61,16 @@ public abstract class EditorScreen extends Screen { @Override public boolean mouseClicked(final MouseButtonEvent event, final boolean doubleClick) { - selectedWidget = raycastWidget(event); + Widget hit = raycastWidget(event.x(), event.y()); + if (selectedWidget != null && selectedWidget != hit) { + selectedWidget.handleFocusLost(); + } + selectedWidget = hit; + if(selectedWidget != null) if (event.button() == 0) { // left button isDragging = true; - if(selectedWidget.handleMouseClicked(event)) + if(selectedWidget.handleMouseClicked(event, doubleClick)) return true; } return super.mouseClicked(event, doubleClick); @@ -84,21 +99,24 @@ public abstract class EditorScreen extends Screen { @Override public boolean mouseScrolled(final double x, final double y, final double scrollX, final double scrollY) { - if (selectedWidget != null){ - if (selectedWidget.inside(x, y)) { - // scrollY from GLFW: positive = up, which in our model = scroll content upward - if(selectedWidget.handleMouseScrolled(scrollY)) - return true; - } - } + // The widget under the mouse scrolls, not the one holding the keyboard: + // with several panes open, hovering one and scrolling should move that + // one. The focused widget keeps priority while it is under the mouse + // (the docs modal counts on it). + Widget target = raycastWidget(x, y); + if (selectedWidget != null && selectedWidget.inside(x, y)) target = selectedWidget; + + if (target != null && target.handleMouseScrolled(scrollY)) + return true; return super.mouseScrolled(x, y, scrollX, scrollY); } - private Widget raycastWidget(MouseButtonEvent event) { + /** The topmost widget containing this point, by z-index. */ + private Widget raycastWidget(double x, double y) { Widget bestWidget = null; for(Widget widget : widgets){ - if(widget.inside(event.x(), event.y())){ + if(widget.inside(x, y)){ if(bestWidget == null) bestWidget = widget; else { if(bestWidget.getZIndex() < widget.getZIndex()) { diff --git a/src/client/java/com/aranroig/client/editor/EditorTerminalPane.java b/src/client/java/com/aranroig/client/editor/EditorTerminalPane.java new file mode 100644 index 0000000..9e6feb8 --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/EditorTerminalPane.java @@ -0,0 +1,308 @@ +package com.aranroig.client.editor; + +import net.minecraft.client.gui.Font; +import net.minecraft.client.gui.GuiGraphicsExtractor; +import net.minecraft.client.input.CharacterEvent; +import net.minecraft.client.input.KeyEvent; +import net.minecraft.client.input.MouseButtonEvent; +import org.jspecify.annotations.NonNull; + +/** + * The terminal pane: keystrokes leave for the server one at a time — no + * local buffer, no Enter to submit — and the shell's output is handed to a + * {@link TerminalEmulator}, which is drawn where it stands. The caret is the + * shell's own cursor: what you type is echoed by the shell's tty, edited by + * its readline, and everything a real terminal is, this is — vim takes the + * screen, less scrolls, Ctrl-C kills. + * + *

The pane's own business is the window around that screen: sizing the + * grid to its pixels and telling the server that size — which moves the + * pseudo-terminal's own window, so full-screen programs notice a resize while + * they run — following output at the bottom until the wheel scrolls up, and + * drawing the cursor over whatever the emulator put there. Escape goes to the + * shell (vim would notice); the editor itself closes on its keybind, as + * ever.

+ */ +public class EditorTerminalPane extends EditorPane { + + private static final int SCROLL_SPEED = 3; // lines per wheel notch + private static final int PAD = 2; + private static final int DEFAULT_COLS = 80; + private static final int DEFAULT_ROWS = 24; + + /** Frames a new grid sits still before the server is told: dragging a sash resizes every frame. */ + private static final int RESIZE_SETTLE_FRAMES = 8; + + private static final int COLOR_BACKGROUND = 0xFF141414; + private static final int COLOR_NOTE = 0xFF888888; // pane notes, not shell output + private static final int COLOR_CURSOR = 0xFFD0D0D0; + private static final int COLOR_CURSOR_TEXT = 0xFF141414; + + private final TerminalEmulator emu = new TerminalEmulator(DEFAULT_COLS, DEFAULT_ROWS, this::answerShell); + + /** Lines the view is lifted from the bottom; 0 = pinned, following. */ + private int scroll; + + private boolean shellAlive = true; + + /** The grid the server was last told about, so a settled size is told once. */ + private int sentRows = -1, sentCols = -1; + + /** A grid the server has not been told about yet, counted up to {@link #RESIZE_SETTLE_FRAMES}. */ + private int pendingRows = -1, pendingCols = -1, pendingFrames; + + private Font font; + + public EditorTerminalPane(EditorManager editorManager) { + super(editorManager); + } + + @Override + public String paneTitle() { + return "Shell"; + } + + /** One shell, no point offering to tile two views of the same thing. */ + @Override + public boolean showSplitButtons() { + return false; + } + + /** Closing the pane means closing the shell: it is not kept for later. */ + @Override + public void onPaneClosed() { + editorManager.closeShell(); + } + + /** The grid the shell would open on, for the spawn payload. */ + public int terminalCols() { return emu.cols(); } + public int terminalRows() { return emu.rows(); } + + // ── Output ──────────────────────────────────────────────────────────── + + /** Hands the emulator one chunk of what the shell printed. */ + public void appendOutput(String text) { + shellAlive = true; + emu.feed(text); + + // At the bottom, new lines pull the view along; scrolled up reading + // something older, the view holds still instead of drifting. + if (scroll > 0) scroll = Math.min(scroll + emu.poppedLastFeed(), emu.scrollbackSize()); + } + + /** The shell exited or could not start: say so and let the button respawn it. */ + public void markClosed(String reason) { + shellAlive = false; + sentRows = sentCols = -1; + pendingRows = -1; + emu.writeText(reason + "\r\n", COLOR_NOTE); + } + + /** A fresh shell is starting: an empty screen, and what is happening. */ + public void announce(String what) { + // Size first: the pane may never have been drawn, and the spawn + // payload that follows should carry the real grid, not the defaults. + if (editorScreen != null) { + font = editorScreen.getFont(); + fitSize(); + } + emu.reset(); + emu.clearScrollback(); + scroll = 0; + shellAlive = true; + // Nothing is "already told" about size to a new shell: the spawn + // payload carries this grid, and the first draws tell it again once + // the server can reach the pty's device — a fresh pty starts at the + // kernel's default, and this corrects it well before bash settles. + sentRows = sentCols = -1; + pendingRows = emu.rows(); + pendingCols = emu.cols(); + pendingFrames = 0; + emu.writeText(what + "\r\n", COLOR_NOTE); + } + + // ── Geometry: the grid follows the pane, and the server is told of it ─ + + private int cellWidth() { + // A terminal is a grid, and the default font is not one: every cell + // gets the width of the widest letter, so columns line up even if + // narrow letters travel with extra air around them. + return Math.max(4, font.width("M")); + } + + private void fitSize() { + int newCols = clamp((getEndX() - getStartX() - 2 * PAD) / cellWidth(), 10, 512); + int newRows = clamp((getEndY() - getStartY() - 2 * PAD) / font.lineHeight, 3, 512); + if (newCols != emu.cols() || newRows != emu.rows()) { + emu.resize(newCols, newRows); + pendingRows = newRows; + pendingCols = newCols; + pendingFrames = 0; + } + } + + /** + * Tells the server a grid that has sat still for a moment, so the pty's + * window moves: the kernel resizes the terminal and signals whatever the + * shell is running, which is what lets a full-screen program reflow + * mid-resize. Nothing is typed into the shell for this — no {@code stty} + * or {@code export} landing in vim's keystrokes — and dragging a sash + * costs one message, for the size it settles on. + */ + private void pumpResize() { + if (pendingRows < 0) return; + if (!shellAlive || (pendingRows == sentRows && pendingCols == sentCols)) { + pendingRows = -1; + return; + } + if (pendingFrames++ < RESIZE_SETTLE_FRAMES) return; + sentRows = pendingRows; + sentCols = pendingCols; + pendingRows = -1; + editorManager.sendShellResize(sentRows, sentCols); + } + + private static int clamp(int value, int low, int high) { + return Math.max(low, Math.min(value, high)); + } + + // ── Draw ────────────────────────────────────────────────────────────── + + @Override + public void draw(@NonNull GuiGraphicsExtractor graphics, int mouseX, int mouseY, double delta) { + font = editorScreen.getFont(); + fitSize(); + scroll = clamp(scroll, 0, emu.scrollbackSize()); + + pumpResize(); + + int lineH = font.lineHeight; + int cellW = cellWidth(); + int left = getStartX() + PAD; + int top = getStartY() + PAD; + int rows = emu.rows(); + + graphics.fill(getStartX(), getStartY(), getEndX(), getEndY(), COLOR_BACKGROUND); + graphics.enableScissor(getStartX(), top, getEndX(), getEndY() - PAD); + + // The content is scrollback, then the screen; the view is a window of + // `rows` lines onto it, pinned to the bottom until scrolled up. + int total = emu.scrollbackSize() + rows; + int end = total - scroll; + int start = Math.max(0, end - rows); + for (int line = start; line < end; line++) { + int y = top + (line - start) * lineH; + for (int x = 0; x < emu.cols(); x++) { + char c = emu.charAt(line, x); + if (c == ' ') continue; + graphics.text(font, String.valueOf(c), left + x * cellW, y, emu.colorAt(line, x), false); + } + } + + drawCursor(graphics, left, top, cellW, lineH, start, end); + + graphics.disableScissor(); + } + + private void drawCursor(GuiGraphicsExtractor graphics, int left, int top, + int cellW, int lineH, int start, int end) { + if (!emu.cursorVisible()) return; + int line = emu.cursorContentLine(); + if (line < start || line >= end) return; + + int x = left + emu.cursorX() * cellW; + int y = top + (line - start) * lineH; + char at = emu.charAt(line, emu.cursorX()); + + if (editorScreen.selectedWidget == this) { + graphics.fill(x, y, x + cellW, y + lineH, COLOR_CURSOR); + if (at != ' ') graphics.text(font, String.valueOf(at), x, y, COLOR_CURSOR_TEXT, false); + } else { + // The keyboard belongs elsewhere: an outline, not a block. + graphics.fill(x, y, x + cellW, y + 1, COLOR_CURSOR); + graphics.fill(x, y + lineH - 1, x + cellW, y + lineH, COLOR_CURSOR); + graphics.fill(x, y + 1, x + 1, y + lineH - 1, COLOR_CURSOR); + graphics.fill(x + cellW - 1, y + 1, x + cellW, y + lineH - 1, COLOR_CURSOR); + } + } + + // ── Input: keystrokes go to the shell, one by one ───────────────────── + + @Override + public boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick) { + // Clicking the terminal means the keyboard belongs to the shell now. + editorManager.setActivePane(this); + scroll = 0; + return true; + } + + @Override + public boolean handleMouseScrolled(double scrollY) { + scroll = clamp(scroll + (int) Math.round(scrollY * SCROLL_SPEED), 0, emu.scrollbackSize()); + return true; + } + + @Override + public boolean handleMouseDragged(MouseButtonEvent event) { + return true; + } + + @Override + public boolean handleMouseReleased(MouseButtonEvent event) { + return true; + } + + @Override + public boolean handleKeyPressed(KeyEvent event) { + int key = event.key(); + + if (event.hasControlDown() && key >= 65 && key <= 90) { + // Ctrl+letter is not a letter: it is \u0001..\u001A, which the tty + // turns into signals and edits (Ctrl-C, Ctrl-D, Ctrl-R…). + sendToShell(String.valueOf((char) (key - 64))); + return true; + } + + boolean appKeys = emu.appCursorKeys(); + switch (key) { + // Escape belongs to the shell (vim would notice): the editor + // closes on its own keybind instead. + case 256 -> sendToShell("\u001B"); + case 257, 335 -> sendToShell("\r"); // Enter, keypad Enter + case 258 -> sendToShell("\t"); // Tab: completion, in shell and vim alike + case 259 -> sendToShell("\u007F"); // Backspace: DEL, what readline expects + case 260 -> sendToShell("\u001B[2~"); // Insert + case 261 -> sendToShell("\u001B[3~"); // Delete + case 262 -> sendToShell(appKeys ? "\u001BOC" : "\u001B[C"); // Right + case 263 -> sendToShell(appKeys ? "\u001BOD" : "\u001B[D"); // Left + case 264 -> sendToShell(appKeys ? "\u001BOB" : "\u001B[B"); // Down + case 265 -> sendToShell(appKeys ? "\u001BOA" : "\u001B[A"); // Up + case 266 -> sendToShell("\u001B[5~"); // Page Up + case 267 -> sendToShell("\u001B[6~"); // Page Down + case 268 -> sendToShell(appKeys ? "\u001BOH" : "\u001B[1~"); // Home + case 269 -> sendToShell(appKeys ? "\u001BOF" : "\u001B[4~"); // End + default -> { } + } + return true; + } + + @Override + public boolean handleCharTyped(CharacterEvent event) { + int codePoint = event.codepoint(); + if (codePoint < 32 || codePoint == 127) return true; // keys, not text: those went through keyPressed + sendToShell(Character.toString(codePoint)); + return true; + } + + /** Types one keystroke's worth into the shell — if there is one to type into. */ + private void sendToShell(String bytes) { + if (!shellAlive) return; // markClosed already said it on the screen + scroll = 0; // typing looks at where the typing is + editorManager.sendShellControl(bytes); + } + + /** The emulator's turn to speak (device attributes, cursor position): back as the shell's input. */ + private void answerShell(String response) { + if (shellAlive) editorManager.sendShellControl(response); + } +} diff --git a/src/client/java/com/aranroig/client/editor/EditorTopBar.java b/src/client/java/com/aranroig/client/editor/EditorTopBar.java index 87ed09a..a259cc5 100644 --- a/src/client/java/com/aranroig/client/editor/EditorTopBar.java +++ b/src/client/java/com/aranroig/client/editor/EditorTopBar.java @@ -1,5 +1,6 @@ package com.aranroig.client.editor; +import com.aranroig.editor.EditorPresence; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GuiGraphicsExtractor; import net.minecraft.client.input.CharacterEvent; @@ -35,13 +36,13 @@ public class EditorTopBar extends Widget { static MenuItem separator() { return new MenuItem("", true); } } - private static final String[] TAB_LABELS = { "File", "Edit", "Run", "Help" }; + private static final String[] TAB_LABELS = { "File", "Edit", "Run", "View", "Help" }; private static final List> TAB_ITEMS = List.of( // File List.of( MenuItem.item("New File"), - MenuItem.item("Open..."), + MenuItem.item("New Folder..."), MenuItem.item("Save"), MenuItem.item("Save As..."), MenuItem.separator(), @@ -66,6 +67,13 @@ public class EditorTopBar extends Widget { MenuItem.separator(), MenuItem.item("Build Project") ), + // View + List.of( + MenuItem.item("Split Right"), + MenuItem.item("Split Below"), + MenuItem.separator(), + MenuItem.item("Close Pane") + ), // Help List.of( MenuItem.item("Lua API Documentation") @@ -78,6 +86,36 @@ public class EditorTopBar extends Widget { /** Mouse position, updated each frame from the screen. */ private int mouseX, mouseY; + // ── Shell button ────────────────────────────────────────────────────── + // The one action that deserves to be a button instead of a menu item. + + private static final String SHELL_LABEL = ">_ Shell"; + private static final int COLOR_SHELL_ACCENT = 0xFF44688A; + + private int shellButtonWidth(Font font) { return font.width(SHELL_LABEL) + TAB_PADDING_X * 2 + 2; } + private int shellButtonX0(Font font) { return getEndX() - shellButtonWidth(font); } + + private boolean insideShellButton(int mx, int my, Font font) { + return mx >= shellButtonX0(font) && mx < getEndX() + && my >= getStartY() && my < getStartY() + BAR_HEIGHT; + } + + private void drawShellButton(GuiGraphicsExtractor graphics, Font font) { + int x0 = shellButtonX0(font); + int y0 = getStartY(); + int y1 = y0 + BAR_HEIGHT; + + boolean open = editorManager.isShellOpen(); + boolean hovered = insideShellButton(mouseX, mouseY, font); + + graphics.fill(x0, y0, getEndX(), y1, + open ? COLOR_TAB_OPEN : hovered ? COLOR_TAB_HOVER : COLOR_BACKGROUND); + graphics.text(font, SHELL_LABEL, x0 + TAB_PADDING_X, y0 + TAB_PADDING_Y, COLOR_TEXT, false); + + // The same underline the active pane header wears: this pane is open. + if (open) graphics.fill(x0, y1 - 1, getEndX(), y1, COLOR_SHELL_ACCENT); + } + // ── Drawing ─────────────────────────────────────────────────────────── public void draw(@NonNull GuiGraphicsExtractor graphics, int mouseX, int mouseY, double delta) { @@ -118,8 +156,45 @@ public class EditorTopBar extends Widget { tabX = tabEndX; } + + drawShellButton(graphics, font); + drawCollaborators(graphics, font); } + /** + * Who else is in the file you are looking at, on the right of the bar: a + * coloured dot and a name each, in the colour their caret is drawn in. + * Nothing here means nobody else has this file open. + */ + private void drawCollaborators(GuiGraphicsExtractor graphics, Font font) { + List editors = editorManager.collaborators(); + if (editors.isEmpty()) return; + + List shown = editors.size() > MAX_COLLABORATOR_LABELS + ? editors.subList(0, MAX_COLLABORATOR_LABELS) + : editors; + + String more = editors.size() > shown.size() ? "+" + (editors.size() - shown.size()) : ""; + int width = font.width(more); + for (EditorPresence editor : shown) width += font.width(editor.name()) + 13; + + // Right-aligned, but never over the menu labels — and leaving the + // shell button its own space at the end of the bar. + int x = Math.max(getStartX() + 120, getEndX() - shellButtonWidth(font) - width); + int y = getStartY() + TAB_PADDING_Y; + + for (EditorPresence editor : shown) { + graphics.fill(x, y + 1, x + 3, y + font.lineHeight - 1, editor.color()); + graphics.text(font, editor.name(), x + 5, y, editor.color(), false); + x += font.width(editor.name()) + 13; + } + if (!more.isEmpty()) { + graphics.text(font, more, x, y, COLOR_TEXT, false); + } + } + + private static final int MAX_COLLABORATOR_LABELS = 4; + @Override public boolean handleKeyPressed(KeyEvent event) { return false; @@ -131,7 +206,7 @@ public class EditorTopBar extends Widget { } @Override - public boolean handleMouseClicked(MouseButtonEvent event) { + public boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick) { int button = event.button(); double mx = event.x(); double my = event.y(); @@ -155,6 +230,13 @@ public class EditorTopBar extends Widget { tabX = tabEndX; } + // The shell button, at the end of the bar. + if (insideShellButton(imx, imy, font())) { + openTab = -1; + editorManager.toggleShell(); + return true; + } + // Click on a dropdown item? if (openTab >= 0) { int result = getClickedItemIndex(imx, imy, openTab); @@ -235,11 +317,15 @@ public class EditorTopBar extends Widget { // TODO: wire these to your EditorManager switch (item.label()) { case "New File" -> editorManager.newFile(); + case "New Folder..." -> editorManager.newFolder(); case "Save" -> editorManager.save(); case "Undo" -> editorManager.undo(); case "Redo" -> editorManager.redo(); case "Run Script" -> editorManager.run(); case "Stop" -> editorManager.stop(); + case "Split Right" -> editorManager.splitRight(); + case "Split Below" -> editorManager.splitBelow(); + case "Close Pane" -> editorManager.closeActivePane(); case "Lua API Documentation" -> editorManager.openDocs(); // Add remaining cases as needed default -> System.out.println("[TopBar] Clicked: " + item.label()); diff --git a/src/client/java/com/aranroig/client/editor/EventsLibrary.java b/src/client/java/com/aranroig/client/editor/EventsLibrary.java new file mode 100644 index 0000000..28a3e8d --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/EventsLibrary.java @@ -0,0 +1,30 @@ +package com.aranroig.client.editor; + +import java.util.List; + +/** + * Completion for the {@code events} global — game event listeners provided by + * codecraft itself. Keep in sync with the listener registration and + * {@code LuaApiDocs}. + */ +public class EventsLibrary implements LuaLibrary { + + private static final List MEMBERS = List.of( + CompletionItem.method("on_use_item", "on_use_item("), + CompletionItem.method("on_break_block", "on_break_block("), + CompletionItem.method("on_chat", "on_chat("), + CompletionItem.method("on_player_join", "on_player_join("), + CompletionItem.method("on_player_leave", "on_player_leave("), + CompletionItem.method("on_tick", "on_tick(") + ); + + @Override + public String name() { + return "events"; + } + + @Override + public List members() { + return MEMBERS; + } +} diff --git a/src/client/java/com/aranroig/client/editor/LiveDocument.java b/src/client/java/com/aranroig/client/editor/LiveDocument.java new file mode 100644 index 0000000..52e83cb --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/LiveDocument.java @@ -0,0 +1,109 @@ +package com.aranroig.client.editor; + +import com.aranroig.editor.Edit; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.UUID; + +/** + * What the client needs to know to edit a document together with other players: + * which version of the server's copy the buffer holds, and which of the + * player's own edits the server has not confirmed yet. + * + *

Local edits are applied to the buffer straight away (typing must feel + * instant) and kept in {@link #pending} until the server confirms them. While + * they are in flight someone else's edit can arrive, and the two were written + * against the same version of the text; {@link #integrateRemote} rewrites both + * so they fit one after the other, which is what stops concurrent typing from + * throwing characters away or applying them at the wrong offset.

+ * + *

Every notification the server sends about a document — somebody else's + * edit, or the ack of one of ours — carries its version and arrives in order, + * so {@link #base()} only ever moves forward and one ack retires exactly one + * pending edit.

+ */ +public final class LiveDocument { + + private final UUID author; + + /** Server version the buffer corresponds to, ignoring the edits in flight. */ + private int base; + + /** Our own edits, oldest first, that the server has not acknowledged yet. */ + private final Deque pending = new ArrayDeque<>(); + + private long sequence; + + public LiveDocument(UUID author) { + this.author = author; + } + + /** + * Records an edit the player just made locally and returns it, ready to be + * sent with {@link #base()} as the version it was written against. Returns + * {@code null} when the change amounts to nothing, so it is not queued or + * sent at all. + */ + public Edit submit(int position, int deleteLength, String insert) { + Edit edit = Edit.replace(author, sequence, position, deleteLength, insert); + if (edit.isEmpty()) return null; + sequence++; + pending.addLast(edit); + return edit; + } + + /** The version of the server's copy this buffer was written against. */ + public int base() { + return base; + } + + /** True when everything the player typed has been confirmed by the server. */ + public boolean isSynced() { + return pending.isEmpty(); + } + + /** + * Notes that the server applied the oldest of our edits, taking the document + * to {@code version}. + */ + public void onAck(int version) { + if (!pending.isEmpty()) pending.removeFirst(); + base = Math.max(base, version); + } + + /** + * Folds somebody else's edit into the local state and returns the version of + * it that fits our buffer, i.e. the one to apply to it. The edits + * still in flight are rewritten the same way, so they stay valid against the + * text they will be replayed onto. + */ + public Edit integrateRemote(int version, Edit remote) { + Edit toApply = remote; + if (!pending.isEmpty()) { + List rebased = new ArrayList<>(pending.size()); + for (Edit mine : pending) { + // One walk gives both directions: the remote edit as it fits our + // buffer, and our edit as it fits the text it will be acked onto. + Edit[] pair = Edit.transformPair(toApply, mine); + toApply = pair[0]; + rebased.add(pair[1]); + } + pending.clear(); + pending.addAll(rebased); + } + base = Math.max(base, version); + return toApply; + } + + /** + * Adopts the server's document wholesale: nothing is in flight any more and + * the buffer is about to be replaced with {@code version} of it. + */ + public void resetTo(int version) { + pending.clear(); + base = version; + } +} diff --git a/src/client/java/com/aranroig/client/editor/LuaLibrary.java b/src/client/java/com/aranroig/client/editor/LuaLibrary.java new file mode 100644 index 0000000..d24be5f --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/LuaLibrary.java @@ -0,0 +1,21 @@ +package com.aranroig.client.editor; + +import java.util.List; + +/** + * A named Lua global table that supports member completion after a "." or ":" + * trigger — Lua's own standard libraries ({@code string}, {@code math}, …) and + * the tables codecraft itself injects ({@code world}, {@code events}). + * + *

To make a new library's members appear in the autocomplete popup, + * implement this interface and add an instance to + * {@link CompletionProvider}.

+ */ +public interface LuaLibrary { + + /** The global table name, e.g. {@code "math"} for {@code math.floor}. */ + String name(); + + /** Members offered when the user types {@code name.} in the editor. */ + List members(); +} diff --git a/src/client/java/com/aranroig/client/editor/LuaSnippets.java b/src/client/java/com/aranroig/client/editor/LuaSnippets.java new file mode 100644 index 0000000..386f13c --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/LuaSnippets.java @@ -0,0 +1,85 @@ +package com.aranroig.client.editor; + +import java.util.List; + +/** + * The common Lua code templates offered at the top level of the autocomplete + * popup (kind {@link CompletionItem.Kind#SNIPPET}) and loaded by + * {@link CompletionProvider}. + */ +public final class LuaSnippets { + + private LuaSnippets() { + } + + private static final List SNIPPETS = List.of( + CompletionItem.snippet("fun", + "function ()\n \nend", + "anonymous function"), + CompletionItem.snippet("function", + "function name()\n \nend", + "named function"), + CompletionItem.snippet("lfun", + "local function name()\n \nend", + "local function"), + CompletionItem.snippet("if", + "if then\n \nend", + "if block"), + CompletionItem.snippet("ifel", + "if then\n \nelse\n \nend", + "if / else"), + CompletionItem.snippet("ifelseif", + "if then\n \nelseif then\n \nelse\n \nend", + "if / elseif / else"), + CompletionItem.snippet("for", + "for i = 1, do\n \nend", + "numeric for"), + CompletionItem.snippet("forin", + "for k, v in pairs() do\n \nend", + "generic for (pairs)"), + CompletionItem.snippet("fori", + "for i, v in ipairs() do\n \nend", + "generic for (ipairs)"), + CompletionItem.snippet("while", + "while do\n \nend", + "while loop"), + CompletionItem.snippet("repeat", + "repeat\n \nuntil ", + "repeat / until"), + CompletionItem.snippet("pcall", + "local ok, err = pcall(function()\n \nend)", + "protected call"), + CompletionItem.snippet("class", + "local ClassName = {}\nClassName.__index = ClassName\n\nfunction ClassName.new()\n local self = setmetatable({}, ClassName)\n return self\nend\n\nreturn ClassName", + "OOP class template"), + CompletionItem.snippet("require", + "local = require(\"\")", + "require module"), + CompletionItem.snippet("print", + "print()", + "print(…)"), + CompletionItem.snippet("setblock", + "world.set_block(, , , \"minecraft:stone\")", + "world.set_block(…)"), + CompletionItem.snippet("removeblock", + "world.remove_block(, , )", + "world.remove_block(…)"), + CompletionItem.snippet("getblock", + "local block = world.get_block(, , )", + "world.get_block(…)"), + CompletionItem.snippet("onevent", + "events.on_chat(function(player, message)\n \nend)", + "event listener"), + CompletionItem.snippet("local", + "local = ", + "local variable"), + CompletionItem.snippet("return", + "return ", + "return statement") + ); + + /** All snippets, in display order. */ + public static List all() { + return SNIPPETS; + } +} diff --git a/src/client/java/com/aranroig/client/editor/LuaStandardLibraries.java b/src/client/java/com/aranroig/client/editor/LuaStandardLibraries.java new file mode 100644 index 0000000..c0d21ce --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/LuaStandardLibraries.java @@ -0,0 +1,120 @@ +package com.aranroig.client.editor; + +import java.util.List; + +/** + * The Lua standard library tables ({@code string}, {@code table}, {@code math}, + * {@code io}, {@code os}, {@code coroutine}) as {@link LuaLibrary} instances, + * so they can be loaded by {@link CompletionProvider} alongside the + * codecraft-provided libraries. + */ +public final class LuaStandardLibraries { + + private LuaStandardLibraries() { + } + + /** A library defined by a fixed member list. */ + private record SimpleLibrary(String name, List members) implements LuaLibrary { + } + + // ── string.* ────────────────────────────────────────────────────────── + private static final LuaLibrary STRING = new SimpleLibrary("string", List.of( + CompletionItem.method("byte(", "byte("), + CompletionItem.method("char(", "char("), + CompletionItem.method("dump(", "dump("), + CompletionItem.method("find(", "find("), + CompletionItem.method("format(", "format("), + CompletionItem.method("gmatch(", "gmatch("), + CompletionItem.method("gsub(", "gsub("), + CompletionItem.method("len(", "len("), + CompletionItem.method("lower(", "lower("), + CompletionItem.method("match(", "match("), + CompletionItem.method("rep(", "rep("), + CompletionItem.method("reverse(", "reverse("), + CompletionItem.method("sub(", "sub("), + CompletionItem.method("upper(", "upper(") + )); + + // ── table.* ─────────────────────────────────────────────────────────── + private static final LuaLibrary TABLE = new SimpleLibrary("table", List.of( + CompletionItem.method("concat(", "concat("), + CompletionItem.method("insert(", "insert("), + CompletionItem.method("move(", "move("), + CompletionItem.method("pack(", "pack("), + CompletionItem.method("remove(", "remove("), + CompletionItem.method("sort(", "sort("), + CompletionItem.method("unpack(", "unpack(") + )); + + // ── math.* ──────────────────────────────────────────────────────────── + private static final LuaLibrary MATH = new SimpleLibrary("math", List.of( + CompletionItem.method("abs", "abs("), + CompletionItem.method("ceil", "ceil("), + CompletionItem.method("cos", "cos("), + CompletionItem.method("exp", "exp("), + CompletionItem.method("floor", "floor("), + CompletionItem.method("fmod", "fmod("), + CompletionItem.method("log", "log("), + CompletionItem.method("max", "max("), + CompletionItem.method("min", "min("), + CompletionItem.method("modf", "modf("), + CompletionItem.method("pow", "pow("), + CompletionItem.method("random", "random("), + CompletionItem.method("randomseed", "randomseed("), + CompletionItem.method("sin", "sin("), + CompletionItem.method("sqrt", "sqrt("), + CompletionItem.method("tan", "tan("), + CompletionItem.method("tointeger", "tointeger("), + CompletionItem.method("type", "type("), + CompletionItem.method("huge", "huge"), + CompletionItem.method("pi", "pi"), + CompletionItem.method("maxinteger", "maxinteger"), + CompletionItem.method("mininteger", "mininteger") + )); + + // ── io.* ────────────────────────────────────────────────────────────── + private static final LuaLibrary IO = new SimpleLibrary("io", List.of( + CompletionItem.method("close", "close("), + CompletionItem.method("flush", "flush()"), + CompletionItem.method("input", "input("), + CompletionItem.method("lines", "lines("), + CompletionItem.method("open", "open("), + CompletionItem.method("output", "output("), + CompletionItem.method("popen", "popen("), + CompletionItem.method("read", "read("), + CompletionItem.method("tmpfile", "tmpfile()"), + CompletionItem.method("type", "type("), + CompletionItem.method("write", "write(") + )); + + // ── os.* ────────────────────────────────────────────────────────────── + private static final LuaLibrary OS = new SimpleLibrary("os", List.of( + CompletionItem.method("clock", "clock()"), + CompletionItem.method("date", "date("), + CompletionItem.method("difftime", "difftime("), + CompletionItem.method("execute", "execute("), + CompletionItem.method("exit", "exit("), + CompletionItem.method("getenv", "getenv("), + CompletionItem.method("remove", "remove("), + CompletionItem.method("rename", "rename("), + CompletionItem.method("setlocale", "setlocale("), + CompletionItem.method("time", "time("), + CompletionItem.method("tmpname", "tmpname()") + )); + + // ── coroutine.* ─────────────────────────────────────────────────────── + private static final LuaLibrary COROUTINE = new SimpleLibrary("coroutine", List.of( + CompletionItem.method("create", "create("), + CompletionItem.method("isyieldable", "isyieldable()"), + CompletionItem.method("resume", "resume("), + CompletionItem.method("running", "running()"), + CompletionItem.method("status", "status("), + CompletionItem.method("wrap", "wrap("), + CompletionItem.method("yield", "yield(") + )); + + /** All standard libraries, in display order. */ + public static List all() { + return List.of(STRING, TABLE, MATH, IO, OS, COROUTINE); + } +} diff --git a/src/client/java/com/aranroig/client/editor/TerminalEmulator.java b/src/client/java/com/aranroig/client/editor/TerminalEmulator.java new file mode 100644 index 0000000..344c099 --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/TerminalEmulator.java @@ -0,0 +1,629 @@ +package com.aranroig.client.editor; + +import java.util.function.Consumer; + +/** + * The terminal emulator: a character grid with a cursor, doing what the + * escape sequences a shell prints tell it to do. This class has no idea a + * game exists — it is the screen, and a screen of any terminal program in + * the world would be too — so {@link EditorTerminalPane} draws it and feeds + * it, and nothing else has to care. + * + *

What it understands

+ * + *

Text and its control characters; SGR colours (the 16, 256 and true + * colour); cursor movement, positioning and saving; erasing line and screen; + * inserting and deleting lines and characters; scroll regions; the + * alternate screen full-screen programs switch to; cursor visibility; auto + * wrap; and the two device queries a program asks a terminal when it wants + * to know what it is talking to — the answers go back through the + * {@code responder} given at construction, because a terminal that stays + * quiet when asked is a program left waiting.

+ * + *

What it keeps

+ * + *

Rows that scroll off the top of the main screen become scrollback, up + * to a cap; the alternate screen produces none, which is why vim leaves no + * mess behind. Everything else — window size, keystrokes, what the shell + * should be told about its dimensions — belongs to the pane.

+ */ +public final class TerminalEmulator { + + /** The colour of a cell nothing has been said about. */ + public static final int DEFAULT_COLOR = 0xFFD4D4D4; + + /** Scrollback lines kept when a {@code yes} decides to introduce itself. */ + public static final int MAX_SCROLLBACK = 1000; + + /** SGR 30..37 and 90..97, in the order the shell counts them. */ + private static final int[] ANSI_COLORS = { + 0xFF000000, 0xFFAA0000, 0xFF00AA00, 0xFFAA5500, + 0xFF0000AA, 0xAA00AA00, 0xFF00AAAA, 0xFFAAAAAA, + 0xFF555555, 0xFFFF5555, 0xFF55FF55, 0xFFFF5555, + 0xFF5555FF, 0xFFFF55FF, 0xFF55FFFF, 0xFFFFFFFF, + }; + + /** One row: a fixed line of characters, one colour each. */ + public static final class Row { + final char[] ch; + final int[] fg; + + Row(int cols) { + ch = new char[cols]; + fg = new int[cols]; + java.util.Arrays.fill(ch, ' '); + java.util.Arrays.fill(fg, DEFAULT_COLOR); + } + } + + private static final class Screen { + final java.util.List rows = new java.util.ArrayList<>(); + + Screen(int cols, int height) { + for (int y = 0; y < height; y++) rows.add(new Row(cols)); + } + + Screen resized(int newCols, int newRows) { + Screen next = new Screen(newCols, newRows); + for (int y = 0; y < Math.min(rows.size(), newRows); y++) { + Row from = rows.get(y), to = next.rows.get(y); + for (int x = 0; x < Math.min(from.ch.length, newCols); x++) { + to.ch[x] = from.ch[x]; + to.fg[x] = from.fg[x]; + } + } + return next; + } + } + + // Parser states for the incoming stream. Sequences may straddle chunk + // boundaries, so the machine and its scratch buffer are fields, not locals. + private static final int ST_TEXT = 0, ST_ESC = 1, ST_CSI = 2, + ST_STRING = 3, ST_STRING_ESC = 4, ST_CHARSET = 5; + + private Screen main, alt; + private boolean onAlt; + private int cols, rows; + + private int cx, cy; + private int savedCx, savedCy, savedPen; + private int regionTop, regionBottom; + + private int pen = DEFAULT_COLOR; + private boolean wrapNext; + private boolean autoWrap = true; + private boolean appCursorKeys; + private boolean cursorVisible = true; + + private final java.util.List scrollback = new java.util.ArrayList<>(); + + /** Rows pushed into scrollback by the last {@link #feed}, to keep a view steady. */ + private int popped; + + private final Consumer responder; + + private int parseState = ST_TEXT; + private final StringBuilder seq = new StringBuilder(64); + private boolean csiIntermediate; + + /** + * @param responder what to do with the answers a terminal owes the shell + * (device attributes, cursor position); may be ignored + * forever, but a program asking and never hearing keeps + * asking + */ + public TerminalEmulator(int cols, int rows, Consumer responder) { + this.responder = responder; + resize(cols, rows); + reset(); + } + + // ── Feeding it ──────────────────────────────────────────────────────── + + /** Hands the emulator one chunk of what the shell printed. */ + public void feed(String text) { + popped = 0; + for (int i = 0; i < text.length(); i++) { + char c = text.charAt(i); + switch (parseState) { + case ST_TEXT -> textChar(c); + case ST_ESC -> escapeChar(c); + case ST_CSI -> csiChar(c); + case ST_STRING -> { + if (c == '\u0007') parseState = ST_TEXT; // BEL ends it + else if (c == '\u001B') parseState = ST_STRING_ESC; // maybe ST… + } + case ST_STRING_ESC -> parseState = (c == '\\') ? ST_TEXT : ST_ESC; + case ST_CHARSET -> parseState = ST_TEXT; // eat the designator + } + } + } + + /** Types plain text at the cursor, the way a pane's own notes arrive. */ + public void writeText(String text, int color) { + int previousPen = pen; + pen = color; + for (int i = 0; i < text.length(); i++) { + char c = text.charAt(i); + if (c == '\n') lineFeed(); + else if (c == '\r') cx = 0; + else if (c >= 32) printChar(c); + } + pen = previousPen; + } + + /** Clears the screen and the cursor: a new shell's clean slate. */ + public void reset() { + main = new Screen(cols, rows); + alt = new Screen(cols, rows); + onAlt = false; + regionTop = 0; + regionBottom = rows - 1; + cx = 0; + cy = 0; + pen = DEFAULT_COLOR; + wrapNext = false; + autoWrap = true; + appCursorKeys = false; + cursorVisible = true; + parseState = ST_TEXT; + } + + /** Drops the scrollback: its shell is gone with it. */ + public void clearScrollback() { + scrollback.clear(); + } + + // ── What the view needs to draw ─────────────────────────────────────── + + public int cols() { return cols; } + public int rows() { return rows; } + public int scrollbackSize() { return scrollback.size(); } + public int poppedLastFeed() { return popped; } + public boolean cursorVisible() { return cursorVisible; } + public boolean appCursorKeys() { return appCursorKeys; } + public boolean onAlternateScreen() { return onAlt; } + + /** The cursor's row counted from the bottom of the content — its screen row plus the scrollback above it. */ + public int cursorContentLine() { return scrollback.size() + cy; } + + /** The character of one content line: the scrollback first, then the screen. */ + public char charAt(int contentLine, int x) { + return rowAt(contentLine).ch[x]; + } + + public int colorAt(int contentLine, int x) { + return rowAt(contentLine).fg[x]; + } + + private Row rowAt(int contentLine) { + return contentLine < scrollback.size() + ? scrollback.get(contentLine) + : screen().rows.get(contentLine - scrollback.size()); + } + + /** The content line the cursor sits on, in absolute coordinates, for the pane to draw a block over. */ + public int cursorX() { return cx; } + + // ── Resizing the window ─────────────────────────────────────────────── + + public void resize(int newCols, int newRows) { + if (main == null) { cols = newCols; rows = newRows; return; } + main = main.resized(newCols, newRows); + alt = alt.resized(newCols, newRows); + resizeScrollback(newCols); + cols = newCols; + rows = newRows; + regionTop = 0; + regionBottom = rows - 1; + clampCursor(); + wrapNext = false; + } + + /** + * Scrollback rows were cut to the old width and must not be read past + * it (or the view, drawn column by column over the new width, walks off + * the end of one): the same treatment as the screens — copy what still + * fits, leave the rest blank. + */ + private void resizeScrollback(int newCols) { + for (int i = 0; i < scrollback.size(); i++) { + Row old = scrollback.get(i); + if (old.ch.length == newCols) continue; + Row fresh = new Row(newCols); + for (int x = 0; x < Math.min(old.ch.length, newCols); x++) { + fresh.ch[x] = old.ch[x]; + fresh.fg[x] = old.fg[x]; + } + scrollback.set(i, fresh); + } + } + + // ── The sequences, one by one ───────────────────────────────────────── + + private Screen screen() { + return onAlt ? alt : main; + } + + private void textChar(char c) { + if (c == '\u001B') { parseState = ST_ESC; return; } + + switch (c) { + case '\u009B' -> startCsi(); // CSI as one character + case '\u0090', '\u0098', '\u009D', '\u009E', '\u009F' -> parseState = ST_STRING; + case '\u0084' -> lineFeed(); // IND + case '\u008D' -> reverseIndex(); // RI + case '\u0085' -> { cx = 0; lineFeed(); } // NEL + case '\u0007' -> { } // BEL: nothing to beep with + case '\b' -> { if (cx > 0) cx--; wrapNext = false; } + case '\t' -> { cx = Math.min(cols - 1, (cx / 8 + 1) * 8); wrapNext = false; } + case '\n', 0x0B, 0x0C -> lineFeed(); + case '\r' -> { cx = 0; wrapNext = false; } + case 0, 0x7F -> { } + default -> { if (c >= 32) printChar(c); } + } + } + + private void escapeChar(char c) { + parseState = ST_TEXT; + switch (c) { + case '[' -> startCsi(); + // OSC (titles and such), DCS, SOS, PM, APC: recognised, swallowed. + case ']', 'P', 'X', '^', '_' -> parseState = ST_STRING; + case '(', ')', '*', '+' -> parseState = ST_CHARSET; // charset designation + case '7' -> { savedCx = cx; savedCy = cy; savedPen = pen; } + case '8' -> { cx = savedCx; cy = savedCy; pen = savedPen; clampCursor(); } + case 'D' -> lineFeed(); // IND + case 'M' -> reverseIndex(); // RI + case 'E' -> { cx = 0; lineFeed(); } // NEL + case 'c' -> reset(); // RIS + default -> { } // '=', '>', ' ', forgotten ones + } + } + + private void startCsi() { + parseState = ST_CSI; + seq.setLength(0); + csiIntermediate = false; + } + + private void csiChar(char c) { + if (c >= '0' && c <= '?') { + if (seq.length() < 64) seq.append(c); // parameter bytes, '?' and '>' included + return; + } + if (c >= ' ' && c <= '/') { csiIntermediate = true; return; } // intermediates: remembered, ignored + parseState = ST_TEXT; + if (c >= '@' && c <= '~') dispatchCsi(c); + } + + private void dispatchCsi(char finalByte) { + String s = seq.toString(); + boolean priv = !s.isEmpty() + && (s.charAt(0) == '?' || s.charAt(0) == '>' || s.charAt(0) == '!' || s.charAt(0) == '='); + String body = priv ? s.substring(1) : s; + String[] parts = body.isEmpty() ? new String[0] : body.split(";", -1); + + switch (finalByte) { + case 'A' -> { cy = clamp(cy - param(parts, 0, 1), 0, rows - 1); wrapNext = false; } + case 'B' -> { cy = clamp(cy + param(parts, 0, 1), 0, rows - 1); wrapNext = false; } + case 'C' -> { cx = clamp(cx + param(parts, 0, 1), 0, cols - 1); wrapNext = false; } + case 'D' -> { cx = clamp(cx - param(parts, 0, 1), 0, cols - 1); wrapNext = false; } + case 'E' -> { cy = clamp(cy + param(parts, 0, 1), 0, rows - 1); cx = 0; wrapNext = false; } + case 'F' -> { cy = clamp(cy - param(parts, 0, 1), 0, rows - 1); cx = 0; wrapNext = false; } + case 'G', '`' -> { cx = clamp(param(parts, 0, 1) - 1, 0, cols - 1); wrapNext = false; } + case 'd' -> { cy = clamp(param(parts, 0, 1) - 1, 0, rows - 1); wrapNext = false; } + case 'H', 'f' -> { + cy = clamp(param(parts, 0, 1) - 1, 0, rows - 1); + cx = clamp(param(parts, 1, 1) - 1, 0, cols - 1); + wrapNext = false; + } + case 'J' -> eraseDisplay(param(parts, 0, 0)); + case 'K' -> eraseLine(param(parts, 0, 0)); + case 'X' -> eraseChars(param(parts, 0, 1)); + case 'L' -> insertLines(param(parts, 0, 1)); + case 'M' -> deleteLines(param(parts, 0, 1)); + case '@' -> insertChars(param(parts, 0, 1)); + case 'P' -> deleteChars(param(parts, 0, 1)); + case 'S' -> scrollRegionUp(regionTop, regionBottom, param(parts, 0, 1)); + case 'T' -> scrollRegionDown(regionTop, regionBottom, param(parts, 0, 1)); + case 'r' -> setScrollRegion(parts); + case 'm' -> applySgr(parts); + // Save and restore, but only the public ones: CSI ? u is kitty's + // keyboard probe, and answering it with a cursor teleport would + // corrupt whoever is mid-redraw. Silence is the right answer. + case 's' -> { if (!priv && !csiIntermediate) { savedCx = cx; savedCy = cy; savedPen = pen; } } + case 'u' -> { if (!priv && !csiIntermediate) { cx = savedCx; cy = savedCy; pen = savedPen; clampCursor(); } } + case 'n' -> reportStatus(parts); + case 'c' -> { + if (csiIntermediate) break; + // Device attributes: who are you — somebody with a VT220's + // manners, which is exactly what this emulator obeys. + answer(priv ? "\u001B[>0;0;0c" : "\u001B[?62;1;2;4;6;9c"); + } + case 'q' -> { + // XTVERSION (no intermediates); DECSCUSR wears one and passes. + if (priv && !csiIntermediate) answer("\u001BP>|codecraft terminal 1.0\u001B\\"); + } + case 'h', 'l' -> setModes(finalByte == 'h', parts); + default -> { } // everything else: recognised, and nothing here obeys it + } + } + + // ── What they do to the screen ──────────────────────────────────────── + + private void printChar(char c) { + if (wrapNext && autoWrap) { + cx = 0; + lineFeed(); + } + Row row = screen().rows.get(cy); + row.ch[cx] = c; + row.fg[cx] = pen; + if (cx == cols - 1) wrapNext = autoWrap; + else cx++; + } + + private void lineFeed() { + if (cy == regionBottom) scrollRegionUp(regionTop, regionBottom, 1); + else cy++; + } + + private void reverseIndex() { + if (cy == regionTop) scrollRegionDown(regionTop, regionBottom, 1); + else cy--; + } + + private void scrollRegionUp(int top, int bottom, int n) { + top = clamp(top, 0, rows - 1); + bottom = clamp(bottom, 0, rows - 1); + Screen s = screen(); + for (int k = 0; k < n; k++) { + Row gone = s.rows.remove(top); + s.rows.add(bottom, new Row(cols)); + // The main screen's top row scrolling out is the one kind of + // scrolling worth remembering; the alternate screen's is not. + if (!onAlt && top == 0) { + scrollback.add(gone); + if (scrollback.size() > MAX_SCROLLBACK) scrollback.remove(0); + popped++; + } + } + } + + private void scrollRegionDown(int top, int bottom, int n) { + top = clamp(top, 0, rows - 1); + bottom = clamp(bottom, 0, rows - 1); + Screen s = screen(); + for (int k = 0; k < n; k++) { + s.rows.add(top, new Row(cols)); + s.rows.remove(bottom); + } + } + + private void setScrollRegion(String[] parts) { + int top = param(parts, 0, 1); + int bottom = param(parts, 1, rows); + if (top < 1 || bottom > rows || top >= bottom) return; + regionTop = top - 1; + regionBottom = bottom - 1; + cx = 0; + cy = 0; + wrapNext = false; + } + + private void eraseDisplay(int mode) { + switch (mode) { + case 0 -> { + eraseLineFrom(cx); + for (int y = cy + 1; y < rows; y++) screen().rows.set(y, new Row(cols)); + } + case 1 -> { + for (int y = 0; y < cy; y++) screen().rows.set(y, new Row(cols)); + eraseLineTo(cx); + } + default -> { + for (int y = 0; y < rows; y++) screen().rows.set(y, new Row(cols)); + if (mode == 3) scrollback.clear(); + } + } + } + + private void eraseLine(int mode) { + switch (mode) { + case 0 -> eraseLineFrom(cx); + case 1 -> eraseLineTo(cx); + default -> screen().rows.set(cy, new Row(cols)); + } + } + + private void eraseLineFrom(int from) { + Row row = screen().rows.get(cy); + for (int x = clamp(from, 0, cols - 1); x < cols; x++) row.ch[x] = ' '; + } + + private void eraseLineTo(int to) { + Row row = screen().rows.get(cy); + for (int x = 0; x <= clamp(to, 0, cols - 1); x++) row.ch[x] = ' '; + } + + private void eraseChars(int n) { + Row row = screen().rows.get(cy); + for (int x = cx; x < Math.min(cols, cx + n); x++) row.ch[x] = ' '; + } + + private void insertLines(int n) { + if (cy < regionTop || cy > regionBottom) return; + n = Math.min(n, regionBottom - cy + 1); + Screen s = screen(); + for (int k = 0; k < n; k++) { + s.rows.add(cy, new Row(cols)); + s.rows.remove(regionBottom + 1); + } + } + + private void deleteLines(int n) { + if (cy < regionTop || cy > regionBottom) return; + n = Math.min(n, regionBottom - cy + 1); + Screen s = screen(); + for (int k = 0; k < n; k++) { + s.rows.remove(cy); + s.rows.add(regionBottom, new Row(cols)); + } + } + + private void insertChars(int n) { + Row row = screen().rows.get(cy); + n = Math.min(n, cols - cx); + for (int x = cols - 1; x >= cx + n; x--) { + row.ch[x] = row.ch[x - n]; + row.fg[x] = row.fg[x - n]; + } + for (int x = cx; x < Math.min(cols, cx + n); x++) row.ch[x] = ' '; + } + + private void deleteChars(int n) { + Row row = screen().rows.get(cy); + n = Math.min(n, cols - cx); + for (int x = cx; x < cols - n; x++) { + row.ch[x] = row.ch[x + n]; + row.fg[x] = row.fg[x + n]; + } + for (int x = Math.max(0, cols - n); x < cols; x++) row.ch[x] = ' '; + } + + private void setModes(boolean on, String[] parts) { + for (int i = 0; i < parts.length; i++) { + switch (param(parts, i, 0)) { + case 1 -> appCursorKeys = on; // DECCKM: arrows send ESC O x + case 7 -> autoWrap = on; // DECAWM + case 25 -> cursorVisible = on; // DECTCEM + case 47, 1047, 1049 -> { + // The alternate screen: full-screen programs live here, + // and leave the main screen — and its scrollback — alone. + if (on) enterAlt(); + else leaveAlt(); + } + default -> { } // 6, 12, 2004, mouse…: acknowledged, unused + } + } + } + + /** The program asked for its own screen; the main one keeps the lights on underneath. */ + private void enterAlt() { + if (onAlt) return; + savedCx = cx; + savedCy = cy; + alt = new Screen(cols, rows); + onAlt = true; + cx = 0; + cy = 0; + wrapNext = false; + } + + /** …and gave it back. */ + private void leaveAlt() { + if (!onAlt) return; + onAlt = false; + cx = savedCx; + cy = savedCy; + clampCursor(); + wrapNext = false; + } + + /** The emulator's turn to speak: the answers a terminal owes. */ + private void answer(String response) { + responder.accept(response); + } + + private void reportStatus(String[] parts) { + if (csiIntermediate) return; // DECRQM is asking, not this + int op = param(parts, 0, 0); + if (op == 5) answer("\u001B[0n"); + else if (op == 6) answer("\u001B[" + (cy + 1) + ";" + (cx + 1) + "R"); + } + + // ── Colours ─────────────────────────────────────────────────────────── + + /** Applies one SGR ("select graphic rendition") parameter list to the pen. */ + private void applySgr(String[] parts) { + for (int i = 0; i < parts.length; i++) { + int code = param(parts, i, 0); + switch (code) { + case 0, 22, 39 -> pen = DEFAULT_COLOR; // reset / normal intensity / default fg + case 30, 31, 32, 33, 34, 35, 36, 37 -> pen = ANSI_COLORS[code - 30]; + case 90, 91, 92, 93, 94, 95, 96, 97 -> pen = ANSI_COLORS[code - 82]; + case 38 -> i = readColor(parts, i, true); // 38;5;n or 38;2;r;g;b + case 48 -> i = readColor(parts, i, false); // background: parsed past, not painted + default -> { + // 1 bold, 4 underline: cells carry no such attribute, and + // these must not eat the codes that follow them. + } + } + } + } + + /** + * Reads a 256-colour or true-colour argument list, applying it to the pen + * when it is a foreground. Returns the index of the last part consumed. + */ + private int readColor(String[] parts, int at, boolean foreground) { + try { + if (at + 2 >= parts.length) return parts.length; + int mode = Integer.parseInt(parts[at + 1]); + if (mode == 5) { + if (foreground) pen = palette256(Integer.parseInt(parts[at + 2])); + return at + 2; + } + if (mode == 2 && at + 4 < parts.length) { + if (foreground) { + pen = 0xFF000000 + | (Integer.parseInt(parts[at + 2]) & 0xFF) << 16 + | (Integer.parseInt(parts[at + 3]) & 0xFF) << 8 + | (Integer.parseInt(parts[at + 4]) & 0xFF); + } + return at + 4; + } + } catch (NumberFormatException e) { + // Garbage parameters: leave the pen where it was. + } + return parts.length; + } + + /** The xterm 256-colour palette: the 16 above, a 6x6x6 cube, a grey ramp. */ + private static int palette256(int index) { + if (index < 16) return ANSI_COLORS[index % ANSI_COLORS.length]; + if (index <= 231) { + int i = index - 16; + return 0xFF000000 | ramp(i / 36) << 16 | ramp((i / 6) % 6) << 8 | ramp(i % 6); + } + if (index <= 255) { + int grey = 8 + (index - 232) * 10; + return 0xFF000000 | grey << 16 | grey << 8 | grey; + } + return DEFAULT_COLOR; + } + + /** The cube's six steps: 0, 95, 135, 175, 215, 255. */ + private static int ramp(int step) { + return step == 0 ? 0 : 55 + step * 40; + } + + private void clampCursor() { + cx = clamp(cx, 0, cols - 1); + cy = clamp(cy, 0, rows - 1); + } + + private static int clamp(int value, int low, int high) { + return Math.max(low, Math.min(value, high)); + } + + private static int param(String[] parts, int index, int def) { + if (index >= parts.length) return def; + try { + return parts[index].isEmpty() ? def : Integer.parseInt(parts[index].split(":")[0]); + } catch (NumberFormatException e) { + return def; + } + } +} diff --git a/src/client/java/com/aranroig/client/editor/TextEditorScreen.java b/src/client/java/com/aranroig/client/editor/TextEditorScreen.java index 79670bc..f85c179 100644 --- a/src/client/java/com/aranroig/client/editor/TextEditorScreen.java +++ b/src/client/java/com/aranroig/client/editor/TextEditorScreen.java @@ -6,12 +6,24 @@ import org.jspecify.annotations.NonNull; public class TextEditorScreen extends EditorScreen { + private final EditorManager editorManager; + /** True while the left mouse button is held down during a drag-select. */ - public TextEditorScreen() { + public TextEditorScreen(EditorManager editorManager) { super(Component.literal("Codecraft Editor")); + this.editorManager = editorManager; } + /** + * Closing the editor leaves the live editing session, so the other players + * stop seeing this caret and stop sending theirs. + */ + @Override + public void onClose() { + editorManager.onEditorClosed(this); + super.onClose(); + } @Override public void extractRenderState( @@ -23,13 +35,7 @@ public class TextEditorScreen extends EditorScreen { super.extractRenderState(graphics, mouseX, mouseY, delta); for (Widget widget : widgets) { - widget.draw( - graphics, - mouseX, - mouseY, - delta - ); + widget.draw(graphics, mouseX, mouseY, delta); } } - -} \ No newline at end of file +} diff --git a/src/client/java/com/aranroig/client/editor/Widget.java b/src/client/java/com/aranroig/client/editor/Widget.java index ae01cfe..c632379 100644 --- a/src/client/java/com/aranroig/client/editor/Widget.java +++ b/src/client/java/com/aranroig/client/editor/Widget.java @@ -69,11 +69,15 @@ public abstract class Widget { public abstract boolean handleKeyPressed(KeyEvent event); public abstract boolean handleCharTyped(CharacterEvent event); - public abstract boolean handleMouseClicked(MouseButtonEvent event); + public abstract boolean handleMouseClicked(MouseButtonEvent event, boolean doubleClick); public abstract boolean handleMouseDragged(MouseButtonEvent event); public abstract boolean handleMouseReleased(MouseButtonEvent event); public abstract boolean handleMouseScrolled(double scrollY); + /** Called when a click lands on another widget: this one loses the keyboard. */ + public void handleFocusLost() { + } + public int getZIndex() { return z_index; } diff --git a/src/client/java/com/aranroig/client/editor/WorldLibrary.java b/src/client/java/com/aranroig/client/editor/WorldLibrary.java new file mode 100644 index 0000000..7727351 --- /dev/null +++ b/src/client/java/com/aranroig/client/editor/WorldLibrary.java @@ -0,0 +1,26 @@ +package com.aranroig.client.editor; + +import java.util.List; + +/** + * Completion for the {@code world} global — block access provided by codecraft + * itself. Keep in sync with the runtime wrapper and {@code LuaApiDocs}. + */ +public class WorldLibrary implements LuaLibrary { + + private static final List MEMBERS = List.of( + CompletionItem.method("set_block", "set_block("), + CompletionItem.method("remove_block", "remove_block("), + CompletionItem.method("get_block", "get_block(") + ); + + @Override + public String name() { + return "world"; + } + + @Override + public List members() { + return MEMBERS; + } +} diff --git a/src/main/java/com/aranroig/Codecraft.java b/src/main/java/com/aranroig/Codecraft.java index 05b8cec..d058322 100644 --- a/src/main/java/com/aranroig/Codecraft.java +++ b/src/main/java/com/aranroig/Codecraft.java @@ -1,13 +1,32 @@ package com.aranroig; +import com.aranroig.collab.DocumentManager; import com.aranroig.editor.EditorFile; +import com.aranroig.editor.ProjectPath; +import com.aranroig.listeners.ScriptRuntime; +import com.aranroig.listeners.ScriptRuntimeManager; +import com.aranroig.payloads.ClientboundDocumentEditPayload; +import com.aranroig.payloads.ClientboundDocumentStatePayload; +import com.aranroig.payloads.ClientboundEditAckPayload; +import com.aranroig.payloads.ClientboundPresencePayload; import com.aranroig.payloads.ClientboundProjectFilesPayload; +import com.aranroig.payloads.ClientboundRenameFilePayload; import com.aranroig.payloads.ClientboundSaveCodePayload; +import com.aranroig.payloads.ClientboundShellClosedPayload; +import com.aranroig.payloads.ClientboundShellOutputPayload; +import com.aranroig.payloads.ServerboundCloseEditorPayload; +import com.aranroig.payloads.ServerboundCloseShellPayload; +import com.aranroig.payloads.ServerboundCursorPayload; +import com.aranroig.payloads.ServerboundEditPayload; +import com.aranroig.payloads.ServerboundOpenDocumentPayload; +import com.aranroig.payloads.ServerboundRenameFilePayload; import com.aranroig.payloads.ServerboundRequestProjectPayload; import com.aranroig.payloads.ServerboundRunCodePayload; import com.aranroig.payloads.ServerboundSaveCodePayload; -import com.aranroig.wrapper.ChatLogger; -import com.aranroig.wrapper.WorldApi; +import com.aranroig.payloads.ServerboundShellInputPayload; +import com.aranroig.payloads.ServerboundShellResizePayload; +import com.aranroig.payloads.ServerboundSpawnShellPayload; +import com.aranroig.shell.ShellManager; import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry; @@ -19,8 +38,6 @@ import net.minecraft.server.MinecraftServer; import net.minecraft.server.level.ServerPlayer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import party.iroiro.luajava.Lua; -import party.iroiro.luajava.luaj.LuaJ; import java.util.List; @@ -42,8 +59,37 @@ public class Codecraft implements ModInitializer { PayloadTypeRegistry.serverboundPlay().register(ServerboundSaveCodePayload.TYPE, ServerboundSaveCodePayload.CODEC); PayloadTypeRegistry.serverboundPlay().register(ServerboundRunCodePayload.TYPE, ServerboundRunCodePayload.CODEC); PayloadTypeRegistry.serverboundPlay().register(ServerboundRequestProjectPayload.TYPE, ServerboundRequestProjectPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundOpenDocumentPayload.TYPE, ServerboundOpenDocumentPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundCloseEditorPayload.TYPE, ServerboundCloseEditorPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundEditPayload.TYPE, ServerboundEditPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundCursorPayload.TYPE, ServerboundCursorPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundRenameFilePayload.TYPE, ServerboundRenameFilePayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundSpawnShellPayload.TYPE, ServerboundSpawnShellPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundShellInputPayload.TYPE, ServerboundShellInputPayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundShellResizePayload.TYPE, ServerboundShellResizePayload.CODEC); + PayloadTypeRegistry.serverboundPlay().register(ServerboundCloseShellPayload.TYPE, ServerboundCloseShellPayload.CODEC); PayloadTypeRegistry.clientboundPlay().register(ClientboundSaveCodePayload.TYPE, ClientboundSaveCodePayload.CODEC); PayloadTypeRegistry.clientboundPlay().register(ClientboundProjectFilesPayload.TYPE, ClientboundProjectFilesPayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundDocumentStatePayload.TYPE, ClientboundDocumentStatePayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundDocumentEditPayload.TYPE, ClientboundDocumentEditPayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundEditAckPayload.TYPE, ClientboundEditAckPayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundPresencePayload.TYPE, ClientboundPresencePayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundRenameFilePayload.TYPE, ClientboundRenameFilePayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundShellOutputPayload.TYPE, ClientboundShellOutputPayload.CODEC); + PayloadTypeRegistry.clientboundPlay().register(ClientboundShellClosedPayload.TYPE, ClientboundShellClosedPayload.CODEC); + + // Bridge game activity (item use, block break, chat, join/leave, tick) to + // the Lua listeners scripts register. Registered once; dispatching to the + // currently running script happens per event. + ScriptRuntimeManager.install(); + + // Drop players from their live editing sessions when they leave, and + // throw the cached documents away when the world stops. + DocumentManager.install(); + + // Same for the shells the terminal pane spawns: nobody leaks when the + // player disconnects or the server stops. + ShellManager.install(); ServerPlayNetworking.registerGlobalReceiver(ServerboundRequestProjectPayload.TYPE, (payload, context) -> { MinecraftServer server = context.player().level().getServer(); @@ -53,8 +99,9 @@ public class Codecraft implements ModInitializer { List files = savedData.getEditorFiles(); // Seed a default entrypoint so the client always has at least one file. + // Names carry no extension: the sidebar shows them as they are. if(files.isEmpty()) { - files.add(new EditorFile("main.lua", "")); + files.add(new EditorFile(ProjectPath.ENTRYPOINT, "")); savedData.setEditorFiles(files); } @@ -62,36 +109,56 @@ public class Codecraft implements ModInitializer { }); ServerPlayNetworking.registerGlobalReceiver(ServerboundSaveCodePayload.TYPE, (payload, context) -> { - MinecraftServer server = context.player().level().getServer(); - if(server == null) return; - - SavedProjectData savedData = SavedProjectData.getSavedBlockData(server); - List files = savedData.getEditorFiles(); - EditorFile editorFile = payload.data(); - boolean existing = false; - for(EditorFile file : files) { - if(file.getName().equals(editorFile.getName())) { - existing = true; - file.setText(editorFile.getText()); - break; - } - } - if(!existing) { - files.add(editorFile); - } - savedData.setEditorFiles(files); + // The live document is what the other editors are looking at, so the + // save goes through it: the new text reaches them as one edit they + // can merge, instead of clobbering whatever they typed meanwhile — + // and it is from there that the rest of them hear the file exists. + DocumentManager.replaceDocument(context.player(), editorFile.getName(), editorFile.getText()); LOGGER.info("Successfully saved file {}", editorFile.getName()); - - // Push the change to every other client so their editors stay in sync. - for(ServerPlayer player : server.getPlayerList().getPlayers()) { - if(player != context.player()) { - ServerPlayNetworking.send(player, new ClientboundSaveCodePayload(new EditorFile(editorFile.getName(), editorFile.getText()))); - } - } }); + // Renaming a file moves it in the saved project and its live document, + // and the other editors' lists follow. + ServerPlayNetworking.registerGlobalReceiver(ServerboundRenameFilePayload.TYPE, (payload, context) -> + DocumentManager.renameFile(context.player(), payload.oldName(), payload.newName())); + + // ── Live editing ──────────────────────────────────────────────────── + // A player opening the editor, or switching file, joins that document's + // session and gets its authoritative contents back. + ServerPlayNetworking.registerGlobalReceiver(ServerboundOpenDocumentPayload.TYPE, (payload, context) -> + DocumentManager.openDocument(context.player(), payload.file())); + + // One keystroke's worth of changes, rebased and passed to the others. + ServerPlayNetworking.registerGlobalReceiver(ServerboundEditPayload.TYPE, (payload, context) -> + DocumentManager.applyEdit(context.player(), payload.file(), payload.baseVersion(), payload.edit())); + + // Where the player's caret is, for the other editors to draw. + ServerPlayNetworking.registerGlobalReceiver(ServerboundCursorPayload.TYPE, (payload, context) -> + DocumentManager.updateCursor(context.player(), payload.file(), payload.cursor(), payload.anchor())); + + // Closing the editor ends the session; disconnecting does it too. + ServerPlayNetworking.registerGlobalReceiver(ServerboundCloseEditorPayload.TYPE, (payload, context) -> + DocumentManager.closeEditor(context.player())); + + // ── The terminal pane ─────────────────────────────────────────────── + // The button spawns a bash on this machine, every line typed in the + // pane is a command for it, and closing the pane kills it. + ServerPlayNetworking.registerGlobalReceiver(ServerboundSpawnShellPayload.TYPE, (payload, context) -> + ShellManager.spawn(context.player(), payload.rows(), payload.cols())); + + ServerPlayNetworking.registerGlobalReceiver(ServerboundShellInputPayload.TYPE, (payload, context) -> + ShellManager.submit(context.player(), payload.bytes())); + + // A resize of the pane moves the pty's window on this side: the shell's + // input is not touched, and full-screen programs are signalled live. + ServerPlayNetworking.registerGlobalReceiver(ServerboundShellResizePayload.TYPE, (payload, context) -> + ShellManager.resize(context.player(), payload.rows(), payload.cols())); + + ServerPlayNetworking.registerGlobalReceiver(ServerboundCloseShellPayload.TYPE, (payload, context) -> + ShellManager.close(context.player())); + ServerPlayNetworking.registerGlobalReceiver(ServerboundRunCodePayload.TYPE, (payload, context) -> { MinecraftServer server = context.player().level().getServer(); if(server == null) return; @@ -104,12 +171,10 @@ public class Codecraft implements ModInitializer { String entrypoint = payload.data().getEntrypoint(); LOGGER.info("Running entrypoint {}", entrypoint); - EditorFile target = null; - for(EditorFile file : files) { - if(file.getName().equals(entrypoint)) { - target = file; - break; - } + EditorFile target = findByName(files, entrypoint); + if(target == null) { + // Worlds seeded while names still carried the extension. + target = findByName(files, entrypoint + ProjectPath.LEGACY_EXTENSION); } if(target == null) { @@ -117,12 +182,12 @@ public class Codecraft implements ModInitializer { return; } - Lua lua = new LuaJ(); - lua.push(ChatLogger.print(player)); - lua.setGlobal("print"); - WorldApi.register(lua, player); + // Fresh runtime per run: this drops the listeners the player + // registered last time (reset-on-rerun) and registers print/world/ + // events on a brand-new Lua state. + ScriptRuntime runtime = ScriptRuntimeManager.startRun(player); try { - lua.run(target.getText()); + runtime.run(target.getText()); } catch (Exception e) { LOGGER.warn("Error running " + entrypoint, e); player.sendSystemMessage(Component.literal("§ccodecraft error: " + e.getMessage())); @@ -130,6 +195,14 @@ public class Codecraft implements ModInitializer { }); } + /** The project's file called {@code name}, or null when the project has none. */ + private static EditorFile findByName(List files, String name) { + for(EditorFile file : files) { + if(file.getName().equals(name)) return file; + } + return null; + } + public static Identifier id(String path) { return Identifier.fromNamespaceAndPath(MOD_ID, path); } diff --git a/src/main/java/com/aranroig/SavedProjectData.java b/src/main/java/com/aranroig/SavedProjectData.java index f63e382..d368f7d 100644 --- a/src/main/java/com/aranroig/SavedProjectData.java +++ b/src/main/java/com/aranroig/SavedProjectData.java @@ -20,15 +20,34 @@ public class SavedProjectData extends SavedData { } public SavedProjectData(List editorFiles) { - this.editorFiles = editorFiles; + // What the codec decodes is an immutable list: writing the project back + // out is fine with it, but while the server runs the project is added to + // — a new file, or one that first appeared as a keystroke — and adding to + // what the codec handed over throws. Keeping a copy of our own is what + // makes `getEditorFiles().add(...)` mean anything. + this.editorFiles = new ArrayList<>(editorFiles); } + /** + * The project's files. The list itself is mutable, so a file can be added to + * it; remember to {@link #setEditorFiles(List) set} it or at least + * {@link #markDirty()} when its contents change, or nothing is written out. + */ public List getEditorFiles() { return editorFiles; } public void setEditorFiles(List editorFiles) { - this.editorFiles = editorFiles; + this.editorFiles = new ArrayList<>(editorFiles); + setDirty(); + } + + /** + * Flags the data for saving after a file's contents were changed in place. + * Minecraft only writes it to disk periodically, so this is cheap enough to + * call on every keystroke. + */ + public void markDirty() { setDirty(); } @@ -56,9 +75,9 @@ public class SavedProjectData extends SavedData { return new SavedProjectData(); // Return a new instance if the level is null. } - // The first time the following 'computeIfAbsent' function is called, it creates a new 'SavedBlockData' + // The first time the following 'computeIfAbsent' function is called, it creates a new 'SavedProjectData' // instance and stores it inside the 'DimensionDataStorage'. - // Subsequent calls to 'computeIfAbsent' returns the saved 'SavedBlockData' NBT on disk to the Codec in our type, + // Subsequent calls to 'computeIfAbsent' returns the saved 'SavedProjectData' NBT on disk to the Codec in our type, // using the Codec to decode the NBT into our saved data. return level.getDataStorage().computeIfAbsent(TYPE); } diff --git a/src/main/java/com/aranroig/collab/DocumentManager.java b/src/main/java/com/aranroig/collab/DocumentManager.java new file mode 100644 index 0000000..e9b4bf1 --- /dev/null +++ b/src/main/java/com/aranroig/collab/DocumentManager.java @@ -0,0 +1,453 @@ +package com.aranroig.collab; + +import com.aranroig.Codecraft; +import com.aranroig.SavedProjectData; +import com.aranroig.editor.Edit; +import com.aranroig.editor.EditorFile; +import com.aranroig.editor.EditorPresence; +import com.aranroig.payloads.ClientboundDocumentEditPayload; +import com.aranroig.payloads.ClientboundDocumentStatePayload; +import com.aranroig.payloads.ClientboundEditAckPayload; +import com.aranroig.payloads.ClientboundPresencePayload; +import com.aranroig.payloads.ClientboundRenameFilePayload; +import com.aranroig.payloads.ClientboundSaveCodePayload; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; +import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; +import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerPlayer; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +/** + * The server's copy of every document that players have open in the editor, and + * the single authority on what they contain. + * + *

Live editing

+ * + *

A player who opens the editor is put in a session for the file + * they are looking at. Every keystroke they make arrives as an + * {@link Edit} written against a known version of the document; this class + * rebases it onto the current version — transforming it against the edits that + * landed in the meantime, and never against the sender's own edits, which are + * already in the buffer it was typed into — applies it, and hands it to the + * other players in that file. That is what lets several people type in the same + * file at once without losing each other's work.

+ * + *

Each applied edit bumps the document's version, so every client can tell + * which version it holds. The server keeps the last few edits per document so + * an edit that arrives a little late can still be rebased; when one arrives + * too late for that, its author is simply sent the authoritative document + * again. The same thing happens whenever a client reports (through the ack + * hash) that its copy stopped matching.

+ * + *

Carets are tracked per session too, and every session gets the caret + * positions of the other players, which is what lets the editor draw them.

+ * + *

Threading

+ * + *

All of this runs on the server thread: payload handlers and the connection + * events below are dispatched there, so the maps need no locking.

+ */ +public final class DocumentManager { + + /** How many applied edits are kept per document for rebasing stale edits. */ + private static final int HISTORY_PER_DOCUMENT = 128; + + /** Caret colours, picked by player id so a player looks the same everywhere. */ + private static final int[] PRESENCE_COLORS = { + 0xFF4FC3F7, // light blue + 0xFFFF8A65, // orange + 0xFFAED581, // green + 0xFFF06292, // pink + 0xFFBA68C8, // purple + 0xFFFFD54F, // amber + 0xFF4DB6AC, // teal + 0xFFE57373, // red + 0xFF90A4AE, // grey + 0xFFA1887F, // brown + }; + + private static final Map DOCUMENTS = new HashMap<>(); + + /** One entry per player with the editor open, keyed by player id. */ + private static final Map SESSIONS = new HashMap<>(); + + private DocumentManager() { + } + + /** + * Drops players from their editing sessions when they disconnect and + * throws the cached documents away when the world shuts down. Call once + * from {@link com.aranroig.Codecraft#onInitialize()}. + */ + public static void install() { + ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> closeEditor(handler.player)); + + // Cached text must not outlive the world it came from. + ServerLifecycleEvents.SERVER_STOPPING.register(server -> { + DOCUMENTS.clear(); + SESSIONS.clear(); + }); + } + + // ── Sessions ────────────────────────────────────────────────────────── + + /** + * Puts {@code player} in the live session of {@code file} and replies with + * its authoritative contents. Their previous file, if any, is dropped. + */ + public static void openDocument(ServerPlayer player, String file) { + MinecraftServer server = server(player); + if (server == null) return; + + Session session = SESSIONS.computeIfAbsent(player.getUUID(), id -> new Session(player)); + if (!file.equals(session.file)) { + session.file = file; + session.cursor = 0; + session.anchor = -1; + } + + Document document = document(server, file); + ServerPlayNetworking.send(player, new ClientboundDocumentStatePayload(file, document.text, document.version)); + + broadcastPresence(server, file); + sendPresenceSnapshot(player); + } + + /** Ends {@code player}'s editing session: called on close and on disconnect. */ + public static void closeEditor(ServerPlayer player) { + Session session = SESSIONS.remove(player.getUUID()); + if (session == null) return; + + MinecraftServer server = server(player); + if (server != null && session.file != null) { + broadcastPresence(server, session.file); + } + } + + // ── Document contents ───────────────────────────────────────────────── + + /** + * Applies one of {@code player}'s keystrokes. The edit was written against + * version {@code baseVersion}; if the document moved on since then the edit + * is rebased onto what happened in between first. + */ + public static void applyEdit(ServerPlayer player, String file, int baseVersion, Edit edit) { + MinecraftServer server = server(player); + if (server == null) return; + + Document document = document(server, file); + + // Never take the client's word for who wrote an edit: rebasing skips + // the sender's own edits, so a spoofed author would apply one twice. + Edit applied = new Edit(player.getUUID(), edit.seq(), edit.components()); + + if (baseVersion > document.version || baseVersion < document.oldestRebaseVersion()) { + // Too far behind to rebase this edit without guessing: give the + // player the real document and let them retype on top of it. + ServerPlayNetworking.send(player, new ClientboundDocumentStatePayload(file, document.text, document.version)); + return; + } + + for (int version = baseVersion + 1; version <= document.version; version++) { + Edit earlier = document.appliedAt(version); + if (earlier == null) break; + if (earlier.author().equals(player.getUUID())) continue; + applied = applied.transformAgainst(earlier); + } + + document.apply(applied); + boolean brandNew = persist(server, file, document.text); + + ServerPlayNetworking.send(player, + new ClientboundEditAckPayload(file, document.version, document.text.hashCode(), document.text.length())); + broadcastEdit(server, player.getUUID(), file, document.version, applied); + + // A file nobody had saved yet came into the project with this keystroke, + // and the editors of it are the only ones the edit above reaches: tell + // everybody else the project has one more file. + if (brandNew) broadcastProjectFile(server, player, file, document.text); + } + + /** + * Writes {@code text} over {@code file} as one edit (the explicit Save). + * Going through an edit rather than storing the buffer directly is what + * keeps the other editors converging instead of being clobbered, and it + * trims the parts both versions agree on so the change stays small. + */ + public static void replaceDocument(ServerPlayer player, String file, String text) { + MinecraftServer server = server(player); + if (server == null) return; + + Document document = document(server, file); + String current = document.text; + + if (current.equals(text)) { + // Nothing changed, but the player asked to save: the file still + // has to exist on disk (a brand-new file is saved before it has + // any edits flowing), and confirm the version they are on so they + // can check their copy against it. + persist(server, file, current); + ServerPlayNetworking.send(player, + new ClientboundEditAckPayload(file, document.version, current.hashCode(), current.length())); + } else { + int prefix = commonPrefix(current, text); + int suffix = commonSuffix(current, text, prefix); + Edit edit = Edit.replace(player.getUUID(), document.nextSequence(), + prefix, current.length() - prefix - suffix, text.substring(prefix, text.length() - suffix)); + + // A whole-file save states what the file should contain, so it is + // applied to the server's current text instead of being rebased. + document.apply(edit); + persist(server, file, document.text); + + ServerPlayNetworking.send(player, + new ClientboundEditAckPayload(file, document.version, document.text.hashCode(), document.text.length())); + broadcastEdit(server, player.getUUID(), file, document.version, edit); + } + + // Saving is also how a file says it exists: the other editors add it to + // their sidebars, and the ones not looking at it are not left holding a + // copy a save behind. + broadcastProjectFile(server, player, file, document.text); + } + + /** + * Moves {@code oldName} to {@code newName} everywhere the server knows it: + * in the saved project, in the cached document and in the sessions of + * everyone editing it — and the other editors' file lists are told. A name + * the project already holds is refused. + */ + public static void renameFile(ServerPlayer player, String oldName, String newName) { + MinecraftServer server = server(player); + if (server == null || oldName.equals(newName)) return; + + SavedProjectData data = SavedProjectData.getSavedBlockData(server); + List files = data.getEditorFiles(); + + for (EditorFile editorFile : files) { + if (editorFile.getName().equals(newName)) return; // the name is taken + } + + boolean onDisk = false; + for (EditorFile editorFile : files) { + if (editorFile.getName().equals(oldName)) { + editorFile.setName(newName); + onDisk = true; + break; + } + } + if (onDisk) data.markDirty(); + + // The live document keeps its version history under the new name, so + // the editors of the file can carry on without refetching anything. + Document document = DOCUMENTS.remove(oldName); + if (document != null) DOCUMENTS.put(newName, document); + + for (Session session : SESSIONS.values()) { + if (oldName.equals(session.file)) session.file = newName; + } + + // Nobody is in the old name any more, and the new one holds them all. + broadcastPresence(server, oldName); + broadcastPresence(server, newName); + + for (ServerPlayer other : server.getPlayerList().getPlayers()) { + if (other != player) { + ServerPlayNetworking.send(other, new ClientboundRenameFilePayload(oldName, newName)); + } + } + } + + // ── Carets ──────────────────────────────────────────────────────────── + + /** Records where {@code player}'s caret is in {@code file} and tells everyone. */ + public static void updateCursor(ServerPlayer player, String file, int cursor, int anchor) { + Session session = SESSIONS.get(player.getUUID()); + if (session == null || !file.equals(session.file)) return; + + MinecraftServer server = server(player); + if (server == null) return; + + session.cursor = Math.max(0, cursor); + session.anchor = anchor; + + broadcastPresence(server, file); + } + + // ── Internals ───────────────────────────────────────────────────────── + + private static Document document(MinecraftServer server, String file) { + Document document = DOCUMENTS.get(file); + if (document == null) { + String text = ""; + for (EditorFile editorFile : SavedProjectData.getSavedBlockData(server).getEditorFiles()) { + if (editorFile.getName().equals(file)) { + text = editorFile.getText(); + break; + } + } + document = new Document(text); + DOCUMENTS.put(file, document); + } + return document; + } + + /** + * Copies the live text back into the project's saved data, saying whether + * that meant the project gained the file. The write itself is throttled by + * {@code SavedData}, so marking it dirty per keystroke is cheap and means a + * crash loses at most a second of typing. + */ + private static boolean persist(MinecraftServer server, String file, String text) { + SavedProjectData data = SavedProjectData.getSavedBlockData(server); + List files = data.getEditorFiles(); + + for (EditorFile editorFile : files) { + if (editorFile.getName().equals(file)) { + editorFile.setText(text); + data.markDirty(); + return false; + } + } + files.add(new EditorFile(file, text)); + data.setEditorFiles(files); + return true; + } + + /** + * Tells every editor but {@code author} that the project holds {@code file} + * with {@code text}. It is how one player's new file turns into a row in the + * others' sidebars, and what keeps a client that is not looking at the file + * from holding a copy a save behind. + */ + private static void broadcastProjectFile(MinecraftServer server, ServerPlayer author, String file, String text) { + for (ServerPlayer other : server.getPlayerList().getPlayers()) { + if (other == author) continue; + ServerPlayNetworking.send(other, new ClientboundSaveCodePayload(new EditorFile(file, text))); + } + } + + private static void broadcastEdit(MinecraftServer server, UUID author, String file, int version, Edit edit) { + for (Map.Entry entry : SESSIONS.entrySet()) { + if (entry.getKey().equals(author) || !file.equals(entry.getValue().file)) continue; + ServerPlayNetworking.send(entry.getValue().player, new ClientboundDocumentEditPayload(file, version, edit)); + } + } + + /** Re-sends the carets of everyone in {@code file} to every open editor. */ + private static void broadcastPresence(MinecraftServer server, String file) { + for (Map.Entry entry : SESSIONS.entrySet()) { + if (entry.getValue().file == null) continue; + sendPresence(entry.getValue().player, file, presenceIn(file, entry.getKey())); + } + } + + /** Brings a player up to date with everywhere somebody is already editing. */ + private static void sendPresenceSnapshot(ServerPlayer player) { + UUID self = player.getUUID(); + List files = new ArrayList<>(); + for (Session session : SESSIONS.values()) { + if (session.file != null && !files.contains(session.file)) files.add(session.file); + } + for (String file : files) { + sendPresence(player, file, presenceIn(file, self)); + } + } + + private static void sendPresence(ServerPlayer to, String file, List editors) { + ServerPlayNetworking.send(to, new ClientboundPresencePayload(file, editors)); + } + + private static List presenceIn(String file, UUID exclude) { + List editors = new ArrayList<>(); + for (Map.Entry entry : SESSIONS.entrySet()) { + Session session = entry.getValue(); + if (entry.getKey().equals(exclude) || !file.equals(session.file)) continue; + editors.add(new EditorPresence(entry.getKey(), session.player.getScoreboardName(), + session.color, session.cursor, session.anchor)); + } + return editors; + } + + private static MinecraftServer server(ServerPlayer player) { + return player.level().getServer(); + } + + private static int commonPrefix(String left, String right) { + int max = Math.min(left.length(), right.length()); + int i = 0; + while (i < max && left.charAt(i) == right.charAt(i)) i++; + return i; + } + + private static int commonSuffix(String left, String right, int prefix) { + int max = Math.min(left.length(), right.length()) - prefix; + int i = 0; + while (i < max && left.charAt(left.length() - 1 - i) == right.charAt(right.length() - 1 - i)) i++; + return i; + } + + // ── State ───────────────────────────────────────────────────────────── + + /** The server's copy of one document, with the edits that produced it. */ + private static final class Document { + private String text; + private int version; + + /** Applied edits, oldest first; {@code history.get(0)} is version {@code firstRetainedVersion}. */ + private final List history = new ArrayList<>(); + private int firstRetainedVersion = 1; + + private Document(String text) { + this.text = text; + } + + private void apply(Edit edit) { + text = edit.apply(text); + version++; + + if (history.size() == HISTORY_PER_DOCUMENT) { + history.remove(0); + firstRetainedVersion++; + } + history.add(edit); + } + + /** The edit that took the document to {@code targetVersion}, or null once forgotten. */ + private Edit appliedAt(int targetVersion) { + int index = targetVersion - firstRetainedVersion; + if (index < 0 || index >= history.size()) return null; + return history.get(index); + } + + /** Oldest base version that can still be rebased onto this document. */ + private int oldestRebaseVersion() { + return firstRetainedVersion - 1; + } + + private long nextSequence() { + return version + 1L; + } + } + + /** One player with the editor open, and where they are pointing. */ + private static final class Session { + private final ServerPlayer player; + private final int color; + + private String file; + private int cursor; + private int anchor = -1; + + private Session(ServerPlayer player) { + this.player = player; + this.color = PRESENCE_COLORS[Math.floorMod(player.getUUID().hashCode(), PRESENCE_COLORS.length)]; + } + } +} diff --git a/src/main/java/com/aranroig/docs/LuaApiDocs.java b/src/main/java/com/aranroig/docs/LuaApiDocs.java index 08ccb42..2d2c0d2 100644 --- a/src/main/java/com/aranroig/docs/LuaApiDocs.java +++ b/src/main/java/com/aranroig/docs/LuaApiDocs.java @@ -1,142 +1,125 @@ package com.aranroig.docs; +import com.aranroig.Codecraft; +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; + +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; import java.util.List; /** * The in-game reference for every Lua global this mod exposes to user scripts. * - *

This is a hand-written catalog describing the functions registered by the - * wrappers in {@code com.aranroig.wrapper} (currently {@code world} from - * {@link com.aranroig.wrapper.WorldApi} and the {@code print} helper). The - * client editor reads it to render the browsable documentation panel, so it is - * the single source of truth shown to players.

+ *

The catalog is data, not code: it lives in + * {@code src/main/resources/data/codecraft/docs/lua-api.json} and is loaded from + * the mod resources on first access, so documentation can be edited (and, once + * packed, overridden) without touching Java. It describes the functions + * registered by the wrappers in {@code com.aranroig.wrapper} (currently + * {@code world} and the {@code print} helper) and by + * {@link com.aranroig.listeners.EventsApi} ({@code events}). The client editor + * reads it to render the browsable documentation panel, so it is the single + * source of truth shown to players.

* *

Keep it in sync with the wrapper implementations and {@code docs/lua-api.md}.

*/ public final class LuaApiDocs { + /** Location of the catalog inside the mod resources. */ + private static final String RESOURCE = "/data/codecraft/docs/lua-api.json"; + + private static List cache; + private LuaApiDocs() { } - // ── world.* — block access ──────────────────────────────────────────── - - private static final FunctionDoc SET_BLOCK = new FunctionDoc( - "world.set_block", - "world.set_block(x, y, z, block)", - "Places a block and updates neighbours and clients, like /setblock does.", - List.of( - new ParamDoc("x", "number", false, "Absolute world x coordinate (F3 to read your own)."), - new ParamDoc("y", "number", false, "Absolute world y coordinate."), - new ParamDoc("z", "number", false, "Absolute world z coordinate."), - new ParamDoc("block", "string", false, - "Block id, with or without the minecraft: namespace, optionally with block states.") - ), - "true on success, or false followed by a reason string.", - List.of( - "Coordinates are absolute, never relative to the player.", - "A block that cannot survive where it is put (a torch without a wall, a flower without ground) drops itself again and the call reports failure.", - "Replacing a block that holds items, such as a chest, drops its contents." - ), - List.of( - new ExampleDoc("Namespace is optional; states are allowed", - "world.set_block(10, 64, -3, \"minecraft:stone\")\n" - + "world.set_block(10, 65, -3, \"gold_block\")\n" - + "world.set_block(10, 66, -3, \"minecraft:oak_stairs[facing=north]\")"), - new ExampleDoc("Check whether it worked", - "local ok, reason = world.set_block(10, 64, -3, \"minecraft:stone\")\n" - + "if not ok then\n" - + " print(\"could not place the block: \" .. reason)\n" - + "end") - ) - ); - - private static final FunctionDoc REMOVE_BLOCK = new FunctionDoc( - "world.remove_block", - "world.remove_block(x, y, z [, drops])", - "Removes the block at the given position.", - List.of( - new ParamDoc("x", "number", false, "Absolute world x coordinate."), - new ParamDoc("y", "number", false, "Absolute world y coordinate."), - new ParamDoc("z", "number", false, "Absolute world z coordinate."), - new ParamDoc("drops", "boolean", true, - "Pass true to break the block the way a player would (items, sound, particles).") - ), - "true on success, or false followed by a reason string.", - List.of( - "Without drops the block just vanishes, silently and without items.", - "Fails with \"there is nothing to remove\" if the target is already air." - ), - List.of( - new ExampleDoc("Vanish versus break", - "world.remove_block(10, 64, -3) -- vanish\n" - + "world.remove_block(10, 65, -3, true) -- break it, dropping items") - ) - ); - - private static final FunctionDoc GET_BLOCK = new FunctionDoc( - "world.get_block", - "world.get_block(x, y, z)", - "Returns the block id at that position, including its block states.", - List.of( - new ParamDoc("x", "number", false, "Absolute world x coordinate."), - new ParamDoc("y", "number", false, "Absolute world y coordinate."), - new ParamDoc("z", "number", false, "Absolute world z coordinate.") - ), - "The block id string (ready to hand to set_block), or nil followed by a reason string.", - List.of( - "Air is the string \"minecraft:air\", and every string is truthy in Lua — compare against the id rather than testing the value.", - "The result carries block states, e.g. minecraft:grass_block[snowy=false]." - ), - List.of( - new ExampleDoc("Compare against the id, not the value", - "local block = world.get_block(10, 64, -3)\n" - + "if block ~= \"minecraft:air\" then\n" - + " print(\"something is there: \" .. block)\n" - + "end"), - new ExampleDoc("Copy one place to another", - "local block = world.get_block(10, 64, -3)\n" - + "if block then\n" - + " world.set_block(20, 70, 5, block)\n" - + "end") - ) - ); - - // ── print — chat output ─────────────────────────────────────────────── - - private static final FunctionDoc PRINT = new FunctionDoc( - "print", - "print(...)", - "Writes to the chat of the player who ran the script, tab-separated.", - List.of(), - "nothing", - List.of( - "Whole numbers go through the Lua wrapper and are printed as 12.0; concatenate them into a string to drop the decimal.", - "Runs on the server, so output appears in the running player's chat." - ), - List.of( - new ExampleDoc("Print to chat", - "print(\"blocks placed:\", 12)"), - new ExampleDoc("Drop the trailing .0", - "print(\"blocks placed: \" .. 12) -- -> blocks placed: 12") - ) - ); - - // ── The full table ──────────────────────────────────────────────────── - - private static final List TOPICS = List.of( - new Topic("world", "Read and write blocks in the running player's dimension.", - List.of(SET_BLOCK, REMOVE_BLOCK, GET_BLOCK)), - new Topic("print", "Send text to the chat of the player running the script.", - List.of(PRINT)) - ); - /** All documented topics, in display order. */ - public static List topics() { - return TOPICS; + public static synchronized List topics() { + if (cache == null) { + cache = load(); + } + return cache; } /** Flattened list of every documented function, across all topics. */ public static List functions() { - return TOPICS.stream().flatMap(t -> t.functions().stream()).toList(); + return topics().stream().flatMap(t -> t.functions().stream()).toList(); + } + + // ── Loading ─────────────────────────────────────────────────────────── + + private static List load() { + try (InputStream in = LuaApiDocs.class.getResourceAsStream(RESOURCE)) { + if (in == null) { + Codecraft.LOGGER.error("Lua API docs resource not found at {}", RESOURCE); + return List.of(); + } + return parse(JsonParser.parseReader( + new InputStreamReader(in, StandardCharsets.UTF_8)).getAsJsonObject()); + } catch (Exception e) { + Codecraft.LOGGER.error("Failed to load Lua API docs from {}", RESOURCE, e); + return List.of(); + } + } + + private static List parse(JsonObject root) { + List topics = new ArrayList<>(); + for (JsonElement t : optArray(root, "topics")) { + JsonObject topic = t.getAsJsonObject(); + List functions = new ArrayList<>(); + for (JsonElement f : optArray(topic, "functions")) { + functions.add(readFunction(f.getAsJsonObject())); + } + topics.add(new Topic( + str(topic, "title"), + str(topic, "blurb"), + List.copyOf(functions))); + } + return List.copyOf(topics); + } + + private static FunctionDoc readFunction(JsonObject f) { + List params = new ArrayList<>(); + for (JsonElement p : optArray(f, "params")) { + JsonObject param = p.getAsJsonObject(); + params.add(new ParamDoc( + str(param, "name"), + str(param, "type"), + param.has("optional") && param.get("optional").getAsBoolean(), + str(param, "description"))); + } + List notes = new ArrayList<>(); + for (JsonElement n : optArray(f, "notes")) { + notes.add(n.getAsString()); + } + List examples = new ArrayList<>(); + for (JsonElement e : optArray(f, "examples")) { + JsonObject example = e.getAsJsonObject(); + examples.add(new ExampleDoc( + str(example, "title"), + str(example, "code"))); + } + return new FunctionDoc( + str(f, "name"), + str(f, "signature"), + str(f, "summary"), + List.copyOf(params), + str(f, "returns"), + List.copyOf(notes), + List.copyOf(examples)); + } + + private static String str(JsonObject object, String key) { + JsonElement value = object.get(key); + return value == null || value.isJsonNull() ? "" : value.getAsString(); + } + + private static JsonArray optArray(JsonObject object, String key) { + JsonElement value = object.get(key); + return value != null && value.isJsonArray() ? value.getAsJsonArray() : new JsonArray(); } } diff --git a/src/main/java/com/aranroig/editor/Edit.java b/src/main/java/com/aranroig/editor/Edit.java new file mode 100644 index 0000000..9a65af5 --- /dev/null +++ b/src/main/java/com/aranroig/editor/Edit.java @@ -0,0 +1,338 @@ +package com.aranroig.editor; + +import net.minecraft.core.UUIDUtil; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.UUID; + +/** + * A character-level change to a document: a walk over the text saying which + * characters to keep ({@link Retain}), which to remove ({@link Delete}) and what + * to write ({@link Insert}). Anything the walk does not mention is left alone. + * + *

Describing a change this way, instead of as one "replace this range with + * that text", is what makes shared editing possible. Two players can write + * against the same version of a file at the same time; before such a change is + * used anywhere other than where it was written it is transformed + * against the changes that went in first ({@link #transformAgainst(Edit)}, + * {@link #transformPair(Edit, Edit)}), which re-expresses it against the text it + * is about to meet. Deleting around somebody else's freshly typed text, typing + * inside a selection they are throwing away, both merge instead of one of the + * two losing.

+ * + *

{@code author} and {@code seq} survive every transform. They give two + * inserts at the same offset a total order, so every player ends up with the + * characters in the same sequence, and they tell the server which edits came + * from the sender itself (those are already in the buffer the sender typed + * into, so the server must not apply them twice).

+ */ +public record Edit(UUID author, long seq, List components) { + + /** One step of the walk over a document. */ + public sealed interface Component permits Retain, Insert, Delete { + } + + /** Keep {@code count} characters of the document as they are. */ + public record Retain(int count) implements Component { + } + + /** Write {@code text} at this point of the document. */ + public record Insert(String text) implements Component { + } + + /** Remove {@code count} characters from the document. */ + public record Delete(int count) implements Component { + } + + private static final StreamCodec COMPONENT_CODEC = new StreamCodec<>() { + @Override + public Component decode(RegistryFriendlyByteBuf buf) { + return switch (buf.readByte()) { + case 1 -> new Insert(ByteBufCodecs.STRING_UTF8.decode(buf)); + case 2 -> new Delete(ByteBufCodecs.VAR_INT.decode(buf)); + default -> new Retain(ByteBufCodecs.VAR_INT.decode(buf)); + }; + } + + @Override + public void encode(RegistryFriendlyByteBuf buf, Component component) { + if (component instanceof Insert insert) { + buf.writeByte(1); + ByteBufCodecs.STRING_UTF8.encode(buf, insert.text()); + } else if (component instanceof Delete delete) { + buf.writeByte(2); + ByteBufCodecs.VAR_INT.encode(buf, delete.count()); + } else { + buf.writeByte(0); + ByteBufCodecs.VAR_INT.encode(buf, ((Retain) component).count()); + } + } + }; + + public static final StreamCodec STREAM_CODEC = + StreamCodec.composite( + UUIDUtil.STREAM_CODEC, + Edit::author, + + ByteBufCodecs.VAR_LONG, + Edit::seq, + + COMPONENT_CODEC.apply(ByteBufCodecs.list()), + Edit::components, + + Edit::new + ); + + // ── Building edits ──────────────────────────────────────────────────── + + /** A change that leaves the document as it is. */ + public static Edit none(UUID author, long seq) { + return new Edit(author, seq, List.of()); + } + + /** {@code text} written at {@code position}, nothing removed. */ + public static Edit insertion(UUID author, long seq, int position, String text) { + return replace(author, seq, position, 0, text); + } + + /** {@code count} characters removed at {@code position}, nothing written back. */ + public static Edit deletion(UUID author, long seq, int position, int count) { + return replace(author, seq, position, count, ""); + } + + /** + * The shape the text editor produces with every keystroke: remove + * {@code deleteLength} characters at {@code position} and write + * {@code insert} there. + */ + public static Edit replace(UUID author, long seq, int position, int deleteLength, String insert) { + List components = new ArrayList<>(3); + if (position > 0) components.add(new Retain(position)); + if (deleteLength > 0) components.add(new Delete(deleteLength)); + if (!insert.isEmpty()) components.add(new Insert(insert)); + return new Edit(author, seq, components); + } + + public boolean isEmpty() { + for (Component component : components) { + if (component instanceof Insert || component instanceof Delete) return false; + } + return true; + } + + /** How many characters of the document this edit reads; 0 for a pure insert. */ + public int baseLength() { + int total = 0; + for (Component component : components) { + if (component instanceof Retain retain) total += retain.count(); + else if (component instanceof Delete delete) total += delete.count(); + } + return total; + } + + // ── Applying ────────────────────────────────────────────────────────── + + /** + * Runs this edit over {@code base}. Counts that do not fit the text are + * clamped rather than thrown at: a document that stopped matching its + * version is repaired by resyncing, not by crashing the editor. + */ + public String apply(String base) { + if (isEmpty()) return base; + + StringBuilder result = new StringBuilder(base.length()); + int index = 0; + + for (Component component : components) { + if (component instanceof Retain retain) { + int count = Math.min(retain.count(), base.length() - index); + if (count <= 0) break; + result.append(base, index, index + count); + index += count; + } else if (component instanceof Delete delete) { + int count = Math.min(delete.count(), base.length() - index); + if (count <= 0) break; + index += count; + } else if (component instanceof Insert insert) { + result.append(insert.text()); + } + } + if (index < base.length()) result.append(base, index, base.length()); + return result.toString(); + } + + /** + * Where a caret at {@code caret} ends up once this edit is applied: text + * inserted before it pushes it along, text deleted around it collapses it + * onto the deletion point. Text inserted at the caret's own offset goes in + * front of it, which is where the editor expects its own typing to land. + */ + public int shiftPosition(int caret) { + int read = 0; // how far into the base document the walk has got + int written = 0; + + for (Component component : components) { + if (read >= caret) break; + + if (component instanceof Retain retain) { + int count = Math.min(retain.count(), caret - read); + read += count; + written += count; + } else if (component instanceof Delete delete) { + read += Math.min(delete.count(), caret - read); + // written does not move: the caret collapses onto the deletion + } else if (component instanceof Insert insert) { + written += insert.text().length(); + } + } + return written; + } + + // ── Transforming ────────────────────────────────────────────────────── + + /** + * This edit re-expressed against a document that already contains + * {@code other}. Both are assumed to have been written against the same + * base document; applying the result after {@code other} has the effect this + * edit was meant to have there. + */ + public Edit transformAgainst(Edit other) { + return transformPair(this, other)[0]; + } + + /** + * Both edits expressed against each other's result: returns + * {@code [this↑other, other↑this]}. Applying {@code this↑other} after + * {@code other} gives the same document as applying {@code other↑this} + * after {@code this}, which is what every player's copy converging on + * rests upon. + */ + public static Edit[] transformPair(Edit left, Edit right) { + List leftResult = new ArrayList<>(); + List rightResult = new ArrayList<>(); + + Deque leftOp = new ArrayDeque<>(left.components()); + Deque rightOp = new ArrayDeque<>(right.components()); + + while (!leftOp.isEmpty() || !rightOp.isEmpty()) { + // Whichever edit ran out says nothing about what is left of the + // document, which is the same as keeping it. + Component l = leftOp.peekFirst(); + Component r = rightOp.peekFirst(); + boolean lVirtual = l == null; + boolean rVirtual = r == null; + if (l == null) l = new Retain(remaining(r)); + if (r == null) r = new Retain(remaining(l)); + + if (l instanceof Insert lInsert && !(r instanceof Insert)) { + // Our text goes in before whatever the other edit does next. An + // insert is never swallowed by a concurrent deletion. + add(leftResult, lInsert); + add(rightResult, new Retain(lInsert.text().length())); + leftOp.pollFirst(); + continue; + } + if (r instanceof Insert rInsert && !(l instanceof Insert)) { + add(rightResult, rInsert); + add(leftResult, new Retain(rInsert.text().length())); + rightOp.pollFirst(); + continue; + } + if (l instanceof Insert lInsert && r instanceof Insert rInsert) { + // Two players typed at the same offset: authorship decides who + // ends up in front, the same way round in both directions. + if (left.precedes(right)) { + add(leftResult, lInsert); + add(rightResult, new Retain(lInsert.text().length())); + leftOp.pollFirst(); + } else { + add(rightResult, rInsert); + add(leftResult, new Retain(rInsert.text().length())); + rightOp.pollFirst(); + } + continue; + } + + // Neither side writes text here: both steps cover the same stretch + // of the original document. + int count = Math.min(remaining(l), remaining(r)); + boolean lDeletes = l instanceof Delete; + boolean rDeletes = r instanceof Delete; + + if (lDeletes && !rDeletes) add(leftResult, new Delete(count)); // they deleted it; we still want it gone + else if (rDeletes && !lDeletes) add(rightResult, new Delete(count)); + else if (!lDeletes && !rDeletes) { + add(leftResult, new Retain(count)); + add(rightResult, new Retain(count)); + } + // Both deleting: the characters are gone either way, nothing to say. + + consume(leftOp, count, lVirtual); + consume(rightOp, count, rVirtual); + } + + return new Edit[]{ + new Edit(left.author, left.seq, leftResult), + new Edit(right.author, right.seq, rightResult), + }; + } + + /** Collects a component, merging it into the previous one where possible. */ + private static void add(List components, Component component) { + if (component instanceof Retain retain && retain.count() == 0) return; + if (component instanceof Delete delete && delete.count() == 0) return; + if (component instanceof Insert insert && insert.text().isEmpty()) return; + + int last = components.size() - 1; + if (last >= 0) { + Component previous = components.get(last); + if (previous instanceof Retain a && component instanceof Retain b) { + components.set(last, new Retain(a.count() + b.count())); + return; + } + if (previous instanceof Delete a && component instanceof Delete b) { + components.set(last, new Delete(a.count() + b.count())); + return; + } + if (previous instanceof Insert a && component instanceof Insert b) { + components.set(last, new Insert(a.text() + b.text())); + return; + } + } + components.add(component); + } + + /** Characters a step covers: for inserts, the length of the text written. */ + private static int remaining(Component component) { + if (component instanceof Retain retain) return retain.count(); + if (component instanceof Delete delete) return delete.count(); + return ((Insert) component).text().length(); + } + + /** Advances a walk by {@code count} characters, splitting the step it lands in. */ + private static void consume(Deque components, int count, boolean virtual) { + if (virtual) return; // nothing there to advance; it is re-derived next round + Component head = components.pollFirst(); + int left = remaining(head) - count; + if (left > 0) { + components.addFirst(head instanceof Retain ? new Retain(left) : new Delete(left)); + } + } + + /** + * Total order over two edits, used only to decide which of two inserts at + * the same offset comes first. It deliberately ignores positions, so it + * still says the same thing after both have been transformed. + */ + public boolean precedes(Edit other) { + int byAuthor = author.compareTo(other.author); + if (byAuthor != 0) return byAuthor < 0; + return seq < other.seq; + } +} diff --git a/src/main/java/com/aranroig/editor/EditorFile.java b/src/main/java/com/aranroig/editor/EditorFile.java index 0eb5371..d7bf5a9 100644 --- a/src/main/java/com/aranroig/editor/EditorFile.java +++ b/src/main/java/com/aranroig/editor/EditorFile.java @@ -38,6 +38,10 @@ public class EditorFile { return name; } + public void setName(String name) { + this.name = name; + } + public String getText() { return text; } diff --git a/src/main/java/com/aranroig/editor/EditorPresence.java b/src/main/java/com/aranroig/editor/EditorPresence.java new file mode 100644 index 0000000..25bfa80 --- /dev/null +++ b/src/main/java/com/aranroig/editor/EditorPresence.java @@ -0,0 +1,43 @@ +package com.aranroig.editor; + +import net.minecraft.core.UUIDUtil; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; + +import java.util.UUID; + +/** + * Where one player is pointing inside a document they have open in the editor. + * + *

Offsets are character offsets into the document, the same coordinates the + * text editor uses for its own caret ({@code EditorFileView#cursorPos}), so a + * remote caret can be drawn with the same offset-to-pixel maths as the local + * one. {@code anchor} is {@code -1} when nothing is selected.

+ */ +public record EditorPresence(UUID playerId, String name, int color, int cursor, int anchor) { + + public static final StreamCodec STREAM_CODEC = + StreamCodec.composite( + UUIDUtil.STREAM_CODEC, + EditorPresence::playerId, + + ByteBufCodecs.STRING_UTF8, + EditorPresence::name, + + ByteBufCodecs.VAR_INT, + EditorPresence::color, + + ByteBufCodecs.VAR_INT, + EditorPresence::cursor, + + ByteBufCodecs.VAR_INT, + EditorPresence::anchor, + + EditorPresence::new + ); + + public boolean hasSelection() { + return anchor >= 0 && anchor != cursor; + } +} diff --git a/src/main/java/com/aranroig/editor/ProjectPath.java b/src/main/java/com/aranroig/editor/ProjectPath.java new file mode 100644 index 0000000..dd42cc4 --- /dev/null +++ b/src/main/java/com/aranroig/editor/ProjectPath.java @@ -0,0 +1,55 @@ +package com.aranroig.editor; + +/** + * The name of a project file is the path it lives at: {@code lib/gui/theme}, + * with '/' between the folders and no extension on the end. Nothing else has to + * know how a name is spelled — to the server it is only a key — so the sidebar + * can read the folders straight out of it instead of keeping a second structure + * that could end up disagreeing with the files it shows. + */ +public final class ProjectPath { + + public static final char SEPARATOR = '/'; + + /** The file a run executes: the one called {@code main}, at the root of the project. */ + public static final String ENTRYPOINT = "main"; + + /** Names written before files dropped the extension are still shown without it. */ + public static final String LEGACY_EXTENSION = ".lua"; + + private ProjectPath() { + } + + /** + * The folders in front of the file, without a trailing slash. Empty when the + * file sits at the root of the project, which is the same folder key the + * sidebar uses for everything not inside a folder. + */ + public static String folderOf(String path) { + int separator = path.lastIndexOf(SEPARATOR); + return separator < 0 ? "" : path.substring(0, separator); + } + + /** The last segment of a path: the name of the file or folder itself. */ + public static String nameOf(String path) { + int separator = path.lastIndexOf(SEPARATOR); + return separator < 0 ? path : path.substring(separator + 1); + } + + /** The last segment without its extension: what the sidebar shows as a label. */ + public static String displayNameOf(String path) { + return withoutExtension(nameOf(path)); + } + + /** Drops a trailing {@code .lua}. New names are written without one. */ + public static String withoutExtension(String name) { + return name.endsWith(LEGACY_EXTENSION) + ? name.substring(0, name.length() - LEGACY_EXTENSION.length()) + : name; + } + + /** Joins a folder and a name into a path. The folder may be the project root. */ + public static String resolve(String folder, String name) { + return folder.isEmpty() ? name : folder + SEPARATOR + name; + } +} diff --git a/src/main/java/com/aranroig/listeners/EventsApi.java b/src/main/java/com/aranroig/listeners/EventsApi.java new file mode 100644 index 0000000..c2d7005 --- /dev/null +++ b/src/main/java/com/aranroig/listeners/EventsApi.java @@ -0,0 +1,55 @@ +package com.aranroig.listeners; + +import party.iroiro.luajava.Lua; +import party.iroiro.luajava.value.LuaValue; + +/** + * The {@code events} table given to user scripts for registering listeners. + * + *

Registers one {@code events.on_(callback)} function per + * {@link GameEvent} onto a script's {@link Lua} state. Calling one stores the + * callback on the owning {@link ScriptRuntime}; it then fires whenever the game + * event happens, until the script is rerun (which resets the runtime) or the + * player disconnects.

+ * + *

The argument handling mirrors {@link com.aranroig.wrapper.WorldApi}: + * misuse returns {@code false} followed by a reason so callers can write + * {@code if not events.on_...(...) then ... end}. A passed function value is + * captured directly — luajava pops JFunction arguments with {@link Lua#get()}, + * which for a function yields a registry reference that stays valid while the + * state is open, so it can be called after the script has finished running.

+ */ +public final class EventsApi { + + private EventsApi() { + } + + /** + * Registers the global {@code events} table on the script's Lua state. + * + * @param lua state to register on + * @param runtime the runtime that owns the state and stores the callbacks + */ + public static void register(Lua lua, ScriptRuntime runtime) { + lua.newTable(); + int events = lua.getTop(); + + for (GameEvent event : GameEvent.values()) { + registerOne(lua, events, runtime, event); + } + + lua.setGlobal("events"); + } + + private static void registerOne(Lua lua, int table, ScriptRuntime runtime, GameEvent event) { + String function = event.luaFunction(); + lua.push((L, args) -> { + if (args.length < 1 || args[0].type() != Lua.LuaType.FUNCTION) { + return new LuaValue[]{ lua.from(false), lua.from("usage: events." + function + "(callback)") }; + } + runtime.addListener(event, args[0]); + return new LuaValue[]{ lua.from(true) }; + }); + lua.setField(table, function); + } +} diff --git a/src/main/java/com/aranroig/listeners/GameEvent.java b/src/main/java/com/aranroig/listeners/GameEvent.java new file mode 100644 index 0000000..17e3021 --- /dev/null +++ b/src/main/java/com/aranroig/listeners/GameEvent.java @@ -0,0 +1,49 @@ +package com.aranroig.listeners; + +/** + * The game events a Lua script can subscribe to with the {@code events} table. + * + *

The enum name is turned into the Lua registration function by + * {@link EventsApi}: {@link #USE_ITEM} becomes {@code events.on_use_item(fn)} + * and is the key a callback is stored under in {@link ScriptRuntime}. Keeping + * the names here means {@link EventsApi} (which registers the Lua functions) + * and {@link ScriptRuntimeManager} (which fires them from Fabric hooks) cannot + * drift apart.

+ */ +public enum GameEvent { + + /** Fires when a player right-clicks to use the item in their hand. */ + USE_ITEM("use_item"), + + /** Fires after a player has broken a block. */ + BREAK_BLOCK("break_block"), + + /** Fires when a player sends a chat message. */ + CHAT("chat"), + + /** Fires when a player finishes joining the game. */ + PLAYER_JOIN("player_join"), + + /** Fires when a player leaves the game. */ + PLAYER_LEAVE("player_leave"), + + /** Fires once per server tick, at the end of the tick. */ + TICK("tick"); + + /** Suffix used after {@code on_} for the Lua-facing function name. */ + private final String key; + + GameEvent(String key) { + this.key = key; + } + + /** {@code "use_item"} for {@link #USE_ITEM}; used as the listener-map key. */ + public String key() { + return key; + } + + /** The Lua function a player writes to subscribe, e.g. {@code on_use_item}. */ + public String luaFunction() { + return "on_" + key; + } +} diff --git a/src/main/java/com/aranroig/listeners/ScriptRuntime.java b/src/main/java/com/aranroig/listeners/ScriptRuntime.java new file mode 100644 index 0000000..4b0abd2 --- /dev/null +++ b/src/main/java/com/aranroig/listeners/ScriptRuntime.java @@ -0,0 +1,119 @@ +package com.aranroig.listeners; + +import com.aranroig.Codecraft; +import net.minecraft.network.chat.Component; +import net.minecraft.server.level.ServerPlayer; +import party.iroiro.luajava.Lua; +import party.iroiro.luajava.value.LuaValue; + +import java.util.ArrayList; +import java.util.EnumMap; +import java.util.List; +import java.util.Map; + +/** + * One running Lua script and the game-event listeners it registered. + * + *

A runtime is created fresh every time a player presses Run Script + * (see {@link ScriptRuntimeManager#startRun(ServerPlayer)}) and lives until the + * player runs the script again — which replaces it — or disconnects. It owns the + * {@link Lua} state that {@code events.on_*(fn)} callbacks close over, so those + * callbacks are only valid while this runtime is alive; {@link #stop()} closes + * the state and releases them.

+ * + *

Why callbacks survive the script finishing

+ * + *

When Lua calls a Java function, luajava pops each argument with + * {@link Lua#get()}; for a function argument that returns a registry-backed + * {@link LuaValue} ({@code RefLuaValue}). Holding a strong Java reference to it + * (which the listener list below does) keeps it alive, and calling it later with + * {@link LuaValue#call(Object...)} re-pushes it from the registry and + * {@code pcall}s it. That reference dies as soon as the {@link Lua} state is + * closed, which is exactly the reset behaviour we want on a rerun.

+ * + *

All methods run on the server thread — payload handling and every game + * event this bridges are server-thread — so there is no locking.

+ */ +public final class ScriptRuntime { + + private final Lua lua; + private final ServerPlayer owner; + private final Map> listeners = new EnumMap<>(GameEvent.class); + + ScriptRuntime(Lua lua, ServerPlayer owner) { + this.lua = lua; + this.owner = owner; + } + + /** The Lua state to run the entrypoint on; globals are already registered. */ + public Lua lua() { + return lua; + } + + /** Runs the entrypoint. Errors are left to the caller to report to the player. */ + public void run(String script) { + lua.run(script); + } + + /** + * Registers one Lua callback for an event. + * + *

The value must be a function; the caller ({@link EventsApi}) checks + * that before handing it over. The reference is stored as-is and stays valid + * until {@link #stop()} closes the state.

+ */ + void addListener(GameEvent event, LuaValue callback) { + listeners.computeIfAbsent(event, e -> new ArrayList<>()).add(callback); + } + + /** Whether any script under this runtime listens for {@code event}. */ + boolean hasListeners(GameEvent event) { + List list = listeners.get(event); + return list != null && !list.isEmpty(); + } + + /** + * Fires every callback registered for {@code event}, passing {@code args} + * (Java strings/numbers converted to Lua scalars) positionally. + * + *

Iterates a snapshot so a callback may itself call {@code events.on_*} + * without disturbing this loop. A callback that throws is reported to the + * owner and logged, and the remaining callbacks still run — one bad listener + * never breaks the game loop or the others.

+ */ + void dispatch(GameEvent event, Object... args) { + List list = listeners.get(event); + if (list == null || list.isEmpty()) { + return; + } + for (LuaValue callback : List.copyOf(list)) { + try { + callback.call(args); + } catch (Throwable t) { + Codecraft.LOGGER.warn("Error in events." + event.luaFunction() + " callback", t); + reportError("events." + event.luaFunction() + ": " + t.getMessage()); + } + } + } + + /** Sends an error line to the owner's chat, if they are still connected. */ + void reportError(String message) { + if (owner != null && !owner.hasDisconnected()) { + owner.sendSystemMessage(Component.literal("§ccodecraft error: " + message)); + } + } + + /** + * Releases the script: empties the listener list and closes the Lua state, + * which invalidates every callback that was stored. Called on rerun (before + * the replacement runtime is installed) and on disconnect. + */ + void stop() { + listeners.clear(); + try { + lua.close(); + } catch (RuntimeException e) { + Codecraft.LOGGER.warn("Error closing Lua state", e); + } + } +} diff --git a/src/main/java/com/aranroig/listeners/ScriptRuntimeManager.java b/src/main/java/com/aranroig/listeners/ScriptRuntimeManager.java new file mode 100644 index 0000000..88ac872 --- /dev/null +++ b/src/main/java/com/aranroig/listeners/ScriptRuntimeManager.java @@ -0,0 +1,186 @@ +package com.aranroig.listeners; + +import com.aranroig.wrapper.ChatLogger; +import com.aranroig.wrapper.WorldApi; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents; +import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents; +import net.fabricmc.fabric.api.event.player.UseItemCallback; +import net.fabricmc.fabric.api.message.v1.ServerMessageEvents; +import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; +import net.minecraft.core.BlockPos; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.network.chat.PlayerChatMessage; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.InteractionHand; +import net.minecraft.world.InteractionResult; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.block.state.BlockState; +import party.iroiro.luajava.Lua; +import party.iroiro.luajava.luaj.LuaJ; + +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +/** + * The server-side owner of every running script and of the {@code events} + * listeners they register. + * + *

There is one {@link ScriptRuntime} per player who has run the script. The + * Fabric hooks that turn game activity into Lua callbacks are installed + * once, in {@link #install()}; each hook simply dispatches to whichever + * runtime is currently registered. That keeps reset cheap and complete: + * {@link #startRun(ServerPlayer)} stops the player's previous runtime (closing + * its Lua state, which drops its callbacks) and installs a fresh one, so + * re-running the script always starts from no listeners.

+ * + *

Threading

+ * + *

All state here is touched only on the server thread: run requests arrive on + * it, and every hooked game event (item use, block break, chat, join/leave, + * tick) fires on it. A script's {@code Lua} state is therefore never touched + * concurrently, and the disconnect hook is careful to drop a runtime that a + * later dispatch might otherwise reach.

+ */ +public final class ScriptRuntimeManager { + + private static final Map ACTIVE = new HashMap<>(); + + private ScriptRuntimeManager() { + } + + /** + * Wires the Fabric game events to the dispatcher. Call once from + * {@link com.aranroig.Codecraft#onInitialize()}. + */ + public static void install() { + UseItemCallback.EVENT.register((player, level, hand) -> { + onUseItem(player, hand); + return InteractionResult.PASS; + }); + + PlayerBlockBreakEvents.AFTER.register((level, player, pos, state, blockEntity) -> + onBreakBlock(player, pos, state)); + + ServerMessageEvents.CHAT_MESSAGE.register((message, sender, params) -> + onChat(sender, message)); + + ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> + onPlayerJoin(handler.player)); + + ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> { + onPlayerLeave(handler.player); + // Free the leaving player's runtime; their callbacks can no longer + // act on a disconnected owner. + stop(handler.player); + }); + + ServerTickEvents.END_SERVER_TICK.register(ScriptRuntimeManager::onTick); + + // Safety net: never leave Lua states open across a server shutdown. + ServerLifecycleEvents.SERVER_STOPPING.register(server -> stopAll()); + } + + /** + * Replaces {@code player}'s running script with a brand-new runtime and + * returns it, ready for the entrypoint to be {@linkplain ScriptRuntime#run + * run}. Any listeners the player registered previously are dropped. + * + * @param player the player who pressed Run Script + * @return the fresh runtime with {@code print}, {@code world} and + * {@code events} already registered on its Lua state + */ + public static ScriptRuntime startRun(ServerPlayer player) { + stop(player); + ScriptRuntime runtime = newRuntime(player); + ACTIVE.put(player.getUUID(), runtime); + return runtime; + } + + private static ScriptRuntime newRuntime(ServerPlayer player) { + Lua lua = new LuaJ(); + ScriptRuntime runtime = new ScriptRuntime(lua, player); + lua.push(ChatLogger.print(player)); + lua.setGlobal("print"); + WorldApi.register(lua, player); + EventsApi.register(lua, runtime); + return runtime; + } + + // ── Dispatch ────────────────────────────────────────────────────────── + + private static void onUseItem(Player player, InteractionHand hand) { + if (!(player instanceof ServerPlayer)) { + return; + } + ItemStack stack = player.getItemInHand(hand); + if (stack.isEmpty()) { + return; + } + String item = BuiltInRegistries.ITEM.getKey(stack.getItem()).toString(); + String handName = hand == InteractionHand.OFF_HAND ? "off" : "main"; + dispatch(GameEvent.USE_ITEM, player.getScoreboardName(), item, (long) stack.getCount(), handName); + } + + private static void onBreakBlock(Player player, BlockPos pos, BlockState state) { + if (!(player instanceof ServerPlayer)) { + return; + } + String block = BuiltInRegistries.BLOCK.getKey(state.getBlock()).toString(); + dispatch(GameEvent.BREAK_BLOCK, player.getScoreboardName(), + (long) pos.getX(), (long) pos.getY(), (long) pos.getZ(), block); + } + + private static void onChat(ServerPlayer player, PlayerChatMessage message) { + dispatch(GameEvent.CHAT, player.getScoreboardName(), message.signedContent()); + } + + private static void onPlayerJoin(ServerPlayer player) { + dispatch(GameEvent.PLAYER_JOIN, player.getScoreboardName()); + } + + private static void onPlayerLeave(ServerPlayer player) { + dispatch(GameEvent.PLAYER_LEAVE, player.getScoreboardName()); + } + + private static void onTick(MinecraftServer server) { + dispatch(GameEvent.TICK, (long) server.getTickCount()); + } + + /** + * Fires {@code event} on every runtime that listens for it. A runtime with + * no listener for the event is skipped, so idle scripts cost nothing per + * hook. + */ + private static void dispatch(GameEvent event, Object... args) { + if (ACTIVE.isEmpty()) { + return; + } + // Copy values so a callback that reruns or a disconnect during the loop + // cannot mutate the map while we iterate. + for (ScriptRuntime runtime : Map.copyOf(ACTIVE).values()) { + if (runtime.hasListeners(event)) { + runtime.dispatch(event, args); + } + } + } + + // ── Teardown ────────────────────────────────────────────────────────── + + private static void stop(ServerPlayer player) { + ScriptRuntime runtime = ACTIVE.remove(player.getUUID()); + if (runtime != null) { + runtime.stop(); + } + } + + private static void stopAll() { + for (ScriptRuntime runtime : ACTIVE.values()) { + runtime.stop(); + } + ACTIVE.clear(); + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundDocumentEditPayload.java b/src/main/java/com/aranroig/payloads/ClientboundDocumentEditPayload.java new file mode 100644 index 0000000..7fbb611 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundDocumentEditPayload.java @@ -0,0 +1,41 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import com.aranroig.editor.Edit; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Someone else's edit of {@code file}, already rebased by the server. The file + * is now at {@code version}. The player who wrote the edit does not get this: + * their copy already has it, they get an {@link ClientboundEditAckPayload} + * instead. + */ +public record ClientboundDocumentEditPayload(String file, int version, Edit edit) implements CustomPacketPayload { + + public static final Identifier DOCUMENT_EDIT_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "document_edit"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(DOCUMENT_EDIT_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundDocumentEditPayload::file, + + ByteBufCodecs.VAR_INT, + ClientboundDocumentEditPayload::version, + + Edit.STREAM_CODEC, + ClientboundDocumentEditPayload::edit, + + ClientboundDocumentEditPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundDocumentStatePayload.java b/src/main/java/com/aranroig/payloads/ClientboundDocumentStatePayload.java new file mode 100644 index 0000000..f7b23d4 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundDocumentStatePayload.java @@ -0,0 +1,39 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * The authoritative contents of {@code file} at {@code version}. Sent in reply + * to {@link ServerboundOpenDocumentPayload}, and again whenever the server + * finds that a client's copy is too old to be rebased onto the live one. + */ +public record ClientboundDocumentStatePayload(String file, String text, int version) implements CustomPacketPayload { + + public static final Identifier DOCUMENT_STATE_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "document_state"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(DOCUMENT_STATE_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundDocumentStatePayload::file, + + ByteBufCodecs.STRING_UTF8, + ClientboundDocumentStatePayload::text, + + ByteBufCodecs.VAR_INT, + ClientboundDocumentStatePayload::version, + + ClientboundDocumentStatePayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundEditAckPayload.java b/src/main/java/com/aranroig/payloads/ClientboundEditAckPayload.java new file mode 100644 index 0000000..104213b --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundEditAckPayload.java @@ -0,0 +1,44 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Confirms that the server applied one of the player's own edits: the document + * is now at {@code version}, whose contents have length {@code textLength} and + * hash {@code textHash}. Once the player has no edits in flight any more, they + * compare those two against their own buffer; a mismatch means the copies + * drifted apart and the file is fetched again. + */ +public record ClientboundEditAckPayload(String file, int version, int textHash, int textLength) implements CustomPacketPayload { + + public static final Identifier EDIT_ACK_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "edit_ack"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(EDIT_ACK_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundEditAckPayload::file, + + ByteBufCodecs.VAR_INT, + ClientboundEditAckPayload::version, + + ByteBufCodecs.VAR_INT, + ClientboundEditAckPayload::textHash, + + ByteBufCodecs.VAR_INT, + ClientboundEditAckPayload::textLength, + + ClientboundEditAckPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundPresencePayload.java b/src/main/java/com/aranroig/payloads/ClientboundPresencePayload.java new file mode 100644 index 0000000..4ef9a76 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundPresencePayload.java @@ -0,0 +1,39 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import com.aranroig.editor.EditorPresence; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +import java.util.List; + +/** + * Who else has {@code file} open in their editor right now, and where their + * carets are. Everyone with the editor open gets this for every file somebody + * joins, leaves or moves in, minus themselves. + */ +public record ClientboundPresencePayload(String file, List editors) implements CustomPacketPayload { + + public static final Identifier PRESENCE_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "presence"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(PRESENCE_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundPresencePayload::file, + + EditorPresence.STREAM_CODEC.apply(ByteBufCodecs.list()), + ClientboundPresencePayload::editors, + + ClientboundPresencePayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundRenameFilePayload.java b/src/main/java/com/aranroig/payloads/ClientboundRenameFilePayload.java new file mode 100644 index 0000000..7ade3df --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundRenameFilePayload.java @@ -0,0 +1,36 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Tells the client that a project file was renamed by somebody else, so its + * name in the file list and all live-editing bookkeeping keyed by the old name + * follow it. + */ +public record ClientboundRenameFilePayload(String oldName, String newName) implements CustomPacketPayload { + + public static final Identifier RENAME_FILE_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "rename_file"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(RENAME_FILE_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundRenameFilePayload::oldName, + + ByteBufCodecs.STRING_UTF8, + ClientboundRenameFilePayload::newName, + + ClientboundRenameFilePayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundShellClosedPayload.java b/src/main/java/com/aranroig/payloads/ClientboundShellClosedPayload.java new file mode 100644 index 0000000..8ceea00 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundShellClosedPayload.java @@ -0,0 +1,31 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * The shell is gone — it exited on its own or could not be started — and says + * why, which the terminal pane prints as a dim note. + */ +public record ClientboundShellClosedPayload(String reason) implements CustomPacketPayload { + + public static final Identifier SHELL_CLOSED_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "shell_closed"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(SHELL_CLOSED_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundShellClosedPayload::reason, + ClientboundShellClosedPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ClientboundShellOutputPayload.java b/src/main/java/com/aranroig/payloads/ClientboundShellOutputPayload.java new file mode 100644 index 0000000..e4cea92 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ClientboundShellOutputPayload.java @@ -0,0 +1,32 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Everything the shell printed, in order — stdout and stderr merged, line + * endings already normalised to {@code \n}. A message can hold any number of + * lines and can stop in the middle of one: the pane just appends it. + */ +public record ClientboundShellOutputPayload(String text) implements CustomPacketPayload { + + public static final Identifier SHELL_OUTPUT_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "shell_output"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(SHELL_OUTPUT_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ClientboundShellOutputPayload::text, + ClientboundShellOutputPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundCloseEditorPayload.java b/src/main/java/com/aranroig/payloads/ServerboundCloseEditorPayload.java new file mode 100644 index 0000000..a162ff7 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundCloseEditorPayload.java @@ -0,0 +1,27 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * The player closed the editor: drop them from every live editing session, so + * their caret disappears from everyone else's screen and their keystrokes are + * no longer streamed to them. + */ +public record ServerboundCloseEditorPayload() implements CustomPacketPayload { + + public static final Identifier CLOSE_EDITOR_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "close_editor"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(CLOSE_EDITOR_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.unit(new ServerboundCloseEditorPayload()); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundCloseShellPayload.java b/src/main/java/com/aranroig/payloads/ServerboundCloseShellPayload.java new file mode 100644 index 0000000..2e56f4c --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundCloseShellPayload.java @@ -0,0 +1,26 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * The player closed the terminal pane: kill the shell it was attached to. + * Nothing about it is saved — closing the pane means closing the shell. + */ +public record ServerboundCloseShellPayload() implements CustomPacketPayload { + + public static final Identifier CLOSE_SHELL_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "close_shell"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(CLOSE_SHELL_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.unit(new ServerboundCloseShellPayload()); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundCursorPayload.java b/src/main/java/com/aranroig/payloads/ServerboundCursorPayload.java new file mode 100644 index 0000000..8296eb6 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundCursorPayload.java @@ -0,0 +1,38 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Moves the player's caret (and selection) inside {@code file}, to be shown on + * everyone else's screen. + */ +public record ServerboundCursorPayload(String file, int cursor, int anchor) implements CustomPacketPayload { + + public static final Identifier CURSOR_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "cursor"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(CURSOR_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ServerboundCursorPayload::file, + + ByteBufCodecs.VAR_INT, + ServerboundCursorPayload::cursor, + + ByteBufCodecs.VAR_INT, + ServerboundCursorPayload::anchor, + + ServerboundCursorPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundEditPayload.java b/src/main/java/com/aranroig/payloads/ServerboundEditPayload.java new file mode 100644 index 0000000..f02ed44 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundEditPayload.java @@ -0,0 +1,40 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import com.aranroig.editor.Edit; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * One keystroke's worth of changes to {@code file}, made against version + * {@code baseVersion} of it. The server rebases the edit onto the current + * version, applies it, and hands it to everyone else editing the file. + */ +public record ServerboundEditPayload(String file, int baseVersion, Edit edit) implements CustomPacketPayload { + + public static final Identifier EDIT_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "edit"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(EDIT_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ServerboundEditPayload::file, + + ByteBufCodecs.VAR_INT, + ServerboundEditPayload::baseVersion, + + Edit.STREAM_CODEC, + ServerboundEditPayload::edit, + + ServerboundEditPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundOpenDocumentPayload.java b/src/main/java/com/aranroig/payloads/ServerboundOpenDocumentPayload.java new file mode 100644 index 0000000..ede6e15 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundOpenDocumentPayload.java @@ -0,0 +1,35 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Asks the server to put the player into the live editing session of + * {@code file} and to reply with its authoritative contents + * ({@link ClientboundDocumentStatePayload}). Sent when the editor opens and + * every time the player switches file; the server then streams that file's + * edits and carets to the player. + */ +public record ServerboundOpenDocumentPayload(String file) implements CustomPacketPayload { + + public static final Identifier OPEN_DOCUMENT_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "open_document"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(OPEN_DOCUMENT_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ServerboundOpenDocumentPayload::file, + + ServerboundOpenDocumentPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundRenameFilePayload.java b/src/main/java/com/aranroig/payloads/ServerboundRenameFilePayload.java new file mode 100644 index 0000000..2b20f42 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundRenameFilePayload.java @@ -0,0 +1,37 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Asks the server to rename a project file: its copy in the saved project and + * its live document move to the new name, the sessions of everyone editing it + * follow, and the other editors are told + * ({@link ClientboundRenameFilePayload}). + */ +public record ServerboundRenameFilePayload(String oldName, String newName) implements CustomPacketPayload { + + public static final Identifier RENAME_FILE_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "rename_file"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(RENAME_FILE_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ServerboundRenameFilePayload::oldName, + + ByteBufCodecs.STRING_UTF8, + ServerboundRenameFilePayload::newName, + + ServerboundRenameFilePayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundShellInputPayload.java b/src/main/java/com/aranroig/payloads/ServerboundShellInputPayload.java new file mode 100644 index 0000000..8132e13 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundShellInputPayload.java @@ -0,0 +1,34 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * What the terminal pane's keyboard produces, written to the pseudo-terminal + * exactly as it is: a keystroke, a Tab, the {@code \u0003} Ctrl-C becomes, an + * arrow key's escape sequence, a status report the emulator owes the shell. + * On the pty those bytes are not text but signals and edits — SIGINT, an + * echoed backspace, vim moving its cursor — so nothing here interprets them. + */ +public record ServerboundShellInputPayload(String bytes) implements CustomPacketPayload { + + public static final Identifier SHELL_INPUT_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "shell_input"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(SHELL_INPUT_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.STRING_UTF8, + ServerboundShellInputPayload::bytes, + ServerboundShellInputPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundShellResizePayload.java b/src/main/java/com/aranroig/payloads/ServerboundShellResizePayload.java new file mode 100644 index 0000000..7d7cba8 --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundShellResizePayload.java @@ -0,0 +1,37 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * The terminal pane's grid changed size. Not keystrokes — the shell's input + * is left alone: the server resizes the pseudo-terminal itself, and the + * kernel signals whatever runs in it the way it signals a real window's + * resize. That is what lets a full-screen program reflow while it holds the + * screen, which a typed {@code stty} at a prompt that is not there could + * never do. + */ +public record ServerboundShellResizePayload(int rows, int cols) implements CustomPacketPayload { + + public static final Identifier SHELL_RESIZE_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "shell_resize"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(SHELL_RESIZE_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.VAR_INT, + ServerboundShellResizePayload::rows, + ByteBufCodecs.VAR_INT, + ServerboundShellResizePayload::cols, + ServerboundShellResizePayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/payloads/ServerboundSpawnShellPayload.java b/src/main/java/com/aranroig/payloads/ServerboundSpawnShellPayload.java new file mode 100644 index 0000000..de2f5ab --- /dev/null +++ b/src/main/java/com/aranroig/payloads/ServerboundSpawnShellPayload.java @@ -0,0 +1,34 @@ +package com.aranroig.payloads; + +import com.aranroig.Codecraft; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.codec.ByteBufCodecs; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.resources.Identifier; + +/** + * Ask for a shell. The size of the terminal pane that asked comes along: a + * terminal opens at the size of its window, and 0 means the client could not + * tell it yet, which leaves the shell on its own defaults. + */ +public record ServerboundSpawnShellPayload(int rows, int cols) implements CustomPacketPayload { + + public static final Identifier SPAWN_SHELL_PAYLOAD_ID = Identifier.fromNamespaceAndPath(Codecraft.MOD_ID, "spawn_shell"); + + public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(SPAWN_SHELL_PAYLOAD_ID); + + public static final StreamCodec CODEC = + StreamCodec.composite( + ByteBufCodecs.VAR_INT, + ServerboundSpawnShellPayload::rows, + ByteBufCodecs.VAR_INT, + ServerboundSpawnShellPayload::cols, + ServerboundSpawnShellPayload::new + ); + + @Override + public Type type() { + return TYPE; + } +} diff --git a/src/main/java/com/aranroig/shell/ShellManager.java b/src/main/java/com/aranroig/shell/ShellManager.java new file mode 100644 index 0000000..a8f1481 --- /dev/null +++ b/src/main/java/com/aranroig/shell/ShellManager.java @@ -0,0 +1,115 @@ +package com.aranroig.shell; + +import com.aranroig.Codecraft; +import com.aranroig.payloads.ClientboundShellClosedPayload; +import com.aranroig.payloads.ClientboundShellOutputPayload; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; +import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; +import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerPlayer; + +import java.io.IOException; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + +/** + * The server half of the editor's terminal: at most one {@link ShellSession} + * per player, spawned when they press the terminal button and killed when they + * close the pane, leave, or the server stops. + * + *

This hands out a real shell on the machine the server runs on, to + * anyone who can open the editor. Commands run as the server's user, in + * the server's files, with everything that implies. That is fine on a + * single-player game or a server among friends who all get the keys to the + * box; it is emphatically not something to leave open to strangers.

+ * + *

Payload handlers run on the server thread, so spawning, submitting and + * closing need no locking; only the output threads report back from outside, + * through {@link #sessionEnded}, hence the concurrent map.

+ */ +public final class ShellManager { + + private static final Map SESSIONS = new ConcurrentHashMap<>(); + + private ShellManager() { + } + + /** Kills every shell when its player leaves or the server goes down. */ + public static void install() { + ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> close(handler.player)); + ServerLifecycleEvents.SERVER_STOPPING.register(ShellManager::closeAll); + } + + /** + * Gives {@code player} a shell, opening it at the size of the terminal + * pane that asked ({@code rows}/{@code cols} of 0: the shell's own + * defaults). Pressing the button with one already running does not + * disturb it: the pane keeps its scrollback, so the same session is + * simply attached again and told so. + */ + public static void spawn(ServerPlayer player, int rows, int cols) { + ShellSession existing = SESSIONS.get(player.getUUID()); + if (existing != null && existing.isAlive()) { + send(player, new ClientboundShellOutputPayload("shell already running — this pane is attached to it\r\n")); + return; + } + if (existing != null) existing.close(); + + ShellSession session = new ShellSession(player); + try { + session.start(rows, cols); + SESSIONS.put(player.getUUID(), session); + } catch (IOException e) { + Codecraft.LOGGER.warn("Could not spawn a shell for {}", player.getName().getString(), e); + send(player, new ClientboundShellOutputPayload("could not start a shell: " + e.getMessage() + "\r\n")); + send(player, new ClientboundShellClosedPayload("could not start a shell")); + } + } + + /** Forwards what the pane's keyboard produced, as it is, to that player's shell. */ + public static void submit(ServerPlayer player, String bytes) { + ShellSession session = SESSIONS.get(player.getUUID()); + if (session == null || !session.isAlive()) { + send(player, new ClientboundShellOutputPayload("no shell running — open one with the Shell button\r\n")); + return; + } + session.submitInput(bytes); + } + + /** + * Resizes the pty behind that player's shell to the size their terminal + * pane now has. Nothing is said when there is no live shell to size: the + * next spawn opens at whatever size asks anyway. + */ + public static void resize(ServerPlayer player, int rows, int cols) { + ShellSession session = SESSIONS.get(player.getUUID()); + if (session != null && session.isAlive()) session.resize(rows, cols); + } + + /** Kills the shell a player was attached to, if they had one. */ + public static void close(ServerPlayer player) { + ShellSession session = SESSIONS.remove(player.getUUID()); + if (session != null) session.close(); + } + + /** Called by a session's output thread once the process is done with. */ + static void sessionEnded(ShellSession session) { + SESSIONS.values().removeIf(alive -> alive == session); + } + + private static void closeAll(MinecraftServer server) { + for (ShellSession session : SESSIONS.values()) session.close(); + SESSIONS.clear(); + } + + private static void send(ServerPlayer player, CustomPacketPayload payload) { + try { + ServerPlayNetworking.send(player, payload); + } catch (RuntimeException e) { + // The player is leaving; nobody is there to read this. + } + } +} diff --git a/src/main/java/com/aranroig/shell/ShellSession.java b/src/main/java/com/aranroig/shell/ShellSession.java new file mode 100644 index 0000000..a94ab1e --- /dev/null +++ b/src/main/java/com/aranroig/shell/ShellSession.java @@ -0,0 +1,535 @@ +package com.aranroig.shell; + +import com.aranroig.Codecraft; +import com.aranroig.payloads.ClientboundShellClosedPayload; +import com.aranroig.payloads.ClientboundShellOutputPayload; +import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; +import net.minecraft.network.protocol.common.custom.CustomPacketPayload; +import net.minecraft.server.level.ServerPlayer; + +import java.io.File; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.Reader; +import java.lang.ProcessBuilder.Redirect; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +/** + * One interactive bash session on the server, wired to one player's terminal + * pane: what it prints is forwarded to the pane as + * {@link ClientboundShellOutputPayload}s, and every byte the player types is + * written to its input. + * + *

A real terminal, not a pipe

+ * + *

Bash is fully interactive ({@code -i}, readline and all) and runs on a + * pseudo-terminal allocated through {@code script} (util-linux), so everything + * a real terminal does happens here: the tty echoes what arrives, readline + * redraws the line while it is edited, programs see a tty — {@code tty} says + * {@code /dev/pts/…}, {@code ls --color=auto} colours, {@code sudo} prompts, + * {@code vim} takes over the screen — and {@code TERM} is + * {@code xterm-256color} to match. Drawing all of that, cursor and all, is the + * pane's job: it is the emulator, this is only the machine behind it. Where + * {@code script} is not available, it falls back to plain non-interactive + * bash over pipes, which still runs commands and keeps state, but without any + * of the tty behaviours.

+ * + *

The pane tells the shell how big the "window" is the way a real terminal + * emulator sizes one: the pty's window is moved from out here — {@code stty} + * run against the session's {@code /dev/pts} device, which makes the kernel + * resize the terminal and signal the programs in the foreground that it did, + * so a full-screen program reflows mid-resize — and nothing is ever typed + * into the shell to say so.

+ * + *

Threading

+ * + *

The process' output is read on its own thread — a command that prints + * for a minute must not stop the server from ticking — and handed straight to + * the player's connection, which netty accepts from any thread. Input goes + * the other way from the server thread, written through as it arrives.

+ */ +public final class ShellSession { + + /** + * The shell the pseudo-terminal runs: the server user's plain interactive + * bash, so — exactly like a terminal opened on the machine itself — it + * sources their startup files, {@code /etc/bash.bashrc} and + * {@code ~/.bashrc}, before the first prompt. + */ + private static final String SHELL_COMMAND = "bash -i"; + + /** Allocates the pty that lets bash be interactive. Tried in order. */ + private static final String[] PTY_LAUNCHERS = { "/usr/bin/script", "/bin/script", "script" }; + + /** Tried in order when no pty launcher could be started; first one that starts wins. */ + private static final String[] PLAIN_SHELLS = { "/bin/bash", "/usr/bin/bash", "bash" }; + + /** + * Sizes the pty's window through its {@code /dev/pts} device; tried in + * order like everything else. {@code stty} does nothing but the one ioctl + * on its standard input, which the kernel turns into a new window size + * and — when it changed — a SIGWINCH for the terminal's foreground group. + */ + private static final String[] STTY_COMMANDS = { "/bin/stty", "/usr/bin/stty", "stty" }; + + /** How long the shell may take to appear under {@code script} before the pty device search gives up. */ + private static final long PTS_SEARCH_BUDGET_MS = 5_000; + private static final long PTS_SEARCH_RETRY_MS = 200; + + /** How long one {@code stty} may take to size a window before it is not believed. */ + private static final long STTY_TIMEOUT_MS = 2_000; + + /** How much of the shell's output is read — and sent — at once. */ + private static final int CHUNK_SIZE = 4096; + + private final ServerPlayer player; + + private Process process; + private OutputStream stdin; + private volatile boolean alive; + + /** Whether the shell sits on a real pty (programs see a terminal) or on pipes. */ + private boolean interactive; + + /** Set when we killed it ourselves, so its exit is not announced as news. */ + private volatile boolean closing; + + /** + * Guards the wanted and applied window sizes, and the wait between the + * pane wanting one and the resize worker getting it: the pane's sizes + * arrive on the server thread with its payloads, and the {@code stty} + * runs that turn them into kernel calls must not keep the server ticking. + */ + private final Object resizeLock = new Object(); + + /** The size the pane last wanted, and the last one actually applied; guarded by {@link #resizeLock}. */ + private int wantRows, wantCols, appliedRows, appliedCols; + + /** Whether the worker that applies sizes has been started; guarded by {@link #resizeLock}. */ + private boolean resizeLoopStarted; + + /** + * This session's {@code /dev/pts} device, found once by following the + * process tree down from {@code script}: whoever runs under it has the + * pty on its standard input, and the link there is the device. Written + * only by the resize worker. + */ + private String ptsDevice; + + /** Whether the device above was given up on; guarded by {@link #resizeLock}, read by the worker. */ + private boolean ptsSearchFailed; + + ShellSession(ServerPlayer player) { + this.player = player; + } + + /** + * Spawns the shell and starts forwarding its output to the player. A + * pseudo-terminal through {@code script} if one can be had, plain bash + * over pipes otherwise. {@code rows}/{@code cols} (when positive) are the + * size of the pane that asked: on the pty the window is set to them as + * soon as its device can be found (see {@link #resize}), the same call a + * real window resize makes; only the pipe fallback, which has no terminal + * at all to size, is given them as {@code LINES}/{@code COLUMNS} instead. + * + * @throws IOException no shell could be started on this machine + */ + public void start(int rows, int cols) throws IOException { + IOException lastFailure = null; + + for (String launcher : PTY_LAUNCHERS) { + try { + process = ptyBuilderFor(launcher).start(); + // `script` starting is not running it: an older one that does + // not know these options exits at once, and that is found out + // by giving it the moment it needs, no more. + if (startedAndStayedUp()) { + interactive = true; + break; + } + process = null; + } catch (IOException e) { + lastFailure = e; + process = null; + } + } + if (process == null) { + for (String shell : PLAIN_SHELLS) { + try { + process = plainBuilderFor(shell, rows, cols).start(); + break; + } catch (IOException e) { + lastFailure = e; + } + } + } + if (process == null) { + throw lastFailure != null ? lastFailure + : new IOException("no bash found on this server"); + } + + stdin = process.getOutputStream(); + alive = true; + Codecraft.LOGGER.info("Spawned a {} shell for {} in {}", + interactive ? "pty-backed" : "plain", + player.getName().getString(), System.getProperty("user.dir")); + + // A terminal opens at the size of the window that asked: `script` + // cannot be told, so its pty starts at the kernel's default and the + // worker corrects it to the pane's grid a moment later, as soon as + // the device behind it is findable — well before bash prints much. + synchronized (resizeLock) { + wantRows = rows; + wantCols = cols; + if (interactive) startResizeLoop(); + } + + Thread.ofVirtual() + .name("codecraft-shell-" + player.getName().getString()) + .start(this::pumpOutput); + } + + /** + * Whether the process made it past the moment an unusable launcher takes + * to argue with its own command line and give up. + */ + private boolean startedAndStayedUp() { + try { + return !process.waitFor(250, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return true; + } + } + + private static ProcessBuilder ptyBuilderFor(String script) { + ProcessBuilder builder = new ProcessBuilder( + // -q quiet, -f flush every write (output must not wait for the + // shell to exit), -e exit with the child's code. The tty's + // echo stays on: the pane shows what was typed exactly the + // way it arrives back, as any terminal does, so readline can + // redraw the line and nothing is ever shown twice. + script, "-q", "-f", "-e", + "-c", SHELL_COMMAND, + // No typescript file: the scrollback in the pane is the record. + "/dev/null"); + // A real terminal on a real tty, not the dumb one a pipe implies. The + // prompt stays bash's own — it is part of what the pane draws. And no + // LINES/COLUMNS in the environment: those make programs trust the + // numbers over the terminal they are on, and the numbers here must be + // the pty's own window, kept true by the resize machinery below. + builder.environment().put("TERM", "xterm-256color"); + return builder; + } + + private static ProcessBuilder plainBuilderFor(String shell, int rows, int cols) { + ProcessBuilder builder = new ProcessBuilder(shell, "--noediting"); + // A non-interactive bash reads no rc files at all, so BASH_ENV is the + // way to have this path source the same ~/.bashrc (expanded by bash + // itself, against the server process' HOME) that the pty path gets. + builder.environment().put("BASH_ENV", "~/.bashrc"); + // Without the pty, stdout and stderr are merged here instead. + builder.redirectErrorStream(true); + return configurePipeEnv(builder, rows, cols); + } + + /** The environment of the pipe fallback: a terminal it does not really have, sized only by env. */ + private static ProcessBuilder configurePipeEnv(ProcessBuilder builder, int rows, int cols) { + Map env = builder.environment(); + env.put("TERM", "xterm-256color"); + // There is no terminal to size on this path, so LINES/COLUMNS are the + // only way a program here can be told anything at all. + if (rows > 0 && cols > 0) { + env.put("LINES", String.valueOf(rows)); + env.put("COLUMNS", String.valueOf(cols)); + } + return builder; + } + + /** + * Writes what the pane typed straight to the pseudo-terminal: keystrokes, + * tabs, Ctrl-C's {@code \u0003}, an arrow key's escape sequence, an + * emulator's answer to a status query. Nothing is interpreted on the way — + * on the pty those bytes are edits and signals, not text, and the shell + * and its programs read them exactly as they would from a real terminal. + */ + public void submitInput(String bytes) { + if (!alive || stdin == null) return; + try { + stdin.write(bytes.getBytes(StandardCharsets.UTF_8)); + stdin.flush(); + } catch (IOException e) { + Codecraft.LOGGER.warn("Could not write to the shell of {}", player.getName().getString(), e); + } + } + + /** + * Resizes the pty's window to a new size of the pane, from the outside: + * nothing is written to the shell's input, so a full-screen program in + * the foreground is signalled mid-run — SIGWINCH, and it redraws — + * instead of waiting for a typed {@code stty} it would only read as + * keystrokes. The newest size wins while an older one is still being + * applied, so dragging a sash across the screen converges on where it + * was let go rather than queueing a resize per frame. + */ + public void resize(int rows, int cols) { + if (rows <= 0 || cols <= 0) return; + synchronized (resizeLock) { + if (!alive) return; + wantRows = rows; + wantCols = cols; + resizeLock.notifyAll(); + if (interactive) startResizeLoop(); + } + } + + /** Hands the pending sizes to a worker; the caller holds {@link #resizeLock}. */ + private void startResizeLoop() { + if (resizeLoopStarted) return; + resizeLoopStarted = true; + Thread.ofVirtual() + .name("codecraft-shell-resize-" + player.getName().getString()) + .start(this::applySizes); + } + + /** + * Waits for the pane to want a window of a different size and applies it, + * one wanted size at a time: whatever arrived meanwhile is simply the + * next thing asked for. + */ + private void applySizes() { + while (true) { + int rows, cols; + synchronized (resizeLock) { + while (alive && !sizeWantedLocked()) { + try { + resizeLock.wait(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return; + } + } + if (!alive) return; + rows = wantRows; + cols = wantCols; + } + + applyWindowSize(rows, cols); + synchronized (resizeLock) { + appliedRows = rows; + appliedCols = cols; + } + } + } + + /** Whether a real size is wanted and not applied yet; the caller holds {@link #resizeLock}. */ + private boolean sizeWantedLocked() { + return wantRows > 0 && wantCols > 0 && (wantRows != appliedRows || wantCols != appliedCols); + } + + /** + * Moves the pty's window to {@code rows} x {@code cols} by sizing its + * device — the same ioctl a real terminal emulator makes, and the kernel + * signals the terminal's foreground the way it signals any resize. + */ + private void applyWindowSize(int rows, int cols) { + String device = findPtsDevice(); + if (device != null && runSttyAt(device, rows, cols)) return; + + // No device to size from — no /proc to find it, no stty to size it, + // or it went away mid-session. Typed at the prompt is the only way + // left to tell a size at all: echoed, blind to whatever holds the + // screen, and the old behaviour, but better here than a window stuck + // at whatever it was. + Codecraft.LOGGER.warn("Could not size the pty of {}'s shell from its device; " + + "resizing falls back to typing at the prompt", player.getName().getString()); + ptsDevice = null; + submitInput("export LINES=" + rows + " COLUMNS=" + cols + + "; stty rows " + rows + " cols " + cols + "\r"); + } + + /** Sizes the terminal at {@code device} by handing it, as standard input, to {@code stty}. */ + private boolean runSttyAt(String device, int rows, int cols) { + for (String stty : STTY_COMMANDS) { + Process resized = null; + try { + resized = new ProcessBuilder(stty, "rows", String.valueOf(rows), "cols", String.valueOf(cols)) + .redirectInput(new File(device)) + .redirectOutput(Redirect.DISCARD) + .redirectError(Redirect.DISCARD) + .start(); + if (resized.waitFor(STTY_TIMEOUT_MS, TimeUnit.MILLISECONDS) && resized.exitValue() == 0) return true; + } catch (IOException e) { + // This stty is not here; the next one may be. + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return false; + } finally { + if (resized != null && resized.isAlive()) resized.destroyForcibly(); + } + } + return false; + } + + /** + * This session's pty device, searched for on first need and kept after. + * The shell appears under {@code script} a moment after the spawn, so the + * search retries quietly for a little while before giving up — from then + * on this session is known to have no findable device. + */ + private String findPtsDevice() { + synchronized (resizeLock) { + if (ptsDevice != null) return ptsDevice; + if (ptsSearchFailed) return null; + } + + long deadline = System.currentTimeMillis() + PTS_SEARCH_BUDGET_MS; + do { + try { + String device = searchPtsDevice(); + ptsDevice = device; + return device; + } catch (IOException e) { + try { + Thread.sleep(PTS_SEARCH_RETRY_MS); + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + return null; + } + } + } while (alive && System.currentTimeMillis() < deadline); + + synchronized (resizeLock) { + ptsSearchFailed = true; + } + Codecraft.LOGGER.warn("No /dev/pts under {}'s shell process tree; the pty window cannot be sized from here", + player.getName().getString()); + return null; + } + + /** + * Follows the process tree down from {@code script}: whoever runs under + * it has the pty on its standard input, and the {@code /proc} link there + * names the device. Throws when the tree holds nobody yet, which is how + * the search knows to look again in a moment. + */ + private String searchPtsDevice() throws IOException { + ArrayDeque queue = new ArrayDeque<>(); + queue.add(process.pid()); + for (int visited = 0; !queue.isEmpty() && visited < 64; visited++) { + for (long child : childrenOf(queue.poll())) { + String standardInput = fdTarget(child, 0); + if (standardInput != null && standardInput.startsWith("/dev/pts/")) return standardInput; + queue.add(child); + } + } + throw new IOException("no /dev/pts within pid " + process.pid() + "'s tree"); + } + + /** The pids {@code pid} spawned, as {@code /proc} reports them. */ + private static List childrenOf(long pid) { + List children = new ArrayList<>(); + try { + String line = Files.readString( + Path.of("/proc", Long.toString(pid), "task", Long.toString(pid), "children")); + for (String token : line.split(" ")) { + if (!token.isBlank()) children.add(Long.parseLong(token)); + } + } catch (IOException | NumberFormatException e) { + // No /proc to ask, or the process is gone already: nobody is under there. + } + return children; + } + + /** What fd {@code fd} of {@code pid} points at, or null when {@code /proc} will not say. */ + private static String fdTarget(long pid, int fd) { + try { + return Files.readSymbolicLink( + Path.of("/proc", Long.toString(pid), "fd", Integer.toString(fd))).toString(); + } catch (IOException | SecurityException e) { + return null; + } + } + + public boolean isAlive() { + return alive; + } + + /** Kills the shell; its output thread then ends by itself, quietly. */ + public void close() { + closing = true; + alive = false; + synchronized (resizeLock) { + resizeLock.notifyAll(); + } + if (process == null) return; + + process.destroy(); + try { + if (!process.waitFor(500, TimeUnit.MILLISECONDS)) process.destroyForcibly(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + process.destroyForcibly(); + } + } + + /** + * Reads the shell's merged output until it closes, forwarding every chunk. + * + *

Reading characters through a decoder rather than raw bytes is what + * keeps a multibyte character that arrives split over two reads intact. + * Nothing else is done to the stream: the pane interprets it character by + * character — escape sequences and chunk boundaries rarely agree with each + * other, and the emulator is built knowing that.

+ */ + private void pumpOutput() { + char[] buffer = new char[CHUNK_SIZE]; + + try (Reader output = new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8)) { + int read; + while ((read = output.read(buffer)) > 0) { + send(new ClientboundShellOutputPayload(new String(buffer, 0, read))); + } + } catch (IOException e) { + if (!closing) { + Codecraft.LOGGER.warn("Shell output for {} broke: {}", player.getName().getString(), e.toString()); + } + } finally { + alive = false; + synchronized (resizeLock) { + resizeLock.notifyAll(); + } + ShellManager.sessionEnded(this); + if (!closing) { + int code = exitCode(); + send(new ClientboundShellClosedPayload( + code >= 0 ? "shell exited (code " + code + ")" : "shell stopped")); + } + } + } + + private int exitCode() { + try { + return process.exitValue(); + } catch (IllegalStateException e) { + return -1; + } + } + + /** Sends one message to the player, surviving the moment they are leaving. */ + private void send(CustomPacketPayload payload) { + try { + ServerPlayNetworking.send(player, payload); + } catch (RuntimeException e) { + // The connection is gone; there is nobody left to print this to. + } + } +} diff --git a/src/main/resources/data/codecraft/docs/lua-api.json b/src/main/resources/data/codecraft/docs/lua-api.json new file mode 100644 index 0000000..51c69bf --- /dev/null +++ b/src/main/resources/data/codecraft/docs/lua-api.json @@ -0,0 +1,322 @@ +{ + "topics": [ + { + "title": "world", + "blurb": "Read and write blocks in the running player's dimension.", + "functions": [ + { + "name": "world.set_block", + "signature": "world.set_block(x, y, z, block)", + "summary": "Places a block and updates neighbours and clients, like /setblock does.", + "params": [ + { + "name": "x", + "type": "number", + "optional": false, + "description": "Absolute world x coordinate (F3 to read your own)." + }, + { + "name": "y", + "type": "number", + "optional": false, + "description": "Absolute world y coordinate." + }, + { + "name": "z", + "type": "number", + "optional": false, + "description": "Absolute world z coordinate." + }, + { + "name": "block", + "type": "string", + "optional": false, + "description": "Block id, with or without the minecraft: namespace, optionally with block states." + } + ], + "returns": "true on success, or false followed by a reason string.", + "notes": [ + "Coordinates are absolute, never relative to the player.", + "A block that cannot survive where it is put (a torch without a wall, a flower without ground) drops itself again and the call reports failure.", + "Replacing a block that holds items, such as a chest, drops its contents." + ], + "examples": [ + { + "title": "Namespace is optional; states are allowed", + "code": "world.set_block(10, 64, -3, \"minecraft:stone\")\nworld.set_block(10, 65, -3, \"gold_block\")\nworld.set_block(10, 66, -3, \"minecraft:oak_stairs[facing=north]\")" + }, + { + "title": "Check whether it worked", + "code": "local ok, reason = world.set_block(10, 64, -3, \"minecraft:stone\")\nif not ok then\n print(\"could not place the block: \" .. reason)\nend" + } + ] + }, + { + "name": "world.remove_block", + "signature": "world.remove_block(x, y, z [, drops])", + "summary": "Removes the block at the given position.", + "params": [ + { + "name": "x", + "type": "number", + "optional": false, + "description": "Absolute world x coordinate." + }, + { + "name": "y", + "type": "number", + "optional": false, + "description": "Absolute world y coordinate." + }, + { + "name": "z", + "type": "number", + "optional": false, + "description": "Absolute world z coordinate." + }, + { + "name": "drops", + "type": "boolean", + "optional": true, + "description": "Pass true to break the block the way a player would (items, sound, particles)." + } + ], + "returns": "true on success, or false followed by a reason string.", + "notes": [ + "Without drops the block just vanishes, silently and without items.", + "Fails with \"there is nothing to remove\" if the target is already air." + ], + "examples": [ + { + "title": "Vanish versus break", + "code": "world.remove_block(10, 64, -3) -- vanish\nworld.remove_block(10, 65, -3, true) -- break it, dropping items" + } + ] + }, + { + "name": "world.get_block", + "signature": "world.get_block(x, y, z)", + "summary": "Returns the block id at that position, including its block states.", + "params": [ + { + "name": "x", + "type": "number", + "optional": false, + "description": "Absolute world x coordinate." + }, + { + "name": "y", + "type": "number", + "optional": false, + "description": "Absolute world y coordinate." + }, + { + "name": "z", + "type": "number", + "optional": false, + "description": "Absolute world z coordinate." + } + ], + "returns": "The block id string (ready to hand to set_block), or nil followed by a reason string.", + "notes": [ + "Air is the string \"minecraft:air\", and every string is truthy in Lua — compare against the id rather than testing the value.", + "The result carries block states, e.g. minecraft:grass_block[snowy=false]." + ], + "examples": [ + { + "title": "Compare against the id, not the value", + "code": "local block = world.get_block(10, 64, -3)\nif block ~= \"minecraft:air\" then\n print(\"something is there: \" .. block)\nend" + }, + { + "title": "Copy one place to another", + "code": "local block = world.get_block(10, 64, -3)\nif block then\n world.set_block(20, 70, 5, block)\nend" + } + ] + } + ] + }, + { + "title": "events", + "blurb": "Run a function when something happens in the game. Listeners keep firing after the script has finished running, and reset when the script runs again.", + "functions": [ + { + "name": "events.on_use_item", + "signature": "events.on_use_item(callback)", + "summary": "Calls callback whenever a player right-clicks to use the item in their hand.", + "params": [ + { + "name": "callback", + "type": "function", + "optional": false, + "description": "Lua function to call every time the event happens." + } + ], + "returns": "true once the listener is registered, or false followed by a reason string.", + "notes": [ + "The callback is given the player name, the item id, the stack size and the hand: \"main\" or \"off\".", + "It fires alongside the game, never instead of it: the click still does whatever it would have done.", + "An empty hand does not fire the event.", + "The listener stays active after the script has finished running, until the script is run again, which resets all listeners." + ], + "examples": [ + { + "title": "Notice stick waves", + "code": "events.on_use_item(function(player, item, count, hand)\n if item == \"minecraft:stick\" then\n print(player .. \" waved a stick (\" .. hand .. \" hand)\")\n end\nend)" + } + ] + }, + { + "name": "events.on_break_block", + "signature": "events.on_break_block(callback)", + "summary": "Calls callback after a player has broken a block.", + "params": [ + { + "name": "callback", + "type": "function", + "optional": false, + "description": "Lua function to call every time the event happens." + } + ], + "returns": "true once the listener is registered, or false followed by a reason string.", + "notes": [ + "The callback is given the player name, the x, y and z coordinates of the broken block and its block id.", + "It fires after the block is already gone — the coordinates now hold air.", + "The listener stays active after the script has finished running, until the script is run again, which resets all listeners." + ], + "examples": [ + { + "title": "Count broken ore", + "code": "broken = 0\nevents.on_break_block(function(player, x, y, z, block)\n if block == \"minecraft:diamond_ore\" then\n broken = broken + 1\n print(player .. \" broke a diamond ore (\" .. broken .. \" total)\")\n end\nend)" + } + ] + }, + { + "name": "events.on_chat", + "signature": "events.on_chat(callback)", + "summary": "Calls callback when a player sends a chat message.", + "params": [ + { + "name": "callback", + "type": "function", + "optional": false, + "description": "Lua function to call every time the event happens." + } + ], + "returns": "true once the listener is registered, or false followed by a reason string.", + "notes": [ + "The callback is given the player name and the plain text of the message.", + "The message is still sent to chat as usual — the callback only observes it.", + "The listener stays active after the script has finished running, until the script is run again, which resets all listeners." + ], + "examples": [ + { + "title": "Reply to a keyword", + "code": "events.on_chat(function(player, message)\n if message == \"help\" then\n print(player .. \" asked for help\")\n end\nend)" + } + ] + }, + { + "name": "events.on_player_join", + "signature": "events.on_player_join(callback)", + "summary": "Calls callback when a player finishes joining the game.", + "params": [ + { + "name": "callback", + "type": "function", + "optional": false, + "description": "Lua function to call every time the event happens." + } + ], + "returns": "true once the listener is registered, or false followed by a reason string.", + "notes": [ + "The callback is given the name of the player who just joined, including the running player themselves.", + "The listener stays active after the script has finished running, until the script is run again, which resets all listeners." + ], + "examples": [ + { + "title": "Welcome everyone", + "code": "events.on_player_join(function(player)\n print(\"welcome, \" .. player .. \"!\")\nend)" + } + ] + }, + { + "name": "events.on_player_leave", + "signature": "events.on_player_leave(callback)", + "summary": "Calls callback when a player leaves the game.", + "params": [ + { + "name": "callback", + "type": "function", + "optional": false, + "description": "Lua function to call every time the event happens." + } + ], + "returns": "true once the listener is registered, or false followed by a reason string.", + "notes": [ + "The callback is given the name of the player who left.", + "When the running player themselves disconnects, their script stops with them, so a script cannot outlive its owner.", + "The listener stays active after the script has finished running, until the script is run again, which resets all listeners." + ], + "examples": [ + { + "title": "Track who is online", + "code": "events.on_player_leave(function(player)\n print(player .. \" left the game\")\nend)" + } + ] + }, + { + "name": "events.on_tick", + "signature": "events.on_tick(callback)", + "summary": "Calls callback once per server tick, at the end of each tick.", + "params": [ + { + "name": "callback", + "type": "function", + "optional": false, + "description": "Lua function to call every time the event happens." + } + ], + "returns": "true once the listener is registered, or false followed by a reason string.", + "notes": [ + "The callback is given the tick counter, a whole number that increases by one every tick (20 ticks per second).", + "Keep tick callbacks cheap: they run twenty times a second, and a slow one lags the whole server.", + "The listener stays active after the script has finished running, until the script is run again, which resets all listeners." + ], + "examples": [ + { + "title": "Do something every five seconds", + "code": "events.on_tick(function(tick)\n if tick % 100 == 0 then\n print(\"still running at tick \" .. tick)\n end\nend)" + } + ] + } + ] + }, + { + "title": "print", + "blurb": "Send text to the chat of the player running the script.", + "functions": [ + { + "name": "print", + "signature": "print(...)", + "summary": "Writes to the chat of the player who ran the script, tab-separated.", + "params": [], + "returns": "nothing", + "notes": [ + "Whole numbers go through the Lua wrapper and are printed as 12.0; concatenate them into a string to drop the decimal.", + "Runs on the server, so output appears in the running player's chat." + ], + "examples": [ + { + "title": "Print to chat", + "code": "print(\"blocks placed:\", 12)" + }, + { + "title": "Drop the trailing .0", + "code": "print(\"blocks placed: \" .. 12) -- -> blocks placed: 12" + } + ] + } + ] + } + ] +}