A!leys Galerie

import android.content.Context
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.Color
import android.graphics.Paint
import android.graphics.Path
import android.graphics.RectF
import android.graphics.Typeface
import android.graphics.drawable.BitmapDrawable
import android.graphics.pdf.PdfDocument
import android.graphics.pdf.PageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfRenderer
import android.graphics.pdf.PdfWriter
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.PdfPageInfo
import android.graphics.pdf.PdfPage
import android.graphics.pdf.P

use rand::{Rng, thread_rng};
use std::io::{self, Write};
use std::time::Instant;

// --- Konstanten ---
const MIN_LENGTH: usize = 8;
const MAX_LENGTH: usize = 64;
const CHAR_SET: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+=-{}[]|\\:;\"'<>,.?/";

// --- Datenstrukturen ---
struct PasswordStrength {
    entropy: f64,
    score: u8,
    description: String,
}

// --- Funktionen ---

/// Berechnet die Entropie eines Passworts basierend auf der Länge und der Größe des Zeichensatzes.
/// Formel: E = L * log2(N)
fn calculate_entropy(password: &str) -> f64 {
    let n = CHAR_SET.len() as f64;
    let l = password.len() as f64;
    l * n.log2()
}

/// Bewertet die Stärke eines Passworts basierend auf Entropie und Länge.
fn evaluate_strength(password: &str) -> PasswordStrength {
    let entropy = calculate_entropy(password);
    let score = if entropy < 40.0 {
        1
    } else if entropy < 60.0 {
        2
    } else if entropy < 80.0 {
        3
    } else {
        4
    };

    let description = match score {
        1 => "Schwach - leicht zu knacken.",
        2 => "Mittel - brauchst du für weniger kritische Dinge.",
        3 => "Stark - gut für die meisten Konten.",
        4 => "Sehr stark - fast unknackbar.",
        _ => "Unbekannt.",
    };

    PasswordStrength {
        entropy,
        score,
        description: description.to_string(),
    }
}

/// Generiert ein zufälliges Passwort.
fn generate_password(length: usize) -> String {
    let mut rng = thread_rng();
    let mut password = String::with_capacity(length);
    for _ in 0..length {
        let idx = rng.gen_range(0..CHAR_SET.len());
        password.push(CHAR_SET.chars().nth(idx).unwrap());
    }
    password
}

/// Zeigt eine kleine ASCII-Animation als "Sound-Feedback".
fn play_feedback(score: u8) {
    let frames = [
        " [ ] ",
        " [###] ",
        " [###] ",
        " [ ] ",
    ];
    for i in 0..4 {
        print!("\r{}", frames[i]);
        std::io::Write::flush(&mut io::stdout()).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    println!("\n");
}

// --- Main ---

fn main() {
    println!("--- PassGen Entropy Analyzer ---");
    println!("Generiere ein sicheres Passwort (8-64 Zeichen):");

    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Fehler beim Lesen");
    let length: usize = input.trim().parse().unwrap_or(16);

    if length < MIN_LENGTH || length > MAX_LENGTH {
        println!("Bitte gib eine Länge zwischen {} und {} ein.", MIN_LENGTH, MAX_LENGTH);
        return;
    }

    let start = Instant::now();
    let password = generate_password(length);
    let duration = start.elapsed();

    let strength = evaluate_strength(&password);

    println!("Generiertes Passwort: {}", password);
    println!("Entropie: {:.2} bits", strength.entropy);
    println!("Bewertung: {}/4 - {}", strength.score, strength.description);
    println!("Generiert in: {:?}", duration);

    play_feedback(strength.score);
}

using UnityEngine;
using System.Collections.Generic;

public class FoggyMinimap : MonoBehaviour
{
    [Header("Minimap Settings")]
    [SerializeField] private Transform playerTransform;
    [SerializeField] private float viewDistance = 10f;
    [SerializeField] private float mapScale = 0.1f;
    [SerializeField] private Color fogColor = Color.black;
    [SerializeField] private Color revealedColor = Color.white;

    [Header("Grid Settings")]
    [SerializeField] private int gridWidth = 20;
    [SerializeField] private int gridHeight = 20;
    [SerializeField] private float cellSize = 1f;

    private Texture2D minimapTexture;
    private Color[] mapData;
    private Vector2 lastPlayerPosition;

    void Start()
    {
        InitializeMinimap();
    }

    void InitializeMinimap()
    {
        minimapTexture = new Texture2D(gridWidth, gridHeight);
        mapData = new Color[gridWidth * gridHeight];

        for (int i = 0; i < mapData.Length; i++)
        {
            mapData[i] = fogColor;
        }

        UpdateMinimap();
    }

    void Update()
    {
        if (playerTransform != null)
        {
            UpdateMinimap();
        }
    }

    void UpdateMinimap()
    {
        Vector3 currentPosition = playerTransform.position;
        Vector3 direction = currentPosition - lastPlayerPosition;

        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                Vector3 cellPosition = new Vector3(x * cellSize, y * cellSize, 0);
                float distance = Vector3.Distance(currentPosition, cellPosition);

                if (distance < viewDistance)
                {
                    mapData[x + y * gridWidth] = revealedColor;
                }
            }
        }

        minimapTexture.SetPixels(mapData);
        minimapTexture.Apply();
        lastPlayerPosition = currentPosition;
    }

    void OnDestroy()
    {
        if (minimapTexture != null)
        {
            Destroy(minimapTexture);
        }
    }
}