feat: 🚧 Peripherals

Author: ChristophLHR

.gitignore

@@ -1,3 +1,4 @@
 /config
 /.vscode
-/computer
+/computer
+/suits

generalFunctions.lua

@@ -30,8 +30,7 @@
 ---@field select fun(self: inventory, slot: integer): boolean
 ---@field list fun(): item[]
 ---@field __index any
-
-local deepCopy = require("../generalFunctions").deepCopy
+---@field deepCopy fun(table: table): table
 
 ---# inventory
 ---Inventory system emulated
@@ -108,7 +107,7 @@ local function pickUpItem(inventory, item, slot)
             local toTransfer = math.min(space, item.count)
 
             local currentCount = getItemCount(inventory, fittingSlot)
-            inventory[fittingSlot] = deepCopy(item)
+            inventory[fittingSlot] = inventory.deepCopy(item)
             if (inventory[fittingSlot] == nil) then
                 inventory[fittingSlot].maxcount = item.maxcount or inventory.defaultMaxSlotSize
             end
@@ -138,12 +137,15 @@ end
 
 --- ### Description:
 ---creates an Instance of of the Inventory class
----@param inventorySize any
-function inventory:createInventory(inventorySize) 
+---@param inventorySize number | nil
+---@param deepCopy fun(table: table): table
+---@return inventory
+function inventory:createInventory(inventorySize, deepCopy) 
     local i = {
         inventorySize = inventorySize or 27,
         selectedSlot = 1,
         defaultMaxSlotSize = 64,
+        deepCopy = deepCopy
     }
     setmetatable(i, self)
     self.__index = self
@@ -224,7 +226,7 @@ function inventory:transferTo(slot, count)
         if currentSlot == nil then
             return true
         end
-        self[slot] = deepCopy(self[self.selectedSlot])
+        self[slot] = self.deepCopy(self[self.selectedSlot])
         self[slot].count =  math.min(self[slot] and self[slot].maxcount or 0 , count)
         local transferTo = math.min(currentSlot.count, count)
         currentSlot.count = currentSlot.count - transferTo

inventory.lua

@@ -0,0 +1,119 @@
+---@alias filterFunc fun(name: string, wrapped: table):boolean
+
+---@alias relativePosition
+--- | "front"
+--- | "back"
+--- | "top"
+--- | "bottom"
+--- | "left"
+--- | "right"
+
+---@class peripheral
+---@field turtle TurtleMock
+---@field linkToTurtle fun(peripheral: peripheral, turtle: TurtleMock):peripheral
+---@field find fun(peripheral: peripheral, typeName: string, filterFunc: filterFunc | nil):table | nil
+---@field getMethods fun(peripheral: peripheral, name: any):string[] | nil
+---@field getNames fun(peripheral: peripheral):string[]
+---@field isPresent fun(peripheral: peripheral, positionOrname: any):boolean
+---@field __index peripheral
+
+---@param turtle TurtleMock
+---@return position[]
+local function getPositions(turtle)
+
+    return pos
+end
+
+---@type peripheral
+---@diagnostic disable-next-line: missing-fields
+local peripheral = {}
+---create a new instance of a peripheral and link it to a turtle
+---@param turtle TurtleMock
+---@return peripheral
+function peripheral:linkToTurtle(turtle)
+    local mt = {
+        turtle = turtle,
+    }
+    local proxy = {}
+    mt.__index = function (_, key)
+        local value = peripheral[key]
+        if type(value) == "function" then
+            return function(...)
+                local mightBeSelf = select(1, ...)
+                if mightBeSelf == peripheral then
+                    return value(...)
+                elseif mightBeSelf == proxy then
+                ---@diagnostic disable-next-line: missing-parameter
+                    return value(peripheral, select(2, ...))
+                end
+                return value(peripheral, ...)
+            end
+        end
+        return value
+    end
+    mt.__newindex = function (_, key, value)
+        peripheral[key] = value
+    end
+    
+    setmetatable(proxy, mt)
+    return proxy
+    
+end
+
+---@param self peripheral
+---@param typeName string
+---@param filterFunc filterFunc | nil
+---@return table
+function peripheral:find(typeName, filterFunc)
+    assert(self.turtle, "Peripheral is not linked to a turtle")
+    local positions = getPositions(self.turtle.position)
+    local peripheral
+    for _, position in pairs(positions) do
+        local block = self.turtle.emulator:getBlock(position)
+        if block and block.peripheralName and block.peripheralName == typeName then
+            peripheral = self.turtle.emulator:playPeripheralProxy(block)
+            if peripheral and ((not filterFunc) or filterFunc(block.item.name, peripheral)) then
+                return peripheral
+            end
+        end
+    end
+end
+
+---returns all the functions of a peripheral with the given name
+---@param name any
+---@return string[] | nil
+function peripheral:getMethods(name)
+    local p = self:find(name)
+    if not p then return nil end
+    local methods = {}
+    for k, v in pairs(p) do
+        if type(v) == "function" then
+            table.insert(methods, k)
+        end
+    end
+    return methods
+end
+
+---@return string[]
+function peripheral:getNames()
+    local names = {}
+    local positions = getPositions(self.turtle.position)
+    for _, position in pairs(positions) do
+        local block = self.turtle.emulator:getBlock(position)
+        if block and block.peripheralName then
+            if block.peripheralActions then
+                table.insert(names, block.item.name)
+            end
+        end
+    end
+    return names
+end
+
+--- Checks if a peripheral is present at the given position or with a given name
+---@param positionOrname any
+---@return boolean
+function peripheral:isPresent(positionOrname)
+
+end
+
+return peripheral

peripheral.lua

@@ -29,13 +29,34 @@
 ---@field equal function
 assert = assert
 
--- functions provided by busted, only available in the global scope
-describe = describe
-it = it
-setup = setup
-before_each = before_each
+-- installs the other suits
+if not pcall(function () io.open("./suits/vector/vector.lua", "r"):close() end) then
+    print("Downloading TestSuite-lib")
+    local http = require("socket.http")
+    local url = "https://raw.githubusercontent.com/mc-cc-scripts/TestSuite-lib/master/installSuit.lua" -- URL of the installer
+    local body, statusCode = http.request(url)
+    if statusCode == 200 then
+        local loader
+        if _VERSION == "Lua 5.1" then 
+            loader = loadstring
+        else
+            loader = load
+        end
+        local installScript = loader(body)().install()
+    else
+        error("Failed to download TestSuite-lib: " .. tostring(statusCode))
+    end
+end
+
+-- load the other suits
+local vector = require("./suits/vector/vector")
+local deepCopy = require("./suits/helperFunctions/helperFunctions").deepCopy
+
+print(deepCopy({a = 1, b = 2, c = 3}))
 
 local turtleEmulator = require("../turtleEmulator")
+turtleEmulator:init(vector, deepCopy)
+local peripheral = require("../peripheral")
 describe("Disabled Movement", function()
     local turtle
     setup(function()
@@ -742,29 +763,72 @@ describe("Place", function()
         assert.are.equal("minecraft:water", block.item.name)
     end)
 end)
-describe("Chest", function()
+describe("peripherals", function()
     local turtle
-    describe("Create Chests", function ()
-        it("Create Chests", function ()
-            turtleEmulator:clearBlocks()
-            turtleEmulator:clearTurtles()
-            turtleEmulator:createBlock({ item = {name = "minecraft:chest"}, position = { x = 1, y = 0, z = 0 } })
-            local block = turtleEmulator:getBlock({ x = 1, y = 0, z = 0 })
-            turtleEmulator:addInventoryToBlock(block.position)
-            block.inventory:addItemToInventory({ name = "minecraft:stone", count = 64, maxcount = 64 })
-            
-            block.inventory:select(2)
-            
-            turtleEmulator:createBlock({ item = {name = "minecraft:chest"}, position = { x = 2, y = 0, z = 0 } })
-            local block2 = turtleEmulator:getBlock({ x = 2, y = 0, z = 0 })
-            turtleEmulator:addInventoryToBlock(block2.position)
-            block2.inventory:select(2)
-            assert.is_true(block2.inventory:addItemToInventory({ name = "minecraft:stone", count = 64, maxcount = 64 }, 2))
-            assert.are.equal(64, block.inventory:getItemCount(1))
-            assert.are.equal(0, block.inventory:getItemCount(2))
-            assert.are.equal(0, block2.inventory:getItemCount(1))
-            assert.are.equal(64, block2.inventory:getItemCount()) -- slot 2
-            assert.are.equal(64, block2.inventory:getItemCount(2))
-        end)
+    before_each(function()
+        turtleEmulator:clearBlocks()
+        turtleEmulator:clearTurtles()
+        turtle = turtleEmulator:createTurtle()
+    end)
+    it("Create Chests", function ()
+        turtleEmulator:clearBlocks()
+        turtleEmulator:clearTurtles()
+        local block = turtleEmulator:createBlock({ item = {name = "minecraft:chest"}, position = { x = 1, y = 0, z = 0 } })
+        local chest = turtleEmulator:addInventoryToBlock(block.position)
+        chest:addItemToInventory({ name = "minecraft:stone", count = 64, maxcount = 64 })
+        
+        chest:select(2)
+        
+        local block2 = turtleEmulator:createBlock({ item = {name = "minecraft:chest"}, position = { x = 2, y = 0, z = 0 } })
+        local chest2 = turtleEmulator:addInventoryToBlock({ x = 2, y = 0, z = 0 })
+        chest2:select(2)
+        assert.is_true(chest2:addItemToInventory({ name = "minecraft:stone", count = 64, maxcount = 64 }, 2))
+        assert.are.equal(64, chest:getItemCount(1))
+        assert.are.equal(0, chest:getItemCount(2))
+        assert.are.equal(0, chest2.getItemCount(1))
+        assert.are.equal(64, chest2.getItemCount()) -- slot 2
+        assert.are.equal(64, chest2.getItemCount(2))
+        -- check the ORIGINAL block in the emulator
+        -- since the return is just a proxy
+        assert.are.equal(64, block2.peripheralActions[2].count)
+    end)
+    it("isPresent", function()
+        turtle.position = { x = 5, y = 0, z = 5 }
+        local p = peripheral.linkToTurtle(turtle)
+
+        local block = turtleEmulator:createBlock({ item = {name = "minecraft:chest"}, position = { x = 5, y = 0, z = 6 } })
+        turtleEmulator:addInventoryToBlock(block.position)
+        assert.is_true(p.isPresent("right"))
+        assert.is_false(p.isPresent("front"))
+        assert.is_false(p.isPresent("left"))
+        assert.is_false(p.isPresent("back"))
+        assert.is_false(p.isPresent("up"))
+        assert.is_false(p.isPresent("down"))
+        local block2 = turtleEmulator:createBlock({ item = {name = "minecraft:chest"}, position = { x = 6, y = 0, z = 5 } })
+        turtleEmulator:addInventoryToBlock(block2.position)
+        assert.is_true(p.isPresent("front"))
+        assert.is_true(p.isPresent("right"))
+        assert.is_false(p.isPresent("left"))
+        assert.is_false(p.isPresent("back"))
+        turtle.turnRight()
+        assert.is_true(p.isPresent("right"))
+        assert.is_true(p.isPresent("back"))
+        assert.is_false(p.isPresent("left"))
+        assert.is_false(p.isPresent("front"))
+        turtle.turnRight()
+        assert.is_true(p.isPresent("back"))
+        assert.is_true(p.isPresent("left"))
+        assert.is_false(p.isPresent("front"))
+        assert.is_false(p.isPresent("right"))
+        turtle.turnRight()
+        assert.is_true(p.isPresent("left"))
+        assert.is_true(p.isPresent("front"))
+        assert.is_false(p.isPresent("right"))
+        assert.is_false(p.isPresent("back"))
+        turtle.turnRight()
+        assert.is_true(p.isPresent("front"))
+        assert.is_true(p.isPresent("right"))
+        assert.is_false(p.isPresent("left"))
+        assert.is_false(p.isPresent("back"))
     end)
 end)