Changeset 150


Ignore:
Timestamp:
06/19/09 07:50:22 (10 years ago)
Author:
maximinus_parpg
Message:

Added tZee's patch.
Some other minor editing.

Location:
trunk/PARPG
Files:
2 added
1 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/PARPG/maps/map2_objects.xml

    r148 r150  
    1313    <!-- There can be a number of doors, which serve as transition triggers --> 
    1414    <door display="True" gfx="grass-a" xpos="-14" ypos="-17" 
    15           id="tt01" carry="0" contain="0" text="Start Map" map="map" 
     15          id="tt02" carry="0" contain="0" text="Start Map" map="maps/map.xml" 
    1616          txpos="-14" typos="9"></door> 
    1717</objects> 
  • trunk/PARPG/maps/map_objects.xml

    r148 r150  
    2626    <!-- There can be a number of doors, which serve as transition triggers --> 
    2727    <door display="True" gfx="shanty-door" xpos="-2.0" ypos="6.0" 
    28         id="sh-door" text="Enter building" map="shanty" 
     28        id="sh-door" text="Enter building" map="maps/shanty.xml" 
    2929        txpos="-1" typos="1"></door> 
    3030    <door display="True" gfx="snow02" xpos="-14" ypos="10" 
    31         id="tt01" text="New Map" map="map2" 
     31        id="tt01" text="New Map" map="maps/map2.xml" 
    3232        txpos="-14" typos="-16"></door> 
    3333</objects> 
  • trunk/PARPG/maps/shanty_objects.xml

    r147 r150  
    99    <!-- There can be a number of doors, which serve as transition triggers --> 
    1010    <door display="True" gfx="fdoor" xpos="-1.0" ypos="2.0" 
    11         id="sh-door" text="Exit building" map="map" txpos="-2" typos="7"></door> 
     11        id="sh-door2" text="Exit building" map="maps/map.xml" txpos="-2" typos="7"></door> 
    1212</objects> 
    1313 
  • trunk/PARPG/objects/agents/player/player.xml

    r96 r150  
    1010                <animation source="stand/animation.xml" direction="0" /> 
    1111        </action> 
     12        <action id="approachDoor"> 
     13                <animation source="stand/animation.xml" direction="0" /> 
     14        </action> 
    1215</object> 
  • trunk/PARPG/run.py

    r148 r150  
    8484        self.listener = ApplicationListener(self.engine,self.world) 
    8585        self.world.quitFunction = self.listener.quitGame 
    86         self.model.loadMap(str(TDS.readSetting("MapFile")), False)    
     86        self.model.loadMap(str(TDS.readSetting("MapFile")))    
    8787 
    8888    def loadSettings(self): 
     
    136136            self.breakRequested = True 
    137137        else: 
     138            self.model.pump() 
    138139            self.world.pump() 
    139140 
  • trunk/PARPG/scripts/agents/hero.py

    r148 r150  
    2121 
    2222class Hero(fife.InstanceActionListener): 
    23     def __init__(self, agentName, layer): 
     23    def __init__(self, agentName, layer, engine): 
    2424        """This is the class we use for the PC character. 
    2525           @type agentName: string 
    2626           @param agentName: name of the agent 
    2727           @type layer: string 
    28            @param layer: Layer to place agent on 
     28           @param layer: Layer to place agent on. 
     29           @type engine: scripts.engine.Engine 
     30           @param engine: Reference to the engine that owns this PC. 
    2931           @return: None""" 
    3032        # add this class for callbacks from fife itself 
     
    3638        self.idlecounter = 1 
    3739        self.speed = float(TDS.readSetting("PCSpeed")) 
     40        self.engine = engine 
     41         
     42    def onNewMap(self, layer): 
     43        """Sets the agent onto the new layer. 
     44        """ 
     45        self.agent = layer.getInstance(self.agentName) 
     46        self.agent.addActionListener(self) 
     47        self.state = _STATE_NONE 
     48        self.idlecounter = 1 
    3849 
    3950    def getX(self): 
     
    5566           @param action: ??? 
    5667           @return: None""" 
     68        if action.getId() == 'approachDoor': 
     69            # issue map change 
     70            self.engine.changeMap(self.targetMap, self.targetLocation) 
     71         
    5772        self.idle() 
    5873        if(action.getId() != 'stand'): 
     
    7792        self.agent.move('run', location, self.speed) 
    7893 
     94    def approachDoor(self, doorLocation, map, targetLocation): 
     95        """Approach a door and then teleport to the new map. 
     96           @type doorLocation: fife.ScreenPoint 
     97           @param doorLocation: ??? 
     98           @type map: ??? 
     99           @param map: ??? 
     100           @type targetLocation: ??? 
     101           @param targetLocation: ??? 
     102           @return: None""" 
     103        self.state = _STATE_RUN 
     104        self.targetMap = map 
     105        self.targetLocation = targetLocation 
     106        self.agent.move('approachDoor', doorLocation, self.speed) 
  • trunk/PARPG/scripts/context_menu.py

    r147 r150  
    1717 
    1818import fife, pychan 
     19from pychan.tools import callbackWithArguments 
    1920 
    2021class ContextMenu(): 
     
    3536            p = pychan.widgets.Button(name=item[0], text=unicode(item[1])) 
    3637            self.vbox.addChild(p) 
    37             events_to_map[item[0]] = item[2] 
     38            if item[3]: 
     39                events_to_map[item[0]] = callbackWithArguments(item[2], item[3]) 
     40            else: 
     41                events_to_map[item[0]] = item[2] 
    3842        self.vbox.mapEvents(events_to_map) 
    3943        self.vbox.show() 
  • trunk/PARPG/scripts/engine.py

    r148 r150  
    2323from saver import Saver 
    2424import pickle 
     25from gamestate import GameState 
     26from gamedata import * 
    2527 
    2628# design note: 
     
    4749           @return: None""" 
    4850        self.id = name 
    49         self.map = "maps/"+new_map+".xml" 
     51        self.map = new_map 
    5052        # location is an (int, int) which stores the intended location  
    5153        # of the PC on the new map 
     
    5860       the fife view here. This also prevents us from just having a 
    5961       function heavy controller.""" 
     62     
    6063    def __init__(self, view): 
    6164        """Initialise the instance. 
     
    6568        # a World object 
    6669        self.view = view 
     70        self.gameState = GameState() 
     71        self.doors = {} 
     72        self.objects = [] 
     73        self.npcs = [] 
     74        self.PC = None 
     75        self.mapchange = False 
     76 
     77    def reset(self): 
     78        """Clears the data on a map reload so we don't have objects/npcs from 
     79           other maps hanging around. 
     80           @return: None""" 
    6781        self.PC = None 
    6882        self.npcs = [] 
    6983        self.objects = [] 
    70         self.doors = [] 
    71         self.PC_targLoc = None 
    72         self.saver = Saver() 
    73  
    74     def reset(self): 
    75         """Clears the data on a map reload so we don't have objects/npcs from 
    76            other maps hanging around. 
    77            @return: None""" 
    78         self.PC = None 
    79         self.npcs = [] 
    80         self.objects = [] 
    81         self.doors = [] 
     84        self.doors = {} 
    8285 
    8386    def save(self, filename): 
    84         """ Writes the saver to a file. 
    85             @type filename: string 
    86             @param filename: the name of the file to write to 
    87             @return: None""" 
    88         self.updateSaver() 
     87        """Writes the saver to a file. 
     88           @type filename: string 
     89           @param filename: the name of the file to write to 
     90           @return: None""" 
     91        self.updateGameState() 
    8992        f = open(filename, 'w') 
    90         pickle.dump(self.saver, f) 
     93        pickle.dump(self.gameState, f) 
    9194        f.close() 
    9295 
    9396    def load(self, filename): 
    94         """ Loads a saver from a file. 
    95             @type filename: string 
    96             @param filename: the name of the file to load from 
    97             @return: None""" 
     97        """Loads a saver from a file. 
     98           @type filename: string 
     99           @param filename: the name of the file to load from 
     100           @return: None""" 
    98101        f = open(filename, 'r') 
    99         self.saver = pickle.load(f) 
     102        self.gameState = pickle.load(f) 
    100103        f.close() 
    101         self.loadMap(self.saver.curMap+'.xml', False) 
    102  
    103     def updateSaver(self): 
    104         """ Saves existing object/npc/door/pc data to the saver by calling 
    105             the saver's update functions. 
    106             @return: None""" 
    107         # TODO: add calls to other functions and write those functions for  
    108         # other bits of state that change. For now, the only one we can do is 
    109         # NPC info 
    110         self.saver.updatePC(self.PC) 
    111         self.saver.updateNPCs(self.npcs) 
     104        if self.gameState.currentMap: 
     105            self.loadMap(self.gameState.currentMap) 
     106             
     107    def updateGameState(self): 
     108        """Stores the current npcs positons in the game state.""" 
     109        #save the PC position 
     110        self.gameState.PC.posx = self.PC.getX() 
     111        self.gameState.PC.posy = self.PC.getY() 
     112        #save npc positions 
     113        for i in self.npcs: 
     114            if str(i.id) in self.gameState.objects: 
     115                self.gameState.getObjectById(str(i.id)).posx = i.getX() 
     116                self.gameState.getObjectById(str(i.id)).posy = i.getY() 
    112117 
    113118    def loadObjects(self, filename): 
     
    138143        self.addObjects(cur_handler.objects) 
    139144        self.addDoors(cur_handler.doors) 
    140         # Save the initial map state 
    141         self.saver.addData(cur_handler.pc, cur_handler.npcs, \ 
    142                 cur_handler.objects, cur_handler.doors) 
    143145        return True 
    144     
    145     def loadFromSaved(self, data): 
    146         """ Loads objects from a previously stored SavedData object. 
    147             @type data: saver.SavedData 
    148             @param data: The stored entry from which to get information 
    149             @return: None""" 
    150         self.addPC(data.PC) 
    151         self.addNPCs(data.getList("npcs")) 
    152         self.addObjects(data.getList("objects")) 
    153         self.addDoors(data.getList("doors")) 
    154146 
    155147    def addPC(self,pc): 
     
    158150           @param pc: List of data for PC attributes 
    159151           @return: None""" 
    160         if self.PC_targLoc: 
    161             self.view.addObject(float(self.PC_targLoc[0]), \ 
    162                     float(self.PC_targLoc[1]), "PC", "PC") 
    163             self.PC_targLoc = None 
     152        # sync with game data 
     153        posx, posy = 0, 0 
     154        if self.gameState.PC: 
     155            # use existing position 
     156            posx = self.gameState.PC.posx 
     157            posy = self.gameState.PC.posy 
    164158        else: 
    165             self.view.addObject(float(pc[0]), float(pc[1]),"PC","PC") 
    166         self.PC = Hero("PC", self.view.agent_layer) 
    167         # ensure the PC starts on a default action 
     159            posx = pc[0] 
     160            posy = pc[1] 
     161            # save the new PC to the game data 
     162            self.gameState.PC = HeroData("PC", posx, posy, "PC", self.gameState.currentMap) 
     163             
     164        self.view.addObject(float(posx), float(posy),"PC","PC") 
     165         # create the PC agent 
     166        self.PC = Hero("PC", self.view.agent_layer, self) 
    168167        self.PC.start() 
    169168        self.view.addPC(self.PC.agent) 
     
    176175           @return: None""" 
    177176        for i in objects: 
     177            # add it to the game state 
     178            ref = self.gameState.getObjectById(i.id)  
     179            if ref is None: 
     180                i.map = self.gameState.currentMap 
     181                self.gameState.objects[str(i.id)] = i 
     182            else: 
     183                # use the current game state data 
     184                i.posx = ref.posx 
     185                i.posy = ref.posy 
     186                i.gfx = ref.gfx         
    178187            # is it visible? 
    179             if(i[0] == True): 
    180                 self.view.addObject(float(i[1]), float(i[2]), i[3], i[4]) 
    181             # now add it as an engine object 
    182             self.objects.append(GameObject(i)) 
     188            if(i.display): 
     189                self.view.addObject(i.posx, i.posy, i.gfx, i.id) 
    183190 
    184191    def addNPCs(self,npcs): 
     
    188195           @return: None""" 
    189196        for i in npcs: 
    190             self.view.addObject(float(i[0]), float(i[1]), i[2], i[3]) 
    191             # now add as engine data 
    192             self.npcs.append(NPC(i[4], str(i[3]), self.view.agent_layer)) 
     197            # add it to the game state 
     198            ref = self.gameState.getObjectById(i.id)  
     199            if ref is None: 
     200                i.map = self.gameState.currentMap 
     201                self.gameState.objects[i.id] = i 
     202            else: 
     203                # use the current game state data 
     204                i.posx = ref.posx 
     205                i.posy = ref.posy 
     206                i.gfx = ref.gfx               
     207            # add it to the view 
     208            self.view.addObject(i.posx, i.posy, i.gfx, i.id)           
     209            # create the agent 
     210            self.npcs.append(NPC(i.text, str(i.id), self.view.agent_layer)) 
    193211            self.npcs[-1].start() 
    194212 
     
    200218           @return: None""" 
    201219        for i in doors: 
    202             self.doors.append(MapDoor(i[0], i[1], i[2])) 
     220            self.doors[str(i.id)] = MapDoor(i.id, i.destmap, (i.destx, i.desty)) 
    203221 
    204222    def objectActive(self, ident): 
     
    209227           @rtype: boolean 
    210228           @return: Status of result (True/False)""" 
    211         for i in self.objects: 
    212             if((i.display == True)and(i.id == ident)): 
     229        for i in self.gameState.getObjectsFromMap(self.gameState.currentMap): 
     230            if i.display and (i.id == ident): 
    213231                # we found a match 
    214                 return i 
    215         # now try NPC's 
    216         for i in self.npcs: 
    217             # all NPC's are deemed active 
    218             if(i.id == ident): 
    219                 return i 
     232                return i          
    220233        # no match 
    221234        return False 
     
    230243        # note: ALWAYS check NPC's first! 
    231244        # is it an NPC? 
    232         for i in self.npcs: 
     245        for i in self.gameState.getObjectsFromMap(self.gameState.currentMap): 
    233246            if(obj_id == i.id): 
    234                 # keep it simple for now 
    235                 actions.append(("Talk",None)) 
    236                 actions.append(("Attack",None))      
    237         # is it a door? 
    238         for i in self.doors: 
    239             if(obj_id == i.id): 
    240                 # load the new map 
    241                 self.PC_targLoc = i.targ_coords 
    242                 self.loadMap(str(i.map), True) 
    243                 return None 
    244         # is it in our objects? 
    245         for i in self.objects: 
    246             if(obj_id == i.id): 
    247                 actions.append(("Examine",None)) 
    248                 # is it a container? 
    249                 if(i.container == True): 
    250                     actions.append(("Open",None)) 
    251                 # can you pick it up? 
    252                 if(i.carry == True): 
    253                     actions.append(("Pick Up",None)) 
    254                 #return actions 
    255         #return actions 
    256  
    257     def loadMap(self, map_file, update): 
     247                if isinstance(i, NpcData): 
     248                    # keep it simple for now, None to be replaced by callbacks 
     249                    actions.append(["Talk", "Talk", self.nullFunc, i]) 
     250                    actions.append(["Attack", "Attack", self.nullFunc, i])  
     251                elif isinstance(i, DoorData): 
     252                    return self.doors[str(i.id)] 
     253                elif isinstance(i, NonLivingObjectData): 
     254                    actions.append(["Examine", "Examine", self.nullFunc, i]) 
     255                    # is it a container? 
     256                    if(i.container == True): 
     257                        actions.append(["Open", "Open", self.nullFunc, i]) 
     258                    # can you pick it up? 
     259                    if(i.carryable == True): 
     260                        actions.append(["Pick Up", "Pick Up", self.nullFunc, i])        
     261        return actions 
     262     
     263    def nullFunc(self, userdata): 
     264        """Sample callback for the context menus.""" 
     265        print userdata 
     266 
     267    def loadMap(self, map_file): 
    258268        """Load a new map. TODO: needs some error checking 
    259269           @type map_file: string 
    260270           @param map_file: Name of map file to load 
    261            @type update: bool 
    262            @param update: whether or not to update the saver 
    263            @return: None""" 
    264         # first we update anything that has to be updated (npcs, objects, etc) 
    265         if update: 
    266             self.updateSaver() 
     271           @return: None""" 
    267272        # then we let FIFE load the rest of the map 
    268         self.view.load(map_file) 
     273        self.view.load(str(map_file)) 
    269274        # then we update FIFE with the PC, NPC and object details 
    270275        self.reset() 
    271         # we set the current map in the saver 
    272         self.saver.setCurMap(map_file[:-4]) 
    273         # we have to check if we have saved a previous version of this filename 
    274         savedData = self.saver.getData(map_file[:-4]) 
    275         # then we update FIFE with the PC, NPC and object details 
    276         if savedData: 
    277             self.loadFromSaved(savedData) 
    278         else: 
    279             self.loadObjects(map_file[:-4]+"_objects.xml") 
     276        self.gameState.currentMap = map_file 
     277        self.loadObjects(map_file[:-4] + "_objects.xml") 
    280278 
    281279    def handleMouseClick(self,position): 
     
    285283           @return: None""" 
    286284        self.PC.run(position) 
     285         
     286    def changeMap(self, map, targetPosition): 
     287        """Registers for a mapchange on the next pump(). 
     288           @type map: ??? 
     289           @param map: Name of the target map. 
     290           @type targetPosition: ??? 
     291           @param targetPosition: Position of PC on target map. 
     292           @return: None""" 
     293        # save the postions 
     294        self.updateGameState() 
     295        # set the PC position 
     296        self.gameState.PC.posx = targetPosition[0] 
     297        self.gameState.PC.posy = targetPosition[1] 
     298        # set the parameters for the mapchange 
     299        self.targetMap = map 
     300        # issue the mapchange 
     301        self.mapchange = True 
     302 
     303    def handleCommands(self): 
     304        if self.mapchange: 
     305            self.loadMap(self.targetMap) 
     306            self.mapchange = False 
     307 
     308    def pump(self): 
     309        """Main loop in the engine.""" 
     310        self.handleCommands() 
     311 
  • trunk/PARPG/scripts/objLoader.py

    r147 r150  
    1919from xml.sax.handler import ContentHandler 
    2020import sys 
     21from gamedata import * 
    2122 
    2223class LocalXMLParser(ContentHandler): 
     
    4546        try: 
    4647            display = attrs.getValue("display") 
     48            xpos, ypos = 0, 0 
     49            owner = None 
    4750            if(display == "True"): 
    4851                xpos = attrs.getValue("xpos") 
     
    5962            sys.exit(False) 
    6063        # now we have the data, save it for later 
    61         if(display == "True"): 
    62             self.objects.append([True, xpos, ypos, gfx, ident, 
    63                                  text, contain, carry]) 
    64         else: 
    65             self.objects.append([False, gfx, ident, text, 
    66                                  owner, contain, carry]) 
     64        self.objects.append(NonLivingObjectData(str(ident), float(xpos), 
     65                            float(ypos), str(text), None, str(gfx), 
     66                            str(display) == "True", str(owner), 
     67                            str(contain) == "1", str(carry) == "1")) 
    6768 
    6869    def getDoor(self, attrs): 
     
    7374        try: 
    7475            display = attrs.getValue("display") 
     76            xpos, ypos, xdest, ydest = 0, 0, 0, 0 
     77            owner = None 
    7578            if(display == "True"): 
    7679                xpos = attrs.getValue("xpos") 
     
    7881            else: 
    7982                owner = attrs.getValue("owner") 
     83            xdest = attrs.getValue("txpos") 
     84            ydest = attrs.getValue("typos") 
    8085            gfx = attrs.getValue("gfx") 
    8186            ident = attrs.getValue("id") 
    8287            text = attrs.getValue("text") 
     88            map = attrs.getValue("map") 
    8389        except(KeyError): 
    8490            sys.stderr.write("Error: Data missing in door definition\n") 
    8591            sys.exit(False) 
    8692        # now we have the data, save it for later 
    87         if(display == "True"): 
    88             self.objects.append([True, xpos, ypos, gfx, ident, 
    89                                  text, "0", "0"]) 
    90         else: 
    91             self.objects.append([False, gfx, ident, text, 
    92                                  owner, "0", "0"]) 
     93        door = DoorData(ident, xpos, ypos, text, None, gfx, display == "True", 
     94                        owner, xdest, ydest, map) 
     95        self.objects.append(door) 
     96        self.doors.append(door) 
    9397 
    9498    def startElement(self, name, attrs): 
     
    126130                sys.exit(False) 
    127131            # now we have the data, save it for later 
    128             self.npcs.append([xpos, ypos, gfx, ident, text]) 
     132            self.npcs.append(NpcData(ident, xpos, ypos, text, None, gfx, True)) 
    129133        elif(name == "object"): 
    130134            # same old same old 
     
    133137            # firstly, add the object 
    134138            self.getDoor(attrs) 
    135             # then save the other data 
    136             try: 
    137                 new_map = attrs.getValue("map") 
    138                 txpos = attrs.getValue("txpos") 
    139                 typos = attrs.getValue("typos") 
    140             except(KeyError): 
    141                 sys.stderr.write("Error: Door has no map or no target!\n") 
    142                 sys.exit(False) 
    143             # format is [id,map_name,target coords on new map] 
    144             self.doors.append([self.objects[-1][4],new_map, \ 
    145                     tuple([txpos, typos])]) 
    146139 
  • trunk/PARPG/scripts/sounds.py

    r147 r150  
    6666           @param volume: The volume wanted, 0 to 100 
    6767           @return: None""" 
    68         pass 
     68        self.sound_engine.setVolume(0.01*volume) 
    6969 
  • trunk/PARPG/scripts/world.py

    r148 r150  
    2727from scripts.context_menu import ContextMenu 
    2828from pychan.tools import callbackWithArguments as cbwa 
     29from engine import MapDoor 
    2930 
    3031TDS = Setting() 
     
    6162        self.quitFunction = None 
    6263        self.inventoryShown = False 
     64        self.agent_layer = None 
     65        self.cameras = {} 
    6366        # self.data is an engine.Engine object, but is set in run.py 
    6467        self.data = None 
     
    8992           @return: None""" 
    9093        # We have to delete the map in Fife. 
    91         # TODO: I'm killing the PC now, but later we will have to save the PC 
     94        # TODO: We're killing the PC now, but later we will have to save the PC 
    9295        if self.map: 
    9396            self.model.deleteObjects() 
     
    167170        obj = self.agent_layer.createInstance( 
    168171                self.model.getObject(str(gfx), "PARPG"), 
    169                 fife.ExactModelCoordinate(xpos,ypos,0.0), str(name)) 
     172                fife.ExactModelCoordinate(float(xpos), float(ypos), 0.0), str(name)) 
    170173        obj.setRotation(0) 
    171174        fife.InstanceVisual.create(obj) 
     
    285288            # is there an object here? 
    286289            i=self.cameras['main'].getMatchingInstances(click, self.agent_layer) 
     290            info = None 
    287291            if(i != ()): 
    288292                for obj in i: 
    289293                    # check to see if this is an active item 
    290                     if(self.data.objectActive(obj.getId()) != False):             
     294                    if(self.data.objectActive(obj.getId())):             
    291295                        # yes, get the data 
    292296                        info = self.data.getItemActions(obj.getId()) 
    293                         if(info == None): 
    294                             # there was a map change, don't screw with the GUI 
     297                        if(isinstance(info, MapDoor)): 
     298                            # approach the door 
     299                            self.data.PC.approachDoor(self.getCoords(click), 
     300                                                      info.map, 
     301                                                      info.targ_coords) 
    295302                            return 
     303                        else: 
     304                            # show the context menu 
     305                            break 
     306                         
     307            # delete the old context menu 
    296308            if(hasattr(self, "context_menu")): 
    297309                self.context_menu.vbox.hide() 
    298                 delattr(self, "context_menu") 
    299                 data = [["Placeholder", "Placeholder Button", self.placeHolderFunction, click]] 
    300                 pos = (evt.getX(), evt.getY()) 
    301                 self.context_menu = ContextMenu(self.engine, data, pos) 
    302  
     310                delattr(self, "context_menu")        
     311            if info: 
     312                # take the menu items returned by the engine 
     313                data = info 
    303314            else: 
    304                 data = [["Placeholder", "Placeholder Button", self.placeHolderFunction, click]] 
    305                 pos = (evt.getX(), evt.getY()) 
    306                 self.context_menu = ContextMenu(self.engine, data, pos) 
     315                # default menu, could be walk etc. 
     316                data = [["Walk", "Walk here", self.onWalk, self.getCoords(click)]] 
     317            pos = (evt.getX(), evt.getY()) 
     318            self.context_menu = ContextMenu(self.engine, data, pos) 
     319             
     320    def onWalk(self, click): 
     321        """Callback sample for the context menu. 
     322        """ 
     323        self.data.PC.run(click) 
     324        self.context_menu.vbox.hide() 
     325        delattr(self, "context_menu") 
    307326 
    308327    def mouseMoved(self, evt): 
     
    317336            for obj in i: 
    318337                # check to see if this in our list at all 
    319                 item = self.data.objectActive(obj.getId()) 
    320                 if(item!=False): 
     338                if(self.data.objectActive(obj.getId())): 
    321339                    # yes, so outline     
    322340                    self.outline_render.addOutlined(obj, 0, 137, 255, 2) 
    323341                    # get the text 
    324                     self.displayObjectText(obj, item.text) 
     342                    item = self.data.objectActive(obj.getId()) 
     343                    if(item): 
     344                        self.displayObjectText(obj, item.text) 
    325345        else: 
    326346            # erase the outline 
    327347            self.outline_render.removeAllOutlines() 
    328  
    329     def placeHolderFunction(self): 
    330         """Just a simple function to make the PC say "Place Holder Function!" 
    331            It's in here because we needed some sort of function to test the 
    332            context menu with. 
    333            @return: None""" 
    334         self.agent_layer.getInstance("PC").say("Place Holder Function!", 1000) 
    335         self.context_menu.vbox.hide() 
    336         delattr(self, "context_menu") 
    337348 
    338349    def getCoords(self, click): 
     
    377388           We ignore this main loop (but FIFE complains if it is missing).""" 
    378389        pass 
    379  
Note: See TracChangeset for help on using the changeset viewer.