public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance) { float positiveInfinity = float.PositiveInfinity; float negativeInfinity = float.NegativeInfinity; int layerMask = -5; return CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, negativeInfinity, positiveInfinity); }
public static void DrawCapsuleCast2DHits(RaycastHit2D[] hits, Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, Color color, int maxCount = -1) { if (maxCount < 0) { maxCount = hits.Length; } if (maxCount == 0) { return; } direction.EnsureNormalized(); DrawCapsuleStructure2D capsuleStructure2D = new DrawCapsuleStructure2D(size, capsuleDirection, angle); for (int i = 0; i < maxCount; i++) { DrawCapsule2DFast(origin + direction * hits[i].distance, capsuleStructure2D, DrawLine); } void DrawLine(Vector3 a, Vector3 b, float v) => lineDelegate(a, b, color); }
public static void DrawCapsule(Vector2 position, Vector2 size, CapsuleDirection2D direction, float angle, Color color, bool debug, float duration) { Quaternion rotation = Quaternion.Euler(0, 0, angle); Vector2 colliderDirectionVector = rotation * (direction == CapsuleDirection2D.Vertical ? Vector2.up : Vector2.right); Vector2 colliderDirectionPerpendicularVector = rotation * (direction == CapsuleDirection2D.Vertical ? Vector2.right : Vector2.up); float radius = (direction == CapsuleDirection2D.Vertical ? size.x : size.y) / 2.0f; float boxHeight = 2 * Mathf.Max(0.0f, direction == CapsuleDirection2D.Vertical ? (size.y / 2.0f - radius) : (size.x / 2.0f - radius)); Vector2 colliderCircleA = colliderDirectionVector * boxHeight / 2.0f + position; Vector2 colliderCircleB = -colliderDirectionVector * boxHeight / 2.0f + position; float circleAAngleStart = angle + (direction == CapsuleDirection2D.Vertical ? 0.0f : -90.0f); float circleAAngleEnd = angle + (direction == CapsuleDirection2D.Vertical ? 180.0f : 90.0f); float circleBAngleStart = angle + (direction == CapsuleDirection2D.Vertical ? 180.0f : 90.0f); float circleBAngleEnd = angle + (direction == CapsuleDirection2D.Vertical ? 360.0f : 270.0f); DrawCircle(colliderCircleA, radius, color, circleAAngleStart, circleAAngleEnd, debug, duration); DrawCircle(colliderCircleB, radius, color, circleBAngleStart, circleBAngleEnd, debug, duration); DrawLine(colliderDirectionPerpendicularVector * radius + colliderDirectionVector * boxHeight / 2.0f + position, colliderDirectionPerpendicularVector * radius - colliderDirectionVector * boxHeight / 2.0f + position, color, debug, duration); DrawLine(-colliderDirectionPerpendicularVector * radius + colliderDirectionVector * boxHeight / 2.0f + position, -colliderDirectionPerpendicularVector * radius - colliderDirectionVector * boxHeight / 2.0f + position, color, debug, duration); }
public static void DrawCapsule2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Color color, float duration = 0) { DrawCapsuleStructure2D capsuleStructure2D = new DrawCapsuleStructure2D(size, capsuleDirection, angle); DrawCapsule2DFast(origin, capsuleStructure2D, DrawLine); void DrawLine(Vector3 a, Vector3 b, float t) => lineDelegate(a, b, color, duration); }
Rigidbody2D FindFloor() { bIsOnGround = false; CapsuleDirection2D Dir = CapsuleDirection2D.Vertical; if (Size.x > Size.y) { Dir = CapsuleDirection2D.Horizontal; } LayerMask Mask = LayerMask.GetMask("Gameplay"); //bIsOnGround = Physics2D.OverlapCapsule(transform.position, Size, Dir, 0, Mask); //Collider2D Ground = Physics2D.OverlapCapsule(transform.position, Size, Dir, 0, Mask); Collider2D[] Ground = Physics2D.OverlapCapsuleAll(transform.position, Size, Dir, 0, Mask); foreach (Collider2D col in Ground) { if (col.gameObject != gameObject) { bIsOnGround = true; if (col.GetComponent <Rigidbody2D>()) { return(col.GetComponent <Rigidbody2D>()); } } } return(null); }
public static void DrawCapsuleCast2D( Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, Color colorStart, Color colorEnd) { direction.EnsureNormalized(); DrawCapsuleStructure2D capsuleStructure2D = new DrawCapsuleStructure2D(size, capsuleDirection, angle); Color color = colorStart; DrawCapsule2DFast(origin, capsuleStructure2D, DrawLine); var scaledDirection = direction * distance; Vector2 destination = origin + scaledDirection; float dot = Vector2.Dot(PerpendicularClockwise(capsuleStructure2D.VerticalOffset), direction); float sign = Mathf.Sign(dot); float scaledRadius = capsuleStructure2D.Radius * sign; Vector2 o1 = PerpendicularCounterClockwise(direction) * scaledRadius; Vector2 o2 = PerpendicularClockwise(direction) * scaledRadius; Vector2 originA = origin + capsuleStructure2D.VerticalOffset + o1; Vector2 originB = origin - capsuleStructure2D.VerticalOffset + o2; Vector2 currentA = originA; Vector2 currentB = originB; for (int i = 1; i <= 10; i++) { float t = i / (float)10; color = Color.Lerp(colorStart, colorEnd, t); Vector2 nextA = originA + scaledDirection * t; Vector2 nextB = originB + scaledDirection * t; DrawLine(currentA, nextA, t); DrawLine(currentB, nextB, t); currentA = nextA; currentB = nextB; } color = colorEnd; DrawCapsule2DFast(destination, capsuleStructure2D, DrawLine); void DrawLine(Vector3 a, Vector3 b, float v) => lineDelegate(a, b, color); }
public static void DrawCapsuleCast2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] hits, float distance, int count, Color startColor, Color endColor, Color hitColor) { DrawCapsuleCast2D(origin, size, capsuleDirection, angle, direction, distance, startColor, endColor); DrawCapsuleCast2DHits(hits, origin, size, capsuleDirection, angle, direction, hitColor, count); }
// Start is called before the first frame update void Start() { thrustDirection = new Vector2(1.0f, 0.0f); CapsuleCollider2D capsuleCollider2D = GetComponent <CapsuleCollider2D>(); direction = capsuleCollider2D.direction; size = capsuleCollider2D.size; rigidbody2d = GetComponent <Rigidbody2D>(); // start spawn timer spawnTimer = gameObject.AddComponent <Timer>(); spawnTimer.Duration = SpawnDelaySeconds; spawnTimer.Run(); }
public override void UpdateIfNeeded() { CapsuleCollider2D capsule = collider as CapsuleCollider2D; if (capsule != null && (capsule.size != size || capsule.direction != direction || capsule.offset != center)) { size = capsule.size; direction = capsule.direction; center = capsule.offset; adaptor.Set(center, (capsule.direction == CapsuleDirection2D.Horizontal ? size.y : size.x) * 0.5f, Mathf.Max(size.x, size.y), capsule.direction == CapsuleDirection2D.Horizontal ? 0 : 1); Oni.UpdateShape(oniShape, ref adaptor); } }
private void Awake() { myVelocity = Vector2.zero; // Setting up references. priv_Anim = GetComponent <Animator>(); priv_Rigidbody2D = GetComponent <Rigidbody2D>(); quickCapsule = GetComponent <CapsuleCollider2D>(); crouchCheckPosition = new Vector3( quickCapsule.offset.x * Mathf.Abs(transform.lossyScale.x), (quickCapsule.offset.y + quickCapsule.size.y * 0.0125f) * transform.lossyScale.y, transform.position.z); crouchCheckSize = new Vector2( quickCapsule.size.x * 0.95f * Mathf.Abs(transform.lossyScale.x), quickCapsule.size.y * 0.975f * transform.lossyScale.y); crouchCheckDirection = quickCapsule.direction; //not necessary, but initializing the enums here to make myself feel better stateGrounded = PlayerStateGrounded.Idle; stateAerial = PlayerStateAerial.No; stateCrouch = PlayerStateCrouch.No; myOriginalMaxSpeed = myMaxSpeed; }
public DrawCapsuleStructure2D( Vector2 size, CapsuleDirection2D capsuleDirection, float angle) { if (capsuleDirection == CapsuleDirection2D.Horizontal) { float temp = size.y; size.y = size.x; size.x = temp; angle += 180; } Radius = size.x * 0.5f; float vertical = Mathf.Max(0, size.y - size.x) * 0.5f; GetRotationCoefficients(angle, out var s, out var c); VerticalOffset = RotateFast(new Vector2(0, vertical), s, c); Left = new Vector2(c, s); ScaledLeft = Left * Radius; ScaledRight = -ScaledLeft; }
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask = Physics2D.DefaultRaycastLayers) { return(_world.OverlapCapsule(point, size, direction, angle, results, layerMask)); }
/// <summary> /// <para>Casts a capsule into the scene, returning colliders that contact with it into the provided results array.</para> /// </summary> /// <param name="origin">The point in 2D space where the shape originates.</param> /// <param name="size">The size of the shape.</param> /// <param name="capsuleDirection">The direction of the capsule.</param> /// <param name="angle">The angle of the shape (in degrees).</param> /// <param name="direction">Vector representing the direction to cast the shape.</param> /// <param name="results">Array to receive results.</param> /// <param name="distance">Maximum distance over which to cast the shape.</param> /// <param name="layerMask">Filter to detect Colliders only on certain layers.</param> /// <param name="minDepth">Only include objects with a Z coordinate (depth) greater than this value.</param> /// <param name="maxDepth">Only include objects with a Z coordinate (depth) less than this value.</param> /// <returns> /// <para>The number of results returned.</para> /// </returns> public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth) { return INTERNAL_CALL_CapsuleCastNonAlloc(ref origin, ref size, capsuleDirection, angle, ref direction, results, distance, layerMask, minDepth, maxDepth); }
private static extern void INTERNAL_CALL_Internal_CapsuleCast(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, int layerMask, float minDepth, float maxDepth, out RaycastHit2D raycastHit);
public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth) { float positiveInfinity = float.PositiveInfinity; return CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, minDepth, positiveInfinity); }
public static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask) { float positiveInfinity = float.PositiveInfinity; float negativeInfinity = float.NegativeInfinity; return INTERNAL_CALL_CapsuleCastAll(ref origin, ref size, capsuleDirection, angle, ref direction, distance, layerMask, negativeInfinity, positiveInfinity); }
public static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask) { float positiveInfinity = float.PositiveInfinity; float negativeInfinity = float.NegativeInfinity; return INTERNAL_CALL_OverlapCapsuleAll(ref point, ref size, direction, angle, layerMask, negativeInfinity, positiveInfinity); }
/// <summary> /// <para>Get a list of all colliders that fall within a capsule area.</para> /// </summary> /// <param name="point">Center of the capsule.</param> /// <param name="size">Size of the capsule.</param> /// <param name="direction">The direction of the capsule.</param> /// <param name="angle">Angle of the capsule.</param> /// <param name="results">Array to receive results.</param> /// <param name="layerMask">Filter to check objects only on specific layers.</param> /// <param name="minDepth">Only include objects with a Z coordinate (depth) greater than this value.</param> /// <param name="maxDepth">Only include objects with a Z coordinate (depth) less than this value.</param> /// <returns> /// <para>The number of results returned.</para> /// </returns> public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth) { return INTERNAL_CALL_OverlapCapsuleNonAlloc(ref point, ref size, direction, angle, results, layerMask, minDepth, maxDepth); }
public static void DrawCapsule2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, bool hit, float duration = 0) => DrawCapsule2D(origin, size, capsuleDirection, angle, hit ? HitColor : RayColor, duration);
public static void DrawCapsuleCast2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance) => DrawCapsuleCast2D(origin, size, capsuleDirection, angle, direction, distance, StartColor, EndColor);
private static extern void CapsuleCast_Internal_Injected(ref PhysicsScene2D physicsScene, ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, out RaycastHit2D ret);
public static void DrawCapsuleCast2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] hits, float distance, int count) => DrawCapsuleCast2D(origin, size, capsuleDirection, angle, direction, hits, distance, count, StartColor, EndColor, HitColor);
private static extern int CapsuleCastList_Internal_Injected(ref PhysicsScene2D physicsScene, ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, List <RaycastHit2D> results);
private static extern int OverlapCapsuleList_Internal_Injected(ref PhysicsScene2D physicsScene, ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, ref ContactFilter2D contactFilter, List <Collider2D> results);
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, List <Collider2D> results) { return(_world.OverlapCapsule(point, size, direction, angle, contactFilter, results)); }
private void SetCrouchState(CapsuleDirection2D direction, float sizeX, float sizeY) { playerCollider.direction = direction; playerCollider.size = new Vector2(sizeX, sizeY); }
public static void DrawCapsuleCast2DHits(RaycastHit2D[] hits, Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, int maxCount = -1) => DrawCapsuleCast2DHits(hits, origin, size, capsuleDirection, angle, direction, HitColor, maxCount);
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, [DefaultValue("Physics2D.DefaultRaycastLayers")] int layerMask = -5) { ContactFilter2D contactFilter = ContactFilter2D.CreateLegacyFilter(layerMask, float.NegativeInfinity, float.PositiveInfinity); return(PhysicsScene2D.OverlapCapsuleArray_Internal(this, point, size, direction, angle, contactFilter, results)); }
public Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter) { return(PhysicsScene2D.OverlapCapsule_Internal(this, point, size, direction, angle, contactFilter)); }
public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask, float minDepth) { float positiveInfinity = float.PositiveInfinity; return INTERNAL_CALL_OverlapCapsuleNonAlloc(ref point, ref size, direction, angle, results, layerMask, minDepth, positiveInfinity); }
private static int OverlapCapsuleList_Internal(PhysicsScene2D physicsScene, Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, [NotNull("ArgumentNullException")] List <Collider2D> results) { return(PhysicsScene2D.OverlapCapsuleList_Internal_Injected(ref physicsScene, ref point, ref size, direction, angle, ref contactFilter, results)); }
private static Collider2D OverlapCapsule_Internal(PhysicsScene2D physicsScene, Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter) { return(PhysicsScene2D.OverlapCapsule_Internal_Injected(ref physicsScene, ref point, ref size, direction, angle, ref contactFilter)); }
/// <summary> /// Adjusts the position of the attack spawner based on current direction state /// </summary> private void RecalculatePosition() { //get center offset (due to pivot changes) //float spriteHeight = spriteRenderer.bounds.size.y / 32f; //characters will always be 32ppu //Debug.Log(spriteHeight); Vector2 center = spriteRenderer.bounds.center; Direction direction; //get direction from whichever controller component this entity has direction = controller.Direction; // move spawn point into position if (direction == Direction.East) { attackCapsuleDirection = CapsuleDirection2D.Horizontal; attackCapsuleRotation = 0; attackSpawnPoint = new Vector2(transform.position.x + (meleeRange / 2f), center.y); } else if (direction == Direction.West) { attackCapsuleDirection = CapsuleDirection2D.Horizontal; attackCapsuleRotation = 0; attackSpawnPoint = new Vector2(transform.position.x - (meleeRange / 2f), center.y); } else if (direction == Direction.North) { attackCapsuleDirection = CapsuleDirection2D.Vertical; attackCapsuleRotation = 0; attackSpawnPoint = new Vector2(transform.position.x, center.y + (meleeRange / 2f)); } else if (direction == Direction.South) { attackCapsuleDirection = CapsuleDirection2D.Vertical; attackCapsuleRotation = 0; attackSpawnPoint = new Vector2(transform.position.x, center.y - (meleeRange / 2f)); } //intermediate directions else if (direction == Direction.NorthWest) { attackCapsuleDirection = CapsuleDirection2D.Horizontal; attackCapsuleRotation = -45f; attackSpawnPoint = new Vector2(transform.position.x - (meleeRange / 2f), center.y + (meleeRange / 2f)); } else if (direction == Direction.NorthEast) { attackCapsuleDirection = CapsuleDirection2D.Horizontal; attackCapsuleRotation = 45f; attackSpawnPoint = new Vector2(transform.position.x + (meleeRange / 2f), center.y + (meleeRange / 2f)); } else if (direction == Direction.SouthWest) { attackCapsuleDirection = CapsuleDirection2D.Horizontal; attackCapsuleRotation = 45f; attackSpawnPoint = new Vector2(transform.position.x - (meleeRange / 2f), center.y - (meleeRange / 2f)); } else if (direction == Direction.SouthEast) { attackCapsuleDirection = CapsuleDirection2D.Horizontal; attackCapsuleRotation = -45f; attackSpawnPoint = new Vector2(transform.position.x + (meleeRange / 2f), center.y - (meleeRange / 2f)); } }
/// <summary> /// <para>Casts a capsule against colliders in the scene, returning the first collider to contact with it.</para> /// </summary> /// <param name="origin">The point in 2D space where the shape originates.</param> /// <param name="size">The size of the shape.</param> /// <param name="capsuleDirection">The direction of the capsule.</param> /// <param name="angle">The angle of the shape (in degrees).</param> /// <param name="direction">Vector representing the direction to cast the shape.</param> /// <param name="distance">Maximum distance over which to cast the shape.</param> /// <param name="layerMask">Filter to detect Colliders only on certain layers.</param> /// <param name="minDepth">Only include objects with a Z coordinate (depth) greater than this value.</param> /// <param name="maxDepth">Only include objects with a Z coordinate (depth) less than this value.</param> /// <returns> /// <para>The cast results returned.</para> /// </returns> public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth) { RaycastHit2D hitd; Internal_CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, minDepth, maxDepth, out hitd); return hitd; }
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, List <Collider2D> results) { return(PhysicsScene2D.OverlapCapsuleList_Internal(this, point, size, direction, angle, contactFilter, results)); }
public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth) { float positiveInfinity = float.PositiveInfinity; return INTERNAL_CALL_CapsuleCastNonAlloc(ref origin, ref size, capsuleDirection, angle, ref direction, results, distance, layerMask, minDepth, positiveInfinity); }
private static void Internal_CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth, float maxDepth, out RaycastHit2D raycastHit) { INTERNAL_CALL_Internal_CapsuleCast(ref origin, ref size, capsuleDirection, angle, ref direction, distance, layerMask, minDepth, maxDepth, out raycastHit); }
private static extern int INTERNAL_CALL_CapsuleCastNonAlloc(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth, float maxDepth);
public int CastCapsule(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, List <RaycastHit2D> results) { return(_world.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, contactFilter, results)); }
private static extern int INTERNAL_CALL_OverlapCapsuleNonAlloc(ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask, float minDepth, float maxDepth);
public Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter) { return(_world.OverlapCapsule(point, size, direction, angle, contactFilter)); }
private static int CapsuleCastList_Internal(PhysicsScene2D physicsScene, Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, [NotNull("ArgumentNullException")] List <RaycastHit2D> results) { return(PhysicsScene2D.CapsuleCastList_Internal_Injected(ref physicsScene, ref origin, ref size, capsuleDirection, angle, ref direction, distance, ref contactFilter, results)); }
public int CastCapsule(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, RaycastHit2D[] results, int layerMask = Physics2D.DefaultRaycastLayers) { return(_world.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, results, layerMask)); }