Tutorials - AI examples

[Defensive - Easy] Shield activation

WARNING: this video is obsolete and uses deprecated API. The source code to use is pasted after the video.

An AI example with Eclipse: shield activation

You need a flash plugin to be able to see this tutorial.
view sourceprint?
01.package foo.me.ai;
02. 
03.import galaxiia.jeu.intelligence.Intelligence;
04.import galaxiia.jeu.terrain.InformateurTerrain;
05.import galaxiia.jeu.unite.ControleurUnite;
06.import galaxiia.jeu.unite.InformateurUnite;
07. 
08.public class Test2 implements Intelligence {
09. 
10.    public void initialisation(InformateurUnite unite, InformateurTerrain terrain) {
11.        // Nothing to initialize
12.    }
13. 
14.    public void nouveauTour(ControleurUnite unite, InformateurTerrain terrain) {
15.        // The shield is activated at each turn.
16.        unite.activationBouclier();
17.    }
18.}

[Neutral - Easy] Moving a spaceship

[Agressive - Normal] Burst of "fox missiles"

view sourceprint?
001./**
002. * Les packages permettent de ranger les fichiers de vos programme.
003. *
004. * Ici pour que ce programme compile, il faut que ce fichier soit situé dans un
005. * pakage nommé votrenom. Pour ajouter un package sur Eclipse, il suffit de
006. * faire Fichier -> Nouveau -> Package.
007. */
008. 
009.package foo.me.ai;
010. 
011.import galaxiia.configuration.Identification;
012.import galaxiia.jeu.intelligence.Intelligence;
013.import galaxiia.jeu.terrain.InformateurTerrain;
014.import galaxiia.jeu.unite.ClasseurUnite;
015.import galaxiia.jeu.unite.ConstantesUnite;
016.import galaxiia.jeu.unite.ControleurUnite;
017.import galaxiia.jeu.unite.InformateurUnite;
018. 
019.@Identification(nom = "Fox burst", auteur = "2CIA", version = 1)
020.public class FoxBurst implements Intelligence {
021. 
022.    /*
023.     * Définition des constantes.
024.     */
025. 
026.    /**
027.     * Le nombre de missiles dans une rafale de fox.
028.     */
029.    private static final int NOMBRE_MISSILE_RAFALE = 12;
030. 
031.    /**
032.     * Récupération du coût énergétique de lancement d'un missile fox.
033.     */
034.    private static final double COUT_ENERGETIQUE_LANCEMENT_FOX = ClasseurUnite
035.            .creationUniteAbstraite(ConstantesUnite.MISSILE_FOX)
036.            .coutEnergetiqueCreation();
037. 
038.    /*
039.     * Définition des variables globales.
040.     */
041. 
042.    /**
043.     * Si cette variable vaut <code>true</code>, c'est que l'unité est en train de
044.     * lancer une rafale de fox.
045.     */
046.    private boolean lancementRafaleEnCours;
047. 
048.    /**
049.     * Le nombre de missile déjà lancés pour la rafale en cours.
050.     */
051.    private int nombreMissilesLances;
052. 
053.    /**
054.     * L'unite ciblée par la rafale en cours.
055.     */
056.    private InformateurUnite uniteCible;
057. 
058.    /**
059.     * L'initialisation de l'intelligence.
060.     */
061.    public void initialisation(InformateurUnite unite, InformateurTerrain terrain) {
062.        if (!unite.peutCreer(ClasseurUnite.MISSILE_FOX)) {
063.            // Si notre unité ne peut pas lancer de missile fox on refuse le combat et
064.            // on abandonne.
065.            throw new IllegalStateException("Notre unité ne peut pas lancer de fox.");
066.        } else {
067.            // Sinon, on initialise les variables.
068.            lancementRafaleEnCours = false;
069.            nombreMissilesLances = 0;
070.            uniteCible = null;
071.        }
072.    }
073. 
074.    /**
075.     * Continue de lancer la raffale de fox.
076.     *
077.     * @param monUnite
078.     *          L'unité que l'on contrôle.
079.     */
080.    public void lancementRafale(ControleurUnite monUnite) {
081. 
082.        // On tire le missile.
083.        monUnite.lancementProjectileVersPoint(ControleurUnite.MISSILE_FOX,
084.                pointCible(uniteCible));
085. 
086.        // On ajoute un au nombre de missiles lancés.
087.        nombreMissilesLances++;
088.        if (nombreMissilesLances == NOMBRE_MISSILE_RAFALE) {
089.            // Si on a lancé le bon nombre de missiles, on réinitiale les variables.
090.            lancementRafaleEnCours = false;
091.            nombreMissilesLances = 0;
092.            uniteCible = null;
093.        }
094.    }
095. 
096.    /**
097.     * Donne une unité cible.
098.     *
099.     * @param monUnite
100.     *          L'unité que l'on contrôle.
101.     * @param terrain
102.     *          Le terrain sur lequel on joue.
103.     *
104.     * @return L'unité cible ou null si aucune unité ne peut être une cible.
105.     */
106. 
107.    public InformateurUnite uniteCible(InformateurUnite monUnite,
108.            InformateurTerrain terrain) {
109. 
110.        // On parcourt toutes les unités du terrain.
111.        for (InformateurUnite unite : terrain.tableauUnites()) {
112.            if ((unite.equipe() != monUnite.equipe())
113.                    && (unite.equipe() != ConstantesUnite.EQUIPE_MISSILE)) {
114. 
115.                // Si l'unité n'est ni de mon équipe, ni un missile, on choisie cette
116.                // unité.
117.                return unite;
118. 
119.            }
120. 
121.        }
122. 
123.        // On a pas trouvé d'unité ennemi. On retourne null.
124.        return null;
125. 
126.    }
127. 
128.    /**
129.     * Donne le point vers lequel il faut lancer le missile pour toucher l'unité.
130.     *
131.     * @param uniteCible
132.     *          L'unite cible.
133.     *
134.     * @return Le point où il faut lancer le missile pour toucher la cible.
135.     */
136. 
137.    public double[] pointCible(InformateurUnite uniteCible) {
138.        // On donne la position de l'unité cible.
139.        return uniteCible.position();
140.    }
141. 
142.    /**
143.     * Les choix de l'intelligence.
144.     */
145.    public void nouveauTour(ControleurUnite monUnite, InformateurTerrain terrain) {
146.        if (lancementRafaleEnCours) {
147.            // Si notre unite est en train de tirer une rafale, on continue.
148.            lancementRafale(monUnite);
149.        } else {
150.            if (COUT_ENERGETIQUE_LANCEMENT_FOX * NOMBRE_MISSILE_RAFALE <= monUnite
151.                    .energie()) {
152.                // Si notre unite à suffisamment d'énergie pour lancer tous les missiles
153.                // fox à la suite.
154. 
155.                // Recherche d'un cible potentielle.
156.                uniteCible = uniteCible(monUnite, terrain);
157.                if (uniteCible != null) {
158.                    // Si on a bien une cible, on commence à lancer la rafale de fox.
159.                    lancementRafaleEnCours = true;
160.                    lancementRafale(monUnite);
161.                } else {
162.                    // Sinon on ne fait rien, on a pas de cible.
163.                }
164.            } else {
165.                // Si notre unite n'a pas suffisamment d'énergie, on attent un tour de
166.                // plus (on fait rien).
167.            }
168.        }
169.    }
170.}