Mercurial > parpg-core
annotate src/parpg/bGrease/component/__init__.py @ 70:ee350343b69b
Changed data subrepo to a grease specific one
| author | KarstenBock@gmx.net |
|---|---|
| date | Tue, 06 Sep 2011 15:39:27 +0200 |
| parents | 96af64cf3b81 |
| children | 0f659c7675f6 |
| rev | line source |
|---|---|
| 27 | 1 ############################################################################# |
| 2 # | |
| 3 # Copyright (c) 2010 by Casey Duncan and contributors | |
| 4 # All Rights Reserved. | |
| 5 # | |
| 6 # This software is subject to the provisions of the MIT License | |
| 7 # A copy of the license should accompany this distribution. | |
| 8 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| 9 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| 10 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
| 11 # | |
| 12 ############################################################################# | |
| 13 """Components store all entity data in a given |World|. You can | |
| 14 think of components as tables with entities as their primary keys. Like | |
| 15 database tables, components are defined with a "schema" that specifies | |
| 16 the data fields. Each field in a component has a name and a type. | |
| 17 | |
| 18 Component objects themselves have a dict-like interface with entities | |
| 19 as keys and data records as values. An application will typically | |
| 20 interact with components via entity attributes, entity extents or | |
| 21 by joining them. For more information see: | |
| 22 | |
| 23 - :class:`~grease.entity.Entity` class. | |
| 24 - :class:`~grease.world.EntityExtent` class. | |
| 25 - :meth:`~grease.world.ComponentParts.join` method of ComponentParts. | |
| 26 | |
| 27 See also :ref:`defining custom components in the tutorial <custom-component-example>`. | |
| 28 """ | |
| 29 | |
| 30 __version__ = '$Id$' | |
| 31 | |
| 32 __all__ = ('Component', 'ComponentError', 'Position', 'Transform', 'Movement', | |
| 33 'Shape', 'Renderable', 'Collision') | |
| 34 | |
|
66
96af64cf3b81
Renamed grease to bGrease (Basic Grease) to get rid of conflicts with an already installed grease.
KarstenBock@gmx.net
parents:
27
diff
changeset
|
35 from bGrease.component.general import Component |
|
96af64cf3b81
Renamed grease to bGrease (Basic Grease) to get rid of conflicts with an already installed grease.
KarstenBock@gmx.net
parents:
27
diff
changeset
|
36 from bGrease.geometry import Vec2d, Vec2dArray, Rect |
|
96af64cf3b81
Renamed grease to bGrease (Basic Grease) to get rid of conflicts with an already installed grease.
KarstenBock@gmx.net
parents:
27
diff
changeset
|
37 from bGrease import color |
| 27 | 38 |
| 39 | |
| 40 class ComponentError(Exception): | |
| 41 """General component error""" | |
| 42 | |
| 43 | |
| 44 class Position(Component): | |
| 45 """Predefined component that stores position and orientation info for | |
| 46 entities. | |
| 47 | |
| 48 Fields: | |
| 49 | |
| 50 - **position** (Vec2d) -- Position vector | |
| 51 - **angle** (float) -- Angle, in degrees | |
| 52 """ | |
| 53 | |
| 54 def __init__(self): | |
| 55 Component.__init__(self, position=Vec2d, angle=float) | |
| 56 | |
| 57 | |
| 58 class Transform(Component): | |
| 59 """Predefined component that stores offset, shear, | |
| 60 rotation and scale info for entity shapes. | |
| 61 | |
| 62 Fields: | |
| 63 | |
| 64 - **offset** (Vec2d) | |
| 65 - **shear** (Vec2d) | |
| 66 - **rotation** (float) | |
| 67 - **scale** (float, default 1.0) | |
| 68 """ | |
| 69 | |
| 70 def __init__(self): | |
| 71 Component.__init__(self, offset=Vec2d, shear=Vec2d, rotation=float, scale=float) | |
| 72 self.fields['scale'].default = lambda: 1.0 | |
| 73 | |
| 74 | |
| 75 class Movement(Component): | |
| 76 """Predefined component that stores velocity, | |
| 77 acceleration and rotation info for entities. | |
| 78 | |
| 79 Fields: | |
| 80 | |
| 81 - **velocity** (Vec2d) -- Rate of change of entity position | |
| 82 - **accel** (Vec2d) -- Rate of change of entity velocity | |
| 83 - **rotation** (Vec2d) -- Rate of change of entity angle, in degrees/time | |
| 84 """ | |
| 85 | |
| 86 def __init__(self): | |
| 87 Component.__init__(self, velocity=Vec2d, accel=Vec2d, rotation=float) | |
| 88 | |
| 89 | |
| 90 class Shape(Component): | |
| 91 """Predefined component that stores shape vertices for entities | |
| 92 | |
| 93 - **closed** (bool) -- If the shapes is closed implying an edge between | |
| 94 last and first vertices. | |
| 95 - **verts** (Vec2dArray) -- Array of vertex points | |
| 96 """ | |
| 97 | |
| 98 def __init__(self): | |
| 99 Component.__init__(self, closed=int, verts=Vec2dArray) | |
| 100 self.fields['closed'].default = lambda: 1 | |
| 101 | |
| 102 | |
| 103 class Renderable(Component): | |
| 104 """Predefined component that identifies entities to be | |
| 105 rendered and provides their depth and color. | |
| 106 | |
| 107 - **depth** (float) -- Drawing depth, can be used to determine z-order | |
| 108 while rendering. | |
| 109 - **color** (color.RGBA) -- Color used for entity. The effect of this | |
| 110 field depends on the renderer. | |
| 111 """ | |
| 112 | |
| 113 def __init__(self): | |
| 114 Component.__init__(self, depth=float, color=color.RGBA) | |
| 115 self.fields['color'].default = lambda: color.RGBA(1,1,1,1) | |
| 116 | |
| 117 | |
| 118 class Collision(Component): | |
| 119 """Predefined component that stores collision masks to determine | |
| 120 which entities can collide. | |
| 121 | |
| 122 Fields: | |
| 123 | |
| 124 - **aabb** (Rect) -- The axis-aligned bounding box for the entity. | |
| 125 This is used for broad-phase collision detection. | |
| 126 | |
| 127 - **radius** (float) -- The collision radius of the entity, used for narrow-phase | |
| 128 collision detection. The exact meaning of this value depends on the collision | |
| 129 system in use. | |
| 130 | |
| 131 - **from_mask** (int) -- A bitmask that determines what entities this object | |
| 132 can collide with. | |
| 133 | |
| 134 - **into_mask** (int) -- A bitmask that determines what entities can collide | |
| 135 with this object. | |
| 136 | |
| 137 When considering an entity A for collision with entity B, A's ``from_mask`` is | |
| 138 bit ANDed with B's ``into_mask``. If the result is nonzero (meaning 1 or more | |
| 139 bits is set the same for each) then the collision test is made. Otherwise, | |
| 140 the pair cannot collide. | |
| 141 | |
| 142 The default value for both of these masks is ``0xffffffff``, which means that | |
| 143 all entities will collide with each other by default. | |
| 144 """ | |
| 145 def __init__(self): | |
| 146 Component.__init__(self, aabb=Rect, radius=float, from_mask=int, into_mask=int) | |
| 147 self.fields['into_mask'].default = lambda: 0xffffffff | |
| 148 self.fields['from_mask'].default = lambda: 0xffffffff | |
| 149 |