Changeset 552


Ignore:
Timestamp:
06/19/10 22:35:21 (9 years ago)
Author:
beliar
Message:

This concludes the cleanup and refactoring for now. I hope the changes will make it easier to add functionality to the game.

Location:
branches/code-cleanup-and-refactoring/game
Files:
2 added
1 deleted
11 edited

Legend:

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

    r550 r552  
    8181 
    8282    pathstr = '' 
    83     while master_leftovers: 
     83    for _ in master_leftovers: 
    8484        pathstr += '..' + dir_delim 
    8585        master_leftovers = master_leftovers[1:] 
  • branches/code-cleanup-and-refactoring/game/local_loaders/xmlmap.py

    r551 r552  
    101101        Inputs: 
    102102            engine = FIFE engine 
    103             model = Engine object for PARPG model 
     103            model = The game model 
    104104            callback = function callback 
    105105        """ 
     
    139139 
    140140    def parseMap(self, map_elt): 
    141         if not map_elt: 
     141        if not map_elt and not map_elt.tag == "map": 
    142142            self._err(\ 
    143143                'No <map> element found at top level of map file definition.') 
     
    402402                if inventory_el is not None: 
    403403                    inventory = Inventory() 
    404                     inv_objects = inventory_el.findall("object") 
     404                    inv_objects = inventory_el.findall("map_obj") 
    405405                    for inv_object in inv_objects: 
    406406                        attributes = inv_object.attrib.copy() 
  • branches/code-cleanup-and-refactoring/game/scripts/console.py

    r550 r552  
    2222        @type appListener: ApplicationListener 
    2323        @param appListener: ApplicationListener object providing a link with 
    24         the engine, the view and the fife_model""" 
     24        the Controller, the view and the GameModel""" 
    2525        exit_help   = "Terminate application" 
    2626        grid_help   = "Toggle grid display" 
     
    4646        self.app_listener = app_listener 
    4747        self.view = self.app_listener.view  
    48         self.engine = self.app_listener.fife_model 
    49         self.game_state = self.app_listener.view.fife_model.game_state 
     48        self.model = self.app_listener.model 
     49        self.game_state = self.app_listener.view.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.fife_model.pc_run == 1: 
    81             self.app_listener.fife_model.pc_run = 0 
     80        if self.app_listener.model.pc_run == 1: 
     81            self.app_listener.model.pc_run = 0 
    8282            return "PC is now walking" 
    8383        else: 
    84             self.app_listener.fife_model.pc_run = 1 
     84            self.app_listener.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.fife_model.load_save = True 
    127                 self.app_listener.fife_model.savegame = os.path.join(l_path, l_filename) 
     126                self.app_listener.model.load_save = True 
     127                self.app_listener.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.fife_model.save(s_path, s_filename) 
     148                self.app_listener.model.save(s_path, s_filename) 
    149149                result = "Saved to file: " + s_path + s_filename 
    150150 
  • branches/code-cleanup-and-refactoring/game/scripts/gamemodel.py

    r550 r552  
    2121from gamestate import GameState 
    2222from objects import createObject 
    23 from objects.action import ChangeMapAction, ExamineBoxAction, OpenBoxAction, \ 
    24                             UnlockBoxAction, LockBoxAction, TalkAction 
     23from map import Map 
     24from fife import fife 
     25 
    2526import yaml 
    2627 
     
    3132       the fife view here. This also prevents us from just having a 
    3233       function heavy controller.""" 
    33     def __init__(self, view): 
     34    def __init__(self, engine): 
    3435        """Initialize the instance. 
    35            @type view: world 
    36            @param view: A world instance 
    37            @return: None""" 
     36        @param engine: A fife.Engine object 
     37        @type emgome: fife.Engine  
     38        @return: None""" 
    3839        # a World object (the fife stuff, essentially) 
    39         self.view = view 
    4040        self.map_change = False 
    4141        self.load_saver = False 
     
    4747        self.target_map_file = None 
    4848        self.object_db = {} 
    49  
    50     def save(self, path, filename): 
    51         """Writes the saver to a file. 
    52            @type filename: string 
    53            @param filename: the name of the file to write to 
    54            @return: None""" 
    55         fname = '/'.join([path, filename]) 
    56         try: 
    57             f = open(fname, 'wb') 
    58         except(IOError): 
    59             sys.stderr.write("Error: Can't find save game: " + fname + "\n") 
    60             return 
    61          
    62         # save the PC coordinates 
    63         coords = self.game_state.PC.behaviour.agent.getLocation().\ 
    64                     getMapCoordinates() 
    65         self.game_state.saved_pc_coordinates = (coords.x, coords.y) 
    66          
    67         # Pickle it  
    68         pickle.dump(self.game_state, f) 
    69         f.close()        
    70  
    71     def load(self, path, filename): 
    72         """Loads a saver from a file. 
    73            @type filename: string 
    74            @param filename: the name of the file (including path) to load from 
    75            @return: None""" 
    76         fname = '/'.join([path, filename]) 
    77  
    78         try: 
    79             f = open(fname, 'rb') 
    80         except(IOError): 
    81             sys.stderr.write("Error: Can't find save game file\n") 
    82             return 
    83          
    84         # Remove all currently loaded maps so we can start fresh 
    85         self.view.deleteMaps() 
    86          
    87         self.game_state = pickle.load(f) 
    88         f.close() 
    89  
    90         self.target_position = self.game_state.saved_pc_coordinates 
    91  
    92         # Load the current map 
    93         if self.game_state.current_map_file: 
    94             self.loadMap(self.game_state.current_map_name, \ 
    95                          self.game_state.current_map_file)          
    96  
    97         # Recreate all the behaviours. These can't be saved because FIFE 
    98         # objects cannot be pickled 
    99          
    100         for map_id in self.game_state.objects: 
    101             for obj in self.game_state.objects[map_id].itervalues(): 
    102                 if obj.trueAttr("NPC") or obj.trueAttr("AnimatedContainer"): 
    103                     obj.createBehaviour(self.view.active_map.agent_layer) 
    104                     obj.setup() 
    105        
    106         # In most maps we'll create the PC Instance internally. In these 
    107         # cases we need a target position 
    108          
     49        # self.map is a Map object, set to none here 
     50        self.active_map = None 
     51        self.maps = {} 
     52        self.engine = engine         
    10953 
    11054    def checkAttributes(self, attributes): 
     
    15195        container.placeItem(obj) 
    15296         
     97    def save(self, path, filename): 
     98        """Writes the saver to a file. 
     99           @type filename: string 
     100           @param filename: the name of the file to write to 
     101           @return: None""" 
     102        fname = '/'.join([path, filename]) 
     103        try: 
     104            save_file = open(fname, 'wb') 
     105        except(IOError): 
     106            sys.stderr.write("Error: Can't find save game: " + fname + "\n") 
     107            return 
     108         
     109        # save the PC coordinates 
     110        coords = self.game_state.PlayerCharacter.behaviour.agent.getLocation().\ 
     111                    getMapCoordinates() 
     112        self.game_state.saved_pc_coordinates = (coords.x, coords.y) 
     113         
     114        # Pickle it  
     115        pickle.dump(self.game_state, save_file) 
     116        save_file.close()        
     117 
     118    def load(self, path, filename): 
     119        """Loads a saver from a file. 
     120           @type filename: string 
     121           @param filename: the name of the file (including path) to load from 
     122           @return: None""" 
     123        fname = '/'.join([path, filename]) 
     124 
     125        try: 
     126            load_file = open(fname, 'rb') 
     127        except(IOError): 
     128            sys.stderr.write("Error: Can't find save game file\n") 
     129            return         
     130         
     131        self.game_state = pickle.load(load_file) 
     132        load_file.close() 
     133 
     134        self.target_position = self.game_state.saved_pc_coordinates 
     135 
     136        # Load the current map 
     137        if self.game_state.current_map_file: 
     138            self.loadMap(self.game_state.current_map_name, \ 
     139                         self.game_state.current_map_file)          
     140 
     141        # Recreate all the behaviours. These can't be saved because FIFE 
     142        # objects cannot be pickled 
     143         
     144        for map_id in self.game_state.objects: 
     145            for obj in self.game_state.objects[map_id].itervalues(): 
     146                if obj.trueAttr("NPC") or obj.trueAttr("AnimatedContainer"): 
     147                    obj.createBehaviour(self.active_map.agent_layer) 
     148                    obj.setup() 
     149       
     150        # In most maps we'll create the PlayerCharacter Instance internally.  
     151        # In these cases we need a target position 
     152          
     153    def teleport(self, position): 
     154        """Called when a door is used that moves a player to a new 
     155           location on the same map. the setting of position may want 
     156           to be created as its own method down the road. 
     157           @type position: String Tuple 
     158           @param position: X,Y coordinates passed from engine.changeMap 
     159           @return: fife.Location""" 
     160        print position 
     161        coord = fife.DoublePoint3D(float(position[0]), float(position[1]), 0) 
     162        location = fife.Location(self.active_map.agent_layer) 
     163        location.setMapCoordinates(coord) 
     164        self.game_state.PlayerCharacter.teleport(location) 
     165                 
     166    def getObjectAtCoords(self, coords): 
     167        """Get the object which is at the given coords 
     168            @type coords: fife.Screenpoint 
     169            @param coords: Coordinates where to check for an object 
     170            @rtype: fife.Object 
     171            @return: An object or None""" 
     172        instances = self.active_map.cameras[ 
     173                                            self.active_map.my_cam_id].\ 
     174            getMatchingInstances(coords, self.active_map.agent_layer) 
     175        # no object returns an empty tuple 
     176        if(instances != ()): 
     177            front_y = 0 
     178             
     179 
     180            for obj in instances: 
     181                # check to see if this in our list at all 
     182                if(self.objectActive(obj.getId())): 
     183                    # check if the object is on the foreground 
     184                    obj_map_coords = \ 
     185                                      obj.getLocation().getMapCoordinates() 
     186                    obj_screen_coords = self.active_map.\ 
     187                        cameras[self.active_map.my_cam_id]\ 
     188                        .toScreenCoordinates(obj_map_coords) 
     189 
     190                    if obj_screen_coords.y > front_y: 
     191                        #Object on the foreground 
     192                        front_y = obj_screen_coords.y 
     193                        return obj 
     194                    else: 
     195                        return None 
     196        else: 
     197            return None 
     198 
     199    def getCoords(self, click): 
     200        """Get the map location x, y coordinates from the screen coordinates 
     201           @type click: fife.ScreenPoint 
     202           @param click: Screen coordinates 
     203           @rtype: fife.Location 
     204           @return: The map coordinates""" 
     205        coord = self.active_map.cameras[self.active_map.my_cam_id].\ 
     206                    toMapCoordinates(click, False) 
     207        coord.z = 0 
     208        location = fife.Location(self.active_map.agent_layer) 
     209        location.setMapCoordinates(coord) 
     210        return location 
     211 
     212    def togglePause(self): 
     213        """ Pause/Unpause the game. 
     214            @return: nothing""" 
     215        self.active_map.togglePause() 
     216     
     217    def loadMap(self, map_name, map_file): 
     218        """Load a new map. 
     219           @type map_name: string 
     220           @param map_name: Name of the map to load 
     221           @type map_file: string 
     222           @param map_file: Filename of map file to load 
     223           @return: None""" 
     224        self.game_state.current_map_file = map_file 
     225        self.game_state.current_map_name = map_name 
     226 
     227        if not map_name in self.maps:            
     228            new_map = Map(self.engine, self) 
     229            self.maps[map_name] = new_map 
     230            new_map.load(map_file) 
     231        else: 
     232            self.setActiveMap(map_name) 
     233 
     234        # create the PlayerCharacter agent 
     235        self.active_map.addPC() 
     236        self.game_state.PlayerCharacter.start() 
     237 
     238    def changeMap(self, map_name, map_file, target_position): 
     239        """Registers for a map change on the next pump(). 
     240           @type map_name: String 
     241           @param map_name: Id of the map to teleport to 
     242           @type map_file: String 
     243           @param map_file: Filename of the map to teleport to 
     244           @type target_position: Tuple 
     245           @param target_position: Position of PlayerCharacter on target map. 
     246           @return None""" 
     247        # set the parameters for the map change if moving to a new map 
     248        if map_name != self.game_state.current_map_name: 
     249            self.target_map_name = map_name 
     250            self.target_map_file = map_file 
     251            self.target_position = target_position 
     252            # issue the map change 
     253            self.map_change = True 
     254        else: 
     255            #set the player position on the current map 
     256            self.teleport(target_position) 
     257 
     258    def deleteMaps(self): 
     259        """Clear all currently loaded maps from FIFE as well as clear our 
     260            local map cache 
     261            @return: nothing""" 
     262        self.engine.getModel().deleteMaps() 
     263        self.engine.getModel().deleteObjects() 
     264        self.maps = {} 
     265         
     266    def setActiveMap(self, map_name): 
     267        """Sets the active map that is to be rendered. 
     268           @type map_name: String 
     269           @param map_name: The name of the map to load 
     270           @return: None""" 
     271        # Turn off the camera on the old map before we turn on the camera 
     272        # on the new map. 
     273        self.active_map.cameras[self.active_map.my_cam_id].setEnabled(False) 
     274        # Make the new map active. 
     275        self.active_map = self.maps[map_name] 
     276        self.active_map.makeActive() 
     277 
    153278    def createMapObject (self, layer, attributes, instance): 
    154279        """Create an object and add it to the current map. 
     
    174299            self.addObject(layer, obj, instance)  
    175300 
    176     def addPC(self, layer, pc, instance): 
    177         """Add the PC to the map 
     301    def addPC(self, layer, player_char, instance): 
     302        """Add the PlayerCharacter to the map 
    178303           @type layer: fife.Layer 
    179304           @param layer: FIFE layer object exists in 
    180            @type pc: PlayerCharacter 
    181            @param pc: PlayerCharacter object 
     305           @type player_char: PlayerCharacter 
     306           @param player_char: PlayerCharacter object 
    182307           @type instance: fife.Instance 
    183            @param instance: FIFE instance of PC 
    184            @return: None""" 
    185         # For now we copy the PC, in the future we will need to copy 
    186         # PC specifics between the different PC's 
    187         self.game_state.PC = pc 
    188         self.game_state.PC.setup() 
    189          
    190         # The PC has an inventory, and also some filling of the ready slots  
    191         # in the HUD. At this point we sync the contents of the ready slots  
    192         # with the contents of the inventory. 
    193         self.view.hud.initializeInventory() 
     308           @param instance: FIFE instance of PlayerCharacter 
     309           @return: None""" 
     310        # For now we copy the PlayerCharacter,  
     311        # in the future we will need to copy 
     312        # PlayerCharacter specifics between the different PlayerCharacter's 
     313        self.game_state.PlayerCharacter = player_char 
     314        self.game_state.PlayerCharacter.setup()         
    194315 
    195316    def addObject(self, layer, obj, instance): 
     
    217338            # create the agent 
    218339            obj.setup() 
    219             # create the PC agent 
     340            # create the PlayerCharacter agent 
    220341            obj.start() 
    221342        if obj.trueAttr("AnimatedContainer"): 
     
    236357                return i 
    237358        # no match 
    238         return False 
    239  
    240     def getItemActions(self, obj_id): 
    241         """Given the objects ID, return the text strings and callbacks. 
    242            @type obj_id: string 
    243            @param obj_id: ID of object 
    244            @rtype: list 
    245            @return: List of text and callbacks""" 
    246         actions = [] 
    247         # note: ALWAYS check NPC's first! 
    248         obj = self.game_state.getObjectById(obj_id, \ 
    249                                             self.game_state.current_map_name) 
    250          
    251         if obj is not None: 
    252             if obj.trueAttr("NPC"): 
    253                 # keep it simple for now, None to be replaced by callbacks 
    254                 actions.append(["Talk", "Talk", self.initTalk, obj]) 
    255                 actions.append(["Attack", "Attack", self.nullFunc, obj]) 
    256             else: 
    257                 actions.append(["Examine", "Examine", \ 
    258                                 self.game_state.PC.approach, [obj.X, obj.Y], \ 
    259                                 ExamineBoxAction(self, obj.name, obj.text)]) 
    260                 # is it a Door? 
    261                 if obj.trueAttr("door"): 
    262                     actions.append(["Change Map", "Change Map", \ 
    263                        self.game_state.PC.approach, [obj.X, obj.Y], \ 
    264                             ChangeMapAction(self, obj.target_map_name, \ 
    265                                 obj.target_map, obj.target_pos)]) 
    266                 # is it a container? 
    267                 if obj.trueAttr("container"): 
    268                     actions.append(["Open", "Open",  
    269                                     self.game_state.PC.approach, \ 
    270                                     [obj.X, obj.Y], \ 
    271                                     OpenBoxAction(self, obj)]) 
    272                     actions.append(["Unlock", "Unlock",  
    273                                     self.game_state.PC.approach, \ 
    274                                     [obj.X, obj.Y], \ 
    275                                     UnlockBoxAction(obj)]) 
    276                     actions.append(["Lock", "Lock",  
    277                                     self.game_state.PC.approach, \ 
    278                                     [obj.X, obj.Y], \ 
    279                                     LockBoxAction(obj)]) 
    280                 # can you pick it up? 
    281                 if obj.trueAttr("carryable"): 
    282                     actions.append(["Pick Up", "Pick Up", self.nullFunc, obj]) 
    283  
    284         return actions 
    285      
    286     def nullFunc(self, userdata): 
    287         """Sample callback for the context menus.""" 
    288         print userdata 
    289      
    290     def initTalk(self, npcInfo): 
    291         """ Starts the PC talking to an NPC. """ 
    292         # TODO: work more on this when we get NPCData and HeroData straightened 
    293         # out 
    294         npc = self.game_state.getObjectById(npcInfo.ID, \ 
    295                                             self.game_state.current_map_name) 
    296         self.game_state.PC.approach([npc.getLocation().\ 
    297                                      getLayerCoordinates().x, \ 
    298                                      npc.getLocation().\ 
    299                                      getLayerCoordinates().y], \ 
    300                                     TalkAction(self, npc)) 
    301  
    302     def loadMap(self, map_name, map_file): 
    303         """Load a new map. 
    304            @type map_name: string 
    305            @param map_name: Name of the map to load 
    306            @type map_file: string 
    307            @param map_file: Filename of map file to load 
    308            @return: None""" 
    309         self.game_state.current_map_file = map_file 
    310         self.game_state.current_map_name = map_name 
    311         self.view.loadMap(map_name, str(map_file)) 
    312  
    313         # create the PC agent 
    314         self.view.active_map.addPC() 
    315         self.game_state.PC.start() 
    316  
    317     def handleMouseClick(self, position): 
    318         """Code called when user left clicks the screen. 
     359        return False     
     360 
     361    def movePlayer(self, position): 
     362        """Code called when the player should move to another location 
    319363           @type position: fife.ScreenPoint 
    320            @param position: Screen position of click 
     364           @param position: Screen position to move to 
    321365           @return: None""" 
    322366        if(self.pc_run == 1): 
    323             self.game_state.PC.run(position) 
    324         else: 
    325             self.game_state.PC.walk(position) 
    326  
    327     def changeMap(self, map_name, map_file, target_position): 
    328         """Registers for a map change on the next pump(). 
    329            @type map_name: String 
    330            @param map_name: Id of the map to teleport to 
    331            @type map_file: String 
    332            @param map_file: Filename of the map to teleport to 
    333            @type target_position: Tuple 
    334            @param target_position: Position of PC on target map. 
    335            @return None""" 
    336         # set the parameters for the map change if moving to a new map 
    337         if map_name != self.game_state.current_map_name: 
    338             self.target_map_name = map_name 
    339             self.target_map_file = map_file 
    340             self.target_position = target_position 
    341             # issue the map change 
    342             self.map_change = True 
    343         else: 
    344             #set the player position on the current map 
    345             self.view.teleport(target_position) 
    346  
    347     def handleCommands(self): 
    348         if self.map_change: 
    349             self.loadMap(self.target_map_name, self.target_map_file) 
    350             self.view.teleport(self.target_position) 
    351             self.map_change = False 
    352          
    353         if self.load_saver: 
    354             self.load(self.savegame) 
    355             self.load_saver = False 
    356  
    357     def pump(self): 
    358         """Main loop in the engine.""" 
    359         self.handleCommands() 
    360          
     367            self.game_state.PlayerCharacter.run(position) 
     368        else: 
     369            self.game_state.PlayerCharacter.walk(position) 
     370         
     371    def teleportPlayer(self, position): 
     372        """Code called when the player should teleport to another location 
     373           @type position: fife.ScreenPoint 
     374           @param position: Screen position to teleport to 
     375           @return: None""" 
     376        self.game_state.PlayerCharacter.teleport(position) 
     377 
    361378    def readObjectDB(self, db_file): 
    362379        """Reads the Object Information Database from a file. 
  • branches/code-cleanup-and-refactoring/game/scripts/gamescenecontroller.py

    r550 r552  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 from scripts.common.eventlistenerbase import EventListenerBase 
     18from controllerbase import ControllerBase 
    1919from datetime import date, time 
    2020from fife import fife 
     
    2323import glob 
    2424import os 
    25  
    26 class GameSceneController(EventListenerBase): 
     25from objects.action import ChangeMapAction, ExamineBoxAction, OpenBoxAction, \ 
     26                            UnlockBoxAction, LockBoxAction, TalkAction 
     27 
     28class GameSceneController(ControllerBase): 
    2729    ''' 
    28     classdocs 
     30    This controller handles inputs when the game is in "scene" state. 
     31    "Scene" state is when the player can move around and interact 
     32    with objects. Like, talking to a npc or examining the contents of a box.  
    2933    ''' 
    3034 
     
    3337        ''' 
    3438        Constructor 
     39        @param engine: Instance of the active fife engine 
     40        @type engine: fife.Engine 
     41        @param view: Instance of a GameSceneView 
     42        @param type: scripts.GameSceneView 
     43        @param model: The model that has the current gamestate 
     44        @type model: scripts.GameModel 
     45        @param application: The application that created this controller 
     46        @type application: scripts.PARPGApplication 
     47        @param settings: The current settings of the application 
     48        @type settings: fife.extensions.fife_settings.Setting 
    3549        ''' 
    36         super(GameSceneController, self).__init__(engine,  
    37                                              reg_mouse=True,  
    38                                              reg_keys=True) 
    39         self.engine = engine 
    40         self.event_manager = engine.getEventManager() 
    41         # Last saved mouse coords 
     50        super(GameSceneController, self).__init__(engine, 
     51                                                  view, 
     52                                                  model, 
     53                                                  application, 
     54                                                  settings, 
     55                                                  reg_mouse=True,  
     56                                                  reg_keys=True) 
     57        # Last saved mouse coords         
    4258        self.last_mousecoords = None 
    43         self.view = view 
    44         self.fife_model = model 
    4559         
    4660        self.mouse_callback = None 
    47         self.application = application 
    48         self.settings = settings 
    4961 
    5062        # don't force restart if skipping to new section 
     
    6577            'quitGame': self.quitGame, 
    6678        } 
    67         self.view.hud = Hud(self.engine, self.settings, self.fife_model, hud_callbacks) 
     79        self.view.hud = Hud(self.engine,  
     80                            self.settings,  
     81                            self.model,  
     82                            hud_callbacks) 
    6883 
    6984    def keyPressed(self, evt): 
     
    125140        scr_point = fife.ScreenPoint(evt.getX(), evt.getY()) 
    126141        if(evt.getButton() == fife.MouseEvent.LEFT): 
    127             self.fife_model.handleMouseClick(self.view.getCoords(scr_point)) 
     142            self.model.movePlayer(self.model.getCoords(scr_point)) 
    128143        elif(evt.getButton() == fife.MouseEvent.RIGHT): 
    129144            # is there an object here? 
    130             tmp_active_map = self.view.active_map 
     145            tmp_active_map = self.model.active_map 
    131146            instances = tmp_active_map.cameras[tmp_active_map.my_cam_id].\ 
    132147                            getMatchingInstances(scr_point, \ 
     
    135150            for inst in instances: 
    136151                # check to see if this is an active item 
    137                 if(self.fife_model.objectActive(inst.getId())): 
    138                     # yes, get the fife_model 
    139                     info = self.fife_model.getItemActions(inst.getId()) 
     152                if(self.model.objectActive(inst.getId())): 
     153                    # yes, get the model 
     154                    info = self.getItemActions(inst.getId()) 
    140155                    break 
    141156 
     
    144159            data = info or \ 
    145160                [["Walk", "Walk here", self.view.onWalk,  
    146                   self.view.getCoords(scr_point)]] 
     161                  self.model.getCoords(scr_point)]] 
    147162            # show the menu 
    148163            self.view.hud.showContextMenu(data, (scr_point.x, scr_point.y)) 
     
    154169           @return: None""" 
    155170        self.last_mousecoords = fife.ScreenPoint(evt.getX(), evt.getY()) 
    156         self.view.highlightFrontObject(self.last_mousecoords)         
     171        self.view.highlightFrontObject(self.last_mousecoords)        
     172 
     173    def handleCommands(self): 
     174        if self.model.map_change: 
     175            self.model.loadMap(self.model.target_map_name,  
     176                               self.model.target_map_file) 
     177            self.model.teleport(self.model.target_position) 
     178            self.model.map_change = False 
     179            # The PlayerCharacter has an inventory, and also some  
     180            # filling of the ready slots in the HUD.  
     181            # At this point we sync the contents of the ready slots  
     182            # with the contents of the inventory. 
     183            self.view.hud.initializeInventory()           
     184         
     185        if self.model.load_saver: 
     186            self.load(self.savegame) 
     187            self.model.load_saver = False 
    157188                 
     189    def nullFunc(self, userdata): 
     190        """Sample callback for the context menus.""" 
     191        print userdata     
     192 
     193    def initTalk(self, npc_info): 
     194        """ Starts the PlayerCharacter talking to an NPC. """ 
     195        # TODO: work more on this when we get NPCData and HeroData straightened 
     196        # out 
     197        npc = self.model.game_state.getObjectById(npc_info.ID, \ 
     198                                            self.model.game_state.current_map_name) 
     199        self.model.game_state.PlayerCharacter.approach([npc.getLocation().\ 
     200                                     getLayerCoordinates().x, \ 
     201                                     npc.getLocation().\ 
     202                                     getLayerCoordinates().y], \ 
     203                                    TalkAction(self.model, self.view, npc)) 
     204 
     205    def getItemActions(self, obj_id): 
     206        """Given the objects ID, return the text strings and callbacks. 
     207           @type obj_id: string 
     208           @param obj_id: ID of object 
     209           @rtype: list 
     210           @return: List of text and callbacks""" 
     211        actions = [] 
     212        # note: ALWAYS check NPC's first! 
     213        obj = self.model.game_state.getObjectById(obj_id, \ 
     214                                            self.model.game_state.current_map_name) 
     215         
     216        if obj is not None: 
     217            if obj.trueAttr("NPC"): 
     218                # keep it simple for now, None to be replaced by callbacks 
     219                actions.append(["Talk", "Talk", self.initTalk, obj]) 
     220                actions.append(["Attack", "Attack", self.nullFunc, obj]) 
     221            else: 
     222                actions.append(["Examine", "Examine", 
     223                                self.model.game_state.PlayerCharacter.approach, [obj.X, obj.Y], \ 
     224                                ExamineBoxAction(self.model, self.view,  
     225                                                 obj.name, obj.text)]) 
     226                # is it a Door? 
     227                if obj.trueAttr("door"): 
     228                    actions.append(["Change Map", "Change Map", 
     229                       self.model.game_state.PlayerCharacter.approach, [obj.X, obj.Y], \ 
     230                            ChangeMapAction(self.model, self.view 
     231                                            , obj.target_map_name, 
     232                                obj.target_map, obj.target_pos)]) 
     233                # is it a container? 
     234                if obj.trueAttr("container"): 
     235                    actions.append(["Open", "Open",  
     236                                    self.model.game_state.PlayerCharacter.approach, \ 
     237                                    [obj.X, obj.Y], 
     238                                    OpenBoxAction(self.model, self.view, obj)]) 
     239                    actions.append(["Unlock", "Unlock",  
     240                                    self.model.game_state.PlayerCharacter.approach, \ 
     241                                    [obj.X, obj.Y], 
     242                                    UnlockBoxAction(obj)]) 
     243                    actions.append(["Lock", "Lock",  
     244                                    self.model.game_state.PlayerCharacter.approach, \ 
     245                                    [obj.X, obj.Y], 
     246                                    LockBoxAction(obj)]) 
     247                # can you pick it up? 
     248                if obj.trueAttr("carryable"): 
     249                    actions.append(["Pick Up", "Pick Up", self.nullFunc, obj]) 
     250 
     251        return actions 
     252     
     253    def saveGame(self, *args, **kwargs): 
     254        """Saves the game state, delegates call to engine.Engine 
     255           @return: None""" 
     256        self.model.save(*args, **kwargs) 
     257 
     258    def loadGame(self, *args, **kwargs): 
     259        """Loads the game state, delegates call to engine.Engine 
     260           @return: None""" 
     261        # Remove all currently loaded maps so we can start fresh 
     262        self.model.deleteMaps() 
     263 
     264        self.model.load(*args, **kwargs) 
     265 
     266    def quitGame(self): 
     267        """Quits the game 
     268           @return: None""" 
     269        self.application.listener.quitGame() 
     270 
    158271    def pump(self): 
    159272        """Routine called during each frame. Our main loop is in ./run.py""" 
     
    162275        self.view.highlightFrontObject(self.last_mousecoords) 
    163276        self.view.refreshTopLayerTransparencies() 
     277        self.handleCommands() 
    164278        # print "%05f" % (time.time()-t0,) 
    165  
    166     def saveGame(self, *args, **kwargs): 
    167         """Saves the game state, delegates call to engine.Engine 
    168            @return: None""" 
    169         self.fife_model.save(*args, **kwargs) 
    170  
    171     def loadGame(self, *args, **kwargs): 
    172         """Loads the game state, delegates call to engine.Engine 
    173            @return: None""" 
    174         self.fife_model.load(*args, **kwargs) 
    175  
    176     def quitGame(self): 
    177         """Quits the game 
    178            @return: None""" 
    179         self.application.listener.quitGame() 
  • branches/code-cleanup-and-refactoring/game/scripts/gamesceneview.py

    r550 r552  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 from map import Map 
    19 from fife import fife 
    2018from sounds import SoundEngine 
     19from viewbase import ViewBase 
    2120 
    22 # this file should be the meta-file for all FIFE-related code 
    23 # engine.py handles is our fife_model fife_model, whilst this is our view 
    24 # in order to not replicate fife_model, some of our fife_model fife_model will naturally 
    25 # reside on this side of the fence (PC xpos and ypos, for example). 
    26 # we should aim to never replicate any fife_model as this leads to maintenance 
    27 # issues (and just looks plain bad). 
    28 # however, any logic needed to resolve this should sit in engine.py 
    29  
    30 class GameSceneView(object): 
    31     """GameSceneView holds the fife_model needed by fife to render the engine 
    32        The engine keeps a copy of this class""" 
    33     def __init__(self, engine): 
     21class GameSceneView(ViewBase): 
     22    """GameSceneView is responsible for drawing the scene""" 
     23    def __init__(self, engine, model): 
    3424        """Constructor for engine 
     25           @param engine: A fife.Engine instance 
    3526           @type engine: fife.Engine 
    36            @param engine: A fife.Engine instance 
    37            @return: None""" 
    38         # self.engine is a fife.Engine object, not an Engine object 
    39         self.engine = engine 
    40  
    41         # self.fife_model is an gamemodel.GameModel object, but is set in run.py 
    42         self.fife_model = None 
    43  
    44         # self.map is a Map object, set to none here 
    45         self.active_map = None 
    46         self.maps = {} 
     27           @param model: a script.GameModel instance 
     28           @type model: script.GameModel  
     29           """ 
     30        super(GameSceneView, self).__init__(engine, model) 
    4731 
    4832        self.action_number = 1 
     
    5943        self.faded_objects = set() 
    6044 
    61     def loadMap(self, map_name, filename): 
    62         """Loads a map and stores it under the given name in the maps list. 
    63            @type map_name: String 
    64            @param map_name: The name of the map to load 
    65            @type filename: String 
    66            @param filename: File which contains the map to be loaded 
    67            @return: None""" 
    68         if not map_name in self.maps: 
    69             new_map = Map(self.engine, self.fife_model) 
    70             self.maps[map_name] = new_map 
    71             new_map.load(filename) 
    72         else: 
    73             self.setActiveMap(map_name) 
    74  
    75     def setActiveMap(self, map_name): 
    76         """Sets the active map that is to be rendered. 
    77            @type map_name: String 
    78            @param map_name: The name of the map to load 
    79            @return: None""" 
    80         # Turn off the camera on the old map before we turn on the camera 
    81         # on the new map. 
    82         self.active_map.cameras[self.active_map.my_cam_id].setEnabled(False) 
    83         # Make the new map active. 
    84         self.active_map = self.maps[map_name] 
    85         self.active_map.makeActive() 
    86  
    8745    def displayObjectText(self, obj, text): 
    8846        """Display on screen the text of the object over the object. 
     
    9755        """Callback sample for the context menu.""" 
    9856        self.hud.hideContainer() 
    99         self.fife_model.game_state.PC.run(click) 
     57        self.engine.getModel().game_state.PlayerCharacter.run(click) 
    10058 
    10159    def refreshTopLayerTransparencies(self): 
    102         """Fade or unfade TopLayer instances if the PC is under them.""" 
    103         # get the PC's screen coordinates 
    104         camera = self.active_map.cameras[self.active_map.my_cam_id] 
    105         point = self.fife_model.game_state.PC.behaviour.agent.getLocation() 
     60        """Fade or unfade TopLayer instances if the PlayerCharacter  
     61        is under them.""" 
     62        # get the PlayerCharacter's screen coordinates 
     63        camera = self.model.active_map.cameras[self.model.active_map.my_cam_id] 
     64        point = self.model.game_state.PlayerCharacter.\ 
     65                                        behaviour.agent.getLocation() 
    10666        scr_coords = camera.toScreenCoordinates(point.getMapCoordinates()) 
    10767 
    10868        # find all instances on TopLayer that fall on those coordinates 
    10969        instances = camera.getMatchingInstances(scr_coords, 
    110                         self.active_map.top_layer) 
     70                        self.model.active_map.top_layer) 
    11171        instance_ids = [ instance.getId() for instance in instances ] 
    11272        faded_objects = self.faded_objects 
     
    11676            if instance_id not in faded_objects: 
    11777                faded_objects.add(instance_id) 
    118                 self.active_map.top_layer.getInstance(instance_id).\ 
     78                self.model.active_map.top_layer.getInstance(instance_id).\ 
    11979                        get2dGfxVisual().setTransparency(128) 
    12080 
     
    12383            if instance_id not in instance_ids: 
    12484                faded_objects.remove(instance_id) 
    125                 self.active_map.top_layer.getInstance(instance_id).\ 
     85                self.model.active_map.top_layer.getInstance(instance_id).\ 
    12686                        get2dGfxVisual().setTransparency(0) 
    12787 
    128     def teleport(self, position): 
    129         """Called when a door is used that moves a player to a new 
    130            location on the same map. the setting of position may want 
    131            to be created as its own method down the road. 
    132            @type position: String Tuple 
    133            @param position: X,Y coordinates passed from engine.changeMap 
    134            @return: fife.Location""" 
    135         print position 
    136         coord = fife.DoublePoint3D(float(position[0]), float(position[1]), 0) 
    137         location = fife.Location(self.active_map.agent_layer) 
    138         location.setMapCoordinates(coord) 
    139         self.fife_model.game_state.PC.teleport(location) 
    140                  
    141     def getObjectAtCoords(self, coords): 
    142         """Get the object which is at the given coords 
    143             @type coords: fife.Screenpoint 
    144             @param coords: Coordinates where to check for an object 
    145             @rtype: fife.Object 
    146             @return: An object or None""" 
    147         instances = self.active_map.cameras[self.active_map.my_cam_id].\ 
    148             getMatchingInstances(coords, self.active_map.agent_layer) 
    149         # no object returns an empty tuple 
    150         if(instances != ()): 
    151             front_y = 0 
    152              
    153  
    154             for obj in instances: 
    155                 # check to see if this in our list at all 
    156                 if(self.fife_model.objectActive(obj.getId())): 
    157                     # check if the object is on the foreground 
    158                     obj_map_coords = \ 
    159                                       obj.getLocation().getMapCoordinates() 
    160                     obj_screen_coords = self.active_map.\ 
    161                         cameras[self.active_map.my_cam_id]\ 
    162                         .toScreenCoordinates(obj_map_coords) 
    163  
    164                     if obj_screen_coords.y > front_y: 
    165                         #Object on the foreground 
    166                         front_y = obj_screen_coords.y 
    167                         return obj 
    168                     else: 
    169                         return None 
    170         else: 
    171             return None 
    172  
    173     def getCoords(self, click): 
    174         """Get the map location x, y coordinates from the screen coordinates 
    175            @type click: fife.ScreenPoint 
    176            @param click: Screen coordinates 
    177            @rtype: fife.Location 
    178            @return: The map coordinates""" 
    179         coord = self.active_map.cameras[self.active_map.my_cam_id].\ 
    180                     toMapCoordinates(click, False) 
    181         coord.z = 0 
    182         location = fife.Location(self.active_map.agent_layer) 
    183         location.setMapCoordinates(coord) 
    184         return location 
    185  
    186     def togglePause(self): 
    187         """ Pause/Unpause the game. 
    188             @return: nothing""" 
    189         self.active_map.togglePause() 
    190      
    191     def deleteMaps(self): 
    192         """Clear all currently loaded maps from FIFE as well as clear our 
    193             local map cache 
    194             @return: nothing""" 
    195         self.engine.getModel().deleteMaps() 
    196         self.engine.getModel().deleteObjects() 
    197         self.maps = {} 
    19888 
    19989    def highlightFrontObject(self, mouse_coords): 
    200         """Highlights the object that is at the current mouse coordinates"""         
     90        """Highlights the object that is at the  
     91        current mouse coordinates"""         
    20192        if mouse_coords: 
    202             front_obj = self.getObjectAtCoords(mouse_coords) 
     93            front_obj = self.model.getObjectAtCoords(mouse_coords) 
    20394            if front_obj != None: 
    20495                if self.highlight_obj == None \ 
     
    20798                    if self.highlight_obj: 
    20899                        self.displayObjectText(self.highlight_obj,"") 
    209                     self.active_map.outline_renderer.removeAllOutlines() 
     100                    self.model.active_map.outline_renderer.removeAllOutlines() 
    210101                    self.highlight_obj = front_obj 
    211                     self.active_map.outline_renderer.addOutlined( 
     102                    self.model.active_map.outline_renderer.addOutlined( 
    212103                                                    self.highlight_obj,  
    213104                                                    0, 
    214105                                                    137, 255, 2) 
    215106                    # get the text 
    216                     item = self.fife_model.objectActive( 
     107                    item = self.model.objectActive( 
    217108                                                    self.highlight_obj.getId()) 
    218109                    if item is not None: 
     
    222113                if self.highlight_obj: 
    223114                    self.displayObjectText(self.highlight_obj,"") 
    224                 self.active_map.outline_renderer.removeAllOutlines() 
     115                self.model.active_map.outline_renderer.removeAllOutlines() 
    225116                self.highlight_obj = None   
    226117            
  • branches/code-cleanup-and-refactoring/game/scripts/gamestate.py

    r550 r552  
    2121    """This class holds the current state of the game.""" 
    2222    def __init__(self): 
    23         self.PC = None 
     23        self.PlayerCharacter = None 
    2424        self.quest_engine = quest_engine.QuestEngine() 
    2525        self.objects = {} 
  • branches/code-cleanup-and-refactoring/game/scripts/gui/hud.py

    r550 r552  
    2727class Hud(object): 
    2828    """Main Hud class""" 
    29     def __init__(self, engine, settings, data, callbacks): 
     29    def __init__(self, engine, settings, model, callbacks): 
    3030        """Initialise the instance. 
    3131           @type engine: fife.Engine 
    3232           @param engine: An instance of the fife engine 
    3333           @type settings: settings.Setting 
    34            @param settings: The settings fife_model 
     34           @param settings: The settings 
    3535           @type inv_model: dict 
    3636           @type callbacks: dict 
     
    4646        self.engine = engine 
    4747        self.settings = settings 
    48         self.fife_model = data 
     48        self.model = model 
    4949        self.inventory = None 
    5050 
     
    138138            'toggleInventoryButton': self.toggleInventoryButton, 
    139139        } 
    140         self.inventory_storage = self.fife_model.game_state.PC.inventory 
     140        self.inventory_storage = self.model.game_state.PlayerCharacter.inventory 
    141141        if self.inventory == None: 
    142142            self.inventory = inventorygui.InventoryGUI(self.engine, 
     
    152152 
    153153    def showContextMenu(self, data, pos): 
    154         """Display the Context Menu with fife_model at pos 
    155            @type fife_model: list 
    156            @param fife_model: fife_model 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 
    157157           @type pos: tuple 
    158158           @param pos: tuple of x and y coordinates 
     
    420420        dialogue = DialogueGUI( 
    421421                    npc, 
    422                     self.fife_model.game_state.quest_engine, 
    423                     self.fife_model.game_state.PC) 
     422                    self.model.game_state.quest_engine, 
     423                    self.model.game_state.PlayerCharacter) 
    424424        dialogue.initiateDialogue() 
  • branches/code-cleanup-and-refactoring/game/scripts/map.py

    r550 r552  
    8282        self.top_layer = self.map.getLayer('TopLayer') 
    8383         
    84         #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 
    8585        found = False 
    8686        inst = None 
     
    9090                break 
    9191                 
    92         #If there is not a PC instance created yet than we construct the PC 
    93         #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 
    9494        if not found: 
    9595            x = float(self.model.target_position[0]) 
     
    104104                                            "PC") 
    105105            fife.InstanceVisual.create(inst) 
    106         #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 
    107107        #location for this new map 
    108108        elif self.model.target_position is not None: 
     
    112112            location.setMapCoordinates(coord) 
    113113            inst.setLocation(location) 
    114         #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 
    115115        #the coordinates in the Map file 
    116116             
     
    159159          
    160160        # Make World aware that this is now the active map. 
    161         self.model.view.active_map = self 
     161        self.model.active_map = self 
    162162 
    163163    def addPC(self): 
    164164        """Add the player character to the map 
    165165           @return: None""" 
    166         # Update gamestate.PC 
    167         self.model.game_state.PC.behaviour.onNewMap(self.agent_layer) 
     166        # Update gamestate.PlayerCharacter 
     167        self.model.game_state.PlayerCharacter.behaviour.onNewMap(self.agent_layer) 
    168168 
    169169        # actually this is real easy, we just have to 
    170         # attach the main camera to the PC, if a camera 
     170        # attach the main camera to the PlayerCharacter, if a camera 
    171171        # was already used, we simply recycle it.  
    172172        if self.cameras[self.my_cam_id].getAttached() == None: 
    173173            self.cameras[self.my_cam_id].attach(self.model.game_state. 
    174                                                 PC.behaviour.agent) 
     174                                                PlayerCharacter.behaviour.agent) 
    175175 
    176176    def toggleRenderer(self, r_name): 
  • branches/code-cleanup-and-refactoring/game/scripts/objects/action.py

    r550 r552  
    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  
     
    3739           @return: None""" 
    3840        Action.__init__(self) 
    39         self.engine = engine 
     41        self.model = model 
     42        self.view = view 
    4043        self.target_pos = target_pos 
    4144        self.target_map_name = target_map_name 
     
    4447    def execute(self): 
    4548        """Executes the map change.""" 
    46         self.engine.changeMap(self.target_map_name, self.target_map_file,\ 
     49        self.model.changeMap(self.target_map_name, self.target_map_file,\ 
    4750                              self.target_pos) 
    4851        
    4952class OpenBoxAction(Action): 
    5053    """Open a box. Needs to be more generic, but will do for now.""" 
    51     def __init__(self, engine, container): 
    52         """@type engine: Engine reference 
    53            @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 
    5459           @param container: A reference to the container""" 
    5560        Action.__init__(self) 
    56         self.engine = engine 
     61        self.model = model 
     62        self.view = view 
    5763        self.container = container 
    5864         
     
    6167        try: 
    6268            self.container.open() 
    63             self.engine.view.hud.createBoxGUI(self.container.name, \ 
     69            self.view.hud.createBoxGUI(self.container.name, \ 
    6470                                              self.container) 
    6571 
    6672        except ValueError: 
    67             self.engine.view.hud.createExamineBox(self.container.name, \ 
     73            self.view.hud.createExamineBox(self.container.name, \ 
    6874                                                  "The container is locked") 
    6975         
     
    9399class ExamineBoxAction(Action): 
    94100    """Examine a box. Needs to be more generic, but will do for now.""" 
    95     def __init__(self, engine, examine_name, examine_desc): 
    96         """@type engine: Engine reference 
    97            @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 
    98106           @type examine_name: String 
    99107           @param examine_name: Name of the object to be examined. 
     
    101109           @param examine_name: Description of the object to be examined.""" 
    102110        Action.__init__(self) 
    103         self.engine = engine 
     111        self.model = model 
     112        self.view = view 
    104113        self.examine_name = examine_name 
    105114        self.examine_desc = examine_desc 
     
    107116    def execute(self): 
    108117        """Examine the box.""" 
    109         self.engine.view.hud.createExamineBox(self.examine_name, \ 
     118        self.view.hud.createExamineBox(self.examine_name, \ 
    110119                                              self.examine_desc) 
    111120 
    112121class TalkAction(Action): 
    113122    """An action to represent starting a dialogue""" 
    114     def __init__(self, engine, npc): 
    115         """@type engine: Engine reference 
    116            @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 
    117128           @type npc: NonPlayerCharacter 
    118129           @param npc: NPC to interact with.""" 
    119130        Action.__init__(self) 
    120         self.engine = engine 
     131        self.model = model 
     132        self.view = view 
    121133        self.npc = npc 
    122134         
     
    125137           @return: None""" 
    126138       
    127         pc = self.engine.game_state.PC 
     139        pc = self.model.game_state.PlayerCharacter 
    128140        npc_coordinates = self.npc.getLocation().getLayerCoordinates() 
    129141        pc_coordinates = pc.behaviour.agent.getLocation().getLayerCoordinates() 
     
    140152                         self.npc.getLocation().\ 
    141153                         getLayerCoordinates().y], \ 
    142                         TalkAction(self.engine,\ 
     154                        TalkAction(self.model,\ 
    143155                                   self.npc))         
    144156        else: 
     
    147159            if self.npc.dialogue is not None: 
    148160                self.npc.talk(pc) 
    149                 self.engine.view.hud.showDialogue(self.npc) 
     161                self.view.hud.showDialogue(self.npc) 
    150162            else: 
    151163                self.npc.behaviour.agent.say("Leave me alone!", 1000) 
    152164                 
    153             self.engine.game_state.PC.behaviour.idle() 
    154             self.engine.game_state.PC.nextAction = None 
     165            self.model.game_state.PlayerCharacter.behaviour.idle() 
     166            self.model.game_state.PlayerCharacter.nextAction = None 
  • branches/code-cleanup-and-refactoring/game/scripts/parpg.py

    r550 r552  
    4444           @type gamesceneview: gamesceneview.GameSceneView 
    4545           @param gamesceneview: ??? 
    46            @type fife_model: engine.GameModel 
    47            @param fife_model: an instance of PARPG's engine""" 
     46           @type model: script.GameModel 
     47           @param model: The game model""" 
    4848        super(ApplicationListener, self).__init__(engine, 
    4949                                                  reg_keys=True,reg_cmd=True, 
     
    5353        self.engine = engine 
    5454        self.view = world 
    55         self.fife_model = model 
     55        self.model = model 
    5656        keyfilter = KeyFilter([fife.Key.ESCAPE]) 
    5757        keyfilter.__disown__()         
     
    8888class PARPGApplication(ApplicationBase): 
    8989    """Main Application class 
    90        We use an MVC fife_model fife_model. 
    91        self.gamesceneview is our view,self.fife_model is our fife_model 
    92        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""" 
    9393    def __init__(self, setting): 
    9494        """Initialise the instance. 
    9595           @return: None""" 
    9696        super(PARPGApplication, self).__init__(setting) 
    97         self.view = gamesceneview.GameSceneView(self.engine) 
    98         self.fife_model = gamemodel.GameModel(self.view) 
     97        #self.engine.getModel(self) 
     98        self.model = gamemodel.GameModel(self.engine) 
     99        self.view = gamesceneview.GameSceneView(self.engine, self.model) 
    99100        self.controller = gamescenecontroller.GameSceneController(self.engine,  
    100101                                                        self.view,  
    101                                                         self.fife_model,  
     102                                                        self.model,  
    102103                                                        self, 
    103104                                                        setting) 
    104         self.fife_model.readObjectDB(self._setting.get("PARPG",  
     105        self.model.readObjectDB(self._setting.get("PARPG",  
    105106                                                  "ObjectDatabaseFile")) 
    106         self.view.fife_model = self.fife_model 
    107107        self.controller.initHud() 
    108108        self.listener = ApplicationListener(self.engine,  
    109109                                            self.view,  
    110                                             self.fife_model) 
    111         self.fife_model.loadMap("main-map", str(self._setting.get("PARPG",  
     110                                            self.model) 
     111        self.model.loadMap("main-map", str(self._setting.get("PARPG",  
    112112                                                             "MapFile"))) 
    113113        pychan.init(self.engine, debug = True) 
     
    126126            self.breakRequested = True 
    127127        else: 
    128             self.fife_model.pump() 
    129128            self.controller.pump() 
Note: See TracChangeset for help on using the changeset viewer.