def _load_config(self): # creates the main config dictionary from the YAML machine config files. self.config = dict() # load the MPF config & machine defaults self.config = Config.load_config_yaml( config=self.config, yaml_file=self.options['mpfconfigfile']) # Find the machine_files location. If it starts with a forward or # backward slash, then we assume it's from the mpf root. Otherwise we # assume it's from the subfolder location specified in the # mpfconfigfile location if (self.options['machinepath'].startswith('/') or self.options['machinepath'].startswith('\\')): machine_path = self.options['machinepath'] else: machine_path = os.path.join( self.config['mpf']['paths']['machine_files'], self.options['machinepath']) self.machine_path = os.path.abspath(machine_path) # Add the machine folder to our path so we can import modules from it sys.path.append(self.machine_path) self.log.info("Machine folder: %s", machine_path) # Now find the config file location. Same as machine_file with the # slash uses to specify an absolute path if (self.options['configfile'].startswith('/') or self.options['configfile'].startswith('\\')): config_file = self.options['configfile'] else: if not self.options['configfile'].endswith('.yaml'): self.options['configfile'] += '.yaml' config_file = os.path.join(machine_path, self.config['mpf']['paths']['config'], self.options['configfile']) self.log.info("Base machine config file: %s", config_file) # Load the machine-specific config self.config = Config.load_config_yaml(config=self.config, yaml_file=config_file)
def _load_config(self): # creates the main config dictionary from the YAML machine config files. self.config = dict() # load the MPF config & machine defaults self.config = Config.load_config_yaml(config=self.config, yaml_file=self.options['mpfconfigfile']) # Find the machine_files location. If it starts with a forward or # backward slash, then we assume it's from the mpf root. Otherwise we # assume it's from the subfolder location specified in the # mpfconfigfile location if (self.options['machinepath'].startswith('/') or self.options['machinepath'].startswith('\\')): machine_path = self.options['machinepath'] else: machine_path = os.path.join(self.config['mpf']['paths'] ['machine_files'], self.options['machinepath']) self.machine_path = os.path.abspath(machine_path) # Add the machine folder to our path so we can import modules from it sys.path.append(self.machine_path) self.log.info("Machine folder: %s", machine_path) # Now find the config file location. Same as machine_file with the # slash uses to specify an absolute path if (self.options['configfile'].startswith('/') or self.options['configfile'].startswith('\\')): config_file = self.options['configfile'] else: if not self.options['configfile'].endswith('.yaml'): self.options['configfile'] += '.yaml' config_file = os.path.join(machine_path, self.config['mpf']['paths']['config'], self.options['configfile']) self.log.info("Base machine config file: %s", config_file) # Load the machine-specific config self.config = Config.load_config_yaml(config=self.config, yaml_file=config_file)
def _load_mode(self, mode_string): """Loads a mode, reads in its config, and creates the Mode object. Args: mode: String name of the mode you're loading. This is the name of the mode's folder in your game's machine_files/modes folder. """ self.log.info('Processing mode: %s', mode_string) mode_path = os.path.join( self.machine.machine_path, self.machine.config['mediacontroller']['paths']['modes'], mode_string) mode_config_file = os.path.join( self.machine.machine_path, self.machine.config['mediacontroller']['paths']['modes'], mode_string, 'config', mode_string + '.yaml') config = Config.load_config_yaml(yaml_file=mode_config_file) if 'code' in config['mode']: import_str = ('modes.' + mode_string + '.code.' + config['mode']['code'].split('.')[0]) i = __import__(import_str, fromlist=['']) mode_object = getattr(i, config['mode']['code'].split('.')[1])( self.machine, config, mode_string, mode_path) else: mode_object = Mode(self.machine, config, mode_string, mode_path) return mode_object
def _load_mode(self, mode_string): """Loads a mode, reads in its config, and creates the Mode object. Args: mode: String name of the mode you're loading. This is the name of the mode's folder in your game's machine_files/modes folder. """ self.log.info('Processing mode: %s', mode_string) mode_path = os.path.join(self.machine.machine_path, self.machine.config['mediacontroller']['paths']['modes'], mode_string) mode_config_file = os.path.join(self.machine.machine_path, self.machine.config['mediacontroller']['paths']['modes'], mode_string, 'config', mode_string + '.yaml') config = Config.load_config_yaml(yaml_file=mode_config_file) if 'code' in config['mode']: import_str = ('modes.' + mode_string + '.code.' + config['mode']['code'].split('.')[0]) i = __import__(import_str, fromlist=['']) mode_object = getattr(i, config['mode']['code'].split('.')[1])( self.machine, config, mode_string, mode_path) else: mode_object = Mode(self.machine, config, mode_string, mode_path) return mode_object
def _load_mode(self, mode_string): """Loads a mode, reads in its config, and creates the Mode object. Args: mode: String name of the mode you're loading. This is the name of the mode's folder in your game's machine_files/modes folder. """ self.log.debug('Processing mode: %s', mode_string) config = dict() # Is there an MPF default config for this mode? If so, load it first mpf_mode_config = os.path.join( 'mpf', self.machine.config['media_controller']['paths']['modes'], mode_string, 'config', mode_string + '.yaml') if os.path.isfile(mpf_mode_config): config = Config.load_config_yaml(yaml_file=mpf_mode_config) # Now figure out if there's a machine-specific config for this mode, and # if so, merge it into the config mode_path = os.path.join(self.machine.machine_path, self.machine.config['media_controller']['paths']['modes'], mode_string) mode_config_file = os.path.join(self.machine.machine_path, self.machine.config['media_controller']['paths']['modes'], mode_string, 'config', mode_string + '.yaml') if os.path.isfile(mode_config_file): config = Config.load_config_yaml(config=config, yaml_file=mode_config_file) return Mode(self.machine, config, mode_string, mode_path)
def _load_mode(self, mode_string): """Loads a mode, reads in its config, and creates the Mode object. Args: mode: String name of the mode you're loading. This is the name of the mode's folder in your game's machine_files/modes folder. """ if self.debug: self.log.debug('Processing mode: %s', mode_string) config = dict() # Is there an MPF default config for this mode? If so, load it first mpf_mode_config = os.path.join( 'mpf', self.machine.config['mpf']['paths']['modes'], mode_string, 'config', mode_string + '.yaml') if os.path.isfile(mpf_mode_config): config = Config.load_config_yaml(yaml_file=mpf_mode_config) # Now figure out if there's a machine-specific config for this mode, and # if so, merge it into the config mode_path = os.path.join(self.machine.machine_path, self.machine.config['mpf']['paths']['modes'], mode_string) mode_config_file = os.path.join(self.machine.machine_path, self.machine.config['mpf']['paths']['modes'], mode_string, 'config', mode_string + '.yaml') if os.path.isfile(mode_config_file): config = Config.load_config_yaml(config=config, yaml_file=mode_config_file) if 'code' in config['mode']: # need to figure out if this mode code is in the machine folder or # the default mpf folder mode_code_file = os.path.join(self.machine.machine_path, self.machine.config['mpf']['paths']['modes'], mode_string, 'code', config['mode']['code'].split('.')[0] + '.py') if os.path.isfile(mode_code_file): # code is in the machine folder import_str = (self.machine.config['mpf']['paths']['modes'] + '.' + mode_string + '.code.' + config['mode']['code'].split('.')[0]) i = __import__(import_str, fromlist=['']) if self.debug: self.log.debug("Loading Mode class code from %s", mode_code_file) mode_object = getattr(i, config['mode']['code'].split('.')[1])( self.machine, config, mode_string, mode_path) else: # code is in the mpf folder import_str = ('mpf.' + self.machine.config['mpf']['paths']['modes'] + '.' + mode_string + '.code.' + config['mode']['code'].split('.')[0]) i = __import__(import_str, fromlist=['']) if self.debug: self.log.debug("Loading Mode class code from %s", import_str) mode_object = getattr(i, config['mode']['code'].split('.')[1])( self.machine, config, mode_string, mode_path) else: # no code specified, so using the default Mode class if self.debug: self.log.debug("Loading default Mode class code") mode_object = Mode(self.machine, config, mode_string, mode_path) return mode_object
def __init__(self, options): self.options = options self.log = logging.getLogger("MediaController") self.log.info("Media Controller Version %s", version.__version__) self.log.info("Backbox Control Protocol Version %s", version.__bcp_version__) self.log.info("Config File Version %s", version.__config_version__) python_version = sys.version_info self.log.info("Python version: %s.%s.%s", python_version[0], python_version[1], python_version[2]) self.log.info("Platform: %s", sys.platform) self.log.info("Python executable location: %s", sys.executable) self.log.info("32-bit Python? %s", sys.maxsize < 2**32) self.config = dict() self.done = False # todo self.machine_path = None self.asset_managers = dict() self.num_assets_to_load = 0 self.window = None self.window_manager = None self.pygame = False self.pygame_requested = False self.registered_pygame_handlers = dict() self.pygame_allowed_events = list() self.socket_thread = None self.receive_queue = Queue.Queue() self.sending_queue = Queue.Queue() self.crash_queue = Queue.Queue() self.game_modes = CaseInsensitiveDict() self.player_list = list() self.player = None self.HZ = 0 self.next_tick_time = 0 self.secs_per_tick = 0 Task.Create(self._check_crash_queue) self.bcp_commands = {'hello': self.bcp_hello, 'goodbye': self.bcp_goodbye, 'reset': self.reset, 'mode_start': self.bcp_mode_start, 'mode_stop': self.bcp_mode_stop, 'error': self.bcp_error, 'ball_start': self.bcp_ball_start, 'ball_end': self.bcp_ball_end, 'game_start': self.bcp_game_start, 'game_end': self.bcp_game_end, 'player_added': self.bcp_player_add, 'player_variable': self.bcp_player_variable, 'player_score': self.bcp_player_score, 'player_turn_start': self.bcp_player_turn_start, 'attract_start': self.bcp_attract_start, 'attract_stop': self.bcp_attract_stop, 'trigger': self.bcp_trigger, 'switch': self.bcp_switch, 'get': self.bcp_get, 'set': self.bcp_set, 'config': self.bcp_config, 'timer': self.bcp_timer } # load the MPF config & machine defaults self.config = ( Config.load_config_yaml(config=self.config, yaml_file=self.options['mcconfigfile'])) # Find the machine_files location. If it starts with a forward or # backward slash, then we assume it's from the mpf root. Otherwise we # assume it's from the subfolder location specified in the # mpfconfigfile location if (options['machinepath'].startswith('/') or options['machinepath'].startswith('\\')): machine_path = options['machinepath'] else: machine_path = os.path.join(self.config['mediacontroller']['paths'] ['machine_files'], options['machinepath']) self.machine_path = os.path.abspath(machine_path) # Add the machine folder to our path so we can import modules from it sys.path.append(self.machine_path) self.log.info("Machine folder: %s", machine_path) # Now find the config file location. Same as machine_file with the # slash uses to specify an absolute path if (options['configfile'].startswith('/') or options['configfile'].startswith('\\')): config_file = options['configfile'] else: if not options['configfile'].endswith('.yaml'): options['configfile'] += '.yaml' config_file = os.path.join(self.machine_path, self.config['mediacontroller']['paths'] ['config'], options['configfile']) self.log.info("Base machine config file: %s", config_file) # Load the machine-specific config self.config = Config.load_config_yaml(config=self.config, yaml_file=config_file) mediacontroller_config_spec = ''' exit_on_disconnect: boolean|True port: int|5050 ''' self.config['mediacontroller'] = ( Config.process_config(mediacontroller_config_spec, self.config['mediacontroller'])) self.events = EventManager(self) self.timing = Timing(self) # Load the media controller modules self.config['mediacontroller']['modules'] = ( self.config['mediacontroller']['modules'].split(' ')) for module in self.config['mediacontroller']['modules']: self.log.info("Loading module: %s", module) module_parts = module.split('.') exec('self.' + module_parts[0] + '=' + module + '(self)') # todo there's probably a more pythonic way to do this, and I know # exec() is supposedly unsafe, but meh, if you have access to put # malicious files in the system folder then you have access to this # code too. self.start_socket_thread() self.events.post("init_phase_1") self.events.post("init_phase_2") self.events.post("init_phase_3") self.events.post("init_phase_4") self.events.post("init_phase_5") self.reset()