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.Security;
using System.Security.Permissions;
using BepInEx;
using FistVR;
using OtherLoader;
using ProBuilder2.Common;
using ProBuilder2.MeshOperations;
using UnityEngine;
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[RequireComponent(typeof(ParticleSystem))]
public class CFX_AutoDestructShuriken : MonoBehaviour
{
public bool OnlyDeactivate;
private void OnEnable()
{
((MonoBehaviour)this).StartCoroutine("CheckIfAlive");
}
private IEnumerator CheckIfAlive()
{
do
{
yield return (object)new WaitForSeconds(0.5f);
}
while (((Component)this).GetComponent<ParticleSystem>().IsAlive(true));
if (OnlyDeactivate)
{
((Component)this).gameObject.SetActive(false);
}
else
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
[RequireComponent(typeof(Light))]
public class CFX_LightIntensityFade : MonoBehaviour
{
public float duration = 1f;
public float delay = 0f;
public float finalIntensity = 0f;
private float baseIntensity;
public bool autodestruct;
private float p_lifetime = 0f;
private float p_delay;
private void Start()
{
baseIntensity = ((Component)this).GetComponent<Light>().intensity;
}
private void OnEnable()
{
p_lifetime = 0f;
p_delay = delay;
if (delay > 0f)
{
((Behaviour)((Component)this).GetComponent<Light>()).enabled = false;
}
}
private void Update()
{
if (p_delay > 0f)
{
p_delay -= Time.deltaTime;
if (p_delay <= 0f)
{
((Behaviour)((Component)this).GetComponent<Light>()).enabled = true;
}
}
else if (p_lifetime / duration < 1f)
{
((Component)this).GetComponent<Light>().intensity = Mathf.Lerp(baseIntensity, finalIntensity, p_lifetime / duration);
p_lifetime += Time.deltaTime;
}
else if (autodestruct)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
[RequireComponent(typeof(MeshFilter))]
public class WFX_BulletHoleDecal : MonoBehaviour
{
private static Vector2[] quadUVs = (Vector2[])(object)new Vector2[4]
{
new Vector2(0f, 0f),
new Vector2(0f, 1f),
new Vector2(1f, 0f),
new Vector2(1f, 1f)
};
public float lifetime = 10f;
public float fadeoutpercent = 80f;
public Vector2 frames;
public bool randomRotation = false;
public bool deactivate = false;
private float life;
private float fadeout;
private Color color;
private float orgAlpha;
private void Awake()
{
//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)
color = ((Component)this).GetComponent<Renderer>().material.GetColor("_TintColor");
orgAlpha = color.a;
}
private void OnEnable()
{
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
int num = Random.Range(0, (int)(frames.x * frames.y));
int num2 = (int)((float)num % frames.x);
int num3 = (int)((float)num / frames.y);
Vector2[] array = (Vector2[])(object)new Vector2[4];
for (int i = 0; i < 4; i++)
{
array[i].x = (quadUVs[i].x + (float)num2) * (1f / frames.x);
array[i].y = (quadUVs[i].y + (float)num3) * (1f / frames.y);
}
((Component)this).GetComponent<MeshFilter>().mesh.uv = array;
if (randomRotation)
{
((Component)this).transform.Rotate(0f, 0f, Random.Range(0f, 360f), (Space)1);
}
life = lifetime;
fadeout = life * (fadeoutpercent / 100f);
color.a = orgAlpha;
((Component)this).GetComponent<Renderer>().material.SetColor("_TintColor", color);
((MonoBehaviour)this).StopAllCoroutines();
((MonoBehaviour)this).StartCoroutine("holeUpdate");
}
private IEnumerator holeUpdate()
{
while (life > 0f)
{
life -= Time.deltaTime;
if (life <= fadeout)
{
color.a = Mathf.Lerp(0f, orgAlpha, life / fadeout);
((Component)this).GetComponent<Renderer>().material.SetColor("_TintColor", color);
}
yield return null;
}
}
}
[RequireComponent(typeof(Light))]
public class WFX_LightFlicker : MonoBehaviour
{
public float time = 0.05f;
private float timer;
private void Start()
{
timer = time;
((MonoBehaviour)this).StartCoroutine("Flicker");
}
private IEnumerator Flicker()
{
while (true)
{
((Behaviour)((Component)this).GetComponent<Light>()).enabled = !((Behaviour)((Component)this).GetComponent<Light>()).enabled;
do
{
timer -= Time.deltaTime;
yield return null;
}
while (timer > 0f);
timer = time;
}
}
}
[BepInPlugin("Okkim.Record_Player", "Record_Player", "1.3.0")]
[BepInProcess("h3vr.exe")]
[BepInDependency("h3vr.otherloader", "1.3.0")]
public class Record_PlayerPlugin : BaseUnityPlugin
{
private static readonly string BasePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
private void Awake()
{
LoadAssets();
}
private void LoadAssets()
{
OtherLoader.RegisterDirectLoad(BasePath, "Okkim.Record_Player", "", "", "jukebox,musicdiscs_modmas2022,musicdiscs_modmas2023", "");
}
}
namespace ModMas;
public class JukeBox : MonoBehaviour
{
[SerializeField]
private AudioClip recordStartSound;
[HideInInspector]
public RecordDisc curDisc;
private RecordDisc prevDisc;
[SerializeField]
private AudioSource music;
[SerializeField]
private AudioSource startSoundSource;
[SerializeField]
private Transform discPosition;
[SerializeField]
private float discRotateSpeed = 1f;
public bool isPlaying;
public bool hasMusicStarted;
private float songProgress;
private float songLength;
[SerializeField]
private JukeBoxButton pausePlayInteractable;
[SerializeField]
private JukeBoxButton muteInteractable;
private GameObject rotatingArm;
[SerializeField]
private Vector2 minMaxYArmRot = default(Vector2);
private void Start()
{
rotatingArm = muteInteractable.thingNegativeObject;
startSoundSource.clip = recordStartSound;
}
private void OnTriggerEnter(Collider other)
{
if ((Object)(object)curDisc == (Object)null)
{
RecordDisc componentInParent = ((Component)other).GetComponentInParent<RecordDisc>();
if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent != (Object)(object)prevDisc)
{
DiscInsert(componentInParent);
}
}
}
private void OnTriggerExit(Collider other)
{
if ((Object)(object)prevDisc != (Object)null && (Object)(object)((Component)other).gameObject == (Object)(object)((Component)prevDisc).gameObject)
{
prevDisc = null;
}
}
private void Update()
{
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
if (hasMusicStarted && isPlaying)
{
discPosition.Rotate(0f, Time.deltaTime * discRotateSpeed, 0f);
if (songLength != 0f)
{
songProgress = music.time / songLength;
rotatingArm.transform.localRotation = Quaternion.Euler(0f, Mathf.Lerp(minMaxYArmRot.x, minMaxYArmRot.y, songProgress), 0f);
}
else
{
rotatingArm.transform.localRotation = Quaternion.Euler(0f, minMaxYArmRot.x, 0f);
}
}
}
private void DiscInsert(RecordDisc D)
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
((FVRInteractiveObject)D).ForceBreakInteraction();
D.CurBox = this;
curDisc = D;
prevDisc = null;
music.clip = D.RecordSong;
songLength = music.clip.length;
songProgress = 0f;
music.mute = true;
((FVRPhysicalObject)D).SetParentage(discPosition);
((FVRInteractiveObject)D).Transform.localPosition = new Vector3(0f, 0f, 0f);
((FVRInteractiveObject)D).Transform.localRotation = Quaternion.identity;
((FVRPhysicalObject)D).StoreAndDestroyRigidbody();
if (pausePlayInteractable.thingPositiveObject.activeSelf)
{
startMusic();
}
}
public void DiscExit()
{
songProgress = 0f;
stopMusic();
music.clip = null;
((FVRPhysicalObject)curDisc).RecoverRigidbody();
prevDisc = curDisc;
curDisc = null;
music.mute = true;
muteInteractable.SetPositive();
}
public void startMusic()
{
if ((Object)(object)music.clip != (Object)null)
{
hasMusicStarted = true;
if (muteInteractable.thingNegativeObject.activeSelf)
{
startSoundSource.Play();
music.PlayDelayed(recordStartSound.length);
}
else
{
music.Play();
}
isPlaying = true;
pausePlayInteractable.SetPositive();
}
}
public void stopMusic()
{
startSoundSource.Stop();
music.UnPause();
music.Stop();
hasMusicStarted = false;
}
public void pausePlay()
{
if (isPlaying)
{
music.Pause();
isPlaying = false;
if ((Object)(object)pausePlayInteractable != (Object)null)
{
pausePlayInteractable.SetNegative();
}
}
else
{
music.UnPause();
isPlaying = true;
if ((Object)(object)pausePlayInteractable != (Object)null)
{
pausePlayInteractable.SetPositive();
}
}
}
public void restartMusic()
{
hasMusicStarted = true;
startSoundSource.Stop();
music.Stop();
startSoundSource.Play();
music.PlayDelayed(recordStartSound.length);
isPlaying = false;
}
public void repeatMusic()
{
music.loop = !music.loop;
}
public void muteMusic()
{
music.mute = !music.mute;
if ((Object)(object)curDisc != (Object)null)
{
muteInteractable.swapActiveObjects();
}
}
}
public class JukeBoxButton : FVRInteractiveObject
{
public enum JBButtonTypes
{
Restart,
PausePlay,
Eject,
Repeat,
Start,
Mute
}
public JukeBox jukebox;
public JBButtonTypes ButtonTypes;
public GameObject thingPositiveObject;
public GameObject thingNegativeObject;
[SerializeField]
private AudioEvent positiveButtonSounds;
[SerializeField]
private AudioEvent negativeButtonSounds;
public override void SimpleInteraction(FVRViveHand hand)
{
((FVRInteractiveObject)this).SimpleInteraction(hand);
switch (ButtonTypes)
{
case JBButtonTypes.Restart:
jukebox.restartMusic();
break;
case JBButtonTypes.PausePlay:
if ((Object)(object)jukebox.curDisc != (Object)null)
{
if (!jukebox.hasMusicStarted)
{
jukebox.startMusic();
}
else
{
jukebox.pausePlay();
}
break;
}
swapActiveObjects();
if (thingPositiveObject.activeSelf)
{
jukebox.isPlaying = true;
}
else
{
jukebox.isPlaying = false;
}
break;
case JBButtonTypes.Eject:
break;
case JBButtonTypes.Repeat:
jukebox.repeatMusic();
swapActiveObjects();
break;
case JBButtonTypes.Start:
jukebox.startMusic();
break;
case JBButtonTypes.Mute:
jukebox.muteMusic();
break;
}
}
public void swapActiveObjects()
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)thingPositiveObject != (Object)null) || !((Object)(object)thingPositiveObject != (Object)null))
{
return;
}
if (thingNegativeObject.activeSelf)
{
thingNegativeObject.SetActive(false);
thingPositiveObject.SetActive(true);
if (positiveButtonSounds.Clips.Count > 0)
{
SM.PlayGenericSound(positiveButtonSounds, ((Component)this).transform.position);
}
}
else if (thingPositiveObject.activeSelf)
{
thingNegativeObject.SetActive(true);
thingPositiveObject.SetActive(false);
if (negativeButtonSounds.Clips.Count > 0)
{
SM.PlayGenericSound(negativeButtonSounds, ((Component)this).transform.position);
}
}
}
public void SetPositive()
{
if ((Object)(object)thingPositiveObject != (Object)null && (Object)(object)thingPositiveObject != (Object)null)
{
thingPositiveObject.SetActive(true);
thingNegativeObject.SetActive(false);
}
}
public void SetNegative()
{
if ((Object)(object)thingPositiveObject != (Object)null && (Object)(object)thingPositiveObject != (Object)null)
{
thingPositiveObject.SetActive(false);
thingNegativeObject.SetActive(true);
}
}
}
public class RecordDisc : FVRPhysicalObject
{
public AudioClip RecordSong;
[HideInInspector]
public JukeBox CurBox;
public override void BeginInteraction(FVRViveHand hand)
{
((FVRPhysicalObject)this).BeginInteraction(hand);
if ((Object)(object)CurBox != (Object)null)
{
CurBox.DiscExit();
((Component)this).transform.parent = null;
CurBox = null;
}
}
}
public class FollowTargetDebug : MonoBehaviour
{
public bool check;
private void OnLevelWasLoaded()
{
Debug.Log((object)("OnLevelWasLoaded, player head exists: " + GM.CurrentPlayerBody != null));
}
private void Awake()
{
Debug.Log((object)"OnAwake, player head exists: ");
}
private void Start()
{
Debug.Log((object)"Start, player head exists: ");
}
private void Update()
{
if (!check)
{
Debug.Log((object)"Update, player head exists: ");
}
check = true;
}
}
public class ExtrudeRandomEdges : MonoBehaviour
{
private pb_Object pb;
private pb_Face lastExtrudedFace = null;
public float distance = 1f;
private void Start()
{
pb = pb_ShapeGenerator.PlaneGenerator(1f, 1f, 0, 0, (Axis)2, false);
pb.SetFaceMaterial(pb.faces, pb_Constant.DefaultMaterial);
lastExtrudedFace = pb.faces[0];
}
private void OnGUI()
{
if (GUILayout.Button("Extrude Random Edge", (GUILayoutOption[])(object)new GUILayoutOption[0]))
{
ExtrudeEdge();
}
}
private void ExtrudeEdge()
{
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
pb_Face sourceFace = lastExtrudedFace;
List<pb_WingedEdge> wingedEdges = pb_WingedEdge.GetWingedEdges(pb, false);
IEnumerable<pb_WingedEdge> source = wingedEdges.Where((pb_WingedEdge x) => x.face == sourceFace);
List<pb_Edge> list = (from x in source
where x.opposite == null
select x into y
select y.edge.local).ToList();
int index = Random.Range(0, list.Count);
pb_Edge val = list[index];
Vector3 val2 = (pb.vertices[val.x] + pb.vertices[val.y]) * 0.5f - pb_Math.Average<int>((IList<int>)sourceFace.distinctIndices, (Func<int, Vector3>)((int x) => pb.vertices[x]), (IList<int>)null);
((Vector3)(ref val2)).Normalize();
pb_Edge[] selectedEdges = default(pb_Edge[]);
pbMeshOps.Extrude(pb, (pb_Edge[])(object)new pb_Edge[1] { val }, 0f, false, true, ref selectedEdges);
lastExtrudedFace = pb.faces.Last();
pb.SetSelectedEdges((IEnumerable<pb_Edge>)selectedEdges);
pb_Object_Utility.TranslateVertices(pb, pb.SelectedTriangles, val2 * distance);
pb.ToMesh();
pb.Refresh((RefreshMask)255);
}
}
public class HighlightNearestFace : MonoBehaviour
{
public float travel = 50f;
public float speed = 0.2f;
private pb_Object target;
private pb_Face nearest = null;
private void Start()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
target = pb_ShapeGenerator.PlaneGenerator(travel, travel, 25, 25, (Axis)2, false);
target.SetFaceMaterial(target.faces, pb_Constant.DefaultMaterial);
((Component)target).transform.position = new Vector3(travel * 0.5f, 0f, travel * 0.5f);
target.ToMesh();
target.Refresh((RefreshMask)255);
Camera main = Camera.main;
((Component)main).transform.position = new Vector3(25f, 40f, 0f);
((Component)main).transform.localRotation = Quaternion.Euler(new Vector3(65f, 0f, 0f));
}
private void Update()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: 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)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
float num = Time.time * speed;
Vector3 position = default(Vector3);
((Vector3)(ref position))..ctor(Mathf.PerlinNoise(num, num) * travel, 2f, Mathf.PerlinNoise(num + 1f, num + 1f) * travel);
((Component)this).transform.position = position;
if ((Object)(object)target == (Object)null)
{
Debug.LogWarning((object)"Missing the ProBuilder Mesh target!");
return;
}
Vector3 val = ((Component)target).transform.InverseTransformPoint(((Component)this).transform.position);
if (nearest != null)
{
target.SetFaceColor(nearest, Color.white);
}
int num2 = target.faces.Length;
float num3 = float.PositiveInfinity;
nearest = target.faces[0];
for (int i = 0; i < num2; i++)
{
float num4 = Vector3.Distance(val, FaceCenter(target, target.faces[i]));
if (num4 < num3)
{
num3 = num4;
nearest = target.faces[i];
}
}
target.SetFaceColor(nearest, Color.blue);
target.RefreshColors();
}
private Vector3 FaceCenter(pb_Object pb, pb_Face face)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
Vector3[] vertices = pb.vertices;
Vector3 zero = Vector3.zero;
int[] distinctIndices = face.distinctIndices;
foreach (int num in distinctIndices)
{
zero.x += vertices[num].x;
zero.y += vertices[num].y;
zero.z += vertices[num].z;
}
float num2 = face.distinctIndices.Length;
zero.x /= num2;
zero.y /= num2;
zero.z /= num2;
return zero;
}
}
