Plethora

https://plethora.madefor.cc/
Admin
Plethora is a Minecraft mod that allows ComputerCraft computers to interact with tile entities and...
Tokens:35,788
Snippets:239
Trust Score:5.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Documentation for a Peripheral in Lua

Source: https://plethora.madefor.cc/getting-started

Demonstrates how to retrieve documentation for a wrapped peripheral using the `getDocs()` method. This can be called without arguments to list all methods or with a method name to get specific documentation.

```Lua
chest.getDocs()

-- Example output:
-- {
--   getMetadata = "function():table -- Get metadata about this object.",
--   list = "function():table -- List all items in this inventory",
--   getItem = "function(slot:integer):table|nil -- The item in the specified slot. The slot number starts from 1.",
--   ...
-- }
```

```Lua
chest.getDocs("getMetadata")
```

--------------------------------

### Get Metadata of a Specific Item in Lua

Source: https://plethora.madefor.cc/getting-started

Shows how to get metadata for a specific item obtained from a chest slot using `item.getMetadata()`. This can reveal details like enchantments, max damage, and item count.

```Lua
item.getMetadata()

-- Example output:
-- {
--   maxDamage = 1561,
--   toolClass = {
--     pickaxe = 3,
--   },
--   maxCount = 1,
--   displayName = "Diamond Pickaxe",
--   count = 1,
--   name = "minecraft:diamond_pickaxe",
--   rawName = "item.pickaxeDiamond",
--   material = "DIAMOND",
--   damage = 0,
-- }
```

--------------------------------

### Setup Minimap Canvas

Source: https://plethora.madefor.cc/examples/ore-scanner

Retrieves the canvas from the neural interface, clears it, and then initializes a 2D array of text elements to represent the minimap grid. It also adds a marker for the player's current location.

```lua
local canvas = modules.canvas()
canvas.clear()

local block_text = {}
local blocks = {}
for x = -scannerRange, scannerRange, 1 do
	block_text[x] = {}
	blocks[x] = {}

	for z = -scannerRange, scannerRange, 1 do
		block_text[x][z] = canvas.addText({ 0, 0 }, " ", 0xFFFFFFFF, size)
		blocks[x][z] = { y = nil, block = nil }
	end
end

canvas.addText({ offsetX, offsetY }, "^", 0xFFFFFFFF, size * 2)
```

--------------------------------

### Wrap a Chest Peripheral in Lua

Source: https://plethora.madefor.cc/getting-started

This snippet shows how to wrap a chest peripheral in ComputerCraft using Plethora's `peripheral.wrap()` function. It requires specifying the side the chest is on and prints the wrapped object.

```Lua
chest = peripheral.wrap("<side>") -- Specify the side the chest is on.
print(chest)
```

--------------------------------

### Get a Specific Item from a Chest Slot in Lua

Source: https://plethora.madefor.cc/getting-started

This snippet demonstrates how to get a specific item from a chest using the `getItem(slot)` method, passing the slot number obtained from `chest.list()`. The returned object represents the item in that slot.

```Lua
item = chest.getItem(slot)
print(item)
```

--------------------------------

### Get Metadata of a Chest Peripheral in Lua

Source: https://plethora.madefor.cc/getting-started

This code snippet retrieves metadata for a wrapped chest peripheral using the `getMetadata()` method. The returned metadata includes information like the object's state and name.

```Lua
chest.getMetadata()

-- Example output:
-- {
--   state = {
--     facing = "east",
--   },
--   unlocalizedName = "tile.chest",
--   name = "minecraft:chest",
--   metadata = 5,
--   displayName = "Chest",
-- }
```

--------------------------------

### List Items in a Chest Peripheral in Lua

Source: https://plethora.madefor.cc/getting-started

This Lua code uses the `list()` method on a wrapped chest peripheral to retrieve a table containing all items within the chest, including their names, counts, and damage values.

```Lua
chest.list()

-- Example output:
-- {
--   {
--     name   = "minecraft:cobblestone",
--     count  = 64,
--     damage = 0,
--   },
--   {
--     name   = "minecraft:log",
--     count  = 16,
--     damage = 0,
--   },
--   [19] = {
--     name   = "minecraft:diamond_pickaxe",
--     count  = 1,
--     damage = 0,
--   },
-- }
```

--------------------------------

### Drop an Item from a Chest Slot in Lua

Source: https://plethora.madefor.cc/getting-started

This code uses the `drop()` method on an item object to remove it from its slot and drop it in the game world. It takes the count of items to drop and an optional direction.

```Lua
item.drop(1, "up")
```

--------------------------------

### Item Handling: Get Item

Source: https://plethora.madefor.cc/methods

Retrieves information about the item in a specific inventory slot. The slot numbering starts from 1. Returns a table representing the item or nil if the slot is empty.

```Java
public static Any getItem(net.minecraftforge.items.IItemHandler itemHandler, int slot)

```

--------------------------------

### Initialize Neural Interface and Modules

Source: https://plethora.madefor.cc/examples/ore-scanner

Checks for the presence of a neural interface and required modules (block scanner and overlay glasses). If any are missing, it throws an error.

```lua
local modules = peripheral.find("neuralInterface")
if not modules then error("Must have a neural interface", 0) end
if not modules.hasModule("plethora:scanner") then error("The block scanner is missing", 0) end
if not modules.hasModule("plethora:glasses") then error("The overlay glasses are missing", 0) end
```

--------------------------------

### List Available Modules (Lua)

Source: https://plethora.madefor.cc/modules

Lists all modules currently installed and available on the manipulator. It returns a table containing the names of the modules.

```Lua
manip.listModules()
```

--------------------------------

### Item Handling: Get Item Metadata

Source: https://plethora.madefor.cc/methods

Retrieves the metadata of the item in a specific inventory slot. The slot numbering starts from 1. Returns a table representing the item's metadata or nil if the slot is empty.

```Java
public static Any getItemMeta(net.minecraftforge.items.IItemHandler itemHandler, int slot)

```

--------------------------------

### Configure Scanner and Renderer

Source: https://plethora.madefor.cc/examples/ore-scanner

Sets up configuration variables for scanning and rendering intervals, scanner range, and minimap appearance. These values control the frequency of updates and the visual properties of the minimap.

```lua
local scanInterval = 0.2
local renderInterval = 0.05
local scannerRange = 8
local scannerWidth = scannerRange * 2 + 1

local size = 0.5
local cellSize = 16
local offsetX = 75
local offsetY = 75
```

--------------------------------

### Get Entity Metadata by ID with Plethora

Source: https://plethora.madefor.cc/items/module-sensor

This example shows how to retrieve detailed metadata for a specific entity using its UUID. It first uses `.sense()` to get entity IDs and then calls `.getMetaByID()` to fetch the metadata. It includes a check to ensure metadata was successfully retrieved.

```lua
local entities = sensor.sense()
if #entities > 0 then
  local meta = sensor.getMetaByID(entities[1].id)
  if meta then print(textutils.serialise(meta)) end
end

```

--------------------------------

### Documentation: Get Documentation

Source: https://plethora.madefor.cc/methods

Retrieves documentation for all available functions or a specific function by name. If the function name is provided and not found, an error will be raised. Returns documentation as a string or a table.

```Java
public static Any getDocs(org.squiddev.plethora.api.method.IMethodCollection methodCollection, @Nullable String name)

```

--------------------------------

### Get Computer Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata for a ComputerCraft computer, including its family, ID, and label. This is useful for identifying and managing computers in the game.

```Lua
{
  computer = {
    family = "Normal",
    id = 3,
    label = "My computer"
  }
}
```

--------------------------------

### Get Block Reference Metadata

Source: https://plethora.madefor.cc/methods

Provides metadata about blocks in the world, including their color, colour value, and hardness. This is available when a daylight sensor module is attached.

```Lua
{
  color = 9923917,
  colour = 9923917,
  hardness = 0.5
}
```

--------------------------------

### Define Ores and Colors

Source: https://plethora.madefor.cc/examples/ore-scanner

Defines a table of ores to scan for, assigning a priority to each. It also defines a color mapping for each ore type to be displayed on the minimap. Higher priority ores will be prioritized in the display.

```lua
local ores = {
	["minecraft:diamond_ore"] = 10,
	["minecraft:emerald_ore"] = 10,
	["minecraft:gold_ore"] = 8,
	["minecraft:redstone_ore"] = 5,
	["minecraft:lapis_ore"] = 5,
	["minecraft:iron_ore"] = 2,
	["minecraft:coal_ore"] = 1
}

local colours = {
	["minecraft:coal_ore"] = { 150, 150, 150 },
	["minecraft:iron_ore"] = { 255, 150, 50 },
	["minecraft:lava"] = { 150, 75, 0 },
	["minecraft:gold_ore"] = { 255, 255, 0 },
	["minecraft:diamond_ore"] = { 0, 255, 255 },
	["minecraft:redstone_ore"] = { 255, 0, 0 },
	["minecraft:lapis_ore"] = { 0, 50, 255 },
	["minecraft:emerald_ore"] = { 0, 255, 0 }
}
```

--------------------------------

### Get Player Inventory and Item Meta

Source: https://plethora.madefor.cc/items/module-introspection

This snippet demonstrates how to wrap the introspection module and retrieve the player's inventory. It then shows how to get the metadata for an item in a specific slot and print its display name.

```lua
local introspection = peripheral.wrap(--[[ whatever ]])

local inv = introspection.getInventory()
local item = inv.getItemMeta(1)
if item then
	print(item.displayName .. " at slot #1")
end
```

--------------------------------

### Get Block Display Name (Lua)

Source: https://plethora.madefor.cc/methods

Provides the display name, registry name, and translation key for a given Minecraft block.

```Lua
{
  displayName = "Dirt",
  name = "minecraft:dirt",
  translationKey = "tile.dirt"
}
```

--------------------------------

### Get Pocket Computer Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata for a ComputerCraft pocket computer, including its color and equipped peripherals (back). This is useful for identifying and managing pocket computers.

```Lua
{
  pocket = {
    back = {
      adjective = "upgrade.computercraft:speaker.adjective",
      id = "computercraft:speaker"
    },
    color = 16711680,
    colour = 16711680
  }
}
```

--------------------------------

### Reload Plethora Configuration

Source: https://plethora.madefor.cc/configuring

Reload the `plethora-core.cfg` configuration file without restarting the server using the `/plethora reload` command. Note that blacklist options require a server restart to take full effect.

```bash
/plethora reload
```

--------------------------------

### Get Entity Basic Information (Lua)

Source: https://plethora.madefor.cc/methods

Retrieves fundamental information about an entity, including its display name, UUID, position, and orientation.

```Lua
{
  displayName = "Experience Orb",
  id = "8a28378f-9b8f-4d5c-80e1-7544a01d7847",
  motionX = 0.5,
  motionY = 0,
  motionZ = 0,
  name = "XPOrb",
  pitch = 73,
  withinBlock = {
    x = 0,
    y = 0.2125,
    z = 0
  },
  x = 11.5,
  y = -0.2875,
  yaw = 30,
  z = -0.5
}
```

--------------------------------

### minecraft:daylight_detector - Get Weather

Source: https://plethora.madefor.cc/methods

Returns the current weather conditions in the world. This method is part of the minecraft:daylight_detector module.

```Java
// Placeholder for getWeather method implementation
// public Weather getWeather();
```

--------------------------------

### Get FluidHandler Tanks Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata for all tanks managed by a FluidHandler. This includes details for each tank, such as amount, capacity, and fluid type.

```Lua
{
  tanks = {
    {
      amount = 525,
      capacity = 1000,
      displayName = "Water",
      id = "minecraft:water",
      name = "water",
      rawName = "fluid.tile.water"
    }
  }
}
```

--------------------------------

### Get Player Movement and Food Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata related to a player's movement speed and food status, including whether they can fly, their current flying state, and hunger/saturation levels.

```Lua
{
  allowFlying = false,
  flySpeed = 0.05,
  food = {
    hunger = 20,
    hungry = false,
    saturation = 5
  },
  isFlying = false,
  walkSpeed = 0.1
}
```

--------------------------------

### Get Banner Patterns Metadata

Source: https://plethora.madefor.cc/methods

Provides metadata for banner patterns, including their color and identifier. This allows for the programmatic inspection of banner designs.

```Lua
{
  banner = {
    {
      color = "purple",
      colour = "purple",
      id = "cre",
      name = "creeper"
    }
  }
}
```

--------------------------------

### Get Manipulator Documentation (Lua)

Source: https://plethora.madefor.cc/modules

Retrieves documentation for the modules attached to the manipulator. This function returns a table containing information about available methods, including their names, types, and descriptions.

```Lua
manip.getDocs()
```

--------------------------------

### Create Line - Plethora API

Source: https://plethora.madefor.cc/methods

Creates a new line with specified start and end points, optionally including thickness and color. This function is part of the MethodsCanvas3D class.

```Java
org.squiddev.plethora.gameplay.modules.glasses.methods.MethodsCanvas3D#addLine(Group3D)
```

--------------------------------

### Get FluidTankProperties Capacity Metadata

Source: https://plethora.madefor.cc/methods

Provides the capacity of a fluid tank, specifically from the IFluidTankProperties interface. This metadata indicates the maximum fluid storage.

```Lua
{
  capacity = 1000
}
```

--------------------------------

### Get Spawner Entities Metadata

Source: https://plethora.madefor.cc/methods

Retrieves the metadata for entities that a spawner will spawn. This includes details like display name, health, and position.

```Lua
{
  spawnedEntities = {
    {
      armor = {
        boots = nil,
        chestplate = nil,
        helmet = nil,
        leggings = nil
      },
      displayName = "Squid",
      health = 10,
      heldItem = nil,
      id = "779c2d0f-8c3f-4709-9ecb-f562d51c5c9e",
      isAirborne = false,
      isAlive = true,
      isBurning = false,
      isChild = false,
      isDead = false,
      isElytraFlying = false,
      isInWater = false,
      isOnLadder = false,
      isRiding = false,
      isSleeping = false,
      isSneaking = false,
      isSprinting = false,
      isWet = false,
      maxHealth = 10,
      motionX = 0,
      motionY = 0,
      motionZ = 0,
      name = "Squid",
      offhandItem = nil,
      pitch = 0,
      potionEffects = {},
      withinBlock = {
        x = 0.5,
        y = 0.9,
        z = 0.5
      },
      x = 0,
      y = 0.4,
      yaw = 0,
      z = 0
    }
  }
}
```

--------------------------------

### Configure Plethora: Base Method Costs

Source: https://plethora.madefor.cc/configuring

Set the energy cost for individual methods to regulate their usage frequency. This section lists all registered methods, allowing you to assign a custom cost to each, overriding the default of 0.

```properties
<method_name> <cost_value>
```

--------------------------------

### Render Minimap

Source: https://plethora.madefor.cc/examples/ore-scanner

Continuously renders the minimap by updating the text elements on the canvas based on the scanned block data. It accounts for player rotation to orient the map correctly and updates the text and color of each minimap cell.

```lua
local function render() 
	while true do
		local meta = modules.getMetaOwner and modules.getMetaOwner()
		local angle = meta and math.rad(-meta.yaw % 360) or math.rad(180)

		for x = -scannerRange, scannerRange do
			for z = -scannerRange, scannerRange do
				local text = block_text[x][z]
				local block = blocks[x][z]

				if block.block then
					local px = math.cos(angle) * -x - math.sin(angle) * -z
					-- Further rendering logic would go here to update text and color
				end
			end
		end

		sleep(renderInterval)
	end
end
```

--------------------------------

### Get Media Item Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata for media items, such as disks, including their label and record title. This is relevant for ComputerCraft's media and music functionalities.

```Lua
{
  media = {
    label = "My disk",
    recordTitle = nil
  }
}
```

--------------------------------

### Get Tanks (Capability Provider)

Source: https://plethora.madefor.cc/methods

Retrieves a list of all tanks associated with a capability provider. This method is relevant for `ICapabilityProvider` and is used to access fluid storage.

```Java
public List<ITank> getTanks();
```

--------------------------------

### Get Block State Information (Lua)

Source: https://plethora.madefor.cc/methods

Provides basic information about a block's state, including harvest level, harvest tool, material properties, and variant.

```Lua
{
  harvestLevel = 0,
  harvestTool = "pickaxe",
  material = {
    blocksLight = true,
    blocksMovement = true,
    burns = false,
    liquid = false,
    opaque = true,
    replaceable = false,
    requiresTool = true,
    solid = true
  },
  metadata = 0,
  state = {
    variant = "stone"
  }
}
```

--------------------------------

### Get Turtle Metadata

Source: https://plethora.madefor.cc/methods

Provides metadata for a ComputerCraft turtle, including its color, fuel level, and equipped peripherals (left and right). This allows for detailed inspection of a turtle's state and capabilities.

```Lua
{
  turtle = {
    color = 65280,
    colour = 65280,
    fuel = 3000,
    left = {
      adjective = "upgrade.computercraft:advanced_modem.adjective",
      id = "computercraft:advanced_modem",
      type = "Peripheral"
    },
    right = nil
  }
}
```

--------------------------------

### Get Forge Energy Storage Metadata

Source: https://plethora.madefor.cc/methods

Provides information about the energy stored and the capacity of a Forge Energy cell. This is useful for managing power in integrated systems.

```Lua
{
  energy = {
    capacity = 50000,
    stored = 1000
  }
}
```

--------------------------------

### Get FluidTank Capacity Metadata

Source: https://plethora.madefor.cc/methods

Provides the capacity of a fluid tank. This is a simple metadata entry indicating the maximum amount of fluid the tank can hold.

```Lua
{
  capacity = 1000
}
```

--------------------------------

### Get Sign Text (Sign)

Source: https://plethora.madefor.cc/methods

Retrieves all lines of text present on a sign. This function targets `TileEntitySign` and is part of the vanilla tile entity integrations.

```Java
public table getSignText();
```

--------------------------------

### Lua: Basic Chat Message Event Handling

Source: https://plethora.madefor.cc/items/module-chat

This is a fundamental example of how to use `os.pullEvent` to capture 'chat_message' events. It extracts the player name and message, and prints a confirmation if the message contains 'hello'.

```lua
while true do
	local _, player, message, uuid = os.pullEvent("chat_message")
	if message:find("[Hh]ello") then
		print(player .. "said hello!")
	end
end
```

--------------------------------

### Get Sign Text Metadata

Source: https://plethora.madefor.cc/methods

Retrieves the text content displayed on a sign tile entity. This provides access to the lines of text written on the sign.

```Lua
{
  lines = {
    "This is",
    "my rather fancy",
    "sign.",
    ""
  }
}
```

--------------------------------

### Lua: Capture and Execute Chat Commands

Source: https://plethora.madefor.cc/items/module-chat

This snippet shows how to use the `.capture()` method to intercept messages starting with '!', and then execute them as shell commands. It listens for 'chat_capture' events and processes the captured messages.

```lua
local chat = peripheral.wrap(-- [[whatever ]])
chat.capture("^!") -- Capture any messages starting with "!"

while true do
	local _, message, pattern, player, uuid = os.pullEvent("chat_capture")
	if pattern == "^!" then
		-- Run the provided command in the shell. So "!ls" will execute "ls".
		shell.run(message:sub(2))
	end
end
```

--------------------------------

### Get Potion Item Effects Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata for potion items, including their effects, amplifier, duration, and color. This allows for detailed inspection of potion properties.

```Lua
{
  effects = {
    {
      amplifier = 0,
      color = 8171462,
      duration = 180,
      instant = false,
      name = "effect.moveSpeed"
    }
  },
  potion = "minecraft:swiftness",
  potionType = "normal"
}
```

--------------------------------

### Get FluidStack Metadata

Source: https://plethora.madefor.cc/methods

Retrieves metadata for a FluidStack, including its amount, display name, and internal ID. This allows for detailed inspection of fluid contents.

```Lua
{
  amount = 525,
  displayName = "Water",
  id = "minecraft:water",
  name = "water",
  rawName = "fluid.tile.water"
}
```

--------------------------------

### Basic Redstone Integrator Usage

Source: https://plethora.madefor.cc/items/redstone-integrator

Demonstrates the basic usage of the Plethora Redstone Integrator. It shows how to find the integrator peripheral and set a redstone output using cardinal directions.

```Lua
local integrator = peripheral.find("redstone_integrator")
integrator.setOutput("north", true)

```

--------------------------------

### Get Item Printout Metadata

Source: https://plethora.madefor.cc/methods

Provides metadata for an item that can be printed, including its title and the number of pages it contains. This is relevant for items used in ComputerCraft's printing functionality.

```Lua
{
  printout = {
    lines = {},
    pages = 0,
    title = "My page",
    type = "Single"
  }
}
```

--------------------------------

### Get Basic Item Metadata

Source: https://plethora.madefor.cc/methods

Retrieves fundamental metadata for an item, such as its count, damage, display name, and maximum stack size. This is a general-purpose metadata for most items.

```Lua
{
  count = 5,
  damage = 0,
  displayName = "Stick",
  maxCount = 64,
  maxDamage = 0,
  name = "minecraft:stick",
  nbtHash = nil,
  rawName = "item.stick"
}
```

--------------------------------

### Get Transfer Locations

Source: https://plethora.madefor.cc/item-transfer

Retrieves a list of available transfer locations for an inventory. This can include 'self', cardinal directions, side-specific locations, inventory slots, and network peripherals if CCTweaks is installed.

```Lua
chest.getTransferLocations()
```

```Lua
chest.getTransferLocations("up")
```

--------------------------------

### Get Block Light Level (Java)

Source: https://plethora.madefor.cc/methods

Retrieves the ambient light level from blocks surrounding a target. This method is part of the Daylight Sensor integration and requires the 'minecraft:daylight_detector' module.

```Java
getBlockLight():int
Class | org.squiddev.plethora.integration.vanilla.method.MethodsDaylightSensor#getBlockLight(IModuleContainer)
```

--------------------------------

### Configure Plethora: Cost System Settings

Source: https://plethora.madefor.cc/configuring

Adjust the cost system parameters to manage energy consumption for method calls. Options include initial energy, maximum limit, regeneration rate, and behavior for negative energy and awaiting regeneration.

```properties
cost.initial <value>
cost.limit <value>
cost.regen <value>
cost.allowNegative <true|false>
cost.awaitRegen <true|false>
```

--------------------------------

### Get Food Item Heal and Saturation Metadata

Source: https://plethora.madefor.cc/methods

Provides information on how much health and saturation a food item restores. This metadata is specific to edible items in the game.

```Lua
{
  heal = 5,
  saturation = 0.6
}
```

--------------------------------

### Get Armor Item Type and Color Metadata

Source: https://plethora.madefor.cc/methods

Provides the type (e.g., 'chest', 'helmet') and color of armor pieces. This metadata is specific to wearable armor items.

```Lua
{
  armorType = "chest",
  color = 16711680,
  colour = 16711680
}
```

--------------------------------

### Get Sky Light Level (Java)

Source: https://plethora.madefor.cc/methods

Retrieves the light level contributed by the sky (sun or moon). This method is associated with the Daylight Sensor module ('minecraft:daylight_detector').

```Java
getSkyLight():int
Class | org.squiddev.plethora.integration.vanilla.method.MethodsDaylightSensor#getSkyLight(IModuleContainer)
```

--------------------------------

### minecraft:daylight_detector - Get Block Light

Source: https://plethora.madefor.cc/methods

Gets the light level contributed by surrounding blocks. This method is part of the minecraft:daylight_detector module.

```Java
// Placeholder for getBlockLight method implementation
// public int getBlockLight();
```

--------------------------------

### Configure Plethora: Blacklist Providers

Source: https://plethora.madefor.cc/configuring

Blacklist Plethora providers using package prefixes, class names, or specific method names. This allows fine-grained control over which functionalities are available. Ensure package prefixes and class names end with a dot for correct matching.

```properties
blacklist.blacklistProviders <package_prefix.>
blacklist.blacklistProviders <class_name>
blacklist.blacklistProviders <class_name#method_name>
```

--------------------------------

### Get Object Color

Source: https://plethora.madefor.cc/methods

Retrieves the color of the object. This function returns the color as an integer representation.

```Lua
getColor():int
```

--------------------------------

### Get Text - Plethora API

Source: https://plethora.madefor.cc/methods

Retrieves the text content of a TextObject. This method is part of the TextObject class.

```Java
org.squiddev.plethora.gameplay.modules.glasses.objects.TextObject#getText(TextObject)
```

--------------------------------

### Fire Laser Programmatically (Lua)

Source: https://plethora.madefor.cc/items/module-laser

Demonstrates the basic usage of the Frickin' laser beam module by firing lasers with varying yaw angles and a fixed potency. It assumes a laser peripheral has been wrapped.

```lua
local laser = peripheral.wrap(--[[ whatever ]])

for yaw = 0, 360, 10 do
  laser.fire(yaw, 0, 2) -- Fire a laser on the horizontal with potency 2
end

```

--------------------------------

### Get Entity Name

Source: https://plethora.madefor.cc/methods

Retrieves the name of an entity. This function is part of the introspection module and targets an EntityIdentifier.

```Lua
getName(): string
```

--------------------------------

### List Available Modules

Source: https://plethora.madefor.cc/methods

Lists all modules that are currently available. This function returns a table containing the names of all accessible modules.

```Lua
listModules():table
```

--------------------------------

### Get Turtle Inventory

Source: https://plethora.madefor.cc/methods

Retrieves the inventory of a turtle. This function is part of the introspection module and targets an ITurtleAccess.

```Lua
getInventory(): table
```

--------------------------------

### Lua Block Rendering and Scanning Logic

Source: https://plethora.madefor.cc/examples/ore-scanner

This Lua code snippet handles the core logic for rendering and scanning blocks in the Plethora Madefor CC project. It calculates screen positions (sx, sy) based on world coordinates (px, py), updates text elements with block data (y-coordinate and color), and manages the display of empty text when no block is present. The code also includes a sleep function for controlling the render interval and utilizes parallel execution for rendering and scanning loops.

```Lua
local py = math.sin(angle) * -x + math.cos(angle) * -z

local sx = math.floor(px * size * cellSize)
local sy = math.floor(py * size * cellSize)
text.setPosition(offsetX + sx, offsetY + sy)

---
text.setText(tostring(block.y))
text.setColor(table.unpack(colours[block.block]))
else
---
text.setText(" ")
end
end
end

sleep(renderInterval)
end
end

---
parallel.waitForAll(render, scan)
```

--------------------------------

### Get Entity ID

Source: https://plethora.madefor.cc/methods

Retrieves the UUID of an entity. This function is part of the introspection module and targets an EntityIdentifier.

```Lua
getID(): string
```

--------------------------------

### Get Line Height - Plethora API

Source: https://plethora.madefor.cc/methods

Retrieves the line height of a TextObject. This method is part of the TextObject class.

```Java
org.squiddev.plethora.gameplay.modules.glasses.objects.TextObject#getLineHeight(TextObject)
```

--------------------------------

### Get Player Inventory

Source: https://plethora.madefor.cc/methods

Retrieves the inventory of a player. This function is part of the introspection module and targets a Player entity.

```Lua
getInventory(): table
```

--------------------------------

### Get Size of Rectangle

Source: https://plethora.madefor.cc/methods

Returns the width and height of a Rectangle object. Essential for understanding the dimensions of 2D rectangular shapes.

```Java
public double[] getSize()
```

--------------------------------

### Scan for Ores

Source: https://plethora.madefor.cc/examples/ore-scanner

Continuously scans the area around the player for ores. It iterates through nearby blocks, identifies the ore with the highest priority at each location, and updates a table with the found ore and its Y-coordinate. Includes a delay to reduce server load.

```lua
local function scan() 
	while true do
		local scanned_blocks = modules.scan()

		for x = -scannerRange, scannerRange do
			for z = -scannerRange, scannerRange do
				local best_score, best_block, best_y = -1
				for y = -scannerRange, scannerRange do
					local scanned = scanned_blocks[scannerWidth ^ 2 * (x + scannerRange) + scannerWidth * (y + scannerRange) + (z + scannerRange) + 1]

					if scanned then
						local new_score = ores[scanned.name]
						if new_score and new_score > best_score then
							best_block = scanned.name
							best_score = new_score
							best_y = y
						end
					end
			end

			blocks[x][z].block = best_block
			blocks[x][z].y = best_y
		end
	end

		sleep(scanInterval)
	end
end
```

--------------------------------

### Get Position of Positionable2D

Source: https://plethora.madefor.cc/methods

Retrieves the current position (x, y coordinates) of a Positionable2D object. This is fundamental for all positioned 2D elements.

```Java
public double[] getPosition()
```

--------------------------------

### Turtle Use Item

Source: https://plethora.madefor.cc/methods

Simulates a right-click action with an item held by a ComputerCraft turtle, optionally for a specified duration. Returns success status and action description. Targets `ITurtleAccess` and requires 'plethora:kinetic'.

```Java
public static Object[] use(IModuleContainer container, Integer duration)
```

--------------------------------

### Get Scale - Plethora API

Source: https://plethora.madefor.cc/methods

Retrieves the current scale factor for a Scalable object. This method is part of the Scalable class.

```Java
org.squiddev.plethora.gameplay.modules.glasses.objects.Scalable#getScale(Scalable)
```

--------------------------------

### Get Metadata (Object)

Source: https://plethora.madefor.cc/methods

Retrieves metadata associated with a generic Java object. This method targets `java.lang.Object` and is implemented in `org.squiddev.plethora.integration.MethodMeta`.

```Java
public table getMetadata();
```

--------------------------------

### Plethora Kinetic Augment Basic Usage

Source: https://plethora.madefor.cc/items/module-kinetic

Demonstrates the basic usage of the kinetic augment's `.launch()` function. This code continuously launches an entity upwards with a specified pitch and power, pausing briefly between launches.

```Lua
local kinetic = peripheral.wrap(--[[ whatever ]])

-- Continuously fire the player into the sky
while true do
	kinetic.launch(0, -90, 4)
	sleep(0.5)
end

```

--------------------------------

### Get Entity Equipment

Source: https://plethora.madefor.cc/methods

Retrieves the held item and armor of an entity. This function is part of the introspection module and targets an EntityIdentifier.

```Lua
getEquipment(): table
```

--------------------------------

### Get Ender Chest

Source: https://plethora.madefor.cc/methods

Retrieves the ender chest of a player. This function is part of the introspection module and targets a Player entity.

```Lua
getEnder(): table
```

--------------------------------

### Get 3D Canvas

Source: https://plethora.madefor.cc/methods

Retrieves the 3D canvas associated with the glasses module. This function targets an IModuleContainer and interacts with the CanvasServer.

```Lua
canvas3d(): table
```

--------------------------------

### Grouping and Animating Elements with Plethora Overlay Glasses

Source: https://plethora.madefor.cc/items/module-glasses

Illustrates grouping multiple elements (a rectangle and text) into a single group to move them together. The example clears the canvas, creates a group, adds a rectangle and text to it, and then animates the group's position to bounce around the screen, updating the time display concurrently.

```lua
local canvas = peripheral.wrap("back").canvas()
canvas.clear() -- Get rid of our previous clock

local group = canvas.addGroup({ 0, 0 })

-- Look, we add items to our group instead
group.addRectangle(0, 0, 240, 30, 0xFF000064)

local text = group.addText({ 5, 5 }, "")
text.setScale(3)

local x, y, dx, dy = 0, 0, 5, 5

-- Compute the dimensions we can move within
local width, height = canvas.getSize()
width = width - 240
height = height - 30

while true do
  -- Bounce the group around the canvas
  x = x + dx
  if x < 0 then x, dx = 0, -dx end
  if x > width then x, dx = width, -dx end

  y = y + dy
  if y < 0 then y, dy = 0, -dy end
  if y > height then y, dy = height, -dy end

  group.setPosition(x, y)

  -- And update the time
  text.setText("Time is " .. textutils.formatTime(os.time()))

  sleep(0.05)
end

```

--------------------------------

### Get 2D Canvas

Source: https://plethora.madefor.cc/methods

Retrieves the 2D canvas associated with the glasses module. This function targets an IModuleContainer and interacts with the CanvasServer.

```Lua
canvas(): table
```

--------------------------------

### Launch Entity with Plethora

Source: https://plethora.madefor.cc/neural-interface

The kinetic augment module's `.launch(yaw, pitch, power)` method allows for launching an entity through the air with specified directional and power parameters.

```Lua
neuralInterface.launch(yaw, pitch, power)
```

--------------------------------

### Module Management: List Modules

Source: https://plethora.madefor.cc/methods

Lists all available modules within the module container. Returns a table containing the names of all available modules.

```Java
public static Any listModules(org.squiddev.plethora.api.module.IModuleContainer moduleContainer)

```

--------------------------------

### Get Block Material Properties (Lua)

Source: https://plethora.madefor.cc/methods

Retrieves material properties of a Minecraft block, such as whether it blocks light, movement, or is replaceable.

```Lua
{
  blocksLight = true,
  blocksMovement = true,
  burns = false,
  liquid = false,
  opaque = true,
  replaceable = false,
  requiresTool = true,
  solid = true
}
```

--------------------------------

### Move Entity with Plethora

Source: https://plethora.madefor.cc/neural-interface

The kinetic augment module provides a `.walk(x, y, z)` method to direct an entity to path-find to a specific position, facilitating movement commands.

```Lua
neuralInterface.walk(x, y, z)
```

--------------------------------

### Get Turtle Status (Lua)

Source: https://plethora.madefor.cc/methods

Retrieves the current status of a ComputerCraft turtle, including its color, fuel level, and equipped items.

```Lua
{
  turtle = {
    color = 23,
    colour = 23,
    fuel = 100,
    left = nil,
    right = nil
  }
}
```

--------------------------------

### Get Point - Plethora API

Source: https://plethora.madefor.cc/methods

Retrieves the coordinates of a specific vertex (point) in a MultiPoint2D object. This method is part of the MultiPoint2D class.

```Java
org.squiddev.plethora.gameplay.modules.glasses.objects.object2d.MultiPoint2D#getPoint(MultiPoint2D)
```

--------------------------------

### Walk to Coordinate (Kinetic Module)

Source: https://plethora.madefor.cc/methods

Allows a kinetic module to move to a specified 3D coordinate (x, y, z). This function is part of the kinetic module and requires a target entity that implements IModuleContainer and a sub-target that is an EntityLiving.

```Lua
walk(x:number, y:number, z:number):boolean
```

--------------------------------

### Get Item and Damage

Source: https://plethora.madefor.cc/methods

Retrieves the item and its associated damage value for an object. This function returns both the item identifier and the damage value.

```Lua
getItem(): string, number
```

--------------------------------

### Get Meta Owner

Source: https://plethora.madefor.cc/methods

Retrieves the UUID of an entity, likely related to ownership or metadata. This function is part of the introspection and sensor modules.

```Lua
getMetaOwner(): table
```

--------------------------------

### Item Handling: List Items

Source: https://plethora.madefor.cc/methods

Lists all items currently present in the inventory. Returns a table where each entry represents an item in a slot.

```Java
public static Any list(net.minecraftforge.items.IItemHandler itemHandler)

```

--------------------------------

### minecraft:daylight_detector - Get Sky Light

Source: https://plethora.madefor.cc/methods

Retrieves the light level originating from the sun. This function is associated with the minecraft:daylight_detector module.

```Java
// Placeholder for getSkyLight method implementation
// public int getSkyLight();
```

--------------------------------

### Entity Use Item (LivingBase)

Source: https://plethora.madefor.cc/methods

Simulates a right-click action with an item held by an entity, optionally specifying the hand ('left' or 'right') and duration. Returns success status and action description. Targets `EntityLivingBase` and requires 'plethora:kinetic'.

```Java
public static Object[] use(IModuleContainer container, Integer duration, String hand)
```

--------------------------------

### minecraft:clock - Get Day

Source: https://plethora.madefor.cc/methods

Returns the current day in the world. This function belongs to the minecraft:clock module and requires an IModuleContainer.

```Java
public static int getDay(IModuleContainer __instance) {
    // Implementation details for getting the current day
    return 0; // Placeholder
}
```

--------------------------------

### Drawing a Rectangle with Plethora Overlay Glasses

Source: https://plethora.madefor.cc/items/module-glasses

Demonstrates how to get the canvas from the neural interface and draw a red rectangle using the addRectangle method. It highlights that the method returns an object for later modification and explains the RGBA color format.

```lua
-- Get hold of the canvas
local interface = peripheral.wrap("back")
local canvas = interface.canvas()
-- And add a rectangle
local rect = canvas.addRectangle(0, 0, 100, 100, 0xFF0000FF)

```

--------------------------------

### Sentry Tower Logic - Lua

Source: https://plethora.madefor.cc/examples/laser-sentry

The core logic for the sentry tower. It initializes peripherals, defines a firing function, filters mobs, and enters a loop to detect and engage hostile entities.

```lua
--- This program finds hostile mobs and fires lasers at them, acting like a sentry tower.

--- We check that a manipulator exists and wrap it.
local modules = peripheral.find("manipulator")
if not modules then
	error("Cannot find manipulator", 0)
end

--- We require an entity sensor to find mobs and a laser to shoot at them. We error if neither exists.
if not modules.hasModule("plethora:laser") then error("Cannot find laser", 0) end
if not modules.hasModule("plethora:sensor") then error("Cannot find entity sensor", 0) end

--- We define a function which fires a laser towards an entity. This is a very naive implementation as it does not
--- account for the entity moving between firing and impact. You could use the `motionX`, `motionY` and `motionZ` fields
--- if you wish to add such functionality.
local function fire(entity)
	local x, y, z = entity.x, entity.y, entity.z
	local pitch = -math.atan2(y, math.sqrt(x * x + z * z))
	local yaw = math.atan2(-x, z)

	modules.fire(math.deg(yaw), math.deg(pitch), 5)
	ssleep(0.2)
end

--- We build a lookup of mobs we wish to target, to avoid shooting non-hostile mobs.
local mobNames = { "Creeper", "Zombie", "Skeleton" }
local mobLookup = {}
for i = 1, #mobNames do
	mobLookup[mobNames[i]] = true
end

--- We now sense the vicinity and prepare to fire at them.
while true do
	local mobs = modules.sense()

	---
	local candidates = {}
	for i = 1, #mobs do
		local mob = mobs[i]
		if mobLookup[mob.name] then
			candidates[#candidates + 1] = mob
		end
	end

	---
	if #candidates > 0 then
		local mob = candidates[math.random(1, #candidates)]
		fire(mob)
	else
		sleep(1)
	end
end

```

--------------------------------

### Set Sign Text (Sign)

Source: https://plethora.madefor.cc/methods

Sets the lines of text on a sign. This method targets `TileEntitySign` and accepts a variable number of string arguments for the lines.

```Java
public void setSignText(String... lines);
```

--------------------------------

### Launch Entity

Source: https://plethora.madefor.cc/methods

Launches an entity in a specified direction defined by yaw and pitch, with a given power. This kinetic method targets entities implementing `IModuleContainer` and `Entity`, requiring the 'plethora:kinetic' module.

```Java
public static void launch(IModuleContainer container, double yaw, double pitch, double power)
```

--------------------------------

### Skeleton Specific Action with Plethora

Source: https://plethora.madefor.cc/neural-interface

Skeletons have a specific `.shoot()` method available through the neural interface, allowing them to fire projectiles.

```Lua
skeleton.shoot()
```

--------------------------------

### Turtle Swing Item

Source: https://plethora.madefor.cc/methods

Simulates a left-click action with an item held by a ComputerCraft turtle. Returns the action taken. This method targets `ITurtleAccess` and requires the 'plethora:kinetic' module.

```Java
public static Object[] swing(IModuleContainer container)
```

--------------------------------

### Get Material Item Metadata

Source: https://plethora.madefor.cc/methods

Retrieves the material type of an item, such as 'DIAMOND' or 'IRON'. This metadata is specific to items that represent raw materials.

```Lua
{
  material = "DIAMOND"
}
```

--------------------------------

### Get Size of Box

Source: https://plethora.madefor.cc/methods

Retrieves the dimensions (width, height, depth) of a Box object. Used for managing the size of 3D box elements.

```Java
public double[] getSize()
```

--------------------------------

### Basic Block Scan and Iteration

Source: https://plethora.madefor.cc/items/module-scanner

Scans all blocks within an 8-block radius and iterates through the results to print block names and coordinates. This is the simplest way to use the block scanner.

```lua
local scanner = peripheral.wrap(--[[ whatever ]])
for _, block in pairs(scanner.scan()) do
  print(("The block at %d, %d, %d is %s"):format(block.x, block.y, block.z, block.name))
end
```

--------------------------------

### Get Point Count - Plethora API

Source: https://plethora.madefor.cc/methods

Retrieves the total number of vertices (points) in a MultiPointResizable2D object. This method is part of the MultiPointResizable2D class.

```Java
org.squiddev.plethora.gameplay.modules.glasses.objects.object2d.MultiPointResizable2D#getPointCount(MultiPointResizable2D)
```
Tokens:
Raw