BGE patch: Add PyDoc for new logic bricks, set exception message on Py error, remove...
[blender.git] / source / gameengine / PyDoc / KX_ConstraintActuator.py
1 # $Id$
2 # Documentation for KX_ConstraintActuator
3 from SCA_IActuator import *
4
5 class KX_ConstraintActuator(SCA_IActuator):
6         """
7         A constraint actuator limits the position, rotation, distance or orientation of an object.
8         """
9         def setDamp(time):
10                 """
11                 Sets the time this constraint is delayed.
12                 
13                 @param time: The number of frames to delay.  
14                              Negative values are ignored.
15                 @type time: integer
16                 """
17         def getDamp():
18                 """
19                 Returns the damping time of the constraint.
20                 
21                 @rtype: integer
22                 """
23         def setMin(lower):
24                 """
25                 Sets the lower bound of the constraint.
26                 
27                 For rotational and orientation constraints, lower is specified in degrees.
28                 
29                 @type lower: float
30                 """
31         def getMin():
32                 """
33                 Gets the lower bound of the constraint.
34                 
35                 For rotational and orientation constraints, the lower bound is returned in radians.
36                 
37                 @rtype: float
38                 """
39         def setMax(upper):
40                 """
41                 Sets the upper bound of the constraint.
42                 
43                 For rotational and orientation constraints, upper is specified in degrees.
44                 
45                 @type upper: float
46                 """
47         def getMax():
48                 """
49                 Gets the upper bound of the constraint.
50                 
51                 For rotational and orientation constraints, the upper bound is returned in radians.
52                 
53                 @rtype: float
54                 """
55         def setLimit(limit):
56                 """
57                 Sets the type of constraint.
58                 
59                 See module L{GameLogic} for valid constraint types.
60                 
61                 @param limit: Position constraints: KX_CONSTRAINTACT_LOCX, KX_CONSTRAINTACT_LOCY, KX_CONSTRAINTACT_LOCZ, 
62                               Rotation constraints: KX_CONSTRAINTACT_ROTX, KX_CONSTRAINTACT_ROTY or KX_CONSTRAINTACT_ROTZ
63                               Distance contraints: KX_ACT_CONSTRAINT_DIRPX, KX_ACT_CONSTRAINT_DIRPY, KX_ACT_CONSTRAINT_DIRPZ,
64                                                    KX_ACT_CONSTRAINT_DIRNX, KX_ACT_CONSTRAINT_DIRNY, KX_ACT_CONSTRAINT_DIRNZ,
65                               Orientation constraints: KX_ACT_CONSTRAINT_ORIX, KX_ACT_CONSTRAINT_ORIY, KX_ACT_CONSTRAINT_ORIZ
66                 """
67         def getLimit():
68                 """
69                 Gets the type of constraint.
70                 
71                 See module L{GameLogic} for valid constraints.
72                 
73                 @return: Position constraints: KX_CONSTRAINTACT_LOCX, KX_CONSTRAINTACT_LOCY, KX_CONSTRAINTACT_LOCZ, 
74                          Rotation constraints: KX_CONSTRAINTACT_ROTX, KX_CONSTRAINTACT_ROTY, KX_CONSTRAINTACT_ROTZ,
75                          Distance contraints: KX_ACT_CONSTRAINT_DIRPX, KX_ACT_CONSTRAINT_DIRPY, KX_ACT_CONSTRAINT_DIRPZ,
76                                               KX_ACT_CONSTRAINT_DIRNX, KX_ACT_CONSTRAINT_DIRNY, KX_ACT_CONSTRAINT_DIRNZ,
77                          Orientation constraints: KX_ACT_CONSTRAINT_ORIX, KX_ACT_CONSTRAINT_ORIY, KX_ACT_CONSTRAINT_ORIZ
78                 """
79         def setRotDamp(duration):
80                 """
81                 Sets the time constant of the orientation constraint.
82                 
83                 @param duration: If the duration is negative, it is set to 0.
84                 @type duration: integer
85                 """
86         def getRotDamp():
87                 """ 
88                 Returns the damping time for application of the constraint.
89                 
90                 @rtype: integer
91                 """
92         def setDirection(vector):
93                 """
94                 Sets the reference direction in world coordinate for the orientation constraint
95                 
96                 @type vector: 3-tuple
97                 """
98         def getDirection():
99                 """
100                 Returns the reference direction of the orientation constraint in world coordinate.
101                 
102                 @rtype: 3-tuple
103                 """
104         def setOption(option):
105                 """
106                 Sets several options of the distance constraint.
107                 
108                 @type option: integer
109                 @param option: Binary combination of the following values:
110                                 64 : Activate alignment to surface
111                                128 : Detect material rather than property
112                                256 : No deactivation if ray does not hit target
113                                512 : Activate distance control
114                 """
115         def getOption():
116                 """
117                 Returns the option parameter.
118                 
119                 @rtype: integer
120                 """
121         def setTime(duration):
122                 """
123                 Sets the activation time of the actuator.
124                 
125                 @type duration: integer
126                 @param duration: The actuator disables itself after this many frame.
127                                  If set to 0 or negative, the actuator is not limited in time.
128                 """
129         def getTime():
130                 """
131                 Returns the time parameter.
132                 
133                 @rtype: integer
134                 """
135         def setProperty(property):
136                 """
137                 Sets the name of the property or material for the ray detection of the distance constraint.
138                 
139                 @type property: string
140                 @param property: If empty, the ray will detect any collisioning object.
141                 """
142         def getProperty():
143                 """
144                 Returns the property parameter.
145                 
146                 @rtype: string
147                 """
148         def setDistance(distance):
149                 """
150                 Sets the target distance in distance constraint.
151                 
152                 @type distance: float
153                 """
154         def getDistance():
155                 """
156                 Returns the distance parameter.
157                 
158                 @rtype: float
159                 """
160         def setRayLength(length):
161                 """
162                 Sets the maximum ray length of the distance constraint.
163                 
164                 @type length: float
165                 """
166         def getRayLength():
167                 """
168                 Returns the length of the ray
169                 
170                 @rtype: float
171                 """
172
173
174
175
176
177
178
179
180