public CustomTileSelectorLogic(Widget widget, World world, WorldRenderer worldRenderer)
: base(widget, world, worldRenderer, "TILETEMPLATE_LIST", "TILEPREVIEW_TEMPLATE")
{
terrainInfo = world.Map.Rules.TerrainInfo as ITemplatedTerrainInfo;
if (terrainInfo == null)
{
throw new InvalidDataException("CustomTileSelectorLogic requires a template-based tileset.");
}
terrainRenderer = world.WorldActor.TraitOrDefault <ITiledTerrainRenderer>();
if (terrainRenderer == null)
{
throw new InvalidDataException("TileSelectorLogic requires a tile-based terrain renderer.");
}
allTemplates = terrainInfo.Templates.Values.Select(t => new TileSelectorTemplate(t)).ToArray();
editorCursor = world.WorldActor.Trait <EditorCursorLayer>();
allCategories = allTemplates.SelectMany(t => t.Categories)
.Distinct()
.OrderBy(CategoryOrder)
.ToArray();
foreach (var c in allCategories)
{
SelectedCategories.Add(c);
FilteredCategories.Add(c);
}
SearchTextField.OnTextEdited = () =>
{
searchFilter = SearchTextField.Text.Trim();
FilteredCategories.Clear();
if (!string.IsNullOrEmpty(searchFilter))
{
FilteredCategories.AddRange(
allTemplates.Where(t => t.SearchTerms.Any(
s => s.IndexOf(searchFilter, StringComparison.OrdinalIgnoreCase) >= 0))
.SelectMany(t => t.Categories)
.Distinct()
.OrderBy(CategoryOrder));
}
else
{
FilteredCategories.AddRange(allCategories);
}
InitializePreviews();
};
InitializePreviews();
}
public override IEnumerator <SortOrderModel> GetEnumerator()
{
foreach (var src in RankCaches)
{
var prob = new ProblemStatisticsModel[Problems.Count];
for (int i = 0; i < Problems.Count; i++)
{
prob[i] = new ProblemStatisticsModel();
}
var teams = new List <TeamModel>();
int rank = 0, last_rank = 0;
(int point, int penalty, int lastac)last = (int.MinValue, int.MinValue, int.MinValue);
foreach (var item in src)
{
if (!Affiliations.ContainsKey(item.AffiliationId) ||
!Categories.ContainsKey(item.CategoryId) ||
!(FilteredAffiliations?.Contains(item.AffiliationId) ?? true) ||
!(FilteredCategories?.Contains(item.CategoryId) ?? true) ||
(!Categories[item.CategoryId].IsPublic && !ShowHiddenCategories))
{
continue;
}
var team = CreateTeamViewModel(
item,
Affiliations[item.AffiliationId],
Categories[item.CategoryId],
IsPublic,
prob);
rank++;
var now = (team.Points, team.Penalty, team.LastAc);
if (last != now)
{
(last_rank, last) = (rank, now);
}
team.ContestId = IsPublic ? default(int?) : ContestId;
team.Rank = last_rank;
team.ShowRank = last_rank == rank;
teams.Add(team);
}
if (teams.Count == 0)
{
continue;
}
yield return(new SortOrderModel(teams, prob));
}
}
private void RefreshFilteredList(Category category = null)
{
FilteredCategories.Clear();
// Filter only the specific Category
if (category != null)
{
FilteredCategories.Add(category);
}
else
{
_categoryMatchFinder.SearchCategories(SearchText, Categories)
.ForEach(c => FilteredCategories.Add(c));
}
}
public TileSelectorLogic(Widget widget, World world, WorldRenderer worldRenderer)
: base(widget, world, worldRenderer, "TILETEMPLATE_LIST", "TILEPREVIEW_TEMPLATE")
{
tileset = world.Map.Rules.TileSet;
allTemplates = tileset.Templates.Values.Select(t => new TileSelectorTemplate(t)).ToArray();
editorCursor = world.WorldActor.Trait <EditorCursorLayer>();
allCategories = allTemplates.SelectMany(t => t.Categories)
.Distinct()
.OrderBy(CategoryOrder)
.ToArray();
foreach (var c in allCategories)
{
SelectedCategories.Add(c);
FilteredCategories.Add(c);
}
SearchTextField.OnTextEdited = () =>
{
searchFilter = SearchTextField.Text.Trim();
FilteredCategories.Clear();
if (!string.IsNullOrEmpty(searchFilter))
{
FilteredCategories.AddRange(
allTemplates.Where(t => t.SearchTerms.Any(
s => s.IndexOf(searchFilter, StringComparison.OrdinalIgnoreCase) >= 0))
.SelectMany(t => t.Categories)
.Distinct()
.OrderBy(CategoryOrder));
}
else
{
FilteredCategories.AddRange(allCategories);
}
InitializePreviews();
};
InitializePreviews();
}
public ActorSelectorLogic(Widget widget, World world, WorldRenderer worldRenderer)
: base(widget, world, worldRenderer, "ACTORTEMPLATE_LIST", "ACTORPREVIEW_TEMPLATE")
{
mapRules = world.Map.Rules;
ownersDropDown = widget.Get <DropDownButtonWidget>("OWNERS_DROPDOWN");
editorCursor = world.WorldActor.Trait <EditorCursorLayer>();
var editorLayer = world.WorldActor.Trait <EditorActorLayer>();
selectedOwner = editorLayer.Players.Players.Values.First();
Func <PlayerReference, ScrollItemWidget, ScrollItemWidget> setupItem = (option, template) =>
{
var item = ScrollItemWidget.Setup(template, () => selectedOwner == option, () => SelectOwner(option));
item.Get <LabelWidget>("LABEL").GetText = () => option.Name;
item.GetColor = () => option.Color;
return(item);
};
editorLayer.OnPlayerRemoved = () =>
{
if (editorLayer.Players.Players.Values.Any(p => p.Name == selectedOwner.Name))
{
return;
}
SelectOwner(editorLayer.Players.Players.Values.First());
};
ownersDropDown.OnClick = () =>
{
var owners = editorLayer.Players.Players.Values.OrderBy(p => p.Name);
ownersDropDown.ShowDropDown("LABEL_DROPDOWN_TEMPLATE", 270, owners, setupItem);
};
ownersDropDown.Text = selectedOwner.Name;
ownersDropDown.TextColor = selectedOwner.Color;
var tileSetId = world.Map.Rules.TerrainInfo.Id;
var allActorsTemp = new List <ActorSelectorActor>();
foreach (var a in mapRules.Actors.Values)
{
// Partial templates are not allowed
if (a.Name.Contains('^'))
{
continue;
}
// Actor must have a preview associated with it
if (!a.HasTraitInfo <IRenderActorPreviewInfo>())
{
continue;
}
var editorData = a.TraitInfoOrDefault <MapEditorDataInfo>();
// Actor must be included in at least one category
if (editorData == null || editorData.Categories == null)
{
continue;
}
// Excluded by tileset
if (editorData.ExcludeTilesets != null && editorData.ExcludeTilesets.Contains(tileSetId))
{
continue;
}
if (editorData.RequireTilesets != null && !editorData.RequireTilesets.Contains(tileSetId))
{
continue;
}
var tooltip = a.TraitInfos <EditorOnlyTooltipInfo>().FirstOrDefault(ti => ti.EnabledByDefault) as TooltipInfoBase
?? a.TraitInfos <TooltipInfo>().FirstOrDefault(ti => ti.EnabledByDefault);
var searchTerms = new List <string>()
{
a.Name
};
if (tooltip != null)
{
searchTerms.Add(tooltip.Name);
}
var tooltipText = (tooltip == null ? "Type: " : tooltip.Name + "\nType: ") + a.Name;
allActorsTemp.Add(new ActorSelectorActor(a, editorData.Categories, searchTerms.ToArray(), tooltipText));
}
allActors = allActorsTemp.ToArray();
allCategories = allActors.SelectMany(ac => ac.Categories)
.Distinct()
.OrderBy(x => x)
.ToArray();
foreach (var c in allCategories)
{
SelectedCategories.Add(c);
FilteredCategories.Add(c);
}
SearchTextField.OnTextEdited = () =>
{
searchFilter = SearchTextField.Text.Trim();
FilteredCategories.Clear();
if (!string.IsNullOrEmpty(searchFilter))
{
FilteredCategories.AddRange(
allActors.Where(t => t.SearchTerms.Any(
s => s.IndexOf(searchFilter, StringComparison.OrdinalIgnoreCase) >= 0))
.SelectMany(t => t.Categories)
.Distinct()
.OrderBy(x => x));
}
else
{
FilteredCategories.AddRange(allCategories);
}
InitializePreviews();
};
InitializePreviews();
}
private void SelectItems(IEnumerable <object> selection)
{
var groups = new SortedDictionary <string, GroupEntry>(StringComparer.Ordinal);
foreach (var obj in selection)
{
var isSettings = obj is Settings;
var bindingAttr = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance;
if (isSettings)
{
bindingAttr |= BindingFlags.Static;
}
var type = Inst.CacheType(obj.GetType());
var properties = type.Properties;
foreach (var property in properties)
{
if (!property.IsPublic)
{
continue;
}
if (property.IsStatic && !isSettings)
{
continue;
}
if (!property.IsStatic && isSettings)
{
continue;
}
var visibleAttr = property.EditorVisible;
if (visibleAttr == null || FilteredCategories.Contains(visibleAttr.Group))
{
continue;
}
if (property.IsDeprecated && !EditorSettings.ShowDeprecated)
{
continue;
}
GroupEntry groupEntry;
var groupNeedsAdded = false;
if (!groups.TryGetValue(visibleAttr.Group, out groupEntry))
{
groupEntry = new GroupEntry();
groupNeedsAdded = true;
}
IEditor editor;
if (!groupEntry.Editors.TryGetValue(property.Name, out editor))
{
editor = GetEditor(obj, property, visibleAttr.Data);
if (editor != null)
{
groupEntry.Editors.Add(property.Name, editor);
editor.PropertiesWidget = this;
}
else
{
Debug.WriteLine($"No editor for type {property.PropertyType.Name}");
}
}
else
{
editor.AddObject(obj, property);
}
if (groupNeedsAdded && editor != null)
{
groups.Add(visibleAttr.Group, groupEntry);
}
}
}
var inspectors = new List <InspectorBase>(12);
foreach (var group in groups)
{
inspectors.Add(new CollapsibleGroupViewModel(group.Key, group.Value.Editors.Values.Cast <InspectorBase>()));
}
Inspectors = inspectors;
NotifyOfPropertyChange(nameof(Inspectors));
NotifyOfPropertyChange(nameof(DisplayName));
}
