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 Configgy;
using HarmonyLib;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
public class CarouselBase : MonoBehaviour
{
[CompilerGenerated]
private sealed class <MonitorTextToCheck>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public CarouselBase <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MonitorTextToCheck>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
CarouselBase carouselBase = <>4__this;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
}
else
{
<>1__state = -1;
}
bool flag = carouselBase.hoofTV.currentSeason == 3;
if (flag != carouselBase.halfModeActive)
{
carouselBase.halfModeActive = flag;
if (carouselBase.halfModeActive)
{
carouselBase.currentOptions = carouselBase.fullOptions.Take(carouselBase.fullOptions.Length / 2).ToArray();
}
else
{
carouselBase.currentOptions = carouselBase.fullOptions;
}
if (carouselBase.currentOptions.Length == 0)
{
carouselBase.currentIndex = 0;
carouselBase.selectedText.text = "Nothing here!";
}
else
{
carouselBase.currentIndex = Mathf.Clamp(carouselBase.currentIndex, 0, carouselBase.currentOptions.Length - 1);
carouselBase.selectedText.text = carouselBase.currentOptions[carouselBase.currentIndex];
}
carouselBase.UpdateText();
}
<>2__current = null;
<>1__state = 1;
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();
}
}
[Header("UI Elements")]
[SerializeField]
private TMP_Text selectedText;
[SerializeField]
private Button leftArrow;
[SerializeField]
private Button rightArrow;
[Header("Options")]
[SerializeField]
private string[] options;
[Header("Half Mode Settings (Optional)")]
[SerializeField]
private bool enableHalfModeBehavior;
[SerializeField]
private TMP_Text textToCheck;
[SerializeField]
private HoofTVBase hoofTV;
private string[] fullOptions;
private string[] currentOptions;
private int currentIndex;
private bool halfModeActive;
private Coroutine monitorRoutine;
private void OnEnable()
{
if (enableHalfModeBehavior && monitorRoutine == null)
{
monitorRoutine = ((MonoBehaviour)this).StartCoroutine(MonitorTextToCheck());
}
}
private void OnDisable()
{
if (monitorRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(monitorRoutine);
monitorRoutine = null;
}
}
private void Awake()
{
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Expected O, but got Unknown
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Expected O, but got Unknown
if ((Object)(object)leftArrow == (Object)null || (Object)(object)rightArrow == (Object)null || (Object)(object)selectedText == (Object)null)
{
Debug.LogError((object)"CarouselBase: Missing UI elements! Drag them in the Inspector.");
((Behaviour)this).enabled = false;
return;
}
if (enableHalfModeBehavior && (Object)(object)textToCheck == (Object)null)
{
Debug.LogError((object)"CarouselBase: Half Mode enabled but textToCheck is not assigned.");
((Behaviour)this).enabled = false;
return;
}
if (options == null || options.Length == 0)
{
Debug.LogWarning((object)"CarouselBase: No options set in the Inspector!");
fullOptions = new string[0];
}
else
{
fullOptions = options;
}
currentOptions = fullOptions;
((UnityEventBase)leftArrow.onClick).RemoveAllListeners();
((UnityEventBase)rightArrow.onClick).RemoveAllListeners();
((UnityEvent)leftArrow.onClick).AddListener(new UnityAction(GoLeft));
((UnityEvent)rightArrow.onClick).AddListener(new UnityAction(GoRight));
UpdateText();
if (enableHalfModeBehavior)
{
((MonoBehaviour)this).StartCoroutine(MonitorTextToCheck());
}
}
[IteratorStateMachine(typeof(<MonitorTextToCheck>d__15))]
private IEnumerator MonitorTextToCheck()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MonitorTextToCheck>d__15(0)
{
<>4__this = this
};
}
public void GoLeft()
{
if (currentOptions == null || currentOptions.Length == 0)
{
Debug.LogWarning((object)"CarouselBase: No options to scroll through!");
return;
}
currentIndex--;
if (currentIndex < 0)
{
currentIndex = currentOptions.Length - 1;
}
UpdateText();
}
public void GoRight()
{
if (currentOptions == null || currentOptions.Length == 0)
{
Debug.LogWarning((object)"CarouselBase: No options to scroll through!");
return;
}
currentIndex++;
if (currentIndex >= currentOptions.Length)
{
currentIndex = 0;
}
UpdateText();
}
private void UpdateText()
{
if (currentOptions == null || currentOptions.Length == 0)
{
selectedText.text = "Nothing here!";
}
else
{
selectedText.text = currentOptions[currentIndex];
}
}
}
public class HoofTVBase : MonoBehaviour
{
public enum ResolutionOption
{
R480p = 480,
R720p = 720,
R1080p = 1080
}
[CompilerGenerated]
private sealed class <DownloadVideoCoroutine>d__38 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string downloadUrl;
public string localPath;
public HoofTVBase <>4__this;
private UnityWebRequest <request>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DownloadVideoCoroutine>d__38(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<request>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Expected O, but got Unknown
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Invalid comparison between Unknown and I4
bool result;
try
{
int num = <>1__state;
HoofTVBase hoofTVBase = <>4__this;
switch (num)
{
default:
result = false;
break;
case 0:
<>1__state = -1;
Debug.Log((object)("HoofTV: Starting download from " + downloadUrl + " to " + localPath));
if ((Object)(object)hoofTVBase.downloadingObj != (Object)null)
{
hoofTVBase.downloadingObj.SetActive(true);
}
<request>5__2 = UnityWebRequest.Get(downloadUrl);
<>1__state = -3;
<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerFile(localPath);
<>2__current = <request>5__2.SendWebRequest();
<>1__state = 1;
result = true;
break;
case 1:
<>1__state = -3;
if ((int)<request>5__2.result != 1)
{
Debug.LogError((object)("HoofTV: Download failed: " + <request>5__2.error));
if ((Object)(object)hoofTVBase.downloadingObj != (Object)null)
{
hoofTVBase.downloadingObj.SetActive(false);
}
hoofTVBase.isPreparingVideo = false;
hoofTVBase.AttemptRetryOrFallback();
result = false;
<>m__Finally1();
}
else
{
Debug.Log((object)$"HoofTV: Download completed. File size: {new FileInfo(localPath).Length} bytes");
hoofTVBase.PlayVideoFromFile(localPath);
<>m__Finally1();
<request>5__2 = null;
result = false;
}
break;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
return result;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<request>5__2 != null)
{
((IDisposable)<request>5__2).Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <RetryAfterDelay>d__35 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public float delaySeconds;
public string url;
public HoofTVBase <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RetryAfterDelay>d__35(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
int num = <>1__state;
HoofTVBase hoofTVBase = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delaySeconds);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!string.IsNullOrEmpty(url))
{
hoofTVBase.PlayVideo(url);
}
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();
}
}
[Header("UI Elements")]
[SerializeField]
private TMP_Text seasonLabel;
[SerializeField]
private TMP_Text episodeLabel;
[SerializeField]
private Canvas canvas;
[Header("Screen & Video")]
[SerializeField]
private GameObject screenToEnable;
[SerializeField]
private GameObject warningText;
[SerializeField]
private GameObject errorObj;
[SerializeField]
private GameObject downloadingObj;
[SerializeField]
private TMP_Text errorText;
[Header("Control Buttons (Hidden initially)")]
[SerializeField]
private Button startButton;
[SerializeField]
private Button stopButton;
[SerializeField]
private Button pauseButton;
[SerializeField]
private Button resumeButton;
[Header("Audio")]
[SerializeField]
private AudioMixerGroup audioOutputGroup;
[Header("Render Texture")]
[SerializeField]
private RenderTexture targetRenderTexture;
[Header("Playback Settings")]
[SerializeField]
private int maxRetries = 3;
[SerializeField]
private float prepareTimeoutSeconds = 30f;
[Configgable("Video Config", null, 0, null)]
private static ConfigToggle DownloadVideoBeforePlaying = new ConfigToggle(false);
[Configgable("Video Config", null, 0, null)]
private static ConfigLabel DownloadVideoWarningLabel = new ConfigLabel("WARNING: This makes video loading slow (around 130mb per video) while also being at a lower quality. Use ONLY if you have issues with how videos are streamed by default!", 55f);
private VideoPlayer videoPlayer;
private AudioSource audioSource;
private ResolutionOption currentResolution = ResolutionOption.R720p;
private bool isMeantToBePaused;
private double pausedTimestamp;
public int currentSeason;
public int currentEpisode;
private int currentRetryCount;
private float prepareStartTime;
private bool isPreparingVideo;
private string pendingVideoUrl = "";
private string videoCachePath = "";
private void Update()
{
if (!((Object)(object)videoPlayer == (Object)null))
{
if (isMeantToBePaused)
{
videoPlayer.Pause();
videoPlayer.time = pausedTimestamp;
}
TMP_Text obj = seasonLabel;
currentSeason = ParseLabelNumber(((obj != null) ? obj.text : null) ?? "");
TMP_Text obj2 = episodeLabel;
currentEpisode = ParseLabelNumber(((obj2 != null) ? obj2.text : null) ?? "");
if (isPreparingVideo && Time.time - prepareStartTime > prepareTimeoutSeconds)
{
Debug.LogWarning((object)$"HoofTV: Preparation timeout after {prepareTimeoutSeconds}s. Attempting retry...");
isPreparingVideo = false;
AttemptRetryOrFallback();
}
}
}
private void Awake()
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected O, but got Unknown
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Expected O, but got Unknown
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Expected O, but got Unknown
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: Expected O, but got Unknown
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: 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
videoCachePath = Path.Combine(Path.GetTempPath(), "hooftv-cache.mp4");
if ((Object)(object)startButton != (Object)null)
{
((UnityEvent)startButton.onClick).AddListener(new UnityAction(OnStartClicked));
}
if ((Object)(object)stopButton != (Object)null)
{
((UnityEvent)stopButton.onClick).AddListener(new UnityAction(OnStopClicked));
((Component)stopButton).gameObject.SetActive(false);
}
if ((Object)(object)pauseButton != (Object)null)
{
((UnityEvent)pauseButton.onClick).AddListener(new UnityAction(OnPauseClicked));
((Component)pauseButton).gameObject.SetActive(false);
}
if ((Object)(object)resumeButton != (Object)null)
{
((UnityEvent)resumeButton.onClick).AddListener(new UnityAction(OnResumeClicked));
((Component)resumeButton).gameObject.SetActive(false);
}
if ((Object)(object)canvas != (Object)null)
{
canvas.worldCamera = Camera.main;
}
videoPlayer = ((Component)this).gameObject.AddComponent<VideoPlayer>();
videoPlayer.playOnAwake = false;
videoPlayer.renderMode = (VideoRenderMode)2;
videoPlayer.audioOutputMode = (VideoAudioOutputMode)1;
videoPlayer.source = (VideoSource)1;
videoPlayer.waitForFirstFrame = true;
videoPlayer.skipOnDrop = true;
audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
if ((Object)(object)audioOutputGroup != (Object)null)
{
audioSource.outputAudioMixerGroup = audioOutputGroup;
}
videoPlayer.SetTargetAudioSource((ushort)0, audioSource);
audioSource.spatialBlend = 1f;
audioSource.rolloffMode = (AudioRolloffMode)0;
audioSource.minDistance = 2f;
audioSource.maxDistance = 350f;
audioSource.spread = 180f;
videoPlayer.loopPointReached += new EventHandler(OnVideoEnd);
videoPlayer.prepareCompleted += new EventHandler(OnPrepareCompleted);
videoPlayer.errorReceived += new ErrorEventHandler(OnVideoError);
if ((Object)(object)screenToEnable != (Object)null)
{
screenToEnable.SetActive(false);
}
EnsureRenderTexture((int)currentResolution);
}
private void EnsureRenderTexture(int verticalResolution)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
int num = verticalResolution * 16 / 9;
if ((Object)(object)targetRenderTexture == (Object)null)
{
targetRenderTexture = new RenderTexture(num, verticalResolution, 0)
{
name = $"HoofTV_RT_{verticalResolution}p"
};
targetRenderTexture.Create();
Debug.Log((object)$"HoofTV: Created RenderTexture {((Object)targetRenderTexture).name} ({num}x{verticalResolution})");
}
else if (((Texture)targetRenderTexture).width != num || ((Texture)targetRenderTexture).height != verticalResolution)
{
Debug.Log((object)$"HoofTV: Recreating RenderTexture. Old: {((Texture)targetRenderTexture).width}x{((Texture)targetRenderTexture).height} -> New: {num}x{verticalResolution}");
videoPlayer.targetTexture = null;
targetRenderTexture.Release();
((Texture)targetRenderTexture).width = num;
((Texture)targetRenderTexture).height = verticalResolution;
targetRenderTexture.Create();
}
videoPlayer.targetTexture = targetRenderTexture;
if ((Object)(object)screenToEnable != (Object)null)
{
Renderer component = screenToEnable.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
component.material.mainTexture = (Texture)(object)targetRenderTexture;
}
}
}
private void AttemptRetryOrFallback()
{
if (currentRetryCount < maxRetries)
{
currentRetryCount++;
float num = Mathf.Pow(2f, (float)(currentRetryCount - 1));
Debug.Log((object)$"HoofTV: Retry attempt {currentRetryCount}/{maxRetries} in {num}s");
((MonoBehaviour)this).StartCoroutine(RetryAfterDelay(num, pendingVideoUrl));
return;
}
ResolutionOption lowerResolution = GetLowerResolution(currentResolution);
if (lowerResolution != currentResolution)
{
Debug.Log((object)$"HoofTV: Fallback to lower resolution: {(int)lowerResolution}p");
currentResolution = lowerResolution;
currentRetryCount = 0;
TMP_Text obj = seasonLabel;
int season = ParseLabelNumber(((obj != null) ? obj.text : null) ?? "");
TMP_Text obj2 = episodeLabel;
int episode = ParseLabelNumber(((obj2 != null) ? obj2.text : null) ?? "");
string url = GenerateUrl(season, episode, (int)currentResolution);
PlayVideo(url);
}
else
{
ShowError("Unable to load video after all retry attempts and fallback resolutions.");
}
}
[IteratorStateMachine(typeof(<RetryAfterDelay>d__35))]
private IEnumerator RetryAfterDelay(float delaySeconds, string url)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RetryAfterDelay>d__35(0)
{
<>4__this = this,
delaySeconds = delaySeconds,
url = url
};
}
private ResolutionOption GetLowerResolution(ResolutionOption current)
{
return current switch
{
ResolutionOption.R1080p => ResolutionOption.R720p,
ResolutionOption.R720p => ResolutionOption.R480p,
_ => current,
};
}
private void ShowError(string message)
{
Debug.LogError((object)("HoofTV: " + message));
if ((Object)(object)downloadingObj != (Object)null)
{
downloadingObj.SetActive(false);
}
if ((Object)(object)errorObj != (Object)null)
{
errorObj.SetActive(true);
}
if ((Object)(object)errorText != (Object)null)
{
errorText.text = "Error: " + message;
}
ToggleControls(startVisible: true, stopVisible: false, pauseVisible: false, resumeVisible: false);
}
[IteratorStateMachine(typeof(<DownloadVideoCoroutine>d__38))]
private IEnumerator DownloadVideoCoroutine(string downloadUrl, string localPath)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DownloadVideoCoroutine>d__38(0)
{
<>4__this = this,
downloadUrl = downloadUrl,
localPath = localPath
};
}
private void PlayVideoFromFile(string filePath)
{
if (!File.Exists(filePath))
{
Debug.LogError((object)("HoofTV: Downloaded file not found at " + filePath));
isPreparingVideo = false;
AttemptRetryOrFallback();
return;
}
Debug.Log((object)("HoofTV: Playing video from local file: " + filePath));
if ((Object)(object)videoPlayer == (Object)null)
{
Debug.LogError((object)"HoofTV: VideoPlayer is null!");
return;
}
pendingVideoUrl = filePath;
videoPlayer.source = (VideoSource)1;
videoPlayer.url = "file://" + filePath;
if ((Object)(object)videoPlayer.targetTexture == (Object)null)
{
EnsureRenderTexture((int)currentResolution);
}
if (videoPlayer.isPlaying)
{
videoPlayer.Stop();
}
videoPlayer.controlledAudioTrackCount = 1;
videoPlayer.EnableAudioTrack((ushort)0, true);
videoPlayer.Prepare();
}
public void OnStopClicked()
{
if ((Object)(object)videoPlayer != (Object)null && videoPlayer.isPlaying)
{
videoPlayer.Stop();
}
isPreparingVideo = false;
currentRetryCount = 0;
pendingVideoUrl = "";
if ((Object)(object)downloadingObj != (Object)null)
{
downloadingObj.SetActive(false);
}
if ((Object)(object)screenToEnable != (Object)null)
{
screenToEnable.SetActive(false);
}
ToggleControls(startVisible: true, stopVisible: false, pauseVisible: false, resumeVisible: false);
}
public void OnPauseClicked()
{
if ((Object)(object)videoPlayer != (Object)null && videoPlayer.isPlaying)
{
videoPlayer.Pause();
isMeantToBePaused = true;
pausedTimestamp = videoPlayer.time;
ToggleControls(startVisible: false, stopVisible: true, pauseVisible: false, resumeVisible: true);
}
}
public void OnResumeClicked()
{
if ((Object)(object)videoPlayer != (Object)null && !videoPlayer.isPlaying)
{
videoPlayer.Play();
isMeantToBePaused = false;
videoPlayer.time = pausedTimestamp;
ToggleControls(startVisible: false, stopVisible: true, pauseVisible: true, resumeVisible: false);
}
}
private void ToggleControls(bool startVisible, bool stopVisible, bool pauseVisible, bool resumeVisible)
{
if ((Object)(object)startButton != (Object)null)
{
((Component)startButton).gameObject.SetActive(startVisible);
}
if ((Object)(object)stopButton != (Object)null)
{
((Component)stopButton).gameObject.SetActive(stopVisible);
}
if ((Object)(object)pauseButton != (Object)null)
{
((Component)pauseButton).gameObject.SetActive(pauseVisible);
}
if ((Object)(object)resumeButton != (Object)null)
{
((Component)resumeButton).gameObject.SetActive(resumeVisible);
}
}
private void OnStartClicked()
{
TMP_Text obj = seasonLabel;
int num = ParseLabelNumber(((obj != null) ? obj.text : null) ?? "");
TMP_Text obj2 = episodeLabel;
int num2 = ParseLabelNumber(((obj2 != null) ? obj2.text : null) ?? "");
if (num <= 0 || num2 <= 0)
{
Debug.LogWarning((object)"Season or Episode label is not a valid positive integer.");
return;
}
currentResolution = ResolutionOption.R720p;
errorObj.SetActive(false);
EnsureRenderTexture((int)currentResolution);
string text = GenerateUrl(num, num2, (int)currentResolution);
Debug.Log((object)("HoofTV: Starting video playback: " + text));
if ((Object)(object)warningText != (Object)null)
{
warningText.SetActive(false);
}
ToggleControls(startVisible: false, stopVisible: true, pauseVisible: true, resumeVisible: false);
PlayVideo(text);
}
private int ParseLabelNumber(string label)
{
if (string.IsNullOrEmpty(label))
{
return -1;
}
string[] array = label.Split(' ');
for (int i = 0; i < array.Length; i++)
{
if (int.TryParse(array[i], out var result))
{
return result;
}
}
return -1;
}
private string GenerateUrl(int season, int episode, int resolution)
{
return $"https://static.heartshine.gay/g4-fim/s{season:D2}e{episode:D2}-720p.mp4";
}
private string GenerateUrlForDownlaod(int season, int episode)
{
return $"https://static.heartshine.gay/g4-fim/s{season:D2}e{episode:D2}-480p.mp4";
}
private void OnPrepareCompleted(VideoPlayer vp)
{
Debug.Log((object)("HoofTV: Prepare completed for url: " + vp.url));
isPreparingVideo = false;
currentRetryCount = 0;
if ((Object)(object)downloadingObj != (Object)null)
{
downloadingObj.SetActive(false);
}
vp.Play();
if ((Object)(object)screenToEnable != (Object)null)
{
screenToEnable.SetActive(true);
}
ToggleControls(startVisible: false, stopVisible: true, pauseVisible: true, resumeVisible: false);
}
public void PlayVideo(string url)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError((object)"HoofTV: PlayVideo called with null/empty url.");
return;
}
Debug.Log((object)("HoofTV: PlayVideo called. Setting url and preparing: " + url));
if ((Object)(object)videoPlayer == (Object)null)
{
Debug.LogError((object)"HoofTV: VideoPlayer is null!");
return;
}
isPreparingVideo = true;
prepareStartTime = Time.time;
if (((ConfigValueElement<bool>)(object)DownloadVideoBeforePlaying).Value)
{
TMP_Text obj = seasonLabel;
int season = ParseLabelNumber(((obj != null) ? obj.text : null) ?? "");
TMP_Text obj2 = episodeLabel;
int episode = ParseLabelNumber(((obj2 != null) ? obj2.text : null) ?? "");
string downloadUrl = GenerateUrlForDownlaod(season, episode);
try
{
if (File.Exists(videoCachePath))
{
File.Delete(videoCachePath);
Debug.Log((object)"HoofTV: Deleted old cache file");
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("HoofTV: Could not delete old cache file: " + ex.Message));
}
((MonoBehaviour)this).StartCoroutine(DownloadVideoCoroutine(downloadUrl, videoCachePath));
}
else
{
pendingVideoUrl = url;
videoPlayer.source = (VideoSource)1;
videoPlayer.url = url;
if ((Object)(object)videoPlayer.targetTexture == (Object)null)
{
EnsureRenderTexture((int)currentResolution);
}
if (videoPlayer.isPlaying)
{
videoPlayer.Stop();
}
videoPlayer.controlledAudioTrackCount = 1;
videoPlayer.EnableAudioTrack((ushort)0, true);
videoPlayer.Prepare();
}
}
private void OnVideoEnd(VideoPlayer vp)
{
Debug.Log((object)"HoofTV: Video ended.");
if ((Object)(object)screenToEnable != (Object)null)
{
screenToEnable.SetActive(false);
}
ToggleControls(startVisible: true, stopVisible: false, pauseVisible: false, resumeVisible: false);
}
private void OnVideoError(VideoPlayer vp, string message)
{
Debug.LogError((object)("HoofTV: VideoPlayer error: " + message + " | url: " + ((vp != null) ? vp.url : null)));
isPreparingVideo = false;
AttemptRetryOrFallback();
}
private void OnDestroy()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Expected O, but got Unknown
if ((Object)(object)videoPlayer != (Object)null)
{
videoPlayer.loopPointReached -= new EventHandler(OnVideoEnd);
videoPlayer.prepareCompleted -= new EventHandler(OnPrepareCompleted);
videoPlayer.errorReceived -= new ErrorEventHandler(OnVideoError);
}
if ((Object)(object)targetRenderTexture != (Object)null)
{
targetRenderTexture.Release();
Object.Destroy((Object)(object)targetRenderTexture);
}
}
public void PauseVideo()
{
if ((Object)(object)videoPlayer != (Object)null && videoPlayer.isPlaying)
{
videoPlayer.Pause();
isMeantToBePaused = true;
pausedTimestamp = videoPlayer.time;
}
}
public void ResumeVideo()
{
if ((Object)(object)videoPlayer != (Object)null && !videoPlayer.isPlaying)
{
isMeantToBePaused = false;
videoPlayer.time = pausedTimestamp;
videoPlayer.Play();
}
}
public void StopVideo()
{
if ((Object)(object)videoPlayer != (Object)null && videoPlayer.isPlaying)
{
videoPlayer.Stop();
if ((Object)(object)screenToEnable != (Object)null)
{
screenToEnable.SetActive(false);
}
}
}
}
namespace HoofTV
{
[BepInPlugin("com.NOTHANKYOU.hooftv", "HoofTV", "1.0.0")]
public class HoofTVPlugin : BaseUnityPlugin
{
public class CoroutineRunner : MonoBehaviour
{
private static CoroutineRunner _instance;
public static CoroutineRunner Instance
{
get
{
//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("CoroutineRunner");
Object.DontDestroyOnLoad((Object)val);
_instance = val.AddComponent<CoroutineRunner>();
}
return _instance;
}
}
}
[HarmonyPatch(typeof(StockMapInfo), "Awake")]
internal class Magic
{
[CompilerGenerated]
private sealed class <LoadAndInstantiatePrefab>d__1 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private AsyncOperationHandle<GameObject> <handle>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadAndInstantiatePrefab>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
<handle>5__2 = default(AsyncOperationHandle<GameObject>);
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: 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_0054: Invalid comparison between Unknown and I4
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<handle>5__2 = Addressables.LoadAssetAsync<GameObject>((object)"f1ff75d10ab733a4fb4a7d0abb3c170a");
<>2__current = <handle>5__2;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((int)<handle>5__2.Status == 1)
{
GameObject result = <handle>5__2.Result;
Object.Instantiate<GameObject>(result, result.transform.position, result.transform.rotation);
Debug.Log((object)$"HoofTV: TV prefab instantiated at {result.transform.position}.");
}
else
{
Debug.LogError((object)"HoofTV: Failed to load TV prefab.");
}
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 void Postfix(StockMapInfo __instance)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name.StartsWith("7b3cb6a0a"))
{
((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(LoadAndInstantiatePrefab());
}
}
[IteratorStateMachine(typeof(<LoadAndInstantiatePrefab>d__1))]
private static IEnumerator LoadAndInstantiatePrefab()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadAndInstantiatePrefab>d__1(0);
}
}
[CompilerGenerated]
private sealed class <loadHoofTVAddr>d__8 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private AsyncOperationHandle<IResourceLocator> <addressableHandle>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <loadHoofTVAddr>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
<addressableHandle>5__2 = default(AsyncOperationHandle<IResourceLocator>);
<>1__state = -2;
}
private bool MoveNext()
{
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01a7: Invalid comparison between Unknown and I4
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Invalid comparison between Unknown and I4
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_0175: Unknown result type (might be due to invalid IL or missing references)
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
string text = Path.Combine(addrDataPath, "catalog.json");
string text2 = Path.Combine(addrDataPath, "patched_catalog.json");
if (!File.Exists(text))
{
Debug.LogError((object)("HoofTV: Catalog file not found at: " + text));
return false;
}
try
{
JObject val = JObject.Parse(File.ReadAllText(text));
string text3 = "AngryLevelLoader.Plugin.tempFolderPath";
string text4 = addrDataPath.Replace("\\", "/");
if (!text4.EndsWith("/"))
{
text4 += "/";
}
JToken val2 = ((JToken)val).SelectToken("m_InternalIds");
if (val2 != null && (int)val2.Type == 2)
{
JArray val3 = (JArray)val2;
for (int i = 0; i < ((JContainer)val3).Count; i++)
{
string text5 = ((object)val3[i]).ToString();
if (text5.Contains(text3))
{
string text6 = text5.Replace(text3, text4);
Debug.Log((object)("HoofTV: Replacing path\n" + text5 + "\n->\n" + text6));
val3[i] = JToken.op_Implicit(text6);
}
}
}
File.WriteAllText(text2, ((JToken)val).ToString((Formatting)1, Array.Empty<JsonConverter>()));
Debug.Log((object)"HoofTV: Patched catalog created successfully.");
}
catch (Exception arg)
{
Debug.LogError((object)$"HoofTV: Error while patching catalog: {arg}");
return false;
}
Debug.Log((object)("HoofTV: Loading patched catalog from: " + text2));
<addressableHandle>5__2 = Addressables.LoadContentCatalogAsync(text2, false, (string)null);
<>2__current = <addressableHandle>5__2;
<>1__state = 1;
return true;
}
case 1:
<>1__state = -1;
if ((int)<addressableHandle>5__2.Status == 1)
{
Debug.Log((object)"HoofTV: Catalog loaded successfully.");
}
else
{
Debug.LogError((object)$"HoofTV: Failed to load patched catalog: {<addressableHandle>5__2.OperationException}");
}
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 bool isCatalogLoaded;
private ConfigBuilder config;
public static string addrDataPath = Path.Combine(ModPath(), "Addressable");
public static HoofTVPlugin instance;
public static string toolsPath = Path.Combine(ModPath(), "Tools");
public static string libPath = Path.Combine(toolsPath, "lib");
public static string ModPath()
{
return Assembly.GetExecutingAssembly().Location.Substring(0, Assembly.GetExecutingAssembly().Location.LastIndexOf(Path.DirectorySeparatorChar));
}
private void Awake()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Expected O, but got Unknown
instance = this;
((BaseUnityPlugin)this).Logger.LogInfo((object)"HoofTV: neigh");
if (!isCatalogLoaded)
{
((MonoBehaviour)this).StartCoroutine(loadHoofTVAddr());
isCatalogLoaded = true;
}
new Harmony("com.NOTHANKYOU.hooftv").PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"HoofTV: Harmony patches applied.");
config = new ConfigBuilder("probablysarah.hooftv", "HoofTV");
config.BuildAll();
}
[IteratorStateMachine(typeof(<loadHoofTVAddr>d__8))]
private IEnumerator loadHoofTVAddr()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <loadHoofTVAddr>d__8(0);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
internal IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
