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.