mpf 0.80.0.dev9__tar.gz → 0.80.0.dev11__tar.gz

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/.github/workflows/run_tests.yml

@@ -10,35 +10,32 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - os: windows-latest
-          python-version: 3.8
-        - os: windows-latest
-          python-version: 3.9
         - os: windows-latest
           python-version: "3.10"
         - os: windows-latest
           python-version: 3.11
         - os: windows-latest
           python-version: 3.12
-        - os: ubuntu-latest
-          python-version: 3.8
-        - os: ubuntu-latest
-          python-version: 3.9
+        - os: windows-latest
+          python-version: 3.13
+
         - os: ubuntu-latest
           python-version: "3.10"
         - os: ubuntu-latest
           python-version: 3.11
-        # Ubuntu can't run 3.12 because Pillow dependencies.
-        - os: macos-latest
-          python-version: 3.8
-        - os: macos-latest
-          python-version: 3.9
+        - os: ubuntu-latest
+          python-version: 3.12
+        - os: ubuntu-latest
+          python-version: 3.13
+
         - os: macos-latest
           python-version: "3.10"
         - os: macos-latest
           python-version: 3.11
         - os: macos-latest
           python-version: 3.12
+        - os: macos-latest
+          python-version: 3.13
 
     steps:
       - name: Checkout MPF

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpf
-Version: 0.80.0.dev9
+Version: 0.80.0.dev11
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -10,18 +10,17 @@ Keywords: pinball
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Natural Language :: English
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: Artistic Software
 Classifier: Topic :: Games/Entertainment :: Arcade
-Requires-Python: <3.13,>=3.8
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 License-File: AUTHORS.md
@@ -35,6 +34,7 @@ Requires-Dist: ruamel.yaml==0.18.6
 Requires-Dist: setuptools~=72.2.0
 Requires-Dist: sortedcontainers==2.4.0
 Requires-Dist: terminaltables==3.1.10
+Requires-Dist: Pillow==10.4.0
 Provides-Extra: crash-reporter
 Requires-Dist: requests==2.28.2; extra == "crash-reporter"
 Provides-Extra: irc

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.80.0.dev9'
+__version__ = '0.80.0.dev11'
 '''The full version of MPF.'''
 
 __short_version__ = '0.80'
@@ -19,7 +19,7 @@ __short_version__ = '0.80'
 __bcp_version__ = '1.1'
 '''The version of BCP this build of MPF uses.'''
 
-__gmc_version__ = '0.1.5'
+__gmc_version__ = '0.1.6'
 '''The version of GMC this build of MPF requires.'''
 
 __config_version__ = '6'

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/config_spec.yaml

@@ -818,6 +818,7 @@ hardware:
     accelerometers: list|str|default
     i2c: list|str|default
     stepper_controllers: list|str|default
+    shaker_controllers: list|str|default
     hardware_sound_system: list|str|default
 hardware_sound_systems:
     __valid_in__: machine
@@ -1812,6 +1813,18 @@ steppers:
 stepper_position_settings:
     event: single|str|
     speed: single|int|None
+shakers:
+    __valid_in__: machine
+    __type__: device
+    default_power: single|float|0.0
+    number: single|str|
+    control_events: dict|str:subconfig(shaker_pulse_settings)|None
+    platform: single|str|None
+    platform_settings: single|dict|None
+shaker_pulse_settings:
+    action: single|enum(pulse,stop)|pulse
+    power: single|float|None
+    duration: single|template_secs|None
 spike_stepper_settings:
     homing_speed: single|int|10
     speed: single|int|20

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/core/machine.py

@@ -61,6 +61,7 @@ if MYPY:   # pragma: no cover
     from mpf.devices.digital_output import DigitalOutput    # pylint: disable-msg=cyclic-import,unused-import
     from logging import Logger  # noqa
     from mpf.devices.autofire import AutofireCoil   # pylint: disable-msg=cyclic-import,unused-import
+    from mpf.devices.shaker import Shaker   # pylint: disable-msg=cyclic-import,unused-import
     from mpf.devices.stepper import Stepper     # pylint: disable-msg=cyclic-import,unused-import
     from mpf.config_players.show_player import ShowPlayer   # pylint: disable-msg=cyclic-import,unused-import
     from mpf.devices.dmd import Dmd     # pylint: disable-msg=cyclic-import,unused-import
@@ -167,6 +168,7 @@ class MachineController(LogMixin):
             self.autofire_coils = {}                    # type: Dict[str, AutofireCoil]
             self.motors = {}                            # type: Dict[str, Motor]
             self.digital_outputs = {}                   # type: Dict[str, DigitalOutput]
+            self.shakers = {}                           # type: Dict[str, Shaker]
             self.shows = {}                             # type: Dict[str, Show]
             self.shots = {}                             # type: Dict[str, Shot]
             self.shot_groups = {}                       # type: Dict[str, ShotGroup]
@@ -444,9 +446,9 @@ class MachineController(LogMixin):
         """
         python_version_info = sys.version_info
 
-        # if not (python_version_info[0] == 3 and python_version_info[1] in (5, 6, 7, 8, 9)):
+        # if not (python_version_info[0] == 3 and python_version_info[1] in (10, 11, 12, 13)):
         #     raise AssertionError("Incorrect Python version. MPF requires "
-        #                          "Python 3.5, 3.6, 3.7, 3.8 or 3.9. You have Python {}.{}.{}."
+        #                          "Python 3.10, 3.11, 3.12 or 3.13. You have Python {}.{}.{}."
         #                          .format(python_version_info[0], python_version_info[1],
         #                                  python_version_info[2]))
 

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/core/platform.py

@@ -12,6 +12,7 @@ from mpf.core.utility_functions import Util
 
 MYPY = False
 if MYPY:   # pragma: no cover
+    from mpf.devices.shaker import Shaker   # pylint: disable-msg=cyclic-import,unused-import
     from mpf.devices.switch import Switch   # pylint: disable-msg=cyclic-import,unused-import
     from mpf.devices.stepper import Stepper     # pylint: disable-msg=cyclic-import,unused-import
     from mpf.devices.servo import Servo     # pylint: disable-msg=cyclic-import,unused-import
@@ -19,6 +20,7 @@ if MYPY:   # pragma: no cover
     from mpf.platforms.interfaces.switch_platform_interface import SwitchPlatformInterface  # pylint: disable-msg=cyclic-import,unused-import; # noqa
     from mpf.platforms.interfaces.light_platform_interface import LightPlatformInterface    # pylint: disable-msg=cyclic-import,unused-import; # noqa
     from mpf.platforms.interfaces.servo_platform_interface import ServoPlatformInterface    # pylint: disable-msg=cyclic-import,unused-import; # noqa
+    from mpf.platforms.interfaces.shaker_platform_interface import ShakerPlatformInterface    # pylint: disable-msg=cyclic-import,unused-import; # noqa
     from mpf.platforms.interfaces.segment_display_platform_interface import SegmentDisplayPlatformInterface     # pylint: disable-msg=cyclic-import,unused-import; # noqa
     from mpf.platforms.interfaces.hardware_sound_platform_interface import HardwareSoundPlatformInterface   # pylint: disable-msg=cyclic-import,unused-import; # noqa
     from mpf.platforms.interfaces.stepper_platform_interface import StepperPlatformInterface    # pylint: disable-msg=cyclic-import,unused-import; # noqa
@@ -60,6 +62,7 @@ class BasePlatform(LogMixin, metaclass=abc.ABCMeta):
         self.features['has_segment_displays'] = False
         self.features['has_hardware_sound_systems'] = True
         self.features['has_steppers'] = False
+        self.features['has_shakers'] = False
         self.features['allow_empty_numbers'] = False
         self.features['hardware_eos_repulse'] = False
 
@@ -404,6 +407,53 @@ class StepperPlatform(BasePlatform, metaclass=abc.ABCMeta):
         raise NotImplementedError
 
 
+class ShakerPlatform(BasePlatform, metaclass=abc.ABCMeta):
+
+    """Baseclass for shaker platforms in MPF."""
+
+    __slots__ = []  # type: List[str]
+
+    def __init__(self, machine):
+        """Add shaker feature."""
+        super().__init__(machine)
+        self.features['has_shakers'] = True
+
+    @classmethod
+    def get_stepper_config_section(cls) -> Optional[str]:
+        """Return config section for additional stepper config items."""
+        return None
+
+    def validate_shaker_section(self, shaker: "Shaker", config: dict) -> dict:
+        """Validate a shaker config for platform.
+
+        Args:
+        ----
+            shaker: Shaker to validate.
+            config: Config to validate.
+
+        Returns: Validated config.
+        """
+        if self.get_shaker_config_section():
+            spec = self.get_shaker_config_section()    # pylint: disable-msg=assignment-from-none
+            config = shaker.machine.config_validator.validate_config(spec, config, shaker.name)
+        elif config:
+            raise AssertionError("No platform_config supported but not empty {} for shaker {}".
+                                 format(config, shaker.name))
+
+        return config
+
+    @abc.abstractmethod
+    async def configure_shaker(self, number: str, config: dict) -> "ShakerPlatformInterface":
+        """Configure a shaker device in platform.
+
+        Args:
+        ----
+            number: Number of the shaker
+            config: Config for this shaker.
+        """
+        raise NotImplementedError
+
+
 class LightConfigColors(Enum):
 
     """Light color for LightConfig."""

mpf-0.80.0.dev11/mpf/devices/shaker.py

@@ -0,0 +1,66 @@
+"""A digital output on either a light or driver platform."""
+from typing import Union, Optional
+
+from mpf.core.delays import DelayManager
+from mpf.core.events import event_handler
+
+from mpf.core.machine import MachineController
+from mpf.core.platform import DriverConfig, LightConfig, LightConfigColors
+from mpf.core.system_wide_device import SystemWideDevice
+from mpf.platforms.interfaces.driver_platform_interface import PulseSettings, HoldSettings
+
+MYPY = False
+if MYPY:    # pragma: no cover
+    from mpf.core.platform import ShakerPlatform    # pylint: disable-msg=cyclic-import,unused-import
+    from mpf.platforms.interfaces.shaker_platform_interface import ShakerPlatformInterface  # pylint: disable-msg=cyclic-import,unused-import
+
+class Shaker(SystemWideDevice):
+
+    """A digital output on either a light or driver platform."""
+
+    config_section = 'shakers'
+    collection = 'shakers'
+    class_label = 'shaker'
+
+    __slots__ = ["hw_shaker", "type", "__dict__"]
+
+    def __init__(self, machine: MachineController, name: str) -> None:
+        """Initialize digital output."""
+        self.hw_shaker = None           # type: Optional[ShakerPlatformInterface]
+        self.platform = None            # type: Optional[ShakerPlatform]
+        super().__init__(machine, name)
+        self.delay = DelayManager(self.machine)
+
+    async def _initialize(self):
+        await super()._initialize()
+        self.platform = self.machine.get_platform_sections('shaker_controllers', self.config['platform'])
+        self.platform.assert_has_feature("shakers")
+        self.hw_shaker = await self.platform.configure_shaker(self.config['number'], self.config['platform_settings'])
+        for event, config in self.config['control_events'].items():
+            if config.get('action') == 'stop':
+                self.machine.events.add_handler(event, self.event_stop)
+                continue
+            self.machine.events.add_handler(event,
+                                            self.event_pulse,
+                                            power=config.get('power'),
+                                            duration=config['duration'].evaluate({}))
+
+    @event_handler(1)
+    def event_pulse(self, duration=None, power=None, **kwargs):
+        del kwargs
+        self.pulse(duration, power)
+
+    def pulse(self, duration=None, power=None):
+        if power is None:
+            power = self.config['default_power']
+        if not duration:
+            raise AssertionError("Shaker pulse called with no duration value")
+        self.hw_shaker.pulse(duration, power)
+
+    @event_handler(2)
+    def event_stop(self, **kwargs):
+        del kwargs
+        self.stop()
+
+    def stop(self):
+        self.hw_shaker.stop()

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/modes/carousel/code/carousel.py

@@ -57,11 +57,12 @@ class Carousel(Mode):
             elif not item.condition or item.condition.evaluate({}):
                 self._items.append(item.name)
         if not self._items:
-            self.machine.events.post("{}_items_empty".format(self.name))
-            '''event (carousel_name)_items_empty
+            self.machine.events.post("carousel_items_empty", carousel=self.name)
+            '''event carousel_items_empty
                 desc: A carousel's items are all conditional and all evaluated false.
-                    If this event is posted, the carousel mode will not be started.
-                '''
+                    If this event is posted, the carousel mode will also stop itself
+                    instead of continuing to start and run.
+            '''
             self.stop()
             return
 
@@ -97,15 +98,17 @@ class Carousel(Mode):
     def _update_highlighted_item(self, direction):
         self.debug_log("Highlighted item: " + self._get_highlighted_item())
 
-        self.machine.events.post("item_highlighted",
+        self.machine.events.post("carousel_item_highlighted",
                                  carousel=self.name,
                                  direction=direction,
                                  item=self._get_highlighted_item())
-        '''event (carousel_name)_(item)_highlighted
+        '''event carousel_item_highlighted
             desc: Player highlighted an item in a carousel. Mostly used to play shows or trigger slides.
             args:
+               carousel: The name of the carousel that posted this event.
                direction: The direction the carousel is moving. Either forwards or backwards. None on mode start.
-            '''
+               item: The name of the item that is now highlighted.
+        '''
 
     def _get_available_items(self):
         # Return the default items
@@ -143,13 +146,13 @@ class Carousel(Mode):
         self.debug_log("Selected mode: " + str(self._get_highlighted_item()))
         self._done = True
 
-        self.machine.events.post("{}_{}_selected".format(self.name, self._get_highlighted_item()))
-        '''event (carousel_name)_(item)_selected
-            desc: Player selected an item in a carousel. Can be used to trigger modes. '''
-        self.machine.events.post("{}_item_selected".format(self.name))
-        '''event (carousel_name)_item_selected
-            desc: Player selected any item in a carousel. Used to stop mode. '''
-
+        self.machine.events.post("carousel_item_selected", carousel=self.name, item=self._get_highlighted_item())
+        '''event carousel_item_selected
+            desc: Player selected an item in a carousel.
+            args:
+               carousel: The name of the carousel that posted this event.
+               item: The name of the item that is being selected.
+        '''
     def _block_enable(self, **kwargs):
         del kwargs
         self._is_blocking = True

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/modes/high_score/code/high_score.py

@@ -10,8 +10,8 @@ class HighScore(AsyncMode):
 
     """High score mode.
 
-    Mode which runs during the game ending process to check for high scores and lets the players enter their names or
-    initials.
+    Mode which runs during the game ending process to check for high scores and lets the
+    players enter their names or initials.
     """
 
     __slots__ = ["data_manager", "high_scores", "high_score_config", "pending_award", "vars"]
@@ -83,10 +83,11 @@ class HighScore(AsyncMode):
                     if not isinstance(entry[0], str) or not isinstance(entry[1], (int, float)):
                         self.log.warning("Found invalid data type in high score entry.")
                         return False
-                if len(data[category]) != len(self.config['high_score']['defaults'][category]):
+
+                category_default_scores = self.config['high_score']['defaults'][category]
+                if len(data[category]) != len(category_default_scores):
                     self.log.warning("High Score Category %s contains %s entries while defaults contain %s",
-                                     category, len(data[category]),
-                                     len(self.config['high_score']['defaults'][category]))
+                                     category, len(data[category]), len(category_default_scores))
                     return False
 
         except TypeError:
@@ -102,12 +103,10 @@ class HighScore(AsyncMode):
         for category, entries in self.high_score_config['categories'].items():
             try:
                 for position, (label, (name, value, *hs_vars)) in (
-                        enumerate(zip(entries,
-                                      self.high_scores[category]))):
+                        enumerate(zip(entries, self.high_scores[category]))):
 
-                    self.machine.variables.set_machine_var(
-                        name=category + str(position + 1) + '_label',
-                        value=label)
+                    var_name_base = category + str(position + 1) + "_"
+                    self.machine.variables.set_machine_var(name=var_name_base + 'label', value=label)
 
                     '''machine_var: (high_score_category)(position)_label
 
@@ -119,9 +118,7 @@ class HighScore(AsyncMode):
 
                     '''
 
-                    self.machine.variables.set_machine_var(
-                        name=category + str(position + 1) + '_name',
-                        value=name)
+                    self.machine.variables.set_machine_var(name=var_name_base + 'name', value=name)
 
                     '''machine_var: (high_score_category)(position)_name
 
@@ -130,9 +127,7 @@ class HighScore(AsyncMode):
 
                     '''
 
-                    self.machine.variables.set_machine_var(
-                        name=category + str(position + 1) + '_value',
-                        value=value)
+                    self.machine.variables.set_machine_var(name=var_name_base + 'value', value=value)
 
                     '''machine_var: (high_score_category)(position)_value
 
@@ -143,9 +138,7 @@ class HighScore(AsyncMode):
 
                     if len(hs_vars) > 0:
                         for k, v in hs_vars[0].items():
-                            self.machine.variables.set_machine_var(
-                                name=category + str(position + 1) + '_' + str(k),
-                                value=v)
+                            self.machine.variables.set_machine_var(name=var_name_base + str(k), value=v)
 
                     '''machine_var: (high_score_category)(position)_(variable)
 
@@ -157,11 +150,19 @@ class HighScore(AsyncMode):
             except KeyError:
                 self.high_scores[category] = list()
 
+    def _get_players(self):
+        return self.machine.game.player_list
+
     # pylint: disable-msg=too-many-nested-blocks
     async def _run(self) -> None:
         """Run high score mode."""
-        if not self.machine.game or not self.machine.game.player_list:
-            self.warning_log("High Score started but there was no game. Will not start.")
+        if not self.machine.game:
+            self.warning_log("High Score starting but there is no game. Mode will not start.")
+            return
+
+        players = self._get_players()
+        if not players:
+            self.warning_log("High Score starting but there are no players. Mode will not start.")
             return
 
         new_high_score_list = {}
@@ -178,7 +179,7 @@ class HighScore(AsyncMode):
                     new_list.append(category_high_scores)
 
             # add the players scores from this game to the list
-            for player in self.machine.game.player_list:
+            for player in players:
                 # if the player var is 0, don't add it. This prevents
                 # values of 0 being added to blank high score lists
                 if player[category_name]:
@@ -196,8 +197,8 @@ class HighScore(AsyncMode):
                     # ask player for initials if we do not know them
                     if not player.initials:
                         try:
-                            player.initials = await self._ask_player_for_initials(player, award_names[i],
-                                                                                  value, category_name)
+                            player.initials = await self._ask_player_for_initials(player.number,
+                                                                                  award_names[i], value, category_name)
                         except asyncio.TimeoutError:
                             del new_list[i]
                             # no entry when the player missed the timeout
@@ -205,7 +206,7 @@ class HighScore(AsyncMode):
                     # get vars from config
                     self._load_vars()
                     if category_name in self.vars:
-                        var_dict = self._assign_vars(category_name, player)
+                        var_dict = self._assign_vars(category_name, player.number)
                         # add high score with variables
                         new_list[i] = [player.initials, value, var_dict]
                     else:
@@ -225,33 +226,44 @@ class HighScore(AsyncMode):
         self._write_scores_to_disk()
         self._create_machine_vars()
 
-    def _assign_vars(self, category_name, player):
+    def _assign_vars(self, category_name, player_number):
         """Define all vars that are for the given category, and assign their values."""
-        # create dictionary of the variable name and its value, then load it for the category
-        player_num_index = player.number - 1
-        var_dict = dict()
+        var_dict = dict()  # store the results of var lookups for the player entry being saved
+        player_index = player_number - 1
+
         j = 0
-        while j < len(self.vars[category_name]) and bool(self.vars[category_name]):
-            if 'player' in self.vars[category_name][j][0]:
-                var_dict[self.vars[category_name][j][0] + '_' + self.vars[category_name][j][1]] \
-                    = self.machine.game.player_list[player_num_index][self.vars[category_name][j][1]]
-            else:
-                var_dict[self.vars[category_name][j][0] + '_' + self.vars[category_name][j][1]] \
-                    = self.machine.variables.get_machine_var(self.vars[category_name][j][1])
+        category_var_configuration = self.vars[category_name]
+        while j < len(category_var_configuration) and bool(category_var_configuration):
+            variable_type = category_var_configuration[j][0]
+            variable_name = category_var_configuration[j][1]
+            dict_key = variable_type + '_' + variable_name
+            if 'player' in variable_type:
+                var_dict[dict_key] = self._get_players()[player_index][variable_name]
+            else:  # else is machine variable
+                var_dict[dict_key] = self.machine.variables.get_machine_var(variable_name)
             j += 1
-        # return the dictionary of items for this specific player and category entry
+
         return var_dict
 
     # pylint: disable-msg=too-many-arguments
-    async def _ask_player_for_initials(self, player: Player, award_label: str, value: int, category_name: str) -> str:
+    async def _ask_player_for_initials(self,
+                                       player_number: int, award_label: str, value: int, category_name: str) -> str:
         """Show text widget to ask player for initials."""
         self.info_log("New high score. Player: %s, award_label: %s"
-                      ", Value: %s", player, award_label, value)
+                      ", Value: %s", player_number, award_label, value)
 
         self.machine.events.post('high_score_enter_initials',
-                                 award=award_label,
-                                 player_num=player.number,
-                                 value=value)
+                                 award=award_label, player_num=player_number, value=value,
+                                 category_name=category_name)
+        '''event high_score_enter_initials
+            desc: A high score has been submitted and the award slide can be displayed.
+            args:
+               player_num: The player number of the player being prompted for a name (counts from 1)
+               category_name: The category name of the award (e.g. "score")
+               award: The award name, based on the ordered set of rank names
+                      in the category (e.g. "GRAND CHAMPION")
+               value: The numerical value the player achieved
+        '''
 
         event_result = await asyncio.wait_for(
             self.machine.events.wait_for_event("text_input_high_score_complete"),
@@ -276,23 +288,21 @@ class HighScore(AsyncMode):
         if not self.high_score_config['award_slide_display_time']:
             return
 
-        self.machine.events.post(
-            'high_score_award_display',
-            player_name=player_name,
-            award=award,
-            value=value)
-        self.machine.events.post(
-            '{}_award_display'.format(award),
-            player_name=player_name,
-            award=award,
-            value=value)
-        self.machine.events.post(
-            '{}_award_display'.format(category_name),
-            player_num=player_num,
-            player_name=player_name,
-            category_name=category_name,
-            award=award,
-            value=value)
+        self.machine.events.post('high_score_award_display',
+                                 player_name=player_name, award=award, value=value,
+                                 player_num=player_num, category_name=category_name)
+
+        '''event high_score_award_display
+            desc: A high score has been submitted and the award slide can be displayed.
+            args:
+               player_name: The text name of the player being awarded.
+               player_num: The player number of the player being awarded (counts from 1)
+               category_name: The category name of the award (e.g. "score")
+               award: The name of the award, based on the ordered set of
+                      rank names in the category (e.g. "GRAND CHAMPION")
+               value: The numerical value the player achieved
+        '''
+
         await asyncio.sleep(self.high_score_config['award_slide_display_time'] / 1000)
 
     def _write_scores_to_disk(self) -> None:

mpf-0.80.0.dev11/mpf/modes/high_score/config/high_score.yaml

@@ -0,0 +1,57 @@
+#config_version=6
+mode:
+  code: mpf.modes.high_score.code.high_score.HighScore
+  priority: 1500
+  start_events: game_ending, start_high_score
+  game_mode: False
+  use_wait_queue: true
+
+# Instructions on how to use this mode:
+# https://missionpinball.org/latest/game_logic/high_scores
+
+high_score:
+  enter_initials_timeout: 60
+  award_slide_display_time: 4s
+  categories:
+    score:
+      - GRAND CHAMPION
+      - HIGH SCORE 1
+      - HIGH SCORE 2
+      - HIGH SCORE 3
+      - HIGH SCORE 4
+  defaults:
+    score:
+      - BRI: 4242
+      - GHK: 2323
+      - JK: 1337
+      - QC: 42
+      - MPF: 23
+
+event_player:
+  sw_left_flipper_active:
+    text_input:
+      action: left
+  sw_right_flipper_active:
+    text_input:
+      action: right
+  sw_start_active:
+    text_input:
+      action: select
+
+slide_player:
+  high_score_enter_initials:
+    high_score:
+        action: play
+    high_score_award:
+        action: remove
+  high_score_award_display:
+    high_score_award:
+        action: play
+    high_score:
+        action: remove
+
+  # When a player wins multiple awards, we only prompt for initials
+  # on the first. For the rest, we must update the award slide in place.
+  high_score_award_display.1:
+    high_score_award:
+        action: update

{mpf-0.80.0.dev9 → mpf-0.80.0.dev11}/mpf/mpfconfig.yaml

@@ -89,6 +89,7 @@ mpf:
         timers: mpf.devices.timer.Timer
         segment_displays: mpf.devices.segment_display.segment_display.SegmentDisplay
         sequence_shots: mpf.devices.sequence_shot.SequenceShot
+        shakers: mpf.devices.shaker.Shaker
         speedometers: mpf.devices.speedometer.Speedometer
         hardware_sound_systems: mpf.devices.hardware_sound_system.HardwareSoundSystem
         steppers: mpf.devices.stepper.Stepper
@@ -424,6 +425,7 @@ hardware:
   accelerometers: default
   servo_controllers: default
   i2c: default
+  shaker_controllers: default
   stepper_controllers: default
 
 combo_switches: