Changeset 553 for trunk


Ignore:
Timestamp:
06/19/10 23:03:06 (9 years ago)
Author:
beliar
Message:

Merged changes from code-cleanup-and-refactoring back into the trunk.

Location:
trunk
Files:
4 deleted
37 edited
5 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/game/local_loaders/__init__.py

    r474 r553  
    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    for _ in master_leftovers: 
     84        pathstr += '..' + dir_delim 
     85        master_leftovers = master_leftovers[1:] 
     86    pathstr += dir_delim.join(sub_leftovers) 
    8687    return pathstr 
    8788 
  • trunk/game/local_loaders/loaders.py

    r473 r553  
    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): 
  • trunk/game/local_loaders/xmlmap.py

    r541 r553  
    1818# as we read map files 
    1919 
    20 import sys, os 
     20import os 
    2121 
    2222from scripts.common.utils import parseBool 
    2323from fife import fife  
    2424try: 
    25     import xml.etree.cElementTree as ET 
    26 except: 
     25    import xml.etree.cElementTree as ET  
     26except ImportError: 
    2727    import xml.etree.ElementTree as ET 
    2828 
    2929from fife.extensions import loaders 
    30 from fife.extensions import serializers 
     30#from fife.extensions import serializers 
    3131import time 
    3232 
     
    4141    NOTE: masterfile is expected to be *file*, not directory. subfile can be either 
    4242    """ 
    43     s = '/' 
     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(s) 
    49     sub_fragments = subfile.split(s) 
     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 += '..' + s 
    65     pathstr += s.join(sub_leftovers) 
     63    for _ in master_leftovers[:-1]: 
     64        pathstr += '..' + dir_delim 
     65    pathstr += dir_delim.join(sub_leftovers) 
    6666    return pathstr 
    6767 
     
    9191 
    9292class XMLMapLoader(fife.ResourceLoader): 
    93     def __init__(self, engine, data, callback): 
     93    def __init__(self, engine, model, callback): 
    9494        """ The XMLMapLoader parses the xml map using several section.  
    9595        Each section fires a callback (if given) which can e. g. be 
     
    101101        Inputs: 
    102102            engine = FIFE engine 
    103             data = Engine object for PARPG data 
     103            model = The game model 
    104104            callback = function callback 
    105105        """ 
     
    110110 
    111111        self.engine = engine 
    112         self.data = data 
     112        self.model = model 
    113113        self.vfs = self.engine.getVFS() 
    114         self.model = self.engine.getModel() 
     114        self.fife_model = self.engine.getModel() 
    115115        self.pool = self.engine.getImagePool() 
    116116        self.anim_pool = self.engine.getAnimationPool() 
     
    120120 
    121121        self.n_space = None 
     122        self.x = 0 
     123        self.y = 0 
    122124 
    123125    def _err(self, msg): 
     
    132134        root = tree.getroot() 
    133135             
    134         map = self.parseMap(root) 
     136        ret_map = self.parseMap(root) 
    135137        self.time_to_load = time.time() - start_time 
    136         return map 
     138        return ret_map 
    137139 
    138140    def parseMap(self, map_elt): 
    139         if not map_elt: 
     141        if not map_elt and not map_elt.tag == "map": 
    140142            self._err(\ 
    141143                '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 
     144        map_id,map_format = map_elt.get('id'),map_elt.get('format') 
     145 
     146        if not map_format == FORMAT: 
     147            self._err(''.join(['This file has map_format ', map_format, 
     148                               ' but this loader has map_format ', FORMAT])) 
     149        if not map_id: self._err('Map declared without an identifier.') 
     150 
     151        self.map = None 
    150152        try: 
    151             self.map = self.model.createMap(str(id)) 
     153            self.map = self.fife_model.createMap(str(map_id)) 
    152154            self.map.setResourceFile(self.source) 
    153155        # NameClash appears as general fife.Exception; any ideas? 
    154156        except fife.Exception, e:  
    155157            print e.getMessage() 
    156             print ''.join(['File: ', self.source, '. The map ', str(id), \ 
     158            print ''.join(['File: ', self.source, '. The map ', str(map_id), \ 
    157159                           ' already exists! Ignoring map definition.']) 
    158160            return None 
     
    172174        return self.map 
    173175 
    174     def parseImports(self, map_elt, map): 
     176    def parseImports(self, map_elt, game_map): 
    175177        parsedImports = {} 
    176178 
     
    180182         
    181183        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) 
     184            imp_file = item.get('file') 
     185            if imp_file: 
     186                imp_file = reverseRootSubfile(self.source, imp_file) 
     187            directory = item.get('dir') 
     188            if directory: 
     189                directory = reverseRootSubfile(self.source, directory) 
    188190 
    189191            # Don't parse duplicate imports 
    190             if (dir,file) in parsedImports: 
    191                 print "Duplicate import:" ,(dir,file) 
     192            if (directory,imp_file) in parsedImports: 
     193                print "Duplicate import:" ,(directory,imp_file) 
    192194                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) 
     195            parsedImports[(directory,imp_file)] = 1 
     196 
     197            if imp_file and directory: 
     198                loaders.loadImportFile('/'.join(directory, imp_file), self.engine) 
     199            elif imp_file: 
     200                loaders.loadImportFile(imp_file, self.engine) 
     201            elif directory: 
     202                loaders.loadImportDirRec(directory, self.engine) 
     203                game_map.importDirs.append(directory) 
    202204            else: 
    203205                print 'Empty import statement?' 
     
    209211 
    210212 
    211     def parseLayers(self, map_elt, map): 
     213    def parseLayers(self, map_elt, game_map): 
    212214        if self.callback is not None:         
    213215            tmp_list = map_elt.findall('layer') 
     
    215217 
    216218        for layer in map_elt.findall('layer'): 
    217             id = layer.get('id') 
     219            layer_id = layer.get('id') 
    218220            grid_type = layer.get('grid_type') 
    219221            x_scale = layer.get('x_scale') 
     
    236238                transparency = int(transparency) 
    237239 
    238             if not id: self._err('<layer> declared with no id attribute.') 
    239             if not grid_type: self._err(''.join(['Layer ', str(id), \ 
     240            if not layer_id:  
     241                self._err('<layer> declared with no layer_id attribute.') 
     242            if not grid_type:  
     243                self._err(''.join(['Layer ', str(layer_id), \ 
    240244                                            ' has no grid_type attribute.'])) 
    241245 
    242             allow_diagonals = pathing == "cell_edges_and_diagonals" 
    243             cell_grid = self.model.getCellGrid(grid_type) 
    244             if not cell_grid: self._err('<layer> declared with invalid '\ 
     246            #allow_diagonals = pathing == "cell_edges_and_diagonals" 
     247            cell_grid = self.fife_model.getCellGrid(grid_type) 
     248            if not cell_grid:  
     249                self._err('<layer> declared with invalid '\ 
    245250                                       'cell grid type. (%s)' % grid_type) 
    246251 
     
    253258            layer_obj = None 
    254259            try: 
    255                 layer_obj = map.createLayer(str(id), cell_grid) 
    256             except fife.Exception, e: 
    257                 print e.getMessage() 
    258                 print 'The layer ' + str(id) + \ 
     260                layer_obj = game_map.createLayer(str(layer_id), cell_grid) 
     261            except fife.Exception, exception: 
     262                print exception.getMessage() 
     263                print 'The layer ' + str(layer_id) + \ 
    259264                        ' already exists! Ignoring this layer.' 
    260265                continue 
     
    273278                i += 1 
    274279                self.callback('loaded layer :' + \ 
    275                               str(id), float( i / float(len(tmp_list)) * \ 
     280                              str(layer_id), float( i / float(len(tmp_list)) * \ 
    276281                                              0.25 + 0.5 ) ) 
    277282 
     
    290295        for instance in instances: 
    291296 
    292             object_id = instance.get('object') 
     297            object_id = instance.get('map_object') 
    293298            if not object_id: 
    294299                object_id = instance.get('obj') 
     
    297302 
    298303            if not object_id: self._err('<instance> does not specify an '\ 
    299                                         'object attribute.') 
     304                                        'map_obj attribute.') 
    300305 
    301306            n_space = instance.get('namespace') 
     
    306311 
    307312            if not n_space: self._err('<instance> %s does not specify an '\ 
    308                                       'object namespace, and no default is '\ 
     313                                      'map_obj namespace, and no default is '\ 
    309314                                      'available.' % str(object_id)) 
    310315 
    311316            self.n_space = n_space 
    312317 
    313             object = self.model.getObject(str(object_id), str(n_space)) 
    314             if not object: 
    315                 print ''.join(['Object with id=', str(object_id), ' ns=', \ 
     318            map_obj = self.fife_model.getObject(str(object_id), str(n_space)) 
     319            if not map_obj: 
     320                print ''.join(['Object with inst_id=', str(object_id), ' ns=', \ 
    316321                               str(n_space), \ 
    317322                               ' could not be found. Omitting...']) 
     
    322327            z = instance.get('z') 
    323328            stack_pos = instance.get('stackpos') 
    324             id = instance.get('id') 
     329            inst_id = instance.get('id') 
    325330 
    326331            if x: 
     
    342347                z = 0.0 
    343348 
    344             if not id: 
    345                 id = '' 
    346             else: 
    347                 id = str(id)             
     349            if not inst_id: 
     350                inst_id = '' 
     351            else: 
     352                inst_id = str(inst_id)             
    348353             
    349             inst = layer.createInstance(object, \ 
     354            inst = layer.createInstance(map_obj, \ 
    350355                                        fife.ExactModelCoordinate(x,y,z), \ 
    351                                         str(id)) 
    352  
    353             if id: inst.setId(id) 
     356                                        str(inst_id)) 
     357 
     358            if inst_id: inst.setId(inst_id) 
    354359            rotation = instance.get('r') 
    355360            if not rotation: 
    356361                rotation = instance.get('rotation') 
    357362            if not rotation: 
    358                 angles = object.get2dGfxVisual().getStaticImageAngles() 
     363                angles = map_obj.get2dGfxVisual().getStaticImageAngles() 
    359364                if angles: 
    360365                    rotation = angles[0] 
     
    369374                inst.get2dGfxVisual().setStackPosition(int(stack_pos)) 
    370375 
    371             if (object.getAction('default')): 
     376            if (map_obj.getAction('default')): 
    372377                target = fife.Location(layer) 
    373378                inst.act('default', target, True) 
    374379                 
    375             #Check for PARPG specific object attributes 
     380            #Check for PARPG specific map_obj attributes 
    376381            object_type = instance.get('object_type') 
    377382            if object_type: 
    378383                inst_dict = {} 
    379384                inst_dict["type"] = object_type 
    380                 inst_dict["id"] = id 
     385                inst_dict["id"] = inst_id 
    381386                inst_dict["xpos"] = x 
    382387                inst_dict["ypos"] = y 
     
    397402                if inventory_el is not None: 
    398403                    inventory = Inventory() 
    399                     inv_objects = inventory_el.findall("object") 
     404                    inv_objects = inventory_el.findall("map_obj") 
    400405                    for inv_object in inv_objects: 
    401406                        attributes = inv_object.attrib.copy() 
    402                         self.data.createInventoryObject(inventory, attributes) 
     407                        self.model.createInventoryObject(inventory, attributes) 
    403408                    inst_dict["inventory"] = inventory 
    404                 self.data.createMapObject(layer, inst_dict, inst) 
    405                  
    406     def parseCameras(self, map_elt, map): 
     409                self.model.createMapObject(layer, inst_dict, inst) 
     410                 
     411    def parseCameras(self, map_elt, game_map): 
    407412        if self.callback:         
    408413            tmp_list = map_elt.findall('camera') 
     
    410415 
    411416        for camera in map_elt.findall('camera'): 
    412             id = camera.get('id') 
     417            cam_id = camera.get('id') 
    413418            zoom = camera.get('zoom') 
    414419            tilt = camera.get('tilt') 
     
    423428            if not rotation: rotation = 0 
    424429 
    425             if not id: self._err('Camera declared without an id.') 
    426             if not ref_layer_id: self._err(''.join(['Camera ', str(id), \ 
     430            if not cam_id: self._err('Camera declared without an cam_id.') 
     431            if not ref_layer_id: self._err(''.join(['Camera ', str(cam_id), \ 
    427432                                                    ' declared with no '\ 
    428433                                                    'reference layer.'])) 
    429434            if not (ref_cell_width and ref_cell_height): 
    430                 self._err(''.join(['Camera ', str(id), \ 
     435                self._err(''.join(['Camera ', str(cam_id), \ 
    431436                                   ' declared without reference cell '\ 
    432437                                   'dimensions.'])) 
     
    434439            try: 
    435440                if view_port: 
    436                     cam = map.addCamera(str(id), \ 
    437                                     map.getLayer(str(ref_layer_id)), \ 
     441                    cam = game_map.addCamera(str(cam_id), \ 
     442                                    game_map.getLayer(str(ref_layer_id)), \ 
    438443                                    fife.Rect(\ 
    439444                                    *[int(c) for c in view_port.split(',')])) 
    440445                else: 
    441446                    screen = self.engine.getRenderBackend() 
    442                     cam = map.addCamera(str(id), \ 
    443                                     map.getLayer(str(ref_layer_id)), \ 
     447                    cam = game_map.addCamera(str(cam_id), \ 
     448                                    game_map.getLayer(str(ref_layer_id)), \ 
    444449                                    fife.Rect(0, 0, screen.getScreenWidth(), \ 
    445450                                              screen.getScreenHeight()) ) 
     
    452457 
    453458                renderer = fife.InstanceRenderer.getInstance(cam) 
    454                 renderer.activateAllLayers(map)                      
     459                renderer.activateAllLayers(game_map)                      
    455460                 
    456461            except fife.Exception, e: 
     
    459464            if self.callback: 
    460465                i += 1 
    461                 self.callback('loaded camera: ' +  str(id), \ 
     466                self.callback('loaded camera: ' +  str(cam_id), \ 
    462467                              float( i / len(tmp_list) * 0.25 + 0.75 ) )     
  • trunk/game/pylintrc

    r541 r553  
    5454 
    5555# Disable the message(s) with the given id(s). 
    56 disable-msg=W0704,W0105,W0142,R0901,R0913,W0221,W0613,R0903,R0902 
     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__ 
     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 
  • trunk/game/run.py

    r544 r553  
    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 
     
    2627utils.addPaths ('../../engine/swigwrappers/python', '../../engine/extensions') 
    2728utils.addPaths ('./lib', './lib/extensions') 
    28  
    29 if not os.path.exists('settings.xml'): 
    30     shutil.copyfile('settings-dist.xml', 'settings.xml') 
    3129 
    3230#from settings import Setting 
     
    4745 
    4846if __name__ == '__main__': 
     47    if TDS.get("FIFE", "UsePsyco"): 
     48        # Import Psyco if available 
     49        try: 
     50            import psyco 
     51            psyco.full() 
     52            print "Psyco acceleration in use" 
     53        except ImportError: 
     54            print "Psyco acceleration not used" 
     55    else: 
     56        print "Psyco acceleration not used" 
    4957    main() 
    5058 
  • trunk/game/scripts/console.py

    r479 r553  
    2222        @type appListener: ApplicationListener 
    2323        @param appListener: ApplicationListener object providing a link with 
    24         the engine, the world and the model""" 
     24        the Controller, the view and the GameModel""" 
    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  
    48         self.engine = self.app_listener.model 
    49         self.game_state = self.app_listener.world.data.game_state 
     47        self.view = self.app_listener.view  
     48        self.model = self.app_listener.model 
     49        self.game_state = self.app_listener.view.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 
  • trunk/game/scripts/dialogue.py

    r520 r553  
    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'): 
  • trunk/game/scripts/gamestate.py

    r476 r553  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 from objects import base 
    1918from scripts import quest_engine 
    2019 
     
    2221    """This class holds the current state of the game.""" 
    2322    def __init__(self): 
    24         self.PC = None 
     23        self.PlayerCharacter = None 
    2524        self.quest_engine = quest_engine.QuestEngine() 
    2625        self.objects = {} 
  • trunk/game/scripts/gui/dialoguegui.py

    r532 r553  
    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             
  • trunk/game/scripts/gui/hud.py

    r541 r553  
    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 
     
    3027class Hud(object): 
    3128    """Main Hud class""" 
    32     def __init__(self, engine, settings, data, callbacks): 
     29    def __init__(self, engine, settings, model, callbacks): 
    3330        """Initialise the instance. 
    3431           @type engine: fife.Engine 
    3532           @param engine: An instance of the fife engine 
    3633           @type settings: settings.Setting 
    37            @param settings: The settings data 
     34           @param settings: The settings 
    3835           @type inv_model: dict 
    3936           @type callbacks: dict 
     
    4946        self.engine = engine 
    5047        self.settings = settings 
    51         self.data = data 
     48        self.model = model 
    5249        self.inventory = None 
    5350 
     
    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, 
    134138            'toggleInventoryButton': self.toggleInventoryButton, 
    135139        } 
    136         self.inventory_storage = self.data.game_state.PC.inventory 
     140        self.inventory_storage = self.model.game_state.PlayerCharacter.inventory 
    137141        if self.inventory == None: 
    138142            self.inventory = inventorygui.InventoryGUI(self.engine, 
     
    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 
    149153    def showContextMenu(self, data, pos): 
    150         """Display the Context Menu with data at pos 
    151            @type data: list 
    152            @param data: data to pass to context menu 
     154        """Display the Context Menu with model at pos 
     155           @type model: list 
     156           @param model: model to pass to context menu 
    153157           @type pos: tuple 
    154158           @param pos: tuple of x and y coordinates 
     
    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): 
     
    445420        dialogue = DialogueGUI( 
    446421                    npc, 
    447                     self.data.game_state.quest_engine, 
    448                     self.data.game_state.PC) 
     422                    self.model.game_state.quest_engine, 
     423                    self.model.game_state.PlayerCharacter) 
    449424        dialogue.initiateDialogue() 
  • trunk/game/scripts/gui/inventorygui.py

    r532 r553  
    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]): 
    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)) 
  • trunk/game/scripts/inventory.py

    r480 r553  
    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): 
  • trunk/game/scripts/map.py

    r541 r553  
    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 
     
    3331        self.map = None 
    3432        self.engine = engine 
    35         self.data = data 
     33        self.model = data 
    3634 
    3735        # init map attributes 
     
    4038        self.agent_layer = None 
    4139        self.top_layer = None 
    42         self.model = engine.getModel() 
     40        self.fife_model = engine.getModel() 
    4341        self.transitions = [] 
    4442        self.cur_cam2_x = 0 
     
    4947         
    5048    def reset(self): 
    51         """Reset the data to default settings. 
     49        """Reset the model to default settings. 
    5250           @return: None""" 
    5351        # We have to delete the map in Fife. 
     
    8078           @return: None""" 
    8179        self.reset() 
    82         self.map = loadMapFile(filename, self.engine, self.data) 
     80        self.map = loadMapFile(filename, self.engine, self.model) 
    8381        self.agent_layer = self.map.getLayer('ObjectLayer') 
    8482        self.top_layer = self.map.getLayer('TopLayer') 
    8583         
    86         #find out if a PC instance was created when the map was loaded 
     84        #find out if a PlayerCharacter 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": 
     
    9190                break 
    9291                 
    93         #If there is not a PC instance created yet than we construct the PC 
    94         #instance from what we have saved in the PC Game Object 
     92        #If there is not a PlayerCharacter instance created yet than we construct the PlayerCharacter 
     93        #instance from what we have saved in the PlayerCharacter Game Object 
    9594        if not found: 
    96             x = float(self.data.target_position[0]) 
    97             y = float(self.data.target_position[1]) 
     95            x = float(self.model.target_position[0]) 
     96            y = float(self.model.target_position[1]) 
    9897            z = 0 
    99             pc_obj = self.model.getObject("player", "PARPG") 
    100             inst = self.agent_layer.createInstance(pc_obj,\ 
    101                                             fife.ExactModelCoordinate(x,y,z),\ 
     98            pc_obj = self.fife_model.getObject("player", "PARPG") 
     99            inst = self.agent_layer.createInstance(pc_obj, \ 
     100                                            fife.ExactModelCoordinate( 
     101                                                                      x, 
     102                                                                      y, 
     103                                                                      z), 
    102104                                            "PC") 
    103105            fife.InstanceVisual.create(inst) 
    104         #If the PC instance exists already then make sure it's set to correct 
     106        #If the PlayerCharacter instance exists already then make sure it's set to correct 
    105107        #location for this new map 
    106         elif self.data.target_position is not None: 
    107             pos = self.data.target_position 
     108        elif self.model.target_position is not None: 
     109            pos = self.model.target_position 
    108110            coord = fife.DoublePoint3D(float(pos[0]), float(pos[1]), 0) 
    109111            location = fife.Location(self.agent_layer) 
    110112            location.setMapCoordinates(coord) 
    111113            inst.setLocation(location) 
    112         #else we are loading the first map and the PC position were set by 
     114        #else we are loading the first map and the PlayerCharacter position were set by 
    113115        #the coordinates in the Map file 
    114116             
     
    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. 
    154         self.data.view.active_map = self 
     161        self.model.active_map = self 
    155162 
    156163    def addPC(self): 
    157164        """Add the player character to the map 
    158165           @return: None""" 
    159         # Update gamestate.PC 
    160         self.data.game_state.PC.behaviour.onNewMap(self.agent_layer) 
     166        # Update gamestate.PlayerCharacter 
     167        self.model.game_state.PlayerCharacter.behaviour.onNewMap(self.agent_layer) 
    161168 
    162169        # actually this is real easy, we just have to 
    163         # attach the main camera to the PC, if a camera 
     170        # attach the main camera to the PlayerCharacter, if a camera 
    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.data.game_state.PC.behaviour.agent) 
     173            self.cameras[self.my_cam_id].attach(self.model.game_state. 
     174                                                PlayerCharacter.behaviour.agent) 
    167175 
    168176    def toggleRenderer(self, r_name): 
  • trunk/game/scripts/objects/action.py

    r477 r553  
    2424class ChangeMapAction(Action): 
    2525    """A change map scheduled""" 
    26     def __init__(self, engine, target_map_name, target_map_file , target_pos): 
     26    def __init__(self, model, view, target_map_name, target_map_file , target_pos): 
    2727        """Initiates a change of the position of the character 
    2828           possibly flagging a new map to be loaded. 
    29            @type engine: Engine reference 
    30            @param engine: A reference to the engine. 
     29           @type model: scripts.GameModel 
     30           @param model: A reference to the game model. 
     31           @type view: class derived from scripts.ViewBase 
     32           @param view: The view 
    3133           @type target_map_name: String 
    3234           @param target_map_name: Target map id  
     
    3638           @param target_pos: (X, Y) coordinates on the target map. 
    3739           @return: None""" 
    38         self.engine = engine 
     40        Action.__init__(self) 
     41        self.model = model 
     42        self.view = view 
    3943        self.target_pos = target_pos 
    4044        self.target_map_name = target_map_name 
     
    4347    def execute(self): 
    4448        """Executes the map change.""" 
    45         self.engine.changeMap(self.target_map_name, self.target_map_file,\ 
     49        self.model.changeMap(self.target_map_name, self.target_map_file,\ 
    4650                              self.target_pos) 
    4751        
    4852class OpenBoxAction(Action): 
    4953    """Open a box. Needs to be more generic, but will do for now.""" 
    50     def __init__(self, engine, container): 
    51         """@type engine: Engine reference 
    52            @param engine: A reference to the engine. 
     54    def __init__(self, model, view, container): 
     55        """@type model: Engine reference 
     56           @param model: A reference to the model. 
     57           @type view: class derived from scripts.ViewBase 
     58           @param view: The view 
    5359           @param container: A reference to the container""" 
    54         self.engine = engine 
     60        Action.__init__(self) 
     61        self.model = model 
     62        self.view = view 
    5563        self.container = container 
    5664         
     
    5967        try: 
    6068            self.container.open() 
    61             self.engine.view.hud.createBoxGUI(self.container.name, \ 
     69            self.view.hud.createBoxGUI(self.container.name, \ 
    6270                                              self.container) 
    6371 
    6472        except ValueError: 
    65             self.engine.view.hud.createExamineBox(self.container.name, \ 
     73            self.view.hud.createExamineBox(self.container.name, \ 
    6674                                                  "The container is locked") 
    6775         
     
    7078    def __init__(self,  container): 
    7179        """@param container: A reference to the container""" 
     80        Action.__init__(self) 
    7281        self.container = container 
    7382     
     
    8089    def __init__(self, container): 
    8190        """@param container: A reference to the container""" 
     91        Action.__init__(self) 
    8292        self.container = container 
    8393         
     
    8999class ExamineBoxAction(Action): 
    90100    """Examine a box. Needs to be more generic, but will do for now.""" 
    91     def __init__(self, engine, examine_name, examine_desc): 
    92         """@type engine: Engine reference 
    93            @param engine: A reference to the engine. 
     101    def __init__(self, model, view, examine_name, examine_desc): 
     102        """@type model: Engine reference 
     103           @param model: A reference to the model. 
     104           @type view: class derived from scripts.ViewBase 
     105           @param view: The view 
    94106           @type examine_name: String 
    95107           @param examine_name: Name of the object to be examined. 
    96108           @type examine_name: String 
    97109           @param examine_name: Description of the object to be examined.""" 
    98         self.engine = engine 
     110        Action.__init__(self) 
     111        self.model = model 
     112        self.view = view 
    99113        self.examine_name = examine_name 
    100114        self.examine_desc = examine_desc 
     
    102116    def execute(self): 
    103117        """Examine the box.""" 
    104         self.engine.view.hud.createExamineBox(self.examine_name, \ 
     118        self.view.hud.createExamineBox(self.examine_name, \ 
    105119                                              self.examine_desc) 
    106120 
    107121class TalkAction(Action): 
    108122    """An action to represent starting a dialogue""" 
    109     def __init__(self, engine, npc): 
    110         """@type engine: Engine reference 
    111            @param engine: A reference to the engine. 
     123    def __init__(self, model, view, npc): 
     124        """@type model: Engine reference 
     125           @param model: A reference to the model. 
     126           @type view: class derived from scripts.ViewBase 
     127           @param view: The view 
    112128           @type npc: NonPlayerCharacter 
    113129           @param npc: NPC to interact with.""" 
    114         self.engine = engine 
     130        Action.__init__(self) 
     131        self.model = model 
     132        self.view = view 
    115133        self.npc = npc 
    116134         
     
    119137           @return: None""" 
    120138       
    121         pc = self.engine.game_state.PC 
     139        pc = self.model.game_state.PlayerCharacter 
    122140        npc_coordinates = self.npc.getLocation().getLayerCoordinates() 
    123141        pc_coordinates = pc.behaviour.agent.getLocation().getLayerCoordinates() 
     
    134152                         self.npc.getLocation().\ 
    135153                         getLayerCoordinates().y], \ 
    136                         TalkAction(self.engine,\ 
     154                        TalkAction(self.model,\ 
    137155                                   self.npc))         
    138156        else: 
     
    141159            if self.npc.dialogue is not None: 
    142160                self.npc.talk(pc) 
    143                 self.engine.view.hud.showDialogue(self.npc) 
     161                self.view.hud.showDialogue(self.npc) 
    144162            else: 
    145163                self.npc.behaviour.agent.say("Leave me alone!", 1000) 
    146164                 
    147             self.engine.game_state.PC.behaviour.idle() 
    148             self.engine.game_state.PC.nextAction = None 
     165            self.model.game_state.PlayerCharacter.behaviour.idle() 
     166            self.model.game_state.PlayerCharacter.nextAction = None 
  • trunk/game/scripts/objects/actors.py

    r542 r553  
    1717 
    1818from fife import fife 
    19 from scripts import world 
    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 
  • trunk/game/scripts/objects/base.py

    r542 r553  
    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 : 
  • trunk/game/scripts/objects/composed.py

    r477 r553  
    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): 
  • trunk/game/scripts/parpg.py

    r544 r553  
    1515 
    1616from fife import fife 
    17 from fife.extensions import fife_compat, fifelog, pychan 
     17from fife.extensions import pychan 
    1818from fife.extensions.basicapplication import ApplicationBase 
     19from scripts import gamemodel 
    1920 
    20 from scripts import world 
    21 from scripts import engine 
     21from scripts import gamesceneview 
    2222from scripts import console 
    23 from scripts.engine import Engine 
     23from scripts import gamescenecontroller 
    2424from scripts.common import eventlistenerbase 
    2525 
     26class KeyFilter(fife.IKeyFilter): 
     27    """ 
     28    This is the implementation of the fife.IKeyFilter class. 
     29     
     30    Prevents any filtered keys from being consumed by guichan. 
     31    """ 
     32    def __init__(self, keys): 
     33        fife.IKeyFilter.__init__(self) 
     34        self._keys = keys 
     35 
     36    def isFiltered(self, event): 
     37        return event.getKey().getValue() in self._keys 
    2638 
    2739class ApplicationListener(eventlistenerbase.EventListenerBase): 
    2840    def __init__(self, engine, world, model): 
    2941        """Initialise the instance. 
    30            @type engine: fife.Engine 
     42           @type engine: fife.GameModel 
    3143           @param engine: ??? 
    32            @type world: world.World 
    33            @param world: ??? 
    34            @type model: engine.Engine 
    35            @param model: an instance of PARPG's engine""" 
     44           @type gamesceneview: gamesceneview.GameSceneView 
     45           @param gamesceneview: ??? 
     46           @type model: script.GameModel 
     47           @param model: The game model""" 
    3648        super(ApplicationListener, self).__init__(engine, 
    3749                                                  reg_keys=True,reg_cmd=True, 
     
    4052                                                  reg_widget=True) 
    4153        self.engine = engine 
    42         self.world = world 
     54        self.view = world 
    4355        self.model = model 
    44         engine.getEventManager().setNonConsumableKeys([fife.Key.ESCAPE,]) 
     56        keyfilter = KeyFilter([fife.Key.ESCAPE]) 
     57        keyfilter.__disown__()         
     58         
     59        engine.getEventManager().setKeyFilter(keyfilter) 
    4560        self.quit = False 
    4661        self.aboutWindow = None 
     
    7388class PARPGApplication(ApplicationBase): 
    7489    """Main Application class 
    75        We use an MVC data model. 
    76        self.world is our view,self.engine is our model 
    77        This file is the minimal controller""" 
     90       We use an MVC model model 
     91       self.gamesceneview is our view,self.model is our model 
     92       self.controller is the controller""" 
    7893    def __init__(self, setting): 
    7994        """Initialise the instance. 
    8095           @return: None""" 
    8196        super(PARPGApplication, self).__init__(setting) 
    82         self.world = world.World(self.engine) 
    83         self.model = engine.Engine(self.world) 
     97        #self.engine.getModel(self) 
     98        self.model = gamemodel.GameModel(self.engine) 
     99        self.view = gamesceneview.GameSceneView(self.engine, self.model) 
     100        self.controller = gamescenecontroller.GameSceneController(self.engine,  
     101                                                        self.view,  
     102                                                        self.model,  
     103                                                        self, 
     104                                                        setting) 
    84105        self.model.readObjectDB(self._setting.get("PARPG",  
    85106                                                  "ObjectDatabaseFile")) 
    86         self.world.data = self.model 
    87         self.world.initHud() 
    88         self.listener = ApplicationListener(self.engine, self.world, self.model) 
    89         self.world.quitFunction = self.listener.quitGame 
     107        self.controller.initHud() 
     108        self.listener = ApplicationListener(self.engine,  
     109                                            self.view,  
     110                                            self.model) 
    90111        self.model.loadMap("main-map", str(self._setting.get("PARPG",  
    91112                                                             "MapFile"))) 
     
    100121    def _pump(self): 
    101122        """Main game loop. 
    102            There are in fact 2 main loops, this one and the one in World. 
     123           There are in fact 2 main loops, this one and the one in GameSceneView. 
    103124           @return: None""" 
    104125        if self.listener.quit: 
    105126            self.breakRequested = True 
    106127        else: 
    107             self.model.pump() 
    108             self.world.pump() 
     128            self.controller.pump() 
  • trunk/game/utilities/gfxsplit.py

    r328 r553  
    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.