#include "raylib.h"

#include <math.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <stdarg.h>

#define MAX_HEAP 63

#define LOG_LINES 16

static float gFontScale = 1.0f;

typedef struct {

int data[MAX_HEAP];

int size;

} Heap;

typedef enum {

OP_NONE = 0,

OP_INSERT,

OP_POP,

OP_HEAPIFY,

OP_BUILD

} OpType;

typedef struct {

OpType op;

int activeA;

int activeB;

int candidate;

int root;

int current;

int frame;

int stage;

int tempValue;

int path[16];

int pathLen;

bool running;

bool swapActive;

int swapI;

int swapJ;

int swapValI;

int swapValJ;

int nextCurrent;

float swapT;

float swapSpeed;

} OpState;

typedef struct {

char lines[LOG_LINES][160];

int count;

} LogPanel;

typedef struct {

char title[48];

int line;

char note[160];

int i;

int parent;

int left;

int right;

int largest;

int child;

int size;

int vI;

int vParent;

int vLeft;

int vRight;

int vLargest;

} DebugState;

typedef struct {

bool active;

int from;

int hover;

int value;

bool fromTree;

} DragState;

typedef enum {

SPLIT_NONE = 0,

SPLIT_LEFT_RIGHT,

SPLIT_ARRAY_TREE,

SPLIT_INSPECT_DEBUG,

SPLIT_CODE_ARM

} SplitterKind;

static void DebugClear(DebugState *d) {

strcpy(d->title, "IDLE");

d->line = 1;

strcpy(d->note, "Waiting for operation");

d->i = -1;

d->parent = -1;

d->left = -1;

d->right = -1;

d->largest = -1;

d->child = -1;

d->size = 0;

d->vI = -1;

d->vParent = -1;

d->vLeft = -1;

d->vRight = -1;

d->vLargest = -1;

}

static void DebugSet(DebugState *d, const char *title, int line, const char *note) {

snprintf(d->title, sizeof(d->title), "%s", title);

d->line = line;

snprintf(d->note, sizeof(d->note), "%s", note);

}

static const char *OpTitle(OpType op) {

if (op == OP_INSERT) return "INSERT";

if (op == OP_POP) return "POP_MAX";

if (op == OP_HEAPIFY) return "HEAPIFY";

if (op == OP_BUILD) return "BUILD_HEAP";

return "IDLE";

}

static int ClampInt(int v, int lo, int hi) {

if (v < lo) return lo;

if (v > hi) return hi;

return v;

}

static int FontPx(int base) {

int s = (int)roundf((float)base * gFontScale);

if (s < 8) s = 8;

return s;

}

static int MeasureTextScaled(const char *txt, int baseSize) {

Vector2 sz = MeasureTextEx(GetFontDefault(), txt, (float)FontPx(baseSize), 1.0f);

return (int)sz.x;

}

static void DrawTextScaled(const char *txt, int x, int y, int baseSize, Color c) {

DrawTextEx(GetFontDefault(), txt, (Vector2){(float)x, (float)y}, (float)FontPx(baseSize), 1.0f, c);

}

#define MeasureText(txt, size) MeasureTextScaled((txt), (size))

#define DrawText(txt, x, y, size, color) DrawTextScaled((txt), (x), (y), (size), (color))

static void LogPush(LogPanel *log, const char *fmt, ...) {

if (!log) return;

if (log->count < LOG_LINES) {

log->count++;

}

for (int i = 0; i < log->count - 1; i++) {

strcpy(log->lines[i], log->lines[i + 1]);

}

va_list args;

va_start(args, fmt);

vsnprintf(log->lines[log->count - 1], sizeof(log->lines[0]), fmt, args);

va_end(args);

}

static void HeapSwap(Heap *h, int i, int j) {

int t = h->data[i];

h->data[i] = h->data[j];

h->data[j] = t;

}

static void HeapClear(Heap *h) {

h->size = 0;

}

static int HeapHeight(int n) {

int height = 0;

int total = 1;

while (total < n) {

total <<= 1;

height++;

}

return height;

}

static Vector2 NodePos(int idx, Rectangle area, int heapSize) {

if (heapSize <= 0) return (Vector2){area.x + area.width * 0.5f, area.y + 60};

int level = (int)floorf(log2f((float)(idx + 1)));

int firstOnLevel = (1 << level) - 1;

int indexOnLevel = idx - firstOnLevel;

int nodesOnLevel = 1 << level;

int height = HeapHeight(heapSize);

float levelGap = (height > 0) ? (area.height - 80) / (float)(height + 1) : 0;

float y = area.y + 40 + level * levelGap;

float xSpacing = area.width / (float)(nodesOnLevel + 1);

float x = area.x + xSpacing * (float)(indexOnLevel + 1);

return (Vector2){x, y};

}

static Rectangle ArrayCellRect(Rectangle area, int idx) {

int cols = 9;

int rows = (MAX_HEAP + cols - 1) / cols;

float sidePad = 12.0f;

float topPad = 48.0f;

float colGap = 6.0f;

float rowGap = 8.0f;

float cellW = (area.width - sidePad * 2.0f - colGap * (cols - 1)) / (float)cols;

float availableH = area.height - topPad - rowGap * (rows - 1);

float cellH = availableH / (float)rows;

if (cellH < 24) cellH = 24;

if (cellH > 72) cellH = 72;

float startX = area.x + sidePad;

float y = area.y + topPad;

int row = idx / cols;

int col = idx % cols;

return (Rectangle){

startX + col * (cellW + colGap),

y + row * (cellH + rowGap),

cellW,

cellH

};

}

static int ArrayIndexAtPoint(Rectangle area, Vector2 p) {

for (int i = 0; i < MAX_HEAP; i++) {

if (CheckCollisionPointRec(p, ArrayCellRect(area, i))) return i;

}

return -1;

}

static int TreeIndexAtPoint(const Heap *h, Rectangle area, Vector2 p) {

for (int i = 0; i < h->size; i++) {

Vector2 n = NodePos(i, area, h->size);

if (CheckCollisionPointCircle(p, n, 24.0f)) return i;

}

return -1;

}

static void StartSwapAnim(const Heap *h, OpState *st, int i, int j, int nextCurrent) {

st->swapActive = true;

st->swapI = i;

st->swapJ = j;

st->swapValI = h->data[i];

st->swapValJ = h->data[j];

st->nextCurrent = nextCurrent;

st->swapT = 0.0f;

}

static Color HeatColor(float t) {

if (t < 0.0f) t = 0.0f;

if (t > 1.0f) t = 1.0f;

unsigned char r = (unsigned char)(50 + 200 * t);

unsigned char g = (unsigned char)(80 + 140 * (1 - t));

unsigned char b = (unsigned char)(220 - 170 * t);

return (Color){r, g, b, 255};

}

static void DrawBadge(Rectangle r, Color c, const char *txt) {

DrawRectangleRounded(r, 0.35f, 6, Fade(c, 0.2f));

DrawRectangleRoundedLines(r, 0.35f, 6, Fade(c, 0.7f));

int tw = MeasureText(txt, 18);

DrawText(txt, (int)(r.x + r.width * 0.5f - tw * 0.5f), (int)(r.y + 8), 18, RAYWHITE);

}

static bool DrawActionButton(Rectangle r, const char *label, Color accent, bool hovered, bool disabled) {

Color fill = Fade((Color){24, 34, 46, 255}, disabled ? 0.45f : 0.92f);

Color border = disabled ? Fade((Color){95, 110, 124, 255}, 0.55f) : Fade(accent, hovered ? 1.0f : 0.72f);

Color text = disabled ? Fade(RAYWHITE, 0.45f) : RAYWHITE;

if (!disabled && hovered) {

fill = Fade(accent, 0.24f);

}

DrawRectangleRounded(r, 0.28f, 6, fill);

DrawRectangleRoundedLines(r, 0.28f, 6, border);

int tw = MeasureText(label, 18);

DrawText(label, (int)(r.x + r.width * 0.5f - tw * 0.5f), (int)(r.y + 7), 18, text);

return hovered && !disabled;

}

static void StartInsert(Heap *h, OpState *st, int value, LogPanel *log, DebugState *dbg) {

if (h->size >= MAX_HEAP) {

LogPush(log, "Insert blocked: heap is full (%d)", MAX_HEAP);

return;

}

st->op = OP_INSERT;

st->running = true;

st->activeA = h->size;

st->activeB = -1;

st->candidate = -1;

st->frame = 0;

st->stage = 0;

st->tempValue = value;

st->pathLen = 0;

st->swapActive = false;

h->data[h->size] = value;

h->size++;

st->current = h->size - 1;

DebugSet(dbg, "INSERT", 2, "Place value at tail, begin sift-up");

dbg->i = st->current;

dbg->size = h->size;

dbg->vI = value;

LogPush(log, "INSERT %d -> place at index %d, then sift-up", value, st->current);

}

static void StartPop(Heap *h, OpState *st, LogPanel *log, DebugState *dbg) {

if (h->size <= 0) {

LogPush(log, "Pop blocked: heap is empty");

return;

}

st->op = OP_POP;

st->running = true;

st->frame = 0;

st->stage = 0;

st->pathLen = 0;

st->swapActive = false;

st->tempValue = h->data[0];

st->activeA = 0;

st->activeB = h->size - 1;

DebugSet(dbg, "POP_MAX", 2, "Save max, move last element to root");

dbg->i = 0;

dbg->size = h->size;

dbg->vI = h->data[0];

LogPush(log, "POP max=%d -> move last node to root, then sift-down", st->tempValue);

}

static void StartHeapify(Heap *h, OpState *st, int rootIndex, LogPanel *log, DebugState *dbg) {

if (h->size <= 0 || rootIndex < 0 || rootIndex >= h->size) {

return;

}

st->op = OP_HEAPIFY;

st->running = true;

st->frame = 0;

st->stage = 0;

st->root = rootIndex;

st->current = rootIndex;

st->activeA = rootIndex;

st->activeB = -1;

st->candidate = -1;

st->pathLen = 0;

st->swapActive = false;

DebugSet(dbg, "HEAPIFY", 1, "Start sift-down at selected root");

dbg->i = rootIndex;

dbg->size = h->size;

dbg->vI = h->data[rootIndex];

LogPush(log, "HEAPIFY at root=%d", rootIndex);

}

static void StartBuild(Heap *h, OpState *st, LogPanel *log, DebugState *dbg) {

if (h->size <= 1) {

LogPush(log, "Build-heap skipped: size <= 1");

return;

}

st->op = OP_BUILD;

st->running = true;

st->frame = 0;

st->stage = 0;

st->root = h->size / 2 - 1;

st->current = st->root;

st->activeA = st->root;

st->activeB = -1;

st->candidate = -1;

st->pathLen = 0;

st->swapActive = false;

DebugSet(dbg, "BUILD_HEAP", 2, "Start from last internal node and sift-down");

dbg->i = st->root;

dbg->size = h->size;

dbg->vI = h->data[st->root];

LogPush(log, "BUILD-HEAP from last internal node %d down to root", st->root);

}

static void ContinueSiftUp(Heap *h, OpState *st, LogPanel *log, DebugState *dbg) {

if (st->current <= 0) {

st->running = false;

st->activeA = -1;

st->activeB = -1;

st->candidate = -1;

DebugSet(dbg, "INSERT", 9, "Reached root; sift-up complete");

dbg->i = st->current;

dbg->size = h->size;

LogPush(log, "Insert complete: heap property restored");

return;

}

int parent = (st->current - 1) / 2;

st->activeA = st->current;

st->activeB = parent;

DebugSet(dbg, "INSERT", 6, "Compute parent and compare child vs parent");

dbg->i = st->current;

dbg->parent = parent;

dbg->size = h->size;

dbg->vI = h->data[st->current];

dbg->vParent = h->data[parent];

if (h->data[st->current] > h->data[parent]) {

DebugSet(dbg, "INSERT", 8, "Child bigger than parent -> swap and bubble up");

LogPush(log, "sift-up compare child[%d]=%d > parent[%d]=%d => swap",

st->current, h->data[st->current], parent, h->data[parent]);

StartSwapAnim(h, st, st->current, parent, parent);

if (st->pathLen < 16) st->path[st->pathLen++] = parent;

} else {

DebugSet(dbg, "INSERT", 7, "Child <= parent -> stop");

LogPush(log, "sift-up compare child[%d]=%d <= parent[%d]=%d => stop",

st->current, h->data[st->current], parent, h->data[parent]);

st->running = false;

st->activeA = -1;

st->activeB = -1;

st->candidate = -1;

}

}

static bool ContinueSiftDown(Heap *h, OpState *st, LogPanel *log, DebugState *dbg) {

int i = st->current;

int left = 2 * i + 1;

int right = 2 * i + 2;

int largest = i;

st->activeA = i;

st->activeB = -1;

st->candidate = -1;

DebugSet(dbg, "SIFT_DOWN", 2, "Inspect children and choose largest");

dbg->i = i;

dbg->size = h->size;

dbg->vI = h->data[i];

if (left < h->size) {

dbg->left = left;

dbg->vLeft = h->data[left];

if (h->data[left] > h->data[largest]) {

largest = left;

st->candidate = left;

DebugSet(dbg, "SIFT_DOWN", 4, "Left child is current largest candidate");

}

}

if (right < h->size && h->data[right] > h->data[largest]) {

largest = right;

st->candidate = right;

dbg->right = right;

dbg->vRight = h->data[right];

DebugSet(dbg, "SIFT_DOWN", 5, "Right child beats current largest candidate");

} else if (right < h->size) {

dbg->right = right;

dbg->vRight = h->data[right];

}

if (largest != i) {

dbg->largest = largest;

dbg->vLargest = h->data[largest];

DebugSet(dbg, "SIFT_DOWN", 6, "Largest child > parent -> swap and continue");

LogPush(log, "sift-down at[%d]=%d, best child[%d]=%d => swap",

i, h->data[i], largest, h->data[largest]);

st->activeB = largest;

StartSwapAnim(h, st, i, largest, largest);

if (st->pathLen < 16) st->path[st->pathLen++] = largest;

return true;

}

DebugSet(dbg, "SIFT_DOWN", 7, "No child greater than parent -> stop");

LogPush(log, "sift-down at[%d]=%d has no larger child => stop", i, h->data[i]);

return false;

}

static void UpdateOp(Heap *h, OpState *st, LogPanel *log, DebugState *dbg, int framesPerStep) {

if (st->swapActive) {

DebugSet(dbg, st->running ? OpTitle(st->op) : "MANUAL_SWAP", 3, "Animating swap between two indices");

dbg->i = st->swapI;

dbg->child = st->swapJ;

dbg->size = h->size;

float frames = (float)framesPerStep;

if (frames < 1.0f) frames = 1.0f;

st->swapT += 1.0f / frames;

if (st->swapT >= 1.0f) {

HeapSwap(h, st->swapI, st->swapJ);

st->swapActive = false;

st->swapT = 0.0f;

st->current = st->nextCurrent;

DebugSet(dbg, st->running ? OpTitle(st->op) : "MANUAL_SWAP", 4, "Swap committed");

if (!st->running) {

st->activeA = -1;

st->activeB = -1;

st->candidate = -1;

}

}

return;

}

if (!st->running) return;

st->frame++;

if (st->frame < framesPerStep) return;

st->frame = 0;

if (st->op == OP_INSERT) {

ContinueSiftUp(h, st, log, dbg);

return;

}

if (st->op == OP_POP) {

if (st->stage == 0) {

int last = h->size - 1;

h->data[0] = h->data[last];

h->size--;

st->stage = 1;

st->current = 0;

DebugSet(dbg, "POP_MAX", 3, "Root replaced; begin sift-down");

dbg->i = 0;

dbg->size = h->size;

LogPush(log, "root replaced with last value; heap size is now %d", h->size);

if (h->size == 0) {

st->running = false;

st->activeA = -1;

st->activeB = -1;

LogPush(log, "Pop complete: heap is empty");

}

return;

}

bool moved = ContinueSiftDown(h, st, log, dbg);

if (!moved) {

st->running = false;

st->activeA = -1;

st->activeB = -1;

st->candidate = -1;

DebugSet(dbg, "POP_MAX", 5, "Pop complete");

LogPush(log, "Pop complete: returned %d", st->tempValue);

}

return;

}

if (st->op == OP_HEAPIFY) {

bool moved = ContinueSiftDown(h, st, log, dbg);

if (!moved) {

st->running = false;

st->activeA = -1;

st->activeB = -1;

st->candidate = -1;

DebugSet(dbg, "HEAPIFY", 2, "Heapify complete for selected root");

LogPush(log, "Heapify complete at root=%d", st->root);

}

return;

}

if (st->op == OP_BUILD) {

DebugSet(dbg, "BUILD_HEAP", 3, "Sift-down current internal node");

bool moved = ContinueSiftDown(h, st, log, dbg);

if (!moved) {

st->root--;

if (st->root < 0) {

st->running = false;

st->activeA = -1;

st->activeB = -1;

st->candidate = -1;

DebugSet(dbg, "BUILD_HEAP", 5, "Build complete");

LogPush(log, "Build-heap complete");

} else {

st->current = st->root;

st->activeA = st->root;

st->pathLen = 0;

DebugSet(dbg, "BUILD_HEAP", 4, "Move to previous internal node");

dbg->i = st->root;

LogPush(log, "Build-heap next root=%d", st->root);

}

}

}

}

static void DrawArrayView(const Heap *h, Rectangle area, const OpState *st, const DragState *drag) {

DrawRectangleRounded(area, 0.03f, 8, Fade((Color){18, 26, 36, 255}, 0.95f));

DrawRectangleRoundedLines(area, 0.03f, 8, Fade(SKYBLUE, 0.45f));

DrawText("Array Representation (contiguous memory)", (int)area.x + 14, (int)area.y + 10, 20, RAYWHITE);

Rectangle sampleCell = ArrayCellRect(area, 0);

int indexFs = (sampleCell.height < 34) ? 11 : 14;

int valueFs = (int)(sampleCell.height * 0.42f);

if (valueFs < 14) valueFs = 14;

if (valueFs > 26) valueFs = 26;

int parentFs = (sampleCell.height < 34) ? 10 : 13;

for (int i = 0; i < MAX_HEAP; i++) {

Rectangle c = ArrayCellRect(area, i);

bool inHeap = i < h->size;

bool active = i == st->activeA || i == st->activeB;

bool candidate = i == st->candidate;

bool hiddenForSwap = st->swapActive && (i == st->swapI || i == st->swapJ);

bool hiddenForDrag = drag && drag->active && i == drag->from;

Color border = Fade((Color){105, 132, 156, 255}, 0.5f);

Color fill = Fade((Color){31, 44, 58, 255}, 0.65f);

if (inHeap) {

float norm = (h->data[i] + 1) / 101.0f;

fill = Fade(HeatColor(norm), 0.24f);

}

if (candidate) border = ORANGE;

if (active) border = YELLOW;

if (drag && drag->active && i == drag->hover && i < h->size) border = LIME;

DrawRectangleRounded(c, 0.15f, 4, fill);

DrawRectangleRoundedLines(c, 0.15f, 4, border);

char ibuf[24];

snprintf(ibuf, sizeof(ibuf), "[%d]", i);

DrawText(ibuf, (int)c.x + 6, (int)c.y + 5, indexFs, Fade(RAYWHITE, 0.7f));

if (inHeap && !hiddenForSwap && !hiddenForDrag) {

char vbuf[32];

snprintf(vbuf, sizeof(vbuf), "%d", h->data[i]);

int tw = MeasureText(vbuf, valueFs);

int vy = (int)(c.y + c.height * 0.5f - valueFs * 0.45f);

DrawText(vbuf, (int)(c.x + c.width * 0.5f - tw * 0.5f), vy, valueFs, RAYWHITE);

if (i > 0) {

int p = (i - 1) / 2;

char rbuf[32];

snprintf(rbuf, sizeof(rbuf), "p=%d", p);

int pw = MeasureText(rbuf, parentFs);

DrawText(rbuf, (int)(c.x + c.width - pw - 6), (int)c.y + 5, parentFs, Fade(SKYBLUE, 0.8f));

}

}

}

if (st->swapActive) {

Rectangle a = ArrayCellRect(area, st->swapI);

Rectangle b = ArrayCellRect(area, st->swapJ);

float t = st->swapT;

Vector2 ac = {a.x + a.width * 0.5f, a.y + a.height * 0.5f};

Vector2 bc = {b.x + b.width * 0.5f, b.y + b.height * 0.5f};

Vector2 pAB = {ac.x + (bc.x - ac.x) * t, ac.y + (bc.y - ac.y) * t};

Vector2 pBA = {bc.x + (ac.x - bc.x) * t, bc.y + (ac.y - bc.y) * t};

Rectangle moving = {0, 0, a.width * 0.8f, a.height * 0.72f};

moving.x = pAB.x - moving.width * 0.5f;

moving.y = pAB.y - moving.height * 0.5f;

DrawRectangleRounded(moving, 0.2f, 4, Fade(YELLOW, 0.25f));

DrawRectangleRoundedLines(moving, 0.2f, 4, YELLOW);

char va[24];

snprintf(va, sizeof(va), "%d", st->swapValI);

int mt = MeasureText(va, valueFs);

DrawText(va, (int)(moving.x + moving.width * 0.5f - mt * 0.5f), (int)(moving.y + moving.height * 0.5f - valueFs * 0.45f), valueFs, RAYWHITE);

moving.x = pBA.x - moving.width * 0.5f;

moving.y = pBA.y - moving.height * 0.5f;

DrawRectangleRounded(moving, 0.2f, 4, Fade(ORANGE, 0.24f));

DrawRectangleRoundedLines(moving, 0.2f, 4, ORANGE);

char vb[24];

snprintf(vb, sizeof(vb), "%d", st->swapValJ);

mt = MeasureText(vb, valueFs);

DrawText(vb, (int)(moving.x + moving.width * 0.5f - mt * 0.5f), (int)(moving.y + moving.height * 0.5f - valueFs * 0.45f), valueFs, RAYWHITE);

}

if (drag && drag->active) {

Vector2 mouse = GetMousePosition();

Rectangle moving = {mouse.x - sampleCell.width * 0.4f, mouse.y - sampleCell.height * 0.36f, sampleCell.width * 0.8f, sampleCell.height * 0.72f};

DrawRectangleRounded(moving, 0.2f, 4, Fade(LIME, 0.28f));

DrawRectangleRoundedLines(moving, 0.2f, 4, LIME);

char txt[24];

snprintf(txt, sizeof(txt), "%d", drag->value);

int tw = MeasureText(txt, valueFs);

DrawText(txt, (int)(moving.x + moving.width * 0.5f - tw * 0.5f), (int)(moving.y + moving.height * 0.5f - valueFs * 0.45f), valueFs, RAYWHITE);

}

}

static void DrawTreeView(const Heap *h, Rectangle area, const OpState *st, const DragState *drag) {

DrawRectangleRounded(area, 0.03f, 8, Fade((Color){18, 26, 36, 255}, 0.95f));

DrawRectangleRoundedLines(area, 0.03f, 8, Fade(LIME, 0.3f));

DrawText("Binary Tree Topology (implicit pointers)", (int)area.x + 14, (int)area.y + 10, 20, RAYWHITE);

for (int i = 0; i < h->size; i++) {

int l = 2 * i + 1;

int r = 2 * i + 2;

Vector2 p = NodePos(i, area, h->size);

if (l < h->size) {

Vector2 c = NodePos(l, area, h->size);

DrawLineEx(p, c, 2.0f, Fade(SKYBLUE, 0.45f));

}

if (r < h->size) {

Vector2 c = NodePos(r, area, h->size);

DrawLineEx(p, c, 2.0f, Fade(SKYBLUE, 0.45f));

}

}

for (int i = 0; i < h->size; i++) {

Vector2 p = NodePos(i, area, h->size);

bool active = i == st->activeA || i == st->activeB;

bool candidate = i == st->candidate;

bool hiddenForSwap = st->swapActive && (i == st->swapI || i == st->swapJ);

bool hiddenForDrag = drag && drag->active && i == drag->from;

bool onPath = false;

for (int k = 0; k < st->pathLen; k++) {

if (st->path[k] == i) {

onPath = true;

break;

}

}

float norm = (h->data[i] + 1) / 101.0f;

Color fill = Fade(HeatColor(norm), 0.3f);

Color border = Fade(RAYWHITE, 0.75f);

if (onPath) border = GOLD;

if (candidate) border = ORANGE;

if (active) border = YELLOW;

if (drag && drag->active && i == drag->hover && i < h->size) border = LIME;

DrawCircleV(p, 24, (hiddenForSwap || hiddenForDrag) ? Fade(fill, 0.2f) : fill);

DrawCircleLines((int)p.x, (int)p.y, 24, border);

DrawCircleLines((int)p.x, (int)p.y, 23, border);

if (!hiddenForSwap && !hiddenForDrag) {

char vbuf[24];

snprintf(vbuf, sizeof(vbuf), "%d", h->data[i]);

int tw = MeasureText(vbuf, 22);

DrawText(vbuf, (int)(p.x - tw / 2), (int)p.y - 11, 22, RAYWHITE);

}

char ibuf[16];

snprintf(ibuf, sizeof(ibuf), "%d", i);

DrawText(ibuf, (int)p.x - 8, (int)p.y + 26, 14, Fade(SKYBLUE, 0.9f));

}

if (st->swapActive) {

Vector2 a = NodePos(st->swapI, area, h->size);

Vector2 b = NodePos(st->swapJ, area, h->size);

float t = st->swapT;

Vector2 pAB = {a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t};

Vector2 pBA = {b.x + (a.x - b.x) * t, b.y + (a.y - b.y) * t};

DrawCircleV(pAB, 22, Fade(YELLOW, 0.26f));

DrawCircleLines((int)pAB.x, (int)pAB.y, 22, YELLOW);

char va[24];

snprintf(va, sizeof(va), "%d", st->swapValI);

int twa = MeasureText(va, 21);

DrawText(va, (int)pAB.x - twa / 2, (int)pAB.y - 10, 21, RAYWHITE);

DrawCircleV(pBA, 22, Fade(ORANGE, 0.25f));

DrawCircleLines((int)pBA.x, (int)pBA.y, 22, ORANGE);

char vb[24];

snprintf(vb, sizeof(vb), "%d", st->swapValJ);

int twb = MeasureText(vb, 21);

DrawText(vb, (int)pBA.x - twb / 2, (int)pBA.y - 10, 21, RAYWHITE);

}

if (drag && drag->active && drag->fromTree) {

Vector2 mouse = GetMousePosition();

DrawCircleV(mouse, 22, Fade(LIME, 0.28f));

DrawCircleLines((int)mouse.x, (int)mouse.y, 22, LIME);

char txt[24];

snprintf(txt, sizeof(txt), "%d", drag->value);

int tw = MeasureText(txt, 21);

DrawText(txt, (int)mouse.x - tw / 2, (int)mouse.y - 10, 21, RAYWHITE);

}

DrawText("edge: parent -> child", (int)area.x + 20, (int)(area.y + area.height - 36), 16, Fade(RAYWHITE, 0.65f));

}

static bool HeapPropertyHolds(const Heap *h, int *badParent, int *badChild) {

for (int i = 1; i < h->size; i++) {

int p = (i - 1) / 2;

if (h->data[p] < h->data[i]) {

if (badParent) *badParent = p;

if (badChild) *badChild = i;

return false;

}

}

return true;

}

static void DrawInspector(const Heap *h, Rectangle area, const OpState *st, const LogPanel *log, int stepFrames) {

DrawRectangleRounded(area, 0.03f, 8, Fade((Color){20, 28, 38, 255}, 0.97f));

DrawRectangleRoundedLines(area, 0.03f, 8, Fade(ORANGE, 0.4f));

DrawText("Heap + Priority Queue Inspector", (int)area.x + 14, (int)area.y + 10, 22, RAYWHITE);

char status[128];

const char *opName = "IDLE";

if (st->op == OP_INSERT) opName = "INSERT";

else if (st->op == OP_POP) opName = "POP-MAX";

else if (st->op == OP_HEAPIFY) opName = "HEAPIFY";

else if (st->op == OP_BUILD) opName = "BUILD-HEAP";

snprintf(status, sizeof(status), "op=%s | running=%s | size=%d | step-delay=%d frames",

opName, st->running ? "yes" : "no", h->size, stepFrames);

DrawText(status, (int)area.x + 14, (int)area.y + 42, 18, Fade(RAYWHITE, 0.82f));

if (st->swapActive) {

DrawText("swap animation: active", (int)area.x + 14, (int)area.y + 62, 16, Fade(YELLOW, 0.9f));

}

(void)h;

DrawText("Operation trace (newest at bottom):", (int)area.x + 14, (int)area.y + 92, 18, Fade(SKYBLUE, 0.9f));

int top = (int)area.y + 120;

int maxLines = (int)((area.height - 130) / 18);

if (maxLines < 0) maxLines = 0;

int start = log->count - maxLines;

if (start < 0) start = 0;

for (int i = start; i < log->count; i++) {

int row = i - start;

DrawText(log->lines[i], (int)area.x + 20, top + row * 18, 17, Fade(RAYWHITE, 0.85f));

}

}

static void DrawCodeDebugger(Rectangle area, const OpState *st, const DebugState *dbg) {

static const char *insertCode[] = {

"void insert(int x) {",

" A[size] = x;",

" i = size;",

" size++;",

" while (i > 0) {",

" p = (i - 1) / 2;",

" if (A[i] <= A[p]) break;",

" swap(A[i], A[p]);",

" i = p;",

" }",

"}"

};

static const char *siftDownCode[] = {

"void siftDown(int i) {",

" while (true) {",

" largest = i;",

" if (left(i) < size && A[left(i)] > A[largest]) largest = left(i);",

" if (right(i) < size && A[right(i)] > A[largest]) largest = right(i);",

" if (largest == i) break;",

" swap(A[i], A[largest]);",

" i = largest;",

" }",

"}"

};