Class KX_GameObject

Delete this object, can be used inpace of the EndObject Actuator. The actual removal of the object from the scene is delayed.

Sets the game object's visible flag.

Parameters:

• visible (boolean)

Gets the game object's state bitmask.

Returns: int

the objects state.

Sets the game object's state flag. The bitmasks for states from 1 to 30 can be set with (1<<0, 1<<1, 1<<2 ... 1<<29)

Parameters:

• state (integer)

Sets the game object's position. Global coordinates for root object, local for child objects.

Parameters:

• pos ([x, y, z]) - the new position, in local coordinates.

Sets the game object's position in world coordinates regardless if the object is root or child.

Parameters:

• pos ([x, y, z]) - the new position, in world coordinates.

Gets the game object's position.

Returns: list [x, y, z]

the object's position in world coordinates.

Sets the game object's orientation.

Parameters:

• orn (3x3 rotation matrix, or Quaternion.) - a rotation matrix specifying the new rotation.

Aligns any of the game object's axis along the given vector.

Parameters:

• vect (3d vector.) - a vector to align the axis.
• axis (integer.) - The axis you want to align
  • 0: X axis
  • 1: Y axis
  • 2: Z axis (default)

Returns the axis vector rotates by the objects worldspace orientation. This is the equivalent if multiplying the vector by the orientation matrix.

Parameters:

• vect (3d vector.) - a vector to align the axis.

Returns: 3d vector.

The vector in relation to the objects rotation.

Gets the game object's orientation.

Returns: 3x3 rotation matrix

The game object's rotation matrix

Gets the game object's linear velocity.

This method returns the game object's velocity through it's centre of mass, ie no angular velocity component.

Parameters:

• local (boolean) - - False: you get the "global" velocity ie: relative to world orientation (default).
  • True: you get the "local" velocity ie: relative to object orientation.

Returns: list [vx, vy, vz]

the object's linear velocity.

Sets the game object's linear velocity.

This method sets game object's velocity through it's centre of mass, ie no angular velocity component.

Parameters:

• velocity (3d vector.) - linear velocity vector.
• local (boolean) - - False: you get the "global" velocity ie: relative to world orientation (default).
  • True: you get the "local" velocity ie: relative to object orientation.

Gets the game object's angular velocity.

Parameters:

• local (boolean) - - False: you get the "global" velocity ie: relative to world orientation (default).
  • True: you get the "local" velocity ie: relative to object orientation.

Returns: list [vx, vy, vz]

the object's angular velocity.

Sets the game object's angular velocity.

Parameters:

• velocity (3d vector.) - angular velocity vector.
• local (boolean) - - False: you get the "global" velocity ie: relative to world orientation (default).
  • True: you get the "local" velocity ie: relative to object orientation.

Gets the game object's velocity at the specified point.

Gets the game object's velocity at the specified point, including angular components.

Parameters:

• point (list [x, y, z]) - the point to return the velocity for, in local coordinates. (optional: default = [0, 0, 0])

Returns: list [vx, vy, vz]

the velocity at the specified point.

Gets the game object's mass.

Returns: float

the object's mass.

Gets the game object's reaction force.

The reaction force is the force applied to this object over the last simulation timestep. This also includes impulses, eg from collisions.

Returns: list [fx, fy, fz]

the reaction force of this object.

Applies an impulse to the game object.

This will apply the specified impulse to the game object at the specified point. If point != getPosition(), applyImpulse will also change the object's angular momentum. Otherwise, only linear momentum will change.

Parameters:

• point (list [x, y, z]) - the point to apply the impulse to (in world coordinates)

Resumes physics for this object.

Enables rigid body physics for this object.

Rigid body physics allows the object to roll on collisions.

Disables rigid body physics for this object.

Gets this object's parent.

Returns: KX_GameObject

this object's parent object, or None if this object has no parent.

Sets this object's parent.

Parameters:

• parent (KX_GameObject) - new parent object.

Return a list of immediate children of this object.

Returns: list

a list of all this objects children.

Return a list of children of this object, including all their childrens children.

Returns: list

a list of all this objects children recursivly.

Gets the mesh object for this object.

Parameters:

• mesh (integer) - the mesh object to return (optional: default mesh = 0)

Returns: KX_MeshProxy

the first mesh object associated with this game object, or None if this object has no meshs.

Gets a list of all property names.

Returns: list

All property names for this object.

Returns the distance to another object or point.

Parameters:

• other (KX_GameObject or list [x, y, z]) - a point or another KX_GameObject to measure the distance to.

Returns: float

Returns the vector and the distance to another object or point. The vector is normalized unless the distance is 0, in which a NULL vector is returned.

Parameters:

• other (KX_GameObject or list [x, y, z]) - a point or another KX_GameObject to get the vector and distance to.

Returns: 3-tuple (float, 3-tuple (x,y,z), 3-tuple (x,y,z))

(distance, globalVector(3), localVector(3))

Look towards another point/object and find first object hit within dist that matches prop.

The ray is always casted from the center of the object, ignoring the object itself. The ray is casted towards the center of another object or an explicit [x,y,z] point. Use rayCast() if you need to retrieve the hit point

Parameters:

• other (KX_GameObject or 3-tuple) - [x,y,z] or object towards which the ray is casted
• dist (float) - max distance to look (can be negative => look behind); 0 or omitted => detect up to other
• prop (string) - property name that object must have; can be omitted => detect any object

Returns: KX_GameObject

the first object hit or None if no object or object does not match prop

Look from a point/object to another point/object and find first object hit within dist that matches prop. if poly is 0, returns a 3-tuple with object reference, hit point and hit normal or (None,None,None) if no hit. if poly is 1, returns a 4-tuple with in addition a KX_PolyProxy as 4th element.

Ex:

       # shoot along the axis gun-gunAim (gunAim should be collision-free)
       ob,point,normal = gun.rayCast(gunAim,None,50)
       if ob:
               # hit something

Notes: The ray ignores the object on which the method is called. It is casted from/to object center or explicit [x,y,z] points.

The face paremeter determines the orientation of the normal:

 0 => hit normal is always oriented towards the ray origin (as if you casted the ray from outside)
 1 => hit normal is the real face normal (only for mesh object, otherwise face has no effect)

The ray has X-Ray capability if xray parameter is 1, otherwise the first object hit (other than self object) stops the ray. The prop and xray parameters interact as follow:

   prop off, xray off: return closest hit or no hit if there is no object on the full extend of the ray.
   prop off, xray on : idem.
   prop on,  xray off: return closest hit if it matches prop, no hit otherwise.
   prop on,  xray on : return closest hit matching prop or no hit if there is no object matching prop on the full extend of the ray.

The KX_PolyProxy 4th element of the return tuple when poly=1 allows to retrieve information on the polygon hit by the ray. If there is no hit or the hit object is not a static mesh, None is returned as 4th element.

The ray ignores collision-free objects and faces that dont have the collision flag enabled, you can however use ghost objects.

Parameters:

• objto (KX_GameObject or 3-tuple) - [x,y,z] or object to which the ray is casted
• objfrom (KX_GameObject or 3-tuple or None) - [x,y,z] or object from which the ray is casted; None or omitted => use self object center
• dist (float) - max distance to look (can be negative => look behind); 0 or omitted => detect up to to
• prop (string) - property name that object must have; can be omitted => detect any object
• face (int) - normal option: 1=>return face normal; 0 or omitted => normal is oriented towards origin
• xray (int) - X-ray option: 1=>skip objects that don't match prop; 0 or omitted => stop on first object
• poly (int) - polygon option: 1=>return value is a 4-tuple and the 4th element is a KX_PolyProxy

Returns: 3-tuple (KX_GameObject, 3-tuple (x,y,z), 3-tuple (nx,ny,nz)) or 4-tuple (KX_GameObject, 3-tuple (x,y,z), 3-tuple (nx,ny,nz), KX_PolyProxy)

(object,hitpoint,hitnormal) or (object,hitpoint,hitnormal,polygon) If no hit, returns (None,None,None) or (None,None,None,None) If the object hit is not a static mesh, polygon is None

mass

Type:

float

orientation

Type:

3x3 Matrix [[float]]

parent

Type:

KX_GameObject

scaling

Type:

list [sx, sy, sz]