public static int Distance(IObject object1, IObject object2, Collision.CollisionType collisionType)
{
int result = 0;
Rectangle intersection = Rectangle.Intersect(object1.rectangle, object2.rectangle);
if (intersection.IsEmpty)
{
return(result);
}
else
{
if (collisionType == Collision.CollisionType.Above || collisionType == Collision.CollisionType.Below)
{
result = intersection.Height;
return(result);
}
else if (collisionType == Collision.CollisionType.Right || collisionType == Collision.CollisionType.Left)
{
result = intersection.Width;
return(result);
}
else
{
return(result);
}
}
}
public static int Update(IPlayer mario, IEnemy enemy, Collision.CollisionType collisionType)
{
switch (collisionType)
{
case Collision.CollisionType.Above:
enemy.TakeDamage();
return((int)Enum.DisableMovementType.Down);
case Collision.CollisionType.Below:
enemy.Attack(mario);
mario.Attack(enemy);
return((int)Enum.DisableMovementType.Up);
case Collision.CollisionType.Left:
enemy.Attack(mario);
mario.Attack(enemy);
return((int)Enum.DisableMovementType.Right);
case Collision.CollisionType.Right:
enemy.Attack(mario);
mario.Attack(enemy);
return((int)Enum.DisableMovementType.Left);
default:
return((int)Enum.DisableMovementType.None);
}
}
public static void Update(ILevel level)
{
int getCond;
foreach (IEnemy enemy1 in level.EnemyList)
{
enemy1.ChangeMovement(0);
foreach (IBlock block in level.BlockList)
{
colli = Collision.GetCollision(enemy1, block);
getCond = EBlockCollisionHandler.Update(enemy1, block, colli);
colliList.Add(getCond);
}
foreach (IEnemy enemy2 in level.EnemyList)
{
if (!enemy1.Equals(enemy2))
{
colli = Collision.GetCollision(enemy1, enemy2);
getCond = EEnemyCollisionHandler.Update(enemy1, enemy2, colli);
colliList.Add(getCond);
}
}
foreach (int i in colliList)
{
if (i != 0)
{
enemy1.ChangeMovement(i);
}
}
colliList.Clear();
}
}
public static void Update(IProjectile fireball, IBoss BossPr, Collision.CollisionType collisionType)
{
switch (collisionType)
{
case Collision.CollisionType.Above:
fireball.Attack(BossPr);
return;
case Collision.CollisionType.Below:
fireball.Attack(BossPr);
return;
case Collision.CollisionType.Left:
fireball.Attack(BossPr);
return;
case Collision.CollisionType.Right:
fireball.Attack(BossPr);
return;
default:
return;
}
}
public static void Update(ILevel level)
{
foreach (IProjectile fireball in level.ProjectileQueue)
{
if (level.EnemyList.Count != 0)
{
foreach (IEnemy enemy in level.EnemyList)
{
colli = Collision.GetCollision(fireball, enemy);
FBEnemyCollisionHandler.Update(fireball, enemy, colli);
}
}
if (level.BlockList.Count != 0)
{
foreach (IBlock block in level.BlockList)
{
colli = Collision.GetCollision(fireball, block);
FBBlockCollisionHandler.Update(fireball, block, colli);
}
}
if (level.BossPr != null)
{
colli = Collision.GetCollision(fireball, level.BossPr);
FBBossPrincessCollisionHandler.Update(fireball, level.BossPr, colli);
}
if (level.Mygame.Mario != null)
{
colli = Collision.GetCollision(fireball, level.Mygame.Mario);
FBMarioCollisionHandler.Update(fireball, level.Mygame.Mario, colli);
}
}
}
public static int Update(IPlayer mario, IFire fire, Collision.CollisionType collisionType)
{
switch (collisionType)
{
case Collision.CollisionType.Above:
fire.Attack(mario);
return((int)Enum.DisableMovementType.Down);
case Collision.CollisionType.Below:
fire.Attack(mario);
return((int)Enum.DisableMovementType.Up);
case Collision.CollisionType.Left:
fire.Attack(mario);
return((int)Enum.DisableMovementType.Right);
case Collision.CollisionType.Right:
fire.Attack(mario);
return((int)Enum.DisableMovementType.Left);
default:
return((int)Enum.DisableMovementType.None);
}
}
static public RaycastResults Raycast(Vector2 origin, Vector2 direction, Collision.CollisionType type)
{
RaycastResults result = null;
if (type == Collision.CollisionType.CircleIntersection)
{
foreach (Circle collider in circleColliders)
{
Vector2 l = collider.Center - origin; //lunghezza da origine ray a centro coll
float tca = Vector2.Dot(l, direction); //prodotto scalare tra lunghezza e direzione (deve essere positiva)
if (tca < 0)
{
continue;
}
float d = (float)Math.Sqrt(l.Length * l.Length - tca * tca);
if (d > collider.Radius)
{
continue;
}
float thc = (float)Math.Sqrt(collider.Radius * collider.Radius - d * d);
float p = tca - thc;
float p1 = tca + thc;
Vector2 pCoords = origin + direction * p;
Vector2 p1Coords = origin + direction * p1;
return(result = new RaycastResults(pCoords, p1Coords, collider, null, true));
}
}
else if (type == Collision.CollisionType.RectsIntersection)
{
foreach (Rect collider in rectColliders)
{
float tmin = float.MinValue;
float tmax = float.MaxValue;
float tx1 = (collider.Min.X - origin.X) * (1 / direction.X);
float tx2 = (collider.Max.X - origin.X) * (1 / direction.X);
tmin = Math.Max(tmin, Math.Min(tx1, tx2));
tmax = Math.Min(tmax, Math.Max(tx1, tx2));
float ty1 = (collider.Min.Y - origin.Y) * (1 / direction.Y);
float ty2 = (collider.Max.Y - origin.Y) * (1 / direction.Y);
tmin = Math.Max(tmin, Math.Min(ty1, ty2));
tmax = Math.Min(tmax, Math.Max(ty1, ty2));
Vector2 pCoords = origin + direction * tmin;
Vector2 p1Coords = origin + direction * tmax;
if (tmax >= tmin)
{
return(result = new RaycastResults(pCoords, p1Coords, null, collider, true));
}
}
}
return(null);
}
public static int Update(IPlayer mario, IBlock block, Collision.CollisionType collisionType)
{
if (block is FlagpoleClass && collisionType != Collision.CollisionType.None)
{
block.Used();
}
switch (collisionType)
{
case Collision.CollisionType.Above:
if (block is PenetrablePipeClass)
{
if (mario.State is SMLeftCrouchState || mario.State is SMRightCrouchState || mario.State is BMLeftCrouchState || mario.State is BMRightCrouchState || mario.State is FMLeftCrouchState || mario.State is FMRightCrouchState)
{
block.Used();
}
}
return((int)Enum.DisableMovementType.Down);
case Collision.CollisionType.Below:
if (block is BrickClass)
{
if (mario.State is SMLeftJumpState || mario.State is SMRightJumpState)
{
block.Shake();
}
else
{
block.Used();
}
}
else
{
block.Used();
}
return((int)Enum.DisableMovementType.Up);
case Collision.CollisionType.Left:
if (block is UndergroundPipeClass)
{
block.Used();
}
return((int)Enum.DisableMovementType.Right);
case Collision.CollisionType.Right:
return((int)Enum.DisableMovementType.Left);
default:
return((int)Enum.DisableMovementType.None);
}
}
public void ShootAroundEnemy(Collision.CollisionType type)
{
//Fire multiple shots!
float degrees = 360 / projectileNum;
for (int i = 0; i < projectileNum; i++)
{
Vector3 dir = Quaternion.AngleAxis(transform.rotation.eulerAngles.y, Vector3.up) * (transform.position + Vector3.forward);
Vector3 f = dir - transform.position;
dir = Quaternion.AngleAxis(degrees * i, Vector3.up) * f;
ShootTarget(dir + transform.position, type);
}
//ShootTarget(transform.position + Vector3.forward);
}
public void GetCollisionTestBottomAbove()
{
TestObject nonMario = new TestObject(100, 50, 20, 20);
TestObject mario = new TestObject(90, 100, 50, 50);
for (int y = 31; y <= 49; y++)
{
mario.rectangle = new Rectangle(90, 100 - y, 50, 50);
Collision.CollisionType colli = Collision.GetCollision(mario, nonMario);
if (colli != Collision.CollisionType.Below)
{
Assert.Fail();
}
}
}
public void GetCollisionTestLeft()
{
TestObject mario = new TestObject(50, 100, 20, 20);
TestObject nonMario = new TestObject(100, 90, 50, 50);
for (int y = 31; y <= 49; y++)
{
mario.rectangle = new Rectangle(50 + y, 100, 20, 20);
Collision.CollisionType colli = Collision.GetCollision(mario, nonMario);
if (colli != Collision.CollisionType.Left)
{
Assert.Fail();
}
}
}
public void GetCollisionTestRightNone()
{
TestObject mario = new TestObject(100, 90, 50, 50);
TestObject nonMario = new TestObject(50, 100, 20, 20);
for (int y = 0; y <= 30; y++)
{
mario.rectangle = new Rectangle(100 - y, 90, 50, 50);
Collision.CollisionType colli = Collision.GetCollision(mario, nonMario);
if (colli != Collision.CollisionType.None)
{
Assert.Fail();
}
}
}
protected virtual void ShootTarget(Vector3 target, Collision.CollisionType type)
{
//Get a projectile and place it at the enemy's position
Projectile p = ProjectileManager.instance.RequestProjectile();
p.transform.position = ship.position + new Vector3(0, 1, 0);
//Calculate direction to send the projectile in
Vector3 playerPos = target;
Vector3 dir = (playerPos - transform.position).normalized;
dir = AccuracyRandomizer(dir, inaccuracy);
p.StartProjectile(type, dir, projectileSpeed, 1, this.gameObject);
}
public bool Casting(Collision.CollisionType type)
{
if (type == Collision.CollisionType.CircleIntersection)
{
Confirm = Physics.Raycast_C(Origin, Direction);
}
else if (type == Collision.CollisionType.RectsIntersection)
{
Confirm = Physics.Raycast_R(Origin, Direction);
}
else
{
Confirm = false;
}
return(Confirm);
}
public override void Collide(List <AbsObject> collidedObjects)
{
bool[] directionsBlocked = new bool[] { false, false, false, false };
Dictionary <AbsObject, Collision.CollisionType> cornerCollidedObjects = new Dictionary <AbsObject, Collision.CollisionType>();
foreach (AbsObject obj in collidedObjects)
{
Collision.CollisionType type = Collision.GetCollisionType(this, obj);
if (type == Collision.CollisionType.TSide)
{
TopCollide(this, obj, directionsBlocked);
}
else if (type == Collision.CollisionType.RSide || type == Collision.CollisionType.LSide)
{
SideCollide(this, obj, directionsBlocked);
}
else if (type == Collision.CollisionType.BSide)
{
BottomCollide(this, obj, directionsBlocked);
}
else
{
cornerCollidedObjects.Add(obj, type);
}
}
foreach (AbsObject obj in cornerCollidedObjects.Keys)
{
if (cornerCollidedObjects[obj] == Collision.CollisionType.TRCorner && !directionsBlocked[0] && !directionsBlocked[1])
{
SideCollide(this, obj, directionsBlocked);
}
else if (cornerCollidedObjects[obj] == Collision.CollisionType.TLCorner && !directionsBlocked[0] && !directionsBlocked[3])
{
SideCollide(this, obj, directionsBlocked);
}
else if (cornerCollidedObjects[obj] == Collision.CollisionType.BRCorner && !directionsBlocked[2] && !directionsBlocked[1])
{
BottomCollide(this, obj, directionsBlocked);
}
else if (cornerCollidedObjects[obj] == Collision.CollisionType.BLCorner && !directionsBlocked[2] && !directionsBlocked[3])
{
BottomCollide(this, obj, directionsBlocked);
}
}
}
public void StartProjectile(Collision.CollisionType color, Vector3 dir, float sp, int dmg, GameObject o = null)
{
//Set the owner of this bullet, so that the shooter can't hurt themselves with their own bullet
if (o != null)
{
shooter = o;
}
//Just deactivate all trails here to make things easy
blueTrail.gameObject.SetActive(false);
redTrail.gameObject.SetActive(false);
purpleTrail.gameObject.SetActive(false);
//Reset the reflected state
reflected = false;
//Set trajectory, damage, and speed
damage = dmg;
direction = dir;
speed = sp;
Color actualColor = Color.white;
if (color == Collision.CollisionType.BLUE)
{
actualColor = blue;
blueTrail.gameObject.SetActive(true);
}
else if (color == Collision.CollisionType.RED)
{
actualColor = red;
redTrail.gameObject.SetActive(true);
}
else if (color == Collision.CollisionType.PURPLE)
{
actualColor = purple;
purpleTrail.gameObject.SetActive(true);
}
collision.SetColor(color, actualColor);
//Start the projectile duration
StartCoroutine(ProjectileDuration());
}
public static int Update(IEnemy enemy, IBlock block, Collision.CollisionType collisionType)
{
switch (collisionType)
{
case Collision.CollisionType.Above:
return((int)Enum.DisableMovementType.Down);
case Collision.CollisionType.Below:
return((int)Enum.DisableMovementType.Up);
case Collision.CollisionType.Left:
return((int)Enum.DisableMovementType.Right);
case Collision.CollisionType.Right:
return((int)Enum.DisableMovementType.Left);
default:
return((int)Enum.DisableMovementType.None);
}
}
public void SetColor(Collision.CollisionType c, Color actualColor)
{
color = c;
GetComponentInChildren <MeshRenderer>().material.color = actualColor;
//The only time this is called is when bullets are being re-assigned
//So lets also set glow as well here
if (color == CollisionType.RED)
{
GetComponentInChildren <MeshRenderer>().material = redMaterial;
}
else if (color == CollisionType.BLUE)
{
GetComponentInChildren <MeshRenderer>().material = blueMaterial;
}
else //Purple
{
GetComponentInChildren <MeshRenderer>().material = purpleMaterial;
}
}
public static void Update(ILevel level)
{
int getCond;
level.BossPr.ChangeMovement(0);
foreach (IBlock block in level.BlockList)
{
colli = Collision.GetCollision(level.BossPr, block);
getCond = BossPrincessBlockCollisionHandler.Update(level.BossPr, block, colli);
colliList.Add(getCond);
}
foreach (int i in colliList)
{
if (i != 0)
{
level.BossPr.ChangeMovement(i);
}
}
colliList.Clear();
}
public static void Update(IPlayer mario, IItem item, Collision.CollisionType collisionType)
{
switch (collisionType)
{
case Collision.CollisionType.Above:
item.Used();
break;
case Collision.CollisionType.Below:
item.Used();
break;
case Collision.CollisionType.Left:
item.Used();
break;
case Collision.CollisionType.Right:
item.Used();
break;
}
}
public override void Collide(List <AbsObject> collidedObjects)
{
Dictionary <AbsObject, Collision.CollisionType> cornerCollidedObjects = new Dictionary <AbsObject, Collision.CollisionType>();
foreach (AbsObject obj in collidedObjects)
{
Collision.CollisionType type = Collision.GetCollisionType(this, obj);
if (type == Collision.CollisionType.TSide || type == Collision.CollisionType.TRCorner || type == Collision.CollisionType.TLCorner)
{
TopCollide(obj);
//} else if(type == Collision.CollisionType.RSide || type == Collision.CollisionType.LSide)
//{
// SideCollide(obj);
//}
}
else
{
_objectsToNotCollide.Add(obj);
}
}
}
public static void Update(IProjectile fireball, IBlock block, Collision.CollisionType collisionType)
{
switch (collisionType)
{
case Collision.CollisionType.Above:
fireball.TouchDown();
return;
case Collision.CollisionType.Below:
fireball.Boom();
return;
case Collision.CollisionType.Left:
fireball.Boom();
return;
case Collision.CollisionType.Right:
fireball.Boom();
return;
default:
return;
}
}
public static void Update(ILevel level)
{
int getCond;
foreach (IItem item in level.ItemList)
{
item.ChangeMovement(0);
foreach (IBlock block in level.BlockList)
{
colli = Collision.GetCollision(item, block);
getCond = IBlockCollisionHandler.Update(item, block, colli);
colliList.Add(getCond);
}
foreach (int i in colliList)
{
if (i != 0)
{
item.ChangeMovement(i);
}
}
colliList.Clear();
}
}
public override void Collide(List <AbsObject> collidedObjects)
{
bool[] directionsBlocked = new bool[] { false, false, false, false };
Dictionary <AbsObject, Collision.CollisionType> cornerCollidedObjects = new Dictionary <AbsObject, Collision.CollisionType>();
foreach (AbsObject obj in collidedObjects)
{
if (obj is ItemObject)
{
if (((ItemObject)obj).State == "speed")
{
this.powerState.ToFast();
this.audio.PlaySound("potion");
}
else if (((ItemObject)obj).State == "jump")
{
this.powerState.ToDouble();
this.audio.PlaySound("potion");
}
else if (((ItemObject)obj).State == "propeller")
{
this.moveState = new DoodleFlyingState(this);
this.audio.PlaySound("copter");
}
}
Collision.CollisionType type = Collision.GetCollisionType(this, obj);
if (type == Collision.CollisionType.TSide)
{
TopCollide(this, obj, directionsBlocked);
}
else if (type == Collision.CollisionType.RSide || type == Collision.CollisionType.LSide)
{
SideCollide(this, obj, directionsBlocked);
}
else if (type == Collision.CollisionType.BSide)
{
BottomCollide(this, obj, directionsBlocked);
}
else
{
cornerCollidedObjects.Add(obj, type);
}
}
foreach (AbsObject obj in cornerCollidedObjects.Keys)
{
if (cornerCollidedObjects[obj] == Collision.CollisionType.TRCorner && !directionsBlocked[0] && !directionsBlocked[1])
{
SideCollide(this, obj, directionsBlocked);
}
else if (cornerCollidedObjects[obj] == Collision.CollisionType.TLCorner && !directionsBlocked[0] && !directionsBlocked[3])
{
SideCollide(this, obj, directionsBlocked);
}
else if (cornerCollidedObjects[obj] == Collision.CollisionType.BRCorner && !directionsBlocked[2] && !directionsBlocked[1])
{
BottomCollide(this, obj, directionsBlocked);
}
else if (cornerCollidedObjects[obj] == Collision.CollisionType.BLCorner && !directionsBlocked[2] && !directionsBlocked[3])
{
BottomCollide(this, obj, directionsBlocked);
}
}
}
public static void Update(ILevel level)
{
level.Mygame.Mario.DisableMovement(0);
int getCond;
foreach (IEnemy enemy in level.EnemyList)
{
colli = Collision.GetCollision(level.Mygame.Mario, enemy);
getCond = MEnemyCollisionHandler.Update(level.Mygame.Mario, enemy, colli);
colliList.Add(getCond);
}
foreach (IFire fire in level.FireList)
{
colli = Collision.GetCollision(level.Mygame.Mario, fire);
getCond = MFireCollisionHandler.Update(level.Mygame.Mario, fire, colli);
colliList.Add(getCond);
}
foreach (IItem item in level.ItemList)
{
colli = Collision.GetCollision(level.Mygame.Mario, item);
if (colli != Collision.CollisionType.None)
{
MItemCollisionHandler.Update(level.Mygame.Mario, item, colli);
}
}
foreach (IBlock block in level.BlockList)
{
colli = Collision.GetCollision(level.Mygame.Mario, block);
if (colli == Collision.CollisionType.Below)
{
if (blockEnable)
{
getCond = MBlockCollisionHandler.Update(level.Mygame.Mario, block, colli);
colliList.Add(getCond);
blockEnable = false;
}
}
else
{
getCond = MBlockCollisionHandler.Update(level.Mygame.Mario, block, colli);
colliList.Add(getCond);
}
}
foreach (int i in colliList)
{
if (i != 0)
{
level.Mygame.Mario.DisableMovement(i);
}
}
colliList.Clear();
blockEnable = true;
}
