feat: move next part should respect quickloop bounds

Author: Mint de Wit

packages/job-worker/src/playout/model/PlayoutModel.ts

@@ -167,6 +167,14 @@ export interface PlayoutModelReadonly extends StudioPlayoutModelBaseReadonly {
 	 */
 	getRundownIds(): RundownId[]
 
+	/**
+	 * Returns any segmentId's that are found between 2 quickloop markers, none will be returned if
+	 * the end is before the start.
+	 * @param start A quickloop marker
+	 * @param end A quickloop marker
+	 */
+	getSegmentsBetweenQuickLoopMarker(start: QuickLoopMarker, end: QuickLoopMarker): SegmentId[]
+
 	/**
 	 * Search for a PieceInstance in the RundownPlaylist
 	 * @param id Id of the PieceInstance
@@ -345,14 +353,6 @@ export interface PlayoutModel extends PlayoutModelReadonly, StudioPlayoutModelBa
 	 */
 	setQuickLoopMarker(type: 'start' | 'end', marker: QuickLoopMarker | null): void
 
-	/**
-	 * Returns any segmentId's that are found between 2 quickloop markers, none will be returned if
-	 * the end is before the start.
-	 * @param start A quickloop marker
-	 * @param end A quickloop marker
-	 */
-	getSegmentsBetweenQuickLoopMarker(start: QuickLoopMarker, end: QuickLoopMarker): SegmentId[]
-
 	calculatePartTimings(
 		fromPartInstance: PlayoutPartInstanceModel | null,
 		toPartInstance: PlayoutPartInstanceModel,

packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts

@@ -240,6 +240,10 @@ export class PlayoutModelReadonlyImpl implements PlayoutModelReadonly {
 		return undefined
 	}
 
+	getSegmentsBetweenQuickLoopMarker(start: QuickLoopMarker, end: QuickLoopMarker): SegmentId[] {
+		return this.quickLoopService.getSegmentsBetweenMarkers(start, end)
+	}
+
 	#isMultiGatewayMode: boolean | undefined = undefined
 	public get isMultiGatewayMode(): boolean {
 		if (this.#isMultiGatewayMode === undefined) {
@@ -830,10 +834,6 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 		this.#playlistHasChanged = true
 	}
 
-	getSegmentsBetweenQuickLoopMarker(start: QuickLoopMarker, end: QuickLoopMarker): SegmentId[] {
-		return this.quickLoopService.getSegmentsBetweenMarkers(start, end)
-	}
-
 	/** Notifications */
 
 	async getAllNotifications(

packages/job-worker/src/playout/model/services/QuickLoopService.ts

@@ -8,7 +8,7 @@ import {
 } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
 import { ReadonlyObjectDeep } from 'type-fest/source/readonly-deep'
 import { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
-import { RundownId, SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
+import { PartId, RundownId, SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { DBSegment } from '@sofie-automation/corelib/dist/dataModel/Segment'
 import { PlayoutPartInstanceModel } from '../PlayoutPartInstanceModel'
 import { JobContext } from '../../../jobs'
@@ -150,6 +150,7 @@ export class QuickLoopService {
 	}
 
 	getSegmentsBetweenMarkers(startMarker: QuickLoopMarker, endMarker: QuickLoopMarker): SegmentId[] {
+		// note - this function could be refactored to call getPartsBetweenMarkers instead but it will be less efficient
 		const segments = this.playoutModel.getAllOrderedSegments()
 		const segmentIds: SegmentId[] = []
 
@@ -201,6 +202,71 @@ export class QuickLoopService {
 		return segmentIds
 	}
 
+	getPartsBetweenMarkers(
+		startMarker: QuickLoopMarker,
+		endMarker: QuickLoopMarker
+	): { parts: PartId[]; segments: SegmentId[] } {
+		const parts = this.playoutModel.getAllOrderedParts()
+		const segmentIds: SegmentId[] = []
+		const partIds: PartId[] = []
+
+		let passedStart = false
+		let seenLastRundown = false
+		let seenLastSegment = false
+
+		for (const p of parts) {
+			if (
+				!passedStart &&
+				((startMarker.type === QuickLoopMarkerType.PART && p._id === startMarker.id) ||
+					(startMarker.type === QuickLoopMarkerType.SEGMENT && p.segmentId === startMarker.id) ||
+					(startMarker.type === QuickLoopMarkerType.RUNDOWN && p.rundownId === startMarker.id) ||
+					startMarker.type === QuickLoopMarkerType.PLAYLIST)
+			) {
+				// the start marker is this part, this is the first part in the loop, or this is the first segment that is in the loop
+				// segments from here on are included in the loop
+				passedStart = true
+			}
+
+			if (endMarker.type === QuickLoopMarkerType.RUNDOWN) {
+				// last rundown needs to be inclusive so we need to break once the rundownId is not equal to segment's rundownId
+				if (p.rundownId === endMarker.id) {
+					if (!passedStart) {
+						// we hit the end before the start so quit now:
+						break
+					}
+					seenLastRundown = true
+				} else if (seenLastRundown) {
+					// we have passed the last rundown
+					break
+				}
+			} else if (endMarker.type === QuickLoopMarkerType.SEGMENT) {
+				// last segment needs to be inclusive so we need to break once the segmentId changes but not before
+				if (p.segmentId === endMarker.id) {
+					if (!passedStart) {
+						// we hit the end before the start so quit now:
+						break
+					}
+					seenLastSegment = true
+				} else if (seenLastSegment) {
+					// we have passed the last rundown
+					break
+				}
+			}
+
+			if (passedStart) {
+				if (segmentIds.slice(-1)[0] !== p.segmentId) segmentIds.push(p.segmentId)
+				partIds.push(p._id)
+			}
+
+			if (endMarker.type === QuickLoopMarkerType.PART && p._id === endMarker.id) {
+				// the endMarker is this part so we can quit now
+				break
+			}
+		}
+
+		return { parts: partIds, segments: segmentIds }
+	}
+
 	private areMarkersFlipped(startPosition: MarkerPosition, endPosition: MarkerPosition) {
 		return compareMarkerPositions(startPosition, endPosition) < 0
 	}

packages/job-worker/src/playout/moveNextPart.ts

@@ -6,12 +6,14 @@ import { sortPartsInSortedSegments } from '@sofie-automation/corelib/dist/playou
 import { logger } from '../logging'
 import { SegmentOrphanedReason } from '@sofie-automation/corelib/dist/dataModel/Segment'
 import { ReadonlyDeep } from 'type-fest'
+import { QuickLoopService } from './model/services/QuickLoopService'
 
 export function selectNewPartWithOffsets(
 	_context: JobContext,
 	playoutModel: PlayoutModelReadonly,
 	partDelta: number,
-	segmentDelta: number
+	segmentDelta: number,
+	ignoreQuickLoop = false
 ): ReadonlyDeep<DBPart> | null {
 	const playlist = playoutModel.playlist
 
@@ -23,8 +25,22 @@ export function selectNewPartWithOffsets(
 	if (!refPart || !refPartInstance)
 		throw new Error(`RundownPlaylist "${playlist._id}" has no next and no current part!`)
 
-	const rawSegments = playoutModel.getAllOrderedSegments()
-	const rawParts = playoutModel.getAllOrderedParts()
+	let rawSegments = playoutModel.getAllOrderedSegments()
+	let rawParts = playoutModel.getAllOrderedParts()
+	let allowWrap = false // whether we should wrap to the first part if the curIndex + delta exceeds the total number of parts
+
+	const quickLoopService = new QuickLoopService(_context, playoutModel)
+	if (!ignoreQuickLoop && playlist.quickLoop?.start && playlist.quickLoop.end) {
+		const partsInQuickloop = quickLoopService.getPartsBetweenMarkers(
+			playlist.quickLoop.start,
+			playlist.quickLoop.end
+		)
+		if (partsInQuickloop.parts.includes(refPart._id)) {
+			rawParts = rawParts.filter((p) => partsInQuickloop.parts.includes(p._id))
+			rawSegments = rawSegments.filter((s) => partsInQuickloop.segments.includes(s.segment._id))
+			allowWrap = true
+		}
+	}
 
 	if (segmentDelta) {
 		// Ignores horizontalDelta
@@ -37,7 +53,14 @@ export function selectNewPartWithOffsets(
 		const refSegmentIndex = considerSegments.findIndex((s) => s.segment._id === refPart.segmentId)
 		if (refSegmentIndex === -1) throw new Error(`Segment "${refPart.segmentId}" not found!`)
 
-		const targetSegmentIndex = refSegmentIndex + segmentDelta
+		let targetSegmentIndex = refSegmentIndex + segmentDelta
+		if (allowWrap) {
+			targetSegmentIndex = targetSegmentIndex % considerSegments.length
+			if (targetSegmentIndex < 0) {
+				// -1 becomes last segment
+				targetSegmentIndex = considerSegments.length + targetSegmentIndex
+			}
+		}
 		const targetSegment = considerSegments[targetSegmentIndex]
 		if (!targetSegment) return null
 
@@ -64,7 +87,6 @@ export function selectNewPartWithOffsets(
 			}
 		}
 
-		// TODO - looping playlists
 		if (selectedPart) {
 			// Switch to that part
 			return selectedPart
@@ -88,7 +110,11 @@ export function selectNewPartWithOffsets(
 		}
 
 		// Get the past we are after
-		const targetPartIndex = refPartIndex + partDelta
+		let targetPartIndex = allowWrap ? (refPartIndex + partDelta) % playabaleParts.length : refPartIndex + partDelta
+		if (allowWrap) {
+			targetPartIndex = targetPartIndex % playabaleParts.length
+			if (targetPartIndex < 0) targetPartIndex = playabaleParts.length + targetPartIndex // -1 becomes last part
+		}
 		let targetPart = playabaleParts[targetPartIndex]
 		if (targetPart && targetPart._id === currentPartInstance?.part._id) {
 			// Cant go to the current part (yet)