diff --git a/00_aMeta/toolz/CYOA/main.go b/00_aMeta/toolz/CYOA/main.go
index cf53217..54727ca 100644
--- a/00_aMeta/toolz/CYOA/main.go
+++ b/00_aMeta/toolz/CYOA/main.go
@@ -4,7 +4,6 @@ import (
"encoding/json"
"flag"
"fmt"
- "html/template"
"io"
"net/http"
"os"
@@ -22,7 +21,7 @@ type Choice struct {
type StoryNode struct {
ID string `json:"id"`
Title string `json:"title"`
- Content template.HTML `json:"content"`
+ Content string `json:"content"` // Reiner String, JSON kümmert sich um das Escaping des HTMLs
Choices []Choice `json:"choices"`
IsReboot bool `json:"isReboot"`
IsEnd bool `json:"isEnd"`
@@ -38,14 +37,6 @@ type StoryGraph struct {
DeadEndNodes []string `json:"deadEndNodes"`
}
-// Struct für das saubere Injezieren der Frontend-Komponenten
-type TemplateContext struct {
- Graph template.JS
- CSS template.CSS
- Logic template.JS
- UI template.JS
-}
-
var (
adocNodeRegex = regexp.MustCompile(`\[\[([a-zA-Z0-9_\-]+)\]\]`)
adocChoiceRegex = regexp.MustCompile(`<<([a-zA-Z0-9_\-]+)\s*,\s*([^>]+)>>`)
@@ -55,51 +46,123 @@ var (
)
func main() {
- dirPtr := flag.String("dir", ".", "Verzeichnis mit AsciiDoc/Markdown Dateien")
- outPtr := flag.String("out", "export/story.html", "Zielpfad für den Dateiexport")
- tmplPtr := flag.String("tmpl", "template.html", "Pfad zur HTML Template-Datei")
- servePtr := flag.Bool("serve", false, "Startet den API- & Preview-Server")
- portPtr := flag.Int("port", 8080, "Port für den Server")
+ dirPtr := flag.String("dir", "./stories", "Verzeichnis mit AsciiDoc/Markdown Dateien")
+ frontendPtr := flag.String("frontend", "./frontend", "Pfad zum Verzeichnis der statischen Frontend-Dateien")
+ outPtr := flag.String("out", "export/story.html", "Zielpfad für den Dateiexport (Single-File HTML)")
+ servePtr := flag.Bool("serve", false, "Startet den API- & Preview-Server, statt zu exportieren")
+ portPtr := flag.Int("port", 3344, "Port für den Server")
flag.Parse()
- fmt.Println("\033[1;36m=== Computer Historyz :: CYOA Engine (Modular) ===\033[0m")
+ fmt.Println("\033[1;36m=== Computer Historyz :: CYOA Engine ===\033[0m")
+
+ if info, err := os.Stat(*frontendPtr); os.IsNotExist(err) || !info.IsDir() {
+ fmt.Printf("\033[1;33m[WARNUNG]\033[0m Frontend-Verzeichnis '%s' nicht gefunden!\n", *frontendPtr)
+ }
if *servePtr {
- startServer(*portPtr, *dirPtr, *outPtr, *tmplPtr)
+ startServer(*portPtr, *dirPtr, *frontendPtr)
return
}
+ // --- EXPORT MODUS ---
+ fmt.Printf("\033[1;34m[EXPORT]\033[0m Kompiliere Story-Graph via Asciidoctor aus '%s'...\n", *dirPtr)
graph := loadStoryGraphFromDir(*dirPtr)
validateGraph(graph)
outDir := filepath.Dir(*outPtr)
os.MkdirAll(outDir, 0755)
- if err := generateHTMLFile(graph, *outPtr, *tmplPtr); err != nil {
- fmt.Printf("\033[1;31m[FEHLER]\033[0m %v\n", err)
+ err := buildSingleFileExport(graph, *frontendPtr, *outPtr)
+ if err != nil {
+ fmt.Printf("\033[1;31m[FEHLER]\033[0m Build fehlgeschlagen: %v\n", err)
os.Exit(1)
}
- fmt.Printf("\033[1;32m[ERFOLG]\033[0m Story modular generiert -> \033[1;33m%s\033[0m\n", *outPtr)
+ fmt.Printf("\033[1;32m[ERFOLG]\033[0m Single-File Story exportiert -> \033[1;33m%s\033[0m\n", *outPtr)
}
-func readAsset(basePath, filename string) string {
- b, err := os.ReadFile(filepath.Join(filepath.Dir(basePath), filename))
- if err != nil {
- return fmt.Sprintf("/* %s nicht gefunden */", filename)
+func startServer(port int, watchDir string, frontendDir string) {
+ addr := fmt.Sprintf(":%d", port)
+
+ http.HandleFunc("/api/graph", func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Access-Control-Allow-Origin", "*")
+ w.Header().Set("Content-Type", "application/json")
+
+ if r.Method == http.MethodPost {
+ bodyBytes, err := io.ReadAll(r.Body)
+ if err != nil {
+ http.Error(w, `{"error": "Daten defekt"}`, http.StatusBadRequest)
+ return
+ }
+
+ graph := &StoryGraph{Nodes: make(map[string]*StoryNode)}
+ parseContent(string(bodyBytes), "API_POST_Stream", graph)
+ validateGraph(graph)
+
+ json.NewEncoder(w).Encode(graph)
+ fmt.Println("\033[1;34m[POST-API]\033[0m Story-Graph verarbeitet.")
+ return
+ }
+
+ if r.Method == http.MethodGet {
+ graph := loadStoryGraphFromDir(watchDir)
+ validateGraph(graph)
+ json.NewEncoder(w).Encode(graph)
+ }
+ })
+
+ fs := http.FileServer(http.Dir(frontendDir))
+ http.Handle("/", fs)
+
+ fmt.Printf("\n\033[1;32m[SERVER LÄUFT]\033[0m http://localhost:%d\n", port)
+ if err := http.ListenAndServe(addr, nil); err != nil {
+ fmt.Printf("\033[1;31m[FEHLER]\033[0m %v\n", err)
}
- return string(b)
}
-func renderAsciidoctor(text string) template.HTML {
- if strings.TrimSpace(text) == "" { return "" }
+func buildSingleFileExport(graph *StoryGraph, frontendDir string, outPath string) error {
+ indexPath := filepath.Join(frontendDir, "index.html")
+ htmlBytes, err := os.ReadFile(indexPath)
+ if err != nil {
+ return fmt.Errorf("konnte %s nicht lesen: %v", indexPath, err)
+ }
+ htmlStr := string(htmlBytes)
+
+ cssBytes, _ := os.ReadFile(filepath.Join(frontendDir, "style.css"))
+ logicBytes, _ := os.ReadFile(filepath.Join(frontendDir, "engine_logic.js"))
+ uiBytes, _ := os.ReadFile(filepath.Join(frontendDir, "engine_ui.js"))
+
+ graphJson, _ := json.Marshal(graph)
+
+ // CSS ersetzen
+ htmlStr = strings.Replace(htmlStr, ``, fmt.Sprintf("", string(cssBytes)), 1)
+
+ // JS ersetzen
+ htmlStr = strings.Replace(htmlStr, ``, fmt.Sprintf("", string(logicBytes)), 1)
+ htmlStr = strings.Replace(htmlStr, ``, fmt.Sprintf("", string(uiBytes)), 1)
+
+ // JSON State in den Data-Block pressen
+ re := regexp.MustCompile(`(?s)`)
+ htmlStr = re.ReplaceAllString(htmlStr, fmt.Sprintf("", string(graphJson)))
+
+ return os.WriteFile(outPath, []byte(htmlStr), 0644)
+}
+
+// renderAsciidoctor piped rohen AsciiDoc Text in den lokalen Container-Prozess
+func renderAsciidoctor(text string) string {
+ if strings.TrimSpace(text) == "" {
+ return ""
+ }
+
cmd := exec.Command("asciidoctor", "--embedded", "-")
cmd.Stdin = strings.NewReader(text)
+
out, err := cmd.Output()
if err != nil {
- fallback := strings.ReplaceAll(text, "\n", "
")
- return template.HTML(fallback)
+ fmt.Printf("\033[1;33m[WARNUNG]\033[0m Asciidoctor Rendering fehlgeschlagen: %v\n", err)
+ return strings.ReplaceAll(text, "\n", "
")
}
- return template.HTML(string(out))
+
+ return string(out)
}
func cleanBodyText(raw string) string {
@@ -121,38 +184,72 @@ func parseContent(rawContent string, sourceName string, graph *StoryGraph) {
currentBody.Reset()
}
nodeID := matches[1]
- currentNode = &StoryNode{ ID: nodeID, Title: nodeID, Choices: make([]Choice, 0), FileSource: sourceName, Metadata: make(map[string]string) }
- if graph.StartNodeID == "" || nodeID == "start" || nodeID == "node_start" { graph.StartNodeID = nodeID }
+ currentNode = &StoryNode{
+ ID: nodeID,
+ Title: nodeID,
+ Choices: make([]Choice, 0),
+ FileSource: sourceName,
+ Metadata: make(map[string]string),
+ }
+ if graph.StartNodeID == "" || nodeID == "start" || nodeID == "node_start" {
+ graph.StartNodeID = nodeID
+ }
continue
}
+
if currentNode == nil {
if strings.TrimSpace(line) != "" {
baseID := "start"
- if sourceName != "API_POST_Stream" { baseID = strings.TrimSuffix(filepath.Base(sourceName), filepath.Ext(sourceName)) }
- currentNode = &StoryNode{ ID: baseID, Title: baseID, Choices: make([]Choice, 0), FileSource: sourceName, Metadata: make(map[string]string) }
- if graph.StartNodeID == "" { graph.StartNodeID = baseID }
- } else { continue }
+ if sourceName != "API_POST_Stream" {
+ baseID = strings.TrimSuffix(filepath.Base(sourceName), filepath.Ext(sourceName))
+ }
+ currentNode = &StoryNode{
+ ID: baseID,
+ Title: baseID,
+ Choices: make([]Choice, 0),
+ FileSource: sourceName,
+ Metadata: make(map[string]string),
+ }
+ if graph.StartNodeID == "" {
+ graph.StartNodeID = baseID
+ }
+ } else {
+ continue
+ }
}
if mMatches := metaRegex.FindStringSubmatch(line); len(mMatches) > 2 {
- currentNode.Metadata[strings.ToLower(mMatches[1])] = strings.TrimSpace(mMatches[2]); continue
+ currentNode.Metadata[strings.ToLower(mMatches[1])] = strings.TrimSpace(mMatches[2])
+ continue
}
+
if hMatches := headingRegex.FindStringSubmatch(line); len(hMatches) > 1 && currentNode.Title == currentNode.ID {
currentNode.Title = strings.TrimSpace(hMatches[1])
}
+
if cMatches := adocChoiceRegex.FindAllStringSubmatch(line, -1); len(cMatches) > 0 {
- for _, match := range cMatches { currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[1], Text: strings.TrimSpace(match[2])}) }
+ for _, match := range cMatches {
+ currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[1], Text: strings.TrimSpace(match[2])})
+ }
}
+
if mMatches := mdChoiceRegex.FindAllStringSubmatch(line, -1); len(mMatches) > 0 {
- for _, match := range mMatches { currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[2], Text: strings.TrimSpace(match[1])}) }
+ for _, match := range mMatches {
+ currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[2], Text: strings.TrimSpace(match[1])})
+ }
}
lowerLine := strings.ToLower(line)
- if strings.Contains(lowerLine, "[reboot]") || strings.Contains(lowerLine, "speicherabbild") { currentNode.IsReboot = true }
- if strings.Contains(lowerLine, "[ende]") || strings.Contains(lowerLine, "[end]") { currentNode.IsEnd = true }
+ if strings.Contains(lowerLine, "[reboot]") || strings.Contains(lowerLine, "speicherabbild") {
+ currentNode.IsReboot = true
+ }
+ if strings.Contains(lowerLine, "[ende]") || strings.Contains(lowerLine, "[end]") {
+ currentNode.IsEnd = true
+ }
currentBody.WriteString(line + "\n")
}
+
if currentNode != nil {
currentNode.Content = renderAsciidoctor(cleanBodyText(currentBody.String()))
graph.Nodes[currentNode.ID] = currentNode
@@ -166,7 +263,10 @@ func loadStoryGraphFromDir(rootDir string) *StoryGraph {
ext := strings.ToLower(filepath.Ext(path))
if ext != ".adoc" && ext != ".md" { return nil }
contentBytes, err := os.ReadFile(path)
- if err == nil { parseContent(string(contentBytes), filepath.Base(path), graph) }
+ if err == nil {
+ relPath, _ := filepath.Rel(rootDir, path)
+ parseContent(string(contentBytes), relPath, graph)
+ }
return nil
})
return graph
@@ -178,60 +278,15 @@ func validateGraph(g *StoryGraph) {
for id, node := range g.Nodes {
for _, choice := range node.Choices {
referenced[choice.TargetID] = true
- if _, exists := g.Nodes[choice.TargetID]; !exists { g.BrokenLinks = append(g.BrokenLinks, fmt.Sprintf("%s -> %s (in %s)", id, choice.TargetID, node.FileSource)) }
+ if _, exists := g.Nodes[choice.TargetID]; !exists {
+ g.BrokenLinks = append(g.BrokenLinks, fmt.Sprintf("%s -> %s (in %s)", id, choice.TargetID, node.FileSource))
+ }
+ }
+ if len(node.Choices) == 0 && !node.IsReboot && !node.IsEnd {
+ g.DeadEndNodes = append(g.DeadEndNodes, id)
}
- if len(node.Choices) == 0 && !node.IsReboot && !node.IsEnd { g.DeadEndNodes = append(g.DeadEndNodes, id) }
}
- for id := range g.Nodes { if !referenced[id] { g.OrphanNodes = append(g.OrphanNodes, id) } }
-}
-
-func getContext(graph *StoryGraph, tmplPath string) TemplateContext {
- graphJson, _ := json.Marshal(graph)
- return TemplateContext{
- Graph: template.JS(graphJson),
- CSS: template.CSS(readAsset(tmplPath, "style.css")),
- Logic: template.JS(readAsset(tmplPath, "engine_logic.js")),
- UI: template.JS(readAsset(tmplPath, "engine_ui.js")),
+ for id := range g.Nodes {
+ if !referenced[id] { g.OrphanNodes = append(g.OrphanNodes, id) }
}
-}
-
-func generateHTMLFile(g *StoryGraph, outPath string, tmplPath string) error {
- tmpl, err := template.ParseFiles(tmplPath)
- if err != nil { return fmt.Errorf("Template-Fehler: %v", err) }
- f, err := os.Create(outPath)
- if err != nil { return err }
- defer f.Close()
- return tmpl.Execute(f, getContext(g, tmplPath))
-}
-
-func startServer(port int, watchDir string, htmlPath string, tmplPath string) {
- addr := fmt.Sprintf(":%d", port)
- fmt.Printf("\n\033[1;32m[CONTAINER-API LÄUFT]\033[0m Port: %d | Nutzt Template: %s\n", port, tmplPath)
-
- http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
- w.Header().Set("Access-Control-Allow-Origin", "*")
-
- if r.Method == http.MethodPost {
- bodyBytes, err := io.ReadAll(r.Body)
- if err != nil { http.Error(w, "Daten defekt", http.StatusBadRequest); return }
-
- graph := &StoryGraph{Nodes: make(map[string]*StoryNode)}
- parseContent(string(bodyBytes), "API_POST_Stream", graph)
- validateGraph(graph)
-
- w.Header().Set("Content-Type", "text/html; charset=utf-8")
- tmpl, err := template.ParseFiles(tmplPath)
- if err != nil { http.Error(w, "Template-Fehler: "+err.Error(), http.StatusInternalServerError); return }
-
- tmpl.Execute(w, getContext(graph, tmplPath))
- fmt.Println("\033[1;34m[POST-API]\033[0m Modularer Stack gerendert.")
- return
- }
- if r.Method == http.MethodGet {
- freshGraph := loadStoryGraphFromDir(watchDir)
- _ = generateHTMLFile(freshGraph, htmlPath, tmplPath)
- http.ServeFile(w, r, htmlPath)
- }
- })
- http.ListenAndServe(addr, nil)
}
\ No newline at end of file