def __init__(self, screen_min, screen_max):
WAVE_HEIGHT = 150
self.screen_bounds = (screen_min + geometry.Vector(0, 150), screen_max)
self.npc_bounds = (screen_min - geometry.Vector(200, -150),
screen_max + geometry.Vector(100, 0))
# Set up actors and sprites
player_sprite = game_assets.SealSprite(game_assets.AssetLoader())
player = actor.PlayerSeal()
# Set bounds
player.bounds = (self.screen_bounds[0], self.screen_bounds[1])
# Set size
player.size = geometry.Vector(player_sprite.rect.width,
player_sprite.rect.height)
player_sprite.set_actor(player)
self.player_sprite_group = pygame.sprite.GroupSingle()
self.player_sprite_group.add(player_sprite)
# Create npc groups
self.fish_sprite_group = pygame.sprite.Group()
self.shark_sprite_group = pygame.sprite.Group()
# Audio
self.chomp_audio = game_assets.ChompAudioLoader().audio
self.brrr_audio = game_assets.BrrrAudioLoader().audio
self.score = 0
def setup(screen):
# Load assets
fish_loader = game_assets.FishLoader()
shark_loader = game_assets.SharkLoader()
background_loader = game_assets.BackgroundLoader()
# Create an actor controller
actor_controller = controller.ActorController(geometry.Vector(0,0),
geometry.Vector(config.ScreenInfo.width, config.ScreenInfo.height))
game_controller = controller.GameController(actor_controller,
background_loader)
# Create a npc creator
creator = controller.NpcCreator(fish_loader, shark_loader, pygame.time.set_timer)
PROCESS_CUSTOM_EVENT = {
config.EVENT_MAPPING["CREATE_NEW_FISH"]: creator.create_fish,
config.EVENT_MAPPING["CREATE_NEW_SHARK"]: creator.create_shark,
}
# Fill in background
screen.blit(background_loader.main_image,
pygame.Rect(0,0,config.ScreenInfo.width,
config.ScreenInfo.height))
return (game_controller, PROCESS_CUSTOM_EVENT)
def plan_triangle(triangle):
'''Prend un triangle ABC, renvoie les coefficients de l'équation cartésienne du triangle sous forme d'un liste'''
AB = geo.Vector(triangle.sommets[0],triangle.sommets[1])
AC = geo.Vector(triangle.sommets[0],triangle.sommets[2])
n = triangle.normal() # n est le vecteur normal à AB et AC
a, b, c = n.x, n.y, n.z
A = triangle.sommets[0] # A appartient au plan donc il doit vérifier l'équation de plan
d = -(a * A.x + b * A.y + c * A.z)
return [a, b, c, d]
def __init__(self):
super().__init__(geometry.State(position=geometry.Vector(100, 200)),
is_player=True)
self.size = geometry.Vector(50, 50)
self.bounciness = 0.4
self.state.acceleration = geometry.Vector(0, -0.05)
self.state.velocity = geometry.Vector(0, 0)
self.delta_velocity = geometry.Vector(0, 0.15)
self.delete = False
def _new_faces(self, angle_step) -> [geometry.Face]:
# be warned, this algorithm will be inaccurate b/c adding to desired values
faces = []
point = geometry.Vector(0, 1, 0).unit_vector(
) # it already is a unit vector, but in case I change it
a = copy.deepcopy(point)
rotate_xy = geometry.rotate_matrix(angle_step, 0, 0)
rotate_yz = geometry.rotate_matrix(0, angle_step, 0)
for part in self.parts:
theta_xy = 0
while theta_xy < REVOLUTION:
theta_yz = 0
while theta_yz < REVOLUTION:
corners = []
for xy_coef, yz_coef in [(0, 0), (1, 0), (1, 1), (0, 1)]:
corner = copy.deepcopy(point)
corner_rotate_xy = geometry.rotate_matrix(
xy_coef * angle_step, 0, 0)
corner_rotate_yz = geometry.rotate_matrix(
0, yz_coef * angle_step, 0)
corner = _matrix_times_a_vector(
corner_rotate_xy, corner)
corner = _matrix_times_a_vector(
corner_rotate_yz, corner)
orig_func_signs, orig_bound_signs = self.get_signs(
part, corner)
print(corner.angle_between_vectors(a))
while True:
corner = corner.plus(
corner.unit_vector().times(MAGNITUDE_STEP))
# assuming no folds, spirals, etc from a single function
try:
func_signs, bound_signs = self.get_signs(
part, corner)
if bound_signs != orig_bound_signs:
# won't add points at bound for given func
break # don't add points past here
if func_signs != orig_func_signs:
corners += [corner]
break # don't add points past here
except ValueError: # not on graph, but further points may be, up until boundary
continue
if len(corners) >= 3:
faces += [geometry.Face(corners)]
point = _matrix_times_a_vector(rotate_yz, point)
theta_yz += angle_step
point = _matrix_times_a_vector(rotate_xy, point)
theta_xy += angle_step
return faces
def point_on_map(pt):
"""Returns the coordinates of point on the map."""
normalized_x_angle = (pt[1] - MAP_BASE_LONGITUDE) % 360
return geometry.Vector(
MAP_WIDTH * normalized_x_angle / 360.0,
MAP_HEIGHT * (0.5 - pt[0] / 180.0),
)
def add_beacon(route_map, pt):
"""Adds a beacon mark to SVG map."""
path = []
for cross_leg in [
geometry.Vector(MAP_CROSS_HALF_LENGTH, MAP_CROSS_HALF_LENGTH),
geometry.Vector(MAP_CROSS_HALF_LENGTH, -MAP_CROSS_HALF_LENGTH),
]:
path.extend(
['M', (pt - cross_leg).svg_form(), (pt + cross_leg).svg_form()])
route_map.add(
route_map.path(
d=path,
fill='none',
stroke='black',
stroke_width='{}px'.format(MAP_CROSS_LINE_WIDTH),
))
def circle_on_drag(self, x, y, dx, dy, buttons, modifiers):
try:
# Radius is the distance between the starting point and current point
self.temp_item.radius = geometry.Vector(x - self.temp_item.x, y -
self.temp_item.y).length
self.temp_item.updateBounds()
self.check_collisions([self.temp_item])
except AttributeError:
pass
def create_fish(self):
fish_sprite = self.fish_loader.new_sprite()
npc_size = geometry.Vector(*fish_sprite.rect.size)
npc_fish = self.create_npc(actor.NpcFish, npc_size)
fish_sprite.set_actor(npc_fish)
events.GameEventsManager.notify_with_event(
events.NewFishEvent(fish_sprite))
def __init__(self):
self._running = True
self._object = object3d.Object3D([object3d.Part(EQUATION, BOUNDARY)], DIVISOR)
self._clock = pygame.time.Clock()
self._angle = 0
self._this_rel = (0, 0)
self._since_last_rel = (0, 0)
self._screen_size = (SCREEN_WIDTH, SCREEN_HEIGHT)
self._center = geometry.Vector(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0)
self._trans_surface = None
def create_shark(self):
shark_sprite = self.shark_loader.new_sprite()
npc_size = geometry.Vector(*shark_sprite.rect.size)
npc = self.create_npc(actor.NpcShark, npc_size)
npc.state.velocity.x = -3.0
shark_sprite.set_actor(npc)
events.GameEventsManager.notify_with_event(
events.NewSharkEvent(shark_sprite))
def main():
ad = addon.Addon('addon.xml')
if ad.IsValid():
cm = costmap.Costmap(ad.LayoutWidth(), ad.LayoutHeight(), ad.Buttons())
#cm.Show()
cm.Save(ad.CostmapImage())
goal = geometry.Vector(geometry.Point(0,
ad.LayoutHeight() / 2),
geometry.DIRECTION_LEFT)
pf = pathfinder.PathFinder(cm, ad.Buttons()[0].StartPoints()[0], goal)
img = cv2.imread(ad.LayoutImage(), cv2.IMREAD_UNCHANGED)
pf.Render(img, 'path1.png')
def format(groups):
"""Formats info about grouped bases in the proper form (returns text)."""
text = []
for loc in sorted(groups):
name = re.sub(r'([^A-Z])([A-Z])', r'\1-\2', loc).upper()
for base in groups[loc]:
pos = map(float, base['RadialPosition'].split(','))
coords = geometry.angles_from_sphere(
geometry.Vector.normalize(
geometry.Vector(pos[0], pos[2], pos[1])))
alt = 100 * int(
(float(base['RadiusOffset']) + GUARANTEED_CLEAR_ALTITUDE) /
100)
text.append("'{}': ({}, {}, {}),".format(
name, coords[0], coords[1], alt))
return '\n'.join(text)
def appartenance_triangle(point, dict_triangles):
""" test d'appartenance du point D au triangle ABC, renvoie l'indice du triangle
il parcourt tous les triangles possibles et essaye s'il appartient ou pas"""
for (indice_triangle, triangle) in dict_triangles.items():
AB = geo.Vector(triangle.sommets[0],triangle.sommets[1])
BC = geo.Vector(triangle.sommets[1],triangle.sommets[2])
CA = geo.Vector(triangle.sommets[2],triangle.sommets[0])
AD = geo.Vector(triangle.sommets[0],point)
BD = geo.Vector(triangle.sommets[1],point)
CD = geo.Vector(triangle.sommets[2],point)
if AB.det_2D(AD) * AD.det_2D(CA) <= 0 and AB.det_2D(BD) * BD.det_2D(BC) <= 0 and CA.det_2D(CD) * CD.det_2D(BC) <= 0:
return indice_triangle
print(point)
print("Le point n'appartient pas au plan")
def appartenance(p):
for k in tri.simplices:
AB = geo.Vector(coord[k[0]], coord[k[1]])
BC = geo.Vector(coord[k[1]], coord[k[2]])
CA = geo.Vector(coord[k[2]], coord[k[0]])
AD = geo.Vector(coord[k[0]], p)
BD = geo.Vector(coord[k[1]], p)
CD = geo.Vector(coord[k[2]], p)
if AD.det_2D(AB) == 0:
if sign(BD.det_2D(BC)) == sign(CD.det_2D(CA)):
return (k)
elif BD.det_2D(BC) == 0:
if sign(AD.det_2D(AB)) == sign(CD.det_2D(CA)):
return (k)
elif CD.det_2D(CA) == 0:
if sign(BD.det_2D(BC)) == sign(AD.det_2D(AB)):
return (k)
elif sign(BD.det_2D(BC)) == sign(CD.det_2D(CA)) == sign(AD.det_2D(AB)):
return (k)
return ("ce point n'appartient a aucun triangle")
import collections
import math
import matrices
import algebra
import copy
Part = collections.namedtuple('Part', ['equ', 'bound'])
Boundary = collections.namedtuple(
'Boundary', ['eqns']) # list of equations, function can't pass
SetOfPlanes = collections.namedtuple('SetOfPlanes', ['x', 'y'])
PointsOfEquation = collections.namedtuple('PointsOfEquation',
['expr', 'planes'])
MAGNITUDE_STEP = 10
REVOLUTION = 2 * math.pi
ZERO_VECTOR = geometry.Vector(0, 0, 0)
class NotAVectorError(Exception):
pass
class IntersectionsOfPlane:
def __init__(self, value, intersections):
self.value = value
self.intersections = intersections
def vector_to_matrix(vector):
return matrices.Matrix([[vector.x], [vector.y], [vector.z]])
def __init__(self, state=geometry.State(), is_player=False):
self.state = state
self.bounciness = 0
self.is_player = is_player
self.color = "white"
self.bmin = self.bmax = geometry.Vector(0, 0)
class Actor:
MAX_VELOCITY = geometry.Vector(640.0, 360.0)
def __init__(self, state=geometry.State(), is_player=False):
self.state = state
self.bounciness = 0
self.is_player = is_player
self.color = "white"
self.bmin = self.bmax = geometry.Vector(0, 0)
# Define properties
@property
def size(self):
return self._size
@size.setter
def size(self, new_size):
self._size = new_size
@property
def bounds(self):
return (self.bmin, self.bmax)
@bounds.setter
def bounds(self, bounds_tuple):
self.bmin = bounds_tuple[0]
self.bmax = bounds_tuple[1]
@property
def sprite(self):
return self._sprite
@sprite.setter
def sprite(self, sprite):
self._sprite = sprite
@property
def bounciness(self):
return self._bounciness
@bounciness.setter
def bounciness(self, bounciness):
self._bounciness = bounciness
@property
def state(self):
return self._state
# TODO update state to output individual pos, vel, and accel
@state.setter
def state(self, state):
""" State position is clamped to the actor bounds """
self._state = state
# Methods
def update(self):
self.state.velocity += self.state.acceleration
new_position = self.state.position + self.state.velocity
# Correct bounds for actor size
bounds_max = self.bmax - self.size
# Bounciness behaviour
if new_position.x > bounds_max.x or new_position.x < self.bmin.x:
self.state.velocity.x = -self.state.velocity.x * self.bounciness
if new_position.y > bounds_max.y or new_position.y < self.bmin.y:
self.state.velocity.y = -self.state.velocity.y * self.bounciness
# Bound the position
new_position.x = max(min(new_position.x, bounds_max.x), self.bmin.x)
new_position.y = max(min(new_position.y, bounds_max.y), self.bmin.y)
self.state.position = new_position
def add_velocity(self, velocity):
new_velocity = self.state.velocity + velocity
self.state.velocity.x = min(new_velocity.x, self.MAX_VELOCITY.x)
self.state.velocity.y = min(new_velocity.y, self.MAX_VELOCITY.y)
def bounding_box(self):
return geometry.Rectangle(self.state.position, self.size)
def draw(self):
return geometry.Rectangle(self.state.position, self.size)
if __name__ == '__main__':
import geometry
v1 = geometry.Vector(4, 3)
print 'v1 =', v1
print 'Type of v1 =', type(v1)
print 'x-component of v1 =', v1.get_x()
print 'y-component of v1 =', v1.get_y()
print 'Magnitude of v1 =', v1.magnitude()
print 'Normalized v1 =', v1.normalize()
v2 = geometry.Vector()
print 'v2 =', v2
v2.set_x(3)
v2.set_y(4)
print 'v2 =', v2
print 'Type of v2 =', type(v2)
print 'x-component of v2 =', v2.get_x()
print 'y-component of v2 =', v2.get_y()
print 'Magnitude of v2 =', v2.magnitude()
print 'Length of v2 =', len(v2)
print '|v1| = ', abs(v1)
print 'Normalized v2 =', v2.normalize()
v3 = geometry.Vector(3.0, 4.0)
print 'v3 = ', v3
print 'v1 == v2 =', v1 == v2
print 'v1 == v1 =', v1 == v1
print 'v1 == v3 = ', v1 == v3
print 'v2 == v3 = ', v2 == v3
self.number = number
self.isHuman = isHuman
self.alive = True
self.lines = []
class Death:
def __init__(self, victim, killer, time, location):
self.victim = victim
self.killer = killer
self.time = time
self.location = location
initialPlayers = [
Player(geometry.Vector(120, 120), setup.colors[0], geometry.right, 1,
True),
Player(geometry.Vector(900, 420), setup.colors[1], geometry.left, 3,
False),
Player(geometry.Vector(900, 120), setup.colors[2], geometry.down, 2,
False),
Player(geometry.Vector(120, 420), setup.colors[3], geometry.up, 4, False),
]
for i in initialPlayers:
i.pos.x //= setup.blockSize
i.pos.y //= setup.blockSize
keyDirections = [[pygame.K_w, pygame.K_a, pygame.K_s, pygame.K_d],
[pygame.K_UP, pygame.K_LEFT, pygame.K_DOWN, pygame.K_RIGHT],
[pygame.K_y, pygame.K_g, pygame.K_h, pygame.K_j],
def drag_items(self, x, y, dx, dy, buttons, modifiers):
for item in self.dragged_items:
item.moveBy(geometry.Vector(dx, dy))
self.check_collisions(self.dragged_items)
BLUE = 0, 0, 255
YELLOW = 255, 255, 0
MAGENTA = 255, 0, 255
CYAN = 0, 255, 255
ORANGE = 255, 122, 0
BACKGROUND_COLOR = ORANGE
IS_ORTHOGONAL = False
MIN_DISTANCE = -50
CHANGE_DIST = 50
COLORING = True
SHADING = False
ROTATE_STEP = PI / 16
LIGHT_VECTOR = geometry.Vector(0, 0, 1)
DIVISOR = 40
BOUND = 600
RADIUS = 200
SCALE = 100
EQUATION = \
algebra.Equation(f'x^2+z^2={SCALE}*y')
# algebra.Equation(f'x^2-y^2+z^2={SCALE}')
# [f'math.sqrt({SCALE} - x ** 2 + y ** 2)',
# f'-math.sqrt({SCALE} - x ** 2 + y ** 2)']
# SCALE > 0: 1 sheet hyperboloid (finger trap)
# SCALE = 0: cone(s)
# SCALE < 0: 2 sheet hyperboloid (2 bowls)
# scale and/or divisor need to be big for this one
def _resize_surface(self) -> None:
pygame.display.set_mode(self._screen_size, pygame.RESIZABLE)
self._center = geometry.Vector(self._screen_size[0] / 2, self._screen_size[1] / 2, 0)
def matrix_to_vector(matrix: matrices.Matrix):
if matrix.rows == 3 and matrix.cols == 1:
return geometry.Vector(matrix.matrix[0][0], matrix.matrix[1][0],
matrix.matrix[2][0])
else:
raise NotAVectorError()
def vitesse(p1, p2):
"""Défini la vitesse avec un pas de temps de 5s et de 2 points"""
velocity = geometry.Vector(p1, p2)
return velocity.prod_linear(1 / traffic.STEP)
