A!leys Galerie

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.animation.core.*
import androidx.compose.foundation.*
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.*
import androidx.compose.runtime.*
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.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.unitconverter.ui.theme.UnitConverterTheme
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.expandVertically
import androidx.compose.animation.fadeIn
import androidx.compose.animation.shrinkVertically
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.text.style.TextOverflow
import com.example.unitconverter.data.UnitConverterData
import com.example.unitconverter.ui.theme.Purple200
import com.example.unitconverter.ui.theme.Teal200
import kotlinx.coroutines.launch

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            UnitConverterTheme {
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    UnitConverterApp()
                }
            }
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun UnitConverterApp() {
    var inputValue by remember { mutableStateOf("") }
    var resultValue by remember { mutableStateOf("") }
    var selectedUnits by remember { mutableStateOf(UnitConverterData.allUnits.first()) }
    var isAnimating by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope()

    val animateVisible = remember { Animatable(0f) }
    val animateResult = remember { Animatable(0f) }
    val animateFloating = remember { Animatable(0f) }

    val floatingEmoji = when (selectedUnits.emoji) {
        "🌡️" -> "🔥"
        "ℹ️" -> "💧"
        "📏" -> "🎨"
        "🔋" -> "⚡"
        else -> "✨"
    }

    UnitConverterTheme {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(16.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Text(
                text = "Unit Converter 🎉",
                style = MaterialTheme.typography.headlineMedium,
                color = MaterialTheme.colorScheme.primary,
                fontWeight = FontWeight.Bold,
                modifier = Modifier.padding(vertical = 16.dp)
            )

            AnimatedVisibility(
                visible = !isAnimating,
                enter = expandVertically() + fadeIn(),
                exit = shrinkVertically() + fadeIn()
            ) {
                UnitConverterScreen(
                    inputValue = inputValue,
                    onInputChange = { inputValue = it },
                    selectedUnits = selectedUnits,
                    onUnitChange = { selectedUnits = it },
                    onConvert = {
                        scope.launch {
                            isAnimating = true
                            animateVisible.animateTo(1f, animationSpec = tween(300))
                            animateResult.animateTo(1f, animationSpec = tween(300))
                            animateFloating.animateTo(100f, animationSpec = tween(500))

                            resultValue = UnitConverterData.convert(
                                inputValue.toDoubleOrNull() ?: 0.0,
                                selectedUnits
                            ).toString()

                            // Wait for animation to complete
                            animateFloating.animateTo(0f, animationSpec = tween(300))
                            animateResult.animateTo(0f, animationSpec = tween(300))
                            animateVisible.animateTo(0f, animationSpec = tween(300))
                            isAnimating = false
                        }
                    }
                )
            }

            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(animateFloating.value.dp)
                    .align(Alignment.CenterHorizontally),
                contentAlignment = Alignment.Center
            ) {
                AnimatedContent(
                    targetState = floatingEmoji,
                    transitionSpec = {
                        tween(300).using(
                            initialTargetState = floatingEmoji,
                            crossfadeWith = floatingEmoji
                        )
                    }
                ) { target ->
                    Text(
                        text = target,
                        fontSize = 48.sp,
                        color = Color.Black,
                        modifier = Modifier
                            .clip(CircleShape)
                            .background(Purple200)
                            .padding(8.dp)
                    )
                }
            }
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun UnitConverterScreen(
    inputValue: String,
    onInputChange: (String) -> Unit,
    selectedUnits: UnitConverterData.UnitInfo,
    onUnitChange: (UnitConverterData.UnitInfo) -> Unit,
    onConvert: () -> Unit
) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(horizontal = 16.dp),
        shape = RoundedCornerShape(16.dp),
        elevation = CardDefaults.cardElevation(4.dp)
    ) {
        Column(
            modifier = Modifier.padding(16.dp),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            TextField(
                value = inputValue,
                onValueChange = onInputChange,
                label = { Text("Enter value") },
                keyboardOptions = KeyboardOptions.Default.copy(
                    keyboardType = KeyboardType.Number
                ),
                singleLine = true,
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 8.dp),
                colors = TextFieldDefaults.colors(
                    focusedContainerColor = Teal200.copy(alpha = 0.2f),
                    unfocusedContainerColor = Teal200.copy(alpha = 0.1f)
                ),
                shape = RoundedCornerShape(8.dp)
            )

            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 8.dp),
                horizontalArrangement = Arrangement.Center
            ) {
                Chip(
                    onClick = { onUnitChange(selectedUnits) },
                    label = { Text("${selectedUnits.name} (${selectedUnits.fromUnit})") },
                    leading = {
                        Icon(
                            imageVector = ImageVectorBuilder(
                                name = "unit-icon",
                                defaultWidth = Dp(20f),
                                defaultHeight = Dp(20f),
                                viewportWidth = 20f,
                                viewportHeight = 20f
                            ).apply {
                                path(
                                    fill = SolidColor(MaterialTheme.colorScheme.primary),
                                    stroke = SolidColor(MaterialTheme.colorScheme.primary),
                                    strokeWidth = 1f
                                ) {
                                    moveTo(10f, 10f)
                                    lineTo(10f, 10f)
                                    // Simple placeholder icon - would be replaced with actual vector
                                }
                            },
                            contentDescription = null,
                            modifier = Modifier.size(24.dp)
                        )
                    },
                    shape = RoundedCornerShape(8.dp),
                    colors = ChipDefaults.chipColors(
                        containerColor = MaterialTheme.colorScheme.primaryContainer,
                        labelColor = MaterialTheme.colorScheme.onPrimaryContainer
                    )
                )

                Spacer(modifier = Modifier.width(8.dp))

                Text(
                    text = selectedUnits.emoji,
                    fontSize = 24.sp,
                    color = MaterialTheme.colorScheme.primary
                )
            }

            Button(
                onClick = onConvert,
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 16.dp),
                shape = RoundedCornerShape(8.dp),
                colors = ButtonDefaults.buttonColors(
                    containerColor = MaterialTheme.colorScheme.primary,
                    contentColor = MaterialTheme.colorScheme.onPrimary
                )
            ) {
                Text("Convert! 🚀")
            }

            Spacer(modifier = Modifier.height(16.dp))

            Column(
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = "Result:",
                    fontWeight = FontWeight.Bold,
                    color = MaterialTheme.colorScheme.secondary
                )

                Box(
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(vertical = 8.dp)
                ) {
                    AnimatedVisibility(
                        visible = animateResult.value > 0f,
                        enter = fadeIn() + expandVertically(),
                        exit = fadeOut() + shrinkVertically()
                    ) {
                        Text(
                            text = resultValue,
                            fontSize = 20.sp,
                            fontWeight = FontWeight.Bold,
                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                            textAlign = TextAlign.Center,
                            maxLines = 1,
                            overflow = TextOverflow.Ellipsis
                        )
                    }
                }

                Text(
                    text = "${selectedUnits.toUnit} (${selectedUnits.name})",
                    fontSize = 16.sp,
                    color = MaterialTheme.colorScheme.onSurface
                )
            }
        }
    }
}

@Preview(showBackground = true)
@Composable
fun UnitConverterPreview() {
    UnitConverterTheme {
        UnitConverterApp()
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Linq;

[RequireComponent(typeof(Button))]
public class InteractiveMenuItem : MonoBehaviour
{
    [SerializeField] private float pulseSpeed = 1.5f;
    [SerializeField] private float maxScale = 1.2f;
    [SerializeField] private float minScale = 0.9f;
    [SerializeField] private Color idleColor = Color.white;
    [SerializeField] private Color hoverColor = Color.cyan;
    [SerializeField] private Color activeColor = Color.magenta;
    [SerializeField] private ConfettiParticleSystem confettiPrefab;
    [SerializeField] private float confettiDuration = 2.5f;

    private Button button;
    private Image image;
    private float originalScale;
    private bool isActive;

    private void Awake()
    {
        button = GetComponent<Button>();
        image = GetComponent<Image>();

        if (image == null)
        {
            Debug.LogWarning("InteractiveMenuItem requires an Image component for visual effects");
            enabled = false;
            return;
        }

        originalScale = transform.localScale.x;
        button.onClick.AddListener(OnMenuItemSelected);
        button.onHover.AddListener(OnMenuItemHover);
        button.onHoverEnd.AddListener(OnMenuItemHoverEnd);
    }

    private void Update()
    {
        if (!isActive) return;

        // Pulsing animation
        float scaleFactor = Mathf.PingPong(Time.time * pulseSpeed, maxScale - minScale) + minScale;
        transform.localScale = new Vector3(scaleFactor, scaleFactor, 1);

        // Color cycling
        float colorTime = Time.time * pulseSpeed;
        image.color = Color.Lerp(activeColor, hoverColor, Mathf.Abs(Mathf.Sin(colorTime * 2f)));
    }

    private void OnMenuItemHover()
    {
        image.color = hoverColor;
    }

    private void OnMenuItemHoverEnd()
    {
        image.color = idleColor;
    }

    private void OnMenuItemSelected()
    {
        isActive = true;
        PlayConfettiEffect();

        // Optional: You could trigger other game events here
        // Debug.Log("Menu item selected: " + gameObject.name);
    }

    private void PlayConfettiEffect()
    {
        if (confettiPrefab != null)
        {
            // Create confetti at the center of the button's screen position
            Vector3 confettiPos = Camera.main.ScreenToWorldPoint(new Vector3(
                transform.position.x,
                transform.position.y,
                Camera.main.nearClipPlane + 0.1f
            ));

            var confetti = Instantiate(confettiPrefab, confettiPos, Quaternion.identity, transform);
            confetti.Play(confettiDuration);

            // Auto-destroy after animation completes
            Destroy(confetti.gameObject, confettiDuration + 0.1f);
        }
    }

    private void OnDestroy()
    {
        if (button != null)
        {
            button.onClick.RemoveListener(OnMenuItemSelected);
            button.onHover.RemoveListener(OnMenuItemHover);
            button.onHoverEnd.RemoveListener(OnMenuItemHoverEnd);
        }
    }
}

[RequireComponent(typeof(ParticleSystem))]
public class ConfettiParticleSystem : MonoBehaviour
{
    private ParticleSystem particleSystem;

    private void Awake()
    {
        particleSystem = GetComponent<ParticleSystem>();
    }

    public void Play(float duration)
    {
        if (particleSystem != null)
        {
            var emission = particleSystem.emission;
            emission.enabled = true;
            particleSystem.Play();
            particleSystem.main.duration = duration;
        }
    }

    public void Stop()
    {
        if (particleSystem != null)
        {
            var emission = particleSystem.emission;
            emission.enabled = false;
            particleSystem.Stop();
        }
    }
}