using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using Newtonsoft.Json.Linq;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ChatReadMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ChatReadMod")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fff60788-1a01-4f7f-b42b-cfae325d0334")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
public static class WavUtility
{
private const int HEADER_SIZE = 44;
public static bool Save(string filename, AudioClip clip)
{
if (!filename.ToLower().EndsWith(".wav"))
{
filename += ".wav";
}
string text = Path.Combine(Application.persistentDataPath, filename);
Debug.Log((object)text);
Directory.CreateDirectory(Path.GetDirectoryName(text));
using (FileStream fileStream = CreateEmpty(text))
{
ConvertAndWrite(fileStream, clip);
WriteHeader(fileStream, clip);
}
return true;
}
public static AudioClip TrimSilence(AudioClip clip, float min)
{
float[] array = new float[clip.samples];
clip.GetData(array, 0);
return TrimSilence(new List<float>(array), min, clip.channels, clip.frequency);
}
public static AudioClip TrimSilence(List<float> samples, float min, int channels, int hz)
{
return TrimSilence(samples, min, channels, hz, _3D: false, stream: false);
}
public static AudioClip TrimSilence(List<float> samples, float min, int channels, int hz, bool _3D, bool stream)
{
int i;
for (i = 0; i < samples.Count && !(Mathf.Abs(samples[i]) > min); i++)
{
}
samples.RemoveRange(0, i);
i = samples.Count - 1;
while (i > 0 && !(Mathf.Abs(samples[i]) > min))
{
i--;
}
samples.RemoveRange(i, samples.Count - i);
AudioClip obj = AudioClip.Create("TempClip", samples.Count, channels, hz, _3D, stream);
obj.SetData(samples.ToArray(), 0);
return obj;
}
private static FileStream CreateEmpty(string filepath)
{
FileStream fileStream = new FileStream(filepath, FileMode.Create);
byte value = 0;
for (int i = 0; i < 44; i++)
{
fileStream.WriteByte(value);
}
return fileStream;
}
private static void ConvertAndWrite(FileStream fileStream, AudioClip clip)
{
float[] array = new float[clip.samples];
clip.GetData(array, 0);
short[] array2 = new short[array.Length];
byte[] array3 = new byte[array.Length * 2];
int num = 32767;
for (int i = 0; i < array.Length; i++)
{
array2[i] = (short)(array[i] * (float)num);
_ = new byte[2];
BitConverter.GetBytes(array2[i]).CopyTo(array3, i * 2);
}
fileStream.Write(array3, 0, array3.Length);
}
private static void WriteHeader(FileStream fileStream, AudioClip clip)
{
int frequency = clip.frequency;
int channels = clip.channels;
int samples = clip.samples;
fileStream.Seek(0L, SeekOrigin.Begin);
byte[] bytes = Encoding.UTF8.GetBytes("RIFF");
fileStream.Write(bytes, 0, 4);
byte[] bytes2 = BitConverter.GetBytes(fileStream.Length - 8);
fileStream.Write(bytes2, 0, 4);
byte[] bytes3 = Encoding.UTF8.GetBytes("WAVE");
fileStream.Write(bytes3, 0, 4);
byte[] bytes4 = Encoding.UTF8.GetBytes("fmt ");
fileStream.Write(bytes4, 0, 4);
byte[] bytes5 = BitConverter.GetBytes(16);
fileStream.Write(bytes5, 0, 4);
byte[] bytes6 = BitConverter.GetBytes((ushort)1);
fileStream.Write(bytes6, 0, 2);
byte[] bytes7 = BitConverter.GetBytes(channels);
fileStream.Write(bytes7, 0, 2);
byte[] bytes8 = BitConverter.GetBytes(frequency);
fileStream.Write(bytes8, 0, 4);
byte[] bytes9 = BitConverter.GetBytes(frequency * channels * 2);
fileStream.Write(bytes9, 0, 4);
ushort value = (ushort)(channels * 2);
fileStream.Write(BitConverter.GetBytes(value), 0, 2);
byte[] bytes10 = BitConverter.GetBytes((ushort)16);
fileStream.Write(bytes10, 0, 2);
byte[] bytes11 = Encoding.UTF8.GetBytes("data");
fileStream.Write(bytes11, 0, 4);
byte[] bytes12 = BitConverter.GetBytes(samples * channels * 2);
fileStream.Write(bytes12, 0, 4);
}
public static AudioClip ToAudioClip(byte[] wavFile, int offsetSamples, string name)
{
using MemoryStream input = new MemoryStream(wavFile);
using BinaryReader binaryReader = new BinaryReader(input);
binaryReader.ReadBytes(22);
short num = binaryReader.ReadInt16();
int num2 = binaryReader.ReadInt32();
binaryReader.ReadBytes(6);
short num3 = binaryReader.ReadInt16();
new string(binaryReader.ReadChars(4));
int num4 = binaryReader.ReadInt32() / (num3 / 8);
float[] array = new float[num4];
for (int i = 0; i < num4; i++)
{
short num5 = binaryReader.ReadInt16();
array[i] = (float)num5 / 32768f;
}
AudioClip obj = AudioClip.Create(name, num4 / num, (int)num, num2, false);
obj.SetData(array, 0);
return obj;
}
}
namespace VoicevoxInject;
[BepInPlugin("com.example.voicevox.inject", "ZundamonizedTTS", "1.0.0")]
public class VoicevoxInjectPlugin : BaseUnityPlugin
{
public static VoicevoxInjectPlugin Instance;
public static Sprite GlobalSprite;
public static readonly ConcurrentQueue<Action> ExecutionQueue = new ConcurrentQueue<Action>();
public static ConfigEntry<float> VolumeConfig;
public static ConfigEntry<int> SpeakerIdConfig;
public static ConfigEntry<int> VoicevoxTimeoutSecConfig;
public static ConfigEntry<int> VoicevoxRetryCountConfig;
private void Awake()
{
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
VolumeConfig = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Volume", 1f, "Volume scale for the TTS voice (VOICEVOX volumeScale).");
SpeakerIdConfig = ((BaseUnityPlugin)this).Config.Bind<int>("General", "SpeakerId", 3, "VOICEVOX Speaker ID (3 = Zundamon Normal).");
VoicevoxTimeoutSecConfig = ((BaseUnityPlugin)this).Config.Bind<int>("General", "VoicevoxTimeoutSec", 8, "VOICEVOX request timeout in seconds.");
VoicevoxRetryCountConfig = ((BaseUnityPlugin)this).Config.Bind<int>("General", "VoicevoxRetryCount", 1, "Number of retries on VOICEVOX failure (0 = no retry).");
((BaseUnityPlugin)this).Logger.LogInfo((object)$"ZundamonizedTTS Loaded. Volume: {VolumeConfig.Value}, SpeakerID: {SpeakerIdConfig.Value}, Timeout: {VoicevoxTimeoutSecConfig.Value}s, Retries: {VoicevoxRetryCountConfig.Value}");
new Harmony("com.example.voicevox.inject").PatchAll();
LoadSprite();
}
private void Update()
{
Action result;
while (ExecutionQueue.TryDequeue(out result))
{
try
{
result();
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogError((object)$"Dispatcher Error: {arg}");
}
}
}
public static void Enqueue(Action action)
{
ExecutionQueue.Enqueue(action);
}
private void LoadSprite()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "zundamon.png");
if (File.Exists(path))
{
try
{
byte[] array = File.ReadAllBytes(path);
Texture2D val = new Texture2D(2, 2);
if (ImageConversion.LoadImage(val, array))
{
((Texture)val).filterMode = (FilterMode)1;
GlobalSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
((BaseUnityPlugin)this).Logger.LogInfo((object)"[Voicevox] Image loaded successfully.");
}
return;
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("[Voicevox] Failed to load image: " + ex.Message));
return;
}
}
string path2 = Path.Combine(Paths.PluginPath, "zundamon.png");
if (File.Exists(path2))
{
try
{
byte[] array2 = File.ReadAllBytes(path2);
Texture2D val2 = new Texture2D(2, 2);
if (ImageConversion.LoadImage(val2, array2))
{
((Texture)val2).filterMode = (FilterMode)1;
GlobalSprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f));
((BaseUnityPlugin)this).Logger.LogInfo((object)"[Voicevox] Image loaded from fallback location.");
}
return;
}
catch (Exception ex2)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("[Voicevox] Failed to load fallback image: " + ex2.Message));
return;
}
}
((BaseUnityPlugin)this).Logger.LogWarning((object)"[Voicevox] Image not found. Face feature disabled.");
}
}
public class VoicevoxDispatcher : MonoBehaviour
{
private static VoicevoxDispatcher _instance;
public static void EnsureExists()
{
if (!((Object)(object)_instance != (Object)null) && (Object)(object)HUDManager.Instance != (Object)null)
{
VoicevoxDispatcher component = ((Component)HUDManager.Instance).gameObject.GetComponent<VoicevoxDispatcher>();
if ((Object)(object)component != (Object)null)
{
_instance = component;
}
else
{
_instance = ((Component)HUDManager.Instance).gameObject.AddComponent<VoicevoxDispatcher>();
}
}
}
private void Update()
{
Action result;
while (VoicevoxInjectPlugin.ExecutionQueue.TryDequeue(out result))
{
try
{
result();
}
catch (Exception arg)
{
Debug.LogError((object)$"[Voicevox] Dispatcher Error: {arg}");
}
}
}
}
[HarmonyPatch(typeof(HUDManager), "Update")]
public class DispatcherPatch
{
private static void Postfix()
{
VoicevoxDispatcher.EnsureExists();
}
}
public class ZundamonFaceController : MonoBehaviour
{
[CompilerGenerated]
private sealed class <HideAfter>d__8 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public float duration;
public ZundamonFaceController <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HideAfter>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
int num = <>1__state;
ZundamonFaceController zundamonFaceController = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(duration + 0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)zundamonFaceController._faceObj != (Object)null)
{
zundamonFaceController._faceObj.SetActive(false);
}
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 GameObject _faceObj;
private Coroutine _hideCoroutine;
private PlayerControllerB _ownerPlayer;
private void Awake()
{
_ownerPlayer = ((Component)this).GetComponent<PlayerControllerB>();
}
private void Start()
{
if (!IsLocalPlayer())
{
InitializeFaceObject();
}
}
private bool IsLocalPlayer()
{
if ((Object)(object)_ownerPlayer != (Object)null && (Object)(object)StartOfRound.Instance != (Object)null)
{
return (Object)(object)_ownerPlayer == (Object)(object)StartOfRound.Instance.localPlayerController;
}
return false;
}
private void InitializeFaceObject()
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Expected O, but got Unknown
if (!IsLocalPlayer())
{
Transform val = ((Component)this).transform.Find("ZundamonFace");
if ((Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)((Component)val).gameObject);
}
Transform val2 = FindBoneRecursive(((Component)this).transform, "spine.004");
if ((Object)(object)val2 == (Object)null)
{
val2 = ((Component)this).transform;
}
_faceObj = new GameObject("ZundamonFace");
_faceObj.transform.SetParent(val2);
_faceObj.transform.localPosition = new Vector3(0f, 0.3f, 0.2f);
_faceObj.transform.localRotation = Quaternion.identity;
_faceObj.transform.localScale = Vector3.one * 0.14f;
SpriteRenderer val3 = _faceObj.AddComponent<SpriteRenderer>();
if ((Object)(object)VoicevoxInjectPlugin.GlobalSprite != (Object)null)
{
val3.sprite = VoicevoxInjectPlugin.GlobalSprite;
((Renderer)val3).material = new Material(Shader.Find("Sprites/Default"));
}
_faceObj.SetActive(false);
}
}
public void Show(float duration)
{
if (IsLocalPlayer())
{
return;
}
if ((Object)(object)_faceObj == (Object)null)
{
InitializeFaceObject();
}
if (!((Object)(object)_faceObj == (Object)null))
{
_faceObj.SetActive(true);
if (_hideCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(_hideCoroutine);
}
_hideCoroutine = ((MonoBehaviour)this).StartCoroutine(HideAfter(duration));
}
}
[IteratorStateMachine(typeof(<HideAfter>d__8))]
private IEnumerator HideAfter(float duration)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HideAfter>d__8(0)
{
<>4__this = this,
duration = duration
};
}
private Transform FindBoneRecursive(Transform parent, string boneName)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected O, but got Unknown
if (((Object)parent).name.Equals(boneName))
{
return parent;
}
foreach (Transform item in parent)
{
Transform parent2 = item;
Transform val = FindBoneRecursive(parent2, boneName);
if ((Object)(object)val != (Object)null)
{
return val;
}
}
return null;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Start")]
public class PlayerSetupPatch
{
private static void Postfix(PlayerControllerB __instance)
{
if ((Object)(object)((Component)__instance).gameObject.GetComponent<ZundamonFaceController>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<ZundamonFaceController>();
}
}
}
[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
public class ChatPatch
{
private static void Postfix(HUDManager __instance, string chatMessage, string nameOfUserWhoTyped, int playerWhoSent)
{
HandleChatAsync(__instance, chatMessage, nameOfUserWhoTyped, playerWhoSent);
}
private static async Task HandleChatAsync(HUDManager __instance, string chatMessage, string nameOfUserWhoTyped, int playerWhoSent)
{
using CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(5.0));
_ = 1;
try
{
if ((Object)(object)NetworkManager.Singleton == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null || playerWhoSent == -1)
{
return;
}
PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerWhoSent];
if ((Object)(object)val == (Object)null)
{
return;
}
ulong actualClientId = val.actualClientId;
if (actualClientId == NetworkManager.Singleton.LocalClientId)
{
float[] samples2 = await VoicevoxClient.GenerateVoicePcm(chatMessage, cts.Token);
if (samples2 == null || samples2.Length == 0)
{
return;
}
VoicevoxInjectPlugin.Enqueue(delegate
{
DissonanceInjector.EnqueueAudio(samples2);
HostSpeaker.Play(samples2);
float duration3 = (float)samples2.Length / 48000f;
if (NetworkManager.Singleton.IsServer)
{
HybridNetworkHandler.BroadcastFaceShow(playerWhoSent, duration3);
}
else
{
HybridNetworkHandler.SendFaceRequest(duration3);
}
});
return;
}
if (!NetworkManager.Singleton.IsServer)
{
return;
}
if (ModManager.ModdedClientIds.ContainsKey(actualClientId))
{
VoicevoxInjectPlugin.Enqueue(delegate
{
float duration2 = 2f + (float)chatMessage.Length * 0.1f;
HybridNetworkHandler.BroadcastFaceShow(playerWhoSent, duration2);
});
return;
}
float[] samples = await VoicevoxClient.GenerateVoicePcm(chatMessage, cts.Token);
if (samples == null || samples.Length == 0)
{
return;
}
VoicevoxInjectPlugin.Enqueue(delegate
{
float duration = (float)samples.Length / 48000f;
HybridNetworkHandler.BroadcastFaceShow(playerWhoSent, duration);
DissonanceInjector.EnqueueAudio(samples);
HostSpeaker.Play(samples);
});
}
catch (OperationCanceledException)
{
}
catch (Exception arg)
{
Debug.LogError((object)$"[Voicevox] Chat Error: {arg}");
}
}
}
public static class HybridNetworkHandler
{
private static bool _handlersRegistered;
public static void Register()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && !_handlersRegistered)
{
CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
if (customMessagingManager != null)
{
customMessagingManager.RegisterNamedMessageHandler("VoicevoxFace", new HandleNamedMessageDelegate(ReceiveFaceCommand));
customMessagingManager.RegisterNamedMessageHandler("VoicevoxFaceReq", new HandleNamedMessageDelegate(ReceiveFaceRequest));
_handlersRegistered = true;
}
}
}
public static void Unregister()
{
if ((Object)(object)NetworkManager.Singleton == (Object)null || !_handlersRegistered)
{
return;
}
CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
if (customMessagingManager != null)
{
try
{
customMessagingManager.UnregisterNamedMessageHandler("VoicevoxFace");
customMessagingManager.UnregisterNamedMessageHandler("VoicevoxFaceReq");
}
catch
{
}
}
_handlersRegistered = false;
}
public static void BroadcastFaceShow(int playerId, float duration)
{
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)StartOfRound.Instance != (Object)null && playerId >= 0 && playerId < StartOfRound.Instance.allPlayerScripts.Length)
{
ZundamonFaceController component = ((Component)StartOfRound.Instance.allPlayerScripts[playerId]).GetComponent<ZundamonFaceController>();
if ((Object)(object)component != (Object)null && StartOfRound.Instance.allPlayerScripts[playerId].actualClientId != NetworkManager.Singleton.LocalClientId)
{
component.Show(duration);
}
}
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
foreach (ulong key in ModManager.ModdedClientIds.Keys)
{
if (key != NetworkManager.Singleton.LocalClientId)
{
((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref playerId, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref duration, default(ForPrimitives));
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("VoicevoxFace", key, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
}
}
public static void SendFaceRequest(float duration)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsClient)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref duration, default(ForPrimitives));
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("VoicevoxFaceReq", 0uL, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void ReceiveFaceRequest(ulong sender, FastBufferReader reader)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsServer)
{
return;
}
float duration = default(float);
((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref duration, default(ForPrimitives));
int num = -1;
for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
{
if (StartOfRound.Instance.allPlayerScripts[i].actualClientId == sender)
{
num = i;
break;
}
}
if (num != -1)
{
ModManager.ModdedClientIds.TryAdd(sender, 0);
BroadcastFaceShow(num, duration);
}
}
private static void ReceiveFaceCommand(ulong sender, FastBufferReader reader)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
try
{
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
float duration = default(float);
((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref duration, default(ForPrimitives));
if ((Object)(object)StartOfRound.Instance != (Object)null && num >= 0 && num < StartOfRound.Instance.allPlayerScripts.Length)
{
ZundamonFaceController component = ((Component)StartOfRound.Instance.allPlayerScripts[num]).gameObject.GetComponent<ZundamonFaceController>();
if ((Object)(object)component != (Object)null)
{
component.Show(duration);
}
}
}
catch (Exception ex)
{
Debug.LogError((object)("[Voicevox] FaceCmd Error: " + ex.Message));
}
}
}
[HarmonyPatch]
public class ModManager
{
[CompilerGenerated]
private sealed class <RetryHandshake>d__8 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private int <attempts>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RetryHandshake>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<attempts>5__2 = 0;
break;
case 1:
<>1__state = -1;
break;
}
if (!IsHostModded && <attempts>5__2 < 10)
{
SendHelloToHost();
<attempts>5__2++;
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
}
if (!IsHostModded)
{
Debug.LogWarning((object)"[Voicevox] Handshake failed.");
}
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();
}
}
public static ConcurrentDictionary<ulong, byte> ModdedClientIds = new ConcurrentDictionary<ulong, byte>();
public static bool IsHostModded = false;
private static Coroutine _handshakeCoroutine;
[HarmonyPatch(typeof(StartOfRound), "Awake")]
[HarmonyPostfix]
private static void Initialize()
{
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Expected O, but got Unknown
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
ModdedClientIds.Clear();
IsHostModded = false;
HybridNetworkHandler.Register();
if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.IsServer)
{
NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("VoicevoxHello", new HandleNamedMessageDelegate(OnHelloReceived));
}
else if ((Object)(object)NetworkManager.Singleton != (Object)null)
{
NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("VoicevoxWelcome", new HandleNamedMessageDelegate(OnWelcomeReceived));
}
}
[HarmonyPatch(typeof(StartOfRound), "OnDestroy")]
[HarmonyPostfix]
private static void OnDestroyCleanup()
{
HybridNetworkHandler.Unregister();
if (_handshakeCoroutine != null && (Object)(object)StartOfRound.Instance != (Object)null)
{
StopCoroutine(_handshakeCoroutine);
}
try
{
if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.CustomMessagingManager != null)
{
NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler("VoicevoxHello");
NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler("VoicevoxWelcome");
}
}
catch
{
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Start")]
[HarmonyPostfix]
private static void OnPlayerStart(PlayerControllerB __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && ((NetworkBehaviour)__instance).IsClient && !((NetworkBehaviour)__instance).IsServer)
{
if (_handshakeCoroutine != null)
{
StopCoroutine(_handshakeCoroutine);
}
_handshakeCoroutine = StartCoroutine(RetryHandshake());
}
}
private static Coroutine StartCoroutine(IEnumerator routine)
{
if ((Object)(object)StartOfRound.Instance != (Object)null)
{
return ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(routine);
}
return null;
}
private static void StopCoroutine(Coroutine routine)
{
if ((Object)(object)StartOfRound.Instance != (Object)null)
{
((MonoBehaviour)StartOfRound.Instance).StopCoroutine(routine);
}
}
[IteratorStateMachine(typeof(<RetryHandshake>d__8))]
private static IEnumerator RetryHandshake()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RetryHandshake>d__8(0);
}
private static void SendHelloToHost()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(0, (Allocator)2, -1);
try
{
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("VoicevoxHello", 0uL, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void OnHelloReceived(ulong senderClientId, FastBufferReader reader)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsServer)
{
return;
}
ModdedClientIds.TryAdd(senderClientId, 0);
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(0, (Allocator)2, -1);
try
{
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("VoicevoxWelcome", senderClientId, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void OnWelcomeReceived(ulong senderClientId, FastBufferReader reader)
{
IsHostModded = true;
Debug.Log((object)"[Voicevox] Welcome received.");
}
}
[HarmonyPatch]
public class CreditHandler
{
[CompilerGenerated]
private sealed class <ShowCreditWithDelay>d__3 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ShowCreditWithDelay>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(3f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)HUDManager.Instance != (Object)null)
{
HUDManager.Instance.AddTextToChatOnServer("<color=#52e052>[System] VOICEVOX:Zundamon is working for the company.(1.0.0)</color>", -1);
}
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 const string CreditText = "<color=#52e052>[System] VOICEVOX:Zundamon is working for the company.(1.0.0)</color>";
[HarmonyPatch(typeof(StartOfRound), "SceneManager_OnLoadComplete1")]
[HarmonyPostfix]
private static void OnSceneLoaded()
{
if (NetworkManager.Singleton.IsServer)
{
((MonoBehaviour)StartOfRound.Instance).StartCoroutine(ShowCreditWithDelay());
}
}
[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
[HarmonyPostfix]
private static void OnPlayerJoin()
{
if (NetworkManager.Singleton.IsServer)
{
((MonoBehaviour)StartOfRound.Instance).StartCoroutine(ShowCreditWithDelay());
}
}
[IteratorStateMachine(typeof(<ShowCreditWithDelay>d__3))]
private static IEnumerator ShowCreditWithDelay()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ShowCreditWithDelay>d__3(0);
}
}
public class HostSpeaker : MonoBehaviour
{
private static HostSpeaker _instance;
private AudioSource _source;
public static void Play(float[] samples)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
if ((Object)(object)_instance == (Object)null)
{
GameObject val = new GameObject("VoicevoxHostSpeaker");
Object.DontDestroyOnLoad((Object)val);
_instance = val.AddComponent<HostSpeaker>();
_instance.Initialize();
}
_instance.PlayInternal(samples);
}
private void Initialize()
{
_source = ((Component)this).gameObject.AddComponent<AudioSource>();
_source.spatialBlend = 0f;
_source.volume = 1f;
}
private void PlayInternal(float[] samples)
{
if (!((Object)(object)_source == (Object)null))
{
AudioClip val = AudioClip.Create("HostVoice", samples.Length, 1, 48000, false);
val.SetData(samples, 0);
_source.PlayOneShot(val);
}
}
}
public class DissonanceInjector : MonoBehaviour
{
private static DissonanceInjector _instance;
private static Queue<float[]> _chunkQueue = new Queue<float[]>();
private static object _queueLock = new object();
private float[] _currentChunk;
private int _currentChunkOffset;
private static object _micCaptureObject;
private static MethodInfo _consumeMethod;
private float _timeAccumulator;
public static void EnqueueAudio(float[] samples)
{
if ((Object)(object)_instance == (Object)null)
{
StartOfRound val = Object.FindObjectOfType<StartOfRound>();
if ((Object)(object)val != (Object)null)
{
_instance = ((Component)val).gameObject.AddComponent<DissonanceInjector>();
_instance.Initialize();
}
}
int num;
for (int i = 0; i < samples.Length; i += num)
{
num = Math.Min(4800, samples.Length - i);
float[] array = new float[num];
Array.Copy(samples, i, array, 0, num);
lock (_queueLock)
{
_chunkQueue.Enqueue(array);
}
}
}
private void Initialize()
{
DissonanceComms val = Object.FindObjectOfType<DissonanceComms>();
if ((Object)(object)val == (Object)null)
{
return;
}
PropertyInfo property = ((object)val).GetType().GetProperty("MicrophoneCapture", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
_micCaptureObject = property.GetValue(val);
if (_micCaptureObject != null)
{
_consumeMethod = _micCaptureObject.GetType().GetMethod("ConsumeSamples", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
}
}
private void Update()
{
if (_micCaptureObject != null)
{
_timeAccumulator += Time.deltaTime;
int num = 0;
while (_timeAccumulator >= 0.02f && num < 5)
{
PushFrame();
_timeAccumulator -= 0.02f;
num++;
}
if (_timeAccumulator > 0.5f)
{
_timeAccumulator = 0f;
}
}
}
private void PushFrame()
{
float[] array = new float[960];
int num = 0;
lock (_queueLock)
{
while (num < 960)
{
if (_currentChunk == null)
{
if (_chunkQueue.Count <= 0)
{
break;
}
_currentChunk = _chunkQueue.Dequeue();
_currentChunkOffset = 0;
}
int num2 = Math.Min(_currentChunk.Length - _currentChunkOffset, 960 - num);
Array.Copy(_currentChunk, _currentChunkOffset, array, num, num2);
num += num2;
_currentChunkOffset += num2;
if (_currentChunkOffset >= _currentChunk.Length)
{
_currentChunk = null;
_currentChunkOffset = 0;
}
}
}
if (num > 0 && _consumeMethod != null)
{
if (num < 960)
{
Array.Clear(array, num, 960 - num);
}
ArraySegment<float> arraySegment = new ArraySegment<float>(array);
_consumeMethod.Invoke(_micCaptureObject, new object[1] { arraySegment });
}
}
}
public static class VoicevoxClient
{
private static readonly HttpClient client = new HttpClient();
public static async Task<float[]> GenerateVoicePcm(string text, CancellationToken token)
{
_ = 4;
try
{
int speakerId = VoicevoxInjectPlugin.SpeakerIdConfig.Value;
int timeoutSec = VoicevoxInjectPlugin.VoicevoxTimeoutSecConfig.Value;
int num = Math.Max(0, VoicevoxInjectPlugin.VoicevoxRetryCountConfig.Value);
int attempt = 0;
int maxAttempts = num + 1;
int backoffMs = 300;
while (attempt < maxAttempts)
{
attempt++;
using (CancellationTokenSource ctsTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(timeoutSec)))
{
using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(ctsTimeout.Token, token);
CancellationToken linkedToken = linkedCts.Token;
try
{
HttpResponseMessage val = await client.PostAsync($"http://localhost:50021/audio_query?text={Uri.EscapeDataString(text)}&speaker={speakerId}", (HttpContent)null, linkedToken);
if (!val.IsSuccessStatusCode)
{
throw new HttpRequestException($"audio_query status {(int)val.StatusCode}");
}
JObject obj = JObject.Parse(await val.Content.ReadAsStringAsync());
obj["volumeScale"] = JToken.op_Implicit(VoicevoxInjectPlugin.VolumeConfig.Value);
StringContent val2 = new StringContent(((object)obj).ToString(), Encoding.UTF8, "application/json");
HttpResponseMessage val3 = await client.PostAsync($"http://localhost:50021/synthesis?speaker={speakerId}", (HttpContent)(object)val2, linkedToken);
if (!val3.IsSuccessStatusCode)
{
throw new HttpRequestException($"synthesis status {(int)val3.StatusCode}");
}
float[] array = ConvertWavTo48kMono(await val3.Content.ReadAsByteArrayAsync());
if (array == null || array.Length == 0)
{
return new float[0];
}
return array;
}
catch (OperationCanceledException)
{
if (token != default(CancellationToken) && token.IsCancellationRequested)
{
throw;
}
Debug.LogWarning((object)$"[Voicevox] Generation attempt {attempt} timed out after {timeoutSec}s.");
}
catch (Exception ex2)
{
Debug.LogWarning((object)$"[Voicevox] Generation attempt {attempt} failed: {ex2.Message}");
}
}
if (attempt < maxAttempts)
{
await Task.Delay(backoffMs);
backoffMs *= 2;
}
}
Debug.LogError((object)"[Voicevox] All attempts to generate voice failed.");
return null;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex4)
{
Debug.LogError((object)("[Voicevox] Gen Error: " + ex4.Message));
return null;
}
}
private static float[] ConvertWavTo48kMono(byte[] wavData)
{
if (wavData == null || wavData.Length < 44)
{
return new float[0];
}
try
{
int num = BitConverter.ToInt16(wavData, 22);
int num2 = BitConverter.ToInt32(wavData, 24);
int num3 = -1;
for (int i = 12; i < wavData.Length - 4; i++)
{
if (wavData[i] == 100 && wavData[i + 1] == 97 && wavData[i + 2] == 116 && wavData[i + 3] == 97)
{
num3 = i;
break;
}
}
if (num3 == -1)
{
num3 = 36;
}
int num4 = num3 + 8;
int num5 = wavData.Length - num4;
if (num5 <= 0)
{
return new float[0];
}
int num6 = num5 / 2;
float[] array = new float[num6];
for (int j = 0; j < num6; j++)
{
short num7 = BitConverter.ToInt16(wavData, num4 + j * 2);
array[j] = (float)num7 / 32768f;
}
float[] array2;
if (num == 2)
{
array2 = new float[num6 / 2];
for (int k = 0; k < array2.Length; k++)
{
array2[k] = (array[k * 2] + array[k * 2 + 1]) * 0.5f;
}
}
else
{
array2 = array;
}
if (num2 == 48000)
{
return array2;
}
float num8 = (float)num2 / 48000f;
int num9 = (int)((float)array2.Length / num8);
float[] array3 = new float[num9];
for (int l = 0; l < num9; l++)
{
float num10 = (float)l * num8;
int num11 = (int)num10;
if (num11 < array2.Length - 1)
{
array3[l] = Mathf.Lerp(array2[num11], array2[num11 + 1], num10 - (float)num11);
}
else if (num11 < array2.Length)
{
array3[l] = array2[num11];
}
}
return array3;
}
catch (Exception ex)
{
Debug.LogError((object)("[Voicevox] WAV Parse Error: " + ex.Message));
return new float[0];
}
}
}
