A!leys Galerie

extends CharacterBody2D

# State Machine Enum
enum EnemyState {
	IDLE,
	PATROL,
	CHASE,
	CYCLONE,
	ATTACK,
	RETREAT,
	DEAD
}

@export var patrol_radius: float = 200.0
@export var chase_speed: float = 300.0
@export var cyclone_speed: float = 200.0
@export var attack_range: float = 50.0
@export var health: int = 100
@export var max_health: int = 100
@export var spiral_rotation_speed: float = 3.0
@export var spiral_approach_distance: float = 150.0
@export var spiral_min_radius: float = 30.0
@export var damage_per_attack: int = 10
@export var retreat_when_health_low: int = 30
@export var patrol_points: Array2D = []

# State Variables
var current_state: EnemyState = EnemyState.IDLE
var spiral_center: Vector2 = Vector2.ZERO
var spiral_radius: float = 0.0
var spiral_rotation: float = 0.0
var original_speed: float = 300.0
var current_spiral_target: Vector2 = Vector2.ZERO
var patrol_index: int = 0
var attack_timer: float = 0.0
var attack_cooldown: float = 1.5

# Signals
signal damaged(int amount)
signal died()

func _ready():
	# Set initial position if patrol points are provided
	if patrol_points.size() > 0:
		spiral_center = global_position
		patrol_index = 0
		current_state = EnemyState.PATROL

	# Configure collision
	$CollisionShape2D.shape = RectShape2D.new()
	$CollisionShape2D.shape.extents = Vector2(10, 10)

func _process(delta):
	match current_state:
		EnemyState.IDLE:
			_idle()
		EnemyState.PATROL:
			_patrol(delta)
		EnemyState.CHASE:
			_chase(delta)
		EnemyState.CYCLONE:
			_cyclone(delta)
		EnemyState.ATTACK:
			_attack(delta)
		EnemyState.RETREAT:
			_retreat(delta)
		EnemyState.DEAD:
			_dead()

func _physics_process(delta):
	if current_state == EnemyState.DEAD:
		return

	# Always check for player proximity
	var player = get_node("/root/Player")
	if player and player.visible_on_screen_2d():
		var player_pos = player.global_position
		var dist_to_player = global_position.distance_to(player_pos)

		# Transition logic
		if current_state == EnemyState.IDLE and dist_to_player < patrol_radius:
			current_state = EnemyState.CHASE

		if current_state == EnemyState.CHASE and dist_to_player > patrol_radius:
			current_state = EnemyState.PATROL

		if current_state == EnemyState.PATROL and dist_to_player < patrol_radius * 0.7:
			current_state = EnemyState.CHASE

		if current_state == EnemyState.CHASE and dist_to_player <= spiral_approach_distance:
			current_state = EnemyState.CYCLONE

		if current_state == EnemyState.CYCLONE and dist_to_player > spiral_approach_distance * 1.5:
			current_state = EnemyState.CHASE

		if current_state == EnemyState.CHASE and dist_to_player <= attack_range:
			current_state = EnemyState.ATTACK

		if current_state == EnemyState.CYCLONE and health <= retreat_when_health_low and dist_to_player > 200:
			current_state = EnemyState.RETREAT

		if current_state == EnemyState.RETREAT and health <= 0:
			current_state = EnemyState.DEAD
			died()

	# Handle health updates
	if health <= 0:
		current_state = EnemyState.DEAD
		died()

	# Apply movement based on state
	if current_state != EnemyState.DEAD and current_state != EnemyState.ATTACK and current_state != EnemyState.IDLE:
		if current_state == EnemyState.CYCLONE:
			_move_spiral(delta)
		else:
			velocity = global_transform.basis.xform(Vector2.RIGHT) * get_state_speed()
		move_and_slide()

func _idle():
	# Wait for player to enter detection range
	if patrol_points.size() > 0:
		current_state = EnemyState.PATROL

func _patrol(delta):
	# Move to next patrol point in circular fashion
	var target_point = patrol_points[patrol_index]
	look_at(target_point)
	velocity = (target_point - global_position).normalized() * original_speed
	move_and_slide()

	# Check if reached patrol point
	if global_position.distance_to(target_point) < 10:
		patrol_index = patrol_index + 1 if patrol_index < patrol_points.size() - 1 else 0

func _chase(delta):
	var player = get_node("/root/Player")
	if player and player.visible_on_screen_2d():
		var player_pos = player.global_position
		look_at(player_pos)
		velocity = (player_pos - global_position).normalized() * chase_speed
		move_and_slide()

func _cyclone(delta):
	var player = get_node("/root/Player")
	if player and player.visible_on_screen_2d():
		var player_pos = player.global_position
		spiral_center = player_pos
		current_spiral_target = player_pos

		# Adjust spiral parameters based on distance
		spiral_radius = max(spiral_min_radius, (global_position.distance_to(player_pos) - spiral_min_radius) * 0.7)
		spiral_rotation = spiral_rotation + spiral_rotation_speed * delta

		_move_spiral(delta)

func _move_spiral(delta):
	# Calculate spiral position
	var angle = spiral_rotation
	var spiral_pos = spiral_center + Vector2(spiral_radius * cos(angle), spiral_radius * sin(angle))

	# Smooth approach to the spiral
	var current_pos = global_position
	var direction = (spiral_pos - current_pos).normalized()
	velocity = direction * cyclone_speed
	move_and_slide()

	# Rotate towards spiral center
	look_at(spiral_center)

func _attack(delta):
	attack_timer += delta
	# Visual attack animation (in Godot, this would be handled by AnimationPlayer)
	if attack_timer >= attack_cooldown:
		attack_timer = 0.0
		# Here you would typically trigger an attack animation or effect
		emit_signal("damaged", damage_per_attack)

func _retreat(delta):
	# Retreat from player in a zig-zag pattern
	var player = get_node("/root/Player")
	if player and player.visible_on_screen_2d():
		var player_pos = player.global_position
		var retreat_dir = (global_position - player_pos).normalized().rotated(Vector2.UP, 45.0 * sin(Time.get_ticks_msec() / 200.0))
		look_at(global_position + retreat_dir)
		velocity = retreat_dir * (chase_speed * 0.7)
		move_and_slide()

func _dead():
	# Cleanup and play death animation
	velocity = Vector2.ZERO
	queue_free()

func get_state_speed() -> float:
	match current_state:
		EnemyState.IDLE:
			return 0.0
		EnemyState.PATROL:
			return original_speed
		EnemyState.CHASE:
			return chase_speed
		EnemyState.CYCLONE:
			return cyclone_speed
		EnemyState.ATTACK:
			return 0.0
		EnemyState.RETREAT:
			return chase_speed * 0.7
		EnemyState.DEAD:
			return 0.0
	_return original_speed

func take_damage(amount: int):
	health -= amount
	if health > 0:
		emit_signal("damaged", amount)
	else:
		current_state = EnemyState.DEAD
		died()

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.media.MediaPlayer
import android.net.Uri
import android.os.VibrationEffect
import android.os.Vibrator
import android.os.VibratorManager
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Camera
import ScannerScreen
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.History
import androidx.compose.material.icons.filled.Mic
import androidx.compose.material.icons.filled.VolumeUp
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.ContextCompat
import com.google.zxing.BarcodeFormat
import com.google.zxing.Result
import com.journeyapps.barcodescanner.BarcodeCallback
import com.journeyapps.barcodescanner.BarcodeCallbackManager
import com.journeyapps.barcodescanner.BarcodeResult
import com.journeyapps.barcodescanner.DecoratedBarcodeView
import kotlinx.coroutines.delay
import java.util.Random

@Composable
fun QRCodeAdventureScannerApp() {
    val context = LocalContext.current
    val snackbarHostState = remember { SnackbarHostState() }
    val scannerViewState = rememberSaveable { mutableStateOf(ScannerScreen.UNREADY) }
    val barcodeResults = rememberSaveable { mutableStateOf<List<BarcodeResult>>(emptyList()) }
    val isCameraPermissionGranted = remember {
        mutableStateOf(
            ContextCompat.checkSelfPermission(
                context,
                Manifest.permission.CAMERA
            ) == PackageManager.PERMISSION_GRANTED
        )
    }
    val cameraLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission(),
        onResult = { granted ->
            isCameraPermissionGranted.value = granted
            if (granted) {
                snackbarHostState.showSnackbar("Camera permission granted!")
            }
        }
    )
    val soundEffects = remember {
        listOf(
            R.raw.explosion,
            R.raw.level_up,
            R.raw.coin,
            R.raw.magic,
            R.raw.fanfare,
            R.raw.wood_hit
        )
    }
    val currentSoundEffect by remember {
        mutableStateOf(R.raw.explosion) // Default
    }

    // Vibrator setup
    val vibrator = remember {
        (context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator) ?: Vibrator(context, null)
    }

    // Handle camera permission
    LaunchedEffect(isCameraPermissionGranted.value) {
        if (!isCameraPermissionGranted.value) {
            cameraLauncher.launch(Manifest.permission.CAMERA)
        }
    }

    // Sound effect player
    val mediaPlayer = remember {
        MediaPlayer().apply {
            setOnCompletionListener { reset() }
        }
    }

    // Play random sound effect
    val playSoundEffect = remember { { effectRes: Int ->
        mediaPlayer.setDataSource(context, Uri.parse("android.resource://${context.packageName}/$effectRes"))
        mediaPlayer.prepare()
        mediaPlayer.start()

        // Trigger vibration
        val vibratorManager = context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
        val vibrationEffect = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            VibrationEffect.createOneShot(100, VibrationEffect.DEFAULT_AMPLITUDE)
        } else {
            @Suppress("DEPRECATION")
            VibrationEffect.simpleVibrate(100)
        }
        vibrator.vibrate(vibrationEffect)
    } }

    // Play sound and pick next effect
    val playNextSound = remember { {
        val random = Random()
        val nextEffect = soundEffects[random.nextInt(soundEffects.size)]
        playSoundEffect(nextEffect)
    } }

    Scaffold(
        snackbarHost = { SnackbarHost(snackbarHostState) },
        topBar = {
            TopAppBarWith QuestPoints(
                modifier = Modifier.fillMaxWidth(),
                questPoints = barcodeResults.value.size,
                onToggleScanner = { scannerViewState.value = if (scannerViewState.value == ScannerScreen.ACTIVE) ScannerScreen.UNREADY else ScannerScreen.ACTIVE }
            )
        }
    ) { padding ->
        Box(
            modifier = Modifier
                .fillMaxSize()
                .padding(padding)
        ) {
            if (scannerViewState.value == ScannerScreen.ACTIVE) {
                ScannerContent(
                    modifier = Modifier.align(Alignment.Center),
                    onScan = { result ->
                        barcodeResults.value = listOf(result) + barcodeResults.value
                        playNextSound()
                    },
                    onError = { snackbarHostState.showSnackbar("Scan failed! Please try again.") },
                    isReady = scannerViewState.value == ScannerScreen.READY
                )
            } else {
                HistoryScreen(
                    modifier = Modifier.align(Alignment.Center),
                    results = barcodeResults.value,
                    onScanTapped = { scannerViewState.value = ScannerScreen.ACTIVE }
                )
            }
        }
    }
}

@Composable
fun TopAppBarWithQuestPoints(
    modifier: Modifier = Modifier,
    questPoints: Int,
    onToggleScanner: () -> Unit
) {
    Surface(
        modifier = modifier,
        color = MaterialTheme.colorScheme.primaryContainer
    ) {
        Column {
            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(16.dp),
                contentAlignment = Alignment.CenterStart
            ) {
                Text(
                    text = "QR Adventure Scanner",
                    color = MaterialTheme.colorScheme.onPrimaryContainer,
                    fontWeight = FontWeight.Bold,
                    fontSize = 20.sp
                )
            }
            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(horizontal = 16.dp, vertical = 8.dp),
                contentAlignment = Alignment.CenterStart
            ) {
                Text(
                    text = "Quest Points: $questPoints",
                    color = MaterialTheme.colorScheme.onPrimaryContainer,
                    fontSize = 14.sp,
                    fontWeight = FontWeight.Medium
                )
            }
            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(horizontal = 16.dp, vertical = 8.dp),
                contentAlignment = Alignment.Center
            ) {
                Button(
                    onClick = onToggleScanner,
                    colors = ButtonDefaults.buttonColors(
                        containerColor = if (scannerViewState.value == ScannerScreen.ACTIVE) {
                            MaterialTheme.colorScheme.errorContainer
                        } else {
                            MaterialTheme.colorScheme.primaryContainer
                        }
                    ),
                    border = ButtonDefaults.buttonBorder(
                        enabled = true,
                        borderColor = if (scannerViewState.value == ScannerScreen.ACTIVE) {
                            MaterialTheme.colorScheme.error
                        } else {
                            MaterialTheme.colorScheme.onPrimaryContainer
                        }
                    )
                ) {
                    Icon(
                        imageVector = if (scannerViewState.value == ScannerScreen.ACTIVE) Icons.Default.Close else Icons.Default.Camera,
                        contentDescription = if (scannerViewState.value == ScannerScreen.ACTIVE) "Return to History" else "Start Scanning"
                    )
                    Spacer(modifier = Modifier.padding(8.dp))
                    Text(
                        text = if (scannerViewState.value == ScannerScreen.ACTIVE) "History" else "Scan QR Code"
                    )
                }
            }
        }
    }
}

enum class ScannerScreen {
    UNREADY, READY, ACTIVE
}

@Composable
fun ScannerContent(
    modifier: Modifier = Modifier,
    onScan: (Result) -> Unit,
    onError: () -> Unit,
    isReady: Boolean
) {
    val context = LocalContext.current
    val anitableColor = remember {
        Animatable(initialValue = Color.Transparent)
    }

    // Scanner setup
    val barcodeView = remember { DecoratedBarcodeView(context) }
    val callbackManager = remember { BarcodeCallbackManager(context, barcodeView) }
    val barcodeCallback = remember {
        object : BarcodeCallback {
            override fun barcodeResult(result: BarcodeResult) {
                onScan(result.result)
                callbackManager.stop()
            }

            override fun possibleResultPoints(resultPoints: List<com.journeyapps.barcodescanner.BarcodeResult.Point?>) {
                // Not needed for this demo
            }
        }
    }

    LaunchedEffect(isReady) {
        if (isReady) {
            callbackManager.startLiveScan(barcodeCallback, BarcodeFormat.QR_CODE)
            anitableColor.animateTo(
                targetValue = Color.Green,
                animationSpec = tween(durationMillis = 300)
            )
        } else {
            callbackManager.stop()
            anitableColor.animateTo(
                targetValue = Color.Transparent,
                animationSpec = tween(durationMillis = 300)
            )
        }
    }

    Column(
        modifier = modifier
            .fillMaxWidth()
            .clip(MaterialTheme.shapes.large),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Box(
            modifier = Modifier
                .fillMaxWidth()
                .aspectRatio(1f)
                .background(if (isReady) Color.Green.copy(alpha = 0.2f) else Color.Transparent),
            contentAlignment = Alignment.Center
        ) {
            if (isReady) {
                DecoratedBarcodeView(
                    modifier = Modifier.fillMaxSize(),
                    torchModeEnabled = false,
                    barcodeView = barcodeView
                )
                CircularProgressIndicator(
                    modifier = Modifier.align(Alignment.Center),
                    color = MaterialTheme.colorScheme.primary,
                    strokeWidth = 4.dp
                )
            } else {
                Text(
                    text = "Point camera at QR code",
                    color = MaterialTheme.colorScheme.onSurface,
                    fontSize = 16.sp
                )
            }
        }
        Spacer(modifier = Modifier.height(16.dp))
        if (isReady) {
            Text(
                text = "Scanning...",
                color = MaterialTheme.colorScheme.onSurface,
                fontSize = 16.sp
            )
        }
    }
}

@Composable
fun HistoryScreen(
    modifier: Modifier = Modifier,
    results: List<BarcodeResult>,
    onScanTapped: () -> Unit
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Your Adventure Log",
            style = MaterialTheme.typography.headlineMedium,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.onSurface,
            modifier = Modifier.padding(bottom = 16.dp)
        )
        if (results.isEmpty()) {
            Text(
                text = "No quests completed yet. Start scanning to embark on your adventure!",
                color = MaterialTheme.colorScheme.onSurfaceVariant,
                modifier = Modifier.padding(16.dp)
            )
            Button(
                onClick = onScanTapped,
                modifier = Modifier.padding(top = 16.dp),
                colors = ButtonDefaults.buttonColors(
                    containerColor = MaterialTheme.colorScheme.primaryContainer
                )
            ) {
                Icon(Icons.Default.Camera, contentDescription = "Start Scanning")
                Spacer(modifier = Modifier.padding(8.dp))
                Text("Start Scanning")
            }
        } else {
            LazyColumn(
                modifier = Modifier.fillMaxSize(),
                contentPadding = PaddingValues(bottom = 16.dp)
            ) {
                items(results) { result ->
                    QuestCard(
                        quest = generateQuest(result.text),
                        dateTime = result.time,
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(vertical = 8.dp)
                    )
                }
            }
        }
    }
}

fun generateQuest(text: String): Quest {
    val questTypes = listOf(
        QuestType.DISCOVERY,
        QuestType.ENIGMA,
        QuestType.TREASURE,
        QuestType.CRYPTIC,
        QuestType.MAGICAL
    )
    val random = Random()
    val type = questTypes[random.nextInt(questTypes.size)]
    return when (type) {
        QuestType.DISCOVERY -> Quest(
            title = "Ancient Discovery",
            description = "You discovered an ancient artifact containing: $text",
            reward = "10 XP"
        )
        QuestType.ENIGMA -> Quest(
            title = "Decoded Enigma",
            description = "You solved the enigma hidden in: $text",
            reward = "15 XP"
        )
        QuestType.TREASURE -> Quest(
            title = "Treasure Found",
            description = "The QR code led you to hidden treasure at location: $text",
            reward = "20 XP + 5 Coins"
        )
        QuestType.CRYPTIC -> Quest(
            title = "Cryptic Message",
            description = "You decoded a cryptic message from: $text",
            reward = "12 XP"
        )
        QuestType.MAGICAL -> Quest(
            title = "Magical Artifact",
            description = "A magical artifact responded to your scan of: $text",
            reward = "18 XP + Special Ability"
        )
    }
}

data class Quest(
    val title: String,
    val description: String,
    val reward: String
)

enum class QuestType {
    DISCOVERY, ENIGMA, TREASURE, CRYPTIC, MAGICAL
}

@Composable
fun QuestCard(
    quest: Quest,
    dateTime: Long,
    modifier: Modifier = Modifier
) {
    Card(
        modifier = modifier.fillMaxWidth(),
        elevation = CardDefaults.cardElevation(4.dp)
    ) {
        Column(
            modifier = Modifier.padding(16.dp)
        ) {
            Text(
                text = quest.title,
                style = MaterialTheme.typography.titleLarge,
                fontWeight = FontWeight.Bold,
                color = MaterialTheme.colorScheme.primary
            )
            Spacer(modifier = Modifier.height(8.dp))
            Text(
                text = quest.description,
                color = MaterialTheme.colorScheme.onSurfaceVariant,
                fontSize = 14.sp
            )
            Spacer(modifier = Modifier.height(12.dp))
            Text(
                text = "Completed on: ${formatDateTime(dateTime)}",
                color = MaterialTheme.colorScheme.onSurfaceVariant,
                fontSize = 12.sp
            )
            Spacer(modifier = Modifier.height(8.dp))
            Text(
                text = "Reward: ${quest.reward}",
                color = MaterialTheme.colorScheme.secondary,
                fontWeight = FontWeight.Medium
            )
        }
    }
}

fun formatDateTime(millis: Long): String {
    return java.text.SimpleDateFormat("MMM dd, yyyy hh:mm a", java.util.Locale.getDefault()).format(millis)
}

@Preview(showBackground = true)
@Composable
fun PreviewQRCodeAdventureScannerApp() {
    MaterialTheme {
        QRCodeAdventureScannerApp()
    }
}

// Dynamic Weather Particle Studio
// A creative particle effect generator with weather-inspired parameters
// Outputs RPG Maker MZ compatible plugin code with localStorage presets

import fs from 'fs';
import readline from 'readline';

// Particle effect types with weather-inspired parameters
const WEATHER_EFFECTS = {
    rain: { baseColor: '#4a8bef', saturation: 0.7, speedRange: [0.5, 1.5], sizeRange: [8, 15], opacityRange: [0.3, 0.8] },
    snow: { baseColor: '#ffffff', saturation: 0.0, speedRange: [0.2, 0.8], sizeRange: [5, 12], opacityRange: [0.7, 1.0] },
    fog: { baseColor: '#a3a3a3', saturation: 0.3, speedRange: [0.1, 0.3], sizeRange: [20, 40], opacityRange: [0.2, 0.5] },
    sandstorm: { baseColor: '#f4d03f', saturation: 0.8, speedRange: [0.8, 2.0], sizeRange: [10, 25], opacityRange: [0.4, 0.9] },
    lightning: { baseColor: '#ffeb3b', saturation: 0.9, speedRange: [1.5, 3.0], sizeRange: [30, 60], opacityRange: [0.6, 1.0] }
};

// Generate RPG Maker MZ plugin code from parameters
function generateRMPlugin(effectType, params, presetName = null) {
    const baseColor = params.baseColor;
    const saturation = params.saturation;
    const speedRange = params.speedRange;
    const sizeRange = params.sizeRange;
    const opacityRange = params.opacityRange;
    const count = params.count || 100;
    const blendMode = effectType === 'lightning' ? 'add' : 'normal';

    let pluginCode = `// Generated Particle Effect - ${effectType} (${presetName || 'Custom'})
/*:
 * @plugindesc Dynamic ${effectType} particle effect with weather parameters.
 * @author Dynamic Weather Studio
 * @help
 * Creates a dynamic particle effect based on weather patterns.
 * Parameters can be adjusted in the plugin manager.
 */

(function() {
    const parameters = {
        baseColor: "${baseColor}",
        saturation: ${saturation},
        speedRange: [${speedRange.join(', ')}],
        sizeRange: [${sizeRange.join(', ')}],
        opacityRange: [${opacityRange.join(', ')}],
        count: ${count},
        blendMode: "${blendMode}",
        weatherType: "${effectType}"
    };

    // Main plugin implementation
    _PluginManager.registerCommand('DynamicWeatherEffect', function(effectType) {
        const weatherParams = parameters;
        const baseColor = ColorManager.convertColor(weatherParams.baseColor);
        const hue = baseColor.hue();

        // Create particles
        const particles = [];
        for (let i = 0; i < weatherParams.count; i++) {
            const particle = new Game_Particle('basic');
            const size = Random ranging(weatherParams.sizeRange[0], weatherParams.sizeRange[1]);
            const speed = Random ranging(weatherParams.speedRange[0], weatherParams.speedRange[1]);
            const opacity = Random ranging(weatherParams.opacityRange[0], weatherParams.opacityRange[1]);
            const saturation = weatherParams.saturation + (Math.random() * 0.2 - 0.1); // Add slight variation

            particle.init(
                Math.random() * Game_Particle.birthRate,
                Math.random() * Game_Particle.deathRate,
                size,
                baseColor.clone().setHue(hue + (Math.random() * 30 - 15)),
                [0, 0],
                [speed, speed],
                weatherParams.blendMode,
                false
            );
            particles.push(particle);
        }

        // Animate particles
        this._weatherParticles = particles;
    });

    // Game_Interpreter command for triggering effects
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        if (command === 'WeatherEffect') {
            _PluginManager.registerCommand('DynamicWeatherEffect', args[0]);
        }
    };
})();
    `;

    return pluginCode;
}

// Load presets from localStorage
function loadPresets() {
    try {
        const presets = JSON.parse(localStorage.getItem('weatherPresets')) || {};
        return Object.entries(presets).map(([name, params]) => ({
            name,
            ...params
        }));
    } catch (e) {
        console.error('Error loading presets:', e);
        return [];
    }
}

// Save preset to localStorage
function savePreset(name, effectType, params) {
    const presets = JSON.parse(localStorage.getItem('weatherPresets')) || {};
    presets[name] = { effectType, params };
    localStorage.setItem('weatherPresets', JSON.stringify(presets));
}

// CLI interaction
function startCLI() {
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });

    console.log('\n=== Dynamic Weather Particle Studio ===');
    console.log('1. Generate new effect');
    console.log('2. List saved presets');
    console.log('3. Export preset to RPG Maker plugin');
    console.log('4. Exit');

    const mainMenu = async () => {
        const question = '\nSelect option (1-4): ';
        const answer = await ask(question);

        switch (answer) {
            case '1':
                await generateNewEffect(rl);
                break;
            case '2':
                listPresets(rl);
                break;
            case '3':
                await exportPreset(rl);
                break;
            case '4':
                rl.close();
                return;
            default:
                console.log('Invalid option. Try again.');
        }

        mainMenu();
    };

    mainMenu();
}

// Ask user a question
function ask(question) {
    return new Promise(resolve => {
        readline.question(question, answer => resolve(answer));
    });
}

// Generate new effect with custom parameters
async function generateNewEffect(rl) {
    console.log('\n=== New Weather Effect Generator ===');
    const effects = Object.keys(WEATHER_EFFECTS);
    console.log('Available weather types:', effects.join(', '));

    const effectType = await ask('Select effect type: ');
    if (!effects.includes(effectType)) {
        console.log('Invalid effect type. Using default (rain).');
    } else {
        console.log(`\nSelected: ${effectType}`);
    }

    const params = {
        ...WEATHER_EFFECTS[effectType],
        count: parseInt(await ask(`Particle count (${params.count}): `)) || params.count,
        baseColor: await ask(`Base color (${params.baseColor}, e.g., #4a8bef): `)
    };

    const presetName = await ask(`Preset name (leave blank to skip saving): `);

    if (presetName) {
        savePreset(presetName, effectType, params);
        console.log(`Saved preset "${presetName}"`);
    }

    return { effectType, params, presetName };
}

// List saved presets
function listPresets(rl) {
    const presets = loadPresets();
    if (presets.length === 0) {
        console.log('No presets saved.');
        return;
    }

    console.log('\n=== Saved Presets ===');
    presets.forEach((preset, index) => {
        console.log(`${index + 1}. ${preset.name} (${preset.effectType})`);
    });
}

// Export preset to RPG Maker plugin
async function exportPreset(rl) {
    const presets = loadPresets();
    if (presets.length === 0) {
        console.log('No presets to export.');
        return;
    }

    console.log('\n=== Export Preset ===');
    const index = parseInt(await ask('Select preset number to export: ')) - 1;

    if (index < 0 || index >= presets.length) {
        console.log('Invalid preset number.');
        return;
    }

    const { name, effectType, params } = presets[index];
    const pluginCode = generateRMPlugin(effectType, params, name);
    const outputPath = await ask('Enter output file path (e.g., weather_effect.js): ');

    fs.writeFile(outputPath, pluginCode, (err) => {
        if (err) {
            console.error('Error writing file:', err);
            return;
        }
        console.log(`Successfully exported preset "${name}" to ${outputPath}`);
    });
}

// Start the application
startCLI().catch(console.error);

#!/usr/bin/env node

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { marked } from 'marked';
import * as hljs from 'highlight.js';

// Custom theme data
const THEMES = {
  light: {
    bg: '#f8f9fa',
    text: '#212529',
    primary: '#0d6efd',
    secondary: '#6c757d',
    border: '#dee2e6',
    accent: '#fd7e14',
    heading: '#198754',
    codeBg: '#f8f9fa',
    codeText: '#212529',
  },
  dark: {
    bg: '#212529',
    text: '#f8f9fa',
    primary: '#0d6efd',
    secondary: '#6c757d',
    border: '#495057',
    accent: '#fd7e14',
    heading: '#198754',
    codeBg: '#2b3038',
    codeText: '#f8f9fa',
  },
};

// CSS for dark/light mode with animations
const getThemeCss = (theme, isDark) => `
  :root {
    --bg: ${theme.bg};
    --text: ${theme.text};
    --primary: ${theme.primary};
    --secondary: ${theme.secondary};
    --border: ${theme.border};
    --accent: ${theme.accent};
    --heading: ${theme.heading};
    --code-bg: ${theme.codeBg};
    --code-text: ${theme.codeText};
    --mode: ${isDark ? 'dark' : 'light'};
  }

  body {
    background-color: var(--bg);
    color: var(--text);
    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
    line-height: 1.6;
    margin: 0;
    padding: 2rem;
    transition: background-color 0.3s ease, color 0.3s ease;
  }

  h1, h2, h3, h4, h5, h6 {
    color: var(--heading);
  }

  a {
    color: var(--primary);
    text-decoration: none;
    transition: color 0.2s ease;
  }

  a:hover {
    color: var(--accent);
    text-decoration: underline;
  }

  code, pre {
    background-color: var(--code-bg);
    color: var(--code-text);
    border-radius: 4px;
    padding: 0.2rem 0.4rem;
  }

  pre {
    padding: 1rem;
    overflow-x: auto;
  }

  blockquote {
    background-color: rgba(0, 0, 0, 0.05);
    border-left: 4px solid var(--accent);
    padding-left: 1rem;
    color: var(--secondary);
    margin: 1rem 0;
  }

  hr {
    border: 0;
    border-top: 1px solid var(--border);
  }

  /* Playful animations */
  @keyframes float {
    0% { transform: translateY(0px); }
    50% { transform: translateY(-10px); }
    100% { transform: translateY(0px); }
  }

  h1 {
    animation: float 3s ease-in-out infinite;
  }

  @media (prefers-color-scheme: dark) {
    :root {
      --mode: dark;
    }
  }
`;

// Configure marked
marked.setOptions({
  gfm: true,
  breaks: true,
  highlight: (code, lang) => {
    if (hljs.getLanguage(lang)) {
      return hljs.highlight(code, { language: lang }).value;
    }
    return code;
  }
});

// Main function
const main = async () => {
  const __dirname = path.dirname(fileURLToPath(import.meta.url));
  const [inputPath, outputPath, theme = 'light'] = process.argv.slice(2);

  if (!inputPath || !outputPath) {
    console.error('Usage: node markdown-glamour.js <input.md> <output.html> [theme=light|dark]');
    process.exit(1);
  }

  try {
    const markdownContent = fs.readFileSync(inputPath, 'utf8');
    const html = marked(markdownContent);
    const isDark = theme === 'dark';
    const themeData = THEMES[theme];

    // Inject custom CSS and theme colors
    const fullHtml = `
      <!DOCTYPE html>
      <html lang="en">
      <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Markdown Glamour</title>
        <style>${getThemeCss(themeData, isDark)}</style>
        <style>
          /* Additional custom styles */
          body {
            max-width: 900px;
            margin: 0 auto;
          }
          img {
            max-width: 100%;
            height: auto;
            border-radius: 8px;
          }
        </style>
      </head>
      <body>
        ${html}
      </body>
      </html>
    `;

    fs.writeFileSync(outputPath, fullHtml);
    console.log(`Successfully converted to ${outputPath} with ${theme} theme!`);
  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
};

// Handle both CommonJS and ES modules
if (typeof module !== 'undefined' && module.exports) {
  module.exports = main;
} else {
  main();
}

#!/usr/bin/env python3
"""
Regex Sorcerer - A visually enchanting regex tester that reveals the magic behind regular expressions
with smooth animations, step-by-step parsing, and detailed explanations.
"""

import re
import time
import sys
from typing import Tuple, List, Optional, Dict
import traceback
from enum import Enum, auto
import argparse
import textwrap
import random
from dataclasses import dataclass
from abc import ABC, abstractmethod

import pygame
from pygame.locals import (
    K_UP, K_DOWN, K_RETURN, K_BACKSPACE, K_ESCAPE, K_TAB, K_LEFTSHIFT, K_RIGHTSHIFT,
    MOUSEBUTTONUP, MOUSEBUTTONDOWN, MOUSEMOTION, QUIT
)

# Constants
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
DARK_GRAY = (50, 50, 50)
GOLD = (255, 215, 0)
MAGENTA = (255, 0, 255)
LIGHT_BLUE = (173, 216, 230)
DARK_BLUE = (0, 0, 139)
GREEN = (0, 128, 0)
LIGHT_GREEN = (144, 238, 144)
RED = (255, 0, 0)
BACKGROUND_COLOR = DARK_GRAY
HIGHLIGHT_COLOR = LIGHT_BLUE
TEXT_COLOR = WHITE
MAGIC_COLOR = GOLD
ERROR_COLOR = RED

# Animation constants
ANIMATION_DURATION = 0.2  # seconds
ANIMATION_STEPS = 20
FADE_DURATION = 0.3
BPlusFADE_DURATION = 0.15

# Font setup
SMALL_FONT_SIZE = 20
MEDIUM_FONT_SIZE = 24
LARGE_FONT_SIZE = 28
TITLE_FONT_SIZE = 36

class AnimationType(Enum):
    SLIDE_IN = auto()
    SLIDE_OUT = auto()
    FADE_IN = auto()
    FADE_OUT = auto()
    PULSE = auto()
    BPlus = auto()

class Animation(ABC):
    def __init__(self, start_value: float, end_value: float, duration: float):
        self.start_value = start_value
        self.end_value = end_value
        self.duration = duration
        self.current_time = 0.0
        self.completed = False

    @abstractmethod
    def update(self, delta_time: float) -> float:
        pass

    @abstractmethod
    def is_completed(self) -> bool:
        pass

class LinearAnimation(Animation):
    def update(self, delta_time: float) -> float:
        self.current_time += delta_time
        if self.current_time >= self.duration:
            self.completed = True
            return self.end_value
        progress = self.current_time / self.duration
        return self.start_value + (self.end_value - self.start_value) * progress

    def is_completed(self) -> bool:
        return self.completed

class FadeAnimation(Animation):
    def update(self, delta_time: float) -> float:
        self.current_time += delta_time
        if self.current_time >= self.duration:
            self.completed = True
            return self.end_value
        progress = self.current_time / self.duration
        return self.start_value + (self.end_value - self.start_value) * (1 - (1 - progress) ** 2)

    def is_completed(self) -> bool:
        return self.completed

class BPlusAnimation(Animation):
    def __init__(self, start_value: float, end_value: float, duration: float, bplus_factor: float):
        super().__init__(start_value, end_value, duration)
        self.bplus_factor = bplus_factor
        self.oscillation = 0

    def update(self, delta_time: float) -> float:
        self.current_time += delta_time
        if self.current_time >= self.duration:
            self.completed = True
            return self.end_value

        progress = self.current_time / self.duration
        self.oscillation = math.sin(progress * math.pi * 2 * self.bplus_factor) * 0.1
        return self.start_value + (self.end_value - self.start_value) * progress + self.oscillation

    def is_completed(self) -> bool:
        return self.completed

@dataclass
class RegexComponent:
    pattern: str
    explanation: str
    category: str
    color: Tuple[int, int, int] = GOLD
    start_pos: int = 0
    end_pos: int = 0

class RegexSorcerer:
    def __init__(self, screen: pygame.Surface):
        self.screen = screen
        self.width, self.height = screen.get_size()
        self.clock = pygame.time.Clock()
        self.fonts = self._init_fonts()
        self.running = True
        self.state = "title"
        self.history = []
        self.current_regex = ""
        self.current_test_string = ""
        self.results = []
        self.animations = []
        self.component_animations = []
        self.state_animations = []
        self.event_queue = []
        self.component_highlights = []
        self.test_string_highlights = []
        self.floating_particles = []
        self.last_update_time = time.time()
        self._init_sounds()

    def _init_fonts(self) -> Dict[str, pygame.font.Font]:
        return {
            "small": pygame.font.SysFont("Courier New", SMALL_FONT_SIZE),
            "medium": pygame.font.SysFont("Courier New", MEDIUM_FONT_SIZE),
            "large": pygame.font.SysFont("Courier New", LARGE_FONT_SIZE),
            "title": pygame.font.SysFont("Arial", TITLE_FONT_SIZE, bold=True),
            "title_bold": pygame.font.SysFont("Arial", TITLE_FONT_SIZE, bold=True, italic=True)
        }

    def _init_sounds(self):
        try:
            self.success_sound = pygame.mixer.Sound("assets/success.wav")
            self.error_sound = pygame.mixer.Sound("assets/error.wav")
            self.magic_sound = pygame.mixer.Sound("assets/magic.wav")
            self.fade_sound = pygame.mixer.Sound("assets/fade.wav")
            self.mixer = pygame.mixer.Channel(4)
        except:
            self.success_sound = None
            self.error_sound = None
            self.magic_sound = None
            self.fade_sound = None
            self.mixer = None

    def _add_event(self, event):
        self.event_queue.append(event)

    def _process_events(self):
        for event in self.event_queue:
            if event.type == QUIT:
                self.running = False
            elif event.type == MOUSEBUTTONDOWN:
                if event.button == 1:  # Left mouse button
                    self._handle_click(event.pos)
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    self._handle_enter()
                elif event.key == K_BACKSPACE:
                    self._handle_backspace()
                elif event.key == K_TAB:
                    self._handle_tab(event.mod)
                elif event.key == K_ESCAPE:
                    self._handle_escape()
                elif event.key == K_UP:
                    self._handle_up()
                elif event.key == K_DOWN:
                    self._handle_down()
                elif event.unicode and event.unicode.isprintable():
                    self._handle_char_input(event.unicode)
        self.event_queue.clear()

    def _handle_click(self, pos: Tuple[int, int]):
        if self.state == "title":
            if 300 <= pos[0] <= 700 and 400 <= pos[1] <= 450:
                self.state = "regex_input"
                self._add_event(pygame.event.Event(MOUSEBUTTONUP, {"pos": pos}))
        elif self.state == "regex_input":
            x, y = pos
            if 100 <= x <= 100 + 200 and 100 <= y <= 100 + 30:
                self._toggle_regex_capture_group()
            elif 100 <= x <= 100 + 200 and 150 <= y <= 150 + 30:
                self._toggle_regex_flag(1)
            elif 100 <= x <= 100 + 200 and 200 <= y <= 200 + 30:
                self._toggle_regex_flag(2)
            elif 100 <= x <= 100 + 200 and 250 <= y <= 250 + 30:
                self._toggle_regex_flag(3)
            elif 100 <= x <= 100 + 200 and 300 <= y <= 300 + 30:
                self._toggle_regex_flag(4)
            elif 350 <= x <= 350 + 300 and 100 <= y <= 100 + 30:
                self.current_test_string = "Hello, world!"
            elif 350 <= x <= 350 + 300 and 150 <= y <= 150 + 30:
                self.current_test_string = "123-456-7890"
            elif 200 <= y <= 200 + 30:
                self.current_test_string = "test@example.com"
            elif 250 <= y <= 250 + 30:
                self.current_test_string = "2023-12-25"
            elif 300 <= y <= 300 + 30:
                self.current_test_string = ""

    def _handle_enter(self):
        if self.state == "title":
            self.state = "regex_input"
        elif self.state == "regex_input":
            if self.current_regex.strip():
                self._parse_regex()
        elif self.state == "results":
            pass

    def _handle_backspace(self):
        if self.state == "regex_input":
            if self.current_regex:
                self.current_regex = self.current_regex[:-1]
        elif self.state == "regex_input_test_string":
            if self.current_test_string:
                self.current_test_string = self.current_test_string[:-1]

    def _handle_tab(self, mod):
        if mod & K_LEFTSHIFT or mod & K_RIGHTSHIFT:
            if self.state == "regex_input":
                self.state = "regex_input_test_string"
            elif self.state == "regex_input_test_string":
                self.state = "regex_input"
        else:
            pass  # Could handle other tab functionality

    def _handle_escape(self):
        if self.state == "regex_input":
            self.state = "title"
        elif self.state == "regex_input_test_string":
            self.state = "regex_input"
        elif self.state == "results":
            self.state = "title"

    def _handle_up(self):
        if self.state == "regex_input":
            pass  # Could navigate through components
        elif self.state == "regex_input_test_string":
            pass  # Could navigate through test string positions

    def _handle_down(self):
        if self.state == "regex_input":
            pass  # Could navigate through components
        elif self.state == "regex_input_test_string":
            pass  # Could navigate through test string positions

    def _handle_char_input(self, char: str):
        if self.state == "regex_input":
            self.current_regex += char
        elif self.state == "regex_input_test_string":
            self.current_test_string += char

    def _toggle_regex_capture_group(self):
        if self.current_regex.endswith("(?:"):
            self.current_regex = self.current_regex[:-3] + ")"
        elif self.current_regex.endswith("(?:"):
            self.current_regex = self.current_regex[:-1] + "(?:"
        else:
            self.current_regex += "(?:"

    def _toggle_regex_flag(self, flag_index: int):
        flags = [re.IGNORECASE, re.MULTILINE, re.DOTALL, re.VERBOSE]
        current_flags = re.compile(self.current_regex).flags if self.current_regex else 0

        if flag_index < 4:
            if current_flags & flags[flag_index]:
                new_flags = current_flags & ~flags[flag_index]
            else:
                new_flags = current_flags | flags[flag_index]

            # Rebuild the regex with new flags
            if new_flags == 0:
                new_regex = self.current_regex
            else:
                flag_str = ""
                if new_flags & re.IGNORECASE:
                    flag_str += "i"
                if new_flags & re.MULTILINE:
                    flag_str += "m"
                if new_flags & re.DOTALL:
                    flag_str += "s"
                if new_flags & re.VERBOSE:
                    flag_str += "x"
                new_regex = f"{self.current_regex}{flag_str}" if flag_str else self.current_regex

            self.current_regex = new_regex

    def _handle_test_string_click(self, pos: Tuple[int, int]):
        x, y = pos
        if 350 <= x <= 350 + 300:
            if 100 <= y <= 100 + 30:
                self.current_test_string = "Hello, world!"
            elif 150 <= y <= 150 + 30:
                self.current_test_string = "123-456-7890"
            elif 200 <= y <= 200 + 30:
                self.current_test_string = "test@example.com"
            elif 250 <= y <= 250 + 30:
                self.current_test_string = "2023-12-25"
            elif 300 <= y <= 300 + 30:
                self.current_test_string = ""

    def _toggle_test_string_highlight(self):
        # Toggle between showing/hiding character highlights
        pass  # Implementation would toggle self.test_string_highlights

    def _parse_regex(self):
        if not self.current_regex.strip():
            return

        self._add_animation(AnimationType.FADE_OUT, duration=FADE_DURATION)
        self._add_event(pygame.event.Event(MOUSEBUTTONUP, {"pos": (500, 500)}))
        self._add_event(pygame.event.Event(KEYDOWN, {"key": K_RETURN}))

        # Simulate a short delay before parsing
        time.sleep(0.1)

        try:
            pattern = re.compile(self.current_regex)
            self.results = self._analyze_regex(pattern)

            # Play success sound if available
            if self.success_sound:
                self.mixer.play(self.success_sound)

            # Transition to results state
            self.state = "results"

        except re.error as e:
            error_msg = f"Regex Error: {str(e)}"
            self.results = [("error", error_msg, BLACK)]
            if self.error_sound:
                self.mixer.play(self.error_sound)

            # Transition to results state
            self.state = "results"

        except Exception as e:
            error_msg = f"Unexpected error: {str(e)}\n{traceback.format_exc()}"
            self.results = [("error", error_msg, BLACK)]
            if self.error_sound:
                self.mixer.play(self.error_sound)
            self.state = "results"

    def _analyze_regex(self, pattern: re.Pattern) -> List[Tuple[str, str, Tuple[int, int, int]]]:
        components = self._extract_regex_components(pattern.pattern)
        explanations = []

        # First, show the full pattern
        explanations.append(("pattern", f"Pattern: {pattern.pattern}", MAGIC_COLOR))

        # Add components with explanations
        for i, component in enumerate(components):
            explanation = self._get_component_explanation(component)
            color = component.color
            explanations.append((f"component_{i}", explanation, color))

        # Add test results
        if self.current_test_string.strip():
            test_results = self._test_regex(pattern, self.current_test_string)
            explanations.append(("test_results", test_results, WHITE))

        return explanations

    def _extract_regex_components(self, pattern_str: str) -> List[RegexComponent]:
        components = []
        i = 0
        n = len(pattern_str)

        while i < n:
            if pattern_str[i] == '\\':
                # Handle escape sequences
                if i + 1 < n:
                    char = pattern_str[i+1]
                    component = RegexComponent(
                        pattern=f"\\{char}",
                        explanation=f"Escaped character: {char}",
                        category="escape",
                        color=MAGENTA,
                        start_pos=i,
                        end_pos=i+2
                    )
                    components.append(component)
                    i += 2
                else:
                    # Invalid escape at end
                    component = RegexComponent(
                        pattern="\\",
                        explanation="Incomplete regex",
                        category="error",
                        color=ERROR_COLOR,
                        start_pos=i,
                        end_pos=i+1
                    )
                    components.append(component)
                    break
            elif pattern_str[i] == '(':
                # Handle opening parenthesis
                if i + 1 < n and pattern_str[i+1] == '(':
                    # Nested parentheses
                    nested_count = 1
                    start_pos = i
                    i += 2
                    while nested_count > 0:
                        if pattern_str[i] == '(':
                            nested_count += 1
                        elif pattern_str[i] == ')':
                            nested_count -= 1
                        i += 1
                    end_pos = i
                    component = RegexComponent(
                        pattern=f"({pattern_str[start_pos:end_pos]}",
                        explanation=f"Nested group: {pattern_str[start_pos:end_pos]}",
                        category="group",
                        color=MAGENTA,
                        start_pos=start_pos,
                        end_pos=end_pos
                    )
                    components.append(component)
                else:
                    # Regular opening parenthesis
                    start_pos = i
                    i += 1
                    while i < n and pattern_str[i] != ')':
                        i += 1
                    end_pos = i
                    component = RegexComponent(
                        pattern=f"({pattern_str[start_pos:end_pos]}",
                        explanation=f"Regular group: {pattern_str[start_pos:end_pos]}",
                        category="group",
                        color=MAGENTA,
                        start_pos=start_pos,
                        end_pos=end_pos
                    )
                    components.append(component)
            elif pattern_str[i] == ')':
                # Handle closing parenthesis
                if i + 1 < n and pattern_str[i+1] == ')':
                    # Nested parentheses
                    nested_count = 1
                    start_pos = i
                    i += 2
                    while nested_count > 0:
                        if pattern_str[i] == '(':
                            nested_count += 1
                        elif pattern_str[i] == ')':
                            nested_count -= 1
                        i += 1
                    end_pos = i
                    component = RegexComponent(
                        pattern=f"{pattern_str[start_pos:end_pos]}",
                        explanation=f"Nested group: {pattern_str[start_pos:end_pos]}",
                        category="group",
                        color=MAGENTA,
                        start_pos=start_pos,
                        end_pos=end_pos
                    )
                    components.append(component)
                else:
                    # Regular closing parenthesis
                    start_pos