Ignore:
Timestamp:
07/16/10 16:23:31 (9 years ago)
Author:
beliar
Message:

Patch by Beliar.

Location:
trunk/game/scripts/objects
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/scripts/objects/actors.py

    r584 r590  
    111111        else: 
    112112            self.idle_counter += 1             
    113  
    114 class PlayerCharacter (GameObject, Living, CharStats): 
    115     """PC class""" 
    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 ) 
    118         Living.__init__( self, **kwargs ) 
    119         CharStats.__init__( self, **kwargs ) 
    120  
    121         self.is_PC = True 
    122         self.behaviour = None 
    123          
    124         # PC _has_ an inventory, he _is not_ one 
    125         if inventory == None: 
    126             self.inventory = Inventory() 
    127             self.inventory.placeItem(CarryableItem(ID=456, name="Dagger123")) 
    128             self.inventory.placeItem(CarryableItem(ID=555, name="Beer")) 
    129             self.inventory.placeItem(CarryableItem(ID = 616, 
    130                                                    name = "Pamphlet", 
    131                                                    image = "/gui/inv_images/inv_pamphlet.png")) 
    132         else: 
    133             self.inventory = inventory 
    134         self.peopleIknow = set() 
    135  
    136         self.state = _AGENT_STATE_NONE 
    137         self.layer_id = agent_layer.getId() 
    138         self.createBehaviour(agent_layer) 
    139      
    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 
    149         """ 
    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      
    155     def meet(self, npc): 
    156         """Record that the PC has met a certain NPC 
    157            @type npc: str 
    158            @param npc: The NPC's name or id""" 
    159         if npc in self.peopleIknow: 
    160             # we could raise an error here, but should probably be a warn 
    161             # raise RuntimeError("I already know %s" % npc) 
    162             return 
    163         self.peopleIknow.add(npc) 
    164  
    165     def met(self, npc): 
    166         """Indicate whether the PC has met this npc before 
    167            @type npc: str 
    168            @param npc: The NPC's name or id 
    169            @return: None""" 
    170         return npc in self.peopleIknow 
    171  
    172     def createBehaviour(self, layer): 
    173         """Creates the behaviour for this actor. 
    174            @return: None""" 
    175         self.behaviour = PCBehaviour(self, layer) 
    176      
    177     def setup(self): 
    178         """@return: None""" 
    179         self.behaviour.attachToLayer(self.ID) 
    180  
    181     def start(self): 
    182         """@return: None""" 
    183         self.behaviour.idle() 
    184      
    185     def run(self, location): 
    186         """Makes the PC run to a certain location 
    187            @type location: fife.ScreenPoint 
    188            @param location: Screen position to run to. 
    189            @return: None""" 
    190         self.state = _AGENT_STATE_RUN 
    191         self.behaviour.nextAction = None 
    192         self.behaviour.agent.move('run', location, self.behaviour.speed+1) 
    193  
    194     def walk(self, location): 
    195         """Makes the PC walk to a certain location. 
    196            @type location: fife.ScreenPoint 
    197            @param location: Screen position to walk to. 
    198            @return: None""" 
    199         self.state = _AGENT_STATE_RUN 
    200         self.behaviour.nextAction = None  
    201         self.behaviour.agent.move('walk', location, self.behaviour.speed-1) 
    202  
    203     def teleport(self, location): 
    204         """Teleports a PC instantly to the given location. 
    205            @type location: fife.Location 
    206            @param location: Target coordinates for PC. 
    207            @return: None""" 
    208         self.state = _AGENT_STATE_IDLE 
    209         self.behaviour.nextAction = None  
    210         self.behaviour.agent.setLocation(location) 
    211  
    212     def approach(self, location, action = None): 
    213         """Approaches a location and then perform an action (if set). 
    214            @type loc: fife.Location 
    215            @param loc: the location to approach 
    216            @type action: Action 
    217            @param action: The action to schedule for execution after the approach. 
    218            @return: None""" 
    219         self.state = _AGENT_STATE_APPROACH 
    220         self.behaviour.nextAction = action 
    221         boxLocation = tuple([int(float(i)) for i in location]) 
    222         l = fife.Location(self.behaviour.agent.getLocation()) 
    223         l.setLayerCoordinates(fife.ModelCoordinate(*boxLocation)) 
    224         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") 
    240113 
    241114 
     
    305178        elif self.state == _AGENT_STATE_TALK: 
    306179            self.agent.act('stand', self.pc.getLocation()) 
    307  
    308 class NonPlayerCharacter(GameObject, Living, Scriptable, CharStats): 
    309     """NPC class""" 
    310     def __init__(self, ID, agent_layer=None, name='NPC', \ 
    311                  text = 'A nonplayer character', inventory = None,  
    312                  real_name = 'NPC', dialogue = None, **kwargs): 
    313         # init game object 
    314         GameObject.__init__(self, ID, name=name, real_name=real_name, text = text, **kwargs) 
    315         Living.__init__(self, **kwargs) 
    316         Scriptable.__init__(self, **kwargs) 
    317         CharStats.__init__(self, **kwargs) 
    318  
    319         self.is_NPC = True 
     180             
     181class CharacterBase(GameObject, Living, CharStats): 
     182    """Base class for Characters""" 
     183    def __init__(self, ID, agent_layer = None, inventory = None,  
     184                 text = "", **kwargs): 
     185        GameObject.__init__( self, ID, text = text, **kwargs ) 
     186        Living.__init__( self, **kwargs ) 
     187        CharStats.__init__( self, **kwargs ) 
     188         
    320189        self.behaviour = None 
    321         self.state = None 
    322190         
    323191        if inventory == None: 
     
    325193        else: 
    326194            self.inventory = inventory 
     195 
     196        self.state = _AGENT_STATE_NONE 
    327197        self.layer_id = agent_layer.getId() 
    328         self.createBehaviour(agent_layer)         
    329         self.dialogue = dialogue 
    330  
    331     def prepareStateForSaving(self, state): 
    332         """Prepares state for saving 
    333         @type state: dictionary 
    334         @param state: State of the object   
    335         """ 
    336         GameObject.prepareStateForSaving(self, state) 
    337         del state["behaviour"] 
    338  
    339     def getStateForSaving(self): 
    340         """Returns state for saving 
    341         """ 
    342         ret_dict = super(NonPlayerCharacter, self).getStateForSaving() 
    343         ret_dict["Lives"] = self.is_living 
    344         ret_dict["Inventory"] = self.inventory.serializeInventory() 
    345         ret_dict["State"] = self.behaviour.state 
    346         return ret_dict 
    347  
     198        self.createBehaviour(agent_layer) 
     199     
    348200    def createBehaviour(self, layer): 
    349201        """Creates the behaviour for this actor. 
    350            @return None """ 
    351         self.behaviour = NPCBehaviour(self, layer) 
     202           @return: None""" 
     203        pass 
     204     
     205    def setup(self): 
     206        """@return: None""" 
     207        self.behaviour.attachToLayer(self.ID) 
     208 
     209    def start(self): 
     210        """@return: None""" 
     211        self.behaviour.idle() 
     212 
     213    def teleport(self, location): 
     214        """Teleports a Character instantly to the given location. 
     215           @type location: fife.Location 
     216           @param location: Target coordinates for Character. 
     217           @return: None""" 
     218        self.state = _AGENT_STATE_IDLE 
     219        self.behaviour.nextAction = None  
     220        self.behaviour.agent.setLocation(location) 
     221 
     222    def hasItem(self, item_id): 
     223        """Returns wether an item is present in the players inventory or not 
     224        @param item_id: ID of the item 
     225        @type item_id: str 
     226        @return: True when the item is present, False when not""" 
     227        return self.inventory.findItem(item_id = item_id) 
     228 
     229    def itemCount(self, item_id = ""): 
     230        """Returns number of all items or items specified by item_id  
     231        the player has. 
     232        @param item_id: ID of the item, can be empty 
     233        @type item_id: str 
     234        @return: Number of items""" 
     235        return self.inventory.count(item_id) 
    352236 
    353237    def getLocation(self): 
     
    358242        return self.behaviour.agent.getLocation() 
    359243     
    360     def teleport(self, location): 
    361         """Teleports a NPC instantly to the given location. 
    362            @type location: fife.Location 
    363            @param location: Target coordinates for PC. 
    364            @return: None""" 
    365         self.state = _AGENT_STATE_IDLE 
     244    def run(self, location): 
     245        """Makes the PC run to a certain location 
     246           @type location: fife.ScreenPoint 
     247           @param location: Screen position to run to. 
     248           @return: None""" 
     249        self.state = _AGENT_STATE_RUN 
     250        self.behaviour.nextAction = None 
     251        self.behaviour.agent.move('run', location, self.behaviour.speed+1) 
     252 
     253    def walk(self, location): 
     254        """Makes the PC walk to a certain location. 
     255           @type location: fife.ScreenPoint 
     256           @param location: Screen position to walk to. 
     257           @return: None""" 
     258        self.state = _AGENT_STATE_RUN 
    366259        self.behaviour.nextAction = None  
    367         self.behaviour.agent.setLocation(location) 
     260        self.behaviour.agent.move('walk', location, self.behaviour.speed-1) 
     261 
     262    def getStateForSaving(self): 
     263        """Returns state for saving 
     264        """ 
     265        ret_dict = GameObject.getStateForSaving(self) 
     266        ret_dict["Inventory"] = self.inventory.serializeInventory() 
     267        return ret_dict 
     268 
     269    def _getCoords(self): 
     270        """Get-er property function""" 
     271        return (self.getLocation().getMapCoordinates().x,  
     272                self.getLocation().getMapCoordinates().y) 
     273     
     274    def _setCoords(self, coords): 
     275        """Set-er property function""" 
     276        map_coords = self.getLocation().getMapCoordinates() 
     277        map_coords.X, map_coords.Y = float(coords[0]), float (coords[1]) 
     278        self.teleport(map_coords) 
     279     
     280    coords = property (_getCoords, _setCoords,  
     281        doc = "Property allowing you to get and set the object's \ 
     282                coordinates via tuples") 
     283            
     284class PlayerCharacter (CharacterBase): 
     285    """PC class""" 
     286    def __init__ (self, ID, agent_layer = None, inventory = None,  
     287                  text = "Its you. Who would've thought that?", **kwargs): 
     288        if inventory == None: 
     289            inventory = Inventory() 
     290            inventory.placeItem(CarryableItem(ID=456, name="Dagger123")) 
     291            inventory.placeItem(CarryableItem(ID=555, name="Beer")) 
     292            inventory.placeItem(CarryableItem(ID = 616, 
     293                                    name = "Pamphlet", 
     294                                    image = "/gui/inv_images/inv_pamphlet.png")) 
     295        CharacterBase.__init__(self, ID, agent_layer, inventory, text, **kwargs) 
     296        self.people_i_know = set() 
     297        self.is_PC = True 
     298   
     299    def getStateForSaving(self): 
     300        """Returns state for saving 
     301        """ 
     302        ret_dict = super(PlayerCharacter, self).getStateForSaving() 
     303        ret_dict["PeopleKnown"] = self.people_i_know 
     304        return ret_dict 
     305     
     306    def meet(self, npc): 
     307        """Record that the PC has met a certain NPC 
     308           @type npc: str 
     309           @param npc: The NPC's name or id""" 
     310        if npc in self.people_i_know: 
     311            # we could raise an error here, but should probably be a warn 
     312            # raise RuntimeError("I already know %s" % npc) 
     313            return 
     314        self.people_i_know.add(npc) 
     315 
     316    def met(self, npc): 
     317        """Indicate whether the PC has met this npc before 
     318           @type npc: str 
     319           @param npc: The NPC's name or id 
     320           @return: None""" 
     321        return npc in self.people_i_know 
     322 
     323    def createBehaviour(self, layer): 
     324        """Creates the behaviour for this actor. 
     325           @return: None""" 
     326        self.behaviour = PCBehaviour(self, layer) 
     327  
     328    def approach(self, location, action = None): 
     329        """Approaches a location and then perform an action (if set). 
     330           @type loc: fife.Location 
     331           @param loc: the location to approach 
     332           @type action: Action 
     333           @param action: The action to schedule for execution after the approach. 
     334           @return: None""" 
     335        self.state = _AGENT_STATE_APPROACH 
     336        self.behaviour.nextAction = action 
     337        boxLocation = tuple([int(float(i)) for i in location]) 
     338        l = fife.Location(self.behaviour.agent.getLocation()) 
     339        l.setLayerCoordinates(fife.ModelCoordinate(*boxLocation)) 
     340        self.behaviour.agent.move('run', l, self.behaviour.speed+1) 
     341     
     342class NonPlayerCharacter(CharacterBase, Scriptable): 
     343    """NPC class""" 
     344    def __init__(self, ID, agent_layer=None, name='NPC', \ 
     345                 text = 'A nonplayer character', inventory = None,  
     346                 real_name = 'NPC', dialogue = None, **kwargs): 
     347        # init game object 
     348        CharacterBase.__init__(self, ID, agent_layer = agent_layer,  
     349                               inventory = inventory, name=name,  
     350                               real_name=real_name, text = text, **kwargs) 
     351        Scriptable.__init__(self, **kwargs) 
     352 
     353        self.is_NPC = True 
     354        self.dialogue = dialogue 
     355 
     356    def prepareStateForSaving(self, state): 
     357        """Prepares state for saving 
     358        @type state: dictionary 
     359        @param state: State of the object   
     360        """ 
     361        CharacterBase.prepareStateForSaving(self, state) 
     362        del state["behaviour"] 
     363 
     364    def getStateForSaving(self): 
     365        """Returns state for saving 
     366        """ 
     367        ret_dict = CharacterBase.getStateForSaving(self) 
     368        ret_dict["Lives"] = self.is_living 
     369        ret_dict["State"] = self.behaviour.state 
     370        return ret_dict 
     371 
     372    def createBehaviour(self, layer): 
     373        """Creates the behaviour for this actor. 
     374           @return None """ 
     375        self.behaviour = NPCBehaviour(self, layer) 
    368376 
    369377    def wander(self, location): 
     
    373381           @return: None""" 
    374382        self.behaviour.agent.move('walk', location, self.behaviour.speed-1) 
    375  
    376     def run(self, location): 
    377         """Faster movement than walk. 
    378            @type location: fife.Location 
    379            @param location: Where the NPC will run to.""" 
    380         self.behaviour.agent.move('run', location, self.behaviour.speed+1) 
    381383 
    382384    def talk(self, pc): 
     
    396398        self.inventory.takeItem(item) 
    397399        actor.inventory.placeItem(item)            
    398      
    399     def setup(self): 
    400         """@return: None""" 
    401         self.behaviour.attachToLayer(self.ID) 
    402  
    403     def start(self): 
    404         """@return: None""" 
    405         self.behaviour.idle() 
    406  
    407     def _getCoords(self): 
    408         """Get-er property function""" 
    409         return (self.getLocation().getMapCoordinates().x,  
    410                 self.getLocation().getMapCoordinates().y) 
    411      
    412     def _setCoords(self, coords): 
    413         """Set-er property function""" 
    414         map_coords = self.getLocation().getMapCoordinates() 
    415         map_coords.X, map_coords.Y = float(coords[0]), float (coords[1]) 
    416         self.teleport(map_coords) 
    417  
    418     coords = property (_getCoords, _setCoords,  
    419         doc = "Property allowing you to get and set the object's \ 
    420                 coordinates via tuples") 
  • trunk/game/scripts/objects/base.py

    r584 r590  
    360360            pass 
    361361 
    362     def count (self): 
     362    def count (self, item_id = ""): 
    363363        """Returns the number of items""" 
    364         return len(self.items) 
    365  
     364        if item_id: 
     365            ret_count = 0 
     366            for index in self.items : 
     367                if self.items[index].item_id == item_id: 
     368                    ret_count += 1 
     369            return ret_count 
     370        return len(self.items)    
     371     
    366372    def getContentsBulk(self): 
    367373        """Bulk of the container contents""" 
     
    384390    def findItemByItemID(self, item_id): 
    385391        """Returns the item with the passed item_id""" 
    386         for i in self.items : 
    387             if self.items[i].item_id == item_id: 
    388                 return self.items[i] 
     392        for index in self.items : 
     393            if self.items[index].item_id == item_id: 
     394                return self.items[index] 
    389395        return None 
    390396 
     
    396402           @param kind: One of the possible object types 
    397403           @return: The item matching criteria or None if none was found""" 
    398         for i in self.items : 
    399             if "name" in kwargs and self.items[i].name != kwargs["name"]: 
     404        for index in self.items : 
     405            if "name" in kwargs and self.items[index].name != kwargs["name"]: 
    400406                continue 
    401             if "ID" in kwargs and self.items[i].ID != kwargs["ID"]: 
     407            if "ID" in kwargs and self.items[index].ID != kwargs["ID"]: 
    402408                continue 
    403             if "kind" in kwargs and not self.items[i].trueAttr(kwargs["kind"]): 
     409            if "kind" in kwargs and not self.items[index].trueAttr(kwargs["kind"]): 
    404410                continue 
    405             if "item_id" in kwargs and self.items[i].item_id != kwargs["item_id"]: 
     411            if "item_id" in kwargs and self.items[index].item_id != kwargs["item_id"]: 
    406412                continue 
    407             return self.items[i] 
     413            return self.items[index] 
    408414        return None 
    409415     
Note: See TracChangeset for help on using the changeset viewer.