private static bool RectContainsCircle(Rect rect, CollisionCircle obj)
{
if (!rect.Contains(obj.Trans.position))
{
return(false);
}
float radius = 0;
if (obj.IsStatic)
{
radius = obj.GetRadius();
}
if ((obj.Trans.position.x - radius) <= rect.x)
{
return(false);
}
if ((obj.Trans.position.x + radius) >= (rect.x + rect.width))
{
return(false);
}
if ((obj.Trans.position.y - radius) <= rect.y)
{
return(false);
}
if ((obj.Trans.position.y + radius) >= (rect.y + rect.height))
{
return(false);
}
return(true);
}
public void CollidedEnded(CollisionCircle other)
{
if (InstanceId == other.InstanceId)
{
return;
}
if (Owner.PlayerNumber == other.Owner.PlayerNumber)
{
return;
}
if (IsDead)
{
return;
}
if (!IsWeapon)
{
return;
}
if (Mover.Weapon.Target != null)
{
if (Mover.Weapon.Target.GameObj == other.Trans.gameObject)
{
Mover.Weapon.Target = null;
}
}
}
protected override void LoadContent()
{
base.LoadContent();
Sprite = Game.Content.Load <Texture2D>("Graphics/Entities/ship");
_bulletSprite = this.Game.Content.Load <Texture2D>("Graphics/Entities/ship_bullet");
_hitboxSprite = this.Game.Content.Load <Texture2D>("Graphics/Pictures/hitbox");
Center = new Vector2(Sprite.Width / 2f, Sprite.Height / 2f);
CollisionBox = new CollisionCircle(this, new Vector2(Sprite.Height / 6f, Sprite.Height / 6f), _hitboxRadius / 2f);
_lifeIcon = Game.Content.Load <Texture2D>("Graphics/Pictures/life");
_bulletTimeBarLeft = Game.Content.Load <Texture2D>("Graphics/Pictures/bulletTimeBarLeft");
_bulletTimeBarContent = Game.Content.Load <Texture2D>("Graphics/Pictures/bulletTimeBarContent");
_bulletTimeBarRight = Game.Content.Load <Texture2D>("Graphics/Pictures/bulletTimeBarRight");
if (_shootSound == null)
{
_shootSound = Game.Content.Load <SoundEffect>(@"Audio/SE/hit");
}
if (_deadSound == null)
{
_deadSound = Game.Content.Load <SoundEffect>(@"Audio/SE/dead");
}
float xLag = Config.Resolution.X / 2;
if (Config.PlayersNumber > 1)
{
xLag /= 2;
}
_camera = new Camera2D(_viewport, Config.GameArea.X, Config.GameArea.Y, 1f);
}
public void Collided(CollisionCircle other)
{
if (InstanceId == other.InstanceId)
{
return;
}
if (Owner.PlayerNumber == other.Owner.PlayerNumber)
{
return;
}
if (IsDead)
{
return;
}
if (!IsWeapon)
{
return;
}
if (IsWeapon && !Mover.Weapon.HasTarget)
{
Mover.Weapon.Target = other.Trans.GetComponent <ITargetable>();
Mover.Weapon.HasTarget = true;
}
else
{
Mover.Weapon.AttackTarget();
}
}
protected override void LoadContent()
{
base.LoadContent();
Sprite = GameRef.Content.Load <Texture2D>("Graphics/Entities/player");
_bulletSprite = GameRef.Content.Load <Texture2D>("Graphics/Entities/player_bullet");
_hitboxSprite = GameRef.Content.Load <Texture2D>("Graphics/Pictures/player_hitbox");
CollisionBoxes.Add(new CollisionCircle(this, new Vector2(Sprite.Height / 6f, Sprite.Height / 6f), _hitboxRadius / 2f));
_shieldSprite = GameRef.Content.Load <Texture2D>("Graphics/Entities/shield");
_shieldOrigin = new Vector2(_shieldSprite.Width / 2f, _shieldSprite.Height / 2f);
_shieldCollisionCircle = new CollisionCircle(this, Vector2.Zero, _shieldSprite.Width / 2f);
_lifeIcon = GameRef.Content.Load <Texture2D>("Graphics/Pictures/life_icon");
_bulletTimeBarLeft = GameRef.Content.Load <Texture2D>("Graphics/Pictures/gauge_left");
_bulletTimeBarContent = GameRef.Content.Load <Texture2D>("Graphics/Pictures/gauge_middle");
_bulletTimeBarRight = GameRef.Content.Load <Texture2D>("Graphics/Pictures/gauge_right");
if (_shootSound == null)
{
_shootSound = GameRef.Content.Load <SoundEffect>(@"Audio/SE/hit");
}
if (_deadSound == null)
{
_deadSound = GameRef.Content.Load <SoundEffect>(@"Audio/SE/dead");
}
}
private void setupEnvironments(Car car, World world, Game game, Move move)
{
TilePos.TileSize = game.TrackTileSize;
GlobalMap.InstanceInit(world);
GlobalMap.Instance.SetupEnvironment(world, game);
AngleReachEvent.setupEnvironment(game);
MoveToAngleFunction.setupEnvironment(world);
MoveToPoint.setupEnvironment(world);
PhysicExtensions.setupEnvironment(game);
PhysicEventsCalculator.setupEnvironment(game, world);
CollisionSide.SetupEnvironment(game);
CollisionCircle.SetupEnvironment(game);
CollisionDetector.SetupEnvironment(game, GlobalMap.Instance);
map.SetupEnvironment(car, GlobalMap.Instance);
path.SetupEnvironment(car, GlobalMap.Instance, world, game);
foreach (IAction action in actions.Values)
{
action.setupEnvironment(car, world, game, path);
}
foreach (AdditionalPoints action in additionalPointsActions)
{
action.setupEnvironment(car, world, game, path);
}
}
public Player(XmasHell game)
{
_game = game;
_currentDirection = Vector2.Zero;
_idleAnimationTimer = new CountdownTimer(5);
_idleAnimationTimer.Stop();
_idleAnimationTimer.Completed += (sender, args) =>
{
Console.WriteLine("PLAY IDLE");
CurrentAnimator.Play("Idle");
};
var playerHitboxTexture = Assets.GetTexture2D("Graphics/Sprites/Player/hitbox");
var animatorConfig = new Config
{
MetadataEnabled = false,
EventsEnabled = false,
PoolingEnabled = true,
TagsEnabled = false,
VarsEnabled = false,
SoundsEnabled = false
};
var factory = new DefaultProviderFactory <ISprite, SoundEffect>(animatorConfig, true);
var loader = new SpriterContentLoader(_game.Content, "Graphics/Sprites/Player/player");
loader.Fill(factory);
Stack <SpriteDrawInfo> drawInfoPool = new Stack <SpriteDrawInfo>();
foreach (var entity in loader.Spriter.Entities)
{
var animator = new CustomSpriterAnimator(_game, entity, factory, drawInfoPool);
_animators.Add(animator);
}
CurrentAnimator = _animators.First();
var spriteSize = new Vector2(60, 82);
CurrentAnimator.Position = new Vector2(spriteSize.X / 2f, spriteSize.Y / 2f);
CurrentAnimator.Play("Idle");
CurrentAnimator.AnimationFinished += AnimationFinished;
_hitboxSprite = new Sprite(playerHitboxTexture)
{
//Scale = new Vector2(
// (GameConfig.PlayerHitboxRadius * 2f) / playerHitboxTexture.Width,
// (GameConfig.PlayerHitboxRadius * 2f) / playerHitboxTexture.Height
//)
};
_hitbox = new CollisionCircle(this, Vector2.Zero, GameConfig.PlayerHitboxRadius);
// Don't forget to set the player position delegate to the MoverManager
_game.GameManager.MoverManager.SetPlayerPositionDelegate(Position);
}
public void PointOutsideReturnsFalseTest(float x, float y, float z, float radius)
{
var shape = new CollisionCircle(Vector2.Zero, radius);
var result = shape.IsWithin(new Vector3(x, y, z));
result.Should().BeFalse();
}
/// <summary>
/// Test if this collides with another collision circle.
/// </summary>
/// <returns><c>true</c>, the two circles collide, <c>false</c> the two circles dont collide.</returns>
/// <param name="c">the circle to test against.</param>
public bool TestCollisionCircle(CollisionCircle c)
{
Vector3 position = this.transform.position;
float distance = c.Raduis + radius;
distance *= distance;
Vector3 offset = position - c.Position;
return(offset.sqrMagnitude < distance);
}
private void OnEnable()
{
//mode = Mode.Idle;
Collision = new CollisionCircle(Trans, null, Owner, null);
CollisionManager.Instance.AddCollidable(Collision);
Collision.IsDead = false;
Collision.CollidedBaseCircle = null;
LoadFromConfig();
}
public Bullet Update(int id, List <int> bulletsToDelete)
{
if (_dieing)
{
UpdateAnimation();
if (_animations[_currentAnimation].FinishedPlaying)
{
SetInactive(_id);
bulletsToDelete.Add(id);
}
return(this);
}
--KillTime;
if (KillTime == 0)
{
Clear();
return(this);
}
if (SpawnDelay > 0)
{
--SpawnDelay;
}
if (SpawnDelay != 0)
{
return(this);
}
UpdateAnimation();
Behavior.Update(ref this);
if (AutomaticCollision)
{
if (!_tileMap.CellIsPassableByPixel(CircleCollisionCenter) ||
!Camera.WorldRectangle.Contains((int)Position.X, (int)Position.Y))
{
Clear();
return(this);
}
}
if (CollisionCircle.Intersects(((Player)VariableProvider.CurrentPlayer).PlayerBulletCollisionCircle))
{
Clear();
return(this);
//VariableProvider.CurrentPlayer.Send<string>("KILL", null);
}
_directionVector.Normalize();
_lastDirection = Direction;
_lastPosition = Position;
return(this);
}
public void Start()
{
Trans.localScale = Vector3.one;
Collision = new CollisionCircle(Trans, null, Owner, null);
CollisionManager.Instance.AddCollidable(Collision);
ConfigManager.Instance.OnConfigsLoaded += Reset;
GameManager.Instance.OnGameStart += Reset;
GameManager.Instance.OnGameStart += Initialize;
}
private void Start()
{
Collision = new CollisionCircle(Trans, Mover, Owner, this);
CollisionManager.Instance.AddCollidable(Collision);
IsAttacking = false;
Collision.IsDead = false;
Collision.CollidedBaseCircle = null;
Target = null;
HasTarget = false;
isStarted = true;
}
public void LoadContent(IContentLoader contentLoader)
{
sprite = contentLoader.Load <Texture2D>("Graphics/Entities/player");
var size = (sprite.Width, sprite.Height);
var pos = (position.X, position.Y);
ship = system.ActorOf(Props.Create(() => new Danmaku.ShipActor(pos, size)));
_shieldSprite = contentLoader.Load <Texture2D>("Graphics/Entities/shield");
_shieldOrigin = new Vector2(_shieldSprite.Width / 2f, _shieldSprite.Height / 2f);
CollisionBoxes.Add(new CollisionCircle(this, new Vector2(sprite.Height / 6f, sprite.Height / 6f), _hitboxRadius / 2f));
_shieldCollisionCircle = new CollisionCircle(this, Vector2.Zero, _shieldSprite.Width / 2f);
}
protected override void LoadContent()
{
Sprite = Game.Content.Load <Texture2D>(@"Graphics/Sprites/balls");
Center = new Vector2(Sprite.Height / 2f, Sprite.Height / 2f);
CollisionBox = new CollisionCircle(this, Vector2.Zero, Sprite.Height / 2f);
int index = (int)(Sprite.Height * _rand.Next((Sprite.Width / Sprite.Height)));
_spriteRectangle = new Rectangle(index, 0, Sprite.Height, Sprite.Height);
base.LoadContent();
}
public bool Collided(CollisionCircle c)
{
var rad = c.Circ.Radius;
var center = c.Circ.Center;
return c.Circ.ContainsPoint(new Point(Rect.Left, Rect.Top))
|| c.Circ.ContainsPoint(new Point(Rect.Left, Rect.Bottom))
|| c.Circ.ContainsPoint(new Point(Rect.Right, Rect.Top))
|| c.Circ.ContainsPoint(new Point(Rect.Right, Rect.Bottom))
|| Rect.ContainsPoint(new Point(center.X, center.Y - rad))
|| Rect.ContainsPoint(new Point(center.X, center.Y + rad))
|| Rect.ContainsPoint(new Point(center.X - rad, center.Y))
|| Rect.ContainsPoint(new Point(center.X + rad, center.Y));
}
private bool tireCollisionWithCar(Vector tirePos, PCar car, out Vector normal, double multR = 1)
{
CollisionCircle collisionTire = new CollisionCircle(tirePos, game.TireRadius * multR);
CollisionRect collisionCar = new CollisionRect(car);
CollisionInfo collision = new CollisionInfo(collisionTire, collisionCar);
if (CollisionDetector.CheckCollision(collision))
{
normal = collision.NormalObj1;
return(true);
}
normal = null;
return(false);
}
public void Update(GameTime a_GameTime)
{
if (Follow != null)
{
if (CollisionCircle.Intersects(Follow.CollisionCircle) == false)
{
Velocity = Follow.Position - Position;
Position += (Vector2.Normalize(Velocity)) * 5;
if (Velocity != Vector2.Zero)
{
ConstantVelocity = Velocity;
}
}
}
}
/// <summary>
/// Returns whether or not the tongue intersects with a circle.
/// </summary>
/// <param name="collisionCircle"></param>
/// <returns></returns>
public bool Intersects(CollisionCircle collisionCircle)
{
if (!IsAttacking)
{
return(false);
}
foreach (Vector2 v in GetCollisionPoints())
{
if (collisionCircle.Contains(v.X, v.Y))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Handle collisions between the boss and the players bullets
/// </summary>
public void CollideBossBullets()
{
HealthManager health = Boss.GetComponent <HealthManager> ();
List <GameObject> bullets = bulletManager.BulletsList;
CollisionCircle bossCollider = Boss.GetComponent <CollisionCircle> ();
if (!health.Immune)
{
for (int i = bullets.Count - 1; i >= 0; i--)
{
if (bossCollider.TestCollisionCircle(bullets [i].GetComponent <CollisionCircle> ()))
{
health.Hit();
bulletManager.DestroyBullet(i);
}
}
}
}
public CollisionCircle(Transform newTrans, Mover newMover, Owner newOwner, Weapon newWeapon)
{
showGizmos = true;
Trans = newTrans;
Mover = newMover;
if (Mover == null)
{
IsStatic = true;
Planet = Trans.GetComponent <Planet>();
}
Owner = newOwner;
Weapon = newWeapon;
if (Weapon != null)
{
IsWeapon = true;
}
IsCollidedWithBase = false;
CollidedBaseCircle = null;
CollidedCount = 0;
InstanceId = Trans.gameObject.GetInstanceID();
}
private Vector tireCollisionWithMap(Vector pos, Vector lastPos)
{
int ticks = 5;
Vector spd = (pos - lastPos) / (double)ticks;
for (int i = 0; i < ticks; i++)
{
pos += spd;
CollisionCircle collisionTire = new CollisionCircle(pos, game.TireRadius);
List <CollisionInfo> collisions = CollisionDetector.CollisionsWithMap(collisionTire);
if (!collisions.HasCollision())
{
continue;
}
return(collisions.AverageNormalObj1());
}
return(null);
}
/// <summary>
/// Handles collisions between the ship and asteroids.
/// </summary>
public void CollideShipAsteroids()
{
//get the players health script
HealthManager health = Ship.GetComponent <HealthManager> ();
//check if the player currently has immunity
if (!health.Immune)
{
//get the asteroids and the ships collision circle
List <GameObject> asteroids = asteroidManager.AsteroidsList;
CollisionCircle shipCollider = Ship.GetComponent <CollisionCircle> ();
//loop through the asteroids
for (int i = asteroids.Count - 1; i >= 0; i--)
{
//check for collision
if (shipCollider.TestCollisionCircle(asteroids [i].GetComponent <CollisionCircle> ()))
{
//if there is a collision damage the ship
health.Hit();
}
}
}
}
/// <summary>
/// Handles collisions between asteroids and the players bullets.
/// </summary>
public void CollideAsteroidsBullets()
{
//get the asteroids and the players bullets
List <GameObject> asteroids = asteroidManager.AsteroidsList;
List <GameObject> bullets = bulletManager.BulletsList;
//loop through the asteroids
for (int i = asteroids.Count - 1; i >= 0; i--)
{
//get the asteroids collision circle then loop through the bullets
CollisionCircle curr = asteroids [i].GetComponent <CollisionCircle> ();
for (int j = bullets.Count - 1; j >= 0; j--)
{
//check for collision
if (curr.TestCollisionCircle(bullets[j].GetComponent <CollisionCircle>()))
{
//if there is a collision destroy both the asteroid and the bullet then and stop looping through bullets
asteroidManager.DestroyAsteroid(asteroids[i]);
bulletManager.DestroyBullet(j);
j = -1;
}
}
}
}
public bool CollidesWithFrozenEnemy(CollisionCircle circle)
{
return(false);
}
public void AddCollidable(CollisionCircle obj)
{
// qtree.Insert(obj);
ObjectsToInsert.Enqueue(obj);
}
public void Insert(CollisionCircle obj)
{
if (objects.Count < 1 && activeNodes == 0)
{
objects.Add(obj);
obj.IsInQt = true;
return;
}
if (rect.size.x < Vector2.one.x && rect.size.y < Vector2.one.y)
{
objects.Add(obj);
obj.IsInQt = true;
return;
}
Rect[] quadrant = new Rect[4];
quadrant[0] = (childs[0] != null) ? childs[0].rect : new Rect(rect.x + halfWidth, rect.y, halfWidth, halfHeight);
quadrant[1] = (childs[1] != null) ? childs[1].rect : new Rect(rect.x, rect.y, halfWidth, halfHeight);
quadrant[2] = (childs[2] != null) ? childs[2].rect : new Rect(rect.x, rect.y + halfHeight, halfWidth, halfHeight);
quadrant[3] = (childs[3] != null) ? childs[3].rect : new Rect(rect.x + halfWidth, rect.y + halfHeight, halfWidth, halfHeight);
if (RectContainsCircle(rect, obj))
{
bool found = false;
for (int i = 0; i < 4; i++)
{
if (RectContainsCircle(quadrant[i], obj))
//if (quadrant[i].Contains(obj.GetPoint()))
{
// using existing child
if (childs[i] != null)
{
childs[i].Insert(obj);
}
// create new child
else
{
childs[i] = new QuadTreeEternal(quadrant[i]);
childs[i].Root = Root;
childs[i].parent = this;
childs[i].level = level + 1;
childs[i].Insert(obj);
hasChilds = true;
activeNodes |= (byte)(1 << i);
}
found = true;
}
}
if (!found)
{
objects.Add(obj);
obj.IsInQt = true;
}
}
else
{
// attach object to root if it's outside of battleground boundaries
//objects.Add(obj);
obj.IsInQt = false;
}
}
private static void CheckBodies(CollisionCircle unit1, CollisionCircle unit2)
{
if (unit1.InstanceId == unit2.InstanceId)
{
return;
}
if (unit1.IsStatic && unit2.IsStatic)
{
return;
}
if (unit1.IsDead || unit2.IsDead)
{
return;
}
if (unit1.IsWeapon || unit2.IsWeapon)
{
return;
}
float distance = (unit1.Trans.position - unit2.Trans.position).sqrMagnitude;
// if no mover then it's a base
if (unit1.IsStatic)
{
if (unit1.Owner.PlayerNumber == -1)
{
float radiuses = unit1.GetRadius();
if (distance < radiuses * radiuses)
{
if (unit2.IsCollidedWithBase == false)
{
unit2.CollidedBaseCircle = unit1;
unit2.IsCollidedWithBase = true;
unit1.CollidedCount++;
}
}
else
{
if (unit2.CollidedBaseCircle == unit1)
{
unit2.CollidedBaseCircle = null;
unit2.IsCollidedWithBase = false;
unit1.CollidedCount--;
}
}
}
else
{
float radiuses = unit1.GetRadius();
if (distance < radiuses * radiuses)
{
if (unit1.Owner.PlayerNumber == unit2.Owner.PlayerNumber)
{
if (!unit2.IsDead)
{
if (unit2.Mover.FollowBase.TargetPlanet.gameObject != unit1.Trans.gameObject)
{
if (unit2.Mover.Separation.Enabled)
{
unit2.Mover.Separation.AddSeparation(unit1.Trans.position, distance);
}
}
}
}
}
}
}
// if no mover then it's a base
else if (unit2.IsStatic)
{
if (unit2.Owner.PlayerNumber == -1)
{
float radiuses = unit2.GetRadius();
if (distance < radiuses * radiuses)
{
if (unit1.IsCollidedWithBase == false)
{
unit1.CollidedBaseCircle = unit2;
unit1.IsCollidedWithBase = true;
unit2.CollidedCount++;
}
}
else
{
if (unit1.CollidedBaseCircle == unit2)
{
unit1.CollidedBaseCircle = null;
unit1.IsCollidedWithBase = false;
unit2.CollidedCount--;
}
}
}
else
{
float radiuses = unit2.GetRadius();
if (distance < radiuses * radiuses)
{
if (unit2.Owner.PlayerNumber == unit1.Owner.PlayerNumber)
{
if (!unit1.IsDead)
{
if (unit1.Mover.FollowBase.TargetPlanet.gameObject != unit2.Trans.gameObject)
{
if (unit1.Mover.Separation.Enabled)
{
unit1.Mover.Separation.AddSeparation(unit2.Trans.position, distance);
}
}
}
}
}
}
}
else if (!unit1.IsStatic && !unit2.IsStatic)
{
if (distance > 0)
{
// check all dynamic bodies to apply separation
if (distance < unit1.Mover.Separation.Desired * unit1.Mover.Separation.Desired)
{
if (unit1.Mover.Separation.Enabled)
{
unit1.Mover.Separation.AddSeparation(unit2.Trans.position, distance);
}
if (unit2.Mover.Separation.Enabled)
{
unit2.Mover.Separation.AddSeparation(unit1.Trans.position, distance);
}
}
// check ally bodies only
if (unit1.Owner.PlayerNumber == unit2.Owner.PlayerNumber)
{
// check to apply cohesion
if (distance < unit1.Mover.Cohesion.Desired * unit1.Mover.Cohesion.Desired)
{
if (unit1.Mover.Cohesion.Enabled)
{
unit1.Mover.Cohesion.AddCohesion(unit2.Trans.position);
}
if (unit2.Mover.Cohesion.Enabled)
{
unit2.Mover.Cohesion.AddCohesion(unit1.Trans.position);
}
}
}
}
else
{
unit2.Trans.Translate(-0.2f, 0, 0);
unit1.Trans.Translate(0.2f, 0, 0);
}
}
}
void CheckWeapon(CollisionCircle unit1, CollisionCircle unit2)
{
if (unit1.InstanceId == unit2.InstanceId)
{
return;
}
if (unit1.Owner.PlayerNumber == unit2.Owner.PlayerNumber)
{
return;
}
if (unit1.Owner.PlayerNumber == -1 || unit2.Owner.PlayerNumber == -1)
{
return;
}
if (unit1.IsDead || unit2.IsDead)
{
return;
}
if (unit1.IsWeapon && unit2.IsWeapon)
{
return;
}
float distance = (unit1.Trans.position - unit2.Trans.position).sqrMagnitude;
if (distance > 0)
{
if (unit1.IsWeapon)
{
float radiuses = unit1.GetRadius() + unit2.GetRadius();
if (distance < radiuses * radiuses)
{
if (!unit1.Weapon.HasTarget)
{
unit1.Weapon.Target = unit2.Trans.GetComponent <ITargetable>();
unit1.Weapon.HasTarget = true;
unit1.Weapon.AttackTarget();
}
else
{
unit1.Weapon.AttackTarget();
}
}
else
{
if (unit1.Weapon.Target != null)
{
if (unit1.Weapon.Target.GameObj == unit2.Trans.gameObject)
{
unit1.Weapon.Target = null;
}
}
}
}
else if (unit2.IsWeapon)
{
float radiuses = unit1.GetRadius() + unit2.GetRadius();
if (distance < radiuses * radiuses)
{
if (!unit2.Weapon.HasTarget)
{
unit2.Weapon.Target = unit1.Trans.GetComponent <ITargetable>();
unit2.Weapon.HasTarget = true;
unit2.Weapon.AttackTarget();
}
else
{
unit2.Weapon.AttackTarget();
}
}
else
{
if (unit2.Weapon.Target != null)
{
if (unit2.Weapon.Target.GameObj == unit1.Trans.gameObject)
{
unit2.Weapon.Target = null;
}
}
}
}
}
}
public bool Collided(CollisionCircle c)
{
return c.Circ.Intersects(Circ);
}
