private bool FindClosestInteractable(out BaseInteractable baseInteractable)
{
var colliders = new Collider[15];
var count = Physics.OverlapSphereNonAlloc(transform.position, interactRange, colliders);
var closestDistance = float.MaxValue;
BaseInteractable closestBaseInteractable = null;
foreach (var foundCollider in colliders)
{
if (foundCollider == null)
{
continue;
}
var foundInteractable = TryGetBaseInteractable(foundCollider.gameObject);
if (foundInteractable == null || !foundInteractable.IsActive)
{
continue;
}
var distanceToInteractable = (foundInteractable.transform.position - transform.position).magnitude;
if (distanceToInteractable > closestDistance)
{
continue;
}
closestDistance = distanceToInteractable;
closestBaseInteractable = foundInteractable;
}
baseInteractable = closestBaseInteractable;
return(baseInteractable != null);
}
public override bool Attach(GameObject hook, GameObject target)
{
if (hook == null || target == null)
{
return(false);
}
m_enabled = true;
m_hook = hook;
m_target = target;
m_targetRigidbody = m_target.GetComponent <Rigidbody2D>();
m_targetInteractable = m_target.GetComponent <BaseInteractable>();
Vector2 pos = transform.position;
Vector2 targetPos = m_target.transform.position;
m_oldPos = targetPos;
if (m_targetInteractable != null)
{
m_targetInteractable.StartInteract(m_hookBehaviour);
}
return(true);
}
public void ChangeState(PlayerState newState, Vector3 raycastHitPoint, BaseInteractable interactingWith = null)
{
switch (newState)
{
case PlayerState.NORMAL:
break;
case PlayerState.HARVESTING:
HarvestingState(interactingWith);
break;
case PlayerState.FAINT:
FaintState();
break;
case PlayerState.REPLENISHING:
ReplenishingState(interactingWith, raycastHitPoint);
break;
default:
_rigidBody.velocity = Vector3.zero;
_rigidBody.angularVelocity = 0;
_rigidBody.isKinematic = true;
break;
}
mState = newState;
}
public override bool Condition()
{
interactable = other.GetComponent <BaseInteractable>();
if (interactable != null && interactable.interaction == BaseInteractable.GameInteraction.Pushable)
{
return(true);
}
return(false);
}
protected virtual void HoverExit(BaseInteractable interactable)
{
if (m_HoverInteractable == interactable)
{
// Cleared interactable
m_HoverInteractable = null;
m_HoverModel.onChanged -= ModelChanged;
m_HoverModel = null;
SetModel(null);
}
}
void Update()
{
_RayFromScreen = _MainCamera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
if (Physics.Raycast(_RayFromScreen, out RaycastHit hit))
{
// Compare layer mask with layer of hit object. Change color if its layer is in the valid mask
if ((1 << hit.transform.gameObject.layer & ValidLayer.value) != 0)
{
CCManager.ColorToValid();
}
else
{
CCManager.ColorToDefault();
}
OnRaycastHit?.Invoke(hit);
_InteractableHovering = hit.collider.GetComponentInParent <BaseInteractable>();
if (_InteractableHovering != null)
{
CCManager.ShowCross();
if (Input.GetMouseButtonUp(1))
{
_InteractableHovering.OnRightClick();
}
if (Input.GetMouseButtonUp(0))
{
_InteractableHovering.OnLeftClick();
}
}
else
{
CCManager.ShowCross(false);
}
}
else
{
CCManager.ColorToDefault();
OnRaycastMiss?.Invoke();
_InteractableHovering = null;
CCManager.ShowCross(false);
}
if (Input.GetKeyUp("f"))
{
GameObject go = Instantiate(Bullet, FireTransform.position, Quaternion.LookRotation(_RayFromScreen.direction));
go.GetComponent <Rigidbody>().velocity = _RayFromScreen.direction * BulletVelocity;
}
}
// Update is called once per frame
void Update()
{
#region Handles clicks
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
var interactable = Physics.Raycast(ray, out hit)
? hit.transform.GetComponent <BaseInteractable>()
: null;
// Only need to call hover/unhover if things changed
if (this.hovering != interactable)
{
if (this.hovering != null)
{
this.hovering.OnUnhover();
}
if (interactable != null)
{
interactable.OnHover();
}
this.hovering = interactable;
}
if (this.hovering != null && Input.GetMouseButtonDown(0))
{
this.hovering.OnClick();
}
#endregion
#region Handles movement
var x = 0;
var z = 0;
if (Input.GetKey(KeyCode.A))
{
x--;
}
if (Input.GetKey(KeyCode.D))
{
x++;
}
if (Input.GetKey(KeyCode.W))
{
z++;
}
if (Input.GetKey(KeyCode.S))
{
z--;
}
var movement = new Vector3(x, 0, z).normalized;
this.transform.position += movement * this.MovementSpeed * Time.deltaTime;
#endregion
}
private void SwitchToNewInteractable(BaseInteractable foundBaseInteractable)
{
if (_currentBaseInteractable != null)
{
_currentBaseInteractable.HightlightAsInteractable(false);
}
_currentBaseInteractable = foundBaseInteractable;
if (_currentBaseInteractable != null)
{
_currentBaseInteractable.HightlightAsInteractable(true);
}
}
public void HarvestingState(BaseInteractable aHarvestingResource)
{
if (aHarvestingResource is ResourceInteractable)
{
ResourceInteractable resource = (ResourceInteractable)aHarvestingResource;
runningRoutine = HarvestingRoutine(resource);
StartCoroutine(runningRoutine);
}
else
{
ChangeState(PlayerState.NORMAL, Vector3.zero);
}
}
protected virtual void HoverEnter(BaseInteractable interactable)
{
var model = interactable.GetComponent <T>();
if (model == null)
{
return;
}
m_HoverInteractable = interactable;
m_HoverModel = model;
m_HoverModel.onChanged += ModelChanged;
SetModel(model);
}
// Update is called once per frame
void Update()
{
target.text = "";
if (interactablesInRange.Count == 0)
{
return;
}
float minDistance = float.MaxValue;
BaseInteractable closest = null;
foreach (BaseInteractable interactable in interactablesInRange)
{
var center = interactable.center != null ? interactable.center.position : interactable.transform.position;
var relativePos = this.transform.InverseTransformPoint(center);
if (relativePos.z < 0)
{
continue;
}
float angle = Vector3.Angle(Vector3.forward, relativePos.normalized);
this.debug = angle;
if (angle > maxInteractAngle)
{
continue;
}
if (angle < minDistance)
{
minDistance = angle;
closest = interactable;
}
}
if (closest == null)
{
return;
}
target.text = closest.gameObject.name;
if (!Input.GetButtonDown("Interact"))
{
return;
}
closest.Interact(inventory, miniGameManager);
}
private void ReplenishingState(BaseInteractable interactable, Vector3 rayHitPoint)
{
if (interactable is PlayerResourceInteractable)
{
PlayerResourceInteractable resource = (PlayerResourceInteractable)interactable;
if (resource.ReplenishType == PlayerResoureType.STAMINA)
{
mResources.DepleteResource(PlayerResoureType.HUNGER, true);
mResources.DepleteResource(PlayerResoureType.THIRST, true);
}
runningRoutine = ResourceReplenishRoutine(resource, rayHitPoint);
StartCoroutine(runningRoutine);
}
else
{
ChangeState(PlayerState.NORMAL, Vector3.zero);
}
}
private void HoverExit(BaseInteractable interactable)
{
m_Graphic.color = m_NormalColor;
}
private void HoverEnter(BaseInteractable interactable)
{
m_Graphic.color = m_HoverColor;
}
private IEnumerator HarvestingRoutine(BaseInteractable aHarvestingResource)
{
float timer = 0;
this._rigidBody.velocity = Vector3.zero;
Debug.Log("HarvestingRoutine");
ResourceInteractable resource = (ResourceInteractable)aHarvestingResource;
float harvestingTime = resource.HarvestingTime;
ProgressBar bar = UIManager.Instance.GetProgressBar(resource.gameObject);
while (timer <= harvestingTime)
{
bar.SetProgress(timer / harvestingTime);
timer += Time.deltaTime;
yield return(null);
}
Destroy(bar.gameObject);
if (mInventory.ContainsItem(resource.itemScriptableObject))
{
for (int i = 0; i < mInventory.m_Items.Count; i++)
{
if (mInventory.m_Items[i].ItemType == ItemType.RESOURCE && mInventory.m_Items[i].ResourceType == resource.ResourceType)
{
mInventory.m_Items[i].IncreaseQuantity(resource.Interact(mInventory.GetCurrentItem()));
}
}
}
else
{
//Create a new item
Item newItem = Instantiate(resource.itemScriptableObject);
newItem.IncreaseQuantity(resource.Interact(mInventory.GetCurrentItem()));
mInventory.AddNewItem(newItem);
}
if (resource.secondaryHarvest)
{
if (mInventory.ContainsItem(resource.secondaryHarvestItem))
{
for (int i = 0; i < mInventory.m_Items.Count; i++)
{
if (mInventory.m_Items[i].ItemType == ItemType.RESOURCE && mInventory.m_Items[i].ResourceType == resource.SecondaryResourceType)
{
mInventory.m_Items[i].IncreaseQuantity(resource.Interact(mInventory.GetCurrentItem()));
}
}
}
else
{
//Create a new item
Item newItem = Instantiate(resource.secondaryHarvestItem);
newItem.IncreaseQuantity(resource.Interact(mInventory.GetCurrentItem()));
mInventory.AddNewItem(newItem);
}
}
resource.ItemHarvested();
if (resource.limitedResource)
{
if (resource.DepletedResource)
{
Destroy(resource.gameObject);
}
}
mResources.DepleteResource(PlayerResoureType.STAMINA, true);
//Do the harvesting things
ChangeState(PlayerState.NORMAL, Vector3.zero);
yield return(null);
}
