Studio scene pack contract for runtime SCENE binary payload
This commit is contained in:
@@ -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));
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
+97
-24
@@ -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.");
|
||||
|
||||
-1
@@ -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));
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -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")));
|
||||
|
||||
+139
-31
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+74
-2
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
+53
-1
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
+22
@@ -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);
|
||||
}
|
||||
}
|
||||
+240
-282
@@ -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) {
|
||||
}
|
||||
}
|
||||
|
||||
+37
@@ -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");
|
||||
}
|
||||
}
|
||||
}
|
||||
+18
@@ -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");
|
||||
}
|
||||
}
|
||||
}
|
||||
+367
-84
@@ -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
|
||||
|
||||
+84
-7
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
+86
-84
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
+371
-14
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user