Integrate typed peripheral package

build.gradle.kts

@@ -18,7 +18,9 @@ subprojectShaking {
 val setupSubproject = subprojectShaking::setupSubproject
 
 subprojects {
-    setupSubproject(this)
+    if (name != "typed-peripheral-turtlematic") {
+        setupSubproject(this)
+    }
 }
 
 githubShaking {

projects/typed-peripheral-turtlematic/.gitignore

@@ -0,0 +1,3 @@
+*.lua
+*.d.ts
+node_modules

projects/typed-peripheral-turtlematic/automata/end.ts

@@ -0,0 +1,25 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+import { FuelApi } from "@siredvin/typed-peripheral-api/fuel";
+import { InteractionApi } from "@siredvin/typed-peripheral-api/interaction";
+import { ConfigurationAPI } from "@siredvin/typed-peripheral-api/configuration";
+import { OperationApi } from "@siredvin/typed-peripheral-api/operations";
+import { LookApi } from "@siredvin/typed-peripheral-api/look";
+import { CaptureAPI } from "@siredvin/typed-peripheral-api/capture";
+import { SuckAPI } from "@siredvin/typed-peripheral-api/suck";
+import { WarpAPI } from "@siredvin/typed-peripheral-api/warp";
+
+/** @noSelf **/
+export declare interface EndAutomata
+    extends FuelApi,
+        InteractionApi,
+        ConfigurationAPI<object>,
+        OperationApi,
+        LookApi,
+        CaptureAPI,
+        SuckAPI,
+        WarpAPI {}
+
+export const endAutomataProvider = new IPeripheralProvider<EndAutomata>(
+    "endAutomata",
+    () => null
+);

projects/typed-peripheral-turtlematic/automata/husbandry.ts

@@ -0,0 +1,28 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+import { FuelApi, FuelAPIConfiguration } from "@siredvin/typed-peripheral-api/fuel";
+import { InteractionApi } from "@siredvin/typed-peripheral-api/interaction";
+import { ConfigurationAPI } from "@siredvin/typed-peripheral-api/configuration";
+import { OperationApi } from "@siredvin/typed-peripheral-api/operations";
+import { LookApi } from "@siredvin/typed-peripheral-api/look";
+import { CaptureAPI } from "@siredvin/typed-peripheral-api/capture";
+
+export declare interface HusbandryConfiguration extends FuelAPIConfiguration {
+    maxHusbandryPoints: number;
+    simulationGrowCost: number;
+}
+
+/** @noSelf **/
+export declare interface HusbandryAutomata
+    extends FuelApi,
+        InteractionApi,
+        ConfigurationAPI<HusbandryConfiguration>,
+        OperationApi,
+        LookApi,
+        CaptureAPI {
+    harvest(direction?: "up" | "down"): Result;
+    getHusbandryPoints(): number;
+    simulateGrow(): Result;
+}
+
+export const husbandryAutomataProvider =
+    new IPeripheralProvider<HusbandryAutomata>("husbandryAutomata", () => null);

projects/typed-peripheral-turtlematic/automata/mason.ts

@@ -0,0 +1,19 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+import { DummyFuelApi, FuelApi } from "@siredvin/typed-peripheral-api/fuel";
+
+/** @noSelf **/
+export declare interface MasonAutomata extends FuelApi {
+    chisel(mode: "block", target: string, direction?: Direction): Result;
+}
+
+/** @noSelf **/
+class DummyMasonAutomata extends DummyFuelApi implements MasonAutomata {
+    chisel(mode: "block", target: string, direction?: Direction): Result {
+        return $multi(true, null);
+    }
+}
+
+export const masonProvider = new IPeripheralProvider<MasonAutomata>(
+    "masonAutomata",
+    () => new DummyMasonAutomata()
+);

projects/typed-peripheral-turtlematic/automata/protective.ts

@@ -0,0 +1,23 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+import { DummyFuelApi, FuelApi } from "@siredvin/typed-peripheral-api/fuel";
+import { InteractionApi } from "@siredvin/typed-peripheral-api/interaction";
+import { ConfigurationAPI } from "@siredvin/typed-peripheral-api/configuration";
+import { CaptureAPI } from "@siredvin/typed-peripheral-api/capture";
+import { OperationApi } from "@siredvin/typed-peripheral-api/operations";
+import { LookApi } from "@siredvin/typed-peripheral-api/look";
+import { SuckAPI } from "@siredvin/typed-peripheral-api/suck";
+
+/** @noSelf **/
+export declare interface ProtectiveAutomata
+    extends FuelApi,
+        InteractionApi,
+        ConfigurationAPI<object>,
+        CaptureAPI,
+        OperationApi,
+        LookApi,
+        SuckAPI {}
+
+export const protectiveProvider = new IPeripheralProvider<ProtectiveAutomata>(
+    "protectiveAutomata",
+    () => null
+);

projects/typed-peripheral-turtlematic/automata/regular.ts

@@ -0,0 +1,17 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+import { FuelApi } from "@siredvin/typed-peripheral-api/fuel";
+import { InteractionApi } from "@siredvin/typed-peripheral-api/interaction";
+import { ConfigurationAPI } from "@siredvin/typed-peripheral-api/configuration";
+import { OperationApi } from "@siredvin/typed-peripheral-api/operations";
+
+/** @noSelf **/
+export declare interface Automata
+    extends FuelApi,
+        InteractionApi,
+        ConfigurationAPI<object>,
+        OperationApi {}
+
+export const automataProvider = new IPeripheralProvider<Automata>(
+    "automata",
+    () => null
+);

projects/typed-peripheral-turtlematic/automata/smithing.ts

@@ -0,0 +1,22 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+import { DummyFuelApi, FuelApi } from "@siredvin/typed-peripheral-api/fuel";
+
+/** @noSelf **/
+export declare interface SmithingAutomata extends FuelApi {
+    smelt(mode: "block", direction?: Direction): Result;
+    smelt(mode: "inventory", limit: number): Result;
+}
+
+/** @noSelf **/
+class DummySmithingAutomata extends DummyFuelApi implements SmithingAutomata {
+    smelt(mode: "block", direction?: Direction): Result;
+    smelt(mode: "inventory", limit: number): Result;
+    smelt(mode: unknown, limit?: unknown): Result {
+        return $multi(true, null);
+    }
+}
+
+export const smithingProvider = new IPeripheralProvider<SmithingAutomata>(
+    "smithingAutomata",
+    () => new DummySmithingAutomata()
+);

projects/typed-peripheral-turtlematic/build.gradle.kts

@@ -0,0 +1,40 @@
+import com.github.gradle.node.npm.task.NpmTask
+
+plugins {
+    base
+    id("com.github.node-gradle.node") version "7.1.0"
+}
+
+node {
+    version.set("22.14.0")
+    download.set(true)
+    nodeProjectDir.set(projectDir)
+    workDir.set(rootProject.layout.projectDirectory.dir(".gradle/nodejs"))
+    npmWorkDir.set(rootProject.layout.projectDirectory.dir(".gradle/npm"))
+    npmInstallCommand.set("ci")
+}
+
+val typeScriptSources = fileTree(projectDir) {
+    include("**/*.ts")
+    exclude("node_modules/**")
+}
+
+val compileTypeScript by tasks.registering(NpmTask::class) {
+    dependsOn(tasks.npmInstall)
+    npmCommand.set(listOf("run", "build"))
+    inputs.files("package.json", "package-lock.json", "tsconfig.json", typeScriptSources)
+    outputs.files(typeScriptSources.files.flatMap { source ->
+        val output = source.relativeTo(projectDir).invariantSeparatorsPath.removeSuffix(".ts")
+        listOf(file("$output.d.ts"), file("$output.lua"))
+    } + file("lualib_bundle.lua"))
+}
+
+tasks.assemble {
+    dependsOn(compileTypeScript)
+}
+
+tasks.clean {
+    delete(fileTree(projectDir) {
+        include("**/*.d.ts", "**/*.lua")
+    })
+}

projects/typed-peripheral-turtlematic/mics/chatter.ts

@@ -0,0 +1,29 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+
+let DUMMY_MESSAGE: string | null = null;
+
+/** @noSelf **/
+export interface Chatter extends IPeripheral {
+    getMessage(): string | null;
+    setMessage(text: string): void;
+    clearMessage(): void;
+}
+
+/** @noSelf **/
+export class DummyChatter implements Chatter {
+    getMessage(): string | null {
+        return DUMMY_MESSAGE;
+    }
+    setMessage(text: string): void {
+        DUMMY_MESSAGE = text;
+        print("Setting message to chatter", DUMMY_MESSAGE);
+    }
+    clearMessage(): void {
+        DUMMY_MESSAGE = null;
+    }
+}
+
+export const chatterProvider = new IPeripheralProvider<Chatter>(
+    "chatter",
+    () => new DummyChatter()
+);

projects/typed-peripheral-turtlematic/mics/lava_bucket.ts

@@ -0,0 +1,16 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+
+/** @noSelf **/
+export interface LavaBucket extends IPeripheral {
+    void(): void;
+}
+
+/** @noSelf **/
+export class DummyLavaBucket implements LavaBucket {
+    void(): void {}
+}
+
+export const lavaBucketProvider = new IPeripheralProvider<LavaBucket>(
+    "lava_bucket",
+    () => new DummyLavaBucket()
+);

projects/typed-peripheral-turtlematic/mics/mimic.ts

@@ -0,0 +1,12 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+
+/** @noSelf **/
+export interface Mimic extends IPeripheral {
+    reset();
+    setTransformation(rlm: string);
+    getTransformation(): string;
+    setMimic(block: LuaTable, nbtData?: string);
+    getMimic(): LuaMultiReturn<[LuaTable | null, string | null]>;
+}
+
+export const mimicProvider = new IPeripheralProvider<Mimic>("mimic");

projects/typed-peripheral-turtlematic/mics/piston.ts

@@ -0,0 +1,28 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+
+let IS_SILENT_GLOBAL = false;
+
+/** @noSelf **/
+export interface Piston extends IPeripheral {
+    push(direction?: Direction): Result;
+    isSilent(): boolean;
+    setSilent(value: boolean): void;
+}
+
+/** @noSelf **/
+export class DummyPiston implements Piston {
+    isSilent(): boolean {
+        return IS_SILENT_GLOBAL;
+    }
+    setSilent(value: boolean): void {
+        IS_SILENT_GLOBAL = value;
+    }
+    push(direction?: Direction): Result {
+        return $multi(true, null);
+    }
+}
+
+export const pistonProvider = new IPeripheralProvider<Piston>(
+    "piston",
+    () => new DummyPiston()
+);

projects/typed-peripheral-turtlematic/mics/sticky_piston.ts

@@ -0,0 +1,32 @@
+import { IPeripheralProvider } from "@siredvin/typed-peripheral-base";
+
+let IS_SILENT_GLOBAL = false;
+
+/** @noSelf **/
+export interface StickyPiston extends IPeripheral {
+    pull(direction?: Direction): Result;
+    push(direction?: Direction): Result;
+    isSilent(): boolean;
+    setSilent(value: boolean): void;
+}
+
+/** @noSelf **/
+export class DummyStickyPiston implements StickyPiston {
+    isSilent(): boolean {
+        return IS_SILENT_GLOBAL;
+    }
+    setSilent(value: boolean): void {
+        IS_SILENT_GLOBAL = value;
+    }
+    push(direction?: Direction): Result {
+        return $multi(true, null);
+    }
+    pull(direction?: Direction): Result {
+        return $multi(true, null);
+    }
+}
+
+export const stickyPistonProvider = new IPeripheralProvider<StickyPiston>(
+    "stickyPiston",
+    () => new DummyStickyPiston()
+);