Gameforge

Générateur de concepts de jeux vidéo alimenté par l'IA

Gameforge est une plateforme web innovante qui utilise l'intelligence artificielle (Mistral AI pour le texte, FLUX.1-schnell pour les images) pour générer automatiquement des concepts complets de jeux vidéo, incluant l'univers, le scénario, les personnages, les lieux et même des concept arts.

Présentation du projet

Contexte

Gameforge est né d'une volonté de démocratiser la création de concepts de jeux vidéo en utilisant l'intelligence artificielle. L'objectif est de permettre à n'importe qui (game designers, développeurs indépendants, passionnés) de générer rapidement des idées de jeux complètes et cohérentes.

Objectifs

Générer automatiquement des concepts de jeux vidéo complets
Utiliser plusieurs modèles d'IA (Mistral AI pour le texte, tentatives avec Hugging Face)
Créer une interface web intuitive et responsive
Gérer une communauté d'utilisateurs avec système de favoris
Limiter les abus avec un système de quotas quotidiens

Fonctionnement général

L'utilisateur choisit des paramètres (genre, ambiance, mots-clés)
Le backend appelle l'API Mistral AI via le service ai_service.py
L'IA génère séquentiellement :
- Un titre accrocheur
- Un univers détaillé
- Un scénario en 3 actes
- 3 personnages principaux
- 4 lieux emblématiques
- (Optionnel) Une image de concept art
Les données sont sauvegardées dans la base de données SQLite
L'utilisateur peut consulter, partager et liker les créations

Fonctionnalités

Génération IA Complète

Titre du jeu : Génération créative basée sur le genre et l'ambiance
Univers : Description détaillée avec style graphique (réaliste, cartoon, pixel art, anime, low poly) et type de monde (open world, linéaire, hub, arène)
Scénario en 3 actes : Structure narrative complète (introduction, développement, climax) avec twist optionnel
Personnages : 3 personnages détaillés avec :
- Nom et classe (guerrier, mage, voleur, archer, healer, tank, support)
- Rôle (héros, antagoniste, allié, mentor, neutre)
- Background complet
- Description du gameplay
Lieux emblématiques : 4 locations uniques avec descriptions immersives
Concept Arts : Génération d'images via Mistral AI (fonctionnalité bêta)

Gestion Utilisateur

Système d'authentification complet (inscription/connexion/déconnexion)
Tableau de bord personnel avec vue sur ses créations
Limite de générations quotidiennes personnalisable (5 par défaut)
Gestion de la visibilité (jeux publics/privés)
Interface d'administration Django pour les superutilisateurs

Fonctionnalités Sociales

Système de favoris/likes avec compteur
Exploration des créations de la communauté
Recherche avancée par titre, genre ou mots-clés
Page dédiée aux favoris
Partage de créations publiques

Génération Aléatoire

Bouton "Génération Aléatoire" pour générer un jeu avec paramètres aléatoires
Permet de découvrir des combinaisons inattendues
Code : Fonction create_random_game() dans views.py + generate_random_game_params() dans ai_service.py

Architecture & Flux de données

Structure du projet

Gameforge/
├── gameforge_project/          # Configuration Django principale
│   ├── settings.py            # Configuration (API keys, DB, middlewares)
│   ├── urls.py                # Routage principal
│   ├── wsgi.py                # Point d'entrée WSGI
│   └── asgi.py                # Point d'entrée ASGI
│
├── games/                      # Application principale
│   ├── models.py              # 8 modèles de données
│   ├── views.py               # 11 vues (home, register, login, dashboard, etc.)
│   ├── forms.py               # Formulaire de création de jeu
│   ├── ai_service.py          # Service d'intégration Mistral AI (554 lignes)
│   ├── urls.py                # Routes de l'application games
│   ├── admin.py               # Configuration interface admin
│   ├── apps.py                # Configuration de l'app
│   ├── templates/games/       # 9 templates HTML
│   │   ├── base.html          # Template de base
│   │   ├── home.html          # Page d'accueil
│   │   ├── register.html      # Inscription
│   │   ├── login.html         # Connexion
│   │   ├── dashboard.html     # Tableau de bord
│   │   ├── create_game.html   # Formulaire de création
│   │   ├── game_detail.html   # Détails d'un jeu
│   │   ├── favorites.html     # Page des favoris
│   │   └── confirm_delete.html # Confirmation de suppression
│   └── migrations/            # Migrations de base de données
│       ├── 0001_initial.py
│       ├── 0002_alter_generationlimit_max_daily.py
│       └── 0003_remove_generationlimit_max_daily_and_more.py
│
├── media/                      # Dossier pour les concept arts générés
│   └── concept_arts/
│
├── manage.py                   # CLI Django
├── requirements.txt            # Dépendances Python
└── .env                        # Variables d'environnement (non versionné)

Schéma du flux de données

┌─────────────────────────────────────────────────────────────────┐
│                        UTILISATEUR                              │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                   INTERFACE WEB (Templates HTML)                │
│  • Formulaire de création (genre, ambiance, mots-clés)          │
│  • Bouton "Surprise-moi !"                                      │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                    VIEWS.PY (Logique métier)                    │
│  • create_game() : Validation du formulaire                     │
│  • create_random_game() : Paramètres aléatoires                 │
│  • Vérification des limites quotidiennes                        │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│               AI_SERVICE.PY (Service d'IA)                      │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 1. generate_game_title(genre, ambiance, keywords)       │    │
│  │    → Génère le titre du jeu                             │    │
│  └─────────────────────────────────────────────────────────┘    │
│                            │                                    │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 2. generate_universe(titre, genre, ambiance)            │    │
│  │    → Génère description, style graphique, type monde    │    │
│  └─────────────────────────────────────────────────────────┘    │
│                            │                                    │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 3. generate_scenario(titre, universe, genre)            │    │
│  │    → Génère les 3 actes + twist                         │    │
│  └─────────────────────────────────────────────────────────┘    │
│                            │                                    │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 4. generate_characters(titre, genre, count=3)           │    │
│  │    → Génère 3 personnages avec backgrounds              │    │
│  └─────────────────────────────────────────────────────────┘    │
│                            │                                    │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 5. generate_locations(titre, universe, count=4)         │    │
│  │    → Génère 4 lieux emblématiques                       │    │
│  └─────────────────────────────────────────────────────────┘    │
│                            │                                    │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 6. generate_and_save_image(titre, genre, ambiance)      │    │
│  │    → Génère une image de concept art (optionnel)        │    │
│  └─────────────────────────────────────────────────────────┘    │
│                            │                                    │
│  Chaque appel contacte : MISTRAL AI API                         │
│  (mistral-small-latest pour texte, mistral-medium pour images)  │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                   MODELS.PY (Base de données)                   │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ Game (titre, genre, ambiance, mots_cles, createur)      │    │
│  │   ↓                                                     │    │
│  │ Universe (description, style_graphique, type_monde)     │    │
│  │   ↓                                                     │    │
│  │ Scenario (acte_1, acte_2, acte_3, twist)                │    │
│  │   ↓                                                     │    │
│  │ Character × 3 (nom, classe, role, background)           │    │
│  │   ↓                                                     │    │
│  │ Location × 4 (nom, description)                         │    │
│  │   ↓                                                     │    │
│  │ ConceptArt (image, description, type_art)               │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                 │
│  + Favorite (user ↔ game) pour les likes                        │
│  + GenerationLimit (compteur quotidien par user)                │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                    SQLite Database (db.sqlite3)                 │
│  Stockage persistant de toutes les données                      │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│              AFFICHAGE FINAL (game_detail.html)                 │
│  • Titre et métadonnées                                         │
│  • Description de l'univers                                     │
│  • Scénario complet                                             │
│  • Liste des personnages                                        │
│  • Liste des lieux                                              │
│  • Concept art (si généré)                                      │
│  • Bouton like/unlike                                           │
└─────────────────────────────────────────────────────────────────┘

Flux détaillé d'une génération

Requête utilisateur → POST vers /create-game/
Validation → Vérification des limites quotidiennes (5/jour par défaut)

Génération séquentielle :

titre = ai_service.generate_game_title(...)          
universe_data = ai_service.generate_universe(...)    
scenario_data = ai_service.generate_scenario(...)    
characters_data = ai_service.generate_characters(...) 
locations_data = ai_service.generate_locations(...)  
image_result = ai_service.generate_and_save_image(...)

Temps total : ~30-40 secondes avec image, ~20 secondes sans

Sauvegarde → Création des objets Django et relations en base
Redirection → Vers la page de détail du jeu créé
Incrémentation → Compteur de générations quotidiennes +1

Modèles de données

Diagramme de relations

┌─────────────────┐
│      User       │
│  (Django Auth)  │
└────────┬────────┘
         │
         │ 1:N
         │
    ┌────▼──────────────┐         ┌──────────────────┐
    │       Game        │◄────────│ GenerationLimit  │
    │                   │  1:1    │  (quotas)        │
    ├───────────────────┤         └──────────────────┘
    │ • titre           │
    │ • genre           │               1:1
    │ • ambiance        │         ┌──────▼───────────┐
    │ • mots_cles       │◄────────│    Universe      │
    │ • references      │         │                  │
    │ • est_public      │         │ • description    │
    │ • likes_count     │         │ • style_graphique│
    └───────┬───────────┘         │ • type_monde     │
            │                     └──────────────────┘
            │
            ├─────1:1────────►┌──────────────────┐
            │                 │    Scenario      │
            │                 │                  │
            │                 │ • acte_1         │
            │                 │ • acte_2         │
            │                 │ • acte_3         │
            │                 │ • twist          │
            │                 └──────────────────┘
            │
            ├─────1:N────────►┌──────────────────┐
            │                 │   Character      │
            │                 │                  │
            │                 │ • nom            │
            │                 │ • classe         │
            │                 │ • role           │
            │                 │ • background     │
            │                 │ • gameplay_desc  │
            │                 └──────────────────┘
            │
            ├─────1:N────────►┌──────────────────┐
            │                 │    Location      │
            │                 │                  │
            │                 │ • nom            │
            │                 │ • description    │
            │                 └──────────────────┘
            │
            ├─────1:N────────►┌──────────────────┐
            │                 │   ConceptArt     │
            │                 │                  │
            │                 │ • image          │
            │                 │ • description    │
            │                 │ • type_art       │
            │                 └──────────────────┘
            │
            └─────N:M────────►┌──────────────────┐
                 (via)        │    Favorite      │
                              │                  │
                              │ • user           │
                              │ • game           │
                              │ • date_added     │
                              └──────────────────┘

Description des modèles

Modèle	Type de relation	Champs principaux	Description
Game	Hub central	`titre`, `genre`, `ambiance`, `mots_cles`, `references`, `createur` (FK User), `est_public`, `likes_count`	Modèle principal représentant un jeu généré
Universe	OneToOne avec Game	`description`, `style_graphique`, `type_monde`	Décrit l'univers et l'esthétique du jeu
Scenario	OneToOne avec Game	`acte_1`, `acte_2`, `acte_3`, `twist`	Structure narrative en 3 actes + twist optionnel
Character	ForeignKey vers Game	`nom`, `classe`, `role`, `background`, `gameplay_description`	Personnages jouables ou PNJ importants (3 par jeu)
Location	ForeignKey vers Game	`nom`, `description`	Lieux emblématiques du jeu (4 par jeu)
ConceptArt	ForeignKey vers Game	`image` (ImageField), `description`, `type_art`	Images générées par l'IA (optionnel)
Favorite	ManyToMany User-Game	`user` (FK), `game` (FK), `date_added`	Système de likes/favoris
GenerationLimit	OneToOne avec User	`generations_today`, `daily_count`, `last_reset`	Gestion des quotas quotidiens (5 par défaut)

Choix de conception

OneToOne pour Universe et Scenario : Un jeu ne peut avoir qu'un seul univers et scénario
ForeignKey pour Characters et Locations : Permet d'avoir plusieurs éléments par jeu
ManyToMany pour Favorites : Un user peut liker plusieurs jeux, un jeu peut être liké par plusieurs users
ImageField pour ConceptArt : Utilise Pillow pour le stockage et la manipulation d'images

Installation

Prérequis

Python 3.10+ (développé avec Python 3.13)
pip (gestionnaire de paquets Python)
Git (pour cloner le dépôt)

1. Cloner le dépôt

git clone https://github.com/evadpe/Gameforge.git
cd Gameforge/Gameforge

2. Créer un environnement virtuel

Sur macOS/Linux :

python -m venv venv
# ou python3 -m venv venv
source venv/bin/activate

Sur Windows :

python -m venv venv
venv\Scripts\activate

3. Installer les dépendances

pip install -r requirements.txt

Dépendances installées :

Django==5.2.7 - Framework web
mistralai>=1.0.0 - SDK Mistral AI
python-dotenv==1.0.0 - Gestion des variables d'environnement
Pillow>=10.0.0 - Traitement d'images

4. Configuration des variables d'environnement

Créez un fichier .env à la racine du dossier Gameforge/ :

# API Keys
MISTRAL_API_KEY=votre_cle_api_mistral_ici
HUGGINGFACE_API_KEY=votre_cle_api_huggingface_ici

# Django Settings (optionnel)
DEBUG=True
SECRET_KEY=votre_secret_key_django

** Obtenir une clé Mistral AI :**

Créez un compte sur console.mistral.ai

Allez dans "API Keys"

Créez une nouvelle clé

Copiez-la dans votre fichier .env

** Obtenir une clé Hugging Face :**

Créez un compte sur huggingface.co

Allez dans Settings → Access Tokens

Créez un nouveau token (Read access suffit)

Copiez-le dans votre fichier .env

Note : La clé Hugging Face est utilisée pour générer les concept arts avec FLUX.1-schnell

5. Créer la base de données

# Créer les migrations
python manage.py makemigrations

# Appliquer les migrations
python manage.py migrate

Migrations appliquées :

0001_initial.py : Création des modèles initiaux
0002_alter_generationlimit_max_daily.py : Modification du champ max_daily
0003_remove_generationlimit_max_daily_and_more.py : Refactoring des limites

6. (Optionnel) Créer un super-utilisateur

Pour accéder à l'interface d'administration Django :

python manage.py createsuperuser

Renseignez :

Username (ex: admin)
Email (optionnel)
Password (2 fois)

7. Lancer le serveur de développement

python manage.py runserver

L'application sera accessible sur http://127.0.0.1:8000/

URLs importantes :

/ - Page d'accueil
/register/ - Inscription
/login/ - Connexion
/dashboard/ - Tableau de bord
/create-game/ - Créer un jeu
/admin/ - Interface d'administration (nécessite un superuser)

Technologies utilisées

Backend

Technologie	Version	Usage
Python	3.13	Langage principal
Django	5.2.7	Framework web MVC
SQLite	3.x	Base de données (incluse avec Python)
Mistral AI SDK	1.0+	Génération de texte et images
python-dotenv	1.0.0	Gestion des variables d'environnement
Pillow	10.0+	Traitement d'images (ImageField)

Frontend

Technologie	Usage
HTML5	Structure des pages
CSS3	Stylisation
Django Template Language	Moteur de templates
Bootstrap	Framework CSS responsive

Intelligence Artificielle

Modèles utilisés en production

Service	Modèle	Usage	Performance
Mistral AI	`mistral-small-latest`	Génération de texte (titre, univers, scénario, personnages, lieux)	Rapide, cohérent, français natif
Hugging Face	`black-forest-labs/FLUX.1-schnell`	Génération d'images (concept arts)	Rapide, qualité correcte via API Inference

Choix du modèle d'image :

FLUX.1-schnell (Black Forest Labs) choisi car :
- Modèle rapide optimisé pour l'inférence ("schnell" = rapide en allemand)
- API Hugging Face Inference gratuite et accessible
- Qualité d'image correcte pour des concept arts
- Temps de génération acceptable (~5-10 secondes)
- Pas besoin de télécharger le modèle localement

Code utilisé :

# ai_service.py
model_url = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
headers = {"Authorization": f"Bearer {HUGGINGFACE_API_KEY}"}

response = requests.post(model_url, headers=headers, json={
    "inputs": prompt  
})

if response.status_code == 200:
    image_bytes = response.content

Outils de développement

Git - Gestion de versions
GitHub - Hébergement du code
VS Code - Éditeurs de code

Screenshots

Page d'accueil

Page de Login

Page de signin

Tableau de bord utilisateur

Formulaire de création

Page de détail d'un jeu

Détail Image

Détail Univers

Détail Personnage

Détail Scénario

Détail Lieux

Page des favoris

Page suppression

Page des paramètres Profil

Barre de chargement

Bonus implémentés

Fonctionnalités bonus réalisées

Système de "favoris" ou "like" IMPLÉMENTÉ

Les utilisateurs peuvent liker/unliker des jeux
Compteur de likes en temps réel affiché sur chaque jeu
Page dédiée /favorites/ pour consulter tous ses jeux favoris
Relation ManyToMany avec modèle Favorite (table de liaison)
Système d'unicité (un user ne peut liker qu'une fois le même jeu)
Code :
- Modèle Favorite dans models.py
- Vue toggle_favorite() et favorites() dans views.py
- Affichage du bouton pour les favoris dans game_detail.html

Barre de recherche pour filtrer les jeux IMPLÉMENTÉ

Barre de recherche sur la page d'accueil
Filtres multi-critères : nom du jeu, genre, mots-clés
Recherche insensible à la casse (utilisation de __icontains)
Utilisation de Django Q objects pour requêtes complexes

Code :

# views.py - fonction home()
query = request.GET.get('q')
if query:
    games = games.filter(
        Q(titre__icontains=query) | 
        Q(genre__icontains=query) |
        Q(mots_cles__icontains=query)
    )

Pop-ups de chargement pendant la génération IMPLÉMENTÉ

Messages Django affichés à chaque étape de génération
Feedback utilisateur en temps réel :
- "Génération en cours..." (début)
- "Jeu créé avec succès!" (succès)
- "Erreur lors de la génération: ..." (échec)
Système de messages colorés (success, error, warning, info)

Code :

from django.contrib import messages
messages.success(request, f'Jeu "{titre}" créé avec succès!')
messages.error(request, f'Erreur lors de la génération: {str(e)}')

Export PDF IMPLÉMENTÉ

Objectif : Télécharger une fiche jeu auto-maquettée (style Steam/itch.io)
Permet l'export d'une maquette de la fiche du jeu qui contient :
- Les informations générales du jeu
- Son univers
- Son scénario complet
- Les Personnages
- Lieux emblématiques
- Concept Arts / Cover
Code :
Plusieurs fonctions pour l'outil d'export suivant les navigateurs.

Fonctionnalités bonus partiellement implémentées

GDD complet (Game Design Document) PARTIELLEMENT IMPLÉMENTÉ

Ce qui est généré :
- Titre du jeu
- Genre et ambiance
- Univers détaillé (description, style graphique, type de monde)
- Scénario en 3 actes + twist
- 3 personnages avec backgrounds et gameplay
- 4 lieux emblématiques
- (Optionnel) Concept art
Ce qui manque pour un GDD complet :
- Mécaniques de gameplay détaillées
- Système de progression
- Économie du jeu
- Arbre de compétences
- UI/UX mockups
- Feuille de route de développement

Fonctionnalités bonus non implémentées

Système de narration dynamique NON IMPLÉMENTÉ

Objectif : Le scénario devait pouvoir évoluer selon les choix de l'utilisateur
Pourquoi non fait :
- Nécessite un système de "jeu jouable" (pas juste un concept)
- Implique une logique de branches narratives complexes
- Aurait nécessité un moteur de choix interactif (type Twine/Ink)
- Temps de développement trop important

Ce qui aurait été nécessaire :

class Choice(models.Model):
    scenario = models.ForeignKey(Scenario)
    text = models.TextField()
    next_act = models.ForeignKey('self', null=True)

class PlayerProgress(models.Model):
    user = models.ForeignKey(User)
    game = models.ForeignKey(Game)
    current_choice = models.ForeignKey(Choice)

Page de paramètres de compte NON IMPLÉMENTÉ

Objectif : Permettre à l'utilisateur de modifier ses informations (email, mot de passe, préférences)
Pourquoi non fait :
- Manque de temps en fin de projet
- Fonctionnalité "nice to have" mais pas critique
- Django admin permet déjà ces modifications pour les superusers