public static CommandStage Select <TStreamType>(this CommandStage stage, int index)
where TStreamType : class, IStream
{
var streamId = stage.Command.StreamIdentifier <TStreamType>(index);
return(stage.Select(streamId));
}
public static CommandStage WithInput <TStreamType>(this CommandStage command, string fileName, SettingsCollection settings)
where TStreamType : class, IStream
{
command.Command.AddInput(fileName, settings);
return(command.Select(command.Command.LastInputStream <TStreamType>()));
}
//command stage
public static CommandStage WithInput <TStreamType>(this FFmpegCommand command, string fileName)
where TStreamType : class, IStream
{
var commandStage = CommandStage.Create(command);
return(commandStage.WithInput <TStreamType>(fileName));
}
public async Task Command_Stage_MaskTest()
{
CommandResponse response = null;
CommandStage commandStage = CommandStage.All;
TestCommand command = null;
command = new TestCommand(commandStage);
command.SetComandStageMask = commandStage;
response = await command.Execute();
Assert.AreEqual(4, command.StagesExecuted.Count);
commandStage = CommandStage.None;
command = new TestCommand(commandStage);
command.SetComandStageMask = commandStage;
response = await command.Execute();
Assert.AreEqual(0, command.StagesExecuted.Count);
commandStage = CommandStage.OnValidation;
command = new TestCommand(commandStage);
command.SetComandStageMask = commandStage;
response = await command.Execute();
Assert.AreEqual(1, command.StagesExecuted.Count);
}
protected override async Task <CommandResponse <VoteTracker> > ExecuteStage(CommandStage stage, CommandResponse <VoteTracker> previous)
{
switch (stage)
{
case CommandStage.OnExecuting:
var q = new QueryVote(_voteID);
var vote = await q.ExecuteAsync();
var notPassed = vote.Restrictions.FirstOrDefault(x => {
var e = x.Evaluate(User);
return(!e.Success);
});
_restrictionsPassed = notPassed == null;
break;
case CommandStage.OnExecuted:
if (previous.Success)
{
CacheHandler.Instance.Remove(CachingKey.VoteStatistics(_voteID));
}
break;
}
return(await base.ExecuteStage(stage, previous));
}
public static CommandOutput SetupCommandOutputMaps <TOutputType>(CommandStage stage, SettingsCollection settings, string fileName)
where TOutputType : class, IContainer, new()
{
var settingsCopy = settings.Copy();
var commandOutput = CommandOutput.Create(Resource.CreateOutput <TOutputType>(), settingsCopy);
stage.StreamIdentifiers.ForEach(streamId =>
{
var theStream = StreamFromStreamIdentifier(stage.Command, streamId);
var theResource = CommandInputFromStreamIdentifier(stage.Command, streamId);
if (theResource == null)
{
commandOutput.Settings.Merge(new Map(streamId), FFmpegMergeOptionType.NewWins);
}
else
{
var resourceIndex = IndexOfResource(stage.Command, streamId);
commandOutput.Settings.Merge(new Map(string.Format("{0}:{1}", resourceIndex, theStream.ResourceIndicator)),
FFmpegMergeOptionType.NewWins);
}
commandOutput.Resource.Streams.Add(theStream.Copy());
});
if (!string.IsNullOrWhiteSpace(fileName))
{
commandOutput.Resource.Name = fileName;
}
return(commandOutput);
}
public static CommandStage Select(this CommandStage stage, List <StreamIdentifier> streamIds)
{
ValidateStreams(stage, streamIds);
stage.StreamIdentifiers.AddRange(streamIds);
return(stage);
}
public static CommandStage Select(this CommandStage stage, StreamIdentifier streamId)
{
var streamIdList = new List <StreamIdentifier> {
streamId
};
return(stage.Select(streamIdList));
}
public static CommandStage Select(this CommandStage stage, params CommandStage[] stages)
{
if (stages == null || stages.Length == 0)
{
throw new ArgumentNullException("stages");
}
return(stage.Select(stages.ToList()));
}
public static CommandStage Select(this CommandStage stage, CommandInput resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
return(stage.Select(resource.GetStreamIdentifier()));
}
public static CommandStage Select <TStreamType>(this CommandStage stage, CommandInput resource)
where TStreamType : class, IStream
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
return(stage.Select(resource.GetStreamIdentifier <TStreamType>()));
}
protected override async Task <CommandResponse <Vote> > ExecuteStage(CommandStage stage, CommandResponse <Vote> previous)
{
switch (stage)
{
case CommandStage.OnExecuting:
//perform validationn return non-success if not success
break;
}
return(await base.ExecuteStage(stage, previous));
}
public static void ValidateStreams(CommandStage stage, List <StreamIdentifier> streamIds)
{
if (stage.Command.Owner == null)
{
throw new ArgumentException("Command must contain an owner before sugar is allowed.", "stage");
}
if (streamIds == null)
{
throw new ArgumentNullException("streamIds");
}
}
protected override async Task <CommandResponse <Submission> > ExecuteStage(CommandStage stage, CommandResponse <Submission> previous)
{
switch (stage)
{
case CommandStage.OnValidation:
if (_userSubmission.Content.Length > 10000)
{
return(CommandResponse.FromStatus <Submission>(null, Status.Invalid, "Content can not exceed 10,000 characters"));
}
break;
}
return(await base.ExecuteStage(stage, previous));
}
public void Command_FilterWithNoStream()
{
var command = CommandHelper.CreateCommand();
var filterchain = Filterchain.FilterTo <AudioStream>(new AEvalSrc {
Expression = "0"
});
CommandStage stage = null;
Assert.DoesNotThrow(() => stage = command.Filter(filterchain));
Assert.True(stage.StreamIdentifiers.Count == 1);
}
protected override async Task <CommandResponse <Submission> > ExecuteStage(CommandStage stage, CommandResponse <Submission> previous)
{
switch (stage)
{
case CommandStage.OnValidation:
var results = ValidationHandler.Validate(_userSubmission);
if (!results.IsNullOrEmpty())
{
return(CommandResponse.Invalid <Submission>(results));
}
break;
}
return(await base.ExecuteStage(stage, previous));
}
public static List <CommandOutput> To <TOutputType>(this CommandStage stage, string fileName, SettingsCollection settings)
where TOutputType : class, IContainer, new()
{
ValidateTo(stage.Command);
var commandOutput = CommandHelperUtility.SetupCommandOutput <TOutputType>(stage.Command, settings, fileName);
stage.Command.OutputManager.Add(commandOutput);
return(new List <CommandOutput>
{
commandOutput
});
}
public void Command_WithInputVsAddInput_Verify()
{
var command = CommandHelper.CreateCommand();
Assert.Throws <ArgumentException>(() => command.AddInput(string.Empty));
Assert.Throws <ArgumentException>(() => command.WithInput <VideoStream>(string.Empty));
var stage = CommandStage.Create(command);
stage = command.AddInput(Assets.Utilities.GetVideoFile())
.WithInput <VideoStream>(Assets.Utilities.GetVideoFile());
Assert.True(command.Inputs.Count == 2);
Assert.True(stage.StreamIdentifiers.Count == 1);
}
public static CommandStage Select(this CommandStage stage, List <CommandStage> stages)
{
var streams = new List <StreamIdentifier>();
foreach (var commandStage in stages)
{
if (commandStage.StreamIdentifiers == null)
{
continue;
}
streams.AddRange(commandStage.StreamIdentifiers);
}
return(stage.Select(streams));
}
public static CommandStage WithInput <TStreamType>(this CommandStage command, List <string> files)
where TStreamType : class, IStream
{
if (files == null || files.Count == 0)
{
throw new ArgumentException("Files cannot be null or empty.", "files");
}
var streamIds = files.Select(fileName =>
{
command.Command.AddInput(fileName);
return(command.Command.LastInputStream <TStreamType>());
}).ToList();
return(command.Select(streamIds));
}
private static void RemuxToMpeg4Container(JobConfiguration jobConfiguration)
{
CommandFactory factory = CommandFactory.Create();
FFmpegCommand command = factory.CreateOutputCommand();
CommandStage chain = command.WithInput <VideoStream>(jobConfiguration.InputFile);
SettingsCollection outputSettings = SettingsCollection.ForOutput(new CodecVideo(VideoCodecType.Copy),
new CodecAudio(AudioCodecType.Copy));
chain.To <Mp4>(jobConfiguration.OutputFile, outputSettings);
Console.WriteLine($"Remuxing {jobConfiguration.InputFile}");
try {
factory.Render();
// Console.WriteLine($"Remuxed {jobConfiguration.OutputFile}");
if (jobConfiguration.RemoveInputFileAfterRemux && File.Exists(jobConfiguration.OutputFile))
{
File.Delete(jobConfiguration.InputFile);
}
} catch (FFmpegRenderingException e) {
Console.WriteLine($"Remuxing failed for file {jobConfiguration.InputFile}: {e.Message}");
}
}
public static CommandStage WithInput <TStreamType>(this CommandStage command, string fileName)
where TStreamType : class, IStream
{
return(command.WithInput <TStreamType>(fileName, SettingsCollection.ForInput()));
}
public void SelectMinion(PositionVO _position)
{
Minion selectedMinion;
switch (stage)
{
case GameStage.Command:
switch(commandStage)
{
case CommandStage.WaitingForSelection:
selectedMinion = MinionManager.Instance.GetMinionByPosition(_position);
if (selectedMinion != null)
{
selectedMinionID = selectedMinion.ID;
commandStage = CommandStage.WaitingForOrder;
GameUIManager.Instance.ControlCommandButton(true);
}
break;
case CommandStage.WaitingForOrder:
selectedMinion = MinionManager.Instance.GetMinionByPosition(_position);
if (selectedMinion != null)
{
selectedMinionID = selectedMinion.ID;
commandStage = CommandStage.WaitingForOrder;
GameUIManager.Instance.ControlCommandButton(true);
}
else
{
selectedMinionID = -1;
commandStage = CommandStage.WaitingForSelection;
GameUIManager.Instance.ControlCommandButton(false);
}
break;
case CommandStage.SelectingTarget:
if (selectedMinionID == -1)
{
Debug.LogError("SelectingTarget but no minion Selected");
return;
}
Result _result = MinionManager.Instance.GetMinionByID(selectedMinionID).CheckCommandValid(commandType, skillNum, _position);
if(_result.Success)
{
CommandManager.Instance.SetCommand(selectedMinionID, commandType, skillNum, _position);
commandStage = CommandStage.WaitingForSelection;
}
else
{
// Show Info To Player The reason why it failed
Debug.Log ("Command Failed: " + _result.Reason);
}
GameUIManager.Instance.ControlCommandButton(false);
break;
}
break;
case GameStage.Fight:
break;
}
Debug.Log("after commandStage: " + commandStage);
}
public void SelectCommand(int _commandButtonIndex)
{
Debug.Log("before commandStage: " + commandStage);
if (commandStage != CommandStage.WaitingForOrder)
{
Debug.LogError("commandStage is not WaitingForOrder");
return;
}
if(selectedMinionID == -1)
{
Debug.LogError("No Minion Selected");
return;
}
Minion minion = MinionManager.Instance.GetMinionByID(selectedMinionID);
if (minion == null)
{
Debug.LogError("Selected Minion ID Not Valid");
return;
}
switch(_commandButtonIndex)
{
case 0:
commandType = CommandType.StandBy;
commandStage = CommandStage.WaitingForSelection;
break;
case 1:
commandType = CommandType.Attack;
commandStage = CommandStage.SelectingTarget;
break;
case 2:
commandType = CommandType.Move;
commandStage = CommandStage.SelectingTarget;
break;
default:
commandType = CommandType.Skill;
skillNum = _commandButtonIndex - 3;
commandStage = CommandStage.SelectingTarget;
break;
}
GameUIManager.Instance.ControlCommandButton(false);
Debug.Log("after commandStage: " + commandStage);
}
public static CommandStage Select(this CommandStage stage, int index)
{
var streamId = stage.Command.StreamIdentifier(index);
return(stage.Select(streamId));
}
public static CommandStage WithInputNoLoad(this CommandStage command, string fileName)
{
command.Command.AddInputNoLoad(fileName);
return(command.Select(command.Command.LastInputStream()));
}
public static CommandStage OnError(this CommandStage stage, Action <ICommandFactory, ICommand, ICommandProcessor> action)
{
stage.Command.OnErrorAction = action;
return(stage);
}
public static CommandStage Filter(this CommandStage stage, FilterchainTemplate filterchainTemplate)
{
var outputStreamIdentifiers = filterchainTemplate.SetupTemplate(stage.Command, stage.StreamIdentifiers);
return(stage.Command.Select(outputStreamIdentifiers));
}
public static CommandStage AfterRender(this CommandStage stage, Action <ICommandFactory, ICommand, bool> action)
{
stage.Command.PostExecutionAction = action;
return(stage);
}
public static List <CommandOutput> To <TOutputType>(this CommandStage stage, SettingsCollection settings)
where TOutputType : class, IContainer, new()
{
return(stage.To <TOutputType>(string.Empty, settings));
}
public static List <CommandOutput> To <TOutputType>(this CommandStage stage)
where TOutputType : class, IContainer, new()
{
return(stage.To <TOutputType>(SettingsCollection.ForOutput()));
}
public static CommandStage FilterEach(this CommandStage stage, Filterchain filterchain)
{
var outputStreamIdentifiers = stage.Command.FilterchainManager.AddToEach(filterchain, stage.StreamIdentifiers.ToArray());
return(stage.Command.Select(outputStreamIdentifiers));
}
