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)