I haven't used MPF, but I'm assuming you can drop to straight python to pulse the coils directly?

If so, writing a simple routine to increment the scores and fire the appropriate chimes simultaneously wouldn't be hard, at least it's not in pyprocgame.

Write a separate method for each scoring increment (10/100/1000) and have that control the chime. It would then work exactly as the scoring relays do in an EM.

Another question is if you've wired up the score reel switches to indicate which position the reels are on. That would simplify coding (as it did for EMs).

Something like (and this is off-the-cuff, so I haven't really thought it through, but without score reel indicator switches):

def score_10():
....if current_score % 100 == 0:
........game.coils.tens_reel.pulse()
........score_100()
....else:
........game.coils.tens_reel.pulse()
........game.coils.tens_chime.pulse()
........current_score += 10

def score_100():
....if current_score % 1000 == 0:
........game.coils.hundreds_reel.pulse()
........score_1000()
....else:
........game.coils.hundreds_reel.pulse()
........game.coils.hundreds_chime.pulse()
........current_score += 100

def score_1000():
....game.coils.thousands_reel.pulse()
....game.coils.thousands_chime.pulse()
....current_score += 1000

then you could have a main method that handles scoring, that uses an argument passed by the switch or function return for scoring you already have set up.

def add_score(amount):
....if amount == 10:
........score_10()
....elif amount == 100:
........score_100()
....elif amount == 1000:
........score_1000()

then to actually use it...

#This switch scores 100 points
def sw_rollover_switch_active(self, sw):
....if self.game.tilted == False:
........add_score(100)

This is absolutely not the only way to do it and may not even be possible with the way MPF abstractions function. I'd suggest rewriting these anyway since they don't take into account current player (you'd need to handle that however that abstraction works in MPF).

The big takeaway is that relatively simple methods can give you almost immediate coil access.

You would need to add multipliers for methods that add 500 at a clip, for example, but that is pretty trivial, and can reference these existing methods 5x (with a suitable delay between calls to allow for the physical plungers to finish moving). That's the way the score motor functions.

I see you mentioned above how you would handle multiple scoring situations - one way (again, not optimized or likely compatible with MPF, and I don't remember offhand how to write the delay method calls in pyprocgame, but this pseudocode should give you an idea):

def score_multiple(amount, multiplier, event_name):
....cancel_delayed("multiplier" + multiplier + event_name)
....if multiplier > 0:
........add_score(amount)
........multiplier -= 1
........this.delay("multiplier" + multiplier + event_name, 0.2f, score_multiple(amount, multiplier, event_name))

This creates problems when you have multiple multipliers for the same event going on simultaneously. In a regular EM, this wouldn't happen often, and if your scoring is similar-ish to what an EM could process, it won't happen (frequently) to you, either. However, if you have several switches that score 500 without holding the ball, it could easily happen through random action.