public Missile(Vecteur2D position, Vecteur2D vitesse, int lives)
{
this.position = position;
this.vitesse = vitesse;
this.lives = lives;
this.image = new Bitmap("../../resources/shoot1.png");
}
public BonusWeapon(Vecteur2D pos,Bitmap img)
: base(pos,img)
{
switch (Game.rnd.Next(0,2))
{
case 0:
this.data = new Tuple<Missile, int>(
new Missile(new Vecteur2D(0, 0), new Vecteur2D(0, -400), 8, true, SpaceInvaders.Properties.Resources.shoot4),
Game.rnd.Next(5, 10)
);
break;
case 1:
this.data = new Tuple<Missile, int>(
new SuperMissile(new Vecteur2D(0, -300), 2, true, SpaceInvaders.Properties.Resources.shoot1),
Game.rnd.Next(10, 20)
);
break;
case 2:
this.data = new Tuple<Missile, int>(
new SuperMissile(new Vecteur2D(0, -300), 2, true, SpaceInvaders.Properties.Resources.shoot1),
Game.rnd.Next(10, 20)
);
break;
}
}
/// <summary>
/// Simple constructor
/// </summary>
/// <param name="position">start position x</param>
public Bonus(Vecteur2D position)
{
Position = position;
int choice = Game.prob.Next(1, 4);
if (choice == 1)
{
image = space_invaders.Properties.Resources.bonus;
imageWidth = image.Width;
imageHeight = image.Height;
bonusName = "BigMissile";
action = new BonusAction(Bonus1);
}
else if (choice == 2)
{
image = space_invaders.Properties.Resources.bonus2;
imageWidth = image.Width;
imageHeight = image.Height;
bonusName = "InstantKill";
action = new BonusAction(Bonus2);
}
else if (choice == 3)
{
image = space_invaders.Properties.Resources.bonus3;
imageWidth = image.Width;
imageHeight = image.Height;
bonusName = "DoublePoints";
action = new BonusAction(Bonus3);
}
}
public Missile( Vecteur2D vit, int li, bool user, Bitmap img)
: base(new Vecteur2D(0,0), 0, img)
{
this.liveOnFire = li;
this.avit = vit;
this.UserMisile = user;
}
/// <summary>
/// Constructeur du vaisseau de joueur
/// </summary>
/// <param name="x">Position en X</param>
/// <param name="y">Position en Y</param>
/// <param name="lives">Point de vie</param>
/// <param name="side">Le camps du vaisseau du joueur</param>
public PlayerSpaceship(float x, float y, int lives, Side side) : base(x, y, lives, side)
{
Image = SpaceInvaders.Properties.Resources.ship3;
Position = new Vecteur2D(x, y - Image.Height); // Soustraction l'hauteur de l'image de la position y pour que l'affichage soit correct
this.SpaceShipSpeedPixelPerSecond = ConstantsDeJeu.PlayerSpaceShipSpeedPixelPerSecond;
Side = side;
}
public Missile()
: base(new Vecteur2D(0, 0), 0, SpaceInvaders.Properties.Resources.shoot1)
{
this.UserMisile = true;
this.liveOnFire = 2;
this.avit= new Vecteur2D(0, -100);
}
/// <summary>
/// Simple constructor
/// </summary>
/// <param name="position">start position</param>
public EnemyBlock(Vecteur2D position)
{
Position = position;
Size = Size.Empty;
Ships = new List <SpaceShip>();
}
public Missile(Vecteur2D pos, Vecteur2D vit,int li,bool user)
: base(pos,0,SpaceInvaders.Properties.Resources.shoot1)
{
this.liveOnFire = li;
this.avit = vit;
this.UserMisile = user;
}
/// <summary>
/// Update the dimensions of the enemy block
/// </summary>
private void UpdateBBox()
{
Vecteur2D topLeftCorner = new Vecteur2D(Int32.MaxValue, Int32.MaxValue);
Vecteur2D bottomRightCorner = new Vecteur2D(0, 0);
foreach (SpaceShip s in Ships)
{
if (s.Position.x < topLeftCorner.x)
{
topLeftCorner.x = s.Position.x;
}
if (s.Position.y < topLeftCorner.y)
{
topLeftCorner.y = s.Position.y;
}
if (s.Position.x > bottomRightCorner.x)
{
bottomRightCorner.x = s.Position.x + s.imageWidth;
}
if (s.Position.y > bottomRightCorner.y)
{
bottomRightCorner.y = s.Position.y + s.imageHeight;
}
}
Position = new Vecteur2D(topLeftCorner.x, topLeftCorner.y);
Size.Width = (int)bottomRightCorner.x - (int)Position.x;
Size.Height = (int)bottomRightCorner.y - (int)Position.y;
}
/// <summary>
/// Crée un nouveau <see cref="Player"/> au centre
/// </summary>
public Player() : this(0, 0)
{
Bitmap playerSprite = Properties.Resources.ship1;
Vecteur2D pos = new Vecteur2D((Game.game.gameSize.Width / 2) - (playerSprite.Width), Game.game.gameSize.Height - (2 * playerSprite.Height));
this.position = pos;
}
/// <summary>
/// Determine les pixels qui sont en collisions entre deux sprites
/// </summary>
/// <param name="b">L'autre sprite</param>
/// <param name="position">La position de ce sprite</param>
/// <param name="positionB">La position de l'autre sprite</param>
/// <returns>La liste des pixels en collisions (représentés par des vecteurs)</returns>
public List <Vecteur2D> pixelColliding(Sprite b, Vecteur2D position, Vecteur2D positionB)
{
List <Vecteur2D> listColliding = new List <Vecteur2D>();
if (b == null)
{
return(listColliding);
}
//On détermine le rectangle en collision
Vecteur2D v1Collision = new Vecteur2D(Math.Max(0, positionB.X - position.X), Math.Max(0, positionB.Y - position.Y));
Vecteur2D v2Collision = new Vecteur2D(Math.Min(Draw().Width, positionB.X + b.Draw().Width - position.X), Math.Min(Draw().Height, positionB.Y + b.Draw().Height - position.Y));
for (int y = (int)v1Collision.Y; y < (int)v2Collision.Y; y++)
{
for (int x = (int)v1Collision.X; x < (int)v2Collision.X; x++)
{
if (isPixelsColliding(x, y, position, positionB, b))
{
listColliding.Add(new Vecteur2D(x, y));
}
}
}
return(listColliding);
}
/// <summary>
/// Redimensionne la hitbox en fonction des enemis à l'intérieur
/// </summary>
public void resizeHitbox()
{
Vecteur2D min = new Vecteur2D(int.MaxValue, int.MaxValue);
Vecteur2D max = new Vecteur2D();
foreach (Enemy enemy in Game.game.gameObjects.OfType <Enemy>())
{
if (enemy.position.X < min.X)
{
min = new Vecteur2D(enemy.position.X, min.Y);
}
if (enemy.position.Y < min.Y)
{
min = new Vecteur2D(min.X, enemy.position.Y);
}
if (enemy.position.X + enemy.sprite.Draw().Width > max.X)
{
max = new Vecteur2D(enemy.position.X + enemy.sprite.Draw().Width, max.Y);
}
if (enemy.position.Y + enemy.sprite.Draw().Height > max.Y)
{
max = new Vecteur2D(max.X, enemy.position.Y + enemy.sprite.Draw().Height);
}
}
this.hitbox = new Rectangle(min, max);
}
/// <summary>
/// Simple constructor
/// </summary>
/// <param name="position">start position x</param>
public Bunker(Vecteur2D position)
{
this.image = space_invaders.Properties.Resources.bunker;
this.imageWidth = image.Width;
this.imageHeight = image.Height;
Position = position;
}
/// <summary>
/// Simple constructor
/// </summary>
public Win()
{
this.image = space_invaders.Properties.Resources.win;
this.imageWidth = image.Width;
this.imageHeight = image.Height;
Position = new Vecteur2D(Game.game.gameSize.Width / 2 - imageWidth / 2, -imageHeight);
}
/// <summary>
/// Drop a random bonus
/// </summary>
/// <param name="position">Postion of the destroyed enemy</param>
public void RandomBonus(Vecteur2D position)
{
if (Game.prob.NextDouble() < bonusProbability)
{
Bonus b = new Bonus(position);
bonus.Add(b);
}
}
public EnnemiBlock(Vecteur2D pos,Vecteur2D pspeed)
: base(pos, 1, null)
{
this.speed = pspeed;
this.s = new Size(0,0);
this.listSpaceship = new List<BasicShip>();
this.decalageBox = new Vecteur2D();
}
/// <summary>
/// Initialise un nouveau <see cref="Missil"/>
/// </summary>
/// <param name="position">Position initiale</param>
/// <param name="team">Equipe du missile</param>
public Missil(Vecteur2D position, Teams team)
{
this.position = position;
this.team = team;
if (team == Teams.Player)
{
missilSpeed *= -1; //On ira vers le haut
}
}
/// <summary>
/// Move the object. Last call to move was deltaT seconds ago.
/// </summary>
/// <param name="deltaT">Time ellapsed since last move.</param>
public void Move(double deltaT)
{
if ((Position.x >= 0 && (Position.x + Size.Width) < Game.game.gameSize.Width))
{
foreach (SpaceShip ship in Ships)
{
ship.Move(deltaT, SpeedX.x);
}
Position.x += SpeedX.x * deltaT;
if ((Position.x + Size.Width) >= Game.game.gameSize.Width)
{
for (int i = 0; i < deltaT * 2000; ++i)
{
foreach (SpaceShip Ship in Ships)
{
Ship.Position.y += SpeedY.y * deltaT;
}
Position.y += SpeedY.y * deltaT;
}
SpeedX = -SpeedX * 1.1;
}
}
else if (Position.x > 1)
{
foreach (SpaceShip Ship in Ships)
{
Ship.Move(deltaT, SpeedX.x);
}
Position.x += SpeedX.x * deltaT;
}
else if (Position.x < 1)
{
for (int i = 0; i < deltaT * 2000; ++i)
{
foreach (SpaceShip Ship in Ships)
{
Ship.Position.y += SpeedY.y * deltaT;
}
Position.y += SpeedY.y * deltaT;
}
SpeedX = -SpeedX * 1.1;
foreach (SpaceShip Ship in Ships)
{
Ship.Position.x += SpeedX.x / 10;
}
Position.x += SpeedX.x / 10;
}
}
/// <summary>
/// Crée un nouveau <see cref="Bonus"/>.
/// </summary>
/// <param name="sprite">Sprite du bonus</param>
/// <param name="position">Position initiale du Bonus</param>
public Bonus(Sprite sprite, Vecteur2D position)
{
this.sprite = sprite;
this.position = position;
List <BonusType> types = Enum.GetValues(typeof(BonusType)).Cast <BonusType>().ToList();
int random = new Random().Next(types.Count);
type = types[random];
}
/// <summary>
/// Soustraction vectorielle
/// </summary>
/// <param name="v1">Vecteur 1</param>
/// <param name="v2">Vecteur 2</param>
/// <returns></returns>
public static Vecteur2D operator -(Vecteur2D v1, Vecteur2D v2)
{
Vecteur2D result = new Vecteur2D();
result.x = v1.x - v2.x;
result.y = v1.y - v2.y;
return(result);
}
/// <summary>
/// Met a jour l'état d'un objet
/// </summary>
/// <param name="gameInstance">Instance de la partie</param>
/// <param name="deltaT">Temps écoulé depuis le dernier appel</param>
public override void Update(Game gameInstance, double deltaT)
{
position += new Vecteur2D(0, missilSpeed * deltaT);
foreach (GameObject go in gameInstance.gameObjects)
{
checkAndHandleCollision(go);
}
}
/// <summary>
/// Simple constructor
/// </summary>
/// <param name="image">Image used to illustrate the player ship</param>
/// <param name="position">start position x</param>
/// <param name="lives">Number of lives</param>
public SpaceShip(Bitmap image, Vecteur2D position, int lives)
{
this.image = image;
this.imageWidth = image.Width;
this.imageHeight = image.Height;
Position = position;
Lives = lives;
}
/// <summary>
/// Met a jour l'état d'un objet
/// </summary>
/// <param name="gameInstance">Instance de la partie</param>
/// <param name="deltaT">Temps écoulé depuis le dernier appel</param>
public override void Update(Game gameInstance, double deltaT)
{
position += new Vecteur2D(0, bonusSpeed * deltaT);
Player p = gameInstance.gameObjects.OfType <Player>().First();
if (p.IsColliding(this))
{
collision(p);
}
}
/// <summary>
/// Gère les cas ou il va y avoir une sortie d'écran
/// </summary>
/// <param name="deltaT">The delta t.</param>
private void handleOutOfBound(double deltaT)
{
if (position.X + PlayerSpeed * deltaT > Game.game.gameSize.Width - sprite.Draw().Width)
{
position = new Vecteur2D(Game.game.gameSize.Width - sprite.Draw().Width, position.Y);
}
else if (position.X + -PlayerSpeed * deltaT < 0)
{
position = new Vecteur2D(0, position.Y);
}
}
/// <summary>
/// Simple constructor
/// </summary>
public Intro()
{
this.image = space_invaders.Properties.Resources.esieelogo;
this.imageWidth = image.Width;
this.imageHeight = image.Height;
timeIntro.Start();
Position1 = new Vecteur2D(1000, 200.0);
Position2 = new Vecteur2D(1000, 250.0);
Position3 = new Vecteur2D(1000, 300.0);
}
/// <summary>
/// Simple constructor
/// </summary>
/// <param name="vitesse">Speed of the missile.</param>
/// <param name="position">Position of the missile.</param>
/// <param name="lives">Number of lives of the missile.</param>
public Missile(Vecteur2D vitesse, Vecteur2D position, int lives)
{
this.image = space_invaders.Properties.Resources.shoot1;
this.imageWidth = this.image.Width;
this.imageHeight = this.image.Height;
Vitesse = vitesse;
Position = position;
Lives = lives;
}
/// <summary>
/// Supprime les pixels qui sont en collisions
/// </summary>
/// <param name="b">L'autre sprite</param>
/// <param name="position">La position du sprite</param>
/// <param name="positionB">La position de l'autre sprite</param>
/// <returns>nombre de pixels supprimées</returns>
public int deleteCollidingPixels(Sprite b, Vecteur2D position, Vecteur2D positionB)
{
List <Vecteur2D> collidingPixels = pixelColliding(b, position, positionB);
foreach (Vecteur2D pixel in collidingPixels)
{
foreach (Bitmap img in image)
{
img.SetPixel((int)pixel.X, (int)pixel.Y, Color.FromArgb(0, 255, 255, 255));
}
}
return(collidingPixels.Count());
}
/// <summary>
/// Génère une rangée de bunkers
/// </summary>
/// <param name="instance">Instance de la partie</param>
/// <param name="number">Nombre de bunker a générer</param>
public static void generateBunkers(Game instance, int number)
{
Bitmap sprite = Properties.Resources.bunker;
Bitmap playerSprite = Properties.Resources.ship1;
Vecteur2D start = new Vecteur2D(0, instance.gameSize.Height - (playerSprite.Height * number + 50 + sprite.Height));
int offset = (instance.gameSize.Width - (number * sprite.Width)) / (number + 1);
start += new Vecteur2D(offset, 0);
for (int i = 0; i < number; i++)
{
instance.AddNewGameObject(new Bunker(new Vecteur2D(start)));
start += new Vecteur2D(offset + sprite.Width, 0);
}
}
/// <summary>
/// Met a jour l'état d'un objet
/// </summary>
/// <param name="gameInstance">Instance de la partie</param>
/// <param name="deltaT">Temps écoulé depuis le dernier appel</param>
public override void Update(Game gameInstance, double deltaT)
{
if (activeMissil != null && !activeMissil.IsAlive())
{
this.activeMissil = null;
}
if (Game.game.keyPressed.Contains(Keys.Right) || Game.game.keyPressed.Contains(Keys.Left))
{
handleOutOfBound(deltaT);
position += determineMove(deltaT);
}
if (Game.game.keyPressed.Contains(Keys.Space) && activeMissil == null)
{
fireMissil(gameInstance);
}
if (remainingTimeBonus > 0) //Si un bonus est actif
{
remainingTimeBonus -= deltaT;
}
}
/// <summary>
/// Met a jour l'état d'un objet
/// </summary>
/// <param name="gameInstance">Instance de la partie</param>
/// <param name="deltaT">Temps écoulé depuis le dernier appel</param>
public override void Update(Game gameInstance, double deltaT)
{
if (hitbox == null)
{
resizeHitbox();
}
handleCollisions(gameInstance.gameObjects);
Vecteur2D toAdd = determineToAdd(gameInstance, deltaT);
if (hitbox.v2.X == gameInstance.gameSize.Width || hitbox.v1.X == 0)
{
hitbox += toAdd;
xSpeed *= -1;
}
else
{
hitbox += toAdd;
}
foreach (Enemy enemy in gameInstance.gameObjects.OfType <Enemy>())
{
enemy.position += toAdd;
}
}
/// <summary>
/// Determines to le déplacement a ajouter au groupe d'ennemi
/// </summary>
/// <param name="gameInstance">L'instance de partie</param>
/// <param name="deltaT">Le temps depuis le dernier appel</param>
/// <returns>Vecteur a ajouter</returns>
private Vecteur2D determineToAdd(Game gameInstance, double deltaT)
{
Vecteur2D toAdd;
if (hitbox.v2.X == gameInstance.gameSize.Width || hitbox.v1.X == 0)
{
toAdd = new Vecteur2D((xSpeed < 0) ? 1 : -1, ySpeed); // Gère la fin de l'écran
xSpeed *= 1.25;
}
else if (hitbox.v1.X + xSpeed * deltaT < 0)
{
toAdd = new Vecteur2D(-hitbox.v1.X, 0);
}
else if (hitbox.v2.X + xSpeed * deltaT > Game.game.gameSize.Width)
{
toAdd = new Vecteur2D(gameInstance.gameSize.Width - hitbox.v2.X, 0);
}
else
{
toAdd = new Vecteur2D(deltaT * xSpeed, 0);
}
return(toAdd);
}
public EnemyBlock(Vecteur2D position)
{
}
public Spaceship(Vecteur2D pos , int li)
: base(pos,li,SpaceInvaders.Properties.Resources.ship3)
{
playerSpeed = 200;
this.munitionStock = new MunitionManager();
}
public Vecteur2D(Vecteur2D v)
: this(v.x,v.y)
{
}
/// <summary>
/// Redimensionne en changeant le point en haut a gauche
/// </summary>
/// <param name="v">Le changement a effectuer</param>
public void resizeP1(Vecteur2D v)
{
this.v1 += v;
}
/// <summary>
/// Simple constructor
/// </summary>
/// <param name="x">start position x</param>
/// <param name="y">start position y</param>
public Score()
{
score = 0;
Position = new Vecteur2D(Game.game.gameSize.Width, 2);
}
public Vecteur2D addition(Vecteur2D v)
{
return new Vecteur2D(this.x + v.x, this.y + v.y);
}
/// <summary>
/// Determines Collision between player ship and a missile
/// </summary>
/// <param name="m">Colliding missile</param>
public bool Collision(Missile m)
{
if (m.Position.x > Position.x + imageWidth)
{
return(false);
}
else if (m.Position.y > Position.y + imageHeight)
{
return(false);
}
else if (Position.x > m.Position.x + m.imageWidth)
{
return(false);
}
else if (Position.y > m.Position.y + m.imageHeight)
{
return(false);
}
else
{
Vecteur2D[] v = new Vecteur2D[m.imageWidth * m.imageHeight];
for (int i = 0; i < m.imageWidth; i++)
{
for (int j = 0; j < m.imageHeight; j++)
{
v[(i * m.imageHeight) + j] = new Vecteur2D((i + m.Position.x) - Position.x, (j + m.Position.y) - Position.y);
}
}
Color currentcolor;
Vecteur2D currentV = new Vecteur2D();
for (int i = 0; i < v.Length; i++)
{
if (v[i].y >= 0 && v[i].x > 0 && v[i].x < imageWidth && v[i].y < imageHeight)
{
currentcolor = image.GetPixel((int)v[i].x, (int)v[i].y);
if (currentcolor == Color.FromArgb(255, 0, 0, 0))
{
currentV.x = v[i].x;
currentV.y = v[i].y;
i = v.Length;
}
}
}
if (currentV.x != 0 || currentV.y != 0)
{
for (int i = (int)currentV.y; i < imageHeight; i++)
{
currentcolor = image.GetPixel((int)currentV.x, i);
if (currentcolor == Color.FromArgb(0, 255, 255, 255))
{
currentV.y = i - 1;
i = imageHeight;
}
}
for (int i = 0; i < m.imageWidth; i++)
{
if (currentV.y > 0 && currentV.x > 0 && (i + currentV.x) < imageWidth)
{
currentcolor = image.GetPixel((int)(i + currentV.x), (int)currentV.y);
if (currentcolor == Color.FromArgb(255, 0, 0, 0))
{
Lives--;
m.Lives--;
return(true);
}
}
}
}
return(false);
}
}
public Vecteur2D soustraction(Vecteur2D v)
{
return new Vecteur2D(this.x - v.x, this.y - v.y);
}
//public bool collision;
public Bunker(Vecteur2D position)
{
this.vie = 5;
this.position = position;
this.image = new Bitmap("../../resources/bunker.png");
}
public Bonus(Vecteur2D pos)
: this(pos, SpaceInvaders.Properties.Resources.bonus)
{
}
public Bunker(Vecteur2D pos)
: base(pos,1, SpaceInvaders.Properties.Resources.bunker)
{
}
public Bonus(Vecteur2D pos,Bitmap img)
: base(pos, 1,img)
{
bonusList.Add(this);
this.speed = new Vecteur2D(0, 50);
}
/// <summary>
/// Permet d’initialiser la position et la largeur de base du bloc d'ennemie
/// </summary>
/// <param name="x">Position en X</param>
/// <param name="y">Position en Y</param>
/// <param name="baseWidth">La largeur de base du bloc</param>
/// <param name="side">Le camps du bloc</param>
public EnemyBlock(float x, float y, int baseWidth, Side side) : base(side)
{
Position = new Vecteur2D(x, y);
this.baseWidth = baseWidth;
Size = new Size(0, 0);
}
public EnemyBlock(Vecteur2D position)
{
this.position = position;
}
public Vecteur2D multiplication(Vecteur2D v)
{
return new Vecteur2D(this.x * v.x, this.y * v.y);
}
public IndirectVecteur2D(Vecteur2D v,int decX, int decY)
{
refe = v;
this.decnx = decX;
this.decny = decY;
}
public void move()
{
this.position=this.position.addition(this.vitesse);
}
/// <summary>
///
/// </summary>
/// <param name="ppos">position to draw</param>
/// <param name="plive">live to the item</param>
/// <param name="pimg">image to draw</param>
protected BasicObjet(Vecteur2D ppos, int plive, Bitmap pimg)
{
this.position = ppos;
this.live = plive;
img = pimg;
}
public BasicShip(Vecteur2D v, int live, Bitmap bi,double spd)
: base(v, live, bi)
{
this.speedMisile = spd;
}
public BasicShip(BasicShip bs, Vecteur2D dec)
: this(dec, bs.live, bs.img,bs.speedMisile)
{
}
/// <summary>
/// Constructeur du bunker
/// </summary>
/// <param name="x">Position en X</param>
/// <param name="y">Position en Y</param>
/// <param name="side">Le camps du bunker</param>
public Bunker(float x, float y, Side side) : base(side)
{
Position = new Vecteur2D(x, y);
Image = SpaceInvaders.Properties.Resources.bunker;
}
public SuperMissile(Vecteur2D vit, int li, bool user,Bitmap img)
: base(new Vecteur2D(0,0), vit, li, user, img)
{
this.brotherRight = new Missile( vit + new Vecteur2D(30, 30), li, user, img);
this.brotherLeft = new Missile( vit + new Vecteur2D(-30, 30), li, user, img);
}
