tModLoader/tModLoader

Features

• Custom Content Creation - tModLoader uses an API with polymorphic classes to add new items, projectiles, and players to the game.
• Hot Code Reloading - Updates running code in real-time without restarting the game through a hot-reloading assembly runtime.
• Game Modification Frameworks - Provides a framework for patching internal game methods and accessing private members via IL editing and reflection.
• Multiplayer Networking - Provides a comprehensive framework for synchronizing game state and netcode between all connected participants.
• Modding Frameworks - Provides a dedicated API and toolset for creating custom items, enemies, and world assets.
• Mod Loaders - Provides the core mechanism to load, apply, and unload mod packages within the game environment.
• Inter-Mod Dependency Management - Implements strong dependency requirements to ensure a specific mod is present for direct class access.
• Game Asset Management - Handles loading, packaging, and localizing textures, sounds, and shaders for modded game integration.
• Modding - Provides infrastructure to save and load mod-specific data using structured compounds.
• Item Management - Synchronizes the status and properties of dropped items and chest contents across the network.
• Mod State Persistence - Implements a nestable key-value format to persist mod state for players and worlds.
• Property Synchronizers - Updates item data across the network during inventory changes to maintain consistency for all players.
• Runtime Project Recompilation - Modifies source code and recompiles the project while the game is running to apply changes instantly.
• Generation Sequence Management - Allows developers to adjust the world generation sequence by inserting custom logic or removing existing stages.
• Modded Game Server Deployment - Provides management scripts to install and run game servers on Windows, Linux, and macOS.
• 2D User Interface Construction - Provides a dedicated system for building game-specific HUDs, menus, and interactive screens.
• Crafting Recipe Definitions - tModLoader specifies the materials and requirements needed for users to craft a custom item.
• Custom Game Behaviors - Overrides predefined virtual methods to trigger custom logic and special effects during game events.
• Data-Driven Item Definitions - tModLoader sets behavioral attributes for items, including combat damage, use animations, and rarity.
• Game Item Definitions - tModLoader defines new items with specific dimensions, rarities, and values to integrate into the game world.
• Entity Definition APIs - tModLoader creates new game objects, such as items or projectiles, by inheriting from base classes.
• Entity Spawning Systems - Creates NPCs or items at specific coordinates or relative to the player in the world.
• Entity Transform Management - Tracks 2D coordinates and movement vectors to control the location and speed of game elements.
• Game Content Extension - tModLoader creates new items, enemies, furniture, pets, bosses, and NPCs to expand the game world.
• Gameplay Extensions - Allows development of new systems like leveling and questing to extend core gameplay mechanics.
• Game Logic Modification - Alters vanilla game behaviors, recipes, and entity properties using hooks, injections, and reflection.
• Game Logic Scripting - Allows the definition of custom entity behaviors, spawning rules, and loot drops through scripting.
• Gameplay Stat Modifiers - tModLoader adjusts combat attributes, movement speeds, and resource capacities to alter gameplay balance.
• Global State Broadcasting - Pushes global state updates from the server to all connected clients to trigger shared game events.
• Item Collection and Crafting Systems - Implements systems for defining item combinations and requirements to craft new equipment.
• Movement Physics Simulation - Adjusts entity velocity over time to simulate gravity, wind resistance, and homing behaviors.
• Noise-Based Terrain Generation - Provides a framework for scripting the procedural creation of landscapes, structures, and walls.
• NPC Spawning - Creates new non-player character instances with optional AI initialization data.
• Headless Servers - Supports launching dedicated game servers without graphical interfaces via pre-defined configuration.
• Player Entity Extensions - Adds custom data and logic to player entities to modify their behavior and stats.
• Player State Synchronization - Transmits player appearance, health, buffs, and inventory across the multiplayer network.
• Player Status Effect Controls - tModLoader toggles immunity, damage reduction, and environmental protections to change how the player interacts with hazards.
• Procedural World Building - Inserts custom generation passes into a sequenced execution order to create terrain and structures.
• Programmatic World Modification - Provides methods to place and remove tiles during creation or gameplay to customize landscapes.
• Projectile Definitions - tModLoader defines a projectile's core properties, such as hitbox size and damage type, using a dedicated class.
• Projectile Spawning - Creates projectile entities with specified coordinates, velocity, damage, and ownership.
• Regional State Synchronization - Sends state updates from the server to clients when players enter specific regions or tile properties change.
• Voxel World Generation - Implements the core logic for procedurally generating terrain and structures during world creation.
• Generation Pipeline Ordering - Enables the registration of custom generation logic into the world creation sequence with specified execution orders.
• World Generation Runners - Implements runners to place tiles and ores during world generation while preserving existing structures.
• Text Content Localization - tModLoader adds translated text and language support to make content accessible to a global audience.
• Tile Definition Systems - Provides an API to define custom tiles with physical properties like solidity and light emission.
• Tile Entity State Synchronization - Saves custom tile entity states to disk and synchronizes these values between the server and clients.
• Tile Entity Systems - Creates complex tiles with persistent data and custom placement hooks.
• World Modification Synchronization - Implements network synchronization of tile and rectangular area changes to keep world modifications consistent across all clients.
• World State Synchronization - Updates all clients on global data including game time, weather, and boss progression.
• 2D Sprite Animations - Implements 2D sprite animations by sequencing multiple frames from a single image.
• Custom Protocol Implementations - Implements custom network protocols and binary data handling to synchronize state between clients and servers.
• Multiplayer Connection Handshaking - Handles the network handshake process, version validation, and the ability to kick players from a session.
• Packet Construction - Writes binary data to network packets to synchronize state between client and server.
• Game State Synchronization - Synchronizes game state between clients and servers by transmitting binary data packets for entities and world changes.
• Request Data Transmission - Sends raw netcode data and custom message types between clients and the server.
• Class Method Overrides - Intercepts and replaces original game method implementations to extend or customize core behavior.
• Runtime Bytecode Instrumentation - Modifies low-level intermediate language instructions at runtime to alter game behavior.
• Conditional Mod Loading - Prevents specific content from loading based on whether other required or conflicting mods are enabled.
• Object Serialization - Defines serialization interfaces to convert complex classes into a persistable save format.
• Polymorphism - Uses object-oriented inheritance from base classes to define new items, NPCs, and projectiles with custom behaviors.
• Bytecode Logic Modification - Alters the low-level bytecode of a method at runtime to change its behavior.
• Code Modification Systems - Edits intermediate language instructions to change behavior in methods where standard hooks are unavailable.
• Code Patching Engines - Implements a patching system to modify existing source code for updates and licensing compliance.
• Logic Hooks - Bridges custom assemblies with base logic by subscribing to events at defined execution points in the game loop.
• Logic Overrides - Allows replacing internal vanilla game logic with modded hooks to modify player stats and particle effects.
• Method Logic Injection - Bridges custom assemblies with base logic by injecting code at defined execution points.
• Client-Server State Synchronization - Synchronizes entity position, health, and AI data between server and clients to ensure consistent behavior.
• Game AI - Copies existing projectile movement and behavior by assigning specific AI styles and types.
• Minion Targeting Logic - Controls how summoned entities target enemies and execute attacks via contact damage.
• Build And Packaging - Transforms source code into distributable package files through an integrated build menu.
• Tile Variant Management - Supports the creation of multiple visual and functional variants for a single base tile type.
• Cross-Mod Logic Patching - Modifies the behavior of external mods by replacing methods or performing granular IL changes.
• Workshop Integration - Downloads and activates community-made content via an integrated workshop or manual placement.
• Lifecycle Hooks - Defines explicit load and unload routines for custom components to ensure proper resource initialization.
• Modset Management - Allows creating and exporting lists of enabled mods to share configurations or maintain version sets.
• Ingredient Consumption Logic - tModLoader defines custom rules for whether ingredients are consumed upon crafting, including random retention.
• External Content Integrations - References items or assets from other modules to integrate them into recipes, shops, and loot tables.
• Mod Publishing - Supports uploading mods to a community workshop and managing stable or preview builds.
• Mod Workshop Publishing - Uploads server-side mods to a public workshop with controls for visibility and tagging.
• Configuration Persistence - tModLoader defines customizable settings for a mod stored as JSON files to persist user preferences.
• API Compatibility Migrations - Automatically applies code fixes to maintain mod compatibility across major framework releases.
• Automated Code Fix Suggestions - Offers automated code fix suggestions based on detected issues to improve mod stability and quality.
• Code Expressiveness Suggestions - Analyzes common code patterns to suggest more expressive and concise alternatives to improve overall clarity.
• Asset Bundling - Packages assemblies, images, sounds, and libraries into single compressed binary files for distribution.
• Build Validation Tools - Includes tools to verify source code for compilation errors to ensure stability before deployment.
• Code Quality and Analysis - Analyzes source code to identify magic numbers and suggest named identifier replacements for better maintainability.
• Compiler Command Line Interfaces - Allows developers to compile mods from source folders directly via command line arguments.
• Hot Reloading - Detects changes to localization files and updates text in-game instantly without a rebuild.
• Diagnostic Logging - Outputs diagnostic messages to the chat window, log files, or floating world text for troubleshooting.
• Decompiled Code Browsers - Enables stepping into framework methods by automatically decompiling managed code to source.
• Network Role Execution Control - Restricts logic execution to specific network roles to prevent state desynchronization between clients and servers.
• Game Item Spawning Tools - Provides tools to place physical item instances into the game world at specific coordinates.
• Breakpoint Debugging - Provides the ability to set breakpoints and inspect variables during execution to resolve bugs in real-time.
• Inter-Plugin Communication - Sends formatted messages to other modules to trigger behaviors without requiring direct code dependencies.
• Constant Identifier Substitutions - Identifies raw numeric constants in source code and suggests replacing them with named ID constants.
• Boilerplate Upgraders - Converts outdated project files into compatible formats to enable continued development on older mods.
• Runtime Version Switching - Allows switching between stable, legacy, and preview versions to ensure compatibility with specific mods.
• Network State Optimization - Transmits large state updates using specialized synchronization methods to minimize network traffic.
• World Generation Threading - Executes intensive world modification logic on separate threads to prevent the game from freezing.
• Restart Automation - Applies changes to the running mod instantly without requiring a full game reboot.
• AI Style Mapping - Assigns specific movement and targeting logic to projectiles by mapping them to internal AI styles.
• Ammo Type Categorization - tModLoader creates new categories of ammunition to allow custom weapons to use unique ammo types.
• Ammunition Consumption Logic - tModLoader controls whether ammunition is consumed only on the first or last shot of an animation.
• Asset Autoloading - tModLoader registers image files as environment backgrounds by detecting files in designated directories.
• Asynchronous Asset Loading - Provides flexible asset loading strategies, allowing resources to be loaded at boot or on-demand to balance memory and stability.
• Audio Event Mapping - tModLoader links specific sound assets to game events, such as item usage, so they trigger automatically.
• Auto-Tiling Systems - Builds tiles that adjust visual frames based on adjacent tiles for seamless environments.
• Biome Transformation Logic - Defines the rules for how tiles transform when exposed to in-game infection or purification effects.
• Combat Resolution Systems - tModLoader calculates damage using an equation where mods contribute modifiers for penetration and crit.
• Combat System Configurators - tModLoader sets armor penetration, critical strike chance, and damage classes for projectiles.
• Crafting Environmental Requirements - Restricts the ability to craft items unless specific environmental requirements are met.
• Crafting Recipe Modifications - Provides the ability to tweak or disable base game and modded crafting recipes.
• Cross-Mod Recipe Integration - Integrates items or tiles from different mods into recipes with fallback logic.
• Save Restoration - Maintains and recovers archived versions of world and player files to prevent data loss.
• Enemy and Boss Battle Systems - Enables the programming of custom movement and attack patterns for bosses and minions.
• Spawning Triggers - Implements logic to trigger boss appearances at specific locations relative to the player.
• Entity Collision Control - Determines how summoned entities interact with world tiles, such as falling through platforms.
• Entity Property Definitions - Assigns boolean flags and data to vanilla content via specialized sets to trigger specific game behaviors.
• Equipment Slot Definitions - Enables custom accessory slots to support loadout colors and server-side validation.
• Equipment Visual Asset Definition - Defines visual assets for armor and accessories, including specialized extended arm sprites.
• Game Asset Referencing - Uses named ID classes to reference existing game assets, avoiding the use of hardcoded numerical values.
• Object Spawning - Implements probability and condition-based logic for spawning creatures based on biomes and events.
• Generation Area Protection - Prevents overlapping generation passes by marking specific rectangular world areas as occupied.
• Homing Logic - Adjusts a projectile's velocity to track and move toward the nearest enemy or mouse cursor.
• In-Game Inventory Querying - Provides the ability to check for the presence of specific items within a player's inventory.
• Ammunition Systems - tModLoader transforms standard items into ammunition by assigning them to ammo classes and defining projectile behavior.
• Interactive Tile Logic - Creates interactive world blocks that integrate with wiring and lighting systems.
• Item Drop Logic - tModLoader sets drop probabilities and selection rules for items based on game difficulty.
• Item Pickup Logic - Executes specific game logic through hooks when players pick up items in the world.
• Item Use Timing - Manages the duration of item use cycles and the cooldown periods before an item can be reused.
• Localization Overrides - tModLoader replaces existing game localization values by defining original game keys within mod files.
• Loot Chest Placement - Adds chests to the world and populates them based on depth or loot tables.
• Loot Rule Systems - Supports nesting multiple drop rules to create dependent logic for item loot.
• Loot Table Definitions - Configures the items dropped by NPCs using specific rules for both custom and vanilla entities.
• Mod Asset Metadata Management - tModLoader manages display names and tooltips for modded content using external configuration files.
• Mod Content Autoloading - Implements custom loading logic to reduce boilerplate and remove default constructor requirements for mod content.
• Multi-Tile Systems - Defines complex tiles that occupy multiple grid coordinates with internal rendering coordinates.
• NPC Behavior Systems - Configures NPC properties such as combat stats and hit sounds by referencing existing entity data.
• NPC Interaction Overrides - Overrides or extends the behavior triggered when a player hovers over or right-clicks an NPC.
• NPC Shop Systems - Registers NPC shops using a declarative system with conditional item availability.
• Collision Event Handlers - Provides callback systems that trigger specific game logic when projectiles intersect with enemies or tiles.
• Player Equipment Management - Tracks and modifies items in the player's inventory and armor slots, including vanity and accessory equipment.
• Resource Capacity Management - tModLoader adjusts maximum health and mana and adds custom visual overlays to the resource UI.
• Projectile AI - Controls how projectiles move and act by implementing logic for timers, gravity, and rotation.
• Explosive Behaviors - tModLoader creates projectiles that trigger explosions and damage players within a specific hitbox.
• Weapon-Projectile Attachment - tModLoader links a projectile to a player's hand and rotation to simulate weapons like drills or spears.
• Projectile Physics Configuration - Defines how projectiles interact with the environment by adjusting collision and physics.
• Projectile Rendering - Allows overriding default drawing behavior to implement effects like fade-ins and afterimage trails for projectiles.
• Entity Projectile Overriding - tModLoader changes the specific projectile launched by an entity by overriding internal IDs with modded types.
• Recipe Availability Logic - Requires specific world states or boss milestones to be met before a recipe can be used.
• World State Analysis - Checks global environmental conditions, including weather and biome generation, to analyze world state.
• Status Effect Systems - Adds status effects to players or NPCs and checks for the presence of specific active buffs.
• Structure Stamping - Exports binary selections of tiles to be copied into the world as single units.
• Summoning Slot Management - Configures how many slots a minion occupies and restricts summoning based on player capacity.
• External Library Linking - Links external DLL files to projects to enable shared dependencies and cross-mod content.
• Tile Animations - Creates looping visual animations for tiles by defining vertical spritesheet sequences.
• Tile Framing Systems - Allows overriding default terrain logic to create custom tile merging patterns and textures.
• Tile-Item Associations - Links specific items to tiles so that using the item places the tile and mining the tile drops the item.
• Tile Metadata Layers - Attaches custom data properties and frame-by-frame logic to individual world tiles.
• Automated Build Pipelines - Integrates with version control to automatically build and verify mods upon each commit.
• Execution Debugging - Runs the game with an attached debugger to set breakpoints and inspect mod state in real-time.
• Modpack Loading - Loads predefined collections of mods via modpack names to facilitate concurrent playthroughs.
• Remote Mod Importing - Enables searching and downloading community-created content via an integrated browser.
• Terrain Shape Chaining - Creates organic shapes and structures by chaining together conditions and modifiers for tile placement.
• Unified Gameplay Conditions - tModLoader sets requirements for NPC loot drops and integrates these conditions into the game's bestiary UI.
• Drop Restrictions - tModLoader limits item drops to specific scenarios based on game events, biomes, or boss progress.
• Vendor Inventory Logic - Determines which items a vendor sells based on a set of required conditions.
• Wall Tile Systems - Enables the creation of custom placeable wall types paired with specific items.
• Weapon-Projectile Mapping - tModLoader connects weapons to specific projectiles by defining ammo classes and assigning ammo items.
• World Chunk Streaming - Pushes specific chunks of the world map and NPC information to clients for multiplayer synchronization.
• World Coordinate Scanning - Provides the ability to scan for coordinates that satisfy specific conditions before placing structures in the world.
• World Lifecycle Hooks - Provides hooks to execute logic immediately after the world loads or is cleared.
• Character Model Animations - Produces animation sprites for armor sets that correctly align with character movement.
• Particle Effect Simulations - Implements a system for generating and configuring visual dust particles with custom size, color, and velocity.
• Texture Animations - Cycles through sequence of texture frames using custom timing to create moving visual effects for walls.
• Coordinate-Based Lighting - Adds light to specific tile coordinates to change the visual environment.
• Visual Effect Shaders - Supports the development of custom GLSL shaders to alter game lighting and graphical effects.
• Texture-Specific Shaders - Modifies how specific textures, such as armor, are drawn to create visual effects like dyes.
• Seamless Texture Drawing - Sets up visual assets using styles and frame numbers to create seamless patterns for walls.
• Shader Filter Applications - Applies global screen-wide shaders to create visual effects such as color tints and distortions.
• Interactive Sound Effect Managers - tModLoader retrieves, modifies, or stops a currently playing sound instance in real-time.
• Class Member Access - Utilizes reflection to interact with internal classes and fields when public interfaces are unavailable.
• Reflection-Based Access - Uses runtime type inspection to read or modify private fields and classes to bypass access restrictions.
• Game Property Datasets - Provides a dataset of existing game item attributes to help modders replicate specific behaviors.
• NPC Physical Attributes - Sets physical attributes and behavioral traits for NPCs, including hitbox size and health.
• Status Effect Immunities - Defines NPC immunity to specific debuffs and implements immunity inheritance.
• ID Type Validation - Detects when an incorrect ID class is used in a method call to prevent logical bugs.
• Method Interception Proxies - Intercepts target method calls and redirects them to custom implementations for modified logic.
• Ingredient Groups - tModLoader allows a recipe requirement to be satisfied by any one item from a predefined set of materials.
• Data Migration - Transfers mods, worlds, and characters between major version iterations of the framework.
• World Progression Tracking - Tracks global state changes and milestones, such as boss defeats, to manage world progression.
• Behavior Mimicry - Implements complex entity logic by adapting original source code into mod hooks to mimic vanilla patterns.
• Coordinate Space Transformations - Translates positions between world space, tile grids, and screen space for correct asset placement.
• Custom UI Component Derivation - tModLoader builds personalized interface components by deriving from a base element class and overriding methods.
• Custom UI Components - Allows the creation of interactive graphical components like buttons and panels using custom drawing logic.
• Event Handling Systems - Triggers specific modded actions in response to user inputs like mouse clicks and hovers.
• Game Item Localizations - tModLoader customizes the display names and tooltips for items to support different languages.
• Configuration Menus - Provides customizable settings menus with dropdowns and panels for mod configuration.
• Tactile and Visual Feedback - Generates combined visual and auditory feedback, such as dust particles and dynamic lighting, for projectiles.
• Game - Enables the creation of interactive UI elements and visual menus to enhance the player experience.
• UI Layout Design - Organizes multiple UI elements into a single canvas to control their initialization and rendering.
• Custom UI Overlays - Injects custom user interface layers into the game engine to render modded menus and overlays.
• Content Translation - tModLoader translates user-facing text into multiple languages using HJSON files for accessibility.

سجل النجوم