yueh
125 lines
3.9 KiB
Java
125 lines
3.9 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.parts.automation;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import com.google.common.base.Strings;
|
|
|
|
/**
|
|
* Models in which directions - looking at the front face - a plane
|
|
* (annihilation, formation, etc.) is connected to other planes of the same
|
|
* type.
|
|
*/
|
|
public final class PlaneConnections {
|
|
|
|
private final boolean up;
|
|
private final boolean right;
|
|
private final boolean down;
|
|
private final boolean left;
|
|
|
|
private static final int BITMASK_UP = 8;
|
|
private static final int BITMASK_RIGHT = 4;
|
|
private static final int BITMASK_DOWN = 2;
|
|
private static final int BITMASK_LEFT = 1;
|
|
|
|
public static final List<PlaneConnections> PERMUTATIONS = generatePermutations();
|
|
|
|
private static List<PlaneConnections> generatePermutations() {
|
|
List<PlaneConnections> connections = new ArrayList<>(16);
|
|
|
|
for (int i = 0; i < 16; i++) {
|
|
boolean up = (i & BITMASK_UP) != 0;
|
|
boolean right = (i & BITMASK_RIGHT) != 0;
|
|
boolean down = (i & BITMASK_DOWN) != 0;
|
|
boolean left = (i & BITMASK_LEFT) != 0;
|
|
|
|
connections.add(new PlaneConnections(up, right, down, left));
|
|
}
|
|
|
|
return connections;
|
|
}
|
|
|
|
private PlaneConnections(boolean up, boolean right, boolean down, boolean left) {
|
|
this.up = up;
|
|
this.right = right;
|
|
this.down = down;
|
|
this.left = left;
|
|
}
|
|
|
|
public static PlaneConnections of(boolean up, boolean right, boolean down, boolean left) {
|
|
return PERMUTATIONS.get(getIndex(up, right, down, left));
|
|
}
|
|
|
|
public boolean isUp() {
|
|
return this.up;
|
|
}
|
|
|
|
public boolean isRight() {
|
|
return this.right;
|
|
}
|
|
|
|
public boolean isDown() {
|
|
return this.down;
|
|
}
|
|
|
|
public boolean isLeft() {
|
|
return this.left;
|
|
}
|
|
|
|
// The combination of connections expressed as a number ranging from [0,15]
|
|
public int getIndex() {
|
|
return getIndex(this.up, this.right, this.down, this.left);
|
|
}
|
|
|
|
private static int getIndex(boolean up, boolean right, boolean down, boolean left) {
|
|
return (up ? BITMASK_UP : 0) + (right ? BITMASK_RIGHT : 0) + (left ? BITMASK_LEFT : 0)
|
|
+ (down ? BITMASK_DOWN : 0);
|
|
}
|
|
|
|
// Returns a suffix that expresses the connection states as a string
|
|
public String getFilenameSuffix() {
|
|
String suffix = Integer.toBinaryString(this.getIndex());
|
|
return Strings.padStart(suffix, 4, '0');
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) {
|
|
return true;
|
|
}
|
|
if (o == null || this.getClass() != o.getClass()) {
|
|
return false;
|
|
}
|
|
|
|
PlaneConnections that = (PlaneConnections) o;
|
|
return this.up == that.up && this.right == that.right && this.down == that.down && this.left == that.left;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int result = (this.up ? 1 : 0);
|
|
result = 31 * result + (this.right ? 1 : 0);
|
|
result = 31 * result + (this.down ? 1 : 0);
|
|
result = 31 * result + (this.left ? 1 : 0);
|
|
return result;
|
|
}
|
|
}
|