Java TiledMapTileLayer.getOpacity方法代碼示例

import com.badlogic.gdx.maps.tiled.TiledMapTileLayer; //導入方法依賴的package包/類
/**
 * <p>
 * Creates and returns a new {@link TerrainCollisionMap} from the given map.
 * If the map is not a valid Möbius map, the behaviour is undefined.
 * </p>
 * 
 * @param map
 *        The map from which to create a TerrainCollisionMap.
 * @return
 */
public static TerrainCollisionMap generateCollisionMap(TiledMap map, TiledMap mirrorMap) {
	TerrainCollisionMap retVal = null;

	MapLayers layers = map.getLayers();
	MapLayers mirrorLayers = mirrorMap.getLayers();

	TiledMapTileLayer egLayer = (TiledMapTileLayer) layers.get(0);
	HashMap<TiledMapTileLayer, PlatformManipulationHandler> platformLayers = new HashMap<TiledMapTileLayer, PlatformManipulationHandler>();

	ArrayList<Integer> collisionArray = null;

	for (int i = 0; i < layers.getCount(); i++) {
		TiledMapTileLayer origLayer = (TiledMapTileLayer) layers.get(i);
		TiledMapTileLayer mirrorLayer = (TiledMapTileLayer) mirrorLayers.get(i);

		if ((LevelEntityFactory.isSolidLayer(origLayer) && LevelEntityFactory.isSolidLayer(mirrorLayer))
				|| (LevelEntityFactory.isInteractableLayer(origLayer) && LevelEntityFactory
						.isInteractableLayer(mirrorLayer))) {
			if (collisionArray == null) {
				collisionArray = generateCollisionArray(origLayer, mirrorLayer);
			} else {
				if (origLayer.getOpacity() >= WorldConstants.GLOBAL_SOLID_OPACITY_THRESHOLD) {
					collisionArray = accumulateCollisionArray(collisionArray, origLayer, mirrorLayer);
				}
			}

			if (LevelEntityFactory.isInteractableLayer(origLayer)) {
				PlatformManipulationHandler handler = null;
				ArrayList<TerrainMapTileCoordinate> tileCoords = generatePlatformTileCoordinateArray(origLayer,
						mirrorLayer);

				InteractableLayerTypes layerType = LevelEntityFactory.getInteractableLayerType(origLayer);

				if (layerType.equals(InteractableLayerTypes.DX) || layerType.equals(InteractableLayerTypes.DY)) {
					handler = new MovingPlatformManipulationHandler(collisionArray, tileCoords,
							layerType.equals(InteractableLayerTypes.DX),
							layerType.equals(InteractableLayerTypes.DY));
				} else if (layerType.equals(InteractableLayerTypes.FADABLE)) {
					float opacity = origLayer.getOpacity();
					handler = new FadableLayerManipulationHandler(collisionArray, tileCoords,
							(opacity >= WorldConstants.GLOBAL_SOLID_OPACITY_THRESHOLD));
				}

				if (handler == null) {
					throw new GdxRuntimeException("Trying to create handler for invalid platform type.");
				} else {
					platformLayers.put(origLayer, handler);
					platformLayers.put(mirrorLayer, handler);
				}
			}
		}
	}

	retVal = new TerrainCollisionMap(egLayer, platformLayers, collisionArray);

	return retVal;
}
 

import com.badlogic.gdx.maps.tiled.TiledMapTileLayer; //導入方法依賴的package包/類
protected Entity generateInteractablePlatformEntity(TiledMapTileLayer layer, boolean mirrored, float xOffset,
		float yOffset) {
	Entity e = world.createEntity();

	MapProperties properties = layer.getProperties();

	Rectangle platformRect = calculatePlatformRect(layer);
	if (platformRect == null) {
		Gdx.app.debug("LOAD_LEVEL", "Couldn't create platform rect for layer " + layer);
		return null;
	}

	Texture texture = null;

	int platSize = 0;

	PlatformSpriteOrientation orientation = PlatformSpriteOrientation.NONE;

	if (platformRect.height == 1.0f) { // if height is 1 tile
		texture = generateHorizontalPlatformTexture((int) platformRect.width);
		platSize = (int) platformRect.width;
		orientation = PlatformSpriteOrientation.HORIZONTAL;
	} else if (platformRect.width == 1.0f) {
		texture = generateVerticalPlatformTexture((int) platformRect.height);
		platSize = (int) platformRect.height;
		orientation = PlatformSpriteOrientation.VERTICAL;
	}

	Position position = world.createComponent(Position.class);
	position.position.x = platformRect.x + xOffset;
	position.position.y = platformRect.y + yOffset;

	PlatformSprite platformSprite = world.createComponent(PlatformSprite.class);
	platformSprite.setTexture(texture);
	platformSprite.mirrored = mirrored;
	platformSprite.spriteWidth = texture.getWidth();
	platformSprite.spriteHeight = texture.getHeight();
	platformSprite.size = platSize;
	platformSprite.orientation = orientation;
	platformSprite.rectangle = new Rectangle(platformRect);
	platformSprite.rectangle.width *= PLATFORM_TILE_WIDTH;
	platformSprite.rectangle.height *= PLATFORM_TILE_HEIGHT;

	e.addComponent(position);
	e.addComponent(platformSprite);
	e.addComponent(world.createComponent(PlatformInputListener.class));

	if (properties.get("dx") != null) {
		DxLayer dxLayer = world.createComponent(DxLayer.class);
		dxLayer.fromTiledProperties(properties);
		dxLayer.layer = layer;

		e.addComponent(dxLayer);
	} else if (properties.get("dy") != null) {
		DyLayer dyLayer = world.createComponent(DyLayer.class);
		dyLayer.fromTiledProperties(properties);
		dyLayer.layer = layer;

		e.addComponent(dyLayer);
	} else if (properties.get("minOpacity") != null) {
		Opacity opacity = world.createComponent(Opacity.class);
		opacity.opacity = layer.getOpacity();

		FadableLayer fadableLayer = world.createComponent(FadableLayer.class);
		fadableLayer.layer = layer;
		fadableLayer.setupOpacity(opacity, layer.getOpacity(), properties);

		e.addComponent(opacity);
		e.addComponent(fadableLayer);
	}

	Solid solid = world.createComponent(Solid.class);
	solid.boundingBox = platformSprite.rectangle;
	solid.invertedGravity = false;
	solid.weight = 100.0f;

	e.addToWorld();
	e.disable();
	return e;
}