Merge branch 'missionpinball:dev' into dev

Author: worldpeace-germany

mpf/modes/bonus/code/bonus.py

@@ -91,11 +91,10 @@ def _bonus_next_item(self):
             self._subtotal()
             return
 
-        # Calling player.vars.get() instead of player.get() bypasses the
-        # auto-fill zero and will throw if there is no player variable.
-        # The fallback value of 1 is used for bonus entries that don't use
-        # a player score, which are multiplied by one to get the bonus.
-        hits = self.player.vars.get(entry['player_score_entry'], 1)
+        # If a player_score_entry is provided, use player getattr to get a
+        # fallback value of zero if the variable is not set. Otherwise
+        # use 1 as the multiplier for non-player-score bonuses.
+        hits = self.player[entry['player_score_entry']] if entry['player_score_entry'] else 1
         score = entry['score'].evaluate([]) * hits
 
         if (not score and entry['skip_if_zero']) or (score < 0 and entry['skip_if_negative']):

mpf/modes/high_score/code/high_score.py

@@ -196,7 +196,8 @@ async def _run(self) -> None:
                     # 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, award_names[i],
+                                                                                  value, category_name)
                         except asyncio.TimeoutError:
                             del new_list[i]
                             # no entry when the player missed the timeout

mpf/platforms/fast/communicators/net_neuron.py

@@ -293,7 +293,7 @@ def update_switches_from_hw_data(self):
         This will silently sync the switch.hw_state. If the logical state changes,
         it will process it like any switch change.
         """
-        for switch in self.machine.switches:
+        for switch in self.machine.switches.values():
             hw_state = self.platform.hw_switch_data[switch.hw_switch.number]
 
             if hw_state != switch.hw_state:

mpf/platforms/fast/fast_exp_board.py

@@ -2,6 +2,7 @@
 
 import asyncio
 from base64 import b16decode
+from binascii import Error as binasciiError
 from importlib import import_module
 
 from packaging import version
@@ -176,7 +177,7 @@ def update_leds(self):
 
                 try:
                     self.communicator.send_bytes(b16decode(f'{msg_header}{msg}'), log_msg)
-                except Exception as e:
+                except binasciiError as e:
                     self.log.error(
                         f"Error decoding the following message for board {breakout_address} : {msg_header}{msg}")
                     self.log.info("Attempted update that caused this error: %s", dirty_leds)

mpf/platforms/virtual.py

@@ -105,16 +105,16 @@ async def get_hw_switch_states(self):
 
             if 'virtual_platform_start_active_switches' in self.machine.config:
                 initial_active_switches = []
-                for switch in Util.string_to_list(self.machine.config['virtual_platform_start_active_switches']):
-                    if switch not in self.machine.switches:
-                        if " " in switch:
+                for switch_name in Util.string_to_list(self.machine.config['virtual_platform_start_active_switches']):
+                    if switch_name not in self.machine.switches.keys():
+                        if " " in switch_name:
                             self.raise_config_error("MPF no longer supports lists separated by space in "
                                                     "virtual_platform_start_active_switches. Please separate "
-                                                    "switches by comma: {}.".format(switch), 1)
+                                                    "switches by comma: {}.".format(switch_name), 1)
                         else:
                             self.raise_config_error("Switch {} used in virtual_platform_start_active_switches was not "
-                                                    "found in switches section.".format(switch), 1)
-                    initial_active_switches.append(self.machine.switches[switch].hw_switch.number)
+                                                    "found in switches section.".format(switch_name), 1)
+                    initial_active_switches.append(self.machine.switches[switch_name].hw_switch.number)
 
                 for k in self.hw_switches:
                     if k in initial_active_switches:

mpf/plugins/platform_integration_test_runner.py

@@ -227,7 +227,7 @@ async def move_ball_from_drain_to_trough(self, **kwargs):
         drain_switches = self.machine.ball_devices.items_tagged('drain')[0].config.get('ball_switches')
         self.info_log("Found drain switches: %s of type %s", drain_switches, type(drain_switches))
         # If there's only one drain switch it might be a single value, rather than a list
-        drain_switch = drain_switches if type(drain_switches) is str else drain_switches[-1]
+        drain_switch = drain_switches if isinstance(drain_switches, str) else drain_switches[-1]
         self.info_log("Setting drain switch '%s' to zero", drain_switch)
         self.set_switch_sync(drain_switch, 0)
         await asyncio.sleep(0.25)

mpf/tests/machine_files/bonus/modes/bonus/config/bonus.yaml

@@ -12,3 +12,9 @@ mode_settings:
         score: 5000
         player_score_entry: modes
         reset_player_score_entry: False
+      - event: bonus_undefined_var
+        score: 5000
+        skip_if_zero: false
+        player_score_entry: undefined_var
+      - event: bonus_static
+        score: 2000

mpf/tests/machine_files/shots/config/test_shot_groups.yaml

@@ -12,6 +12,10 @@ switches:
     number:
   switch_4:
     number:
+  switch_5:
+    number:
+  switch_6:
+    number:
   s_rotate_l:
     number:
   s_rotate_r:

mpf/tests/machine_files/shots/modes/base2/config/base2.yaml

@@ -20,6 +20,10 @@ shots:
       light: tag1
   shot_4:
     switch: switch_1
+  shot_5:
+    switch: switch_5
+  shot_6:
+    switch: switch_6
   led_1:
     switch: switch_1
     show_tokens:

mpf/tests/machine_files/shots/modes/mode1/config/mode1.yaml

@@ -24,6 +24,12 @@ shots:
   mode1_shot_3:
     switch: switch_3
     profile: mode1_shot_3
+  mode1_shot_5:
+    switch: switch_5
+    profile: mode1_shot_5
+  mode1_shot_6:
+    switch: switch_6
+    profile: mode1_shot_6
 
 shot_profiles:
   mode1_shot_2:
@@ -32,10 +38,21 @@ shot_profiles:
     - name: mode1_one
     - name: mode1_two
     - name: mode1_three
-  mode1_shot_3:
+  mode1_shot_3: # Test block: True
     show: rainbow2
     block: True
     states:
     - name: mode1_one
     - name: mode1_two
     - name: mode1_three
+  mode1_shot_5: # Test block: False
+    show: rainbow2
+    block: False
+    states:
+    - name: mode1_one
+    - name: mode1_two
+  mode1_shot_6: # Test block default
+    show: rainbow2
+    states:
+    - name: mode1_one
+    - name: mode1_two

mpf/tests/test_Bonus.py

@@ -38,6 +38,8 @@ def test_slam_tilt_in_service(self):
     def testBonus(self):
         self.mock_event("bonus_ramps")
         self.mock_event("bonus_modes")
+        self.mock_event("bonus_undefined_var")
+        self.mock_event("bonus_static")
         self.mock_event("bonus_subtotal")
         self.mock_event("bonus_multiplier")
         self.mock_event("bonus_total")
@@ -78,10 +80,14 @@ def testBonus(self):
         self.assertEqual(3, self._last_event_kwargs["bonus_ramps"]["hits"])
         self.assertEqual(10000, self._last_event_kwargs["bonus_modes"]["score"])
         self.assertEqual(2, self._last_event_kwargs["bonus_modes"]["hits"])
-        self.assertEqual(13000, self._last_event_kwargs["bonus_subtotal"]["score"])
+        self.assertEqual(0, self._last_event_kwargs["bonus_undefined_var"]["score"])
+        self.assertEqual(0, self._last_event_kwargs["bonus_undefined_var"]["hits"])
+        self.assertEqual(2000, self._last_event_kwargs["bonus_static"]["score"])
+        self.assertEqual(1, self._last_event_kwargs["bonus_static"]["hits"])
+        self.assertEqual(15000, self._last_event_kwargs["bonus_subtotal"]["score"])
         self.assertEqual(5, self._last_event_kwargs["bonus_multiplier"]["multiplier"])
-        self.assertEqual(65000, self._last_event_kwargs["bonus_total"]["score"])
-        self.assertEqual(66337, self.machine.game.player.score)
+        self.assertEqual(75000, self._last_event_kwargs["bonus_total"]["score"])
+        self.assertEqual(76337, self.machine.game.player.score)
 
         # check resets
         self.assertEqual(0, self.machine.game.player.ramps)
@@ -102,10 +108,10 @@ def testBonus(self):
         self.assertEqual(0, self._last_event_kwargs["bonus_ramps"]["hits"])
         self.assertEqual(10000, self._last_event_kwargs["bonus_modes"]["score"])
         self.assertEqual(2, self._last_event_kwargs["bonus_modes"]["hits"])
-        self.assertEqual(10000, self._last_event_kwargs["bonus_subtotal"]["score"])
+        self.assertEqual(12000, self._last_event_kwargs["bonus_subtotal"]["score"])
         self.assertEqual(5, self._last_event_kwargs["bonus_multiplier"]["multiplier"])
-        self.assertEqual(50000, self._last_event_kwargs["bonus_total"]["score"])
-        self.assertEqual(116337, self.machine.game.player.score)
+        self.assertEqual(60000, self._last_event_kwargs["bonus_total"]["score"])
+        self.assertEqual(136337, self.machine.game.player.score)
 
         # multiplier should stay the same
         self.assertEqual(0, self.machine.game.player.ramps)
@@ -128,6 +134,8 @@ def testBonus(self):
         self.mock_event("bonus_start")
         self.mock_event("bonus_ramps")
         self.mock_event("bonus_modes")
+        self.mock_event("bonus_undefined_var")
+        self.mock_event("bonus_static")
         self.mock_event("bonus_subtotal")
         self.mock_event("bonus_multiplier")
         self.mock_event("bonus_total")
@@ -157,6 +165,18 @@ def testBonus(self):
         self.assertEventNotCalled('bonus_multiplier')
         self.assertEventNotCalled('bonus_total')
 
+        self.advance_time_and_run(.5)
+        self.assertEventCalled('bonus_undefined_var')
+        self.assertEventNotCalled('bonus_subtotal')
+        self.assertEventNotCalled('bonus_multiplier')
+        self.assertEventNotCalled('bonus_total')
+
+        self.advance_time_and_run(.5)
+        self.assertEventCalled('bonus_static')
+        self.assertEventNotCalled('bonus_subtotal')
+        self.assertEventNotCalled('bonus_multiplier')
+        self.assertEventNotCalled('bonus_total')
+
         self.advance_time_and_run(.5)
         self.assertEventCalled('bonus_subtotal')
         self.assertEventNotCalled('bonus_multiplier')

mpf/tests/test_Shots.py

@@ -29,36 +29,51 @@ def stop_game(self):
         self.advance_time_and_run()
         self.assertIsNone(self.machine.game)
 
-    def test_block(self):
+    def block_test(self, switch, shot, should_block):
+        high_priority_shot = "mode1_" + shot
         self.mock_event("playfield_active")
-        self.hit_and_release_switch("switch_3")
+        self.hit_and_release_switch(switch)
         self.advance_time_and_run(.1)
         self.assertEventCalled("playfield_active")
 
         self.start_game()
-        self.assertEqual("unlit", self.machine.shots["shot_3"].state_name)
+        self.assertEqual("unlit", self.machine.shots[shot].state_name)
 
-        self.hit_and_release_switch("switch_3")
+        self.hit_and_release_switch(switch)
         self.advance_time_and_run(.1)
-        self.assertTrue(self.machine.shots["shot_3"].enabled)
-        self.assertEqual("lit", self.machine.shots["shot_3"].state_name)
+        self.assertFalse(self.machine.shots[high_priority_shot].enabled)
+        self.assertTrue(self.machine.shots[shot].enabled)
+        self.assertEqual("lit", self.machine.shots[shot].state_name)
 
-        self.machine.shots["shot_3"].reset()
-        self.assertEqual("unlit", self.machine.shots["shot_3"].state_name)
+        self.machine.shots[shot].reset()
+        self.assertEqual("unlit", self.machine.shots[shot].state_name)
 
         # Start the mode and make sure those shots load
         self.start_mode("mode1")
 
-        self.assertTrue(self.machine.shots["shot_3"].enabled)
-        self.assertTrue(self.machine.shots["mode1_shot_3"].enabled)
-        self.assertEqual("unlit", self.machine.shots["shot_3"].state_name)
-        self.assertEqual("mode1_one", self.machine.shots["mode1_shot_3"].state_name)
+        self.assertTrue(self.machine.shots[shot].enabled)
+        self.assertTrue(self.machine.shots[high_priority_shot].enabled)
+        self.assertEqual("unlit", self.machine.shots[shot].state_name)
+        self.assertEqual("mode1_one", self.machine.shots[high_priority_shot].state_name)
 
-        self.hit_and_release_switch("switch_3")
+        self.hit_and_release_switch(switch)
         self.advance_time_and_run(.1)
 
-        self.assertEqual("unlit", self.machine.shots["shot_3"].state_name)
-        self.assertEqual("mode1_two", self.machine.shots["mode1_shot_3"].state_name)
+        if should_block:
+            self.assertEqual("unlit", self.machine.shots[shot].state_name)
+        else:
+            self.assertEqual("lit", self.machine.shots[shot].state_name)
+
+        self.assertEqual("mode1_two", self.machine.shots[high_priority_shot].state_name)
+
+    def test_block_true(self):
+        self.block_test("switch_3", "shot_3", True)
+
+    def test_block_false(self):
+        self.block_test("switch_5", "shot_5", False)
+
+    def test_block_default(self): #Default behaves as false
+        self.block_test("switch_6", "shot_6", False)
 
     def test_loading_shots(self):
         # Make sure machine-wide shots load & mode-specific shots do not