feat(web): align double-elimination winner connector rails
This commit is contained in:
1 parent
61f1db0e6a
commit
8ec9edc35f
5 files changed
+866
-44
No files matched your search
@@ -17,6 +17,8 @@ export const DOUBLE_ELIMINATION_BRACKET_GEOMETRY = {
|
||||
boardPadding: 12,
|
||||
columnWidth: 228,
|
||||
columnGap: 40,
|
||||
// Matches the widest focused connector underlay so parallel routes stay legible.
|
||||
connectorRailClearance: 5,
|
||||
cardBorderWidth: SERIES_SCORE_CARD_GEOMETRY.borderWidth,
|
||||
cardHeight: SERIES_SCORE_CARD_GEOMETRY.height,
|
||||
cardHeaderHeight: SERIES_SCORE_CARD_GEOMETRY.headerHeight,
|
||||
@@ -109,6 +111,29 @@ interface NormalizedRound {
|
||||
seriesIds: SeriesId[];
|
||||
}
|
||||
|
||||
interface ConnectorRoute {
|
||||
connector: SeriesConnectorView;
|
||||
key: string;
|
||||
kind: BracketConnectorKind;
|
||||
targetColumn: number;
|
||||
targetNodeY: number;
|
||||
sourceX: number;
|
||||
sourceY: number;
|
||||
targetX: number;
|
||||
targetY: number;
|
||||
}
|
||||
|
||||
interface SeparateWinnerRailChoice {
|
||||
verticalXs: [number, number];
|
||||
crossings: number;
|
||||
distanceFromBaseline: number;
|
||||
distanceFromCenter: number;
|
||||
}
|
||||
|
||||
type OrthogonalSegment =
|
||||
| { orientation: "horizontal"; fixed: number; start: number; end: number }
|
||||
| { orientation: "vertical"; fixed: number; start: number; end: number };
|
||||
|
||||
const STAGE_ORDER: Record<BracketStage, number> = {
|
||||
upper: 0,
|
||||
lower: 1,
|
||||
@@ -126,6 +151,9 @@ const CONNECTOR_SELECTION_ORDER: Record<
|
||||
"slot-b": 3,
|
||||
};
|
||||
|
||||
// A focused 5px underlay extends 2.5px from its centerline.
|
||||
const CONNECTOR_RAIL_EDGE_INSET = 3;
|
||||
|
||||
export function createDoubleEliminationBracketLayout(
|
||||
projection: DoubleEliminationCompetitionProjection,
|
||||
configuration: DoubleEliminationBracketConfiguration,
|
||||
@@ -540,56 +568,53 @@ function buildConnectors(
|
||||
nodeById: Map<SeriesId, BracketNodeLayout>,
|
||||
): BracketConnectorLayout[] | null {
|
||||
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
|
||||
const connectorsByTargetColumn = new Map<
|
||||
number,
|
||||
Array<{
|
||||
connector: SeriesConnectorView;
|
||||
source: BracketNodeLayout;
|
||||
target: BracketNodeLayout;
|
||||
}>
|
||||
>();
|
||||
const routes: ConnectorRoute[] = [];
|
||||
const routesByTargetColumn = new Map<number, ConnectorRoute[]>();
|
||||
for (const connector of projection.connectors) {
|
||||
const source = nodeById.get(connector.from.seriesId);
|
||||
const target = nodeById.get(connector.to.seriesId);
|
||||
if (!source || !target || target.column <= source.column) return null;
|
||||
const routes = connectorsByTargetColumn.get(target.column) ?? [];
|
||||
routes.push({ connector, source, target });
|
||||
connectorsByTargetColumn.set(target.column, routes);
|
||||
const route = {
|
||||
connector,
|
||||
key: connectorKey(connector),
|
||||
kind: connectorKind(connector.from.select),
|
||||
targetColumn: target.column,
|
||||
targetNodeY: target.y,
|
||||
sourceX: source.x + source.width,
|
||||
sourceY: connectorAnchorY(source, connector.from.select),
|
||||
targetX: target.x,
|
||||
targetY: targetSlotY(target, connector.to.slot),
|
||||
} satisfies ConnectorRoute;
|
||||
routes.push(route);
|
||||
const columnRoutes = routesByTargetColumn.get(target.column) ?? [];
|
||||
columnRoutes.push(route);
|
||||
routesByTargetColumn.set(target.column, columnRoutes);
|
||||
}
|
||||
|
||||
const verticalXByConnector = new Map<string, number>();
|
||||
for (const routes of connectorsByTargetColumn.values()) {
|
||||
routes.sort(
|
||||
for (const columnRoutes of routesByTargetColumn.values()) {
|
||||
columnRoutes.sort(
|
||||
(left, right) =>
|
||||
connectorAnchorY(right.source, right.connector.from.select) -
|
||||
connectorAnchorY(left.source, left.connector.from.select) ||
|
||||
targetSlotY(right.target, right.connector.to.slot) -
|
||||
targetSlotY(left.target, left.connector.to.slot) ||
|
||||
connectorKey(left.connector).localeCompare(connectorKey(right.connector)),
|
||||
right.sourceY - left.sourceY ||
|
||||
right.targetY - left.targetY ||
|
||||
left.key.localeCompare(right.key),
|
||||
);
|
||||
routes.forEach(({ connector, target }, index) => {
|
||||
columnRoutes.forEach(({ key, targetX }, index) => {
|
||||
verticalXByConnector.set(
|
||||
connectorKey(connector),
|
||||
target.x -
|
||||
key,
|
||||
targetX -
|
||||
geometry.columnGap +
|
||||
(geometry.columnGap * (index + 1)) / (routes.length + 1),
|
||||
(geometry.columnGap * (index + 1)) / (columnRoutes.length + 1),
|
||||
);
|
||||
});
|
||||
}
|
||||
if (!alignWinnerBundleRails(routes, verticalXByConnector)) return null;
|
||||
|
||||
const result: BracketConnectorLayout[] = [];
|
||||
for (const connector of projection.connectors) {
|
||||
const source = nodeById.get(connector.from.seriesId);
|
||||
const target = nodeById.get(connector.to.seriesId);
|
||||
if (!source || !target || target.column <= source.column) return null;
|
||||
|
||||
const sourceX = source.x + source.width;
|
||||
const targetX = target.x;
|
||||
const sourceY = connectorAnchorY(source, connector.from.select);
|
||||
const targetY = targetSlotY(target, connector.to.slot);
|
||||
const verticalX = verticalXByConnector.get(connectorKey(connector));
|
||||
for (const route of routes) {
|
||||
const { connector, key, kind, sourceX, sourceY, targetX, targetY } = route;
|
||||
const verticalX = verticalXByConnector.get(key);
|
||||
if (verticalX === undefined) return null;
|
||||
const kind = connectorKind(connector.from.select);
|
||||
result.push({
|
||||
fromSeriesId: connector.from.seriesId,
|
||||
select: connector.from.select,
|
||||
@@ -622,6 +647,324 @@ function buildConnectors(
|
||||
);
|
||||
}
|
||||
|
||||
function alignWinnerBundleRails(
|
||||
routes: readonly ConnectorRoute[],
|
||||
verticalXByConnector: Map<string, number>,
|
||||
): boolean {
|
||||
const winnersByTarget = new Map<SeriesId, ConnectorRoute[]>();
|
||||
for (const route of routes) {
|
||||
if (route.kind !== "winner") continue;
|
||||
const winners = winnersByTarget.get(route.connector.to.seriesId) ?? [];
|
||||
winners.push(route);
|
||||
winnersByTarget.set(route.connector.to.seriesId, winners);
|
||||
}
|
||||
|
||||
const bundles = [...winnersByTarget.values()]
|
||||
.filter(
|
||||
(winners) =>
|
||||
winners.length === 2 &&
|
||||
winners[0].connector.to.slot !== winners[1].connector.to.slot,
|
||||
)
|
||||
.sort(
|
||||
(left, right) =>
|
||||
left[0].targetColumn - right[0].targetColumn ||
|
||||
left[0].targetNodeY - right[0].targetNodeY ||
|
||||
left[0].key.localeCompare(right[0].key),
|
||||
);
|
||||
|
||||
for (const bundle of bundles) {
|
||||
const preferredX =
|
||||
bundle[0].targetX - DOUBLE_ELIMINATION_BRACKET_GEOMETRY.columnGap / 2;
|
||||
if (
|
||||
intervalsOverlap(
|
||||
bundle[0].sourceY,
|
||||
bundle[0].targetY,
|
||||
bundle[1].sourceY,
|
||||
bundle[1].targetY,
|
||||
)
|
||||
) {
|
||||
const assignment = chooseSeparateWinnerRails(
|
||||
bundle,
|
||||
routes,
|
||||
verticalXByConnector,
|
||||
preferredX,
|
||||
);
|
||||
if (!assignment) return false;
|
||||
for (const [key, verticalX] of assignment) {
|
||||
verticalXByConnector.set(key, verticalX);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const verticalX = chooseWinnerBundleRail(
|
||||
bundle,
|
||||
routes,
|
||||
verticalXByConnector,
|
||||
preferredX,
|
||||
);
|
||||
if (verticalX === null) return false;
|
||||
for (const route of bundle) verticalXByConnector.set(route.key, verticalX);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function chooseWinnerBundleRail(
|
||||
bundle: readonly ConnectorRoute[],
|
||||
routes: readonly ConnectorRoute[],
|
||||
verticalXByConnector: Map<string, number>,
|
||||
preferredX: number,
|
||||
): number | null {
|
||||
const previousRails = bundle.map((route) =>
|
||||
verticalXByConnector.get(route.key),
|
||||
);
|
||||
if (previousRails.some((verticalX) => verticalX === undefined)) return null;
|
||||
const previousScore = connectorConflictScore(routes, verticalXByConnector);
|
||||
// Keep the existing crossing budget, then favor stroke-clear rails nearest center.
|
||||
let best:
|
||||
| {
|
||||
verticalX: number;
|
||||
crossings: number;
|
||||
clearanceConflicts: number;
|
||||
distanceFromCenter: number;
|
||||
}
|
||||
| null = null;
|
||||
|
||||
for (const candidateX of winnerRailCandidates(preferredX)) {
|
||||
for (const route of bundle) {
|
||||
verticalXByConnector.set(route.key, candidateX);
|
||||
}
|
||||
const score = connectorConflictScore(routes, verticalXByConnector);
|
||||
if (
|
||||
score.overlaps !== 0 ||
|
||||
score.crossings > previousScore.crossings ||
|
||||
score.clearanceConflicts > previousScore.clearanceConflicts
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const distanceFromCenter = Math.abs(candidateX - preferredX);
|
||||
if (
|
||||
!best ||
|
||||
score.clearanceConflicts < best.clearanceConflicts ||
|
||||
(score.clearanceConflicts === best.clearanceConflicts &&
|
||||
(score.crossings < best.crossings ||
|
||||
(score.crossings === best.crossings &&
|
||||
distanceFromCenter < best.distanceFromCenter)))
|
||||
) {
|
||||
best = {
|
||||
verticalX: candidateX,
|
||||
crossings: score.crossings,
|
||||
clearanceConflicts: score.clearanceConflicts,
|
||||
distanceFromCenter,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (best) return best.verticalX;
|
||||
|
||||
bundle.forEach((route, index) => {
|
||||
const previousX = previousRails[index];
|
||||
if (previousX !== undefined) {
|
||||
verticalXByConnector.set(route.key, previousX);
|
||||
}
|
||||
});
|
||||
return null;
|
||||
}
|
||||
|
||||
function winnerRailCandidates(preferredX: number): number[] {
|
||||
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
|
||||
const maximumOffset =
|
||||
geometry.columnGap / 2 - CONNECTOR_RAIL_EDGE_INSET;
|
||||
const candidates = [preferredX];
|
||||
for (let offset = 1; offset <= maximumOffset; offset += 1) {
|
||||
candidates.push(preferredX - offset, preferredX + offset);
|
||||
}
|
||||
return candidates;
|
||||
}
|
||||
|
||||
function chooseSeparateWinnerRails(
|
||||
bundle: readonly ConnectorRoute[],
|
||||
routes: readonly ConnectorRoute[],
|
||||
verticalXByConnector: Map<string, number>,
|
||||
preferredX: number,
|
||||
): Map<string, number> | null {
|
||||
const orderedBundle = [...bundle].sort(
|
||||
(left, right) =>
|
||||
left.sourceY - right.sourceY ||
|
||||
left.targetY - right.targetY ||
|
||||
left.key.localeCompare(right.key),
|
||||
);
|
||||
const previousRails: number[] = [];
|
||||
for (const route of orderedBundle) {
|
||||
const previousX = verticalXByConnector.get(route.key);
|
||||
if (previousX === undefined) return null;
|
||||
previousRails.push(previousX);
|
||||
}
|
||||
|
||||
const previousScore = connectorConflictScore(routes, verticalXByConnector);
|
||||
const bundleKeys = new Set(orderedBundle.map(({ key }) => key));
|
||||
const candidates = [
|
||||
...new Set([...previousRails, ...winnerRailCandidates(preferredX)]),
|
||||
];
|
||||
let best: SeparateWinnerRailChoice | null = null;
|
||||
|
||||
for (const firstX of candidates) {
|
||||
for (const secondX of candidates) {
|
||||
if (firstX === secondX) continue;
|
||||
verticalXByConnector.set(orderedBundle[0].key, firstX);
|
||||
verticalXByConnector.set(orderedBundle[1].key, secondX);
|
||||
|
||||
const bundleScore = connectorConflictScore(
|
||||
routes,
|
||||
verticalXByConnector,
|
||||
bundleKeys,
|
||||
);
|
||||
const score = connectorConflictScore(routes, verticalXByConnector);
|
||||
if (
|
||||
bundleScore.overlaps !== 0 ||
|
||||
bundleScore.clearanceConflicts !== 0 ||
|
||||
score.overlaps !== 0 ||
|
||||
score.crossings > previousScore.crossings
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const distanceFromBaseline =
|
||||
Math.abs(firstX - previousRails[0]) +
|
||||
Math.abs(secondX - previousRails[1]);
|
||||
const distanceFromCenter =
|
||||
Math.abs(firstX - preferredX) + Math.abs(secondX - preferredX);
|
||||
const candidate: SeparateWinnerRailChoice = {
|
||||
verticalXs: [firstX, secondX],
|
||||
crossings: score.crossings,
|
||||
distanceFromBaseline,
|
||||
distanceFromCenter,
|
||||
};
|
||||
if (!best || compareSeparateWinnerRailChoices(candidate, best) < 0) {
|
||||
best = candidate;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
orderedBundle.forEach((route, index) => {
|
||||
verticalXByConnector.set(route.key, previousRails[index]);
|
||||
});
|
||||
if (!best) return null;
|
||||
return new Map(
|
||||
orderedBundle.map((route, index) => [route.key, best.verticalXs[index]]),
|
||||
);
|
||||
}
|
||||
|
||||
function compareSeparateWinnerRailChoices(
|
||||
left: SeparateWinnerRailChoice,
|
||||
right: SeparateWinnerRailChoice,
|
||||
): number {
|
||||
return (
|
||||
left.crossings - right.crossings ||
|
||||
left.distanceFromBaseline - right.distanceFromBaseline ||
|
||||
left.distanceFromCenter - right.distanceFromCenter ||
|
||||
left.verticalXs[0] - right.verticalXs[0] ||
|
||||
left.verticalXs[1] - right.verticalXs[1]
|
||||
);
|
||||
}
|
||||
|
||||
function connectorConflictScore(
|
||||
routes: readonly ConnectorRoute[],
|
||||
verticalXByConnector: ReadonlyMap<string, number>,
|
||||
focusedRouteKeys?: ReadonlySet<string>,
|
||||
): { crossings: number; overlaps: number; clearanceConflicts: number } {
|
||||
let crossings = 0;
|
||||
let overlaps = 0;
|
||||
let clearanceConflicts = 0;
|
||||
for (let leftIndex = 0; leftIndex < routes.length; leftIndex += 1) {
|
||||
const leftX = verticalXByConnector.get(routes[leftIndex].key);
|
||||
if (leftX === undefined) continue;
|
||||
const leftSegments = connectorRouteSegments(routes[leftIndex], leftX);
|
||||
for (
|
||||
let rightIndex = leftIndex + 1;
|
||||
rightIndex < routes.length;
|
||||
rightIndex += 1
|
||||
) {
|
||||
if (
|
||||
focusedRouteKeys &&
|
||||
!focusedRouteKeys.has(routes[leftIndex].key) &&
|
||||
!focusedRouteKeys.has(routes[rightIndex].key)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const rightX = verticalXByConnector.get(routes[rightIndex].key);
|
||||
if (rightX === undefined) continue;
|
||||
const rightSegments = connectorRouteSegments(routes[rightIndex], rightX);
|
||||
for (const left of leftSegments) {
|
||||
for (const right of rightSegments) {
|
||||
if (left.orientation === right.orientation) {
|
||||
const overlapLength =
|
||||
Math.min(left.end, right.end) - Math.max(left.start, right.start);
|
||||
if (left.fixed === right.fixed && overlapLength > 0) {
|
||||
overlaps += 1;
|
||||
} else if (
|
||||
left.orientation === "vertical" &&
|
||||
overlapLength > 0 &&
|
||||
Math.abs(left.fixed - right.fixed) <
|
||||
DOUBLE_ELIMINATION_BRACKET_GEOMETRY.connectorRailClearance
|
||||
) {
|
||||
clearanceConflicts += 1;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const horizontal =
|
||||
left.orientation === "horizontal" ? left : right;
|
||||
const vertical = left.orientation === "vertical" ? left : right;
|
||||
if (
|
||||
vertical.fixed > horizontal.start &&
|
||||
vertical.fixed < horizontal.end &&
|
||||
horizontal.fixed > vertical.start &&
|
||||
horizontal.fixed < vertical.end
|
||||
) {
|
||||
crossings += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return { crossings, overlaps, clearanceConflicts };
|
||||
}
|
||||
|
||||
function connectorRouteSegments(
|
||||
route: ConnectorRoute,
|
||||
verticalX: number,
|
||||
): OrthogonalSegment[] {
|
||||
return [
|
||||
orthogonalSegment("horizontal", route.sourceY, route.sourceX, verticalX),
|
||||
orthogonalSegment("vertical", verticalX, route.sourceY, route.targetY),
|
||||
orthogonalSegment("horizontal", route.targetY, verticalX, route.targetX),
|
||||
];
|
||||
}
|
||||
|
||||
function orthogonalSegment(
|
||||
orientation: OrthogonalSegment["orientation"],
|
||||
fixed: number,
|
||||
first: number,
|
||||
second: number,
|
||||
): OrthogonalSegment {
|
||||
return {
|
||||
orientation,
|
||||
fixed,
|
||||
start: Math.min(first, second),
|
||||
end: Math.max(first, second),
|
||||
};
|
||||
}
|
||||
|
||||
function intervalsOverlap(
|
||||
firstStart: number,
|
||||
firstEnd: number,
|
||||
secondStart: number,
|
||||
secondEnd: number,
|
||||
): boolean {
|
||||
return (
|
||||
Math.min(firstStart, firstEnd) < Math.max(secondStart, secondEnd) &&
|
||||
Math.min(secondStart, secondEnd) < Math.max(firstStart, firstEnd)
|
||||
);
|
||||
}
|
||||
|
||||
function connectorLabel(
|
||||
connector: SeriesConnectorView,
|
||||
graph: ValidatedGraph,
|
||||
|
||||
Reference in new issue
Block a user