Changeset 313


Ignore:
Timestamp:
10/10/09 21:45:49 (10 years ago)
Author:
Kaydeth_parpg
Message:

Ticket #2: Patch by Kaydeth. Updated the rest of the classes in the scripts directory to correct some obvious discrepancies with our coding standard. Still need to go through the common and objects sub directories. comment[s:trac, t:2]

Location:
trunk/game/scripts
Files:
1 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/scripts/common/eventlistenerbase.py

    r147 r313  
    2121    def __init__(self, engine, regKeys=False, regCmd=False, regMouse=False, regConsole=False, regWidget=False): 
    2222        """Initialise the instance""" 
    23         self.eventmanager = engine.getEventManager() 
     23        self.event_manager = engine.getEventManager() 
    2424 
    2525        fife.IKeyListener.__init__(self) 
    2626        if regKeys: 
    27             self.eventmanager.addKeyListener(self) 
     27            self.event_manager.addKeyListener(self) 
    2828        fife.ICommandListener.__init__(self) 
    2929        if regCmd: 
    30             self.eventmanager.addCommandListener(self) 
     30            self.event_manager.addCommandListener(self) 
    3131        fife.IMouseListener.__init__(self) 
    3232        if regMouse: 
    33             self.eventmanager.addMouseListener(self) 
     33            self.event_manager.addMouseListener(self) 
    3434        fife.ConsoleExecuter.__init__(self) 
    3535        if regConsole: 
  • trunk/game/scripts/console.py

    r312 r313  
    6161        @return: The resultstring""" 
    6262 
    63         self.app_listener.world.activeMap.toggle_renderer('GridRenderer') 
     63        self.app_listener.world.active_map.toggle_renderer('GridRenderer') 
    6464        return "Grid toggled" 
    6565 
  • trunk/game/scripts/engine.py

    r312 r313  
    2121from gamestate import GameState 
    2222from objects import * 
    23 from objectLoader import ObjectXMLParser 
    2423from objects.action import * 
    2524 
     
    8281        """Loads a saver from a file. 
    8382           @type path: string  
    84            @param path: the path where the savefile is located 
     83           @param path: the path where the save file is located 
    8584           @type filename: string 
    8685           @param filename: the name of the file to load from 
     
    9493        self.game_state = pickle.load(f) 
    9594        f.close() 
    96         if self.game_state.currentMap: 
    97             self.loadMap(self.game_state.currentMapName, \ 
    98                          self.game_state.currentMap)  
     95        if self.game_state.current_map: 
     96            self.loadMap(self.game_state.current_map_name, \ 
     97                         self.game_state.current_map)  
    9998 
    10099    def createObject (self, layer, attributes, instance): 
     
    133132        """ 
    134133        # add to view data  
    135         self.view.activeMap.addObject(pc.ID, instance)           
     134        self.view.active_map.addObject(pc.ID, instance)           
    136135         
    137136        # sync with game data 
     
    156155        if ref is None: 
    157156            # no, add it to the game state 
    158             obj.map_id = self.game_state.currentMap 
     157            obj.map_id = self.game_state.current_map 
    159158            self.game_state.objects[obj.ID] = obj 
    160159        else: 
     
    165164             
    166165        # add it to the view 
    167         self.view.activeMap.addObject(obj.ID, instance)           
     166        self.view.active_map.addObject(obj.ID, instance)           
    168167 
    169168        if obj.trueAttr("NPC"): 
     
    181180           @rtype: boolean 
    182181           @return: Status of result (True/False)""" 
    183         for i in self.game_state.getObjectsFromMap(self.game_state.currentMap): 
     182        for i in self.game_state.getObjectsFromMap(self.game_state.current_map): 
    184183            if (i.ID == ident): 
    185184                # we found a match 
     
    248247           @param map_file: Filename of map file to load 
    249248           @return: None""" 
    250         self.game_state.currentMap = map_file 
    251         self.game_state.currentMapName= map_name 
     249        self.game_state.current_map = map_file 
     250        self.game_state.current_map_name= map_name 
    252251        self.view.loadMap(map_name, str(map_file)) 
    253252        self.view.setActiveMap(map_name) 
     
    256255 
    257256        # create the PC agent 
    258         self.view.activeMap.addPC(self.game_state.PC.behaviour.agent) 
     257        self.view.active_map.addPC(self.game_state.PC.behaviour.agent) 
    259258        self.game_state.PC.start() 
    260259 
     
    270269            self.game_state.PC.walk(position) 
    271270 
    272     def changeMap(self, mapName, mapFile, target_position): 
     271    def changeMap(self, map_name, mapFile, target_position): 
    273272        """Registers for a map change on the next pump(). 
    274273           @type nameName: String 
    275            @param mapName: Id of the map to teleport to 
     274           @param map_name: Id of the map to teleport to 
    276275           @type mapFile: String 
    277276           @param mapFile: Filename of the map to teleport to 
     
    280279           @return None""" 
    281280        # set the parameters for the map change if moving to a new map 
    282         print self.game_state.currentMapName 
    283         if mapName != self.game_state.currentMapName: 
    284             self.game_state.currentMapName = mapName 
    285             self.game_state.currentMap = mapFile 
     281        print self.game_state.current_map_name 
     282        if map_name != self.game_state.current_map_name: 
     283            self.game_state.current_map_name = map_name 
     284            self.game_state.current_map = mapFile 
    286285            self.target_position = target_position 
    287286            # issue the map change 
     
    293292    def handleCommands(self): 
    294293        if self.map_change: 
    295             self.loadMap(self.game_state.currentMapName, \ 
    296                          self.game_state.currentMap) 
     294            self.loadMap(self.game_state.current_map_name, \ 
     295                         self.game_state.current_map) 
    297296            self.view.teleport(self.target_position) 
    298297            self.map_change = False 
  • trunk/game/scripts/filebrowser.py

    r303 r313  
    2424    """ 
    2525    FileBrowser displays directory and file listings from the vfs. 
    26     The fileSelected parameter is a callback invoked when a file selection has been made; its 
    27     signature must be fileSelected(path,filename). If selectdir is set, fileSelected's 
    28     filename parameter should be optional. 
    29     The savefile option provides a box for supplying a new filename that doesn't exist yet. 
    30     The selectdir option allows directories to be selected as well as files. 
     26    The file_selected parameter is a callback invoked when a file selection 
     27    has been made; its signature must be file_selected(path,filename). If 
     28    select_dir is set, file_selected's filename parameter should be optional. 
     29    The save_file option provides a box for supplying a new filename that 
     30    doesn't exist yet. The select_dir option allows directories to be 
     31    selected as well as files. 
    3132    """ 
    32     def __init__(self, engine, fileSelected, savefile=False, selectdir=False, extensions=('.dat',), guixmlpath="gui/filebrowser.xml"): 
     33    def __init__(self, engine, file_selected, save_file=False, \ 
     34                 select_dir=False, extensions=('.dat',), \ 
     35                 gui_xml_path="gui/filebrowser.xml"): 
    3336        self.engine = engine 
    34         self.fileSelected = fileSelected 
     37        self.file_selected = file_selected 
    3538 
    3639        self._widget = None 
    37         self.savefile = savefile 
    38         self.selectdir = selectdir 
     40        self.save_file = save_file 
     41        self.select_dir = select_dir 
    3942         
    40         self.guixmlpath = guixmlpath 
     43        self.gui_xml_path = gui_xml_path 
    4144 
    4245        self.extensions = extensions 
     
    5053            self._widget.show() 
    5154            return 
    52         self._widget = pychan.loadXML(self.guixmlpath) 
     55        self._widget = pychan.loadXML(self.gui_xml_path) 
    5356        self._widget.mapEvents({ 
    5457            'dirList'       : self._setDirectory, 
     
    5760        }) 
    5861        self._setDirectory() 
    59         if self.savefile: 
     62        if self.save_file: 
    6063            self._file_entry = widgets.TextField(name='saveField', text=u'')     
    61             self._widget.findChild(name="fileColumn").addChild(self._file_entry) 
     64            self._widget.findChild(name="fileColumn").\ 
     65                addChild(self._file_entry) 
    6266        self._widget.show() 
    6367 
     
    7882            if fs_encoding is None: fs_encoding = "ascii" 
    7983         
    80             newList = [] 
     84            new_list = [] 
    8185            for i in list: 
    82                 try: newList.append(unicode(i, fs_encoding)) 
     86                try: 
     87                    new_list.append(unicode(i, fs_encoding)) 
    8388                except: 
    84                     newList.append(unicode(i, fs_encoding, 'replace')) 
     89                    new_list.append(unicode(i, fs_encoding, 'replace')) 
    8590                    print "WARNING: Could not decode item:", i 
    86             return newList 
     91            return new_list 
    8792             
    8893         
     
    9196        self.file_list = [] 
    9297         
    93         dir_list = ('..',) + filter(lambda d: not d.startswith('.'), self.engine.getVFS().listDirectories(self.path)) 
    94         file_list = filter(lambda f: f.split('.')[-1] in self.extensions, self.engine.getVFS().listFiles(self.path)) 
     98        dir_list = ('..',) + filter(lambda d: not d.startswith('.'), \ 
     99                                    self.engine.getVFS().\ 
     100                                    listDirectories(self.path)) 
     101        file_list = filter(lambda f: f.split('.')[-1] in self.extensions, \ 
     102                           self.engine.getVFS().listFiles(self.path)) 
    95103                 
    96104        self.dir_list = decodeList(dir_list) 
     
    107115        data = self._widget.collectData('saveField') 
    108116 
    109         if self.savefile: 
     117        if self.save_file: 
    110118            if data: 
    111119                if (data.split('.')[1] == 'dat'): 
    112                     self.fileSelected(self.path, u2s(self._widget.collectData('saveField'))) 
     120                    self.file_selected(self.path, \ 
     121                                u2s(self._widget.collectData('saveField'))) 
    113122                else: 
    114123                    self._warningMessage() 
     
    117126 
    118127        if selection >= 0 and selection < len(self.file_list): 
    119             self.fileSelected(self.path, u2s(self.file_list[selection])) 
     128            self.file_selected(self.path, u2s(self.file_list[selection])) 
    120129            return 
    121130         
    122         if self.selectdir: 
    123             self.fileSelected(self.path) 
     131        if self.select_dir: 
     132            self.file_selected(self.path) 
    124133            return 
    125134 
  • trunk/game/scripts/gamestate.py

    r302 r313  
    2424        self.PC = None 
    2525        self.objects = {} 
    26         self.currentMap = None 
    27         self.currentMapName = None 
     26        self.current_map = None 
     27        self.current_map_name = None 
    2828         
    2929    def getObjectsFromMap(self, map_id): 
  • trunk/game/scripts/hud.py

    r304 r313  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import shutil, fife, pychan 
     18import shutil 
     19import fife 
     20import pychan 
    1921import pychan.widgets as widgets 
    2022from pychan.tools import callbackWithArguments as cbwa 
     
    5254        } 
    5355 
    54         self.inventory = inventory.Inventory(self.engine, inv_model, inv_callbacks) 
     56        self.inventory = inventory.Inventory(self.engine, \ 
     57                                             inv_model, inv_callbacks) 
    5558        self.refreshReadyImages() 
    5659 
    57         self.saveGameCallback = callbacks['saveGame'] 
    58         self.loadGameCallback = callbacks['loadGame'] 
    59         self.quitCallback     = callbacks['quitGame'] 
     60        self.save_game_callback = callbacks['saveGame'] 
     61        self.load_game_callback = callbacks['loadGame'] 
     62        self.quit_callback     = callbacks['quitGame'] 
    6063 
    6164        self.box_container = None 
    6265        self.examine_box = None 
    6366 
    64         self.actionsBox = self.hud.findChild(name="actionsBox") 
    65         self.actionsText = [] 
     67        self.actions_box = self.hud.findChild(name="actionsBox") 
     68        self.actions_text = [] 
    6669        self.menu_displayed = False 
    6770        self.initializeHud() 
     
    8184        screen_width = int(self.settings.readSetting('ScreenWidth')) 
    8285        self.hud.findChild(name="mainHudWindow").size = (screen_width, 65) 
    83         self.hud.findChild(name="inventoryButton").position = (screen_width-59, 7) 
     86        self.hud.findChild(name="inventoryButton").position = \ 
     87                                                    (screen_width-59, 7) 
    8488        # add ready slots 
    8589        ready1 = self.hud.findChild(name='hudReady1') 
     
    109113    def refreshActionsBox(self): 
    110114        """Refresh the actions box so that it displays the contents of 
    111            self.actionsText 
    112            @return: None""" 
    113         self.actionsBox.items = self.actionsText 
     115           self.actions_text 
     116           @return: None""" 
     117        self.actions_box.items = self.actions_text 
    114118 
    115119    def addAction(self, action): 
     
    118122           @param action: The text that you want to display in the actions box 
    119123           @return: None""" 
    120         self.actionsText.insert(0, action) 
     124        self.actions_text.insert(0, action) 
    121125        self.refreshActionsBox() 
    122126 
     
    183187        self.help_dialog.mapEvents(help_events) 
    184188        main_help_text = u"Welcome to Post-Apocalyptic RPG or PARPG![br][br]"\ 
    185         "This game is still in development, so please expect for there to be bugs"\ 
    186         " and[br]feel free to tell us about them at http://www.forums.parpg.net.[br]"\ 
    187         "This game uses a \"Point 'N' Click\" interface, which means that to move around,[br]"\ 
    188         "just click where you would like to go and your character will move there.[br]"\ 
    189         "PARPG also utilizes a context menu. To access this, just right click "\ 
    190         "anywhere[br]on the screen and a menu will come up. This menu will change"\ 
    191         " depending on[br]what you have clicked on, hence it's name \"context menu\".[br][br]" 
     189        "This game is still in development, so please expect for there to be "\ 
     190        "bugs and[br]feel free to tell us about them at "\ 
     191        "http://www.forums.parpg.net.[br]This game uses a "\ 
     192        "\"Point 'N' Click\" interface, which means that to move around,[br]"\ 
     193        "just click where you would like to go and your character will move "\ 
     194        "there.[br]PARPG also utilizes a context menu. To access this, just "\ 
     195        "right click anywhere[br]on the screen and a menu will come up. This "\ 
     196        "menu will change depending on[br]what you have clicked on, hence "\ 
     197        "it's name \"context menu\".[br][br]" 
    192198         
    193199        k_text = u" Keybindings"  
    194         k_text+="[br] A : Add a test action to the actions display" 
    195         k_text+="[br] I : Toggle the inventory screen" 
    196         k_text+="[br] F5 : Take a screenshot" 
    197         k_text+="[br]      (saves to <parpg>/screenshots/)" 
    198         k_text+="[br] Q : Quit the game" 
     200        k_text += "[br] A : Add a test action to the actions display" 
     201        k_text += "[br] I : Toggle the inventory screen" 
     202        k_text += "[br] F5 : Take a screenshot" 
     203        k_text += "[br]      (saves to <parpg>/screenshots/)" 
     204        k_text += "[br] Q : Quit the game" 
    199205        self.help_dialog.distributeInitialData({ 
    200206                "MainHelpText":main_help_text, 
     
    219225        current_fullscreen = settings.isFullScreen() 
    220226        settings.setFullScreen(True) 
    221         availableResolutions = settings.getPossibleResolutions() 
     227        available_resolutions = settings.getPossibleResolutions() 
    222228 
    223229        # Filter too small resolutions 
    224         self.Resolutions=[] 
    225         for x in availableResolutions: 
     230        self.resolutions=[] 
     231        for x in available_resolutions: 
    226232            if x[0]>=1024 and x[1]>=768: 
    227                 self.Resolutions.append(str(x[0])+'x'+str(x[1])) 
     233                self.resolutions.append(str(x[0])+'x'+str(x[1])) 
    228234 
    229235        settings.setFullScreen(current_fullscreen) 
    230         self.RenderBackends = ['OpenGL', 'SDL'] 
    231         self.renderNumber = 0 
     236        self.render_backends = ['OpenGL', 'SDL'] 
     237        self.render_number = 0 
    232238        if (str(self.settings.readSetting('RenderBackend')) == "SDL"): 
    233             self.renderNumber = 1 
    234         initialVolume = float(self.settings.readSetting('InitialVolume')) 
    235         initialVolumeText = str('Initial Volume: %.0f%s' % 
    236                                 (int(initialVolume*10), "%")) 
     239            self.render_number = 1 
     240        initial_volume = float(self.settings.readSetting('InitialVolume')) 
     241        initial_volume_text = str('Initial Volume: %.0f%s' % 
     242                                (int(initial_volume*10), "%")) 
    237243        self.options_menu.distributeInitialData({ 
    238                 'ResolutionBox': self.Resolutions, 
    239                 'RenderBox': self.RenderBackends, 
    240                 'InitialVolumeLabel' : initialVolumeText 
     244                'ResolutionBox': self.resolutions, 
     245                'RenderBox': self.render_backends, 
     246                'InitialVolumeLabel' : initial_volume_text 
    241247                }) 
    242248 
    243         sFullscreen = self.settings.readSetting(name="FullScreen") 
    244         sSounds = self.settings.readSetting(name="PlaySounds") 
    245         sRender = self.renderNumber 
    246         sVolume = initialVolume 
     249        s_fullscreen = self.settings.readSetting(name="FullScreen") 
     250        s_sounds = self.settings.readSetting(name="PlaySounds") 
     251        s_render = self.render_number 
     252        s_volume = initial_volume 
    247253 
    248254        screen_width = self.settings.readSetting(name="ScreenWidth") 
    249255        screen_height = self.settings.readSetting(name="ScreenHeight") 
    250         indexRes = str(screen_width + 'x' + screen_height) 
     256        index_res = str(screen_width + 'x' + screen_height) 
    251257        try: 
    252             sResolution = self.Resolutions.index(indexRes) 
    253             resolutionInList = True 
     258            s_resolution = self.resolutions.index(index_res) 
     259            resolution_in_list = True 
    254260        except: 
    255             resolutionInList = False 
    256  
    257         dataToDistribute = { 
    258                 'FullscreenBox':int(sFullscreen),  
    259                 'SoundsBox':int(sSounds), 
    260                 'RenderBox': sRender, 
    261                 'InitialVolumeSlider':sVolume 
     261            resolution_in_list = False 
     262 
     263        data_to_distribute = { 
     264                'FullscreenBox':int(s_fullscreen),  
     265                'SoundsBox':int(s_sounds), 
     266                'RenderBox': s_render, 
     267                'InitialVolumeSlider':s_volume 
    262268                } 
    263269 
    264         if (resolutionInList == True): 
    265             dataToDistribute['ResolutionBox'] = sResolution 
    266  
    267         self.options_menu.distributeData(dataToDistribute) 
     270        if (resolution_in_list == True): 
     271            data_to_distribute['ResolutionBox'] = s_resolution 
     272 
     273        self.options_menu.distributeData(data_to_distribute) 
    268274 
    269275        self.options_menu.mapEvents(self.options_events) 
     
    273279            @return: None""" 
    274280        save_browser = FileBrowser(self.engine, 
    275                                    self.saveGameCallback, 
    276                                    savefile=True, 
    277                                    guixmlpath="gui/savebrowser.xml", 
     281                                   self.save_game_callback, 
     282                                   save_file=True, 
     283                                   gui_xml_path="gui/savebrowser.xml", 
    278284                                   extensions = ('.dat')) 
    279285        save_browser.showBrowser() 
     
    288294            @return: None""" 
    289295        load_browser = FileBrowser(self.engine, 
    290                                    self.loadGameCallback, 
    291                                    savefile=False, 
    292                                    guixmlpath='gui/loadbrowser.xml', 
     296                                   self.load_game_callback, 
     297                                   save_file=False, 
     298                                   gui_xml_path='gui/loadbrowser.xml', 
    293299                                   extensions=('.dat')) 
    294300        load_browser.showBrowser() 
     
    297303        """Creates the quit confirmation dialog 
    298304           @return: None""" 
    299         self.quitWindow = pychan.widgets.Window(title=unicode("Quit?"),min_size=(200,0)) 
     305        self.quit_window = pychan.widgets.Window(title=unicode("Quit?"), \ 
     306                                                 min_size=(200,0)) 
    300307 
    301308        hbox = pychan.widgets.HBox() 
     
    311318                                          max_size=(90,20)) 
    312319 
    313         self.quitWindow.addChild(label) 
     320        self.quit_window.addChild(label) 
    314321        hbox.addChild(yes_button) 
    315322        hbox.addChild(no_button) 
    316         self.quitWindow.addChild(hbox) 
    317  
    318         events_to_map = { "yes_button": self.quitCallback, 
    319                           "no_button":  self.quitWindow.hide } 
     323        self.quit_window.addChild(hbox) 
     324 
     325        events_to_map = { "yes_button": self.quit_callback, 
     326                          "no_button":  self.quit_window.hide } 
    320327         
    321         self.quitWindow.mapEvents(events_to_map) 
     328        self.quit_window.mapEvents(events_to_map) 
    322329 
    323330 
     
    326333           @return: None""" 
    327334 
    328         self.quitWindow.show() 
     335        self.quit_window.show() 
    329336 
    330337    def toggleInventoryButton(self): 
     
    377384        # when we click the toggle button don't change the image 
    378385        events_to_map["inventoryButton"] = cbwa(self.toggleInventory, False) 
    379         events_to_map["saveButton"] = self.saveGame 
    380         events_to_map["loadButton"] = self.loadGame 
    381  
    382         hud_ready_buttons = ["hudReady1", "hudReady2", "hudReady3", "hudReady4"] 
     386        events_to_map["saveButton"] = self.save_game_callback 
     387        events_to_map["loadButton"] = self.load_game_callback 
     388 
     389        hud_ready_buttons = ["hudReady1", "hudReady2", \ 
     390                             "hudReady3", "hudReady4"] 
    383391 
    384392        for item in hud_ready_buttons: 
     
    390398        menu_events["newButton"] = self.newGame 
    391399        menu_events["quitButton"] = self.quitGame 
    392         menu_events["saveButton"] = self.saveGame 
    393         menu_events["loadButton"] = self.loadGame 
     400        menu_events["saveButton"] = self.save_game_callback 
     401        menu_events["loadButton"] = self.load_game_callback 
    394402        self.main_menu.mapEvents(menu_events) 
    395403 
     
    408416           @return: None""" 
    409417        require_restart_dialog = pychan.loadXML('gui/hud_require_restart.xml') 
    410         require_restart_dialog.mapEvents({'okButton':require_restart_dialog.hide}) 
     418        require_restart_dialog.mapEvents(\ 
     419                                {'okButton':require_restart_dialog.hide}) 
    411420        require_restart_dialog.show() 
    412421 
     
    415424           @return: None""" 
    416425        # At first no restart is required 
    417         self.requireRestart = False 
     426        self.require_restart = False 
    418427 
    419428        # get the current values of each setting from the options menu 
     
    421430        enable_sound = self.options_menu.collectData('SoundsBox') 
    422431        screen_resolution = self.options_menu.collectData('ResolutionBox') 
    423         partition = self.Resolutions[screen_resolution].partition('x') 
     432        partition = self.resolutions[screen_resolution].partition('x') 
    424433        screen_width = partition[0] 
    425434        screen_height = partition[2] 
     
    429438 
    430439        # get the options that are being used right now from settings.xml 
    431         sFullscreen = self.settings.readSetting('FullScreen') 
    432         sSound = self.settings.readSetting('PlaySounds') 
    433         sRender = self.settings.readSetting('RenderBackend') 
    434         sVolume = self.settings.readSetting('InitialVolume') 
    435  
    436         sScreenHeight = self.settings.readSetting('ScreenHeight') 
    437         sScreenWidth = self.settings.readSetting('ScreenWidth') 
    438         sResolution = sScreenWidth + 'x' + sScreenHeight 
     440        s_fullscreen = self.settings.readSetting('FullScreen') 
     441        s_sounds = self.settings.readSetting('PlaySounds') 
     442        s_render = self.settings.readSetting('RenderBackend') 
     443        s_volume = self.settings.readSetting('InitialVolume') 
     444 
     445        s_screen_height = self.settings.readSetting('ScreenHeight') 
     446        s_screen_width = self.settings.readSetting('ScreenWidth') 
     447        s_resolution = s_screen_width + 'x' + s_screen_height 
    439448 
    440449        # On each: 
     
    445454        # - Require a restart 
    446455 
    447         if (int(enable_fullscreen) != int(sFullscreen)): 
     456        if (int(enable_fullscreen) != int(s_fullscreen)): 
    448457            self.setOption('FullScreen', int(enable_fullscreen)) 
    449             self.requireRestart = True 
     458            self.require_restart = True 
    450459             
    451         if (int(enable_sound) != int(sSound)): 
     460        if (int(enable_sound) != int(s_sounds)): 
    452461            self.setOption('PlaySounds', int(enable_sound)) 
    453             self.requireRestart = True 
    454  
    455         if (screen_resolution != sResolution): 
     462            self.require_restart = True 
     463 
     464        if (screen_resolution != s_resolution): 
    456465            self.setOption('ScreenWidth', int(screen_width)) 
    457466            self.setOption('ScreenHeight', int(screen_height)) 
    458             self.requireRestart = True 
     467            self.require_restart = True 
    459468 
    460469        # Convert the number from the list of render backends to 
     
    465474            render_backend = 'SDL' 
    466475 
    467         if (render_backend != str(sRender)): 
     476        if (render_backend != str(s_render)): 
    468477            self.setOption('RenderBackend', render_backend) 
    469             self.requireRestart = True 
    470  
    471         if (initial_volume != float(sVolume)): 
     478            self.require_restart = True 
     479 
     480        if (initial_volume != float(s_volume)): 
    472481            self.setOption('InitialVolume', initial_volume) 
    473             self.requireRestart = True 
     482            self.require_restart = True 
    474483         
    475484        # Write all the settings to settings.xml 
     
    478487        # If the changes require a restart, popup the dialog telling 
    479488        # the user to do so 
    480         if (self.requireRestart): 
     489        if (self.require_restart): 
    481490            self.requireRestartDialog() 
    482491        # Once we are done, we close the options menu 
     
    526535            data = ["dagger01", "empty", "empty", "empty", "empty", 
    527536                    "empty", "empty", "empty", "empty"] 
    528             self.box_container = ContainerGUI(self.engine, unicode(title), data) 
    529             def close_and_delete(): 
     537            self.box_container = ContainerGUI(self.engine, \ 
     538                                              unicode(title), data) 
     539            def closeAndDelete(): 
    530540                self.hideContainer() 
    531             events = {'takeAllButton':close_and_delete, 
    532                       'closeButton':close_and_delete} 
     541            events = {'takeAllButton':closeAndDelete, 
     542                      'closeButton':closeAndDelete} 
    533543            self.box_container.container_gui.mapEvents(events) 
    534544            self.box_container.showContainer() 
     
    549559           @return: None""" 
    550560 
    551         if self.examine_box: 
     561        if self.examine_box is not None: 
    552562            self.examine_box.closePopUp() 
    553563        self.examine_box = ExaminePopup(self.engine, title, desc) 
  • trunk/game/scripts/inventory.py

    r270 r313  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import sys, os, fife, fifelog, pychan 
     18import sys 
     19import os 
     20import fife 
     21import fifelog 
     22import pychan 
    1923from scripts import drag_drop_data as data_drag 
    2024from pychan.tools import callbackWithArguments as cbwa 
     
    2832           @param engine: An instance of the fife engine 
    2933           @type items: dict 
    30            @param items: A dictionary for every slot that goes '{slot:item, slot:item}' 
    31                          if a slot is not included in the dict, it is assumed to be empty 
     34           @param items: A dictionary for every slot that goes '{slot:item,  
     35                         slot:item}' if a slot is not included in the dict, 
     36                         it is assumed to be empty 
    3237           @type callbacks: dict 
    3338           @param callbacks: a dict of callbacks 
     
    4550        # TODO: remove hard-coded string? 
    4651        self.inventory = pychan.loadXML("gui/inventory.xml") 
    47         self.inventoryShown = False  
     52        self.inventory_shown = False  
    4853        self.events_to_map = {} 
    4954        # the images that should be used for the buttons when they are "empty" 
     
    112117            # make every button's callback be self.dragDrop 
    113118            self.events_to_map[button] = cbwa(self.dragDrop, button) 
    114             ch = self.inventory.findChild(name = button) 
     119            ch = self.inventory.findChild(name=button) 
    115120            # make every slot's item be none if it has not already been set 
    116121            if button not in items: 
     
    131136        self.closeInventory() 
    132137        self.toggleInventoryButtonCallback() 
    133         self.inventoryShown = False 
     138        self.inventory_shown = False 
    134139 
    135140    def toggleInventory(self, toggleImage=True): 
     
    143148               image implicitly, so we don't change it. 
    144149           @return: None""" 
    145         if not self.inventoryShown: 
     150        if not self.inventory_shown: 
    146151            self.showInventory() 
    147             self.inventoryShown = True 
     152            self.inventory_shown = True 
    148153        else: 
    149154            self.closeInventory() 
    150             self.inventoryShown = False 
     155            self.inventory_shown = False 
    151156 
    152157        if toggleImage: 
     
    158163        self.inventory.show() 
    159164 
    160     def setMouseCursor(self, image, dummy_image, type = "native"):  
     165    def setMouseCursor(self, image, dummy_image, type="native"):  
    161166        """Set the mouse cursor to an image. 
    162167           @type image: string 
     
    286291    def getItems(self): 
    287292        """ 
    288         Get the items in the inventory slots. If there is no item in the slot, it is skipped 
     293        Get the items in the inventory slots. If there is no item in the slot, 
     294        it is skipped 
    289295         
    290296        @rtype: dict 
  • trunk/game/scripts/map.py

    r264 r313  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import fife, time 
     18import fife 
     19import time 
    1920from local_loaders.loaders import loadMapFile 
    2021from scripts.common.eventlistenerbase import EventListenerBase 
     
    3940        self.transitions = [] 
    4041        self.obj_hash = {} 
    41         self.cur_cam2_x, self.initial_cam2_x, self.cam2_scrolling_right = 0,0,True 
     42        self.cur_cam2_x = 0 
     43        self.initial_cam2_x = 0 
     44        self.cam2_scrolling_right = True 
    4245        self.target_rotation = 0 
    4346        self.outline_renderer = None 
     
    5356        self.transitions = [] 
    5457        self.obj_hash = {} 
    55         self.map,self.agent_layer = None,None 
     58        self.map = None 
     59        self.agent_layer = None 
    5660        # We have to clear the cameras in the view as well, or we can't reuse 
    5761        # camera names like 'main' 
    5862        self.view.clearCameras() 
    5963        self.cameras = {} 
    60         self.cur_cam2_x,self.initial_cam2_x,self.cam2_scrolling_right = 0,0,True 
     64        self.cur_cam2_x = 0 
     65        self.initial_cam2_x = 0 
     66        self.cam2_scrolling_right = True 
    6167        self.target_rotation = 0 
    6268        self.outline_renderer = None 
     
    9197        self.target_rotation = self.cameras['main'].getRotation() 
    9298         
    93         self.outline_render = fife.InstanceRenderer.getInstance(self.cameras['main']) 
     99        self.outline_render = fife.InstanceRenderer.\ 
     100                                        getInstance(self.cameras['main']) 
    94101         
    95102        # set the render text 
    96103        rend = fife.FloatingTextRenderer.getInstance(self.cameras['main']) 
    97         text = self.engine.getGuiManager().createFont('fonts/rpgfont.png', 
    98                                                        0, str(TDS.readSetting("FontGlyphs", strip=False))) 
     104        text = self.engine.getGuiManager().\ 
     105                        createFont('fonts/rpgfont.png', 0, \ 
     106                                   str(TDS.readSetting("FontGlyphs", \ 
     107                                                       strip=False))) 
    99108        rend.changeDefaultFont(text) 
    100109                 
  • trunk/game/scripts/popups.py

    r277 r313  
    4848         
    4949        # Prepare slots 1 through 9 
    50         dataIsList = False 
    51         emptyImage = "gui/inv_images/inv_backpack.png" 
    52         slotCount = 9 
     50        data_is_list = False 
     51        empty_image = "gui/inv_images/inv_backpack.png" 
     52        slot_count = 9 
    5353        self.empty_images = dict() 
    5454        # Did this step because I'm unsure which is more costly , to check the 
    5555        # type of object or the value of boolean object. Change as you see fit. 
    5656        if type(data) == list: 
    57             dataIsList = True 
    58         for counter in range(1, slotCount): 
    59             slotName = "Slot%i" % counter 
    60             selectedData = None 
    61              
    62             if dataIsList: 
    63                 selectedData = data[counter-1] 
     57            data_is_list = True 
     58        for counter in range(1, slot_count): 
     59            slot_name = "Slot%i" % counter 
     60            selected_data = None 
     61             
     62            if data_is_list: 
     63                selected_data = data[counter-1] 
    6464            else: 
    65                 selectedData = data 
    66              
    67             self.setContainerImage(slotName, item_image_dict[selectedData]) 
    68             self.container_gui.findChild(name=slotName).item = selectedData 
    69             self.empty_images[slotName] = emptyImage 
     65                selected_data = data 
     66             
     67            self.setContainerImage(slot_name, item_image_dict[selected_data]) 
     68            self.container_gui.findChild(name=slot_name).item = selected_data 
     69            self.empty_images[slot_name] = empty_image 
    7070         
    7171         
     
    117117            self.container_gui.hide() 
    118118         
    119     def setMouseCursor(self, image, dummy_image, type = "native"):  
     119    def setMouseCursor(self, image, dummy_image, type="native"):  
    120120        """Set the mouse cursor to an image. 
    121121           @type image: string 
     
    254254        @param engine: an instance of the fife engine 
    255255        @type object_title: string 
    256         @param object_title: The title for the window, probably should just be the name of the object 
     256        @param object_title: The title for the window, probably should just be 
     257            the name of the object 
    257258        @type desc: string 
    258259        @param desc: The description of the object 
     
    262263        pychan.init(self.engine, debug=True) 
    263264 
    264         self.examineWindow = pychan.widgets.Window(title=unicode(object_title), 
    265                                                    position_technique="center:center", 
    266                                                    min_size=(175,175)) 
     265        self.examine_window = pychan.widgets.\ 
     266                                Window(title=unicode(object_title), 
     267                                       position_technique="center:center", 
     268                                       min_size=(175,175)) 
    267269 
    268270        self.scroll = pychan.widgets.ScrollArea(name='scroll', size=(150,150)) 
    269         self.description = pychan.widgets.Label(name='descText', text=unicode(desc), wrap_text=True) 
     271        self.description = pychan.widgets.Label(name='descText', 
     272                                                text=unicode(desc), 
     273                                                wrap_text=True) 
    270274        self.description.max_width = 170 
    271275        self.scroll.addChild(self.description) 
    272         self.examineWindow.addChild(self.scroll) 
    273          
    274         self.close_button = pychan.widgets.Button(name='closeButton', text=unicode('Close')) 
    275         self.examineWindow.addChild(self.close_button) 
    276  
    277         self.examineWindow.mapEvents({'closeButton':self.examineWindow.hide}) 
     276        self.examine_window.addChild(self.scroll) 
     277         
     278        self.close_button = pychan.widgets.Button(name='closeButton', 
     279                                                  text=unicode('Close')) 
     280        self.examine_window.addChild(self.close_button) 
     281 
     282        self.examine_window.mapEvents({'closeButton':self.examine_window.hide}) 
    278283 
    279284    def closePopUp(self): 
    280         if self.examineWindow.isVisible(): 
    281             self.examineWindow.hide() 
     285        if self.examine_window.isVisible(): 
     286            self.examine_window.hide() 
    282287     
    283288    def showPopUp(self): 
    284         self.examineWindow.show() 
     289        self.examine_window.show() 
  • trunk/game/scripts/sounds.py

    r150 r313  
    3232        self.music_init = False 
    3333     
    34     def playMusic(self, sfile = None): 
     34    def playMusic(self, sfile=None): 
    3535        """Play music, with the given file if passed 
    3636           @type sfile: string 
    3737           @param sfile: Filename to play 
    3838           @return: None""" 
    39         if(sfile != None): 
     39        if(sfile is not None): 
    4040            # setup the new sound 
    4141            sound = self.engine.getSoundClipPool().addResourceFromFile(sfile) 
     
    6666           @param volume: The volume wanted, 0 to 100 
    6767           @return: None""" 
    68         self.sound_engine.setVolume(0.01*volume) 
     68        self.sound_engine.setVolume(0.01 * volume) 
    6969 
  • trunk/game/scripts/world.py

    r312 r313  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import fife, time 
     18import time 
     19import fife 
    1920import pychan 
    2021from sounds import SoundEngine 
     
    4748           @param engine: A fife.Engine instance 
    4849           @return: None""" 
    49         super(World, self).__init__(engine, regMouse = True, regKeys = True) 
     50        super(World, self).__init__(engine, regMouse=True, regKeys=True) 
    5051        # self.engine is a fife.Engine object, not an Engine object 
    5152        self.engine = engine 
    52         self.eventmanager = engine.getEventManager() 
     53        self.event_manager = engine.getEventManager() 
    5354        self.quitFunction = None 
    5455         
     
    5960 
    6061        # self.map is a Map object, set to none here 
    61         self.activeMap = None 
     62        self.active_map = None 
    6263        self.maps = {} 
    6364 
     
    9798        self.data.load(*args, **kwargs) 
    9899 
    99     def loadMap(self, mapname, filename): 
     100    def loadMap(self, map_name, filename): 
    100101        """Loads a map and stores it under the given name in the maps list. 
    101            @type mapname: text 
    102            @param mapname: The name of the map to load  
     102           @type map_name: text 
     103           @param map_name: The name of the map to load  
    103104           @type filename: text 
    104105           @param filename: File which contains the map to be loaded 
    105106           @return: None 
    106107        """ 
    107         if not mapname in self.maps: 
     108        if not map_name in self.maps: 
    108109            """Need to set active map before we load it because the map  
    109110            loader uses call backs that expect to find an active map.  
     
    111112            """ 
    112113            map = Map(self.engine, self.data) 
    113             self.maps[mapname] = map         
    114             self.setActiveMap(mapname) 
     114            self.maps[map_name] = map         
     115            self.setActiveMap(map_name) 
    115116            map.load(filename) 
    116117     
    117     def setActiveMap(self, mapname): 
     118    def setActiveMap(self, map_name): 
    118119        """Sets the active map that is to be rendered. 
    119            @type mapname: text 
    120            @param mapname: The name of the map to load  
     120           @type map_name: text 
     121           @param map_name: The name of the map to load  
    121122           @return: None 
    122123        """ 
    123         self.activeMap = self.maps[mapname] 
    124         self.activeMap.makeActive() 
     124        self.active_map = self.maps[map_name] 
     125        self.active_map.makeActive() 
    125126 
    126127    def displayObjectText(self, obj, text): 
     
    140141           @return: None""" 
    141142        key = evt.getKey() 
    142         keyval = key.getValue() 
    143  
    144         if(keyval == key.Q): 
     143        key_val = key.getValue() 
     144 
     145        if(key_val == key.Q): 
    145146            # we need to quit the game 
    146147            self.hud.quitGame() 
    147         if(keyval == key.T): 
    148             self.activeMap.toggle_renderer('GridRenderer') 
    149         if(keyval == key.F1): 
     148        if(key_val == key.T): 
     149            self.active_map.toggle_renderer('GridRenderer') 
     150        if(key_val == key.F1): 
    150151            # display the help screen and pause the game 
    151152            self.hud.displayHelp() 
    152         if(keyval == key.F5): 
     153        if(key_val == key.F5): 
    153154            # logic would say we use similar code to above and toggle 
    154155            # logic here does not work, my friend :-( 
    155156            self.cord_render.setEnabled(not self.cord_render.isEnabled()) 
    156         if(keyval == key.F7): 
     157        if(key_val == key.F7): 
    157158            # F7 saves a screenshot to fife/clients/parpg/screenshots 
    158             t = "screenshots/screen-%s-%s.png" % (date.today().strftime('%Y-%m-%d'), 
    159                                                   time.strftime('%H-%M-%S')) 
     159            t = "screenshots/screen-%s-%s.png" % \ 
     160                    (date.today().strftime('%Y-%m-%d'),\ 
     161                    time.strftime('%H-%M-%S')) 
    160162            print "PARPG: Saved:",t 
    161163            self.engine.getRenderBackend().captureScreen(t) 
    162         if(keyval == key.F10): 
     164        if(key_val == key.F10): 
    163165            # F10 shows/hides the console 
    164166            self.engine.getGuiManager().getConsole().toggleShowHide() 
    165         if(keyval == key.I): 
     167        if(key_val == key.I): 
    166168            # I opens and closes the inventory 
    167169            self.hud.toggleInventory() 
    168         if(keyval == key.A): 
     170        if(key_val == key.A): 
    169171            # A adds a test action to the action box 
    170             # The test actions will follow this format: Action 1, Action 2, etc. 
     172            # The test actions will follow this format: Action 1, 
     173            # Action 2, etc. 
    171174            self.hud.addAction("Action " + str(self.action_number)) 
    172175            self.action_number += 1 
    173         if(keyval == key.ESCAPE): 
     176        if(key_val == key.ESCAPE): 
    174177            # Escape brings up the main menu 
    175178            self.hud.displayMenu() 
    176179            # Hide the quit menu  
    177             self.hud.quitWindow.hide() 
    178         if(keyval == key.M): 
     180            self.hud.quit_window.hide() 
     181        if(key_val == key.M): 
    179182            self.sounds.toggleMusic() 
    180183 
     
    186189           @param evt: The event that fife caught 
    187190           @return: None""" 
    188         self.hud.hideContextMenu() # hide the context menu in case it is displayed 
     191        self.hud.hideContextMenu() 
    189192        scr_point = fife.ScreenPoint(evt.getX(), evt.getY()) 
    190193        if(evt.getButton() == fife.MouseEvent.LEFT): 
     
    192195        elif(evt.getButton() == fife.MouseEvent.RIGHT): 
    193196            # is there an object here? 
    194             instances = self.activeMap.cameras['main'].getMatchingInstances(scr_point, self.activeMap.agent_layer) 
     197            instances = self.active_map.cameras['main'].\ 
     198                            getMatchingInstances(scr_point, \ 
     199                                                 self.active_map.agent_layer) 
    195200            info = None 
    196201            for inst in instances: 
     
    201206                    break 
    202207                 
    203             # take the menu items returned by the engine or show a default menu if no items     
    204             data = info or [["Walk", "Walk here", self.onWalk, self.getCoords(scr_point)]] 
     208            # take the menu items returned by the engine or show a 
     209            # default menu if no items     
     210            data = info or \ 
     211                [["Walk", "Walk here", self.onWalk, self.getCoords(scr_point)]] 
    205212            # show the menu 
    206213            self.hud.showContextMenu(data, (scr_point.x, scr_point.y)) 
     
    221228        """ 
    222229        coord = fife.DoublePoint3D(float(position[0]), float(position[1]), 0) 
    223         location = fife.Location(self.activeMap.agent_layer) 
     230        location = fife.Location(self.active_map.agent_layer) 
    224231        location.setMapCoordinates(coord) 
    225232        self.data.game_state.PC.teleport(location) 
     
    231238           @return: None""" 
    232239        click = fife.ScreenPoint(evt.getX(), evt.getY()) 
    233         i=self.activeMap.cameras['main'].getMatchingInstances(click, self.activeMap.agent_layer) 
     240        i=self.active_map.cameras['main'].getMatchingInstances(click, \ 
     241                                                self.active_map.agent_layer) 
    234242        # no object returns an empty tuple 
    235243        if(i != ()): 
     
    238246                if(self.data.objectActive(obj.getId())): 
    239247                    # yes, so outline  
    240                     self.activeMap.outline_render.addOutlined(obj, 0, 137, 255, 2) 
     248                    self.active_map.outline_render.addOutlined(obj, 0, \ 
     249                                                               137, 255, 2) 
    241250                    # get the text 
    242251                    item = self.data.objectActive(obj.getId()) 
    243                     if(item): 
     252                    if(item is not None): 
    244253                        self.displayObjectText(obj, item.name) 
    245254        else: 
    246255            # erase the outline 
    247             self.activeMap.outline_render.removeAllOutlines() 
     256            self.active_map.outline_render.removeAllOutlines() 
    248257 
    249258    def getCoords(self, click): 
     
    253262           @rtype: fife.Location 
    254263           @return: The map co-ords""" 
    255         coord = self.activeMap.cameras["main"].toMapCoordinates(click, False) 
     264        coord = self.active_map.cameras["main"].toMapCoordinates(click, False) 
    256265        coord.z = 0 
    257         location = fife.Location(self.activeMap.agent_layer) 
     266        location = fife.Location(self.active_map.agent_layer) 
    258267        location.setMapCoordinates(coord) 
    259268        return location 
Note: See TracChangeset for help on using the changeset viewer.