280 lines
8.4 KiB
C#
280 lines
8.4 KiB
C#
#region Copyright & License Information
|
|
/*
|
|
* Copyright (c) The OpenRA Developers and Contributors
|
|
* This file is part of OpenRA, which is free software. It is made
|
|
* available to you under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation, either version 3 of
|
|
* the License, or (at your option) any later version. For more
|
|
* information, see COPYING.
|
|
*/
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using OpenRA.Graphics;
|
|
using OpenRA.Mods.Common.Traits;
|
|
using OpenRA.Mods.Common.Traits.Render;
|
|
using OpenRA.Primitives;
|
|
using OpenRA.Widgets;
|
|
|
|
namespace OpenRA.Mods.Common.Widgets
|
|
{
|
|
public class ObserverProductionIconsWidget : Widget
|
|
{
|
|
public readonly string TooltipTemplate = "PRODUCTION_TOOLTIP";
|
|
public readonly string TooltipContainer;
|
|
public Func<Player> GetPlayer;
|
|
readonly World world;
|
|
readonly WorldRenderer worldRenderer;
|
|
|
|
public int IconWidth = 32;
|
|
public int IconHeight = 24;
|
|
public int IconSpacing = 1;
|
|
|
|
public string ClockAnimation = "clock";
|
|
public string ClockSequence = "idle";
|
|
public string ClockPalette = "chrome";
|
|
|
|
public ProductionIcon TooltipIcon { get; private set; }
|
|
public Func<ProductionIcon> GetTooltipIcon;
|
|
|
|
readonly Dictionary<ProductionQueue, Animation> clocks;
|
|
readonly Lazy<TooltipContainerWidget> tooltipContainer;
|
|
readonly List<ProductionIcon> productionIcons = new();
|
|
readonly List<Rectangle> productionIconsBounds = new();
|
|
|
|
readonly float2 iconSize;
|
|
int lastIconIdx;
|
|
public int MinWidth = 240;
|
|
int currentTooltipToken;
|
|
|
|
[ObjectCreator.UseCtor]
|
|
public ObserverProductionIconsWidget(World world, WorldRenderer worldRenderer)
|
|
{
|
|
this.world = world;
|
|
this.worldRenderer = worldRenderer;
|
|
clocks = new Dictionary<ProductionQueue, Animation>();
|
|
GetTooltipIcon = () => TooltipIcon;
|
|
tooltipContainer = Exts.Lazy(() =>
|
|
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
|
|
iconSize = new float2(IconWidth, IconHeight);
|
|
}
|
|
|
|
protected ObserverProductionIconsWidget(ObserverProductionIconsWidget other)
|
|
: base(other)
|
|
{
|
|
GetPlayer = other.GetPlayer;
|
|
world = other.world;
|
|
worldRenderer = other.worldRenderer;
|
|
clocks = other.clocks;
|
|
|
|
IconWidth = other.IconWidth;
|
|
IconHeight = other.IconHeight;
|
|
IconSpacing = other.IconSpacing;
|
|
iconSize = new float2(IconWidth, IconHeight);
|
|
|
|
ClockAnimation = other.ClockAnimation;
|
|
ClockSequence = other.ClockSequence;
|
|
ClockPalette = other.ClockPalette;
|
|
|
|
TooltipIcon = other.TooltipIcon;
|
|
GetTooltipIcon = () => TooltipIcon;
|
|
|
|
MinWidth = other.MinWidth;
|
|
|
|
TooltipTemplate = other.TooltipTemplate;
|
|
TooltipContainer = other.TooltipContainer;
|
|
|
|
tooltipContainer = Exts.Lazy(() =>
|
|
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
|
|
}
|
|
|
|
public override void Draw()
|
|
{
|
|
productionIcons.Clear();
|
|
productionIconsBounds.Clear();
|
|
|
|
var player = GetPlayer();
|
|
if (player == null)
|
|
return;
|
|
|
|
var queues = world.ActorsWithTrait<ProductionQueue>()
|
|
.Where(a => a.Actor.Owner == player)
|
|
.Select(a => a.Trait)
|
|
.ToList();
|
|
|
|
foreach (var queue in queues)
|
|
if (!clocks.ContainsKey(queue))
|
|
clocks.Add(queue, new Animation(world, ClockAnimation));
|
|
|
|
var currentItemsByItem = queues
|
|
.Select(q => q.CurrentItem())
|
|
.Where(pi => pi != null)
|
|
.GroupBy(pr => pr.Item)
|
|
.OrderBy(g => g.First().Queue.Info.DisplayOrder)
|
|
.ThenBy(g => g.First().BuildPaletteOrder)
|
|
.ToList();
|
|
|
|
Game.Renderer.EnableAntialiasingFilter();
|
|
|
|
var queueCol = 0;
|
|
foreach (var currentItems in currentItemsByItem)
|
|
{
|
|
var queued = currentItems
|
|
.OrderBy(pi => pi.Done ? 0 : (pi.Paused ? 2 : 1))
|
|
.ThenBy(q => q.RemainingTimeActual)
|
|
.ToList();
|
|
|
|
var current = queued[0];
|
|
var queue = current.Queue;
|
|
|
|
var faction = queue.Actor.Owner.Faction.InternalName;
|
|
var actor = queue.AllItems().FirstOrDefault(a => a.Name == current.Item);
|
|
if (actor == null)
|
|
continue;
|
|
|
|
var rsi = actor.TraitInfo<RenderSpritesInfo>();
|
|
var icon = new Animation(world, rsi.GetImage(actor, faction));
|
|
var bi = actor.TraitInfo<BuildableInfo>();
|
|
|
|
icon.Play(bi.Icon);
|
|
var topLeftOffset = new float2(queueCol * (IconWidth + IconSpacing), 0);
|
|
|
|
var iconTopLeft = RenderOrigin + topLeftOffset;
|
|
var centerPosition = iconTopLeft + 0.5f * iconSize;
|
|
|
|
var palette = bi.IconPaletteIsPlayerPalette ? bi.IconPalette + player.InternalName : bi.IconPalette;
|
|
WidgetUtils.DrawSpriteCentered(icon.Image, worldRenderer.Palette(palette), centerPosition, 0.5f);
|
|
|
|
var rect = new Rectangle((int)iconTopLeft.X, (int)iconTopLeft.Y, (int)iconSize.X, (int)iconSize.Y);
|
|
productionIcons.Add(new ProductionIcon
|
|
{
|
|
Actor = actor,
|
|
Pos = new float2(rect.Location),
|
|
Queued = queued,
|
|
ProductionQueue = current.Queue
|
|
});
|
|
|
|
productionIconsBounds.Add(rect);
|
|
|
|
var pios = queue.Actor.Owner.PlayerActor.TraitsImplementing<IProductionIconOverlay>();
|
|
|
|
foreach (var pio in pios.Where(p => p.IsOverlayActive(actor)))
|
|
WidgetUtils.DrawSpriteCentered(pio.Sprite, worldRenderer.Palette(pio.Palette),
|
|
centerPosition + pio.Offset(iconSize), 0.5f);
|
|
|
|
var clock = clocks[queue];
|
|
clock.PlayFetchIndex(ClockSequence, () => current.TotalTime == 0 ? 0 :
|
|
(current.TotalTime - current.RemainingTime) * (clock.CurrentSequence.Length - 1) / current.TotalTime);
|
|
|
|
clock.Tick();
|
|
WidgetUtils.DrawSpriteCentered(clock.Image, worldRenderer.Palette(ClockPalette), centerPosition, 0.5f);
|
|
|
|
queueCol++;
|
|
}
|
|
|
|
var newWidth = Math.Max(queueCol * (IconWidth + IconSpacing), MinWidth);
|
|
|
|
if (newWidth != Bounds.Width)
|
|
{
|
|
var wasInBounds = EventBounds.Contains(Viewport.LastMousePos);
|
|
Bounds.Width = newWidth;
|
|
var isInBounds = EventBounds.Contains(Viewport.LastMousePos);
|
|
|
|
// HACK: Ui.MouseOverWidget is normally only updated when the mouse moves
|
|
// Call ResetTooltips to force a fake mouse movement so the checks in Tick will work properly
|
|
if (wasInBounds != isInBounds)
|
|
Game.RunAfterTick(Ui.ResetTooltips);
|
|
}
|
|
|
|
Game.Renderer.DisableAntialiasingFilter();
|
|
|
|
var tiny = Game.Renderer.Fonts["Tiny"];
|
|
var bold = Game.Renderer.Fonts["Small"];
|
|
foreach (var icon in productionIcons)
|
|
{
|
|
var current = icon.Queued[0];
|
|
var text = GetOverlayForItem(current, world.Timestep);
|
|
tiny.DrawTextWithContrast(text,
|
|
icon.Pos + new float2(16, 12) - new float2(tiny.Measure(text).X / 2, 0),
|
|
Color.White, Color.Black, 1);
|
|
|
|
if (icon.Queued.Count > 1)
|
|
{
|
|
text = icon.Queued.Count.ToString(NumberFormatInfo.CurrentInfo);
|
|
bold.DrawTextWithContrast(text, icon.Pos + new float2(16, 0) - new float2(bold.Measure(text).X / 2, 0),
|
|
Color.White, Color.Black, 1);
|
|
}
|
|
}
|
|
|
|
var parentWidth = Bounds.X + Bounds.Width;
|
|
Parent.Bounds.Width = parentWidth;
|
|
|
|
var gradient = Parent.Get<GradientColorBlockWidget>("PLAYER_GRADIENT");
|
|
|
|
var offset = gradient.Bounds.X - Bounds.X;
|
|
var gradientWidth = Math.Max(MinWidth - offset, currentItemsByItem.Count * (IconWidth + IconSpacing));
|
|
|
|
gradient.Bounds.Width = gradientWidth;
|
|
var widestChildWidth = Parent.Parent.Children.Max(x => x.Bounds.Width);
|
|
|
|
Parent.Parent.Bounds.Width = Math.Max(25 + widestChildWidth, Bounds.Left + MinWidth);
|
|
}
|
|
|
|
static string GetOverlayForItem(ProductionItem item, int timestep)
|
|
{
|
|
if (item.Paused)
|
|
return "ON HOLD";
|
|
|
|
if (item.Done)
|
|
return "READY";
|
|
|
|
return WidgetUtils.FormatTime(item.Queue.RemainingTimeActual(item), timestep);
|
|
}
|
|
|
|
public override Widget Clone()
|
|
{
|
|
return new ObserverProductionIconsWidget(this);
|
|
}
|
|
|
|
public override void Tick()
|
|
{
|
|
if (TooltipContainer == null)
|
|
return;
|
|
|
|
if (Ui.MouseOverWidget != this)
|
|
{
|
|
if (TooltipIcon != null)
|
|
{
|
|
tooltipContainer.Value.RemoveTooltip(currentTooltipToken);
|
|
lastIconIdx = 0;
|
|
TooltipIcon = null;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (TooltipIcon != null &&
|
|
productionIconsBounds.Count > lastIconIdx &&
|
|
productionIcons[lastIconIdx].Actor == TooltipIcon.Actor &&
|
|
productionIconsBounds[lastIconIdx].Contains(Viewport.LastMousePos))
|
|
return;
|
|
|
|
for (var i = 0; i < productionIconsBounds.Count; i++)
|
|
{
|
|
if (!productionIconsBounds[i].Contains(Viewport.LastMousePos))
|
|
continue;
|
|
|
|
lastIconIdx = i;
|
|
TooltipIcon = productionIcons[i];
|
|
currentTooltipToken = tooltipContainer.Value.SetTooltip(TooltipTemplate, new WidgetArgs { { "player", GetPlayer() }, { "getTooltipIcon", GetTooltipIcon } });
|
|
return;
|
|
}
|
|
|
|
TooltipIcon = null;
|
|
}
|
|
}
|
|
}
|