How to use

IButterfly

in

forestry.api.lepidopterology

private void attemptButterflySpawn(World world, IButterfly butterfly, double x, double y, double z) {
  if (BinnieCore.isLepidopteryActive()) {
    ButterflyManager.butterflyRoot.spawnButterflyInWorld(world, butterfly.copy(), x, y + 0.10000000149011612, z);
  }
}

@Override
public void mate(IIndividual individual) {
  if (!(individual instanceof IButterfly)) {
    return;
  }
  mate = ((IButterfly) individual).getGenome();
}

  @Nonnull
  @Override
  public Map<Object, Object> getMeta(@Nonnull IButterfly butterfly) {
    if (butterfly.isAnalyzed()) {
      return Collections.singletonMap("size", butterfly.getSize());
    } else {
      return Collections.emptyMap();
    }
  }
}

  @Override
  protected boolean isValid(IButterfly butterfly) {
    return butterfly.getGenome().getNocturnal() && butterfly.isPureBred(EnumButterflyChromosome.NOCTURNAL);
  }
},

@Override
protected boolean processInteract(EntityPlayer player, EnumHand hand) {
  if (isDead) {
    return false;
  }
  ItemStack stack = player.getHeldItem(hand);
  if ((stack.getItem() instanceof IToolScoop)) {
    if (!world.isRemote) {
      IButterflyRoot root = contained.getGenome().getPrimary().getRoot();
      ILepidopteristTracker tracker = root.getBreedingTracker(world, player.getGameProfile());
      ItemStack itemStack = root.getMemberStack(contained.copy(), EnumFlutterType.BUTTERFLY);
      tracker.registerCatch(contained);
      ItemStackUtil.dropItemStackAsEntity(itemStack, world, posX, posY, posZ);
      setDead();
    } else {
      player.swingArm(hand);
    }
    return true;
  }
  return false;
}

@Override
public void updateTask() {
  if (shouldContinueExecuting()) {
    if (entity.getButterfly().getMate() == null && targetMate != null) {
      if (entity.cooldownMate <= 0 && entity.getDistance(targetMate) < 9.0D) {
        entity.getButterfly().mate(targetMate.getButterfly());
        targetMate.getButterfly().mate(entity.getButterfly());
        entity.cooldownMate = EntityButterfly.COOLDOWNS;
      }
    } else if (rest != null) {
      IButterflyNursery nursery = GeneticsUtil.getOrCreateNursery(null, entity.world, rest, false);
      if (nursery != null) {
        if (nursery.canNurse(entity.getButterfly())) {
          nursery.setCaterpillar(entity.getButterfly().spawnCaterpillar(entity.world, nursery));
          //Log.finest("A butterfly '%s' laid an egg at %s/%s/%s.", entity.getButterfly().getIdent(), rest.posX, rest.posY, rest.posZ);
          if (entity.getRNG().nextFloat() < 1.0f / entity.getButterfly().getGenome().getFertility()) {
            entity.setHealth(0);
          }
        }
      }
      setHasInteracted();
      entity.cooldownEgg = EntityButterfly.COOLDOWNS;
    }
  }
}

static boolean attemptButterflySpawn(World world, IButterfly butterfly, BlockPos pos) {
  EntityLiving entityLiving = ButterflyManager.butterflyRoot.spawnButterflyInWorld(world, butterfly.copy(), pos.getX(), pos.getY() + 0.1f, pos.getZ());
  Log.trace("Spawned a butterfly '{}' at {}/{}/{}.", butterfly.getDisplayName(), pos.getX(), pos.getY(), pos.getZ());
  return entityLiving != null;
}

public void onBlockTick() {
  maturationTime++;
  IButterflyGenome caterpillarGenome = caterpillar.getGenome();
  int caterpillarMatureTime = Math
    .round((float) caterpillarGenome.getLifespan() / (caterpillarGenome.getFertility() * 2));
  if (maturationTime >= caterpillarMatureTime) {
    if (age < 2) {
      age++;
      maturationTime = 0;
      IBlockState blockState = world.getBlockState(pos);
      world.notifyBlockUpdate(pos, blockState, blockState, 0);
    } else if (caterpillar.canTakeFlight(world, getPos().getX(), getPos().getY(), getPos().getZ())) {
      NonNullList<ItemStack> cocoonDrops = caterpillar.getCocoonDrop(this);
      for (ItemStack drop : cocoonDrops) {
        ItemStackUtil.dropItemStackAsEntity(drop, world, pos);
      }
      world.setBlockToAir(getPos());
      attemptButterflySpawn(world, caterpillar, getPos());
    }
  }
}

@Override
public String getItemStackDisplayName(ItemStack itemstack) {
  if (itemstack.getTagCompound() == null) {
    return super.getItemStackDisplayName(itemstack);
  }
  IButterfly individual = ButterflyManager.butterflyRoot.getMember(itemstack);
  String customKey = "for.butterflies.custom." + type.getName() + "."
    + individual.getGenome().getPrimary().getUnlocalizedName().replace("butterflies.species.", "");
  if (Translator.canTranslateToLocal(customKey)) {
    return Translator.translateToLocal(customKey);
  }
  String grammar = Translator.translateToLocal("for.butterflies.grammar." + type.getName());
  String speciesString = individual.getDisplayName();
  String typeString = Translator.translateToLocal("for.butterflies.grammar." + type.getName() + ".type");
  return grammar.replaceAll("%SPECIES", speciesString).replaceAll("%TYPE", typeString);
}

@Override
public ItemStack getCraftingResult(InventoryCrafting crafting) {
  IButterfly butterfly = null;
  IButterfly serum = null;
  for (int i = 0; i < crafting.getSizeInventory(); i++) {
    if (ButterflyManager.butterflyRoot.isMember(crafting.getStackInSlot(i), EnumFlutterType.BUTTERFLY)) {
      butterfly = ButterflyManager.butterflyRoot.getMember(crafting.getStackInSlot(i));
    } else if (ButterflyManager.butterflyRoot.isMember(crafting.getStackInSlot(i), EnumFlutterType.SERUM)) {
      serum = ButterflyManager.butterflyRoot.getMember(crafting.getStackInSlot(i));
    }
  }
  if (butterfly == null || serum == null) {
    return ItemStack.EMPTY;
  }
  IButterfly mated = butterfly.copy();
  mated.mate(serum);
  return ButterflyManager.butterflyRoot.getMemberStack(mated, EnumFlutterType.BUTTERFLY);
}

if (!ModuleLepidopterology.spawnRaritys.containsKey(spawn.getGenome().getPrimary().getUID())) {
  rarity = spawn.getGenome().getPrimary().getRarity();
} else {
  rarity = ModuleLepidopterology.spawnRaritys.get(spawn.getGenome().getPrimary().getUID());
if (!spawn.canSpawn(world, pos.getX(), pos.getY(), pos.getZ())) {
  return false;

@Override
public NBTTagCompound writeToNBT(NBTTagCompound nbttagcompound) {
  nbttagcompound = super.writeToNBT(nbttagcompound);
  NBTTagCompound subcompound = new NBTTagCompound();
  caterpillar.writeToNBT(subcompound);
  nbttagcompound.setTag("Caterpillar", subcompound);
  ownerHandler.writeToNBT(nbttagcompound);
  nbttagcompound.setInteger("Age", age);
  nbttagcompound.setInteger("CATMAT", maturationTime);
  nbttagcompound.setBoolean("isSolid", isSolid);
  return nbttagcompound;
}

public AnalystPageSpecimen(IWidget parent, IArea area, IButterfly ind) {
  super(parent, area);
  setColor(3355443);
  int y = 4;
  new ControlTextCentered(this, y, TextFormatting.UNDERLINE + getTitle()).setColor(getColor());
  y += 12;
  int w = Math.round((getWidth() - 16) * ind.getSize());
  new ControlIndividualDisplay(this, (getWidth() - w) / 2, y + (getWidth() - w) / 2, w, ind);
}

public boolean canFly() {
  return contained.canTakeFlight(world, posX, posY, posZ);
}

public NonNullList<ItemStack> getCocoonDrops() {
  return caterpillar.getCocoonDrop(this);
}

@Override
public void writeData(PacketBufferForestry data) {
  IButterfly caterpillar = getCaterpillar();
  String speciesUID = caterpillar.getIdent();
  data.writeString(speciesUID);
  data.writeInt(age);
}

public static boolean spawnButterfly(IButterfly butterfly, World world, BlockPos pos) {
  if (world.countEntities(EntityButterfly.class) > ModuleLepidopterology.spawnConstraint) {
    return false;
  }
  if (!butterfly.canSpawn(world, pos.getX(), pos.getY(), pos.getZ())) {
    return false;
  }
  if (world.isAirBlock(pos)) {
    return attemptButterflySpawn(world, butterfly, pos);
  }
  return false;
}

@Method(modid = GTValues.MODID_FR)
private boolean processButterflyCatch(ItemStack itemStack, EntityPlayer player, Entity entity) {
  if (entity instanceof IEntityButterfly) {
    if (player.world.isRemote) {
      return true;
    }
    if (player.capabilities.isCreativeMode || GTUtility.doDamageItem(itemStack, this.cost, false)) {
      IEntityButterfly butterfly = (IEntityButterfly) entity;
      IAlleleButterflySpecies species = butterfly.getButterfly().getGenome().getPrimary();
      species.getRoot().getBreedingTracker(entity.world, player.getGameProfile()).registerCatch(butterfly.getButterfly());
      player.world.spawnEntity(new EntityItem(player.world, entity.posX, entity.posY, entity.posZ,
        species.getRoot().getMemberStack(butterfly.getButterfly().copy(), EnumFlutterType.BUTTERFLY)));
      entity.setDead();
    }
    return true;
  }
  return false;
}

private static void attemptButterflySpawn(World world, IButterfly butterfly, BlockPos pos) {
  EntityLiving entityLiving = ButterflyManager.butterflyRoot.spawnButterflyInWorld(world, butterfly.copy(),
    pos.getX(), pos.getY() + 0.1f, pos.getZ());
  Log.trace("A caterpillar '%s' hatched at %s/%s/%s.", butterfly.getDisplayName(), pos.getX(), pos.getY(),
    pos.getZ());
}

  @Override
  protected boolean isValid(IButterfly butterfly) {
    return butterfly.getGenome().getTolerantFlyer() && butterfly.isPureBred(EnumButterflyChromosome.TOLERANT_FLYER);
  }
};