public RunnerStatsMessage(RunnerState currentState, Vector3 velocity, CollisionInfo contacts, InputState currentInput)
{
CurrentState = currentState;
Velocity = velocity;
Contacts = contacts;
CurrentInput = currentInput;
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObjectGroup = collisionInfo.HitObject.CollisionGroup ;
if (hitObjectGroup == CollisionGroup.Ground)
{
}
}
protected virtual void OnCollision(GameObject other, CollisionInfo info)
{
if (Collision != null && other.activeSelf)
{
Collision(this, other, info);
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
if (collisionInfo.HitObject is Ground || collisionInfo.HitObject is StarShrapnel)
{
this.Exists = false;
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
if (collisionInfo.HitObject.CollisionGroup == CollisionGroup.Explosion)
{
this.Exists = false;
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObject = collisionInfo.HitObject;
if (hitObject is Explosion)
{
this.Exists = false;
}
}
// ако снежинката удари земята да изчезва
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObject = collisionInfo.HitObject;
if (hitObject is Ground || hitObject is Snow)
{
this.Exists = false;
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObjectGroup = collisionInfo.HitObject.CollisionGroup;
if (hitObjectGroup == CollisionGroup.Ground || hitObjectGroup == CollisionGroup.Snow)
{
this.Exists = false;
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObjectGroup = collisionInfo.HitObject.CollisionGroup ;
if (hitObjectGroup == CollisionGroup.Ground || hitObjectGroup == CollisionGroup.Snow)
{
this.Exists = false; // added to stop snowflakes passing through the ground (1)
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var fallingStar = collisionInfo.HitObject.CollisionGroup;
if (fallingStar == CollisionGroup.Ground || fallingStar == CollisionGroup.Explosion)
{
this.Exists = false;
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObject = collisionInfo.HitObject;
if (hitObject is Star)
{
Star st = (Star) hitObject;
st.Exists = false;
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
var hitObjectGroup = collisionInfo.HitObject.CollisionGroup;
if (hitObjectGroup == CollisionGroup.Star)
{
var hitObj = collisionInfo.HitObject;
//(hitObj as EnvironmentObject).Exists = false;
}
}
public bool Valid(CollisionInfo other)
{
var equals =
(!Above.HasValue || Above.Equals(other.Above)) &&
(!Below.HasValue || Below.Equals(other.Below)) &&
(!Left.HasValue || Left.Equals(other.Left)) &&
(!Right.HasValue || Right.Equals(other.Right));
return equals;
}
void EffectSettings_CollisionEnter(object sender, CollisionInfo e)
{
if (Effect==null)
return;
var colliders = Physics.OverlapSphere(transform.position, EffectSettings.EffectRadius, EffectSettings.LayerMask);
foreach (var coll in colliders) {
var hitGO = coll.transform;
var renderer = hitGO.GetComponentInChildren<Renderer>();
var effectInstance = Instantiate(Effect) as GameObject;
effectInstance.transform.parent = renderer.transform;
effectInstance.transform.localPosition = Vector3.zero;
effectInstance.GetComponent<AddMaterialOnHit>().UpdateMaterial(coll.transform);
}
}
void InitializeDefault()
{
GetComponent<Renderer>().material.SetFloat("_Chanel", currentShaderIndex);
++currentShaderIndex;
if (currentShaderIndex == 3) currentShaderIndex = 0;
line.SetPosition(0, tRoot.position);
if (IsVertical)
{
if (Physics.Raycast(tRoot.position, Vector3.down, out hit))
{
line.SetPosition(1, hit.point);
if (StartGlow != null) StartGlow.transform.position = tRoot.position;
if (HitGlow != null) HitGlow.transform.position = hit.point;
if (GoLight != null) GoLight.transform.position = hit.point + new Vector3(0, LightHeightOffset, 0);
if (Particles != null) Particles.transform.position = hit.point + new Vector3(0, ParticlesHeightOffset, 0);
if (Explosion != null) Explosion.transform.position = hit.point + new Vector3(0, ParticlesHeightOffset, 0);
}
}
else
{
if (effectSettings.Target != null) tTarget = effectSettings.Target.transform;
else if (!effectSettings.UseMoveVector) { Debug.Log("You must setup the the target or the motion vector"); }
Vector3 targetDirection;
if (!effectSettings.UseMoveVector) {
targetDirection = (tTarget.position - tRoot.position).normalized;
}
else {
targetDirection = tRoot.position + effectSettings.MoveVector * effectSettings.MoveDistance;
}
var direction = tRoot.position + targetDirection * effectSettings.MoveDistance;
if (Physics.Raycast(tRoot.position, targetDirection, out hit, effectSettings.MoveDistance + 1, effectSettings.LayerMask)) {
direction = (tRoot.position + Vector3.Normalize(hit.point - tRoot.position) * (effectSettings.MoveDistance + 1)).normalized;
}
line.SetPosition(1, hit.point - effectSettings.ColliderRadius * direction);
var particlesOffsetPos = hit.point - direction * ParticlesHeightOffset;
if (StartGlow!=null) StartGlow.transform.position = tRoot.position;
if (HitGlow!=null) HitGlow.transform.position = particlesOffsetPos;
if (GoLight!=null) GoLight.transform.position = hit.point - direction * LightHeightOffset;
if (Particles!=null) Particles.transform.position = particlesOffsetPos;
if (Explosion!=null) Explosion.transform.position = particlesOffsetPos;
}
var collInfo = new CollisionInfo { Hit = hit };
effectSettings.OnCollisionHandler(collInfo);
if (hit.transform != null)
{
var shield = hit.transform.GetComponent<ShieldCollisionBehaviour>();
if (shield != null) shield.ShieldCollisionEnter(collInfo);
}
}
void DeactivateAttachedPoints(RaycastHit hit)
{
for (int i = 0; i < AttachedPoints.Length; i++) {
var ap = AttachedPoints[i];
ap.SetActive(false);
}
var collInfo = new CollisionInfo { Hit = hit };
effectSettings.OnCollisionHandler(collInfo);
if (hit.transform != null)
{
var shield = hit.transform.GetComponent<ShieldCollisionBehaviour>();
if (shield != null) shield.ShieldCollisionEnter(collInfo);
}
onCollision = true;
}
public void ShieldCollisionEnter(CollisionInfo e)
{
if (e.Hit.transform!=null) {
if (IsWaterInstance) {
var go = Instantiate(ExplosionOnHit) as GameObject;
var t = go.transform;
t.parent = transform;
var scale = transform.localScale.x * ScaleWave;
t.localScale = new Vector3(scale, scale, scale);
t.localPosition = new Vector3(0, 0.001f, 0);
t.LookAt(e.Hit.point);
}
else {
if (EffectOnHit!=null) {
if (!CreateMechInstanceOnHit) {
var hitGO = e.Hit.transform;
var renderer = hitGO.GetComponentInChildren<Renderer>();
var effectInstance = Instantiate(EffectOnHit) as GameObject;
effectInstance.transform.parent = renderer.transform;
effectInstance.transform.localPosition = Vector3.zero;
var addMat = effectInstance.GetComponent<AddMaterialOnHit>();
addMat.SetMaterialQueue(currentQueue);
addMat.UpdateMaterial(e.Hit);
}
else {
var effectInstance = Instantiate(EffectOnHit) as GameObject;
var tr = effectInstance.transform;
tr.parent = GetComponent<Renderer>().transform;
tr.localPosition = Vector3.zero;
tr.localScale = transform.localScale * ScaleWave;
tr.LookAt(e.Hit.point);
tr.Rotate(AngleFix);
effectInstance.GetComponent<Renderer>().material.renderQueue = currentQueue-1000;
}
}
if (currentQueue > 4000) currentQueue = 3001;
else ++currentQueue;
if (ExplosionOnHit!=null) {
var inst2 = Instantiate(ExplosionOnHit, e.Hit.point, new Quaternion()) as GameObject;
inst2.transform.parent = transform;
}
}
}
//Debug.Log(e.Hit.textureCoord);
}
public void OnCollisionHandler(CollisionInfo e)
{
for (int i = 0; i < lastActiveIndex; i++)
{
Invoke("SetGoActive", active_value[i]);
}
for (int i = 0; i < lastInactiveIndex; i++)
{
Invoke("SetGoInactive", inactive_value[i]);
}
var handler = CollisionEnter;
if (handler != null)
handler(this, e);
if (DeactivateAfterCollision && !deactivatedIsWait)
{
deactivatedIsWait = true;
Invoke("Deactivate", DeactivateTimeDelay);
}
}
void _Collided(CollisionInfo info)
{
if (enabled && triggerable)
{
triggerCount--;
triggerable = false;
if (triggerCount > 0 || triggerCount == -1)
{
if (Check(info))
{
Triggered(info);
}
}
else
{
Disable();
}
}
}
CollisionInfo TestCollideWithPolygon(Vector2 moveBy, Polygon other)
{
//test collision of this polygon's points against edges of other polygon
CollisionInfo ret = TestPointsCollideWithPolygon(moveBy, other);
CollisionInfo collisionOther = other.TestPointsCollideWithPolygon(-moveBy, this);
if (collisionOther.IsCollision && (!ret.IsCollision || collisionOther.Fraction < ret.Fraction))
{
ret = collisionOther;
//reverse the collision so it's from this polygon's point of view
ret.Type = CollisionType.EdgeStrikesVertex;
int tmp = ret.IndexOfStriking;
ret.IndexOfStriking = collisionOther.IndexOfStruck;
ret.IndexOfStruck = tmp;
//collided with point of other, but the collision info holds the point of intersection with self
//so reset it to the point of the other that we struck
ret.Impact = other.ToWorld(other._points[ret.IndexOfStruck]);
}
return(ret);
}
public void MakeResponse(CollisionInfo collision)
{
collision.BodyA.BeforeCollision(collision);
collision.BodyB.BeforeCollision(collision);
if (collision.BodyA.type == FBBodyType.Dynamic)
{
collision.BodyA.Position += collision.AMovement.ValidMovement;
collision.BodyA.SetMove(collision.AMovement.RemainderAxisMovement);
}
if (collision.BodyB.type == FBBodyType.Dynamic)
{
collision.BodyB.Position += collision.BMovement.ValidMovement;
collision.BodyB.SetMove(collision.BMovement.RemainderAxisMovement);
}
collision.BodyA.AfterCollision(collision);
collision.BodyB.AfterCollision(collision);
}
public void DealDamage(CollisionInfo i)
{
if (isDead)
{
return;
}
usePhysics = true;
if (!isImmune)
{
info = i;
if (!immortal)
{
life -= info.totalDmg;
}
if (life <= 0)
{
isDead = true;
OnDeath.Invoke();
}
else
{
StartCoroutine(HitStun());
StartCoroutine(HitImmune());
}
//StartCoroutine(HitStun());
//StartCoroutine(HitImmune());
//if (life <= 0)
//{
// OnDeath.Invoke();
//}
}
else
{
return;
}
}
bool Check(CollisionInfo info)
{
if (acceptableCollisionTypes.Count > 0)
{
string insta = info.Instigator.GetType().ToString();
string col = info.Collider.GetType().ToString();
if (acceptableCollisionTypes.Contains(insta))
{
return(true);
}
else if (acceptableCollisionTypes.Contains(col))
{
return(true);
}
return(false);
}
return(true);
}
public void OnCollision(CollisionInfo c)
{
Position -= c.PenetrationVector;
Velocity = Vector2.Zero;
//if (c.PenetrationVector.X != 0)
//{
// Position -= c.PenetrationVector;
// Velocity = new Vector2(0, Velocity.Y);
//}
//else
//{
// if (Velocity.Y > 0)
// IsOnGround = true;
// var d = Position.Y < c.Other.BoundingBox.Center.Y
// ? c.IntersectingRectangle.Height
// : -c.IntersectingRectangle.Height;
// Position = new Vector2(Position.X, Position.Y - d);
// Velocity = new Vector2(Velocity.X, 0);
//}
}
void HorizontalCollisions(Vector3 velocity, ref CollisionInfo collisions)
{
float directionX = Mathf.Sign(velocity.x); //vertical direction (1 eller -1)
float rayLength = collisionDistance + skinWidth;
for (int i = 0; i < horizontalRayCount; i++)
{
Vector2 rayOrigin = (directionX == -1) ? raycastOrigins.botLeft : raycastOrigins.botRight; //sätter raycasts Start till Vänster eller Höger av BoxCollidern
rayOrigin += Vector2.up * (horizontalRaySpacing * i);
RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, collisionMask);
Debug.DrawRay(rayOrigin, Vector2.right * directionX * rayLength, Color.red);
if (hit)
{
velocity.x = (hit.distance - skinWidth) * directionX; //sätter velocity till avståndet till det object som kolliderades med
rayLength = hit.distance; //Sätter rayLength till velocity, så att de inte letar efter object under kollisionen
collisions.left = directionX == -1;
collisions.right = directionX == 1;
}
}
}
public void Step()
{
oldPosition = position;
oldVelocity = velocity;
if (grounded)
{
grounded = false;
}
else
{
velocity += acceleration;
}
position += velocity;
CollisionInfo firstCollision = FindEarliestCollision();
if (firstCollision != null)
{
ResolveCollision(firstCollision);
}
UpdateScreenPosition();
}
private void CheckForDeflect(System.Object prevCollisionInfoObj, System.Object collisionInfoObj)
{
CollisionInfo collisionInfo = (CollisionInfo)collisionInfoObj;
GameObject otherObj = collisionInfo.other.gameObject;
//If going fast enough into the normal, deflect with knockback
Vector3 velocityIntoNormal = Vector3.Project(previousVelocityOutput, -collisionInfo.contactNormal);
float velocityGroundDot = Vector3.Dot(previousVelocityOutput.normalized, collisionInfo.contactNormal);
if (EnableDeflect && velocityIntoNormal.magnitude >= DeflectThresholdVelocity.Value &&
-velocityGroundDot > DeflectContactDotThreshold.Value)
{
//Reflect velocity in the XZ plane
DeflectGameEvent.Raise();
storedDeflectVelocity = Vector3.Reflect(NewVelocityOut.Value.normalized, collisionInfo.contactNormal);
storedDeflectVelocity =
storedDeflectVelocity.xoz() * NewVelocityOut.Value.xoz().magnitude *DeflectFactor.Value;
}
}
public Vector2 Move(Vector2 moveAmount, bool standingOnPlatform = false)
{
moveAmount += extraMove;
extraMove = Vector2.zero;
UpdateRaycastOrigins();
moveAmount = moveAmount.Rotate(-transform.eulerAngles.z);
CollisionInfo old = new CollisionInfo(collisions);
collisions.Reset();
collisions.moveAmountOld = moveAmount;
if (moveAmount.y < 0)
{
DescendSlope(ref moveAmount);
}
if (moveAmount.x != 0)
{
collisions.faceDir = (int)Mathf.Sign(moveAmount.x);
}
HorizontalCollisions(ref moveAmount);
if (moveAmount.y != 0)
{
VerticalCollisions(ref moveAmount);
}
// translate is affected by rotation, so don't rotate the moveAmount back to original
//moveAmount = moveAmount.Rotate(transform.eulerAngles.z);
transform.Translate(moveAmount);
if (standingOnPlatform)
{
collisions.below = true;
}
return(moveAmount);
}
/// <summary>
/// Redirects a sphere to be on collision course towards a point
/// </summary>
/// <param name="transition">The transition information for the sphere</param>
/// <param name="checkPos">The spherical point to redirect towards</param>
/// <param name="disp">Currently doesn't seem to be used?</param>
/// <param name="radsum">The sum of the sphere and spherical point radii</param>
/// <param name="sphereNum">Used as an offset in path.GlobalCurrCenter to determine movement</param>
/// <returns>The TransitionState either collided or adjusted</returns>
public TransitionState CollideWithPoint(Transition transition, Sphere checkPos, Vector3 disp, float radsum, int sphereNum)
{
var obj = transition.ObjectInfo;
var path = transition.SpherePath;
var collisions = transition.CollisionInfo;
var gCenter = path.GlobalCurrCenter[sphereNum].Center;
var globalOffset = gCenter - Center;
// if set to PerfectClip, does a more precise check
if (obj.State.HasFlag(ObjectInfoState.PerfectClip))
{
var blockOffset = LandDefs.GetBlockOffset(path.CurPos.ObjCellID, path.CheckPos.ObjCellID);
var checkOffset = checkPos.Center - gCenter + blockOffset;
var collisionTime = FindTimeOfCollision(checkOffset, globalOffset, radsum + PhysicsGlobals.EPSILON);
if (collisionTime > PhysicsGlobals.EPSILON || collisionTime < -1.0f)
{
return(TransitionState.Collided);
}
else
{
var collisionOffset = checkOffset * (float)collisionTime;
var old_disp = collisionOffset + checkOffset - Center; // ?? verify
var invRad = 1.0f / radsum;
var collision_normal = old_disp * invRad;
collisions.SetCollisionNormal(collision_normal);
path.AddOffsetToCheckPos(old_disp, checkPos.Radius);
return(TransitionState.Adjusted);
}
}
else
{
if (!CollisionInfo.NormalizeCheckSmall(ref globalOffset))
{
collisions.SetCollisionNormal(globalOffset);
}
return(TransitionState.Collided);
}
}
public static CollisionInfo checkCollision(GeomBase geom1, GeomBase geom2, MapData mapData)
{
//把大的放在前面！
if (geom1.type > geom2.type)
{
GeomBase temp = geom1;
geom1 = geom2;
geom2 = temp;
}
if (geom1.applyEntity)
{
geom1.position.copy(geom1.entity.position);
geom1.angle = geom1.entity.angle;
}
if (geom2.applyEntity)
{
geom2.position.copy(geom2.entity.position);
geom2.angle = geom2.entity.angle;
}
CollisionInfo result = realPosition(geom1.position, geom2.position, mapData);
geom1.position.copy(result.pos1);
geom2.position.copy(result.pos2);
geom1.updatePoints();
geom2.updatePoints();
int type = geom1.type | geom2.type;
result = handlerMap[1](geom1, geom2);
//非圆形 就再判断一次！
if (result.isHit && type != 1)
{
result = handlerMap[type](geom1, geom2);
}
return(result);
}
CollisionInfo[] GetObstacles()
{
//return Root.Instance.Scene.FindEntitiesByType<Node>();
List <CollisionInfo> list = new List <CollisionInfo>();
foreach (Node n in Root.Instance.Scene.FindEntitiesByType <Node>())
{
if (!n.CanCollide(Owner) || n == Owner || n is SpaceWar2006.Weapons.Projectile || n is SpaceWar2006.Effects.EclipticNode || n is SpaceWar2006.GameObjects.SpawnPoint || n is SpaceWar2006.GameObjects.Flag || n is SpaceWar2006.GameObjects.SpaceShip)
{
continue;
}
CollisionInfo ci = n.GetCollisionInfo();
if (ci != null)
{
//System.Console.WriteLine(n.ToString());
list.Add(ci);
}
}
return(list.ToArray());
}
public void OnCollisionHandler(CollisionInfo e)
{
for (int i = 0; i < this.lastActiveIndex; i++)
{
base.Invoke("SetGoActive", this.active_value[i]);
}
for (int j = 0; j < this.lastInactiveIndex; j++)
{
base.Invoke("SetGoInactive", this.inactive_value[j]);
}
EventHandler <CollisionInfo> collisionEnter = this.CollisionEnter;
if (collisionEnter != null)
{
collisionEnter(this, e);
}
if (this.DeactivateAfterCollision && !this.deactivatedIsWait)
{
this.deactivatedIsWait = true;
base.Invoke("Deactivate", this.DeactivateTimeDelay);
}
}
public override void CollisionReaction(CollisionInfo collisionInfo_)
{
base.CollisionReaction(collisionInfo_);
GameObject with = collisionInfo_.collidedWithGameObject;
if (with.Name == "PlayerBody" && playerAffected == false)
{
float xdiff = with.Position.X - Position.X;
float ydiff = with.Position.Y - Position.Y;
float xsquared = xdiff * xdiff;
float ysquared = ydiff * ydiff;
float length = (float)Math.Sqrt(xsquared + ysquared);
xdiff /= length;
ydiff /= length;
HelperObject ho = (HelperObject)ObjectManager.GetObjectByName("HelperObject");
ho.xVel = xdiff * (1000 / (length + 200));
ho.yVel = ydiff * (1000 / (length + 200));
playerAffected = true;
}
}
void VerticalCollisions(Vector3 velocity, ref CollisionInfo collisions)
{
float directionY = Mathf.Sign(velocity.y); //vertical direction (1 eller -1)
float rayLength = collisionDistance + skinWidth;
for (int i = 0; i < verticalRayCount; i++)
{
Vector2 rayOrigin = (directionY == -1) ? raycastOrigins.botLeft : raycastOrigins.topLeft; //sätter raycasts Start till toppen eller botten av BoxColliderns
rayOrigin += Vector2.right * (verticalRaySpacing * i);
RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, collisionMask);
Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.red);
if (hit)
{
velocity.y = (hit.distance - skinWidth) * directionY; //sätter velocity till avståndet till det object som kolliderades med
rayLength = hit.distance; //Sätter rayLength till velocity, så att de inte letar efter object under kollisionen
collisions.below = directionY == -1;
collisions.above = directionY == 1;
}
}
}
public override void CollisionReaction(CollisionInfo collisionInfo_)
{
base.CollisionReaction(collisionInfo_);
GameObject with = collisionInfo_.collidedWithGameObject;
if (with.Name == "nullfield")
{
collidingWithNullField = true;
this.IsDead = true;
}
if (collidingWithNullField == false)
{
if (with.Name == "PlayerBody")
{
PersistentData.Health -= damage;
this.IsDead = true;
}
if (with.Name == "EnemyBody")
{
this.IsDead = true;
}
if (with.Name == "bullet1")
{
this.IsDead = true;
}
if (with.Name == "bullet2")
{
this.IsDead = true;
}
if (with.Name == "bullet3")
{
this.IsDead = true;
}
if (with.Name == "bullet4")
{
this.IsDead = true;
}
}
}
public void OnCollisionHandler(CollisionInfo e)
{
for (int i = 0; i < lastActiveIndex; i++)
{
Invoke("SetGoActive", active_value[i]);
}
for (int i = 0; i < lastInactiveIndex; i++)
{
Invoke("SetGoInactive", inactive_value[i]);
}
var handler = CollisionEnter;
if (handler != null)
{
handler(this, e);
}
if (InstanceBehaviour == DeactivationEnum.DestroyAfterCollision)
{
Destroy(gameObject, DestroyTimeDelay);
}
}
private void VerticalRays(BoundsCorners corners, float verticalDisplacement, ref CollisionInfo collisions)
{
if (Mathf.Approximately(verticalDisplacement, 0f))
{
return;
}
bool isMovingUp = Mathf.Sign(verticalDisplacement) > 0f;
Vector2 rayDirection = isMovingUp ? Vector2.up : Vector2.down;
float rayLength = Mathf.Abs(verticalDisplacement) + skinWidth;
Vector2 rayOrigin = isMovingUp ? corners.topLeft : corners.bottomLeft;
rayOrigin.x += collisions.vec.x;
for (int i = 0; i < verticalRayCount; i++)
{
RaycastHit2D hit = Physics2D.Raycast(rayOrigin, rayDirection, rayLength, collisionMask);
Debug.DrawRay(rayOrigin, rayDirection * rayLength, Color.red);
if (hit)
{
rayLength = hit.distance;
// collisions.collider2D = hit.collider;
if (isMovingUp)
{
collisions.above = true;
}
else
{
collisions.below = true;
}
}
rayOrigin += Vector2.right * verticalRaySpacing;
}
collisions.vec.y = (rayLength - skinWidth) * rayDirection.y;
}
/// <summary>
/// Collisions triggered.
/// </summary>
/// <param name="collided">The collided.</param>
public override void CollisionTriggered(CollisionInfo collided)
{
if (Vector2.Dot(collided.NormalVector, new Vector2(0.0f, 1.0f)) > 0)
{
_isGrounded = false;
}
else
{
_isGrounded = true;
}
if (!_alreadySpawnedDust && Vector2.Dot(collided.NormalVector, new Vector2(0.0f, -1.0f)) > 0)
{
Entity dust = new EmptyEntity(
collided.PointOfCollision + new Vector2(0, 16.0f),
"Effects_Dust_Ground",
0.5f,
true);
LevelManager.Instance.SpawnTempEntity(dust.Id, dust);
_alreadySpawnedDust = true;
}
}
void DeactivateAttachedPoints(RaycastHit hit)
{
for (int i = 0; i < AttachedPoints.Length; i++)
{
var ap = AttachedPoints[i];
ap.SetActive(false);
}
var collInfo = new CollisionInfo {
Hit = hit
};
effectSettings.OnCollisionHandler(collInfo);
if (hit.transform != null)
{
var shield = hit.transform.GetComponent <ShieldCollisionBehaviour>();
if (shield != null)
{
shield.ShieldCollisionEnter(collInfo);
}
}
onCollision = true;
}
public void OnCollisionHandler(CollisionInfo e)
{
for (int i = 0; i < lastActiveIndex; i++)
{
Invoke("SetGoActive", active_value[i]);
}
for (int i = 0; i < lastInactiveIndex; i++)
{
Invoke("SetGoInactive", inactive_value[i]);
}
var handler = CollisionEnter;
if (handler != null)
{
handler(this, e);
}
if (DeactivateAfterCollision && !deactivatedIsWait)
{
deactivatedIsWait = true;
Invoke("Deactivate", DeactivateTimeDelay);
}
}
public override void CollisionReaction(CollisionInfo collisionInfo_)
{
base.CollisionReaction(collisionInfo_);
GameObject with = collisionInfo_.collidedWithGameObject;
if (with.Name == "PlayerBody")
{
PersistentData.Level += 1;
if (PersistentData.Level == 1)
{
GameStateManager.GoToState(new Level1());
}
if (PersistentData.Level == 2)
{
GameStateManager.GoToState(new Level2());
}
if (PersistentData.Level == 3)
{
GameStateManager.GoToState(new Level3());
}
if (PersistentData.Level == 4)
{
GameStateManager.GoToState(new Level4());
}
if (PersistentData.Level == 5)
{
GameStateManager.GoToState(new Level5());
}
if (PersistentData.Level == 6)
{
GameStateManager.GoToState(new Level6());
}
if (PersistentData.Level == 7)
{
GameStateManager.GoToState(new TitleScreen());
}
}
}
public void MovementAnimation(Vector3 _movementVelocity, CollisionInfo _collisions)
{
if (controllerToUse == null)
{
if (_collisions.below)
{
if (jumping)
{
jumping = false;
BodyJump(false);
HeadJump(false);
}
if (!moving && (_movementVelocity.x < -0.001f || _movementVelocity.x > 0.001f))
{
moving = true;
HeadMovement(true);
BodyMovement(true);
}
else if (moving && (_movementVelocity.x > -0.001f && _movementVelocity.x < 0.001f))
{
moving = false;
HeadMovement(false);
BodyMovement(false);
}
}
else if (!_collisions.below && !jumping)
{
jumping = true;
BodyJump(true);
HeadJump(true);
}
}
else
{
controllerToUse.MovementAnimation(_movementVelocity, _collisions);
}
}
// Use this for initialization
//CONVERTED
void Start()
{
if (isServer)
{
foreach (Transform childTransform in transform)
{
NetworkedCollisionToParent colPar = childTransform.gameObject.AddComponent <NetworkedCollisionToParent>();
colPar.parent = transform.gameObject;
for (int i = 0; i < numCollisions; i++)
{
CollisionInfo ci = new CollisionInfo
{
time = 0f,
pos = Vector3.zero,
dir = Vector3.zero,
active = 0f,
speed = 0f,
};
collisions.Add(ci);
}
}
}
collisionValues = new float[numCollisions * COLLISION_SIZE];
//collisions = new CollisionInfo[numCollisions];
//TODO: Find out if this needs to be done for clients
roomAudio = transform.gameObject.GetComponent <RoomAudio>();
createBuffers();
createMaterial();
_kernel = computeShader.FindKernel("CSMain");
PostRenderEvent.PostRender += Render;
}
public static void HandleCollisions(IList <EnvironmentObject> objects)
{
foreach (var obj in objects)
{
collidingObjects.Insert(obj);
}
foreach (var obj in objects)
{
var candidateCollisionItems =
collidingObjects.GetItems(new List <ICollidable>(), obj.Bounds);
foreach (var item in candidateCollisionItems)
{
if (Rectangle.Intersects(obj.Bounds, item.Bounds) && item != obj)
{
var collisionInfo = new CollisionInfo(item);
obj.RespondToCollision(collisionInfo);
}
}
}
collidingObjects.Clear();
}
public static string GetDebugCollisionMessage(CollisionInfo colInfo)
{
string whatHappened;
if (colInfo.collisionState == CollisionInfo.CollisionState.enter)
{
whatHappened = " entered ";
}
else if (colInfo.collisionState == CollisionInfo.CollisionState.stay)
{
whatHappened = " stayed in ";
}
else if (colInfo.collisionState == CollisionInfo.CollisionState.exit)
{
whatHappened = " exited ";
}
else
{
whatHappened = " ? ";
}
return(colInfo.sender.name + whatHappened + colInfo.collidedWith.name + ", isTrigger: " + colInfo.isTrigger);
}
/// <summary>
/// Method to write to all surface VB databases
/// </summary>
/// <param name="dp">photon data point</param>
/// <param name="collisionInfo">collision information</param>
public void WriteToSurfaceVirtualBoundaryDatabases(PhotonDataPoint dp, CollisionInfo collisionInfo)
{
var writeData = false;
foreach (var writer in _photonDatabaseWriters)
{
if (DPBelongsToSurfaceVirtualBoundary(dp, writer))
{
writer.Write(dp);
writeData = true;
}
}
;
// not best design but may work for now
foreach (var writer in _collisionInfoDatabaseWriters)
{
if (writeData)
{
writer.Write(collisionInfo);
}
}
;
}
public CollisionInfo CollisionDetection(Tile mobile, Point destination)
{
var target = this[destination];
var collisionInfo = new CollisionInfo{
Tile = mobile,
Vector = mobile.Location.NormalizedVector(destination)};
if (target != null)
{
collisionInfo.Collision = _collisionRules.All(r => r(mobile, target));
collisionInfo.Object = target;
}
if (collisionInfo.Tile != null && collisionInfo.Object != null && collisionInfo.Object != collisionInfo.Tile)
{
if (collisionInfo.Tile.OnCollision != null)
collisionInfo.Messages.AddRange(collisionInfo.Tile.GetCollisionResponse(collisionInfo));
if (collisionInfo.Object.OnCollision != null)
collisionInfo.Messages.AddRange(collisionInfo.Object.GetCollisionResponse(collisionInfo));
}
return collisionInfo;
}
private void OnHighSpeedCollision(CollisionInfo collision)
{
bool collided = false;
foreach (var living in MatrixManager.GetAt <LivingHealthBehaviour>(collision.CollisionTile, true))
{
living.ApplyDamage(gameObject, collision.Damage, AttackType.Melee, DamageType.Brute, BodyPartType.Chest.Randomize(0));
collided = true;
}
foreach (var tile in MatrixManager.GetDamagetableTilemapsAt(collision.CollisionTile))
{
tile.DoMeleeDamage(collision.CollisionTile.To2Int(), gameObject, (int)collision.Damage);
collided = true;
}
if (collided)
{
//Damage self as bad as the thing you collide with
GetComponent <LivingHealthBehaviour>()?.ApplyDamage(gameObject, collision.Damage, AttackType.Melee, DamageType.Brute, BodyPartType.Chest.Randomize(0));
Logger.LogFormat("{0}: collided with something at {2}, both received {1} damage",
Category.Health, gameObject.name, collision.Damage, collision.CollisionTile);
}
}
public void CollidedWith(Body otherBody, Vector2 collisionAxes, CollisionInfo <Body> hCollisionInfo, CollisionInfo <Body> vCollisionInfo)
{
if (!Active || Entity == null || !Entity.Active)
{
return;
}
if (_currentUpdateCollisionList.Contains(otherBody))
{
return;
}
_currentUpdateCollisionList.Add(otherBody);
_notCollidingAnymoreList.Remove(otherBody);
if (!_collisionList.Contains(otherBody))
{
_collisionList.Add(otherBody);
BeginCollision(otherBody, collisionAxes, hCollisionInfo, vCollisionInfo);
}
Collided(otherBody, collisionAxes, hCollisionInfo, vCollisionInfo);
}
private void CollisionEnter()
{
if (EffectOnHitObject!=null && hit.transform!=null) {
var hitGO = hit.transform;
var renderer = hitGO.GetComponentInChildren<Renderer>();
var effectInstance = Instantiate(EffectOnHitObject) as GameObject;
effectInstance.transform.parent = renderer.transform;
effectInstance.transform.localPosition = Vector3.zero;
effectInstance.GetComponent<AddMaterialOnHit>().UpdateMaterial(hit);
}
if (AttachAfterCollision)
tRoot.parent = hit.transform;
if (SendCollisionMessage) {
var collInfo = new CollisionInfo {Hit = hit};
effectSettings.OnCollisionHandler(collInfo);
if (hit.transform != null) {
var shield = hit.transform.GetComponent<ShieldCollisionBehaviour>();
if (shield != null) shield.ShieldCollisionEnter(collInfo);
}
}
onCollision = true;
}
public void OnCollisionHandler(CollisionInfo e)
{
for (int i = 0; i < lastActiveIndex; i++)
{
Invoke("SetGoActive", active_value[i]);
}
for (int i = 0; i < lastInactiveIndex; i++)
{
Invoke("SetGoInactive", inactive_value[i]);
}
var handler = CollisionEnter;
if (handler != null)
handler(this, e);
if (InstanceBehaviour == DeactivationEnum.Deactivate && !deactivatedIsWait)
{
deactivatedIsWait = true;
Invoke("Deactivate", DeactivateTimeDelay);
}
if (InstanceBehaviour == DeactivationEnum.DestroyAfterCollision) Destroy(gameObject, DestroyTimeDelay);
}
private static void CalculateVertexEdgePoint(CollisionFunctor cf, PolyhedronPart a, PolyhedronPart b, ref CollisionInfo ci)
{
Vector3 pa, pb;
Segment eb;
float sb;
int[] edgeB = b.Edge(ci.FeatureB.Index);
b.World(edgeB[0], out eb.P1);
b.World(edgeB[1], out eb.P2);
a.World(ci.FeatureA.Index, out pa);
eb.ClosestPointTo(ref pa, out sb, out pb);
cf.WritePoint(ref pa, ref pb, ref ci.Normal);
}
private static void CalculateFaceFacePoints(CollisionFunctor cf, PolyhedronPart a, PolyhedronPart b, ref CollisionInfo ci)
{
int[] faceA = a.Face(ci.FeatureA.Index);
int[] faceB = b.Face(ci.FeatureB.Index);
Vector3 pa, pb, n;
a.World(faceA[0], out pa);
a.FaceNormal(ci.FeatureA.Index, out n);
Plane planeA = new Plane(pa, n);
b.World(faceB[0], out pb);
Plane planeB = new Plane(pb, ci.Normal);
// vertices of A contained in face of B
for (int i = 0; i < faceA.Length; i++)
{
a.World(faceA[i], out pa);
planeB.ClosestPointTo(ref pa, out pb);
if(b.IsPointOnFace(ci.FeatureB.Index, ref pb, true))
{
cf.WritePoint(ref pa, ref pb, ref ci.Normal);
}
}
// vertices of B contained in face of A
for (int i = 0; i < faceB.Length; i++)
{
b.World(faceB[i], out pb);
planeA.ClosestPointTo(ref pb, out pa);
if (a.IsPointOnFace(ci.FeatureA.Index, ref pa, true))
{
cf.WritePoint(ref pa, ref pb, ref ci.Normal);
}
}
// intersections of edges from both faces
Segment ea, eb;
for (int i = 0; i < faceA.Length; i++)
{
a.World(faceA[i == 0 ? faceA.Length - 1 : i - 1], out ea.P1);
a.World(faceA[i], out ea.P2);
for (int j = 0; j < faceB.Length; j++)
{
b.World(faceB[j == 0 ? faceB.Length - 1 : j - 1], out eb.P1);
b.World(faceB[j], out eb.P2);
float sa, sb;
Segment.ClosestPoints(ref ea, ref eb, out sa, out pa, out sb, out pb);
if (sa > 0f && sa < 1f && sb > 0f && sb < 1f)
{
cf.WritePoint(ref pa, ref pb, ref ci.Normal);
}
}
}
}
public override void RespondToCollision(CollisionInfo collisionInfo)
{
}
private static void CalculateVertexFacePoint(CollisionFunctor cf, PolyhedronPart a, PolyhedronPart b, ref CollisionInfo ci)
{
Vector3 pa, pb;
a.World(ci.FeatureA.Index, out pa);
b.World(b.Face(ci.FeatureB.Index)[0], out pb);
var plane = new Plane(pb, ci.Normal);
plane.ClosestPointTo(ref pa, out pb);
cf.WritePoint(ref pa, ref pb, ref ci.Normal);
}
private static void CalculateVertexVertexPoint(CollisionFunctor cf, PolyhedronPart a, PolyhedronPart b, ref CollisionInfo ci)
{
Vector3 pa, pb;
a.World(ci.FeatureA.Index, out pa);
b.World(ci.FeatureB.Index, out pb);
cf.WritePoint(ref pa, ref pb, ref ci.Normal);
}
void prefabSettings_CollisionEnter(object sender, CollisionInfo e)
{
anim.speed = 0;
}
private void prefabSettings_CollisionEnter(object sender, CollisionInfo e)
{
isCollisionEnter = true;
if (!isIn && FadeOutAfterCollision) Invoke("SetupFadeOutDelay", FadeOutDelay);
}
private void RecurseNodes(System.Management.Automation.PSCmdlet cmdlet, MappingToolDatabaseDataContext mapDatabaseContext, QueryMapNode rootMap, QueryMapNode node, HashSet<Guid> convertedNodes, List<CollisionInfo> collisions, bool fillRootMapId)
{
var dbNodes = from qNode in mapDatabaseContext.Nodes
where qNode.NodeUid == node.NodeUid
select qNode;
if (dbNodes != null && dbNodes.Count() > 0)
{
var dbNode = dbNodes.First();
convertedNodes.Add(dbNode.NodeUid);
if (dbNode.RootMapUid != null && dbNode.RootMapUid != rootMap.NodeUid)
{
CollisionInfo collisionInfo = new CollisionInfo();
collisionInfo.CollisionPoint = node;
collisionInfo.CurrentRootMap = dbNode.RootMapUid.Value;
collisionInfo.CollidingRootMap = rootMap;
collisions.Add(collisionInfo);
cmdlet.WriteWarning("Collision detected.");
}
else if (dbNode.RootMapUid == null && fillRootMapId)
{
dbNode.RootMapUid = rootMap.NodeUid;
mapDatabaseContext.SubmitChanges();
}
}
IEnumerable<QueryMapRelationship> relationships = Consumer.GetRelationships(node, MapContainerRelationship);
foreach (QueryMapRelationship relationship in relationships)
{
IEnumerable<QueryMapNode> children = Consumer.GetNodes(relationship, node);
foreach (QueryMapNode childNode in children)
{
if (!convertedNodes.Contains(childNode.NodeUid))
{
RecurseNodes(cmdlet, mapDatabaseContext, rootMap, childNode, convertedNodes, collisions, fillRootMapId);
}
}
}
}
void effectSettings_CollisionEnter(object sender, CollisionInfo e)
{
var direction = (tRoot.position + Vector3.Normalize(e.Hit.point - tRoot.position) * (effectSettings.MoveDistance + 1)).normalized;
transform.position = e.Hit.point - direction*OffsetPosition;
}
