upstream/StructureLib
1
0 Fork 0
mirror of https://github.com/GTNewHorizons/StructureLib.git synced 2026-11-11 15:57:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

minor refactor to alignment subsystem

Browse Source 
1. Moved package private utility methods (?!) into public API
2. Actual builder pattern
This commit is contained in:
Glease committed 2021-05-27 18:26:05 +08:00
1 parent c597fda09d
commit 59d311edb2
3 files changed
+114 -176
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/main/java/com/gtnewhorizon/structurelib/alignment/AlignmentLimits.java
+5 -169
View File
@@ -1,183 +1,19 @@
package com.gtnewhorizon.structurelib.alignment;
import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
import com.gtnewhorizon.structurelib.alignment.enumerable.Flip;
import com.gtnewhorizon.structurelib.alignment.enumerable.Rotation;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.Arrays;
import java.util.Optional;
import java.util.Random;
import java.util.function.Function;
class AlignmentLimits implements IAlignmentLimits {
import static com.gtnewhorizon.structurelib.alignment.IAlignment.STATES_COUNT;
protected final boolean[] validStates;
public class AlignmentLimits implements IAlignmentLimits {
protected final boolean[] validStates=new boolean[STATES_COUNT];
public AlignmentLimits() {
allowAll();
}
AlignmentLimits allowAll(){
Arrays.fill(validStates,true);
return this;
}
AlignmentLimits denyAll(){
Arrays.fill(validStates,false);
return this;
}
AlignmentLimits randomAll(Random random){
for (int i = 0; i < validStates.length; i++) {
validStates[i]=random.nextBoolean();
}
return this;
}
AlignmentLimits deny(ExtendedFacing... deny){
if(deny!=null){
for (ExtendedFacing extendedFacing : deny) {
validStates[extendedFacing.getIndex()]=false;
}
}
return this;
}
AlignmentLimits allow(ExtendedFacing... allow){
if(allow!=null){
for (ExtendedFacing extendedFacing : allow) {
validStates[extendedFacing.getIndex()]=false;
}
}
return this;
}
AlignmentLimits deny(ForgeDirection... deny){
if(deny!=null){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
for (ForgeDirection direction : deny) {
if (value.getDirection() == direction) {
validStates[value.getIndex()] = false;
break;
}
}
}
}
return this;
}
AlignmentLimits allow(ForgeDirection... allow){
if(allow!=null){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
for (ForgeDirection direction : allow) {
if (value.getDirection() == direction) {
validStates[value.getIndex()] = true;
break;
}
}
}
}
return this;
}
AlignmentLimits deny(Rotation... deny){
if(deny!=null){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
for (Rotation rotation : deny) {
if (value.getRotation() == rotation) {
validStates[value.getIndex()] = false;
break;
}
}
}
}
return this;
}
AlignmentLimits allow(Rotation... allow){
if(allow!=null){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
for (Rotation rotation : allow) {
if (value.getRotation() == rotation) {
validStates[value.getIndex()] = true;
break;
}
}
}
}
return this;
}
AlignmentLimits deny(Flip... deny){
if(deny!=null){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
for (Flip flip : deny) {
if (value.getFlip() == flip) {
validStates[value.getIndex()] = false;
break;
}
}
}
}
return this;
}
AlignmentLimits allow(Flip... allow){
if(allow!=null){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
for (Flip flip : allow) {
if (value.getFlip() == flip) {
validStates[value.getIndex()] = true;
break;
}
}
}
}
return this;
}
AlignmentLimits predicateApply(Function<ExtendedFacing,Optional<Boolean>> predicate){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
predicate.apply(value).ifPresent(bool->validStates[value.getIndex()]=bool);
}
return this;
}
AlignmentLimits ensureDuplicates(){
for (ExtendedFacing value : ExtendedFacing.VALUES) {
if(validStates[value.getIndex()]){
validStates[value.getDuplicate().getIndex()]=true;
}
}
return this;
}
/**
* Prefers rotation over flip, so both flip will get translated to opposite rotation and no flip
* @param flip the preferred flip to be used Horizontal or vertical
* @return this
*/
AlignmentLimits ensureNoDuplicates(Flip flip){
if(flip==Flip.BOTH||flip==Flip.NONE){
throw new IllegalArgumentException("Preffered Flip must be Horizontal or Vertical");
}
flip=flip.getOpposite();
for (ExtendedFacing value : ExtendedFacing.VALUES) {
if(validStates[value.getIndex()]){
if(value.getFlip()==Flip.BOTH || value.getFlip()==flip){
validStates[value.getIndex()]=false;
validStates[value.getDuplicate().getIndex()]=true;
}
}
}
return this;
AlignmentLimits(boolean[] validStates) {
this.validStates = validStates;
}
@Override
public boolean isNewExtendedFacingValid(ForgeDirection direction, Rotation rotation, Flip flip) {
return validStates[IAlignment.getAlignmentIndex(direction,rotation,flip)];
return validStates[IAlignment.getAlignmentIndex(direction, rotation, flip)];
}
}
src/main/java/com/gtnewhorizon/structurelib/alignment/IAlignmentLimits.java
+96 -2
View File
@@ -4,16 +4,110 @@ import com.gtnewhorizon.structurelib.alignment.enumerable.Flip;
import com.gtnewhorizon.structurelib.alignment.enumerable.Rotation;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.Arrays;
import java.util.Optional;
import java.util.function.Function;
import static com.gtnewhorizon.structurelib.alignment.IAlignment.STATES_COUNT;
public interface IAlignmentLimits {
IAlignmentLimits UNLIMITED= (direction, rotation, flip) -> true;
IAlignmentLimits UNLIMITED = (direction, rotation, flip) -> true;
boolean isNewExtendedFacingValid(ForgeDirection direction, Rotation rotation, Flip flip);
default boolean isNewExtendedFacingValid(ExtendedFacing alignment){
default boolean isNewExtendedFacingValid(ExtendedFacing alignment) {
return isNewExtendedFacingValid(
alignment.getDirection(),
alignment.getRotation(),
alignment.getFlip());
}
class Builder {
protected final boolean[] validStates = new boolean[STATES_COUNT];
public static Builder allowAll() {
Builder b = new Builder();
Arrays.fill(b.validStates, true);
return b;
}
public static Builder denyAll() {
Builder b = new Builder();
Arrays.fill(b.validStates, true);
return b;
}
public Builder deny(ForgeDirection fd) {
ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = false);
return this;
}
public Builder allow(ForgeDirection fd) {
ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = true);
return this;
}
public Builder deny(Rotation fd) {
ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = false);
return this;
}
public Builder allow(Rotation fd) {
ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = true);
return this;
}
public Builder deny(Flip fd) {
ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = false);
return this;
}
public Builder allow(Flip fd) {
ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = true);
return this;
}
public Builder filter(Function<ExtendedFacing, Optional<Boolean>> predicate) {
for (ExtendedFacing value : ExtendedFacing.VALUES) {
predicate.apply(value).ifPresent(bool -> validStates[value.getIndex()] = bool);
}
return this;
}
public Builder ensureDuplicates() {
for (ExtendedFacing value : ExtendedFacing.VALUES) {
if (validStates[value.getIndex()]) {
validStates[value.getDuplicate().getIndex()] = true;
}
}
return this;
}
/**
* Prefers rotation over flip, so both flip will get translated to opposite rotation and no flip
*
* @param flip the preferred flip to be used Horizontal or vertical
* @return this
*/
public Builder ensureNoDuplicates(Flip flip) {
if (flip == Flip.BOTH || flip == Flip.NONE) {
throw new IllegalArgumentException("Preffered Flip must be Horizontal or Vertical");
}
flip = flip.getOpposite();
for (ExtendedFacing value : ExtendedFacing.VALUES) {
if (validStates[value.getIndex()]) {
if (value.getFlip() == Flip.BOTH || value.getFlip() == flip) {
validStates[value.getIndex()] = false;
validStates[value.getDuplicate().getIndex()] = true;
}
}
}
return this;
}
public IAlignmentLimits build() {
return new AlignmentLimits(validStates);
}
}
}
src/main/java/com/gtnewhorizon/structurelib/alignment/enumerable/ExtendedFacing.java
+13 -5
View File
@@ -1,5 +1,6 @@
package com.gtnewhorizon.structurelib.alignment.enumerable;
import com.google.common.collect.ImmutableSet;
import com.gtnewhorizon.structurelib.alignment.IAlignment;
import com.gtnewhorizon.structurelib.alignment.IntegerAxisSwap;
import com.gtnewhorizon.structurelib.util.Vec3Impl;
@@ -12,7 +13,7 @@ import static com.gtnewhorizon.structurelib.alignment.IAlignment.FLIPS_COUNT;
import static com.gtnewhorizon.structurelib.alignment.IAlignment.ROTATIONS_COUNT;
import static java.lang.Math.abs;
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toMap;
import static java.util.stream.Collectors.*;
public enum ExtendedFacing {
DOWN_NORMAL_NONE("down normal none"),
@@ -117,18 +118,21 @@ public enum ExtendedFacing {
public static final Map<ForgeDirection, List<ExtendedFacing>> FOR_FACING=new HashMap<>();
static {
stream(values()).forEach(extendedFacing ->
FOR_FACING.compute(extendedFacing.direction,((forgeDirection, extendedFacings) -> {
if(extendedFacings==null){
FOR_FACING.compute(extendedFacing.direction, ((forgeDirection, extendedFacings) -> {
if (extendedFacings == null) {
extendedFacings = new ArrayList<>();
}
extendedFacings.add(extendedFacing);
return extendedFacings;
})));
}
private static final Map<String, ExtendedFacing> NAME_LOOKUP = stream(VALUES).collect(toMap(ExtendedFacing::getName2, (extendedFacing) -> extendedFacing));
private static final Map<String, ExtendedFacing> NAME_LOOKUP = stream(VALUES).collect(toMap(ExtendedFacing::getName2, (extendedFacing) -> extendedFacing));
private static final EnumMap<ForgeDirection, ImmutableSet<ExtendedFacing>> LOOKUP_BY_DIRECTION = stream(VALUES).collect(groupingBy(ExtendedFacing::getDirection, () -> new EnumMap<>(ForgeDirection.class), collectingAndThen(toSet(), ImmutableSet::copyOf)));
private static final EnumMap<Rotation, ImmutableSet<ExtendedFacing>> LOOKUP_BY_ROTATION = stream(VALUES).collect(groupingBy(ExtendedFacing::getRotation, () -> new EnumMap<>(Rotation.class), collectingAndThen(toSet(), ImmutableSet::copyOf)));
private static final EnumMap<Flip, ImmutableSet<ExtendedFacing>> LOOKUP_BY_FLIP = stream(VALUES).collect(groupingBy(ExtendedFacing::getFlip, () -> new EnumMap<>(Flip.class), collectingAndThen(toSet(), ImmutableSet::copyOf)));
private final ForgeDirection direction;
private final ForgeDirection a,b,c;
private final ForgeDirection a, b, c;
private final Rotation rotation;
private final Flip flip;
@@ -227,6 +231,10 @@ public enum ExtendedFacing {
return VALUES[IAlignment.getAlignmentIndex(direction, Rotation.NORMAL, Flip.NONE)];
}
public static ImmutableSet<ExtendedFacing> getAllWith(ForgeDirection direction) { return LOOKUP_BY_DIRECTION.get(direction);}
public static ImmutableSet<ExtendedFacing> getAllWith(Rotation rotation) { return LOOKUP_BY_ROTATION.get(rotation);}
public static ImmutableSet<ExtendedFacing> getAllWith(Flip flip) { return LOOKUP_BY_FLIP.get(flip);}
public ExtendedFacing with(ForgeDirection direction){
return of(direction,rotation,flip);
}