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

Cleanup and refactoring continues

File:
1 moved

Legend:

Unmodified
Added
Removed
  • branches/code-cleanup-and-refactoring/game/scripts/gameview.py

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