using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using ReLogic.Content;
using System;
using System.Collections.Generic;
using Terraria;
using Terraria.GameContent;
using Terraria.ModLoader;
using Terraria.UI;
namespace SoulHarvest.Common;
/// <summary>
/// Client-only presentation for Reaper ultimates. Combat code reports the authoritative
/// visual clock each tick; this system owns only short-lived draw state and asks the
/// shared VFX director for capped camera/flash punctuation. It never creates attacks.
/// </summary>
[Autoload(Side = ModSide.Client)]
public sealed class ReaperUltimateVisualSystem : ModSystem
{
private const int TailFrames = 18;
private const int CrescentMaskSize = 512;
private const float CrescentReferenceRadius = 180f;
private static UltimateVisualState[] states = [];
private static Asset<Texture2D>? soulTexture;
private static ReaperUltimateCrescentMaskSet[] crescentMasks = [];
private static readonly float[] deathMirrorAngles =
new float[ReaperDeathUltimateGeometry.CutCount * 2];
private static readonly VertexPositionColorTexture[] deathMirrorVertices =
new VertexPositionColorTexture[ReaperDeathUltimateGeometry.CutCount * 6];
private static BasicEffect? deathMirrorEffect;
/// <summary>
/// Reports one frame of an active ultimate. This method is safe to call from
/// projectile AI on every net mode: dedicated servers immediately return.
/// </summary>
public static void ReportUltimate(Player owner, ReaperFormId form, Vector2 aim,
Vector2 focusWorld, int actionId, int timer, int duration)
{
if (Main.dedServ
|| Main.gameMenu
|| owner is null
|| !owner.active
|| owner.dead
|| owner.whoAmI < 0
|| owner.whoAmI >= Main.maxPlayers
|| form == ReaperFormId.Base
|| (byte)form > (byte)ReaperFormId.Death)
{
return;
}
EnsureStateStorage();
Vector2 fallback = Vector2.UnitX * (owner.direction == 0 ? 1 : owner.direction);
if (!float.IsFinite(aim.X) || !float.IsFinite(aim.Y) || aim.LengthSquared() < 0.0001f)
aim = fallback;
else
aim.Normalize();
if (!float.IsFinite(focusWorld.X) || !float.IsFinite(focusWorld.Y))
focusWorld = owner.MountedCenter + aim * 180f;
duration = Math.Clamp(duration, 1, 3600);
timer = Math.Clamp(timer, 0, duration);
ref UltimateVisualState state = ref states[owner.whoAmI];
bool restarted = !state.Active || state.Form != form || state.ActionId != actionId;
// A remote controller can first replicate halfway through its action.
// Floor a newly observed storyboard at that authoritative frame so all
// earlier impacts are not replayed at once. Tick-one openings still cross
// normally for actions observed from their actual start.
int previousTimer = restarted
? (timer <= 1 ? timer - 1 : timer)
: state.Timer;
if (!restarted)
{
// Extra-AI packets can arrive after the local controller has already
// advanced. Never rewind a storyboard for the same authoritative
// action, otherwise old packets replay white flashes, sounds and shake.
int monotonicFloor = state.LastReportTick < Main.GameUpdateCount
? Math.Min(duration, state.Timer + 1)
: state.Timer;
timer = Math.Max(timer, monotonicFloor);
}
state.Active = true;
state.Form = form;
state.ActionId = actionId;
state.OriginWorld = owner.MountedCenter;
state.FocusWorld = focusWorld;
state.Aim = aim;
state.Timer = timer;
state.Duration = duration;
state.FramesSinceReport = 0;
state.LastReportTick = Main.GameUpdateCount;
float normalizedTime = state.Timer / (float)Math.Max(1, state.Duration);
ReaperVfxDirector.ReportCinematicCamera(owner.whoAmI, state.ActionId,
normalizedTime, aim, form == ReaperFormId.Death ? 1f : 0.84f);
TriggerTimelineImpacts(form, aim, previousTimer, state.Timer);
}
public override void Load()
{
EnsureStateStorage();
soulTexture = ModContent.Request<Texture2D>("SoulHarvest/Items/Soul", AssetRequestMode.ImmediateLoad);
}
public override void Unload()
{
states = [];
soulTexture = null;
// Content hooks may run on a loader worker. Detach immediately so no
// future draw can observe these resources, then dispose them on FNA's
// graphics thread just like the other procedural texture systems.
ReaperUltimateCrescentMaskSet[] oldMasks = crescentMasks;
crescentMasks = [];
BasicEffect? oldMirrorEffect = deathMirrorEffect;
deathMirrorEffect = null;
if (!Main.dedServ && oldMasks.Length > 0)
Main.QueueMainThreadAction(() => DisposeCrescentMasks(oldMasks));
if (!Main.dedServ && oldMirrorEffect is not null)
Main.QueueMainThreadAction(oldMirrorEffect.Dispose);
}
public override void OnWorldUnload()
{
ClearStates();
}
public override void PostUpdateEverything()
{
if (Main.gameMenu)
{
ClearStates();
return;
}
EnsureStateStorage();
for (int index = 0; index < states.Length; index++)
{
ref UltimateVisualState state = ref states[index];
if (!state.Active)
continue;
Player owner = Main.player[index];
if (!owner.active || owner.dead || state.LastReportTick > Main.GameUpdateCount)
{
state = default;
continue;
}
if (state.LastReportTick == Main.GameUpdateCount)
{
state.FramesSinceReport = 0;
continue;
}
state.FramesSinceReport++;
if (state.FramesSinceReport > TailFrames)
state = default;
}
}
public override void ModifyInterfaceLayers(List<GameInterfaceLayer> layers)
{
int index = layers.FindIndex(layer => layer.Name == "Vanilla: Resource Bars");
if (index < 0)
index = layers.FindIndex(layer => layer.Name == "Vanilla: Mouse Text");
if (index < 0)
index = layers.Count;
layers.Insert(index, new LegacyGameInterfaceLayer(
"SoulHarvest: Reaper Ultimate Spectacle",
DrawUltimateLayer,
InterfaceScaleType.None));
}
private static bool DrawUltimateLayer()
{
if (Main.gameMenu || states.Length == 0)
return true;
Player localPlayer = Main.LocalPlayer;
if (!localPlayer.active)
return true;
// This layer renders in physical screen space. Applying UI scale here
// confined the composition to the upper-left on high-DPI displays.
const float uiScale = 1f;
Vector2 viewport = new(Main.screenWidth, Main.screenHeight);
Rectangle viewportBounds = new(0, 0,
Math.Max(1, (int)Math.Ceiling(viewport.X)),
Math.Max(1, (int)Math.Ceiling(viewport.Y)));
Texture2D pixel = TextureAssets.MagicPixel.Value;
SpriteBatch batch = Main.spriteBatch;
float strongestDarkness = 0f;
for (int index = 0; index < states.Length; index++)
{
ref UltimateVisualState state = ref states[index];
if (!IsVisible(index, in state, viewport, uiScale))
continue;
strongestDarkness = Math.Max(strongestDarkness,
GetBackdropDarkness(in state) * GetStateOpacity(in state));
}
if (strongestDarkness <= 0.001f)
return true;
// Interface drawing always runs on the graphics thread. Creating the
// procedural masks lazily here avoids allocating Texture2D instances
// from a content-loader worker and keeps dedicated servers texture-free.
EnsureCrescentMasks();
batch.Draw(pixel, viewportBounds, Color.Black * strongestDarkness);
for (int index = 0; index < states.Length; index++)
{
ref UltimateVisualState state = ref states[index];
if (!IsVisible(index, in state, viewport, uiScale))
continue;
DrawState(batch, pixel, index, in state, viewport, viewportBounds, uiScale);
}
return true;
}
private static bool IsVisible(int playerIndex, in UltimateVisualState state, Vector2 viewport, float uiScale)
{
if (!state.Active || playerIndex < 0 || playerIndex >= Main.maxPlayers)
return false;
Player owner = Main.player[playerIndex];
if (!owner.active || owner.dead)
return false;
// Every client which has the authoritative action projectile renders the full
// storyboard. Off-screen owners are re-framed in DrawState instead of receiving
// the old reduced/culled presentation.
return true;
}
private static void DrawState(
SpriteBatch batch,
Texture2D pixel,
int ownerIndex,
in UltimateVisualState state,
Vector2 viewport,
Rectangle viewportBounds,
float uiScale)
{
float progress = MathHelper.Clamp(state.Timer / (float)Math.Max(1, state.Duration), 0f, 1f);
float opacity = GetStateOpacity(in state);
if (opacity <= 0.001f)
return;
Vector2 origin = state.OriginWorld - Main.screenPosition;
const float presentationMargin = 120f;
if (origin.X < -presentationMargin || origin.X > viewport.X + presentationMargin
|| origin.Y < -presentationMargin || origin.Y > viewport.Y + presentationMargin)
{
origin = viewport * 0.5f - state.Aim * 180f;
}
Vector2 focus = state.FocusWorld - Main.screenPosition;
if (state.Form != ReaperFormId.Death
&& (focus.X < -presentationMargin
|| focus.X > viewport.X + presentationMargin
|| focus.Y < -presentationMargin
|| focus.Y > viewport.Y + presentationMargin))
{
focus = viewport * 0.5f;
}
Color primary = ReaperCombatRegistry.GetPrimaryColor(state.Form);
Color secondary = ReaperCombatRegistry.GetSecondaryColor(state.Form);
float time = Main.GlobalTimeWrappedHourly;
batch.Draw(pixel, viewportBounds, primary * (0.028f * opacity));
DrawGlow(batch, focus, Math.Min(viewport.X, viewport.Y) * 0.33f,
primary * (0.105f * opacity));
DrawCinematicFrame(batch, pixel, viewport, progress, opacity, primary, secondary);
switch (state.Form)
{
case ReaperFormId.Bone:
DrawBone(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Blood:
DrawBlood(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Infernal:
DrawInfernal(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Frost:
DrawFrost(batch, pixel, focus, viewport, viewportBounds, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Soul:
DrawSoul(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Void:
DrawVoid(batch, pixel, focus, viewport, viewportBounds, progress, opacity,
time, primary, secondary, state.Aim, state.ActionId);
break;
case ReaperFormId.Death:
DrawDeath(batch, pixel, ownerIndex, in state, focus, viewport,
viewportBounds, progress, opacity, time);
break;
}
}
private static void TriggerTimelineImpacts(
ReaperFormId form,
Vector2 direction,
int previousTimer,
int currentTimer)
{
if (currentTimer <= previousTimer)
return;
Color primary = ReaperCombatRegistry.GetPrimaryColor(form);
Color secondary = ReaperCombatRegistry.GetSecondaryColor(form);
switch (form)
{
case ReaperFormId.Bone:
TriggerImpactAt(30, previousTimer, currentTimer, direction, 3.4f, primary, 0.10f);
TriggerImpactAt(66, previousTimer, currentTimer, -direction, 4.0f, primary, 0.12f);
TriggerImpactAt(102, previousTimer, currentTimer, direction.RotatedBy(0.8f), 4.8f, secondary, 0.15f);
TriggerImpactAt(138, previousTimer, currentTimer, direction.RotatedBy(-0.8f), 5.6f, secondary, 0.18f);
TriggerImpactAt(168, previousTimer, currentTimer, Vector2.UnitY, 7.8f, secondary, 0.34f);
TriggerImpactAt(207, previousTimer, currentTimer, direction, 11.5f, Color.White, 0.68f);
break;
case ReaperFormId.Blood:
TriggerImpactAt(18, previousTimer, currentTimer, Vector2.UnitY,
4.2f, new Color(170, 0, 34), 0.16f);
foreach (int tick in new[] { 48, 78, 108, 138 })
TriggerImpactAt(tick, previousTimer, currentTimer,
direction.RotatedBy(tick * 0.017f), 4.5f,
tick % 2 == 0 ? primary : secondary, 0.13f);
TriggerImpactAt(166, previousTimer, currentTimer, direction,
12f, new Color(255, 238, 228), 0.75f);
break;
case ReaperFormId.Infernal:
for (int index = 0; index < 5; index++)
TriggerImpactAt(20 + index * 20, previousTimer, currentTimer,
direction.RotatedBy(index * MathHelper.TwoPi / 5f), 4.8f + index * 0.3f,
index % 2 == 0 ? primary : secondary, 0.16f);
TriggerImpactAt(130, previousTimer, currentTimer, direction, 8f, secondary, 0.36f);
TriggerImpactAt(190, previousTimer, currentTimer, Vector2.UnitY, 12f, Color.White, 0.72f);
break;
case ReaperFormId.Frost:
TriggerImpactAt(1, previousTimer, currentTimer, Vector2.UnitY, 2.6f, new Color(180, 230, 255), 0.12f);
for (int index = 0; index < 4; index++)
TriggerImpactAt(30 + index * 18, previousTimer, currentTimer,
direction.RotatedBy(index * MathHelper.PiOver2), 4.2f + index * 0.35f,
index % 2 == 0 ? primary : secondary, 0.17f);
TriggerImpactAt(100, previousTimer, currentTimer, direction.RotatedBy(-0.5f), 8.4f, secondary, 0.43f);
TriggerImpactAt(110, previousTimer, currentTimer, direction.RotatedBy(0.5f), 11.2f, Color.White, 0.76f);
break;
case ReaperFormId.Soul:
TriggerImpactAt(20, previousTimer, currentTimer, Vector2.UnitY, 3.3f, primary, 0.13f);
for (int index = 0; index < 8; index++)
TriggerImpactAt(32 + index * 8, previousTimer, currentTimer,
direction.RotatedBy(index * MathHelper.PiOver4), 3.4f + index * 0.22f,
index % 2 == 0 ? primary : secondary, 0.11f);
TriggerImpactAt(104, previousTimer, currentTimer, direction, 11f, Color.White, 0.66f);
break;
case ReaperFormId.Void:
TriggerImpactAt(32, previousTimer, currentTimer, direction, 11f, Color.White, 0.66f);
break;
case ReaperFormId.Death:
for (int index = 0; index < ReaperDeathUltimateGeometry.CutCount; index++)
TriggerImpactAt(ReaperDeathUltimateGeometry.GetCutTick(index),
previousTimer, currentTimer,
direction.RotatedBy(index * 2.39996f), 4.6f + index * 0.08f,
new Color(225, 25, 66), 0.14f);
TriggerImpactAt(ReaperDeathUltimateGeometry.ShatterTick,
previousTimer, currentTimer, direction,
12f, new Color(190, 14, 48), 0.14f);
break;
}
}
private static void TriggerImpactAt(
int eventTick,
int previousTimer,
int currentTimer,
Vector2 direction,
float strength,
Color color,
float opacity)
{
if (previousTimer >= eventTick || currentTimer < eventTick)
return;
int frames = strength >= 10f ? 14 : strength >= 7f ? 10 : 7;
ReaperVfxDirector.TriggerGlobalImpact(direction, strength, frames, color, opacity,
strength >= 10f ? 7 : 4, strength >= 10f ? 0.50f : 0.24f);
}
private static void DrawCinematicFrame(
SpriteBatch batch,
Texture2D pixel,
Vector2 viewport,
float progress,
float opacity,
Color primary,
Color secondary)
{
float ritual = Envelope(progress, 0f, 0.07f, 0.94f, 1f) * opacity;
int barHeight = Math.Max(8, (int)Math.Round(viewport.Y * 0.035f));
batch.Draw(pixel, new Rectangle(0, 0, (int)Math.Ceiling(viewport.X), barHeight),
Color.Black * (ritual * 0.76f));
batch.Draw(pixel, new Rectangle(0, Math.Max(0, (int)Math.Floor(viewport.Y) - barHeight),
(int)Math.Ceiling(viewport.X), barHeight), Color.Black * (ritual * 0.76f));
// Deliberately omit ornamental corner brackets. The restrained full-width
// letterbox reads as one cinematic composition and cannot resemble a
// misplaced child viewport.
// Final impacts are expressed by world geometry, sound and camera
// response. A full-viewport white heartbeat obscured those details and
// became a one-frame white screen when several attacks overlapped.
}
private static void DrawBone(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float graveWidth = MathHelper.Clamp(viewport.X / 11f, 48f, 76f);
for (int index = 0; index < 8; index++)
{
float reveal = Reveal(progress, 0.05f + index * 0.052f, 0.18f + index * 0.052f) * opacity;
if (reveal <= 0.001f)
continue;
float horizontal = (index - 3.5f) * graveWidth;
float restingY = focus.Y + 112f + Math.Abs(index - 3.5f) * 8f;
Vector2 position = new(focus.X + horizontal, restingY + (1f - Ease(reveal / Math.Max(opacity, 0.001f))) * 54f);
float pulse = 0.82f + (float)Math.Sin(time * 2.7f + index * 1.3f) * 0.12f;
DrawTombstone(batch, pixel, position, 36f, 56f,
new Color(7, 20, 27) * (0.90f * reveal),
Color.Lerp(primary, secondary, 0.38f) * (pulse * reveal));
}
float frameReveal = Reveal(progress, 0.58f, 0.78f) * opacity;
if (frameReveal > 0.001f)
{
float halfWidth = MathHelper.Clamp(viewport.X * 0.16f, 150f, 260f);
float height = MathHelper.Clamp(viewport.Y * 0.46f, 260f, 430f);
Vector2 topLeft = focus + new Vector2(-halfWidth, -height * 0.63f);
Vector2 topRight = focus + new Vector2(halfWidth, -height * 0.63f);
Vector2 bottomLeft = topLeft + Vector2.UnitY * height;
Vector2 bottomRight = topRight + Vector2.UnitY * height;
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, primary, secondary, 10f, 2.4f, frameReveal * 0.62f);
DrawLayeredLine(batch, pixel, topRight, bottomRight, primary, secondary, 10f, 2.4f, frameReveal * 0.62f);
DrawLayeredLine(batch, pixel, topLeft, topRight, primary, secondary, 12f, 2.8f, frameReveal * 0.78f);
float bladeReveal = Reveal(progress, 0.75f, 0.94f);
Vector2 bladeStart = topRight + new Vector2(-20f, 30f);
Vector2 bladeEnd = bottomLeft + new Vector2(38f, -24f);
DrawJaggedLine(batch, pixel, bladeStart, bladeEnd, bladeReveal,
primary, Color.White, 22f, 5.2f, 3.5f, 7.8f, opacity);
Vector2 parallel = (bladeEnd - bladeStart).SafeNormalize(Vector2.UnitY).RotatedBy(MathHelper.PiOver2) * 22f;
DrawJaggedLine(batch, pixel, bladeStart + parallel, bladeEnd + parallel, bladeReveal,
new Color(25, 100, 120), secondary, 12f, 2.5f, 2.4f, 11.2f, opacity * 0.78f);
float impact = Pulse(progress, 0.965f, 0.07f) * opacity;
DrawGlow(batch, bladeEnd, 125f, secondary * (0.30f * impact));
DrawRing(batch, pixel, bladeEnd, MathHelper.Lerp(18f, 128f, Ease(impact)), 36,
secondary * (impact * 0.9f), 3f, 0f, 1f);
}
float burial = Envelope(progress, 0.18f, 0.30f, 0.72f, 0.88f) * opacity;
if (burial > 0.001f)
{
float cageRadius = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.21f, 130f, 235f);
for (int side = -1; side <= 1; side += 2)
{
for (int rib = 0; rib < 6; rib++)
{
float y = MathHelper.Lerp(-cageRadius * 0.68f, cageRadius * 0.65f, rib / 5f);
float width = cageRadius * (0.92f - Math.Abs(rib - 2.5f) * 0.09f);
Vector2 spine = focus + new Vector2(side * cageRadius * 0.88f, y);
Vector2 sternum = focus + new Vector2(side * width * 0.12f, y + 13f);
Vector2 elbow = Vector2.Lerp(spine, sternum, 0.52f) + new Vector2(side * 24f, -20f);
DrawLayeredLine(batch, pixel, spine, elbow, new Color(20, 95, 112), secondary,
9f, 2.3f, burial * 0.48f);
DrawLayeredLine(batch, pixel, elbow, sternum, primary, Color.White,
7f, 1.8f, burial * 0.58f);
}
}
}
float judge = Envelope(progress, 0.70f, 0.80f, 0.975f, 1f) * opacity;
if (judge > 0.001f)
{
Vector2 judgeCenter = focus - Vector2.UnitY * MathHelper.Clamp(viewport.Y * 0.21f, 120f, 210f);
float skullRadius = MathHelper.Clamp(viewport.Y * 0.095f, 52f, 94f);
DrawGlow(batch, judgeCenter, skullRadius * 2.4f, primary * (judge * 0.16f));
DrawPolygon(batch, pixel, judgeCenter, skullRadius, 8, new Color(8, 25, 30) * (judge * 0.94f),
skullRadius * 0.75f, -MathHelper.PiOver2, 1f);
DrawRing(batch, pixel, judgeCenter, skullRadius, 30, secondary * (judge * 0.84f), 4f, 0f, 1f);
Vector2 eyeOffset = new(skullRadius * 0.33f, -skullRadius * 0.08f);
DrawGlow(batch, judgeCenter - eyeOffset, skullRadius * 0.34f, primary * (judge * 0.72f));
DrawGlow(batch, judgeCenter + new Vector2(eyeOffset.X, eyeOffset.Y), skullRadius * 0.34f,
primary * (judge * 0.72f));
for (int tooth = -3; tooth <= 3; tooth++)
{
Vector2 root = judgeCenter + new Vector2(tooth * skullRadius * 0.16f, skullRadius * 0.62f);
DrawLayeredLine(batch, pixel, root, root + Vector2.UnitY * skullRadius * 0.34f,
primary, Color.White, 5f, 1.3f, judge * 0.72f);
}
}
}
private static void DrawBlood(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
// The shared Blood blade projectiles draw their own exact flight paths and
// persistent wounds. This layer supplies only restrained atmosphere so it
// cannot invent a second set of fake, screen-space projectiles or scars.
float opening = Reveal(progress, 0.01f, 0.10f) * opacity;
float pulse = 0.82f + (float)Math.Sin(time * 3.4f) * 0.10f;
DrawGlow(batch, focus, MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.31f,
170f, 340f), new Color(122, 0, 24) * (opening * pulse * 0.28f));
float closing = Envelope(progress, 0.76f, 0.84f, 0.97f, 1f) * opacity;
DrawGlow(batch, focus, 240f,
new Color(238, 22, 52) * (closing * 0.24f));
}
private static void DrawBloodLegacy(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float opening = Reveal(progress, 0.01f, 0.10f) * opacity;
DrawGlow(batch, focus, MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.28f,
150f, 310f), new Color(122, 0, 24) * (opening * 0.26f));
// Six projectiles are rendered in the world. The overlay only reinforces
// their curved approach paths and preserves the wounds they cut, keeping
// the composition readable instead of replacing them with six crescents.
float flightFade = 1f - MathHelper.SmoothStep(0f, 1f,
MathHelper.Clamp((progress - 0.72f) / 0.12f, 0f, 1f));
float orbit = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.31f, 190f, 360f);
for (int index = 0; index < 6; index++)
{
float phase = progress * 5.8f + index / 6f;
float angle = index * MathHelper.TwoPi / 6f + phase * MathHelper.TwoPi;
Vector2 tangent = angle.ToRotationVector2();
Vector2 head = focus + tangent * orbit * (0.72f + (float)Math.Sin(phase * 4f) * 0.12f);
Vector2 tail = focus + (angle - 0.54f).ToRotationVector2() * orbit * 0.92f;
DrawLayeredLine(batch, pixel, tail, head, new Color(238, 20, 54),
new Color(8, 0, 3), 20f, 8f, opening * flightFade * 0.68f);
DrawTaperedCrescent(batch, pixel, head, 34f, angle - 2.5f, 4.0f,
opening * flightFade * 0.74f, new Color(58, 0, 14),
new Color(225, 18, 50), new Color(255, 214, 205), 9f);
float scarReveal = Reveal(progress, 0.16f + index * 0.035f,
0.28f + index * 0.035f) * opacity;
float scarAngle = -0.78f + index * 0.31f;
Vector2 scarAxis = scarAngle.ToRotationVector2();
Vector2 scarCenter = focus + (index - 2.5f) * 20f * Vector2.UnitY;
DrawLayeredLine(batch, pixel, scarCenter - scarAxis * orbit * 0.58f,
scarCenter + scarAxis * orbit * 0.58f,
new Color(245, 18, 52), new Color(5, 0, 2),
15f, 8f, scarReveal * flightFade * 0.56f);
}
float finalSlash = Envelope(progress, 0.76f, 0.82f, 0.96f, 1f) * opacity;
if (finalSlash > 0.001f)
{
Vector2 direction = new Vector2(1f, -0.20f).SafeNormalize(Vector2.UnitX);
float reach = (float)Math.Sqrt(viewport.X * viewport.X + viewport.Y * viewport.Y) * 0.72f;
Vector2 start = focus - direction * reach;
Vector2 end = focus + direction * reach;
DrawLayeredLine(batch, pixel, start, end,
new Color(255, 24, 58), new Color(4, 0, 2),
MathHelper.Lerp(18f, 82f, finalSlash),
MathHelper.Lerp(8f, 49f, finalSlash), finalSlash);
DrawGlow(batch, focus, 220f,
new Color(238, 22, 52) * (finalSlash * 0.22f));
}
}
private static void DrawInfernal(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float radius = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.23f, 145f, 265f);
float rotation = -MathHelper.PiOver2 + time * 0.055f;
float circleReveal = Reveal(progress, 0.015f, 0.22f);
DrawRing(batch, pixel, focus, radius * 1.08f, 64, primary * (0.82f * opacity), 4f,
rotation, circleReveal);
DrawRing(batch, pixel, focus, radius * 0.94f, 54, secondary * (0.48f * opacity), 1.8f,
-rotation * 0.7f, circleReveal);
Span<Vector2> vertices = stackalloc Vector2[5];
for (int index = 0; index < vertices.Length; index++)
vertices[index] = focus + (rotation + index * MathHelper.TwoPi / 5f).ToRotationVector2() * radius;
for (int edge = 0; edge < 5; edge++)
{
int startIndex = edge * 2 % 5;
int endIndex = (edge + 1) * 2 % 5;
float reveal = Reveal(progress, 0.08f + edge * 0.085f, 0.24f + edge * 0.085f);
DrawLayeredLine(batch, pixel, vertices[startIndex],
Vector2.Lerp(vertices[startIndex], vertices[endIndex], reveal),
new Color(185, 38, 5), secondary, 13f, 3f, opacity * reveal);
if (reveal > 0.02f)
{
Vector2 flame = vertices[startIndex] + Vector2.UnitY * (10f + (float)Math.Sin(time * 7f + edge) * 5f);
DrawGlow(batch, flame, 38f, primary * (0.25f * opacity * reveal));
DrawRuneTriangle(batch, pixel, vertices[startIndex], 20f, rotation + edge, secondary,
opacity * reveal);
}
}
float ignition = Reveal(progress, 0.62f, 0.82f) * opacity;
for (int index = 0; index < 5; index++)
{
Vector2 direction = (vertices[index] - focus).SafeNormalize(Vector2.UnitY);
Vector2 flameTip = vertices[index] + direction * MathHelper.Lerp(10f, 86f, ignition);
DrawJaggedLine(batch, pixel, vertices[index], flameTip, ignition,
primary, secondary, 9f, 2.2f, 5f, 130f + index * 13f, opacity);
}
float detonation = Pulse(progress, 0.94f, 0.10f) * opacity;
DrawGlow(batch, focus, radius * 1.2f, secondary * (0.25f * detonation));
DrawRing(batch, pixel, focus, MathHelper.Lerp(radius * 0.18f, radius * 1.35f, Ease(detonation)), 72,
Color.White * (0.78f * detonation), 4.5f, rotation, 1f);
float gate = Envelope(progress, 0.58f, 0.72f, 0.98f, 1f) * opacity;
if (gate > 0.001f)
{
float gateWidth = MathHelper.Clamp(viewport.X * 0.24f, 210f, 420f);
float gateHeight = MathHelper.Clamp(viewport.Y * 0.56f, 310f, 590f);
Vector2 topLeft = focus + new Vector2(-gateWidth * 0.5f, -gateHeight * 0.62f);
Vector2 topRight = focus + new Vector2(gateWidth * 0.5f, -gateHeight * 0.62f);
Vector2 bottomLeft = topLeft + Vector2.UnitY * gateHeight;
Vector2 bottomRight = topRight + Vector2.UnitY * gateHeight;
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, new Color(42, 8, 3), primary, 24f, 4f, gate * 0.74f);
DrawLayeredLine(batch, pixel, topRight, bottomRight, new Color(42, 8, 3), primary, 24f, 4f, gate * 0.74f);
DrawTaperedCrescent(batch, pixel, focus - Vector2.UnitY * gateHeight * 0.50f, gateWidth * 0.52f,
MathHelper.Pi, MathHelper.Pi, gate * 0.72f, new Color(30, 4, 0),
new Color(220, 52, 4), secondary, gateWidth * 0.13f);
for (int ember = 0; ember < 9; ember++)
{
float along = ember / 8f;
Vector2 emberPosition = Vector2.Lerp(bottomLeft, bottomRight, along)
- Vector2.UnitY * (22f + (float)Math.Sin(time * 7f + ember) * 18f);
DrawGlow(batch, emberPosition, 28f + ember % 3 * 7f, primary * (gate * 0.24f));
}
}
float execution = Envelope(progress, 0.84f, 0.91f, 0.99f, 1f) * opacity;
if (execution > 0.001f)
{
DrawReaperSilhouette(batch, pixel, focus - Vector2.UnitY * radius * 0.50f,
radius * 1.45f, new Color(18, 3, 0), primary, execution * 0.78f);
DrawTaperedCrescent(batch, pixel, focus, radius * 1.78f, -2.7f, 4.55f, execution,
new Color(58, 7, 0), new Color(255, 75, 5), Color.White, radius * 0.28f);
}
}
private static void DrawFrost(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
Rectangle viewportBounds,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
// A cool gray veil mutes the world without changing Terraria's shared shader state.
batch.Draw(pixel, viewportBounds, new Color(102, 128, 148) * (0.12f * opacity));
float reach = Math.Max(viewport.X, viewport.Y) * 0.68f;
for (int index = 0; index < 4; index++)
{
float reveal = Reveal(progress, 0.16f + index * 0.085f, 0.34f + index * 0.085f);
Vector2 direction = (-MathHelper.PiOver2 + index * MathHelper.PiOver2).ToRotationVector2();
Vector2 end = focus + direction * reach;
DrawJaggedLine(batch, pixel, focus, end, reveal,
new Color(38, 105, 155), secondary, 15f, 3.1f, 17f, 208f + index * 19f, opacity);
for (int branch = 0; branch < 3; branch++)
{
float branchProgress = 0.29f + branch * 0.19f;
if (reveal <= branchProgress)
continue;
Vector2 branchOrigin = Vector2.Lerp(focus, end, branchProgress);
float side = (branch + index) % 2 == 0 ? -1f : 1f;
Vector2 branchDirection = direction.RotatedBy(side * (0.42f + branch * 0.12f));
float branchReveal = MathHelper.Clamp((reveal - branchProgress) / 0.25f, 0f, 1f);
DrawJaggedLine(batch, pixel, branchOrigin,
branchOrigin + branchDirection * (58f + branch * 24f), branchReveal,
primary, Color.White, 7f, 1.6f, 7f, 260f + index * 31f + branch * 7f, opacity * 0.82f);
}
}
float crossReveal = Reveal(progress, 0.76f, 0.93f);
float diagonalReach = Math.Max(viewport.X, viewport.Y) * 0.72f;
for (int index = 0; index < 4; index++)
{
Vector2 direction = (MathHelper.PiOver4 + index * MathHelper.PiOver2).ToRotationVector2();
DrawJaggedLine(batch, pixel, focus, focus + direction * diagonalReach, crossReveal,
primary, Color.White, 24f, 5f, 8f, 330f + index * 17f, opacity);
}
DrawGlow(batch, focus, 180f + (float)Math.Sin(time * 3f) * 12f,
secondary * (Pulse(progress, 0.90f, 0.13f) * 0.26f * opacity));
float mirrors = Envelope(progress, 0.10f, 0.24f, 0.84f, 0.96f) * opacity;
float mirrorOrbit = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.27f, 170f, 300f);
for (int index = 0; index < 4; index++)
{
float angle = MathHelper.PiOver4 + index * MathHelper.PiOver2;
Vector2 center = focus + angle.ToRotationVector2() * mirrorOrbit;
DrawPolygon(batch, pixel, center, 54f, 6, new Color(35, 100, 150) * (mirrors * 0.52f),
13f, angle, 1f);
DrawPolygon(batch, pixel, center, 47f, 6, Color.White * (mirrors * 0.72f),
2.2f, -angle, 1f);
Vector2 reflection = (focus - center).SafeNormalize(Vector2.UnitY);
DrawLayeredLine(batch, pixel, center - reflection.RotatedBy(MathHelper.PiOver2) * 25f,
center + reflection.RotatedBy(MathHelper.PiOver2) * 25f,
primary, Color.White, 8f, 1.5f, mirrors * 0.52f);
}
float shatteredScreen = Envelope(progress, 0.86f, 0.92f, 0.995f, 1f) * opacity;
if (shatteredScreen > 0.001f)
{
Vector2[] corners =
[
new Vector2(0f, 0f),
new Vector2(viewport.X, 0f),
new Vector2(viewport.X, viewport.Y),
new Vector2(0f, viewport.Y),
new Vector2(viewport.X * 0.5f, 0f),
new Vector2(viewport.X, viewport.Y * 0.5f),
new Vector2(viewport.X * 0.5f, viewport.Y),
new Vector2(0f, viewport.Y * 0.5f)
];
for (int index = 0; index < corners.Length; index++)
{
DrawJaggedLine(batch, pixel, focus, corners[index], shatteredScreen,
new Color(84, 170, 220), Color.White, 10f, 2.1f, 16f,
710f + index * 23f, opacity);
}
}
}
private static void DrawSoul(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float riverY = MathHelper.Clamp(focus.Y, viewport.Y * 0.26f, viewport.Y * 0.74f);
float riverReveal = Reveal(progress, 0.02f, 0.24f) * opacity;
float convergence = Reveal(progress, 0.66f, 0.93f);
for (int lane = 0; lane < 3; lane++)
{
const int segments = 34;
Vector2 previous = default;
for (int index = 0; index <= segments; index++)
{
float along = index / (float)segments;
float x = MathHelper.Lerp(-70f, viewport.X + 70f, along);
float wave = (float)Math.Sin(along * MathHelper.TwoPi * 2.2f - time * (1.15f + lane * 0.12f) + lane * 1.8f);
float y = riverY + (lane - 1) * 45f + wave * (22f + lane * 5f);
float centerWeight = 1f - MathHelper.Clamp(Math.Abs(along - 0.5f) * 2f, 0f, 1f);
y = MathHelper.Lerp(y, focus.Y, convergence * centerWeight * 0.88f);
Vector2 current = new(x, y);
if (index > 0)
{
Color laneColor = lane == 1 ? secondary : Color.Lerp(primary, secondary, lane * 0.34f);
DrawLayeredLine(batch, pixel, previous, current, primary, laneColor,
10f - lane * 1.5f, 2.1f, riverReveal * (0.56f + lane * 0.12f));
}
previous = current;
}
}
for (int index = 0; index < 12; index++)
{
float reveal = Reveal(progress, 0.07f + index * 0.022f, 0.19f + index * 0.022f) * opacity;
if (reveal <= 0.001f)
continue;
float along = PositiveModulo(time * (0.065f + index % 3 * 0.006f) + index / 12f, 1f);
int lane = index % 3;
float x = MathHelper.Lerp(-45f, viewport.X + 45f, along);
float y = riverY + (lane - 1) * 45f
+ (float)Math.Sin(along * MathHelper.TwoPi * 2.2f - time * 1.25f + lane * 1.8f) * 24f;
Vector2 riverPosition = new(x, y);
float orbitAngle = index * MathHelper.TwoPi / 12f + time * 0.75f;
Vector2 gatheredPosition = focus + orbitAngle.ToRotationVector2()
* MathHelper.Lerp(72f, 20f, Reveal(progress, 0.82f, 0.98f));
Vector2 position = Vector2.Lerp(riverPosition, gatheredPosition, convergence);
Color shadeColor = Color.Lerp(secondary, Color.White, index % 4 == 0 ? 0.34f : 0.08f);
DrawSoulShade(batch, pixel, position, shadeColor, reveal,
0.78f + (float)Math.Sin(time * 3f + index) * 0.10f, orbitAngle);
}
float burial = Reveal(progress, 0.82f, 0.98f) * opacity;
DrawRing(batch, pixel, focus, MathHelper.Lerp(210f, 26f, Ease(burial)), 56,
secondary * (0.92f * burial), 4f, -time * 0.22f, 1f);
DrawGlow(batch, focus, 150f, primary * (0.30f * burial));
float ferryman = Envelope(progress, 0.63f, 0.76f, 0.99f, 1f) * opacity;
if (ferryman > 0.001f)
{
float scale = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.42f, 260f, 480f);
DrawReaperSilhouette(batch, pixel, focus - Vector2.UnitY * scale * 0.18f,
scale, new Color(12, 5, 35), primary, ferryman * 0.72f);
DrawTaperedCrescent(batch, pixel, focus, scale * 0.92f, -2.75f, 4.72f, ferryman,
new Color(25, 10, 72), primary, new Color(170, 255, 255), scale * 0.16f);
}
float soulBloom = Pulse(progress, 0.94f, 0.08f) * opacity;
for (int petal = 0; petal < 8; petal++)
{
float angle = petal * MathHelper.PiOver4 + time * 0.08f;
Vector2 direction = angle.ToRotationVector2();
DrawLayeredLine(batch, pixel, focus + direction * 20f,
focus + direction * MathHelper.Lerp(28f, 190f, soulBloom),
primary, secondary, 11f, 2.2f, soulBloom * 0.58f);
}
}
private static void DrawVoid(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
Rectangle viewportBounds,
float progress,
float opacity,
float time,
Color primary,
Color secondary,
Vector2 aim,
int actionId)
{
// The combat projectile owns the one and only world-space rift. Keeping
// this UI layer to atmosphere prevents a second crack from following the
// camera while the authoritative tear stays in the world.
batch.Draw(pixel, viewportBounds, new Color(1, 0, 5) * (0.31f * opacity));
DrawGlow(batch, focus, 210f,
secondary * (Reveal(progress, 0.48f, 1f) * 0.24f * opacity));
}
private static void DrawDeath(
SpriteBatch batch,
Texture2D pixel,
int ownerIndex,
in UltimateVisualState state,
Vector2 focus,
Vector2 viewport,
Rectangle viewportBounds,
float progress,
float opacity,
float time)
{
float shatterStart = ReaperDeathUltimateGeometry.ShatterTick
/ (float)ReaperDeathUltimateGeometry.Duration;
float isolation = Envelope(progress, 0.58f, 0.79f,
shatterStart - 0.015f, shatterStart + 0.012f) * opacity;
Texture2D? capturedWorld = Main.screenTarget;
// Each successful cut removes more of the ordinary scene. Immediately
// before the shatter, only small windows around the caster and recorded
// victims are restored from Terraria's world render target.
if (isolation > 0.001f)
{
batch.Draw(pixel, viewportBounds,
new Color(0, 0, 1) * (isolation * 0.965f));
if (capturedWorld is not null && !capturedWorld.IsDisposed)
DrawDeathUltimateActors(batch, capturedWorld, ownerIndex,
state.ActionId, viewport, isolation);
}
float shatter = Reveal(progress, shatterStart, 0.985f) * opacity;
if (shatter > 0.001f)
{
// The actual Death Necklace plates fill the void behind the broken
// game image; no substitute gradient or black fill is used here.
DeathDomainBackdropTextureSystem.DrawScreenAlignedBackdrop(batch,
viewportBounds, shatter);
if (capturedWorld is not null && !capturedWorld.IsDisposed)
DrawDeathMirrorShards(batch, capturedWorld, focus, viewport,
state.ActionId, shatter, opacity);
}
DrawDeathUltimateCutCracks(batch, pixel, in state, focus, viewport,
shatter, opacity);
DrawGlow(batch, focus, 230f,
new Color(125, 0, 34) * ((0.12f + shatter * 0.18f) * opacity));
_ = time;
}
private static void DrawDeathUltimateActors(SpriteBatch batch,
Texture2D capturedWorld, int ownerIndex, int actionId,
Vector2 viewport, float opacity)
{
if (ownerIndex < 0 || ownerIndex >= Main.maxPlayers)
return;
Player owner = Main.player[ownerIndex];
if (owner.active && !owner.dead)
DrawCapturedActorWindow(batch, capturedWorld, owner.getRect(),
viewport, opacity, 34f);
HashSet<int> drawnRoots = [];
foreach (NPC npc in Main.ActiveNPCs)
{
int root = npc.realLife >= 0 ? npc.realLife : npc.whoAmI;
if (root < 0 || root >= Main.maxNPCs || !drawnRoots.Add(root))
continue;
NPC target = Main.npc[root];
if (!target.active
|| !target.GetGlobalNPC<ReaperCombatGlobalNPC>()
.IsTrackedByDeathUltimate(ownerIndex, actionId))
{
continue;
}
DrawCapturedActorWindow(batch, capturedWorld, target.Hitbox,
viewport, opacity, 28f);
}
}
private static void DrawCapturedActorWindow(SpriteBatch batch,
Texture2D capturedWorld, Rectangle worldBounds, Vector2 viewport,
float opacity, float padding)
{
Rectangle screenBounds = new(
(int)Math.Floor(worldBounds.X - Main.screenPosition.X - padding),
(int)Math.Floor(worldBounds.Y - Main.screenPosition.Y - padding),
Math.Max(1, (int)Math.Ceiling(worldBounds.Width + padding * 2f)),
Math.Max(1, (int)Math.Ceiling(worldBounds.Height + padding * 2f)));
Rectangle clipped = Rectangle.Intersect(screenBounds,
new Rectangle(0, 0, (int)viewport.X, (int)viewport.Y));
if (clipped.Width <= 0 || clipped.Height <= 0)
return;
const int bands = 12;
for (int band = 0; band < bands; band++)
{
float y0 = band / (float)bands;
float y1 = (band + 1f) / bands;
float normalizedY = (y0 + y1) - 1f;
float halfWidth = (float)Math.Sqrt(Math.Max(0f,
1f - normalizedY * normalizedY));
int bandTop = screenBounds.Top
+ (int)Math.Floor(screenBounds.Height * y0);
int bandBottom = screenBounds.Top
+ (int)Math.Ceiling(screenBounds.Height * y1);
int bandHalfWidth = Math.Max(1,
(int)Math.Ceiling(screenBounds.Width * 0.5f * halfWidth));
Rectangle destination = new(
screenBounds.Center.X - bandHalfWidth,
bandTop,
bandHalfWidth * 2,
Math.Max(1, bandBottom - bandTop));
destination = Rectangle.Intersect(destination, clipped);
if (destination.Width <= 0 || destination.Height <= 0)
continue;
Rectangle source = new(
(int)Math.Floor(destination.X / viewport.X * capturedWorld.Width),
(int)Math.Floor(destination.Y / viewport.Y * capturedWorld.Height),
Math.Max(1, (int)Math.Ceiling(destination.Width / viewport.X
* capturedWorld.Width)),
Math.Max(1, (int)Math.Ceiling(destination.Height / viewport.Y
* capturedWorld.Height)));
source = Rectangle.Intersect(source, capturedWorld.Bounds);
if (source.Width > 0 && source.Height > 0)
batch.Draw(capturedWorld, destination, source,
Color.White * MathHelper.Clamp(opacity, 0f, 1f));
}
}
private static void DrawDeathMirrorShards(SpriteBatch batch,
Texture2D capturedWorld, Vector2 focus, Vector2 viewport,
int actionId, float shatter, float opacity)
{
if (Main.graphics?.GraphicsDevice is not GraphicsDevice graphicsDevice)
return;
int rayCount = deathMirrorAngles.Length;
for (int cut = 0; cut < ReaperDeathUltimateGeometry.CutCount; cut++)
{
float angle = ReaperDeathUltimateGeometry.GetCutAxis(actionId, cut)
.ToRotation();
if (angle < 0f)
angle += MathHelper.TwoPi;
deathMirrorAngles[cut * 2] = angle;
deathMirrorAngles[cut * 2 + 1] = PositiveModulo(
angle + MathHelper.Pi, MathHelper.TwoPi);
}
Array.Sort(deathMirrorAngles);
float eased = Ease(shatter);
float radius = GetViewportCoverRadius(focus, viewport) * 1.08f;
Color shardColor = Color.White
* (opacity * MathHelper.Lerp(1f, 0.48f, eased));
int vertex = 0;
for (int shard = 0; shard < rayCount; shard++)
{
float startAngle = deathMirrorAngles[shard];
float endAngle = shard == rayCount - 1
? deathMirrorAngles[0] + MathHelper.TwoPi
: deathMirrorAngles[shard + 1];
float middleAngle = (startAngle + endAngle) * 0.5f;
uint hash = unchecked((uint)(actionId * 16777619
+ shard * 2246822519));
hash ^= hash >> 15;
float random = (hash & 0xFFFFu) / 65535f;
float signed = ((hash >> 16) & 1u) == 0u ? -1f : 1f;
Vector2 displacement = middleAngle.ToRotationVector2()
* ((18f + random * 48f) * eased)
+ Vector2.UnitY * (eased * eased * (8f + random * 34f));
float rotation = signed * (0.012f + random * 0.032f) * eased;
Vector2 originalCenter = focus;
Vector2 originalStart = focus
+ startAngle.ToRotationVector2() * radius;
Vector2 originalEnd = focus
+ endAngle.ToRotationVector2() * radius;
WriteMirrorVertex(ref vertex,
RotatePoint(originalCenter, focus, rotation) + displacement,
originalCenter, viewport, shardColor);
WriteMirrorVertex(ref vertex,
RotatePoint(originalStart, focus, rotation) + displacement,
originalStart, viewport, shardColor);
WriteMirrorVertex(ref vertex,
RotatePoint(originalEnd, focus, rotation) + displacement,
originalEnd, viewport, shardColor);
}
batch.End();
try
{
deathMirrorEffect ??= new BasicEffect(graphicsDevice)
{
TextureEnabled = true,
VertexColorEnabled = true,
LightingEnabled = false,
FogEnabled = false
};
deathMirrorEffect.World = Matrix.Identity;
deathMirrorEffect.View = Matrix.Identity;
deathMirrorEffect.Projection = Matrix.CreateOrthographicOffCenter(
0f, viewport.X, viewport.Y, 0f, 0f, 1f);
deathMirrorEffect.Texture = capturedWorld;
graphicsDevice.BlendState = BlendState.AlphaBlend;
graphicsDevice.DepthStencilState = DepthStencilState.None;
graphicsDevice.RasterizerState = RasterizerState.CullNone;
graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp;
foreach (EffectPass pass in deathMirrorEffect.CurrentTechnique.Passes)
{
pass.Apply();
graphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleList,
deathMirrorVertices, 0, vertex / 3);
}
}
finally
{
batch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend,
SamplerState.LinearClamp, DepthStencilState.None,
RasterizerState.CullNone, null, Matrix.Identity);
}
}
private static void WriteMirrorVertex(ref int index, Vector2 position,
Vector2 samplePosition, Vector2 viewport, Color color)
{
Vector2 uv = new(
samplePosition.X / Math.Max(1f, viewport.X),
samplePosition.Y / Math.Max(1f, viewport.Y));
deathMirrorVertices[index++] = new VertexPositionColorTexture(
new Vector3(position, 0f), color, uv);
}
private static Vector2 RotatePoint(Vector2 point, Vector2 origin,
float rotation)
=> origin + (point - origin).RotatedBy(rotation);
private static float GetViewportCoverRadius(Vector2 focus, Vector2 viewport)
{
float radius = focus.Length();
radius = Math.Max(radius, Vector2.Distance(focus,
new Vector2(viewport.X, 0f)));
radius = Math.Max(radius, Vector2.Distance(focus,
new Vector2(0f, viewport.Y)));
radius = Math.Max(radius, Vector2.Distance(focus, viewport));
return Math.Max(1f, radius);
}
private static void DrawDeathUltimateCutCracks(SpriteBatch batch,
Texture2D pixel, in UltimateVisualState state, Vector2 focus,
Vector2 viewport, float shatter, float opacity)
{
float radius = GetViewportCoverRadius(focus, viewport) * 1.04f;
for (int cut = 0; cut < ReaperDeathUltimateGeometry.CutCount; cut++)
{
int cutTick = ReaperDeathUltimateGeometry.GetCutTick(cut);
if (state.Timer < cutTick)
continue;
float age = state.Timer - cutTick;
float fresh = (float)Math.Exp(-age / 13f);
float strength = (0.12f + fresh * 0.38f + shatter * 0.74f)
* opacity;
Vector2 axis = ReaperDeathUltimateGeometry.GetCutAxis(
state.ActionId, cut);
Vector2 start = focus - axis * radius;
Vector2 end = focus + axis * radius;
DrawLayeredLine(batch, pixel, start, end,
new Color(32, 0, 15),
Color.Lerp(new Color(235, 12, 62), Color.White,
shatter * 0.48f),
4f + shatter * 3f, 0.9f + shatter * 0.8f,
strength);
}
}
private static void DrawDeathLegacy(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time)
{
ReadOnlySpan<ReaperFormId> forms =
[
ReaperFormId.Bone,
ReaperFormId.Blood,
ReaperFormId.Infernal,
ReaperFormId.Frost,
ReaperFormId.Soul,
ReaperFormId.Void
];
float converge = Reveal(progress, 0.69f, 0.92f);
float initialOrbit = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.31f, 205f, 340f);
float orbitRadius = MathHelper.Lerp(initialOrbit, 34f, Ease(converge));
float rotation = -MathHelper.PiOver2 + time * MathHelper.Lerp(0.08f, 0.72f, converge);
for (int index = 0; index < forms.Length; index++)
{
float reveal = Reveal(progress, 0.015f + index * 0.038f, 0.105f + index * 0.038f) * opacity;
if (reveal <= 0.001f)
continue;
Color color = ReaperCombatRegistry.GetPrimaryColor(forms[index]);
Color core = ReaperCombatRegistry.GetSecondaryColor(forms[index]);
float angle = rotation + index * MathHelper.TwoPi / forms.Length;
Vector2 originalPosition = focus + angle.ToRotationVector2() * initialOrbit;
Vector2 position = focus + angle.ToRotationVector2() * orbitRadius;
if (converge > 0.001f)
DrawLayeredLine(batch, pixel, originalPosition, position, color, core, 9f, 2f,
converge * reveal * 0.58f);
DrawLayeredLine(batch, pixel, position, focus, color, core, 5f, 1.2f, reveal * 0.30f);
DrawGlow(batch, position, 54f, color * (0.24f * reveal));
float phaseCenter = 36f / 170f + index * 18f / 170f;
float activePulse = 0.74f + Pulse(progress, phaseCenter, 0.055f) * 0.36f;
DrawDeathGate(batch, pixel, position, index, angle, reveal * activePulse,
converge, time, color, core);
}
// Six executions use their branch's actual silhouette, not six recolored
// copies of one crescent. Their centers match the authoritative hit ticks.
for (int index = 0; index < forms.Length; index++)
{
float center = 36f / 170f + index * 18f / 170f;
float phase = Envelope(progress, center - 0.055f, center - 0.012f,
center + 0.052f, center + 0.105f) * opacity;
if (phase > 0.001f)
DrawDeathPhaseMotif(batch, pixel, focus, viewport, index, phase, time);
}
float unity = Reveal(progress, 0.72f, 0.96f) * opacity;
if (unity > 0.001f)
{
for (int index = 0; index < forms.Length; index++)
{
Color color = ReaperCombatRegistry.GetPrimaryColor(forms[index]);
Vector2 direction = (rotation + index * MathHelper.TwoPi / forms.Length).ToRotationVector2();
DrawLayeredLine(batch, pixel, focus, focus + direction * MathHelper.Lerp(18f, 115f, 1f - converge),
color, Color.White, 12f, 2.1f, unity * 0.72f);
}
DrawRing(batch, pixel, focus, MathHelper.Lerp(152f, 24f, Ease(unity)), 64,
Color.White * (0.88f * unity), 5f, rotation, 1f);
DrawRing(batch, pixel, focus, MathHelper.Lerp(104f, 15f, Ease(unity)), 54,
new Color(255, 58, 105) * (0.72f * unity), 2.5f, -rotation, 1f);
DrawGlow(batch, focus, 210f, Color.White * (0.20f * unity));
}
float finalCut = Reveal(progress, 0.86f, 0.985f);
float reach = Math.Max(viewport.X, viewport.Y) * 0.80f;
Vector2 cutDirection = new Vector2(1f, -0.16f).SafeNormalize(Vector2.UnitX);
DrawJaggedLine(batch, pixel, focus - cutDirection * reach, focus + cutDirection * reach,
finalCut, new Color(225, 30, 75), Color.White, 34f, 6f, 5f, 667f, opacity);
float requiem = Envelope(progress, 0.82f, 0.90f, 0.99f, 1f) * opacity;
if (requiem > 0.001f)
{
float scale = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.58f, 370f, 690f);
DrawReaperSilhouette(batch, pixel, focus - Vector2.UnitY * scale * 0.23f,
scale, new Color(3, 0, 4), new Color(210, 18, 54), requiem * 0.88f);
for (int band = 0; band < forms.Length; band++)
{
Color color = ReaperCombatRegistry.GetPrimaryColor(forms[band]);
DrawTaperedCrescent(batch, pixel, focus, scale * (0.94f - band * 0.032f),
-2.74f + band * 0.018f, 4.62f, requiem * (0.20f + band * 0.035f),
new Color(8, 0, 10), Color.Lerp(new Color(120, 0, 28), color, 0.42f),
color, scale * (0.16f - band * 0.012f));
}
DrawTaperedCrescent(batch, pixel, focus, scale, -2.76f, 4.64f, requiem,
new Color(8, 0, 10), new Color(224, 18, 56), Color.White, scale * 0.10f);
}
}
private static void DrawDeathGate(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
int gate,
float rotation,
float opacity,
float converge,
float time,
Color color,
Color core)
{
float size = MathHelper.Lerp(42f, 23f, converge);
switch (gate)
{
case 0: // Ribbed bone guillotine gate.
{
Vector2 topLeft = center + new Vector2(-size * 0.68f, -size);
Vector2 topRight = center + new Vector2(size * 0.68f, -size);
Vector2 bottomLeft = center + new Vector2(-size * 0.68f, size);
Vector2 bottomRight = center + new Vector2(size * 0.68f, size);
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, new Color(6, 28, 35), color,
8f, 2f, opacity);
DrawLayeredLine(batch, pixel, topRight, bottomRight, new Color(6, 28, 35), color,
8f, 2f, opacity);
DrawJaggedLine(batch, pixel, topLeft, topRight, 1f, color, core,
9f, 2.2f, 2f, 90f, opacity);
for (int rib = 0; rib < 3; rib++)
{
float y = MathHelper.Lerp(-size * 0.52f, size * 0.58f, rib / 2f);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.66f, y),
center + new Vector2(-size * 0.16f, y + size * 0.13f), color, core,
4f, 1f, opacity * 0.78f);
DrawLayeredLine(batch, pixel, center + new Vector2(size * 0.66f, y),
center + new Vector2(size * 0.16f, y + size * 0.13f), color, core,
4f, 1f, opacity * 0.78f);
}
break;
}
case 1: // Blood moon gate and white-rimmed crescent.
DrawGlow(batch, center, size * 1.85f, new Color(126, 0, 24) * (opacity * 0.42f));
DrawRing(batch, pixel, center, size * 0.86f, 32, color * (opacity * 0.82f),
size * 0.18f, rotation, 1f);
DrawTaperedCrescent(batch, pixel, center, size * 0.92f, -2.55f, 4.24f,
opacity, new Color(55, 0, 16), color, Color.White, size * 0.18f);
break;
case 2: // Infernal five-point gate.
DrawRing(batch, pixel, center, size, 36, new Color(52, 8, 0) * opacity,
7f, rotation, 1f);
DrawPentagram(batch, pixel, center, size * 0.88f, rotation + time * 0.05f,
new Color(70, 7, 0), core, opacity);
break;
case 3: // Hexagonal frost mirror and X blades.
DrawPolygon(batch, pixel, center, size, 6, new Color(54, 120, 170) * (opacity * 0.72f),
10f, rotation, 1f);
DrawPolygon(batch, pixel, center, size * 0.86f, 6, Color.White * opacity,
2f, -rotation, 1f);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.66f, -size * 0.66f),
center + new Vector2(size * 0.66f, size * 0.66f), color, core, 5f, 1.2f, opacity);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.66f, size * 0.66f),
center + new Vector2(size * 0.66f, -size * 0.66f), color, Color.White, 5f, 1.2f, opacity);
break;
case 4: // Soft soul portal with a single ferryman shade.
DrawRing(batch, pixel, center, size, 36, color * (opacity * 0.72f), 5f,
rotation + time * 0.1f, 1f);
DrawRing(batch, pixel, center, size * 0.72f, 30, core * (opacity * 0.54f), 2f,
-rotation, 1f);
DrawSoulShade(batch, pixel, center, core, opacity, size / 44f, time);
break;
default: // Offset coordinate door cut out of the scene.
{
Rectangle voidCore = new(
(int)Math.Round(center.X - size * 0.72f),
(int)Math.Round(center.Y - size),
Math.Max(1, (int)Math.Round(size * 1.44f)),
Math.Max(1, (int)Math.Round(size * 2f)));
batch.Draw(pixel, voidCore, new Color(0, 0, 2) * (opacity * 0.94f));
Vector2 topLeft = new(voidCore.Left, voidCore.Top);
Vector2 topRight = new(voidCore.Right, voidCore.Top + size * 0.12f);
Vector2 bottomLeft = new(voidCore.Left, voidCore.Bottom - size * 0.12f);
Vector2 bottomRight = new(voidCore.Right, voidCore.Bottom);
DrawLayeredLine(batch, pixel, topLeft, topRight, color, Color.White, 6f, 1.3f, opacity);
DrawLayeredLine(batch, pixel, bottomLeft, bottomRight, color, core, 6f, 1.3f, opacity);
DrawLayeredLine(batch, pixel, center - Vector2.UnitX * size * 0.90f,
center + Vector2.UnitX * size * 0.90f, Color.Black, core, 10f, 2f, opacity);
break;
}
}
DrawDeathRuneGlyph(batch, pixel, center, gate, size * 0.28f, color, core, opacity * 0.74f);
}
private static void DrawDeathPhaseMotif(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
int phase,
float opacity,
float time)
{
float shortSide = Math.Min(viewport.X, viewport.Y);
float longSide = Math.Max(viewport.X, viewport.Y);
switch (phase)
{
case 0: // Bone guillotine and rib frame.
{
Color bone = new(210, 244, 232);
Color corpseFire = new(58, 214, 228);
float halfWidth = MathHelper.Clamp(viewport.X * 0.17f, 145f, 270f);
float height = MathHelper.Clamp(viewport.Y * 0.52f, 300f, 520f);
Vector2 topLeft = focus + new Vector2(-halfWidth, -height * 0.56f);
Vector2 topRight = focus + new Vector2(halfWidth, -height * 0.56f);
Vector2 bottomLeft = topLeft + Vector2.UnitY * height;
Vector2 bottomRight = topRight + Vector2.UnitY * height;
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, new Color(8, 28, 34), corpseFire,
18f, 3f, opacity);
DrawLayeredLine(batch, pixel, topRight, bottomRight, new Color(8, 28, 34), corpseFire,
18f, 3f, opacity);
DrawJaggedLine(batch, pixel, topLeft, topRight, 1f, corpseFire, bone,
20f, 4f, 5f, 180f, opacity);
for (int rib = 0; rib < 5; rib++)
{
float amount = (rib + 1f) / 6f;
Vector2 left = Vector2.Lerp(topLeft, bottomLeft, amount);
Vector2 right = Vector2.Lerp(topRight, bottomRight, amount);
DrawLayeredLine(batch, pixel, left, Vector2.Lerp(left, focus, 0.56f),
corpseFire, bone, 8f, 2f, opacity * 0.68f);
DrawLayeredLine(batch, pixel, right, Vector2.Lerp(right, focus, 0.56f),
corpseFire, bone, 8f, 2f, opacity * 0.68f);
}
DrawJaggedLine(batch, pixel, topRight + new Vector2(-20f, 30f),
bottomLeft + new Vector2(34f, -20f), 1f, new Color(22, 92, 110), bone,
28f, 5f, 4f, 219f, opacity);
break;
}
case 1: // Thick reference-style blood crescent.
{
float radius = MathHelper.Clamp(shortSide * 0.54f, 330f, 610f);
Vector2 center = focus + new Vector2(-radius * 0.13f, radius * 0.05f);
DrawGlow(batch, focus - Vector2.UnitY * radius * 0.25f, radius * 0.62f,
new Color(115, 0, 22) * (opacity * 0.42f));
DrawTaperedCrescent(batch, pixel, center, radius * 1.025f, -2.50f, 4.36f,
opacity * 0.24f, new Color(35, 0, 10), new Color(155, 5, 34),
new Color(255, 102, 112), radius * 0.22f);
DrawTaperedCrescent(batch, pixel, center, radius, -2.46f, 4.36f,
opacity, new Color(70, 0, 18), new Color(238, 24, 58),
new Color(255, 244, 226), radius * 0.18f);
DrawImpactStar(batch, pixel, focus + new Vector2(radius * 0.20f, radius * 0.43f),
radius * 0.09f, new Color(255, 145, 65), Color.White, opacity);
break;
}
case 2: // Pentagram and black-shell molten tracks.
{
float radius = MathHelper.Clamp(shortSide * 0.30f, 190f, 350f);
float rotation = -MathHelper.PiOver2 + time * 0.06f;
DrawPentagram(batch, pixel, focus, radius, rotation, new Color(43, 4, 0),
new Color(255, 192, 46), opacity);
for (int index = 0; index < 5; index++)
{
Vector2 direction = (rotation + index * MathHelper.TwoPi / 5f).ToRotationVector2();
Vector2 vertex = focus + direction * radius;
DrawLayeredLine(batch, pixel, focus, vertex + direction * radius * 0.55f,
new Color(12, 3, 0), new Color(255, 92, 8), 24f, 5f, opacity);
DrawGlow(batch, vertex, 52f, new Color(255, 150, 18) * (opacity * 0.30f));
}
break;
}
case 3: // Four frost mirrors and a crystalline X.
{
float orbit = MathHelper.Clamp(shortSide * 0.24f, 155f, 285f);
for (int index = 0; index < 4; index++)
{
float angle = MathHelper.PiOver4 + index * MathHelper.PiOver2;
Vector2 mirror = focus + angle.ToRotationVector2() * orbit;
DrawPolygon(batch, pixel, mirror, 58f, 6,
new Color(42, 126, 184) * (opacity * 0.66f), 15f, angle, 1f);
DrawPolygon(batch, pixel, mirror, 50f, 6, Color.White * opacity,
2.4f, -angle, 1f);
}
Vector2 diagonalA = new Vector2(1f, 1f).SafeNormalize(Vector2.One);
Vector2 diagonalB = new Vector2(1f, -1f).SafeNormalize(Vector2.UnitX);
DrawLayeredLine(batch, pixel, focus - diagonalA * longSide * 0.52f,
focus + diagonalA * longSide * 0.52f, new Color(45, 130, 190),
Color.White, 26f, 4f, opacity);
DrawLayeredLine(batch, pixel, focus - diagonalB * longSide * 0.52f,
focus + diagonalB * longSide * 0.52f, new Color(28, 91, 160),
new Color(190, 250, 255), 26f, 4f, opacity);
break;
}
case 4: // Winding soul river and ferryman shades.
{
for (int lane = 0; lane < 3; lane++)
{
Vector2 previous = default;
for (int segment = 0; segment <= 20; segment++)
{
float along = segment / 20f;
Vector2 current = new(
MathHelper.Lerp(-50f, viewport.X + 50f, along),
focus.Y + (lane - 1) * 46f
+ (float)Math.Sin(along * MathHelper.TwoPi * 2f + lane * 1.7f - time) * 24f);
if (segment > 0)
{
DrawLayeredLine(batch, pixel, previous, current, new Color(31, 8, 72),
lane == 1 ? new Color(118, 240, 242) : new Color(120, 75, 225),
13f, 2.4f, opacity * 0.78f);
}
previous = current;
}
}
for (int index = 0; index < 7; index++)
{
float angle = index * MathHelper.TwoPi / 7f + time * 0.25f;
Vector2 shade = focus + angle.ToRotationVector2() * (70f + index % 2 * 38f);
DrawSoulShade(batch, pixel, shade, new Color(154, 246, 239), opacity,
0.72f + index % 3 * 0.10f, angle);
}
break;
}
default: // Coordinate grid collapses into a negative-space world split.
{
float splitWidth = MathHelper.Clamp(shortSide * 0.10f, 68f, 128f);
batch.Draw(pixel, new Rectangle(0, (int)Math.Round(focus.Y - splitWidth * 0.5f),
(int)Math.Ceiling(viewport.X), (int)Math.Round(splitWidth)),
new Color(0, 0, 2) * (opacity * 0.96f));
batch.Draw(pixel, new Rectangle((int)Math.Round(focus.X - splitWidth * 0.38f), 0,
(int)Math.Round(splitWidth * 0.76f), (int)Math.Ceiling(viewport.Y)),
new Color(0, 0, 2) * (opacity * 0.96f));
DrawLayeredLine(batch, pixel, new Vector2(0f, focus.Y - splitWidth * 0.5f),
new Vector2(viewport.X, focus.Y - splitWidth * 0.5f), new Color(82, 9, 130),
Color.White, 9f, 2f, opacity);
DrawLayeredLine(batch, pixel, new Vector2(focus.X + splitWidth * 0.38f, 0f),
new Vector2(focus.X + splitWidth * 0.38f, viewport.Y), new Color(55, 4, 100),
new Color(220, 160, 255), 9f, 2f, opacity);
for (int panel = 0; panel < 5; panel++)
{
float y = viewport.Y * (panel + 1f) / 6f;
float offset = (panel % 2 == 0 ? 1f : -1f) * 22f * opacity;
DrawLayeredLine(batch, pixel, new Vector2(offset, y),
new Vector2(viewport.X + offset, y), Color.Black,
new Color(122, 30, 180), 7f, 1.5f, opacity * 0.72f);
}
break;
}
}
}
private static void DrawPentagram(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
float rotation,
Color shell,
Color core,
float opacity)
{
Span<Vector2> vertices = stackalloc Vector2[5];
for (int index = 0; index < vertices.Length; index++)
vertices[index] = center + (rotation + index * MathHelper.TwoPi / 5f).ToRotationVector2() * radius;
for (int edge = 0; edge < vertices.Length; edge++)
{
int start = edge * 2 % 5;
int end = (edge + 1) * 2 % 5;
DrawLayeredLine(batch, pixel, vertices[start], vertices[end], shell, core,
15f, 3f, opacity);
}
DrawRing(batch, pixel, center, radius * 1.04f, 48, shell * (opacity * 0.80f),
7f, rotation, 1f);
}
private static void DrawTaperedCrescent(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
float rotation,
float sweep,
float opacity,
Color shadow,
Color body,
Color edge,
float thickness)
{
opacity = MathHelper.Clamp(opacity, 0f, 1f);
if (opacity <= 0.001f || radius <= 2f || thickness <= 0.5f || Math.Abs(sweep) <= 0.01f)
return;
ReaperUltimateCrescentMaskSet? mask = SelectCrescentMask(Math.Abs(sweep), thickness / radius);
if (mask is null || mask.Body.IsDisposed || mask.Flow.IsDisposed || mask.Edge.IsDisposed)
return;
float scale = radius / CrescentReferenceRadius;
Vector2 textureOrigin = new(CrescentMaskSize * 0.5f);
SpriteEffects effects = sweep < 0f ? SpriteEffects.FlipVertically : SpriteEffects.None;
// Four cached-mask draws replace hundreds of MagicPixel segments. Body,
// longitudinal flow and white-hot rim remain independently tintable.
batch.Draw(mask.Body, center, null, shadow * (opacity * 0.48f), rotation,
textureOrigin, scale * 1.025f, effects, 0f);
batch.Draw(mask.Body, center, null, body * (opacity * 0.84f), rotation,
textureOrigin, scale, effects, 0f);
batch.Draw(mask.Flow, center, null, Color.Lerp(body, edge, 0.34f) * (opacity * 0.48f),
rotation + (float)Math.Sin(Main.GlobalTimeWrappedHourly * 2.4f) * 0.004f,
textureOrigin, scale, effects, 0f);
batch.Draw(mask.Edge, center, null, edge * opacity, rotation,
textureOrigin, scale, effects, 0f);
}
private static ReaperUltimateCrescentMaskSet? SelectCrescentMask(float sweep, float thicknessRatio)
{
ReaperUltimateCrescentMaskSet? best = null;
float bestScore = float.MaxValue;
for (int index = 0; index < crescentMasks.Length; index++)
{
ReaperUltimateCrescentMaskSet candidate = crescentMasks[index];
// Preserve the requested arc silhouette first; thickness selects the
// closer preset when two sweep families are visually comparable.
float score = Math.Abs(candidate.Sweep - sweep) * 2.4f
+ Math.Abs(candidate.ThicknessRatio - thicknessRatio) * 4f;
if (score >= bestScore)
continue;
best = candidate;
bestScore = score;
}
return best;
}
private static void EnsureCrescentMasks()
{
if (crescentMasks.Length > 0)
return;
if (Main.dedServ || Main.graphics?.GraphicsDevice is not GraphicsDevice graphicsDevice)
return;
crescentMasks =
[
CreateCrescentMask(graphicsDevice, 3.58f, 0.115f),
CreateCrescentMask(graphicsDevice, 4.24f, 0.175f),
CreateCrescentMask(graphicsDevice, 4.66f, 0.245f)
];
}
private static ReaperUltimateCrescentMaskSet CreateCrescentMask(
GraphicsDevice graphicsDevice,
float sweep,
float thicknessRatio)
{
Color[] bodyData = new Color[CrescentMaskSize * CrescentMaskSize];
Color[] flowData = new Color[bodyData.Length];
Color[] edgeData = new Color[bodyData.Length];
float center = CrescentMaskSize * 0.5f;
float maximumWidth = CrescentReferenceRadius * thicknessRatio;
for (int y = 0; y < CrescentMaskSize; y++)
{
float dy = y + 0.5f - center;
for (int x = 0; x < CrescentMaskSize; x++)
{
float dx = x + 0.5f - center;
float radial = (float)Math.Sqrt(dx * dx + dy * dy);
if (radial < CrescentReferenceRadius - maximumWidth
|| radial > CrescentReferenceRadius + maximumWidth)
{
continue;
}
float angle = (float)Math.Atan2(dy, dx);
if (angle < 0f)
angle += MathHelper.TwoPi;
if (angle > sweep)
continue;
float along = angle / sweep;
float taper = (float)Math.Pow(Math.Max(0f, Math.Sin(along * MathHelper.Pi)), 0.58f);
taper *= MathHelper.Lerp(0.72f, 1f, 1f - along * 0.42f);
float halfWidth = Math.Max(0.75f, maximumWidth * taper * 0.5f);
float distance = Math.Abs(radial - CrescentReferenceRadius);
float bodyAlpha = MathHelper.Clamp((halfWidth + 1.6f - distance) / 2.8f, 0f, 1f);
if (bodyAlpha <= 0f)
continue;
int dataIndex = y * CrescentMaskSize + x;
bodyData[dataIndex] = PremultipliedMask(bodyAlpha);
float normalizedRadial = (radial - CrescentReferenceRadius) / Math.Max(1f, halfWidth);
float firstFlow = -0.34f + (float)Math.Sin(along * MathHelper.TwoPi * 2.1f) * 0.10f;
float secondFlow = 0.18f + (float)Math.Sin(along * MathHelper.TwoPi * 3.2f + 1.3f) * 0.11f;
float flowAlpha = Math.Max(
1f - Math.Abs(normalizedRadial - firstFlow) / 0.12f,
1f - Math.Abs(normalizedRadial - secondFlow) / 0.09f);
flowAlpha = MathHelper.Clamp(flowAlpha, 0f, 1f) * bodyAlpha * (0.62f + taper * 0.38f);
flowData[dataIndex] = PremultipliedMask(flowAlpha);
float rimRadius = CrescentReferenceRadius + halfWidth * 0.88f;
float rimWidth = Math.Max(1.35f, maximumWidth * 0.055f);
float rimAlpha = MathHelper.Clamp((rimWidth + 1.2f - Math.Abs(radial - rimRadius)) / 2.2f, 0f, 1f);
edgeData[dataIndex] = PremultipliedMask(rimAlpha * bodyAlpha);
}
}
Texture2D bodyTexture = new(graphicsDevice, CrescentMaskSize, CrescentMaskSize);
Texture2D flowTexture = new(graphicsDevice, CrescentMaskSize, CrescentMaskSize);
Texture2D edgeTexture = new(graphicsDevice, CrescentMaskSize, CrescentMaskSize);
bodyTexture.SetData(bodyData);
flowTexture.SetData(flowData);
edgeTexture.SetData(edgeData);
return new ReaperUltimateCrescentMaskSet(sweep, thicknessRatio, bodyTexture, flowTexture, edgeTexture);
}
private static Color PremultipliedMask(float opacity)
{
byte value = (byte)Math.Round(MathHelper.Clamp(opacity, 0f, 1f) * byte.MaxValue);
return new Color(value, value, value, value);
}
private static void DisposeCrescentMasks(ReaperUltimateCrescentMaskSet[] masks)
{
for (int index = 0; index < masks.Length; index++)
masks[index].Dispose();
}
private static void DrawImpactStar(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
Color outer,
Color core,
float opacity)
{
opacity = MathHelper.Clamp(opacity, 0f, 1f);
if (opacity <= 0.001f || radius <= 1f)
return;
DrawGlow(batch, center, radius * 2.4f, outer * (opacity * 0.30f));
for (int ray = 0; ray < 10; ray++)
{
float angle = ray * MathHelper.TwoPi / 10f + (ray % 2) * 0.11f;
float rayLength = radius * (ray % 2 == 0 ? 1f : 0.55f);
Vector2 direction = angle.ToRotationVector2();
DrawLayeredLine(batch, pixel, center - direction * rayLength * 0.12f,
center + direction * rayLength, outer, core, 5f, 1.4f, opacity);
}
}
private static void DrawReaperSilhouette(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float scale,
Color shadow,
Color rim,
float opacity)
{
opacity = MathHelper.Clamp(opacity, 0f, 1f);
if (opacity <= 0.001f || scale <= 10f)
return;
float headRadius = scale * 0.11f;
Vector2 head = center - Vector2.UnitY * scale * 0.30f;
DrawGlow(batch, head, headRadius * 2.5f, rim * (opacity * 0.13f));
DrawPolygon(batch, pixel, head, headRadius, 9, shadow * (opacity * 0.96f),
headRadius * 0.82f, -MathHelper.PiOver2, 1f);
DrawRing(batch, pixel, head, headRadius * 1.04f, 28, rim * (opacity * 0.56f), 3f, 0f, 1f);
Vector2 leftShoulder = center + new Vector2(-scale * 0.25f, -scale * 0.17f);
Vector2 rightShoulder = center + new Vector2(scale * 0.25f, -scale * 0.17f);
Vector2 hem = center + Vector2.UnitY * scale * 0.42f;
DrawLayeredLine(batch, pixel, leftShoulder, hem, shadow, rim, scale * 0.22f, 3f, opacity * 0.62f);
DrawLayeredLine(batch, pixel, rightShoulder, hem, shadow, rim, scale * 0.22f, 3f, opacity * 0.62f);
DrawLayeredLine(batch, pixel, leftShoulder, rightShoulder, shadow, rim, scale * 0.18f, 3f, opacity * 0.58f);
Vector2 staffStart = center + new Vector2(-scale * 0.30f, scale * 0.36f);
Vector2 staffEnd = center + new Vector2(scale * 0.26f, -scale * 0.48f);
DrawLayeredLine(batch, pixel, staffStart, staffEnd, shadow, rim, 15f, 3.2f, opacity * 0.82f);
DrawTaperedCrescent(batch, pixel, staffEnd + new Vector2(scale * 0.10f, scale * 0.03f),
scale * 0.25f, -2.7f, 3.5f, opacity * 0.88f, shadow, rim, Color.White, scale * 0.045f);
}
private static void DrawTombstone(
SpriteBatch batch,
Texture2D pixel,
Vector2 bottomCenter,
float width,
float height,
Color fill,
Color outline)
{
Vector2 top = bottomCenter - Vector2.UnitY * height;
Rectangle body = new(
(int)Math.Round(bottomCenter.X - width * 0.5f),
(int)Math.Round(top.Y + width * 0.26f),
Math.Max(1, (int)Math.Round(width)),
Math.Max(1, (int)Math.Round(height - width * 0.26f)));
batch.Draw(pixel, body, fill);
DrawRing(batch, pixel, new Vector2(bottomCenter.X, body.Top), width * 0.5f, 16,
fill, width * 0.48f, MathHelper.Pi, 0.5f);
DrawLayeredLine(batch, pixel, new Vector2(body.Left, body.Bottom), new Vector2(body.Right, body.Bottom),
outline, Color.White, 4f, 1f, 0.78f);
DrawLayeredLine(batch, pixel, new Vector2(body.Left, body.Top), new Vector2(body.Left, body.Bottom),
outline, Color.White, 3f, 0.8f, 0.64f);
DrawLayeredLine(batch, pixel, new Vector2(body.Right, body.Top), new Vector2(body.Right, body.Bottom),
outline, Color.White, 3f, 0.8f, 0.64f);
Vector2 crossCenter = bottomCenter - Vector2.UnitY * height * 0.48f;
DrawSegment(batch, pixel, crossCenter - Vector2.UnitY * 12f, crossCenter + Vector2.UnitY * 13f,
outline, 2.2f);
DrawSegment(batch, pixel, crossCenter - Vector2.UnitX * 8f, crossCenter + Vector2.UnitX * 8f,
outline, 2.2f);
}
private static void DrawSoulShade(
SpriteBatch batch,
Texture2D pixel,
Vector2 position,
Color color,
float opacity,
float scale,
float rotation)
{
DrawGlow(batch, position, 38f * scale, color * (0.20f * opacity));
Texture2D? texture = soulTexture?.IsLoaded == true ? soulTexture.Value : null;
if (texture is not null)
{
float textureScale = 46f / Math.Max(texture.Width, texture.Height) * scale;
batch.Draw(texture, position, null, color * (0.74f * opacity), rotation * 0.04f,
new Vector2(texture.Width, texture.Height) * 0.5f, textureScale, SpriteEffects.None, 0f);
}
else
{
DrawPolygon(batch, pixel, position, 14f * scale, 4, color * opacity, 2f,
MathHelper.PiOver4, 1f);
}
Vector2 tail = position + new Vector2((float)Math.Sin(rotation) * 7f, 20f * scale);
DrawLayeredLine(batch, pixel, position, tail, color, Color.White, 5f, 1.1f, opacity * 0.56f);
}
private static void DrawDeathRuneGlyph(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
int glyph,
float size,
Color color,
Color core,
float opacity)
{
switch (glyph)
{
case 0: // Bone cross.
DrawLayeredLine(batch, pixel, center - Vector2.UnitY * size, center + Vector2.UnitY * size,
color, core, 4f, 1.2f, opacity);
DrawLayeredLine(batch, pixel, center - Vector2.UnitX * size * 0.65f, center + Vector2.UnitX * size * 0.65f,
color, core, 4f, 1.2f, opacity);
break;
case 1: // Blood fang.
DrawLayeredLine(batch, pixel, center + new Vector2(-size, -size * 0.7f), center + new Vector2(0f, size),
color, core, 4f, 1.2f, opacity);
DrawLayeredLine(batch, pixel, center + new Vector2(size, -size * 0.7f), center + new Vector2(0f, size),
color, core, 4f, 1.2f, opacity);
break;
case 2: // Infernal triangle.
DrawRuneTriangle(batch, pixel, center, size, -MathHelper.PiOver2, core, opacity);
break;
case 3: // Frost crystal.
for (int index = 0; index < 3; index++)
{
Vector2 direction = (index * MathHelper.Pi / 3f).ToRotationVector2() * size;
DrawLayeredLine(batch, pixel, center - direction, center + direction,
color, core, 3.5f, 1f, opacity);
}
break;
case 4: // Soul diamond.
DrawPolygon(batch, pixel, center, size, 4, core * opacity, 3f, MathHelper.PiOver4, 1f);
DrawSegment(batch, pixel, center - Vector2.UnitY * size * 0.55f,
center + Vector2.UnitY * size * 0.55f, color * opacity, 2f);
break;
default: // Void severance.
DrawLayeredLine(batch, pixel, center + new Vector2(-size, size), center + new Vector2(size, -size),
color, Color.White, 5f, 1.3f, opacity);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.55f, -size), center + new Vector2(size * 0.55f, size),
color, core, 3f, 0.9f, opacity * 0.75f);
break;
}
}
private static void DrawRuneTriangle(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
float rotation,
Color color,
float opacity)
{
DrawPolygon(batch, pixel, center, radius, 3, color * opacity, 2.2f, rotation, 1f);
}
private static void DrawGlow(SpriteBatch batch, Vector2 center, float radius, Color color)
{
if (radius <= 0.5f || color.A == 0)
return;
DeathDomainPrimitiveTextureSystem.DrawRadialGradient(batch, center, radius, color);
}
private static void DrawRing(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
int segments,
Color color,
float width,
float rotation,
float reveal)
{
if (radius <= 0.5f || segments < 3 || width <= 0.05f || reveal <= 0.001f || color.A == 0)
return;
reveal = MathHelper.Clamp(reveal, 0f, 1f);
segments = Math.Max(segments,
Math.Min(192, (int)Math.Ceiling(MathHelper.TwoPi * radius / 18f)));
Vector2 previous = center + rotation.ToRotationVector2() * radius;
int visibleSegments = Math.Max(1, (int)Math.Ceiling(segments * reveal));
for (int index = 1; index <= visibleSegments; index++)
{
float amount = Math.Min(reveal, index / (float)segments);
Vector2 current = center + (rotation + MathHelper.TwoPi * amount).ToRotationVector2() * radius;
DrawSegment(batch, pixel, previous, current, color, width);
previous = current;
}
}
private static void DrawPolygon(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
int sides,
Color color,
float width,
float rotation,
float reveal)
{
if (sides < 3 || radius <= 0.5f || reveal <= 0.001f)
return;
reveal = MathHelper.Clamp(reveal, 0f, 1f);
Vector2 previous = center + rotation.ToRotationVector2() * radius;
int visibleEdges = Math.Max(1, (int)Math.Ceiling(sides * reveal));
for (int edge = 1; edge <= visibleEdges; edge++)
{
float edgeCompletion = Math.Min(1f, sides * reveal - (edge - 1));
Vector2 target = center + (rotation + MathHelper.TwoPi * edge / sides).ToRotationVector2() * radius;
Vector2 current = Vector2.Lerp(previous, target, edgeCompletion);
DrawSegment(batch, pixel, previous, current, color, width);
previous = target;
}
}
private static void DrawJaggedLine(
SpriteBatch batch,
Texture2D pixel,
Vector2 start,
Vector2 end,
float reveal,
Color outerColor,
Color coreColor,
float outerWidth,
float coreWidth,
float amplitude,
float seed,
float opacity)
{
reveal = MathHelper.Clamp(reveal, 0f, 1f);
if (reveal <= 0.001f || opacity <= 0.001f)
return;
const int segments = 18;
float totalLength = Vector2.Distance(start, end);
int segmentCount = Math.Max(3, Math.Min(segments, (int)(totalLength / 38f) + 3));
Vector2 direction = (end - start).SafeNormalize(Vector2.UnitX);
Vector2 perpendicular = new(-direction.Y, direction.X);
Vector2 previous = JaggedPoint(start, end, perpendicular, 0f, segmentCount, amplitude, seed);
int visibleSegments = Math.Max(1, (int)Math.Ceiling(segmentCount * reveal));
for (int index = 1; index <= visibleSegments; index++)
{
float amount = Math.Min(reveal, index / (float)segmentCount);
Vector2 current = JaggedPoint(start, end, perpendicular, amount, segmentCount, amplitude, seed);
DrawLayeredLine(batch, pixel, previous, current, outerColor, coreColor,
outerWidth, coreWidth, opacity);
previous = current;
}
}
private static Vector2 JaggedPoint(
Vector2 start,
Vector2 end,
Vector2 perpendicular,
float amount,
int segments,
float amplitude,
float seed)
{
float envelope = (float)Math.Sin(amount * MathHelper.Pi);
float grain = (float)Math.Sin((amount * segments + seed) * 5.137f) * 0.67f
+ (float)Math.Sin((amount * segments + seed * 1.91f) * 11.73f) * 0.33f;
return Vector2.Lerp(start, end, amount) + perpendicular * (grain * amplitude * envelope);
}
private static void DrawLayeredLine(
SpriteBatch batch,
Texture2D pixel,
Vector2 start,
Vector2 end,
Color outerColor,
Color coreColor,
float outerWidth,
float coreWidth,
float opacity)
{
if (opacity <= 0.001f)
return;
DrawSegment(batch, pixel, start, end, outerColor * (opacity * 0.72f), outerWidth);
DrawSegment(batch, pixel, start, end, coreColor * opacity, coreWidth);
}
private static void DrawSegment(
SpriteBatch batch,
Texture2D pixel,
Vector2 start,
Vector2 end,
Color color,
float width)
{
DeathDomainPrimitiveTextureSystem.DrawSmoothLine(batch, start, end, color, width);
}
private static float GetStateOpacity(in UltimateVisualState state)
{
float progress = MathHelper.Clamp(state.Timer / (float)Math.Max(1, state.Duration), 0f, 1f);
float introduction = MathHelper.Lerp(0.35f, 1f, Ease(progress / 0.06f));
float tail = 1f - MathHelper.Clamp(state.FramesSinceReport / (float)TailFrames, 0f, 1f);
return introduction * Ease(tail);
}
private static float GetBackdropDarkness(in UltimateVisualState state)
{
if (state.Form == ReaperFormId.Death)
{
float cutProgress = MathHelper.Clamp(
(state.Timer - ReaperDeathUltimateGeometry.FirstCutTick)
/ (float)(ReaperDeathUltimateGeometry.ShatterTick
- ReaperDeathUltimateGeometry.FirstCutTick), 0f, 1f);
return MathHelper.Lerp(0.30f, 0.985f, Ease(cutProgress));
}
return state.Form switch
{
ReaperFormId.Bone => 0.36f,
ReaperFormId.Blood => 0.42f,
ReaperFormId.Infernal => 0.38f,
ReaperFormId.Frost => 0.31f,
ReaperFormId.Soul => 0.37f,
ReaperFormId.Void => 0.52f,
_ => 0f
};
}
private static float Reveal(float progress, float start, float end)
{
if (end <= start)
return progress >= end ? 1f : 0f;
return Ease((progress - start) / (end - start));
}
private static float Envelope(float progress, float start, float riseEnd, float fallStart, float end)
{
if (progress < start || progress > end)
return 0f;
if (progress < riseEnd)
return Reveal(progress, start, riseEnd);
if (progress <= fallStart)
return 1f;
return 1f - Reveal(progress, fallStart, end);
}
private static float Pulse(float progress, float center, float halfWidth)
{
if (halfWidth <= 0f)
return 0f;
return Ease(1f - Math.Abs(progress - center) / halfWidth);
}
private static float Ease(float value)
{
value = MathHelper.Clamp(value, 0f, 1f);
return value * value * (3f - 2f * value);
}
private static float PositiveModulo(float value, float modulus)
{
float result = value % modulus;
return result < 0f ? result + modulus : result;
}
private static void EnsureStateStorage()
{
if (states.Length != Main.maxPlayers)
states = new UltimateVisualState[Main.maxPlayers];
}
private static void ClearStates()
{
if (states.Length > 0)
Array.Clear(states, 0, states.Length);
}
private struct UltimateVisualState
{
public bool Active;
public ReaperFormId Form;
public int ActionId;
public Vector2 OriginWorld;
public Vector2 FocusWorld;
public Vector2 Aim;
public int Timer;
public int Duration;
public int FramesSinceReport;
public ulong LastReportTick;
}
}
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using ReLogic.Content;
using System;
using System.Collections.Generic;
using Terraria;
using Terraria.GameContent;
using Terraria.ModLoader;
using Terraria.UI;
namespace SoulHarvest.Common;
/// <summary>
/// Client-only presentation for Reaper ultimates. Combat code reports the authoritative
/// visual clock each tick; this system owns only short-lived draw state and asks the
/// shared VFX director for capped camera/flash punctuation. It never creates attacks.
/// </summary>
[Autoload(Side = ModSide.Client)]
public sealed class ReaperUltimateVisualSystem : ModSystem
{
private const int TailFrames = 18;
private const int CrescentMaskSize = 512;
private const float CrescentReferenceRadius = 180f;
private static UltimateVisualState[] states = [];
private static Asset<Texture2D>? soulTexture;
private static ReaperUltimateCrescentMaskSet[] crescentMasks = [];
private static readonly float[] deathMirrorAngles =
new float[ReaperDeathUltimateGeometry.CutCount * 2];
private static readonly VertexPositionColorTexture[] deathMirrorVertices =
new VertexPositionColorTexture[ReaperDeathUltimateGeometry.CutCount * 6];
private static BasicEffect? deathMirrorEffect;
/// <summary>
/// Reports one frame of an active ultimate. This method is safe to call from
/// projectile AI on every net mode: dedicated servers immediately return.
/// </summary>
public static void ReportUltimate(Player owner, ReaperFormId form, Vector2 aim,
Vector2 focusWorld, int actionId, int timer, int duration)
{
if (Main.dedServ
|| Main.gameMenu
|| owner is null
|| !owner.active
|| owner.dead
|| owner.whoAmI < 0
|| owner.whoAmI >= Main.maxPlayers
|| form == ReaperFormId.Base
|| (byte)form > (byte)ReaperFormId.Death)
{
return;
}
EnsureStateStorage();
Vector2 fallback = Vector2.UnitX * (owner.direction == 0 ? 1 : owner.direction);
if (!float.IsFinite(aim.X) || !float.IsFinite(aim.Y) || aim.LengthSquared() < 0.0001f)
aim = fallback;
else
aim.Normalize();
if (!float.IsFinite(focusWorld.X) || !float.IsFinite(focusWorld.Y))
focusWorld = owner.MountedCenter + aim * 180f;
duration = Math.Clamp(duration, 1, 3600);
timer = Math.Clamp(timer, 0, duration);
ref UltimateVisualState state = ref states[owner.whoAmI];
bool restarted = !state.Active || state.Form != form || state.ActionId != actionId;
// A remote controller can first replicate halfway through its action.
// Floor a newly observed storyboard at that authoritative frame so all
// earlier impacts are not replayed at once. Tick-one openings still cross
// normally for actions observed from their actual start.
int previousTimer = restarted
? (timer <= 1 ? timer - 1 : timer)
: state.Timer;
if (!restarted)
{
// Extra-AI packets can arrive after the local controller has already
// advanced. Never rewind a storyboard for the same authoritative
// action, otherwise old packets replay white flashes, sounds and shake.
int monotonicFloor = state.LastReportTick < Main.GameUpdateCount
? Math.Min(duration, state.Timer + 1)
: state.Timer;
timer = Math.Max(timer, monotonicFloor);
}
state.Active = true;
state.Form = form;
state.ActionId = actionId;
state.OriginWorld = owner.MountedCenter;
state.FocusWorld = focusWorld;
state.Aim = aim;
state.Timer = timer;
state.Duration = duration;
state.FramesSinceReport = 0;
state.LastReportTick = Main.GameUpdateCount;
float normalizedTime = state.Timer / (float)Math.Max(1, state.Duration);
ReaperVfxDirector.ReportCinematicCamera(owner.whoAmI, state.ActionId,
normalizedTime, aim, form == ReaperFormId.Death ? 1f : 0.84f);
TriggerTimelineImpacts(form, aim, previousTimer, state.Timer);
}
public override void Load()
{
EnsureStateStorage();
soulTexture = ModContent.Request<Texture2D>("SoulHarvest/Items/Soul", AssetRequestMode.ImmediateLoad);
}
public override void Unload()
{
states = [];
soulTexture = null;
// Content hooks may run on a loader worker. Detach immediately so no
// future draw can observe these resources, then dispose them on FNA's
// graphics thread just like the other procedural texture systems.
ReaperUltimateCrescentMaskSet[] oldMasks = crescentMasks;
crescentMasks = [];
BasicEffect? oldMirrorEffect = deathMirrorEffect;
deathMirrorEffect = null;
if (!Main.dedServ && oldMasks.Length > 0)
Main.QueueMainThreadAction(() => DisposeCrescentMasks(oldMasks));
if (!Main.dedServ && oldMirrorEffect is not null)
Main.QueueMainThreadAction(oldMirrorEffect.Dispose);
}
public override void OnWorldUnload()
{
ClearStates();
}
public override void PostUpdateEverything()
{
if (Main.gameMenu)
{
ClearStates();
return;
}
EnsureStateStorage();
for (int index = 0; index < states.Length; index++)
{
ref UltimateVisualState state = ref states[index];
if (!state.Active)
continue;
Player owner = Main.player[index];
if (!owner.active || owner.dead || state.LastReportTick > Main.GameUpdateCount)
{
state = default;
continue;
}
if (state.LastReportTick == Main.GameUpdateCount)
{
state.FramesSinceReport = 0;
continue;
}
state.FramesSinceReport++;
if (state.FramesSinceReport > TailFrames)
state = default;
}
}
public override void ModifyInterfaceLayers(List<GameInterfaceLayer> layers)
{
int index = layers.FindIndex(layer => layer.Name == "Vanilla: Resource Bars");
if (index < 0)
index = layers.FindIndex(layer => layer.Name == "Vanilla: Mouse Text");
if (index < 0)
index = layers.Count;
layers.Insert(index, new LegacyGameInterfaceLayer(
"SoulHarvest: Reaper Ultimate Spectacle",
DrawUltimateLayer,
InterfaceScaleType.None));
}
private static bool DrawUltimateLayer()
{
if (Main.gameMenu || states.Length == 0)
return true;
Player localPlayer = Main.LocalPlayer;
if (!localPlayer.active)
return true;
// This layer renders in physical screen space. Applying UI scale here
// confined the composition to the upper-left on high-DPI displays.
const float uiScale = 1f;
Vector2 viewport = new(Main.screenWidth, Main.screenHeight);
Rectangle viewportBounds = new(0, 0,
Math.Max(1, (int)Math.Ceiling(viewport.X)),
Math.Max(1, (int)Math.Ceiling(viewport.Y)));
Texture2D pixel = TextureAssets.MagicPixel.Value;
SpriteBatch batch = Main.spriteBatch;
float strongestDarkness = 0f;
for (int index = 0; index < states.Length; index++)
{
ref UltimateVisualState state = ref states[index];
if (!IsVisible(index, in state, viewport, uiScale))
continue;
strongestDarkness = Math.Max(strongestDarkness,
GetBackdropDarkness(in state) * GetStateOpacity(in state));
}
if (strongestDarkness <= 0.001f)
return true;
// Interface drawing always runs on the graphics thread. Creating the
// procedural masks lazily here avoids allocating Texture2D instances
// from a content-loader worker and keeps dedicated servers texture-free.
EnsureCrescentMasks();
batch.Draw(pixel, viewportBounds, Color.Black * strongestDarkness);
for (int index = 0; index < states.Length; index++)
{
ref UltimateVisualState state = ref states[index];
if (!IsVisible(index, in state, viewport, uiScale))
continue;
DrawState(batch, pixel, index, in state, viewport, viewportBounds, uiScale);
}
return true;
}
private static bool IsVisible(int playerIndex, in UltimateVisualState state, Vector2 viewport, float uiScale)
{
if (!state.Active || playerIndex < 0 || playerIndex >= Main.maxPlayers)
return false;
Player owner = Main.player[playerIndex];
if (!owner.active || owner.dead)
return false;
// Every client which has the authoritative action projectile renders the full
// storyboard. Off-screen owners are re-framed in DrawState instead of receiving
// the old reduced/culled presentation.
return true;
}
private static void DrawState(
SpriteBatch batch,
Texture2D pixel,
int ownerIndex,
in UltimateVisualState state,
Vector2 viewport,
Rectangle viewportBounds,
float uiScale)
{
float progress = MathHelper.Clamp(state.Timer / (float)Math.Max(1, state.Duration), 0f, 1f);
float opacity = GetStateOpacity(in state);
if (opacity <= 0.001f)
return;
Vector2 origin = state.OriginWorld - Main.screenPosition;
const float presentationMargin = 120f;
if (origin.X < -presentationMargin || origin.X > viewport.X + presentationMargin
|| origin.Y < -presentationMargin || origin.Y > viewport.Y + presentationMargin)
{
origin = viewport * 0.5f - state.Aim * 180f;
}
Vector2 focus = state.FocusWorld - Main.screenPosition;
if (state.Form != ReaperFormId.Death
&& (focus.X < -presentationMargin
|| focus.X > viewport.X + presentationMargin
|| focus.Y < -presentationMargin
|| focus.Y > viewport.Y + presentationMargin))
{
focus = viewport * 0.5f;
}
Color primary = ReaperCombatRegistry.GetPrimaryColor(state.Form);
Color secondary = ReaperCombatRegistry.GetSecondaryColor(state.Form);
float time = Main.GlobalTimeWrappedHourly;
batch.Draw(pixel, viewportBounds, primary * (0.028f * opacity));
DrawGlow(batch, focus, Math.Min(viewport.X, viewport.Y) * 0.33f,
primary * (0.105f * opacity));
DrawCinematicFrame(batch, pixel, viewport, progress, opacity, primary, secondary);
switch (state.Form)
{
case ReaperFormId.Bone:
DrawBone(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Blood:
DrawBlood(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Infernal:
DrawInfernal(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Frost:
DrawFrost(batch, pixel, focus, viewport, viewportBounds, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Soul:
DrawSoul(batch, pixel, focus, viewport, progress, opacity, time, primary, secondary);
break;
case ReaperFormId.Void:
DrawVoid(batch, pixel, focus, viewport, viewportBounds, progress, opacity,
time, primary, secondary, state.Aim, state.ActionId);
break;
case ReaperFormId.Death:
DrawDeath(batch, pixel, ownerIndex, in state, focus, viewport,
viewportBounds, progress, opacity, time);
break;
}
}
private static void TriggerTimelineImpacts(
ReaperFormId form,
Vector2 direction,
int previousTimer,
int currentTimer)
{
if (currentTimer <= previousTimer)
return;
Color primary = ReaperCombatRegistry.GetPrimaryColor(form);
Color secondary = ReaperCombatRegistry.GetSecondaryColor(form);
switch (form)
{
case ReaperFormId.Bone:
TriggerImpactAt(30, previousTimer, currentTimer, direction, 3.4f, primary, 0.10f);
TriggerImpactAt(66, previousTimer, currentTimer, -direction, 4.0f, primary, 0.12f);
TriggerImpactAt(102, previousTimer, currentTimer, direction.RotatedBy(0.8f), 4.8f, secondary, 0.15f);
TriggerImpactAt(138, previousTimer, currentTimer, direction.RotatedBy(-0.8f), 5.6f, secondary, 0.18f);
TriggerImpactAt(168, previousTimer, currentTimer, Vector2.UnitY, 7.8f, secondary, 0.34f);
TriggerImpactAt(207, previousTimer, currentTimer, direction, 11.5f, Color.White, 0.68f);
break;
case ReaperFormId.Blood:
TriggerImpactAt(18, previousTimer, currentTimer, Vector2.UnitY,
4.2f, new Color(170, 0, 34), 0.16f);
foreach (int tick in new[] { 48, 78, 108, 138 })
TriggerImpactAt(tick, previousTimer, currentTimer,
direction.RotatedBy(tick * 0.017f), 4.5f,
tick % 2 == 0 ? primary : secondary, 0.13f);
TriggerImpactAt(166, previousTimer, currentTimer, direction,
12f, new Color(255, 238, 228), 0.75f);
break;
case ReaperFormId.Infernal:
for (int index = 0; index < 5; index++)
TriggerImpactAt(20 + index * 20, previousTimer, currentTimer,
direction.RotatedBy(index * MathHelper.TwoPi / 5f), 4.8f + index * 0.3f,
index % 2 == 0 ? primary : secondary, 0.16f);
TriggerImpactAt(130, previousTimer, currentTimer, direction, 8f, secondary, 0.36f);
TriggerImpactAt(190, previousTimer, currentTimer, Vector2.UnitY, 12f, Color.White, 0.72f);
break;
case ReaperFormId.Frost:
TriggerImpactAt(1, previousTimer, currentTimer, Vector2.UnitY, 2.6f, new Color(180, 230, 255), 0.12f);
for (int index = 0; index < 4; index++)
TriggerImpactAt(30 + index * 18, previousTimer, currentTimer,
direction.RotatedBy(index * MathHelper.PiOver2), 4.2f + index * 0.35f,
index % 2 == 0 ? primary : secondary, 0.17f);
TriggerImpactAt(100, previousTimer, currentTimer, direction.RotatedBy(-0.5f), 8.4f, secondary, 0.43f);
TriggerImpactAt(110, previousTimer, currentTimer, direction.RotatedBy(0.5f), 11.2f, Color.White, 0.76f);
break;
case ReaperFormId.Soul:
TriggerImpactAt(20, previousTimer, currentTimer, Vector2.UnitY, 3.3f, primary, 0.13f);
for (int index = 0; index < 8; index++)
TriggerImpactAt(32 + index * 8, previousTimer, currentTimer,
direction.RotatedBy(index * MathHelper.PiOver4), 3.4f + index * 0.22f,
index % 2 == 0 ? primary : secondary, 0.11f);
TriggerImpactAt(104, previousTimer, currentTimer, direction, 11f, Color.White, 0.66f);
break;
case ReaperFormId.Void:
TriggerImpactAt(32, previousTimer, currentTimer, direction, 11f, Color.White, 0.66f);
break;
case ReaperFormId.Death:
for (int index = 0; index < ReaperDeathUltimateGeometry.CutCount; index++)
TriggerImpactAt(ReaperDeathUltimateGeometry.GetCutTick(index),
previousTimer, currentTimer,
direction.RotatedBy(index * 2.39996f), 4.6f + index * 0.08f,
new Color(225, 25, 66), 0.14f);
TriggerImpactAt(ReaperDeathUltimateGeometry.ShatterTick,
previousTimer, currentTimer, direction,
12f, new Color(190, 14, 48), 0.14f);
break;
}
}
private static void TriggerImpactAt(
int eventTick,
int previousTimer,
int currentTimer,
Vector2 direction,
float strength,
Color color,
float opacity)
{
if (previousTimer >= eventTick || currentTimer < eventTick)
return;
int frames = strength >= 10f ? 14 : strength >= 7f ? 10 : 7;
ReaperVfxDirector.TriggerGlobalImpact(direction, strength, frames, color, opacity,
strength >= 10f ? 7 : 4, strength >= 10f ? 0.50f : 0.24f);
}
private static void DrawCinematicFrame(
SpriteBatch batch,
Texture2D pixel,
Vector2 viewport,
float progress,
float opacity,
Color primary,
Color secondary)
{
float ritual = Envelope(progress, 0f, 0.07f, 0.94f, 1f) * opacity;
int barHeight = Math.Max(8, (int)Math.Round(viewport.Y * 0.035f));
batch.Draw(pixel, new Rectangle(0, 0, (int)Math.Ceiling(viewport.X), barHeight),
Color.Black * (ritual * 0.76f));
batch.Draw(pixel, new Rectangle(0, Math.Max(0, (int)Math.Floor(viewport.Y) - barHeight),
(int)Math.Ceiling(viewport.X), barHeight), Color.Black * (ritual * 0.76f));
// Deliberately omit ornamental corner brackets. The restrained full-width
// letterbox reads as one cinematic composition and cannot resemble a
// misplaced child viewport.
// Final impacts are expressed by world geometry, sound and camera
// response. A full-viewport white heartbeat obscured those details and
// became a one-frame white screen when several attacks overlapped.
}
private static void DrawBone(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float graveWidth = MathHelper.Clamp(viewport.X / 11f, 48f, 76f);
for (int index = 0; index < 8; index++)
{
float reveal = Reveal(progress, 0.05f + index * 0.052f, 0.18f + index * 0.052f) * opacity;
if (reveal <= 0.001f)
continue;
float horizontal = (index - 3.5f) * graveWidth;
float restingY = focus.Y + 112f + Math.Abs(index - 3.5f) * 8f;
Vector2 position = new(focus.X + horizontal, restingY + (1f - Ease(reveal / Math.Max(opacity, 0.001f))) * 54f);
float pulse = 0.82f + (float)Math.Sin(time * 2.7f + index * 1.3f) * 0.12f;
DrawTombstone(batch, pixel, position, 36f, 56f,
new Color(7, 20, 27) * (0.90f * reveal),
Color.Lerp(primary, secondary, 0.38f) * (pulse * reveal));
}
float frameReveal = Reveal(progress, 0.58f, 0.78f) * opacity;
if (frameReveal > 0.001f)
{
float halfWidth = MathHelper.Clamp(viewport.X * 0.16f, 150f, 260f);
float height = MathHelper.Clamp(viewport.Y * 0.46f, 260f, 430f);
Vector2 topLeft = focus + new Vector2(-halfWidth, -height * 0.63f);
Vector2 topRight = focus + new Vector2(halfWidth, -height * 0.63f);
Vector2 bottomLeft = topLeft + Vector2.UnitY * height;
Vector2 bottomRight = topRight + Vector2.UnitY * height;
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, primary, secondary, 10f, 2.4f, frameReveal * 0.62f);
DrawLayeredLine(batch, pixel, topRight, bottomRight, primary, secondary, 10f, 2.4f, frameReveal * 0.62f);
DrawLayeredLine(batch, pixel, topLeft, topRight, primary, secondary, 12f, 2.8f, frameReveal * 0.78f);
float bladeReveal = Reveal(progress, 0.75f, 0.94f);
Vector2 bladeStart = topRight + new Vector2(-20f, 30f);
Vector2 bladeEnd = bottomLeft + new Vector2(38f, -24f);
DrawJaggedLine(batch, pixel, bladeStart, bladeEnd, bladeReveal,
primary, Color.White, 22f, 5.2f, 3.5f, 7.8f, opacity);
Vector2 parallel = (bladeEnd - bladeStart).SafeNormalize(Vector2.UnitY).RotatedBy(MathHelper.PiOver2) * 22f;
DrawJaggedLine(batch, pixel, bladeStart + parallel, bladeEnd + parallel, bladeReveal,
new Color(25, 100, 120), secondary, 12f, 2.5f, 2.4f, 11.2f, opacity * 0.78f);
float impact = Pulse(progress, 0.965f, 0.07f) * opacity;
DrawGlow(batch, bladeEnd, 125f, secondary * (0.30f * impact));
DrawRing(batch, pixel, bladeEnd, MathHelper.Lerp(18f, 128f, Ease(impact)), 36,
secondary * (impact * 0.9f), 3f, 0f, 1f);
}
float burial = Envelope(progress, 0.18f, 0.30f, 0.72f, 0.88f) * opacity;
if (burial > 0.001f)
{
float cageRadius = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.21f, 130f, 235f);
for (int side = -1; side <= 1; side += 2)
{
for (int rib = 0; rib < 6; rib++)
{
float y = MathHelper.Lerp(-cageRadius * 0.68f, cageRadius * 0.65f, rib / 5f);
float width = cageRadius * (0.92f - Math.Abs(rib - 2.5f) * 0.09f);
Vector2 spine = focus + new Vector2(side * cageRadius * 0.88f, y);
Vector2 sternum = focus + new Vector2(side * width * 0.12f, y + 13f);
Vector2 elbow = Vector2.Lerp(spine, sternum, 0.52f) + new Vector2(side * 24f, -20f);
DrawLayeredLine(batch, pixel, spine, elbow, new Color(20, 95, 112), secondary,
9f, 2.3f, burial * 0.48f);
DrawLayeredLine(batch, pixel, elbow, sternum, primary, Color.White,
7f, 1.8f, burial * 0.58f);
}
}
}
float judge = Envelope(progress, 0.70f, 0.80f, 0.975f, 1f) * opacity;
if (judge > 0.001f)
{
Vector2 judgeCenter = focus - Vector2.UnitY * MathHelper.Clamp(viewport.Y * 0.21f, 120f, 210f);
float skullRadius = MathHelper.Clamp(viewport.Y * 0.095f, 52f, 94f);
DrawGlow(batch, judgeCenter, skullRadius * 2.4f, primary * (judge * 0.16f));
DrawPolygon(batch, pixel, judgeCenter, skullRadius, 8, new Color(8, 25, 30) * (judge * 0.94f),
skullRadius * 0.75f, -MathHelper.PiOver2, 1f);
DrawRing(batch, pixel, judgeCenter, skullRadius, 30, secondary * (judge * 0.84f), 4f, 0f, 1f);
Vector2 eyeOffset = new(skullRadius * 0.33f, -skullRadius * 0.08f);
DrawGlow(batch, judgeCenter - eyeOffset, skullRadius * 0.34f, primary * (judge * 0.72f));
DrawGlow(batch, judgeCenter + new Vector2(eyeOffset.X, eyeOffset.Y), skullRadius * 0.34f,
primary * (judge * 0.72f));
for (int tooth = -3; tooth <= 3; tooth++)
{
Vector2 root = judgeCenter + new Vector2(tooth * skullRadius * 0.16f, skullRadius * 0.62f);
DrawLayeredLine(batch, pixel, root, root + Vector2.UnitY * skullRadius * 0.34f,
primary, Color.White, 5f, 1.3f, judge * 0.72f);
}
}
}
private static void DrawBlood(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
// The shared Blood blade projectiles draw their own exact flight paths and
// persistent wounds. This layer supplies only restrained atmosphere so it
// cannot invent a second set of fake, screen-space projectiles or scars.
float opening = Reveal(progress, 0.01f, 0.10f) * opacity;
float pulse = 0.82f + (float)Math.Sin(time * 3.4f) * 0.10f;
DrawGlow(batch, focus, MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.31f,
170f, 340f), new Color(122, 0, 24) * (opening * pulse * 0.28f));
float closing = Envelope(progress, 0.76f, 0.84f, 0.97f, 1f) * opacity;
DrawGlow(batch, focus, 240f,
new Color(238, 22, 52) * (closing * 0.24f));
}
private static void DrawBloodLegacy(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float opening = Reveal(progress, 0.01f, 0.10f) * opacity;
DrawGlow(batch, focus, MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.28f,
150f, 310f), new Color(122, 0, 24) * (opening * 0.26f));
// Six projectiles are rendered in the world. The overlay only reinforces
// their curved approach paths and preserves the wounds they cut, keeping
// the composition readable instead of replacing them with six crescents.
float flightFade = 1f - MathHelper.SmoothStep(0f, 1f,
MathHelper.Clamp((progress - 0.72f) / 0.12f, 0f, 1f));
float orbit = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.31f, 190f, 360f);
for (int index = 0; index < 6; index++)
{
float phase = progress * 5.8f + index / 6f;
float angle = index * MathHelper.TwoPi / 6f + phase * MathHelper.TwoPi;
Vector2 tangent = angle.ToRotationVector2();
Vector2 head = focus + tangent * orbit * (0.72f + (float)Math.Sin(phase * 4f) * 0.12f);
Vector2 tail = focus + (angle - 0.54f).ToRotationVector2() * orbit * 0.92f;
DrawLayeredLine(batch, pixel, tail, head, new Color(238, 20, 54),
new Color(8, 0, 3), 20f, 8f, opening * flightFade * 0.68f);
DrawTaperedCrescent(batch, pixel, head, 34f, angle - 2.5f, 4.0f,
opening * flightFade * 0.74f, new Color(58, 0, 14),
new Color(225, 18, 50), new Color(255, 214, 205), 9f);
float scarReveal = Reveal(progress, 0.16f + index * 0.035f,
0.28f + index * 0.035f) * opacity;
float scarAngle = -0.78f + index * 0.31f;
Vector2 scarAxis = scarAngle.ToRotationVector2();
Vector2 scarCenter = focus + (index - 2.5f) * 20f * Vector2.UnitY;
DrawLayeredLine(batch, pixel, scarCenter - scarAxis * orbit * 0.58f,
scarCenter + scarAxis * orbit * 0.58f,
new Color(245, 18, 52), new Color(5, 0, 2),
15f, 8f, scarReveal * flightFade * 0.56f);
}
float finalSlash = Envelope(progress, 0.76f, 0.82f, 0.96f, 1f) * opacity;
if (finalSlash > 0.001f)
{
Vector2 direction = new Vector2(1f, -0.20f).SafeNormalize(Vector2.UnitX);
float reach = (float)Math.Sqrt(viewport.X * viewport.X + viewport.Y * viewport.Y) * 0.72f;
Vector2 start = focus - direction * reach;
Vector2 end = focus + direction * reach;
DrawLayeredLine(batch, pixel, start, end,
new Color(255, 24, 58), new Color(4, 0, 2),
MathHelper.Lerp(18f, 82f, finalSlash),
MathHelper.Lerp(8f, 49f, finalSlash), finalSlash);
DrawGlow(batch, focus, 220f,
new Color(238, 22, 52) * (finalSlash * 0.22f));
}
}
private static void DrawInfernal(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float radius = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.23f, 145f, 265f);
float rotation = -MathHelper.PiOver2 + time * 0.055f;
float circleReveal = Reveal(progress, 0.015f, 0.22f);
DrawRing(batch, pixel, focus, radius * 1.08f, 64, primary * (0.82f * opacity), 4f,
rotation, circleReveal);
DrawRing(batch, pixel, focus, radius * 0.94f, 54, secondary * (0.48f * opacity), 1.8f,
-rotation * 0.7f, circleReveal);
Span<Vector2> vertices = stackalloc Vector2[5];
for (int index = 0; index < vertices.Length; index++)
vertices[index] = focus + (rotation + index * MathHelper.TwoPi / 5f).ToRotationVector2() * radius;
for (int edge = 0; edge < 5; edge++)
{
int startIndex = edge * 2 % 5;
int endIndex = (edge + 1) * 2 % 5;
float reveal = Reveal(progress, 0.08f + edge * 0.085f, 0.24f + edge * 0.085f);
DrawLayeredLine(batch, pixel, vertices[startIndex],
Vector2.Lerp(vertices[startIndex], vertices[endIndex], reveal),
new Color(185, 38, 5), secondary, 13f, 3f, opacity * reveal);
if (reveal > 0.02f)
{
Vector2 flame = vertices[startIndex] + Vector2.UnitY * (10f + (float)Math.Sin(time * 7f + edge) * 5f);
DrawGlow(batch, flame, 38f, primary * (0.25f * opacity * reveal));
DrawRuneTriangle(batch, pixel, vertices[startIndex], 20f, rotation + edge, secondary,
opacity * reveal);
}
}
float ignition = Reveal(progress, 0.62f, 0.82f) * opacity;
for (int index = 0; index < 5; index++)
{
Vector2 direction = (vertices[index] - focus).SafeNormalize(Vector2.UnitY);
Vector2 flameTip = vertices[index] + direction * MathHelper.Lerp(10f, 86f, ignition);
DrawJaggedLine(batch, pixel, vertices[index], flameTip, ignition,
primary, secondary, 9f, 2.2f, 5f, 130f + index * 13f, opacity);
}
float detonation = Pulse(progress, 0.94f, 0.10f) * opacity;
DrawGlow(batch, focus, radius * 1.2f, secondary * (0.25f * detonation));
DrawRing(batch, pixel, focus, MathHelper.Lerp(radius * 0.18f, radius * 1.35f, Ease(detonation)), 72,
Color.White * (0.78f * detonation), 4.5f, rotation, 1f);
float gate = Envelope(progress, 0.58f, 0.72f, 0.98f, 1f) * opacity;
if (gate > 0.001f)
{
float gateWidth = MathHelper.Clamp(viewport.X * 0.24f, 210f, 420f);
float gateHeight = MathHelper.Clamp(viewport.Y * 0.56f, 310f, 590f);
Vector2 topLeft = focus + new Vector2(-gateWidth * 0.5f, -gateHeight * 0.62f);
Vector2 topRight = focus + new Vector2(gateWidth * 0.5f, -gateHeight * 0.62f);
Vector2 bottomLeft = topLeft + Vector2.UnitY * gateHeight;
Vector2 bottomRight = topRight + Vector2.UnitY * gateHeight;
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, new Color(42, 8, 3), primary, 24f, 4f, gate * 0.74f);
DrawLayeredLine(batch, pixel, topRight, bottomRight, new Color(42, 8, 3), primary, 24f, 4f, gate * 0.74f);
DrawTaperedCrescent(batch, pixel, focus - Vector2.UnitY * gateHeight * 0.50f, gateWidth * 0.52f,
MathHelper.Pi, MathHelper.Pi, gate * 0.72f, new Color(30, 4, 0),
new Color(220, 52, 4), secondary, gateWidth * 0.13f);
for (int ember = 0; ember < 9; ember++)
{
float along = ember / 8f;
Vector2 emberPosition = Vector2.Lerp(bottomLeft, bottomRight, along)
- Vector2.UnitY * (22f + (float)Math.Sin(time * 7f + ember) * 18f);
DrawGlow(batch, emberPosition, 28f + ember % 3 * 7f, primary * (gate * 0.24f));
}
}
float execution = Envelope(progress, 0.84f, 0.91f, 0.99f, 1f) * opacity;
if (execution > 0.001f)
{
DrawReaperSilhouette(batch, pixel, focus - Vector2.UnitY * radius * 0.50f,
radius * 1.45f, new Color(18, 3, 0), primary, execution * 0.78f);
DrawTaperedCrescent(batch, pixel, focus, radius * 1.78f, -2.7f, 4.55f, execution,
new Color(58, 7, 0), new Color(255, 75, 5), Color.White, radius * 0.28f);
}
}
private static void DrawFrost(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
Rectangle viewportBounds,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
// A cool gray veil mutes the world without changing Terraria's shared shader state.
batch.Draw(pixel, viewportBounds, new Color(102, 128, 148) * (0.12f * opacity));
float reach = Math.Max(viewport.X, viewport.Y) * 0.68f;
for (int index = 0; index < 4; index++)
{
float reveal = Reveal(progress, 0.16f + index * 0.085f, 0.34f + index * 0.085f);
Vector2 direction = (-MathHelper.PiOver2 + index * MathHelper.PiOver2).ToRotationVector2();
Vector2 end = focus + direction * reach;
DrawJaggedLine(batch, pixel, focus, end, reveal,
new Color(38, 105, 155), secondary, 15f, 3.1f, 17f, 208f + index * 19f, opacity);
for (int branch = 0; branch < 3; branch++)
{
float branchProgress = 0.29f + branch * 0.19f;
if (reveal <= branchProgress)
continue;
Vector2 branchOrigin = Vector2.Lerp(focus, end, branchProgress);
float side = (branch + index) % 2 == 0 ? -1f : 1f;
Vector2 branchDirection = direction.RotatedBy(side * (0.42f + branch * 0.12f));
float branchReveal = MathHelper.Clamp((reveal - branchProgress) / 0.25f, 0f, 1f);
DrawJaggedLine(batch, pixel, branchOrigin,
branchOrigin + branchDirection * (58f + branch * 24f), branchReveal,
primary, Color.White, 7f, 1.6f, 7f, 260f + index * 31f + branch * 7f, opacity * 0.82f);
}
}
float crossReveal = Reveal(progress, 0.76f, 0.93f);
float diagonalReach = Math.Max(viewport.X, viewport.Y) * 0.72f;
for (int index = 0; index < 4; index++)
{
Vector2 direction = (MathHelper.PiOver4 + index * MathHelper.PiOver2).ToRotationVector2();
DrawJaggedLine(batch, pixel, focus, focus + direction * diagonalReach, crossReveal,
primary, Color.White, 24f, 5f, 8f, 330f + index * 17f, opacity);
}
DrawGlow(batch, focus, 180f + (float)Math.Sin(time * 3f) * 12f,
secondary * (Pulse(progress, 0.90f, 0.13f) * 0.26f * opacity));
float mirrors = Envelope(progress, 0.10f, 0.24f, 0.84f, 0.96f) * opacity;
float mirrorOrbit = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.27f, 170f, 300f);
for (int index = 0; index < 4; index++)
{
float angle = MathHelper.PiOver4 + index * MathHelper.PiOver2;
Vector2 center = focus + angle.ToRotationVector2() * mirrorOrbit;
DrawPolygon(batch, pixel, center, 54f, 6, new Color(35, 100, 150) * (mirrors * 0.52f),
13f, angle, 1f);
DrawPolygon(batch, pixel, center, 47f, 6, Color.White * (mirrors * 0.72f),
2.2f, -angle, 1f);
Vector2 reflection = (focus - center).SafeNormalize(Vector2.UnitY);
DrawLayeredLine(batch, pixel, center - reflection.RotatedBy(MathHelper.PiOver2) * 25f,
center + reflection.RotatedBy(MathHelper.PiOver2) * 25f,
primary, Color.White, 8f, 1.5f, mirrors * 0.52f);
}
float shatteredScreen = Envelope(progress, 0.86f, 0.92f, 0.995f, 1f) * opacity;
if (shatteredScreen > 0.001f)
{
Vector2[] corners =
[
new Vector2(0f, 0f),
new Vector2(viewport.X, 0f),
new Vector2(viewport.X, viewport.Y),
new Vector2(0f, viewport.Y),
new Vector2(viewport.X * 0.5f, 0f),
new Vector2(viewport.X, viewport.Y * 0.5f),
new Vector2(viewport.X * 0.5f, viewport.Y),
new Vector2(0f, viewport.Y * 0.5f)
];
for (int index = 0; index < corners.Length; index++)
{
DrawJaggedLine(batch, pixel, focus, corners[index], shatteredScreen,
new Color(84, 170, 220), Color.White, 10f, 2.1f, 16f,
710f + index * 23f, opacity);
}
}
}
private static void DrawSoul(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time,
Color primary,
Color secondary)
{
float riverY = MathHelper.Clamp(focus.Y, viewport.Y * 0.26f, viewport.Y * 0.74f);
float riverReveal = Reveal(progress, 0.02f, 0.24f) * opacity;
float convergence = Reveal(progress, 0.66f, 0.93f);
for (int lane = 0; lane < 3; lane++)
{
const int segments = 34;
Vector2 previous = default;
for (int index = 0; index <= segments; index++)
{
float along = index / (float)segments;
float x = MathHelper.Lerp(-70f, viewport.X + 70f, along);
float wave = (float)Math.Sin(along * MathHelper.TwoPi * 2.2f - time * (1.15f + lane * 0.12f) + lane * 1.8f);
float y = riverY + (lane - 1) * 45f + wave * (22f + lane * 5f);
float centerWeight = 1f - MathHelper.Clamp(Math.Abs(along - 0.5f) * 2f, 0f, 1f);
y = MathHelper.Lerp(y, focus.Y, convergence * centerWeight * 0.88f);
Vector2 current = new(x, y);
if (index > 0)
{
Color laneColor = lane == 1 ? secondary : Color.Lerp(primary, secondary, lane * 0.34f);
DrawLayeredLine(batch, pixel, previous, current, primary, laneColor,
10f - lane * 1.5f, 2.1f, riverReveal * (0.56f + lane * 0.12f));
}
previous = current;
}
}
for (int index = 0; index < 12; index++)
{
float reveal = Reveal(progress, 0.07f + index * 0.022f, 0.19f + index * 0.022f) * opacity;
if (reveal <= 0.001f)
continue;
float along = PositiveModulo(time * (0.065f + index % 3 * 0.006f) + index / 12f, 1f);
int lane = index % 3;
float x = MathHelper.Lerp(-45f, viewport.X + 45f, along);
float y = riverY + (lane - 1) * 45f
+ (float)Math.Sin(along * MathHelper.TwoPi * 2.2f - time * 1.25f + lane * 1.8f) * 24f;
Vector2 riverPosition = new(x, y);
float orbitAngle = index * MathHelper.TwoPi / 12f + time * 0.75f;
Vector2 gatheredPosition = focus + orbitAngle.ToRotationVector2()
* MathHelper.Lerp(72f, 20f, Reveal(progress, 0.82f, 0.98f));
Vector2 position = Vector2.Lerp(riverPosition, gatheredPosition, convergence);
Color shadeColor = Color.Lerp(secondary, Color.White, index % 4 == 0 ? 0.34f : 0.08f);
DrawSoulShade(batch, pixel, position, shadeColor, reveal,
0.78f + (float)Math.Sin(time * 3f + index) * 0.10f, orbitAngle);
}
float burial = Reveal(progress, 0.82f, 0.98f) * opacity;
DrawRing(batch, pixel, focus, MathHelper.Lerp(210f, 26f, Ease(burial)), 56,
secondary * (0.92f * burial), 4f, -time * 0.22f, 1f);
DrawGlow(batch, focus, 150f, primary * (0.30f * burial));
float ferryman = Envelope(progress, 0.63f, 0.76f, 0.99f, 1f) * opacity;
if (ferryman > 0.001f)
{
float scale = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.42f, 260f, 480f);
DrawReaperSilhouette(batch, pixel, focus - Vector2.UnitY * scale * 0.18f,
scale, new Color(12, 5, 35), primary, ferryman * 0.72f);
DrawTaperedCrescent(batch, pixel, focus, scale * 0.92f, -2.75f, 4.72f, ferryman,
new Color(25, 10, 72), primary, new Color(170, 255, 255), scale * 0.16f);
}
float soulBloom = Pulse(progress, 0.94f, 0.08f) * opacity;
for (int petal = 0; petal < 8; petal++)
{
float angle = petal * MathHelper.PiOver4 + time * 0.08f;
Vector2 direction = angle.ToRotationVector2();
DrawLayeredLine(batch, pixel, focus + direction * 20f,
focus + direction * MathHelper.Lerp(28f, 190f, soulBloom),
primary, secondary, 11f, 2.2f, soulBloom * 0.58f);
}
}
private static void DrawVoid(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
Rectangle viewportBounds,
float progress,
float opacity,
float time,
Color primary,
Color secondary,
Vector2 aim,
int actionId)
{
// The combat projectile owns the one and only world-space rift. Keeping
// this UI layer to atmosphere prevents a second crack from following the
// camera while the authoritative tear stays in the world.
batch.Draw(pixel, viewportBounds, new Color(1, 0, 5) * (0.31f * opacity));
DrawGlow(batch, focus, 210f,
secondary * (Reveal(progress, 0.48f, 1f) * 0.24f * opacity));
}
private static void DrawDeath(
SpriteBatch batch,
Texture2D pixel,
int ownerIndex,
in UltimateVisualState state,
Vector2 focus,
Vector2 viewport,
Rectangle viewportBounds,
float progress,
float opacity,
float time)
{
float shatterStart = ReaperDeathUltimateGeometry.ShatterTick
/ (float)ReaperDeathUltimateGeometry.Duration;
float isolation = Envelope(progress, 0.58f, 0.79f,
shatterStart - 0.015f, shatterStart + 0.012f) * opacity;
Texture2D? capturedWorld = Main.screenTarget;
// Each successful cut removes more of the ordinary scene. Immediately
// before the shatter, only small windows around the caster and recorded
// victims are restored from Terraria's world render target.
if (isolation > 0.001f)
{
batch.Draw(pixel, viewportBounds,
new Color(0, 0, 1) * (isolation * 0.965f));
if (capturedWorld is not null && !capturedWorld.IsDisposed)
DrawDeathUltimateActors(batch, capturedWorld, ownerIndex,
state.ActionId, viewport, isolation);
}
float shatter = Reveal(progress, shatterStart, 0.985f) * opacity;
if (shatter > 0.001f)
{
// The actual Death Necklace plates fill the void behind the broken
// game image; no substitute gradient or black fill is used here.
DeathDomainBackdropTextureSystem.DrawScreenAlignedBackdrop(batch,
viewportBounds, shatter);
if (capturedWorld is not null && !capturedWorld.IsDisposed)
DrawDeathMirrorShards(batch, capturedWorld, focus, viewport,
state.ActionId, shatter, opacity);
}
DrawDeathUltimateCutCracks(batch, pixel, in state, focus, viewport,
shatter, opacity);
DrawGlow(batch, focus, 230f,
new Color(125, 0, 34) * ((0.12f + shatter * 0.18f) * opacity));
_ = time;
}
private static void DrawDeathUltimateActors(SpriteBatch batch,
Texture2D capturedWorld, int ownerIndex, int actionId,
Vector2 viewport, float opacity)
{
if (ownerIndex < 0 || ownerIndex >= Main.maxPlayers)
return;
Player owner = Main.player[ownerIndex];
if (owner.active && !owner.dead)
DrawCapturedActorWindow(batch, capturedWorld, owner.getRect(),
viewport, opacity, 34f);
HashSet<int> drawnRoots = [];
foreach (NPC npc in Main.ActiveNPCs)
{
int root = npc.realLife >= 0 ? npc.realLife : npc.whoAmI;
if (root < 0 || root >= Main.maxNPCs || !drawnRoots.Add(root))
continue;
NPC target = Main.npc[root];
if (!target.active
|| !target.GetGlobalNPC<ReaperCombatGlobalNPC>()
.IsTrackedByDeathUltimate(ownerIndex, actionId))
{
continue;
}
DrawCapturedActorWindow(batch, capturedWorld, target.Hitbox,
viewport, opacity, 28f);
}
}
private static void DrawCapturedActorWindow(SpriteBatch batch,
Texture2D capturedWorld, Rectangle worldBounds, Vector2 viewport,
float opacity, float padding)
{
Rectangle screenBounds = new(
(int)Math.Floor(worldBounds.X - Main.screenPosition.X - padding),
(int)Math.Floor(worldBounds.Y - Main.screenPosition.Y - padding),
Math.Max(1, (int)Math.Ceiling(worldBounds.Width + padding * 2f)),
Math.Max(1, (int)Math.Ceiling(worldBounds.Height + padding * 2f)));
Rectangle clipped = Rectangle.Intersect(screenBounds,
new Rectangle(0, 0, (int)viewport.X, (int)viewport.Y));
if (clipped.Width <= 0 || clipped.Height <= 0)
return;
const int bands = 12;
for (int band = 0; band < bands; band++)
{
float y0 = band / (float)bands;
float y1 = (band + 1f) / bands;
float normalizedY = (y0 + y1) - 1f;
float halfWidth = (float)Math.Sqrt(Math.Max(0f,
1f - normalizedY * normalizedY));
int bandTop = screenBounds.Top
+ (int)Math.Floor(screenBounds.Height * y0);
int bandBottom = screenBounds.Top
+ (int)Math.Ceiling(screenBounds.Height * y1);
int bandHalfWidth = Math.Max(1,
(int)Math.Ceiling(screenBounds.Width * 0.5f * halfWidth));
Rectangle destination = new(
screenBounds.Center.X - bandHalfWidth,
bandTop,
bandHalfWidth * 2,
Math.Max(1, bandBottom - bandTop));
destination = Rectangle.Intersect(destination, clipped);
if (destination.Width <= 0 || destination.Height <= 0)
continue;
Rectangle source = new(
(int)Math.Floor(destination.X / viewport.X * capturedWorld.Width),
(int)Math.Floor(destination.Y / viewport.Y * capturedWorld.Height),
Math.Max(1, (int)Math.Ceiling(destination.Width / viewport.X
* capturedWorld.Width)),
Math.Max(1, (int)Math.Ceiling(destination.Height / viewport.Y
* capturedWorld.Height)));
source = Rectangle.Intersect(source, capturedWorld.Bounds);
if (source.Width > 0 && source.Height > 0)
batch.Draw(capturedWorld, destination, source,
Color.White * MathHelper.Clamp(opacity, 0f, 1f));
}
}
private static void DrawDeathMirrorShards(SpriteBatch batch,
Texture2D capturedWorld, Vector2 focus, Vector2 viewport,
int actionId, float shatter, float opacity)
{
if (Main.graphics?.GraphicsDevice is not GraphicsDevice graphicsDevice)
return;
int rayCount = deathMirrorAngles.Length;
for (int cut = 0; cut < ReaperDeathUltimateGeometry.CutCount; cut++)
{
float angle = ReaperDeathUltimateGeometry.GetCutAxis(actionId, cut)
.ToRotation();
if (angle < 0f)
angle += MathHelper.TwoPi;
deathMirrorAngles[cut * 2] = angle;
deathMirrorAngles[cut * 2 + 1] = PositiveModulo(
angle + MathHelper.Pi, MathHelper.TwoPi);
}
Array.Sort(deathMirrorAngles);
float eased = Ease(shatter);
float radius = GetViewportCoverRadius(focus, viewport) * 1.08f;
Color shardColor = Color.White
* (opacity * MathHelper.Lerp(1f, 0.48f, eased));
int vertex = 0;
for (int shard = 0; shard < rayCount; shard++)
{
float startAngle = deathMirrorAngles[shard];
float endAngle = shard == rayCount - 1
? deathMirrorAngles[0] + MathHelper.TwoPi
: deathMirrorAngles[shard + 1];
float middleAngle = (startAngle + endAngle) * 0.5f;
uint hash = unchecked((uint)(actionId * 16777619
+ shard * 2246822519));
hash ^= hash >> 15;
float random = (hash & 0xFFFFu) / 65535f;
float signed = ((hash >> 16) & 1u) == 0u ? -1f : 1f;
Vector2 displacement = middleAngle.ToRotationVector2()
* ((18f + random * 48f) * eased)
+ Vector2.UnitY * (eased * eased * (8f + random * 34f));
float rotation = signed * (0.012f + random * 0.032f) * eased;
Vector2 originalCenter = focus;
Vector2 originalStart = focus
+ startAngle.ToRotationVector2() * radius;
Vector2 originalEnd = focus
+ endAngle.ToRotationVector2() * radius;
WriteMirrorVertex(ref vertex,
RotatePoint(originalCenter, focus, rotation) + displacement,
originalCenter, viewport, shardColor);
WriteMirrorVertex(ref vertex,
RotatePoint(originalStart, focus, rotation) + displacement,
originalStart, viewport, shardColor);
WriteMirrorVertex(ref vertex,
RotatePoint(originalEnd, focus, rotation) + displacement,
originalEnd, viewport, shardColor);
}
batch.End();
try
{
deathMirrorEffect ??= new BasicEffect(graphicsDevice)
{
TextureEnabled = true,
VertexColorEnabled = true,
LightingEnabled = false,
FogEnabled = false
};
deathMirrorEffect.World = Matrix.Identity;
deathMirrorEffect.View = Matrix.Identity;
deathMirrorEffect.Projection = Matrix.CreateOrthographicOffCenter(
0f, viewport.X, viewport.Y, 0f, 0f, 1f);
deathMirrorEffect.Texture = capturedWorld;
graphicsDevice.BlendState = BlendState.AlphaBlend;
graphicsDevice.DepthStencilState = DepthStencilState.None;
graphicsDevice.RasterizerState = RasterizerState.CullNone;
graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp;
foreach (EffectPass pass in deathMirrorEffect.CurrentTechnique.Passes)
{
pass.Apply();
graphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleList,
deathMirrorVertices, 0, vertex / 3);
}
}
finally
{
batch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend,
SamplerState.LinearClamp, DepthStencilState.None,
RasterizerState.CullNone, null, Matrix.Identity);
}
}
private static void WriteMirrorVertex(ref int index, Vector2 position,
Vector2 samplePosition, Vector2 viewport, Color color)
{
Vector2 uv = new(
samplePosition.X / Math.Max(1f, viewport.X),
samplePosition.Y / Math.Max(1f, viewport.Y));
deathMirrorVertices[index++] = new VertexPositionColorTexture(
new Vector3(position, 0f), color, uv);
}
private static Vector2 RotatePoint(Vector2 point, Vector2 origin,
float rotation)
=> origin + (point - origin).RotatedBy(rotation);
private static float GetViewportCoverRadius(Vector2 focus, Vector2 viewport)
{
float radius = focus.Length();
radius = Math.Max(radius, Vector2.Distance(focus,
new Vector2(viewport.X, 0f)));
radius = Math.Max(radius, Vector2.Distance(focus,
new Vector2(0f, viewport.Y)));
radius = Math.Max(radius, Vector2.Distance(focus, viewport));
return Math.Max(1f, radius);
}
private static void DrawDeathUltimateCutCracks(SpriteBatch batch,
Texture2D pixel, in UltimateVisualState state, Vector2 focus,
Vector2 viewport, float shatter, float opacity)
{
float radius = GetViewportCoverRadius(focus, viewport) * 1.04f;
for (int cut = 0; cut < ReaperDeathUltimateGeometry.CutCount; cut++)
{
int cutTick = ReaperDeathUltimateGeometry.GetCutTick(cut);
if (state.Timer < cutTick)
continue;
float age = state.Timer - cutTick;
float fresh = (float)Math.Exp(-age / 13f);
float strength = (0.12f + fresh * 0.38f + shatter * 0.74f)
* opacity;
Vector2 axis = ReaperDeathUltimateGeometry.GetCutAxis(
state.ActionId, cut);
Vector2 start = focus - axis * radius;
Vector2 end = focus + axis * radius;
DrawLayeredLine(batch, pixel, start, end,
new Color(32, 0, 15),
Color.Lerp(new Color(235, 12, 62), Color.White,
shatter * 0.48f),
4f + shatter * 3f, 0.9f + shatter * 0.8f,
strength);
}
}
private static void DrawDeathLegacy(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
float progress,
float opacity,
float time)
{
ReadOnlySpan<ReaperFormId> forms =
[
ReaperFormId.Bone,
ReaperFormId.Blood,
ReaperFormId.Infernal,
ReaperFormId.Frost,
ReaperFormId.Soul,
ReaperFormId.Void
];
float converge = Reveal(progress, 0.69f, 0.92f);
float initialOrbit = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.31f, 205f, 340f);
float orbitRadius = MathHelper.Lerp(initialOrbit, 34f, Ease(converge));
float rotation = -MathHelper.PiOver2 + time * MathHelper.Lerp(0.08f, 0.72f, converge);
for (int index = 0; index < forms.Length; index++)
{
float reveal = Reveal(progress, 0.015f + index * 0.038f, 0.105f + index * 0.038f) * opacity;
if (reveal <= 0.001f)
continue;
Color color = ReaperCombatRegistry.GetPrimaryColor(forms[index]);
Color core = ReaperCombatRegistry.GetSecondaryColor(forms[index]);
float angle = rotation + index * MathHelper.TwoPi / forms.Length;
Vector2 originalPosition = focus + angle.ToRotationVector2() * initialOrbit;
Vector2 position = focus + angle.ToRotationVector2() * orbitRadius;
if (converge > 0.001f)
DrawLayeredLine(batch, pixel, originalPosition, position, color, core, 9f, 2f,
converge * reveal * 0.58f);
DrawLayeredLine(batch, pixel, position, focus, color, core, 5f, 1.2f, reveal * 0.30f);
DrawGlow(batch, position, 54f, color * (0.24f * reveal));
float phaseCenter = 36f / 170f + index * 18f / 170f;
float activePulse = 0.74f + Pulse(progress, phaseCenter, 0.055f) * 0.36f;
DrawDeathGate(batch, pixel, position, index, angle, reveal * activePulse,
converge, time, color, core);
}
// Six executions use their branch's actual silhouette, not six recolored
// copies of one crescent. Their centers match the authoritative hit ticks.
for (int index = 0; index < forms.Length; index++)
{
float center = 36f / 170f + index * 18f / 170f;
float phase = Envelope(progress, center - 0.055f, center - 0.012f,
center + 0.052f, center + 0.105f) * opacity;
if (phase > 0.001f)
DrawDeathPhaseMotif(batch, pixel, focus, viewport, index, phase, time);
}
float unity = Reveal(progress, 0.72f, 0.96f) * opacity;
if (unity > 0.001f)
{
for (int index = 0; index < forms.Length; index++)
{
Color color = ReaperCombatRegistry.GetPrimaryColor(forms[index]);
Vector2 direction = (rotation + index * MathHelper.TwoPi / forms.Length).ToRotationVector2();
DrawLayeredLine(batch, pixel, focus, focus + direction * MathHelper.Lerp(18f, 115f, 1f - converge),
color, Color.White, 12f, 2.1f, unity * 0.72f);
}
DrawRing(batch, pixel, focus, MathHelper.Lerp(152f, 24f, Ease(unity)), 64,
Color.White * (0.88f * unity), 5f, rotation, 1f);
DrawRing(batch, pixel, focus, MathHelper.Lerp(104f, 15f, Ease(unity)), 54,
new Color(255, 58, 105) * (0.72f * unity), 2.5f, -rotation, 1f);
DrawGlow(batch, focus, 210f, Color.White * (0.20f * unity));
}
float finalCut = Reveal(progress, 0.86f, 0.985f);
float reach = Math.Max(viewport.X, viewport.Y) * 0.80f;
Vector2 cutDirection = new Vector2(1f, -0.16f).SafeNormalize(Vector2.UnitX);
DrawJaggedLine(batch, pixel, focus - cutDirection * reach, focus + cutDirection * reach,
finalCut, new Color(225, 30, 75), Color.White, 34f, 6f, 5f, 667f, opacity);
float requiem = Envelope(progress, 0.82f, 0.90f, 0.99f, 1f) * opacity;
if (requiem > 0.001f)
{
float scale = MathHelper.Clamp(Math.Min(viewport.X, viewport.Y) * 0.58f, 370f, 690f);
DrawReaperSilhouette(batch, pixel, focus - Vector2.UnitY * scale * 0.23f,
scale, new Color(3, 0, 4), new Color(210, 18, 54), requiem * 0.88f);
for (int band = 0; band < forms.Length; band++)
{
Color color = ReaperCombatRegistry.GetPrimaryColor(forms[band]);
DrawTaperedCrescent(batch, pixel, focus, scale * (0.94f - band * 0.032f),
-2.74f + band * 0.018f, 4.62f, requiem * (0.20f + band * 0.035f),
new Color(8, 0, 10), Color.Lerp(new Color(120, 0, 28), color, 0.42f),
color, scale * (0.16f - band * 0.012f));
}
DrawTaperedCrescent(batch, pixel, focus, scale, -2.76f, 4.64f, requiem,
new Color(8, 0, 10), new Color(224, 18, 56), Color.White, scale * 0.10f);
}
}
private static void DrawDeathGate(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
int gate,
float rotation,
float opacity,
float converge,
float time,
Color color,
Color core)
{
float size = MathHelper.Lerp(42f, 23f, converge);
switch (gate)
{
case 0: // Ribbed bone guillotine gate.
{
Vector2 topLeft = center + new Vector2(-size * 0.68f, -size);
Vector2 topRight = center + new Vector2(size * 0.68f, -size);
Vector2 bottomLeft = center + new Vector2(-size * 0.68f, size);
Vector2 bottomRight = center + new Vector2(size * 0.68f, size);
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, new Color(6, 28, 35), color,
8f, 2f, opacity);
DrawLayeredLine(batch, pixel, topRight, bottomRight, new Color(6, 28, 35), color,
8f, 2f, opacity);
DrawJaggedLine(batch, pixel, topLeft, topRight, 1f, color, core,
9f, 2.2f, 2f, 90f, opacity);
for (int rib = 0; rib < 3; rib++)
{
float y = MathHelper.Lerp(-size * 0.52f, size * 0.58f, rib / 2f);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.66f, y),
center + new Vector2(-size * 0.16f, y + size * 0.13f), color, core,
4f, 1f, opacity * 0.78f);
DrawLayeredLine(batch, pixel, center + new Vector2(size * 0.66f, y),
center + new Vector2(size * 0.16f, y + size * 0.13f), color, core,
4f, 1f, opacity * 0.78f);
}
break;
}
case 1: // Blood moon gate and white-rimmed crescent.
DrawGlow(batch, center, size * 1.85f, new Color(126, 0, 24) * (opacity * 0.42f));
DrawRing(batch, pixel, center, size * 0.86f, 32, color * (opacity * 0.82f),
size * 0.18f, rotation, 1f);
DrawTaperedCrescent(batch, pixel, center, size * 0.92f, -2.55f, 4.24f,
opacity, new Color(55, 0, 16), color, Color.White, size * 0.18f);
break;
case 2: // Infernal five-point gate.
DrawRing(batch, pixel, center, size, 36, new Color(52, 8, 0) * opacity,
7f, rotation, 1f);
DrawPentagram(batch, pixel, center, size * 0.88f, rotation + time * 0.05f,
new Color(70, 7, 0), core, opacity);
break;
case 3: // Hexagonal frost mirror and X blades.
DrawPolygon(batch, pixel, center, size, 6, new Color(54, 120, 170) * (opacity * 0.72f),
10f, rotation, 1f);
DrawPolygon(batch, pixel, center, size * 0.86f, 6, Color.White * opacity,
2f, -rotation, 1f);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.66f, -size * 0.66f),
center + new Vector2(size * 0.66f, size * 0.66f), color, core, 5f, 1.2f, opacity);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.66f, size * 0.66f),
center + new Vector2(size * 0.66f, -size * 0.66f), color, Color.White, 5f, 1.2f, opacity);
break;
case 4: // Soft soul portal with a single ferryman shade.
DrawRing(batch, pixel, center, size, 36, color * (opacity * 0.72f), 5f,
rotation + time * 0.1f, 1f);
DrawRing(batch, pixel, center, size * 0.72f, 30, core * (opacity * 0.54f), 2f,
-rotation, 1f);
DrawSoulShade(batch, pixel, center, core, opacity, size / 44f, time);
break;
default: // Offset coordinate door cut out of the scene.
{
Rectangle voidCore = new(
(int)Math.Round(center.X - size * 0.72f),
(int)Math.Round(center.Y - size),
Math.Max(1, (int)Math.Round(size * 1.44f)),
Math.Max(1, (int)Math.Round(size * 2f)));
batch.Draw(pixel, voidCore, new Color(0, 0, 2) * (opacity * 0.94f));
Vector2 topLeft = new(voidCore.Left, voidCore.Top);
Vector2 topRight = new(voidCore.Right, voidCore.Top + size * 0.12f);
Vector2 bottomLeft = new(voidCore.Left, voidCore.Bottom - size * 0.12f);
Vector2 bottomRight = new(voidCore.Right, voidCore.Bottom);
DrawLayeredLine(batch, pixel, topLeft, topRight, color, Color.White, 6f, 1.3f, opacity);
DrawLayeredLine(batch, pixel, bottomLeft, bottomRight, color, core, 6f, 1.3f, opacity);
DrawLayeredLine(batch, pixel, center - Vector2.UnitX * size * 0.90f,
center + Vector2.UnitX * size * 0.90f, Color.Black, core, 10f, 2f, opacity);
break;
}
}
DrawDeathRuneGlyph(batch, pixel, center, gate, size * 0.28f, color, core, opacity * 0.74f);
}
private static void DrawDeathPhaseMotif(
SpriteBatch batch,
Texture2D pixel,
Vector2 focus,
Vector2 viewport,
int phase,
float opacity,
float time)
{
float shortSide = Math.Min(viewport.X, viewport.Y);
float longSide = Math.Max(viewport.X, viewport.Y);
switch (phase)
{
case 0: // Bone guillotine and rib frame.
{
Color bone = new(210, 244, 232);
Color corpseFire = new(58, 214, 228);
float halfWidth = MathHelper.Clamp(viewport.X * 0.17f, 145f, 270f);
float height = MathHelper.Clamp(viewport.Y * 0.52f, 300f, 520f);
Vector2 topLeft = focus + new Vector2(-halfWidth, -height * 0.56f);
Vector2 topRight = focus + new Vector2(halfWidth, -height * 0.56f);
Vector2 bottomLeft = topLeft + Vector2.UnitY * height;
Vector2 bottomRight = topRight + Vector2.UnitY * height;
DrawLayeredLine(batch, pixel, topLeft, bottomLeft, new Color(8, 28, 34), corpseFire,
18f, 3f, opacity);
DrawLayeredLine(batch, pixel, topRight, bottomRight, new Color(8, 28, 34), corpseFire,
18f, 3f, opacity);
DrawJaggedLine(batch, pixel, topLeft, topRight, 1f, corpseFire, bone,
20f, 4f, 5f, 180f, opacity);
for (int rib = 0; rib < 5; rib++)
{
float amount = (rib + 1f) / 6f;
Vector2 left = Vector2.Lerp(topLeft, bottomLeft, amount);
Vector2 right = Vector2.Lerp(topRight, bottomRight, amount);
DrawLayeredLine(batch, pixel, left, Vector2.Lerp(left, focus, 0.56f),
corpseFire, bone, 8f, 2f, opacity * 0.68f);
DrawLayeredLine(batch, pixel, right, Vector2.Lerp(right, focus, 0.56f),
corpseFire, bone, 8f, 2f, opacity * 0.68f);
}
DrawJaggedLine(batch, pixel, topRight + new Vector2(-20f, 30f),
bottomLeft + new Vector2(34f, -20f), 1f, new Color(22, 92, 110), bone,
28f, 5f, 4f, 219f, opacity);
break;
}
case 1: // Thick reference-style blood crescent.
{
float radius = MathHelper.Clamp(shortSide * 0.54f, 330f, 610f);
Vector2 center = focus + new Vector2(-radius * 0.13f, radius * 0.05f);
DrawGlow(batch, focus - Vector2.UnitY * radius * 0.25f, radius * 0.62f,
new Color(115, 0, 22) * (opacity * 0.42f));
DrawTaperedCrescent(batch, pixel, center, radius * 1.025f, -2.50f, 4.36f,
opacity * 0.24f, new Color(35, 0, 10), new Color(155, 5, 34),
new Color(255, 102, 112), radius * 0.22f);
DrawTaperedCrescent(batch, pixel, center, radius, -2.46f, 4.36f,
opacity, new Color(70, 0, 18), new Color(238, 24, 58),
new Color(255, 244, 226), radius * 0.18f);
DrawImpactStar(batch, pixel, focus + new Vector2(radius * 0.20f, radius * 0.43f),
radius * 0.09f, new Color(255, 145, 65), Color.White, opacity);
break;
}
case 2: // Pentagram and black-shell molten tracks.
{
float radius = MathHelper.Clamp(shortSide * 0.30f, 190f, 350f);
float rotation = -MathHelper.PiOver2 + time * 0.06f;
DrawPentagram(batch, pixel, focus, radius, rotation, new Color(43, 4, 0),
new Color(255, 192, 46), opacity);
for (int index = 0; index < 5; index++)
{
Vector2 direction = (rotation + index * MathHelper.TwoPi / 5f).ToRotationVector2();
Vector2 vertex = focus + direction * radius;
DrawLayeredLine(batch, pixel, focus, vertex + direction * radius * 0.55f,
new Color(12, 3, 0), new Color(255, 92, 8), 24f, 5f, opacity);
DrawGlow(batch, vertex, 52f, new Color(255, 150, 18) * (opacity * 0.30f));
}
break;
}
case 3: // Four frost mirrors and a crystalline X.
{
float orbit = MathHelper.Clamp(shortSide * 0.24f, 155f, 285f);
for (int index = 0; index < 4; index++)
{
float angle = MathHelper.PiOver4 + index * MathHelper.PiOver2;
Vector2 mirror = focus + angle.ToRotationVector2() * orbit;
DrawPolygon(batch, pixel, mirror, 58f, 6,
new Color(42, 126, 184) * (opacity * 0.66f), 15f, angle, 1f);
DrawPolygon(batch, pixel, mirror, 50f, 6, Color.White * opacity,
2.4f, -angle, 1f);
}
Vector2 diagonalA = new Vector2(1f, 1f).SafeNormalize(Vector2.One);
Vector2 diagonalB = new Vector2(1f, -1f).SafeNormalize(Vector2.UnitX);
DrawLayeredLine(batch, pixel, focus - diagonalA * longSide * 0.52f,
focus + diagonalA * longSide * 0.52f, new Color(45, 130, 190),
Color.White, 26f, 4f, opacity);
DrawLayeredLine(batch, pixel, focus - diagonalB * longSide * 0.52f,
focus + diagonalB * longSide * 0.52f, new Color(28, 91, 160),
new Color(190, 250, 255), 26f, 4f, opacity);
break;
}
case 4: // Winding soul river and ferryman shades.
{
for (int lane = 0; lane < 3; lane++)
{
Vector2 previous = default;
for (int segment = 0; segment <= 20; segment++)
{
float along = segment / 20f;
Vector2 current = new(
MathHelper.Lerp(-50f, viewport.X + 50f, along),
focus.Y + (lane - 1) * 46f
+ (float)Math.Sin(along * MathHelper.TwoPi * 2f + lane * 1.7f - time) * 24f);
if (segment > 0)
{
DrawLayeredLine(batch, pixel, previous, current, new Color(31, 8, 72),
lane == 1 ? new Color(118, 240, 242) : new Color(120, 75, 225),
13f, 2.4f, opacity * 0.78f);
}
previous = current;
}
}
for (int index = 0; index < 7; index++)
{
float angle = index * MathHelper.TwoPi / 7f + time * 0.25f;
Vector2 shade = focus + angle.ToRotationVector2() * (70f + index % 2 * 38f);
DrawSoulShade(batch, pixel, shade, new Color(154, 246, 239), opacity,
0.72f + index % 3 * 0.10f, angle);
}
break;
}
default: // Coordinate grid collapses into a negative-space world split.
{
float splitWidth = MathHelper.Clamp(shortSide * 0.10f, 68f, 128f);
batch.Draw(pixel, new Rectangle(0, (int)Math.Round(focus.Y - splitWidth * 0.5f),
(int)Math.Ceiling(viewport.X), (int)Math.Round(splitWidth)),
new Color(0, 0, 2) * (opacity * 0.96f));
batch.Draw(pixel, new Rectangle((int)Math.Round(focus.X - splitWidth * 0.38f), 0,
(int)Math.Round(splitWidth * 0.76f), (int)Math.Ceiling(viewport.Y)),
new Color(0, 0, 2) * (opacity * 0.96f));
DrawLayeredLine(batch, pixel, new Vector2(0f, focus.Y - splitWidth * 0.5f),
new Vector2(viewport.X, focus.Y - splitWidth * 0.5f), new Color(82, 9, 130),
Color.White, 9f, 2f, opacity);
DrawLayeredLine(batch, pixel, new Vector2(focus.X + splitWidth * 0.38f, 0f),
new Vector2(focus.X + splitWidth * 0.38f, viewport.Y), new Color(55, 4, 100),
new Color(220, 160, 255), 9f, 2f, opacity);
for (int panel = 0; panel < 5; panel++)
{
float y = viewport.Y * (panel + 1f) / 6f;
float offset = (panel % 2 == 0 ? 1f : -1f) * 22f * opacity;
DrawLayeredLine(batch, pixel, new Vector2(offset, y),
new Vector2(viewport.X + offset, y), Color.Black,
new Color(122, 30, 180), 7f, 1.5f, opacity * 0.72f);
}
break;
}
}
}
private static void DrawPentagram(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
float rotation,
Color shell,
Color core,
float opacity)
{
Span<Vector2> vertices = stackalloc Vector2[5];
for (int index = 0; index < vertices.Length; index++)
vertices[index] = center + (rotation + index * MathHelper.TwoPi / 5f).ToRotationVector2() * radius;
for (int edge = 0; edge < vertices.Length; edge++)
{
int start = edge * 2 % 5;
int end = (edge + 1) * 2 % 5;
DrawLayeredLine(batch, pixel, vertices[start], vertices[end], shell, core,
15f, 3f, opacity);
}
DrawRing(batch, pixel, center, radius * 1.04f, 48, shell * (opacity * 0.80f),
7f, rotation, 1f);
}
private static void DrawTaperedCrescent(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
float rotation,
float sweep,
float opacity,
Color shadow,
Color body,
Color edge,
float thickness)
{
opacity = MathHelper.Clamp(opacity, 0f, 1f);
if (opacity <= 0.001f || radius <= 2f || thickness <= 0.5f || Math.Abs(sweep) <= 0.01f)
return;
ReaperUltimateCrescentMaskSet? mask = SelectCrescentMask(Math.Abs(sweep), thickness / radius);
if (mask is null || mask.Body.IsDisposed || mask.Flow.IsDisposed || mask.Edge.IsDisposed)
return;
float scale = radius / CrescentReferenceRadius;
Vector2 textureOrigin = new(CrescentMaskSize * 0.5f);
SpriteEffects effects = sweep < 0f ? SpriteEffects.FlipVertically : SpriteEffects.None;
// Four cached-mask draws replace hundreds of MagicPixel segments. Body,
// longitudinal flow and white-hot rim remain independently tintable.
batch.Draw(mask.Body, center, null, shadow * (opacity * 0.48f), rotation,
textureOrigin, scale * 1.025f, effects, 0f);
batch.Draw(mask.Body, center, null, body * (opacity * 0.84f), rotation,
textureOrigin, scale, effects, 0f);
batch.Draw(mask.Flow, center, null, Color.Lerp(body, edge, 0.34f) * (opacity * 0.48f),
rotation + (float)Math.Sin(Main.GlobalTimeWrappedHourly * 2.4f) * 0.004f,
textureOrigin, scale, effects, 0f);
batch.Draw(mask.Edge, center, null, edge * opacity, rotation,
textureOrigin, scale, effects, 0f);
}
private static ReaperUltimateCrescentMaskSet? SelectCrescentMask(float sweep, float thicknessRatio)
{
ReaperUltimateCrescentMaskSet? best = null;
float bestScore = float.MaxValue;
for (int index = 0; index < crescentMasks.Length; index++)
{
ReaperUltimateCrescentMaskSet candidate = crescentMasks[index];
// Preserve the requested arc silhouette first; thickness selects the
// closer preset when two sweep families are visually comparable.
float score = Math.Abs(candidate.Sweep - sweep) * 2.4f
+ Math.Abs(candidate.ThicknessRatio - thicknessRatio) * 4f;
if (score >= bestScore)
continue;
best = candidate;
bestScore = score;
}
return best;
}
private static void EnsureCrescentMasks()
{
if (crescentMasks.Length > 0)
return;
if (Main.dedServ || Main.graphics?.GraphicsDevice is not GraphicsDevice graphicsDevice)
return;
crescentMasks =
[
CreateCrescentMask(graphicsDevice, 3.58f, 0.115f),
CreateCrescentMask(graphicsDevice, 4.24f, 0.175f),
CreateCrescentMask(graphicsDevice, 4.66f, 0.245f)
];
}
private static ReaperUltimateCrescentMaskSet CreateCrescentMask(
GraphicsDevice graphicsDevice,
float sweep,
float thicknessRatio)
{
Color[] bodyData = new Color[CrescentMaskSize * CrescentMaskSize];
Color[] flowData = new Color[bodyData.Length];
Color[] edgeData = new Color[bodyData.Length];
float center = CrescentMaskSize * 0.5f;
float maximumWidth = CrescentReferenceRadius * thicknessRatio;
for (int y = 0; y < CrescentMaskSize; y++)
{
float dy = y + 0.5f - center;
for (int x = 0; x < CrescentMaskSize; x++)
{
float dx = x + 0.5f - center;
float radial = (float)Math.Sqrt(dx * dx + dy * dy);
if (radial < CrescentReferenceRadius - maximumWidth
|| radial > CrescentReferenceRadius + maximumWidth)
{
continue;
}
float angle = (float)Math.Atan2(dy, dx);
if (angle < 0f)
angle += MathHelper.TwoPi;
if (angle > sweep)
continue;
float along = angle / sweep;
float taper = (float)Math.Pow(Math.Max(0f, Math.Sin(along * MathHelper.Pi)), 0.58f);
taper *= MathHelper.Lerp(0.72f, 1f, 1f - along * 0.42f);
float halfWidth = Math.Max(0.75f, maximumWidth * taper * 0.5f);
float distance = Math.Abs(radial - CrescentReferenceRadius);
float bodyAlpha = MathHelper.Clamp((halfWidth + 1.6f - distance) / 2.8f, 0f, 1f);
if (bodyAlpha <= 0f)
continue;
int dataIndex = y * CrescentMaskSize + x;
bodyData[dataIndex] = PremultipliedMask(bodyAlpha);
float normalizedRadial = (radial - CrescentReferenceRadius) / Math.Max(1f, halfWidth);
float firstFlow = -0.34f + (float)Math.Sin(along * MathHelper.TwoPi * 2.1f) * 0.10f;
float secondFlow = 0.18f + (float)Math.Sin(along * MathHelper.TwoPi * 3.2f + 1.3f) * 0.11f;
float flowAlpha = Math.Max(
1f - Math.Abs(normalizedRadial - firstFlow) / 0.12f,
1f - Math.Abs(normalizedRadial - secondFlow) / 0.09f);
flowAlpha = MathHelper.Clamp(flowAlpha, 0f, 1f) * bodyAlpha * (0.62f + taper * 0.38f);
flowData[dataIndex] = PremultipliedMask(flowAlpha);
float rimRadius = CrescentReferenceRadius + halfWidth * 0.88f;
float rimWidth = Math.Max(1.35f, maximumWidth * 0.055f);
float rimAlpha = MathHelper.Clamp((rimWidth + 1.2f - Math.Abs(radial - rimRadius)) / 2.2f, 0f, 1f);
edgeData[dataIndex] = PremultipliedMask(rimAlpha * bodyAlpha);
}
}
Texture2D bodyTexture = new(graphicsDevice, CrescentMaskSize, CrescentMaskSize);
Texture2D flowTexture = new(graphicsDevice, CrescentMaskSize, CrescentMaskSize);
Texture2D edgeTexture = new(graphicsDevice, CrescentMaskSize, CrescentMaskSize);
bodyTexture.SetData(bodyData);
flowTexture.SetData(flowData);
edgeTexture.SetData(edgeData);
return new ReaperUltimateCrescentMaskSet(sweep, thicknessRatio, bodyTexture, flowTexture, edgeTexture);
}
private static Color PremultipliedMask(float opacity)
{
byte value = (byte)Math.Round(MathHelper.Clamp(opacity, 0f, 1f) * byte.MaxValue);
return new Color(value, value, value, value);
}
private static void DisposeCrescentMasks(ReaperUltimateCrescentMaskSet[] masks)
{
for (int index = 0; index < masks.Length; index++)
masks[index].Dispose();
}
private static void DrawImpactStar(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
Color outer,
Color core,
float opacity)
{
opacity = MathHelper.Clamp(opacity, 0f, 1f);
if (opacity <= 0.001f || radius <= 1f)
return;
DrawGlow(batch, center, radius * 2.4f, outer * (opacity * 0.30f));
for (int ray = 0; ray < 10; ray++)
{
float angle = ray * MathHelper.TwoPi / 10f + (ray % 2) * 0.11f;
float rayLength = radius * (ray % 2 == 0 ? 1f : 0.55f);
Vector2 direction = angle.ToRotationVector2();
DrawLayeredLine(batch, pixel, center - direction * rayLength * 0.12f,
center + direction * rayLength, outer, core, 5f, 1.4f, opacity);
}
}
private static void DrawReaperSilhouette(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float scale,
Color shadow,
Color rim,
float opacity)
{
opacity = MathHelper.Clamp(opacity, 0f, 1f);
if (opacity <= 0.001f || scale <= 10f)
return;
float headRadius = scale * 0.11f;
Vector2 head = center - Vector2.UnitY * scale * 0.30f;
DrawGlow(batch, head, headRadius * 2.5f, rim * (opacity * 0.13f));
DrawPolygon(batch, pixel, head, headRadius, 9, shadow * (opacity * 0.96f),
headRadius * 0.82f, -MathHelper.PiOver2, 1f);
DrawRing(batch, pixel, head, headRadius * 1.04f, 28, rim * (opacity * 0.56f), 3f, 0f, 1f);
Vector2 leftShoulder = center + new Vector2(-scale * 0.25f, -scale * 0.17f);
Vector2 rightShoulder = center + new Vector2(scale * 0.25f, -scale * 0.17f);
Vector2 hem = center + Vector2.UnitY * scale * 0.42f;
DrawLayeredLine(batch, pixel, leftShoulder, hem, shadow, rim, scale * 0.22f, 3f, opacity * 0.62f);
DrawLayeredLine(batch, pixel, rightShoulder, hem, shadow, rim, scale * 0.22f, 3f, opacity * 0.62f);
DrawLayeredLine(batch, pixel, leftShoulder, rightShoulder, shadow, rim, scale * 0.18f, 3f, opacity * 0.58f);
Vector2 staffStart = center + new Vector2(-scale * 0.30f, scale * 0.36f);
Vector2 staffEnd = center + new Vector2(scale * 0.26f, -scale * 0.48f);
DrawLayeredLine(batch, pixel, staffStart, staffEnd, shadow, rim, 15f, 3.2f, opacity * 0.82f);
DrawTaperedCrescent(batch, pixel, staffEnd + new Vector2(scale * 0.10f, scale * 0.03f),
scale * 0.25f, -2.7f, 3.5f, opacity * 0.88f, shadow, rim, Color.White, scale * 0.045f);
}
private static void DrawTombstone(
SpriteBatch batch,
Texture2D pixel,
Vector2 bottomCenter,
float width,
float height,
Color fill,
Color outline)
{
Vector2 top = bottomCenter - Vector2.UnitY * height;
Rectangle body = new(
(int)Math.Round(bottomCenter.X - width * 0.5f),
(int)Math.Round(top.Y + width * 0.26f),
Math.Max(1, (int)Math.Round(width)),
Math.Max(1, (int)Math.Round(height - width * 0.26f)));
batch.Draw(pixel, body, fill);
DrawRing(batch, pixel, new Vector2(bottomCenter.X, body.Top), width * 0.5f, 16,
fill, width * 0.48f, MathHelper.Pi, 0.5f);
DrawLayeredLine(batch, pixel, new Vector2(body.Left, body.Bottom), new Vector2(body.Right, body.Bottom),
outline, Color.White, 4f, 1f, 0.78f);
DrawLayeredLine(batch, pixel, new Vector2(body.Left, body.Top), new Vector2(body.Left, body.Bottom),
outline, Color.White, 3f, 0.8f, 0.64f);
DrawLayeredLine(batch, pixel, new Vector2(body.Right, body.Top), new Vector2(body.Right, body.Bottom),
outline, Color.White, 3f, 0.8f, 0.64f);
Vector2 crossCenter = bottomCenter - Vector2.UnitY * height * 0.48f;
DrawSegment(batch, pixel, crossCenter - Vector2.UnitY * 12f, crossCenter + Vector2.UnitY * 13f,
outline, 2.2f);
DrawSegment(batch, pixel, crossCenter - Vector2.UnitX * 8f, crossCenter + Vector2.UnitX * 8f,
outline, 2.2f);
}
private static void DrawSoulShade(
SpriteBatch batch,
Texture2D pixel,
Vector2 position,
Color color,
float opacity,
float scale,
float rotation)
{
DrawGlow(batch, position, 38f * scale, color * (0.20f * opacity));
Texture2D? texture = soulTexture?.IsLoaded == true ? soulTexture.Value : null;
if (texture is not null)
{
float textureScale = 46f / Math.Max(texture.Width, texture.Height) * scale;
batch.Draw(texture, position, null, color * (0.74f * opacity), rotation * 0.04f,
new Vector2(texture.Width, texture.Height) * 0.5f, textureScale, SpriteEffects.None, 0f);
}
else
{
DrawPolygon(batch, pixel, position, 14f * scale, 4, color * opacity, 2f,
MathHelper.PiOver4, 1f);
}
Vector2 tail = position + new Vector2((float)Math.Sin(rotation) * 7f, 20f * scale);
DrawLayeredLine(batch, pixel, position, tail, color, Color.White, 5f, 1.1f, opacity * 0.56f);
}
private static void DrawDeathRuneGlyph(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
int glyph,
float size,
Color color,
Color core,
float opacity)
{
switch (glyph)
{
case 0: // Bone cross.
DrawLayeredLine(batch, pixel, center - Vector2.UnitY * size, center + Vector2.UnitY * size,
color, core, 4f, 1.2f, opacity);
DrawLayeredLine(batch, pixel, center - Vector2.UnitX * size * 0.65f, center + Vector2.UnitX * size * 0.65f,
color, core, 4f, 1.2f, opacity);
break;
case 1: // Blood fang.
DrawLayeredLine(batch, pixel, center + new Vector2(-size, -size * 0.7f), center + new Vector2(0f, size),
color, core, 4f, 1.2f, opacity);
DrawLayeredLine(batch, pixel, center + new Vector2(size, -size * 0.7f), center + new Vector2(0f, size),
color, core, 4f, 1.2f, opacity);
break;
case 2: // Infernal triangle.
DrawRuneTriangle(batch, pixel, center, size, -MathHelper.PiOver2, core, opacity);
break;
case 3: // Frost crystal.
for (int index = 0; index < 3; index++)
{
Vector2 direction = (index * MathHelper.Pi / 3f).ToRotationVector2() * size;
DrawLayeredLine(batch, pixel, center - direction, center + direction,
color, core, 3.5f, 1f, opacity);
}
break;
case 4: // Soul diamond.
DrawPolygon(batch, pixel, center, size, 4, core * opacity, 3f, MathHelper.PiOver4, 1f);
DrawSegment(batch, pixel, center - Vector2.UnitY * size * 0.55f,
center + Vector2.UnitY * size * 0.55f, color * opacity, 2f);
break;
default: // Void severance.
DrawLayeredLine(batch, pixel, center + new Vector2(-size, size), center + new Vector2(size, -size),
color, Color.White, 5f, 1.3f, opacity);
DrawLayeredLine(batch, pixel, center + new Vector2(-size * 0.55f, -size), center + new Vector2(size * 0.55f, size),
color, core, 3f, 0.9f, opacity * 0.75f);
break;
}
}
private static void DrawRuneTriangle(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
float rotation,
Color color,
float opacity)
{
DrawPolygon(batch, pixel, center, radius, 3, color * opacity, 2.2f, rotation, 1f);
}
private static void DrawGlow(SpriteBatch batch, Vector2 center, float radius, Color color)
{
if (radius <= 0.5f || color.A == 0)
return;
DeathDomainPrimitiveTextureSystem.DrawRadialGradient(batch, center, radius, color);
}
private static void DrawRing(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
int segments,
Color color,
float width,
float rotation,
float reveal)
{
if (radius <= 0.5f || segments < 3 || width <= 0.05f || reveal <= 0.001f || color.A == 0)
return;
reveal = MathHelper.Clamp(reveal, 0f, 1f);
segments = Math.Max(segments,
Math.Min(192, (int)Math.Ceiling(MathHelper.TwoPi * radius / 18f)));
Vector2 previous = center + rotation.ToRotationVector2() * radius;
int visibleSegments = Math.Max(1, (int)Math.Ceiling(segments * reveal));
for (int index = 1; index <= visibleSegments; index++)
{
float amount = Math.Min(reveal, index / (float)segments);
Vector2 current = center + (rotation + MathHelper.TwoPi * amount).ToRotationVector2() * radius;
DrawSegment(batch, pixel, previous, current, color, width);
previous = current;
}
}
private static void DrawPolygon(
SpriteBatch batch,
Texture2D pixel,
Vector2 center,
float radius,
int sides,
Color color,
float width,
float rotation,
float reveal)
{
if (sides < 3 || radius <= 0.5f || reveal <= 0.001f)
return;
reveal = MathHelper.Clamp(reveal, 0f, 1f);
Vector2 previous = center + rotation.ToRotationVector2() * radius;
int visibleEdges = Math.Max(1, (int)Math.Ceiling(sides * reveal));
for (int edge = 1; edge <= visibleEdges; edge++)
{
float edgeCompletion = Math.Min(1f, sides * reveal - (edge - 1));
Vector2 target = center + (rotation + MathHelper.TwoPi * edge / sides).ToRotationVector2() * radius;
Vector2 current = Vector2.Lerp(previous, target, edgeCompletion);
DrawSegment(batch, pixel, previous, current, color, width);
previous = target;
}
}
private static void DrawJaggedLine(
SpriteBatch batch,
Texture2D pixel,
Vector2 start,
Vector2 end,
float reveal,
Color outerColor,
Color coreColor,
float outerWidth,
float coreWidth,
float amplitude,
float seed,
float opacity)
{
reveal = MathHelper.Clamp(reveal, 0f, 1f);
if (reveal <= 0.001f || opacity <= 0.001f)
return;
const int segments = 18;
float totalLength = Vector2.Distance(start, end);
int segmentCount = Math.Max(3, Math.Min(segments, (int)(totalLength / 38f) + 3));
Vector2 direction = (end - start).SafeNormalize(Vector2.UnitX);
Vector2 perpendicular = new(-direction.Y, direction.X);
Vector2 previous = JaggedPoint(start, end, perpendicular, 0f, segmentCount, amplitude, seed);
int visibleSegments = Math.Max(1, (int)Math.Ceiling(segmentCount * reveal));
for (int index = 1; index <= visibleSegments; index++)
{
float amount = Math.Min(reveal, index / (float)segmentCount);
Vector2 current = JaggedPoint(start, end, perpendicular, amount, segmentCount, amplitude, seed);
DrawLayeredLine(batch, pixel, previous, current, outerColor, coreColor,
outerWidth, coreWidth, opacity);
previous = current;
}
}
private static Vector2 JaggedPoint(
Vector2 start,
Vector2 end,
Vector2 perpendicular,
float amount,
int segments,
float amplitude,
float seed)
{
float envelope = (float)Math.Sin(amount * MathHelper.Pi);
float grain = (float)Math.Sin((amount * segments + seed) * 5.137f) * 0.67f
+ (float)Math.Sin((amount * segments + seed * 1.91f) * 11.73f) * 0.33f;
return Vector2.Lerp(start, end, amount) + perpendicular * (grain * amplitude * envelope);
}
private static void DrawLayeredLine(
SpriteBatch batch,
Texture2D pixel,
Vector2 start,
Vector2 end,
Color outerColor,
Color coreColor,
float outerWidth,
float coreWidth,
float opacity)
{
if (opacity <= 0.001f)
return;
DrawSegment(batch, pixel, start, end, outerColor * (opacity * 0.72f), outerWidth);
DrawSegment(batch, pixel, start, end, coreColor * opacity, coreWidth);
}
private static void DrawSegment(
SpriteBatch batch,
Texture2D pixel,
Vector2 start,
Vector2 end,
Color color,
float width)
{
DeathDomainPrimitiveTextureSystem.DrawSmoothLine(batch, start, end, color, width);
}
private static float GetStateOpacity(in UltimateVisualState state)
{
float progress = MathHelper.Clamp(state.Timer / (float)Math.Max(1, state.Duration), 0f, 1f);
float introduction = MathHelper.Lerp(0.35f, 1f, Ease(progress / 0.06f));
float tail = 1f - MathHelper.Clamp(state.FramesSinceReport / (float)TailFrames, 0f, 1f);
return introduction * Ease(tail);
}
private static float GetBackdropDarkness(in UltimateVisualState state)
{
if (state.Form == ReaperFormId.Death)
{
float cutProgress = MathHelper.Clamp(
(state.Timer - ReaperDeathUltimateGeometry.FirstCutTick)
/ (float)(ReaperDeathUltimateGeometry.ShatterTick
- ReaperDeathUltimateGeometry.FirstCutTick), 0f, 1f);
return MathHelper.Lerp(0.30f, 0.985f, Ease(cutProgress));
}
return state.Form switch
{
ReaperFormId.Bone => 0.36f,
ReaperFormId.Blood => 0.42f,
ReaperFormId.Infernal => 0.38f,
ReaperFormId.Frost => 0.31f,
ReaperFormId.Soul => 0.37f,
ReaperFormId.Void => 0.52f,
_ => 0f
};
}
private static float Reveal(float progress, float start, float end)
{
if (end <= start)
return progress >= end ? 1f : 0f;
return Ease((progress - start) / (end - start));
}
private static float Envelope(float progress, float start, float riseEnd, float fallStart, float end)
{
if (progress < start || progress > end)
return 0f;
if (progress < riseEnd)
return Reveal(progress, start, riseEnd);
if (progress <= fallStart)
return 1f;
return 1f - Reveal(progress, fallStart, end);
}
private static float Pulse(float progress, float center, float halfWidth)
{
if (halfWidth <= 0f)
return 0f;
return Ease(1f - Math.Abs(progress - center) / halfWidth);
}
private static float Ease(float value)
{
value = MathHelper.Clamp(value, 0f, 1f);
return value * value * (3f - 2f * value);
}
private static float PositiveModulo(float value, float modulus)
{
float result = value % modulus;
return result < 0f ? result + modulus : result;
}
private static void EnsureStateStorage()
{
if (states.Length != Main.maxPlayers)
states = new UltimateVisualState[Main.maxPlayers];
}
private static void ClearStates()
{
if (states.Length > 0)
Array.Clear(states, 0, states.Length);
}
private struct UltimateVisualState
{
public bool Active;
public ReaperFormId Form;
public int ActionId;
public Vector2 OriginWorld;
public Vector2 FocusWorld;
public Vector2 Aim;
public int Timer;
public int Duration;
public int FramesSinceReport;
public ulong LastReportTick;
}
}
