net.minecraft.state.property.Property Java Examples

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

@Override
public Property<SideOption> getProperty(@Nonnull BlockFace direction) {
    switch (direction) {
        case FRONT:
            return FRONT_SIDE_OPTION;
        case RIGHT:
            return RIGHT_SIDE_OPTION;
        case LEFT:
            return LEFT_SIDE_OPTION;
        case BACK:
            return BACK_SIDE_OPTION;
        case TOP:
            return TOP_SIDE_OPTION;
        case BOTTOM:
            return BOTTOM_SIDE_OPTION;
    }
    throw new NullPointerException();
}
 

private void use(PlayerEntity player, BlockState state, WorldAccess iWorld, BlockPos pos, ItemStack stack) {
    Block block = state.getBlock();
    if (block instanceof Rotatable) {
        StateManager<Block, BlockState> manager = block.getStateManager();
        Collection<Property<?>> collection = manager.getProperties();
        String string_1 = Registry.BLOCK.getId(block).toString();
        if (!collection.isEmpty()) {
            CompoundTag compoundTag_1 = stack.getOrCreateSubTag("wrenchProp");
            String string_2 = compoundTag_1.getString(string_1);
            Property<?> property = manager.getProperty(string_2);
            if (property == null) {
                property = collection.iterator().next();
            }
            if (property.getName().equals("facing")) {
                BlockState blockState_2 = cycle(state, property, player.isSneaking());
                iWorld.setBlockState(pos, blockState_2, 18);
                stack.damage(2, player, (playerEntity) -> playerEntity.sendEquipmentBreakStatus(EquipmentSlot.MAINHAND));
            }
        }
    }
}
 

/**
 * Re-colors this block in the world.
 *
 * @param state   The current state
 * @param world   The world
 * @param pos     Block position
 * @param facing  ??? (this method has no usages)
 * @param color   Color to recolor to.
 * @return if the block was affected
 */
@SuppressWarnings("unchecked")
default boolean recolorBlock(BlockState state, IWorld world, BlockPos pos, Direction facing, DyeColor color) {
	for (Property<?> prop : state.getProperties()) {
		if (prop.getName().equals("color") && prop.getType() == DyeColor.class) {
			DyeColor current = (DyeColor) state.get(prop);

			if (current != color && prop.getValues().contains(color)) {
				world.setBlockState(pos, state.with(((Property<DyeColor>) prop), color), 3);
				return true;
			}
		}
	}

	return false;
}
 

private <T extends Comparable<T>> BlockState setProperty(Property<T> property, String name, String value,
                                                          BlockState bs)
{
    Optional<T> optional = property.parse(value);

    if (optional.isPresent())
    {
        bs = bs.with(property, optional.get());
    }
    else
    {
        throw new InternalExpressionException(value + " is not a valid value for property " + name);
    }
    return bs;
}
 

@Override
public Tag toTag(boolean force)
{
    if (!force) throw new NBTSerializableValue.IncompatibleTypeException(this);
    // follows falling block convertion
    CompoundTag tag =  new CompoundTag();
    CompoundTag state = new CompoundTag();
    BlockState s = getBlockState();
    state.put("Name", StringTag.of(Registry.BLOCK.getId(s.getBlock()).toString()));
    Collection<Property<?>> properties = s.getProperties();
    if (!properties.isEmpty())
    {
        CompoundTag props = new CompoundTag();
        for (Property<?> p: properties)
        {
            props.put(p.getName(), StringTag.of(s.get(p).toString().toLowerCase(Locale.ROOT)));
        }
        state.put("Properties", props);
    }
    tag.put("BlockState", state);
    CompoundTag dataTag = getData();
    if (dataTag != null)
    {
        tag.put("TileEntityData", dataTag);
    }
    return tag;
}
 

@ModifyVariable(method = "add", at = @At("HEAD"), ordinal = 0)
        public Property<?>[] properties(Property<?>[] in) {
//            if (ArrayUtils.contains(in, Properties.WATERLOGGED)) {
//                in=ArrayUtils.add(ArrayUtils.removeElement(in, Properties.WATERLOGGED), SandboxProperties.PROPERTY_FLUIDLOGGABLE);
//            }
            return in;
        }
 

/**
 * Get the rotations that can apply to the block at the specified coordinates. Null means no rotations are possible.
 * Note, this is up to the block to decide. It may not be accurate or representative.
 *
 * @param state The current state
 * @param world The world
 * @param pos   Block position in world
 * @return An array of valid axes to rotate around, or null for none or unknown
 */
@Nullable
default Direction[] getValidRotations(BlockState state, BlockView world, BlockPos pos) {
	for (Property<?> prop : state.getProperties()) {
		if ((prop.getName().equals("facing") || prop.getName().equals("rotation")) && prop.getType() == Direction.class) {
			@SuppressWarnings("unchecked")
			Collection<Direction> values = ((Collection<Direction>) prop.getValues());
			return values.toArray(new Direction[values.size()]);
		}
	}

	return null;
}
 

@SuppressWarnings("unchecked")
private static <T extends Comparable<T>> BlockState addProperty(StateManager<Block, BlockState> stateManager, BlockState state, String propName, String valName) {
    Property<T> prop = (Property<T>) stateManager.getProperty(propName);
    return prop == null ? state : state.with(prop, prop.parse(valName).orElseGet(() -> state.get(prop)));
}
 

@SuppressWarnings("rawtypes")
@Redirect(method = "getAvailableMoisture", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/BlockState;get(Lnet/minecraft/state/property/Property;)Ljava/lang/Comparable;"))
private static Comparable<Integer> redirectHydratedCheck(BlockState blockState, Property property) {
	final IForgeBlockState forgeBlockState = (IForgeBlockState) blockState;
	return forgeBlockState.isFertile(currentWorld.get(), currentBlockPos.get()) ? 1 : 0;
}
 

public static Property convert(org.sandboxpowered.sandbox.api.state.Property property) {
    //TODO: Wrapper
    return (Property) property;
}
 

private AbstractBlockStateMixin(WurstClient wurst, Block object,
	ImmutableMap<Property<?>, Comparable<?>> immutableMap,
	MapCodec<BlockState> mapCodec)
{
	super(object, immutableMap, mapCodec);
}
 

public MixinBlockState(net.minecraft.block.Block object_1, ImmutableMap<Property<?>, Comparable<?>> immutableMap_1) {
    super(object_1, immutableMap_1);
}
 

private static <T extends Comparable<T>> BlockState cycle(BlockState state, Property<T> property, boolean sneaking) {
    return state.with(property, cycle(property.getValues(), state.get(property), sneaking));
}
 

public abstract Property<SideOption> getProperty(BlockFace direction);