Changeset 553 for trunk/game/scripts


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

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

Location:
trunk
Files:
2 deleted
14 edited
5 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/game/scripts/console.py

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

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

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

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

    r541 r553  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import shutil 
    19 from fife import fife 
    2018from fife.extensions import pychan 
    2119from fife.extensions.pychan.tools import callbackWithArguments as cbwa 
    22 from fife.extensions.pychan import widgets 
    2320 
    2421from scripts.gui.filebrowser import FileBrowser 
     
    3027class Hud(object): 
    3128    """Main Hud class""" 
    32     def __init__(self, engine, settings, data, callbacks): 
     29    def __init__(self, engine, settings, model, callbacks): 
    3330        """Initialise the instance. 
    3431           @type engine: fife.Engine 
    3532           @param engine: An instance of the fife engine 
    3633           @type settings: settings.Setting 
    37            @param settings: The settings data 
     34           @param settings: The settings 
    3835           @type inv_model: dict 
    3936           @type callbacks: dict 
     
    4946        self.engine = engine 
    5047        self.settings = settings 
    51         self.data = data 
     48        self.model = model 
    5249        self.inventory = None 
    5350 
     
    5855        self.box_container = None 
    5956        self.examine_box = None 
    60  
     57        self.context_menu = None 
     58        self.help_dialog = None 
     59        self.events_to_map = None 
     60        self.main_menu = None 
     61        self.menu_events = None 
     62        self.quit_window = None 
     63         
    6164        self.actions_box = self.hud.findChild(name="actionsBox") 
    6265        self.actions_text = [] 
     
    7376        """Initialize and show the main HUD 
    7477           @return: None""" 
    75         self.events_to_map = {"menuButton":self.displayMenu,} 
     78        self.events_to_map = {"menuButton":self.displayMenu, } 
    7679        self.hud.mapEvents(self.events_to_map)  
    7780        # set HUD size according to screen size 
     
    130133 
    131134    def initializeInventory(self): 
     135        """Initialize the inventory""" 
    132136        inv_callbacks = { 
    133137            'refreshReadyImages': self.refreshReadyImages, 
    134138            'toggleInventoryButton': self.toggleInventoryButton, 
    135139        } 
    136         self.inventory_storage = self.data.game_state.PC.inventory 
     140        self.inventory_storage = self.model.game_state.PlayerCharacter.inventory 
    137141        if self.inventory == None: 
    138142            self.inventory = inventorygui.InventoryGUI(self.engine, 
     
    144148        """Initialize the Context Menu 
    145149           @return: None""" 
    146         self.context_menu = ContextMenu (self.engine, [], (0,0)) 
     150        self.context_menu = ContextMenu (self.engine, [], (0, 0)) 
    147151        self.context_menu.hide() 
    148152 
    149153    def showContextMenu(self, data, pos): 
    150         """Display the Context Menu with data at pos 
    151            @type data: list 
    152            @param data: data to pass to context menu 
     154        """Display the Context Menu with model at pos 
     155           @type model: list 
     156           @param model: model to pass to context menu 
    153157           @type pos: tuple 
    154158           @param pos: tuple of x and y coordinates 
     
    221225        self.help_dialog.show() 
    222226 
    223     def switchResolutions(self): 
    224         """ Sync the contents of the resolution box (windowed or fullscreen 
    225             resolutions to the selection made in the Fullscreen checkbox. 
    226             @return: None""" 
    227              
    228         if self.options_menu.collectData('FullscreenBox'): 
    229             self.options_menu.distributeInitialData({ 
    230                                 'ResolutionBox' : self.resolutions_fullscreen 
    231                                                      }) 
    232         else: 
    233             self.options_menu.distributeInitialData({ 
    234                                 'ResolutionBox' : self.resolutions_windowed 
    235                                                      }) 
    236          
    237  
    238  
    239227    def saveGame(self): 
    240228        """ Called when the user wants to save the game. 
     
    306294            button.toggled = 0 
    307295 
    308     def toggleInventory(self, toggleImage=True): 
     296    def toggleInventory(self, toggle_image=True): 
    309297        """Displays the inventory screen 
    310298           @return: None""" 
    311299        if self.inventory == None: 
    312300            self.initializeInventory() 
    313         self.inventory.toggleInventory(toggleImage) 
     301        self.inventory.toggleInventory(toggle_image) 
    314302 
    315303    def refreshReadyImages(self): 
     
    317305           on the inventory 
    318306           @return: None""" 
    319         for ready in range(1,5): 
     307        for ready in range(1, 5): 
    320308            button = self.hud.findChild(name=("hudReady%d" % ready)) 
    321309            if self.inventory_storage == None : 
    322310                origin = None 
    323311            else: 
    324                origin = self.inventory_storage.getItemsInSlot('ready', ready-1) 
     312                origin = self.inventory_storage.getItemsInSlot('ready', ready-1) 
    325313            if origin == None: 
    326                 self.setImages(button, self.inventory.slot_empty_images['ready']) 
     314                self.setImages(button,  
     315                               self.inventory.slot_empty_images['ready']) 
    327316            else: 
    328                 self.setImages(button,origin.getInventoryThumbnail()) 
     317                self.setImages(button, origin.getInventoryThumbnail()) 
    329318 
    330319    def setImages(self, widget, image): 
     
    364353        self.main_menu.mapEvents(menu_events) 
    365354 
    366     def updateVolumeText(self): 
    367         """Update the initial volume label to the value of the slider""" 
    368         volume = float(self.options_menu.collectData("InitialVolumeSlider")) 
    369         volume_label = self.options_menu.findChild(name="InitialVolumeLabel") 
    370         volume_label.text = unicode("Initial Volume: %.0f%s" % 
    371                                     (int(volume*10), "%")) 
    372  
    373355    def setOption(self, name, value): 
    374356        """Set an option within the xml. 
     
    384366        else: 
    385367            print 'Setting,', name, 'does not exist!' 
    386  
    387     def setToDefaults(self): 
    388         """Reset all the options to the options in settings-dist.xml. 
    389            @return: None""" 
    390         shutil.copyfile('settings-dist.xml', 'settings.xml') 
    391         self.requireRestartDialog() 
    392         self.options_menu.hide() 
    393368     
    394369    def readyAction(self, ready_button): 
     
    445420        dialogue = DialogueGUI( 
    446421                    npc, 
    447                     self.data.game_state.quest_engine, 
    448                     self.data.game_state.PC) 
     422                    self.model.game_state.quest_engine, 
     423                    self.model.game_state.PlayerCharacter) 
    449424        dialogue.initiateDialogue() 
  • trunk/game/scripts/gui/inventorygui.py

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

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

    r541 r553  
    1717 
    1818from fife import fife 
    19 import time 
    2019from local_loaders.loaders import loadMapFile 
    21 from scripts.common.eventlistenerbase import EventListenerBase 
    2220from fife.extensions.fife_settings import Setting 
    2321 
     
    3331        self.map = None 
    3432        self.engine = engine 
    35         self.data = data 
     33        self.model = data 
    3634 
    3735        # init map attributes 
     
    4038        self.agent_layer = None 
    4139        self.top_layer = None 
    42         self.model = engine.getModel() 
     40        self.fife_model = engine.getModel() 
    4341        self.transitions = [] 
    4442        self.cur_cam2_x = 0 
     
    4947         
    5048    def reset(self): 
    51         """Reset the data to default settings. 
     49        """Reset the model to default settings. 
    5250           @return: None""" 
    5351        # We have to delete the map in Fife. 
     
    8078           @return: None""" 
    8179        self.reset() 
    82         self.map = loadMapFile(filename, self.engine, self.data) 
     80        self.map = loadMapFile(filename, self.engine, self.model) 
    8381        self.agent_layer = self.map.getLayer('ObjectLayer') 
    8482        self.top_layer = self.map.getLayer('TopLayer') 
    8583         
    86         #find out if a PC instance was created when the map was loaded 
     84        #find out if a PlayerCharacter instance was created when the map was loaded 
    8785        found = False 
     86        inst = None 
    8887        for inst in self.agent_layer.getInstances(): 
    8988            if inst.getId() == "PC": 
     
    9190                break 
    9291                 
    93         #If there is not a PC instance created yet than we construct the PC 
    94         #instance from what we have saved in the PC Game Object 
     92        #If there is not a PlayerCharacter instance created yet than we construct the PlayerCharacter 
     93        #instance from what we have saved in the PlayerCharacter Game Object 
    9594        if not found: 
    96             x = float(self.data.target_position[0]) 
    97             y = float(self.data.target_position[1]) 
     95            x = float(self.model.target_position[0]) 
     96            y = float(self.model.target_position[1]) 
    9897            z = 0 
    99             pc_obj = self.model.getObject("player", "PARPG") 
    100             inst = self.agent_layer.createInstance(pc_obj,\ 
    101                                             fife.ExactModelCoordinate(x,y,z),\ 
     98            pc_obj = self.fife_model.getObject("player", "PARPG") 
     99            inst = self.agent_layer.createInstance(pc_obj, \ 
     100                                            fife.ExactModelCoordinate( 
     101                                                                      x, 
     102                                                                      y, 
     103                                                                      z), 
    102104                                            "PC") 
    103105            fife.InstanceVisual.create(inst) 
    104         #If the PC instance exists already then make sure it's set to correct 
     106        #If the PlayerCharacter instance exists already then make sure it's set to correct 
    105107        #location for this new map 
    106         elif self.data.target_position is not None: 
    107             pos = self.data.target_position 
     108        elif self.model.target_position is not None: 
     109            pos = self.model.target_position 
    108110            coord = fife.DoublePoint3D(float(pos[0]), float(pos[1]), 0) 
    109111            location = fife.Location(self.agent_layer) 
    110112            location.setMapCoordinates(coord) 
    111113            inst.setLocation(location) 
    112         #else we are loading the first map and the PC position were set by 
     114        #else we are loading the first map and the PlayerCharacter position were set by 
    113115        #the coordinates in the Map file 
    114116             
     
    128130            width = self.engine.getSettings().getScreenWidth() 
    129131            height = self.engine.getSettings().getScreenHeight()  
    130             viewport = fife.Rect(0,0,width,height) 
     132            viewport = fife.Rect(0, 0, width, height) 
    131133            cam.setViewPort(viewport) 
    132134            self.my_cam_id = cam.getId() 
     
    136138        self.target_rotation = self.cameras[self.my_cam_id].getRotation() 
    137139 
    138         self.outline_render = fife.InstanceRenderer.\ 
    139                                         getInstance(self.cameras[self.my_cam_id]) 
     140        self.outline_renderer = fife.InstanceRenderer.\ 
     141                                        getInstance( 
     142                                                    self.cameras[ 
     143                                                                 self.my_cam_id 
     144                                                                 ]) 
    140145 
    141146        # set the render text 
    142         rend = fife.FloatingTextRenderer.getInstance(self.cameras[self.my_cam_id]) 
     147        rend = fife.FloatingTextRenderer.getInstance(self.cameras[ 
     148                                                                  self.my_cam_id 
     149                                                                  ]) 
    143150        text = self.engine.getGuiManager().\ 
    144151                        createFont('fonts/rpgfont.png', 0, \ 
     
    146153        rend.changeDefaultFont(text) 
    147154        rend.activateAllLayers(self.map) 
    148           
    149         # Activate the grid renderer on all layers 
    150         rend = self.cameras['map_camera'].getRenderer('GridRenderer') 
    151         rend.activateAllLayers(self.map) 
     155         
     156        # Activate the grid renderer on all layers 
     157        rend = self.cameras['map_camera'].getRenderer('GridRenderer') 
     158        rend.activateAllLayers(self.map) 
    152159          
    153160        # Make World aware that this is now the active map. 
    154         self.data.view.active_map = self 
     161        self.model.active_map = self 
    155162 
    156163    def addPC(self): 
    157164        """Add the player character to the map 
    158165           @return: None""" 
    159         # Update gamestate.PC 
    160         self.data.game_state.PC.behaviour.onNewMap(self.agent_layer) 
     166        # Update gamestate.PlayerCharacter 
     167        self.model.game_state.PlayerCharacter.behaviour.onNewMap(self.agent_layer) 
    161168 
    162169        # actually this is real easy, we just have to 
    163         # attach the main camera to the PC, if a camera 
     170        # attach the main camera to the PlayerCharacter, if a camera 
    164171        # was already used, we simply recycle it.  
    165172        if self.cameras[self.my_cam_id].getAttached() == None: 
    166             self.cameras[self.my_cam_id].attach(self.data.game_state.PC.behaviour.agent) 
     173            self.cameras[self.my_cam_id].attach(self.model.game_state. 
     174                                                PlayerCharacter.behaviour.agent) 
    167175 
    168176    def toggleRenderer(self, r_name): 
  • trunk/game/scripts/objects/action.py

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

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

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

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

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