/// <summary>
/// Affiche à l'écran la partie de la mappe monde visible par la caméra.
/// </summary>
/// <param name="camera">Caméra à exploiter pour l'affichage.</param>
/// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param>
protected void Draw(Camera camera, SpriteBatch spriteBatch)
{
// Initialiser le rectangle de destination aux dimensions d'une image.
Rectangle destRect = new Rectangle(0, 0, this.LargeurImage, this.HauteurImage);
// Afficher une rangée à la fois.
for (int row = 0; row < this.Textures.GetLength(0); row++)
{
for (int col = 0; col < this.Textures.GetLength(1); col++)
{
// Calculer la position de l'image à l'écran.
destRect.X = col * this.LargeurImage;
destRect.Y = row * this.HauteurImage;
// Afficher l'image si elle est visible dans la caméra.
if (camera == null || camera.EstVisible(destRect))
{
// Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect
// de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran).
if (camera != null)
{
camera.Monde2Camera(ref destRect);
}
// Afficher l'image courante.
spriteBatch.Draw(this.Textures[row, col], destinationRectangle: destRect); // afficher la tuile
}
}
}
}
/// <summary>
/// Affiche à l'écran la particule (si elle est visible).
/// </summary>
/// <param name="camera">Caméra indiquant la partie du monde présentement visible à l'écran (peut être nulle).</param>
/// <param name="spriteBatch">Tampon d'affichage de sprites.</param>
public override void Draw(float angle, Camera camera, SpriteBatch spriteBatch, SpriteEffects effects = SpriteEffects.None)
{
if (this.Visible)
{
// Calculer le canal alpha à appliquer à la texture (permet à Update() de faire
// graduellement diaparaître l'image à l'écran (fade out).
Color fadeColor = new Color(255, 255, 255, (byte)MathHelper.Clamp(this.fadeAlpha, 0, 255));
// Corriger la position d'affichage de la texture en fonction de l'expansion occasionnée
// par l'explosion.
Vector2 pos = new Vector2(this.Position.X + this.dispersionDelta.X, this.Position.Y + this.dispersionDelta.Y);
// On doit travailler avec une copie de PositionRect car on va mapper ses coordonnées
// en celles du monde si on nous a fourni une caméra.
Rectangle destRect = this.PositionRect;
// Si une caméra est fournie, on s'assure que le sprite y est visible.
if (camera == null || camera.EstVisible(destRect))
{
// Décaler la destination en fonction de la caméra avant de dessiner.
if (camera != null)
{
camera.Monde2Camera(ref destRect);
}
spriteBatch.Draw(this.Texture, pos, null, fadeColor, this.rotation, new Vector2(this.Texture.Width / 2, this.Texture.Height / 2), this.echelle, effects, 1);
}
}
}
/// <summary>
/// Affiche à l'écran le sprite en fonction de la position de la camera. L'affichage est
/// déléguée à palette afin d'afficher la tuile courante d'animation.
/// </summary>
/// <param name="camera">Caméra à exploiter pour l'affichage.</param>
/// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param>
public override void Draw(float angle, Camera camera, SpriteBatch spriteBatch, SpriteEffects effects = SpriteEffects.None)
{
// Calculer les coordonnées du sprite dans le monde.
Rectangle destRect = new Rectangle(0, 0, this.Width, this.Height);
destRect.X = (int)Position.X - (this.Width / 2);
destRect.Y = (int)Position.Y - (this.Height / 2);
// Si une caméra est fournie, on s'assure que le sprite y est visible.
if (camera == null || camera.EstVisible(destRect))
{
// Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect
// de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran).
camera.Monde2Camera(ref destRect);
// Afficher la tuile courante
this.PaletteAnimation.Draw(angle, this.IndexTuile, destRect, spriteBatch, effects);
}
}
/// <summary>
/// Fonction membre à surcharger pour dessiner le sprite. Par défaut la this.texture est
/// affichée à sa position.
/// </summary>
/// <param name="camera">Caméra indiquant la partie du monde présentement visible à l'écran (peut être nulle).</param>
/// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param>
public virtual void Draw(Camera camera, SpriteBatch spriteBatch)
{
// On doit travailler avec une copie de PositionRect car on va mapper ses coordonnées
// en celles du monde si on nous a fourni une caméra.
Rectangle destRect = this.PositionRect;
// Si une caméra est fournie, on s'assure que le sprite y est visible.
if (camera == null || camera.EstVisible(destRect))
{
// Décaler la destination en fonction de la caméra avant de dessiner.
if (camera != null)
{
camera.Monde2Camera(ref destRect);
}
// Afficher le sprite.
spriteBatch.Draw(this.Texture, destinationRectangle: destRect);
}
}
/// <summary>
/// Affiche à l'écran le sprite en fonction de la position de la camera. L'affichage est
/// déléguée à palette afin d'afficher la tuile courante d'animation.
/// </summary>
/// <param name="camera">Caméra à exploiter pour l'affichage.</param>
/// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param>
public override void Draw(Camera camera, SpriteBatch spriteBatch)
{
// Comme l'attribut _position contient la position centrée du sprite mais
// que Draw() considère la position fournie comme celle de l'origine du
// sprite, il faut décaler _position en conséquence avant d'invoquer Draw().
this.ForcerPosition(Position.X - (this.Width / 2), Position.Y - (this.Height / 2));
// Créer destRect aux coordonnées du sprite dans le monde. À noter que
// les dimensions de destRect sont constantes.
Rectangle destRect = new Rectangle((int)Position.X, (int)Position.Y, this.Width, this.Height);
// Afficher le sprite s'il est visible.
if (camera == null)
{
// Afficher la tuile courante.
this.Palette.Draw((int)this.IndexTuile, destRect, spriteBatch);
}
else if (camera.EstVisible(destRect))
{
// Puisque le sprite est visible, déléguer à la palette de tuiles la tâche d'afficher
// la tuile courante.
// Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect
// de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran).
camera.Monde2Camera(ref destRect);
// Afficher la tuile courante.
this.Palette.Draw((int)this.IndexTuile, destRect, spriteBatch);
}
// Remettre _position au centre du sprite.
this.ForcerPosition(Position.X + (this.Width / 2), Position.Y + (this.Height / 2));
}
/// <summary>
/// Affiche à l'écran la partie de la mappe monde visible par la caméra.
/// </summary>
/// <param name="camera">Caméra à exploiter pour l'affichage.</param>
/// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param>
public override void Draw(Camera camera, SpriteBatch spriteBatch)
{
// Initialiser le rectangle de destination aux dimensions d'une image.
Rectangle destRect = new Rectangle(0, 0, this.LargeurImage, this.HauteurImage);
// Afficher une rangée à la fois.
for (int row = 0; row < this.Textures.GetLength(0); row++)
{
for (int col = 0; col < this.Textures.GetLength(1); col++)
{
// Calculer la position de l'image à l'écran.
destRect.X = col * this.LargeurImage;
destRect.Y = row * this.HauteurImage;
// Afficher l'image si elle est visible dans la caméra.
if (camera.EstVisible(destRect))
{
// Puisque l'image est visible, l'afficher.
// Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect
// de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran).
camera.Monde2Camera(ref destRect);
// Afficher l'image courante.
spriteBatch.Draw(this.Textures[row, col], destRect, null, Color.White); // afficher la tuile
}
}
}
}
/// <summary>
/// Affiche à l'écran la partie de la mappe monde visible par la camera.
/// </summary>
/// <param name="camera">Caméra à exploiter pour l'affichage.</param>
/// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param>
public override void Draw(Camera camera, SpriteBatch spriteBatch)
{
// Initialiser le rectangle de destination aux dimensions d'une tuile
Rectangle destRect = new Rectangle(0, 0, this.Palette.LargeurTuile, this.Palette.HauteurTuile);
// Afficher une rangée à la fois
for (int row = 0; row < this.MappeMonde.GetLength(0); row++)
{
for (int col = 0; col < this.MappeMonde.GetLength(1); col++)
{
// Calculer la position de la tuile à l'écran
destRect.X = col * this.Palette.LargeurTuile;
destRect.Y = row * this.Palette.HauteurTuile;
// Afficher la tuile si elle est visible par la caméra
if (camera.EstVisible(destRect))
{
// Puisque le sprite est visible, déléguer à la palette de tuiles la tâche d'afficher
// la tuile courante.
// Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect
// de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran).
camera.Monde2Camera(ref destRect);
// Afficher la tuile courante
this.Palette.Draw(this.MappeMonde[row, col], destRect, spriteBatch);
}
}
}
}
