main.go

package main

import (
	"fmt"
	"log"

	"conditional-narrative-engine/narrative"
)

func main() {
	// Define narrative nodes and choices
	nodes := []narrative.Node{
		{
			ID:   "start",
			Text: "You wake up in a mysterious forest. A path splits into two directions.",
			Choices: []narrative.Choice{
				{
					ID:         "go_left",
					Text:       "Go left, deeper into the forest.",
					NextNodeID: "forest_left",
					Events: []narrative.Event{ // Example event: add item
						{
							Type: narrative.InventoryEvent,
							Payload: map[string]interface{}{
								"action": "add",
								"item":   "rusty_sword",
								"quantity": 1,
							},
						},
						{
							Type: narrative.QuestEvent,
							Payload: map[string]interface{}{
								"quest_id": "find_town",
								"state":    "started",
							},
						},
					},
				},
				{
					ID:         "go_right",
					Text:       "Go right, towards a glimmer of light.",
					NextNodeID: "forest_right",
					Events: []narrative.Event{ // Example event: dialogue
						{
							Type: narrative.DialogueEvent,
							Payload: map[string]interface{}{
								"speaker": "narrator",
								"message": "You feel a strange presence.",
							},
						},
					},
				},
			},
		},
		{
			ID:   "forest_left",
			Text: "You encounter a grumpy troll demanding a toll.",
			Choices: []narrative.Choice{
				{
					ID:         "fight_troll",
					Text:       "Fight the troll.",
					NextNodeID: "troll_battle",
					Conditions: []narrative.Condition{ // Example condition (not yet processed by engine)
						{
							Type: narrative.HasItemCondition,
							Payload: map[string]interface{}{
								"item": "rusty_sword",
							},
						},
					},
					Events: []narrative.Event{
						{
							Type: narrative.QuestEvent,
							Payload: map[string]interface{}{
								"quest_id": "defeat_troll",
								"state":    "active",
							},
						},
					},
				},
				{
					ID:         "run_away",
					Text:       "Run away!",
					NextNodeID: "start", // Back to start for now
				},
			},
		},
		{
			ID:      "forest_right",
			Text:    "You find a hidden glade with a magical spring.",
			Choices: []narrative.Choice{},
		},
		{
			ID:   "troll_battle",
			Text: "You bravely faced the troll! What will you do next?",
			Choices: []narrative.Choice{
				{
					ID:         "collect_loot",
					Text:       "Collect troll loot.",
					NextNodeID: "forest_left", // Go back for simplicity
					Events: []narrative.Event{
						{
							Type: narrative.InventoryEvent,
							Payload: map[string]interface{}{
								"action": "add",
								"item":   "troll_tooth",
								"quantity": 3,
							},
						},
					},
				},
			},
		},
	}

	// Create a new narrative engine
	engine, err := narrative.NewEngine(nodes, "start")
	if err != nil {
		log.Fatalf("Failed to create narrative engine: %v", err)
	}

	fmt.Println("--- Narrative Start ---")

	// Game loop simulation
	for {
		currentNode := engine.GetCurrentNode()
		fmt.Printf("\nNode: %s\nText: %s\n", currentNode.ID, currentNode.Text)
		if len(currentNode.Choices) == 0 {
			fmt.Println("End of this narrative path.")
			break
		}

		fmt.Println("Choices:")
		for _, choice := range currentNode.Choices {
			fmt.Printf("  [%s] %s\n", choice.ID, choice.Text)
		}

		fmt.Print("Enter your choice ID: ")
		var choiceID string
		fmt.Scanln(&choiceID)

		// Choose a path and get triggered events
		_, triggeredEvents, err := engine.Choose(choiceID)
		if err != nil {
			fmt.Printf("Error choosing: %v. Please try again.\n", err)
			continue
		}

		// Process triggered events (in a real game, this would dispatch to specific handlers)
		if len(triggeredEvents) > 0 {
			fmt.Println("--- Events Triggered ---")
			for _, event := range triggeredEvents {
				fmt.Printf("  Type: %s, Payload: %v\n", event.Type, event.Payload)
			}
			fmt.Println("------------------------")
		}
	}

	fmt.Println("\n--- Narrative End ---")
}