mpf 0.57.2.dev3__tar.gz → 0.57.2.dev4__tar.gz

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.2.dev3
+Version: 0.57.2.dev4
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.57.2.dev3'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.57.2.dev4'  # Also consider whether MPF-MC pyproject.toml should be updated
 '''The full version of MPF.'''
 
 __short_version__ = '0.57'

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/config_spec.yaml

@@ -115,7 +115,7 @@ autofire_coils:
     coil_overwrite: single|subconfig(coil_overwrites)|None
     switch_overwrite: dict|str:str|None
     ball_search_order: single|int|100
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
     timeout_watch_time: single|ms|0
     timeout_max_hits: single|int|0
     timeout_disable_time: single|ms|0
@@ -493,7 +493,7 @@ drop_targets:
     reset_coil_max_wait_ms: single|ms|100ms
     knockdown_coil_max_wait_ms: single|ms|100ms
     ignore_switch_ms: single|ms|500ms
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
 drop_target_banks:
     __valid_in__: machine, mode
     __type__: device
@@ -1076,7 +1076,7 @@ magnets:
     release_time: single|ms|500ms
     fling_drop_time: single|ms|250ms
     fling_regrab_time: single|ms|50ms
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
     enable_events: event_handler|event_handler:ms|ball_started
     disable_events: event_handler|event_handler:ms|ball_will_end, service_mode_entered
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting
@@ -1986,7 +1986,7 @@ sequence_shots:
     delay_switch_list: dict|machine(switches):ms|None
     delay_event_list: event_handler|event_handler:ms|None
     sequence_timeout: single|ms|0
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
 switches:
     __valid_in__: machine
     __type__: device
@@ -1999,6 +1999,7 @@ switches:
     events_when_deactivated: list|event_posted|None
     platform: single|str|None
     platform_settings: single|dict|None
+    playfield: single|machine(playfields)|playfield
     x: single|float|None
     y: single|float|None
     z: single|float|None

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/core/switch_controller.py

@@ -367,14 +367,17 @@ class SwitchController(MpfController):
         obj.state = state
         obj.last_change = timestamp
 
+        muted_state = "(muted) " if obj.is_muted else ""
         if state:
-            self.info_log("<<<<<<< '%s' active >>>>>>>", obj.name)
+            self.info_log("<<<<<<< '%s' active %s>>>>>>>", obj.name, muted_state)
         else:
-            self.info_log("<<<<<<< '%s' inactive >>>>>>>", obj.name)
+            self.info_log("<<<<<<< '%s' inactive %s>>>>>>>", obj.name, muted_state)
 
         self._cancel_timed_handlers(obj)
 
-        if not obj.is_muted:
+        # Don't call switch callbacks during initialization, or devices may try and
+        # flag playfields active and mess up the ball counts.
+        if self._initialized and not obj.is_muted:
             self._call_handlers(obj, state)
 
         for monitor in self.monitors:

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/devices/autofire.py

@@ -34,7 +34,8 @@ class AutofireCoil(SystemWideDevice):
     collection = 'autofire_coils'
     class_label = 'autofire'
 
-    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "_timeout_watch_time", "_timeout_max_hits",
+    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "playfield",
+                 "_timeout_watch_time", "_timeout_max_hits",
                  "_timeout_disable_time", "_timeout_hits"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
@@ -44,6 +45,7 @@ class AutofireCoil(SystemWideDevice):
         super().__init__(machine, name)
         self.delay = DelayManager(self.machine)
         self._ball_search_in_progress = False
+        self.playfield = None
         self._timeout_watch_time = None
         self._timeout_max_hits = None
         self._timeout_disable_time = None
@@ -51,8 +53,9 @@ class AutofireCoil(SystemWideDevice):
 
     async def _initialize(self):
         await super()._initialize()
+        self.playfield = self.config['playfield'] or self.config['switch'].playfield
         if self.config['ball_search_order']:
-            self.config['playfield'].ball_search.register(
+            self.playfield.ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
         # pulse is handled via rule but add a handler so that we take notice anyway
         self.config['switch'].add_handler(self._hit)
@@ -61,13 +64,13 @@ class AutofireCoil(SystemWideDevice):
             self._timeout_max_hits = self.config['timeout_max_hits']
             self._timeout_disable_time = self.config['timeout_disable_time']
 
-        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
+        if f"{self.playfield.name}_active" in self.config['switch'].tags:
             self.raise_config_error(
                 "Autofire device '{}' uses switch '{}' which has a "
                 "'{}_active' tag. This is handled internally by the device. Remove the "
                 "redundant '{}_active' tag from that switch.".format(
-                    self.name, self.config['switch'].name, self.config['playfield'].name,
-                    self.config['playfield'].name), 1)
+                    self.name, self.config['switch'].name, self.playfield.name,
+                    self.playfield.name), 1)
 
     @event_handler(1)
     def event_enable(self, **kwargs):
@@ -169,7 +172,7 @@ class AutofireCoil(SystemWideDevice):
         if not self._enabled:
             return
         if not self._ball_search_in_progress:
-            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
+            self.playfield.mark_playfield_active_from_device_action(self.name)
         if self._timeout_watch_time:
             current_time = self.machine.clock.get_time()
             self._timeout_hits = [t for t in self._timeout_hits if t > current_time - self._timeout_watch_time / 1000.0]

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/devices/drop_target.py

@@ -30,7 +30,7 @@ class DropTarget(SystemWideDevice):
     collection = 'drop_targets'
     class_label = 'drop_target'
 
-    __slots__ = ["reset_coil", "knockdown_coil", "banks", "complete", "delay"]
+    __slots__ = ["reset_coil", "knockdown_coil", "banks", "complete", "delay", "playfield"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
         """Initialize drop target."""
@@ -41,6 +41,7 @@ class DropTarget(SystemWideDevice):
 
         self.complete = False
         self.delay = DelayManager(machine)
+        self.playfield = None
 
     async def _initialize(self):
         await super()._initialize()
@@ -53,17 +54,20 @@ class DropTarget(SystemWideDevice):
         self.machine.events.add_handler('init_phase_4',
                                         self._register_switch_handlers, priority=1)
 
+        # If a playfield is not explicitly defined, defer to the switch's playfield
+        self.playfield = self.config['playfield'] or self.config['switch'].playfield
+
         if self.config['ball_search_order']:
-            self.config['playfield'].ball_search.register(
+            self.playfield.ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
 
-        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
+        if f"{self.playfield.name}_active" in self.config['switch'].tags:
             self.raise_config_error(
                 "Drop target device '{}' uses switch '{}' which has a "
                 "'{}_active' tag. This is handled internally by the device. Remove the "
                 "redundant '{}_active' tag from that switch.".format(
-                    self.name, self.config['switch'].name, self.config['playfield'].name,
-                    self.config['playfield'].name), 1)
+                    self.name, self.config['switch'].name, self.playfield.name,
+                    self.playfield.name), 1)
 
     def _ignore_switch_hits_for(self, ms, reset_attempt=None):
         """Ignore switch hits for ms."""
@@ -207,7 +211,7 @@ class DropTarget(SystemWideDevice):
                        self.name, self.config['switch'].name, is_complete, self.complete)
 
         if not reconcile:
-            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
+            self.playfield.mark_playfield_active_from_device_action(self.name)
 
         if is_complete != self.complete:
 
@@ -352,6 +356,9 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         """Add targets to bank."""
         for target in self.drop_targets:
             target.add_to_bank(self)
+            assert self.config['playfield'] == target.playfield, \
+                   f"Drop target bank has a playfield {self.config['playfield']} but target {target.name} " \
+                   "has playfield {target.playfield}. Banks do not support targets on multiple playfields."
 
         self.member_target_change()
 

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/devices/magnet.py

@@ -14,7 +14,7 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     """Controls a playfield magnet in a pinball machine."""
 
-    __slots__ = ["delay", "_active", "_release_in_progress"]
+    __slots__ = ["delay", "_active", "_release_in_progress", "playfield"]
 
     config_section = 'magnets'
     collection = 'magnets'
@@ -24,6 +24,7 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
         """Initialize magnet."""
         super().__init__(machine, name)
         self.delay = DelayManager(machine)
+        self.playfield = None
         self._active = False
         self._release_in_progress = False
 
@@ -33,6 +34,9 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
         if self.config['grab_switch']:
             self.config['grab_switch'].add_handler(self.grab_ball)
+            self.playfield = self.config['playfield'] or self.config['grab_switch'].playfield
+        else:
+            self.playfield = self.config['playfield']
 
     def _disable(self):
         """Disable magnet."""
@@ -61,8 +65,8 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     def grab_ball(self):
         """Grab a ball."""
-        # mark the playfield active no matter what
-        self.config['playfield'].mark_playfield_active_from_device_action(self.name)
+        if self.playfield:
+            self.playfield.mark_playfield_active_from_device_action(self.name)
         # check if magnet is enabled or already active
         if not self.enabled or self._active or self._release_in_progress:
             return

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/devices/sequence_shot.py

@@ -100,7 +100,7 @@ class SequenceShot(SystemWideDevice, ModeDevice):
         # switch is starting a new sequence or continuing an existing one
         del kwargs
 
-        # mark playfield active
+        # mark playfield active if a playfield is defined for this sequence
         if self.config['playfield']:
             self.config['playfield'].mark_playfield_active_from_device_action(self.name)
 

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/devices/shot.py

@@ -24,8 +24,8 @@ class Shot(EnableDisableMixin, ModeDevice):
     to track shots.
     """
 
-    __slots__ = ["delay", "active_sequences", "active_delays", "running_show", "_handlers",
-                 "_player_var_name"]
+    __slots__ = ["delay", "active_sequences", "active_delays", "playfield", "running_show",
+                 "_handlers", "_player_var_name"]
 
     def __init__(self, machine, name):
         """Initialize shot."""
@@ -40,22 +40,29 @@ class Shot(EnableDisableMixin, ModeDevice):
         """List of tuples: (id, current_position_index, next_switch)"""
         self.active_delays = set()
         self.running_show = None
+        self.playfield = None
         self._handlers = []
 
     async def _initialize(self) -> None:
         """Register playfield active handlers."""
         await super()._initialize()
 
+        self._register_control_event_handlers()
+
+        # No need to mark active if not required
+        if not self.config['mark_playfield_active']:
+            return
+
         for switch in self.config['switches'] + list(self.config['delay_switch'].keys()):
             # mark the playfield active no matter what
-            switch.add_handler(self._mark_active)
-        self._register_control_event_handlers()
+            switch.add_handler(self._mark_active,
+                               callback_kwargs={'playfield': switch.config['playfield']})
 
-    def _mark_active(self, **kwargs):
+    def _mark_active(self, playfield, **kwargs):
         """Mark playfield active."""
         del kwargs
-        if self.config['mark_playfield_active']:
-            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
+        # Whatever playfield the triggering switch is on, mark *that* as active
+        playfield.mark_playfield_active_from_device_action(self.name)
 
     def device_loaded_in_mode(self, mode: Mode, player: Player):
         """Add device to a mode that was already started.

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/devices/switch.py

@@ -266,3 +266,8 @@ class Switch(SystemWideDevice, DevicePositionMixin):
     def is_muted(self):
         """True if this switch is currently muted."""
         return self._mutes > 0
+
+    @property
+    def playfield(self):
+        """Return the playfield this switch is assigned to."""
+        return self.config['playfield']

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf/tests/machine_files/head2head/config/config.yaml

@@ -13,45 +13,65 @@ playfields:
 switches:
   s_trough1_front:
     number:
+    playfield: playfield_front
   s_trough2_front:
     number:
+    playfield: playfield_front
   s_trough3_front:
     number:
+    playfield: playfield_front
   s_trough4_front:
     number:
+    playfield: playfield_front
   s_trough1_back:
     number:
+    playfield: playfield_back
   s_trough2_back:
     number:
+    playfield: playfield_back
   s_trough3_back:
     number:
+    playfield: playfield_back
   s_trough4_back:
     number:
+    playfield: playfield_back
   s_launcher_lane_front:
     number:
+    playfield: playfield_front
   s_launcher_lane_back:
     number:
+    playfield: playfield_back
   s_middle_front1:
     number:
+    playfield: playfield_front
   s_middle_back1:
     number:
+    playfield: playfield_front
   s_feeder_front:
     number:
+    playfield: playfield_front
   s_feeder_back:
     number:
+    playfield: playfield_back
   s_launcher_diverter_front:
     number:
+    playfield: playfield_front
   s_launcher_diverter_back:
     number:
+    playfield: playfield_back
   s_transfer_front_back:
     number:
+    playfield: playfield_back
   s_transfer_back_front:
     number:
+    playfield: playfield_front
   s_playfield_front:
     number:
+    playfield: playfield_front
     tags: playfield_front_active
   s_playfield_back:
     number:
+    playfield: playfield_back
     tags: playfield_back_active
 
 coils:

{mpf-0.57.2.dev3 → mpf-0.57.2.dev4}/mpf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.2.dev3
+Version: 0.57.2.dev4
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT