Ultimate Guide: Redstone PC with Create and ComputerCraft

Hello, Minecrafter!

Welcome to the ultimate guide on building a Redstone PC using the Create mod and ComputerCraft (CC: Tweaked). This guide will walk you through combining mechanical ingenuity with programming prowess to create a fully functional computer within Minecraft. Let's dive into the intricate details of each step!

1. Create Mod: Building the Physical Infrastructure

The Create mod provides the mechanical backbone of our Redstone PC. We'll use its components to build the physical structure and basic mechanisms.

1.1 Power Generation

Start by setting up a reliable power source:

Build a Water Wheel (8x8 blocks) near a water source
Alternatively, construct a Windmill (7x7 blades) in an open area
Connect the power source to a Large Cogwheel

1.2 Power Distribution

Create a network to distribute rotational force:

Use Shafts to extend power horizontally and vertically
Place Cogwheels at corners to change direction
Implement Gearboxes to adjust rotation speed and direction

1.3 Mechanical Memory Unit

Construct a rotation-based memory system:

Build a circular structure (diameter: 7 blocks) using different colored wool for bits
Place a Stationary Bearing in the center
Attach Mechanical Pistons around the perimeter for read/write operations
Connect the bearing to your power network

// Create mod setup schematic
[Water Wheel/Windmill] -> [Large Cogwheel]
            |
        [Shaft] -> [Gearbox] -> [Mechanical Components]
            |
    [Stationary Bearing] -> [Memory Structure]
            |
    [Mechanical Pistons] (for read/write)
      

2. ComputerCraft: Implementing Control and Programming

ComputerCraft will serve as the brain of our Redstone PC, handling complex computations and control mechanisms.

2.1 Setting Up the Central Computer

Place and configure the main ComputerCraft computer:

Craft and place an Advanced Computer
Attach a Disk Drive and insert a floppy disk for extra storage
Place Wired Modems on the computer and nearby Create mod components
Connect modems with Networking Cables

2.2 Programming the Core Functions

Write Lua programs to control your Redstone PC:

Create a startup file to initialize all peripherals
Implement functions for basic arithmetic operations
Develop a simple operating system with a command interface

2.3 Setting Up Display Output

Create a visual interface for your Redstone PC:

Place an Advanced Monitor (3x3 size) near the computer
Write a program to manage screen output
Implement a simple GUI with options and status display

-- Basic ComputerCraft startup file
local monitor = peripheral.wrap("top")
monitor.clear()
monitor.setCursorPos(1,1)
monitor.write("Redstone PC v1.0")

function initPeripherals()
  -- Initialize Create mod components
  createMotor = peripheral.wrap("create:motor_0")
  createSensor = peripheral.wrap("create:sensor_0")
end

initPeripherals()

while true do
  local event, side = os.pullEvent("redstone")
  if side == "left" then
    monitor.setCursorPos(1,3)
    monitor.write("Processing...")
    -- Perform operations
  end
end
      

3. Integrating Create and ComputerCraft

Now, let's combine the physical components from Create with the digital brain of ComputerCraft.

3.1 Interfacing Create Mechanisms

Connect Create mod components to the ComputerCraft network:

Attach Redstone Integrators to key Create mod machines
Place Wired Modems on the Redstone Integrators
Connect all modems to the central computer using Networking Cables

3.2 Creating Control Programs

Write Lua programs to control Create mod machines:

Implement functions to adjust Gearbox settings
Create programs to control Mechanical Piston movements for memory operations
Develop a system to read from and write to the mechanical memory unit

3.3 Data Flow Management

Establish protocols for data transfer between mods:

Use ComputerCraft to read data from Create mod sensors
Implement a queuing system for operations involving both mods
Create error handling and logging mechanisms

-- ComputerCraft program to control Create mod components
local gearbox = peripheral.wrap("create:gearbox_0")
local memoryBearing = peripheral.wrap("create:bearing_0")
local memoryPiston = peripheral.wrap("create:piston_0")

function setGearRatio(ratio)
  gearbox.setRatio(ratio)
end

function rotateBearing(degrees)
  memoryBearing.rotate(degrees)
end

function readMemoryBit()
  memoryPiston.extend()
  local bit = memoryPiston.isTouching()
  memoryPiston.retract()
  return bit
end

-- Example usage
setGearRatio(2)
rotateBearing(45)
local bitValue = readMemoryBit()
print("Read bit value: " .. tostring(bitValue))
      

4. Building the Advanced ALU

Create a powerful Arithmetic Logic Unit (ALU) by combining Create's mechanical calculators with ComputerCraft's processing capabilities.

4.1 Mechanical Calculator Array

Set up an array of Create mod Mechanical Calculators:

Place 4 Mechanical Calculators in a 2x2 grid
Connect each calculator to the power network
Attach Redstone Integrators to each calculator

4.2 ComputerCraft Control Program

Write a Lua program to manage the calculator array:

Implement functions for each basic arithmetic operation
Create a dispatcher to distribute calculations across the array
Develop more complex mathematical functions using basic operations

4.3 Advanced Mathematical Operations

Use ComputerCraft to extend the ALU's capabilities:

Implement trigonometric functions (sin, cos, tan)
Create functions for exponential and logarithmic calculations
Develop a simple floating-point arithmetic system

-- Advanced ALU control program
local calculators = {
  peripheral.wrap("create:calculator_0"),
  peripheral.wrap("create:calculator_1"),
  peripheral.wrap("create:calculator_2"),
  peripheral.wrap("create:calculator_3")
}

function add(x, y)
  return calculators[1].add(x, y)
end

function subtract(x, y)
  return calculators[2].subtract(x, y)
end

function multiply(x, y)
  return calculators[3].multiply(x, y)
end

function divide(x, y)
  return calculators[4].divide(x, y)
end

function power(x, y)
  local result = 1
  for i = 1, y do
    result = multiply(result, x)
  end
  return result
end

function sin(x)
  -- Implement Taylor series approximation
  -- sin(x) ≈ x - x^3/3! + x^5/5! - x^7/7! + ...
  local result = x
  local term = x
  for i = 1, 5 do
    term = multiply(multiply(term, -1), divide(multiply(x, x), multiply(2*i, 2*i+1)))
    result = add(result, term)
  end
  return result
end

-- Example usage
print("5 + 3 =", add(5, 3))
print("2^8 =", power(2, 8))
print("sin(0.5) ≈", sin(0.5))
      

5. Crafting an Interactive I/O System

Design an intuitive and visually appealing input/output system that leverages both mods' strengths.

5.1 Physical Input Mechanism

Create a tangible input system using Create mod components:

Set up a 3x3 grid of Mechanical Crafters
Use different colored wool blocks to represent digits and operations
Implement a Deployer to automatically place input blocks
Use a Mechanical Arm to remove processed blocks

5.2 ComputerCraft Input Processing

Write programs to interpret and process physical inputs:

Scan the Mechanical Crafter grid to read input values
Implement a parser to convert block patterns into mathematical expressions
Create an expression evaluator to process the parsed input

5.3 Dynamic Display Output

Develop an engaging visual output system:

Use a large Advanced Monitor (5x3) for the main display
Create a GUI with current operation, result, and system status
Implement animated transitions between different screens
Use Create mod Mechanical Displays for secondary numeric output

-- Interactive I/O System control program
local crafters = {
  peripheral.wrap("create:crafter_0"),
  -- ... wrap all 9 crafters
}
local deployer = peripheral.wrap("create:deployer_0")
local arm = peripheral.wrap("create:arm_0")
local monitor = peripheral.wrap("monitor_0")

function readInput()
  local input = {}
  for i = 1, 9 do
    local item = crafters[i].getItem(1)
    if item then
      input[i] = item.name
    end
  end
  return input
end

function parseInput(input)
  -- Convert wool colors to digits and operations
  -- Example: "minecraft:red_wool" -> "1", "minecraft:yellow_wool" -> "+"
end

function displayOutput(result)
  monitor.clear()
  monitor.setCursorPos(1,1)
  monitor.write("Result: " .. result)
  
  -- Animate result
  for i = 1, 5 do
    monitor.setCursorPos(1,3)
    monitor.write(string.rep("=", i) .. ">")
    os.sleep(0.2)
  end
end

while true do
  local input = readInput()
  local expression = parseInput(input)
  local result = evaluateExpression(expression)
  displayOutput(result)
  
  -- Clear input
  arm.pushItem("down", 1, 9)
  os.sleep(1)
end
      

By meticulously integrating the Create mod's mechanical wonders with ComputerCraft's programming prowess, you've constructed a Redstone PC that pushes the boundaries of what's possible in Minecraft. This machine not only performs complex computations but also provides a tangible, interactive experience that bridges the gap between the digital and physical Minecraft world. Continue to experiment, expand, and refine your creation – the only limit is your imagination!