GregTech-Modern CCTweaked Integration

https://pastebin.com/raw/u5qFFzqC
Admin
GregTech-Modern CCTweaked integration provides Lua-based peripheral APIs for ComputerCraft to...
Tokens:4,825
Snippets:26
Trust Score:5.8
Update:8 months ago
Show doc for...
Tokens:
Raw
### Get Workable Progress and Status (Lua)

Source: https://pastebin.com/raw/u5qFFzqC/index

Checks the current progress, maximum progress, and active status of a 'gtceu:workable' peripheral. This is useful for monitoring crafting or processing tasks.

```lua
local p = peripheral.find("gtceu:workable")
if p then
  print(("Progress: %d / %d"):format(p.getProgress(), p.getMaxProgress()))
  print("Active:", p.isActive())
end
```

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

### gtceu:workable Peripheral

Source: https://pastebin.com/raw/u5qFFzqC/index

Manages the working state and progress of a GregTech-Modern workable machine.

```APIDOC
## gtceu:workable Peripheral

### Description
Provides control and status information for GregTech-Modern machines that have a working process, such as assemblers or furnaces.

### Method
`peripheral.find("gtceu:workable")` or `peripheral.wrap(side)`

### Methods
- **getProgress()** -> `number`: Returns the current progress of the ongoing task.
- **getMaxProgress()** -> `number`: Returns the maximum progress required to complete the task.
- **isActive()** -> `boolean`: Returns `true` if the machine is currently active, `false` otherwise.
- **isWorkingEnabled()** -> `boolean`: Returns `true` if working is enabled, `false` otherwise.
- **setWorkingEnabled(enabled: boolean)** -> `nil`: Enables or disables the machine's operation.
- **setSuspendAfterFinish(suspendAfterFinish: boolean)** -> `nil`: Configures whether the machine should suspend after completing its current task.

### Request Example
```lua
local p = peripheral.find("gtceu:workable")
if p then
  print(("Progress: %d / %d"):format(p.getProgress(), p.getMaxProgress()))
  print("Active:" .. tostring(p.isActive()))

  -- Example: Disable working
  -- p.setWorkingEnabled(false)
  -- Example: Suspend after finish
  -- p.setSuspendAfterFinish(true)
end
```

### Response
#### Success Response (200)
- **Progress** (`number`): The current progress value.
- **Max Progress** (`number`): The total progress needed.
- **Active** (`boolean`): Whether the machine is currently working.
- **Working Enabled** (`boolean`): Current state of the working enable flag.

#### Response Example
```json
{
  "Progress": 50,
  "Max Progress": 100,
  "Active": true,
  "Working Enabled": true
}
```
```

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

### gtceu:coverable Peripheral

Source: https://pastebin.com/raw/u5qFFzqC/index

Allows interaction with coverable blocks, enabling text display and placeholder parsing on faces.

```APIDOC
## gtceu:coverable Peripheral

### Description
Manages the text display and placeholder evaluation on the faces of GregTech-Modern coverable blocks, such as monitors or control panels.

### Method
`peripheral.find("gtceu:coverable")` or `peripheral.wrap(side)`

### Methods
- **setBufferedText(face: string, line: int (1..100), text: string)** -> (`boolean` success, `string` message): Sets text on a specific line of a given face. Returns `true` on success, `false` with an error message on failure.
  - `face`: One of "north", "south", "east", "west", "up", "down".
- **parsePlaceholders(face: string, text: string)** -> (`boolean` success, `string` resultOrError): Evaluates placeholders within a given text string for a specific face. Returns `true` and the processed string on success, or `false` and an error message on failure.

### Request Example
```lua
local c = peripheral.find("gtceu:coverable")
if c then
  -- Set text on the north face, line 1
  local ok, msg = c.setBufferedText("north", 1, "Hello from CC")
  print(ok, msg)

  -- Parse placeholders on the north face
  local ok2, result = c.parsePlaceholders("north", "Status: <status_placeholder>")
  if ok2 then
    print("Parsed result:" .. result)
  else
    print("Parse error:" .. result)
  end
end
```

### Response
#### Success Response (200)
- **Success** (`boolean`): Indicates if the operation was successful.
- **Message/Result** (`string`): A success message or the parsed string result.

#### Response Example
```json
{
  "Success": true,
  "Message/Result": "Operation successful" 
}
```

#### Error Response Example
```json
{
  "Success": false,
  "Message/Result": "Invalid face specified" 
}
```
```

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

### Interact with gtceu:coverable Peripheral (Lua)

Source: https://pastebin.com/raw/u5qFFzqC/index

Shows how to use the 'gtceu:coverable' peripheral to set text on specific faces and parse placeholders within text. It includes error handling for the operations.

```lua
local c = peripheral.find("gtceu:coverable")
if c then
  -- set line 1 on north face
  local ok, msg = c.setBufferedText("north", 1, "Hello from CC")
  print(ok, msg)

  -- parse placeholders in a string for a face; result returned as second value on success
  local ok2, result = c.parsePlaceholders("north", "Line 1 content: <placeholder-here>")
  if ok2 then
    print("Parsed:", result)
  else
    print("Parse error:", result)
  end
end
```

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

### Get Energy Info from gtceu:energy_info Peripheral (Lua)

Source: https://pastebin.com/raw/u5qFFzqC/index

Retrieves and prints energy-related information (stored, capacity, input, output) from the 'gtceu:energy_info' peripheral. This snippet assumes the peripheral is available and accessible.

```lua
local p = peripheral.find("gtceu:energy_info")
if p then
  print("Stored:", p.getEnergyStored())
  print("Capacity:", p.getEnergyCapacity())
  print("In/sec:", p.getInputPerSec())
  print("Out/sec:", p.getOutputPerSec())
end
```

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

### Interact with Central Monitor Peripheral

Source: https://pastebin.com/raw/u5qFFzqC/index

This Lua code snippet demonstrates how to find the 'gtceu:central_monitor' peripheral, retrieve its groups, and interact with text and image modules. It shows how to get current text/image URLs and set new placeholder text or image URLs, handling different module types.

```lua
local cm = peripheral.find("gtceu:central_monitor")
if not cm then
  print("No central monitor peripheral found")
  return
end

local groups = cm.getGroups()
for i, g in ipairs(groups) do
  print(("Group %d: %s"):format(i, g.getName()))
  local m = g.getModule()
  if m then
    local t = m.getType()
    print(" Module type:", t)
    if t == "text" then
      local text = m.getCurrentText() -- may be nil if nothing
      print("  Current text:", text or "<none>")
      -- change placeholder text
      m.setPlaceholderText("CPU: ${cpu}%")
      m.setScale(1.2)
    elseif t == "image" then
      print("  URL:", m.getImageUrl() or "<none>")
      m.setImageUrl("https://example.com/image.png")
    else
      print("  No usable module or unknown type")
    end
  end
end
```

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

### Get Large Turbine Information (Lua)

Source: https://pastebin.com/raw/u5qFFzqC/index

Retrieves various performance metrics from a 'gtceu:large_turbine' peripheral, including rotor status, speed, efficiency, production, overclock voltage, and durability. This helps in monitoring and optimizing turbine performance.

```lua
local t = peripheral.find("gtceu:large_turbine")
if t then
  print("Has rotor:", t.hasRotor())
  print("Rotor speed:", t.getRotorSpeed())
  print("Max rotor holder speed:", t.getMaxRotorHolderSpeed())
  print("Efficiency:", t.getTotalEfficiency())
  print("Production:", t.getCurrentProduction())
  print("Overclock V:", t.getOverclockVoltage())
  print("Rotor durability %:", t.getRotorDurabilityPercent())
end
```

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

### gtceu:energy_info Peripheral

Source: https://pastebin.com/raw/u5qFFzqC/index

Provides information about the energy stored, capacity, and transfer rates of a GregTech-Modern energy device.

```APIDOC
## gtceu:energy_info Peripheral

### Description
Accesses energy information for a GregTech-Modern block, including stored energy, capacity, and energy transfer rates.

### Method
`peripheral.find("gtceu:energy_info")` or `peripheral.wrap(side)`

### Methods
- **getEnergyStored()** -> `number`: Returns the amount of energy currently stored.
- **getEnergyCapacity()** -> `number`: Returns the maximum energy capacity.
- **getInputPerSec()** -> `number`: Returns the current energy input rate per second.
- **getOutputPerSec()** -> `number`: Returns the current energy output rate per second.

### Request Example
```lua
local p = peripheral.find("gtceu:energy_info")
if p then
  print("Stored:" .. p.getEnergyStored())
  print("Capacity:" .. p.getEnergyCapacity())
  print("In/sec:" .. p.getInputPerSec())
  print("Out/sec:" .. p.getOutputPerSec())
end
```

### Response
#### Success Response (200)
- **Energy Stored** (`number`): The current energy level.
- **Energy Capacity** (`number`): The maximum energy the device can hold.
- **Input Per Second** (`number`): The rate of energy input.
- **Output Per Second** (`number`): The rate of energy output.

#### Response Example
```json
{
  "Stored": 1000000,
  "Capacity": 2000000,
  "Input Per Second": 5000,
  "Output Per Second": 4500
}
```
```

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

### Find and Call Peripherals in Lua

Source: https://pastebin.com/raw/u5qFFzqC/index

Demonstrates how to find and call methods on GregTech-Modern peripherals using ComputerCraft's peripheral API in Lua. It covers finding peripherals by side or type, listing available methods, and calling them directly or via a wrapper.

```lua
local p_left = peripheral.wrap("left")
local p_right = peripheral.wrap("right")

local energy_info_name = peripheral.find("gtceu:energy_info")

if energy_info_name then
  local methods = peripheral.getMethods(energy_info_name)
  print("Energy info methods:", table.concat(methods, ", "))

  -- Call method directly
  local stored = peripheral.call(energy_info_name, "getEnergyStored")
  print("Stored energy (direct call):", stored)

  -- Call method on wrapper
  local p_energy = peripheral.wrap(energy_info_name)
  local capacity = p_energy.getEnergyCapacity()
  print("Energy capacity (wrapper call):", capacity)
end
```

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

### Control Working State of gtceu:workable Peripheral (Lua)

Source: https://pastebin.com/raw/u5qFFzqC/index

Demonstrates how to check and modify the working state of a 'gtceu:workable' peripheral, including enabling/disabling work and setting it to suspend after completion. Requires the peripheral to support these controllable methods.

```lua
local p = peripheral.find("gtceu:workable")
if p and p.isWorkingEnabled then
  print("Working enabled:", p.isWorkingEnabled())
  -- disable working
  p.setWorkingEnabled(false)
  -- request suspend after finishing current job
  p.setSuspendAfterFinish(true)
end
```

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

### Periodically Print Workable Progress

Source: https://pastebin.com/raw/u5qFFzqC/index

This Lua code snippet demonstrates how to monitor and display the progress of a 'gtceu:workable' peripheral. It calculates and prints the progress percentage every two seconds, indicating if the workable peripheral is found.

```lua
local w = peripheral.find("gtceu:workable")
while true do
  if w then
    print(("Progress: %.1f%% "):format(100 * (w.getProgress() / w.getMaxProgress())))
  else
    print("Workable not found")
  end
  sleep(2)
end
```

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

### gtceu:large_turbine Peripheral

Source: https://pastebin.com/raw/u5qFFzqC/index

Retrieves operational data from a large turbine, including speed, efficiency, and production.

```APIDOC
## gtceu:large_turbine Peripheral

### Description
Provides detailed performance metrics for a large GregTech-Modern turbine, such as rotor speed, efficiency, and energy production.

### Method
`peripheral.find("gtceu:large_turbine")` or `peripheral.wrap(side)`

### Methods
- **hasRotor()** -> `boolean`: Checks if the turbine has a rotor installed.
- **getRotorSpeed()** -> `number`: Returns the current speed of the rotor.
- **getMaxRotorHolderSpeed()** -> `number`: Returns the maximum speed the rotor holder can sustain.
- **getTotalEfficiency()** -> `number`: Returns the overall efficiency of the turbine.
- **getCurrentProduction()** -> `number`: Returns the current energy production rate.
- **getOverclockVoltage()** -> `number`: Returns the overclock voltage setting.
- **getRotorDurabilityPercent()** -> `number`: Returns the rotor's durability as a percentage.

### Request Example
```lua
local t = peripheral.find("gtceu:large_turbine")
if t then
  print("Has rotor:" .. tostring(t.hasRotor()))
  print("Rotor speed:" .. t.getRotorSpeed())
  print("Max rotor holder speed:" .. t.getMaxRotorHolderSpeed())
  print("Efficiency:" .. t.getTotalEfficiency())
  print("Production:" .. t.getCurrentProduction())
  print("Overclock V:" .. t.getOverclockVoltage())
  print("Rotor durability %:" .. t.getRotorDurabilityPercent())
end
```

### Response
#### Success Response (200)
- **Has Rotor** (`boolean`): Indicates if a rotor is present.
- **Rotor Speed** (`number`): The current rotational speed.
- **Max Rotor Holder Speed** (`number`): The maximum safe speed for the rotor holder.
- **Total Efficiency** (`number`): The turbine's efficiency rating.
- **Current Production** (`number`): The current energy output.
- **Overclock Voltage** (`number`): The voltage used for overclocking.
- **Rotor Durability Percent** (`number`): The remaining durability of the rotor.

#### Response Example
```json
{
  "Has Rotor": true,
  "Rotor Speed": 1200,
  "Max Rotor Holder Speed": 1500,
  "Total Efficiency": 0.95,
  "Current Production": 1024,
  "Overclock Voltage": 240,
  "Rotor Durability Percent": 98.5
}
```
```

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

### Poll Energy Stored and Capacity

Source: https://pastebin.com/raw/u5qFFzqC/index

This Lua snippet shows how to periodically poll the energy stored and capacity of a 'gtceu:energy_info' peripheral. It continuously prints the energy status every second as long as the peripheral is available.

```lua
local p = peripheral.find("gtceu:energy_info")
while p do
  print("Energy:", p.getEnergyStored(), "/", p.getEnergyCapacity())
  sleep(1)
end
```
Tokens:
Raw