public static Vector3 PointInsideCircle(Vector3 center, float radius, LayerMask groundLayerMask) { Vector2 new2dPos = Random.insideUnitCircle * radius; Vector3 new3dPos = center + new Vector3(new2dPos.x, 0, new2dPos.y); return(PhysicsUtils.RaycastFromUpToDown(new3dPos, groundLayerMask).point); }
public void Update() { //MainSprite属性设置 mainDebugSprite.pos = rope.A; mainDebugSprite.sprite.rotation = Utils.AimFromOneVectorToAnother(rope.A, rope.B); mainDebugSprite.sprite.scaleY = Vector2.Distance(rope.A, rope.B); //根据Rope.bends列表动态调整Sprite数量 while (sprts.Count > rope.bends.Count + 1) { sprts[sprts.Count - 1].Destroy(); sprts.RemoveAt(sprts.Count - 1); } while (sprts.Count < rope.bends.Count + 1) { sprts.Add(new DebugSprite(rope.A, new FSprite("pixel", true), rope.room)); rope.room.AddObject(sprts[sprts.Count - 1]); sprts[sprts.Count - 1].sprite.anchorY = 0.0f; sprts[sprts.Count - 1].sprite.scaleX = 2f; } //根据前后节点的位置:修改各节点Sprite的旋转、Scale、颜色 for (int i = 0; i < rope.bends.Count + 1; ++i) { //得到前一Bends位置和当前bend位置 Vector2 preBend = i != 0 ? rope.bends[i - 1].pos : rope.A; Vector2 curBend = i != rope.bends.Count ? rope.bends[i].pos : rope.B; //修改当前索引Sprite属性 sprts[i].pos = preBend; sprts[i].sprite.rotation = Utils.AimFromOneVectorToAnother(preBend, curBend); sprts[i].sprite.scaleY = Vector2.Distance(preBend, curBend); sprts[i].sprite.color = !PhysicsUtils.RayTraceTilesForTerrain(rope.room, preBend, curBend) ? new Color(1f, 0.0f, 0.0f) : new Color(0.0f, 1f, 0.1f); } }
virtual protected void CheckRoamingDestinationReached() { if (PhysicsUtils.HasNavAgentReachedDestination(_navMeshAgent)) { SetAnimatorBool(Character.ANIMATOR_BOOL_MOVING, false); } }
public bool Search(out LVector3 found) { found = LVector3.Invalid; if (lookingForBlock || true) { RaycastResults res; for (int i = 0; i < 50; i++) { if (PhysicsUtils.CustomRaycast(transform.position, Random.onUnitSphere, 20.0f, (b, bx, by, bz, pbx, pby, pbz) => { return(true); }, (b, bx, by, bz, pbx, pby, pbz) => { return(DesiredBlock(b)); }, out res)) { found = res.hitBlock; return(true); } } } else { Debug.Log("not looking for block but called search?"); } return(false); }
public void UpdateDashState(State currState, float deltaTime) { m_CurrDashTime -= deltaTime; if (m_CurrDashTime <= 0.0f) { m_PlayerStateMachine.CanChangeState = true; } m_Animation.CrossFade("Run"); if (Vector3.SqrMagnitude(m_LastDashDecalPointAdded - transform.position) >= (m_DecalPointAddDist * m_DecalPointAddDist)) { RaycastHit rayHit; if (PhysicsUtils.RaycastToGround(transform.position, out rayHit)) { m_LastDashDecalPointAdded = rayHit.point; } else { m_LastDashDecalPointAdded = transform.position; } m_CurrentDecal.AddPoint(m_LastDashDecalPointAdded + Vector3.up * m_DecalUpOffset); } m_CurrRunTime = m_RunTimeToDash; }
private void TurnTowards(float seconds, Vector2 target) { float targetAngle = this.GetClosestPointAtAngleInRange(target); float currentAngle = Vector2Utils.MinimizeMagnitude(this.TurretDirectionRelativeToSelf); float maxAngleChange = seconds * this.AngularSpeed; if (this.Range >= Math.PI) { this.TurretDirectionRelativeToSelf = PhysicsUtils.AngularMoveTowardBounded(currentAngle, targetAngle, maxAngleChange); } else { if (Math.Abs(currentAngle - targetAngle) <= maxAngleChange) { this.TurretDirectionRelativeToSelf = targetAngle; } else if (targetAngle < currentAngle) { this.TurretDirectionRelativeToSelf = currentAngle - maxAngleChange; } else { this.TurretDirectionRelativeToSelf = currentAngle + maxAngleChange; } } }
// Check raycast collision public override RaycastHit CheckRay(Vector2 start, Vector2 direction) { Vector2[] points = GetPoints(); Vector2 end = start + direction; LineHit closest = PhysicsUtils.CheckLineCollision(points[3], points[0], start, end); for (int i = 0; i <= 2; i++) { Vector2 p1 = points[i]; Vector2 p2 = points[i + 1]; LineHit hit = PhysicsUtils.CheckLineCollision(p1, p2, start, end); if (hit.hit) { if (!closest.hit || Vector2.Distance(hit.hitPoint, start) < Vector2.Distance(closest.hitPoint, start)) { closest = hit; } } } if (!closest.hit) { return(null); } RaycastHit raycastHit = new RaycastHit(closest.hitPoint, entity, Vector2.Distance(closest.hitPoint, start)); return(raycastHit); }
// End Walk, Run State // ----------------- // ----------------- // Start Dash State public void BeginDashState(State prvState, State newState) { //m_Animation.Play(); //SetCharacterFlag(CharacterFlag.eCF_ResetMoveSpeedAfterUse); CurrentVelocity = new Vector3(0.0f, m_OnGroundYVelocity, 0.0f); m_CurrentDashSpeed = m_DefaultMoveSpeed * m_DashSpeedMultiplier;// Can be current speed. CurrentMoveSpeed = m_CurrentDashSpeed; m_PlayerStateMachine.CanChangeState = false; m_CurrRunTime = m_RunTimeToDash; m_CurrentDecal = m_DecalsManaer.CreateDecal(DecalsManager.DecalsType.DT_Tape); RaycastHit rayHit; if (PhysicsUtils.RaycastToGround(transform.position, out rayHit)) { m_LastDashDecalPointAdded = rayHit.point; } else { m_LastDashDecalPointAdded = transform.position; } m_CurrentDecal.Thickness = m_DecalThickness; m_CurrentDecal.AddPoint(m_LastDashDecalPointAdded + Vector3.up * m_DecalUpOffset); m_CurrentDecal.UpVector = transform.up; m_CurrDashTime = m_MaxDashTime; m_Animation.CrossFade("Run"); m_PlayerHUD.ShowMeter(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var deltaTime = Time.DeltaTime; return(Entities.ForEach((ref Rotation rotation, in MovementOrder movementOrder, in MovementCapabilities movementCapabilities) => { if (math.length(movementOrder.Heading) == 0) { return; } var fwd = math.forward(rotation.Value); var angle = PhysicsUtils.AngleSigned(fwd, movementOrder.Heading); if (math.abs(angle) < float.Epsilon) { return; } var steerAngle = math.sign(angle) * math.radians(movementCapabilities.TurnRate * deltaTime); rotation.Value = math.mul( math.normalize(rotation.Value), quaternion.AxisAngle(math.up(), steerAngle) ); }).Schedule(inputDeps));
public override bool OnCheckObserver(NetworkConnection conn) { Player p; if (_self == null) { _self = GetComponent <Player>(); } if (!GameManager.Instance.GameStarted || (p = conn.identity.GetComponent <Player>()).Lives == 0 || p.SeesEveryone || _self.KilledBy == p) { return(true); } if (forceHidden) { return(false); } Vector3 position = conn.identity.transform.position + new Vector3(0f, 1f, 0f); Vector3 connPosition = transform.position + new Vector3(0f, 1f, 0f); RaycastHit[] hits = Physics.RaycastAll(position, connPosition - position, p.Vision - 1f); Transform nearest = PhysicsUtils.GetNearestHit(hits, conn.identity.transform, PhysicsUtils.HitType.OnlyColliders); return(nearest != null && nearest.transform == transform); }
private void OnDrawGizmos() { if (!_isDoneRaycastToGround) { transform.position = PhysicsUtils.RaycastFromUpToDown(transform.position, Consts.LayerMasks.GroundForUnits).point + new Vector3(0, _positionAboveGround, 0); _isDoneRaycastToGround = true; } }
protected virtual void Init() { Rb = gameObject.GetComponent <Rigidbody>(); _childColliderList = PhysicsUtils.GetAllChildColliders(transform); Transform = transform; _velocityMax = 10; _distMaxForFollowingAngVel = 0.5f; }
void LateUpdate() { if (target) { float x = PhysicsUtils.IncrementTowards(transform.position.x, target.position.x, trackSpeed); float y = PhysicsUtils.IncrementTowards(transform.position.y, target.position.y, trackSpeed); transform.position = new Vector3(x, y, transform.position.z); } }
/// <summary> /// Handles horizontal movement on the XZ plane. /// </summary> /// <param name="horizontalVelocity"></param> /// <param name="entity"></param> /// <param name="currPos"></param> /// <param name="currRot"></param> /// <param name="controller"></param> /// <param name="collider"></param> /// <param name="collisionWorld"></param> private void HandleHorizontalMovement( ref float3 horizontalVelocity, ref Entity entity, ref float3 currPos, ref quaternion currRot, ref CharacterControllerData controller, ref PhysicsCollider collider, ref CollisionWorld collisionWorld) { if (MathUtils.IsZero(horizontalVelocity)) { return; } float3 targetPos = currPos + horizontalVelocity; NativeList <ColliderCastHit> horizontalCollisions = PhysicsUtils.ColliderCastAll(collider, currPos, targetPos, ref collisionWorld, entity, Allocator.Temp); PhysicsUtils.TrimByFilter(ref horizontalCollisions, ColliderData, PhysicsCollisionFilters.DynamicWithPhysical); if (horizontalCollisions.Length > 0) { // We either have to step or slide as something is in our way. float3 step = new float3(0.0f, controller.maxStep, 0.0f); PhysicsUtils.ColliderCast(out ColliderCastHit nearestStepHit, collider, targetPos + step, targetPos, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp); if (!MathUtils.IsZero(nearestStepHit.Fraction)) { // We can step up. targetPos += (step * (1.0f - nearestStepHit.Fraction)); horizontalVelocity = targetPos - currPos; } else { // We can not step up, so slide. NativeList <DistanceHit> horizontalDistances = PhysicsUtils.ColliderDistanceAll(collider, 1.0f, new RigidTransform() { pos = currPos + horizontalVelocity, rot = currRot }, ref collisionWorld, entity, Allocator.Temp); PhysicsUtils.TrimByFilter(ref horizontalDistances, ColliderData, PhysicsCollisionFilters.DynamicWithPhysical); for (int i = 0; i < horizontalDistances.Length; ++i) { if (horizontalDistances[i].Distance >= 0.0f) { continue; } horizontalVelocity += (horizontalDistances[i].SurfaceNormal * -horizontalDistances[i].Distance); } horizontalDistances.Dispose(); } } horizontalCollisions.Dispose(); }
private void OnDrawGizmos() { if (!_isDoneRaycastToGround) { //после остановки игры в редакторе, или при запуске редактора, устанавливает Y позицию в точке, где земля. transform.position = PhysicsUtils.RaycastFromUpToDown(transform.position, Consts.LayerMasks.GroundForUnits).point; _isDoneRaycastToGround = true; } }
private IEnumerator MoveCoroutine() { while (transform.position.y > _targetYpos) { transform.Translate(-Vector3.up * _speed * Time.deltaTime); yield return(new WaitForEndOfFrame()); } transform.position = PhysicsUtils.RaycastFromUpToDown(transform.position, Consts.LayerMasks.BallCollisions).point; Explosion(); }
private BodyInfo GetBodyInfo() { var sizeTransform = Components.GetComponent <ISizeTransform>().AssertNotNull(); var positionTransform = Components.GetComponent <IPositionTransform>().AssertNotNull(); var physicsCollisionNotifier = Components.GetComponent <IPhysicsCollisionNotifier>().AssertNotNull(); var fixtureDefinition = PhysicsUtils.CreateFixtureDefinition(sizeTransform.Size, layerMask, physicsCollisionNotifier); var bodyDefinitionWrapper = PhysicsUtils.CreateBodyDefinitionWrapper(fixtureDefinition, positionTransform.Position, this); bodyDefinitionWrapper.BodyDefiniton.AllowSleep = allowSleep; return(new BodyInfo(Id, bodyDefinitionWrapper)); }
public static T FindNearestTarget <T>(Vector3 seekerPos, float searchRadius, LayerMask targetLayerMask) where T : Component { T[] targets = PhysicsUtils.OverlapSphere <T>(seekerPos, searchRadius, targetLayerMask); if (targets.Length != 0) { T nearTarget = GetNearest(seekerPos, targets); return(nearTarget); } return(null); }
void UpdateTarget() { raycastedPoint = CameraHelper.WalkablePoint(); if (raycastedPoint.Equals(Vector3.negativeInfinity)) { return; } var nextTarget = CameraUtils.RaycastOnlyType(Trigger.Context.Type, 1 << (int)Trigger.Context.Layer); if (nextTarget && nextTarget.transform == playerTransform) { nextTarget = null; } else if (!nextTarget) { nextTarget = PhysicsUtils.NearestCollider( raycastedPoint, Config.SelectorRadius, target => target.GetComponent(Trigger.Context.Type) && target.transform != playerTransform, 1 << (int)Trigger.Context.Layer ); } if (nextTarget) { if (nextTarget != currentTarget) { SelectTarget(nextTarget.transform); } } else if (currentTarget) { UnselectTarget(); } if (!currentTarget) { selectorSprite.transform.position = raycastedPoint; } if (Input.GetKeyUp(Config.FinishKeyCode)) { if (nextTarget) { Trigger.OnTrigger(new Inputs.Event { GameObject = nextTarget.gameObject, Point = Vector3.zero }); } } }
private void UpdatePositionAboveGround() { RaycastHit hit = PhysicsUtils.RaycastFromUpToDown(_newPos, Consts.LayerMasks.GroundForCamera); if (hit.collider != null) { var height = PhysicsUtils.RaycastHeigthFromUpToDown - hit.distance + _positionAboveGround; _newPos.y = height; } else { Debug.LogWarning("Camera position is not over ground", this); } }
public override bool applyContentDimensions(float minScrollExtent, float maxScrollExtent) { if (!PhysicsUtils.nearEqual(this._minScrollExtent, minScrollExtent, Tolerance.defaultTolerance.distance) || !PhysicsUtils.nearEqual(this._maxScrollExtent, maxScrollExtent, Tolerance.defaultTolerance.distance) || this._didChangeViewportDimensionOrReceiveCorrection) { this._minScrollExtent = minScrollExtent; this._maxScrollExtent = maxScrollExtent; this._haveDimensions = true; this.applyNewDimensions(); this._didChangeViewportDimensionOrReceiveCorrection = false; } return(true); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var headingTolerance = SimulationSettings.Instance.headingToleranceToAccelerate; return(Entities.ForEach((ref Rotation rotation, ref Movement movement, in MovementOrder movementOrder) => { // Accelerate only if orientation is within tolerance var fwd = math.forward(rotation.Value); var angle = PhysicsUtils.Angle(fwd, movementOrder.Heading); if (angle <= headingTolerance) { movement.Acceleration = math.normalize(fwd) * PhysicsUtils.GeesToMs2(movementOrder.AccelerationMagnitude); } }).Schedule(inputDeps)); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var leadTime = SimulationSettings.Instance.predictionsLeadTime; return(Entities.ForEach((ref PredictMovement predictMovement, in Position position, in Movement movement) => { var future = PhysicsUtils.PredictFutureState(new PhysicalState() { Position = position.Value, Velocity = movement.Velocity, Acceleration = movement.Acceleration }, leadTime); predictMovement.Position = future.Position; predictMovement.Velocity = future.Velocity; }).Schedule(inputDeps));
public override void SubclassUpdate(float seconds) { base.SubclassUpdate(seconds); this.Position = this.Position + (this.Velocity * seconds); if (this.TargetAngle <= Math.PI * 2 && this.TargetAngle >= 0) { float changeInAngle = (float)(seconds * this.AngularSpeed); this.Direction = PhysicsUtils.AngularMoveTowardBounded(this.Direction, this.TargetAngle, changeInAngle); } else { this.Direction = this.Direction + (float)(seconds * this.AngularSpeed); } }
/// <summary> /// Handles vertical movement from gravity and jumping. /// </summary> /// <param name="entity"></param> /// <param name="currPos"></param> /// <param name="currRot"></param> /// <param name="controller"></param> /// <param name="collider"></param> /// <param name="collisionWorld"></param> private void HandleVerticalMovement( ref float3 verticalVelocity, ref Entity entity, ref float3 currPos, ref quaternion currRot, ref CharacterControllerData controller, ref PhysicsCollider collider, ref CollisionWorld collisionWorld, float DeltaTime) { controller.verticalVelocity = verticalVelocity; if (MathUtils.IsZero(verticalVelocity)) { return; } verticalVelocity *= DeltaTime; NativeList <ColliderCastHit> verticalCollisions = PhysicsUtils.ColliderCastAll(collider, currPos, currPos + verticalVelocity, ref collisionWorld, entity, Allocator.Temp); PhysicsUtils.TrimByFilter(ref verticalCollisions, ColliderData, PhysicsCollisionFilters.DynamicWithPhysical); if (verticalCollisions.Length > 0) { RigidTransform transform = new RigidTransform() { pos = currPos + verticalVelocity, rot = currRot }; if (PhysicsUtils.ColliderDistance(out DistanceHit verticalPenetration, collider, 1.0f, transform, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp)) { if (verticalPenetration.Distance < -0.01f) { verticalVelocity += (verticalPenetration.SurfaceNormal * verticalPenetration.Distance); if (PhysicsUtils.ColliderCast(out ColliderCastHit adjustedHit, collider, currPos, currPos + verticalVelocity, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp)) { verticalVelocity *= adjustedHit.Fraction; } } } } verticalVelocity = MathUtils.ZeroOut(verticalVelocity, 0.0001f); verticalCollisions.Dispose(); }
void Initialize() { // If no body was manually assigned, see if the parents have one if (!_body) { _body = PhysicsUtils.GetRigidBodyInParents(transform); if (!_body) { _initialized = false; Debug.LogError(string.Format("Suspension '{0}' failed to initialize, no rigidbody assigned or found in hierarchy", name)); } } if (_body) { _initialized = true; } }
public static void DrawSquareGrid(Vector3 center, float size, float countCells) { #if UNITY_EDITOR Vector3 gridCenter = center + new Vector3(-size / 2f + 0.5f, 0f, -size / 2f + 0.5f); for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { if (countCells <= i * size + j) { return; } var cellCenter = PhysicsUtils.RaycastFromUpToDown(gridCenter + new Vector3(i, 0, j), Consts.LayerMasks.GroundForUnits).point; Gizmos.DrawCube(cellCenter, new Vector3(0.9f, 1f, 0.9f)); } } #endif }
// Find the hitpoints of two colliding polygons via Line collision public Vector2[] FindPolygonHitpoints(Line[] poly1, Line[] poly2) { List <Vector2> collisionPoints = new List <Vector2>(); foreach (Line line1 in poly1) { foreach (Line line2 in poly2) { LineHit lineHit = PhysicsUtils.CheckLineCollision(line1.p1, line1.p2, line2.p1, line2.p2); if (lineHit.hit) { collisionPoints.Add(lineHit.hitPoint); } } } return(collisionPoints.ToArray()); }
void Update() { targetSpeed = getHorizontalMovement() * speed; currentSpeed = PhysicsUtils.IncrementTowards(currentSpeed, targetSpeed, acceleration); if (playerPhysics.grounded) { amountToMove.y = 0; if (isJumping()) { amountToMove.y = jumpHeight; } } amountToMove.x = currentSpeed; amountToMove.y -= gravity * Time.deltaTime; playerPhysics.Move(amountToMove * Time.deltaTime); }
private float SecondaryGrabPosScore(IntVector2 testPos) { //没有抓取目标 or 测试点太近 if (!this.GrabDest.HasValue || testPos.FloatDist(this.BasePos) < 7.0) { return(0.0f); } float num1 = this.idealLength - grabPath.Count * 20f; if (Vector2.Distance(this.room.MiddleOfTile(testPos), this.floatGrabDest.Value) > (double)num1 || !PhysicsUtils.RayTraceTilesForTerrain(this.room, this.GrabDest.Value, testPos)) { return(0.0f); } //测试点周围8方向存在Solid +分 float num2 = 0.0f; for (int index = 0; index < 8; ++index) { if (this.room.GetTile(testPos + Utils.eightDirections[index]).Solid) { ++num2; } } //如果测试点地形是Beam 加分 if (this.room.GetTile(testPos).horizontalBeam || this.room.GetTile(testPos).verticalBeam) { ++num2; } //如果测试分 大于0 且测试点等于次级抓取点 加分 if (num2 > 0.0 && testPos == this.secondaryGrabPos) { ++num2; } if (num2 == 0.0) { return(0.0f); } //复杂计算:分数、距离、索引节等等 return((num2 + testPos.FloatDist(this.BasePos) / 10f) / (1f + Mathf.Abs(num1 * 0.75f - Vector2.Distance(this.room.MiddleOfTile(testPos), this.floatGrabDest.Value)) + Vector2.Distance(this.room.MiddleOfTile(testPos), this.room.MiddleOfTile(this.segments[this.segments.Count - 1])))); }