Behalten Sie den Überblick: So programmieren Sie Ihr eigenes `Computercraft Radar`

Die Welt von Minecraft ist riesig, unvorhersehbar und voller Geheimnisse. Ob Sie eine automatisierte Basis bauen, komplexe Bergbauoperationen durchführen oder einfach nur Ihre Umgebung im Auge behalten wollen – der Überblick kann entscheidend sein. Hier kommt Computercraft ins Spiel, eine Minecraft-Mod, die Ihnen die Macht der Programmierung in die Hände legt. Mit einem Computer, einem Monitor und ein paar Zeilen Lua-Code können Sie erstaunliche Dinge tun, zum Beispiel Ihr eigenes Computercraft Radar bauen.

Stellen Sie sich vor, Sie könnten die Position Ihrer Bergbau-Schildkröten verfolgen, den Status Ihrer entfernten Farmen überwachen oder sogar andere automatisierte Systeme auf einer Karte sehen. Genau das ermöglicht ein selbstprogrammiertes Radar. Dieser Artikel führt Sie Schritt für Schritt durch den Prozess, von den Grundlagen bis zu fortgeschrittenen Funktionen. Bereiten Sie sich darauf vor, Ihre Minecraft-Welt auf ein neues Level der Automatisierung und Kontrolle zu heben!

Was ist Computercraft und warum ein Radar?

Computercraft fügt Minecraft programmierbare Computer und Roboter (Schildkröten) hinzu, die mithilfe der Skriptsprache Lua gesteuert werden. Diese Geräte können mit der Umgebung interagieren, Redstone-Signale senden, Blöcke platzieren oder abbauen und über drahtlose Netzwerke kommunizieren. Ihre Einsatzmöglichkeiten sind nahezu unbegrenzt.

Ein „Radar” im Computercraft-Kontext ist typischerweise ein System, das die Position von Objekten – in den meisten Fällen andere Computercraft-Geräte wie Schildkröten oder entfernte Computer – erfasst und auf einem Display visualisiert. Obwohl Computercraft keine native Funktion zur direkten Erkennung von Mobs oder Spielern auf einer Karte bietet (ohne externe Addons oder sehr aufwendige Redstone-Konstruktionen), ist die Verfolgung Ihrer eigenen automatisierten Einheiten von unschätzbarem Wert. Es hilft Ihnen:

• Ihre automatisierten Bergbau-Schildkröten zu lokalisieren, wenn sie sich verlaufen.
• Den Fortschritt von Konstruktions-Schildkröten zu überwachen.
• Den Überblick über mehrere verteilte Automatisierungssysteme zu behalten.
• Schnell Probleme zu erkennen, wenn sich eine Einheit nicht wie erwartet bewegt.

Grundlagen und Voraussetzungen

Bevor wir mit dem Programmieren beginnen, stellen Sie sicher, dass Sie die Computercraft-Mod in Ihrem Minecraft installiert haben. Für unser Radar benötigen wir einige grundlegende Komponenten:

• Ein Computercraft-Computer: Dies ist die zentrale Einheit, die das Radarprogramm ausführt.
• Ein Advanced Monitor: Ein einfacher Monitor würde auch funktionieren, aber ein Advanced Monitor bietet mehr Farben und Pixel, was für eine bessere Visualisierung unerlässlich ist. Platzieren Sie ihn direkt neben dem Computer.
• Mindestens ein Funkmodem (Wireless Modem): Dieses ist entscheidend für die drahtlose Kommunikation. Platzieren Sie es an einer Seite des Computers. Jede Einheit, die vom Radar erfasst werden soll (z.B. eine Schildkröte), benötigt ebenfalls ein Funkmodem.
• (Optional) GPS-Sender: Computercraft bietet ein Global Positioning System (GPS). Für präzise Standortbestimmungen sollten Sie einige GPS-Sender in der Nähe Ihres Radars positionieren. Je mehr Sender, desto genauer die Ortung.

Grundkenntnisse in Lua sind von Vorteil, aber keine Voraussetzung. Wir werden den Code ausführlich erklären, sodass auch Anfänger folgen können.

Das Funktionsprinzip unseres Radars

Unser Computercraft Radar wird auf einem einfachen, aber effektiven Prinzip basieren: Dezentrale Ortung und zentrale Visualisierung. Jede „Radareinheit” (z.B. eine Schildkröte) wird ihre aktuelle Position mithilfe des GPS-Systems ermitteln und diese Information über das drahtlose Netzwerk (Rednet) an den zentralen Radarrechner senden. Der Radarrechner empfängt diese Daten, speichert sie und stellt sie auf dem angeschlossenen Monitor dar.

1. Positionsbestimmung: Jede zu verfolgende Einheit (Schildkröte/Computer) ruft regelmäßig ihre GPS-Koordinaten ab.
2. Datenübertragung: Die Einheit sendet diese Koordinaten zusammen mit einer eindeutigen Kennung über das Rednet an den Radarrechner.
3. Datenempfang: Der Radarrechner lauscht auf eingehende Rednet-Nachrichten und extrahiert die Positionsdaten.
4. Visualisierung: Die empfangenen Positionen werden auf dem Monitor als Punkte oder Symbole dargestellt.
5. Aktualisierung: Dieser Zyklus wird kontinuierlich wiederholt, um eine Echtzeit-Aktualisierung der Positionen zu gewährleisten.

Schritt 1: Das Radarempfänger-Programm (Zentraler Rechner)

Beginnen wir mit dem Programm für den zentralen Rechner, der die Daten empfängt und anzeigt. Nennen wir es radar_server.lua.

Auf Ihrem zentralen Computer öffnen Sie ein Terminal und geben edit radar_server.lua ein.

-- radar_server.lua
-- Zentraler Radarcomputer zur Anzeige von Einheiten

-- Initialisiere Peripheriegeräte
local monitor = peripheral.wrap("top") -- Angenommen, der Monitor ist oben
if monitor == nil then
    print("Fehler: Monitor nicht gefunden. Stellen Sie sicher, dass er oben angebracht ist.")
    return
end

local modem = peripheral.wrap("back") -- Angenommen, das Funkmodem ist hinten
if modem == nil then
    print("Fehler: Funkmodem nicht gefunden. Stellen Sie sicher, dass es hinten angebracht ist.")
    return
end

-- Öffne Rednet für drahtlose Kommunikation
modem.open(1) -- Öffne Rednet auf Kanal 1 (kann beliebig gewählt werden)

-- Globale Variablen
local known_units = {} -- Tabelle zum Speichern der bekannten Einheiten
local center_x, center_y, center_z = 0, 0, 0 -- Die initialen Koordinaten des Radarrechners
local range = 30 -- Der anzuzeigende Radius um den Radarrechner
local scale = 1 -- Skalierungsfaktor für die Anzeige auf dem Monitor (Pixel pro Block)
local refresh_rate = 1 -- Aktualisierungsrate in Sekunden

-- Holen Sie die aktuelle Position des Radarrechners über GPS
-- Stellen Sie sicher, dass Sie GPS-Sender in der Nähe haben
local function get_computer_position()
    local success, x, y, z = gps.locate(5) -- Versuche, die Position innerhalb von 5 Sekunden zu finden
    if success then
        return x, y, z
    else
        print("Fehler: GPS-Position konnte nicht bestimmt werden. Verwende 0,0,0 als Standard.")
        return 0, 0, 0
    end
end

center_x, center_y, center_z = get_computer_position()

-- Funktion zum Zeichnen des Radars auf dem Monitor
local function draw_radar()
    monitor.clear()
    monitor.setTextScale(0.5) -- Kleinere Schrift für mehr Platz
    
    local mon_width, mon_height = monitor.getSize()
    local display_width = mon_width
    local display_height = mon_height - 2 -- Platz für Titel und Statuszeile
    
    -- Zeichne den Rahmen
    for i = 1, display_width do
        monitor.setCursorPos(i, 1)
        monitor.write("-")
        monitor.setCursorPos(i, display_height)
        monitor.write("-")
    end
    for i = 1, display_height do
        monitor.setCursorPos(1, i)
        monitor.write("|")
        monitor.setCursorPos(display_width, i)
        monitor.write("|")
    end
    
    -- Titel
    monitor.setCursorPos(2, 1)
    monitor.write("Computercraft Radar (Range: " .. range .. ")")
    
    -- Zeichne den Radarrechner in der Mitte
    local radar_center_x = math.floor(display_width / 2)
    local radar_center_y = math.floor(display_height / 2)
    monitor.setCursorPos(radar_center_x, radar_center_y)
    monitor.setBackgroundColor(colors.blue)
    monitor.write("C")
    monitor.setBackgroundColor(colors.black)

    -- Zeichne bekannte Einheiten
    for id, unit_data in pairs(known_units) do
        local unit_x = unit_data.x
        local unit_z = unit_data.z -- Wir verwenden X und Z für eine 2D-Karte
        
        -- Berechne relative Position zum Radarrechner
        local rel_x = unit_x - center_x
        local rel_z = unit_z - center_z
        
        -- Prüfe, ob die Einheit innerhalb des Darstellungsbereichs liegt
        if math.abs(rel_x) <= range and math.abs(rel_z)  1 and display_x  1 and display_y < display_height then
                monitor.setCursorPos(display_x, display_y)
                monitor.setBackgroundColor(colors.green)
                monitor.write("T") -- Oder einen anderen Buchstaben/Symbol für Turtle/Unit
                monitor.setBackgroundColor(colors.black)
            end
        end
    end
    
    -- Statuszeile
    monitor.setCursorPos(2, mon_height)
    monitor.write("Einheiten: " .. #known_units .. " | Letzte Aktualisierung: " .. os.time())
end

-- Hauptschleife
while true do
    -- Empfange Rednet-Nachrichten
    local event, p_side, p_channel, message, distance = os.pullEvent("rednet_message")
    
    if event == "rednet_message" and p_channel == 1 then -- Prüfe, ob es unser Kanal ist
        local success, unit_data = pcall(textutils.unserializeJSON, message)
        if success and unit_data and unit_data.id and unit_data.x and unit_data.y and unit_data.z then
            known_units[unit_data.id] = unit_data
        end
    end

    -- Aktualisiere das Radar nur alle 'refresh_rate' Sekunden
    if os.time() % refresh_rate == 0 then
        draw_radar()
    end
    
    sleep(0.1) -- Kurze Pause, um CPU-Last zu reduzieren
end

Erklärung des Codes für den Radarrechner:

• peripheral.wrap("top"): Verbindet sich mit dem Monitor, der oben am Computer angebracht ist. Passen Sie „top” an, wenn Ihr Monitor woanders ist (z.B. „front”, „left”, etc.).
• peripheral.wrap("back"): Verbindet sich mit dem Funkmodem, das hinten am Computer angebracht ist.
• modem.open(1): Öffnet das Rednet auf Kanal 1. Alle zu verfolgenden Einheiten müssen auf demselben Kanal kommunizieren.
• gps.locate(5): Versucht, die aktuelle Position des Radarrechners zu ermitteln. Dies ist wichtig, um relative Positionen der Einheiten korrekt anzuzeigen.
• known_units = {}: Eine Tabelle, die die Daten aller verfolgten Einheiten speichert. Der Schlüssel ist die ID der Einheit.
• draw_radar(): Diese Funktion ist für die Darstellung auf dem Monitor verantwortlich.
  • monitor.clear(): Löscht den Monitor vor jeder Aktualisierung.
  • Es wird ein einfacher Rahmen gezeichnet und der Titel „Computercraft Radar” angezeigt.
  • Der Radarrechner selbst wird als ‘C’ in der Mitte des Bildschirms dargestellt.
  • Für jede bekannte Einheit in known_units wird die relative Position berechnet und auf den Monitor skaliert.
  • Einheiten werden als ‘T’ (für Turtle/Einheit) angezeigt.
• Die Hauptschleife while true do ... end:
  • os.pullEvent("rednet_message"): Wartet auf Rednet-Nachrichten.
  • Wenn eine Nachricht auf dem richtigen Kanal empfangen wird, versucht der Code, sie als JSON-String zu deserialisieren.
  • Die deserialisierten Daten (ID, X, Y, Z) werden in der known_units-Tabelle gespeichert.
  • os.time() % refresh_rate == 0: Stellt sicher, dass der Monitor nur alle paar Sekunden aktualisiert wird, um Flackern zu reduzieren und die Performance zu verbessern.
  • sleep(0.1): Eine kurze Pause, um die CPU-Auslastung zu reduzieren.

Schritt 2: Das Sende-Programm (Verfolgte Einheiten)

Als Nächstes benötigen wir ein Programm für die Einheiten, die vom Radar verfolgt werden sollen. Dies kann eine Schildkröte oder ein anderer Computercraft-Computer sein. Nennen wir es radar_client.lua.

Auf jeder Schildkröte oder jedem Computer, den Sie verfolgen möchten, öffnen Sie ein Terminal und geben edit radar_client.lua ein.

-- radar_client.lua
-- Client-Programm für eine verfolgte Einheit

-- Initialisiere Peripheriegeräte
local modem = peripheral.wrap("back") -- Angenommen, das Funkmodem ist hinten
if modem == nil then
    print("Fehler: Funkmodem nicht gefunden. Stellen Sie sicher, dass es hinten angebracht ist.")
    return
end

-- Öffne Rednet für drahtlose Kommunikation
modem.open(1) -- Muss derselbe Kanal sein wie beim Radarserver

-- Eindeutige ID für diese Einheit (z.B. die Computer-ID)
local unit_id = os.getComputerID()
print("Client gestartet mit ID: " .. unit_id)

-- Schleife zum Senden der Position
while true do
    -- Versuche, die aktuelle GPS-Position zu finden
    local success, x, y, z = gps.locate(5) -- Zeitlimit 5 Sekunden
    
    if success then
        local unit_data = {
            id = unit_id,
            x = x,
            y = y,
            z = z
        }
        
        -- Serialisiere die Daten in einen JSON-String
        local message = textutils.serializeJSON(unit_data)
        
        -- Sende die Position an den Radarserver
        -- Angenommen, der Server lauscht auf Kanal 1
        rednet.broadcast(message, 1) 
        
        print("Position gesendet: X:" .. x .. " Y:" .. y .. " Z:" .. z)
    else
        print("GPS-Position konnte nicht ermittelt werden.")
    end
    
    sleep(5) -- Sende alle 5 Sekunden die Position
end

Erklärung des Codes für die verfolgte Einheit:

• peripheral.wrap("back"): Verbindet sich mit dem Funkmodem.
• modem.open(1): Öffnet das Rednet auf Kanal 1. Wichtig: Dies muss derselbe Kanal sein, den Sie im radar_server.lua-Programm verwendet haben.
• unit_id = os.getComputerID(): Jede Einheit erhält die eindeutige ID ihres Computers oder ihrer Schildkröte. Dies ist entscheidend, damit der Server die Einheiten unterscheiden und deren Positionen aktualisieren kann.
• Die Hauptschleife while true do ... end:
  • gps.locate(5): Ermittelt die aktuelle Position der Einheit.
  • Die Positionsdaten (X, Y, Z) und die unit_id werden in einer Lua-Tabelle gesammelt.
  • textutils.serializeJSON(unit_data): Wandelt die Lua-Tabelle in einen JSON-String um. Dies ist eine standardisierte Methode, um komplexe Daten über Rednet zu senden.
  • rednet.broadcast(message, 1): Sendet die JSON-Nachricht an alle auf Kanal 1 lauschenden Computer.
  • sleep(5): Die Einheit sendet ihre Position alle 5 Sekunden. Passen Sie dies nach Bedarf an (höhere Frequenz = aktuellere Daten, aber mehr Netzwerkverkehr und CPU-Last).

Einrichtung und Test

1. GPS-Sender platzieren: Für eine zuverlässige GPS-Ortung sollten Sie mehrere GPS-Sender (mindestens 3 für 3D-Ortung) in einem gewissen Abstand zueinander und zum Bereich, in dem Ihre Einheiten arbeiten, platzieren. Je mehr Sender, desto besser.
2. Radarrechner aufstellen: Platzieren Sie Ihren zentralen Computer, den Advanced Monitor (z.B. oben am Computer) und das Funkmodem (z.B. hinten am Computer).
3. Programme installieren: Kopieren Sie radar_server.lua auf den zentralen Computer und radar_client.lua auf jede Schildkröte oder jeden Computer, den Sie verfolgen möchten.
4. Programme starten:
   • Auf dem zentralen Rechner: Geben Sie radar_server ein und drücken Sie Enter. Das Radar sollte starten und versuchen, seine eigene Position zu bestimmen.
   • Auf jeder Schildkröte/jedem Client-Computer: Geben Sie radar_client ein und drücken Sie Enter. Die Clients sollten beginnen, ihre Positionen zu senden.

Sie sollten nun sehen, wie auf dem Monitor des zentralen Radarrechners Punkte (Ihre Schildkröten/Clients) erscheinen und sich bewegen, sobald sich die Clients in der Welt fortbewegen. Der zentrale Computer wird als „C” und die Clients als „T” dargestellt.

Erweiterungen und Optimierungen

Das hier vorgestellte Radar ist eine Basiskonfiguration. Hier sind einige Ideen für Erweiterungen und Optimierungen:

• Anzeige von Y-Koordinate/Höhe: Aktuell wird nur eine 2D-Karte (X und Z) dargestellt. Sie könnten die Y-Koordinate als Text neben dem Symbol anzeigen oder eine Farbskala verwenden, um Höhenunterschiede zu visualisieren.
• Einheiten-Namen: Anstatt nur die Computer-ID zu verwenden, könnten Sie jeder Einheit einen benutzerdefinierten Namen zuweisen, der dann auf dem Radar angezeigt wird (z.B. „Miner 1”, „Farmer B”). Fügen Sie dafür einfach ein Feld name = "Mein Name" zur unit_data in radar_client.lua hinzu und zeigen Sie es im draw_radar-Teil an.
• Filterung und Anzeigeoptionen: Implementieren Sie eine Benutzeroberfläche (z.B. über Tastatureingaben), um die Reichweite (range) zu ändern, bestimmte Einheiten zu filtern oder die Aktualisierungsrate anzupassen.
• Alarmfunktionen: Wenn eine Einheit einen bestimmten Bereich verlässt oder betritt, könnte das Radar einen Ton abspielen oder eine Redstone-Ausgabe aktivieren.
• Persistent Speicherung: Speichern Sie die bekannten Einheiten und ihre letzten Positionen in einer Datei, damit diese nach einem Neustart des Radarrechners nicht verloren gehen. Nutzen Sie dafür fs.open() und textutils.serializeJSON() zum Speichern und Laden.
• Grafische Verbesserungen: Mit monitor.setBackgroundColor() und monitor.setTextColor() können Sie Farben nutzen, um verschiedene Einheiten oder Status darzustellen. Sie könnten auch versuchen, komplexere Symbole zu zeichnen.
• Effizienz: Für sehr viele Clients (20+) könnte das Senden und Empfangen von Nachrichten zu einer Belastung werden. Optimierungen wie das Senden nur bei Positionsänderung oder die Verwendung von dezidierten Kommunikationskanälen für Gruppen von Clients können helfen.
• Multi-Channel Rednet: Wenn Sie viele verschiedene Radarsysteme oder Client-Typen haben, sollten Sie verschiedene Rednet-Kanäle verwenden, um Konflikte zu vermeiden.

Herausforderungen und Grenzen

Wie bereits erwähnt, hat dieses Computercraft Radar einige inhärente Grenzen, die primär aus den Funktionalitäten der Computercraft-Mod selbst resultieren:

• Keine Mobs/Spieler-Erkennung: Das Radar kann keine unkontrollierten Mobs oder andere Spieler direkt auf einer Karte anzeigen. Es verfolgt nur Computercraft-Geräte, die aktiv ihre Position über Rednet senden. Für Mobs/Spieler bräuchten Sie zusätzliche Mods oder sehr ausgeklügelte Redstone-Detektoren in Kombination mit Computercraft.
• GPS-Genauigkeit: Die Genauigkeit der GPS-Ortung hängt von der Anzahl und Platzierung Ihrer GPS-Sender ab. In abgelegenen Bereichen oder ohne ausreichende Sender können die Positionsdaten ungenau oder gar nicht verfügbar sein.
• Reichweite des Funkmodems: Funkmodems haben eine begrenzte Reichweite. Wenn Ihre Einheiten zu weit entfernt sind, müssen Sie möglicherweise Repeater-Stationen mit zusätzlichen Computern und Modems aufstellen, um die Kommunikation zu überbrücken.
• Performance: Viele Einheiten, die häufig ihre Position senden, können die Performance des Servers oder des Radarrechners beeinträchtigen. Optimierungen sind hier wichtig.

Fazit

Der Bau eines Computercraft Radars ist ein hervorragendes Projekt, um die Leistungsfähigkeit von Computercraft und der Programmiersprache Lua zu erkunden. Es vermittelt Ihnen nicht nur praktische Fähigkeiten im Umgang mit Peripheriegeräten, Rednet-Kommunikation und GPS, sondern gibt Ihnen auch ein mächtiges Werkzeug an die Hand, um Ihre Minecraft-Automatisierung zu überwachen und zu steuern.

Auch wenn es keine direkte „Mob-Ortung” bietet, ist die Fähigkeit, Ihre eigenen automatisierten Einheiten zu verfolgen, von unschätzbarem Wert für jede größere Minecraft-Basis. Nehmen Sie die bereitgestellten Codebeispiele als Startpunkt, experimentieren Sie, passen Sie sie an Ihre Bedürfnisse an und lassen Sie Ihrer Kreativität freien Lauf. Das Computercraft Radar ist nur der Anfang dessen, was Sie mit ein wenig Code und Vorstellungskraft in Ihrer Minecraft-Welt erreichen können. Behalten Sie den Überblick – Ihre Projekte werden es Ihnen danken!