Un brouillard de guerre dynamique qui suit l'orientation du Player ?

Bonjour les amis,

Voilà ma demande, j'aimerais vos suggestions pour réaliser un brouillard de guerre qui afficherait en gros uniquement la zone qui correspond au champ de vision du personnage.

Voici un schéma :

Le principe serait qu'en se déplaçant, ça afficherait temporairement une partie. Un peu comme s'il avait une lampe torche en fait.

Vous avez des idées pour quelque chose d'ergonomique ? Car j'ai plusieurs pistes, mais elles sont un peu bourrines...

Tu peux regarder du côté de ce module. C'est quoi les pistes que t'avais sinon ?

EDIT : le lien principal pour télécharger le module semble mort, mais le mirroir est toujours fonctionnel

Je crois que j'avais fait un objet de la taille de l'écran, opaque autour, transparent au milieu, qui suivait le joueur dans le repeatidly_execute de la room, mais je ne me souvient plus pour quel jeux, sans doute NATD ?

EDIT: j'avais pas vu l'image qui c'est chargé trop lentement, mais l'idée doit être adaptable, mais un poil plus complexe? Avec la fonction pour tourner les sprites ?

Merci pour vos réponses.

Alors, je connais ce module, mais effectivement, l'idée c'est simplement un masque noir avec une sphère transparente qui suit le joueur.
Là, où c'est plus complexe c'est que j'aimerais plutôt avoir une sorte de camembert qui tourne en fonction du joueur.

La seule fonction qu va dans ce sens, c'est le rotate sprite.
Dommage qu'on ne puisse pas l'utiliser avec les Overlay.

Sinon en méthode bourrine, j'avais celle de faire du calque un character et comme ça, on peut utiliser le FaceDirection du perso principal, mais bof... Celle d'avoir un objet qui recouvre tout l'écran ; enfin l'objet doit être la double taille de l'écran, le problème c'est que la résolution de mon jeu est de 1920 x1200 et donc avoir un objet de 3840 * 2400. A cette taille une image c'est 15Mo et il faut en penser une pour chaque angle ( Haut / bas / Gauche / droite / Haut gauche / Haut droite / bas gauche / bas droite) et elle doit se recharger chaque cycle ... Ca me bouffait 30/40 fps facile, sans parler du temps de chargement de la room qui était inutilement long, je trouvais.  

En dernière piste, j'avais celle d'un GUI, préalablement découpé en camemberts noirs et jongler avec le visible = true / false, selon la direction de mon perso.

Et surtout le pire du pire, je veux avoir la possibilité de switcher entre différents persos durant les combats, pour justement découvrir d'autre partie de la carte...

filoulefilou a écrit:

La seule fonction qu va dans ce sens, c'est le rotate sprite.
Dommage qu'on ne puisse pas l'utiliser avec les Overlay.

Tu peux tout à fait utiliser des sprites comme Overlays, même si le module suscité propose plutôt d'utiliser des GUIs par défaut. Exemple (non fonctionnel) :

Code:

enum Orientation {
  eBas = 0,
  eGauche = 1,
  eDroite = 2,
  eHaut = 3,
  eBasGauche = 4,
  eBasDroite = 5,
  eHautGauche = 6,
  eHautDroite = 7
};

Overlay* brouillard;
Sprite* masque;
Character* voyeur;
Orientation angle;


function initBrouillard(Character* this){
    masque = DynamicSprite.Create(System.ViewportWidth, System.ViewportHeight, true);
    angle = this.Loop;
    voyeur = this;
    if (brouillard && brouillard.Valid)
        brouillard.Remove();
}

function repeatedly_execute_always(){
  if (voyeur == null || voyeur.Loop == angle)
    return;
  angle = voyeur.Loop;
  if (!brouillard.Valid)
    brouillard.CreateGraphical(0, 0, masque.Graphic, true);
  DrawingSurface* toile = masque.GetDrawingSurface();
  toile.Clear(0);
  toile.DrawingColor = COLOR_TRANSPARENT;
  // Ici tu dessines le cone avec la couleur transparente
  toile.Release();
  // masque.Rotate( calcul en fonction de angle ); // tu pivotes ici, ou bien directement lorsque tu dessines
}

filoulefilou a écrit:

En dernière piste, j'avais celle d'un GUI, préalablement découpé en camemberts noirs et jongler avec le visible = true / false, selon la direction de mon perso.

Qu'est-ce qui va pas avec ça ? Ça me paraît très simple et économe en ressources.

filoulefilou a écrit:

Et surtout le pire du pire, je veux avoir la possibilité de switcher entre différents persos durant les combats, pour justement découvrir d'autre partie de la carte...

Est-ce que ça ajoute quoi que ce soit, ça ? Tu dois mettre à jour le brouillard à chaque cycle dans tous les cas, donc que tu changes de perso en cours de route devrait pas vraiment avoir d'impact (tant que ton générateur de brouillard peut prendre n'importe quel perso comme paramètre).

Plusieurs problèmes avec les GUI, c'est encore une fois une question de taille, afficher un Sprite trop gros, ca fait perdre trop de FPS. Surtout si je le recharge a chaque cycle.


En regardant ton code, je me suis posé plusieurs questions...
Est-ce que ça serait possible d'avoir une dynamiqueSprite (le triangle)
Puis lui dire de dessiner tout l'écran en noir avec un DynamiqueSprite qui ferait la taille de l'écran puis un Clear par exemple, puis lui dire de dessiner par dessus le DynamiqueSprite du triangle mais en COLOR_TRANSPARENT ? Et j'aurais juste à jouer avec le Rotate par la suite pour déplacer mon triangle ?

J'avais fait un petit code dans cet esprit mais je n'étais pas très convaincu de l'effet au final.
Par contre je n'avais pas utilisé la fonction de rotation et c'est peut être une meilleure idée.

Voici ma fonction :

Code:

DynamicSprite *sprite;
DrawingSurface *surface ;
Overlay* calque ;
int cycle;
// Les variables pour définir la portée de la vision
int vA = 75 ;
int vB = 200 ;

    
function Fog(this Character*)
{
  if (cycle>=0) {
    if (cycle == 0 ) {
      sprite = DynamicSprite.Create(Room.Width, Room.Height);
      surface = sprite.GetDrawingSurface();
      surface.DrawingColor=0;
      surface.DrawRectangle(0, 0, Room.Width, Room.Height); // On dessine un carré noir de la taille de la room
      surface.Release();
      surface = sprite.GetDrawingSurface();
      surface.DrawingColor = COLOR_TRANSPARENT;  // On utilise la couleur transparente pour dessiner un triangle selon la direction du personnage
      if ( this.Loop == 0 ) surface.DrawTriangle(this.x-GetViewportX(), this.y-GetViewportY(), this.x-GetViewportX()-vA, this.y-GetViewportY()+vB, this.x-GetViewportX()+vA, this.y-GetViewportY()+vB);
      else if ( this.Loop == 1 ) surface.DrawTriangle(this.x-GetViewportX(), this.y-GetViewportY(), this.x-GetViewportX()-vB, this.y-GetViewportY()+vA, this.x-GetViewportX()-vB, this.y-GetViewportY()-vA);
      else if ( this.Loop == 2 ) surface.DrawTriangle(this.x-GetViewportX(), this.y-GetViewportY(), this.x-GetViewportX()+vB, this.y-GetViewportY()+vA, this.x-GetViewportX()+vB, this.y-GetViewportY()-vA);
      else if ( this.Loop == 3 ) surface.DrawTriangle(this.x-GetViewportX(), this.y-GetViewportY(), this.x-GetViewportX()-vA, this.y-GetViewportY()-vB, this.x-GetViewportX()+vA, this.y-GetViewportY()-vB);
      calque = Overlay.CreateGraphical(0 , 0 , sprite.Graphic, false);
      surface.Release();
      sprite.Delete();
    }
    if ( cycle >= 20 ) { // La fréquence de rafraichissement du brouillard
      cycle = 0 ;
      calque.Remove();
    }
  }
  else cycle++;

}

function repeatedly_execute()
{
player.Fog();
}

A noter que la taille du cône de vision est gérée de manière très rudimentaire et que pour bien faire, avec un personnage à 8 directions, il faudrait ajouter un peu de trigonométrie au code pour dessiner le triangle.

filoulefilou a écrit:

Plusieurs problèmes avec les GUI, c'est encore une fois une question de taille, afficher un Sprite trop gros, ca fait perdre trop de FPS. Surtout si je le recharge a chaque cycle.

Ah oui, tu as une haute résolution ? Ça me surprend quand même qu'une image simple, composée par exemple que de pixels noirs + transparents (PNG) utiliserait tant de ressource (quand t'y penses le background est beaucoup plus complexe que ça et peut même dépasser la résolution sans poser de problème de performance).

filoulefilou a écrit:

En regardant ton code, je me suis posé plusieurs questions...
Est-ce que ça serait possible d'avoir une dynamiqueSprite (le triangle)
Puis lui dire de dessiner tout l'écran en noir avec un DynamiqueSprite qui ferait la taille de l'écran puis un  Clear par exemple, puis lui dire de dessiner par dessus le DynamiqueSprite du triangle mais en COLOR_TRANSPARENT ? Et j'aurais juste à jouer avec le Rotate par la suite pour déplacer mon triangle ?

Oui c'est presque exactement ce que j'avais en tête avec mon proto-code (bourré de problèmes, j'ai essayé de le compiler et j'ai eu plein d'erreurs !). J'imaginais dessiner le triangle avec DrawTriangle, mais c'est tout à fait possible aussi d'avoir la forme du triangle stockée dans une sprite et la surimposer en COLOR_TRANSAPRENT (j'ai codé un effet miroir comme ça avant---je sais pas si j'ai encore le code par contre).

Le problème de Rotate c'est que ça peut être un peu lent, mais si c'est juste pour tourner l'image de ton triangle, j'imagine que ça devrait le faire.

Arlann a écrit:

J'avais fait un petit code dans cet esprit mais je n'étais pas très convaincu de l'effet au final.
Par contre je n'avais pas utilisé la fonction de rotation et c'est peut être une meilleure idée.

Voici ma fonction :

Je vois que tu rafraichis tous les 20 cycles : ça marche bien ?
Aussi, est-ce que ce serait pas moins gourmand en ressources d'utiliser System.ViewportWidth et System.ViewportHeight plutôt que Room.Width et Room.Height ?

Arlann a écrit:

A noter que la taille du cône de vision est gérée de manière très rudimentaire et que pour bien faire, avec un personnage à 8 directions, il faudrait ajouter un peu de trigonométrie au code pour dessiner le triangle.

Je garderais une simple énumération s'il y a un nombre fini de directions, comme le rappelle filoulefilou AGS est pas super fort côté performance (surtout que la gestion float-int de AGS est super pénible). Mais d'un autre côté je trouve ça davantage fun de générer le truc avec de la trigo en effet

Kitai a écrit:

Je vois que tu rafraichis tous les 20 cycles : ça marche bien ?

Sur le jeu Les survivants ça tournait bien en 640*480, je n’ai jamais testé en HD.
EDIT : En relisant mon vieux code, je me rend compte que la loop est buguée et ne peut pas rafraichir par cycle de 20... Du coup elle rafraichit à tous les cycles de jeu donc cela n'a pas l'air d'être trop gourmand...

Kitai a écrit:

Aussi, est-ce que ce serait pas moins gourmand en ressources d'utiliser System.ViewportWidth et System.ViewportHeight plutôt que Room.Width et Room.Height ?

Tout dépend de la taille des rooms j’imagine, mais c’est peut être mieux effectivement à voir si cela ne provoque pas des apparitions furtives du décor sur les côtés entre deux rafraichissements en cas de scrolling.

Kitai a écrit:

Je garderais une simple énumération s'il y a un nombre fini de directions, comme le rappelle filoulefilou AGS est pas super fort côté performance (surtout que la gestion float-int de AGS est super pénible). Mais d'un autre côté je trouve ça davantage fun de générer le truc avec de la trigo en effet  

A la base je voulais utiliser de la trigo pour avoir des directions infinies car je voulais simuler le faisceau d’une lampe autour d’un personnage avec la souris. Mais je crois que je me suis emmêlé les pinceaux et que finalement je n’ai pas gardé cette idée de gameplay.

Yeah, ça y est, j'ai exactement ce qu'il me fallait, grâce au code de Arlann.

Enfait, je pensais naïvement que si l'on faisait une zone en COLOR_TRANSPARENT superposé sur un rectangle noir, ça allait donner un rectangle tout noir, je ne savais pas que ça allait effacer la zone en question. C'est hyper puissant comme principe.

Du coup, j'ai pu me faire une image type nuage en opacité 50, puis j'ai utilisé la fonction
masque = DynamicSprite.CreateFromBackground(); Pour avoir une copie de la zone, j'ai superposé mon image de nuage, puis j'ai découpé des triangles transparents. Ca rend trop bien.

J'ai repris ton principe Arlann, celui de définir un triangle a chaque changement de Loop, l'option Rotate est trop complexe, car en gros elle permet de faire tourner l'image, mais comme ma zone c'est pas un carré, mais un rectangle, c'est compliqué.  Je n'arrivais pas a avoir la pointe de mon triangle exactement où je voulais ... Bref

J'ai crée une fonction MAJ_brouillard que j'ai mis dans un repeat_exectute_always (pour que la mise a jour se fasse même si j'utilise des options bloquantes) et en condition pour éviter que ça se fasse a tous les tours inutilement, au lieu d'un cycle,  j'ai ajouté une petite condition du type if(player.Moving) et bingo !
Ca rend hyper bien.

Kitai a écrit:

@filoulefilou a écrit:
Ah oui, tu as une haute résolution ? Ça me surprend quand même qu'une image simple, composée par exemple que de pixels noirs + transparents (PNG) utiliserait tant de ressource (quand t'y penses le background est beaucoup plus complexe que ça et peut même dépasser la résolution sans poser de problème de performance).

Alors, oui, j'ai pu observer que AGS perdait énormément de FPS aussitôt qu'on tapait dans une grande résolution. Depuis les dernières versions, on peut se lâcher sur la résolution, mais je pense que ce logiciel est idéal pour le pixel retro a petite résolution, un peu moins quand il faut gérer les grosses images. D'ailleurs, c'est la même chose pour les musiques, je ne sais pas si vous avez déjà calé ça, mais en transition, ca fait parfois lagger la musique, si on a par exemple un MP3 de plusieurs Mo.

Pour info, avec l'option transparence activée 32 bits true colors, une image de 1920 * 1200 (on est loin des résolutions qu'on pourrait utiliser avec d'autre Engine) , l'image fait 9000ko.  C'est la limite limite, au dessus le logiciel ne suit plus. Une zone trop grande provoque un chargement en transition un peu long aussi.
Voilà pourquoi j'évite de mettre trop d'objets et d'animations superflus.
Si j'avais voulu passer par un GUI qui avait en mémoire plusieurs images Masque de grandes tailles et jouer avec le Visible true/false, ça faisait lagger à mort.

D'ailleurs, la solution que j'applique avec les dynamique sprites fonctionne très bien, car ça demande au jeu de rafraîchir uniquement lors des déplacements, mais durant un déplacement je tombe à 24 FPS / sur 60 en temps normal. C'est pas non plus la fluidité absolue.

J'avais observé ça aussi avec un module sur le forum anglais qui permettait d'avoir des ombres dynamiques plutôt sympa mais qui ne fonctionnait pas du tout sur mon jeu a trop haute résolution. (Je tombais à moins de 10/15 FPS)

Après, je test sans avoir encodé le jeu, si ça se trouve, une fois buildé, ça passe mieux.

Je sais que le sujet est résolu, mais j'ai essayé de continuer mon idée de dessiner le triangle selon toutes les orientations possibles.
Dans mon exemple j'utilise l'orientation de la souris autour d'un personnage et je dessine le triangle transparent sur un fond noir comme dans l'exemple précédent, mais ces coordonnées peuvent bien sûr être utilisées différemment.

Code:

float  angleVision = 45.0 ; // Définir ici l'angle de vision
float distanceVison = 100.0 ; // Définir ici la profondeur de vision

DynamicSprite *sprite ;
DrawingSurface *surface ;
Overlay *overlay ;

void TriangleDeVision(this Character*)
{
  // initialise les valeurs
  int origineX = this.x-GetViewportX(); // L'origine de la vision -> un personnage
  int origineY = this.y-GetViewportY();
  int directionX = mouse.x; // La direction de la vision -> la souris
  int directionY = mouse.y;  
  
  // récupère la distance entre l'origine et la cible grâce à Pythagore
  float a = IntToFloat(directionX-origineX);
  float b = IntToFloat(directionY-origineY);
  float c = Maths.Sqrt(a*a+b*b);
  
  // trouve l'angle de direction avec le cosinus (la médiane du triangle)
  float alpha ;
  if (c != 0.0 ) alpha = Maths.ArcCos(a/c);  
  else alpha = 0.0 ; // impossible de diviser si l'origine et la cible sont identiques
  if(directionY > origineY) alpha = -1.0*alpha ; // inverse l'angle selon cette condition
  
  // calcule les points du triangle de chaque côté de la médiane.
  float delta = Maths.DegreesToRadians(angleVision)/2.0 ;
  float bX = IntToFloat(origineX)+distanceVison*Maths.Cos(alpha-delta);
  float bY = IntToFloat(origineY)-distanceVison*Maths.Sin(alpha-delta);
  float cX = IntToFloat(origineX)+distanceVison*Maths.Cos(alpha+delta);
  float cY = IntToFloat(origineY)-distanceVison*Maths.Sin(alpha+delta);

 // dessine un triangle transparent sur un fond noir
  sprite = DynamicSprite.Create(System.ScreenWidth, System.ScreenHeight);
  surface = sprite.GetDrawingSurface();
  surface.Clear(16);
  surface.DrawingColor=COLOR_TRANSPARENT;
  surface.DrawTriangle(origineX, origineY, FloatToInt(bX), FloatToInt(bY), FloatToInt(cX), FloatToInt(cY));
  surface.Release();
  overlay = Overlay.CreateGraphical(0, 0, sprite.Graphic, false);
  sprite.Delete();
}

// pour enlever l'effet :
if (overlay.Valid) overlay.Remove();

Il existe peut être un moyen plus simple et optimisé pour le calcul mais en tout cas il fonctionne, j'espère que cela pourra servir !