Studio scene pack contract for runtime SCENE binary payload

This commit is contained in:
2026-05-01 06:59:42 +01:00
parent 1182d3ae1f
commit 822e892c82
61 changed files with 120404 additions and 685 deletions
@@ -157,8 +157,9 @@ public enum I18n {
ASSETS_ACTIONS_EMPTY("assets.actions.empty"),
ASSETS_ACTION_REGISTER("assets.action.register"),
ASSETS_ACTION_ANALYSE("assets.action.analyse"),
ASSETS_ACTION_GENERATE_TSX("assets.action.generateTsx"),
ASSETS_ACTION_GENERATE_TMX("assets.action.generateTmx"),
ASSETS_ACTION_EXPORT_TSX("assets.action.exportTsx"),
ASSETS_ACTION_EXPORT_TMX("assets.action.exportTmx"),
ASSETS_ACTION_IMPORT_TMX("assets.action.importTmx"),
ASSETS_ACTION_VALIDATE_SCENE_BANK("assets.action.validateSceneBank"),
ASSETS_ACTION_ACCEPT_SCENE_BANK("assets.action.acceptSceneBank"),
ASSETS_ACTION_VALIDATE_LAYER("assets.action.validateLayer"),
@@ -209,6 +210,8 @@ public enum I18n {
ASSETS_LABEL_TILEMAPS("assets.label.tilemaps"),
ASSETS_LABEL_TILEMAP("assets.label.tilemap"),
ASSETS_LABEL_TILESET("assets.label.tileset"),
ASSETS_LABEL_PARALLAX("assets.label.parallax"),
ASSETS_LABEL_DEFAULT_PALETTE("assets.label.defaultPalette"),
ASSETS_LABEL_SUPPORT_FILE("assets.label.supportFile"),
ASSETS_LABEL_USE_LAYER("assets.label.useLayer"),
ASSETS_VALUE_NOT_CONFIGURED("assets.value.notConfigured"),
@@ -170,7 +170,6 @@ public final class AssetWorkspace extends Workspace {
}
AddAssetWizard.showAndWait(root.getScene().getWindow(), projectReference).ifPresent(assetReference -> {
workspaceEventBus.publish(new StudioAssetsRefreshRequestedEvent(assetReference));
workspaceEventBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(assetReference, false));
});
}
@@ -2,7 +2,10 @@ package p.studio.workspaces.assets.details;
import javafx.application.Platform;
import javafx.scene.Node;
import javafx.scene.control.Alert;
import javafx.scene.control.ButtonBar;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Label;
import javafx.scene.control.ScrollPane;
import javafx.scene.layout.HBox;
@@ -45,6 +48,7 @@ import p.studio.workspaces.assets.scene.SceneBankWorkflowResult;
import p.studio.workspaces.assets.scene.SceneBankWorkflowService;
import p.studio.workspaces.assets.tiled.TiledAssetGenerationResult;
import p.studio.workspaces.assets.tiled.TiledAssetGenerationService;
import p.studio.workspaces.assets.tiled.TiledAssetGenerationService.SceneTmxExportDisposition;
import p.studio.workspaces.assets.wizards.DeleteAssetDialog;
import p.studio.workspaces.assets.wizards.MoveAssetWizard;
import p.studio.workspaces.framework.StudioEventAware;
@@ -53,6 +57,9 @@ import p.studio.workspaces.framework.StudioEventBindings;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicLong;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.LinkedHashSet;
public final class AssetDetailsControl extends VBox implements StudioEventAware {
private final ProjectReference projectReference;
@@ -93,9 +100,6 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
this.colorSchemaGroupsControl = new AssetDetailsColorSchemaGroupsControl(projectReference, workspaceBus);
this.paletteOverhaulingControl = new AssetDetailsPaletteOverhaulingControl(projectReference, workspaceBus);
this.sceneLayersControl = new AssetDetailsSceneLayersControl(projectReference, workspaceBus);
this.sceneLayersControl.setGenerateLayerAction(this::generateTmx);
this.sceneLayersControl.setValidateLayerAction(this::validateSceneBank);
this.sceneLayersControl.setAcceptLayerAction(this::acceptSceneBank);
this.actionsSection = createActionsSection();
getStyleClass().add("assets-workspace-pane");
@@ -375,10 +379,21 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
analyseButton.setOnAction(ignored -> openDiagnosticsDialog());
nodes.add(analyseButton);
if (canGenerateTsx()) {
final Button generateTsxButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_GENERATE_TSX));
generateTsxButton.setDisable(actionRunning);
generateTsxButton.setOnAction(ignored -> generateTsx());
nodes.add(generateTsxButton);
final Button exportTsxButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_EXPORT_TSX));
exportTsxButton.setDisable(actionRunning);
exportTsxButton.setOnAction(ignored -> generateTsx());
nodes.add(exportTsxButton);
}
if (canSceneTmxInteroperability()) {
final Button importTmxButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_IMPORT_TMX));
importTmxButton.setDisable(actionRunning);
importTmxButton.setOnAction(ignored -> importTmx());
nodes.add(importTmxButton);
final Button exportTmxButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_EXPORT_TMX));
exportTmxButton.setDisable(actionRunning);
exportTmxButton.setOnAction(ignored -> exportTmx());
nodes.add(exportTmxButton);
}
final Button buildParticipationButton = AssetDetailsUiSupport.createActionButton(buildParticipationActionLabel());
AssetDetailsUiSupport.applyActionTone(
@@ -434,7 +449,6 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
viewState.selectedAssetReference(),
viewState.selectedAssetDetails().summary()).ifPresent(assetReference -> {
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(assetReference));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(assetReference, true));
});
}
@@ -519,12 +533,10 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
&& viewState.selectedAssetDetails().summary().glyphSpecialization() == AssetStudioGlyphSpecialization.TILESET;
}
private boolean canGenerateTmx() {
return false;
}
private boolean canValidateSceneBank() {
return false;
private boolean canSceneTmxInteroperability() {
return viewState.selectedAssetDetails() != null
&& viewState.selectedAssetDetails().summary().assetFamily() == AssetFamilyCatalog.SCENE_BANK
&& viewState.selectedAssetDetails().sceneBankMetadata() != null;
}
private void generateTsx() {
@@ -536,12 +548,73 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
renderActions();
final AssetWorkspaceAssetDetails details = viewState.selectedAssetDetails();
Container.backgroundTasks().submit(() -> {
final TiledAssetGenerationResult result = tiledGenerationService.generateTilesetTsx(details);
Platform.runLater(() -> applyTiledGenerationResult("glyph-bank-tileset", result));
final TiledAssetGenerationResult result = tiledGenerationService.exportTilesetTsx(details);
Platform.runLater(() -> applyTiledGenerationResult("glyph-bank-tileset-export", result));
});
}
private void generateTmx(int layerIndex) {
private void exportTmx() {
if (actionRunning || viewState.selectedAssetDetails() == null) {
return;
}
final AssetWorkspaceAssetDetails details = viewState.selectedAssetDetails();
final SceneTmxExportDisposition disposition = chooseSceneTmxExportDisposition(details);
if (disposition == null) {
return;
}
actionRunning = true;
actionFeedbackMessage = null;
renderActions();
Container.backgroundTasks().submit(() -> {
final TiledAssetGenerationResult result = tiledGenerationService.exportSceneBankTmx(projectReference, details, disposition);
Platform.runLater(() -> applyTiledGenerationResult("scene-bank-tmx-export", result));
});
}
private SceneTmxExportDisposition chooseSceneTmxExportDisposition(AssetWorkspaceAssetDetails details) {
final Path sceneTmxPath = resolveSceneTmxPath(details);
if (sceneTmxPath == null || !Files.isRegularFile(sceneTmxPath)) {
return SceneTmxExportDisposition.OVERWRITE;
}
final Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
if (getScene() != null) {
alert.initOwner(getScene().getWindow());
}
final ButtonType overwriteButton = new ButtonType("Overwrite", ButtonBar.ButtonData.YES);
final ButtonType keepBothButton = new ButtonType("Keep Both", ButtonBar.ButtonData.NO);
final ButtonType cancelButton = new ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);
alert.setTitle("Export TMX");
alert.setHeaderText(null);
alert.setContentText("A scene.tmx file already exists. Choose how to proceed.");
alert.getButtonTypes().setAll(overwriteButton, keepBothButton, cancelButton);
final ButtonType result = alert.showAndWait().orElse(cancelButton);
if (result == overwriteButton) {
return SceneTmxExportDisposition.OVERWRITE;
}
if (result == keepBothButton) {
return SceneTmxExportDisposition.KEEP_BOTH;
}
return null;
}
private Path resolveSceneTmxPath(AssetWorkspaceAssetDetails details) {
if (details == null || details.sceneBankMetadata() == null) {
return null;
}
final LinkedHashSet<String> tilemaps = new LinkedHashSet<>();
details.sceneBankMetadata().layerBindings().forEach(binding -> {
final String tilemap = Objects.requireNonNullElse(binding.tilemap(), "").trim();
if (!tilemap.isBlank()) {
tilemaps.add(tilemap);
}
});
if (tilemaps.size() != 1) {
return null;
}
return details.summary().assetRoot().resolve(tilemaps.iterator().next());
}
private void importTmx() {
if (actionRunning || viewState.selectedAssetDetails() == null) {
return;
}
@@ -550,8 +623,8 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
renderActions();
final AssetWorkspaceAssetDetails details = viewState.selectedAssetDetails();
Container.backgroundTasks().submit(() -> {
final TiledAssetGenerationResult result = tiledGenerationService.generateSceneBankTilemap(projectReference, details, layerIndex);
Platform.runLater(() -> applyTiledGenerationResult("scene-bank-layer-" + layerIndex, result));
final TiledAssetGenerationResult result = tiledGenerationService.importSceneBankTmx(projectReference, details);
Platform.runLater(() -> applyTiledGenerationResult("scene-bank-tmx-import", result));
});
}
@@ -560,8 +633,7 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
actionFeedbackMessage = result.message();
workspaceBus.publish(new StudioAssetLogEvent(source, result.message()));
renderActions();
if (result.success() && viewState.selectedAssetReference() != null) {
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(viewState.selectedAssetReference()));
if (result.success() && viewState.selectedAssetReference() != null && shouldReloadDetailsAfterTiledResult(source)) {
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(viewState.selectedAssetReference(), true));
}
}
@@ -600,17 +672,19 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
workspaceBus.publish(new StudioAssetLogEvent(source, result.message()));
renderActions();
if (viewState.selectedAssetReference() != null) {
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(viewState.selectedAssetReference()));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(viewState.selectedAssetReference(), true));
}
}
private boolean shouldReloadDetailsAfterTiledResult(String source) {
return "scene-bank-tmx-import".equals(source);
}
private void applyBuildParticipationResult(UpdateAssetBuildParticipationResult result) {
actionRunning = false;
if (result.status() == p.packer.messages.PackerOperationStatus.SUCCESS && result.assetReference() != null) {
actionFeedbackMessage = null;
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(result.assetReference()));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(result.assetReference(), false));
return;
}
actionFeedbackMessage = result.summary();
@@ -641,7 +715,6 @@ public final class AssetDetailsControl extends VBox implements StudioEventAware
if (result.status() == p.packer.messages.PackerOperationStatus.SUCCESS && result.assetReference() != null) {
actionFeedbackMessage = null;
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(result.assetReference()));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(result.assetReference(), false));
return;
}
actionFeedbackMessage = Objects.requireNonNullElse(result.summary(), "Unable to register asset.");
@@ -98,7 +98,6 @@ public final class AssetDetailsContractControl extends HBox implements StudioCon
if (viewState == null || viewState.selectedAssetReference() == null) {
return;
}
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(viewState.selectedAssetReference()));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(viewState.selectedAssetReference(), true));
}
@@ -17,8 +17,8 @@ import p.studio.projects.ProjectReference;
import p.studio.utilities.i18n.I18n;
import p.studio.workspaces.assets.messages.AssetWorkspaceDetailsViewState;
import p.studio.workspaces.assets.messages.events.StudioAssetLogEvent;
import p.studio.workspaces.assets.messages.events.StudioAssetsRefreshRequestedEvent;
import p.studio.workspaces.assets.messages.events.StudioAssetsDetailsViewStateChangedEvent;
import p.studio.workspaces.assets.messages.events.StudioAssetsWorkspaceSelectionRequestedEvent;
import p.studio.workspaces.assets.messages.events.StudioGlyphMaterialMetadataChangedEvent;
import p.studio.workspaces.assets.metadata.AssetStudioGlyphMaterialMetadata;
import p.studio.workspaces.assets.metadata.AssetStudioMetadataService;
@@ -222,7 +222,7 @@ public final class AssetDetailsPaletteOverhaulingControl extends StudioFormSecti
coordinator.apply();
publishEditScope(workspaceBus, currentScopeKey(), null);
renderSection();
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(assetReference));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(assetReference, true));
} else {
workspaceBus.publish(new StudioAssetLogEvent("palette-overhauling",
"Apply failed: " + Objects.requireNonNullElse(response.errorMessage(), "unknown error")));
@@ -25,9 +25,9 @@ import p.studio.workspaces.assets.details.AssetDetailsUiSupport;
import p.studio.workspaces.assets.metadata.AssetStudioMetadataService;
import p.studio.workspaces.assets.metadata.AssetStudioSceneBankMetadata;
import p.studio.workspaces.assets.metadata.AssetStudioSceneLayerBinding;
import p.studio.workspaces.assets.metadata.AssetStudioSceneTile;
import p.studio.workspaces.assets.messages.AssetWorkspaceDetailsViewState;
import p.studio.workspaces.assets.messages.events.StudioAssetLogEvent;
import p.studio.workspaces.assets.messages.events.StudioAssetsRefreshRequestedEvent;
import p.studio.workspaces.assets.messages.events.StudioAssetsDetailsViewStateChangedEvent;
import p.studio.workspaces.assets.messages.events.StudioAssetsWorkspaceSelectionRequestedEvent;
import p.studio.workspaces.framework.StudioSubscriptionBag;
@@ -188,7 +188,13 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
: AssetDetailsUiSupport.projectRelativePath(projectReference, sceneAssetRoot.resolve(binding.tilemap()))),
AssetDetailsUiSupport.createKeyValueRow(
Container.i18n().text(I18n.ASSETS_LABEL_TILESET),
editing ? createTilesetCombo(draft, true) : createTilesetReadOnlyValue(binding, draft)));
editing ? createTilesetCombo(draft, true) : createTilesetReadOnlyValue(binding, draft)),
AssetDetailsUiSupport.createKeyValueRow(
Container.i18n().text(I18n.ASSETS_LABEL_PARALLAX),
editing ? createParallaxEditor(draft) : new Label(draft.parallaxText())),
AssetDetailsUiSupport.createKeyValueRow(
Container.i18n().text(I18n.ASSETS_LABEL_DEFAULT_PALETTE),
editing ? createDefaultPaletteEditor(draft) : new Label(draft.defaultPaletteText())));
return card;
}
@@ -235,27 +241,9 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
final HBox actions = new HBox(8);
actions.setAlignment(Pos.CENTER_LEFT);
actions.getStyleClass().add("assets-scene-layer-actions");
final boolean enabled = draft != null && draft.enabled();
final boolean hasTmx = hasLayerTilemap(sceneAssetRoot, layerIndex);
final Button generateButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_GENERATE_TMX));
generateButton.getStyleClass().add("assets-scene-layer-action");
generateButton.setDisable(!enabled || hasTmx);
generateButton.setOnAction(ignored -> generateLayerAction.accept(layerIndex));
final Button validateButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_VALIDATE_LAYER));
validateButton.getStyleClass().add("assets-scene-layer-action");
validateButton.setDisable(!enabled || !hasTmx);
validateButton.setOnAction(ignored -> validateLayerAction.accept(layerIndex));
final Button acceptButton = AssetDetailsUiSupport.createActionButton(Container.i18n().text(I18n.ASSETS_ACTION_ACCEPT_LAYER));
acceptButton.getStyleClass().add("assets-scene-layer-action");
acceptButton.setDisable(!enabled || !hasTmx);
acceptButton.setOnAction(ignored -> acceptLayerAction.accept(layerIndex));
final Region spacer = new Region();
HBox.setHgrow(spacer, Priority.ALWAYS);
actions.getChildren().addAll(generateButton, validateButton, acceptButton, spacer);
actions.getChildren().add(spacer);
return actions;
}
@@ -320,6 +308,24 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
return combo;
}
private Node createParallaxEditor(LayerDraft draft) {
final HBox editor = new HBox(8);
editor.getStyleClass().add("assets-scene-layer-size-editor");
final TextField xField = createSizeField(draft.parallaxXText(), draft::setParallaxXText);
final Label separator = new Label(",");
separator.getStyleClass().add("assets-scene-layer-size-separator");
final TextField yField = createSizeField(draft.parallaxYText(), draft::setParallaxYText);
editor.getChildren().addAll(xField, separator, yField);
return editor;
}
private Node createDefaultPaletteEditor(LayerDraft draft) {
final TextField textField = new TextField(draft.defaultPaletteText());
textField.getStyleClass().add("assets-scene-layer-size-field");
textField.textProperty().addListener((ignored, oldValue, newValue) -> draft.setDefaultPaletteText(newValue));
return textField;
}
private Node createTilesetReadOnlyValue(AssetStudioSceneLayerBinding binding, LayerDraft draft) {
final String value = binding == null || draft == null || draft.tilesetAssetRoot().isBlank()
? Container.i18n().text(I18n.ASSETS_VALUE_NOT_CONFIGURED)
@@ -377,7 +383,6 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
metadataService.writeSceneBankMetadata(viewState.selectedAssetDetails().summary().assetRoot(), updatedMetadata);
Platform.runLater(() -> {
workspaceBus.publish(new StudioAssetLogEvent("scene-bank-layer", successMessage));
workspaceBus.publish(new StudioAssetsRefreshRequestedEvent(viewState.selectedAssetReference()));
workspaceBus.publish(new StudioAssetsWorkspaceSelectionRequestedEvent(viewState.selectedAssetReference(), true));
});
} catch (IOException exception) {
@@ -407,10 +412,10 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
}
private void applyEdit(int layerIndex, AssetStudioSceneLayerBinding binding) {
if (binding == null || editingDraft == null || !editingDraft.hasValidDimensions()) {
if (binding == null || editingDraft == null || !editingDraft.hasValidState()) {
workspaceBus.publish(new StudioAssetLogEvent(
"scene-bank-layer",
"Layer size must use positive integer values before applying changes."));
"Layer configuration must use positive dimensions, non-negative parallax, and a non-negative default palette before applying changes."));
return;
}
final LayerDraft draft = editingDraft.copy();
@@ -424,10 +429,28 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
draft.widthValue(),
draft.heightValue(),
current.tilemap(),
draft.tilesetAssetRoot()),
draft.tilesetAssetRoot(),
draft.parallaxXValue(),
draft.parallaxYValue(),
draft.defaultPaletteValue(),
preservedTilesOrBlank(current, draft)),
"Updated layer " + layerIndex + " configuration.");
}
private List<AssetStudioSceneTile> preservedTilesOrBlank(
AssetStudioSceneLayerBinding current,
LayerDraft draft) {
if (current.width() == draft.widthValue() && current.height() == draft.heightValue()) {
return current.tiles();
}
final int tileCount = draft.widthValue() * draft.heightValue();
final List<AssetStudioSceneTile> tiles = new ArrayList<>(tileCount);
for (int index = 0; index < tileCount; index += 1) {
tiles.add(AssetStudioSceneTile.inactive(draft.defaultPaletteValue()));
}
return List.copyOf(tiles);
}
private void resetEdit(AssetStudioSceneLayerBinding binding) {
editingDraft = LayerDraft.from(binding);
render();
@@ -467,27 +490,43 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
private String widthText;
private String heightText;
private String tilesetAssetRoot;
private String parallaxXText;
private String parallaxYText;
private String defaultPaletteText;
private LayerDraft(boolean enabled, String widthText, String heightText, String tilesetAssetRoot) {
private LayerDraft(
boolean enabled,
String widthText,
String heightText,
String tilesetAssetRoot,
String parallaxXText,
String parallaxYText,
String defaultPaletteText) {
this.enabled = enabled;
this.widthText = widthText;
this.heightText = heightText;
this.tilesetAssetRoot = Objects.requireNonNullElse(tilesetAssetRoot, "").trim();
this.parallaxXText = Objects.requireNonNullElse(parallaxXText, "").trim();
this.parallaxYText = Objects.requireNonNullElse(parallaxYText, "").trim();
this.defaultPaletteText = Objects.requireNonNullElse(defaultPaletteText, "").trim();
}
static LayerDraft from(AssetStudioSceneLayerBinding binding) {
if (binding == null) {
return new LayerDraft(false, "16", "16", "");
return new LayerDraft(false, "16", "16", "", "1.0", "1.0", "0");
}
return new LayerDraft(
binding.enabled(),
Integer.toString(binding.width()),
Integer.toString(binding.height()),
binding.tilesetAssetRoot());
binding.tilesetAssetRoot(),
trimFloat(binding.parallaxFactorX()),
trimFloat(binding.parallaxFactorY()),
Integer.toString(binding.defaultPaletteId()));
}
LayerDraft copy() {
return new LayerDraft(enabled, widthText, heightText, tilesetAssetRoot);
return new LayerDraft(enabled, widthText, heightText, tilesetAssetRoot, parallaxXText, parallaxYText, defaultPaletteText);
}
boolean enabled() {
@@ -522,8 +561,40 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
this.tilesetAssetRoot = Objects.requireNonNullElse(tilesetAssetRoot, "").trim();
}
boolean hasValidDimensions() {
return parsePositiveInt(widthText) > 0 && parsePositiveInt(heightText) > 0;
String parallaxXText() {
return parallaxXText;
}
void setParallaxXText(String parallaxXText) {
this.parallaxXText = Objects.requireNonNullElse(parallaxXText, "").trim();
}
String parallaxYText() {
return parallaxYText;
}
void setParallaxYText(String parallaxYText) {
this.parallaxYText = Objects.requireNonNullElse(parallaxYText, "").trim();
}
String parallaxText() {
return parallaxXText + ", " + parallaxYText;
}
String defaultPaletteText() {
return defaultPaletteText;
}
void setDefaultPaletteText(String defaultPaletteText) {
this.defaultPaletteText = Objects.requireNonNullElse(defaultPaletteText, "").trim();
}
boolean hasValidState() {
return parsePositiveInt(widthText) > 0
&& parsePositiveInt(heightText) > 0
&& parseNonNegativeFloat(parallaxXText) >= 0.0f
&& parseNonNegativeFloat(parallaxYText) >= 0.0f
&& parseNonNegativeInt(defaultPaletteText) >= 0;
}
int widthValue() {
@@ -534,6 +605,18 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
return parsePositiveInt(heightText);
}
float parallaxXValue() {
return parseNonNegativeFloat(parallaxXText);
}
float parallaxYValue() {
return parseNonNegativeFloat(parallaxYText);
}
int defaultPaletteValue() {
return parseNonNegativeInt(defaultPaletteText);
}
private static int parsePositiveInt(String value) {
try {
return Integer.parseInt(Objects.requireNonNullElse(value, "").trim());
@@ -541,5 +624,30 @@ public final class AssetDetailsSceneLayersControl extends VBox implements Studio
return -1;
}
}
private static int parseNonNegativeInt(String value) {
try {
final int parsed = Integer.parseInt(Objects.requireNonNullElse(value, "").trim());
return parsed >= 0 ? parsed : -1;
} catch (NumberFormatException exception) {
return -1;
}
}
private static float parseNonNegativeFloat(String value) {
try {
final float parsed = Float.parseFloat(Objects.requireNonNullElse(value, "").trim());
return Float.isFinite(parsed) && parsed >= 0.0f ? parsed : -1.0f;
} catch (NumberFormatException exception) {
return -1.0f;
}
}
private static String trimFloat(float value) {
if (value == (long) value) {
return Long.toString((long) value) + ".0";
}
return Float.toString(value);
}
}
}
@@ -49,6 +49,20 @@ public final class AssetStudioMetadataService {
layer.put("height", binding.height());
layer.put("tilemap", binding.tilemap());
layer.put("tileset_asset_root", binding.tilesetAssetRoot());
layer.put("parallax_factor_x", binding.parallaxFactorX());
layer.put("parallax_factor_y", binding.parallaxFactorY());
layer.put("default_palette_id", binding.defaultPaletteId());
if (binding.tiles().stream().anyMatch(AssetStudioSceneTile::active)) {
final ArrayNode tiles = layer.putArray("tiles");
for (AssetStudioSceneTile tile : binding.tiles()) {
final var tileNode = tiles.addObject();
tileNode.put("active", tile.active());
tileNode.put("glyph_id", tile.glyphId());
tileNode.put("palette_id", tile.paletteId());
tileNode.put("flip_x", tile.flipX());
tileNode.put("flip_y", tile.flipY());
}
}
}
mapper.writerWithDefaultPrettyPrinter().writeValue(
normalizedAssetRoot.resolve(SCENE_BANK_SUPPORT_FILE).toFile(),
@@ -137,7 +151,7 @@ public final class AssetStudioMetadataService {
}
final Path supportFile = assetRoot.resolve(SCENE_BANK_SUPPORT_FILE);
if (!Files.isRegularFile(supportFile)) {
return null;
return defaultSceneBankMetadata(supportFile);
}
try {
final JsonNode root = mapper.readTree(supportFile.toFile());
@@ -163,10 +177,28 @@ public final class AssetStudioMetadataService {
final int height = layerNode.path("height").asInt(mapHeight);
final String tilemap = layerNode.path("tilemap").asText("").trim();
final String tilesetAssetRoot = layerNode.path("tileset_asset_root").asText("").trim();
final float parallaxFactorX = (float) layerNode.path("parallax_factor_x").asDouble(1.0d);
final float parallaxFactorY = (float) layerNode.path("parallax_factor_y").asDouble(1.0d);
final int defaultPaletteId = layerNode.path("default_palette_id").asInt(0);
if (index < 1 || index > layerCount || layerName.isBlank() || width <= 0 || height <= 0 || tilemap.isBlank() || !indexes.add(index)) {
return null;
}
bindings.add(new AssetStudioSceneLayerBinding(enabled, index, layerName, width, height, tilemap, tilesetAssetRoot));
final List<AssetStudioSceneTile> tiles = readSceneTiles(layerNode.path("tiles"), width, height, defaultPaletteId);
if (tiles == null) {
return null;
}
bindings.add(new AssetStudioSceneLayerBinding(
enabled,
index,
layerName,
width,
height,
tilemap,
tilesetAssetRoot,
parallaxFactorX,
parallaxFactorY,
defaultPaletteId,
tiles));
}
bindings.sort(Comparator.comparingInt(AssetStudioSceneLayerBinding::index));
return new AssetStudioSceneBankMetadata(mapWidth, mapHeight, layerCount, bindings, supportFile);
@@ -287,4 +319,44 @@ public final class AssetStudioMetadataService {
final String normalized = value.trim().toUpperCase();
return normalized.matches("^#[0-9A-F]{6}$") ? normalized : null;
}
private AssetStudioSceneBankMetadata defaultSceneBankMetadata(Path supportFile) {
return new AssetStudioSceneBankMetadata(
16,
16,
4,
List.of(
new AssetStudioSceneLayerBinding(false, 1, "Layer 1", 16, 16, "scene.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 16, 16, "scene.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 16, 16, "scene.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 16, 16, "scene.tmx", "", 1.0f, 1.0f, 0)),
supportFile);
}
private List<AssetStudioSceneTile> readSceneTiles(JsonNode tilesNode, int width, int height, int defaultPaletteId) {
final int tileCount = width * height;
if (!(tilesNode instanceof ArrayNode arrayNode)) {
final List<AssetStudioSceneTile> defaults = new ArrayList<>(tileCount);
for (int index = 0; index < tileCount; index += 1) {
defaults.add(AssetStudioSceneTile.inactive(defaultPaletteId));
}
return List.copyOf(defaults);
}
if (arrayNode.size() != tileCount) {
return null;
}
final List<AssetStudioSceneTile> tiles = new ArrayList<>(tileCount);
for (JsonNode tileNode : arrayNode) {
final boolean active = tileNode.path("active").asBoolean(false);
final int glyphId = tileNode.path("glyph_id").asInt(0);
final int paletteId = tileNode.path("palette_id").asInt(defaultPaletteId);
final boolean flipX = tileNode.path("flip_x").asBoolean(false);
final boolean flipY = tileNode.path("flip_y").asBoolean(false);
if (glyphId < 0 || paletteId < 0) {
return null;
}
tiles.add(new AssetStudioSceneTile(active, glyphId, paletteId, flipX, flipY));
}
return List.copyOf(tiles);
}
}
@@ -1,5 +1,7 @@
package p.studio.workspaces.assets.metadata;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public record AssetStudioSceneLayerBinding(
@@ -9,11 +11,16 @@ public record AssetStudioSceneLayerBinding(
int width,
int height,
String tilemap,
String tilesetAssetRoot) {
String tilesetAssetRoot,
float parallaxFactorX,
float parallaxFactorY,
int defaultPaletteId,
List<AssetStudioSceneTile> tiles) {
public AssetStudioSceneLayerBinding {
layerName = Objects.requireNonNull(layerName, "layerName").trim();
tilemap = Objects.requireNonNull(tilemap, "tilemap").trim();
tilesetAssetRoot = Objects.requireNonNull(tilesetAssetRoot, "tilesetAssetRoot").trim();
tiles = List.copyOf(Objects.requireNonNull(tiles, "tiles"));
if (index <= 0) {
throw new IllegalArgumentException("index must be positive");
}
@@ -26,5 +33,50 @@ public record AssetStudioSceneLayerBinding(
if (tilemap.isBlank()) {
throw new IllegalArgumentException("tilemap must not be blank");
}
if (!Float.isFinite(parallaxFactorX) || parallaxFactorX < 0.0f) {
throw new IllegalArgumentException("parallaxFactorX must be finite and non-negative");
}
if (!Float.isFinite(parallaxFactorY) || parallaxFactorY < 0.0f) {
throw new IllegalArgumentException("parallaxFactorY must be finite and non-negative");
}
if (defaultPaletteId < 0) {
throw new IllegalArgumentException("defaultPaletteId must be non-negative");
}
if (tiles.size() != width * height) {
throw new IllegalArgumentException("tiles must match width * height");
}
}
public AssetStudioSceneLayerBinding(
boolean enabled,
int index,
String layerName,
int width,
int height,
String tilemap,
String tilesetAssetRoot,
float parallaxFactorX,
float parallaxFactorY,
int defaultPaletteId) {
this(
enabled,
index,
layerName,
width,
height,
tilemap,
tilesetAssetRoot,
parallaxFactorX,
parallaxFactorY,
defaultPaletteId,
blankTiles(width, height, defaultPaletteId));
}
private static List<AssetStudioSceneTile> blankTiles(int width, int height, int defaultPaletteId) {
final List<AssetStudioSceneTile> tiles = new ArrayList<>(width * height);
for (int index = 0; index < width * height; index += 1) {
tiles.add(AssetStudioSceneTile.inactive(defaultPaletteId));
}
return List.copyOf(tiles);
}
}
@@ -0,0 +1,22 @@
package p.studio.workspaces.assets.metadata;
public record AssetStudioSceneTile(
boolean active,
int glyphId,
int paletteId,
boolean flipX,
boolean flipY) {
public AssetStudioSceneTile {
if (glyphId < 0) {
throw new IllegalArgumentException("glyphId must be non-negative");
}
if (paletteId < 0) {
throw new IllegalArgumentException("paletteId must be non-negative");
}
}
public static AssetStudioSceneTile inactive(int paletteId) {
return new AssetStudioSceneTile(false, 0, Math.max(0, paletteId), false, false);
}
}
@@ -3,383 +3,333 @@ package p.studio.workspaces.assets.scene;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import p.packer.dtos.PackerDiagnosticDTO;
import p.packer.messages.ListAssetsRequest;
import p.packer.messages.assets.AssetFamilyCatalog;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
import p.packer.messages.diagnostics.PackerDiagnosticSeverity;
import p.studio.Container;
import p.studio.projects.ProjectReference;
import p.studio.workspaces.assets.metadata.AssetStudioSceneBankMetadata;
import p.studio.workspaces.assets.metadata.AssetStudioSceneLayerBinding;
import p.studio.workspaces.assets.metadata.AssetStudioSceneTile;
import p.studio.workspaces.assets.messages.AssetWorkspaceAssetDetails;
import p.studio.workspaces.assets.messages.AssetWorkspaceSceneBankStatus;
import p.studio.workspaces.assets.messages.AssetWorkspaceSceneBankValidation;
import p.studio.workspaces.assets.tiled.TiledMapDocument;
import p.studio.workspaces.assets.tiled.TiledTilesetDocument;
import p.studio.workspaces.assets.tiled.TiledUnsupportedFeatureException;
import p.studio.workspaces.assets.tiled.TiledXmlCodec;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HexFormat;
import java.util.List;
import java.util.Objects;
public final class SceneBankWorkflowService {
private static final String VALIDATION_FILE = "scene-bank.validation.json";
private static final String ACCEPTANCE_FILE = "scene-bank.acceptance.json";
public static final String ACCEPTED_REQUEST_FILE = "scene-bank.pack-request.json";
private final ObjectMapper mapper = new ObjectMapper();
private final TiledXmlCodec codec = new TiledXmlCodec();
private final SceneBankGlyphAssetResolver glyphAssetResolver;
public SceneBankWorkflowService() {
this((projectReference, tilesetAssetRoot) -> Container.packer().workspaceService()
.listAssets(new ListAssetsRequest(projectReference.toPackerProjectContext()))
.assets()
.stream()
.filter(asset -> asset.assetFamily() == AssetFamilyCatalog.GLYPH_BANK)
.filter(asset -> projectReference.rootPath()
.resolve("assets")
.resolve(tilesetAssetRoot)
.toAbsolutePath()
.normalize()
.equals(asset.identity().assetRoot().toAbsolutePath().normalize()))
.findFirst()
.map(asset -> asset.identity().assetId() == null ? -1 : asset.identity().assetId())
.orElse(-1));
}
SceneBankWorkflowService(SceneBankGlyphAssetResolver glyphAssetResolver) {
this.glyphAssetResolver = Objects.requireNonNull(glyphAssetResolver, "glyphAssetResolver");
}
public SceneBankWorkflowResult inspect(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
if (details == null || details.summary().assetFamily() != p.packer.messages.assets.AssetFamilyCatalog.SCENE_BANK) {
if (details == null || details.summary().assetFamily() != AssetFamilyCatalog.SCENE_BANK) {
return new SceneBankWorkflowResult(true, "", AssetWorkspaceSceneBankValidation.NOT_APPLICABLE, List.of());
}
final List<PackerDiagnosticDTO> diagnostics = validateDiagnostics(projectReference, details, null);
final String currentFingerprint = diagnostics.stream().anyMatch(PackerDiagnosticDTO::blocking)
? ""
: computeFingerprint(projectReference, details);
final String validatedFingerprint = readFingerprint(details.summary().assetRoot().resolve(VALIDATION_FILE));
final String acceptedFingerprint = readFingerprint(details.summary().assetRoot().resolve(ACCEPTANCE_FILE));
final AssetWorkspaceSceneBankValidation validation = validationState(
diagnostics,
currentFingerprint,
validatedFingerprint,
acceptedFingerprint);
final List<PackerDiagnosticDTO> diagnostics = new ArrayList<>(validateDiagnostics(projectReference, details));
if (diagnostics.stream().noneMatch(PackerDiagnosticDTO::blocking)) {
try {
writeAcceptedRequest(
details.summary().assetRoot().resolve(ACCEPTED_REQUEST_FILE),
buildCanonicalRequest(projectReference, details));
} catch (IOException | IllegalArgumentException exception) {
diagnostics.add(error(
"Unable to persist canonical scene-pack request: " + exception.getMessage(),
details.summary().assetRoot().resolve(ACCEPTED_REQUEST_FILE)));
}
}
final AssetWorkspaceSceneBankValidation validation = validationState(diagnostics);
return new SceneBankWorkflowResult(
diagnostics.stream().noneMatch(PackerDiagnosticDTO::blocking),
messageFor(validation),
validation,
diagnostics);
List.copyOf(diagnostics));
}
public SceneBankWorkflowResult validate(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
final SceneBankWorkflowResult inspection = inspect(projectReference, details);
final Path validationFile = details.summary().assetRoot().resolve(VALIDATION_FILE);
try {
if (inspection.success() && !inspection.validation().currentFingerprint().isBlank()) {
writeFingerprint(validationFile, inspection.validation().currentFingerprint());
} else {
Files.deleteIfExists(validationFile);
}
} catch (IOException exception) {
return new SceneBankWorkflowResult(
false,
"Unable to persist validation state: " + exception.getMessage(),
inspection.validation(),
inspection.diagnostics());
}
return inspect(projectReference, details);
}
public SceneBankWorkflowResult accept(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
final SceneBankWorkflowResult inspection = inspect(projectReference, details);
if (!inspection.validation().canAccept()) {
return new SceneBankWorkflowResult(
false,
"Scene Bank must validate successfully before acceptance.",
inspection.validation(),
inspection.diagnostics());
}
try {
writeFingerprint(details.summary().assetRoot().resolve(ACCEPTANCE_FILE), inspection.validation().currentFingerprint());
writeFingerprint(details.summary().assetRoot().resolve(VALIDATION_FILE), inspection.validation().currentFingerprint());
} catch (IOException exception) {
return new SceneBankWorkflowResult(
false,
"Unable to persist acceptance state: " + exception.getMessage(),
inspection.validation(),
inspection.diagnostics());
}
return inspect(projectReference, details);
}
public SceneBankWorkflowResult inspectLayer(ProjectReference projectReference, AssetWorkspaceAssetDetails details, int layerIndex) {
if (details == null || details.summary().assetFamily() != p.packer.messages.assets.AssetFamilyCatalog.SCENE_BANK) {
return new SceneBankWorkflowResult(true, "", AssetWorkspaceSceneBankValidation.NOT_APPLICABLE, List.of());
}
final List<PackerDiagnosticDTO> diagnostics = validateDiagnostics(projectReference, details, layerIndex);
final String currentFingerprint = diagnostics.stream().anyMatch(PackerDiagnosticDTO::blocking)
? ""
: computeFingerprint(projectReference, details, layerIndex);
final String validatedFingerprint = readFingerprint(details.summary().assetRoot().resolve(layerValidationFile(layerIndex)));
final String acceptedFingerprint = readFingerprint(details.summary().assetRoot().resolve(layerAcceptanceFile(layerIndex)));
final AssetWorkspaceSceneBankValidation validation = validationState(
diagnostics,
currentFingerprint,
validatedFingerprint,
acceptedFingerprint);
return new SceneBankWorkflowResult(
diagnostics.stream().noneMatch(PackerDiagnosticDTO::blocking),
messageFor(validation),
validation,
diagnostics);
return inspect(projectReference, details);
}
public SceneBankWorkflowResult validateLayer(ProjectReference projectReference, AssetWorkspaceAssetDetails details, int layerIndex) {
final SceneBankWorkflowResult inspection = inspectLayer(projectReference, details, layerIndex);
final Path validationFile = details.summary().assetRoot().resolve(layerValidationFile(layerIndex));
try {
if (inspection.success() && !inspection.validation().currentFingerprint().isBlank()) {
writeFingerprint(validationFile, inspection.validation().currentFingerprint());
} else {
Files.deleteIfExists(validationFile);
}
} catch (IOException exception) {
return new SceneBankWorkflowResult(
false,
"Unable to persist validation state: " + exception.getMessage(),
inspection.validation(),
inspection.diagnostics());
}
return inspectLayer(projectReference, details, layerIndex);
return inspect(projectReference, details);
}
public SceneBankWorkflowResult acceptLayer(ProjectReference projectReference, AssetWorkspaceAssetDetails details, int layerIndex) {
final SceneBankWorkflowResult inspection = inspectLayer(projectReference, details, layerIndex);
if (!inspection.validation().canAccept()) {
return new SceneBankWorkflowResult(
false,
"Scene layer must validate successfully before acceptance.",
inspection.validation(),
inspection.diagnostics());
}
try {
writeFingerprint(details.summary().assetRoot().resolve(layerAcceptanceFile(layerIndex)), inspection.validation().currentFingerprint());
writeFingerprint(details.summary().assetRoot().resolve(layerValidationFile(layerIndex)), inspection.validation().currentFingerprint());
} catch (IOException exception) {
return new SceneBankWorkflowResult(
false,
"Unable to persist acceptance state: " + exception.getMessage(),
inspection.validation(),
inspection.diagnostics());
}
return inspectLayer(projectReference, details, layerIndex);
return inspect(projectReference, details);
}
private List<PackerDiagnosticDTO> validateDiagnostics(ProjectReference projectReference, AssetWorkspaceAssetDetails details, Integer targetLayerIndex) {
private List<PackerDiagnosticDTO> validateDiagnostics(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
final List<PackerDiagnosticDTO> diagnostics = new ArrayList<>();
final AssetStudioSceneBankMetadata metadata = details.sceneBankMetadata();
if (metadata == null) {
diagnostics.add(error("Scene Bank support metadata is missing or invalid.", details.summary().assetRoot().resolve("scene-bank.studio.json")));
diagnostics.add(error("Scene Bank support metadata is missing or invalid.",
details.summary().assetRoot().resolve("scene-bank.studio.json")));
return diagnostics;
}
final SceneLayerRuntimeDefaults sceneDefaults =
resolveSceneLayerRuntimeDefaults(projectReference, metadata.layerBindings());
for (AssetStudioSceneLayerBinding binding : metadata.layerBindings()) {
if (!binding.enabled()) {
continue;
}
if (targetLayerIndex != null && binding.index() != targetLayerIndex) {
if (resolveLayerRuntimeDefaults(projectReference, binding, sceneDefaults) == null) {
diagnostics.add(error(
"Unable to resolve runtime glyph/tile_size defaults for inactive layer " + binding.index() + ".",
metadata.supportFile()));
}
continue;
}
if (binding.tilesetAssetRoot().isBlank()) {
diagnostics.add(error("Layer " + binding.index() + " is missing tileset_asset_root.", metadata.supportFile()));
continue;
}
final Path tmxPath = details.summary().assetRoot().resolve(binding.tilemap()).toAbsolutePath().normalize();
final Path tsxPath = projectReference.rootPath()
.resolve("assets")
.resolve(binding.tilesetAssetRoot())
.resolve("tileset.tsx")
.toAbsolutePath()
.normalize();
if (!Files.isRegularFile(tmxPath)) {
diagnostics.add(error("TMX file is missing for layer " + binding.index() + ": " + binding.tilemap(), tmxPath));
if (binding.tiles().size() != binding.width() * binding.height()) {
diagnostics.add(error("Canonical scene tile count does not match width * height for layer " + binding.index() + ".",
metadata.supportFile()));
continue;
}
if (!Files.isRegularFile(tsxPath)) {
diagnostics.add(error("Referenced TSX file is missing for layer " + binding.index() + ": " + binding.tilesetAssetRoot(), tsxPath));
continue;
if (resolveGlyphAssetId(projectReference, binding.tilesetAssetRoot()) < 0) {
diagnostics.add(error("Unable to resolve glyph_asset_id for layer " + binding.index() + ": " + binding.tilesetAssetRoot(),
metadata.supportFile()));
}
try {
final TiledTilesetDocument tileset = codec.readTileset(tsxPath);
final TiledMapDocument map = codec.readMap(tmxPath);
final String expectedSource = details.summary().assetRoot()
.toAbsolutePath()
.normalize()
.relativize(tsxPath)
.toString()
.replace('\\', '/');
if (map.tilesets().size() != 1) {
diagnostics.add(error("TMX must reference exactly one TSX in wave 1: " + binding.tilemap(), tmxPath));
} else if (!expectedSource.equals(map.tilesets().getFirst().source())) {
diagnostics.add(error("TMX tileset reference does not match support metadata: " + binding.tilemap(), tmxPath));
if (resolveTileSize(projectReference, binding.tilesetAssetRoot()) <= 0) {
diagnostics.add(error("Unable to resolve tile_size for layer " + binding.index() + ": " + binding.tilesetAssetRoot(),
metadata.supportFile()));
}
for (AssetStudioSceneTile tile : binding.tiles()) {
if (tile.glyphId() < 0) {
diagnostics.add(error("Canonical scene tile glyph_id must be non-negative for layer " + binding.index() + ".",
metadata.supportFile()));
break;
}
if (map.width() != binding.width() || map.height() != binding.height()) {
diagnostics.add(error("TMX dimensions do not match scene-bank support metadata: " + binding.tilemap(), tmxPath));
if (tile.paletteId() < 0) {
diagnostics.add(error("Canonical scene tile palette_id must be non-negative for layer " + binding.index() + ".",
metadata.supportFile()));
break;
}
if (map.tileWidth() != tileset.tileWidth() || map.tileHeight() != tileset.tileHeight()) {
diagnostics.add(error("TMX tile size does not match referenced TSX: " + binding.tilemap(), tmxPath));
}
if (map.tileLayers().size() != 1 || !binding.layerName().equals(map.tileLayers().getFirst().name())) {
diagnostics.add(error("TMX layer mapping does not match scene-bank support metadata: " + binding.tilemap(), tmxPath));
}
} catch (TiledUnsupportedFeatureException exception) {
diagnostics.add(error(exception.getMessage(), tmxPath));
} catch (IOException exception) {
diagnostics.add(error("Unable to validate Scene Bank XML: " + exception.getMessage(), tmxPath));
}
}
return List.copyOf(diagnostics);
}
private String computeFingerprint(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
final AssetStudioSceneBankMetadata metadata = details.sceneBankMetadata();
if (metadata == null) {
return "";
}
try {
final MessageDigest digest = MessageDigest.getInstance("SHA-256");
final List<Path> files = new ArrayList<>();
files.add(metadata.supportFile());
for (AssetStudioSceneLayerBinding binding : metadata.layerBindings()) {
if (!binding.enabled()) {
continue;
}
files.add(details.summary().assetRoot().resolve(binding.tilemap()).toAbsolutePath().normalize());
if (!binding.tilesetAssetRoot().isBlank()) {
files.add(projectReference.rootPath().resolve("assets").resolve(binding.tilesetAssetRoot()).resolve("tileset.tsx").toAbsolutePath().normalize());
}
private ScenePackRequest buildCanonicalRequest(ProjectReference projectReference, AssetWorkspaceAssetDetails details) throws IOException {
final AssetStudioSceneBankMetadata metadata = Objects.requireNonNull(details.sceneBankMetadata(), "sceneBankMetadata");
final SceneLayerRuntimeDefaults sceneDefaults =
resolveSceneLayerRuntimeDefaults(projectReference, metadata.layerBindings());
final List<ScenePackLayerRequest> layers = new ArrayList<>();
for (AssetStudioSceneLayerBinding binding : metadata.layerBindings()) {
if (!binding.enabled()) {
layers.add(inactiveLayer(projectReference, binding, sceneDefaults));
continue;
}
files.stream()
.distinct()
.sorted(Comparator.comparing(Path::toString))
.forEach(path -> updateDigest(digest, path));
return HexFormat.of().formatHex(digest.digest());
} catch (Exception exception) {
return "";
layers.add(activeLayer(projectReference, binding));
}
return new ScenePackRequest(1, layers);
}
private ScenePackLayerRequest inactiveLayer(ProjectReference projectReference,
AssetStudioSceneLayerBinding binding,
SceneLayerRuntimeDefaults sceneDefaults) {
final SceneLayerRuntimeDefaults defaults = resolveLayerRuntimeDefaults(projectReference, binding, sceneDefaults);
if (defaults == null) {
throw new IllegalArgumentException("Unable to resolve runtime defaults for inactive layer " + binding.index());
}
final List<ScenePackTileRequest> tiles = new ArrayList<>(binding.tiles().size());
for (AssetStudioSceneTile tile : binding.tiles()) {
tiles.add(new ScenePackTileRequest(false, 0, tile.paletteId(), false, false));
}
return new ScenePackLayerRequest(
false,
defaults.glyphAssetId(),
defaults.tileSize(),
binding.parallaxFactorX(),
binding.parallaxFactorY(),
binding.width(),
binding.height(),
tiles);
}
private ScenePackLayerRequest activeLayer(ProjectReference projectReference, AssetStudioSceneLayerBinding binding) throws IOException {
final int glyphAssetId = resolveGlyphAssetId(projectReference, binding.tilesetAssetRoot());
if (glyphAssetId < 0) {
throw new IllegalArgumentException("Unable to resolve glyph_asset_id for " + binding.tilesetAssetRoot());
}
final int tileSize = resolveTileSize(projectReference, binding.tilesetAssetRoot());
if (tileSize <= 0) {
throw new IllegalArgumentException("Unable to resolve tile_size for " + binding.tilesetAssetRoot());
}
final List<ScenePackTileRequest> tiles = new ArrayList<>(binding.tiles().size());
for (AssetStudioSceneTile tile : binding.tiles()) {
if (!tile.active()) {
tiles.add(new ScenePackTileRequest(false, 0, tile.paletteId(), false, false));
continue;
}
tiles.add(new ScenePackTileRequest(true, tile.glyphId(), tile.paletteId(), tile.flipX(), tile.flipY()));
}
return new ScenePackLayerRequest(
true,
glyphAssetId,
tileSize,
binding.parallaxFactorX(),
binding.parallaxFactorY(),
binding.width(),
binding.height(),
tiles);
}
private SceneLayerRuntimeDefaults resolveSceneLayerRuntimeDefaults(ProjectReference projectReference,
List<AssetStudioSceneLayerBinding> bindings) {
for (AssetStudioSceneLayerBinding binding : bindings) {
final SceneLayerRuntimeDefaults defaults = resolveLayerOwnRuntimeDefaults(projectReference, binding);
if (defaults != null) {
return defaults;
}
}
return null;
}
private SceneLayerRuntimeDefaults resolveLayerRuntimeDefaults(ProjectReference projectReference,
AssetStudioSceneLayerBinding binding,
SceneLayerRuntimeDefaults sceneDefaults) {
final SceneLayerRuntimeDefaults ownDefaults = resolveLayerOwnRuntimeDefaults(projectReference, binding);
return ownDefaults != null ? ownDefaults : sceneDefaults;
}
private SceneLayerRuntimeDefaults resolveLayerOwnRuntimeDefaults(ProjectReference projectReference,
AssetStudioSceneLayerBinding binding) {
if (binding.tilesetAssetRoot().isBlank()) {
return null;
}
final int glyphAssetId = resolveGlyphAssetId(projectReference, binding.tilesetAssetRoot());
final int tileSize = resolveTileSize(projectReference, binding.tilesetAssetRoot());
if (glyphAssetId < 0 || tileSize <= 0) {
return null;
}
return new SceneLayerRuntimeDefaults(glyphAssetId, tileSize);
}
private void writeAcceptedRequest(Path path, ScenePackRequest request) throws IOException {
final var root = mapper.createObjectNode();
root.put("schema_version", 1);
root.put("format", "SCENE/tilemap_v1");
root.put("version", request.version());
final var layersNode = root.putArray("layers");
for (ScenePackLayerRequest layer : request.layers()) {
final var layerNode = layersNode.addObject();
layerNode.put("active", layer.active());
layerNode.put("glyph_asset_id", layer.glyphAssetId());
layerNode.put("tile_size", layer.tileSize());
layerNode.put("parallax_factor_x", layer.parallaxFactorX());
layerNode.put("parallax_factor_y", layer.parallaxFactorY());
layerNode.put("width", layer.width());
layerNode.put("height", layer.height());
final var tilesNode = layerNode.putArray("tiles");
for (ScenePackTileRequest tile : layer.tiles()) {
final var tileNode = tilesNode.addObject();
tileNode.put("active", tile.active());
tileNode.put("glyph_id", tile.glyphId());
tileNode.put("palette_id", tile.paletteId());
tileNode.put("flip_x", tile.flipX());
tileNode.put("flip_y", tile.flipY());
}
}
mapper.writerWithDefaultPrettyPrinter().writeValue(path.toFile(), root);
}
private int resolveGlyphAssetId(ProjectReference projectReference, String tilesetAssetRoot) {
try {
return glyphAssetResolver.resolveGlyphAssetId(projectReference, tilesetAssetRoot);
} catch (IOException exception) {
return -1;
}
}
private String computeFingerprint(ProjectReference projectReference, AssetWorkspaceAssetDetails details, int layerIndex) {
final AssetStudioSceneBankMetadata metadata = details.sceneBankMetadata();
if (metadata == null) {
return "";
private int resolveTileSize(ProjectReference projectReference, String tilesetAssetRoot) {
final Path declarationPath = projectReference.rootPath()
.resolve("assets")
.resolve(tilesetAssetRoot)
.resolve("asset.json")
.toAbsolutePath()
.normalize();
if (!Files.isRegularFile(declarationPath)) {
return -1;
}
try {
final MessageDigest digest = MessageDigest.getInstance("SHA-256");
final List<Path> files = new ArrayList<>();
files.add(metadata.supportFile());
metadata.layerBindings().stream()
.filter(AssetStudioSceneLayerBinding::enabled)
.filter(binding -> binding.index() == layerIndex)
.findFirst()
.ifPresent(binding -> {
files.add(details.summary().assetRoot().resolve(binding.tilemap()).toAbsolutePath().normalize());
if (!binding.tilesetAssetRoot().isBlank()) {
files.add(projectReference.rootPath().resolve("assets").resolve(binding.tilesetAssetRoot()).resolve("tileset.tsx").toAbsolutePath().normalize());
}
});
if (files.size() == 1) {
return "";
}
files.stream()
.distinct()
.sorted(Comparator.comparing(Path::toString))
.forEach(path -> updateDigest(digest, path));
return HexFormat.of().formatHex(digest.digest());
} catch (Exception exception) {
return "";
final JsonNode root = mapper.readTree(declarationPath.toFile());
final String value = root.path("output").path("metadata").path("tile_size").asText("").trim().toLowerCase();
return switch (value) {
case "8x8" -> 8;
case "16x16" -> 16;
case "32x32" -> 32;
default -> -1;
};
} catch (IOException exception) {
return -1;
}
}
private void updateDigest(MessageDigest digest, Path path) {
try {
if (!Files.isRegularFile(path)) {
return;
}
digest.update(path.toString().getBytes(StandardCharsets.UTF_8));
digest.update((byte) 0);
digest.update(Files.readAllBytes(path));
digest.update((byte) 0);
} catch (IOException ignored) {
}
}
private AssetWorkspaceSceneBankValidation validationState(
List<PackerDiagnosticDTO> diagnostics,
String currentFingerprint,
String validatedFingerprint,
String acceptedFingerprint) {
private AssetWorkspaceSceneBankValidation validationState(List<PackerDiagnosticDTO> diagnostics) {
if (diagnostics.stream().anyMatch(PackerDiagnosticDTO::blocking)) {
return new AssetWorkspaceSceneBankValidation(
AssetWorkspaceSceneBankStatus.VALIDATION_FAILED,
true,
false,
currentFingerprint,
validatedFingerprint,
acceptedFingerprint);
}
final boolean validated = !currentFingerprint.isBlank() && currentFingerprint.equals(validatedFingerprint);
final boolean accepted = validated && currentFingerprint.equals(acceptedFingerprint);
if (accepted) {
return new AssetWorkspaceSceneBankValidation(
AssetWorkspaceSceneBankStatus.READY,
false,
false,
currentFingerprint,
validatedFingerprint,
acceptedFingerprint);
}
if (validated) {
return new AssetWorkspaceSceneBankValidation(
AssetWorkspaceSceneBankStatus.VALIDATED_PENDING_ACCEPTANCE,
true,
true,
currentFingerprint,
validatedFingerprint,
acceptedFingerprint);
"",
"",
"");
}
return new AssetWorkspaceSceneBankValidation(
AssetWorkspaceSceneBankStatus.PENDING_VALIDATION,
true,
AssetWorkspaceSceneBankStatus.READY,
false,
currentFingerprint,
validatedFingerprint,
acceptedFingerprint);
}
private String layerValidationFile(int layerIndex) {
return "scene-bank.layer-" + layerIndex + ".validation.json";
}
private String layerAcceptanceFile(int layerIndex) {
return "scene-bank.layer-" + layerIndex + ".acceptance.json";
false,
"",
"",
"");
}
private String messageFor(AssetWorkspaceSceneBankValidation validation) {
return switch (validation.status()) {
case NOT_APPLICABLE -> "";
case PENDING_VALIDATION -> "Scene Bank has pending external changes and requires validation.";
case VALIDATED_PENDING_ACCEPTANCE -> "Scene Bank validation succeeded and is waiting for explicit acceptance.";
case READY -> "Scene Bank is ready.";
case PENDING_VALIDATION, VALIDATED_PENDING_ACCEPTANCE -> "Scene Bank canonical workflow no longer uses validation/acceptance staging.";
case READY -> "Scene Bank canonical scene is ready.";
case VALIDATION_FAILED -> "Scene Bank validation failed.";
};
}
private String readFingerprint(Path path) {
if (!Files.isRegularFile(path)) {
return "";
}
try {
final JsonNode root = mapper.readTree(path.toFile());
return root.path("fingerprint").asText("").trim();
} catch (IOException ignored) {
return "";
}
}
private void writeFingerprint(Path path, String fingerprint) throws IOException {
final var root = mapper.createObjectNode();
root.put("schema_version", 1);
root.put("fingerprint", Objects.requireNonNullElse(fingerprint, ""));
root.put("recorded_at", Instant.now().toString());
mapper.writerWithDefaultPrettyPrinter().writeValue(path.toFile(), root);
}
private PackerDiagnosticDTO error(String message, Path path) {
return new PackerDiagnosticDTO(
PackerDiagnosticSeverity.ERROR,
@@ -388,4 +338,12 @@ public final class SceneBankWorkflowService {
path,
true);
}
@FunctionalInterface
interface SceneBankGlyphAssetResolver {
int resolveGlyphAssetId(ProjectReference projectReference, String tilesetAssetRoot) throws IOException;
}
private record SceneLayerRuntimeDefaults(int glyphAssetId, int tileSize) {
}
}
@@ -0,0 +1,37 @@
package p.studio.workspaces.assets.scene;
import java.util.List;
import java.util.Objects;
public record ScenePackLayerRequest(
boolean active,
int glyphAssetId,
int tileSize,
float parallaxFactorX,
float parallaxFactorY,
int width,
int height,
List<ScenePackTileRequest> tiles) {
public ScenePackLayerRequest {
tiles = List.copyOf(Objects.requireNonNull(tiles, "tiles"));
if (glyphAssetId < 0) {
throw new IllegalArgumentException("glyphAssetId must be non-negative");
}
if (tileSize < 0) {
throw new IllegalArgumentException("tileSize must be non-negative");
}
if (width <= 0 || height <= 0) {
throw new IllegalArgumentException("width and height must be positive");
}
if (!Float.isFinite(parallaxFactorX) || parallaxFactorX < 0.0f) {
throw new IllegalArgumentException("parallaxFactorX must be finite and non-negative");
}
if (!Float.isFinite(parallaxFactorY) || parallaxFactorY < 0.0f) {
throw new IllegalArgumentException("parallaxFactorY must be finite and non-negative");
}
if (tiles.size() != width * height) {
throw new IllegalArgumentException("tiles size must match width * height");
}
}
}
@@ -0,0 +1,19 @@
package p.studio.workspaces.assets.scene;
import java.util.List;
import java.util.Objects;
public record ScenePackRequest(
int version,
List<ScenePackLayerRequest> layers) {
public ScenePackRequest {
layers = List.copyOf(Objects.requireNonNull(layers, "layers"));
if (version <= 0) {
throw new IllegalArgumentException("version must be positive");
}
if (layers.size() != 4) {
throw new IllegalArgumentException("layers must contain exactly 4 entries");
}
}
}
@@ -0,0 +1,18 @@
package p.studio.workspaces.assets.scene;
public record ScenePackTileRequest(
boolean active,
int glyphId,
int paletteId,
boolean flipX,
boolean flipY) {
public ScenePackTileRequest {
if (glyphId < 0) {
throw new IllegalArgumentException("glyphId must be non-negative");
}
if (paletteId < 0) {
throw new IllegalArgumentException("paletteId must be non-negative");
}
}
}
@@ -4,27 +4,48 @@ import p.packer.dtos.PackerCodecConfigurationFieldDTO;
import p.packer.messages.assets.AssetFamilyCatalog;
import p.studio.projects.ProjectReference;
import p.studio.workspaces.assets.metadata.AssetStudioGlyphSpecialization;
import p.studio.workspaces.assets.metadata.AssetStudioMetadataService;
import p.studio.workspaces.assets.metadata.AssetStudioSceneBankMetadata;
import p.studio.workspaces.assets.metadata.AssetStudioSceneLayerBinding;
import p.studio.workspaces.assets.metadata.AssetStudioSceneTile;
import p.studio.workspaces.assets.messages.AssetWorkspaceAssetDetails;
import p.studio.workspaces.assets.messages.AssetWorkspaceBankCompositionFile;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
public final class TiledAssetGenerationService {
public static final String GENERATED_TSX_FILE = "tileset.tsx";
private static final long FLIP_HORIZONTAL_FLAG = 0x80000000L;
private static final long FLIP_VERTICAL_FLAG = 0x40000000L;
private static final long FLIP_DIAGONAL_FLAG = 0x20000000L;
private static final long GID_MASK = ~(FLIP_HORIZONTAL_FLAG | FLIP_VERTICAL_FLAG | FLIP_DIAGONAL_FLAG);
private final TiledXmlCodec codec = new TiledXmlCodec();
private final AssetStudioMetadataService metadataService = new AssetStudioMetadataService();
public enum SceneTmxExportDisposition {
OVERWRITE,
KEEP_BOTH
}
public TiledAssetGenerationResult generateTilesetTsx(AssetWorkspaceAssetDetails details) {
return exportTilesetTsx(details);
}
public TiledAssetGenerationResult exportTilesetTsx(AssetWorkspaceAssetDetails details) {
if (details == null
|| details.summary().assetFamily() != AssetFamilyCatalog.GLYPH_BANK
|| details.summary().glyphSpecialization() != AssetStudioGlyphSpecialization.TILESET) {
return new TiledAssetGenerationResult(false, "TSX generation is available only for Tileset-specialized glyph banks.", List.of());
return new TiledAssetGenerationResult(false, "TSX export is available only for Tileset-specialized glyph banks.", List.of());
}
final List<AssetWorkspaceBankCompositionFile> selectedFiles = details.bankComposition().selectedFiles();
if (selectedFiles.isEmpty()) {
@@ -55,120 +76,330 @@ public final class TiledAssetGenerationService {
final Path outputPath = details.summary().assetRoot().resolve(GENERATED_TSX_FILE);
try {
codec.writeTileset(outputPath, document);
return new TiledAssetGenerationResult(true, "Generated TSX successfully.", List.of(outputPath));
return new TiledAssetGenerationResult(true, "Exported TSX successfully.", List.of(outputPath));
} catch (IOException exception) {
return new TiledAssetGenerationResult(false, "Unable to generate TSX: " + exception.getMessage(), List.of());
return new TiledAssetGenerationResult(false, "Unable to export TSX: " + exception.getMessage(), List.of());
}
}
public TiledAssetGenerationResult generateSceneBankTilemaps(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
if (details == null || details.summary().assetFamily() != AssetFamilyCatalog.SCENE_BANK) {
return new TiledAssetGenerationResult(false, "TMX generation is available only for Scene Bank assets.", List.of());
}
final AssetStudioSceneBankMetadata metadata = details.sceneBankMetadata();
if (metadata == null) {
return new TiledAssetGenerationResult(false, "Scene Bank support metadata is missing or invalid.", List.of());
}
final List<Path> writtenFiles = new ArrayList<>();
try {
for (AssetStudioSceneLayerBinding binding : metadata.layerBindings()) {
if (!binding.enabled()) {
continue;
}
final TiledAssetGenerationResult result = generateSceneBankTilemap(projectReference, details, binding.index());
if (!result.success()) {
return result;
}
writtenFiles.addAll(result.writtenFiles());
}
if (writtenFiles.isEmpty()) {
return new TiledAssetGenerationResult(false, "Enable at least one layer before generating TMX.", List.of());
}
return new TiledAssetGenerationResult(true, "Generated TMX successfully.", writtenFiles);
} catch (RuntimeException exception) {
return new TiledAssetGenerationResult(false, "Unable to generate TMX: " + exception.getMessage(), List.of());
}
return exportSceneBankTmx(projectReference, details);
}
public TiledAssetGenerationResult generateSceneBankTilemap(ProjectReference projectReference, AssetWorkspaceAssetDetails details, int layerIndex) {
return exportSceneBankTmx(projectReference, details);
}
public TiledAssetGenerationResult exportSceneBankTmx(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
return exportSceneBankTmx(projectReference, details, SceneTmxExportDisposition.OVERWRITE);
}
public TiledAssetGenerationResult exportSceneBankTmx(
ProjectReference projectReference,
AssetWorkspaceAssetDetails details,
SceneTmxExportDisposition disposition) {
if (details == null || details.summary().assetFamily() != AssetFamilyCatalog.SCENE_BANK) {
return new TiledAssetGenerationResult(false, "TMX generation is available only for Scene Bank assets.", List.of());
return new TiledAssetGenerationResult(false, "TMX export is available only for Scene Bank assets.", List.of());
}
final AssetStudioSceneBankMetadata metadata = details.sceneBankMetadata();
if (metadata == null) {
return new TiledAssetGenerationResult(false, "Scene Bank support metadata is missing or invalid.", List.of());
}
final AssetStudioSceneLayerBinding binding = metadata.layerBindings().stream()
.filter(candidate -> candidate.index() == layerIndex)
.findFirst()
.orElse(null);
if (binding == null) {
return new TiledAssetGenerationResult(false, "Layer " + layerIndex + " is not defined in Scene Bank metadata.", List.of());
final List<AssetStudioSceneLayerBinding> enabledLayers = metadata.layerBindings().stream()
.filter(AssetStudioSceneLayerBinding::enabled)
.toList();
if (enabledLayers.isEmpty()) {
return new TiledAssetGenerationResult(false, "Enable at least one layer before exporting TMX.", List.of());
}
if (!binding.enabled()) {
return new TiledAssetGenerationResult(false, "Layer " + layerIndex + " is disabled.", List.of());
final String sceneTilemap = resolveSceneTilemap(metadata);
if (sceneTilemap == null) {
return new TiledAssetGenerationResult(false, "Scene TMX export requires a single shared tilemap binding across Scene Bank layers.", List.of());
}
try {
final String tilesetAssetRoot = Objects.requireNonNullElse(binding.tilesetAssetRoot(), "").trim();
if (tilesetAssetRoot.isBlank()) {
return new TiledAssetGenerationResult(
false,
"Layer " + binding.index() + " must declare a non-blank tileset_asset_root before TMX generation.",
List.of());
}
final Path tilesetPath = projectReference.rootPath()
.resolve("assets")
.resolve(tilesetAssetRoot)
.resolve(GENERATED_TSX_FILE)
.toAbsolutePath()
.normalize();
if (!java.nio.file.Files.isRegularFile(tilesetPath)) {
return new TiledAssetGenerationResult(
false,
"Referenced TSX was not found for layer " + binding.index() + ": " + tilesetAssetRoot,
List.of());
}
final TiledTilesetDocument tileset = codec.readTileset(tilesetPath);
final String relativeTilesetPath = details.summary().assetRoot()
.toAbsolutePath()
.normalize()
.relativize(tilesetPath)
.toString()
.replace('\\', '/');
final int tileCount = binding.width() * binding.height();
final List<Long> gids = new ArrayList<>(tileCount);
for (int index = 0; index < tileCount; index += 1) {
gids.add(0L);
final ExportContext context = buildExportContext(projectReference, details, enabledLayers);
final List<TiledTileLayer> tileLayers = new ArrayList<>();
int nextLayerId = 1;
for (AssetStudioSceneLayerBinding binding : enabledLayers) {
final TilesetRef ref = context.tilesetByAssetRoot().get(binding.tilesetAssetRoot());
final List<Long> gids = new ArrayList<>(binding.tiles().size());
for (AssetStudioSceneTile tile : binding.tiles()) {
if (!tile.active()) {
gids.add(0L);
continue;
}
if (tile.glyphId() >= ref.tileCount()) {
return new TiledAssetGenerationResult(
false,
"Layer " + binding.index() + " references glyph_id outside the exported TSX range.",
List.of());
}
long gid = ref.firstGid() + tile.glyphId();
if (tile.flipX()) {
gid |= FLIP_HORIZONTAL_FLAG;
}
if (tile.flipY()) {
gid |= FLIP_VERTICAL_FLAG;
}
gids.add(gid);
}
tileLayers.add(new TiledTileLayer(
nextLayerId,
binding.layerName(),
binding.width(),
binding.height(),
gids,
List.of()));
nextLayerId += 1;
}
final TiledMapDocument document = new TiledMapDocument(
"1.10",
"1.12.1",
"orthogonal",
"right-down",
binding.width(),
binding.height(),
tileset.tileWidth(),
tileset.tileHeight(),
2,
enabledLayers.stream().mapToInt(AssetStudioSceneLayerBinding::width).max().orElse(1),
enabledLayers.stream().mapToInt(AssetStudioSceneLayerBinding::height).max().orElse(1),
context.tileSize(),
context.tileSize(),
nextLayerId,
1,
List.of(),
List.of(new TiledTilesetReference(1, relativeTilesetPath)),
List.of(new TiledTileLayer(
1,
context.tilesetRefs(),
tileLayers,
List.of());
final Path outputPath = details.summary().assetRoot().resolve(sceneTilemap);
final ArrayList<Path> writtenFiles = new ArrayList<>();
if (disposition == SceneTmxExportDisposition.KEEP_BOTH && Files.isRegularFile(outputPath)) {
final Path backupPath = nextSceneTmxBackupPath(outputPath);
Files.copy(outputPath, backupPath);
writtenFiles.add(backupPath);
}
codec.writeMap(outputPath, document);
writtenFiles.add(outputPath);
return new TiledAssetGenerationResult(true, "Exported TMX successfully.", List.copyOf(writtenFiles));
} catch (IOException | TiledUnsupportedFeatureException exception) {
return new TiledAssetGenerationResult(false, "Unable to export TMX: " + exception.getMessage(), List.of());
}
}
public TiledAssetGenerationResult importSceneBankTmx(ProjectReference projectReference, AssetWorkspaceAssetDetails details) {
if (details == null || details.summary().assetFamily() != AssetFamilyCatalog.SCENE_BANK) {
return new TiledAssetGenerationResult(false, "TMX import is available only for Scene Bank assets.", List.of());
}
final AssetStudioSceneBankMetadata metadata = details.sceneBankMetadata();
if (metadata == null) {
return new TiledAssetGenerationResult(false, "Scene Bank support metadata is missing or invalid.", List.of());
}
final String sceneTilemap = resolveSceneTilemap(metadata);
if (sceneTilemap == null) {
return new TiledAssetGenerationResult(false, "Scene TMX import requires a single shared tilemap binding across Scene Bank layers.", List.of());
}
final Path inputPath = details.summary().assetRoot().resolve(sceneTilemap);
if (!Files.isRegularFile(inputPath)) {
return new TiledAssetGenerationResult(false, "TMX import source is missing: " + sceneTilemap, List.of());
}
try {
final List<AssetStudioSceneLayerBinding> enabledLayers = metadata.layerBindings().stream()
.filter(AssetStudioSceneLayerBinding::enabled)
.toList();
final ExportContext context = buildExportContext(projectReference, details, enabledLayers);
final TiledMapDocument map = codec.readMap(inputPath);
if (map.tileLayers().isEmpty()) {
return new TiledAssetGenerationResult(false, "TMX import rejected: at least one tile layer is required.", List.of());
}
if (map.tileLayers().size() > metadata.layerCount()) {
return new TiledAssetGenerationResult(false, "TMX import rejected: more than four tile layers are not supported.", List.of());
}
if (map.tilesets().size() != context.tilesetRefs().size()) {
return new TiledAssetGenerationResult(false, "TMX import rejected: unexpected tileset count.", List.of());
}
for (int index = 0; index < context.tilesetRefs().size(); index += 1) {
if (!context.tilesetRefs().get(index).source().equals(map.tilesets().get(index).source())) {
return new TiledAssetGenerationResult(false, "TMX import rejected: unexpected tileset reference.", List.of());
}
}
final List<AssetStudioSceneLayerBinding> updatedBindings = new ArrayList<>();
for (int bindingIndex = 0; bindingIndex < metadata.layerBindings().size(); bindingIndex += 1) {
final AssetStudioSceneLayerBinding binding = metadata.layerBindings().get(bindingIndex);
if (bindingIndex >= map.tileLayers().size()) {
updatedBindings.add(new AssetStudioSceneLayerBinding(
false,
binding.index(),
binding.layerName(),
binding.width(),
binding.height(),
gids,
List.of())),
List.of());
final Path outputPath = details.summary().assetRoot().resolve(binding.tilemap());
codec.writeMap(outputPath, document);
return new TiledAssetGenerationResult(true, "Generated TMX for layer " + binding.index() + ".", List.of(outputPath));
} catch (TiledUnsupportedFeatureException | IOException exception) {
return new TiledAssetGenerationResult(false, "Unable to generate TMX: " + exception.getMessage(), List.of());
binding.tilemap(),
binding.tilesetAssetRoot(),
binding.parallaxFactorX(),
binding.parallaxFactorY(),
binding.defaultPaletteId(),
binding.tiles()));
continue;
}
final TiledTileLayer importedLayer = map.tileLayers().get(bindingIndex);
if (importedLayer.gids().size() != importedLayer.width() * importedLayer.height()) {
return new TiledAssetGenerationResult(false, "TMX import rejected: layer tile data does not match layer dimensions.", List.of());
}
final TilesetRef ref = resolveImportedLayerTilesetRef(importedLayer, binding, context);
if (ref == null) {
return new TiledAssetGenerationResult(false, "TMX import rejected: layer uses an unexpected tileset.", List.of());
}
final List<AssetStudioSceneTile> importedTiles = new ArrayList<>(importedLayer.width() * importedLayer.height());
for (long rawGid : importedLayer.gids()) {
if ((rawGid & FLIP_DIAGONAL_FLAG) != 0L) {
return new TiledAssetGenerationResult(false, "TMX import rejected: diagonal flips are not supported.", List.of());
}
final boolean flipX = (rawGid & FLIP_HORIZONTAL_FLAG) != 0L;
final boolean flipY = (rawGid & FLIP_VERTICAL_FLAG) != 0L;
final long gid = rawGid & GID_MASK;
if (gid == 0L) {
importedTiles.add(AssetStudioSceneTile.inactive(binding.defaultPaletteId()));
continue;
}
if (gid < ref.firstGid() || gid >= ref.firstGid() + ref.tileCount()) {
return new TiledAssetGenerationResult(false, "TMX import rejected: tile uses an unexpected tileset.", List.of());
}
final int tilesetTileId = (int) (gid - ref.firstGid());
final Integer glyphId = ref.glyphIdByTileId().get(tilesetTileId);
if (glyphId == null) {
return new TiledAssetGenerationResult(false, "TMX import rejected: tileset tile is missing glyph_id mapping.", List.of());
}
importedTiles.add(new AssetStudioSceneTile(
true,
glyphId,
binding.defaultPaletteId(),
flipX,
flipY));
}
updatedBindings.add(new AssetStudioSceneLayerBinding(
true,
binding.index(),
binding.layerName(),
importedLayer.width(),
importedLayer.height(),
binding.tilemap(),
ref.assetRoot(),
binding.parallaxFactorX(),
binding.parallaxFactorY(),
binding.defaultPaletteId(),
importedTiles));
}
final int mapWidth = Math.max(map.width(), updatedBindings.stream()
.filter(AssetStudioSceneLayerBinding::enabled)
.mapToInt(AssetStudioSceneLayerBinding::width)
.max()
.orElse(metadata.mapWidth()));
final int mapHeight = Math.max(map.height(), updatedBindings.stream()
.filter(AssetStudioSceneLayerBinding::enabled)
.mapToInt(AssetStudioSceneLayerBinding::height)
.max()
.orElse(metadata.mapHeight()));
metadataService.writeSceneBankMetadata(details.summary().assetRoot(), new AssetStudioSceneBankMetadata(
mapWidth,
mapHeight,
metadata.layerCount(),
updatedBindings,
metadata.supportFile()));
return new TiledAssetGenerationResult(true, "Imported TMX successfully.", List.of(inputPath, metadata.supportFile()));
} catch (IOException | TiledUnsupportedFeatureException exception) {
return new TiledAssetGenerationResult(false, "Unable to import TMX: " + exception.getMessage(), List.of());
}
}
private TilesetRef resolveImportedLayerTilesetRef(
TiledTileLayer importedLayer,
AssetStudioSceneLayerBinding binding,
ExportContext context) {
TilesetRef resolved = null;
for (long rawGid : importedLayer.gids()) {
final long gid = rawGid & GID_MASK;
if (gid == 0L) {
continue;
}
final TilesetRef ref = context.tilesetByAssetRoot().values().stream()
.filter(candidate -> gid >= candidate.firstGid() && gid < candidate.firstGid() + candidate.tileCount())
.findFirst()
.orElse(null);
if (ref == null) {
return null;
}
if (resolved != null && !resolved.assetRoot().equals(ref.assetRoot())) {
return null;
}
resolved = ref;
}
if (resolved != null) {
return resolved;
}
final String declaredAssetRoot = Objects.requireNonNullElse(binding.tilesetAssetRoot(), "").trim();
if (!declaredAssetRoot.isBlank()) {
return context.tilesetByAssetRoot().get(declaredAssetRoot);
}
if (context.tilesetByAssetRoot().size() == 1) {
return context.tilesetByAssetRoot().values().iterator().next();
}
return null;
}
private ExportContext buildExportContext(
ProjectReference projectReference,
AssetWorkspaceAssetDetails details,
List<AssetStudioSceneLayerBinding> enabledLayers) throws IOException {
final LinkedHashMap<String, TilesetRef> refs = new LinkedHashMap<>();
final List<TiledTilesetReference> tilesetRefs = new ArrayList<>();
int tileSize = -1;
int nextFirstGid = 1;
for (AssetStudioSceneLayerBinding binding : enabledLayers) {
if (refs.containsKey(binding.tilesetAssetRoot())) {
continue;
}
final Path tilesetPath = projectReference.rootPath()
.resolve("assets")
.resolve(binding.tilesetAssetRoot())
.resolve(GENERATED_TSX_FILE)
.toAbsolutePath()
.normalize();
if (!Files.isRegularFile(tilesetPath)) {
throw new IOException("Referenced TSX was not found for layer " + binding.index() + ": " + binding.tilesetAssetRoot());
}
final TiledTilesetDocument tileset = codec.readTileset(tilesetPath);
if (tileSize < 0) {
tileSize = tileset.tileWidth();
} else if (tileSize != tileset.tileWidth() || tileSize != tileset.tileHeight()) {
throw new IOException("All exported Scene Bank tilesets must share the same tile size.");
}
final String relativeTilesetPath = details.summary().assetRoot()
.toAbsolutePath()
.normalize()
.relativize(tilesetPath)
.toString()
.replace('\\', '/');
refs.put(binding.tilesetAssetRoot(), new TilesetRef(
nextFirstGid,
binding.tilesetAssetRoot(),
relativeTilesetPath,
tileset.tileCount(),
glyphIdByTileId(tileset)));
tilesetRefs.add(new TiledTilesetReference(nextFirstGid, relativeTilesetPath));
nextFirstGid += tileset.tileCount();
}
if (tileSize <= 0) {
throw new IOException("Unable to resolve tile size for Scene Bank export.");
}
return new ExportContext(tileSize, List.copyOf(tilesetRefs), Map.copyOf(refs));
}
private String resolveSceneTilemap(AssetStudioSceneBankMetadata metadata) {
final LinkedHashSet<String> tilemaps = new LinkedHashSet<>();
for (AssetStudioSceneLayerBinding binding : metadata.layerBindings()) {
final String tilemap = Objects.requireNonNullElse(binding.tilemap(), "").trim();
if (!tilemap.isBlank()) {
tilemaps.add(tilemap);
}
}
return tilemaps.size() == 1 ? tilemaps.iterator().next() : null;
}
private int parseTileSize(List<PackerCodecConfigurationFieldDTO> metadataFields) {
final String value = metadataFields.stream()
.filter(field -> "tile_size".equals(field.key()))
@@ -184,4 +415,56 @@ public final class TiledAssetGenerationService {
}
return 16;
}
private Path nextSceneTmxBackupPath(Path outputPath) {
final String filename = outputPath.getFileName().toString();
final int extensionOffset = filename.lastIndexOf('.');
final String stem = extensionOffset >= 0 ? filename.substring(0, extensionOffset) : filename;
final String extension = extensionOffset >= 0 ? filename.substring(extensionOffset) : "";
final Path parent = outputPath.getParent();
int sequence = 1;
while (true) {
final Path candidate = parent.resolve(stem + ".bkp-" + sequence + extension);
if (!Files.exists(candidate)) {
return candidate;
}
sequence += 1;
}
}
private Map<Integer, Integer> glyphIdByTileId(TiledTilesetDocument tileset) throws IOException {
final LinkedHashMap<Integer, Integer> glyphs = new LinkedHashMap<>();
for (TiledTilesetTile tile : tileset.tiles()) {
final Integer glyphId = tile.properties().stream()
.filter(property -> "glyph_id".equals(property.name()))
.findFirst()
.map(TiledProperty::value)
.map(String::trim)
.filter(value -> !value.isBlank())
.map(Integer::parseInt)
.orElse(null);
if (glyphId == null || glyphId < 0) {
throw new IOException("TSX tile " + tile.id() + " is missing a valid glyph_id property.");
}
glyphs.put(tile.id(), glyphId);
}
if (glyphs.size() != tileset.tileCount()) {
throw new IOException("TSX tile count does not match declared tile_count.");
}
return Map.copyOf(glyphs);
}
private record ExportContext(
int tileSize,
List<TiledTilesetReference> tilesetRefs,
Map<String, TilesetRef> tilesetByAssetRoot) {
}
private record TilesetRef(
int firstGid,
String assetRoot,
String source,
int tileCount,
Map<Integer, Integer> glyphIdByTileId) {
}
}
@@ -147,8 +147,9 @@ assets.section.actions=Actions
assets.actions.empty=No actions available for this asset.
assets.action.register=Register
assets.action.analyse=Analyse
assets.action.generateTsx=Generate TSX
assets.action.generateTmx=Generate TMX
assets.action.exportTsx=Export TSX
assets.action.exportTmx=Export TMX
assets.action.importTmx=Import TMX
assets.action.validateSceneBank=Validate Scene Bank
assets.action.acceptSceneBank=Accept Scene Bank
assets.action.validateLayer=Validate Layer
@@ -199,6 +200,8 @@ assets.label.layerOverview=Layer Overview
assets.label.tilemaps=Tilemaps
assets.label.tilemap=Tilemap
assets.label.tileset=Tileset
assets.label.parallax=Parallax
assets.label.defaultPalette=Default Palette
assets.label.supportFile=Support File
assets.label.useLayer=Use this layer
assets.type.glyphBank=Glyph Bank
@@ -99,10 +99,10 @@ final class AssetStudioMetadataServiceTest {
"map_height": 12,
"layer_count": 4,
"layers": [
{ "index": 1, "enabled": true, "name": "Ground", "width": 20, "height": 12, "tilemap": "ground.tmx", "tileset_asset_root": "tilesets/ground" },
{ "index": 2, "enabled": true, "name": "Collision", "width": 10, "height": 8, "tilemap": "collision.tmx", "tileset_asset_root": "tilesets/ground" },
{ "index": 3, "enabled": false, "name": "Layer 3", "width": 20, "height": 12, "tilemap": "layer-3.tmx", "tileset_asset_root": "" },
{ "index": 4, "enabled": false, "name": "Layer 4", "width": 20, "height": 12, "tilemap": "layer-4.tmx", "tileset_asset_root": "" }
{ "index": 1, "enabled": true, "name": "Ground", "width": 20, "height": 12, "tilemap": "ground.tmx", "tileset_asset_root": "tilesets/ground", "parallax_factor_x": 1.0, "parallax_factor_y": 1.0, "default_palette_id": 2 },
{ "index": 2, "enabled": true, "name": "Collision", "width": 10, "height": 8, "tilemap": "collision.tmx", "tileset_asset_root": "tilesets/ground", "parallax_factor_x": 0.5, "parallax_factor_y": 0.75, "default_palette_id": 3 },
{ "index": 3, "enabled": false, "name": "Layer 3", "width": 20, "height": 12, "tilemap": "layer-3.tmx", "tileset_asset_root": "", "default_palette_id": 0 },
{ "index": 4, "enabled": false, "name": "Layer 4", "width": 20, "height": 12, "tilemap": "layer-4.tmx", "tileset_asset_root": "", "default_palette_id": 0 }
]
}
""");
@@ -115,6 +115,11 @@ final class AssetStudioMetadataServiceTest {
assertEquals(4, snapshot.sceneBankMetadata().layerCount());
assertEquals(10, snapshot.sceneBankMetadata().layerBindings().get(1).width());
assertEquals(8, snapshot.sceneBankMetadata().layerBindings().get(1).height());
assertEquals(0.5f, snapshot.sceneBankMetadata().layerBindings().get(1).parallaxFactorX());
assertEquals(0.75f, snapshot.sceneBankMetadata().layerBindings().get(1).parallaxFactorY());
assertEquals(3, snapshot.sceneBankMetadata().layerBindings().get(1).defaultPaletteId());
assertEquals(20 * 12, snapshot.sceneBankMetadata().layerBindings().getFirst().tiles().size());
assertFalse(snapshot.sceneBankMetadata().layerBindings().getFirst().tiles().getFirst().active());
assertEquals(
java.util.List.of("ground.tmx", "collision.tmx"),
snapshot.sceneBankMetadata().layerBindings().stream()
@@ -134,9 +139,9 @@ final class AssetStudioMetadataServiceTest {
"map_height": 16,
"layer_count": 3,
"layers": [
{ "index": 1, "enabled": true, "name": "A", "width": 16, "height": 16, "tilemap": "a.tmx", "tileset_asset_root": "" },
{ "index": 2, "enabled": false, "name": "B", "width": 16, "height": 16, "tilemap": "b.tmx", "tileset_asset_root": "" },
{ "index": 3, "enabled": false, "name": "C", "width": 16, "height": 16, "tilemap": "c.tmx", "tileset_asset_root": "" }
{ "index": 1, "enabled": true, "name": "A", "width": 16, "height": 16, "tilemap": "a.tmx", "tileset_asset_root": "", "default_palette_id": 0 },
{ "index": 2, "enabled": false, "name": "B", "width": 16, "height": 16, "tilemap": "b.tmx", "tileset_asset_root": "", "default_palette_id": 0 },
{ "index": 3, "enabled": false, "name": "C", "width": 16, "height": 16, "tilemap": "c.tmx", "tileset_asset_root": "", "default_palette_id": 0 }
]
}
""");
@@ -145,4 +150,76 @@ final class AssetStudioMetadataServiceTest {
assertNull(snapshot.sceneBankMetadata());
}
@Test
void writesSceneBankSupportMetadataWithCanonicalLayerFields() throws Exception {
final Path assetRoot = tempDir.resolve("scene-written");
Files.createDirectories(assetRoot);
final AssetStudioSceneBankMetadata metadata = new AssetStudioSceneBankMetadata(
16,
12,
4,
List.of(
new AssetStudioSceneLayerBinding(true, 1, "Ground", 16, 12, "ground.tmx", "tilesets/ground", 1.0f, 1.0f, 2),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 16, 12, "layer-2.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 16, 12, "layer-3.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 16, 12, "layer-4.tmx", "", 1.0f, 1.0f, 0)),
assetRoot.resolve(AssetStudioMetadataService.SCENE_BANK_SUPPORT_FILE));
service.writeSceneBankMetadata(assetRoot, metadata);
final String json = Files.readString(assetRoot.resolve(AssetStudioMetadataService.SCENE_BANK_SUPPORT_FILE));
assertTrue(json.contains("\"parallax_factor_x\""));
assertTrue(json.contains("\"parallax_factor_y\""));
assertTrue(json.contains("\"default_palette_id\""));
}
@Test
void writesSceneBankSupportMetadataWithCanonicalTilesWhenPresent() throws Exception {
final Path assetRoot = tempDir.resolve("scene-tiles");
Files.createDirectories(assetRoot);
final AssetStudioSceneBankMetadata metadata = new AssetStudioSceneBankMetadata(
2,
2,
4,
List.of(
new AssetStudioSceneLayerBinding(
true,
1,
"Ground",
2,
2,
"ground.tmx",
"tilesets/ground",
1.0f,
1.0f,
2,
List.of(
new AssetStudioSceneTile(true, 7, 2, false, false),
AssetStudioSceneTile.inactive(2),
AssetStudioSceneTile.inactive(2),
AssetStudioSceneTile.inactive(2))),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 2, 2, "layer-2.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 2, 2, "layer-3.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 2, 2, "layer-4.tmx", "", 1.0f, 1.0f, 0)),
assetRoot.resolve(AssetStudioMetadataService.SCENE_BANK_SUPPORT_FILE));
service.writeSceneBankMetadata(assetRoot, metadata);
final String json = Files.readString(assetRoot.resolve(AssetStudioMetadataService.SCENE_BANK_SUPPORT_FILE));
assertTrue(json.contains("\"tiles\""));
assertTrue(json.contains("\"glyph_id\""));
}
@Test
void providesDefaultSceneBankMetadataWhenSupportFileIsMissing() throws Exception {
final Path assetRoot = tempDir.resolve("scene-missing");
Files.createDirectories(assetRoot);
final AssetStudioMetadataSnapshot snapshot = service.read(assetRoot, AssetFamilyCatalog.SCENE_BANK);
assertNotNull(snapshot.sceneBankMetadata());
assertEquals(16, snapshot.sceneBankMetadata().mapWidth());
assertEquals("scene.tmx", snapshot.sceneBankMetadata().layerBindings().getFirst().tilemap());
}
}
@@ -1,5 +1,7 @@
package p.studio.workspaces.assets.scene;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.packer.dtos.PackerCodecConfigurationFieldDTO;
@@ -12,50 +14,40 @@ import p.studio.projects.ProjectReference;
import p.studio.workspaces.assets.metadata.AssetStudioGlyphSpecialization;
import p.studio.workspaces.assets.metadata.AssetStudioSceneBankMetadata;
import p.studio.workspaces.assets.metadata.AssetStudioSceneLayerBinding;
import p.studio.workspaces.assets.metadata.AssetStudioSceneTile;
import p.studio.workspaces.assets.messages.*;
import p.studio.workspaces.assets.tiled.TiledAssetGenerationService;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
final class SceneBankWorkflowServiceTest {
private final TiledAssetGenerationService generationService = new TiledAssetGenerationService();
private final SceneBankWorkflowService workflowService = new SceneBankWorkflowService();
private final ObjectMapper mapper = new ObjectMapper();
private final SceneBankWorkflowService workflowService = new SceneBankWorkflowService((projectReference, tilesetAssetRoot) ->
"tilesets/overworld".equals(tilesetAssetRoot) ? 1 : -1);
@TempDir
Path tempDir;
@Test
void validateThenAcceptPromotesSceneBankToReadyUntilFilesChange() throws Exception {
void inspectProjectsCanonicalSceneStateIntoReadyRequest() throws Exception {
final ProjectReference project = projectReference();
final AssetWorkspaceAssetDetails sceneDetails = createValidScene(project);
final SceneBankWorkflowResult initial = workflowService.inspect(project, sceneDetails);
assertEquals(AssetWorkspaceSceneBankStatus.PENDING_VALIDATION, initial.validation().status());
assertFalse(initial.validation().canAccept());
final SceneBankWorkflowResult result = workflowService.inspect(project, sceneDetails);
final SceneBankWorkflowResult validated = workflowService.validate(project, sceneDetails);
assertEquals(AssetWorkspaceSceneBankStatus.VALIDATED_PENDING_ACCEPTANCE, validated.validation().status());
assertTrue(validated.validation().canAccept());
final SceneBankWorkflowResult accepted = workflowService.accept(project, sceneDetails);
assertEquals(AssetWorkspaceSceneBankStatus.READY, accepted.validation().status());
assertFalse(accepted.validation().pendingExternalChanges());
final Path tmxPath = sceneDetails.summary().assetRoot().resolve("ground.tmx");
Files.writeString(tmxPath, Files.readString(tmxPath).replaceFirst("0,0,0", "1,0,0"));
final SceneBankWorkflowResult changed = workflowService.inspect(project, sceneDetails);
assertEquals(AssetWorkspaceSceneBankStatus.PENDING_VALIDATION, changed.validation().status());
assertTrue(changed.validation().pendingExternalChanges());
assertEquals(AssetWorkspaceSceneBankStatus.READY, result.validation().status());
assertFalse(result.validation().pendingExternalChanges());
assertFalse(result.validation().canAccept());
assertTrue(Files.isRegularFile(sceneDetails.summary().assetRoot().resolve(SceneBankWorkflowService.ACCEPTED_REQUEST_FILE)));
}
@Test
void validationFailsWhenReferencedTsxIsMissing() throws Exception {
void validationFailsWhenReferencedGlyphAssetCannotResolveTileSize() throws Exception {
final ProjectReference project = projectReference();
final Path sceneRoot = project.rootPath().resolve("assets/scenes/broken");
Files.createDirectories(sceneRoot);
@@ -86,29 +78,43 @@ final class SceneBankWorkflowServiceTest {
8,
4,
List.of(
new AssetStudioSceneLayerBinding(true, 1, "Ground", 8, 8, "ground.tmx", "tilesets/missing"),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 8, 8, "layer-2.tmx", ""),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 8, 8, "layer-3.tmx", ""),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 8, 8, "layer-4.tmx", "")),
new AssetStudioSceneLayerBinding(true, 1, "Ground", 8, 8, "ground.tmx", "tilesets/missing", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 8, 8, "layer-2.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 8, 8, "layer-3.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 8, 8, "layer-4.tmx", "", 1.0f, 1.0f, 0)),
sceneRoot.resolve("scene-bank.studio.json")),
AssetWorkspaceSceneBankValidation.NOT_APPLICABLE,
List.of());
Files.writeString(sceneRoot.resolve("ground.tmx"), """
<?xml version="1.0" encoding="UTF-8"?>
<map version="1.10" tiledversion="1.12.1" orientation="orthogonal" renderorder="right-down"
width="8" height="8" tilewidth="16" tileheight="16" infinite="0" nextlayerid="2" nextobjectid="1">
<tileset firstgid="1" source="../../tilesets/missing/tileset.tsx"/>
<layer id="1" name="Ground" width="8" height="8">
<data encoding="csv">0</data>
</layer>
</map>
""");
final SceneBankWorkflowResult result = workflowService.inspect(project, brokenScene);
assertEquals(AssetWorkspaceSceneBankStatus.VALIDATION_FAILED, result.validation().status());
assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.message().contains("Referenced TSX file is missing")));
assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.message().contains("tile_size")));
}
@Test
void inspectPersistsCanonicalScenePackRequestUsingCanonicalTiles() throws Exception {
final ProjectReference project = projectReference();
final AssetWorkspaceAssetDetails sceneDetails = createValidScene(project);
final SceneBankWorkflowResult result = workflowService.inspect(project, sceneDetails);
assertEquals(AssetWorkspaceSceneBankStatus.READY, result.validation().status());
final JsonNode request = mapper.readTree(sceneDetails.summary().assetRoot().resolve(SceneBankWorkflowService.ACCEPTED_REQUEST_FILE).toFile());
assertEquals("SCENE/tilemap_v1", request.path("format").asText());
assertEquals(1, request.path("version").asInt());
final JsonNode firstLayer = request.path("layers").get(0);
assertTrue(firstLayer.path("active").asBoolean());
assertEquals(1, firstLayer.path("glyph_asset_id").asInt());
assertEquals(2, firstLayer.path("tiles").get(0).path("palette_id").asInt());
assertEquals(7, firstLayer.path("tiles").get(0).path("glyph_id").asInt());
assertEquals(3, firstLayer.path("tiles").get(1).path("palette_id").asInt());
assertEquals(9, firstLayer.path("tiles").get(1).path("glyph_id").asInt());
assertTrue(firstLayer.path("tiles").get(1).path("flip_x").asBoolean());
final JsonNode secondLayer = request.path("layers").get(1);
assertFalse(secondLayer.path("active").asBoolean());
assertEquals(1, secondLayer.path("glyph_asset_id").asInt());
assertEquals(16, secondLayer.path("tile_size").asInt());
}
private ProjectReference projectReference() {
@@ -119,50 +125,19 @@ final class SceneBankWorkflowServiceTest {
final Path tilesetRoot = project.rootPath().resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
assertTrue(generationService.generateTilesetTsx(tilesetDetails(tilesetRoot)).success());
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
final Path sceneRoot = project.rootPath().resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails scene = sceneDetails(sceneRoot);
assertTrue(generationService.generateSceneBankTilemaps(project, scene).success());
return scene;
}
private AssetWorkspaceAssetDetails tilesetDetails(Path assetRoot) {
return new AssetWorkspaceAssetDetails(
new AssetWorkspaceAssetSummary(
AssetReference.forAssetId(1),
"overworld_tileset",
AssetWorkspaceAssetState.REGISTERED,
AssetWorkspaceBuildParticipation.INCLUDED,
1,
AssetFamilyCatalog.GLYPH_BANK,
AssetStudioGlyphSpecialization.TILESET,
assetRoot,
false,
false),
List.of(),
OutputFormatCatalog.GLYPH_INDEXED_V1,
OutputCodecCatalog.NONE,
List.of(OutputCodecCatalog.NONE),
Map.of(OutputCodecCatalog.NONE, List.of()),
List.of(new PackerCodecConfigurationFieldDTO(
"tile_size",
"Tile Size",
PackerCodecConfigurationFieldType.ENUM,
"16x16",
true,
List.of("8x8", "16x16", "32x32"))),
Map.of(),
new AssetWorkspaceBankCompositionDetails(
List.of(),
List.of(new AssetWorkspaceBankCompositionFile("a.png", "a.png", 1L, 1L, null, Map.of())),
0L),
List.of(),
null,
null,
AssetWorkspaceSceneBankValidation.NOT_APPLICABLE,
List.of());
return sceneDetails(sceneRoot);
}
private AssetWorkspaceAssetDetails sceneDetails(Path assetRoot) {
@@ -183,7 +158,13 @@ final class SceneBankWorkflowServiceTest {
OutputCodecCatalog.NONE,
List.of(OutputCodecCatalog.NONE),
Map.of(OutputCodecCatalog.NONE, List.of()),
List.of(),
List.of(new PackerCodecConfigurationFieldDTO(
"tile_size",
"Tile Size",
PackerCodecConfigurationFieldType.ENUM,
"16x16",
true,
List.of("8x8", "16x16", "32x32"))),
Map.of(),
new AssetWorkspaceBankCompositionDetails(List.of(), List.of(), 0L),
List.of(),
@@ -193,12 +174,33 @@ final class SceneBankWorkflowServiceTest {
12,
4,
List.of(
new AssetStudioSceneLayerBinding(true, 1, "Ground", 16, 12, "ground.tmx", "tilesets/overworld"),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 16, 12, "layer-2.tmx", ""),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 16, 12, "layer-3.tmx", ""),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 16, 12, "layer-4.tmx", "")),
new AssetStudioSceneLayerBinding(
true,
1,
"Ground",
16,
12,
"ground.tmx",
"tilesets/overworld",
1.0f,
1.0f,
2,
canonicalTiles(16, 12)),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 16, 12, "layer-2.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 16, 12, "layer-3.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 16, 12, "layer-4.tmx", "", 1.0f, 1.0f, 0)),
assetRoot.resolve("scene-bank.studio.json")),
AssetWorkspaceSceneBankValidation.NOT_APPLICABLE,
List.of());
}
private List<AssetStudioSceneTile> canonicalTiles(int width, int height) {
final ArrayList<AssetStudioSceneTile> tiles = new ArrayList<>(width * height);
tiles.add(new AssetStudioSceneTile(true, 7, 2, false, false));
tiles.add(new AssetStudioSceneTile(true, 9, 3, true, false));
while (tiles.size() < width * height) {
tiles.add(AssetStudioSceneTile.inactive(2));
}
return List.copyOf(tiles);
}
}
@@ -10,12 +10,15 @@ import p.packer.messages.assets.OutputFormatCatalog;
import p.packer.messages.assets.PackerCodecConfigurationFieldType;
import p.studio.projects.ProjectReference;
import p.studio.workspaces.assets.metadata.AssetStudioGlyphSpecialization;
import p.studio.workspaces.assets.metadata.AssetStudioMetadataService;
import p.studio.workspaces.assets.metadata.AssetStudioSceneBankMetadata;
import p.studio.workspaces.assets.metadata.AssetStudioSceneLayerBinding;
import p.studio.workspaces.assets.metadata.AssetStudioSceneTile;
import p.studio.workspaces.assets.messages.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@@ -29,13 +32,13 @@ final class TiledAssetGenerationServiceTest {
Path tempDir;
@Test
void generatesTsxForTilesetSpecializedGlyphBank() throws Exception {
void exportsTsxForTilesetSpecializedGlyphBank() throws Exception {
final Path assetRoot = tempDir.resolve("assets/tilesets/overworld");
Files.createDirectories(assetRoot);
Files.writeString(assetRoot.resolve("a.png"), "fixture");
Files.writeString(assetRoot.resolve("b.png"), "fixture");
final TiledAssetGenerationResult result = service.generateTilesetTsx(tilesetDetails(assetRoot));
final TiledAssetGenerationResult result = service.exportTilesetTsx(tilesetDetails(assetRoot));
assertTrue(result.success());
final Path tsxPath = assetRoot.resolve(TiledAssetGenerationService.GENERATED_TSX_FILE);
@@ -47,28 +50,373 @@ final class TiledAssetGenerationServiceTest {
}
@Test
void generatesTmxFilesForSceneBankUsingReferencedTsx() throws Exception {
void exportsSingleSceneTmxFromCanonicalState() throws Exception {
final Path projectRoot = tempDir.resolve("project");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
assertTrue(service.generateTilesetTsx(tilesetDetails(tilesetRoot)).success());
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
final TiledAssetGenerationResult result = service.generateSceneBankTilemaps(projectReference, details);
final TiledAssetGenerationResult result = service.exportSceneBankTmx(projectReference, details);
assertTrue(result.success());
final Path tmxPath = sceneRoot.resolve("ground.tmx");
final Path tmxPath = sceneRoot.resolve("scene.tmx");
assertTrue(Files.isRegularFile(tmxPath));
final TiledMapDocument map = codec.readMap(tmxPath);
assertEquals("../../tilesets/overworld/tileset.tsx", map.tilesets().getFirst().source());
assertEquals(16, map.width());
assertEquals(12, map.height());
assertEquals(2, map.tileLayers().size());
assertEquals("Ground", map.tileLayers().getFirst().name());
assertEquals(1L, map.tileLayers().getFirst().gids().getFirst());
}
@Test
void exportsSceneTmxKeepingExistingFileAsBackup() throws Exception {
final Path projectRoot = tempDir.resolve("project-export-backup");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
final Path tmxPath = sceneRoot.resolve("scene.tmx");
Files.writeString(tmxPath, "legacy");
final TiledAssetGenerationResult result = service.exportSceneBankTmx(
projectReference,
details,
TiledAssetGenerationService.SceneTmxExportDisposition.KEEP_BOTH);
assertTrue(result.success());
final Path backupPath = sceneRoot.resolve("scene.bkp-1.tmx");
assertTrue(Files.isRegularFile(backupPath));
assertEquals("legacy", Files.readString(backupPath));
assertNotEquals("legacy", Files.readString(tmxPath));
assertTrue(result.writtenFiles().contains(backupPath));
assertTrue(result.writtenFiles().contains(tmxPath));
}
@Test
void importsSceneTmxIntoCanonicalTiles() throws Exception {
final Path projectRoot = tempDir.resolve("project-import");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
assertTrue(service.exportSceneBankTmx(projectReference, details).success());
final Path tmxPath = sceneRoot.resolve("scene.tmx");
Files.writeString(tmxPath, Files.readString(tmxPath).replaceFirst("1,0,0,0", "2147483650,0,0,0"));
final TiledAssetGenerationResult result = service.importSceneBankTmx(projectReference, details);
assertTrue(result.success());
final AssetStudioMetadataService metadataService = new AssetStudioMetadataService();
final var snapshot = metadataService.read(sceneRoot, AssetFamilyCatalog.SCENE_BANK);
assertNotNull(snapshot.sceneBankMetadata());
assertTrue(snapshot.sceneBankMetadata().layerBindings().getFirst().tiles().getFirst().active());
assertEquals(1, snapshot.sceneBankMetadata().layerBindings().getFirst().tiles().getFirst().glyphId());
assertTrue(snapshot.sceneBankMetadata().layerBindings().getFirst().tiles().getFirst().flipX());
}
@Test
void importsSceneTmxUsingGlyphIdPropertyFromTsx() throws Exception {
final Path projectRoot = tempDir.resolve("project-import-glyph-property");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
assertTrue(service.exportSceneBankTmx(projectReference, details).success());
final Path tsxPath = tilesetRoot.resolve(TiledAssetGenerationService.GENERATED_TSX_FILE);
Files.writeString(tsxPath, Files.readString(tsxPath)
.replace("value=\"0\"", "value=\"7\"")
.replace("value=\"1\"", "value=\"3\""));
final Path tmxPath = sceneRoot.resolve("scene.tmx");
Files.writeString(tmxPath, Files.readString(tmxPath).replaceFirst("1,0,0,0", "2,0,0,0"));
final TiledAssetGenerationResult result = service.importSceneBankTmx(projectReference, details);
assertTrue(result.success());
final AssetStudioMetadataService metadataService = new AssetStudioMetadataService();
final var snapshot = metadataService.read(sceneRoot, AssetFamilyCatalog.SCENE_BANK);
assertNotNull(snapshot.sceneBankMetadata());
assertEquals(3, snapshot.sceneBankMetadata().layerBindings().getFirst().tiles().getFirst().glyphId());
}
@Test
void importsSceneTmxAndPropagatesLayerDimensionsFromTmx() throws Exception {
final Path projectRoot = tempDir.resolve("project-import-resize");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
assertTrue(service.exportSceneBankTmx(projectReference, details).success());
final Path tmxPath = sceneRoot.resolve("scene.tmx");
final String resizedTmx = """
<?xml version="1.0" encoding="UTF-8"?>
<map version="1.10" tiledversion="1.12.1" orientation="orthogonal" renderorder="right-down" width="6" height="5" tilewidth="16" tileheight="16" infinite="0" nextlayerid="3" nextobjectid="1">
<tileset firstgid="1" source="../../tilesets/overworld/tileset.tsx"/>
<layer id="1" name="Ground" width="6" height="5">
<data encoding="csv">
1,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0
</data>
</layer>
<layer id="2" name="Decor" width="3" height="2">
<data encoding="csv">
2,0,0,
0,0,0
</data>
</layer>
</map>
""";
Files.writeString(tmxPath, resizedTmx);
final TiledAssetGenerationResult result = service.importSceneBankTmx(projectReference, details);
assertTrue(result.success());
final AssetStudioMetadataService metadataService = new AssetStudioMetadataService();
final var snapshot = metadataService.read(sceneRoot, AssetFamilyCatalog.SCENE_BANK);
assertNotNull(snapshot.sceneBankMetadata());
assertEquals(6, snapshot.sceneBankMetadata().mapWidth());
assertEquals(5, snapshot.sceneBankMetadata().mapHeight());
assertEquals(6, snapshot.sceneBankMetadata().layerBindings().get(0).width());
assertEquals(5, snapshot.sceneBankMetadata().layerBindings().get(0).height());
assertEquals(3, snapshot.sceneBankMetadata().layerBindings().get(1).width());
assertEquals(2, snapshot.sceneBankMetadata().layerBindings().get(1).height());
assertEquals(30, snapshot.sceneBankMetadata().layerBindings().get(0).tiles().size());
assertEquals(6, snapshot.sceneBankMetadata().layerBindings().get(1).tiles().size());
assertEquals("Ground", snapshot.sceneBankMetadata().layerBindings().get(0).layerName());
assertEquals("Decor", snapshot.sceneBankMetadata().layerBindings().get(1).layerName());
}
@Test
void importsSceneTmxAndPromotesNewLayerIntoDisabledStudioSlot() throws Exception {
final Path projectRoot = tempDir.resolve("project-import-new-layer");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
assertTrue(service.exportSceneBankTmx(projectReference, details).success());
final Path tmxPath = sceneRoot.resolve("scene.tmx");
final String expandedTmx = """
<?xml version="1.0" encoding="UTF-8"?>
<map version="1.10" tiledversion="1.12.1" orientation="orthogonal" renderorder="right-down" width="4" height="4" tilewidth="16" tileheight="16" infinite="0" nextlayerid="4" nextobjectid="1">
<tileset firstgid="1" source="../../tilesets/overworld/tileset.tsx"/>
<layer id="1" name="Ground" width="4" height="4">
<data encoding="csv">
1,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0
</data>
</layer>
<layer id="2" name="Decor" width="4" height="4">
<data encoding="csv">
2,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0
</data>
</layer>
<layer id="3" name="Collision" width="2" height="2">
<data encoding="csv">
1,0,
0,0
</data>
</layer>
</map>
""";
Files.writeString(tmxPath, expandedTmx);
final TiledAssetGenerationResult result = service.importSceneBankTmx(projectReference, details);
assertTrue(result.success());
final AssetStudioMetadataService metadataService = new AssetStudioMetadataService();
final var snapshot = metadataService.read(sceneRoot, AssetFamilyCatalog.SCENE_BANK);
assertNotNull(snapshot.sceneBankMetadata());
assertEquals(3, snapshot.sceneBankMetadata().enabledLayerCount());
assertTrue(snapshot.sceneBankMetadata().layerBindings().get(2).enabled());
assertEquals("Layer 3", snapshot.sceneBankMetadata().layerBindings().get(2).layerName());
assertEquals("tilesets/overworld", snapshot.sceneBankMetadata().layerBindings().get(2).tilesetAssetRoot());
assertEquals(2, snapshot.sceneBankMetadata().layerBindings().get(2).width());
assertEquals(2, snapshot.sceneBankMetadata().layerBindings().get(2).height());
assertEquals(0, snapshot.sceneBankMetadata().layerBindings().get(2).tiles().getFirst().glyphId());
assertFalse(snapshot.sceneBankMetadata().layerBindings().get(3).enabled());
}
@Test
void rejectsSceneTmxImportWithoutTileLayers() throws Exception {
final Path projectRoot = tempDir.resolve("project-import-no-layers");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
final Path tmxPath = sceneRoot.resolve("scene.tmx");
Files.writeString(tmxPath, """
<?xml version="1.0" encoding="UTF-8"?>
<map version="1.10" tiledversion="1.12.1" orientation="orthogonal" renderorder="right-down" width="4" height="4" tilewidth="16" tileheight="16" infinite="0" nextlayerid="1" nextobjectid="1">
<tileset firstgid="1" source="../../tilesets/overworld/tileset.tsx"/>
</map>
""");
final TiledAssetGenerationResult result = service.importSceneBankTmx(projectReference, details);
assertFalse(result.success());
assertEquals("TMX import rejected: at least one tile layer is required.", result.message());
}
@Test
void rejectsSceneTmxImportWithMoreThanFourTileLayers() throws Exception {
final Path projectRoot = tempDir.resolve("project-import-too-many-layers");
final Path tilesetRoot = projectRoot.resolve("assets/tilesets/overworld");
Files.createDirectories(tilesetRoot);
Files.writeString(tilesetRoot.resolve("a.png"), "fixture");
Files.writeString(tilesetRoot.resolve("b.png"), "fixture");
Files.writeString(tilesetRoot.resolve("asset.json"), """
{
"output": {
"metadata": {
"tile_size": "16x16"
}
}
}
""");
assertTrue(service.exportTilesetTsx(tilesetDetails(tilesetRoot)).success());
final Path sceneRoot = projectRoot.resolve("assets/scenes/overworld");
Files.createDirectories(sceneRoot);
final AssetWorkspaceAssetDetails details = sceneDetails(sceneRoot);
final ProjectReference projectReference = new ProjectReference("main", "1", "pbs", 1, projectRoot);
final Path tmxPath = sceneRoot.resolve("scene.tmx");
Files.writeString(tmxPath, """
<?xml version="1.0" encoding="UTF-8"?>
<map version="1.10" tiledversion="1.12.1" orientation="orthogonal" renderorder="right-down" width="4" height="4" tilewidth="16" tileheight="16" infinite="0" nextlayerid="6" nextobjectid="1">
<tileset firstgid="1" source="../../tilesets/overworld/tileset.tsx"/>
<layer id="1" name="A" width="4" height="4"><data encoding="csv">1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</data></layer>
<layer id="2" name="B" width="4" height="4"><data encoding="csv">1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</data></layer>
<layer id="3" name="C" width="4" height="4"><data encoding="csv">1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</data></layer>
<layer id="4" name="D" width="4" height="4"><data encoding="csv">1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</data></layer>
<layer id="5" name="E" width="4" height="4"><data encoding="csv">1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</data></layer>
</map>
""");
final TiledAssetGenerationResult result = service.importSceneBankTmx(projectReference, details);
assertFalse(result.success());
assertEquals("TMX import rejected: more than four tile layers are not supported.", result.message());
}
private AssetWorkspaceAssetDetails tilesetDetails(Path assetRoot) {
@@ -134,16 +482,25 @@ final class TiledAssetGenerationServiceTest {
List.of(),
null,
new AssetStudioSceneBankMetadata(
16,
12,
4,
4,
4,
List.of(
new AssetStudioSceneLayerBinding(true, 1, "Ground", 16, 12, "ground.tmx", "tilesets/overworld"),
new AssetStudioSceneLayerBinding(false, 2, "Layer 2", 16, 12, "layer-2.tmx", ""),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 16, 12, "layer-3.tmx", ""),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 16, 12, "layer-4.tmx", "")),
new AssetStudioSceneLayerBinding(true, 1, "Ground", 4, 4, "scene.tmx", "tilesets/overworld", 1.0f, 1.0f, 0, canonicalTiles(4, 4, 0)),
new AssetStudioSceneLayerBinding(true, 2, "Decor", 4, 4, "scene.tmx", "tilesets/overworld", 1.0f, 1.0f, 0, canonicalTiles(4, 4, 1)),
new AssetStudioSceneLayerBinding(false, 3, "Layer 3", 4, 4, "scene.tmx", "", 1.0f, 1.0f, 0),
new AssetStudioSceneLayerBinding(false, 4, "Layer 4", 4, 4, "scene.tmx", "", 1.0f, 1.0f, 0)),
assetRoot.resolve("scene-bank.studio.json")),
AssetWorkspaceSceneBankValidation.NOT_APPLICABLE,
List.of());
}
private List<AssetStudioSceneTile> canonicalTiles(int width, int height, int glyphId) {
final ArrayList<AssetStudioSceneTile> tiles = new ArrayList<>(width * height);
tiles.add(new AssetStudioSceneTile(true, glyphId, 0, false, false));
while (tiles.size() < width * height) {
tiles.add(AssetStudioSceneTile.inactive(0));
}
return List.copyOf(tiles);
}
}