A!leys Galerie

extends CanvasLayer

@export var intensity: float = 0.5
@export var speed_factor: float = 1.0
@export var color_shift: Vector3 = Vector3(0.2, 0.1, 0.0)
@export var glass_mask_intensity: float = 0.3
@export var neumorphic_intensity: float = 0.2
@export var particle_count: int = 200
@export var base_particle_size: float = 0.1

var _time_offset: float = 0.0
var _particles: PoolByteArray
var _shader_material: ShaderMaterial
var _canvas_item: CanvasItem

func _ready() -> void:
	_time_offset = randf()
	_particles = PoolByteArray.new()
	_material = create_material()

	_canvas_item = CanvasItem.new()
	add_child(_canvas_item)
	_canvas_item.material_override = _material

	regenerate_particles()

func _process(delta: float) -> void:
	_time_offset += delta * speed_factor
	_material.set_shader_param("time_offset", _time_offset + intensity * sin(_time_offset * 2.0))
	_material.set_shader_param("glass_mask_intensity", glass_mask_intensity * (0.5 + 0.5 * sin(_time_offset * 1.5)))
	_material.set_shader_param("neumorphic_intensity", neumorphic_intensity * (0.3 + 0.2 * cos(_time_offset * 1.0)))

	if Input.is_action_just_pressed("ui_accept"):
		regenerate_particles()

func create_material() -> ShaderMaterial:
	var material = ShaderMaterial.new()
	material.shader = load("res://glassmorphic_particle_shader.shader")
	material.set_shader_param("particle_count", particle_count)
	material.set_shader_param("base_size", base_particle_size)
	material.set_shader_param("color_shift", color_shift)
	material.set_shader_param("time_offset", _time_offset)
	material.set_shader_param("glass_mask_intensity", glass_mask_intensity)
	material.set_shader_param("neumorphic_intensity", neumorphic_intensity)
	return material

func regenerate_particles() -> void:
	_particles.clear()
	for i in range(particle_count):
		_particles.append((randf_range(-1.0, 1.0), randf_range(-1.0, 1.0), randf_range(0.5, 1.5)))
	_material.set_shader_param("particle_data", _particles)

import SwiftUI
import Charts

struct Mood: Identifiable, Equatable {
    let id = UUID()
    let date: Date
    let mood: MoodType
    var emoji: String { mood.rawValue }
    var color: Color { mood.color }
    var isFav: Bool = false

    static func example(timestamp: Int) -> Mood {
        let moodTypes = MoodType.allCases.shuffled()
        return Mood(date: Date(timeIntervalSince1970: Double(timestamp)),
                    mood: moodTypes[0], isFav: Bool.random())
    }
}

enum MoodType: String, CaseIterable, Identifiable {
    case happy = "😊"
    case relaxed = "😌"
    case nervous = "😬"
    case sad = "😢"
    case angry = "😠"

    var id: String { rawValue }
    var color: Color {
        switch self {
        case .happy: return .orange
        case .relaxed: return .blue
        case .nervous: return .purple
        case .sad: return .teal
        case .angry: return .red
        }
    }

    var desc: String {
        switch self {
        case .happy: return "Feeling cheerful and awesome!"
        case .relaxed: return "Chill vibes only, please."
        case .nervous: return "Why is my heart beating so fast?"
        case .sad: return "Today is a little gray."
        case .angry: return "Red alert! 🚨"
        }
    }
}

class MoodStore: ObservableObject {
    @Published var moods: [Mood] = []

    func addMood() {
        moods.append(.example(timestamp: Int(Date().timeIntervalSince1970)))
    }

    func deleteMood(at offsets: IndexSet) {
        moods.remove(at: offsets.first!)
    }

    var favoriteMoods: [Mood] {
        moods.filter { $0.isFav }
    }

    var groupedByDay: [Date: [Mood]] {
        var result = [Date: [Mood]]()
        for mood in moods {
            let calendar = Calendar.current
            if let day = calendar.startOfDay(for: mood.date) {
                result[day, default: []].append(mood)
            }
        }
        return result
    }
}

struct MoodJoyView: View {
    @StateObject private var store = MoodStore()
    @State private var selectedMood: Mood?
    @State private var showActionSheet = false
    @State private var showMoodSelection = false

    var body: some View {
        NavigationStack {
            List {
                Section("Today's Mood") {
                    Button(action: {
                        showMoodSelection = true
                    }) {
                        HStack {
                            if let mood = selectedMood {
                                mood.emoji
                                    .font(.system(size: 30))
                                    .foregroundColor(mood.color)
                                Text(mood.mood.rawValue)
                                    .font(.headline)
                            } else {
                                Text("Tap to add your mood!")
                                    .foregroundColor(.secondary)
                            }
                        }
                    }
                    .padding()
                    .background(selectedMood == nil ? Color(red: 0.9, green: 0.9, blue: 0.9) : selectedMood!.color.opacity(0.2))
                    .cornerRadius(12)
                }

                Section("Your Mood History") {
                    if moods.isEmpty {
                        Text("No moods yet! Tap above to add one.")
                            .foregroundColor(.secondary)
                    } else {
                        Chart(store.groupedByDay.sorted { $0.key < $1.key }.map { date, moods in
                            moods
                        }.flatMap { $0 }) { mood in
                            BarMark(
                                x: .value("Date", mood.date, unit: .day),
                                y: .value("Mood", 1)
                            )
                            .foregroundStyle(mood.color)
                            .cornerRadius(4)
                            .animation(.easeInOut, value: mood)
                        }
                        .chartXAxis {
                            AxisMarks(values: .automatic)
                        }
                        .chartYAxis {
                            AxisMarks(values: .automatic)
                        }
                        .frame(height: 250)
                    }
                }

                Section("Your Favorite Moods") {
                    if store.favoriteMoods.isEmpty {
                        Text("No favorites yet. Tap a mood to make it favorite!")
                            .foregroundColor(.secondary)
                    } else {
                        ForEach(store.favoriteMoods) { mood in
                            HStack {
                                mood.emoji
                                    .font(.system(size: 20))
                                    .foregroundColor(mood.color)
                                Text(mood.mood.rawValue)
                                    .font(.subheadline)
                                Spacer()
                                Image(systemName: mood.isFav ? "star.fill" : "star")
                                    .foregroundColor(mood.isFav ? .yellow : .gray)
                            }
                            .onTapGesture {
                                withAnimation {
                                    mood.isFav.toggle()
                                }
                            }
                        }
                    }
                }
            }
            .navigationTitle("MoodJoy 🌈")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showActionSheet = true }) {
                        Image(systemName: "plus.circle.fill")
                            .font(.system(size: 24))
                    }
                }
            }
            .sheet(isPresented: $showMoodSelection) {
                MoodSelectionView(selectedMood: $selectedMood, onDismiss: { showMoodSelection = false })
            }
            .actionSheet(isPresented: $showActionSheet) {
                ActionSheet(title: Text("Add mood"), message: Text("How do you feel today?"), buttons: [
                    .default(Text("Add manually")) { showMoodSelection = true },
                    .default(Text("Auto-detect")) {
                        let moods = MoodType.allCases.shuffled()
                        selectedMood = Mood(date: Date(), mood: moods[0], isFav: Bool.random())
                        showMoodSelection = false
                    },
                    .cancel()
                ])
            }
        }
        .preferredColorScheme(.light)
        .accentColor(.orange)
        .onAppear {
            store.addMood() // Seed one mood for demo
        }
    }
}

struct MoodSelectionView: View {
    @Binding var selectedMood: Mood?
    var onDismiss: () -> Void

    var body: some View {
        NavigationView {
            List(MoodType.allCases, id: \.rawValue) { moodType in
                Button(action: {
                    selectedMood = Mood(date: Date(), mood: moodType, isFav: selectedMood?.isFav ?? false)
                    onDismiss()
                }) {
                    HStack {
                        moodType.emoji
                            .font(.system(size: 30))
                            .foregroundColor(moodType.color)
                        Text(moodType.rawValue)
                            .font(.headline)
                        Spacer()
                        if let selected = selectedMood, selected.mood == moodType {
                            Image(systemName: "checkmark.circle.fill")
                                .foregroundColor(moodType.color)
                        }
                    }
                }
                .padding()
            }
            .navigationTitle("Choose your mood")
            .navigationBarTitleDisplayMode(.inline)
        }
    }
}

struct MoodJoyView_Previews: PreviewProvider {
    static var previews: some View {
        MoodJoyView()
            .previewDevice("iPhone 15")
    }
}

// Complete Particle Storm Generator for RPG Maker MZ
// Standalone Node.js script with full RPG Maker MZ compatibility
// Features: Dynamic weather systems, interactive particles, realistic storm simulation

const { join } = require('path');
const fs = require('fs').promises;

class ParticleStorm {
  constructor() {
    this.particles = [];
    this.weatherEffects = [];
    this.simulationRunning = false;
    this.frames = 0;
  }

  // RPG Maker MZ Compatible Particle System
  createParticle(x, y, color, speed, duration) {
    const particle = {
      id: this.frames++,
      x,
      y,
      color,
      speed: [speed * (Math.random() * 0.5 + 0.25), speed * (Math.random() * 0.5 + 0.25)],
      size: Math.random() * 5 + 2,
      alpha: Math.random() * 0.7 + 0.3,
      duration,
      age: 0,
      orbitRadius: Math.random() * 10 + 5,
      orbitSpeed: Math.random() * 0.05 + 0.01,
      isWeatherEffect: false
    };

    this.particles.push(particle);
    return particle.id;
  }

  // Dynamic Weather Effects
  startWeatherEffect(type, intensity, duration) {
    const effect = {
      type,
      intensity,
      startTime: Date.now(),
      endTime: Date.now() + duration * 1000,
      particles: [],
      active: true
    };

    this.weatherEffects.push(effect);

    if (type === 'storm') {
      setInterval(() => this.updateStormEffect(effect), 16);
    }

    return effect;
  }

  updateStormEffect(effect) {
    if (effect.active && Date.now() < effect.endTime) {
      const count = Math.floor(effect.intensity * 10);

      for (let i = 0; i < count; i++) {
        this.createParticle(
          Math.random() * 800,
          Math.random() * 600,
          `hsl(${Math.random() * 30 + 180}, 80%, ${Math.random() * 50 + 50}%)`,
          2 + Math.random() * 3,
          1 + Math.random() * 2
        );
      }
    } else {
      effect.active = false;
    }
  }

  // RPG Maker MZ Draw Simulation
  drawParticles(ctx) {
    // Simulate RPG Maker MZ Canvas
    const canvas = {
      width: 800,
      height: 600,
      clear: (color) => {
        ctx.fillStyle = color || 'rgba(0,0,0,0.1)';
        ctx.fillRect(0, 0, 800, 600);
      }
    };

    // Clear with storm background
    canvas.clear('rgba(20, 20, 40, 0.8)');

    // Draw all particles
    this.particles.forEach(particle => {
      if (particle.age < particle.duration) {
        // Update position
        particle.x += particle.speed[0];
        particle.y += particle.speed[1];

        // Add orbit effect
        if (particle.orbitRadius) {
          const angle = (Date.now() / 1000 + particle.id * 0.1) * particle.orbitSpeed;
          const orbitX = Math.sin(angle) * particle.orbitRadius;
          const orbitY = Math.cos(angle) * particle.orbitRadius;

          particle.x += orbitX;
          particle.y += orbitY;
        }

        // Draw particle
        ctx.globalAlpha = particle.alpha * (1 - particle.age / particle.duration);
        ctx.fillStyle = particle.color;
        ctx.beginPath();
        ctx.arc(particle.x, particle.y, particle.size, 0, Math.PI * 2);
        ctx.fill();
      }
    });

    // Clean up dead particles
    this.particles = this.particles.filter(p => p.age < p.duration);
  }

  // Simulation Loop
  startSimulation() {
    if (this.simulationRunning) return;

    this.simulationRunning = true;
    this.lastTime = Date.now();

    const canvas = document.createElement('canvas');
    canvas.width = 800;
    canvas.height = 600;
    document.body.appendChild(canvas);

    const ctx = canvas.getContext('2d');

    function loop() {
      const now = Date.now();
      const delta = now - ParticleStorm.lastTime;
      ParticleStorm.lastTime = now;

      // Update weather effects
      ParticleStorm.weatherEffects.forEach(effect => {
        if (Date.now() < effect.endTime) {
          ParticleStorm.updateStormEffect(effect);
        }
      });

      // Draw everything
      ParticleStorm.drawParticles(ctx);

      if (ParticleStorm.simulationRunning) {
        requestAnimationFrame(loop);
      }
    }

    loop();
  }

  stopSimulation() {
    this.simulationRunning = false;
  }

  // RPG Maker MZ Plugin Export
  exportPlugin() {
    const pluginCode = `
// Particle Storm Generator Plugin for RPG Maker MZ
// Dynamic weather and particle effects

/*:
 * @plugindesc Particle Storm Generator with dynamic weather effects
 * @author Ailey
 * @help Features:
 *  - Dynamic storm effects
 *  - Interactive particles
 *  - Weather system controller
 */

var ParticleStorm = ParticleStorm || function() {
  var particles = [];
  var weatherEffects = [];
  var frames = 0;

  function createParticle(x, y, color, speed, duration) {
    var particle = {
      id: frames++,
      x: x,
      y: y,
      color: color,
      speed: [speed * (Math.random() * 0.5 + 0.25), speed * (Math.random() * 0.5 + 0.25)],
      size: Math.random() * 5 + 2,
      alpha: Math.random() * 0.7 + 0.3,
      duration: duration,
      age: 0,
      orbitRadius: Math.random() * 10 + 5,
      orbitSpeed: Math.random() * 0.05 + 0.01
    };

    particles.push(particle);
    return particle.id;
  }

  function startWeatherEffect(type, intensity, duration) {
    var effect = {
      type: type,
      intensity: intensity,
      startTime: Date.now(),
      endTime: Date.now() + duration * 1000,
      particles: []
    };

    weatherEffects.push(effect);

    if (type === 'storm') {
      setInterval(updateStormEffect, 16, effect);
    }

    return effect;
  }

  function updateStormEffect(effect) {
    if (Date.now() < effect.endTime) {
      var count = Math.floor(effect.intensity * 10);

      for (var i = 0; i < count; i++) {
        createParticle(
          Math.random() * 800,
          Math.random() * 600,
          \`hsl(${Math.random() * 30 + 180}, 80%, ${Math.random() * 50 + 50}%)\`,
          2 + Math.random() * 3,
          1 + Math.random() * 2
        );
      }
    } else {
      weatherEffects = weatherEffects.filter(e => e !== effect);
    }
  }

  function drawParticles(ctx) {
    ctx.clearRect(0, 0, 800, 600);
    ctx.fillStyle = 'rgba(20, 20, 40, 0.8)';
    ctx.fillRect(0, 0, 800, 600);

    particles.forEach(function(particle) {
      if (particle.age < particle.duration) {
        particle.x += particle.speed[0];
        particle.y += particle.speed[1];

        if (particle.orbitRadius) {
          var angle = (Date.now() / 1000 + particle.id * 0.1) * particle.orbitSpeed;
          var orbitX = Math.sin(angle) * particle.orbitRadius;
          var orbitY = Math.cos(angle) * particle.orbitRadius;

          particle.x += orbitX;
          particle.y += orbitY;
        }

        ctx.globalAlpha = particle.alpha * (1 - particle.age / particle.duration);
        ctx.fillStyle = particle.color;
        ctx.beginPath();
        ctx.arc(particle.x, particle.y, particle.size, 0, Math.PI * 2);
        ctx.fill();
      }
    });

    particles = particles.filter(p => p.age < p.duration);
  }

  return {
    createParticle: createParticle,
    startWeatherEffect: startWeatherEffect,
    drawParticles: drawParticles
  };
}();

if (typeof Scene_Base !== 'undefined') {
  Scene_Base.prototype.update = function() {
    Scene_Base.prototype.update.call(this);
    ParticleStorm.drawParticles(this._renderer._c);
  };
}
    `;

    const outputPath = join(__dirname, 'ParticleStormPlugin.js');
    await fs.writeFile(outputPath, pluginCode);
    console.log(`Plugin exported to ${outputPath}`);
    return outputPath;
  }
}

// Main Execution
const storm = new ParticleStorm();

// Start with a sample storm effect
storm.startWeatherEffect('storm', 1.5, 10);

// Start the simulation
storm.startSimulation();

// Allow exporting to RPG Maker MZ plugin
if (process.argv.includes('--export')) {
  storm.exportPlugin();
}

// Cleanup on exit
process.on('SIGINT', () => {
  storm.stopSimulation();
  process.exit();
});

use rand::Rng;
use std::io;

const CHAR_SETS: [&str; 4] = [
    "23456789BCDFGHJKLMNPQRSTUVWXYZ", // Kein 1, O, 0, l, I, weil Puhle
    "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
    "abcdefghijkmnpqrstuvwxyz",       // Kein i, l, weil sie gleich aussehen wenn man mal betrunken ist
    "0123456789"                       // Nur Zahlen, für diejenigen die numbers lieben
];

fn main() {
    println!("AileyPass - Passwortgenerator mit Entropie-Analyse");
    println!("------------------------------------------------");
    println!("Gib die gewünschte Länge ein (8-100):");
    let length = read_positive_int(8, 100);

    println!("\nWähle ein Char-Set (1-4):");
    for (i, set) in CHAR_SETS.iter().enumerate() {
        println!("{}. {}", i + 1, set);
    }
    let set_idx = (read_positive_int(1, 4) - 1) as usize;
    let char_set = CHAR_SETS[set_idx].chars().collect::<Vec<_>>();

    println!("\nGeneriere Passwort...");
    let mut rng = rand::thread_rng();
    let mut password = String::with_capacity(length);
    let mut chars: Vec<char> = char_set.clone();

    for _ in 0..length {
        let idx = rng.gen_range(0..chars.len());
        password.push(chars[idx]);
    }

    let entropy = calculate_entropy(&password, &char_set);
    let entropy_bar = generate_entropy_bar(entropy);

    println!("\nErgebnis:");
    println!("{:-^80}", "");
    println!("Passwort: {}", password);
    println!("Entropie: {:.2} bits", entropy);
    println!("Entropie-Balken: {}", entropy_bar);
    println!("{:-^80}", "");
}

fn read_positive_int(min: u32, max: u32) -> u32 {
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Fehler beim Lesen");

        match input.trim().parse::<u32>() {
            Ok(num) if num >= min && num <= max => return num,
            Ok(_) => println!("Zahl muss zwischen {} und {} liegen", min, max),
            Err(_) => println!("Bitte eine gültige Zahl eingeben"),
        }
    }
}

fn calculate_entropy(password: &str, char_set: &[char]) -> f64 {
    let set_size = char_set.len() as f64;
    let entropy = password.len() as f64 * set_size.ln() / 2.0;
    entropy
}

fn generate_entropy_bar(entropy: f64) -> String {
    let max_entropy = 256.0; // Theoretisches Maximum für 256 Zeichen-Set
    let bar_length = 50;
    let filled = (entropy / max_entropy * bar_length as f64).round() as u32;
    let filled = std::cmp::min(filled, bar_length);
    let empty = bar_length - filled;

    format!(
        "{}{}",
        "█".repeat(filled as usize),
        "-".repeat(empty)
    )
}