CC: Tweaked · Addon guide · Advanced

Plethora Peripherals Guide: Neural Interfaces, Laser Turrets & Kinetic Modules

Plethora Peripherals expands CC: Tweaked by transforming entities, players, and blocks into programmable modules using the Neural Interface. In this guide, you will learn how to build a wearable cybernetic suit that projects custom 3D HUD overlays, automatically launches you into the air using Kinetic Augmentations, scans nearby threats, and eliminates them with automated Frickin' Laser Beams. Mastering these mechanics elevates your Lua scripting from stationary base automation to real-time player augmentation and autonomous combat.

What you need

  • CC: Tweaked and Plethora Peripherals installed (or the modern equivalent port for your version, check JEI for exact recipes)
  • Neural Interface and Neural Connector
  • Advanced Pocket Computer (or standard Computer with a Wireless Modem for remote script transfers)
  • Introspection Module
  • Entity Sensor and Block Scanner
  • Kinetic Augmentation
  • Frickin' Laser Beam
  • Overlay Glasses
  • Ender Modem (optional, for remote drone or turret control)

Step by step

  1. 1Equip and Bind the Neural Interface

    Craft the Neural Interface and place it into your helmet or Baubles/Curios head slot, depending on your modpack configuration. Next, hold the Neural Connector in your main hand and right-click to open the internal computer terminal and module slots of your currently equipped Neural Interface. Unlike a standard Advanced Computer, the Neural Interface wraps up to five specific Plethora modules directly into a single combined peripheral network residing on the entity wearing it.

    Tip: You can shift-right-click a living mob like a Iron Golem or Wolf with the Neural Interface to equip it onto them, then use the Neural Connector on that mob to program its behavior!

  2. 2Install Core Modules and Wrap the Peripheral

    Open the Neural Interface GUI using the Neural Connector and insert the Introspection Module, Entity Sensor, Kinetic Augmentation, Frickin' Laser Beam, and Overlay Glasses into the peripheral slots. In the terminal, create a startup script using `edit startup.lua`. Instead of wrapping sides like `top` or `left`, call `local modules = peripheral.find("neuralInterface")` to bind all installed modules into a single Lua table of functions.

    Tip: Use the `Peripherals` tab inside the Neural Connector GUI or run `periphemu` commands if testing in an emulator to verify that all inserted modules are detected.

  3. 3Program theKinetic Augmentation for Flight and Auto-Feeding

    With the Kinetic Augmentation and Introspection Module installed, your script can manipulate your physical body. Call `modules.getMetaOwner()` to read your current player metadata, including health, hunger, pitch, and yaw. To create a Lua-powered jetpack, listen for a key press event or sneak state (`meta.isSneaking`), and call `modules.launch(meta.yaw, meta.pitch, power)` where power is a float between 0.1 and 4.0.

    Tip: If you have food in your inventory, the Kinetic Augmentation also unlocks `modules.use()` or inventory manipulation via the Introspection Module's `modules.getInventory()` to swap food to your hand and feed you automatically when hunger drops.

  4. 4Scan and Track Targets with the Entity Sensor

    The Entity Sensor grants the `modules.sense()` method, which returns a list of all entities within a fixed spherical radius around the wearer. Each returned table contains the entity's `id`, `name`, and relative coordinates (`x`, `y`, `z`) measured directly from the wearer's current position. Write a loop that filters this table for hostile mobs (such as `Creeper` or `Zombie`) and selects the closest target using standard 3D distance math (`math.sqrt(x*x + y*y + z*z)`).

    Tip: To inspect detailed stats of a specific entity, pass its `id` into `modules.getMetaByID(id)` to check its current health and armor before deciding to attack.

  5. 5Calculate Angles and Fire the Frickin' Laser Beam

    Once you have the relative `x`, `y`, and `z` offsets of a target from `modules.sense()`, you must convert those Cartesian coordinates into spherical direction angles (`yaw` and `pitch`) for the Frickin' Laser Beam. In Lua, calculate the horizontal distance `local hDist = math.sqrt(x*x + z*z)`, then compute `local pitch = math.deg(-math.atan2(y, hDist))` and `local yaw = math.deg(math.atan2(-x, z))`. Pass these angles and a potency value into `modules.fire(yaw, pitch, potency)` to shoot a blazing energy projectile that sets blocks and mobs on fire and deals direct damage.

    Tip: Adjust the `y` offset slightly upwards (e.g., `y + 0.5`) before calculating pitch; entity coordinates usually point to the mob's feet, while the laser fires from your head.

  6. 6Render 2D and 3D HUDs with Overlay Glasses

    With Overlay Glasses inserted into the Neural Interface, call `local canvas2d = modules.canvas()` for screen-space UI or `local canvas3d = modules.canvas3d().create()` for world-space holograms. always call `canvas2d.clear()` at the start of your script so previous text does not overlap after a reboot. Using your scanned entity coordinates from Step 4, call `local box = canvas3d.addBox(x, y, z, 0.8, 1.8, 0.8, 0xFF000080)` inside your main tracking loop to draw translucent red bounding boxes around enemies right through solid walls.

    Tip: Update the position of existing canvas objects using `box.setPosition(x, y, z)` rather than clearing and recreating the entire 3D canvas every tick to avoid visual flickering and network lag.

  7. 7Build a Stationary Autonomous Laser Turret

    You do not need a Neural Interface to use Plethora modules; you can place a Manipulator (Mark I or Mark II) directly in the world next to a standard Advanced Computer. Insert an Entity Sensor and a Frickin' Laser Beam into the Manipulator, wrap it via `peripheral.wrap("side")`, and run the exact same trigonometry targeting loop from Step 5. This creates a completely free-standing base defense turret that runs continuously without needing a player nearby.

    Tip: If you mount a Frickin' Laser Beam onto a Turtle instead, you can create a mobile artillery unit that moves along a perimeter track while firing at intruders.

How it works

Plethora operates on a unified capability and metadata system rather than providing dozens of rigid, single-purpose blocks. When you insert modules into a Neural Interface or a stationary Manipulator, Plethora dynamically merges the Lua methods of all installed items into one peripheral network table. Because the computer executes inside the entity's logical context, methods like `sense()` or `launch()` always operate relative to the wearer's current world origin and facing vector.

Trigonometric targeting works because Minecraft uses a specific coordinate convention for yaw and pitch. Positive Z is South (0 degrees yaw), negative Z is North (180/-180 degrees), positive X is East (-90 degrees), and negative X is West (90 degrees). By taking `math.atan2(-x, z)` on the relative coordinates returned by the Entity Sensor, you translate standard 3D Euclidean vectors directly into the exact angular rotation expected by both the `fire()` method of the Laser and the `launch()` method of the Kinetic Augmentation.

Finally, Plethora introduces an internal cost and cooldown mechanic for powerful actions like firing lasers, launching entities, or breaking blocks. Every time you call `modules.fire(yaw, pitch, potency)`, the module consumes an internal energy buffer that regenerates passively over time. In Lua, these high-cost functions yield the coroutine until the server has accumulated enough internal buffer energy to execute the action, naturally rate-limiting your scripts so they cannot fire infinite lasers in a single server tick.

Common mistakes

  • Forgetting to call `canvas.clear()` at the beginning of a script: Canvas objects persist on the Neural Interface even after a program terminates or crashes, leading to stuck HUD elements and memory clutter until cleared.
  • Using standard `math.atan(y/x)` instead of `math.atan2(y, x)`: Standard `atan` cannot distinguish between opposite quadrants, causing your laser turret or kinetic dash to fire backwards 50% of the time.
  • Aiming at the entity's origin (`y = 0` relative to target) without accounting for eye height: Because the Neural Interface sits on your head and entity positions are measured at their feet, firing directly at raw relative coordinates will often hit the floor right in front of the mob.
  • Trying to access player inventory via the Introspection Module when the module is not bound: You must shift-right-click the Introspection Module in the air to bind it to your specific player UUID before inserting it into a Manipulator or Neural Interface.

FAQ

Why does my Frickin' Laser Beam destroy my own base blocks?

At higher potency values, the laser ignites flammable blocks and melts softer terrain upon impact. Lower the potency parameter (e.g., between 0.5 and 1.5) or implement a raycast/angle check in Lua so the turret refuses to fire along vectors pointing toward critical machinery.

How do I stop taking fall damage when using the Kinetic Augmentation to fly?

Run a background coroutine that monitors your downward vertical velocity (`meta.motionY`). When you are falling rapidly toward a block (checked via the Block Scanner), execute a weak upward `modules.launch(0, -90, 0.8)` right before impact to cancel your momentum.

Can I control a mob wearing a Neural Interface remotely from a base computer?

Yes. Insert an Ender Modem or Wireless Modem into one of the mob's Neural Interface slots. Run a small listener script on the mob's Neural Interface using `rednet.receive()`, allowing your main base computer to transmit movement, laser, or kinetic commands across the world.

What is the difference between a Manipulator Mark I and Mark II?

The Manipulator Mark I only holds a single Plethora module at a time, whereas the Manipulator Mark II provides five slots, functioning like a stationary block version of the wearable Neural Interface.

By combining the Neural Interface with Plethora's sensor, kinetic, laser, and canvas modules, you can script real-time 3D targeting HUDs, automated defense turrets, and personal flight systems using straightforward Lua trigonometry.

More CC: Tweaked guides

CC: Tweaked · ExplainedLua for CC: Tweaked Explained: Variables, Functions & The os.pullEvent LoopWriting your own scripts in CC: Tweaked unlocks total control over your Minecraft world, allowing you to automate everything from simple redstone doors to complex Turtle mining arrays. This guide breaks down the essentials of the Lua language—specifically variables, functions, and the critical event-pulling loop—so you can build reliable programs that never freeze or crash.Beginner6 steps
CC: Tweaked · PowerTurtle Fuel & Progression Guide: From Basic Turtles to Infinite Lava RefuelingTurtles in CC: Tweaked are powerful mobile robots, but they cannot move a single block without fuel. In this guide, you will learn how the internal Turtle fuel economy operates, how to upgrade from basic gray models to high-capacity Advanced Turtles, and how to program a self-sustaining Nether lava refueling loop.Beginner7 steps
CC: Tweaked · AutomationHow to Automate Strip Mining & Quarries with Mining TurtlesManual mining is one of the most time-consuming tasks in survival Minecraft, often taking hours away from complex base building and automation. With CC: Tweaked, you can deploy programmable Mining Turtles to carve out massive quarries and strip mines completely hands-free. This guide will walk you through crafting a Mining Turtle, setting up an automated fueling and chest-dumping station, and running both built-in and custom Lua mining scripts.Intermediate8 steps
CC: Tweaked · ExplainedPeripherals & Wired Networks Explained: Wrapping, Modems & Networking CablesIn CC: Tweaked, a standalone Computer can only do so much on its own; its real power comes from controlling external blocks known as peripherals. This guide will teach you how to connect your Computer to adjacent and distant machines—like Monitors, Speakers, and Chests—using Wired Modems, Networking Cables, and the Lua peripheral API. Mastering wired networks allows you to manage an entire base's inventory and automation from one central terminal.Intermediate8 steps
CC: Tweaked · Setup guideHow to Build a CC: Tweaked Storage Network & Auto-Crafting SystemIn this advanced guide, you will build a centralized item storage network and an on-demand auto-crafting system using CC: Tweaked's Wired Modems, Advanced Computers, and Crafty Turtles. By leveraging the native inventory peripheral methods in Lua, you can create a zero-RF digital storage solution that rivals dedicated logistics mods while giving you total programmable control over every item slot.Advanced8 steps
CC: Tweaked · Setup guideHow to Build an Interactive Touchscreen Monitor Dashboard for Base ControlIn this guide, you will build a dynamic touchscreen dashboard using CC: Tweaked to monitor your base's energy and fluid storage while toggling generators with a single tap. Centralizing your base controls onto an interactive graphical screen eliminates messy redstone wiring and prevents catastrophic power outages by giving you real-time data at a glance.Intermediate7 steps