Ressources Magic Makers

EXPERIMENTER

J'apprends en me trompant.

EXPERIMENTER

J'apprends en me trompant.

PARTAGER

J'ai des idées et je les partage avec les autres.
partager

PARTAGER

J'ai des idées et je les partage avec les autres.

RAISONNER

Je suis fier de ce que je fais.

RAISONNER

Je suis fier de ce que je fais.

INVENTER

Je suis la pour créer.

INVENTER

Je suis la pour créer.

S'AMUSER

Je viens parce que j'en ai envie.

S'AMUSER

Je viens parce que j'en ai envie.
Menu
UP

 

Site en maintenance

 
Nous sommes actuellement entrain de mettre à jour les ressources de ce site.
Pendant la mise à jour vous pouvez retrouver tous les nouveaux contenus sur le site
 

https://lp-magicmakers.fr/

 
 

Petites mécaniques utiles

Sur cette page tu trouveras :

Accélérer le rythme du jeu

Construct a deux unités pour mesurer le temps. Le temps représente le temps qui s’est écoulé dans le jeu. Et le temps montre correspond au temps réel qui s’est écoulé depuis le lancement du jeu.

On peut donc accélérer ou ralentir le temps d’un jeu. Pour cela on utilise l’échelle du temps.
Quand : échelle du temps = 1, le temps du jeu va à sa vitesse normale. Si échelle de temps =2 alors le temps en jeu s’écoule deux fois plus vite. 

Pour accélérer un jeu, il faut donc trouver une solution pour augmenter régulièrement l’échelle de temps. 

Pour éviter que le temps ne s’emballe et que ton jeu devienne injouable, je te conseille de choisir une valeur maximale que ton échelle du temps ne devra pas dépasser.

Dans ta feuille d’événements :

Crée un événement.
En condition : Système => comparer deux valeurs

Ici tu vas choisir comme première valeur l’échelle de temps. Pour cela, trouve là dans le dictionnaire des expression ou cherche “timescale”

Puis tu vas établir une comparaison pour t’assurer qu’elle soit plus petite que la seconde valeur.
Enfin indique la valeur maximale que tu ne veux pas que ton temps dépasse. 

Ajoute une seconde condition : Système => Toutes les X secondes : indique l’intervalle de temps que tu veux avoir entre chaque augmentation de l’échelle du temps.

Attention ! Le nombre que tu vas indiquer pour dans ta condition “toutes les X secondes” sera compté en temps de jeu. Ce qui veut aussi dire que ce temps sera influencé par l’accélération de ton échelle de temps.

Enfin, ajoute une action : Système => Définir l’échelle de temps 

À nouveau, tu vas avoir besoin d’une expression. Comme on l’a vu plus haut, quand l’échelle de temps est égale à 1 elle ne change pas. Donc, on va la multiplier par 1.1 pour lui dire d’augmenter un tout petit peu par rapport à son état actuel. 

Tu vas donc avoir une expression “timescale*1.1”

Détruire en Glissant

Le concept :

Détruire un sprite en glissant son doigt dessus

Sur ta scène :

Si tu veux que le joueur ne puisse détruire en glissant que dans une zone bien précise, crée un sprite qui servira de zone de destruction. Rend le bien visible. Tu pourras le rendre invisible ou légèrement transparent une fois que tu auras vérifié que tout fonctionne bien. 

Assure toi que tu as ajouté le Toucher (mode de saisie) dans ton jeu.

Dans la feuille d’événements :

Crée un nouvel événement.
En condition : Toucher => Est en train de toucher un objet => le sprite à détruire

Avec juste cette condition il suffirait de toucher l’objet. Il faut donc une 2e condition pour vérifier que le joueur glisse.

En 2e condition : Toucher => Comparer la vitesse de toucher=> Ici tu vas vérifier que la vitesse est plus grande que 600 (par exemple)
N’hésite pas à tester ton projet et modifier ce paramètre si besoin.

Si tu as une zone de destruction spécifique, ajoute une 3e condition :
Toucher => est en train de toucher un objet => le sprite de la zone de destruction

En action : le sprite à détruire => détruire

Faire apparaître des éléments au hasard sur l’écran

 => n’importe où en masse (facile)

Le concept :

Un sprite est créé à une position aléatoire sur la scène à intervalles réguliers.

Sur ta scène :

Assure toi d’avoir créé le sprite que tu vas vouloir faire apparaître. Donne-lui les comportements / propriétés nécessaires pour ton jeu.

Regarde les propriétés de ta scène pour avoir la taille de celle-ci. Note là, tu vas en avoir besoin juste après.


Dans la feuille d’événements :

Crée un nouvel événement.
En condition : Système => Toutes les X secondes

En action : Système => (Général) Créer objet => ton sprite

Ici tu vas avoir besoin d’une expression pour déterminer la position en X et en Y. 

Le but sera que ton sprite soit créer sur une position aléatoire en X et en Y dans ta scène.
Tu vas donc avoir besoin de l’expression aléatoire : random. En paramètre de cette expression tu vas rentrer 0, puis la taille de ta scène. Répète l’opération pour X et Y. Tu devrais avoir quelque chose comme ceci : 

 => avec une turtle (moyen)

Le concept :

Tu vas utiliser un sprite “caché” pour faire apparaître un autre sprite à des positions aléatoires sur ta scène. 

Le sprite caché est une “tortue”. 

 

Sur ta scène :

Crée ton sprite de tortue. Donne lui une couleur bien visible. Tu lui enlèveras l’option “initialement visible” dans ses propriétés quand tu auras vérifié que tout fonctionne bien.

Donne lui le comportement “déplacer vers”. 


Dans la feuille d’événements :

Crée un premier événement.
En condition : Système => Toutes les X secondes => fais le réglages de ton choix. Commence avec une petite valeur pour faire test tests.

En action : Sprite de Tortue => (Déplacer vers) Déplacer vers la position.
Ici tu vas avoir besoin d’une expression pour déterminer la position en X et en Y. 

Le but sera que ton sprite apparaisse à une position aléatoire en X et en Y dans ta scène.

Tu vas donc avoir besoin de l’expression aléatoire : random. En paramètre de cette expression tu vas rentrer 0, puis la taille de ta scène. Répète l’opération pour X et Y. Tu devrais avoir quelque chose comme ceci : 

Crée un second événement.
En condition : Système => Toutes les X secondes => fais le réglages de ton choix. 

/!\ pour cette seconde condition, mieux vaut mettre un réglage plus petit que celui de ta première condition.

En 2e condition : Sprite de tortue => est en train de chevaucher un autre objet : l’objet que tu vas créer
Cette condition permettra de s’assurer que la tortue ne crée pas des sprites les uns sur les autres. Pour cela il faudra inverser ta condition. Une fois que tu l’as créé clic droit => inverser

Ajoute enfin une action : Sprite de tortue => Faire apparaître un autre objet => l’objet que tu vas créer.

Pour que ta tortue ne fasse pas apparaître des sprites qui se superposent, pense à la rendre un peu plus grande que le sprite que tu veux faire apparaître sur ta scène.

 => du haut vers le bas (façon tetris / space invader)

Le concept :

Des sprites en haut de la scène font apparaître des sprites qui tombent. 

Sur ta scène :

Crée un sprite qui va servir de point d’apparition. Donne lui une couleur bien visible. Tu lui enlèveras l’option “initialement visible” dans ses propriétés quand tu auras vérifié que tout fonctionne bien.

Dans l’éditeur de sprite, positionne l’origine de ton sprite en haut à gauche. Fais un clique droit sur l’origine => assigner rapidement =>  Haut gauche.
Comme tu vas utiliser la grille pour placer facilement tes sprites de points d’apparition, en mettant l’origine en haut à gauche tes sprites se placeront d’eux-même sur ta grille. 

Ajoute un second point d’image à ton sprite. Celui-ci doit être au centre, il servira pour faire apparaître les sprites. 

Pense à activer la grille de ta scène et règle là pour qu’elle fasse la même taille que ton sprite. Active l’option aligner sur la grille. Cela t’aidera à le placer facilement.

Place ton sprite sur la grille. Tu peux le dupliquer en maintenant la touche “contrôle” (ctrl) pour avoir autant de point d’apparition que nécessaire. 

Assure toi que tu as aussi créer le sprite que tu veux faire apparaître. Donne-lui les comportements / propriétés nécessaires pour ton jeu. 

Idéalement si tu veux que ton sprite descende tout seul vers le bas, donne lui au moins le comportement projectile. Désactive l’orientation automatique dans ses propriétés si tu ne veux pas qu’il tourne en fonction de l’angle donné par son comportement de projectile. Pense à régler la vitesse du projectile selon les besoins de ton jeu. 


Dans la feuille d’événements :

Si tu veux que tous tes points d’apparition créer des sprites tous en même temps suit les étapes ci-dessous.
Si tu veux faire apparaitre un seul sprite à la fois, suit les étapes ci-dessous et ajoute le bonus juste après.

Crée un événement.
En condition : Système => Toutes les X secondes => 0.2

En action : Sprite Spawner => faire apparaître un objet => sprite à faire apparaître

En action : Sprite à faire apparaître => (projectile) définir l’angle => 90 

Cette seconde action va permettre au sprite de descendre vers le bas de la scène. 

Pour n’avoir qu’un seul spawner actif à la fois :

Ajoute cette condition à ton événement : Système => (Sélectionner les instances)
Sélectionner une instance aléatoire => Choisi le sprite de ton point d’apparition.

Projeter / Lancer

pré-requis : un jeu avec de la physique

Le concept :

Utiliser la physique et le comportement Glisser Déposer pour projeter un objet

Sur ta scène :

Un sprite à projeter qui a les comportements “Physique” et “Glisser Déposer”.


Dans la feuille d’événements :

Crée un événement.
En condition : Sprite à lancer => (GlisserDéposer) Au dépôt 

En action : Sprite à lancer => (Physique : Forces) Appliquer une impulsion à l’angle

Ici tu vas devoir mettre plusieurs expression.
Le but c’est qu’au moment où on lâche le sprite, on transfert une partie de la vitesse à laquelle on le déplaçait dans une impulsion sur ce sprite. Pour cela il va falloir détecter la vitesse du toucher.Commence par chercher l’expression Toucher => (Toucher) VitesseA

Une fois choisie, tu auras un paramètre entre parenthèses en rouge pour l’Index.
Il faut préciser la vitesse de quel toucher on veut utiliser. Construct distingue les toucher en leur donnant un index. Tu vas utiliser une 2e expression qui détecte automatiquement le toucher actuel. 

Dans la parenthèse remplace Index par cette expression :

Toucher => (Toucher) IndexToucher

Tu auras deux expressions imbriquées comme ceci. 

Ensuite, il faut régler l’angle de l’impulsion.
À nouveau il va falloir imbriquer deux expressions. Commence par trouver l’expression qui détecte l’angle du toucher :
Toucher => (Toucher) AngleA

Puis à nouveau, remplace ‘Index’ par une expression :
Toucher => (Toucher) IndexToucher

Lance ton jeu et teste. 

Il est possible que la vitesse de projection soit très forte. Pour cela, retourne dans ta feuille d’événements.
Modifie simplement l’expression de ton impulsion en divisant la vitesse par un nombre (ici 10). Tu peux ainsi affiner le réglage de ton impulsion en fonction de tes besoins.

Diriger en tapant sur l’écran

pré-requis : cette ressource est pensé pour un jeu diriger au Toucher, donc adapté pour du jeu mobile/tablette

Le concept :

Avoir une manette virtuelle sur l’écran pour déplacer son personnage

Sur ta scène :

Dans les calques de ta scène ajoute un nouveau calques : clic droit “ajouter un calque en haut”. Renomme le (manette par exemple).
Ce calque va venir se superposer à ta scène de jeu. C’est un peu un calque pour mettre ton HUD (c’est-à-dire des éléments visuels de l’interface). 

Pendant que tu crée et utilise ton calque de manette, pense à verrouiller le calque principal de ton jeu. Pour cela clique sur le cadenas devant le nom du calque pour qu’il soit noir. 

Tu peux éventuellement rendre ton calque de jeu invisible temporairement pour te concentrer sur le calque où tu vas mettre en place ta manette. Pour cela, décoche la case bleu devant le nom de ton calque principal. 

Note : si tu lance ton jeu, le calque sera bien visible. Cette méthode pour faire disparaître les calques ne concerne que la vue de la scène dans l’éditeur du jeu et pas dans l’aperçu du jeu.

Créer des sprites pour faire les boutons de ta manette et place-les dans ta fenêtre de jeu là où tu voudrais qu’il soit sur l’écran. Pense à bien renommer tes sprites (par exemple “Manette_Haut”).
Ici, je vais créer 4 sprites pour faire des flèches directionnelles.

Ajoute le comportement “Ancre” à tes sprites de boutons de manette. 

Note : si tu utilises la version payante de Construct, tu peux créer une famille manette et donner le comporte Ancre à cette famille directement. Ainsi tous tes sprites auront ce comportement. 

Une fois que tes sprites de manettes sont bien positionnés, verrouille ton calque pour ne plus y toucher accidentellement. (et si besoin déverouille ton calque de jeu).

Avant de passer aux événement, assure toi que ton personnage a un comportement de déplacement (8-direction/plateformer..) et vérifie que tu as désactiver l’option “Contrôles par défaut” dans les propriétés de ce comportement. 

Dans la feuille d’événements :

L’objectif ici va être de créer un événement pour chaque bouton de manette afin d’y associer une action de contrôle du personnage.

Crée un événement.
En condition : Toucher => Est en train de toucher un objet => un de tes boutons de manette
En action : Sprite du personnage => simuler un contrôle => le contrôle qui t’intéresse.

Ici, tu as un exemple pour un personnage en 8 direction et sa touche vers le haut.

Ensuite, tu n’as plus qu’à dupliquer tes événements et les ajuster en fonction de tes contrôles.

Faire rebondir une balle/un projectile

Le concept :

Ton projectile ne sort pas de la scène et rebondi

Sur ta scène :

Vérifie que tu as un sprite de balle avec le comportement projectile. Dans les propriétés du comportement projectile, active l’option “Rebondi sur les solides”.

Ajoute un sprite solide (que tu pourras rendre invisible plus tard) sur les bords de ta scène. 

Félicitation ton projectile est prêt.

Si tu utilises un sprite pour “taper” dans ta balle, ou la faire rebondir (comme dans Pong, ou le casse-brique) par exemple, il y a une dernière astuce que tu peux utiliser. 

Par défaut, l’angle de rebond de ta balle sur ta “raquette” pourrait être un peu ennuyeux (repartir toujours en ligne droite). Pour arranger ça tu peux modifier légèrement la boite de collision de ton sprite.
Modifie la boite de collision de ton sprite sur le côté de la “raquette” contre lequel ta balle va venir rebondir, de sorte que les extrémités de ce côté ai une boite de collision plus “petite” que ce qu’on voit (cf screenshot)

Manger / devenir de plus en plus grand

Le concept :

Ton sprite devient de plus en plus grand à mesure qu’il a “mangé” d’autres sprites.

Sur ta scène :

Assure toi d’avoir un sprite “mangeur” et un ou plusieurs sprites qui seront “mangés”.

Si tu as plusieurs sprites différents qui seront “mangé” et que tu es sur la version payante de Construct, tu peux les regrouper dans une famille pour simplifier ton code. Pense à renommer cette famille.


Dans la feuille d’événements :

Crée un événement.
En condition : Sprite Mangeur => Lors de la collision avec un objet => Sprite Mangé

/!\ si tu utilises une famille, remplace “Sprite Mangé” par la famille des sprites mangés pour tout l’événement.

En action : Sprite Mangeur => Définir la taille
Ici tu vas avoir besoin de faire deux expressions. Le but c’est que la taille du sprite mangeur augmente en fonction de la taille du sprite mangé. Ainsi si on mange un gros sprite on grandit plus qu’en mangeant un petit sprite. 

Pour cela cherche une première expression liée au sprite mangeur :
Sprite mangeur => (Taille et position) Largeur 
Ici on récupère la Largeur actuel de notre sprite.

Tu vas maintenant lui ajouter la largeur du sprite mangé.
Ajoute un “+” après ta première expression, puis cherche une expression liée à ton sprite mangé :

Sprite Mangé  => (Taille et position) Largeur

Fais de même avec la hauteur en cherchant d’abord la hauteur du sprite mangeur puis en lui ajoutant la hauteur du sprite mangé.

Note si tu veux que la croissance de ton sprite mangeur soit un peu plus lente tu peux diviser la largeur et la hauteur du sprite mangé comme ceci :