pymunk.constraints 模块

约束是描述两个物体如何相互作用的东西。(它们如何相互约束)。约束可以是允许实体彼此旋转的简单关节，就像身体中的骨骼一样，也可以更抽象，比如齿轮关节或马达。

此子模块包含Pymunk支持的所有约束。

所有约束都支持从标准库复制和PICLE。在约束上设置的自定义属性也将被复制/拾取。

Chipmunk很好地概述了YouTube上的不同限制，它也很好地在Pymunk中展示了它们。Http://www.youtube.com/watch?v=ZgJJZTS0aMM

示例：：

>>> import pymunk
>>> import pymunk.constraints
>>> s = pymunk.Space()
>>> a,b = pymunk.Body(10,10), pymunk.Body(10,10)
>>> c = pymunk.constraints.PivotJoint(a, b, (0,0))
>>> s.add(c)

class pymunk.constraints.Constraint(constraint: pymunk._chipmunk.ffi.CData)

基类：PickleMixin, TypingAttrMixing, object

所有约束的基类。

您通常不想直接创建此类的实例，而是使用特定的约束之一，如PinJoint。

__init__(constraint: pymunk._chipmunk.ffi.CData) → None

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

class pymunk.constraints.DampedRotarySpring(a: Body, b: Body, rest_angle: float, stiffness: float, damping: float)

基类：Constraint

阻尼器旋转弹簧的工作原理与阻尼器弹簧类似，但角度不同。

__init__(a: Body, b: Body, rest_angle: float, stiffness: float, damping: float) → None

就像一个受潮的弹簧，但以一种棱角分明的方式工作。

参数:

• a (Body) -- 正文a

• b (Body) -- 正文b

• rest_angle (float) -- 物体希望具有的以弧度为单位的相对角度

• stiffness (float) -- 弹簧常数(杨氏模数)。

• damping (float) -- 使弹簧的湿气变得多么柔软。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property damping: float

使弹簧的湿气变得多么柔软。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

property rest_angle: float

物体希望具有的以弧度为单位的相对角度

property stiffness: float

弹簧常数(杨氏模数)。

class pymunk.constraints.DampedSpring(a: Body, b: Body, anchor_a: Tuple[float, float], anchor_b: Tuple[float, float], rest_length: float, stiffness: float, damping: float)

基类：Constraint

丹皮弹簧是一种受潮的弹簧。

弹簧允许您定义静止长度、刚度和阻尼值。

__init__(a: Body, b: Body, anchor_a: Tuple[float, float], anchor_b: Tuple[float, float], rest_length: float, stiffness: float, damping: float) → None

其定义与滑动关节非常相似。

参数:

• a (Body) -- 正文a

• b (Body) -- 正文b

• anchor_a ((float,float)) -- 相对于主体a的锚点a

• anchor_b ((float,float)) -- 相对于主体b的锚点b

• rest_length (float) -- 春天想要的距离。

• stiffness (float) -- 弹簧常数(杨氏模数)。

• damping (float) -- 使弹簧的湿气变得多么柔软。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property anchor_a: Vec2d

property anchor_b: Vec2d

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property damping: float

使弹簧的湿气变得多么柔软。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

property rest_length: float

春天想要的距离。

property stiffness: float

弹簧常数(杨氏模数)。

class pymunk.constraints.GearJoint(a: Body, b: Body, phase: float, ratio: float)

基类：Constraint

齿轮关节使一对实体的角速度比保持恒定。

__init__(a: Body, b: Body, phase: float, ratio: float)

保持一对物体的角速度比恒定。

比率总是以绝对值来衡量。目前还不可能设置与第三个物体的角速度相关的比率。相位是两个物体的初始角偏移量。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property phase: float

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

property ratio: float

class pymunk.constraints.GrooveJoint(a: Body, b: Body, groove_a: Tuple[float, float], groove_b: Tuple[float, float], anchor_b: Tuple[float, float])

基类：Constraint

GrooveJoint类似于PivotJoint，但带有线性滑块。

其中一个锚点是轴心可以滑动而不是固定的线段。

__init__(a: Body, b: Body, groove_a: Tuple[float, float], groove_b: Tuple[float, float], anchor_b: Tuple[float, float]) → None

槽从主体a上的槽a到槽b，枢轴连接到主体b上的锚b。

所有的坐标都是身体局部的。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property anchor_b: Vec2d

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property groove_a: Vec2d

property groove_b: Vec2d

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

class pymunk.constraints.PinJoint(a: Body, b: Body, anchor_a: Tuple[float, float] = (0, 0), anchor_b: Tuple[float, float] = (0, 0))

基类：Constraint

拼接使用实心条或销链接形状。

将锚点保持在彼此之间设定的距离。

__init__(a: Body, b: Body, anchor_a: Tuple[float, float] = (0, 0), anchor_b: Tuple[float, float] = (0, 0)) → None

A和B是要连接的两个实体，而锚_a和锚_b是这些实体上的锚点。

创建运动类型时测量两个锚点之间的距离。如果要设置特定距离，请使用setter函数覆盖它。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property anchor_a: Vec2d

property anchor_b: Vec2d

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property distance: float

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

class pymunk.constraints.PivotJoint(a: Body, b: Body, *args: Tuple[float, float] | Tuple[Tuple[float, float], Tuple[float, float]])

基类：Constraint

PivotJoint允许两个对象绕单个点旋转。

就像旋转一样。

__init__(a: Body, b: Body, *args: Tuple[float, float] | Tuple[Tuple[float, float], Tuple[float, float]]) → None

A和b是要连接的两个实体，轴心点是轴心点在世界坐标中的点。

因为枢轴位置是在世界坐标中给定的，所以您必须已经将躯干移动到正确的位置。或者，您可以基于一对锚点指定关节，但请确保将实体放置在正确的位置，因为一旦开始模拟空间，关节就会自动修复。

也就是说，要么使用PivotJoint(a，b，Pivot)创建关节，要么使用PivotJoint(a，b，锚_a，锚_b)创建关节。

参数:

• a (Body) -- 两具身体中的第一具

• b (Body) -- 两具身体中的第二具

• args ((float,float) or (float,float) (float,float)) -- 一个轴心点或两个锚点

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property anchor_a: Vec2d

property anchor_b: Vec2d

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

class pymunk.constraints.RatchetJoint(a: Body, b: Body, phase: float, ratchet: float)

基类：Constraint

RatchetJoint是一种旋转棘轮，它的工作原理就像套筒扳手。

__init__(a: Body, b: Body, phase: float, ratchet: float) → None

就像套筒扳手一样。

棘轮是“滴答声”之间的距离，相位是决定棘轮角度的初始偏移量。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property angle: float

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property phase: float

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

property ratchet: float

class pymunk.constraints.RotaryLimitJoint(a: Body, b: Body, min: float, max: float)

基类：Constraint

旋转限制关节约束两个实体的相对旋转。

__init__(a: Body, b: Body, min: float, max: float) → None

约束两个实体的相对旋转。

最小和最大是以弧度为单位的角度限制。它的实施是为了有可能使射程大于一整圈。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max: float

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property min: float

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

class pymunk.constraints.SimpleMotor(a: Body, b: Body, rate: float)

基类：Constraint

SimpleMotor保持相对角速度不变。

__init__(a: Body, b: Body, rate: float) → None

使一对物体的相对角速度保持恒定。

Rate是所需的相对角速度。您通常会希望为马达设置一个力(扭矩)最大值，否则它们将能够施加几乎无限大的扭矩来保持机构的运动。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None

property rate: float

所需的相对角速度

class pymunk.constraints.SlideJoint(a: Body, b: Body, anchor_a: Tuple[float, float], anchor_b: Tuple[float, float], min: float, max: float)

基类：Constraint

SlideJoint类似于PinJoint，但具有最小和最大距离。

可以使用此关节对链进行建模。它使锚点不会离得太远，但会让它们离得更近。

__init__(a: Body, b: Body, anchor_a: Tuple[float, float], anchor_b: Tuple[float, float], min: float, max: float) → None

A和b是要连接的两个实体，锚_a和锚_b是这两个实体上的锚点，而min和max定义了锚点的允许距离。

property a: Body

受约束的两个实体中的第一个

activate_bodies() → None

激活此约束附加到的实体

property anchor_a: Vec2d

property anchor_b: Vec2d

property b: Body

受约束的两个实体中的第二个

property collide_bodies: bool

约束也可用于过滤冲突。

当两个实体发生碰撞时，如果连接两个实体的任何约束的此属性设置为False，则Pymunk会忽略碰撞。默认为True。这可用于创建自碰撞的链，但链中的相邻链接不会碰撞。

copy() → T

创建此对象的深层副本。

property error_bias: float

在一秒后保持未固定的关节误差的百分比。

这与空间的碰撞偏移属性的工作原理完全相同，但适用于关节的固定错误(拉伸)，而不是重叠碰撞。

默认为POW(1.0-0.1，60.0)，这意味着它将每1/60秒纠正10%的错误。

property impulse: float

该约束应用的最新脉冲。

若要将其转化为力，请除以传递给space.step()的时间步长。您可以使用此选项来实现可断关节，以检查它们尝试施加的力是否超过某个阈值。

property max: float

property max_bias: float

约束可以应用纠错的最大速度。

默认为无穷大

property max_force: float

约束可用于作用于两个实体的最大力。

默认为无穷大

property min: float

property post_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行后调用后期求解函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def post_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.post_solve = post_solve_func
>>> j.post_solve = None

property pre_solve: Callable[[Constraint, Space], None] | None

在约束解算器运行之前调用预解算函数。

请注意，不能使用None将其重置为默认值。

>>> import pymunk
>>> j = pymunk.PinJoint(pymunk.Body(1,2), pymunk.Body(3,4), (0,0))
>>> def pre_solve_func(constraint, space):
...     print("Hello from pre-solve")
>>> j.pre_solve = pre_solve_func
>>> j.pre_solve = None