Essential Tools for Schedule 1 Modding

Success in Schedule 1 modding depends on having the right tools. This guide covers the essential software you'll need to analyze, create, and test your mods effectively.

Tool Selection Strategy

Start with the core tools (MelonLoader and dnSpy) before exploring additional options. Each tool serves a specific purpose in the modding workflow, and mastering them in sequence will give you the best foundation.

Core Modding Framework

MelonLoader

The foundation of Schedule 1 modding

MelonLoader is a Universal Mod Loader for Unity games that allows you to run C# mods. It's the primary framework that makes Schedule 1 modding possible.

Installation

1. Download the latest MelonLoader from melonwiki.xyz
2. Run the installer and point it to your Schedule 1 game directory
3. Launch the game once to generate the MelonLoader folder structure

Key Features

• Harmony integration - Patch game methods safely
• Console output - Debug information and logs
• Mod dependency system - Manage mod requirements
• Cross-branch support - Works on both il2cpp and mono branches

Basic Mod Structure

using MelonLoader;
using HarmonyLib;
using UnityEngine;

// Assembly attributes define your mod's metadata
[assembly: MelonInfo(typeof(MyMod), "My First Mod", "1.0.0", "YourName")]
[assembly: MelonGame("TVGS", "Schedule 1")] // Game identification

public class MyMod : MelonMod
{
    // Called when the mod is initialized
    public override void OnInitializeMelon()
    {
        LoggerInstance.Msg("Mod initialized!");
        SetupHarmonyPatches();
    }
    
    // Called when a scene loads
    public override void OnSceneWasLoaded(int buildIndex, string sceneName)
    {
        LoggerInstance.Msg($"Scene loaded: {sceneName}");
    }
    
    private void SetupHarmonyPatches()
    {
        // Apply Harmony patches
        Harmony harmony = new Harmony("com.yourname.mymod");
        harmony.PatchAll();
    }
}

Configuration System

// Example: Setting up mod preferences
private MelonPreferences_Category modCategory;
private MelonPreferences_Entry<bool> enableFeature;
private MelonPreferences_Entry<float> difficultyMultiplier;

public override void OnInitializeMelon()
{
    // Create preference category
    modCategory = MelonPreferences.CreateCategory("MyMod");
    
    // Create preference entries
    enableFeature = modCategory.CreateEntry("EnableFeature", true, "Enable mod feature");
    difficultyMultiplier = modCategory.CreateEntry("DifficultyMultiplier", 1.0f, "Difficulty multiplier");
    
    // Load saved preferences
    MelonPreferences.Load();
}

Code Analysis Tools

dnSpy

Assembly decompilation and analysis

dnSpy is a powerful .NET assembly editor, decompiler, and debugger. It's essential for analyzing Schedule 1's compiled assemblies and understanding the game's code structure.

Installation & Setup

1. Download dnSpy from the official GitHub releases
2. Extract to a folder (no installation required)
3. Open Schedule1_Data\Managed\Assembly-CSharp.dll in dnSpy to analyze game code

Key Features for Modding

• Assembly browsing - Navigate through game classes
• Decompilation - View C# code from compiled assemblies
• Search functionality - Find specific methods or fields
• Export capabilities - Save decompiled code for reference
• Debugging - Attach to game process for runtime analysis

Finding Important Classes Example

To find player-related classes, look in the ScheduleOne.PlayerScripts namespace. This namespace contains most of the player functionality and is a good starting point for player-related modifications.

Common Workflow

1. Open the main game assembly
2. Explore namespaces to understand code organization
3. Find classes related to systems you want to modify
4. Analyze method signatures and dependencies
5. Take notes on important classes and methods for your mod

Pro Tip

Use dnSpy's search feature (Ctrl+Shift+K) to find game classes by name. This is invaluable when looking for specific systems to hook into.

AssetRipper

Unity project extraction and decompilation

AssetRipper extracts and decompiles Unity projects, providing access to both assets and decompiled C# scripts. This gives you a complete view of the game's structure, including the source code organization.

Installation

1. Download from GitHub releases
2. Extract the archive
3. Run AssetRipper.exe

Usage for Code Analysis

1. Load game files - Point AssetRipper to Schedule 1's data folder
2. Export Unity project - Get a complete Unity project with decompiled scripts
3. Analyze script organization - See how classes are organized in the original project
4. Study MonoBehaviour configurations - Understand component setups and references

Key Benefits for Code Analysis

• Complete project structure - See the original Unity project organization
• Decompiled C# scripts - Access to all game scripts in their original file structure
• Asset references - Understand how code connects to game assets
• MonoBehaviour analysis - See component configurations and serialized fields

Legal Notice

Only extract assets for analysis and understanding. Never redistribute original game assets. Create your own content inspired by what you learn.

Practical Example: Analyzing a Game Object

// After using AssetRipper to understand a prefab structure:
public static GameObject CreateCustomObject()
{
    // Create a new GameObject based on analyzed structure
    GameObject obj = new GameObject("CustomObject");
    
    // Add components based on original prefab
    obj.AddComponent<MeshFilter>();
    obj.AddComponent<MeshRenderer>();
    
    // Configure properties based on analyzed values
    MeshRenderer renderer = obj.GetComponent<MeshRenderer>();
    renderer.material = CreateCustomMaterial();
    
    return obj;
}

Development Tools

BepInEx Assembly Publicizer (for mono branch)

Make private members accessible for mod development

The BepInEx Assembly Publicizer modifies game assemblies to make private fields and methods public, simplifying mod development for the mono branch by eliminating the need for reflection.

Installation

1. Download from GitHub releases
2. Extract to a folder
3. Run the tool on the mono branch's Assembly-CSharp.dll

Usage

# Basic usage
AssemblyPublicizer.exe "path\to\Assembly-CSharp.dll"

# With output path
AssemblyPublicizer.exe "path\to\Assembly-CSharp.dll" "path\to\output\Assembly-CSharp.dll"

Benefits for Mono Branch Development

• Direct field access - No need for reflection to access private fields
• Simplified Harmony patching - Easier to patch private methods
• Cleaner mod code - More readable and maintainable code
• Better performance - Avoid reflection overhead

Important

Only use the publicized assemblies for development and testing. Your final mod should still work with the original, non-publicized assemblies that players have.

Runtime Analysis & Debugging Tools

UnityExplorer

In-game runtime analysis and mod debugging

UnityExplorer is a universal MelonLoader mod that provides powerful in-game tools for analyzing game objects, classes, and debugging your mods at runtime. It works with both IL2CPP and Mono branches.

Installation

1. Download the latest UnityExplorer from GitHub releases
2. Place the DLL in your MelonLoader's Mods folder
3. Launch the game - UnityExplorer will be available through a hotkey (default: F7)

Key Features for Mod Development

• Scene Explorer - Browse and inspect game objects in real-time
• Object Inspector - View and modify component properties while the game runs
• C# Console - Execute code and test modifications on the fly
• Hook Manager - Create and manage Harmony hooks in-game
• Free Camera - Navigate the game world for analysis
• Clipboard System - Copy/paste objects and values between inspectors

Essential Use Cases for Modding

1. Mod Debugging

   • Inspect your mod's game objects and components
   • Monitor variable values during gameplay
   • Test code changes without restarting the game
   • Debug Harmony patches in real-time

2. Game Analysis

   • Explore game object hierarchies and relationships
   • Understand component configurations
   • Find references between objects
   • Analyze UI elements and their properties

3. Development & Testing

   • Test Harmony patches before implementing them permanently
   • Experiment with game object modifications
   • Prototype new features using the C# console
   • Validate mod behavior in different game states

Pro Tip

UnityExplorer's C# console is invaluable for mod debugging. Use it to test small code snippets, inspect mod variables, and validate your Harmony patches. Combine it with dnSpy and AssetRipper for a complete analysis workflow.

Example: Debugging a Mod Component

// In UnityExplorer's C# console, you can inspect your mod's components:
var myModComponent = GameObject.FindObjectOfType<MyModComponent>();
if (myModComponent != null)
{
    // Inspect current values
    UnityExplorer.InspectorManager.Inspect(myModComponent);
    
    // Test modifications
    myModComponent.someField = newValue;
    myModComponent.TestMethod();
}

Development Environment

Visual Studio Community

Your primary development IDE

Visual Studio provides the best experience for C# mod development.

Essential Extensions

• Unity Tools - Enhanced Unity project support
• GitHub Extension - Version control integration
• ReSharper (optional) - Advanced code analysis
• Productivity Power Tools - General productivity enhancements

Project Setup Tips

<!-- Example .csproj references for Schedule 1 modding -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <AssemblyTitle>My Schedule 1 Mod</AssemblyTitle>
    <AssemblyVersion>1.0.0.0</AssemblyVersion>
  </PropertyGroup>

  <ItemGroup>
    <Reference Include="MelonLoader">
      <HintPath>References\MelonLoader.dll</HintPath>
      <Private>false</Private>
    </Reference>
    <Reference Include="Assembly-CSharp">
      <HintPath>References\Assembly-CSharp.dll</HintPath>
      <Private>false</Private>
    </Reference>
    <Reference Include="UnityEngine.CoreModule">
      <HintPath>References\UnityEngine.CoreModule.dll</HintPath>
      <Private>false</Private>
    </Reference>
  </ItemGroup>
</Project>

Alternative IDEs

• JetBrains Rider - Excellent for complex projects
• Visual Studio Code - Lightweight option with good C# support
• MonoDevelop - Free alternative with Unity integration

Testing & Debugging Tools

Game Process Monitors

• Process Hacker - Monitor memory usage and performance
• CheatEngine - Runtime memory inspection (advanced users)
• Unity Console - Built-in Unity debugging (when available)

Logging Tools

// Structured logging example
public static class ModLogger
{
    public static void Info(string message) => 
        MelonLogger.Msg($"[INFO] {message}");
    
    public static void Warning(string message) => 
        MelonLogger.Warning($"[WARN] {message}");
    
    public static void Error(string message) => 
        MelonLogger.Error($"[ERROR] {message}");
    
    public static void Debug(string message)
    {
        #if DEBUG
        MelonLogger.Msg($"[DEBUG] {message}");
        #endif
    }
}

Performance Profiling

• Unity Profiler - If accessible through development builds
• Custom performance counters - Track specific mod performance
• Memory leak detection - Ensure mods don't cause issues

Version Control & Collaboration

Git Setup for Modding

# Initialize a new mod repository
git init
git add .gitignore
git commit -m "Initial commit"

# Recommended .gitignore for mod projects
bin/
obj/
*.user
*.dll (except necessary references)

Project Organization

MySchedule1Mod/
├── src/
│   ├── Core/
│   │   └── ModMain.cs
│   ├── UI/
│   │   └── ModUI.cs
│   └── Utils/
│       └── ModLogger.cs
├── refs/          # Game assembly references
├── assets/        # Mod-specific assets
├── docs/          # Documentation
└── build/         # Build output

Next Steps

Now that you understand the essential tools, let's set up your development environment:

👉 Continue to Development Environment Setup →

Tool Comparison Table

Tool	Purpose	Difficulty	Essential
MelonLoader	Mod runtime framework	Easy	✅ Yes
dnSpy	Assembly decompilation	Medium	✅ Yes
AssetRipper	Unity project extraction	Easy	✅ Yes
UnityExplorer	Runtime analysis & mod debugging	Medium	✅ Yes
BepInEx Assembly Publicizer	Assembly modification (mono only)	Easy	⚠️ For mono branch
Visual Studio	Development IDE	Medium	✅ Yes
Git	Version control	Medium	⚠️ Recommended

---

Each tool serves a specific purpose in the modding pipeline. Master these tools, and you'll be well-equipped to tackle any Schedule 1 modding project!