April 02, 2026

Rückblick auf das Vitra Projekt SFB 314

Deutschland gilt in der KI Szene als rückständig, innovationsfeindlich und dominiert von philosophischen Debatten anstatt technischer Projekte. Es gibt jedoch davon durchaus Ausnahmen wie das Vitra Projekt was im Jahr 1987 von Wolfgang Wahlster durchgeführt wurde. Vitra steht für "visual translator" und war ein Großforschungsprojekt im Umfang von 50 Mio DM was erstmalig Bilderkennung und Sprache kombinierte. Technisch wurde es auf VAX Minicomputern und Symbolics Workstations realisiert.

Aus heutiger Sicht würde man Vitra als "Vision language model (VLM)" definieren, nur das es damals nicht mit neuronalen Netzen arbeitete, sondern mit händisch erstelltem Lisp Sourcecode. Ähnlich wie die Zuse Z3 aus dem Jahr 1941 war das Vitra Projekt konkurrenzfähig oder sogar leicht überlegen der US amerikanischen Spitzenforschung.

Die Hauptkritikpunkt an Vitra war, dass es zu teuer war. Man verwendete Großrechner um in Echtzeit Videobilder zu analysieren. Auch die Lisp Programmiersprache war ein Kostenfaktor, weil man Spezialisten benötigte, die Lisp programmieren können. Dieses Konzept, bestehend aus VAX Rechnern, Lisp und Livekameras, kann man nicht hochskalieren zu noch mehr Komplexität, sondern Vitra war eine Art von Dinosaurier, der eine Sackgasse darstellte.

Aus heutiger Sicht würde man viel kleinere Forschungsprojekte durchführen. Man würde nicht Lisp sondern Python wählen und man würde keine Videobilder von Kameras parsen sondern lediglich Screenshots von Videospielen analysieren. Damit könnte der Aufwand zur Realisierung auf ein Bruchteil gesenkt werden.


April 01, 2026

Mülltrennung als Computerspiel

Hier ist ein Lernspiel für Jung und Alt bei dem es um Mülltrennung geht. Der Spieler muss mittels drag&drop mögliche Items in die korrekte Tonne werfen. Viel Vergnügen.

import pygame
import random

# Initialisierung
pygame.init()

# Fenster-Einstellungen
WIDTH, HEIGHT = 900, 650 # Etwas breiter für die 5. Tonne
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Müll-Profi: Jetzt auch mit Glas!")

# Farben
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
BLUE = (0, 102, 204)    # Papier
YELLOW = (255, 204, 0)  # Verpackung
BROWN = (102, 51, 0)    # Bio
GRAY = (50, 50, 50)     # Restmüll
DARK_GREEN = (0, 100, 0) # Glas
LIGHT_GREEN = (0, 255, 0) # Feedback Richtig
RED = (255, 0, 0)       # Feedback Falsch

# Schriftarten
font = pygame.font.SysFont("Arial", 22, bold=True)
title_font = pygame.font.SysFont("Arial", 36, bold=True)

# Erweiterte Müll-Daten (Insgesamt 22 Items)
# Erweiterte Müll-Daten (Jetzt insgesamt 42 Items!)
WASTE_ITEMS = {
    # PAPIER (Blau) - Nur sauberes Papier!
    "Zeitungen": BLUE, "Karton": BLUE, "Schulheft": BLUE, "Prospekte": BLUE,
    "Briefumschlag": BLUE, "Eierkarton": BLUE, "Mehltüte (leer)": BLUE, "Geschenkpapier": BLUE,
    
    # GELBER SACK / TONNE (Gelb) - Verpackungen aus Plastik, Metall, Verbundstoff
    "Getränkedose": YELLOW, "Plastetüte": YELLOW, "Joghurtbecher": YELLOW, 
    "Milchtüte": YELLOW, "Alufolie": YELLOW, "Shampooflasche": YELLOW,
    "Konservendose": YELLOW, "Butterfolie": YELLOW, "Kronkorken": YELLOW,
    "Styropor": YELLOW, "Chipsdose": YELLOW,
    
    # BIO (Braun) - Organisches
    "Apfelrest": BROWN, "Bananenschale": BROWN, "Kaffeesatz": BROWN, 
    "Eierschalen": BROWN, "Rasenschnitt": BROWN, "Teebeutel": BROWN,
    "Orangenschale": BROWN, "Kartoffelschalen": BROWN, "Welke Blumen": BROWN,
    
    # RESTMÜLL (Grau) - Alles Verschmutzte oder Nicht-Verwertbare
    "Zahnbürste": GRAY, "Windel": GRAY, "Staubsaugerbeutel": GRAY, 
    "Asche": GRAY, "Zigarette": GRAY, "Pizzakarton (fettig)": GRAY,
    "Backpapier": GRAY, "Kaugummi": GRAY, "Putzlappen": GRAY,
    "Katzenstreu": GRAY, "Alte Fotos": GRAY,
    
    # GLAS (Grün) - Behälterglas (kein Trinkglas/Fensterglas!)
    "Weinflasche": DARK_GREEN, "Marmeladenglas": DARK_GREEN, "Senfglas": DARK_GREEN,
    "Ölflasche (Glas)": DARK_GREEN, "Parfümflakon": DARK_GREEN
}

class Bin:
    def __init__(self, color, x, label):
        self.rect = pygame.Rect(x, HEIGHT - 160, 140, 140)
        self.color = color
        self.label = label

class DraggableItem:
    def __init__(self, text, target_color):
        self.text = text
        self.target_color = target_color
        self.reset_position()
        self.dragging = False
        
    def reset_position(self):
        self.rect = pygame.Rect(WIDTH // 2 - 75, 180, 150, 45)

# 5 Tonnen erstellen
bins = [
    Bin(BLUE, 30, "Papier"),
    Bin(YELLOW, 200, "Gelber Sack"),
    Bin(BROWN, 375, "Bio"),
    Bin(DARK_GREEN, 550, "Glas"),
    Bin(GRAY, 725, "Restmüll")
]

# Spiel-Variablen
score = 0
feedback_text = "Zieh das Wort in die richtige Tonne!"
feedback_color = BLACK

def get_new_item():
    name = random.choice(list(WASTE_ITEMS.keys()))
    return DraggableItem(name, WASTE_ITEMS[name])

current_item = get_new_item()

running = True
while running:
    screen.fill((240, 240, 240)) # Hellgrauer Hintergrund
    
    # UI Zeichnen
    title = title_font.render("Müll-Sortier-Station", True, BLACK)
    screen.blit(title, (WIDTH//2 - title.get_width()//2, 30))
    
    score_display = font.render(f"Punkte: {score}", True, BLACK)
    screen.blit(score_display, (30, 30))

    # Tonnen zeichnen
    for b in bins:
        pygame.draw.rect(screen, b.color, b.rect, border_radius=8)
        # Beschriftung der Tonne
        txt_color = WHITE if b.color != YELLOW else BLACK
        txt = font.render(b.label, True, txt_color)
        screen.blit(txt, (b.rect.centerx - txt.get_width()//2, b.rect.y + 55))

    # Aktuelles Item zeichnen
    if not current_item.dragging: # Schatten-Effekt wenn nicht gezogen
        pygame.draw.rect(screen, (200, 200, 200), current_item.rect.move(3, 3), border_radius=10)
    
    pygame.draw.rect(screen, WHITE, current_item.rect, border_radius=10)
    pygame.draw.rect(screen, BLACK, current_item.rect, 3, border_radius=10)
    item_txt = font.render(current_item.text, True, BLACK)
    screen.blit(item_txt, (current_item.rect.centerx - item_txt.get_width()//2, current_item.rect.y + 10))

    # Feedback
    f_txt = font.render(feedback_text, True, feedback_color)
    screen.blit(f_txt, (WIDTH//2 - f_txt.get_width()//2, 120))

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
            
        elif event.type == pygame.MOUSEBUTTONDOWN:
            if current_item.rect.collidepoint(event.pos):
                current_item.dragging = True
                mouse_x, mouse_y = event.pos
                offset_x = current_item.rect.x - mouse_x
                offset_y = current_item.rect.y - mouse_y

        elif event.type == pygame.MOUSEBUTTONUP:
            if current_item.dragging:
                current_item.dragging = False
                hit_bin = False
                for b in bins:
                    if current_item.rect.colliderect(b.rect):
                        if b.color == current_item.target_color:
                            score += 10
                            feedback_text = f"Richtig! {current_item.text} gehört in {b.label}."
                            feedback_color = LIGHT_GREEN
                        else:
                            score -= 5
                            feedback_text = f"Falsch! {current_item.text} ist kein {b.label}!"
                            feedback_color = RED
                        
                        current_item = get_new_item()
                        hit_bin = True
                        break
                
                if not hit_bin:
                    current_item.reset_position()

        elif event.type == pygame.MOUSEMOTION:
            if current_item.dragging:
                mouse_x, mouse_y = event.pos
                current_item.rect.x = mouse_x + offset_x
                current_item.rect.y = mouse_y + offset_y

    pygame.display.flip()

pygame.quit()
 

AI without programming

Computer science is mostly organized around programming languages. There are imperative languages like C, there are object oriented language like Java and there are modern languages like Python. A common strategy was to implement artificial intelligence in a programming language. The reason is, that a computer which is running a program is the most powerful and often the only tool available in computer science. So the assumption was, that this workflow can be adapted towards artificial intelligence.

Unfortunately, this concept doesn't work in reality. Even many AI related projects were implemented in C++ and lots of industrial robots were programmed in a robot programming language the concept of implementing AI in a programming language is a dead end. Even high level languages like Python doesn't provide the needed elements or libraries needed for making a computer smart. A computer program will run only in a predefined fashion which is the opposite of adaptive systems which are able to solve complex tasks.

The answer to the challenge is to avoid programming languages at all and imagine Artificial intelligence in a non computer science perspective. Instead of asking how to implement AI on a computer the new question is who can humans communicate with robots. This question goes beyond software engineering but it asks for protocols similar to TCP/IP. Implementing a communication protocol in C or in Python is only a detail problem and can be ignored in most AI related projects.

The computer shouldn't be described as a computational machine but as a message transceiver. There are incoming messages from a human and there are outgoing messages back to the human. Artificial intelligence means to formalize this process with a protocol, with a vocabulary and with a grammar. This task can't be described in classical software paradigm but it has to do with protocol design and inventing a domain specific language.

Let me give an example. Suppose the goal is to create a warehouse robot. Such a robot will needed a list of nouns like "obstacle, path, battery, box, barcode" and the robot will need a list of verbs like "stop, forward, rotate, scan, grasp". These nouns and verbs can be combined into sentences and some adjectives may help to communicate in difficult situations. Computer science and especially software engineering is the wrong discipline to describe the robot's vocabulary but it has more in common with linguistics not related to computing anymore.

March 30, 2026

Grounded text to action for playing Maniac Mansion

 In addition to the previous attemps to play the point&click adventure Maniac mansion with a large language model here is a more compressed repreentation. Its a 3 column table with a timecode, a textual desription, and low level mouse actions.

The textual description is located on the information layer of the DIWK pyramid, while the mouse movements are on the bottom data layer.

Timecode    Textual Description    ScummVM Mouse Movements / Interaction
00:05    Select Character: Bernard    Move cursor to Bernard's portrait (bottom right); Left-Click.
00:08    Move to Front Gate    Move cursor to far right of driveway; Left-Click.
00:15    Walk to Front Door    Move cursor to porch steps; Left-Click.
00:20    Action: "Pull" Door Mat    Click "Pull" (verb pane); Click "Door Mat" (on porch floor).
00:24    Action: "Get" House Key    Click "Get" (verb pane); Click "Entrance Key" (revealed on floor).
00:28    Action: "Use" Key on Door    Click "Use"; Click Key (inventory); Click "Front Door".
00:32    Enter Mansion (Main Hall)    Move cursor to open doorway; Left-Click.
00:40    Action: "Get" Flashlight    Walk to the small table near the stairs; Click "Get"; Click "Flashlight".

The main task for the sofrware is translation. A high level textual description gets converted into low level action. E.g.:
textual description= Action: Use Key on Door
mouse movement=Click "Use"; Click Key (inventory); Click "Front Door".

In other words the DIKW pyramid is mostly an abstraction mechanism which consists of different details for the same task. The AI for playing Maniac Mansion hasn't decide anything, but the AI takes a textual description as input and generates low level mouse movements as output.

Here is the workflow how to play the game with an AI. The human user has to provide the textual description what to do in each scene. For example the human enters "walk to front door". This input command is converted by the computer into mouse actions on the screen and executed by the computer. So the Maniac Mansion game gets teleoperated with an advanced textual interface. This interface reduces the workload for the human operator. He is no longer forced to move the mouse directly on the verbs and the objects, but the human enters text into the command line.

Its a bit complicated to explain why such a DIWK workflow works in reality. From a technical perspective, natural language was utilized as an abstraction mechanis to reduce complexity. Instead of solving the original task of moving the mouse on the screen and click on items, the new task to provide a textual walk through which gets converted automatically into mouse movemens.

This abstraction mechanism works only because natural language, here English, is a powerful tool. It provides all the needed vocabulary including grammar to formulate complex tasks. There is no need to develop computer algorithm, neural networks or cognitive architectures, but natural language itself is the asset for enabling artificial intelligence. 

March 28, 2026

Human to robot interaction with a dikw pyramid

Maniac Mansion is a well known point&click adventure. With the help of a walk through tutorial its possible to win the game. The standard tutorial consists of keypoints and full sentences written in English which can be read by humans but can't be executed by a computer. With a converter from high level to a low level layer its possible to transform the walk through tutorial into machine readable commands. The process is demonstrated with the following json code adressing the kitchen scene:

{
  "card_id": "MM_KITCHEN_01",
  "scene_title": "The Mansion Kitchen - ScummVM Navigation",
  "content": {
    "textual_description": {
      "objective": "Enter the kitchen to retrieve the Small Key from the counter while staying alert for Nurse Edna.",
      "key_points": [
        "The kitchen is located through the first door on the right in the main hallway.",
        "Crucial Item: The Small Key is sitting on the counter near the sink.",
        "Hazard: Opening the refrigerator triggers a cutscene/event that can lead to capture.",
        "Exit Strategy: Use the door to the far right to enter the Dining Room if the hallway is blocked."
      ]
    },
    "low_level_representation": {
      "engine_context": "ScummVM - 320x200 Resolution (Original Scale)",
      "mouse_interactions": [
        {
          "step": 1,
          "verb_action": "PICK UP",
          "verb_coordinates": { "x": 40, "y": 175 },
          "target_object": "Small Key",
          "target_coordinates": { "x": 165, "y": 115 },
          "result": "Key added to character inventory."
        },
        {
          "step": 2,
          "verb_action": "WALK TO",
          "verb_coordinates": { "x": 10, "y": 165 },
          "target_location": "Dining Room Door",
          "target_coordinates": { "x": 305, "y": 110 },
          "result": "Character transitions to the next room."
        }
      ],
      "safety_note": "Avoid clicking 'OPEN' (x: 10, y: 175) on the Refrigerator (x: 240, y: 90) unless you have a specific distraction planned."
    }
  }
}


Both layers (low level and high level) are describing the same scene which is to enter the kitchen and fetch the key. The difference is, that that the layers have a different abstraction level. The high level layer is prefered by humans and mirrors how humans are thinking and how they are using language. In contrast, the low level layer is prefered by machines who are programmed with a logic oriented mathematical notation.

The converter has the task to translate between these layer which is known as the symbol grounding problem. Solving the grounding problem means to improve human to machine interaction.

Solving the first scene in Maniac Mansion with a DIKW pyramid

 Symbol grounding means basically to convert abstract description into detailed description. A concrete example with 3 layers for the first scene of the point&click adventure Maniac Mansion is shown next. The textual description can be understood by a human easily but can't be submitted directly to a computer. In contrast, the low level "pyautogui_commands" are hard to read for a human but can be processed by a computer program with ease.

Symbol grounding means basically that an algorithm converts high level descripiton into low level commands. With such a grounding algorithm its possible to script the game by providing textual description and the Artificial intelligence converts these description into mouse movements which are submitted to the SCUMMVM engine.

{
  "notecard_id": 1,
  "scene_title": "The Front Yard",
  "content": {
    "textual_description": {
      "objective": "Gain entry to the Edison Mansion.",
      "key_points": [
        "Start with Dave outside the main gate.",
        "Walk toward the front door of the mansion.",
        "The door is locked; the key is hidden nearby.",
        "Look under the doormat to find the silver key.",
        "Use the key to unlock the door and enter."
      ]
    },
    "low_level_representation": {
      "resolution_reference": "800x600",
      "actions": [
        {
          "step": 1,
          "action": "Select Verb: WALK TO",
          "pixel_coords": [120, 480],
          "note": "Clicking the 'Walk to' verb in the UI tray."
        },
        {
          "step": 2,
          "action": "Target: Front Door",
          "pixel_coords": [400, 300],
          "note": "Moving the character to the mansion entrance."
        },
        {
          "step": 3,
          "action": "Select Verb: PULL",
          "pixel_coords": [250, 480],
          "note": "Preparing to move the mat."
        },
        {
          "step": 4,
          "action": "Target: Doormat",
          "pixel_coords": [400, 420],
          "note": "Revealing the hidden key."
        },
        {
          "step": 5,
          "action": "Select Verb: PICK UP",
          "pixel_coords": [50, 520],
          "note": "Collecting the key."
        }
      ]
    },
    "pyautogui_commands": [
      "import pyautogui",
      "pyautogui.PAUSE = 0.5",
      "# Walk to door",
      "pyautogui.click(120, 480)",
      "pyautogui.click(400, 300)",
      "# Pull mat",
      "pyautogui.click(250, 480)",
      "pyautogui.click(400, 420)",
      "# Pick up key",
      "pyautogui.click(50, 520)",
      "pyautogui.click(405, 425)"
    ]
  }
}

March 27, 2026

Abstieg in der DIKW Pyramide am Beispiel Zak mckracken

 Damit ein Large language model ein Videospiel automatisiert durchspielt braucht es mehrere Ebenen aus der DIKW Pyramide. Auf layer 3 (knowledge) wird eine Spielszene in Stichpunkten beschrieben auf einer sehr hohen Abstraktionsschicht. Dies wird dann in den layer2 übersetzt, der viel präziser ist aber weniger leicht zu lesen für einen Menschen und schlußendlich auf den Layer1 transformiert der die low level Daten Ebene darstellt. Der Layer1 kann dann an die Game engine gesendet werden, also an die ScummVM welche das point&click adventure ausführt.

Hier alle 3 layer der DIKW pyramide in einer übersichtlichen json notation.

{
  "game": "Zak McKracken and the Alien Mindbenders",
  "card_id": 1,
  "title": "Morgenroutine in San Francisco",

  "representation_1_natural_language": {
    "format": "Karteikarte (Menschlich)",
    "content": [
      "Wache in Zaks Schlafzimmer auf.",
      "Nimm das Aquarium-Netz unter dem Bett.",
      "Gehe ins Wohnzimmer und nimm die Fernbedienung vom Fernseher.",
      "Gehe in die Küche.",
      "Nimm das stumpfe Brotmesser aus der Spüle.",
      "Öffne den Kühlschrank und nimm das Ei."
    ]
  },

  "representation_2_intermediate_logic": {
    "format": "Text-to-Action Reasoning (Zwischenschritt)",
    "note": "Hier werden implizite Aktionen und Raumwechsel für die KI logisch explizit gemacht.",
    "logic_chain": [
      {"state": "Room: Bedroom", "goal": "Inventory: Fishnet", "sub_action": "PickUp(Fishnet, under_bed)"},
      {"state": "Room: Bedroom", "goal": "Change Room", "sub_action": "WalkTo(Door_West)"},
      {"state": "Room: Living Room", "goal": "Inventory: Remote", "sub_action": "PickUp(Remote_Control, on_TV)"},
      {"state": "Room: Living Room", "goal": "Change Room", "sub_action": "WalkTo(Door_North)"},
      {"state": "Room: Kitchen", "goal": "Inventory: Knife", "sub_action": "PickUp(Bread_Knife, in_Sink)"},
      {"state": "Room: Kitchen", "goal": "Access Fridge", "sub_action": "Open(Refrigerator)"},
      {"state": "Room: Kitchen", "goal": "Inventory: Egg", "sub_action": "PickUp(Egg, inside_Fridge)"}
    ]
  },

  "representation_3_low_level_scumm": {
    "format": "SCUMM Engine Executable (Low Level)",
    "note": "Direkte Opcode-artige Anweisungen, die Objekten IDs und Verben zuordnen (fiktive IDs).",
    "commands": [
      {"op": "CUTSCENE_START"},
      {"op": "PICK_UP", "obj_id": 142, "comment": "Fishnet"},
      {"op": "WALK_TO_OBJECT", "obj_id": 201, "comment": "Door to Living Room"},
      {"op": "PICK_UP", "obj_id": 155, "comment": "Remote Control"},
      {"op": "WALK_TO_OBJECT", "obj_id": 202, "comment": "Door to Kitchen"},
      {"op": "PICK_UP", "obj_id": 160, "comment": "Bread Knife"},
      {"op": "OPEN", "obj_id": 175, "comment": "Refrigerator"},
      {"op": "PICK_UP", "obj_id": 176, "comment": "Egg"},
      {"op": "CUTSCENE_END"}
    ]
  }
}

 

Das interessante an dem Ansatz ist die Abwesenheit einer künstlichen Intelligenz im klassischen Sinne. Es gibt also kein neuronales Netz oder einen Reinforcement Learning algorithmus welches das Spiel durchspielt sondern die KI wurde so implementiert, dass sie zwischen den layern der DIWK pyramide eine Übersetzung ausführt. Wenn man möchte dass im Videospiel eine andere Aktion ausgeführt wird, schreibt man in den obersten Layer andere Stichworte hinein, die werden dann in echtzeit in die unteren Layer transformiert und ausgeführt. Das prinzip ist vergleichbar mit Unix pipes, also einer Filterkaskade die input in output übersetzt. 

LLMs als ingame AI

Large language modelle genießen eine große Popularität doch bisher wird dessen Potential nur teilweise ausgeschöpft. So finden LLM ihren Einsatz als Suchmaschine, zum Programmieren oder um Fragen zu beantworten. Hingegen werden sie kaum bis gar nicht eingesetzt um Computerspiele automatisiert durchzuspielen. Zwar gibt es neuere Entwicklungen wie Deepmind Sima 2, was durchaus in der Lage ist innerhalb von virtuellen Welten zu agieren, doch ist der Tokenverbrauch hoch und es gibt nur wenige Dokumentationen dazu.

Heutige LLM sind durchaus imstande in virtuellen Welten zu agieren. Als Beispiel sei hier eine stichpunktartige Komplettlösung für das Maniac Mansion Point&click adventure gegeben welche durch ein LLM from scratch erzeugt wurde:

Karte 1: Start
    Team-Wahl: Empfohlen: Syd oder Razor (Musik-Talent) + Bernard (Technik).
    Eingang: Gehe zum Haus. Unter der Fußmatte liegt der Türschlüssel.
    Eingangshalle: Benutze Schlüssel mit Haustür. Drinnen: Vorsicht vor Edna oder Weird Ed! Wenn sie kommen, schnell in einen Nebenraum flüchten.
    Küche: Gehe nach rechts durch die Tür. Nimm das Fleisch aus dem Kühlschrank und die Getränkedose (für später).

Karte 2: Das Gefängnis & Der Fluchtplan
    Trigger: Wenn ein Charakter geschnappt wird, landet er im Kerker.
    Ausbruch: Drücke den losen Stein an der Wand (links neben der Tür), um die Tür kurz zu öffnen.
    Taktik: Nutze einen Charakter als „Köder“, um die Edisons abzulenken, während die anderen zwei das Haus erkunden.
    Wichtig: Speichere oft! Ein falscher Schritt führt zum Game Over.

Karte 3: Die Vorräte im Erdgeschoss
    Esszimmer: Nimm die Früchte von der Schüssel.
    Speisekammer: Nimm den Glasschneider (hinter der Glasvitrine) und den Saft.
    Wohnzimmer: Benutze die Kassette mit dem Kassettenrekorder (wichtig für später, um das Glas zu zerschmettern).
    Bibliothek: Öffne die Lampe, um das Zimmer zu erhellen. Nimm den Loseblatt-Katalog.

Karte 4: Weird Eds Zimmer (1. Stock)
    Vorsicht: Wenn Ed dich sieht, fliegst du raus.
    Ablenkung: Warte, bis Ed sein Zimmer verlässt (um das Paket zu holen) oder nutze die Türklingel an der Haustür, um ihn runterzulocken.
    Gegenstand: Nimm den Hamster (nur als Razor/Syd relevant für böse Enden) und das Sparschwein. Brich das Schwein auf, um Geld zu erhalten.
    Schlüssel: Nimm den Schlüssel vom Nachttisch.

Karte 5: Das Musikzimmer & Die Glasplatte
    Vorbereitung: Geh ins Musikzimmer (1. Stock).
    Aktion: Benutze den Glasschneider mit der Vitrine, um die Kassette zu stehlen.
    Klavier: Wenn du Razor oder Syd bist, kannst du hier spielen, aber das Ziel ist die Schallplatte im Zimmer daneben.
    Tipp: Du musst die Schallplatte auf den Rekorder im Wohnzimmer legen und aufnehmen, um später das Fenster im Labor zu sprengen.

Karte 6: Das Schwimmbad (Außenbereich)
    Gefahr: Das Wasser ist radioaktiv! Nicht hineingehen.
    Aktion: Leere das Becken, indem du das Ventil im Keller (unter der Küche) benutzt.
    Fundstück: Am Boden des leeren Beckens liegt der leuchtende Schlüssel.
    Wichtig: Fülle das Becken sofort wieder auf, da sonst der Reaktor überhitzt (Game Over Timer startet!).

Karte 7: Der Grüne Tentakel
    Ort: 2. Stock, Weg zum Dachboden.
    Problem: Der Grüne Tentakel hat Hunger und lässt dich nicht vorbei.
    Lösung: Gib ihm den Obstteller aus dem Esszimmer und den Saft (oder die Cola).
    Ergebnis: Er wird dein Freund und lässt dich passieren. Du hast nun Zugang zu den oberen Räumen und dem Funkgerät.

Karte 8: Das Paket & Das Telefon
    Paket: Wenn die Türklingel läutet, renne mit einem Charakter zur Haustür und schnapp dir das Paket, bevor Ed es bekommt.
    Inhalt: Briefmarken.
    Telefon: Benutze das Telefon im Arbeitszimmer. Wähle die Nummer vom „Metzger“ (findest du im Loseblatt-Katalog), um Edna abzulenken.
    Nächster Schritt: Während Edna telefoniert, schleiche in ihr Zimmer, um den Schlüssel zum Labor zu finden.
    
Diese Anleitung gibt in natürlicher Sprache einen Ablauf vor um das Spiel erfolgreich zu spielen. Einziges Problem bei dieser Anleitung ist, dass es kein ausführbarer Computer code ist sondern an menschliche Leser adressiert wurde. In der DIKW pyramide ist die Komplettlösung also auf dem Layer 3 (knowledge) angesiedelt. Damit eine KI Maniac Mansion automatisiert durchspöielen kann, muss man die Anleitung auf eine niedrige DIKW Stufe übersetzen also auf Stufe 2 und Stufe 1 (Daten).

Sowas wird über ein Text to action model realisiert. DAs erhält eine Karteikarte als Input und erzeugt dafür die Mausbewegung als Ausgabe.

Hier die simulierten Mausbewegungen für Karteikarte #1 innerhalb der SCUMM-Engine bei einer Auflösung von 320x200 Pixeln. Das json file enthält dieselben Anweisungen wie die textuelle Komplettlösung auch nur mit dem Unterschied dass es nicht auf dem DIKW layer 3 sondern auf dem untersten Layer 1 angesiedelt ist. Als Folge gibt es numerische Koordinaten die definieren wo genau der Mauscursor hinbewegt wird.

{
  "card_id": 1,
  "title": "Start",
  "steps": [
    {
      "action_order": 1,
      "description": "Walk to the front door area",
      "command": "WALK_TO",
      "target_coords": {"x": 160, "y": 140},
      "wait_ms": 2000
    },
    {
      "action_order": 2,
      "description": "Pick up the door mat",
      "verb_click": {"x": 40, "y": 170, "label": "PICK_UP"},
      "object_click": {"x": 155, "y": 155, "label": "DOOR_MAT"},
      "wait_ms": 1500
    },
    {
      "action_order": 3,
      "description": "Pick up the key under the mat",
      "verb_click": {"x": 40, "y": 170, "label": "PICK_UP"},
      "object_click": {"x": 155, "y": 155, "label": "KEY"},
      "wait_ms": 1000
    },
    {
      "action_order": 4,
      "description": "Use key with front door",
      "verb_click": {"x": 80, "y": 180, "label": "USE"},
      "inventory_click": {"x": 300, "y": 170, "label": "KEY"},
      "object_click": {"x": 160, "y": 100, "label": "FRONT_DOOR"},
      "wait_ms": 3000
    },
    {
      "action_order": 5,
      "description": "Enter the house",
      "command": "WALK_TO",
      "target_coords": {"x": 160, "y": 90},
      "wait_ms": 2000
    },
    {
      "action_order": 6,
      "description": "Go to the kitchen (right door)",
      "command": "WALK_TO",
      "target_coords": {"x": 280, "y": 120},
      "wait_ms": 2500
    },
    {
      "action_order": 7,
      "description": "Open refrigerator",
      "verb_click": {"x": 40, "y": 180, "label": "OPEN"},
      "object_click": {"x": 100, "y": 100, "label": "REFRIGERATOR"},
      "wait_ms": 1000
    },
    {
      "action_order": 8,
      "description": "Pick up the meat",
      "verb_click": {"x": 40, "y": 170, "label": "PICK_UP"},
      "object_click": {"x": 105, "y": 110, "label": "MEAT"},
      "wait_ms": 1000
    }
  ]
}