API参考¶

`pymunk` 套餐¶

子模块

..评论

Pymunk

Pymunk是一个易于使用的 Python 2D物理库，可以在您需要来自Python的2D刚体物理时使用。

主页：http://www.pymunk.org

这是《Pymunk》的主要包含模块。它包含非常中心的空间、身体和形状类别。

class pymunk.Arbiter(_arbiter: pymunk._chipmunk.ffi.CData, space: Space)[源代码]¶

基类：object

仲裁器对象封装了一对冲突形状和所有

关于它们碰撞的数据。

它们是在碰撞开始时创建的，并且一直持续到这些图形不再碰撞为止。

警告

因为仲裁器是由空间处理的，你永远不应该持有对仲裁器的引用，因为你不知道它什么时候会被销毁！在给你的回调中使用它们，然后忘记它们，或者从它们那里复制出你需要的信息。

__init__(_arbiter: pymunk._chipmunk.ffi.CData, space: Space) → None[源代码]¶: 从Chipmunk等价结构和空间中初始化一个仲裁器对象。

备注

您永远不需要直接创建此类的实例。

property contact_point_set: ContactPointSet¶

接触点设置使从仲裁器获取联系信息变得更简单。

返回 ContactPointSet

property friction: float¶

此碰撞对的计算摩擦力。

在presolve()回调中设置该值将覆盖由空格计算的值。默认计算是将两个形状的摩擦力相乘。

property is_first_contact: bool¶

如果这是两个形状开始接触的第一步，则返回True。

例如，这对于音效很有用。如果这是某个碰撞的第一帧，请在post_Step()回调中检查碰撞的能量，并使用该能量来确定要播放的音效的音量。

property is_removal: bool¶: 如果由于对象移除而调用回调，则在单独的()回调期间返回True。

property normal: Vec2d¶: 返回碰撞的法线。

property restitution: float¶

此碰撞对的计算恢复(弹性)。

在presolve()回调中设置该值将覆盖由空格计算的值。默认计算将两个形状的弹性相乘。

property shapes: Tuple[Shape, Shape]¶: 按照在与此仲裁器关联的冲突处理程序中定义的顺序获取形状

property surface_velocity: Vec2d¶

为该碰撞对计算的表面速度。

在presolve()回调中设置该值将覆盖由空格计算的值。默认计算从第一个图形减去第二个图形的曲面速度，然后将其投影到碰撞的切线上。这是为了使默认计算只影响摩擦力。使用自定义计算，您可以做出类似于弹球保险杠的响应，或者表面速度取决于接触点位置的情况。

property total_impulse: Vec2d¶

返回应用此步骤以解决冲突的脉冲。

此属性只能从后期解析回调或每个_仲裁器回调中调用。

property total_ke: float¶

碰撞中损失的能量，包括静态摩擦，但不包括动态摩擦。

此属性只能从后期解析回调或每个_仲裁器回调中调用。

class pymunk.BB(left: float = 0, bottom: float = 0, right: float = 0, top: float = 0)[源代码]¶

基类：NamedTuple

简单的轴对齐的二维边界框。

存储为左、下、右、上的值。

创建实例的方式如下：

>>> BB(left=1, bottom=5, right=20, top=10)
BB(left=1, bottom=5, right=20, top=10)

或者部分地，例如这样：

>>> BB(right=5, top=10)
BB(left=0, bottom=0, right=5, top=10)

area() → float[源代码]¶: 退还该地区

bottom: float¶: 字段号%1的别名

center() → Vec2d[源代码]¶: 回击中锋

clamp_vect(v: Tuple[float, float]) → Vec2d[源代码]¶: 返回夹在边界框中的向量v的副本

contains(other: BB) → bool[源代码]¶: 如果BB Complete包含另一个BB，则返回TRUE

contains_vect(v: Tuple[float, float]) → bool[源代码]¶: 如果此bb包含向量v，则返回TRUE

expand(v: Tuple[float, float]) → BB[源代码]¶: 返回包含此边界框和向量v的最小边界框

intersects(other: BB) → bool[源代码]¶: 如果边界框相交，则返回True

intersects_segment(a: Tuple[float, float], b: Tuple[float, float]) → bool[源代码]¶: 如果端点a和b定义的线段与此bb相交，则返回TRUE。

left: float¶: 字段号0的别名

merge(other: BB) → BB[源代码]¶: 返回同时包含此BB和其他BB的最小边界框

merged_area(other: BB) → float[源代码]¶: 合并这个和其他，然后返回合并的边界框的面积。

static newForCircle(p: Tuple[float, float], r: float) → BB[源代码]¶: 用于使BB与半径为r的圆在位置p处拟合的方便构造器。

right: float¶: 字段号2的别名

segment_query(a: Tuple[float, float], b: Tuple[float, float]) → float[源代码]¶

返回沿分段查询BB命中的分数。

如果没有命中，则返回无穷大

top: float¶: 第3号字段的别名

class pymunk.Body(mass: float = 0, moment: float = 0, body_type: int = DYNAMIC)[源代码]¶

基类：PickleMixin, TypingAttrMixing, object

刚体

如果可能，使用力来修改刚体。这可能是最稳定的一次。
不一定要避免修改物体的速度，但应用较大的更改可能会在模拟中导致奇怪的结果。可以自由尝试，但要注意。
除非你真的知道自己在做什么，否则不要每一步都改变身体的位置。否则，你的位置/速度很可能会严重不同步。

身体可以被复制和腌制。被复制的沉睡的身体将在新的副本中苏醒。复制实体时，不会复制附着到实体的任何空间、造型或约束。

DYNAMIC: ClassVar[int]¶

动力学实体是默认的实体类型。

它们对碰撞做出反应，受力和重力的影响，质量有限。这些是您希望物理引擎为您模拟的实体类型。动力学实体与所有类型的实体交互，并可以生成碰撞回调。

KINEMATIC: ClassVar[int]¶

运动学实体是由代码控制的实体，而不是在物理引擎内部。

它们不受重力的影响，质量无限大，因此它们不会对与其他物体的碰撞或力产生反应。运动学实体通过设置它们的速度来控制，这将使它们移动。运动学物体的好例子可能包括像移动平台这样的东西。接触或连接到运动学物体的物体永远不允许入睡。

STATIC: ClassVar[int]¶

静态物体是从不(或很少)移动的物体。

与其他类型的物体相比，使用静态物体来处理地形提供了很大的性能提升--因为Chipmunk不需要检查静态物体之间的碰撞，而且它永远不需要更新碰撞信息。此外，由于静态物体不会移动，Chipmunk知道让接触或连接到它们的物体睡着是安全的。通常，除了移动平台或门之外，所有关卡几何体都将附加到静态实体上。每个空间都有一个内置的静态车身，方便您使用。静态实体可以移动，但在重新计算碰撞信息时会影响性能。拥有多个静态实体不会有任何影响，它可以通过允许分别初始化或移动静态几何体的不同部分来简化代码。

__init__(mass: float = 0, moment: float = 0, body_type: int = DYNAMIC) → None[源代码]¶

创建新实体

当BODY_TYPE为运动学或静态时，质量和力矩将被忽略。

猜测物体的质量通常是可以的，但猜测惯性矩可能会导致非常糟糕的模拟，因此建议使用Chipmunk的矩计算来为您估计时刻。

有两种方法可以设置动力学实体。最简单的选择是创建一个质量和力矩为0的实体，并设置添加到该实体的每个碰撞图形的质量或密度。Chipmunk会自动为你计算质量、转动惯量和重心。在大多数情况下，这可能是首选的。请注意，只有在将主体和形状添加到空间后，才能正确计算这些值。

另一种选择是在创建实体时设置其质量，并将添加到其上的形状的质量保留为0.0。这种方法更灵活，但不太容易使用。不要同时设置身体和形状的质量。如果这样做，当形状添加到实体时，它将重新计算并覆盖您的自定义质量值。

设置质量和力矩的不同方法示例：

>>> import pymunk
>>> radius = 2
>>> mass = 3
>>> density = 3
>>> def print_mass_moment(b):
...    print("mass={:.0f} moment={:.0f}".format(b.mass, b.moment))

>>> # Using Shape.density
>>> s = pymunk.Space()
>>> b = pymunk.Body()
>>> c = pymunk.Circle(b, radius)
>>> c.density = density
>>> print_mass_moment(b)
mass=0 moment=0
>>> s.add(b, c)
>>> print_mass_moment(b)
mass=38 moment=75

>>> # Using Shape.mass
>>> b = pymunk.Body()
>>> c = pymunk.Circle(b, radius)
>>> c.mass = mass
>>> print_mass_moment(b)
mass=0 moment=0
>>> s.add(b, c)
>>> print_mass_moment(b)
mass=3 moment=6

>>> # Using Body constructor
>>> moment = pymunk.moment_for_circle(mass, 0, radius)
>>> b = pymunk.Body()
>>> c = pymunk.Circle(b, radius)
>>> c.mass = mass
>>> print_mass_moment(b)
mass=0 moment=0
>>> s.add(b, c)
>>> print_mass_moment(b)
mass=3 moment=6

将多个图形附加到一个实体时，使用图形的质量或密度属性会变得更加有用，如下面的密度示例所示：

>>> # Using multiple Shape.density
>>> b = pymunk.Body()
>>> c1 = pymunk.Circle(b, radius, offset=(10,0))
>>> c1.density = density
>>> c2 = pymunk.Circle(b, radius, offset=(0,10))
>>> c2.density = density
>>> s.add(b, c1, c2)
>>> print_mass_moment(b)
mass=75 moment=3921

activate() → None[源代码]¶

重置车身上的空闲计时器。

如果它睡着了，叫醒它和它接触到的任何其他身体。

property angle: float¶

身体以弧度为单位的旋转。

在更改轮换时，您可能还希望调用 Space.reindex_shapes_for_body() 如果计划对空间进行任何查询，请更新附加形状的碰撞检测信息。物体围绕其重心旋转，而不是围绕其位置旋转。

备注

如果角度变化很小/没有变化，例如球沿着坡道滚动，这可能是因为附着在主体上的圆形形状或坡度形状没有设置任何摩擦力。

property angular_velocity: float¶: 物体的角速度，以弧度每秒为单位。

apply_force_at_local_point(force: Tuple[float, float], point: Tuple[float, float] = (0, 0)) → None[源代码]¶: 将局部力添加到躯干，就像从躯干局部点施加的力一样。

apply_force_at_world_point(force: Tuple[float, float], point: Tuple[float, float]) → None[源代码]¶

将力添加到躯干，就像从世界点施加的力一样。

人们有时会被力和冲动之间的区别弄糊涂。冲量是在非常短的时间内施加的非常大的力。一些例子是球撞墙或发射大炮。Chipmunk通过直接增加物体的速度来处理脉冲，就像它们是瞬间发生的一样。冲力和力都受物体质量的影响。将物体的质量加倍将使效果减半。

apply_impulse_at_local_point(impulse: Tuple[float, float], point: Tuple[float, float] = (0, 0)) → None[源代码]¶: 将局部冲动添加到身体上，就像从身体局部施加的一样。

apply_impulse_at_world_point(impulse: Tuple[float, float], point: Tuple[float, float]) → None[源代码]¶: 把冲动加到身体上，就像是从世界的角度施加的。

property body_type: int¶

身体的类型 (Body.DYNAMIC ， Body.KINEMATIC 或 Body.STATIC )。

将实体更改为动态实体时，将根据添加到实体的形状重新计算质量和转动惯量。更改类型时，不会保留自定义计算的惯性矩。不能在冲突回调中直接调用此函数。

property center_of_gravity: Vec2d¶

重心在身体局部坐标中的位置。

默认值为(0，0)，表示重心与身体的位置相同。

property constraints: Set[Constraint]¶

获取此实体所附加的约束。

无法将实体从约束中拆离。唯一的方法是通过从任何空间中删除约束并删除对它的任何其他引用来完全删除约束。主体只保留对约束的弱引用，这意味着当删除对约束的所有其他引用并且对约束进行垃圾收集时，它也将自动从该集合中删除。

copy() → T¶: 创建此对象的深层副本。

each_arbiter(func: Callable[[...], None], *args: Any, **kwargs: Any) → None[源代码]¶

在这个实体上的每个仲裁者上运行Func。

func(arbiter, *args, **kwargs) -> None

回调参数

仲裁者 : Arbiter仲裁者
《仲裁者》

ARGS
传递给回调函数的可选参数。

科瓦格人
传递给回调函数的可选关键字参数。

警告

回调后不要紧抓仲裁员！

property force: Vec2d¶

施加在身体重心上的力。

对于每个时间点，该值都会被重置。请注意，这不是作用在身体上的力(例如来自碰撞)的总和，而是从应用力功能手动应用的力。

property id: int¶

正文的唯一ID。

身体的副本(或泡菜)将获得新的ID。

备注

实验性API。在未来的主要、次要或重点版本中可能会发生变化。

property is_sleeping: bool¶: 如果主体处于睡眠状态，则返回True。

property kinetic_energy: float¶: 得到物体的动能。

local_to_world(v: Tuple[float, float]) → Vec2d[源代码]¶

将身体局部坐标转换为世界空间坐标

很多东西都是在身体的局部坐标中定义的，这意味着(0，0)位于身体的重心，轴与身体一起旋转。

参数:: v -- 身体局部坐标中的矢量

property mass: float¶: 身体的质量。

property moment: float¶

身体的转动惯量(MOI或有时只是力矩)。

这个力矩就像一个物体的转动质量。

property position: Vec2d¶

身体的位置。

当更改位置时，您可能还想要呼叫 Space.reindex_shapes_for_body() 如果计划对空间进行任何查询，请更新附加形状的碰撞检测信息。

property position_func¶

位置回调函数。

每个时间点都会调用位置回调函数，该函数可用于更新身体的位置。

func(body, dt) -> None

property rotation_vector: Vec2d¶: 身体的旋转向量。

property shapes: Set[Shape]¶

把这些形状附在这个身体上。

主体只保留对形状的弱引用，活的主体不会阻止附加的形状的GC

sleep() → None[源代码]¶

迫使身体立即入睡，即使在半空中也是如此。

不能从回调中调用。

sleep_with_group(body: Body) → None[源代码]¶

强迫一个身体立即和一组中的其他身体一起入睡。

当Pymunk中的对象进入睡眠状态时，它们将作为一组正在接触或连接在一起的对象进入睡眠状态。当一个对象被唤醒时，其组中的所有对象都被唤醒。 Body.sleep_with_group() 允许您将休眠对象分组在一起。它的作用与 Body.sleep() 如果您通过启动一个新组将None作为组传递。如果你将一个沉睡的身体传递给群，当群被唤醒时，身体会被唤醒。您可以使用它来初始化级别并启动处于预睡眠状态的对象堆栈。

property space: Space | None¶: vt.得到. Space 该正文已被添加到(或没有)。

property torque: float¶

施加在车身上的扭矩。

对于每个时间点，该值都会被重置。

static update_position(body: Body, dt: float) → None[源代码]¶

默认刚体位置积分功能。

使用Euler积分更新实体的位置。与速度函数不同，您不太可能想要覆盖此函数。如果你这样做了，确保你理解它的源代码(在Chipmunk中)，因为它是碰撞/关节校正过程的重要部分。

static update_velocity(body: Body, gravity: Tuple[float, float], damping: float, dt: float) → None[源代码]¶

默认刚体速度积分功能。

使用Euler积分更新身体的速度。

property velocity: Vec2d¶: 身体重心的线速度。

velocity_at_local_point(point: Tuple[float, float]) → Vec2d[源代码]¶: 求出刚体在给定体局部点处的绝对速度

velocity_at_world_point(point: Tuple[float, float]) → Vec2d[源代码]¶

求出刚体在给定世界点处的绝对速度

知道物体表面上一点的绝对速度通常是有用的，因为角速度影响除重心以外的一切。

property velocity_func¶

速度回调函数。

速度回调函数在每个时间步长都会被调用，可用于设置物体的速度。

func(body : Body, gravity, damping, dt)

在许多情况下，这可能是有用的。一个例子是某些物体的个人重力，另一个例子是限制速度，这对防止隧道掘进是有用的。

将对象的重力设置为零的回调示例。

>>> import pymunk
>>> space = pymunk.Space()
>>> space.gravity = 0, 10
>>> body = pymunk.Body(1,2)
>>> space.add(body)
>>> def zero_gravity(body, gravity, damping, dt):
...     pymunk.Body.update_velocity(body, (0,0), damping, dt)
... 
>>> body.velocity_func = zero_gravity
>>> space.step(1)
>>> space.step(1)
>>> print(body.position, body.velocity)
Vec2d(0.0, 0.0) Vec2d(0.0, 0.0)

限制速度的回调示例：

>>> import pymunk
>>> body = pymunk.Body(1,2)
>>> def limit_velocity(body, gravity, damping, dt):
...     max_velocity = 1000
...     pymunk.Body.update_velocity(body, gravity, damping, dt)
...     l = body.velocity.length
...     if l > max_velocity:
...         scale = max_velocity / l
...         body.velocity = body.velocity * scale
...
>>> body.velocity_func = limit_velocity

world_to_local(v: Tuple[float, float]) → Vec2d[源代码]¶

将世界空间坐标转换为身体局部坐标

参数:: v -- 世界空间坐标中的矢量

class pymunk.Circle(body: Body | None, radius: float, offset: Tuple[float, float] = (0, 0))[源代码]¶

基类：Shape

由半径定义的圆形

这是最快、最简单的碰撞形状

__init__(body: Body | None, radius: float, offset: Tuple[float, float] = (0, 0)) → None[源代码]¶

Body是将圆附加到的Body，Offset是相对于Body局部坐标中Body重心的偏移。

将None作为Body参数发送是合法的，以指示此形状未附加到Body。但是，在将造型添加到空间或用于空间造型查询之前，必须将其附着到实体。

property area: float¶: 此形状的计算面积。

property bb: BB¶

包围盒 BB 它的形状。

只有在以下情况下才保证有效 Shape.cache_bb() 或 Space.step() 被称为。移动与形状连接的实体不会更新其边界框。对于未附加到实体的查询所使用的形状，还可以使用 Shape.update() 。

property body: Body | None¶: 此形状附加到的主体。可以设置为“无”，以指示此形状不属于实体。

cache_bb() → BB¶: 更新并返回此形状的边框

property center_of_gravity: Vec2d¶: 此形状的计算重心。

property collision_type: int¶

用户为形状定义的碰撞类型。

看见 Space.add_collision_handler() 函数获取有关何时使用此属性的更多信息。

copy() → T¶: 创建此对象的深层副本。

property density: float¶

此形状的密度。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property elasticity: float¶

形状的弹性。

值为0.0时不会反弹，而值为1.0时会产生完美的反弹。但是，由于模拟中的不准确性，不建议使用1.0或更高版本。

property filter: ShapeFilter¶: 设置冲突 ShapeFilter 对于这个形状。

property friction: float¶

摩擦系数。

Pymunk使用库仑摩擦模型，值为0.0表示无摩擦。

值大于1.0就完全可以了。

来自维基百科的一些真实世界的例子(记住，重要的是看起来好的东西，而不是确切的价值)。

材料	其他	摩阻
铝	钢	0.61
铜	钢	0.53
黄铜	钢	0.51
铸铁	铜	1.05
铸铁	锌	0.85
混凝土(湿)	橡胶	0.30
混凝土(干)	橡胶	1.0
混凝土	木材	0.62
铜	玻璃杯	0.68
玻璃杯	玻璃杯	0.94
金属	木材	0.5
聚乙烯	钢	0.2
钢	钢	0.80
钢	特氟龙	0.04
聚四氟乙烯	特氟龙	0.04
木材	木材	0.4

property mass: float¶

这个形状的质量。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property moment: float¶: 此形状的计算力矩。

property offset: Vec2d¶: 偏移。(身体空间坐标)

point_query(p: Tuple[float, float]) → PointQueryInfo¶

检查给定点是否位于形状内。

负距离表示该点在该形状内。

返回:: 元组(距离，信息)
返回类型:: (花车， PointQueryInfo )

property radius: float¶: 圆的半径

segment_query(start: Tuple[float, float], end: Tuple[float, float], radius: float = 0) → SegmentQueryInfo¶

检查从起点到终点的线段是否与形状相交。

返回类型:: SegmentQueryInfo

property sensor: bool¶

如果此形状是传感器或不是传感器，则为布尔值。

传感器只调用冲突回调，从不生成真正的冲突。

shapes_collide(b: Shape) → ContactPointSet¶

获取有关此形状和形状b的联系信息。

返回类型:: ContactPointSet

property space: Space | None¶: vt.得到. Space 该形状已添加到(或无)。

property surface_velocity: Vec2d¶

对象的表面速度。

对于创建可四处移动的传送带或播放器非常有用。该值仅在计算摩擦力时使用，而不用于解决碰撞。

unsafe_set_offset(o: Tuple[float, float]) → None[源代码]¶: 不安全设置圆的偏移量。

备注

此更改仅作为形状表面位置的更改，而不是其速度的更改。更改它不会产生真实的物理行为。只有在你知道自己在做什么的情况下才能使用！

unsafe_set_radius(r: float) → None[源代码]¶: 不安全设置圆的半径。

备注

此更改仅作为形状表面位置的更改，而不是其速度的更改。更改它不会产生真实的物理行为。只有在你知道自己在做什么的情况下才能使用！

update(transform: Transform) → BB¶

使用显式转换更新、缓存和返回形状的边框。

如果您有一个没有实体的形状并希望使用它进行查询，则此选项非常有用。

class pymunk.CollisionHandler(_handler: Any, space: Space)[源代码]¶

基类：object

冲突处理程序是一组4个函数回调，用于派蒙克识别的不同冲突事件。

冲突回调与仲裁器对象密切相关。你也应该熟悉这些。

注1：标记为传感器的形状(Shape.ensor==true)不会生成要处理的冲突，因此传感器形状和其他形状之间的冲突永远不会调用post_solve()回调。它们仍然会生成Begin()和Separate()回调，即使没有冲突响应，每一帧也会调用pre_solve()回调。注2：在休眠算法运行之前调用presolve()回调。如果对象进入睡眠状态，则在重新唤醒它之前不会调用它的post_solve()回调。

__init__(_handler: Any, space: Space) → None[源代码]¶: 从Chipmunk等效结构和Space初始化CollisionHandler对象。

备注

您永远不需要直接创建此类的实例。

property begin: Callable[[Arbiter, Space, Any], bool] | None¶

这一步，两个形状刚刚开始接触。

func(arbiter, space, data) -> bool

从回调中返回TRUE以正常处理碰撞，或返回FALSE以使Chipmunk完全忽略碰撞。如果返回FALSE，则 pre_solve 和 post_solve 回调将永远不会运行，但当形状停止重叠时，您仍将收到单独的事件。

property data: Dict[Any, Any]¶

传递到回调中的数据属性。

数据是一本词典，你不能取代它，只能用数据填满它。

如果回调需要一些额外数据来执行其功能，则非常有用。

property post_solve: Callable[[Arbiter, Space, Any], None] | None¶

两个形状正在接触，它们的碰撞响应已处理。

func(arbiter, space, data)

如果您想要使用碰撞冲量或动能来计算声音体积或损伤量，则可以在此时检索它。有关更多信息，请参阅仲裁器。

property pre_solve: Callable[[Arbiter, Space, Any], bool] | None¶

在此步骤中，两个形状相互接触。

func(arbiter, space, data) -> bool

如果从回调中返回FALSE，则会让Chipmunk忽略这一步的碰撞；如果返回TRUE，则会正常处理碰撞。此外，可以使用Arier.Friction、Arier.Ellision或Arier.SurfaceVelocity覆盖碰撞值，以提供自定义的摩擦力、弹性或表面速度值。有关更多信息，请参阅仲裁器。

property separate: Callable[[Arbiter, Space, Any], None] | None¶

这一步，两个形状刚刚第一次停止接触。

func(arbiter, space, data)

为了确保总是成对地调用Begin()/Separate()，当形状与某物接触时移除形状或释放空间时也将调用它。

class pymunk.ContactPoint(point_a: Vec2d, point_b: Vec2d, distance: float)[源代码]¶

基类：object

包含有关接触点的信息。

点_a和点_b是每个形状表面上的接触位置。

距离是两个形状的穿透距离。重叠意味着它将是负面的。该值的计算方式为点(point 2-point 1)，正常)，设置仲裁器时忽略该值。Contact_point_set。

__init__(point_a: Vec2d, point_b: Vec2d, distance: float) → None[源代码]¶

distance: float¶

point_a: Vec2d¶

point_b: Vec2d¶

class pymunk.ContactPointSet(normal: Vec2d, points: List[ContactPoint])[源代码]¶

基类：object

联系人点集使获取联系人信息变得更简单。

法线是碰撞的法线

Points是接触点的数组。最多可以是2个点。

__init__(normal: Vec2d, points: List[ContactPoint]) → None[源代码]¶

normal: Vec2d¶

points: List[ContactPoint]¶

class pymunk.PointQueryInfo(shape: Shape | None, point: Vec2d, distance: float, gradient: Vec2d)[源代码]¶

基类：NamedTuple

PointQueryInfo保存对形状或空间进行的点查询的结果。

distance: float¶: 到该点的距离。如果该点位于形状内部，则距离为负数。

gradient: Vec2d¶

带符号距离函数的梯度。

该值应类似于PointQueryInfo.point/PointQueryInfo.Distance，但即使对于非常小的info.Distance值也是准确的。

point: Vec2d¶: 形状表面上最近的点。(在世界空间坐标中)

shape: Shape | None¶: 最近的形状，如果没有形状在范围内，则为None。

class pymunk.Poly(body: Body | None, vertices: Sequence[Tuple[float, float]], transform: Transform | None = None, radius: float = 0)[源代码]¶

基类：Shape

凸面多边形体

最慢，但最灵活的碰撞形状。

__init__(body: Body | None, vertices: Sequence[Tuple[float, float]], transform: Transform | None = None, radius: float = 0) → None[源代码]¶

创建一个多边形。

将从顶点自动计算出凸壳。

添加较小的半径将使角点倒角，并且可以显著减少几何体中多边形卡在接缝上的问题。

将None作为Body参数发送是合法的，以指示此形状未附加到Body。但是，在将造型添加到空间或用于空间造型查询之前，必须将其附着到实体。

备注

确保将顶点放置在(0，0)周围，否则形状可能会出现奇怪的行为。

直接放置顶点，如下例所示：

>>> import pymunk
>>> w, h = 10, 20
>>> vs = [(-w/2,-h/2), (w/2,-h/2), (w/2,h/2), (-w/2,h/2)]
>>> poly_good = pymunk.Poly(None, vs)
>>> print(poly_good.center_of_gravity)
Vec2d(0.0, 0.0)

或者使用变换来移动它们：

>>> import pymunk
>>> width, height = 10, 20
>>> vs = [(0, 0), (width, 0), (width, height), (0, height)]
>>> poly_bad = pymunk.Poly(None, vs)
>>> print(poly_bad.center_of_gravity)
Vec2d(5.0, 10.0)
>>> t = pymunk.Transform(tx=-width/2, ty=-height/2)
>>> poly_good = pymunk.Poly(None, vs, transform=t)
>>> print(poly_good.center_of_gravity)
Vec2d(0.0, 0.0)

参数:

body (Body) -- 要将多边形附加到的实体
vertices ([(float,float)]) -- 使用逆时针缠绕定义多边形的凸壳。
transform (Transform) -- 变换将应用于每个顶点。
radius (float) -- 设置多边形的半径

property area: float¶: 此形状的计算面积。

property bb: BB¶

包围盒 BB 它的形状。

只有在以下情况下才保证有效 Shape.cache_bb() 或 Space.step() 被称为。移动与形状连接的实体不会更新其边界框。对于未附加到实体的查询所使用的形状，还可以使用 Shape.update() 。

property body: Body | None¶: 此形状附加到的主体。可以设置为“无”，以指示此形状不属于实体。

cache_bb() → BB¶: 更新并返回此形状的边框

property center_of_gravity: Vec2d¶: 此形状的计算重心。

property collision_type: int¶

用户为形状定义的碰撞类型。

看见 Space.add_collision_handler() 函数获取有关何时使用此属性的更多信息。

copy() → T¶: 创建此对象的深层副本。

static create_box(body: Body | None, size: Tuple[float, float] = (10, 10), radius: float = 0) → Poly[源代码]¶

方便函数来创建一个给定宽度和高度的方框。

长方体将始终以要附加它们的身体的重心为中心。如果要创建偏离中心的长方体，则需要使用普通构造函数Poly(...)。

添加较小的半径将使拐角倒角，并且可以显著减少长方体在几何体的接缝上卡住的问题。

参数:

body (Body) -- 要将多边形附加到的实体
size ((float, float)) -- 框的大小为(宽度、高度)
radius (float) -- 多边形半径

返回类型:

Poly

static create_box_bb(body: Body | None, bb: BB, radius: float = 0) → Poly[源代码]¶

函数创建一个方框形状。 BB 。

长方体将始终以要附加它们的身体的重心为中心。如果要创建偏离中心的长方体，则需要使用普通构造函数Poly(..)。

添加较小的半径将使拐角倒角，并且可以显著减少长方体在几何体的接缝上卡住的问题。

参数:

body (Body) -- 要将多边形附加到的实体
bb (BB) -- 盒子的大小
radius (float) -- 多边形半径

返回类型:

Poly

property density: float¶

此形状的密度。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property elasticity: float¶

形状的弹性。

值为0.0时不会反弹，而值为1.0时会产生完美的反弹。但是，由于模拟中的不准确性，不建议使用1.0或更高版本。

property filter: ShapeFilter¶: 设置冲突 ShapeFilter 对于这个形状。

property friction: float¶

摩擦系数。

Pymunk使用库仑摩擦模型，值为0.0表示无摩擦。

值大于1.0就完全可以了。

来自维基百科的一些真实世界的例子(记住，重要的是看起来好的东西，而不是确切的价值)。

材料	其他	摩阻
铝	钢	0.61
铜	钢	0.53
黄铜	钢	0.51
铸铁	铜	1.05
铸铁	锌	0.85
混凝土(湿)	橡胶	0.30
混凝土(干)	橡胶	1.0
混凝土	木材	0.62
铜	玻璃杯	0.68
玻璃杯	玻璃杯	0.94
金属	木材	0.5
聚乙烯	钢	0.2
钢	钢	0.80
钢	特氟龙	0.04
聚四氟乙烯	特氟龙	0.04
木材	木材	0.4

get_vertices() → List[Vec2d][源代码]¶

获取多边形的局部坐标中的折点

如果需要世界坐标中的顶点，则可以通过添加躯干位置来变换顶点，并通过以下方式旋转躯干旋转的每个顶点：

>>> import pymunk
>>> b = pymunk.Body()
>>> b.position = 1,2
>>> b.angle = 0.5
>>> shape = pymunk.Poly(b, [(0,0), (10,0), (10,10)])
>>> for v in shape.get_vertices():
...     x,y = v.rotated(shape.body.angle) + shape.body.position
...     (int(x), int(y))
(1, 2)
(9, 6)
(4, 15)

返回:: 局部余弦中的顶点
返回类型:: [Vec2d]

property mass: float¶

这个形状的质量。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property moment: float¶: 此形状的计算力矩。

point_query(p: Tuple[float, float]) → PointQueryInfo¶

检查给定点是否位于形状内。

负距离表示该点在该形状内。

返回:: 元组(距离，信息)
返回类型:: (花车， PointQueryInfo )

property radius: float¶

多边形的半径。

以给定的半径在所有方向上延伸多边形。

segment_query(start: Tuple[float, float], end: Tuple[float, float], radius: float = 0) → SegmentQueryInfo¶

检查从起点到终点的线段是否与形状相交。

返回类型:: SegmentQueryInfo

property sensor: bool¶

如果此形状是传感器或不是传感器，则为布尔值。

传感器只调用冲突回调，从不生成真正的冲突。

shapes_collide(b: Shape) → ContactPointSet¶

获取有关此形状和形状b的联系信息。

返回类型:: ContactPointSet

property space: Space | None¶: vt.得到. Space 该形状已添加到(或无)。

property surface_velocity: Vec2d¶

对象的表面速度。

对于创建可四处移动的传送带或播放器非常有用。该值仅在计算摩擦力时使用，而不用于解决碰撞。

unsafe_set_radius(radius: float) → None[源代码]¶: 不安全设置多边形的半径。

备注

此更改仅作为形状表面位置的更改，而不是其速度的更改。更改它不会产生真实的物理行为。只有在你知道自己在做什么的情况下才能使用！

unsafe_set_vertices(vertices: Sequence[Tuple[float, float]], transform: Transform | None = None) → None[源代码]¶: 不安全设置多边形的顶点。

备注

此更改仅作为形状表面位置的更改，而不是其速度的更改。更改它不会产生真实的物理行为。只有在你知道自己在做什么的情况下才能使用！

update(transform: Transform) → BB¶

使用显式转换更新、缓存和返回形状的边框。

如果您有一个没有实体的形状并希望使用它进行查询，则此选项非常有用。

class pymunk.Segment(body: Body | None, a: Tuple[float, float], b: Tuple[float, float], radius: float)[源代码]¶

基类：Shape

两点之间的线段形状

主要指的是静态形状。可以倒角以使它们具有一定的厚度。

__init__(body: Body | None, a: Tuple[float, float], b: Tuple[float, float], radius: float) → None[源代码]¶

创建管段

将None作为Body参数发送是合法的，以指示此形状未附加到Body。但是，在将造型添加到空间或用于空间造型查询之前，必须将其附着到实体。

参数:

body (Body) -- 要将线束段附着到的实体
a -- 线束段的第一个端点
b -- 线束段的第二个端点
radius (float) -- 管段的厚度

property a: Vec2d¶: 此数据段的两个端点中的第一个

property area: float¶: 此形状的计算面积。

property b: Vec2d¶: 此段的两个端点中的第二个

property bb: BB¶

包围盒 BB 它的形状。

只有在以下情况下才保证有效 Shape.cache_bb() 或 Space.step() 被称为。移动与形状连接的实体不会更新其边界框。对于未附加到实体的查询所使用的形状，还可以使用 Shape.update() 。

property body: Body | None¶: 此形状附加到的主体。可以设置为“无”，以指示此形状不属于实体。

cache_bb() → BB¶: 更新并返回此形状的边框

property center_of_gravity: Vec2d¶: 此形状的计算重心。

property collision_type: int¶

用户为形状定义的碰撞类型。

看见 Space.add_collision_handler() 函数获取有关何时使用此属性的更多信息。

copy() → T¶: 创建此对象的深层副本。

property density: float¶

此形状的密度。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property elasticity: float¶

形状的弹性。

值为0.0时不会反弹，而值为1.0时会产生完美的反弹。但是，由于模拟中的不准确性，不建议使用1.0或更高版本。

property filter: ShapeFilter¶: 设置冲突 ShapeFilter 对于这个形状。

property friction: float¶

摩擦系数。

Pymunk使用库仑摩擦模型，值为0.0表示无摩擦。

值大于1.0就完全可以了。

来自维基百科的一些真实世界的例子(记住，重要的是看起来好的东西，而不是确切的价值)。

材料	其他	摩阻
铝	钢	0.61
铜	钢	0.53
黄铜	钢	0.51
铸铁	铜	1.05
铸铁	锌	0.85
混凝土(湿)	橡胶	0.30
混凝土(干)	橡胶	1.0
混凝土	木材	0.62
铜	玻璃杯	0.68
玻璃杯	玻璃杯	0.94
金属	木材	0.5
聚乙烯	钢	0.2
钢	钢	0.80
钢	特氟龙	0.04
聚四氟乙烯	特氟龙	0.04
木材	木材	0.4

property mass: float¶

这个形状的质量。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property moment: float¶: 此形状的计算力矩。

property normal: Vec2d¶: 正常的

point_query(p: Tuple[float, float]) → PointQueryInfo¶

检查给定点是否位于形状内。

负距离表示该点在该形状内。

返回:: 元组(距离，信息)
返回类型:: (花车， PointQueryInfo )

property radius: float¶: 管段的半径/厚度

segment_query(start: Tuple[float, float], end: Tuple[float, float], radius: float = 0) → SegmentQueryInfo¶

检查从起点到终点的线段是否与形状相交。

返回类型:: SegmentQueryInfo

property sensor: bool¶

如果此形状是传感器或不是传感器，则为布尔值。

传感器只调用冲突回调，从不生成真正的冲突。

set_neighbors(prev: Tuple[float, float], next: Tuple[float, float]) → None[源代码]¶: 当有多个线段形状全部连接在一起时，仍有可能会与线段之间的“裂缝”发生碰撞。通过设置相邻分段端点，您可以告诉Chipmunk避免与裂缝的内部发生碰撞。

shapes_collide(b: Shape) → ContactPointSet¶

获取有关此形状和形状b的联系信息。

返回类型:: ContactPointSet

property space: Space | None¶: vt.得到. Space 该形状已添加到(或无)。

property surface_velocity: Vec2d¶

对象的表面速度。

对于创建可四处移动的传送带或播放器非常有用。该值仅在计算摩擦力时使用，而不用于解决碰撞。

unsafe_set_endpoints(a: Tuple[float, float], b: Tuple[float, float]) → None[源代码]¶: 设置此线段的两个端点

备注

此更改仅作为形状表面位置的更改，而不是其速度的更改。更改它不会产生真实的物理行为。只有在你知道自己在做什么的情况下才能使用！

unsafe_set_radius(r: float) → None[源代码]¶: 设置管段的半径

备注

此更改仅作为形状表面位置的更改，而不是其速度的更改。更改它不会产生真实的物理行为。只有在你知道自己在做什么的情况下才能使用！

update(transform: Transform) → BB¶

使用显式转换更新、缓存和返回形状的边框。

如果您有一个没有实体的形状并希望使用它进行查询，则此选项非常有用。

class pymunk.SegmentQueryInfo(shape: Shape | None, point: Vec2d, normal: Vec2d, alpha: float)[源代码]¶

基类：NamedTuple

分段查询返回更多的信息，而不仅仅是一个简单的是或否，他们还返回一个形状被击中的位置和它在点击点处的表面法线。该对象保存该信息。

要测试查询是否命中某些内容，请检查SegmentQueryInfo.Shape==None。

段查询类似于光线投射，但并不是所有的空间索引都允许处理无限长的射线查询，因此仅限于段。在实践中，这仍然是非常快的，只要您没有为查询使用非常长的段，就不需要太担心性能。

alpha: float¶: 范围内沿查询段的归一化距离 [0, 1]

normal: Vec2d¶: 曲面的法线命中。

point: Vec2d¶: 撞击点。

shape: Shape | None¶: 命中的形状，如果未发生冲突，则为None

class pymunk.Shape(shape: Shape)[源代码]¶

基类：PickleMixin, TypingAttrMixing, object

所有形状的基类。

您通常不想直接创建此类的实例，而是使用其中一个专门的形状 (Circle ， Poly 或 Segment )。

所有的形状都可以复制和腌制。如果复制/酸洗形状，则也会复制正文(如果有的话)。

__init__(shape: Shape) → None[源代码]¶

property area: float¶: 此形状的计算面积。

property bb: BB¶

包围盒 BB 它的形状。

只有在以下情况下才保证有效 Shape.cache_bb() 或 Space.step() 被称为。移动与形状连接的实体不会更新其边界框。对于未附加到实体的查询所使用的形状，还可以使用 Shape.update() 。

property body: Body | None¶: 此形状附加到的主体。可以设置为“无”，以指示此形状不属于实体。

cache_bb() → BB[源代码]¶: 更新并返回此形状的边框

property center_of_gravity: Vec2d¶: 此形状的计算重心。

property collision_type: int¶

用户为形状定义的碰撞类型。

看见 Space.add_collision_handler() 函数获取有关何时使用此属性的更多信息。

copy() → T¶: 创建此对象的深层副本。

property density: float¶

此形状的密度。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property elasticity: float¶

形状的弹性。

值为0.0时不会反弹，而值为1.0时会产生完美的反弹。但是，由于模拟中的不准确性，不建议使用1.0或更高版本。

property filter: ShapeFilter¶: 设置冲突 ShapeFilter 对于这个形状。

property friction: float¶

摩擦系数。

Pymunk使用库仑摩擦模型，值为0.0表示无摩擦。

值大于1.0就完全可以了。

来自维基百科的一些真实世界的例子(记住，重要的是看起来好的东西，而不是确切的价值)。

材料	其他	摩阻
铝	钢	0.61
铜	钢	0.53
黄铜	钢	0.51
铸铁	铜	1.05
铸铁	锌	0.85
混凝土(湿)	橡胶	0.30
混凝土(干)	橡胶	1.0
混凝土	木材	0.62
铜	玻璃杯	0.68
玻璃杯	玻璃杯	0.94
金属	木材	0.5
聚乙烯	钢	0.2
钢	钢	0.80
钢	特氟龙	0.04
聚四氟乙烯	特氟龙	0.04
木材	木材	0.4

property mass: float¶

这个形状的质量。

这在让Pymunk根据附加的形状计算物体的总质量和惯性时非常有用。(而不是直接设置身体质量和惯性)

property moment: float¶: 此形状的计算力矩。

point_query(p: Tuple[float, float]) → PointQueryInfo[源代码]¶

检查给定点是否位于形状内。

负距离表示该点在该形状内。

返回:: 元组(距离，信息)
返回类型:: (花车， PointQueryInfo )

segment_query(start: Tuple[float, float], end: Tuple[float, float], radius: float = 0) → SegmentQueryInfo[源代码]¶

检查从起点到终点的线段是否与形状相交。

返回类型:: SegmentQueryInfo

property sensor: bool¶

如果此形状是传感器或不是传感器，则为布尔值。

传感器只调用冲突回调，从不生成真正的冲突。

shapes_collide(b: Shape) → ContactPointSet[源代码]¶

获取有关此形状和形状b的联系信息。

返回类型:: ContactPointSet

property space: Space | None¶: vt.得到. Space 该形状已添加到(或无)。

property surface_velocity: Vec2d¶

对象的表面速度。

对于创建可四处移动的传送带或播放器非常有用。该值仅在计算摩擦力时使用，而不用于解决碰撞。

update(transform: Transform) → BB[源代码]¶

使用显式转换更新、缓存和返回形状的边框。

如果您有一个没有实体的形状并希望使用它进行查询，则此选项非常有用。

class pymunk.ShapeFilter(group: int = 0, categories: int = 4294967295, mask: int = 4294967295)[源代码]¶

基类：NamedTuple

Pymunk有两种主要的忽略冲突的方法：组和类别掩码。

组用于忽略复杂对象上各部分之间的碰撞。布娃娃就是一个很好的例子。当将手臂连接到躯干上时，您会希望它们允许重叠。团体让你可以做到这一点。具有相同组的形状不会生成碰撞。因此，通过将布娃娃中的所有形状放在同一组中，可以防止它与自身的其他部分碰撞。类别蒙版允许您标记对象属于哪些类别以及它与哪些类别冲突。

例如，游戏有四个碰撞类别：玩家(0)、敌人(1)、玩家子弹(2)和敌人子弹(3)。无论是玩家还是敌人都不应该与自己的子弹相撞，子弹也不应该与其他子弹相撞。然而，玩家与敌人的子弹相撞，敌人与玩家的子弹相撞。

客体	对象类别	类别掩码
球员	0b00001(1)	0b11000(4，5)
敌人	0b00010(2)	0b01110(2，3，4)
运动员子弹	0b00100(3)	0b10001(1，5)
敌方子弹	0b01000(4)	0b10010(2，5)
墙壁	0b10000(5)	0b01111(1、2、3、4)

请注意，在该表中，类别和掩码以二进制值的形式写入，以清楚地显示逻辑。为了节省空间，只使用了5位数字。ShapeFilter中的类别和掩码的默认类型是无符号整型，分辨率为32位。这意味着您有32位可以使用，以二进制表示法即 0b00000000000000000000000000000000 至 0b11111111111111111111111111111111 它可以用十六进制写成 0x00000000 至 0xFFFFFFFF 。

本例中的所有内容都会与墙发生碰撞。此外，敌人之间还会发生碰撞。

默认情况下，对象存在于每个类别中，并与每个类别冲突。

对象可以分为多个类别。例如，您可能有一个红色团队的类别，并且有一个红色的球员项目符号。在上面的例子中，每个对象只有一个类别。

ShapeFilter中的类别和掩码的默认类型是无符号整型，在大多数系统上具有32位的分辨率。

还有最后一种使用冲突处理程序过滤冲突的方法。有关更多信息，请参阅回调部分。冲突处理程序可以更灵活，但也可以更慢。在运行昂贵的冲突检测代码之前，快速冲突过滤会拒绝冲突，因此首选使用组或类别掩码。

如何使用类别和面具将玩家从敌人对象中过滤出来的示例：

>>> import pymunk
>>> s = pymunk.Space()
>>> player_b = pymunk.Body(1,1)
>>> player_c = pymunk.Circle(player_b, 10)
>>> s.add(player_b, player_c)
>>> player_c.filter = pymunk.ShapeFilter(categories=0b1)
>>> hit = s.point_query_nearest((0,0), 0, pymunk.ShapeFilter())
>>> hit != None
True
>>> filter = pymunk.ShapeFilter(mask=pymunk.ShapeFilter.ALL_MASKS() ^ 0b1)
>>> hit = s.point_query_nearest((0,0), 0, filter)
>>> hit == None
True
>>> enemy_b = pymunk.Body(1,1)
>>> enemy_c = pymunk.Circle(enemy_b, 10)
>>> s.add(enemy_b, enemy_c)
>>> hit = s.point_query_nearest((0,0), 0, filter)
>>> hit != None
True

static ALL_CATEGORIES() → int[源代码]¶

static ALL_MASKS() → int[源代码]¶

categories: int¶

此对象所属的用户可定义类别的位掩码。

碰撞中两个对象的类别/遮罩组合必须一致才能发生碰撞。

group: int¶

具有相同非零组值的两个对象不会发生碰撞。

这通常用于将复合对象中的对象分组在一起，以禁用自碰撞。

mask: int¶

此对象与之冲突的用户可定义类别类型的位掩码。

碰撞中两个对象的类别/遮罩组合必须一致才能发生碰撞。

class pymunk.ShapeQueryInfo(shape: Shape | None, contact_point_set: ContactPointSet)[源代码]¶

基类：NamedTuple

形状查询返回更多信息，而不仅仅是一个简单的是或否，它们还返回击中形状的位置。该对象保存该信息。

contact_point_set: ContactPointSet¶: 字段号%1的别名

shape: Shape | None¶: 命中的形状，如果未发生冲突，则为None

class pymunk.Space(threaded: bool = False)[源代码]¶

基类：PickleMixin, object

空间是模拟的基本单位。您可以向其添加刚体、形状和关节，然后随着时间的推移将它们全部向前移动。

可以复制和酸洗空格。请注意，不会复制任何POST步骤回调。另请注意，某些内部冲突缓存数据不会复制，这可能会使模拟在新复制的前几个步骤中有点不稳定。

空间上设置的自定义属性也将被复制/腌制。

任何冲突处理程序也将被复制/酸洗。请注意，根据所使用的PICLE协议，对可以复制/PICKLE的函数有一些限制。

示例：：

>>> import pymunk, pickle
>>> space = pymunk.Space()
>>> space2 = space.copy()
>>> space3 = pickle.loads(pickle.dumps(space))

__init__(threaded: bool = False) → None[源代码]¶

创建Space的新实例。

如果设置threaded=True，步骤函数将以线程模式运行，这可能会带来加速。请注意，即使在设置threaded=True时，您仍然必须设置Space.线程=2以实际使用多个线程。

还要注意，线程模式在Windows上不可用，并且设置Threaded=True对该平台没有影响。

add(*objs: Body | Shape | Constraint) → None[源代码]¶

将一个或多个形状、实体或约束(运动类型)添加到空间

与Chipmunk和早期版本的Chipmunk不同，它现在允许在模拟步骤中添加对象，甚至可以从回调添加对象。但是，在该步骤结束之前不会执行添加。

add_collision_handler(collision_type_a: int, collision_type_b: int) → CollisionHandler[源代码]¶

返回 CollisionHandler 用于类型为Collision_type_a和Collision_type_b的对象之间的碰撞。

填充所需的冲突回调函数，有关详细信息，请参阅 CollisionHandler 对象。

无论何时具有冲突类型的形状 (Shape.collision_type )a和b发生冲突时，该处理程序将用于处理冲突事件。当创建新的冲突处理程序时，回调将全部设置为执行默认行为(调用通配符处理程序并接受所有冲突)的内置回调。

参数:

collision_type_a (int) -- 碰撞类型a
collision_type_b (int) -- 冲突类型b

返回类型:

CollisionHandler

add_default_collision_handler() → CollisionHandler[源代码]¶

返回对默认冲突处理程序的引用，或用于处理没有更具体处理程序的所有冲突的引用。

每个回调的默认行为是调用通配符处理程序，如果适用，将它们的返回值一起进行AND运算。

add_post_step_callback(callback_function: Callable[[...], None], key: Hashable, *args: Any, **kwargs: Any) → bool[源代码]¶

添加要在下一个模拟步骤中最后调用的函数。

POST步骤回调被注册为一个函数和一个用作键的对象。每个对象只能注册一个POST步骤回调。

此函数在早期版本的pymunk中更有用，在早期版本中，您不允许在模拟步骤期间对空间使用Add和Remove方法。但此功能仍可用于其他用途，并保持向后兼容。

备注

如果从回调中删除形状，则当形状被删除时该形状正在接触时，它将触发‘Separate’事件的冲突处理程序。

备注

POST步骤回调不包括在空间的PICLE/COPY中。

参数:

callback_function (func(space : Space, key, *args, **kwargs)) -- 回调函数
key (Any) -- 此对象作为键使用，单个对象只能有一个回调。它被传递给回调函数。
args -- 传递给回调的可选参数
kwargs -- 传递给回调的可选关键字参数

返回:

如果以前未添加密钥，则为True，否则为False

add_wildcard_collision_handler(collision_type_a: int) → CollisionHandler[源代码]¶

为给定的冲突类型添加一个通配符冲突处理程序。

此处理程序将在此类型的对象与其他对象冲突的任何时候使用，而不考虑其类型。一个很好的例子是第一次击中任何东西就应该摧毁的投射物。可能有一个特定的冲突处理程序和两个通配符处理程序。由特定的处理程序决定是否以及何时调用通配符处理程序，以及如何处理它们的返回值。

当创建新的通配符处理程序时，回调将全部设置为执行默认行为的内置回调。(接受中的所有冲突 begin() 和 pre_solve() ，或者什么都不做 post_solve() 和 separate() 。

参数:: collision_type_a (int) -- 碰撞类型
返回类型:: CollisionHandler

bb_query(bb: BB, shape_filter: ShapeFilter) → List[Shape][源代码]¶

查询空间以查找BB附近的所有形状。

过滤器应用于查询，并遵循与冲突检测相同的规则。

备注

传感器形状包含在结果中

参数:

bb -- 包围盒
shape_filter -- 形状滤镜

返回类型:

[Shape]

property bodies: List[Body]¶: 添加到此空间的身体列表

property collision_bias: float¶

确定将重叠形状推开的速度。

Pymunk允许快速移动的对象重叠，然后随着时间的推移修复重叠。即使支持扫掠碰撞，重叠对象也是不可避免的，这是处理重叠对象的一种高效而稳定的方法。偏移值控制在一秒后保持不固定的重叠百分比，默认为~0.2%。有效值介于0到1的范围内，但出于稳定性原因，不建议使用0。缺省值计算为cpfpow(1.0f-0.1f，60.0f)，表示金龟子尝试每隔1/60秒纠正10%的错误。

..注：：: 很少有游戏需要更改这个值。

property collision_persistence: float¶

为其保留碰撞解决方案的空间的帧数量。

有助于防止抖动的接触变得更糟。默认为3。

..注：：: 很少有游戏需要更改这个值。

property collision_slop: float¶

允许的形状之间的重叠量。

要提高稳定性，请将其设置为尽可能高，而不会出现明显的重叠。默认为0.1。

property constraints: List[Constraint]¶: 添加到此空间的约束列表

copy() → T¶: 创建此对象的深层副本。

property current_time_step: float¶: 检索当前(如果在来自Space.Step()的回调中)或最新的(在Space.Step()调用之外)时间步长。

property damping: float¶

应用于空间的简单阻尼量。

值为0.9意味着每个物体每秒将损失10%的速度。默认为1。与重力一样，它可以基于每个身体进行覆盖。

debug_draw(options: SpaceDebugDrawOptions) → None[源代码]¶

调试使用提供的绘制选项绘制空间的当前状态。

如果您使用的是已受支持的图形后端，例如，您可以使用其x_util模块中的预定义选项 pygame_util.DrawOptions 。

也可以编写自己的图形后端，请参见 SpaceDebugDrawOptions 。

如果您需要任何高级或优化的绘图，最好不要将此函数用于绘图，因为它用于调试和快速脚本编写。

property gravity: Vec2d¶

应用于空间的全局重力。

默认为(0，0)。可以通过编写自定义集成函数并将其设置在Body上来覆盖每个Body： pymunk.Body.velocity_func() 。

property idle_speed_threshold: float¶

被视为空闲的物体的速度阈值。

默认值0表示空间根据重力估计良好的阈值。

property iterations: int¶

迭代允许您控制解算器的精度。

默认为10。

Pymunk使用迭代解算器来计算空间中对象之间的力。这意味着它将构建一个包含实体之间的所有碰撞、关节和其他约束的大列表，并分别考虑每个约束并在列表中进行多次传递。它通过的次数就是迭代计数，每次迭代都会使解更准确。如果使用太多迭代，物理效果应该看起来很好很坚实，但可能会占用太多的CPU时间。如果使用的迭代次数太少，当对象应该是实体时，模拟可能会看起来糊状或弹跳。通过设置迭代次数，可以在CPU使用率和物理精度之间取得平衡。Pymunk默认的10次迭代对于大多数简单的游戏来说已经足够了。

point_query(point: Tuple[float, float], max_distance: float, shape_filter: ShapeFilter) → List[PointQueryInfo][源代码]¶

查询给定距离范围内的形状的点空间。

过滤器应用于查询，并遵循与冲突检测相同的规则。如果使用的最大距离为0.0，则该点必须位于形状内部。负的max_Distance也是允许的，这意味着该点必须在形状内的某个深度以下才能被视为匹配。

看见 ShapeFilter 有关如何使用Shape_Filter参数的详细信息。

备注

传感器形状包含在结果中(在 Space.point_query_nearest() 他们不是)

参数:

point (Vec2d or (float,float)) -- 在哪里检查空间中的碰撞
max_distance (float) -- 仅在此距离内匹配
shape_filter (ShapeFilter) -- 仅拾取与滤镜匹配的形状

返回类型:

[PointQueryInfo]

point_query_nearest(point: Tuple[float, float], max_distance: float, shape_filter: ShapeFilter) → PointQueryInfo | None[源代码]¶

查询给定距离范围内最接近形状的点处的空间。

过滤器应用于查询，并遵循与冲突检测相同的规则。如果使用的最大距离为0.0，则该点必须位于形状内部。负的max_Distance也是允许的，这意味着该点必须在形状内的某个深度以下才能被视为匹配。

看见 ShapeFilter 有关如何使用Shape_Filter参数的详细信息。

备注

结果中不包括传感器形状(在 Space.point_query() 它们是)

参数:

point (Vec2d or (float,float)) -- 在哪里检查空间中的碰撞
max_distance (float) -- 仅在此距离内匹配
shape_filter (ShapeFilter) -- 仅拾取与滤镜匹配的形状

返回类型:

PointQueryInfo 或者一个也没有

reindex_shape(shape: Shape) → None[源代码]¶: 更新空间中特定形状的碰撞检测数据。

reindex_shapes_for_body(body: Body) → None[源代码]¶: 为特定实体的所有形状重新编制索引。

reindex_static() → None[源代码]¶: 更新空间中静态形状的碰撞检测信息。仅当您移动其中一个静态形状时才需要调用它。

remove(*objs: Body | Shape | Constraint) → None[源代码]¶

从空间中移除一个或多个形状、实体或约束

与Chipmunk和早期版本的Chipmunk不同，它现在允许在模拟步骤中甚至从回调中删除对象。但是，在该步骤结束之前不会执行删除。

备注

从空间中删除对象时，请确保删除参照该空间的任何其他对象。例如，移除实体时，请移除附加到该实体的关节和形状。

segment_query(start: Tuple[float, float], end: Tuple[float, float], radius: float, shape_filter: ShapeFilter) → List[SegmentQueryInfo][源代码]¶

从起点到终点以给定半径查询直线段上的空间。

过滤器应用于查询，并遵循与冲突检测相同的规则。

看见 ShapeFilter 有关如何使用Shape_Filter参数的详细信息。

备注

传感器形状包含在结果中(在 Space.segment_query_first() 他们不是)

参数:

start -- 起点
end -- 终点
radius (float) -- 半径
shape_filter (ShapeFilter) -- 形状滤镜

返回类型:

[SegmentQueryInfo]

segment_query_first(start: Tuple[float, float], end: Tuple[float, float], radius: float, shape_filter: ShapeFilter) → SegmentQueryInfo | None[源代码]¶

从起点到终点以给定半径查询直线段上的空间。

过滤器应用于查询，并遵循与冲突检测相同的规则。

备注

结果中不包括传感器形状(在 Space.segment_query() 它们是)

看见 ShapeFilter 有关如何使用Shape_Filter参数的详细信息。

返回类型:: SegmentQueryInfo 或者一个也没有

shape_query(shape: Shape) → List[ShapeQueryInfo][源代码]¶

查询空间以查找与给定形状重叠的任何形状

备注

传感器形状包含在结果中

参数:: shape (Circle, Poly or Segment) -- 要用来查询的形状
返回类型:: [ShapeQueryInfo]

property shapes: List[Shape]¶

添加到此空间的所有形状的列表

(包括静态和非静态)

property sleep_time_threshold: float¶

时间一组身体必须保持空闲才能入睡。

的默认值为 inf 禁用休眠算法。

property static_body: Body¶

专为空间设计的静态车身。

你不一定要使用它，但很多时候，在空间中有一个静态的身体会很方便。

step(dt: float) → None[源代码]¶

更新给定时间步长的空间。

强烈建议使用固定的时间步长。这样做将提高接触持久性的效率，在通常情况下，解决冲突所需的迭代次数要少一个数量级。

即使最终结果是模拟向前移动了100个单位，调用10次DT为0.1的Step和调用100次DT为0.01的Step也是不同的。使用较小的DT执行多个调用可以创建更稳定、更准确的模拟。因此，有时在步骤调用中使用一点for循环是有意义的，如下例所示：

>>> import pymunk
>>> s = pymunk.Space()
>>> steps = 10
>>> for x in range(steps): # move simulation forward 0.1 seconds:
...     s.step(0.1 / steps)

参数:: dt -- 时间步长

property threads: int¶

用于运行步骤函数的线程数。

仅当创建的空间为Threaded=True时才有效。目前最大限制是2，设置更高的值不会有任何影响。无论空间是否在Threaded=True的情况下创建，默认为1，以在模拟中保持确定性。请注意，Windows不支持线程解算器。

use_spatial_hash(dim: float, count: int) → None[源代码]¶

切换空间以使用空间散列而不是边界框树。

Pymunk支持两个空间索引。默认情况下是一个轴对齐的边界框树，灵感来自于Bullet物理库中使用的边界框树，但添加了重叠树叶的缓存以使其具有非常好的时间一致性。树不需要调整，大多数游戏都会发现使用树可以获得最好的性能。另一种可用的空间索引类型是空间散列，当有大量(1000个)大小完全相同的对象时，空间散列的速度会快得多。对于数量较少的对象或大小变化很大的对象，空间散列通常要慢得多。它还需要调优(通常通过实验)以获得最佳性能。

空间散列数据对大小相当敏感。Dim是散列单元格的大小。将暗淡设置为平均碰撞形状大小可能会提供最佳性能。将Dim设置得太小会导致将形状插入到许多单元格中，将其设置得太低会导致太多对象插入到同一哈希槽中。

Count是哈希表中建议的最小单元格数量。如果单元太少，空间散列将返回许多误报。太多的单元会占用高速缓存并浪费内存。将计数设置为空间中对象数量的约10倍可能是一个很好的起点。如有必要，请从那里开始调音。

参数:

dim -- 散列单元格的大小
count -- 哈希表中建议的最小单元格数量

class pymunk.SpaceDebugDrawOptions[源代码]¶

基类：object

SpaceDebugDrawOptions配置调试绘图。

如果合适，直接使用提供的DRAW实现通常很容易：pymunk.pyGame_util、pymunk.pyglet_util和pymunk.matplotlib_util。

DRAW_COLLISION_POINTS: ClassVar[int]¶

绘制碰撞点。

在标志属性上使用来控制是否应绘制冲突点。

DRAW_CONSTRAINTS: ClassVar[int]¶

绘制约束。

在标志属性上使用可控制是否应绘制约束。

DRAW_SHAPES: ClassVar[int]¶

绘制形状。

在FLAGS属性上使用可控制是否应绘制形状。

__init__() → None[源代码]¶

property collision_point_color: SpaceDebugColor¶

碰撞的颜色。

应为介于0和255(r，g，b，a)之间的4个整数的元组。

示例：

>>> import pymunk
>>> s = pymunk.Space()
>>> b = pymunk.Body(1,10)
>>> c1 = pymunk.Circle(b, 10)
>>> c2 = pymunk.Circle(s.static_body, 10)
>>> s.add(b, c1, c2)
>>> s.step(1)
>>> options = pymunk.SpaceDebugDrawOptions()
>>> s.debug_draw(options)
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=52.0, g=152.0, b=219.0, a=255.0))
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))
draw_segment (Vec2d(8.0, 0.0), Vec2d(-8.0, 0.0), SpaceDebugColor(r=231.0, g=76.0, b=60.0, a=255.0))
>>> options.collision_point_color = (10,20,30,40)
>>> s.debug_draw(options)
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=52.0, g=152.0, b=219.0, a=255.0))
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))
draw_segment (Vec2d(8.0, 0.0), Vec2d(-8.0, 0.0), SpaceDebugColor(r=10.0, g=20.0, b=30.0, a=40.0))

color_for_shape(shape: Shape) → SpaceDebugColor[源代码]¶

property constraint_color: SpaceDebugColor¶

约束的颜色。

应为介于0和255(r，g，b，a)之间的4个整数的元组。

示例：

>>> import pymunk
>>> s = pymunk.Space()
>>> b = pymunk.Body(1, 10)
>>> j = pymunk.PivotJoint(s.static_body, b, (0,0))
>>> s.add(j)
>>> options = pymunk.SpaceDebugDrawOptions()
>>> s.debug_draw(options)
draw_dot (5.0, Vec2d(0.0, 0.0), SpaceDebugColor(r=142.0, g=68.0, b=173.0, a=255.0))
draw_dot (5.0, Vec2d(0.0, 0.0), SpaceDebugColor(r=142.0, g=68.0, b=173.0, a=255.0))
>>> options.constraint_color = (10,20,30,40)
>>> s.debug_draw(options)
draw_dot (5.0, Vec2d(0.0, 0.0), SpaceDebugColor(r=10.0, g=20.0, b=30.0, a=40.0))
draw_dot (5.0, Vec2d(0.0, 0.0), SpaceDebugColor(r=10.0, g=20.0, b=30.0, a=40.0))

draw_circle(pos: Vec2d, angle: float, radius: float, outline_color: SpaceDebugColor, fill_color: SpaceDebugColor) → None[源代码]¶

draw_dot(size: float, pos: Vec2d, color: SpaceDebugColor) → None[源代码]¶

draw_fat_segment(a: Vec2d, b: Vec2d, radius: float, outline_color: SpaceDebugColor, fill_color: SpaceDebugColor) → None[源代码]¶

draw_polygon(verts: Sequence[Vec2d], radius: float, outline_color: SpaceDebugColor, fill_color: SpaceDebugColor) → None[源代码]¶

draw_segment(a: Vec2d, b: Vec2d, color: SpaceDebugColor) → None[源代码]¶

draw_shape(shape: Shape) → None[源代码]¶

property flags: int¶

位标志应绘制哪些形状、关节和碰撞。

默认情况下，所有3个标志都已设置，这意味着将绘制形状、关节和碰撞。

使用仅基本文本的DebugDraw实现的示例(通常，您应该使用所需的后端，例如 pygame_util.DrawOptions 或 pyglet_util.DrawOptions )：

>>> import pymunk
>>> s = pymunk.Space()
>>> b = pymunk.Body()
>>> c = pymunk.Circle(b, 10)
>>> c.mass = 3
>>> s.add(b, c)
>>> s.add(pymunk.Circle(s.static_body, 3))
>>> s.step(0.01)
>>> options = pymunk.SpaceDebugDrawOptions() 

>>> # Only draw the shapes, nothing else:
>>> options.flags = pymunk.SpaceDebugDrawOptions.DRAW_SHAPES
>>> s.debug_draw(options) 
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=52.0, g=152.0, b=219.0, a=255.0))
draw_circle (Vec2d(0.0, 0.0), 0.0, 3.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))

>>> # Draw the shapes and collision points:
>>> options.flags = pymunk.SpaceDebugDrawOptions.DRAW_SHAPES
>>> options.flags |= pymunk.SpaceDebugDrawOptions.DRAW_COLLISION_POINTS
>>> s.debug_draw(options)
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=52.0, g=152.0, b=219.0, a=255.0))
draw_circle (Vec2d(0.0, 0.0), 0.0, 3.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))
draw_segment (Vec2d(1.0, 0.0), Vec2d(-8.0, 0.0), SpaceDebugColor(r=231.0, g=76.0, b=60.0, a=255.0))

shape_dynamic_color: SpaceDebugColor = (52, 152, 219, 255)¶

shape_kinematic_color: SpaceDebugColor = (39, 174, 96, 255)¶

property shape_outline_color: SpaceDebugColor¶

形状的轮廓颜色。

应为介于0和255(r，g，b，a)之间的4个整数的元组。

示例：

>>> import pymunk
>>> s = pymunk.Space()
>>> c = pymunk.Circle(s.static_body, 10)
>>> s.add(c)
>>> options = pymunk.SpaceDebugDrawOptions()
>>> s.debug_draw(options)
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))
>>> options.shape_outline_color = (10,20,30,40)
>>> s.debug_draw(options)
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=10.0, g=20.0, b=30.0, a=40.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))

shape_sleeping_color: SpaceDebugColor = (114, 148, 168, 255)¶

shape_static_color: SpaceDebugColor = (149, 165, 166, 255)¶

property transform: Transform¶

变换在绘制之前应用，例如用于缩放或平移。

示例：

>>> import pymunk
>>> s = pymunk.Space()
>>> c = pymunk.Circle(s.static_body, 10)
>>> s.add(c)
>>> options = pymunk.SpaceDebugDrawOptions() 
>>> s.debug_draw(options) 
draw_circle (Vec2d(0.0, 0.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))
>>> options.transform = pymunk.Transform.scaling(2)
>>> s.debug_draw(options)
draw_circle (Vec2d(0.0, 0.0), 0.0, 20.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))
>>> options.transform = pymunk.Transform.translation(2,3)
>>> s.debug_draw(options)
draw_circle (Vec2d(2.0, 3.0), 0.0, 10.0, SpaceDebugColor(r=44.0, g=62.0, b=80.0, a=255.0), SpaceDebugColor(r=149.0, g=165.0, b=166.0, a=255.0))

备注

并非所有转换都受调试绘制逻辑支持。支持均匀缩放和平移，但不支持旋转、线性拉伸或剪切。

class pymunk.Transform(a: float = 1, b: float = 0, c: float = 0, d: float = 1, tx: float = 0, ty: float = 0)[源代码]¶

基类：NamedTuple

用于2x3仿射变换的类型。

详情请参阅维基百科：http://en.wikipedia.org/wiki/Affine_transformation

属性以这种方式映射到矩阵：

一个	C	TX
B类	D	泰伊
0	0	1

创建实例的方式如下：

>>> Transform(1,2,3,4,5,6)
Transform(a=1, b=2, c=3, d=4, tx=5, ty=6)

或仅覆盖部分值(在单位矩阵上)：

>>> Transform(b=3,ty=5)
Transform(a=1, b=3, c=0, d=1, tx=0, ty=5)

或者使用一种静态方法，如标识或转换(有关详细信息，请参阅每种方法)。

转换支持将转换、Vec2d或元组作为第二个操作数的矩阵乘法运算符(@)，这将生成转换后的转换或Vec2d作为结果：

>>> Transform.scaling(2) @ Transform.scaling(3)
Transform(a=6, b=0, c=0, d=6, tx=0, ty=0)
>>> Transform.scaling(2) @ Vec2d(1, 2)
Vec2d(2, 4)

__matmul__(other: Tuple[float, float]) → Vec2d[源代码]¶

__matmul__(other: Tuple[float, float, float, float, float, float]) → Transform

将此变换与大小为2或6的变换、Vec2d或Tuple相乘。

示例(Transform@Transform)：

>>> Transform() @ Transform() == Transform.identity()
True
>>> Transform.translation(2,3) @ Transform.translation(4,5)
Transform(a=1, b=0, c=0, d=1, tx=6, ty=8)
>>> Transform.scaling(2) @ Transform.scaling(3)
Transform(a=6, b=0, c=0, d=6, tx=0, ty=0)
>>> Transform.scaling(2) @ Transform.translation(3,4)
Transform(a=2, b=0, c=0, d=2, tx=6, ty=8)
>>> Transform.translation(3,4) @ Transform.scaling(2)
Transform(a=2, b=0, c=0, d=2, tx=3, ty=4)

示例(Transform@Vec2d)：

>>> Transform.identity() @ Vec2d(1, 2)
Vec2d(1, 2)
>>> Transform.scaling(2) @ Vec2d(1, 2)
Vec2d(2, 4)
>>> Transform.translation(3,5) @ Vec2d(1, 2)
Vec2d(4, 7)
>>> Transform.rotation(1) @ Vec2d(1, 2) == Vec2d(1, 2).rotated(1)
True

a: float¶: 字段号0的别名

b: float¶: 字段号%1的别名

c: float¶: 字段号2的别名

d: float¶: 第3号字段的别名

static identity() → Transform[源代码]¶

同一性变换

示例：

>>> Transform.identity()
Transform(a=1, b=0, c=0, d=1, tx=0, ty=0)

返回包含此矩阵的转换：

1	0	0
0	1	0
0	0	1

rotated(t: float) → Transform[源代码]¶

旋转此变换并返回结果。

>>> '%.2f, %.2f, %.2f, %.2f, %.2f, %.2f' % Transform.rotation(1).rotated(0.5)
'0.07, 1.00, -1.00, 0.07, 0.00, 0.00'
>>> '%.2f, %.2f, %.2f, %.2f, %.2f, %.2f' % Transform.rotation(1.5)
'0.07, 1.00, -1.00, 0.07, 0.00, 0.00'

static rotation(t: float) → Transform[源代码]¶

旋转变换

旋转1拉德的示例：

>>> '%.2f, %.2f, %.2f, %.2f, %.2f, %.2f' % Transform.rotation(1)
'0.54, 0.84, -0.84, 0.54, 0.00, 0.00'

返回包含此矩阵的转换：

COS(T)	-SIN(T)	0
SIN(T)	COS(T)	0
0	0	1

scaled(s: float) → Transform[源代码]¶

缩放该变换并返回结果。

示例：

>>> Transform.translation(3,4).scaled(2)
Transform(a=2, b=0, c=0, d=2, tx=3, ty=4)

static scaling(s: float) → Transform[源代码]¶

一种缩放变换

扩展到4倍的示例：

>>> Transform.scaling(4)
Transform(a=4, b=0, c=0, d=4, tx=0, ty=0)

返回包含此矩阵的转换：

S	0	0
0	S	0
0	0	1

translated(x: float, y: float) → Transform[源代码]¶

转换此转换并返回结果。

示例：>Transform.Scaling(2).Transted(3，4)Transform(a=2，b=0，c=0，d=2，tx=6，ty=8)

static translation(x: float, y: float) → Transform[源代码]¶

平移变换

在x轴上平移(移动)3并在y轴上平移(移动)5的示例：

>>> Transform.translation(3, 5)
Transform(a=1, b=0, c=0, d=1, tx=3, ty=5)

返回包含此矩阵的转换：

1	0	X
0	1	是
0	0	1

tx: float¶: 字段号4的别名

ty: float¶: 字段号5的别名

class pymunk.Vec2d(x: float, y: float)[源代码]¶

基类：NamedTuple

2D向量类，支持向量和标量运算符，还提供了一些高级函数。

property angle: float¶: 向量的角度(以弧度表示)

property angle_degrees: float¶: 获取向量的角度(以度为单位)

convert_to_basis(x_vector: Tuple[float, float], y_vector: Tuple[float, float]) → Vec2d[源代码]¶

cpvrotate(other: Tuple[float, float]) → Vec2d[源代码]¶: 使用复数乘法将此向量旋转到另一个。

cpvunrotate(other: Tuple[float, float]) → Vec2d[源代码]¶: CpvRotate的逆数

cross(other: Tuple[float, float]) → float[源代码]¶

向量与其他向量之间的叉积: V1.cross(V2)->v1.x v2.y - v1.y v2.x

返回:: 叉积

dot(other: Tuple[float, float]) → float[源代码]¶

向量与其他向量之间的点积: V1.ot(V2)->v1.x v2.x + v1.y v2.y

返回:: 点积

get_angle_between(other: Tuple[float, float]) → float[源代码]¶

求出向量与另一个向量之间的角度，单位为弧度

返回:: 角度

get_angle_degrees_between(other: Vec2d) → float[源代码]¶

获取向量与另一个向量之间的角度(以度为单位

返回:: 角度(以度为单位)

get_dist_sqrd(other: Tuple[float, float]) → float[源代码]¶

向量和其他向量之间的平方距离使用此方法比先调用get_Distance()然后对结果执行SQRT()更有效。

返回:: 平方距离

get_distance(other: Tuple[float, float]) → float[源代码]¶

向量与其他向量之间的距离

返回:: 距离

get_length_sqrd() → float[源代码]¶

得到向量的平方长度。如果长度的平方足够，则使用此方法比首先调用GET_LENGTH()或Access.Length然后执行x**2更有效。

>>> v = Vec2d(3,4)
>>> v.get_length_sqrd() == v.length**2
True

返回:: 长度的平方

property int_tuple: Tuple[int, int]¶

此向量的x和y值，表示为整型数组。使用ROUND()舍入到最接近的整型。

>>> Vec2d(0.9, 2.4).int_tuple
(1, 2)

interpolate_to(other: Tuple[float, float], range: float) → Vec2d[源代码]¶

property length: float¶

获取向量的长度。

>>> Vec2d(10, 0).length
10.0
>>> '%.2f' % Vec2d(10, 20).length
'22.36'

返回:: 它的长度

normalized() → Vec2d[源代码]¶

获取向量的标准化副本注意：如果向量的长度为0，则此函数将返回0。

返回:: 归一化向量

normalized_and_length() → Tuple[Vec2d, float][源代码]¶

规格化向量并在规格化之前返回其长度

返回:: 规范化前的长度

static ones() → Vec2d[源代码]¶

X和y均为1的向量

>>> Vec2d.ones()
Vec2d(1, 1)

perpendicular() → Vec2d[源代码]¶

perpendicular_normal() → Vec2d[源代码]¶

projection(other: Tuple[float, float]) → Vec2d[源代码]¶: 将此向量投影到其他向量的顶部

rotated(angle_radians: float) → Vec2d[源代码]¶

通过按角度弧度旋转该向量来创建并返回一个新向量。

返回:: 旋转向量

rotated_degrees(angle_degrees: float) → Vec2d[源代码]¶

通过按角度度数旋转该向量来创建并返回一个新的向量。

返回:: 旋转向量

scale_to_length(length: float) → Vec2d[源代码]¶

返回缩放到给定长度的该向量的副本。

>>> '%.2f, %.2f' % Vec2d(10, 20).scale_to_length(20)
'8.94, 17.89'

static unit() → Vec2d[源代码]¶

指向上方的单位向量

>>> Vec2d.unit()
Vec2d(0, 1)

x: float¶: 字段号0的别名

y: float¶: 字段号%1的别名

static zero() → Vec2d[源代码]¶

长度为零的向量。

>>> Vec2d.zero()
Vec2d(0, 0)

pymunk.chipmunk_version: str = 'pymunk._chipmunk.ffi.string.decode-5dd7d774053145fa37f352d7a07d2f75a9bd8039'¶

Chipmunk版本与这个Pymunk版本一起使用。

只有当您实际导入pymunk并执行pymunk.chipmunk_version时，此属性才不会在编译的文档中显示有效值

该字符串采用以下格式：R其中cpVersionString是由Chipmunk设置的版本字符串，并且Git Commit散列对应于来自包括在Pymunk中的gihub.com/viblo/Chipmunk2D的花栗源代码的git散列。

pymunk.moment_for_box(mass: float, size: Tuple[float, float]) → float[源代码]¶

计算以物体为中心的实心长方体的转动惯量。

大小应为(宽度、高度)的元组

pymunk.moment_for_circle(mass: float, inner_radius: float, outer_radius: float, offset: Tuple[float, float] = (0, 0)) → float[源代码]¶

计算空心圆的转动惯量

(实心圆的内径为0)

pymunk.moment_for_poly(mass: float, vertices: Sequence[Tuple[float, float]], offset: Tuple[float, float] = (0, 0), radius: float = 0) → float[源代码]¶

计算实心多边形的转动惯量。

假定多边形重心位于其质心。该偏移将添加到每个顶点。

pymunk.moment_for_segment(mass: float, a: Tuple[float, float], b: Tuple[float, float], radius: float) → float[源代码]¶

计算直线段的转动惯量

端点a和b是相对于主体的

pymunk.version: str = '6.6.2'¶: 此Pymunk安装的发布版本。仅当从源代码或二进制发行版(即不是从git签出的副本中)安装了pymunk时才有效。

API参考¶

`pymunk` 套餐¶

目录

Related Topics

API参考¶

pymunk 套餐¶

`pymunk` 套餐¶