A!leys Galerie

// RPG Maker MZ Dynamic AI Behavior Simulator
// Simulates NPC behavior including wandering, interaction, and emotional state

const { EventEmitter } = require('events');
const { v4: uuidv4 } = require('uuid');

class RPGMAISEmitter extends EventEmitter {
  constructor() {
    super();
    this.npcs = new Map();
  }

  addNPC(name, x, y, mapId) {
    const id = uuidv4();
    this.npcs.set(id, {
      id,
      name,
      x,
      y,
      mapId,
      emotionalState: 'neutral',
      currentTask: null,
      wanderTarget: null,
      lastInteraction: null
    });
    this.emit('npcAdded', id);
    return id;
  }

  updateNPC(id, x, y) {
    const npc = this.npcs.get(id);
    if (npc) {
      npc.x = x;
      npc.y = y;
      this.emit('npcMoved', id, x, y);
    }
  }

  interact(id, playerId, interactionType) {
    const npc = this.npcs.get(id);
    if (npc) {
      npc.emotionalState = interactionType === 'positive' ? 'happy' : 'angry';
      npc.lastInteraction = {
        playerId,
        type: interactionType,
        timestamp: Date.now()
      };
      this.emit('npcInteracted', id, playerId, interactionType);
    }
  }

  getNPCStatus(id) {
    const npc = this.npcs.get(id);
    if (npc) {
      return {
        id: npc.id,
        name: npc.name,
        position: { x: npc.x, y: npc.y },
        mapId: npc.mapId,
        emotionalState: npc.emotionalState,
        lastInteraction: npc.lastInteraction
      };
    }
    return null;
  }

  simulateFrame() {
    for (const [id, npc] of this.npcs) {
      // Wander behavior
      if (!npc.wanderTarget) {
        npc.wanderTarget = {
          x: npc.x + (Math.random() > 0.5 ? 1 : -1) * 3,
          y: npc.y + (Math.random() > 0.5 ? 1 : -1) * 3
        };
      }

      // Move toward wander target
      const dx = npc.wanderTarget.x - npc.x;
      const dy = npc.wanderTarget.y - npc.y;
      const distance = Math.sqrt(dx * dx + dy * dy);

      if (distance < 1) {
        npc.wanderTarget = null;
      } else {
        npc.x += (dx / distance) * 0.5;
        npc.y += (dy / distance) * 0.5;
        this.emit('npcMoved', id, npc.x, npc.y);
      }

      // Emotional state decay
      if (npc.emotionalState !== 'neutral') {
        if (Math.random() < 0.05) { // 5% chance to reset state each frame
          npc.emotionalState = 'neutral';
        }
      }
    }
  }
}

// Simulation setup
const rpgAI = new RPGMAISEmitter();

// Example NPCs
const merchantId = rpgAI.addNPC('Traveling Merchant', 10, 10, 1);
const guardId = rpgAI.addNPC('Town Guard', 15, 15, 1);
const wandererId = rpgAI.addNPC('Lost Wanderer', 5, 5, 1);

// Example interactions
setTimeout(() => {
  rpgAI.interact(merchantId, 'player1', 'positive');
}, 1000);

setTimeout(() => {
  rpgAI.interact(guardId, 'player1', 'negative');
}, 2000);

// Simulation loop
setInterval(() => {
  rpgAI.simulateFrame();
}, 16); // ~60fps

// Status check every 5 seconds
setInterval(() => {
  console.log('Current NPC States:');
  for (const id of rpgAI.npcs.keys()) {
    const status = rpgAI.getNPCStatus(id);
    if (status) {
      console.log(`- ${status.name}: ${status.emotionalState} (${status.position.x}, ${status.position.y})`);
      if (status.lastInteraction) {
        console.log(`  Last interaction: ${status.lastInteraction.type} with player ${status.lastInteraction.playerId}`);
      }
    }
  }
  console.log('------------------');
}, 5000);

// Export for potential RPG Maker MZ integration
module.exports = RPGMAISEmitter;

using UnityEngine;
using UnityEngine.UI;
using System;
using System.Collections.Generic;
using System.Linq;

/// <summary>
/// Ailey's SmoothTween - A creative, smooth animation system with dark mode support
/// Features: Smooth Easing, Multiple Targets, Dark Mode Toggle, Event Callbacks
/// </summary>
[DisallowMultipleComponent]
public class SmoothTween : MonoBehaviour
{
    [Serializable]
    public class TweenTarget
    {
        public enum PropertyType { Float, Vector3, Color, RectTransform }

        public PropertyType propertyType;
        public string targetName;
        public float initialValue;
        public float targetValue;
        public EaseType easeType;
        public float duration;
        public bool darkModeColor = false;
        public Color darkColor;
        public Action<float> progressCallback;
        public Action completeCallback;
    }

    [Serializable]
    public enum EaseType
    {
        Linear,
        EaseInQuad,
        EaseOutQuad,
        EaseInOutQuad,
        EaseInCubic,
        EaseOutCubic,
        EaseInOutCubic,
        EaseInQuart,
        EaseOutQuart,
        EaseInOutQuart,
        SmoothStep,
        Bounce
    }

    [Header("Settings")]
    [SerializeField] private bool autoStart = false;
    [SerializeField] private float smoothness = 1.2f;
    [SerializeField] private bool darkMode = false;
    [SerializeField] private Color darkModeBackground = new Color(0.1f, 0.1f, 0.15f);
    [SerializeField] private Color darkModeText = new Color(0.9f, 0.9f, 0.95f);

    [Header("Tween Targets")]
    public List<TweenTarget> targets = new List<TweenTarget>();
    private List<Coroutine> activeCoroutines = new List<Coroutine>();

    private void Awake()
    {
        if (autoStart)
        {
            StartAllTweens();
        }

        // Apply dark mode if enabled
        if (darkMode)
        {
            ToggleDarkMode(true);
        }
    }

    public void StartAllTweens()
    {
        foreach (var coroutine in activeCoroutines)
        {
            StopCoroutine(coroutine);
        }
        activeCoroutines.Clear();

        foreach (var target in targets)
        {
            activeCoroutines.Add(StartCoroutine(Animate(target)));
        }
    }

    public void StopAllTweens()
    {
        foreach (var coroutine in activeCoroutines)
        {
            StopCoroutine(coroutine);
        }
        activeCoroutines.Clear();
    }

    public void ToggleDarkMode(bool enable)
    {
        darkMode = enable;

        // Apply dark mode to UI elements
        var uiElements = FindObjectsOfType<Graphic>(true);
        foreach (var ui in uiElements)
        {
            ui.color = enable ? darkModeText : Color.white;
        }

        // Change background if Canvas exists
        var canvas = FindObjectOfType<Canvas>();
        if (canvas != null && canvas.renderMode == RenderMode.ScreenSpaceCamera)
        {
            var renderers = canvas.GetComponentsInChildren<Renderer>(true);
            foreach (var renderer in renderers)
            {
                renderer.material.color = enable ? darkModeBackground : Color.white;
            }
        }
    }

    private IEnumerator Animate(TweenTarget target)
    {
        float elapsedTime = 0f;
        float initialValue = target.initialValue;
        float progress = 0f;

        while (elapsedTime < target.duration)
        {
            elapsedTime += Time.deltaTime;
            progress = CalculateProgress(elapsedTime, target.duration, target.easeType);

            float currentValue;
            switch (target.propertyType)
            {
                case TweenTarget.PropertyType.Float:
                    currentValue = Mathf.Lerp(initialValue, target.targetValue, progress);
                    break;

                case TweenTarget.PropertyType.Vector3:
                    var vecTarget = target.targetValue;
                    var vecInitial = target.initialValue;
                    currentValue = Mathf.Lerp(vecInitial, vecTarget, progress);
                    break;

                case TweenTarget.PropertyType.Color:
                    var colorTarget = target.darkModeColor ? target.darkColor : target.targetValue;
                    var colorInitial = target.initialValue;
                    currentValue = Mathf.Lerp(colorInitial.r, colorTarget.r, progress);
                    currentValue = Mathf.Lerp(currentValue, colorTarget.g, progress);
                    currentValue = Mathf.Lerp(currentValue, colorTarget.b, progress);
                    currentValue = Mathf.Lerp(currentValue, colorTarget.a, progress);
                    break;

                case TweenTarget.PropertyType.RectTransform:
                    var rectTarget = target.targetValue;
                    var rectInitial = target.initialValue;
                    currentValue = Mathf.Lerp(rectInitial, rectTarget, progress);
                    break;

                default:
                    currentValue = Mathf.Lerp(initialValue, target.targetValue, progress);
                    break;
            }

            // Apply the value based on target type
            ApplyValueToTarget(target, currentValue, progress);

            // Smoothness adjustment
            float smoothedProgress = SmoothStep(progress, smoothness);
            target.progressCallback?.Invoke(smoothedProgress);

            yield return null;
        }

        // Final value
        ApplyValueToTarget(target, target.targetValue, 1f);
        target.progressCallback?.Invoke(1f);
        target.completeCallback?.Invoke();

        // Remove the coroutine from active list
        if (activeCoroutines.Contains(coroutine))
        {
            activeCoroutines.Remove(coroutine);
        }
    }

    private void ApplyValueToTarget(TweenTarget target, float currentValue, float progress)
    {
        switch (target.propertyType)
        {
            case TweenTarget.PropertyType.Float:
                var floatTarget = FindTarget<float>(target.targetName);
                if (floatTarget != null)
                {
                    floatTarget.value = currentValue;
                }
                break;

            case TweenTarget.PropertyType.Vector3:
                var vecTarget = FindTarget<Vector3>(target.targetName);
                if (vecTarget != null)
                {
                    vecTarget.value = Vector3.Lerp(vecTarget.value, (Vector3)currentValue, progress * 2f);
                }
                break;

            case TweenTarget.PropertyType.Color:
                var colorTarget = FindTarget<Color>(target.targetName);
                if (colorTarget != null)
                {
                    colorTarget.value = Color.Lerp(colorTarget.value, (Color)currentValue, progress * 2f);
                }
                break;

            case TweenTarget.PropertyType.RectTransform:
                var rectTarget = FindTarget<RectTransform>(target.targetName);
                if (rectTarget != null)
                {
                    rectTarget.value.anchoredPosition = Vector2.Lerp(rectTarget.value.anchoredPosition, (Vector2)currentValue, progress * 2f);
                }
                break;
        }
    }

    private T FindTarget<T>(string name)
    {
        var components = GetComponentsInChildren<T>(true);
        return components.FirstOrDefault(c => c.name == name);
    }

    private float CalculateProgress(float elapsedTime, float duration, EaseType easeType)
    {
        float normalizedTime = elapsedTime / duration;

        switch (easeType)
        {
            case EaseType.Linear:
                return normalizedTime;

            case EaseType.EaseInQuad:
                return normalizedTime * normalizedTime;

            case EaseType.EaseOutQuad:
                return normalizedTime * (2 - normalizedTime);

            case EaseType.EaseInOutQuad:
                if (normalizedTime < 0.5f)
                    return 2 * normalizedTime * normalizedTime;
                else
                    return -1 + (4 * --normalizedTime * normalizedTime);

            case EaseType.EaseInCubic:
                return normalizedTime * normalizedTime * normalizedTime;

            case EaseType.EaseOutCubic:
                return (--normalizedTime) * (normalizedTime) * (normalizedTime) + 1;

            case EaseType.EaseInOutCubic:
                if (normalizedTime < 0.5f)
                    return 4 * normalizedTime * normalizedTime * normalizedTime;
                else
                    return (normalizedTime - 1) * (normalizedTime - 1) * (normalizedTime - 1) + 1;

            case EaseType.EaseInQuart:
                return normalizedTime * normalizedTime * normalizedTime * normalizedTime;

            case EaseType.EaseOutQuart:
                return 1 - (--normalizedTime) * (normalizedTime) * (normalizedTime) * (normalizedTime);

            case EaseType.EaseInOutQuart:
                if (normalizedTime < 0.5f)
                    return 8 * normalizedTime * normalizedTime * normalizedTime * normalizedTime;
                else
                    return 1 - 8 * (--normalizedTime) * (normalizedTime) * (normalizedTime) * (normalizedTime);

            case EaseType.SmoothStep:
                return normalizedTime * normalizedTime * (3 - 2 * normalizedTime);

            case EaseType.Bounce:
                if (normalizedTime < 0.363636f)
                    return 7.5684f * normalizedTime * normalizedTime;
                else if (normalizedTime < 0.727272f)
                    return 7.5684f * (normalizedTime - 0.545454f) * (normalizedTime - 0.545454f) + 0.75f;
                else if (normalizedTime < 0.909090f)
                    return 7.5684f * (normalizedTime - 0.818181f) * (normalizedTime - 0.818181f) + 0.9375f;
                else
                    return 7.5684f * (normalizedTime - 0.954545f) * (normalizedTime - 0.954545f) + 0.984375f;

            default:
                return normalizedTime;
        }
    }

    private float SmoothStep(float x, float smoothness)
    {
        return x * x * (3 - 2 * x);
    }
}