diff options
Diffstat (limited to 'src/host/Console.zig')
| -rw-r--r-- | src/host/Console.zig | 260 |
1 files changed, 260 insertions, 0 deletions
diff --git a/src/host/Console.zig b/src/host/Console.zig new file mode 100644 index 0000000..d9aa469 --- /dev/null +++ b/src/host/Console.zig @@ -0,0 +1,260 @@ +//! The developer console: a line editor, a short log, and the host commands +//! (snapshots, recordings, replay, field inspection). Lines the host does not +//! know go to the sketch's `command`. +const Console = @This(); +const std = @import("std"); +const abi = @import("abi"); +const Host = @import("Host.zig"); +const fields = @import("fields.zig"); +const memory = @import("memory.zig"); +const timeline = @import("timeline.zig"); + +pub const panel_height = 144; +pub const Key = enum { left, right, home, end, backspace, delete, clear, tab, submit }; +const Line = struct { bytes: [118]u8 = @splat(0), len: usize = 0 }; + +const host_commands = [_][]const u8{ + "help", "overlay memory", "overlay sound", "get", "set", "reset", "save", "load", "snapshot", "recording", + "record", "stop", "play", "pause", "step", "seek start", "seek end", "diff", "quit", "exit", +}; + +visible: bool = false, +buffer: [96]u8 = @splat(0), +len: usize = 0, +cursor: usize = 0, +lines: [5]Line = @splat(.{}), +snapshot: usize = 1, +recording: usize = 0, +overlay_memory: bool = false, +overlay_sound: bool = false, + +pub fn text(self: *const Console) []const u8 { + return self.buffer[0..self.len]; +} + +pub fn insert(self: *Console, typed: []const u8) void { + for (typed) |byte| { + // Commands and the built-in font only need printable ASCII. + if (byte < 32 or byte > 126 or byte == '`' or self.len == self.buffer.len) continue; + std.mem.copyBackwards(u8, self.buffer[self.cursor + 1 .. self.len + 1], self.buffer[self.cursor..self.len]); + self.buffer[self.cursor] = byte; + self.cursor += 1; + self.len += 1; + } +} + +/// Edits the line; `submit` returns it (valid until the next edit). +pub fn edit(self: *Console, key: Key, extra: []const []const u8) ?[]const u8 { + switch (key) { + .left => self.cursor -|= 1, + .right => self.cursor = @min(self.len, self.cursor + 1), + .home => self.cursor = 0, + .end => self.cursor = self.len, + .clear => { + self.len = 0; + self.cursor = 0; + }, + .backspace => if (self.cursor > 0) { + self.cursor -= 1; + self.erase(); + }, + .delete => self.erase(), + .tab => self.complete(extra), + .submit => { + const line = self.text(); + // The bytes stay put until the next edit; only the length resets. + self.len = 0; + self.cursor = 0; + if (std.mem.trim(u8, line, " ").len == 0) return null; + self.print("> {s}", .{line}); + return line; + }, + } + return null; +} + +fn erase(self: *Console) void { + if (self.cursor == self.len) return; + std.mem.copyForwards(u8, self.buffer[self.cursor .. self.len - 1], self.buffer[self.cursor + 1 .. self.len]); + self.len -= 1; +} + +fn complete(self: *Console, extra: []const []const u8) void { + var first: ?[]const u8 = null; + var common: usize = 0; + var matches: [256]u8 = undefined; + var used: usize = 0; + var count: usize = 0; + for ([_][]const []const u8{ &host_commands, extra }) |list| for (list) |candidate| { + if (!std.mem.startsWith(u8, candidate, self.text())) continue; + if (first) |previous| { + var i: usize = 0; + while (i < common and i < candidate.len and previous[i] == candidate[i]) : (i += 1) {} + common = i; + } else { + first = candidate; + common = candidate.len; + } + const match = std.fmt.bufPrint(matches[used..], "{s} ", .{candidate}) catch continue; + used += match.len; + count += 1; + }; + if (first) |candidate| { + self.cursor = self.len; + self.insert(candidate[self.len..common]); + if (count > 1) self.log(matches[0..used]); + } else self.log("No completion. Type help for commands."); +} + +pub fn log(self: *Console, message: []const u8) void { + var rest = message; + while (true) { + std.mem.copyForwards(Line, self.lines[0..4], self.lines[1..5]); + const line = &self.lines[4]; + line.len = @min(rest.len, line.bytes.len); + @memcpy(line.bytes[0..line.len], rest[0..line.len]); + rest = rest[line.len..]; + if (rest.len == 0) break; + } +} + +pub fn print(self: *Console, comptime fmt: []const u8, args: anytype) void { + var buf: [512]u8 = undefined; + self.log(std.fmt.bufPrint(&buf, fmt, args) catch "(message too long)"); +} + +/// Runs one line. Host commands first; anything else goes to the sketch. +/// Returns events to replay after a seek, already restored to the snapshot. +pub fn execute(self: *Console, host: *Host, line: []const u8, now: u64) ![]const abi.Event { + const h = &host.timeline; + var words = std.mem.tokenizeAny(u8, line, " \t"); + const command = words.next() orelse return &.{}; + const arg = words.next(); + const rest = words.rest(); + + if (eq(command, "help")) { + self.log("save|load [1..7] snapshot N | record|play [0..15] recording N | stop | pause | step N | seek start|end|<ms>"); + self.log("diff [N] | reset | get <field> | set <field> <value> | overlay memory|sound | quit"); + if (!host.forward(self, line, now)) self.log("Backtick hides the console. Tab completes."); + return &.{}; + } + if (eq(command, "overlay")) { + const name = arg orelse return error.ExpectedOverlay; + const flag = if (eq(name, "memory")) &self.overlay_memory else if (eq(name, "sound")) &self.overlay_sound else return error.UnknownOverlay; + flag.* = !flag.*; + self.print("{s} overlay: {s}", .{ name, if (flag.*) "on" else "off" }); + } else if (eq(command, "get")) { + const path = arg orelse return error.ExpectedField; + const leaf = host.state.layout.find(path) orelse return error.UnknownField; + var buf: [160]u8 = undefined; + var w: std.Io.Writer = .fixed(&buf); + fields.format(leaf, host.live(), &w) catch {}; + self.print("{s} = {s}", .{ path, w.buffered() }); + } else if (eq(command, "set")) { + const path = arg orelse return error.ExpectedField; + const leaf = host.state.layout.find(path) orelse return error.UnknownField; + if (rest.len == 0) return error.ExpectedValue; + h.stop(now); + try fields.set(leaf, host.live(), std.mem.trim(u8, rest, " ")); + self.print("{s} = {s}", .{ path, std.mem.trim(u8, rest, " ") }); + } else if (eq(command, "quit") or eq(command, "exit")) { + h.stop(now); + host.quit = true; + } else if (eq(command, "reset")) { + h.stop(now); + host.resetState(); + self.log("Live state reset. Snapshots are kept."); + } else if (eq(command, "snapshot")) { + self.snapshot = try slot(arg orelse return error.ExpectedSlot, 1, memory.slot_count - 1); + } else if (eq(command, "recording")) { + self.recording = try slot(arg orelse return error.ExpectedSlot, 0, timeline.recording_count - 1); + } else if (eq(command, "save") or eq(command, "load")) { + const index = if (arg) |a| try slot(a, 1, memory.slot_count - 1) else self.snapshot; + if (eq(command, "load") and !h.bank.hasSnapshot(index)) return error.EmptySnapshot; + h.stop(now); + if (eq(command, "save")) { + h.bank.save(index); + self.print("Saved snapshot {d}. Recordings from its old contents are invalidated.", .{index}); + } else { + try h.bank.restore(index); + self.print("Loaded snapshot {d}.", .{index}); + } + } else if (eq(command, "record") or eq(command, "play")) { + const index = if (arg) |a| try slot(a, 0, timeline.recording_count - 1) else self.recording; + if (eq(command, "play")) _ = try h.bank.get(index); + h.stop(now); + if (eq(command, "record")) try h.startRecording(index, self.snapshot, now) else try h.play(index, now); + self.recording = index; + self.print("{s} recording {d} from snapshot {d}.", .{ if (eq(command, "record")) "Started" else "Playing", index, h.bank.recording(index).snapshot }); + } else if (eq(command, "stop")) { + h.stop(now); + } else if (eq(command, "pause")) { + if (h.mode != .playing and h.mode != .paused) return error.NotReplaying; + h.pause(now); + } else if (eq(command, "step") or eq(command, "seek")) { + const value = arg orelse return error.ExpectedPosition; + _ = try h.bank.get(if (h.mode == .live or h.mode == .recording) self.recording else h.selected); + if (h.mode == .recording) h.stop(now); + if (h.mode == .live) try h.play(self.recording, now); + const r = try h.bank.get(h.selected); + if (eq(command, "step")) return h.step(std.fmt.parseInt(i64, value, 10) catch return error.InvalidPosition); + if (eq(value, "start")) return h.seekCount(0); + if (eq(value, "end")) return h.seekCount(r.count); + const ms = std.fmt.parseInt(u64, value, 10) catch return error.InvalidPosition; + return h.seekTime(ms *| std.time.ns_per_ms); + } else if (eq(command, "diff")) { + const index = if (arg) |a| try slot(a, 1, memory.slot_count - 1) else self.snapshot; + if (!h.bank.hasSnapshot(index)) return error.EmptySnapshot; + const diff = h.bank.compare(0, index); + self.print("Live vs snapshot {d}: {d} differing bytes; first={any}, last={any}", .{ index, diff.count, diff.first, diff.last }); + } else { + // Sketch commands edit state outside the recorded input. + h.stop(now); + if (!host.forward(self, line, now)) return error.UnknownCommand; + } + return &.{}; +} + +pub fn draw(self: *const Console, host: *Host, out: *std.ArrayList(abi.Command), arena: std.mem.Allocator) !void { + const ink: abi.Color = .{ .r = 230, .g = 255, .b = 230 }; + const hint: abi.Color = .{ .r = 145, .g = 220, .b = 150 }; + const top = @as(f32, @floatFromInt(host.canvas[1])) - panel_height; + const width: f32 = @floatFromInt(host.canvas[0]); + const h = &host.timeline; + try out.append(arena, .{ .rect = .{ .dst = .{ .x = 0, .y = top, .w = width, .h = panel_height }, .color = .{ .r = 24, .g = 28, .b = 28 } } }); + const status = try std.fmt.allocPrint(arena, "{s} | {t} | snapshot {d} | recording {d} (active {d}) | event {d} | {d}ms", .{ + host.name, h.mode, self.snapshot, self.recording, h.selected, h.cursor, h.position / std.time.ns_per_ms, + }); + try out.append(arena, .{ .text = .{ .x = 12, .y = top + 8, .scale = 1, .color = hint, .bytes = status } }); + for (&self.lines, 0..) |*line, i| { + try out.append(arena, .{ .text = .{ .x = 12, .y = top + 28 + @as(f32, @floatFromInt(i)) * 18, .scale = 1, .color = ink, .bytes = line.bytes[0..line.len] } }); + } + try out.append(arena, .{ .text = .{ .x = 12, .y = top + 122, .scale = 1, .color = ink, .bytes = try std.fmt.allocPrint(arena, "> {s}", .{self.text()}) } }); + try out.append(arena, .{ .rect = .{ .dst = .{ .x = @floatFromInt(28 + self.cursor * 8), .y = top + 120, .w = 1, .h = 12 }, .color = hint } }); +} + +fn eq(a: []const u8, b: []const u8) bool { + return std.mem.eql(u8, a, b); +} + +fn slot(value: []const u8, min: usize, max: usize) !usize { + const index = std.fmt.parseInt(usize, value, 10) catch return error.InvalidSlot; + if (index < min or index > max) return error.InvalidSlot; + return index; +} + +test "line editing, completion and submission" { + var c: Console = .{}; + c.insert("scen"); + _ = c.edit(.tab, &.{ "scene room", "scene gallery" }); + try std.testing.expectEqualStrings("scene ", c.text()); + c.insert("`room"); + try std.testing.expectEqualStrings("scene room", c.text()); + _ = c.edit(.home, &.{}); + _ = c.edit(.delete, &.{}); + try std.testing.expectEqualStrings("cene room", c.text()); + const line = c.edit(.submit, &.{}).?; + try std.testing.expectEqualStrings("cene room", line); + try std.testing.expectEqualStrings("", c.text()); + try std.testing.expect(c.edit(.submit, &.{}) == null); +} |
