Java 类net.minecraftforge.fml.common.Optional.Method 实例源码

@Method(modid = "aperture")
public static void handlePlaybackItem(EntityPlayer player, NBTTagCompound tag)
{
    /* To allow actors using playback item without a crash */
    if (player instanceof EntityPlayerMP)
    {
        if (tag.hasKey("CameraPlay"))
        {
            CameraAPI.playCurrentProfile((EntityPlayerMP) player);
        }
        else if (tag.hasKey("CameraProfile"))
        {
            CameraAPI.playCameraProfile((EntityPlayerMP) player, new ResourceLocation(tag.getString("CameraProfile")));
        }
    }
}

@Override
@Method(modid = "Baubles|API")
public void onWornTick(ItemStack itemstack, EntityLivingBase player) {
  if (itemstack == null || player == null) {
    return;
  }
  if (player instanceof EntityPlayer && isActive(itemstack) && hasPower(itemstack) && ((EntityPlayer) player).getHealth() > 0f) {
    MagnetController.doHoover((EntityPlayer) player);
    if (!player.world.isRemote && player.world.getTotalWorldTime() % 20 == 0) {
      // mustn't change the item that is in the slot or Baubles will ignore the change
      ItemStack changedStack = itemstack.copy();
      drainPerSecondPower(changedStack);
      IInventory baubles = BaublesUtil.instance().getBaubles((EntityPlayer) player);
      if (baubles != null) {
        for (int i = 0; i < baubles.getSizeInventory(); i++) {
          if (baubles.getStackInSlot(i) == itemstack) {
            baubles.setInventorySlotContents(i, changedStack);
          }
        }
      }
    }
  }
}

@Override
@Method(modid = MODID_BAUBLES)
public void onWornTick(ItemStack stack, EntityLivingBase player) {
    if (!player.getEntityWorld().isRemote) {
        doTick(player, stack);
    }
}

@Override
@Method(modid = MODID_BAUBLES)
public void onWornTick(ItemStack stack, EntityLivingBase player) {
    if (!player.getEntityWorld().isRemote) {
        doTick(player, stack);
    }
}

@Callback
@Method(modid = "opencomputers")
public Object[] getMass(Context context, Arguments args) {
    if(ValkyrienWarfareHooks.isBlockPartOfShip(worldObj, pos)) {
        return new Object[] { ValkyrienWarfareHooks.getShipMass(ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos)) };
    }
    return new Object[] { null };
}

@Callback
@Method(modid = "opencomputers")
public Object[] getPosition(Context context, Arguments args) {
    if(ValkyrienWarfareHooks.isBlockPartOfShip(worldObj, pos)) {
        Vector ship = new Vector(ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos));
        return new Object[] { ship.X, ship.Y, ship.Z };
    }
    return new Object[] { null };
}

@Callback
@Method(modid = "opencomputers")
public Object[] getPitch(Context context, Arguments args) {
    if(ValkyrienWarfareHooks.isBlockPartOfShip(worldObj, pos)) {
        return new Object[] { ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos).pitch };
    }
    return new Object[] { null };
}

@Callback
@Method(modid = "opencomputers")
public Object[] getYaw(Context context, Arguments args) {
    if(ValkyrienWarfareHooks.isBlockPartOfShip(worldObj, pos)) {
        return new Object[] { ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos).yaw };
    }
    return new Object[] { null };
}

@Callback
@Method(modid = "opencomputers")
public Object[] getRoll(Context context, Arguments args) {
    if(ValkyrienWarfareHooks.isBlockPartOfShip(worldObj, pos)) {
        return new Object[] { ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos).roll };
    }
    return new Object[] { null };
}

@Callback
@Method(modid = "opencomputers")
public Object[] getYawPitch(Context context, Arguments args) {
    if(ValkyrienWarfareHooks.isBlockPartOfShip(worldObj, pos)) {
        return new Object[] { ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos).yaw,
                ValkyrienWarfareHooks.getShipEntityManagingPos(worldObj, pos).pitch };
    }
    return new Object[] { null };
}

@Method(modid = "aperture")
public static void registerMessages()
{
    /* Camera management */
    Dispatcher.register(PacketPlaybackButton.class, ServerHandlerPlaybackButton.class, Side.SERVER);
    Dispatcher.register(PacketRequestProfiles.class, ServerHandlerRequestProfiles.class, Side.SERVER);
    Dispatcher.register(PacketCameraProfileList.class, ClientHandlerCameraProfileList.class, Side.CLIENT);

    Dispatcher.register(PacketRequestLength.class, ServerHandlerRequestLength.class, Side.SERVER);
    Dispatcher.register(PacketSceneLength.class, ClientHandlerSceneLength.class, Side.CLIENT);
}

@Method(modid = "aperture")
@SubscribeEvent
public void onCameraScrub(CameraEditorScrubbedEvent event)
{
    BlockPos pos = getDirectorPos();

    if (pos != null)
    {
        Dispatcher.sendToServer(new PacketDirectorGoto(pos, event.position, CameraHandler.actions));
    }
}

@Method(modid = "aperture")
@SubscribeEvent
public void onCameraPlause(CameraEditorPlaybackStateEvent event)
{
    BlockPos pos = getDirectorPos();

    if (pos != null)
    {
        Dispatcher.sendToServer(new PacketDirectorPlay(pos, event.play ? PacketDirectorPlay.PLAY : PacketDirectorPlay.PAUSE, event.position));
    }
}

@Method(modid = "aperture")
@SubscribeEvent
public void onGuiOpen(GuiOpenEvent event)
{
    if (Minecraft.getMinecraft().thePlayer == null)
    {
        return;
    }

    GuiScreen current = Minecraft.getMinecraft().currentScreen;
    GuiScreen toOpen = event.getGui();
    BlockPos pos = getDirectorPos();

    if (pos != null)
    {
        int tick = ClientProxy.cameraEditor.scrub.value;

        if (current != ClientProxy.cameraEditor && toOpen instanceof GuiCameraEditor)
        {
            /* Camera editor opens */
            CameraHandler.tick = tick;

            if (CameraHandler.reload)
            {
                Dispatcher.sendToServer(new PacketDirectorPlay(pos, PacketDirectorPlay.START, tick));
            }

            Dispatcher.sendToServer(new PacketRequestLength(pos));
        }
    }
}

@Method(modid = "theoneprobe")
@Override
public void addProbeInfo(ProbeMode mode, IProbeInfo probeInfo, EntityPlayer player, World world, IBlockState blockState, IProbeHitData data) {

    SignInfo info = getSignInfo(world, data.getPos());
    String modName = info.activateTag.equals(SignRegistry.ALWAYS_ACTIVE_TAG) ? "Minecraft" : info.activateTag;

    probeInfo.text(Colors.LIGHTGRAY + Localization.ITEM.SIGN.MATERIAL_ORIGIN.translate(Colors.WHITE + Utils.getModName(modName)));

    if (mode.equals(ProbeMode.EXTENDED) || mode.equals(ProbeMode.DEBUG)) {
        probeInfo.text(Colors.LIGHTGRAY + Localization.ITEM.SIGN.MATERIAL.translate(Colors.WHITE + info.material.materialName));
    }
}

/**
 * Registers {@link HeroBowFireHandler} and all arrows required for use with
 * Battlegear2's quiver system
 */
@Method(modid="battlegear2")
public static void registerBG2() {
    fireHandlers.add(new HeroBowFireHandler());
    fireHandlers.add(new DefaultArrowFire());
    QuiverArrowRegistry.addArrowFireHandler(new HeroBowFireHandler());
    // registering as null prevents default fire handler from handling these arrows:
    QuiverArrowRegistry.addArrowToRegistry(ZSSItems.arrowBomb, null);
    QuiverArrowRegistry.addArrowToRegistry(ZSSItems.arrowBombFire, null);
    QuiverArrowRegistry.addArrowToRegistry(ZSSItems.arrowBombWater, null);
    QuiverArrowRegistry.addArrowToRegistry(ZSSItems.arrowFire, null);
    QuiverArrowRegistry.addArrowToRegistry(ZSSItems.arrowIce, null);
    QuiverArrowRegistry.addArrowToRegistry(ZSSItems.arrowLight, null);
}

@Method(modid="battlegear2")
@Override
public boolean canFireArrow(ItemStack arrow, World world, EntityPlayer player, float charge) {
    ItemStack bow = player.getHeldItem();
    if (bow != null) { // allow creative players to shoot custom Zelda arrows using any bow
        return (bow.getItem() instanceof ItemHeroBow ? ((ItemHeroBow) bow.getItem()).canShootArrow(player, bow, arrow) : player.capabilities.isCreativeMode);
    }
    return false;
}

@Method(modid="battlegear2")
@Override
public EntityArrow getFiredArrow(ItemStack arrow, World world, EntityPlayer player, float charge) {
    ItemStack bow = player.getHeldItem();
    if (bow != null && (bow.getItem() instanceof ItemHeroBow || player.capabilities.isCreativeMode)) {
        EntityArrowCustom arrowEntity = ItemHeroBow.getArrowEntity(arrow, world, player, charge);
        if (arrowEntity != null && (!(bow.getItem() instanceof ItemHeroBow) || ((ItemHeroBow) bow.getItem()).confirmArrowShot(arrow, player))) {
            // vanilla arrow settings will be applied by BG2's arrow loose event
            ItemHeroBow.applyCustomArrowSettings(player, bow, arrow, arrowEntity, charge);
        }
        return arrowEntity;
    }
    return null;
}

@Method(modid="battlegear2")
@Override
public boolean catchArrow(ItemStack shield, EntityPlayer player, IProjectile projectile) {
    if (toolMaterial == ToolMaterial.WOOD && projectile instanceof EntityArrow){
        setArrowCount(shield, getArrowCount(shield) + 1);
        player.setArrowCountInEntity(player.getArrowCountInEntity() - 1);
        ((EntityArrow) projectile).setDead();
        return true;
    }
    return false;
}

@Method(modid="battlegear2")
@SubscribeEvent
public void renderOffhand(PreRenderPlayerElement event) {
    ItemStack offhandItem = ((InventoryPlayerBattle) event.entityPlayer.inventory).getCurrentOffhandWeapon();
    if (offhandItem == null || !(offhandItem.getItem() instanceof ItemZeldaShield)) {
        return;
    }
    switch (event.type) {
    case ItemOffhand:
        boolean flag = ((IBattlePlayer) event.entityPlayer).isBlockingWithShield();
        if (event.isFirstPerson) {
            GlStateManager.rotate(25F, 0.375F, 0.8F, 0.0F);
            if (flag) {
                GlStateManager.translate(-0.3D, 0.15D, -0.3D);
            } else {
                GlStateManager.translate(-0.475D, 0.2125D, -0.15D);
            }
        } else {
            if (flag) {
                GlStateManager.rotate(27.5F, 0.0F, 0.325F, 0.1F);
            } else {
                GlStateManager.rotate(24F, 0.125F, 1.0F, 0.35F);
            }
            GlStateManager.translate(0.05D, -0.00125D, 0.0125D);
        }
        break;
    default:
    }
}

@Override
@Method(modid = "Baubles|API")
public BaubleType getBaubleType(ItemStack itemstack) {
  BaubleType t = null;
  try {
    t = BaubleType.valueOf(Config.magnetBaublesType);
  } catch (Exception e) {
    // NOP
  }
  return t != null ? t : BaubleType.AMULET;
}

@Override
@Method(modid = "Baubles|API")
public boolean canEquip(ItemStack itemstack, EntityLivingBase player) {
  if (itemstack == null || player == null) {
    return false;
  }
  return Config.magnetAllowInBaublesSlot && (Config.magnetAllowDeactivatedInBaublesSlot || isActive(itemstack));
}

@Override
@Method(modid = "forestry")
public boolean canSeePollination(@Nonnull EntityPlayer player, @Nonnull ItemStack armor, boolean doSee) {
  if (armor.getItem() != ModObject.itemDarkSteelHelmet.getItemNN()) {
    return false;
  }
  return FORESTRY_EYES != null && FORESTRY_EYES.hasUpgrade(player.getItemStackFromSlot(EntityEquipmentSlot.HEAD));
}

@Override
@Method(modid = MODID_BAUBLES)
public BaubleType getBaubleType(ItemStack stack) {
    return BaubleType.TRINKET;
}

@Override
@Method(modid = MODID_BAUBLES)
public boolean willAutoSync(ItemStack itemstack, EntityLivingBase player) {
    return true;
}

@Override
@Method(modid = MODID_BAUBLES)
public BaubleType getBaubleType(ItemStack stack) {
    return BaubleType.TRINKET;
}

@Override
@Method(modid = MODID_BAUBLES)
public boolean willAutoSync(ItemStack itemstack, EntityLivingBase player) {
    return true;
}

@Method(modid = "aperture")
public static void register()
{
    ClientProxy.EVENT_BUS.register(new CameraHandler());
    MinecraftForge.EVENT_BUS.register(new CameraGUIHandler());
}

@Method(modid = "aperture")
public static void postRegister()
{
    ClientProxy.cameraEditor.config.options.add(new GuiDirectorConfigOptions(ClientProxy.cameraEditor));
}

@Method(modid="battlegear2")
@Override
public boolean allowOffhand(ItemStack main, ItemStack offhand, EntityPlayer player) {
    return offhand == null || offhand.getItem() instanceof ItemQuiver;
}

@Method(modid="battlegear2")
@Override
public boolean sheatheOnBack(ItemStack stack) {
    return true;
}

@Method(modid="battlegear2")
@Override
public List<IArrowFireHandler> getFireHandlers(ItemStack arrow, ItemStack bow, EntityPlayer player) {
    return fireHandlers;
}

@Method(modid="battlegear2")
@Override
public Result canDrawBow(ItemStack bow, EntityPlayer player) {
    ItemStack arrow = BattlegearEvents.getQuiverArrow(bow, player);
    return (canShootArrow(player, bow, arrow) ? Result.ALLOW : Result.DENY);
}

@Method(modid="battlegear2")
@Override
public boolean sheatheOnBack(ItemStack stack) {
    return true;
}

@Method(modid="battlegear2")
@Override
public boolean isOffhandWieldable(ItemStack stack, EntityPlayer player) {
    return !twoHanded && (!isMaster || Config.allowOffhandMaster());
}

@Method(modid="battlegear2")
@Override
public boolean allowOffhand(ItemStack main, ItemStack offhand, EntityPlayer player) {
    return !twoHanded;
}

@Method(modid="battlegear2")
@Override
public void setArrowCount(ItemStack stack, int count) {
    if (!stack.hasTagCompound()) { stack.setTagCompound(new NBTTagCompound()); }
    stack.getTagCompound().setShort("arrows", (short) Math.min(count, Short.MAX_VALUE));
}

@Method(modid="battlegear2")
@Override
public int getArrowCount(ItemStack stack) {
    return (stack.hasTagCompound() ? stack.getTagCompound().getShort("arrows") : 0);
}

@Method(modid="battlegear2")
@Override
public boolean sheatheOnBack(ItemStack item) {
    return true;
}

@Method(modid="battlegear2")
@Override
public float getDecayRate(ItemStack shield) {
    return bg2DecayRate;
}