net.minecraft.entity.MoverType Java Examples

private void updateMovement()
{
    if (this.hasNoGravity() == false)
    {
        this.motionY -= 0.04D;
    }

    this.prevPosX = this.posX;
    this.prevPosY = this.posY;
    this.prevPosZ = this.posZ;

    this.move(MoverType.SELF, this.motionX, this.motionY, this.motionZ);

    this.motionX *= 0.98D;
    this.motionY *= 0.98D;
    this.motionZ *= 0.98D;
}
 

void updateTranslation(double deltaTime) {
	//Integrate velocity to displacement
	Vector3D displacement = velocity().scalarMultiply(deltaTime);
	mcEntity().move(MoverType.SELF, displacement.getX(), displacement.getY(), displacement.getZ());

	//Integrate netForce to velocity
	setVelocity(velocity().add(netForce.scalarMultiply(1 / mass()).scalarMultiply(deltaTime)));

	//Clear net force
	netForce = Vector3D.ZERO;

	//Apply drag
	addForce(velocity().negate().scalarMultiply(drag()));
	if (!mcEntity().onGround) {
		//Apply gravity
		addForce(gravity().scalarMultiply(mass()));
	}
}
 

public static IntermediateMovementVariableStorage handleMove(MoverType type, double dx,
    double dy, double dz, Entity this_) {
    if (this_ instanceof PhysicsWrapperEntity) {
        //Don't move at all
        return null;
    }
    if (this_ instanceof EntityPlayer && ((EntityPlayer) this_).isSpectator()) {
        return null;
    }

    double movDistSq = (dx * dx) + (dy * dy) + (dz * dz);

    if (movDistSq > 10000) {
        // Assume this_ will take us to Ship coordinates
        double newX = this_.posX + dx;
        double newY = this_.posY + dy;
        double newZ = this_.posZ + dz;
        BlockPos newPosInBlock = new BlockPos(newX, newY, newZ);
        Optional<PhysicsObject> physicsObject = ValkyrienUtils
            .getPhysicsObject(this_.world, newPosInBlock);

        if (!physicsObject.isPresent()) {
            return null;
        }

        Vector endPos = new Vector(newX, newY, newZ);
        physicsObject.get()
            .getShipTransformationManager()
            .getCurrentTickTransform()
            .transform(endPos, TransformType.GLOBAL_TO_SUBSPACE);
        dx = endPos.X - this_.posX;
        dy = endPos.Y - this_.posY;
        dz = endPos.Z - this_.posZ;
    }

    IntermediateMovementVariableStorage alteredMovement = EntityCollisionInjector
        .alterEntityMovement(this_, type, dx, dy, dz);

    return alteredMovement;
}
 

@Override
public void onUpdate() {
	if (posY < -500.0D) {
		setDead();
		return;
	}

	if (hasGravity) {
		motionY -= 0.03999999910593033D;
	}
	if (hasAirResistance) {
		motionX *= 0.98;
		motionY *= 0.98;
		motionZ *= 0.98;
	}
	prevPosX = posX;
	prevPosY = posY;
	prevPosZ = posZ;

	extinguish();
	move(MoverType.SELF, motionX, motionY, motionZ);

	final Block block = blockState.getBlock();
	if (block == null) setDead();
	// TODO missing functionality, fix (fake world access?)
	// setHeight((float)block.getBlockBoundsMaxY());

	if (world instanceof WorldServer && shouldPlaceBlock()) {
		if (!tryPlaceBlock((WorldServer)world, getDropPos())) dropBlock();

		setDead();
	}
}
 

@Override
public void onUpdate() {
	ItemStack stack = this.getDataManager().get(ITEM);
	
       if (this.getEntityItem() == null)
       {
           this.setDead();
       }
       //super.onEntityUpdate();
       
       this.prevPosX = this.posX;
       this.prevPosY = this.posY;
       this.prevPosZ = this.posZ;
       
       this.move(MoverType.SELF,this.motionX, this.motionY, this.motionZ);

       ++this.age;

       if (!this.world.isRemote && this.age >= lifespan)
       {
       	this.setDead();
       }

       if (stack != null && stack.getCount() <= 0)
       {
           this.setDead();
       }
}
 

@Inject(method = "move", at = @At("HEAD"), cancellable = true)
public void changeMoveArgs(MoverType type, double dx, double dy, double dz,
    CallbackInfo callbackInfo) {
    if (!hasChanged) {
        alteredMovement = EntityMoveInjectionMethods
            .handleMove(type, dx, dy, dz, thisClassAsAnEntity);
        if (alteredMovement != null) {
            hasChanged = true;
            this.move(type, alteredMovement.dxyz.X, alteredMovement.dxyz.Y,
                alteredMovement.dxyz.Z);
            hasChanged = false;
            callbackInfo.cancel();
        }
    }
}
 

public EntityMoveEvent(Entity entity, MoverType type, double x, double y, double z) {
	this.entity = entity;
	this.type = type;
	this.x = x;
	this.y = y;
	this.z = z;
}
 

@SubscribeEvent
public void tickBoss(LivingEvent.LivingUpdateEvent event) {
	for (Arena arena : arenas) {
		if (event.getEntityLiving().getEntityId() != arena.getBossID()) continue;

		if (event.getEntityLiving().getDistance(arena.getCenter().getX() + 0.5, arena.getCenter().getY(), arena.getCenter().getZ() + 0.5) > arena.getRadius()) {
			event.getEntityLiving().move(MoverType.SELF, arena.getCenter().getX() + 0.5, arena.getCenter().getY() + 0.5, arena.getCenter().getZ() + 0.5);
		}
	}
}
 

public void travel(float strafe, float vertical, float forward) {
    if (this.isServerWorld() && this.isInWater()) {
        this.moveRelative(strafe, vertical, forward, 0.01F);
        this.move(MoverType.SELF, this.motionX, this.motionY, this.motionZ);
        this.motionX *= (double)0.9F;
        this.motionY *= (double)0.9F;
        this.motionZ *= (double)0.9F;
        if (this.getAttackTarget() == null) {
            this.motionY -= 0.005D;
        }
    } else {
        super.travel(strafe, vertical, forward);
    }

}
 

public static EntityMoveEvent entityPreMoveHook(Entity entity, MoverType type, double x, double y, double z) {
	EntityMoveEvent event = new EntityMoveEvent(entity, type, x, y, z);
	MinecraftForge.EVENT_BUS.post(event);
	return event;
}
 

@Override
public void onUpdate() {

    this.prevPosX = this.posX;
    this.prevPosY = this.posY;
    this.prevPosZ = this.posZ;
    if (this.hurtEntities && this.onGround) {
        this.world.spawnParticle(EnumParticleTypes.CLOUD, this.posX, this.posY, this.posZ, 0.0F, 0.0F, 0.0F);
        this.playSound(SoundEvents.BLOCK_STONE_BREAK, 1.2F, 1.0F);
        if (!this.world.isRemote) {
            this.setDead();
            return;
        }
    }
    if (this.fallTime++ == 300) {
        this.world.spawnParticle(EnumParticleTypes.CLOUD, this.posX, this.posY, this.posZ, 0.0F, 0.0F, 0.0F);
        this.playSound(SoundEvents.BLOCK_STONE_BREAK, 1.2F, 1.0F);
        if (!this.world.isRemote) {
            this.setDead();
            return;
        }
    }


    RayTraceResult raytraceresult = ProjectileHelper.forwardsRaycast(this, true, false, this.owner);

    if (raytraceresult != null && !net.minecraftforge.event.ForgeEventFactory.onProjectileImpact(this, raytraceresult)) {
        this.onImpact(raytraceresult);
        this.playSound(SoundEvents.BLOCK_STONE_BREAK, 1.2F, 1.0F);
        this.world.spawnParticle(EnumParticleTypes.CLOUD, this.posX, this.posY, this.posZ, 0.0F, 0.0F, 0.0F);
        if (!this.world.isRemote) {
            this.setDead();
        }
    }


    if (!this.hasNoGravity()) {
        if (this.onGround) {
            this.motionY = 0.0F;
        } else if (this.isInWater() || this.isInLava()) {
            this.motionY = (0.3 - this.motionY) * 0.3;
        } else {
            this.motionY -= 0.03999999910593033D;
        }
    }

    this.move(MoverType.SELF, this.motionX, this.motionY, this.motionZ);

    this.motionX *= 0.9800000190734863D;
    this.motionY *= 0.9800000190734863D;
    this.motionZ *= 0.9800000190734863D;
}
 

@Shadow
public abstract void move(MoverType type, double x, double y, double z);
 

@Shadow
public abstract void move(MoverType type, double x, double y, double z);
 

public void setMoverType(MoverType moverType) {
    this.moverType = moverType;
}
 

public MoverType getMoverType() {
    return moverType;
}
 

public EventMove(MoverType moverType, double x, double y, double z) {
    this.moverType = moverType;
    this.x = x;
    this.y = y;
    this.z = z;
}
 

void move(MoverType type, double dx, double dy, double dz);