/// <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); }