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]))));
}
