mario_mmo.py

#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║                    SUPER MARIO RPG: ONLINE ADVENTURES                        ║
║                        Samsoft Play! Network Edition                         ║
║══════════════════════════════════════════════════════════════════════════════║
║  ROM Support: Super Mario RPG (.sfc/.smc) - All Regions (NTSC/PAL/JP)       ║
║  Network: P2P with Samsoft Play! (DS Download Play Style)                    ║
║  Test Map: Bowser's Castle + Chat Window                                     ║
╚══════════════════════════════════════════════════════════════════════════════╝
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
import socket
import threading
import json
import hashlib
import struct
import time
import random
import os
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple, Callable
from enum import Enum, auto
import zlib

# ═══════════════════════════════════════════════════════════════════════════════
# SNES ROM LOADER - Super Mario RPG Support (All Regions)
# ═══════════════════════════════════════════════════════════════════════════════

class ROMRegion(Enum):
    NTSC_US = "NTSC-U"
    NTSC_JP = "NTSC-J"
    PAL_EU = "PAL"
    UNKNOWN = "Unknown"

@dataclass
class SNESHeader:
    """SNES ROM Header structure"""
    title: str = ""
    rom_makeup: int = 0
    rom_type: int = 0
    rom_size: int = 0
    sram_size: int = 0
    country_code: int = 0
    license_code: int = 0
    version: int = 0
    checksum_complement: int = 0
    checksum: int = 0
    region: ROMRegion = ROMRegion.UNKNOWN
    is_hirom: bool = False
    has_header: bool = False

class SuperMarioRPGLoader:
    """
    Loads Super Mario RPG ROM files (.sfc/.smc)
    Supports all regions: NTSC-U, NTSC-J, PAL
    """
    
    # Known Super Mario RPG checksums for validation
    KNOWN_CHECKSUMS = {
        "d0b68d68d9efc0558242f5f642c6075d": ("NTSC-U", "Super Mario RPG (USA)"),
        "85cee55c5f7b6a36b8ed4f0f4c2cfeee": ("NTSC-J", "Super Mario RPG (Japan)"),
        "e1b19f7a6c5a5a5e5c1d4b8a9f8e7d6c": ("PAL", "Super Mario RPG (Europe)"),
    }
    
    # Header locations
    LOROM_HEADER = 0x7FC0
    HIROM_HEADER = 0xFFC0
    COPIER_HEADER_SIZE = 512
    
    def __init__(self):
        self.rom_data: bytes = b""
        self.header: SNESHeader = SNESHeader()
        self.assets: Dict[str, bytes] = {}
        self.maps: Dict[int, dict] = {}
        self.sprites: Dict[str, bytes] = {}
        self.loaded = False
        
    def load_rom(self, filepath: str) -> bool:
        """Load and parse a Super Mario RPG ROM file"""
        if not os.path.exists(filepath):
            raise FileNotFoundError(f"ROM file not found: {filepath}")
            
        ext = os.path.splitext(filepath)[1].lower()
        if ext not in ['.sfc', '.smc']:
            raise ValueError(f"Invalid ROM extension: {ext}. Expected .sfc or .smc")
        
        with open(filepath, 'rb') as f:
            self.rom_data = f.read()
        
        # Detect and remove copier header if present
        self._detect_copier_header()
        
        # Parse SNES header
        self._parse_header()
        
        # Validate checksum
        if not self._validate_checksum():
            print("Warning: ROM checksum mismatch - ROM may be modified")
        
        # Extract game assets for MMO use
        self._extract_assets()
        
        self.loaded = True
        return True
    
    def _detect_copier_header(self):
        """Detect and handle copier headers (512 bytes)"""
        rom_size = len(self.rom_data)
        
        # Check if ROM size suggests copier header
        if rom_size % 1024 == 512:
            self.header.has_header = True
            self.rom_data = self.rom_data[self.COPIER_HEADER_SIZE:]
            print("Copier header detected and removed")
    
    def _parse_header(self):
        """Parse SNES internal ROM header"""
        # Try LoROM first, then HiROM
        for offset, is_hirom in [(self.LOROM_HEADER, False), (self.HIROM_HEADER, True)]:
            if offset + 32 > len(self.rom_data):
                continue
                
            header_data = self.rom_data[offset:offset + 32]
            
            # Validate header by checking ROM makeup byte
            rom_makeup = header_data[21]
            if self._is_valid_makeup(rom_makeup, is_hirom):
                self._extract_header_info(header_data, is_hirom)
                return
        
        # Fallback: assume LoROM
        if len(self.rom_data) > self.LOROM_HEADER + 32:
            header_data = self.rom_data[self.LOROM_HEADER:self.LOROM_HEADER + 32]
            self._extract_header_info(header_data, False)
    
    def _is_valid_makeup(self, makeup: int, is_hirom: bool) -> bool:
        """Validate ROM makeup byte"""
        if is_hirom:
            return makeup in [0x21, 0x31, 0x35, 0x3A]
        return makeup in [0x20, 0x30, 0x32, 0x23]
    
    def _extract_header_info(self, header_data: bytes, is_hirom: bool):
        """Extract header information"""
        self.header.is_hirom = is_hirom
        
        # Title (21 bytes, ASCII)
        self.header.title = header_data[0:21].decode('ascii', errors='replace').strip()
        
        # ROM specifications
        self.header.rom_makeup = header_data[21]
        self.header.rom_type = header_data[22]
        self.header.rom_size = 1024 << header_data[23]  # In bytes
        self.header.sram_size = 1024 << header_data[24] if header_data[24] > 0 else 0
        
        # Region info
        self.header.country_code = header_data[25]
        self.header.license_code = header_data[26]
        self.header.version = header_data[27]
        
        # Checksums
        self.header.checksum_complement = struct.unpack('<H', header_data[28:30])[0]
        self.header.checksum = struct.unpack('<H', header_data[30:32])[0]
        
        # Determine region
        self.header.region = self._determine_region()
    
    def _determine_region(self) -> ROMRegion:
        """Determine ROM region from country code"""
        country = self.header.country_code
        if country == 0x00:
            return ROMRegion.NTSC_JP
        elif country == 0x01:
            return ROMRegion.NTSC_US
        elif country in [0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0A, 0x0B, 0x0C]:
            return ROMRegion.PAL_EU
        return ROMRegion.UNKNOWN
    
    def _validate_checksum(self) -> bool:
        """Validate ROM internal checksum"""
        if len(self.rom_data) < 0x10000:
            return False
            
        # Calculate checksum (sum of all bytes mod 0x10000)
        calculated = sum(self.rom_data) & 0xFFFF
        expected = self.header.checksum
        
        return calculated == expected or (calculated + self.header.checksum_complement) == 0xFFFF
    
    def _extract_assets(self):
        """Extract game assets for MMO usage"""
        # Extract tileset data
        self._extract_tilesets()
        
        # Extract sprite data
        self._extract_sprites()
        
        # Extract map data
        self._extract_maps()
        
        # Extract palette data
        self._extract_palettes()
    
    def _extract_tilesets(self):
        """Extract tileset graphics"""
        # Super Mario RPG uses compressed graphics
        # These are approximate offsets - actual ROM has compression
        tileset_regions = [
            (0x100000, 0x120000, "overworld"),
            (0x120000, 0x140000, "dungeon"),
            (0x140000, 0x160000, "castle"),
            (0x160000, 0x180000, "battle"),
        ]
        
        for start, end, name in tileset_regions:
            if end <= len(self.rom_data):
                self.assets[f"tileset_{name}"] = self.rom_data[start:end]
    
    def _extract_sprites(self):
        """Extract character sprite data"""
        sprite_offsets = {
            "mario": (0x180000, 0x190000),
            "mallow": (0x190000, 0x1A0000),
            "geno": (0x1A0000, 0x1B0000),
            "bowser": (0x1B0000, 0x1C0000),
            "peach": (0x1C0000, 0x1D0000),
        }
        
        for name, (start, end) in sprite_offsets.items():
            if end <= len(self.rom_data):
                self.sprites[name] = self.rom_data[start:end]
    
    def _extract_maps(self):
        """Extract map/level data"""
        # Map data table offset (approximate for SMRPG)
        map_table_offset = 0x1E0000
        
        if map_table_offset + 0x1000 <= len(self.rom_data):
            map_count = min(200, (len(self.rom_data) - map_table_offset) // 0x100)
            
            for i in range(map_count):
                offset = map_table_offset + (i * 0x100)
                self.maps[i] = {
                    "data": self.rom_data[offset:offset + 0x100],
                    "id": i
                }
    
    def _extract_palettes(self):
        """Extract color palette data"""
        palette_offset = 0x200000
        
        if palette_offset + 0x2000 <= len(self.rom_data):
            self.assets["palettes"] = self.rom_data[palette_offset:palette_offset + 0x2000]
    
    def get_rom_info(self) -> dict:
        """Get ROM information dictionary"""
        return {
            "title": self.header.title,
            "region": self.header.region.value,
            "rom_size": f"{len(self.rom_data) / 1024 / 1024:.2f} MB",
            "sram_size": f"{self.header.sram_size / 1024:.0f} KB" if self.header.sram_size > 0 else "None",
            "version": f"1.{self.header.version}",
            "hirom": self.header.is_hirom,
            "checksum": f"0x{self.header.checksum:04X}",
            "maps_loaded": len(self.maps),
            "sprites_loaded": len(self.sprites),
        }

# ═══════════════════════════════════════════════════════════════════════════════
# SAMSOFT PLAY! NETWORK PROTOCOL - DS Download Play Style P2P
# ═══════════════════════════════════════════════════════════════════════════════

class PacketType(Enum):
    DISCOVERY = 0x01
    DISCOVERY_RESPONSE = 0x02
    JOIN_REQUEST = 0x03
    JOIN_ACCEPT = 0x04
    JOIN_DENY = 0x05
    PLAYER_UPDATE = 0x10
    PLAYER_POSITION = 0x11
    PLAYER_ACTION = 0x12
    CHAT_MESSAGE = 0x20
    ROOM_STATE = 0x30
    SYNC_REQUEST = 0x40
    SYNC_DATA = 0x41
    PING = 0xF0
    PONG = 0xF1
    DISCONNECT = 0xFF

@dataclass
class NetworkPlayer:
    """Represents a connected player"""
    player_id: str
    username: str
    address: Tuple[str, int]
    x: float = 400.0
    y: float = 300.0
    sprite_state: str = "idle"
    character: str = "mario"
    last_seen: float = field(default_factory=time.time)
    latency: int = 0

@dataclass 
class SamsoftPacket:
    """Samsoft Play! network packet structure"""
    magic: bytes = b'SMSP'  # Samsoft Play magic bytes
    version: int = 1
    packet_type: PacketType = PacketType.PING
    player_id: str = ""
    payload: bytes = b""
    timestamp: float = field(default_factory=time.time)
    
    def serialize(self) -> bytes:
        """Serialize packet for network transmission"""
        payload_data = self.payload if isinstance(self.payload, bytes) else json.dumps(self.payload).encode()
        
        header = struct.pack(
            '<4sBB32sI',
            self.magic,
            self.version,
            self.packet_type.value,
            self.player_id.encode().ljust(32, b'\x00'),
            len(payload_data)
        )
        
        return header + payload_data
    
    @classmethod
    def deserialize(cls, data: bytes) -> 'SamsoftPacket':
        """Deserialize packet from network data"""
        if len(data) < 42:
            raise ValueError("Packet too small")
            
        magic, version, ptype, player_id_bytes, payload_len = struct.unpack(
            '<4sBB32sI', data[:42]
        )
        
        if magic != b'SMSP':
            raise ValueError("Invalid packet magic")
        
        payload = data[42:42 + payload_len]
        
        return cls(
            magic=magic,
            version=version,
            packet_type=PacketType(ptype),
            player_id=player_id_bytes.rstrip(b'\x00').decode(),
            payload=payload
        )

class SamsoftPlayNetwork:
    """
    Samsoft Play! P2P Network System
    DS Download Play style connection and discovery
    """
    
    DISCOVERY_PORT = 31337
    GAME_PORT = 31338
    BROADCAST_INTERVAL = 2.0
    TIMEOUT = 10.0
    
    def __init__(self, username: str):
        self.username = username
        self.player_id = hashlib.md5(f"{username}{time.time()}".encode()).hexdigest()[:16]
        self.players: Dict[str, NetworkPlayer] = {}
        self.is_host = False
        self.room_code = ""
        self.running = False
        
        # Sockets
        self.discovery_socket: Optional[socket.socket] = None
        self.game_socket: Optional[socket.socket] = None
        
        # Callbacks
        self.on_player_join: Optional[Callable] = None
        self.on_player_leave: Optional[Callable] = None
        self.on_player_update: Optional[Callable] = None
        self.on_chat_message: Optional[Callable] = None
        self.on_room_discovered: Optional[Callable] = None
        
        # Threading
        self.threads: List[threading.Thread] = []
        self._lock = threading.Lock()
    
    def generate_room_code(self) -> str:
        """Generate DS Download Play style room code"""
        chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
        return ''.join(random.choice(chars) for _ in range(6))
    
    def start_host(self) -> str:
        """Start hosting a room (DS Download Play host)"""
        self.is_host = True
        self.room_code = self.generate_room_code()
        self.running = True
        
        # Setup discovery socket (broadcast)
        self.discovery_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        self.discovery_socket.bind(('', self.DISCOVERY_PORT))
        
        # Setup game socket
        self.game_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.game_socket.bind(('', self.GAME_PORT))
        
        # Start threads
        discovery_thread = threading.Thread(target=self._discovery_listener, daemon=True)
        game_thread = threading.Thread(target=self._game_listener, daemon=True)
        broadcast_thread = threading.Thread(target=self._broadcast_room, daemon=True)
        
        self.threads = [discovery_thread, game_thread, broadcast_thread]
        for t in self.threads:
            t.start()
        
        return self.room_code
    
    def start_client(self):
        """Start as client (searching for rooms)"""
        self.is_host = False
        self.running = True
        
        # Setup discovery socket
        self.discovery_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        self.discovery_socket.settimeout(1.0)
        
        # Setup game socket
        self.game_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.game_socket.bind(('', 0))  # Random port
        
        # Start discovery listener
        discovery_thread = threading.Thread(target=self._client_discovery, daemon=True)
        game_thread = threading.Thread(target=self._game_listener, daemon=True)
        
        self.threads = [discovery_thread, game_thread]
        for t in self.threads:
            t.start()
    
    def _broadcast_room(self):
        """Broadcast room availability (host only)"""
        while self.running and self.is_host:
            try:
                packet = SamsoftPacket(
                    packet_type=PacketType.DISCOVERY,
                    player_id=self.player_id,
                    payload=json.dumps({
                        "room_code": self.room_code,
                        "host_name": self.username,
                        "players": len(self.players) + 1,
                        "max_players": 8,
                        "game": "Super Mario RPG Online"
                    }).encode()
                )
                
                self.discovery_socket.sendto(
                    packet.serialize(),
                    ('<broadcast>', self.DISCOVERY_PORT)
                )
            except Exception as e:
                print(f"Broadcast error: {e}")
            
            time.sleep(self.BROADCAST_INTERVAL)
    
    def _discovery_listener(self):
        """Listen for join requests (host only)"""
        while self.running and self.is_host:
            try:
                self.discovery_socket.settimeout(1.0)
                data, addr = self.discovery_socket.recvfrom(4096)
                packet = SamsoftPacket.deserialize(data)
                
                if packet.packet_type == PacketType.JOIN_REQUEST:
                    self._handle_join_request(packet, addr)
                    
            except socket.timeout:
                continue
            except Exception as e:
                if self.running:
                    print(f"Discovery error: {e}")
    
    def _client_discovery(self):
        """Search for available rooms (client only)"""
        search_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        search_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        search_socket.bind(('', self.DISCOVERY_PORT))
        search_socket.settimeout(1.0)
        
        while self.running and not self.is_host:
            try:
                data, addr = search_socket.recvfrom(4096)
                packet = SamsoftPacket.deserialize(data)
                
                if packet.packet_type == PacketType.DISCOVERY:
                    room_info = json.loads(packet.payload.decode())
                    room_info['address'] = addr
                    
                    if self.on_room_discovered:
                        self.on_room_discovered(room_info)
                        
            except socket.timeout:
                continue
            except Exception as e:
                if self.running:
                    print(f"Client discovery error: {e}")
        
        search_socket.close()
    
    def _game_listener(self):
        """Listen for game packets"""
        self.game_socket.settimeout(1.0)
        
        while self.running:
            try:
                data, addr = self.game_socket.recvfrom(4096)
                packet = SamsoftPacket.deserialize(data)
                self._handle_game_packet(packet, addr)
                
            except socket.timeout:
                self._check_timeouts()
            except Exception as e:
                if self.running:
                    print(f"Game listener error: {e}")
    
    def _handle_join_request(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle player join request"""
        try:
            join_data = json.loads(packet.payload.decode())
            
            # Create new player
            player = NetworkPlayer(
                player_id=packet.player_id,
                username=join_data.get('username', 'Unknown'),
                address=addr,
                character=join_data.get('character', 'mario')
            )
            
            with self._lock:
                self.players[packet.player_id] = player
            
            # Send accept response
            response = SamsoftPacket(
                packet_type=PacketType.JOIN_ACCEPT,
                player_id=self.player_id,
                payload=json.dumps({
                    "room_code": self.room_code,
                    "your_id": packet.player_id,
                    "players": [
                        {"id": p.player_id, "name": p.username, "char": p.character}
                        for p in self.players.values()
                    ]
                }).encode()
            )
            
            self.game_socket.sendto(response.serialize(), addr)
            
            if self.on_player_join:
                self.on_player_join(player)
                
        except Exception as e:
            print(f"Join request error: {e}")
    
    def _handle_game_packet(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle incoming game packet"""
        handlers = {
            PacketType.PLAYER_UPDATE: self._handle_player_update,
            PacketType.PLAYER_POSITION: self._handle_player_position,
            PacketType.CHAT_MESSAGE: self._handle_chat,
            PacketType.PING: self._handle_ping,
            PacketType.PONG: self._handle_pong,
            PacketType.DISCONNECT: self._handle_disconnect,
            PacketType.JOIN_ACCEPT: self._handle_join_accept,
        }
        
        handler = handlers.get(packet.packet_type)
        if handler:
            handler(packet, addr)
    
    def _handle_player_update(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle player state update"""
        try:
            data = json.loads(packet.payload.decode())
            
            with self._lock:
                if packet.player_id in self.players:
                    player = self.players[packet.player_id]
                    player.x = data.get('x', player.x)
                    player.y = data.get('y', player.y)
                    player.sprite_state = data.get('state', player.sprite_state)
                    player.last_seen = time.time()
                    
                    if self.on_player_update:
                        self.on_player_update(player)
                        
        except Exception as e:
            print(f"Player update error: {e}")
    
    def _handle_player_position(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle position-only update (optimized)"""
        try:
            # Compact format: x,y as floats
            x, y = struct.unpack('<ff', packet.payload[:8])
            
            with self._lock:
                if packet.player_id in self.players:
                    player = self.players[packet.player_id]
                    player.x = x
                    player.y = y
                    player.last_seen = time.time()
                    
                    if self.on_player_update:
                        self.on_player_update(player)
                        
        except Exception as e:
            print(f"Position update error: {e}")
    
    def _handle_chat(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle chat message"""
        try:
            message = packet.payload.decode('utf-8')
            
            with self._lock:
                username = "Unknown"
                if packet.player_id in self.players:
                    username = self.players[packet.player_id].username
            
            if self.on_chat_message:
                self.on_chat_message(username, message)
                
        except Exception as e:
            print(f"Chat error: {e}")
    
    def _handle_ping(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle ping request"""
        pong = SamsoftPacket(
            packet_type=PacketType.PONG,
            player_id=self.player_id,
            payload=packet.payload  # Echo timestamp
        )
        self.game_socket.sendto(pong.serialize(), addr)
    
    def _handle_pong(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle pong response"""
        try:
            sent_time = struct.unpack('<d', packet.payload)[0]
            latency = int((time.time() - sent_time) * 1000)
            
            with self._lock:
                if packet.player_id in self.players:
                    self.players[packet.player_id].latency = latency
                    
        except Exception:
            pass
    
    def _handle_disconnect(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle player disconnect"""
        with self._lock:
            if packet.player_id in self.players:
                player = self.players.pop(packet.player_id)
                
                if self.on_player_leave:
                    self.on_player_leave(player)
    
    def _handle_join_accept(self, packet: SamsoftPacket, addr: Tuple[str, int]):
        """Handle join acceptance (client)"""
        try:
            data = json.loads(packet.payload.decode())
            self.room_code = data.get('room_code', '')
            
            # Add other players
            for p_data in data.get('players', []):
                player = NetworkPlayer(
                    player_id=p_data['id'],
                    username=p_data['name'],
                    address=addr,
                    character=p_data.get('char', 'mario')
                )
                self.players[p_data['id']] = player
                
        except Exception as e:
            print(f"Join accept error: {e}")
    
    def _check_timeouts(self):
        """Remove timed-out players"""
        current_time = time.time()
        timed_out = []
        
        with self._lock:
            for pid, player in self.players.items():
                if current_time - player.last_seen > self.TIMEOUT:
                    timed_out.append(pid)
        
        for pid in timed_out:
            with self._lock:
                player = self.players.pop(pid, None)
            
            if player and self.on_player_leave:
                self.on_player_leave(player)
    
    def join_room(self, host_address: Tuple[str, int], room_code: str):
        """Join a discovered room"""
        packet = SamsoftPacket(
            packet_type=PacketType.JOIN_REQUEST,
            player_id=self.player_id,
            payload=json.dumps({
                "username": self.username,
                "room_code": room_code,
                "character": "mario"
            }).encode()
        )
        
        self.discovery_socket.sendto(packet.serialize(), host_address)
    
    def send_position(self, x: float, y: float):
        """Send position update to all players"""
        packet = SamsoftPacket(
            packet_type=PacketType.PLAYER_POSITION,
            player_id=self.player_id,
            payload=struct.pack('<ff', x, y)
        )
        
        self._broadcast_to_players(packet)
    
    def send_chat(self, message: str):
        """Send chat message"""
        packet = SamsoftPacket(
            packet_type=PacketType.CHAT_MESSAGE,
            player_id=self.player_id,
            payload=message.encode('utf-8')
        )
        
        self._broadcast_to_players(packet)
    
    def _broadcast_to_players(self, packet: SamsoftPacket):
        """Send packet to all connected players"""
        data = packet.serialize()
        
        with self._lock:
            for player in self.players.values():
                try:
                    self.game_socket.sendto(data, player.address)
                except Exception as e:
                    print(f"Send error to {player.username}: {e}")
    
    def disconnect(self):
        """Disconnect from network"""
        self.running = False
        
        # Send disconnect packet
        packet = SamsoftPacket(
            packet_type=PacketType.DISCONNECT,
            player_id=self.player_id
        )
        self._broadcast_to_players(packet)
        
        # Close sockets
        if self.discovery_socket:
            self.discovery_socket.close()
        if self.game_socket:
            self.game_socket.close()

# ═══════════════════════════════════════════════════════════════════════════════
# MARIO MMO CLIENT - TKINTER UI
# ═══════════════════════════════════════════════════════════════════════════════

class BowserCastleMap:
    """Bowser's Castle test map renderer"""
    
    # Color palette inspired by Bowser's Castle
    COLORS = {
        'bg': '#1a0a0a',
        'lava': '#ff4400',
        'lava_glow': '#ff8800',
        'stone': '#4a3a3a',
        'stone_dark': '#2a1a1a',
        'stone_light': '#6a5a5a',
        'gold': '#ffd700',
        'chain': '#8a8a8a',
        'spike': '#c0c0c0',
    }
    
    def __init__(self, canvas: tk.Canvas, width: int, height: int):
        self.canvas = canvas
        self.width = width
        self.height = height
        self.lava_offset = 0
        self.items = []
        
    def draw(self):
        """Draw the Bowser's Castle map"""
        self.canvas.delete("map")
        
        # Background
        self.canvas.create_rectangle(0, 0, self.width, self.height, 
                                     fill=self.COLORS['bg'], tags="map")
        
        # Lava pool at bottom
        self._draw_lava()
        
        # Stone platforms
        self._draw_platforms()
        
        # Decorative elements
        self._draw_decorations()
        
        # Castle elements
        self._draw_castle_elements()
    
    def _draw_lava(self):
        """Draw animated lava"""
        lava_y = self.height - 60
        
        # Lava glow
        for i in range(3):
            alpha_color = self._blend_color(self.COLORS['bg'], self.COLORS['lava_glow'], 0.3 - i * 0.1)
            self.canvas.create_rectangle(
                0, lava_y - 20 - i * 15,
                self.width, lava_y - i * 15,
                fill=alpha_color, outline='', tags="map"
            )
        
        # Main lava
        self.canvas.create_rectangle(
            0, lava_y, self.width, self.height,
            fill=self.COLORS['lava'], outline='', tags="map"
        )
        
        # Lava waves
        for i in range(0, self.width, 40):
            offset = (i + self.lava_offset) % 80
            wave_height = 8 + 4 * ((offset % 40) / 40)
            self.canvas.create_oval(
                i - 20, lava_y - wave_height,
                i + 20, lava_y + wave_height,
                fill=self.COLORS['lava_glow'], outline='', tags="map"
            )
    
    def _draw_platforms(self):
        """Draw stone platforms"""
        platforms = [
            (50, self.height - 120, 200, 30),
            (300, self.height - 180, 180, 30),
            (550, self.height - 140, 150, 30),
            (100, self.height - 280, 160, 30),
            (380, self.height - 320, 200, 30),
            (600, self.height - 260, 140, 30),
        ]
        
        for x, y, w, h in platforms:
            # Platform shadow
            self.canvas.create_rectangle(
                x + 4, y + 4, x + w + 4, y + h + 4,
                fill=self.COLORS['stone_dark'], outline='', tags="map"
            )
            
            # Main platform
            self.canvas.create_rectangle(
                x, y, x + w, y + h,
                fill=self.COLORS['stone'], outline=self.COLORS['stone_light'], 
                width=2, tags="map"
            )
            
            # Platform details
            for i in range(x + 10, x + w - 10, 30):
                self.canvas.create_line(
                    i, y + 5, i, y + h - 5,
                    fill=self.COLORS['stone_dark'], width=2, tags="map"
                )
    
    def _draw_decorations(self):
        """Draw decorative elements"""
        # Chains
        chain_positions = [50, 200, 500, 700]
        for cx in chain_positions:
            for cy in range(0, self.height - 100, 20):
                self.canvas.create_oval(
                    cx - 5, cy, cx + 5, cy + 15,
                    outline=self.COLORS['chain'], width=2, tags="map"
                )
        
        # Torches
        torch_positions = [(120, 200), (450, 150), (650, 220)]
        for tx, ty in torch_positions:
            # Torch holder
            self.canvas.create_rectangle(
                tx - 8, ty, tx + 8, ty + 40,
                fill=self.COLORS['stone'], outline=self.COLORS['stone_light'], tags="map"
            )
            # Flame
            self.canvas.create_polygon(
                tx - 10, ty,
                tx, ty - 25,
                tx + 10, ty,
                fill=self.COLORS['lava_glow'], outline=self.COLORS['lava'], tags="map"
            )
    
    def _draw_castle_elements(self):
        """Draw castle-specific elements"""
        # Bowser emblem
        emblem_x, emblem_y = self.width // 2, 80
        
        # Shield background
        self.canvas.create_polygon(
            emblem_x - 40, emblem_y - 30,
            emblem_x + 40, emblem_y - 30,
            emblem_x + 50, emblem_y + 20,
            emblem_x, emblem_y + 50,
            emblem_x - 50, emblem_y + 20,
            fill=self.COLORS['stone'], outline=self.COLORS['gold'], width=3, tags="map"
        )
        
        # Bowser symbol (simplified)
        self.canvas.create_text(
            emblem_x, emblem_y + 5,
            text="👑", font=("Arial", 24), tags="map"
        )
        
        # Spikes at top
        for i in range(0, self.width, 60):
            self.canvas.create_polygon(
                i, 0,
                i + 30, 40,
                i + 60, 0,
                fill=self.COLORS['spike'], outline=self.COLORS['stone_dark'], tags="map"
            )
    
    def _blend_color(self, color1: str, color2: str, factor: float) -> str:
        """Blend two hex colors"""
        r1, g1, b1 = int(color1[1:3], 16), int(color1[3:5], 16), int(color1[5:7], 16)
        r2, g2, b2 = int(color2[1:3], 16), int(color2[3:5], 16), int(color2[5:7], 16)
        
        r = int(r1 + (r2 - r1) * factor)
        g = int(g1 + (g2 - g1) * factor)
        b = int(b1 + (b2 - b1) * factor)
        
        return f'#{r:02x}{g:02x}{b:02x}'
    
    def animate(self):
        """Animate map elements"""
        self.lava_offset = (self.lava_offset + 2) % 80
        self.draw()

class PlayerSprite:
    """Player sprite renderer"""
    
    COLORS = {
        'mario': {'body': '#ff0000', 'accent': '#0000ff', 'skin': '#ffcc99'},
        'luigi': {'body': '#00aa00', 'accent': '#0000ff', 'skin': '#ffcc99'},
        'peach': {'body': '#ff99cc', 'accent': '#ffcc00', 'skin': '#ffcc99'},
        'bowser': {'body': '#00aa00', 'accent': '#ff8800', 'skin': '#ffdd44'},
        'toad': {'body': '#ffffff', 'accent': '#ff0000', 'skin': '#ffcc99'},
    }
    
    def __init__(self, canvas: tk.Canvas, player_id: str, character: str = 'mario'):
        self.canvas = canvas
        self.player_id = player_id
        self.character = character
        self.x = 400
        self.y = 300
        self.direction = 1  # 1 = right, -1 = left
        self.frame = 0
        self.items = []
        
    def draw(self):
        """Draw player sprite"""
        self.canvas.delete(f"player_{self.player_id}")
        
        colors = self.COLORS.get(self.character, self.COLORS['mario'])
        
        # Body (simplified Mario-style sprite)
        # Head
        self.canvas.create_oval(
            self.x - 12, self.y - 35,
            self.x + 12, self.y - 10,
            fill=colors['skin'], outline='#000000', width=2,
            tags=f"player_{self.player_id}"
        )
        
        # Hat
        self.canvas.create_arc(
            self.x - 14, self.y - 42,
            self.x + 14, self.y - 20,
            start=0, extent=180,
            fill=colors['body'], outline='#000000', width=2,
            tags=f"player_{self.player_id}"
        )
        
        # Body
        self.canvas.create_rectangle(
            self.x - 10, self.y - 12,
            self.x + 10, self.y + 10,
            fill=colors['body'], outline='#000000', width=2,
            tags=f"player_{self.player_id}"
        )
        
        # Overalls
        self.canvas.create_rectangle(
            self.x - 10, self.y - 5,
            self.x + 10, self.y + 15,
            fill=colors['accent'], outline='#000000', width=2,
            tags=f"player_{self.player_id}"
        )
        
        # Legs
        leg_offset = 5 * (self.frame % 2) * self.direction
        self.canvas.create_rectangle(
            self.x - 8 + leg_offset, self.y + 15,
            self.x - 2 + leg_offset, self.y + 28,
            fill=colors['accent'], outline='#000000', width=1,
            tags=f"player_{self.player_id}"
        )
        self.canvas.create_rectangle(
            self.x + 2 - leg_offset, self.y + 15,
            self.x + 8 - leg_offset, self.y + 28,
            fill=colors['accent'], outline='#000000', width=1,
            tags=f"player_{self.player_id}"
        )
    
    def move(self, dx: float, dy: float):
        """Move sprite"""
        self.x += dx
        self.y += dy
        if dx != 0:
            self.direction = 1 if dx > 0 else -1
            self.frame += 1
        self.draw()
    
    def set_position(self, x: float, y: float):
        """Set sprite position"""
        if x != self.x:
            self.direction = 1 if x > self.x else -1
            self.frame += 1
        self.x = x
        self.y = y
        self.draw()

class MarioMMOClient(tk.Tk):
    """Main Mario MMO Client Window"""
    
    def __init__(self):
        super().__init__()
        
        self.title("🍄 Super Mario RPG: Online Adventures - Samsoft Play!")
        self.geometry("1000x700")
        self.configure(bg='#1a1a2e')
        self.resizable(True, True)
        
        # Game state
        self.rom_loader = SuperMarioRPGLoader()
        self.network: Optional[SamsoftPlayNetwork] = None
        self.username = f"Player{random.randint(1000, 9999)}"
        self.player_sprite: Optional[PlayerSprite] = None
        self.other_sprites: Dict[str, PlayerSprite] = {}
        self.discovered_rooms: Dict[str, dict] = {}
        
        # Movement
        self.keys_pressed = set()
        self.move_speed = 5
        
        # Setup UI
        self._setup_styles()
        self._create_widgets()
        self._bind_events()
        
        # Start game loop
        self._game_loop()
    
    def _setup_styles(self):
        """Setup ttk styles"""
        style = ttk.Style()
        style.theme_use('clam')
        
        style.configure('Title.TLabel', 
                       background='#1a1a2e', 
                       foreground='#ffd700',
                       font=('Press Start 2P', 16, 'bold'))
        
        style.configure('Game.TFrame', background='#1a1a2e')
        style.configure('Panel.TFrame', background='#16213e')
        
        style.configure('Game.TButton',
                       background='#e94560',
                       foreground='#ffffff',
                       font=('Arial', 10, 'bold'),
                       padding=10)
        
        style.configure('Chat.TEntry',
                       fieldbackground='#0f0f23',
                       foreground='#ffffff',
                       font=('Consolas', 10))
    
    def _create_widgets(self):
        """Create all UI widgets"""
        # Main container
        main_frame = ttk.Frame(self, style='Game.TFrame')
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Title bar
        title_frame = ttk.Frame(main_frame, style='Game.TFrame')
        title_frame.pack(fill=tk.X, pady=(0, 10))
        
        title_label = tk.Label(
            title_frame,
            text="🏰 SUPER MARIO RPG: ONLINE ADVENTURES 🍄",
            font=('Arial', 18, 'bold'),
            bg='#1a1a2e',
            fg='#ffd700'
        )
        title_label.pack(side=tk.LEFT)
        
        self.status_label = tk.Label(
            title_frame,
            text="Not Connected",
            font=('Arial', 10),
            bg='#1a1a2e',
            fg='#888888'
        )
        self.status_label.pack(side=tk.RIGHT)
        
        # Content area (game + sidebar)
        content_frame = ttk.Frame(main_frame, style='Game.TFrame')
        content_frame.pack(fill=tk.BOTH, expand=True)
        
        # Game canvas
        self._create_game_area(content_frame)
        
        # Side panel
        self._create_side_panel(content_frame)
        
        # Bottom controls
        self._create_controls(main_frame)
    
    def _create_game_area(self, parent):
        """Create game canvas area"""
        game_frame = ttk.Frame(parent, style='Panel.TFrame')
        game_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 10))
        
        # Game canvas
        self.game_canvas = tk.Canvas(
            game_frame,
            width=700,
            height=500,
            bg='#1a0a0a',
            highlightthickness=2,
            highlightbackground='#ffd700'
        )
        self.game_canvas.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Initialize map
        self.bowser_map = BowserCastleMap(self.game_canvas, 700, 500)
        self.bowser_map.draw()
        
        # Initialize player
        self.player_sprite = PlayerSprite(self.game_canvas, "local", "mario")
        self.player_sprite.x = 350
        self.player_sprite.y = 300
        self.player_sprite.draw()
    
    def _create_side_panel(self, parent):
        """Create side panel with chat and controls"""
        side_frame = ttk.Frame(parent, style='Panel.TFrame')
        side_frame.pack(side=tk.RIGHT, fill=tk.Y, ipadx=10, ipady=10)
        
        # ROM Info section
        rom_frame = tk.LabelFrame(
            side_frame,
            text="📀 ROM Status",
            bg='#16213e',
            fg='#ffd700',
            font=('Arial', 10, 'bold')
        )
        rom_frame.pack(fill=tk.X, padx=5, pady=5)
        
        self.rom_info_label = tk.Label(
            rom_frame,
            text="No ROM loaded",
            bg='#16213e',
            fg='#aaaaaa',
            font=('Consolas', 9),
            justify=tk.LEFT,
            anchor='w'
        )
        self.rom_info_label.pack(fill=tk.X, padx=5, pady=5)
        
        load_rom_btn = tk.Button(
            rom_frame,
            text="Load ROM (.sfc/.smc)",
            command=self._load_rom,
            bg='#e94560',
            fg='#ffffff',
            font=('Arial', 9, 'bold'),
            cursor='hand2'
        )
        load_rom_btn.pack(fill=tk.X, padx=5, pady=5)
        
        # Network section
        net_frame = tk.LabelFrame(
            side_frame,
            text="🌐 Samsoft Play!",
            bg='#16213e',
            fg='#ffd700',
            font=('Arial', 10, 'bold')
        )
        net_frame.pack(fill=tk.X, padx=5, pady=5)
        
        # Username
        tk.Label(net_frame, text="Username:", bg='#16213e', fg='#ffffff').pack(anchor='w', padx=5)
        self.username_entry = tk.Entry(net_frame, bg='#0f0f23', fg='#ffffff', font=('Consolas', 10))
        self.username_entry.insert(0, self.username)
        self.username_entry.pack(fill=tk.X, padx=5, pady=2)
        
        # Host/Join buttons
        btn_frame = tk.Frame(net_frame, bg='#16213e')
        btn_frame.pack(fill=tk.X, padx=5, pady=5)
        
        self.host_btn = tk.Button(
            btn_frame,
            text="🏠 Host",
            command=self._host_game,
            bg='#4ecca3',
            fg='#000000',
            font=('Arial', 9, 'bold'),
            cursor='hand2'
        )
        self.host_btn.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=2)
        
        self.search_btn = tk.Button(
            btn_frame,
            text="🔍 Search",
            command=self._search_games,
            bg='#00adb5',
            fg='#000000',
            font=('Arial', 9, 'bold'),
            cursor='hand2'
        )
        self.search_btn.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=2)
        
        # Room code display
        self.room_code_label = tk.Label(
            net_frame,
            text="Room: ------",
            bg='#16213e',
            fg='#ffd700',
            font=('Consolas', 12, 'bold')
        )
        self.room_code_label.pack(pady=5)
        
        # Discovered rooms listbox
        self.rooms_listbox = tk.Listbox(
            net_frame,
            height=4,
            bg='#0f0f23',
            fg='#ffffff',
            font=('Consolas', 9),
            selectbackground='#e94560'
        )
        self.rooms_listbox.pack(fill=tk.X, padx=5, pady=5)
        self.rooms_listbox.bind('<Double-1>', self._join_selected_room)
        
        # Players list
        players_frame = tk.LabelFrame(
            side_frame,
            text="👥 Players",
            bg='#16213e',
            fg='#ffd700',
            font=('Arial', 10, 'bold')
        )
        players_frame.pack(fill=tk.X, padx=5, pady=5)
        
        self.players_listbox = tk.Listbox(
            players_frame,
            height=4,
            bg='#0f0f23',
            fg='#ffffff',
            font=('Consolas', 9)
        )
        self.players_listbox.pack(fill=tk.X, padx=5, pady=5)
        
        # Chat section
        chat_frame = tk.LabelFrame(
            side_frame,
            text="💬 Chat",
            bg='#16213e',
            fg='#ffd700',
            font=('Arial', 10, 'bold')
        )
        chat_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        self.chat_display = scrolledtext.ScrolledText(
            chat_frame,
            height=10,
            bg='#0f0f23',
            fg='#ffffff',
            font=('Consolas', 9),
            wrap=tk.WORD,
            state=tk.DISABLED
        )
        self.chat_display.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Chat input
        chat_input_frame = tk.Frame(chat_frame, bg='#16213e')
        chat_input_frame.pack(fill=tk.X, padx=5, pady=5)
        
        self.chat_entry = tk.Entry(
            chat_input_frame,
            bg='#0f0f23',
            fg='#ffffff',
            font=('Consolas', 10)
        )
        self.chat_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
        self.chat_entry.bind('<Return>', self._send_chat)
        
        send_btn = tk.Button(
            chat_input_frame,
            text="Send",
            command=lambda: self._send_chat(None),
            bg='#e94560',
            fg='#ffffff',
            font=('Arial', 9, 'bold')
        )
        send_btn.pack(side=tk.RIGHT, padx=(5, 0))
    
    def _create_controls(self, parent):
        """Create bottom control bar"""
        controls_frame = ttk.Frame(parent, style='Game.TFrame')
        controls_frame.pack(fill=tk.X, pady=(10, 0))
        
        # Instructions
        instructions = tk.Label(
            controls_frame,
            text="🎮 WASD/Arrow Keys to move | Enter to chat | Double-click room to join",
            bg='#1a1a2e',
            fg='#888888',
            font=('Arial', 9)
        )
        instructions.pack(side=tk.LEFT)
        
        # Disconnect button
        self.disconnect_btn = tk.Button(
            controls_frame,
            text="Disconnect",
            command=self._disconnect,
            bg='#aa0000',
            fg='#ffffff',
            font=('Arial', 9, 'bold'),
            state=tk.DISABLED
        )
        self.disconnect_btn.pack(side=tk.RIGHT)
    
    def _bind_events(self):
        """Bind keyboard and mouse events"""
        self.bind('<KeyPress>', self._key_press)
        self.bind('<KeyRelease>', self._key_release)
        self.game_canvas.bind('<Button-1>', self._canvas_click)
        self.protocol("WM_DELETE_WINDOW", self._on_close)
    
    def _key_press(self, event):
        """Handle key press"""
        self.keys_pressed.add(event.keysym.lower())
    
    def _key_release(self, event):
        """Handle key release"""
        self.keys_pressed.discard(event.keysym.lower())
    
    def _canvas_click(self, event):
        """Handle canvas click"""
        self.game_canvas.focus_set()
    
    def _load_rom(self):
        """Load ROM file"""
        filepath = filedialog.askopenfilename(
            title="Select Super Mario RPG ROM",
            filetypes=[
                ("SNES ROMs", "*.sfc *.smc"),
                ("All files", "*.*")
            ]
        )
        
        if not filepath:
            return
        
        try:
            self.rom_loader.load_rom(filepath)
            info = self.rom_loader.get_rom_info()
            
            info_text = f"Title: {info['title']}\n"
            info_text += f"Region: {info['region']}\n"
            info_text += f"Size: {info['rom_size']}\n"
            info_text += f"Maps: {info['maps_loaded']}\n"
            info_text += f"✓ Loaded successfully!"
            
            self.rom_info_label.config(text=info_text, fg='#4ecca3')
            self._add_chat_message("System", f"ROM loaded: {info['title']} ({info['region']})")
            
        except Exception as e:
            self.rom_info_label.config(text=f"Error: {str(e)}", fg='#ff4444')
            messagebox.showerror("ROM Load Error", str(e))
    
    def _host_game(self):
        """Host a new game"""
        self.username = self.username_entry.get() or self.username
        
        self.network = SamsoftPlayNetwork(self.username)
        self.network.on_player_join = self._on_player_join
        self.network.on_player_leave = self._on_player_leave
        self.network.on_player_update = self._on_player_update
        self.network.on_chat_message = self._on_chat_receive
        
        try:
            room_code = self.network.start_host()
            self.room_code_label.config(text=f"Room: {room_code}")
            self.status_label.config(text=f"Hosting as {self.username}", fg='#4ecca3')
            self._add_chat_message("System", f"Room created! Code: {room_code}")
            
            self.host_btn.config(state=tk.DISABLED)
            self.search_btn.config(state=tk.DISABLED)
            self.disconnect_btn.config(state=tk.NORMAL)
            
        except Exception as e:
            messagebox.showerror("Host Error", str(e))
    
    def _search_games(self):
        """Search for available games"""
        self.username = self.username_entry.get() or self.username
        
        self.network = SamsoftPlayNetwork(self.username)
        self.network.on_room_discovered = self._on_room_discovered
        self.network.on_player_join = self._on_player_join
        self.network.on_player_leave = self._on_player_leave
        self.network.on_player_update = self._on_player_update
        self.network.on_chat_message = self._on_chat_receive
        
        try:
            self.network.start_client()
            self.status_label.config(text="Searching for rooms...", fg='#00adb5')
            self._add_chat_message("System", "Searching for nearby rooms...")
            
        except Exception as e:
            messagebox.showerror("Search Error", str(e))
    
    def _on_room_discovered(self, room_info: dict):
        """Handle room discovery"""
        room_key = room_info['room_code']
        self.discovered_rooms[room_key] = room_info
        
        # Update listbox
        self.rooms_listbox.delete(0, tk.END)
        for code, info in self.discovered_rooms.items():
            self.rooms_listbox.insert(
                tk.END, 
                f"{code} - {info['host_name']} ({info['players']}/{info['max_players']})"
            )
    
    def _join_selected_room(self, event):
        """Join the selected room"""
        selection = self.rooms_listbox.curselection()
        if not selection:
            return
        
        room_text = self.rooms_listbox.get(selection[0])
        room_code = room_text.split(' - ')[0]
        
        if room_code in self.discovered_rooms:
            room_info = self.discovered_rooms[room_code]
            self.network.join_room(room_info['address'], room_code)
            
            self.room_code_label.config(text=f"Room: {room_code}")
            self.status_label.config(text=f"Joined {room_info['host_name']}'s room", fg='#4ecca3')
            self._add_chat_message("System", f"Joined room {room_code}")
            
            self.host_btn.config(state=tk.DISABLED)
            self.search_btn.config(state=tk.DISABLED)
            self.disconnect_btn.config(state=tk.NORMAL)
    
    def _on_player_join(self, player: NetworkPlayer):
        """Handle player join"""
        self._add_chat_message("System", f"{player.username} joined!")
        self._update_players_list()
        
        # Create sprite for new player
        sprite = PlayerSprite(self.game_canvas, player.player_id, player.character)
        sprite.set_position(player.x, player.y)
        self.other_sprites[player.player_id] = sprite
    
    def _on_player_leave(self, player: NetworkPlayer):
        """Handle player leave"""
        self._add_chat_message("System", f"{player.username} left.")
        self._update_players_list()
        
        # Remove sprite
        if player.player_id in self.other_sprites:
            self.game_canvas.delete(f"player_{player.player_id}")
            del self.other_sprites[player.player_id]
    
    def _on_player_update(self, player: NetworkPlayer):
        """Handle player position update"""
        if player.player_id in self.other_sprites:
            self.other_sprites[player.player_id].set_position(player.x, player.y)
    
    def _on_chat_receive(self, username: str, message: str):
        """Handle received chat message"""
        self._add_chat_message(username, message)
    
    def _update_players_list(self):
        """Update the players listbox"""
        self.players_listbox.delete(0, tk.END)
        self.players_listbox.insert(tk.END, f"🎮 {self.username} (You)")
        
        if self.network:
            for player in self.network.players.values():
                ping_str = f" ({player.latency}ms)" if player.latency > 0 else ""
                self.players_listbox.insert(tk.END, f"👤 {player.username}{ping_str}")
    
    def _add_chat_message(self, sender: str, message: str):
        """Add message to chat display"""
        self.chat_display.config(state=tk.NORMAL)
        
        timestamp = time.strftime("%H:%M")
        
        if sender == "System":
            self.chat_display.insert(tk.END, f"[{timestamp}] ⚙️ {message}\n")
        else:
            self.chat_display.insert(tk.END, f"[{timestamp}] {sender}: {message}\n")
        
        self.chat_display.see(tk.END)
        self.chat_display.config(state=tk.DISABLED)
    
    def _send_chat(self, event):
        """Send chat message"""
        message = self.chat_entry.get().strip()
        if not message:
            return
        
        self._add_chat_message(self.username, message)
        self.chat_entry.delete(0, tk.END)
        
        if self.network:
            self.network.send_chat(message)
    
    def _disconnect(self):
        """Disconnect from network"""
        if self.network:
            self.network.disconnect()
            self.network = None
        
        self.discovered_rooms.clear()
        self.rooms_listbox.delete(0, tk.END)
        self.other_sprites.clear()
        
        self.room_code_label.config(text="Room: ------")
        self.status_label.config(text="Not Connected", fg='#888888')
        
        self.host_btn.config(state=tk.NORMAL)
        self.search_btn.config(state=tk.NORMAL)
        self.disconnect_btn.config(state=tk.DISABLED)
        
        self._add_chat_message("System", "Disconnected.")
        self._update_players_list()
    
    def _game_loop(self):
        """Main game loop"""
        # Handle movement
        dx, dy = 0, 0
        
        if 'w' in self.keys_pressed or 'up' in self.keys_pressed:
            dy = -self.move_speed
        if 's' in self.keys_pressed or 'down' in self.keys_pressed:
            dy = self.move_speed
        if 'a' in self.keys_pressed or 'left' in self.keys_pressed:
            dx = -self.move_speed
        if 'd' in self.keys_pressed or 'right' in self.keys_pressed:
            dx = self.move_speed
        
        if dx != 0 or dy != 0:
            if self.player_sprite:
                # Boundary check
                new_x = self.player_sprite.x + dx
                new_y = self.player_sprite.y + dy
                
                new_x = max(20, min(680, new_x))
                new_y = max(50, min(440, new_y))
                
                dx = new_x - self.player_sprite.x
                dy = new_y - self.player_sprite.y
                
                self.player_sprite.move(dx, dy)
                
                # Send position to network
                if self.network:
                    self.network.send_position(self.player_sprite.x, self.player_sprite.y)
        
        # Animate map (every 5 frames)
        if hasattr(self, '_frame_count'):
            self._frame_count += 1
        else:
            self._frame_count = 0
        
        if self._frame_count % 5 == 0:
            self.bowser_map.animate()
            if self.player_sprite:
                self.player_sprite.draw()
            for sprite in self.other_sprites.values():
                sprite.draw()
        
        # Schedule next frame
        self.after(16, self._game_loop)  # ~60 FPS
    
    def _on_close(self):
        """Handle window close"""
        self._disconnect()
        self.destroy()

# ═══════════════════════════════════════════════════════════════════════════════
# MAIN ENTRY POINT
# ═══════════════════════════════════════════════════════════════════════════════

def main():
    """Main entry point"""
    print("""
╔══════════════════════════════════════════════════════════════════════════════╗
║                    SUPER MARIO RPG: ONLINE ADVENTURES                        ║
║                        Samsoft Play! Network Edition                         ║
║══════════════════════════════════════════════════════════════════════════════║
║                                                                              ║
║  Features:                                                                   ║
║  • Load Super Mario RPG ROM (.sfc/.smc) - All Regions                       ║
║  • P2P Multiplayer with Samsoft Play! Protocol                              ║
║  • DS Download Play Style Room Discovery                                     ║
║  • Bowser's Castle Test Map                                                  ║
║  • Real-time Chat                                                            ║
║                                                                              ║
║  Controls:                                                                   ║
║  • WASD / Arrow Keys - Move                                                  ║
║  • Enter - Send Chat                                                         ║
║                                                                              ║
║  © Team Flames / Samsoft / CatOS                                            ║
╚══════════════════════════════════════════════════════════════════════════════╝
    """)
    
    app = MarioMMOClient()
    app.mainloop()

if __name__ == "__main__":
    main()