Changeset 549


Ignore:
Timestamp:
06/18/10 11:51:56 (9 years ago)
Author:
beliar
Message:

Cleanup and refactoring continues

Location:
branches/code-cleanup-and-refactoring/game
Files:
1 added
7 edited
1 moved

Legend:

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

    r548 r549  
    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 
     25    import xml.etree.cElementTree as ET  
    2626except: 
    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    directory_delimiter = '/' 
    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(directory_delimiter) 
     49    sub_fragments = subfile.split(directory_delimiter) 
    5050 
    5151    master_leftovers = [] 
     
    6262    pathstr = '' 
    6363    for f in master_leftovers[:-1]: 
    64         pathstr += '..' + s 
    65     pathstr += s.join(sub_leftovers) 
     64        pathstr += '..' + directory_delimiter 
     65    pathstr += directory_delimiter.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 = Engine object for PARPG 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() 
     
    149149        map = None 
    150150        try: 
    151             self.map = self.model.createMap(str(id)) 
     151            self.map = self.fife_model.createMap(str(id)) 
    152152            self.map.setResourceFile(self.source) 
    153153        # NameClash appears as general fife.Exception; any ideas? 
     
    236236                transparency = int(transparency) 
    237237 
    238             if not id: self._err('<layer> declared with no id attribute.') 
    239             if not grid_type: self._err(''.join(['Layer ', str(id), \ 
     238            if not id:  
     239                self._err('<layer> declared with no id attribute.') 
     240            if not grid_type:  
     241                self._err(''.join(['Layer ', str(id), \ 
    240242                                            ' has no grid_type attribute.'])) 
    241243 
    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 '\ 
     244            #allow_diagonals = pathing == "cell_edges_and_diagonals" 
     245            cell_grid = self.fife_model.getCellGrid(grid_type) 
     246            if not cell_grid:  
     247                self._err('<layer> declared with invalid '\ 
    245248                                       'cell grid type. (%s)' % grid_type) 
    246249 
     
    254257            try: 
    255258                layer_obj = map.createLayer(str(id), cell_grid) 
    256             except fife.Exception, e: 
    257                 print e.getMessage() 
     259            except fife.Exception, exception: 
     260                print exception.getMessage() 
    258261                print 'The layer ' + str(id) + \ 
    259262                        ' already exists! Ignoring this layer.' 
     
    311314            self.n_space = n_space 
    312315 
    313             object = self.model.getObject(str(object_id), str(n_space)) 
     316            object = self.fife_model.getObject(str(object_id), str(n_space)) 
    314317            if not object: 
    315318                print ''.join(['Object with id=', str(object_id), ' ns=', \ 
     
    400403                    for inv_object in inv_objects: 
    401404                        attributes = inv_object.attrib.copy() 
    402                         self.data.createInventoryObject(inventory, attributes) 
     405                        self.model.createInventoryObject(inventory, attributes) 
    403406                    inst_dict["inventory"] = inventory 
    404                 self.data.createMapObject(layer, inst_dict, inst) 
     407                self.model.createMapObject(layer, inst_dict, inst) 
    405408                 
    406409    def parseCameras(self, map_elt, map): 
  • branches/code-cleanup-and-refactoring/game/pylintrc

    r541 r549  
    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 
    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,X,Y,__repr__,i 
    143143 
    144144# Bad variable names which should always be refused, separated by a comma 
  • branches/code-cleanup-and-refactoring/game/scripts/console.py

    r548 r549  
    2222        @type appListener: ApplicationListener 
    2323        @param appListener: ApplicationListener object providing a link with 
    24         the engine, the world and the model""" 
     24        the engine, the world and the fife_model""" 
    2525        exit_help   = "Terminate application" 
    2626        grid_help   = "Toggle grid display" 
     
    4646        self.app_listener = app_listener 
    4747        self.world = self.app_listener.world  
    48         self.engine = self.app_listener.model 
    49         self.game_state = self.app_listener.world.data.game_state 
     48        self.engine = self.app_listener.fife_model 
     49        self.game_state = self.app_listener.world.fife_model.game_state 
    5050 
    5151    def handleQuit(self, command): 
     
    7878           @param command: The command to run. 
    7979           @return: The response""" 
    80         if self.app_listener.model.pc_run == 1: 
    81             self.app_listener.model.pc_run = 0 
     80        if self.app_listener.fife_model.pc_run == 1: 
     81            self.app_listener.fife_model.pc_run = 0 
    8282            return "PC is now walking" 
    8383        else: 
    84             self.app_listener.model.pc_run = 1 
     84            self.app_listener.fife_model.pc_run = 1 
    8585            return "PC is now running" 
    8686             
     
    124124                l_args = command.lower()[end_load + 1:].strip() 
    125125                l_path, l_filename = l_args.split(' ') 
    126                 self.app_listener.model.load_save = True 
    127                 self.app_listener.model.savegame = os.path.join(l_path, l_filename) 
     126                self.app_listener.fife_model.load_save = True 
     127                self.app_listener.fife_model.savegame = os.path.join(l_path, l_filename) 
    128128                result = "Load triggered" 
    129129 
     
    146146                s_args = command.lower()[end_save+1:].strip() 
    147147                s_path, s_filename = s_args.split(' ') 
    148                 self.app_listener.model.save(s_path, s_filename) 
     148                self.app_listener.fife_model.save(s_path, s_filename) 
    149149                result = "Saved to file: " + s_path + s_filename 
    150150 
  • branches/code-cleanup-and-refactoring/game/scripts/gameview.py

    r546 r549  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import time 
    19 import fife 
    2018import random 
    2119import glob 
    2220import os  
    23 from fife.extensions import pychan 
    2421from sounds import SoundEngine 
    25 from datetime import date 
    2622from scripts.common.eventlistenerbase import EventListenerBase 
    27 from local_loaders.loaders import loadMapFile 
    28 from sounds import SoundEngine 
    2923from fife.extensions.fife_settings import Setting 
    3024from scripts.gui import hud 
    31 from scripts.gui.popups import * 
    32 from fife.extensions.pychan.tools import callbackWithArguments as cbwa 
    3325from map import Map 
     26from fife import fife 
    3427 
    3528TDS = Setting(app_name="PARPG", 
     
    3831 
    3932# this file should be the meta-file for all FIFE-related code 
    40 # engine.py handles is our data model, whilst this is our view 
    41 # in order to not replicate data, some of our data model will naturally 
     33# engine.py handles is our fife_model fife_model, whilst this is our view 
     34# in order to not replicate fife_model, some of our fife_model fife_model will naturally 
    4235# reside on this side of the fence (PC xpos and ypos, for example). 
    43 # we should aim to never replicate any data as this leads to maintenance 
     36# we should aim to never replicate any fife_model as this leads to maintenance 
    4437# issues (and just looks plain bad). 
    4538# however, any logic needed to resolve this should sit in engine.py 
    4639 
    47 class World(EventListenerBase): 
    48     """World holds the data needed by fife to render the engine 
     40class GameView(object): 
     41    """GameView holds the fife_model needed by fife to render the engine 
    4942       The engine keeps a copy of this class""" 
    5043    def __init__(self, engine): 
     
    5346           @param engine: A fife.Engine instance 
    5447           @return: None""" 
    55         super(World, self).__init__(engine, reg_mouse=True, reg_keys=True) 
    5648        # self.engine is a fife.Engine object, not an Engine object 
    5749        self.engine = engine 
    58         self.event_manager = engine.getEventManager() 
    59         self.quitFunction = None 
    60  
    61         # self.data is an engine.Engine object, but is set in run.py 
    62         self.data = None 
    63         self.mouseCallback = None 
     50 
     51        # self.fife_model is an gamemodel.GameModel object, but is set in run.py 
     52        self.fife_model = None 
    6453 
    6554        # self.map is a Map object, set to none here 
     
    7261        self.sounds = SoundEngine(engine) 
    7362 
     63        self.hud = None 
     64         
    7465        # don't force restart if skipping to new section 
    7566        if TDS.get("FIFE",  "PlaySounds"): 
    7667            if not self.sounds.music_init: 
    77                 self.sounds.playMusic(random.choice(glob.glob(os.path.join("music", "*.ogg"))))  
     68                music_file = random.choice(glob.glob(os.path.join( 
     69                                                                  "music",  
     70                                                                  "*.ogg"))) 
     71                self.sounds.playMusic(music_file)  
    7872 
    7973        # The current highlighted object 
    8074        self.highlight_obj = None 
    81          
    82         # Last saved mouse coords 
    83         self.last_mousecoords = None 
    84  
     75      
    8576        # faded objects in top layer 
    8677        self.faded_objects = set() 
     
    9485            'quitGame': self.quitGame, 
    9586        } 
    96         self.hud = hud.Hud(self.engine, TDS, self.data, hud_callbacks) 
    97      
     87        self.hud = hud.Hud(self.engine, TDS, self.fife_model, hud_callbacks)    
     88 
    9889    def quitGame(self): 
    9990        """Quits the game 
    10091           @return: None""" 
    101         self.quitFunction() 
     92        self.quit_function() 
    10293 
    10394    def saveGame(self, *args, **kwargs): 
    10495        """Saves the game state, delegates call to engine.Engine 
    10596           @return: None""" 
    106         self.data.save(*args, **kwargs) 
     97        self.fife_model.save(*args, **kwargs) 
    10798 
    10899    def loadGame(self, *args, **kwargs): 
    109100        """Loads the game state, delegates call to engine.Engine 
    110101           @return: None""" 
    111         self.data.load(*args, **kwargs) 
     102        self.fife_model.load(*args, **kwargs) 
    112103 
    113104    def loadMap(self, map_name, filename): 
     
    119110           @return: None""" 
    120111        if not map_name in self.maps: 
    121             map = Map(self.engine, self.data) 
    122             self.maps[map_name] = map 
    123             map.load(filename) 
     112            new_map = Map(self.engine, self.fife_model) 
     113            self.maps[map_name] = new_map 
     114            new_map.load(filename) 
    124115        else: 
    125116            self.setActiveMap(map_name) 
     
    146137        obj.say(str(text), 1000) 
    147138 
    148     def keyPressed(self, evt): 
    149         """Whenever a key is pressed, fife calls this routine. 
    150            @type evt: fife.event 
    151            @param evt: The event that fife caught 
    152            @return: None""" 
    153         key = evt.getKey() 
    154         key_val = key.getValue() 
    155  
    156         if(key_val == key.Q): 
    157             # we need to quit the game 
    158             self.hud.quitGame() 
    159         if(key_val == key.T): 
    160             self.active_map.toggleRenderer('GridRenderer') 
    161         if(key_val == key.F1): 
    162             # display the help screen and pause the game 
    163             self.hud.displayHelp() 
    164         if(key_val == key.F5): 
    165             self.active_map.toggleRenderer('CoordinateRenderer') 
    166         if(key_val == key.F7): 
    167             # F7 saves a screenshot to fife/clients/parpg/screenshots 
    168             t = "screenshots/screen-%s-%s.png" % \ 
    169                     (date.today().strftime('%Y-%m-%d'),\ 
    170                     time.strftime('%H-%M-%S')) 
    171             print "PARPG: Saved:",t 
    172             self.engine.getRenderBackend().captureScreen(t) 
    173         if(key_val == key.F10): 
    174             # F10 shows/hides the console 
    175             self.engine.getGuiManager().getConsole().toggleShowHide() 
    176         if(key_val == key.I): 
    177             # I opens and closes the inventory 
    178             self.hud.toggleInventory() 
    179         if(key_val == key.A): 
    180             # A adds a test action to the action box 
    181             # The test actions will follow this format: Action 1, 
    182             # Action 2, etc. 
    183             self.hud.addAction("Action " + str(self.action_number)) 
    184             self.action_number += 1 
    185         if(key_val == key.ESCAPE): 
    186             # Escape brings up the main menu 
    187             self.hud.displayMenu() 
    188             # Hide the quit menu 
    189             self.hud.quit_window.hide() 
    190         if(key_val == key.M): 
    191             self.sounds.toggleMusic() 
    192         if(key_val == key.PAUSE): 
    193             # Pause pause/unpause the game  
    194             self.togglePause() 
    195  
    196     def mouseReleased(self, evt): 
    197         """If a mouse button is released, fife calls this routine. 
    198            We want to wait until the button is released, because otherwise 
    199            pychan captures the release if a menu is opened. 
    200            @type evt: fife.event 
    201            @param evt: The event that fife caught 
    202            @return: None""" 
    203         self.hud.hideContextMenu() 
    204         scr_point = fife.ScreenPoint(evt.getX(), evt.getY()) 
    205         if(evt.getButton() == fife.MouseEvent.LEFT): 
    206             self.data.handleMouseClick(self.getCoords(scr_point)) 
    207         elif(evt.getButton() == fife.MouseEvent.RIGHT): 
    208             # is there an object here? 
    209             instances = self.active_map.cameras[self.active_map.my_cam_id].\ 
    210                             getMatchingInstances(scr_point, \ 
    211                                                  self.active_map.agent_layer) 
    212             info = None 
    213             for inst in instances: 
    214                 # check to see if this is an active item 
    215                 if(self.data.objectActive(inst.getId())): 
    216                     # yes, get the data 
    217                     info = self.data.getItemActions(inst.getId()) 
    218                     break 
    219  
    220             # take the menu items returned by the engine or show a 
    221             # default menu if no items 
    222             data = info or \ 
    223                 [["Walk", "Walk here", self.onWalk, self.getCoords(scr_point)]] 
    224             # show the menu 
    225             self.hud.showContextMenu(data, (scr_point.x, scr_point.y)) 
    226  
    227139    def onWalk(self, click): 
    228140        """Callback sample for the context menu.""" 
    229141        self.hud.hideContainer() 
    230         self.data.game_state.PC.run(click) 
    231  
    232     def refreshTopLayerInstanceTransparencies(self): 
     142        self.fife_model.game_state.PC.run(click) 
     143 
     144    def refreshTopLayerTransparencies(self): 
    233145        """Fade or unfade TopLayer instances if the PC is under them.""" 
    234146        # get the PC's screen coordinates 
    235147        camera = self.active_map.cameras[self.active_map.my_cam_id] 
    236         point = self.data.game_state.PC.behaviour.agent.getLocation() 
     148        point = self.fife_model.game_state.PC.behaviour.agent.getLocation() 
    237149        scr_coords = camera.toScreenCoordinates(point.getMapCoordinates()) 
    238150 
     
    247159            if instance_id not in faded_objects: 
    248160                faded_objects.add(instance_id) 
    249                 instance.get2dGfxVisual().setTransparency(128) 
     161                self.active_map.top_layer.getInstance(instance_id).\ 
     162                        get2dGfxVisual().setTransparency(128) 
    250163 
    251164        # unfade previously faded instances 
     
    267180        location = fife.Location(self.active_map.agent_layer) 
    268181        location.setMapCoordinates(coord) 
    269         self.data.game_state.PC.teleport(location) 
    270  
    271     def mouseMoved(self, evt): 
    272         """Called when the mouse is moved 
    273            @type evt: fife.event 
    274            @param evt: The event that fife caught 
    275            @return: None""" 
    276         self.last_mousecoords = fife.ScreenPoint(evt.getX(), evt.getY()) 
    277         self.highlightFrontObject() 
    278  
    279     def highlightFrontObject(self): 
    280         """Highlights the object that is at the current mouse coordinates""" 
    281         if self.last_mousecoords: 
    282             front_obj = self.getObjectAtCoords(self.last_mousecoords) 
    283             if front_obj != None: 
    284                 if self.highlight_obj == None or front_obj.getId() != self.highlight_obj.getId(): 
    285                     if self.highlight_obj: 
    286                         self.displayObjectText(self.highlight_obj,"") 
    287                     self.active_map.outline_render.removeAllOutlines() 
    288                     self.highlight_obj = front_obj 
    289                     self.active_map.outline_render.addOutlined(self.highlight_obj, 0, \ 
    290                                                                137, 255, 2) 
    291                     # get the text 
    292                     item = self.data.objectActive(self.highlight_obj.getId()) 
    293                     if item is not None: 
    294                         self.displayObjectText(self.highlight_obj, item.name) 
    295             else: 
    296                 if self.highlight_obj: 
    297                     self.displayObjectText(self.highlight_obj,"") 
    298                 self.active_map.outline_render.removeAllOutlines() 
    299                 self.highlight_obj = None 
     182        self.fife_model.game_state.PC.teleport(location) 
    300183                 
    301184    def getObjectAtCoords(self, coords): 
     
    305188            @rtype: fife.Object 
    306189            @return: An object or None""" 
    307         i=self.active_map.cameras[self.active_map.my_cam_id].\ 
     190        instances = self.active_map.cameras[self.active_map.my_cam_id].\ 
    308191            getMatchingInstances(coords, self.active_map.agent_layer) 
    309192        # no object returns an empty tuple 
    310         if(i != ()): 
     193        if(instances != ()): 
    311194            front_y = 0 
    312195             
    313196 
    314             for obj in i: 
     197            for obj in instances: 
    315198                # check to see if this in our list at all 
    316                 if(self.data.objectActive(obj.getId())): 
     199                if(self.fife_model.objectActive(obj.getId())): 
    317200                    # check if the object is on the foreground 
    318201                    obj_map_coords = \ 
     
    357240        self.maps = {} 
    358241 
    359     def pump(self): 
    360         """Routine called during each frame. Our main loop is in ./run.py""" 
    361         # uncomment to instrument 
    362         # t0 = time.time() 
    363         self.highlightFrontObject() 
    364         self.refreshTopLayerInstanceTransparencies() 
    365         # print "%05f" % (time.time()-t0,) 
     242    def highlightFrontObject(self, mouse_coords): 
     243        """Highlights the object that is at the current mouse coordinates""" 
     244        if mouse_coords: 
     245            front_obj = self.getObjectAtCoords(mouse_coords) 
     246            if front_obj != None: 
     247                if self.highlight_obj == None \ 
     248                            or front_obj.getId() != \ 
     249                            self.highlight_obj.getId(): 
     250                    if self.highlight_obj: 
     251                        self.displayObjectText(self.highlight_obj,"") 
     252                    self.active_map.outline_render.removeAllOutlines() 
     253                    self.highlight_obj = front_obj 
     254                    self.active_map.outline_render.addOutlined( 
     255                                                    self.highlight_obj,  
     256                                                    0, 
     257                                                    137, 255, 2) 
     258                    # get the text 
     259                    item = self.fife_model.objectActive( 
     260                                                    self.highlight_obj.getId()) 
     261                    if item is not None: 
     262                        self.displayObjectText(self.highlight_obj,  
     263                                                    item.name) 
     264            else: 
     265                if self.highlight_obj: 
     266                    self.displayObjectText(self.highlight_obj,"") 
     267                self.active_map.outline_render.removeAllOutlines() 
     268                self.highlight_obj = None       
  • branches/code-cleanup-and-refactoring/game/scripts/gui/hud.py

    r541 r549  
    3535           @param engine: An instance of the fife engine 
    3636           @type settings: settings.Setting 
    37            @param settings: The settings data 
     37           @param settings: The settings fife_model 
    3838           @type inv_model: dict 
    3939           @type callbacks: dict 
     
    4949        self.engine = engine 
    5050        self.settings = settings 
    51         self.data = data 
     51        self.fife_model = data 
    5252        self.inventory = None 
    5353 
     
    134134            'toggleInventoryButton': self.toggleInventoryButton, 
    135135        } 
    136         self.inventory_storage = self.data.game_state.PC.inventory 
     136        self.inventory_storage = self.fife_model.game_state.PC.inventory 
    137137        if self.inventory == None: 
    138138            self.inventory = inventorygui.InventoryGUI(self.engine, 
     
    148148 
    149149    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 
     150        """Display the Context Menu with fife_model at pos 
     151           @type fife_model: list 
     152           @param fife_model: fife_model to pass to context menu 
    153153           @type pos: tuple 
    154154           @param pos: tuple of x and y coordinates 
     
    445445        dialogue = DialogueGUI( 
    446446                    npc, 
    447                     self.data.game_state.quest_engine, 
    448                     self.data.game_state.PC) 
     447                    self.fife_model.game_state.quest_engine, 
     448                    self.fife_model.game_state.PC) 
    449449        dialogue.initiateDialogue() 
  • branches/code-cleanup-and-refactoring/game/scripts/map.py

    r548 r549  
    3333        self.map = None 
    3434        self.engine = engine 
    35         self.data = data 
     35        self.model = data 
    3636 
    3737        # init map attributes 
     
    4040        self.agent_layer = None 
    4141        self.top_layer = None 
    42         self.model = engine.getModel() 
     42        self.fife_model = engine.getModel() 
    4343        self.transitions = [] 
    4444        self.cur_cam2_x = 0 
     
    4949         
    5050    def reset(self): 
    51         """Reset the data to default settings. 
     51        """Reset the model to default settings. 
    5252           @return: None""" 
    5353        # We have to delete the map in Fife. 
     
    8080           @return: None""" 
    8181        self.reset() 
    82         self.map = loadMapFile(filename, self.engine, self.data) 
     82        self.map = loadMapFile(filename, self.engine, self.model) 
    8383        self.agent_layer = self.map.getLayer('ObjectLayer') 
    8484        self.top_layer = self.map.getLayer('TopLayer') 
     
    9494        #instance from what we have saved in the PC Game Object 
    9595        if not found: 
    96             x = float(self.data.target_position[0]) 
    97             y = float(self.data.target_position[1]) 
     96            x = float(self.model.target_position[0]) 
     97            y = float(self.model.target_position[1]) 
    9898            z = 0 
    99             pc_obj = self.model.getObject("player", "PARPG") 
     99            pc_obj = self.fife_model.getObject("player", "PARPG") 
    100100            inst = self.agent_layer.createInstance(pc_obj,\ 
    101101                                            fife.ExactModelCoordinate(x,y,z),\ 
     
    104104        #If the PC instance exists already then make sure it's set to correct 
    105105        #location for this new map 
    106         elif self.data.target_position is not None: 
    107             pos = self.data.target_position 
     106        elif self.model.target_position is not None: 
     107            pos = self.model.target_position 
    108108            coord = fife.DoublePoint3D(float(pos[0]), float(pos[1]), 0) 
    109109            location = fife.Location(self.agent_layer) 
     
    152152          
    153153        # Make World aware that this is now the active map. 
    154         self.data.view.active_map = self 
     154        self.model.view.active_map = self 
    155155 
    156156    def addPC(self): 
     
    158158           @return: None""" 
    159159        # Update gamestate.PC 
    160         self.data.game_state.PC.behaviour.onNewMap(self.agent_layer) 
     160        self.model.game_state.PC.behaviour.onNewMap(self.agent_layer) 
    161161 
    162162        # actually this is real easy, we just have to 
     
    164164        # was already used, we simply recycle it.  
    165165        if self.cameras[self.my_cam_id].getAttached() == None: 
    166             self.cameras[self.my_cam_id].attach(self.data.game_state.PC.behaviour.agent) 
     166            self.cameras[self.my_cam_id].attach(self.model.game_state.PC.behaviour.agent) 
    167167 
    168168    def toggleRenderer(self, r_name): 
  • branches/code-cleanup-and-refactoring/game/scripts/objects/actors.py

    r542 r549  
    1717 
    1818from fife import fife 
    19 from scripts import world 
     19from scripts import gameview 
    2020from base import * 
    2121from composed import * 
  • branches/code-cleanup-and-refactoring/game/scripts/parpg.py

    r548 r549  
    1919from scripts import gamemodel 
    2020 
    21 from scripts import world 
     21from scripts import gameview 
    2222from scripts import console 
     23from scripts import gamecontroller 
    2324from scripts.common import eventlistenerbase 
    2425 
     
    4142           @type engine: fife.GameModel 
    4243           @param engine: ??? 
    43            @type world: world.World 
    44            @param world: ??? 
    45            @type model: engine.GameModel 
    46            @param model: an instance of PARPG's engine""" 
     44           @type gameview: gameview.GameView 
     45           @param gameview: ??? 
     46           @type fife_model: engine.GameModel 
     47           @param fife_model: an instance of PARPG's engine""" 
    4748        super(ApplicationListener, self).__init__(engine, 
    4849                                                  reg_keys=True,reg_cmd=True, 
     
    5253        self.engine = engine 
    5354        self.world = world 
    54         self.model = model 
     55        self.fife_model = model 
    5556        keyfilter = KeyFilter([fife.Key.ESCAPE]) 
    5657        keyfilter.__disown__()         
     
    8788class PARPGApplication(ApplicationBase): 
    8889    """Main Application class 
    89        We use an MVC data model. 
    90        self.world is our view,self.model is our model 
     90       We use an MVC fife_model fife_model. 
     91       self.gameview is our view,self.fife_model is our fife_model 
    9192       This file is the minimal controller""" 
    9293    def __init__(self, setting): 
     
    9495           @return: None""" 
    9596        super(PARPGApplication, self).__init__(setting) 
    96         self.world = world.World(self.engine) 
    97         self.model = gamemodel.GameModel(self.world) 
    98         self.model.readObjectDB(self._setting.get("PARPG",  
     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) 
     102        self.fife_model.readObjectDB(self._setting.get("PARPG",  
    99103                                                  "ObjectDatabaseFile")) 
    100         self.world.data = self.model 
     104        self.world.fife_model = self.fife_model 
    101105        self.world.initHud() 
    102         self.listener = ApplicationListener(self.engine, self.world, self.model) 
     106        self.listener = ApplicationListener(self.engine, self.world, self.fife_model) 
    103107        self.world.quitFunction = self.listener.quitGame 
    104         self.model.loadMap("main-map", str(self._setting.get("PARPG",  
     108        self.fife_model.loadMap("main-map", str(self._setting.get("PARPG",  
    105109                                                             "MapFile"))) 
    106110        pychan.init(self.engine, debug = True) 
     
    114118    def _pump(self): 
    115119        """Main game loop. 
    116            There are in fact 2 main loops, this one and the one in World. 
     120           There are in fact 2 main loops, this one and the one in GameView. 
    117121           @return: None""" 
    118122        if self.listener.quit: 
    119123            self.breakRequested = True 
    120124        else: 
    121             self.model.pump() 
    122             self.world.pump() 
     125            self.fife_model.pump() 
     126            self.controller.pump() 
Note: See TracChangeset for help on using the changeset viewer.