generated from tilera/1710mod
348 lines
12 KiB
Java
348 lines
12 KiB
Java
package icbm.gangshao.turret.sentries;
|
|
|
|
import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint;
|
|
import icbm.api.sentry.IAATarget;
|
|
import icbm.gangshao.IAmmunition;
|
|
import icbm.gangshao.IAutoSentry;
|
|
import icbm.gangshao.ICBMSentry;
|
|
import icbm.gangshao.ProjectileType;
|
|
import icbm.gangshao.damage.TileDamageSource;
|
|
import icbm.gangshao.packet.PacketTurret;
|
|
import icbm.gangshao.packet.PacketTurret.Type;
|
|
import icbm.gangshao.platform.TTurretPlatform;
|
|
import icbm.gangshao.task.TaskManager;
|
|
import icbm.gangshao.task.TaskSearchTarget;
|
|
import icbm.gangshao.turret.TTurretBase;
|
|
import icbm.gangshao.turret.upgrades.ItPaoTaiUpgrades;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityFlying;
|
|
import net.minecraft.entity.EntityLiving;
|
|
import net.minecraft.entity.IMerchant;
|
|
import net.minecraft.entity.INpc;
|
|
import net.minecraft.entity.boss.EntityDragon;
|
|
import net.minecraft.entity.boss.EntityWither;
|
|
import net.minecraft.entity.item.EntityItem;
|
|
import net.minecraft.entity.monster.IMob;
|
|
import net.minecraft.entity.passive.IAnimals;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.util.DamageSource;
|
|
import universalelectricity.core.vector.Vector3;
|
|
|
|
public abstract class TAutomaticTurret extends TTurretBase implements IAutoSentry {
|
|
public Entity target;
|
|
public boolean targetPlayers;
|
|
public boolean targetAir;
|
|
public boolean targetHostile;
|
|
public boolean targetFriendly;
|
|
public boolean canTargetAir;
|
|
public final TaskManager taskManager;
|
|
public int baseTargetRange;
|
|
public int maxTargetRange;
|
|
public float rotationSpeed;
|
|
public ProjectileType projectileType;
|
|
|
|
public TAutomaticTurret() {
|
|
this.targetPlayers = false;
|
|
this.targetAir = false;
|
|
this.targetHostile = false;
|
|
this.targetFriendly = false;
|
|
this.canTargetAir = false;
|
|
this.taskManager = new TaskManager(this);
|
|
this.baseTargetRange = 20;
|
|
this.maxTargetRange = 90;
|
|
this.rotationSpeed = 3.0f;
|
|
this.projectileType = ProjectileType.CONVENTIONAL;
|
|
}
|
|
|
|
@Override
|
|
public void onTurretPacket(Type type, NBTTagCompound data) {
|
|
super.onTurretPacket(type, data);
|
|
|
|
if (type == PacketTurret.Type.SHOT) {
|
|
Vector3 target = Vector3.readFromNBT(data.getCompoundTag("target"));
|
|
|
|
this.renderShot(target);
|
|
|
|
super.currentRotationYaw = data.getFloat("yaw");
|
|
super.currentRotationPitch = data.getFloat("pitch");
|
|
|
|
this.playFiringSound();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
super.updateEntity();
|
|
|
|
if (!this.worldObj.isRemote && this.isRunning()) {
|
|
this.taskManager.onUpdate();
|
|
|
|
if (!this.taskManager.hasTasks()) {
|
|
this.taskManager.addTask(new TaskSearchTarget());
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public float getRotationSpeed() {
|
|
return this.rotationSpeed;
|
|
}
|
|
|
|
@Override
|
|
public AxisAlignedBB getTargetingBox() {
|
|
return AxisAlignedBB.getBoundingBox(
|
|
this.xCoord - this.getDetectRange(),
|
|
(double) (this.yCoord - 5),
|
|
this.zCoord - this.getDetectRange(),
|
|
this.xCoord + this.getDetectRange(),
|
|
(double) (this.yCoord + 5),
|
|
this.zCoord + this.getDetectRange()
|
|
);
|
|
}
|
|
|
|
@Override
|
|
public Entity getTarget() {
|
|
return this.target;
|
|
}
|
|
|
|
@Override
|
|
public void setTarget(final Entity target) {
|
|
this.target = target;
|
|
}
|
|
|
|
@Override
|
|
public boolean isValidTarget(final Entity entity) {
|
|
if (entity != null && !entity.isDead && !entity.isEntityInvulnerable()
|
|
&& this.getCenter().distanceTo(new Vector3(entity))
|
|
<= this.getDetectRange()) {
|
|
final float[] rotations = super.lookHelper.getDeltaRotations(
|
|
new Vector3(entity).add(new Vector3(0.0, entity.getEyeHeight(), 0.0))
|
|
);
|
|
|
|
if (((rotations[1] <= super.maxPitch && rotations[1] >= super.minPitch)
|
|
|| super.allowFreePitch)
|
|
&& super.lookHelper.canEntityBeSeen(entity)) {
|
|
if (this.targetAir && this.canTargetAir && this.isAir(entity)) {
|
|
return true;
|
|
}
|
|
|
|
if (this.targetPlayers
|
|
&& (entity instanceof EntityPlayer
|
|
|| entity.riddenByEntity instanceof EntityPlayer)) {
|
|
EntityPlayer player;
|
|
|
|
if (entity.riddenByEntity instanceof EntityPlayer) {
|
|
player = (EntityPlayer) entity.riddenByEntity;
|
|
} else {
|
|
player = (EntityPlayer) entity;
|
|
}
|
|
|
|
if (!player.capabilities.isCreativeMode && this.getPlatform() != null
|
|
&& !this.getPlatform().canUserAccess(player.getDisplayName())) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (this.targetHostile && entity instanceof IMob && !this.isAir(entity)) {
|
|
return true;
|
|
}
|
|
|
|
if (this.targetFriendly
|
|
&& (entity instanceof IAnimals || entity instanceof INpc
|
|
|| entity instanceof IMerchant)
|
|
&& !this.isAir(entity)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected boolean isAir(final Entity entity) {
|
|
return (entity instanceof IMob && entity instanceof EntityFlying)
|
|
|| (entity instanceof IAATarget && ((IAATarget) entity).canBeTargeted(this))
|
|
|| entity instanceof EntityWither || entity instanceof EntityDragon;
|
|
}
|
|
|
|
@Override
|
|
public boolean canActivateWeapon() {
|
|
return this.isValidTarget(this.target) && this.getPlatform() != null
|
|
&& super.lookHelper.isLookingAt(this.target, 5.0f)
|
|
&& super.tickSinceFired == 0
|
|
&& this.getPlatform().wattsReceived >= this.getFiringRequest()
|
|
&& (this.getPlatform().hasAmmunition(this.projectileType) != null
|
|
|| this.projectileType == ProjectileType.UNKNOWN);
|
|
}
|
|
|
|
public void sendShotToClient(final Vector3 position) {
|
|
ICBMSentry.channel.sendToAllAround(
|
|
PacketTurret.shot(
|
|
new Vector3(this),
|
|
position,
|
|
super.currentRotationYaw,
|
|
super.currentRotationPitch
|
|
),
|
|
new TargetPoint(
|
|
this.worldObj.provider.dimensionId,
|
|
this.xCoord,
|
|
this.yCoord,
|
|
this.zCoord,
|
|
40.0
|
|
)
|
|
);
|
|
}
|
|
|
|
@Override
|
|
public void onWeaponActivated() {
|
|
super.onWeaponActivated();
|
|
|
|
if (!this.worldObj.isRemote && this.onFire()) {
|
|
this.sendShotToClient(this.getTargetPosition());
|
|
this.playFiringSound();
|
|
this.getPlatform().wattsReceived = Math.max(
|
|
this.getPlatform().wattsReceived - this.getFiringRequest(), 0.0
|
|
);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void renderShot(final Vector3 target) {
|
|
this.drawParticleStreamTo(target);
|
|
}
|
|
|
|
protected boolean onFire() {
|
|
if (!this.worldObj.isRemote) {
|
|
final ItemStack ammoStack
|
|
= this.getPlatform().hasAmmunition(this.projectileType);
|
|
|
|
if (this.getPlatform() != null && ammoStack != null) {
|
|
boolean fired = false;
|
|
final IAmmunition bullet = (IAmmunition) ammoStack.getItem();
|
|
|
|
if (this.target instanceof EntityLiving) {
|
|
final TTurretPlatform platform = this.getPlatform();
|
|
platform.wattsReceived -= this.getFiringRequest();
|
|
|
|
if (bullet.getType(ammoStack) == ProjectileType.CONVENTIONAL) {
|
|
this.target.attackEntityFrom(
|
|
(DamageSource) TileDamageSource.doBulletDamage(this),
|
|
bullet.getDamage()
|
|
);
|
|
}
|
|
|
|
fired = true;
|
|
} else if (this.target instanceof IAATarget) {
|
|
if (this.worldObj.rand.nextFloat() > 0.2) {
|
|
final int damage = ((IAATarget) this.target).doDamage(8);
|
|
|
|
if (damage == -1 && this.worldObj.rand.nextFloat() > 0.7) {
|
|
((IAATarget) this.target).destroyCraft();
|
|
} else if (damage <= 0) {
|
|
((IAATarget) this.target).destroyCraft();
|
|
}
|
|
}
|
|
|
|
fired = true;
|
|
}
|
|
|
|
if (fired && this.projectileType != ProjectileType.UNKNOWN
|
|
&& this.getPlatform().useAmmunition(ammoStack)) {
|
|
boolean drop = true;
|
|
|
|
if (this.getPlatform().getUpgradeCount(
|
|
ItPaoTaiUpgrades.TurretUpgradeType.COLLECTOR
|
|
) > 0
|
|
&& this.getPlatform().addStackToInventory(
|
|
ICBMSentry.bulletShell.copy()
|
|
)) {
|
|
drop = false;
|
|
}
|
|
|
|
if (drop && this.worldObj.rand.nextFloat() < 0.9) {
|
|
final Vector3 spawnPos = this.getMuzzle();
|
|
final EntityItem entityShell = new EntityItem(
|
|
this.worldObj,
|
|
spawnPos.x,
|
|
spawnPos.y,
|
|
spawnPos.z,
|
|
ICBMSentry.bulletShell.copy()
|
|
);
|
|
entityShell.delayBeforeCanPickup = 20;
|
|
this.worldObj.spawnEntityInWorld((Entity) entityShell);
|
|
}
|
|
}
|
|
|
|
return fired;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(final NBTTagCompound nbt) {
|
|
super.writeToNBT(nbt);
|
|
nbt.setBoolean("targetPlayers", this.targetPlayers);
|
|
nbt.setBoolean("targetAir", this.targetAir);
|
|
nbt.setBoolean("targetHostile", this.targetHostile);
|
|
nbt.setBoolean("targetFriendly", this.targetFriendly);
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(final NBTTagCompound nbt) {
|
|
super.readFromNBT(nbt);
|
|
|
|
if (nbt.hasKey("targetPlayers")) {
|
|
this.targetPlayers = nbt.getBoolean("targetPlayers");
|
|
}
|
|
|
|
if (nbt.hasKey("targetAir")) {
|
|
this.targetAir = nbt.getBoolean("targetAir");
|
|
}
|
|
|
|
if (nbt.hasKey("targetHostile")) {
|
|
this.targetHostile = nbt.getBoolean("targetHostile");
|
|
}
|
|
|
|
if (nbt.hasKey("targetFriendly")) {
|
|
this.targetFriendly = nbt.getBoolean("targetFriendly");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public double getDetectRange() {
|
|
if (this.getPlatform() != null) {
|
|
return Math.min(
|
|
this.baseTargetRange
|
|
+ (this.maxTargetRange - this.baseTargetRange)
|
|
* (this.getPlatform().getUpgradeCount(
|
|
ItPaoTaiUpgrades.TurretUpgradeType.RANGE
|
|
)
|
|
/ 64.0f),
|
|
(float) this.maxTargetRange
|
|
);
|
|
}
|
|
|
|
return this.baseTargetRange;
|
|
}
|
|
|
|
@Override
|
|
public boolean canApplyPotion(final PotionEffect par1PotionEffect) {
|
|
return false;
|
|
}
|
|
|
|
public Vector3 getTargetPosition() {
|
|
if (this.getTarget() != null) {
|
|
return new Vector3(this.getTarget())
|
|
.add(new Vector3(0.0, this.getTarget().getEyeHeight(), 0.0));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|