Permalink
Cannot retrieve contributors at this time
| # Using SkeletonGame: | |
| # 1. Your filesystem should be set up with assets/dmd and assets/sound sub-folders | |
| # 2. Your game class should inheriet from SkeletonGame | |
| # 3. Your config.yaml (which may be in this directory) must define | |
| # information about the dmd resolution, fps, etc. See the example. | |
| # 4. Your game class should implement the following helpful methods: | |
| # doBallSearch() | |
| # 5. Your modes should handle the following events: | |
| # game_started | |
| # ball_starting | |
| # ball_ended | |
| # game_ended | |
| # 6. your assets.yaml should define: | |
| # font: default_msg | |
| # | |
| ########################## | |
| from . import GameController | |
| from . import BasicGame | |
| from . import Player | |
| from .advancedmode import AdvancedMode | |
| from ..dmd import HDDisplayController, font_named, sdl2_DisplayManager | |
| from ..dmd.layers import SolidLayer, GroupedLayer | |
| from ..modes import ScoreDisplay, ScoreDisplayHD | |
| from ..modes import Trough, ballsave, BallSearch | |
| from ..modes import osc | |
| from ..modes import DMDHelper, SwitchMonitor | |
| from ..modes import bonusmode, service, Attract, TiltMonitorMode, Tilted | |
| #from ..modes import serviceHD | |
| from .. import sound | |
| from .. import config | |
| from .. import auxport | |
| from .. import alphanumeric | |
| from .. import lamps | |
| from .. import assetmanager | |
| from .. import highscore | |
| import pinproc | |
| import time | |
| import datetime | |
| import traceback | |
| import inspect | |
| import pygame | |
| from pygame import mixer | |
| import time | |
| import pinproc | |
| import os | |
| import logging | |
| import locale | |
| import random | |
| import re | |
| import weakref | |
| import yaml | |
| from procgame.yaml_helper import value_for_key | |
| # from weakref import WeakValueDictionary | |
| from game import config_named | |
| from procgame.modes.rgbshow import RgbShowPlayer | |
| try: | |
| # Mac/Linux version | |
| locale.setlocale(locale.LC_ALL, "en_US.UTF-8") # This is used to put commas in the score | |
| except Exception, e: | |
| # Windows | |
| locale.setlocale(locale.LC_ALL, "") # This is used to put commas in the score | |
| def cleanup(): | |
| import sdl2.ext | |
| sdl2.ext.quit() | |
| from procgame.modes.osc import OSC_INST | |
| global OSC_INST | |
| if(OSC_INST is not None): | |
| OSC_INST.OSC_shutdown() | |
| def run_proc_game(game_class): | |
| import sys | |
| game = None | |
| exc_info = None | |
| try: | |
| game = game_class() | |
| game.run_loop(.0001) | |
| except Exception, e: | |
| # back up the exception | |
| exc_info = sys.exc_info() | |
| finally: | |
| # if the game crashes, end_run_loop might not be called | |
| if(game is not None): | |
| game.end_run_loop() | |
| else: | |
| cleanup() | |
| if(exc_info is not None): | |
| raise exc_info[0], exc_info[1], exc_info[2] | |
| print "---------" | |
| class SkeletonGame(BasicGame): | |
| """ SkeletonGame is intended to be the new super-class for your game class. It provides | |
| more of the functionality that one expects to be in a 'generic' 'modern' pinball machine | |
| """ | |
| def __init__(self, machineYamlFile, curr_file_path, machineType=None): | |
| try: | |
| self.cleaned_up = False | |
| random.seed() | |
| pygame.mixer.pre_init(44100,-16,2,512) | |
| self.curr_file_path = curr_file_path | |
| if(machineType is None): | |
| self.config = config_named(machineYamlFile) | |
| if not self.config: | |
| raise ValueError, 'Yaml file "%s" could not be loaded and machineType not passed as arg to SkeletonGame() init.' % (machineYamlFile) | |
| machineType = self.config['PRGame']['machineType'] | |
| machine_type = pinproc.normalize_machine_type(machineType) | |
| if not machine_type: | |
| raise ValueError, 'machine config(filename="%s") did not set machineType, and not set in SkeletonGame() init.' % (machineYamlFile) | |
| # try: | |
| super(SkeletonGame, self).__init__(machine_type) | |
| # except IOError, e: | |
| # self.log("Error connecting to P-ROC -- running virtual mode") | |
| # config.values['pinproc_class'] = 'procgame.fakepinproc.FakePinPROC' | |
| # super(SkeletonGame, self).__init__(machine_type) | |
| self.dmd_width = config.value_for_key_path('dmd_dots_w', 480) | |
| self.dmd_height = config.value_for_key_path('dmd_dots_h', 240) | |
| self.dmd_fps = config.value_for_key_path('dmd_framerate', 30) | |
| # load the machine config yaml | |
| self.load_config(machineYamlFile) | |
| self.max_players = 4 | |
| # used to hold the 'fonts' dictionary | |
| fonts = {} | |
| animations = {} | |
| self.lampshow_path = config.value_for_key_path('lampshow_path', curr_file_path + "/assets/lampshows/") | |
| self.dmd_path = config.value_for_key_path('dmd_path', curr_file_path + "/assets/dmd/") | |
| self.sound_path = config.value_for_key_path('sound_path', curr_file_path + "/assets/sound/") | |
| self.voice_path = self.sound_path + config.value_for_key_path('voice_dir', "voice/") | |
| self.sfx_path = self.sound_path + config.value_for_key_path('sfx_dir', "sfx/") | |
| self.music_path = self.sound_path + config.value_for_key_path('music_dir', "music/") | |
| self.hdfont_path = config.value_for_key_path('hdfont_dir', curr_file_path + "/assets/fonts/") | |
| # known_modes are all AdvancedModes that have been created; they are stored by type | |
| # what is stored is a weakref to each, so we don't mess up reference counts/garbage collection | |
| self.known_modes = {} | |
| self.known_modes[AdvancedMode.System] = [] | |
| self.known_modes[AdvancedMode.Ball] = [] | |
| self.known_modes[AdvancedMode.Game] = [] | |
| self.known_modes[AdvancedMode.Manual] = [] | |
| # event hanlders are lists of AdvancedModes (again, weakref) that care about these specific | |
| # events (i.e., these classes define functions to handle these specific events) | |
| self.event_handlers = {} | |
| # the evt_ methods: | |
| self.known_events = [ 'evt_tilt', 'evt_shoot_again', 'evt_single_ball_play', \ | |
| 'evt_ball_ending', 'evt_ball_starting', 'evt_ball_saved', \ | |
| 'evt_game_ending', 'evt_game_starting', 'evt_tilt_ball_ending', \ | |
| 'evt_player_added', 'evt_balls_missing', 'evt_balls_found', | |
| 'evt_volume_up', 'evt_volume_down', 'evt_tilt_warning', \ | |
| 'evt_game_ended', 'evt_initial_entry', 'evt_mb_drain'] | |
| for e in self.known_events: | |
| self.event_handlers[e] = [] | |
| self.sg_event_queue = [] # if a known event fires while still processing another, this will | |
| # hold the queue of out-standing SG events | |
| self.event = None # the current SG event being processed | |
| self.game_tilted = False # indicates if any kind of tilt has occured; tilt, slam_tilt | |
| # create a sound controller (self.game.sound from within modes) | |
| self.sound = sound.SoundController(self) | |
| self.modes.add(self.sound) | |
| self.settings = [] | |
| # create a lamp controller for lampshows | |
| self.lampctrl = lamps.LampController(self) | |
| ### the rgb show player is a player for rgb lamps | |
| self.rgbshow_player = RgbShowPlayer(game=self, priority=50) | |
| self.modes.add(self.rgbshow_player) | |
| self.rgbshow_player.reset() | |
| # call load_assets function to load fonts, sounds, etc. | |
| self.load_assets() | |
| self.dmd = HDDisplayController(self) | |
| self.use_stock_scoredisplay = config.value_for_key_path('default_modes.score_display', True) | |
| self.use_stock_bonusmode = config.value_for_key_path('default_modes.bonus_tally', True) | |
| self.use_stock_attractmode = config.value_for_key_path('default_modes.attract', True) | |
| self.use_osc_input = config.value_for_key_path('default_modes.osc_input', True) | |
| self.use_stock_servicemode = config.value_for_key_path('default_modes.service_mode', True) | |
| #self.use_HD_servicemode = config.value_for_key_path('default_modes.service_mode_HD', True) | |
| self.use_stock_tiltmode = config.value_for_key_path('default_modes.tilt_mode', True) | |
| self.use_ballsearch_mode = config.value_for_key_path('default_modes.ball_search', True) | |
| self.use_multiline_score_entry = config.value_for_key_path('default_modes.multiline_highscore_entry', False) | |
| self.ballsearch_time = config.value_for_key_path('default_modes.ball_search_delay', 30) | |
| self.dmdHelper = DMDHelper(game=self) | |
| self.modes.add(self.dmdHelper) | |
| if(self.use_stock_scoredisplay is True): | |
| self.score_display = ScoreDisplay(self,0) | |
| elif(self.use_stock_scoredisplay=='HD'): | |
| self.score_display = ScoreDisplayHD(self, 0) | |
| if(self.use_stock_bonusmode): | |
| self.bonus_mode = bonusmode.BonusMode(game=self) | |
| self.load_settings_and_stats() | |
| #if(self.use_HD_servicemode): | |
| # self.service_mode = serviceHD.ServiceModeHD(self, 99, self.fonts['settings-font-small'], self.fonts['settings-font-small'], extra_tests=[]) | |
| #elif(self.use_stock_servicemode): | |
| self.service_mode = service.ServiceMode(self, 99, self.fonts['settings-font-small'], extra_tests=[]) | |
| if(self.use_stock_tiltmode): | |
| # find a tilt switch | |
| tilt_sw_name = self.find_item_name('tilt',self.switches) | |
| slamtilt_sw_name = self.find_item_name('slamTilt',self.switches) | |
| self.tilt_mode = TiltMonitorMode(game=self, priority=99998, | |
| tilt_sw=tilt_sw_name, slam_tilt_sw=slamtilt_sw_name) | |
| shoot_again = self.lamps.item_named_or_tagged('shoot_again') | |
| shooter_lane_sw_name = self.find_item_name('shooter',self.switches) | |
| self.ball_save = ballsave.BallSave(self, lamp=shoot_again, delayed_start_switch=shooter_lane_sw_name) | |
| # Note - Game specific item: | |
| trough_switchnames = self.switches.items_tagged('trough') | |
| # This range should include the number of trough switches for | |
| # the specific game being run. In range(1,x), x = last number + 1. | |
| if(len(trough_switchnames)==0): | |
| logging.getLogger('Trough').warning("No switches have been tagged 'trough'. Switches with names that start Trough will be used.") | |
| trough_switchnames = [t.name for t in self.switches if t.name.startswith("trough") ] | |
| else: | |
| trough_switchnames = [t.name for t in trough_switchnames] | |
| if(len(trough_switchnames)==0): | |
| logging.getLogger('Trough').error("No switches have been tagged 'trough' and no switch names start with 'trough'") | |
| raise ValueError("Machine YAML must contain switches either tagged 'trough' or with names that start with 'trough'") | |
| early_save_switchnames = [save_sw.name for save_sw in self.switches.items_tagged('early_save')] | |
| # Added auto-config for auto plunger | |
| plunge_coilname = self.find_item_name('autoPlunger', self.coils) | |
| # Note - Game specific item: | |
| # Here, trough6 is used for the 'eject_switchname'. This must | |
| # be the switch of the next ball to be ejected. Some games | |
| # number the trough switches in the opposite order; so trough1 | |
| # might be the proper switchname to user here. | |
| trough_coil_name = None | |
| if('trough' in self.coils): | |
| trough_coil_name = 'trough' | |
| else: | |
| for c in self.coils: | |
| if(c.name.startswith("trough")): | |
| trough_coil_name = c.name | |
| break | |
| if(trough_coil_name is None): | |
| raise ValueError, "machine YAML must define a coil named 'Trough' or that starts with" | |
| if(hasattr(self,'autoplunge_settle_time')): | |
| autoplunge_settle_time = self.autoplunge_settle_time | |
| else: | |
| autoplunge_settle_time = 0.3 | |
| if(hasattr(self,'trough_settle_time')): | |
| trough_settle_time = self.trough_settle_time | |
| else: | |
| trough_settle_time = 0.5 | |
| if(shooter_lane_sw_name is None): | |
| raise ValueError, "machine YAML must define a switch named 'shooter' or tagged 'shooter'" | |
| self.trough = Trough(self,trough_switchnames, trough_switchnames[-1], trough_coil_name, \ | |
| early_save_switchnames, shooter_lane_sw_name, drain_callback=None, plunge_coilname=plunge_coilname, \ | |
| autoplunge_settle_time=autoplunge_settle_time, trough_settle_time=trough_settle_time) | |
| # Only once the ball is fed to the shooter lane is it possible for the ball | |
| # drain to actually end a ball | |
| self.trough.drain_callback = None | |
| self.trough.launch_callback = None | |
| self.trough.launched_callback = self.__install_drain_logic | |
| # Link ball_save to trough | |
| self.trough.ball_save_callback = self.ball_save.launch_callback | |
| self.trough.num_balls_to_save = self.ball_save.get_num_balls_to_save | |
| self.ball_save.trough_enable_ball_save = self.trough.enable_ball_save | |
| self.game_start_pending = False | |
| bs_stopSwitches = list() | |
| bs_resetSwitches = list() | |
| self.ball_search_tries = 0 | |
| # add ball search options as per config.yaml | |
| bs_stopSwitches = [sw for sw in self.switches if (hasattr(sw,'ballsearch') and (sw.ballsearch == 'stop' or 'stop' in sw.ballsearch))] | |
| bs_resetSwitches = [sw for sw in self.switches if (hasattr(sw,'ballsearch') and (sw.ballsearch == 'reset' or 'reset' in sw.ballsearch))] | |
| self.ballsearch_resetSwitches = dict() | |
| for sw in bs_resetSwitches: | |
| v = 'closed' if sw.type == 'NC' or sw.type == 'nc' else 'open' | |
| self.ballsearch_resetSwitches[sw.name]=v | |
| self.ballsearch_stopSwitches = dict() | |
| for sw in bs_stopSwitches: | |
| v = 'active' if sw.type == 'NC' or sw.type == 'nc' else 'closed' | |
| self.ballsearch_stopSwitches[sw.name]=v | |
| self.ballsearch_coils = [dr.name for dr in self.coils if (hasattr(dr,'ballsearch') and dr.ballsearch == True)] | |
| if(self.use_ballsearch_mode): | |
| if(len(bs_stopSwitches) == 0 and len(bs_resetSwitches) == 0): | |
| self.logger.error("Could not use Ball search mode as there were no ballsearch tags (reset/stop) on any game switches in the yaml.\n -- will default to using your games: do_ball_search() method...") | |
| self.use_ballsearch_mode = False | |
| # create it anyway; if the switches are empty it will nerf itself. | |
| self.ball_search = BallSearch(self, priority=100, \ | |
| countdown_time=self.ballsearch_time, coils=self.ballsearch_coils, \ | |
| reset_switches=self.ballsearch_resetSwitches, \ | |
| stop_switches=self.ballsearch_stopSwitches, \ | |
| special_handler_modes=[]) | |
| if(self.use_osc_input): | |
| try: | |
| self.osc_closed_switches | |
| # or getattr(self, 'big_object') | |
| except AttributeError: | |
| self.osc_closed_switches = [] | |
| self.osc = osc.OSC_Mode(game=self, priority=1, closed_switches=self.osc_closed_switches) | |
| self.modes.add(self.osc) | |
| self.switchmonitor = SwitchMonitor(game=self) | |
| self.modes.add(self.switchmonitor) | |
| # # call reset (to reset the machine/modes/etc) | |
| self.genLayerFromYAML = self.dmdHelper.genLayerFromYAML | |
| self.notify_list = None | |
| self.curr_delayed_by_mode = None | |
| if(self.use_stock_attractmode): | |
| start_lamp = self.lamps.item_named_or_tagged('start_button') | |
| self.attract_mode = Attract(game=self, start_button_lamp=start_lamp) | |
| except Exception, e: | |
| if(hasattr(self,'osc') and self.osc is not None): | |
| self.osc.OSC_shutdown() | |
| raise | |
| def __install_drain_logic(self): | |
| """ do not install the "ball drained" logic until we know we have | |
| successfully fed the ball into the shooter lane """ | |
| self.logger.debug("drain logic installed to trough") | |
| self.trough.drain_callback = self.__ball_drained_callback | |
| self.trough.launch_callback = None | |
| self.trough.launched_callback = None | |
| def cleanup(self): | |
| """ stub incase subclass doesn't provide an implementation """ | |
| pass | |
| def end_run_loop(self): | |
| if(not self.cleaned_up): # if the game hasn't crashed, this might be called twice | |
| cleanup() | |
| if(hasattr(self,'cleanup')): | |
| self.logger.info("calling cleanup") | |
| self.cleanup() | |
| super(SkeletonGame,self).end_run_loop() | |
| self.cleaned_up = True | |
| else: | |
| pass | |
| # self.logger.info("suppressing second call to cleanup") | |
| def define_bonuses(self, file_name): | |
| """ given a yaml file that defines bonus records will init the list of known | |
| bonuses and their respective values """ | |
| BonusRecord.parse_from_file(file_name) | |
| def find_item_name(self, identifier, group): | |
| """ returns the name of a switch either named or tagged with the given tag """ | |
| tmp = group.item_named_or_tagged(identifier) | |
| if(tmp is None): | |
| return tmp | |
| return tmp.name | |
| def clear_status(self): | |
| self.dmdHelper.layer = None | |
| def set_status(self, msg, duration=2.0): | |
| """ a helper used to display a message on the DMD --low-tech version of displayText """ | |
| self.displayText(msg, font_key=self.status_font_name, background_layer='status_bg', font_style=self.status_font_style, flashing=8, duration=duration) | |
| def displayText(self, msg, background_layer=None, font_key=None, font_style=None, opaque=False, duration=2.0, flashing=False): | |
| """ a helper to show a specified message on the display for duration seconds. Calling | |
| showMessage twice in rapid successioin will result in replacing the first message with | |
| the contents of the second. | |
| msg may be a single string or a list of strings. A single string will show centered | |
| vertically. A list will be spaced out across the vertical space of the dmd height | |
| the message will appear on top of the animation/layer asset with a key matching the | |
| background_layer parameter. If background_layer is a list, then the elements will be | |
| arranged in a grouped layer and the message will appear on top of that stack of frames | |
| the font_key argument refers to the key (i.e., name) of the font as defined in the asset_yaml | |
| If None is passed then the default message font is used: the font named 'med' in the yaml file | |
| the font_style argument is an instance of HDFontStyle (allowing the caller to set | |
| the border size, border color and fill color of the text) | |
| opaque indicates whether or not the contents below this message will be visible when shown | |
| duration is the maximum number of seconds that this message will be visible on the screen | |
| """ | |
| self.dmdHelper.showMessage(msg, background_layer, font_style, opaque, duration, font_key=font_key, flashing=flashing) | |
| def generateLayer(self, msg, background_layer=None, font_style=None, font_key=None, opaque=False): | |
| """ a helper to generate a frame containing a specified message on top of an image/animation | |
| msg may be a single string or a list of strings. A single string will show centered | |
| vertically. A list will be spaced out across the vertical space of the dmd height | |
| the message will appear on top of the animation/layer asset with a key matching the | |
| background_layer parameter. If background_layer is a list, then the elements will be | |
| arranged in a grouped layer and the message will appear on top of that stack of frames | |
| the font_key argument refers to the key (i.e., name) of the font as defined in the asset_yaml | |
| If None is passed then the default message font is used: the font named 'med' in the yaml file | |
| the font_style argument is an instance of HDFontStyle (allowing the caller to set | |
| the border size, border color and fill color of the text) | |
| opaque indicates whether or not the contents below this message will be visible when shown | |
| """ | |
| return self.dmdHelper.genMsgFrame(msg, background_layer, font_style, font_key, opaque) | |
| def ball_saver_enable(self, num_balls_to_save=1, time=5, now=True, allow_multiple_saves=False, callback=None): | |
| import warnings | |
| message = "'ball_saver_enable' has been phased out. Replace with a call to 'enable_ball_saver()' and handle the 'evt_ball_saved' event for notification." | |
| warnings.simplefilter("error") | |
| warnings.warn(message, DeprecationWarning, stacklevel=2) | |
| # raise NameError, message | |
| def enable_ball_saver(self, num_balls_to_save=1, time=None, now=True, allow_multiple_saves=False, tick_rate=1): | |
| """ turns on the ball saver -- omit time to use the setting from the service menu | |
| --note, if this happens 'too early' in your game, just enable the saver again at | |
| a later point to extend the timer """ | |
| if(self.game_tilted): | |
| self.logger.debug("ball saver enable() request DENIED -- game is tilted") | |
| return | |
| if(time is None): | |
| time = self.user_settings['Gameplay (Feature)']['Ball Save Timer'] | |
| self.logger.debug("ball saver enabled balls=[%d], time left=[%d]" % (num_balls_to_save,time)) | |
| self.ball_save.start(num_balls_to_save, time, now, allow_multiple_saves, tick_rate) | |
| self.ball_save.callback = self.__ball_saved | |
| def __ball_saved(self): | |
| self.notifyModes('evt_ball_saved', args=None, event_complete_fn=None) | |
| def disable_ball_saver(self): | |
| """ use this to end the ball saver early """ | |
| self.logger.debug("ball saver disabled") | |
| self.ball_save.disable() | |
| def get_highscore_data(self): | |
| return highscore.get_highscore_data(self.highscore_categories) | |
| def notifyOfNewMode(self,new_mode): | |
| """ let the skeletongame instance know about the new mode. Use weakref to | |
| record information about the new mode so we don't accidentally keep it | |
| around longer than needed. learning of the new mode happens whenever | |
| an advancedMode is created, and allows skeletongame to handle auto-add/remove | |
| of a mode based on the specified mode_type. | |
| NOTE: if a second instance of the same mode type is created, this raises an error. | |
| Do not re create modes in reset(), just reset() the mode itself | |
| """ | |
| if(weakref.ref(new_mode) in self.known_modes[new_mode.mode_type]): | |
| self.logger.warning("Skel: A second instance of an already known mode has been created '%s'" % new_mode) | |
| raise ValueError, "This cannot happen. Someone notified us of the same mode instance twice!" | |
| for m in self.known_modes[new_mode.mode_type]: | |
| if type(m())==type(new_mode): | |
| raise ValueError, "Your code attempted to create a second instance of the Mode '%s' --this is likely an error." % type(new_mode) | |
| self.known_modes[new_mode.mode_type].append(weakref.ref(new_mode)) | |
| self.logger.debug("Skel: Known advanced modes added '%s'" % new_mode) | |
| # import sys | |
| # for thing in self.known_modes[new_mode.mode_type]: | |
| # self.logger.debug("skel: mode='%s' ref_ct=%d'" % (thing, sys.getrefcount(thing))) | |
| # # Format: evt_name(self): | |
| # handler_func_re = re.compile('evt_(?P<name>[a-zA-Z0-9_]+)?') | |
| # for item in dir(new_mode): | |
| # m = handler_func_re.match(item) | |
| # if m == None: | |
| # continue | |
| # handlerfn = getattr(new_mode, item) | |
| # evt_name = m.group('name') | |
| # self.add_evt_handler(new_mode, evt_name, handler=handlerfn) | |
| def add_evt_handler(self, mode, evt_name): | |
| if(evt_name not in self.event_handlers): | |
| raise ValueError, "Mode: %s defined a function named '%s' which is not known to the Event System" % (mode, evt_name) | |
| self.event_handlers[evt_name].append(weakref.ref(mode)) | |
| def notifyNextMode(self): | |
| self.curr_delayed_by_mode = None | |
| if(len(self.notify_list)==0): | |
| self.event = None | |
| if(self.event_complete_fn is not None): | |
| self.logger.debug("Skel: completing event '%s' by calling '%s'" % (self.event, self.event_complete_fn)) | |
| self.event_complete_fn() | |
| else: | |
| self.logger.debug("Skel: completing event '%s'." % (self.event)) | |
| self.checkOutstandingSGEvents() | |
| return | |
| # otherwise there are more modes awaiting notification | |
| next_handler = self.notify_list.pop() | |
| self.logger.debug("Skel: calling mode '%s' event handler for event '%s'" % (next_handler, self.event)) | |
| d = next_handler.handle_game_event(self.event,params=self.args) | |
| # if(self.args is None): | |
| # d = evt_handler() | |
| # else: | |
| # d = evt_handler(self.args) | |
| if(d is not None and (type(d) is int or type(d) is float)): | |
| if(d == 0): | |
| self.notifyNextMode() | |
| else: | |
| self.curr_delayed_by_mode = next_handler | |
| if(d > 0): | |
| self.switchmonitor.delay(name='notifyNextMode', | |
| event_type=None, | |
| delay=d, | |
| handler=self.notifyNextMode) | |
| # else, handler will need to handle the event itself (self.force_event_next()) | |
| elif(type(d) is tuple): | |
| if(d[1] == True): # flag to stop event propegation and jump to the event | |
| self.notify_list = list() # zero out the list so the next 'notifyNext' call will just call the final event handler | |
| self.logger.info("Skel: Mode '%s' indicates event '%s' is now complete. Blocking further propegation" % (next_handler, self.event)) | |
| if(d[0] > 0): | |
| self.curr_delayed_by_mode = next_handler | |
| self.switchmonitor.delay(name='notifyNextMode', | |
| event_type=None, | |
| delay=d[0], | |
| handler=self.notifyNextMode) | |
| elif(d[0]==0): | |
| # no delay specified | |
| self.notifyNextMode() | |
| else: | |
| # time reported is less than zero (e.g., -1) --user is saying they do not | |
| # want to return a bound on how long they need to handle the event, so | |
| # the mode is responsible for indicating the completion of handling (self.force_event_next()) | |
| self.curr_delayed_by_mode = next_handler | |
| else: | |
| # returning None from an event handler (or not returning at all) means no delay will be given | |
| self.notifyNextMode() | |
| def notifyNextModeNow(self, caller_mode): | |
| if(caller_mode == self.curr_delayed_by_mode): | |
| # okay to notify next | |
| self.logger.info("Skel: notifyNextModeNow called by %s..." % (caller_mode)) | |
| self.switchmonitor.cancel_delayed(name='notifyNextMode') | |
| self.notifyNextMode() | |
| else: | |
| # not okay, wrong caller!! | |
| self.logger.critical("Skel: notifyNextModeNow called by %s, but this mode is not blocking this event! (%s is)!?" % (caller_mode, self.curr_delayed_by_mode)) | |
| def checkOutstandingSGEvents(self): | |
| if(len(self.sg_event_queue)>0): | |
| self.logger.info("Processing SG Event Queue: contains %d events" % len(self.sg_event_queue)) | |
| evt = self.sg_event_queue.pop() | |
| self.notifyModes(evt.name, evt.args, evt.on_complete_fn, evt.only_active_modes) | |
| else: | |
| self.logger.info("SG Event Queue -- All Clear") | |
| def notifyModes(self, event, args=None, event_complete_fn=None, only_active_modes=True): | |
| """ this method will notify all AdvencedMode derived modes of the given event. Modes | |
| will be notified in priority order and notifications happen over time -- that is, | |
| the next mode will be notified after the previous mode has completed dealing with this | |
| notification. To facilitate this, modes that handle the event (by defining a | |
| method of the same name as the event) should respond to notifications by returning a | |
| number of seconds required to complete the handling of this event. Should a method | |
| complete handling of the event earlier than originally anticipated (e.g., a user | |
| skips an animation sequence), that mode should call the AdvancedMode method: | |
| self.force_event_next() | |
| Setting the only_active_modes=False will notify _all_ known modes, not just active | |
| modes. This will be of _very_ limited utility, however is useful for events such as | |
| evt_player_added. | |
| """ | |
| if(self.event is not None): | |
| #We are still processing an event | |
| self.logger.error("Trying to notify modes about new event [%s] while [%s] is still being processed!!" % (event, self.event)) | |
| self.sg_event_queue.append(SGEvent(event,args,event_complete_fn,only_active_modes)) | |
| return | |
| delay = 0 | |
| self.notify_list = [] | |
| self.event_complete_fn = event_complete_fn | |
| self.args = args | |
| # if(event.startswith('evt_')): | |
| # self.event = event[4:] | |
| self.event = event | |
| self.logger.info("Skel: preparing to notify modes of event %s." % event) | |
| if(only_active_modes): | |
| handlers = [h() for h in self.event_handlers[self.event] if h() is not None and h() in self.modes] | |
| else: | |
| handlers = [h() for h in self.event_handlers[self.event] if h() is not None] | |
| for h in handlers: | |
| self.logger.debug("Skel: event '%s' queuing handler found in mode [%s]" % (event, h)) | |
| self.notify_list.append(h) | |
| # note this sort is in reverse priority order because we pop | |
| # off the back! | |
| self.notify_list.sort(lambda x, y: x.priority - y.priority) | |
| self.notifyNextMode() | |
| def quickNotifyModes(self, event, args=None, event_complete_fn=None, only_active_modes=True): | |
| """ this method will notify all AdvencedMode derived modes of the given event. Modes | |
| will be notified in priority order and notifications happen within this run_loop cycle -- that is, | |
| the next mode will be notified immediately after the previous mode has executed its event | |
| handler method. Modes should not respond to notifications by returning a | |
| number of seconds required to complete the handling of this event, because it will be ignored. | |
| Setting the only_active_modes=False will notify _all_ known modes, not just active | |
| modes. This will be of _very_ limited utility, however is useful for events such as | |
| evt_player_added. | |
| """ | |
| if(self.event is not None): | |
| #We are still processing an event | |
| self.logger.info("NOTE: we are notifying modes about a 'quick' event [%s] while a system event [%s] is still being processed!!" % (event, self.event)) | |
| quick_notify_list = [] | |
| self.logger.info("Skel: preparing to notify modes of 'quick' event %s." % event) | |
| if(only_active_modes): | |
| handlers = [h() for h in self.event_handlers[event] if h() is not None and h() in self.modes] | |
| else: | |
| handlers = [h() for h in self.event_handlers[event] if h() is not None] | |
| for h in handlers: | |
| self.logger.debug("Skel: quick event '%s' handler found in mode [%s]" % (event, h)) | |
| quick_notify_list.append(h) | |
| # note this sort is in reverse priority order because we pop | |
| # off the back! | |
| quick_notify_list.sort(lambda x, y: x.priority - y.priority) | |
| for h in quick_notify_list: | |
| self.logger.debug("Skel: quick event '%s' being handled in mode [%s]" % (event, h)) | |
| d = h.handle_game_event(event,params=args) | |
| if(d is not None) and (d!=0): | |
| self.logger.error("modes '%s' has a quick event handler for event [%s] that seems to be requesting additional time. This is not possible!" % (event, h)) | |
| # called when you want to fully reset the game | |
| def reset(self): | |
| self.logger.info("Skel: RESET()") | |
| # reset mid-game can leave Lamps, coils or flippers on. Turn them OFF | |
| # as modes might use delay() to disable them, but those won't run now | |
| self.disableAllLamps() | |
| self.disableAllCoils() | |
| self.enable_flippers(False) | |
| self.enable_alphanumeric_flippers(False) | |
| self.dmdHelper.reset() | |
| if(hasattr(self,'bonus_mode')): | |
| self.bonus_mode.reset() | |
| # clear the notification list | |
| self.notify_list = [] | |
| self.event_complete_fn = None | |
| self.sg_event_queue = [] | |
| self.switchmonitor.cancel_delayed(name='notifyNextMode') | |
| self.event = None | |
| super(SkeletonGame,self).reset() | |
| self.ball_search_tries = 0 | |
| self.game_start_pending = False | |
| # reload settings | |
| self.load_settings_and_stats() | |
| # try to set the game up to be in a clean state from the outset: | |
| if(self.trough.num_balls() < self.num_balls_total): | |
| self.logger.info("Skel: RESET: trough isn't full [%d of %d] -- requesting search" % (self.trough.num_balls(), self.num_balls_total)) | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.perform_search(5, silent=True) | |
| else: | |
| self.do_ball_search(silent=True) | |
| self.modes.add(self.sound) | |
| # handle modes that need to be alerted of the game reset! | |
| for m in self.known_modes[AdvancedMode.System]: | |
| self.modes.add(m()) | |
| self.modes.add(self.trough) | |
| # Only once the ball is fed to the shooter lane is it possible for the ball | |
| # drain to actually end a ball | |
| self.trough.drain_callback = None | |
| self.trough.launch_callback = None | |
| self.trough.launched_callback = self.__install_drain_logic | |
| # Link ball_save to trough | |
| self.trough.ball_save_callback = self.ball_save.launch_callback | |
| self.trough.num_balls_to_save = self.ball_save.get_num_balls_to_save | |
| self.ball_save.trough_enable_ball_save = self.trough.enable_ball_save | |
| # trough fixes | |
| self.modes.add(self.ball_save) | |
| if(self.use_stock_scoredisplay is not False): | |
| self.score_display.reset() | |
| self.modes.add(self.score_display) | |
| self.modes.add(self.ball_search) | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.disable() | |
| # initialize the mode variables; the general form is: | |
| # self.varName = fileName.classModeName(game=self) | |
| # Note this creates the mode and causes the Mode's constructor | |
| # function --aka __init__() to be run | |
| if(self.use_osc_input): | |
| self.modes.modes.append(self.osc) | |
| self.modes.add(self.dmdHelper) | |
| self.modes.add(self.switchmonitor) | |
| def start_attract_mode(self): | |
| self.attract_mode.reset() | |
| self.modes.add(self.attract_mode) # plays the attract mode and kicks off the game | |
| def enable_alphanumeric_flippers(self, enable): | |
| """ overrides the defaults in game.py so that the flipper-relay is checked from the | |
| machine.yaml. Looking for either a coil named 'flipperEnable' or a coil tagged: 'flipper_enable' | |
| If not present, the default value of '79' can be used for WPCAlphanumeric, but is not used for safety. | |
| """ | |
| # 79 corresponds to the circuit on the power/driver board. It will be 79 for all WPCAlphanumeric machines. | |
| self.logger.debug("AN Flipper enable in SkelGame.py called") | |
| flipperEnableCoil = None | |
| if('flipperEnable' in self.coils): | |
| flipperEnableCoil = self.coils.flipperEnable | |
| else: | |
| feList = self.coils.items_tagged('flipper_enable') | |
| if(len(feList)>0): | |
| flipperEnableCoil = feList[0] | |
| if(flipperEnableCoil is not None): | |
| if enable: | |
| flipperEnableCoil.pulse(0) | |
| else: | |
| flipperEnableCoil.disable() | |
| else: | |
| self.logger.warning("No flipperEnable entry in PRCoils section of machine yaml") | |
| def process_config(self): | |
| """Called by :meth:`load_config` and :meth:`load_config_stream` to process the values in :attr:`config`.""" | |
| super(SkeletonGame,self).process_config() | |
| # if ('arduino' in self.config['PRGame'] and self.config['PRGame']['arduino'] != False) : | |
| # comport = self.config['PRGame']['arduino'] | |
| # self.arduino_client = ArduinoClient(comport, baud_rate=14400,timeout=1) | |
| sect_dict = self.config['PRSwitches'] | |
| for name in sect_dict: | |
| item_dict = sect_dict[name] | |
| if ('ballsearch' in item_dict): | |
| self.switches[name].ballsearch = item_dict['ballsearch'] | |
| sect_dict = self.config['PRCoils'] | |
| for name in sect_dict: | |
| item_dict = sect_dict[name] | |
| if ('ballsearch' in item_dict): | |
| self.coils[name].ballsearch = item_dict['ballsearch'] | |
| def load_settings_and_stats(self): | |
| self.load_game_data('game_default_data.yaml','game_user_data.yaml') | |
| game_volume = self.load_volume() | |
| self.logger.info("VOLUME SET TO: %d / %d" % (game_volume, self.sound.get_max_volume())) | |
| if(self.load_settings('game_default_settings.yaml','game_user_settings.yaml')): | |
| # settings changed as a result of reconciling with the default template! re-save | |
| self.user_settings['Sound']['Initial volume'] = game_volume | |
| self.logger.warning('settings changed. Re-Saving!') | |
| self.save_settings() | |
| self.balls_per_game = self.user_settings['Machine (Standard)']['Balls Per Game'] | |
| # self.auto_plunge_strength = self.user_settings['Machine (Coils)']['Auto Plunger'] | |
| self.user_settings['Sound']['Initial volume'] = game_volume | |
| ## high score stuff: | |
| self.highscore_categories = [] | |
| cat = highscore.HighScoreCategory() | |
| cat.game_data_key = 'ClassicHighScores' | |
| cat.titles = ['Grand Champion', 'High Score 1', 'High Score 2', 'High Score 3', 'High Score 4'] | |
| self.highscore_categories.append(cat) | |
| for category in self.highscore_categories: | |
| category.load_from_game(self) | |
| def save_settings(self, filename=None): | |
| if(filename is None): | |
| filename = 'game_user_settings.yaml' | |
| super(SkeletonGame, self).save_settings(os.path.join('config/' + filename)) | |
| def save_game_data(self, filename): | |
| super(SkeletonGame, self).save_game_data(os.path.join('config/' + filename)) | |
| def load_game_data(self, file_default, file_game): | |
| super(SkeletonGame, self).load_game_data(os.path.join('config/' + file_default),os.path.join('config/' + file_game)) | |
| def load_settings(self, file_default, file_game): | |
| return super(SkeletonGame, self).load_settings(os.path.join('config/' + file_default),os.path.join('config/' + file_game)) | |
| def load_assets(self): | |
| """ function to clean up code/make things easier to read; | |
| this handles reading/loading of all assets (sounds, dmd images, | |
| dmd fonts, lightshows) from the file system | |
| """ | |
| self.asset_mgr = assetmanager.AssetManager(game=self) | |
| self.animations = self.asset_mgr.animations | |
| self.fontstyles = self.asset_mgr.fontstyles | |
| self.fonts = self.asset_mgr.fonts | |
| def load_volume(self): | |
| try: | |
| v_file_path = os.path.join('config/game_user_volume.txt') | |
| vol_file = open(v_file_path,'r') | |
| vol = int(vol_file.readline()) | |
| vol_file.close() | |
| self.logger.info("Read volume file value: %d" % vol) | |
| except Exception, e: | |
| self.logger.warning("Loading volume failed: %s" % e) | |
| vol = 5 | |
| self.sound.set_volume_idx(vol) | |
| return vol | |
| def save_volume(self): | |
| try: | |
| v_file_path = os.path.join('config/game_user_volume.txt') | |
| vol_file = open(v_file_path,'w') | |
| vol_file.write(str(self.sound.get_volume_idx())) | |
| vol_file.close() | |
| except Exception, e: | |
| self.logger.warning("Saving volume failed: %s" % e) | |
| def ball_starting(self): | |
| """ this is auto-called when the ball is actually starting | |
| (so happens 3 or more times a game) """ | |
| self.logger.info("Skel: BALL STARTING") | |
| for m in self.known_modes[AdvancedMode.Ball]: | |
| self.modes.add(m()) | |
| self.notifyModes('evt_ball_starting', args=None, event_complete_fn=self.actually_start_ball) | |
| def shoot_again(self): | |
| """ this intentionally does NOT call the super class method because | |
| we want to block 'ball_starting' from being called immediately """ | |
| self.logger.info("Skel: SHOOT AGAIN") | |
| self.notifyModes('evt_shoot_again', args=None, event_complete_fn=self.ball_starting, only_active_modes=False) | |
| def actually_start_ball(self): | |
| super(SkeletonGame, self).ball_starting() | |
| # eject a ball into the shooter lane | |
| self.trough.launch_balls(1) | |
| self.enable_flippers(True) | |
| self.enable_alphanumeric_flippers(True) | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.enable() | |
| def __ball_drained_callback(self): | |
| """ this is the "drain logic" that is called by the trough if a | |
| ball drains --either from a multiball ball ending or from | |
| the trough becoming full """ | |
| if self.trough.num_balls_in_play == 0: | |
| shoot_again = False | |
| last_ball = False | |
| if self.current_player().extra_balls > 0: | |
| shoot_again = True | |
| if self.ball >= self.balls_per_game: | |
| last_ball = True | |
| self.ball_end_time = time.time() | |
| # Calculate ball time and save it because the start time | |
| # gets overwritten when the next ball starts. | |
| self.ball_time = self.get_ball_time() | |
| self.current_player().game_time += self.ball_time | |
| self.game_data['Audits']['Avg Ball Time'] = self.calc_time_average_string(self.game_data['Audits']['Balls Played'], self.game_data['Audits']['Avg Ball Time'], self.ball_time) | |
| self.game_data['Audits']['Balls Played'] += 1 | |
| # can't save here as file might still be open on game end... | |
| # self.save_game_data('game_user_data.yaml') | |
| # Remove ball drained logic until the ball is fed into the shooter lane again | |
| self.trough.drain_callback = None | |
| self.trough.launch_callback = None | |
| self.trough.launched_callback = self.__install_drain_logic | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.disable() | |
| if(self.game_tilted): | |
| self.tilted_ball_end() | |
| else: | |
| self.notifyModes('evt_ball_ending', args=(shoot_again,last_ball), event_complete_fn=self.end_ball) | |
| elif self.trough.num_balls_in_play == 1: | |
| """ TODO: Ensure we are only seeing this event during multiball """ | |
| # ensure this isn't a situation of a fast-drain when more balls are pending launch | |
| if(self.trough.num_balls_to_launch >= 1): | |
| self.logger.warning("one ball in play, but more balls are pending launch (supressing evt_single_ball_play)") | |
| elif(self.game_tilted): | |
| self.logger.info("one ball in play, but game is tilted (supressing evt_single_ball_play)") | |
| else: | |
| self.notifyModes('evt_single_ball_play', args=None, event_complete_fn=None) | |
| else: | |
| self.notifyModes('evt_mb_drain', args=None, event_complete_fn=None) | |
| def your_search_is_over(self): | |
| """ all balls have been accounted for --if you were blocking a game start, stop that. """ | |
| if(self.game_start_pending): | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.full_stop() | |
| self.game_start_pending = False | |
| self.notifyModes('evt_balls_found', args=None, event_complete_fn=None) | |
| # self.game_started() | |
| def volume_down(self): | |
| """ decrease volume and store the new setting """ | |
| volume = self.sound.volume_down() | |
| self.quickNotifyModes('evt_volume_down', args=volume, event_complete_fn=None) | |
| self.user_settings['Sound']['Initial volume'] = int(volume) | |
| self.save_volume() | |
| # self.save_settings() | |
| def volume_up(self): | |
| """ increase volume and store the new setting """ | |
| volume = self.sound.volume_up() | |
| self.quickNotifyModes('evt_volume_up', args=volume, event_complete_fn=None) | |
| self.user_settings['Sound']['Initial volume'] = int(volume) | |
| self.save_volume() | |
| # self.save_settings() | |
| def request_additional_player(self): | |
| """ attempt to add an additional player, but honor the max_players setting """ | |
| if len(self.players) < self.max_players: | |
| p = self.add_player() | |
| else: | |
| self.logger.info("Cannot add more than %d players." % self.max_players) | |
| def add_player(self): | |
| """ add another player (even if there are too many); fires evt_player_added to notify modes that care """ | |
| player = super(SkeletonGame, self).add_player() | |
| self.quickNotifyModes('evt_player_added', args=(player), event_complete_fn=None, only_active_modes=False) | |
| return player | |
| def slam_tilted(self): | |
| self.b_slam_tilted = True | |
| self.game_tilted = True | |
| self.notifyModes('evt_tilt', args=True, event_complete_fn=None) | |
| def slam_tilt_complete(self): | |
| self.b_slam_tilted = False | |
| self.game_tilted = False | |
| self.end_ball() | |
| self.end_game() | |
| self.reset() | |
| def tilt_warning(self, times_warned): | |
| """ called by the 'TiltMonitor' mode to indicate a tilt warning | |
| """ | |
| self.notifyModes('evt_tilt_warning', args=times_warned, event_complete_fn=None) | |
| def tilted(self): | |
| """ called by the 'Tilted' mode to indicate the machine has been tilted; | |
| because evt_ball_ending isn't fired, bonus mode will not be tallied | |
| """ | |
| self.b_slam_tilted = False | |
| self.game_tilted = True | |
| if(self.trough.drain_callback == None): | |
| self.logger.debug("machine tilted before drain logic installed; install it now!") | |
| self.trough.num_balls_to_launch = 0 | |
| self.trough.drain_callback = self.__ball_drained_callback | |
| # TODO: check if the trough is full in a few seconds | |
| self.notifyModes('evt_tilt', args=False, event_complete_fn=None) | |
| def tilted_ball_end(self): | |
| """ called by the 'Tilted' mode to indicate the machine has been | |
| tilted and all balls are back in the trough -- in essence, this | |
| signals a evt_tilt_ball_ending, which is a variant of evt_ball_ending; | |
| because evt_ball_ending isn't fired, bonus mode will not be tallied | |
| """ | |
| self.game_tilted = False | |
| self.tilt_mode.tilt_reset() | |
| self.modes.remove(self.tilted_mode) | |
| if(not self.b_slam_tilted): | |
| self.notifyModes('evt_tilt_ball_ending', args=None, event_complete_fn=self.end_ball) | |
| else: | |
| self.notifyModes('evt_tilt_ball_ending', args=None, event_complete_fn=self.slam_tilt_complete) | |
| def end_ball(self): | |
| """ overides game.py version to prevent ball/game time | |
| increasing (we count it here, to get more accurate data) | |
| note that super is intentionally not called. | |
| this method should only be called following appropriate | |
| event notification --read: don't call this from your game code | |
| unless you really know what you are doing | |
| """ | |
| self.ball_ended() | |
| if self.current_player().extra_balls > 0: | |
| self.current_player().extra_balls -= 1 | |
| self.shoot_again() | |
| return | |
| if self.current_player_index + 1 == len(self.players): | |
| self.ball += 1 | |
| self.current_player_index = 0 | |
| else: | |
| self.current_player_index += 1 | |
| if self.ball > self.balls_per_game: | |
| self.end_game() | |
| else: | |
| self.start_ball() # Consider: Do we want to call this here, or should it be called by the game? (for bonus sequence) | |
| def ball_ended(self): | |
| """ Subclassed by implementor to react to the ball being completely over | |
| automatically invoked by end_ball(). At this point the ball is over """ | |
| self.logger.info("Skel: BALL ENDED") | |
| # turn off the flippers | |
| self.enable_flippers(False) | |
| self.enable_alphanumeric_flippers(False) | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.disable() # possibly redundant if ball ends normally, but not redundant when slam tilted | |
| super(SkeletonGame, self).ball_ended() | |
| for m in self.known_modes[AdvancedMode.Ball]: | |
| self.modes.remove(m()) | |
| def reset_search(self): | |
| if(self.game_start_pending): | |
| # self.clear_status() | |
| self.game_start_pending = False | |
| if(self.trough.num_balls() >= self.num_balls_total): | |
| # we could start now... | |
| # but don't! | |
| # self.game_started() | |
| pass | |
| else: # insufficient balls to start | |
| # don't try again, just shut down the status indicator | |
| # # wait 3s before trying again | |
| # if(self.use_ballsearch_mode): | |
| # self.ball_search.perform_search(3, completion_handler=self.reset_search) | |
| # # self.ball_search.delay(name='ballsearch_start_delay', | |
| # # event_type=None, | |
| # # delay=3, | |
| # # handler=self.game_started) | |
| # else: | |
| # self.do_ball_search(silent=False) | |
| # self.ball_search.delay(name='ballsearch_start_delay', event_type=None, delay=3.0, handler=self.reset_search) | |
| pass | |
| else: | |
| # game started on it's own. Continue living | |
| pass | |
| def game_started(self): | |
| """ this happens after start_game but before start_ball/ball_starting""" | |
| self.logger.info("Skel:Game START Requested...(check trough first)") | |
| # check trough and potentially do a ball search first | |
| if(self.game_start_pending and (self.trough.num_balls() < self.num_balls_total)): | |
| self.logger.info("Skel: Game START : PLEASE WAIT!! -- TROUGH STATE is still BLOCKING GAME START!") | |
| # self.set_status("Balls STILL Missing: PLEASE WAIT!!", 3.0) | |
| self.notifyModes('evt_balls_missing', args=None, event_complete_fn=None) | |
| return | |
| if(self.trough.num_balls() < self.num_balls_total): | |
| self.game_start_pending=True | |
| self.logger.info("Skel: game_started: trough isn't full [%d of %d] -- requesting search" % (self.trough.num_balls(), self.num_balls_total)) | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.perform_search(3, completion_handler=self.reset_search) | |
| self.logger.debug("Skel: game_started: Standard ball search initiated") | |
| else: | |
| self.logger.debug("Skel: game_started: Programmer custom ball search initiated") | |
| self.do_ball_search(silent=False) | |
| self.ball_search.delay(name='ballsearch_start_delay', event_type=None, delay=3.0, handler=self.reset_search) | |
| return | |
| else: # we have the right number of balls | |
| self.game_start_pending=False | |
| if(self.use_ballsearch_mode): | |
| self.ball_search.cancel_delayed(name='ballsearch_start_delay') | |
| self.logger.info("Skel:Game START Proceeding") | |
| # remove attract mode | |
| self.modes.remove(self.attract_mode) | |
| super(SkeletonGame, self).game_started() | |
| for m in self.known_modes[AdvancedMode.Game]: | |
| self.modes.add(m()) | |
| self.ball_search_tries = 0 | |
| self.game_data['Audits']['Games Started'] += 1 | |
| self.save_game_data('game_user_data.yaml') | |
| self.notifyModes('evt_game_starting', args=None, event_complete_fn=self.actually_start_game) | |
| def actually_start_game(self): | |
| # Add the first player | |
| self.add_player() | |
| # Start the ball. This includes ejecting a ball from the trough. | |
| self.start_ball() | |
| def end_game(self): | |
| """Called by the implementor to mark notify the game that the game has ended.""" | |
| # Handle stats for last ball here | |
| self.ball = 0 | |
| self.logger.info("Skel: 'GAME ENDED") | |
| # ball time is handled in ball drained callback | |
| # Also handle game stats. | |
| for i in range(0,len(self.players)): | |
| game_time = self.get_game_time(i) | |
| self.game_data['Audits']['Avg Game Time'] = self.calc_time_average_string( self.game_data['Audits']['Games Played'], self.game_data['Audits']['Avg Game Time'], game_time) | |
| self.game_data['Audits']['Avg Score'] = self.calc_number_average(self.game_data['Audits']['Games Played'], self.game_data['Audits']['Avg Score'], self.players[i].score) | |
| self.game_data['Audits']['Games Played'] += 1 | |
| self.logger.info("Skel: 'player %d score %d" % (i, self.players[i].score)) | |
| self.save_game_data('game_user_data.yaml') | |
| # show any animations you want in ball_ending | |
| self.notifyModes('evt_game_ending', args=None, event_complete_fn=self.game_ended) | |
| def game_ended(self): | |
| super(SkeletonGame, self).game_ended() | |
| self.disableAllLamps() | |
| # remove Game-duration modes | |
| for m in self.known_modes[AdvancedMode.Game]: | |
| self.modes.remove(m()) | |
| pass | |
| seq_manager = highscore.HD_EntrySequenceManager(game=self, priority=2, multiline=self.use_multiline_score_entry) | |
| seq_manager.finished_handler = self.high_score_entry_completed | |
| seq_manager.logic = highscore.CategoryLogic(game=self, categories=self.highscore_categories) | |
| seq_manager.ready_handler = self.__pre_high_score_entry | |
| self.modes.add(seq_manager) | |
| def __pre_high_score_entry(self, seq_manager, category): | |
| self.notifyModes('evt_initial_entry', args=category, event_complete_fn=seq_manager.prompt) | |
| def high_score_entry_completed(self, mode): | |
| self.save_game_data('game_user_data.yaml') | |
| self.modes.remove(mode) | |
| self.notifyModes('evt_game_ended', args=None, event_complete_fn=self.reset) | |
| def calc_time_average_string(self, prev_total, prev_x, new_value): | |
| prev_time_list = prev_x.split(':') | |
| prev_time = (int(prev_time_list[0]) * 60) + int(prev_time_list[1]) | |
| avg_game_time = int((int(prev_total) * int(prev_time)) + int(new_value)) / (int(prev_total) + 1) | |
| avg_game_time_min = avg_game_time/60 | |
| avg_game_time_sec = str(avg_game_time%60) | |
| if len(avg_game_time_sec) == 1: | |
| avg_game_time_sec = '0' + avg_game_time_sec | |
| return_str = str(avg_game_time_min) + ':' + avg_game_time_sec | |
| return return_str | |
| def calc_number_average(self, prev_total, prev_x, new_value): | |
| avg_game_time = int((prev_total * prev_x) + new_value) / (prev_total + 1) | |
| return int(avg_game_time) | |
| def dmd_event(self): | |
| self.dmd.update() | |
| def start_service_mode(self): | |
| """ dump all existing modes that are running | |
| stop music, stop lampshows, disable flippers | |
| then add the service mode. | |
| """ | |
| self.modes.modes = [m for m in self.modes.modes if isinstance(m,AdvancedMode) and m.mode_type==AdvancedMode.System] | |
| for m in self.modes: | |
| self.modes.remove(m) | |
| self.lampctrl.stop_show() | |
| self.rgbshow_player.stop_all() | |
| self.disableAllLamps() | |
| self.sound.stop_music() | |
| # disable flippers | |
| self.enable_flippers(False) | |
| self.enable_alphanumeric_flippers(False) | |
| self.modes.add(self.service_mode) | |
| def service_mode_ended(self): | |
| self.save_settings() | |
| self.load_settings_and_stats() | |
| self.reset() | |
| def disableAllCoils(self): | |
| """ turn off all coils | |
| needed after a reset while the game is in progress, we don't want | |
| to leave coils energized that might have been disabled by now cancelled | |
| delays | |
| # NOTE: If this behavior is undesirable in your machine, define your own reset method | |
| and re-engergize any coils you need to OR define your own disableAllCoils that | |
| leaves some on | |
| """ | |
| for coil in self.coils: | |
| coil.disable() | |
| def disableAllLamps(self): | |
| # turn off all the lamps | |
| for lamp in self.lamps: | |
| lamp.disable() | |
| def create_player(self, name): | |
| # do NOT call the super class, we replace the | |
| # player with our own 'advancedPlayerRecord' | |
| # | |
| # super(SkeletonGame,self).create_player(name) | |
| return AdvPlayer(name) | |
| def setPlayerState(self, key, val): | |
| if (self.ball != 0): | |
| self.p = self.current_player() | |
| self.p.setState(key,val) | |
| def adjPlayerState(self, key, delta): | |
| if (self.ball != 0): | |
| self.p = self.current_player() | |
| self.p.adjState(key, delta) | |
| def getPlayerState(self, key, default = None): | |
| if (self.ball != 0): | |
| self.p = self.current_player() | |
| return self.p.getState(key, default) | |
| def bonus(self, name, quantity=1, value=None): | |
| """ value is not required if the bonus has been predefined """ | |
| if (self.ball != 0): | |
| self.p = self.current_player() | |
| self.p.awardBonus(name,quantity, value) | |
| def run_loop(self, min_seconds_per_cycle=None): | |
| #sdl2_DisplayManager.inst().show_window(True) | |
| super(SkeletonGame, self).run_loop(min_seconds_per_cycle) | |
| def do_ball_search(self, silent=False): | |
| self.ball_search_tries += 1 | |
| if(not silent): | |
| # self.set_status("Balls Missing: PLEASE WAIT!!", 3.0) | |
| self.notifyModes('evt_balls_missing', args=None, event_complete_fn=None) | |
| class SGEvent(object): | |
| """An object to hold an SGEvent; useful if multiple events come in at a time""" | |
| def __init__(self, event_name, evt_args, on_complete_fn, only_active_modes): | |
| super(SGEvent, self).__init__() | |
| self.name = event_name | |
| self.args = evt_args | |
| self.on_complete_fn = on_complete_fn | |
| self.only_active_modes = only_active_modes | |
| class AdvPlayer(Player): | |
| """Represents a player in the game. | |
| The game maintains a collection of players in :attr:`GameController.players`.""" | |
| # parent class tracks: score, name, extra_balls, and game_time | |
| # this class adds: | |
| state_tracking = {} | |
| """ player-specific mode progress variables (owned by the specific player and | |
| kept between balls, across players """ | |
| bonus_records = None | |
| """ the information about bonuses awarded to the player on this ball (or held over) """ | |
| def __init__(self, name): | |
| super(AdvPlayer, self).__init__(name) | |
| self.bonuses = BonusRecord() | |
| self.state_tracking = {} | |
| def awardBonus(self, name, quantity=1, point_value=None): | |
| """ adds an entry for `quantity` more bonuses named `name` | |
| assuming the bonus has been defined, the point_value per each | |
| is considered. If the bonus has not previously defined, this | |
| also defines the value (which should be awarded at end_of_ball) | |
| """ | |
| self.bonuses.award(name,quantity, point_value) | |
| def getBonusList(self): | |
| t = self.bonuses.earned_list | |
| if(not self.bonuses.bonus_held): | |
| self.bonuses.earned_list = [] | |
| return t | |
| def setState(self, key, val): | |
| self.state_tracking[key] = val | |
| def adjState(self, key, delta): | |
| v = self.state_tracking[key] | |
| v = v + delta | |
| self.state_tracking[key] = v | |
| def getState(self, key, default = None): | |
| return self.state_tracking.get(key,default) | |
| class BonusRecord(object): | |
| """ represents a list of the bonuses awarded to the player, as well as | |
| all possible bonuses, their display order (in ball_end animation) | |
| and the bonus types (award: once, many, max); this is used by the | |
| ball_end animation Mode: BonusTally to show the player their bonus """ | |
| bonus_held = False | |
| master_list = [] | |
| """ a list of all possible bonuses and their orders """ | |
| earned_list = [] | |
| """ list of key/val pairs (dict) mapping bonus name to the current number awarded for this player | |
| values should be 0 (not awarded!?), 1 (once only), 2, ..., N | |
| """ | |
| def __init__(self): | |
| self.bonus_held = False | |
| self.earned_list = [] | |
| @classmethod | |
| def define_bonus(cls, name, point_value, max_per_ball=float('inf'), max_per_game=float('inf')): | |
| """ defines a point value for a specific named bonus """ | |
| master = find_in_list(name, cls.master_list) | |
| if(master is not None): | |
| logging.getLogger('Bonus').warning("trying to redefine existing bonus named ['%s']" % name) | |
| else: | |
| logging.getLogger('Bonus').info("defining bonus ['%s']" % name) | |
| master = { 'name':name, | |
| 'points': point_value, | |
| 'max_ball': max_per_ball, | |
| 'max_game': max_per_game, | |
| 'order':len(cls.master_list)} | |
| cls.master_list.append(master) | |
| logging.getLogger('Bonus').info("master list ['%s']" % cls.master_list) | |
| def award(self, name, quantity=1, point_value=None): | |
| """ adds an entry for `quantity` more bonuses named `name` | |
| assuming the bonus has been defined, the point_value per each | |
| is considered. If the bonus has not previously defined, this | |
| also defines the value (which should be awarded at end_of_ball) | |
| """ | |
| master = find_in_list(name, self.master_list) | |
| if(master is None): | |
| logging.getLogger('Bonus').warning("trying to award bonus ['%s'] which is not defined in master list" % name) | |
| master = { 'name':name, | |
| 'points': 1000 if point_value is None else point_value, | |
| 'max_ball':float('inf'), | |
| 'max_game':float('inf'), | |
| 'order':len(self.master_list)} | |
| self.master_list.append(master) | |
| prev_award = find_in_list(name, self.earned_list) | |
| if(prev_award is None): | |
| prev_award = {'name':name, 'count':0, 'points':master['points']} | |
| self.earned_list.append(prev_award) | |
| if(prev_award['count'] < master['max_ball'] and prev_award['count'] < master['max_game']): | |
| prev_award['count'] = prev_award['count'] + quantity | |
| else: | |
| logging.getLogger('Bonus').info("Bonus ['%s'] at max!" % name) | |
| print("==================") | |
| print("%s" % self.earned_list) | |
| print("%s" % self.master_list) | |
| print("==================") | |
| @classmethod | |
| def parse_from_file(cls, bonus_def_file): | |
| # read a yaml fie and load all the bonuses | |
| try: | |
| values = yaml.load(open(bonus_def_file, 'r')) | |
| except yaml.scanner.ScannerError, e: | |
| raise | |
| except Exception, e: | |
| values = dict() | |
| if "BonusDefs" in values: | |
| bdefs = values["BonusDefs"] | |
| for bonus_record_dict in bdefs: | |
| n = bonus_record_dict.keys()[0] | |
| bonus_record = value_for_key(bonus_record_dict,n) | |
| p = value_for_key(bonus_record,'points') | |
| mpb = value_for_key(bonus_record,'max_per_ball', float('inf')) | |
| mpg = value_for_key(bonus_record,'max_per_game', float('inf')) | |
| cls.define_bonus(n, p, mpb, mpg) | |
| pass | |
| def find_in_list(name, list): | |
| found_item = next((tmpItem for tmpItem in list if tmpItem["name"] == name), None) | |
| return found_item | |
| ## the following just set things up such that you can run Python ExampleGame.py | |
| # and it will create an instance of the correct game objct and start running it! | |
| def main(): | |
| # initialize the sound playback hardware | |
| pygame.mixer.pre_init(44100,-16,2,512) | |
| # print pygame.mixer.get_init() | |
| game = None | |
| game = SkeletonGame() | |
| game.run_loop() | |
| del game | |
| if __name__ == '__main__': | |
| main() |