A!leys Galerie

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

extends CharacterBody2D

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

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

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

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

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

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

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

	# Handle input
	handle_input()

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

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

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

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

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

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

	# Apply movement
	move_and_slide()

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

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

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

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

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

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);