Changeset 810


Ignore:
Timestamp:
03/09/11 05:23:21 (8 years ago)
Author:
aspidites
Message:

Patch by Aspidites

  • Removed SystemDataDirectory? and UserDataDirectory?
    • it is the the settings module's job to keep track of this sort of thing, not fife or PARPG's
    • consequently, setting.py's command line interface became simple
    • this will also prevent those "I generated a settings file but PARPG doesnt run" complaints
    • I think I'm going to have some helper methods to generate platform-specific paths at run-time
  • User data directory is now properly created
  • added platform_paths(system) which returns the platform-specific paths for the given system
  • if no system is given, it gives the paths for the system that the script was run on
  • changed logic of settings.py so that it is not required to pass a path.
  • not passing a path invokes paltform_paths
Location:
branches/active/character_customization/game
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • branches/active/character_customization/game/dialogue_demo.py

    r809 r810  
    8686    to select one for testing. 
    8787    """ 
    88     dialogue_dir = os.path.join(settings.fife.SystemDataDirectory,  
     88    dialogue_dir = os.path.join(settings.paths['system'],  
    8989                                settings.parpg.DialoguesDirectory) 
    9090    dialogue_files = [file_name for file_name in os.listdir(dialogue_dir)  
  • branches/active/character_customization/game/parpg/application.py

    r809 r810  
    111111        """Initialise the instance. 
    112112           @return: None""" 
    113         self._setting = setting.fife 
     113        self._setting = setting 
    114114        self.engine = fife.Engine() 
    115         fonts_dir = os.path.join(self._setting.SystemDataDirectory, 
    116                                  self._setting.FontsDirectory) 
     115        fonts_dir = os.path.join(self._setting.paths['system'], 
     116                                 self._setting.fife.FontsDirectory) 
    117117        self.fonts_directory = fonts_dir 
    118118        self.loadSettings() 
     
    147147                                            self.view,  
    148148                                            self.model) 
    149         #start_map = self._setting.get("PARPG", "Map") 
     149        #start_map = self._setting.fife.get("PARPG", "Map") 
    150150        #self.model.changeMap(start_map) 
    151151 
     
    165165 
    166166        engineSetting = self.engine.getSettings() 
    167         engineSetting.setDefaultFontGlyphs(self._setting.FontGlyphs) 
     167        engineSetting.setDefaultFontGlyphs(self._setting.fife.FontGlyphs) 
    168168        engineSetting.setDefaultFontPath(os.path.join(self.fonts_directory, 
    169                                                        self._setting.Font)) 
    170         engineSetting.setDefaultFontSize(self._setting.DefaultFontSize) 
    171         engineSetting.setBitsPerPixel(self._setting.BitsPerPixel) 
    172         engineSetting.setInitialVolume(self._setting.InitialVolume) 
    173         engineSetting.setSDLRemoveFakeAlpha(self._setting.SDLRemoveFakeAlpha) 
    174         engineSetting.setScreenWidth(self._setting.ScreenWidth) 
    175         engineSetting.setScreenHeight(self._setting.ScreenHeight) 
    176         engineSetting.setRenderBackend(self._setting.RenderBackend) 
    177         engineSetting.setFullScreen(self._setting.FullScreen) 
    178         engineSetting.setVideoDriver(self._setting.VideoDriver) 
    179         engineSetting.setLightingModel(self._setting.Lighting) 
    180         engineSetting.setColorKeyEnabled(self._setting.ColorKeyEnabled) 
     169                                                       self._setting.fife.Font)) 
     170        engineSetting.setDefaultFontSize(self._setting.fife.DefaultFontSize) 
     171        engineSetting.setBitsPerPixel(self._setting.fife.BitsPerPixel) 
     172        engineSetting.setInitialVolume(self._setting.fife.InitialVolume) 
     173        engineSetting.setSDLRemoveFakeAlpha(self._setting.fife.SDLRemoveFakeAlpha) 
     174        engineSetting.setScreenWidth(self._setting.fife.ScreenWidth) 
     175        engineSetting.setScreenHeight(self._setting.fife.ScreenHeight) 
     176        engineSetting.setRenderBackend(self._setting.fife.RenderBackend) 
     177        engineSetting.setFullScreen(self._setting.fife.FullScreen) 
     178        engineSetting.setVideoDriver(self._setting.fife.VideoDriver) 
     179        engineSetting.setLightingModel(self._setting.fife.Lighting) 
     180        engineSetting.setColorKeyEnabled(self._setting.fife.ColorKeyEnabled) 
    181181 
    182182        engineSetting.setColorKey(*[int(digit)  
    183                                     for digit in self._setting.ColorKey]) 
    184  
    185         engineSetting.setWindowTitle(self._setting.WindowTitle) 
    186         engineSetting.setWindowIcon(os.path.join(self._setting.SystemDataDirectory,  
    187                                                  self._setting.IconsDirectory, 
    188                                                  self._setting.WindowIcon)) 
     183                                    for digit in self._setting.fife.ColorKey]) 
     184 
     185        engineSetting.setWindowTitle(self._setting.fife.WindowTitle) 
     186        engineSetting.setWindowIcon(os.path.join(self._setting.paths['system'],  
     187                                                 self._setting.fife.IconsDirectory, 
     188                                                 self._setting.fife.WindowIcon)) 
    189189 
    190190    def createListener(self): 
  • branches/active/character_customization/game/parpg/controllerbase.py

    r809 r810  
    8484        """Reset cursor to default image. 
    8585           @return: None""" 
    86         image = os.path.join(self.model.settings.fife.SystemDataDirectory, 
     86        image = os.path.join(self.model.settings.paths['system'], 
    8787                             self.model.settings.parpg.GuiDirectory, 
    8888                             self.model.settings.parpg.CursorDirectory, 
  • branches/active/character_customization/game/parpg/gamemodel.py

    r809 r810  
    5858        @return: None""" 
    5959        self.settings = settings 
    60         data_dir = self.settings.fife.SystemDataDirectory 
    6160 
    6261        self.map_change = False 
    6362        self.load_saver = False 
    6463        self.savegame = None 
    65         quests_directory = os.path.join(data_dir, 
     64        quests_directory = os.path.join(self.settings.paths['system'], 
    6665                                        self.settings.parpg.QuestsDirectory) 
    6766        self.game_state = GameState(quests_dir=quests_directory) 
     
    8079 
    8180        # set values from settings 
    82         maps_file = os.path.join(data_dir, self.settings.parpg.MapsDirectory, 
     81        maps_file = os.path.join(self.settings.paths['system'],  
     82                                 self.settings.parpg.MapsDirectory, 
    8383                                 self.settings.parpg.MapsFile) 
    8484        self.game_state.maps_file = maps_file 
    85         all_agents_file = os.path.join(data_dir,  
     85        all_agents_file = os.path.join(self.settings.paths['system'], 
    8686                                       self.settings.parpg.MapsDirectory, 
    8787                                       self.settings.parpg.AllAgentsFile) 
    8888        self.all_agents_file = all_agents_file 
    89         objects_dir = os.path.join(data_dir, 
     89        objects_dir = os.path.join(self.settings.paths['system'], 
    9090                                    self.settings.parpg.ObjectsDirectory) 
    9191        self.objects_directory = objects_dir 
     
    9393                                      self.settings.parpg.ObjectDatabaseFile) 
    9494        self.object_db_file = object_db_file 
    95         dialogues_dir = os.path.join(data_dir,  
     95        dialogues_dir = os.path.join(self.settings.paths['system'],  
    9696                                     self.settings.parpg.DialoguesDirectory) 
    9797        self.dialogues_directory = dialogues_dir 
  • branches/active/character_customization/game/parpg/gamescenecontroller.py

    r809 r810  
    135135            # F7 saves a screenshot to screenshots directory 
    136136 
    137             fife_ = self.model.settings.fife 
    138             parpg_ = self.model.settings.parpg 
    139             screenshot_directory = os.path.join(fife_.UserDataDirectory, 
    140                                            parpg_.ScreenshotsDirectory) 
     137            settings = self.model.settings 
     138            screenshot_directory = os.path.join(settings.paths['user'], 
     139                                           settings.parpg.ScreenshotsDirectory) 
    141140            # try to create the screenshots directory 
    142141            try: 
     
    258257                direction[0] += 1 
    259258                direction[1] -= 1 
    260                 image = os.path.join(settings.fife.SystemDataDirectory, 
     259                image = os.path.join(settings.paths['system'], 
    261260                                     settings.parpg.GuiDirectory, 
    262261                                     settings.parpg.CursorDirectory, 
     
    267266                direction[0] += 1 
    268267                direction[1] += 1 
    269                 image = os.path.join(settings.fife.SystemDataDirectory, 
     268                image = os.path.join(settings.paths['system'], 
    270269                                     settings.parpg.GuiDirectory, 
    271270                                     settings.parpg.CursorDirectory, 
     
    276275                direction[0] -= 1 
    277276                direction[1] += 1 
    278                 image = os.path.join(settings.fife.SystemDataDirectory, 
     277                image = os.path.join(settings.paths['system'], 
    279278                                     settings.parpg.GuiDirectory, 
    280279                                     settings.parpg.CursorDirectory, 
     
    285284                direction[0] -= 1 
    286285                direction[1] -= 1 
    287                 image = os.path.join(settings.fife.SystemDataDirectory, 
     286                image = os.path.join(settings.paths['system'], 
    288287                                     settings.parpg.GuiDirectory, 
    289288                                     settings.parpg.CursorDirectory, 
  • branches/active/character_customization/game/parpg/gui/filebrowser.py

    r809 r810  
    4848         
    4949        self.extensions = extensions 
    50         self.path = os.path.join(self.settings.fife.UserDataDirectory, 
     50        self.path = os.path.join(self.settings.paths['user'], 
    5151                                 self.settings.parpg.SavesDirectory) 
    5252        self.dir_list = [] 
  • branches/active/character_customization/game/parpg/gui/hud.py

    r809 r810  
    274274            @return: None""" 
    275275        self.stopActions() 
    276         xml_path = os.path.join(self.settings.fife.SystemDataDirectory, 
     276        xml_path = os.path.join(self.settings.paths['system'], 
    277277                                    self.settings.parpg.GuiDirectory, 
    278278                                    'savebrowser.xml') 
     
    319319            @return: None""" 
    320320        self.stopActions() 
    321         xml_path = os.path.join(self.settings.fife.SystemDataDirectory, 
     321        xml_path = os.path.join(self.settings.paths['system'], 
    322322                                    self.settings.parpg.GuiDirectory, 
    323323                                    'loadbrowser.xml') 
  • branches/active/character_customization/game/parpg/mainmenuview.py

    r809 r810  
    8282        """ Called when the user wants to load a game. 
    8383            @return: None""" 
    84         xml_path = os.path.join(self.model.settings.fife.SystemDataDirectory, 
     84        xml_path = os.path.join(self.model.settings.paths['system'], 
    8585                                self.model.settings.parpg.GuiDirectory, 
    8686                                'loadbrowser.xml') 
  • branches/active/character_customization/game/parpg/settings.py

    r809 r810  
    8080 
    8181            @param option: name of the option to assign a value to. 
    82             @type option: string 
    83             @param value: value to be assigned to the option. 
     82            @type option: string @param value: value to be assigned to the option. 
    8483            @type value: int, float, string, boolean, or list 
    8584        """ 
     
    130129        and the options defined within those sections. 
    131130    """ 
    132     def __init__(self, system_path, user_path=None, suffix='.cfg'): 
    133         """ initializes a new settings object. 
     131    def __init__(self, system_path=None, user_path=None, suffix='.cfg'): 
     132        """ initializes a new settings object. If no paths are given, they are 
     133            guessed based on whatever platform the script was run on. 
    134134 
    135135            Examples: 
     
    142142 
    143143                settings = Settings('.') 
     144 
     145                settigns = Settings() 
    144146 
    145147            @param system_path: Path to the system settings file. 
     
    155157            @type suffix: string 
    156158        """ 
    157  
    158159        if not suffix.startswith('.'): 
    159160            suffix = '.' + suffix 
     
    162163        self.settings_file = '' 
    163164 
    164         if user_path is None: 
    165             user_path = system_path 
    166  
    167         self.paths = {'system': system_path, 'user': user_path} 
     165        if system_path is None and user_path is None: 
     166            # use platform-specific values as paths 
     167            self.paths = {} 
     168            self.paths['system'], self.paths['user'] = self.platform_paths() 
     169        else: 
     170            self.paths = {'system': system_path, 'user': user_path} 
     171 
    168172        self.read() 
     173 
    169174 
    170175    def __getattr__(self, name): 
     
    186191        return getattr(self, name) 
    187192 
     193    def platform_paths(self, system=None): 
     194        if system is None: 
     195            system = platform.system() 
     196         
     197        if system.lower() == 'linux': 
     198            return (os.path.join(os.environ['XDG_DATA_DIRS'].split(':')[0],  
     199                                 'parpg'), 
     200                    os.path.join(os.environ['XDG_CONFIG_HOME'], 'parpg')) 
     201        elif system.lower() == 'windows': 
     202            return (os.path.join(os.environ['PROGRAMFILES'], 'PARPG'), 
     203                    os.path.join(os.environ['USERDATA'], 'PARPG')) 
     204        else: 
     205            return None 
     206 
     207 
    188208    def read(self, filenames=None): 
    189209        """ Reads a settings file and populates the settings object  
     
    197217         
    198218        if filenames is None: 
    199             filenames = [os.path.join(self.paths['system'],  
    200                          'system{0}'.format(self.suffix)), 
    201                          os.path.join(self.paths['user'], 
    202                          'user{0}'.format(self.suffix))] 
     219            filenames = [os.path.join(self.paths[key],  
     220                                      '{0}{1}'.format(key, self.suffix)) 
     221                         for key in self.paths.keys()  
     222                         if self.paths[key] is not None] 
    203223        elif hasattr(filenames, 'split'): 
    204224            filenames = [filenames] 
     
    280300        return sections 
    281301 
     302    @property 
     303    def sys_path(self): 
     304        return self.paths['system'] 
     305 
     306    @property 
     307    def user_path(self): 
     308        return self.paths['user'] 
     309 
    282310DEFAULT_SETTINGS = """\ 
    283311[fife] 
    284312# Options marked with ? are untested/unknown 
    285313 
    286  
    287314# Game window's title (string) DO NOT EDIT! 
    288315WindowTitle = PARPG Techdemo 2 
     
    411438""" 
    412439 
    413 def write_defaults(system=None, sys_dir="", user_dir="", filename='system.cfg'): 
    414     #TODO: write defaults for Mac OS X 
    415     if system is None: 
    416         system = platform.system().lower() 
    417  
    418     # automatically set sys_dir since it wasn't defined 
    419     if len(sys_dir) == 0: 
    420         if system == 'local': 
    421             sys_dir = os.path.join('.') 
    422         elif system == 'linux': 
    423             sys_dir = os.path.join(os.environ['XDG_DATA_DIRS'].split(':')[0], 
    424                                    'parpg') 
    425         elif system == 'windows': 
    426             sys_dir = os.path.join(os.environ['PROGRAMFILES'], 'PARPG') 
    427  
    428     # automatically set user_dir since it wasn't defined 
    429     if len(user_dir) == 0: 
    430         if system == 'local': 
    431             user_dir = os.path.join('.') 
    432         elif system == 'linux': 
    433             user_dir = os.path.join(os.environ['XDG_CONFIG_HOME'], 'parpg') 
    434         elif system == 'windows': 
    435             user_dir = os.path.join(os.environ['APPDATA'], 'PARPG') 
    436  
    437     # insert the defined system and user data directories into the template 
    438     default_settings = DEFAULT_SETTINGS.split('\n') 
    439     default_settings.insert(3, ('# Directory where files necessary to run ' 
    440                                 'PARPG are located\n' 
    441                                 'SystemDataDirectory = {0}\n\n' 
    442                                 '# Directory where saved games and ' 
    443                                 'screenshots are stored\n' 
    444                                 'UserDataDirectory = {1}').format(sys_dir, 
    445                                                                   user_dir)) 
    446  
    447     with open(filename, 'w') as f: 
    448         for line in default_settings: 
    449             f.write(line + '\n') 
    450  
    451440if __name__ == '__main__': 
    452441    from optparse import OptionParser 
     
    455444    parser = OptionParser(usage=usage) 
    456445 
    457     parser.add_option('-s', '--sys-dir', default='', 
    458                       help=('System Data Directory where data files ' 
    459                             'necessary to make the game run are stored')) 
    460     parser.add_option('-u', '--user-dir', default='', 
    461                       help=('User Data Directory where saved games and ' 
    462                             'screenshots are stored.'))  
    463446    parser.add_option('-f', '--filename', default='system.cfg', 
    464447                      help='Filename of output configuration file') 
    465448 
    466449    opts, args = parser.parse_args() 
    467  
    468     if len(args) == 0: 
    469         write_defaults(None, opts.sys_dir, opts.user_dir) 
    470     else:  
    471         valid_systems = ['local', 'linux', 'windows'] 
    472         # remove invalid systems from args 
    473         args = [arg for arg in args if arg in valid_systems] 
    474  
    475         if len(args) == 0: 
    476             parser.show_help() 
    477         elif len(args) == 1: 
    478             write_defaults(arg, opts.sys_dir, opts.user_dir, opts.filename) 
    479         else: 
    480             [write_defaults(arg, opts.sys_dir, opts.user_dir, 
    481                             '{0}_{1}'.format(arg, opts.filename))  
    482              for arg in args] 
     450     
     451    with open(opts.filename, 'w') as f: 
     452        for line in DEFAULT_SETTINGS: 
     453            f.write(line) 
  • branches/active/character_customization/game/run.py

    r809 r810  
    2323# Python 2.6 or lower 
    2424parser = OptionParser(description='PARPG Launcher Script') 
    25 parser.add_option('-s', '--settings', nargs=2, 
    26                     dest='paths', default='.', 
    27                     help='One or more paths to load settings from') 
     25parser.add_option('-p', '--paths', nargs=2, 
     26                  default='.', 
     27                  help='One or more paths to load settings from') 
    2828parser.add_option('-f', '--logfile', 
    29                     help='Name of log file to save to') 
     29                  help='Name of log file to save to') 
    3030parser.add_option('-l', '--loglevel', default='critical', 
    31                     help='desired output level for log file') 
     31                  help='desired output level for log file') 
    3232opts, args = parser.parse_args() 
    3333 
Note: See TracChangeset for help on using the changeset viewer.