[VM_ScriptContextMenu("Randomize all", nameof(RandomizeAll))]
[VM_ScriptContextMenu("Clear all", nameof(ClearAll), enableIf: nameof(HasAnyValue))]
[VM_ScriptContextMenu("", null)]
[VM_ScriptContextMenu("Tools/Generate ID", nameof(GenerateId))]
[VM_ScriptContextMenu("Tools/Copy ID", nameof(CopyId), enableMode: eEnableMode.Editor)]
public class MyComponent : MonoBehaviour
{
   // your fields and methods...
}

// 1. As a HexColor constant in an attribute parameter (Name Color format)
[VM_Label("Health")]
[VM_ProgressBar(0, nameof(_maxLife), hexColorBar: HexColor.Blue600)]
public int _health;

// 2. As a runtime Color value (RGB-float format)
renderer.material.color = new Color(0.039f, 0.624f, 0.969f);

[VM_Note("The \"Player\" tag must be set so that the object can interact with other objects.")]
[VM_Label("🧙 Player tag")]
[VM_Tag]
public string _tagPlayer;

[VM_Space(10)]
[VM_Note("Health cannot go below 0.\nRegeneration starts after 3 seconds of no damage.")]
[VM_Note("Tip: used <b>VM_Clamp</b> to enforce the valid range.")]
[VM_Label("❤️ Health")]
[VM_Suffix("HP")]
[VM_Clamp(0, 1000)]
public int _health = 100;

[VM_Space(10)]
[VM_Note("These messages support some rich text tags:\n" +
         "✅ <noparse><b>Noparse text</b></noparse> <noparse>(<noparse><b>Noparse text</b></noparse>)</noparse>\n" +
         "✅ <b>Bold text</b> <noparse>(<b>Bold text</b>)</noparse>\n" +
         "✅ <i>Italic text</i> (<noparse><i>Italic text</i></noparse>)\n" +
         "✅ <u>Underlined text</u> (<noparse><u>Underlined text</u></noparse>)\n" +
         "✅ <color=red>Colored</color> <color='#FF00FF'>text</color> (<noparse><color=red>Colored</color> <color='#FF00FF'>text</color></noparse>)\n" +
         "✅ <a href='https://vm-gamedev.com/'>Web link</a> (<noparse><a href='https://vm-gamedev.com/'>Web link</a></noparse>)")]
[VM_Label("🏃 Speed")]
[VM_Suffix("m/s")]
public float _speed = 5f;

[VM_Space(10, beforeGroup: "Visuals")]
[VM_Note("Customizing a group of character appearance parameters.", beforeGroup: "Visuals")]
[VM_VerticalGroup("Visuals", label: "🎨 Visuals")]
[VM_Label("🖌️ Skin Color")]
public Color _skinColor = Color.white;
[VM_VerticalGroup("Visuals")]
[VM_Note("This material is used in inventory!")]
[VM_Label("🧱 Material")]
public Material _material;

[VM_Code("Bitmask formula:\n" +
         "  mask = 1 << layer\n" +
         "  Physics.Raycast(ray, hit, dist, mask)")]
[VM_Label("📡 Raycast Mask")]
public LayerMask _raycastMask;

[VM_Space(10)]
[VM_Code("These messages support some rich text tags:\n" +
         "✅ <noparse><b>Noparse text</b></noparse> <noparse>(<noparse><b>Noparse text</b></noparse>)</noparse>\n" +
         "✅ <b>Bold text</b> <noparse>(<b>Bold text</b>)</noparse>\n" +
         "✅ <i>Italic text</i> (<noparse><i>Italic text</i></noparse>)\n" +
         "✅ <u>Underlined text</u> (<noparse><u>Underlined text</u></noparse>)\n" +
         "✅ <color=red>Colored</color> <color='#FF00FF'>text</color> (<noparse><color=red>Colored</color> <color='#FF00FF'>text</color></noparse>)\n" +
         "✅ <a href='https://vm-gamedev.com/'>Web link</a> (<noparse><a href='https://vm-gamedev.com/'>Web link</a></noparse>)")]
[VM_Code("In addition to Unity's standard rich text tags, <b>VM_Code</b> supported a custom tag:\n" +
         "✅ <b><noparse><hang>...</hang></noparse></b> — <hang>hanging indent. " +
         "When a line wraps, continuation lines align with the position where the tag was opened. " +
         "Useful for parameter lists, bullets, and any case where you want a clean visual hierarchy on wrap.</hang>")]
[VM_Label("📝 Text Demo")]
public string _richTextDemo = "some text";

[VM_Space(10, beforeGroup: "Visuals")]
[VM_Code("Format: <b>class Inventory : IGridAccessor</b> (256 cells)", beforeGroup: "Visuals")]
[VM_VerticalGroup("Visuals", label: "🎨 Visuals")]
[VM_Label("🖌️ Skin Color")]
public Color _skinColor = Color.white;
[VM_VerticalGroup("Visuals")]
[VM_Code("How to use: <b>Inventory.AttachMaterialToItem(Material material)</b>")]
[VM_Label("🧱 Material")]
public Material _material;

[VM_Warning("This reference must be assigned before entering Play Mode.")]
[VM_Label("🎯 Required Target")]
public GameObject _requiredTarget;

[VM_Space(10)]
[VM_Warning("Enabling debug mode reduces performance.")]
[VM_Warning("Use only during development!")]
[VM_Label("🐛 Debug Mode")]
public bool _debugMode = false;

[VM_Space(10)]
[VM_Warning("These messages support some rich text tags:\n" +
         "✅ <noparse><b>Noparse text</b></noparse> <noparse>(<noparse><b>Noparse text</b></noparse>)</noparse>\n" +
         "✅ <b>Bold text</b> <noparse>(<b>Bold text</b>)</noparse>\n" +
         "✅ <i>Italic text</i> (<noparse><i>Italic text</i></noparse>)\n" +
         "✅ <u>Underlined text</u> (<noparse><u>Underlined text</u></noparse>)\n" +
         "✅ <color=red>Colored</color> <color='#FF00FF'>text</color> (<noparse><color=red>Colored</color> <color='#FF00FF'>text</color></noparse>)\n" +
         "✅ <a href='https://vm-gamedev.com/'>Web link</a> (<noparse><a href='https://vm-gamedev.com/'>Web link</a></noparse>)")]
[VM_Label("🚀 Max Velocity")]
[VM_Suffix("m/s")]
[VM_Clamp(1, 500)]
public float _maxVelocity = 50f;

[VM_Space(10, beforeGroup: "Visuals")]
[VM_Warning("Don't forget to customize a group of character appearance parameters!", beforeGroup: "Visuals")]
[VM_VerticalGroup("Visuals", label: "🎨 Visuals")]
[VM_Label("🖌️ Skin Color")]
public Color _skinColor = Color.white;

[VM_VerticalGroup("Visuals")]
[VM_Warning("Don't forget to assign this material to an item in your inventory!")]
[VM_Label("🧱 Material")]
public Material _material;

[VM_Title("🏃 Movement", fontSize: 15, hexColorTitle: HexColor.Green600, align: eAlign.Center, thicknessLine: 0)]
[VM_Label("🏃 Speed")]
[VM_Suffix("m/s")]
public float _speed = 5f;
[VM_Label("🦘 Jump Height")]
[VM_Suffix("m")]
public float _jumpHeight = 2f;

[VM_Title("⚔️ Combat Stats", align: eAlign.Center, hexColorTitle: HexColor.Indigo700, hexColorLine: HexColor.Indigo700, thicknessLine: 4)]
[VM_Label("💥 Damage")]
[VM_Suffix("HP")]
public int _damage = 10;
[VM_Label("⏱️ Attack Rate")]
[VM_Suffix("sec")]
public float _attackRate = 1.5f;

[VM_Title("Visual Settings", align: eAlign.Right)]
[VM_Label("🖌️ Tint Color")]
public Color _tintColor = Color.white;
[VM_Label("🧱 Material")]
public Material _material;

[VM_Title("🐛 Debug", fontSize: 11, fieldOnly: true, thicknessLine: 2)]
[VM_Label("👁️ Show Gizmos")]
public bool _showGizmos = false;
[VM_Label("📋 Log Events")]
public bool _logEvents = false;

[VM_Label("🏃 Speed")]
[VM_Suffix("m/s")]
public float _speed = 5f;
[VM_Label("🦘 Jump Height")]
[VM_Suffix("m")]
public float _jumpHeight = 2f;

[VM_Separator(hexColor: HexColor.Indigo700, thickness: 6)]
[VM_Label("❤️ Health")]
[VM_Suffix("HP")]
public int _health = 100;
[VM_Label("🛡️ Armor")]
[VM_Suffix("%")]
public int _armor = 25;

[VM_Separator(hexColor: HexColor.Green600, fieldOnly: true)]
[VM_Label("🖌️ Tint Color")]
public Color _tintColor = Color.white;
[VM_Label("🧱 Material")]
public Material _material;

[VM_Separator(fieldOnly: true, thickness: 1)]
[VM_Label("👁️ Show Gizmos")]
[VM_Toggles]
public bool _showGizmos = false;
[VM_Label("📋 Log Events")]
public bool _logEvents = false;

[VM_LabelWidth(0.25f)]


[VM_Label("🎥 Main Camera", tooltip: "reference to the camera in the scene")]
public Camera _camera;

[VM_Label("🧙 Unit", tooltip: "prefab model for the unit")]
public GameObject _unit;

[VM_Label("❤️ Life", tooltip: "current amount of Health Points", bold: true)]
[VM_Min(0)]
public int _life = 1;

[VM_Label("🔮 Mana", tooltip: "current amount of Mana Points", hexColor: HexColor.Blue800)]
[VM_Min(0)]
public int _mana = 0;

[VM_Label("👁️ Visibility", tooltip: "enemy visibility radius", italic: true)]
[VM_Min(1f)]
public float _visibility = 5f;

[VM_Label("⚔️ Melee Skill", tooltip: "сlose combat parameters", bold: true)]
[VM_NestedColor(hexColor: HexColor.Blue300)]
public MeleeSkill _meleeSkill;

[VM_Label("🏹 Ranged Skill", tooltip: "long-range attack parameters", underline: true, hexColor: HexColor.Green700)]
public RangedSkill _rangedSkill;

[System.Serializable]
public class CriticalDamage
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("🚩 Applied", tooltip: "critical hit applying flag", bold: true, underline: true, hexColor: HexColor.Red600)]
   public bool _applied = false;

   [VM_Label("🎲 Probability", tooltip: "critical hit chance")]
   [VM_RangeSlider(1, 100)]
   public int _probability = 50;

   [VM_Label("✖️ Damage Multiplier", tooltip: "damage multiplier for critical hit")]
   [VM_RangeSlider(1f, 10f)]
   public float _multiplier = 2.5f;
}
[System.Serializable]
public class MeleeSkill
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("💥 Damage", tooltip: "damage range")]
   [VM_Range]
   public Vector2Int _damage = new(0, 10);

   [VM_NestedAsGroup("☠️ Critical Hit", hexColor: HexColor.Red200)]
   public CriticalDamage _critical;
}
[System.Serializable]
public class RangedSkill
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("💥 Shot damage", tooltip: "damage range")]
   [VM_Min(1)]
   public int _damage = 1;

   [VM_NestedAsGroup("☠️ Critical Hit")]
   public CriticalDamage _critical;

   [VM_Label("📏 Shot Distance", tooltip: "maximum shooting range")]
   [VM_Min(0f)]
   public float _rangeDistance = 40f;

   [VM_Label("🎯 Number of Arrows", tooltip: "number of available shots")]
   [VM_Min(0)]
   public int _numArrows = 1;
}

[VM_LabelWidth(0.25f)]

[VM_Label("🎥 Main Camera", tooltip: "reference to the camera in the scene")]
[VM_Suffix("in scene", showOutside: true, width: 45)]
public Camera _camera;

[VM_Label("🧙 Unit", tooltip: "prefab model for the unit")]
[VM_Suffix("prefab", showOutside: true, width: 45)]
public GameObject _unit;

[VM_Label("❤️ Life", tooltip: "current amount of Health Points")]
[VM_Suffix("HP")]
[VM_Min(0)]
public int _life = 1;

[VM_Label("🔮 Mana", tooltip: "current amount of Mana Points")]
[VM_Suffix("MP")]
[VM_Min(0)]
public int _mana = 0;

[VM_Label("👁️ Visibility", tooltip: "enemy visibility radius")]
[VM_Suffix("m")]
[VM_Min(1f)]
public float _visibility = 5f;

[VM_Label("⚔️ Melee Skill", tooltip: "сlose combat parameters")]
public MeleeSkill _meleeSkill;

[VM_Label("🏹 Ranged Skill", tooltip: "long-range attack parameters")]
public RangedSkill _rangedSkill;

[VM_List("❤️ Add Health")]
[VM_RangeSlider(0, 100)]
[VM_Suffix("HP")]
public List<int> _fieldList = new();

[VM_Dictionary("🎯 Stat Caps")]
[VM_RangeSlider(0, 100)]
[VM_Suffix("%")]
public SerializedDictionary<string, int> _statCaps = new();

[VM_Title("NonSerialized Fields")]

[VM_ShowInInspector]
[VM_Label("Private")]
[VM_Suffix("chars")]
private string _privateValue = "some text ...";

[VM_ShowInInspector]
[VM_Label("Property (get/set)")]
[VM_Suffix("symbols", showOutside: true)]
public string PropertyValue { get; set; } = "some text ...";

[System.Serializable]
public class MeleeSkill
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("💥 Damage", tooltip: "damage range")]
   [VM_Range]
   [VM_Suffix("HP")]
   public Vector2Int _damage = new(0, 10);

   [VM_NestedAsGroup("☠️ Critical Hit")]
   public CriticalDamage _critical;
}

[System.Serializable]
public class RangedSkill
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("💥 Shot damage", tooltip: "damage range")]
   [VM_Suffix("HP", width: 30)]
   [VM_Min(1)]
   public int _damage = 1;

   [VM_NestedAsGroup("☠️ Critical Hit")]
   public CriticalDamage _critical;

   [VM_Label("📏 Shot Distance", tooltip: "maximum shooting range")]
   [VM_Suffix("m", width: 30)]
   [VM_Min(0f)]
   public float _rangeDistance = 40f;

   [VM_Label("🎯 Number of Arrows", tooltip: "number of available shots")]
   [VM_Suffix("pcs", width: 30)]
   [VM_Min(0)]
   public int _numArrows = 1;
}

[System.Serializable]
public class CriticalDamage
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("🚩 Applied", tooltip: "critical hit applying flag")]
   [VM_Suffix("on|off", showOutside: true, width: 30)]
   public bool _applied = false;

   [VM_Label("🎲 Probability", tooltip: "critical hit chance")]
   [VM_Suffix("%")]
   [VM_RangeSlider(1, 100)]
   public int _probability = 50;

   [VM_Label("✖️ Damage Multiplier", tooltip: "damage multiplier for critical hit")]
   [VM_Suffix("coef", showOutside: true)]
   [VM_RangeSlider(1f, 10f)]
   public float _multiplier = 2.5f;
}

[VM_LabelWidth(140)]
[VM_Label("🎥 Main Camera", tooltip: "reference to the camera in the scene")]
[VM_Suffix("in scene")]
public Camera _camera;

[VM_LabelWidth(60)]
[VM_Label("🧙 Unit", tooltip: "prefab model for the unit")]
[VM_Suffix("prefab")]
public GameObject _unit;

[VM_LabelWidth(0.35f)]
[VM_Label("❤️ Life", tooltip: "current amount of Health Points")]
[VM_Suffix("HP")]
[VM_Min(0)]
public int _life = 1;

[VM_LabelWidth(0.2f)]
[VM_Label("🔮 Mana", tooltip: "current amount of Mana Points")]
[VM_Suffix("MP")]
[VM_Min(0)]
public int _mana = 0;

[VM_Label("👁️ Visibility", tooltip: "enemy visibility radius")]
[VM_Suffix("m")]
[VM_Min(1f)]
public float _visibility = 5f;

[VM_Label("⚔️ Melee Skill", tooltip: "сlose combat parameters")]
public MeleeSkill _meleeSkill;

[VM_HideLabel(useLabelWidth: true)]
public CriticalDamage _critical;

[VM_LabelWidth(0)]

[VM_Label("🏹 Ranged Skill", tooltip: "long-range attack parameters")]
public RangedSkill _rangedSkill;

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_LabelWidth(0.4f)]
[VM_ShowInInspector]
private string _privateString = "private field";

[VM_Label("Property (get/set)")]
[VM_LabelWidth(0.5f)]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "Property (get/set)";


[System.Serializable]
public class CriticalDamage
{
   [VM_LabelWidth(0.1f)]

   [VM_Label("🚩", tooltip: "critical hit applying flag")]
   [VM_Suffix("on|off", width: 30)]
   public bool _applied = false;

   [VM_Label("🎲", tooltip: "critical hit chance")]
   [VM_Suffix("%", width: 30)]
   [VM_RangeSlider(1, 100)]
   public int _probability = 50;

   [VM_Label("✖️", tooltip: "damage multiplier for critical hit")]
   [VM_RangeSlider(1f, 10f)]
   public float _multiplier = 2.5f;
}
[System.Serializable]
public class MeleeSkill
{
   [VM_LabelWidth(0.25f)]

   [VM_Label("💥 Damage", tooltip: "damage range")]
   [VM_Suffix("HP", width: 30)]
   public Vector2Int _damage = new(0, 10);

   [VM_NestedAsGroup("☠️ Critical Hit")]
   public CriticalDamage _critical;
}
[System.Serializable]
public class RangedSkill
{
   [VM_LabelWidth(0.4f)]

   [VM_Label("💥 Shot damage", tooltip: "damage range")]
   [VM_Suffix("HP", width: 30)]
   [VM_Min(1)]
   public int _damage = 1;

   [VM_NestedAsGroup("☠️ Critical Hit")]
   public CriticalDamage _critical;

   [VM_Label("📏 Shot Distance", tooltip: "maximum shooting range")]
   [VM_Suffix("m", width: 30)]
   [VM_Min(0f)]
   public float _rangeDistance = 40f;

   [VM_Label("🎯 Number of Arrows", tooltip: "number of available shots")]
   [VM_Suffix("pcs", width: 30)]
   [VM_Min(0)]
   public int _numArrows = 1;
}

[VM_Label("🧩 Prefab to Spawn")]
public GameObject _fieldPrefab0;
[VM_HideLabel(useLabelWidth: true)]
public GameObject _fieldPrefab1;

[VM_Title("🎲 Spawn Settings:", fontSize: 12)]
[VM_HideLabel]
public SpawnData _spawnData;

[System.Serializable]
public class SpawnData
{
   [VM_Label("✅ Enabled")]
   [VM_Toggles]
   public bool _enabled = false;

   [VM_Label("🎲 Probability")]
   [VM_Suffix("%")]
   [VM_Clamp(0, 100)]
   public int _probability = 50;
}

[VM_Title("🎥 Camera:", fontSize: 12)]
[VM_HideLabel]
public Camera _camera;

[VM_Title("NonSerialized Fields")]

[VM_HideLabel(useLabelWidth: true)]
[VM_ShowInInspector]
private string _privateString = "private field";

[VM_HideLabel]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "Property (get/set)";

[VM_Label("🔊 Sound Enabler")]
public bool _sound = true;

[VM_LabelWidth(50)]
[VM_EnableIf(nameof(_sound))]
[VM_HideLabel(useLabelWidth: true)]
[VM_Checkbox(desc: "Use background music?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Red600)]
public bool _music = true;

[VM_EnableIf(nameof(_sound))]
[VM_HideLabel(useLabelWidth: true)]
[VM_Checkbox(desc: "Use sound effects?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Emerald700)]
public bool _effects = true;

[VM_EnableIf(nameof(_sound))]
[VM_HideLabel(useLabelWidth: true)]
[VM_Checkbox(desc: "Use actor voices?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Blue600)]
public bool _voice = true;

[VM_LabelWidth(0)]
[VM_Label("🛡️ Defense")]
[VM_NestedInline]
public DefenseData _defense;

[VM_HideLabel]
[VM_Checkbox(desc: "It can be used as a left toggle !", tooltipDesc: "Hover here to see this tooltip")]
public bool _leftToggle = false;

[VM_List("🎯 Hit flags")]
[VM_Checkbox(desc: "Apply the skill damage ?", tooltipDesc: "Hover here to see this tooltip")]
public List<bool> _fieldList = new();

[VM_Dictionary("🎯 Hit flags")]
[VM_Checkbox(desc: "Apply the skill damage ?", tooltipDesc: "Hover here to see this tooltip")]
public SerializedDictionary<string, bool> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Checkbox(desc: "Toggle visibility ?", tooltipDesc: "Hover here to see this tooltip")]
[VM_ShowInInspector]
private bool _privateToggle = false;

[VM_Label("Property (get/set)")]
[VM_Checkbox(desc: "Toggle availability ?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Blue600)]
[VM_ShowInInspector]
public bool PropertyToggle { get; set; } = true;

[System.Serializable]
public class DefenseData
{
   [VM_Width(40, gap: 30)]
   [VM_HideLabel]
   [VM_Checkbox]
   public bool _enable = false;

   [VM_Label("Armor")]
   [VM_EnableIf(nameof(_enable))]
   public int _armor = 50;

   [VM_Label("Block")]
   [VM_Suffix("%")]
   [VM_EnableIf(nameof(_enable))]
   public float _blockChance = 10f;
}

[VM_Label("🔊 Sound Enabler")]
[VM_Toggle(width: 40)]
public bool _sound = true;

[VM_LabelWidth(20)]
[VM_EnableIf(nameof(_sound))]
[VM_HideLabel(useLabelWidth: true)]
[VM_Toggle(name: "Music", desc: "Use background music?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Red600, width: 90)]
public bool _music = true;

[VM_EnableIf(nameof(_sound))]
[VM_HideLabel(useLabelWidth: true)]
[VM_Toggle(name: "Effects", desc: "Use sound effects?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Emerald700, width: 90)]
public bool _effects = true;

[VM_EnableIf(nameof(_sound))]
[VM_HideLabel(useLabelWidth: true)]
[VM_Toggle(name: "Voice", desc: "Use actor voices?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Blue600, width: 90)]
public bool _voice = true;

[VM_LabelWidth(0)]
[VM_Label("⚡ Power")]
[VM_Toggle(name: "Enable")]
public bool _power = true;

[VM_Label("🛡️ Shield")]
[VM_Toggle(name: "Active", desc: "Absorbs incoming damage ?", tooltipDesc: "Hover here to see this tooltip")]
public bool _shield = true;

[VM_Label("🏃 Speed Boost")]
[VM_Toggle(name: "Enable", width: 70, desc: "Increases movement by 50% ?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Red600)]
public bool _speedBoost = true;

[VM_Label("🛡️ Defense")]
[VM_NestedInline]
public DefenseData _defense;

[VM_HideLabel]
[VM_Toggle(width: 40, desc: "It can be used as a left toggle", tooltipDesc: "Hover here to see this tooltip")]
public bool _leftToggle = false;

[VM_HideLabel]
[VM_Toggle(name: "🚩", width: 22, desc: "It can be used with emoji symbols", tooltipDesc: "Hover here to see this tooltip")]
public bool _leftToggleEmoji = false;

[VM_List("🎯 Hit flags")]
[VM_Toggle(name: "Hit", desc: "Apply the skill damage ?", tooltipDesc: "Hover here to see this tooltip")]
public List<bool> _fieldList = new();

[VM_Dictionary("🎯 Hit flags")]
[VM_Toggle(name: "Hit", desc: "Apply the skill damage ?", tooltipDesc: "Hover here to see this tooltip")]
public SerializedDictionary<string, bool> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Toggle(name: "Show", desc: "Toggle visibility ?", tooltipDesc: "Hover here to see this tooltip", width: 60)]
[VM_ShowInInspector]
private bool _privateToggle = false;

[VM_Label("Property (get/set)")]
[VM_Toggle(name: "Enable", desc: "Toggle availability ?", tooltipDesc: "Hover here to see this tooltip", hexColorDesc: HexColor.Blue600)]
[VM_ShowInInspector]
public bool PropertyToggle { get; set; } = true;

[System.Serializable]
public class DefenseData
{
   [VM_Width(40, gap: 30)]
   [VM_HideLabel]
   [VM_Toggle]
   public bool _enable = false;

   [VM_Label("Armor")]
   [VM_EnableIf(nameof(_enable))]
   public int _armor = 50;

   [VM_Label("Block")]
   [VM_Suffix("%")]
   [VM_EnableIf(nameof(_enable))]
   public float _blockChance = 10f;
}

[VM_Label("🛡️ Invincible")]
[VM_Toggles]
public bool _toggleDefault = false;

[VM_Label("🔊 Sound Effects")]
[VM_Toggles(nameTrue: "On", nameFalse: "Off", tooltipTrue: "Switch On", tooltipFalse: "Switch Off")]
public bool _toggleVariant1 = false;

[VM_HideLabel(useLabelWidth: true)]
[VM_Toggles(nameTrue: "Enable", nameFalse: "Disable")]
public bool _toggleVariant2 = false;

[VM_List("⚙️ Ability Toggles")]
[VM_Toggles]
public List<bool> _fieldListToggle = new();

[VM_Dictionary("⚙️ Ability Toggles")]
[VM_Toggles]
public SerializedDictionary<string, bool> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Toggles(nameTrue: "Visible", nameFalse: "Hidden", tooltipTrue: "Visible Option", tooltipFalse: "Hidden Option")]
[VM_ShowInInspector]
private bool _privateToggle = false;

[VM_Label("Property (get/set)")]
[VM_Toggles(nameTrue: "Available", nameFalse: "Unavailable", tooltipTrue: "Available Option", tooltipFalse: "Unavailable Option")]
[VM_ShowInInspector]
private bool PropertyToggle { get; set; } = false;

[VM_Label("🧭 Move Direction")]
[VM_Enum]
public eDirection _enumTogles;

[VM_Label("🎯 Attack Cross Direction")]
[VM_Enum(variants: new object[] { eDirection.Up, eDirection.Down, eDirection.Left, eDirection.Right })]
public eDirection _enumCrossTogles;

[VM_Label("🎯 Attack None Direction")]
[VM_Enum(limitPerLine: 4)]
public eDirection _enumToglesLimit;

[VM_Label("⚔️ Combat Style")]
[VM_Enum]
public CombatContext _enumToglesLabel;

[VM_List("📋 AI Patrol Directions")]
[VM_Enum]
public List<eDirection> _fieldListEnum = new();

[VM_List("📋 AI Patrol Directions (MultiLine)")]
[VM_Enum(limitPerLine: 3)]
public List<eDirection> _fieldListEnumMultiLine = new();

[VM_Dictionary("📋 AI Patrol Directions")]
[VM_Enum]
public SerializedDictionary<string, eDirection> _fieldDictEnum = new();

[VM_Dictionary("📋 AI Patrol Directions (MultiLine)")]
[VM_Enum(limitPerLine: 3)]
public SerializedDictionary<string, eDirection> _fieldDictEnumMultiLine = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Enum(showToggles: false)]
[VM_ShowInInspector]
private eDirection _privateEnum;

[VM_Label("Property (get/set)")]
[VM_Enum(showToggles: false, variants: new object[] { eDirection.Up, eDirection.Down, eDirection.Left, eDirection.Right })]
[VM_ShowInInspector]
public eDirection PropertyEnum { get; set; }

public enum eDirection
{
   Right, Left, Up, Down, UpLeft, UpRight, DownLeft, DownRight
}
public enum CombatContext
{
   [VM_Label("Close quarters", tooltip: "Close-quarters combat")] Melee,
   [VM_Label("Targeting shooting", tooltip: "Ranged attack on a target")] Shooting,
   [VM_Label("Fire exchange", tooltip: "Ranged exchange of fire")] Firefight,
}

[VM_Label("🧭 Allowed Directions")]
[VM_EnumBits]
public eDirectionBits _enumBits;

[VM_Label("🎯 Shooting Cross Direction")]
[VM_EnumBits(variants: new object[] { eDirectionBits.Up, eDirectionBits.Down, eDirectionBits.Left, eDirectionBits.Right })]
public eDirectionBits _shootingCrossEnumBits;

[VM_Label("🎯 Shooting None Directions")]
[VM_EnumBits(limitPerLine: 4)]
public eDirectionBits _shootingEnumBits;

[VM_List("🗺️ Patrol Directions")]
[VM_EnumBits]
public List<eDirectionBits> _fieldList = new();

[VM_List("🗺️ Patrol Directions (limit = 4)")]
[VM_EnumBits(limitPerLine: 4)]
public List<eDirectionBits> _fieldListLimit = new();

[VM_Dictionary("🗺️ Patrol Directions")]
[VM_EnumBits]
public SerializedDictionary<string, eDirectionBits> _fieldDict = new();

[VM_Dictionary("🗺️ Patrol Directions (limit = 4)")]
[VM_EnumBits(limitPerLine: 4)]
public SerializedDictionary<string, eDirectionBits> _fieldDictLimit = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_EnumBits(showToggles: false)]
[VM_ShowInInspector]
private eDirectionBits _privateEnumBits;

[VM_Label("Property (get/set)")]
[VM_EnumBits(showToggles: false, variants: new object[] { eDirectionBits.Up, eDirectionBits.Down, eDirectionBits.Left, eDirectionBits.Right })]
[VM_ShowInInspector]
public eDirectionBits PropertyEnumBits { get; set; }

public enum eDirectionBits
{
   Right = 1 << 0,
   Left = 1 << 1,
   Up = 1 << 2,
   Down = 1 << 3,
   UpLeft = 1 << 4,
   UpRight = 1 << 5,
   DownLeft = 1 << 6,
   DownRight = 1 << 7,
}

[VM_Label("⚔️ Damage")]
[VM_Range]
public Vector2Int _damage = new(10, 25);

[VM_Label("🌡️ Temperature")]
[VM_Range(separator: "~", suffix: "°C")]
[VM_Suffix("t")]
public Vector2 _temperature = new(-10f, 35f);

[VM_Label("📏 Distance")]
[VM_Range(separator: "..")]
[VM_Suffix("m")]
public Vector2 _distance = new(0f, 100f);

[VM_Label("⏱️ Duration")]
[VM_Range]
[VM_Suffix("sec")]
public Vector2 _duration = new(0.5f, 3.0f);

[VM_List("🎯 Ability Range")]
[VM_Range(separator: "...")]
[VM_Suffix("meter")]
public List<Vector2Int> _fieldList = new();

[VM_Dictionary("🎯 Ability Range")]
[VM_Range(separator: "...")]
[VM_Suffix("meter")]
public SerializedDictionary<string, Vector2Int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_ShowInInspector]
[VM_Label("Private")]
[VM_Range(suffix: "HP")]
private Vector2Int _privateRange = new(0, 100);

[VM_Label("Property (get/set)")]
[VM_Range(separator: "/")]
[VM_Suffix("mana")]
[VM_ShowInInspector]
public Vector2 PropertyRange { get; set; } = new(1f, 10f);

[VM_Label("⚔️ Damage Range")]
[VM_MinMaxSlider(0, 10)]
[VM_Suffix("m")]
public Vector2Int _fieldIntVector = Vector2Int.up * 5;

[VM_Label("🎲 Spawn Distance")]
[VM_MinMaxSlider(-1, 1, suffix: "m")]
public Vector2 _fieldVector = Vector2.up;

[VM_Label("❤️ Health Regen")]
[VM_Suffix("[0,10]", showOutside: true)]
[VM_MinMaxSlider(minValue: 0, maxValue: 10)]
public Vector2Int _fieldIntVectorSuffix = Vector2Int.up * 5;

[VM_List("📊 Loot Drop Ranges")]
[VM_MinMaxSlider(0, 100)]
[VM_Suffix("m")]
public List<Vector2Int> _fieldList = new();

[VM_Dictionary("📊 Loot Drop Ranges")]
[VM_MinMaxSlider(0, 100)]
[VM_Suffix("m")]
public SerializedDictionary<string, Vector2Int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("K")]
[VM_MinMaxSlider(-1, 1)]
[VM_ShowInInspector]
private Vector2 _privateMinMax = Vector2.up;

[VM_Label("Property (get/set)")]
[VM_Suffix("[-1,1]", showOutside: true)]
[VM_MinMaxSlider(-1, 1)]
[VM_ShowInInspector]
public Vector2 PropertyMinMax { get; set; } = Vector2.up;

[VM_Label("Max Power")]
[VM_Min(1)]
public int _maxPower = 3;

[VM_Label("⚔️ Attack Power")]
[VM_RangeSlider(0, nameof(_maxPower))]
public int _fieldInt = 2;

[VM_Label("🎯 Accuracy")]
[VM_RangeSlider(0, 100, toHexColor: HexColor.Red, suffix: "%")]
public int _fieldAccuracy = 75;

[VM_Label("💰 Price")]
[VM_RangeSlider(0, 1000, prefix: "$")]
public int _fieldPrice = 250;

[VM_Label("🛡️ Defense Rating")]
[VM_Suffix("%")]
[VM_RangeSlider(0, 10)]
public int _fieldIntSuffix = 2;

[VM_Label("🏃 Evasion Chance")]
[VM_Suffix("[1,-1]", showOutside: true, width: 30)]
[VM_RangeSlider(1, -1)]
public float _fieldFloatSuffix = 0.5f;

[VM_List("📊 Skill Levels")]
[VM_RangeSlider(0, 100, fromHexColor: HexColor.Red, toHexColor: HexColor.Green)]
[VM_Suffix("%")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Skill Levels")]
[VM_RangeSlider(0, 100, fromHexColor: HexColor.Red, toHexColor: HexColor.Green)]
[VM_Suffix("%")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("MP")]
[VM_RangeSlider(0, 10, fieldWidth: 95)]
[VM_ShowInInspector]
private float _privateRange = 0.5f;

[VM_Label("Property (get/set)")]
[VM_Suffix("[1,-1]", showOutside: true, width: 30)]
[VM_RangeSlider(1, -1)]
[VM_ShowInInspector]
public float PropertyRange { get; set; } = 0.5f;

[VM_Label("🔊 Volume")]
[VM_AnchoredSlider(0, 2, anchorValue: 1, fieldWidth: 80)]
public float _volume = 1f;

[VM_Label("⚖️ Weight Factor")]
[VM_AnchoredSlider(0, 10, anchorValue: 5)]
public int _weight = 5;

[VM_Label("🌡️ Temperature")]
[VM_AnchoredSlider(-20, 40, anchorValue: 20, flipColors: true)]
[VM_Suffix("°C")]
public int _temperature = 20;

[VM_Label("💵 Balance")]
[VM_AnchoredSlider(-1000, 1000, anchorValue: 0, prefix: "$")]
public int _balance = 100;

[VM_Label("⚠️ Hazard Level")]
[VM_AnchoredSlider(0, 100, anchorValue: 50, suffix: "%", flipColors: true)]
public int _hazard = 50;

[VM_List("📊 List of weights")]
[VM_AnchoredSlider(50, 150, anchorValue: 90, flipColors: true)]
[VM_Suffix("kg")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 List of weights")]
[VM_AnchoredSlider(50, 150, anchorValue: 90, flipColors: true)]
[VM_Suffix("kg")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_ShowInInspector]
[VM_Label("Private")]
[VM_AnchoredSlider(0, 100, anchorValue: 50)]
[VM_Suffix("%")]
private int _privateValue = 50;

[VM_ShowInInspector]
[VM_Label("Property (get/set)")]
[VM_AnchoredSlider(0, 1, anchorValue: 0.5f)]
public float PropertyValue { get; set; } = 0.5f;

[VM_Label("🍀 Luck Modifier")]
[VM_BonusSlider(0, 1)]
[VM_Suffix("[0..1]", showOutside: true, width: 30)]
public float _fieldFloat = 0;

[VM_Label("🧊 Frost Resistance")]
[VM_Suffix("[0..-1]", showOutside: true, width: 30)]
[VM_BonusSlider(0, -1)]
public float _fieldFloatInvert = 0.0f;

[VM_Label("💀 Damage Taken")]
[VM_BonusSlider(-10, 10, flipColors: true)]
[VM_Suffix("HP")]
public int _damageTaken = 0;

[VM_Label("⚔️ Strength Buff")]
[VM_BonusSlider(-10, 10)]
[VM_Suffix("AP")]
public int _fieldInt = 0;

[VM_HideLabel(useLabelWidth: true)]
[VM_Suffix("[10..-10]", showOutside: true)]
[VM_BonusSlider(10, -10)]
public int _fieldIntInvert = 0;

[VM_List("📊 Stat Modifiers")]
[VM_BonusSlider(-10, 10, fieldWidth: 80)]
[VM_Suffix("AP")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Stat Modifiers")]
[VM_BonusSlider(-10, 10, fieldWidth: 80)]
[VM_Suffix("AP")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_BonusSlider(-1, 1, fieldWidth: 95)]
[VM_Suffix("K")]
[VM_ShowInInspector]
private float _privateBonus = 0f;

[VM_Label("Property (get/set)")]
[VM_Suffix("[0..10]", showOutside: true, width: 30)]
[VM_BonusSlider(0, 10)]
[VM_ShowInInspector]
public float PropertyBonus { get; set; } = 0f;

[VM_Label("Max Life")]
[VM_Suffix("HP")]
[VM_Min(1)]
public int _maxLife = 100;

[VM_Label("Health")]
[VM_ProgressBar(0, nameof(_maxLife), hexColorBar: HexColor.Orange500)]
[VM_Suffix("HP")]
public int _health = 50;

[VM_Label("Mana")]
[VM_ProgressBar(0, 100, suffix: " MP")]
public int _mana = 80;

[VM_Label("Stamina")]
[VM_ProgressBar(0, 1, hexColorBar: HexColor.Green400, suffix: " SP", showFromValue: false)]
public float _stamina = 0.25f;

[VM_ProgressBar(0, 100, suffix: " %", hexColorBar: HexColor.Green, showFromValue: false, showToValue: false)]
public int _attack = 50;

[VM_List("📊 Skill Damage")]
[VM_ProgressBar(0, 100)]
[VM_Suffix("HP")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Skill Damage")]
[VM_ProgressBar(0, 100)]
[VM_Suffix("HP")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_ProgressBar(0, 1)]
[VM_ShowInInspector]
private float _privateBar = 0.15f;

[VM_Label("Property (get/set)")]
[VM_ProgressBar(0, 100, hexColorBar: HexColor.Red)]
[VM_ShowInInspector]
public int PropertyBar { get; set; } = 35;

[VM_Label("Stat cap")]
[VM_Suffix("lvl")]
[VM_RangeSlider(2, 12)]
public int _maxParam = 6;

[VM_Label("Attack")]
[VM_SegmentedBar(nameof(_maxParam), hexColorBar: HexColor.Lime200, showField: false)]
[VM_Suffix("HP", showOutside: true)]
public int _attack = 3;

[VM_Label("Defense")]
[VM_Suffix("%")]
[VM_SegmentedBar(nameof(_maxParam), hexColorBar: HexColor.Green600)]
public int _defense = 2;

[VM_Label("Armor")]
[VM_SegmentedBar(nameof(_maxParam), hexColorBar: HexColor.Yellow600, showValueInSegment: false)]
public int _armour = 4;

[VM_Label("Damage")]
[VM_SegmentedBar(4, stepSize: 25, hexColorBar: HexColor.Fuchsia600, suffix: " HP")]
public int _damage = 50;

[VM_Label("Speed")]
[VM_SegmentedBar(4, hexColorBar: HexColor.Yellow100, fieldWidth: 120, fieldListCallback: nameof(SpeedNameList))]
public int _speed = 2;
DropdownItems<int> SpeedNameList => new()
{
   { "Very Slow", 0 },
   { "Slow"     , 1 },
   { "Normal"   , 2 },
   { "Fast"     , 3 },
   { "Very Fast", 4 },
};

[VM_List("📊 Skill Levels")]
[VM_SegmentedBar(10, fieldWidth: 70)]
[VM_Suffix("Lvl")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Skill Levels")]
[VM_SegmentedBar(10, fieldWidth: 70)]
[VM_Suffix("Lvl")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_SegmentedBar(5, prefix: "x ")]
[VM_ShowInInspector]
private int _privateBar = 4;

[VM_Label("Property (get/set)")]
[VM_SegmentedBar(10, hexColorBar: HexColor.Red)]
[VM_ShowInInspector]
public int PropertyBar { get; set; } = 3;

[VM_Label("Unity string")]
public string _unityDefault = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.";

[VM_Label("📜 Multiline-string")]
[VM_Multiline]
public string _fieldString = string.Empty;

[VM_HideLabel]
[VM_Multiline]
public string _fieldStringHide = string.Empty;

[VM_List("📋 Multiline-string List")]
[VM_Multiline]
public List<string> _fieldList = new();

[VM_Dictionary("📋 Multiline-string Dictionary")]
[VM_Multiline]
public SerializedDictionary<string, string> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Multiline]
[VM_ShowInInspector]
private string _privateMultiLine = string.Empty;

[VM_Label("Property (get/set)")]
[VM_Multiline]
[VM_ShowInInspector]
public string PropertyMultiLine { get; set; } = string.Empty;

[VM_Label("🏷️ Enemy Tag")]
[VM_Tag]
public string _tagName;

[VM_List("📋 Targetable Tags")]
[VM_Tag]
public List<string> _fieldList = new();

[VM_Dictionary("📋 Targetable Tags")]
[VM_Tag]
public SerializedDictionary<string, string> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Tag]
[VM_ShowInInspector]
private string _privateTag = "";

[VM_Label("Property (get/set)")]
[VM_Tag]
[VM_ShowInInspector]
public string PropertyTag { get; set; } = "";

[VM_Label("🎯 Raycast Layer")]
[VM_Layer]
public string _layerName;

[VM_Label("🛡️ Collision Layer")]
[VM_Layer]
public int _layerIndex = -1;

[VM_List("📋 Interaction Layers")]
[VM_Layer]
public List<int> _fieldList = new();

[VM_Dictionary("📋 Interaction Layers")]
[VM_Layer]
public SerializedDictionary<string, string> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Layer]
[VM_ShowInInspector]
private string _privateLayer = "";

[VM_Label("Property (get/set)")]
[VM_Layer]
[VM_ShowInInspector]
public string PropertyLayer { get; set; } = "";

[VM_Label("🎨 Sprite Layer")]
[VM_SortingLayer]
public string _layerName;

[VM_Label("🖼️ UI Layer")]
[VM_SortingLayer]
public int _layerIndex = -1;

[VM_List("📋 VFX Layers")]
[VM_SortingLayer]
public List<int> _fieldList = new();

[VM_Dictionary("📋 VFX Layers")]
[VM_SortingLayer]
public SerializedDictionary<string, string> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_SortingLayer]
[VM_ShowInInspector]
private string _privateLayer = "";

[VM_Label("Property (get/set)")]
[VM_SortingLayer]
[VM_ShowInInspector]
public string PropertyLayer { get; set; } = "";

[VM_Label("🚶 Squad Agent")]
[VM_NavMeshAgent]
public int _squadNavAgent = 0;

[VM_List("📋 Patrol Agents")]
[VM_NavMeshAgent]
public List<int> _fieldList = new();

[VM_Dictionary("📋 Patrol Agents")]
[VM_NavMeshAgent]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_NavMeshAgent]
[VM_ShowInInspector]
private int _privateAgent = 0;

[VM_Label("Property (get/set)")]
[VM_NavMeshAgent]
[VM_ShowInInspector]
public int PropertyAgent { get; set; } = 0;

[VM_Label("📈 Damage Falloff")]
[VM_AnimationCurve(width: 0.6f, maxX: 10, maxY: 10)]
public AnimationCurve curve = AnimationCurve.EaseInOut(0, 0, 10, 10);

[VM_List("🎯 Ability Scaling Curves", onAddMethod: nameof(OnListAddMethod))]
[VM_AnimationCurve(hexColor: HexColor.Red)]
public List<AnimationCurve> _fieldList = new();
void OnListAddMethod(int index)
{
   _fieldList[index] = AnimationCurve.Linear(0, 0, 1, 1);
}

[VM_Dictionary("📋 Patrol Agents", onAddMethod: nameof(OnDictAddMethod))]
[VM_AnimationCurve(hexColor: HexColor.Red)]
public SerializedDictionary<string, AnimationCurve> _fieldDict = new();
void OnDictAddMethod(string key)
{
   _fieldDict[key] = AnimationCurve.Linear(0, 0, 1, 1);
}

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_AnimationCurve(hexColor: HexColor.Magenta, width: 120)]
[VM_ShowInInspector]
private AnimationCurve _privateCurve = AnimationCurve.Linear(0, 0, 1, 1);

[VM_Label("Property (get/set)")]
[VM_AnimationCurve(hexColor: HexColor.Blue600)]
[VM_ShowInInspector]
public AnimationCurve PropertyTag { get; set; } = AnimationCurve.Constant(0, 1, 0.5f);

[VM_Required]
[VM_Label("🎬 Character Animator")]
[VM_AssetObjectsOnly]
public RuntimeAnimatorController _animatorController;

[VM_Label("All Parameters")]
[VM_AnimatorParameter(nameof(_animatorController))]
public string _allParamName;

[VM_Label("Boolean Only")]
[VM_AnimatorParameter(nameof(_animatorController), AnimatorControllerParameterType.Bool)]
public int _paramHashBool;

[VM_Label("Integer Only")]
[VM_AnimatorParameter(nameof(_animatorController), AnimatorControllerParameterType.Int)]
public int _paramHashInt;

[VM_Label("Float Only")]
[VM_AnimatorParameter(nameof(_animatorController), AnimatorControllerParameterType.Float)]
public int _paramHashFloat;

[VM_Label("Trigger Only")]
[VM_AnimatorParameter(nameof(_animatorController), AnimatorControllerParameterType.Trigger)]
public int _paramHashTrigger;

[VM_List("📋 List of Parameters")]
[VM_AnimatorParameter(nameof(_animatorController))]
public List<string> _fieldList = new();

[VM_Dictionary("📋 Dictionary of Parameters")]
[VM_AnimatorParameter(nameof(_animatorController))]
public SerializedDictionary<string, string> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_AnimatorParameter(nameof(_animatorController), AnimatorControllerParameterType.Trigger)]
[VM_ShowInInspector]
private int _privateParameterTrigger;

[VM_Label("Property (get/set)")]
[VM_AnimatorParameter(nameof(_animatorController), AnimatorControllerParameterType.Trigger)]
[VM_ShowInInspector]
public int PropertyParameter { get; set; }

[VM_Title("Unity Scene", fontSize: 16, thicknessLine: 0, align: eAlign.Center)]

[VM_Label("🏰 Dungeon Scene")]
[VM_Scene]
public string sceneName;

[VM_Label("🌍 World Scene Index")]
[VM_Scene]
public int sceneIndex = -1;

[VM_List("📜 Quest Scenes")]
[VM_Scene]
public List<int> _fieldList = new();

[VM_Dictionary("📜 Quest Scenes")]
[VM_Scene]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Scene]
[VM_ShowInInspector]
private int _privateScene = -1;

[VM_Label("Property (get/set)")]
[VM_Space(0, after: 10)]
[VM_Scene]
[VM_ShowInInspector]
public int PropertyScene { get; set; } = -1;

[VM_Title("Addressable Scene", fontSize: 16, thicknessLine: 0, align: eAlign.Center)]

[VM_Label("🗺️ Arena Scene")]
[VM_Scene]
public AssetReferenceScene _addressableScene;

[VM_List("⚔️ Battle Scenes")]
[VM_Scene]
public List<AssetReferenceScene> _fieldListAddressableScenes = new();

[VM_Dictionary("⚔️ Battle Scenes")]
[VM_Scene]
public SerializedDictionary<string, AssetReferenceScene> _fieldDictAddressableScenes = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Scene]
[VM_ShowInInspector]
private AssetReferenceScene _privateAddressableScene;

[VM_Label("Property (get/set)")]
[VM_Scene]
[VM_ShowInInspector]
public AssetReferenceScene PropertyAddressableScene { get; set; } = null;

[VM_TabGroup("AnimationTab", "Usage Prefab")]
[VM_HideLabel]
[VM_Prefab(onInit: nameof(OnInit), onChangedVisibleMeshes: nameof(OnChangedVisibleMeshes),
           onSetTrigger: nameof(OnSetTrigger), onAnimationEvent: nameof(OnAnimEvent))]
public GameObject _assetPrefab;
private List<string> OnInit(List<string> boneNames)
{
   print("OnInit: " + string.Join(", ", boneNames));
   BoneNames = boneNames;
   return _visibleMeshNames;
}
private void OnChangedVisibleMeshes()
{
   print("OnChangedVisibleMeshes: " + string.Join(", ", _visibleMeshNames));
}
private void OnSetTrigger(string triggerName, IPlayerFX player)
{
   Debug.Log($"Trigger called: {triggerName}");
}
void OnAnimEvent(string eventName, IPlayerFX player)
{
   Debug.Log($"Animation event: {eventName}");

   foreach (var data in _listEvents)
   {
      if (eventName == data._eventName)
         player.Add(data._scriptableFX, data._boneName, data._bindToBone);
   }
}
[VM_HideInInspector]
public List<string> _visibleMeshNames = new();

static List<string> BoneNames = new();
[RuntimeInitializeOnLoadMethod]
static void ResetStatics()
{
   BoneNames ??= new();
}

[System.Serializable]
public class EventData
{
   [VM_Label("🎬 Event Name")]
   public string _eventName;

   [VM_Label("🦴 Bone Attachment")]
   [VM_Dropdown(nameof(BoneNames), null)]
   public string _boneName;

   [VM_Label("📌 Binding Type")]
   [VM_Toggles(nameTrue: "To bone", nameFalse: "World")]
   public bool _bindToBone = false;

   [VM_Label("✨ Particle Effect")]
   [VM_Scriptable(assetsPathToCreate: "ScriptableObjects/FX/")]
   public VM_SimpleFX _scriptableFX;
}
[VM_TabGroup("AnimationTab")]
[VM_List("⚡ Animation Events", nameRefHeaderNested: nameof(EventData._eventName))]
public List<EventData> _listEvents = new();

[VM_TabGroup("RestrictedTab", "Prefab variants")]
[VM_Label("🏗️ Without Animation")]
[VM_Prefab(hideAnimatorGUI: true)]
public GameObject _assetPrefabWithoutAnimation0;

[VM_TabGroup("RestrictedTab")]
[VM_Label("📦 Without Controls")]
[VM_Prefab(hideMeshesGUI: true, hideAnimatorGUI: true, stretchWidth: false)]
public GameObject _assetPrefabWithoutAnimation1;

[VM_TabGroup("RestrictedTab")]
[VM_Label("🌐 Addressable")]
[VM_Prefab]
public AssetReferencePrefab _assetAddressablePrefab;

[VM_TabGroup("ArrayTab", "Prefab Into Array")]
[VM_List("🗡️ Prefabs")]
[VM_Prefab(size: 128)]
public List<GameObject> _fielsList = new();

[VM_TabGroup("ArrayTab")]
[VM_List("🛡️ Addressable Prefab")]
[VM_Prefab(size: 128)]
public List<AssetReferencePrefab> _fieldListAddressable = new();

[VM_TabGroup("ArrayTab")]
[VM_Dictionary("🗡️ Prefabs")]
[VM_Prefab(size: 128)]
public SerializedDictionary<string, GameObject> _fieldDict = new();

[VM_TabGroup("ArrayTab")]
[VM_Dictionary("🛡️ Addressable Prefab")]
[VM_Prefab(size: 128)]
public SerializedDictionary<string, AssetReferencePrefab> _fieldDictAddressable = new();

[VM_TabGroup("NonSerialized", "NonSerialized")]
[VM_Label("Private")]
[VM_Prefab]
[VM_ShowInInspector]
private GameObject _privatePrefab;

[VM_TabGroup("NonSerialized")]
[VM_Label("Property (get/set)")]
[VM_Prefab(stretchWidth: false)]
[VM_ShowInInspector]
public GameObject PropertyPrefab { get; set; } = null;

[VM_Label("🗡️ Weapon Model")]
[VM_SimplePrefab]
public GameObject _assetPrefabSimple;

[VM_List("📋 Prop Models")]
[VM_SimplePrefab(showGrid: false, showAxes: false, stretchWidth: true)]
public List<GameObject> _fieldList;

[VM_List("📋 Prop Models (Addressable)")]
[VM_SimplePrefab(showGrid: false, showAxes: false, stretchWidth: true)]
public List<AssetReferencePrefab> _fieldListAddressable;

[VM_Dictionary("📋 Prop Models")]
[VM_SimplePrefab(showGrid: false, showAxes: false, stretchWidth: true)]
public SerializedDictionary<string, GameObject> _fieldDict = new();

[VM_Dictionary("📋 Prop Models (Addressable)")]
[VM_SimplePrefab(showGrid: false, showAxes: false, stretchWidth: true)]
public SerializedDictionary<string, AssetReferencePrefab> _fieldDictAddressable = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_SimplePrefab(size: 96, showGrid: false)]
[VM_ShowInInspector]
private GameObject _privatePrefab;

[VM_Label("Property (get/set)")]
[VM_SimplePrefab(stretchWidth: true)]
[VM_ShowInInspector]
public GameObject PropertyPrefab { get; set; } = null;

[VM_Label("🧱 Armor Material")]
[VM_Material]
public Material _assetMaterial;

[VM_List("📋 Terrain Materials")]
[VM_Material(size: 64, stretchWidth: true)]
public List<Material> _fieldListMaterial = new();

[VM_Dictionary("📋 Terrain Materials")]
[VM_Material(size: 64, stretchWidth: true)]
public SerializedDictionary<string, Material> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Material(size: 32)]
[VM_ShowInInspector]
private Material _privateMaterial;

[VM_Label("Property (get/set)")]
[VM_Material(size: 96, stretchWidth: true)]
[VM_ShowInInspector]
public Material PropertyMaterial { get; set; } = null;

[VM_Label("🎨 Character Sprite")]
[VM_Image]
public Sprite _assetSprite;

[VM_Label("🗺️ WorldMap Texture")]
[VM_Image(size: 256, stretchWidth: true)]
public Texture _assetTexture;

[VM_List("🎒 Inventory Sprites")]
[VM_Image(size: 48, stretchWidth: true, showSizeImage: false)]
public List<Sprite> _fieldList = new();

[VM_Dictionary("🖼️ Loading Screen Textures")]
[VM_Image(size: 64, align: eAlign.Center)]
public SerializedDictionary<string, Texture> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Image(size: 64, fitSmallImage: true, showOnChecker: false, align: eAlign.Right)]
[VM_ShowInInspector]
private Texture _privateTexture;

[VM_Label("Property (get/set)")]
[VM_Image(size: 64, stretchWidth: true)]
[VM_ShowInInspector]
public Texture PropertyTexture { get; set; } = null;

[VM_Label("🔊 Sword Swing SFX")]
[VM_Audio]
public AudioClip _fieldClip;

[VM_List("📋 Footstep Sounds")]
[VM_Audio]
public List<AudioClip> _fieldList = new();

[VM_Dictionary("📋 Footstep Sounds")]
[VM_Audio]
public SerializedDictionary<string, AudioClip> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Audio]
[VM_ShowInInspector]
private AudioClip _privateAudioClip;

[VM_Label("Property (get/set)")]
[VM_Audio]
[VM_ShowInInspector]
public AudioClip PropertyAudioClip { get; set; } = null;

[VM_Label("📦 Game Config")]
[VM_Scriptable]
public ScriptableObject _fieldSO;

[VM_Label("🧪 Potion Recipe")]
[VM_Scriptable(assetsPathToCreate: "ScriptableObjects/", showCreate: true)]
public SimpleSO _fieldSimpleSO;

[VM_Label("⚔️ Weapon Stats")]
[VM_Scriptable(assetsPathToCreate: "ScriptableObjects/", showCreate: true)]
public ComplexSO _fieldComplexSO;

[VM_List("📋 Loot Table Entries")]
[VM_Scriptable]
public List<ComplexSO> _fieldList = new();

[VM_Dictionary("📋 Loot Table Entries")]
[VM_Scriptable]
public SerializedDictionary<string, ComplexSO> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Scriptable]
[VM_ShowInInspector]
private SimpleSO _privateAddressableScene;

[VM_Label("Property (get/set)")]
[VM_Scriptable]
[VM_ShowInInspector]
public ComplexSO PropertyAddressableScene { get; set; } = null;

[VM_Label("Dialogue")]
[VM_LocalizedString]
public LocalizedString _dialogue;

[VM_Label("Item Name")]
[VM_LocalizedString]
public LocalizedString _itemName;

[VM_List("Array of Description")]
[VM_LocalizedString]
public List<LocalizedString> _fieldList = new();

[VM_Dictionary("Dictionary of Description")]
[VM_LocalizedString]
public SerializedDictionary<string, LocalizedString> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_LocalizedString]
[VM_ShowInInspector]
private LocalizedString _privateLS;

[VM_Label("Property (get/set)")]
[VM_LocalizedString]
[VM_ShowInInspector]
public LocalizedString PropertyLS { get; set; }

[VM_Label("🔊 Voice Line")]
[VM_LocalizedAudio]
public LocalizedAudioClip _voiceLine;

[VM_Label("🎵 Ambient Sound")]
[VM_LocalizedAudio]
public LocalizedAudioClip _ambientSound;

[VM_List("📋 Sound Effects")]
[VM_LocalizedAudio]
public List<LocalizedAudioClip> _fieldList = new();

[VM_Dictionary("📋 Sound Effects")]
[VM_LocalizedAudio]
public SerializedDictionary<string, LocalizedAudioClip> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_LocalizedAudio]
[VM_ShowInInspector]
private LocalizedAudioClip _privateAudio;

[VM_Label("Property (get/set)")]
[VM_LocalizedAudio]
[VM_ShowInInspector]
public LocalizedAudioClip PropertyAudio { get; set; }

[VM_Label("🏳️ Localized sprite")]
[VM_LocalizedImage(size: 64)]
public LocalizedSprite _flag;

[VM_Label("🗺️ Localized texture")]
[VM_LocalizedImage(size: 96, stretchWidth: true)]
public LocalizedTexture _mapTexture;

[VM_List("🎨 Localized sprites")]
[VM_LocalizedImage(size: 48, showSizeImage: false, stretchWidth: true)]
public List<LocalizedSprite> _fieldList = new();

[VM_Dictionary("🎨 Localized sprites")]
[VM_LocalizedImage(size: 48, showSizeImage: false, stretchWidth: true)]
public SerializedDictionary<string, LocalizedSprite> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private sprite")]
[VM_LocalizedImage(size: 32)]
[VM_ShowInInspector]
private LocalizedSprite _privateSprite;

[VM_Label("Property texture (get/set)")]
[VM_LocalizedImage(size: 64, stretchWidth: true)]
[VM_ShowInInspector]
public LocalizedTexture PropertyTexture { get; set; }

[VM_Label("📊 Stats")]
public StatsData _stats;

[VM_Label("⚔️ Attack")]
[VM_NestedColor(hexColor: HexColor.Red400)]
public AttackData _attack;

[VM_Label("🛡️ Defense")]
[VM_NestedColor(hexColor: HexColor.Sky400)]
public DefenseData _defense;

[VM_List("📋 List of Parameters", showHeaderNested: false)]
public List<AllStatsData> _fieldList = new();

[VM_Dictionary("📋 Dictionary of Parameters")]
public SerializedDictionary<string, AllStatsData> _fieldDict = new();

[System.Serializable]
public class AttackData
{
   [VM_Label("🗡️ Damage")]
   public int _damage = 25;

   [VM_Label("⚡ Speed")]
   [VM_Suffix("atk/s")]
   public float _speed = 1.5f;
}

[System.Serializable]
public class DefenseData
{
   [VM_Label("🛡️ Armor")]
   public int _armor = 50;

   [VM_Label("❤️ Health")]
   [VM_Suffix("HP")]
   public int _health = 100;
}

[System.Serializable]
public class StatsData
{
   [VM_Label("⭐ Level")]
   public int _level = 10;

   [VM_Label("🎯 Experience")]
   [VM_Suffix("XP")]
   public int _xp = 500;
}

[System.Serializable]
public class AllStatsData
{
   [VM_Label("⚔️ Attack")]
   [VM_NestedColor(hexColor: HexColor.Red400)]
   public AttackData _attack;

   [VM_Label("🛡️ Defense")]
   [VM_NestedColor(hexColor: HexColor.Sky400)]
   public DefenseData _defense;
}

[VM_Label("Nested as Field")]
public CombatData _combatDefault;

[VM_NestedAsGroup(null, hexColor: HexColor.Sky400)]
public CombatData _combatStats;

[VM_Separator]
[VM_NestedAsGroup("🏃 Movement Stats", drawer: eDrawer.Foldout)]
public MovementData _movementStats;

[VM_Separator]
[VM_NestedAsGroup(null)]
public AudioData _audioSettings;

[System.Serializable]
public class CombatData
{
   [VM_LabelWidth(0.2f)]

   [VM_Label("💥 Damage")]
   [VM_RangeSlider(0, 100)]
   public int _damage = 50;

   [VM_Label("⏱️ Attack Rate")]
   [VM_Suffix("sec")]
   [VM_Min(0.1f)]
   public float _attackRate = 1.5f;

   [VM_NestedAsGroup("🛡️ Defense", drawer: eDrawer.Foldout)]
   public DefenseData _defense;

   public override string ToString() => "⚔️ Combat Stats";
}

[System.Serializable]
public class MovementData
{
   [VM_Label("🏃 Speed")]
   [VM_RangeSlider(0, 100, fieldWidth: 80)]
   [VM_Suffix("m/s")]
   public int _speed = 50;

   [VM_Label("🦘 Jump Height")]
   [VM_Suffix("m")]
   [VM_Min(1f)]
   public float _jumpHeight = 2.5f;

   [VM_HideLabel]
   public DefenseData _defense;
}

[System.Serializable]
public class AudioData
{
   [VM_LabelWidth(0.15f)]

   [VM_Label("🔊 Volume")]
   [VM_RangeSlider(0, 100)]
   [VM_Suffix("%")]
   public int _volume = 80;

   [VM_Label("🎵 Pitch")]
   [VM_Min(0.1f)]
   public float _pitch = 1.0f;

   [VM_NestedAsGroup(null, drawer: eDrawer.None)]
   public DefenseData _defense;
}

[System.Serializable]
public class DefenseData
{
   [VM_Label("🛡️ Armor")]
   [VM_Suffix("%")]
   public int _armorType = 12;

   [VM_Label("🚫 Block")]
   [VM_Toggles]
   public bool _canBlock = true;

   public override string ToString() => "⚔️ Defense Stats";
}

[VM_Label("Damage")]
[VM_NestedInline(hexColor: HexColor.Sky400)]
public DamageRange _damage;

[VM_HideLabel(useLabelWidth: true)]
[VM_NestedInline(showBorder: false)]
public DamageRange _damageNoBorder;

[VM_Label("Defense")]
[VM_NestedInline]
public DefenseData _defense;

[VM_HideLabel(useLabelWidth: true)]
[VM_NestedInline]
public DefenseData _defenseNoLabel;

[VM_Label("Position")]
[VM_NestedInline(showBorder: false)]
public PositionData _position;

[VM_HideLabel]
[VM_NestedInline(showBorder: false)]
public PositionData _positionNoLabel;

[System.Serializable]
public class DamageRange
{
   [VM_Label("Min")]
   [VM_Suffix("HP")]
   public int _min = 5;

   [VM_Label("Max")]
   [VM_Suffix("HP")]
   public int _max = 25;

   [VM_Label("Crit")]
   [VM_Suffix("%")]
   public float _critChance = 15f;
}

[System.Serializable]
public class DefenseData
{
   [VM_Width(40, gap: 30)]
   [VM_HideLabel]
   [VM_Toggle]
   public bool _enable = false;

   [VM_Label("Armor")]
   [VM_EnableIf(nameof(_enable))]
   public int _armor = 50;

   [VM_Label("Block")]
   [VM_Suffix("%")]
   [VM_EnableIf(nameof(_enable))]
   public float _blockChance = 10f;
}

[System.Serializable]
public class PositionData
{
   [VM_Width(0.2f)]
   [VM_HideLabel]
   [VM_Suffix("X")]
   public float _x = 0f;

   [VM_Width(0.2f)]
   [VM_HideLabel]
   [VM_Suffix("Y")]
   public float _y = 0f;

   [VM_Width(0.3f)]
   [VM_HideLabel]
   [VM_Suffix("Z")]
   public float _z = 0f;

   [VM_Width(0.3f)]
   [VM_HideLabel]
   [VM_Suffix("W")]
   public float _w = 0f;
}

[VM_Label("🎭 Character Model")]
[VM_AssetObjectsOnly]
public GameObject _assetPrefab;
private bool IsPrefabValid => _assetPrefab != null;

[VM_EnableIf(nameof(IsPrefabValid))]
[VM_Label("👁️ Visible Meshes")]
[VM_DropdownList(nameof(OnListInit), nameof(OnSelectChanged))]
public List<Transform> _visibleMeshes = new();
private DropdownItems<Transform> OnListInit()
{
   if (_assetPrefab == null)
      return new();

   var result = new DropdownItems<Transform>();
   var renderers = _assetPrefab.GetComponentsInChildren<Renderer>(true);

   foreach (var renderer in renderers)
      result.Add(renderer.gameObject.name, renderer.transform);

   return result;
}
private void OnSelectChanged()
{
   Debug.Log($"Selection changed! Now {_visibleMeshes.Count} meshes selected.");
}

[VM_Label("🎯 All Types")]
[VM_DropdownList(nameof(GetAvailableTypes))]
public List<int> _selectedTypes = new();
private DropdownItems<int> GetAvailableTypes()
{
   return new DropdownItems<int>
   {
      { "Obstacle", 0 },
      { "Enemy on the ground", 1 },
      { "Enemy in the air", 2 },
      { "Neutral NPC", 3 },
      { "Bonus for the player", 4 },
      { "Trigger of the quest", 5 },
   };
}

[VM_Label("🎯 Target Types")]
[VM_DropdownList(nameof(GetUnitTypes))]
public List<int> _selectedTargets = new();
private DropdownItems<int> GetUnitTypes()
{
   return new DropdownItems<int>
   {
      { "Enemy on the ground", 1 },
      { "Enemy in the air", 2 },
      { "Neutral NPC", 3 },
   };
}

[VM_Dictionary("📋 Dictionary of Types")]
[VM_DropdownList(nameof(GetAvailableTypes))]
public SerializedDictionary<string, List<int>> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_DropdownList(nameof(GetAvailableTypes))]
[VM_ShowInInspector]
private List<int> _privateTypes = new();

[VM_Label("Property (get/set)")]
[VM_DropdownList(nameof(GetUnitTypes))]
[VM_ShowInInspector]
public List<int> PropertyTypes { get; set; } = new();

[VM_Label("🧭 Patrol Route")]
[VM_EnumList]
public List<eDirection> _enumTogles = new();

[VM_Label("🎯 Attack Cross Direction")]
[VM_EnumList(variants: new object[] { eDirection.Up, eDirection.Down, eDirection.Left, eDirection.Right })]
public List<eDirection> _enumCrossTogles = new();

[VM_Label("🎯 Attack None Directions")]
[VM_EnumList(limitPerLine: 4)]
public List<eDirection> _enumToglesLimit = new();

[VM_HideLabel]
[VM_EnumList]
public List<eDirection> _enumToglesHide = new();

[VM_HideLabel]
[VM_EnumList(limitPerLine: 4)]
public List<eDirection> _enumToglesHideLimit = new();

[VM_Label("⚔️ Combat Styles")]
[VM_EnumList]
public List<CombatContext> _enumToglesLabel = new();

[VM_Dictionary("📋 Dictionary of Direction List")]
[VM_EnumList(limitPerLine: 4)]
public SerializedDictionary<string, List<eDirection>> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_EnumList(toggles: false)]
[VM_ShowInInspector]
private List<eDirection> _privateEnums = new();

[VM_Label("Property (get/set)")]
[VM_EnumList(toggles: false, variants: new object[] { eDirection.Up, eDirection.Down, eDirection.Left, eDirection.Right })]
[VM_ShowInInspector]
public List<eDirection> PropertyEnums { get; set; } = new();

public enum eDirection
{
   Right, Left, Up, Down, UpLeft, UpRight, DownLeft, DownRight
}
public enum CombatContext
{
   [VM_Label("Close quarters", tooltip: "Close-quarters combat")] Melee,
   [VM_Label("Targeting shooting", tooltip: "Ranged attack on a target")] Shooting,
   [VM_Label("Fire exchange", tooltip: "Ranged exchange of fire")] Firefight,
}

[VM_Title("Simple data", thicknessLine: 2)]

[VM_List("📋 Waypoints")]
public List<float> _waypoints = new();

[VM_List("Quest Logs (Add: disabled)", hideAdd: true)]
[VM_Multiline]
public List<string> _fieldListString = new();
[VM_Button("Add a multiline string", hexColor: HexColor.Lime400)]
void AddString() => _fieldListString.Add(string.Empty);

[VM_List("Skill Levels (Del: disabled, Draggable: disabled)", hideDel: true, isDraggable: false)]
[VM_RangeSlider(0, 100)]
public List<float> _fieldListRange = new();
bool IsValidListRange => _fieldListRange.Count > 0;
[VM_EnableIf(nameof(IsValidListRange))]
[VM_Button("Delete last element", hexColor: HexColor.Amber500)]
void DelLastElement() => _fieldListRange.RemoveAt(_fieldListRange.Count - 1);

[VM_List("Target Priority (ContextMenu: disabled)", isContextMenu: false)]
[VM_Dropdown(nameof(DropdownValues), -1)]
public List<int> _fieldListDropdown = new();
static DropdownItems<int> DropdownValues => new()
{
   { "Zero", 0 },
   { "One", 1 },
   { "Two", 2 },
   { "Three", 3 },
   { "Four", 4 },
   { "Five", 5 },
};

[VM_List("Battle Sounds (Limited size)", minNumElements: 1, maxNumElements: 5)]
[VM_Audio]
public List<AudioClip> _fieldListClips = new() { null };

[VM_List("Sprite objects (Index: disabled)", hideIndex: true)]
[VM_AssetObjectsOnly]
public List<Sprite> _fieldListSprites = new();

[VM_Title("Nested data", thicknessLine: 2)]

[VM_List("Ability Roster (Foldout)", nameRefHeaderNested: nameof(NestedData._name),
         onAddMethod: nameof(OnAdd), onDelMethod: nameof(OnDel), onReorderMethod: nameof(OnReorder),
         onPasteMethod: nameof(OnPaste), onClearMethod: nameof(OnClear))]
public List<NestedData> _fieldFoldoutList = new();
void OnAdd(int index) => Debug.Log($"New element[{index}] was added.");
void OnDel(int index) => Debug.Log($"The element[{index}] will be removed.");
void OnReorder(int oldIndex, int newIndex) => Debug.Log($"The element[{oldIndex}] moved to index {newIndex}.");
void OnPaste() => Debug.Log("Array pasted");
void OnClear() => Debug.Log("Array cleared");

[VM_List("Ability Roster (Box)", foldoutHeaderNested: false)]
public List<NestedData> _fieldNoFoldoutList = new();

[VM_List("Ability Desc (No Header)", showHeaderNested: false)]
public List<ChildNestedData> _fieldNoHeaderList = new();

[VM_List("Ability Desc (Inline variant)", showHeaderNested: false, inlineNested: true)]
public List<InlineNestedData> _fieldInlineList = new();

[VM_Title("NonSerialized Fields")]

[VM_List("Private (Del: disabled, ReadOnlyItems: enabled)", hideDel: true, isReadOnlyItems: true)]
[VM_ShowInInspector]
private List<NestedData> _privateList = new();

[VM_List("Property (get/set) (Index: disabled)", hideIndex: true)]
[VM_ProgressBar(0, 100)]
[VM_ShowInInspector]
public List<int> PropertyList { get; set; } = new();

public enum eDirection
{
   Right, Left, Up, Down, UpLeft, UpRight, DownLeft, DownRight
}

public enum eDirectionBits
{
   None = 0,
   Right = 1 << 0,
   Left = 1 << 1,
   Up = 1 << 2,
   Down = 1 << 3,
   UpLeft = 1 << 4,
   UpRight = 1 << 5,
   DownLeft = 1 << 6,
   DownRight = 1 << 7,
}

[System.Serializable]
public class NestedData
{
   public override string ToString() => string.IsNullOrEmpty(_name) ? "Ability Name : unknown" : $"Ability Name : {_name}";

   [VM_LabelWidth(0.2f)]
   [VM_Label("🏷️ Ability Name")]
   public string _name = "";

   [VM_Label("⚡ Mana Cost")]
   [VM_ProgressBar(0, 100)]
   public int _intValue = 50;

   [VM_Label("⏱️ Cooldown")]
   [VM_RangeSlider(0, 100)]
   public float _floatValue = 10.5f;

   [VM_Label("🧭 Cast Direction")]
   [VM_Enum(limitPerLine: 4)]
   public eDirection _enumToglesLimit;

   [VM_Label("💥 Damage")]
   [VM_SegmentedBar(10)]
   public int _damage = 5;

   [VM_Label("🎯 Target Directions")]
   [VM_EnumList(limitPerLine: 4)]
   public List<eDirection> _enumToglesLabel = new();

   [VM_TabGroup("Tab1")]
   [VM_NestedAsGroup("🧪 Unique Effect Data")]
   public ChildNestedData _childData;

   [VM_TabGroup("Tab2")]
   [VM_List("📋 Effect Variants")]
   public List<ChildNestedData> _fieldList = new();
}

[System.Serializable]
public class ChildNestedData
{
   [VM_Label("📝 Description")]
   public string _stringValue = "some text";

   [VM_Label("✅ Active")]
   [VM_Toggles]
   public bool _booleanValue = true;

   public override string ToString() => "🧪 Effect Data";
}

[System.Serializable]
public class InlineNestedData
{
   [VM_Width(0.75f, gap: 10)]
   [VM_Label("📝 Description")]
   public string _stringValue = "some text";

   [VM_HideLabel]
   [VM_Toggles]
   public bool _booleanValue = true;
}

[VM_Title("Simple data", thicknessLine: 2)]

[VM_Dictionary("🎯 Stat Caps (default)")]
[VM_Multiline]
public SerializedDictionary<int, string> _damagePerLevel = new();

[VM_Dictionary("⚡ Damage Per Level (key width = 0.35)", tableKeyWidth: 0.35f)]
[VM_Suffix("%")]
public SerializedDictionary<string, int> _statCaps = new();

[VM_Dictionary("🎚️ Multipliers (key width = 120px)", tableKeyWidth: 120f)]
[VM_ProgressBar(0, 1, suffix: " SP")]
public SerializedDictionary<string, float> _multipliers = new();

[VM_Dictionary("🧭 Bonuses")]
[VM_SimplePrefab(stretchWidth: true)]
public SerializedDictionary<eDirection, GameObject> _directionSpeeds = new();

[VM_Dictionary("❤️ Skill Mana (range slider + suffix)")]
[VM_RangeSlider(0, 100)]
[VM_Suffix("%")]
public SerializedDictionary<string, int> _skillMana = new();

[VM_Dictionary("📊 Resistance % (limited size [1..6])", minNumElements: 1, maxNumElements: 6)]
[VM_ProgressBar(0, 100, suffix: " HP")]
[VM_Suffix("%")]
public SerializedDictionary<int, int> _resistance = new() { { 0, default } };

[VM_Title("List<T>", thicknessLine: 2)]

[VM_Dictionary("🎒 List via Unity")]
public SerializedDictionary<eDirection, List<int>> _fieldDictUnity = new();

[VM_Dictionary("🎒 List via attributes", tableviewNested: true)]
[VM_List("Int Array")]
[VM_RangeSlider(0, 999)]
[VM_Suffix("%")]
public SerializedDictionary<eDirection, List<int>> _lootTables = new();

[VM_Title("Nested data", thicknessLine: 2)]

[VM_Dictionary("🗡️ Nested data (default)",
               onAddMethod: nameof(OnAdd), onDelMethod: nameof(OnDel),
               onPasteMethod: nameof(OnPaste), onClearMethod: nameof(OnClear))]
public SerializedDictionary<string, AbilityData> _abilities = new();
void OnAdd(string key) => Debug.Log($"New element[{key}] was added.");
void OnDel(string key) => Debug.Log($"The element[{key}] will be removed.");
void OnPaste() => Debug.Log("Dictionary pasted");
void OnClear() => Debug.Log("Dictionary cleared");

[VM_Dictionary("🗡️ Abilities inline (inlineNested = true)", inlineNested: true)]
public SerializedDictionary<string, InlineNestedData> _abilitiesInline = new();

[VM_Dictionary("🗡️ Abilities table (tableviewNested = true)", tableviewNested: true)]
public SerializedDictionary<string, AbilityData> _abilitiesTable = new();

[VM_Dictionary("🗡️ Abilities table inline (inlineNested = true)", tableviewNested: true, inlineNested: true)]
public SerializedDictionary<string, InlineNestedData> _abilitiesInlineTable = new();

[VM_Title("NonSerialized Fields")]

[VM_Dictionary("Private", hideAdd: true)]
[VM_RangeSlider(0, 100)]
[VM_Suffix("%")]
[VM_ShowInInspector]
private SerializedDictionary<string, int> _privateDict = new();
[VM_Button("Add a value", hexColor: HexColor.Lime400)]
void AddValue() => _privateDict.Add(0);

[VM_Dictionary("Property (get/set)")]
[VM_ShowInInspector]
public SerializedDictionary<string, AbilityData> _propertyDict { get; set; } = new();

public enum eDirection
{
   North, East, South, West
}

[System.Serializable]
public class AbilityData
{
   [VM_Label("⚡ Mana Cost")]
   [VM_RangeSlider(0, 100)]
   public int _manaCost = 25;

   [VM_Label("⏱️ Cooldown")]
   [VM_Suffix("sec")]
   [VM_Min(0.1f)]
   public float _cooldown = 1.5f;

   [VM_Label("💥 Damage")]
   [VM_SegmentedBar(5)]
   public int _damage = 3;
}

[System.Serializable]
public class InlineNestedData
{
   [VM_Width(0.75f, gap: 10)]
   [VM_Label("📝 Desc")]
   [VM_LabelWidth(55)]
   public string _stringValue = "some text";

   [VM_HideLabel]
   [VM_Toggles]
   public bool _booleanValue = true;
}

[VM_VerticalGroup("Vert", label: "🎮 Player Settings")]
[VM_VerticalGroup("Vert/Child", label: "Combat", drawer: eDrawer.Box, hexColor: HexColor.Sky400)]
[VM_VerticalGroup("Vert/Child/InnerData", label: "💥 Damage", drawer: eDrawer.Foldout)]
[VM_Label("🗡️ Weapon")]
public string _weapon = "Iron Sword";

[VM_VerticalGroup("Vert/Child/InnerDict", label: "💥 Dictionary", drawer: eDrawer.Foldout)]
[VM_Dictionary("📋 Waypoints")]
[VM_RangeSlider(0, 100, fieldWidth: 80)]
[VM_Suffix("%")]
public SerializedDictionary<string, float> _fieldDict = new();

[VM_VerticalGroup("Vert")]
[VM_List("📋 Waypoints")]
[VM_RangeSlider(0, 100, fieldWidth: 80)]
[VM_Suffix("%")]
public List<float> _fieldList = new();

[VM_VerticalGroup("Vert/Child/InnerData")]
[VM_Title("🛡️ Defense", align: eAlign.Center)]
[VM_Label("Defense Stats")]
[VM_NestedColor(hexColor: HexColor.Green300)]
public DefenseData _defenseStats;

[VM_Separator(beforeGroup: "VertWithoutHeader")]
[VM_Note("Also you can hide the group header to simply frame the data.", beforeGroup: "VertWithoutHeader")]

[VM_VerticalGroup("VertWithoutHeader", hideLabel: true)]
[VM_Label("🎵 Music Volume")]
[VM_Suffix("%")]
public string _musicVolume = "80";

[VM_VerticalGroup("VertWithoutHeader")]
[VM_Label("🔊 SFX Volume")]
[VM_Suffix("%")]
public float _sfxVolume = 0.75f;

[System.Serializable]
public class DefenseData
{
   [VM_Label("🛡️ Armor")]
   [VM_RangeSlider(0, 100)]
   public int _armor = 50;

   [VM_Label("❤️ Max Health")]
   [VM_Suffix("HP")]
   [VM_Min(1f)]
   public float _maxHealth = 100f;

   [VM_NestedAsGroup("🧪 Resistances", hexColor: HexColor.Fuchsia300)]
   public ResistanceData _resistances;
}

[System.Serializable]
public class ResistanceData
{
   [VM_Label("🔥 Fire")]
   [VM_Suffix("%")]
   public string _fire = "25";

   [VM_Label("❄️ Frost")]
   [VM_Toggles]
   public bool _frostImmune = true;
}

[VM_HorizontalGroup("Horiz", label: "🎮 Character Setup")]
[VM_VerticalGroup("Horiz/Left", label: "⚔️ Offense", hexColor: HexColor.Sky400)]
[VM_Label("🗡️ Weapon")]
[VM_LabelWidth(90, beforeGroup: "Horiz/Left")]
public string _weapon = "Iron Sword";

[VM_VerticalGroup("Horiz/Left")]
[VM_NestedAsGroup("💥 Attack Stats")]
public AttackData _attackStats;

[VM_VerticalGroup("Horiz/Right", label: "🛡️ Defense")]
[VM_Label("🛡️ Armor Type")]
public string _armorType = "Chainmail";

[VM_VerticalGroup("Horiz/Right", label: "🛡️ Defense")]
[VM_LabelWidth(0.6f)]
[VM_NestedAsGroup("❤️ Health Stats")]
public HealthData _healthStats;

[VM_Separator(beforeGroup: "HorizNone")]
[VM_Note("Set the Drawer property to <b>None</b> to use the horizontal group as a simple container without a border.", beforeGroup: "HorizNone")]
[VM_Note("Also you can assign width weights to elements (ensure the total sum does not exceed 1.0).", beforeGroup: "HorizNone")]

[VM_Title("Invisible horizontal group (eDrawer.None)", beforeGroup: "HorizNone")]

[VM_HorizontalGroup("HorizNone", drawer: eDrawer.None)]
[VM_VerticalGroup("HorizNone/Left", label: "📍 Position")]
[VM_Width(0.6f)]
[VM_Label("🌍 Location")]
public string _location = "Spawn Point";

[VM_VerticalGroup("HorizNone/Left")]
[VM_NestedAsGroup("📐 Coordinates")]
public CoordinateData _coordinates;

[VM_Width(0.4f)]
[VM_VerticalGroup("HorizNone/Right", label: "🎨 Appearance")]
[VM_Label("👤 Skin")]
public string _skin = "Default";

[VM_VerticalGroup("HorizNone/Right", label: "🎨 Appearance")]
[VM_NestedAsGroup("🎨 Visual")]
public VisualData _visual;

[System.Serializable]
public class AttackData
{
   [VM_Label("💥 Damage")]
   [VM_RangeSlider(0, 100)]
   public int _damage = 50;

   [VM_Label("⏱️ Rate")]
   [VM_Suffix("sec")]
   [VM_Min(0.1f)]
   public float _attackRate = 1.5f;
}

[System.Serializable]
public class HealthData
{
   [VM_Label("❤️ Max HP")]
   [VM_Suffix("HP")]
   public string _maxHP = "100";

   [VM_Label("🧪 Regen")]
   [VM_Toggles]
   public bool _regenEnabled = true;
}

[System.Serializable]
public class CoordinateData
{
   [VM_LabelWidth(35)]

   [VM_Label("📍 X")]
   [VM_RangeSlider(-100, 100)]
   public int _x = 0;

   [VM_Label("📍 Y")]
   [VM_Min(0f)]
   public float _y = 1.5f;
}

[System.Serializable]
public class VisualData
{
   [VM_Label("🎨 Color")]
   public string _tint = "White";

   [VM_Label("✨ Glow")]
   [VM_Toggles]
   public bool _glowEnabled = true;
}

[VM_TabGroup("General", label: "⚙️ General")]
[VM_Label("🏷️ Player Name")]
public string _playerName = "Hero";
[VM_TabGroup("General")]
[VM_Label("🎚️ Difficulty")]
[VM_Suffix("level")]
public float _difficulty = 0.5f;
[VM_TabGroup("General")]
[VM_List("📋 Waypoints")]
[VM_RangeSlider(0, 100, fieldWidth: 80)]
[VM_Suffix("%")]
public List<float> _waypoints = new();

[VM_TabGroup("Combat", label: "⚔️ Combat", hexColor: HexColor.Red200)]
[VM_Label("🗡️ Weapon")]
public string _weapon = "Iron Sword";
[VM_TabGroup("Combat")]
[VM_Label("💥 Base Damage")]
[VM_Suffix("HP")]
public float _baseDamage = 25f;

[VM_HorizontalGroup("Combat/Horiz", label: "📊 Attributes")]
[VM_VerticalGroup("Combat/Horiz/VertLeft", label: "⚔️ Offense")]
[VM_Label("💪 Strength")]
public string _strength = "10";
[VM_VerticalGroup("Combat/Horiz/VertLeft")]
[VM_Label("🏹 Dexterity")]
public float _dexterity = 8f;

[VM_VerticalGroup("Combat/Horiz/VertRight", label: "🛡️ Defense")]
[VM_Label("🛡️ Armor")]
public string _armor = "Chainmail";
[VM_VerticalGroup("Combat/Horiz/VertRight")]
[VM_Label("❤️ Vitality")]
public float _vitality = 12f;

[VM_TabGroup("Skills", label: "🧙 Skills", hexColor: HexColor.Sky200)]
[VM_Label("🔮 Active Spell")]
public string _activeSpell = "Fireball";
[VM_TabGroup("Skills")]
[VM_Label("🧪 Mana Cost")]
[VM_Suffix("MP")]
public float _manaCost = 15f;

[VM_TabGroup("Skills/Offensive", label: "⚔️ Offensive", hexColor: HexColor.Orange200)]
[VM_Label("🔥 Fire Power")]
public string _firePower = "Level 3";
[VM_TabGroup("Skills/Offensive")]
[VM_Label("⚡ Lightning")]
[VM_Suffix("dmg")]
public float _lightningDmg = 45f;

[VM_HorizontalGroup("Skills/Offensive/Horiz", drawer: eDrawer.None)]
[VM_VerticalGroup("Skills/Offensive/Horiz/Fire", label: "🔥 Fire")]
[VM_Label("💥 Damage")]
public string _fireDmg = "30";
[VM_VerticalGroup("Skills/Offensive/Horiz/Fire")]
[VM_Label("⏱️ Cooldown")]
[VM_Suffix("sec")]
public float _fireCooldown = 1.5f;

[VM_VerticalGroup("Skills/Offensive/Horiz/Ice", label: "❄️ Ice")]
[VM_Label("💥 Damage")]
public string _iceDmg = "20";
[VM_VerticalGroup("Skills/Offensive/Horiz/Ice")]
[VM_Label("⏱️ Cooldown")]
[VM_Suffix("sec")]
public float _iceCooldown = 2.0f;

[VM_VerticalGroup("Skills/Offensive/Horiz/Shock", label: "⚡ Shock")]
[VM_Label("💥 Damage")]
public string _shockDmg = "45";
[VM_VerticalGroup("Skills/Offensive/Horiz/Shock")]
[VM_Label("⏱️ Cooldown")]
[VM_Suffix("sec")]
public float _shockCooldown = 3.0f;

[VM_TabGroup("Skills/Defensive", label: "🛡️ Defensive", hexColor: HexColor.Green200)]
[VM_Label("🧪 Heal Amount")]
[VM_Suffix("HP")]
public string _healAmount = "50";
[VM_VerticalGroup("Skills/Defensive")]
[VM_Label("⏱️ Heal Cooldown")]
[VM_Suffix("sec")]
public float _healCooldown = 5f;
[VM_TabGroup("Skills/Defensive")]
[VM_Label("🛡️ Shield")]
public ShieldData _shield;

[VM_Separator]
[VM_Note("Fields without any group attributes default to the root group.")]

[VM_Label("📝 Description")]
public string _description = "A brave adventurer";
[VM_Label("⭐ Level")]
public float _level = 1f;

[System.Serializable]
public class ShieldData
{
   [VM_Label("🛡️ Duration")]
   [VM_Suffix("sec")]
   [VM_RangeSlider(0, 100)]
   public int _duration = 10;

   [VM_Label("💪 Strength")]
   public float _strength = 50f;

   [VM_Label("🧪 Absorption")]
   public AbsorptionData _absorption;
}

[System.Serializable]
public class AbsorptionData
{
   [VM_Label("🔥 Fire")]
   [VM_Suffix("%")]
   public string _fire = "50";

   [VM_Label("❄️ Frost")]
   [VM_Toggles]
   public bool _frostImmune = true;
}

[VM_Label("🎯 Max Level")]
[VM_ReadOnly]
public int _fieldReadonlyInt = 20;

[VM_Label("💀 Damage Taken")]
[VM_ReadOnly]
[VM_BonusSlider(-10, 10, flipColors: true)]
[VM_Suffix("HP")]
public int _damageTaken = 7;

[VM_Label("👑 Is Legendary")]
[VM_ReadOnly]
[VM_Toggles]
public bool _fieldReadonlyBoolean = true;

[VM_Label("🎯 Attack None Direction")]
[VM_ReadOnly]
[VM_Enum(limitPerLine: 4)]
public eDirection _enumToglesLimit = eDirection.DownLeft;
public enum eDirection
{
   Right, Left, Up, Down, UpLeft, UpRight, DownLeft, DownRight
}

[VM_Label("Health")]
[VM_ReadOnly]
[VM_ProgressBar(0, 100, hexColorBar: HexColor.Orange500)]
[VM_Suffix("HP")]
public int _health = 50;

[VM_Label("Defense")]
[VM_ReadOnly]
[VM_Suffix("%")]
[VM_SegmentedBar(6, hexColorBar: HexColor.Green600)]
public int _defense = 2;

[VM_Label("Nested Data")]
[VM_ReadOnly]
public SmallNestedData _nestedData;

[VM_List("Array")]
[VM_Toggles]
[VM_ReadOnly]
public List<bool> _fieldList = new() { true, true };

[VM_Dictionary("Dictionary")]
[VM_Toggles]
[VM_ReadOnly]
public SerializedDictionary<string, bool> _fieldDict = new() { false, false };

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_ReadOnly]
[VM_ShowInInspector]
private string _privateString = "some text";

[VM_Label("Property (get/set)")]
[VM_ReadOnly]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "some text";

[System.Serializable]
public class SmallNestedData
{
   [VM_Label("String")]
   [VM_Multiline]
   public string _stringValue = "some text";

   [VM_Label("Boolean")]
   [VM_Toggles]
   public bool _booleanValue = true;
}

[VM_Label("Int")]
[VM_ShowAsString]
public int _intValue = 42;

[VM_Label("Float")]
[VM_ShowAsString(format: "0.##")]
public float _floatValue = 3.14159f;

[VM_Label("Formatted Float")]
[VM_ShowAsString(format: "0.####")]
public float _formattedFloat = 123.456789f;

[VM_Label("Boolean")]
[VM_ShowAsString]
public bool _boolValue = true;

[VM_Label("String")]
[VM_ShowAsString]
[VM_Multiline]
public string _stringValue = "Hello World!\nYou are beautiful!";

[VM_Label("Vector3")]
[VM_ShowAsString(format: "0.##")]
public Vector3 _vectorValue = new Vector3(1.5f, 2f, 3.1f);

[VM_Label("Color")]
[VM_ShowAsString(format: "0.#")]
public Color _colorValue = Color.black * 0.5f;

[VM_Label("Nested Data")]
public SmallNestedData _nested;

[VM_List("Array")]
[VM_ShowAsString]
public List<bool> _fieldList = new() { true, true };

[VM_Dictionary("Dictionary")]
[VM_ShowAsString]
public SerializedDictionary<string, bool> _fieldDict = new() { false, false };

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_ShowAsString]
[VM_ShowInInspector]
private string _privateString = "Hello World";

[VM_Label("Property (get/set)")]
[VM_ShowAsString]
[VM_ShowInInspector]
public float PropertyFloat { get; set; } = 3.14159f;

[System.Serializable]
public class SmallNestedData
{
   [VM_Label("String")]
   [VM_ShowAsString]
   public string _stringValue = "some text";

   [VM_Label("Boolean")]
   [VM_ShowAsString]
   public bool _booleanValue = true;
}

[VM_Label("🏰 Root Object")]
public GameObject _rootObject;

[VM_Label("🎯 Select all Transform")]
[VM_ChildrenOnly(nameof(_rootObject))]
public Transform _selectedTransform;

[VM_Label("🔲 Select all Collider")]
[VM_ChildrenOnly(nameof(_rootObject))]
public Collider _selectedCollider;

[VM_Label("🎨 Select all Renderer")]
[VM_ChildrenOnly(nameof(_rootObject))]
public Renderer _selectedRenderer;

[VM_Label("📦 Select child GameObject")]
[VM_ChildrenOnly(nameof(_rootObject))]
public GameObject _selectedChild;

[VM_Label("🟢 Show active Only")]
[VM_ChildrenOnly(nameof(_rootObject), includeInactive: false)]
public GameObject _selectedActiveChild;

[VM_Label("🗡️ Weapon Prefab")]
[VM_Suffix("asset")]
[VM_AssetObjectsOnly]
public GameObject _assetPrefab;

[VM_Label("🧱 Armor Material")]
[VM_Suffix("asset")]
[VM_AssetObjectsOnly]
public Material _assetMaterial;

[VM_Label("🖼️ Ability Icon")]
[VM_Suffix("asset")]
[VM_AssetObjectsOnly]
public Texture2D _assetTexture;

[VM_List("Sprite objects")]
[VM_AssetObjectsOnly]
[VM_Suffix("asset")]
public List<Sprite> _fieldList = new();

[VM_Dictionary("Sprite objects")]
[VM_AssetObjectsOnly]
[VM_Suffix("asset")]
public SerializedDictionary<string, Sprite> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("asset")]
[VM_AssetObjectsOnly]
[VM_ShowInInspector]
private GameObject _privateObject;

[VM_Label("Property (get/set)")]
[VM_Suffix("asset")]
[VM_AssetObjectsOnly]
[VM_ShowInInspector]
public GameObject PropertyObject { get; set; } = null;

[VM_Label("🎯 Target Object")]
[VM_Suffix("in scene")]
[VM_SceneObjectsOnly]
public GameObject _sceneObject;

[VM_Label("🎥 Battle Camera")]
[VM_Suffix("in scene")]
[VM_SceneObjectsOnly]
public Camera _sceneCamera;

[VM_Label("📍 Spawn Point")]
[VM_Suffix("in scene")]
[VM_SceneObjectsOnly]
public Transform _sceneTransform;

[VM_List("Camera objects")]
[VM_SceneObjectsOnly]
[VM_Suffix("in scene")]
public List<Camera> _fieldList = new();

[VM_Dictionary("GameObject objects")]
[VM_SceneObjectsOnly]
[VM_Suffix("in scene")]
public SerializedDictionary<string, GameObject> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("in scene")]
[VM_SceneObjectsOnly]
[VM_ShowInInspector]
private GameObject _privateObject;

[VM_Label("Property (get/set)")]
[VM_Suffix("in scene")]
[VM_SceneObjectsOnly]
[VM_ShowInInspector]
public GameObject PropertyObject { get; set; } = null;

[VM_Label("⚔️ Attack Power")]
[VM_DisableInPlayMode]
public int _fieldInt = 10;

[VM_Label("📝 Hero Name")]
[VM_DisableInPlayMode]
public string _fieldString = "Knight";

[VM_Label("👑 Is Legendary")]
[VM_Toggles]
[VM_DisableInPlayMode]
public bool _fieldBoolean = true;

[VM_List("Array")]
[VM_Toggles]
[VM_DisableInPlayMode]
public List<bool> _fieldList = new() { true, true };

[VM_Dictionary("Dictionary")]
[VM_Toggles]
[VM_DisableInPlayMode]
public SerializedDictionary<string, bool> _fieldDict = new() { false, false };

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_DisableInPlayMode]
[VM_ShowInInspector]
private string _privateString = "some text";

[VM_Label("Property (get/set)")]
[VM_DisableInPlayMode]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "some text";

[VM_Label("⚔️ Attack Power")]
[VM_DisableInEditorMode]
public int _fieldInt = 10;

[VM_Label("📝 Hero Name")]
[VM_DisableInEditorMode]
public string _fieldString = "Knight";

[VM_Label("👑 Is Legendary")]
[VM_Toggles]
[VM_DisableInEditorMode]
public bool _fieldBoolean = true;

[VM_List("Array")]
[VM_Toggles]
[VM_DisableInEditorMode]
public List<bool> _fieldList = new() { true, true };

[VM_Dictionary("Dictionary")]
[VM_Toggles]
[VM_DisableInEditorMode]
public SerializedDictionary<string, bool> _fieldDict = new() { false, false };

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_DisableInEditorMode]
[VM_ShowInInspector]
private string _privateString = "some text";

[VM_Label("Property (get/set)")]
[VM_DisableInEditorMode]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "some text";

[VM_Label("⚔️ Attack Power")]
[VM_HideInPlayMode]
public int _fieldInt = 10;

[VM_Label("📝 Hero Name")]
[VM_HideInPlayMode]
public string _fieldString = "Knight";

[VM_Label("👑 Is Legendary")]
[VM_Toggles]
[VM_HideInPlayMode]
public bool _fieldBoolean = true;

[VM_List("Array")]
[VM_Toggles]
[VM_HideInPlayMode]
public List<bool> _fieldList = new() { true, true };

[VM_Dictionary("Dictionary")]
[VM_Toggles]
[VM_HideInPlayMode]
public SerializedDictionary<string, bool> _fieldDict = new() { false, false };

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_HideInPlayMode]
[VM_ShowInInspector]
private string _privateString = "some text";

[VM_Label("Property (get/set)")]
[VM_HideInPlayMode]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "some text";

[VM_Label("⚔️ Attack Power")]
public int _fieldInt = 10;

[VM_Note("None other fields will be visible only in Play Mode.")]
[VM_Label("📝 Hero Name")]
public string _fieldString = "Knight";

[VM_Label("👑 Is Legendary")]
[VM_Toggles]
[VM_HideInEditorMode]
public bool _fieldBoolean = true;

[VM_List("Array")]
[VM_Toggles]
[VM_HideInEditorMode]
public List<bool> _fieldList = new() { true, true };

[VM_Dictionary("Dictionary")]
[VM_Toggles]
[VM_HideInEditorMode]
public SerializedDictionary<string, bool> _fieldDict = new() { false, false };

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_HideInEditorMode]
[VM_ShowInInspector]
private string _privateString = "some text";

[VM_Label("Property (get/set)")]
[VM_HideInEditorMode]
[VM_ShowInInspector]
public string PropertyString { get; set; } = "some text";

[VM_LabelWidth(0.4f)]

[VM_Label("Public Field")]
[VM_ProgressBar(0, 100)]
public int _publicField = 50;

[VM_Label("Private Field")]
[VM_ShowInInspector]
[VM_RangeSlider(0, 100)]
private int _privateField = 50;

[VM_Label("Protected Field")]
[VM_ShowInInspector]
[VM_SegmentedBar(10)]
protected int _protectedField = 2;

[VM_Label("Public Property (get/set)")]
[VM_ShowInInspector]
[VM_ProgressBar(0, 100)]
public int PublicProperty { get; set; } = 73;

[VM_Label("Private Property (get/set)")]
[VM_ShowInInspector]
[VM_RangeSlider(0, 100)]
private int PrivateProperty { get; set; } = 40;

[VM_Label("Protected Property (get/set)")]
[VM_ShowInInspector]
[VM_SegmentedBar(10)]
protected int ProtectedProperty { get; set; } = 5;

[VM_Label("Public Property (get only)")]
[VM_ShowInInspector]
public float GetterOnlyProperty => _publicField + _privateField + _protectedField + PublicProperty + PrivateProperty + ProtectedProperty;

[VM_NestedAsGroup("Nested Data")]
public NestedData _nestedData;

[System.Serializable]
public class NestedData
{
   [VM_Label("Public Field")]
   [VM_ProgressBar(0, 100)]
   public int _publicField = 50;

   [VM_Label("Private Field")]
   [VM_ShowInInspector]
   [VM_RangeSlider(0, 100)]
   private int _privateField = 50;

   [VM_Label("Protected Field")]
   [VM_ShowInInspector]
   [VM_SegmentedBar(10)]
   protected int _protectedField = 2;

   [VM_Label("Public Property (get/set)")]
   [VM_ShowInInspector]
   [VM_ProgressBar(0, 100)]
   public int PublicProperty { get; set; } = 73;

   [VM_Label("Private Property (get/set)")]
   [VM_ShowInInspector]
   [VM_RangeSlider(0, 100)]
   private int PrivateProperty { get; set; } = 40;

   [VM_Label("Protected Property (get/set)")]
   [VM_ShowInInspector]
   [VM_SegmentedBar(10)]
   protected int ProtectedProperty { get; set; } = 5;

   [VM_Label("Public Property (get only)")]
   [VM_ShowInInspector]
   public float GetterOnlyProperty => _publicField + _privateField + _protectedField + PublicProperty + PrivateProperty + ProtectedProperty;
}

[VM_Label("Public Field")]
[VM_ProgressBar(0, 100)]
public int _visibleField = 50;

[VM_Label("Public Field (you won't see this)")]
[VM_HideInInspector]
[VM_RangeSlider(0, 100)]
public int _hiddenField = 50;

[VM_Note("The field marked with <b>VM_HideInInspector</b> above is still serialized, " +
            "but it is not displayed in the Inspector.")]

[VM_Label("Public Property (get only)")]
[VM_ShowInInspector]
public int SumOfFields => _visibleField + _hiddenField;

[VM_NestedAsGroup("Nested Data")]
public NestedData _nestedData;

[System.Serializable]
public class NestedData
{
   [VM_LabelWidth(0.5f)]
   [VM_HideInInspector]
   public bool _useFlag = true;

   [VM_Label("Public Field")]
   [VM_ProgressBar(0, 100)]
   public int _visibleField = 50;

   [VM_Label("Public Field (you won't see this)")]
   [VM_HideInInspector]
   [VM_RangeSlider(0, 100)]
   public int _hiddenField = 50;

   [VM_Note("The field marked with <b>VM_HideInInspector</b> above is still serialized, " +
            "but it is not displayed in the Inspector.")]

   [VM_Label("Public Property (get only)")]
   [VM_ShowInInspector]
   public int SumOfFields => _visibleField + _hiddenField;
}

public enum eConditionEnabled
{
   All, Integer, Float, Segments
}

[VM_Label("Root Fields")]
[VM_Toggles(nameTrue: "Enable", nameFalse: "Disable")]
public bool _fieldToggle = true;

[VM_EnableIf(nameof(_fieldToggle))]
[VM_Label("Enable by Type")]
[VM_Enum(limitPerLine: 4)]
public eConditionEnabled _fieldEnumCondition = eConditionEnabled.All;

[VM_EnableIf(nameof(_fieldToggle), nameof(IsEnumInt))]
[VM_Label("⚔️ Attack Power")]
[VM_RangeSlider(0, 100)]
public int _intValue = 50;
bool IsEnumInt => _fieldEnumCondition == eConditionEnabled.All || _fieldEnumCondition == eConditionEnabled.Integer;

[VM_EnableIf(nameof(_fieldToggle), nameof(IsEnumFloat))]
[VM_Label("🏃 Move Speed")]
[VM_Min(1f)]
public float _floatValue = 10.5f;
bool IsEnumFloat => _fieldEnumCondition == eConditionEnabled.All || _fieldEnumCondition == eConditionEnabled.Float;

[VM_EnableIf(nameof(_fieldToggle), nameof(IsEnumSegments))]
[VM_Label("💎 Enchantment")]
[VM_SegmentedBar(10)]
public int _segmentValue = 5;
bool IsEnumSegments => _fieldEnumCondition == eConditionEnabled.All || _fieldEnumCondition == eConditionEnabled.Segments;

[VM_Separator]
[VM_Label("Nested Data")]
[VM_Toggles(nameTrue: "Enable", nameFalse: "Disable")]
public bool _fieldToggleNested = true;

[VM_EnableIf(nameof(_fieldToggleNested))]
[VM_NestedAsGroup("📦 Nested Data")]
public NestedData _fieldNested;

[System.Serializable]
public class NestedData
{
   [VM_LabelWidth(0.2f)]

   [VM_Label("🏷️ Name")]
   public string _name = "Player";

   [VM_Label("Tab-1")]
   [VM_Toggles(nameTrue: "Enable", nameFalse: "Disable")]
   public bool _fieldToggleTab1 = true;

   [VM_Label("Tab-2")]
   [VM_Toggles(nameTrue: "Enable", nameFalse: "Disable")]
   public bool _fieldToggleTab2 = true;

   [VM_Label("ChildNest Data")]
   [VM_Toggles(nameTrue: "Enable", nameFalse: "Disable")]
   public bool _fieldToggleChildNested = true;

   [VM_EnableIf(nameof(_fieldToggleTab1))]
   [VM_TabGroup("Tab-1")]
   [VM_List("📋 String List")]
   public List<string> _fieldListSimple = new();

   [VM_EnableIf(nameof(_fieldToggleTab2))]
   [VM_TabGroup("Tab-2")]
   [VM_List("📋 Child List")]
   public List<ChildNestedData> _fieldList = new();

   [VM_EnableIf(nameof(_fieldToggleChildNested))]
   [VM_Label("🧪 ChildNested Data")]
   public ChildNestedData _fieldChildNested;
}

[System.Serializable]
public class ChildNestedData
{
   [VM_Label("📝 Description")]
   public string _stringValue = "some text";

   [VM_Label("✅ Active")]
   [VM_Toggles]
   public bool _booleanValue = true;
}

public enum eConditionDisabled
{
   None, Integer, Float, Segments
}

[VM_Label("Root Fields")]
[VM_Toggles(nameTrue: "Disable", nameFalse: "Enable")]
public bool _fieldToggle = false;

[VM_DisableIf(nameof(_fieldToggle))]
[VM_Label("Disable by Type")]
[VM_Enum(limitPerLine: 4)]
public eConditionDisabled _fieldEnumCondition = eConditionDisabled.None;

[VM_DisableIf(nameof(_fieldToggle), nameof(IsEnumInt))]
[VM_Label("⚔️ Attack Power")]
[VM_RangeSlider(0, 100)]
public int _intValue = 50;
bool IsEnumInt => _fieldEnumCondition == eConditionDisabled.Integer;

[VM_DisableIf(nameof(_fieldToggle), nameof(IsEnumFloat))]
[VM_Label("🏃 Move Speed")]
[VM_Min(1f)]
public float _floatValue = 10.5f;
bool IsEnumFloat => _fieldEnumCondition == eConditionDisabled.Float;

[VM_DisableIf(nameof(_fieldToggle), nameof(IsEnumSegments))]
[VM_Label("💎 Enchantment")]
[VM_SegmentedBar(10)]
public int _segmentValue = 5;
bool IsEnumSegments => _fieldEnumCondition == eConditionDisabled.Segments;

[VM_Separator]
[VM_Label("Nested Data")]
[VM_Toggles(nameTrue: "Disable", nameFalse: "Enable")]
public bool _fieldToggleNested = false;

[VM_DisableIf(nameof(_fieldToggleNested))]
[VM_NestedAsGroup("📦 Nested Data")]
public NestedData _fieldNested;

[System.Serializable]
public class NestedData
{
   [VM_LabelWidth(0.2f)]

   [VM_Label("🏷️ Name")]
   public string _name = "Player";

   [VM_Label("Tab-1")]
   [VM_Toggles(nameTrue: "Disable", nameFalse: "Enable")]
   public bool _fieldToggleTab1 = false;

   [VM_Label("Tab-2")]
   [VM_Toggles(nameTrue: "Disable", nameFalse: "Enable")]
   public bool _fieldToggleTab2 = false;

   [VM_Label("ChildNested Data")]
   [VM_Toggles(nameTrue: "Disable", nameFalse: "Enable")]
   public bool _fieldToggleChildNested = false;

   [VM_DisableIf(nameof(_fieldToggleTab1))]
   [VM_TabGroup("Tab-1")]
   [VM_List("📋 String List")]
   public List<string> _fieldListSimple = new();

   [VM_DisableIf(nameof(_fieldToggleTab2))]
   [VM_TabGroup("Tab-2")]
   [VM_List("📋 Child List")]
   public List<ChildNestedData> _fieldList = new();

   [VM_DisableIf(nameof(_fieldToggleChildNested))]
   [VM_Label("🧪 ChildNested Data")]
   public ChildNestedData _fieldChildNested;
}

[System.Serializable]
public class ChildNestedData
{
   [VM_Label("📝 Description")]
   public string _stringValue = "some text";

   [VM_Label("✅ Active")]
   [VM_Toggles]
   public bool _booleanValue = true;
}

public enum eConditionShown
{
   All, Integer, Float, Segments
}

[VM_Label("Root Fields")]
[VM_Toggles(nameTrue: "Show", nameFalse: "Hide")]
public bool _fieldToggle = true;

[VM_ShowIf(nameof(_fieldToggle))]
[VM_Label("Show by Type")]
[VM_Enum(limitPerLine: 4)]
public eConditionShown _fieldEnumCondition = eConditionShown.All;

[VM_ShowIf(nameof(_fieldToggle), nameof(IsEnumInt))]
[VM_Label("⚔️ Attack Power")]
[VM_RangeSlider(0, 100)]
public int _intValue = 50;
bool IsEnumInt => _fieldEnumCondition == eConditionShown.All || _fieldEnumCondition == eConditionShown.Integer;

[VM_ShowIf(nameof(_fieldToggle), nameof(IsEnumFloat))]
[VM_Label("🏃 Move Speed")]
[VM_Min(1f)]
public float _floatValue = 10.5f;
bool IsEnumFloat => _fieldEnumCondition == eConditionShown.All || _fieldEnumCondition == eConditionShown.Float;

[VM_ShowIf(nameof(_fieldToggle), nameof(IsEnumSegments))]
[VM_Label("💎 Enchantment")]
[VM_SegmentedBar(10)]
public int _segmentValue = 5;
bool IsEnumSegments => _fieldEnumCondition == eConditionShown.All || _fieldEnumCondition == eConditionShown.Segments;

[VM_Separator]
[VM_Label("Nested Data")]
[VM_Toggles(nameTrue: "Show", nameFalse: "Hide")]
public bool _fieldToggleNested = true;

[VM_ShowIf(nameof(_fieldToggleNested))]
[VM_NestedAsGroup("📦 Nested Data")]
public NestedData _fieldNested;

[System.Serializable]
public class NestedData
{
   [VM_LabelWidth(0.2f)]

   [VM_Label("🏷️ Name")]
   public string _name = "Player";

   [VM_Label("Tab-1")]
   [VM_Toggles(nameTrue: "Show", nameFalse: "Hide")]
   public bool _fieldToggleTab1 = true;

   [VM_Label("Tab-2")]
   [VM_Toggles(nameTrue: "Show", nameFalse: "Hide")]
   public bool _fieldToggleTab2 = true;

   [VM_Label("ChildNest Data")]
   [VM_Toggles(nameTrue: "Show", nameFalse: "Hide")]
   public bool _fieldToggleChildNested = true;

   [VM_ShowIf(nameof(_fieldToggleTab1))]
   [VM_TabGroup("Tab-1")]
   [VM_List("📋 String List")]
   public List<string> _fieldListSimple = new();

   [VM_ShowIf(nameof(_fieldToggleTab2))]
   [VM_TabGroup("Tab-2")]
   [VM_List("📋 Child List")]
   public List<ChildNestedData> _fieldList = new();

   [VM_ShowIf(nameof(_fieldToggleChildNested))]
   [VM_Label("🧪 Child Fields")]
   public ChildNestedData _fieldChildNested;
}

[System.Serializable]
public class ChildNestedData
{
   [VM_Label("📝 Description")]
   public string _stringValue = "some text";

   [VM_Label("✅ Active")]
   [VM_Toggles]
   public bool _booleanValue = true;
}

public enum eConditionHidden
{
   None, Integer, Float, Segments
}

[VM_Label("Root Fields")]
[VM_Toggles(nameTrue: "Hide", nameFalse: "Show")]
public bool _fieldToggle = false;

[VM_HideIf(nameof(_fieldToggle))]
[VM_Label("Hide by Type")]
[VM_Enum(limitPerLine: 4)]
public eConditionHidden _fieldEnumCondition = eConditionHidden.None;

[VM_HideIf(nameof(_fieldToggle), nameof(IsEnumInt))]
[VM_Label("⚔️ Attack Power")]
[VM_RangeSlider(0, 100)]
public int _intValue = 50;
bool IsEnumInt => _fieldEnumCondition == eConditionHidden.Integer;

[VM_HideIf(nameof(_fieldToggle), nameof(IsEnumFloat))]
[VM_Label("🏃 Move Speed")]
[VM_Min(1f)]
public float _floatValue = 10.5f;
bool IsEnumFloat => _fieldEnumCondition == eConditionHidden.Float;

[VM_HideIf(nameof(_fieldToggle), nameof(IsEnumSegments))]
[VM_Label("💎 Enchantment")]
[VM_SegmentedBar(10)]
public int _segmentValue = 5;
bool IsEnumSegments => _fieldEnumCondition == eConditionHidden.Segments;

[VM_Separator]
[VM_Label("Nested Data")]
[VM_Toggles(nameTrue: "Hide", nameFalse: "Show")]
public bool _fieldToggleNested = false;

[VM_HideIf(nameof(_fieldToggleNested))]
[VM_NestedAsGroup("📦 Nested Data")]
public NestedData _fieldNested;

[System.Serializable]
public class NestedData
{
   [VM_LabelWidth(0.2f)]

   [VM_Label("🏷️ Name")]
   public string _name = "Player";

   [VM_Label("Tab-1")]
   [VM_Toggles(nameTrue: "Hide", nameFalse: "Show")]
   public bool _fieldToggleTab1 = false;

   [VM_Label("Tab-2")]
   [VM_Toggles(nameTrue: "Hide", nameFalse: "Show")]
   public bool _fieldToggleTab2 = false;

   [VM_Label("ChildNest Data")]
   [VM_Toggles(nameTrue: "Hide", nameFalse: "Show")]
   public bool _fieldToggleChildNested = false;

   [VM_HideIf(nameof(_fieldToggleTab1))]
   [VM_TabGroup("Tab-1")]
   [VM_List("📋 String List")]
   public List<string> _fieldListSimple = new();

   [VM_HideIf(nameof(_fieldToggleTab2))]
   [VM_TabGroup("Tab-2")]
   [VM_List("📋 Child List")]
   public List<ChildNestedData> _fieldList = new();

   [VM_HideIf(nameof(_fieldToggleChildNested))]
   [VM_Label("🧪 ChildNested Data")]
   public ChildNestedData _fieldChildNested;
}

[System.Serializable]
public class ChildNestedData
{
   [VM_Label("📝 Description")]
   public string _stringValue = "some text";

   [VM_Label("✅ Active")]
   [VM_Toggles]
   public bool _booleanValue = true;
}

[VM_Label("⚔️ Min Damage")]
[VM_Suffix("[1,N]")]
[VM_Min(1)]
public int _fieldInt = 1;

[VM_Label("🏃 Min Speed")]
[VM_Suffix("[10,N]")]
[VM_Min(10f)]
public float _fieldFloat = 12.5f;

[VM_Label("📍 Min Position")]
[VM_Suffix("[0,N]")]
[VM_Min(0f)]
public Vector3 _fieldVector = Vector3.one * 5.5f;

[VM_Label("🧱 Min Grid Cell")]
[VM_Suffix("[0,N]")]
[VM_Min(0)]
public Vector3Int _fieldVectorInt = Vector3Int.one * 10;

[VM_List("📊 Skill Damage")]
[VM_Min(1)]
[VM_Suffix("[1,N]")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Skill Damage")]
[VM_Min(1)]
[VM_Suffix("[1,N]")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("[-10,N]")]
[VM_Min(-10)]
[VM_ShowInInspector]
private float _privateFloat = 1;

[VM_Label("Property (get/set)")]
[VM_Suffix("[0,N]")]
[VM_Min(0f)]
[VM_ShowInInspector]
public float PropertyInt { get; set; } = 5.5f;

[VM_Label("⚔️ Max Damage")]
[VM_Suffix("[N,20]")]
[VM_Max(20)]
public int _fieldInt = 1;

[VM_Label("🏃 Max Speed")]
[VM_Suffix("[N,-10]")]
[VM_Max(-10f)]
public float _fieldFloat = -20.5f;

[VM_Label("📍 Max Position")]
[VM_Suffix("[N,20]")]
[VM_Max(20f)]
public Vector3 _fieldVector = Vector3.one * 5.5f;

[VM_Label("🧱 Max Grid Cell")]
[VM_Suffix("[N,20]")]
[VM_Max(20)]
public Vector3Int _fieldVectorInt = Vector3Int.one * 10;

[VM_List("📊 Skill Damage")]
[VM_Max(10)]
[VM_Suffix("[N,10]")]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Skill Damage")]
[VM_Max(10)]
[VM_Suffix("[N,10]")]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("[N,1]")]
[VM_Max(1)]
[VM_ShowInInspector]
private float _privateFloat = 1;

[VM_Label("Property (get/set)")]
[VM_Suffix("[N,20]")]
[VM_Max(20f)]
[VM_ShowInInspector]
public float PropertyInt { get; set; } = 5.5f;

[VM_Label("❤️ Health")]
[VM_Suffix("[0,100]")]
[VM_Clamp(0, 100)]
public int _fieldInt = 1;

[VM_Label("⚡ Mana")]
[VM_Suffix("[0,1]")]
[VM_Clamp(0, 1)]
public float _fieldFloat = 0.5f;

[VM_Label("📍 Patrol Area")]
[VM_Suffix("[0,10]")]
[VM_Clamp(0, 10)]
public Vector3 _fieldVector = Vector3.one * 5.5f;

[VM_Label("🧱 Dungeon Bounds")]
[VM_Suffix("[0,100]")]
[VM_Clamp(0, 100)]
public Vector3Int _fieldVectorInt = Vector3Int.one * 10;

[VM_Title("With Wraping", fieldOnly: true, align: eAlign.Center, fontSize: 11)]

[VM_Label("🔄 Rotation Angle")]
[VM_Suffix("[0,360]")]
[VM_Clamp(0, 360, wrap: true)]
public int _fieldIntWraping = 1;

[VM_Label("🌀 Spin Speed")]
[VM_Suffix("[0,1]")]
[VM_Clamp(0, 1, wrap: true)]
public float _fieldFloatWraping = 0.25f;

[VM_Label("🧭 Wind Direction")]
[VM_Suffix("[0,90]")]
[VM_Clamp(0, 90, wrap: true)]
public Vector3 _fieldVectorWraping = Vector3.one * 45.5f;

[VM_Label("🗺️ Tile Coords")]
[VM_Suffix("[0,50]")]
[VM_Clamp(0, 50, wrap: true)]
public Vector3Int _fieldVectorIntWraping = Vector3Int.one * 10;

[VM_List("📊 Skill Damage")]
[VM_Suffix("[1,10]")]
[VM_Clamp(1, 10)]
public List<int> _fieldList = new();

[VM_Dictionary("📊 Skill Damage")]
[VM_Suffix("[1,10]")]
[VM_Clamp(1, 10)]
public SerializedDictionary<string, int> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Suffix("[0,1]")]
[VM_Clamp(0, 1)]
[VM_ShowInInspector]
private float _privateFloat = 1;

[VM_Label("Property (get/set)")]
[VM_Suffix("[0,10]")]
[VM_Clamp(0f, 10f)]
[VM_ShowInInspector]
public float PropertyInt { get; set; } = 5.5f;

[VM_Required("You need to set a <b>texture</b> for the material")]
[VM_Label("🖼️ Character Skin")]
[VM_Image]
public Texture2D _assetTexture;

[VM_Required]
[VM_Label("🧱 Armor Surface")]
[VM_Material]
public Material _assetMaterial;

[VM_Required("<b>Prefab</b> is required")]
[VM_Label("🗡️ Weapon Model")]
[VM_SimplePrefab]
public GameObject _assetPrefab;

[VM_List("📊 Item Model")]
[VM_Required("<b>Prefab</b> is required")]
[VM_SimplePrefab(stretchWidth: true)]
public List<GameObject> _fieldList = new();

[VM_Dictionary("📊 Item Model")]
[VM_Required("<b>Prefab</b> is required")]
[VM_SimplePrefab(stretchWidth: true)]
public SerializedDictionary<string, GameObject> _fieldDict = new();

[VM_Title("NonSerialized Fields")]

[VM_Label("Private")]
[VM_Required]
[VM_ShowInInspector]
private Material _privateMaterial;

[VM_Label("Property (get/set)")]
[VM_Required]
[VM_ShowInInspector]
public GameObject PropertyObj { get; set; } = null;