private static void StartBuild(int playerCount)
{
FlowSettings settings = ScriptableObject.CreateInstance <FlowSettings>();
BuildTarget target = BuildTarget.StandaloneWindows64;
EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Standalone, target);
string server = GetScenePath(settings.TEST_SCENE_SERVER);
BuildPlayerOptions serverOptions = new BuildPlayerOptions();
serverOptions.scenes = new[] { server };
serverOptions.target = target;
serverOptions.locationPathName = "Build/server/server.exe";
serverOptions.options = BuildOptions.EnableHeadlessMode | BuildOptions.AutoRunPlayer;
BuildPipeline.BuildPlayer(serverOptions);
for (int i = 1; i <= playerCount; i++)
{
string client = GetScenePath(settings.TEST_SCENE_CLIENT);
BuildPlayerOptions clientOptions = new BuildPlayerOptions();
clientOptions.scenes = new[] { client };
clientOptions.target = target;
clientOptions.locationPathName = "Build/clients/client" + i.ToString() + "/client.exe";
clientOptions.options = BuildOptions.AutoRunPlayer;
BuildPipeline.BuildPlayer(clientOptions);
}
}
public ModulesFactory(IOptions <FlowSettings> settings, ILoggerFactory loggerFactory, IListener listener, IAnnouncer announcer)
{
this.listener = listener;
this.announcer = announcer;
this.settings = settings.Value;
this.loggerFactory = loggerFactory;
}
private void UpdateViewOnNext(FlowSettings flowSettings)
{
if (forwardRepopulateStack.Count == 0)
{
return;
}
ViewFieldsListPair pair = forwardRepopulateStack.Pop();
if (pair == null)
{
return;
}
DoUpdate(flowSettings.ScreenSettings.View);
void DoUpdate(ViewBase view)
{
if (!pair.View.Equals(view))
{
forwardRepopulateStack.Clear();
return;
}
view.UpdateFields(pair.Fields);
}
}
/// <summary>
/// setup necessary stuff for the client
/// </summary>
void Setup()
{
settings = FlowSettings;
FlowActions.settings = settings;
FlowActions.isClient = true;
flowActions = gameObject.AddComponent <FlowActions>();
IsEnabled = true;
}
private void FlowSettingsChanged(FlowSettings flowSettings)
{
flowSettings.FlowDataCache.NavigationBar.MenuItems
.ForEach(item => item.Active = item.InitialModule == flowSettings.FlowDataCache.NavigationBar.CurrentModule);
ChangePage(flowSettings.ScreenSettings.CreatePage());
UpdateNavigationMenu(flowSettings);
}
public async Task RunFlow(NewFlowRequest request)
{
DateTime dt = DateTime.Now;
FlowSettings flowSettings = await this.FlowManager.NewFlowStart(request);
DateTime dt2 = DateTime.Now;
appLogger.LogMessage(nameof(ScopedFlowManagerService), $"RunFlow (milliseconds) = {(dt2 - dt).TotalMilliseconds}");
}
public async Task Start()
{
DateTime dt = DateTime.Now;
FlowSettings flowSettings = await this.FlowManager.Start("home");
DateTime dt2 = DateTime.Now;
appLogger.LogMessage(nameof(ScopedFlowManagerService), $"Start (milliseconds) = {(dt2 - dt).TotalMilliseconds}");
uiNotificationService.NotifyFlowSettingsChanged(flowSettings);
}
public async Task Next(CommandButtonRequest request)
{
DateTime dt = DateTime.Now;
FlowSettings flowSettings = await this.FlowManager.Next(request);
DateTime dt2 = DateTime.Now;
appLogger.LogMessage(nameof(ScopedFlowManagerService), $"Next (milliseconds) = {(dt2 - dt).TotalMilliseconds}");
uiNotificationService.NotifyFlowSettingsChanged(flowSettings);
}
/// <summary>
/// Sets up rudimentary stuff for the server
/// </summary>
void Setup()
{
settings = FlowSettings;
FlowActions.settings = FlowSettings;
flowActions = gameObject.AddComponent <FlowActions>();
// setup unity to run on the defined tickrate
Time.fixedDeltaTime = 1f / settings.TICK_RATE;
QualitySettings.vSyncCount = 0;
Application.targetFrameRate = settings.TICK_RATE;
}
private FlowSettings UpdateFlowSettings(FlowSettings flowSettings, NavigationType navigationType = NavigationType.Next)
{
this.FlowDataCache = flowSettings.FlowDataCache;
this.ScreenSettings = flowSettings.ScreenSettings;
flowSettings.NavigationType = navigationType;
if (flowSettings.ScreenSettings.ViewType != ViewType.Exception)
{
Task.Run(async() => await flowStateRepository.SaveFlowState(flowSettings.FlowState)); //just fire and forget
}
return(flowSettings);
}
private void FlowSettingsChanged(FlowSettings flowSettings)
{
flowSettings.NavigationBar.MenuItems
.ForEach(item => item.Active = item.InitialModule == flowSettings.NavigationBar.CurrentModule);
/*To Remove*/
if (flowSettings.ScreenSettings == null)
{
return;
}
ChangePage(flowSettings.ScreenSettings.CreatePage());
UpdateNavigationMenu(flowSettings);
}
private void UpdateViewOnPrevious(FlowSettings flowSettings)
{
ViewFieldsListPair pair = previousRepopulateStack.Pop();
if (pair == null)
{
return;
}
DoUpdate(flowSettings.ScreenSettings.View);
void DoUpdate(ViewBase view)
{
if (pair.View.GetType() != view.GetType())
{
return;
}
view.UpdateFields(pair.Fields);
}
}
private void UpdateNavigationMenuOnNext(FlowSettings flowSettings)
{
if (ViewModel.MenuItems.Count == 0)
{
ViewModel.MenuItems = new ObservableCollection <MenuItem>(flowSettings.FlowDataCache.DialogList);
}
else
{
for (int i = 0; i < ViewModel.MenuItems.Count; i++)
{
if (ViewModel.MenuItems[i].Equals(flowSettings.FlowDataCache.DialogList[i]))
{
continue;
}
ViewModel.MenuItems[i] = flowSettings.FlowDataCache.DialogList[i];
}
ViewModel.MenuItems.Add(flowSettings.FlowDataCache.DialogList.Last());
}
}
private void UpdateNavigationMenu(FlowSettings flowSettings)
{
//ViewModel.MenuItems.Clear();
navView.MenuItems.Clear();
navView.SelectedItem = null;
//Need to manually clear the navigation view because
//of unpredictable behaviour in the Top Nav. The left nav worked fine without clearing.
if (flowSettings.NavigationType == NavigationType.Start)
{
UpdateNavigationMenuOnStart(flowSettings);
}
if (flowSettings.NavigationType == NavigationType.Next)
{
UpdateNavigationMenuOnNext(flowSettings);
}
if (flowSettings.NavigationType == NavigationType.Previous)
{
UpdateNavigationMenuOnPrevious(flowSettings);
}
}
private void UpdateNavigationMenuOnPrevious(FlowSettings flowSettings)
{
if (ViewModel.MenuItems.Count == 0)//should never happen beacuse the Resume navigation type is Next
{
ViewModel.MenuItems = new ObservableCollection <MenuItem>(flowSettings.FlowDataCache.DialogList);
}
else
{
ViewModel.MenuItems
.Skip(flowSettings.FlowDataCache.DialogList.Count)
.ToList()
.ForEach(m => ViewModel.MenuItems.Remove(m));
for (int i = 0; i < flowSettings.FlowDataCache.DialogList.Count; i++)
{
if (ViewModel.MenuItems[i].Equals(flowSettings.FlowDataCache.DialogList[i]))
{
continue;
}
ViewModel.MenuItems[i] = flowSettings.FlowDataCache.DialogList[i];
}
}
}
private void FlowSettingsChanged(FlowSettings flowSettings)
{
if (flowSettings.ScreenSettings.ViewType != ViewType.Exception)
{
int stage = -1;
flowSettings.FlowDataCache.DialogList.ForEach(item =>
{
item.Stage = ++stage;
item.Last = item.Equals(flowSettings.FlowDataCache.DialogList.Last());
if (item.Text.Length > 20)
{
item.Text = string.Concat(item.Text.Substring(0, 20), "...");
}
});
UpdateNavigationMenu(flowSettings);
ViewModel.BackButtonEnabled = ViewModel.MenuItems?.Count > 1;
}
if (flowSettings.NavigationType == NavigationType.Next || flowSettings.NavigationType == NavigationType.Start)
{
if (flowSettings.ScreenSettings.ViewType == ViewType.Exception)
{
SetExceptionDialog(flowSettings.ScreenSettings);
}
else
{
SetNextDialog(flowSettings.ScreenSettings);
}
}
if (flowSettings.NavigationType == NavigationType.Previous)
{
SetPreviousDialog(flowSettings.ScreenSettings);
}
}
public FlowService(IOptions <FlowSettings> flowSettings)
{
this.flowSettings = flowSettings.Value;
}
public async Task Next(RequestBase request)
{
FlowSettings flowSettings = await Task.Run(() => this.FlowManager.Next(request));
this.FlowSettings.OnNext(UpdateFlowSettings(flowSettings, NavigationType.Next));
}
protected SourceBlockBase(BlockHeader header, FlowSettings settings, LinkRouterBase <T> router) : base(header, settings)
{
Router = router;
Children = new List <ITargetBlock <T> >();
}
private FlowSettings DoGet(FlowSettings settings, Action <FlowSettings> updateView)
{
updateView(settings);
settings.FlowState = new FlowState(this.previousDataStack, this.previousRepopulateStack, this.forwardRepopulateStack);
return(settings);
}
private void UpdateNavigationMenu(FlowSettings flowSettings) => ViewModel.MenuItems = new ObservableCollection <NavigationMenuItemDescriptor>(flowSettings.FlowDataCache.NavigationBar.MenuItems);
protected BlockBase(BlockHeader header, FlowSettings settings)
{
Header = header;
FlowSettings = settings;
}
public void NotifyFlowSettingsChanged(FlowSettings flowSettings)
{
this.FlowSettings = flowSettings;
this.FlowSettingsSubject.OnNext(flowSettings);
}
private void UpdateNavigationMenuOnStart(FlowSettings flowSettings)
{
ViewModel.MenuItems.Clear();
ViewModel.MenuItems = new ObservableCollection <MenuItem>(flowSettings.FlowDataCache.DialogList);
}
