mirror of
https://github.com/PaperMC/Paper.git
synced 2025-08-09 08:32:07 -07:00
Adding all Entities into CraftBukkit.
These are needed to properly allow for determining class type, in accordance with current practice.
This commit is contained in:
Andrew Ardill
committed by
Dinner Bone
Dinner Bone
parent
5f2c8108b7
commit
5209e17e1b
723
src/main/java/net/minecraft/server/EntityLiving.java
Normal file
723
src/main/java/net/minecraft/server/EntityLiving.java
Normal file
@@ -0,0 +1,723 @@
|
||||
package net.minecraft.server;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
|
||||
public abstract class EntityLiving extends Entity {
|
||||
|
||||
public int aF;
|
||||
public float aG;
|
||||
public float aH;
|
||||
public float aI;
|
||||
public float aJ;
|
||||
protected float aK;
|
||||
protected float aL;
|
||||
protected float aM;
|
||||
protected float aN;
|
||||
protected boolean aO;
|
||||
protected String aP;
|
||||
protected boolean aQ;
|
||||
protected float aR;
|
||||
protected String aS;
|
||||
protected float aT;
|
||||
protected int aU;
|
||||
protected float aV;
|
||||
public boolean aW;
|
||||
public float aX;
|
||||
public float aY;
|
||||
public int aZ;
|
||||
public int ba;
|
||||
private int a;
|
||||
public int bb;
|
||||
public int bc;
|
||||
public float bd;
|
||||
public int be;
|
||||
public int bf;
|
||||
public float bg;
|
||||
public float bh;
|
||||
protected boolean bi;
|
||||
public int bj;
|
||||
public float bk;
|
||||
public float bl;
|
||||
public float bm;
|
||||
public float bn;
|
||||
protected int bo;
|
||||
protected double bp;
|
||||
protected double bq;
|
||||
protected double br;
|
||||
protected double bs;
|
||||
protected double bt;
|
||||
float bu;
|
||||
protected int bv;
|
||||
protected int bw;
|
||||
protected float bx;
|
||||
protected float by;
|
||||
protected float bz;
|
||||
protected boolean bA;
|
||||
protected float bB;
|
||||
protected float bC;
|
||||
private Entity b;
|
||||
private int c;
|
||||
|
||||
public EntityLiving(World world) {
|
||||
super(world);
|
||||
aF = 20;
|
||||
aI = 0.0F;
|
||||
aJ = 0.0F;
|
||||
aO = true;
|
||||
aP = "/mob/char.png";
|
||||
aQ = true;
|
||||
aR = 0.0F;
|
||||
aS = null;
|
||||
aT = 1.0F;
|
||||
aU = 0;
|
||||
aV = 0.0F;
|
||||
aW = false;
|
||||
bd = 0.0F;
|
||||
be = 0;
|
||||
bf = 0;
|
||||
bi = false;
|
||||
bj = -1;
|
||||
bk = (float) (Math.random() * 0.89999997615814209D + 0.10000000149011612D);
|
||||
bu = 0.0F;
|
||||
bv = 0;
|
||||
bw = 0;
|
||||
bA = false;
|
||||
bB = 0.0F;
|
||||
bC = 0.7F;
|
||||
c = 0;
|
||||
aZ = 10;
|
||||
i = true;
|
||||
aH = (float) (Math.random() + 1.0D) * 0.01F;
|
||||
a(p, q, r);
|
||||
aG = (float) Math.random() * 12398F;
|
||||
v = (float) (Math.random() * 3.1415927410125732D * 2D);
|
||||
S = 0.5F;
|
||||
}
|
||||
|
||||
protected void a() {}
|
||||
|
||||
public boolean i(Entity entity) {
|
||||
return l.a(Vec3D.b(p, q + (double) w(), r), Vec3D.b(entity.p, entity.q + (double) entity.w(), entity.r)) == null;
|
||||
}
|
||||
|
||||
public boolean c_() {
|
||||
return !G;
|
||||
}
|
||||
|
||||
public boolean z() {
|
||||
return !G;
|
||||
}
|
||||
|
||||
public float w() {
|
||||
return J * 0.85F;
|
||||
}
|
||||
|
||||
public int c() {
|
||||
return 80;
|
||||
}
|
||||
|
||||
public void r() {
|
||||
aX = aY;
|
||||
super.r();
|
||||
if (W.nextInt(1000) < a++) {
|
||||
a = -c();
|
||||
String s = e();
|
||||
|
||||
if (s != null) {
|
||||
this.l.a(((Entity) (this)), s, i(), (W.nextFloat() - W.nextFloat()) * 0.2F + 1.0F);
|
||||
}
|
||||
}
|
||||
if (B() && C()) {
|
||||
a(((Entity) (null)), 1);
|
||||
}
|
||||
if (ae || this.l.z) {
|
||||
Z = 0;
|
||||
}
|
||||
if (B() && a(Material.f) && !d_()) {
|
||||
ad--;
|
||||
if (ad == -20) {
|
||||
ad = 0;
|
||||
for (int k = 0; k < 8; k++) {
|
||||
float f1 = W.nextFloat() - W.nextFloat();
|
||||
float f2 = W.nextFloat() - W.nextFloat();
|
||||
float f3 = W.nextFloat() - W.nextFloat();
|
||||
|
||||
this.l.a("bubble", p + (double) f1, q + (double) f2, r + (double) f3, this.s, t, u);
|
||||
}
|
||||
|
||||
a(((Entity) (null)), 2);
|
||||
}
|
||||
Z = 0;
|
||||
} else {
|
||||
ad = aa;
|
||||
}
|
||||
bg = bh;
|
||||
if (bf > 0) {
|
||||
bf--;
|
||||
}
|
||||
if (bb > 0) {
|
||||
bb--;
|
||||
}
|
||||
if (ac > 0) {
|
||||
ac--;
|
||||
}
|
||||
if (aZ <= 0) {
|
||||
be++;
|
||||
if (be > 20) {
|
||||
T();
|
||||
q();
|
||||
for (int l = 0; l < 20; l++) {
|
||||
double d1 = W.nextGaussian() * 0.02D;
|
||||
double d2 = W.nextGaussian() * 0.02D;
|
||||
double d3 = W.nextGaussian() * 0.02D;
|
||||
|
||||
this.l.a("explode", (p + (double) (W.nextFloat() * I * 2.0F)) - (double) I, q + (double) (W.nextFloat() * J), (r + (double) (W.nextFloat() * I * 2.0F)) - (double) I, d1, d2, d3);
|
||||
}
|
||||
}
|
||||
}
|
||||
aN = aM;
|
||||
aJ = aI;
|
||||
x = v;
|
||||
y = w;
|
||||
}
|
||||
|
||||
public void R() {
|
||||
for (int k = 0; k < 20; k++) {
|
||||
double d1 = W.nextGaussian() * 0.02D;
|
||||
double d2 = W.nextGaussian() * 0.02D;
|
||||
double d3 = W.nextGaussian() * 0.02D;
|
||||
double d4 = 10D;
|
||||
|
||||
l.a("explode", (p + (double) (W.nextFloat() * I * 2.0F)) - (double) I - d1 * d4, (q + (double) (W.nextFloat() * J)) - d2 * d4, (r + (double) (W.nextFloat() * I * 2.0F)) - (double) I - d3 * d4, d1, d2, d3);
|
||||
}
|
||||
}
|
||||
|
||||
public void D() {
|
||||
super.D();
|
||||
aK = aL;
|
||||
aL = 0.0F;
|
||||
}
|
||||
|
||||
public void b_() {
|
||||
super.b_();
|
||||
o();
|
||||
double d1 = p - m;
|
||||
double d2 = r - o;
|
||||
float f1 = MathHelper.a(d1 * d1 + d2 * d2);
|
||||
float f2 = aI;
|
||||
float f3 = 0.0F;
|
||||
|
||||
aK = aL;
|
||||
float f4 = 0.0F;
|
||||
|
||||
if (f1 > 0.05F) {
|
||||
f4 = 1.0F;
|
||||
f3 = f1 * 3F;
|
||||
f2 = ((float) Math.atan2(d2, d1) * 180F) / 3.141593F - 90F;
|
||||
}
|
||||
if (aY > 0.0F) {
|
||||
f2 = v;
|
||||
}
|
||||
if (!A) {
|
||||
f4 = 0.0F;
|
||||
}
|
||||
aL = aL + (f4 - aL) * 0.3F;
|
||||
float f5;
|
||||
|
||||
for (f5 = f2 - aI; f5 < -180F; f5 += 360F) {
|
||||
;
|
||||
}
|
||||
for (; f5 >= 180F; f5 -= 360F) {
|
||||
;
|
||||
}
|
||||
aI += f5 * 0.3F;
|
||||
float f6;
|
||||
|
||||
for (f6 = v - aI; f6 < -180F; f6 += 360F) {
|
||||
;
|
||||
}
|
||||
for (; f6 >= 180F; f6 -= 360F) {
|
||||
;
|
||||
}
|
||||
boolean flag = f6 < -90F || f6 >= 90F;
|
||||
|
||||
if (f6 < -75F) {
|
||||
f6 = -75F;
|
||||
}
|
||||
if (f6 >= 75F) {
|
||||
f6 = 75F;
|
||||
}
|
||||
aI = v - f6;
|
||||
if (f6 * f6 > 2500F) {
|
||||
aI += f6 * 0.2F;
|
||||
}
|
||||
if (flag) {
|
||||
f3 *= -1F;
|
||||
}
|
||||
for (; v - x < -180F; x -= 360F) {
|
||||
;
|
||||
}
|
||||
for (; v - x >= 180F; x += 360F) {
|
||||
;
|
||||
}
|
||||
for (; aI - aJ < -180F; aJ -= 360F) {
|
||||
;
|
||||
}
|
||||
for (; aI - aJ >= 180F; aJ += 360F) {
|
||||
;
|
||||
}
|
||||
for (; w - y < -180F; y -= 360F) {
|
||||
;
|
||||
}
|
||||
for (; w - y >= 180F; y += 360F) {
|
||||
;
|
||||
}
|
||||
aM += f3;
|
||||
}
|
||||
|
||||
protected void a(float f1, float f2) {
|
||||
super.a(f1, f2);
|
||||
}
|
||||
|
||||
public void d(int k) {
|
||||
if (aZ <= 0) {
|
||||
return;
|
||||
}
|
||||
aZ += k;
|
||||
if (aZ > 20) {
|
||||
aZ = 20;
|
||||
}
|
||||
ac = aF / 2;
|
||||
}
|
||||
|
||||
public boolean a(Entity entity, int k) {
|
||||
if (l.z) {
|
||||
return false;
|
||||
}
|
||||
bw = 0;
|
||||
if (aZ <= 0) {
|
||||
return false;
|
||||
}
|
||||
bm = 1.5F;
|
||||
boolean flag = true;
|
||||
|
||||
if ((float) ac > (float) aF / 2.0F) {
|
||||
if (k <= bv) {
|
||||
return false;
|
||||
}
|
||||
e(k - bv);
|
||||
bv = k;
|
||||
flag = false;
|
||||
} else {
|
||||
bv = k;
|
||||
ba = aZ;
|
||||
ac = aF;
|
||||
e(k);
|
||||
bb = bc = 10;
|
||||
}
|
||||
bd = 0.0F;
|
||||
if (flag) {
|
||||
l.a(((Entity) (this)), (byte) 2);
|
||||
y();
|
||||
if (entity != null) {
|
||||
double d1 = entity.p - p;
|
||||
double d2;
|
||||
|
||||
for (d2 = entity.r - r; d1 * d1 + d2 * d2 < 0.0001D; d2 = (Math.random() - Math.random()) * 0.01D) {
|
||||
d1 = (Math.random() - Math.random()) * 0.01D;
|
||||
}
|
||||
|
||||
bd = (float) ((Math.atan2(d2, d1) * 180D) / 3.1415927410125732D) - v;
|
||||
a(entity, k, d1, d2);
|
||||
} else {
|
||||
bd = (int) (Math.random() * 2D) * 180;
|
||||
}
|
||||
}
|
||||
if (aZ <= 0) {
|
||||
if (flag) {
|
||||
l.a(((Entity) (this)), g(), i(), (W.nextFloat() - W.nextFloat()) * 0.2F + 1.0F);
|
||||
}
|
||||
f(entity);
|
||||
} else if (flag) {
|
||||
l.a(((Entity) (this)), f(), i(), (W.nextFloat() - W.nextFloat()) * 0.2F + 1.0F);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
protected void e(int k) {
|
||||
aZ -= k;
|
||||
}
|
||||
|
||||
protected float i() {
|
||||
return 1.0F;
|
||||
}
|
||||
|
||||
protected String e() {
|
||||
return null;
|
||||
}
|
||||
|
||||
protected String f() {
|
||||
return "random.hurt";
|
||||
}
|
||||
|
||||
protected String g() {
|
||||
return "random.hurt";
|
||||
}
|
||||
|
||||
public void a(Entity entity, int k, double d1, double d2) {
|
||||
float f1 = MathHelper.a(d1 * d1 + d2 * d2);
|
||||
float f2 = 0.4F;
|
||||
|
||||
s /= 2D;
|
||||
t /= 2D;
|
||||
u /= 2D;
|
||||
s -= (d1 / (double) f1) * (double) f2;
|
||||
t += 0.40000000596046448D;
|
||||
u -= (d2 / (double) f1) * (double) f2;
|
||||
if (t > 0.40000000596046448D) {
|
||||
t = 0.40000000596046448D;
|
||||
}
|
||||
}
|
||||
|
||||
public void f(Entity entity) {
|
||||
if (aU > 0 && entity != null) {
|
||||
entity.b(((Entity) (this)), aU);
|
||||
}
|
||||
bi = true;
|
||||
if (!l.z) {
|
||||
g_();
|
||||
}
|
||||
l.a(((Entity) (this)), (byte) 3);
|
||||
}
|
||||
|
||||
protected void g_() {
|
||||
int k = h();
|
||||
|
||||
if (k > 0) {
|
||||
int l = W.nextInt(3);
|
||||
|
||||
for (int i1 = 0; i1 < l; i1++) {
|
||||
a(k, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected int h() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
protected void a(float f1) {
|
||||
int k = (int) Math.ceil(f1 - 3F);
|
||||
|
||||
if (k > 0) {
|
||||
a(((Entity) (null)), k);
|
||||
int l = this.l.a(MathHelper.b(p), MathHelper.b(q - 0.20000000298023224D - (double) H), MathHelper.b(r));
|
||||
|
||||
if (l > 0) {
|
||||
StepSound stepsound = Block.m[l].br;
|
||||
|
||||
this.l.a(((Entity) (this)), stepsound.c(), stepsound.a() * 0.5F, stepsound.b() * 0.75F);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void c(float f1, float f2) {
|
||||
if (v()) {
|
||||
double d1 = q;
|
||||
|
||||
a(f1, f2, 0.02F);
|
||||
c(s, t, u);
|
||||
s *= 0.80000001192092896D;
|
||||
t *= 0.80000001192092896D;
|
||||
u *= 0.80000001192092896D;
|
||||
t -= 0.02D;
|
||||
if (B && b(s, ((t + 0.60000002384185791D) - q) + d1, u)) {
|
||||
t = 0.30000001192092896D;
|
||||
}
|
||||
} else if (x()) {
|
||||
double d2 = q;
|
||||
|
||||
a(f1, f2, 0.02F);
|
||||
c(s, t, u);
|
||||
s *= 0.5D;
|
||||
t *= 0.5D;
|
||||
u *= 0.5D;
|
||||
t -= 0.02D;
|
||||
if (B && b(s, ((t + 0.60000002384185791D) - q) + d2, u)) {
|
||||
t = 0.30000001192092896D;
|
||||
}
|
||||
} else {
|
||||
float f3 = 0.91F;
|
||||
|
||||
if (A) {
|
||||
f3 = 0.5460001F;
|
||||
int k = this.l.a(MathHelper.b(p), MathHelper.b(z.b) - 1, MathHelper.b(r));
|
||||
|
||||
if (k > 0) {
|
||||
f3 = Block.m[k].bu * 0.91F;
|
||||
}
|
||||
}
|
||||
float f4 = 0.1627714F / (f3 * f3 * f3);
|
||||
|
||||
a(f1, f2, A ? 0.1F * f4 : 0.02F);
|
||||
f3 = 0.91F;
|
||||
if (A) {
|
||||
f3 = 0.5460001F;
|
||||
int l = this.l.a(MathHelper.b(p), MathHelper.b(z.b) - 1, MathHelper.b(r));
|
||||
|
||||
if (l > 0) {
|
||||
f3 = Block.m[l].bu * 0.91F;
|
||||
}
|
||||
}
|
||||
if (m()) {
|
||||
N = 0.0F;
|
||||
if (t < -0.14999999999999999D) {
|
||||
t = -0.14999999999999999D;
|
||||
}
|
||||
}
|
||||
c(s, t, u);
|
||||
if (B && m()) {
|
||||
t = 0.20000000000000001D;
|
||||
}
|
||||
t -= 0.080000000000000002D;
|
||||
t *= 0.98000001907348633D;
|
||||
s *= f3;
|
||||
u *= f3;
|
||||
}
|
||||
bl = bm;
|
||||
double d3 = p - m;
|
||||
double d4 = r - o;
|
||||
float f5 = MathHelper.a(d3 * d3 + d4 * d4) * 4F;
|
||||
|
||||
if (f5 > 1.0F) {
|
||||
f5 = 1.0F;
|
||||
}
|
||||
bm += (f5 - bm) * 0.4F;
|
||||
bn += bm;
|
||||
}
|
||||
|
||||
public boolean m() {
|
||||
int k = MathHelper.b(p);
|
||||
int l = MathHelper.b(z.b);
|
||||
int i1 = MathHelper.b(r);
|
||||
|
||||
return this.l.a(k, l, i1) == Block.aF.bi || this.l.a(k, l + 1, i1) == Block.aF.bi;
|
||||
}
|
||||
|
||||
public void a(NBTTagCompound nbttagcompound) {
|
||||
nbttagcompound.a("Health", (short) aZ);
|
||||
nbttagcompound.a("HurtTime", (short) bb);
|
||||
nbttagcompound.a("DeathTime", (short) be);
|
||||
nbttagcompound.a("AttackTime", (short) bf);
|
||||
}
|
||||
|
||||
public void b(NBTTagCompound nbttagcompound) {
|
||||
aZ = ((int) (nbttagcompound.c("Health")));
|
||||
if (!nbttagcompound.a("Health")) {
|
||||
aZ = 10;
|
||||
}
|
||||
bb = ((int) (nbttagcompound.c("HurtTime")));
|
||||
be = ((int) (nbttagcompound.c("DeathTime")));
|
||||
bf = ((int) (nbttagcompound.c("AttackTime")));
|
||||
}
|
||||
|
||||
public boolean B() {
|
||||
return !G && aZ > 0;
|
||||
}
|
||||
|
||||
public boolean d_() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public void o() {
|
||||
if (bo > 0) {
|
||||
double d1 = p + (bp - p) / (double) bo;
|
||||
double d2 = q + (bq - q) / (double) bo;
|
||||
double d3 = r + (br - r) / (double) bo;
|
||||
double d4;
|
||||
|
||||
for (d4 = bs - (double) v; d4 < -180D; d4 += 360D) {
|
||||
;
|
||||
}
|
||||
for (; d4 >= 180D; d4 -= 360D) {
|
||||
;
|
||||
}
|
||||
v += ((float) (d4 / (double) bo));
|
||||
w += ((float) ((bt - (double) w) / (double) bo));
|
||||
bo--;
|
||||
a(d1, d2, d3);
|
||||
b(v, w);
|
||||
}
|
||||
if (aZ <= 0) {
|
||||
bA = false;
|
||||
bx = 0.0F;
|
||||
by = 0.0F;
|
||||
bz = 0.0F;
|
||||
} else if (!aW) {
|
||||
d();
|
||||
}
|
||||
boolean flag = v();
|
||||
boolean flag1 = x();
|
||||
|
||||
if (bA) {
|
||||
if (flag) {
|
||||
t += 0.039999999105930328D;
|
||||
} else if (flag1) {
|
||||
t += 0.039999999105930328D;
|
||||
} else if (A) {
|
||||
S();
|
||||
}
|
||||
}
|
||||
bx *= 0.98F;
|
||||
by *= 0.98F;
|
||||
bz *= 0.9F;
|
||||
c(bx, by);
|
||||
List list = l.b(((Entity) (this)), z.b(0.20000000298023224D, 0.0D, 0.20000000298023224D));
|
||||
|
||||
if (list != null && list.size() > 0) {
|
||||
for (int k = 0; k < list.size(); k++) {
|
||||
Entity entity = (Entity) list.get(k);
|
||||
|
||||
if (entity.z()) {
|
||||
entity.c(((Entity) (this)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void S() {
|
||||
t = 0.41999998688697815D;
|
||||
}
|
||||
|
||||
protected void d() {
|
||||
bw++;
|
||||
EntityPlayer entityplayer = l.a(((Entity) (this)), -1D);
|
||||
|
||||
if (entityplayer != null) {
|
||||
double d1 = ((Entity) (entityplayer)).p - p;
|
||||
double d2 = ((Entity) (entityplayer)).q - q;
|
||||
double d3 = ((Entity) (entityplayer)).r - r;
|
||||
double d4 = d1 * d1 + d2 * d2 + d3 * d3;
|
||||
|
||||
if (d4 > 16384D) {
|
||||
q();
|
||||
}
|
||||
if (bw > 600 && W.nextInt(800) == 0) {
|
||||
if (d4 < 1024D) {
|
||||
bw = 0;
|
||||
} else {
|
||||
q();
|
||||
}
|
||||
}
|
||||
}
|
||||
bx = 0.0F;
|
||||
by = 0.0F;
|
||||
float f1 = 8F;
|
||||
|
||||
if (W.nextFloat() < 0.02F) {
|
||||
EntityPlayer entityplayer1 = l.a(((Entity) (this)), f1);
|
||||
|
||||
if (entityplayer1 != null) {
|
||||
b = ((Entity) (entityplayer1));
|
||||
c = 10 + W.nextInt(20);
|
||||
} else {
|
||||
bz = (W.nextFloat() - 0.5F) * 20F;
|
||||
}
|
||||
}
|
||||
if (b != null) {
|
||||
b(b, 10F);
|
||||
if (c-- <= 0 || b.G || b.b(((Entity) (this))) > (double) (f1 * f1)) {
|
||||
b = null;
|
||||
}
|
||||
} else {
|
||||
if (W.nextFloat() < 0.05F) {
|
||||
bz = (W.nextFloat() - 0.5F) * 20F;
|
||||
}
|
||||
v += bz;
|
||||
w = bB;
|
||||
}
|
||||
boolean flag = v();
|
||||
boolean flag1 = x();
|
||||
|
||||
if (flag || flag1) {
|
||||
bA = W.nextFloat() < 0.8F;
|
||||
}
|
||||
}
|
||||
|
||||
public void b(Entity entity, float f1) {
|
||||
double d1 = entity.p - p;
|
||||
double d2 = entity.r - r;
|
||||
double d3;
|
||||
|
||||
if (entity instanceof EntityLiving) {
|
||||
EntityLiving entityliving = (EntityLiving) entity;
|
||||
|
||||
d3 = (entityliving.q + (double) entityliving.w()) - (q + (double) w());
|
||||
} else {
|
||||
d3 = (entity.z.b + entity.z.e) / 2D - (q + (double) w());
|
||||
}
|
||||
double d4 = MathHelper.a(d1 * d1 + d2 * d2);
|
||||
float f2 = (float) ((Math.atan2(d2, d1) * 180D) / 3.1415927410125732D) - 90F;
|
||||
float f3 = (float) ((Math.atan2(d3, d4) * 180D) / 3.1415927410125732D);
|
||||
|
||||
w = -b(w, f3, f1);
|
||||
v = b(v, f2, f1);
|
||||
}
|
||||
|
||||
private float b(float f1, float f2, float f3) {
|
||||
float f4;
|
||||
|
||||
for (f4 = f2 - f1; f4 < -180F; f4 += 360F) {
|
||||
;
|
||||
}
|
||||
for (; f4 >= 180F; f4 -= 360F) {
|
||||
;
|
||||
}
|
||||
if (f4 > f3) {
|
||||
f4 = f3;
|
||||
}
|
||||
if (f4 < -f3) {
|
||||
f4 = -f3;
|
||||
}
|
||||
return f1 + f4;
|
||||
}
|
||||
|
||||
public void T() {}
|
||||
|
||||
public boolean b() {
|
||||
return l.a(z) && l.a(((Entity) (this)), z).size() == 0 && !l.b(z);
|
||||
}
|
||||
|
||||
protected void t() {
|
||||
a(((Entity) (null)), 4);
|
||||
}
|
||||
|
||||
public Vec3D G() {
|
||||
return c(1.0F);
|
||||
}
|
||||
|
||||
public Vec3D c(float f1) {
|
||||
if (f1 == 1.0F) {
|
||||
float f2 = MathHelper.b(-v * 0.01745329F - 3.141593F);
|
||||
float f4 = MathHelper.a(-v * 0.01745329F - 3.141593F);
|
||||
float f6 = -MathHelper.b(-w * 0.01745329F);
|
||||
float f8 = MathHelper.a(-w * 0.01745329F);
|
||||
|
||||
return Vec3D.b(f4 * f6, f8, f2 * f6);
|
||||
} else {
|
||||
float f3 = y + (w - y) * f1;
|
||||
float f5 = x + (v - x) * f1;
|
||||
float f7 = MathHelper.b(-f5 * 0.01745329F - 3.141593F);
|
||||
float f9 = MathHelper.a(-f5 * 0.01745329F - 3.141593F);
|
||||
float f10 = -MathHelper.b(-f3 * 0.01745329F);
|
||||
float f11 = MathHelper.a(-f3 * 0.01745329F);
|
||||
|
||||
return Vec3D.b(f9 * f10, f11, f7 * f10);
|
||||
}
|
||||
}
|
||||
|
||||
public int j() {
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user