public void ZapperCharged()
{
Transmissible thisTransmissable = GetComponent <Transmissible>();
if (thisTransmissable.type.name == "Energy" && !alreadyUsed)
{
Debug.Log("Charged with energy!");
StartCoroutine(ZapperActive());
}
}
public void CheckType()
{
Transmissible thisTransmissable = GetComponent <Transmissible>();
if (thisTransmissable.type.name == requiredType)
{
TypeCorrect.Invoke();
}
else if (thisTransmissable.type.name != requiredType)
{
TypeIncorrect.Invoke();
}
}
void OnTriggerEnter(Collider collider)
{
Audible audible = collider.GetComponent <Audible>();
if (audible)
{
audible.SoundEvent("Footstep", transform.position);
}
Transmissible t = collider.GetComponent <Transmissible>();
if (t && t.type.audibleType && t.progress == 1 && m_player.isGrounded == true && m_player.inFluid == false)
{
Audible.SoundEvent(t.type.audibleType, "Footstep", transform.position);
}
}
// Update is called once per frame
void FixedUpdate()
{
bool prevGrounded = m_grounded;
m_grounded = false;
m_ground = null;
// Check if we're floating in something
Collider[] colliders = Physics.OverlapSphere(m_rigidbody.position, m_collider.radius, m_groundMask);
foreach (var c in colliders)
{
Transmissible t = c.GetComponent <Transmissible>();
if (t && t.progress == 1 && t.type.bouyancy > 0)
{
m_grounded = true;
m_ground = t.gameObject;
m_groundNormal = Vector3.up;
}
}
if (m_grounded == false)
{
RaycastHit[] hits = Physics.SphereCastAll(m_rigidbody.position,
m_collider.radius - 0.01f,
Vector3.down,
m_collider.height / 2 - m_collider.radius + 0.02f,
m_groundMask,
QueryTriggerInteraction.Ignore);
foreach (RaycastHit hit in hits)
{
if (hit.normal.y > 0.5f)
{
float distanceFromRim = Mathf.Abs((m_rigidbody.position.y - m_collider.height / 2) - hit.point.y);
distanceFromRimDebug = distanceFromRim;
if (distanceFromRim < 0.25f)
{
m_grounded = true;
m_ground = hit.collider.gameObject;
m_groundNormal = hit.normal;
}
break;
}
}
}
Vector2 localDir = m_input.movement;
// TODO: Check grounded state
Vector3 force = (Camera.main.transform.right * localDir.x + Camera.main.transform.forward * localDir.y);
if (m_stunTimer > 0)
{
m_stunTimer -= Time.deltaTime;
force.x = 0;
force.z = 0;
}
force.y = 0;
if (force.magnitude > 0)
{
force.Normalize();
bool abyss = false;
if (m_fallPreventionEnabled)
{
RaycastHit[] hits = Physics.SphereCastAll(m_rigidbody.position + force * m_collider.radius * 2, m_collider.radius, Vector3.down, 100, m_groundMask);
abyss = true;
foreach (RaycastHit hit in hits)
{
// Solid object or bouyand object
Transmissible t = hit.collider.GetComponent <Transmissible>();
if (t)
{
if ((t.type.hasCollisions == true || (t.type.bouyancy > 0 && t.progress == 1)))
{
abyss = false;
break;
}
}
else if (hit.collider.isTrigger == false)
{
abyss = false;
break;
}
}
}
if (m_grounded)
{
Vector3 right = Vector3.Cross(force, Vector3.up);
force = Vector3.Cross(m_groundNormal, right);
}
if (abyss)
{
force = Vector3.zero;
}
m_rigidbody.AddForce(force * m_maxForce);
}
Vector3 velocity = m_rigidbody.velocity;
float vy = velocity.y;
velocity.y = 0;
if (velocity.magnitude > m_maxVelocity)
{
velocity = velocity.normalized * m_maxVelocity;
}
//m_rigidbody.drag = velocity.magnitude / m_drag;
if (velocity.magnitude > 0.25f && m_stunTimer <= 0)
{
m_angle = Mathf.Atan2(velocity.x, velocity.z) * Mathf.Rad2Deg;
}
transform.localEulerAngles = new Vector3(0, m_angle, 0);
velocity *= m_friction;
if (m_grounded && m_ground)
{
if (prevGrounded == false)
{
Audible a = m_ground.GetComponent <Audible>();
if (a)
{
a.SoundEvent("Land", transform.position);
}
Transmissible t = m_ground.GetComponent <Transmissible>();
if (t && t.type.audibleType && t.progress == 1)
{
Audible.SoundEvent(t.type.audibleType, "Land", transform.position);
}
}
if (inFluid)
{
if (m_input.wasJumpPressed)
{
velocity.y = Mathf.Lerp(velocity.y, m_waterJumpSpeed, 0.25f);
}
else
{
velocity.y = vy;
}
m_animator.SetFloat("Speed", 0.0f);
m_animator.SetFloat("Speed2", 0.1f);
}
else
{
velocity.y = 0;
if (m_input.wasJumpPressed)
{
m_grounded = false;
// TODO: check water
velocity.y = m_jumpSpeed;
m_animator.SetTrigger("Jump");
}
m_animator.SetFloat("Speed", velocity.magnitude / m_maxVelocity);
m_animator.SetFloat("Speed2", 0.1f + (velocity.magnitude / m_maxVelocity) * 1.5f);
}
}
else
{
velocity.y = vy;
m_animator.SetFloat("Speed", 0.5f);
m_animator.SetFloat("Speed2", 0.1f);
}
m_animator.SetFloat("YSpeed", velocity.y);
m_animator.SetBool("Grounded", m_grounded && !inFluid);
m_animator.SetBool("InFluid", inFluid);
m_rigidbody.velocity = velocity;
}
Transmissible DetectObject()
{
Vector3 origin = transform.position;
Vector3 dir = transform.forward;
Transmissible minTarget = null;
float minAngle = 0;
for (int i = 0; i < m_rays; i++)
{
float rayAngle = -m_detectionSpread + (m_detectionSpread * 2.0f) * (i / (float)m_rays);
Vector3 dir2 = Quaternion.AngleAxis(rayAngle, Vector3.up) * dir;
Vector3 hitPoint = origin + dir2 * m_detectionDistance;
Color hitColor = Color.gray;
RaycastHit hit;
if (Physics.Raycast(origin, dir2, out hit, m_detectionDistance, m_detectionMask))
{
Transmissible t = hit.collider.gameObject.GetComponent <Transmissible>();
if (t)
{
hitPoint = hit.point;
if (minTarget == null || Mathf.Abs(rayAngle) < minAngle)
{
minTarget = t;
minAngle = Mathf.Abs(rayAngle);
hitColor = Color.yellow;
m_targetHitPoint = minTarget.transform.InverseTransformPoint(hit.point);
m_targetHitNormal = hit.normal;
}
}
}
Debug.DrawLine(origin, hitPoint, hitColor);
}
if (minTarget == null)
{
minAngle = 0;
for (int i = 0; i < m_rays; i++)
{
float rayAngle = -m_detectionSpread + (m_detectionSpread * 2.0f) * (i / (float)m_rays);
Vector3 dir2 = Quaternion.AngleAxis(30, transform.right) * Quaternion.AngleAxis(rayAngle, Vector3.up) * dir;
Vector3 hitPoint = origin + dir2 * m_detectionDistance;
Color hitColor = Color.gray;
RaycastHit hit;
if (Physics.Raycast(origin, dir2, out hit, m_detectionDistance, m_detectionMask))
{
Transmissible t = hit.collider.gameObject.GetComponent <Transmissible>();
if (t)
{
hitPoint = hit.point;
if (minTarget == null || Mathf.Abs(rayAngle) < minAngle)
{
minTarget = t;
minAngle = Mathf.Abs(rayAngle);
hitColor = Color.yellow;
m_targetHitPoint = minTarget.transform.InverseTransformPoint(hit.point);
m_targetHitNormal = hit.normal;
}
}
}
Debug.DrawLine(origin, hitPoint, hitColor);
}
}
if (minTarget)
{
// Reject direct down hits
RaycastHit hit;
if (Physics.Raycast(origin, -Vector3.up, out hit, m_detectionDistance, m_detectionMask))
{
if (hit.collider.GetComponent <Transmissible>() == minTarget)
{
minTarget = null;
}
}
}
return(minTarget);
}
public void DetectObjects()
{
if (m_target)
{
m_target.GetComponent <Highlightable>().highlighted = false;
}
Transmissible newTarget = DetectObject();
if (m_target != newTarget)
{
if (m_target)
{
if (m_target.state == Transmissible.State.Infusing)
{
m_target.EndInfuse();
m_tank.EndDrain();
}
else if (m_target.state == Transmissible.State.Draining)
{
m_target.EndDrain();
m_tank.EndInfuse();
}
}
}
if (newTarget)
{
m_target = newTarget;
m_target.GetComponent <Highlightable>().highlighted = true;
m_source.pitch = m_target.progress + 0.5f;
m_source.volume = m_soundCurve.Evaluate(m_target.progress);
}
else
{
m_target = null;
}
if (m_input.isDrainPressed && m_target && m_currentType == null)
{
if (m_target.state == Transmissible.State.Full)
{
//m_source.clip = m_target.type.drainClip;
m_source.Play();
TransmissibleType type = m_target.BeginDrain((Transmissible t) =>
{
m_currentType = t.type;
});
m_tank.BeginInfuse(m_target.type, (Transmissible t) => { });
}
}
else if (!m_input.isDrainPressed && m_target && m_target.state == Transmissible.State.Draining)
{
m_target.EndDrain();
m_tank.EndInfuse();
}
else if (m_input.isInfusePressed && m_target && m_target.state == Transmissible.State.Empty && m_currentType != null)
{
//m_source.clip = m_target.type.infuseClip;
m_source.Play();
m_target.BeginInfuse(m_currentType, (Transmissible t) =>
{
// TODO: update visuals
m_currentType = null;
});
m_tank.BeginDrain((Transmissible t) => { });
}
else if (!m_input.isInfusePressed && m_target && m_target.state == Transmissible.State.Infusing)
{
m_target.EndInfuse();
m_tank.EndDrain();
}
//m_prevObjects = objects;
}
