resent-1.8/src/main/java/net/minecraft/block/state/BlockState.java
2023-01-14 15:56:36 +00:00

189 lines
7.4 KiB
Java

package net.minecraft.block.state;
import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.base.Objects;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableTable;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import net.minecraft.block.Block;
import net.minecraft.block.properties.IProperty;
import net.minecraft.util.Cartesian;
import net.minecraft.util.MapPopulator;
/**+
* This portion of EaglercraftX contains deobfuscated Minecraft 1.8 source code.
*
* Minecraft 1.8.8 bytecode is (c) 2015 Mojang AB. "Do not distribute!"
* Mod Coder Pack v9.18 deobfuscation configs are (c) Copyright by the MCP Team
*
* EaglercraftX 1.8 patch files are (c) 2022-2023 LAX1DUDE. All Rights Reserved.
*
* WITH THE EXCEPTION OF PATCH FILES, MINIFIED JAVASCRIPT, AND ALL FILES
* NORMALLY FOUND IN AN UNMODIFIED MINECRAFT RESOURCE PACK, YOU ARE NOT ALLOWED
* TO SHARE, DISTRIBUTE, OR REPURPOSE ANY FILE USED BY OR PRODUCED BY THE
* SOFTWARE IN THIS REPOSITORY WITHOUT PRIOR PERMISSION FROM THE PROJECT AUTHOR.
*
* NOT FOR COMMERCIAL OR MALICIOUS USE
*
* (please read the 'LICENSE' file this repo's root directory for more info)
*
*/
public class BlockState {
private static final Joiner COMMA_JOINER = Joiner.on(", ");
private static final Function<IProperty, String> GET_NAME_FUNC = new Function<IProperty, String>() {
public String apply(IProperty iproperty) {
return iproperty == null ? "<NULL>" : iproperty.getName();
}
};
private final Block block;
private final ImmutableList<IProperty> properties;
private final ImmutableList<IBlockState> validStates;
public BlockState(Block blockIn, IProperty... properties) {
this.block = blockIn;
Arrays.sort(
properties,
new Comparator<IProperty>() {
public int compare(IProperty iproperty, IProperty iproperty1) {
return iproperty.getName().compareTo(iproperty1.getName());
}
}
);
this.properties = ImmutableList.copyOf(properties);
LinkedHashMap linkedhashmap = Maps.newLinkedHashMap();
ArrayList<BlockState.StateImplementation> arraylist = Lists.newArrayList();
for (List list : Cartesian.cartesianProduct(this.getAllowedValues())) {
Map map = MapPopulator.createMap(this.properties, list);
BlockState.StateImplementation blockstate$stateimplementation = new BlockState.StateImplementation(blockIn, ImmutableMap.copyOf(map));
linkedhashmap.put(map, blockstate$stateimplementation);
arraylist.add(blockstate$stateimplementation);
}
for (BlockState.StateImplementation blockstate$stateimplementation1 : arraylist) {
blockstate$stateimplementation1.buildPropertyValueTable(linkedhashmap);
}
this.validStates = ImmutableList.copyOf(arraylist);
}
public ImmutableList<IBlockState> getValidStates() {
return this.validStates;
}
private List<Iterable<Comparable>> getAllowedValues() {
ArrayList arraylist = Lists.newArrayList();
for (int i = 0; i < this.properties.size(); ++i) {
arraylist.add(((IProperty) this.properties.get(i)).getAllowedValues());
}
return arraylist;
}
public IBlockState getBaseState() {
return (IBlockState) this.validStates.get(0);
}
public Block getBlock() {
return this.block;
}
public Collection<IProperty> getProperties() {
return this.properties;
}
public String toString() {
return Objects.toStringHelper(this).add("block", Block.blockRegistry.getNameForObject(this.block)).add("properties", Iterables.transform(this.properties, GET_NAME_FUNC)).toString();
}
static class StateImplementation extends BlockStateBase {
private final Block block;
private final ImmutableMap<IProperty, Comparable> properties;
private ImmutableTable<IProperty, Comparable, IBlockState> propertyValueTable;
private StateImplementation(Block blockIn, ImmutableMap<IProperty, Comparable> propertiesIn) {
this.block = blockIn;
this.properties = propertiesIn;
}
public Collection<IProperty> getPropertyNames() {
return Collections.unmodifiableCollection(this.properties.keySet());
}
public <T extends Comparable<T>> T getValue(IProperty<T> iproperty) {
if (!this.properties.containsKey(iproperty)) {
throw new IllegalArgumentException("Cannot get property " + iproperty + " as it does not exist in " + this.block.getBlockState());
} else {
return (T) ((Comparable) iproperty.getValueClass().cast(this.properties.get(iproperty)));
}
}
public <T extends Comparable<T>, V extends T> IBlockState withProperty(IProperty<T> iproperty, V comparable) {
if (!this.properties.containsKey(iproperty)) {
throw new IllegalArgumentException("Cannot set property " + iproperty + " as it does not exist in " + this.block.getBlockState());
} else if (!iproperty.getAllowedValues().contains(comparable)) {
throw new IllegalArgumentException("Cannot set property " + iproperty + " to " + comparable + " on block " + Block.blockRegistry.getNameForObject(this.block) + ", it is not an allowed value");
} else {
return (IBlockState) (this.properties.get(iproperty) == comparable ? this : (IBlockState) this.propertyValueTable.get(iproperty, comparable));
}
}
public ImmutableMap<IProperty, Comparable> getProperties() {
return this.properties;
}
public Block getBlock() {
return this.block;
}
public boolean equals(Object object) {
return this == object;
}
public int hashCode() {
return this.properties.hashCode();
}
public void buildPropertyValueTable(Map<Map<IProperty, Comparable>, BlockState.StateImplementation> map) {
if (this.propertyValueTable != null) {
throw new IllegalStateException();
} else {
HashBasedTable hashbasedtable = HashBasedTable.create();
for (IProperty iproperty : this.properties.keySet()) {
for (Object comparable : iproperty.getAllowedValues()) {
if (comparable != this.properties.get(iproperty)) {
hashbasedtable.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, (Comparable) comparable)));
}
}
}
this.propertyValueTable = ImmutableTable.copyOf(hashbasedtable);
}
}
private Map<IProperty, Comparable> getPropertiesWithValue(IProperty property, Comparable value) {
HashMap hashmap = Maps.newHashMap(this.properties);
hashmap.put(property, value);
return hashmap;
}
}
}