Changeset 151


Ignore:
Timestamp:
06/19/09 13:41:49 (10 years ago)
Author:
maximinus_parpg
Message:

Merged gamestate and engine.
Fixed a few typos.

Location:
trunk/PARPG/scripts
Files:
1 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/PARPG/scripts/engine.py

    r150 r151  
    1717 
    1818# there should be NO references to FIFE here! 
     19import pickle 
    1920from agents.hero import Hero 
    2021from agents.npc import NPC 
    21 from objects import GameObject 
    2222from objLoader import LocalXMLParser 
    2323from saver import Saver 
    24 import pickle 
    25 from gamestate import GameState 
    2624from gamedata import * 
     25from gamedata import BaseObjectData 
    2726 
    2827# design note: 
     
    3635# This other file has the name AAA_objects.xml where AAA.xml is the name 
    3736# of the original mapfile. 
    38  
    39 class MapDoor: 
    40     """A MapDoor is an item that when clicked transports the player to 
    41        another map""" 
    42     def __init__(self, name, new_map, location): 
    43         """@type name: string 
    44            @param name: name of fife object 
    45            @type new_map: string 
    46            @param new_map: name of new map 
    47            @type location: tuple 
    48            @param location: where to put the PC when map is loaded 
    49            @return: None""" 
    50         self.id = name 
    51         self.map = new_map 
    52         # location is an (int, int) which stores the intended location  
    53         # of the PC on the new map 
    54         self.targ_coords = location 
    5537 
    5638class Engine: 
     
    6648           @param view: A world instance 
    6749           @return: None""" 
    68         # a World object 
     50        # a World object (the fife stuff, essentially) 
    6951        self.view = view 
    70         self.gameState = GameState() 
    7152        self.doors = {} 
    72         self.objects = [] 
    7353        self.npcs = [] 
    7454        self.PC = None 
    7555        self.mapchange = False 
     56        # below this needs to be pickled 
     57        self.PC_old = None 
     58        self.objects = {} 
     59        self.currentMap = None 
    7660 
    7761    def reset(self): 
     
    8165        self.PC = None 
    8266        self.npcs = [] 
    83         self.objects = [] 
    8467        self.doors = {} 
    8568 
     
    9073           @return: None""" 
    9174        self.updateGameState() 
    92         f = open(filename, 'w') 
    93         pickle.dump(self.gameState, f) 
     75        try: 
     76            f = open(filename, 'r') 
     77        except(IOError): 
     78            sys.stderr.write("Error: Can't find save game\n") 
     79            return 
     80        pickle.dump(self.PC_old, f) 
     81        pickle.dump(self.objects, f) 
     82        pickle.dump(self.currentMap, f) 
    9483        f.close() 
    9584 
     
    9988           @param filename: the name of the file to load from 
    10089           @return: None""" 
    101         f = open(filename, 'r') 
    102         self.gameState = pickle.load(f) 
     90        try: 
     91            f = open(filename, 'r') 
     92        except(IOError): 
     93            sys.stderr.write("Error: Can't find save game file\n") 
     94            return 
     95        self.PC_old = pickle.load(f) 
     96        self.objects = pickle.load(f) 
     97        self.currentMap = pickle.load(f) 
    10398        f.close() 
    10499        if self.gameState.currentMap: 
     
    106101             
    107102    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() 
     103        """Stores the current pc and npcs positons in the game state.""" 
     104        # save the PC position 
     105        self.PC_old.posx = self.PC.getX() 
     106        self.PC_old.posy = self.PC.getY() 
    112107        #save npc positions 
    113108        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() 
     109            if str(i.id) in self.objects: 
     110                self.getObjectById(str(i.id)).posx = i.getX() 
     111                self.getObjectById(str(i.id)).posy = i.getY() 
    117112 
    118113    def loadObjects(self, filename): 
     
    151146           @return: None""" 
    152147        # sync with game data 
    153         posx, posy = 0, 0 
    154         if self.gameState.PC: 
     148        if self.PC_old: 
    155149            # use existing position 
    156             posx = self.gameState.PC.posx 
    157             posy = self.gameState.PC.posy 
     150            posx = self.PC_old.posx 
     151            posy = self.PC_old.posy 
    158152        else: 
    159153            posx = pc[0] 
    160154            posy = pc[1] 
    161155            # save the new PC to the game data 
    162             self.gameState.PC = HeroData("PC", posx, posy, "PC", self.gameState.currentMap) 
    163              
     156            self.PC_old = HeroData("PC", posx, posy, "PC", self.currentMap) 
     157        # add to game data     
    164158        self.view.addObject(float(posx), float(posy),"PC","PC") 
    165159         # create the PC agent 
     
    175169           @return: None""" 
    176170        for i in objects: 
    177             # add it to the game state 
    178             ref = self.gameState.getObjectById(i.id)  
     171            # already in game data? 
     172            ref = self.getObjectById(i.id) 
    179173            if ref is None: 
    180                 i.map = self.gameState.currentMap 
    181                 self.gameState.objects[str(i.id)] = i 
     174                # no, add it to the game state 
     175                i.map = self.currentMap 
     176                self.objects[i.id] = i 
    182177            else: 
    183                 # use the current game state data 
     178                # yes, use the current game state data 
    184179                i.posx = ref.posx 
    185180                i.posy = ref.posy 
    186181                i.gfx = ref.gfx         
    187182            # is it visible? 
    188             if(i.display): 
     183            if(i.display == True): 
    189184                self.view.addObject(i.posx, i.posy, i.gfx, i.id) 
    190185 
     
    195190           @return: None""" 
    196191        for i in npcs: 
    197             # add it to the game state 
    198             ref = self.gameState.getObjectById(i.id)  
     192            # already in the game data? 
     193            ref = self.getObjectById(i.id)  
    199194            if ref is None: 
    200                 i.map = self.gameState.currentMap 
    201                 self.gameState.objects[i.id] = i 
     195                # no, add it to the game state 
     196                i.map = self.currentMap 
     197                self.objects[i.id] = i 
    202198            else: 
    203                 # use the current game state data 
     199                # yes, use the current game state data 
    204200                i.posx = ref.posx 
    205201                i.posy = ref.posy 
     
    227223           @rtype: boolean 
    228224           @return: Status of result (True/False)""" 
    229         for i in self.gameState.getObjectsFromMap(self.gameState.currentMap): 
     225        for i in self.getObjectsFromMap(self.currentMap): 
    230226            if i.display and (i.id == ident): 
    231227                # we found a match 
     
    243239        # note: ALWAYS check NPC's first! 
    244240        # is it an NPC? 
    245         for i in self.gameState.getObjectsFromMap(self.gameState.currentMap): 
     241        for i in self.getObjectsFromMap(self.currentMap): 
    246242            if(obj_id == i.id): 
    247243                if isinstance(i, NpcData): 
     
    274270        # then we update FIFE with the PC, NPC and object details 
    275271        self.reset() 
    276         self.gameState.currentMap = map_file 
     272        self.currentMap = map_file 
    277273        self.loadObjects(map_file[:-4] + "_objects.xml") 
    278274 
     
    294290        self.updateGameState() 
    295291        # set the PC position 
    296         self.gameState.PC.posx = targetPosition[0] 
    297         self.gameState.PC.posy = targetPosition[1] 
     292        self.PC_old.posx = targetPosition[0] 
     293        self.PC_old.posy = targetPosition[1] 
    298294        # set the parameters for the mapchange 
    299295        self.targetMap = map 
     
    301297        self.mapchange = True 
    302298 
     299    def getObjectsFromMap(self, cmap): 
     300        """Gets all objects that are currently on the given map. 
     301           @type cmap: String 
     302           @param cmap: The map name. 
     303           @returns: The list of objects on this map.""" 
     304        return [i for i in self.objects.values() if i.map == cmap] 
     305     
     306    def getObjectById(self, ident): 
     307        """Gets an object by it's id 
     308           @type ident: String 
     309           @param ident: The id of the object. 
     310           @returns: The object or None.""" 
     311        if ident in self.objects: 
     312            return self.objects[ident] 
     313 
    303314    def handleCommands(self): 
    304315        if self.mapchange: 
  • trunk/PARPG/scripts/gamedata.py

    r150 r151  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import fife 
    19  
    2018class BaseObjectData(object): 
    2119    """Basis for game object data. 
    2220    """ 
    23     def __init__(self, id, posx, posy, text, map, gfx=None, display=True): 
     21    def __init__(self, ident, posx, posy, text, cmap, gfx=None, display=True): 
    2422        """Set the basic values that are shared by all game objects. 
    25         @type id: String 
    26         @param id: Unique identifier for this object. 
     23        @type ident: String 
     24        @param ident: Unique identifier for this object. 
    2725        @type posx: Integer 
    2826        @param posx: Position X 
     
    3129        @type text: String 
    3230        @param text: The caption of this object 
    33         @type map: String 
    34         @param map: Map where this object is currently located 
     31        @type cmap: String 
     32        @param cmap: Map where this object is currently located 
    3533        @type display: Bool 
    3634        @param display: Display this object? 
    3735        @type gfx: String 
    3836        @param gfx: ??? 
    39         @returns: None 
    40         """ 
    41         self.id = id 
     37        @returns: None""" 
     38        self.id = ident 
    4239        self.posx = posx 
    4340        self.posy = posy 
    4441        self.display = display 
    4542        self.text = text 
    46         self.map = map 
     43        self.map = cmap 
    4744        self.gfx = gfx 
    4845     
    4946    def __cmp__(self, other): 
    5047        """Compares this instance to another. 
    51         @type other: baseObject 
    52         @param other: the other object to compare 
    53         @returns: True if the ids are equal, false otherwise. 
    54         """ 
     48        @type other: BaseObjectData 
     49        @param other: The other object to compare 
     50        @returns: True if the ids are equal, false otherwise.""" 
    5551        return self.id == other.id 
    5652     
     
    5854    """Represents a door. 
    5955    """ 
    60     def __init__(self, id, posx, posy, text, map, gfx, display, 
     56    def __init__(self, ident, posx, posy, text, cmap, gfx, display, 
    6157                 owner, destx, desty, destmap): 
    6258        """Set initial values 
    63         @type id: String 
    64         @param id: Unique identifier for this object. 
     59        @type ident: String 
     60        @param ident: Unique identifier for this object. 
    6561        @type posx: Integer 
    6662        @param posx: Position X 
     
    6965        @type text: String 
    7066        @param text: The caption of this object 
    71         @type map: String 
    72         @param map: Map where this NPC is currently located 
     67        @type cmap: String 
     68        @param cmap: Map where this NPC is currently located 
    7369        @type display: Bool 
    7470        @param display: Display this object? 
     
    8480        @param destmap: Target map 
    8581        @returns: None""" 
    86         super(DoorData, self).__init__(id, posx, posy, text, map, gfx, display) 
     82        super(DoorData, self).__init__(ident, posx, posy, text, 
     83                                       cmap, gfx, display) 
    8784        self.destx = destx 
    8885        self.desty = desty 
     
    9390    """Non Player Character 
    9491    """ 
    95     def __init__(self, id, posx, posy, text, map, gfx=None, display=True): 
     92    def __init__(self, ident, posx, posy, text, cmap, gfx=None, display=True): 
    9693        """Set initial NPC values. 
    97         @type id: String 
    98         @param id: Unique identifier for this object. 
     94        @type ident: String 
     95        @param ident: Unique identifier for this object. 
    9996        @type posx: Integer 
    10097        @param posx: Position X 
     
    103100        @type text: String 
    104101        @param text: The caption of this object 
    105         @type map: String 
    106         @param map: Map where this NPC is currently located 
     102        @type cmap: String 
     103        @param cmap: Map where this NPC is currently located 
    107104        @type display: Bool 
    108105        @param display: Display this object? 
     
    110107        @param gfx: ??? 
    111108        @returns: None""" 
    112         super(NpcData, self).__init__(id, posx, posy, text, map, gfx, display) 
     109        super(NpcData, self).__init__(ident, posx, posy, text, 
     110                                      cmap, gfx, display) 
    113111 
    114112class HeroData(NpcData): 
    115113    """Hero character, for now equal to a NPC""" 
    116     def __init__(self, id, posx, posy, text, map, gfx=None, display=True): 
     114    def __init__(self, ident, posx, posy, text, cmap, gfx=None, display=True): 
    117115        """Set initial NPC values. 
    118         @type id: String 
    119         @param id: Unique identifier for this object. 
     116        @type ident: String 
     117        @param ident: Unique identifier for this object. 
    120118        @type posx: Integer 
    121119        @param posx: Position X 
     
    124122        @type text: String 
    125123        @param text: The caption of this object 
    126         @type map: String 
    127         @param map: Map where this NPC is currently located 
     124        @type cmap: String 
     125        @param cmap: Map where this NPC is currently located 
    128126        @type display: Bool 
    129127        @param display: Display this object? 
     
    131129        @param gfx: ??? 
    132130        @returns: None""" 
    133         super(HeroData, self).__init__(id, posx, posy, text, map, gfx, display) 
     131        super(HeroData, self).__init__(ident, posx, posy, text, 
     132                                       cmap, gfx, display) 
    134133 
    135134class NonLivingObjectData(BaseObjectData): 
    136     def __init__(self, id, posx, posy, text, map, gfx=None, display=True,  
     135    def __init__(self, ident, posx, posy, text, cmap, gfx=None, display=True,  
    137136                 owner=None, container=False, carryable=False): 
    138137        """Set initial object values. 
    139         @type id: String 
    140         @param id: Unique identifier for this object. 
     138        @type ident: String 
     139        @param ident: Unique identifier for this object. 
    141140        @type posx: Integer 
    142141        @param posx: Position X 
     
    145144        @type text: String 
    146145        @param text: The caption of this object 
    147         @type map: String 
    148         @param map: Map where this NPC is currently located 
     146        @type cmap: String 
     147        @param cmap: Map where this NPC is currently located 
    149148        @type owner: ??? 
    150149        @param owner: The owner of this object 
     
    158157        @param gfx: ??? 
    159158        @returns: None""" 
    160         super(NonLivingObjectData, self).__init__(id, posx, posy, text, map, gfx, display) 
     159        super(NonLivingObjectData, self).__init__(ident, posx, posy, text,  
     160                                                  cmap, gfx, display) 
    161161        self.container = container 
    162162        self.carryable = carryable 
    163163        self.owner = owner 
    164164 
     165class MapDoor: 
     166    """A MapDoor is an item that when clicked transports the player to 
     167       another map""" 
     168    def __init__(self, name, new_map, location): 
     169        """@type name: string 
     170           @param name: name of fife object 
     171           @type new_map: string 
     172           @param new_map: name of new map 
     173           @type location: tuple 
     174           @param location: where to put the PC when map is loaded 
     175           @return: None""" 
     176        self.id = name 
     177        self.map = new_map 
     178        # location is an (int, int) which stores the intended location  
     179        # of the PC on the new map 
     180        self.targ_coords = location 
     181 
  • trunk/PARPG/scripts/saver.py

    r148 r151  
    9191    def addData(self, pc, npcs, objects, doors): 
    9292        """ Adds a new maps worth of data to the maps object. 
    93             @type PC: list 
    94             @param PC: a list of the x y coordinates of the PC 
     93            @type pc: list 
     94            @param pc: a list of the x y coordinates of the PC 
    9595            @type npcs: list 
    9696            @param npcs: a list of various npc information as from .xml files 
Note: See TracChangeset for help on using the changeset viewer.