Systm

/**
 * Sistema de Router MVC Avanzado para PHP 8.2
 */
class Router {
    private array $routes = [];
    private ?string $notFoundHandler = null;
    
    public function addRoute(string $method, string $path, callable $handler): void {
        $this->routes[] = [
            'method' => strtoupper($method),
            'path' => $path,
            'handler' => $handler,
            'middleware' => []
        ];
    }
    
    public function get(string $path, callable $handler): self {
        $this->addRoute('GET', $path, $handler);
        return $this;
    }
    
    public function post(string $path, callable $handler): self {
        $this->addRoute('POST', $path, $handler);
        return $this;
    }
    
    public function middleware(callable $middleware): self {
        $lastRouteIndex = count($this->routes) - 1;
        if ($lastRouteIndex >= 0) {
            $this->routes[$lastRouteIndex]['middleware'][] = $middleware;
        }
        return $this;
    }
    
    public function setNotFound(callable $handler): void {
        $this->notFoundHandler = $handler;
    }
    
    public function run(): void {
        $requestMethod = $_SERVER['REQUEST_METHOD'];
        $requestPath = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
        
        foreach ($this->routes as $route) {
            // Match route using regex patterns
            $pattern = $this->convertRouteToRegex($route['path']);
            if ($route['method'] === $requestMethod && preg_match($pattern, $requestPath, $matches)) {
                array_shift($matches); // Remove full match
                
                // Apply middleware
                foreach ($route['middleware'] as $middleware) {
                    $result = $middleware();
                    if ($result === false) {
                        return;
                    }
                }
                
                // Execute handler with parameters
                call_user_func_array($route['handler'], $matches);
                return;
            }
        }
        
        // No route found
        if ($this->notFoundHandler) {
            call_user_func($this->notFoundHandler);
        } else {
            header("HTTP/1.0 404 Not Found");
            echo "404 Not Found";
        }
    }
    
    private function convertRouteToRegex(string $route): string {
        // Convert route params to regex capture groups
        return '#^' . preg_replace('#\{([a-zA-Z0-9_]+)\}#', '([^/]+)', $route) . '$#';
    }
}

namespace Systm\Plugin;

use pocketmine\plugin\PluginBase;
use pocketmine\event\Listener;
use pocketmine\event\player\PlayerJoinEvent;
use pocketmine\utils\TextFormat;

class WelcomePlugin extends PluginBase implements Listener {

    public function onEnable(): void {
        $this->getLogger()->info("WelcomePlugin has been enabled!");
        $this->getServer()->getPluginManager()->registerEvents($this, $this);
    }
    
    public function onDisable(): void {
        $this->getLogger()->info("WelcomePlugin has been disabled!");
    }

    public function onPlayerJoin(PlayerJoinEvent $event): void {
        $player = $event->getPlayer();
        $player->sendMessage(TextFormat::YELLOW . "¡Bienvenido, " . $player->getName() . "!");
        $player->sendTip("¡Espero que disfrutes tu estadía!");
    }
}

// Módulo de gestión de datos para Minecraft HCF
import { FactionAPI } from './api/factions.js';
import { EventEmitter } from './utils/events.js';

/**
 * Clase para administrar facciones de Minecraft HCF
 * Implementa patrón de diseño Observer
 */
export class FactionManager extends EventEmitter {
    #factions = new Map();
    #api = new FactionAPI();
    
    constructor() {
        super();
        this.#init();
    }
    
    async #init() {
        try {
            const factions = await this.#api.getAllFactions();
            factions.forEach(faction => {
                this.#factions.set(faction.id, faction);
            });
            this.emit('ready', Array.from(this.#factions.values()));
        } catch (error) {
            this.emit('error', error);
            console.error('Failed to initialize faction manager:', error);
        }
    }
    
    async createFaction({ name, owner, description }) {
        // Validación con destructuring y defaults
        const validatedName = name?.trim() || '';
        if (!validatedName || validatedName.length < 3) {
            throw new Error('Faction name must be at least 3 characters');
        }
        
        try {
            // Uso de async/await con operador de propagación
            const newFaction = await this.#api.createFaction({
                name: validatedName,
                owner,
                description,
                members: [owner],
                created: Date.now()
            });
            
            // Almacenamiento local y notificación
            this.#factions.set(newFaction.id, newFaction);
            this.emit('factionCreated', newFaction);
            return newFaction;
        } catch (error) {
            this.emit('error', error);
            throw error;
        }
    }
    
    // Implementación del patrón Iterator
    [Symbol.iterator]() {
        const factions = Array.from(this.#factions.values());
        let index = 0;
        
        return {
            next() {
                return {
                    value: factions[index++],
                    done: index > factions.length
                };
            }
        };
    }
}

/* Sistema de layouts de CSS Grid avanzado para panel de servidor */
.minecraft-dashboard {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  grid-template-rows: auto auto 1fr auto;
  grid-gap: 1rem;
  height: 100vh;
  
  --primary: #00c853;
  --secondary: #b71c1c;
  --background: #212121;
  --text: #f5f5f5;
}

.dashboard-header {
  grid-column: 1 / -1;
  grid-row: 1 / 2;
  background-color: var(--background);
  border-bottom: 3px solid var(--primary);
  padding: 1rem;
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.dashboard-sidebar {
  grid-column: 1 / 3;
  grid-row: 2 / 4;
  background-color: rgba(0, 0, 0, 0.3);
  transition: transform 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275);
}

.dashboard-main {
  grid-column: 3 / -1;
  grid-row: 2 / 4;
  background-color: var(--background);
  overflow-y: auto;
  position: relative;
}

.dashboard-footer {
  grid-column: 1 / -1;
  grid-row: 4 / 5;
  background-color: var(--background);
  padding: 1rem;
  text-align: center;
}

/* Animaciones CSS avanzadas */
.server-card {
  position: relative;
  overflow: hidden;
  border-radius: 8px;
  background: linear-gradient(135deg, #2c3e50, #1a1a2e);
  box-shadow: 0 10px 20px rgba(0, 0, 0, 0.2);
}

.server-card::before {
  content: "";
  position: absolute;
  top: -50%;
  left: -50%;
  width: 200%;
  height: 200%;
  background: conic-gradient(
    transparent, 
    transparent, 
    transparent, 
    var(--primary)
  );
  animation: server-rotate 4s linear infinite;
  z-index: -1;
}

.server-card::after {
  content: "";
  position: absolute;
  inset: 3px;
  background: var(--background);
  border-radius: 5px;
  z-index: -1;
}

@keyframes server-rotate {
  from {
    transform: rotate(0deg);
  }
  to {
    transform: rotate(360deg);
  }
}

/* Animación del status del servidor */
.status-indicator {
  --status-color: var(--primary);
  position: relative;
  width: 15px;
  height: 15px;
  border-radius: 50%;
  background-color: var(--status-color);
}

.status-indicator::before {
  content: "";
  position: absolute;
  inset: -5px;
  border-radius: 50%;
  background-color: transparent;
  border: 2px solid var(--status-color);
  opacity: 0;
  animation: pulse 2s cubic-bezier(0.455, 0.03, 0.515, 0.955) infinite;
}

@keyframes pulse {
  0% {
    transform: scale(0.5);
    opacity: 0;
  }
  50% {
    opacity: 0.5;
  }
  100% {
    transform: scale(1.5);
    opacity: 0;
  }
}

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace MinecraftHCF.Core.Data
{
    // Modelos para sistema de facciones de Minecraft HCF
    public class Faction
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public DateTime CreatedDate { get; set; }
        public double Power { get; set; }
        public double MaxPower { get; set; }
        public string HomeLocation { get; set; }
        public bool IsRaidable => Power <= 0;

        // Relaciones
        public virtual ICollection Members { get; set; }
        public virtual ICollection Claims { get; set; }
        public virtual ICollection Relations { get; set; }
    }

    public class Player
    {
        public Guid Id { get; set; }
        public string Username { get; set; }
        public Guid? FactionId { get; set; }
        public string Rank { get; set; }
        public double Power { get; set; }
        public double MaxPower { get; set; }
        public DateTime LastOnline { get; set; }
        public bool IsOnline { get; set; }

        // Relaciones
        public virtual Faction Faction { get; set; }
        public virtual ICollection Statistics { get; set; }
    }

    public class HCFContext : DbContext
    {
        public DbSet Factions { get; set; }
        public DbSet Players { get; set; }
        public DbSet Claims { get; set; }
        
        public HCFContext(DbContextOptions options) 
            : base(options) { }
            
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // Configuración de relaciones y restricciones
            modelBuilder.Entity()
                .HasIndex(f => f.Name)
                .IsUnique();
                
            modelBuilder.Entity()
                .HasOne(p => p.Faction)
                .WithMany(f => f.Members)
                .HasForeignKey(p => p.FactionId)
                .OnDelete(DeleteBehavior.SetNull);
        }
    }

    // Servicio de facciones con consultas LINQ avanzadas
    public class FactionService
    {
        private readonly HCFContext _context;
        
        public FactionService(HCFContext context)
        {
            _context = context;
        }
        
        // Consultas LINQ avanzadas
        public async Task> GetTopFactionsByPowerAsync(int count = 10)
        {
            return await _context.Factions
                .OrderByDescending(f => f.Power)
                .Take(count)
                .Include(f => f.Members)
                .AsNoTracking()
                .ToListAsync();
        }
        
        public async Task> GetFactionMembersOrderedByRankAsync(Guid factionId)
        {
            // Uso de expresiones LINQ con agrupación y ordenamiento
            var rankOrder = new Dictionary {
                { "leader", 0 },
                { "coleader", 1 },
                { "officer", 2 },
                { "member", 3 }
            };
            
            return await _context.Players
                .Where(p => p.FactionId == factionId)
                .OrderBy(p => rankOrder.TryGetValue(p.Rank.ToLower(), out var order) 
                    ? order : int.MaxValue)
                .ThenBy(p => p.Username)
                .ToListAsync();
        }
        
        // Transacción para proceso de invasión de territorio
        public async Task TryClaimTerritory(
            Guid factionId, 
            string worldName, 
            int chunkX, 
            int chunkZ)
        {
            using var transaction = await _context.Database.BeginTransactionAsync();
            
            try
            {
                // Verificar si el chunk ya está reclamado
                var existingClaim = await _context.Claims
                    .FirstOrDefaultAsync(c => 
                        c.WorldName == worldName && 
                        c.ChunkX == chunkX && 
                        c.ChunkZ == chunkZ);
                        
                if (existingClaim != null)
                    return false;
                    
                // Verificar si la facción tiene suficiente poder
                var faction = await _context.Factions
                    .Include(f => f.Claims)
                    .FirstOrDefaultAsync(f => f.Id == factionId);
                    
                if (faction == null || faction.Claims.Count >= faction.Power / 10)
                    return false;
                
                // Crear la nueva reclamación
                var claim = new Claim
                {
                    Id = Guid.NewGuid(),
                    FactionId = factionId,
                    WorldName = worldName,
                    ChunkX = chunkX,
                    ChunkZ = chunkZ,
                    ClaimedDate = DateTime.UtcNow
                };
                
                _context.Claims.Add(claim);
                await _context.SaveChangesAsync();
                await transaction.CommitAsync();
                
                return true;
            }
            catch (Exception)
            {
                await transaction.RollbackAsync();
                return false;
            }
        }
    }
}