A!leys Galerie

```csharp
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System.Linq;
using DG.Tweening;
using UnityEngine.EventSystems;

[RequireComponent(typeof(GraphCanvas))]
[ExecuteAlways]
public class DynamicTweenFlow : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    [SerializeField] private float minNodeSize = 30f;
    [SerializeField] private float maxNodeSize = 100f;
    [SerializeField] private Color defaultNodeColor = new Color(0.2f, 0.6f, 0.9f);
    [SerializeField] private Color highlightColor = Color.yellow;
    [SerializeField] private Color warningColor = Color.red;
    [SerializeField] private float connectionThickness = 2f;
    [SerializeField] private float minConnectionDistance = 50f;
    [SerializeField] private float dragSpeedMultiplier = 0.5f;
    [SerializeField] private float zoomSpeed = 2f;
    [SerializeField] private float minZoom = 0.1f;
    [SerializeField] private float maxZoom = 5f;
    [SerializeField] private AnimationCurve zoomCurve;

    private GraphCanvas canvas;
    private List<Node> nodes = new List<Node>();
    private List<Connection> connections = new List<Connection>();
    private Node selectedNode;
    private Vector2 lastDragPosition;
    private float currentZoom = 1f;
    private RectTransform canvasRect;
    private bool isDragging = false;
    private bool isGeneratingCode = false;
    private string generatedCode;

    private enum NodeType { Tween, Property, Event, None }
    private enum ConnectionType { Tween, Flow, None }

    [System.Serializable]
    public class Node
    {
        public Vector2 position;
        public NodeType type;
        public string name = "New Node";
        public string propertyPath;
        public Ease easeType;
        public float duration = 1f;
        public float delay = 0f;
        public bool isLoop;
        public bool isActive = true;
        public Color color;
        public RectTransform rectTransform;
        public List<int> incomingConnections = new List<int>();
        public List<int> outgoingConnections = new List<int>();

        public Node(NodeType type, string name = "New Node")
        {
            this.type = type;
            this.name = name;
            this.color = defaultNodeColor;
            this.easeType = Ease.InOutQuad;
        }

        public void UpdateVisuals()
        {
            if (rectTransform == null) return;

            // Dynamic size based on content and type
            float size = minNodeSize + (type == NodeType.Property ? 20f : 0);
            size = Mathf.Clamp(size, minNodeSize, maxNodeSize);
            rectTransform.sizeDelta = new Vector2(size, size);

            // Update color based on state
            if (incomingConnections.Count == 0 && outgoingConnections.Count == 0)
                color = warningColor;
            else if (incomingConnections.Count > 0)
                color = defaultNodeColor;
            else if (selectedNode == this)
                color = highlightColor;
            else
                color = defaultNodeColor * 0.8f;

            GetComponent<Image>().color = color;

            // Update text based on type
            Text text = GetComponentInChildren<Text>();
            if (text == null) return;

            switch (type)
            {
                case NodeType.Tween:
                    text.text = name + "\n" + $"Dur: {duration:F1}s\nEase: {easeType}";
                    break;
                case NodeType.Property:
                    text.text = propertyPath;
                    break;
                case NodeType.Event:
                    text.text = name;
                    break;
                default:
                    text.text = name;
                    break;
            }
        }
    }

    [System.Serializable]
    public class Connection
    {
        public int fromNodeIndex;
        public int toNodeIndex;
        public ConnectionType type;
        public LineRenderer lineRenderer;
        public bool isValid = true;

        public Connection(int from, int to, ConnectionType type)
        {
            fromNodeIndex = from;
            toNodeIndex = to;
            this.type = type;
            CreateLineRenderer();
        }

        private void CreateLineRenderer()
        {
            GameObject lineObj = new GameObject("ConnectionLine_" + fromNodeIndex + "_" + toNodeIndex);
            lineObj.transform.SetParent(transform);
            lineRenderer = lineObj.AddComponent<LineRenderer>();
            lineRenderer.startWidth = connectionThickness;
            lineRenderer.endWidth = connectionThickness;
            lineRenderer.positionCount = 2;
            lineRenderer.useWorldSpace = true;
            lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
            lineRenderer.startColor = type == ConnectionType.Tween ? Color.green : Color.blue;
            lineRenderer.endColor = type == ConnectionType.Tween ? Color.green : Color.blue;
        }

        public void UpdateLine()
        {
            if (lineRenderer == null) return;

            if (fromNodeIndex >= nodes.Count || toNodeIndex >= nodes.Count)
            {
                Destroy(lineRenderer.gameObject);
                return;
            }

            Node fromNode = nodes[fromNodeIndex];
            Node toNode = nodes[toNodeIndex];

            if (fromNode.rectTransform == null || toNode.rectTransform == null)
            {
                Destroy(lineRenderer.gameObject);
                return;
            }

            Vector3[] positions = new Vector3[2];
            positions[0] = fromNode.rectTransform.rect.center + fromNode.rectTransform.anchoredPosition;
            positions[1] = toNode.rectTransform.rect.center + toNode.rectTransform.anchoredPosition;
            lineRenderer.SetPositions(positions);

            // Check if connection is valid (not overlapping nodes)
            isValid = Vector2.Distance(positions[0], positions[1]) > minConnectionDistance;

            if (!isValid)
            {
                lineRenderer.startColor = warningColor;
                lineRenderer.endColor = warningColor;
            }
            else
            {
                lineRenderer.startColor = type == ConnectionType.Tween ? Color.green : Color.blue;
                lineRenderer.endColor = type == ConnectionType.Tween ? Color.green : Color.blue;
            }
        }

        public void DestroyLine()
        {
            if (lineRenderer != null)
                Destroy(lineRenderer.gameObject);
        }
    }

    private void Awake()
    {
        if (canvas == null)
            canvas = GetComponent<GraphCanvas>();

        if (canvasRect == null)
            canvasRect = canvas.GetComponent<RectTransform>();

        // Initialize with default nodes
        if (nodes.Count == 0)
        {
            CreateDefaultNodes();
        }
    }

    private void CreateDefaultNodes()
    {
        // Property node (start)
        Node startNode = new Node(NodeType.Property, "Start Position");
        startNode.propertyPath = "transform.localPosition";
        nodes.Add(startNode);

        // Tween node
        Node tweenNode = new Node(NodeType.Tween, "Move Tween");
        tweenNode.duration = 2f;
        nodes.Add(tweenNode);

        // Property node (end)
        Node endNode = new Node(NodeType.Property, "End Position");
        endNode.propertyPath = "transform.localPosition";
        nodes.Add(endNode);

        // Create connections
        connections.Add(new Connection(0, 1, ConnectionType.Tween));
        connections.Add(new Connection(1, 2, ConnectionType.Flow));

        UpdateAllNodes();
    }

    private void UpdateAllNodes()
    {
        foreach (Node node in nodes)
        {
            if (node.rectTransform == null)
            {
                CreateNodeUI(node);
            }
            node.UpdateVisuals();
        }

        foreach (Connection conn in connections)
        {
            conn.UpdateLine();
        }

        GenerateCode();
    }

    private void CreateNodeUI(Node node)
    {
        GameObject nodeObj = new GameObject(node.name);
        nodeObj.transform.SetParent(canvas.transform);
        node.rectTransform = nodeObj.AddComponent<RectTransform>();
        node.rectTransform.anchorMin = Vector2.zero;
        node.rectTransform.anchorMax = Vector2.one;
        node.rectTransform.sizeDelta = new Vector2(minNodeSize, minNodeSize);
        node.rectTransform.anchoredPosition = node.position;

        Image nodeImage = nodeObj.AddComponent<Image>();
        nodeImage.color = node.color;
        nodeImage.preserveAspect = true;

        // Add label
        GameObject labelObj = new GameObject("Label");
        labelObj.transform.SetParent(nodeObj.transform);
        Text label = labelObj.AddComponent<Text>();
        label.alignment = TextAnchor.MiddleCenter;
        label.fontSize = Mathf.RoundToInt(minNodeSize * 0.6f);
        label.color = Color.white;
        nodeObj.AddComponent<Node>().Initialize(node, label);

        // Add drag handler
        nodeObj.AddComponent<NodeDragHandler>().Initialize(node);
    }

    private void GenerateCode()
    {
        if (isGeneratingCode) return;
        isGeneratingCode = true;

        generatedCode = GenerateTweenSequence();
        Debug.Log("Generated Tween Code:\n" + generatedCode);

        isGeneratingCode = false;
    }

    private string GenerateTweenSequence()
    {
        string code = "using DG.Tweening;\nusing UnityEngine;\n\n";

        if (connections.Count == 0)
        {
            code += "// No valid tween sequence found. Create connections to generate code.\n";
            return code;
        }

        // Find the starting node (node with no incoming connections)
        Node startNode = nodes.FirstOrDefault(n => n.incomingConnections.Count == 0);
        if (startNode == null)
        {
            code += "// No starting node found (node with no incoming connections).\n";
            return code;
        }

        code += "public class GeneratedTweenSequence : MonoBehaviour\n{\n";
        code += "    void Start()\n    {\n";

        code += $"        // Start tween from {startNode.name}\n";
        if (startNode.type == NodeType.Property)
        {
            code += $"        Tween tween = DOTween.To(() => transform.{startNode.propertyPath}, x => transform.{startNode.propertyPath} = x,\n";
            code += $"            new Vector3(0, 0, 0), // Default target (will be replaced)\n";
            code += $"            {startNode.duration}.f).SetEase({GetEaseName(startNode.easeType)}).SetDelay({startNode.delay})\n";

            // Find all tween nodes connected to this
            foreach (int outgoingIndex in startNode.outgoingConnections)
            {
                Connection conn = connections[outgoingIndex];
                if (conn.type == ConnectionType.Tween)
                {
                    Node tweenNode = nodes[conn.toNodeIndex];
                    code += $".OnComplete(() =>\n" +
                            $"    DOTween.To(() => transform.{tweenNode.propertyPath}, x => transform.{tweenNode.propertyPath} = x,\n" +
                            $"        new Vector3({GetRandomVector3()}), // Target position\n" +
                            $"        {tweenNode.duration}.f).SetEase({GetEaseName(tweenNode.easeType)})\n";
                }
            }
        }

        code += ";\n";
        code += "    }\n";
        code += "}\n";

        return code;
    }

    private string GetEaseName(Ease ease)
    {
        return ease switch
        {
            Ease.InQuad => "Ease.InQuad",
            Ease.OutQuad => "Ease.OutQuad",
            Ease.InOutQuad => "Ease.InOutQuad",
            Ease.InExpo => "Ease.InExpo",
            Ease.OutExpo => "Ease.OutExpo",
            Ease.InOutExpo => "Ease.InOutExpo",
            Ease.InCirc => "Ease.InCirc",
            Ease.OutCirc => "Ease.OutCirc",
            Ease.InOutCirc => "Ease.InOutCirc",
            _ => "Ease.Linear"
        };
    }

    private Vector3 GetRandomVector3()
    {
        return new Vector3(Random.Range(-5, 5), Random.Range(-5, 5), Random.Range(-5, 5));
    }

    #region UI Interactions

    public void OnBeginDrag(PointerEventData eventData)
    {
        if (!canvas.IsPointerOverCanvas(eventData))
            return;

        lastDragPosition = eventData.position;
        isDragging = true;
    }

    public void OnDrag(PointerEventData eventData)
    {
        if (!isDragging || !canvas.IsPointerOverCanvas(eventData))
            return;

        Vector2 delta = eventData.position - lastDragPosition;
        lastDragPosition = eventData.position;

        // Handle zoom with pinch (mobile) or mouse wheel (desktop)
        if (eventData.pointerCount > 1)
        {
            float pinchDelta = GetPinchDelta(eventData);
            ZoomCamera(pinchDelta * zoomSpeed);
        }
        else if (Input.GetAxis("Mouse ScrollWheel") != 0)
        {
            ZoomCamera(Input.GetAxis("Mouse ScrollWheel") * zoomSpeed);
        }
        else
        {
            // Pan the camera
            Vector2 pan = Camera.main.ScreenToViewportPoint(delta) * currentZoom;
            camera.transform.Translate(new Vector3(pan.x, pan.y, 0), Space.World);
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        isDragging = false;
    }

    private float GetPinchDelta(PointerEventData eventData)
    {
        if (eventData.pointerCount < 2) return 0f;

        Vector2 firstPos, secondPos;
        eventData.GetPosition(out firstPos);
        eventData.GetPosition(out secondPos, 1);

        Vector2 prevFirst, prevSecond;
        eventData.GetPreviousPosition(out prevFirst);
        eventData.GetPreviousPosition(out prevSecond, 1);

        float prevDistance = Vector2.Distance(prevFirst, prevSecond);
        float currentDistance = Vector2.Distance(firstPos, secondPos);

        return currentDistance / (prevDistance + 0.001f);
    }

    private void ZoomCamera(float zoomFactor)
    {
        zoomFactor = Mathf.Clamp(zoomFactor, -1f, 1f);
        currentZoom = Mathf.Clamp(currentZoom + zoomFactor, minZoom, maxZoom);

        // Apply zoom curve for smoother feel
        currentZoom = Mathf.Clamp(zoomCurve.Evaluate(currentZoom), minZoom, maxZoom);

        // Update camera orthographic size
        Camera.main.orthographicSize = currentZoom * 5f;

        // Update all node positions to maintain relative positioning
        Vector2 center = canvasRect.rect.center;
        foreach (Node node in nodes)
        {
            if (node.rectTransform != null)
            {
                Vector2 newPos = node.rectTransform.anchoredPosition;
                newPos.x = Mathf.Lerp(newPos.x, center.x, 0.1f * currentZoom);
                newPos.y = Mathf.Lerp(newPos.y, center.y, 0.1f * currentZoom);
                node.rectTransform.anchoredPosition = newPos;
            }
        }
    }

    #endregion

    #region Node Management

    public void AddNode(NodeType type, Vector2 position = default)
    {
        Node newNode = new Node(type);
        newNode.position = position == default ? Camera.main.ScreenToViewportPoint(Input.mousePosition) * 1000f : position;
        nodes.Add(newNode);
        CreateNodeUI(newNode);
        UpdateAllNodes();
    }

    public void RemoveNode(int index)
    {
        if (index < 0 || index >= nodes.Count) return;

        // Remove all connections to/from this node
        connections.RemoveAll(c => c.fromNodeIndex == index || c.toNodeIndex == index);

        // Update other nodes' connection lists
        foreach (Node node in nodes)
        {
            node.incomingConnections.Remove(index);
            node.outgoingConnections.Remove(index);
        }

        Destroy(nodes[index].rectTransform.gameObject);
        nodes.RemoveAt(index);
        UpdateAllNodes();
    }

    public void AddConnection(int fromIndex, int toIndex, ConnectionType type)
    {
        if (fromIndex < 0 || fromIndex >= nodes.Count || toIndex < 0 || toIndex >= nodes.Count) return;
        if (fromIndex == toIndex) return; // No self connections

        // Check if connection already exists
        if (connections.Exists(c => c.fromNodeIndex == fromIndex && c.toNodeIndex == toIndex))
            return;

        connections.Add(new Connection(fromIndex, toIndex, type));
        nodes[fromIndex].outgoingConnections.Add(connections.Count - 1);
        nodes[toIndex].incomingConnections.Add(connections.Count - 1);
        UpdateAllNodes();
    }

    public void RemoveConnection(int connectionIndex)
    {
        if (connectionIndex < 0 || connectionIndex >= connections.Count) return;

        Connection conn = connections[connectionIndex];
        nodes[conn.fromNodeIndex].outgoingConnections.Remove(connectionIndex);
        nodes[conn.toNodeIndex].incomingConnections.Remove(connectionIndex);
        conn.DestroyLine();
        connections.RemoveAt(connectionIndex);
        UpdateAllNodes();
    }

    #endregion

    #region Editor Tools

    public void ResetGraph()
    {
        foreach (Connection conn in connections)
        {
            conn.DestroyLine();
        }
        connections.Clear();

        foreach (Node node in nodes)
        {
            Destroy(node.rectTransform.gameObject);
        }
        nodes.Clear();

        CreateDefaultNodes();
    }

    public void ExportCodeToFile()
    {
        if (string.IsNullOrEmpty(generatedCode))
        {
            Debug.LogWarning("No code to export. Create a valid tween sequence first.");
            return;
        }

        string filePath = System.IO.Path.Combine(Application.persistentDataPath, "GeneratedTweenSequence.cs");
        System.IO.File.WriteAllText(filePath, generatedCode);
        Debug.Log($"Code exported to: {filePath}");
    }

    #endregion

#!/usr/bin/env node

const fs = require('fs');
const readline = require('readline');
const Ajv = require('ajv');
const chalk = require('chalk');

const ajv = new Ajv({
  allErrors: true,
  removeAdditional: true,
  verbose: true
});

// Enhance default AJV with our custom error messages
ajv.addFormat('email', /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/);

// Creative error message generator
function generateSparkError(error, data) {
  const errors = error.errors || [error];
  const messages = errors.map(err => {
    const path = err.dataPath ? data.dataPath : '';
    let message = '';

    // Determine error type and generate creative message
    switch (err.params?.type) {
      case 'required':
        message = `🌑 ${path} is missing! Like a ghost, it haunts the schema, demanding to be present.`;
        break;
      case 'additionalProperties':
        message = `🤖 ${path} is not allowed here! The schema bot detected an unauthorized property trying to sneak in.`;
        break;
      case 'type':
        switch (err.params?.type) {
          case 'string':
            message = `🧙‍♀️ Expected a string at ${path} but found something else. Maybe it was cast by an evil spell?`;
            break;
          case 'number':
            message = `🧮 Expected a number at ${path} but found a non-numeric value. Numbers should be crisp like a math teacher's grading.`;
            break;
          case 'array':
            message = `🧩 Expected an array at ${path} but found something that doesn't like to be counted.`;
            break;
          case 'object':
            message = `🌍 Expected an object at ${path} but found something that doesn't like to be structured.`;
            break;
          case 'boolean':
            message = `⚡ Expected a boolean at ${path} but found something that can't decide between true or false.`;
            break;
        }
        break;
      case 'enum':
        message = `🎭 ${path} should be one of [${err.params.allowedValues.join(', ')}] but tried to be something else. Maybe it's an imposter?`;
        break;
      case 'pattern':
        message = `🔍 ${path} has an invalid pattern. The regex guardian won't let unknown patterns pass.`;
        break;
      case 'format':
        if (err.params?.type === 'email') {
          message = `✉️ ${path} is not a valid email address. It looks like it got lost in the digital void.`;
        }
        break;
      case 'minLength':
        message = `📏 ${path} is too short! It needs at least ${err.params.limit} characters to be considered valid.`;
        break;
      case 'maxLength':
        message = `📏 ${path} is too long! It needs to shrink down to ${err.params.limit} characters or less.`;
        break;
      case 'minimum':
        message = `📉 ${path} is too small! It needs to be at least ${err.params.limit}. Maybe it's still in its embryonic state?`;
        break;
      case 'maximum':
        message = `📈 ${path} is too big! It needs to shrink down to ${err.params.limit} or less.`;
        break;
      default:
        message = `❓ ${path} has an issue that the SchemaSpark couldn't decode. Try asking a human or a very smart robot.`;
    }

    // Add additional context if available
    if (err.params?.type === 'additionalProperties' && err.params?.additionalProperty) {
      message += ` The offender is: ${err.params.additionalProperty}`;
    }

    return message;
  });

  return {
    valid: false,
    errors: messages,
    path: error.dataPath || ''
  };
}

async function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  console.log(chalk.yellow bold('=== SchemaSpark - JSON Schema Validator with AI-Inspired Error Messages ==='));
  console.log(chalk.blue('Enter your JSON data (press Ctrl+C to exit):\n'));

  const jsonData = await new Promise((resolve, reject) => {
    let data = '';
    rl.on('line', (line) => { data += line; });
    rl.on('close', () => resolve(data));
  }).catch(() => {
    console.log(chalk.red('\nValidation cancelled by user.'));
    process.exit(0);
  });

  try {
    const schemaPath = process.argv[2];
    if (!schemaPath) {
      console.error(chalk.red('Error: Please provide a schema file path as an argument.'));
      console.log(chalk.gray('Usage: node schemaSpark.js <path-to-schema.json>'));
      process.exit(1);
    }

    if (!fs.existsSync(schemaPath)) {
      console.error(chalk.red(`Error: Schema file not found at ${schemaPath}`));
      process.exit(1);
    }

    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
    const data = JSON.parse(jsonData);

    const validate = ajv.compile(schema);
    const isValid = validate(data);

    if (isValid) {
      console.log(chalk.green('✨ Sparkle! Your data passed all validation checks with flying colors! 🌟'));
      console.log(chalk.green('The SchemaSpark is proud of your perfect JSON structure!'));
    } else {
      const sparkError = generateSparkError(validate, data);
      console.log(chalk.red(`\n⚠️  SchemaSpark Detected ${sparkError.errors.length} Issues:`));
      sparkError.errors.forEach((error, index) => {
        console.log(`  ${index + 1}. ${error}`);
      });
      console.log('\n💡 Tips:');
      console.log('  - Check the paths mentioned in the errors');
      console.log('  - Ensure required fields are present');
      console.log('  - Verify all data types match the schema');
      console.log('  - Keep strings to the correct length');
    }
  } catch (err) {
    if (err instanceof SyntaxError) {
      console.error(chalk.red(`\n🌑 Syntax Error: ${err.message}`));
      console.log(chalk.red('Please ensure your JSON is properly formatted.'));
    } else {
      console.error(chalk.red(`\n🤖 Unexpected Error: ${err.message}`));
    }
    process.exit(1);
  } finally {
    rl.close();
  }
}

main();

// Import required modules
const readline = require('readline');
const fs = require('fs').promises;
const path = require('path');

// Main module for the simulation
const SkyTintSimulator = (() => {
  // Private variables
  let currentTime = 12; // 12:00 PM in 24-hour format (0-24)
  let skyTintState = {
    day: { hue: 210, saturation: 0.8, brightness: 0.9 },
    dusk: { hue: 220, saturation: 0.9, brightness: 0.7 },
    night: { hue: 240, saturation: 1.0, brightness: 0.2 },
    dawn: { hue: 190, saturation: 0.85, brightness: 0.6 },
  };
  let weatherEffect = 'clear';

  // Time constants (in hours)
  const DAWN_DURATION = 2;
  const DAY_DURATION = 8;
  const DUSK_DURATION = 3;
  const NIGHT_DURATION = 11;

  // Load state from localStorage
  const loadState = async () => {
    try {
      const savedState = localStorage.getItem('skyTintState');
      if (savedState) {
        const parsedState = JSON.parse(savedState);
        currentTime = parsedState.currentTime || 12;
        skyTintState = { ...skyTintState, ...parsedState.skyTintState };
        weatherEffect = parsedState.weatherEffect || 'clear';
      }
    } catch (e) {
      console.error('Error loading state:', e);
    }
  };

  // Save state to localStorage
  const saveState = () => {
    try {
      const stateToSave = {
        currentTime,
        skyTintState,
        weatherEffect,
      };
      localStorage.setItem('skyTintState', JSON.stringify(stateToSave));
    } catch (e) {
      console.error('Error saving state:', e);
    }
  };

  // Calculate current sky tint based on time and weather
  const calculateTint = () => {
    const timeInHours = currentTime;
    const isDaytime = timeInHours >= 6 && timeInHours <= 18;
    const isDawn = timeInHours >= 4 && timeInHours < 6;
    const isDusk = timeInHours >= 18 && timeInHours < 20;
    const isNight = timeInHours >= 20 || timeInHours < 4;

    let baseTint = skyTintState.day;
    if (isDawn) {
      baseTint = skyTintState.dawn;
    } else if (isDusk) {
      baseTint = skyTintState.dusk;
    } else if (isNight) {
      baseTint = skyTintState.night;
    }

    // Apply weather effect with a 30% chance
    if (Math.random() < 0.3 && weatherEffect !== 'clear') {
      switch (weatherEffect) {
        case 'rain':
          baseTint.hue = (baseTint.hue + 20) % 360;
          baseTint.saturation *= 0.9;
          baseTint.brightness *= 0.8;
          break;
        case 'snow':
          baseTint.hue = (baseTint.hue + 10) % 360;
          baseTint.saturation *= 0.7;
          baseTint.brightness *= 0.6;
          break;
        case 'fog':
          baseTint.hue = (baseTint.hue + 30) % 360;
          baseTint.saturation *= 0.5;
          baseTint.brightness *= 0.4;
          break;
      }
    }

    return {
      hue: Math.round(baseTint.hue),
      saturation: Math.round(baseTint.saturation * 100) / 100,
      brightness: Math.round(baseTint.brightness * 100) / 100,
    };
  };

  // Advance time by a specified amount (in hours)
  const advanceTime = (hours) => {
    currentTime = (currentTime + hours) % 24;
    saveState();
  };

  // Display the current sky tint in a readable format
  const displayTint = () => {
    const tint = calculateTint();
    const timeOfDay = getTimeOfDay();

    console.log('\x1b[1mCurrent Sky Tint:\x1b[0m');
    console.log(`  Time of Day: ${timeOfDay}`);
    console.log(`  Hue: ${tint.hue}° (${hsvToColorName(tint.hue)})`);
    console.log(`  Saturation: ${tint.saturation * 100}%`);
    console.log(`  Brightness: ${tint.brightness * 100}%`);
    console.log(`  Weather: ${weatherEffect.charAt(0).toUpperCase() + weatherEffect.slice(1)}`);
    console.log('\x1b[1mSimulation State:\x1b[0m');
    console.log(`  Current Time: ${currentTime.toFixed(1)}:00`);
    console.log(`  Total Duration: ${DAWN_DURATION + DAY_DURATION + DUSK_DURATION + NIGHT_DURATION} hours`);
    console.log(`  Current Phase: ${getCurrentPhase()}`);
  };

  // Helper to get time of day
  const getTimeOfDay = () => {
    const timeInHours = currentTime;
    if (timeInHours >= 4 && timeInHours < 6) return 'Dawn';
    if (timeInHours >= 6 && timeInHours < 18) return 'Day';
    if (timeInHours >= 18 && timeInHours < 20) return 'Dusk';
    return 'Night';
  };

  // Helper to get current phase
  const getCurrentPhase = () => {
    const timeInHours = currentTime;
    if (timeInHours >= 4 && timeInHours < 6) return 'Dawn';
    if (timeInHours >= 6 && timeInHours < 18) return 'Day';
    if (timeInHours >= 18 && timeInHours < 20) return 'Dusk';
    return 'Night';
  };

  // Helper to convert hue to color name
  const hsvToColorName = (hue) => {
    const colors = [
      'Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet', 'Magenta'
    ];
    const index = Math.floor(hue / 30) % colors.length;
    return colors[index];
  };

  // Public API
  return {
    loadState,
    saveState,
    calculateTint,
    advanceTime,
    displayTint,
    getCurrentTime: () => currentTime,
    setWeatherEffect: (effect) => {
      if (['clear', 'rain', 'snow', 'fog'].includes(effect)) {
        weatherEffect = effect;
        saveState();
      }
    },
  };
})();

// Initialize the simulator
const simulator = SkyTintSimulator;

// Initialize readline interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Main command loop
async function main() {
  await simulator.loadState();
  simulator.displayTint();

  console.log('\n\x1b[1mCommands:\x1b[0m');
  console.log('  - "advance [hours]": Advance time by specified hours');
  console.log('  - "set weather [effect]": Set weather effect (clear, rain, snow, fog)');
  console.log('  - "reset": Reset to 12:00 PM');
  console.log('  - "exit": Quit the simulation');
  console.log('  - "display": Display current tint');

  rl.on('line', async (line) => {
    const args = line.trim().split(' ');
    const command = args[0].toLowerCase();

    switch (command) {
      case 'advance':
        if (args.length > 1 && !isNaN(parseFloat(args[1]))) {
          simulator.advanceTime(parseFloat(args[1]));
          simulator.displayTint();
        } else {
          console.log('Usage: advance [hours]');
        }
        break;
      case 'set':
        if (args.length > 2 && args[1].toLowerCase() === 'weather') {
          const effect = args[2].toLowerCase();
          if (['clear', 'rain', 'snow', 'fog'].includes(effect)) {
            simulator.setWeatherEffect(effect);
            simulator.displayTint();
          } else {
            console.log('Invalid weather effect. Use: clear, rain, snow, fog');
          }
        } else {
          console.log('Usage: set weather [effect]');
        }
        break;
      case 'reset':
        simulator.advanceTime(0 - simulator.getCurrentTime());
        simulator.displayTint();
        break;
      case 'exit':
        rl.close();
        break;
      case 'display':
        simulator.displayTint();
        break;
      default:
        console.log('Unknown command. Available commands: advance, set weather, reset, exit, display');
    }
  });

  rl.on('close', () => {
    console.log('\nExiting simulation. State saved.');
    process.exit(0);
  });
}

// Start the simulation
main().catch(console.error);