private void OnTriggerEnter2D(Collider2D collision)
{
if (canContact)
{
OnCollision.Invoke(this);
}
}
public override void TStart()
{
base.TStart();
playAnim("loop");
float dist = (destiny - origin).magnitude;
timeToTravel = dist / speed;
transform.position = origin;
hasCollide = false;
iTween.MoveTo(gameObject,
iTween.Hash(
"position", destiny,
"oncomplete", "GoBack",
"easetype", iTween.EaseType.linear,
"time", timeToTravel));
OnCollision collisionCb = GetComponent <OnCollision>();
if (collisionCb)
{
collisionCb.OnTriggerEnterCallback = OnHitCollider;
collisionCb.OnTriggerStayCallback = OnHitCollider;
}
}
private void Update()
{
_lineRenderer.SetPosition(0, transform.position);
var ray = new Ray(transform.position, transform.forward);
var point = transform.TransformPoint(new Vector3(0, 0, maxLaserLen));
var raycastHits = Physics.RaycastAll(ray, maxLaserLen).ToList();
raycastHits.Sort((a, b) => a.distance.CompareTo(b.distance));
if (raycastHits.Count > 0)
{
foreach (var hit in raycastHits)
{
LaserReceiverData receiver = null;
if (hit.collider && (receiver = hit.collider.GetComponent <LaserReceiverData>()) &&
!receiver.receiveLaser)
{
continue;
}
point = hit.point;
OnCollision?.Invoke(hit.collider);
if (receiver)
{
receiver.OnCollisionWithLaser(this);
}
break;
}
}
_lineRenderer.SetPosition(1, point);
}
private void OnCollisionEnter(Collision collision)
{
if (!IsRunning)
{
return;
}
if (_wasCollided && IsSingleCollisionMode)
{
return;
}
foreach (var contact in collision.contacts)
{
if (!_wasCollided)
{
_wasCollided = true;
}
if (OnCollision != null)
{
OnCollision.Invoke(new SFX_CollisionPoint
{
Point = contact.point,
Normal = contact.normal
});
}
}
}
public void FixedUpdate()
{
var thisContains = false;
foreach (var particle in manager.Around(Position, ScaledSize))
{
Vector2 halfSize = ScaledSize / 2;
Vector2 direction = particle.particleInfo.Position - Position;
direction.x = Mathf.Abs(direction.x);
direction.y = Mathf.Abs(direction.y);
if (direction.x < halfSize.x && direction.y < halfSize.y)
{
OnCollision.Invoke(particle);
thisContains = true;
}
}
if (thisContains ^ lastContains)
{
if (thisContains)
{
OnContains.Invoke();
}
else
{
OnContainsNot.Invoke();
}
}
lastContains = thisContains;
}
public static bool DifferentAlliance(OnCollision a, OnCollision b)
{
return(a.allianceFilter == 0 || // any
b.allianceFilter == 0 || // any
((a.allianceFilter & b.allianceFilter) == 0));// check if they incompatible
// will work for both being 0
}
void OnTriggerEnter2D(Collider2D collision)
{
Log.Message("Столкновение с " + collision.name);
Color partColor = Color.black;
Color orbColor = GetComponent <SpriteRenderer>().color;
PartFlashing partFlashing = null;
if (!collision.TryGetComponent(out partFlashing))
{
Log.Error("Не удалось получить компонент PartFlashing части формы: " + collision.name);
}
else
{
partColor = partFlashing.PartColor;
}
try
{
CollisionData collisionData = new CollisionData(partColor, orbColor, partFlashing);
OnCollision?.Invoke(collisionData);
}
catch
{
Log.Warning("Обработка ошибки генерации данных о колизии.");
Debug.Break();
}
Log.Message("Уничтожение сферы.");
Destroy(gameObject);
}
public override void attackUpdate()
{
if (currentState == Attack.AttackStates.IDLE)
{
Vector3 myFeets = character.getFeet().position;
Vector3 targetFeets = character.currentTarget.getFeet().position;
float diffX = targetFeets.x - myFeets.x;
if (inAtkRange())
{
currentState = Attack.AttackStates.ATTACKING;
character.currentFacing = (diffX > 0)?SoulAvenger.Character.FACING.RIGHT:SoulAvenger.Character.FACING.LEFT;
OnCollision collisionCb = character.GetComponent <OnCollision>();
collisionCb.OnTriggerEnterCallback = OnHitCollider;
collisionCb.OnTriggerStayCallback = OnHitCollider;
hitTimer = 0.0f;
}
}
else if (currentState == Attack.AttackStates.ATTACKING && speed > 0.0f)
{
float diff = Time.deltaTime * ((character.currentFacing == SoulAvenger.Character.FACING.RIGHT)?speed:-speed);
Vector3 newPos = character.getFeet().position + new Vector3(diff, 0, 0);
character.tryToMove(newPos);
}
if (currentState == Attack.AttackStates.ATTACKING)
{
hitTimer += Time.deltaTime;
}
}
public void OnHitCollider(Collider other)
{
bool hasHit = false;
SoulAvenger.Character defender = other.GetComponent <SoulAvenger.Character>();
if (defender == null && other.transform.parent != null)
{
defender = other.transform.parent.GetComponent <SoulAvenger.Character>();
}
if (defender is Hero)
{
hasHit = true;
defender.onAttackFrom(this.attack.character, attack);
Game.game.inflictDamage(defender, attack, critical);
}
if (hasHit)
{
if (destroyOnHit)
{
destroyAmmo();
}
else
{
OnCollision collisionCb = GetComponent <OnCollision>();
if (collisionCb)
{
collisionCb.OnTriggerEnterCallback = null;
collisionCb.OnTriggerStayCallback = null;
}
}
}
}
public PlayerPhysicsCharacter(Entity owner, World world, Vector2 position, float width, float height, float density, OnCollision onCollision, OnSeparation onSeparation)
: base(owner, world, position, width, height, density, onCollision, onSeparation)
{
// Load resources
ConfigFile configFile = PhysicsSystem.GetPhysicsConfigFile();
runSpeed = configFile.SettingGroups[physicsSettings].Settings["runSpeed"].GetValueAsFloat();
runAirControlSpeed = configFile.SettingGroups[physicsSettings].Settings["airControlSpeed"].GetValueAsFloat();
jumpImpulse = configFile.SettingGroups[physicsSettings].Settings["jumpImpulse"].GetValueAsFloat();
wallJumpImpulse = configFile.SettingGroups[physicsSettings].Settings["wallJumpImpulse"].GetValueAsFloat();
airControlAbility = configFile.SettingGroups[physicsSettings].Settings["airControlAbility"].GetValueAsFloat();
terminalVelocity = configFile.SettingGroups[physicsSettings].Settings["terminalVelocity"].GetValueAsFloat();
slideTerminalVelocity = configFile.SettingGroups[physicsSettings].Settings["slideTerminalVelocity"].GetValueAsFloat();
dashMultiplier = configFile.SettingGroups[physicsSettings].Settings["dashMultiplier"].GetValueAsFloat();
wallSlideEnabled = false;
onGroundTimer = new Timer();
onLeftWallTimer = new Timer();
onRightWallTimer = new Timer();
enableOnGroundDelay = true;
enableOnLeftWallDelay = true;
enableOnRightWallDelay = true;
moveSpeed = runSpeed;
airControlSpeed = runAirControlSpeed;
}
public void HandleCollision(GameSession gameSession, ColliderInfo collidedInfo, ColliderInfo colliderInfo, Vector2 collisionPosition, bool amCollided)
{
lock (CollisionCooldownLock)
{
//Check for existing collision cooldown
bool inCooldown = false;
for (int i = 0; i < collisionCooldowns.Count; i++)
{
if (collisionCooldowns[i].collidedInfo.clientIndex == collidedInfo.clientIndex && collisionCooldowns[i].collidedInfo.entityIndex == collidedInfo.entityIndex && collisionCooldowns[i].colliderInfo.clientIndex == colliderInfo.clientIndex && collisionCooldowns[i].colliderInfo.entityIndex == colliderInfo.entityIndex)
{
inCooldown = true;
break;
}
}
if (!inCooldown)
{
//Add collision cooldown
collisionCooldowns.Add(new CollisionCooldown(gameSession.LatestGameTime.TotalGameTime.TotalMilliseconds, colliderInfo, collidedInfo));
//Handle collision
OnCollision.Invoke(gameSession, collidedInfo, colliderInfo, collisionPosition, amCollided);
}
else
{
return;
}
}
}
void OnCollisionEnter(Collision col)
{
if (OnCollision != null)
{
OnCollision.Invoke(col);
}
}
private float VerticalCollisions(Vector2 velocity)
{
var direction = Mathf.Sign(velocity.y);
var distance = Mathf.Abs(velocity.y - skinWidth);
var y = direction < 0
? Collider.bounds.min.y + skinWidth
: Collider.bounds.max.y - skinWidth;
Vector2 rayOrigin = new Vector2(Collider.bounds.center.x, y);
var hit = Physics2D.Raycast(rayOrigin, Vector2.up * direction, distance, cameraLayer);
if (debugRays)
{
Debug.DrawRay(rayOrigin, direction * distance * Vector2.up, Color.green);
}
if (hit)
{
if (ShouldIgnoreCollisions(hit.collider.gameObject))
{
return(velocity.y);
}
velocity.y = (hit.distance - skinWidth) * direction;
collisions.Below = direction == -1;
collisions.Above = direction == 1;
OnCollision?.Invoke(hit.collider.gameObject);
}
return(velocity.y);
}
public virtual void RaiseCollision(ColliderComponent other)
{
if (OnCollision != null)
{
OnCollision.Invoke(other);
}
}
private float HorizontalCollisions(Vector2 velocity)
{
var direction = Mathf.Sign(velocity.x);
var distance = Mathf.Abs(velocity.x - skinWidth);
var x = direction < 0
? Collider.bounds.min.x + skinWidth
: Collider.bounds.max.x - skinWidth;
Vector2 rayOrigin = new Vector2(x, Collider.bounds.center.y);
if (debugRays)
{
Debug.DrawRay(rayOrigin, direction * distance * Vector2.right, Color.green);
}
var hit = Physics2D.Raycast(rayOrigin, Vector2.right * direction, distance, cameraLayer);
if (hit)
{
if (ShouldIgnoreCollisions(hit.collider.gameObject))
{
return(velocity.x);
}
velocity.x = (hit.distance - skinWidth) * direction;
collisions.Left = direction == -1;
collisions.Right = direction == 1;
OnCollision?.Invoke(hit.collider.gameObject);
}
return(velocity.x);
}
public override void TStart()
{
//get the character
character = gameObject.GetComponent <SoulAvenger.Character>();
character.changeAnimation("slash");
//instantiate the effect
effect = Instantiate(Resources.Load("Prefabs/Effects/Slash")) as GameObject;
//set the effect position
Vector3 fxpos = effect.transform.position;
effect.transform.parent = this.transform;
effect.transform.localPosition = fxpos;
//asign a delegate when animation is completed
effect.GetComponent <tk2dAnimatedSprite>().animationCompleteDelegate = onFxComplete;
//set the effect scale
Vector3 scale = effect.transform.localScale;
scale.x *= (character.currentFacing == SoulAvenger.Character.FACING.RIGHT)?1.0f:-1.0f;
effect.transform.localScale = scale;
OnCollision onCollision = effect.GetComponent <OnCollision>();
onCollision.OnTriggerEnterCallback = OnTriggerEnter;
base.TStart();
}
void Start()
{
HighscoreUI.SetActive(false);
UserInputUI.SetActive(true);
timer = FindObjectOfType <Timer>();
collision = FindObjectOfType <OnCollision>();
}
private void FixedUpdate()
{
foreach (var particle in Manager.Particles)
{
OnCollision.Invoke(particle);
}
}
private void LateUpdate()
{
if (_wasCollisionDetected)
{
return;
}
RaycastHit hit;
if (!Physics.Raycast(_transform.position + transform.forward, transform.forward, out hit, RayCastRange))
{
return;
}
var point = hit.point;
var distance = Vector3.Distance(point, _transform.position);
if (distance > Distance)
{
return;
}
_wasCollisionDetected = true;
if (OnCollision != null)
{
OnCollision.Invoke(new CollisionPoint
{
Point = hit.point,
Normal = hit.normal
});
}
}
public override void attackUpdate()
{
if (currentState == Attack.AttackStates.IDLE)
{
Vector3 myFeet = character.getFeetPosition();
Vector3 targetFeet = character.currentTarget.getFeetPosition();
float diffX = targetFeet.x - myFeet.x;
//if the fw vector of my feet are in range with the fw vector of the target's feet
if (myFeet.y > (targetFeet.y - feetsHeightRange) &&
myFeet.y < (targetFeet.y + feetsHeightRange)
)
{
currentState = Attack.AttackStates.ATTACKING;
character.currentFacing = (diffX > 0)?SoulAvenger.Character.FACING.RIGHT:SoulAvenger.Character.FACING.LEFT;
OnCollision collisionCb = character.GetComponent <OnCollision>();
collisionCb.OnTriggerEnterCallback = OnHitCollider;
collisionCb.OnTriggerStayCallback = OnHitCollider;
}
}
else if (currentState == Attack.AttackStates.ATTACKING)
{
float diff = Time.deltaTime * ((character.currentFacing == SoulAvenger.Character.FACING.RIGHT)?speed:-speed);
Vector3 newPos = character.getFeetPosition() + new Vector3(diff, 0, 0);
character.tryToMove(newPos, true);
}
}
private void NotifyCollision(PlayerController player)
{
if (OnCollision != null)
{
OnCollision.Invoke(player);
}
}
private void LateUpdate()
{
if (!IsRunning)
{
return;
}
if (IsSingleCollisionMode && _wasCollided)
{
return;
}
bool wasCollided = false;
Vector3 point = Vector3.zero;
Vector3 normal = Vector3.zero;
switch (DistanceMode)
{
case DistanceComparisonMode.Target:
var distance = Vector3.Distance(_transform.position, TargetPosition);
if (distance <= CollisionDistance)
{
wasCollided = true;
point = TargetPosition;
}
break;
case DistanceComparisonMode.Raycast:
RaycastHit hit;
if (Physics.Raycast(_transform.position, _transform.forward, out hit, CollisionDistance))
{
wasCollided = true;
point = hit.point;
normal = hit.normal;
}
break;
}
if (!wasCollided)
{
return;
}
if (!_wasCollided)
{
_wasCollided = true;
}
if (OnCollision != null)
{
OnCollision.Invoke(new SFX_CollisionPoint
{
Point = point,
Normal = normal
});
}
}
public override void onEndAttack()
{
base.onEndAttack();
OnCollision collisionCb = character.GetComponent <OnCollision>();
collisionCb.OnTriggerEnterCallback = null;
collisionCb.OnTriggerStayCallback = null;
}
public void startCharging()
{
charging = true;
OnCollision collisionCb = character.GetComponent <OnCollision>();
collisionCb.OnTriggerEnterCallback = OnHitCollider;
collisionCb.OnTriggerStayCallback = OnHitCollider;
}
public void stopCharging()
{
charging = false;
OnCollision collisionCb = character.GetComponent <OnCollision>();
collisionCb.OnTriggerEnterCallback = null;
collisionCb.OnTriggerStayCallback = null;
}
private void EventLogic(object obj, CollisionType type, TriggerStyle style,
CollisionResolutionData data = new CollisionResolutionData())
{
OnCollision?.Invoke(obj, new CollisionEventArgs("")
{
CType = type, TStyle = style, CData = data
});
}
private void RunSolidLogic(object objParent, CollisionType type, CollisionResolutionData data)
{
OnCollision?.Invoke(objParent,
new CollisionEventArgs("")
{
CType = type, TStyle = TriggerStyle.None, CData = data
});
}
private void OnTriggerEnter2D(Collider2D other)
{
OnCollision otherCollision = other.GetComponent <OnCollision>();
if (OnCollision.DifferentAlliance(collision, otherCollision))
{
otherCollision.SendDamage(hp);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (canContact)
{
var damageDealer = collision.GetComponent <DamageDealer>();
OnCollision.Invoke(this, damageDealer.damage);
}
}
void FixedUpdate()
{
foreach (var particle in manager.Around(Position, new Vector2(1, 1) * (Radius + manager.Param.Radius)))
{
if (Vector2.Distance(particle.particleInfo.Position, Position) <= Radius + manager.Param.Radius)
{
OnCollision.Invoke(particle);
}
}
}
/// <summary>
/// Add a member to the group
/// </summary>
/// <param name="collider">Collider used to test the collision</param>
/// <param name="action">Action to perform when collision occurs. May be null.</param>
public void Add(Collider collider, OnCollision action)
{
CollisionEntry entry = new CollisionEntry();
entry.collider = collider;
entry.onCollision = action;
m_entries.Add(entry);
collider.m_groups.Add(this);
}
public PhysicsCharacter(Entity owner, World world, Vector2 position, float width, float height, float density, OnCollision onCollision, OnSeparation onSeparation)
: base(owner, world, position, width, height, density)
{
OnRightWall = false;
OnLeftWall = false;
CharOnHead = false;
onGroundInt = 0;
onGroundDelay = false;
onGroundRay = false;
RayCastIncludesDeath = true;
SetUpContactDelegates(onCollision, onSeparation);
}
public void Remove(Collider collider, OnCollision action)
{
for (int i = 0; i < m_entries.Count; ++i)
if (m_entries[i].collider == collider && m_entries[i].onCollision == action)
{
m_entries.RemoveAt(i);
return;
}
}
public void ReplaceAction(Collider collider, OnCollision action)
{
for (int i = 0; i < m_entries.Count; ++i)
if (m_entries[i].collider == collider)
{
m_entries[i].onCollision = action;
return;
}
}
/// <summary>
/// Test collisions with a single other collider.
/// </summary>
/// <param name="objectToTest">Collider to test</param>
/// <param name="action">Action to perform when collision occurs. May be null.</param>
public void DoCollision(Collider objectToTest, OnCollision action)
{
for (int i = 0; i < m_entries.Count; ++i)
if (m_methods.TestCollision(objectToTest, m_entries[i].collider))
{
if (m_entries[i].onCollision != null)
m_entries[i].onCollision(objectToTest);
if (action != null)
action(m_entries[i].collider);
}
}
/// <summary>
/// Add a member to the group
/// </summary>
/// <param name="collider">Collider used to test the collision</param>
/// <param name="action">Action to perform when collision occurs. May be null.</param>
public void Add(Collider collider, OnCollision action)
{
CollisionEntry entry = new CollisionEntry();
entry.collider = collider;
entry.onCollision = action;
m_entries.Add(entry);
collider.m_groups.Add(this);
}
public void SetUpContactDelegates(OnCollision onCollision, OnSeparation onSeparation)
{
this.onCollision = onCollision;
this.onSeparation = onSeparation;
}
public void Initialize(OnCollision pCollision)
{
if( m_pMesh == null)
m_pMesh = GetComponentInChildren<MeshRenderer>();
m_pOnCollision = pCollision;
}
public EnemyPhysicsCharacter(Entity owner, World world, Vector2 position, float width, float height, float density, OnCollision onCollision, OnSeparation onSeparation)
: base(owner, world, position, width, height, density, onCollision, onSeparation)
{
}
