doRender(args) problem

//MainModFile.class
@SidedProxy(clientSide="mod.proxy.ClientProxy", serverSide="mod.proxy.ServerProxy")
public static CommonProxy proxy;

@EventHandler
public void init(FMLInitializationEvent event)
{
    proxy.init();
}

//CommonProxy.class
public void init()
{
    EntityRegistry.registerModEntity(EntityRopeKnot.class, "rope", 1, Mod.instance, 160, Integer.MAX_VALUE, false);
}

//ClientProxy.class
//This extends CommonProxy.class
public void init()
{
    super.init();

    RenderingRegistry.registerEntityRenderingHandler(EntityRopeKnot.class, new RenderRopeKnot());
}

//ItemRope.class
public class ItemRope extends Item
{
    public ItemRope(String name)
    {
        this.setUnlocalizedName(Mod.MODID + "." + name);
        this.setCreativeTab(Mod.creativeTab);
    }

    @Override
    public boolean onItemUse(ItemStack stack, EntityPlayer playerIn, World worldIn, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ)
    {
        Block block = worldIn.getBlockState(pos).getBlock();

        if (block instanceof BlockFence)
        {
            if (worldIn.isRemote)
            {
                return true;
            }
            else
            {
                return attach(playerIn, worldIn, pos);
            }
        }
        else
        {
            return false;
        }
    }

    //checks if the fence already has a rope or leash attached to it
    private boolean attach(EntityPlayer player, World worldIn, BlockPos fence)
    {
        EntityLeashKnot leash = EntityLeashKnot.getKnotForPosition(worldIn, fence);
        EntityRopeKnot rope = EntityRopeKnot.getKnotForPosition(worldIn, fence);
        if (leash == null && rope == null)
        {
            rope = EntityRopeKnot.createKnot(worldIn, fence);
            return true;
        }
        return false;
    }
}

//EntityRopeKnot.class
//Direct copy (+minor changes such as renaming etc.) of the EntityLeashKnot.class
//The System.out.println("here") on onUpdate() is being called, meaning that the entity spawned.
public class EntityRopeKnot extends EntityHanging
{
    public EntityRopeKnot(World worldIn)
    {
        super(worldIn);
    }

    public EntityRopeKnot(World worldIn, BlockPos pos)
    {
        super(worldIn, pos);
        this.setPosition((double)pos.getX() + 0.5D, (double)pos.getY() + 0.5D, (double)pos.getZ() + 0.5D);
        float f = 0.125F;
        float f1 = 0.1875F;
        float f2 = 0.25F;
        this.setEntityBoundingBox(new AxisAlignedBB(this.posX - 0.1875D, this.posY - 0.25D + 0.125D, this.posZ - 0.1875D, this.posX + 0.1875D, this.posY + 0.25D + 0.125D, this.posZ + 0.1875D));
    }

    @Override
    public void onUpdate()
    {
        super.onUpdate();
        System.out.println("here");
    }

    @Override
    protected void entityInit()
    {
        super.entityInit();
    }

    @Override
    public void func_174859_a(EnumFacing enumfacing) {}

    @Override
    public int getWidthPixels()
    {
        return 9;
    }

    @Override
    public int getHeightPixels()
    {
        return 9;
    }

    @Override
    public float getEyeHeight()
    {
        return -0.0625F;
    }

    @Override
    @SideOnly(Side.CLIENT)
    public boolean isInRangeToRenderDist(double distance)
    {
        return distance < 1024.0D;
    }

    @Override
    public void onBroken(Entity entity) {}

    @Override
    public boolean writeToNBTOptional(NBTTagCompound tagCompund)
    {
        return false;
    }

    @Override
    public void writeEntityToNBT(NBTTagCompound tagCompound) {}

    @Override
    public void readEntityFromNBT(NBTTagCompound tagCompund) {}

    //Todo later
    //@Override
    //public boolean interactFirst(EntityPlayer playerIn)
    //{
    //  if (!this.worldObj.isRemote)
    //  {
    //      System.out.println("dead");
    //      this.setDead();
    //      this.dropItem(Mod.ropeItem, 1);
    //  }
    //
    //  return true;
    //}

    @Override
    public boolean onValidSurface()
    {
        return this.worldObj.getBlockState(this.hangingPosition).getBlock() instanceof BlockFence;
    }

    public static EntityRopeKnot createKnot(World worldIn, BlockPos fence)
    {
        EntityRopeKnot entityropeknot = new EntityRopeKnot(worldIn, fence);
        entityropeknot.forceSpawn = true;
        System.out.println("spawn");
        worldIn.spawnEntityInWorld(entityropeknot);
        return entityropeknot;
    }

    public static EntityRopeKnot getKnotForPosition(World worldIn, BlockPos pos)
    {
        int i = pos.getX();
        int j = pos.getY();
        int k = pos.getZ();
        List list = worldIn.getEntitiesWithinAABB(EntityRopeKnot.class, new AxisAlignedBB((double)i - 1.0D, (double)j - 1.0D, (double)k - 1.0D, (double)i + 1.0D, (double)j + 1.0D, (double)k + 1.0D));
        Iterator iterator = list.iterator();
        EntityRopeKnot entityropeknot;

        do
        {
            if (!iterator.hasNext())
            {
                return null;
            }

            entityropeknot = (EntityRopeKnot)iterator.next();
        }
        while (!entityropeknot.func_174857_n().equals(pos));

        return entityropeknot;
    }
}

//RenderRopeKnot.class
//Again, a direct copy of RenderLeashKnot.class (just changed names and stuff)
//Take a look at doRender(args).
//The System.out.println("render"); never gets called.
@SideOnly(Side.CLIENT)
public class RenderRopeKnot extends Render
{
    private static final ResourceLocation TEXTURE = new ResourceLocation(Mod.MODID, "textures/entity/rope_knot.png");
    private ModelRopeKnot MODEL = new ModelRopeKnot();

    public RenderRopeKnot()
    {
        super(Minecraft.getMinecraft().getRenderManager());
    }

    private void render(EntityRopeKnot entityropeknot, double x, double y, double z, float f, float partialTicks)
    {
        GlStateManager.pushMatrix();
        GlStateManager.disableCull();
        GlStateManager.translate((float)x, (float)y, (float)z);
        float f2 = 0.0625F;
        GlStateManager.enableRescaleNormal();
        GlStateManager.scale(-1.0F, -1.0F, 1.0F);
        GlStateManager.enableAlpha();
        this.bindEntityTexture(entityropeknot);
        this.MODEL.render(entityropeknot, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, f2);
        GlStateManager.popMatrix();
        super.doRender(entityropeknot, x, y, z, f, partialTicks);
    }

    protected ResourceLocation getEntityTexture(EntityRopeKnot entity)
    {
        return TEXTURE;
    }

    @Override
    protected ResourceLocation getEntityTexture(Entity entity)
    {
        return this.getEntityTexture((EntityRopeKnot)entity);
    }

    @Override
    public void doRender(Entity entity, double x, double y, double z, float f, float partialTicks)
    {
        System.out.println("render");
        this.render((EntityRopeKnot)entity, x, y, z, f, partialTicks);
    }
}

//ModelRopeKnot.class
//Yet another direct copy of ModelLeashKnot.class (just changed names and stuff)
@SideOnly(Side.CLIENT)
public class ModelRopeKnot extends ModelBase
{
    public ModelRenderer MODEL_RENDERER;

    public ModelRopeKnot()
    {
        this(0, 0, 32, 32);
    }

    public ModelRopeKnot(int u1, int v1, int u2, int v2)
    {
        this.textureWidth = u2;
        this.textureHeight = v2;
        this.MODEL_RENDERER = new ModelRenderer(this, u1, v1);
        this.MODEL_RENDERER.addBox(-3.0F, -6.0F, -3.0F, 6, 8, 6, 0.0F);
        this.MODEL_RENDERER.setRotationPoint(0.0F, 0.0F, 0.0F);
    }

    @Override
    public void render(Entity entity, float f1, float f2, float f3, float f4, float f5, float f6)
    {
        this.setRotationAngles(f1, f2, f3, f4, f5, f6, entity);
        this.MODEL_RENDERER.render(f6);
    }

    @Override
    public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
    {
        super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
        this.MODEL_RENDERER.rotateAngleY = f3 / (180F / (float)Math.PI);
        this.MODEL_RENDERER.rotateAngleX = f4 / (180F / (float)Math.PI);
    }
}