private void OnCollisionEnter(Collision other)
{
var damageable = other.gameObject.GetComponent <IDamageable>();
if (damageable == null)
{
damageable = other.gameObject.GetComponentInParent <IDamageable>();
}
damageable?.TakeDamage(transform.position, _hitForce);
var particleSystem = Instantiate(particles, transform.position, Quaternion.identity);
if (particleSystem == null)
{
Debug.LogError("Missing particle system prefab");
}
else
{
var systems = particleSystem.GetComponentsInChildren <ParticleSystem>();
foreach (var s in systems)
{
s.Play();
}
}
_audioPool.PlayAudioEvent(_audio, transform.position);
var ship = other.gameObject.GetComponentInParent <ShipCondition>();
if (Physics.Raycast(transform.position, Vector3.down, out RaycastHit hit, 10f))
{
if (hit.collider.gameObject.GetComponent <InteractableItem>())
{
Destroy(gameObject);
return;
}
if (hit.collider.gameObject.GetComponentInParent <ShipCondition>())
{
var pos = hit.point;
if (createsHoles)
{
ContactPoint contact = other.contacts[0];
Quaternion rotation = Quaternion.FromToRotation(Vector3.up, contact.normal);
var hole = Instantiate(holePrefab, pos, rotation);
hole.transform.SetParent(hit.transform);
hole.transform.localRotation = Quaternion.identity;
}
if (causesFire)
{
var fire = Instantiate(firePrefab, pos, Quaternion.identity);
fire.transform.SetParent(hit.transform);
fire.transform.localRotation = Quaternion.identity;
}
ship?.TakeDamage();
}
}
Destroy(gameObject);
}
private List <HITSSegment> GenerateHITSSegments(List <WayPointPath> wayPointPathList)
{
List <HITSSegment> hitsSegments = new List <HITSSegment>();
var distanceBetweenLastGateAndWayPointEndPoint = 0f;
foreach (var wayPointPath in wayPointPathList)
{
HITSSegment previousHitsSegment = null;
while (previousHitsSegment == null || (wayPointPath.endPoint.transform.position - previousHitsSegment.startPoint).magnitude > distanceBetweenGates)
{
Vector3 startRot = Vector3.left;
if (previousHitsSegment == null)
{
var startPoint = wayPointPath.startPoint.transform.position + (wayPointPath.Heading * (distanceBetweenGates - distanceBetweenLastGateAndWayPointEndPoint));
var endPoint = startPoint + (wayPointPath.Heading * distanceBetweenGates);
previousHitsSegment = new HITSSegment(startPoint, endPoint, Quaternion.FromToRotation(startRot, wayPointPath.Heading));
hitsSegments.Add(previousHitsSegment);
}
else
{
previousHitsSegment = new HITSSegment(previousHitsSegment.endPoint, previousHitsSegment.endPoint + (wayPointPath.Heading * distanceBetweenGates), Quaternion.FromToRotation(startRot, wayPointPath.Heading));
hitsSegments.Add(previousHitsSegment);
}
}
distanceBetweenLastGateAndWayPointEndPoint = (wayPointPath.endPoint.transform.position - previousHitsSegment.startPoint).magnitude;
}
return(hitsSegments);
}
private void LateUpdate()
{
//Must be the local player to animate through here
if (!isLocalPlayer)
{
return;
}
foreach (SimpleBodyPartLookAt part in LookAt)
{
part.MoveTarget();
Vector3 forward = transform.TransformDirection(Vector3.forward).normalized;
Vector3 toOther = (part.target.position - transform.position).normalized;
Vector3 targetLookAt = part.target.position - part.transform.position;
Quaternion targetRotation = Quaternion.FromToRotation(forward, targetLookAt.normalized);
targetRotation = Quaternion.RotateTowards(part.currentRot, targetRotation, Time.deltaTime * part.rotationSpeed * Mathf.Rad2Deg);
float targetAngle = Mathf.Abs(Quaternion.Angle(Quaternion.identity, targetRotation));
if (targetAngle > part.minRotationLimit && targetAngle < part.maxRotationLimit)
{
part.currentRot = targetRotation;
}
part.transform.localRotation = part.currentRot;
}
// TODO: Might eventually want more animation options. E.g. when in 0-gravity and 'clambering' via a surface
//characterAnimator.SetBool("Floating", false); // Note: Player can be floating and still move
}
private void Update()
{
_leftHand = InputDevices.GetDeviceAtXRNode(XRNode.LeftHand);
_leftHand.TryGetFeatureValue(CommonUsages.trigger, out var triggerVal);
if (triggerVal >= triggerThreshold && !_isRotating)
{
OnTriggerDown();
}
if (triggerVal < triggerThreshold && _isRotating)
{
OnTriggerUp();
}
if (!_isRotating)
{
return;
}
_leftHand.TryGetFeatureValue(CommonUsages.devicePosition, out var currentPosition);
currentPosition += cameraContainer.transform.position;
var tmpRotation = Quaternion.FromToRotation(_controllerReference, currentPosition);
transform.Rotate(tmpRotation.eulerAngles, Space.World);
_controllerReference = currentPosition;
}
private void DrawArrowFromSourceToTarget(Vector2 source, Vector2 target)
{
GameObject arrow = Instantiate(arrowObject, (source + target) / 2, Quaternion.identity, this.transform);
var angle = Quaternion.FromToRotation(new UnityEngine.Vector3(1, 0, 0), target - source);
arrow.transform.rotation = angle;
}
/*
* Accelorometer Calibration: https://forum.unity.com/threads/input-acceleration-calibration.317121/
*/
public void Calibrate()
{
Quaternion rotate = Quaternion.FromToRotation(new Vector3(0.0f, 0.0f, -1.0f), Input.acceleration);
Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, rotate, new Vector3(1.0f, 1.0f, 1.0f));
this.baseMatrix = matrix.inverse;
}
// Update is called once per frame
public void RefreshPositionPlane()
{
Vector3 p = Vector3.zero;
p[axis] = atom.transform.localPosition[axis];
frontPlane.transform.localPosition = p;
backPlane.transform.localPosition = p;
frontPlane.transform.localRotation = Quaternion.FromToRotation(Vector3.forward, Normal());
backPlane.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Normal());
}
void LookAtAnchor()
{
if (!_anchor || !_movementMotor.TargetToMove)
{
return;
}
var targetRot = Quaternion.FromToRotation(Vector3.forward, (_anchor.position - _movementMotor.TargetToMove.position).normalized);
_movementMotor.TargetToMove.GetChild(0).rotation = Quaternion.Slerp(_movementMotor.TargetToMove.GetChild(0).rotation, targetRot, Time.deltaTime * 14f);
}
public void RefreshPositionLine()
{
Vector3 p = Vector3.zero;
p[(axis + 1) % 3] = atom.transform.localPosition[(axis + 1) % 3];
p[(axis + 2) % 3] = atom.transform.localPosition[(axis + 2) % 3];
frontLine.transform.localPosition = p;
backLine.transform.localPosition = p;
frontLine.transform.localRotation = Quaternion.FromToRotation(Vector3.up, Normal());
backLine.transform.localRotation = Quaternion.FromToRotation(Vector3.up, Normal());
backLine.transform.Rotate(0, 180, 0, Space.Self);
}
public void RefreshPositionSlice()
{
Transform frontDottedSlice = this.frontDottedSlice;
Transform backDottedSlice = this.backDottedSlice;
frontDottedSlice.localRotation = Quaternion.FromToRotation(Vector3.forward, sliceNormal);
backDottedSlice.localRotation = Quaternion.FromToRotation(Vector3.back, sliceNormal);
float r = atom.distanceToMolecularParent * 2;
frontDottedSlice.transform.localScale =
backDottedSlice.transform.localScale = new Vector3(r, r, r);
frontDottedSlice.transform.localPosition =
backDottedSlice.transform.localPosition = atom.molecularParent.transform.localPosition;
}
private void FixedUpdate()
{
Vector2 playerGravityUp = (player.transform.position - planetBody.transform.position).normalized;
Vector2 playerBodyUp = player.transform.up;
//Finds the right angle to set the body to
targetRotation = Quaternion.FromToRotation(playerBodyUp, playerGravityUp) * player.transform.rotation;
if (enemyTransform != null)
{
Vector2 enemyGravityUp = (enemyTransform.position - planetBody.transform.position).normalized;
Vector2 enemyBodyUp = enemyTransform.up;
enemyTargetRotation = Quaternion.FromToRotation(enemyBodyUp, enemyGravityUp) * enemyTransform.rotation;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Start()
{
vInterface = ImagingInterface.GetInterface(ContextProvider.Context,
"/camera/" + (IsLeft ? "left" : "right"));
vInterface.StateChanged += HandleChanged;
vTex = new Texture2D(ImageWidth, ImageHeight);
var mat = new Material(Shader.Find("Diffuse"));
mat.mainTexture = vTex;
vGameObj = GameObject.CreatePrimitive(PrimitiveType.Quad);
vGameObj.transform.SetParent(gameObject.transform, false);
vGameObj.transform.localRotation = Quaternion.FromToRotation(Vector3.down, Vector3.forward);
vGameObj.transform.localScale = new Vector3(1, (float)ImageHeight / ImageWidth, 1) * 0.06f;
vGameObj.GetComponent <MeshRenderer>().material = mat;
}
/// <summary>
/// Moves the current tower to the mouse pointer.
/// </summary>
private void MoveCurrentObjectToMouse()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
var layerMask = LayerMask.GetMask("Ground", "Path", "Tower", "SeenGround", "Base", "Obstacle");
Physics.Raycast(ray, out hitInfo, Mathf.Infinity, layerMask);
if (hitInfo.transform != null)
{
_currentPlacedTower.transform.localPosition = hitInfo.point;
_currentPlacedTower.transform.rotation = Quaternion.FromToRotation(Vector3.up, hitInfo.normal);
if (hitInfo.transform.gameObject.layer == LayerMask.NameToLayer(_placementLayer))
{
_currentPlacedTower.IsPlaceable();
}
else
{
_currentPlacedTower.IsUnplaceable();
}
}
}
public void RefreshPositionDottedCircle()
{
Vector3 fatherPos = atom.molecularParent.transform.localPosition;
Vector3 childPos = atom.transform.localPosition;
Vector3 p = fatherPos;
p[axis] = childPos[axis];
frontDottedCircle.transform.localPosition = p;
backDottedCircle.transform.localPosition = p;
float targetDistance = atom.distanceToMolecularParent;
float k = childPos[axis] - fatherPos[axis];
float r = Mathf.Sqrt(Mathf.Abs(targetDistance * targetDistance - k * k)) * 2;
frontDottedCircle.transform.localScale =
backDottedCircle.transform.localScale = new Vector3(r, r, r);
frontDottedCircle.transform.localRotation = Quaternion.FromToRotation(Vector3.forward, Normal());
backDottedCircle.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Normal());
}
public void SetFromToRotation(Vector3 fromDirection, Vector3 toDirection)
{
this = Quaternion.FromToRotation(fromDirection, toDirection);
}
public static Vector3 TransformDirection(this Vector3 self, Vector3 forward)
{
return(Quaternion.FromToRotation(V_FORWARD, self) * forward);
}
void RotateAsSpeed()
{
var targetRot = Quaternion.FromToRotation(-Vector3.forward, _rigidbody.velocity.normalized);
transform.GetChild(0).rotation = Quaternion.Slerp(transform.GetChild(0).rotation, targetRot, Time.deltaTime * 14f);
}
public void MoveStep()
{
if (!initialized)
{
return;
}
World.worldInstance.GatherEntities(currentTile, maxNeighborRadius, ref _neighbors);
_neighbors.Remove(this);
// Randomly choose 5
while (_neighbors.Count > 5)
{
_neighbors.RemoveAt((int)UnityEngine.Random.Range(0.0f, _neighbors.Count - 0.1f));
}
foreach (var moveInfluencer in movementInfluencers)
{
moveInfluencer.Setup(_neighbors);
}
Vector3 totalInfluence = Vector3.zero;
foreach (var moveInfluencer in movementInfluencers)
{
var influence = moveInfluencer.GetInfluenceVector();
if (float.IsNaN(influence.x) || float.IsNaN(influence.y) || float.IsNaN(influence.z))
{
continue;
}
totalInfluence += influence;
}
velocity += totalInfluence * Time.deltaTime;
velocity.y = 0;
float sqrMag = velocity.sqrMagnitude;
if (!float.IsNaN(sqrMag) && sqrMag > 0.001f && sqrMag > typeInfo.speedRange.y * typeInfo.speedRange.y)
{
velocity = velocity.normalized * typeInfo.speedRange.y;
}
transform.position += velocity * Time.deltaTime;
if (!float.IsNaN(sqrMag) && sqrMag > 0.001f)
{
transform.rotation = Quaternion.FromToRotation(Vector3.forward, velocity);
}
if (animator != null)
{
animator.SetFloat("speed", velocity.magnitude);
}
if (World.worldInstance != null)
{
var size = World.worldInstance.worldSize;
var pos = position;
if (pos.x < 0)
{
pos.x += size;
}
if (pos.x > size)
{
pos.x -= size;
}
if (pos.z < 0)
{
pos.z += size;
}
if (pos.z > size)
{
pos.z -= size;
}
transform.position = pos;
}
var cell = World.worldInstance.GetCellFromPosition(transform.position);
if (cell != currentTile.myCell)
{
UpdateTile();
}
}
