Discussion :

[Neckara]

Bonjour,

Vous me connaissez peut-être déjà de part quelques projets sur ce forum.
Je suis en deuxième année d'ingénieur informatique et en première année d'un master Management Administration Entreprise sur deux ans après avoir obtenu un DUT Informatique.

Du fait de mes études, j'ai dû mettre en pause quelques uns de mes projets par manque de temps. Malheureusement, je ne peux plus contrôler mes pulsions. Certains de mes cours sont devenus de véritables supplices de Tantale, et je n'ai plus qu'une envie : me replonger dans le code.

Je reviens donc ici avec Last Engine, un projet de moteur de jeu modulaire que je reprendrais à partir du 5 février, dès que mes examens seront terminés. Je tiens à préciser que, par manque de temps, je vais me concentrer avant tout sur le code et beaucoup moins sur la communication. Cependant, je pense que je pourrais donner plus de nouvelles pendant les vacances scolaires ou pendant mes stages. Donc si vous souhaitez de plus amples informations, n'hésitez pas à poster ici.


Pourquoi Last Engine ?

Le but est d'avoir un "Kernel" minimaliste autours duquel se greffent dynamiquement des modules (simples fichiers .so/.dll).
Ceci permet de pouvoir remplacer un module par un autre très facilement, sans tout recompiler.
Certains modules peuvent aussi encapsuler des bibliothèques, ce qui permet de rendre l'application indépendante vis à vis de ces dernières. Donc plus de craintes que demain :

• ma bibliothèque n'est plus maintenue ;
• ma bibliothèque ne peut pas être utilisée sur une plateforme donnée.

Le fait que les modules soient interchangeable force à programmer proprement en ayant un couplage minimal entre les modules. Couplage qui devient très souvent de plus en plus important au fur et à mesure que le projet avance.
Ceci permet aussi de faciliter la réutilisation de code au maximum.

Il est aussi prévu un gestionnaire de mise à jour des modules, d'ajouter des "plugins".

Bref, ce moteur force l'utilisation de la POC (programmation orienté components).

Mais tout ceci n'existe-t-il pas déjà ?

Ceci existe très certainement déjà et je n'ai pas la prétention de faire mieux que des moteurs de jeux existants.
En revanche, ce moteur n'est pas incompatible avec l'utilisation d'autres moteurs comme Irrlicht, c'est d'ailleurs ce qui fait sa force, réutiliser l'existant.

D'ailleurs, le Kernel se limitant au chargement puis à l'appel d'une méthode d'un module "init", même la gestion des modules peut être changé.

Ensuite, on peut toujours trouver un jeu similaire ou plus intéressant qu'une idée qu'on a. Mais est-ce pour autant qu'il faut abandonner toute idée de créer soit-même un jeu ?
Tout comme les projets de jeux, je ne m'amuse pas en jouant mais en créant le jeu. Je code d'abord pour moi-même.
Après si d'autres personnes veulent utiliser mon moteur, j'en serais très flatté.

Quelles technologies utilisées ?

Langage : C++11
Outils : CMake, git
Bibliothèques (modules) : SFML, Irrlicht, Qt (?)

État du projet

Fait :

• information sur les modules ;
• liste des modules activé/désactivés ;
• chargement des symboles ;
• algorithme du calcul de l'ordre de chargement des modules ;
• système d'exceptions donnant l'état de la pile d'appel ;
• implémentation du calcul de l'ordre de chargement des modules en fonction de leurs dépendances ;

En cours :

• chargement d'un module (charger les bons symboles) ;

Prévus :

• façade pour simplifier le chargement des modules ;
• création d'un jeu (Last Escape) en parallèle des modules 2D/Fenêtrage.

Cf Trello pour plus d'informations

Quelle licence ?

Pour le moment, vu qu'il n'y a aucune release, la licence est
"officiellement, pas touche ! Tous droits réservés, officieusement je ne peux pas vous empêcher de consulter le code source sur github ".

La licence sera très certainement LGPL mais il faut que je renseigne tout cela sur github, sur les fichiers, etc.
Or je suis pour le moment bien plus intéressé par mon envie maladive de coder que de distribuer un moteur.

Qui utilise Last Engine ?

• [Il est prévu de créer des modules à partir d'un autre moteur existant sur ce forum]
• Moi-même pour mes propres projets ;

Liens utiles

Site : http://last-project.ovh/fr/
IRC : irc.last-project.ovh:6667 salon #last-team
Github : plus tard
Trello : https://trello.com/b/U1LbyIZ6/last-project

Voilà, si vous avez des remarques ou des questions, n'hésitez pas
J'espère que vous prendrez autant plaisir à suivre ce projet que j'en ai à vous le présenter.

[Vetea]

Excellente nouvelle !
Bon courage pour ton cursus.
Bon, j'ai pas tout compris dans les termes techniques je dois t'avouer ...
Au plaisir de suivre la suite.

[Neckara]

Bon courage pour ton cursus.

Merci.

Bon, j'ai pas tout compris dans les termes techniques je dois t'avouer ...

Kernel : "noyau", en gros, c'est le cœur, le centre de l'application.
modules : c'est un ensemble de classes.
classe : structure contenant des attributs (données) et des méthodes (fonctions).
couplage : mesure de la dépendance entre deux modules, ie si un des module a besoin de l'autre, etc.
POC : en gros avoir des composants, ici, avoir des modules.


Pour l'état du projet, en gros il ne reste plus qu'à charger les modules dans le bon ordre avant de commencer à faire Last Escape.

[Neckara]

Bon…
J'ai pas pu résister jusqu'au 5 .

Je viens de finir le calcul de l'ordre de chargement des modules.
Ce n'est pas si simple que cela. J'ai d'abord commencé à refactorer le code (=réécrire certaines parties), séparer le code en plusieurs fonctions, créer quelques typedefs…
Le code est devenu tout de suite plus simple et agréable.

Je ne teste pas, si ça compile c'est que ça marche .
La prochaine étape est donc de charger les modules puis de créer la façade, cela devrait être très rapide.
Last Escape, j'arrive !!


Juste pour le fun, voici le code pour calculer l'ordre de chargement des modules

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
#include "moduledependancies.h"
 
#include <unordered_map>
#include <stack>
#include <unordered_set>
#include <algorithm>
 
#include <LastEngine/Algorithms.h>
 
namespace std
{
    template<>
    class hash<LE::Module::ModuleDependancies::ModuleInfo> {
    public:
        std::size_t operator()(const LE::Module::ModuleDependancies::ModuleInfo & info) const
        {
            return (std::size_t) & info.file.modules[info.module];
        }
    };
 
    template<>
    class equal_to<LE::Module::ModuleDependancies::ModuleInfo> {
    public:
        bool operator()(const LE::Module::ModuleDependancies::ModuleInfo & infoA, const LE::Module::ModuleDependancies::ModuleInfo & infoB) const
        {
            return &infoA.file.modules[infoA.module] == &infoB.file.modules[infoB.module];
        }
    };
}
 
namespace LE
{
    namespace Module
    {
 
                namespace {
 
                    typedef std::unordered_multimap<std::string, const ModuleDependancies::ModuleInfo *> APIList;
                    typedef std::unordered_multimap<ModuleDependancies::ModuleInfo, std::string> ExcludeList;
                    typedef std::unordered_map<const ModuleDependancies::ModuleInfo *, std::size_t> NbDependancies;
                    typedef std::unordered_multimap<std::string, const ModuleDependancies::ModuleInfo *> Users;
                    typedef std::unordered_set<ModuleDependancies::ModuleInfo> Modules;
 
                    const Info::Module & mod(const ModuleDependancies::ModuleInfo & m)
                    {
                        return m.file.modules[m.module];
                    }
 
 
                    // get alls modules from modulesFiles
                    void fillModules( Modules & modules, const Range<const std::pair<std::string, Info::File> > &modulesFiles )
                    {
                        for( const std::pair<std::string, Info::File> & file : modulesFiles )
                        {
                            ModuleDependancies::ModuleInfo info = { file.first, file.second };
                            std::size_t i = 0;
                            for( const Info::Module & m : file.second.modules )
                            {
                                info.module = i;
                                modules.insert( info );
                                ++i;
                            }
                        }
                    }
 
                    // fill all informations about modules
                    void fillInformations( Modules & modules,
                                           NbDependancies & nbDependancies,
                                           APIList & apis,
                                           Users & users)
                    {
                        for( const ModuleDependancies::ModuleInfo & module : modules )
                        {
                            const Info::Module & moduleInfo = module.file.modules[module.module];
                            const auto & dependancies = moduleInfo.dependancies;
                            nbDependancies[&module] = dependancies.size();
 
                            for( const Info::API & api : dependancies )
                                users.insert( std::make_pair( api.name, &module) );
 
                            apis.insert( std::make_pair(moduleInfo.api.name, &module) );
                        }
                    }
 
                    bool isApiHere(const Info::API & api, APIList & apis) {
 
                        auto range = apis.equal_range(api.name);
                        if( range.first == range.second )
                            return false;
 
                        for( ; range.first != range.second; ++range.first)
                        {
                            const ModuleDependancies::ModuleInfo * moduleInfo = range.first->second;
                            const Info::Module & mod = moduleInfo->file.modules[ moduleInfo->module ];
                            if( mod.api.version >= api.version)
                                return true;
                        }
 
                        return false;
                    }
 
                    bool isAllDependanciesHere( const ModuleDependancies::ModuleInfo & module, APIList & apis)
                    {
                        const Info::Module & moduleInfo = module.file.modules[module.module];
                        const auto & dependancies = moduleInfo.dependancies;
 
                        for( const Info::API & api : dependancies )
                            if( ! isApiHere(api, apis) )
                                return false;
                        return true;
                    }
 
                    Info::Version versionNeeded(const ModuleDependancies::ModuleInfo & module, const std::string & api_name)
                    {
                        for( const Info::API & api : mod(module).dependancies )
                            if( api.name == api_name )
                                return api.version;
 
                        return Info::Version();
                    }
 
                    void excludeModule(const ModuleDependancies::ModuleInfo & module, ExcludeList & exclus, const std::string & reason,
                                       APIList & apis, Users & users, NbDependancies & nbDependancies)
                    {
                        typedef std::pair<const std::string, const ModuleDependancies::ModuleInfo *> Element;
 
                        exclus.insert( std::make_pair(module, reason) );
 
                        const Info::Module & moduleInfo = mod(module);
 
                        for( const Info::API & api : moduleInfo.dependancies )
                            multimap_erase(users, api.name, &module); // not an user anymore
                        multimap_erase( apis, moduleInfo.api.name, &module); // give no api anymore
 
                        auto range = apis.equal_range( moduleInfo.api.name );
                        Info::Version version;
 
                        if( range.first != range.second)
                        {
                            auto max = std::max_element(range.first, range.second,
                                                        [](const Element & a, const Element & b){ return mod(*a.second).api.version < mod(*b.second).api.version; } );
                            version = mod(*max->second).api.version;
                        }
 
                        if( moduleInfo.api.version > version) // search modules which need a version > version
                        {
                            auto range = apis.equal_range( moduleInfo.api.name );
                            for( ; range.first != range.second ; ++ range.first )
                            {
                                const ModuleDependancies::ModuleInfo & user = * range.first->second;
                                if( versionNeeded(user, moduleInfo.api.name) > version)
                                    excludeModule(user, exclus, "A dependancy can't be loaded", apis, users, nbDependancies);
 
                            }
                        }
 
                        nbDependancies.erase( nbDependancies.find(&module) );
 
                    }
 
 
                    void acceptModule(const ModuleDependancies::ModuleInfo & module, std::vector<ModuleDependancies::ModuleInfo> & toLoad,
                                      Users & users, NbDependancies & nbDependancies, std::stack<const ModuleDependancies::ModuleInfo *> & noDependancies)
                    {
                        toLoad.push_back(module);
 
                        nbDependancies.erase(&module);
 
                        auto range = users.equal_range( mod(module).api.name );
 
                        for( ; range.first != range.second; range.first)
                            if( --nbDependancies[range.first->second] )
                                noDependancies.push(range.first->second);
 
                        //users.erase( range.first, range.second);
                    }
 
                    void excludeOldestAPI(APIList & apis, ExcludeList & exclus,
                                          Users & users, NbDependancies & nbDependancies)
                    {
                        auto last = apis.begin();
                        auto end = apis.end();
                        auto it = ++last;
 
                        while(it != end)
                        {
                            if(last->first != it->first)
                            {
                                last = ++it;
                                continue;
                            }
 
                            if( mod(*last->second).api.version != mod(*it->second).api.version)
                            {
                                const ModuleDependancies::ModuleInfo & module = *it->second;
                                it = apis.erase(it);
                                excludeModule(module, exclus, "newer api available",
                                              apis, users, nbDependancies);
                            }
                            else
                            {
                                excludeModule(*last->second, exclus, "newer api available",
                                              apis, users, nbDependancies);
                                ++it;
                            }
                        }
                    }
                }
 
 
 
                void ModuleDependancies::loadOrder(const Range<const std::pair<std::string, Info::File> > &modulesFiles)
                {
                    Modules modules;
                    NbDependancies nbDependancies;
                    APIList apis; // api_name, module which implements the API.
                    Users users;  // api_name, module which use the API.
 
 
                    fillModules(modules, modulesFiles);
                    fillInformations(modules, nbDependancies, apis, users);
 
                    ExcludeList exclus;
 
                    for( const ModuleInfo & module : modules)
                        if( ! isAllDependanciesHere(module, apis) )
                            excludeModule(module, exclus, "A dependancy is missing", apis, users, nbDependancies);
 
 
                    excludeOldestAPI(apis, exclus, users, nbDependancies);
 
                    // get all modules with no dependancies.
                    std::stack<const ModuleInfo *> noDependancies;
                    for( const auto & dep : nbDependancies)
                        if( ! dep.second )
                            noDependancies.push(dep.first);
 
                    // get all module to load
                    std::vector<ModuleInfo> toLoad; // to return
                    while( ! noDependancies.empty() )
                    {
                        auto dep = noDependancies.top();
                        noDependancies.pop();
 
                        acceptModule(*dep, toLoad, users, nbDependancies, noDependancies);
                    }
 
                    // unloaded modules are exclued.
                    for( const auto & dep : nbDependancies)
                        excludeModule(*dep.first, exclus, "Dependancy circle", apis, users, nbDependancies);
 
 
                    // TODO return exclus & toLoad.
                }
 
    }
}

Je rappelle que tous droits sont réservés, vous n'avez donc pas le droit de lire le code ci-dessus.

[Dabou Master]

Mais euh c'est quoi au juste "Last Escape" ?
Nan parce que moi je suis sensible au "marketing cache-cache" alors attention à la rétention d'information .

[Neckara]

C'est un petit projet de jeu pour tester le début du moteur.
Je donnerais plus de détails pendant les vacances (ou avant) dans un autre sujet, juste le temps que je l'avance un peu pour pouvoir ouvrir un autre sujet et éviter de tout mélanger ici.

Et puis je te vois venir, tu vas essayer de piquer mon idée formidable et inédite.

Et puis si je te passe le lien vers la description sur le site en cours de développement, tu vas dire que le design du site est horrible.

[Neckara]

Je viens de rajouter le lien vers le Trello.

Comme vous pourrez le voir, il y a beaucoup de choses à faire.

[Dabou Master]

Et puis je te vois venir, tu vas essayer de piquer mon idée formidable et inédite.

Merde démasqué avant même d'avoir fraudé ! Je suis fichu :'(.
Tu remarqueras que je garde en secret toutes mes idées depuis que j'existe sur ce forum, c'est parce que je les collectionne mais je compte pas les exploiter .

Et puis si je te passe le lien vers la description sur le site en cours de développement, tu vas dire que le design du site est horrible.

Tout de suite les à priori ! Je ne suis pas gêné par un design affreux (faut voir ce que je suis capable de faire même avec un template tout fait, pas de quoi rougir ^^) dès le moment où il m'arrache pas la rétine pour ce qui est de le lire (genre le classique fond bleu turquoise super clair avec l'écrit en jaune ...)

Allez allez, j'arrête de polluer ton sujet tu n'entendras plus JAMAIS parler de moi ! (pour ce que je peux apporter ou comprendre de toute façon ...).

[Neckara]

Tu remarqueras que je garde en secret toutes mes idées depuis que j'existe sur ce forum, c'est parce que je les collectionne mais je compte pas les exploiter .

Tu les collectionnes mais tu les revends surtout !
Regarde Vetea, faire des jeux super géniaux que tout le monde adore, c'était mon idée ! Et tu lui l'as vendu

Comme si, après ça, j'allais te donner le lien vers le site preprod…

dès le moment où il m'arrache pas la rétine pour ce qui est de le lire (genre le classique fond bleu turquoise super clair avec l'écrit en jaune ...)

Tu me donneras des nouvelles de ta rétine .

pour ce que je peux apporter ou comprendre de toute façon ...

Rhôoo, là c'est un projet de moteur donc c'est en effet un peu technique, mais le sujet pour Last Escape sera plus simple avec pleins de petites images, comme ça tu n'auras même pas besoin de lire le texte .

[Invité]

Salut, comme je te l'ai déjà dis, si la license est en LGPL, ça m'intéresse, j'y intégrerai sûrement mon propre moteur.

Je n'ai pas envie de prétendre que je ferai mieux que les moteurs de jeux existant, ce n'est qu'un petit moteur avec juste des fonctionnalités de base rendu de type "biased raytracing" dont je me sert pour mes rendus et pour ensuite coder mes propres petits jeux ou applications en solo, mais, ici le moteur pratiquement terminé je compte développer pleins de jeux avec mon moteur et tenter d'en vendre.
La seule chose qui m'inquiète comme tu le soulignes c'est si un jour les librairies que j'utilise (ou bien les plate formes/os) ne sont plus maintenu.

[Neckara]

J'ai un peu bossé sur le site aujourd'hui :

• dans le menu : possibilité de désactiver un item ;
• intégration de sources ;
• une jolie page 404.

À noter que ce site est écrit en XML/XSLT .

J'estime désormais qu'il est présentable, je peux donc vous en donner le lien :
http://last-project.ovh/fr/

J'aurais d'ailleurs besoin de savoir quelle coloration syntaxique vous préférez.
N'hésitez pas aussi à me dire votre avis sur le design.

Donc voilà, j'ai un site à peu près propre, je me replonge donc dans le moteur.
Serait-il d'ailleurs possible d'éditer le premier post du sujet pour y ajouter le lien vers le site ( http://last-project.ovh/fr/ ) ?

[Invité]

Ha, tu y as intégré mes tutoriels à présent. ^^

Je tenterai d'y intégrer quelques vidéos mais pour l'instant je dois finir un petit système de GUI pour les menus du jeux pour mes tutoriels vidéos sur la création d'un petit jeux avec le moteur.

'aurais d'ailleurs besoin de savoir quelle coloration syntaxique vous préférez.

La 2ème.

[Invité]

La 3e n'est pas la plus jolie; mais la plus lisible...

(source : Cercle Chromatique accessible )

[Neckara]

Merci pour vos réponses, je continue à chercher encore un peu.

Je suis tombé récemment sur des bibliothèques JavaScripts :

• https://highlightjs.org/static/demo/
• http://prismjs.com/test.html

La première a une coloration bien plus complète.

[Neckara]

Bonjour,

Mes examens sont enfin fini, je commence donc à me replonger un peu dans le code, d'autant plus que les vacances se rapprochent \o/.

Je viens totalement de finir le calcul de l'ordre de chargement des modules (non testé) et j'ai commencé à attaquer le chargement des modules, dans quelques jours à peine, je devrais avoir fini.

Il ne me restera plus qu'à écrire la doc et des tutoriels avant de passer à l'étape suivante, Last Escape.
Donc principalement sur le système de module et sur quelques outils (principalement des type erasure sur des itérateurs).

Pour Last Escape, il me faudra :

• Gui/fenêtrage avec Qt ;
• 2D avec la SFML ;
• gestion des événements ;
• son avec ?
• vidéo avec ?
• gestion de paramètres (XML/DOM) ;

Donc :

• dès que j'ai la fenêtre, ce sera celle de Last Escape ;
• dès que j'aurais un module de paramètres, je pourrais gérer les langues et donc l'affichage du texte ;
• dès que j'aurais la 2D, je pourrais commencer à charger des cartes ;
• ensuite, j'essaye d'intégrer le son ;
• dès que j'aurais la gestion des événements, on pourra se déplacer.

Dès que j'aurais tout cela, je pense qu'il sera temps de faire une petite présentation ici .


Je vais faire une petite estimation :

• d'ici vendredi, système de module terminé ;
• pendant ma semaine de vacances, docs, tutoriels, deux-trois trucs sur le site ;
• 4 semaines pour la fenêtre et le module de paramètres ;
• 2D, 2 semaines ;
• sons, 1 semaine ;
• gestions événements, 3 semaines.

Donc dans 12 semaines, je devrais poster ici pour le projet Last Escape .

J'espère sincèrement que je serais plus rapide .

[Neckara]

CSS Awards 2015 : élisez la meilleure coloration syntaxique du site.

Présentation

Aujourd'hui, je viens d'installer highlight.js sur le site du projet et je les ais regroupés dans un sommaire afin de leur donner une visibilité accrue. Maintenant, il est grand temps de faire le point et de faire une sélection pour choisir la coloration syntaxique par défaut.
Voici donc, les CSS Awards (2015).

Ces Awards se dérouleront en six sondages dans lesquels vous pouvez voter pour la meilleure coloration syntaxique dans les catégories suivantes :

• meilleurs graphismes ;
• meilleur lisibilité ;
• meilleur nom ;
• aboutissement ;
• meilleur crève-œil ;
• meilleur sapin de noël.

Plus sérieusement, ce serait gentil de m'aider à trouver une bonne coloration syntaxique parmi celles-ci en me donnant vos préférées.

Concernant le projet en lui-même, je suis un peu en avance, en effet, j'ai déjà fini le système de module depuis samedi soir. Mais je n'ai pas plus avancé depuis.
Aujourd'hui j'ai un peu bossé sur l'intégration de la coloration syntaxique, une vrai galère pour numéroter les lignes en CSS .
Pour créer les pages de tests et le sommaire, j'ai utiliser des petits scripts shells pour éviter de le faire à la main .

Donc à partir de maintenant, je commence la documentation et les tutoriel.
Je viens aussi d'apprendre qu'une dérogation que je vise pour mes études est très exceptionnelle et malgré mes bons résultats, ce n'est pas gagné d'avance. Je risque donc de ne pas avancer aussi vite que je l'avais prévu.

[Invité]

meilleurs graphismes ;

La plus jolie : je vote pour pojoaque.css

meilleur lisibilité :

Je vote pour magula.css

meilleur nom :

Je vote pour zenburn.css

aboutissement :

Je vote pour brown_paper.css

meilleur crève-œil ;

Je vote far.css

meilleur sapin de noël.

Je vote pour atelier-forest-light.css

Voilà j'espère que cela pourra t'aider à choisir.

[Neckara]

Bonjour,

Je travaille encore un peu sur le site : css pour les mobiles, langue par défaut si une traduction est inexistante,…
J'ai encore quelques informations à mettre sur le moteur, l'équipe et les outils utilisés, mais je pense que je vais rédiger les articles avant.


J'ai passé beaucoup de temps à faire une synthèse/historique sur le projet, pour cela j'ai reparcouru tous mes anciens sujets.
Ce n'était pas facile car certaines choses datent et on été oubliée et je ne sais pas s'il n'y a pas quelques petites erreurs ou des choses qui manquent.

Voici le lien de mon premier jet : http://last-project.ovh/fr/projects/chronicles/

Ce serait vraiment gentil si vous pouviez me faire un petit commentaire ici, me dire ce que vous en pensez. J'y ai passé pas mal de temps aujourd'hui donc j'aimerais vraiment avoir vos retours.

[AdmChiMay]

Avec mes yeux il y a un problème de contraste. Sans vouloir causer "accessibilité", il y a quand même un problème de lisibilité. Sur les menus, noir sur rouge foncé, ça ne passe pas vraiment pour moi. Pour les items de menus, le gris améliore "un peu", mais c'est pas top. Question : pourquoi certains items de menus sont en noir et d'autres en rouge ? certains en italique et d'autres pas ? (je n'ai pas trouvé de logique). Le gris foncé autour de la bande d'affichage est un peu morose.
Ton en-tête est bien présentée/placée. Pour gérer ta bande centrale, je ne sais pas si tu dimensionnes en em ou en % (j'espère que ce n'est pas autre chose), mais elle fait presque un peu petite chez moi, et je dois user du ctrl+molette de souris. Il faudrait mettre les titres plus en valeur visuellement (les h2) pour bien séparer les zones de lecture.

Globalement, je dirai d'abord d'améliorer le contraste, sans se sentir obligé de faire dans l'accessible (un outil tel que le colour contrast analyser peut donner une idée), il faut au moins revoir ce point. voilà pour une première approche.

Pour le contenu, agréable à lire.

[Neckara]

Merci pour ta réponse.

Pour les couleurs, c'est très difficile à gérer dans le sens où elles dépendent de l'écran, de la configuration de l'écran et de l'utilisateur. Et je suis vraiment pas doué de ce côté là, ou plutôt, je suis très doué pour provoquer des crises d’épilepsies.

Sur les menus, noir sur rouge foncé, ça ne passe pas vraiment pour moi.

Normalement, c'est du rouge clair.

Question : pourquoi certains items de menus sont en noir et d'autres en rouge ? certains en italique et d'autres pas ? (je n'ai pas trouvé de logique).

Rouge et italique : la page n'existe pas encore, le curseur reste un pointeur au survol et au clique rien ne se passe.

Le gris foncé autour de la bande d'affichage est un peu morose.

En théorie, on devrait rajouter une image de fond, donc cela devrait devenir un peu plus vivant mais ce n'est pas encore prévu pour tout de suite.

Pour gérer ta bande centrale, je ne sais pas si tu dimensionnes en em ou en % (j'espère que ce n'est pas autre chose), mais elle fait presque un peu petite chez moi, et je dois user du ctrl+molette de souris.

C'est redimensionné en %.
Quelle est ta résolution ? Quelle est la résolution maximale de ton écran ?
Pour les mobiles, en deçà de 768px, le CSS change légèrement pour augmenter la taille de cette zone.

Il faudrait mettre les titres plus en valeur visuellement (les h2) pour bien séparer les zones de lecture.

À par augmenter le margin-top, je ne sais pas trop ce que je pourrais faire.

J'ai essayé de modifier un peu le CSS, mais j'ai l'impression que cela rend plus illisible la page sur Last Escape.
http://last-project.ovh/en/last-escape/
http://last-project.ovh/en/projects/chronicles/

Globalement, je dirai d'abord d'améliorer le contraste, sans se sentir obligé de faire dans l'accessible (un outil tel que le colour contrast analyser peut donner une idée), il faut au moins revoir ce point. voilà pour une première approche.

Le problème, c'est que moi et les couleurs… et c'est aussi une chose tellement subjective.

Après pour le moment, le plus important est le contenu, pour le design il vaut mieux que je me trouve une victime féru de CSS.
Si je devais le faire moi-même cela me prendrait beaucoup de temps pour un résultat médiocre et je n'aurais pas le temps de continuer le projet en parallèle.
En C++ ton code, il marche ou il marche pas, il est facile à maintenir ou non, il est agréable à lire ou non, c'est bien carré.
En design, je suis complètement perdu, je fais un joli design avec un fond bleu et on me dit que les années 90 ont appelées et réclament leurs feuilles CSS .
Pour recevoir des conseils, on a juste quelques sites pour nous aider à trouver des couleurs, mais cela ne fait pas tout non plus.
On a 2-3 conseils sur le css-responsive.
Si on montre un exemple, on aura toujours au moins une personne pour dire qu'elle n'aime pas. Bref, c'est une véritable horreur .

Pour le contenu, agréable à lire.

Merci.