Chronological sequence of events with a running commentary *ahead* of the event - algorithm

Question

I apologise in advance if this is somewhat vague, but I'm lacking even the basic idea of how to approach this - including even knowing whether there is a proper term to search for.
I am trying to code a table-driven system of animating chronological events, where descriptive commentary is also pulled out of the table but that commentary is issued ahead of the actual event animation, so not like sub-titles, which appear synchronous with the event on screen.
To explain further:
Given a table with
Seq | Event | Start | End | Pace
1 | Walk up to A | | A | Walk
2 | Stand at A | A | | Stand
3 | Walk from A to B | A | B | Walk
4 | Run from B to C | B | C | Run
5 | Stand at C, turn left | C | | Stand
6 | Turn left at C and walk to D | C | D | Walk
7 | At D quickly spin around your own axis | D | | Stand
8 | Run back to A | D | A | Run
And so on. The speed of the movements and duration of standing in place or spinning around your axis are set by variable properties - some people are faster than others, after all.
The point is that the commentary - essentialy the text in the Event column, will be read before the actual movement.
Creating a sequence like this
Seq | Commentary | Movement
0 | See the toon walk up to A and stop there | animation of movement to A from random point
1 | They now stand and will move from A to B | toon stands in place
2 | at B they will run to C | toon is walking towards B
3 | at C they will turn left | toon is running towards C
4 | then they walk from C to D | toon is still running towards C
5 | at D they spin around their axis | toon is walking towards D
6 | after spin they will run back to A | toon does the spin at D,
| | based on timing they are running back to D
I've tried to include some edge cases here. For example, where an even is so short that the duration of the commentary would be longer than the duration of the animation, enforcing an immediate back-to-back reading of two commentaries ahead of the movement.
Thinking of systems like video and auditor editors, with their multi-track approach, I thought I could something similar. I would "pre-compile" the sequence table into a timeline and then create the commentary track by timeshifting it "to the left" (i.e. backwards in time, as it were). The playback would present the two streams.
But I utterly and totally lack the knowledge to do that and am not even sure what to look into, so I can learn. Is this some form of state machine? An event loop?
The system will ultimately be developed in C#/.NET. Xamarin to be precise, to allow it to run on both Android and iOS. The animation code actually exists, to the extend of having the toon walk, run, stand between points on a grid (where the points boil down to coordinates). Audio commentary, as in reading the event text is also straight-forward nowadays (there's even device-independent PCLs).
It's the timing and synchronisation that I am utterly lost with! Creating that time stream between offset animation and audio out of the information in the table (and properties). I looked into things like state machines and graph theory, but frankly a lot of that went over my head.
What should I even research here? I'd be more than happy with an answer of "what you're trying to do is called XXX, google it for the algorithms" and "read THIS to find out more about doing XXX and YYY" and "THIS describes the algorithms (even if in another language or not language at all) to do ZZZ".

Answer 1

Let's assume you can calculate the lengths of the animations and the lengths of the commentaries ahead.
action | length in sec
a1 | 5
a2 | 2
a3 | 3
commentary | length in sec
c1 | 2
c2 | 10
c3 | 5
Create a schedule for the actions first:
a-schedule | start | end
a1 | 0 | 5
a2 | 5 | 7
a3 | 7 | 10
Now create a schedule for the commentaries by adjusting the end time of each commentary to the start time of the appropriate action:
c-schedule | start | end
c1 | -2 | 0
c2 | -5 | 5
c3 | 2 | 7
Now iterate through on this last table in backwards from the second to last element and do the following:
for(int x=c.length-2;x>=0;x--) {
if (c[x].end> c[x+1].start) {
c[x].end-= c[x].end- c[x+1].start;
c[x].start-= c[x].end- c[x+1].start;
}
}
It will result the following table:
c-schedule | start | end
c1 | -10 | -8
c2 | -8 | 2
c3 | 2 | 7
Each commentaries will be finished before the corresponding action however - if most of the commentaries are last longer than the actions - they could happen way before. But if there are several actions which are longer that their commentaries then the commentary can gain on the action there.
The table shows that you have to start playing the first commentary 10 seconds before start playing the first action. You can shift both of these values if you want a zero-based schedule.