A!leys Galerie

#!/usr/bin/env node

/**
 * Colorful Terminal Confetti - Ein CLI-Tool, das bunte Konfetti in der Konsole ausgibt.
 * Nutze es, um dein Terminal mit einem Mini-Feuerwerk zu füllen!
 */

// Import necessary modules
const readline = require('readline');
const chalk = require('chalk');
const figlet = require('figlet');

// Define colors (using chalk for terminal-safe colors)
const COLORS = [
  chalk.hex('#FF0000'), // Red
  chalk.hex('#00FF00'), // Green
  chalk.hex('#0000FF'), // Blue
  chalk.hex('#FFFF00'), // Yellow
  chalk.hex('#FF00FF'), // Magenta
  chalk.hex('#00FFFF'), // Cyan
  chalk.hex('#FFA500'), // Orange
  chalk.hex('#800080'), // Purple
  chalk.hex('#FF69B4'), // Hot Pink
  chalk.hex('#008000'), // Dark Green
];

// Animation frames for confetti
const CONFETTI_FRAMES = [
  ['✦', '✧', '❋', '✦', '✧', '❋'],
  ['★', '☆', '✦', '✧', '❋'],
  ['✦', '✧', '❋', '★', '☆'],
  ['✧', '❋', '★', '☆', '✦'],
  ['❋', '★', '☆', '✦', '✧'],
];

// Function to generate random confetti
function generateConfetti(count, colors) {
  const lines = [];
  for (let i = 0; i < count; i++) {
    const line = Math.floor(Math.random() * CONFETTI_FRAMES.length);
    const colorIndex = Math.floor(Math.random() * colors.length);
    const char = CONFETTI_FRAMES[line][Math.floor(Math.random() * CONFETTI_FRAMES[line].length)];
    lines.push(chalk.bgHex(colors[colorIndex])(chalk.hex(colors[colorIndex])(char)));
  }
  return lines;
}

// Function to animate confetti
function animateConfetti(frames, duration, callback) {
  let frameIndex = 0;
  const interval = setInterval(() => {
    const lines = generateConfetti(5, COLORS);
    console.log('\n' + lines.join(' '));
    frameIndex = (frameIndex + 1) % frames.length;
    if (frameIndex === 0 && frames.length > 1) {
      clearInterval(interval);
      callback();
    }
  }, duration / frames.length);
}

// Main function to ask for user input
function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  // Display ASCII art title
  figlet('Confetti 🎉', (err, art) => {
    if (err) {
      console.error('Fehler beim Generieren des ASCII Arts:', err);
      process.exit(1);
    }
    console.log(chalk.green(art));

    console.log('\nMöchtest du Konfetti in deiner Konsole haben?\n');
    console.log('1. Standard-Konfetti (10 Stück, 3 Sekunden)')
    console.log('2. Benutzerdefiniertes Konfetti')
    console.log('3. Beenden\n');

    rl.question('Wähle eine Option (1-3): ', (choice) => {
      if (choice === '1') {
        animateConfetti(CONFETTI_FRAMES, 3000, () => {
          console.log('\n\033[2J\033[0;0H'); // Clear console
          console.log(chalk.blue('Viel Spaß mit deinem Konfetti! 🎉\n'));
          rl.close();
        });
      } else if (choice === '2') {
        console.log('\nBenutzerdefiniertes Konfetti:');
        rl.question('Anzahl des Konfettis (1-50): ', (count) => {
          const num = parseInt(count, 10);
          if (isNaN(num) || num < 1 || num > 50) {
            console.log(chalk.red('Ungültige Anzahl. Bitte versuche es erneut.'));
            main();
            return;
          }

          rl.question('Dauer in Sekunden (1-10): ', (duration) => {
            const dur = parseInt(duration, 10);
            if (isNaN(dur) || dur < 1 || dur > 10) {
              console.log(chalk.red('Ungültige Dauer. Bitte versuche es erneut.'));
              main();
              return;
            }

            animateConfetti(CONFETTI_FRAMES, dur * 1000, () => {
              console.log('\n\033[2J\033[0;0H'); // Clear console
              console.log(chalk.blue(`Viel Spaß mit deinem benutzerdefinierten Konfetti! 🎉\n`));
              rl.close();
            });
          });
        });
      } else if (choice === '3') {
        console.log('\n\033[2J\033[0;0H'); // Clear console
        console.log(chalk.blue('Bis zum nächsten Mal! 👋'));
        rl.close();
        process.exit(0);
      } else {
        console.log(chalk.red('Ungültige Wahl. Bitte versuche es erneut.'));
        main();
      }
    });
  });
}

// Check if chalk and figlet are installed
try {
  main();
} catch (err) {
  if (err.code === 'MODULE_NOT_FOUND') {
    console.error(chalk.red('\nFehler: Benötigte Pakete fehlen. Bitte installiere sie mit:\n\n  npm install chalk figlet\n\n'));
    process.exit(1);
  }
  console.error(chalk.red(`\nUnbekannter Fehler: ${err.message}`));
  process.exit(1);
}

// RPG Maker MZ ItemSpark - Dynamische Item-Description-Generator mit Humor und Magnet-Effekten
// Kompatibel mit RPG Maker MZ und Node.js (CommonJS)

const fs = require('fs');
const path = require('path');

class ItemSpark {
  constructor() {
    this.items = [];
    this.magneticItems = [];
    this.humorDatabase = [
      "Zufällig gefunden, als du auf einen Stein getreten bist, der eigentlich ein verängstliches Einhorn war.",
      "Leuchtet schwach, wenn du es anschaust – vielleicht sollte das ein Warnsignal sein?",
      "Verloren von einem Piraten, der behauptete, es sei ein 'geheiligter Tintenfisch-Zahn'.",
      "Erzeugt beim Essen kleine Rauchringe (geschmack:regret).",
      "Wird warm, wenn du lügst. Nicht, dass das hier passieren würde."
    ];
    this.magnetStrengths = [0.1, 0.3, 0.5, 0.7, 0.9];
  }

  // Generiert ein zufälliges humorvolles Item mit magnetischen Effekten
  generateRandomItem() {
    const name = this.generateRandomName();
    const description = this.generateRandomDescription();
    const magnetEffect = this.generateMagnetEffect();

    const item = {
      name,
      description,
      magnetEffect,
      rarity: this.getRarity(),
      value: Math.floor(Math.random() * 1000) + 100,
      id: this.items.length + 1
    };

    this.items.push(item);
    if (magnetEffect.strength > 0) {
      this.magneticItems.push(item);
    }

    return item;
  }

  // Erstellt einen zufälligen Item-Namen mit RPG-Flair
  generateRandomName() {
    const adjectives = ['Glowende', 'Verwunschene', 'Uralte', 'Explosive', 'Magische', 'Flimmernde', 'Schicksals-', 'Würfelnde', 'Rätselhafte', 'Kohlrabi-'];
    const nouns = ['Tinte', 'Kugel', 'Feder', 'Stern', 'Schlüssel', 'Kartoffel', 'Hut', 'Sock', 'Schlange', 'Drehscheibe'];
    const modifier = ['', 'von Jotunn', 'des Schattens', 'der Lüge', 'mit Aufbauanleitung', 'der Gnade', 'der Fabel', 'der Zeit'];

    const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
    const noun = nouns[Math.floor(Math.random() * nouns.length)];
    const mod = modifier[Math.floor(Math.random() * modifier.length)];

    return `${adj} ${noun}${mod}`.trim();
  }

  // Erstellt eine humorvolle Item-Beschreibung
  generateRandomDescription() {
    return this.humorDatabase[Math.floor(Math.random() * this.humorDatabase.length)];
  }

  // Erzeugt einen magnetischen Effekt (0 = kein Effekt, >0 = Stärke)
  generateMagnetEffect() {
    const strength = this.magnetStrengths[Math.floor(Math.random() * this.magnetStrengths.length)];
    const direction = Math.floor(Math.random() * 4); // 0: Links, 1: Rechts, 2: Oben, 3: Unten

    return {
      strength,
      direction,
      description: strength > 0 ? `Zieht dich mit ${strength * 100}% ${direction === 0 ? 'nach links' : direction === 1 ? 'nach rechts' : direction === 2 ? 'nach oben' : 'nach unten'} an (wenn du wirklich hinschaust).` : 'Kein magnetischer Effekt.'
    };
  }

  // Bestimmt die Seltenheit eines Items
  getRarity() {
    const rarityLevels = ['Common', 'Uncommon', 'Rare', 'Epic', 'Legendary', 'Mythic'];
    return rarityLevels[Math.floor(Math.random() * rarityLevels.length)];
  }

  // Speichert die generierten Items in einer JSON-Datei (für RPG Maker MZ)
  saveToJson(filePath = 'itemspark_items.json') {
    fs.writeFileSync(filePath, JSON.stringify(this.items, null, 2));
    console.log(`✨ ${this.items.length} Items wurden in ${path.basename(filePath)} gespeichert!`);
  }

  // Lädt Items aus einer JSON-Datei (für RPG Maker MZ)
  loadFromJson(filePath = 'itemspark_items.json') {
    if (fs.existsSync(filePath)) {
      this.items = JSON.parse(fs.readFileSync(filePath, 'utf8'));
      this.magneticItems = this.items.filter(item => item.magnetEffect.strength > 0);
      console.log(`📜 ${this.items.length} Items wurden aus ${path.basename(filePath)} geladen.`);
    } else {
      console.log('⚠️ Keine Items gefunden. Es wird eine neue Liste generiert.');
    }
  }

  // Druckt eine schöne Liste der Items (für Debugging/Spielbuch)
  printInventory() {
    console.log('\n🔮 ItemSpark Inventory:\n');
    this.items.forEach(item => {
      console.log(`🔹 ${item.name} [${item.rarity}] (Wert: ${item.value} GP)`);
      console.log(`   ${item.description}`);
      console.log(`   ${item.magnetEffect.description}`);
      console.log(`   — — — — — — —`);
    });
    console.log(`\n🧲 Magnetische Items (${this.magneticItems.length}):`);
    this.magneticItems.forEach(item => {
      console.log(`   - ${item.name} (Stärke: ${item.magnetEffect.strength * 100}% ${this.getDirectionSymbol(item.magnetEffect.direction)})`);
    });
  }

  // Hilfsfunktion für Pfeilsymbole
  getDirectionSymbol(direction) {
    return direction === 0 ? '←' : direction === 1 ? '→' : direction === 2 ? '↑' : '↓';
  }

  // Generiert 50 zufällige Items (Standard)
  generateSampleItems(count = 50) {
    for (let i = 0; i < count; i++) {
      this.generateRandomItem();
    }
    console.log(`🎲 ${count} zufällige Items generiert!`);
  }
}

// Main-Funktion
const main = () => {
  const spark = new ItemSpark();

  // Lade bestehende Items oder generiere neue
  spark.loadFromJson();
  if (spark.items.length === 0) {
    spark.generateSampleItems(20); // Starte mit 20 Beispiel-Items
  }

  // Drucke die Inventory-Liste
  spark.printInventory();

  // Speichere die Items (falls changes)
  spark.saveToJson();

  // Interaktives Menü für Node.js
  console.log('\n🎮 ItemSpark Menü:');
  console.log('1. 10 neue Items generieren');
  console.log('2. Alle Items anzeigen');
  console.log('3. Magnetische Items filtern');
  console.log('4. Items speichern');
  console.log('5. Beenden');

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

  const handleInput = (input) => {
    switch (input) {
      case '1':
        spark.generateSampleItems(10);
        spark.printInventory();
        break;
      case '2':
        spark.printInventory();
        break;
      case '3':
        console.log('\n🧲 Magnetische Items:');
        spark.magneticItems.forEach(item => {
          console.log(`   - ${item.name} (${item.magnetEffect.strength * 100}% ${spark.getDirectionSymbol(item.magnetEffect.direction)})`);
        });
        break;
      case '4':
        spark.saveToJson();
        console.log('Items gespeichert!');
        break;
      case '5':
        readline.close();
        console.log('👋 Bis zum nächsten Mal!');
        return;
      default:
        console.log('Ungültige Eingabe. Versuche es nochmal.');
    }
    askQuestion();
  };

  const askQuestion = () => {
    readline.question('Wahl (1-5): ', handleInput);
  };

  askQuestion();
};

main();

import SwiftUI
import CoreData

@main
struct NoteSparkApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
                .preferredColorScheme(.light)
        }
    }
}

class PersistenceController: NSObject {
    static let shared = PersistenceController()

    lazy var container: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "NoteSpark")
        container.loadPersistentStores { description, error in
            if let error = error {
                fatalError("Unable to load persistent stores: \(error)")
            }
        }
        return container
    }()

    func save() {
        container.viewContext.save()
    }
}

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Note.id, ascending: true)],
        animation: .default
    ) private var notes: FetchedResults<Note>

    @State private var isEditing = false
    @State private var newNoteText = ""

    var body: some View {
        NavigationView {
            ZStack {
                Color(red: 0.98, green: 0.98, blue: 0.98, opacity: 1.0)
                    .edgesIgnoringSafeArea(.all)

                if notes.isEmpty {
                    VStack {
                        Text("No notes yet")
                            .font(.title2)
                            .foregroundColor(.gray)
                        Text("Tap + to add your first note")
                            .font(.caption)
                            .foregroundColor(.gray.opacity(0.7))
                    }
                    .transition(.opacity.combined(with: .scale))
                } else {
                    GeometryReader { geometry in
                        ScrollView {
                            LazyVStack(spacing: 16) {
                                ForEach(notes) { note in
                                    NoteSparkView(note: note)
                                        .frame(width: geometry.size.width, height: geometry.size.height / 4)
                                        .offset(y: -geometry.frame(in: .global).minY)
                                }
                            }
                            .padding(.vertical, 8)
                        }
                        .coordinateSpace(name: "notesScroll")
                    }
                }
            }
            .navigationTitle("NoteSpark")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    EditButton()
                }
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { isEditing.toggle() }) {
                        Image(systemName: isEditing ? "arrow.uturn.backward" : "pencil.tip")
                    }
                }
            }
            .overlay(
                VStack {
                    Spacer()
                    HStack {
                        TextField("Type a new note...", text: $newNoteText)
                            .textFieldStyle(RoundedBorderTextFieldStyle())
                            .padding(.horizontal)
                            .onSubmit {
                                addNote()
                            }
                        Button(action: { addNote() }) {
                            Image(systemName: "plus.circle.fill")
                                .font(.system(size: 24))
                                .foregroundColor(.blue)
                        }
                        .disabled(newNoteText.isEmpty)
                    }
                    .padding()
                },
                alignment: .bottom
            )
            .animation(.spring(response: 0.5, dampingFraction: 0.6, blendDuration: 0.5), value: notes)
        }
        .onAppear {
            let color = UIColor(hue: CGFloat.random(in: 0...1), saturation: 0.3, brightness: 0.9, alpha: 1)
            UIApplication.shared.keyWindow?.overrideUserInterfaceStyle = .light
            UIApplication.shared.keyWindow?.tintColor = color
        }
    }

    private func addNote() {
        guard !newNoteText.isEmpty else { return }

        withAnimation {
            let newNote = Note(context: viewContext)
            newNote.id = UUID()
            newNote.text = newNoteText
            newNote.color = UIColor(hue: CGFloat.random(in: 0...1), saturation: 0.5, brightness: 0.8, alpha: 1).cgColor
            newNote.date = Date()
            persistenceController.save()

            newNoteText = ""
        }
    }
}

struct NoteSparkView: View, Identifiable {
    @ObservedObject var note: Note
    @Environment(\.managedObjectContext) private var viewContext

    var id: UUID {
        note.id ?? UUID()
    }

    var body: some View {
        ZStack(alignment: .topTrailing) {
            RoundedRectangle(cornerRadius: 16)
                .fill(Color(note.color))
                .shadow(color: .black.opacity(0.1), radius: 8, x: 0, y: 4)
                .overlay(
                    VStack(alignment: .leading, spacing: 8) {
                        HStack {
                            Text(note.date, style: .time)
                                .font(.caption2)
                                .foregroundColor(.white.opacity(0.7))
                            Spacer()
                            Menu {
                                Button("Delete", role: .destructive) {
                                    deleteNote()
                                }
                            } label: {
                                Image(systemName: "ellipsis.circle")
                                    .font(.system(size: 20))
                                    .foregroundColor(.white.opacity(0.7))
                            }
                        }
                        Text(note.text ?? "")
                            .font(.body)
                            .foregroundColor(.white)
                            .padding(.vertical, 8)
                            .lineLimit(3)
                            .multilineTextAlignment(.leading)
                    }
                    .padding(.horizontal, 12)
                    .padding(.vertical, 8)
                    .background(Color.clear)
                )

            Text(note.text ?? "")
                .font(.body)
                .foregroundColor(.white)
                .padding(.horizontal, 12)
                .lineLimit(3)
                .multilineTextAlignment(.leading)
                .frame(maxWidth: .infinity, alignment: .leading)
        }
        .frame(height: 200)
        .transition(.opacity.combined(with: .scale))
        .gesture(
            DragGesture(minimumDistance: 20, coordinateSpace: .named("notesScroll"))
                .onEnded { value in
                    if value.translation.height > 20 {
                        // Move note up
                        withAnimation {
                            moveNote(direction: .up)
                        }
                    } else if value.translation.height < -20 {
                        // Move note down
                        withAnimation {
                            moveNote(direction: .down)
                        }
                    }
                }
        )
        .gesture(
            MagnificationGesture()
                .onChanged { value in
                    if value.magnification > 1.1 {
                        // Zoom in
                        withAnimation {
                            note.zoomFactor = value.magnification
                        }
                    } else if value.magnification < 0.9 {
                        // Zoom out
                        withAnimation {
                            note.zoomFactor = value.magnification
                        }
                    }
                }
        )
    }

    private func deleteNote() {
        withAnimation {
            viewContext.delete(note)
            persistenceController.save()
        }
    }

    private func moveNote(direction: Note.Direction) {
        note.direction = direction
        persistenceController.save()
    }
}

extension Note {
    @NSManaged var id: UUID?
    @NSManaged var text: String?
    @NSManaged var color: CGColor?
    @NSManaged var date: Date?
    @NSManaged var direction: Direction

    enum Direction: String, Codable {
        case up, down
    }

    var zoomFactor: Double {
        get {
            if let data = UserDefaults.standard.data(forKey: "noteZoomFactor") {
                return data.decoded() as? Double ?? 1.0
            }
            return 1.0
        }
        set {
            UserDefaults.standard.set(NSKeyedArchiver.archivedData(withRootObject: newValue), forKey: "noteZoomFactor")
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        let context = PersistenceController.shared.container.viewContext
        let note = Note(context: context)
        note.id = UUID()
        note.text = "This is a preview note. Swipe up/down to reorder and pinch to zoom!"
        note.color = UIColor(hue: 0.1, saturation: 0.5, brightness: 0.8, alpha: 1).cgColor
        note.date = Date()
        note.direction = .up

        return ContentView()
            .environment(\.managedObjectContext, context)
    }
}

<?php
/**
 * Plugin Name: Dynamic Content Rotator
 * Description: Rotates content blocks with smooth transitions and customizable styles. Works with both WordPress and Joomla.
 * Version: 1.0.0
 * Author: Ailey
 * License: GPL2
 */

// Define plugin constants
if (!defined('DYNAMIC_ROTATOR_VERSION')) {
    define('DYNAMIC_ROTATOR_VERSION', '1.0.0');
    define('DYNAMIC_ROTATOR_DIR', plugin_dir_path(__FILE__));
    define('DYNAMIC_ROTATOR_URL', plugin_dir_url(__FILE__));
}

/**
 * Class for Dynamic Content Rotator
 */
class DynamicContentRotator {
    private $content_blocks = [];
    private $transition_speed = 1000;
    private $transition_style = 'fade';
    private $auto_rotate = true;
    private $rotate_interval = 5000;
    private $current_index = 0;
    private $css_classes = [];

    /**
     * Initialize the rotator
     */
    public function __construct() {
        $this->load_defaults();
        $this->enqueue_scripts();
        $this->add_hooks();
    }

    /**
     * Load default settings
     */
    private function load_defaults() {
        $this->css_classes = [
            'rotator-container' => 'dcr-container',
            'rotator-slide' => 'dcr-slide',
            'rotator-overlay' => 'dcr-overlay',
            'active-slide' => 'dcr-active'
        ];
    }

    /**
     * Enqueue necessary scripts and styles
     */
    private function enqueue_scripts() {
        wp_enqueue_script('dcr-script', DYNAMIC_ROTATOR_URL . 'js/dcr-script.js', ['jquery'], DYNAMIC_ROTATOR_VERSION, true);
        wp_enqueue_style('dcr-style', DYNAMIC_ROTATOR_URL . 'css/dcr-style.css', [], DYNAMIC_ROTATOR_VERSION);
    }

    /**
     * Add necessary hooks
     */
    private function add_hooks() {
        // WordPress hooks
        if (function_exists('add_action')) {
            add_action('wp_enqueue_scripts', [$this, 'enqueue_scripts']);
            add_shortcode('dcr_rotator', [$this, 'render_rotator']);
            add_action('admin_enqueue_scripts', [$this, 'admin_scripts']);
        }

        // Joomla hooks (check if in Joomla)
        if (class_exists('JApplicationSite')) {
            JFactory::getApplication()->registerEvent('onContentBeforeDisplay', [$this, 'joomla_before_display']);
            JFactory::getApplication()->registerEvent('onAfterBody', [$this, 'joomla_after_body']);
        }
    }

    /**
     * Admin scripts for WordPress
     */
    public function admin_scripts() {
        wp_enqueue_style('dcr-admin-style', DYNAMIC_ROTATOR_URL . 'css/admin.css', [], DYNAMIC_ROTATOR_VERSION);
        wp_enqueue_script('dcr-admin-script', DYNAMIC_ROTATOR_URL . 'js/admin.js', ['jquery'], DYNAMIC_ROTATOR_VERSION, true);
    }

    /**
     * Render the rotator shortcode
     */
    public function render_rotator($atts) {
        $atts = shortcode_atts([
            'title' => '',
            'auto_rotate' => 'true',
            'interval' => 5000,
            'transition' => 'fade',
            'speed' => 1000,
            'slides' => []
        ], $atts);

        $this->set_settings($atts);

        ob_start();
        ?>
        <div class="<?php echo esc_attr($this->css_classes['rotator-container']); ?>" data-dcr-id="dcr-<?php echo uniqid(); ?>">
            <h3><?php echo esc_html($atts['title']); ?></h3>
            <div class="<?php echo esc_attr($this->css_classes['rotator-overlay']); ?>">
                <?php foreach ($this->content_blocks as $index => $block): ?>
                    <div class="<?php echo esc_attr($this->css_classes['rotator-slide']); ?> dcr-slide-<?php echo $index; ?>">
                        <?php echo wp_kses_post($block['content']); ?>
                    </div>
                <?php endforeach; ?>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }

    /**
     * Set rotator settings
     */
    private function set_settings($atts) {
        if (isset($atts['auto_rotate']) && strtolower($atts['auto_rotate']) === 'false') {
            $this->auto_rotate = false;
        } else {
            $this->auto_rotate = true;
        }

        $this->transition_style = isset($atts['transition']) ? sanitize_text_field($atts['transition']) : 'fade';
        $this->transition_speed = isset($atts['speed']) ? intval($atts['speed']) : 1000;
        $this->rotate_interval = isset($atts['interval']) ? intval($atts['interval']) : 5000;

        // Parse slides if provided
        if (isset($atts['slides'])) {
            $this->content_blocks = [];
            $slides = explode('||', $atts['slides']);
            foreach ($slides as $slide) {
                if (!empty($slide)) {
                    $parts = explode('###', $slide, 2);
                    $this->content_blocks[] = [
                        'content' => isset($parts[1]) ? $parts[1] : ''
                    ];
                }
            }
        }
    }

    /**
     * Add content blocks programmatically (for Joomla or advanced usage)
     */
    public function add_content_block($content, $index = null) {
        if (is_null($index)) {
            $this->content_blocks[] = ['content' => $content];
        } else {
            if (isset($this->content_blocks[$index])) {
                $this->content_blocks[$index]['content'] = $content;
            } else {
                $this->content_blocks[] = ['content' => $content];
            }
        }
    }

    /**
     * Joomla onContentBeforeDisplay event
     */
    public function joomla_before_display($event, $context) {
        $app = JFactory::getApplication();
        $doc = JFactory::getDocument();

        // Only process if this is a page or blog view
        if ($app->isSite() && ($context === 'com_content' || $context === 'com_content.article') || $context === 'com_content.blog') {
            $doc->addStyleSheet(DYNAMIC_ROTATOR_URL . 'css/dcr-style.css');
            $doc->addScript(DYNAMIC_ROTATOR_URL . 'js/dcr-script.js');

            // You could extract content from articles or modules here
            // For this example, we'll just add a placeholder block
            $this->add_content_block('<p>This content is dynamically rotated by the Dynamic Content Rotator plugin.</p>');

            echo '<div class="' . esc_attr($this->css_classes['rotator-container']) . '" data-dcr-id="dcr-' . uniqid() . '">';
            echo '<h3>Dynamic Content Rotator</h3>';
            echo '<div class="' . esc_attr($this->css_classes['rotator-overlay']) . '">';
            foreach ($this->content_blocks as $index => $block) {
                echo '<div class="' . esc_attr($this->css_classes['rotator-slide']) . ' dcr-slide-' . $index . '">';
                echo wp_kses_post($block['content']);
                echo '</div>';
            }
            echo '</div>';
            echo '</div>';
        }
    }

    /**
     * Joomla onAfterBody event
     */
    public function joomla_after_body($event, $context) {
        if ($this->auto_rotate) {
            $doc = JFactory::getDocument();
            $doc->addScriptDeclaration('
                jQuery(document).ready(function($) {
                    jQuery(".dcr-container").dcr_rotator({
                        auto_rotate: ' . ($this->auto_rotate ? 'true' : 'false') . ',
                        rotate_interval: ' . $this->rotate_interval . ',
                        transition_speed: ' . $this->transition_speed . ',
                        transition_style: "' . $this->transition_style . '"
                    });
                });
            ');
        }
    }

    /**
     * Get current settings
     */
    public function get_settings() {
        return [
            'transition_style' => $this->transition_style,
            'transition_speed' => $this->transition_speed,
            'auto_rotate' => $this->auto_rotate,
            'rotate_interval' => $this->rotate_interval,
            'content_blocks' => $this->content_blocks
        ];
    }
}

// Initialize the rotator on plugin activation
if (!function_exists('add_action') || !function_exists('is_admin')) {
    // Check if we're in WordPress or Joomla
    if (function_exists('add_action')) {
        add_action('plugins_loaded', function() {
            new DynamicContentRotator();
        });
    } elseif (class_exists('JApplicationSite')) {
        JFactory::getApplication()->registerEvent('onContentBeforeDisplay', [$this, 'joomla_before_display']);
        JFactory::getApplication()->registerEvent('onAfterBody', [$this, 'joomla_after_body']);
    }
} else {
    new DynamicContentRotator();
}

/**
 * JavaScript for the rotator
 */
?>
<script>
jQuery(document).ready(function($) {
    $.fn.dcr_rotator = function(options) {
        var settings = $.extend({
            auto_rotate: true,
            rotate_interval: 5000,
            transition_speed: 1000,
            transition_style: 'fade'
        }, options);

        return this.each(function() {
            var $container = $(this);
            var $slides = $container.find('.dcr-slide');
            var current = 0;
            var total = $slides.length;
            var timer;

            if (total < 2) {
                $container.hide();
                return;
            }

            function rotate() {
                $container.find('.dcr-slide').removeClass(settings.active_class || 'dcr-active');
                current = (current + 1) % total;
                $slides.eq(current).addClass(settings.active_class || 'dcr-active');

                if (settings.transition_style === 'fade') {
                    $container.find('.dcr-slide').fadeOut(settings.transition_speed);
                    $slides.eq(current).fadeIn(settings.transition_speed);
                } else if (settings.transition_style === 'slide') {
                    $container.find('.dcr-slide').slideUp(settings.transition_speed);
                    $slides.eq(current).slideDown(settings.transition_speed);
                } else {
                    $container.find('.dcr-slide').removeClass('active');
                    $slides.eq(current).addClass('active');
                }
            }

            if (settings.auto_rotate) {
                timer = setInterval(rotate, settings.rotate_interval);
            }

            $container.on('mouseenter', function() {
                clearInterval(timer);
            }).on('mouseleave', function() {
                if (settings.auto_rotate) {
                    timer = setInterval(rotate, settings.rotate_interval);
                }
            });

            $container.find('.dcr-slide').on('click', function() {
                clearInterval(timer);
                $container.find('.dcr-slide').removeClass('dcr-active');
                $(this).addClass('dcr-active');
            });
        });
    };
});
</script>