private void Update() { if (Grid == null) { BuildGrid(); } if (DrawGridPoints) { foreach (var node in Grid.InnerGrid) { if (node.HasFlag(NodeFlags.Avoidance)) { DebugExtension.DebugWireSphere(Grid.ToWorldPosition(node.NavigableCenter), UnityColors.OrangeRed, 0.1f); } else if (node.HasFlag(NodeFlags.NearEdge)) { DebugExtension.DebugPoint(Grid.ToWorldPosition(node.NavigableCenter), UnityColors.Gray, 0.2f); } else if (node.HasFlag(NodeFlags.Navigation)) { DebugExtension.DebugPoint(Grid.ToWorldPosition(node.NavigableCenter), UnityColors.Blue, 0.2f); } } } }
/// <summary> /// Checks for nearby enemies and hits those that are inside the /// sphere radius, also adds push back force from the sphere origin /// </summary> /// <param name="position">The position.</param> /// <param name="radius">The radius.</param> private void HitPushback(Vector3 position, float radius) { #if UNITY_EDITOR DebugExtension.DebugWireSphere(position, radius, 2); #endif Collider[] colliders = Physics.OverlapSphere(position, radius, _pushbackMask); for (int i = 0; i < colliders.Length; i++) { var rb = colliders[i].attachedRigidbody; if (null != rb && colliders[i].transform != transform) { // if enemy and hittable, register a hit if (rb.CompareTag("Enemy")) { var enemy = rb.GetComponent <IHittable>(); if (enemy != null) { enemy.Hit(); } } rb.AddExplosionForce(_player.PushbackForceRatio * radius, position, radius, _player.UpwardModifier); } } }
/// <summary> /// renvoi vrai ou faux si on a le droit de sauter (selon le hold) /// </summary> /// <returns></returns> public bool CanGrip(bool setupPoint = true) { //faux si le cooldown n'est pas fini, ou qu'on est pas grounded if (!coolDownGrip.IsReady() || !worldCollision.IsGroundedSafe()) { return(false); } Collider coll; if (worldCollision.PlatformManager.IsGrippable(out coll)) { if (!setupPoint) { return(true); } // The distance from the explosion position to the surface of the collider. //Collider coll = objectToAggrip.GetComponent<Collider>(); pointAttract = coll.ClosestPointOnBounds(transform.position); DebugExtension.DebugWireSphere(pointAttract, 1, 1); return(true); } return(false); }
private void CheckIsGrounded() { Vector3 checkPosition = Vector3.down * boxCollider2D.size.y / 2 + transform.position; DebugExtension .DebugWireSphere(checkPosition, Color.red, fGroundSphereRadius, Time.deltaTime); Collider2D[] colliders = Physics2D .OverlapCircleAll((Vector2)checkPosition, fGroundSphereRadius, groundMask); if (rb.velocity.y <= 0.0f) { if (colliders.Length > 0) { isGrounded = true; } else { isGrounded = false; } } else { isGrounded = false; } animator.SetBool("isJump", !isGrounded); }
void Rpc_Explode(Vector3 explosionpos) { //Explosion GameObject explosion = (GameObject)Instantiate(rocketExplosion, explosionpos, Quaternion.identity); Destroy(explosion, 1.0f); GameObject[] players = GameObject.FindGameObjectsWithTag("Player"); foreach (GameObject player in players) { player.GetComponent <PlayerCall>().Call_ExplosionDamage(explosionpos, rocketTeam, ownerIdentity); } //Trail rocketBits.transform.parent = null; rocketSmoke.transform.parent = null; em1.enabled = false; em2.enabled = false; Destroy(rocketBits, 0.4f); Destroy(rocketSmoke, 1.0f); #region DEBUG if (DBG_Explosion) { DebugExtension.DebugWireSphere(explosionpos, Color.blue, 0.05f, DBG_time_explosion, true); DebugExtension.DebugPoint(explosionpos, Color.red, 0.05f, DBG_time_explosion, true); DebugExtension.DebugWireSphere(explosionpos, Color.green, 2.0f, DBG_time_explosion, true); } #endregion Destroy(gameObject); //Destroys the rocket and everything still attached to it }
//public void Punch(bool isLeftHand) public void Punch(int _left) { Transform hand = _left == 1 ? leftHand : rightHand; //Transform hand = isLeftHand == true ? leftHand : rightHand; DebugExtension.DebugWireSphere(hand.position, punchRadius, punchRadius); RaycastHit[] hits = Physics.SphereCastAll(hand.position, punchRadius, hand.forward, 0f); //Collider[] hitColliders = Physics.OverlapSphere(hand.position, punchRadius); List <PlayerController> playersHit = new List <PlayerController>(); foreach (var hit in hits) { RootFix playerRoot = hit.transform.GetComponent <RootFix>(); if (playerRoot != null) { PlayerController player = playerRoot.playerRoot.GetComponentInChildren <PlayerController>(); DamageableBehaviour damageable = playerRoot.playerRoot.GetComponent <DamageableBehaviour>(); var myAlignment = myDamageableBehaviour.configuration.AlignmentProvider; if (damageable != null && myAlignment != null) { float knockback = 1f + (damageable.configuration.CurrentDamage / 100f); //EDIT var hitInfo = new HitInfo { damageChangeInfo = new DamageChangeInfo(), damagePoint = hit.point }; bool canKnockBack = (myAlignment != damageable.configuration.AlignmentProvider); if (!playersHit.Contains(player)) { if (canKnockBack) { damageable.configuration.AddDamage(damagePerHit, hitInfo); playersHit.Add(player); } } MuscleCollisionBroadcaster broadcaster = hit.transform.GetComponent <MuscleCollisionBroadcaster>(); if (broadcaster != null && canKnockBack) { Vector3 heading = hit.point - hand.position; Vector3 direction = hand.transform.forward; broadcaster.Hit(5, direction * (baseKnockback * (knockback * (damageable.configuration.CurrentDamage / 100f))), hit.point); } } } } }
private void CheckAround() { if (GameConstants.paused) { return; } this._closest = Helper.FindNearestInLayer(this._head.position, this._radius.Value, this._layerMask.value); DebugExtension.DebugWireSphere(this._head.position, this._radius.Value, this._updateTime.Value); }
public override float CalculateYPosition() { Vector2 Velocity = ballController.Velocity; // If ball moving away, then move towards the center float yPosition = 0.0f; if (isBallHeadingToSelf()) { float dist = Vector3.Distance(aiController.transform.position, ballController.transform.position); // if(dist > aiController.FMidDist) //Far dist if (Mathf.Abs(aiController.transform.position.x - ballController.transform.position.x) > aiController.FMidDist) //Far dist { Debug.Log("Head towards ball half y position"); yPosition = ballController.transform.position.y / 2; } else { Vector2 A1 = (Vector2)aiController.transform.position + Vector2.up * 10; Vector2 A2 = (Vector2)aiController.transform.position + Vector2.up * -10; Vector2 ballPosition = (Vector2)ballController.transform.position; Vector2 B1 = ballPosition; Vector2 B2 = (Vector2)ballController.transform.position + Velocity.normalized * 20.0f; bool found = false; Vector2 movePosition = Math.GetIntersectionPointCoordinates(A1, A2, B1, B2, out found); DebugExtension.DebugWireSphere(movePosition, Color.red, 2.0f, Time.deltaTime); if (found) { Debug.Log("Head towards intersection y position"); yPosition = movePosition.y; } else { Debug.Log("Head towards ball half y position. No intersection"); yPosition = ballController.transform.position.y / 2; } } } Vector3 pos = aiController.transform.position; pos.y = yPosition; DebugExtension.DebugWireSphere(pos, Color.cyan, 0.5f, 0.02f); return(yPosition); }
// Update is called once per frame void Update() { DebugExtension.DebugPoint(debugPoint_Position, debugPoint_Color, debugPoint_Scale); DebugExtension.DebugBounds(new Bounds(new Vector3(10, 0, 0), debugBounds_Size), debugBounds_Color); DebugExtension.DebugCircle(new Vector3(20, 0, 0), debugCircle_Up, debugCircle_Color, debugCircle_Radius); DebugExtension.DebugWireSphere(new Vector3(30, 0, 0), debugWireSphere_Color, debugWireSphere_Radius); DebugExtension.DebugCylinder(new Vector3(40, 0, 0), debugCylinder_End, debugCylinder_Color, debugCylinder_Radius); DebugExtension.DebugCone(new Vector3(50, 0, 0), debugCone_Direction, debugCone_Color, debugCone_Angle); DebugExtension.DebugArrow(new Vector3(60, 0, 0), debugArrow_Direction, debugArrow_Color); DebugExtension.DebugCapsule(new Vector3(70, 0, 0), debugCapsule_End, debugCapsule_Color, debugCapsule_Radius); }
private void OnDrawGizmos() { if (steeringAgent != null && showGizmoArrows) { DebugExtension.DebugArrow(transform.position, desiredVelocity, Color.red); DebugExtension.DebugArrow(transform.position, steeringAgent.velocity, Color.blue); } if (EnemyTarget != null) { DebugExtension.DebugWireSphere(EnemyTarget.position, Color.green, FleeDistance); } }
public void UseItemAbility() { //sphr cast and attack all objects with PropCol layerMask in it if (nextMelee < Time.time) { nextMelee = Time.time + fireRate; //do damage if (bIs2DGame) // for 2D Games { Collider2D[] target = Physics2D.OverlapCircleAll(transform.position, knockBackRadius, shootableMask); if (bDebugTrace) { DebugExtension.DebugWireSphere(transform.position, Color.red, knockBackRadius); } foreach (Collider2D tCol in target) { MechCharStatHP targetMechCharStatHP = tCol.GetComponent <MechCharStatHP>(); if (targetMechCharStatHP) { targetMechCharStatHP.ApplyDamage(damage); MechExtraCharSkillPhysicsShortcuts.LaunchObjBy2Transforms(tCol.gameObject.transform, transform, pushBackForce); } } } else // for 3D Games { Collider[] target = Physics.OverlapSphere(transform.position, knockBackRadius, shootableMask); if (bDebugTrace) { DebugExtension.DebugWireSphere(transform.position, Color.red, knockBackRadius); } print(target.Length); foreach (Collider tCol in target) { MechCharStatHP targetMechCharStatHP = tCol.GetComponent <MechCharStatHP>(); if (targetMechCharStatHP) { targetMechCharStatHP.ApplyDamage(damage); MechExtraCharSkillPhysicsShortcuts.LaunchObjBy2Transforms(tCol.gameObject.transform, transform, pushBackForce); } } } } }
// Generate hit with overlap sphere public void Hit() { // Get colliders inside the overlay sphere Collider[] hitColliders = Physics.OverlapSphere(_hitLocation.position, _hitRadius, _hitDamageMask); if (_attackSFX != null && _attackSFX.isPlaying == false) { _attackSFX.Play(); } foreach (Collider collider in hitColliders) // Do for each collider { if (collider.gameObject == gameObject) { continue; // Do not collide with self } if (_overlapTargets.Contains(collider.gameObject) == true) { continue; // Do not collide with already collided object } _overlapTargets.Add(collider.gameObject); // Add the collided object to already collided list if (collider.CompareTag(gameObject.tag) == false) // If it is { if (_hitParticle) { GameObject particle = Instantiate(_hitParticle, _hitLocation.position, transform.rotation); Destroy(particle, _particleDestroyTime); } collider.GetComponent <HitPoints>()?.AddDamage(_damage); // Damage target Rigidbody rigidbody = collider.GetComponent <Rigidbody>(); if (rigidbody != null) // Push target back { if (_isHitDirectionRelative) { rigidbody.AddForce(transform.forward * _hitForceMagnitude, ForceMode.Impulse); } else { rigidbody.AddForce(_hitDirection.normalized * _hitForceMagnitude, ForceMode.Impulse); } } } } if (_overlapTargets.Count > 0 && _hitSFX != null && _hitSFX.isPlaying == false) { _hitSFX.Play(); } DebugExtension.DebugWireSphere(_hitLocation.position, Color.red, _hitRadius); // Show overlay sphere in viewport }
void CalculateGround() { RaycastHit hit; //if (Physics.Raycast(transform.position + Vector3.up * 0.1f, -Vector3.up, out hit, 0.4f)) DebugExtension.DebugWireSphere(transform.position + Vector3.up - new Vector3(0, 1.0f, 0), new Color(0.0f, 1.0f, 0.0f), 0.34f); if (Physics.SphereCast(transform.position + Vector3.up, 0.34f, -Vector3.up, out hit, 1.0f, floorMasks, QueryTriggerInteraction.UseGlobal)) { grounded = true; } else { grounded = false; } }
private PlayerController[] CheckHitbox(Vector3 p_hitboxOrigin, float p_hitboxSize, LayerMask p_layerMask) { DebugExtension.DebugWireSphere(p_hitboxOrigin, p_hitboxSize); Collider[] colliders = Physics.OverlapSphere(p_hitboxOrigin, p_hitboxSize, p_layerMask); List <PlayerController> playerList = new List <PlayerController>(); foreach (Collider collider in colliders) { if (collider.transform.root != transform) { playerList.Add(collider.gameObject.GetComponentInParent <PlayerController>()); } } return(playerList.ToArray()); }
private float _particleDestroyTime = 5.0f; // Delay to destroy particle gameobject // ===================================== ATTACK ===================================== // Create a overlap sphere and strike enemies that are inside of it public void Attack() { // Get colliders inside the overlay sphere Collider[] hitColliders = Physics.OverlapSphere(_part.position, _hitRadius, _damageMask); if (_attackSFX != null && _attackSFX.isPlaying == false) { _attackSFX.Play(); } foreach (Collider collider in hitColliders) // Do for each collider { if (collider.gameObject == gameObject) { continue; // Do not repeat for the same gameobject } if (_overlapTargets.Contains(collider.gameObject)) { continue; // Do not collide with already collided object } _overlapTargets.Add(collider.gameObject); // Add the collided object to already collided list if (!collider.CompareTag(gameObject.tag)) // If it is { if (_hitParticle) { GameObject particle = Instantiate(_hitParticle, _part.position, transform.rotation); Destroy(particle, _particleDestroyTime); } collider.GetComponent <HitPoints>()?.AddDamage(_hitDamage); // Damage target if (_hitSFX != null && _hitSFX.isPlaying == false) { _hitSFX.Play(); } if (collider.GetComponent <Rigidbody>()) // Push target back { collider.GetComponent <Rigidbody>()?.AddForce((transform.forward + new Vector3(0, _forceVerticality, 0)).normalized * _hitForce, ForceMode.Impulse); } } } gameObject.GetComponent <Rigidbody>()?.AddForce(transform.forward * _selfImpulse); DebugExtension.DebugWireSphere(_part.position, Color.red, _hitRadius); // Show overlay sphere in viewport }
/// <summary> /// déplace le player /// </summary> private void TryToMove() { //ici gérer le air control if (!CanMove()) { if (isOnAirMove) { Debug.Log("air move fin"); //pointPivot = Vector3.zero; coolDownInactiveAirMove.StartCoolDown(); DebugExtension.DebugWireSphere(transform.position, Color.red, 1f, 1f); } isOnAirMove = false; return; } if (!isOnAirMove) { /*//ici test supplémentaire au airMove * if (!coolDownInactiveAirMove.IsReady() && activeTimer) * { * Debug.LogWarning("ici on vient de finir un airMove... attendre avant de commencer le suivant..."); * return; * }*/ if (coolDownInactiveAirMove.IsReady()) { //ici on a arreté, et quand on reprend... le timer a dépassé 0.3sec... ducoup //forcément on reprend à zero... ResetForcePendule(); InverseReset(); } DebugExtension.DebugWireSphere(transform.position, Color.green, 1f, 1f); Debug.Log("air move debut"); isOnAirMove = true; externalForce.ResetInitialParameter(); } AirMove(); }
// =================================== GROUND CHECK ====================================== protected void CheckGround() { if (_groundLocation == null) // Check if ground check transform is added { Debug.LogWarning("Ground check target is not added"); return; } Vector3 checkLocation = new Vector3(0, _groundCheckOffset, 0) + _groundLocation.position; // Location for the ground check DebugExtension.DebugWireSphere(checkLocation, Color.green, _groundCheckRadius); // Show it as a sphere for debugging Collider[] groundColliders = Physics.OverlapSphere(checkLocation, _groundCheckRadius, _groundMask); // Get colliders for ground check foreach (Collider collider in groundColliders) // Do for each collider { if (collider.gameObject == gameObject) { continue; // Do not collide with your own collider } _isGrounded = true; // Check for ground return; } _isGrounded = false; }
/// <summary> /// ici effectue un jump extraordinaire ! /// </summary> public void ControlledAirJumpSetup(bool jump, Vector3 dir, bool fromGround = true, float ratioForceJump = 1) { previousControllerJumpDir = dir; if (jump) { Debug.Log("active le jump"); inAutoAirMove = isAutoAirMoveAndCoolDownNotFinish = true; savePivot = playerPenduleMove.GetPivotPoint(true); DebugExtension.DebugWireSphere(savePivot, Color.green, 1f, 1f); //Debug.Break(); playerJump.PrepareAndJump(dir); airMoveActifLong.StartCoolDown(); //playerMove.MoveOnWallWhenAirMove(dir); StartCoroutine(JumpNextFrame(dir, true, initialBoost, ratioForceJump)); //playerJump.Jump(dir, true, initialBoost, 1); currentJumpBoost = jumpBoost; currentForceOnRopeBoost = forceOnRopeBoost; } else { Debug.Log("desactive le jump"); inAutoAirMove = false; if (fromGround) { airMoveActifLong.Reset(); isAutoAirMoveAndCoolDownNotFinish = false; } } }
public override void ActionStuff() { DebugExtension.DebugWireSphere(dealDamageAt, radius); if (isFinished) { var coll = Physics2D.OverlapCircle(dealDamageAt, radius, LayerMask.GetMask(HelperConstants.warriorTag)); if (coll) { var attackedWarr = coll.GetComponent <WarriorController>(); attackedWarr.TakeDamage(damage); //TODO: random limbs must be if (attackedWarr.team != attackingWarr.team) //different teams { attackedWarr.stats.damageFromEnemy += damage; attackingWarr.stats.enemyDamage += damage; } else { attackedWarr.stats.damageFromAlly += damage; attackingWarr.stats.allyDamage += damage; } } } }
private void OnDrawGizmos() { DebugExtension.DebugWireSphere(target, debugColor); }
void OnDrawGizmos() { DebugExtension.DebugWireSphere(transform.position, Color.white); }
// Update is called once per frame void Update() { // ====================== // TIMER // ====================== m_dashTimer += Time.deltaTime; // ====================== // GROUND CHECK // ====================== m_isGrounded = Physics.CheckSphere(m_groundChecker.position, GroundDistance, Ground, QueryTriggerInteraction.Ignore); // visualize ground check sphere if (IsDebugEnabled) { DebugExtension.DebugWireSphere(m_groundChecker.position, GroundDistance); } if (m_isGrounded && m_velocity.y < 0) { m_velocity.y = 0.0f; } // ====================== // MOVEMENT // ====================== Vector3 move = Vector3.zero; ProcessMovement(out move); // ====================== // JUMP // ====================== if (Input.GetButtonDown(Constants.Inputs.Jump) && m_isGrounded) { m_velocity.y = Mathf.Sqrt(JumpHeight * -2.0f * Physics.gravity.y); } // ====================== // DASH // ====================== if (Input.GetButtonDown(Constants.Inputs.Dash)) { if (m_dashTimer > DashCoolDown) { m_velocity += Vector3.Scale(move, DashDistance * new Vector3((Mathf.Log(1.0f / (Time.deltaTime * Drag.x + 1)) / -Time.deltaTime), 0, (Mathf.Log(1.0f / (Time.deltaTime * Drag.z + 1)) / -Time.deltaTime))); m_dashTimer = 0.0f; } } // ====================== // GRAVITY // ====================== m_velocity.y += Physics.gravity.y * GravityModifier * Time.deltaTime; // ====================== // DRAG // ====================== m_velocity.x /= 1 + Drag.x * Time.deltaTime; m_velocity.y /= 1 + Drag.y * Time.deltaTime; m_velocity.z /= 1 + Drag.z * Time.deltaTime; // ====================== // APPLY ALL MOVEMENT // ====================== m_controller.Move(m_velocity * Time.deltaTime); }
protected virtual void OnDrawGizmos() { DebugExtension.DebugWireSphere(mTarget, Color.red); }
private List <Vector2> optimizeGesture(List <Vector2> pointsList)//, List<Vector2> deltaList) { float pD = Screen.width * pointDistance; if (deltaTotal / deltaCount <= pD) { optimizedDistance = new List <Vector2> { pointsList[0] }; for (int i = 1; i < pointsList.Count; ++i) { if (Vector2.Distance(pointsList[i], optimizedDistance[optimizedDistance.Count - 1]) >= pD) { //optimizedDistance.Insert(optimizedDistance.Count - 2, pointsList[i]); optimizedDistance.Add(pointsList[i]); } else if (i == pointsList.Count - 1) { optimizedDistance[optimizedDistance.Count - 1] = pointsList[i]; } } } else { optimizedDistance = pointsList; } //Quitamos los puntos que no creen un cambio de direccion. optimizedDirection = new List <Vector2>(); Vector2 pointA = optimizedDistance[0]; for (int i = 1; i < optimizedDistance.Count - 1; ++i) { if (i >= optimizedDistance.Count - 2 && Vector2.Distance(optimizedDistance[i], pointA) > lineDistance) { optimizedDirection.Add(pointA); optimizedDirection.Add(optimizedDistance[i]); continue; } //if (Vector2.Distance(optimizedDistance[i], pointA) < pointDistance || Vector2.Distance(optimizedDistance[i], optimizedDistance[i + 1]) < pointDistance) // continue; Vector2 AB = optimizedDistance[i] - pointA; Vector2 CB = optimizedDistance[i] - optimizedDistance[i + 1]; float angle = Vector2.Angle(AB, CB); if (angle <= minimumAngle) { if (Vector2.Distance(optimizedDistance[i], pointA) > lineDistance) { optimizedDirection.Add(pointA); optimizedDirection.Add(optimizedDistance[i]); } pointA = optimizedDistance[i]; } } if (optimizedDirection.Count < 3) { return(optimizedDirection); } optimizedIntersection = new List <Vector2> { optimizedDirection[0] }; for (int i = 2; i < optimizedDirection.Count - 1; i += 2) { if (Vector2.Distance(optimizedDirection[i], optimizedDirection[i - 1]) < 1) { optimizedIntersection.Add(optimizedDirection[i]); } else { bool b = false; Vector2 v = GetIntersectionPointCoordinates(optimizedDirection[i - 2], optimizedDirection[i - 1], optimizedDirection[i], optimizedDirection[i + 1], out b); if (b) { optimizedIntersection.Add(v); } } } optimizedIntersection.Add(optimizedDirection[optimizedDirection.Count - 1]); if (debug) { DebugExtension.DebugLine(optimizedDirection, Colors.IndianRed, 5); DebugExtension.DebugLine(optimizedDistance, Colors.Red, 5); foreach (Vector2 v in optimizedIntersection) { DebugExtension.DebugWireSphere(v, Colors.DarkRed, 10, 5); } } return(optimizedIntersection); }
public void SwingHit() { DebugExtension.DebugWireSphere(swingLocation.position, swingRadius, 0.25f); //Delete this RaycastHit[] _hits = Physics.SphereCastAll(swingLocation.position, swingRadius, transform.forward, 0f); PickUp weapon = _item.GetComponent <PickUp>(); List <PlayerController> playersHit = new List <PlayerController>(); foreach (RaycastHit hit in _hits) { RootFix playerRoot = hit.transform.GetComponent <RootFix>(); if (playerRoot != null) { PlayerController player = playerRoot.playerRoot.GetComponentInChildren <PlayerController>(); DamageableBehaviour damageable = playerRoot.playerRoot.GetComponent <DamageableBehaviour>(); var myAlignment = myDamageableBehaviour.configuration.AlignmentProvider; if (damageable != null && myAlignment != null) { float knockback = 1f + (damageable.configuration.CurrentDamage / 100f); //EDIT var hitInfo = new HitInfo { damageChangeInfo = new DamageChangeInfo(), damagePoint = hit.point }; bool canKnockBack = (myAlignment != damageable.configuration.AlignmentProvider); //print("Obj: " + player.name + ", Count: " + playersHit.Count + ", Contains: " + playersHit.Contains(player)); if (!playersHit.Contains(player)) { if (canKnockBack) { damageable.configuration.AddDamage((weapon != null ? weapon.damage : damagePerHit), hitInfo); playersHit.Add(player); } } MuscleCollisionBroadcaster broadcaster = hit.transform.GetComponent <MuscleCollisionBroadcaster>(); if (broadcaster != null && canKnockBack) { broadcaster.Hit(5, rightHand.transform.forward * (baseKnockback * (knockback * (damageable.configuration.CurrentDamage / 100f))), hit.point); } } } /* * if (_hit.transform.root != transform.root) * { * Debug.Log("RUGHAARINMIJNRIETJE TWEE"); * * //PlayerController _player = null; * DamageableBehaviour _damageable = null; * IAlignmentProvider myAlignment = null; * * if (_hit.transform.root.tag == "Player") * { * //_player = _hit.transform.root.GetComponentInChildren<PlayerController>(); * _damageable = _hit.transform.root.GetComponentInChildren<DamageableBehaviour>(); * } * * float knockback = 1f; * if (_damageable != null) * { * myAlignment = myDamageableBehaviour.configuration.AlignmentProvider; * * int weaponDamagePerHit = ((_item != null) ? _item.GetComponent<PickUp>().damage : damagePerHit); * * _damageable.configuration.CheckDamage(weaponDamagePerHit, myAlignment, swingLocation.position); * } * * MuscleCollisionBroadcaster broadcaster = _hit.transform.GetComponent<MuscleCollisionBroadcaster>(); * * if (broadcaster != null && _damageable.CanKnockback(myAlignment)) * { * Vector3 _heading = _hit.point - swingLocation.position; * float _distance = _heading.magnitude; * Vector3 _direction = _heading / _distance; * * broadcaster.Hit(5, _direction * (baseKnockback * knockback), _hit.point); //Edit this * } * } */ } }
/* * Verify if character would penetrate and try to move just enough to not collide. */ private void ContinuosCollisionDetection(Vector3 movementSpeed) { Vector3 origin = rb.position; int attempts; Color startColor = Color.blue; for (attempts = 0; attempts < maxCollisionAttempts; attempts++) { Vector3 prevOrigin = origin; float castDistance = movementSpeed.magnitude + backstepOffset; Vector3 castDirection = movementSpeed.normalized; Vector3 castStartBackOffset = origin - (castDirection * backstepOffset); float offSetCapsule = col.height - col.radius; Vector3 castStartBackOffsetTop = castStartBackOffset + transform.up * offSetCapsule; Vector3 castStartBackOffsetBot = castStartBackOffset + transform.up * col.radius; DebugExtension.DebugWireSphere(castStartBackOffsetTop, Color.red, col.radius); DebugExtension.DebugWireSphere(castStartBackOffsetBot, Color.red, col.radius); DebugExtension.DebugWireSphere(castStartBackOffsetTop + castDirection * castDistance, Color.blue, col.radius); DebugExtension.DebugWireSphere(castStartBackOffsetBot + castDirection * castDistance, Color.blue, col.radius); RaycastHit hitInfo; if (Physics.CapsuleCast(castStartBackOffsetTop, castStartBackOffsetBot, col.radius, castDirection, out hitInfo, castDistance, LayerMaskCollision)) { if (hitInfo.collider.isTrigger) { origin += movementSpeed; break; } origin = CastCenterOnCollision(castStartBackOffset, castDirection, hitInfo.distance); origin += (hitInfo.normal * surfaceOffset); float remainingDistance = Mathf.Max(0, castDistance - Vector3.Distance(prevOrigin, origin)); Vector3 remainingSpeed = castDirection * remainingDistance; movementSpeed = remainingSpeed - Vector3.Project(remainingSpeed, hitInfo.normal); if (movementSpeed.magnitude <= minVelocityBreak) { break; } } else { origin += movementSpeed; break; } } bool failedCollision = attempts >= maxCollisionAttempts; if (failedCollision) { Debug.LogWarning("Failed collision handling"); } if (!moveEvenIfFailedCollision && failedCollision) { Debug.LogWarning("Aborting movement"); } else { Vector3 disp = Vector3.zero; if (dePenetrate) { int numbOfNearbyCols = Physics.OverlapSphereNonAlloc(rb.position, 1 + 0.1f, nearbyColliders, LayerMaskCollision); disp = DePenetrateCollisions(ref movementSpeed, numbOfNearbyCols); } rb.MovePosition(origin + disp); } }
void OnDrawGizmos() { DebugExtension.DrawCone(transform.position, transform.forward * 10, Color.blue, MaxSightAngle); DebugExtension.DebugWireSphere(transform.position, Color.red, MaxInfectionRadius); }
public override void OnDrawGizmos(bool isGizmo, Color color) { #if UNITY_EDITOR DebugExtension.DebugWireSphere(c.ToVector3(), color, r.ToFloat()); #endif }
/// <summary> /// ici cherche le premier point de pivot, puis assigne la distance, et le nombre de particule player - point de pivot. /// </summary> public void GetPivotPoint(int indexPlayer, float angleDifferenceMarginForPivotPoint, float marginAngleConsideredAsEqual, out float distance, out int numberParticleFromPlayerToPivot, out Vector3 pointPivot, out bool onRope) { int startPoint = 4; //ici commence au Xeme point... float diffAdd = 0; //ici la somme des différence d'angles à chaque test int numberParticleTested = startPoint; //ici le nombre de particule testé onRope = false; Vector3 lastDir = Vector3.zero; //défini le vecteur directeur précédent Vector3 currentDir = Vector3.zero; //défini le vecteur à tester courrament dans la boucle if (indexPlayer == 0) { Vector3 posFirst = GetPosParticle(0); Vector3 posSecond = GetPosParticle(0 + startPoint); lastDir = posSecond - posFirst; for (int i = startPoint; i <= GetSizeConstrain() - 1; i++) { Vector3 posFirstTmp = posFirst; posFirst = GetPosParticle(i); posSecond = GetPosParticle(i + 1); currentDir = posSecond - posFirst; //Debug.Log("posActualPartivcleTested(current): " + posFirst); //Debug.Log("pos next: " + posSecond); //Debug.Log("current Direction: " + currentDir); if (currentDir == Vector3.zero) { //ici ok même angle, on continue //DebugExtension.DebugWireSphere(GetPosParticle(i), Color.blue, 1f, 1f); numberParticleTested++; //lastDir = currentDir; //Debug.Log("next"); continue; } //Debug.DrawRay(posFirstTmp, lastDir, Color.red, 1f); //Debug.DrawRay(posFirst, currentDir, Color.cyan, 1f); float anglePrevious = QuaternionExt.GetAngleFromVector(lastDir); float angleCurrent = QuaternionExt.GetAngleFromVector(currentDir); float diffAngleDir; QuaternionExt.IsAngleCloseToOtherByAmount(anglePrevious, angleCurrent, angleDifferenceMarginForPivotPoint, out diffAngleDir); if (diffAngleDir > marginAngleConsideredAsEqual) { diffAdd += diffAngleDir; } //Debug.Log("anglePrevious: " + anglePrevious + ", angleCurrent: " + angleCurrent); //Debug.Log("diffAdd: " + diffAdd + " (+" + diffAngleDir + ")"); if (diffAdd < angleDifferenceMarginForPivotPoint) { //ici ok même angle, on continue //DebugExtension.DebugWireSphere(GetPosParticle(i), Color.blue, 1f, 1f); numberParticleTested++; lastDir = currentDir; //Debug.Log("next"); } else { //ici on a changé d'angle ! (soit brutalement, soit avec le temps) //ici prendre... la différence entre le premier et ce dernier point testé pointPivot = GetPosParticle(i); distance = Vector3.Distance(playerManager.GetPosPlayer(indexPlayer), pointPivot); numberParticleFromPlayerToPivot = numberParticleTested; //Debug.Log("ici !"); onRope = true; DebugExtension.DebugWireSphere(GetPosParticle(i), Color.blue, 1f, 1f); //Debug.Break(); return; } } //Debug.Log("on prend le dernier"); //ici prendre... le dernier player. (et la distance par rapport au premier player) pointPivot = playerManager.GetPosPlayer(1); distance = Vector3.Distance(playerManager.GetPosPlayer(0), pointPivot); numberParticleFromPlayerToPivot = numberParticleTested; return; } else { Vector3 posFirst = GetPosParticle(GetSizeConstrain()); Vector3 posSecond = GetPosParticle(GetSizeConstrain() - startPoint); lastDir = posSecond - posFirst; for (int i = GetSizeConstrain() - startPoint; i >= 1; i--) { Vector3 posFirstTmp = posFirst; posFirst = GetPosParticle(i); posSecond = GetPosParticle(i - 1); currentDir = posSecond - posFirst; if (currentDir == Vector3.zero) { //ici ok même angle, on continue //DebugExtension.DebugWireSphere(GetPosParticle(i), Color.blue, 1f, 1f); numberParticleTested++; //lastDir = currentDir; //Debug.Log("next"); continue; } //Debug.DrawRay(posFirstTmp, lastDir, Color.red, 1f); //Debug.DrawRay(posFirst, currentDir, Color.cyan, 1f); float anglePrevious = QuaternionExt.GetAngleFromVector(lastDir); float angleCurrent = QuaternionExt.GetAngleFromVector(currentDir); float diffAngleDir; QuaternionExt.IsAngleCloseToOtherByAmount(anglePrevious, angleCurrent, angleDifferenceMarginForPivotPoint, out diffAngleDir); diffAdd += diffAngleDir; if (diffAdd < angleDifferenceMarginForPivotPoint) { //ici ok même angle, on continue //DebugExtension.DebugWireSphere(GetPosParticle(i), Color.red, 1f, 1f); numberParticleTested++; lastDir = currentDir; } else { //ici on a changé d'angle ! (soit brutalement, soit avec le temps) //ici prendre... la différence entre le dernier et ce dernier point testé pointPivot = GetPosParticle(i); distance = Vector3.Distance(playerManager.GetPosPlayer(indexPlayer), pointPivot); numberParticleFromPlayerToPivot = numberParticleTested; onRope = true; return; } } //ici prendre... le premier player. (et la distance par rapport au dernier player) pointPivot = playerManager.GetPosPlayer(0); distance = Vector3.Distance(playerManager.GetPosPlayer(1), pointPivot); numberParticleFromPlayerToPivot = numberParticleTested; return; } }