mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-12 03:47:27 +00:00
378 lines
12 KiB
Java
378 lines
12 KiB
Java
package noppes.npcs.scripted.entity;
|
|
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.SharedMonsterAttributes;
|
|
import net.minecraft.potion.Potion;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.util.DamageSource;
|
|
import net.minecraft.util.EntityDamageSource;
|
|
import net.minecraft.util.Vec3;
|
|
import noppes.npcs.api.IBlock;
|
|
import noppes.npcs.api.IDamageSource;
|
|
import noppes.npcs.api.IPos;
|
|
import noppes.npcs.api.entity.IEntity;
|
|
import noppes.npcs.api.entity.IEntityLivingBase;
|
|
import noppes.npcs.api.item.IItemStack;
|
|
import noppes.npcs.scripted.NpcAPI;
|
|
import noppes.npcs.scripted.constants.EntityType;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
|
|
public class ScriptLivingBase<T extends EntityLivingBase> extends ScriptEntity<T> implements IEntityLivingBase {
|
|
|
|
public ScriptLivingBase(T entity) {
|
|
super(entity);
|
|
}
|
|
|
|
/**
|
|
* @return The entity's current health
|
|
*/
|
|
public float getHealth() {
|
|
return entity.getHealth();
|
|
}
|
|
|
|
/**
|
|
* @param health The new health of this entity
|
|
*/
|
|
public void setHealth(float health) {
|
|
entity.setHealth(health);
|
|
}
|
|
|
|
public void hurt(float damage) {
|
|
entity.attackEntityFrom(DamageSource.generic, damage);
|
|
}
|
|
|
|
public void hurt(float damage, IEntity source) {
|
|
if (source.getType() == 1)//if player
|
|
entity.attackEntityFrom(new EntityDamageSource("player", source.getMCEntity()), damage);
|
|
else
|
|
entity.attackEntityFrom(new EntityDamageSource(source.getTypeName(), source.getMCEntity()), damage);
|
|
}
|
|
|
|
public void hurt(float damage, IDamageSource damageSource) {
|
|
entity.attackEntityFrom(damageSource.getMCDamageSource(), damage);
|
|
}
|
|
|
|
public void setMaxHurtTime(int time) {
|
|
entity.maxHurtResistantTime = time;
|
|
}
|
|
|
|
public int getMaxHurtTime() {
|
|
return entity.maxHurtResistantTime;
|
|
}
|
|
|
|
public double getMaxHealth() {
|
|
return entity.getEntityAttribute(SharedMonsterAttributes.maxHealth).getAttributeValue();
|
|
}
|
|
|
|
public double getFollowRange() {
|
|
return entity.getEntityAttribute(SharedMonsterAttributes.followRange).getAttributeValue();
|
|
}
|
|
|
|
public double getKnockbackResistance() {
|
|
return entity.getEntityAttribute(SharedMonsterAttributes.knockbackResistance).getAttributeValue();
|
|
}
|
|
|
|
public double getSpeed() {
|
|
return entity.getEntityAttribute(SharedMonsterAttributes.movementSpeed).getAttributeValue();
|
|
}
|
|
|
|
public double getMeleeStrength() {
|
|
return entity.getEntityAttribute(SharedMonsterAttributes.attackDamage).getAttributeValue();
|
|
}
|
|
|
|
public void setMaxHealth(double health) {
|
|
entity.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(health);
|
|
}
|
|
|
|
public void setFollowRange(double range) {
|
|
entity.getEntityAttribute(SharedMonsterAttributes.followRange).setBaseValue(range);
|
|
}
|
|
|
|
public void setKnockbackResistance(double knockbackResistance) {
|
|
entity.getEntityAttribute(SharedMonsterAttributes.knockbackResistance).setBaseValue(knockbackResistance);
|
|
}
|
|
|
|
public void setSpeed(double speed) {
|
|
entity.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(speed);
|
|
}
|
|
|
|
public void setMeleeStrength(double attackDamage) {
|
|
entity.getEntityAttribute(SharedMonsterAttributes.attackDamage).setBaseValue(attackDamage);
|
|
}
|
|
|
|
/**
|
|
* @return Whether or not this entity is attacking something
|
|
*/
|
|
public boolean isAttacking() {
|
|
return entity.getAITarget() != null;
|
|
}
|
|
|
|
/**
|
|
* @param living Entity which this entity will attack
|
|
*/
|
|
public void setAttackTarget(IEntityLivingBase living) {
|
|
if (living == null)
|
|
entity.setRevengeTarget(null);
|
|
else
|
|
entity.setRevengeTarget(living.getMCEntity());
|
|
}
|
|
|
|
/**
|
|
* @return The entity which this entity is attacking
|
|
*/
|
|
public IEntityLivingBase getAttackTarget() {
|
|
return (IEntityLivingBase) NpcAPI.Instance().getIEntity(entity.getAITarget());
|
|
}
|
|
|
|
public int getAttackTargetTime() {
|
|
return this.entity.func_142015_aE();
|
|
}
|
|
|
|
public void setLastAttacker(IEntity p_130011_1_) {
|
|
this.entity.setLastAttacker(p_130011_1_.getMCEntity());
|
|
}
|
|
|
|
public IEntity getLastAttacker() {
|
|
return NpcAPI.Instance().getIEntity(this.entity.getLastAttacker());
|
|
}
|
|
|
|
public int getLastAttackerTime() {
|
|
return this.entity.getLastAttackerTime();
|
|
}
|
|
|
|
public boolean canBreatheUnderwater() {
|
|
return this.entity.canBreatheUnderwater();
|
|
}
|
|
|
|
@Override
|
|
public int getType() {
|
|
return EntityType.LIVING;
|
|
}
|
|
|
|
|
|
@Override
|
|
public boolean typeOf(int type) {
|
|
return type == EntityType.LIVING || super.typeOf(type);
|
|
}
|
|
|
|
/**
|
|
* @param entity Entity to check
|
|
* @return Whether or not this entity can see the given entity
|
|
*/
|
|
public boolean canSeeEntity(IEntity entity) {
|
|
return this.entity.canEntityBeSeen(entity.getMCEntity());
|
|
}
|
|
|
|
public IPos getLookVector() {
|
|
Vec3 lookVec = entity.getLookVec();
|
|
return NpcAPI.Instance().getIPos(lookVec.xCoord, lookVec.yCoord, lookVec.zCoord);
|
|
}
|
|
|
|
public IBlock getLookingAtBlock(int maxDistance, boolean stopOnBlock, boolean stopOnLiquid, boolean stopOnCollision) {
|
|
return NpcAPI.Instance().getIBlock(getWorld(), getLookingAtPos(maxDistance, stopOnBlock, stopOnLiquid, stopOnCollision));
|
|
}
|
|
|
|
public IBlock getLookingAtBlock(int maxDistance) {
|
|
return getLookingAtBlock(maxDistance, true, false, false);
|
|
}
|
|
|
|
public IPos getLookingAtPos(int maxDistance, boolean stopOnBlock, boolean stopOnLiquid, boolean stopOnCollision) {
|
|
Vec3 lookVec = entity.getLookVec();
|
|
return getWorld().rayCastPos(
|
|
new double[]{entity.posX, entity.posY + entity.getEyeHeight(), entity.posZ},
|
|
new double[]{lookVec.xCoord, lookVec.yCoord, lookVec.zCoord},
|
|
maxDistance, stopOnBlock, stopOnLiquid, stopOnCollision);
|
|
}
|
|
|
|
public IPos getLookingAtPos(int maxDistance) {
|
|
return getLookingAtPos(maxDistance, true, false, false);
|
|
}
|
|
|
|
public IEntity[] getLookingAtEntities(IEntity[] ignoreEntities, int maxDistance, double offset, double range, boolean stopOnBlock, boolean stopOnLiquid, boolean stopOnCollision) {
|
|
Vec3 lookVec = entity.getLookVec();
|
|
double[] startPos = new double[]{entity.posX, entity.posY + entity.getEyeHeight(), entity.posZ};
|
|
double[] lookVector = new double[]{lookVec.xCoord, lookVec.yCoord, lookVec.zCoord};
|
|
|
|
if (ignoreEntities == null) {
|
|
ignoreEntities = new IEntity<?>[0];
|
|
}
|
|
ArrayList<IEntity> entities = new ArrayList<>();
|
|
entities.add(this);
|
|
Collections.addAll(entities, ignoreEntities);
|
|
|
|
return getWorld().rayCastEntities(entities.toArray(new IEntity[0]), startPos, lookVector, maxDistance, offset, range, stopOnBlock, stopOnLiquid, stopOnCollision);
|
|
}
|
|
|
|
public IEntity[] getLookingAtEntities(int maxDistance, double offset, double range, boolean stopOnBlock, boolean stopOnLiquid, boolean stopOnCollision) {
|
|
return this.getLookingAtEntities(null, maxDistance, offset, range, stopOnBlock, stopOnLiquid, stopOnCollision);
|
|
}
|
|
|
|
public IEntity[] getLookingAtEntities(int maxDistance, double offset, double range) {
|
|
return getLookingAtEntities(maxDistance, offset, range, true, false, true);
|
|
}
|
|
|
|
/**
|
|
* Expert use only
|
|
*
|
|
* @return Returns the minecraft entity object
|
|
*/
|
|
public T getMCEntity() {
|
|
return entity;
|
|
}
|
|
|
|
public T getMinecraftEntity() {
|
|
return getMCEntity();
|
|
}
|
|
|
|
@Override
|
|
public float getRotation() {
|
|
return entity.renderYawOffset;
|
|
}
|
|
|
|
@Override
|
|
public void setRotation(float rotation) {
|
|
entity.renderYawOffset = rotation;
|
|
}
|
|
|
|
/**
|
|
* Makes the entity swing its hand
|
|
*/
|
|
public void swingHand() {
|
|
entity.swingItem();
|
|
}
|
|
|
|
/**
|
|
* Works the same as the <a href="http://minecraft.wiki/w/Commands#effect">/effect command</a>
|
|
*
|
|
* @param effect
|
|
* @param duration The duration in seconds
|
|
* @param strength The amplifier of the potion effect
|
|
* @param hideParticles Whether or not you want to hide potion particles
|
|
*/
|
|
public void addPotionEffect(int effect, int duration, int strength, boolean hideParticles) {
|
|
if (effect < 0 || effect >= Potion.potionTypes.length || Potion.potionTypes[effect] == null)
|
|
return;
|
|
|
|
if (strength < 0)
|
|
strength = 0;
|
|
|
|
if (duration < 0)
|
|
duration = 0;
|
|
|
|
if (!Potion.potionTypes[effect].isInstant())
|
|
duration *= 20;
|
|
|
|
if (duration == 0)
|
|
entity.removePotionEffect(effect);
|
|
else
|
|
entity.addPotionEffect(new PotionEffect(effect, duration, strength));
|
|
//TODO in 1.8 add hideParticles option
|
|
}
|
|
|
|
/**
|
|
* Clears all potion effects
|
|
*/
|
|
public void clearPotionEffects() {
|
|
entity.clearActivePotions();
|
|
}
|
|
|
|
/**
|
|
* @param effect Potion effect to check
|
|
* @return Returns -1 if its not active. Otherwise returns the strenght of the potion
|
|
* @since 1.7.10c
|
|
*/
|
|
public int getPotionEffect(int effect) {
|
|
PotionEffect pf = entity.getActivePotionEffect(Potion.potionTypes[effect]);
|
|
if (pf == null)
|
|
return -1;
|
|
return pf.getAmplifier();
|
|
}
|
|
|
|
/**
|
|
* Note not all Living Entities support this
|
|
*
|
|
* @return The item the entity is holding
|
|
* @since 1.7.10c
|
|
*/
|
|
public IItemStack getHeldItem() {
|
|
return NpcAPI.Instance().getIItemStack(entity.getHeldItem());
|
|
}
|
|
|
|
/**
|
|
* Note not all Living Entities support this
|
|
*
|
|
* @param item The item to be set
|
|
* @since 1.7.10c
|
|
*/
|
|
public void setHeldItem(IItemStack item) {
|
|
entity.setCurrentItemOrArmor(0, item == null ? null : item.getMCItemStack());
|
|
}
|
|
|
|
/**
|
|
* Note not all Living Entities support this
|
|
*
|
|
* @param slot Slot of what armor piece to get, 0:boots, 1:pants, 2:body, 3:head
|
|
* @return The item in the given slot
|
|
*/
|
|
public IItemStack getArmor(int slot) {
|
|
return NpcAPI.Instance().getIItemStack(entity.getEquipmentInSlot(slot + 1));
|
|
}
|
|
|
|
/**
|
|
* Note not all Living Entities support this
|
|
*
|
|
* @param slot Slot of what armor piece to set, 0:boots, 1:pants, 2:body, 3:head
|
|
* @param item Item to be set
|
|
* @since 1.7.10c
|
|
*/
|
|
public void setArmor(int slot, IItemStack item) {
|
|
entity.setCurrentItemOrArmor(slot + 1, item == null ? null : item.getMCItemStack());
|
|
}
|
|
|
|
public boolean isChild() {
|
|
return this.entity.isChild();
|
|
}
|
|
|
|
public void renderBrokenItemStack(IItemStack itemStack) {
|
|
this.entity.renderBrokenItemStack(itemStack.getMCItemStack());
|
|
}
|
|
|
|
public boolean isOnLadder() {
|
|
return this.entity.isOnLadder();
|
|
}
|
|
|
|
public int getTotalArmorValue() {
|
|
return this.entity.getTotalArmorValue();
|
|
}
|
|
|
|
public int getArrowCountInEntity() {
|
|
return this.entity.getArrowCountInEntity();
|
|
}
|
|
|
|
public void setArrowCountInEntity(int count) {
|
|
this.entity.setArrowCountInEntity(count);
|
|
}
|
|
|
|
public void dismountEntity(IEntity entity) {
|
|
this.entity.dismountEntity(entity.getMCEntity());
|
|
}
|
|
|
|
public void setAIMoveSpeed(float speed) {
|
|
this.entity.setAIMoveSpeed(speed);
|
|
}
|
|
|
|
public float getAIMoveSpeed() {
|
|
return this.entity.getAIMoveSpeed();
|
|
}
|
|
|
|
public void setAbsorptionAmount(float amount) {
|
|
this.entity.setAbsorptionAmount(amount);
|
|
}
|
|
|
|
public float getAbsorptionAmount() {
|
|
return this.entity.getAbsorptionAmount();
|
|
}
|
|
}
|