A. Utiliser du formatage directement en jeu :
La première classe vous permettra d’utiliser le fameux symbole § permettant le formatage du texte directement en jeu, afin d’éviter le recourt à un programme extérieur.
Nous allons d'abord modifier la classe « ChatAllowedCharacters » ("SharedConstants" désormais).
La partie qui nous intéresse est celle-ci :
Code (cpp):
public static final char[] allowedCharactersArray = new char[] {'/', '\n', '\r', '\t', '\u0000', '\f', '`', '?', '*', '\\', '<', '>', '|', '\"', ':'};
public static boolean isAllowedCharacter(char character)
{
return character != 167 && character >= 32 && character != 127;
}
Cette dernière permet de définir des caractères dont l’utilisation en jeu sera bloquée, et le caractère d’identifiant "167" correspond, comme vous l’avez deviné au §. En enlevant cette petite partie nous pourrons débloquer son utilisation, ce qui donne ceci :
Code (cpp):
public static final char[] allowedCharactersArray = new char[] {'/', '\n', '\r', '\t', '\u0000', '\f', '`', '?', '*', '\\', '<', '>', '|', '\"', ':'};
public static boolean isAllowedCharacter(char character)
{
return character >= 32 && character != 127;
}
Vous pourrez alors utiliser en jeu le §. Etant un caractère de formatage il ne sera visible que jusqu’à ce que vous rentriez un nouveau caractère définissant le formatage choisi (bien que vous puissiez le faire réapparaitre en vous déplaçant dans un texte, mais il n’apparaitra pas lorsque le texte sera affiché en jeu). Voici un rappel des différentes modifications applicables (pour plus d’info vous pouvez consulter le wiki) :
- Les couleurs : §0 noir, §1 bleu foncé, §2 vert foncé, §3 turquoise foncé, §4 rouge foncé, §5 violet foncé, §6 or, §7 gris, §8 gris foncé, §9 bleu, §a vert, §b turquoise, §c rouge, §d violet, §e jaune, §f blanc
- Les mises en forme : §l gras, §m barré, §n souligné, §o italique
- Les spéciaux : §r reset annule tout formatage précédent (il met fin à la chaîne formatée précédemment pour revenir au texte du base qui peut également être formaté différemment), §k obfuscate qui fait changer les caractères très rapidement de manière random
B. Etendre son chat jusqu’à la capacité d’un bloc de commande :
Qui n’a jamais ragé en tapant une commande de buter contre la limite de caractères du chat ? Grâce à ici non pas une mais deux classes modifiés nous allons pouvoir étendre cette limite jusqu’à 32 767 caractères, permettant ainsi de faire des commandes entières en chat avant de pouvoir les copier-coller ailleurs, ou tout simplement de les stocker dans l’historique pour pouvoir les reprendre plus tard ou déplacer des systèmes.
La première classe qui sera modifiée est « GuiChat » ("ChatScreen" désormais), voici la partie qui nous intéresse :
Code (cpp):
public void initGui()
{
Keyboard.enableRepeatEvents(true);
this.sentHistoryCursor = this.mc.ingameGUI.getChatGUI().getSentMessages().size();
this.inputField = new GuiTextField(0, this.fontRendererObj, 4, this.height - 12, this.width - 4, 12);
this.inputField.setMaxStringLength(100);
this.inputField.setEnableBackgroundDrawing(false);
this.inputField.setFocused(true);
this.inputField.setText(this.defaultInputFieldText);
this.inputField.setCanLoseFocus(false);
this.field_184096_i = new GuiChat.ChatTabCompleter(this.inputField);
}
Nous allons ici modifier le paramètre « setMaxStringLenght » pour étendre la capacité d’une chaine de texte à 32 767 ce qui donne :
Code (cpp):
public void initGui()
{
Keyboard.enableRepeatEvents(true);
this.sentHistoryCursor = this.mc.ingameGUI.getChatGUI().getSentMessages().size();
this.inputField = new GuiTextField(0, this.fontRendererObj, 4, this.height - 12, this.width - 4, 12);
this.inputField.setMaxStringLength(32767);
this.inputField.setEnableBackgroundDrawing(false);
this.inputField.setFocused(true);
this.inputField.setText(this.defaultInputFieldText);
this.inputField.setCanLoseFocus(false);
this.field_184096_i = new GuiChat.ChatTabCompleter(this.inputField);
}
Mais ce n’est pas tout, cela étend la capacité d’affichage pour une seule chaîne de caractère mais n’enlève pas encore la limite en chat. Nous allons devoir modifier une seconde classe appelée « CPacketChatMessage » ("CChatMessagePacket" désormais). La partie à modifier se trouve ici :
Code (cpp):
public CPacketChatMessage(String p_i46887_1_)
{
if (p_i46887_1_.length() > 100)
{
p_i46887_1_ = p_i46887_1_.substring(0, 100);
}
this.message = p_i46887_1_;
}
Nous allons donc modifier les valeurs utiliser pour augmenter la limite jusqu’à 32 767 :
Code (cpp):
public CPacketChatMessage(String p_i46887_1_)
{
if (p_i46887_1_.length() > 32767)
{
p_i46887_1_ = p_i46887_1_.substring(0, 32767);
}
this.message = p_i46887_1_;
}
PS : Attention en utilisant cette classe en map-making car en augmentant la capacité du chat vous étendez également la limite de taille d’un run_command en json, hors quelqu’un n’ayant pas cette classe aura bel et bien la limite.
Voilà, vous avez maintenant un chat (presque) infini. Enfin vous l’aurez quand vous aurez appliqué ces modifications et nous allons passer à l’installation.
C. Ajouter les blocs techniques à l'inventaire créatif :
Nouveauté ajoutée le 23/06/2016.
Il suffit d'aller dans le .java et d'un bloc et de faire deux choses :
- Rajouter dans les import au début la classe creative tabs
Code (cpp):
import net.minecraft.creativetab.CreativeTabs;
- Modifier le premier protected de la class pour rajouter la tab auquel l'ajouter (ici comme exemple le mobSpawner
Code (cpp):
protected BlockMobSpawner()
{
super(Material.ROCK);
this.setCreativeTab(CreativeTabs.MISC);
}
Blocs disponibles :
- Onglet block : farmland, grass path, hugemushroom
- Onglet décoration : dragon egg
- Onglet redstone : command block (les 3 types), barrier structure block, structure void
- Onglet divers : spawner
D. Rajouter une spawn egg d'une entité :
Nouveauté ajoutée le 7/07/2016
Dans la classe "EntityList", rajouter dans la seconde partie de la grande liste une ligne pour l'entité, avec les nombres donnant en décimales le code pour les deux couleurs de l'oeuf (ici un extrait en 1.12 pour le giant).
Code (cpp):
func_191305_a("ghast", 16382457, 12369084);
func_191305_a("giant", 34735, 7311963);
func_191305_a("guardian", 5931634, 15826224);
func_191305_a("horse", 12623485, 15656192);
...
Œufs disponibles : giant, snowman, villagergolem
E. Augmenter la limite de luminosité
Nouveauté ajoutée le 27/08/2016
Dans la classe "GameSettings" ("AbstractOption" désormais) :
- Dans "getKeyBinding" qui vérifie les options, modifier la partie concernant le gamma
Code (cpp):
else if (settingOption == GameSettings.Options.GAMMA)
{
if (f == 0.0F)
{
return s + I18n.format("options.gamma.min");
}
else
{
return f == 5.0F ? s + I18n.format("options.gamma.max") : s + "+" + (int)(f * 500.0F) + "%";
}
}
- Dans le enum "Options", modifier le gamma en ajoutant la valeur minimale, la valeur maximale, et le pas
Code (cpp):
FOV("options.fov", true, false, 30.0F, 110.0F, 1.0F),
GAMMA("options.gamma", true, false, 0.0F, 5.0F, 0.01F),
SATURATION("options.saturation", true, false),
RENDER_DISTANCE("options.renderDistance", true, false, 2.0F, 16.0F, 1.0F),
...
Permet de pousser la limite de luminosité à +500% (+100% de base).
F. Utiliser des blocs de commandes pour "ajouter" un item aux blocs cachés
Nouveauté ajoutée le 28/08/2016
Il est nécessaire au préalable de rajouter le bloc de commande à l'inventaire comme expliqué en C.
Trois parties à cet ajout :
- Import de méthodes utilisées par la suite (à rajouter parmi les import au début,)
Code (cpp):
import net.minecraft.item.Item;
import net.minecraft.util.NonNullList;
- Rajout d'une méthode pour créer un itemstack à partir d'une commande et du nom à donner au bloc de commande
Code (cpp):
public ItemStack ReturnStack (String Command, String Name)
{
ItemStack stack = new ItemStack(this);
NBTTagCompound tag = new NBTTagCompound();
stack.setStackDisplayName(Name);
tag.setByte("auto", (byte) 1);
tag.setString("Command", Command);
stack.setTagInfo("BlockEntityTag", tag);
return stack;
}
- Rajout d'un getSubBlocks (méthode d'énumération dans l'inventaire existant sur d'autres blocs) appelant la méthode précédente pour chaque variante
Code (cpp):
public void getSubBlocks(CreativeTabs itemIn, NonNullList<ItemStack> tab)
{
tab.add(new ItemStack(this));
if (this == Blocks.COMMAND_BLOCK)
{
tab.add(ReturnStack ("setblock ~ ~ ~ double_stone_slab 8 replace","§7Stone Slab Block§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ double_stone_slab 9 replace","§eSmooth Sandstone§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ double_stone_slab2 8 replace","§cSmooth Red Sandstone§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ end_gateway 0 replace {Age:300}","§dEnd Gateway§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ log 12 replace","§aFull Oak Log§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ log 13 replace","§aFull Spruce Log§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ log 14 replace","§aFull Birch Log§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ log 15 replace","§aFull Jungle Log§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ log2 12 replace","§aFull Acacia Log§r"));
tab.add(ReturnStack ("setblock ~ ~ ~ log2 13 replace","§aFull DarkOak Log§r"));
}
}
Ajoute à la liste d'objets des variantes de bloc de commande avec des tags et nom prédéfinis, qui se transformeront en un bloc caché une fois posés.
Blocs disponibles : "bloc" de stone slab, smooth sandstone et red sandstone, end gateway, bûches "pleines"
NB : il s'agit d'une des classes les plus variables, il arrive couramment qu'elle soit éditée pour fonctionner avec les modifications qu'apportent les versions, ce code exact peut ne plus fonctionner à l'avenir (dans cet exemple il s'agit de la version 1.12 qui vient tout juste d'être modifiée depuis la 1.11)
