fix clipboard rotation
This commit is contained in:
parent
66d1b9befe
commit
1c6939d61f
GPG key ID:
3AC50A6F47D1B722
13 changed files with 252 additions and 1243 deletions
|
|
@ -9,22 +9,18 @@ import common.model.Model;
|
|||
import common.model.ModelProvider;
|
||||
import common.model.ModelRotation;
|
||||
import common.properties.Property;
|
||||
import common.properties.PropertyEnum;
|
||||
import common.util.BlockPos;
|
||||
import common.util.Facing;
|
||||
import common.util.Identifyable;
|
||||
import common.world.State;
|
||||
import common.world.World;
|
||||
import common.world.AWorldServer;
|
||||
|
||||
public class BlockLog extends BlockRotatedPillar
|
||||
{
|
||||
public static final PropertyEnum<BlockLog.EnumAxis> LOG_AXIS = PropertyEnum.<BlockLog.EnumAxis>create("axis", BlockLog.EnumAxis.class);
|
||||
|
||||
public BlockLog()
|
||||
{
|
||||
super(Material.WOOD);
|
||||
this.setDefaultState(this.getBaseState().withProperty(LOG_AXIS, BlockLog.EnumAxis.Y));
|
||||
this.setDefaultState(this.getBaseState().withProperty(AXIS, Facing.Axis.Y));
|
||||
this.setTab(CheatTab.WOOD);
|
||||
this.setHardness(2.0F);
|
||||
this.setStepSound(SoundType.WOOD);
|
||||
|
|
@ -33,34 +29,30 @@ public class BlockLog extends BlockRotatedPillar
|
|||
|
||||
public void onBlockRemoved(AWorldServer worldIn, BlockPos pos, State state)
|
||||
{
|
||||
int i = 4;
|
||||
int j = i + 1;
|
||||
int r = 4;
|
||||
int l = r + 1;
|
||||
|
||||
if (worldIn.isAreaLoaded(pos.add(-j, -j, -j), pos.add(j, j, j)))
|
||||
if (worldIn.isAreaLoaded(pos.add(-l, -l, -l), pos.add(l, l, l)))
|
||||
{
|
||||
for (BlockPos blockpos : BlockPos.getAllInBox(pos.add(-i, -i, -i), pos.add(i, i, i)))
|
||||
for (BlockPos bpos : BlockPos.getAllInBox(pos.add(-r, -r, -r), pos.add(r, r, r)))
|
||||
{
|
||||
State iblockstate = worldIn.getState(blockpos);
|
||||
State blk = worldIn.getState(bpos);
|
||||
|
||||
if (iblockstate.getBlock().getMaterial() == Material.LEAVES && !((Boolean)iblockstate.getValue(BlockLeaves.DECAY)).booleanValue())
|
||||
if (blk.getBlock().getMaterial() == Material.LEAVES && !((Boolean)blk.getValue(BlockLeaves.DECAY)).booleanValue())
|
||||
{
|
||||
worldIn.setState(blockpos, iblockstate.withProperty(BlockLeaves.DECAY, Boolean.valueOf(true)), 4);
|
||||
worldIn.setState(bpos, blk.withProperty(BlockLeaves.DECAY, Boolean.valueOf(true)), 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called by ItemBlocks just before a block is actually set in the world, to allow for adjustments to the
|
||||
* IBlockstate
|
||||
*/
|
||||
public State onBlockPlaced(World worldIn, BlockPos pos, Facing facing, float hitX, float hitY, float hitZ, EntityLiving placer)
|
||||
{
|
||||
return super.onBlockPlaced(worldIn, pos, facing, hitX, hitY, hitZ, placer).withProperty(LOG_AXIS, BlockLog.EnumAxis.fromFacingAxis(facing.getAxis()));
|
||||
return super.onBlockPlaced(worldIn, pos, facing, hitX, hitY, hitZ, placer).withProperty(AXIS, facing.getAxis());
|
||||
}
|
||||
|
||||
public Model getModel(ModelProvider provider, String name, State state) {
|
||||
switch(state.getValue(LOG_AXIS)) {
|
||||
switch(state.getValue(AXIS)) {
|
||||
case X:
|
||||
return provider.getModel(name + "_bark").add().d().rot(180).u()
|
||||
.n(name + "_top").rot(180).s(name + "_top").w().rot(270)
|
||||
|
|
@ -72,114 +64,51 @@ public class BlockLog extends BlockRotatedPillar
|
|||
return provider.getModel(name + "_bark").add().d().rot(180).u()
|
||||
.n(name + "_top").rot(180).s(name + "_top").w().rot(270)
|
||||
.e().rot(90);
|
||||
case NONE:
|
||||
return provider.getModel(name + "_bark").add().all();
|
||||
}
|
||||
}
|
||||
|
||||
public State getStateFromMeta(int meta)
|
||||
{
|
||||
State iblockstate = this.getState();
|
||||
State state = this.getState();
|
||||
|
||||
switch (meta & 3)
|
||||
{
|
||||
default:
|
||||
iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.Y);
|
||||
state = state.withProperty(AXIS, Facing.Axis.Y);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.X);
|
||||
state = state.withProperty(AXIS, Facing.Axis.X);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.Z);
|
||||
state = state.withProperty(AXIS, Facing.Axis.Z);
|
||||
break;
|
||||
|
||||
case 3:
|
||||
iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.NONE);
|
||||
}
|
||||
|
||||
return iblockstate;
|
||||
return state;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Convert the BlockState into the correct metadata value
|
||||
*/
|
||||
public int getMetaFromState(State state)
|
||||
{
|
||||
int i = 0;
|
||||
int meta = 0;
|
||||
|
||||
switch ((BlockLog.EnumAxis)state.getValue(LOG_AXIS))
|
||||
switch ((Facing.Axis)state.getValue(AXIS))
|
||||
{
|
||||
case X:
|
||||
i = 1;
|
||||
meta = 1;
|
||||
break;
|
||||
|
||||
case Z:
|
||||
i = 2;
|
||||
meta = 2;
|
||||
break;
|
||||
|
||||
case NONE:
|
||||
i = 3;
|
||||
}
|
||||
|
||||
return i;
|
||||
return meta;
|
||||
}
|
||||
|
||||
protected Property[] getProperties()
|
||||
{
|
||||
return new Property[] {LOG_AXIS};
|
||||
}
|
||||
|
||||
public static enum EnumAxis implements Identifyable
|
||||
{
|
||||
X("x", Facing.Axis.X),
|
||||
Y("y", Facing.Axis.Y),
|
||||
Z("z", Facing.Axis.Z),
|
||||
NONE("none", null);
|
||||
|
||||
private final String name;
|
||||
private final Facing.Axis axis;
|
||||
|
||||
private EnumAxis(String name, Facing.Axis axis)
|
||||
{
|
||||
this.name = name;
|
||||
this.axis = axis;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return this.name;
|
||||
}
|
||||
|
||||
public static BlockLog.EnumAxis fromFacingAxis(Facing.Axis axis)
|
||||
{
|
||||
switch (axis)
|
||||
{
|
||||
case X:
|
||||
return X;
|
||||
|
||||
case Y:
|
||||
return Y;
|
||||
|
||||
case Z:
|
||||
return Z;
|
||||
|
||||
default:
|
||||
return NONE;
|
||||
}
|
||||
}
|
||||
|
||||
public String getName()
|
||||
{
|
||||
return this.name;
|
||||
}
|
||||
|
||||
public Facing.Axis getAxis()
|
||||
{
|
||||
return this.axis;
|
||||
}
|
||||
return new Property[] {AXIS};
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ import common.properties.PropertyBool;
|
|||
import common.properties.PropertyEnum;
|
||||
import common.util.BlockPos;
|
||||
import common.util.BoundingBox;
|
||||
import common.util.DirectionVec;
|
||||
import common.util.Facing;
|
||||
import common.util.Identifyable;
|
||||
import common.world.IWorldAccess;
|
||||
|
|
@ -322,7 +323,7 @@ public class BlockLever extends Block
|
|||
return new ItemBlock(this, "lever", false);
|
||||
}
|
||||
|
||||
public static enum EnumOrientation implements Identifyable
|
||||
public static enum EnumOrientation implements Identifyable, DirectionVec<EnumOrientation>
|
||||
{
|
||||
DOWN_X(0, "down_x", Facing.DOWN),
|
||||
EAST(1, "east", Facing.EAST),
|
||||
|
|
@ -422,6 +423,18 @@ public class BlockLever extends Block
|
|||
return this.name;
|
||||
}
|
||||
|
||||
public Facing getVector() {
|
||||
return this == DOWN_Z || this == UP_Z ? Facing.SOUTH : (this == DOWN_X || this == UP_X ? Facing.EAST : this.facing);
|
||||
}
|
||||
|
||||
public boolean isAxis() {
|
||||
return this.facing.getAxis().isVertical();
|
||||
}
|
||||
|
||||
public boolean canApply(EnumOrientation dir) {
|
||||
return this.facing.getAxis().isVertical() == dir.facing.getAxis().isVertical();
|
||||
}
|
||||
|
||||
static {
|
||||
for (BlockLever.EnumOrientation blocklever$enumorientation : values())
|
||||
{
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ import common.model.ModelRotation;
|
|||
import common.properties.Property;
|
||||
import common.util.BlockPos;
|
||||
import common.util.BoundingBox;
|
||||
import common.util.DirectionVec;
|
||||
import common.util.Facing;
|
||||
import common.util.HitPosition;
|
||||
import common.util.Identifyable;
|
||||
|
|
@ -229,30 +230,36 @@ public abstract class BlockRailBase extends Block
|
|||
}
|
||||
|
||||
public abstract Property<BlockRailBase.EnumRailDirection> getShapeProperty();
|
||||
|
||||
private static enum BaseShape {
|
||||
STRAIGHT, ASCENDING, TURNED;
|
||||
}
|
||||
|
||||
public static enum EnumRailDirection implements Identifyable
|
||||
public static enum EnumRailDirection implements Identifyable, DirectionVec<EnumRailDirection>
|
||||
{
|
||||
NORTH_SOUTH(0, "north_south", Facing.SOUTH),
|
||||
EAST_WEST(1, "east_west", Facing.EAST),
|
||||
ASCENDING_EAST(2, "ascending_east", Facing.EAST),
|
||||
ASCENDING_WEST(3, "ascending_west", Facing.WEST),
|
||||
ASCENDING_NORTH(4, "ascending_north", Facing.NORTH),
|
||||
ASCENDING_SOUTH(5, "ascending_south", Facing.DOWN),
|
||||
SOUTH_EAST(6, "south_east", Facing.EAST),
|
||||
SOUTH_WEST(7, "south_west", Facing.SOUTH),
|
||||
NORTH_WEST(8, "north_west", Facing.NORTH),
|
||||
NORTH_EAST(9, "north_east", Facing.WEST);
|
||||
NORTH_SOUTH(0, "north_south", Facing.SOUTH, BaseShape.STRAIGHT),
|
||||
EAST_WEST(1, "east_west", Facing.EAST, BaseShape.STRAIGHT),
|
||||
ASCENDING_EAST(2, "ascending_east", Facing.EAST, BaseShape.ASCENDING),
|
||||
ASCENDING_WEST(3, "ascending_west", Facing.WEST, BaseShape.ASCENDING),
|
||||
ASCENDING_NORTH(4, "ascending_north", Facing.NORTH, BaseShape.ASCENDING),
|
||||
ASCENDING_SOUTH(5, "ascending_south", Facing.DOWN, BaseShape.ASCENDING),
|
||||
SOUTH_EAST(6, "south_east", Facing.EAST, BaseShape.TURNED),
|
||||
SOUTH_WEST(7, "south_west", Facing.SOUTH, BaseShape.TURNED),
|
||||
NORTH_WEST(8, "north_west", Facing.NORTH, BaseShape.TURNED),
|
||||
NORTH_EAST(9, "north_east", Facing.WEST, BaseShape.TURNED);
|
||||
|
||||
private static final BlockRailBase.EnumRailDirection[] META_LOOKUP = new BlockRailBase.EnumRailDirection[values().length];
|
||||
private final int meta;
|
||||
private final String name;
|
||||
private final Facing facing;
|
||||
private final BaseShape shape;
|
||||
|
||||
private EnumRailDirection(int meta, String name, Facing facing)
|
||||
private EnumRailDirection(int meta, String name, Facing facing, BaseShape shape)
|
||||
{
|
||||
this.meta = meta;
|
||||
this.name = name;
|
||||
this.facing = facing;
|
||||
this.shape = shape;
|
||||
}
|
||||
|
||||
public int getMetadata()
|
||||
|
|
@ -290,6 +297,18 @@ public abstract class BlockRailBase extends Block
|
|||
return this.facing;
|
||||
}
|
||||
|
||||
public Facing getVector() {
|
||||
return this.facing;
|
||||
}
|
||||
|
||||
public boolean isAxis() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean canApply(EnumRailDirection dir) {
|
||||
return this.shape == dir.shape;
|
||||
}
|
||||
|
||||
static {
|
||||
for (BlockRailBase.EnumRailDirection blockrailbase$enumraildirection : values())
|
||||
{
|
||||
|
|
|
|||
9
common/src/main/java/common/util/DirectionVec.java
Normal file
9
common/src/main/java/common/util/DirectionVec.java
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
package common.util;
|
||||
|
||||
public interface DirectionVec<T> {
|
||||
public Facing getVector();
|
||||
public boolean isAxis();
|
||||
default boolean canApply(T other) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -8,7 +8,7 @@ import common.collect.Iterators;
|
|||
import common.collect.Maps;
|
||||
import common.rng.Random;
|
||||
|
||||
public enum Facing implements Identifyable
|
||||
public enum Facing implements Identifyable, DirectionVec<Facing>
|
||||
{
|
||||
DOWN(0, 2, 1, -1, "down", Facing.AxisDirection.NEGATIVE, Facing.Axis.Y, new Vec3i(0, -1, 0)),
|
||||
UP(1, 3, 0, -1, "up", Facing.AxisDirection.POSITIVE, Facing.Axis.Y, new Vec3i(0, 1, 0)),
|
||||
|
|
@ -353,6 +353,14 @@ public enum Facing implements Identifyable
|
|||
{
|
||||
return this.directionVec;
|
||||
}
|
||||
|
||||
public Facing getVector() {
|
||||
return this.axis.isVertical() ? null : this;
|
||||
}
|
||||
|
||||
public boolean isAxis() {
|
||||
return false;
|
||||
}
|
||||
|
||||
static {
|
||||
for (Facing enumfacing : values())
|
||||
|
|
@ -368,7 +376,7 @@ public enum Facing implements Identifyable
|
|||
}
|
||||
}
|
||||
|
||||
public static enum Axis implements Predicate<Facing>, Identifyable {
|
||||
public static enum Axis implements Predicate<Facing>, Identifyable, DirectionVec<Axis> {
|
||||
X("x", Facing.Plane.HORIZONTAL),
|
||||
Y("y", Facing.Plane.VERTICAL),
|
||||
Z("z", Facing.Plane.HORIZONTAL);
|
||||
|
|
@ -422,6 +430,14 @@ public enum Facing implements Identifyable
|
|||
{
|
||||
return this.name;
|
||||
}
|
||||
|
||||
public Facing getVector() {
|
||||
return this == Y ? null : (this == X ? EAST : SOUTH);
|
||||
}
|
||||
|
||||
public boolean isAxis() {
|
||||
return true;
|
||||
}
|
||||
|
||||
static {
|
||||
for (Facing.Axis enumfacing$axis : values())
|
||||
|
|
|
|||
|
|
@ -1,111 +1,63 @@
|
|||
package server.clipboard;
|
||||
|
||||
public class BlockTransform {
|
||||
private double m00, m01, m02, m03;
|
||||
private double m10, m11, m12, m13;
|
||||
private double m20, m21, m22, m23;
|
||||
|
||||
public BlockTransform() {
|
||||
m00 = m11 = m22 = 1;
|
||||
m01 = m02 = m03 = 0;
|
||||
m10 = m12 = m13 = 0;
|
||||
m20 = m21 = m23 = 0;
|
||||
}
|
||||
private final int xx;
|
||||
private final int zx;
|
||||
private final int xz;
|
||||
private final int zz;
|
||||
|
||||
private BlockTransform(double xx, double yx, double zx, double tx,
|
||||
double xy, double yy, double zy, double ty, double xz, double yz,
|
||||
double zz, double tz) {
|
||||
m00 = xx;
|
||||
m01 = yx;
|
||||
m02 = zx;
|
||||
m03 = tx;
|
||||
m10 = xy;
|
||||
m11 = yy;
|
||||
m12 = zy;
|
||||
m13 = ty;
|
||||
m20 = xz;
|
||||
m21 = yz;
|
||||
m22 = zz;
|
||||
m23 = tz;
|
||||
}
|
||||
|
||||
private BlockTransform concatenate(BlockTransform that) {
|
||||
double n00 = m00 * that.m00 + m01 * that.m10 + m02 * that.m20;
|
||||
double n01 = m00 * that.m01 + m01 * that.m11 + m02 * that.m21;
|
||||
double n02 = m00 * that.m02 + m01 * that.m12 + m02 * that.m22;
|
||||
double n03 = m00 * that.m03 + m01 * that.m13 + m02 * that.m23 + m03;
|
||||
double n10 = m10 * that.m00 + m11 * that.m10 + m12 * that.m20;
|
||||
double n11 = m10 * that.m01 + m11 * that.m11 + m12 * that.m21;
|
||||
double n12 = m10 * that.m02 + m11 * that.m12 + m12 * that.m22;
|
||||
double n13 = m10 * that.m03 + m11 * that.m13 + m12 * that.m23 + m13;
|
||||
double n20 = m20 * that.m00 + m21 * that.m10 + m22 * that.m20;
|
||||
double n21 = m20 * that.m01 + m21 * that.m11 + m22 * that.m21;
|
||||
double n22 = m20 * that.m02 + m21 * that.m12 + m22 * that.m22;
|
||||
double n23 = m20 * that.m03 + m21 * that.m13 + m22 * that.m23 + m23;
|
||||
return new BlockTransform(
|
||||
n00, n01, n02, n03,
|
||||
n10, n11, n12, n13,
|
||||
n20, n21, n22, n23);
|
||||
}
|
||||
|
||||
public BlockTransform rotateY(int theta) {
|
||||
double cot = dCos(theta);
|
||||
double sit = dSin(theta);
|
||||
return concatenate(
|
||||
new BlockTransform(
|
||||
cot, 0, sit, 0,
|
||||
0, 1, 0, 0,
|
||||
-sit, 0, cot, 0));
|
||||
}
|
||||
|
||||
public BlockTransform scale(Vector vec) {
|
||||
return concatenate(new BlockTransform(vec.getX(), 0, 0, 0, 0, vec.getY(), 0, 0, 0, 0, vec.getZ(), 0));
|
||||
}
|
||||
|
||||
public Vector apply(Vector vector) {
|
||||
return new Vector(
|
||||
vector.getX() * m00 + vector.getY() * m01 + vector.getZ() * m02 + m03,
|
||||
vector.getX() * m10 + vector.getY() * m11 + vector.getZ() * m12 + m13,
|
||||
vector.getX() * m20 + vector.getY() * m21 + vector.getZ() * m22 + m23);
|
||||
}
|
||||
|
||||
private static double dSin(int degrees) {
|
||||
if (degrees % 90 == 0) {
|
||||
degrees %= 360;
|
||||
if (degrees < 0) {
|
||||
degrees += 360;
|
||||
}
|
||||
switch (degrees) {
|
||||
case 0:
|
||||
return 0.0;
|
||||
case 90:
|
||||
return 1.0;
|
||||
case 180:
|
||||
return 0.0;
|
||||
case 270:
|
||||
return -1.0;
|
||||
}
|
||||
}
|
||||
return Math.cos(Math.toRadians(degrees));
|
||||
public BlockTransform(int theta, boolean x, boolean z) {
|
||||
int cot = dCos(theta);
|
||||
int sit = dSin(theta);
|
||||
this.xx = cot * (x ? -1 : 1);
|
||||
this.zx = sit * (z ? -1 : 1);
|
||||
this.xz = -sit * (x ? -1 : 1);
|
||||
this.zz = cot * (z ? -1 : 1);
|
||||
}
|
||||
|
||||
private static double dCos(int degrees) {
|
||||
if (degrees % 90 == 0) {
|
||||
degrees %= 360;
|
||||
if (degrees < 0) {
|
||||
degrees += 360;
|
||||
}
|
||||
switch (degrees) {
|
||||
case 0:
|
||||
return 1.0;
|
||||
case 90:
|
||||
return 0.0;
|
||||
case 180:
|
||||
return -1.0;
|
||||
case 270:
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
return Math.cos(Math.toRadians(degrees));
|
||||
|
||||
public int applyX(int x, int z) {
|
||||
return x * this.xx + z * this.zx;
|
||||
}
|
||||
|
||||
public int applyZ(int x, int z) {
|
||||
return x * this.xz + z * this.zz;
|
||||
}
|
||||
|
||||
private static int dSin(int degrees) {
|
||||
if(degrees % 90 == 0) {
|
||||
degrees %= 360;
|
||||
if(degrees < 0)
|
||||
degrees += 360;
|
||||
switch(degrees) {
|
||||
case 0:
|
||||
return 0;
|
||||
case 90:
|
||||
return 1;
|
||||
case 180:
|
||||
return 0;
|
||||
case 270:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
private static int dCos(int degrees) {
|
||||
if(degrees % 90 == 0) {
|
||||
degrees %= 360;
|
||||
if(degrees < 0)
|
||||
degrees += 360;
|
||||
switch(degrees) {
|
||||
case 0:
|
||||
return 1;
|
||||
case 90:
|
||||
return 0;
|
||||
case 180:
|
||||
return -1;
|
||||
case 270:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,43 +0,0 @@
|
|||
package server.clipboard;
|
||||
|
||||
import java.util.function.Predicate;
|
||||
|
||||
public class Rotation {
|
||||
private final RotationValue[] values;
|
||||
private final boolean[] dirFlags = new boolean[16];
|
||||
|
||||
public Rotation(RotationValue[] values, Predicate<Integer> predicate) {
|
||||
this.values = values;
|
||||
for(int z = 0; z < 16; z++) {
|
||||
if(predicate != null && !predicate.test(z)) {
|
||||
this.dirFlags[z] = false;
|
||||
continue;
|
||||
}
|
||||
boolean flag = false;
|
||||
for(RotationValue value : values) {
|
||||
if(value.getDirection() != null) {
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
this.dirFlags[z] = flag;
|
||||
}
|
||||
}
|
||||
|
||||
public RotationValue[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public RotationValue getValue(int meta) {
|
||||
for (RotationValue value : this.values) {
|
||||
if (value.isSet(meta)) {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean hasDirection(int meta) {
|
||||
return this.dirFlags[meta & 15];
|
||||
}
|
||||
}
|
||||
|
|
@ -3,121 +3,41 @@ package server.clipboard;
|
|||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
import common.block.Block;
|
||||
import common.block.BlockRotatedPillar;
|
||||
import common.block.artificial.BlockDoor;
|
||||
import common.block.artificial.BlockPortal;
|
||||
import common.block.foliage.BlockLog;
|
||||
import common.block.tech.BlockLever;
|
||||
import common.block.tech.BlockRail;
|
||||
import common.block.tech.BlockRailBase;
|
||||
import common.block.tech.BlockRailDetector;
|
||||
import common.block.tech.BlockRailPowered;
|
||||
import common.collect.Lists;
|
||||
import common.collect.Maps;
|
||||
import common.properties.Property;
|
||||
import common.util.DirectionVec;
|
||||
import common.util.Facing;
|
||||
import common.util.Vec3i;
|
||||
import common.world.State;
|
||||
|
||||
public abstract class RotationRegistry {
|
||||
private static final Map<Block, Rotation> MAP = new HashMap<Block, Rotation>();
|
||||
private static final Map<Block, RotationValue[]> MAP = new HashMap<Block, RotationValue[]>();
|
||||
|
||||
public static void register() {
|
||||
List<RotationValue> values = Lists.newArrayList();
|
||||
for(Block block : common.init.BlockRegistry.REGISTRY) {
|
||||
for(Property<?> prop : block.getPropertyMap()) {
|
||||
Predicate<Integer> predicate = null;
|
||||
if(prop == BlockDoor.FACING) {
|
||||
predicate = new Predicate<Integer>() {
|
||||
@Override
|
||||
public boolean test(Integer meta) {
|
||||
return (meta & 8) == 0;
|
||||
}
|
||||
};
|
||||
}
|
||||
List<RotationValue> values = Lists.newArrayList();
|
||||
Map<Object, Byte> map = Maps.newHashMap();
|
||||
for(int z = 15; z >= 0; z--) {
|
||||
State st = block.getStateFromMeta(z);
|
||||
if(st.getProperties().containsKey(prop)) {
|
||||
map.put(st.getProperties().get(prop), (byte)z);
|
||||
for(Comparable v : prop.getStates()) {
|
||||
if(!(v instanceof DirectionVec vec))
|
||||
continue;
|
||||
Facing dir = vec.getVector();
|
||||
if(dir != null) {
|
||||
Vec3i dv = dir.getDirectionVec();
|
||||
values.add(new RotationValue(prop, v, vec, dv.getX(), dv.getZ()));
|
||||
if(vec.isAxis())
|
||||
values.add(new RotationValue(prop, v, vec, -dv.getX(), -dv.getZ()));
|
||||
}
|
||||
}
|
||||
|
||||
byte mask = 0;
|
||||
for(Object v : prop.getStates()) {
|
||||
if(map.get(v) == null) {
|
||||
continue;
|
||||
}
|
||||
mask |= map.get(v);
|
||||
}
|
||||
if(mask == 0) {
|
||||
continue;
|
||||
}
|
||||
for(Object v : prop.getStates()) {
|
||||
if(map.get(v) == null) {
|
||||
continue;
|
||||
}
|
||||
Vec3i dv = null;
|
||||
Facing.Axis axis = null;
|
||||
if(v instanceof Facing face) {
|
||||
dv = face.getDirectionVec();
|
||||
}
|
||||
else if(prop == BlockRotatedPillar.AXIS) {
|
||||
axis = ((Facing.Axis)v);
|
||||
}
|
||||
else if(prop == BlockPortal.AXIS) {
|
||||
axis = ((Facing.Axis)v);
|
||||
}
|
||||
else if(prop == BlockLog.LOG_AXIS) {
|
||||
axis = ((BlockLog.EnumAxis)v).getAxis();
|
||||
}
|
||||
else if(prop == BlockLever.FACING) {
|
||||
dv = ((BlockLever.EnumOrientation)v).getFacing().getDirectionVec();
|
||||
}
|
||||
else if(prop == BlockRail.SHAPE || prop == BlockRailDetector.SHAPE || prop == BlockRailPowered.SHAPE) {
|
||||
dv = ((BlockRailBase.EnumRailDirection)v).getFacing().getDirectionVec();
|
||||
}
|
||||
// else if(prop == BlockDoor.HINGE) {
|
||||
// dv = ((BlockDoor.EnumHingePosition)v) == BlockDoor.EnumHingePosition.LEFT ? new Vec3i(-1, 0, 0) : new Vec3i(1, 0, 0);
|
||||
// }
|
||||
if(axis != null) {
|
||||
switch(axis) {
|
||||
case X:
|
||||
dv = new Vec3i(1, 0, 0);
|
||||
break;
|
||||
case Y:
|
||||
dv = new Vec3i(0, 1, 0);
|
||||
break;
|
||||
case Z:
|
||||
dv = new Vec3i(0, 0, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(dv == null) {
|
||||
continue;
|
||||
}
|
||||
values.add(new RotationValue(mask, (byte)(map.get(v) & mask), new Vector(dv.getX(), dv.getY(), dv.getZ())));
|
||||
if(axis != null) {
|
||||
values.add(new RotationValue(mask, (byte)(map.get(v) & mask), new Vector(-dv.getX(), -dv.getY(), -dv.getZ())));
|
||||
}
|
||||
}
|
||||
if(!values.isEmpty()) {
|
||||
Rotation state = new Rotation(values.toArray(new RotationValue[values.size()]), predicate);
|
||||
// Log.CONFIG.debug("Block " + game.init.BlockRegistry.getNameFromBlock(block) + "/" + legacyId + " mask = " + String.format("0x%x", mask));
|
||||
// for(RotationValue value : values) {
|
||||
// Log.CONFIG.debug(" meta " + value.data + " -> " + value.direction.toString());
|
||||
// }
|
||||
MAP.put(block, state);
|
||||
}
|
||||
if(values.size() > 1)
|
||||
MAP.put(block, values.toArray(new RotationValue[values.size()]));
|
||||
if(!values.isEmpty())
|
||||
break;
|
||||
}
|
||||
values.clear();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public static Rotation getRotation(Block block) {
|
||||
public static RotationValue[] getRotation(Block block) {
|
||||
return MAP.get(block);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,25 +1,41 @@
|
|||
package server.clipboard;
|
||||
|
||||
public class RotationValue {
|
||||
public final byte mask;
|
||||
public final byte data;
|
||||
public final Vector direction;
|
||||
import common.properties.Property;
|
||||
import common.util.DirectionVec;
|
||||
import common.world.State;
|
||||
|
||||
public RotationValue(byte mask, byte data, Vector direction) {
|
||||
this.mask = mask;
|
||||
this.data = data;
|
||||
this.direction = direction;
|
||||
public class RotationValue<T extends Comparable<T>> {
|
||||
private final Property<T> property;
|
||||
private final T value;
|
||||
private final DirectionVec vec;
|
||||
private final int dirX;
|
||||
private final int dirZ;
|
||||
|
||||
public RotationValue(Property property, T value, DirectionVec vec, int x, int z) {
|
||||
this.property = property;
|
||||
this.value = value;
|
||||
this.vec = vec;
|
||||
this.dirX = x;
|
||||
this.dirZ = z;
|
||||
}
|
||||
|
||||
public boolean isSet(int meta) {
|
||||
return (meta & mask) == data;
|
||||
public boolean isSet(State state) {
|
||||
return state.getValue(this.property) == this.value;
|
||||
}
|
||||
|
||||
public int set(int meta) {
|
||||
return ((meta & ~mask) | data);
|
||||
public State set(State state) {
|
||||
return state.withProperty(this.property, this.value);
|
||||
}
|
||||
|
||||
public Vector getDirection() {
|
||||
return direction;
|
||||
public boolean canTransform(RotationValue other) {
|
||||
return this.vec.canApply(other.vec);
|
||||
}
|
||||
|
||||
public int getX() {
|
||||
return this.dirX;
|
||||
}
|
||||
|
||||
public int getZ() {
|
||||
return this.dirZ;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,802 +0,0 @@
|
|||
package server.clipboard;
|
||||
|
||||
public class Vector implements Comparable<Vector> {
|
||||
public static final Vector ZERO = new Vector(0, 0, 0);
|
||||
|
||||
protected final double x, y, z;
|
||||
|
||||
public Vector(double x, double y, double z) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Construct an instance.
|
||||
// *
|
||||
// * @param x the X coordinate
|
||||
// * @param y the Y coordinate
|
||||
// * @param z the Z coordinate
|
||||
// */
|
||||
// public Vector(int x, int y, int z) {
|
||||
// this.x = (double) x;
|
||||
// this.y = (double) y;
|
||||
// this.z = (double) z;
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Construct an instance.
|
||||
// *
|
||||
// * @param x the X coordinate
|
||||
// * @param y the Y coordinate
|
||||
// * @param z the Z coordinate
|
||||
// */
|
||||
// public Vector(float x, float y, float z) {
|
||||
// this.x = (double) x;
|
||||
// this.y = (double) y;
|
||||
// this.z = (double) z;
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Copy another vector.
|
||||
// *
|
||||
// * @param other another vector to make a copy of
|
||||
// */
|
||||
// public Vector(Vector other) {
|
||||
// this.x = other.x;
|
||||
// this.y = other.y;
|
||||
// this.z = other.z;
|
||||
// }
|
||||
|
||||
/**
|
||||
* Construct a new instance with X, Y, and Z coordinates set to 0.
|
||||
*
|
||||
* <p>One can also refer to a static {@link #ZERO}.</p>
|
||||
*/
|
||||
public Vector() {
|
||||
this.x = 0;
|
||||
this.y = 0;
|
||||
this.z = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the X coordinate.
|
||||
*
|
||||
* @return the x coordinate
|
||||
*/
|
||||
public double getX() {
|
||||
return x;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the X coordinate rounded.
|
||||
*
|
||||
* @return the x coordinate
|
||||
*/
|
||||
public int getBlockX() {
|
||||
return (int) Math.round(x);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Set the X coordinate.
|
||||
// *
|
||||
// * @param x the new X
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector setX(double x) {
|
||||
// return new Vector(x, y, z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Set the X coordinate.
|
||||
// *
|
||||
// * @param x the X coordinate
|
||||
// * @return new vector
|
||||
// */
|
||||
// public Vector setX(int x) {
|
||||
// return new Vector(x, y, z);
|
||||
// }
|
||||
|
||||
/**
|
||||
* Get the Y coordinate.
|
||||
*
|
||||
* @return the y coordinate
|
||||
*/
|
||||
public double getY() {
|
||||
return y;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Y coordinate rounded.
|
||||
*
|
||||
* @return the y coordinate
|
||||
*/
|
||||
public int getBlockY() {
|
||||
return (int) Math.round(y);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Set the Y coordinate.
|
||||
// *
|
||||
// * @param y the new Y
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector setY(double y) {
|
||||
// return new Vector(x, y, z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Set the Y coordinate.
|
||||
// *
|
||||
// * @param y the new Y
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector setY(int y) {
|
||||
// return new Vector(x, y, z);
|
||||
// }
|
||||
|
||||
/**
|
||||
* Get the Z coordinate.
|
||||
*
|
||||
* @return the z coordinate
|
||||
*/
|
||||
public double getZ() {
|
||||
return z;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Z coordinate rounded.
|
||||
*
|
||||
* @return the z coordinate
|
||||
*/
|
||||
public int getBlockZ() {
|
||||
return (int) Math.round(z);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Set the Z coordinate.
|
||||
// *
|
||||
// * @param z the new Z
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector setZ(double z) {
|
||||
// return new Vector(x, y, z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Set the Z coordinate.
|
||||
// *
|
||||
// * @param z the new Z
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector setZ(int z) {
|
||||
// return new Vector(x, y, z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Add another vector to this vector and return the result as a new vector.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector add(Vector other) {
|
||||
// return new Vector(x + other.x, y + other.y, z + other.z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Add another vector to this vector and return the result as a new vector.
|
||||
// *
|
||||
// * @param x the value to add
|
||||
// * @param y the value to add
|
||||
// * @param z the value to add
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector add(double x, double y, double z) {
|
||||
// return new Vector(this.x + x, this.y + y, this.z + z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Add another vector to this vector and return the result as a new vector.
|
||||
// *
|
||||
// * @param x the value to add
|
||||
// * @param y the value to add
|
||||
// * @param z the value to add
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector add(int x, int y, int z) {
|
||||
// return new Vector(this.x + x, this.y + y, this.z + z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Add a list of vectors to this vector and return the
|
||||
// * result as a new vector.
|
||||
// *
|
||||
// * @param others an array of vectors
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector add(Vector... others) {
|
||||
// double newX = x, newY = y, newZ = z;
|
||||
//
|
||||
// for (Vector other : others) {
|
||||
// newX += other.x;
|
||||
// newY += other.y;
|
||||
// newZ += other.z;
|
||||
// }
|
||||
//
|
||||
// return new Vector(newX, newY, newZ);
|
||||
// }
|
||||
|
||||
/**
|
||||
* Subtract another vector from this vector and return the result
|
||||
* as a new vector.
|
||||
*
|
||||
* @param other the other vector
|
||||
* @return a new vector
|
||||
*/
|
||||
public Vector subtract(Vector other) {
|
||||
return new Vector(x - other.x, y - other.y, z - other.z);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Subtract another vector from this vector and return the result
|
||||
// * as a new vector.
|
||||
// *
|
||||
// * @param x the value to subtract
|
||||
// * @param y the value to subtract
|
||||
// * @param z the value to subtract
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector subtract(double x, double y, double z) {
|
||||
// return new Vector(this.x - x, this.y - y, this.z - z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Subtract another vector from this vector and return the result
|
||||
// * as a new vector.
|
||||
// *
|
||||
// * @param x the value to subtract
|
||||
// * @param y the value to subtract
|
||||
// * @param z the value to subtract
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector subtract(int x, int y, int z) {
|
||||
// return new Vector(this.x - x, this.y - y, this.z - z);
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Subtract a list of vectors from this vector and return the result
|
||||
// * as a new vector.
|
||||
// *
|
||||
// * @param others an array of vectors
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector subtract(Vector... others) {
|
||||
// double newX = x, newY = y, newZ = z;
|
||||
//
|
||||
// for (Vector other : others) {
|
||||
// newX -= other.x;
|
||||
// newY -= other.y;
|
||||
// newZ -= other.z;
|
||||
// }
|
||||
//
|
||||
// return new Vector(newX, newY, newZ);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Multiply this vector by another vector on each component.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(Vector other) {
|
||||
// return new Vector(x * other.x, y * other.y, z * other.z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Multiply this vector by another vector on each component.
|
||||
// *
|
||||
// * @param x the value to multiply
|
||||
// * @param y the value to multiply
|
||||
// * @param z the value to multiply
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(double x, double y, double z) {
|
||||
// return new Vector(this.x * x, this.y * y, this.z * z);
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Multiply this vector by another vector on each component.
|
||||
// *
|
||||
// * @param x the value to multiply
|
||||
// * @param y the value to multiply
|
||||
// * @param z the value to multiply
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(int x, int y, int z) {
|
||||
// return new Vector(this.x * x, this.y * y, this.z * z);
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Multiply this vector by zero or more vectors on each component.
|
||||
// *
|
||||
// * @param others an array of vectors
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(Vector... others) {
|
||||
// double newX = x, newY = y, newZ = z;
|
||||
//
|
||||
// for (Vector other : others) {
|
||||
// newX *= other.x;
|
||||
// newY *= other.y;
|
||||
// newZ *= other.z;
|
||||
// }
|
||||
//
|
||||
// return new Vector(newX, newY, newZ);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Perform scalar multiplication and return a new vector.
|
||||
// *
|
||||
// * @param n the value to multiply
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(double n) {
|
||||
// return new Vector(this.x * n, this.y * n, this.z * n);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Perform scalar multiplication and return a new vector.
|
||||
// *
|
||||
// * @param n the value to multiply
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(float n) {
|
||||
// return new Vector(this.x * n, this.y * n, this.z * n);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Perform scalar multiplication and return a new vector.
|
||||
// *
|
||||
// * @param n the value to multiply
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector multiply(int n) {
|
||||
// return new Vector(this.x * n, this.y * n, this.z * n);
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Divide this vector by another vector on each component.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector divide(Vector other) {
|
||||
// return new Vector(x / other.x, y / other.y, z / other.z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Divide this vector by another vector on each component.
|
||||
// *
|
||||
// * @param x the value to divide by
|
||||
// * @param y the value to divide by
|
||||
// * @param z the value to divide by
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector divide(double x, double y, double z) {
|
||||
// return new Vector(this.x / x, this.y / y, this.z / z);
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Divide this vector by another vector on each component.
|
||||
// *
|
||||
// * @param x the value to divide by
|
||||
// * @param y the value to divide by
|
||||
// * @param z the value to divide by
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector divide(int x, int y, int z) {
|
||||
// return new Vector(this.x / x, this.y / y, this.z / z);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Perform scalar division and return a new vector.
|
||||
// *
|
||||
// * @param n the value to divide by
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector divide(int n) {
|
||||
// return new Vector(x / n, y / n, z / n);
|
||||
// }
|
||||
|
||||
/**
|
||||
* Perform scalar division and return a new vector.
|
||||
*
|
||||
* @param n the value to divide by
|
||||
* @return a new vector
|
||||
*/
|
||||
public Vector divide(double n) {
|
||||
return new Vector(x / n, y / n, z / n);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Perform scalar division and return a new vector.
|
||||
// *
|
||||
// * @param n the value to divide by
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector divide(float n) {
|
||||
// return new Vector(x / n, y / n, z / n);
|
||||
// }
|
||||
|
||||
/**
|
||||
* Get the length of the vector.
|
||||
*
|
||||
* @return length
|
||||
*/
|
||||
public double length() {
|
||||
return Math.sqrt(x * x + y * y + z * z);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Get the length, squared, of the vector.
|
||||
// *
|
||||
// * @return length, squared
|
||||
// */
|
||||
// public double lengthSq() {
|
||||
// return x * x + y * y + z * z;
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Get the distance between this vector and another vector.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return distance
|
||||
// */
|
||||
// public double distance(Vector other) {
|
||||
// return Math.sqrt(Math.pow(other.x - x, 2) +
|
||||
// Math.pow(other.y - y, 2) +
|
||||
// Math.pow(other.z - z, 2));
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Get the distance between this vector and another vector, squared.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return distance
|
||||
// */
|
||||
// public double distanceSq(Vector other) {
|
||||
// return Math.pow(other.x - x, 2) +
|
||||
// Math.pow(other.y - y, 2) +
|
||||
// Math.pow(other.z - z, 2);
|
||||
// }
|
||||
|
||||
/**
|
||||
* Get the normalized vector, which is the vector divided by its
|
||||
* length, as a new vector.
|
||||
*
|
||||
* @return a new vector
|
||||
*/
|
||||
public Vector normalize() {
|
||||
return divide(length());
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the dot product of this and another vector.
|
||||
*
|
||||
* @param other the other vector
|
||||
* @return the dot product of this and the other vector
|
||||
*/
|
||||
public double dot(Vector other) {
|
||||
return x * other.x + y * other.y + z * other.z;
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Gets the cross product of this and another vector.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return the cross product of this and the other vector
|
||||
// */
|
||||
// public Vector cross(Vector other) {
|
||||
// return new Vector(
|
||||
// y * other.z - z * other.y,
|
||||
// z * other.x - x * other.z,
|
||||
// x * other.y - y * other.x
|
||||
// );
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Checks to see if a vector is contained with another.
|
||||
// *
|
||||
// * @param min the minimum point (X, Y, and Z are the lowest)
|
||||
// * @param max the maximum point (X, Y, and Z are the lowest)
|
||||
// * @return true if the vector is contained
|
||||
// */
|
||||
// public boolean containedWithin(Vector min, Vector max) {
|
||||
// return x >= min.x && x <= max.x && y >= min.y && y <= max.y && z >= min.z && z <= max.z;
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Checks to see if a vector is contained with another, comparing
|
||||
// * using discrete comparisons, inclusively.
|
||||
// *
|
||||
// * @param min the minimum point (X, Y, and Z are the lowest)
|
||||
// * @param max the maximum point (X, Y, and Z are the lowest)
|
||||
// * @return true if the vector is contained
|
||||
// */
|
||||
// public boolean containedWithinBlock(Vector min, Vector max) {
|
||||
// return getBlockX() >= min.getBlockX() && getBlockX() <= max.getBlockX()
|
||||
// && getBlockY() >= min.getBlockY() && getBlockY() <= max.getBlockY()
|
||||
// && getBlockZ() >= min.getBlockZ() && getBlockZ() <= max.getBlockZ();
|
||||
// }
|
||||
|
||||
/**
|
||||
* Clamp the Y component.
|
||||
*
|
||||
* @param min the minimum value
|
||||
* @param max the maximum value
|
||||
* @return a new vector
|
||||
*/
|
||||
public Vector clampY(int min, int max) {
|
||||
return new Vector(x, Math.max(min, Math.min(max, y)), z);
|
||||
}
|
||||
|
||||
// /**
|
||||
// * Floors the values of all components.
|
||||
// *
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector floor() {
|
||||
// return new Vector(Math.floor(x), Math.floor(y), Math.floor(z));
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Rounds all components up.
|
||||
// *
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector ceil() {
|
||||
// return new Vector(Math.ceil(x), Math.ceil(y), Math.ceil(z));
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Rounds all components to the closest integer.
|
||||
// *
|
||||
// * <p>Components < 0.5 are rounded down, otherwise up.</p>
|
||||
// *
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector round() {
|
||||
// return new Vector(Math.floor(x + 0.5), Math.floor(y + 0.5), Math.floor(z + 0.5));
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Returns a vector with the absolute values of the components of
|
||||
// * this vector.
|
||||
// *
|
||||
// * @return a new vector
|
||||
// */
|
||||
// public Vector positive() {
|
||||
// return new Vector(Math.abs(x), Math.abs(y), Math.abs(z));
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Perform a 2D transformation on this vector and return a new one.
|
||||
// *
|
||||
// * @param angle in degrees
|
||||
// * @param aboutX about which x coordinate to rotate
|
||||
// * @param aboutZ about which z coordinate to rotate
|
||||
// * @param translateX what to add after rotation
|
||||
// * @param translateZ what to add after rotation
|
||||
// * @return a new vector
|
||||
// * @see AffineTransform another method to transform vectors
|
||||
// */
|
||||
// public Vector transform2D(double angle, double aboutX, double aboutZ, double translateX, double translateZ) {
|
||||
// angle = Math.toRadians(angle);
|
||||
// double x = this.x - aboutX;
|
||||
// double z = this.z - aboutZ;
|
||||
// double x2 = x * Math.cos(angle) - z * Math.sin(angle);
|
||||
// double z2 = x * Math.sin(angle) + z * Math.cos(angle);
|
||||
//
|
||||
// return new Vector(
|
||||
// x2 + aboutX + translateX,
|
||||
// y,
|
||||
// z2 + aboutZ + translateZ
|
||||
// );
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Returns whether this vector is collinear with another vector.
|
||||
// *
|
||||
// * @param other the other vector
|
||||
// * @return true if collinear
|
||||
// */
|
||||
// public boolean isCollinearWith(Vector other) {
|
||||
// if (x == 0 && y == 0 && z == 0) {
|
||||
// // this is a zero vector
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// final double otherX = other.x;
|
||||
// final double otherY = other.y;
|
||||
// final double otherZ = other.z;
|
||||
//
|
||||
// if (otherX == 0 && otherY == 0 && otherZ == 0) {
|
||||
// // other is a zero vector
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// if ((x == 0) != (otherX == 0)) return false;
|
||||
// if ((y == 0) != (otherY == 0)) return false;
|
||||
// if ((z == 0) != (otherZ == 0)) return false;
|
||||
//
|
||||
// final double quotientX = otherX / x;
|
||||
// if (!Double.isNaN(quotientX)) {
|
||||
// return other.equals(multiply(quotientX));
|
||||
// }
|
||||
//
|
||||
// final double quotientY = otherY / y;
|
||||
// if (!Double.isNaN(quotientY)) {
|
||||
// return other.equals(multiply(quotientY));
|
||||
// }
|
||||
//
|
||||
// final double quotientZ = otherZ / z;
|
||||
// if (!Double.isNaN(quotientZ)) {
|
||||
// return other.equals(multiply(quotientZ));
|
||||
// }
|
||||
//
|
||||
// throw new RuntimeException("This should not happen");
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Get this vector's pitch as used within the game.
|
||||
// *
|
||||
// * @return pitch in radians
|
||||
// */
|
||||
// public float toPitch() {
|
||||
// double x = getX();
|
||||
// double z = getZ();
|
||||
//
|
||||
// if (x == 0 && z == 0) {
|
||||
// return getY() > 0 ? -90 : 90;
|
||||
// } else {
|
||||
// double x2 = x * x;
|
||||
// double z2 = z * z;
|
||||
// double xz = Math.sqrt(x2 + z2);
|
||||
// return (float) Math.toDegrees(Math.atan(-getY() / xz));
|
||||
// }
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Get this vector's yaw as used within the game.
|
||||
// *
|
||||
// * @return yaw in radians
|
||||
// */
|
||||
// public float toYaw() {
|
||||
// double x = getX();
|
||||
// double z = getZ();
|
||||
//
|
||||
// double t = Math.atan2(-x, z);
|
||||
// double _2pi = 2 * Math.PI;
|
||||
//
|
||||
// return (float) Math.toDegrees(((t + _2pi) % _2pi));
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Create a new {@code BlockVector} using the given components.
|
||||
// *
|
||||
// * @param x the X coordinate
|
||||
// * @param y the Y coordinate
|
||||
// * @param z the Z coordinate
|
||||
// * @return a new {@code BlockVector}
|
||||
// */
|
||||
// public static BlockVector toBlockPoint(double x, double y, double z) {
|
||||
// return new BlockVector(
|
||||
// Math.floor(x),
|
||||
// Math.floor(y),
|
||||
// Math.floor(z)
|
||||
// );
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Create a new {@code BlockVector} from this vector.
|
||||
// *
|
||||
// * @return a new {@code BlockVector}
|
||||
// */
|
||||
// public BlockVector toBlockVector() {
|
||||
// return new BlockVector(this);
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * Creates a 2D vector by dropping the Y component from this vector.
|
||||
// *
|
||||
// * @return a new {@code Vector2D}
|
||||
// */
|
||||
// public Vector2D toVector2D() {
|
||||
// return new Vector2D(x, z);
|
||||
// }
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (!(obj instanceof Vector)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
Vector other = (Vector) obj;
|
||||
return other.x == this.x && other.y == this.y && other.z == this.z;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Vector other) {
|
||||
if (other == null) {
|
||||
throw new IllegalArgumentException("null not supported");
|
||||
}
|
||||
if (y != other.y) return Double.compare(y, other.y);
|
||||
if (z != other.z) return Double.compare(z, other.z);
|
||||
if (x != other.x) return Double.compare(x, other.x);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@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;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return x + ", " + y + ", " + z;
|
||||
}
|
||||
|
||||
// /**
|
||||
// * 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 the midpoint of two vectors.
|
||||
// *
|
||||
// * @param v1 the first vector
|
||||
// * @param v2 the second vector
|
||||
// * @return maximum
|
||||
// */
|
||||
// public static Vector getMidpoint(Vector v1, Vector v2) {
|
||||
// return new Vector(
|
||||
// (v1.x + v2.x) / 2,
|
||||
// (v1.y + v2.y) / 2,
|
||||
// (v1.z + v2.z) / 2
|
||||
// );
|
||||
// }
|
||||
|
||||
// public BlockPos toBlockPos() {
|
||||
// return new BlockPos(x, y, z);
|
||||
// }
|
||||
}
|
||||
|
|
@ -124,10 +124,8 @@ import server.Server;
|
|||
import server.clipboard.BlockTransform;
|
||||
import server.clipboard.ClipboardBlock;
|
||||
import server.clipboard.ClipboardPlacer;
|
||||
import server.clipboard.Rotation;
|
||||
import server.clipboard.RotationRegistry;
|
||||
import server.clipboard.RotationValue;
|
||||
import server.clipboard.Vector;
|
||||
import server.command.Executor;
|
||||
import server.util.Form;
|
||||
import server.vars.SVars;
|
||||
|
|
@ -1423,11 +1421,7 @@ public class Player extends User implements ICrafting, Executor, IPlayer
|
|||
ClipboardPlacer placer = new ClipboardPlacer(this.getEntityWorld());
|
||||
BlockTransform transform = null;
|
||||
if(this.rotation != 0 || this.flipX || this.flipZ) {
|
||||
transform = new BlockTransform();
|
||||
if(this.rotation != 0)
|
||||
transform = transform.rotateY(-this.rotation);
|
||||
if(this.flipX || this.flipZ)
|
||||
transform = transform.scale(new Vector(this.flipX ? -1.0 : 1.0, 1.0, this.flipZ ? -1.0 : 1.0));
|
||||
transform = new BlockTransform(-this.rotation, this.flipX, this.flipZ);
|
||||
}
|
||||
else {
|
||||
to = to.add(this.selOffset);
|
||||
|
|
@ -1440,15 +1434,14 @@ public class Player extends User implements ICrafting, Executor, IPlayer
|
|||
}
|
||||
else {
|
||||
ClipboardBlock block = transformBlock(transform, this.clipboard[x][y][z]);
|
||||
Vector tf = transform.apply(new Vector(x + this.selOffset.getX(), y + this.selOffset.getY(), z + this.selOffset.getZ()));
|
||||
placer.setBlock(to.add(tf.getBlockX(), tf.getBlockY(), tf.getBlockZ()), block);
|
||||
placer.setBlock(to.add(transform.applyX(x + this.selOffset.getX(), z + this.selOffset.getZ()), y + this.selOffset.getY(),
|
||||
transform.applyZ(x + this.selOffset.getX(), z + this.selOffset.getZ())), block);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(transform != null) {
|
||||
Vector tf = transform.apply(new Vector(this.selOffset.getX(), this.selOffset.getY(), this.selOffset.getZ()));
|
||||
to = to.add(tf.getBlockX(), tf.getBlockY(), tf.getBlockZ());
|
||||
to = to.add(transform.applyX(this.selOffset.getX(), this.selOffset.getZ()), this.selOffset.getY(), transform.applyZ(this.selOffset.getX(), this.selOffset.getZ()));
|
||||
}
|
||||
placer.commit();
|
||||
this.addHotbar(TextColor.YELLOW + "Zwischenablage wurde bei %d, %d, %d eingefügt", to.getX(), to.getY(), to.getZ());
|
||||
|
|
@ -1456,49 +1449,41 @@ public class Player extends User implements ICrafting, Executor, IPlayer
|
|||
}
|
||||
|
||||
private static ClipboardBlock transformBlock(BlockTransform transform, ClipboardBlock block) {
|
||||
Rotation state = RotationRegistry.getRotation(block.getState().getBlock());
|
||||
|
||||
if (state == null) {
|
||||
RotationValue[] state = RotationRegistry.getRotation(block.getState().getBlock());
|
||||
if(state == null)
|
||||
return block;
|
||||
}
|
||||
|
||||
int meta = block.getState().getBlock().getMetaFromState(block.getState());
|
||||
|
||||
if (state.hasDirection(meta)) {
|
||||
RotationValue value = state.getValue(meta);
|
||||
if (value != null && value.getDirection() != null) {
|
||||
RotationValue newValue = getNewRotation(transform, state, value.getDirection());
|
||||
if (newValue != null) {
|
||||
block.setState(block.getState().getBlock().getStateFromMeta(newValue.set(meta)));
|
||||
}
|
||||
for(RotationValue value : state) {
|
||||
if(value.isSet(block.getState())) {
|
||||
RotationValue newValue = getNewRotation(transform, state, value);
|
||||
if(newValue != null)
|
||||
block.setState(newValue.set(block.getState()));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return block;
|
||||
}
|
||||
|
||||
private static double dot(double x1, double z1, double x2, double z2) {
|
||||
double l1 = Math.sqrt(x1 * x1 + z1 * z1);
|
||||
double l2 = Math.sqrt(x2 * x2 + z2 * z2);
|
||||
return (x1 / l1) * (x2 / l2) + (z1 / l1) * (z2 / l2);
|
||||
}
|
||||
|
||||
private static RotationValue getNewRotation(BlockTransform transform, Rotation state, Vector oldDirection) {
|
||||
Vector newDirection = transform.apply(oldDirection).subtract(transform.apply(Vector.ZERO)).normalize();
|
||||
private static RotationValue getNewRotation(BlockTransform transform, RotationValue[] state, RotationValue value) {
|
||||
int x = transform.applyX(value.getX(), value.getZ());
|
||||
int z = transform.applyZ(value.getX(), value.getZ());
|
||||
RotationValue newValue = null;
|
||||
double closest = -2;
|
||||
boolean found = false;
|
||||
|
||||
for (RotationValue v : state.getValues()) {
|
||||
if (v.getDirection() != null) {
|
||||
double dot = v.getDirection().normalize().dot(newDirection);
|
||||
if (dot >= closest) {
|
||||
closest = dot;
|
||||
newValue = v;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (found) {
|
||||
return newValue;
|
||||
} else {
|
||||
return null;
|
||||
for(RotationValue v : state) {
|
||||
if(v.canTransform(value)) {
|
||||
double dot = dot(v.getX(), v.getZ(), x, z);
|
||||
if(dot >= closest) {
|
||||
closest = dot;
|
||||
newValue = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
return newValue;
|
||||
}
|
||||
|
||||
private boolean copyClipboard() {
|
||||
|
|
|
|||
|
|
@ -435,22 +435,18 @@ public abstract class Converter {
|
|||
mapBlock(Blocks.gold_ore, 14);
|
||||
mapBlock(Blocks.iron_ore, 15);
|
||||
mapBlock(Blocks.coal_ore, 16);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Y), 17);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.X), 17, 4);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Z), 17, 8);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.NONE), 17, 12);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Y), 17, 1);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.X), 17, 5);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Z), 17, 9);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.NONE), 17, 13);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Y), 17, 2);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.X), 17, 6);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Z), 17, 10);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.NONE), 17, 14);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Y), 17, 3);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.X), 17, 7);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Z), 17, 11);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.NONE), 17, 15);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.AXIS, Axis.Y), 17);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.AXIS, Axis.X), 17, 4);
|
||||
mapBlock(Blocks.oak_log.getState().withProperty(BlockLog.AXIS, Axis.Z), 17, 8);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.AXIS, Axis.Y), 17, 1, 13);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.AXIS, Axis.X), 17, 5);
|
||||
mapBlock(Blocks.spruce_log.getState().withProperty(BlockLog.AXIS, Axis.Z), 17, 9);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.AXIS, Axis.Y), 17, 2, 14);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.AXIS, Axis.X), 17, 6);
|
||||
mapBlock(Blocks.birch_log.getState().withProperty(BlockLog.AXIS, Axis.Z), 17, 10);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.AXIS, Axis.Y), 17, 3, 15);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.AXIS, Axis.X), 17, 7);
|
||||
mapBlock(Blocks.jungle_log.getState().withProperty(BlockLog.AXIS, Axis.Z), 17, 11);
|
||||
mapBlock(Blocks.oak_leaves_spring.getState()
|
||||
.withProperty(BlockLeaves.DECAY, false), 18);
|
||||
mapBlock(Blocks.oak_leaves_spring.getState()
|
||||
|
|
@ -1400,14 +1396,12 @@ public abstract class Converter {
|
|||
.withProperty(BlockLeaves.DECAY, true), 161, 9);
|
||||
mapBlock(Blocks.dark_oak_leaves_spring.getState()
|
||||
.withProperty(BlockLeaves.DECAY, true), 161, 13);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Y), 162);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.X), 162, 4);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Z), 162, 8);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.NONE), 162, 12);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Y), 162, 1);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.X), 162, 5);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.Z), 162, 9);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.LOG_AXIS, BlockLog.EnumAxis.NONE), 162, 13);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.AXIS, Axis.Y), 162);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.AXIS, Axis.X), 162, 4);
|
||||
mapBlock(Blocks.acacia_log.getState().withProperty(BlockLog.AXIS, Axis.Z), 162, 8);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.AXIS, Axis.Y), 162, 1, 13);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.AXIS, Axis.X), 162, 5);
|
||||
mapBlock(Blocks.dark_oak_log.getState().withProperty(BlockLog.AXIS, Axis.Z), 162, 9);
|
||||
mapBlock(Blocks.acacia_stairs.getState().withProperty(BlockStairs.FACING, Facing.EAST).withProperty(BlockStairs.HALF, EnumHalf.BOTTOM), 163, 0, 8);
|
||||
mapBlock(Blocks.acacia_stairs.getState().withProperty(BlockStairs.FACING, Facing.WEST).withProperty(BlockStairs.HALF, EnumHalf.BOTTOM), 163, 1, 9);
|
||||
mapBlock(Blocks.acacia_stairs.getState().withProperty(BlockStairs.FACING, Facing.SOUTH).withProperty(BlockStairs.HALF, EnumHalf.BOTTOM), 163, 2, 10);
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import common.init.WoodType;
|
|||
import common.rng.Random;
|
||||
import common.util.BlockPos;
|
||||
import common.util.ExtMath;
|
||||
import common.util.Facing;
|
||||
import common.world.State;
|
||||
import server.world.WorldServer;
|
||||
|
||||
|
|
@ -192,8 +193,8 @@ public class WorldGenBigTree extends WorldGenTree
|
|||
for (int j = 0; j <= i; ++j)
|
||||
{
|
||||
BlockPos blockpos1 = p_175937_1_.add((double)(0.5F + (float)j * f), (double)(0.5F + (float)j * f1), (double)(0.5F + (float)j * f2));
|
||||
BlockLog.EnumAxis blocklog$enumaxis = this.func_175938_b(p_175937_1_, blockpos1);
|
||||
this.setBlockAndNotifyAdequately(this.world, blockpos1, this.logBase.withProperty(BlockLog.LOG_AXIS, blocklog$enumaxis));
|
||||
Facing.Axis blocklog$enumaxis = this.func_175938_b(p_175937_1_, blockpos1);
|
||||
this.setBlockAndNotifyAdequately(this.world, blockpos1, this.logBase.withProperty(BlockLog.AXIS, blocklog$enumaxis));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -208,9 +209,9 @@ public class WorldGenBigTree extends WorldGenTree
|
|||
return k > i && k > j ? k : (j > i ? j : i);
|
||||
}
|
||||
|
||||
private BlockLog.EnumAxis func_175938_b(BlockPos p_175938_1_, BlockPos p_175938_2_)
|
||||
private Facing.Axis func_175938_b(BlockPos p_175938_1_, BlockPos p_175938_2_)
|
||||
{
|
||||
BlockLog.EnumAxis blocklog$enumaxis = BlockLog.EnumAxis.Y;
|
||||
Facing.Axis blocklog$enumaxis = Facing.Axis.Y;
|
||||
int i = Math.abs(p_175938_2_.getX() - p_175938_1_.getX());
|
||||
int j = Math.abs(p_175938_2_.getZ() - p_175938_1_.getZ());
|
||||
int k = Math.max(i, j);
|
||||
|
|
@ -219,11 +220,11 @@ public class WorldGenBigTree extends WorldGenTree
|
|||
{
|
||||
if (i == k)
|
||||
{
|
||||
blocklog$enumaxis = BlockLog.EnumAxis.X;
|
||||
blocklog$enumaxis = Facing.Axis.X;
|
||||
}
|
||||
else if (j == k)
|
||||
{
|
||||
blocklog$enumaxis = BlockLog.EnumAxis.Z;
|
||||
blocklog$enumaxis = Facing.Axis.Z;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue