Changeset 828


Ignore:
Timestamp:
04/03/11 22:43:05 (8 years ago)
Author:
barra_parpg
Message:

Patch by aspidites:

  • renamed all Directory options to Path for brevity and consistency
  • settings.py no longer sets absolute paths as this was crashing fife
  • settings.py no longer errors out on file read. instead, it errors out only if system.cfg isn't found and displays a useful help message
  • added a settings_path argument to settings.py to compensate for the fact that on linux, the settings file is not in the same location as the other data files
  • run.py no longer takes a -p option. instead, 1 to 3 filenames are taken as required arguments
  • subclassed pychan's Font object to create PARPGFont, which is arguably more flexible
  • instead of taking a fontdef file, it takes a settings object as well as a python dictionary called fontdef
  • created three fontdef modules in /fonts to assist in creation of the forementioned fontdef dictonaries.
  • one needs only copy the file, rename it, and change the name option to create a new fontdef
  • because of the above changes, the fontspath is not configurable
Location:
trunk/game
Files:
4 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/game/dialogue_demo.py

    r818 r828  
    8787    """ 
    8888    dialogue_dir = os.path.join(settings.system_path,  
    89                                 settings.parpg.DialoguesDirectory) 
     89                                settings.parpg.DialoguesPath) 
    9090    dialogue_files = [file_name for file_name in os.listdir(dialogue_dir)  
    9191                      if file_name.endswith('.yaml')] 

  • trunk/game/parpg/application.py

    r818 r828  
    1515 
    1616import os 
     17import sys 
    1718 
    1819from fife import fife 
    … …  
    2223 
    2324from parpg import console 
     25from parpg.font import PARPGFont 
    2426from parpg.gamemodel import GameModel 
    2527from parpg.mainmenuview import MainMenuView 
    … …  
    113115        self._setting = setting 
    114116        self.engine = fife.Engine() 
    115         fonts_dir = os.path.join(self._setting.system_path, 
    116                                  self._setting.fife.FontsDirectory) 
    117         self.fonts_directory = fonts_dir 
    118117        self.loadSettings() 
    119118        self.engine.init() 
    … …  
    136135        self.model.getDialogues() 
    137136        self.view = MainMenuView(self.engine, self.model) 
    138         self.loadFonts(self.fonts_directory) 
     137        self.loadFonts() 
    139138        self.event_listener = EventListener(self.engine) 
    140139        self.controllers = [] 
    … …  
    150149        #self.model.changeMap(start_map) 
    151150 
    152     def loadFonts(self, fonts_directory): 
    153         file_names = os.listdir(fonts_directory) 
    154         for file_name in file_names: 
    155             base_name, extension = os.path.splitext(file_name) 
    156             if extension == '.fontdef': 
    157                 file_path = os.path.join(fonts_directory, file_name) 
    158                 pychan.loadFonts(file_path) 
     151    def loadFonts(self): 
     152        # add the fonts path to the system path to import font definitons 
     153        sys.path.insert(0, os.path.join(self._setting.system_path,  
     154                                        self._setting.fife.FontsPath)) 
     155        from oldtypewriter import fontdefs 
     156 
     157        for fontdef in fontdefs: 
     158            pychan.internal.get_manager().addFont(PARPGFont(fontdef, 
     159                                                            self._setting)) 
     160                 
    159161 
    160162    def loadSettings(self): 
    … …  
    166168        engineSetting = self.engine.getSettings() 
    167169        engineSetting.setDefaultFontGlyphs(self._setting.fife.FontGlyphs) 
    168         engineSetting.setDefaultFontPath(os.path.join(self.fonts_directory, 
    169                                                        self._setting.fife.Font)) 
     170        engineSetting.setDefaultFontPath(os.path.join(self._setting.system_path, 
     171                                                   self._setting.fife.FontsPath, 
     172                                                   self._setting.fife.Font)) 
    170173        engineSetting.setDefaultFontSize(self._setting.fife.DefaultFontSize) 
    171174        engineSetting.setBitsPerPixel(self._setting.fife.BitsPerPixel) 
    … …  
    185188        engineSetting.setWindowTitle(self._setting.fife.WindowTitle) 
    186189        engineSetting.setWindowIcon(os.path.join(self._setting.system_path,  
    187                                                  self._setting.fife.IconsDirectory, 
     190                                                 self._setting.fife.IconsPath, 
    188191                                                 self._setting.fife.WindowIcon)) 
    189192 

  • trunk/game/parpg/controllerbase.py

    r818 r828  
    8585           @return: None""" 
    8686        image = os.path.join(self.model.settings.system_path, 
    87                              self.model.settings.parpg.GuiDirectory, 
    88                              self.model.settings.parpg.CursorDirectory, 
     87                             self.model.settings.parpg.GuiPath, 
     88                             self.model.settings.parpg.CursorPath, 
    8989                             self.model.settings.parpg.CursorDefault) 
    9090        self.setMouseCursor(image, image) 

  • trunk/game/parpg/gamemodel.py

    r818 r828  
    6363        self.savegame = None 
    6464        quests_directory = os.path.join(self.settings.system_path, 
    65                                         self.settings.parpg.QuestsDirectory) 
     65                                        self.settings.parpg.QuestsPath) 
    6666        self.game_state = GameState(quests_dir=quests_directory) 
    6767        #self.game_state.quest_engine =  
    … …  
    8080        # set values from settings 
    8181        maps_file = os.path.join(self.settings.system_path,  
    82                                  self.settings.parpg.MapsDirectory, 
     82                                 self.settings.parpg.MapsPath, 
    8383                                 self.settings.parpg.MapsFile) 
    8484        self.game_state.maps_file = maps_file 
    8585        all_agents_file = os.path.join(self.settings.system_path, 
    86                                        self.settings.parpg.MapsDirectory, 
     86                                       self.settings.parpg.MapsPath, 
    8787                                       self.settings.parpg.AllAgentsFile) 
    8888        self.all_agents_file = all_agents_file 
    8989        objects_dir = os.path.join(self.settings.system_path, 
    90                                     self.settings.parpg.ObjectsDirectory) 
     90                                    self.settings.parpg.ObjectsPath) 
    9191        self.objects_directory = objects_dir 
    9292        object_db_file = os.path.join(self.objects_directory, 
    … …  
    9494        self.object_db_file = object_db_file 
    9595        dialogues_dir = os.path.join(self.settings.system_path,  
    96                                      self.settings.parpg.DialoguesDirectory) 
     96                                     self.settings.parpg.DialoguesPath) 
    9797        self.dialogues_directory = dialogues_dir 
    9898        self.dialogues = {} 

  • trunk/game/parpg/gamescenecontroller.py

    r818 r828  
    137137            settings = self.model.settings 
    138138            screenshot_directory = os.path.join(settings.user_path, 
    139                                            settings.parpg.ScreenshotsDirectory) 
     139                                           settings.parpg.ScreenshotsPath) 
    140140            # try to create the screenshots directory 
    141141            try: 
    … …  
    258258                direction[1] -= 1 
    259259                image = os.path.join(settings.system_path, 
    260                                      settings.parpg.GuiDirectory, 
    261                                      settings.parpg.CursorDirectory, 
     260                                     settings.parpg.GuiPath, 
     261                                     settings.parpg.CursorPath, 
    262262                                     settings.parpg.CursorUp) 
    263263                 
    … …  
    267267                direction[1] += 1 
    268268                image = os.path.join(settings.system_path, 
    269                                      settings.parpg.GuiDirectory, 
    270                                      settings.parpg.CursorDirectory, 
     269                                     settings.parpg.GuiPath, 
     270                                     settings.parpg.CursorPath, 
    271271                                     settings.parpg.CursorRight) 
    272272                 
    … …  
    276276                direction[1] += 1 
    277277                image = os.path.join(settings.system_path, 
    278                                      settings.parpg.GuiDirectory, 
    279                                      settings.parpg.CursorDirectory, 
     278                                     settings.parpg.GuiPath, 
     279                                     settings.parpg.CursorPath, 
    280280                                     settings.parpg.CursorDown) 
    281281                 
    … …  
    285285                direction[1] -= 1 
    286286                image = os.path.join(settings.system_path, 
    287                                      settings.parpg.GuiDirectory, 
    288                                      settings.parpg.CursorDirectory, 
     287                                     settings.parpg.GuiPath, 
     288                                     settings.parpg.CursorPath, 
    289289                                     settings.parpg.CursorLeft) 
    290290             

  • trunk/game/parpg/gui/filebrowser.py

    r818 r828  
    3838        self.engine = engine 
    3939        self.settings = settings 
    40         print self.settings.parpg.SavesDirectory 
     40        print self.settings.parpg.SavesPath 
    4141        self.file_selected = file_selected 
    4242 
    … …  
    4949        self.extensions = extensions 
    5050        self.path = os.path.join(self.settings.user_path, 
    51                                  self.settings.parpg.SavesDirectory) 
     51                                 self.settings.parpg.SavesPath) 
    5252        self.dir_list = [] 
    5353        self.file_list = [] 
    … …  
    6666        self._widget = pychan.loadXML(self.gui_xml_path) 
    6767        self._widget.mapEvents({ 
    68             'dirList'       : self._setDirectory, 
     68            'dirList'       : self._setPath, 
    6969            'selectButton'  : self._selectFile, 
    7070            'closeButton'   : self.close 
    7171        }) 
    72         self._setDirectory() 
     72        self._setPath() 
    7373        if self.save_file: 
    7474            self._file_entry = widgets.TextField(name='saveField', text=u'')     
    … …  
    7777        self._widget.show() 
    7878 
    79     def _setDirectory(self): 
    80         """Directory change callback.""" 
     79    def _setPath(self): 
     80        """Path change callback.""" 
    8181        selection = self._widget.collectData('dirList') 
    8282        if not (selection < 0): 

  • trunk/game/parpg/gui/hud.py

    r818 r828  
    275275        self.stopActions() 
    276276        xml_path = os.path.join(self.settings.system_path, 
    277                                     self.settings.parpg.GuiDirectory, 
     277                                    self.settings.parpg.GuiPath, 
    278278                                    'savebrowser.xml') 
    279279        save_browser = FileBrowser(self.engine, 
    … …  
    320320        self.stopActions() 
    321321        xml_path = os.path.join(self.settings.system_path, 
    322                                     self.settings.parpg.GuiDirectory, 
     322                                    self.settings.parpg.GuiPath, 
    323323                                    'loadbrowser.xml') 
    324324        load_browser = FileBrowser(self.engine, 

  • trunk/game/parpg/mainmenuview.py

    r818 r828  
    8383            @return: None""" 
    8484        xml_path = os.path.join(self.model.settings.system_path, 
    85                                 self.model.settings.parpg.GuiDirectory, 
     85                                self.model.settings.parpg.GuiPath, 
    8686                                'loadbrowser.xml') 
    8787        load_browser = FileBrowser(self.engine, 

  • trunk/game/parpg/settings.py

    r819 r828  
    4444import platform 
    4545 
     46#TODO: add logging to replace print statements 
    4647class Section(object): 
    4748    """ An object that represents a section in a settings file. 
    … …  
    129130        and the options defined within those sections. 
    130131    """ 
    131     def __init__(self, system_path='', user_path='', suffix='.cfg'): 
     132    def __init__(self, system_path='', user_path='', settings_path='', suffix='.cfg'): 
    132133        """ initializes a new settings object. If no paths are given, they are 
    133134            guessed based on whatever platform the script was run on. 
    … …  
    163164        self.settings_file = '' 
    164165 
    165         if not system_path and not user_path: 
     166 
     167        self.paths = {} 
     168        if not system_path and not user_path and not settings_path: 
    166169            # use platform-specific values as paths 
    167             self.paths = {} 
    168             self.paths['system'], self.paths['user'] = self.platform_paths() 
     170            (self.paths['system'], self.paths['user'],  
     171             self.paths['settings']) = self.platform_paths() 
    169172        else: 
    170             self.paths = {'system': system_path, 'user': user_path} 
     173            # convert supplied paths to absolute paths 
     174            abs_paths = [os.path.expanduser(path) 
     175                         for path in [system_path, user_path, settings_path]] 
     176            (self.paths['system'], self.paths['user'], 
     177             self.paths['settings']) = abs_paths 
    171178 
    172179        self.read() 
    … …  
    193200    def platform_paths(self, system=None): 
    194201        if system is None: 
    195             system = platform.system() 
     202            system = platform.system().lower() 
    196203         
    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': 
     204        if system == 'linux': 
     205            return (os.path.join(os.sep, 'usr', 'share', 'parpg'), 
     206                    os.path.join(os.environ['XDG_CONFIG_HOME'], 'parpg'), 
     207                    os.path.join(os.sep, 'etc', 'parpg')) 
     208        elif system == 'windows': 
    202209            return (os.path.join(os.environ['PROGRAMFILES'], 'PARPG'), 
    203                     os.path.join(os.environ['USERDATA'], 'PARPG')) 
     210                    os.path.join(os.environ['USERDATA'], 'PARPG'), 
     211                    os.path.join(os.environ['PROGRAMFILES'], 'PARPG')) 
    204212        else: 
     213            # TODO: determine values for Mac 
    205214            return None 
    206215 
    … …  
    216225         
    217226        if filenames is None: 
    218             filenames = [os.path.join(self.paths[key],  
    219                                       '{0}{1}'.format(key, self.suffix)) 
    220                          for key in self.paths.keys()  
    221                          if self.paths[key] is not None] 
     227            filenames = [os.path.join(self.paths['settings'],  
     228                                      'system{0}'.format(self.suffix)), 
     229                         os.path.join(self.paths['user'], 
     230                                      'user{0}'.format(self.suffix))] 
    222231        elif hasattr(filenames, 'split'): 
    223232            filenames = [filenames] 
    … …  
    225234        for filename in filenames: 
    226235            section = None 
     236 
    227237            try: 
    228238                self.settings_file = open(filename, 'r').readlines() 
    229             except IOError: 
    230                 pass 
     239            except IOError as (errno, strerror): 
     240                if errno == 2: 
     241                    if os.path.basename(filename).startswith('system'): 
     242                        print ('{0} could not be found. Please supply a ' 
     243                               'different path or generate a system settings ' 
     244                               'file with:\n' 
     245                               'python2 -m parpg.settings').format(filename) 
     246                        sys.exit(1) 
     247                else: 
     248                    print 'Error No. {0}: {1} {2}'.format(errno, filename, strerror) 
     249                    sys.exit(1) 
    231250 
    232251            for line in self.settings_file: 
    … …  
    339358 
    340359# Subdirectory to load icons from (path) 
    341 IconsDirectory = icons 
     360IconsPath = icons 
    342361 
    343362# ? ([R, G, B]) 
    … …  
    357376 
    358377# Subdirectory to load fronts from (path) 
    359 FontsDirectory = fonts 
     378FontsPath = fonts 
    360379 
    361380# Font to load when game starts 
    … …  
    383402 
    384403# System subdirectory to load maps from (path) 
    385 MapsDirectory = maps 
     404MapsPath = maps 
    386405 
    387406# YAML file that contains the available maps (filename) 
    … …  
    395414 
    396415# System subdirectory to load objects from (path) 
    397 ObjectsDirectory = objects 
     416ObjectsPath = objects 
    398417 
    399418# YAML file that contains the database of availabel objects (filename) 
    … …  
    401420 
    402421# System subdirectory to load dialogues from (path) 
    403 DialoguesDirectory = dialogue 
     422DialoguesPath = dialogue 
    404423 
    405424# System subdirectory to load quests from (path) 
    406 QuestsDirectory = quests 
     425QuestsPath = quests 
    407426 
    408427# User subdirectory to save screenshots to 
    409 ScreenshotsDirectory = screenshots 
     428ScreenshotsPath = screenshots 
    410429 
    411430# User subdirectory to save games to 
    412 SavesDirectory = saves 
     431SavesPath = saves 
    413432 
    414433# System subdirectory where gui files are loaded from (path) 
    415 GuiDirectory = gui 
     434GuiPath = gui 
    416435 
    417436# System subdirectory where cursors are loaded from (path) 
    418 CursorDirectory = cursors 
     437CursorPath = cursors 
    419438 
    420439# File to use for default cursor (filename) 

  • trunk/game/run.py

    r818 r828  
    1 #!/usr/bin/env python2 
    2  
     1#!/usr/bin/env python2  
    32#   This program is free software: you can redistribute it and/or modify 
    43#   it under the terms of the GNU General Public License as published by 
    … …  
    1918 
    2019from optparse import OptionParser 
    21 from parpg.settings import Settings 
    2220 
    23 # Python 2.6 or lower 
    2421parser = OptionParser(description='PARPG Launcher Script') 
    25 parser.add_option('-p', '--paths', nargs=2, 
    26                   default='.', 
    27                   help='One or more paths to load settings from') 
    2822parser.add_option('-f', '--logfile', 
    2923                  help='Name of log file to save to') 
    3024parser.add_option('-l', '--loglevel', default='critical', 
    3125                  help='desired output level for log file') 
     26parser.add_option('-m', '--module', 
     27                  help='location of the parpg module') 
    3228opts, args = parser.parse_args() 
    3329 
     30if not args: 
     31    #TODO: display usage message 
     32    sys.exit(1) 
     33             
     34 
    3435# initialize settings 
    35 settings = Settings(*opts.paths) 
     36if opts.module: 
     37    sys.path.insert(0, opts.module) 
     38 
     39from parpg.settings import Settings 
     40 
     41settings = Settings(*args) 
    3642 
    3743levels = {'debug': logging.DEBUG, 
    … …  
    4652 
    4753try: 
    48     sys.path.insert(0, settings.parpg.FifePath) 
     54    sys.path.insert(0, settings.parpg.FifePath)  
    4955except AttributeError: 
    5056    logger.warning('[parpg] section has no FifePath option') 
    … …  
    5258try: 
    5359    from fife import fife 
    54     from parpg.application import PARPGApplication 
    55  
    56     from parpg.common import utils 
    5760except ImportError: 
    58     #TODO: pay attention to which module actually failed 
    5961    logger.critical("Could not import fife module. Please install fife or add " 
    6062                     "'FifePath' to the [parpg] section of your settings file") 
    6163    sys.exit(1) 
     64 
     65from parpg.application import PARPGApplication 
     66from parpg.common import utils 
    6267 
    6368# enable psyco if available and in settings file 

  • trunk/game/system.cfg

    r818 r828  
    3030 
    3131# Subdirectory to load icons from (path) 
    32 IconsDirectory = icons 
     32IconsPath = icons 
    3333 
    3434# ? ([R, G, B]) 
    … …  
    4848 
    4949# Subdirectory to load fronts from (path) 
    50 FontsDirectory = fonts 
     50FontsPath = fonts 
    5151 
    5252# Font to load when game starts 
     53#TODO: make it so that the font name is supplied instead of the filename 
    5354Font = oldtypewriter.ttf 
    5455 
    … …  
    7475 
    7576# System subdirectory to load maps from (path) 
    76 MapsDirectory = maps 
     77MapsPath = maps 
    7778 
    7879# YAML file that contains the available maps (filename) 
    … …  
    8687 
    8788# System subdirectory to load objects from (path) 
    88 ObjectsDirectory = objects 
     89ObjectsPath = objects 
    8990 
    9091# YAML file that contains the database of availabel objects (filename) 
    … …  
    9293 
    9394# System subdirectory to load dialogues from (path) 
    94 DialoguesDirectory = dialogue 
     95DialoguesPath = dialogue 
    9596 
    9697# System subdirectory to load quests from (path) 
    97 QuestsDirectory = quests 
     98QuestsPath = quests 
    9899 
    99100# User subdirectory to save screenshots to 
    100 ScreenshotsDirectory = screenshots 
     101ScreenshotsPath = screenshots 
    101102 
    102103# User subdirectory to save games to 
    103 SavesDirectory = saves 
     104SavesPath = saves 
    104105 
    105106# System subdirectory where gui files are loaded from (path) 
    106 GuiDirectory = gui 
     107GuiPath = gui 
    107108 
    108109# System subdirectory where cursors are loaded from (path) 
    109 CursorDirectory = cursors 
     110CursorPath = cursors 
    110111 
    111112# File to use for default cursor (filename) 
Note: See TracChangeset for help on using the changeset viewer.