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

Added tZee's patch.
Some other minor editing.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 
Note: See TracChangeset for help on using the changeset viewer.