rom24-quickmud-python 1.2.2__py3-none-any.whl

mud/loaders/json_area_loader.py

@@ -0,0 +1,203 @@
+"""JSON area loader - loads areas from converted JSON files."""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+from mud.models.area_json import AreaJson
+from mud.models.json_io import load_dataclass
+from mud.models.area import Area
+from mud.models.room import Room, Exit, ExtraDescr
+from mud.models.mob import MobIndex
+from mud.models.obj import ObjIndex
+from mud.registry import room_registry, mob_registry, obj_registry, area_registry
+
+
+def load_area_from_json(json_file_path: str) -> Area:
+    """Load an area from a JSON file and populate registries."""
+    
+    with open(json_file_path, 'r', encoding='utf-8') as f:
+        # Load raw JSON data instead of using the dataclass loader to handle missing fields
+        data = json.load(f)
+    
+    # Create the Area object
+    area = Area(
+        file_name=Path(json_file_path).name,
+        name=data.get('name', 'Unknown Area'),
+        min_vnum=data.get('vnum_range', {}).get('min', 0),
+        max_vnum=data.get('vnum_range', {}).get('max', 0),
+        builders=', '.join(data.get('builders', [])),
+        vnum=data.get('vnum_range', {}).get('min', 0),
+        age=15,  # Default age for areas
+        empty=False
+    )
+    
+    # Register the area
+    area_key = area.min_vnum
+    if (
+        area_key != 0
+        and area_key in area_registry
+        and area_registry[area_key].file_name != area.file_name
+    ):
+        raise ValueError(f"duplicate area vnum {area_key}")
+    area_registry[area_key] = area
+    
+    # Load rooms
+    for room_data in data.get('rooms', []):
+        room = _json_to_room(room_data, area)
+        room_registry[room.vnum] = room
+    
+    # Load mobiles
+    for mob_data in data.get('mobiles', []):
+        mob = _json_to_mob(mob_data, area)
+        mob_registry[mob.vnum] = mob
+    
+    # Load objects  
+    for obj_data in data.get('objects', []):
+        obj = _json_to_obj(obj_data, area)
+        obj_registry[obj.vnum] = obj
+    
+    return area
+
+
+def _json_to_room(room_data: Dict[str, Any], area: Area) -> Room:
+    """Convert room JSON data to Room model."""
+    room = Room(
+        vnum=room_data.get('id', 0),
+        name=room_data.get('name', 'Unnamed Room'),
+        description=room_data.get('description', 'No description.'),
+        area=area,
+        sector_type=_sector_name_to_int(room_data.get('sector_type', 'inside')),
+        room_flags=_flags_to_int(room_data.get('flags', []))
+    )
+    
+    # Handle exits - initialize with None for all directions
+    room.exits = [None] * 10
+    exits_data = room_data.get('exits', {})
+    if exits_data:
+        direction_map = {
+            'north': 0, 'east': 1, 'south': 2, 'west': 3, 'up': 4, 'down': 5,
+            'northeast': 6, 'northwest': 7, 'southeast': 8, 'southwest': 9
+        }
+        
+        for direction, exit_data in exits_data.items():
+            if direction in direction_map:
+                dir_num = direction_map[direction]
+                exit = Exit(
+                    vnum=exit_data.get('to_room', 0),
+                    exit_info=_flags_to_int(exit_data.get('flags', [])),
+                    keyword=exit_data.get('keyword'),
+                    description=exit_data.get('description')
+                )
+                room.exits[dir_num] = exit
+    
+    # Handle extra descriptions
+    extra_descriptions = room_data.get('extra_descriptions', [])
+    for extra_desc in extra_descriptions:
+        room.extra_descr.append(ExtraDescr(
+            keyword=extra_desc.get('keyword'),
+            description=extra_desc.get('description')
+        ))
+    
+    return room
+
+
+def _json_to_mob(mob_data: Dict[str, Any], area: Area) -> MobIndex:
+    """Convert mobile JSON data to MobIndex model."""
+    mob = MobIndex(
+        vnum=mob_data.get('id', 0),
+        player_name=mob_data.get('name', 'unnamed mobile'),
+        short_descr=mob_data.get('short_description', mob_data.get('name', 'unnamed mobile')),
+        long_descr=mob_data.get('long_description', ''),
+        description=mob_data.get('description', 'No description.'),
+        area=area,
+        level=mob_data.get('level', 1),
+        alignment=mob_data.get('alignment', 0),
+        act=_flags_to_int(mob_data.get('flags', [])),
+        new_format=True
+    )
+    
+    return mob
+
+
+def _json_to_obj(obj_data: Dict[str, Any], area: Area) -> ObjIndex:
+    """Convert object JSON data to ObjIndex model.""" 
+    obj = ObjIndex(
+        vnum=obj_data.get('id', 0),
+        name=obj_data.get('name', 'unnamed object'),
+        short_descr=obj_data.get('short_description', obj_data.get('name', 'unnamed object')),
+        description=obj_data.get('description', 'No description.'),
+        area=area,
+        item_type=_item_type_to_int(obj_data.get('item_type', 'trash')),
+        extra_flags=_flags_to_int(obj_data.get('flags', [])),
+        wear_flags=_flags_to_int(obj_data.get('wear_flags', [])),
+        level=obj_data.get('level', 0),
+        weight=obj_data.get('weight', 0),
+        cost=obj_data.get('cost', 0),
+        material=obj_data.get('material', 'unknown')
+    )
+    
+    # Handle values array
+    values = obj_data.get('values', [0, 0, 0, 0, 0])
+    obj.value = values[:5] if len(values) >= 5 else values + [0] * (5 - len(values))
+    
+    return obj
+
+
+def _sector_name_to_int(sector_name: str) -> int:
+    """Convert sector name to integer."""
+    sector_map = {
+        'inside': 0, 'city': 1, 'field': 2, 'forest': 3, 'hills': 4,
+        'mountain': 5, 'water_swim': 6, 'water_noswim': 7, 'underwater': 8, 'air': 9,
+        'desert': 10, 'unknown': 11
+    }
+    return sector_map.get(sector_name, 0)
+
+
+def _item_type_to_int(item_type: str) -> int:
+    """Convert item type name to integer."""
+    type_map = {
+        'light': 1, 'scroll': 2, 'wand': 3, 'staff': 4, 'weapon': 5,
+        'fireweapon': 6, 'missile': 7, 'treasure': 8, 'armor': 9, 'potion': 10,
+        'clothing': 11, 'furniture': 12, 'trash': 13, 'oldtrap': 14, 'container': 15,
+        'note': 16, 'drinkcon': 17, 'key': 18, 'food': 19, 'money': 20,
+        'pen': 21, 'boat': 22, 'corpse': 23, 'corpse_pc': 24, 'fountain': 25,
+        'pill': 26, 'protect': 27, 'map': 28, 'portal': 29, 'warp_stone': 30,
+        'room_key': 31, 'gem': 32, 'jewelry': 33, 'jukebox': 34
+    }
+    return type_map.get(item_type, 13)  # Default to 'trash'
+
+
+def _flags_to_int(flags_list) -> int:
+    """Convert list of flag names to integer bitfield."""
+    if not flags_list:
+        return 0
+    
+    # For now, return 0 as we don't have the flag mappings
+    # This can be extended later with proper flag name to bit mappings
+    return 0
+
+
+def load_all_areas_from_json(areas_dir: str = "data/areas") -> None:
+    """Load all areas from JSON files in the specified directory."""
+    areas_path = Path(areas_dir)
+    
+    if not areas_path.exists():
+        raise FileNotFoundError(f"Areas directory not found: {areas_dir}")
+    
+    json_files = list(areas_path.glob("*.json"))
+    if not json_files:
+        raise FileNotFoundError(f"No JSON files found in: {areas_dir}")
+    
+    print(f"Loading {len(json_files)} areas from JSON files...")
+    
+    for json_file in sorted(json_files):
+        try:
+            area = load_area_from_json(str(json_file))
+            print(f"✅ Loaded area: {area.name} ({area.min_vnum}-{area.max_vnum})")
+        except Exception as e:
+            print(f"❌ Failed to load {json_file.name}: {e}")
+            raise
+    
+    print(f"🎯 Successfully loaded {len(area_registry)} areas, {len(room_registry)} rooms, "
+          f"{len(mob_registry)} mobs, {len(obj_registry)} objects")

mud/loaders/json_loader.py

@@ -0,0 +1,285 @@
+"""
+JSON area loader for QuickMUD.
+
+This loader reads areas from JSON files created by the convert_are_to_json.py script
+with complete field mapping from the original ROM .are format.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, Any, List
+
+from ..models.area import Area
+from ..models.room import Room, Exit, ExtraDescr
+from ..models.mob import MobIndex  
+from ..models.obj import ObjIndex, Affect
+from ..models.room_json import ResetJson
+from mud.models.constants import Direction, Sector, Sex, ITEM_INVENTORY
+from mud.registry import area_registry, room_registry, mob_registry, obj_registry
+
+
+def _rom_flags_to_int(flags_str: str) -> int:
+    """Convert ROM-style letter flags to integer bitfield.
+    
+    ROM uses letters A-Z and aa-dd to represent bit positions:
+    A=1<<0, B=1<<1, ..., Z=1<<25, aa=1<<26, bb=1<<27, cc=1<<28, dd=1<<29
+    """
+    if not flags_str or flags_str == '0':
+        return 0
+    
+    result = 0
+    
+    # Handle single characters and double characters
+    i = 0
+    while i < len(flags_str):
+        if i + 1 < len(flags_str) and flags_str[i:i+2] in ['aa', 'bb', 'cc', 'dd']:
+            # Double character flags (26-29)
+            double_char = flags_str[i:i+2]
+            if double_char == 'aa':
+                result |= 1 << 26
+            elif double_char == 'bb':
+                result |= 1 << 27
+            elif double_char == 'cc':
+                result |= 1 << 28
+            elif double_char == 'dd':
+                result |= 1 << 29
+            i += 2
+        else:
+            # Single character flags (0-25)
+            char = flags_str[i]
+            if 'A' <= char <= 'Z':
+                result |= 1 << (ord(char) - ord('A'))
+            elif 'a' <= char <= 'z':
+                result |= 1 << (ord(char) - ord('a'))
+            i += 1
+    
+    return result
+
+logger = logging.getLogger(__name__)
+
+
+def load_area_from_json(json_file_path: str) -> Area:
+    """Load a complete area from JSON file with all ROM fields."""
+    
+    with open(json_file_path, 'r') as f:
+        data = json.load(f)
+    
+    # Handle two different JSON formats
+    if 'area' in data:
+        # Format 2: Nested structure with area object
+        area_data = data['area']
+        area = Area(
+            vnum=area_data.get('vnum', 0),
+            name=area_data.get('name', ''),
+            file_name=area_data.get('filename', Path(json_file_path).stem),
+            low_range=area_data.get('min_level', 0),
+            high_range=area_data.get('max_level', 0),
+            builders=area_data.get('builders', ''),
+            credits=area_data.get('credits', ''),
+            min_vnum=area_data.get('min_vnum', area_data.get('vnum', 0)),
+            max_vnum=area_data.get('max_vnum', area_data.get('vnum', 0)),
+            area_flags=area_data.get('area_flags', 0),
+            security=area_data.get('security', 0),
+        )
+        rooms_key = 'rooms'
+        mobs_key = 'mobs'
+        objects_key = 'objects'
+    else:
+        # Format 1: Root-level structure with vnum_range
+        vnum_range = data.get('vnum_range', {'min': 0, 'max': 0})
+        area = Area(
+            vnum=vnum_range.get('min', 0),  # Use min vnum as area vnum
+            name=data.get('name', ''),
+            file_name=Path(json_file_path).stem,
+            low_range=vnum_range.get('min', 0),
+            high_range=vnum_range.get('max', 0),
+            builders=', '.join(data.get('builders', [])),
+            min_vnum=vnum_range.get('min', 0),
+            max_vnum=vnum_range.get('max', 0),
+            area_flags=0,  # Not in JSON, default to 0
+            security=0,    # Not in JSON, default to 0
+        )
+        rooms_key = 'rooms'
+        mobs_key = 'mobiles'  # Different key in format 1
+        objects_key = 'objects'
+    
+    # Register area
+    area_registry[area.vnum] = area
+    
+    # Load rooms
+    _load_rooms_from_json(data.get(rooms_key, []), area)
+    
+    # Load mobs
+    _load_mobs_from_json(data.get(mobs_key, []), area)
+    
+    # Load objects
+    _load_objects_from_json(data.get(objects_key, []), area)
+    
+    # Load area-level resets
+    for reset_data in data.get('resets', []):
+        reset = ResetJson(
+            command=reset_data['command'],
+            arg1=reset_data['arg1'],
+            arg2=reset_data['arg2'],
+            arg3=reset_data['arg3'],
+            arg4=reset_data['arg4'],
+        )
+        area.resets.append(reset)
+    
+    logger.info(f"Loaded area {area.name} from JSON with {len(data.get(rooms_key, []))} rooms, "
+               f"{len(data.get(mobs_key, []))} mobs, {len(data.get(objects_key, []))} objects, "
+               f"{len(data.get('resets', []))} resets")
+    
+    return area
+
+
+def _load_rooms_from_json(rooms_data: List[Dict[str, Any]], area: Area) -> None:
+    """Load rooms from JSON data with complete field mapping."""
+    
+    for room_data in rooms_data:
+        # Parse sector type
+        sector_str = room_data.get('sector_type', 'inside')
+        try:
+            if sector_str.isdigit():
+                sector = Sector(int(sector_str))
+            else:
+                sector = Sector[sector_str.upper()]
+        except (ValueError, KeyError):
+            logger.warning(f"Unknown sector type: {sector_str}, defaulting to INSIDE")
+            sector = Sector.INSIDE
+        
+        # Create room
+        room = Room(
+            vnum=room_data['id'],
+            name=room_data.get('name', ''),
+            description=room_data.get('description', ''),
+            sector_type=sector,
+            room_flags=room_data.get('flags', 0),
+            area=area,
+        )
+        
+        # Load exits
+        exits_data = room_data.get('exits', {})
+        for direction_name, exit_data in exits_data.items():
+            try:
+                direction = Direction[direction_name.upper()]
+                exit_obj = Exit(
+                    vnum=exit_data.get('to_room', 0),
+                    description=exit_data.get('description', ''),
+                    keyword=exit_data.get('keyword', ''),
+                    flags=exit_data.get('flags', '0'),
+                    key=exit_data.get('key', 0),
+                )
+                room.exits[direction.value] = exit_obj
+            except KeyError:
+                logger.warning(f"Unknown direction: {direction_name}")
+        
+        # Load extra descriptions
+        for extra_data in room_data.get('extra_descriptions', []):
+            extra_desc = ExtraDescr(
+                keyword=extra_data['keyword'],
+                description=extra_data['description']
+            )
+            room.extra_descr.append(extra_desc)
+        
+        room_registry[room.vnum] = room
+
+
+def _load_mobs_from_json(mobs_data: List[Dict[str, Any]], area: Area) -> None:
+    """Load mobs from JSON data with complete field mapping."""
+    
+    for mob_data in mobs_data:
+        # Parse sex
+        sex_str = mob_data.get('sex', 'none')
+        try:
+            sex = Sex[sex_str.upper()]
+        except KeyError:
+            logger.warning(f"Unknown sex: {sex_str}, defaulting to NONE")
+            sex = Sex.NONE
+        
+        # Create mob with all fields
+        mob = MobIndex(
+            vnum=mob_data['id'],
+            player_name=mob_data.get('player_name', ''),
+            short_descr=mob_data.get('name', ''),
+            long_descr=mob_data.get('long_description', ''),
+            description=mob_data.get('description', ''),
+            race=mob_data.get('race', ''),
+            act_flags=mob_data.get('act_flags', ''),
+            affected_by=mob_data.get('affected_by', ''),
+            alignment=mob_data.get('alignment', 0),
+            group=mob_data.get('group', 0),
+            level=mob_data.get('level', 1),
+            thac0=mob_data.get('thac0', 20),
+            ac=mob_data.get('ac', '1d1+0'),
+            hit_dice=mob_data.get('hit_dice', '1d1+0'),
+            mana_dice=mob_data.get('mana_dice', '1d1+0'),
+            damage_dice=mob_data.get('damage_dice', '1d4+0'),
+            damage_type=mob_data.get('damage_type', 'beating'),
+            ac_pierce=mob_data.get('ac_pierce', 0),
+            ac_bash=mob_data.get('ac_bash', 0),
+            ac_slash=mob_data.get('ac_slash', 0),
+            ac_exotic=mob_data.get('ac_exotic', 0),
+            offensive=mob_data.get('offensive', ''),
+            immune=mob_data.get('immune', ''),
+            resist=mob_data.get('resist', ''),
+            vuln=mob_data.get('vuln', ''),
+            start_pos=mob_data.get('start_pos', 'standing'),
+            default_pos=mob_data.get('default_pos', 'standing'),
+            sex=sex,
+            wealth=mob_data.get('wealth', 0),
+            form=mob_data.get('form', '0'),
+            parts=mob_data.get('parts', '0'),
+            size=mob_data.get('size', 'medium'),
+            material=mob_data.get('material', '0'),
+            area=area,
+        )
+        
+        mob_registry[mob.vnum] = mob
+
+
+def _load_objects_from_json(objects_data: List[Dict[str, Any]], area: Area) -> None:
+    """Load objects from JSON data with complete field mapping."""
+    
+    for obj_data in objects_data:
+        # Create object with all fields
+        obj = ObjIndex(
+            vnum=obj_data['id'],
+            short_descr=obj_data.get('name', ''),
+            description=obj_data.get('description', ''),
+            material=obj_data.get('material', ''),
+            item_type=obj_data.get('item_type', 'trash'),
+            extra_flags=_rom_flags_to_int(obj_data.get('extra_flags', '')),
+            wear_flags=obj_data.get('wear_flags', ''),
+            weight=obj_data.get('weight', 0),
+            cost=obj_data.get('cost', 0),
+            condition=obj_data.get('condition', 'P'),
+            value=obj_data.get('values', [0, 0, 0, 0, 0]),
+            affects=obj_data.get('affects', []),
+            extra_descr=obj_data.get('extra_descriptions', []),
+            area=area,
+        )
+        
+        obj_registry[obj.vnum] = obj
+
+
+def load_all_areas_from_json(json_dir: str) -> Dict[int, Area]:
+    """Load all areas from JSON files in a directory."""
+    
+    json_path = Path(json_dir)
+    if not json_path.exists():
+        logger.error(f"JSON directory not found: {json_dir}")
+        return {}
+    
+    areas = {}
+    
+    for json_file in json_path.glob("*.json"):
+        try:
+            area = load_area_from_json(str(json_file))
+            areas[area.vnum] = area
+        except Exception as e:
+            logger.error(f"Failed to load {json_file}: {e}")
+    
+    logger.info(f"Loaded {len(areas)} areas from JSON")
+    return areas

mud/loaders/mob_loader.py

@@ -0,0 +1,104 @@
+from mud.models.mob import MobIndex
+from mud.registry import mob_registry
+from .base_loader import BaseTokenizer
+
+
+def load_mobiles(tokenizer: BaseTokenizer, area):
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        if line.startswith('#'):
+            if line == '#0' or line.startswith('#$'):
+                break
+            vnum = int(line[1:])
+            player_name = tokenizer.next_line().rstrip('~')
+            short_descr = tokenizer.next_line().rstrip('~')
+            long_descr = tokenizer.read_string_tilde()
+            desc = tokenizer.read_string_tilde()
+            race = tokenizer.next_line().rstrip('~')
+            
+            # Parse act flags, affected flags, alignment, group
+            act_line = tokenizer.next_line().split()
+            act_flags = act_line[0] if len(act_line) > 0 else ''
+            affected_by = act_line[1] if len(act_line) > 1 else ''
+            alignment = int(act_line[2]) if len(act_line) > 2 and act_line[2].lstrip('-').isdigit() else 0
+            group = int(act_line[3]) if len(act_line) > 3 and act_line[3].isdigit() else 0
+            
+            # Parse level, thac0, ac, hitnodice, hitdicenum, hitdicesides, manadice, damroll, damdice
+            stats_line = tokenizer.next_line().split()
+            level = int(stats_line[0]) if len(stats_line) > 0 and stats_line[0].isdigit() else 1
+            thac0 = int(stats_line[1]) if len(stats_line) > 1 and stats_line[1].lstrip('-').isdigit() else 20
+            ac = stats_line[2] if len(stats_line) > 2 else '1d1+0'
+            hit_dice = stats_line[3] if len(stats_line) > 3 else '1d1+0'  
+            mana_dice = stats_line[4] if len(stats_line) > 4 else '1d1+0'
+            damage_dice = stats_line[5] if len(stats_line) > 5 else '1d4+0'
+            damage_type = stats_line[6] if len(stats_line) > 6 else 'beating'
+            
+            # Parse armor class values
+            ac_line = tokenizer.next_line().split()
+            ac_pierce = int(ac_line[0]) if len(ac_line) > 0 and ac_line[0].lstrip('-').isdigit() else 0
+            ac_bash = int(ac_line[1]) if len(ac_line) > 1 and ac_line[1].lstrip('-').isdigit() else 0
+            ac_slash = int(ac_line[2]) if len(ac_line) > 2 and ac_line[2].lstrip('-').isdigit() else 0  
+            ac_exotic = int(ac_line[3]) if len(ac_line) > 3 and ac_line[3].lstrip('-').isdigit() else 0
+            
+            # Parse off/imm/res/vuln flags
+            flags_line = tokenizer.next_line().split()
+            offensive = flags_line[0] if len(flags_line) > 0 else ''
+            immune = flags_line[1] if len(flags_line) > 1 else ''
+            resist = flags_line[2] if len(flags_line) > 2 else ''
+            vuln = flags_line[3] if len(flags_line) > 3 else ''
+            
+            # Parse position, sex, wealth
+            pos_line = tokenizer.next_line().split()
+            start_pos = pos_line[0] if len(pos_line) > 0 else 'standing'
+            default_pos = pos_line[1] if len(pos_line) > 1 else 'standing'
+            sex = pos_line[2] if len(pos_line) > 2 else 'neutral'
+            wealth = int(pos_line[3]) if len(pos_line) > 3 and pos_line[3].isdigit() else 0
+            
+            # Parse form/parts/size/material
+            form_line = tokenizer.next_line().split()
+            form = form_line[0] if len(form_line) > 0 else '0'
+            parts = form_line[1] if len(form_line) > 1 else '0' 
+            size = form_line[2] if len(form_line) > 2 else 'medium'
+            material = form_line[3] if len(form_line) > 3 else '0'
+            
+            mob = MobIndex(
+                vnum=vnum, 
+                player_name=player_name, 
+                short_descr=short_descr, 
+                long_descr=long_descr, 
+                description=desc, 
+                race=race,
+                act_flags=act_flags,
+                affected_by=affected_by,
+                alignment=alignment,
+                group=group,
+                level=level,
+                thac0=thac0,
+                ac=ac,
+                hit_dice=hit_dice,
+                mana_dice=mana_dice,
+                damage_dice=damage_dice,
+                damage_type=damage_type,
+                ac_pierce=ac_pierce,
+                ac_bash=ac_bash,
+                ac_slash=ac_slash,
+                ac_exotic=ac_exotic,
+                offensive=offensive,
+                immune=immune,
+                resist=resist,
+                vuln=vuln,
+                start_pos=start_pos,
+                default_pos=default_pos,
+                sex=sex,
+                wealth=wealth,
+                form=form,
+                parts=parts,
+                size=size,
+                material=material,
+                area=area
+            )
+            mob_registry[vnum] = mob
+        elif line == '$':
+            break

mud/loaders/obj_loader.py

@@ -0,0 +1,76 @@
+from mud.models.obj import ObjIndex
+from mud.registry import obj_registry
+from .base_loader import BaseTokenizer
+
+
+def load_objects(tokenizer: BaseTokenizer, area):
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        if line.startswith('#'):
+            if line == '#0' or line.startswith('#$'):
+                break
+            vnum = int(line[1:])
+            name = tokenizer.next_line().rstrip('~')
+            short_descr = tokenizer.next_line().rstrip('~')
+            desc = tokenizer.read_string_tilde()
+            extra = tokenizer.read_string_tilde()
+            
+            # Parse item type and extra flags
+            type_flags_line = tokenizer.next_line().split()
+            item_type = type_flags_line[0] if len(type_flags_line) > 0 else 'trash'
+            extra_flags = type_flags_line[1] if len(type_flags_line) > 1 else ''
+            wear_flags = type_flags_line[2] if len(type_flags_line) > 2 else ''
+            
+            # Parse values
+            values_line = tokenizer.next_line().split()
+            value0 = int(values_line[0]) if len(values_line) > 0 and values_line[0].lstrip('-').isdigit() else 0
+            value1 = int(values_line[1]) if len(values_line) > 1 and values_line[1].lstrip('-').isdigit() else 0
+            value2 = int(values_line[2]) if len(values_line) > 2 and values_line[2].lstrip('-').isdigit() else 0
+            value3 = int(values_line[3]) if len(values_line) > 3 and values_line[3].lstrip('-').isdigit() else 0
+            value4 = int(values_line[4]) if len(values_line) > 4 and values_line[4].lstrip('-').isdigit() else 0
+            
+            # Parse weight, cost, condition
+            weight_cost = tokenizer.next_line().split()
+            weight = int(weight_cost[0]) if len(weight_cost) > 0 and weight_cost[0].isdigit() else 0
+            cost = int(weight_cost[1]) if len(weight_cost) > 1 and weight_cost[1].isdigit() else 0
+            condition = weight_cost[2] if len(weight_cost) > 2 else 'P'
+            
+            obj = ObjIndex(
+                vnum=vnum,
+                name=name,
+                short_descr=short_descr,
+                description=desc,
+                material=extra,
+                item_type=item_type,
+                extra_flags=extra_flags,
+                wear_flags=wear_flags,
+                value=[value0, value1, value2, value3, value4],
+                weight=weight,
+                cost=cost,
+                condition=condition,
+                area=area,
+            )
+            obj_registry[vnum] = obj
+            
+            # Process extra descriptions and affects
+            while True:
+                peek = tokenizer.peek_line()
+                if peek is None or peek.startswith('#') or peek == '$':
+                    break
+                if peek.startswith('E'):
+                    tokenizer.next_line()  # consume 'E'
+                    keyword = tokenizer.next_line().rstrip('~')
+                    descr = tokenizer.read_string_tilde()
+                    obj.extra_descr.append({'keyword': keyword, 'description': descr})
+                elif peek.startswith('A'):
+                    tokenizer.next_line()  # consume 'A'
+                    affect_line = tokenizer.next_line().split()
+                    location = int(affect_line[0]) if len(affect_line) > 0 and affect_line[0].lstrip('-').isdigit() else 0
+                    modifier = int(affect_line[1]) if len(affect_line) > 1 and affect_line[1].lstrip('-').isdigit() else 0
+                    obj.affects.append({'location': location, 'modifier': modifier})
+                else:
+                    break
+        elif line == '$':
+            break