Lancer son premier jeu

Petite question au passage : quelle résolution me conseilles-tu pour créer le jeu ?

Pour l'instant j'ai fait ce "brouillon" de jeu avec une résolution de 800/600. Mais je trouve ça très petit. Je me dis que vu que ce que je veux faire ne vas pas être bourré d'animations et de trucs méga compliqués (y aura même aucune animation, voilà), je peux envisager de monter la résolution sans que ça alourdisse le jeu. Et vu que la plupart des ordi ont maintenant des résolutions élevées...

Parce que je pense tout reprendre de 0, refaire un jeu qui sera le bon, en recopiant tous les codes que j'ai pu écrire etc... Mais avec une résolution de 1920/1280 par exemple, pour que ça soit en plein écran, et avec des images en bonne qualité.

A moins que je puisse garder ce que j'ai fait jusqu'à présent, et juste changer la résolution ? A ce moment là, je change les images de boutons/sprites/background en mettant des images de la nouvelle résolution, et le tour est joué ?

1920*1080 est idéal mais je ne sais pas ce que ça donne pour les écrans aux résolutions plus petites. L'inconvénient c'est que tu ne peux pas vraiment jouer en fenêtré du coup (sauf sur un écran 2K et 4K par exemple). Après ça reste une bonne option, même si 1280*720 ou 1600*900 feraient l'affaire aussi.

Tu n'auras pas besoin de tout reprendre à zéro, par contre tu devras changer toutes les positions et dimensions de tes éléments d'interface, en plus de leurs images.

Bonne nouvelle que je n'aie pas à tout refaire !

C'est vrai que je me demandais si en mettant une résolution de 1920*1080, un écran plus petit pouvait afficher correctement. Peut-être je vais utiliser 1600*900 ?

L'autre solution c'est de passer ton écran dans une résolution plus petite et de voir ce qu'il se passe. Pour ça je te conseille de compiler ton projet et de lancer directement l'exe en plein écran.

Bon ben je viens de tester, j'ai mis mon écran en 1280/720 et le jeu en 1920/1080, et ça a marché ! L'affichage était a priori normal, le jeu n'a pas crashé. Faut juste que je me dépêche de coder le bouton "quitter le jeu" parce que je suis obligé de faire du gestionnaire de tâches pour fermer le jeu lorsqu'il est en plein écran

Du coup je pars sur du 1920/1080 !

Baguettator a écrit:

Faut juste que je me dépêche de coder le bouton "quitter le jeu" parce que je suis obligé de faire du gestionnaire de tâches pour fermer le jeu lorsqu'il est en plein écran !

Haha j'ai connu ça. Sinon par défaut il y a la possibilité de faire ctrl+Q, puis Entrée.

Cool !

Rebonjour !

Alors, j'ai à nouveau un problème à poser (décidément...).

J'ai pu faire grâce à toi un super système qui permet de trier les cartes disponibles en fonction des jeux/extensions possédés.

Le hic : certaines cartes ne sont jouables qu'avec minimum une extension et un jeu de base précis.

Je m'explique : il y a 3 jeux de base, qui peuvent être joués indépendamment, mais aussi combinés entre eux. Pour chacun de ces jeux, il y a des cartes qui n'utilisent que du contenu propre à un jeu.

Ex : les cartes de la boite 1 n'utilisent que le contenu de la boite 1.

MAIS il y a des cartes qui utilisent du contenu de la boite 1 ET de la boite 2. Ce qui signifie qu'il faut les boites 1 et 2 pour pouvoir les jouer.

Dans le système qu'on a fait, j'ai l'impression que ça trie les cartes qui n'utilisent qu'une boite. Mais il n'y a rien pour les cartes utilisant 2 boites.

J'imagine qu'il faudrait donc une variable qui, lorsqu'on a choisi les jeux/extensions qu'on possède, prend une valeur qui permet de récupérer les cartes qui utilisent les jeux/extensions concernés.

Bon j'avoue que j'ai pas encore regardé ça de plus près pour le moment (je suis très occupé pour créer les visuels propres à chaque carte)... Mais j'imagine qu'il va falloir affiner la fonction de Kitai pour prendre en compte cela, non ?

EDIT : parce qu'il y a même des cartes qui utilisent le contenu de 3 boites...
Peut-être que la solution serait qu'au moment de sélectionner les cartes disponibles grâce à la formule de Kitai, on peut faire une autre formule de Kitai qui se déclenche sous condition que "le joueur possède boites 1 et 2 ALORS cartes utilisant les contenus des boites 1 et 2 sont sélectionnées". Et les cartes sélectionnées avec cette deuxième formule de Kitai s'ajouteraient ensuite au tableau des cartes disponibles ?

EDIT 2 : peut-être que la solution serait de considérer par exemple :

- les cartes utilisant les boites 1 et 2 sont considérées comme une extension supplémentaire, les cartes utilisant les boites 1 et 3 sont considérées comme une extension supplémentaire, et ainsi de suite pour toutes les combinaisons possibles

- au moment de valider les jeux possédés par le joueur, si le joueur possède les boites 1 et 2, nbExtension gagne 1 en valeur (car on rajoute "l'extension" qui comprend les cartes qui ont besoin des boites 1 et 2). Si le joueur possède les boites 1 et 3, nbExtension gagne encore 1 en valeur et les cartes utilisant les boites 1 et 3 seront ainsi ajoutées. Et ainsi de suite pour chaque combinaison possible (il y en aura sans doute beaucoup, car 3 jeux de base et 3 extensions...).

- a priori avec cette méthode, y aurait pas besoin d'autre fonction de Kitai, vu qu'on considère ces cartes issues de combinaisons d'extensions/jeux de base comme des extensions à part entière qui ne s'active que si le joueur possède les jeux/extensions concernés. Ou dis-moi si je me trompe, ça sort sans doute de mon domaine de compétence là

J'ai pas tout compris. Dans le jeu physique (sans prendre en compte ton outil) ça se passe comment ? Si on possède une extension dont des cartes nécessitent deux jeux de base, alors on est censé posséder ces deux jeux de base pour jouer avec l'extension non ? Il faudrait un exemple un peu plus concret je pense.

C'est ça ! Il y a aussi les cartes créées par la communauté qui parfois utilisent plusieurs extensions/jeux, donc les combinaisons sont multiples

Bah ça veut juste dire que le joueur n'a pas le droit d'utiliser certaines extensions si il ne possède pas certains jeux de base/autre extensions non ? Dans ce cas là ça suffirait pas de mettre des incompatibilités dès la sélection ?

Ah non, je reformule :

- disons qu'il y a 3 jeux de base. Chacun de ces jeux peut être joué seul, on peut aussi les combiner. ça veut dire : il y a des cartes qui utilisent la boite 1 uniquement. Mais il y a des cartes qui utilisent la boîte 1 et 2.

- ça veut dire que celui qui a la boîte 2 peut jouer les cartes de la boîte 2. Mais pas les cartes qui utilisent les boites 1 et 2 (car il n'a pas la 1 !).

- ou si le joueur a la boite 1 et 3, il peut jouer les cartes de la boite 1, celles de la boite 3, et aussi les cartes qui utilisent les boites 1 et 3. Pas celles de la boite 2. Pas non plus celles qui utilisent les boites 2 et 3 (car il n'a pas la boite 2 !), ni celles qui utilisent les boites 1 et 2 (il n'a pas la boite 2 !).

- ce qui implique qu'il y a des cartes qui ne sont jouables qu'à la seule condition qu'on a une certaine "combinaison" de jeux. Heureux sont ceux qui les ont tous. Ceux qui n'ont qu'une boite sont limités (ils ne peuvent pas jouer toutes les cartes), mais ça reste un bon jeu avec déjà beaucoup de choses à faire

- ce qui est sûr c'est que toutes les boites/extensions/jeux de base sont compatibles ! Elles s'ajoutent les unes aux autres, et offrent de nouveaux éléments de jeu. MAIS en ce qui concerne les cartes, on ne peut jouer que celles dont on a les boites correspondantes (ça concerne les "dalles" qui représente le terrain de jeu, qui sont différents d'une boite à l'autre)

Je sais pas si j'ai été plus clair :S

Alors si je comprends bien il faut que chaque carte contienne l'information des boîtes dont elle a besoin. C'est ça qui est plus chiant parce qu'il faut rentrer cette information carte par carte. Il faut déjà voir quelle méthode utiliser pour ça avant de penser au tri (qui ne devrait pas demander une adaptation très compliquée une fois cette information disponible).

Ah ok ! Par rapport à ce que j'ai pensé, tu penses que c'est une fausse route ?

à savoir : vu qu'on a trié les cartes par extension (en tout cas les cartes qui n'ont besoin que d'une boite), on pourrait considérer que les cartes qui ont besoin des boites 1 et 2 sont une extension (donc dans notre VUE, une loop supplémentaire), idem pour celles qui utilisent les boites 1 et 3, puis pour celles qui utilisent 1, 2 et 3 etc... ça fait une "extension" par "combinaison". On active ces "extensions" en détectant quel jeux ont été sélectionnés par le joueur.

Hum dans l'absolu ça semble pas mal mais ces cartes font pas elles mêmes partie d'une extension ?
Oh bah oui mais du coup y'a qu'à ajouter cette extension dans les conditions et le tour est joué ! Habile ! Bon par contre faut pouvoir s'y retrouver et qu'il n'y ait pas trop de combinaisons différentes. Une autre solution serait d'utiliser un code dans les propriétés des frames, mais bon ta solution me paraît meilleure.
Il faudra juste trouver un endroit où noter à quoi correspond chaque loop parce que c'est un coup à s'y perdre. À mon avis il doit y avoir une solution plus propre, mais là comme ça ça me vient pas trop... Donc si ça te convient pourquoi pas.
Si tu organises tes cartes (ou tes prototypes) dans des loops et me fait une capture d'écran de la view sur laquelle tu précises à quoi correspond chaque loop (enfin celles qui utilisent des combinaisons d'extensions) je peux t'aider à ajouter ça lors du tri.
Mais ça doit pas être très compliqué, en gros au moment de valider, il faudra définir le nombre cartes de ces loops "spéciales", avec un truc du genre :

Code:

if ((tailleExtension[0] != 0) && (tailleExtension[1] != 0) && (tailleExtension[2] != 0)) tailleExtension[8] = Game.GetFrameCountForLoop(VUECARTES, 8);

Pour une extension "virtuelle" 8 qui nécessiterait les extensions 0, 1 et 2.

Et tu fais ça pour chaque extension "virtuelle". Je pense que c'est suffisant en fait.

Ah oui je viens de comprendre ! En effet ça devrait marcher ! Non ça me dérange pas d'écrire des lignes de code infernales, tant que ça marche

Si jamais tu vois une solution plus propre je suis preneur, mais je pense que ça va le faire.

Pour être concret : il y a 3 jeux de base (qui sont autonomes ou qui peuvent se combiner au reste) et 2 extensions (qui peuvent vraiment pas être jouées seules, il faut au moins un jeu de base avec elles pour jouer). Et c'est très rare que les cartes utilisent plus que 2 boites différentes. Donc ça fait pas tant d'extensions "virtuelles" à créer, au final. Grâce à la magie du copier coller, ça ira vite

EDIT : par exemple il faudra les combinaisons suivantes : (boite = jeu de base, extension = boite qui ne sont pas suffisantes pour jouer)

loop 0 : boite 1
loop 1 : boite 2
loop 2 : boite 3
loop 3 : boite 1 + extension 1
loop 4 : boite 1 + extension 2
loop 5 :boite 2 + extension 1
loop 6 : boite 2 + extension 2
loop 7 : boite 3 + extension 1
loop 8 :boite 3 + extension 2
loop 9 : boite 1 + boite 2
loop 10 : boite 1+ boite 3
loop 11 : boite 2 + boite 3
loop 12 et + : si y a des combinaisons à trois boites (y en aurait pas tant que ça je pense)

Seul hic: on peut vraiment faire autant de loops qu'on veut dans une VUE ?

Effectivement ça va alors. Et point besoin de lignes de codes infernales, quelques unes suffiront. Je pense que c'est la solution la plus simple et la plus élégante qu'on ait dans la mesure ou il n'y a pas plusieurs dizaines de combinaisons.

Attention, il faut aussi rajouter comme critère l'extension dans laquelle est la carte à la base. Si dans l'extension 1 tu as une carte qui nécessite la boîte 1 et la boîte 2, alors la loop sera plutôt "boîte 1 + boîte 2 + extension 1" (si j'ai bien compris l'idée).

Euh, moi je croyais qu'on créait une loop spécialement pour les cartes qui ont besoin des boites 1 et 2 ! C'est pas plus simple ? En gros une loop par combinaison, qu'elle soit simple (une boite requise), double (deux boites requises) ou triple (3 boites requises).

Bah oui mais si la carte est contenue dans l'extension 1 il faut que le joueur possède aussi l'extension 1 non ? Donc ça fait tout autant partie des critères... Non ?
Quand tu parles d'une carte qui a besoin des boîtes 1 et 2, elle vient d'où la carte ?

Elle vient... ben d'ailleurs que les boites 1 ou 2

Comme c'est un jeu "bac à sable" qui se construit non stop par les éditeurs et les fans, il y a des cartes qui sont créées régulièrement. Les boites en proposent certaines, après il y en a des tas disponibles gratuitement sur internet par exemple. Soit éditées par les créateurs, soit créées par les fans !

Mais du coup, je crois que j'ai compris ce que tu veux faire, ça me semble bien ! Et ça réduit le nombre de loops !

Pour la capture écran, je peux pas le faire maintenant, car j'ai pas encore créé toutes les loops. Je suis en train d'éditer toutes les cartes sur l'ordi, après quoi faut que je les mette en page, après je les transforme en .bmp et après je pourrai les intégrer dans la VUE. Y a encore du boulot...

Baguettator a écrit:

Mais du coup, je crois que j'ai compris ce que tu veux faire, ça me semble bien ! Et ça réduit le nombre de loops !

Bah je sais pas moi je ne fais que reprendre ce que j'ai compris de ton idée. Qu'est-ce qui réduit le nombre de loop ?

En fait j'avais pas compris qu'il y avait des cartes indépendantes. Bon enfin ne nous compliquons pas la vie. En gros, si je reprends ton exemple, la loop 3, par exemple, contiendra les cartes qui seront présentes si et seulement si le joueur à sélectionné au moins la boîte 1 + l'extension 1. Si ça te va comme ça, alors c'est parfait.
Et du coup tu n'auras qu'à ajouter des lignes similaires à celle que je t'ai proposé plus haut (une pour chaque loop utilisant une combinaison), au début du bloc de code du bouton valider.
Enfin peut-être qu'il faudrait juste changer un peu ce qu'il se passe quand on sélectionne un groupe de cartes au début, que ça active une variable boléenne plutôt que définir un nombre de cartes directement.

Réduire le nombre de loops : rien, j'avais mal compris

Mais es-tu sûr qu'on peut avoir autant de loops qu'on le veut dans une VUE ? Si on est limité, on pourra peut-être pas rentrer toutes les combinaisons dans autant de loops...

Pour la variable boléenne, ça reviendrait à dire :

if ((boite 1 = true) && (boite 2 = true) && (boite 3 = true)) tailleextension[8] = Game.GetFrameCountForLoop(VUECARTES, ;

avec boite 1 la variable boléenne qui devient true lorsqu'on sélectionne la boite 1, etc...?

En gros c'est ça, et le faire pour chaque loop (pas seulement celles qui utilisent des combinaisons). Il faut créer un tableau en plus de tailleExtension[] dont la taille serait définie au même endroit de la même manière, et qui serait déclaré en haut du script pareil, comme ça :

Code:

bool extensionValide[];

(par exemple, en considérant encore une fois extension = groupe de carte (jeu de base ou non).
Quand tu clique sur le bouton de sélection d'un groupe de cartes ça ferait donc :

Code:

extensionValide[n] = true;

Et ensuite faire ce que tu as écrit pour chaque loop.

Yes, ok je me penche dessus demain, et je te dis quoi

Merci !!

Bonjour !

Bon ça y est, j'ai fini d'éditer une grande partie des cartes du jeu, je vais bientôt pouvoir tester notre histoire !

Avant cela, une nouvelle interrogation :

- avec tout ce qu'on a créé pour choisir aléatoirement les cartes, y a-t-il un moyen que le jeu sache lorsqu'il choisit une carte de quelle carte précisément il s'agit ? Parce que si j'ai bien compris, les cartes déjà jouées sont enlevées du tableau grâce à la fonction de Kitai. Mais y a-t-il un paramètre qui permet de "nommer" chaque carte ? J'ai le sentiment que le tableau dynamique leur donne une valeur (la variable carte[a] ), mais cette valeur change. Si la carte 12 est jouée, elle disparaît ensuite, donc la carte 14 prend la valeur 13, la carte 75 prend la valeur 74 etc...

- en gros mon idée, c'est que lorsqu'une carte est choisie, elle apparaît en room 7 (donc ça ça marche, on l'a fait), puis le jeu sait de quelle carte il s'agit (par exemple, la carte numéro 12 de la boite 3), et fait apparaître en fonction des boutons à certaines positions, que les joueurs vont devoir utiliser pour certains événements. En gros, chaque carte a des boutons placés manuellement pour chaque carte.

- donc il faudrait que le jeu sache quelle carte a été tirée, pour bien placer ces boutons au bon endroit (et les bons !).

- j'ai l'impression que le seul paramètre pour "identifier" chaque carte, c'est :

Code:

ViewFrame* frame = Game.GetViewFrame(VUECARTES, numExtension, rang);

en gros si j'ai bien compris, chaque "frame" des "loops" de la "VUECARTES" est attribuée à une carte spécifique. Ce serait donc le (seul ?) moyen de les identifier.

Je ne sais pas si je suis clair ?

Je vois deux solutions, soit tu identifies les cartes via leur sprite (je rappelle que carte[0] renvoie le sprite de la carte concernée (qui ne change jamais)). Donc tu peux faire quelque chose comme :

Code:

if (carte[tirage] == 14){
//ton code
}

Sinon tu peux utiliser aussi la propriété "Delay" de chaque carte pour leur attribuer un code spécifique (ce qui te permettrait d'attribuer le même code à deux cartes qui doivent avoir le même comportement si jamais ça t'es utile).
Quoi qu'il en soit si tu veux vraiment un comportement spécifique à chaque carte, il va falloir le coder manuellement pour chaque carte (mais bon ça tu t'en doutes).

Une solution pour organiser ça proprement, ce serait de faire une fonction personnalisée où tu liste le le comportement des cartes. Comme ça :

Code:

function BoutonsCartes (int IDcarte) {
if (IDcarte == 0) //ton code
else if (IDcarte == 1) //ton code
//etc
}

Ensuite tu peux mettre ça où tu veux :

Code:

BoutonsCartes(carte[0]);

Qui exécutera le code désiré en fonction de la valeur de "carte[0]" (mais tu peux remplacer ça par n'importe quelle autre variable). Ce n'est pas obligatoire mais ça te permet de coder le comportement de tes cartes à un endroit déterminé pour clarifier ton code, et aussi tu peux faire appel à la fonction depuis différents endroits.

Ah super alors ! Donc c'est effectivement via le numéro de sprite qu'on va pouvoir les identifier. Cela veut-il dire que carte[0] = sprite 0 ? J'espère pas...

Parce que dans la ligne que tu as écrite : if carte[tirage] == 14, ça veut dire "si la carte qui vient d'être tirée  est la carte dont le sprite est le numéro 14" ?

A priori, chaque carte aura son comportement spécifique. Et oui, je me prépare mentalement à coder des centaines de cartes... Mais notre ami "copier coller" va être d'une grande aide pour adoucir ce labeur

EDIT : j'avais pas vu ton "edit" Mais du coup, je suis pas sûr d'avoir pigé...