- 1,560
- 86
- 204
Достал код из ванильной лодки. Вставил, зарегистрировал, но когда я создаю лодку(с помощью команды /summon) вылетает игра. Убрал регистр рендера и не вылетает, но лодка просто не плывёт и всё. В чём проблема? Я не понимаю. Или где есть рабочий исходник своей лодки.
Код EntitySteamBoat:
Код RenderSteamBoat:
Код EntitySteamBoat:
Код:
public class EntitySteamBoat extends Entity
{
private static final DataParameter<Integer> TIME_SINCE_HIT = EntityDataManager.<Integer>createKey(EntitySteamBoat.class, DataSerializers.VARINT);
private static final DataParameter<Integer> FORWARD_DIRECTION = EntityDataManager.<Integer>createKey(EntitySteamBoat.class, DataSerializers.VARINT);
private static final DataParameter<Float> DAMAGE_TAKEN = EntityDataManager.<Float>createKey(EntitySteamBoat.class, DataSerializers.FLOAT);
private static final DataParameter<Integer> BOAT_TYPE = EntityDataManager.<Integer>createKey(EntitySteamBoat.class, DataSerializers.VARINT);
private static final DataParameter<Boolean>[] DATA_ID_PADDLE = new DataParameter[] {EntityDataManager.createKey(EntitySteamBoat.class, DataSerializers.BOOLEAN), EntityDataManager.createKey(EntitySteamBoat.class, DataSerializers.BOOLEAN)};
private float[] paddlePositions;
/** How much of current speed to retain. Value zero to one. */
private float momentum;
private float outOfControlTicks;
private float deltaRotation;
private int lerpSteps;
private double boatPitch;
private double lerpY;
private double lerpZ;
private double boatYaw;
private double lerpXRot;
private boolean leftInputDown;
private boolean rightInputDown;
private boolean forwardInputDown;
private boolean backInputDown;
private double waterLevel;
/**
* How much the boat should glide given the slippery blocks it's currently gliding over.
* Halved every tick.
*/
private float boatGlide;
private EntitySteamBoat.Status status;
private EntitySteamBoat.Status previousStatus;
private double lastYd;
public EntitySteamBoat(World worldIn)
{
super(worldIn);
this.paddlePositions = new float[2];
this.preventEntitySpawning = true;
this.setSize(1.375F, 0.5625F);
}
public EntitySteamBoat(World worldIn, double x, double y, double z)
{
this(worldIn);
this.setPosition(x, y, z);
this.motionX = 0.0D;
this.motionY = 0.0D;
this.motionZ = 0.0D;
this.prevPosX = x;
this.prevPosY = y;
this.prevPosZ = z;
}
/**
* returns if this entity triggers Block.onEntityWalking on the blocks they walk on. used for spiders and wolves to
* prevent them from trampling crops
*/
protected boolean canTriggerWalking()
{
return false;
}
protected void entityInit()
{
this.dataManager.register(TIME_SINCE_HIT, Integer.valueOf(0));
this.dataManager.register(FORWARD_DIRECTION, Integer.valueOf(1));
this.dataManager.register(DAMAGE_TAKEN, Float.valueOf(0.0F));
this.dataManager.register(BOAT_TYPE, Integer.valueOf(EntitySteamBoat.Type.OAK.ordinal()));
for (int i = 0; i < DATA_ID_PADDLE.length; ++i)
{
this.dataManager.register(DATA_ID_PADDLE[i], Boolean.valueOf(false));
}
}
/**
* Returns a boundingBox used to collide the entity with other entities and blocks. This enables the entity to be
* pushable on contact, like boats or minecarts.
*/
@Nullable
public AxisAlignedBB getCollisionBox(Entity entityIn)
{
return entityIn.getEntityBoundingBox();
}
/**
* Returns the collision bounding box for this entity
*/
@Nullable
public AxisAlignedBB getCollisionBoundingBox()
{
return this.getEntityBoundingBox();
}
/**
* Returns true if this entity should push and be pushed by other entities when colliding.
*/
public boolean canBePushed()
{
return true;
}
/**
* Returns the Y offset from the entity's position for any entity riding this one.
*/
public double getMountedYOffset()
{
return -0.1D;
}
/**
* Called when the entity is attacked.
*/
public boolean attackEntityFrom(DamageSource source, float amount)
{
if (this.isEntityInvulnerable(source))
{
return false;
}
else if (!this.worldObj.isRemote && !this.isDead)
{
if (source instanceof EntityDamageSourceIndirect && source.getEntity() != null && this.isPassenger(source.getEntity()))
{
return false;
}
else
{
this.setForwardDirection(-this.getForwardDirection());
this.setTimeSinceHit(10);
this.setDamageTaken(this.getDamageTaken() + amount * 10.0F);
this.setBeenAttacked();
boolean flag = source.getEntity() instanceof EntityPlayer && ((EntityPlayer)source.getEntity()).capabilities.isCreativeMode;
if (flag || this.getDamageTaken() > 40.0F)
{
if (!flag && this.worldObj.getGameRules().getBoolean("doEntityDrops"))
{
this.dropItemWithOffset(this.getItemBoat(), 1, 0.0F);
}
this.setDead();
}
return true;
}
}
else
{
return true;
}
}
/**
* Applies a velocity to the entities, to push them away from eachother.
*/
public void applyEntityCollision(Entity entityIn)
{
if (entityIn instanceof EntitySteamBoat)
{
if (entityIn.getEntityBoundingBox().minY < this.getEntityBoundingBox().maxY)
{
super.applyEntityCollision(entityIn);
}
}
else if (entityIn.getEntityBoundingBox().minY <= this.getEntityBoundingBox().minY)
{
super.applyEntityCollision(entityIn);
}
}
public Item getItemBoat()
{
switch (this.getBoatType())
{
case OAK:
default:
return Items.BOAT;
case SPRUCE:
return Items.SPRUCE_BOAT;
case BIRCH:
return Items.BIRCH_BOAT;
case JUNGLE:
return Items.JUNGLE_BOAT;
case ACACIA:
return Items.ACACIA_BOAT;
case DARK_OAK:
return Items.DARK_OAK_BOAT;
}
}
/**
* Setups the entity to do the hurt animation. Only used by packets in multiplayer.
*/
@SideOnly(Side.CLIENT)
public void performHurtAnimation()
{
this.setForwardDirection(-this.getForwardDirection());
this.setTimeSinceHit(10);
this.setDamageTaken(this.getDamageTaken() * 11.0F);
}
/**
* Returns true if other Entities should be prevented from moving through this Entity.
*/
public boolean canBeCollidedWith()
{
return !this.isDead;
}
/**
* Set the position and rotation values directly without any clamping.
*/
@SideOnly(Side.CLIENT)
public void setPositionAndRotationDirect(double x, double y, double z, float yaw, float pitch, int posRotationIncrements, boolean teleport)
{
this.boatPitch = x;
this.lerpY = y;
this.lerpZ = z;
this.boatYaw = (double)yaw;
this.lerpXRot = (double)pitch;
this.lerpSteps = 10;
}
/**
* Gets the horizontal facing direction of this Entity, adjusted to take specially-treated entity types into
* account.
*/
public EnumFacing getAdjustedHorizontalFacing()
{
return this.getHorizontalFacing().rotateY();
}
/**
* Called to update the entity's position/logic.
*/
public void onUpdate()
{
this.previousStatus = this.status;
this.status = this.getBoatStatus();
if (this.status != EntitySteamBoat.Status.UNDER_WATER && this.status != EntitySteamBoat.Status.UNDER_FLOWING_WATER)
{
this.outOfControlTicks = 0.0F;
}
else
{
++this.outOfControlTicks;
}
if (!this.worldObj.isRemote && this.outOfControlTicks >= 60.0F)
{
this.removePassengers();
}
if (this.getTimeSinceHit() > 0)
{
this.setTimeSinceHit(this.getTimeSinceHit() - 1);
}
if (this.getDamageTaken() > 0.0F)
{
this.setDamageTaken(this.getDamageTaken() - 1.0F);
}
this.prevPosX = this.posX;
this.prevPosY = this.posY;
this.prevPosZ = this.posZ;
super.onUpdate();
this.tickLerp();
if (this.canPassengerSteer())
{
if (this.getPassengers().size() == 0 || !(this.getPassengers().get(0) instanceof EntityPlayer))
{
this.setPaddleState(false, false);
}
this.updateMotion();
if (this.worldObj.isRemote)
{
this.controlBoat();
this.worldObj.sendPacketToServer(new CPacketSteerBoat(this.getPaddleState(0), this.getPaddleState(1)));
}
this.moveEntity(this.motionX, this.motionY, this.motionZ);
}
else
{
this.motionX = 0.0D;
this.motionY = 0.0D;
this.motionZ = 0.0D;
}
for (int i = 0; i <= 1; ++i)
{
if (this.getPaddleState(i))
{
this.paddlePositions[i] = (float)((double)this.paddlePositions[i] + 0.01D);
}
else
{
this.paddlePositions[i] = 0.0F;
}
}
this.doBlockCollisions();
List<Entity> list = this.worldObj.getEntitiesInAABBexcluding(this, this.getEntityBoundingBox().expand(0.20000000298023224D, -0.009999999776482582D, 0.20000000298023224D), EntitySelectors.<Entity>getTeamCollisionPredicate(this));
if (!list.isEmpty())
{
boolean flag = !this.worldObj.isRemote && !(this.getControllingPassenger() instanceof EntityPlayer);
for (int j = 0; j < list.size(); ++j)
{
Entity entity = (Entity)list.get(j);
if (!entity.isPassenger(this))
{
if (flag && this.getPassengers().size() < 2 && !entity.isRiding() && entity.width < this.width && entity instanceof EntityLivingBase && !(entity instanceof EntityWaterMob) && !(entity instanceof EntityPlayer))
{
entity.startRiding(this);
}
else
{
this.applyEntityCollision(entity);
}
}
}
}
}
private void tickLerp()
{
if (this.lerpSteps > 0 && !this.canPassengerSteer())
{
double d0 = this.posX + (this.boatPitch - this.posX) / (double)this.lerpSteps;
double d1 = this.posY + (this.lerpY - this.posY) / (double)this.lerpSteps;
double d2 = this.posZ + (this.lerpZ - this.posZ) / (double)this.lerpSteps;
double d3 = MathHelper.wrapDegrees(this.boatYaw - (double)this.rotationYaw);
this.rotationYaw = (float)((double)this.rotationYaw + d3 / (double)this.lerpSteps);
this.rotationPitch = (float)((double)this.rotationPitch + (this.lerpXRot - (double)this.rotationPitch) / (double)this.lerpSteps);
--this.lerpSteps;
this.setPosition(d0, d1, d2);
this.setRotation(this.rotationYaw, this.rotationPitch);
}
}
public void setPaddleState(boolean p_184445_1_, boolean p_184445_2_)
{
this.dataManager.set(DATA_ID_PADDLE[0], Boolean.valueOf(p_184445_1_));
this.dataManager.set(DATA_ID_PADDLE[1], Boolean.valueOf(p_184445_2_));
}
@SideOnly(Side.CLIENT)
public float getRowingTime(int p_184448_1_, float limbSwing)
{
return this.getPaddleState(p_184448_1_) ? (float)MathHelper.denormalizeClamp((double)this.paddlePositions[p_184448_1_] - 0.01D, (double)this.paddlePositions[p_184448_1_], (double)limbSwing) : 0.0F;
}
/**
* Determines whether the boat is in water, gliding on land, or in air
*/
private EntitySteamBoat.Status getBoatStatus()
{
EntitySteamBoat.Status entityboat$status = this.getUnderwaterStatus();
if (entityboat$status != null)
{
this.waterLevel = this.getEntityBoundingBox().maxY;
return entityboat$status;
}
else if (this.checkInWater())
{
return EntitySteamBoat.Status.IN_WATER;
}
else
{
float f = this.getBoatGlide();
if (f > 0.0F)
{
this.boatGlide = f;
return EntitySteamBoat.Status.ON_LAND;
}
else
{
return EntitySteamBoat.Status.IN_AIR;
}
}
}
public float getWaterLevelAbove()
{
AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.ceiling_double_int(axisalignedbb.maxX);
int k = MathHelper.floor_double(axisalignedbb.maxY);
int l = MathHelper.ceiling_double_int(axisalignedbb.maxY - this.lastYd);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.ceiling_double_int(axisalignedbb.maxZ);
BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
try
{
label78:
for (int k1 = k; k1 < l; ++k1)
{
float f = 0.0F;
int l1 = i;
while (true)
{
if (l1 >= j)
{
if (f < 1.0F)
{
float f2 = (float)blockpos$pooledmutableblockpos.getY() + f;
return f2;
}
break;
}
for (int i2 = i1; i2 < j1; ++i2)
{
blockpos$pooledmutableblockpos.set(l1, k1, i2);
IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
if (iblockstate.getMaterial() == Material.WATER)
{
f = Math.max(f, getBlockLiquidHeight(iblockstate, this.worldObj, blockpos$pooledmutableblockpos));
}
if (f >= 1.0F)
{
continue label78;
}
}
++l1;
}
}
float f1 = (float)(l + 1);
return f1;
}
finally
{
blockpos$pooledmutableblockpos.release();
}
}
/**
* Decides how much the boat should be gliding on the land (based on any slippery blocks)
*/
public float getBoatGlide()
{
AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
AxisAlignedBB axisalignedbb1 = new AxisAlignedBB(axisalignedbb.minX, axisalignedbb.minY - 0.001D, axisalignedbb.minZ, axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ);
int i = MathHelper.floor_double(axisalignedbb1.minX) - 1;
int j = MathHelper.ceiling_double_int(axisalignedbb1.maxX) + 1;
int k = MathHelper.floor_double(axisalignedbb1.minY) - 1;
int l = MathHelper.ceiling_double_int(axisalignedbb1.maxY) + 1;
int i1 = MathHelper.floor_double(axisalignedbb1.minZ) - 1;
int j1 = MathHelper.ceiling_double_int(axisalignedbb1.maxZ) + 1;
List<AxisAlignedBB> list = Lists.<AxisAlignedBB>newArrayList();
float f = 0.0F;
int k1 = 0;
BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
try
{
for (int l1 = i; l1 < j; ++l1)
{
for (int i2 = i1; i2 < j1; ++i2)
{
int j2 = (l1 != i && l1 != j - 1 ? 0 : 1) + (i2 != i1 && i2 != j1 - 1 ? 0 : 1);
if (j2 != 2)
{
for (int k2 = k; k2 < l; ++k2)
{
if (j2 <= 0 || k2 != k && k2 != l - 1)
{
blockpos$pooledmutableblockpos.set(l1, k2, i2);
IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
iblockstate.addCollisionBoxToList(this.worldObj, blockpos$pooledmutableblockpos, axisalignedbb1, list, this);
if (!list.isEmpty())
{
f += iblockstate.getBlock().slipperiness;
++k1;
}
list.clear();
}
}
}
}
}
}
finally
{
blockpos$pooledmutableblockpos.release();
}
return f / (float)k1;
}
private boolean checkInWater()
{
AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.ceiling_double_int(axisalignedbb.maxX);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.ceiling_double_int(axisalignedbb.minY + 0.001D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.ceiling_double_int(axisalignedbb.maxZ);
boolean flag = false;
this.waterLevel = Double.MIN_VALUE;
BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
try
{
for (int k1 = i; k1 < j; ++k1)
{
for (int l1 = k; l1 < l; ++l1)
{
for (int i2 = i1; i2 < j1; ++i2)
{
blockpos$pooledmutableblockpos.set(k1, l1, i2);
IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
if (iblockstate.getMaterial() == Material.WATER)
{
float f = getLiquidHeight(iblockstate, this.worldObj, blockpos$pooledmutableblockpos);
this.waterLevel = Math.max((double)f, this.waterLevel);
flag |= axisalignedbb.minY < (double)f;
}
}
}
}
}
finally
{
blockpos$pooledmutableblockpos.release();
}
return flag;
}
/**
* Decides whether the boat is currently underwater.
*/
@Nullable
private EntitySteamBoat.Status getUnderwaterStatus()
{
AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
double d0 = axisalignedbb.maxY + 0.001D;
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.ceiling_double_int(axisalignedbb.maxX);
int k = MathHelper.floor_double(axisalignedbb.maxY);
int l = MathHelper.ceiling_double_int(d0);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.ceiling_double_int(axisalignedbb.maxZ);
boolean flag = false;
BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
try
{
for (int k1 = i; k1 < j; ++k1)
{
for (int l1 = k; l1 < l; ++l1)
{
for (int i2 = i1; i2 < j1; ++i2)
{
blockpos$pooledmutableblockpos.set(k1, l1, i2);
IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
if (iblockstate.getMaterial() == Material.WATER && d0 < (double)getLiquidHeight(iblockstate, this.worldObj, blockpos$pooledmutableblockpos))
{
if (((Integer)iblockstate.getValue(BlockLiquid.LEVEL)).intValue() != 0)
{
EntitySteamBoat.Status entityboat$status = EntitySteamBoat.Status.UNDER_FLOWING_WATER;
return entityboat$status;
}
flag = true;
}
}
}
}
}
finally
{
blockpos$pooledmutableblockpos.release();
}
return flag ? EntitySteamBoat.Status.UNDER_WATER : null;
}
public static float getBlockLiquidHeight(IBlockState p_184456_0_, IBlockAccess p_184456_1_, BlockPos p_184456_2_)
{
int i = ((Integer)p_184456_0_.getValue(BlockLiquid.LEVEL)).intValue();
return (i & 7) == 0 && p_184456_1_.getBlockState(p_184456_2_.up()).getMaterial() == Material.WATER ? 1.0F : 1.0F - BlockLiquid.getLiquidHeightPercent(i);
}
public static float getLiquidHeight(IBlockState p_184452_0_, IBlockAccess p_184452_1_, BlockPos p_184452_2_)
{
return (float)p_184452_2_.getY() + getBlockLiquidHeight(p_184452_0_, p_184452_1_, p_184452_2_);
}
/**
* Update the boat's speed, based on momentum.
*/
private void updateMotion()
{
double d0 = -0.03999999910593033D;
double d1 = d0;
double d2 = 0.0D;
this.momentum = 0.05F;
if (this.previousStatus == EntitySteamBoat.Status.IN_AIR && this.status != EntitySteamBoat.Status.IN_AIR && this.status != EntitySteamBoat.Status.ON_LAND)
{
this.waterLevel = this.getEntityBoundingBox().minY + (double)this.height;
this.setPosition(this.posX, (double)(this.getWaterLevelAbove() - this.height) + 0.101D, this.posZ);
this.motionY = 0.0D;
this.lastYd = 0.0D;
this.status = EntitySteamBoat.Status.IN_WATER;
}
else
{
if (this.status == EntitySteamBoat.Status.IN_WATER)
{
d2 = (this.waterLevel - this.getEntityBoundingBox().minY) / (double)this.height;
this.momentum = 0.9F;
}
else if (this.status == EntitySteamBoat.Status.UNDER_FLOWING_WATER)
{
d1 = -7.0E-4D;
this.momentum = 0.9F;
}
else if (this.status == EntitySteamBoat.Status.UNDER_WATER)
{
d2 = 0.009999999776482582D;
this.momentum = 0.45F;
}
else if (this.status == EntitySteamBoat.Status.IN_AIR)
{
this.momentum = 0.9F;
}
else if (this.status == EntitySteamBoat.Status.ON_LAND)
{
this.momentum = this.boatGlide;
if (this.getControllingPassenger() instanceof EntityPlayer)
{
this.boatGlide /= 2.0F;
}
}
this.motionX *= (double)this.momentum;
this.motionZ *= (double)this.momentum;
this.deltaRotation *= this.momentum;
this.motionY += d1;
if (d2 > 0.0D)
{
double d3 = 0.65D;
this.motionY += d2 * (-d0 / 0.65D);
double d4 = 0.75D;
this.motionY *= 0.75D;
}
}
}
private void controlBoat()
{
if (this.isBeingRidden())
{
float f = 0.0F;
if (this.leftInputDown)
{
this.deltaRotation += -1.0F;
}
if (this.rightInputDown)
{
++this.deltaRotation;
}
if (this.rightInputDown != this.leftInputDown && !this.forwardInputDown && !this.backInputDown)
{
f += 0.005F;
}
this.rotationYaw += this.deltaRotation;
if (this.forwardInputDown)
{
f += 0.04F;
}
if (this.backInputDown)
{
f -= 0.005F;
}
this.motionX += (double)(MathHelper.sin(-this.rotationYaw * 0.017453292F) * f);
this.motionZ += (double)(MathHelper.cos(this.rotationYaw * 0.017453292F) * f);
this.setPaddleState(this.rightInputDown || this.forwardInputDown, this.leftInputDown || this.forwardInputDown);
}
}
public void updatePassenger(Entity passenger)
{
if (this.isPassenger(passenger))
{
float f = 0.0F;
float f1 = (float)((this.isDead ? 0.009999999776482582D : this.getMountedYOffset()) + passenger.getYOffset());
if (this.getPassengers().size() > 1)
{
int i = this.getPassengers().indexOf(passenger);
if (i == 0)
{
f = 0.2F;
}
else
{
f = -0.6F;
}
if (passenger instanceof EntityAnimal)
{
f = (float)((double)f + 0.2D);
}
}
Vec3d vec3d = (new Vec3d((double)f, 0.0D, 0.0D)).rotateYaw(-this.rotationYaw * 0.017453292F - ((float)Math.PI / 2F));
passenger.setPosition(this.posX + vec3d.xCoord, this.posY + (double)f1, this.posZ + vec3d.zCoord);
passenger.rotationYaw += this.deltaRotation;
passenger.setRotationYawHead(passenger.getRotationYawHead() + this.deltaRotation);
this.applyYawToEntity(passenger);
if (passenger instanceof EntityAnimal && this.getPassengers().size() > 1)
{
int j = passenger.getEntityId() % 2 == 0 ? 90 : 270;
passenger.setRenderYawOffset(((EntityAnimal)passenger).renderYawOffset + (float)j);
passenger.setRotationYawHead(passenger.getRotationYawHead() + (float)j);
}
}
}
/**
* Applies this boat's yaw to the given entity. Used to update the orientation of its passenger.
*/
protected void applyYawToEntity(Entity entityToUpdate)
{
entityToUpdate.setRenderYawOffset(this.rotationYaw);
float f = MathHelper.wrapDegrees(entityToUpdate.rotationYaw - this.rotationYaw);
float f1 = MathHelper.clamp_float(f, -105.0F, 105.0F);
entityToUpdate.prevRotationYaw += f1 - f;
entityToUpdate.rotationYaw += f1 - f;
entityToUpdate.setRotationYawHead(entityToUpdate.rotationYaw);
}
/**
* Applies this entity's orientation (pitch/yaw) to another entity. Used to update passenger orientation.
*/
@SideOnly(Side.CLIENT)
public void applyOrientationToEntity(Entity entityToUpdate)
{
this.applyYawToEntity(entityToUpdate);
}
/**
* (abstract) Protected helper method to write subclass entity data to NBT.
*/
protected void writeEntityToNBT(NBTTagCompound compound)
{
compound.setString("Type", this.getBoatType().getName());
}
/**
* (abstract) Protected helper method to read subclass entity data from NBT.
*/
protected void readEntityFromNBT(NBTTagCompound compound)
{
if (compound.hasKey("Type", 8))
{
this.setBoatType(EntitySteamBoat.Type.getTypeFromString(compound.getString("Type")));
}
}
public boolean processInitialInteract(EntityPlayer player, @Nullable ItemStack stack, EnumHand hand)
{
if (!this.worldObj.isRemote && !player.isSneaking() && this.outOfControlTicks < 60.0F)
{
player.startRiding(this);
}
return true;
}
protected void updateFallState(double y, boolean onGroundIn, IBlockState state, BlockPos pos)
{
this.lastYd = this.motionY;
if (!this.isRiding())
{
if (onGroundIn)
{
if (this.fallDistance > 3.0F)
{
if (this.status != EntitySteamBoat.Status.ON_LAND)
{
this.fallDistance = 0.0F;
return;
}
this.fall(this.fallDistance, 1.0F);
if (!this.worldObj.isRemote && !this.isDead)
{
this.setDead();
if (this.worldObj.getGameRules().getBoolean("doEntityDrops"))
{
for (int i = 0; i < 3; ++i)
{
this.entityDropItem(new ItemStack(Item.getItemFromBlock(Blocks.PLANKS), 1, this.getBoatType().getMetadata()), 0.0F);
}
for (int j = 0; j < 2; ++j)
{
this.dropItemWithOffset(Items.STICK, 1, 0.0F);
}
}
}
}
this.fallDistance = 0.0F;
}
else if (this.worldObj.getBlockState((new BlockPos(this)).down()).getMaterial() != Material.WATER && y < 0.0D)
{
this.fallDistance = (float)((double)this.fallDistance - y);
}
}
}
public boolean getPaddleState(int p_184457_1_)
{
return ((Boolean)this.dataManager.get(DATA_ID_PADDLE[p_184457_1_])).booleanValue() && this.getControllingPassenger() != null;
}
/**
* Sets the damage taken from the last hit.
*/
public void setDamageTaken(float damageTaken)
{
this.dataManager.set(DAMAGE_TAKEN, Float.valueOf(damageTaken));
}
/**
* Gets the damage taken from the last hit.
*/
public float getDamageTaken()
{
return ((Float)this.dataManager.get(DAMAGE_TAKEN)).floatValue();
}
/**
* Sets the time to count down from since the last time entity was hit.
*/
public void setTimeSinceHit(int timeSinceHit)
{
this.dataManager.set(TIME_SINCE_HIT, Integer.valueOf(timeSinceHit));
}
/**
* Gets the time since the last hit.
*/
public int getTimeSinceHit()
{
return ((Integer)this.dataManager.get(TIME_SINCE_HIT)).intValue();
}
/**
* Sets the forward direction of the entity.
*/
public void setForwardDirection(int forwardDirection)
{
this.dataManager.set(FORWARD_DIRECTION, Integer.valueOf(forwardDirection));
}
/**
* Gets the forward direction of the entity.
*/
public int getForwardDirection()
{
return ((Integer)this.dataManager.get(FORWARD_DIRECTION)).intValue();
}
public void setBoatType(EntitySteamBoat.Type boatType)
{
this.dataManager.set(BOAT_TYPE, Integer.valueOf(boatType.ordinal()));
}
public EntitySteamBoat.Type getBoatType()
{
return EntitySteamBoat.Type.byId(((Integer)this.dataManager.get(BOAT_TYPE)).intValue());
}
protected boolean canFitPassenger(Entity passenger)
{
return this.getPassengers().size() < 2;
}
/**
* For vehicles, the first passenger is generally considered the controller and "drives" the vehicle. For example,
* Pigs, Horses, and Boats are generally "steered" by the controlling passenger.
*/
@Nullable
public Entity getControllingPassenger()
{
List<Entity> list = this.getPassengers();
return list.isEmpty() ? null : (Entity)list.get(0);
}
@SideOnly(Side.CLIENT)
public void updateInputs(boolean p_184442_1_, boolean p_184442_2_, boolean p_184442_3_, boolean p_184442_4_)
{
this.leftInputDown = p_184442_1_;
this.rightInputDown = p_184442_2_;
this.forwardInputDown = p_184442_3_;
this.backInputDown = p_184442_4_;
}
public static enum Status
{
IN_WATER,
UNDER_WATER,
UNDER_FLOWING_WATER,
ON_LAND,
IN_AIR;
}
public static enum Type
{
OAK(BlockPlanks.EnumType.OAK.getMetadata(), "oak"),
SPRUCE(BlockPlanks.EnumType.SPRUCE.getMetadata(), "spruce"),
BIRCH(BlockPlanks.EnumType.BIRCH.getMetadata(), "birch"),
JUNGLE(BlockPlanks.EnumType.JUNGLE.getMetadata(), "jungle"),
ACACIA(BlockPlanks.EnumType.ACACIA.getMetadata(), "acacia"),
DARK_OAK(BlockPlanks.EnumType.DARK_OAK.getMetadata(), "dark_oak");
private final String name;
private final int metadata;
private Type(int metadataIn, String nameIn)
{
this.name = nameIn;
this.metadata = metadataIn;
}
public String getName()
{
return this.name;
}
public int getMetadata()
{
return this.metadata;
}
public String toString()
{
return this.name;
}
/**
* Get a boat type by it's enum ordinal
*/
public static EntitySteamBoat.Type byId(int id)
{
if (id < 0 || id >= values().length)
{
id = 0;
}
return values()[id];
}
public static EntitySteamBoat.Type getTypeFromString(String nameIn)
{
for (int i = 0; i < values().length; ++i)
{
if (values()[i].getName().equals(nameIn))
{
return values()[i];
}
}
return values()[0];
}
}
}
Код:
public class RenderSteamBoat extends Render<EntityBoat>
{
private static final ResourceLocation[] BOAT_TEXTURES = new ResourceLocation[] {new ResourceLocation("textures/entity/boat/boat_oak.png"), new ResourceLocation("textures/entity/boat/boat_spruce.png"), new ResourceLocation("textures/entity/boat/boat_birch.png"), new ResourceLocation("textures/entity/boat/boat_jungle.png"), new ResourceLocation("textures/entity/boat/boat_acacia.png"), new ResourceLocation("textures/entity/boat/boat_darkoak.png")};
/** instance of ModelBoat for rendering */
protected ModelBase modelBoat = new ModelBoat();
public RenderSteamBoat(RenderManager renderManagerIn)
{
super(renderManagerIn);
this.shadowSize = 0.5F;
}
/**
* Renders the desired {@code T} type Entity.
*/
public void doRender(EntityBoat entity, double x, double y, double z, float entityYaw, float partialTicks)
{
GlStateManager.pushMatrix();
this.setupTranslation(x, y, z);
this.setupRotation(entity, entityYaw, partialTicks);
this.bindEntityTexture(entity);
if (this.renderOutlines)
{
GlStateManager.enableColorMaterial();
GlStateManager.enableOutlineMode(this.getTeamColor(entity));
}
this.modelBoat.render(entity, partialTicks, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
if (this.renderOutlines)
{
GlStateManager.disableOutlineMode();
GlStateManager.disableColorMaterial();
}
GlStateManager.popMatrix();
super.doRender(entity, x, y, z, entityYaw, partialTicks);
}
public void setupRotation(EntityBoat p_188311_1_, float p_188311_2_, float p_188311_3_)
{
GlStateManager.rotate(180.0F - p_188311_2_, 0.0F, 1.0F, 0.0F);
float f = (float)p_188311_1_.getTimeSinceHit() - p_188311_3_;
float f1 = p_188311_1_.getDamageTaken() - p_188311_3_;
if (f1 < 0.0F)
{
f1 = 0.0F;
}
if (f > 0.0F)
{
GlStateManager.rotate(MathHelper.sin(f) * f * f1 / 10.0F * (float)p_188311_1_.getForwardDirection(), 1.0F, 0.0F, 0.0F);
}
GlStateManager.scale(-1.0F, -1.0F, 1.0F);
}
public void setupTranslation(double p_188309_1_, double p_188309_3_, double p_188309_5_)
{
GlStateManager.translate((float)p_188309_1_, (float)p_188309_3_ + 0.375F, (float)p_188309_5_);
}
/**
* Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
*/
protected ResourceLocation getEntityTexture(EntityBoat entity)
{
return BOAT_TEXTURES[entity.getBoatType().ordinal()];
}
public boolean isMultipass()
{
return true;
}
public void renderMultipass(EntityBoat p_188300_1_, double p_188300_2_, double p_188300_4_, double p_188300_6_, float p_188300_8_, float p_188300_9_)
{
GlStateManager.pushMatrix();
this.setupTranslation(p_188300_2_, p_188300_4_, p_188300_6_);
this.setupRotation(p_188300_1_, p_188300_8_, p_188300_9_);
this.bindEntityTexture(p_188300_1_);
((IMultipassModel)this.modelBoat).renderMultipass(p_188300_1_, p_188300_9_, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
GlStateManager.popMatrix();
}
}