gopheria

README

Gopheria

A comprehensive Go library for reading Terraria world files (.wld), player save files (.plr), map exploration files (.map) and Terraria game client resource files (.xnb, .xwb).

Quick Start

Installation

go get gitlab.com/nicolaw/gopheria

Basic Usage

package main

import (
    "fmt"
    "log"
    "gitlab.com/nicolaw/gopheria/world"
)

func main() {
    w, err := world.LoadFile("MyWorld.wld")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("World: %s\n", w.Name())
    width, height := w.Size()
    fmt.Printf("Size: %d x %d tiles\n", width, height)
}

Building Command Line Tools

make build

This builds all example tools to ./bin/:

• playerinfo - Inspect player files
• worldinfo - Inspect world files
• houseinfo - Find and inspect houses in world files
• playerdebug - Debug player file parsing
• resourceextract - Extract game resources
• rendermap - Render world maps as PNG images
• genworld - Generate a single Terraria world via the server (with map)
• genworlds - Generate a full corpus of worlds (all seeds × sizes × difficulties × evils)

Documentation

• Features - Complete feature list
• Installation - Installation and setup
• Command Line Tools - Using the example tools
• World Files - Working with world files
• Player Files - Working with player files
• Resource Files - Extracting game resources
• Map Rendering - Rendering world maps
• Exploration Maps - Player exploration data
• Architecture - Library structure and design
• Testing - Running tests and benchmarks
• Development Plan - Implementation roadmap
• Credits - Prior art and references

API Documentation

Full API documentation is available on pkg.go.dev.

View documentation locally:

# Install tools
make install-tools

# Start documentation server
godoc -http=:6060
# Then open http://localhost:6060/pkg/gitlab.com/nicolaw/gopheria/

Development

Running Tests

make test              # All tests
make test-unit         # Unit tests only
make test-integration   # Integration tests
make benchmark         # Benchmark tests
make coverage          # Test coverage report

Code Quality

make fmt    # Format code
make vet    # Run go vet
make lint   # Run golangci-lint (if installed)

See Testing for more details. A large corpus of test data is available at https://gitlab.com/nicolaw/terraria-testdata, which has a browsable index at https://terraria-testdata-0d2bb3.gitlab.io/.

Supported Versions

The library supports Terraria file versions 194+ (1.3.5.3 onwards). Primary testing and development targets version 279 (1.4.4.9).

License

MIT License

Documentation

Overview

Package gopheria provides a comprehensive Go library for reading Terraria world files (.wld), player save files (.plr), and game resource files (.xnb).

Overview

Gopheria enables Go programs to read and analyze Terraria game files. The library targets Terraria version 1.4.4.9 (file version 279) as the primary supported version, with architecture designed to support older versions back to 1.3.5.3 (version 194).

Main Packages

The library is organized into several packages:

• gitlab.com/nicolaw/gopheria/world: World file reading with full tile, chest, sign, NPC, and entity support
• gitlab.com/nicolaw/gopheria/player: Player file reading with AES decryption, inventory, and equipment parsing
• gitlab.com/nicolaw/gopheria/render: World map image rendering with customizable options
• gitlab.com/nicolaw/gopheria/worldgen: Interactive world generation by driving the Terraria server (genworld/genworlds use this)
• gitlab.com/nicolaw/gopheria/resource/xnb: XNB resource file reading with texture extraction

Data Packages

Supporting data packages provide lookup tables and metadata:

• gitlab.com/nicolaw/gopheria/data/items: Item ID to name lookups (version-specific)
• gitlab.com/nicolaw/gopheria/data/npcs: NPC type ID to names and comprehensive metadata (version-specific)
• gitlab.com/nicolaw/gopheria/data/prefixes: Item prefix (reforge) names (stable, may need versioning in future)
• gitlab.com/nicolaw/gopheria/data/colors: Map tile and wall color palettes (version-specific)
• gitlab.com/nicolaw/gopheria/data/buffs: Buff/debuff name lookups (version-specific)
• gitlab.com/nicolaw/gopheria/data/slots: Equipment slot information (stable, may need versioning in future)
• gitlab.com/nicolaw/gopheria/data/toggles: Builder toggle settings (version-specific)
• gitlab.com/nicolaw/gopheria/data/tiles: Tile ID to names and metadata (version-specific)
• gitlab.com/nicolaw/gopheria/data/walls: Wall ID to names and metadata (version-specific)

Quick Start

Loading a world file:

w, err := world.LoadFile("MyWorld.wld")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("World: %s (%s)\n", w.Name(), w.Version())

Loading a player file:

p, err := player.LoadFile("Player1.plr")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Player: %s, HP: %d/%d\n", p.Name, p.Health, p.HealthMax)

Rendering a world map:

palette := colors.GetLatestPalette()
renderer := render.NewMapRenderer(palette)
img := renderer.RenderMap(w)
render.SavePNG(img, "map.png")

Using version-specific data packages:

// Get version from world file
versionStr := world.Version.GameVersion() // e.g., "1.4.4.9"
items, err := items.GetItems(items.Version(versionStr))
if err != nil {
    // Handle error or use latest
    items = items.GetLatestItems()
}
itemName := items.Name(itemID)

Test Data Discovery

The package includes functions for discovering test data files:

• DiscoverAllWorldFiles: Find all .wld files in testdata directories
• DiscoverAllPlayerFiles: Find all .plr files in testdata directories
• DiscoverWorldFilesWithInfo: Get world files with metadata
• DiscoverPlayerFilesWithInfo: Get player files with metadata

Supported Versions

The library supports Terraria file versions 194+ (1.3.5.3 onwards). Primary testing and development targets version 279 (1.4.4.9).

Thread Safety

World and Player structs are not safe for concurrent modification. Create separate instances for concurrent reads, or synchronize access if modifying shared instances.

Package gopheria provides functionality for reading Terraria world and player files.

This file contains test data discovery functions used across all tests. These functions are intended for use in testing only.

Example (Buffs)

Example using buff lookups.

package main

import (
	"fmt"

	"gitlab.com/nicolaw/gopheria/data/buffs"
)

func main() {
	// Get buff names
	fmt.Println(buffs.Name(1))   // Obsidian Skin
	fmt.Println(buffs.Name(2))   // Regeneration
	fmt.Println(buffs.Name(20))  // Poisoned
	fmt.Println(buffs.Name(21))  // Potion Sickness
	fmt.Println(buffs.Name(190)) // Exquisitely Stuffed

	// Check if known
	fmt.Println(buffs.IsKnown(1))     // true
	fmt.Println(buffs.IsKnown(99999)) // false
}

Example (Colors)

Example using color palettes.

package main

import (
	"fmt"

	"gitlab.com/nicolaw/gopheria/data/colors"
)

func main() {
	palette := colors.GetLatestPalette()

	// Get tile colors
	dirt := palette.GetTileColor(0, 0)
	stone := palette.GetTileColor(1, 0)
	fmt.Printf("Dirt: RGB(%d, %d, %d)\n", dirt.R, dirt.G, dirt.B)
	fmt.Printf("Stone: RGB(%d, %d, %d)\n", stone.R, stone.G, stone.B)

	// Get liquid colors
	water := palette.GetLiquidColor(0)
	lava := palette.GetLiquidColor(1)
	fmt.Printf("Water: RGB(%d, %d, %d)\n", water.R, water.G, water.B)
	fmt.Printf("Lava: RGB(%d, %d, %d)\n", lava.R, lava.G, lava.B)

	// Get background color for a Y coordinate
	bg := palette.GetBackgroundColor(100, 300, 600, 1000)
	fmt.Printf("Background at y=100: RGB(%d, %d, %d)\n", bg.R, bg.G, bg.B)
}

Example (Items)

Example looking up item names.

package main

import (
	"fmt"

	"gitlab.com/nicolaw/gopheria/data/items"
)

func main() {
	// Get item names by ID
	fmt.Println(items.Name(1))  // First item
	fmt.Println(items.Name(71)) // Gold Coin
	fmt.Println(items.Name(72)) // Silver Coin
	fmt.Println(items.Name(0))  // Empty
	fmt.Println(items.Name(-1)) // Unknown

	// Get max item ID
	fmt.Printf("Max item ID: %d\n", items.MaxID())
}

Example (JourneyResearch)

Example checking Journey mode research.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/player"
)

func main() {
	p, err := player.LoadFile("JourneyPlayer.plr")
	if err != nil {
		log.Fatal(err)
	}

	if p.Difficulty == player.GameModeJourney {
		fmt.Printf("Total items researched: %d\n", p.ResearchProgress())

		// Check specific items
		if p.IsItemResearched("Dirt Block") {
			fmt.Println("Dirt Block is fully researched!")
		}

		// List first 10 researched items
		count := 0
		for itemName, researched := range p.ResearchedItems {
			fmt.Printf("%s: %d\n", itemName, researched)
			count++
			if count >= 10 {
				break
			}
		}
	}
}

Example (PlayerBasics)

Example loading a player file and accessing stats.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/player"
)

func main() {
	p, err := player.LoadFile("Player1.plr")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Player: %s\n", p.Name)
	fmt.Printf("Difficulty: %s\n", p.Difficulty)
	fmt.Printf("Health: %d/%d\n", p.Health, p.HealthMax)
	fmt.Printf("Mana: %d/%d\n", p.Mana, p.ManaMax)
	fmt.Printf("Play Time: %s\n", p.PlayTimeFormatted())
}

Example (PlayerBuffs)

Example displaying active player buffs.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/data/buffs"
	"gitlab.com/nicolaw/gopheria/player"
)

func main() {
	p, err := player.LoadFile("Player1.plr")
	if err != nil {
		log.Fatal(err)
	}

	activeBuffs := p.ActiveBuffs()
	fmt.Printf("Active buffs: %d\n", len(activeBuffs))

	for _, buff := range activeBuffs {
		name := buffs.Name(buff.ID)
		seconds := buff.Time / 60 // Ticks to seconds
		fmt.Printf("  %s: %d seconds remaining\n", name, seconds)
	}
}

Example (PlayerInventory)

Example accessing player inventory with item names.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/data/items"
	"gitlab.com/nicolaw/gopheria/data/prefixes"
	"gitlab.com/nicolaw/gopheria/player"
)

func main() {
	p, err := player.LoadFile("Player1.plr")
	if err != nil {
		log.Fatal(err)
	}

	// List non-empty inventory items
	for i, item := range p.MainInventory() {
		if !item.IsEmpty() {
			name := items.Name(item.ID)
			prefix := prefixes.Name(item.Prefix)
			if prefix != "" {
				fmt.Printf("Slot %d: %s %s x%d\n", i, prefix, name, item.Stack)
			} else {
				fmt.Printf("Slot %d: %s x%d\n", i, name, item.Stack)
			}
		}
	}
}

Example (PlayerMapExploration)

Example loading a player's map exploration file.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/player"
)

func main() {
	// Load a player's map exploration file
	// These files track which tiles the player has discovered on the minimap
	mapFile, err := player.LoadMapFile("PlayerName/world-uuid.map")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("World: %s\n", mapFile.WorldName)
	fmt.Printf("Size: %d x %d tiles\n", mapFile.Width, mapFile.Height)
	fmt.Printf("Explored: %d tiles (%.2f%%)\n",
		mapFile.ExploredTileCount(), mapFile.ExplorationPercentage())

	// Check if a specific tile is explored
	tile := mapFile.GetTile(100, 200)
	if tile != nil && tile.IsExplored() {
		fmt.Printf("Tile at (100, 200): Type=%d, Light=%d\n", tile.Type, tile.Light)
	}
}

Example (Prefixes)

Example looking up prefix names.

package main

import (
	"fmt"

	"gitlab.com/nicolaw/gopheria/data/prefixes"
)

func main() {
	// Get prefix names by ID
	fmt.Println(prefixes.Name(59)) // Godly
	fmt.Println(prefixes.Name(81)) // Legendary
	fmt.Println(prefixes.Name(82)) // Unreal
	fmt.Println(prefixes.Name(83)) // Mythical
	fmt.Println(prefixes.Name(65)) // Warding
	fmt.Println(prefixes.Name(0))  // (no prefix)

	// Check if valid
	fmt.Println(prefixes.IsValid(59)) // true
	fmt.Println(prefixes.IsValid(0))  // false
}

Example (RenderExplorationMap)

Example rendering a player's exploration map.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/data/colors"
	"gitlab.com/nicolaw/gopheria/player"
	"gitlab.com/nicolaw/gopheria/render"
)

func main() {
	// Load the map file
	mapFile, err := player.LoadMapFile("PlayerName/world-uuid.map")
	if err != nil {
		log.Fatal(err)
	}

	// Create an exploration renderer
	palette := colors.GetLatestPalette()
	renderer := render.NewExplorationRenderer(palette)

	// Render with default options (unexplored areas shown as dark)
	img := renderer.RenderExploration(mapFile)
	if err := render.SavePNG(img, "exploration.png"); err != nil {
		log.Fatal(err)
	}

	// Render with custom options
	opts := render.DefaultExplorationOptions()
	opts.TransparentUnexplored = true // Make unexplored areas transparent

	renderer = renderer.WithOptions(opts)
	overlay := renderer.RenderExploration(mapFile)
	if err := render.SavePNG(overlay, "exploration_overlay.png"); err != nil {
		log.Fatal(err)
	}

	// Render just an exploration mask (grayscale)
	mask := renderer.RenderExplorationMask(mapFile)
	fmt.Printf("Rendered exploration mask: %dx%d\n", mask.Bounds().Dx(), mask.Bounds().Dy())
}

Example (RenderMap)

Example rendering a world map image.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/data/colors"
	"gitlab.com/nicolaw/gopheria/render"
	"gitlab.com/nicolaw/gopheria/world"
)

func main() {
	w, err := world.LoadFile("MyWorld.wld")
	if err != nil {
		log.Fatal(err)
	}

	// Create renderer with default settings
	palette := colors.GetLatestPalette()
	renderer := render.NewMapRenderer(palette)

	// Render the map
	img := renderer.RenderMap(w)

	// Save as PNG
	if err := render.SavePNG(img, "map.png"); err != nil {
		log.Fatal(err)
	}

	width, height := w.Size()
	fmt.Printf("Saved %dx%d map to map.png\n", width, height)
}

Example (RenderMapOptions)

Example rendering with custom options.

package main

import (
	"log"

	"gitlab.com/nicolaw/gopheria/data/colors"
	"gitlab.com/nicolaw/gopheria/render"
	"gitlab.com/nicolaw/gopheria/world"
)

func main() {
	w, err := world.LoadFile("MyWorld.wld")
	if err != nil {
		log.Fatal(err)
	}

	palette := colors.GetLatestPalette()

	// Custom options: show wires, transparent sky
	opts := render.DefaultMapOptions()
	opts.ShowWires = true
	opts.TransparentSky = true

	renderer := render.NewMapRenderer(palette).WithOptions(opts)
	img := renderer.RenderMap(w)

	if err := render.SavePNG(img, "map_with_wires.png"); err != nil {
		log.Fatal(err)
	}
}

Example (Slots)

Example using equipment slot information.

package main

import (
	"fmt"

	"gitlab.com/nicolaw/gopheria/data/slots"
)

func main() {
	// Get equipment slot info
	slot := slots.GetEquipmentSlot(0)
	fmt.Printf("Slot 0: %s (%s)\n", slot.Name, slot.Type)

	// Check slot types
	fmt.Println(slots.IsVanitySlot(10))   // true
	fmt.Println(slots.IsAccessorySlot(3)) // true
	fmt.Println(slots.IsExpertSlot(8))    // true
	fmt.Println(slots.IsMasterSlot(9))    // true

	// Get misc equipment slots
	misc := slots.GetMiscSlot(0)
	fmt.Printf("Misc 0: %s (%s)\n", misc.Name, misc.Type)
}

Example (TestDataDiscovery)

This example is skipped because it requires actual files.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria"
)

func main() {
	// Discover terraria version directories
	dirs, err := gopheria.DiscoverTerrariaDirectories("testdata")
	if err != nil {
		log.Fatal(err)
	}

	for _, dir := range dirs {
		fmt.Println(dir)

		// Discover files in each directory
		worlds, _ := gopheria.DiscoverWorldFiles(dir)
		players, _ := gopheria.DiscoverPlayerFiles(dir)

		fmt.Printf("  Worlds: %d\n", len(worlds))
		fmt.Printf("  Players: %d\n", len(players))
	}
}

Example (Toggles)

Example using builder toggle information.

package main

import (
	"fmt"

	"gitlab.com/nicolaw/gopheria/data/toggles"
)

func main() {
	// Get toggle info
	toggle := toggles.GetBuilderToggle(0)
	fmt.Printf("%s: %s\n", toggle.Name, toggle.Description)

	// Get toggles for a specific version
	count := toggles.BuilderTogglesForVersion(269)
	fmt.Printf("Version 269 has %d toggles\n", count)

	// List all toggles
	all := toggles.AllBuilderToggles()
	for _, t := range all {
		fmt.Printf("%d: %s (v%d+)\n", t.Index, t.Name, t.MinVersion)
	}
}

Example (WorldBasics)

Example loading a world file and accessing basic information.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/world"
)

func main() {
	w, err := world.LoadFile("MyWorld.wld")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("World: %s\n", w.Name())
	fmt.Printf("Version: %s\n", w.Version())

	width, height := w.Size()
	fmt.Printf("Size: %d x %d tiles\n", width, height)

	spawnX, spawnY := w.Spawn()
	fmt.Printf("Spawn: (%d, %d)\n", spawnX, spawnY)

	fmt.Printf("Difficulty: %s\n", w.Difficulty())
	fmt.Printf("World Evil: %s\n", w.WorldEvil())
	fmt.Printf("Hardmode: %v\n", w.IsHardMode())
}

Example (WorldTiles)

Example accessing tile data from a world.

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria/world"
)

func main() {
	w, err := world.LoadFile("MyWorld.wld")
	if err != nil {
		log.Fatal(err)
	}

	// Access individual tiles
	tile := w.GetTile(100, 200)
	if tile.HasBlock {
		fmt.Printf("Block type at (100, 200): %d\n", tile.BlockType)
	}
	if tile.HasWall {
		fmt.Printf("Wall type at (100, 200): %d\n", tile.WallType)
	}

	// Count tiles by type
	tileCounts := w.Tiles.CountTiles()
	for tileID, count := range tileCounts {
		if count > 10000 {
			fmt.Printf("Tile %d: %d blocks\n", tileID, count)
		}
	}

	// Count liquids
	liquidCounts := w.Tiles.CountLiquids()
	fmt.Printf("Water: %d\n", liquidCounts[world.LiquidWater])
	fmt.Printf("Lava: %d\n", liquidCounts[world.LiquidLava])
}

Index

• Variables
• func DiscoverAllMapFiles(testDataRoot string) ([]string, error)
• func DiscoverAllPlayerFiles(testDataRoot string) ([]string, error)
• func DiscoverAllWorldFiles(testDataRoot string) ([]string, error)
• func DiscoverMapFiles(root string) ([]string, error)
• func DiscoverPlayerFiles(root string) ([]string, error)
• func DiscoverTerrariaDirectories(testDataRoot string) ([]string, error)
• func DiscoverWorldFiles(root string) ([]string, error)
• func DiscoverXNBFiles(root string) ([]string, error)
• func FindTestDataRoot(packageDir string) string
• func GetAllTestDataRoots(packageDir string) []string
• func GetExtendedTestDataRoots() []string
• type MapFileInfo
  • func DiscoverMapFilesWithInfo(testDataRoot string) ([]MapFileInfo, error)
• type PlayerFileInfo
  • func DiscoverPlayerFilesWithInfo(testDataRoot string) ([]PlayerFileInfo, error)
• type WorldFileInfo
  • func DiscoverWorldFilesWithInfo(testDataRoot string) ([]WorldFileInfo, error)

Examples

• Package (Buffs)
• Package (Colors)
• Package (Items)
• Package (JourneyResearch)
• Package (PlayerBasics)
• Package (PlayerBuffs)
• Package (PlayerInventory)
• Package (PlayerMapExploration)
• Package (Prefixes)
• Package (RenderExplorationMap)
• Package (RenderMap)
• Package (RenderMapOptions)
• Package (Slots)
• Package (TestDataDiscovery)
• Package (Toggles)
• Package (WorldBasics)
• Package (WorldTiles)
• DiscoverPlayerFiles
• DiscoverWorldFiles

Variables

var TestDataRoots = []string{
	"testdata",
	"../testdata",
	"../../testdata",
}

TestDataRoots are the paths to search for test data files. Tests should use these paths relative to their package location. Order matters: check local testdata first, then parent directories. These paths are all within the gopheria project directory.

Functions

func DiscoverAllMapFiles

func DiscoverAllMapFiles(testDataRoot string) ([]string, error)

DiscoverAllMapFiles finds all .map files across all version directories in testdata. It searches the provided testDataRoot and any extended test data roots from the GOPHERIA_EXTENDED_TESTDATA environment variable.

func DiscoverAllPlayerFiles

func DiscoverAllPlayerFiles(testDataRoot string) ([]string, error)

DiscoverAllPlayerFiles finds all .plr files in testdata. It searches both the root testdata directory and any version subdirectories. It also searches any extended test data roots from the GOPHERIA_EXTENDED_TESTDATA environment variable.

func DiscoverAllWorldFiles

func DiscoverAllWorldFiles(testDataRoot string) ([]string, error)

DiscoverAllWorldFiles finds all .wld files in testdata. It searches both the root testdata directory and any version subdirectories. It also searches any extended test data roots from the GOPHERIA_EXTENDED_TESTDATA environment variable.

func DiscoverMapFiles

func DiscoverMapFiles(root string) ([]string, error)

DiscoverMapFiles finds all .map files (player exploration maps) in the given directory tree. It recursively searches all subdirectories.

func DiscoverPlayerFiles

func DiscoverPlayerFiles(root string) ([]string, error)

DiscoverPlayerFiles finds all .plr files in the given directory tree. It recursively searches all subdirectories and excludes backup files (.bak).

Example

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria"
)

func main() {
	// Find all player files in a directory
	files, err := gopheria.DiscoverPlayerFiles("/path/to/terraria/players")
	if err != nil {
		log.Fatal(err)
	}

	for _, f := range files {
		fmt.Println(f)
	}
}

func DiscoverTerrariaDirectories

func DiscoverTerrariaDirectories(testDataRoot string) ([]string, error)

DiscoverTerrariaDirectories finds all version directories in the testdata root. It looks for directories that match X.X.X.X format (version number only).

func DiscoverWorldFiles

func DiscoverWorldFiles(root string) ([]string, error)

DiscoverWorldFiles finds all .wld files in the given directory tree. It recursively searches all subdirectories and excludes backup files (.bak, .bad).

Example

package main

import (
	"fmt"
	"log"

	"gitlab.com/nicolaw/gopheria"
)

func main() {
	// Find all world files in a directory
	files, err := gopheria.DiscoverWorldFiles("/path/to/terraria/worlds")
	if err != nil {
		log.Fatal(err)
	}

	for _, f := range files {
		fmt.Println(f)
	}
}

func DiscoverXNBFiles

func DiscoverXNBFiles(root string) ([]string, error)

DiscoverXNBFiles finds all .xnb files in the given directory tree. It recursively searches all subdirectories.

func FindTestDataRoot

func FindTestDataRoot(packageDir string) string

FindTestDataRoot finds the testdata directory from the given package directory. It searches upward through TestDataRoots until it finds a valid testdata directory. This function only returns local testdata, not extended paths from environment variable. Use GetAllTestDataRoots() if you need extended paths as well.

func GetAllTestDataRoots

func GetAllTestDataRoots(packageDir string) []string

GetAllTestDataRoots returns all test data roots: local first, then extended. Local roots are searched relative to packageDir using TestDataRoots. Extended roots come from the GOPHERIA_EXTENDED_TESTDATA environment variable.

func GetExtendedTestDataRoots

func GetExtendedTestDataRoots() []string

GetExtendedTestDataRoots returns additional test data root paths from the GOPHERIA_EXTENDED_TESTDATA environment variable. Returns empty slice if not set. Paths are comma-separated and can be absolute or relative.

Types

type MapFileInfo

type MapFileInfo struct {
	Path       string // Absolute path to the file
	RelPath    string // Path relative to testdata root
	VersionDir string // Name of the version directory (e.g., "1.4.4.9")
	Size       int64  // File size in bytes
}

MapFileInfo contains metadata about a discovered map exploration file.

func DiscoverMapFilesWithInfo

func DiscoverMapFilesWithInfo(testDataRoot string) ([]MapFileInfo, error)

DiscoverMapFilesWithInfo finds all .map files with detailed metadata.

type PlayerFileInfo

type PlayerFileInfo struct {
	Path       string // Absolute path to the file
	RelPath    string // Path relative to testdata root
	VersionDir string // Name of the version directory (e.g., "1.4.4.9")
	Size       int64  // File size in bytes
}

PlayerFileInfo contains metadata about a discovered player file.

func DiscoverPlayerFilesWithInfo

func DiscoverPlayerFilesWithInfo(testDataRoot string) ([]PlayerFileInfo, error)

DiscoverPlayerFilesWithInfo finds all .plr files with detailed metadata.

type WorldFileInfo

type WorldFileInfo struct {
	Path       string // Absolute path to the file
	RelPath    string // Path relative to testdata root
	VersionDir string // Name of the version directory (e.g., "1.4.4.9")
	Size       int64  // File size in bytes
}

WorldFileInfo contains metadata about a discovered world file.

func DiscoverWorldFilesWithInfo

func DiscoverWorldFilesWithInfo(testDataRoot string) ([]WorldFileInfo, error)

DiscoverWorldFilesWithInfo finds all .wld files with detailed metadata.