538 lines
18 KiB
C#
538 lines
18 KiB
C#
using Dalamud.Game.ClientState.JobGauge.Enums;
|
|
using Dalamud.Game.ClientState.JobGauge.Types;
|
|
using Dalamud.Game.ClientState.Objects.SubKinds;
|
|
using Dalamud.Game.ClientState.Statuses;
|
|
using HSUI.Config;
|
|
using HSUI.Config.Attributes;
|
|
using HSUI.Enums;
|
|
using HSUI.Helpers;
|
|
using HSUI.Interface.Bars;
|
|
using HSUI.Interface.GeneralElements;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Numerics;
|
|
using System.Text.Json.Serialization;
|
|
|
|
namespace HSUI.Interface.Jobs
|
|
{
|
|
public class PictomancerHud : JobHud
|
|
{
|
|
private new PictomancerConfig Config => (PictomancerConfig)_config;
|
|
|
|
private static PluginConfigColor EmptyColor => GlobalColors.Instance.EmptyColor;
|
|
|
|
public PictomancerHud(PictomancerConfig config, string? displayName = null) : base(config, displayName)
|
|
{
|
|
|
|
}
|
|
|
|
protected override (List<Vector2>, List<Vector2>) ChildrenPositionsAndSizes()
|
|
{
|
|
List<Vector2> positions = new List<Vector2>();
|
|
List<Vector2> sizes = new List<Vector2>();
|
|
|
|
if (Config.PaletteBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.PaletteBar.Position);
|
|
sizes.Add(Config.PaletteBar.Size);
|
|
}
|
|
|
|
if (Config.PaintBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.PaintBar.Position);
|
|
sizes.Add(Config.PaintBar.Size);
|
|
}
|
|
|
|
if (Config.CreatureCanvasBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.CreatureCanvasBar.Position);
|
|
sizes.Add(Config.CreatureCanvasBar.Size);
|
|
}
|
|
|
|
if (Config.WeaponCanvasBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.WeaponCanvasBar.Position);
|
|
sizes.Add(Config.WeaponCanvasBar.Size);
|
|
}
|
|
|
|
if (Config.LandscapeCanvasBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.LandscapeCanvasBar.Position);
|
|
sizes.Add(Config.LandscapeCanvasBar.Size);
|
|
}
|
|
|
|
if (Config.HammerTimeBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.HammerTimeBar.Position);
|
|
sizes.Add(Config.HammerTimeBar.Size);
|
|
}
|
|
|
|
if (Config.HyperphantasiaBar.Enabled)
|
|
{
|
|
positions.Add(Config.Position + Config.HyperphantasiaBar.Position);
|
|
sizes.Add(Config.HyperphantasiaBar.Size);
|
|
}
|
|
|
|
return (positions, sizes);
|
|
}
|
|
|
|
public override void DrawJobHud(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
Vector2 pos = origin + Config.Position;
|
|
|
|
if (Config.PaletteBar.Enabled)
|
|
{
|
|
DrawPaletteBar(pos, player);
|
|
}
|
|
|
|
if (Config.PaintBar.Enabled)
|
|
{
|
|
DrawPaintBar(pos, player);
|
|
}
|
|
|
|
if (Config.CreatureCanvasBar.Enabled)
|
|
{
|
|
DrawCreatureCanvasBar(pos, player);
|
|
}
|
|
|
|
if (Config.WeaponCanvasBar.Enabled)
|
|
{
|
|
DrawWeaponCanvasBar(pos, player);
|
|
}
|
|
|
|
if (Config.LandscapeCanvasBar.Enabled)
|
|
{
|
|
DrawLandscapeCanvasBar(pos, player);
|
|
}
|
|
|
|
if (Config.HammerTimeBar.Enabled)
|
|
{
|
|
DrawHammerTimeBar(pos, player);
|
|
}
|
|
|
|
if (Config.HyperphantasiaBar.Enabled)
|
|
{
|
|
DrawHyperphantasiaBar(pos, player);
|
|
}
|
|
}
|
|
|
|
protected unsafe void DrawPaletteBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
PictomancerPaletteBarConfig config = Config.PaletteBar;
|
|
PCTGauge gauge = Plugin.JobGauges.Get<PCTGauge>();
|
|
|
|
if (config.HideWhenInactive && gauge.PalleteGauge == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool isSubstractive = Utils.StatusListForBattleChara(player).FirstOrDefault(o => o.StatusId is 3674) != null;
|
|
|
|
config.Label = config.PaletteLabel;
|
|
config.PaletteLabel.SubtractiveMode = isSubstractive;
|
|
config.Label.SetValue(gauge.PalleteGauge);
|
|
|
|
PluginConfigColor fillColor = isSubstractive ? config.SubtractiveColor : config.FillColor;
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedProgressBars(
|
|
config,
|
|
2,
|
|
gauge.PalleteGauge,
|
|
100,
|
|
0,
|
|
player,
|
|
fillColor: fillColor
|
|
);
|
|
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
|
|
private unsafe void DrawPaintBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
PictomancerPaintBarConfig config = Config.PaintBar;
|
|
PCTGauge gauge = Plugin.JobGauges.Get<PCTGauge>();
|
|
|
|
if (config.HideWhenInactive && gauge.Paint == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool hasBlackPaint = Utils.StatusListForBattleChara(player).FirstOrDefault(o => o.StatusId is 3691) != null;
|
|
Tuple<PluginConfigColor, float, LabelConfig?>[] chunks = new Tuple<PluginConfigColor, float, LabelConfig?>[5];
|
|
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
PluginConfigColor color = PluginConfigColor.Empty;
|
|
if (i < gauge.Paint)
|
|
{
|
|
color = i == gauge.Paint - 1 && hasBlackPaint ? config.BlackPaintColor : config.WhitePaintColor;
|
|
}
|
|
chunks[i] = new(color, 1, null);
|
|
}
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedBars(config, chunks, player);
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
|
|
private unsafe void DrawCreatureCanvasBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
PictomancerCreatureCanvasBarConfig config = Config.CreatureCanvasBar;
|
|
PCTGauge gauge = Plugin.JobGauges.Get<PCTGauge>();
|
|
|
|
if (config.HideWhenInactive && !gauge.CreatureMotifDrawn && gauge.CreatureFlags != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// canvas
|
|
PluginConfigColor? canvasColor = null;
|
|
if (gauge.CanvasFlags.HasFlag(CanvasFlags.Maw))
|
|
{
|
|
canvasColor = config.FangsColor;
|
|
}
|
|
else if (gauge.CanvasFlags.HasFlag(CanvasFlags.Claw))
|
|
{
|
|
canvasColor = config.ClawColor;
|
|
}
|
|
else if (gauge.CanvasFlags.HasFlag(CanvasFlags.Wing))
|
|
{
|
|
canvasColor = config.WingsColor;
|
|
}
|
|
else if(gauge.CanvasFlags.HasFlag(CanvasFlags.Pom))
|
|
{
|
|
canvasColor = config.PomColor;
|
|
}
|
|
Tuple<PluginConfigColor, float, LabelConfig?> canvas = new(
|
|
canvasColor ?? PluginConfigColor.Empty,
|
|
canvasColor != null ? 1 : 0,
|
|
null
|
|
);
|
|
|
|
// part drawing
|
|
PluginConfigColor? drawingColor = null;
|
|
if (gauge.CreatureFlags.HasFlag(CreatureFlags.Claw))
|
|
{
|
|
drawingColor = config.ClawColor;
|
|
}
|
|
else if (config.ShowEmptyPomWings &&
|
|
gauge.CreatureFlags.HasFlag(CreatureFlags.Pom) &&
|
|
gauge.CreatureFlags.HasFlag(CreatureFlags.Wings))
|
|
{
|
|
drawingColor = PluginConfigColor.Empty;
|
|
}
|
|
else if (gauge.CreatureFlags.HasFlag(CreatureFlags.Wings))
|
|
{
|
|
drawingColor = config.WingsColor;
|
|
}
|
|
else if(gauge.CreatureFlags.HasFlag(CreatureFlags.Pom))
|
|
{
|
|
drawingColor = config.PomColor;
|
|
}
|
|
Tuple<PluginConfigColor, float, LabelConfig?> drawing = new(
|
|
drawingColor ?? PluginConfigColor.Empty,
|
|
drawingColor != null ? 1 : 0,
|
|
null
|
|
);
|
|
|
|
// portrait
|
|
PluginConfigColor? portraitColor = null;
|
|
if (gauge.CreatureFlags.HasFlag(CreatureFlags.MooglePortait))
|
|
{
|
|
portraitColor = config.MoogleColor;
|
|
}
|
|
else if (gauge.CreatureFlags.HasFlag(CreatureFlags.MadeenPortrait))
|
|
{
|
|
portraitColor = config.MadeenColor;
|
|
}
|
|
Tuple<PluginConfigColor, float, LabelConfig?> portrait = new(
|
|
portraitColor ?? PluginConfigColor.Empty,
|
|
portraitColor != null ? 1 : 0,
|
|
null
|
|
);
|
|
|
|
var chunks = new List<Tuple<PluginConfigColor, float, LabelConfig?>>();
|
|
chunks.Add(canvas);
|
|
if (!config.DontShowDrawing)
|
|
{
|
|
chunks.Add(drawing);
|
|
}
|
|
chunks.Add(portrait);
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedBars(config, chunks.ToArray(), player);
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
|
|
private unsafe void DrawWeaponCanvasBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
ChunkedBarConfig config = Config.WeaponCanvasBar;
|
|
PCTGauge gauge = Plugin.JobGauges.Get<PCTGauge>();
|
|
|
|
bool active = gauge.CanvasFlags.HasFlag(CanvasFlags.Weapon);
|
|
|
|
if (config.HideWhenInactive && !active)
|
|
{
|
|
return;
|
|
}
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedBars(config, 1, active ? 1 : 0, 1, 0, player);
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
|
|
private unsafe void DrawLandscapeCanvasBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
ChunkedBarConfig config = Config.LandscapeCanvasBar;
|
|
PCTGauge gauge = Plugin.JobGauges.Get<PCTGauge>();
|
|
|
|
bool active = gauge.CanvasFlags.HasFlag(CanvasFlags.Landscape);
|
|
|
|
if (config.HideWhenInactive && !active)
|
|
{
|
|
return;
|
|
}
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedBars(config, 1, active ? 1 : 0, 1, 0, player);
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
|
|
private unsafe void DrawHammerTimeBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
StacksWithDurationBarConfig config = Config.HammerTimeBar;
|
|
IStatus? status = Utils.StatusListForBattleChara(player).FirstOrDefault(o => o.StatusId is 3680);
|
|
int stacks = status?.Param ?? 0;
|
|
float time = Math.Abs(status?.RemainingTime ?? 0f);
|
|
|
|
if (config.HideWhenInactive && stacks == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
config.Label.SetValue(time);
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedProgressBars(config, 3, stacks, 3, 0, player, forceLabelIndex: 1);
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
|
|
private unsafe void DrawHyperphantasiaBar(Vector2 origin, IPlayerCharacter player)
|
|
{
|
|
StacksWithDurationBarConfig config = Config.HyperphantasiaBar;
|
|
IStatus? status = Utils.StatusListForBattleChara(player).FirstOrDefault(o => o.StatusId is 3688);
|
|
int stacks = status?.Param ?? 0;
|
|
float time = Math.Abs(status?.RemainingTime ?? 0f);
|
|
|
|
if (config.HideWhenInactive && stacks == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
config.Label.SetValue(time);
|
|
|
|
BarHud[] bars = BarUtilities.GetChunkedProgressBars(config, 5, stacks, 5, 0, player, forceLabelIndex: 2);
|
|
foreach (BarHud bar in bars)
|
|
{
|
|
AddDrawActions(bar.GetDrawActions(origin, config.StrataLevel));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Section("Job Specific Bars")]
|
|
[SubSection("Caster", 0)]
|
|
[SubSection("Pictomancer", 1)]
|
|
public class PictomancerConfig : JobConfig
|
|
{
|
|
[JsonIgnore] public override uint JobId => JobIDs.PCT;
|
|
|
|
public new static PictomancerConfig DefaultConfig()
|
|
{
|
|
var config = new PictomancerConfig();
|
|
config.PaletteBar.UseChunks = false;
|
|
config.PaletteBar.Label.Enabled = true;
|
|
|
|
return config;
|
|
}
|
|
|
|
[NestedConfig("Palette Bar", 30)]
|
|
public PictomancerPaletteBarConfig PaletteBar = new PictomancerPaletteBarConfig(
|
|
new Vector2(0, -10),
|
|
new Vector2(152, 18),
|
|
PluginConfigColor.FromHex(0xFFC8C89F)
|
|
);
|
|
|
|
[NestedConfig("Paint Bar", 35)]
|
|
public PictomancerPaintBarConfig PaintBar = new PictomancerPaintBarConfig(
|
|
new(0, -26),
|
|
new(254, 10)
|
|
);
|
|
|
|
[NestedConfig("Creature Canvas Bar", 40)]
|
|
public PictomancerCreatureCanvasBarConfig CreatureCanvasBar = new PictomancerCreatureCanvasBarConfig(
|
|
new(0, -38),
|
|
new(254, 10)
|
|
);
|
|
|
|
[NestedConfig("Weapon Canvas Bar", 40)]
|
|
public ChunkedBarConfig WeaponCanvasBar = new ChunkedBarConfig(
|
|
new(-102.5f, -10),
|
|
new(49, 18),
|
|
PluginConfigColor.FromHex(0xFFC5616C)
|
|
);
|
|
|
|
[NestedConfig("Landscape Canvas Bar", 40)]
|
|
public ChunkedBarConfig LandscapeCanvasBar = new ChunkedBarConfig(
|
|
new(102.5f, -10),
|
|
new(49, 18),
|
|
PluginConfigColor.FromHex(0xFF8690E5)
|
|
);
|
|
|
|
[NestedConfig("Hammer Time Bar", 40)]
|
|
public StacksWithDurationBarConfig HammerTimeBar = new StacksWithDurationBarConfig(
|
|
new(0, -50),
|
|
new(254, 10),
|
|
PluginConfigColor.FromHex(0xFFFFFFFF)
|
|
);
|
|
|
|
[NestedConfig("Hyperphantasia Bar", 45)]
|
|
public StacksWithDurationBarConfig HyperphantasiaBar = new StacksWithDurationBarConfig(
|
|
new(0, -50),
|
|
new(254, 10),
|
|
PluginConfigColor.FromHex(0xFFFFFFFF)
|
|
);
|
|
}
|
|
|
|
[DisableParentSettings("Label")]
|
|
[Exportable(false)]
|
|
public class PictomancerPaletteBarConfig : ChunkedProgressBarConfig
|
|
{
|
|
[ColorEdit4("Subtractive Fill Color")]
|
|
[Order(27)]
|
|
public PluginConfigColor SubtractiveColor = PluginConfigColor.FromHex(0xFFAF6BAE);
|
|
|
|
[NestedConfig("Bar Text", 1001, separator = false, spacing = true)]
|
|
public PictomancerPaletteLabelConfig PaletteLabel = new PictomancerPaletteLabelConfig(Vector2.Zero, "", DrawAnchor.Center, DrawAnchor.Center);
|
|
|
|
public PictomancerPaletteBarConfig(Vector2 position, Vector2 size, PluginConfigColor fillColor)
|
|
: base(position, size, fillColor)
|
|
{
|
|
Label = PaletteLabel;
|
|
}
|
|
}
|
|
|
|
[Exportable(false)]
|
|
public class PictomancerPaletteLabelConfig : NumericLabelConfig
|
|
{
|
|
[ColorEdit4("Subtractive Color")]
|
|
[Order(31)]
|
|
public PluginConfigColor SubtractiveColor = new PluginConfigColor(Vector4.UnitW);
|
|
|
|
[ColorEdit4("Subtractive Color ##Outline")]
|
|
[Order(41, collapseWith = nameof(ShowOutline))]
|
|
public PluginConfigColor SubtractiveOutlineColor = new PluginConfigColor(Vector4.One);
|
|
|
|
public PictomancerPaletteLabelConfig(Vector2 position, string text, DrawAnchor frameAnchor, DrawAnchor textAnchor)
|
|
: base(position, text, frameAnchor, textAnchor)
|
|
{
|
|
}
|
|
|
|
[JsonIgnore] public bool SubtractiveMode = false;
|
|
|
|
public override PluginConfigColor GetColor() => SubtractiveMode ? SubtractiveColor : Color;
|
|
|
|
public override PluginConfigColor GetOutlineColor() => SubtractiveMode ? SubtractiveOutlineColor : OutlineColor;
|
|
|
|
public override PictomancerPaletteLabelConfig Clone(int index) =>
|
|
new PictomancerPaletteLabelConfig(Position, _text, FrameAnchor, TextAnchor)
|
|
{
|
|
Color = Color,
|
|
SubtractiveColor = SubtractiveColor,
|
|
OutlineColor = OutlineColor,
|
|
SubtractiveOutlineColor = SubtractiveOutlineColor,
|
|
ShadowConfig = ShadowConfig,
|
|
ShowOutline = ShowOutline,
|
|
FontID = FontID,
|
|
UseJobColor = UseJobColor,
|
|
Enabled = Enabled,
|
|
HideIfZero = HideIfZero,
|
|
ID = ID + "_{index}"
|
|
};
|
|
}
|
|
|
|
[DisableParentSettings("FillColor")]
|
|
[Exportable(false)]
|
|
public class PictomancerPaintBarConfig : ChunkedBarConfig
|
|
{
|
|
[ColorEdit4("White Paint Color")]
|
|
[Order(26)]
|
|
public PluginConfigColor WhitePaintColor = PluginConfigColor.FromHex(0xFF00FFFF);
|
|
|
|
[ColorEdit4("Black Paint Color")]
|
|
[Order(27)]
|
|
public PluginConfigColor BlackPaintColor = PluginConfigColor.FromHex(0xFFDB57DB);
|
|
|
|
public PictomancerPaintBarConfig(Vector2 position, Vector2 size)
|
|
: base(position, size, PluginConfigColor.Empty)
|
|
{
|
|
}
|
|
}
|
|
|
|
[DisableParentSettings("FillColor")]
|
|
[Exportable(false)]
|
|
public class PictomancerCreatureCanvasBarConfig : ChunkedBarConfig
|
|
{
|
|
[ColorEdit4("Pom Color")]
|
|
[Order(17)]
|
|
public PluginConfigColor PomColor = PluginConfigColor.FromHex(0xFFE69378);
|
|
|
|
[ColorEdit4("Wings Color")]
|
|
[Order(18)]
|
|
public PluginConfigColor WingsColor = PluginConfigColor.FromHex(0xFFD38BE4);
|
|
|
|
[ColorEdit4("Claw Color")]
|
|
[Order(19)]
|
|
public PluginConfigColor ClawColor = PluginConfigColor.FromHex(0xFFA16854);
|
|
|
|
[ColorEdit4("Fangs Color")]
|
|
[Order(20)]
|
|
public PluginConfigColor FangsColor = PluginConfigColor.FromHex(0xFF80BFBD);
|
|
|
|
[ColorEdit4("Moogle Color")]
|
|
[Order(21)]
|
|
public PluginConfigColor MoogleColor = PluginConfigColor.FromHex(0xFFA745C7);
|
|
|
|
[ColorEdit4("Madeen Color")]
|
|
[Order(22)]
|
|
public PluginConfigColor MadeenColor = PluginConfigColor.FromHex(0xFF93Cf7D);
|
|
|
|
[Checkbox("Don't Show Drawing", spacing = true, help = "When enabled, this hides the middle chunk that shows which creature parts were already drawn.")]
|
|
[Order(50)]
|
|
public bool DontShowDrawing = false;
|
|
|
|
[Checkbox("Show Empty Drawing for Pom + Wings")]
|
|
[Order(51)]
|
|
public bool ShowEmptyPomWings = false;
|
|
|
|
|
|
public PictomancerCreatureCanvasBarConfig(Vector2 position, Vector2 size)
|
|
: base(position, size, PluginConfigColor.Empty)
|
|
{
|
|
}
|
|
}
|
|
}
|