Changeset 550


Ignore:
Timestamp:
06/18/10 20:18:57 (9 years ago)
Author:
beliar
Message:

More code-cleanup

  • removed editor/loaders.py - doesn't seem to be used, editor still works
  • Took care of all errors and all warnings that where possible to fix
  • Renamed GameController? to GameSceneController? and GameView? to GameSceneView? - Will be using more controllers and views for different states of the game
Location:
branches/code-cleanup-and-refactoring/game
Files:
1 deleted
20 edited
2 moved

Legend:

Unmodified
Added
Removed
  • branches/code-cleanup-and-refactoring/game/local_loaders/__init__.py

    r474 r550  
    3232try: 
    3333    import xml.etree.cElementTree as ET 
    34 except: 
    35     import xml.etree.ElementTree as ET 
     34except(ImportError): 
     35    import xml.etree.ElementTree as ET #@Reimport 
    3636 
    3737class SerializerError(Exception): 
     
    6161    subfile can be either 
    6262    """ 
    63     s = '/' 
     63    dir_delim = '/' 
    6464 
    6565    masterfile = normalizePath(os.path.abspath(masterfile)) 
    6666    subfile = normalizePath(os.path.abspath(subfile)) 
    6767 
    68     master_fragments = masterfile.split(s) 
    69     sub_fragments = subfile.split(s) 
     68    master_fragments = masterfile.split(dir_delim) 
     69    sub_fragments = subfile.split(dir_delim) 
    7070 
    7171    master_leftovers = [] 
     
    8181 
    8282    pathstr = '' 
    83     for f in master_leftovers[:-1]: 
    84         pathstr += '..' + s 
    85     pathstr += s.join(sub_leftovers) 
     83    while master_leftovers: 
     84        pathstr += '..' + dir_delim 
     85        master_leftovers = master_leftovers[1:] 
     86    pathstr += dir_delim.join(sub_leftovers) 
    8687    return pathstr 
    8788 
  • branches/code-cleanup-and-refactoring/game/local_loaders/loaders.py

    r473 r550  
    4444    """ 
    4545    map_loader = XMLMapLoader(engine, data, callback) 
    46     map = map_loader.loadResource(fife.ResourceLocation(path)) 
     46    ret_map = map_loader.loadResource(fife.ResourceLocation(path)) 
    4747    print "--- Loading map took: ", map_loader.time_to_load, " seconds." 
    48     return map 
     48    return ret_map 
    4949 
    5050def loadImportFile(path, engine): 
  • branches/code-cleanup-and-refactoring/game/local_loaders/xmlmap.py

    r549 r550  
    2323from fife import fife  
    2424try: 
    25     import xml.etree.cElementTree as ET  
    26 except: 
    27     import xml.etree.ElementTree as ET 
     25    import xml.etree.cElementTree as ET #@UnusedImport 
     26except(ImportError): 
     27    import xml.etree.ElementTree as ET #@Reimport 
    2828 
    2929from fife.extensions import loaders 
     
    4141    NOTE: masterfile is expected to be *file*, not directory. subfile can be either 
    4242    """ 
    43     directory_delimiter = '/' 
     43    dir_delim = '/' 
    4444 
    4545    masterfile = norm_path(os.path.abspath(masterfile)) 
    4646    subfile = norm_path(os.path.abspath(subfile)) 
    4747 
    48     master_fragments = masterfile.split(directory_delimiter) 
    49     sub_fragments = subfile.split(directory_delimiter) 
     48    master_fragments = masterfile.split(dir_delim) 
     49    sub_fragments = subfile.split(dir_delim) 
    5050 
    5151    master_leftovers = [] 
     
    6161 
    6262    pathstr = '' 
    63     for f in master_leftovers[:-1]: 
    64         pathstr += '..' + directory_delimiter 
    65     pathstr += directory_delimiter.join(sub_leftovers) 
     63    while master_leftovers: 
     64        pathstr += '..' + dir_delim 
     65        master_leftovers = master_leftovers[1:] 
     66    pathstr += dir_delim.join(sub_leftovers) 
    6667    return pathstr 
    6768 
     
    120121 
    121122        self.n_space = None 
     123        self.x = None 
     124        self.y = None 
    122125 
    123126    def _err(self, msg): 
     
    132135        root = tree.getroot() 
    133136             
    134         map = self.parseMap(root) 
     137        ret_map = self.parseMap(root) 
    135138        self.time_to_load = time.time() - start_time 
    136         return map 
     139        return ret_map 
    137140 
    138141    def parseMap(self, map_elt): 
     
    140143            self._err(\ 
    141144                'No <map> element found at top level of map file definition.') 
    142         id,format = map_elt.get('id'),map_elt.get('format') 
    143  
    144         if not format == FORMAT: 
    145             self._err(''.join(['This file has format ', format, 
    146                                ' but this loader has format ', FORMAT])) 
    147         if not id: self._err('Map declared without an identifier.') 
    148  
    149         map = None 
     145        map_id, map_format = map_elt.get('map_id'), map_elt.get('map_format') 
     146 
     147        if not map_format == FORMAT: 
     148            self._err(''.join(['This file has map_format ', map_format, 
     149                               ' but this loader has map_format ', FORMAT])) 
     150        if not map_id: self._err('Map declared without an identifier.') 
     151 
     152        self.map = None 
    150153        try: 
    151             self.map = self.fife_model.createMap(str(id)) 
     154            self.map = self.fife_model.createMap(str(map_id)) 
    152155            self.map.setResourceFile(self.source) 
    153156        # NameClash appears as general fife.Exception; any ideas? 
    154157        except fife.Exception, e:  
    155158            print e.getMessage() 
    156             print ''.join(['File: ', self.source, '. The map ', str(id), \ 
     159            print ''.join(['File: ', self.source, '. The map ', str(map_id), \ 
    157160                           ' already exists! Ignoring map definition.']) 
    158161            return None 
     
    172175        return self.map 
    173176 
    174     def parseImports(self, map_elt, map): 
     177    def parseImports(self, map_elt, game_map): 
    175178        parsedImports = {} 
    176179 
     
    180183         
    181184        for item in map_elt.findall('import'): 
    182             file = item.get('file') 
    183             if file: 
    184                 file = reverseRootSubfile(self.source, file) 
    185             dir = item.get('dir') 
    186             if dir: 
    187                 dir = reverseRootSubfile(self.source, dir) 
     185            imp_file = item.get('imp_file') 
     186            if imp_file: 
     187                imp_file = reverseRootSubfile(self.source, imp_file) 
     188            directory = item.get('directory') 
     189            if directory: 
     190                directory = reverseRootSubfile(self.source, directory) 
    188191 
    189192            # Don't parse duplicate imports 
    190             if (dir,file) in parsedImports: 
    191                 print "Duplicate import:" ,(dir,file) 
     193            if (directory,imp_file) in parsedImports: 
     194                print "Duplicate import:" ,(directory,imp_file) 
    192195                continue 
    193             parsedImports[(dir,file)] = 1 
    194  
    195             if file and dir: 
    196                 loaders.loadImportFile('/'.join(dir, file), self.engine) 
    197             elif file: 
    198                 loaders.loadImportFile(file, self.engine) 
    199             elif dir: 
    200                 loaders.loadImportDirRec(dir, self.engine) 
    201                 map.importDirs.append(dir) 
     196            parsedImports[(directory,imp_file)] = 1 
     197 
     198            if imp_file and directory: 
     199                loaders.loadImportFile('/'.join(directory, imp_file), self.engine) 
     200            elif imp_file: 
     201                loaders.loadImportFile(imp_file, self.engine) 
     202            elif directory: 
     203                loaders.loadImportDirRec(directory, self.engine) 
     204                game_map.importDirs.append(directory) 
    202205            else: 
    203206                print 'Empty import statement?' 
     
    209212 
    210213 
    211     def parseLayers(self, map_elt, map): 
     214    def parseLayers(self, map_elt, game_map): 
    212215        if self.callback is not None:         
    213216            tmp_list = map_elt.findall('layer') 
     
    215218 
    216219        for layer in map_elt.findall('layer'): 
    217             id = layer.get('id') 
     220            layer_id = layer.get('layer_id') 
    218221            grid_type = layer.get('grid_type') 
    219222            x_scale = layer.get('x_scale') 
     
    236239                transparency = int(transparency) 
    237240 
    238             if not id:  
    239                 self._err('<layer> declared with no id attribute.') 
     241            if not layer_id:  
     242                self._err('<layer> declared with no layer_id attribute.') 
    240243            if not grid_type:  
    241                 self._err(''.join(['Layer ', str(id), \ 
     244                self._err(''.join(['Layer ', str(layer_id), \ 
    242245                                            ' has no grid_type attribute.'])) 
    243246 
     
    256259            layer_obj = None 
    257260            try: 
    258                 layer_obj = map.createLayer(str(id), cell_grid) 
     261                layer_obj = game_map.createLayer(str(layer_id), cell_grid) 
    259262            except fife.Exception, exception: 
    260263                print exception.getMessage() 
    261                 print 'The layer ' + str(id) + \ 
     264                print 'The layer ' + str(layer_id) + \ 
    262265                        ' already exists! Ignoring this layer.' 
    263266                continue 
     
    276279                i += 1 
    277280                self.callback('loaded layer :' + \ 
    278                               str(id), float( i / float(len(tmp_list)) * \ 
     281                              str(layer_id), float( i / float(len(tmp_list)) * \ 
    279282                                              0.25 + 0.5 ) ) 
    280283 
     
    293296        for instance in instances: 
    294297 
    295             object_id = instance.get('object') 
     298            object_id = instance.get('map_object') 
    296299            if not object_id: 
    297300                object_id = instance.get('obj') 
     
    300303 
    301304            if not object_id: self._err('<instance> does not specify an '\ 
    302                                         'object attribute.') 
     305                                        'map_object attribute.') 
    303306 
    304307            n_space = instance.get('namespace') 
     
    309312 
    310313            if not n_space: self._err('<instance> %s does not specify an '\ 
    311                                       'object namespace, and no default is '\ 
     314                                      'map_object namespace, and no default is '\ 
    312315                                      'available.' % str(object_id)) 
    313316 
    314317            self.n_space = n_space 
    315318 
    316             object = self.fife_model.getObject(str(object_id), str(n_space)) 
    317             if not object: 
    318                 print ''.join(['Object with id=', str(object_id), ' ns=', \ 
     319            map_object = self.fife_model.getObject(str(object_id), str(n_space)) 
     320            if not map_object: 
     321                print ''.join(['Object with inst_id=', str(object_id), ' ns=', \ 
    319322                               str(n_space), \ 
    320323                               ' could not be found. Omitting...']) 
     
    325328            z = instance.get('z') 
    326329            stack_pos = instance.get('stackpos') 
    327             id = instance.get('id') 
     330            inst_id = instance.get('inst_id') 
    328331 
    329332            if x: 
     
    345348                z = 0.0 
    346349 
    347             if not id: 
    348                 id = '' 
    349             else: 
    350                 id = str(id)             
     350            if not inst_id: 
     351                inst_id = '' 
     352            else: 
     353                inst_id = str(inst_id)             
    351354             
    352             inst = layer.createInstance(object, \ 
     355            inst = layer.createInstance(map_object, \ 
    353356                                        fife.ExactModelCoordinate(x,y,z), \ 
    354                                         str(id)) 
    355  
    356             if id: inst.setId(id) 
     357                                        str(inst_id)) 
     358 
     359            if inst_id: inst.setId(inst_id) 
    357360            rotation = instance.get('r') 
    358361            if not rotation: 
    359362                rotation = instance.get('rotation') 
    360363            if not rotation: 
    361                 angles = object.get2dGfxVisual().getStaticImageAngles() 
     364                angles = map_object.get2dGfxVisual().getStaticImageAngles() 
    362365                if angles: 
    363366                    rotation = angles[0] 
     
    372375                inst.get2dGfxVisual().setStackPosition(int(stack_pos)) 
    373376 
    374             if (object.getAction('default')): 
     377            if (map_object.getAction('default')): 
    375378                target = fife.Location(layer) 
    376379                inst.act('default', target, True) 
    377380                 
    378             #Check for PARPG specific object attributes 
     381            #Check for PARPG specific map_object attributes 
    379382            object_type = instance.get('object_type') 
    380383            if object_type: 
    381384                inst_dict = {} 
    382385                inst_dict["type"] = object_type 
    383                 inst_dict["id"] = id 
     386                inst_dict["inst_id"] = inst_id 
    384387                inst_dict["xpos"] = x 
    385388                inst_dict["ypos"] = y 
     
    400403                if inventory_el is not None: 
    401404                    inventory = Inventory() 
    402                     inv_objects = inventory_el.findall("object") 
     405                    inv_objects = inventory_el.findall("map_object") 
    403406                    for inv_object in inv_objects: 
    404407                        attributes = inv_object.attrib.copy() 
     
    407410                self.model.createMapObject(layer, inst_dict, inst) 
    408411                 
    409     def parseCameras(self, map_elt, map): 
     412    def parseCameras(self, map_elt, game_map): 
    410413        if self.callback:         
    411414            tmp_list = map_elt.findall('camera') 
     
    413416 
    414417        for camera in map_elt.findall('camera'): 
    415             id = camera.get('id') 
     418            cam_id = camera.get('cam_id') 
    416419            zoom = camera.get('zoom') 
    417420            tilt = camera.get('tilt') 
     
    426429            if not rotation: rotation = 0 
    427430 
    428             if not id: self._err('Camera declared without an id.') 
    429             if not ref_layer_id: self._err(''.join(['Camera ', str(id), \ 
     431            if not cam_id: self._err('Camera declared without an cam_id.') 
     432            if not ref_layer_id: self._err(''.join(['Camera ', str(cam_id), \ 
    430433                                                    ' declared with no '\ 
    431434                                                    'reference layer.'])) 
    432435            if not (ref_cell_width and ref_cell_height): 
    433                 self._err(''.join(['Camera ', str(id), \ 
     436                self._err(''.join(['Camera ', str(cam_id), \ 
    434437                                   ' declared without reference cell '\ 
    435438                                   'dimensions.'])) 
     
    437440            try: 
    438441                if view_port: 
    439                     cam = map.addCamera(str(id), \ 
    440                                     map.getLayer(str(ref_layer_id)), \ 
     442                    cam = game_map.addCamera(str(cam_id), \ 
     443                                    game_map.getLayer(str(ref_layer_id)), \ 
    441444                                    fife.Rect(\ 
    442445                                    *[int(c) for c in view_port.split(',')])) 
    443446                else: 
    444447                    screen = self.engine.getRenderBackend() 
    445                     cam = map.addCamera(str(id), \ 
    446                                     map.getLayer(str(ref_layer_id)), \ 
     448                    cam = game_map.addCamera(str(cam_id), \ 
     449                                    game_map.getLayer(str(ref_layer_id)), \ 
    447450                                    fife.Rect(0, 0, screen.getScreenWidth(), \ 
    448451                                              screen.getScreenHeight()) ) 
     
    455458 
    456459                renderer = fife.InstanceRenderer.getInstance(cam) 
    457                 renderer.activateAllLayers(map)                      
     460                renderer.activateAllLayers(game_map)                      
    458461                 
    459462            except fife.Exception, e: 
     
    462465            if self.callback: 
    463466                i += 1 
    464                 self.callback('loaded camera: ' +  str(id), \ 
     467                self.callback('loaded camera: ' +  str(cam_id), \ 
    465468                              float( i / len(tmp_list) * 0.25 + 0.75 ) )     
  • branches/code-cleanup-and-refactoring/game/pylintrc

    r549 r550  
    5454 
    5555# Disable the message(s) with the given id(s). 
    56 disable-msg=W0704,W0105,W0142,R0901,R0913,W0221,W0613,R0903,R0902,R0201,R0904 
     56disable-msg=W0704,W0105,W0142,R0901,R0913,W0221,W0613,R0903,R0902,R0201,R0904,R0914 
    5757 
    5858 
     
    140140 
    141141# Good variable names which should always be accepted, separated by a comma 
    142 good-names=k,ex,Run,_,__init__,__getstate__,__setstate__,ID,X,Y,__repr__,i 
     142good-names=k,ex,Run,_,__init__,__getstate__,__setstate__,ID,__repr__,i,x,y,z,X,Y,Z 
    143143 
    144144# Bad variable names which should always be refused, separated by a comma 
  • branches/code-cleanup-and-refactoring/game/run.py

    r547 r550  
    1414#   along with this program.  If not, see <http://www.gnu.org/licenses/>. 
    1515 
    16 import sys, os, shutil, re 
     16import os 
    1717 
    1818from scripts.common import utils 
    1919 
    2020from fife import fife 
    21 print "Using the FIFE python module found here: ", os.path.dirname(fife.__file__) 
     21print "Using the FIFE python module found here: ", \ 
     22    os.path.dirname(fife.__file__) 
    2223from fife.extensions.fife_settings import Setting 
    2324from scripts.parpg import PARPGApplication 
  • branches/code-cleanup-and-refactoring/game/scripts/console.py

    r549 r550  
    2222        @type appListener: ApplicationListener 
    2323        @param appListener: ApplicationListener object providing a link with 
    24         the engine, the world and the fife_model""" 
     24        the engine, the view and the fife_model""" 
    2525        exit_help   = "Terminate application" 
    2626        grid_help   = "Toggle grid display" 
     
    4545        ] 
    4646        self.app_listener = app_listener 
    47         self.world = self.app_listener.world  
     47        self.view = self.app_listener.view  
    4848        self.engine = self.app_listener.fife_model 
    49         self.game_state = self.app_listener.world.fife_model.game_state 
     49        self.game_state = self.app_listener.view.fife_model.game_state 
    5050 
    5151    def handleQuit(self, command): 
     
    6262           @param command: The command to run 
    6363           @return: The resultstring""" 
    64         self.world.togglePause() 
     64        self.view.togglePause() 
    6565        return "Game (un)paused" 
    6666     
     
    7070           @param command: The command to run 
    7171           @return: The resultstring""" 
    72         self.app_listener.world.active_map.toggleRenderer('GridRenderer') 
     72        self.app_listener.view.active_map.toggleRenderer('GridRenderer') 
    7373        return "Grid toggled" 
    7474 
  • branches/code-cleanup-and-refactoring/game/scripts/dialogue.py

    r520 r550  
    3838 
    3939class DialogueEngine(object): 
    40     def __init__(self, obj, callbacks={}, state={}): 
     40    def __init__(self, obj, callbacks = None, state = None): 
    4141        """A very simple dialogue engine for a game. 
    4242           d = DialogueEngine(tree, callbacks) 
     
    5050        logging.basicConfig(level=logging.INFO) 
    5151 
    52         self.callbacks = callbacks 
    53         self.state = state 
     52        self.callbacks = callbacks or {} 
     53        self.state = state or {} 
    5454        self.section_stack = [] 
    5555 
     
    109109                    self.runSection(self.section_stack[-1]) 
    110110            except ResponseException, e: 
    111                 logging.debug("Got response exception %s" % (e.args, )) 
     111                logging.debug("Got response exception %s" , e.args ) 
    112112                return e.args[0] 
    113113            except BackException, e: 
     
    158158                    if not cond or eval(cond[0], state, {}): 
    159159                        responses.append(r) 
    160                 except Exception, e: 
     160                except Exception: 
    161161                    print "Error in response conditional: %s" % (cond[0],) 
    162                     #raise e 
    163162 
    164163            section = responses[response][1] 
    165             logging.debug("User chose %s" % (section,)) 
     164            logging.debug("User chose %s", (section, )) 
    166165 
    167166            if section == "back": 
     
    189188                self.section_stack.pop(-1) 
    190189 
    191         logging.debug("In runSection %s %s" % (section_name, \ 
     190        logging.debug("In runSection %s %s", (section_name, \ 
    192191                                               self.section_stack,)) 
    193192        for command in itertools.cycle(self.getSection(section_name)): 
    194             logging.debug("command was %s" % (command,)) 
     193            logging.debug("command was %s", (command,)) 
    195194            if command.get("say"): 
    196195                if self.callbacks.get('say'): 
  • branches/code-cleanup-and-refactoring/game/scripts/gamemodel.py

    r548 r550  
    2020import sys 
    2121from gamestate import GameState 
    22 from objects import * 
    23 from objects.action import * 
     22from objects import createObject 
     23from objects.action import ChangeMapAction, ExamineBoxAction, OpenBoxAction, \ 
     24                            UnlockBoxAction, LockBoxAction, TalkAction 
    2425import yaml 
    2526 
     
    8283         
    8384        # Remove all currently loaded maps so we can start fresh 
    84         self.view.deleteMaps(); 
     85        self.view.deleteMaps() 
    8586         
    8687        self.game_state = pickle.load(f) 
     
    9899         
    99100        for map_id in self.game_state.objects: 
    100             for (object_id, obj) in self.game_state.objects[map_id].iteritems(): 
     101            for obj in self.game_state.objects[map_id].itervalues(): 
    101102                if obj.trueAttr("NPC") or obj.trueAttr("AnimatedContainer"): 
    102103                    obj.createBehaviour(self.view.active_map.agent_layer) 
  • branches/code-cleanup-and-refactoring/game/scripts/gamescenecontroller.py

    r549 r550  
    1717 
    1818from scripts.common.eventlistenerbase import EventListenerBase 
    19 from datetime import date 
    20 from datetime import time 
     19from datetime import date, time 
    2120from fife import fife 
     21from scripts.gui.hud import Hud 
     22import random 
     23import glob 
     24import os 
    2225 
    23 class GameController(EventListenerBase): 
     26class GameSceneController(EventListenerBase): 
    2427    ''' 
    2528    classdocs 
     
    2730 
    2831 
    29     def __init__(self, engine, view, model): 
     32    def __init__(self, engine, view, model, application, settings): 
    3033        ''' 
    3134        Constructor 
    3235        ''' 
    33         super(GameController, self).__init__(engine,  
     36        super(GameSceneController, self).__init__(engine,  
    3437                                             reg_mouse=True,  
    3538                                             reg_keys=True) 
     
    4245         
    4346        self.mouse_callback = None 
    44         self.quit_function = None 
     47        self.application = application 
     48        self.settings = settings 
    4549 
     50        # don't force restart if skipping to new section 
     51        if settings.get("FIFE",  "PlaySounds"): 
     52            if not self.view.sounds.music_init: 
     53                music_file = random.choice(glob.glob(os.path.join( 
     54                                                                  "music",  
     55                                                                  "*.ogg"))) 
     56                self.view.sounds.playMusic(music_file)  
     57 
     58 
     59    def initHud(self): 
     60        """Initialize the hud member 
     61        @return: None""" 
     62        hud_callbacks = { 
     63            'saveGame': self.saveGame, 
     64            'loadGame': self.loadGame, 
     65            'quitGame': self.quitGame, 
     66        } 
     67        self.view.hud = Hud(self.engine, self.settings, self.fife_model, hud_callbacks) 
    4668 
    4769    def keyPressed(self, evt): 
     
    141163        self.view.refreshTopLayerTransparencies() 
    142164        # print "%05f" % (time.time()-t0,) 
    143    
     165 
     166    def saveGame(self, *args, **kwargs): 
     167        """Saves the game state, delegates call to engine.Engine 
     168           @return: None""" 
     169        self.fife_model.save(*args, **kwargs) 
     170 
     171    def loadGame(self, *args, **kwargs): 
     172        """Loads the game state, delegates call to engine.Engine 
     173           @return: None""" 
     174        self.fife_model.load(*args, **kwargs) 
     175 
     176    def quitGame(self): 
     177        """Quits the game 
     178           @return: None""" 
     179        self.application.listener.quitGame() 
  • branches/code-cleanup-and-refactoring/game/scripts/gamesceneview.py

    r549 r550  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import random 
    19 import glob 
    20 import os  
    21 from sounds import SoundEngine 
    22 from scripts.common.eventlistenerbase import EventListenerBase 
    23 from fife.extensions.fife_settings import Setting 
    24 from scripts.gui import hud 
    2518from map import Map 
    2619from fife import fife 
    27  
    28 TDS = Setting(app_name="PARPG", 
    29               settings_file="./settings.xml",  
    30               settings_gui_xml="") 
     20from sounds import SoundEngine 
    3121 
    3222# this file should be the meta-file for all FIFE-related code 
     
    3828# however, any logic needed to resolve this should sit in engine.py 
    3929 
    40 class GameView(object): 
    41     """GameView holds the fife_model needed by fife to render the engine 
     30class GameSceneView(object): 
     31    """GameSceneView holds the fife_model needed by fife to render the engine 
    4232       The engine keeps a copy of this class""" 
    4333    def __init__(self, engine): 
     
    6151        self.sounds = SoundEngine(engine) 
    6252 
    63         self.hud = None 
    64          
    65         # don't force restart if skipping to new section 
    66         if TDS.get("FIFE",  "PlaySounds"): 
    67             if not self.sounds.music_init: 
    68                 music_file = random.choice(glob.glob(os.path.join( 
    69                                                                   "music",  
    70                                                                   "*.ogg"))) 
    71                 self.sounds.playMusic(music_file)  
     53        self.hud = None         
    7254 
    7355        # The current highlighted object 
     
    7658        # faded objects in top layer 
    7759        self.faded_objects = set() 
    78  
    79     def initHud(self): 
    80         """Initialize the hud member 
    81         @return: None""" 
    82         hud_callbacks = { 
    83             'saveGame': self.saveGame, 
    84             'loadGame': self.loadGame, 
    85             'quitGame': self.quitGame, 
    86         } 
    87         self.hud = hud.Hud(self.engine, TDS, self.fife_model, hud_callbacks)    
    88  
    89     def quitGame(self): 
    90         """Quits the game 
    91            @return: None""" 
    92         self.quit_function() 
    93  
    94     def saveGame(self, *args, **kwargs): 
    95         """Saves the game state, delegates call to engine.Engine 
    96            @return: None""" 
    97         self.fife_model.save(*args, **kwargs) 
    98  
    99     def loadGame(self, *args, **kwargs): 
    100         """Loads the game state, delegates call to engine.Engine 
    101            @return: None""" 
    102         self.fife_model.load(*args, **kwargs) 
    10360 
    10461    def loadMap(self, map_name, filename): 
     
    241198 
    242199    def highlightFrontObject(self, mouse_coords): 
    243         """Highlights the object that is at the current mouse coordinates""" 
     200        """Highlights the object that is at the current mouse coordinates"""         
    244201        if mouse_coords: 
    245202            front_obj = self.getObjectAtCoords(mouse_coords) 
     
    250207                    if self.highlight_obj: 
    251208                        self.displayObjectText(self.highlight_obj,"") 
    252                     self.active_map.outline_render.removeAllOutlines() 
     209                    self.active_map.outline_renderer.removeAllOutlines() 
    253210                    self.highlight_obj = front_obj 
    254                     self.active_map.outline_render.addOutlined( 
     211                    self.active_map.outline_renderer.addOutlined( 
    255212                                                    self.highlight_obj,  
    256213                                                    0, 
     
    265222                if self.highlight_obj: 
    266223                    self.displayObjectText(self.highlight_obj,"") 
    267                 self.active_map.outline_render.removeAllOutlines() 
    268                 self.highlight_obj = None       
     224                self.active_map.outline_renderer.removeAllOutlines() 
     225                self.highlight_obj = None   
     226            
  • branches/code-cleanup-and-refactoring/game/scripts/gamestate.py

    r476 r550  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 from objects import base 
    1918from scripts import quest_engine 
    2019 
  • branches/code-cleanup-and-refactoring/game/scripts/gui/dialoguegui.py

    r532 r550  
    104104        self.dialogue_gui.mapEvents(events) 
    105105        self.dialogue_gui.show() 
    106         responses_list = self.dialogue_gui.findChild(name='choices_list') 
     106        #responses_list = self.dialogue_gui.findChild(name='choices_list') 
    107107        responses = self.dialogue_engine.run() 
    108108        self.setResponses(responses) 
     
    146146            (first_name, desc) = name.split(" ",1) 
    147147            stats_label.text = u'Name: ' + first_name + "\n" + desc 
    148         except: 
     148        except(ValueError): 
    149149            stats_label.text = u'Name: ' + name  
    150150             
  • branches/code-cleanup-and-refactoring/game/scripts/gui/hud.py

    r549 r550  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import shutil 
    19 from fife import fife 
    2018from fife.extensions import pychan 
    2119from fife.extensions.pychan.tools import callbackWithArguments as cbwa 
    22 from fife.extensions.pychan import widgets 
    2320 
    2421from scripts.gui.filebrowser import FileBrowser 
     
    5855        self.box_container = None 
    5956        self.examine_box = None 
    60  
     57        self.context_menu = None 
     58        self.help_dialog = None 
     59        self.events_to_map = None 
     60        self.main_menu = None 
     61        self.menu_events = None 
     62        self.quit_window = None 
     63         
    6164        self.actions_box = self.hud.findChild(name="actionsBox") 
    6265        self.actions_text = [] 
     
    7376        """Initialize and show the main HUD 
    7477           @return: None""" 
    75         self.events_to_map = {"menuButton":self.displayMenu,} 
     78        self.events_to_map = {"menuButton":self.displayMenu, } 
    7679        self.hud.mapEvents(self.events_to_map)  
    7780        # set HUD size according to screen size 
     
    130133 
    131134    def initializeInventory(self): 
     135        """Initialize the inventory""" 
    132136        inv_callbacks = { 
    133137            'refreshReadyImages': self.refreshReadyImages, 
     
    144148        """Initialize the Context Menu 
    145149           @return: None""" 
    146         self.context_menu = ContextMenu (self.engine, [], (0,0)) 
     150        self.context_menu = ContextMenu (self.engine, [], (0, 0)) 
    147151        self.context_menu.hide() 
    148152 
     
    221225        self.help_dialog.show() 
    222226 
    223     def switchResolutions(self): 
    224         """ Sync the contents of the resolution box (windowed or fullscreen 
    225             resolutions to the selection made in the Fullscreen checkbox. 
    226             @return: None""" 
    227              
    228         if self.options_menu.collectData('FullscreenBox'): 
    229             self.options_menu.distributeInitialData({ 
    230                                 'ResolutionBox' : self.resolutions_fullscreen 
    231                                                      }) 
    232         else: 
    233             self.options_menu.distributeInitialData({ 
    234                                 'ResolutionBox' : self.resolutions_windowed 
    235                                                      }) 
    236          
    237  
    238  
    239227    def saveGame(self): 
    240228        """ Called when the user wants to save the game. 
     
    306294            button.toggled = 0 
    307295 
    308     def toggleInventory(self, toggleImage=True): 
     296    def toggleInventory(self, toggle_image=True): 
    309297        """Displays the inventory screen 
    310298           @return: None""" 
    311299        if self.inventory == None: 
    312300            self.initializeInventory() 
    313         self.inventory.toggleInventory(toggleImage) 
     301        self.inventory.toggleInventory(toggle_image) 
    314302 
    315303    def refreshReadyImages(self): 
     
    317305           on the inventory 
    318306           @return: None""" 
    319         for ready in range(1,5): 
     307        for ready in range(1, 5): 
    320308            button = self.hud.findChild(name=("hudReady%d" % ready)) 
    321309            if self.inventory_storage == None : 
    322310                origin = None 
    323311            else: 
    324                origin = self.inventory_storage.getItemsInSlot('ready', ready-1) 
     312                origin = self.inventory_storage.getItemsInSlot('ready', ready-1) 
    325313            if origin == None: 
    326                 self.setImages(button, self.inventory.slot_empty_images['ready']) 
     314                self.setImages(button,  
     315                               self.inventory.slot_empty_images['ready']) 
    327316            else: 
    328                 self.setImages(button,origin.getInventoryThumbnail()) 
     317                self.setImages(button, origin.getInventoryThumbnail()) 
    329318 
    330319    def setImages(self, widget, image): 
     
    364353        self.main_menu.mapEvents(menu_events) 
    365354 
    366     def updateVolumeText(self): 
    367         """Update the initial volume label to the value of the slider""" 
    368         volume = float(self.options_menu.collectData("InitialVolumeSlider")) 
    369         volume_label = self.options_menu.findChild(name="InitialVolumeLabel") 
    370         volume_label.text = unicode("Initial Volume: %.0f%s" % 
    371                                     (int(volume*10), "%")) 
    372  
    373355    def setOption(self, name, value): 
    374356        """Set an option within the xml. 
     
    384366        else: 
    385367            print 'Setting,', name, 'does not exist!' 
    386  
    387     def setToDefaults(self): 
    388         """Reset all the options to the options in settings-dist.xml. 
    389            @return: None""" 
    390         shutil.copyfile('settings-dist.xml', 'settings.xml') 
    391         self.requireRestartDialog() 
    392         self.options_menu.hide() 
    393368     
    394369    def readyAction(self, ready_button): 
  • branches/code-cleanup-and-refactoring/game/scripts/gui/inventorygui.py

    r532 r550  
    7979 
    8080        for slot in self.slot_buttons: 
    81             for index, button in enumerate(self.slot_buttons[slot]): 
     81            for button in enumerate(self.slot_buttons[slot].values): 
    8282                events_to_map[button] = cbwa(self.dragDrop, button) 
    8383        events_to_map['close_button'] = self.closeInventoryAndToggle 
     
    143143        self.inventory.show() 
    144144 
    145     def setMouseCursor(self, image, dummy_image, type="native"):  
     145    def setMouseCursor(self, image, dummy_image, cur_type="native"):  
    146146        """Set the mouse cursor to an image. 
    147147           @type image: string 
     
    149149           @type dummy_image: string 
    150150           @param dummy_image: ??? 
    151            @type type: string 
    152            @param type: ??? 
     151           @type cur_type: string 
     152           @param cur_type: ??? 
    153153           @return: None""" 
    154154        cursor = self.engine.getCursor() 
    155         cursor_type = fife.CURSOR_IMAGE 
     155        fife_cur_type = fife.CURSOR_IMAGE 
    156156        img_pool = self.engine.getImagePool() 
    157         if(type == "target"): 
     157        if(cur_type == "target"): 
    158158            target_cursor_id = img_pool.addResourceFromFile(image)   
    159159            dummy_cursor_id = img_pool.addResourceFromFile(dummy_image) 
    160             cursor.set(cursor_type,dummy_cursor_id) 
    161             cursor.setDrag(cursor_type,target_cursor_id,-16,-16) 
     160            cursor.set(fife_cur_type,dummy_cursor_id) 
     161            cursor.setDrag(fife_cur_type,target_cursor_id,-16,-16) 
    162162        else: 
    163             cursor_type = fife.CURSOR_IMAGE 
     163            fife_cur_type = fife.CURSOR_IMAGE 
    164164            zero_cursor_id = img_pool.addResourceFromFile(image) 
    165             cursor.set(cursor_type,zero_cursor_id) 
    166             cursor.setDrag(cursor_type,zero_cursor_id) 
     165            cursor.set(fife_cur_type,zero_cursor_id) 
     166            cursor.setDrag(fife_cur_type,zero_cursor_id) 
    167167             
    168168    def resetMouseCursor(self): 
     
    232232            self.resetMouseCursor() 
    233233            data_drag.dragging = False 
    234         except Container.TooBig : 
     234        except "Container.TooBig" : 
    235235            print("%s too big to fit into %s" % (data_drag.dragged_item, 
    236236                                                 drop_widget.slot)) 
  • branches/code-cleanup-and-refactoring/game/scripts/inventory.py

    r480 r550  
    1414# along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1515 
    16 from scripts.objects.base import GameObject, Container, Carryable 
    17 from scripts.objects.composed import CarryableContainer, SingleItemContainer as Slot 
     16from scripts.objects.base import Container 
     17from scripts.objects.composed import CarryableContainer, \ 
     18                                        SingleItemContainer as Slot 
    1819import copy 
    1920 
     
    6667    def moveItemToSlot(self,item,slot,index=None): 
    6768        if not slot in self.items: 
    68             raise(ValueError,"%s: No such slot" % slot) 
     69            raise(ValueError("%s: No such slot" % slot)) 
    6970 
    7071        if item.ID in self.item_lookup: 
     
    8485    def getItemsInSlot(self, slot, index=None): 
    8586        if not slot in self.items: 
    86             raise(ValueError,"%s: No such slot" % slot) 
     87            raise(ValueError("%s: No such slot" % slot)) 
    8788        if index != None: 
    8889            return self.items[slot].items.get(index) 
     
    9293    def isSlotEmpty(self, slot): 
    9394        if not slot in self.items: 
    94             raise(ValueError,"%s: No such slot" % slot) 
     95            raise(ValueError("%s: No such slot" % slot)) 
    9596        return self.items[slot].count() == 0 
    9697 
    9798    def has(self, item): 
    98         return item.ID in self.item_lookup; 
     99        return item.ID in self.item_lookup 
    99100 
    100101    def findItemByID(self, ID): 
  • branches/code-cleanup-and-refactoring/game/scripts/map.py

    r549 r550  
    1717 
    1818from fife import fife 
    19 import time 
    2019from local_loaders.loaders import loadMapFile 
    21 from scripts.common.eventlistenerbase import EventListenerBase 
    2220from fife.extensions.fife_settings import Setting 
    2321 
     
    8684        #find out if a PC instance was created when the map was loaded 
    8785        found = False 
     86        inst = None 
    8887        for inst in self.agent_layer.getInstances(): 
    8988            if inst.getId() == "PC": 
     
    9897            z = 0 
    9998            pc_obj = self.fife_model.getObject("player", "PARPG") 
    100             inst = self.agent_layer.createInstance(pc_obj,\ 
    101                                             fife.ExactModelCoordinate(x,y,z),\ 
     99            inst = self.agent_layer.createInstance(pc_obj, \ 
     100                                            fife.ExactModelCoordinate( 
     101                                                                      x, 
     102                                                                      y, 
     103                                                                      z), 
    102104                                            "PC") 
    103105            fife.InstanceVisual.create(inst) 
     
    128130            width = self.engine.getSettings().getScreenWidth() 
    129131            height = self.engine.getSettings().getScreenHeight()  
    130             viewport = fife.Rect(0,0,width,height) 
     132            viewport = fife.Rect(0, 0, width, height) 
    131133            cam.setViewPort(viewport) 
    132134            self.my_cam_id = cam.getId() 
     
    136138        self.target_rotation = self.cameras[self.my_cam_id].getRotation() 
    137139 
    138         self.outline_render = fife.InstanceRenderer.\ 
    139                                         getInstance(self.cameras[self.my_cam_id]) 
     140        self.outline_renderer = fife.InstanceRenderer.\ 
     141                                        getInstance( 
     142                                                    self.cameras[ 
     143                                                                 self.my_cam_id 
     144                                                                 ]) 
    140145 
    141146        # set the render text 
    142         rend = fife.FloatingTextRenderer.getInstance(self.cameras[self.my_cam_id]) 
     147        rend = fife.FloatingTextRenderer.getInstance(self.cameras[ 
     148                                                                  self.my_cam_id 
     149                                                                  ]) 
    143150        text = self.engine.getGuiManager().\ 
    144151                        createFont('fonts/rpgfont.png', 0, \ 
     
    146153        rend.changeDefaultFont(text) 
    147154        rend.activateAllLayers(self.map) 
    148           
    149         # Activate the grid renderer on all layers 
    150         rend = self.cameras['map_camera'].getRenderer('GridRenderer') 
    151         rend.activateAllLayers(self.map) 
     155         
     156        # Activate the grid renderer on all layers 
     157        rend = self.cameras['map_camera'].getRenderer('GridRenderer') 
     158        rend.activateAllLayers(self.map) 
    152159          
    153160        # Make World aware that this is now the active map. 
     
    164171        # was already used, we simply recycle it.  
    165172        if self.cameras[self.my_cam_id].getAttached() == None: 
    166             self.cameras[self.my_cam_id].attach(self.model.game_state.PC.behaviour.agent) 
     173            self.cameras[self.my_cam_id].attach(self.model.game_state. 
     174                                                PC.behaviour.agent) 
    167175 
    168176    def toggleRenderer(self, r_name): 
  • branches/code-cleanup-and-refactoring/game/scripts/objects/action.py

    r477 r550  
    3636           @param target_pos: (X, Y) coordinates on the target map. 
    3737           @return: None""" 
     38        Action.__init__(self) 
    3839        self.engine = engine 
    3940        self.target_pos = target_pos 
     
    5253           @param engine: A reference to the engine. 
    5354           @param container: A reference to the container""" 
     55        Action.__init__(self) 
    5456        self.engine = engine 
    5557        self.container = container 
     
    7072    def __init__(self,  container): 
    7173        """@param container: A reference to the container""" 
     74        Action.__init__(self) 
    7275        self.container = container 
    7376     
     
    8083    def __init__(self, container): 
    8184        """@param container: A reference to the container""" 
     85        Action.__init__(self) 
    8286        self.container = container 
    8387         
     
    96100           @type examine_name: String 
    97101           @param examine_name: Description of the object to be examined.""" 
     102        Action.__init__(self) 
    98103        self.engine = engine 
    99104        self.examine_name = examine_name 
     
    112117           @type npc: NonPlayerCharacter 
    113118           @param npc: NPC to interact with.""" 
     119        Action.__init__(self) 
    114120        self.engine = engine 
    115121        self.npc = npc 
  • branches/code-cleanup-and-refactoring/game/scripts/objects/actors.py

    r549 r550  
    1717 
    1818from fife import fife 
    19 from scripts import gameview 
    20 from base import * 
    21 from composed import * 
     19from base import GameObject, Living, Scriptable, CharStats 
     20from fife.extensions.fife_settings import Setting 
     21from composed import CarryableItem 
    2222from scripts.inventory import Inventory 
     23from random import randrange 
    2324 
    2425"""All actors go here. Concrete classes only.""" 
     
    3637        fife.InstanceActionListener.__init__(self) 
    3738        self.layer = layer 
     39        self.agent = None 
     40        self.state = None 
     41        self.speed = 0 
    3842     
    3943    def attachToLayer(self, agent_ID): 
     
    115119 
    116120        self.is_PC = True 
     121        self.behaviour = None 
    117122         
    118123        # PC _has_ an inventory, he _is not_ one 
     
    218223        self.parent = Parent 
    219224        self.state = _AGENT_STATE_NONE 
     225        self.pc = None 
     226        self.target_loc = None 
    220227         
    221228        # hard code this for now 
     
    286293 
    287294        self.is_NPC = True 
     295        self.behaviour = None 
     296         
    288297        if inventory == None: 
    289298            self.inventory = Inventory() 
     
    297306        self.createBehaviour(agent_layer)         
    298307        self.dialogue = kwargs.get('dialogue') 
    299  
     308         
    300309    def prepareStateForSaving(self, state): 
    301310        """Prepares state for saving 
  • branches/code-cleanup-and-refactoring/game/scripts/objects/base.py

    r542 r550  
    2222   Some rules that should be followed when CREATING base property classes: 
    2323    
    24    1. If you want to support some custom initialization arguments, always define  
    25       them as keyword ones. Only GameObject would use positional arguments. 
     24   1. If you want to support some custom initialization arguments,  
     25      always define them as keyword ones. Only GameObject would use  
     26      positional arguments. 
    2627   2. In __init__() **ALWAYS** call the parent's __init__(**kwargs), preferably  
    2728      *at the end* of your __init__() (makes it easier to follow) 
     
    3839         
    3940 
    40    Some rules are to be followed when USING the base classes to make composed ones: 
     41   Some rules are to be followed when USING the base classes to make composed  
     42   ones: 
    4143 
    4244   1. The first parent should always be the base GameObject class 
     
    5153           super(TinCan,self).__init__ (*args, **kwargs) 
    5254           self.name = 'Tin Can'""" 
    53             
    54 from fife import fife 
    55 from fife.extensions.fife_settings import Setting 
    56 from random import randrange 
    57 from scripts.gui.popups import ExaminePopup, ContainerGUI 
    58  
     55          
    5956class DynamicObject (object): 
    6057    """A base class that only supports dynamic attributes functionality""" 
    61     def __init__ (self, name="Dynamic object", image=None, engine = None, **kwargs): 
     58    def __init__ (self, name="Dynamic object", image=None, **kwargs): 
    6259        """Initialise minimalistic set of data 
    6360           @type name: String 
     
    6764        self.name = name 
    6865        self.image = image 
    69         self.engine = engine 
    7066 
    7167    def prepareStateForSaving(self, state): 
     
    7470        @param state: State of the object   
    7571        """ 
    76         del state["engine"] 
     72        pass 
    7773     
    7874    def restoreState(self, state): 
     
    10096    """A base class to be inherited by all game objects. This must be the 
    10197       first class (left to right) inherited by any game object.""" 
    102     def __init__ (self, ID, gfx = {}, xpos = 0.0, ypos = 0.0, map_id = None,  
     98    def __init__ (self, ID, gfx = None, xpos = 0.0, ypos = 0.0, map_id = None,  
    10399                  blocking=True, name="Generic object", text="Item description", 
    104100                  desc="Detailed description", **kwargs): 
     
    123119        DynamicObject.__init__(self, name, **kwargs) 
    124120        self.ID = ID 
    125         self.gfx = gfx 
     121        self.gfx = gfx or {} 
    126122        self.X = xpos 
    127123        self.Y = ypos 
     
    140136         
    141137    coords = property (_getCoords, _setCoords,  
    142         doc = "Property allowing you to get and set the obejct's coordinates via tuples") 
     138        doc = "Property allowing you to get and set the obejct's \ 
     139                coordinates via tuples") 
    143140     
    144141    def __repr__(self): 
     
    146143        return "<%s:%s>" % (self.name, self.ID) 
    147144 
    148 class Openable(object): 
     145class Scriptable (object): 
     146    """Allows objects to have predefined scripts executed on certain events""" 
     147    def __init__ (self, scripts = None, **kwargs): 
     148        """Init operation for scriptable objects 
     149           @type scripts: Dictionary 
     150           @param scripts: Dictionary where the event strings are keys. The  
     151           values are 3-item tuples (function, positional_args, keyword_args)""" 
     152        self.is_scriptable = True 
     153        self.scripts = scripts or {} 
     154         
     155    def runScript (self, event): 
     156        """Runs the script for the given event""" 
     157        if event in self.scripts and self.scripts[event]: 
     158            func, args, kwargs = self.scripts[event] 
     159            func (*args, **kwargs) 
     160             
     161    def setScript (self, event, func, args = None , kwargs = None): 
     162        """Sets a script to be executed for the given event.""" 
     163        args = args or {} 
     164        kwargs = kwargs or {} 
     165        self.scripts[event] = (func, args, kwargs) 
     166 
     167class Openable(DynamicObject, Scriptable): 
    149168    """Adds open() and .close() capabilities to game objects 
    150169       The current state is tracked by the .is_open variable""" 
     
    153172           @type is_open: Boolean 
    154173           @param is_open: Keyword boolean argument sets the initial state.""" 
     174        DynamicObject.__init__(self, **kwargs) 
     175        Scriptable.__init__(self, **kwargs) 
    155176        self.is_openable = True 
    156177        self.is_open = is_open 
     
    187208        self.locked = locked 
    188209        if locked : 
    189             is_open=False 
     210            is_open = False 
    190211        Openable.__init__( self, is_open, **kwargs ) 
    191212         
     
    204225        if self.locked: 
    205226            raise ValueError ("Open failed: object locked") 
    206         super (Lockable,self).open(*args,**kwargs) 
    207          
    208 class Carryable (object): 
     227        super (Lockable, self).open(*args, **kwargs) 
     228         
     229class Carryable (DynamicObject): 
    209230    """Allows objects to be stored in containers""" 
    210231    def __init__ (self, weight=0.0, bulk=0.0, **kwargs): 
     232        DynamicObject.__init__(self, **kwargs) 
    211233        self.is_carryable = True 
    212234        self.in_container = None 
    213235        self.weight = weight 
    214         self.bulk=bulk 
     236        self.bulk = bulk 
    215237 
    216238    def getInventoryThumbnail(self): 
     239        """Returns the inventory thumbnail of the object""" 
    217240        # TODO: Implement properly after the objects database is in place 
    218241        if self.image == None: 
     
    221244            return self.image 
    222245     
    223 class Container (object): 
     246class Container (DynamicObject, Scriptable): 
    224247    """Gives objects the capability to hold other objects""" 
    225248    class TooBig(Exception): 
     
    233256 
    234257    def __init__ (self, capacity = 0, **kwargs): 
     258        DynamicObject.__init__(self, **kwargs) 
     259        Scriptable.__init__(self, **kwargs) 
    235260        self.is_container = True 
    236261        self.items = {} 
    237         self.capacity=capacity 
     262        self.capacity = capacity 
    238263         
    239264    def placeItem (self, item, index=None): 
     
    243268            raise TypeError ('%s is not carriable!' % item) 
    244269        if self.capacity and self.getContentsBulk()+item.bulk > self.capacity: 
    245             raise self.TooBig ('%s is too big to fit into %s' % (item,self)) 
     270            raise self.TooBig ('%s is too big to fit into %s' % (item, self)) 
    246271        item.in_container = self 
    247272        if index == None: 
     
    249274        else: 
    250275            if index in self.items : 
    251                 raise self.SlotBusy('Slot %d is busy in %s' % (index, self.name)) 
    252             self.items[index]=item 
     276                raise self.SlotBusy('Slot %d is busy in %s' % (index,  
     277                                                               self.name)) 
     278            self.items[index] = item 
    253279 
    254280        # Run any scripts associated with storing an item in the container 
     
    260286 
    261287    def placeAtVacant(self, item): 
     288        """Places an item at a vacant slot""" 
    262289        vacant = None 
    263290        for i in range(len(self.items)): 
     
    284311 
    285312    def count (self): 
     313        """Returns the number of items""" 
    286314        return len(self.items) 
    287315 
     
    291319 
    292320    def findItemByID(self, ID): 
     321        """Returns the item with the passed ID""" 
    293322        for i in self.items : 
    294323            if self.items[i].ID == ID: 
     
    312341         
    313342class Living (object): 
     343    """Objects that 'live'""" 
    314344    def __init__ (self, **kwargs): 
    315345        self.is_living = True 
    316346 
    317347    def die(self): 
    318         self.is_living = False 
    319          
    320 class Scriptable (object): 
    321     """Allows objects to have predefined scripts executed on certain events""" 
    322     def __init__ (self, scripts = {}, **kwargs): 
    323         """Init operation for scriptable objects 
    324            @type scripts: Dictionary 
    325            @param scripts: Dictionary where the event strings are keys. The  
    326            values are 3-item tuples (function, positional_args, keyword_args)""" 
    327         self.is_scriptable = True 
    328         self.scripts = scripts  
    329          
    330     def runScript (self, event): 
    331         """Runs the script for the given event""" 
    332         if event in self.scripts and self.scripts[event]: 
    333             func, args, kwargs = self.scripts[event] 
    334             func (*args, **kwargs) 
    335              
    336     def setScript (self, event, func, args = [] , kwargs={}): 
    337         """Sets a script to be executed for the given event.""" 
    338         self.scripts[event] = (func, args, kwargs) 
     348        """Kills the object""" 
     349        self.is_living = False    
    339350 
    340351class CharStats (object): 
     
    344355         
    345356class Wearable (object): 
     357    """Objects than can be weared""" 
    346358    def __init__ (self, slots, **kwargs): 
    347359        """Allows the object to be worn somewhere on the body (e.g. pants)""" 
    348360        self.is_wearable = True 
    349         if isinstance(slots,tuple) : 
     361        if isinstance(slots, tuple) : 
    350362            self.slots = slots 
    351363        else : 
  • branches/code-cleanup-and-refactoring/game/scripts/objects/composed.py

    r477 r550  
    1818"""Composite game object classes are kept here""" 
    1919 
    20 from base import * 
     20from base import GameObject, Container, Lockable, \ 
     21                Scriptable, Trappable, Destructable, Carryable 
    2122 
    2223class ImmovableContainer(GameObject, Container, Lockable, Scriptable,  
     
    3233        self.blocking = True 
    3334 
    34 class CarryableContainer(DynamicObject, Container, Carryable): 
     35class CarryableContainer(Container, Carryable): 
    3536    """Composite class that will be used for backpack, pouches, etc.""" 
    3637    def __init__ (self, **kwargs): 
    37         DynamicObject.__init__(self, **kwargs) 
    38         Container.__init__(self,**kwargs) 
    39         Carryable.__init__(self,**kwargs) 
     38        Container.__init__(self, **kwargs) 
     39        Carryable.__init__(self, **kwargs) 
     40        self.own_bulk = 0 
     41        self.own_weight = 0 
    4042 
    4143    def getWeight(self): 
  • branches/code-cleanup-and-refactoring/game/scripts/parpg.py

    r549 r550  
    1919from scripts import gamemodel 
    2020 
    21 from scripts import gameview 
     21from scripts import gamesceneview 
    2222from scripts import console 
    23 from scripts import gamecontroller 
     23from scripts import gamescenecontroller 
    2424from scripts.common import eventlistenerbase 
    2525 
     
    4242           @type engine: fife.GameModel 
    4343           @param engine: ??? 
    44            @type gameview: gameview.GameView 
    45            @param gameview: ??? 
     44           @type gamesceneview: gamesceneview.GameSceneView 
     45           @param gamesceneview: ??? 
    4646           @type fife_model: engine.GameModel 
    4747           @param fife_model: an instance of PARPG's engine""" 
     
    5252                                                  reg_widget=True) 
    5353        self.engine = engine 
    54         self.world = world 
     54        self.view = world 
    5555        self.fife_model = model 
    5656        keyfilter = KeyFilter([fife.Key.ESCAPE]) 
     
    8989    """Main Application class 
    9090       We use an MVC fife_model fife_model. 
    91        self.gameview is our view,self.fife_model is our fife_model 
     91       self.gamesceneview is our view,self.fife_model is our fife_model 
    9292       This file is the minimal controller""" 
    9393    def __init__(self, setting): 
     
    9595           @return: None""" 
    9696        super(PARPGApplication, self).__init__(setting) 
    97         self.world = gameview.GameView(self.engine) 
    98         self.fife_model = gamemodel.GameModel(self.world) 
    99         self.controller = gamecontroller.GameController(self.engine,  
    100                                                         self.world,  
    101                                                         self.fife_model) 
     97        self.view = gamesceneview.GameSceneView(self.engine) 
     98        self.fife_model = gamemodel.GameModel(self.view) 
     99        self.controller = gamescenecontroller.GameSceneController(self.engine,  
     100                                                        self.view,  
     101                                                        self.fife_model,  
     102                                                        self, 
     103                                                        setting) 
    102104        self.fife_model.readObjectDB(self._setting.get("PARPG",  
    103105                                                  "ObjectDatabaseFile")) 
    104         self.world.fife_model = self.fife_model 
    105         self.world.initHud() 
    106         self.listener = ApplicationListener(self.engine, self.world, self.fife_model) 
    107         self.world.quitFunction = self.listener.quitGame 
     106        self.view.fife_model = self.fife_model 
     107        self.controller.initHud() 
     108        self.listener = ApplicationListener(self.engine,  
     109                                            self.view,  
     110                                            self.fife_model) 
    108111        self.fife_model.loadMap("main-map", str(self._setting.get("PARPG",  
    109112                                                             "MapFile"))) 
     
    118121    def _pump(self): 
    119122        """Main game loop. 
    120            There are in fact 2 main loops, this one and the one in GameView. 
     123           There are in fact 2 main loops, this one and the one in GameSceneView. 
    121124           @return: None""" 
    122125        if self.listener.quit: 
  • branches/code-cleanup-and-refactoring/game/utilities/gfxsplit.py

    r328 r550  
    5656    # the \n\n is ESSENTIAL otherwise the XML parser in FIFE craps out! 
    5757    x_file.write('''</object>\n\n''') 
    58     x_file.close 
     58    x_file.close() 
    5959 
    6060def stitchImages(files, width, height): 
     
    8282            # output the XML file as well 
    8383            writeXML(i.filename, str(i.y_offset)) 
    84         except: 
     84        except(IOError): 
    8585            print "Error: Failed to save",i.filename 
    8686            # if we saved some anyway, then tell the user 
     
    104104    # the starting point for the grab is always the middle of the image 
    105105    height = (image.get_height() / 2) + (TILE_HEIGHT / 2) 
     106    width = 0 
    106107    x_pos = 0 
    107108    file_counter = 0 
Note: See TracChangeset for help on using the changeset viewer.