309 lines
12 KiB
Java
309 lines
12 KiB
Java
package net.minecraft.world.item;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.mojang.serialization.Codec;
|
|
import com.mojang.serialization.codecs.RecordCodecBuilder;
|
|
import java.util.List;
|
|
import java.util.Optional;
|
|
import java.util.function.Predicate;
|
|
import net.minecraft.ChatFormatting;
|
|
import net.minecraft.advancements.CriteriaTriggers;
|
|
import net.minecraft.core.Holder;
|
|
import net.minecraft.core.component.DataComponents;
|
|
import net.minecraft.network.chat.CommonComponents;
|
|
import net.minecraft.network.chat.Component;
|
|
import net.minecraft.server.level.ServerLevel;
|
|
import net.minecraft.server.level.ServerPlayer;
|
|
import net.minecraft.sounds.SoundEvent;
|
|
import net.minecraft.sounds.SoundEvents;
|
|
import net.minecraft.sounds.SoundSource;
|
|
import net.minecraft.stats.Stats;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.util.RandomSource;
|
|
import net.minecraft.world.InteractionHand;
|
|
import net.minecraft.world.InteractionResultHolder;
|
|
import net.minecraft.world.entity.LivingEntity;
|
|
import net.minecraft.world.entity.player.Player;
|
|
import net.minecraft.world.entity.projectile.AbstractArrow;
|
|
import net.minecraft.world.entity.projectile.FireworkRocketEntity;
|
|
import net.minecraft.world.entity.projectile.Projectile;
|
|
import net.minecraft.world.item.component.ChargedProjectiles;
|
|
import net.minecraft.world.item.enchantment.EnchantmentEffectComponents;
|
|
import net.minecraft.world.item.enchantment.EnchantmentHelper;
|
|
import net.minecraft.world.level.Level;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.joml.Quaternionf;
|
|
import org.joml.Vector3f;
|
|
|
|
public class CrossbowItem extends ProjectileWeaponItem {
|
|
private static final float MAX_CHARGE_DURATION = 1.25F;
|
|
public static final int DEFAULT_RANGE = 8;
|
|
/**
|
|
* Set to {@code true} when the crossbow is 20% charged.
|
|
*/
|
|
private boolean startSoundPlayed = false;
|
|
/**
|
|
* Set to {@code true} when the crossbow is 50% charged.
|
|
*/
|
|
private boolean midLoadSoundPlayed = false;
|
|
private static final float START_SOUND_PERCENT = 0.2F;
|
|
private static final float MID_SOUND_PERCENT = 0.5F;
|
|
private static final float ARROW_POWER = 3.15F;
|
|
private static final float FIREWORK_POWER = 1.6F;
|
|
public static final float MOB_ARROW_POWER = 1.6F;
|
|
private static final CrossbowItem.ChargingSounds DEFAULT_SOUNDS = new CrossbowItem.ChargingSounds(
|
|
Optional.of(SoundEvents.CROSSBOW_LOADING_START), Optional.of(SoundEvents.CROSSBOW_LOADING_MIDDLE), Optional.of(SoundEvents.CROSSBOW_LOADING_END)
|
|
);
|
|
|
|
public CrossbowItem(Item.Properties properties) {
|
|
super(properties);
|
|
}
|
|
|
|
@Override
|
|
public Predicate<ItemStack> getSupportedHeldProjectiles() {
|
|
return ARROW_OR_FIREWORK;
|
|
}
|
|
|
|
@Override
|
|
public Predicate<ItemStack> getAllSupportedProjectiles() {
|
|
return ARROW_ONLY;
|
|
}
|
|
|
|
@Override
|
|
public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
|
|
ItemStack itemStack = player.getItemInHand(usedHand);
|
|
ChargedProjectiles chargedProjectiles = itemStack.get(DataComponents.CHARGED_PROJECTILES);
|
|
if (chargedProjectiles != null && !chargedProjectiles.isEmpty()) {
|
|
this.performShooting(level, player, usedHand, itemStack, getShootingPower(chargedProjectiles), 1.0F, null);
|
|
return InteractionResultHolder.consume(itemStack);
|
|
} else if (!player.getProjectile(itemStack).isEmpty()) {
|
|
this.startSoundPlayed = false;
|
|
this.midLoadSoundPlayed = false;
|
|
player.startUsingItem(usedHand);
|
|
return InteractionResultHolder.consume(itemStack);
|
|
} else {
|
|
return InteractionResultHolder.fail(itemStack);
|
|
}
|
|
}
|
|
|
|
private static float getShootingPower(ChargedProjectiles projectile) {
|
|
return projectile.contains(Items.FIREWORK_ROCKET) ? 1.6F : 3.15F;
|
|
}
|
|
|
|
@Override
|
|
public void releaseUsing(ItemStack stack, Level level, LivingEntity livingEntity, int timeCharged) {
|
|
int i = this.getUseDuration(stack, livingEntity) - timeCharged;
|
|
float f = getPowerForTime(i, stack, livingEntity);
|
|
if (f >= 1.0F && !isCharged(stack) && tryLoadProjectiles(livingEntity, stack)) {
|
|
CrossbowItem.ChargingSounds chargingSounds = this.getChargingSounds(stack);
|
|
chargingSounds.end()
|
|
.ifPresent(
|
|
holder -> level.playSound(
|
|
null,
|
|
livingEntity.getX(),
|
|
livingEntity.getY(),
|
|
livingEntity.getZ(),
|
|
(SoundEvent)holder.value(),
|
|
livingEntity.getSoundSource(),
|
|
1.0F,
|
|
1.0F / (level.getRandom().nextFloat() * 0.5F + 1.0F) + 0.2F
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
private static boolean tryLoadProjectiles(LivingEntity shooter, ItemStack crossbowStack) {
|
|
List<ItemStack> list = draw(crossbowStack, shooter.getProjectile(crossbowStack), shooter);
|
|
if (!list.isEmpty()) {
|
|
crossbowStack.set(DataComponents.CHARGED_PROJECTILES, ChargedProjectiles.of(list));
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static boolean isCharged(ItemStack crossbowStack) {
|
|
ChargedProjectiles chargedProjectiles = crossbowStack.getOrDefault(DataComponents.CHARGED_PROJECTILES, ChargedProjectiles.EMPTY);
|
|
return !chargedProjectiles.isEmpty();
|
|
}
|
|
|
|
@Override
|
|
protected void shootProjectile(
|
|
LivingEntity shooter, Projectile projectile, int index, float velocity, float inaccuracy, float angle, @Nullable LivingEntity target
|
|
) {
|
|
Vector3f vector3f;
|
|
if (target != null) {
|
|
double d = target.getX() - shooter.getX();
|
|
double e = target.getZ() - shooter.getZ();
|
|
double f = Math.sqrt(d * d + e * e);
|
|
double g = target.getY(0.3333333333333333) - projectile.getY() + f * 0.2F;
|
|
vector3f = getProjectileShotVector(shooter, new Vec3(d, g, e), angle);
|
|
} else {
|
|
Vec3 vec3 = shooter.getUpVector(1.0F);
|
|
Quaternionf quaternionf = new Quaternionf().setAngleAxis((double)(angle * (float) (Math.PI / 180.0)), vec3.x, vec3.y, vec3.z);
|
|
Vec3 vec32 = shooter.getViewVector(1.0F);
|
|
vector3f = vec32.toVector3f().rotate(quaternionf);
|
|
}
|
|
|
|
projectile.shoot(vector3f.x(), vector3f.y(), vector3f.z(), velocity, inaccuracy);
|
|
float h = getShotPitch(shooter.getRandom(), index);
|
|
shooter.level().playSound(null, shooter.getX(), shooter.getY(), shooter.getZ(), SoundEvents.CROSSBOW_SHOOT, shooter.getSoundSource(), 1.0F, h);
|
|
}
|
|
|
|
private static Vector3f getProjectileShotVector(LivingEntity shooter, Vec3 distance, float angle) {
|
|
Vector3f vector3f = distance.toVector3f().normalize();
|
|
Vector3f vector3f2 = new Vector3f(vector3f).cross(new Vector3f(0.0F, 1.0F, 0.0F));
|
|
if (vector3f2.lengthSquared() <= 1.0E-7) {
|
|
Vec3 vec3 = shooter.getUpVector(1.0F);
|
|
vector3f2 = new Vector3f(vector3f).cross(vec3.toVector3f());
|
|
}
|
|
|
|
Vector3f vector3f3 = new Vector3f(vector3f).rotateAxis((float) (Math.PI / 2), vector3f2.x, vector3f2.y, vector3f2.z);
|
|
return new Vector3f(vector3f).rotateAxis(angle * (float) (Math.PI / 180.0), vector3f3.x, vector3f3.y, vector3f3.z);
|
|
}
|
|
|
|
@Override
|
|
protected Projectile createProjectile(Level level, LivingEntity shooter, ItemStack weapon, ItemStack ammo, boolean isCrit) {
|
|
if (ammo.is(Items.FIREWORK_ROCKET)) {
|
|
return new FireworkRocketEntity(level, ammo, shooter, shooter.getX(), shooter.getEyeY() - 0.15F, shooter.getZ(), true);
|
|
} else {
|
|
Projectile projectile = super.createProjectile(level, shooter, weapon, ammo, isCrit);
|
|
if (projectile instanceof AbstractArrow abstractArrow) {
|
|
abstractArrow.setSoundEvent(SoundEvents.CROSSBOW_HIT);
|
|
}
|
|
|
|
return projectile;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected int getDurabilityUse(ItemStack stack) {
|
|
return stack.is(Items.FIREWORK_ROCKET) ? 3 : 1;
|
|
}
|
|
|
|
public void performShooting(
|
|
Level level, LivingEntity shooter, InteractionHand hand, ItemStack weapon, float velocity, float inaccuracy, @Nullable LivingEntity target
|
|
) {
|
|
if (level instanceof ServerLevel serverLevel) {
|
|
ChargedProjectiles chargedProjectiles = weapon.set(DataComponents.CHARGED_PROJECTILES, ChargedProjectiles.EMPTY);
|
|
if (chargedProjectiles != null && !chargedProjectiles.isEmpty()) {
|
|
this.shoot(serverLevel, shooter, hand, weapon, chargedProjectiles.getItems(), velocity, inaccuracy, shooter instanceof Player, target);
|
|
if (shooter instanceof ServerPlayer serverPlayer) {
|
|
CriteriaTriggers.SHOT_CROSSBOW.trigger(serverPlayer, weapon);
|
|
serverPlayer.awardStat(Stats.ITEM_USED.get(weapon.getItem()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static float getShotPitch(RandomSource random, int index) {
|
|
return index == 0 ? 1.0F : getRandomShotPitch((index & 1) == 1, random);
|
|
}
|
|
|
|
private static float getRandomShotPitch(boolean isHighPitched, RandomSource random) {
|
|
float f = isHighPitched ? 0.63F : 0.43F;
|
|
return 1.0F / (random.nextFloat() * 0.5F + 1.8F) + f;
|
|
}
|
|
|
|
@Override
|
|
public void onUseTick(Level level, LivingEntity livingEntity, ItemStack stack, int remainingUseDuration) {
|
|
if (!level.isClientSide) {
|
|
CrossbowItem.ChargingSounds chargingSounds = this.getChargingSounds(stack);
|
|
float f = (float)(stack.getUseDuration(livingEntity) - remainingUseDuration) / getChargeDuration(stack, livingEntity);
|
|
if (f < 0.2F) {
|
|
this.startSoundPlayed = false;
|
|
this.midLoadSoundPlayed = false;
|
|
}
|
|
|
|
if (f >= 0.2F && !this.startSoundPlayed) {
|
|
this.startSoundPlayed = true;
|
|
chargingSounds.start()
|
|
.ifPresent(
|
|
holder -> level.playSound(
|
|
null, livingEntity.getX(), livingEntity.getY(), livingEntity.getZ(), (SoundEvent)holder.value(), SoundSource.PLAYERS, 0.5F, 1.0F
|
|
)
|
|
);
|
|
}
|
|
|
|
if (f >= 0.5F && !this.midLoadSoundPlayed) {
|
|
this.midLoadSoundPlayed = true;
|
|
chargingSounds.mid()
|
|
.ifPresent(
|
|
holder -> level.playSound(
|
|
null, livingEntity.getX(), livingEntity.getY(), livingEntity.getZ(), (SoundEvent)holder.value(), SoundSource.PLAYERS, 0.5F, 1.0F
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getUseDuration(ItemStack stack, LivingEntity entity) {
|
|
return getChargeDuration(stack, entity) + 3;
|
|
}
|
|
|
|
public static int getChargeDuration(ItemStack stack, LivingEntity shooter) {
|
|
float f = EnchantmentHelper.modifyCrossbowChargingTime(stack, shooter, 1.25F);
|
|
return Mth.floor(f * 20.0F);
|
|
}
|
|
|
|
@Override
|
|
public UseAnim getUseAnimation(ItemStack stack) {
|
|
return UseAnim.CROSSBOW;
|
|
}
|
|
|
|
CrossbowItem.ChargingSounds getChargingSounds(ItemStack stack) {
|
|
return (CrossbowItem.ChargingSounds)EnchantmentHelper.pickHighestLevel(stack, EnchantmentEffectComponents.CROSSBOW_CHARGING_SOUNDS).orElse(DEFAULT_SOUNDS);
|
|
}
|
|
|
|
private static float getPowerForTime(int timeLeft, ItemStack stack, LivingEntity shooter) {
|
|
float f = (float)timeLeft / getChargeDuration(stack, shooter);
|
|
if (f > 1.0F) {
|
|
f = 1.0F;
|
|
}
|
|
|
|
return f;
|
|
}
|
|
|
|
@Override
|
|
public void appendHoverText(ItemStack stack, Item.TooltipContext context, List<Component> tooltipComponents, TooltipFlag tooltipFlag) {
|
|
ChargedProjectiles chargedProjectiles = stack.get(DataComponents.CHARGED_PROJECTILES);
|
|
if (chargedProjectiles != null && !chargedProjectiles.isEmpty()) {
|
|
ItemStack itemStack = (ItemStack)chargedProjectiles.getItems().get(0);
|
|
tooltipComponents.add(Component.translatable("item.minecraft.crossbow.projectile").append(CommonComponents.SPACE).append(itemStack.getDisplayName()));
|
|
if (tooltipFlag.isAdvanced() && itemStack.is(Items.FIREWORK_ROCKET)) {
|
|
List<Component> list = Lists.<Component>newArrayList();
|
|
Items.FIREWORK_ROCKET.appendHoverText(itemStack, context, list, tooltipFlag);
|
|
if (!list.isEmpty()) {
|
|
for (int i = 0; i < list.size(); i++) {
|
|
list.set(i, Component.literal(" ").append((Component)list.get(i)).withStyle(ChatFormatting.GRAY));
|
|
}
|
|
|
|
tooltipComponents.addAll(list);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean useOnRelease(ItemStack stack) {
|
|
return stack.is(this);
|
|
}
|
|
|
|
@Override
|
|
public int getDefaultProjectileRange() {
|
|
return 8;
|
|
}
|
|
|
|
public record ChargingSounds(Optional<Holder<SoundEvent>> start, Optional<Holder<SoundEvent>> mid, Optional<Holder<SoundEvent>> end) {
|
|
public static final Codec<CrossbowItem.ChargingSounds> CODEC = RecordCodecBuilder.create(
|
|
instance -> instance.group(
|
|
SoundEvent.CODEC.optionalFieldOf("start").forGetter(CrossbowItem.ChargingSounds::start),
|
|
SoundEvent.CODEC.optionalFieldOf("mid").forGetter(CrossbowItem.ChargingSounds::mid),
|
|
SoundEvent.CODEC.optionalFieldOf("end").forGetter(CrossbowItem.ChargingSounds::end)
|
|
)
|
|
.apply(instance, CrossbowItem.ChargingSounds::new)
|
|
);
|
|
}
|
|
}
|