BLOCKFANTASY
/
LimboService
forked from BLOCKFANTASY/LOOHP-Limbo
1
0
Fork 0
Code Pull Requests Activity

Ignore empty console commands, added other stuff for future updates

This commit is contained in:
LOOHP 2020-08-14 18:54:32 +08:00
parent 59b68a6bf8
commit aa969cc821
19 changed files with 1632 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
pom.xml
View File

@ -89,6 +89,12 @@
<artifactId>bungeecord-chat</artifactId>
<version>1.16-R0.3</version>
</dependency>
<dependency>
<groupId>jline</groupId>
<artifactId>jline</artifactId>
<version>2.6</version>
<scope>compile</scope>
</dependency>
</dependencies>
<properties>

7
src/com/loohp/limbo/Console.java
View File

@ -88,8 +88,11 @@ public class Console implements CommandSender {
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
while (true) {
try {
String[] input = CustomStringUtils.splitStringToArgs(reader.readLine());
Limbo.getInstance().dispatchCommand(this, input);
String command = reader.readLine();
if (command.length() > 0) {
String[] input = CustomStringUtils.splitStringToArgs(command);
Limbo.getInstance().dispatchCommand(this, input);
}
} catch (IOException e) {
e.printStackTrace();
}

21
src/com/loohp/limbo/Limbo.java
View File

@ -47,9 +47,10 @@ import com.loohp.limbo.Server.Packets.PacketOut;
import com.loohp.limbo.Utils.CustomStringUtils;
import com.loohp.limbo.Utils.ImageUtils;
import com.loohp.limbo.Utils.NetworkUtils;
import com.loohp.limbo.World.DimensionRegistry;
import com.loohp.limbo.World.Environment;
import com.loohp.limbo.World.Schematic;
import com.loohp.limbo.World.World;
import com.loohp.limbo.World.World.Environment;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.chat.ComponentSerializer;
@ -115,8 +116,13 @@ public class Limbo {
private File internalDataFolder;
private DimensionRegistry dimensionRegistry;
public AtomicInteger entityIdCount = new AtomicInteger();
@SuppressWarnings("deprecation")
private Unsafe unsafe = new Unsafe();
@SuppressWarnings("unchecked")
public Limbo() throws IOException, ParseException, NumberFormatException, ClassNotFoundException, InterruptedException {
instance = this;
@ -227,6 +233,8 @@ public class Limbo {
console.sendMessage("Loaded all " + mappingsCount + " packet id mappings!");
dimensionRegistry = new DimensionRegistry();
worlds.add(loadDefaultWorld());
Location spawn = properties.getWorldSpawn();
properties.setWorldSpawn(new Location(getWorld(properties.getLevelName().getKey()), spawn.getX(), spawn.getY(), spawn.getZ(), spawn.getYaw(), spawn.getPitch()));
@ -278,6 +286,15 @@ public class Limbo {
console.run();
}
@Deprecated
public Unsafe getUnsafe() {
return unsafe;
}
public DimensionRegistry getDimensionRegistry() {
return dimensionRegistry;
}
public String getServerImplementationVersion() {
return serverImplementationVersion;
}
@ -434,6 +451,8 @@ public class Limbo {
e.printStackTrace();
}
}
console.sendMessage("Server closed");
console.logs.close();
System.exit(0);
}

425
src/com/loohp/limbo/Location/Location.java
View File

@ -1,8 +1,11 @@
package com.loohp.limbo.Location;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.Utils.NumberConversions;
import com.loohp.limbo.World.BlockState;
import com.loohp.limbo.World.World;
public class Location {
public class Location implements Cloneable {
World world;
double x;
@ -26,7 +29,23 @@ public class Location {
@Override
public Location clone() {
return new Location(this.world, this.x, this.y, this.z, this.yaw, this.pitch);
try {
return (Location) super.clone();
} catch (CloneNotSupportedException e) {
throw new Error(e);
}
}
public BlockState getBlockState() {
return world.getBlock((int) x,(int) y,(int) z);
}
public void setBlockState(BlockState state) {
world.setBlock((int) x, (int) y, (int) z, state);
}
public boolean isWorldLoaded() {
return Limbo.getInstance().getWorld(world.getName()) != null;
}
public World getWorld() {
@ -77,53 +96,373 @@ public class Location {
this.pitch = pitch;
}
/**
* Gets a unit-vector pointing in the direction that this Location is
* facing.
*
* @return a vector pointing the direction of this location's {@link
* #getPitch() pitch} and {@link #getYaw() yaw}
*/
public Vector getDirection() {
Vector vector = new Vector();
double rotX = this.getYaw();
double rotY = this.getPitch();
vector.setY(-Math.sin(Math.toRadians(rotY)));
double xz = Math.cos(Math.toRadians(rotY));
vector.setX(-xz * Math.sin(Math.toRadians(rotX)));
vector.setZ(xz * Math.cos(Math.toRadians(rotX)));
return vector;
}
/**
* Sets the {@link #getYaw() yaw} and {@link #getPitch() pitch} to point
* in the direction of the vector.
*
* @param vector the direction vector
* @return the same location
*/
public Location setDirection(Vector vector) {
/*
* Sin = Opp / Hyp
* Cos = Adj / Hyp
* Tan = Opp / Adj
*
* x = -Opp
* z = Adj
*/
final double _2PI = 2 * Math.PI;
final double x = vector.getX();
final double z = vector.getZ();
if (x == 0 && z == 0) {
pitch = vector.getY() > 0 ? -90 : 90;
return this;
}
double theta = Math.atan2(-x, z);
yaw = (float) Math.toDegrees((theta + _2PI) % _2PI);
double x2 = NumberConversions.square(x);
double z2 = NumberConversions.square(z);
double xz = Math.sqrt(x2 + z2);
pitch = (float) Math.toDegrees(Math.atan(-vector.getY() / xz));
return this;
}
/**
* Adds the location by another.
*
* @see Vector
* @param vec The other location
* @return the same location
* @throws IllegalArgumentException for differing worlds
*/
public Location add(Location vec) {
if (vec == null || vec.getWorld() != getWorld()) {
throw new IllegalArgumentException("Cannot add Locations of differing worlds");
}
x += vec.x;
y += vec.y;
z += vec.z;
return this;
}
/**
* Adds the location by a vector.
*
* @see Vector
* @param vec Vector to use
* @return the same location
*/
public Location add(Vector vec) {
this.x += vec.getX();
this.y += vec.getY();
this.z += vec.getZ();
return this;
}
/**
* Adds the location by another. Not world-aware.
*
* @see Vector
* @param x X coordinate
* @param y Y coordinate
* @param z Z coordinate
* @return the same location
*/
public Location add(double x, double y, double z) {
this.x += x;
this.y += y;
this.z += z;
return this;
}
/**
* Subtracts the location by another.
*
* @see Vector
* @param vec The other location
* @return the same location
* @throws IllegalArgumentException for differing worlds
*/
public Location subtract(Location vec) {
if (vec == null || vec.getWorld() != getWorld()) {
throw new IllegalArgumentException("Cannot add Locations of differing worlds");
}
x -= vec.x;
y -= vec.y;
z -= vec.z;
return this;
}
/**
* Subtracts the location by a vector.
*
* @see Vector
* @param vec The vector to use
* @return the same location
*/
public Location subtract(Vector vec) {
this.x -= vec.getX();
this.y -= vec.getY();
this.z -= vec.getZ();
return this;
}
/**
* Subtracts the location by another. Not world-aware and
* orientation independent.
*
* @see Vector
* @param x X coordinate
* @param y Y coordinate
* @param z Z coordinate
* @return the same location
*/
public Location subtract(double x, double y, double z) {
this.x -= x;
this.y -= y;
this.z -= z;
return this;
}
/**
* Gets the magnitude of the location, defined as sqrt(x^2+y^2+z^2). The
* value of this method is not cached and uses a costly square-root
* function, so do not repeatedly call this method to get the location's
* magnitude. NaN will be returned if the inner result of the sqrt()
* function overflows, which will be caused if the length is too long. Not
* world-aware and orientation independent.
*
* @return the magnitude
* @see Vector
*/
public double length() {
return Math.sqrt(NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z));
}
/**
* Gets the magnitude of the location squared. Not world-aware and
* orientation independent.
*
* @return the magnitude
* @see Vector
*/
public double lengthSquared() {
return NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z);
}
/**
* Get the distance between this location and another. The value of this
* method is not cached and uses a costly square-root function, so do not
* repeatedly call this method to get the location's magnitude. NaN will
* be returned if the inner result of the sqrt() function overflows, which
* will be caused if the distance is too long.
*
* @param o The other location
* @return the distance
* @throws IllegalArgumentException for differing worlds
* @see Vector
*/
public double distance(Location o) {
return Math.sqrt(distanceSquared(o));
}
/**
* Get the squared distance between this location and another.
*
* @param o The other location
* @return the distance
* @throws IllegalArgumentException for differing worlds
* @see Vector
*/
public double distanceSquared(Location o) {
if (o == null) {
throw new IllegalArgumentException("Cannot measure distance to a null location");
} else if (o.getWorld() == null || getWorld() == null) {
throw new IllegalArgumentException("Cannot measure distance to a null world");
} else if (o.getWorld() != getWorld()) {
throw new IllegalArgumentException("Cannot measure distance between " + getWorld().getName() + " and " + o.getWorld().getName());
}
return NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z);
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar. Not world-aware.
*
* @param m The factor
* @return the same location
* @see Vector
*/
public Location multiply(double m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Zero this location's components. Not world-aware.
*
* @return the same location
* @see Vector
*/
public Location zero() {
x = 0;
y = 0;
z = 0;
return this;
}
/**
* Constructs a new {@link Vector} based on this Location
*
* @return New Vector containing the coordinates represented by this
* Location
*/
public Vector toVector() {
return new Vector(x, y, z);
}
/**
* Check if each component of this Location is finite.
*
* @throws IllegalArgumentException if any component is not finite
*/
public void checkFinite() throws IllegalArgumentException {
NumberConversions.checkFinite(x, "x not finite");
NumberConversions.checkFinite(y, "y not finite");
NumberConversions.checkFinite(z, "z not finite");
NumberConversions.checkFinite(pitch, "pitch not finite");
NumberConversions.checkFinite(yaw, "yaw not finite");
}
/**
* Safely converts a double (location coordinate) to an int (block
* coordinate)
*
* @param loc Precise coordinate
* @return Block coordinate
*/
public static int locToBlock(double loc) {
return NumberConversions.floor(loc);
}
/**
* Normalizes the given yaw angle to a value between <code>+/-180</code>
* degrees.
*
* @param yaw the yaw in degrees
* @return the normalized yaw in degrees
* @see Location#getYaw()
*/
public static float normalizeYaw(float yaw) {
yaw %= 360.0f;
if (yaw >= 180.0f) {
yaw -= 360.0f;
} else if (yaw < -180.0f) {
yaw += 360.0f;
}
return yaw;
}
/**
* Normalizes the given pitch angle to a value between <code>+/-90</code>
* degrees.
*
* @param pitch the pitch in degrees
* @return the normalized pitch in degrees
* @see Location#getPitch()
*/
public static float normalizePitch(float pitch) {
if (pitch > 90.0f) {
pitch = 90.0f;
} else if (pitch < -90.0f) {
pitch = -90.0f;
}
return pitch;
}
@Override
public String toString() {
return "Location{" + "world=" + world + ",x=" + x + ",y=" + y + ",z=" + z + ",pitch=" + pitch + ",yaw=" + yaw + "}";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + Float.floatToIntBits(pitch);
result = prime * result + ((world == null) ? 0 : world.hashCode());
long temp;
temp = Double.doubleToLongBits(x);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(y);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + Float.floatToIntBits(yaw);
temp = Double.doubleToLongBits(z);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Location other = (Location) obj;
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Location other = (Location) obj;
if (Float.floatToIntBits(pitch) != Float.floatToIntBits(other.pitch))
return false;
if (world == null) {
if (other.world != null)
return false;
} else if (!world.equals(other.world))
return false;
if (Double.doubleToLongBits(x) != Double.doubleToLongBits(other.x))
return false;
if (Double.doubleToLongBits(y) != Double.doubleToLongBits(other.y))
return false;
if (Float.floatToIntBits(yaw) != Float.floatToIntBits(other.yaw))
return false;
if (Double.doubleToLongBits(z) != Double.doubleToLongBits(other.z))
return false;
return true;
}
World world = (this.world == null) ? null : this.world;
World otherWorld = (other.world == null) ? null : other.world;
if (world != otherWorld && (world == null || !world.equals(otherWorld))) {
return false;
}
if (Double.doubleToLongBits(this.x) != Double.doubleToLongBits(other.x)) {
return false;
}
if (Double.doubleToLongBits(this.y) != Double.doubleToLongBits(other.y)) {
return false;
}
if (Double.doubleToLongBits(this.z) != Double.doubleToLongBits(other.z)) {
return false;
}
if (Float.floatToIntBits(this.pitch) != Float.floatToIntBits(other.pitch)) {
return false;
}
if (Float.floatToIntBits(this.yaw) != Float.floatToIntBits(other.yaw)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int hash = 3;
World world = (this.world == null) ? null : this.world;
hash = 19 * hash + (world != null ? world.hashCode() : 0);
hash = 19 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32));
hash = 19 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32));
hash = 19 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32));
hash = 19 * hash + Float.floatToIntBits(this.pitch);
hash = 19 * hash + Float.floatToIntBits(this.yaw);
return hash;
}
}

852
src/com/loohp/limbo/Location/Vector.java Normal file
View File

@ -0,0 +1,852 @@
package com.loohp.limbo.Location;
import java.util.Random;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Doubles;
import com.loohp.limbo.Utils.NumberConversions;
import com.loohp.limbo.World.World;
/**
* Represents a mutable vector. Because the components of Vectors are mutable,
* storing Vectors long term may be dangerous if passing code modifies the
* Vector later. If you want to keep around a Vector, it may be wise to call
* <code>clone()</code> in order to get a copy.
*/
public class Vector implements Cloneable {
private static Random random = new Random();
/**
* Threshold for fuzzy equals().
*/
private static final double epsilon = 0.000001;
protected double x;
protected double y;
protected double z;
/**
* Construct the vector with all components as 0.
*/
public Vector() {
this.x = 0;
this.y = 0;
this.z = 0;
}
/**
* Construct the vector with provided integer components.
*
* @param x X component
* @param y Y component
* @param z Z component
*/
public Vector(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Construct the vector with provided double components.
*
* @param x X component
* @param y Y component
* @param z Z component
*/
public Vector(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Construct the vector with provided float components.
*
* @param x X component
* @param y Y component
* @param z Z component
*/
public Vector(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Adds a vector to this one
*
* @param vec The other vector
* @return the same vector
*/
public Vector add(Vector vec) {
x += vec.x;
y += vec.y;
z += vec.z;
return this;
}
/**
* Subtracts a vector from this one.
*
* @param vec The other vector
* @return the same vector
*/
public Vector subtract(Vector vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
return this;
}
/**
* Multiplies the vector by another.
*
* @param vec The other vector
* @return the same vector
*/
public Vector multiply(Vector vec) {
x *= vec.x;
y *= vec.y;
z *= vec.z;
return this;
}
/**
* Divides the vector by another.
*
* @param vec The other vector
* @return the same vector
*/
public Vector divide(Vector vec) {
x /= vec.x;
y /= vec.y;
z /= vec.z;
return this;
}
/**
* Copies another vector
*
* @param vec The other vector
* @return the same vector
*/
public Vector copy(Vector vec) {
x = vec.x;
y = vec.y;
z = vec.z;
return this;
}
/**
* Gets the magnitude of the vector, defined as sqrt(x^2+y^2+z^2). The
* value of this method is not cached and uses a costly square-root
* function, so do not repeatedly call this method to get the vector's
* magnitude. NaN will be returned if the inner result of the sqrt()
* function overflows, which will be caused if the length is too long.
*
* @return the magnitude
*/
public double length() {
return Math.sqrt(NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z));
}
/**
* Gets the magnitude of the vector squared.
*
* @return the magnitude
*/
public double lengthSquared() {
return NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z);
}
/**
* Get the distance between this vector and another. The value of this
* method is not cached and uses a costly square-root function, so do not
* repeatedly call this method to get the vector's magnitude. NaN will be
* returned if the inner result of the sqrt() function overflows, which
* will be caused if the distance is too long.
*
* @param o The other vector
* @return the distance
*/
public double distance(Vector o) {
return Math.sqrt(NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z));
}
/**
* Get the squared distance between this vector and another.
*
* @param o The other vector
* @return the distance
*/
public double distanceSquared(Vector o) {
return NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z);
}
/**
* Gets the angle between this vector and another in radians.
*
* @param other The other vector
* @return angle in radians
*/
public float angle(Vector other) {
double dot = Doubles.constrainToRange(dot(other) / (length() * other.length()), -1.0, 1.0);
return (float) Math.acos(dot);
}
/**
* Sets this vector to the midpoint between this vector and another.
*
* @param other The other vector
* @return this same vector (now a midpoint)
*/
public Vector midpoint(Vector other) {
x = (x + other.x) / 2;
y = (y + other.y) / 2;
z = (z + other.z) / 2;
return this;
}
/**
* Gets a new midpoint vector between this vector and another.
*
* @param other The other vector
* @return a new midpoint vector
*/
public Vector getMidpoint(Vector other) {
double x = (this.x + other.x) / 2;
double y = (this.y + other.y) / 2;
double z = (this.z + other.z) / 2;
return new Vector(x, y, z);
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar.
*
* @param m The factor
* @return the same vector
*/
public Vector multiply(int m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar.
*
* @param m The factor
* @return the same vector
*/
public Vector multiply(double m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar.
*
* @param m The factor
* @return the same vector
*/
public Vector multiply(float m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Calculates the dot product of this vector with another. The dot product
* is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar.
*
* @param other The other vector
* @return dot product
*/
public double dot(Vector other) {
return x * other.x + y * other.y + z * other.z;
}
/**
* Calculates the cross product of this vector with another. The cross
* product is defined as:
* <ul>
* <li>x = y1 * z2 - y2 * z1
* <li>y = z1 * x2 - z2 * x1
* <li>z = x1 * y2 - x2 * y1
* </ul>
*
* @param o The other vector
* @return the same vector
*/
public Vector crossProduct(Vector o) {
double newX = y * o.z - o.y * z;
double newY = z * o.x - o.z * x;
double newZ = x * o.y - o.x * y;
x = newX;
y = newY;
z = newZ;
return this;
}
/**
* Calculates the cross product of this vector with another without mutating
* the original. The cross product is defined as:
* <ul>
* <li>x = y1 * z2 - y2 * z1
* <li>y = z1 * x2 - z2 * x1
* <li>z = x1 * y2 - x2 * y1
* </ul>
*
* @param o The other vector
* @return a new vector
*/
public Vector getCrossProduct(Vector o) {
double x = this.y * o.z - o.y * this.z;
double y = this.z * o.x - o.z * this.x;
double z = this.x * o.y - o.x * this.y;
return new Vector(x, y, z);
}
/**
* Converts this vector to a unit vector (a vector with length of 1).
*
* @return the same vector
*/
public Vector normalize() {
double length = length();
x /= length;
y /= length;
z /= length;
return this;
}
/**
* Zero this vector's components.
*
* @return the same vector
*/
public Vector zero() {
x = 0;
y = 0;
z = 0;
return this;
}
/**
* Converts each component of value <code>-0.0</code> to <code>0.0</code>.
*
* @return This vector.
*/
Vector normalizeZeros() {
if (x == -0.0D) x = 0.0D;
if (y == -0.0D) y = 0.0D;
if (z == -0.0D) z = 0.0D;
return this;
}
/**
* Returns whether this vector is in an axis-aligned bounding box.
* <p>
* The minimum and maximum vectors given must be truly the minimum and
* maximum X, Y and Z components.
*
* @param min Minimum vector
* @param max Maximum vector
* @return whether this vector is in the AABB
*/
public boolean isInAABB(Vector min, Vector max) {
return x >= min.x && x <= max.x && y >= min.y && y <= max.y && z >= min.z && z <= max.z;
}
/**
* Returns whether this vector is within a sphere.
*
* @param origin Sphere origin.
* @param radius Sphere radius
* @return whether this vector is in the sphere
*/
public boolean isInSphere(Vector origin, double radius) {
return (NumberConversions.square(origin.x - x) + NumberConversions.square(origin.y - y) + NumberConversions.square(origin.z - z)) <= NumberConversions.square(radius);
}
/**
* Returns if a vector is normalized
*
* @return whether the vector is normalised
*/
public boolean isNormalized() {
return Math.abs(this.lengthSquared() - 1) < getEpsilon();
}
/**
* Rotates the vector around the x axis.
* <p>
* This piece of math is based on the standard rotation matrix for vectors
* in three dimensional space. This matrix can be found here:
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
* Matrix</a>.
*
* @param angle the angle to rotate the vector about. This angle is passed
* in radians
* @return the same vector
*/
public Vector rotateAroundX(double angle) {
double angleCos = Math.cos(angle);
double angleSin = Math.sin(angle);
double y = angleCos * getY() - angleSin * getZ();
double z = angleSin * getY() + angleCos * getZ();
return setY(y).setZ(z);
}
/**
* Rotates the vector around the y axis.
* <p>
* This piece of math is based on the standard rotation matrix for vectors
* in three dimensional space. This matrix can be found here:
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
* Matrix</a>.
*
* @param angle the angle to rotate the vector about. This angle is passed
* in radians
* @return the same vector
*/
public Vector rotateAroundY(double angle) {
double angleCos = Math.cos(angle);
double angleSin = Math.sin(angle);
double x = angleCos * getX() + angleSin * getZ();
double z = -angleSin * getX() + angleCos * getZ();
return setX(x).setZ(z);
}
/**
* Rotates the vector around the z axis
* <p>
* This piece of math is based on the standard rotation matrix for vectors
* in three dimensional space. This matrix can be found here:
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
* Matrix</a>.
*
* @param angle the angle to rotate the vector about. This angle is passed
* in radians
* @return the same vector
*/
public Vector rotateAroundZ(double angle) {
double angleCos = Math.cos(angle);
double angleSin = Math.sin(angle);
double x = angleCos * getX() - angleSin * getY();
double y = angleSin * getX() + angleCos * getY();
return setX(x).setY(y);
}
/**
* Rotates the vector around a given arbitrary axis in 3 dimensional space.
*
* <p>
* Rotation will follow the general Right-Hand-Rule, which means rotation
* will be counterclockwise when the axis is pointing towards the observer.
* <p>
* This method will always make sure the provided axis is a unit vector, to
* not modify the length of the vector when rotating. If you are experienced
* with the scaling of a non-unit axis vector, you can use
* {@link Vector#rotateAroundNonUnitAxis(Vector, double)}.
*
* @param axis the axis to rotate the vector around. If the passed vector is
* not of length 1, it gets copied and normalized before using it for the
* rotation. Please use {@link Vector#normalize()} on the instance before
* passing it to this method
* @param angle the angle to rotate the vector around the axis
* @return the same vector
* @throws IllegalArgumentException if the provided axis vector instance is
* null
*/
public Vector rotateAroundAxis(Vector axis, double angle) throws IllegalArgumentException {
Preconditions.checkArgument(axis != null, "The provided axis vector was null");
return rotateAroundNonUnitAxis(axis.isNormalized() ? axis : axis.clone().normalize(), angle);
}
/**
* Rotates the vector around a given arbitrary axis in 3 dimensional space.
*
* <p>
* Rotation will follow the general Right-Hand-Rule, which means rotation
* will be counterclockwise when the axis is pointing towards the observer.
* <p>
* Note that the vector length will change accordingly to the axis vector
* length. If the provided axis is not a unit vector, the rotated vector
* will not have its previous length. The scaled length of the resulting
* vector will be related to the axis vector. If you are not perfectly sure
* about the scaling of the vector, use
* {@link Vector#rotateAroundAxis(Vector, double)}
*
* @param axis the axis to rotate the vector around.
* @param angle the angle to rotate the vector around the axis
* @return the same vector
* @throws IllegalArgumentException if the provided axis vector instance is
* null
*/
public Vector rotateAroundNonUnitAxis(Vector axis, double angle) throws IllegalArgumentException {
Preconditions.checkArgument(axis != null, "The provided axis vector was null");
double x = getX(), y = getY(), z = getZ();
double x2 = axis.getX(), y2 = axis.getY(), z2 = axis.getZ();
double cosTheta = Math.cos(angle);
double sinTheta = Math.sin(angle);
double dotProduct = this.dot(axis);
double xPrime = x2 * dotProduct * (1d - cosTheta)
+ x * cosTheta
+ (-z2 * y + y2 * z) * sinTheta;
double yPrime = y2 * dotProduct * (1d - cosTheta)
+ y * cosTheta
+ (z2 * x - x2 * z) * sinTheta;
double zPrime = z2 * dotProduct * (1d - cosTheta)
+ z * cosTheta
+ (-y2 * x + x2 * y) * sinTheta;
return setX(xPrime).setY(yPrime).setZ(zPrime);
}
/**
* Gets the X component.
*
* @return The X component.
*/
public double getX() {
return x;
}
/**
* Gets the floored value of the X component, indicating the block that
* this vector is contained with.
*
* @return block X
*/
public int getBlockX() {
return NumberConversions.floor(x);
}
/**
* Gets the Y component.
*
* @return The Y component.
*/
public double getY() {
return y;
}
/**
* Gets the floored value of the Y component, indicating the block that
* this vector is contained with.
*
* @return block y
*/
public int getBlockY() {
return NumberConversions.floor(y);
}
/**
* Gets the Z component.
*
* @return The Z component.
*/
public double getZ() {
return z;
}
/**
* Gets the floored value of the Z component, indicating the block that
* this vector is contained with.
*
* @return block z
*/
public int getBlockZ() {
return NumberConversions.floor(z);
}
/**
* Set the X component.
*
* @param x The new X component.
* @return This vector.
*/
public Vector setX(int x) {
this.x = x;
return this;
}
/**
* Set the X component.
*
* @param x The new X component.
* @return This vector.
*/
public Vector setX(double x) {
this.x = x;
return this;
}
/**
* Set the X component.
*
* @param x The new X component.
* @return This vector.
*/
public Vector setX(float x) {
this.x = x;
return this;
}
/**
* Set the Y component.
*
* @param y The new Y component.
* @return This vector.
*/
public Vector setY(int y) {
this.y = y;
return this;
}
/**
* Set the Y component.
*
* @param y The new Y component.
* @return This vector.
*/
public Vector setY(double y) {
this.y = y;
return this;
}
/**
* Set the Y component.
*
* @param y The new Y component.
* @return This vector.
*/
public Vector setY(float y) {
this.y = y;
return this;
}
/**
* Set the Z component.
*
* @param z The new Z component.
* @return This vector.
*/
public Vector setZ(int z) {
this.z = z;
return this;
}
/**
* Set the Z component.
*
* @param z The new Z component.
* @return This vector.
*/
public Vector setZ(double z) {
this.z = z;
return this;
}
/**
* Set the Z component.
*
* @param z The new Z component.
* @return This vector.
*/
public Vector setZ(float z) {
this.z = z;
return this;
}
/**
* Checks to see if two objects are equal.
* <p>
* Only two Vectors can ever return true. This method uses a fuzzy match
* to account for floating point errors. The epsilon can be retrieved
* with epsilon.
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Vector)) {
return false;
}
Vector other = (Vector) obj;
return Math.abs(x - other.x) < epsilon && Math.abs(y - other.y) < epsilon && Math.abs(z - other.z) < epsilon && (this.getClass().equals(obj.getClass()));
}
/**
* Returns a hash code for this vector
*
* @return hash code
*/
@Override
public int hashCode() {
int hash = 7;
hash = 79 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32));
hash = 79 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32));
hash = 79 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32));
return hash;
}
/**
* Get a new vector.
*
* @return vector
*/
@Override
public Vector clone() {
try {
return (Vector) super.clone();
} catch (CloneNotSupportedException e) {
throw new Error(e);
}
}
/**
* Returns this vector's components as x,y,z.
*/
@Override
public String toString() {
return x + "," + y + "," + z;
}
/**
* Gets a Location version of this vector with yaw and pitch being 0.
*
* @param world The world to link the location to.
* @return the location
*/
public Location toLocation(World world) {
return new Location(world, x, y, z);
}
/**
* Gets a Location version of this vector.
*
* @param world The world to link the location to.
* @param yaw The desired yaw.
* @param pitch The desired pitch.
* @return the location
*/
public Location toLocation(World world, float yaw, float pitch) {
return new Location(world, x, y, z, yaw, pitch);
}
/**
* Get the block vector of this vector.
*
* @return A block vector.
public BlockVector toBlockVector() {
return new BlockVector(x, y, z);
}
*/
/**
* Check if each component of this Vector is finite.
*
* @throws IllegalArgumentException if any component is not finite
*/
public void checkFinite() throws IllegalArgumentException {
NumberConversions.checkFinite(x, "x not finite");
NumberConversions.checkFinite(y, "y not finite");
NumberConversions.checkFinite(z, "z not finite");
}
/**
* Get the threshold used for equals().
*
* @return The epsilon.
*/
public static double getEpsilon() {
return epsilon;
}
/**
* Gets the minimum components of two vectors.
*
* @param v1 The first vector.
* @param v2 The second vector.
* @return minimum
*/
public static Vector getMinimum(Vector v1, Vector v2) {
return new Vector(Math.min(v1.x, v2.x), Math.min(v1.y, v2.y), Math.min(v1.z, v2.z));
}
/**
* Gets the maximum components of two vectors.
*
* @param v1 The first vector.
* @param v2 The second vector.
* @return maximum
*/
public static Vector getMaximum(Vector v1, Vector v2) {
return new Vector(Math.max(v1.x, v2.x), Math.max(v1.y, v2.y), Math.max(v1.z, v2.z));
}
/**
* Gets a random vector with components having a random value between 0
* and 1.
*
* @return A random vector.
*/
public static Vector getRandom() {
return new Vector(random.nextDouble(), random.nextDouble(), random.nextDouble());
}
/*
@Override
public Map<String, Object> serialize() {
Map<String, Object> result = new LinkedHashMap<String, Object>();
result.put("x", getX());
result.put("y", getY());
result.put("z", getZ());
return result;
}
*/
/*
public static Vector deserialize(Map<String, Object> args) {
double x = 0;
double y = 0;
double z = 0;
if (args.containsKey("x")) {
x = (Double) args.get("x");
}
if (args.containsKey("y")) {
y = (Double) args.get("y");
}
if (args.containsKey("z")) {
z = (Double) args.get("z");
}
return new Vector(x, y, z);
}
*/
}

17
src/com/loohp/limbo/Player/Player.java
View File

@ -13,7 +13,6 @@ import com.loohp.limbo.Server.Packets.PacketPlayOutGameState;
import com.loohp.limbo.Server.Packets.PacketPlayOutPositionAndLook;
import com.loohp.limbo.Server.Packets.PacketPlayOutRespawn;
import com.loohp.limbo.Utils.GameMode;
import com.loohp.limbo.World.DimensionRegistry;
import com.loohp.limbo.World.World;
import net.md_5.bungee.api.chat.BaseComponent;
@ -26,9 +25,9 @@ public class Player implements CommandSender {
private final String username;
private final UUID uuid;
private GameMode gamemode;
protected GameMode gamemode;
private int entityId;
protected int entityId;
private Location location;
@ -55,20 +54,10 @@ public class Player implements CommandSender {
}
this.gamemode = gamemode;
}
@Deprecated
public void setGamemodeSilent(GameMode gamemode) {
this.gamemode = gamemode;
}
public World getWorld() {
return location.clone().getWorld();
}
@Deprecated
public void setEntityId(int entityId) {
this.entityId = entityId;
}
public int getEntityId() {
return entityId;
@ -105,7 +94,7 @@ public class Player implements CommandSender {
public void teleport(Location location) {
try {
if (!this.location.getWorld().equals(location.getWorld())) {
PacketPlayOutRespawn respawn = new PacketPlayOutRespawn(location.getWorld(), DimensionRegistry.getCodec(), 0, gamemode, false, false, true);
PacketPlayOutRespawn respawn = new PacketPlayOutRespawn(location.getWorld(), Limbo.getInstance().getDimensionRegistry().getCodec(), 0, gamemode, false, false, true);
clientConnection.sendPacket(respawn);
}
PacketPlayOutPositionAndLook positionLook = new PacketPlayOutPositionAndLook(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch(), 1);

20
src/com/loohp/limbo/Player/Unsafe.java Normal file
View File

@ -0,0 +1,20 @@
package com.loohp.limbo.Player;
import com.loohp.limbo.Utils.GameMode;
@Deprecated
public class Unsafe {
private Unsafe() {}
@Deprecated
public void a(Player a, GameMode b) {
a.gamemode = b;
}
@Deprecated
public void a(Player a, int b) {
a.entityId = b;
}
}

5
src/com/loohp/limbo/Server/ClientConnection.java
View File

@ -63,7 +63,6 @@ import com.loohp.limbo.Utils.MojangAPIUtils;
import com.loohp.limbo.Utils.MojangAPIUtils.SkinResponse;
import com.loohp.limbo.Utils.NamespacedKey;
import com.loohp.limbo.World.BlockPosition;
import com.loohp.limbo.World.DimensionRegistry;
import com.loohp.limbo.World.World;
import net.md_5.bungee.api.ChatColor;
@ -284,9 +283,9 @@ public class ClientConnection extends Thread {
TimeUnit.MILLISECONDS.sleep(500);
ServerProperties p = Limbo.getInstance().getServerProperties();
PacketPlayOutLogin join = new PacketPlayOutLogin(player.getEntityId(), false, p.getDefaultGamemode(), Limbo.getInstance().getWorlds().stream().map(each -> new NamespacedKey(each.getName()).toString()).collect(Collectors.toList()).toArray(new String[Limbo.getInstance().getWorlds().size()]), DimensionRegistry.getCodec(), p.getWorldSpawn().getWorld(), 0, (byte) p.getMaxPlayers(), 8, p.isReducedDebugInfo(), true, false, true);
PacketPlayOutLogin join = new PacketPlayOutLogin(player.getEntityId(), false, p.getDefaultGamemode(), Limbo.getInstance().getWorlds().stream().map(each -> new NamespacedKey(each.getName()).toString()).collect(Collectors.toList()).toArray(new String[Limbo.getInstance().getWorlds().size()]), Limbo.getInstance().getDimensionRegistry().getCodec(), p.getWorldSpawn().getWorld(), 0, (byte) p.getMaxPlayers(), 8, p.isReducedDebugInfo(), true, false, true);
sendPacket(join);
player.setGamemodeSilent(p.getDefaultGamemode());
Limbo.getInstance().getUnsafe().setPlayerGameModeSilently(player, p.getDefaultGamemode());
Location s = p.getWorldSpawn();

2
src/com/loohp/limbo/Server/Packets/PacketPlayOutLogin.java
View File

@ -8,8 +8,8 @@ import java.nio.charset.StandardCharsets;
import com.loohp.limbo.Utils.DataTypeIO;
import com.loohp.limbo.Utils.GameMode;
import com.loohp.limbo.Utils.NamespacedKey;
import com.loohp.limbo.World.Environment;
import com.loohp.limbo.World.World;
import com.loohp.limbo.World.World.Environment;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.ListTag;

15
src/com/loohp/limbo/Server/Packets/PacketPlayOutMapChunk.java
View File

@ -7,8 +7,8 @@ import java.util.Iterator;
import com.loohp.limbo.Utils.ChunkDataUtils;
import com.loohp.limbo.Utils.DataTypeIO;
import com.loohp.limbo.World.Environment;
import com.loohp.limbo.World.GeneratedBlockDataMappings;
import com.loohp.limbo.World.World.Environment;
import net.querz.mca.Chunk;
import net.querz.mca.Section;
@ -72,17 +72,14 @@ public class PacketPlayOutMapChunk extends PacketOut {
DataTypeIO.writeVarInt(output, 1024);
int biome;
switch (environment) {
case END:
if (environment.equals(Environment.END)) {
biome = 9; //the_end
break;
case NETHER:
} else if (environment.equals(Environment.NETHER)) {
biome = 8; //nether_waste
break;
case NORMAL:
default:
} else if (environment.equals(Environment.NORMAL)) {
biome = 1; //plains
} else {
biome = 1; //plains
break;
}
for (int i = 0; i < 1024; i++) {
DataTypeIO.writeVarInt(output, biome);

2
src/com/loohp/limbo/Server/Packets/PacketPlayOutRespawn.java
View File

@ -8,8 +8,8 @@ import java.nio.charset.StandardCharsets;
import com.loohp.limbo.Utils.DataTypeIO;
import com.loohp.limbo.Utils.GameMode;
import com.loohp.limbo.Utils.NamespacedKey;
import com.loohp.limbo.World.Environment;
import com.loohp.limbo.World.World;
import com.loohp.limbo.World.World.Environment;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.ListTag;

32
src/com/loohp/limbo/Unsafe.java Normal file
View File

@ -0,0 +1,32 @@
package com.loohp.limbo;
import java.lang.reflect.Constructor;
import com.loohp.limbo.Player.Player;
import com.loohp.limbo.Utils.GameMode;
@Deprecated
public class Unsafe {
private com.loohp.limbo.Player.Unsafe playerUnsafe;
protected Unsafe() {
try {
Constructor<com.loohp.limbo.Player.Unsafe> playerConstructor = com.loohp.limbo.Player.Unsafe.class.getDeclaredConstructor();
playerConstructor.setAccessible(true);
playerUnsafe = playerConstructor.newInstance();
playerConstructor.setAccessible(false);
} catch (Exception e) {e.printStackTrace();}
}
@Deprecated
public void setPlayerGameModeSilently(Player player, GameMode mode) {
playerUnsafe.a(player, mode);
}
@Deprecated
public void setPlayerEntityId(Player player, int entityId) {
playerUnsafe.a(player, entityId);
}
}

4
src/com/loohp/limbo/Utils/NamespacedKey.java
View File

@ -2,8 +2,8 @@ package com.loohp.limbo.Utils;
public class NamespacedKey {
String namespace;
String key;
private String namespace;
private String key;
public NamespacedKey(String namespacedKey) {
int index = namespacedKey.indexOf(":");

124
src/com/loohp/limbo/Utils/NumberConversions.java Normal file
View File

@ -0,0 +1,124 @@
package com.loohp.limbo.Utils;
/**
* Utils for casting number types to other number types
*/
public final class NumberConversions {
private NumberConversions() {}
public static int floor(double num) {
final int floor = (int) num;
return floor == num ? floor : floor - (int) (Double.doubleToRawLongBits(num) >>> 63);
}
public static int ceil(final double num) {
final int floor = (int) num;
return floor == num ? floor : floor + (int) (~Double.doubleToRawLongBits(num) >>> 63);
}
public static int round(double num) {
return floor(num + 0.5d);
}
public static double square(double num) {
return num * num;
}
public static int toInt(Object object) {
if (object instanceof Number) {
return ((Number) object).intValue();
}
try {
return Integer.parseInt(object.toString());
} catch (NumberFormatException e) {
} catch (NullPointerException e) {
}
return 0;
}
public static float toFloat(Object object) {
if (object instanceof Number) {
return ((Number) object).floatValue();
}
try {
return Float.parseFloat(object.toString());
} catch (NumberFormatException e) {
} catch (NullPointerException e) {
}
return 0;
}
public static double toDouble(Object object) {
if (object instanceof Number) {
return ((Number) object).doubleValue();
}
try {
return Double.parseDouble(object.toString());
} catch (NumberFormatException e) {
} catch (NullPointerException e) {
}
return 0;
}
public static long toLong(Object object) {
if (object instanceof Number) {
return ((Number) object).longValue();
}
try {
return Long.parseLong(object.toString());
} catch (NumberFormatException e) {
} catch (NullPointerException e) {
}
return 0;
}
public static short toShort(Object object) {
if (object instanceof Number) {
return ((Number) object).shortValue();
}
try {
return Short.parseShort(object.toString());
} catch (NumberFormatException e) {
} catch (NullPointerException e) {
}
return 0;
}
public static byte toByte(Object object) {
if (object instanceof Number) {
return ((Number) object).byteValue();
}
try {
return Byte.parseByte(object.toString());
} catch (NumberFormatException e) {
} catch (NullPointerException e) {
}
return 0;
}
public static boolean isFinite(double d) {
return Math.abs(d) <= Double.MAX_VALUE;
}
public static boolean isFinite(float f) {
return Math.abs(f) <= Float.MAX_VALUE;
}
public static void checkFinite(double d, String message) {
if (!isFinite(d)) {
throw new IllegalArgumentException(message);
}
}
public static void checkFinite(float d, String message) {
if (!isFinite(d)) {
throw new IllegalArgumentException(message);
}
}
}

63
src/com/loohp/limbo/World/BlockState.java Normal file
View File

@ -0,0 +1,63 @@
package com.loohp.limbo.World;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import com.loohp.limbo.Utils.NamespacedKey;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.StringTag;
import net.querz.nbt.tag.Tag;
public class BlockState {
private CompoundTag tag;
public BlockState(CompoundTag tag) {
this.tag = tag;
}
public CompoundTag toCompoundTag() {
return tag;
}
public NamespacedKey getType() {
return new NamespacedKey(tag.getString("Name"));
}
public void setType(NamespacedKey namespacedKey) {
tag.putString("Name", namespacedKey.toString());
}
public Map<String, String> getProperties() {
Map<String, String> mapping = new HashMap<>();
for (Entry<String, Tag<?>> entry : tag.getCompoundTag("Properties")) {
String key = entry.getKey();
String value = ((StringTag) entry.getValue()).getValue();
mapping.put(key, value);
}
return mapping;
}
public String getProperty(String key) {
Tag<?> value = tag.getCompoundTag("Properties").get(key);
return value == null ? null : ((StringTag) value).getValue();
}
public void setProperties(Map<String, String> mapping) {
CompoundTag properties = new CompoundTag();
for (Entry<String, String> entry : mapping.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
properties.putString(key, value);
}
tag.put("Properties", properties);
}
public <T> void setProperty(String key, T value) {
CompoundTag properties = tag.getCompoundTag("Properties");
properties.putString(key, ((T) value).toString());
}
}

38
src/com/loohp/limbo/World/DimensionRegistry.java
View File

@ -17,37 +17,45 @@ import net.querz.nbt.tag.CompoundTag;
public class DimensionRegistry {
public static CompoundTag defaultTag;
private static File reg;
private CompoundTag defaultTag;
private CompoundTag codec;
private File reg;
static {
String reg = "dimension_registry.json";
File file = new File(Limbo.getInstance().getInternalDataFolder(), reg);
public DimensionRegistry() {
this.defaultTag = new CompoundTag();
String name = "dimension_registry.json";
File file = new File(Limbo.getInstance().getInternalDataFolder(), name);
if (!file.exists()) {
try (InputStream in = Limbo.class.getClassLoader().getResourceAsStream(reg)) {
try (InputStream in = Limbo.class.getClassLoader().getResourceAsStream(name)) {
Files.copy(in, file.toPath());
} catch (IOException e) {
e.printStackTrace();
}
}
DimensionRegistry.reg = file;
resetTag();
}
public static void resetTag() {
try {
this.reg = file;
try {
JSONObject json = (JSONObject) new JSONParser().parse(new FileReader(reg));
CompoundTag tag = CustomNBTUtils.getCompoundTagFromJson((JSONObject) json.get("value"));
defaultTag = tag;
codec = defaultTag.clone();
} catch (IOException | ParseException e) {
e.printStackTrace();
}
}
public static CompoundTag getCodec() {
return defaultTag;
public File getFile() {
return reg;
}
public void resetCodec() {
codec = defaultTag.clone();
}
public CompoundTag getCodec() {
return codec;
}
}

37
src/com/loohp/limbo/World/Environment.java Normal file
View File

@ -0,0 +1,37 @@
package com.loohp.limbo.World;
import com.loohp.limbo.Utils.NamespacedKey;
public class Environment {
public static final Environment NORMAL = new Environment(new NamespacedKey("minecraft:overworld"));
public static final Environment NETHER = new Environment(new NamespacedKey("minecraft:the_nether"));
public static final Environment END = new Environment(new NamespacedKey("minecraft:the_end"));
public static Environment fromNamespacedKey(NamespacedKey key) {
if (key.equals(NORMAL.getNamespacedKey())) {
return NORMAL;
} else if (key.equals(NETHER.getNamespacedKey())) {
return NETHER;
} else if (key.equals(END.getNamespacedKey())) {
return END;
}
return null;
}
public static Environment createCustom(NamespacedKey key) {
return new Environment(key);
}
//=========================
private NamespacedKey key;
private Environment(NamespacedKey key) {
this.key = key;
}
public NamespacedKey getNamespacedKey() {
return key;
}
}

1
src/com/loohp/limbo/World/Schematic.java
View File

@ -5,7 +5,6 @@ import java.util.Iterator;
import java.util.Map;
import com.loohp.limbo.Utils.SchematicConvertionUtils;
import com.loohp.limbo.World.World.Environment;
import net.querz.mca.Chunk;
import net.querz.nbt.tag.CompoundTag;

74
src/com/loohp/limbo/World/World.java
View File

@ -1,6 +1,7 @@
package com.loohp.limbo.World;
import com.loohp.limbo.Utils.NamespacedKey;
import java.util.Arrays;
import com.loohp.limbo.Utils.SchematicConvertionUtils;
import net.querz.mca.Chunk;
@ -42,7 +43,7 @@ public class World {
}
}
public void setBlock(int x, int y, int z, String blockdata) {
protected void setBlock(int x, int y, int z, String blockdata) {
Chunk chunk = this.chunks[(x >> 4)][(z >> 4)];
if (chunk == null) {
chunk = Chunk.newChunk();
@ -51,6 +52,24 @@ public class World {
CompoundTag block = SchematicConvertionUtils.toBlockTag(blockdata);
chunk.setBlockStateAt(x, y, z, block, false);
}
public BlockState getBlock(int x, int y, int z) {
Chunk chunk = this.chunks[(x >> 4)][(z >> 4)];
if (chunk == null) {
chunk = Chunk.newChunk();
this.chunks[(x >> 4)][(z >> 4)] = chunk;
}
return new BlockState(chunk.getBlockStateAt(x % 16, y % 16, z % 16));
}
public void setBlock(int x, int y, int z, BlockState state) {
Chunk chunk = this.chunks[(x >> 4)][(z >> 4)];
if (chunk == null) {
chunk = Chunk.newChunk();
this.chunks[(x >> 4)][(z >> 4)] = chunk;
}
chunk.setBlockStateAt(x % 16, y % 16, z % 16, state.toCompoundTag(), false);
}
public Chunk[][] getChunks() {
return this.chunks;
@ -67,29 +86,42 @@ public class World {
public Environment getEnvironment() {
return environment;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + Arrays.deepHashCode(chunks);
result = prime * result + ((environment == null) ? 0 : environment.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
public enum Environment {
NORMAL(new NamespacedKey("minecraft:overworld")),
NETHER(new NamespacedKey("minecraft:the_nether")),
END(new NamespacedKey("minecraft:the_end"));
NamespacedKey key;
Environment(NamespacedKey key) {
this.key = key;
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
public NamespacedKey getNamespacedKey() {
return key;
if (obj == null) {
return false;
}
public static Environment fromNamespacedKey(NamespacedKey key) {
for (Environment each : Environment.values()) {
if (each.getNamespacedKey().equals(key)) {
return each;
}
if (getClass() != obj.getClass()) {
return false;
}
World other = (World) obj;
if (!Arrays.deepEquals(chunks, other.chunks)) {
return false;
}
if (environment != other.environment) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
return null;
} else if (!name.equals(other.name)) {
return false;
}
return true;
}
}