using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using HarmonyLib;
using MageArenaItalianVoice.Config;
using Microsoft.CodeAnalysis;
using Recognissimo;
using Recognissimo.Components;
using UnityEngine;
using UnityEngine.Events;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("MageArenaItalianVoice")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2083092e9ff1559d12ace93ad94911a028f39734")]
[assembly: AssemblyProduct("MageArenaItalianVoice")]
[assembly: AssemblyTitle("MageArenaItalianVoice")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace MageArenaItalianVoice
{
[BepInPlugin("com.teddi201252.magearenaitalianvoice", "MageArenaItalianVoice", "1.0.0")]
public class MageArenaItalianVoice : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("com.teddi201252.magearenaitalianvoice");
internal static ManualLogSource Logger;
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
VoiceCommandConfig.Init(((BaseUnityPlugin)this).Config);
harmony.PatchAll();
Logger.LogInfo((object)"MageArenaItalianVoice loaded!");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "MageArenaItalianVoice";
public const string PLUGIN_NAME = "MageArenaItalianVoice";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace MageArenaItalianVoice.Patches
{
[HarmonyPatch(typeof(SetUpModelProvider), "Setup")]
public static class SetUpModelProviderPatch
{
private static readonly string nameOfModel = "vosk-model-small-it-0.22";
[HarmonyPrefix]
public static bool Prefix(SetUpModelProvider __instance)
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
StreamingAssetsLanguageModelProvider val = ((Component)__instance).gameObject.AddComponent<StreamingAssetsLanguageModelProvider>();
string directoryName = Path.GetDirectoryName(typeof(SetUpModelProviderPatch).Assembly.Location);
string path = Path.Combine(directoryName, "LanguageModels/" + nameOfModel);
val.language = (SystemLanguage)21;
val.languageModels = new List<StreamingAssetsLanguageModel>
{
new StreamingAssetsLanguageModel
{
language = (SystemLanguage)21,
path = path
}
};
SpeechRecognizer component = ((Component)__instance).GetComponent<SpeechRecognizer>();
((SpeechProcessor)component).LanguageModelProvider = (LanguageModelProvider)(object)val;
return false;
}
}
[HarmonyPatch(typeof(VoiceControlListener))]
public static class VoiceControlListenerPatch
{
[CompilerGenerated]
private sealed class <>c__DisplayClass11_0
{
public VoiceControlListener instance;
internal void <ModifiedResetMicLong>b__0(Result res)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
instance.tryresult(res.text);
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass7_0
{
public VoiceControlListener instance;
internal void <ModifiedWaitGetPlayer>b__0(Result res)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
instance.tryresult(res.text);
}
}
[CompilerGenerated]
private sealed class <ModifiedResetMicLong>d__11 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public VoiceControlListener instance;
private <>c__DisplayClass11_0 <>8__1;
private SpeechRecognizer <recognizer>5__2;
private SpeechRecognizer <recognizerNew>5__3;
private MonoBehaviour[] <components>5__4;
private int <i>5__5;
private ISpellCommand <spellCommand>5__6;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ModifiedResetMicLong>d__11(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<recognizer>5__2 = null;
<recognizerNew>5__3 = null;
<components>5__4 = null;
<spellCommand>5__6 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_020b: Unknown result type (might be due to invalid IL or missing references)
//IL_0215: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass11_0();
<>8__1.instance = instance;
<recognizer>5__2 = srRef.Invoke(<>8__1.instance);
((SpeechProcessor)<recognizer>5__2).StopProcessing();
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Object.Destroy((Object)(object)<recognizer>5__2);
srRef.Invoke(<>8__1.instance) = ((Component)<>8__1.instance).gameObject.AddComponent<SpeechRecognizer>();
<recognizerNew>5__3 = srRef.Invoke(<>8__1.instance);
((SpeechProcessor)<recognizerNew>5__3).LanguageModelProvider = (LanguageModelProvider)(object)((Component)<>8__1.instance).GetComponent<StreamingAssetsLanguageModelProvider>();
((SpeechProcessor)<recognizerNew>5__3).SpeechSource = (SpeechSource)(object)((Component)<>8__1.instance).GetComponent<DissonanceSpeechSource>();
<recognizerNew>5__3.Vocabulary = new List<string>();
<>8__1.instance.SpellPages = new List<ISpellCommand>();
<components>5__4 = ((Component)<>8__1.instance).gameObject.GetComponents<MonoBehaviour>();
<i>5__5 = 0;
while (<i>5__5 < <components>5__4.Length)
{
ref ISpellCommand reference = ref <spellCommand>5__6;
MonoBehaviour obj = <components>5__4[<i>5__5];
reference = (ISpellCommand)(object)((obj is ISpellCommand) ? obj : null);
if (<spellCommand>5__6 != null)
{
<>8__1.instance.SpellPages.Add(<spellCommand>5__6);
}
<spellCommand>5__6 = null;
<i>5__5++;
}
addSpellsToVocabulary(<recognizerNew>5__3);
((UnityEvent<Result>)(object)<recognizerNew>5__3.ResultReady).AddListener((UnityAction<Result>)delegate(Result res)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
<>8__1.instance.tryresult(res.text);
});
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
((SpeechProcessor)<recognizerNew>5__3).StartProcessing();
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ModifiedWaitGetPlayer>d__7 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public VoiceControlListener instance;
private <>c__DisplayClass7_0 <>8__1;
private MonoBehaviour[] <components>5__2;
private SpeechRecognizer <recognizer>5__3;
private PlayerInventory <playerInventory>5__4;
private int <i>5__5;
private ISpellCommand <spellCommand>5__6;
private VoiceBroadcastTrigger <vbt>5__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ModifiedWaitGetPlayer>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<components>5__2 = null;
<recognizer>5__3 = null;
<playerInventory>5__4 = null;
<spellCommand>5__6 = null;
<vbt>5__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_023e: Unknown result type (might be due to invalid IL or missing references)
//IL_0248: Expected O, but got Unknown
//IL_027a: Unknown result type (might be due to invalid IL or missing references)
//IL_0284: Expected O, but got Unknown
//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
//IL_02df: Invalid comparison between Unknown and I4
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass7_0();
<>8__1.instance = instance;
goto IL_00d1;
case 1:
<>1__state = -1;
<playerInventory>5__4 = null;
goto IL_00d1;
case 2:
<>1__state = -1;
srRef.Invoke(<>8__1.instance) = ((Component)<>8__1.instance).GetComponent<SpeechRecognizer>();
<>8__1.instance.SpellPages = new List<ISpellCommand>();
<components>5__2 = ((Component)<>8__1.instance).gameObject.GetComponents<MonoBehaviour>();
<i>5__5 = 0;
while (<i>5__5 < <components>5__2.Length)
{
ref ISpellCommand reference = ref <spellCommand>5__6;
MonoBehaviour obj = <components>5__2[<i>5__5];
reference = (ISpellCommand)(object)((obj is ISpellCommand) ? obj : null);
if (<spellCommand>5__6 != null)
{
<>8__1.instance.SpellPages.Add(<spellCommand>5__6);
}
<spellCommand>5__6 = null;
<i>5__5++;
}
<recognizer>5__3 = srRef.Invoke(<>8__1.instance);
addSpellsToVocabulary(<recognizer>5__3);
((UnityEvent<Result>)(object)<recognizer>5__3.ResultReady).AddListener((UnityAction<Result>)delegate(Result res)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
<>8__1.instance.tryresult(res.text);
});
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
((SpeechProcessor)((Component)<>8__1.instance).GetComponent<SpeechRecognizer>()).StartProcessing();
break;
case 4:
{
<>1__state = -1;
<vbt>5__7 = vbtRef.Invoke(<>8__1.instance);
if (!<vbt>5__7.IsTransmitting && (Object)(object)<recognizer>5__3 != (Object)null && (int)((SpeechProcessor)<recognizer>5__3).State > 0)
{
((SpeechProcessor)<recognizer>5__3).StopProcessing();
((MonoBehaviour)<>8__1.instance).StartCoroutine((IEnumerator)restartsrMethod.Invoke(<>8__1.instance, null));
}
<vbt>5__7 = null;
break;
}
IL_00d1:
if ((Object)(object)<>8__1.instance.pi == (Object)null)
{
if ((Object)(object)((Component)Camera.main).transform.parent != (Object)null && ((Component)((Component)Camera.main).transform.parent).TryGetComponent<PlayerInventory>(ref <playerInventory>5__4))
{
<>8__1.instance.pi = <playerInventory>5__4;
}
<>2__current = null;
<>1__state = 1;
return true;
}
((Component)<>8__1.instance).GetComponent<SetUpModelProvider>().Setup();
<>2__current = null;
<>1__state = 2;
return true;
}
if (((Behaviour)<>8__1.instance).isActiveAndEnabled)
{
<>2__current = (object)new WaitForSeconds(30f);
<>1__state = 4;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SafeRestartSr>d__13 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public VoiceControlListener instance;
private SpeechRecognizer <recognizer>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SafeRestartSr>d__13(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<recognizer>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Invalid comparison between Unknown and I4
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<recognizer>5__1 = srRef.Invoke(instance);
if ((Object)(object)<recognizer>5__1 == (Object)null)
{
return false;
}
break;
case 1:
<>1__state = -1;
break;
}
if ((int)((SpeechProcessor)<recognizer>5__1).State > 0)
{
<>2__current = null;
<>1__state = 1;
return true;
}
if ((Object)(object)<recognizer>5__1 != (Object)null)
{
((SpeechProcessor)<recognizer>5__1).StartProcessing();
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static Dictionary<string[], Action<VoiceControlListener>> italianCommandMap;
private static Dictionary<string, string[]> italianAdditionalCommandMap;
private static readonly FieldRef<VoiceControlListener, SpeechRecognizer> srRef = AccessTools.FieldRefAccess<VoiceControlListener, SpeechRecognizer>("sr");
private static readonly FieldRef<VoiceControlListener, VoiceBroadcastTrigger> vbtRef = AccessTools.FieldRefAccess<VoiceControlListener, VoiceBroadcastTrigger>("vbt");
private static readonly MethodInfo restartsrMethod = AccessTools.Method(typeof(VoiceControlListener), "restartsr", (Type[])null, (Type[])null);
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void AwakePostfix(VoiceControlListener __instance)
{
PluginInfo val = ((IEnumerable<PluginInfo>)Chainloader.PluginInfos.Values).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo p) => p.Metadata.GUID == "com.teddi201252.magearenaitalianvoice"));
if (val != null)
{
VoiceCommandConfig.Init(val.Instance.Config);
Dictionary<string[], Action<VoiceControlListener>> dictionary = new Dictionary<string[], Action<VoiceControlListener>>();
dictionary.Add(VoiceCommandConfig.FireballCommand.Value.Split(new char[1] { ' ' }), delegate(VoiceControlListener v)
{
v.CastFireball();
});
dictionary.Add(VoiceCommandConfig.FrostBoltCommand.Value.Split(new char[1] { ' ' }), delegate(VoiceControlListener v)
{
v.CastFrostBolt();
});
dictionary.Add(VoiceCommandConfig.WormCommand.Value.Split(new char[1] { ' ' }), delegate(VoiceControlListener v)
{
v.CastWorm();
});
dictionary.Add(VoiceCommandConfig.HoleCommand.Value.Split(new char[1] { ' ' }), delegate(VoiceControlListener v)
{
v.CastHole();
});
dictionary.Add(VoiceCommandConfig.MagicMissileCommand.Value.Split(new char[1] { ' ' }), delegate(VoiceControlListener v)
{
v.CastMagicMissle();
});
dictionary.Add(VoiceCommandConfig.MirrorCommand.Value.Split(new char[1] { ' ' }), delegate(VoiceControlListener v)
{
v.ActivateMirror();
});
italianCommandMap = dictionary;
Dictionary<string, string[]> dictionary2 = new Dictionary<string, string[]>();
dictionary2.Add("rock", VoiceCommandConfig.RockCommand.Value.Split(new char[1] { ' ' }));
dictionary2.Add("wisp", VoiceCommandConfig.WispCommand.Value.Split(new char[1] { ' ' }));
dictionary2.Add("blast", VoiceCommandConfig.BlastCommand.Value.Split(new char[1] { ' ' }));
dictionary2.Add("divine", VoiceCommandConfig.DivineCommand.Value.Split(new char[1] { ' ' }));
dictionary2.Add("blink", VoiceCommandConfig.BlinkCommand.Value.Split(new char[1] { ' ' }));
dictionary2.Add("thunderbolt", VoiceCommandConfig.ThunderboltCommand.Value.Split(new char[1] { ' ' }));
italianAdditionalCommandMap = dictionary2;
}
}
[HarmonyPatch("waitgetplayer")]
[HarmonyPrefix]
private static bool WaitGetPlayerPrefix(VoiceControlListener __instance, ref IEnumerator __result)
{
__result = ModifiedWaitGetPlayer(__instance);
return false;
}
[IteratorStateMachine(typeof(<ModifiedWaitGetPlayer>d__7))]
private static IEnumerator ModifiedWaitGetPlayer(VoiceControlListener instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ModifiedWaitGetPlayer>d__7(0)
{
instance = instance
};
}
private static void addSpellsToVocabulary(SpeechRecognizer recognizer)
{
foreach (KeyValuePair<string[], Action<VoiceControlListener>> item3 in italianCommandMap)
{
string[] key = item3.Key;
foreach (string item in key)
{
recognizer.Vocabulary.Add(item);
}
}
foreach (KeyValuePair<string, string[]> item4 in italianAdditionalCommandMap)
{
string[] value = item4.Value;
foreach (string item2 in value)
{
recognizer.Vocabulary.Add(item2);
}
}
}
[HarmonyPatch("tryresult")]
[HarmonyPrefix]
private static bool TryResultPrefix(VoiceControlListener __instance, string res)
{
if (res != null)
{
foreach (KeyValuePair<string[], Action<VoiceControlListener>> item in italianCommandMap)
{
if (item.Key.Any((string keyword) => res.Contains(keyword)))
{
item.Value(__instance);
}
}
foreach (KeyValuePair<string, string[]> pair in italianAdditionalCommandMap)
{
if (pair.Value.Any((string keyword) => res.Contains(keyword)))
{
ISpellCommand val = ((IEnumerable<ISpellCommand>)__instance.SpellPages).FirstOrDefault((Func<ISpellCommand, bool>)((ISpellCommand s) => s != null && s.GetSpellName() == pair.Key));
if (val != null)
{
val.TryCastSpell();
}
}
}
((SpeechProcessor)srRef.Invoke(__instance)).StopProcessing();
((MonoBehaviour)__instance).StartCoroutine((IEnumerator)restartsrMethod.Invoke(__instance, null));
}
return false;
}
[HarmonyPatch("resetmiclong")]
[HarmonyPrefix]
private static bool ResetMicLongPrefix(VoiceControlListener __instance, ref IEnumerator __result)
{
__result = ModifiedResetMicLong(__instance);
return false;
}
[IteratorStateMachine(typeof(<ModifiedResetMicLong>d__11))]
private static IEnumerator ModifiedResetMicLong(VoiceControlListener instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ModifiedResetMicLong>d__11(0)
{
instance = instance
};
}
[HarmonyPatch("restartsr")]
[HarmonyPrefix]
private static bool RestartSrPrefix(VoiceControlListener __instance, ref IEnumerator __result)
{
__result = SafeRestartSr(__instance);
return false;
}
[IteratorStateMachine(typeof(<SafeRestartSr>d__13))]
private static IEnumerator SafeRestartSr(VoiceControlListener instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SafeRestartSr>d__13(0)
{
instance = instance
};
}
}
}
namespace MageArenaItalianVoice.Config
{
public static class VoiceCommandConfig
{
public static ConfigEntry<string> FireballCommand;
public static ConfigEntry<string> FrostBoltCommand;
public static ConfigEntry<string> WormCommand;
public static ConfigEntry<string> HoleCommand;
public static ConfigEntry<string> MagicMissileCommand;
public static ConfigEntry<string> MirrorCommand;
public static ConfigEntry<string> RockCommand;
public static ConfigEntry<string> WispCommand;
public static ConfigEntry<string> BlastCommand;
public static ConfigEntry<string> DivineCommand;
public static ConfigEntry<string> BlinkCommand;
public static ConfigEntry<string> ThunderboltCommand;
public static void Init(ConfigFile config)
{
FireballCommand = config.Bind<string>("Commands", "Fireball", "palla infuocata", "Italian command for Fireball spell (tutte le varianti di una parola possono essere separate da uno spazio)");
FrostBoltCommand = config.Bind<string>("Commands", "FrostBolt", "congelati", "Italian command for Frost Bolt spell (tutte le varianti di una parola possono essere separate da uno spazio)");
WormCommand = config.Bind<string>("Commands", "Worm", "buco", "Italian command for Worm spell (tutte le varianti di una parola possono essere separate da uno spazio)");
HoleCommand = config.Bind<string>("Commands", "Hole", "nero", "Italian command for Hole spell (tutte le varianti di una parola possono essere separate da uno spazio)");
MagicMissileCommand = config.Bind<string>("Commands", "MagicMissile", "missile magico", "Italian command for Magic Missile spell (tutte le varianti di una parola possono essere separate da uno spazio)");
MirrorCommand = config.Bind<string>("Commands", "Mirror", "specchio", "Italian command for Mirror spell (tutte le varianti di una parola possono essere separate da uno spazio)");
RockCommand = config.Bind<string>("AdditionalCommands", "Rock", "roccia", "Italian command for Rock spell (tutte le varianti di una parola possono essere separate da uno spazio)");
WispCommand = config.Bind<string>("AdditionalCommands", "Wisp", "spirito", "Italian command for Wisp spell (tutte le varianti di una parola possono essere separate da uno spazio)");
BlastCommand = config.Bind<string>("AdditionalCommands", "Blast", "raggio oscuro", "Italian command for Blast spell (tutte le varianti di una parola possono essere separate da uno spazio)");
DivineCommand = config.Bind<string>("AdditionalCommands", "Divine", "luce divina", "Italian command for Divine spell (tutte le varianti di una parola possono essere separate da uno spazio)");
BlinkCommand = config.Bind<string>("AdditionalCommands", "Blink", "salto", "Italian command for Blink spell (tutte le varianti di una parola possono essere separate da uno spazio)");
ThunderboltCommand = config.Bind<string>("AdditionalCommands", "Thunderbolt", "fulmine", "Italian command for Thunderbolt spell (tutte le varianti di una parola possono essere separate da uno spazio)");
}
}
}
