⚙️ Configuration & Customization

Default Configuration Location

Assets/Resources/MedievalBioGenerator/Config/
├── MedievalNameConfig.asset
├── OccupationConfig.asset
├── PersonalityConfig.asset
└── PhysicalTraitsConfig.asset

Configuration Asset Types

MedievalNameConfig Structure

[CreateAssetMenu(fileName = "MedievalNameConfig", menuName = "Medieval Bio/Name Config")]
public class MedievalNameConfig : ScriptableObject
{
    [Header("Male First Names")]
    public string[] MaleFirstNames = {
        "Aldric", "Baldwin", "Cedric", "Edgar", "Godric",
        "Harold", "Leofric", "Oswald", "Ralph", "Wulfric"
    };
    
    [Header("Female First Names")]
    public string[] FemaleFirstNames = {
        "Aelfgifu", "Beatrice", "Cwenhild", "Edith", "Godiva",
        "Hilda", "Leofwen", "Matilda", "Roswitha", "Wulfhild"
    };
    
    [Header("Surname Prefixes")]
    public string[] SurnamePrefixes = {
        "the", "of", "son of", "daughter of", "from"
    };
    
    [Header("Noble House Names")]
    public string[] NobleHouseNames = {
        "House of Thornbury", "House of Blackwood", "House of Silverstone",
        "House of Ravenshire", "House of Goldentower"
    };
    
    [Header("Occupation-Based Surnames")]
    public Dictionary<Occupation, string[]> OccupationSurnames;
}

Custom Name Categories

• Cultural Names: Add specific cultural name sets (Norse, Celtic, etc.)
• Regional Variations: Different name pools for different game regions
• Social Class Names: Distinct naming conventions for nobles vs. commoners
• Religious Names: Saint names, biblical names for religious characters

Occupation Definition System

[System.Serializable]
public class OccupationData
{
    public Occupation Type;
    public string DisplayName;
    public SocialClass DefaultSocialClass;
    public int MinSettlementTier; // 0=Wilderness, 5=Keep
    public int MaxSettlementTier;
    public float[] SettlementProbabilityWeights; // Array for each tier
    public string[] RelatedOccupations;
    public string[] RequiredSkills;
}

Settlement Tier Availability

Personality Trait System

[System.Serializable]
public class PersonalityTrait
{
    public string Name;
    public string Description;
    public float BaseProbability;
    public SocialClass[] CommonInClasses;
    public Occupation[] CommonInOccupations;
    public string[] OppositeTraits;
    public bool IsPositive;
}

public class PersonalityConfig : ScriptableObject
{
    public PersonalityTrait[] Traits = {
        new PersonalityTrait {
            Name = "Brave",
            Description = "Shows courage in the face of danger",
            BaseProbability = 0.3f,
            CommonInClasses = new[] { SocialClass.Noble, SocialClass.Artisan },
            CommonInOccupations = new[] { Occupation.Soldier, Occupation.Knight },
            OppositeTraits = new[] { "Cowardly" },
            IsPositive = true
        }
        // ... more traits
    };
}

Custom Trait Categories

• Virtues: Honesty, Kindness, Generosity, Humility
• Vices: Greed, Pride, Wrath, Envy, Sloth
• Social Traits: Charismatic, Shy, Diplomatic, Aggressive
• Professional Traits: Diligent, Innovative, Traditional, Ambitious
• Personal Quirks: Superstitious, Pious, Romantic, Mysterious

Physical Appearance System

[System.Serializable]
public class PhysicalTraitData
{
    public string BuildType;
    public float HeightModifier;
    public float StrengthModifier;
    public string[] AssociatedOccupations;
    public SocialClass[] CommonInClasses;
    public float ProbabilityWeight;
}

public class PhysicalTraitsConfig : ScriptableObject
{
    [Header("Build Types")]
    public PhysicalTraitData[] BuildTypes = {
        new PhysicalTraitData { BuildType = "Sturdy", HeightModifier = 1.0f, 
            StrengthModifier = 1.2f, AssociatedOccupations = new[] { "Blacksmith", "Laborer" } },
        new PhysicalTraitData { BuildType = "Slender", HeightModifier = 1.1f, 
            StrengthModifier = 0.8f, AssociatedOccupations = new[] { "Scholar", "Merchant" } }
    };
    
    [Header("Hair Colors")]
    public string[] HairColors = { "Black", "Brown", "Blonde", "Red", "Gray", "White" };
    
    [Header("Eye Colors")]
    public string[] EyeColors = { "Brown", "Blue", "Green", "Hazel", "Gray" };
}

Custom Generation Algorithms

public class CustomCharacterGenerator : CharacterBioGenerator
{
    public override CharacterBio Generate(NpcContext context, MedievalNameConfig config = null)
    {
        // Override default generation logic
        var bio = base.Generate(context, config);
        
        // Apply custom modifications
        ApplyCulturalModifications(bio, context);
        ApplyRegionalVariations(bio, context);
        ApplyStoryRequirements(bio, context);
        
        return bio;
    }
    
    private void ApplyCulturalModifications(CharacterBio bio, NpcContext context)
    {
        // Your custom cultural logic here
        if (context.Faction == FactionType.Noble)
        {
            bio.Profile.DisplayName = AddNoblePrefix(bio.Profile.DisplayName);
        }
    }
}

Regional Configuration System

public class RegionalConfig
{
    public string RegionName;
    public MedievalNameConfig NameConfig;
    public OccupationConfig OccupationConfig;
    public float[] SettlementDistribution; // Probability weights for each tier
    public FactionType[] DominantFactions;
    public Color[] RegionalColorPalette; // For UI theming
}

// Usage
var northernKingdom = new RegionalConfig
{
    RegionName = "Northern Kingdoms",
    NameConfig = Resources.Load<MedievalNameConfig>("Configs/NorseNames"),
    OccupationConfig = Resources.Load<OccupationConfig>("Configs/NorthernOccupations"),
    SettlementDistribution = new float[] { 0.3f, 0.4f, 0.2f, 0.08f, 0.02f, 0f, 0f },
    DominantFactions = new[] { FactionType.Civilian, FactionType.Noble },
    RegionalColorPalette = new[] { Color.blue, Color.white, Color.gray }
};

Dynamic Configuration System

public class ConfigManager : MonoBehaviour
{
    private Dictionary<string, MedievalNameConfig> nameConfigs;
    private Dictionary<string, OccupationConfig> occupationConfigs;
    
    public void LoadConfiguration(string configName)
    {
        var nameConfig = Resources.Load<MedievalNameConfig>($"Configs/{configName}/Names");
        var occupationConfig = Resources.Load<OccupationConfig>($"Configs/{configName}/Occupations");
        
        if (nameConfig != null)
        {
            CharacterBioGenerator.SetNameConfig(nameConfig);
        }
        
        if (occupationConfig != null)
        {
            CharacterBioGenerator.SetOccupationConfig(occupationConfig);
        }
    }
    
    public void LoadRegionalConfig(string regionName)
    {
        var regionalConfig = Resources.Load<RegionalConfig>($"Regions/{regionName}");
        if (regionalConfig != null)
        {
            ApplyRegionalSettings(regionalConfig);
        }
    }
}

Configuration Testing Tools

[CustomEditor(typeof(MedievalNameConfig))]
public class MedievalNameConfigEditor : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        
        if (GUILayout.Button("Test Name Generation"))
        {
            TestNameGeneration();
        }
        
        if (GUILayout.Button("Validate Configuration"))
        {
            ValidateConfiguration();
        }
    }
    
    private void TestNameGeneration()
    {
        var config = (MedievalNameConfig)target;
        var testResults = new List<string>();
        
        for (int i = 0; i < 10; i++)
        {
            var name = config.GenerateRandomName(Gender.Male);
            testResults.Add(name);
        }
        
        Debug.Log("Generated Names:\n" + string.Join("\n", testResults));
    }
}

Performance Considerations

• Array Sizes: Keep name arrays reasonably sized (50-200 entries per category)
• Memory Usage: Large configuration files can impact loading times
• Loading Strategy: Load configurations on demand rather than all at once
• Caching: Cache frequently used configurations in memory

Fantasy RPG Configuration

// Elven Name Configuration
public class ElvenNameConfig : MedievalNameConfig
{
    public string[] ElvenMaleNames = {
        "Legolas", "Thranduil", "Celeborn", "Haldir", "Rumil"
    };
    
    public string[] ElvenFemaleNames = {
        "Galadriel", "Arwen", "Tauriel", "Nimrodel", "Celebrían"
    };
    
    public string[] ElvenHouseNames = {
        "House of the Silver Tree", "House of Elrond", "House of Finwë"
    };
}

// Dwarven Occupation Configuration
public class DwarvenOccupationConfig : OccupationConfig
{
    public new OccupationData[] Occupations = {
        new OccupationData { Type = Occupation.Miner, DisplayName = "Deep Delver",
            MinSettlementTier = 1, MaxSettlementTier = 6, DefaultSocialClass = SocialClass.Artisan },
        new OccupationData { Type = Occupation.Smith, DisplayName = "Master Forgekeeper",
            MinSettlementTier = 2, MaxSettlementTier = 5, DefaultSocialClass = SocialClass.Artisan }
    };
}

Historical Simulation Configuration

// Medieval England Configuration
public class MedievalEnglandConfig : RegionalConfig
{
    public MedievalEnglandConfig()
    {
        RegionName = "Medieval England";
        
        // Historically accurate Norman/Saxon names
        NameConfig.MaleFirstNames = new[] {
            "William", "Henry", "Richard", "John", "Robert",
            "Thomas", "Edward", "George", "James", "Charles"
        };
        
        // Realistic medieval occupations
        OccupationConfig.Occupations = new[] {
            new OccupationData { Type = Occupation.Reeve, DisplayName = "Manor Reeve",
                MinSettlementTier = 2, MaxSettlementTier = 4, DefaultSocialClass = SocialClass.Commoner },
            new OccupationData { Type = Occupation.Bailiff, DisplayName = "Bailiff",
                MinSettlementTier = 3, MaxSettlementTier = 5, DefaultSocialClass = SocialClass.Commoner }
        };
        
        // Realistic settlement distribution
        SettlementDistribution = new float[] { 0.1f, 0.3f, 0.4f, 0.15f, 0.04f, 0.01f, 0f };
    }
}