/// <summary>
/// Dessine le sprite en fond si il existe, puis le sprite en fonction du pourcentage dans le rectangle calculé
/// selon le pourcentage courant et les booléens Vertical et Inverted, qui déterminent dans quel sens se
/// dessine le sprite.
/// </summary>
/// <param name="shift"> La position du sprite </param>
/// <param name="g"> L'objet graphique permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
var percent = Percent * (1 - _percentMerge) + _percentMerge / 2;
int min, max, x1, y1, x2, y2;
var limit = Vertical ? _foregroundSprite.Height : _foregroundSprite.Width;
// Détermine le sens pour dessiner le sprite
if (!Inverted)
{
min = 0;
max = (int)(percent * limit);
}
else // TODO Problème de placement si le sprite est redimensionné
{
min = (int)((1 - percent) * limit);
max = limit;
}
// Entre le haut et le bas
if (Vertical)
{
x1 = 0;
y1 = min;
x2 = _foregroundSprite.Width;
y2 = max;
}
// Entre la droite et la gauche
else
{
x1 = min;
y1 = 0;
x2 = max;
y2 = _foregroundSprite.Height;
}
if (_backgroundSprite != null)
{
DrawBitmap(_backgroundSprite, shift, g,
new Rectangle(0, 0, _foregroundSprite.Width, _foregroundSprite.Height));
}
DrawBitmap(_foregroundSprite, shift, g, new Rectangle(x1, y1, x2, y2));
}
/// <summary>
/// Centre la caméra par rapport aux joueurs vivants.
/// </summary>
private void CenterCamera()
{
var camera = Point.Null;
var numPlayersAlive = 0;
foreach (var player in _players)
{
if (player.IsDead())
{
continue;
}
camera += player.Position;
numPlayersAlive++;
}
if (numPlayersAlive > 0)
{
camera /= numPlayersAlive;
camera -= new Point(MainForm.FixedWidth / 2.0, MainForm.FixedHeight / 2.0);
_camera = camera;
}
}
/// <summary>
/// Déplace l'acteur dans le monde, actualise ses collisions (si il en a) et le retrie dans la
/// liste d'acteurs du monde pour tenir compte de sa nouvelle ordonnée dans l'ordre d'affichage.
/// </summary>
/// <param name="shift"> Les coordonnées du point correspondent au déplacement </param>
public void Move(Point shift)
{
Replaces(Position + shift);
Collision?.UpdateAndCollide();
}
/// <summary>
/// Affiche l'acteur si il possède un SpriteHandler à partir de sa position basse.
/// </summary>
/// <param name="shift"> La position relative pour afficher l'acteur </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public virtual void Draw(Point shift, Graphics g)
{
SpriteHandler?.Draw(shift + Bottom(), g);
}
/// <summary>
/// Affiche le numéro de la vague courante, et écrit en-dessous le temps restant avant la prochaine.
/// </summary>
/// <param name="shift"> La position de décalage, inutilisée </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
new Text("Niveau " + World.GetWorld().Level +
" - Vague courante : " + _level.Wave).Draw(Position, g);
_cooldown.Draw(Position + new Point(0, 35), g);
}
/// <summary>
/// Crée le composant en lui donnnant le LevelScript à observer pour récupérer la vague courante et le temps
/// restant.
/// </summary>
/// <param name="position"> Le centre du composant </param>
/// <param name="level"> Le LevelScript observé </param>
public LevelObserver(Point position, LevelScript level) : base(position)
{
_level = level;
Update();
}
/// <summary>
/// Crée le composant en indiquant le joueur et son numéro de sort associé.
/// </summary>
/// <param name="position"> Le centre du composant </param>
/// <param name="owner"> Le joueur associé </param>
/// <param name="numSpell"> Le numéro du sort associé </param>
public SpellSocket(Point position, PlayerCharacter owner, int numSpell) : base(position)
{
_owner = owner;
_numSpell = numSpell;
Update();
}
/// <summary>
/// Affiche l'acteur selon la classe mère et ajoute les possibles affichages de ses états courants.
/// </summary>
/// <param name="shift"> La position relative pour afficher l'acteur </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
base.Draw(shift, g);
_stateHandler.Draw(Bottom() + shift, g);
}
/// <summary>
/// Affiche le contenu de l'état ainsi que le highscore.
/// </summary>
/// <param name="shift"> La position de décalage, inutilisée </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
base.Draw(shift, g);
_highScore.Draw(new Point(600, 50), g);
}
/// <summary>
/// Affiche la barre de vie.
/// </summary>
/// <param name="shift"> La position de décalage, inutilisée </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
_sprite.Draw(shift + Position, g);
}
/// <summary>
/// Appelle la fonction DrawBitmap par laquelle passe tous les sprites du jeu.
/// </summary>
/// <param name="shift"> La position du sprite à dessiner </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
DrawBitmap(_sprite, shift, g, new Rectangle(0, 0, _sprite.Width, _sprite.Height));
}
/// <summary>
/// Dessine l'image de fond puis affiche les boutons.
/// </summary>
/// <param name="shift"> La position de décalage, inutilisée </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
_screen.Draw(ScreenPoint, g);
ButtonsHandler?.Draw(shift, g);
}
/// <summary>
/// Crée le composant à la position indiquée.
/// </summary>
/// <param name="position"> Le centre du composant </param>
protected HudComponent(Point position)
{
Position = position;
}
/// <summary>
/// Retourne un composant de l'interface ayant accès aux données du niveau en train de se dérouler.
/// </summary>
/// <param name="position"> La position du composant </param>
/// <returns> Le composant de l'interface </returns>
public LevelObserver GetLevelObserver(Point position)
{
return(_levelObserver ?? (_levelObserver = new LevelObserver(position, _levelScript[0])));
}
/// <summary>
/// Affiche le monde puis l'interface.
/// </summary>
/// <param name="shift"> La position de décalage, inutilisée </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
_world.Draw(shift, g);
_hudHandler.Draw(shift, g);
}
/// <summary>
/// Charge le fichier .map du dossier resources/maps ayant le numéro indiqué.
/// Enregistre le nom, la taille et l'image de fond de la map.
/// Puis, parcourt les cases de la map pour enregistrer les positions d'apparition des joueurs, des mobs, des
/// boss et des murs (invisibles ou non). Lors du parcourt, les murs sont crées dans le monde.
/// </summary>
/// <param name="num"> Le numéro de la map à charger </param>
public Map(int num)
{
// Ouvre le fichier correspondant au num demandé
var file = new StreamReader(MapPath + num + ".map");
var line = file.ReadLine();
var elements = line.Split(' ');
Num = num;
// Enregistre l'entête avec le nom et les dimensions de la map.
Name = elements[0];
Width = int.Parse(elements[1]);
Height = int.Parse(elements[2]);
// Initialise les Squares et y donne l'accès dans les collisions handler
const int coef = (int)((Square.Size + 0.1) / Size);
var indices = new Point(Width - 1, Height - 1) / coef;
CollisionFunctions.SquaresHandler = new SquaresHandler((int)indices.X + 2, (int)indices.Y + 2);
WallsMatrix = new bool[Width, Height];
_background = new Bitmap(MapPath + Backgrounds + num + ".png");
var j = 0;
PlayerSpawns = new List <Point>();
Gateways = new List <Point>();
while ((line = file.ReadLine()) != null)
{
elements = line.Split(' ');
for (var i = 0; i < Width; i++)
{
var c = elements[i][0];
// x = case vide
if (c == 'x')
{
continue;
}
var p = new Point(i * Size + Size / 2, j * Size + Size / 2);
// p = spawns des joueurs
if (c == 'p')
{
PlayerSpawns.Add(p);
}
// g = spawns des mobs
else if (c == 'g')
{
Gateways.Add(p);
}
// f = spawn du boss
else if (c == 'f')
{
BossSpawn = p;
}
// [int] = mur avec le sprite associé si num != 0
else
{
WallsMatrix[i, j] = true;
var numWall = (int)char.GetNumericValue(c);
var sprite = numWall > 0 ? Walls[numWall] : null;
var transparency = j > 0 && WallsMatrix[i, j - 1] == false;
new Wall(p, sprite, transparency);
}
}
j++;
}
file.Close();
}
public abstract void Draw(Point shift, Graphics g);
/// <summary>
/// Dessine l'image de fond de la map. L'image doit être dessinée en premier pour que les autres acteurs ou
/// composants s'affichent par dessus.
/// </summary>
/// <param name="shift"> La position de décalage </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public void Draw(Point shift, Graphics g)
{
g.DrawImage(_background, new Rectangle(shift, _background.Size));
}
/// <summary>
/// Affiche l'image de l'état, si elle existe.
/// </summary>
/// <param name="shift"> La position où est dessiné l'acteur associé </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public void Draw(Point shift, Graphics g)
{
_data.Sprite?.Draw(shift, g);
}
/// <summary>
/// Affiche le contenu de l'état, puis le texte et le score.
/// </summary>
/// <param name="shift"> La position de décalage, inutilisée </param>
/// <param name="g"> L'objet permettant de dessiner </param>
public override void Draw(Point shift, Graphics g)
{
base.Draw(shift, g);
Title.Draw(new Point(600, 180), g);
_score.Draw(new Point(600, 230), g);
}
