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