Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2024-09-27 06:03:01 +02:00
Code Issues Projects Releases Wiki Activity

Revert "Start of rotation, chunkbatch is fine, relative batch is not."

Browse Source 
This reverts commit b48cce1d
This commit is contained in:
Matt Worzala 2021-01-12 15:53:03 -05:00
parent e1e2772f4d
commit 5bedee2795
7 changed files with 2 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/main/java/net/minestom/server/instance/batch/AbsoluteBlockBatch.java
View File

@ -82,11 +82,6 @@ public class AbsoluteBlockBatch implements Batch<Runnable> {
}
}
@Override
public AbsoluteBlockBatch squareRotate(int degree) {
throw new IllegalStateException("Rotation not supported on AbsoluteBlockBatch.");
}
/**
* Applies this batch to the given instance.
*

43
src/main/java/net/minestom/server/instance/batch/Batch.java
View File

@ -5,7 +5,6 @@ import net.minestom.server.data.Data;
import net.minestom.server.instance.BlockModifier;
import net.minestom.server.instance.Instance;
import net.minestom.server.instance.block.CustomBlock;
import net.minestom.server.utils.Rotation;
import net.minestom.server.utils.thread.MinestomThread;
import net.minestom.server.utils.validate.Check;
import org.jetbrains.annotations.NotNull;
@ -68,47 +67,7 @@ public interface Batch<Callback> extends BlockModifier {
*/
void clear();
/**
* Creates a new batch with the blocks currently inside this batch,
* rotated the given amount of degrees.
* <p>
* At the moment, only rotations of 90 degree increments may be applied.
* All rotations will be rounded down to the nearest 90 degree increment.
*
* @param degrees The number of degrees to rotate
* @return A new batch with the rotation applied
*
* @see #squareRotate(int)
*/
default Batch<Callback> rotate(int degrees) {
return squareRotate((degrees / 90) % 4);
}
/**
* Creates a new batch with the blocks currently inside this batch,
* rotated the given {@link Rotation}.
* <p>
* At the moment, only rotations of 90 degree increments may be applied.
* 45 degree rotations will have undefined behavior.
*
* @param rotation The rotation to apply
* @return A new batch with the rotation applied
*/
default Batch<Callback> rotate(Rotation rotation) {
return squareRotate(rotation.ordinal() / 2);
}
/**
* Creates a new batch with the blocks currently inside this batch,
* rotated the given 'degree'.
* <p>
* The 'degree' is the number of 90 degree rotations to apply. For
* example: degree of 1 = 90°, 2 = 180°, -2 = -180°
*
* @param degree The degree to rotate
* @return A new batch with the rotation applied
*/
Batch<Callback> squareRotate(int degree);
// Batch rotate(? );
/**
* Called to apply the batch to the given instance.

54
src/main/java/net/minestom/server/instance/batch/ChunkBatch.java
View File

@ -8,8 +8,6 @@ import net.minestom.server.data.Data;
import net.minestom.server.instance.Chunk;
import net.minestom.server.instance.Instance;
import net.minestom.server.instance.InstanceContainer;
import net.minestom.server.utils.MathUtils;
import net.minestom.server.utils.Rotation;
import net.minestom.server.utils.block.CustomBlockUtils;
import net.minestom.server.utils.callback.OptionalCallback;
import net.minestom.server.utils.chunk.ChunkCallback;
@ -21,8 +19,6 @@ import org.slf4j.LoggerFactory;
import java.util.concurrent.CountDownLatch;
import static net.minestom.server.utils.MathUtils.isBetween;
/**
* A Batch used when all of the block changed are contained inside a single chunk.
* If more than one chunk is needed, use an {@link AbsoluteBlockBatch} instead.
@ -36,8 +32,6 @@ import static net.minestom.server.utils.MathUtils.isBetween;
* @see Batch
*/
public class ChunkBatch implements Batch<ChunkCallback> {
private static final int HALF_CHUNK_SIZE = 7;
// private static final int HALF_CHUNK_SIZE = Chunk.CHUNK_SIZE_X / 2;
private static final Logger LOGGER = LoggerFactory.getLogger(ChunkBatch.class);
// Need to be synchronized manually
@ -112,50 +106,6 @@ public class ChunkBatch implements Batch<ChunkCallback> {
}
}
@Override
public ChunkBatch rotate(int degrees) {
return squareRotate((degrees / 90) % 4);
}
@Override
public ChunkBatch rotate(Rotation rotation) {
return squareRotate(rotation.ordinal() / 2);
}
@Override
public ChunkBatch squareRotate(int degree) {
if ((degree %= 4) < 0) degree += 4;
final ChunkBatch rotated = new ChunkBatch(this.options);
synchronized (blocks) {
for (long value : blocks) {
final short customBlockId = (short) (value & 0xFFFF);
final short blockId = (short) ((value >> 16) & 0xFFFF);
final int index = (int) ((value >> 32) & 0xFFFFFFFFL);
Data data = null;
if (!blockDataMap.isEmpty()) {
synchronized (blockDataMap) {
data = blockDataMap.get(index);
}
}
final int x = ChunkUtils.blockIndexToChunkPositionX(index);
final int y = ChunkUtils.blockIndexToChunkPositionY(index);
final int z = ChunkUtils.blockIndexToChunkPositionZ(index);
final int newX = MathUtils.squareRotateX(degree, x, z) + (isBetween(degree, 1, 2) ? 15 : 0);
final int newZ = MathUtils.squareRotateZ(degree, x, z) + (isBetween(degree, 2, 3) ? 15 : 0);
rotated.setSeparateBlocks(newX, y, newZ, blockId, customBlockId, data);
}
}
return rotated;
}
/**
* Apply this batch to chunk (0, 0).
*
@ -249,10 +199,6 @@ public class ChunkBatch implements Batch<ChunkCallback> {
return;
}
if (this.options.isFullChunk()) {
chunk.reset();
}
synchronized (blocks) {
for (long block : blocks) {
apply(chunk, block, inverse);

5
src/main/java/net/minestom/server/instance/batch/ChunkGenerationBatch.java
View File

@ -53,11 +53,6 @@ public class ChunkGenerationBatch extends ChunkBatch {
throw new IllegalStateException("#clear is not supported for chunk generation batch.");
}
@Override
public ChunkBatch squareRotate(int degree) {
throw new IllegalStateException("Rotation is not supported for chunk generation batch.");
}
@Override
protected ChunkBatch apply(@NotNull Instance instance, @NotNull Chunk chunk, @Nullable ChunkCallback callback, boolean safeCallback) {
throw new IllegalStateException("#apply is not supported for chunk generation batch.");

49
src/main/java/net/minestom/server/instance/batch/RelativeBlockBatch.java
View File

@ -7,8 +7,6 @@ import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
import net.minestom.server.data.Data;
import net.minestom.server.instance.Instance;
import net.minestom.server.utils.BlockPosition;
import net.minestom.server.utils.MathUtils;
import net.minestom.server.utils.Rotation;
import net.minestom.server.utils.validate.Check;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@ -102,53 +100,6 @@ public class RelativeBlockBatch implements Batch<Runnable> {
}
}
@Override
public RelativeBlockBatch rotate(int degrees) {
return squareRotate((degrees / 90) % 4);
}
@Override
public RelativeBlockBatch rotate(Rotation rotation) {
return squareRotate(rotation.ordinal() / 2);
}
@Override
public RelativeBlockBatch squareRotate(int degree) {
if ((degree %= 4) < 0) degree += 4;
final RelativeBlockBatch rotated = new RelativeBlockBatch();
rotated.offsetX = this.offsetX;
rotated.offsetY = this.offsetY;
rotated.offsetZ = this.offsetZ;
synchronized (blockIdMap) {
for (Long2IntMap.Entry entry : blockIdMap.long2IntEntrySet()) {
final long pos = entry.getLongKey();
final short relZ = (short) (pos & 0xFFFF);
final short relY = (short) ((pos >> 16) & 0xFFFF);
final short relX = (short) ((pos >> 32) & 0xFFFF);
final int ids = entry.getIntValue();
final short customBlockId = (short) (ids & 0xFFFF);
final short blockStateId = (short) ((ids >> 16) & 0xFFFF);
Data data = null;
if (!blockDataMap.isEmpty()) {
synchronized (blockDataMap) {
data = blockDataMap.get(pos);
}
}
final int finalX = MathUtils.squareRotateX(degree, relX, relZ);
final int finalZ = MathUtils.squareRotateZ(degree, relX, relZ);
rotated.setSeparateBlocks(finalX, relY, finalZ, blockStateId, customBlockId, data);
}
}
return rotated;
}
/**
* Applies this batch to the given instance at the origin (0, 0, 0) of the instance.
*

10
src/main/java/net/minestom/server/utils/MathUtils.java
View File

@ -94,14 +94,4 @@ public final class MathUtils {
public static double mod(final double a, final double b) {
return (a % b + b) % b;
}
private static final int[] MAGIC_TRIG = {0, 1, 0, -1};
public static int squareRotateX(int degree, int x, int z) {
return MAGIC_TRIG[(degree + 1) % 4]*x - MAGIC_TRIG[degree]*z;
}
public static int squareRotateZ(int degree, int x, int z) {
return MAGIC_TRIG[degree]*x + MAGIC_TRIG[(degree + 1) % 4]*z;
}
}

51
src/test/java/demo/commands/CubeBatchCommand.java
View File

@ -16,8 +16,6 @@ import net.minestom.server.instance.block.Block;
import net.minestom.server.utils.time.TimeUnit;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
public class CubeBatchCommand extends Command {
@ -39,55 +37,8 @@ public class CubeBatchCommand extends Command {
Player player = sender.asPlayer();
InstanceContainer instance = (InstanceContainer) player.getInstance();
RelativeBlockBatch rotBatch = new RelativeBlockBatch();
for (int x = 0; x < 50; x += 2) {
for (int y = 0; y < 50; y += 2) {
for (int z = 0; z < 10; z += 2) {
rotBatch.setBlockStateId(x, y, z, Block.BLUE_CONCRETE.getBlockId());
}
}
}
rotBatch.apply(instance, 50, 50, 50, null);
rotBatch.rotate(90).apply(instance, 50, 50, 50, null);
rotBatch.rotate(180).apply(instance, 50, 50, 50, null);
rotBatch.rotate(270).apply(instance, 50, 50, 50, null);
// ChunkBatch rotBatch = new ChunkBatch(new BatchOption().setFullChunk(true));
// for (int x = 0; x < 16; x += 2) {
// for (int y = 0; y < 50; y += 2) {
// for (int z = 0; z < 8; z += 2) {
// rotBatch.setBlockStateId(x, y + 50, z, Block.BLUE_CONCRETE.getBlockId());
// }
// }
// }
//
// for (int i = 0; i < 4; i++) {
// rotBatch.apply(instance, 1, i * 2, null);
// rotBatch = rotBatch.squareRotate(1);
// }
// for (int x = 0; x < 10; x++) {
// for (int z = 0; z < 10; z++) {
// final int chunkX = x - 5;
// final int chunkZ = z - 5;
//
// AtomicReference<ChunkBatch> b = new AtomicReference<>(rotBatch.rotate(0));
// MinecraftServer.getSchedulerManager().buildTask(() -> {
// final ChunkBatch current = b.get();
// final ChunkBatch next = current.rotate(90);
// b.set(next);
// next.apply(instance, chunkX, chunkZ, null);
//
// }).delay(10, TimeUnit.TICK).repeat(ThreadLocalRandom.current().nextInt(10) + 1, TimeUnit.TICK).schedule();
// }
// }
// applyChunkShape(instance);
// applyBlockShape(instance);
applyBlockShape(instance);
// AbsoluteBlockBatch batch = new AbsoluteBlockBatch();
//