fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

bge/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import app as app
 from . import constraints as constraints
 from . import types as types

bge/app/__init__.pyi

@@ -6,6 +6,7 @@ Module to access application values that remain unchanged during runtime.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 has_joystick: bool
 """ True if the BGE has been built with joystick support.

bge/constraints/__init__.pyi

@@ -46,6 +46,7 @@ Constraint type to be used with createConstraint.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 def createConstraint(
     physicsid_1: int,
@@ -58,79 +59,63 @@ def createConstraint(
     axis_y: float = 0.0,
     axis_z: float = 0.0,
     flag: int = 0,
-):
+) -> None:
     """Creates a constraint.
 
     :param physicsid_1: The physics id of the first object in constraint.
-    :type physicsid_1: int
     :param physicsid_2: The physics id of the second object in constraint.
-    :type physicsid_2: int
     :param constraint_type: The type of the constraint, see Create Constraint Constants.
-    :type constraint_type: int
     :param pivot_x: Pivot X position. (optional)
-    :type pivot_x: float
     :param pivot_y: Pivot Y position. (optional)
-    :type pivot_y: float
     :param pivot_z: Pivot Z position. (optional)
-    :type pivot_z: float
     :param axis_x: X axis angle in degrees. (optional)
-    :type axis_x: float
     :param axis_y: Y axis angle in degrees. (optional)
-    :type axis_y: float
     :param axis_z: Z axis angle in degrees. (optional)
-    :type axis_z: float
     :param flag: 128 to disable collision between linked bodies. (optional)
-    :type flag: int
     :return: A constraint wrapper.
     """
 
-def createVehicle(physicsid: int):
+def createVehicle(physicsid: int) -> None:
     """Creates a vehicle constraint.
 
     :param physicsid: The physics id of the chassis object in constraint.
-    :type physicsid: int
     :return: A vehicle constraint wrapper.
     """
 
-def exportBulletFile(filename: str):
+def exportBulletFile(filename: str) -> None:
     """Exports a file representing the dynamics world (usually using .bullet extension).See Bullet binary serialization.
 
     :param filename: File path.
-    :type filename: str
     """
 
 def getAppliedImpulse(constraintId: int) -> float:
     """
 
     :param constraintId: The id of the constraint.
-    :type constraintId: int
     :return: The most recent applied impulse.
-    :rtype: float
     """
 
-def getCharacter(gameobj):
+def getCharacter(gameobj) -> None:
     """
 
     :param gameobj: The game object with the character physics.
     :return: Character wrapper.
     """
 
-def getVehicleConstraint(constraintId: int):
+def getVehicleConstraint(constraintId: int) -> None:
     """
 
     :param constraintId: The id of the vehicle constraint.
-    :type constraintId: int
     :return: A vehicle constraint object.
     """
 
-def removeConstraint(constraintId: int):
+def removeConstraint(constraintId: int) -> None:
     """Removes a constraint.
 
     :param constraintId: The id of the constraint to be removed.
-    :type constraintId: int
     """
 
-def setCFM(cfm):
+def setCFM(cfm) -> None:
     """Sets the Constraint Force Mixing (CFM) for soft constraints.
     If the Constraint Force Mixing (CFM) is set to zero, the constraint will be hard.
     If CFM is set to a positive value, it will be possible to violate the constraint by pushing on it (for example, for contact constraints by forcing the two contacting objects together).
@@ -139,42 +124,37 @@ def setCFM(cfm):
         :param cfm: The CFM parameter for soft constraints.
     """
 
-def setContactBreakingTreshold(breakingTreshold: float):
+def setContactBreakingTreshold(breakingTreshold: float) -> None:
     """Sets tresholds to do with contact point management.
 
     :param breakingTreshold: The new contact breaking treshold.
-    :type breakingTreshold: float
     """
 
-def setDeactivationAngularTreshold(angularTreshold: float):
+def setDeactivationAngularTreshold(angularTreshold: float) -> None:
     """Sets the angular velocity treshold.
 
     :param angularTreshold: New deactivation angular treshold.
-    :type angularTreshold: float
     """
 
-def setDeactivationLinearTreshold(linearTreshold: float):
+def setDeactivationLinearTreshold(linearTreshold: float) -> None:
     """Sets the linear velocity treshold.
 
     :param linearTreshold: New deactivation linear treshold.
-    :type linearTreshold: float
     """
 
-def setDeactivationTime(time: float):
+def setDeactivationTime(time: float) -> None:
     """Sets the time after which a resting rigidbody gets deactived.
 
     :param time: The deactivation time.
-    :type time: float
     """
 
-def setDebugMode(mode: int):
+def setDebugMode(mode: int) -> None:
     """Sets the debug mode.
 
     :param mode: The new debug mode, see Debug Mode Constants.
-    :type mode: int
     """
 
-def setERPContact(erp2):
+def setERPContact(erp2) -> None:
     """Sets the Error Reduction Parameter (ERP) for contact constraints.
     The Error Reduction Parameter (ERP) specifies what proportion of the joint error will be fixed during the next simulation step.
     If ERP = 0.0 then no correcting force is applied and the bodies will eventually drift apart as the simulation proceeds.
@@ -185,7 +165,7 @@ def setERPContact(erp2):
         :param erp2: The ERP parameter for contact constraints.
     """
 
-def setERPNonContact(erp):
+def setERPNonContact(erp) -> None:
     """Sets the Error Reduction Parameter (ERP) for non-contact constraints.
     The Error Reduction Parameter (ERP) specifies what proportion of the joint error will be fixed during the next simulation step.
     If ERP = 0.0 then no correcting force is applied and the bodies will eventually drift apart as the simulation proceeds.
@@ -196,57 +176,48 @@ def setERPNonContact(erp):
         :param erp: The ERP parameter for non-contact constraints.
     """
 
-def setGravity(x: float, y: float, z: float):
+def setGravity(x: float, y: float, z: float) -> None:
     """Sets the gravity force.Sets the linear air damping for rigidbodies.
 
     :param x: Gravity X force.
-    :type x: float
     :param y: Gravity Y force.
-    :type y: float
     :param z: Gravity Z force.
-    :type z: float
     """
 
-def setNumIterations(numiter: int):
+def setNumIterations(numiter: int) -> None:
     """Sets the number of iterations for an iterative constraint solver.
 
     :param numiter: New number of iterations.
-    :type numiter: int
     """
 
-def setNumTimeSubSteps(numsubstep: int):
+def setNumTimeSubSteps(numsubstep: int) -> None:
     """Sets the number of substeps for each physics proceed. Tradeoff quality for performance.
 
     :param numsubstep: New number of substeps.
-    :type numsubstep: int
     """
 
-def setSolverDamping(damping: float):
+def setSolverDamping(damping: float) -> None:
     """Sets the damper constant of a penalty based solver.
 
     :param damping: New damping for the solver.
-    :type damping: float
     """
 
-def setSolverTau(tau: float):
+def setSolverTau(tau: float) -> None:
     """Sets the spring constant of a penalty based solver.
 
     :param tau: New tau for the solver.
-    :type tau: float
     """
 
-def setSolverType(solverType: int):
+def setSolverType(solverType: int) -> None:
     """Sets the solver type.
 
     :param solverType: The new type of the solver.
-    :type solverType: int
     """
 
-def setSorConstant(sor: float):
+def setSorConstant(sor: float) -> None:
     """Sets the successive overrelaxation constant.
 
     :param sor: New sor value.
-    :type sor: float
     """
 
 ANGULAR_CONSTRAINT: int