A!leys Galerie

// CelestialAmbiance - Advanced Day/Night Cycle with Atmospheric Tinting & Weather Effects
// Designed for RPG Maker MZ but runs standalone in Node.js
// Features: Smooth sky transitions, adaptive tinting, dynamic weather particles, and celestial events

const { TiledCanvas } = require("tiled-canvas"); // For in-browser/Node.js compatibility
const MathUtils = require("math-utils"); // Custom module for trigonometric helpers

// Configuration
const config = {
    cycleDuration: 24 * 60 * 1000, // 24h in ms
    time: 0, // Current time in ms (0 = midnight)
    sunPosition: { x: 0.5, y: 0.5 },
    moonPosition: { x: 0.5, y: 0.5 },
    weatherIntensity: 0.1,
    weatherTypes: ['rain', 'snow', 'fog', 'clear'],
    weatherTransitionSpeed: 0.05,
    ambientLight: { r: 0.2, g: 0.2, b: 0.4 },
    celestialEvents: [
        { time: 12 * 60 * 60 * 1000, event: 'sunrise', color: { r: 1, g: 0.8, b: 0.2 } },
        { time: 18 * 60 * 60 * 1000, event: 'sunset', color: { r: 1, g: 0.4, b: 0.2 } },
        { time: 2 * 60 * 60 * 1000, event: 'moonrise', color: { r: 0.8, g: 0.8, b: 1 } }
    ]
};

// Custom Math Utilities
const MathHelper = {
    radiansToDegrees: (rad) => rad * (180 / Math.PI),
    degreesToRadians: (deg) => deg * (Math.PI / 180),
    map: (value, inMin, inMax, outMin, outMax) => outMin + (outMax - outMin) * ((value - inMin) / (inMax - inMin)),
    // Simulate atmospheric scattering (Chandrasekhar's model simplified)
    getSkyTint: (sunAngle) => {
        const angle = MathHelper.map(sunAngle, -90, 90, 0, 1);
        const intensity = Math.sin(angle * Math.PI / 180) * 0.7 + 0.3;
        return {
            r: 0.2 + intensity * 0.5,
            g: 0.2 + intensity * 0.4,
            b: 0.4 + intensity * 0.6
        };
    },
    // Simulate sun/moon position based on time
    getCelestialPosition: (time, isMoon = false) => {
        const normalizedTime = (time / (config.cycleDuration / 2)) % 2; // 0-1 cycle
        const angle = normalizedTime * 360 - (isMoon ? 180 : 0);
        const deg = angle;
        return {
            x: 0.5 + Math.cos(MathHelper.degreesToRadians(deg)) * 0.4,
            y: 0.5 + Math.sin(MathHelper.degreesToRadians(deg)) * 0.4
        };
    }
};

// Weather System
const Weather = {
    currentType: 'clear',
    particles: [],
    update: (canvas, ctx) => {
        // Clear previous particles if transitioning
        if (Weather.currentType !== config.weatherTypes[0]) {
            Weather.particles = [];
        }

        // Random particle generation based on weather type
        const weather = config.weatherTypes[Math.floor(config.weatherIntensity * config.weatherTypes.length)];
        if (weather !== Weather.currentType) {
            Weather.currentType = weather;
        }

        const particleCount = 20 + Math.floor(Math.random() * 50);
        for (let i = 0; i < particleCount; i++) {
            Weather.particles.push({
                x: Math.random() * canvas.width,
                y: Math.random() * canvas.height,
                size: Math.random() * 3,
                speed: Math.random() * 2,
                type: Weather.currentType
            });
        }

        // Draw particles
        Weather.particles.forEach(particle => {
            ctx.beginPath();
            ctx.arc(particle.x, particle.y, particle.size, 0, Math.PI * 2);
            ctx.fillStyle = Weather.getParticleColor(particle.type);
            ctx.fill();
            ctx.closePath();

            // Update position
            particle.y += particle.speed * (Weather.currentType === 'snow' ? 0.5 : 1);
            if (particle.y > canvas.height + particle.size) {
                particle.y = -particle.size;
                particle.x = Math.random() * canvas.width;
            }
        });
    },
    getParticleColor: (type) => {
        switch (type) {
            case 'rain': return 'rgba(100, 180, 255, 0.6)';
            case 'snow': return 'rgba(255, 255, 255, 0.8)';
            case 'fog': return 'rgba(200, 220, 255, 0.3)';
            default: return 'transparent';
        }
    }
};

// Main Renderer
class CelestialRenderer {
    constructor(width, height) {
        this.canvas = new TiledCanvas(width, height);
        this.ctx = this.canvas.getContext();
        this.width = width;
        this.height = height;
        this.frameCount = 0;
        this.lastEventTime = 0;
    }

    update(time) {
        // Update celestial positions and time
        config.time = time;
        config.sunPosition = MathHelper.getCelestialPosition(time, false);
        config.moonPosition = MathHelper.getCelestialPosition(time, true);

        // Handle celestial events
        config.celestialEvents.forEach(event => {
            if (Math.abs(time - event.time) < 60000 && time > this.lastEventTime) { // 1 minute window
                this.lastEventTime = time;
                console.log(`Event triggered: ${event.event}`);
                // In RPG Maker, this would trigger an event or sound
            }
        });

        // Clear canvas with adaptive background
        this.ctx.clearRect(0, 0, this.width, this.height);

        // Draw sky gradient based on sun position
        const sunAngle = MathHelper.radiansToDegrees(
            Math.atan2(
                config.sunPosition.y - 0.5,
                config.sunPosition.x - 0.5
            )
        );

        const skyTint = MathHelper.getSkyTint(sunAngle);
        const topColor = `rgba(${skyTint.r * 255}, ${skyTint.g * 255}, ${skyTint.b * 255}, 0.8)`;
        const bottomColor = `rgba(${skyTint.r * 150}, ${skyTint.g * 150}, ${skyTint.b * 150}, 0.6)`;

        this.ctx.fillStyle = topColor;
        this.ctx.fillRect(0, 0, this.width, this.height / 2);

        this.ctx.fillStyle = bottomColor;
        this.ctx.fillRect(0, this.height / 2, this.width, this.height / 2);

        // Draw sun and moon (simplified as circles)
        this.drawSunMoon(config.sunPosition, 'yellow', 0.1);
        this.drawSunMoon(config.moonPosition, 'white', 0.08);

        // Update weather
        Weather.update(this.canvas, this.ctx);

        this.frameCount++;
    }

    drawSunMoon(position, color, size) {
        const x = position.x * this.width;
        const y = position.y * this.height;
        const radius = size * Math.min(this.width, this.height);

        this.ctx.beginPath();
        this.ctx.arc(x, y, radius, 0, Math.PI * 2);
        this.ctx.fillStyle = color;
        this.ctx.fill();
        this.ctx.closePath();
    }
}

// RPG Maker MZ Integration (when used in RM)
function initRMPlugin() {
    console.log("CelestialAmbiance initialized for RPG Maker MZ");
    return {
        name: "CelestialAmbiance",
        init: function() {
            // In RM, you'd hook into the game's time system
            // This is a simplified version for demonstration
            this._originalUpdate = Scene_Base.prototype.update;
            Scene_Base.prototype.update = function() {
                this._originalUpdate.call(this);
                if (this.isMap()) {
                    const renderer = new CelestialRenderer(1280, 720);
                    renderer.update(Date.now() % config.cycleDuration);
                }
            };
        }
    };
}

// For standalone Node.js execution
function main() {
    const width = 800;
    const height = 600;
    const renderer = new CelestialRenderer(width, height);

    // Simulate time progression
    let time = 0;
    const updateInterval = 1000 / 60; // 60 FPS

    function animate() {
        time = Date.now() % config.cycleDuration;
        renderer.update(time);
        requestAnimationFrame(animate);
    }

    animate();

    // Export PNG every 5 seconds for debugging
    setInterval(() => {
        renderer.canvas.png().then(png => {
            require('fs').writeFileSync(`celestial_${Math.floor(time / (config.cycleDuration / 24))}.png`, png);
        });
    }, 5000);
}

// Run if not in RM (Node.js standalone)
if (typeof window === 'undefined' && typeof process !== 'undefined') {
    main();
} else if (typeof RPGMAKER !== 'undefined') {
    initRMPlugin();
}

extends CharacterBody2D

@export var jump_velocity: float = -500.0
@export var gravity: float = 1500.0
@export var max_speed: float = 300.0
@export var acceleration: float = 20.0
@export var friction: float = 10.0
@export var celestial_mass: float = 0.8  # Affects movement inertia and collision
@export var trail_color: Color = Color(0.1, 0.8, 1.0, 0.3)
@export var trail_width: float = 2.0

private var trail_timer: Timer
private var current_gravity: float = 0.0
private var movement_vector: Vector2 = Vector2.ZERO

func _ready() -> void:
	if not Engine.is_2d:
		print("This script requires 2D mode!")
		return

	trail_timer = Timer.new()
	add_child(trail_timer)
	trail_timer.timeout.connect(_on_trail_timer_timeout)
	trail_timer.start(0.05)

	# Initialize with gravity facing down
	current_gravity = gravity

func _process(delta: float) -> void:
	# Smooth gravity transition
	if current_gravity != gravity:
		current_gravity = lerp(current_gravity, gravity, delta * 10.0)

	# Get input direction
	var input_dir = Input.get_vector("move_left", "move_right", "move_up", "move_down")
	if input_dir.length() > 0:
		movement_vector = input_dir.normalized()

	# Apply acceleration and friction
	var target_speed = movement_vector * max_speed
	var current_speed = velocity.length()

	if current_speed < target_speed:
		velocity = velocity.move_toward(target_speed * movement_vector, acceleration * delta)
	elif current_speed > target_speed:
		velocity = velocity.move_toward(target_speed * movement_vector, friction * delta)

	# Apply gravity
	if not is_on_floor():
		velocity.y += current_gravity * delta

	# Jump if on ground and pressing jump (with celestial mass effect)
	if is_on_floor() and Input.is_action_just_pressed("jump"):
		velocity.y = jump_velocity * (1.0 - celestial_mass * 0.5)
		# Visual feedback based on mass
		if celestial_mass > 0.5:
			$Trail2D.set_color(Color(trail_color.r, trail_color.g, trail_color.b, 0.6))
		else:
			$Trail2D.set_color(trail_color)

	# Celestial mass effect on velocity (simulates inertia)
	velocity *= 1.0 - celestial_mass * 0.02

	# Movement with momentum preservation
.move_and_slide()

func _on_trail_timer_timeout() -> void:
	if velocity.length() > 10:  # Only create trail when moving
		var trail = Trail2D.new()
		add_child(trail)
		trail.position = global_position
		trail.set_color(trail_color)
		trail.set_width(trail_width)
		trail.lifetime = 30  # Frames before disappearing
		queue_free()  # Remove the player's timer after creating trail

# Collision handling with celestial mass effect
func _on_body_entered(body: Body2D) -> void:
	if body.is_in_group("celestial_body"):
		# Mass-based collision response
		var combined_mass = celestial_mass + body.get("celestial_mass") or 0.5
		var repulsion = (1.0 - combined_mass) * 500.0
		apply_central_force(-velocity.normalized() * repulsion)
		body.apply_central_impulse(velocity.normalized() * repulsion)

		# Visual feedback
		if combined_mass > 1.0:
			$Trail2D.set_color(Color(0.0, 0.8, 1.0, 0.3))
		else:
			$Trail2D.set_color(Color(1.0, 0.8, 0.0, 0.3))

using UnityEngine;
using System.Collections.Generic;

[RequireComponent(typeof(Camera))]
[AddComponentMenu("Camera Control/Smoothonacci Follow")]
public class SmoothonacciCameraFollow : MonoBehaviour
{
    [Header("Fibonacci Smoothing Settings")]
    [SerializeField] private float fibonacciSmoothingStrength = 0.5f;
    [SerializeField] [Range(0, 1)] private float fibonacciTension = 0.3f;
    [SerializeField] private float fibonacciAcceleration = 1.05f;
    [SerializeField] private float minFibonacciVelocity = 0.1f;
    [SerializeField] private bool useFibonacciLag = true;
    [SerializeField] [Range(0, 1)] private float fibonacciLagFactor = 0.2f;

    [Header("Dynamic Control Settings")]
    [SerializeField] private float accelerationFactor = 1.5f;
    [SerializeField] private float decelerationFactor = 0.9f;
    [SerializeField] private float minVelocity = 0.1f;
    [SerializeField] private float maxVelocity = 5.0f;
    [SerializeField] private AnimationCurve velocityCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);

    [Header("Target Settings")]
    [SerializeField] private Transform target;
    [SerializeField] private Vector3 offset = new Vector3(0, 0, -5);
    [SerializeField] private bool smoothRotation = true;
    [SerializeField] [Range(0, 180)] private float rotationSmoothing = 15f;

    [Header("Advanced")]
    [SerializeField] private bool adaptiveFieldOfView = false;
    [SerializeField] [Range(0, 1)] private float fovAdaptationSpeed = 0.1f;
    [SerializeField] [Range(20, 120)] private float minFov = 30f;
    [SerializeField] [Range(20, 120)] private float maxFov = 100f;

    private Camera _camera;
    private Vector3 _velocity;
    private float _currentFibonacciValue;
    private float _currentFibonacciVelocity;
    private float _targetFibonacciValue;
    private float _fibonacciLagValue;
    private float _previousFibonacciValue;
    private float _fibonacciLagVelocity;
    private float _currentVelocity;
    private float _currentLerpedFibonacciValue;
    private float _timeSinceVelocityUpdate;

    private Queue<float> _fibonacciSequence = new Queue<float>();

    private void Awake()
    {
        _camera = GetComponent<Camera>();
        InitializeFibonacciSequence();
    }

    private void InitializeFibonacciSequence()
    {
        _fibonacciSequence.Clear();
        _fibonacciSequence.Enqueue(0);
        _fibonacciSequence.Enqueue(1);

        for (int i = 0; i < 10; i++)
        {
            float nextValue = _fibonacciSequence.Peek() + _fibonacciSequence.ElementAt(_fibonacciSequence.Count - 2);
            _fibonacciSequence.Enqueue(nextValue);
        }

        _currentFibonacciValue = 0;
        _targetFibonacciValue = 1;
        _previousFibonacciValue = 0;
        _fibonacciLagValue = 0;
        _fibonacciLagVelocity = 0;
    }

    private void Update()
    {
        if (target == null) return;

        HandleFibonacciSmoothing();
        HandleDynamicVelocity();
        UpdatePosition();
        UpdateRotation();

        if (adaptiveFieldOfView)
        {
            UpdateFieldOfView();
        }

        _timeSinceVelocityUpdate += Time.deltaTime;
    }

    private void HandleFibonacciSmoothing()
    {
        // Calculate target Fibonacci value based on distance
        float distanceToTarget = Vector3.Distance(transform.position, target.position);
        _targetFibonacciValue = Mathf.Clamp(distanceToTarget * 0.1f, 0.1f, 5f);

        // Fibonacci sequence calculation with acceleration
        _currentFibonacciValue += (_targetFibonacciValue - _currentFibonacciValue) * fibonacciSmoothingStrength * fibonacciAcceleration;
        _currentFibonacciValue = Mathf.Clamp(_currentFibonacciValue, 0, 5);

        // Fibonacci velocity calculation with tension
        float fibonacciDelta = _currentFibonacciValue - _previousFibonacciValue;
        _currentFibonacciVelocity = Mathf.Lerp(_currentFibonacciVelocity, fibonacciDelta, fibonacciTension);

        // Store previous value for next frame
        _previousFibonacciValue = _currentFibonacciValue;

        // Apply Fibonacci lag if enabled
        if (useFibonacciLag)
        {
            _fibonacciLagValue += (_currentFibonacciValue - _fibonacciLagValue) * fibonacciLagFactor;
            _fibonacciLagVelocity = (_fibonacciLagValue - _previousFibonacciValue) * 0.1f;
        }
    }

    private void HandleDynamicVelocity()
    {
        float targetVelocity = velocityCurve.Evaluate(_currentFibonacciValue / 5f) * maxVelocity;

        // Accelerate or decelerate based on Fibonacci velocity
        if (_currentFibonacciVelocity > minFibonacciVelocity)
        {
            _currentVelocity += (_currentFibonacciVelocity * accelerationFactor - _currentVelocity) * accelerationFactor * Time.deltaTime;
        }
        else
        {
            _currentVelocity += (minVelocity - _currentVelocity) * decelerationFactor * Time.deltaTime;
        }

        // Clamp velocity
        _currentVelocity = Mathf.Clamp(_currentVelocity, minVelocity, maxVelocity);

        // Add Fibonacci lag velocity contribution if needed
        if (useFibonacciLag)
        {
            _currentVelocity += _fibonacciLagVelocity * 0.5f;
        }
    }

    private void UpdatePosition()
    {
        if (target == null) return;

        Vector3 targetPosition = target.position + offset;
        Vector3 currentPosition = transform.position;

        // Calculate desired movement direction
        Vector3 direction = (targetPosition - currentPosition).normalized;

        // Apply Fibonacci-smoothed movement with dynamic velocity
        Vector3 movement = direction * _currentVelocity * Time.deltaTime;

        // Apply Fibonacci-based weighting to movement
        float fibonacciWeight = Mathf.Clamp01(_currentFibonacciValue / 2f);
        _currentLerpedFibonacciValue = Mathf.Lerp(_currentLerpedFibonacciValue, fibonacciWeight, 0.1f);
        movement *= _currentLerpedFibonacciValue;

        // Smooth movement with Fibonacci influence
        Vector3 smoothedMovement = Vector3.Lerp(currentPosition, currentPosition + movement, _currentFibonacciValue * 0.2f);
        transform.position = smoothedMovement;
    }

    private void UpdateRotation()
    {
        if (target == null || !smoothRotation) return;

        Vector3 direction = target.position - transform.position;
        direction = new Vector3(direction.x, 0, direction.z).normalized;

        if (direction != Vector3.zero)
        {
            Quaternion targetRotation = Quaternion.LookRotation(direction);
            transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, rotationSmoothing * Time.deltaTime);
        }
    }

    private void UpdateFieldOfView()
    {
        if (_camera == null) return;

        float fov = _camera.fieldOfView;
        float targetFov = Mathf.Lerp(minFov, maxFov, _currentFibonacciValue / 5f);
        fov = Mathf.Lerp(fov, targetFov, fovAdaptationSpeed * Time.deltaTime);
        _camera.fieldOfView = fov;
    }

    private void OnValidate()
    {
        fibonacciSmoothingStrength = Mathf.Clamp01(fibonacciSmoothingStrength);
        fibonacciTension = Mathf.Clamp01(fibonacciTension);
        fibonacciAcceleration = Mathf.Clamp(fibonacciAcceleration, 1.01f, 2f);
        fibonacciLagFactor = Mathf.Clamp01(fibonacciLagFactor);
        minFibonacciVelocity = Mathf.Clamp(minFibonacciVelocity, 0.01f, 1f);
        rotationSmoothing = Mathf.Clamp(rotationSmoothing, 0f, 180f);
        fovAdaptationSpeed = Mathf.Clamp01(fovAdaptationSpeed);
        minFov = Mathf.Clamp(minFov, 20f, 120f);
        maxFov = Mathf.Clamp(maxFov, 20f, 120f);
    }

    [ContextMenu("Reset Fibonacci Sequence")]
    private void ResetFibonacciSequence()
    {
        InitializeFibonacciSequence();
    }
}

# QuantumDash.gd
# A 2D platformer character with quantum dash mechanics that teleport the character
# in a straight line while respecting collision layers. Dashes can bounce off "quantum mirrors"
# (nodes with the "QuantumMirror" collision layer) to create dynamic path interactions.

extends CharacterBody2D

# Configuration
@export var dash_speed: float = 600.0
@export var dash_cooldown: float = 0.3
@export var dash_distance: float = 1000.0
@export var gravity: float = ProjectSettings.get_setting("physics/2d/default_gravity")
@export var jump_force: float = -500.0
@export var acceleration: float = 1000.0
@export var friction: float = 1000.0
@export var quantum_mirror_bounce: bool = true

# Internal state
var _dash_cooldown_timer: float = 0.0
var _is_dashing: bool = false
var _dash_start_position: Vector2
var _dash_direction: Vector2
var _is_grounded: bool = false
var _is_facing_right: bool = true
var _mirror_reflections: Array[Vector2] = []

# Collision layers
const DASH_LAYER: int = 1 << 0
const QUANTUM_MIRROR_LAYER: int = 1 << 1
const GROUND_LAYER: int = 1 << 2

func _ready() -> void:
	# Ensure the collision layers are set correctly in the editor
	if not get_collision_layerbit(DASH_LAYER):
		print_warn("QuantumDash: Set the DASH_LAYER (bit 0) in the collision layers!")
	if not get_collision_layerbit(GROUND_LAYER):
		print_warn("QuantumDash: Set the GROUND_LAYER (bit 2) in the collision layers!")

	# Initialize physics
	self.gravity = gravity
	self.acceleration = acceleration
	self.friction = friction

func _process(delta: float) -> void:
	# Handle dash cooldown timer
	if _dash_cooldown_timer > 0.0:
		_dash_cooldown_timer -= delta
		if _dash_cooldown_timer <= 0.0:
			_is_dashing = false

	# Update grounded state (for future jump/ground interactions)
	_is_grounded = is_on_floor()

	# Handle input
	handle_input()

	# Apply gravity if not dashing
	if not _is_dashing:
		velocity.y += gravity * delta

	# Move the character if not dashing
	if not _is_dashing:
		var direction: float = Input.get_axis("move_left", "move_right")
		if direction != 0.0:
			velocity.x = direction * acceleration * delta
			_is_facing_right = direction > 0
		else:
			velocity.x = friction * delta * (velocity.x / abs(velocity.x)) if abs(velocity.x) > 0.1 else 0.0

	# Update visuals (e.g., flip sprite based on direction)
	if _is_facing_right:
		$Sprite.flip_h = false
	else:
		$Sprite.flip_h = true

func handle_input() -> void:
	# Jump input
	if Input.is_action_just_pressed("jump") and _is_grounded:
		velocity.y = jump_force

	# Dash input (primary action, e.g., spacebar or click)
	if Input.is_action_just_pressed("dash") and not _is_dashing and _dash_cooldown_timer <= 0.0:
		# Calculate dash direction based on current facing direction
		_dash_direction = Vector2(_is_facing_right ? 1.0 : -1.0, 0.0)
		_dash_start_position = global_position
		_is_dashing = true
		_dash_cooldown_timer = dash_cooldown

func _physics_process(delta: float) -> void:
	# Skip physics if dashing (handled separately)
	if _is_dashing:
		return

	# Apply movement
	move_and_slide()

func _physics_frame(delta: float) -> void:
	# Handle dashing physics (separate from regular movement)
	if _is_dashing:
		# Calculate dash movement
		var dash_velocity: Vector2 = _dash_direction * dash_speed
		var dash_ending_position: Vector2 = _dash_start_position + _dash_direction * dash_distance
		var new_position: Vector2 = global_position + dash_velocity * delta

		# Check for collisions during dash
		var collision_info: Array = []
		var space_state: SpaceState2D = get_world_2d().direct_space_state
		var collision: Dictionary = space_state.intersect_ray(
			global_position,
			dash_ending_position,
			true,
			true
		)

		if collision:
			# Handle collision with quantum mirror
			if collision.collider.is_in_group("QuantumMirror"):
				if quantum_mirror_bounce:
					# Reflect the dash direction off the mirror
					var mirror_normal: Vector2 = collision.normal
					_dash_direction = reflect(_dash_direction, mirror_normal)
					_dash_start_position = collision.position
					_mirror_reflections.append(collision.position)
					return  # Continue dashing in the new direction

			# Handle collision with other objects (e.g., walls, platforms)
			velocity.x = 0.0
			velocity.y = 0.0
			global_position = collision.position
			_is_dashing = false
			_dash_cooldown_timer = dash_cooldown
		else:
			# No collisions, continue dashing
			global_position = new_position

			# Check if dash distance is reached
			var dash_distance_squared: float = (_dash_direction * dash_distance).length_squared()
			if (global_position - _dash_start_position).length_squared() >= dash_distance_squared:
				_is_dashing = false
				_dash_cooldown_timer = dash_cooldown