Files
TinkersConstruct/src/main/java/tconstruct/world/entity/CartEntity.java
T

1274 lines
41 KiB
Java

package tconstruct.world.entity;
import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData;
import cpw.mods.fml.relauncher.*;
import io.netty.buffer.ByteBuf;
import java.util.*;
import net.minecraft.block.*;
import net.minecraft.entity.*;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.monster.EntityIronGolem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.*;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.*;
import net.minecraft.world.*;
public class CartEntity extends Entity implements IInventory, IEntityAdditionalSpawnData {
/** Array of item stacks stored in minecart (for storage minecarts). */
protected ItemStack[] cargoItems;
protected int fuel;
protected boolean isInReverse;
/** The type of minecart, 2 for powered, 1 for storage. */
private int pullcartType;
public double pushX;
public double pushZ;
protected boolean field_82345_h;
/** Minecart rotational logic matrix */
protected static final int[][][] matrix = new int[][][] {
{{0, 0, -1}, {0, 0, 1}},
{{-1, 0, 0}, {1, 0, 0}},
{{-1, -1, 0}, {1, 0, 0}},
{{-1, 0, 0}, {1, -1, 0}},
{{0, 0, -1}, {0, -1, 1}},
{{0, -1, -1}, {0, 0, 1}},
{{0, 0, 1}, {1, 0, 0}},
{{0, 0, 1}, {-1, 0, 0}},
{{0, 0, -1}, {-1, 0, 0}},
{{0, 0, -1}, {1, 0, 0}}
};
/** appears to be the progress of the turn */
protected int turnProgress;
protected double minecartX;
protected double minecartY;
protected double minecartZ;
protected double minecartYaw;
protected double minecartPitch;
@SideOnly(Side.CLIENT)
protected double velocityX;
@SideOnly(Side.CLIENT)
protected double velocityY;
@SideOnly(Side.CLIENT)
protected double velocityZ;
/* Forge: Minecart Compatibility Layer Integration. */
public static float defaultMaxSpeedRail = 0.4f;
public static float defaultMaxSpeedGround = 0.4f;
public static float defaultMaxSpeedAirLateral = 0.4f;
public static float defaultMaxSpeedAirVertical = -1f;
public static double defaultDragRidden = 0.996999979019165D;
public static double defaultDragEmpty = 0.9599999785423279D;
public static double defaultDragAir = 0.94999998807907104D;
protected boolean canUseRail = true;
protected boolean canBePushed = true;
/* Instance versions of the above physics properties */
protected float maxSpeedRail;
protected float maxSpeedGround;
protected float maxSpeedAirLateral;
protected float maxSpeedAirVertical;
protected double dragAir;
Entity entityFollowing;
public CartEntity(World par1World) {
super(par1World);
this.cargoItems = new ItemStack[36];
this.fuel = 0;
this.isInReverse = false;
this.field_82345_h = true;
this.preventEntitySpawning = true;
this.setSize(0.98F, 0.7F);
this.yOffset = this.height / 2.0F;
this.stepHeight = 1.0f;
maxSpeedRail = defaultMaxSpeedRail;
maxSpeedGround = defaultMaxSpeedGround;
maxSpeedAirLateral = defaultMaxSpeedAirLateral;
maxSpeedAirVertical = defaultMaxSpeedAirVertical;
dragAir = defaultDragAir;
}
public CartEntity(World world, int type) {
this(world);
pullcartType = type;
}
public CartEntity(World world, double x, double y, double z, int type) {
this(world);
this.setPosition(x, y + (double) this.yOffset, z);
this.motionX = 0.0D;
this.motionY = 0.0D;
this.motionZ = 0.0D;
this.prevPosX = x;
this.prevPosY = y;
this.prevPosZ = z;
this.pullcartType = type;
this.stepHeight = 1.0f;
}
/**
* returns if this entity triggers Block.onEntityWalking on the blocks they
* walk on. used for spiders and wolves to prevent them from trampling crops
*/
@Override
protected boolean canTriggerWalking() {
return false;
}
@Override
protected void entityInit() {
this.dataWatcher.addObject(16, new Byte((byte) 0));
this.dataWatcher.addObject(17, new Integer(0));
this.dataWatcher.addObject(18, new Integer(1));
this.dataWatcher.addObject(19, new Integer(0));
}
/**
* 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.
*/
@Override
public AxisAlignedBB getCollisionBox(Entity par1Entity) {
return par1Entity.boundingBox;
}
/**
* returns the bounding box for this entity
*/
@Override
public AxisAlignedBB getBoundingBox() {
return this.boundingBox;
}
/**
* Returns true if this entity should push and be pushed by other entities
* when colliding.
*/
@Override
public boolean canBePushed() {
return canBePushed;
}
/**
* Returns the Y offset from the entity's position for any entity riding
* this one.
*/
@Override
public double getMountedYOffset() {
return (double) this.height * 0.0D - 0.30000001192092896D;
}
/**
* Called when the entity is attacked.
*/
public boolean attackEntityFrom(DamageSource par1DamageSource, int par2) {
if (!this.worldObj.isRemote && !this.isDead) {
if (this.isEntityInvulnerable()) {
return false;
} else {
this.setRollingDirection(-this.getRollingDirection());
this.setRollingAmplitude(10);
this.setBeenAttacked();
this.setDamage(this.getDamage() + par2 * 10);
if (par1DamageSource.getEntity() instanceof EntityPlayer
&& ((EntityPlayer) par1DamageSource.getEntity()).capabilities.isCreativeMode) {
this.setDamage(100);
}
if (this.getDamage() > 40) {
if (this.riddenByEntity != null) {
this.riddenByEntity.mountEntity(this);
}
this.setDead();
dropCartAsItem();
}
return true;
}
} else {
return true;
}
}
@Override
@SideOnly(Side.CLIENT)
/**
* Setups the entity to do the hurt animation. Only used by packets in multiplayer.
*/
public void performHurtAnimation() {
this.setRollingDirection(-this.getRollingDirection());
this.setRollingAmplitude(10);
this.setDamage(this.getDamage() + this.getDamage() * 10);
}
/**
* Returns true if other Entities should be prevented from moving through
* this Entity.
*/
@Override
public boolean canBeCollidedWith() {
return !this.isDead;
}
/**
* Will get destroyed next tick.
*/
@Override
public void setDead() {
if (this.field_82345_h) {
for (int var1 = 0; var1 < this.getSizeInventory(); ++var1) {
ItemStack var2 = this.getStackInSlot(var1);
if (var2 != null) {
float var3 = this.rand.nextFloat() * 0.8F + 0.1F;
float var4 = this.rand.nextFloat() * 0.8F + 0.1F;
float var5 = this.rand.nextFloat() * 0.8F + 0.1F;
while (var2.stackSize > 0) {
int var6 = this.rand.nextInt(21) + 10;
if (var6 > var2.stackSize) {
var6 = var2.stackSize;
}
var2.stackSize -= var6;
EntityItem entityitem = new EntityItem(
this.worldObj,
this.posX + (double) var3,
this.posY + (double) var4,
this.posZ + (double) var5,
new ItemStack(var2.getItem(), var6, var2.getItemDamage()));
if (var2.hasTagCompound()) {
entityitem.getEntityItem().setTagCompound((NBTTagCompound)
var2.getTagCompound().copy());
}
float var8 = 0.05F;
entityitem.motionX = (float) this.rand.nextGaussian() * var8;
entityitem.motionY = (float) this.rand.nextGaussian() * var8 + 0.2F;
entityitem.motionZ = (float) this.rand.nextGaussian() * var8;
this.worldObj.spawnEntityInWorld(entityitem);
}
}
}
}
super.setDead();
}
/**
* Teleports the entity to another dimension. Params: Dimension number to
* teleport to
*/
@Override
public void travelToDimension(int par1) {
this.field_82345_h = false;
super.travelToDimension(par1);
}
/**
* Called to update the entity's position/logic.
*/
@Override
public void onUpdate() {
if (this.getRollingAmplitude() > 0) {
this.setRollingAmplitude(this.getRollingAmplitude() - 1);
}
if (this.getDamage() > 0) {
this.setDamage(this.getDamage() - 1);
}
if (this.posY < -64.0D) {
this.kill();
}
if (this.isMinecartPowered()
&& this.rand.nextInt(4) == 0
&& pullcartType == 2
&& getClass() == CartEntity.class) {
this.worldObj.spawnParticle("largesmoke", this.posX, this.posY + 0.8D, this.posZ, 0.0D, 0.0D, 0.0D);
}
int var2;
if (!this.worldObj.isRemote && this.worldObj instanceof WorldServer) {
this.worldObj.theProfiler.startSection("portal");
MinecraftServer var1 = ((WorldServer) this.worldObj).func_73046_m();
var2 = this.getMaxInPortalTime();
// if (this.inPortal) {
// if (var1.getAllowNether()) {
// /*
// * if (this.ridingEntity == null && this.timeInPortal++ >=
// * var2) { this.timeInPortal = var2; this.timeUntilPortal =
// * this.getPortalCooldown(); byte var3;
// *
// * if (this.worldObj.provider.dimensionId == -1) { var3 = 0;
// * } else { var3 = -1; }
// *
// * this.travelToDimension(var3); }
// *
// * this.inPortal = false;
// */
// }
// } else {
// /*
// * if (this.timeInPortal > 0) { this.timeInPortal -= 4; }
// *
// * if (this.timeInPortal < 0) { this.timeInPortal = 0; }
// */
// }
if (this.timeUntilPortal > 0) {
--this.timeUntilPortal;
}
this.worldObj.theProfiler.endSection();
}
if (this.worldObj.isRemote) {
if (this.turnProgress > 0) {
double var46 = this.posX + (this.minecartX - this.posX) / (double) this.turnProgress;
double var48 = this.posY + (this.minecartY - this.posY) / (double) this.turnProgress;
double var5 = this.posZ + (this.minecartZ - this.posZ) / (double) this.turnProgress;
double var7 = MathHelper.wrapAngleTo180_double(this.minecartYaw - (double) this.rotationYaw);
this.rotationYaw = (float) ((double) this.rotationYaw + var7 / (double) this.turnProgress);
this.rotationPitch = (float) ((double) this.rotationPitch
+ (this.minecartPitch - (double) this.rotationPitch) / (double) this.turnProgress);
--this.turnProgress;
this.setPosition(var46, var48, var5);
} else {
this.setPosition(this.posX, this.posY, this.posZ);
}
this.setRotation(this.rotationYaw, this.rotationPitch);
} else {
this.prevPosX = this.posX;
this.prevPosY = this.posY;
this.prevPosZ = this.posZ;
this.motionY -= 0.03999999910593033D;
int var45 = MathHelper.floor_double(this.posX);
var2 = MathHelper.floor_double(this.posY);
int var47 = MathHelper.floor_double(this.posZ);
if (BlockRail.func_150049_b_(this.worldObj, var45, var2 - 1, var47)) {
--var2;
}
double var4 = 0.4D;
double var6 = 0.0078125D;
Block var8 = this.worldObj.getBlock(var45, var2, var47);
moveMinecartOffRail(var45, var2, var47);
if (entityFollowing != null) moveTowardsEntity(entityFollowing);
this.func_145775_I();
this.rotationPitch = 0.0F;
double var49 = this.prevPosX - this.posX;
double var50 = this.prevPosZ - this.posZ;
if (var49 * var49 + var50 * var50 > 0.001D) {
this.rotationYaw = (float) (Math.atan2(var50, var49) * 180.0D / Math.PI);
if (this.isInReverse) {
this.rotationYaw += 180.0F;
}
}
double var51 = MathHelper.wrapAngleTo180_float(this.rotationYaw - this.prevRotationYaw);
if (var51 < -170.0D || var51 >= 170.0D) {
this.rotationYaw += 180.0F;
this.isInReverse = !this.isInReverse;
}
this.setRotation(this.rotationYaw, this.rotationPitch);
AxisAlignedBB box = boundingBox.expand(0.2D, 0.0D, 0.2D);
List var15 = this.worldObj.getEntitiesWithinAABBExcludingEntity(this, box);
if (var15 != null && !var15.isEmpty()) {
for (int var52 = 0; var52 < var15.size(); ++var52) {
Entity var17 = (Entity) var15.get(var52);
if (var17 != this.riddenByEntity && var17.canBePushed() && var17 instanceof CartEntity) {
var17.applyEntityCollision(this);
}
}
}
if (this.riddenByEntity != null && this.riddenByEntity.isDead) {
if (this.riddenByEntity.ridingEntity == this) {
this.riddenByEntity.ridingEntity = null;
}
this.riddenByEntity = null;
}
updateFuel();
}
}
void moveTowardsEntity(Entity entity) {
// TConstruct.logger.info("Moving towards entity");
/*
* double distX = this.posX - entity.posX; double distZ = this.posZ -
* entity.posZ; //posY = posY + 0.1;
*
* if (entity.posY > this.posY) motionY += 0.1; if (distX > 0.5 && distZ
* > 0.5) { motionX = -distX; motionZ = -distZ; }
*/
double var15 = entity.posX;
double var19 = entity.posZ;
if (this.calculateDistance(this.prevPosX, var15) > 1.5D
|| this.calculateDistance(this.prevPosZ, var19) > 1.5D) {
double var28 = this.prevPosX;
double var30 = this.prevPosZ;
double var36 = this.calculateDistance(var28, var15);
double var38 = this.calculateDistance(var30, var19);
double var40 = 1.0D;
double var42 = 1.0D;
double var46;
double var44;
if (var36 > var38) {
var46 = 1.0D;
var44 = var38 / var36;
var42 = var44 / 3.0D;
var40 = var46 / 3.0D;
} else if (var38 > var36) {
var44 = 1.0D;
var46 = var36 / var38;
var40 = var46 / 3.0D;
var42 = var44 / 3.0D;
}
if (var15 > var28) {
this.motionX = var40; // * var26;
} else {
this.motionX = -var40; // * var26;
}
if (var19 > var30) {
this.motionZ = var42; // * var26;
} else {
this.motionZ = -var42; // * var26;
}
}
/*
* if (entity.posY > this.posY) motionY += 0.1;
*/
}
public double calculateDistance(double pos1, double pos2) {
double distance = Math.abs(pos1 - pos2); // 0.0D;
/*
* double absPos1 = Math.abs(pos1); double absPos2 = Math.abs(pos2);
*
* if ((pos1 <= 0.0D || pos2 <= 0.0D) && (pos1 >= 0.0D || pos2 >= 0.0D))
* { distance = absPos1 + absPos2; } else if (absPos1 > absPos2) {
* distance = absPos1 - absPos2; } else if (absPos2 > absPos1) {
* distance = absPos2 - absPos1; }
*/
return distance;
}
@SideOnly(Side.CLIENT)
public Vec3 func_70495_a(double par1, double par3, double par5, double par7) {
int var9 = MathHelper.floor_double(par1);
int var10 = MathHelper.floor_double(par3);
int var11 = MathHelper.floor_double(par5);
if (BlockRail.func_150049_b_(this.worldObj, var9, var10 - 1, var11)) {
--var10;
}
Block var12 = this.worldObj.getBlock(var9, var10, var11);
return null;
}
public Vec3 func_70489_a(double par1, double par3, double par5) {
int var7 = MathHelper.floor_double(par1);
int var8 = MathHelper.floor_double(par3);
int var9 = MathHelper.floor_double(par5);
if (BlockRail.func_150049_b_(this.worldObj, var7, var8 - 1, var9)) {
--var8;
}
Block var10 = this.worldObj.getBlock(var7, var8, var9);
if (BlockRail.func_150051_a(var10)) {
int var11 = 0;
par3 = var8;
if (var11 >= 2 && var11 <= 5) {
par3 = var8 + 1;
}
int[][] var12 = matrix[var11];
double var13;
double var15 = (double) var7 + 0.5D + (double) var12[0][0] * 0.5D;
double var17 = (double) var8 + 0.5D + (double) var12[0][1] * 0.5D;
double var19 = (double) var9 + 0.5D + (double) var12[0][2] * 0.5D;
double var21 = (double) var7 + 0.5D + (double) var12[1][0] * 0.5D;
double var23 = (double) var8 + 0.5D + (double) var12[1][1] * 0.5D;
double var25 = (double) var9 + 0.5D + (double) var12[1][2] * 0.5D;
double var27 = var21 - var15;
double var29 = (var23 - var17) * 2.0D;
double var31 = var25 - var19;
if (var27 == 0.0D) {
par1 = (double) var7 + 0.5D;
var13 = par5 - (double) var9;
} else if (var31 == 0.0D) {
par5 = (double) var9 + 0.5D;
var13 = par1 - (double) var7;
} else {
double var33 = par1 - var15;
double var35 = par5 - var19;
var13 = (var33 * var27 + var35 * var31) * 2.0D;
}
par1 = var15 + var27 * var13;
par3 = var17 + var29 * var13;
par5 = var19 + var31 * var13;
if (var29 < 0.0D) {
++par3;
}
if (var29 > 0.0D) {
par3 += 0.5D;
}
return Vec3.createVectorHelper(par1, par3, par5);
} else {
return null;
}
}
/**
* (abstract) Protected helper method to write subclass entity data to NBT.
*/
@Override
protected void writeEntityToNBT(NBTTagCompound par1NBTTagCompound) {
par1NBTTagCompound.setInteger("Type", pullcartType);
if (isPoweredCart()) {
par1NBTTagCompound.setDouble("PushX", this.pushX);
par1NBTTagCompound.setDouble("PushZ", this.pushZ);
par1NBTTagCompound.setInteger("Fuel", this.fuel);
}
if (getSizeInventory() > 0) {
NBTTagList var2 = new NBTTagList();
for (int var3 = 0; var3 < this.cargoItems.length; ++var3) {
if (this.cargoItems[var3] != null) {
NBTTagCompound var4 = new NBTTagCompound();
var4.setByte("Slot", (byte) var3);
this.cargoItems[var3].writeToNBT(var4);
var2.appendTag(var4);
}
}
par1NBTTagCompound.setTag("Items", var2);
}
}
/**
* (abstract) Protected helper method to read subclass entity data from NBT.
*/
@Override
protected void readEntityFromNBT(NBTTagCompound par1NBTTagCompound) {
pullcartType = par1NBTTagCompound.getInteger("Type");
if (isPoweredCart()) {
this.pushX = par1NBTTagCompound.getDouble("PushX");
this.pushZ = par1NBTTagCompound.getDouble("PushZ");
try {
this.fuel = par1NBTTagCompound.getInteger("Fuel");
} catch (ClassCastException e) {
this.fuel = par1NBTTagCompound.getShort("Fuel");
}
}
if (getSizeInventory() > 0) {
NBTTagList var2 = par1NBTTagCompound.getTagList("Items", 10);
this.cargoItems = new ItemStack[this.getSizeInventory()];
for (int var3 = 0; var3 < var2.tagCount(); ++var3) {
NBTTagCompound var4 = var2.getCompoundTagAt(var3);
int var5 = var4.getByte("Slot") & 255;
if (var5 >= 0 && var5 < this.cargoItems.length) {
this.cargoItems[var5] = ItemStack.loadItemStackFromNBT(var4);
}
}
}
}
@Override
@SideOnly(Side.CLIENT)
public float getShadowSize() {
return 0.5F;
}
/**
* Applies a velocity to each of the entities pushing them away from each
* other. Args: entity
*/
@Override
public void applyEntityCollision(Entity par1Entity) {
if (!this.worldObj.isRemote) {
if (par1Entity != this.riddenByEntity) {
if (par1Entity instanceof EntityLiving
&& !(par1Entity instanceof EntityPlayer)
&& !(par1Entity instanceof EntityIronGolem)
&& canBeRidden()
&& this.motionX * this.motionX + this.motionZ * this.motionZ > 0.01D
&& this.riddenByEntity == null
&& par1Entity.ridingEntity == null) {
par1Entity.mountEntity(this);
}
double var2 = par1Entity.posX - this.posX;
double var4 = par1Entity.posZ - this.posZ;
double var6 = var2 * var2 + var4 * var4;
if (var6 >= 9.999999747378752E-5D) {
var6 = MathHelper.sqrt_double(var6);
var2 /= var6;
var4 /= var6;
double var8 = 1.0D / var6;
if (var8 > 1.0D) {
var8 = 1.0D;
}
var2 *= var8;
var4 *= var8;
var2 *= 0.10000000149011612D;
var4 *= 0.10000000149011612D;
var2 *= 1.0F - this.entityCollisionReduction;
var4 *= 1.0F - this.entityCollisionReduction;
var2 *= 0.5D;
var4 *= 0.5D;
if (par1Entity instanceof CartEntity) {
double var10 = par1Entity.posX - this.posX;
double var12 = par1Entity.posZ - this.posZ;
Vec3 var14 = Vec3.createVectorHelper(var10, 0.0D, var12).normalize();
Vec3 var15 = Vec3.createVectorHelper(
MathHelper.cos(this.rotationYaw * (float) Math.PI / 180.0F),
0.0D,
MathHelper.sin(this.rotationYaw * (float) Math.PI / 180.0F))
.normalize();
double var16 = Math.abs(var14.dotProduct(var15));
if (var16 < 0.8D) {
return;
}
double var18 = par1Entity.motionX + this.motionX;
double var20 = par1Entity.motionZ + this.motionZ;
if (((CartEntity) par1Entity).isPoweredCart() && !isPoweredCart()) {
this.motionX *= 0.20000000298023224D;
this.motionZ *= 0.20000000298023224D;
this.addVelocity(par1Entity.motionX - var2, 0.0D, par1Entity.motionZ - var4);
par1Entity.motionX *= 0.949999988079071D;
par1Entity.motionZ *= 0.949999988079071D;
} else if (!((CartEntity) par1Entity).isPoweredCart() && isPoweredCart()) {
par1Entity.motionX *= 0.20000000298023224D;
par1Entity.motionZ *= 0.20000000298023224D;
par1Entity.addVelocity(this.motionX + var2, 0.0D, this.motionZ + var4);
this.motionX *= 0.949999988079071D;
this.motionZ *= 0.949999988079071D;
} else {
var18 /= 2.0D;
var20 /= 2.0D;
this.motionX *= 0.20000000298023224D;
this.motionZ *= 0.20000000298023224D;
this.addVelocity(var18 - var2, 0.0D, var20 - var4);
par1Entity.motionX *= 0.20000000298023224D;
par1Entity.motionZ *= 0.20000000298023224D;
par1Entity.addVelocity(var18 + var2, 0.0D, var20 + var4);
}
} else {
this.addVelocity(-var2, 0.0D, -var4);
par1Entity.addVelocity(var2 / 4.0D, 0.0D, var4 / 4.0D);
}
}
}
}
}
/**
* Returns the number of slots in the inventory.
*/
@Override
public int getSizeInventory() {
return (pullcartType == 1 && getClass() == CartEntity.class ? 27 : 0);
}
/**
* Returns the stack in slot i
*/
@Override
public ItemStack getStackInSlot(int par1) {
return this.cargoItems[par1];
}
/**
* Removes from an inventory slot (first arg) up to a specified number
* (second arg) of items and returns them in a new stack.
*/
@Override
public ItemStack decrStackSize(int par1, int par2) {
if (this.cargoItems[par1] != null) {
ItemStack var3;
if (this.cargoItems[par1].stackSize <= par2) {
var3 = this.cargoItems[par1];
this.cargoItems[par1] = null;
} else {
var3 = this.cargoItems[par1].splitStack(par2);
if (this.cargoItems[par1].stackSize == 0) {
this.cargoItems[par1] = null;
}
}
return var3;
} else {
return null;
}
}
/**
* When some containers are closed they call this on each slot, then drop
* whatever it returns as an EntityItem - like when you close a workbench
* GUI.
*/
@Override
public ItemStack getStackInSlotOnClosing(int par1) {
if (this.cargoItems[par1] != null) {
ItemStack var2 = this.cargoItems[par1];
this.cargoItems[par1] = null;
return var2;
} else {
return null;
}
}
/**
* Sets the given item stack to the specified slot in the inventory (can be
* crafting or armor sections).
*/
@Override
public void setInventorySlotContents(int par1, ItemStack par2ItemStack) {
this.cargoItems[par1] = par2ItemStack;
if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) {
par2ItemStack.stackSize = this.getInventoryStackLimit();
}
}
/**
* Returns the name of the inventory.
*/
public String getInvName() {
return "container.minecart";
}
/**
* Returns the maximum stack size for a inventory slot. Seems to always be
* 64, possibly will be extended. *Isn't this more of a set than a get?*
*/
@Override
public int getInventoryStackLimit() {
return 64;
}
/**
* Called when an the contents of an Inventory change, usually
*/
@Override
public void markDirty() {}
/**
* Called when a player interacts with a mob. e.g. gets milk from a cow,
* gets into the saddle on a pig.
*/
public boolean interact(EntityPlayer player) {
if (player.isSneaking()) {
if (entityFollowing == null) {
entityFollowing = player;
// if (!worldObj.isRemote)
// player.addChatMessage("The cart is following you");
} else {
entityFollowing = null;
// if (!worldObj.isRemote)
// player.addChatMessage("The cart has stopped following you");
}
return true;
}
if (canBeRidden()) {
if (this.riddenByEntity != null
&& this.riddenByEntity instanceof EntityPlayer
&& this.riddenByEntity != player) {
return true;
}
if (!this.worldObj.isRemote) {
player.mountEntity(this);
}
} else if (getSizeInventory() > 0) {
if (!this.worldObj.isRemote) {
player.displayGUIChest(this);
}
} else if (this.pullcartType == 2 && getClass() == CartEntity.class) {
ItemStack var2 = player.inventory.getCurrentItem();
if (var2 != null && var2.getItem() == Items.coal) {
if (--var2.stackSize == 0) {
player.inventory.setInventorySlotContents(player.inventory.currentItem, null);
}
this.fuel += 3600;
}
this.pushX = this.posX - player.posX;
this.pushZ = this.posZ - player.posZ;
}
return true;
}
@Override
@SideOnly(Side.CLIENT)
/**
* Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
* posY, posZ, yaw, pitch
*/
public void setPositionAndRotation2(double par1, double par3, double par5, float par7, float par8, int par9) {
this.minecartX = par1;
this.minecartY = par3;
this.minecartZ = par5;
this.minecartYaw = par7;
this.minecartPitch = par8;
this.turnProgress = par9 + 2;
this.motionX = this.velocityX;
this.motionY = this.velocityY;
this.motionZ = this.velocityZ;
}
@Override
@SideOnly(Side.CLIENT)
/**
* Sets the velocity to the args. Args: x, y, z
*/
public void setVelocity(double par1, double par3, double par5) {
this.velocityX = this.motionX = par1;
this.velocityY = this.motionY = par3;
this.velocityZ = this.motionZ = par5;
}
/**
* Do not make give this method the name canInteractWith because it clashes
* with Container
*/
@Override
public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) {
return !this.isDead && par1EntityPlayer.getDistanceSqToEntity(this) <= 64.0D;
}
/**
* Is this minecart powered (Fuel > 0)
*/
public boolean isMinecartPowered() {
return (this.dataWatcher.getWatchableObjectByte(16) & 1) != 0;
}
/**
* Set if this minecart is powered (Fuel > 0)
*/
protected void setMinecartPowered(boolean par1) {
if (par1) {
this.dataWatcher.updateObject(16, Byte.valueOf((byte) (this.dataWatcher.getWatchableObjectByte(16) | 1)));
} else {
this.dataWatcher.updateObject(16, Byte.valueOf((byte) (this.dataWatcher.getWatchableObjectByte(16) & -2)));
}
}
public void openChest() {}
public void closeChest() {}
/**
* Sets the current amount of damage the minecart has taken. Decreases over
* time. The cart breaks when this is over 40.
*/
public void setDamage(int par1) {
this.dataWatcher.updateObject(19, Integer.valueOf(par1));
}
/**
* Gets the current amount of damage the minecart has taken. Decreases over
* time. The cart breaks when this is over 40.
*/
public int getDamage() {
return this.dataWatcher.getWatchableObjectInt(19);
}
public void setRollingAmplitude(int par1) {
this.dataWatcher.updateObject(17, Integer.valueOf(par1));
}
public int getRollingAmplitude() {
return this.dataWatcher.getWatchableObjectInt(17);
}
public void setRollingDirection(int par1) {
this.dataWatcher.updateObject(18, Integer.valueOf(par1));
}
public int getRollingDirection() {
return this.dataWatcher.getWatchableObjectInt(18);
}
/**
* Drops the cart as a item. The exact item dropped is defined by
* getItemDropped().
*/
public void dropCartAsItem() {
for (ItemStack item : getItemsDropped()) {
entityDropItem(item, 0);
}
}
/**
* Override this to define which items your cart drops when broken. This
* does not include items contained in the inventory, that is handled
* elsewhere.
*
* @return A list of items dropped.
*/
public List<ItemStack> getItemsDropped() {
/*
* List<ItemStack> items = new ArrayList<ItemStack>(); items.add(new
* ItemStack(Item.minecartEmpty));
*
* switch(cartType) { case 1: items.add(new ItemStack(Block.chest));
* break; case 2: items.add(new ItemStack(Block.stoneOvenIdle)); break;
* } return items;
*/
return new ArrayList<>();
}
/**
* This function returns an ItemStack that represents this cart. This should
* be an ItemStack that can be used by the player to place the cart. This is
* the item that was registered with the cart via the registerMinecart
* function, but is not necessary the item the cart drops when destroyed.
*
* @return An ItemStack that can be used to place the cart.
*/
public ItemStack getCartItem() {
return null;
// return MinecartRegistry.getItemForCart(this);
}
/**
* Returns true if this cart is self propelled.
*
* @return True if powered.
*/
public boolean isPoweredCart() {
return pullcartType == 2 && getClass() == CartEntity.class;
}
/**
* Returns true if this cart is a storage cart Some carts may have
* inventories but not be storage carts and some carts without inventories
* may be storage carts.
*
* @return True if this cart should be classified as a storage cart.
*/
public boolean isStorageCart() {
return pullcartType == 1 && getClass() == CartEntity.class;
}
/**
* Returns true if this cart can be ridden by an Entity.
*
* @return True if this cart can be ridden.
*/
public boolean canBeRidden() {
return pullcartType == 0 && getClass() == CartEntity.class;
}
/**
* Returns true if this cart can currently use rails. This function is
* mainly used to gracefully detach a minecart from a rail.
*
* @return True if the minecart can use rails.
*/
public boolean canUseRail() {
return false;
}
/**
* Set whether the minecart can use rails. This function is mainly used to
* gracefully detach a minecart from a rail.
*
* @param use
* Whether the minecart can currently use rails.
*/
public void setCanUseRail(boolean use) {
canUseRail = use;
}
/**
* Return false if this cart should not call IRail.onMinecartPass() and
* should ignore Powered Rails.
*
* @return True if this cart should call IRail.onMinecartPass().
*/
public boolean shouldDoRailFunctions() {
return true;
}
/**
* Simply returns the minecartType variable.
*
* @return minecartType
*/
public int getCartType() {
return pullcartType;
}
/**
* Carts should return their drag factor here
*
* @return The drag rate.
*/
protected double getDrag() {
return riddenByEntity != null ? defaultDragRidden : defaultDragEmpty;
}
/**
* Moved to allow overrides. This code applies drag and updates push forces.
*/
protected void applyDragAndPushForces() {
if (isPoweredCart()) {
double d27 = MathHelper.sqrt_double(pushX * pushX + pushZ * pushZ);
if (d27 > 0.01D) {
pushX /= d27;
pushZ /= d27;
double d29 = 0.04;
motionX *= 0.8D;
motionY *= 0.0D;
motionZ *= 0.8D;
motionX += pushX * d29;
motionZ += pushZ * d29;
} else {
motionX *= 0.9D;
motionY *= 0.0D;
motionZ *= 0.9D;
}
}
motionX *= getDrag();
motionY *= 0.0D;
motionZ *= getDrag();
}
/**
* Moved to allow overrides. This code updates push forces.
*/
protected void updatePushForces() {
if (isPoweredCart()) {
double push = MathHelper.sqrt_double(pushX * pushX + pushZ * pushZ);
if (push > 0.01D && motionX * motionX + motionZ * motionZ > 0.001D) {
pushX /= push;
pushZ /= push;
if (pushX * motionX + pushZ * motionZ < 0.0D) {
pushX = 0.0D;
pushZ = 0.0D;
} else {
pushX = motionX;
pushZ = motionZ;
}
}
}
}
/**
* Moved to allow overrides. This code handles minecart movement and speed
* capping when not on a rail.
*/
protected void moveMinecartOffRail(int i, int j, int k) {
double d2 = getMaxSpeedGround();
if (!onGround) {
d2 = getMaxSpeedAirLateral();
}
if (motionX < -d2) motionX = -d2;
if (motionX > d2) motionX = d2;
if (motionZ < -d2) motionZ = -d2;
if (motionZ > d2) motionZ = d2;
double moveY = motionY;
if (getMaxSpeedAirVertical() > 0 && motionY > getMaxSpeedAirVertical()) {
moveY = getMaxSpeedAirVertical();
if (Math.abs(motionX) < 0.3f && Math.abs(motionZ) < 0.3f) {
moveY = 0.15f;
motionY = moveY;
}
}
if (onGround) {
motionX *= 0.5D;
motionY *= 0.5D;
motionZ *= 0.5D;
}
moveEntity(motionX, moveY, motionZ);
if (!onGround) {
motionX *= getDragAir();
motionY *= getDragAir();
motionZ *= getDragAir();
}
}
/**
* Moved to allow overrides. This code applies fuel consumption.
*/
protected void updateFuel() {
if (fuel > 0) fuel--;
if (fuel <= 0) pushX = pushZ = 0.0D;
setMinecartPowered(fuel > 0);
}
/**
* Moved to allow overrides, This code handle slopes affecting velocity.
*
* @param metadata
* The blocks position metadata
*/
protected void adjustSlopeVelocities(int metadata) {
double acceleration = 0.0078125D;
if (metadata == 2) {
motionX -= acceleration;
} else if (metadata == 3) {
motionX += acceleration;
} else if (metadata == 4) {
motionZ += acceleration;
} else if (metadata == 5) {
motionZ -= acceleration;
}
}
/**
* Getters/setters for physics variables
*/
/**
* Returns the carts max speed. Carts going faster than 1.1 cause issues
* with chunk loading. Carts cant traverse slopes or corners at greater than
* 0.5 - 0.6. This value is compared with the rails max speed to determine
* the carts current max speed. A normal rails max speed is 0.4.
*
* @return Carts max speed.
*/
public float getMaxSpeedRail() {
return maxSpeedRail;
}
public void setMaxSpeedRail(float value) {
maxSpeedRail = value;
}
public float getMaxSpeedGround() {
return maxSpeedGround;
}
public void setMaxSpeedGround(float value) {
maxSpeedGround = value;
}
public float getMaxSpeedAirLateral() {
return maxSpeedAirLateral;
}
public void setMaxSpeedAirLateral(float value) {
maxSpeedAirLateral = value;
}
public float getMaxSpeedAirVertical() {
return maxSpeedAirVertical;
}
public void setMaxSpeedAirVertical(float value) {
maxSpeedAirVertical = value;
}
public double getDragAir() {
return dragAir;
}
public void setDragAir(double value) {
dragAir = value;
}
@Override
public void writeSpawnData(ByteBuf data) {
data.writeInt(pullcartType);
}
@Override
public void readSpawnData(ByteBuf data) {
pullcartType = data.readInt();
}
@Override
public boolean isItemValidForSlot(int i, ItemStack itemstack) {
return false;
}
@Override
public String getInventoryName() {
// TODO get inventory name
return null;
}
@Override
public boolean hasCustomInventoryName() {
return false;
}
@Override
public void openInventory() {}
@Override
public void closeInventory() {}
}