A!leys Galerie

import SwiftUI
import CoreData
import Combine

// MARK: - CoreData Stack
class PersistenceController {
    static let shared = PersistenceController()
    let container: NSPersistentContainer

    init() {
        container = NSPersistentContainer(name: "NeonNotes")
        container.loadPersistentStores { _, error in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        }
    }
}

// MARK: - Model
@objc(Note)
public class Note: NSManagedObject {
    @NSManaged public var id: UUID?
    @NSManaged public var title: String?
    @NSManaged public var content: String?
    @NSManaged public var timestamp: Date?
}

// MARK: - Views
struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Note.timestamp, ascending: false)],
        animation: .default
    ) private var notes: FetchedResults<Note>

    @State private var showingAddSheet = false

    var body: some View {
        NavigationView {
            ZStack {
                Color.black.ignoresSafeArea()
                
                List {
                    ForEach(notes) { note in
                        NoteRow(note: note)
                    }
                    .onDelete(perform: deleteNotes)
                }
                .listStyle(PlainListStyle())
                .scrollContentBackground(.hidden)
                .background(Color.black)
                
                VStack {
                    Spacer()
                    Button(action: { showingAddSheet = true }) {
                        Image(systemName: "plus")
                            .font(.title)
                            .foregroundColor(.cyan)
                            .padding()
                            .background(Circle().fill(Color.black))
                            .overlay(Circle().stroke(Color.cyan, lineWidth: 2))
                    }
                    .padding()
                }
            }
            .navigationTitle("NeonNotes")
            .toolbar {
                EditButton()
            }
            .sheet(isPresented: $showingAddSheet) {
                AddNoteView()
            }
        }
        .preferredColorScheme(.dark)
    }

    private func deleteNotes(offsets: IndexSet) {
        withAnimation {
            offsets.map { notes[$0] }.forEach(viewContext.delete)
            try? viewContext.save()
        }
    }
}

struct NoteRow: View {
    let note: Note

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(note.title ?? "Untitled")
                .font(.headline)
                .foregroundColor(.cyan)
            Text(note.content ?? "")
                .font(.subheadline)
                .foregroundColor(.white)
                .lineLimit(2)
        }
        .padding()
        .background(Color.white.opacity(0.05))
        .cornerRadius(12)
        .overlay(
            RoundedRectangle(cornerRadius: 12)
                .stroke(Color.magenta, lineWidth: 1)
        )
    }
}

struct AddNoteView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @Environment(\.dismiss) private var dismiss
    @State private var title = ""
    @State private var content = ""

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("Title")) {
                    TextField("Title", text: $title)
                }
                Section(header: Text("Content")) {
                    TextEditor(text: $content)
                        .frame(minHeight: 200)
                }
            }
            .navigationTitle("New Note")
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("Save") {
                        let newNote = Note(context: viewContext)
                        newNote.id = UUID()
                        newNote.title = title
                        newNote.content = content
                        newNote.timestamp = Date()
                        try? viewContext.save()
                        dismiss()
                    }
                    .foregroundColor(.cyan)
                }
                ToolbarItem(placement: .cancellationAction) {
                    Button("Cancel") { dismiss() }
                }
            }
        }
    }
}

// MARK: - Preview
struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
            .preferredColorScheme(.dark)
    }
}

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>MeshFlow - Gradient Mesh Generator</title>
    <style>
        :root {
            --bg: #0a0a0a;
            --accent: #00f2ff;
            --text: #e0e0e0;
        }

        body {
            margin: 0;
            padding: 0;
            background: var(--bg);
            color: var(--text);
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            overflow: hidden;
            display: flex;
            flex-direction: column;
            height: 100vh;
        }

        header {
            padding: 20px;
            display: flex;
            justify-content: space-between;
            align-items: center;
            background: rgba(255, 255, 255, 0.05);
            backdrop-filter: blur(10px);
            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
        }

        h1 {
            margin: 0;
            font-size: 1.5rem;
            letter-spacing: 2px;
            text-transform: uppercase;
        }

        .controls {
            display: flex;
            gap: 20px;
            align-items: center;
        }

        button {
            background: transparent;
            border: 1px solid var(--accent);
            color: var(--accent);
            padding: 8px 16px;
            border-radius: 4px;
            cursor: pointer;
            transition: all 0.3s;
        }

        button:hover {
            background: var(--accent);
            color: var(--bg);
        }

        canvas {
            flex-grow: 1;
            cursor: crosshair;
        }

        .info {
            position: absolute;
            bottom: 20px;
            left: 20px;
            font-size: 0.8rem;
            opacity: 0.7;
        }
    </style>
</head>
<body>
    <header>
        <h1>MeshFlow</h1>
        <div class="controls">
            <button id="randomize">Randomize</button>
            <button id="save">Save PNG</button>
        </div>
    </header>
    <canvas id="meshCanvas"></canvas>
    <div class="info">Drag points to deform the mesh. Click to add new points.</div>

    <script>
        const canvas = document.getElementById('meshCanvas');
        const ctx = canvas.getContext('2d');
        const randomizeBtn = document.getElementById('randomize');
        const saveBtn = document.getElementById('save');

        let points = [];
        let isDragging = false;
        let draggedPoint = null;

        function init() {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight - 80;
            
            points = [];
            const rows = 6;
            const cols = 8;
            const spacingX = canvas.width / (cols - 1);
            const spacingY = canvas.height / (rows - 1);

            for (let i = 0; i < rows; i++) {
                for (let j = 0; j < cols; j++) {
                    points.push({
                        x: j * spacingX,
                        y: i * spacingY,
                        color: `hsl(${Math.random() * 360}, 70%, 60%)`
                    });
                }
            }
            draw();
        }

        function draw() {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // Draw mesh
            ctx.beginPath();
            ctx.moveTo(points[0].x, points[0].y);
            for (let i = 1; i < points.length; i++) {
                ctx.lineTo(points[i].x, points[i].y);
            }
            ctx.stroke();

            // Draw points
            points.forEach(p => {
                ctx.beginPath();
                ctx.arc(p.x, p.y, 5, 0, Math.PI * 2);
                ctx.fillStyle = p.color;
                ctx.fill();
            });
        }

        canvas.addEventListener('mousedown', (e) => {
            const rect = canvas.getBoundingClientRect();
            const x = e.clientX - rect.left;
            const y = e.clientY - rect.top;

            let closest = null;
            let minDist = Infinity;

            points.forEach(p => {
                const dist = Math.sqrt((p.x - x) ** 2 + (p.y - y) ** 2);
                if (dist < minDist) {
                    minDist = dist;
                    closest = p;
                }
            });

            if (minDist < 20) {
                draggedPoint = closest;
                isDragging = true;
            } else {
                points.push({
                    x,
                    y,
                    color: `hsl(${Math.random() * 360}, 70%, 60%)`
                });
                draw();
            }
        });

        window.addEventListener('mousemove', (e) => {
            if (isDragging && draggedPoint) {
                const rect = canvas.getBoundingClientRect();
                draggedPoint.x = e.clientX - rect.left;
                draggedPoint.y = e.clientY - rect.top;
                draw();
            }
        });

        window.addEventListener('mouseup', () => {
            isDragging = false;
            draggedPoint = null;
        });

        randomizeBtn.addEventListener('click', () => {
            points.forEach(p => {
                p.x = Math.random() * canvas.width;
                p.y = Math.random() * canvas.height;
                p.color = `hsl(${Math.random() * 360}, 70%, 60%)`;
            });
            draw();
        });

        saveBtn.addEventListener('click', () => {
            const link = document.createElement('a');
            link.download = 'meshflow-gradient.png';
            link.href = canvas.toDataURL();
            link.click();
        });

        window.addEventListener('resize', init);
        init();
    </script>
</body>
</html>

import random
import time
import sys
from typing import List, Dict, Optional

class GameState:
    def __init__(self):
        self.current_room = "Start"
        self.inventory = []
        self.glitch_level = 0
        self.game_over = False
        self.score = 0

    def update_glitch(self):
        self.glitch_level += random.randint(1, 3)
        if self.glitch_level > 10:
            self.glitch_level = 0
            print("\n[SYSTEM] Glitch reset.")

class Room:
    def __init__(self, name: str, description: str, exits: Dict[str, str]):
        self.name = name
        self.description = description
        self.exits = exits

class GameEngine:
    def __init__(self):
        self.rooms = {
            "Start": Room("Start", "Ein dunkler Flur mit flackernden Lichtern.", {"nord": "Flur", "ost": "Zimmer"}),
            "Flur": Room("Flur", "Ein langer Flur mit rotem Teppich.", {"süd": "Start", "west": "Zimmer", "nord": "Treppe"}),
            "Zimmer": Room("Zimmer", "Ein kleines Zimmer mit einem alten Schreibtisch.", {"west": "Flur", "ost": "Treppe"}),
            "Treppe": Room("Treppe", "Eine steile Treppe nach oben.", {"süd": "Flur", "nord": "Dach"}),
            "Dach": Room("Dach", "Ein Dach mit Blick auf die Stadt.", {"süd": "Treppe"})
        }
        self.state = GameState()
        self.running = True

    def display_room(self):
        room = self.rooms[self.state.current_room]
        print(f"\n--- {room.name} ---")
        print(room.description)
        if self.state.glitch_level > 5:
            print("... die Wände flackern ...")
        print(f"Ausgänge: {', '.join(room.exits.keys())}")
        print(f"Inventar: {self.state.inventory}")
        print(f"Glitch-Level: {self.state.glitch_level}")

    def handle_input(self, command: str):
        parts = command.lower().split()
        if not parts:
            return

        action = parts[0]
        if action == "gehe":
            if len(parts) > 1:
                direction = parts[1]
                if direction in self.rooms[self.state.current_room].exits:
                    self.state.current_room = self.rooms[self.state.current_room].exits[direction]
                    self.display_room()
                else:
                    print("Kein Ausgang in diese Richtung.")
            else:
                print("Wohin willst du gehen?")
        elif action == "nimm":
            if len(parts) > 1:
                item = parts[1]
                # In diesem Beispiel gibt es keine Items in den Räumen, 
                # aber die Logik bleibt für Erweiterungen erhalten.
                print(f"Du versuchst {item} zu nehmen.")
            else:
                print("Was willst du nehmen?")
        elif action == "glitch":
            self.state.update_glitch()
            print("Du hast den Glitch-Modus aktiviert.")
        elif action == "beende":
            self.running = False
            print("Spiel beendet.")
        else:
            print("Unbekannter Befehl.")

    def run(self):
        print("Willkommen in Glitch-Quest!")
        print("Befehle: gehe [richtung], nimm [item], glitch, beende")
        self.display_room()
        while self.running:
            command = input("\n> ")
            self.handle_input(command)

if __name__ == "__main__":
    game = GameEngine()
    game.run()