No Mods

[Outil] Gunivers-Lib [1.12]

[Outil] Gunivers-Lib [1.12]
5(100%) 6 votes

  • Auteur : Gunivers
  • Version : 1.12-4

Lien Original

La réputation de l’équipe de mapmaking Gunivers n’est glus à faire, elle qui s’est illustrée à travers des maps comme Witchery, Slide et Hierarchy. Ses membres ont décidé de partager quelques-unes de leurs techniques dans une librairie tout simplement monstrueuse, qui permet de simplifier grandement la vie aux mapmakers. L’idée est d’utiliser des fonctions pour faciliter la création de mécaniques de jeu, notamment dans le cas de maps PVP. Cette librairie, sobrement intitulée Gunivers-Lib, s’inscrit dans un contexte plus global de publication par Gunivers d’outils destinés à la communauté mapmaking, puisqu’elle suit LGdir et Command Syntax Helper.

Fonctionnement

Chaque fonction remplit une tâche particulière, utile dans le cadre de la conception de systèmes de command blocks, tout particulièrement en mapmaking. Par exemple, l’une de ces fonctions permet de résoudre un tas d’opérations mathématiques, ce qui ouvre un large champ de possibilités. Il ne s’agit là que d’une seule fonction, l’une des plus simples, mais elle permet de se rendre compte du potentiel de cet outil.

Le fonctionnement de chaque fonction suit globalement un principe similaire, comme celui des fonctions que vous avez pu étudier au collège et au lycée. Chacune nécessite des prérequis, qui sont des systèmes ou scoreboards à mettre en place, une ou plusieurs valeurs entrées (inputs) qui doivent parfois elles-mêmes répondre à des critères précis. La fonction ressort ensuite une ou plusieurs valeurs (outputs). Dans le cas d’une fonction mathématique calculant le cosinus d’un angle, l’input est la valeur d’un angle en degrés, donc entre 0 et 360, tandis que l’output sera la valeur du cosinus de cet angle.

Pour vous rendre compte de ce fonctionnement autant que pour voir les merveilles dont Gunivers-Lib est capable, plusieurs systèmes de fonctions sont prêts à l’emploi dans le dossier “Systems”, par exemple un aimbot.

Liste des fonctions

L’idée de ces fonctions est d’effectuer différents calculs, de l’addition à la racine carrée en passant par la multiplication et le cosinus. Ici, l’input est soit la valeur de l’angle avec lequel vous travaillez (dans le cas d’un cosinus, par exemple), soit les valeurs que vous souhaitez multiplier, additionner, etc. Voici les différentes fonctions disponibles. Si vous voulez les manipuler, elles se trouvent dans le répertoire “Math”. Pour toutes ces fonctions, l’output est géré par un scoreboard dummy que vous devrez créer et appeler Res. Les inputs, de même, seront pris en charge par les scoreboards dummy Tmp1 et Tmp2 s’il y a deux inputs.

  • Cos : vous permet de calculer le cosinus d’un angle.
    • Prérequis : dummy scoreboards Tmp1, Tmp 2, Tmp3, Constant et Res ;
    • Input : Tmp1 (en degrés, entre 0 et 360) ;
    • Output : Res (résultat multiplié par 1000 pour obtenir les décimales)..
  • Sin : vous permet de calculer le sinus d’un angle.
    • Prérequis : dummy scoreboards Tmp1, Tmp 2, Tmp3 et Res ;
    • Input : Tmp1 (en degrés, entre 0 et 360);
    • Output : Res (résultat multiplié par 1000 pour obtenir les décimales).
  • Tan : vous permet de calculer la tangente d’un angle.
    • Prérequis : dummy scoreboards Tmp1, Tmp 2, Tmp3, Tmp4, Constant et Res ;
    • Input : Tmp1 (en degrés, entre 0 et 360);
    • Output : Res (résultat multiplié par 1000 pour obtenir les décimales).
  • Arccos : vous permet d’obtenir un angle à partir d’un cosinus.
    • Prérequis : dummy scoreboards Tmp1, Tmp2 et Res ;
    • Input : Tmp1 (la valeur de base doit être multipliée par 1000 pour prendre en compte les décimales);
    • Output : Res.
  • Arcsin : vous permet d’obtenir un angle à partir d’un sinus.
    • Prérequis : dummy scoreboards Tmp1, Tmp2 et Res ;
    • Input : Tmp1 (la valeur de base doit être multipliée par 1000 pour prendre en compte les décimales) ;
    • Output : Res.
  • Arctan : vous permet d’obtenir un angle à partir d’une tangente.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, Tmp3 et Res ;
    • Input : Tmp1 (la valeur de base doit être multipliée par 1000 pour prendre en compte les décimales) ;
    • Output : Res.
  • Divide : vous permet d’effectuer une division de nombres entiers, arrondie à l’entier le plus proche.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, Tmp3 et Res ;
    • Input : Tmp1 (diviseur) et Tmp2 (dividende) ;
    • Output : Res.
  • Factorial : vous permet d’obtenir le factoriel d’un nombre entier. Attention : au-delà de 12, les résultats sont si importants qu’ils ne sont plus pris en charge par le jeu, qui donnera un résultat faux.
    • Prérequis : dummy scoreboards Tmp1, Tmp2 et Res ;
    • Input : Tmp1 (compris entre 0 et 12) ;
    • Output : Res.
  • Pow : vous permet d’obtenir la puissance d’un nombre entier.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, Tmp3 et Res ;
    • Input : Tmp1 (nombre) et Tmp2 (exposant) ;
    • Output : Res.
  • Sqrt : vous permet d’obtenir la racine carrée d’un nombre entier.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, Tmp3, Tmp4, Tmp5 et Res ;
    • Input : Tmp1 ;
    • Output : Res.
  • GCD : vous permet d’obtenir le PGCD de deux nombres entiers.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, Tmp3, Tmp4, Tmp5 et Res ;
    • Input : Tmp1 et Tmp2 ;
    • Output : Res.

Cette fonction vous permet de gérer la vie d’un joueur via un scoreboard. Notez bien que cette fonction nécessite de repenser complètement les systèmes de poison, régénération et absorption présents antérieurement dans la map si vous voulez que la fonction s’intègre dans vos systèmes.

La gestion de ce nouveau système de points de vie passe par la fonction set, que vous pouvez retrouver dans le répertoire global du système, Entity/Health. Elle doit être exécutée en boucle, à chaque tick.

  • Advanced : vous permet de définir la vie d’un joueur.
    • Prérequis : dummy scoreboard Health, health scoreboard HealthRead ;
    • Input : Health ;
    • Output : Health.

Cet ensemble de fonctions permet de gérer les UID d’entités, et donc de les identifier précisément, ce qui est particulièrement utile dans le cas d’une map avec beaucoup de projectiles. Les trois fonctions qui y sont associées et que vous allez manipuler se trouvent dans le répertoire global du système, Entity/Id.

  • GetSUID (Simple Unique ID) : permet à l’entité exécutant la fonction d’obtenir un score ID qui s’incrémente de 1 chaque fois qu’une nouvelle ID est attribuée : 1 pour la première, 2 pour la deuxième, etc..
    • Prérequis : score ID ;
    • Input : /
    • Output : ID.
  • GetCUID (Chain Unique ID) : permet à l’entité exécutant la fonction d’obtenir un score ID différent de celui de toutes les autres entités ayant déjà exécuté la fonction. Contrairement au SUID, le CUID est dynamique et veille à ce que chaque ID forme une chaîne ininterrompue, sans trou. Autrement dit, les scores ID attribués seront 1, 2, 3, 4 et 5, puis, si jamais l’entité liée au score ID 3 disparaît, celle qui avait le score 4 ID prend sa place et celle qui avait le score ID 5 prend elle-même la place de cette dernière. Comme ce système est dynamique, la fonction Update-CUID doit être exécutée en boucle.
    • Prérequis : score ID ;
    • Input : /
    • Output : CUID.
  • Check : permet de comparer le score ID des entités avec le score TargetID de l’entité ayant exécuté la fonction. Elle reçoit le tag IdChecker. Ensuite, les entités ayant un score ID recevront le tag IdUpper, IdLower ou IdMatch selon si leur score ID est respectivement supérieur, inférieur ou égal au TargetID.
    • Prérequis : score ID et score TargetID ;
    • Input : TargetID ;
    • Output : tags IdMatch, IdUpper, IdLower.

Ce système permet de manipuler plus facilement les inventaires des joueurs grâce à deux fonctions de détection, qui détectent le slot actif du joueur ainsi que la présence ou non d’un objet dans sa main secondaire. Une application concrète de ce second système serait par exemple de créer des armes uniquement maniables à deux mains qui empêcheraient de tenir autre chose avec la deuxième main du joueur. Vous pouvez jeter un oeil à ces fonctions dans le répertoire Entity/Inventory.

  • ActiveSlot : permet de connaître le slot actif dans la hotbar du joueur et renvoie un chiffre entre 0 (pour le premier slot) et 8 (pour le dernier slot).
    • Prérequis : dummy scoreboard getActiveSlot ;
    • Input : /
    • Output : getActiveSlot.
  • IsOffHand : permet de savoir si le joueur a quelque chose dans sa main secondaire. Si c’est le cas, il reçoit le tag IsOffHand
    • Prérequis : / ;
    • Input : /
    • Output : IsOffHand (tag).

Comme le nom de l’onglet l’indique, ces fonctions permettent de gérer les localisations des entités grâce aux scores. Il est ainsi possible de connaître leur position absolue, mais aussi relative par rapport à d’autres entités. Des outils de mesure multiples, donc, aux usages variés. Les fonctions associées se trouvent dans le répertoire Entity/Location.

  • Get : permet d’obtenir la position d’une entité en stockant ses coordonnées sur les trois scores en Output.
    • Prérequis : dummy scoreboards Phi et Theta ;
    • Input : /
    • Ouput : dummy scores LocX, LocY et LocZ.
  • GetDistanceToTargetID : calcule la distance en blocs entre l’entité exécutant la fonction et celle possédant l’ID visé.
    • Prérequis : dummy scoreboards VectorX, VectorY, VectorZ, LocX, LocY, LocZ, TargetID ;
    • Input : TargetID (ID de l’entité ciblée), les scores LocX, LocY et LocZ doivent être définis pour les deux entités ;
    • Ouput : Res.
  • RelativeTargetID : dans la même optique, cette fonction donne la position relative de l’entité exécutant la fonction par rapport à l’entité ayant l’ID ciblée.
    • Prérequis : dummy scoreboards LocX, LocY, LocZ et TargetID ;
    • Input : TargetID, les scores LocX, LocY et LocZ doivent être définis pour les deux entités ;
    • Ouput : LocX, LocY, LocZ.
  • Set : permet de placer une entité à des coordonnées précises données via un scoreboard, permettant ainsi d’utiliser les fonctions ci-dessus.
    • Prérequis : dummy scoreboards LocX, LocY, LocZ ;
    • Input : LocX, LocY, LocZ ;
    • Ouput : /
  • Biome : détecte le biome dans lequel se trouve l’entité et stocke l’information dans un dummy score dont le chiffre dépend du biome en question.
    • Prérequis : dummy scoreboards LocX, LocY, LocZ ;
    • Input : LocX, LocY, LocZ ;
    • Ouput : /

Correspondance chiffre <=> biome

  • 0 : Ocean
  • 1 : Plains
  • 2 : Desert
  • 3 : Extreme Hills
  • 4 : Forest
  • 5 : Taiga
  • 6 : Swampland
  • 7 : River
  • 8 : Hell
  • 9 : The End
  • 10 : FrozenOcean
  • 11 : FrozenRiver
  • 12 : Ice Plains
  • 13 : Ice Mountains
  • 14 : MushroomIsland
  • 15 : MushroomIslandShore
  • 16 : Beach
  • 17 : DesertHills
  • 18 : ForestHills
  • 19 : TaigaHills
  • 20 : Extreme Hills Edge
  • 21 : Jungle
  • 22 : JungleHills
  • 23 : JungleEdge
  • 24 : Deep Ocean
  • 25 : Stone Beach
  • 26 : Cold Beach
  • 27 : Birch Forest
  • 28 : Birch Forest Hills
  • 29 : Roofed Forest
  • 30 : Cold Taiga
  • 31 : Cold Taiga Hills
  • 32 : Mega Taiga
  • 33 : Mega Taiga Hills
  • 34 : Extreme Hills+
  • 35 : Savanna
  • 36 : Savanna Plateau
  • 37 : Mesa
  • 38 : Mesa Plateau F
  • 39 : Mesa Plateau
  • 127 : The Void
  • 129 : Sunflower Plains
  • 130 : Desert M
  • 131 : Extreme Hills M
  • 132 : Flower Forest
  • 133 : Taiga M
  • 134 : Swampland M
  • 140 : Ice Plains Spikes
  • 149 : Jungle M
  • 151 : JungleEdge M
  • 155 : Birch Forest M
  • 156 : Birch Forest Hills M
  • 157 : Roofed Forest M
  • 158 : Cold Taiga M
  • 160 : Mega Spruce Taiga
  • 161 : Redwood Taiga Hills M
  • 162 : Extreme Hills+ M
  • 163 : Savanna M
  • 164 : Savanna Plateau M
  • 165 : Mesa (Bryce)
  • 166 : Mesa Plateau F M
  • 167 : Mesa Plateau M

Un peu comme pour les fonctions de localisation, celles-ci s’intéressent à l’orientation d’une entité, donc la direction qu’elle regarde. Elles sont donc au coeur d’un éventuel système de gestion des projectiles. Vous pouvez retrouver les fonctions associées dans le répertoire Entity/Orientation.

  • Get : détecte l’orientation d’une entité selon les angles formés sur les plans horizontal et vertical, qui sont stockés sur les scores Phi et Theta respectivement.
    • Prérequis : dummy scoreboards Phi et Theta ;
    • Input : /
    • Output : Phi et Theta.
  • Set : permet d’orienter une unité selon les scores Phi et Theta.
    • Prérequis : dummy scoreboards Phi, Theta, Tmp1, Tmp2 ;
    • Input : dummy scoreboards Phi, Theta, Tmp1, Tmp2 ;
    • Output : /
  • GetPhiByVector : vous permet d’obtenir l’angle Phi du vecteur de l’entité.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, VectorX, Vector Z, Phi ;
    • Input : VectorX, VectorZ ;
    • Output : Phi.
  • GetThetaByVector : vous permet d’obtenir l’angle Theta du vecteur de l’entité.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, VectorY, Res, Theta ;
    • Input : VectorY ;
    • Output : Theta.
  • Move : vous permet de faire bouger l’orientation d’une entité à partir d’un vecteur.
    • Prérequis : dummy scoreboards Tmp1, Tmp2, VectorPhi, VectorTheta ;
    • Input : VectorPhi, VectorTheta ;
    • Output : /
  • RelativeToTargetID : permet de calculer la différence d’orientation entre l’entité exécutant la fonction et celle ciblée par son ID.
    • Prérequis : dummy scoreboards Phi, Theta, ID, TargetID ;
    • Input : Theta et Phi pour les deux entités, TargetID ;
    • Output : Phi, Theta.

Il sera ici question de vecteurs, qui définissent la trajectoire d’une entité. Ils permettent ainsi de gérer les collisions, et de créer toutes sortes de forces physiques : gravité, vent…

  • GetByOrientation : calcule le vecteur de l’entité selon son orientation, donc en fonction de Phi et Theta. Ce vecteur est composé de trois vecteurs élémentaires compris entre -1000 et 1000 et (VectorX, VectorY, VectorZ) et d’un coefficient de vitesse VectorSpeed (1000 <=> 1 bloc/tick).
    • Prérequis : dummy scoreboards Phi, Theta, VectorX, VectorY, VectorZ, VectorSpeed ;
    • Input : Phi, Theta ;
    • Output : VectorX, Vector Y, VectorZ, VectorSpeed.
  • GetByTargetID : calcule un vecteur entre l’entité exécutant la fonction et une entité cible, qui est l’entité la plus proche ayant un score ID égal au score TargetID de la source.
    • Prérequis : dummy scoreboards LocX, LocY, LocZ, ID et TargetID ;
    • Input : pour la source : LocX, LocY, LocZ, TargetID. Pour la cible : LocX, LocY, Locz, ID ;
    • Output : VectorX, VectorY, VectorZ.
  • RelativeToTargetID : permet d’obtenir le vecteur d’éloignement entre deux entités, selon un principe de détection similaire à celui décrit ci-dessus.
    • Prérequis : dummy scoreboards VectorX, VectorY, VectorZ, TargetID ;
    • Input : VectorX, VectorY et VectorZ pour les deux entités, TargetID pour la source ;
    • Output : VectorX, VectorY, VectorZ.
  • Addition : calcule la somme de deux vecteurs.
    • Prérequis : dummy scoreboards VectorX, vectorY, VectorZ, Tmp1, Tmp2, Tmp3, Tmp4, Tmp5 ;
    • Input : VectorX, VectorY, VectorZ, Tmp1 (second VectorX), Tmp2 (second VectorY), tmp3 (second VectorZ), Tmp4 (coefficient du premier vecteur), Tmp5 (coefficient du second vecteur) ;
    • Output : VectorX, VectorY, VectorZ.
  • GetLength : calcule la longueur d’un vecteur.
    • Prérequis : dummy scoreboards VectorX, VectorY, VectorZ, Tmp1, Res ;
    • Input : VectorX, VectorY, VectorZ ;
    • Output : Res.
  • Normalize : permet de “normaliser” la valeur d’un vecteur. Concrètement, cela signifie que les valeurs de VectorX, de VectorY et de VectorZ seront comprises dans l’intervalle [-Tmp1 ; Tmp1].
    • Prérequis : dummy scoreboards VectorX, VectorY, VectorZ, Tmp1 ;
    • Input : VectorX, VectorY, VectorZ, Tmp1 (paramètre) ;
    • Output : VectorX, VectorY, VectorZ.
  • Move : permet de faire se déplacer des entités grâce à leur vecteur. Un vecteur de 1000 entraînera le déplacement d’un bloc selon un axe donné.
    • Prérequis : dummy scoreboards VectorX, VectorY, VectorZ, VectorSpeed ;
    • Input : VectorX, VectorY, VectorZ, VectorSpeed ;
    • Output : /

Dans ce dernier onglet, il ne sera pas question de fonctions à proprement parler, mais plutôt de trois fichiers texte que vous pourrez trouver dans le répertoire Utils/Lists.

Chaque fichier contient la liste de toutes les entités, de tous les items et de toutes les stats de Minecraft.

Téléchargement

[1.12] Gunivers-Lib

Installation (IMPORTANT)

Téléchargez le fichier. Puis trouvez votre dossier .minecraft :

Windows : Allez dans le menu Démarrer, puis rendez-vous dans Exécuter. Sinon, faites Touche Windows + R. Ensuite, tapez %appdata% dans la barre de recherche, puis allez dans le dossier .minecraft.
Linux : Appuyez en même temps sur ALT + F2. Vous devriez normalement avoir votre .minecraft.
Si vous ne le voyez pas, activez les dossiers cachés avec la combinaison CTRL + H.
Mac : Votre dossier minecraft se trouve dans Utilisateur > Bibliothèque > Application Support.
Si vous ne trouvez pas Application Support, faites Finder > Barre des menus : Aller + Maintenir ALT > Bibliothèque.

Ensuite, trouvez le dossier “saves” qui s’y trouve, puis cliquez sur le sous-dossier correspondant à la map sur laquelle vous souhaitez déployer Gunivers-Lib. Allez ensuite dans “data” et déposez le fichier dans “functions”. Allez dans le dossier “Gunivers-Lib” fraîchement déposé, puis trouvez-y Advancements/Biome et glissez tout le contenu de ce sous-dossier dans “Advancements” du sous-dossier “Advancements” de “data”.

Pour éviter de vous soucier des prérequis des fonctions de Gunivers-Lib, vous pouvez d’ores et déjà exécuter l’intégralité des fonctions contenues dans le dossier Utils/Import, qui créera automatiquement tous les scoreboards nécessaires.

Image de Une réalisée par ClairElite.

Tags

SpookyPowa

Knowledge is Power !

Article similaire

6 Commentaires

  1. Merci Yodi :)

    NeX, pour le dire autrement:
    Chaque fonction utilise des éléments du jeu, la plupart du temps, il s’agit d’objectifs de scoreboards (mais des fois il peut s’agir d’autres choses, comme des advancements).

    Ensuite, certaines fonctions necessitent des valeurs d’entrées. Pour reprendre l’article, une fonction cosinus aura besoin d’une valeur comprise entre 0 et 360 (un angle) pour fonctionner correctement. Il faut donc que l’objectif soit créé et que la valeur d’entrée (donc l’angle), soit bien initialisé.
    La fonction va également utiliser une objectif pour pouvoir stocker le résultat (dans le cas de la fonction Cosinus, elle utilisera le score nommé “Res”. Il faut donc que ce score soit lui aussi créé.

    N’hésite pas à aller sur le lien original (notre site), il se peut que les informations complètent cet article (et réciproquement) ;)

  2. NeX_BloodSword77 Salut, je suis un des développeurs de la lib.
    Ce qu’il veut dire par la, c’est que les fonctions ont (pour la plupart) besoin de scoreboards déjà créés pour fonctionner, ainsi que de valeurs d’entrée pour faire leurs calculs. Une fonction qui calcule le Cosinus d’un angle aura donc besoin de certains objectifs pour stocker des valeurs temporaires utiles au calcul, ainsi que de Res, l’objectif sur lequel tu récupère ton résultat, et d’une valeur d’entrée (l’angle en question, que tu rentres sur Tmp1 et qui doit se trouver dans [0;360]).

    Donc pour calculer ton cosinus tu fait
    /scoreboard players set @p Tmp1 45 (ou une autre valeur)
    /function Gunivers-Lib:Math/Cos

    Et ton résultat sera automatiquement placé sur Res :)

    PS: pour ajouter tous les objectifs rapidement, exécute toutes les fonctions présentes dans Utils/Import

  3. “Chacune nécessite des prérequis, qui sont des systèmes ou scoreboards à mettre en place, une ou plusieurs valeurs entrées (inputs) qui doivent parfois elles-mêmes répondre à des critères précis.” (partie Fonctionnements)

    On m’explique ?

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Close
Close