Jeu de tir à canon contre une IA

**Ploplopa** · 08/12/2020, 21h11

Bonjour,
Je suis en bac+1 et comme premier vrai devoir en java notre professeur nous a demandé de faire l'algorithme d'un jeu de tire, j'aimerais donc savoir si vous le trouviez correcte ou si il y a des erreurs. Merci !

Code algo :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
G est une constante G=10 m
Vmax est une constance Vmax= 150 m/s
Début
    P_ia,P_joueur,α_joueur,α_ia,d_ia,d_joueur,nbr_tire_ia, nbr_tire_joueur,max_joueur,max_ia,min_joueur,min_ia sont des entiers initialisés à 0
    ECRIRE("Saisir votre zone de stockage en donnant une distance comprise entre 500m et 1500m du canon ennemi")
    LIRE(max_joueur, min_joueur)
    random.randint(500, 1000)
    LIRE(max_ia, min_ia)
    ECRIRE("Saisir une puissance de feu entre 50% et 100%")
    LIRE(P_joueur)
    random.randint(50, 100)
    Lire(P_ia)
    ECRIRE("Saisir un angle de tire entre 25° et 75")
    LIRE(α_joueur)
    random.randint(25, 75)
    LIRE(α_ia)
    TANT QUE d > max_joueur ET d < min_joueur OU d > max_ia et d < min_ia FAIRE 
    nbr_tire_joueur <- nbr_tire_joueur + 1
    d_joueur=[(Vmax∗P_ia)2∗sin (2α_joueur)]/G
    max_joueur <- d_joueur + 10
    min_joueur <- d_joueur - 10
    SI d_joueur < max_joueur et d_joueur > min_joueur
        ECRIRE("Victoire vous avez tiré " nbr_tire_joueur)
    SINON
        SI d_ia > max_joueur
            ECRIRE("Tire trop long")
        SINON
            ECRIRE("Tire trop court")
        FinSI
    FinSI
    nbr_tire_ia <- nbr_tire_ia + 1
    d_ia=[(Vmax∗P_ia)2∗sin (2α_ia)]/G
    max_ia <- d + 10
    min_ia <- d - 10
    SI d < max_ia et d > min_ia
        ECRIRE("Perdu vous avez tiré " nbr_tire_joueur)
    SINON
        SI d > max_ia
            ECRIRE("Tire trop long")
        SINON
            ECRIRE("Tire trop court")
        FinSI
    FinSI
    FinTANTQUE
FIN

**valentin03** · 10/12/2020, 12h43

On pourrait parler d'IA si la cible évitait l'impact en fonction des données de tir.
Ce n'est pas le cas ici.

**tbc92** · 10/12/2020, 13h03

Ligne 6 : Lire ... ok ; peut-être que certains diront que Lire () veut dire " Lire une seule variable", alors qu'ici tu dis : "lire 2 variables", ... détail.
Ligne 7 et 8 : Random() puis Lire (max_ia, min_ia)
Là par contre, c'est bizarre. Ca ne peut pas être bon.
En lignes 15 et 16, on retrouve plus ou moins le même problème.

Ligne 17 : TantQue d > max_joueur ET d < min_joueur OU d > max_ia et d < min_ia FAIRE...

Ici, il y a une règle importante, à retenir toute ta vie : quand il y a un OU dans une succession de tests, la précaution, c'est de mettre des parenthèses.

La ligne que tu as écrite, comment le compilateur va la comprendre ?
TantQue d > max_joueur ET ( d < min_joueur OU d > max_ia ) et d < min_ia FAIRE...
TantQue ( d > max_joueur ET d < min_joueur ) OU ( d > max_ia et d < min_ia ) FAIRE...
TantQue d > max_joueur ET ( d < min_joueur OU (d > max_ia et d < min_ia )) FAIRE...
Autrement ?

Je n'en sais rien. Et je ne sais pas non plus ce que tu voulais faire. Donc mets des parenthèses, ce sera immédiatement très facile à lire, alors que la version sans parenthèses est toujours ambigue.
Je pense que la bonne version est la 2.

Je n'ai pas regardé le reste.

**Galet** · 11/12/2020, 13h01

Bonjour

Envoyé par tbc92

Ligne 17 : TantQue d > max_joueur ET d < min_joueur OU d > max_ia et d < min_ia FAIRE...
...
La ligne que tu as écrite, comment le compilateur va la comprendre ?
...
Je n'en sais rien. Et je ne sais pas non plus ce que tu voulais faire. Donc mets des parenthèses, ce sera immédiatement très facile à lire, alors que la version sans parenthèses est toujours ambigue.
Je pense que la bonne version est la 2.

+1. C'est d'autant plus important que, contrairement aux opérations arithmétiques (+ - * /), tous les systèmes ne traitent pas les opérations booléennes de la même manière. La majorité donne priorité au Et sur le OU, mais certains traitent à la volée.
Les parenthèses permettront, à l'écriture du code, de ne plus dépendre de l'interpréteur...

ps: Tu verras, sans le "e", ton tir sera de meilleure qualité et plus précis

**Ploplopa** · 11/12/2020, 14h13

Bonjour,

Merci pour vos réponses, j'ai décidé de d'abord faire le java avant l'algorithme, ayant plus de compétences en java.

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import java.util.Scanner;
import java.util.Locale;
import java.util.Random;
 
 
public class CanonGame
{
  public static double m_vMax = 150;
  public static double m_gravite = 10;
 
  public static double m_zoneJoueur;
  public static double m_zoneIA;
  public static double m_nbTir;
 
  public static Scanner m_sc;
  public static Random m_rnd;
 
    public static void main(String[] args)
    {
        m_sc = new Scanner(System.in);
        m_rnd = new Random();
 
        //NOTE: Can add a while here to make the game auto restart
        DebutJeu();
 
        while(true)
        {
          if(TourJoueur())
          {
            break;
          }
          if(TourIa())
          {
            break;
          }
        }
    }
 
 
    private static void DebutJeu()
    {
      m_nbTir = 0;
 
      System.out.println("Saisir sa zone de stockage en donnant une distance comprise entre 500m et 1500m du canon ennemi");
      m_zoneJoueur = m_sc.nextInt();
      m_zoneIA = m_rnd.nextInt(1500 - 500 + 1) + 500;
      System.out.println("L'IA a choisi comme zone : " + m_zoneIA);
    }
 
    private static boolean TourJoueur()
    {
      System.out.println("Saisir une puissance de feu entre 50% et 100%");
      double puissance = m_sc.nextInt();
 
      System.out.println("Saisir un angle de tire entre 25° et 75°");
      double alpha = m_sc.nextInt();
 
      double zoneDeTir = TirIa(puissance, alpha);
 
      System.out.println("Vous avez tiré à : " + zoneDeTir);
      m_nbTir++;
 
      if (Touche(m_zoneIA, zoneDeTir))
      {
        System.out.println("Vous avez touché la cible, bravo !");
        System.out.println("Vous avez tirer " + m_nbTir + "fois");
        return true;
      }
 
      if(zoneDeTir > (m_zoneIA + 10))
      {
        System.out.println("Tir trop long");
      }
 
      if(zoneDeTir < (m_zoneIA - 10))
      {
        System.out.println("Tir trop court");
      }
 
      return false;
    }
 
    private static boolean TourIa()
    {
      double puissance = m_rnd.nextInt(100 - 50 + 1) + 50;
      double alpha = m_rnd.nextInt(75 - 25 + 1) + 25;
      double zoneDeTir = TirIa(puissance, alpha);
      System.out.println("L'IA a tirée à : " + zoneDeTir);
 
      if (Touche(m_zoneJoueur, zoneDeTir))
      {
        System.out.println("Vous avez perdu");
        return true;
      }
        return false;
 
    }
 
    private static double TirIa(double _puissance, double _angle)
    {
       _angle = Math.sin(2*(_angle*(Math.PI/180)));
 
       return (Math.pow(m_vMax*(_puissance/100.0), 2.0)* _angle) / m_gravite;
    }
 
    private static boolean Touche(double _zoneCible, double _zoneDeTir)
    {
      return _zoneDeTir <= (_zoneCible + 10) && _zoneDeTir >= (_zoneCible - 10);
    }
}

Voici le nouvel algorithme :
Comme je n'ai pas encore appris à déclarer une fonction je vous le mets sous forme de tableau
Déclaration de fonction :

Fonction	Type	Paramètre
DebutJeu()
TourJoueur()	Booléen
TourIa()	Booléen
Tir()	Flottant	_puissance: flottant / _angle: flottant
Touche()	Booléen	_zonecible: flottant / _zoneDeTir: flottant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
vMax est une constante vMax = 150
gravite est une constante gravite = 10
PI est une constante PI = 3,14
 
zoneJoueur, zoneIA sont des flottants statiques
nbTir est un entier statique
 
Début 
	Début Main()
 
		DebutJeu()
		Tant que (true)
			Si (TourJoueur())
				break
			Fin Si
 
			Si (TourIa())
				break
			Fin Si
		Fin Tant que
	Fin
 
	Début DebutJeu()
		nbTir <- 0
 
		Ecrire ("Saisir sa zone de stockage en donnant une distance comprise entre 500m et 1500m")
		Lire(zoneJoueur)
		zoneIA <- random.randint(500, 1500)
		Ecrire("L'IA a choisi comme zone : ", zoneIA)
	Fin
 
	Début TourJoueur()
 
		puissance, apha, zoneDeTir sont des flottants
 
		Ecrire("Saisir une puissance de feu entre 50% et 100%")
		Lire(puissance)
 
		Ecrire("Saisir un angle de tire entre 25° et 75°")
		Lire(alpha)
 
		zoneDeTire <- TireIA(puissance,alpha)
		Ecrire("Vous avez tiré à : ", zoneDeTir);
		nbTir <- nbTir +1
 
		Si (Touche(zoneIa, zoneDeTir))
			Ecrire("Vous avez touché la cible, bravo !")
        		Ecrire("Vous avez tirer ", m_nbTir ,"fois")
        		return true
		Fin Si
 
		Si (zoneDeTir > (zoneIa + 10))
			Ecrire("Tir trop long")
		Fin Si
 
		Si (zoneDeTir < (zoneIa - 10)
			Ecire("Tir trop court")
		Fin Si
 
		return false
	Fin
 
	Début TourIa()
 
		puissance, apha, zoneDeTir sont des flottants
 
		puissance <- random.randint(50, 100)
		alpha <- random.randint(25, 75)
		zoneDeTir <- TirIa(puissance, alpha)
		Ecrire ("L'IA a tirée à : ", zoneDeTir)
 
 
		Si (Touche(zoneJoueur, zoneDeTir))
			Ecrire ("Vous avez perdu")
			return true
		Fin Si
 
		return false
	Fin
 
 
	Début Tir(_puissance, _angle)
 
		_puissance et _angle sont des flottants
 
		_angle <- sin(2*(_angle*(PI/180)))
 
		return ((vMax*(_puissance/100.0))*(vMax*(_puissance/100.0)) * _angle) / gravite
 
	Fin
 
	Début Touche(_zoneCible, _zoneDeTir)
 
		_zoneCible et _zoneDeTir sont des flottants
 
		return _zoneDeTir <= (_zoneCible + 10) && _zoneDeTir >= (_zoneCible - 10)
 
	Fin
 
Fin

**Ploplopa** · 11/12/2020, 14h38

Envoyé par valentin03

On pourrait parler d'IA si la cible évitait l'impact en fonction des données de tir.
Ce n'est pas le cas ici.

J'ai utilisée "IA" car dans notre énoncé il y avait "l'ordinateur" qui devait faire le calcul de la ligne 19 et "le programme" qui était l'adverse du joueur. Donc j'ai décidée de l'appeler IA pour mieux me retrouver.

**tbc92** · 11/12/2020, 17h05

Le mot IA est d plus en plus utilisé à toutes les sauces.

On pourrait imaginer un programme qui jouerait contre toi. A chaque partie, ce programme mémoriserait plein d'informations, et il modifierait sa stratégie, pour s'adapter à ta stratégie. Par exemple, dans un autre jeu, le jeu de bataille navale, si tu poses souvent tes bateaux en haut de la grille, il va s'en rendre compte, et il va lancer ses boulets de canons vers le haut de la grille.

Dans un cas comme ça, on peut parler d'IA : l'ordinateur apprend, et il joue de mieux en mieux, partie après partie. C'était le strict minimum pour qu'on parle d'IA il y a 10 ans.
Aujourd'hui, le terme d'IA ne veut à peu près plus rien dire. Dès qu'un humain joue contre un ordinateur, on parle d'IA.

**Ploplopa** · 11/12/2020, 17h35

Envoyé par tbc92

Le mot IA est d plus en plus utilisé à toutes les sauces.

On pourrait imaginer un programme qui jouerait contre toi. A chaque partie, ce programme mémoriserait plein d'informations, et il modifierait sa stratégie, pour s'adapter à ta stratégie. Par exemple, dans un autre jeu, le jeu de bataille navale, si tu poses souvent tes bateaux en haut de la grille, il va s'en rendre compte, et il va lancer ses boulets de canons vers le haut de la grille.

Dans un cas comme ça, on peut parler d'IA : l'ordinateur apprend, et il joue de mieux en mieux, partie après partie. C'était le strict minimum pour qu'on parle d'IA il y a 10 ans.
Aujourd'hui, le terme d'IA ne veut à peu près plus rien dire. Dès qu'un humain joue contre un ordinateur, on parle d'IA.

Dans ce cas la il n'y n'apprend mais mon professeur voudrait dans l'idéal que l'adverse réagit à ses tires précédents sauf que je ne sais pas encore le faire ^^

Jeu de tir à canon contre une IA

Algorithmes et structures de données

Discussions similaires

Partager

Partager