OcCubeValuables

using System; using System.Collections; using System.Collections.Generic; using Photon.Pun; using UnityEngine; using UnityEngine.AI;

public class ValuableObject : MonoBehaviour { [Serializable] public class ExtractionPointTracking { public GameObject extractionPoint;

	public int closestRingReached;

	public float localPlayerHaulToExtraction;

	public ExtractionPointTracking(GameObject _extractionPoint)
	{
		extractionPoint = _extractionPoint;
		closestRingReached = -1;
		localPlayerHaulToExtraction = 0f;
	}
}

[Space(40f)]
[Header("Presets")]
public Durability durabilityPreset;

public Value valuePreset;

public PhysAttribute physAttributePreset;

public PhysAudio audioPreset;

[Range(0.5f, 3f)]
public float audioPresetPitch = 1f;

public Gradient particleColors;

[Space(70f)]
public ValuableVolume.Type volumeType;

public bool debugVolume = true;

private PhysGrabObjectImpactDetector impactDetector;

[Space(20f)]
internal float dollarValueOriginal = 100f;

internal float dollarValueCurrent = 100f;

internal bool dollarValueSet;

internal int dollarValueOverride;

private Rigidbody rb;

private PhotonView photonView;

private NavMeshObstacle navMeshObstacle;

private bool inStartRoom;

private float inStartRoomCheckTimer;

internal RoomVolumeCheck roomVolumeCheck;

internal PhysGrabObject physGrabObject;

internal bool discovered;

internal bool discoveredReminder;

private float discoveredReminderTimer;

private List<ExtractionPointTracking> extractionPointTrackings = new List<ExtractionPointTracking>();

private bool extractionTrackingInitialized;

private Vector3 lastExtractionTrackingPosition;

private Dictionary<PhysGrabber, float> playerGrabbedTime = new Dictionary<PhysGrabber, float>();

private Dictionary<PhysGrabCart, Dictionary<PhysGrabber, float>> cartSnapshots = new Dictionary<PhysGrabCart, Dictionary<PhysGrabber, float>>();

private float lastGrabbedTimeUpdate;

[SerializeField]
private DebugValuableMeshes debugValuableMeshes;

private void Awake()
{
	photonView = GetComponent<PhotonView>();
}

private void Start()
{
	physGrabObject = GetComponent<PhysGrabObject>();
	roomVolumeCheck = GetComponent<RoomVolumeCheck>();
	impactDetector = GetComponent<PhysGrabObjectImpactDetector>();
	float num = Mathf.Max(base.transform.localScale.x, base.transform.localScale.y, base.transform.localScale.z);
	if (num > 1f)
	{
		float t = Mathf.Clamp01((num - 1f) / 1f);
		audioPresetPitch = Mathf.Lerp(audioPresetPitch, 0.65f, t);
	}
	navMeshObstacle = GetComponent<NavMeshObstacle>();
	if ((bool)navMeshObstacle)
	{
		Debug.LogError(base.gameObject.name + " has a NavMeshObstacle component. Please remove it.");
	}
	StartCoroutine(DollarValueSet());
	rb = GetComponent<Rigidbody>();
	if ((bool)physAttributePreset)
	{
		if ((bool)rb)
		{
			rb.mass = physAttributePreset.mass;
		}
		if ((bool)physGrabObject)
		{
			physGrabObject.massOriginal = physAttributePreset.mass;
		}
	}
	else if ((bool)rb || (bool)physGrabObject || (bool)impactDetector)
	{
		Debug.LogError(base.gameObject.name + " is missing a PhysAttributePreset.", base.gameObject);
	}
	if (!LevelGenerator.Instance.Generated)
	{
		ValuableDirector.instance.valuableSpawnAmount++;
	}
	ValuableDirector.instance.valuableList.Add(this);
	if (volumeType <= ValuableVolume.Type.Small)
	{
		physGrabObject.clientNonKinematic = true;
	}
}

private void AddToDollarHaulList()
{
	if (GameManager.instance.gameMode == 1)
	{
		photonView.RPC("AddToDollarHaulListRPC", RpcTarget.All);
	}
	else if ((bool)GetComponent<ValuableObject>() && !RoundDirector.instance.dollarHaulList.Contains(base.gameObject))
	{
		RoundDirector.instance.dollarHaulList.Add(base.gameObject);
	}
}

[PunRPC]
public void AddToDollarHaulListRPC(PhotonMessageInfo _info = default(PhotonMessageInfo))
{
	if (SemiFunc.MasterOnlyRPC(_info) && (bool)GetComponent<ValuableObject>() && !RoundDirector.instance.dollarHaulList.Contains(base.gameObject))
	{
		RoundDirector.instance.dollarHaulList.Add(base.gameObject);
	}
}

private void RemoveFromDollarHaulList()
{
	if (GameManager.instance.gameMode == 1)
	{
		photonView.RPC("RemoveFromDollarHaulListRPC", RpcTarget.All);
	}
	else if ((bool)GetComponent<ValuableObject>() && RoundDirector.instance.dollarHaulList.Contains(base.gameObject))
	{
		RoundDirector.instance.dollarHaulList.Remove(base.gameObject);
	}
}

[PunRPC]
public void RemoveFromDollarHaulListRPC(PhotonMessageInfo _info = default(PhotonMessageInfo))
{
	if (SemiFunc.MasterOnlyRPC(_info) && (bool)GetComponent<ValuableObject>() && RoundDirector.instance.dollarHaulList.Contains(base.gameObject))
	{
		RoundDirector.instance.dollarHaulList.Remove(base.gameObject);
	}
}

private void Update()
{
	if (GameManager.instance.gameMode == 0 || PhotonNetwork.IsMasterClient)
	{
		if (inStartRoomCheckTimer > 0f)
		{
			inStartRoomCheckTimer -= Time.deltaTime;
		}
		else
		{
			bool flag = false;
			foreach (RoomVolume currentRoom in roomVolumeCheck.CurrentRooms)
			{
				if (currentRoom.Extraction)
				{
					if (!inStartRoom)
					{
						AddToDollarHaulList();
						inStartRoom = true;
					}
					flag = true;
				}
			}
			if (!flag && inStartRoom)
			{
				RemoveFromDollarHaulList();
				inStartRoom = false;
			}
			inStartRoomCheckTimer = 0.5f;
		}
	}
	if (!extractionTrackingInitialized)
	{
		InitializeExtractionTracking();
	}
	else if (Vector3.Distance(base.transform.position, lastExtractionTrackingPosition) >= 2f)
	{
		UpdateExtractionTracking();
		lastExtractionTrackingPosition = base.transform.position;
	}
	UpdatePlayerGrabbedTime();
	UpdateCartSnapshots();
	DiscoverReminderLogic();
}

private IEnumerator DollarValueSet()
{
	yield return new WaitForSeconds(0.05f);
	while (LevelGenerator.Instance.State <= LevelGenerator.LevelState.Valuable)
	{
		yield return new WaitForSeconds(0.05f);
	}
	while (SemiFunc.IsMultiplayer() && photonView.ViewID == 0)
	{
		yield return new WaitForSeconds(0.05f);
	}
	if (!SemiFunc.IsMultiplayer())
	{
		DollarValueSetLogic();
	}
	else if (SemiFunc.IsMasterClient())
	{
		DollarValueSetLogic();
		photonView.RPC("DollarValueSetRPC", RpcTarget.Others, dollarValueCurrent);
	}
	if (SemiFunc.IsMasterClientOrSingleplayer())
	{
		RoundDirector.instance.haulGoalMax += (int)dollarValueCurrent;
	}
}

public void DollarValueSetLogic()
{
	if (!dollarValueSet)
	{
		if (dollarValueOverride != 0)
		{
			dollarValueOriginal = dollarValueOverride;
			dollarValueCurrent = dollarValueOverride;
		}
		else
		{
			dollarValueOriginal = Mathf.Round(UnityEngine.Random.Range(valuePreset.valueMin, valuePreset.valueMax));
			dollarValueOriginal = Mathf.Round(dollarValueOriginal / 100f) * 100f;
			dollarValueCurrent = dollarValueOriginal;
		}
		dollarValueSet = true;
	}
}

private void DiscoverReminderLogic()
{
	if (!discovered || discoveredReminder)
	{
		return;
	}
	if (discoveredReminderTimer > 0f)
	{
		discoveredReminderTimer -= Time.deltaTime;
		return;
	}
	discoveredReminderTimer = UnityEngine.Random.Range(2f, 5f);
	if (!physGrabObject.impactDetector.inCart && (bool)PlayerController.instance && PlayerController.instance.isActiveAndEnabled)
	{
		if (Vector3.Distance(base.transform.position, PlayerController.instance.transform.position) > 20f)
		{
			discoveredReminder = true;
		}
	}
	else
	{
		discoveredReminder = false;
	}
}

public bool Discover(ValuableDiscoverGraphic.State _state)
{
	bool result = false;
	if (!discovered)
	{
		result = true;
		if (!GameManager.Multiplayer())
		{
			DiscoverRPC();
		}
		else
		{
			if (photonView.ViewID == 0)
			{
				return false;
			}
			photonView.RPC("DiscoverRPC", RpcTarget.All);
		}
	}
	ValuableDiscover.instance.New(physGrabObject, _state);
	return result;
}

[PunRPC]
private void DiscoverRPC()
{
	discovered = true;
	Map.Instance.AddValuable(this);
}

[PunRPC]
public void DollarValueSetRPC(float value, PhotonMessageInfo _info = default(PhotonMessageInfo))
{
	if (SemiFunc.MasterOnlyRPC(_info))
	{
		dollarValueOriginal = value;
		dollarValueCurrent = value;
		dollarValueSet = true;
	}
}

private void InitializeExtractionTracking()
{
	if (LevelGenerator.Instance.State <= LevelGenerator.LevelState.Valuable || RoundDirector.instance == null || RoundDirector.instance.extractionPointList == null)
	{
		return;
	}
	foreach (GameObject extractionPoint in RoundDirector.instance.extractionPointList)
	{
		if ((bool)extractionPoint)
		{
			ExtractionPointTracking extractionPointTracking = new ExtractionPointTracking(extractionPoint);
			float num = Vector3.Distance(base.transform.position, extractionPoint.transform.position);
			if (num < 60f)
			{
				int closestRingReached = Mathf.FloorToInt(num / 2f);
				extractionPointTracking.closestRingReached = closestRingReached;
			}
			extractionPointTrackings.Add(extractionPointTracking);
		}
	}
	lastExtractionTrackingPosition = base.transform.position;
	extractionTrackingInitialized = true;
}

private void UpdateExtractionTracking()
{
	if (!extractionTrackingInitialized)
	{
		return;
	}
	foreach (ExtractionPointTracking extractionPointTracking in extractionPointTrackings)
	{
		if (!extractionPointTracking.extractionPoint)
		{
			continue;
		}
		float num = Vector3.Distance(base.transform.position, extractionPointTracking.extractionPoint.transform.position);
		if (num >= 60f)
		{
			continue;
		}
		int num2 = Mathf.FloorToInt(num / 2f);
		if (extractionPointTracking.closestRingReached == -1)
		{
			extractionPointTracking.closestRingReached = num2;
		}
		else if (num2 < extractionPointTracking.closestRingReached)
		{
			if (physGrabObject.grabbedLocal)
			{
				extractionPointTracking.localPlayerHaulToExtraction += 1f;
			}
			else if (impactDetector.inCart)
			{
				float localPlayerPercentageForCurrentCart = GetLocalPlayerPercentageForCurrentCart();
				extractionPointTracking.localPlayerHaulToExtraction += 0.2f * localPlayerPercentageForCurrentCart;
			}
			extractionPointTracking.closestRingReached = num2;
		}
	}
}

public float GetLocalPlayerHaulScore(GameObject _extractionPoint)
{
	foreach (ExtractionPointTracking extractionPointTracking in extractionPointTrackings)
	{
		if (extractionPointTracking.extractionPoint == _extractionPoint)
		{
			return extractionPointTracking.localPlayerHaulToExtraction;
		}
	}
	return 0f;
}

private PhysGrabCart GetCurrentCart()
{
	if (!impactDetector)
	{
		return null;
	}
	return impactDetector.currentCart;
}

private float GetLocalPlayerPercentageForCurrentCart()
{
	PhysGrabCart currentCart = GetCurrentCart();
	if (!currentCart)
	{
		return 0f;
	}
	if (!cartSnapshots.ContainsKey(currentCart))
	{
		return 0f;
	}
	Dictionary<PhysGrabber, float> dictionary = cartSnapshots[currentCart];
	float num = 0f;
	float num2 = 0f;
	foreach (KeyValuePair<PhysGrabber, float> item in dictionary)
	{
		if ((bool)item.Key)
		{
			num += item.Value;
			bool flag = true;
			if ((!GameManager.Multiplayer()) ? item.Key.isLocal : item.Key.photonView.IsMine)
			{
				num2 = item.Value;
			}
		}
	}
	if (num <= 0f)
	{
		return 0f;
	}
	return num2 / num;
}

private void UpdatePlayerGrabbedTime()
{
	if (impactDetector.inCart || physGrabObject.playerGrabbing.Count == 0)
	{
		return;
	}
	float num = Time.time - lastGrabbedTimeUpdate;
	lastGrabbedTimeUpdate = Time.time;
	float num2 = num / (float)physGrabObject.playerGrabbing.Count;
	foreach (PhysGrabber item in physGrabObject.playerGrabbing)
	{
		if ((bool)item)
		{
			if (!playerGrabbedTime.ContainsKey(item))
			{
				playerGrabbedTime[item] = 0f;
			}
			playerGrabbedTime[item] += num2;
		}
	}
}

private void UpdateCartSnapshots()
{
	if (impactDetector.inCart)
	{
		PhysGrabCart currentCart = GetCurrentCart();
		if ((bool)currentCart && !cartSnapshots.ContainsKey(currentCart))
		{
			Dictionary<PhysGrabber, float> value = new Dictionary<PhysGrabber, float>(playerGrabbedTime);
			cartSnapshots[currentCart] = value;
		}
	}
}

private void OnDrawGizmos()
{
	if (debugVolume)
	{
		Gizmos.color = new Color(1f, 0.92f, 0.02f, 0.2f);
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Mesh mesh = null;
		if ((bool)debugValuableMeshes)
		{
			mesh = volumeType switch
			{
				ValuableVolume.Type.Tiny => debugValuableMeshes.tiny, 
				ValuableVolume.Type.Small => debugValuableMeshes.small, 
				ValuableVolume.Type.Medium => debugValuableMeshes.medium, 
				ValuableVolume.Type.Big => debugValuableMeshes.big, 
				ValuableVolume.Type.Wide => debugValuableMeshes.wide, 
				ValuableVolume.Type.Tall => debugValuableMeshes.tall, 
				ValuableVolume.Type.VeryTall => debugValuableMeshes.veryTall, 
				_ => null, 
			};
		}
		Gizmos.DrawMesh(mesh, Vector3.zero, Quaternion.identity, Vector3.one);
		Gizmos.DrawWireMesh(mesh, Vector3.zero, Quaternion.identity, Vector3.one);
	}
}

}