okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d486eff1ed1ce5e4f003bc9163982a1dbb51c2ec
EVEngine/test/action_timeline.cpp
T

388 lines
20 KiB
C++
Raw Blame History

#include "action/Action.h"
#include "action/ActionTimeline.h"
#include "action/editor/ActionTimelineEditor.h"
#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include <string_view>
namespace {
eve::LogicalId id(std::string_view value) {
auto parsed = eve::LogicalId::parse(value);
REQUIRE(parsed.has_value());
return std::move(*parsed);
}
eve::action::ActionTimeline timelineFixture() {
eve::action::ActionTimeline timeline;
timeline.actionId = id("combat:light-attack");
timeline.duration = eve::Duration::fromNanoseconds(100);
timeline.animationUri = "asset://animations/light-attack.eva";
eve::action::ActionTrack gameplay;
gameplay.id = id("combat-track:gameplay");
gameplay.label = "Gameplay";
gameplay.kind = eve::action::ActionTrackKind::Gameplay;
gameplay.notifies.push_back({id("combat-notify:begin"), id("combat-event:combo-open"), eve::Duration::zero(), {}});
gameplay.notifies.push_back({id("combat-notify:hit"),
id("combat-event:deal-damage"),
eve::Duration::fromNanoseconds(20),
{{"damage", eve::Value(25)}}});
gameplay.states.push_back({id("combat-state:buffer"),
id("combat-state-type:input-buffer"),
eve::Duration::fromNanoseconds(10),
eve::Duration::fromNanoseconds(30),
{}});
timeline.tracks.push_back(std::move(gameplay));
return timeline;
}
} // namespace
TEST_CASE("actionTimeline.versionedRoundTripAndDeterministicSampling") {
auto timeline = timelineFixture();
auto valid = timeline.validate();
REQUIRE(valid.ok());
auto encoded = timeline.toValue();
REQUIRE(encoded.ok());
auto json = encoded.value().toJson();
REQUIRE(json.ok());
auto parsedValue = eve::Value::fromJson(json.value());
REQUIRE(parsedValue.ok());
auto decoded = eve::action::ActionTimeline::fromValue(parsedValue.value());
REQUIRE(decoded.ok());
auto reencoded = decoded.value().toValue();
REQUIRE(reencoded.ok());
auto reencodedJson = reencoded.value().toJson();
REQUIRE(reencodedJson.ok());
CHECK_EQ(reencodedJson.value(), json.value());
auto sampled = decoded.value().sample(eve::Duration::zero(), eve::Duration::fromNanoseconds(30), true);
REQUIRE(sampled.ok());
REQUIRE_EQ(sampled.value().size(), 4u);
CHECK_EQ(sampled.value()[0].itemId, id("combat-notify:begin"));
CHECK_EQ(static_cast<int>(sampled.value()[1].kind),
static_cast<int>(eve::action::ActionTimelineEventKind::StateEnter));
CHECK_EQ(sampled.value()[2].itemId, id("combat-notify:hit"));
CHECK_EQ(static_cast<int>(sampled.value()[3].kind),
static_cast<int>(eve::action::ActionTimelineEventKind::StateExit));
auto active = decoded.value().activeBlocks(eve::Duration::fromNanoseconds(20));
REQUIRE(active.ok());
REQUIRE_EQ(active.value().size(), 1u);
CHECK_EQ(active.value()[0].itemId, id("combat-state:buffer"));
CHECK_EQ(active.value()[0].localTime, eve::Duration::fromNanoseconds(10));
CHECK_EQ(active.value()[0].duration, eve::Duration::fromNanoseconds(20));
auto ended = decoded.value().activeBlocks(eve::Duration::fromNanoseconds(30));
REQUIRE(ended.ok());
CHECK(ended.value().empty());
CHECK(!decoded.value().activeBlocks(eve::Duration::fromNanoseconds(101)).ok());
}
TEST_CASE("actionTimeline.disabledItemsPersistAndDoNotProjectRuntimeState") {
auto timeline = timelineFixture();
timeline.tracks[0].notifies[1].enabled = false;
timeline.tracks[0].states[0].enabled = false;
auto encoded = timeline.toValue();
REQUIRE(encoded.ok());
auto decoded = eve::action::ActionTimeline::fromValue(encoded.value());
REQUIRE(decoded.ok());
CHECK(!decoded.value().tracks[0].notifies[1].enabled);
CHECK(!decoded.value().tracks[0].states[0].enabled);
auto sampled = decoded.value().sample(eve::Duration::zero(), eve::Duration::fromNanoseconds(30), true);
REQUIRE(sampled.ok());
REQUIRE_EQ(sampled.value().size(), 1U);
CHECK_EQ(sampled.value()[0].itemId, id("combat-notify:begin"));
auto active = decoded.value().activeBlocks(eve::Duration::fromNanoseconds(20));
REQUIRE(active.ok());
CHECK(active.value().empty());
}
TEST_CASE("gameplayAction.advanceProjectsAuthoredTimelineBoundaries") {
eve::action::ActionDefinition definition;
definition.id = id("combat:light-attack");
definition.timing.windup = eve::Duration::fromNanoseconds(100);
definition.timeline = timelineFixture();
eve::action::ActionRequest request;
request.actionId = definition.id;
eve::action::ActionRuntime runtime;
auto submitted = runtime.submit(definition, request);
REQUIRE(submitted.ok());
const auto execution = std::move(submitted).takeValue();
auto started = runtime.advance(execution, eve::SimulationTick{1}, eve::Duration::zero());
REQUIRE(started.ok());
REQUIRE_EQ(started.value().timelineEvents.size(), 1u);
CHECK_EQ(started.value().timelineEvents[0].itemId, id("combat-notify:begin"));
auto crossed = runtime.advance(execution, eve::SimulationTick{2}, eve::Duration::fromNanoseconds(20));
REQUIRE(crossed.ok());
REQUIRE_EQ(crossed.value().timelineEvents.size(), 2u);
CHECK_EQ(crossed.value().timelineEvents[0].itemId, id("combat-state:buffer"));
CHECK_EQ(crossed.value().timelineEvents[1].itemId, id("combat-notify:hit"));
REQUIRE_EQ(crossed.value().activeBlocks.size(), 1u);
CHECK_EQ(crossed.value().activeBlocks[0].itemId, id("combat-state:buffer"));
CHECK_EQ(crossed.value().activeBlocks[0].localTime, eve::Duration::fromNanoseconds(10));
}
TEST_CASE("actionTimelineEditor.editsPreviewAndUndoThroughCanonicalTarget") {
eve::editor::ActionTimelineEditor editor("asset.combat.light-attack", timelineFixture());
eve::editor::EditorWorkspace workspace("combat", "Combat Editor");
auto configured = editor.configureWorkspace(workspace);
REQUIRE(configured.ok());
CHECK_EQ(workspace.getPanelCount(), 4);
CHECK_EQ(workspace.getActivePanel(), "action.timeline");
eve::action::ActionNotify effect{id("combat-notify:spark"),
id("combat-event:spawn-effect"),
eve::Duration::fromNanoseconds(40),
{{"uri", "asset://vfx/sword-spark"}}};
auto added = editor.addNotify(id("combat-track:gameplay"), effect);
REQUIRE(added.ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies.size(), 3u);
CHECK(editor.canUndo());
auto selected = editor.boxSelect(eve::Duration::fromNanoseconds(15), eve::Duration::fromNanoseconds(45));
REQUIRE(selected.ok());
CHECK_EQ(selected.value(), 3u);
auto copied = editor.copySelection();
REQUIRE(copied.ok());
CHECK_EQ(copied.value(), 3u);
auto undone = editor.undo();
REQUIRE(undone.ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies.size(), 2u);
CHECK(editor.canRedo());
auto redone = editor.redo();
REQUIRE(redone.ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies.size(), 3u);
auto seek = editor.seek(eve::Duration::zero());
REQUIRE(seek.ok());
editor.play();
auto previewed = editor.update(eve::Duration::fromNanoseconds(20));
REQUIRE(previewed.ok());
CHECK_EQ(previewed.value(), 3u);
CHECK_EQ(editor.previewEvents()[2].itemId, id("combat-notify:hit"));
}
TEST_CASE("actionTimelineEditor.editsPhysicalSectionSplitsAtomically") {
eve::editor::ActionTimelineEditor editor("asset.combat.sections", timelineFixture());
REQUIRE(editor.addSectionSplit(eve::Duration::fromNanoseconds(60)).ok());
REQUIRE(editor.addSectionSplit(eve::Duration::fromNanoseconds(30)).ok());
REQUIRE_EQ(editor.target().timeline().splitTimestamps.size(), 2U);
CHECK_EQ(editor.target().timeline().splitTimestamps[0], eve::Duration::fromNanoseconds(30));
CHECK_EQ(editor.target().timeline().splitTimestamps[1], eve::Duration::fromNanoseconds(60));
const auto duplicateRevision = editor.target().revision();
CHECK(!editor.addSectionSplit(eve::Duration::fromNanoseconds(30)).ok());
CHECK_EQ(editor.target().revision(), duplicateRevision);
REQUIRE(editor.setSectionSplit(0, eve::Duration::fromNanoseconds(80)).ok());
CHECK_EQ(editor.target().timeline().splitTimestamps[0], eve::Duration::fromNanoseconds(60));
CHECK_EQ(editor.target().timeline().splitTimestamps[1], eve::Duration::fromNanoseconds(80));
const auto collisionRevision = editor.target().revision();
CHECK(!editor.setSectionSplit(0, eve::Duration::fromNanoseconds(80)).ok());
CHECK_EQ(editor.target().revision(), collisionRevision);
REQUIRE(editor.removeSectionSplit(1).ok());
REQUIRE_EQ(editor.target().timeline().splitTimestamps.size(), 1U);
REQUIRE(editor.undo().ok());
REQUIRE_EQ(editor.target().timeline().splitTimestamps.size(), 2U);
CHECK_EQ(editor.target().timeline().splitTimestamps[1], eve::Duration::fromNanoseconds(80));
}
TEST_CASE("actionTimelineEditor.movesAlignsAndScalesSelectionAtomically") {
eve::editor::ActionTimelineEditor editor("asset.combat.selection", timelineFixture());
REQUIRE(editor.selectItem(id("combat-notify:hit")).ok());
REQUIRE(editor.selectItem(id("combat-state:buffer"), true).ok());
auto range = editor.selectionRange();
REQUIRE(range.ok());
CHECK_EQ(range.value().start, eve::Duration::fromNanoseconds(10));
CHECK_EQ(range.value().end, eve::Duration::fromNanoseconds(30));
REQUIRE(editor.moveSelection(eve::Duration::fromNanoseconds(10)).ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies[1].time, eve::Duration::fromNanoseconds(30));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].start, eve::Duration::fromNanoseconds(20));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].end, eve::Duration::fromNanoseconds(40));
REQUIRE(editor.undo().ok());
REQUIRE(editor.alignSelectionStart().ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies[1].time, eve::Duration::fromNanoseconds(10));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].start, eve::Duration::fromNanoseconds(10));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].end, eve::Duration::fromNanoseconds(30));
REQUIRE(editor.undo().ok());
REQUIRE(editor.alignSelectionEnd().ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies[1].time, eve::Duration::fromNanoseconds(30));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].start, eve::Duration::fromNanoseconds(10));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].end, eve::Duration::fromNanoseconds(30));
REQUIRE(editor.undo().ok());
REQUIRE(editor.scaleSelection(eve::Duration::fromNanoseconds(20), eve::Duration::fromNanoseconds(60)).ok());
CHECK_EQ(editor.target().timeline().tracks[0].notifies[1].time, eve::Duration::fromNanoseconds(40));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].start, eve::Duration::fromNanoseconds(20));
CHECK_EQ(editor.target().timeline().tracks[0].states[0].end, eve::Duration::fromNanoseconds(60));
REQUIRE(editor.undo().ok());
REQUIRE(editor.setTrackLocked(id("combat-track:gameplay"), true).ok());
const auto before = editor.target().timeline();
CHECK(!editor.moveSelection(eve::Duration::fromNanoseconds(1)).ok());
CHECK_EQ(editor.target().timeline().toValue().value().toJson().value(), before.toValue().value().toJson().value());
}
TEST_CASE("actionTimelineEditor.sharesDeepClipboardAcrossDocumentsAndPastesTracks") {
auto clipboard = std::make_shared<eve::editor::ActionTimelineClipboard>();
eve::editor::ActionTimelineEditor source("asset.combat.source", timelineFixture(), clipboard);
auto destinationTimeline = timelineFixture();
destinationTimeline.actionId = id("combat:alternate-attack");
destinationTimeline.tracks[0].id = id("combat-track:alternate");
destinationTimeline.tracks[0].label = "Alternate";
destinationTimeline.tracks[0].notifies.clear();
destinationTimeline.tracks[0].states.clear();
eve::action::ActionTrack collision;
collision.id = id("combat-track:gameplay.copy.1");
collision.label = "Existing Copy";
collision.kind = eve::action::ActionTrackKind::Gameplay;
destinationTimeline.tracks.push_back(std::move(collision));
eve::editor::ActionTimelineEditor destination("asset.combat.destination", std::move(destinationTimeline),
clipboard);
REQUIRE(source.copyTrack(id("combat-track:gameplay")).ok());
auto pastedTrack = destination.pasteTrack();
REQUIRE(pastedTrack.ok());
CHECK_EQ(pastedTrack.value(), id("combat-track:gameplay.copy.2"));
REQUIRE_EQ(destination.target().timeline().tracks.size(), 3U);
const auto& track = destination.target().timeline().tracks.back();
CHECK_EQ(track.label, "Gameplay Copy");
REQUIRE_EQ(track.notifies.size(), 2U);
REQUIRE_EQ(track.states.size(), 1U);
CHECK(track.notifies[0].id != source.target().timeline().tracks[0].notifies[0].id);
CHECK(track.states[0].id != source.target().timeline().tracks[0].states[0].id);
REQUIRE(destination.undo().ok());
CHECK_EQ(destination.target().timeline().tracks.size(), 2U);
REQUIRE(source.selectItem(id("combat-notify:hit")).ok());
auto copied = source.copySelection();
REQUIRE(copied.ok());
CHECK_EQ(copied.value(), 1U);
auto pastedItem = destination.pasteToTrack(id("combat-track:alternate"), eve::Duration::fromNanoseconds(10));
REQUIRE(pastedItem.ok());
CHECK_EQ(pastedItem.value(), 1U);
REQUIRE_EQ(destination.target().timeline().tracks[0].notifies.size(), 1U);
CHECK_EQ(destination.target().timeline().tracks[0].notifies[0].time, eve::Duration::fromNanoseconds(30));
REQUIRE(destination.setTrackLocked(id("combat-track:alternate"), true).ok());
const auto before = destination.target().timeline().toValue().value().toJson().value();
CHECK(!destination.pasteToTrack(id("combat-track:alternate"), eve::Duration::zero()).ok());
CHECK_EQ(destination.target().timeline().toValue().value().toJson().value(), before);
}
TEST_CASE("actionTimelineDocuments.openSaveReconcileAndProtectDirtyTabs") {
eve::editor::MemoryAtomicDocumentStore store;
eve::editor::DocumentService documents(&store);
eve::editor::ActionTimelineDocumentWorkspace workspace(documents);
auto first = workspace.open({eve::editor::DocumentKind::Timeline, eve::editor::AssetGuid("light-attack")},
"Light Attack", "content://Actions/LightAttack.action", timelineFixture());
REQUIRE(first.ok());
auto secondTimeline = timelineFixture();
secondTimeline.actionId = id("combat:heavy-attack");
auto second = workspace.open({eve::editor::DocumentKind::Timeline, eve::editor::AssetGuid("heavy-attack")},
"Heavy Attack", "content://Actions/HeavyAttack.action", secondTimeline);
REQUIRE(second.ok());
CHECK_EQ(workspace.activeDocument(), second.value());
REQUIRE_EQ(workspace.tabs().value().size(), 2U);
auto* editor = workspace.activeEditor();
REQUIRE(editor != nullptr);
REQUIRE(editor->renameTrack(id("combat-track:gameplay"), "Heavy Gameplay").ok());
auto dirtyTabs = workspace.tabs();
REQUIRE(dirtyTabs.ok());
CHECK(dirtyTabs.value()[1].dirty);
auto protectedClose = workspace.close(second.value(), eve::editor::ActionTimelineCloseMode::ProtectDirty);
CHECK(!protectedClose.ok());
CHECK_EQ(protectedClose.code(), eve::editor::EditorStatus::Conflict);
auto saved = workspace.save(second.value());
REQUIRE(saved.ok());
CHECK(!saved.value().dirty());
CHECK(!workspace.tabs().value()[1].dirty);
eve::editor::DocumentService external(&store);
auto externalOpened = external.open(
{eve::editor::DocumentKind::Timeline, eve::editor::AssetGuid("heavy-attack")}, "Heavy Attack",
"content://Actions/HeavyAttack.action");
REQUIRE(externalOpened.ok());
auto externallyEdited = secondTimeline;
externallyEdited.tracks[0].label = "External Gameplay";
auto externalValue = externallyEdited.toValue();
REQUIRE(externalValue.ok());
REQUIRE(external.edit(externalOpened.value().id, eve::editor::toEditorValue(externalValue.value())).ok());
auto externalTicket = external.requestSave(externalOpened.value().id);
REQUIRE(externalTicket.ok());
REQUIRE(external.executeSave(externalTicket.value()).ok());
auto reconciled = workspace.reconcile(second.value());
REQUIRE(reconciled.ok());
REQUIRE(workspace.activeEditor() != nullptr);
CHECK_EQ(workspace.activeEditor()->target().timeline().tracks[0].label, "External Gameplay");
CHECK(!workspace.activeEditor()->canUndo());
auto externalSnapshot = external.snapshot(externalOpened.value().id);
REQUIRE(externalSnapshot.ok());
eve::editor::EditorValue invalid(eve::editor::EditorValue::Object{{"schema", "not-an-action-timeline"}});
REQUIRE(external.edit(externalOpened.value().id, invalid, externalSnapshot.value().revision.edit).ok());
externalTicket = external.requestSave(externalOpened.value().id);
REQUIRE(externalTicket.ok());
REQUIRE(external.executeSave(externalTicket.value()).ok());
auto invalidExternal = workspace.reconcile(second.value());
CHECK(!invalidExternal.ok());
CHECK_EQ(invalidExternal.code(), eve::editor::EditorStatus::Conflict);
CHECK_EQ(workspace.activeEditor()->target().timeline().tracks[0].label, "External Gameplay");
CHECK_EQ(documents.content(second.value()).value(), workspace.activeEditor()->target().snapshotValue());
externallyEdited.tracks[0].label = "External Recovered";
externalValue = externallyEdited.toValue();
REQUIRE(externalValue.ok());
externalSnapshot = external.snapshot(externalOpened.value().id);
REQUIRE(externalSnapshot.ok());
REQUIRE(external.edit(externalOpened.value().id, eve::editor::toEditorValue(externalValue.value()),
externalSnapshot.value().revision.edit)
.ok());
externalTicket = external.requestSave(externalOpened.value().id);
REQUIRE(externalTicket.ok());
REQUIRE(external.executeSave(externalTicket.value()).ok());
REQUIRE(workspace.reconcile(second.value()).ok());
CHECK_EQ(workspace.activeEditor()->target().timeline().tracks[0].label, "External Recovered");
REQUIRE(workspace.activeEditor()->renameTrack(id("combat-track:gameplay"), "Unsaved Local").ok());
externallyEdited.tracks[0].label = "External Again";
externalValue = externallyEdited.toValue();
REQUIRE(externalValue.ok());
externalSnapshot = external.snapshot(externalOpened.value().id);
REQUIRE(externalSnapshot.ok());
REQUIRE(external.edit(externalOpened.value().id, eve::editor::toEditorValue(externalValue.value()),
externalSnapshot.value().revision.edit)
.ok());
externalTicket = external.requestSave(externalOpened.value().id);
REQUIRE(externalTicket.ok());
REQUIRE(external.executeSave(externalTicket.value()).ok());
auto conflict = workspace.reconcile(second.value());
CHECK(!conflict.ok());
CHECK_EQ(conflict.code(), eve::editor::EditorStatus::Conflict);
CHECK_EQ(workspace.activeEditor()->target().timeline().tracks[0].label, "Unsaved Local");
REQUIRE(workspace.close(second.value(), eve::editor::ActionTimelineCloseMode::Discard).ok());
CHECK_EQ(workspace.activeDocument(), first.value());
REQUIRE(workspace.close(first.value(), eve::editor::ActionTimelineCloseMode::ProtectDirty).ok());
CHECK(workspace.activeDocument().empty());
}
Reference in new issue View Git Blame Copy Permalink