Changeset 310 for trunk/game/scripts


Ignore:
Timestamp:
10/09/09 20:03:08 (10 years ago)
Author:
eliedebrauwer
Message:

Ticket #66: Patch by saritor (& eliedebrauwer), implements saritors rework of teleporting, at this point it implements the within-a-map teleport successfully, but cross map teleport still has in issue which probably has to do with the setup of the PC. comment[s:trac, t:66]

Location:
trunk/game/scripts
Files:
6 edited

Legend:

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

    r302 r310  
    2323from objects.action import * 
    2424 
    25 # design note: 
    26 # there is a map file that FIFE reads. We use that file for half the map 
    27 # format because the map editor in FIFE uses it, and secondly because it 
    28 # save us writing a bunch of new code. 
    29 # However, the objects and characters on a map are liable to change 
    30 # whilst the game is being run, so when we change the map, we need to 
    31 # to grab the objects and npc data EITHER from the engine state, or grab 
    32 # from another file if in their initial state 
    33 # This other file has the name AAA_objects.xml where AAA.xml is the name 
    34 # of the original mapfile. 
    3525 
    3626class Engine: 
     
    5141        self.gameState = GameState() 
    5242        self.pc_run = 1 
    53  
     43        self.targetPosition = None 
    5444    def reset(self): 
    5545        """Clears the data on a map reload so we don't have objects/npcs from 
     
    8979    def load(self, path, filename): 
    9080        """Loads a saver from a file. 
     81           @type path: string  
     82           @param path: the path where the savefile is located 
    9183           @type filename: string 
    9284           @param filename: the name of the file to load from 
     
    10597    def createObject (self, layer, attributes, instance): 
    10698        """Create an object and add it to the current map. 
    107             Inputs: 
    108                 layer = FIFE layer object exists in 
    109                 attributes = dictionary of all object attributes 
    110                 instance = FIFE instance corresponding to the object 
    111             Return: 
    112                 Nothing 
     99           @type layer: fife.Layer 
     100           @param layer: FIFE layer object exists in 
     101           @type attributes: Dictionary 
     102           @param attributes: Dictionary of all object attributes 
     103           @type instance: fife.Instance 
     104           @param instance: FIFE instance corresponding to the object 
     105           @return: None 
    113106        """ 
    114107        # create the extra data 
     
    128121    def addPC(self, layer, pc, instance): 
    129122        """Add the PC to the map 
    130             Inputs: 
    131                 layer = FIFE layer object exists in 
    132                 pc = PlayerCharacter object 
    133                 instance = FIFE instance of PC 
    134             Returns: 
    135                 Nothing 
     123           @type layer: fife.Layer 
     124           @param layer: FIFE layer object exists in 
     125           @type pc: PlayerCharacter 
     126           @param pc: PlayerCharacter object 
     127           @type instance: fife.Instance 
     128           @param instance: FIFE instance of PC 
     129           @return: None 
    136130        """ 
    137131        # add to view data  
     
    147141    def addObject(self, layer, obj, instance): 
    148142        """Adds an object to the map. 
    149             Inputs: 
    150                 layer = FIFE layer object exists in 
    151                 obj = corresponding object class 
    152                 instance = FIFE instance of object 
    153             Returns: 
    154                 Nothing 
     143           @type layer: fife.Layer 
     144           @param layer: FIFE layer object exists in 
     145           @type obj: GameObject 
     146           @param obj: corresponding object class 
     147           @type instance: fife.Instance 
     148           @param instance: FIFE instance of object 
     149           @return: Nothing 
    155150        """ 
    156151         
     
    168163        # add it to the view 
    169164        self.view.activeMap.addObject(obj.ID, instance)           
    170         
     165 
    171166        if obj.trueAttr("NPC"): 
    172167            # create the agent 
     
    175170            # create the PC agent 
    176171            obj.start() 
    177  
    178     def addDoors(self, doors): 
    179         """Add all the doors to the map as well. 
    180            As an object they will have already been added. 
    181            @type doors: list 
    182            @param doors: List of doors 
    183            @return: None""" 
    184         for i in doors: 
    185             self.doors[str(i.id)] = MapDoor(i.id, i.destmap, (i.destx, i.desty)) 
    186172 
    187173    def objectActive(self, ident): 
     
    195181            if (i.ID == ident): 
    196182                # we found a match 
    197                 return i          
     183                return i 
    198184        # no match 
    199185        return False 
     
    213199                # keep it simple for now, None to be replaced by callbacks 
    214200                actions.append(["Talk", "Talk", self.initTalk, obj]) 
    215                 actions.append(["Attack", "Attack", self.nullFunc, obj])  
    216             elif obj.trueAttr("Door"): 
    217                 actions.append(["Change Map", "Change Map", \ 
     201                actions.append(["Attack", "Attack", self.nullFunc, obj]) 
     202            else: 
     203                actions.append(["Examine", "Examine", self.gameState.PC.approach, \ 
     204                                [obj.X, obj.Y], ExamineBoxAction(self, obj.name, obj.text)]) 
     205                # is it a Door? 
     206                if obj.trueAttr("door"): 
     207                    actions.append(["Change Map", "Change Map", \ 
    218208                       self.gameState.PC.approach, [obj.X, obj.Y], \ 
    219                         ChangeMapAction(self, self.doors[str(i.ID)].map, [i.destx, i.desty])]) 
    220                 pass 
    221             else: 
    222                 actions.append(["Examine", "Examine", self.gameState.PC.approach,   
    223                                 [obj.X, obj.Y], ExamineBoxAction(self, obj.name, obj.text)]) 
     209                            ChangeMapAction(self, obj.target_map_name, \ 
     210                                obj.target_map, obj.target_pos)]) 
    224211                # is it a container? 
    225212                if obj.trueAttr("container"): 
     
    227214                # can you pick it up? 
    228215                if obj.trueAttr("carryable"): 
    229                     actions.append(["Pick Up", "Pick Up", self.nullFunc, obj])        
    230                      
     216                    actions.append(["Pick Up", "Pick Up", self.nullFunc, obj]) 
     217 
    231218        return actions 
    232219     
     
    243230 
    244231    def loadMap(self, map_name, map_file): 
    245         """Load a new map. TODO: needs some error checking 
     232        """THIS FUNCTION IS BROKEN. DO NOT USE IT YET 
     233           Load a new map. 
    246234           @type map_name: string 
    247235           @param map_name: Name of the map to load 
     
    254242        self.view.setActiveMap(map_name) 
    255243 
    256         self.reset()         
    257          
     244        self.reset() 
     245 
    258246        # create the PC agent 
    259247        self.view.activeMap.addPC(self.gameState.PC.behaviour.agent) 
     
    270258        else: 
    271259            self.gameState.PC.walk(position) 
    272          
    273     def changeMap(self, map, targetPosition): 
     260 
     261    def changeMap(self, mapName, mapFile, targetPosition): 
    274262        """Registers for a mapchange on the next pump(). 
    275            @type map: ??? 
    276            @param map: Name of the target map. 
    277            @type targetPosition: ??? 
     263           @type nameName: String 
     264           @param mapName: Id of the map to teleport to 
     265           @type mapFile: String 
     266           @param mapFile: Filename of the map to teleport to 
     267           @type targetPosition: Tuple 
    278268           @param targetPosition: Position of PC on target map. 
    279            @return: None""" 
    280         # save the postions 
    281         self.updateGameState() 
    282         # set the PC position 
    283         self.gameState.PC.posx = targetPosition[0] 
    284         self.gameState.PC.posy = targetPosition[1] 
    285         # set the parameters for the mapchange 
    286         self.targetMap = map 
    287         # issue the mapchange 
    288         self.mapchange = True 
     269           @return None""" 
     270        # set the parameters for the mapchange if moving to a new map 
     271        print self.gameState.currentMapName 
     272        if mapName != self.gameState.currentMapName: 
     273            self.gameState.currentMapName = mapName 
     274            self.gameState.currentMap = mapFile 
     275            self.targetPosition = targetPosition 
     276            # issue the mapchange 
     277            self.mapchange = True 
     278        else: 
     279            #set the player position on the current map 
     280            self.view.teleport(targetPosition) 
    289281 
    290282    def handleCommands(self): 
    291283        if self.mapchange: 
    292             self.loadMap(self.targetMap) 
     284            self.loadMap(self.gameState.currentMapName, self.gameState.currentMap) 
     285            self.view.teleport(self.targetPosition) 
    293286            self.mapchange = False 
    294287 
     
    296289        """Main loop in the engine.""" 
    297290        self.handleCommands() 
    298  
  • trunk/game/scripts/objects/__init__.py

    r262 r310  
    1515#   You should have received a copy of the GNU General Public License 
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    17 import containers 
     17import containers, doors 
    1818import actors 
    1919import sys 
    2020 
    21 object_modules = [containers, actors,] 
     21object_modules = [containers, actors, doors] 
    2222 
    2323def getAllObjects (): 
     
    5050            info[key] = val 
    5151 
     52        # this is for testing purposes 
    5253        return getAllObjects()[obj_type](ID, **info) 
  • trunk/game/scripts/objects/action.py

    r287 r310  
    2424class ChangeMapAction(Action): 
    2525    """A change map scheduled""" 
    26     def __init__(self, engine, targetmap, targetpos): 
    27         """@type engine: Engine reference 
     26    def __init__(self, engine, targetmapname, targetmapfile , targetpos): 
     27        """Initiates a change of the position of the character 
     28           possibly flagging a new map to be loaded. 
     29           @type engine: Engine reference 
    2830           @param engine: A reference to the engine. 
    29            @type targetmap: String 
    30            @param targetmap: Target mapname. 
     31           @type targetmapname: String 
     32           @param targetmapname: Target map id  
     33           @type targetmapfile: String 
     34           @param targetmapfile: Target map filename 
    3135           @type targetpos: Tuple 
    3236           @param targetpos: (X, Y) coordinates on the target map. 
     
    3438        self.engine = engine 
    3539        self.targetpos = targetpos 
    36         self.targetmap = targetmap 
    37         
     40        self.targetmapname = targetmapname 
     41        self.targetmapfile = targetmapfile 
     42 
    3843    def execute(self): 
    3944        """Executes the mapchange.""" 
    40         self.engine.changeMap(self.targetmap, self.targetpos) 
     45        self.engine.changeMap(self.targetmapname, self.targetmapfile, self.targetpos) 
    4146        
    4247class OpenBoxAction(Action): 
  • trunk/game/scripts/objects/actors.py

    r295 r310  
    136136        self.state = _AGENT_STATE_RUN 
    137137        self.behaviour.agent.move('walk', location, self.behaviour.speed-1) 
    138        
     138 
     139    def teleport(self, location): 
     140        """Teleports a PC instantly to the given location. 
     141           @type location: fife.Location 
     142           @param location: Target coordinates for PC. 
     143           @return: None""" 
     144        self.state = _AGENT_STATE_IDLE 
     145        self.behaviour.agent.setLocation(location) 
     146 
    139147    def approach(self, location, action = None): 
    140148        """Approaches an npc and then ???. 
  • trunk/game/scripts/objects/composed.py

    r262 r310  
    3131        Destructable .__init__(self, **kwargs) 
    3232        self.blocking = True 
     33 
     34class Door(GameObject, Lockable, Scriptable, Trappable): 
     35    """Composite class that can be used to create doors on a map.""" 
     36    def __init__ (self, target_map_name = 'my-map', target_map = 'map/map.xml', target_pos = (0.0, 0.0), \ 
     37                        **kwargs): 
     38        GameObject   .__init__(self, **kwargs) 
     39        Lockable     .__init__(self, **kwargs) 
     40        Scriptable   .__init__(self, **kwargs) 
     41        Trappable    .__init__(self, **kwargs) 
     42        self.is_door = True 
     43        self.target_map_name = target_map_name 
     44        self.target_map = target_map 
     45        self.target_pos = target_pos 
     46        self.blocking = True 
  • trunk/game/scripts/world.py

    r302 r310  
    211211        self.data.gameState.PC.run(click) 
    212212 
     213    def teleport(self, position): 
     214        """Called when a door is used that moves a player to a new 
     215           location on the same map. the setting of position may want 
     216           to be created as its own method down the road. 
     217            
     218           @type position: String Tuple 
     219           @param position: X,Y coordinates passed from enigine.changeMap 
     220           @return: fife.Location 
     221        """ 
     222        coord = fife.DoublePoint3D(float(position[0]), float(position[1]), 0) 
     223        location = fife.Location(self.activeMap.agent_layer) 
     224        location.setMapCoordinates(coord) 
     225        self.data.gameState.PC.teleport(location) 
     226 
    213227    def mouseMoved(self, evt): 
    214228        """Called when the mouse is moved 
Note: See TracChangeset for help on using the changeset viewer.