Modalités de rendu
==================

 Groupe de News:		epita.comp.java et epita.cours.modelisation
 Sujet de mail Yaka	[JAVA][GENERAL]
 Date de rendu:		jeudi 17 Juillet 2003 - 20:42:00
 Nom de l'exécutable:	general.jar
 Nom de la tarball:	login-general.tar.bz2
 Rendu:			Par Upload (cf Infos->Modalités->Rendus du
 			site yaka)
 Modalités:		Ce projet est à faire par groupe de 4
 Compilateur:           	j2sdk de NetBSD 1.3, fournit sur le compte des
 			yakas.
 Tools:			Tout ce qui sera nécessaire, sous réserve
 			d'acceptation des yakas. Des news apporteront
 			des éléments de réponse.
 Version du sujet:	1.05


 Les informations ci-dessus peuvent changer jusqu'au 20/06/2003 20h42.

 Introduction
 ============

 Bonjour jeune officier. Bienvenue au quartier général de CHUDA. En ce
 l'an 2040, de l’âge fantaisiste, notre situation est critique.

 Notre simulateur de stratégie a été détruit par des hackers. Nous
 avons besoin de vous : promotion 2005, afin de nous recoder notre
 système de simulation de défense au plus vite.

 Il ne nous reste pas beaucoup de temps avant une attaque ennemie,
 alors bonne chance et faites de votre mieux.

 Sujet
 =====

 Ce projet a pour but d'éprouver vos connaissances Java,
 algorithmiques, ainsi que votre capacité à utiliser votre matière
 grise dans le contexte d'un jeu de strategie sur plateau.

 En effet, nous vous demandons de placer les armées au mieux pour le
 premier tour d'attaque, et uniquement ce premier tour. Car rappelons
 le, la guerre se déroulera au tour par tour. Pour calculer votre
 placement, vous connaîtrez :

 	* la provenance de l'attaque,
 	* le nombre et le type d'armée que vous possédez.
 	* Et enfin la carte (et oui ça aide...)

 A partir de ces données, vous devrez attendre l'attaque de l'armée
 adverse. Sans satellite, c'est difficile de surveiller une
 progression :). ON vous demande de tenir. L'armée arrivera quelques
 tours après. Si vous tenez, la victoire sera notre. Vous n'aurez donc
 que les garnisons des objectif à défendre et bien sur votre grand
 sens de stratège. A partir su stage 3, vous aurez droit aux tours de
 préparation à la guerre.  Grâce à l'excellence de nos services
 secrets vous disposerez de quelques tours pour préparer et emmener
 vos unités vers les points stratégiques aisément défendables et
 permettant d'infliger un maximum de dégâts. Même s'il en va de la vie
 de l'unité, vous devez tenir !

 Afin de tester vos aptitudes professionnelles, cet exercice
 nécessitera un travail en équipe organisée, dont un rendu
 intermédiaire du suivi du projet permettra de déterminer si votre
 simulateur a été développé dans de bonnes conditions. La gestion du
 projet est à votre entière charge et décision. Toutefois, si nous ne
 possédons pas des documents tel qu'un diagramme de classe (et ce
 n'est pas suffisant mais nécessaire), votre notation en sera très
 fortement ressentie (proche de 0). Vous devrez expliciter la
 construction et la mise en oeuvre de votre programme, le choix des
 algorithmes, leur implémentation, etc...

 rendu intermédiaire
 ------------------

 Date:	Le mardi 1 Juillet à 20h42

 Ces documents devront être uploadés sur le site yaka via une tarball
 comprenant:

 - AUTHORS !! CHANGEMENT - Cela respecte la CSS de P1
 * login		(Prénom Nom	)

 - doc/ Répertoire contenant vos documents (format pdf ou doc) de
  gestion de projet.

 Un rendu papier devra aussi être effectué au labo YAKA pour la même date.

 Exécution du Programme
 ======================

 Votre programme sera appelé de la manière suivante :

 acide@alpha>java -jar general.jar carte.xml param.xml -sXX -tYY -dZZ -rKK

 Ou :
 	* XX est le niveau de calcul demandé.
 	* YY est le nombre de tours de préparation avant l'attaque
 	  (stage >= 3)
 	* ZZ est la provenance de l'armée ennemie (NN => nord,
 	  NE => nord est, EE ==> est, SE => sud est, SS => sud,
 	  SW => sud ouest, WW => ouest, NW => nord west
	* KK est le ratio représentant la force de votre ennemie par
	  rapport à la votre

 Si le niveau correspond au stage 1,alors XX devient 01.

 D'où la commande :

 acide@alpha>java -jar general.jar carte.xml -s01 -dWW -r01

 Si aucun paramètre de niveau n’est spécifié le plus haut de votre
 simulateur sera pris en compte.  Le paramètre de direction devra
 toujours être fourni.


 Le format de la carte XML
 =========================

 Celui-ci est donné à titre d'exemple. Pensez à faire les vôtres !!

 => Des exemples de carte ne tarderont pas à être inclus dans cette
 section.

 La DTD
 ======

 general.dtd : Il s'agit de celle que vous devez utiliser.

 target : point stratégique à défendre.
 army : (stage >= 3) arméé initialement à cet endroit.

 Modificateur (tableau 1)
 ------------------------

                 Cout
               Mouvement      Defenseur

 plaine             1

 foret              2             +1

 montagne           4             +2

 mer           impossible     pas combat



 Le format de army.txt
 ======================

 Voici un exemple du fichier paramètre de votre armée. Chaque section
 décrit le nombre dont vous en disposez, sa capacité de mouvement, sa
 puissance de résistance/feu et sa portée d’attaque. Lors d'un combat
 (je vous rappelle que vous ne devez pas les gérer) si la puissance de
 feu de l'attaquant est supérieur à celle du défenseur, alors c'est la
 mort du défenseur. Il n'y a donc pas de hasard.


 [CAVALRY]
 cavalryMove=4
 cavalryPower=3
 cavalryRange=1

 [SwordMan]
 SwordManMove=1
 SwordManPower=2
 SwordManRange=1

 [Angel]
 AngelMove=5
 AngelPower=1
 AngelRange=1

 [DATA]
 AngelNumber=6
 SwordManNumber=10
 CavalryNumber=5


 Vous l'aurez deviné les anges ont la capacité de s'affranchir des
 obstacles de terrain (stage >= 3).

 Stage
 ======

 Généralités :

 * Aucune attaque ne peut provenir de la mer, d'un lac, etc. excepté
   si c'est un ange qui attaque
 * Pour chaque niveau, les stages antérieurs s’appliquent.
 * Le temps de calcul maximal est de 30 secondes.

 * On ne passe au stage suivant que si le précédent est totalement
   terminé.

 * Il faut défendre le mieux possible un ou des objectifs (cf
   description de la carte)

 * Il est interdit d'empiler plusieurs armées sur le même hexagone.

 Stage 1 :	Newbie
 =========

 Le but de ce niveau est de réussir à placer selon la direction
 d'attaque les armées, en s'affranchissant des valeurs de terrain
 (toutes les cartes ne sont que des plaines), et vous ne disposerez
 que de l'infanterie. L'ennemie vous attaquera aussi qu'avec de
 l'infanterie.

 Vous ne devez défendre qu'un seul objectif.

 Enfin vous pouvez placer vos unités en 1 seul tour, sans contraintes
 de déplacement (considérez vos armées comme parachutables
 instantanément sur la carte).

 Stage 2 :	Rookie
 =========

 Même chose, sauf que les contraintes de terrain rentrent en
 compte. Vous pouvez toujours "parachuter" vos armées, mais vous devez
 utiliser le terrain comme avantage naturel.

 Vous disposerez de cavalerie et d'infanterie tout comme votre
 ennemie. Les modificateur de déplacement et de combat entre en
 compte. (cf: tableau 1 ci-dessus)

 Stage 3 :	Aspirant
 =========

 Ce niveau commence à prendre en compte mes tours de préparation avant
 la bataille.

 Vos armées partent des objectifs à défendre, relativement plus
 logique, puisqu'il s'agit de garnison de défense. Il faut recalculer
 les meilleurs postes et positions de défense atteignables en fonction
 du nombre de tours autorisés.

 L'adversaire placera ces unités après les votres.

 Stage 4 :	Captain
 =========

 Vos objectifs de défense sont multiples. Vu votre rang, le choix de
 la répartition initiale des armées vous appartient.

 Les anges entrent en compte comme éléments possibles de votre armée
 et celle de votre adversaire.

 Stage 5 :	Lieutenant
 =========

 Une infanterie se stabilisant plus de 2 tours au même endroit gagne +2
 en puissance, car elle a le temps d’étudier au mieux le terrain pour se
 défendre.

 Une infanterie stabilisée plus de 3 tours sur une montagne, créé un
 poste de défense lui donnant une portée d'attaque de maximale 3
 hexagones autour de l'infanterie. Car l'infanterie a le temps
 d’installer l’artillerie.

 Stage 6 :	Commandant
 =========

 * Dans les plaines, une cavalerie gagne 1 point puissance contre
   l’infanterie, mais perd 1 point de puissance contre les anges.

 * Les espions vous donnent le placement des unités adverses
   (modifications de la DTD), et vous devez infliger un maximum de
   dégâts les premiers tours de contact avec l’armée adverse. Cela va
   nécessiter de calculer des déplacements possibles de l’armée
   adverse dans les premiers tours jusqu’au contact, et de vérifier
   que leurs déplacements ne tombent pas sur votre unité ==> attaque
   en X déplacements au lieu de X + 1.

 La dtd sera écrite ici ultérieurement

 Stage 7 :	Général
 =========

 Vous devez offrir plusieurs solutions possibles et percutantes, afin
 de prévoir plusieurs plans de bataille. Car les services secrets ne
 sont pas toujours très exacts...

 ==> Un affichage graphique par plan de bataille est requis.

 Stage 8 :	Arès
 =========

 Tout ce à quoi nous n'avons pas pensé et que vous aurez fait.

 Sortie numérique du programme
 =============================

 Un affichage graphique est demandé. Cet affichage est réalisable en
 C/C++ ou Java, et doit montrer le placement des armées pour les
 stages < 3, et leur progression lors de l’appui sur la touche entrée,
 ainsi que les déplacements antérieurs lors de l’appui sur la touche
 backspace. La touche echap fermant l’affichage graphique.

 Dans le cas d’un affichage réalisé en C/C++, il est demandé de ne pas
 faire un appel à un binaire externe à l’aide de Java mais de
 l’intégrer au projet à l’aide de JNI.  Le projet devra être
 compilable à l’école sur les NetBSD, et fournir les sources dans la
 tarball de rendu.

 Pas d’affichage graphique implique 0 à la partie code.

 Note divers
 ===========

 * On ne peut pas capitaliser des points de déplacement. A la fin d'un
   tour, les point de déplacement sont mis à 0, pour tout le monde.
 * Chaque emplacement de la carte a une représentation hexagonale,
   qu'il conviendra de préserver tant au niveau traitement que
   graphique.


 La tarball de rendu
 ===================

 La tarball de rendu devra contenir obligatoirement les fichiers
 suivants et sous cette forme:

 - AUTHORS !! CHANGEMENT - Cela respecte la CSS de P1
 * login		(Prénom Nom	)

 - LINKS
  Contient :
 "http://mon.site.web.interressant/
 Titre Auteur
 (Attention ne mettez pas de # dans les différentes descriptions)

 - README
 Les fonctionnalités du logiciel, algo, etc..

 - TODO
  Contient La liste des choses qu'il reste à faire (ce n'est pas
  forcément vide...)

 - Makefile Contient :
   - une règle "doc" qui permet de créer les docs via javadoc et les
     range dans le répertoire doc/;
   - une règle "jar" qui compile les sources et créé le jar;
   - une règle "run" qui permet de lancer le programme
   - une règle "clean" qui permet de faire ce que l'on attend elle.
   - une règle "test" qui permet de lancer vos tests de développement.

 - STAGE
 Contiendra juste un nombre avec un retour à la ligne indiquant le
 niveau le plus élevé que vous avez programmé.


 Elle devra également contenir les répertoires suivants:

 - src/
  Répertoire contenant vos sources.

 - classes/
  Répertoire de génération des classes.

 - doc/
  Répertoire contenant vos documents de projet générés via javadoc.

 - uml/
  Répertoire contenant votre modélisation

 La tarball de rendu doit être nettoyée (i-e le sous-répertoire javadoc
 vide, documentation supplémentaire à faire, aucun fichier class et pas
 d'archive jar).