test-kivy-app/kivy_venv/share/kivy-examples/miscellaneous/shapecollisions.py
2024-09-15 15:12:16 +03:00

398 lines
14 KiB
Python

# This is a simple demo for advanced collisions and mesh creation from a set
# of points. Its purpose is only to give an idea on how to make complex stuff.
# Check garden.collider for better performance.
from math import cos, sin, pi, sqrt
from random import random, randint
from itertools import combinations
from kivy.app import App
from kivy.clock import Clock
from kivy.uix.label import Label
from kivy.uix.widget import Widget
from kivy.core.window import Window
from kivy.graphics import Color, Mesh, Point
from kivy.uix.floatlayout import FloatLayout
from kivy.properties import (
ListProperty,
StringProperty,
ObjectProperty,
NumericProperty
)
# Cloud polygon, 67 vertices + custom origin [150, 50]
cloud_poly = [
150, 50,
109.7597, 112.9600, 115.4326, 113.0853, 120.1966, 111.9883,
126.0889, 111.9570, 135.0841, 111.9570, 138.5944, 112.5525,
145.7403, 115.5301, 150.5357, 120.3256, 155.5313, 125.5938,
160.8438, 130.5000, 165.7813, 132.5000, 171.8125, 132.3438,
177.5000, 128.4688, 182.1531, 121.4990, 185.1438, 114.0406,
185.9181, 108.5649, 186.2226, 102.5978, 187.8059, 100.2231,
193.2257, 100.1622, 197.6712, 101.8671, 202.6647, 104.1809,
207.1102, 105.8858, 214.2351, 105.0333, 219.3747, 102.8301,
224.0413, 98.7589, 225.7798, 93.7272, 226.0000, 86.8750,
222.9375, 81.0625, 218.3508, 76.0867, 209.8301, 70.8090,
198.7806, 66.1360, 189.7651, 62.2327, 183.6082, 56.6252,
183.2784, 50.5778, 190.9155, 42.7294, 196.8470, 36.1343,
197.7339, 29.9272, 195.5720, 23.4430, 191.2500, 15.9803,
184.0574, 9.5882, 175.8811, 3.9951, 165.7992, 3.4419,
159.0369, 7.4370, 152.5205, 14.8125, 147.4795, 24.2162,
142.4385, 29.0103, 137.0287, 30.9771, 127.1560, 27.4818,
119.1371, 20.0388, 112.1820, 11.3690, 104.6541, 7.1976,
97.2080, 6.2979, 88.9437, 9.8149, 80.3433, 17.3218,
76.5924, 26.5452, 78.1678, 37.0432, 83.5068, 47.1104,
92.8529, 58.3561, 106.3021, 69.2978, 108.9615, 73.9329,
109.0375, 80.6955, 104.4713, 88.6708, 100.6283, 95.7483,
100.1226, 101.5114, 102.8532, 107.2745, 105.6850, 110.9144,
109.7597, 112.9600
]
class BaseShape(Widget):
'''(internal) Base class for moving with touches or calls.'''
# keep references for offset
_old_pos = ListProperty([0, 0])
_old_touch = ListProperty([0, 0])
_new_touch = ListProperty([0, 0])
# shape properties
name = StringProperty('')
poly = ListProperty([])
shape = ObjectProperty()
poly_len = NumericProperty(0)
shape_len = NumericProperty(0)
debug_collider = ObjectProperty()
debug_collider_len = NumericProperty(0)
def __init__(self, **kwargs):
'''Create a shape with size [100, 100]
and give it a label if it's named.
'''
super(BaseShape, self).__init__(**kwargs)
self.size_hint = (None, None)
self.add_widget(Label(text=self.name))
def move_label(self, x, y, *args):
'''Move label with shape name as the only child.'''
self.children[0].pos = [x, y]
def move_collider(self, offset_x, offset_y, *args):
'''Move debug collider when the shape moves.'''
points = self.debug_collider.points[:]
for i in range(0, self.debug_collider_len, 2):
points[i] += offset_x
points[i + 1] += offset_y
self.debug_collider.points = points
def on_debug_collider(self, instance, value):
'''Recalculate length of collider points' array.'''
self.debug_collider_len = len(value.points)
def on_poly(self, instance, value):
'''Recalculate length of polygon points' array.'''
self.poly_len = len(value)
def on_shape(self, instance, value):
'''Recalculate length of Mesh vertices' array.'''
self.shape_len = len(value.vertices)
def on_pos(self, instance, pos):
'''Move polygon and its Mesh on each position change.
This event is above all and changes positions of the other
children-like components, so that a simple::
shape.pos = (100, 200)
would move everything, not just the widget itself.
'''
# position changed by touch
offset_x = self._new_touch[0] - self._old_touch[0]
offset_y = self._new_touch[1] - self._old_touch[1]
# position changed by call (shape.pos = X)
if not offset_x and not offset_y:
offset_x = pos[0] - self._old_pos[0]
offset_y = pos[1] - self._old_pos[1]
self._old_pos = pos
# move polygon points by offset
for i in range(0, self.poly_len, 2):
self.poly[i] += offset_x
self.poly[i + 1] += offset_y
# stick label to bounding box (widget)
if self.name:
self.move_label(*pos)
# move debug collider if available
if self.debug_collider is not None:
self.move_collider(offset_x, offset_y)
# return if no Mesh available
if self.shape is None:
return
# move Mesh vertices by offset
points = self.shape.vertices[:]
for i in range(0, self.shape_len, 2):
points[i] += offset_x
points[i + 1] += offset_y
self.shape.vertices = points
def on_touch_move(self, touch, *args):
'''Move shape with dragging.'''
# grab single touch for shape
if touch.grab_current is not self:
return
# get touches
x, y = touch.pos
new_pos = [x, y]
self._new_touch = new_pos
self._old_touch = [touch.px, touch.py]
# get offsets, move & trigger on_pos event
offset_x = self._new_touch[0] - self._old_touch[0]
offset_y = self._new_touch[1] - self._old_touch[1]
self.pos = [self.x + offset_x, self.y + offset_y]
def shape_collide(self, x, y, *args):
'''Point to polygon collision through a list of points.'''
# ignore if no polygon area is set
poly = self.poly
if not poly:
return False
n = self.poly_len
inside = False
p1x = poly[0]
p1y = poly[1]
# compare point pairs via PIP algo, too long, read
# https://en.wikipedia.org/wiki/Point_in_polygon
for i in range(0, n + 2, 2):
p2x = poly[i % n]
p2y = poly[(i + 1) % n]
if y > min(p1y, p2y) and y <= max(p1y, p2y) and x <= max(p1x, p2x):
if p1y != p2y:
xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
if p1x == p2x or x <= xinters:
inside = not inside
p1x, p1y = p2x, p2y
return inside
class RegularShape(BaseShape):
'''Starting from center and creating edges around for i.e.:
regular triangles, squares, regular pentagons, up to "circle".
'''
def __init__(self, edges=3, color=None, **kwargs):
super(RegularShape, self).__init__(**kwargs)
if edges < 3:
raise Exception('Not enough edges! (3+ only)')
color = color or [random() for i in range(3)]
rad_edge = (pi * 2) / float(edges)
r_x = self.width / 2.0
r_y = self.height / 2.0
poly = []
vertices = []
for i in range(edges):
# get points within a circle with radius of [r_x, r_y]
x = cos(rad_edge * i) * r_x + self.center_x
y = sin(rad_edge * i) * r_y + self.center_y
poly.extend([x, y])
# add UV layout zeros for Mesh, see Mesh docs
vertices.extend([x, y, 0, 0])
# draw Mesh shape from generated poly points
with self.canvas:
Color(rgba=(color[0], color[1], color[2], 0.6))
self.shape = Mesh(
pos=self.pos,
vertices=vertices,
indices=list(range(edges)),
mode='triangle_fan'
)
self.poly = poly
def on_touch_down(self, touch, *args):
if self.shape_collide(*touch.pos):
touch.grab(self)
class MeshShape(BaseShape):
'''Starting from a custom origin and custom points, draw
a convex Mesh shape with both touch and shape collisions.
.. note::
To get the points, use e.g. Pen tool from your favorite
graphics editor and export it to a human readable format.
'''
def __init__(self, color=None, **kwargs):
super(MeshShape, self).__init__(**kwargs)
color = color or [random() for i in range(3)]
min_x = 10000
min_y = 10000
max_x = 0
max_y = 0
# first point has to be the center of the convex shape's mass,
# that's where the triangle fan starts from
poly = [
50, 50, 0, 0, 100, 0, 100, 100, 0, 100
] if not self.poly else self.poly
# make the polygon smaller to fit 100x100 bounding box
poly = [round(p / 1.5, 4) for p in poly]
poly_len = len(poly)
# create list of vertices & get edges of the polygon
vertices = []
vertices_len = 0
for i in range(0, poly_len, 2):
min_x = poly[i] if poly[i] < min_x else min_x
min_y = poly[i + 1] if poly[i + 1] < min_y else min_y
max_x = poly[i] if poly[i] > max_x else max_x
max_y = poly[i + 1] if poly[i + 1] > max_y else max_y
# add UV layout zeros for Mesh
vertices_len += 4
vertices.extend([poly[i], poly[i + 1], 0, 0])
# get center of poly from edges
poly_center_x, poly_center_y = [
(max_x - min_x) / 2.0,
(max_y - min_y) / 2.0
]
# get distance from the widget's center and push the points to
# the widget's origin, so that min_x and min_y for the poly would
# result in 0 i.e.: points moved as close as possible to [0, 0]
# -> No editor gives poly points moved to the origin directly
dec_x = (self.center_x - poly_center_x) - min_x
dec_y = (self.center_y - poly_center_y) - min_y
# move polygon points to the bounding box (touch)
for i in range(0, poly_len, 2):
poly[i] += dec_x
poly[i + 1] += dec_y
# move mesh points to the bounding box (image)
# has to contain the same points as polygon
for i in range(0, vertices_len, 4):
vertices[i] += dec_x
vertices[i + 1] += dec_y
# draw Mesh shape from generated poly points
with self.canvas:
Color(rgba=(color[0], color[1], color[2], 0.6))
self.shape = Mesh(
pos=self.pos,
vertices=vertices,
indices=list(range(int(poly_len / 2.0))),
mode='triangle_fan'
)
# debug polygon points with Line to see the origin point
# and intersections with the other points
# Line(points=poly)
self.poly = poly
def on_touch_down(self, touch, *args):
if self.shape_collide(*touch.pos):
touch.grab(self)
class Collisions(App):
def __init__(self, **kwargs):
super(Collisions, self).__init__(**kwargs)
# register an event for collision
self.register_event_type('on_collision')
def collision_circles(self, shapes=None, distance=100, debug=False, *args):
'''Simple circle <-> circle collision between the shapes i.e. there's
a simple line between the centers of the two shapes and the collision
is only about measuring distance -> 1+ radii intersections.
'''
# get all combinations from all available shapes
if not hasattr(self, 'combins'):
self.combins = list(combinations(shapes, 2))
for com in self.combins:
x = (com[0].center_x - com[1].center_x) ** 2
y = (com[0].center_y - com[1].center_y) ** 2
if sqrt(x + y) <= distance:
# dispatch a custom event if the objects collide
self.dispatch('on_collision', (com[0], com[1]))
# draw collider only if debugging
if not debug:
return
# add circle collider only if the shape doesn't have one
for shape in shapes:
if shape.debug_collider is not None:
continue
d = distance / 2.0
cx, cy = shape.center
points = [(cx + d * cos(i), cy + d * sin(i)) for i in range(44)]
points = [p for ps in points for p in ps]
with shape.canvas:
Color(rgba=(0, 1, 0, 1))
shape.debug_collider = Point(points=points)
def on_collision(self, pair, *args):
'''Dispatched when objects collide, gives back colliding objects
as a "pair" argument holding their instances.
'''
print('Collision {} x {}'.format(pair[0].name, pair[1].name))
def build(self):
# the environment for all 2D shapes
scene = FloatLayout()
# list of 2D shapes, starting with regular ones
shapes = [
RegularShape(
name='Shape {}'.format(x), edges=x
) for x in range(3, 13)
]
shapes.append(MeshShape(name='DefaultMesh'))
shapes.append(MeshShape(name='Cloud', poly=cloud_poly))
shapes.append(MeshShape(
name='3QuarterCloud',
poly=cloud_poly[:110]
))
# move shapes to some random position
for shape in shapes:
shape.pos = [randint(50, i - 50) for i in Window.size]
scene.add_widget(shape)
# check for simple collisions between the shapes
Clock.schedule_interval(
lambda *t: self.collision_circles(shapes, debug=True), 0.1)
return scene
if __name__ == '__main__':
Collisions().run()