LaurentOutang

January 30, 2020

Hi,

I want to perform an action for each tick while the player is right clicking. I also want the animation not to be repeated, juste like the shield. I saw that ItemBow and ItemShield had property like

this.addPropertyOverride(new ResourceLocation("pull"), new IItemPropertyGetter()
        {
            @SideOnly(Side.CLIENT)
            public float apply(ItemStack stack, @Nullable World worldIn, @Nullable EntityLivingBase entityIn)
            {
                if (entityIn == null)
                {
                    return 0.0F;
                }
                else
                {
                    return !(entityIn.getActiveItemStack().getItem() instanceof ItemBow) ? 0.0F : (float)(stack.getMaxItemUseDuration() - entityIn.getItemInUseCount()) / 20.0F;
                }
            }
        });

I also overrided Item#getMaxItemUseDuration and Item#getItemUseAction but I don't know more. This video uses the same system.

Thank you for your help !

December 16, 2018

Ok i'll read this. Thank you very much. I think it will take time. I'll update this post when I finish all these things. Thank you.

December 16, 2018

Thank you for answering and sorry for my english.

2 hours ago, V0idWa1k3r said:

Read and understand: https://mcforge.readthedocs.io/en/latest/concepts/sides/

If I have the same .jar for physical client and server I don't have to deal with @SideOnly, right?

FMLClientHandler.instance().getServer();
FMLServerHandler.instance().getServer();
FMLCommonHandler.instance().getServer();

What is the difference between these three things (with logical / physical explanation please) ?

In the link, it is said :

Quote

Use this check whenever you need to determine if game logic and other mechanics should be run. For example, if you want to damage the player every time they click your block, or have your machine process dirt into diamonds, you should only do so after ensuring world.isRemote is false. Applying game logic to the logical client can cause desynchronization (ghost entities, desynchronized stats, etc.) in the lightest case, and crashes in the worst case.

Then for every method that is related to season I should check if world.isRemote == false in order not to desynchronize (the cycle of seasons is game logic)?

2 hours ago, V0idWa1k3r said:

You must provide both the MCP(deobfuscated) and the SRG field names.(if you are using newer forge version then SRG only will suffice). You can get the SRG name of a field from mcpbot or from your local gradle caches.

I really don't understand this, what do you mean by MCP and SRG ? what should I change in my code ?

2 hours ago, V0idWa1k3r said:

2 hours ago, LaurentOutang said:

MinecraftServer server = FMLClientHandler.instance().getServer(); if(server != null) {

Don't do this, you might be reaching across logical sides. Check that you are on a server in the first place.

Should I check !world.isRemote ?

What do you mean when you say "cache your fields" please I don't understand it ?

Sorry for all these questions and thank you very much.

December 16, 2018

Hey, I have a reflection problem only on my "true" minecraft (not on eclipse) : it seams that he can not change enableSnow value... I also have two more questions : my mod is supposed to manage seasons (summer and winter), but I want that these seasons are the same for all the players. So is my code right or should I put "@SideOnly(Side.SERVER)" before each method that update seasons ? How could I do stop the time when there is no player on the server ? Maybe I should use WorldTickEvent.setCancelled(true); but only on server side ? Should I also cancel ServerTickEvent etc. Thank you.

package com.laurentoutang.hardmod.Seasons;

import java.util.Collection;

import com.laurentoutang.hardmod.Main;
import com.laurentoutang.hardmod.Init.BiomeInit;
import com.laurentoutang.hardmod.Init.ItemInit;
import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;

import net.minecraft.block.BlockBeetroot;
import net.minecraft.block.BlockCarrot;
import net.minecraft.block.BlockCocoa;
import net.minecraft.block.BlockCrops;
import net.minecraft.block.BlockMelon;
import net.minecraft.block.BlockPotato;
import net.minecraft.block.BlockPumpkin;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Biomes;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraftforge.event.CommandEvent;
import net.minecraftforge.event.entity.player.PlayerWakeUpEvent;
import net.minecraftforge.event.world.BlockEvent;
import net.minecraftforge.event.world.BlockEvent.CropGrowEvent;
import net.minecraftforge.fml.client.FMLClientHandler;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.WorldTickEvent;
import net.minecraftforge.fml.common.registry.ForgeRegistries;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.fml.server.FMLServerHandler;

@EventBusSubscriber
public class SeasonEventHandler {
	
	private static boolean transition = true;
	

	@SubscribeEvent
	public static void onWakeUp(PlayerWakeUpEvent event)
	{
		SeasonWorldProvider.season_manager.isDay = true;
	}
	
	@SubscribeEvent
	public static void onPlayerCommandTimeSet(CommandEvent event)
	{
		if(event.getCommand().getName() == "time" && "set".equals(event.getParameters()[0]))		
		{
			event.setCanceled(true);
		}		
	}
	
	@SubscribeEvent
	public static void onBlockDestroyed(BlockEvent.BreakEvent event)
	{ 
			if(SeasonWorldProvider.season_manager.getSeason() == SeasonManager.seasons.Winter && (
	    		   event.getState().getBlock() instanceof BlockBeetroot || 
	    		   event.getState().getBlock() instanceof BlockCarrot || 
	    		   event.getState().getBlock() instanceof BlockPotato || 
	    		   event.getState().getBlock() instanceof BlockCrops || 
	    		   event.getState().getBlock() instanceof BlockCocoa || 
	    		   event.getState().getBlock() instanceof BlockMelon || 
	    		   event.getState().getBlock() instanceof BlockPumpkin
			))
	       {
	            event.setCanceled(true);
	       }
	}
	
	@SubscribeEvent
	public static void onPlayerTick(PlayerTickEvent event)
	{
		EntityPlayer player = event.player;
		
		
		if (player.world.isRemote) 
			return;
		else
			registerArmorTemperature(player);
		
	}
	
	@SubscribeEvent()
	public static void onWorldTick(WorldTickEvent event)
	{		
		MinecraftServer server = FMLClientHandler.instance().getServer();
								
		if(server != null)
		{
			if(server.getOnlinePlayerNames().length > 0)
			{
				if(SeasonWorldProvider.season_manager.getSeason() == SeasonManager.seasons.Winter)
					loadWinterProperties(event.world);
				else
					loadSummerProperties();
				
			}
		}	
	}
	
	private static void registerArmorTemperature(EntityPlayer player)
	{
		IMentalTemperature mt = player.getCapability(MentalTemperatureProvider.MentalTemperature_CAP, null);
		
		
		if(player.inventory.armorItemInSlot(0).getItem().equals(ItemInit.WOOLEN_BOOTS))
		{
			if(mt.getBootsTemperature() == 0)
			{
				mt.setBootsTemperature(10.f);		
			}
		}
		else
		{
			mt.setBootsTemperature(0.f);
		}
		
		
		if(player.inventory.armorItemInSlot(1).getItem().equals(ItemInit.WOOLEN_LEGGINS))
		{
			if(mt.getLegginsTemperature() == 0)
			{
				mt.setLegginsTemperature(10.f);		
			}
		}
		else
		{
			mt.setLegginsTemperature(0.f);
		}
		
		
		if(player.inventory.armorItemInSlot(2).getItem().equals(ItemInit.WOOLEN_CHESTPLATE))
		{
			if(mt.getChestplateTemperature() == 0)
			{
				mt.setChestplateTemperature(10.f);		
			}
		}
		else
		{
			mt.setChestplateTemperature(0.f);
		}
		
		
		
		if(player.inventory.armorItemInSlot(3).getItem().equals(ItemInit.WOOLEN_HELMET))
		{
			if(mt.getHelmetTemperature() == 0)
			{
				mt.setHelmetTemperature(10.f);		
			}
		}
		else
		{
			mt.setHelmetTemperature(0.f);
		}
	}
	
	private static void loadWinterProperties(World world)
	{
		Collection<Biome> allBiomes  = ForgeRegistries.BIOMES.getValuesCollection();
		for(Biome b : allBiomes)
		{
			if(b != Biomes.HELL && b != Biomes.SKY && b != Biomes.VOID)
			{
				ObfuscationReflectionHelper.setPrivateValue(Biome.class, b, true, "enableSnow");
				ObfuscationReflectionHelper.setPrivateValue(Biome.class, b, 0.0F, "temperature");
			}
			
		}
		//Custom biome
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, BiomeInit.forestRemastered, true, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, BiomeInit.forestRemastered, 0.0F, "temperature");
		if(transition)
		{
			world.getWorldInfo().setRainTime(288000);
			transition = false;
		}
			
	}
	
	private static void loadSummerProperties()
	{
		if( transition == false)
			transition = true;	
		
		Collection<Biome> allBiomes  = ForgeRegistries.BIOMES.getValuesCollection();
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.OCEAN, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.OCEAN, 0.5F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.BEACH, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.BEACH, 0.8F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.BIRCH_FOREST, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.BIRCH_FOREST, 0.6F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.BIRCH_FOREST_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.BIRCH_FOREST_HILLS, 0.6F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.COLD_BEACH, 0.05F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.COLD_TAIGA, -0.5F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.COLD_TAIGA_HILLS, -0.5F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.DEEP_OCEAN, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.DEEP_OCEAN, 0.5F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.DESERT, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.DESERT, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.DESERT_HILLS, false, "enableSnow");			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.DESERT_HILLS, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.EXTREME_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.EXTREME_HILLS, 0.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.EXTREME_HILLS_EDGE, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.EXTREME_HILLS_EDGE, 0.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.EXTREME_HILLS_WITH_TREES, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.EXTREME_HILLS_WITH_TREES, 0.2F, "temperature");		
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.FOREST, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.FOREST, 0.7F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, BiomeInit.forestRemastered, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, BiomeInit.forestRemastered, 0.7F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.FOREST_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.FOREST_HILLS, 0.7F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.FROZEN_OCEAN, 0.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.FROZEN_RIVER, 0.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.ICE_MOUNTAINS, 0.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.ICE_PLAINS, 0.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.JUNGLE, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.JUNGLE, 0.95F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.JUNGLE_EDGE, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.JUNGLE_EDGE, 0.95F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.JUNGLE_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.JUNGLE_HILLS, 0.95F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MESA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MESA, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MESA_CLEAR_ROCK, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MESA_CLEAR_ROCK, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MESA_ROCK, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MESA_ROCK, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUSHROOM_ISLAND, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUSHROOM_ISLAND, 0.9F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUSHROOM_ISLAND_SHORE, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUSHROOM_ISLAND_SHORE, 0.9F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_BIRCH_FOREST, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_BIRCH_FOREST, 0.6F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_BIRCH_FOREST_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_BIRCH_FOREST_HILLS, 0.6F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_DESERT, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_DESERT, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_EXTREME_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_EXTREME_HILLS, 0.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_EXTREME_HILLS_WITH_TREES, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_EXTREME_HILLS_WITH_TREES, 0.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_FOREST, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_FOREST, 0.6F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_ICE_FLATS, 0.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_JUNGLE, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_JUNGLE, 0.95F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_JUNGLE_EDGE, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_JUNGLE_EDGE, 0.95F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_MESA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_MESA, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_MESA_CLEAR_ROCK, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_MESA_CLEAR_ROCK, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_MESA_ROCK, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_MESA_ROCK, 2.0F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_PLAINS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_PLAINS, 0.8F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_REDWOOD_TAIGA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_REDWOOD_TAIGA, 0.25F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_REDWOOD_TAIGA_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_REDWOOD_TAIGA_HILLS, 0.25F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_ROOFED_FOREST, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_ROOFED_FOREST, 0.7F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_SAVANNA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_SAVANNA, 1.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_SAVANNA_ROCK, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_SAVANNA_ROCK, 1.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_SWAMPLAND, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_SWAMPLAND, 0.8F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_TAIGA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_TAIGA, 0.25F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.MUTATED_TAIGA_COLD, -0.5F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.PLAINS, false, "enableSnow");			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.PLAINS, 0.8F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.REDWOOD_TAIGA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.REDWOOD_TAIGA, 0.25F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.REDWOOD_TAIGA_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.REDWOOD_TAIGA_HILLS, 0.25F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.RIVER, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.RIVER, 0.5F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.ROOFED_FOREST, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.ROOFED_FOREST, 0.7F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.SAVANNA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.SAVANNA, 1.2F, "temperature");		
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.SAVANNA_PLATEAU, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.SAVANNA_PLATEAU, 1.2F, "temperature");
		
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.STONE_BEACH, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.STONE_BEACH, 0.2F, "temperature");			

		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.SWAMPLAND, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.SWAMPLAND, 0.8F, "temperature");

		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.TAIGA, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.TAIGA, 0.25F, "temperature");
			
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.TAIGA_HILLS, false, "enableSnow");
		ObfuscationReflectionHelper.setPrivateValue(Biome.class, Biomes.TAIGA_HILLS, 0.25F, "temperature");		
	}
}

---- Minecraft Crash Report ----
// Would you like a cupcake?

Time: 12/16/18 3:45 PM
Description: Exception in server tick loop

net.minecraftforge.fml.relauncher.ReflectionHelper$UnableToAccessFieldException: net.minecraftforge.fml.relauncher.ReflectionHelper$UnableToFindFieldException: java.lang.NoSuchFieldException: enableSnow
	at net.minecraftforge.fml.relauncher.ReflectionHelper.setPrivateValue(ReflectionHelper.java:170)
	at net.minecraftforge.fml.common.ObfuscationReflectionHelper.setPrivateValue(ObfuscationReflectionHelper.java:98)
	at com.laurentoutang.hardmod.Seasons.SeasonEventHandler.loadSummerProperties(SeasonEventHandler.java:200)
	at com.laurentoutang.hardmod.Seasons.SeasonEventHandler.onWorldTick(SeasonEventHandler.java:107)
	at net.minecraftforge.fml.common.eventhandler.ASMEventHandler_11_SeasonEventHandler_onWorldTick_WorldTickEvent.invoke(.dynamic)
	at net.minecraftforge.fml.common.eventhandler.ASMEventHandler.invoke(ASMEventHandler.java:90)
	at net.minecraftforge.fml.common.eventhandler.EventBus.post(EventBus.java:179)
	at net.minecraftforge.fml.common.FMLCommonHandler.onPreWorldTick(FMLCommonHandler.java:286)
	at net.minecraft.server.MinecraftServer.func_71190_q(MinecraftServer.java:750)
	at net.minecraft.server.MinecraftServer.func_71217_p(MinecraftServer.java:666)
	at net.minecraft.server.integrated.IntegratedServer.func_71217_p(IntegratedServer.java:185)
	at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:524)
	at java.lang.Thread.run(Thread.java:745)
Caused by: net.minecraftforge.fml.relauncher.ReflectionHelper$UnableToFindFieldException: java.lang.NoSuchFieldException: enableSnow
	at net.minecraftforge.fml.relauncher.ReflectionHelper.findField(ReflectionHelper.java:117)
	at net.minecraftforge.fml.relauncher.ReflectionHelper.setPrivateValue(ReflectionHelper.java:166)
	... 12 more
Caused by: java.lang.NoSuchFieldException: enableSnow
	at java.lang.Class.getDeclaredField(Class.java:2070)
	at net.minecraftforge.fml.relauncher.ReflectionHelper.findField(ReflectionHelper.java:108)
	... 13 more


A detailed walkthrough of the error, its code path and all known details is as follows:
---------------------------------------------------------------------------------------

-- System Details --
Details:
	Minecraft Version: 1.12.2
	Operating System: Windows 10 (amd64) version 10.0
	Java Version: 1.8.0_51, Oracle Corporation
	Java VM Version: Java HotSpot(TM) 64-Bit Server VM (mixed mode), Oracle Corporation
	Memory: 229862328 bytes (219 MB) / 637534208 bytes (608 MB) up to 2147483648 bytes (2048 MB)
	JVM Flags: 8 total; -XX:HeapDumpPath=MojangTricksIntelDriversForPerformance_javaw.exe_minecraft.exe.heapdump -Xmx2G -XX:+UnlockExperimentalVMOptions -XX:+UseG1GC -XX:G1NewSizePercent=20 -XX:G1ReservePercent=20 -XX:MaxGCPauseMillis=50 -XX:G1HeapRegionSize=32M
	IntCache: cache: 0, tcache: 0, allocated: 12, tallocated: 94
	FML: MCP 9.42 Powered by Forge 14.23.2.2611 6 mods loaded, 6 mods active
	States: 'U' = Unloaded 'L' = Loaded 'C' = Constructed 'H' = Pre-initialized 'I' = Initialized 'J' = Post-initialized 'A' = Available 'D' = Disabled 'E' = Errored

	| State     | ID                | Version      | Source                        | Signature                                |
	|:--------- |:----------------- |:------------ |:----------------------------- |:---------------------------------------- |
	| UCHIJAAAA | minecraft         | 1.12.2       | minecraft.jar                 | None                                     |
	| UCHIJAAAA | mcp               | 9.42         | minecraft.jar                 | None                                     |
	| UCHIJAAAA | FML               | 8.0.99.99    | forge-1.12.2-14.23.2.2611.jar | e3c3d50c7c986df74c645c0ac54639741c90a557 |
	| UCHIJAAAA | forge             | 14.23.2.2611 | forge-1.12.2-14.23.2.2611.jar | e3c3d50c7c986df74c645c0ac54639741c90a557 |
	| UCHIJAAAA | mercurius_updater | 1.0          | MercuriusUpdater-1.12.2.jar   | None                                     |
	| UCHIJAAAA | hm                | 1.1          | Hard_Mod-1.7.jar              | None                                     |

	Loaded coremods (and transformers): 
	GL info: ~~ERROR~~ RuntimeException: No OpenGL context found in the current thread.
	Profiler Position: N/A (disabled)
	Player Count: 1 / 8; [EntityPlayerMP['JeanMichouAK47'/1391, l='Test_Vache_Sound', x=-24.50, y=68.00, z=-96.50]]
	Type: Integrated Server (map_client.txt)
	Is Modded: Definitely; Client brand changed to 'fml,forge'

December 16, 2018

It works well with this code for those who are interested in

@EventBusSubscriber
public class SoundsHandler {
		
	@SubscribeEvent
	public static void onSoundPlayed(PlaySoundAtEntityEvent  event)
	{				
		if(event.getSound() == SoundEvents.ENTITY_COW_AMBIENT)
		{
			event.setSound(SoundInit.ENTITY_COW_AMBIENT);
		}
	}

}

where SoundInit.ENTITY_COW_AMBIENT is your custom sound. Thank you.

December 16, 2018

Ok thank you. I'll try this ! (2nd case)

December 16, 2018

Hey, I wanted to know if there was a way to do custom sounds for animals (I am looking for "mooEvent" for example and then play sound when this event is called). Thank you.

April 18, 2018

Working fine with your tutorial thank you. Do you know if there is a file format which I can use (and a software) to design my tree that allows me not to do a line of code for each block. For example if I want to do a complex giant tree that doesn't follow any simple rule. Thank you

April 17, 2018

I'll try this tomorrow but do I have to do the exact same thing as if I wanted to create a custom tree (except log block and leaves block) ? Thank you

April 17, 2018

A normal oak is growing when i put bone meal on sapling. I'm expecting to have a tree taller than 12 blocks and with a thiner aspect maybe like a maple

April 17, 2018

Hi all, I want to remaster trees in Minecraft to generate a world with trees that have a custom pattern. So I watched videos about it and I tried to reproduce the tree with already existing blocks (oak log, sapling, etc...). In the video the guy plants a tree and he has the wanted pattern but it doesn't work with mine. Can you help me (I'll remake the pattern later I just want to see how it works) ? Thank you and sorry for my english

package com.laurentoutang.hardmod.world.gen.feature;

import java.util.Random;

import net.minecraft.block.BlockLeaves;
import net.minecraft.block.BlockLog;
import net.minecraft.block.BlockOldLeaf;
import net.minecraft.block.BlockOldLog;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockPlanks.EnumType;
import net.minecraft.block.BlockSapling;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.IChunkGenerator;
import net.minecraft.world.gen.feature.WorldGenAbstractTree;
import net.minecraftforge.common.IPlantable;
import net.minecraftforge.event.terraingen.DecorateBiomeEvent;
import net.minecraftforge.fml.common.IWorldGenerator;

public class WorldGenRemasteredOak extends WorldGenAbstractTree
{
	public static IBlockState LOG = Blocks.LOG.getDefaultState().withProperty(BlockOldLog.VARIANT, BlockPlanks.EnumType.OAK);
	public static IBlockState LEAF = Blocks.LEAVES.getDefaultState().withProperty(BlockOldLeaf.VARIANT, BlockPlanks.EnumType.OAK).withProperty(BlockLeaves.CHECK_DECAY, Boolean.valueOf(false));
	
	private int minHeight;
	private int varHeight;
	
	
	public WorldGenRemasteredOak(boolean notify) {
		super(false);
		minHeight = 12;
		varHeight = 3;
	}

	@Override
	public boolean generate(World worldIn, Random rand, BlockPos position) {
		
		int height = this.minHeight + rand.nextInt(varHeight);
		
		boolean flag = true;
		
		int x = position.getX();
		int y = position.getY();
		int z = position.getZ();
		
		for(int yPos = y; yPos <= y + 1 + height; yPos++)
		{
			int b0 = 2;
			if(yPos == y)
			{
				b0 = 1;
			}
			if(yPos >= y + 1 + height - 2)
			{
				b0 = 2;
			}
			BlockPos.MutableBlockPos mutable = new BlockPos.MutableBlockPos();
			
			for(int xPos = x - b0; xPos <= x + b0 && flag; xPos++)
			{
				for(int zPos = z - b0; zPos <= z + b0 && flag; zPos++)
				{
					if(yPos >= 0 && yPos < worldIn.getHeight())
					{
						if(!this.isReplaceable(worldIn, new BlockPos(xPos, yPos, zPos)))
						{
							flag = false;
						}						
					}
					else
					{
						flag = false;
					}
				}
			}
		}
		if(!flag)
		{
			return false;
		}
		else
		{
			BlockPos down = position.down();
			IBlockState state = worldIn.getBlockState(down);
			boolean isSoil = state.getBlock().canSustainPlant(state, worldIn, down, EnumFacing.UP, (BlockSapling)Blocks.SAPLING);
			if(isSoil && y < worldIn.getHeight() - height -1)
			{
				state.getBlock().onPlantGrow(state, worldIn, down, position);
				
				for(int yPos = y -3 + height; yPos <= y + height; yPos++)
				{
					int b1 = yPos - (y + height);
					int b2 = 1 - b1 /2;
					
					for(int xPos = x - b2; xPos <= x + b2; xPos++)
					{
						int b3 = xPos -x;
						for(int zPos = z - b2; zPos <= z + b2; zPos++)
						{
							int b4 = zPos-z;
							if(Math.abs(b3) != b2 || Math.abs(b4) != b2 || rand.nextInt(2) != 0 && b1 != 0)
							{
								BlockPos treePos = new BlockPos(xPos, yPos, zPos);
								IBlockState treeState = worldIn.getBlockState(treePos);
								if(treeState.getBlock().isAir(treeState, worldIn, position) || treeState.getBlock().isLeaves(treeState, worldIn, position))
								{
									this.setBlockAndNotifyAdequately(worldIn, treePos, LEAF);
									this.setBlockAndNotifyAdequately(worldIn, treePos.add(0,-0.25 * height, 0), LEAF);
									this.setBlockAndNotifyAdequately(worldIn, treePos.add(0,-0.5 * height, 0), LEAF);
								}
							}
						}
					}
				}
				for(int logHeight = 0; logHeight < height; logHeight++)
				{
					BlockPos up = position.up(logHeight);
					IBlockState logState = worldIn.getBlockState(up);
					if(logState.getBlock().isAir(logState, worldIn, position) || logState.getBlock().isLeaves(logState, worldIn, position))
					{ 
						this.setBlockAndNotifyAdequately(worldIn, position.up(logHeight), LOG);
					}
				}
				return true;
			}
		}
		return true;
	}
	
	

}

I'll see with the world generation later

April 4, 2018

I'm doing it with the class WorldProviderSurface, it works fine, I'll try to handle issues with sleeping and commands. Thank you

April 2, 2018

27 minutes ago, Draco18s said:

...what?

+- 1 tick

26 minutes ago, Ruukas said:

As you say, you need a WorldProvider (although, "need" is rarely the correct word to use about coding)

Ok thank you

April 2, 2018

Yes I searched but I didn't find something really detailed. If I change ticks, does it affect the render like player speed on screen or this kind of stuff ? If I want that snow fall from the sky in winter should I also do a WorldProvider (if I must do this I will probably take the WorldProvider option for the time) ? Thank you

April 1, 2018

Hello,
Do you know a way to modify the length of a day (and a nigth) without doing a new WorldProvider. I want that the length of a day follows a function like : 5 * sin( 2*pi*f*DAY_COUNT + p ) + 10 in order to put a 15m day in summer and a 5m day in winter. Thank's for the help and sorry for my english.

March 31, 2018

I think I've found a nice example of what I want to do rigth here https://github.com/RickyvdBerg/MC_School_Of_Mages/tree/master/src
Thank's everyone for the help !

March 29, 2018

The problem now is that when I play alone on the server the capability works. But when another player comes, it is reset to the initial values... What should I do to attach one capability for each player ? Thank you

March 28, 2018

I found a trick i modified the EventHandler class like that

package com.laurentoutang.hardmod.util.handlers;

import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;
import com.laurentoutang.hardmod.util.Reference;

import Network.MessageCapabilities;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.util.EnumHand;
import net.minecraft.util.text.TextComponentString;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.entity.player.PlayerWakeUpEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent;
import net.minecraftforge.fml.relauncher.Side;

@EventBusSubscriber
public class EventHandler {
	static IMentalTemperature capabilities;
	@SubscribeEvent
	 public static void onPlayerLogsIn(PlayerLoggedInEvent event)
	 {

		 EntityPlayer player = event.player;

		 
		 
		 capabilities = player.getCapability(MentalTemperatureProvider.MentalTemperature_CAP, null);
		 if(capabilities != null)
		 {
			 capabilities.consumeMental(2.f);
			 String message = String.format("Logged in : mental = " + capabilities.getMental());
			 player.sendMessage(new TextComponentString(message));
		 }		
	 }	 
	 @SubscribeEvent
	 public static void onPlayerInteract(PlayerInteractEvent event)
	 {
		 EntityPlayer player = event.getEntityPlayer();
		 if(event.getHand() == EnumHand.MAIN_HAND)
		 {
			 if(capabilities != null)
			 {
				 capabilities.consumeMental(1.f);
				 String message = String.format("Player interact mental = " + capabilities.getMental());
				 player.sendMessage(new TextComponentString(message));
			 }	
		 }
		 	
	 }
	 
}

Because the log player event is the first that is called for what I need, it works. But I'm pretty sure there is a better way to do it...

March 27, 2018

IMentalTemperature

package com.laurentoutang.hardmod.capabilities;

public interface IMentalTemperature {

	public void consumeMental(float points);
	public void fillMental(float points);
	public void setMental(float points);
	public float getMental();
	
	public void consumeTemperature(float points);
	public void fillTemperature(float points);
	public void setTemperature(float points);
	public float getTemperature();
}

MentalTemperature

package com.laurentoutang.hardmod.capabilities;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.common.util.INBTSerializable;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;

public class MentalTemperature implements IMentalTemperature{

	private float mental = 100.f;
	private float temperature = 100.f;
	
	public MentalTemperature(float mental, float temperature)
	{
		this.mental = mental;
		this.temperature = temperature;
	}
	public MentalTemperature()
	{
		
	}
	
	@Override
	public void consumeMental(float points) 
	{
		if(mental-points < 0)
			mental = 0;
		else
			mental -= points;
	}

	@Override
	public void fillMental(float points) 
	{
		if(mental + points > 100)
			mental = 100;
		else
			mental += points;
	}

	@Override
	public void setMental(float points) 
	{
		mental = points;
	}

	@Override
	public float getMental() 
	{
		return mental;
	}	

	public void consumeTemperature(float points)
	{
		if(temperature-points < 0)
			temperature = 0;
		else
			temperature -= points;
	}
	public void fillTemperature(float points)
	{
		if(temperature + points > 100)
			temperature = 100;
		else
			temperature += points;
	}
	public void setTemperature(float points)
	{
		temperature = points;
	}
	public float getTemperature()
	{
		return temperature;
	}
}

MentalTemperatureProvider

package com.laurentoutang.hardmod.capabilities;

import java.util.concurrent.Callable;


import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTPrimitive;
import net.minecraft.nbt.NBTTagFloat;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.CapabilityInject;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.common.capabilities.ICapabilitySerializable;
import net.minecraftforge.common.capabilities.Capability.IStorage;

public class MentalTemperatureProvider implements ICapabilitySerializable<NBTBase>{

	@CapabilityInject(IMentalTemperature.class)
	public static final Capability<IMentalTemperature> MentalTemperature_CAP = null;
	
	private IMentalTemperature instance = MentalTemperature_CAP.getDefaultInstance(); 

	
	

	 
	 @Override
	 public boolean hasCapability(Capability<?> capability, EnumFacing facing)
	 {
		 
		 return capability == MentalTemperature_CAP;

	 }

	 
	 @Override
	 public <T> T getCapability(Capability<T> capability, EnumFacing facing)
	 {
		 if (MentalTemperature_CAP != null && capability == MentalTemperature_CAP) return MentalTemperature_CAP.<T> cast(this.instance);
		 return null;
	 }
	 
	 
	 @Override
	 public NBTBase serializeNBT()
	 {

		 return MentalTemperature_CAP.getStorage().writeNBT(MentalTemperature_CAP, this.instance, null);

	 }

	 
	 @Override
	 public void deserializeNBT(NBTBase nbt)
	 {

		 MentalTemperature_CAP.getStorage().readNBT(MentalTemperature_CAP, this.instance, null, nbt);

	 } 

}

MentalTemperatureStorage

package com.laurentoutang.hardmod.capabilities;

import net.minecraft.inventory.ItemStackHelper;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTPrimitive;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagFloat;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.Capability.IStorage;
import net.minecraftforge.common.capabilities.CapabilityManager;

public class MentalTemperatureStorage implements IStorage<IMentalTemperature>{

	
	 @Override
	 public NBTBase writeNBT(Capability<IMentalTemperature> capability, IMentalTemperature instance, EnumFacing side)
	 {
		 NBTTagCompound tag = new NBTTagCompound();
		 tag.setFloat("Mental", instance.getMental());
		 tag.setFloat("Temperature", instance.getTemperature());
		 
		 return tag;
	 }
	 
	 @Override
	 public void readNBT(Capability<IMentalTemperature> capability, IMentalTemperature instance, EnumFacing side, NBTBase nbt)
	 {
		 NBTTagCompound tag = ((NBTTagCompound)nbt);
		 instance.setMental(tag.getFloat("Mental"));
		 instance.setTemperature(tag.getFloat("Temperature"));
	 }
	
}

ClientProxy

package com.laurentoutang.hardmod.proxy;

import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureStorage;
import com.laurentoutang.hardmod.util.handlers.CapabilityHandler;
import com.laurentoutang.hardmod.util.handlers.MessageCapabilitiesHandler;

import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.util.IThreadListener;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import net.minecraftforge.fml.relauncher.Side;

public class ClientProxy extends CommonProxy {
	
	public void init() 
	{		
		MinecraftForge.EVENT_BUS.register(new MessageCapabilitiesHandler());
	}
	public IThreadListener getListener(MessageContext ctx) {
		return ctx.side == Side.CLIENT ? Minecraft.getMinecraft() : super.getListener(ctx);
	}

	public EntityPlayer getPlayer(MessageContext ctx) {
		return ctx.side == Side.CLIENT ? Minecraft.getMinecraft().player : super.getPlayer(ctx);
	}
	public void registerItemRenderer(Item item, int meta, String id) 
	{
		ModelLoader.setCustomModelResourceLocation(item,  meta,  new ModelResourceLocation(item.getRegistryName(), id));
	}
}

CommonProxy

package com.laurentoutang.hardmod.proxy;



import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.util.IThreadListener;
import net.minecraft.world.WorldServer;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;

public class CommonProxy 
{
	public void init() {
		
	}
	
	public IThreadListener getListener(MessageContext ctx) {
		return (WorldServer) ctx.getServerHandler().player.getServerWorld();
	}

	public EntityPlayer getPlayer(MessageContext ctx) {
		return ctx.getServerHandler().player;
	}
	public void registerItemRenderer(Item item, int meta, String id)
	{
		
	}
	
}

CapabilityHandler

package com.laurentoutang.hardmod.util.handlers;

import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;
import com.laurentoutang.hardmod.util.Reference;

import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.event.AttachCapabilitiesEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.relauncher.Side;

@EventBusSubscriber
public class CapabilityHandler {
	
	 public static final ResourceLocation MentalTemperature_CAP = new ResourceLocation(Reference.MOD_ID, "mentaltemperature");

	 
	 @SubscribeEvent

	 public static void attachCapability(AttachCapabilitiesEvent<Entity> event)
	 {
		 if (event.getObject() instanceof EntityPlayer)
		 {
			 event.addCapability(MentalTemperature_CAP, new MentalTemperatureProvider());	
		 }
	 }
}

EventHandler

package com.laurentoutang.hardmod.util.handlers;

import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;
import com.laurentoutang.hardmod.util.Reference;

import Network.MessageCapabilities;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.util.EnumHand;
import net.minecraft.util.text.TextComponentString;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.entity.player.PlayerWakeUpEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent;
import net.minecraftforge.fml.relauncher.Side;

@EventBusSubscriber
public class EventHandler {

	@SubscribeEvent
	 public static void onPlayerLogsIn(PlayerLoggedInEvent event)
	 {

		 EntityPlayer player = event.player;

		 
		 
		 IMentalTemperature capabilities = player.getCapability(MentalTemperatureProvider.MentalTemperature_CAP, null);
		 if(capabilities != null)
		 {
			 capabilities.consumeMental(2.f);
			 String message = String.format("Logged in : mental = " + capabilities.getMental());
			 player.sendMessage(new TextComponentString(message));
		 }		
	 }	 
	 @SubscribeEvent
	 public static void onPlayerInteract(PlayerInteractEvent event)
	 {
		 EntityPlayer player = event.getEntityPlayer();
		 if(event.getHand() == EnumHand.MAIN_HAND)
		 {
			 IMentalTemperature capabilities = player.getCapability(MentalTemperatureProvider.MentalTemperature_CAP, null);
			 if(capabilities != null)
			 {
				 capabilities.consumeMental(1.f);
				 String message = String.format("Player interact mental = " + capabilities.getMental());
				 player.sendMessage(new TextComponentString(message));
			 }	
		 }
		 	
	 }
	 
}

MessageCapabilityHandler

package com.laurentoutang.hardmod.util.handlers;

import java.util.List;

import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;

import Network.MessageCapabilities;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.util.IThreadListener;
import net.minecraft.util.text.TextComponentString;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import net.minecraftforge.fml.relauncher.Side;


@EventBusSubscriber(value = Side.CLIENT)
public class MessageCapabilitiesHandler implements IMessageHandler<MessageCapabilities, IMessage>{

	@Override
	public IMessage onMessage(MessageCapabilities message, MessageContext ctx) 
	{
		
		
		final float mental = message.getMental();
		final float temperature = message.getTemperature();
		Minecraft minecraft = Minecraft.getMinecraft();
	    final WorldClient worldClient = minecraft.world;
	    minecraft.addScheduledTask(new Runnable()
	    {
	      public void run() {
	        processMessage(worldClient, message);
	      }
	    });
		return null;
	}
	 void processMessage(WorldClient worldClient, MessageCapabilities message)
	  {
		List<EntityPlayer> players = worldClient.playerEntities;
	    for(int i = 0; i < players.size(); i++)
	    {
	    	players.get(i).sendMessage(new TextComponentString("You have " + message.getMental() + " mental left and " + message.getTemperature() + " temperature left"));
	    }
	    return;
	  }


}

PacketHandler

package com.laurentoutang.hardmod.util.handlers;

import net.minecraftforge.fml.common.network.NetworkRegistry;
import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;

public class PacketHandler {
	public static final SimpleNetworkWrapper NETWORK = NetworkRegistry.INSTANCE.newSimpleChannel("hm");
}

MessageCapability

package Network;

import io.netty.buffer.ByteBuf;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;

public class MessageCapabilities implements IMessage{
	
	private float mentalToSend, temperatureToSend;
	
	public MessageCapabilities() {}
	
	public MessageCapabilities(float mentalToSend, float temperatureToSend)
	{
		this.mentalToSend = mentalToSend;
		this.temperatureToSend = temperatureToSend;
	}
	
	@Override
	public void fromBytes(ByteBuf buf) 
	{
		this.mentalToSend = buf.readFloat();
		this.temperatureToSend = buf.readFloat();	
	}

	@Override
	public void toBytes(ByteBuf buf) 
	{
		buf.writeFloat(this.mentalToSend);
		buf.writeFloat(this.temperatureToSend);		
	}
	public float getMental()
	{
		return mentalToSend;
	}
	public float getTemperature()
	{
		return temperatureToSend;
	}

}

Main

package com.laurentoutang.hardmod;

import org.apache.logging.log4j.core.jmx.Server;

import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureStorage;
import com.laurentoutang.hardmod.proxy.CommonProxy;
import com.laurentoutang.hardmod.util.Reference;
import com.laurentoutang.hardmod.util.handlers.MessageCapabilitiesHandler;
import com.laurentoutang.hardmod.util.handlers.PacketHandler;

import Network.MessageCapabilities;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.server.MinecraftServer;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.event.entity.player.PlayerWakeUpEvent;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.Mod.EventHandler;
import net.minecraftforge.fml.common.Mod.Instance;
import net.minecraftforge.fml.common.SidedProxy;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.event.FMLServerStartedEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;

@Mod(modid = Reference.MOD_ID, name = Reference.NAME, version  = Reference.VERSION)
public class Main {
	
	
	
	
	@Instance
	public static Main instance;
	
	@SidedProxy(clientSide = Reference.CLIENT_PROXY_CLASS, serverSide = Reference.COMMON_PROXY_CLASS)
	public static CommonProxy proxy;
	
	@EventHandler
	public static void PreInit(FMLPreInitializationEvent event)
	{
		CapabilityManager.INSTANCE.register(IMentalTemperature.class, new MentalTemperatureStorage(), MentalTemperature::new);
		PacketHandler.NETWORK.registerMessage(MessageCapabilitiesHandler.class, MessageCapabilities.class, 0, Side.SERVER);
	}
	
	@EventHandler
	public static void init(FMLInitializationEvent event)
	{
	}
	
	@EventHandler
	public static void PostInit(FMLPostInitializationEvent event)
	{
		
	}
	
	
}

Here is the code. The problem is that in EventHandler class the two events do not give the same value for mental. When I connect i see a value that is modified at each connection (fine) but when i click, it starts from 100 everytime. So I created packets (thanks to tutorials) but I do not know how to sync capabilities with it ?

public static final Capability<IMentalTemperature> MentalTemperature_CAP = null;
private IMentalTemperature instance = MentalTemperature_CAP.getDefaultInstance();

for these lines I found it on 2 different tutorials. I dont't know how I should instantiate the MentalTemperature_CAP otherwise. Thank you for you help and your attention

March 26, 2018

Do you have any idea how I should use the classes that i created ? The problem is that the MentalTemperature have not the same value in the two events...

March 25, 2018

here is the declaration

 @Nullable
    public T getDefaultInstance()
    {
        try
        {
            return this.factory.call();
        }
        catch (Exception e)
        {
            Throwables.throwIfUnchecked(e);
            throw new RuntimeException(e);
        }
    }

March 25, 2018

I understand what you mean but I do not have NullPointerException so where am I supposed to initialize "instance" please ?

March 25, 2018

What do you mean ?

March 25, 2018

package com.laurentoutang.hardmod.capabilities;

import java.util.concurrent.Callable;

import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTPrimitive;
import net.minecraft.nbt.NBTTagFloat;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.CapabilityInject;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.common.capabilities.ICapabilitySerializable;
import net.minecraftforge.common.capabilities.Capability.IStorage;

public class MentalTemperatureProvider implements ICapabilitySerializable<NBTBase>{

	@CapabilityInject(IMentalTemperature.class)

	 public static final Capability<IMentalTemperature> MentalTemperature_CAP = null;

	 
	 private IMentalTemperature instance = MentalTemperature_CAP.getDefaultInstance();

	 
	 @Override
	 public boolean hasCapability(Capability<?> capability, EnumFacing facing)
	 {

		 return capability == MentalTemperature_CAP;

	 }

	 
	 @Override
	 public <T> T getCapability(Capability<T> capability, EnumFacing facing)
	 {
		 if (MentalTemperature_CAP != null && capability == MentalTemperature_CAP) return MentalTemperature_CAP.<T> cast(this.instance);
		 return null;
	 }
	 
	 
	 @Override
	 public NBTBase serializeNBT()
	 {

		 return MentalTemperature_CAP.getStorage().writeNBT(MentalTemperature_CAP, this.instance, null);

	 }

	 
	 @Override
	 public void deserializeNBT(NBTBase nbt)
	 {

		 MentalTemperature_CAP.getStorage().readNBT(MentalTemperature_CAP, this.instance, null, nbt);

	 } 

}

March 25, 2018

It was a problem about CapabilityHandler, I fixed it:

package com.laurentoutang.hardmod.util.handlers;

import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;
import com.laurentoutang.hardmod.util.Reference;

import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.event.AttachCapabilitiesEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.relauncher.Side;

@EventBusSubscriber
public class CapabilityHandler {
	
	 public static final ResourceLocation MentalTemperature_CAP = new ResourceLocation(Reference.MOD_ID, "mentaltemperature");

	 
	 @SubscribeEvent

	 public static void attachCapability(AttachCapabilitiesEvent<Entity> event)
	 {
		 if (event.getObject() instanceof EntityPlayer)
		 {
			 event.addCapability(MentalTemperature_CAP, new MentalTemperatureProvider());	
		 }
	 }
}

But capabilities are not sync when I use events:

package com.laurentoutang.hardmod.util.handlers;

import com.laurentoutang.hardmod.capabilities.IMentalTemperature;
import com.laurentoutang.hardmod.capabilities.MentalTemperatureProvider;
import com.laurentoutang.hardmod.util.Reference;

import Network.MessageCapabilities;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.util.EnumHand;
import net.minecraft.util.text.TextComponentString;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.entity.player.PlayerWakeUpEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent;
import net.minecraftforge.fml.relauncher.Side;

@EventBusSubscriber
public class EventHandler {

	@SubscribeEvent
	 public static void onPlayerLogsIn(PlayerLoggedInEvent event)
	 {

		 EntityPlayer player = event.player;

		 
		 
		 IMentalTemperature capabilities = player.getCapability(MentalTemperatureProvider.MentalTemperature_CAP, null);
		 if(capabilities != null)
		 {
			 capabilities.consumeMental(2.f);
			 String message = String.format("Logged in : mental = " + capabilities.getMental());
			 player.sendMessage(new TextComponentString(message));
		 }		
	 }	 
	 @SubscribeEvent
	 public static void onPlayerInteract(PlayerInteractEvent event)
	 {
		 EntityPlayer player = event.getEntityPlayer();
		 if(event.getHand() == EnumHand.MAIN_HAND)
		 {
			 IMentalTemperature capabilities = player.getCapability(MentalTemperatureProvider.MentalTemperature_CAP, null);
			 if(capabilities != null)
			 {
				 capabilities.consumeMental(1.f);
				 String message = String.format("Player interact mental = " + capabilities.getMental());
				 player.sendMessage(new TextComponentString(message));
			 }	
		 }
		 	
	 }
	 
}

How am I supposed to use packets with capabilities (if the previous code was correct) please ?

Sign In

LaurentOutang

Posts

Joined

Last visited

Content Type

Profiles

Forums

Posts posted by LaurentOutang

Continuous right click item

Reflection problem + season update server side

Reflection problem + season update server side

Reflection problem + season update server side

[1.12] Animal sound

[1.12] Animal sound

[1.12] Animal sound

[1.12.2] Remaster oaks

[1.12.2] Remaster oaks

[1.12.2] Remaster oaks

[1.12.2] Remaster oaks

day / night cycle

day / night cycle

day / night cycle

day / night cycle

Capabilities

Capabilities

Capabilities

Capabilities

Capabilities

Capabilities

Capabilities

Capabilities

Capabilities

Capabilities

Browse

Activity

Important Information