Java BlockState.getType方法代码示例

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
@Override
protected int checkPhysicalLobbySign(Location3D loc) {
    if (loc.getWorld().isPresent()) {
        Optional<World> world = Sponge.getGame().getServer().getWorld(loc.getWorld().get());

        if (world.isPresent()) {
            BlockState blockState = world.get().getBlock(LocationConverter.floor(loc));

            if (blockState.getType() == BlockTypes.STANDING_SIGN
                    || blockState.getType() == BlockTypes.WALL_SIGN) {
                return 0;
            } else {
                InfernoCore.logWarning("Found lobby sign with location not containing a sign block. Removing...");
                return 2;
            }
        } else {
            InfernoCore.logVerbose("Cannot load world \"" + loc.getWorld().get()
                    + "\" - not loading contained lobby sign");
            return 1;
        }
    } else {
        InfernoCore.logWarning("Found lobby sign in store with invalid location serial. Removing...");
        return 2;
    }
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
@Override
public Optional<AABB> getBlockSelectionBox(int x, int y, int z) {
    final BlockState block = getBlock(x, y, z);
    if (block.getType() == BlockTypes.AIR) {
        return Optional.empty();
    }
    final ObjectProvider<AABB> aabbObjectProvider = ((LanternBlockType) block.getType()).getBoundingBoxProvider();
    if (aabbObjectProvider == null) {
        return Optional.empty();
    }
    final AABB aabb;
    if (aabbObjectProvider instanceof ConstantObjectProvider || aabbObjectProvider instanceof CachedSimpleObjectProvider
            || aabbObjectProvider instanceof SimpleObjectProvider) {
        aabb = aabbObjectProvider.get(block, null, null);
    } else {
        aabb = aabbObjectProvider.get(block, new Location<>(this.world, x, y, z), null);
    }
    return aabb == null ? Optional.empty() : Optional.of(aabb.offset(x, y, z));
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
public static AABB doubleChest(BlockState blockState, @Nullable Location<World> location, @Nullable Direction face) {
    if (location != null) {
        for (Direction direction : Chest.DIRECTIONS) {
            if (blockState.getType() == location.getBlockRelative(direction).getBlock().getType()) {
                switch (direction) {
                    case NORTH:
                        return Chest.CONNECTED_NORTH;
                    case EAST:
                        return Chest.CONNECTED_EAST;
                    case SOUTH:
                        return Chest.CONNECTED_SOUTH;
                    case WEST:
                        return Chest.CONNECTED_WEST;
                    default:
                        throw new IllegalStateException();
                }
            }
        }
    }
    return Chest.DEFAULT;
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
@Override
public void onRemove() {
	super.onRemove();
	Location<World> location = getConsumer().getEntity().getLocation();
	BlockState build = BlockState.builder().blockType(BlockTypes.AIR).build();

	for (Vector3i vector3i : vector3is) {
		BlockState block = location.getExtent().getBlock(vector3i);
		if (block.getType() == BlockTypes.WEB) {
			location.getExtent().setBlock(
					vector3i,
					build,
					BlockChangeFlag.NONE
			);
		}
	}
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
@Listener(order = Order.POST)
public void onPlayerInteract(InteractBlockEvent event) {
    BlockState state = event.getTargetBlock().getState();
    if (state.getType() == BlockTypes.WALL_SIGN || state.getType() == BlockTypes.STANDING_SIGN) {
        Optional<Player> player = event.getCause().first(Player.class);
        if (!event.getTargetBlock().getLocation().isPresent() || !player.isPresent()) {
            return;
        }
        Location3D loc = WorldLocationConverter.of(event.getTargetBlock().getLocation().get());

        CommonCore.getMinigames().values().forEach(mg -> mg.getArenas().stream()
                .filter(arena -> arena.getLobbySignAt(loc).isPresent()).forEach(arena -> {
                    Optional<Boolean> sneaking = player.get().get(Keys.IS_SNEAKING);
                    if (event instanceof InteractBlockEvent.Primary
                            && sneaking.isPresent() && sneaking.get()
                            || !mg.getConfigValue(ConfigNode.REQUIRE_SNEAK_TO_DESTROY_LOBBY)) {
                        if (player.get().hasPermission(mg.getPlugin() + ".lobby.destroy")
                                || player.get().hasPermission(mg.getPlugin() + ".lobby.*")) {
                            arena.getLobbySignAt(loc).get().unregister();
                            player.get().sendMessage(Text.builder("Unregistered lobby sign")
                                    .color(TextColors.DARK_AQUA).build());
                            return;
                        }
                    }
                    mg.getEventBus().post(new CommonPlayerClickLobbySignEvent(
                            player.get().getUniqueId(),
                            arena.getLobbySignAt(loc).get(),
                            event instanceof InteractBlockEvent.Primary
                                    ? PlayerClickLobbySignEvent.ClickType.LEFT
                                    : PlayerClickLobbySignEvent.ClickType.RIGHT
                    ));
                })
        );
    }
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
private static boolean isTransparent(BlockState blockstate, boolean waterIsTransparent) {
    if (blockstate.getType() == BlockTypes.SNOW_LAYER) {
        return false;
    }

    IBlockState iblockstate = (IBlockState)(Object) blockstate;
    Optional<MatterProperty> matterProperty = blockstate.getProperty(MatterProperty.class);
    if (!waterIsTransparent && matterProperty.isPresent() && matterProperty.get().getValue() == MatterProperty.Matter.LIQUID) {
        return false;
    }
    return !iblockstate.isOpaqueCube();
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
boolean hasSurfaceFluids() {
    Location<World> lesser = this.getLesserBoundaryCorner();
    Location<World> greater = this.getGreaterBoundaryCorner();

    // don't bother for very large claims, too expensive
    if (this.getClaimBlocks() > MAX_AREA) {
        return false;
    }

    int seaLevel = 0; // clean up all fluids in the end

    // respect sea level in normal worlds
    if (lesser.getExtent().getDimension().getType().equals(DimensionTypes.OVERWORLD)) {
        seaLevel = GriefPreventionPlugin.instance.getSeaLevel(lesser.getExtent());
    }

    for (int x = lesser.getBlockX(); x <= greater.getBlockX(); x++) {
        for (int z = lesser.getBlockZ(); z <= greater.getBlockZ(); z++) {
            for (int y = seaLevel - 1; y < lesser.getExtent().getDimension().getBuildHeight(); y++) {
                // dodge the exclusion claim
                BlockState block = lesser.getExtent().getBlock(x, y, z);

                if (block.getType() == BlockTypes.WATER || block.getType() == BlockTypes.FLOWING_WATER
                        || block.getType() == BlockTypes.LAVA || block.getType() == BlockTypes.FLOWING_LAVA) {
                    return true;
                }
            }
        }
    }

    return false;
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
public static int getBlockStateMeta(BlockState state) {
    Integer meta = BLOCKSTATE_META_CACHE.get(state);
    if (meta == null) {
        Block mcBlock = (net.minecraft.block.Block) state.getType();
        meta = mcBlock.getMetaFromState((IBlockState) state);
        BLOCKSTATE_META_CACHE.put(state, meta);
    }
    return meta;
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
private void handleBrokenBlock() {
    final Location<World> location = new Location<>(this.player.getWorld(), this.diggingBlock);

    final CauseStack causeStack = CauseStack.current();
    try (CauseStack.Frame frame = causeStack.pushCauseFrame()) {
        frame.pushCause(this.player);

        // Add context
        frame.addContext(EventContextKeys.PLAYER, this.player);
        frame.addContext(ContextKeys.INTERACTION_LOCATION, location);
        frame.addContext(ContextKeys.BLOCK_LOCATION, location);

        final BehaviorContextImpl context = new BehaviorContextImpl(causeStack);

        final BlockState blockState = location.getBlock();
        final LanternBlockType blockType = (LanternBlockType) blockState.getType();
        if (context.process(blockType.getPipeline().pipeline(BreakBlockBehavior.class),
                (ctx, behavior) -> behavior.tryBreak(blockType.getPipeline(), ctx)).isSuccess()) {
            context.accept();

            this.diggingBlock = null;
            this.diggingBlockType = null;
        } else {
            context.revert();

            // TODO: Resend tile entity data, action data, ... ???
            this.player.sendBlockChange(this.diggingBlock, blockState);
        }
        if (this.lastBreakState != -1) {
            sendBreakUpdate(-1);
        }
    }
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
@Override
public void onBlockChange(int x, int y, int z, BlockState oldBlockState, BlockState newBlockState) {
    final long key = LanternChunk.key(x >> 4, z >> 4);
    final ObservedChunk observedChunk = this.observedChunks.get(key);
    if (observedChunk != null) {
        observedChunk.addBlockChange(() -> new Vector3i(x, y, z));
        if (oldBlockState.getType() != newBlockState.getType()) {
            observedChunk.removeBlockAction(new Vector3i(x, y, z));
        }
    }
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
static PortalState getByBlock(BlockState state) {
	BlockType type = state.getType();
	if (type == BlockTypes.LAVA || type == BlockTypes.FLOWING_LAVA) {
		return LAVA;
	}
	if (type == BlockTypes.WATER || type == BlockTypes.FLOWING_WATER) {
		return WATER;
	}
	return INITIALIZED;
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
private void findLeversAndFloodBlocks() {

    Vector3i min = flashMemoryRoom.getMinimumPoint();
    Vector3i max = flashMemoryRoom.getMaximumPoint();

    int minX = min.getX();
    int minZ = min.getZ();
    int minY = min.getY();
    int maxX = max.getX();
    int maxZ = max.getZ();
    int maxY = max.getY();

    for (int x = minX; x <= maxX; x++) {
      for (int z = minZ; z <= maxZ; z++) {
        for (int y = maxY; y >= minY; --y) {
          BlockState state = getRegion().getExtent().getBlock(x, y, z);
          if (state.getType() == BlockTypes.LEVER) {
            Location<World> loc = new Location<>(getRegion().getExtent(), x, y, z);
            loc.getExtent().setBlock(
                loc.getBlockPosition(),
                state.withTrait(BooleanTraits.LEVER_POWERED, false).orElse(state),
                Cause.source(SkreePlugin.container()).build()
            );

            leverBlocks.put(loc, !Probability.getChance(3));
            for (int i = y; i < maxY; i++) {
              BlockType type = getRegion().getExtent().getBlockType(x, i, z);
              if (type == BlockTypes.AIR) {
                floodBlocks.add(new Location<>(getRegion().getExtent(), x, i, z));
                break;
              }
            }
            break; // One lever a column only
          }
        }
      }
    }
  }
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
public BlockStateView(BlockState value) {
    super(value);

    this.type = value.getType();
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
private void plantTree(ExplosionEvent.Pre event) {
    Location explosionLocation = event.getExplosion().getLocation();
    int x = (int) explosionLocation.getX();
    int y = (int) explosionLocation.getY();
    int z = (int) explosionLocation.getZ();

    //Evaluating the tree type, based on biome
    World world = event.getTargetWorld();
    BiomeType biome = world.getBiome(x, z);
    BiomeGenerationSettings biomeSettings = world.getWorldGenerator().getBiomeSettings(biome);
    List<Forest> forestPopulators = biomeSettings.getPopulators(Forest.class);

    PopulatorObject populator;
    try {
        //There may be multiple tree types in one Biome. Get one per weighted random
        populator = forestPopulators.isEmpty() ? fallbackTreePopulator : forestPopulators.get(0).getTypes().get(random).get(0);
    } catch (Exception e) {
        populator = fallbackTreePopulator;
    }

    //if the explosion happened on level 0, set it to 1, so we can place a dirt block below
    if (y == 0) {
        y = 1;
    }

    Vector3i pos = new Vector3i(x, y, z);
    Vector3i below = new Vector3i(x, y - 1, z);

    Cause genericCause = Cause.of(NamedCause.owner(container));


    //set Dirt block below if possible (Trees cannot be placed without)
    BlockState blockBelow = world.containsBlock(below) ? world.getBlock(below) : null;
    if (blockBelow != null) {
        BlockState blockState = BlockState.builder().blockType(BlockTypes.DIRT).build();

        world.setBlock(below, blockState, genericCause);
    }

    //Remove Grass, redstone, etc.
    BlockState blockOnPosition = world.getBlock(pos);

    Optional<PassableProperty> passableProperty_Op = blockOnPosition.getProperty(PassableProperty.class);
    boolean blockPassable = passableProperty_Op.isPresent() && passableProperty_Op.get().getValue();

    boolean passableBlockRemoved = false;
    if (blockPassable) {
        world.setBlock(pos, BlockState.builder().blockType(BlockTypes.AIR).build(), BlockChangeFlag.NEIGHBOR, genericCause);
        passableBlockRemoved = true;
    }

    boolean treePlaced = false;
    //is the tree placeable?
    if (populator.canPlaceAt(world, x, y, z)) {
        //Place the tree
        populator.placeObject(world, random, x, y, z);
        treePlaced = true;
    } else if (passableBlockRemoved) {
        //Reset passable Block
        world.setBlock(pos, blockOnPosition, genericCause);

    }

    //Replace block below with original Block (unless the tree was placed in mid-air or water)
    if (blockBelow != null && !(treePlaced && (blockBelow.getType() == BlockTypes.AIR ||
            blockBelow.getType() == BlockTypes.WATER ||
            blockBelow.getType() == BlockTypes.FLOWING_WATER))) {
        world.setBlock(below, blockBelow, genericCause);
    }
}
 

import org.spongepowered.api.block.BlockState; //导入方法依赖的package包/类
@Override
public BlockState getBlock() {
    final BlockState block = getLocation().getBlock();
    return block.getType() == BlockTypes.FURNACE || block.getType() == BlockTypes.LIT_FURNACE ? block :
            BlockTypes.FURNACE.getDefaultState();
}