Ignore:
Timestamp:
06/25/10 18:01:54 (9 years ago)
Author:
beliar
Message:

Ticket #200: Patch by Beliar.

  • Merging map_loading_change branch back into trunk

fixes[s:trac, t:200]

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk

    • Property svn:ignore
      •  

        old new  
         1*.pyc 
         2.project 
         3.pydevproject 
        14Thumbs.db 
        2 *.pyc 
    • Property svn:mergeinfo changed
      /branches/map_loading_change (added)merged: 554-562
  • trunk/game/scripts/objects/action.py

    r553 r563  
    2424class ChangeMapAction(Action): 
    2525    """A change map scheduled""" 
    26     def __init__(self, model, view, target_map_name, target_map_file , target_pos): 
     26    def __init__(self, model, view, target_map_name, target_pos): 
    2727        """Initiates a change of the position of the character 
    2828           possibly flagging a new map to be loaded. 
     
    3333           @type target_map_name: String 
    3434           @param target_map_name: Target map id  
    35            @type target_map_file: String 
    36            @param target_map_file: Target map filename 
    3735           @type target_pos: Tuple 
    3836           @param target_pos: (X, Y) coordinates on the target map. 
     
    4341        self.target_pos = target_pos 
    4442        self.target_map_name = target_map_name 
    45         self.target_map_file = target_map_file 
    4643 
    4744    def execute(self): 
    4845        """Executes the map change.""" 
    49         self.model.changeMap(self.target_map_name, self.target_map_file,\ 
     46        self.model.changeMap(self.target_map_name, 
    5047                              self.target_pos) 
    5148        
     
    148145        # If we are too far away, we approach the NPC again 
    149146        if distance_squared > 2: 
    150             pc.approach([self.npc.getLocation().\ 
    151                          getLayerCoordinates().x, \ 
    152                          self.npc.getLocation().\ 
    153                          getLayerCoordinates().y], \ 
    154                         TalkAction(self.model,\ 
     147            pc.approach([self.npc.getLocation(). 
     148                         getLayerCoordinates().x, 
     149                         self.npc.getLocation(). 
     150                         getLayerCoordinates().y],  
     151                        TalkAction(self.model, 
     152                                   self.view, 
    155153                                   self.npc))         
    156154        else: 
  • trunk/game/scripts/objects/actors.py

    r553 r563  
    4040        self.state = None 
    4141        self.speed = 0 
     42        self.idle_counter = 1 
    4243     
    4344    def attachToLayer(self, agent_ID): 
     
    6465        return self.agent.getLocation().getLayerCoordinates().y 
    6566         
     67    def onNewMap(self, layer): 
     68        """Sets the agent onto the new layer.""" 
     69        if self.agent is not None: 
     70            self.agent.removeActionListener(self) 
     71             
     72        self.agent = layer.getInstance(self.parent.ID) 
     73        self.agent.addActionListener(self) 
     74        self.state = _AGENT_STATE_NONE 
     75        self.idle_counter = 1 
     76     
     77    def idle(self): 
     78        """@return: None""" 
     79        self.state = _AGENT_STATE_IDLE 
     80        self.agent.act('stand', self.agent.getFacingLocation()) 
     81 
    6682    def onInstanceActionFinished(self, instance, action): 
    6783        pass 
     
    94110            self.idle_counter = 1 
    95111        else: 
    96             self.idle_counter += 1 
    97              
    98     def onNewMap(self, layer): 
    99         """Sets the agent onto the new layer.""" 
    100         if self.agent is not None: 
    101             self.agent.removeActionListener(self) 
    102              
    103         self.agent = layer.getInstance(self.parent.ID) 
    104         self.agent.addActionListener(self) 
    105         self.state = _AGENT_STATE_NONE 
    106         self.idle_counter = 1 
    107      
    108     def idle(self): 
    109         """@return: None""" 
    110         self.state = _AGENT_STATE_IDLE 
    111         self.agent.act('stand', self.agent.getFacingLocation()) 
     112            self.idle_counter += 1             
    112113 
    113114class PlayerCharacter (GameObject, Living, CharStats): 
    114115    """PC class""" 
    115     def __init__ (self, ID, agent_layer = None, inventory = None, **kwargs): 
    116         GameObject.__init__( self, ID, **kwargs ) 
     116    def __init__ (self, ID, agent_layer = None, inventory = None, text = "Its you. Who would've thought that?", **kwargs): 
     117        GameObject.__init__( self, ID, text = text, **kwargs ) 
    117118        Living.__init__( self, **kwargs ) 
    118119        CharStats.__init__( self, **kwargs ) 
     
    137138        self.createBehaviour(agent_layer) 
    138139     
    139     def prepareStateForSaving(self, state): 
    140         """Prepares state for saving 
    141         @type state: dictionary 
    142         @param state: State of the object   
     140    def getLocation(self): 
     141        """Get the NPC's position as a fife.Location object. Basically a 
     142           wrapper. 
     143           @rtype: fife.Location 
     144           @return: the location of the NPC""" 
     145        return self.behaviour.agent.getLocation() 
     146 
     147    def getStateForSaving(self): 
     148        """Returns state for saving 
    143149        """ 
    144         GameObject.prepareStateForSaving(self, state) 
    145         del state["behaviour"] 
    146  
     150        ret_dict = super(PlayerCharacter, self).getStateForSaving() 
     151        ret_dict["Inventory"] = self.inventory.serializeInventory() 
     152        ret_dict["PeopleKnown"] = self.peopleIknow 
     153        return ret_dict 
     154     
    147155    def meet(self, npc): 
    148156        """Record that the PC has met a certain NPC 
     
    215223        l.setLayerCoordinates(fife.ModelCoordinate(*boxLocation)) 
    216224        self.behaviour.agent.move('run', l, self.behaviour.speed+1) 
     225     
     226    def _getCoords(self): 
     227        """Get-er property function""" 
     228        return (self.getLocation().getMapCoordinates().x,  
     229                self.getLocation().getMapCoordinates().y) 
     230     
     231    def _setCoords(self, coords): 
     232        """Set-er property function""" 
     233        map_coords = self.getLocation().getMapCoordinates() 
     234        map_coords.X, map_coords.Y = float(coords[0]), float (coords[1]) 
     235        self.teleport(map_coords) 
     236     
     237    coords = property (_getCoords, _setCoords,  
     238        doc = "Property allowing you to get and set the object's \ 
     239                coordinates via tuples") 
    217240 
    218241 
     
    225248        self.pc = None 
    226249        self.target_loc = None 
     250        self.nextAction = None 
    227251         
    228252        # hard code this for now 
     
    285309    """NPC class""" 
    286310    def __init__(self, ID, agent_layer=None, name='NPC', \ 
    287                  text = 'A nonplayer character', inventory = None, **kwargs): 
     311                 text = 'A nonplayer character', inventory = None,  
     312                 real_name = 'NPC', dialogue = None, **kwargs): 
    288313        # init game object 
    289         GameObject.__init__(self, ID, name=name, **kwargs) 
     314        GameObject.__init__(self, ID, name=name, real_name=real_name, text = text, **kwargs) 
    290315        Living.__init__(self, **kwargs) 
    291316        Scriptable.__init__(self, **kwargs) 
     
    294319        self.is_NPC = True 
    295320        self.behaviour = None 
     321        self.state = None 
    296322         
    297323        if inventory == None: 
     
    305331        self.layer_id = agent_layer.getId() 
    306332        self.createBehaviour(agent_layer)         
    307         self.dialogue = kwargs.get('dialogue') 
    308          
     333        self.dialogue = dialogue 
     334 
    309335    def prepareStateForSaving(self, state): 
    310336        """Prepares state for saving 
     
    315341        del state["behaviour"] 
    316342 
     343    def getStateForSaving(self): 
     344        """Returns state for saving 
     345        """ 
     346        ret_dict = super(NonPlayerCharacter, self).getStateForSaving() 
     347        ret_dict["Lives"] = self.is_living 
     348        ret_dict["State"] = self.behaviour.state 
     349        return ret_dict 
     350 
    317351    def createBehaviour(self, layer): 
    318352        """Creates the behaviour for this actor. 
     
    327361        return self.behaviour.agent.getLocation() 
    328362     
     363    def teleport(self, location): 
     364        """Teleports a NPC instantly to the given location. 
     365           @type location: fife.Location 
     366           @param location: Target coordinates for PC. 
     367           @return: None""" 
     368        self.state = _AGENT_STATE_IDLE 
     369        self.behaviour.nextAction = None  
     370        self.behaviour.agent.setLocation(location) 
     371 
    329372    def wander(self, location): 
    330373        """Nice slow movement for random walking. 
     
    364407        """@return: None""" 
    365408        self.behaviour.idle() 
     409 
     410    def _getCoords(self): 
     411        """Get-er property function""" 
     412        return (self.getLocation().getMapCoordinates().x,  
     413                self.getLocation().getMapCoordinates().y) 
     414     
     415    def _setCoords(self, coords): 
     416        """Set-er property function""" 
     417        map_coords = self.getLocation().getMapCoordinates() 
     418        map_coords.X, map_coords.Y = float(coords[0]), float (coords[1]) 
     419        self.teleport(map_coords) 
     420 
     421    coords = property (_getCoords, _setCoords,  
     422        doc = "Property allowing you to get and set the object's \ 
     423                coordinates via tuples") 
  • trunk/game/scripts/objects/base.py

    r553 r563  
    5656class DynamicObject (object): 
    5757    """A base class that only supports dynamic attributes functionality""" 
    58     def __init__ (self, name="Dynamic object", image=None, **kwargs): 
     58    def __init__ (self, name="Dynamic object", real_name=None, image=None, **kwargs): 
    5959        """Initialise minimalistic set of data 
    6060           @type name: String 
     
    6363           @param name: Filename of image to use in inventory""" 
    6464        self.name = name 
     65        self.real_name = real_name or name 
    6566        self.image = image 
    6667 
     
    9192           is_%attr and if that attribute evaluates to True""" 
    9293        return hasattr(self,'is_%s' % attr) and getattr(self, 'is_%s' % attr) 
    93  
     94     
     95    def getStateForSaving(self): 
     96        """Returns state for saving 
     97        """ 
     98        state = {} 
     99        state["Name"] = self.name 
     100        state["RealName"] = self.real_name 
     101        state["Image"] = self.image 
     102        return state 
    94103 
    95104class GameObject (DynamicObject): 
     
    97106       first class (left to right) inherited by any game object.""" 
    98107    def __init__ (self, ID, gfx = None, xpos = 0.0, ypos = 0.0, map_id = None,  
    99                   blocking=True, name="Generic object", text="Item description", 
     108                  blocking=True, name="Generic object", real_name="Generic object", text="Item description", 
    100109                  desc="Detailed description", **kwargs): 
    101110        """Set the basic values that are shared by all game objects. 
     
    117126           @param desc: A long description of the item that is displayed when it is examined 
    118127           """ 
    119         DynamicObject.__init__(self, name, **kwargs) 
     128        DynamicObject.__init__(self, name, real_name, **kwargs) 
    120129        self.ID = ID 
    121130        self.gfx = gfx or {} 
     
    136145         
    137146    coords = property (_getCoords, _setCoords,  
    138         doc = "Property allowing you to get and set the obejct's \ 
     147        doc = "Property allowing you to get and set the object's \ 
    139148                coordinates via tuples") 
    140149     
     
    142151        """A debugging string representation of the object""" 
    143152        return "<%s:%s>" % (self.name, self.ID) 
     153 
     154    def getStateForSaving(self): 
     155        """Returns state for saving 
     156        """ 
     157        state = super(GameObject, self).getStateForSaving() 
     158        state["ObjectModel"] = self.gfx 
     159        state["Text"] = self.text 
     160        state["Desc"] = self.desc 
     161        state["Position"] = list(self.coords) 
     162        return state 
     163 
    144164 
    145165class Scriptable (object): 
     
    255275        pass 
    256276 
    257     def __init__ (self, capacity = 0, **kwargs): 
     277    def __init__ (self, capacity = 0, items = None, **kwargs): 
    258278        DynamicObject.__init__(self, **kwargs) 
    259279        Scriptable.__init__(self, **kwargs) 
     
    261281        self.items = {} 
    262282        self.capacity = capacity 
     283        if items: 
     284            for item in items: 
     285                self.placeItem(item) 
    263286         
    264287    def placeItem (self, item, index=None): 
     
    339362            return self.items[i] 
    340363        return None 
     364     
     365    def serializeItems(self): 
     366        """Returns the items as a list""" 
     367        items = [] 
     368        for index, item in self.items.iteritems(): 
     369            item_dict = item.getStateForSaving() 
     370            item_dict["index"] = index 
     371            item_dict["type"] = type(item).__name__  
     372            items.append(item_dict) 
     373        return items 
     374     
     375    def getStateForSaving(self): 
     376        """Returns state for saving 
     377        """ 
     378        ret_state = {} 
     379        ret_state["Items"] = self.serializeItems() 
     380        return ret_state 
    341381         
    342382class Living (object): 
  • trunk/game/scripts/objects/composed.py

    r553 r563  
    4343    def getWeight(self): 
    4444        """Resulting weight of a container""" 
    45         return sum((item.weight for item in self.items.values()), self.own_weight) 
     45        return sum((item.weight for item in self.items.values()),  
     46                   self.own_weight) 
    4647 
    4748    def setWeight(self, weight): 
    48         """Set container's own weight. For compatibility with inherited methods""" 
     49        """Set container's own weight.  
     50        For compatibility with inherited methods""" 
    4951        self.own_weight = weight 
    5052 
     
    6264 
    6365    def __repr__(self): 
    64         return "[%s"%self.name +str(reduce((lambda a,b: a +', '+ \ 
    65                                     str(self.items[b])), self.items,""))+" ]" 
    66  
     66        return "[%s" % self.name + str(reduce((lambda a, b: a + ', ' + \ 
     67                                    str(self.items[b])), self.items, "")) + " ]" 
     68     
    6769class SingleItemContainer (CarryableContainer) : 
    6870    """Container that can only store a single item. 
     
    7981    """Composite class that will be used for all carryable items""" 
    8082    def __init__(self, **kwargs): 
    81         GameObject.__init__(self,**kwargs) 
    82         Carryable.__init__(self,**kwargs) 
     83        GameObject.__init__(self, **kwargs) 
     84        Carryable.__init__(self, **kwargs) 
    8385 
     86    def prepareStateForSaving(self, state): 
     87        """Prepares state for saving 
     88        @type state: dictionary 
     89        @param state: State of the object   
     90        """ 
     91        del state["in_container"] 
     92 
     93    def getStateForSaving(self): 
     94        """Returns state for saving 
     95        @type state: dictionary 
     96        @param state: State of the object   
     97        """ 
     98        ret_dict = self.__dict__.copy() 
     99        self.prepareStateForSaving(ret_dict) 
     100        return ret_dict 
     101         
    84102class Door(GameObject, Lockable, Scriptable, Trappable): 
    85103    """Composite class that can be used to create doors on a map.""" 
    86     def __init__ (self, target_map_name = 'my-map', target_map = 'map/map.xml', 
     104    def __init__ (self, target_map_name = 'my-map', 
    87105                  target_x = 0.0, target_y = 0.0, **kwargs): 
    88106        GameObject.__init__(self, **kwargs) 
     
    92110        self.is_door = True 
    93111        self.target_map_name = target_map_name 
    94         self.target_map = target_map 
    95112        self.target_pos = (target_x, target_y) 
    96113        self.blocking = True 
     114 
     115    def getStateForSaving(self): 
     116        """Returns state for saving 
     117        """ 
     118        ret_dict = super(Door, self).getStateForSaving() 
     119        return ret_dict 
  • trunk/game/scripts/objects/containers.py

    r542 r563  
    2525 
    2626from composed import ImmovableContainer 
    27 from composed import CarryableItem 
    2827from fife import fife 
    2928 
     
    3332        ImmovableContainer.__init__(self, ID = object_id, name = name,  
    3433                                    gfx = gfx, text = text, **kwargs) 
    35         self.placeItem(CarryableItem(ID=987, name="Dagger456")) 
    3634         
    3735class ContainerBehaviour(fife.InstanceActionListener): 
     
    8785                                    gfx = gfx, text = text, **kwargs) 
    8886        self.behaviour = None 
    89         self.placeItem(CarryableItem(ID=987, name="Dagger456")) 
    9087 
    9188        self.is_AnimatedContainer = True 
  • trunk/game/scripts/objects/doors.py

    r477 r563  
    1818"""Containes classes defining concrete door game objects.""" 
    1919 
    20 __all__ = ["ShantyDoor",] 
     20__all__ = ["ShantyDoor", ] 
    2121 
    2222from composed import Door 
     
    2525    def __init__ (self, ID, name = 'Shanty Door', text = 'A door', 
    2626                   gfx = 'shanty-door', target_map_name = 'my-map', 
    27                    target_map = 'map.xml', target_x = 0.0, 
    28                    target_y = 0.0, **kwargs): 
     27                   target_x = 0.0, target_y = 0.0, **kwargs): 
    2928        Door.__init__(self, ID = ID, name = name, text = text, gfx = gfx, 
    3029                      target_map_name = target_map_name, 
    31                       target_map = target_map, target_x = target_x, 
     30                      target_x = target_x, 
    3231                      target_y = target_y, **kwargs) 
Note: See TracChangeset for help on using the changeset viewer.