iflow-mcp_bethington-cheat-engine-server-python 0.1.0__py3-none-any.whl

server/cheatengine/table_parser.py

@@ -0,0 +1,1221 @@
+"""
+Cheat Engine Table Parser
+Handles reading, writing, and parsing .CT (Cheat Table) files
+Supports backup creation and comprehensive file operations
+"""
+
+import struct
+import logging
+import shutil
+import time
+from typing import Dict, List, Optional, Any, BinaryIO
+from dataclasses import dataclass
+from pathlib import Path
+import xml.etree.ElementTree as ET
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class CheatEntry:
+    """Represents a single cheat entry"""
+    id: str
+    description: str
+    address: Optional[int] = None
+    address_string: Optional[str] = None  # For module+offset addresses like "D2GAME.dll+1107B8"
+    offsets: List[int] = None
+    variable_type: str = "4 Bytes"
+    value: Any = None
+    enabled: bool = False
+    hotkey: Optional[str] = None
+    script: Optional[str] = None
+    group_header: bool = False
+    
+    def __post_init__(self):
+        if self.offsets is None:
+            self.offsets = []
+
+@dataclass
+class StructureElement:
+    """Represents a single element in a structure"""
+    offset: int
+    vartype: str
+    bytesize: int
+    description: str
+    display_method: str = "unsigned integer"
+    child_struct: Optional[str] = None
+
+@dataclass
+class Structure:
+    """Represents a cheat engine structure definition"""
+    name: str
+    auto_fill: bool = False
+    auto_create: bool = True
+    default_hex: bool = False
+    auto_destroy: bool = False
+    elements: List[StructureElement] = None
+    
+    def __post_init__(self):
+        if self.elements is None:
+            self.elements = []
+
+@dataclass
+class DisassemblerComment:
+    """Represents a disassembler comment"""
+    address: str
+    comment: str
+
+@dataclass
+class CheatTable:
+    """Represents a complete cheat table with all components preserved"""
+    title: str = "Cheat Table"
+    target_process: str = ""
+    entries: List[CheatEntry] = None
+    structures: List[Structure] = None
+    lua_script: Optional[str] = None
+    disassembler_comments: List[DisassemblerComment] = None
+    # Preserve the original XML tree for exact reconstruction
+    _original_xml_root: Optional[ET.Element] = None
+    _original_xml_content: Optional[str] = None
+    
+    def __post_init__(self):
+        if self.entries is None:
+            self.entries = []
+        if self.structures is None:
+            self.structures = []
+        if self.disassembler_comments is None:
+            self.disassembler_comments = []
+
+@dataclass
+class AddressList:
+    """Collection of cheat entries and enhanced data"""
+    entries: List[CheatEntry]
+    title: str = "Cheat Table"
+    target_process: str = ""
+    structures: List[Structure] = None
+    lua_script: Optional[str] = None
+    disassembler_comments: List[DisassemblerComment] = None
+    
+    def __post_init__(self):
+        if self.entries is None:
+            self.entries = []
+        if self.structures is None:
+            self.structures = []
+        if self.disassembler_comments is None:
+            self.disassembler_comments = []
+
+class CheatTableParser:
+    """Parser for Cheat Engine .CT files with complete XML preservation"""
+    
+    def __init__(self):
+        self.type_map = {
+            "Binary": "binary",
+            "Byte": "byte", 
+            "2 Bytes": "word",
+            "4 Bytes": "dword",
+            "8 Bytes": "qword",
+            "Float": "float",
+            "Double": "double",
+            "String": "string",
+            "Array of byte": "aob",
+        }
+    
+    def parse_file(self, file_path: str) -> Optional['CheatTable']:
+        """
+        Parse a .CT file and return a complete CheatTable object
+        Preserves all original XML structure for exact reconstruction
+        
+        Args:
+            file_path: Path to the .CT file
+            
+        Returns:
+            CheatTable object or None if parsing failed
+        """
+        try:
+            if not Path(file_path).exists():
+                logger.error(f"Cheat table file not found: {file_path}")
+                return None
+            
+            # Try to determine if it's binary or XML format
+            with open(file_path, 'rb') as f:
+                header = f.read(1024)  # Read more data for better detection
+                f.seek(0)
+                
+                # Check for XML indicators
+                if (b'<?xml' in header or 
+                    b'<CheatTable' in header or 
+                    b'<CheatEntries' in header):
+                    # XML format (newer CE versions)
+                    return self._parse_xml_format(f)
+                else:
+                    # Binary format (older CE versions)
+                    return self._parse_binary_format_to_cheattable(f)
+                    
+        except Exception as e:
+            logger.error(f"Error parsing cheat table {file_path}: {e}")
+            return None
+    
+    def _parse_xml_format(self, file_handle: BinaryIO) -> Optional['CheatTable']:
+        """Parse XML format .CT file and preserve complete structure"""
+        try:
+            # Read the entire file as text for XML parsing
+            file_handle.seek(0)
+            content = file_handle.read().decode('utf-8', errors='ignore')
+            
+            # Parse XML
+            root = ET.fromstring(content)
+            
+            # Find CheatTable root element
+            if root.tag != 'CheatTable':
+                cheat_table = root.find('.//CheatTable')
+                if cheat_table is None:
+                    logger.error("No CheatTable element found")
+                    return None
+                root = cheat_table
+            
+            # Create CheatTable object and preserve original XML
+            cheat_table = CheatTable()
+            cheat_table._original_xml_root = root
+            cheat_table._original_xml_content = content
+            
+            # Parse header information
+            title = "Cheat Table"
+            target_process = ""
+            
+            # Look for table info
+            for child in root:
+                if child.tag == 'CheatTableInfo':
+                    title_elem = child.find('Title')
+                    if title_elem is not None and title_elem.text:
+                        title = title_elem.text
+                
+                elif child.tag == 'Options':
+                    # Parse options if available
+                    pass
+            
+            cheat_table.title = title
+            cheat_table.target_process = target_process
+            
+            # Parse cheat entries
+            entries = []
+            
+            # Look for CheatEntries container or direct CheatEntry elements
+            cheat_entries_elem = root.find('CheatEntries')
+            if cheat_entries_elem is not None:
+                # Entries are in a CheatEntries container
+                entry_elements = cheat_entries_elem.findall('CheatEntry')
+            else:
+                # Look for direct CheatEntry elements
+                entry_elements = root.findall('CheatEntry')
+            
+            logger.info(f"Found {len(entry_elements)} cheat entries to parse")
+            
+            for entry_elem in entry_elements:
+                entry = self._parse_xml_entry(entry_elem)
+                if entry:
+                    entries.append(entry)
+                    
+                    # Also parse child entries if they exist
+                    child_entries = self._parse_xml_child_entries(entry_elem)
+                    if child_entries:
+                        entries.extend(child_entries)
+            
+            cheat_table.entries = entries
+            
+            # Parse structures
+            structures = []
+            structures_elem = root.find('Structures')
+            if structures_elem is not None:
+                logger.info("Found Structures section")
+                structures = self._parse_structures(structures_elem)
+            
+            cheat_table.structures = structures
+            
+            # Parse Lua script
+            lua_script = None
+            lua_elem = root.find('LuaScript')
+            if lua_elem is not None and lua_elem.text:
+                lua_script = lua_elem.text.strip()
+                logger.info(f"Found Lua script: {len(lua_script)} characters")
+            
+            cheat_table.lua_script = lua_script
+            
+            # Parse disassembler comments
+            disassembler_comments = []
+            comments_elem = root.find('DisassemblerComments')
+            if comments_elem is not None:
+                logger.info("Found DisassemblerComments section")
+                disassembler_comments = self._parse_disassembler_comments(comments_elem)
+            
+            cheat_table.disassembler_comments = disassembler_comments
+            
+            logger.info(f"Successfully parsed cheat table: {len(entries)} entries, {len(structures)} structures, "
+                       f"lua_script: {'yes' if lua_script else 'no'}, {len(disassembler_comments)} comments")
+            
+            return cheat_table
+            
+        except Exception as e:
+            logger.error(f"Error parsing XML format: {e}")
+            return None
+    
+    def _parse_binary_format_to_cheattable(self, file_handle: BinaryIO) -> Optional['CheatTable']:
+        """Parse binary format .CT file and convert to CheatTable"""
+        # Use existing binary parsing logic and convert to CheatTable
+        address_list = self._parse_binary_format(file_handle)
+        if address_list:
+            cheat_table = CheatTable(
+                title=address_list.title,
+                target_process=address_list.target_process,
+                entries=address_list.entries
+            )
+            if hasattr(address_list, 'structures'):
+                cheat_table.structures = address_list.structures
+            if hasattr(address_list, 'lua_script'):
+                cheat_table.lua_script = address_list.lua_script
+            if hasattr(address_list, 'disassembler_comments'):
+                cheat_table.disassembler_comments = address_list.disassembler_comments
+            return cheat_table
+        return None
+        """Parse a .CT file and return the address list
+        
+        Args:
+            file_path: Path to the .CT file
+            
+        Returns:
+            AddressList object or None if parsing failed
+        """
+        try:
+            if not Path(file_path).exists():
+                logger.error(f"Cheat table file not found: {file_path}")
+                return None
+            
+            # Try to determine if it's binary or XML format
+            with open(file_path, 'rb') as f:
+                header = f.read(1024)  # Read more data for better detection
+                f.seek(0)
+                
+                # Check for XML indicators
+                if (b'<?xml' in header or 
+                    b'<CheatTable' in header or 
+                    b'<CheatEntries' in header):
+                    # XML format (newer CE versions)
+                    return self._parse_xml_format(f)
+                else:
+                    # Binary format (older CE versions)
+                    return self._parse_binary_format(f)
+                    
+        except Exception as e:
+            logger.error(f"Error parsing cheat table {file_path}: {e}")
+            return None
+    
+    
+    def _parse_xml_child_entries(self, parent_elem: ET.Element) -> List[CheatEntry]:
+        """Parse child cheat entries from XML elements"""
+        entries = []
+        
+        child_entries_elem = parent_elem.find('CheatEntries')
+        if child_entries_elem is not None:
+            for entry_elem in child_entries_elem.findall('CheatEntry'):
+                entry = self._parse_xml_entry(entry_elem)
+                if entry:
+                    entries.append(entry)
+                    
+                    # Recursively parse nested child entries
+                    nested_entries = self._parse_xml_child_entries(entry_elem)
+                    if nested_entries:
+                        entries.extend(nested_entries)
+        
+        return entries
+    
+    def _parse_structures(self, structures_elem: ET.Element) -> List[Structure]:
+        """Parse structures from XML elements"""
+        structures = []
+        
+        for struct_elem in structures_elem.findall('Structure'):
+            try:
+                name = struct_elem.get('Name', 'Unknown')
+                auto_fill = struct_elem.get('AutoFill', '0') == '1'
+                auto_create = struct_elem.get('AutoCreate', '1') == '1'
+                default_hex = struct_elem.get('DefaultHex', '0') == '1'
+                auto_destroy = struct_elem.get('AutoDestroy', '0') == '1'
+                
+                # Parse elements
+                elements = []
+                elements_elem = struct_elem.find('Elements')
+                if elements_elem is not None:
+                    for element_elem in elements_elem.findall('Element'):
+                        try:
+                            offset_str = element_elem.get('Offset', '0')
+                            # Handle hexadecimal offsets (e.g., '0x0', '0x10', etc.)
+                            if offset_str.startswith('0x'):
+                                offset = int(offset_str, 16)
+                            else:
+                                offset = int(offset_str)
+                            vartype = element_elem.get('Vartype', '4 Bytes')
+                            bytesize = int(element_elem.get('Bytesize', '4'))
+                            description = element_elem.get('Description', 'Unknown')
+                            display_method = element_elem.get('DisplayMethod', 'unsigned integer')
+                            child_struct = element_elem.get('ChildStruct')
+                            
+                            element = StructureElement(
+                                offset=offset,
+                                vartype=vartype,
+                                bytesize=bytesize,
+                                description=description,
+                                display_method=display_method,
+                                child_struct=child_struct
+                            )
+                            elements.append(element)
+                            
+                        except (ValueError, TypeError) as e:
+                            logger.warning(f"Error parsing structure element: {e}")
+                            continue
+                
+                structure = Structure(
+                    name=name,
+                    auto_fill=auto_fill,
+                    auto_create=auto_create,
+                    default_hex=default_hex,
+                    auto_destroy=auto_destroy,
+                    elements=elements
+                )
+                structures.append(structure)
+                
+            except Exception as e:
+                logger.warning(f"Error parsing structure: {e}")
+                continue
+        
+        return structures
+    
+    def _parse_disassembler_comments(self, disassembler_elem: ET.Element) -> List[DisassemblerComment]:
+        """Parse disassembler comments from XML elements"""
+        comments = []
+        
+        for comment_elem in disassembler_elem.findall('DisassemblerComment'):
+            try:
+                address_elem = comment_elem.find('Address')
+                comment_text_elem = comment_elem.find('Comment')
+                
+                if address_elem is not None and comment_text_elem is not None:
+                    address = address_elem.text.strip() if address_elem.text else ""
+                    comment_text = comment_text_elem.text.strip() if comment_text_elem.text else ""
+                    
+                    # Clean up address format (remove quotes)
+                    address = address.strip('"\'')
+                    
+                    comment = DisassemblerComment(
+                        address=address,
+                        comment=comment_text
+                    )
+                    comments.append(comment)
+                    
+            except Exception as e:
+                logger.warning(f"Error parsing disassembler comment: {e}")
+                continue
+        
+        return comments
+    
+    def _parse_xml_entry(self, entry_elem: ET.Element) -> Optional[CheatEntry]:
+        """Parse a single cheat entry from XML"""
+        try:
+            # Get basic attributes
+            entry_id = self._get_xml_text(entry_elem, 'ID', '')
+            description = self._get_xml_text(entry_elem, 'Description', 'Unknown')
+            
+            # Remove quotes from description if present
+            description = description.strip('"\'')
+            
+            # Check if it's a group header
+            group_header = entry_elem.get('GroupHeader', '0') == '1'
+            
+            # Parse address information
+            address_text = self._get_xml_text(entry_elem, 'Address')
+            address = None
+            address_string = None
+            
+            if address_text:
+                # Handle module-relative addresses like "D2GAME.dll+1107B8"
+                if '+' in address_text:
+                    # Store the original address text for module+offset addresses
+                    address_string = address_text
+                else:
+                    # Try to parse as direct address
+                    address = self._parse_address(address_text)
+            
+            # Parse offsets
+            offsets = []
+            offsets_elem = entry_elem.find('Offsets')
+            if offsets_elem is not None:
+                for offset_elem in offsets_elem.findall('Offset'):
+                    if offset_elem.text and offset_elem.text.strip():
+                        try:
+                            offset_text = offset_elem.text.strip()
+                            if offset_text.startswith('0x'):
+                                offset_val = int(offset_text, 16)
+                            else:
+                                offset_val = int(offset_text, 16)  # Assume hex without 0x prefix
+                            offsets.append(offset_val)
+                        except ValueError:
+                            logger.warning(f"Failed to parse offset: {offset_elem.text}")
+                            continue
+            
+            # Parse variable type
+            var_type = self._get_xml_text(entry_elem, 'VariableType', '4 Bytes')
+            
+            # Parse ShowAsSigned
+            show_signed = self._get_xml_text(entry_elem, 'ShowAsSigned', '0') == '1'
+            
+            # Parse ShowAsHex
+            show_hex = self._get_xml_text(entry_elem, 'ShowAsHex', '0') == '1'
+            
+            # Parse value
+            value = None
+            value_elem = entry_elem.find('LastState')
+            if value_elem is not None and value_elem.get('Value'):
+                value = value_elem.get('Value')
+            
+            # Parse enabled state
+            enabled = entry_elem.get('Enabled', '0') == '1'
+            
+            # Parse hotkey
+            hotkey = None
+            hotkey_elem = entry_elem.find('Hotkeys/Hotkey')
+            if hotkey_elem is not None:
+                hotkey = hotkey_elem.get('Keys', '')
+            
+            # Parse script
+            script = None
+            script_elem = entry_elem.find('LuaScript')
+            if script_elem is not None and script_elem.text:
+                script = script_elem.text.strip()
+            
+            # Create entry with additional metadata
+            entry = CheatEntry(
+                id=entry_id,
+                description=description,
+                address=address,
+                address_string=address_string,
+                offsets=offsets,
+                variable_type=var_type,
+                value=value,
+                enabled=enabled,
+                hotkey=hotkey,
+                script=script,
+                group_header=group_header
+            )
+            
+            # Store additional metadata as attributes
+            entry.show_signed = show_signed
+            entry.show_hex = show_hex
+            entry.original_address = address_text
+            
+            return entry
+            
+        except Exception as e:
+            logger.warning(f"Error parsing XML entry: {e}")
+            return None
+    
+    def _get_xml_text(self, parent: ET.Element, tag: str, default: str = '') -> str:
+        """Get text content from XML element"""
+        elem = parent.find(tag)
+        if elem is not None and elem.text:
+            return elem.text.strip()
+        return default
+    
+    def _parse_binary_format(self, file_handle: BinaryIO) -> Optional[AddressList]:
+        """Parse binary format .CT file (older Cheat Engine versions)"""
+        try:
+            # This is a simplified parser for older binary format
+            # The exact format varies by CE version and can be complex
+            logger.warning("Binary .CT format parsing has limited support")
+            
+            # Try to read header
+            file_handle.seek(0)
+            data = file_handle.read()
+            
+            # Look for text patterns that might indicate addresses/descriptions
+            entries = []
+            
+            # Simple heuristic: look for potential address patterns
+            import re
+            
+            # Look for hex addresses in the binary data
+            address_pattern = rb'[0-9A-Fa-f]{8}'
+            matches = re.finditer(address_pattern, data)
+            
+            for i, match in enumerate(matches):
+                if i >= 50:  # Limit results
+                    break
+                
+                try:
+                    addr_str = match.group().decode('ascii')
+                    address = int(addr_str, 16)
+                    
+                    entry = CheatEntry(
+                        id=f"binary_entry_{i}",
+                        description=f"Address from binary table",
+                        address=address,
+                        variable_type="4 Bytes"
+                    )
+                    entries.append(entry)
+                    
+                except (ValueError, UnicodeDecodeError):
+                    continue
+            
+            return AddressList(
+                entries=entries,
+                title="Binary Cheat Table",
+                target_process=""
+            )
+            
+        except Exception as e:
+            logger.error(f"Error parsing binary format: {e}")
+            return None
+    
+    def _parse_address(self, address_str: str) -> Optional[int]:
+        """Parse an address string to integer"""
+        try:
+            if not address_str:
+                return None
+            
+            address_str = address_str.strip()
+            
+            # Handle different address formats
+            if address_str.startswith('0x'):
+                return int(address_str, 16)
+            elif address_str.startswith('$'):
+                return int(address_str[1:], 16)
+            elif all(c in '0123456789ABCDEFabcdef' for c in address_str):
+                return int(address_str, 16)
+            else:
+                # Might be a symbolic address or expression
+                return None
+                
+        except ValueError:
+            return None
+    
+    def export_to_dict(self, address_list: AddressList) -> Dict[str, Any]:
+        """Export address list to dictionary format"""
+        return {
+            'title': address_list.title,
+            'target_process': address_list.target_process,
+            'entries': [
+                {
+                    'id': entry.id,
+                    'description': entry.description,
+                    'address': entry.address_string if entry.address_string else (f"0x{entry.address:08X}" if entry.address else None),
+                    'offsets': [f"0x{offset:X}" for offset in entry.offsets],
+                    'variable_type': entry.variable_type,
+                    'value': entry.value,
+                    'enabled': entry.enabled,
+                    'hotkey': entry.hotkey,
+                    'has_script': entry.script is not None,
+                    'group_header': entry.group_header
+                }
+                for entry in address_list.entries
+            ]
+        }
+    
+    def create_mcp_tools_from_table(self, address_list: AddressList) -> List[Dict[str, Any]]:
+        """Create MCP tool definitions from cheat table entries
+        
+        Args:
+            address_list: Parsed cheat table
+            
+        Returns:
+            List of MCP tool definitions
+        """
+        tools = []
+        
+        for entry in address_list.entries:
+            if entry.group_header or (not entry.address and not entry.address_string):
+                continue
+            
+            # Create a read tool for this entry
+            tool_name = f"read_{entry.id}" if entry.id else f"read_entry_{len(tools)}"
+            tool_name = self._sanitize_tool_name(tool_name)
+            
+            tool_def = {
+                "name": tool_name,
+                "description": f"Read {entry.description} ({entry.variable_type})",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                },
+                "metadata": {
+                    "cheat_entry": {
+                        "address": entry.address_string if entry.address_string else entry.address,
+                        "offsets": entry.offsets,
+                        "type": entry.variable_type,
+                        "description": entry.description
+                    }
+                }
+            }
+            
+            tools.append(tool_def)
+        
+        return tools
+    
+    def _sanitize_tool_name(self, name: str) -> str:
+        """Sanitize a tool name for MCP compatibility"""
+        import re
+        # Replace invalid characters with underscores
+        sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+        # Ensure it starts with a letter or underscore
+        if sanitized and sanitized[0].isdigit():
+            sanitized = 'entry_' + sanitized
+        return sanitized or 'unnamed_entry'
+    
+    def get_summary(self, address_list: AddressList) -> Dict[str, Any]:
+        """Get a summary of the cheat table"""
+        entry_types = {}
+        enabled_count = 0
+        script_count = 0
+        group_count = 0
+        
+        for entry in address_list.entries:
+            # Count by type
+            var_type = entry.variable_type
+            entry_types[var_type] = entry_types.get(var_type, 0) + 1
+            
+            # Count enabled entries
+            if entry.enabled:
+                enabled_count += 1
+            
+            # Count scripts
+            if entry.script:
+                script_count += 1
+            
+            # Count groups
+            if entry.group_header:
+                group_count += 1
+        
+        return {
+            'title': address_list.title,
+            'target_process': address_list.target_process,
+            'total_entries': len(address_list.entries),
+            'enabled_entries': enabled_count,
+            'group_headers': group_count,
+            'script_entries': script_count,
+            'entry_types': entry_types,
+            'has_offsets': sum(1 for e in address_list.entries if e.offsets),
+            'has_hotkeys': sum(1 for e in address_list.entries if e.hotkey)
+        }
+    
+    def create_backup(self, file_path: str) -> str:
+        """
+        Create a backup of the cheat table file
+        
+        Args:
+            file_path: Path to the original .CT file
+            
+        Returns:
+            Path to the backup file
+        """
+        try:
+            original_path = Path(file_path)
+            if not original_path.exists():
+                raise FileNotFoundError(f"Original file not found: {file_path}")
+            
+            # Create backup filename with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_name = f"{original_path.stem}_backup_{timestamp}{original_path.suffix}"
+            backup_path = original_path.parent / backup_name
+            
+            # Copy the file
+            shutil.copy2(file_path, backup_path)
+            logger.info(f"Backup created: {backup_path}")
+            
+            return str(backup_path)
+            
+        except Exception as e:
+            logger.error(f"Error creating backup for {file_path}: {e}")
+            raise
+    
+    def add_address_to_table(self, file_path: str, new_entry: CheatEntry, create_backup: bool = True) -> bool:
+        """
+        Add a new address entry to an existing cheat table
+        
+        Args:
+            file_path: Path to the .CT file
+            new_entry: CheatEntry object to add
+            create_backup: Whether to create a backup before modifying
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            if create_backup:
+                self.create_backup(file_path)
+            
+            # Load existing table
+            address_list = self.parse_file(file_path)
+            if not address_list:
+                logger.error(f"Could not load existing table: {file_path}")
+                return False
+            
+            # Add new entry
+            address_list.entries.append(new_entry)
+            
+            # Write back to file
+            return self.write_table_to_file(file_path, address_list)
+            
+        except Exception as e:
+            logger.error(f"Error adding address to table {file_path}: {e}")
+            return False
+    
+    def write_table_to_file(self, file_path: str, address_list: 'AddressList') -> bool:
+        """
+        Write an AddressList to a .CT file in XML format
+        
+        Args:
+            file_path: Path to write the .CT file
+            address_list: AddressList object to write
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Create XML structure
+            root = ET.Element("CheatTable")
+            
+            # Add CheatEntries section
+            cheat_entries = ET.SubElement(root, "CheatEntries")
+            
+            for entry in address_list.entries:
+                self._write_cheat_entry_xml(cheat_entries, entry)
+            
+            # Add structures if available
+            if hasattr(address_list, 'structures') and address_list.structures:
+                structures_elem = ET.SubElement(root, "Structures")
+                for structure in address_list.structures:
+                    self._write_structure_xml(structures_elem, structure)
+            
+            # Add Lua script if available
+            if hasattr(address_list, 'lua_script') and address_list.lua_script:
+                lua_elem = ET.SubElement(root, "LuaScript")
+                lua_elem.text = address_list.lua_script
+            
+            # Add disassembler comments if available
+            if hasattr(address_list, 'disassembler_comments') and address_list.disassembler_comments:
+                comments_elem = ET.SubElement(root, "DisassemblerComments")
+                for comment in address_list.disassembler_comments:
+                    self._write_disassembler_comment_xml(comments_elem, comment)
+            
+            # Format XML with proper indentation
+            self._indent_xml(root)
+            
+            # Write to file
+            tree = ET.ElementTree(root)
+            tree.write(file_path, encoding='utf-8', xml_declaration=True)
+            
+            logger.info(f"Successfully wrote cheat table to: {file_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error writing table to file {file_path}: {e}")
+            return False
+    
+    def _write_cheat_entry_xml(self, parent: ET.Element, entry: CheatEntry) -> None:
+        """Write a single CheatEntry to XML"""
+        cheat_entry = ET.SubElement(parent, "CheatEntry")
+        
+        # Basic properties
+        ET.SubElement(cheat_entry, "ID").text = str(entry.id)
+        ET.SubElement(cheat_entry, "Description").text = entry.description or ""
+        
+        # Handle both numeric addresses and module+offset addresses
+        if entry.address_string:
+            # Module+offset address (e.g., "D2GAME.dll+1107B8")
+            ET.SubElement(cheat_entry, "Address").text = entry.address_string
+        elif entry.address is not None:
+            # Numeric address
+            ET.SubElement(cheat_entry, "Address").text = hex(entry.address)
+        
+        ET.SubElement(cheat_entry, "VariableType").text = entry.variable_type
+        
+        if entry.offsets:
+            offsets_elem = ET.SubElement(cheat_entry, "Offsets")
+            for offset in entry.offsets:
+                ET.SubElement(offsets_elem, "Offset").text = hex(offset)
+        
+        if entry.value is not None:
+            ET.SubElement(cheat_entry, "Value").text = str(entry.value)
+        
+        if entry.enabled:
+            ET.SubElement(cheat_entry, "Enabled").text = "1"
+        
+        if entry.hotkey:
+            ET.SubElement(cheat_entry, "Hotkey").text = entry.hotkey
+        
+        if entry.script:
+            ET.SubElement(cheat_entry, "Script").text = entry.script
+        
+        if entry.group_header:
+            ET.SubElement(cheat_entry, "GroupHeader").text = "1"
+    
+    def _write_structure_xml(self, parent: ET.Element, structure: Structure) -> None:
+        """Write a Structure to XML"""
+        struct_elem = ET.SubElement(parent, "Structure")
+        struct_elem.set("Name", structure.name)
+        struct_elem.set("AutoFill", "1" if structure.auto_fill else "0")
+        struct_elem.set("AutoCreate", "1" if structure.auto_create else "0")
+        struct_elem.set("DefaultHex", "1" if structure.default_hex else "0")
+        struct_elem.set("AutoDestroy", "1" if structure.auto_destroy else "0")
+        
+        elements_elem = ET.SubElement(struct_elem, "Elements")
+        for element in structure.elements:
+            elem = ET.SubElement(elements_elem, "Element")
+            elem.set("Offset", hex(element.offset))
+            elem.set("Vartype", element.vartype)
+            elem.set("Bytesize", str(element.bytesize))
+            elem.set("Description", element.description)
+            elem.set("DisplayMethod", element.display_method)
+            if element.child_struct:
+                elem.set("ChildStruct", element.child_struct)
+    
+    def _write_disassembler_comment_xml(self, parent: ET.Element, comment: 'DisassemblerComment') -> None:
+        """Write a DisassemblerComment to XML"""
+        comment_elem = ET.SubElement(parent, "Comment")
+        comment_elem.set("Address", comment.address)
+        comment_elem.text = comment.comment
+    
+    def _indent_xml(self, elem: ET.Element, level: int = 0) -> None:
+        """Add proper indentation to XML for readability"""
+        i = "\n" + level * "  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for elem in elem:
+                self._indent_xml(elem, level + 1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i
+    
+    def modify_address_in_table(self, file_path: str, entry_id: str, updated_entry: CheatEntry, create_backup: bool = True) -> bool:
+        """
+        Modify an existing address entry in a cheat table
+        
+        Args:
+            file_path: Path to the .CT file
+            entry_id: ID of the entry to modify
+            updated_entry: Updated CheatEntry object
+            create_backup: Whether to create a backup before modifying
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            if create_backup:
+                self.create_backup(file_path)
+            
+            # Load existing table
+            address_list = self.parse_file(file_path)
+            if not address_list:
+                logger.error(f"Could not load existing table: {file_path}")
+                return False
+            
+            # Find and update entry
+            found = False
+            for i, entry in enumerate(address_list.entries):
+                if entry.id == entry_id:
+                    address_list.entries[i] = updated_entry
+                    found = True
+                    break
+            
+            if not found:
+                logger.error(f"Entry with ID {entry_id} not found")
+                return False
+            
+            # Write back to file
+            return self.write_table_to_file(file_path, address_list)
+            
+        except Exception as e:
+            logger.error(f"Error modifying address in table {file_path}: {e}")
+            return False
+    
+    def remove_address_from_table(self, file_path: str, entry_id: str, create_backup: bool = True) -> bool:
+        """
+        Remove an address entry from a cheat table
+        
+        Args:
+            file_path: Path to the .CT file
+            entry_id: ID of the entry to remove
+            create_backup: Whether to create a backup before modifying
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            if create_backup:
+                self.create_backup(file_path)
+            
+            # Load existing table
+            address_list = self.parse_file(file_path)
+            if not address_list:
+                logger.error(f"Could not load existing table: {file_path}")
+                return False
+            
+            # Find and remove entry
+            original_count = len(address_list.entries)
+            address_list.entries = [entry for entry in address_list.entries if entry.id != entry_id]
+            
+            if len(address_list.entries) == original_count:
+                logger.error(f"Entry with ID {entry_id} not found")
+                return False
+            
+            # Write back to file
+            return self.write_table_to_file(file_path, address_list)
+            
+        except Exception as e:
+            logger.error(f"Error removing address from table {file_path}: {e}")
+            return False
+    
+    def create_new_table(self, file_path: str, title: str = "New Cheat Table", target_process: str = "") -> bool:
+        """
+        Create a new empty cheat table file
+        
+        Args:
+            file_path: Path where to create the .CT file
+            title: Title for the cheat table
+            target_process: Target process name
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Create empty AddressList
+            address_list = AddressList(
+                title=title,
+                target_process=target_process,
+                entries=[]
+            )
+            
+            # Write to file
+            return self.write_table_to_file(file_path, address_list)
+            
+        except Exception as e:
+            logger.error(f"Error creating new table {file_path}: {e}")
+            return False
+    
+    def write_cheat_table_preserving_structure(self, file_path: str, cheat_table: 'CheatTable') -> bool:
+        """
+        Write a CheatTable to file while preserving original XML structure
+        Only modifies the parts that have been changed
+        
+        Args:
+            file_path: Path to write the .CT file
+            cheat_table: CheatTable object to write
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            if cheat_table._original_xml_root is not None:
+                # Use original XML structure and modify only changed parts
+                return self._write_preserving_original_xml(file_path, cheat_table)
+            else:
+                # Create new XML structure
+                return self._write_new_xml_structure(file_path, cheat_table)
+                
+        except Exception as e:
+            logger.error(f"Error writing cheat table to file {file_path}: {e}")
+            return False
+    
+    def _write_preserving_original_xml(self, file_path: str, cheat_table: 'CheatTable') -> bool:
+        """Write using original XML structure, modifying only changed parts"""
+        try:
+            # Create a copy of the original XML root
+            import copy
+            root = copy.deepcopy(cheat_table._original_xml_root)
+            
+            # Update CheatEntries section
+            cheat_entries_elem = root.find('CheatEntries')
+            if cheat_entries_elem is not None:
+                # Clear existing entries and add updated ones
+                cheat_entries_elem.clear()
+                for entry in cheat_table.entries:
+                    self._write_cheat_entry_xml(cheat_entries_elem, entry)
+            else:
+                # Create CheatEntries section if it doesn't exist
+                cheat_entries_elem = ET.SubElement(root, 'CheatEntries')
+                for entry in cheat_table.entries:
+                    self._write_cheat_entry_xml(cheat_entries_elem, entry)
+            
+            # Update Structures section if modified
+            structures_elem = root.find('Structures')
+            if cheat_table.structures:
+                if structures_elem is None:
+                    structures_elem = ET.SubElement(root, 'Structures')
+                else:
+                    structures_elem.clear()
+                
+                for structure in cheat_table.structures:
+                    self._write_structure_xml(structures_elem, structure)
+            
+            # Update Lua script if modified
+            lua_elem = root.find('LuaScript')
+            if cheat_table.lua_script:
+                if lua_elem is None:
+                    lua_elem = ET.SubElement(root, 'LuaScript')
+                lua_elem.text = cheat_table.lua_script
+            
+            # Update disassembler comments if modified
+            comments_elem = root.find('DisassemblerComments')
+            if cheat_table.disassembler_comments:
+                if comments_elem is None:
+                    comments_elem = ET.SubElement(root, 'DisassemblerComments')
+                else:
+                    comments_elem.clear()
+                
+                for comment in cheat_table.disassembler_comments:
+                    self._write_disassembler_comment_xml(comments_elem, comment)
+            
+            # Preserve XML formatting
+            self._preserve_xml_formatting(root)
+            
+            # Write to file with original encoding and declaration
+            tree = ET.ElementTree(root)
+            
+            # Try to preserve original XML declaration
+            if cheat_table._original_xml_content and cheat_table._original_xml_content.startswith('<?xml'):
+                # Extract and preserve original XML declaration
+                xml_decl_end = cheat_table._original_xml_content.find('?>') + 2
+                xml_declaration = cheat_table._original_xml_content[:xml_decl_end]
+                
+                # Write with preserved declaration
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(xml_declaration + '\n')
+                    tree.write(f, encoding='unicode', xml_declaration=False)
+            else:
+                tree.write(file_path, encoding='utf-8', xml_declaration=True)
+            
+            logger.info(f"Successfully wrote cheat table preserving structure to: {file_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error writing with preserved structure: {e}")
+            return False
+    
+    def _write_new_xml_structure(self, file_path: str, cheat_table: 'CheatTable') -> bool:
+        """Write using new XML structure"""
+        try:
+            # Create XML structure
+            root = ET.Element("CheatTable")
+            
+            # Add CheatEntries section
+            cheat_entries = ET.SubElement(root, "CheatEntries")
+            
+            for entry in cheat_table.entries:
+                self._write_cheat_entry_xml(cheat_entries, entry)
+            
+            # Add structures if available
+            if cheat_table.structures:
+                structures_elem = ET.SubElement(root, "Structures")
+                for structure in cheat_table.structures:
+                    self._write_structure_xml(structures_elem, structure)
+            
+            # Add Lua script if available
+            if cheat_table.lua_script:
+                lua_elem = ET.SubElement(root, "LuaScript")
+                lua_elem.text = cheat_table.lua_script
+            
+            # Add disassembler comments if available
+            if cheat_table.disassembler_comments:
+                comments_elem = ET.SubElement(root, "DisassemblerComments")
+                for comment in cheat_table.disassembler_comments:
+                    self._write_disassembler_comment_xml(comments_elem, comment)
+            
+            # Format XML with proper indentation
+            self._indent_xml(root)
+            
+            # Write to file
+            tree = ET.ElementTree(root)
+            tree.write(file_path, encoding='utf-8', xml_declaration=True)
+            
+            logger.info(f"Successfully wrote new cheat table structure to: {file_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error writing new XML structure: {e}")
+            return False
+    
+    def _preserve_xml_formatting(self, elem: ET.Element, level: int = 0) -> None:
+        """Preserve XML formatting similar to original"""
+        i = "\n" + level * "  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for child in elem:
+                self._preserve_xml_formatting(child, level + 1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i
+    
+    def add_address_to_cheat_table(self, file_path: str, new_entry: CheatEntry, create_backup: bool = True) -> bool:
+        """
+        Add a new address entry to an existing cheat table with structure preservation
+        
+        Args:
+            file_path: Path to the .CT file
+            new_entry: CheatEntry object to add
+            create_backup: Whether to create a backup before modifying
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            if create_backup:
+                self.create_backup(file_path)
+            
+            # Load existing table with full structure preservation
+            cheat_table = self.parse_file(file_path)
+            if not cheat_table:
+                logger.error(f"Could not load existing table: {file_path}")
+                return False
+            
+            # Add new entry
+            cheat_table.entries.append(new_entry)
+            
+            # Write back to file preserving structure
+            return self.write_cheat_table_preserving_structure(file_path, cheat_table)
+            
+        except Exception as e:
+            logger.error(f"Error adding address to table {file_path}: {e}")
+            return False
+    
+    def parse_file_to_addresslist(self, file_path: str) -> Optional['AddressList']:
+        """
+        Parse a .CT file and return an AddressList object (for backwards compatibility)
+        
+        Args:
+            file_path: Path to the .CT file
+            
+        Returns:
+            AddressList object or None if parsing failed
+        """
+        cheat_table = self.parse_file(file_path)
+        if cheat_table:
+            return self._convert_cheattable_to_addresslist(cheat_table)
+        return None
+    
+    def _convert_cheattable_to_addresslist(self, cheat_table: 'CheatTable') -> 'AddressList':
+        """Convert CheatTable to AddressList for backwards compatibility"""
+        address_list = AddressList(
+            title=cheat_table.title,
+            target_process=cheat_table.target_process,
+            entries=cheat_table.entries
+        )
+        address_list.structures = cheat_table.structures
+        address_list.lua_script = cheat_table.lua_script
+        address_list.disassembler_comments = cheat_table.disassembler_comments
+        return address_list