using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using LethalNetworkAPI;
using LethalNetworkAPI.Utils;
using TerminalApi;
using TerminalApi.Events;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.Video;
using YoutubeDLSharp;
using YoutubeDLSharp.Options;
using YoutubeOnTV.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("YoutubeOnTV")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("YoutubeOnTV")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("637d9e92-bc74-4646-8436-67954c0a9f24")]
[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")]
namespace YoutubeOnTV
{
[BepInPlugin("com.roandegraaf.youtubeontv", "YoutubeOnTV", "0.2.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class YoutubeOnTVBase : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("com.roandegraaf.youtubeontv");
public static YoutubeOnTVBase Instance;
internal ManualLogSource mls;
private static bool initialized;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("YoutubeOnTV");
mls.LogInfo((object)"YoutubeOnTV loaded");
harmony.PatchAll(typeof(YoutubeOnTVBase));
harmony.PatchAll(typeof(TVScriptPatch));
harmony.PatchAll(typeof(TerminalPatch));
RegisterTerminalCommands();
if (!initialized)
{
initialized = true;
SceneManager.sceneLoaded += OnSceneLoaded;
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
if ((Object)(object)VideoManager.Instance == (Object)null)
{
mls.LogInfo((object)("Scene loaded: " + ((Scene)(ref scene)).name + " - initializing managers..."));
GameObject val = new GameObject("YoutubeOnTVManagers");
Object.DontDestroyOnLoad((Object)(object)val);
mls.LogInfo((object)"Adding VideoManager...");
val.AddComponent<VideoManager>();
mls.LogInfo((object)"Adding NetworkHandler...");
val.AddComponent<NetworkHandler>();
mls.LogInfo((object)"All components added successfully!");
}
}
private void RegisterTerminalCommands()
{
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_0131: Expected O, but got Unknown
mls.LogInfo((object)"Registering terminal commands...");
TerminalKeyword val = TerminalApi.CreateTerminalKeyword("tv", true, (TerminalNode)null);
TerminalKeyword val2 = TerminalApi.CreateTerminalKeyword("add", false, (TerminalNode)null);
TerminalKeyword val3 = TerminalApi.CreateTerminalKeyword("clear", false, (TerminalNode)null);
TerminalKeyword val4 = TerminalApi.CreateTerminalKeyword("skip", false, (TerminalNode)null);
TerminalKeyword val5 = TerminalApi.CreateTerminalKeyword("queue", false, (TerminalNode)null);
TerminalNode val6 = TerminalApi.CreateTerminalNode("Video added to queue.\n\n", true, "");
TerminalNode val7 = TerminalApi.CreateTerminalNode("Queue cleared.\n\n", true, "");
TerminalNode val8 = TerminalApi.CreateTerminalNode("Skipped to next video.\n\n", true, "");
TerminalNode val9 = TerminalApi.CreateTerminalNode("Queue status displayed.\n\n", true, "");
TerminalNode specialKeywordResult = TerminalApi.CreateTerminalNode("TV CONTROLS\n===========\nUsage: tv <command> [args]\n\nCommands:\n tv add [url/query] - Add video to queue\n tv clear - Clear video queue\n tv skip - Skip current video\n tv queue - Show queue status\n\n", true, "");
val = TerminalExtenstionMethods.AddCompatibleNoun(val, val2, val6);
val = TerminalExtenstionMethods.AddCompatibleNoun(val, val3, val7);
val = TerminalExtenstionMethods.AddCompatibleNoun(val, val4, val8);
val = TerminalExtenstionMethods.AddCompatibleNoun(val, val5, val9);
val.specialKeywordResult = specialKeywordResult;
val2.defaultVerb = val;
val3.defaultVerb = val;
val4.defaultVerb = val;
val5.defaultVerb = val;
TerminalApi.AddTerminalKeyword(val);
TerminalApi.AddTerminalKeyword(val2);
TerminalApi.AddTerminalKeyword(val3);
TerminalApi.AddTerminalKeyword(val4);
TerminalApi.AddTerminalKeyword(val5);
Events.TerminalParsedSentence += new TerminalParseSentenceEventHandler(OnTerminalParsedSentence);
mls.LogInfo((object)"Terminal commands registered successfully!");
}
private void OnTerminalParsedSentence(object sender, TerminalParseSentenceEventArgs e)
{
string text = e.SubmittedText.Trim().ToLower();
if (!text.StartsWith("tv"))
{
return;
}
mls.LogInfo((object)("Processing TV command: " + e.SubmittedText));
if (text.StartsWith("tv add"))
{
string text2 = "";
if (e.SubmittedText.Length > 7)
{
int num = e.SubmittedText.ToLower().IndexOf("tv add");
if (num != -1)
{
text2 = e.SubmittedText.Substring(num + 7).Trim();
}
}
if (string.IsNullOrEmpty(text2))
{
e.ReturnedNode = TerminalApi.CreateTerminalNode("Usage: tv add [url or search query]\nExample: tv add dQw4w9WgXcQ\nExample: tv add https://youtube.com/watch?v=...\nExample: tv add never gonna give you up\n\n", true, "");
return;
}
if ((Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.RequestAddVideo(text2);
}
e.ReturnedNode = TerminalApi.CreateTerminalNode("Added to queue: " + text2 + "\n" + $"Queue size: {VideoQueue.Count()}\n\n", true, "");
}
else if (text == "tv clear" || text == "clear tv")
{
int num2 = VideoQueue.Count();
if ((Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.RequestClearQueue();
}
e.ReturnedNode = TerminalApi.CreateTerminalNode($"Cleared {num2} video(s) from queue.\n\n", true, "");
}
else if (text == "tv skip" || text == "skip tv")
{
if (VideoQueue.IsEmpty())
{
e.ReturnedNode = TerminalApi.CreateTerminalNode("Queue is empty. Nothing to skip.\n\n", true, "");
return;
}
if ((Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.RequestSkipVideo();
}
e.ReturnedNode = TerminalApi.CreateTerminalNode("Skipped to next video.\n" + $"Queue size: {VideoQueue.Count()}\n\n", true, "");
}
else if (text == "tv queue" || text == "queue tv")
{
int num3 = VideoQueue.Count();
if (num3 == 0)
{
e.ReturnedNode = TerminalApi.CreateTerminalNode("Queue is empty.\n\n", true, "");
}
else
{
e.ReturnedNode = TerminalApi.CreateTerminalNode($"Videos in queue: {num3}\n\n", true, "");
}
}
}
}
public class VideoManager : MonoBehaviour
{
[CompilerGenerated]
private sealed class <SetPlaybackTimeWhenReady>d__32 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public float startTime;
public VideoManager <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SetPlaybackTimeWhenReady>d__32(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)TVController.Instance != (Object)null && !TVController.Instance.videoPlayer.isPrepared)
{
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
}
if ((Object)(object)TVController.Instance != (Object)null)
{
TVController.Instance.videoPlayer.time = startTime;
<>4__this.logger.LogInfo((object)$"Set playback start time to {startTime}s");
}
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 ManualLogSource logger;
private bool skipRequested = false;
private bool hasStartedCurrentVideo = false;
private bool isPlayingFallback = false;
private float lastSyncTime = 0f;
private const float SYNC_INTERVAL = 2f;
public static VideoManager Instance { get; private set; }
public string CurrentVideoUrl { get; private set; }
public bool IsLoadingVideo { get; private set; }
private static string GetFallbackVideoPath()
{
return Path.Combine(Paths.PluginPath, "YoutubeOnTV", "fallback.mp4");
}
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
logger = Logger.CreateLogSource("YoutubeOnTV");
logger.LogInfo((object)"VideoManager initialized!");
}
else
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
private void Start()
{
if (!LNetworkUtils.IsHostOrServer)
{
logger.LogInfo((object)"Client joining - will request TV state from host");
((MonoBehaviour)this).Invoke("RequestTVStateFromHost", 0.5f);
}
}
private void RequestTVStateFromHost()
{
if ((Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.RequestTVState();
}
else
{
logger.LogWarning((object)"NetworkHandler not found, cannot request TV state");
}
}
private void Update()
{
if ((Object)(object)TVController.Instance == (Object)null)
{
return;
}
if (!IsTVOn())
{
if (TVController.Instance.IsPlaying())
{
TVController.Instance.Pause();
}
return;
}
if (LNetworkUtils.IsHostOrServer && !IsLoadingVideo)
{
if (!VideoQueue.IsEmpty())
{
if (isPlayingFallback)
{
logger.LogInfo((object)"Switching from fallback to queue video");
TVController.Instance.Stop();
isPlayingFallback = false;
hasStartedCurrentVideo = false;
}
if (!hasStartedCurrentVideo && !TVController.Instance.IsPlaying())
{
PlayNextFromQueue();
}
}
else if (!isPlayingFallback && !TVController.Instance.IsPlaying())
{
PlayFallbackVideo();
}
}
if (LNetworkUtils.IsHostOrServer && TVController.Instance.IsPlaying() && !isPlayingFallback && Time.time - lastSyncTime >= 2f)
{
lastSyncTime = Time.time;
float time = (float)TVController.Instance.videoPlayer.time;
if ((Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.BroadcastPlaybackTime(time);
}
}
}
public void OnSkipRequested()
{
skipRequested = true;
hasStartedCurrentVideo = false;
isPlayingFallback = false;
if ((Object)(object)TVController.Instance != (Object)null)
{
TVController.Instance.Stop();
}
}
public void PlayNextFromQueue()
{
if (VideoQueue.IsEmpty())
{
logger.LogInfo((object)"Queue is empty, nothing to play");
return;
}
if (IsLoadingVideo)
{
logger.LogInfo((object)"Already loading a video, please wait");
return;
}
string input = VideoQueue.Next();
logger.LogInfo((object)("Loading video from queue: " + input));
IsLoadingVideo = true;
hasStartedCurrentVideo = true;
skipRequested = false;
VideoStreamer.Instance.GetVideoUrl(input, delegate(string resolvedUrl)
{
IsLoadingVideo = false;
if (string.IsNullOrEmpty(resolvedUrl))
{
logger.LogError((object)("Failed to resolve video URL: " + input));
if (VideoQueue.IncrementRetry(input))
{
string text = VideoQueue.RemoveCurrent();
logger.LogError((object)("Removing video from queue after max retries: " + text));
if ((Object)(object)HUDManager.Instance != (Object)null)
{
HUDManager.Instance.DisplayTip("Video Error", "Failed to load video. Removed from queue.", true, false, "LC_Tip1");
}
hasStartedCurrentVideo = false;
if (!VideoQueue.IsEmpty())
{
((MonoBehaviour)this).Invoke("PlayNextFromQueue", 1f);
}
}
else
{
logger.LogInfo((object)"Retrying video after delay...");
hasStartedCurrentVideo = false;
((MonoBehaviour)this).Invoke("PlayNextFromQueue", 3f);
}
}
else
{
VideoQueue.ResetRetry(input);
CurrentVideoUrl = resolvedUrl;
logger.LogInfo((object)"Video URL resolved successfully!");
if ((Object)(object)TVController.Instance != (Object)null)
{
TVController.Instance.PlayVideo(resolvedUrl);
if (LNetworkUtils.IsHostOrServer && (Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.BroadcastPlayVideo(resolvedUrl, 0f);
}
}
else
{
logger.LogError((object)"TVController not found!");
}
}
});
}
public void OnVideoFinished()
{
logger.LogInfo((object)"Video finished playing");
CurrentVideoUrl = null;
hasStartedCurrentVideo = false;
isPlayingFallback = false;
if (!VideoQueue.IsEmpty() && !skipRequested)
{
((MonoBehaviour)this).Invoke("PlayNextFromQueue", 1f);
}
else
{
logger.LogInfo((object)"Queue empty, will return to fallback video");
}
}
public void OnVideoPlaybackError(string errorMessage)
{
logger.LogError((object)("Video playback error: " + errorMessage));
if (VideoQueue.IsEmpty())
{
logger.LogInfo((object)"No videos in queue to retry");
return;
}
string input = VideoQueue.Current();
if (VideoQueue.IncrementRetry(input))
{
string text = VideoQueue.RemoveCurrent();
logger.LogError((object)("Removing video from queue after playback errors: " + text));
hasStartedCurrentVideo = false;
isPlayingFallback = false;
CurrentVideoUrl = null;
IsLoadingVideo = false;
if (!VideoQueue.IsEmpty())
{
((MonoBehaviour)this).Invoke("PlayNextFromQueue", 1f);
}
}
else
{
logger.LogInfo((object)"Retrying video after playback error...");
hasStartedCurrentVideo = false;
isPlayingFallback = false;
CurrentVideoUrl = null;
IsLoadingVideo = false;
((MonoBehaviour)this).Invoke("PlayNextFromQueue", 3f);
}
}
private bool IsTVOn()
{
if ((Object)(object)TVController.Instance == (Object)null)
{
return false;
}
TVScript tVScript = TVController.Instance.GetTVScript();
if ((Object)(object)tVScript == (Object)null)
{
return false;
}
return tVScript.tvOn;
}
private void PlayFallbackVideo()
{
string fallbackVideoPath = GetFallbackVideoPath();
logger.LogInfo((object)("Playing fallback video: " + fallbackVideoPath));
if ((Object)(object)TVController.Instance != (Object)null)
{
TVController.Instance.PlayLocalVideo(fallbackVideoPath);
isPlayingFallback = true;
if (LNetworkUtils.IsHostOrServer && (Object)(object)NetworkHandler.Instance != (Object)null)
{
NetworkHandler.Instance.BroadcastPlayFallback();
}
}
else
{
logger.LogError((object)"Cannot play fallback: TVController not found!");
}
}
public void OnTVPoweredOn()
{
logger.LogInfo((object)"TV powered on - checking what to play");
if ((Object)(object)TVController.Instance != (Object)null && TVController.Instance.IsPaused())
{
logger.LogInfo((object)"Resuming paused video");
TVController.Instance.Resume();
}
else if (!VideoQueue.IsEmpty())
{
logger.LogInfo((object)"Queue has videos, will play from queue");
hasStartedCurrentVideo = false;
}
else
{
logger.LogInfo((object)"Queue is empty, will play fallback");
}
}
public void PlayVideoFromNetwork(string url, float startTime)
{
logger.LogInfo((object)$"Playing video from network: {url} at {startTime}s");
if (LNetworkUtils.IsHostOrServer)
{
return;
}
CurrentVideoUrl = url;
hasStartedCurrentVideo = true;
isPlayingFallback = false;
if ((Object)(object)TVController.Instance != (Object)null)
{
TVController.Instance.PlayVideo(url);
if (startTime > 0f)
{
((MonoBehaviour)this).StartCoroutine(SetPlaybackTimeWhenReady(startTime));
}
}
}
public void SyncPlaybackTime(float time)
{
if (!LNetworkUtils.IsHostOrServer && !((Object)(object)TVController.Instance == (Object)null) && TVController.Instance.IsPlaying())
{
float num = (float)TVController.Instance.videoPlayer.time;
float num2 = Mathf.Abs(num - time);
if (num2 > 1f)
{
logger.LogInfo((object)$"Syncing playback time: {num}s -> {time}s (diff: {num2}s)");
TVController.Instance.videoPlayer.time = time;
}
}
}
[IteratorStateMachine(typeof(<SetPlaybackTimeWhenReady>d__32))]
private IEnumerator SetPlaybackTimeWhenReady(float startTime)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SetPlaybackTimeWhenReady>d__32(0)
{
<>4__this = this,
startTime = startTime
};
}
public void PlayFallbackFromNetwork()
{
logger.LogInfo((object)"Playing fallback from network");
if (!LNetworkUtils.IsHostOrServer)
{
string fallbackVideoPath = GetFallbackVideoPath();
if ((Object)(object)TVController.Instance != (Object)null)
{
TVController.Instance.PlayLocalVideo(fallbackVideoPath);
isPlayingFallback = true;
hasStartedCurrentVideo = false;
CurrentVideoUrl = null;
}
}
}
public TVStateData GetCurrentTVState()
{
TVStateData tVStateData = default(TVStateData);
tVStateData.isTVOn = IsTVOn();
tVStateData.isPlayingFallback = isPlayingFallback;
tVStateData.currentVideoUrl = CurrentVideoUrl;
tVStateData.currentPlaybackTime = 0f;
tVStateData.isPlaying = false;
TVStateData result = tVStateData;
if ((Object)(object)TVController.Instance != (Object)null)
{
result.isPlaying = TVController.Instance.IsPlaying();
if (result.isPlaying && !isPlayingFallback)
{
result.currentPlaybackTime = (float)TVController.Instance.videoPlayer.time;
}
}
logger.LogInfo((object)$"Gathering TV state - TVOn: {result.isTVOn}, Fallback: {result.isPlayingFallback}, Playing: {result.isPlaying}, URL: {result.currentVideoUrl}");
return result;
}
public void ApplyTVStateFromNetwork(TVStateData state)
{
logger.LogInfo((object)$"Applying TV state - TVOn: {state.isTVOn}, Fallback: {state.isPlayingFallback}, URL: {state.currentVideoUrl}");
if (LNetworkUtils.IsHostOrServer)
{
return;
}
if ((Object)(object)TVController.Instance == (Object)null)
{
logger.LogError((object)"Cannot apply TV state: TVController not found!");
return;
}
TVScript tVScript = TVController.Instance.GetTVScript();
if ((Object)(object)tVScript == (Object)null)
{
logger.LogError((object)"Cannot apply TV state: TVScript not found!");
return;
}
if (!state.isTVOn)
{
logger.LogInfo((object)"TV is off, ensuring TV is off and stopping playback");
if (tVScript.tvOn)
{
tVScript.TurnTVOnOff(false);
}
TVController.Instance.Stop();
isPlayingFallback = false;
hasStartedCurrentVideo = false;
CurrentVideoUrl = null;
return;
}
if (!tVScript.tvOn)
{
logger.LogInfo((object)"Turning on TV to sync with host");
tVScript.TurnTVOnOff(true);
}
if (state.isPlayingFallback)
{
logger.LogInfo((object)"Syncing to fallback video");
string fallbackVideoPath = GetFallbackVideoPath();
TVController.Instance.PlayLocalVideo(fallbackVideoPath);
isPlayingFallback = true;
hasStartedCurrentVideo = false;
CurrentVideoUrl = null;
}
else if (!string.IsNullOrEmpty(state.currentVideoUrl))
{
logger.LogInfo((object)$"Syncing to video: {state.currentVideoUrl} at {state.currentPlaybackTime}s");
CurrentVideoUrl = state.currentVideoUrl;
hasStartedCurrentVideo = true;
isPlayingFallback = false;
TVController.Instance.PlayVideo(state.currentVideoUrl);
if (state.currentPlaybackTime > 0f)
{
((MonoBehaviour)this).StartCoroutine(SetPlaybackTimeWhenReady(state.currentPlaybackTime));
}
}
else
{
logger.LogInfo((object)"TV is on but nothing is playing");
TVController.Instance.Stop();
isPlayingFallback = false;
hasStartedCurrentVideo = false;
CurrentVideoUrl = null;
}
}
}
public static class VideoQueue
{
private static readonly List<string> _inputs = new List<string>();
private static readonly Dictionary<string, int> _retryCount = new Dictionary<string, int>();
private static int _ptr = 0;
private const int MAX_RETRIES = 2;
public static void Add(string input)
{
Debug.Log((object)$"[VideoQueue] Add called with: '{input}' (length: {input.Length})");
string text = "";
string text2 = ExtractYouTubeVideoId(input);
if (!string.IsNullOrEmpty(text2))
{
text = "https://www.youtube.com/watch?v=" + text2;
Debug.Log((object)("[VideoQueue] Extracted video ID '" + text2 + "', constructed URL: '" + text + "'"));
}
else if (input.Length == 11 && !input.Contains(" ") && IsValidVideoId(input))
{
text = "https://www.youtube.com/watch?v=" + input;
Debug.Log((object)("[VideoQueue] Detected as video ID, expanded to: '" + text + "'"));
}
else if (input.StartsWith("http://") || input.StartsWith("https://"))
{
text = input;
Debug.Log((object)("[VideoQueue] Detected as URL, adding as-is: '" + text + "'"));
}
else
{
text = "ytsearch:" + input;
Debug.Log((object)("[VideoQueue] Detected as search query, prefixed: '" + text + "'"));
}
_inputs.Add(text);
Debug.Log((object)$"[VideoQueue] Successfully added. Queue size: {_inputs.Count}");
}
private static string ExtractYouTubeVideoId(string input)
{
if (string.IsNullOrEmpty(input))
{
return null;
}
Match match = Regex.Match(input, "[?&]v=([a-zA-Z0-9_-]{11})");
if (match.Success)
{
return match.Groups[1].Value;
}
match = Regex.Match(input, "youtu\\.be/([a-zA-Z0-9_-]{11})");
if (match.Success)
{
return match.Groups[1].Value;
}
match = Regex.Match(input, "youtube\\.com/embed/([a-zA-Z0-9_-]{11})");
if (match.Success)
{
return match.Groups[1].Value;
}
match = Regex.Match(input, "youtube\\.com/v/([a-zA-Z0-9_-]{11})");
if (match.Success)
{
return match.Groups[1].Value;
}
return null;
}
private static bool IsValidVideoId(string input)
{
if (string.IsNullOrEmpty(input) || input.Length != 11)
{
return false;
}
return Regex.IsMatch(input, "^[a-zA-Z0-9_-]{11}$");
}
public static void Clear()
{
_inputs.Clear();
_retryCount.Clear();
_ptr = 0;
}
public static bool IsEmpty()
{
return _inputs.Count == 0;
}
public static string Next()
{
if (_inputs.Count == 0)
{
return null;
}
string result = _inputs[_ptr];
_ptr = (_ptr + 1) % _inputs.Count;
return result;
}
public static string Current()
{
if (_inputs.Count == 0)
{
return null;
}
return _inputs[_ptr];
}
public static void Skip()
{
if (_inputs.Count > 0)
{
_ptr = (_ptr + 1) % _inputs.Count;
}
}
public static int Count()
{
return _inputs.Count;
}
public static bool IncrementRetry(string input)
{
if (!_retryCount.ContainsKey(input))
{
_retryCount[input] = 0;
}
_retryCount[input]++;
Debug.Log((object)$"[VideoQueue] Retry count for '{input}': {_retryCount[input]}/{2}");
return _retryCount[input] >= 2;
}
public static string RemoveCurrent()
{
if (_inputs.Count == 0)
{
return null;
}
string text = _inputs[_ptr];
_inputs.RemoveAt(_ptr);
_retryCount.Remove(text);
if (_inputs.Count > 0)
{
_ptr %= _inputs.Count;
}
else
{
_ptr = 0;
}
Debug.Log((object)$"[VideoQueue] Removed '{text}' from queue. Remaining: {_inputs.Count}");
return text;
}
public static void ResetRetry(string input)
{
if (_retryCount.ContainsKey(input))
{
_retryCount.Remove(input);
Debug.Log((object)("[VideoQueue] Reset retry count for '" + input + "'"));
}
}
}
public class VideoStreamer : MonoBehaviour
{
[CompilerGenerated]
private sealed class <>c__DisplayClass11_0
{
public StringBuilder outputBuilder;
public StringBuilder errorBuilder;
public YoutubeDLProcess ytdlProc;
public string input;
public OptionSet options;
internal void <GetVideoUrlCoroutine>b__0(object o, DataReceivedEventArgs e)
{
if (!string.IsNullOrEmpty(e.Data))
{
outputBuilder.AppendLine(e.Data);
}
}
internal void <GetVideoUrlCoroutine>b__1(object o, DataReceivedEventArgs e)
{
if (!string.IsNullOrEmpty(e.Data))
{
errorBuilder.AppendLine(e.Data);
}
}
internal async Task<int> <GetVideoUrlCoroutine>b__2()
{
return await ytdlProc.RunAsync(new string[1] { input }, options);
}
}
[CompilerGenerated]
private sealed class <GetVideoUrlCoroutine>d__11 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public string input;
public Action<string> onUrlFound;
public VideoStreamer <>4__this;
private <>c__DisplayClass11_0 <>8__1;
private Task<int> <processTask>5__2;
private int <exitCode>5__3;
private string <output>5__4;
private string <error>5__5;
private Exception <ex>5__6;
private string[] <urls>5__7;
private string <videoUrl>5__8;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GetVideoUrlCoroutine>d__11(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<processTask>5__2 = null;
<output>5__4 = null;
<error>5__5 = null;
<ex>5__6 = null;
<urls>5__7 = null;
<videoUrl>5__8 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Expected O, but got Unknown
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass11_0();
<>8__1.input = input;
goto IL_006e;
case 1:
<>1__state = -1;
goto IL_006e;
case 2:
<>1__state = -1;
goto IL_01e6;
case 3:
{
<>1__state = -1;
if (<processTask>5__2.IsFaulted)
{
<>4__this._logger.LogError((object)("yt-dlp process failed: " + <processTask>5__2.Exception?.GetBaseException().Message));
onUrlFound(null);
<>4__this._isResolving = false;
return false;
}
<exitCode>5__3 = <processTask>5__2.Result;
<output>5__4 = <>8__1.outputBuilder.ToString().Trim();
<error>5__5 = <>8__1.errorBuilder.ToString().Trim();
<>4__this._logger.LogInfo((object)$"yt-dlp exit code: {<exitCode>5__3}");
<>4__this._logger.LogInfo((object)$"yt-dlp stdout length: {<output>5__4.Length}");
if (!string.IsNullOrEmpty(<error>5__5))
{
<>4__this._logger.LogInfo((object)$"yt-dlp stderr length: {<error>5__5.Length}");
}
if (<exitCode>5__3 != 0 || string.IsNullOrEmpty(<output>5__4))
{
<>4__this._logger.LogError((object)$"yt-dlp failed (Exit Code: {<exitCode>5__3})");
if (!string.IsNullOrEmpty(<error>5__5))
{
<>4__this._logger.LogError((object)("Error: " + <error>5__5));
}
onUrlFound(null);
}
else
{
<urls>5__7 = <output>5__4.Split(new char[2] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
if (<urls>5__7.Length != 0)
{
<videoUrl>5__8 = <urls>5__7[0].Trim();
<>4__this._logger.LogInfo((object)"Video URL resolved successfully!");
<>4__this._logger.LogInfo((object)("URL: " + <videoUrl>5__8.Substring(0, Math.Min(100, <videoUrl>5__8.Length)) + "..."));
onUrlFound(<videoUrl>5__8);
<videoUrl>5__8 = null;
}
else
{
<>4__this._logger.LogError((object)"yt-dlp returned empty output");
onUrlFound(null);
}
<urls>5__7 = null;
}
<>4__this._isResolving = false;
return false;
}
IL_006e:
if (!<>4__this._isInitialized)
{
<>2__current = null;
<>1__state = 1;
return true;
}
<>4__this._isResolving = true;
<>4__this._logger.LogInfo((object)("Resolving video URL for: " + <>8__1.input));
<>8__1.ytdlProc = new YoutubeDLProcess(<>4__this._ytDlpPath);
<>8__1.outputBuilder = new StringBuilder();
<>8__1.errorBuilder = new StringBuilder();
<>8__1.ytdlProc.OutputReceived += delegate(object o, DataReceivedEventArgs e)
{
if (!string.IsNullOrEmpty(e.Data))
{
<>8__1.outputBuilder.AppendLine(e.Data);
}
};
<>8__1.ytdlProc.ErrorReceived += delegate(object o, DataReceivedEventArgs e)
{
if (!string.IsNullOrEmpty(e.Data))
{
<>8__1.errorBuilder.AppendLine(e.Data);
}
};
<>8__1.options = new OptionSet
{
Format = "18/22/(mp4)[height<=480]/worst",
GetUrl = true
};
<processTask>5__2 = null;
try
{
<processTask>5__2 = Task.Run(async () => await <>8__1.ytdlProc.RunAsync(new string[1] { <>8__1.input }, <>8__1.options));
}
catch (Exception ex)
{
<ex>5__6 = ex;
<>4__this._logger.LogError((object)("Failed to start yt-dlp process: " + <ex>5__6.Message));
onUrlFound(null);
<>4__this._isResolving = false;
return false;
}
goto IL_01e6;
IL_01e6:
if (!<processTask>5__2.IsCompleted)
{
<>2__current = null;
<>1__state = 2;
return true;
}
<>2__current = (object)new WaitForSeconds(0.2f);
<>1__state = 3;
return true;
}
}
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 <InitializeYtDlp>d__9 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public VideoStreamer <>4__this;
private string <dllPath>5__1;
private Task <downloadTask>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitializeYtDlp>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<dllPath>5__1 = null;
<downloadTask>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
}
else
{
<>1__state = -1;
if (File.Exists(<>4__this._ytDlpPath))
{
<>4__this._logger.LogInfo((object)"yt-dlp.exe found at path.");
goto IL_0138;
}
<>4__this._logger.LogInfo((object)"yt-dlp.exe not found. Downloading...");
<dllPath>5__1 = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
<downloadTask>5__2 = Utils.DownloadYtDlp(<dllPath>5__1);
}
if (!<downloadTask>5__2.IsCompleted)
{
<>2__current = null;
<>1__state = 1;
return true;
}
if (<downloadTask>5__2.IsFaulted)
{
<>4__this._logger.LogError((object)("Failed to download yt-dlp.exe: " + <downloadTask>5__2.Exception?.GetBaseException().Message));
<>4__this._isInitialized = false;
return false;
}
<>4__this._logger.LogInfo((object)"yt-dlp.exe downloaded successfully!");
<dllPath>5__1 = null;
<downloadTask>5__2 = null;
goto IL_0138;
IL_0138:
<>4__this._isInitialized = 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();
}
}
private static VideoStreamer _instance;
private string _ytDlpPath;
private bool _isResolving;
private ManualLogSource _logger;
private YoutubeDL _ytdl;
private bool _isInitialized;
public static VideoStreamer Instance
{
get
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
if ((Object)(object)_instance == (Object)null)
{
GameObject val = new GameObject("VideoStreamer");
_instance = val.AddComponent<VideoStreamer>();
Object.DontDestroyOnLoad((Object)(object)val);
}
return _instance;
}
}
private void Awake()
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
_logger = Logger.CreateLogSource("YoutubeOnTV");
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
_ytDlpPath = Path.Combine(directoryName, "yt-dlp.exe");
_logger.LogInfo((object)("VideoStreamer initialized. yt-dlp path: " + _ytDlpPath));
_ytdl = new YoutubeDL((byte)4);
_ytdl.YoutubeDLPath = _ytDlpPath;
_ytdl.OutputFolder = Path.Combine(directoryName, "temp");
((MonoBehaviour)this).StartCoroutine(InitializeYtDlp());
}
[IteratorStateMachine(typeof(<InitializeYtDlp>d__9))]
private IEnumerator InitializeYtDlp()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitializeYtDlp>d__9(0)
{
<>4__this = this
};
}
public void GetVideoUrl(string input, Action<string> onUrlFound)
{
((MonoBehaviour)this).StartCoroutine(GetVideoUrlCoroutine(input, onUrlFound));
}
[IteratorStateMachine(typeof(<GetVideoUrlCoroutine>d__11))]
private IEnumerator GetVideoUrlCoroutine(string input, Action<string> onUrlFound)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GetVideoUrlCoroutine>d__11(0)
{
<>4__this = this,
input = input,
onUrlFound = onUrlFound
};
}
public bool IsResolving()
{
return _isResolving;
}
}
public class NetworkHandler : MonoBehaviour
{
private LNetworkMessage<string> addVideoMessage;
private LNetworkEvent skipVideoEvent;
private LNetworkEvent clearQueueEvent;
private LNetworkMessage<VideoPlayData> playVideoMessage;
private LNetworkMessage<float> syncPlaybackMessage;
private LNetworkEvent playFallbackEvent;
private LNetworkEvent requestTVStateEvent;
private LNetworkMessage<TVStateData> syncTVStateMessage;
public static NetworkHandler Instance { get; private set; }
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
InitializeNetworkMessages();
YoutubeOnTVBase.Instance.mls.LogInfo((object)"NetworkHandler initialized with LethalNetworkAPI!");
}
else
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
private void InitializeNetworkMessages()
{
addVideoMessage = LNetworkMessage<string>.Connect("YoutubeOnTV_AddVideo", (Action<string, ulong>)OnServerReceivedAddVideo, (Action<string>)OnClientReceivedAddVideo, (Action<string, ulong>)null);
skipVideoEvent = LNetworkEvent.Connect("YoutubeOnTV_Skip", (Action<ulong>)OnServerReceivedSkip, (Action)OnClientReceivedSkip, (Action<ulong>)null);
clearQueueEvent = LNetworkEvent.Connect("YoutubeOnTV_Clear", (Action<ulong>)OnServerReceivedClear, (Action)OnClientReceivedClear, (Action<ulong>)null);
playVideoMessage = LNetworkMessage<VideoPlayData>.Connect("YoutubeOnTV_PlayVideo", (Action<VideoPlayData, ulong>)null, (Action<VideoPlayData>)OnClientReceivedPlayVideo, (Action<VideoPlayData, ulong>)null);
syncPlaybackMessage = LNetworkMessage<float>.Connect("YoutubeOnTV_SyncPlayback", (Action<float, ulong>)null, (Action<float>)OnClientReceivedSyncPlayback, (Action<float, ulong>)null);
playFallbackEvent = LNetworkEvent.Connect("YoutubeOnTV_PlayFallback", (Action<ulong>)null, (Action)OnClientReceivedPlayFallback, (Action<ulong>)null);
requestTVStateEvent = LNetworkEvent.Connect("YoutubeOnTV_RequestTVState", (Action<ulong>)OnServerReceivedRequestTVState, (Action)null, (Action<ulong>)null);
syncTVStateMessage = LNetworkMessage<TVStateData>.Connect("YoutubeOnTV_SyncTVState", (Action<TVStateData, ulong>)null, (Action<TVStateData>)OnClientReceivedSyncTVState, (Action<TVStateData, ulong>)null);
YoutubeOnTVBase.Instance.mls.LogInfo((object)"Network messages initialized!");
}
public void RequestAddVideo(string input)
{
if (LNetworkUtils.IsHostOrServer)
{
OnServerReceivedAddVideo(input, 0uL);
}
else
{
addVideoMessage.SendServer(input);
}
}
public void RequestSkipVideo()
{
if (LNetworkUtils.IsHostOrServer)
{
OnServerReceivedSkip(0uL);
}
else
{
skipVideoEvent.InvokeServer();
}
}
public void RequestClearQueue()
{
if (LNetworkUtils.IsHostOrServer)
{
OnServerReceivedClear(0uL);
}
else
{
clearQueueEvent.InvokeServer();
}
}
public void BroadcastPlayVideo(string url, float startTime)
{
if (!LNetworkUtils.IsHostOrServer)
{
YoutubeOnTVBase.Instance.mls.LogWarning((object)"Only host can broadcast play video!");
return;
}
VideoPlayData videoPlayData = default(VideoPlayData);
videoPlayData.url = url;
videoPlayData.startTime = startTime;
VideoPlayData videoPlayData2 = videoPlayData;
playVideoMessage.SendClients(videoPlayData2);
YoutubeOnTVBase.Instance.mls.LogInfo((object)$"Broadcasting play video: {url} at {startTime}s");
}
public void BroadcastPlaybackTime(float time)
{
if (LNetworkUtils.IsHostOrServer)
{
syncPlaybackMessage.SendClients(time);
}
}
public void BroadcastPlayFallback()
{
if (!LNetworkUtils.IsHostOrServer)
{
YoutubeOnTVBase.Instance.mls.LogWarning((object)"Only host can broadcast play fallback!");
return;
}
playFallbackEvent.InvokeClients();
YoutubeOnTVBase.Instance.mls.LogInfo((object)"Broadcasting play fallback");
}
public void RequestTVState()
{
if (LNetworkUtils.IsHostOrServer)
{
YoutubeOnTVBase.Instance.mls.LogWarning((object)"Host doesn't need to request TV state!");
return;
}
requestTVStateEvent.InvokeServer();
YoutubeOnTVBase.Instance.mls.LogInfo((object)"Requesting TV state from host");
}
public void BroadcastTVState(TVStateData state)
{
if (!LNetworkUtils.IsHostOrServer)
{
YoutubeOnTVBase.Instance.mls.LogWarning((object)"Only host can broadcast TV state!");
return;
}
syncTVStateMessage.SendClients(state);
YoutubeOnTVBase.Instance.mls.LogInfo((object)$"Broadcasting TV state - TVOn: {state.isTVOn}, Fallback: {state.isPlayingFallback}, URL: {state.currentVideoUrl}");
}
private void OnServerReceivedAddVideo(string input, ulong clientId)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)("[Host] Received add video request: " + input));
addVideoMessage.SendClients(input);
}
private void OnServerReceivedSkip(ulong clientId)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)"[Host] Received skip request");
skipVideoEvent.InvokeClients();
}
private void OnServerReceivedClear(ulong clientId)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)"[Host] Received clear queue request");
clearQueueEvent.InvokeClients();
}
private void OnServerReceivedRequestTVState(ulong clientId)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)$"[Host] Received TV state request from client {clientId}");
if ((Object)(object)VideoManager.Instance != (Object)null)
{
TVStateData currentTVState = VideoManager.Instance.GetCurrentTVState();
BroadcastTVState(currentTVState);
}
}
private void OnClientReceivedAddVideo(string input)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)("[Client] Adding video to queue: " + input));
VideoQueue.Add(input);
}
private void OnClientReceivedSkip()
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)"[Client] Skipping video");
VideoQueue.Skip();
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.OnSkipRequested();
}
}
private void OnClientReceivedClear()
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)"[Client] Clearing queue");
VideoQueue.Clear();
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.OnSkipRequested();
}
}
private void OnClientReceivedPlayVideo(VideoPlayData data)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)$"[Client] Received play video: {data.url} at {data.startTime}s");
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.PlayVideoFromNetwork(data.url, data.startTime);
}
}
private void OnClientReceivedSyncPlayback(float time)
{
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.SyncPlaybackTime(time);
}
}
private void OnClientReceivedPlayFallback()
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)"[Client] Received play fallback command");
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.PlayFallbackFromNetwork();
}
}
private void OnClientReceivedSyncTVState(TVStateData state)
{
YoutubeOnTVBase.Instance.mls.LogInfo((object)$"[Client] Received TV state - TVOn: {state.isTVOn}, Fallback: {state.isPlayingFallback}, URL: {state.currentVideoUrl}");
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.ApplyTVStateFromNetwork(state);
}
}
}
[Serializable]
public struct VideoPlayData
{
public string url;
public float startTime;
}
[Serializable]
public struct TVStateData
{
public bool isTVOn;
public bool isPlayingFallback;
public string currentVideoUrl;
public float currentPlaybackTime;
public bool isPlaying;
}
public class TVController : MonoBehaviour
{
public VideoPlayer videoPlayer;
private VideoPlayer vanillaVideoPlayer;
private RenderTexture renderTexture;
private AudioSource tvAudioSource;
private TVScript tvScript;
private ManualLogSource logger;
public static TVController Instance { get; private set; }
private void Awake()
{
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Expected O, but got Unknown
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Expected O, but got Unknown
//IL_0230: Unknown result type (might be due to invalid IL or missing references)
//IL_023a: Expected O, but got Unknown
//IL_0248: Unknown result type (might be due to invalid IL or missing references)
//IL_0252: Expected O, but got Unknown
Instance = this;
logger = Logger.CreateLogSource("YoutubeOnTV");
tvScript = ((Component)this).gameObject.GetComponent<TVScript>();
if ((Object)(object)tvScript == (Object)null)
{
logger.LogError((object)"TVScript not found on this GameObject!");
return;
}
tvAudioSource = tvScript.tvSFX;
logger.LogInfo((object)("Found TV AudioSource: " + ((Object)tvAudioSource).name));
vanillaVideoPlayer = tvScript.video;
if ((Object)(object)vanillaVideoPlayer != (Object)null)
{
renderTexture = vanillaVideoPlayer.targetTexture;
logger.LogInfo((object)$"Captured render texture: {((Texture)renderTexture).width}x{((Texture)renderTexture).height}");
vanillaVideoPlayer.Stop();
((Behaviour)vanillaVideoPlayer).enabled = false;
logger.LogInfo((object)"Disabled vanilla VideoPlayer");
}
else
{
logger.LogError((object)"Vanilla VideoPlayer not found!");
}
videoPlayer = ((Component)this).gameObject.AddComponent<VideoPlayer>();
logger.LogInfo((object)"Created custom VideoPlayer");
videoPlayer.playOnAwake = false;
videoPlayer.isLooping = false;
videoPlayer.source = (VideoSource)1;
videoPlayer.skipOnDrop = true;
videoPlayer.controlledAudioTrackCount = 1;
videoPlayer.audioOutputMode = (VideoAudioOutputMode)1;
videoPlayer.SetTargetAudioSource((ushort)0, tvAudioSource);
videoPlayer.targetTexture = renderTexture;
logger.LogInfo((object)"Configured VideoPlayer with TV's render texture");
tvScript.video = videoPlayer;
logger.LogInfo((object)"Replaced TVScript.video with custom VideoPlayer");
videoPlayer.loopPointReached -= new EventHandler(OnVideoEnd);
videoPlayer.loopPointReached += new EventHandler(OnVideoEnd);
videoPlayer.errorReceived -= new ErrorEventHandler(OnVideoError);
videoPlayer.errorReceived += new ErrorEventHandler(OnVideoError);
logger.LogInfo((object)"TVController initialized successfully!");
}
private void OnDestroy()
{
if ((Object)(object)Instance == (Object)(object)this)
{
Instance = null;
}
}
public void PlayVideo(string url)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Expected O, but got Unknown
if (string.IsNullOrEmpty(url))
{
logger.LogError((object)"Cannot play video: URL is null or empty");
return;
}
logger.LogInfo((object)("Playing video: " + url.Substring(0, Math.Min(100, url.Length)) + "..."));
videoPlayer.url = url;
videoPlayer.prepareCompleted -= new EventHandler(OnVideoPrepared);
videoPlayer.prepareCompleted += new EventHandler(OnVideoPrepared);
videoPlayer.Prepare();
}
private void OnVideoPrepared(VideoPlayer vp)
{
logger.LogInfo((object)$"Video prepared! Audio tracks: {vp.audioTrackCount}");
if (vp.audioTrackCount > 0)
{
logger.LogInfo((object)$"Audio channels: {vp.GetAudioChannelCount((ushort)0)}");
}
else
{
logger.LogWarning((object)"Video has NO audio tracks!");
}
logger.LogInfo((object)$"TV AudioSource volume: {tvAudioSource.volume}");
vp.Play();
logger.LogInfo((object)"Video playback started!");
}
public void Stop()
{
if (videoPlayer.isPlaying)
{
videoPlayer.Stop();
logger.LogInfo((object)"Video stopped");
}
}
public void Pause()
{
if (videoPlayer.isPlaying)
{
videoPlayer.Pause();
logger.LogInfo((object)"Video paused");
}
}
public void Resume()
{
if (!videoPlayer.isPlaying && !string.IsNullOrEmpty(videoPlayer.url))
{
videoPlayer.Play();
logger.LogInfo((object)"Video resumed");
}
}
public bool IsPaused()
{
return !videoPlayer.isPlaying && !string.IsNullOrEmpty(videoPlayer.url) && videoPlayer.isPrepared;
}
public bool IsPlaying()
{
return videoPlayer.isPlaying;
}
public void SetLooping(bool shouldLoop)
{
videoPlayer.isLooping = shouldLoop;
logger.LogInfo((object)$"Video looping set to: {shouldLoop}");
}
public void PlayLocalVideo(string filePath, bool shouldLoop = false)
{
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Expected O, but got Unknown
if (string.IsNullOrEmpty(filePath))
{
logger.LogError((object)"Cannot play local video: file path is null or empty");
return;
}
if (!File.Exists(filePath))
{
logger.LogError((object)("Cannot play local video: file not found at " + filePath));
return;
}
logger.LogInfo((object)("Playing local video: " + filePath));
videoPlayer.isLooping = shouldLoop;
videoPlayer.url = "file://" + filePath;
videoPlayer.prepareCompleted -= new EventHandler(OnVideoPrepared);
videoPlayer.prepareCompleted += new EventHandler(OnVideoPrepared);
videoPlayer.Prepare();
}
public TVScript GetTVScript()
{
return tvScript;
}
private void OnVideoEnd(VideoPlayer vp)
{
logger.LogInfo((object)"Video playback completed");
if (!vp.isLooping && (Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.OnVideoFinished();
}
}
private void OnVideoError(VideoPlayer vp, string message)
{
logger.LogError((object)("Video playback error: " + message));
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.OnVideoPlaybackError(message);
}
if ((Object)(object)HUDManager.Instance != (Object)null)
{
HUDManager.Instance.DisplayTip("Video Playback Error", "Failed to play video. Trying next...", true, false, "LC_Tip1");
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "YoutubeOnTV";
public const string PLUGIN_NAME = "";
public const string PLUGIN_VERSION = "1.0.0.0";
}
}
namespace YoutubeOnTV.Patches
{
[HarmonyPatch(typeof(TVScript))]
internal class TVScriptPatch
{
[HarmonyPatch("Update")]
[HarmonyPrefix]
private static bool UpdatePatch(TVScript __instance)
{
if ((Object)(object)((Component)__instance).gameObject.GetComponent<TVController>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<TVController>();
Debug.Log((object)"Attached TVController to TVScript object.");
}
return false;
}
[HarmonyPatch("TurnTVOnOff")]
[HarmonyPrefix]
private static bool TurnTVOnOffPatch(TVScript __instance, bool on)
{
__instance.tvOn = on;
if (on)
{
Debug.Log((object)"TV turned ON - triggering mod video playback");
__instance.tvSFX.PlayOneShot(__instance.switchTVOn);
WalkieTalkie.TransmitOneShotAudio(__instance.tvSFX, __instance.switchTVOn, 1f);
if ((Object)(object)VideoManager.Instance != (Object)null)
{
VideoManager.Instance.OnTVPoweredOn();
}
}
else
{
Debug.Log((object)"TV turned OFF");
__instance.tvSFX.PlayOneShot(__instance.switchTVOff);
WalkieTalkie.TransmitOneShotAudio(__instance.tvSFX, __instance.switchTVOff, 1f);
}
typeof(TVScript).GetMethod("SetTVScreenMaterial", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(__instance, new object[1] { on });
return false;
}
}
[HarmonyPatch(typeof(Terminal))]
internal class TerminalPatch
{
[HarmonyPatch("TextChanged")]
[HarmonyPrefix]
private static bool TextChangedPatch(Terminal __instance, string newText, ref int ___textAdded, ref string ___currentText, ref bool ___modifyingText)
{
if ((Object)(object)__instance.currentNode == (Object)null)
{
return false;
}
if (___modifyingText)
{
___modifyingText = false;
return false;
}
___textAdded += newText.Length - ___currentText.Length;
if (___textAdded < 0)
{
__instance.screenText.text = ___currentText;
___textAdded = 0;
return false;
}
int num = 500;
if (___textAdded > num)
{
__instance.screenText.text = ___currentText;
___textAdded = num;
return false;
}
___currentText = newText;
return false;
}
}
}
