Changeset 611


Ignore:
Timestamp:
08/01/10 08:59:18 (9 years ago)
Author:
beliar
Message:

Patch by Beliar.

  • Replaced old attribute system. Instead of is_<attribute> variables there is now a list of attributes that a class has. If the value of the attribute was needed its now saved in another variable. (e.g. is_living became lives)
Location:
trunk/game
Files:
7 edited

Legend:

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

    r610 r611  
    1414# along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1515 
    16 from scripts.objects.base import Container, SingleItemContainer as Slot 
     16from scripts.objects.base import Container 
     17from scripts.objects.composed import SingleItemContainer as Slot 
    1718 
    1819import copy 
  • trunk/game/scripts/objects/actors.py

    r609 r611  
    305305        CharacterBase.__init__(self, ID, agent_layer, inventory, text, **kwargs) 
    306306        self.people_i_know = set() 
    307         self.is_PC = True 
     307        self.attributes.append("PC") 
    308308   
    309309    def getStateForSaving(self): 
     
    361361        Scriptable.__init__(self, **kwargs) 
    362362 
    363         self.is_NPC = True 
     363        self.attributes.append("NPC") 
    364364        self.dialogue = dialogue 
    365365 
     
    376376        """ 
    377377        ret_dict = CharacterBase.getStateForSaving(self) 
    378         ret_dict["Lives"] = self.is_living 
     378        ret_dict["Lives"] = self.lives 
    379379        ret_dict["State"] = self.behaviour.state 
    380380        return ret_dict 
  • trunk/game/scripts/objects/base.py

    r610 r611  
    2727   2. In __init__() **ALWAYS** call the parent's __init__(**kwargs), preferably  
    2828      *at the end* of your __init__() (makes it easier to follow) 
    29    3. There should always be an is_x class member set to True on __init__  
     29   3. There should always be an attributes.append(x) call on __init__  
    3030      (where X is the name of the class) 
    3131 
     
    3434   class Openable(object): 
    3535       def __init__ (self, is_open = True, **kwargs): 
    36            self.is_openable = True 
     36           self.attribbutes.append("openable") 
    3737           self.is_open = is_open 
    3838           super(Openable,self).__init__ (**kwargs) 
     
    5454           self.name = 'Tin Can'""" 
    5555          
    56 class DynamicObject (object): 
    57     """A base class that only supports dynamic attributes functionality""" 
     56class BaseObject(object): 
     57    """A base class that supports dynamic attributes functionality""" 
     58    def __init__ (self): 
     59        if not self.__dict__.has_key("attributes"): 
     60            self.attributes = [] 
     61     
     62    def trueAttr(self, attr): 
     63        """Method that checks if the instance has an attribute""" 
     64        return attr in self.attributes 
     65 
     66    def getStateForSaving(self): 
     67        """Returns state for saving 
     68        """ 
     69        state = {} 
     70        state["attributes"] = self.attributes 
     71        return state 
     72 
     73class DynamicObject (BaseObject): 
     74    """Class with basic attributes""" 
    5875    def __init__ (self, name="Dynamic object", real_name=None, image=None, **kwargs): 
    5976        """Initialise minimalistic set of data 
     
    6279           @type image: String or None 
    6380           @param name: Filename of image to use in inventory""" 
     81        BaseObject.__init__(self) 
    6482        self.name = name 
    6583        self.real_name = real_name or name 
     
    87105    def __setstate__(self, state): 
    88106        self.restoreState(state) 
    89  
    90     def trueAttr(self, attr): 
    91         """Shortcut function to check if the current object has a member named 
    92            is_%attr and if that attribute evaluates to True""" 
    93         return hasattr(self,'is_%s' % attr) and getattr(self, 'is_%s' % attr) 
    94107     
    95108    def getStateForSaving(self): 
    96109        """Returns state for saving 
    97110        """ 
    98         state = {} 
     111        state = BaseObject.getStateForSaving(self) 
    99112        state["Name"] = self.name 
    100113        state["RealName"] = self.real_name 
     
    163176 
    164177 
    165 class Scriptable (object): 
     178class Scriptable (BaseObject): 
    166179    """Allows objects to have predefined scripts executed on certain events""" 
    167180    def __init__ (self, scripts = None, **kwargs): 
     
    170183           @param scripts: Dictionary where the event strings are keys. The  
    171184           values are 3-item tuples (function, positional_args, keyword_args)""" 
    172         self.is_scriptable = True 
     185        BaseObject.__init__(self) 
     186        self.attributes.append("scriptable") 
    173187        self.scripts = scripts or {} 
    174188         
     
    194208        DynamicObject.__init__(self, **kwargs) 
    195209        Scriptable.__init__(self, **kwargs) 
    196         self.is_openable = True 
     210        self.attributes.append("openable") 
    197211        self.is_open = is_open 
    198212     
     
    225239                           It is ignored if locked is True -- locked objects 
    226240                           are always closed.""" 
    227         self.is_lockable = True 
     241        self.attributes.append("lockable") 
    228242        self.locked = locked 
    229243        if locked : 
     
    251265    def __init__ (self, weight=0.0, bulk=0.0, **kwargs): 
    252266        DynamicObject.__init__(self, **kwargs) 
    253         self.is_carryable = True 
     267        self.attributes.append("carryable") 
    254268        self.in_container = None 
    255269        self.on_map = None 
     
    284298        DynamicObject.__init__(self, **kwargs) 
    285299        Scriptable.__init__(self, **kwargs) 
    286         self.is_container = True 
     300        self.attributes.append("container") 
    287301        self.items = {} 
    288302        self.capacity = capacity 
     
    441455        ret_state["Items"] = self.serializeItems() 
    442456        return ret_state 
    443  
    444 class SingleItemContainer (Container) : 
    445     """Container that can only store a single item. 
    446        This class can represent single-item inventory slots""" 
    447     def __init__ (self, **kwargs): 
    448         Container.__init__(self, **kwargs) 
    449  
    450     def placeItem(self,item, index=None): 
    451         if len(self.items) > 0 : 
    452             raise self.SlotBusy ('%s is already busy' % self) 
    453         Container.placeItem(self, item) 
    454          
    455 class Living (object): 
     457         
     458class Living (BaseObject): 
    456459    """Objects that 'live'""" 
    457460    def __init__ (self, **kwargs): 
    458         self.is_living = True 
     461        BaseObject.__init__(self) 
     462        self.attributes.append("living") 
     463        self.lives = True 
    459464 
    460465    def die(self): 
    461466        """Kills the object""" 
    462         self.is_living = False    
    463  
    464 class CharStats (object): 
     467        self.lives = False    
     468 
     469class CharStats (BaseObject): 
    465470    """Provides the object with character statistics""" 
    466471    def __init__ (self, **kwargs): 
    467         self.is_charstats = True 
    468          
    469 class Wearable (object): 
     472        BaseObject.__init__(self) 
     473        self.attributes.append("charstats") 
     474         
     475class Wearable (BaseObject): 
    470476    """Objects than can be weared""" 
    471477    def __init__ (self, slots, **kwargs): 
    472478        """Allows the object to be worn somewhere on the body (e.g. pants)""" 
    473         self.is_wearable = True 
     479        BaseObject.__init__(self) 
     480        self.attributes.append("wearable") 
    474481        if isinstance(slots, tuple) : 
    475482            self.slots = slots 
     
    477484            self.slots = (slots,) 
    478485     
    479 class Usable (object): 
     486class Usable (BaseObject): 
    480487    """Allows the object to be used in some way (e.g. a Zippo lighter  
    481488       to make a fire)""" 
    482489    def __init__ (self, actions = None, **kwargs): 
    483         self.is_usable = True 
     490        BaseObject.__init__(self) 
     491        self.attributes.append("usable") 
    484492        self.actions = actions or {}    
    485493         
    486 class Weapon (object): 
     494class Weapon (BaseObject): 
    487495    """Allows the object to be used as a weapon""" 
    488496    def __init__ (self, **kwargs): 
    489         self.is_weapon = True 
    490          
    491 class Destructable (object): 
     497        BaseObject.__init__(self) 
     498        self.attributes.append("weapon") 
     499         
     500class Destructable (BaseObject): 
    492501    """Allows the object to be destroyed""" 
    493502    def __init__ (self, **kwargs): 
    494         self.is_destructable = True 
    495          
    496 class Trappable (object): 
     503        BaseObject.__init__(self) 
     504        self.attributes.append("destructable") 
     505         
     506class Trapable (BaseObject): 
    497507    """Provides trap slots to the object""" 
    498508    def __init__ (self, **kwargs): 
    499         self.is_trappable = True 
     509        BaseObject.__init__(self) 
     510        self.attributes.append("trapable") 
  • trunk/game/scripts/objects/composed.py

    r610 r611  
    1919 
    2020from base import GameObject, Container, Lockable, \ 
    21                 Scriptable, Trappable, Destructable, Carryable, \ 
    22                 Usable, SingleItemContainer 
     21                Scriptable, Trapable, Destructable, Carryable, \ 
     22                Usable 
    2323 
    2424class ImmovableContainer(GameObject, Container, Lockable, Scriptable,  
    25                          Trappable, Destructable): 
     25                         Trapable, Destructable): 
    2626    """Composite class that can be used for crates, chests, etc.""" 
    2727    def __init__ (self, **kwargs): 
     
    3030        Lockable     .__init__(self, **kwargs) 
    3131        Scriptable   .__init__(self, **kwargs) 
    32         Trappable    .__init__(self, **kwargs) 
     32        Trapable    .__init__(self, **kwargs) 
    3333        Destructable .__init__(self, **kwargs) 
    3434        self.blocking = True 
     35 
     36class SingleItemContainer (Container) : 
     37    """Container that can only store a single item. 
     38       This class can represent single-item inventory slots""" 
     39    def __init__ (self, **kwargs): 
     40        Container.__init__(self, **kwargs) 
     41 
     42    def placeItem(self,item, index=None): 
     43        if len(self.items) > 0 : 
     44            raise self.SlotBusy ('%s is already busy' % self) 
     45        Container.placeItem(self, item) 
    3546     
    3647class CarryableItem (GameObject, Carryable, Usable): 
     
    113124        CarryableContainer.__init__(self, item_type, **kwargs) 
    114125         
    115 class Door(GameObject, Lockable, Scriptable, Trappable): 
     126class Door(GameObject, Lockable, Scriptable, Trapable): 
    116127    """Composite class that can be used to create doors on a map.""" 
    117128    def __init__ (self, target_map_name = 'my-map', 
     
    120131        Lockable.__init__(self, **kwargs) 
    121132        Scriptable.__init__(self, **kwargs) 
    122         Trappable.__init__(self, **kwargs) 
    123         self.is_door = True 
     133        Trapable.__init__(self, **kwargs) 
     134        self.attributes.append("door") 
    124135        self.target_map_name = target_map_name 
    125136        self.target_pos = (target_x, target_y) 
  • trunk/game/scripts/objects/containers.py

    r584 r611  
    8686        self.behaviour = None 
    8787 
    88         self.is_AnimatedContainer = True 
     88        self.attributes.append("AnimatedContainer") 
    8989        self.createBehaviour(agent_layer)         
    9090         
  • trunk/game/tests/test_living.py

    r584 r611  
    2424        """Test Living mixin die ability""" 
    2525        creature = Living(); 
    26         self.assertTrue(creature.is_living) 
     26        self.assertTrue(creature.lives) 
    2727        creature.die() 
    28         self.assertFalse(creature.is_living) 
     28        self.assertFalse(creature.lives) 
    2929 
    3030if __name__ == '__main__': 
  • trunk/game/tests/test_objects_base.py

    r584 r611  
    1717 
    1818import unittest 
    19 from scripts.objects.base import * 
     19from scripts.objects.base import GameObject, Lockable, Container, Living, \ 
     20                            Scriptable, CharStats, Wearable, Usable, Weapon, \ 
     21                            Destructable, Trapable, Carryable 
    2022 
    2123class TestObjectsBase(unittest.TestCase): 
     
    2426        class Wildcard (GameObject, Lockable, Container, Living, Scriptable, 
    2527                        CharStats, Wearable, Usable, Weapon, Destructable, 
    26                         Trappable, Carryable, ): 
     28                        Trapable, Carryable, ): 
    2729            def __init__ (self, ID, *args, **kwargs): 
    2830                self.name = 'All-purpose carry-all' 
     
    3840                Weapon.      __init__( self, **kwargs ) 
    3941                Destructable.__init__( self, **kwargs ) 
    40                 Trappable.   __init__( self, **kwargs ) 
     42                Trapable.   __init__( self, **kwargs ) 
    4143                Carryable.   __init__( self, **kwargs ) 
    4244        wc = Wildcard (2) 
     
    4446        # TODO: need to fill the rest of these tests out 
    4547 
     48         
    4649        attrs = dict( 
    47             is_openable = True, 
    48             is_open = True, 
    49             is_lockable = True, 
    50             locked = False, 
    51             is_carryable = True, 
    52             weight = 0.0, 
    53             bulk = 0.0, 
    54             is_container = True, 
    55             items = {}, 
    56             is_living = True, 
    57             is_scriptable = True 
     50            openable = {"is_open":True}, 
     51            lockable = {"locked":False}, 
     52            carryable = {"weight":0.0, "bulk":0.0}, 
     53            container = {"items":{}}, 
     54            living = {"lives":True}, 
     55            scriptable = {} 
    5856        ) 
    5957 
    6058        for attr in attrs: 
    61             self.assertEqual(getattr(wc, attr), attrs[attr]) 
     59            assert(wc.trueAttr(attr)) 
     60            for value in attrs[attr]: 
     61                self.assertEqual(getattr(wc, value), attrs[value]) 
Note: See TracChangeset for help on using the changeset viewer.