Example #1
0
 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;
     }
 }
Example #3
0
        /// <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;
        }
Example #10
0
        /// <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;
        }
Example #11
0
        /// <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);
        }
Example #12
0
        /// <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);
        }
Example #13
0
        /// <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;
        }
Example #14
0
        /// <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);
        }
Example #15
0
 /// <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();
 }
Example #17
0
 /// <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
     }
 }
Example #18
0
        /// <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;
            }
        }
Example #19
0
        /// <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);
        }
Example #21
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)
        {
            position += new Vecteur2D(0, missilSpeed * deltaT);

            foreach (GameObject go in gameInstance.gameObjects)
            {
                checkAndHandleCollision(go);
            }
        }
Example #22
0
        /// <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;
        }
Example #23
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)
        {
            position += new Vecteur2D(0, bonusSpeed * deltaT);
            Player p = gameInstance.gameObjects.OfType <Player>().First();

            if (p.IsColliding(this))
            {
                collision(p);
            }
        }
Example #24
0
 /// <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);
     }
 }
Example #25
0
        /// <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);
        }
Example #26
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;
        }
Example #27
0
        /// <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());
        }
Example #28
0
        /// <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);
            }
        }
Example #29
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;
     }
 }
Example #30
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 (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;
            }
        }
Example #31
0
        /// <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);
        }
Example #32
0
 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)
 {
 }
Example #35
0
 /// <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;
 }
Example #36
0
 /// <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);
 }
Example #37
0
 public Vecteur2D addition(Vecteur2D v)
 {
     return new Vecteur2D(this.x + v.x, this.y + v.y);
 }
Example #38
0
        /// <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);
            }
        }
Example #39
0
 public Vecteur2D soustraction(Vecteur2D v)
 {
     return new Vecteur2D(this.x - v.x, this.y - v.y);
 }
Example #40
0
 //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);
 }
Example #44
0
 /// <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);
 }
Example #45
0
 public EnemyBlock(Vecteur2D position)
 {
     this.position = position;
 }
Example #46
0
 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;
 }
Example #48
0
 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)
 {
 }
Example #52
0
 /// <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);
 }