public TitleViewModel(IScreen screen) : base(screen, "main")
{
using var store = new ModsDataStore();
IsLoaded = store.GetPlayableMods().Any();
SettingsAction = ReactiveCommand.CreateFromObservable(() => HostScreen.Router.Navigate.Execute(new SettingsViewModel(HostScreen)));
ModsAction = ReactiveCommand.CreateFromObservable(() => HostScreen.Router.Navigate.Execute(new ModsViewModel(HostScreen)));
MatchupAction = ReactiveCommand.CreateFromObservable(() => HostScreen.Router.Navigate.Execute(new GenerationViewModel(HostScreen)));
CloseApp = ReactiveCommand.Create(() => Environment.Exit(0));
}
private async Task <IList <ModItemViewModel> > GetModsAsync()
{
return(await Observable.Start(() =>
{
using var store = new ModsDataStore();
return dowModService.GetUnloadedMods()
.Select(unloaded => new ModItemViewModel()
{
Module = unloaded,
IsLoaded = store.GetAll().Any(mod => unloaded.File.ModFolder.Equals(mod.ModFolder) &&
mod.IsVanilla == unloaded.File.IsVanilla)
}).ToList();
}, RxApp.TaskpoolScheduler));
}
private async Task LoadAllMods()
{
using var store = new ModsDataStore();
store.DropAll();
Dictionary <string, UnloadedMod> allUnloaded = BaseGameItems.Concat(ModItems)
.GroupBy(item => item.Module.File.ModFolder, item => item.Module)
.ToDictionary(g => g.Key, g => g.First());
foreach (var item in BaseGameItems.Concat(ModItems))
{
item.IsLoaded = false;
}
var memo = new LoadMemo();
foreach (var item in BaseGameItems.Concat(ModItems).Where(mod => mod.Module.File.Playable))
{
DowMod mod = await Observable.Start(() =>
dowModService.LoadMod(item.Module, allUnloaded, memo), RxApp.TaskpoolScheduler);
store.Add(mod);
item.IsLoaded = true;
}
// Yeah this is kind of weird. But essentially we want to load the playable mods first.
// This is because they likely depend on the non-playable mods. Non-playable mods may be
// sub-modules for playable mods. As such they might have Locales that reference the parent mod
// for this reason we want to ensure that we load from the root.
foreach (var item in BaseGameItems.Concat(ModItems).Where(mod => !mod.Module.File.Playable))
{
DowMod mod = dowModService.LoadMod(item.Module, allUnloaded, memo);
store.Add(mod);
item.IsLoaded = true;
}
}
public GenerationViewModel(IScreen screen) : base(screen, "generation")
{
GameTab = new GameTabViewModel();
TeamTab = new TeamTabViewModel();
using var store = new ModsDataStore();
DowMod[] mods = store.GetPlayableMods().ToArray();
IEnumerable <DowMod> addonMods = mods.Where(mod => !mod.IsVanilla && DowConstants.IsVanilla(mod.ModFolder));
IEnumerable <DowMod> baseMods = mods.Where(mod => mod.IsVanilla || !DowConstants.IsVanilla(mod.ModFolder));
GeneralTab = new GeneralTabViewModel(addonMods.SelectMany(mod => mod.Maps).ToList());
Mod = new OptionInputViewModel <DowMod>(mod => mod.Name, baseMods.ToArray());
RefreshMod = ReactiveCommand.Create((DowMod mod) =>
{
GeneralTab.Mod = mod;
});
GenerateMatchupAction = ReactiveCommand.CreateFromObservable(() =>
{
var settings = new GenerationSettings()
{
Mod = Mod.SelectedItem.Item,
Maps = GeneralTab.Maps.Items.Concat(GeneralTab.AddonMaps.Items)
.Where(map => map.IsEnabled && map.IsToggled)
.Select(map => map.Item).ToList(),
Rules = GeneralTab.Rules.Items
.Where(rule => rule.IsToggled)
.Select(rule => rule.Item).ToList()
};
foreach (var diff in GameTab.DiffOption.Items)
{
settings.GameDifficultyTickets[(int)diff.Item] = diff.Input;
}
foreach (var speed in GameTab.SpeedOption.Items)
{
settings.GameSpeedTickets[(int)speed.Item] = speed.Input;
}
foreach (var rate in GameTab.RateOption.Items)
{
settings.ResourceRateTickets[(int)rate.Item] = rate.Input;
}
foreach (var start in GameTab.StartingOption.Items)
{
settings.StartResourceTickets[(int)start.Item] = start.Input;
}
return(HostScreen.Router.Navigate.Execute(new MatchupViewModel(HostScreen, settings)));
});
this.WhenAnyValue(x => x.Mod.SelectedItem)
.DistinctUntilChanged()
.Select(mod => mod.Item)
.InvokeCommand(RefreshMod);
}
public GeneralTabViewModel(List <DowMap> addonMaps)
{
addonMaps.Sort(MapSort);
AddonMaps = new ToggleItemListViewModel <DowMap>("Addon Maps");
AddonMaps.SetItems(addonMaps.Select(map => new ToggleItemViewModel <DowMap>(true)
{
Label = $"{map.Name} [{map.Size}]", Item = map
}));
Maps = new ToggleItemListViewModel <DowMap>("Maps");
Rules = new ToggleItemListViewModel <GameRule>("Win Conditions");
RefreshForMod = ReactiveCommand.CreateFromTask(async(int id) =>
{
var(maps, rules) = await Observable.Start(() =>
{
using var store = new ModsDataStore();
return(store.GetMaps(id).ToList(), store.GetRules(id).ToList());
}, RxApp.TaskpoolScheduler);
maps.Sort(MapSort);
Maps.SetItems(maps.Select(map => new ToggleItemViewModel <DowMap>(true)
{
Label = $"{map.Name} [{map.Size}]", Item = map
}));
Rules.SetItems(rules.Where(rule => rule.IsWinCondition)
.Select(rule => new ToggleItemViewModel <GameRule>(true)
{
Label = rule.Name, Item = rule
}));
});
var sizeToToggle = new Dictionary <int, ToggleItemViewModel <int> >();
var playerToToggle = new Dictionary <int, ToggleItemViewModel <int> >();
ToggleMapPlayerFilter = ReactiveCommand.Create((ToggleItemViewModel <int> player) =>
{
foreach (var map in Maps.Items.Concat(AddonMaps.Items))
{
if (map.Item.Players == player.Item &&
sizeToToggle.GetValueOrDefault(map.Item.Size) is ToggleItemViewModel <int> size &&
size.IsToggled)
{
map.IsEnabled = player.IsToggled;
}
}
});
ToggleMapSizeFilter = ReactiveCommand.Create((ToggleItemViewModel <int> size) =>
{
foreach (var map in Maps.Items.Concat(AddonMaps.Items))
{
if (map.Item.Size == size.Item &&
playerToToggle.GetValueOrDefault(map.Item.Players) is ToggleItemViewModel <int> players &&
players.IsToggled)
{
map.IsEnabled = size.IsToggled;
}
}
});
foreach (var players in Enumerable.Range(2, 7))
{
var item = new ToggleItemViewModel <int>(true)
{
Label = $"{players}p", Item = players
};
MapTypes.Add(item);
playerToToggle.Add(players, item);
item.WhenAnyValue(x => x.IsToggled)
.DistinctUntilChanged()
.Select(x => item)
.InvokeCommand(ToggleMapPlayerFilter);
}
foreach (int size in Enum.GetValues(typeof(MapSize)))
{
var item = new ToggleItemViewModel <int>(true)
{
Label = size.ToString(), Item = size
};
MapSizes.Add(item);
sizeToToggle.Add(size, item);
item.WhenAnyValue(x => x.IsToggled)
.DistinctUntilChanged()
.Select(x => item)
.InvokeCommand(ToggleMapSizeFilter);
}
this.WhenAnyValue(x => x.Mod)
.Where(mod => mod != null)
.Select(mod => mod.Id)
.DistinctUntilChanged()
.InvokeCommand(RefreshForMod);
}
