/// <summary>
/// Load a Storyboard from a data URI "data:*".
/// </summary>
/// <param name="path">
/// The path to the required storyboard of pattern {asset-bundle}/{text-asset}/{storyboard-name}
/// if not cached, or simply the storyboard name if part of an already cached board.
/// </param>
/// <param name="onLoaded">Callback to Invoke when loaded.</param>
public void LoadData(string path, UnityAction <StoryboardData> onLoaded)
{
// Data based storyboards are cached by the storyboard name. The initial storyboard is named after the asset.
var(assetPath, boardname) = path.SplitOnLast('/');
// Storyboard data already loaded. Trigger callback immediately.
if (CachedBoardData.ContainsKey(boardname))
{
onLoaded.Invoke(CachedBoardData[boardname]);
return;
}
// Load storyboard data, cache, and give callback
_ = StartCoroutine(assetLoader.LoadAsync <TextAsset>(
path,
textAsset => {
if (textAsset == null)
{
return;
}
var parser = new StoryboardParser();
var boardData = parser.Parse(textAsset);
foreach (var entry in boardData)
{
CachedBoardData[entry.Key] = entry.Value;
}
onLoaded.Invoke(CachedBoardData[boardname]);
}
));
}
/// <summary>
/// Attempts to load a storyboard set from the given data file and output information about the result.
/// </summary>
public void LoadStoryboardDataFromAsset()
{
var storyboardParser = new StoryboardParser();
var storyboards = storyboardParser.Parse(loadableStoryboardData);
var outputBuilder = new StringBuilder("Parsed Storyboards:");
foreach (var entry in storyboards)
{
outputBuilder.AppendLine($"Parsed storyboard {entry.Key}");
foreach (var property in entry.Value.Properties)
{
outputBuilder.AppendLine($"Storyboard Property: {property.Key}={property.Value}");
}
var panelCount = 1;
foreach (var panel in entry.Value.Panels)
{
outputBuilder.AppendLine($"Parsed Panel {panelCount}");
outputBuilder.AppendLine($"\tType = {panel.Type.ToString()}");
foreach (var property in panel.Properties)
{
outputBuilder.AppendLine($"\tProperty: {property.Key}={property.Value}");
}
}
}
outputElement.text = outputBuilder.ToString();
}
public StoryboardParserTests()
{
blockFactory = new FakeBlockFactory();
dismissNodes = new();
parsingContext = A.Fake<IParsingContext>(i => i.Strict());
A.CallTo(() => parsingContext.RegisterDismissNode(A<INode>.Ignored))
.Invokes(i => dismissNodes.Add(i.Arguments.Get<INode>(0)));
A.CallTo(() => parsingContext.BlockFactory).Returns(blockFactory);
rootBlockParser = A.Fake<IRootBlockParser>(i => i.Strict());
sceneNavigator = A.Fake<ISceneNavigator>(i => i.Strict());
eventManager = A.Fake<IEventManager>(i => i.Strict());
randomizer = A.Fake<IRandomizer>(i => i.Strict());
navigationState = A.Fake<INavigationState>(i => i.Strict());
variableDictionary = A.Fake<IVariableDictionary>(i => i.Strict());
blockState = A.Fake<IBlockState>(i => i.Strict());
var serviceProvider = A.Fake<IServiceProvider>(i => i.Strict());
A.CallTo(() => serviceProvider.GetService(typeof(IParsingContext))).Returns(parsingContext);
A.CallTo(() => serviceProvider.GetService(typeof(IRootBlockParser))).Returns(rootBlockParser);
A.CallTo(() => serviceProvider.GetService(typeof(ISceneNavigator))).Returns(sceneNavigator);
A.CallTo(() => serviceProvider.GetService(typeof(IEventManager))).Returns(eventManager);
A.CallTo(() => serviceProvider.GetService(typeof(IRandomizer))).Returns(randomizer);
A.CallTo(() => serviceProvider.GetService(typeof(INavigationState))).Returns(navigationState);
A.CallTo(() => serviceProvider.GetService(typeof(IVariableDictionary))).Returns(variableDictionary);
A.CallTo(() => serviceProvider.GetService(typeof(IBlockState))).Returns(blockState);
sut = new StoryboardParser(serviceProvider);
}
public void PromptAndEmotion()
{
var sb = StoryboardParser.Parse(this.GetResourceStream("PromptAndEmotion.xml"));
var prot = sb.GetSingle <ProtagonistItem>();
var mood = prot.GetSingle <ProtagonistMoodItem>();
var prompt = mood.GetSingle <PromptItem>();
prompt.GetSingle <ProtagonistThoughtItem>().GetSingle <ProtagonistThoughtTextItem>().Text.Should().Be("...");
}
public async Task ForwardBackward(string prefix)
{
var expectedForward = this.GetResourceString(prefix + "_Forward.txt");
var expectedBackward = this.GetResourceString(prefix + "_Backward.txt");
var sb = StoryboardParser.Parse(this.GetResourceStream(prefix + ".xml"));
var listener = new EventListener(sb.Context);
(await listener.ForwardAsync(sb)).Should().Be(expectedForward);
(await listener.BackwardAsync(sb)).Should().Be(expectedBackward);
(await listener.ForwardAsync(sb)).Should().Be(expectedForward);
(await listener.BackwardAsync(sb)).Should().Be(expectedBackward);
}
