A!leys Galerie

// Ailey's Dynamic RPG Weather Simulator
// Features: Day/night cycle with atmospheric tints, weather effects, and confetti animations

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

let currentTime = 0; // Time in seconds
let dayCycle = 0; // 0-24 hours
let weatherConditions = ['Clear', 'Partly Cloudy', 'Cloudy', 'Rainy', 'Stormy'];
let weatherIndex = 0;
let skyTints = [
    { name: 'Sunrise', color: '#FF6B35' },
    { name: 'Morning', color: '#FFD23F' },
    { name: 'Daytime', color: '#A0D8FF' },
    { name: 'Afternoon', color: '#4DB5FF' },
    { name: 'Evening', color: '#FF6B9D' },
    { name: 'Sunset', color: '#FF2E63' },
    { name: 'Night', color: '#1A1A2E' },
    { name: 'Midnight', color: '#0A0E2A' }
];
let currentTint = 0;
let isRaining = false;
let isStormy = false;
let isSpecialWeather = false;
let confettiActive = false;
let confettiCount = 0;
let specialWeatherAchieved = false;

// DOM simulation for visual output
const terminalOutput = document.createElement('div');
terminalOutput.style.fontFamily = 'monospace';
terminalOutput.style.whiteSpace = 'pre';
document.body.appendChild(terminalOutput);

// Weather effect elements
const weatherContainer = document.createElement('div');
weatherContainer.style.position = 'fixed';
weatherContainer.style.top = '0';
weatherContainer.style.left = '0';
weatherContainer.style.width = '100%';
weatherContainer.style.height = '100%';
weatherContainer.style.pointerEvents = 'none';
weatherContainer.style.zIndex = '9999';
document.body.appendChild(weatherContainer);

// Confetti elements
const confettiElements = [];

function updateTerminal(time, tint, weather) {
    terminalOutput.innerHTML = `
    ┌─────────────────────────────────────┐
    | Ailey's RPG Weather Simulator        |
    | Time: ${time.toFixed(1)} hours        |
    | Weather: ${weather}                   |
    | Atmosphere: ${skyTints[tint].name}    |
    | Account: ${getAchievementStatus()}    |
    └─────────────────────────────────────┘
    `;

    // Update background tint
    document.body.style.backgroundColor = skyTints[tint].color;

    // Apply weather effects
    if (isRaining) {
        drawRain();
    }
    if (isStormy) {
        drawStorm();
    }
    if (isSpecialWeather && !confettiActive) {
        triggerConfettiAnimation();
    }

    requestAnimationFrame(updateTerminal);
}

function drawRain() {
    if (!isRaining) return;

    const rainDrops = document.createElement('div');
    rainDrops.style.position = 'fixed';
    rainDrops.style.top = '0';
    rainDrops.style.left = '0';
    rainDrops.style.width = '100%';
    rainDrops.style.height = '100%';
    rainDrops.style.pointerEvents = 'none';
    rainDrops.style.zIndex = '9998';
    rainDrops.style.backgroundImage = 'linear-gradient(to bottom, rgba(0, 150, 255, 0.3), rgba(0, 150, 255, 0.1))';
    weatherContainer.appendChild(rainDrops);
}

function drawStorm() {
    if (!isStormy) return;

    const stormElements = document.createElement('div');
    stormElements.style.position = 'fixed';
    stormElements.style.top = '0';
    stormElements.style.left = '0';
    stormElements.style.width = '100%';
    stormElements.style.height = '100%';
    stormElements.style.pointerEvents = 'none';
    stormElements.style.zIndex = '9997';
    stormElements.style.backgroundImage = 'radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%)';
    stormElements.style.animation = 'storm 10s infinite';
    weatherContainer.appendChild(stormElements);

    const style = document.createElement('style');
    style.textContent = `
        @keyframes storm {
            0% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%); }
            20% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.2) 0%, transparent 50%); }
            40% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%); }
            60% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.3) 0%, transparent 50%); }
            80% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%); }
            100% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.2) 0%, transparent 50%); }
        }
    `;
    document.head.appendChild(style);
}

function triggerConfettiAnimation() {
    if (confettiActive || specialWeatherAchieved) return;

    confettiActive = true;
    confettiCount = 0;
    specialWeatherAchieved = true;

    // Stop existing rain/storm effects
    if (isRaining) {
        const rainDrops = document.querySelector('div[style*="backgroundImage: linear-gradient"]');
        if (rainDrops) rainDrops.remove();
    }
    if (isStormy) {
        const stormElements = document.querySelector('div[style*="animation: storm"]');
        if (stormElements) stormElements.remove();
    }

    // Create confetti
    function createConfetti() {
        if (confettiCount >= 100) {
            confettiActive = false;
            return;
        }

        const confetti = document.createElement('div');
        confetti.style.position = 'fixed';
        confetti.style.width = '10px';
        confetti.style.height = '10px';
        confetti.style.backgroundColor = getRandomColor();
        confetti.style.borderRadius = '50%';
        confetti.style.pointerEvents = 'none';
        confetti.style.zIndex = '9999';

        // Position on screen edges
        if (Math.random() > 0.5) {
            confetti.style.left = '0';
            confetti.style.top = `${Math.random() * 100}%`;
        } else {
            confetti.style.right = '0';
            confetti.style.top = `${Math.random() * 100}%`;
        }

        confetti.style.animation = `confetti-fall ${Math.random() * 3 + 2}s forwards`;

        weatherContainer.appendChild(confetti);
        confettiElements.push(confetti);
        confettiCount++;

        requestAnimationFrame(createConfetti);
    }

    // Add confetti animation styles
    const style = document.createElement('style');
    style.textContent = `
        @keyframes confetti-fall {
            0% {
                transform: translateX(0) rotate(0deg);
                opacity: 1;
            }
            50% {
                transform: translateX(50vw) rotate(180deg);
            }
            100% {
                transform: translateX(100vw) rotate(360deg);
                opacity: 0;
            }
        }
    `;
    document.head.appendChild(style);

    createConfetti();
}

function getRandomColor() {
    const letters = '0123456789ABCDEF';
    let color = '#';
    for (let i = 0; i < 6; i++) {
        color += letters[Math.floor(Math.random() * 16)];
    }
    return color;
}

function updateWeather() {
    // Natural weather changes based on time and randomness
    const timeOfDay = dayCycle % 24;

    // More rain at certain times
    if (Math.random() < 0.1) {
        isRaining = true;
        isStormy = false;
        weatherIndex = 2; // Cloudy
    } else if (Math.random() < 0.05) {
        isRaining = false;
        isStormy = true;
        weatherIndex = 3; // Rainy (now stormy)
    } else {
        isRaining = false;
        isStormy = false;
        weatherIndex = Math.max(0, Math.min(3, Math.floor(Math.random() * weatherConditions.length)));
    }

    // Special weather based on time of day and randomness
    if (timeOfDay >= 20 || timeOfDay < 4) { // Late evening to early morning
        if (Math.random() < 0.01) {
            isSpecialWeather = true;
        }
    }

    // Update sky tint based on time of day
    if (timeOfDay < 4) {
        currentTint = 7; // Midnight
    } else if (timeOfDay < 6) {
        currentTint = 6; // Sunrise
    } else if (timeOfDay < 9) {
        currentTint = 1; // Morning
    } else if (timeOfDay < 15) {
        currentTint = 2; // Daytime
    } else if (timeOfDay < 18) {
        currentTint = 3; // Afternoon
    } else if (timeOfDay < 20) {
        currentTint = 4; // Evening
    } else {
        currentTint = 5; // Sunset
    }
}

function getAchievementStatus() {
    if (specialWeatherAchieved) {
        return "⭐ SPECIAL WEATHER ACHIEVED! ⭐";
    } else if (isStormy) {
        return "⚡ STORMY WEATHER ⚡";
    } else if (isRaining) {
        return "🌧 RAINY WEATHER 🌧";
    } else {
        return "";
    }
}

// Main simulation loop
function runSimulation() {
    currentTime = 0;
    dayCycle = 0;

    updateTerminal(dayCycle, currentTint, weatherConditions[weatherIndex]);
    updateWeather();

    const simulationInterval = setInterval(() => {
        currentTime += 1;
        dayCycle = currentTime / 3600; // Convert to hours
        updateWeather();
        updateTerminal(dayCycle, currentTint, weatherConditions[weatherIndex]);

        if (dayCycle > 24) {
            clearInterval(simulationInterval);
            terminalOutput.innerHTML += "\n\n🎉 Simulated 24 hours of RPG weather! 🎉";
        }
    }, 1000);
}

// Start the simulation
runSimulation();

// Handle user input to change simulation speed
readline.on('line', (input) => {
    const speed = parseFloat(input);
    if (!isNaN(speed)) {
        const simulationInterval = setInterval(() => {
            currentTime += speed;
            dayCycle = currentTime / 3600;
            updateWeather();
            updateTerminal(dayCycle, currentTint, weatherConditions[weatherIndex]);

            if (dayCycle > 24) {
                clearInterval(simulationInterval);
                terminalOutput.innerHTML += "\n\n🎉 Simulated 24 hours of RPG weather! 🎉";
            }
        }, 100);
    }
});

readline.on('close', () => {
    console.log('Simulation stopped.');
    process.exit(0);
});

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class VoronoiFractalTerrain : MonoBehaviour
{
    [Header("Generation Settings")]
    [SerializeField] private int width = 128;
    [SerializeField] private int length = 128;
    [SerializeField] private float scale = 1f;
    [SerializeField] private int maxIterations = 8;
    [SerializeField] private float erosionFactor = 0.7f;
    [SerializeField] private AnimationCurve heightCurve;

    [Header("Visual Settings")]
    [SerializeField] private Material terrainMaterial;
    [SerializeField] private float meshDetail = 1f;

    private Mesh mesh;
    private Vector3[] vertices;
    private int[] triangles;
    private Color[] colors;

    private void Start()
    {
        GenerateTerrain();
        GetComponent<MeshFilter>().mesh = mesh;
        GetComponent<MeshRenderer>().material = terrainMaterial;
    }

    [ContextMenu("Generate Terrain")]
    private void GenerateTerrain()
    {
        GenerateVoronoiFractal();
        CreateMesh();
    }

    private void GenerateVoronoiFractal()
    {
        float[,] heightMap = new float[width, length];

        // Step 1: Generate Voronoi points
        Vector2[] points = GenerateRandomPoints(width, length, scale * 0.1f);

        // Step 2: Calculate Voronoi distances
        float[,] voronoiDistances = CalculateVoronoiDistances(points, width, length);

        // Step 3: Apply fractal erosion
        ErodeFractal(voronoiDistances, maxIterations, erosionFactor);

        // Step 4: Normalize and curve
        float minHeight = Mathf.Min(0f, Mathf.Min(voronoiDistances));
        float maxHeight = Mathf.Max(0f, Mathf.Max(voronoiDistances));
        float range = maxHeight - minHeight;

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                heightMap[x, z] = Mathf.Clamp01((voronoiDistances[x, z] - minHeight) / range);
                heightMap[x, z] = heightCurve.Evaluate(heightMap[x, z]);
            }
        }

        // Generate noise layer for texture variation
        float[,] noiseLayer = GenerateNoiseLayer(width, length, 0.2f);

        // Combine layers
        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                heightMap[x, z] = Mathf.Clamp01(heightMap[x, z] + noiseLayer[x, z] * 0.3f);
            }
        }
    }

    private Vector2[] GenerateRandomPoints(int width, int length, float minDistance)
    {
        List<Vector2> points = new List<Vector2>();

        for (int i = 0; i < width * length / 20; i++)
        {
            Vector2 point = new Vector2(
                Random.Range(0, width),
                Random.Range(0, length)
            );

            if (IsPointValid(points, point, minDistance))
            {
                points.Add(point);
            }
        }

        return points.ToArray();
    }

    private bool IsPointValid(List<Vector2> existingPoints, Vector2 newPoint, float minDistance)
    {
        foreach (Vector2 point in existingPoints)
        {
            float distance = Vector2.Distance(point, newPoint);
            if (distance < minDistance)
            {
                return false;
            }
        }
        return true;
    }

    private float[,] CalculateVoronoiDistances(Vector2[] points, int width, int length)
    {
        float[,] distances = new float[width, length];

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                float minDistance = float.MaxValue;

                foreach (Vector2 point in points)
                {
                    float distance = Vector2.Distance(
                        new Vector2(x, z),
                        point
                    );

                    if (distance < minDistance)
                    {
                        minDistance = distance;
                    }
                }

                distances[x, z] = -minDistance; // Invert for mountain-like terrain
            }
        }

        return distances;
    }

    private void ErodeFractal(float[,] heightMap, int iterations, float erosionFactor)
    {
        for (int i = 0; i < iterations; i++)
        {
            float[,] eroded = new float[heightMap.GetLength(0), heightMap.GetLength(1)];

            for (int x = 1; x < heightMap.GetLength(0) - 1; x++)
            {
                for (int z = 1; z < heightMap.GetLength(1) - 1; z++)
                {
                    float erosion = (heightMap[x-1, z] + heightMap[x+1, z] + heightMap[x, z-1] + heightMap[x, z+1]) / 4f;
                    erosion = Mathf.Lerp(heightMap[x, z], erosion, erosionFactor);
                    eroded[x, z] = erosion;
                }
            }

            heightMap = eroded;
        }
    }

    private float[,] GenerateNoiseLayer(int width, int length, float scale)
    {
        float[,] noiseLayer = new float[width, length];
        float[,] perlinNoise = new float[width, length];

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                float xCoord = (float)x / width * scale;
                float zCoord = (float)z / length * scale;
                perlinNoise[x, z] = Mathf.PerlinNoise(xCoord, zCoord) * 0.5f + 0.5f;
            }
        }

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                // Apply fractal noise
                float total = perlinNoise[x, z];
                for (int i = 1; i < 4; i++)
                {
                    xCoord *= 2f;
                    zCoord *= 2f;
                    total += Mathf.PerlinNoise(xCoord, zCoord) * (1f / (float)Mathf.Pow(2, i));
                }
                noiseLayer[x, z] = (total - 0.5f) * 2f; // Normalize to -1..1
            }
        }

        return noiseLayer;
    }

    private void CreateMesh()
    {
        int width = this.width;
        int length = this.length;

        vertices = new Vector3[width * length];
        colors = new Color[width * length];
        triangles = new int[(width - 1) * (length - 1) * 6];

        for (int x = 0, i = 0; x < width; x++, i += length)
        {
            for (int z = 0; z < length; z++, i++)
            {
                vertices[i] = new Vector3(x * meshDetail, 0, z * meshDetail);
                float height = Mathf.Clamp01(heightCurve.Evaluate(Mathf.Abs(vertices[i].x / (float)width * 2f - 1f)));
                vertices[i].y = height * scale * 5f;

                // Create terrain colors based on height
                float r = Mathf.Clamp01(1f - vertices[i].y / (scale * 5f)) * 0.5f;
                float g = Mathf.Clamp01(vertices[i].y / (scale * 5f)) * 0.7f;
                float b = 0.1f;
                colors[i] = new Color(r, g, b, 1f);
            }
        }

        for (int x = 0, i = 0; x < width - 1; x++, i += length)
        {
            for (int z = 0; z < length - 1; z++, i++)
            {
                triangles[i * 6] = i;
                triangles[i * 6 + 1] = i + length;
                triangles[i * 6 + 2] = i + 1;

                triangles[i * 6 + 3] = i + 1;
                triangles[i * 6 + 4] = i + length;
                triangles[i * 6 + 5] = i + length + 1;
            }
        }

        mesh = new Mesh
        {
            vertices = vertices,
            triangles = triangles,
            colors = colors,
            bounds = new Bounds(Vector3.zero, Vector3.one * 10f)
        };
        mesh.RecalculateNormals();
    }

#if UNITY_EDITOR
    [MenuItem("Tools/Generate Terrain")]
    public static void GenerateTerrainFromMenu()
    {
        GameObject terrain = GameObject.FindObjectOfType<VoronoiFractalTerrain>()?.gameObject;
        if (terrain == null)
        {
            terrain = new GameObject("VoronoiTerrain");
            terrain.AddComponent<VoronoiFractalTerrain>();
        }

        VoronoiFractalTerrain generator = terrain.GetComponent<VoronoiFractalTerrain>();
        generator.GenerateTerrain();
    }
#endif
}