4rno

Bonjour, personnellement, étant dans un cas semblable au tien, j'utilise le plugin Multiverse-Core, qui permet d'utiliser plusieurs maps sur un serveur.Il permet aussi de décharger (ou directement supprimer) des maps. Ensuite je copie une backup de la map et je réimporte la map. Malheureusement, je ne sais pas si cela fonctionnera avec le monde end du monde par défaut ("world_the_end" par exemple); si j'essaie de décharger le monde par défaut "world", il me met une erreur. Cependant, tu pourrais contourner cela en utilisant justement des mondes différents pour l'end, les ressources et le nether; faudrait juste un peu bidouiller lors de la téléportation ;)

if {testSiTeamMate2} is false: set {_ok} to true if {testSiTeamMate1} is false: set {_ok} to true if {_ok} is true: #Ton code

@LavaPower Merci ^^ Je craignais que ce soit un poil trop complexe pour les débutants, mais j'ai effectivement mis les spoilers en tant qu'aides/explications :) Heureux que ça soit si bien accueilli sur le forum ! Je ne souhaite pas créer de tutos "basiques" -sans mécanismes très complexes- (genre "Comment faire un SkyWars"), je n'y vois (personnellement) aucun intérêt (à part lorsque l'on débute de l'initiation du commencement de l'apprentissage de Skript xD); je préfère expliquer des mécanismes plus compliqués, de sorte à montrer non pas un code prêt à l'emploi, mais bien la logique qu'il y a derrière ! C'est d'ailleurs pour cela que je ne vais, sur ce tutoriel, pas "fignoler" le travail (en enregistrant par exemple les métas-datas ou les nbt des blocs). Par contre, je pense prochainement faire un tuto sur les variables listes, car j'ai l'impression que relativement peu de gens comprennent vraiment comment elles fonctionnent (comme des variables normales ,mais organisées, en fait !).

@Protoxy @iLaZz Merci :) Mais la grande question est: "Est ce que mon tuto est (facilement) compréhensible ?" !

Merci ! :) @WilliamEzzz Parce qu'il y a moyen de faire plus compliqué ! :O Les fichiers .shematic, par exemple, n'enregistre pas la position du bloc, mais sauvegarde les dimensions de la structure, et puis enregistre les blocs un à un dans un ordre précis. Cependant, ça aurait alors été beaucoup plus compliqué pour mon 2e tutoriel.

Tutoriel du fonctionnement de base de Sk-schematic disponible ici :[Contenu masqué] "Épisode" 2 (encore à intégrer à SK-schematic) : [Contenu masqué] EDIT: Je vais travailler pour pouvoir utiliser des vrais .schematics ! C'est possible !

Bienvenue dans le 2e épisode de Sktructure ! Si vous n'avez pas suivi le 1e épisode, je vous le conseille fortement, sinon vous ne comprendrez pas grand chose ([Contenu masqué]) ! Cette fois ci, nous allons apprendre à effectuer des rotations (de 90°) et des symétries à nos structures qui ont étés préalablement enregistrées ! Les 2 manipulations sont en réalité relativement similaires. /!\Ce tutoriel est relativement... mathématique, cependant, j'ai essayé de simplifier les explications au maximum -Symétrie orthogonale- Vous devriez, j'espère, l'avoir déjà vu à l'école, la symétrie orthogonale, c'est quand on applique un effet "miroir" sur une figure ou autre. comme ceci: [spoiler=Exemple] Oh la belle symétrie ! Et bien si on applique cela dans un plan, voici ce que l'on obtient: Dans le cas ci dessus, on a effectué une symétrie orthogonale du triangle du dessus par rapport à l'axe X, ce qui a donné le triangle du dessous (appelé image). Ce que l'on peut remarquer, c'est, par exemple, le point A qui se situe en (1, 4) -donc de +1 sur l'axe X et +4 sur l'axe Y- se retrouve dans le triangle image (le résultat de la transformation, ici la symétrie) en (1,-4); on a juste pris l'opposé (on a mis le signe moins (-) devant si vous voulez) de la coordonnée en Y. Et cela est vrai pour tous les points du triangle ! Si on applique une symétrie d'axe Y cette fois, ce n'est plus les coordonnées en Y qui changent, mais celles en X ! [spoiler=Eh ! Pourquoi le point C il est le même pour les 2 triangles ?]C'est tout simplement que C est en (0,1), et -0=0, donc le point C ne bouge effectivement pas ! On sait maintenant ce que l'on doit simplement calculer l'inverse de la coordonnée de l'axe de symétrie. Facile ! On va donc effectuer un "loop {sktruc::save::location::*}:" et y effectuer notre calcul sur l'axe de symétrie choisi. command /sktructuremirror <text>: trigger: if arg-1 is "x" or "y" or "z": loop {sktruc::save::location::*}: if arg-1 is "x": set x-coordinate of {sktruc::save::location::%loop-index%} to 0 - x-coordinate of loop-value if arg-1 is "y": set y-coordinate of {sktruc::save::location::%loop-index%} to 0 - y-coordinate of loop-value if arg-1 is "z": set z-coordinate of {sktruc::save::location::%loop-index%} to 0 - z-coordinate of loop-value send "Symétrie orthogonale d'axe %arg-1% appliquée avec succès" else: send "Erreur" [spoiler=Pourquoi tu fais 0 - x-coordinate ... Tu peux pas simplement faire - x-coordinate ?]Eh bien non, c'est une limitation de Skript (bien que ça revienne au même). Je pense que c'est dû au fait qu'il faut lui donner un "vrai" calcul à effectuer. [spoiler=Et {sktruc::save::blocks::*}, tu l'as oublié non ?]Absolument pas, c'est juste que étant donné que l'on réutilise le même index pour la nouvelle position du bloc, il n'y a pas besoin de l changer ! Et voilà ! C'est tout ! Avouez que ce n'était pas très compliqué ! Passons maintenant à la rotation, vous verrez que c'est un brin plus complexe ! -Rotation- Pour la rotation, au niveau géométrie, voici ce que ça donne, avec une rotation de 90° (dans le sens das aiguilles d'une montre) et de centre (0, 0): On peut constater que pour passer du point A (1, 4), à A'1 (4, -1) -l'apostrophe signifie "image"-, on a échangé les deux coordonnées, et ensuite pris l'opposé pour l'axe Y. Cela est vrai également pour les autres points du triangle. On peut donc dire que qu'un point (X, Y) qui a subit l'effet de notre rotation (centre en (0, 0) et de 90° dans le sens des aiguilles d'une montre) se retrouvera en (Y, -X) ! Dans notre cas, on va faire appel à une fonction, car sinon on devra répéter le même code pour les 3 axes. Voici le code de notre fonction, qui correspond à ce que l'on vient de constater juste au dessus: function rotatepoint(coord1: number, coord2: number, times: number) :: numbers: loop {_times} times: set {_coord1temp} to {_coord1} set {_coord1} to {_coord2} set {_coord2} to 0 - {_coord1temp} delete {_coord1temp} add {_coord1} to {_coords::*} add {_coord2} to {_coords::*} return {_coords::*} Alors pour répondre à vos questions, la raison du "loop x times" est que l'on ne va en réalité pas créer une fonction pour chaque rotation de 90° (90, 180, 270), on va donc simplement répéter la rotation de 90° pour obtenir une de 180° ou 270°.Et la raison d’existence de {_coord1temp} et que on réutilise {_coord1}, ça va bugger étant donné qu'on la déjà modifié ! À partir de là, on va utiliser "loop {sktruc::save::location::*}:"; on va ensuite, en fonction de l'axe choisi, utiliser notre fonction et enregistrer le résultat ! [spoiler=Voici le code complet de la rotation] function rotatepoint(coord1: number, coord2: number, times: number) :: numbers: loop {_times} times: set {_coord1temp} to {_coord1} set {_coord1} to {_coord2} set {_coord2} to 0 - {_coord1temp} delete {_coordtemp} add {_coord1} to {_coords::*} add {_coord2} to {_coords::*} return {_coords::*} command /sktructurerotate <text> <integer>: trigger: if arg-1 is "x" or "y" or "z": if arg-2 is divisible by 90: loop {sktruc::save::location::*}: if arg-1 is "x": set {_coords::*} to rotatepoint(y-coordinate of loop-value, z-coordinate of loop-value, arg-2 / 90) set {sktruc::save::location::%loop-index%} to location at (x-coordinate of loop-value, {_coords::1}, {_coords::2}) if arg-1 is "y": set {_coords::*} to rotatepoint(x-coordinate of loop-value, z-coordinate of loop-value, arg-2 / 90) set {sktruc::save::location::%loop-index%} to location at ({_coords::1}, y-coordinate of loop-value, {_coords::2}) if arg-1 is "z": set {_coords::*} to rotatepoint(x-coordinate of loop-value, y-coordinate of loop-value, arg-2 / 90) set {sktruc::save::location::%loop-index%} to location at ({_coords::1}, {_coords::2}, z-coordinate of loop-value) send "Rotation de %arg-2%° sur l'axe %arg-1% effectuée" else: send "Erreur" else: send "Erreur" -Résumé- Cette fois ci, nous avons vu comment modifier nos structures avec des rotations et symétries. Ce sont des transformations, cependant, la forme de notre structure reste inchangée. Qui sait, pourront nous un jour faire des réductions, agrandissements, déformations quelconques en Skript ! Suite: Sktructure #3: Génération de structures automatisée 4rno

Je viens d'essayer, mais malheureusement ce n'est pas cela :/ Les loop {_x2} - {_x1} + 1 times, c'est juste que j’intègre un calcul dans ma loop, et elle boucle autant de fois que le résultat de ce calcul. Cdlt, RebellCraft

Bonjour, Essayant (en vain) d'optimiser le code de mon tutoriel ([Contenu masqué]), je tombe sur une erreur... étrange... Voici le bout de code qui bug: loop {_x2} - {_x1} + 1 times: loop {_y2} - {_y1} + 1 times: loop {_z2} - {_z1} + 1 times: if {_count} is divisible by 500: send "Progression: %{_count}/(({_x2} - {_x1} + 1)*({_y2} - {_y1} + 1)*({_z2} - {_z1} + 1))*100% pourcents" add 1 to {_count} add location at (loop-integer-1-1, loop-integer-2-1, loop-value-3 -1) to {sktruc::save::location::*} add type of block at location at (loop-integer-1-1+{_x1}, loop-integer-2-1+{_y1}, loop-integer-3 -1+{_z1}) to {sktruc::save::block::*} Avec comme erreur: [ATTACH=full]4521[/ATTACH] J'ai essayé de mettre "loop-value-3", "loop-number-3", "loop-integer-3", mais rien n'y fait... J'ai aussi essayé avec d'autres syntaxes (pour le location) , avec et sans (), avec x: , y:, z:, sans, et toujours rien ... En essayant de me résigner, j'ai mis le z en variable locale, mais alors c'était les loop-value-2 qui buggaient ! Si vous avez une idée, n'hésitez pas à proposer...

Hello, ceci devrait convenir: On Store: if world of player is "Evolution": if target block of player is chest: if event-item is not nether star: cancel event Addon nécessaire: SkRayFall Cdlt, RebellCraft

Bonjour, Je vais vous présenter un petit système permettant de manipuler des structures avec comme seul outil Skript, sans shematic, WorldEdit ou autre ! Pour comprendre ce tutoriel, il vous faudra juste connaitre les bases de Skript. Alors, pour manipuler des structures (tri-dimensionnelles), il faudrait déjà pouvoir en sauvegarder ! Nous allons donc voir ici comment enregistrer des structures, et les "coller" par la suite ! -Sauvegarde- Comme dit plus haut, nos structures sont en trois dimensions, nous allons donc devoir, les "découper" en structure bi-dimensionnelles, puis uni-dimensionnelles, puis en "zéro"-dimension (un bloc quoi...) [spoiler=Help... J'ai rien compris !]C'est possible, et c'est pour répondre à cela que ce message est là ! Pour imager la situation, prenez un cube: Celui-ci a 3 dimensions, ce qui est compliqué à gérer. Nous allons donc le découper en tranches bi-dimensionnelles -en 2 dimensions-, avec autant de couches que de blocs dans la dimension dans laquelle nous avons tranché: Ensuite, nous allons encore découper cette surface pour obtenir des éléments uni-dimensionnelles -des lignes (de blocs) donc-, puis encore pour obtenir des blocs à l'unité. Quand nous aurons nos blocs à l'unité, alors à ce moment là nous pourrons sauvegarder leur état, position, ... Pour pouvoir "trancher" notre structure, nous allons utiliser des (3 en fait, vu que nous avons une structure tri-dimensionnelle) loop x times imbriquées, où le "x" correspond au nombre de couches composant notre structure. Voici le principe de fonctionnement du code: loop <x couches> times: loop <y couches> times: loop <z couches> times: #Ici on sauvegardera la position RELATIVE du bloc, ainsi que le bloc en lui-même [spoiler=Position relative ? Késako ?]Vous connaissez -j'espère- les coordonnées de Minecraft ? le X, le Y et le Z. Et bien lors de vos parties d'UHC où vous communiquez à vos amis ces nombres, ce sont en réalité les coordonnées ABSOLUES de votre position, c'est à dire que depuis n'importe où dans la map, on peut aisément se situer, ces coordonnées là ont comme origine le 0, 0, 0 de la map. Les coordonnés relatives, elles, ce serait plutôt comme dire 'Je me trouve 39 blocs à l'est, 6 blocs plus bas et 148 blocs au nord PAR RAPPORT à ta propre position". Les joueurs ayant beaucoup utilisés les blocs de commandes connaissent aussi les coordonnées relatives, le fameux tilde (~). Vous vous demandez peut-être aussi pourquoi nous avons besoin de coordonnées relatives et non absolues; la raison est simple: ici, nous ne souhaitons pas de coordonnées absolues car elles sont justement absolues ! Or, nous ne devons connaitre que le positionnement des blocs de la structure les uns par rapport aux autres. Pour connaitre la position relative d'un bloc, il me suffit maintenant de récupérer la loop-value-<1|2|3> des boucles ! Enfin, presque, un skripteur minutieux sait que la loop-value d'une boucle loop x times commence à partir de 1, or, moi je souhaite que le premier bloc soit en position relative 0, 0, 0. Il me faut donc soustraire 1 à mes loop-values. Voici le code actuel: loop <x couches> times: loop <y couches> times: loop <z couches> times: #On définis les coordonnés corrects par rapport aux loop-values set {_x} to "%loop-value-1%" parsed as number -1 set {_y} to "%loop-value-2%" parsed as number -1 set {_z} to "%loop-value-3%" parsed as number -1 Maintenant, nous allons compléter le début du code, histoire que ce soit clair dans vos têtes ! Pour connaitre la zone à enregistrer, nous avons besoin de seulement 2 coordonnées, de manière à former un parallélépipède rectangle. Pour rendre la sélection plus facile, on va sélectionner nos 2 coordonnées grâce à un item (ici une blaze rod) -à la manière de WorldEdit et de sa hache-. Voici le code que j'utilise: [spoiler=Code] on left click with blaze rod: If name of player's tool is "Sélection": if event-block is set: cancel event set {sktruc::sel1::x} to x-coordinate of event-block set {sktruc::sel1::y} to y-coordinate of event-block set {sktruc::sel1::z} to z-coordinate of event-block send "Point 1: %{sktruc::sel1::x}% %{sktruc::sel1::y}% %{sktruc::sel1::z}%" on right click with blaze rod: If name of player's tool is "Sélection": if event-block is set: cancel event set {sktruc::sel2::x} to x-coordinate of event-block set {sktruc::sel2::y} to y-coordinate of event-block set {sktruc::sel2::z} to z-coordinate of event-block send "Point 2: %{sktruc::sel2::x}% %{sktruc::sel2::y}% %{sktruc::sel2::z}%" Je récupère donc mes coordonnées (absolues) de mes 2 coins de la structure dans des variables. [spoiler="C'est quoi {sktruc::[..]} ?"]Si j'utilise un préfix, car oui c'en est un (SKTRUCture), c'est pour que ce ne soit pas le bordel dans mes variables ! Imaginez que j'installe un skript qui n'est pas de moi sur mon serveur, et que ce skript n'ai pas de préfix et utilise les mêmes variables que moi ! Plus rien ne fonctionnerait correctement ! [spoiler=Et pourquoi tu n'utilise presque que des "::" ? Le . il existe aussi !]C'est exact, mais Skript étant ainsi fait que les "::" signifient une variable liste. Cela est d'un énorme avantage de les utiliser car elles permettent d'être manipulée comme des listes. Je peux donc, par exemple, supprimer le point 1 de ma sélection en une seule ligne (clear {sktruc::sel1::*}), alors que mettre un . n'apporte rien ! Si un jour je décide de supprimer seulement Sktructure de mon serveur, je peux aussi (par souci de perfection) supprimer toutes les variables qui y sont associées ! Une fois mes coordonnées obtenues, il me suffit de faire la soustraction, par exemple, de {sktruc::sel2::x} par {sktruc::sel1::x}, et j'obtient alors l'épaisseur en X de ma structure. On pourrait se dire que c'est bon comme ça; sauf que non. D'abord, il est fort probable que je ne sélectionne pas les plus petites coordonnées en "Point 1" et les plus grandes coordonnées en "Point 2", le problème étant que si je soustrait, par exemple, 98 à 72, le résultat sera négatif ! Le loop x times ne s’exécutera alors pas ! Il faut donc réordonner les paires de coordonnées. Le second problème est plus subtil. Imaginons que nous avons sélectionné un bloc en coordonnées x=2 et l 'autre en x=5; le calcul 5-2 donne 3. Hors, si vous êtes un peu malin, vous savez qu'il y a 4 blocs d'épaisseur en X, x=2, x=3, x=4 et x=5. On peut vérifier ce fait en sélectionnant qu'une épaisseur, vous aurez alors 2-2=0, mais il y a une couche en vérité ! Il faut donc ajouter 1 à notre soustraction. On va donc d'abord réordonner nos coordonnées, et en même temps vérifier qu'elles existent !: if {struc::sel1::x} < {struc::sel2::x}: set {_x1} to {sktruc::sel1::x} set {_x2} to {sktruc::sel2::x} else if {struc::sel1::x} > {struc::sel2::x}: set {_x1} to {sktruc::sel2::x} set {_x2} to {sktruc::sel1::x} else: send "Erreur" stop #Ce même code pour Y et Z Et pour le +1 et la soustraction, on va l'intégrer aux loops: loop {_x2} - {_x1} + 1 times: loop {_y2} - {_y1} + 1 times: loop {_z2} - {_z1} + 1 times: set {_x} to "%loop-value-1%" parsed as number -1 set {_y} to "%loop-value-2%" parsed as number -1 set {_z} to "%loop-value-3%" parsed as number -1 #Reste du code à découvrir ! Maintenant, on va effectuer différents effets à chaque bloc de la structure, en connaissant leurs coordonnées relatives. Cependant, pour récupérer notre bloc, il va falloir convertir nos coordonnées relatives en coordonnées absolue. Pour cela, nous allons ajouter les coordonnées relatives de notre structure (ayant comme origine le bloc avec les plus petites coordonnées) au coordonnées absolues de ce même bloc ! On peut donc faire : add location at {_x}, {_y}, {_z} to {sktruc::save::location::*} #Ici on enregistre les coordonnées relative du bloc add type of block at location {_x}+{_x1}, {_y1}+{_y}, {_z1}+{_z} to {sktruc::save::block::*} #Et ici on enregistre de quel bloc il s'agit ! [spoiler=Heu.. Et comment on sait quels coordonnées correspondent à quel bloc ?]Et bien c'est très simple ! Étant donné que l'on enregistre en même temps la position du bloc et ses propriétés, leur index dans la liste est le même ! On peut aussi informer le joueur de la bonne sauvegarde de sa structure avec: send "Structure sauvegardée." send "Taille: x:%{_x2} - {_x1} +1% y:%{_y2} - {_y1} +1% z:%{_z2} - {_z1} +1%" send "Points: x1:%{_x1}% y1:%{_y1}% z1:%{_z1}% x2:%{_x2}% y2:%{_y2}% z2:%{_z2}%" On peut également ajouter clear {sktruc::save::location::*} clear {sktruc::save::block::*} juste avant les loops, histoire qu'il n'y ai pas de bug de structure imbriquée. Voilà, c'est tout, passons au "collage" de notre structure ! [spoiler=Code de la sauvegarde (et de la sélection)] command /sktructuresave: trigger: if {sktruc::sel1::x} < {sktruc::sel2::x}: set {_x1} to {sktruc::sel1::x} set {_x2} to {sktruc::sel2::x} else if {sktruc::sel1::x} > {sktruc::sel2::x}: set {_x1} to {sktruc::sel2::x} set {_x2} to {sktruc::sel1::x} else: send "Erreur" stop if {sktruc::sel1::y} < {sktruc::sel2::y}: set {_y1} to {sktruc::sel1::y} set {_y2} to {sktruc::sel2::y} else if {sktruc::sel1::y} > {sktruc::sel2::y}: set {_y1} to {sktruc::sel2::y} set {_y2} to {sktruc::sel1::y} else: send "Erreur" stop if {sktruc::sel1::z} < {sktruc::sel2::z}: set {_z1} to {sktruc::sel1::z} set {_z2} to {sktruc::sel2::z} else if {struc::sel1::z} > {sktruc::sel2::z}: set {_z1} to {sktruc::sel2::z} set {_z2} to {sktruc::sel1::z} else: send "Erreur" stop clear {sktruc::save::location::*} clear {sktruc::save::block::*} loop {_x2} - {_x1} + 1 times: loop {_y2} - {_y1} + 1 times: loop {_z2} - {_z1} + 1 times: set {_x} to "%loop-value-1%" parsed as number -1 set {_y} to "%loop-value-2%" parsed as number -1 set {_z} to "%loop-value-3%" parsed as number -1 add location at {_x}, {_y}, {_z} to {sktruc::save::location::*} add type of block at location {_x}+{_x1}, {_y1}+{_y}, {_z1}+{_z} to {sktruc::save::block::*} send "Structure sauvegardée" send "Taille: x:%{_x2} - {_x1} +1% y:%{_y2} - {_y1} +1% z:%{_z2} - {_z1} +1%" send "Points: x1:%{_x1}% y1:%{_y1}% z1:%{_z1}% x2:%{_x2}% y2:%{_y2}% z2:%{_z2}%" on left click with blaze rod: If name of player's tool is "Selection": if event-block is set: cancel event set {sktruc::sel1::x} to x-coordinate of event-block set {sktruc::sel1::y} to y-coordinate of event-block set {sktruc::sel1::z} to z-coordinate of event-block send "Point 1: %{sktruc::sel1::x}% %{sktruc::sel1::y}% %{sktruc::sel1::z}%" stop on right click with blaze rod: If name of player's tool is "Selection": if event-block is set: cancel event set {sktruc::sel2::x} to x-coordinate of event-block set {sktruc::sel2::y} to y-coordinate of event-block set {sktruc::sel2::z} to z-coordinate of event-block send "Point 2: %{sktruc::sel2::x}% %{sktruc::sel2::y}% %{sktruc::sel2::z}%" stop [spoiler=Optimisation du code...]Si vous avez suivi, dans ce bloc de code ci: set {_x} to "%loop-value-1%" parsed as number -1 set {_y} to "%loop-value-2%" parsed as number -1 set {_z} to "%loop-value-3%" parsed as number -1 add location at {_x}, {_y}, {_z} to {sktruc::save::location::*} add type of block at location {_x}+{_x1}, {_y1}+{_y}, {_z1}+{_z} to {sktruc::save::block::*} Je parse mes différentes loop-values. Cependant, après des tests sur de plus grandes structures, cela rend le code horriblement lent ! De plus, je n'ai pas trouvé le moyen de faire autrement (voir :[Contenu masqué]). Si vous pouvez m'aidez, ce serait bien gentil ! -Placer la structure à un autre endroit- Pour ce faire, c'est très simple ! Nous allons d'abord créer une "loop {sktruc::save::location::*}:", nous reconvertirons les coordonnées relatives en coordonnées absolues, et nous irons chercher le type de bloc à poser grâce au loop-index, qui est, je rappelle, le même pour les coordonnées et le type d'un même bloc. loop {sktruc::save::location::*}: set {_x} to x-coordinate of loop-value + x-coordinate of player set {_y} to y-coordinate of loop-value + y-coordinate of player set {_z} to z-coordinate of loop-value + z-coordinate of player set block at location {_x}, {_y}, {_z} to {sktruc::block::%loop-index%} Et vous avez votre structure collé avec comme origine relative votre joueur ! [spoiler=Code du collage de structure] command /sktructureload: trigger: loop {sktruc::save::location::*}: set {_x} to x-coordinate of loop-value + x-coordinate of player set {_y} to y-coordinate of loop-value + y-coordinate of player set {_z} to z-coordinate of loop-value + z-coordinate of player set block at location {_x}, {_y}, {_z} to {sktruc::save::block::%loop-index%} -Résumé- Ici, nous avons appris à sauvegarder une structure tridimensionnelle en Skript. On peut aussi y ajouter un support par joueur, une gestion des sauvegardes, ... On y a également vu comment récupérer notre structure précédemment enregistrée, et la coller de façon simple. Je compte continuez de faire des tutos, en gardant notre Sktructure, l'améliorant et essayant de faire (pourquoi pas ^^) un WorldEdit-like. Si vous avez des idées, des suggestions, des remarques, des questions ou autre, n'hésitez pas à vous manifester ! Suite: Sktructure#2 Rotation et symétrie orthogonale 4rno

Tu n'as qu'a l'intégrer directement dans ton code, au moment de la fin de ton duel, ce sera plus économique; sinon il faut passer par un "every x ticks:". De plus "quand ma variable est finie" ne veut pas dire grand chose, c'est pas plutot quand elle est supprimée/réinitialisée ?

command /resetarene <number> <number> <number> <number> <number> <number> : usage: /resetarene <x1> <y1> <z1> <x2> <y2> <z2> trigger: set {_x1} to arg-1 set {_y1} to arg-2 set {_z1} to arg-3 set {_x2} to arg-4 set {_y2} to arg-5 set {_z2} to arg-6 set {_x} to {_x1} set {_y} to {_y1} set {_z} to {_z1} loop {_x2}-{_x1}+1 times: loop {_y2}-{_y1}+1 times: loop {_z2}-{_z1}+1 times: set block at location {_x}, {_y}, {_z} to air send "%location {_x}, {_y}, {_z}%" add 1 to {_z} set {_z} to {_z1} add 1 to {_y} set {_y} to {_y1} add 1 to {_x} ou #Mettre en entrée les coordonnées, des plus petites aux plus grandes #{_x1} {_y1} {_z1} {_x2} {_y2} {_z2} où #{_x1} < {_x2} #{_y1} < {_y2} #{_z1} < {_z2} et le monde dans la variable {_world} set {_x} to {_x1} set {_y} to {_y1} set {_z} to {_z1} loop {_x2}-{_x1}+1 times: loop {_y2}-{_y1}+1 times: loop {_z2}-{_z1}+1 times: set block at location {_x}, {_y}, {_z} in world "%{_world}%" to air add 1 to {_z} set {_z} to {_z1} add 1 to {_y} set {_y} to {_y1} add 1 to {_x}

@MrForoche quand je disais WE, c'était avec les schematics, donc en copy/paste, et là effectivement ça veut pas.

Ah ok ^^ Bon apès quelques tests, worldedit ne fonctionne pas nn plus... Je pense qu'il faudrait réussir à empêcher aux blocs de s'update... Par contre comment ?

Bonjour, Si tu souhaite que ça te crée un portail avec les blocs d'obsidienne et tout et tout, j'envisagerais 2 solutions (à tester !): Tu fais un code ressemblant à celui-ci: command /portail: trigger: set {_x} to x-coordinate of target block set {_y} to y-coordinate of target block set {_z} to z-coordinate of target block set block at location {_x}, {_y}, {_z} to obsidian set block at location {_x}+1, {_y}, {_z} to obsidian set block at location {_x}+2, {_y}, {_z} to obsidian set block at location {_x}+2, {_y}, {_z}-1 to obsidian Ect.... Tu utilises un addon (je sais plus lequel, et skunity est actuellement down :/) qui te permet d'enregistrer tes structures en schematic, que tu colles quand ta commande est exécutée. Normalement, si tu es en 1.10+, il y a aussi peut être moyen de générer la structure grâce aux structures block, mais je ne sais pas si il existe un addon qui les prend en charge, ni si le portail du nether est enregistré dans les fichiers de structure...

@NaolShow De cette manière, tu est toujours limité par la condition que tu as écrit !Tu ne peux pas t'amuser à écrire tt les multiples de 5000 dans ta condition :/

Cherche du côté du modulo (opération mathématique du reste d'une division), car dire "tous les 5000 blocs minés", c'est comme dire "Si mon nombre est multiple de 5000". EDIT: En fait Skript (de base) ne semble pas connaitre l'opération modulo (doc Skript-mc.fr à l'appui; et skunity est down :/ ) donc ça risque d'être un peu plus compliqué. Faudra que tu testes si le retour de l'opération division retourne un nombre sans décimales.

Bonjour, Que souhaites tu en fait ? Un code tout fait ? Alors tu es dans la mauvaise section ! Sinon, pour la logique de programmation, il te suffit de créer une commande /chat <on|off>, qui définit une variable personnalisée (pour chaque joueur) à true ou false, et puis un autre bloc de code qui détecte si un joueur écrit un message dans le chat, qui annule l’événement (on ne peut pas -à ma connaissance- annuler l’événement que pour certaines personnes) puis qui envoie un message à chaque joueur n'ayant pas sa variable à false (ou qui n'est pas dans le même monde). Cdlt

Ah ouais pas con ^^, merci :)

Voici une petite commande qui vous permet de calculer la hauteur moyenne d'un terrain, pour par exemple générer des spawn aléatoire de structure (en surface ^^) [spoiler=Code] command /surface <integer> <integer> <integer>: usage: /surface <x> <z> <radius> trigger: set {_x} to arg 1 - arg 3 set {_z} to arg 2 - arg 3 set {_diametre} to arg 3 *2 loop {_diametre} times: loop {_diametre} times: set {_y} to 256 while {_surface} is not set: if block at the location x={_x}, y={_y}, z={_z} is air: remove 1 from {_y} else: set {_surface} to {_y} add {_surface} to {_surface::*} if {_y} = 0: set {_surface} to {_y} add {_surface} to {_surface::*} add 1 to {_x} add 1 to {_z} loop {_surface::*}: add loop-value to {_total} set {_moyenne} to {_total}/size of {_surface::*} broadcast "Moyenne de la hauteur de la surface: %{_moyenne}%" broadcast "centre-x=%arg 1% centre-y=%arg 2% rayon=%arg 3% diamètre=%{_diametre}%" Je vais l'adapter en fonction, mais pas bcp le temps actuellement :/ EDIT: si comme moi les espaces ne s'affichent pas, voici le code ici, avec l'indentation qui va bien ;)

Bonjour, Comme je l'ai déjà mentionné dans mon 1er post, j'ai déjà désactivé tous les addons de Skript pour voir si ça allait mieux, ce n'est pas le cas. Le /sk reload all ne fonctionne pas non plus, étant donné qu' essaye aussi de reload les skripts buggés. Je vais comme même essayer de savoir précisément quels skripts buggent (et quoi dans ceux-ci), mais j'en ai pas mal, je vous tiendrait au courant ;) Cependant, j'ai de toute façon "besoin" de ces skripts, donc ça risque d'être compliqué... RebellCraft EDIT: avec Skript-dev22g, le /sk reload all fonctionne, on fera avec ;)

De qui ? Et c'est compatible 1.10 ?

Attention il utilise aussi des fonctions extérieur à ce script, mais on a aussi le même cas pour d'autres scripts. # Dans ce Skript: # Si {game.status} est à 5: # - anti-commande en tant que joueur # - commande forcestop si problème (juste pour moi lol) # - anti-changement de gamemode en tant que joueur # - anti-changement de monde en tant que joueur ou spectateur on command: # retire l'accès de certaines commandes aux joueurs if {game.status} is 5: if PlayerIsInList(player,{game.current.players::*}) is true: if command is not "report" or "reportlog" or "vote" or "setvote" or "fata" or "fatality" or "msg" or "tps": if name of player is not "Aerosmite35" or "RebellCraft": send "&cVous n'êtes pas autorisé à faire cette commande en tant que joueur." to player cancel event command /forcestop: trigger: if name of player is not "Aerosmite35" or "RebellCraft": if {game.status} is 5: set {fata.win} to "forced" else: send "&cAucune partie en cours." to player else: send "&cSeuls les développeurs sont autorisés à utiliser cette commande." to player on gamemode change: # empêche les joueurs de changer de gamemode if {game.status} is 5: if PlayerIsInList(player,{game.current.players::*}) is true: set {_test} to true else if PlayerIsInList(player,{game.current.team::spectateur::*}) is true: set {_test} to true if {_test} is true: if name of player is not "Aerosmite35" or "RebellCraft": cancel event send "&cVous n'êtes pas autorisé à changer de gamemode." to player every second in "world": if {game.status} is 5: loop all players: if PlayerIsInList(loop-player,{game.current.players::*}) is true: # empêche les joueurs d'aller au lobby if name of loop-player is not "Aerosmite35" or "RebellCraft": if PlayerIsInList(loop-player,{game.current.team::green::*}) is true: teleport loop-player to {fata.spawnpoint.green} if PlayerIsInList(loop-player,{game.current.team::orange::*}) is true: teleport loop-player to {fata.spawnpoint.orange} play "ENTITY_VILLAGER_NO" to loop-player set the health of loop-player to 2 send "&cRestez dans la partie !" to loop-player if PlayerIsInList(loop-player,{game.current.team::spectateur::*}) is true: remove uuid of loop-player from {game.current.team::spectateur::*} set loop-player's gamemode to adventure teleport loop-player to {spawn} send "&cVous quittez le mode spectateur." to loop-player

Bonjour/bonsoir, J'ai un gros problème avec skript, certains /sk reload <scripts> ne fonctionnent pas (il affiche "[skript] Reloading jesuisunskript.sk..." puis plus rien (et ça ne sert à rien d'attendre, c'est pas de gros scripts)). Je ne sais pas exactement lequels, ce que je sais c'est que dès que je tombe sur un de ces scripts de mort, je peux plus rien /sk reload, ils ne répondent plus non plus. Cependant, ces scripts "buggés" fonctionnaient auparavant, et ne contiennent rien de spécial... Voici la config du serv: Serveur spigot 1.10.2 Skript 2.2 (fork de bensku, j'ai testé en dev22c, dev20b et dev21c) Plugins installés: WorldEdit, WorldGuard, Multiverse-Core, Multiverse-SignPortals, VoxelSniper, OldPvP, WildSkript, NoteBlockAPI, ViaVersion, Multiverse-Portals, LightAPI, WorldEditSelectionVisualizer, Skript, skDragon, ExertSK, SkQuery, SkAction, SkStuff, SkMorkaz, Skellett, skRayFall, MundoSK, PirateSK, skUtilities, RandomSK, GameBuSK, Vixio, SharpSK. On a déjà essayé de désactiver tout les plugins, ça ne fonctionne comme même pas :/ Merci d'avance pour l'aide. RebellCraft