nwn 0.0.2__tar.gz

nwn-0.0.2/.gitignore

@@ -0,0 +1,12 @@
+.pytest_cache
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.venv
+.vscode
+.ruff_cache
+_build
+_gh-pages

nwn-0.0.2/LICENSE

@@ -0,0 +1,18 @@
+Copyright Bernhard Stöckner <n@e-ix.net> and contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies
+or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

nwn-0.0.2/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: nwn
+Version: 0.0.2
+Summary: collection of modules for working with Neverwinter Nights 1: Enhanced Edition
+Project-URL: Source Code, https://github.com/niv/nwn.py
+Project-URL: Issue Tracker, https://github.com/niv/nwn.py/issues
+Project-URL: Documentation, https://niv.github.io/nwn.py/
+Author-email: Bernhard Stoeckner <n@e-ix.net>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment :: Role-Playing
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+
+nwn
+===
+
+A python package with various modules for accessing Neverwinter Nights: Enhanced Edition
+data formats and functionality.
+
+Stability
+---------
+
+This package is currently in ALPHA state. API stability is not guaranteed.
+
+Documentation
+-------------
+
+See the `documentation <https://niv.github.io/nwn.py/>`_ for usage.

nwn-0.0.2/README.rst

@@ -0,0 +1,15 @@
+nwn
+===
+
+A python package with various modules for accessing Neverwinter Nights: Enhanced Edition
+data formats and functionality.
+
+Stability
+---------
+
+This package is currently in ALPHA state. API stability is not guaranteed.
+
+Documentation
+-------------
+
+See the `documentation <https://niv.github.io/nwn.py/>`_ for usage.

nwn-0.0.2/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "nwn"
+version = "0.0.2"
+description = "collection of modules for working with Neverwinter Nights 1: Enhanced Edition"
+readme = "README.rst"
+license = "MIT"
+authors = [{ name = "Bernhard Stoeckner", email = "n@e-ix.net" }]
+requires-python = ">=3.10"
+dependencies = []
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Games/Entertainment :: Role-Playing",
+]
+[project.urls]
+"Source Code" = "https://github.com/niv/nwn.py"
+"Issue Tracker" = "https://github.com/niv/nwn.py/issues"
+"Documentation" = "https://niv.github.io/nwn.py/"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = ["pydoctor>=24.11.2", "pytest>=8.3.4"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = ["--import-mode=importlib"]
+
+[tool.hatch.build]
+include = ["src/**", "README.rst", "LICENSE"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/nwn"]
+
+[tool.pydoctor]
+add-package = ["src/nwn"]
+docformat = "google"

nwn-0.0.2/src/nwn/__init__.py

@@ -0,0 +1,4 @@
+"""
+This package provides tools for working with Neverwinter Nights data files
+and miscellaneous engine utilities.
+"""

nwn-0.0.2/src/nwn/erf.py

@@ -0,0 +1,240 @@
+"""Read and write ERF (Encapsulated Resource Format) archives."""
+
+import struct
+from typing import NamedTuple, IO
+from enum import Enum
+from datetime import date, timedelta
+
+from nwn.shared import (
+    get_nwn_encoding,
+    Language,
+    restype_to_extension,
+    extension_to_restype,
+)
+
+
+class Reader:
+    class Version(Enum):
+        V_1_0 = "V1.0"
+        # E_1_0 = "E1.0"
+
+    class Header(NamedTuple):
+        file_type: str
+        file_version: "Reader.Version"
+        locstr_count: int
+        locstr_sz: int
+        entry_count: int
+        offset_to_locstr: int
+        offset_to_keylist: int
+        offset_to_reslist: int
+        build_year: int
+        build_day: int
+        description_strref: int
+
+    class Entry(NamedTuple):
+        original_filename: str
+        resref: int
+        offset: int
+        disk_size: int
+        uncompressed_size: int
+
+    def _seek(self, relative_to_start):
+        self._file.seek(self._root_offset + relative_to_start)
+
+    def __init__(self, file, max_entries=65535, max_locstr=100):
+        self._file = file
+        self._root_offset = self._file.tell()
+
+        ft = self._file.read(4).decode("ASCII")
+        fv = self.Version(self._file.read(4).decode("ASCII"))
+        va = struct.unpack("IIIIIIIII", self._file.read(36))
+        self._header = self.Header(ft, fv, *va)
+
+        if self._header.entry_count > max_entries:
+            raise ValueError("Too many resources")
+
+        if self._header.locstr_count > max_locstr:
+            raise ValueError("Too many localized strings")
+
+        self._seek(self._header.offset_to_locstr)
+        loc_str = {}
+        for _ in range(self._header.locstr_count):
+            lid = struct.unpack("I", self._file.read(4))[0]
+            sz = struct.unpack("I", self._file.read(4))[0]
+            st = self._file.read(sz).decode(get_nwn_encoding())
+            loc_str[lid] = st
+
+        self._seek(self._header.offset_to_reslist)
+        resources = []
+        for _ in range(self._header.entry_count):
+            offset = struct.unpack("i", self._file.read(4))[0]
+            disk_size = struct.unpack("i", self._file.read(4))[0]
+            uncompressed = disk_size
+            resources.append((offset, disk_size, uncompressed))
+
+        self._seek(self._header.offset_to_keylist)
+        keys = []
+        for _ in range(self._header.entry_count):
+            resref = self._file.read(16).split(b"\x00")[0].decode("ASCII")
+            _ = struct.unpack("I", self._file.read(4))[0]  # res_id unused
+            res_type = struct.unpack("H", self._file.read(2))[0]
+            _ = self._file.read(2)  # unused
+            keys.append((resref, res_type))
+
+        self._localized_strings = loc_str
+
+        self._files = {
+            f"{resref.lower()}.{restype_to_extension(restype)}": self.Entry(
+                resref, restype, o, d, u
+            )
+            for (resref, restype), (o, d, u) in zip(keys, resources)
+        }
+
+    @property
+    def build_date(self):
+        return date(1900 + self._header.build_year, 1, 1) + timedelta(
+            days=self._header.build_day
+        )
+
+    @property
+    def localized_strings(self) -> dict[Language, str]:
+        return self._localized_strings
+
+    @property
+    def description_strref(self):
+        return self._header.description_strref
+
+    @property
+    def filenames(self) -> list[str]:
+        """
+        Property that returns the filenames in the ERF archive.
+
+        Returns:
+            list[str]: A list of filenames present in the ERF archive.
+        """
+        return list(self._files.keys())
+
+    @property
+    def filemap(self):
+        """
+        Returns the mapping of files.
+
+        This method returns the internal dictionary that maps file names to their
+        corresponding file data.
+
+        Returns:
+            dict[str, Entry]: File names mapping to internal Entry tuple.
+        """
+        return self._files
+
+    def read_file(self, filename: str) -> bytes:
+        """
+        Retrieve the contents of a file from the archive.
+
+        Args:
+            filename: The name of the file to retrieve.
+
+        Returns:
+            bytes: The contents of the file as a byte string.
+
+        Raises:
+            KeyError: If the file is not found in the archive.
+            ValueError: If the filename is of a unknown restype.
+        """
+        resource = self._files[filename.lower()]
+        self._seek(resource.offset)
+        return self._file.read(resource.disk_size)
+
+
+class Writer:
+    class Entry(NamedTuple):
+        resref: str
+        restype: int
+        offset: int
+        size: int
+
+    def __init__(
+        self,
+        file,
+        file_type="ERF ",
+        build_date=date.today(),
+    ):
+        self._file = file
+        self._entries = []
+        self._locstr = {}
+
+        self._file_type = file_type
+        self._build_year = build_date.year - 1900
+        self._build_day = build_date.timetuple().tm_yday - 1
+
+    def __enter__(self):
+        self._file.write(self._file_type.encode("ASCII"))
+        self._file.write(Reader.Version.V_1_0.value.encode("ASCII"))
+        self._file.write(b"\x00" * 36)
+        self._file.write(b"\x00" * 116)  # reserved bytes as per spec
+        assert self._file.tell() == 160
+        return self
+
+    def add_localized_string(self, lang, text):
+        self._locstr[lang] = text
+
+    def add_file(self, filename, data: bytes | IO):
+        if hasattr(data, "read"):
+            data = data.read()
+
+        offset = self._file.tell()
+        size = len(data)
+        # ensure we have a restype
+        base, ext = filename.split(".")
+        if len(base) > 16:
+            raise ValueError("Resource name too long")
+        rt = extension_to_restype(ext)
+        self._entries.append(Writer.Entry(base, rt, offset, size))
+        self._file.write(data)
+        assert self._file.tell() == offset + size
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            return False
+
+        locstr_offset = self._file.tell()
+        for lid, text in self._locstr.items():
+            encoded_text = text.encode(get_nwn_encoding())
+            self._file.write(struct.pack("I", lid))
+            self._file.write(struct.pack("I", len(encoded_text)))
+            self._file.write(encoded_text)
+        locstr_size = self._file.tell() - locstr_offset
+
+        keylist_offset = self._file.tell()
+        for resref, restype, offset, size in self._entries:
+            res_ref = resref.ljust(16, "\x00").encode("ASCII")
+            res_id = 0  # res_id unused
+            self._file.write(res_ref)
+            self._file.write(struct.pack("I", res_id))
+            self._file.write(struct.pack("H", restype))
+            self._file.write(b"\x00\x00")  # Unused
+
+        reslist_offset = self._file.tell()
+        for _, _, offset, size in self._entries:
+            self._file.write(struct.pack("i", offset))
+            self._file.write(struct.pack("i", size))
+
+        eof_offset = self._file.tell()
+
+        self._file.seek(8)
+        self._file.write(
+            struct.pack(
+                "IIIIIIIII",
+                len(self._locstr),
+                locstr_size,
+                len(self._entries),
+                locstr_offset,
+                keylist_offset,
+                reslist_offset,
+                self._build_year,
+                self._build_day,
+                0,  # description_strref
+            )
+        )
+        self._file.seek(eof_offset)
+        return False

nwn-0.0.2/src/nwn/gff/__init__.py

@@ -0,0 +1,51 @@
+"""
+Transform GFF (Generic File Format) files from/to native python types.
+
+Python representation is (Struct) and (List) objects, which can be nested.
+They behave just like native python dictionaries and lists, but with some
+additional methods and properties to make life easier.
+
+Since GFF has strong typing beyond what python offers natively, the module
+provides a number of custom types to represent the various field types that
+can be found in a GFF file.
+
+All field types are subclasses of the native python types, and are used to
+enforce the GFF type system.
+"""
+
+from nwn.gff._reader import read
+from nwn.gff._types import (
+    Byte,
+    Char,
+    Word,
+    Short,
+    Dword,
+    Int,
+    Dword64,
+    Int64,
+    Float,
+    Double,
+    CExoString,
+    ResRef,
+    Struct,
+    List,
+)
+
+
+__all__ = [
+    "read",
+    "Byte",
+    "Char",
+    "Word",
+    "Short",
+    "Dword",
+    "Int",
+    "Dword64",
+    "Int64",
+    "Float",
+    "Double",
+    "CExoString",
+    "ResRef",
+    "List",
+    "Struct",
+]

nwn-0.0.2/src/nwn/gff/_impl.py

@@ -0,0 +1,50 @@
+from enum import IntEnum
+from typing import NamedTuple
+
+
+class FieldKind(IntEnum):
+    BYTE = 0
+    CHAR = 1
+    WORD = 2
+    SHORT = 3
+    DWORD = 4
+    INT = 5
+    DWORD64 = 6
+    INT64 = 7
+    FLOAT = 8
+    DOUBLE = 9
+    CEXOSTRING = 10
+    RESREF = 11
+    CEXOLOCSTRING = 12
+    VOID = 13
+    STRUCT = 14
+    LIST = 15
+
+
+class Header(NamedTuple):
+    file_type: str
+    file_version: str
+    struct_offset: int
+    struct_count: int
+    field_offset: int
+    field_count: int
+    label_offset: int
+    label_count: int
+    field_data_offset: int
+    field_data_size: int
+    field_indices_offset: int
+    field_indices_size: int
+    list_indices_offset: int
+    list_indices_size: int
+
+
+class StructEntry(NamedTuple):
+    id: int
+    data_or_offset: int
+    field_count: int
+
+
+class FieldEntry(NamedTuple):
+    type: FieldKind
+    label_index: int
+    data_or_offset: int

nwn-0.0.2/src/nwn/gff/_reader.py

@@ -0,0 +1,157 @@
+import struct
+from typing import BinaryIO
+
+
+from nwn.shared import get_nwn_encoding, CExoLocString
+from nwn.gff._types import (
+    Byte,
+    Char,
+    Word,
+    Short,
+    Dword,
+    Int,
+    Float,
+    CExoString,
+    ResRef,
+    Struct,
+    List,
+)
+from nwn.gff._impl import FieldKind, Header, FieldEntry, StructEntry
+
+
+def read(file: BinaryIO):
+    """
+    Read a GFF data from a binary stream.
+
+    Args:
+        file: The binary stream to read from.
+
+    Returns:
+        (Struct, str): The root structure of the GFF file and the file type.
+    """
+
+    root_offset = file.tell()
+    labels = []
+    fields = []
+    structs = []
+    list_indices = []
+    field_indices = []
+    resolved_structs = {}
+    struct_parents = {}
+
+    header = Header(
+        file.read(4).decode("ascii"),
+        file.read(4).decode("ascii"),
+        *struct.unpack("<12i", file.read(48)),
+    )
+    if header.file_version != "V3.2":
+        raise ValueError(f"Unsupported GFF version: {header.file_version}")
+
+    file.seek(root_offset + header.label_offset)
+    for _ in range(header.label_count):
+        labels.append(file.read(16).split(b"\x00")[0].decode("ascii"))
+
+    file.seek(root_offset + header.field_offset)
+    for _ in range(header.field_count):
+        data = struct.unpack("<III", file.read(12))
+        fields.append(FieldEntry(FieldKind(data[0]), data[1], data[2]))
+
+    file.seek(root_offset + header.field_indices_offset)
+    for _ in range(header.field_indices_size // 4):
+        field_indices.append(struct.unpack("<I", file.read(4))[0])
+
+    file.seek(root_offset + header.list_indices_offset)
+    for _ in range(header.list_indices_size // 4):
+        list_indices.append(struct.unpack("<I", file.read(4))[0])
+
+    file.seek(root_offset + header.struct_offset)
+    for _ in range(header.struct_count):
+        data = struct.unpack("<III", file.read(12))
+        structs.append(StructEntry(data[0], data[1], data[2]))
+
+    def _read_field_value(field):
+        simple_types = {
+            FieldKind.BYTE: ("B", Byte),
+            FieldKind.CHAR: ("b", Char),
+            FieldKind.WORD: ("H", Word),
+            FieldKind.SHORT: ("h", Short),
+            FieldKind.DWORD: ("I", Dword),
+            FieldKind.INT: ("i", Int),
+            FieldKind.FLOAT: ("f", Float),
+        }
+
+        if field.type in simple_types:
+            us, cls = simple_types[field.type]
+            data = struct.pack("<I", field.data_or_offset)[: struct.calcsize(us)]
+            up = struct.unpack("<" + us, data)
+            return cls(up[0])
+
+        file.seek(root_offset + header.field_data_offset + field.data_or_offset)
+
+        if field.type == FieldKind.CEXOSTRING:
+            sz = struct.unpack("<I", file.read(4))[0]
+            if sz > 0xFFFF:
+                raise ValueError("String too long")
+            return CExoString(file.read(sz).decode(get_nwn_encoding()))
+
+        if field.type == FieldKind.RESREF:
+            sz = struct.unpack("<b", file.read(1))[0]
+            if sz > 16:
+                raise ValueError("Resref too long")
+            return ResRef(file.read(sz).decode(get_nwn_encoding()))
+
+        if field.type == FieldKind.CEXOLOCSTRING:
+            _ = struct.unpack("<I", file.read(4))[0]
+            strref = struct.unpack("<I", file.read(4))[0]
+            count = struct.unpack("<I", file.read(4))[0]
+            entries = {}
+            for _ in range(count):
+                fid = struct.unpack("<I", file.read(4))[0]
+                sz = struct.unpack("<I", file.read(4))[0]
+                entries[fid] = file.read(sz).decode(get_nwn_encoding())
+            return CExoLocString(strref, entries)
+
+        if field.type == FieldKind.LIST:
+            offset = field.data_or_offset // 4
+            size = list_indices[offset]
+            start = offset + 1
+            end = start + size
+
+            return List(*[_read_struct(field, lid) for lid in list_indices[start:end]])
+
+        if field.type == FieldKind.STRUCT:
+            return _read_struct(field, field.data_or_offset)
+
+        raise NotImplementedError(f"Field type {field.type} not implemented")
+
+    def _read_struct(parent, struct_idx) -> Struct:
+        if struct_idx in resolved_structs:
+            if struct_parents[struct_idx] != parent:
+                raise ValueError("Struct already resolved with different parent")
+            return resolved_structs[struct_idx]
+
+        struct_entry = structs[struct_idx]
+
+        if struct_entry.field_count == 1:
+            field_array_indices = [struct_entry.data_or_offset]
+        else:
+            start = struct_entry.data_or_offset // 4
+            end = start + struct_entry.field_count
+            if end < start:
+                raise ValueError("Field index array out of bounds")
+
+            field_array_indices = field_indices[start:end]
+
+        resolved_structs[struct_idx] = Struct(
+            struct_entry.id,
+            **{
+                labels[fld.label_index]: _read_field_value(fld)
+                for fld in map(lambda x: fields[x], field_array_indices)
+            },
+        )
+
+        struct_parents[struct_idx] = parent
+        return resolved_structs[struct_idx]
+
+    root = _read_struct(None, 0)
+    return root, header.file_type

nwn-0.0.2/src/nwn/gff/_types.py

@@ -0,0 +1,109 @@
+class Byte(int):
+    def __new__(cls, value):
+        if not 0 <= value <= 255:
+            raise ValueError(f"BYTE value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Char(int):
+    def __new__(cls, value):
+        if not -128 <= value <= 127:
+            raise ValueError(f"CHAR value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Word(int):
+    def __new__(cls, value):
+        if not 0 <= value <= 65535:
+            raise ValueError(f"WORD value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Short(int):
+    def __new__(cls, value):
+        if not -32768 <= value <= 32767:
+            raise ValueError(f"SHORT value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Dword(int):
+    def __new__(cls, value):
+        if not 0 <= value <= 4294967295:
+            raise ValueError(f"DWORD value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Int(int):
+    def __new__(cls, value):
+        if not -2147483648 <= value <= 2147483647:
+            raise ValueError(f"INT value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Dword64(int):
+    def __new__(cls, value):
+        if not 0 <= value <= 18446744073709551615:
+            raise ValueError(f"DWORD64 value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Int64(int):
+    def __new__(cls, value):
+        if not -9223372036854775808 <= value <= 9223372036854775807:
+            raise ValueError(f"INT64 value out of bounds: {value}")
+        return super().__new__(cls, value)
+
+
+class Float(float):
+    pass
+
+
+class Double(float):
+    pass
+
+
+class CExoString(str):
+    pass
+
+
+class ResRef(str):
+    def __new__(cls, value):
+        if len(value) > 16:
+            raise ValueError(f"ResRef value too long: {value}")
+        return super().__new__(cls, value)
+
+
+class Struct(dict):
+    """GFF Structs are just python dicts with .attr access and some metadata."""
+
+    def __init__(self, struct_id, **kwargs):
+        super().__init__(**kwargs)
+        object.__setattr__(self, "_struct_id", struct_id)
+
+    @property
+    def struct_id(self):
+        """The struct ID of the struct."""
+        return object.__getattribute__(self, "_struct_id")
+
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError as exc:
+            raise AttributeError(
+                f"'{self.__class__.__name__}' object has no attribute '{item}'"
+            ) from exc
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+
+class List(list[Struct]):
+    """
+    GFF Lists are just python lists of Structs. They carry no metadata.
+
+    This class exists as a convenience for type checking and
+    future extensibility.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

nwn-0.0.2/src/nwn/shared.py

@@ -0,0 +1,165 @@
+"""Shared types and helpers useful across the whole library."""
+
+from enum import IntEnum
+from typing import NamedTuple
+
+
+class CExoLocString(NamedTuple):
+    """Represents a localized string in the NWN engine."""
+
+    strref: int
+    entries: dict[int, str]
+
+
+class Language(IntEnum):
+    """Maps engine language IDs."""
+
+    ENGLISH = 0
+    FRENCH = 1
+    GERMAN = 2
+    ITALIAN = 3
+    SPANISH = 4
+    POLISH = 5
+
+
+def get_nwn_encoding():
+    """
+    A stand-in to enable dynamic configuration later.
+
+    Currently hardcoded to "windows-1252".
+
+    Returns:
+        str: The encoding used by NWN.
+    """
+    return "windows-1252"
+
+
+_restype_to_extension = {
+    0: "res",
+    1: "bmp",
+    2: "mve",
+    3: "tga",
+    4: "wav",
+    5: "wfx",
+    6: "plt",
+    7: "ini",
+    8: "bmu",
+    9: "mpg",
+    10: "txt",
+    2000: "plh",
+    2001: "tex",
+    2002: "mdl",
+    2003: "thg",
+    2005: "fnt",
+    2007: "lua",
+    2008: "slt",
+    2009: "nss",
+    2010: "ncs",
+    2011: "mod",
+    2012: "are",
+    2013: "set",
+    2014: "ifo",
+    2015: "bic",
+    2016: "wok",
+    2017: "2da",
+    2018: "tlk",
+    2022: "txi",
+    2023: "git",
+    2024: "bti",
+    2025: "uti",
+    2026: "btc",
+    2027: "utc",
+    2029: "dlg",
+    2030: "itp",
+    2031: "btt",
+    2032: "utt",
+    2033: "dds",
+    2034: "bts",
+    2035: "uts",
+    2036: "ltr",
+    2037: "gff",
+    2038: "fac",
+    2039: "bte",
+    2040: "ute",
+    2041: "btd",
+    2042: "utd",
+    2043: "btp",
+    2044: "utp",
+    2045: "dft",
+    2046: "gic",
+    2047: "gui",
+    2048: "css",
+    2049: "ccs",
+    2050: "btm",
+    2051: "utm",
+    2052: "dwk",
+    2053: "pwk",
+    2054: "btg",
+    2055: "utg",
+    2056: "jrl",
+    2057: "sav",
+    2058: "utw",
+    2059: "4pc",
+    2060: "ssf",
+    2061: "hak",
+    2062: "nwm",
+    2063: "bik",
+    2064: "ndb",
+    2065: "ptm",
+    2066: "ptt",
+    2067: "bak",
+    2068: "dat",
+    2069: "shd",
+    2070: "xbc",
+    2071: "wbm",
+    2072: "mtr",
+    2073: "ktx",
+    2074: "ttf",
+    2075: "sql",
+    2076: "tml",
+    2077: "sq3",
+    2078: "lod",
+    2079: "gif",
+    2080: "png",
+    2081: "jpg",
+    2082: "caf",
+    2083: "jui",
+    9996: "ids",
+    9997: "erf",
+    9998: "bif",
+    9999: "key",
+}
+
+
+def restype_to_extension(restype: int) -> str:
+    """
+    Convert a resource type to its corresponding file extension.
+    Args:
+        restype: The resource type to convert.
+    Returns:
+        str: The corresponding file extension for the given resource type.
+    Raises:
+        ValueError: If the given resource type is unknown.
+    """
+    try:
+        return _restype_to_extension[restype]
+    except KeyError as e:
+        raise ValueError(f"Unknown restype: {restype}") from e
+
+
+def extension_to_restype(extension: str) -> int:
+    """
+    Convert a file extension to its corresponding resource type identifier.
+
+    Args:
+        extension: The file extension to convert.
+    Returns:
+        int: The resource type identifier corresponding to the given extension.
+    Raises:
+        ValueError: If the extension is not recognized.
+    """
+
+    try:
+        return {v: k for k, v in _restype_to_extension.items()}[extension]
+    except KeyError as e:
+        raise ValueError(f"Unknown extension: {extension}") from e

nwn-0.0.2/src/nwn/tileset.py

@@ -0,0 +1,196 @@
+"""A parser for .set files (tilesets configuration)."""
+
+import configparser
+from dataclasses import dataclass, field
+import re
+from typing import BinaryIO
+
+
+@dataclass
+class Terrain:
+    name: str = ""
+    strref: int = 0
+
+
+@dataclass
+class Crosser:
+    name: str = ""
+    strref: int = 0
+
+
+@dataclass
+class Rule:
+    placed: str
+    placedheight: int
+    adjacent: str
+    adjacentheight: int
+    changed: str
+    changedheight: int
+
+
+@dataclass
+class Door:
+    type: int
+    x: float = 0
+    y: float = 0
+    z: float = 0
+    orientation: float = 0
+
+
+@dataclass
+class Tile:
+    doors: list[Door]
+
+    model: str
+    walkmesh: str = ""
+    topleft: str = ""
+    topleftheight: int = 0
+    topright: str = ""
+    toprightheight: int = 0
+    bottomleft: str = ""
+    bottomleftheight: int = 0
+    bottomright: str = ""
+    bottomrightheight: int = 0
+    top: str = ""
+    right: str = ""
+    bottom: str = ""
+    left: str = ""
+    mainlight1: int = 0
+    mainlight2: int = 0
+    sourcelight1: int = 0
+    sourcelight2: int = 0
+    animloop1: int = 0
+    animloop2: int = 0
+    animloop3: int = 0
+    sounds: int = 0
+    pathnode: str = ""
+    orientation: float = 0
+    imagemap2d: str = ""
+
+
+@dataclass
+class Group:
+    name: str
+    rows: int
+    columns: int
+    tiles: list[int] = field(default_factory=list)
+
+
+@dataclass
+class SetGrass:
+    grass: int
+    density: float
+    height: float
+    ambientred: float
+    ambientgreen: float
+    ambientblue: float
+    diffusered: float
+    diffusegreen: float
+    diffuseblue: float
+
+
+@dataclass
+class Set:
+    name: str
+    type: str
+    version: str
+    interior: int
+    hasheighttransition: int
+    envmap: str
+    transition: float
+    displayname: int
+    border: str
+    default: str
+    floor: str
+
+    grass: SetGrass = None
+    terrains: list[Terrain] = field(default_factory=list)
+    crossers: list[Crosser] = field(default_factory=list)
+    primary_rules: list[Rule] = field(default_factory=list)
+    tiles: list[Tile] = field(default_factory=list)
+    groups: list[Group] = field(default_factory=list)
+
+
+def _dataclass_name(s):
+    return "".join(x or "_" for x in s.split("_"))
+
+
+def _read_value(ty, v):
+    if ty == int:
+        return int(v)
+    if ty == bool:
+        return v in {"1"}
+    if ty == float:
+        return float(v)
+    if ty == str:
+        return str(v)
+    if (hasattr(ty, "__origin__") and ty.__origin__ == list) or ty == list:
+        # We manually load these in
+        return []
+    raise ValueError(f"Unsupported type: {ty}")
+
+
+def _read_dataclass(cls, **kwargs):
+    return cls(
+        **{
+            field.name: _read_value(field.type, kwargs[_dataclass_name(field.name)])
+            for field in cls.__dataclass_fields__.values()
+            if _dataclass_name(field.name) in kwargs and not field.name.startswith("_")
+        }
+    )
+
+
+def read_set(file: BinaryIO) -> Set:
+    """
+    Reads a .set file and parses its contents into a Set object.
+    """
+
+    general = None
+
+    data = configparser.ConfigParser()
+    data.read_file(file)
+
+    for s in data.sections():
+        if s == "GENERAL":
+            general = _read_dataclass(Set, **data[s])
+
+        if not general:
+            raise ValueError("No GENERAL section found")
+
+        if s == "GRASS":
+            grass = _read_dataclass(SetGrass, **data[s])
+            general.grass = grass
+
+        if ma := re.match(r"^TERRAIN(\d+)$", s):
+            tid = int(ma.group(1))
+            terrain = _read_dataclass(Terrain, **data[s])
+            general.terrains.append(terrain)
+
+        if ma := re.match(r"^CROSSER(\d+)$", s):
+            terrain = _read_dataclass(Crosser, **data[s])
+            general.crossers.append(terrain)
+
+        if ma := re.match(r"^PRIMARY RULE(\d+)$", s):
+            rule = _read_dataclass(Rule, **data[s])
+            general.primary_rules.append(rule)
+
+        if ma := re.match(r"^TILE(\d+)$", s):
+            tid = int(ma.group(1))
+            tile = _read_dataclass(Tile, **data[s])
+            general.tiles.append(tile)
+
+        if ma := re.match(r"^TILE(\d+)DOOR(\d+)$", s):
+            tid = int(ma.group(1))
+            door = _read_dataclass(Door, **data[s])
+            tile = general.tiles[tid]
+            tile.doors.append(door)
+
+        if ma := re.match(r"^GROUP(\d+)$", s):
+            group = _read_dataclass(Group, **data[s])
+            count = group.rows * group.columns
+            for i in range(count):
+                tile = data[s][f"Tile{i}"]
+                group.tiles.append(int(tile))
+            general.groups.append(group)
+
+    return general