API参考¶

`pymunk` 套餐¶

子模块

..评论

Pymunk

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

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

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

Pymunk使用标准日志模块来记录有用的信息。它以“pymunk”的名字来做到这一点。如果您不进行任何设置，它会将收件箱和更高级别的消息打印到stderr。(Note您很可能不想将logLevel设置为DEBug，因为Pymunk可能会记录大量在Pymunk本身开发期间最有用的调试级消息。）

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

基类：object

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

关于它们碰撞的数据。

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

警告

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

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

备注

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

property bodies: tuple[Body, Body]¶

实体按照与此仲裁器相关的冲突处理程序中定义其相应形状的顺序。

这是获取预兆的简写：：

arb.bodies == arb.shapes[0].body, arb.shapes[1].body .

property contact_point_set: ContactPointSet¶

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

返回 ContactPointSet

property friction: float¶

此碰撞对的计算摩擦力。

在pro_solve（）回调中设置值将覆盖由空间计算的值。默认计算将两个形状的摩擦力相乘。

property is_first_contact: bool¶

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

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

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

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

property process_collision: bool¶

决定是否处理或拒绝冲突。

在 begin() 或 pre_solve() 回调以覆盖默认值 (True ）价值。

将此设置为 true 正常处理碰撞或 false 让皮蒙克完全忽视碰撞。注意虽然 post_solve 如果是，可能会跳过 false , separate 当形状停止重叠时，将始终被调用。

备注

传感器Shape或连接到静态或动态主体的Shape不会处理碰撞。

property restitution: float¶

该碰撞对的计算恢复（弹性）。

在pro_solve（）回调中设置值将覆盖由空间计算的值。默认计算将两个形状的弹性相乘。

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)

__add__(value, /)¶: 回归自我+价值。

__mul__(value, /)¶: 返回自我 * 价值。

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

刚体

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

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

__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: KeysView[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¶

身体的质量。

请注意，如果动态物体连接到Space，其质量必须> 0。

property moment: float¶

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

动量就像物体的旋转质量。请注意，将时刻设置为浮动（' inf '）是有效的。这将使物体无法旋转。

property position: Vec2d¶

身体的位置。

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

property position_func¶

位置回调函数。

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

func(body, dt) -> None

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

property shapes: KeysView[Shape]¶

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

如果您的身体上只有一个形状，您可以轻松将其拆开：

>>> from pymunk import Circle
>>> b = Body(1)
>>> circle = Circle(b, 2)
>>> [shape] = b.shapes
>>> shape == circle
True

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¶

这种形状所附着的身体。

可以设置为无以指示此形状不属于实体。该形状只对身体有弱参考，这意味着它不会阻止它获得GCed。

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

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

property collision_type: int¶

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

0到0。

看到 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 | None¶

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

如果不相交，则返回无

返回类型:: 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.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: tuple[ContactPoint, ...])[源代码]¶

基类：object

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

法线是碰撞的法线

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

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

normal: Vec2d¶

points: tuple[ContactPoint, ...]¶

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

基类：NamedTuple

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

__add__(value, /)¶: 回归自我+价值。

__mul__(value, /)¶: 返回自我 * 价值。

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

gradient: Vec2d¶

带符号距离函数的梯度。

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

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

shape: Shape¶: 最近的形状

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[源代码]¶

创建一个多边形。

将自动从这些点计算出凸壳。请注意，凹凸将使用Quickhull算法转换为凸面壳：：

>>> poly = Poly(None, [(-1,0), (0, -0.5), (1, 0), (0,-1)])
>>> poly.get_vertices()
[Vec2d(-1.0, 0.0), Vec2d(0.0, -1.0), Vec2d(1.0, 0.0)]

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

发送“无”作为实体参数是合法的，以表明该形状不附在实体上。但是，在将形状添加到空间或用于空间形状查询之前，必须将其附加到主体。

备注

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

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

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

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

>>> width, height = 10, 20
>>> vs = [(0, 0), (width, 0), (width, height), (0, height)]
>>> poly_bad = Poly(None, vs)
>>> print(poly_bad.center_of_gravity)
Vec2d(5.0, 10.0)
>>> t = Transform(tx=-width/2, ty=-height/2)
>>> poly_good = 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¶

这种形状所附着的身体。

可以设置为无以指示此形状不属于实体。该形状只对身体有弱参考，这意味着它不会阻止它获得GCed。

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

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

property collision_type: int¶

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

0到0。

看到 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 | None¶

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

如果不相交，则返回无

返回类型:: 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¶

这种形状所附着的身体。

可以设置为无以指示此形状不属于实体。该形状只对身体有弱参考，这意味着它不会阻止它获得GCed。

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

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

property collision_type: int¶

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

0到0。

看到 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 | None¶

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

如果不相交，则返回无

返回类型:: 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, point: Vec2d, normal: Vec2d, alpha: float)[源代码]¶

基类：NamedTuple

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

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

__add__(value, /)¶: 回归自我+价值。

__mul__(value, /)¶: 返回自我 * 价值。

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

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

point: Vec2d¶: 撞击点。

shape: Shape¶: 命中的形状，如果未发生冲突，则为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¶

这种形状所附着的身体。

可以设置为无以指示此形状不属于实体。该形状只对身体有弱参考，这意味着它不会阻止它获得GCed。

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

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

property collision_type: int¶

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

0到0。

看到 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 | None[源代码]¶

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

如果不相交，则返回无

返回类型:: 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[源代码]¶

__add__(value, /)¶: 回归自我+价值。

__mul__(value, /)¶: 返回自我 * 价值。

categories: int¶

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

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

group: int¶

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

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

mask: int¶

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

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

rejects_collision(other: ShapeFilter) → bool[源代码]¶

如果此Shape滤镜会拒绝与其他Shape滤镜的冲突，则返回true。

如果出现以下情况，两个Shape Filters会拒绝冲突：

它们属于同一非零组，或者
类别与其他形状过滤器的蒙版不匹配

有关用例的完整解释，请参阅类文档。

团体：：

>>> ShapeFilter().rejects_collision(ShapeFilter())
False
>>> ShapeFilter(group=1).rejects_collision(ShapeFilter(group=2))
False
>>> ShapeFilter(group=1).rejects_collision(ShapeFilter(group=1))
True

类别和面具：：

>>> default = ShapeFilter()
>>> default.rejects_collision(default)
False
>>> f1 = ShapeFilter(categories=0b11, mask=0b11)
>>> f2 = ShapeFilter(categories=0b01, mask=0b11)
>>> f3 = ShapeFilter(categories=0b01, mask=0b10)
>>> f1.rejects_collision(f2)
False
>>> f1.rejects_collision(f3)
False
>>> f2.rejects_collision(f3)
True

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

基类：NamedTuple

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

__add__(value, /)¶: 回归自我+价值。

__mul__(value, /)¶: 返回自我 * 价值。

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

shape: Shape¶: 命中的形状，如果未发生冲突，则为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_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

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

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

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

传感器形状包含在结果中

参数:

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

返回类型:

[Shape]

property bodies: KeysView[Body]¶

添加到此空间的实体将作为KeysView返回。

这包括添加到空间的静态和非静态物体。由于这是返回的视图，因此它将在添加实体时更新：

>>> import pymunk
>>> s = pymunk.Space()
>>> s.add(pymunk.Body())
>>> bodies_view = s.bodies
>>> len(bodies_view)
1
>>> s.add(pymunk.Body())
>>> len(bodies_view)
2

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: KeysView[Constraint]¶: 约束作为KeysView添加到此空间中。

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次迭代对于大多数简单的游戏来说已经足够了。

on_collision(collision_type_a: int | None = None, collision_type_b: int | None = None, begin: Callable[[Arbiter, Space, Any], None] | None = None, pre_solve: Callable[[Arbiter, Space, Any], None] | None = None, post_solve: Callable[[Arbiter, Space, Any], None] | None = None, separate: Callable[[Arbiter, Space, Any], None] | None = None, data: Any = None) → None[源代码]¶

设置将在冲突处理的4个阶段调用的回调。

每当形状具有碰撞类型 (Shape.collision_type ）a和b发生冲突，则回调将用于处理冲突事件。如果未设置回调，默认为正常处理冲突。

可以为一种或两种碰撞类型传入None。“无”与形状上的任何碰撞类型匹配。但是，如果collision_type_a为None，则collision_type_b也必须为None。

如果您多次使用collision_Type_a和collision_Type_b的相同组合调用此命令，则最后一次调用将覆盖较早的调用。

如果多个回调匹配冲突，则顺序将是首先调用最具体的处理程序。

回调阶段：

begin ：这一步两个形状刚刚第一次开始接触。

pre_solve ：在碰撞解决之前，在此步骤中，两个形状正在接触。您可以使用Arbiter.friction、Arbiter. elastic或Arbiter. surfaceSpeed覆盖碰撞值，以提供自定义摩擦、弹性或表面速度值。请参阅仲裁者了解更多信息。

post_solve ：两个形状正在接触，并且它们的碰撞响应已被处理。如果您想使用碰撞脉冲或动能来计算音量或损坏量，则可以此时检索碰撞脉冲或动能。请参阅仲裁者了解更多信息。

separate ：这一步中，两个形状刚刚第一次停止接触。为了确保始终以平衡对的方式调用Begin（）/separate（），在与某物接触时删除形状或取消分配空间时，也会调用它。

从每个回调中，您可以在仲裁器上设置Process_collision，该仲裁器决定是否应该处理冲突。

数据将不改变地传递到回调函数。

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

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

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

结果中包括传感器形状。

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

参数:

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参数的详细信息。

备注

结果中包括传感器形状。（在Pymunk 7.0中更改）

参数:

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参数的详细信息。

结果中包括传感器形状。

参数:

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[源代码]¶

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

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

备注

结果中包括传感器形状。（在Pymunk 7.0中更改）

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

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

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

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

传感器形状包含在结果中

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

property shapes: KeysView[Shape]¶

添加到此空间的形状返回为KeysView。

由于这是返回的视图，它将随着形状的添加而更新。

>>> import pymunk
>>> s = pymunk.Space()
>>> s.add(pymunk.Circle(s.static_body, 1))
>>> shapes_view = s.shapes
>>> len(shapes_view)
1
>>> s.add(pymunk.Circle(s.static_body, 2))
>>> len(shapes_view)
2

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创建Space时有效。目前最大限制为2，设置更高的值不会有任何影响。无论Space是否使用threaded=True创建，默认值都是1，以保持模拟中的确定性。请注意，Windows不支持线程解算器。

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

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

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

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

计数是哈希表中单元格的最小数量。如果单元格太少，空间哈希将返回许多误报。太多的单元格将对缓存造成困难并浪费内存。将计数设置为空间中对象数量的~ 10倍可能是一个很好的起点。如有必要，可从那里收听。

参数:

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

class pymunk.SpaceDebugDrawOptions[源代码]¶

基类：object

SpaceDebugDrawOptions配置调试绘图。

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

__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个标志都已设置，这意味着将绘制形状、关节和碰撞。

仅使用基本文本的示例IngDraw实现（通常您会使用所需的后台，例如 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)

__add__(value, /)¶: 回归自我+价值。

__matmul__(other: tuple[float, float] | tuple[float, float, float, float, float, float]) → Vec2d | Transform[源代码]¶

将此变换与大小为2或6的变换、Vec 2d或多元组相乘。

示例(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

__mul__(value, /)¶: 返回自我 * 价值。

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向量类，支持向量和标量运算符，还提供了一些高级函数。

__abs__() → float[源代码]¶

返回Vec 2d的长度。

>>> abs(Vec2d(3, 4))
5.0
>>> abs(Vec2d(3, 4)) == Vec2d(3, 4).length
True

__add__(other: tuple[float, float]) → Vec2d[源代码]¶

将Vec 2d与另一个Vec 2d或大小为2的多元组添加。

>>> Vec2d(3, 4) + Vec2d(1, 2)
Vec2d(4, 6)
>>> Vec2d(3, 4) + (1, 2)
Vec2d(4, 6)

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

用浮点数除下限（也称为整除）。

>>> Vec2d(3, 6) // 2.0
Vec2d(1.0, 3.0)
>>> Vec2d(0, 0) // 2.0
Vec2d(0.0, 0.0)

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

将Vec 2d乘以浮点数。

>>> Vec2d(3, 6) * 2.5
Vec2d(7.5, 15.0)

__neg__() → Vec2d[源代码]¶

返回Vec 2d的否定版本。

>>> -Vec2d(1, -2)
Vec2d(-1, 2)
>>> -Vec2d(0, 0)
Vec2d(0, 0)

__pos__() → Vec2d[源代码]¶

返回Vec2d的一元pos。

>>> +Vec2d(1, -2)
Vec2d(1, -2)

__sub__(other: tuple[float, float]) → Vec2d[源代码]¶

用另一个Vec 2d或大小为2的多元组减去Vec 2d。

>>> Vec2d(3, 4) - Vec2d(1, 2)
Vec2d(2, 2)
>>> Vec2d(3, 4) - (1, 2)
Vec2d(2, 2)

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

被浮动除。

>>> Vec2d(3, 6) / 2.0
Vec2d(1.5, 3.0)
>>> Vec2d(0,0) / 2.0
Vec2d(0.0, 0.0)

property angle: float¶

向量的角度（以弧度为单位）。

角度使用atan 2（y，x）计算。

>>> '%.2f' % Vec2d(-1, 0).angle
'3.14'
>>> Vec2d(0, 0).angle
0.0

property angle_degrees: float¶

获取向量的角度（以度为单位）。

>>> Vec2d(0, 1).angle_degrees
90.0
>>> Vec2d(0, 0).angle_degrees
0.0

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

将该载体转换为由给定x和y载体定义的新基。

>>> Vec2d(10, 1).convert_to_basis((5, 0), (0, 0.5))
Vec2d(2.0, 2.0)

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

>>> Vec2d(1, 0.5).cross((4, 6))
4.0

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

该载体与其他载体之间的点积。v1.dot-> v1.x v2.x + v1.y v2.y

>>> Vec2d(5, 0).dot((0, 5))
0.0
>>> Vec2d(1, 2).dot((3, 4))
11.0

static from_polar(length: float, angle: float) → Vec2d[源代码]¶

根据长度和角度（以弧度为单位）创建新的Vec 2d。

请参阅Vec2d.polar_tuple了解相反情况。

>>> Vec2d.from_polar(2, 0)
Vec2d(2.0, 0.0)
>>> Vec2d(2, 0).rotated(0.5) == Vec2d.from_polar(2, 0.5)
True
>>> v = Vec2d.from_polar(2, 0.5)
>>> v.length, v.angle
(2.0, 0.5)

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

获取该方向的角度（以弧度为单位）。

>>> '%.2f' % Vec2d(3, 0).get_angle_between(Vec2d(-1, 0))
'3.14'
>>> Vec2d(3, 0).get_angle_between(Vec2d(0, 0))
0.0
>>> Vec2d(0, 0).get_angle_between(Vec2d(0, 0))
0.0

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

得到向量和另一个向量之间的角度，单位为度。

>>> Vec2d(3, 0).get_angle_degrees_between(Vec2d(-1, 0))
180.0
>>> Vec2d(3, 0).get_angle_degrees_between(Vec2d(0, 0))
0.0
>>> Vec2d(0, 0).get_angle_degrees_between(Vec2d(0, 0))
0.0

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

该载体与其他载体之间的平方距离。使用此方法比首先调用get_distance（）然后对结果进行平方（）更有效。

自 7.0.0 版本弃用: 请使用 get_distance_squared() 而不是.

>>> Vec2d(1, 0).get_dist_sqrd((1, 10))
100
>>> Vec2d(1, 2).get_dist_sqrd((10, 11))
162
>>> Vec2d(1, 2).get_distance((10, 11))**2
162.0

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

该载体与其他载体之间的距离。

>>> Vec2d(0, 2).get_distance((0, -3))
5.0
>>> a, b = Vec2d(3, 2), Vec2d(4,3)
>>> a.get_distance(b) == (a - b).length == (b - a).length
True

get_distance_squared(other: tuple[float, float]) → float[源代码]¶

该载体与其他载体之间的平方距离。使用此方法比首先调用get_distance（）然后对结果进行平方（）更有效。

>>> Vec2d(1, 0).get_distance_squared((1, 10))
100
>>> Vec2d(1, 2).get_distance_squared((10, 11))
162
>>> Vec2d(1, 2).get_distance((10, 11))**2
162.0

get_length_sqrd() → float[源代码]¶

获取该方向的平方长度。如果平方长度足够，则使用此方法更有效，而不是首先访问. long然后执行x**2。

自 7.0.0 版本弃用: 请使用 length_squared 而不是.

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

property int_tuple: tuple[int, int]¶

作为int的多元组的该载体的x和y值。使用 round() 四舍五入到最近的int。

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

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

当前载体和另一个载体之间的载体插值。

>>> Vec2d(10,20).interpolate_to((20,-20), 0.1)
Vec2d(11.0, 16.0)

property length: float¶

获取向量的长度。

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

property length_squared: float¶

获取该方向的平方长度。如果平方长度足够，则使用此方法而不是首先访问. long然后执行x**2会更有效。

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

normalized() → Vec2d[源代码]¶

获取该载体的规范化副本。注意：如果该载体的长度为0，该函数将返回Vec 2d（0.0，0.0）。

>>> Vec2d(3, 0).normalized()
Vec2d(1.0, 0.0)
>>> Vec2d(3, 4).normalized()
Vec2d(0.6, 0.8)
>>> Vec2d(0, 0).normalized()
Vec2d(0.0, 0.0)

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

规范化该载体并返回规范化之前的长度。

>>> Vec2d(3, 0).normalized_and_length()
(Vec2d(1.0, 0.0), 3.0)
>>> Vec2d(3, 4).normalized_and_length()
(Vec2d(0.6, 0.8), 5.0)
>>> Vec2d(0, 0).normalized_and_length()
(Vec2d(0.0, 0.0), 0.0)

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

一个x和y都是1的向量。

>>> Vec2d.ones()
Vec2d(1.0, 1.0)

perpendicular() → Vec2d[源代码]¶

获得从原始载体逆时针旋转90度的垂直载体。

>>> Vec2d(1, 2).perpendicular()
Vec2d(-2, 1)

perpendicular_normal() → Vec2d[源代码]¶

获取从原始载体逆时针旋转90度的垂直规范化载体。

>>> Vec2d(1, 0).perpendicular_normal()
Vec2d(0.0, 1.0)
>>> Vec2d(2, 0).perpendicular_normal()
Vec2d(0.0, 1.0)
>>> Vec2d(1, 1).perpendicular_normal().angle_degrees
135.0
>>> Vec2d(1, 1).angle_degrees + 90
135.0
>>> Vec2d(0, 0).perpendicular_normal()
Vec2d(0, 0)

property polar_tuple: tuple[float, float]¶

将此载体返回为极坐标（长度、角度）

请参阅Vec2d.from_polar（）了解相反情况。

>>> Vec2d(2, 0).polar_tuple
(2.0, 0.0)
>>> Vec2d(2, 0).rotated(0.5).polar_tuple
(2.0, 0.5)
>>> Vec2d.from_polar(2, 0.5).polar_tuple
(2.0, 0.5)

projection(other: tuple[float, float]) → Vec2d[源代码]¶

将此载体投影到其他载体之上。

>>> Vec2d(10, 1).projection((5.0, 0))
Vec2d(10.0, 0.0)
>>> Vec2d(10, 1).projection((10, 5))
Vec2d(8.4, 4.2)
>>> Vec2d(10, 1).projection((0, 0))
Vec2d(0.0, 0.0)

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

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

>>> '%.2f' % Vec2d(2,0).rotated(math.pi).angle
'3.14'
>>> Vec2d(0,0).rotated(1)
Vec2d(0.0, 0.0)

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

创建并返回一个新的向量，方法是将此向量旋转: 角度_度。

>>> Vec2d(2,0).rotated_degrees(90.0).angle_degrees
90.0
>>> Vec2d(0, 0).rotated_degrees(90.0)
Vec2d(0.0, 0.0)

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

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

请注意，零长度Vec 2d无法缩放，但会引发异常。

>>> Vec2d(1, 0).scale_to_length(10)
Vec2d(10.0, 0.0)
>>> '%.2f, %.2f' % Vec2d(10, 20).scale_to_length(20)
'8.94, 17.89'
>>> Vec2d(1, 0).scale_to_length(0)
Vec2d(0.0, 0.0)
>>> Vec2d(0, 0).scale_to_length(1)
Traceback (most recent call last):
...
ZeroDivisionError: float division by zero

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

向上指向的单位载体。

>>> Vec2d.unit()
Vec2d(0.0, 1.0)

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

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

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

长度为零的向量。

>>> Vec2d.zero()
Vec2d(0.0, 0.0)

pymunk.area_for_circle(inner_radius: float, outer_radius: float) → float[源代码]¶: 空心圆的面积。

pymunk.area_for_poly(vertices: Sequence[tuple[float, float]], radius: float = 0) → float[源代码]¶

多边形形状的符号区域。

对于顺时针缠绕的多边形，返回负值。

pymunk.area_for_segment(a: tuple[float, float], b: tuple[float, float], radius: float) → float[源代码]¶

倾斜段的面积。

(Will如果半径为零，则始终为零）

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

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

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

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

pymunk.empty_callback(*args: Any, **kwargs: Any) → None[源代码]¶

默认空回调。

可用于将排序回调重置为其原始空函数。请注意，使用此方法比定义自己的空/无所事事方法更有效。

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 = '2.0.0'¶: 此Pymunk安装的发布版本。仅当从源代码或二进制发行版(即不是从git签出的副本中)安装了pymunk时才有效。

API参考¶

`pymunk` 套餐¶

目录

Related Topics

API参考¶

pymunk 套餐¶

`pymunk` 套餐¶