Skip to content

Commit

Permalink
Add BiList#of Methods And TriList#of Methods
Browse files Browse the repository at this point in the history 
Finish CustomDoubleWidthBlock
Fix OrientedBlockPos
  • Loading branch information
@FirstMegaGame4
FirstMegaGame4 committed Nov 11, 2023
1 parent c19aa0e commit 46d686d
Show file tree
Hide file tree
Showing 4 changed files with 157 additions and 45 deletions.
20 changes: 11 additions & 9 deletions src/main/java/com/mmodding/mmodding_lib/library/blocks/CustomDoubleWidthBlock.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,8 +24,8 @@
import org.jetbrains.annotations.Nullable;
import org.quiltmc.qsl.item.setting.api.QuiltItemSettings;

import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;

public class CustomDoubleWidthBlock extends Block implements BlockRegistrable, BlockWithItem {

Expand Down Expand Up @@ -60,31 +60,33 @@ public BlockState getPlacementState(ItemPlacementContext ctx) {
OrientedBlockPos oriented = OrientedBlockPos.of(ctx.getBlockPos()).apply(ctx.getPlayerFacing());
boolean validOrigin = ctx.getWorld().getBlockState(oriented).canReplace(ctx);
boolean validSub0 = ctx.getWorld().getBlockState(oriented.front()).canReplace(ctx);
boolean validSub1 = ctx.getWorld().getBlockState(oriented.front().right()).canReplace(ctx);
boolean validSub2 = ctx.getWorld().getBlockState(oriented.right()).canReplace(ctx);
boolean validSub1 = ctx.getWorld().getBlockState(oriented.front().left()).canReplace(ctx);
boolean validSub2 = ctx.getWorld().getBlockState(oriented.left()).canReplace(ctx);
return validOrigin && validSub0 && validSub1 && validSub2 ? this.getDefaultState().with(PART, DoubleWidthPart.ORIGIN).with(FACING, ctx.getPlayerFacing()) : null;
}

@Override
public void onPlaced(World world, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack itemStack) {
super.onPlaced(world, pos, state, placer, itemStack);
if (!world.isClient()) {
OrientedBlockPos oriented = OrientedBlockPos.of(pos).apply(state.get(FACING));
world.setBlockState(oriented.front(), state.with(PART, DoubleWidthPart.SUB_PART_0), Block.NOTIFY_ALL);
world.setBlockState(oriented.front().right(), state.with(PART, DoubleWidthPart.SUB_PART_1), Block.NOTIFY_ALL);
world.setBlockState(oriented.right(), state.with(PART, DoubleWidthPart.SUB_PART_2), Block.NOTIFY_ALL);
world.setBlockState(oriented.front().left(), state.with(PART, DoubleWidthPart.SUB_PART_1), Block.NOTIFY_ALL);
world.setBlockState(oriented.left(), state.with(PART, DoubleWidthPart.SUB_PART_2), Block.NOTIFY_ALL);
world.updateNeighbors(pos, Blocks.AIR);
state.updateNeighbors(world, pos, Block.NOTIFY_ALL);
}
}

@Override
public void onBreak(World world, BlockPos pos, BlockState state, PlayerEntity player) {
super.onBreak(world, pos, state, player);
if (!world.isClient()) {
OrientedBlockPos origin = state.get(PART).toOrigin(pos, state.get(FACING));
world.setBlockState(origin, Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL | Block.SKIP_DROPS);
world.setBlockState(origin.front(), Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL | Block.SKIP_DROPS);
world.setBlockState(origin.front().right(), Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL | Block.SKIP_DROPS);
world.setBlockState(origin.right(), Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL | Block.SKIP_DROPS);
world.setBlockState(origin.front().left(), Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL | Block.SKIP_DROPS);
world.setBlockState(origin.left(), Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL | Block.SKIP_DROPS);
world.syncWorldEvent(player, WorldEvents.BLOCK_BROKEN, pos, Block.getRawIdFromState(state));
}
}
Expand Down Expand Up @@ -128,8 +130,8 @@ public void setRegistered() {
public enum DoubleWidthPart implements Opposable<DoubleWidthPart>, StringIdentifiable {
ORIGIN((oriented) -> oriented),
SUB_PART_0(OrientedBlockPos::behind),
SUB_PART_1((oriented) -> oriented.behind().left()),
SUB_PART_2(OrientedBlockPos::left);
SUB_PART_1((oriented) -> oriented.behind().right()),
SUB_PART_2(OrientedBlockPos::right);

private final TweakFunction<OrientedBlockPos> tweak;

Expand Down
48 changes: 12 additions & 36 deletions src/main/java/com/mmodding/mmodding_lib/library/math/OrientedBlockPos.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -54,62 +54,62 @@ public static WithoutOrientation of(Vec3i vec3i) {

public OrientedBlockPos top() {
Direction transformed = NonOriented.TOP.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed));
return new OrientedBlockPos(this.direction, super.offset(transformed));
}

public OrientedBlockPos top(int i) {
Direction transformed = NonOriented.TOP.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed, i));
return new OrientedBlockPos(this.direction, super.offset(transformed, i));
}

public OrientedBlockPos bottom() {
Direction transformed = NonOriented.BOTTOM.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed));
return new OrientedBlockPos(this.direction, super.offset(transformed));
}

public OrientedBlockPos bottom(int i) {
Direction transformed = NonOriented.BOTTOM.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed, i));
return new OrientedBlockPos(this.direction, super.offset(transformed, i));
}

public OrientedBlockPos front() {
Direction transformed = NonOriented.FRONT.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed));
return new OrientedBlockPos(this.direction, super.offset(transformed));
}

public OrientedBlockPos front(int i) {
Direction transformed = NonOriented.FRONT.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed, i));
return new OrientedBlockPos(this.direction, super.offset(transformed, i));
}

public OrientedBlockPos behind() {
Direction transformed = NonOriented.BEHIND.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed));
return new OrientedBlockPos(this.direction, super.offset(transformed));
}

public OrientedBlockPos behind(int i) {
Direction transformed = NonOriented.BEHIND.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed, i));
return new OrientedBlockPos(this.direction, super.offset(transformed, i));
}

public OrientedBlockPos left() {
Direction transformed = NonOriented.LEFT.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed));
return new OrientedBlockPos(this.direction, super.offset(transformed));
}

public OrientedBlockPos left(int i) {
Direction transformed = NonOriented.LEFT.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed, i));
return new OrientedBlockPos(this.direction, super.offset(transformed, i));
}

public OrientedBlockPos right() {
Direction transformed = NonOriented.RIGHT.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed));
return new OrientedBlockPos(this.direction, super.offset(transformed));
}

public OrientedBlockPos right(int i) {
Direction transformed = NonOriented.RIGHT.transform(this.direction);
return new OrientedBlockPos(transformed, super.offset(transformed, i));
return new OrientedBlockPos(this.direction, super.offset(transformed, i));
}

public OrientedBlockPos rotateClockwise(Direction.Axis axis) {
Expand Down Expand Up @@ -192,30 +192,6 @@ public BlockPos east(int i) {
throw new UnsupportedOperationException();
}

@Override
@Deprecated
public BlockPos offset(Direction direction) {
throw new UnsupportedOperationException();
}

@Override
@Deprecated
public BlockPos offset(Direction direction, int i) {
throw new UnsupportedOperationException();
}

@Override
@Deprecated
public BlockPos offset(Direction.Axis axis, int i) {
throw new UnsupportedOperationException();
}

@Override
@Deprecated
public OrientedBlockPos rotate(BlockRotation rotation) {
throw new UnsupportedOperationException();
}

public static class WithoutOrientation {

private final Status status;
Expand Down
67 changes: 67 additions & 0 deletions src/main/java/com/mmodding/mmodding_lib/library/utils/BiList.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,7 @@
import org.apache.commons.lang3.tuple.Pair;

import java.util.List;
import java.util.Objects;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

Expand Down Expand Up @@ -34,4 +35,70 @@ static <E1, E2> Pair<E1, E2> emptyValue() {
void forEachSecond(Consumer<? super E2> action);

void forEach(BiConsumer<? super E1, ? super E2> action);

@SuppressWarnings("unchecked")
static <E1, E2> BiList<E1, E2> generateBiListFromTrustedArray(Object... input) {
if (input.length % 2 != 0) {
throw new IllegalArgumentException("Input Object must be a multiplier of 2");
}

assert input.getClass() == Object[].class;

for (Object o : input) {
Objects.requireNonNull(o);
}

BiList<E1, E2> biList = new BiArrayList<>();

for (int i = 0; i < input.length / 2; i++) {
biList.add((E1) input[i * 2], (E2) input[i * 2 + 1]);
}

return biList;
}

@SafeVarargs
static <E> BiList<E, E> of(E... e) {
return BiList.generateBiListFromTrustedArray((Object) e);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02) {
return BiList.generateBiListFromTrustedArray(e01, e02);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32, E1 e41, E2 e42) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32, e41, e42);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32, E1 e41, E2 e42, E1 e51, E2 e52) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32, e41, e42, e51, e52);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32, E1 e41, E2 e42, E1 e51, E2 e52, E1 e61, E2 e62) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32, e41, e42, e51, e52, e61, e62);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32, E1 e41, E2 e42, E1 e51, E2 e52, E1 e61, E2 e62, E1 e71, E2 e72) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32, e41, e42, e51, e52, e61, e62, e71, e72);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32, E1 e41, E2 e42, E1 e51, E2 e52, E1 e61, E2 e62, E1 e71, E2 e72, E1 e81, E2 e82) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32, e41, e42, e51, e52, e61, e62, e71, e72, e81, e82);
}

static <E1, E2> BiList<E1, E2> of(E1 e01, E2 e02, E1 e11, E2 e12, E1 e21, E2 e22, E1 e31, E2 e32, E1 e41, E2 e42, E1 e51, E2 e52, E1 e61, E2 e62, E1 e71, E2 e72, E1 e81, E2 e82, E1 e91, E2 e92) {
return BiList.generateBiListFromTrustedArray(e01, e02, e11, e12, e21, e22, e31, e32, e41, e42, e51, e52, e61, e62, e71, e72, e81, e82, e91, e92);
}
}
67 changes: 67 additions & 0 deletions src/main/java/com/mmodding/mmodding_lib/library/utils/TriList.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@
import org.apache.logging.log4j.util.TriConsumer;

import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;

public interface TriList<E1, E2, E3> extends List<Triple<E1, E2, E3>> {
Expand Down Expand Up @@ -40,4 +41,70 @@ static <E1, E2, E3> Triple<E1, E2, E3> emptyValue() {
void forEachThird(Consumer<? super E3> action);

void forEach(TriConsumer<? super E1, ? super E2, ? super E3> action);

@SuppressWarnings("unchecked")
static <E1, E2, E3> TriList<E1, E2, E3> generateTriListFromTrustedArray(Object... input) {
if (input.length % 3 != 0) {
throw new IllegalArgumentException("Input Object must be a multiplier of 3");
}

assert input.getClass() == Object[].class;

for (Object o : input) {
Objects.requireNonNull(o);
}

TriList<E1, E2, E3> biList = new TriArrayList<>();

for (int i = 0; i < input.length / 3; i++) {
biList.add((E1) input[i * 3], (E2) input[i * 3 + 1], (E3) input[i * 3 + 2]);
}

return biList;
}

@SafeVarargs
static <E> TriList<E, E, E> of(E... e) {
return TriList.generateTriListFromTrustedArray((Object) e);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33, E1 e41, E2 e42, E3 e43) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33, e41, e42, e43);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33, E1 e41, E2 e42, E3 e43, E1 e51, E2 e52, E3 e53) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33, e41, e42, e43, e51, e52, e53);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33, E1 e41, E2 e42, E3 e43, E1 e51, E2 e52, E3 e53, E1 e61, E2 e62, E3 e63) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33, e41, e42, e43, e51, e52, e53, e61, e62, e63);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33, E1 e41, E2 e42, E3 e43, E1 e51, E2 e52, E3 e53, E1 e61, E2 e62, E3 e63, E1 e71, E2 e72, E3 e73) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33, e41, e42, e43, e51, e52, e53, e61, e62, e63, e71, e72, e73);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33, E1 e41, E2 e42, E3 e43, E1 e51, E2 e52, E3 e53, E1 e61, E2 e62, E3 e63, E1 e71, E2 e72, E3 e73, E1 e81, E2 e82, E3 e83) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33, e41, e42, e43, e51, e52, e53, e61, e62, e63, e71, e72, e73, e81, e82, e83);
}

static <E1, E2, E3> TriList<E1, E2, E3> of(E1 e01, E2 e02, E3 e03, E1 e11, E2 e12, E3 e13, E1 e21, E2 e22, E3 e23, E1 e31, E2 e32, E3 e33, E1 e41, E2 e42, E3 e43, E1 e51, E2 e52, E3 e53, E1 e61, E2 e62, E3 e63, E1 e71, E2 e72, E3 e73, E1 e81, E2 e82, E3 e83, E1 e91, E2 e92, E3 e93) {
return TriList.generateTriListFromTrustedArray(e01, e02, e03, e11, e12, e13, e21, e22, e23, e31, e32, e33, e41, e42, e43, e51, e52, e53, e61, e62, e63, e71, e72, e73, e81, e82, e83, e91, e92, e93);
}
}

0 comments on commit 46d686d

Please sign in to comment.