ForgePatch/src/test/java/net/minecraftforge/debug/ModelAnimationDebug.java

package net.minecraftforge.debug;

import net.minecraft.block.Block;
import net.minecraft.block.BlockPistonBase;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.client.renderer.entity.RenderLiving;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.SharedMonsterAttributes;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.client.model.ModelLoaderRegistry;
import net.minecraftforge.client.model.animation.Animation;
import net.minecraftforge.client.model.animation.AnimationTESR;
import net.minecraftforge.client.model.b3d.B3DLoader;
import net.minecraftforge.client.model.pipeline.VertexLighterSmoothAo;
import net.minecraftforge.common.animation.Event;
import net.minecraftforge.common.animation.ITimeValue;
import net.minecraftforge.common.animation.TimeValues.VariableValue;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.ICapabilityProvider;
import net.minecraftforge.common.model.animation.CapabilityAnimation;
import net.minecraftforge.common.model.animation.IAnimationStateMachine;
import net.minecraftforge.common.property.ExtendedBlockState;
import net.minecraftforge.common.property.IUnlistedProperty;
import net.minecraftforge.common.property.Properties;
import net.minecraftforge.fml.client.registry.ClientRegistry;
import net.minecraftforge.fml.client.registry.IRenderFactory;
import net.minecraftforge.fml.client.registry.RenderingRegistry;
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.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.registry.EntityRegistry;
import net.minecraftforge.fml.common.registry.GameRegistry;

import com.google.common.collect.ImmutableMap;

@Mod(modid = ModelAnimationDebug.MODID, version = ModelAnimationDebug.VERSION)
public class ModelAnimationDebug
{
    public static final String MODID = "forgedebugmodelanimation";
    public static final String VERSION = "0.0";

    public static String blockName = "test_animation_block";
    public static ResourceLocation blockId = new ResourceLocation(MODID, blockName);
    public static final PropertyDirection FACING = PropertyDirection.create("facing");

    @Instance(MODID)
    public static ModelAnimationDebug instance;

    @SidedProxy
    public static CommonProxy proxy;

    public static abstract class CommonProxy
    {
        public void preInit(FMLPreInitializationEvent event)
        {
            GameRegistry.register(new Block(Material.WOOD)
            {
                {
                    setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
                    setUnlocalizedName(MODID + "." + blockName);
                    setRegistryName(blockId);
                }

                @Override
                public ExtendedBlockState createBlockState()
                {
                    return new ExtendedBlockState(this, new IProperty[]{ FACING, Properties.StaticProperty }, new IUnlistedProperty[]{ Properties.AnimationProperty });
                }

                @Override
                public boolean isOpaqueCube(IBlockState state) { return false; }

                @Override
                public boolean isFullCube(IBlockState state) { return false; }

                @Override
                public IBlockState onBlockPlaced(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
                {
                    return this.getDefaultState().withProperty(FACING, BlockPistonBase.getFacingFromEntity(pos, placer));
                }

                @Override
                public IBlockState getStateFromMeta(int meta) {
                    return getDefaultState().withProperty(FACING, EnumFacing.getFront(meta));
                }

                @Override
                public int getMetaFromState(IBlockState state) {
                    return ((EnumFacing)state.getValue(FACING)).getIndex();
                }

                @Override
                public boolean hasTileEntity(IBlockState state) {
                    return true;
                }

                @Override
                public TileEntity createTileEntity(World world, IBlockState state) {
                    return new Chest();
                }

                @Override
                public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
                    return state.withProperty(Properties.StaticProperty, true);
                }

                /*@Override
                public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
                    TileEntity te = world.getTileEntity(pos);
                    if(te instanceof Chest && state instanceof IExtendedBlockState)
                    {
                        return ((Chest)te).getState((IExtendedBlockState)state);
                    }
                    return super.getExtendedState(state, world, pos);
                }*/

                @Override
                public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ)
                {
                    if(world.isRemote)
                    {
                        TileEntity te = world.getTileEntity(pos);
                        if(te instanceof Chest)
                        {
                            ((Chest)te).click(player.isSneaking());
                        }
                    }
                    return true;
                }
            });
            GameRegistry.register(new ItemBlock(Block.REGISTRY.getObject(blockId))
            {
                @Override
                public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
                {
                    return new ItemAnimationHolder();
                }
            }.setRegistryName(blockId));
            GameRegistry.registerTileEntity(Chest.class, MODID + ":" + "tile_" + blockName);
        }

        public abstract IAnimationStateMachine load(ResourceLocation location, ImmutableMap<String, ITimeValue> parameters);
    }

    public static class ServerProxy extends CommonProxy
    {
        public IAnimationStateMachine load(ResourceLocation location, ImmutableMap<String, ITimeValue> parameters)
        {
            return null;
        }
    }

    public static class ClientProxy extends CommonProxy
    {
        @Override
        public void preInit(FMLPreInitializationEvent event)
        {
            super.preInit(event);
            B3DLoader.INSTANCE.addDomain(MODID);
            ModelLoader.setCustomModelResourceLocation(Item.REGISTRY.getObject(blockId), 0, new ModelResourceLocation(blockId, "inventory"));
            ClientRegistry.bindTileEntitySpecialRenderer(Chest.class, new AnimationTESR<Chest>()
            {
                @Override
                public void handleEvents(Chest chest, float time, Iterable<Event> pastEvents)
                {
                    chest.handleEvents(time, pastEvents);
                }
            });
            String entityName = MODID + ":entity_chest";
            //EntityRegistry.registerGlobalEntityID(EntityChest.class, entityName, EntityRegistry.findGlobalUniqueEntityId());
            EntityRegistry.registerModEntity(EntityChest.class, entityName, 0, ModelAnimationDebug.instance, 64, 20, true, 0xFFAAAA00, 0xFFDDDD00);
            RenderingRegistry.registerEntityRenderingHandler(EntityChest.class, new IRenderFactory<EntityChest>()
            {
                @SuppressWarnings("deprecation")
                public Render<EntityChest> createRenderFor(RenderManager manager)
                {
                    /*model = ModelLoaderRegistry.getModel(new ResourceLocation(ModelLoaderRegistryDebug.MODID, "block/chest.b3d"));
                    if(model instanceof IRetexturableModel)
                    {
                        model = ((IRetexturableModel)model).retexture(ImmutableMap.of("#chest", "entity/chest/normal"));
                    }
                    if(model instanceof IModelCustomData)
                    {
                        model = ((IModelCustomData)model).process(ImmutableMap.of("mesh", "[\"Base\", \"Lid\"]"));
                    }*/
                    ResourceLocation location = new ModelResourceLocation(new ResourceLocation(MODID, blockName), "entity");
                    return new RenderLiving<EntityChest>(manager, new net.minecraftforge.client.model.animation.AnimationModelBase<EntityChest>(location, new VertexLighterSmoothAo(Minecraft.getMinecraft().getBlockColors()))
                        {
                            @Override
                            public void handleEvents(EntityChest chest, float time, Iterable<Event> pastEvents)
                            {
                                chest.handleEvents(time, pastEvents);
                            }
                        }, 0.5f)
                    {
                        protected ResourceLocation getEntityTexture(EntityChest entity)
                        {
                            return TextureMap.LOCATION_BLOCKS_TEXTURE;
                        }
                    };
                }
            });
        }

        public IAnimationStateMachine load(ResourceLocation location, ImmutableMap<String, ITimeValue> parameters)
        {
            return ModelLoaderRegistry.loadASM(location, parameters);
        }

    }

    private static class ItemAnimationHolder implements ICapabilityProvider
    {
        private final VariableValue cycleLength = new VariableValue(4);

        private final IAnimationStateMachine asm = proxy.load(new ResourceLocation(MODID.toLowerCase(), "asms/block/engine.json"), ImmutableMap.<String, ITimeValue>of(
            "cycle_length", cycleLength
        ));

        public boolean hasCapability(Capability<?> capability, EnumFacing facing)
        {
            return capability == CapabilityAnimation.ANIMATION_CAPABILITY;
        }

        public <T> T getCapability(Capability<T> capability, EnumFacing facing)
        {
            if(capability == CapabilityAnimation.ANIMATION_CAPABILITY)
            {
                return CapabilityAnimation.ANIMATION_CAPABILITY.cast(asm);
            }
            return null;
        }
    }

    @EventHandler
    public void preInit(FMLPreInitializationEvent event) { proxy.preInit(event); }

    public static class Chest extends TileEntity
    {
        private final IAnimationStateMachine asm;
        private final VariableValue cycleLength = new VariableValue(4);
        private final VariableValue clickTime = new VariableValue(Float.NEGATIVE_INFINITY);
        //private final VariableValue offset = new VariableValue(0);

        public Chest() {
            /*asm = proxy.load(new ResourceLocation(MODID.toLowerCase(), "asms/block/chest.json"), ImmutableMap.<String, ITimeValue>of(
                "click_time", clickTime
            ));*/
            asm = proxy.load(new ResourceLocation(MODID.toLowerCase(), "asms/block/engine.json"), ImmutableMap.<String, ITimeValue>of(
                "cycle_length", cycleLength,
                "click_time", clickTime
                //"offset", offset
            ));
        }

        public void handleEvents(float time, Iterable<Event> pastEvents)
        {
            for(Event event : pastEvents)
            {
                System.out.println("Event: " + event.event() + " " + event.offset() + " " + getPos() + " " + time);
            }
        }

        @Override
        public boolean hasFastRenderer()
        {
            return true;
        }

        /*public IExtendedBlockState getState(IExtendedBlockState state) {
            return state.withProperty(B3DFrameProperty.instance, curState);
        }*/

        public void click(boolean sneaking)
        {
            if(asm != null)
            {
                if(sneaking)
                {
                    cycleLength.setValue(6 - cycleLength.apply(0));
                }
                /*else if(asm.currentState().equals("closed"))
                {
                    clickTime.setValue(Animation.getWorldTime(getWorld()));
                    asm.transition("opening");
                }
                else if(asm.currentState().equals("open"))
                {
                    clickTime.setValue(Animation.getWorldTime(getWorld()));
                    asm.transition("closing");
                }*/
                else if(asm.currentState().equals("default"))
                {
                    float time = Animation.getWorldTime(getWorld(), Animation.getPartialTickTime());
                    clickTime.setValue(time);
                    //offset.setValue(time);
                    //asm.transition("moving");
                    asm.transition("starting");
                }
                else if(asm.currentState().equals("moving"))
                {
                    clickTime.setValue(Animation.getWorldTime(getWorld(), Animation.getPartialTickTime()));
                    asm.transition("stopping");
                }
            }
        }

        @Override
        public boolean hasCapability(Capability<?> capability, EnumFacing side)
        {
            if(capability == CapabilityAnimation.ANIMATION_CAPABILITY)
            {
                return true;
            }
            return super.hasCapability(capability, side);
        }

        @Override
        public <T> T getCapability(Capability<T> capability, EnumFacing side)
        {
            if(capability == CapabilityAnimation.ANIMATION_CAPABILITY)
            {
                return CapabilityAnimation.ANIMATION_CAPABILITY.cast(asm);
            }
            return super.getCapability(capability, side);
        }
    }

    public static class EntityChest extends EntityLiving
    {
        private final IAnimationStateMachine asm;
        private final VariableValue cycleLength = new VariableValue(getHealth() / 5);

        public EntityChest(World world)
        {
            super(world);
            setSize(1, 1);
            asm = proxy.load(new ResourceLocation(MODID.toLowerCase(), "asms/block/engine.json"), ImmutableMap.<String, ITimeValue>of(
                "cycle_length", cycleLength
            ));
        }

        public void handleEvents(float time, Iterable<Event> pastEvents)
        {
            // TODO Auto-generated method stub
        }

        @Override
        public void onEntityUpdate()
        {
            super.onEntityUpdate();
            if(worldObj.isRemote && cycleLength != null)
            {
                cycleLength.setValue(getHealth() / 5);
            }
        }

        @Override
        protected void applyEntityAttributes()
        {
            super.applyEntityAttributes();
            this.getEntityAttribute(SharedMonsterAttributes.MAX_HEALTH).setBaseValue(60);
        }

        @Override
        public boolean hasCapability(Capability<?> capability, EnumFacing side)
        {
            if(capability == CapabilityAnimation.ANIMATION_CAPABILITY)
            {
                return true;
            }
            return super.hasCapability(capability, side);
        }

        @Override
        public <T> T getCapability(Capability<T> capability, EnumFacing side)
        {
            if(capability == CapabilityAnimation.ANIMATION_CAPABILITY)
            {
                return CapabilityAnimation.ANIMATION_CAPABILITY.cast(asm);
            }
            return super.getCapability(capability, side);
        }
    }
}