Université de Sherbrooke, développement du jeu vidéo, COA

Vous trouverez ici quelques documents et quelques liens pouvant, je l'espère, vous être utiles.

	Plan de cours (à venir incessamment)
	Document d'accompagnement au plan de cours

À propos des séances en classe

Les quelques sections qui suivent réfèrent à ce que nous avons fait (ou allons faire) en classe cette session.

#include <iostream>
#include <random>
using namespace std;

class GenStochastique {
   mt19937 prng;
   GenStochastique() : prng{ random_device{}() } {
   }
public:
   using value_type = int;
   GenStochastique(const GenStochastique &) = delete;
   GenStochastique& operator=(const GenStochastique &) = delete;
   static GenStochastique &get() {
      static GenStochastique singleton; // définition (singleton Meyers)
      return singleton;
   }
   value_type prochain() {
      return uniform_int_distribution<value_type>{ 1, 100 }(prng);
   }
   // précondition : min <= max
   value_type prochain(value_type min, value_type max) {
      return uniform_int_distribution<value_type>{ min, max }(prng);
   }
};

int main() {
   auto & gen = GenStochastique::get();
   for (int i = 0; i != 10; ++i)
      cout << gen.prochain(1,6) << ' ';
}

// ...
class Objet3D {
   // ...
public:
   virtual void draw(IDirect3DDevice9 *device) = 0;
   virtual ~Objet3D() = default;
   // ...
};
class Dessiner {
   IDirect3DDevice9 *dev;
public:
   Dessiner(IDirect3DDevice9 *dev) : dev{ dev } {
   }
   void operator()(const Object3D *p) const {
      p->draw(dev);
   }
};
#include <vector>
#include <algorithm>
int main() {
   using namespace std;
   vector<Object3D*> v;
   IDirect3DDevice9 *device = ...
   //
   // remplir v...
   //
   // Tout afficher avec un foncteur (exemple)
   //
   for_each(begin(v), end(v), Dessiner{ device });
   // Tout libérer avec une λ (exemple)
   for_each(begin(v), end(v), [](Objet3D* p) {
      delete p;
   });
   // ... dans un cas comme celui-ci, on peut faire plus simple encore ;)
   for(auto p : v)
      delete p;
}

class Monstre {
   // ...
public:
   bool est_mort() const;
   // ...
   virtual ~Monstre();
};

vector<Monstre*> filtrer_morts(vector<Monstre*> v) {
   // [begin(v),p) est une séquence de non-morts, [p,end(v)) est une séquence de morts
   auto p = partition(begin(v), end(v), [](const Monstre *p) { return !p->est_mort(); });
   for_each(p, end(v), [](const Monstre *p) { delete p; }); // destruction des morts
   v.erase(p, end(v)); // élimination des éléments détruits
   return v;
}

vector<Monstre*> filtrer_morts(vector<Monstre*> v) {
   auto p = partition(begin(v), end(v), [](const Monstre *p) { return !p->est_mort(); });
   for_each(p, end(v), [](const Monstre *p) { delete p; }); // destruction des morts
   return { begin(v), p }; // on retourne ceux qui restent
}

Code des cas sous étude dans les notes de cours

Ce qui suit vous est gracieusement offert dans le but de vous épargner une recopie pénible d'exemples et de tests proposés dans les notes de cours.

Exercice à faire suite à la séance S00

L'exercice proposé est celui de la construction d'un petit jeu de devinette

Exercice à faire suite à la séance S01

L'exercice proposé est celui de la construction d'un petit jeu de Mastermind

Consignes des travaux pratiques

Les consignes des travaux pratiques en lien avec le cours sont ci-dessous.

Consignes propres aux deux travaux pratiques

De manière générale :

• Les travaux pratiques à faire vous sont donnés dès le début de la session, et vous avez accès à des éditeurs de texte munis de correcteurs orthographiques et grammaticaux. Soyez gentilles et gentils, et faites une vérification linguistique de vos documents avant remise s.v.p. Cela me permettra de me concentrer sur le fond plutôt que sur la forme quand je lirai le tout
• Remettez vos documents par courriel sur mon adresse @USherbrooke.ca.
• Donnez-moi suffisamment de contexte pour vous comprendre.
• Prenez soin de donner un nom significatif à votre document, pour éviter une accumulation de documents portant le même nom dans ma boîte de courriel. Ainsi :
  • S'il s'avère que votre nom soit Gaëtan Tromblon et que vous remettiez le TP00 sur une base individuelle, par exemple, préférez un document nommé TP00-TromblonGaetan à un autre nommé TP00 tout court.
  • S'il s'avère que votre équipe se nomme Les Snorros et que vous remettiez le TP01 sur la base d'un document pour l'équipe entière, par exemple, préférez TP01-Snorros à TP01 tout court.

Consignes du TP00

Date de remise : début de la séance S06.

Ce travail s'intègre aux travaux pratiques de vos autres cours de la session, et est à faire sur une base individuelle. Réfléchissez à l'application pertinente et justifiée par vous-même dans l'un ou l'autre de ces travaux pratiques :

• D'au moins un algorithme standard, qu'il s'agisse d'une fonction trouvée dans <algorithm>, d'une fonction trouvée dans <numeric> ou d'un équivalent « maison » (dans le doute, consultez votre chic prof!)
• D'au moins un foncteur ou une λ (avec contexte pertinent pour son application)
• D'au moins un schéma de conception mis en application dans l'un ou l'autre de vos travaux pratiques, par vous ou par vos collègues, incluant une brève explication de ce qu'est ce schéma de conception et de son rôle dans le travail pratique en question

Notez que ce que vous proposerez doit se distinguer des exemples proposés par votre chic prof. Présentez chaque application en la mettant en contexte et en décrivant son fonctionnement, code à l'appui. Montrez clairement les éléments que vous intégrez à vos projets, et mettez en valeur la pertinence de vos choix. Le but de ce travail est de vous aider à progresser dans votre développement, pas de vous nuire.

int trouver_plus_pres_de(Point pt, vector<Point> candidats) {
   if (candidats.size() == 0) return -1; // personne
   int reponse = 0; // optimiste
   double plus_proche_dist = numeric_limits<double>::max(); // loin!
   for(int i = 0; i < candidats.size(); ++i) {
      if (pt != candidats[i] && pt - candidats[i] < plus_proche_dist) {
         reponse = i;
         plus_proche_dist = pt - candidats[i];
      }
   }
   return reponse;
}

Si candidats est vide
    Retourner -1 // cas dénégéré
plus_proche ← trouver premier autre que pt dans candidats
Si plus_proche = pt
   Retourner 0 // seul au monde
distance_plus_proche ← *plus_proche - pt
Tant que je n'ai pas épuisé les Points candidats
   plus_proche ← trouver plus proche que plus_proche
   distance_plus_proche ← *plus_proche - pt
Retourner distance(debut(candidats), plus_proche)

int trouver_plus_pres_de(const Point &pt, const vector<Point> &candidats) {
   if (candidats.empty()) return -1; // cas dégénéré
   auto plus_proche = find_if_not(next(begin(candidats)), end(candidats), pt);
   if (plus_proche == end(candidats)) return 0; // seul au monde
   auto distance_plus_proche = *plus_proche - pt;
   for(plus_proche = find_if(plus_proche, end(candidats), [&](const Point &p) { return p != pt && pt - p < distance_plus_proche; });
       plus_proche != end(candidats);
       plus_proche = find_if(plus_proche, end(candidats), [&](const Point &p) { return p != pt && pt - p < distance_plus_proche; }))
      distance_plus_proche = *plus_proche - pt
   return distance(begin(candidats), plus_proche);
}

int trouver_plus_pres_de(const Point &pt, const vector<Point> &candidats) {
   if (candidats.empty()) return -1; // cas dégénéré
   auto plus_proche = find_if_not(next(begin(candidats)), end(candidats), pt);
   if (plus_proche == end(candidats)) return 0; // seul au monde
   auto distance_plus_proche = *plus_proche - pt;
   auto pred = [&](const Point &p) { return p != pt && pt - p < distance_plus_proche; };
   for(plus_proche = find_if(plus_proche, end(candidats), pred);
       plus_proche != end(candidats);
       plus_proche = find_if(plus_proche, end(candidats), pred))
      distance_plus_proche = *plus_proche - pt
   return distance(begin(candidats), plus_proche);
}

double plus_courte_distance_de(const Point &pt, const vector<Point> &candidats) {
   if (candidats.empty()) return -1.0; // cas dégénéré
   auto cur = find_if_not(begin(candidats), end(candidats), [&pt](const Point &p) { return p != pt; });
   if (cur == end(candidats)) return 0.0; // seul au monde
   return accumulate(next(cur), end(candidats), *cur - pt, [&pt](double so_far, const Point &p) {
      return pt == p? so_far : std::min(so_far, pt - p);
   });
}

Consignes du TP01

Date de remise : début de la séance S12 (en fait, quand vous aurez fini votre projet, car c'est la priorité)

Il se fait tard, vous souhaitez produire et conclure votre session, et je souhaite pouvoir savoir où vous en êtes sans toutefois vous surcharger. Voici ce que je vous propose :

• Nous faisons tous de bons et de mauvais coups en développant. Personne n'est parfait
• Je veux un document de quatre pages par personne (c'est tout petit!). Votre nom et le nom de votre équipe doit apparaître sur chaque page (je veux donner les points à la bonne personne!)
• Voici ce que doit contenir ce document :
  • Page 0 : une brève description de votre plus grande réussite technique, code ou schéma à l'appui, avec explication succincte de ce qui vous en rend si fière ou si fier
  • Page 1 : une brève description de votre choix technique le moins... heureux, code ou schéma à l'appui, avec explication succincte de ce qui vous fait poser ce jugement... et une réflexion sur ce qu'il aurait été possible de faire pour mieux faire, justement
  • Page 2 : une brève description de la plus grande réussite technique de votre équipe qui ne soit pas de votre cru, à votre avis, code ou schéma à l'appui, avec explication succincte de ce qui vous en rend si fière ou si fier
  • Page 3 : une brève description du choix technique le moins... heureux de votre équipe et qui ne soit pas de votre faute, code ou schéma à l'appui, avec explication succincte de ce qui vous fait poser ce jugement. Attention : on veut un regard technique, et personne n'est parfait, mais on ne veut pas une critique personnelle ou humaine. On veut aussi savoir ce qu'il aurait été préférable de faire
• Dans les quatre cas, je dois avoir suffisamment de contexte et de code pour comprendre ce que vous m'expliquez, alors il faut trouver le moyen d'être à la fois clair(e) et succinct(e)

L'idée est de produire une très brève autocritique de contribution individuelle et de design global qui puisse servir de rampe de lancement au projet de cet hiver. Autocritique ne signifie pas autoflagellation : personne n'est parfait et l'école est un lieu d'apprentissage.