def main(): pygame.init() pygame.display.set_caption("Mines!") screen = pygame.display.set_mode(tuple(settings.SCREEN_SIZE)) running = True ended = False board = logic.Board(settings.MINE_COUNT) draw_board(board, screen) while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.MOUSEBUTTONUP: if event.button == 1: if ended: board = logic.Board(settings.MINE_COUNT) ended = False else: left_click(board, vec(event.pos)) elif event.button == 3: right_click(board, vec(event.pos)) draw_board(board, screen) status = board.get_status() if status != 'Ok': ended = True draw_text(status, screen)
def ball(x, y, r): b = SimpleNamespace() b.forces = vec.vec(0, 0) b.speed = vec.vec(0, 0) b.pos = vec.vec(x, y) b.radius = r return b
def touch(self, sprite, oldsprite): # takes a sprite, calculates collision with it, returns it bundled in a tuple with a tuple of the sides the sprite touched relspritepos = vec(BLKX * (sprite.blk.x - self.blk.x) + sprite.pos.x, BLKY * (sprite.blk.y - self.blk.y) + sprite.pos.y) # print 'NOW COLLISION:\nrelspritepos =',relspritepos reloldspritepos = vec( BLKX * (oldsprite.blk.x - self.blk.x) + oldsprite.pos.x, BLKY * (sprite.blk.y - self.blk.y) + oldsprite.pos.y) # print 'reloldspritepos =',reloldspritepos spritebottom = relspritepos.y # print 'spritebottom =',spritebottom spriteleft = relspritepos.x # print 'spriteleft =',spriteleft spriteright = relspritepos.x + sprite.dim.x - 1. # print 'spriteright =',spriteright oldspritebottom = reloldspritepos.y # print 'oldspritebottom =',oldspritebottom oldspriteleft = reloldspritepos.x # print 'oldspriteleft =',oldspriteleft oldspriteright = reloldspritepos.x + oldsprite.dim.x - 1. # print 'oldspriteright =',oldspriteright,'\nTILE STATE:\nself.top =',self.top,'\nself.bottom =',self.bottom,'\nself.left =',self.left,'\nself.right =',self.right sides = [ ] # sides from which the tile was impacted upon; returned as part of a tuple with the sprite itself if (spritebottom <= self.top + 1 and self.top + 1 <= oldspritebottom ) and (spriteright >= self.left and self.right >= spriteleft): sprite.vel.y = 0 sprite.pos.y = self.top + 1. sprite.blk = self.blk if not sprite.walks: sprite.F.x += sprite.F.y * self.fric sides.append('top') return (sides, sprite)
def touch(self,sprite,oldsprite): # takes a sprite, calculates collision with it, returns it bundled in a tuple with a tuple of the sides the sprite touched relspritepos = vec(BLKX*(sprite.blk.x-self.blk.x)+sprite.pos.x,BLKY*(sprite.blk.y-self.blk.y)+sprite.pos.y) # print 'NOW COLLISION:\nrelspritepos =',relspritepos reloldspritepos = vec(BLKX*(oldsprite.blk.x-self.blk.x)+oldsprite.pos.x,BLKY*(sprite.blk.y-self.blk.y)+oldsprite.pos.y) # print 'reloldspritepos =',reloldspritepos spritebottom = relspritepos.y # print 'spritebottom =',spritebottom spriteleft = relspritepos.x # print 'spriteleft =',spriteleft spriteright = relspritepos.x+sprite.dim.x-1. # print 'spriteright =',spriteright oldspritebottom = reloldspritepos.y # print 'oldspritebottom =',oldspritebottom oldspriteleft = reloldspritepos.x # print 'oldspriteleft =',oldspriteleft oldspriteright = reloldspritepos.x+oldsprite.dim.x-1. # print 'oldspriteright =',oldspriteright,'\nTILE STATE:\nself.top =',self.top,'\nself.bottom =',self.bottom,'\nself.left =',self.left,'\nself.right =',self.right sides = [] # sides from which the tile was impacted upon; returned as part of a tuple with the sprite itself if (spritebottom <= self.top+1 and self.top+1 <= oldspritebottom) and (spriteright >= self.left and self.right >= spriteleft): sprite.vel.y = 0 sprite.pos.y = self.top+1. sprite.blk = self.blk if not sprite.walks: sprite.F.x += sprite.F.y*self.fric sides.append('top') return (sides,sprite)
def attack(self, entity): """Try to attack other players in range""" # Fetch components body = self.engine.entities.bodies.get(entity) character = self.engine.entities.characters.get(entity) if not body or not character: return # Find players in range for other_entity in self.engine.entities.players: if entity == other_entity: continue # Fetch components other_body = self.engine.entities.bodies.get(other_entity) other_character = self.engine.entities.characters.get(other_entity) other_animation = self.engine.entities.animations.get(other_entity) if not other_body or not other_character: continue # Check if other player near enough if (vec(other_body) - vec(body)).length() > character.attack_range: continue # Try to attack, succeeds if cool down has finished if character.attack(other_character): other_body.bounce_from(body) if other_animation: other_animation.play('hit')
def generate(self, start): """Generate a new game board""" mines = self.mines while mines > 0: # Choose a random location mine_location = vec(randint(0, BOARD_SIZE.x - 1), randint(0, BOARD_SIZE.y - 1)) mine_cell = self.get(mine_location) # If there is a mine - try again if mine_cell.bomb: continue # If it is near the starting position - try again if mine_location.x - start.x <= 1 and start.x - mine_location.x <= 1: if mine_location.y - start.y <= 1 and start.y - mine_location.y <= 1: continue # Place a bomb mine_cell.bomb = True mines -= 1 # Increment all adjacent cells for x in range(-1, 2): for y in range(-1, 2): self.increment(mine_location + vec(x, y))
def AtoB(self, pos_a): """ A -- position relative to user interface window B -- position on game map """ return (vec(pos_a) - vec(self.pos)) / self.get_zoom() + self.window_pos
def rblit_map(self, to, render_tab, window_pos, window_end, zoom): """ scale map visible through window to dim and blit window_dim = dim * scale """ terr = self.game.map # total area cmax_ij = terr.size() cmin_ij = 0,0 # window covered area vmin_ij = map(int, window_pos / FIELD_DIM) vmax_ij = map(int, window_end / FIELD_DIM + vec(1,1)) min_ij = max(vmin_ij[0], cmin_ij[0]), max(vmin_ij[1], cmin_ij[1]) max_ij = min(vmax_ij[0], cmax_ij[0]), min(vmax_ij[1], cmax_ij[1]) for j in range(min_ij[1], max_ij[1]): for i in range(min_ij[0], max_ij[0]): t = terr.get(i,j) a = self.BtoA(vec(i,j) * FIELD_DIM) render_tab[t].render(scale = zoom).rblit(to, a)
def __init__(self, **kwargs): """ Proxy dodajace funkcjonalnosc content (rblit) dzieki czemu mozna wstawic do CBoxa game -- obiekt Game ktory bedzie reprezentowany """ self.game = kwargs.pop('game') self.env = kwargs.pop('env') self.ctrl = kwargs.pop('ctrl') super(GameBox, self).__init__(**kwargs) self.window_pos = vec(0, 0) self.window_dim = None #(20,20) #self.dim self._rscale = 1.0 self._dscale = 1.0 self.map_dim = vec(self.game.map.size()) * 24 self.selected = None # warstwa sladow #self.tracks self.on(self.ctrl, et.MOUSEBUTTONDOWN, self.onclick)
def benchmark(integrator): m1 = mass.mass(m_SUN, vec(0, 0, 0), vec(0, 0, 0)) m2 = mass.mass(m_SUN, vec(1, 0, 0), vec(0, 0, 0)) def test(): integrator([m1, m2]) import timeit print(timeit.timeit(test, number=10000) / 10000)
def menuinit(): global u, f, p, zoom, beta u = vec(0, 0, 1) f = vec(1, 0, 0) p = f beta = 0 zoom = 100
def compute_p_inv_A(b, z0): (z, info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-2) if info > 0: print('cgs convergence to tolerance not achieved') elif info < 0: print('cgs gets illegal input or breakdown') z = np.reshape(z, x_shape, order='F') return z
def enemy_move(self, enemy): directions = list( filter(lambda xy: self.check_move(enemy, xy), [vec(0, -1), vec(0, 1), vec(-1, 0), vec(1, 0)])) if directions: direction = choice(directions) self.try_move(enemy, direction)
def __init__(self): self.entities = Entities() self.events = Events() self.running = True self.width = 640 self.height = 480 self.level = vec() self.scroll = vec()
def compute_init(b, z0): (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2) if info > 0: print 'cgs convergence to tolerance not achieved' elif info <0: print 'cgs gets illegal input or breakdown' z = np.reshape(z, x_shape, order='F') return z
def __init__(self, height, diameter, detail=12): d = 2 * math.pi / detail r = diameter * 0.5 vs = [(math.sin(i * d) * r, math.cos(i * d) * r) for i in range(detail)] self.verts = [vec(v[0], height * 0.5, v[1]) for v in vs] self.verts += [vec(v[0], height * -0.5, v[1]) for v in vs] self.polys = [(i, i + detail, (i+1) % detail + detail, (i+1) % detail) for i in range(detail)] self.polys.append(range(detail)) self.polys.append(range(detail, detail*2)[::-1])
def __init__( self, element: DisplayElement, mouse_rect: Rectangle = Rectangle(vec(0, 0), vec(0, 0)), signals: Dict[str, Callable[[vec, int, Dict[str, Any]], Any]] = {} ) -> None: self.element = element self.mouse_rect = mouse_rect self.signals = signals.copy()
def init(): global u, f, p, zoom, target, beta beta = 0.2 u = vec(-math.cos(beta), 0, math.sin(beta)) f = vec(math.sin(beta), 0, math.cos(beta)) p = vec(0, 0, 1) zoom = 80 target = None
def main(): m1 = mass.mass(m_SUN, vec(0, 0, 0), vec(0, 0, 0)) m2 = mass.mass(m_EARTH, vec(r_EARTH, 0, 0), vec(0, 107300, 0)) initial_radius = m1.q.dist(m2.q) for masses in run_time([m1, m2], 0.01, explicit, iters=100000): pass final_radius = m1.q.dist(m2.q) print('delta_distance = %f (%.3f%%)' % ( final_radius - initial_radius, (final_radius - initial_radius) * 100 / initial_radius))
def __init__(self, rect): super().__init__(rect.left, rect.top, rect.width, rect.height) self.real = vec(self.x, self.y) self.standing = False self.ontops = set() self.underneaths = set() # Physics properties self.velocity = vec() self.dumping = vec(0.01) self.friction = vec(0.03, 0) self.restitution = 0.2 self.mass = 1.0
def initstone(): global stone A, B, C, D = vec(1,1,1).norm(), vec(-1,1,-1).norm(), vec(-1,-1,1).norm(), vec(1,-1,-1).norm() a, b, c, d = A.times(-1), B.times(-1), C.times(-1), D.times(-1) def flatten(*args): for arg in args: for x in arg: yield x vertexdata = list(flatten(A,B,C, A,C,D, A,D,B, C,B,D, a,c,b, a,d,c, a,b,d, c,d,b)) normaldata = list(flatten(d,d,d, b,b,b, c,c,c, a,a,a, D,D,D, B,B,B, C,C,C, A,A,A)) stone = makedrawable(GL_TRIANGLES, vertexdata, None, normaldata)
def rblit(self, to): render_tab = self.env.render_tab zoom = self.get_zoom() to.set_clip(Rect(self.pos, self.dim)) self.rblit_map(to, render_tab = render_tab, window_pos = self.window_pos, window_end = self.window_end, zoom = zoom, ) sgame = sorted(self.game, lambda a,b: cmp(a.z, b.z)) for x in sgame: if x.__class__ in self.env.render_tab: ni = self.env.render_tab[x.__class__].render(scale = zoom) ni.rblit(to, self.BtoA(x.pos)) if self.selected: to.draw_rect(self.BtoA(self.selected.pos), self.selected.dim * zoom, (0.5,0.5,0.5), 1) if self.border: to.draw_rect(vec(self.pos), self.dim, (0.5,0.5,0.5), 1) # draw ghost under mouse cursor if any mpos = vec(pygame.mouse.get_pos()) o = self.env.order a = o.action p = o.get_next_param_type() if a == 'move' and p == 'point': ghost = render_tab['move'].render(scale = zoom) elif a == 'build' and p == 'point': struct = o.args[1] if struct in render_tab: ghost = render_tab[struct].render(scale = zoom) else: ghost = None if ghost: ghost.rblit(to, mpos - ghost.dim / 2.0) to.set_clip(None)
def raycast(self): start = (self.pos.x, self.pos.y) end_front = vec(start[0] + self.dir.x * 500, start[1] + self.dir.y * 500) x_rotated = self.dir.rotate(-3.1415 / 2).scale(500) end_front_left = vec(start[0] + x_rotated.x, start[1] + x_rotated.y) x_rotated = self.dir.rotate(3.1415 / 2).scale(500) end_front_right = vec(start[0] + x_rotated.x, start[1] + x_rotated.y) end_back = vec(start[0] - self.dir.x * 500, start[1] - self.dir.y * 500) x_rotated = self.dir.rotate(3.1415 / 4).scale(500) end_back_left = vec(start[0] - x_rotated.x, start[1] - x_rotated.y) x_rotated = self.dir.rotate(-3.1415 / 4).scale(500) end_back_right = vec(start[0] - x_rotated.x, start[1] - x_rotated.y) x_rotated = self.dir.rotate(3.1415 / 4).scale(500) r1 = vec(start[0] + x_rotated.x, start[1] + x_rotated.y) x_rotated = self.dir.rotate(-3.1415 / 4).scale(500) r2 = vec(start[0] + x_rotated.x, start[1] + x_rotated.y) self.rays = [ end_front, end_front_left, end_front_right, end_back, end_back_left, end_back_right, r1, r2 ]
def constraint_window(self): map_dim = vec(self.map_dim) * self.get_zoom() if self.window_pos[1] < 0: self.window_pos = vec(self.window_pos[0], 0) if self.window_pos[1] + self.window_dim[1] > map_dim[1]: self.window_pos = vec(self.window_pos[0], map_dim[1] - self.window_dim[1]) if self.window_pos[0] < 0: self.window_pos = vec(0, self.window_pos[1]) if self.window_pos[0] + self.window_dim[0] > map_dim[0]: self.window_pos = vec(map_dim[0] - self.window_dim[0], self.window_pos[1])
def update(self, dt): SPEED = 20.0 keys = pygame.key.get_pressed() map_dim = vec(self.map_dim) * self.get_zoom() # pygame.VIDEORESIZE vert = int(keys[pygame.K_s] or keys[pygame.K_DOWN]) - int(keys[pygame.K_w] or keys[pygame.K_UP]) hori = int(keys[pygame.K_d] or keys[pygame.K_RIGHT]) - int(keys[pygame.K_a] or keys[pygame.K_LEFT]) self.move_window(vec(hori, vert) * SPEED)
def locomotion(self): self.lrF = 0 # added momentum from pressing left and right: see below lkey, rkey = pygame.key.get_pressed()[K_LEFT], pygame.key.get_pressed( )[K_RIGHT] if not (lkey or rkey): self.lrCounter = vec(-1, -1) self.lastPressed = None elif lkey and not rkey: if 0 <= self.lrCounter.x and self.lrCounter.x < 20: self.F.x += -0.05 * (20 - sqrt(400 - (self.lrCounter.x - 20)**2)) if not self.flipped: self.img = pygame.transform.flip(self.img, True, False) self.flipped = True self.lastPressed = K_LEFT self.lrCounter.x += 1 self.lrCounter.y = 0 elif not lkey and rkey: if 0 <= self.lrCounter.y and self.lrCounter.y < 20: self.F.x += 0.05 * (20 - sqrt(400 - (self.lrCounter.y - 20)**2)) if self.flipped: self.img = pygame.transform.flip(self.img, True, False) self.flipped = False self.lastPressed = K_RIGHT self.lrCounter.y += 1 self.lrCounter.x = 0 elif lkey and rkey: if self.lastPressed == K_LEFT: try: self.F.x += 0.07 * (20 - sqrt(400 - (self.lrCounter.y - 20)**2)) except ValueError: pass if self.flipped: self.img = pygame.transform.flip(self.img, True, False) self.flipped = False elif self.lastPressed == K_RIGHT: try: self.F.x += -0.07 * (20 - sqrt(400 - (self.lrCounter.x - 20)**2)) except ValueError: pass if not self.flipped: self.img = pygame.transform.flip(self.img, True, False) self.flipped = True self.lrCounter += vec(1, 1) if pygame.key.get_pressed()[K_UP] and self.supported: self.vel.y += 6. self.supported = False
def moveAgain(self,sprite): # takes a sprite for the second time in the main loop and moves it again, accounting for # the fact that it's already moved the sprite once this frame, and then returns the sprite sprite.pos += sprite.secondF/sprite.m if not (0 <= sprite.pos.x and sprite.pos.x < BLKX): offset = sprite.pos.x//BLKX sprite.blk.x += offset sprite.pos.x -= offset*BLKX if not (0 <= sprite.pos.y and sprite.pos.y < BLKY): offset = sprite.pos.y//BLKY sprite.blk.y += offset sprite.pos.y -= offset*BLKY sprite.F = vec(0,0) sprite.secondF = vec(0,0) return sprite
def update(self, time_dif): self.ang_y += (Stupid.key_state(K_RIGHT) - Stupid.key_state(K_LEFT)) * time_dif self.ang_x += (Stupid.key_state(K_DOWN) - Stupid.key_state(K_UP)) * time_dif x = Stupid.key_state(K_d) - Stupid.key_state(K_a) y = Stupid.key_state(K_SPACE) - Stupid.key_state(K_LSHIFT) z = Stupid.key_state(K_s) - Stupid.key_state(K_w) cy = math.cos(self.ang_y) sy = math.sin(self.ang_y) cx = math.cos(self.ang_x) sx = math.sin(self.ang_x) move = vec() move.y = y * cx + z * sx move.x = x * cy - z * sy * cx + sy * sx * y move.z = x * sy + z * cy * cx - cy * sx * y if not Stupid.key_state(K_RCTRL): self.pos += time_dif * move * 5 else: self.stupid.candle.pos += time_dif * move * 5 # frame rate self.frame += 1 t = get_time() if t - self.time > 2: self.fps = self.frame / (t - self.time) self.time = t self.frame = 0
def apply_gas_force(*args): dtime = it.mech_age() - blast.starting_time press = pressure(dtime) magnitude = press * blast.barea for ball in blast.load_balls: direction = (ball.pos() * vec((1, 1, 0))).norm() ball.set_force_app(direction * magnitude)
def calc_triangles(self): # triangulation works only for convex polygons atm triangles = [] for f in [[vec(*self.vertices[v[0] - 1]) for v in face] for face in self.faces]: a = f[0] for b, c in zip(f[1:], f[2:]): triangles.append([a, b, c]) return triangles
def prepare_edges(self): class Edge: pass faces = [[x[0] for x in face] for face in self.faces] verts = [vec(*vert) for vert in self.vertices] edge_dict = {} self.edges = [] for face in faces: a, b, c = [verts[v - 1] for v in face[:3]] ab = b - a ac = c - a n = ab.cross(ac).normalize() for i, j in zip(face, face[1:]+[face[0]]): edge_dict[(i, j)] = n for (i, j), n in edge_dict.iteritems(): if i > j: continue try: edge = Edge() edge.a = verts[i - 1] edge.b = verts[j - 1] edge.n1 = n edge.n2 = edge_dict[(j, i)] self.edges.append(edge) except: pass
def addradcomp(vdata, cdata, ndata, ps, colors, edges=None, m=12): n = len(ps) - 1 pnorms = [] for k in range(n): r0, z0 = ps[k] r1, z1 = ps[k+1] pnorms.append(vec(z1 - z0, 0, -(r1 - r0)).norm()) if edges: bnorms, tnorms = [pnorms[0]], [] for k, sharp in enumerate(edges): if sharp: bnorms.append(pnorms[k+1]) tnorms.append(pnorms[k]) else: norm = pnorms[k].plus(pnorms[k+1]).norm() bnorms.append(norm) tnorms.append(norm) tnorms.append(pnorms[-1]) else: bnorms = tnorms = pnorms for k in range(n): r0, z0 = ps[k] r1, z1 = ps[k+1] nr0, _, nz0 = bnorms[k] nr1, _, nz1 = tnorms[k] for j in range(m): A0, A1 = math.tau * j / m, math.tau * (j+1) / m S0, C0, S1, C1 = math.sin(A0), math.cos(A0), math.sin(A1), math.cos(A1) vdata.extend([r0*S0, r0*C0, z0, r1*S0, r1*C0, z1, r1*S1, r1*C1, z1, r0*S1, r0*C1, z0]) ndata.extend([nr0*S0, nr0*C0, nz0, nr1*S0, nr1*C0, nz1, nr1*S1, nr1*C1, nz1, nr0*S1, nr0*C1, nz0]) if len(colors) > n: c = colors[k] + colors[k+1] + colors[k+1] + colors[k] cdata.extend(c * m) else: cdata.extend(colors[k % len(colors)] * (4 * m))
def moveAgain(self,sprite): # takes a sprite for the second time in the main loop and moves it again, accounting for # the fact that it's already moved the sprite once this frame, and then returns the sprite invLorentz = sqrt(1.-(sprite.vel/self.c)**2) # the inverse of the Lorentz factor sprite.pos += sprite.secondF*invLorentz/sprite.m if not (0 <= sprite.pos.x and sprite.pos.x < BLKX): offset = sprite.pos.x//BLKX sprite.blk.x += offset sprite.pos.x -= offset*BLKX if not (0 <= sprite.pos.y and sprite.pos.y < BLKY): offset = sprite.pos.y//BLKY sprite.blk.y += offset sprite.pos.y -= offset*BLKY sprite.F = vec(0,0) sprite.secondF = vec(0,0) return sprite
def draw_board(board, screen): for x, y, current_cell in board: pos = (vec(x, y) * settings.BLOCK_SIZE) draw_cell(current_cell, screen, tuple(pos)) pygame.display.flip()
def make_wheel_scrool(self): if self._wheel_scrool: cpos = vec(pygame.mouse.get_pos()) delta = self._wheel_scrool_mpos - cpos self._wheel_scrool_mpos = cpos self.gamebox.move_window(delta)
def select(self, x): self.target = x if isinstance(x, MobileAutomat): # icon action addargs ICON = 0 ACTION = 1 ADDARG = 2 orders = [ ('move', 'move'), ('stop', 'stop'), ] if isinstance(x, Manip): orders.extend([ (CoalMine, 'build', CoalMine), (MetalMine, 'build', MetalMine), (Generator, 'build', Generator), (Solar, 'build', Solar), (MGPost, 'build', MGPost), (ControlPost, 'build', ControlPost), (Factory, 'build', Factory), #('build', Mutant), (Recycler, 'build', Recycler), (GreenHouse, 'build', GreenHouse), ]) self.cmdbox.clear() size = self.cmdbox.dim[0] / self.cmdbox.cols for o in orders: cb = CBox( content=self.render(o[ICON], dim = vec(size,size)), dim = lambda s: s.content.dim, border = 1, ) cb.on( self.ctrl, et.MOUSEBUTTONDOWN, partial( self.h_unit_order, cb, o[ACTION], addargs=([o[ADDARG]] if len(o) > 2 else None) ), ) self.cmdbox.add(cb) self.cmdbox.refresh() else: self.cmdbox.clear()
def locomotion(self): self.lrF = 0 # added momentum from pressing left and right: see below lkey,rkey = pygame.key.get_pressed()[K_LEFT],pygame.key.get_pressed()[K_RIGHT] if not (lkey or rkey): self.lrCounter = vec(-1,-1) self.lastPressed = None elif lkey and not rkey: if 0 <= self.lrCounter.x and self.lrCounter.x < 20: self.F.x += -0.05*(20-sqrt(400-(self.lrCounter.x-20)**2)) if not self.flipped: self.img = pygame.transform.flip(self.img,True,False) self.flipped = True self.lastPressed = K_LEFT self.lrCounter.x += 1 self.lrCounter.y = 0 elif not lkey and rkey: if 0 <= self.lrCounter.y and self.lrCounter.y < 20: self.F.x += 0.05*(20-sqrt(400-(self.lrCounter.y-20)**2)) if self.flipped: self.img = pygame.transform.flip(self.img,True,False) self.flipped = False self.lastPressed = K_RIGHT self.lrCounter.y += 1 self.lrCounter.x = 0 elif lkey and rkey: if self.lastPressed == K_LEFT: try: self.F.x += 0.07*(20-sqrt(400-(self.lrCounter.y-20)**2)) except ValueError: pass if self.flipped: self.img = pygame.transform.flip(self.img,True,False) self.flipped = False elif self.lastPressed == K_RIGHT: try: self.F.x += -0.07*(20-sqrt(400-(self.lrCounter.x-20)**2)) except ValueError: pass if not self.flipped: self.img = pygame.transform.flip(self.img,True,False) self.flipped = True self.lrCounter += vec(1,1) if pygame.key.get_pressed()[K_UP] and self.supported: self.vel.y += 6. self.supported = False
def _update_zoom(self, _rscale): # discrette zoom such that field_dim is int _dscale = int(_rscale * FIELD_DIM) / float(FIELD_DIM) # window_dis window_dim = vec(self.dim) / _dscale # window pos such that map point under mouse do not move rmpos = vec(pygame.mouse.get_pos()) - vec(self.pos) window_pos = self.window_pos + rmpos/self._dscale - rmpos/_dscale # set self._rscale = _rscale self._dscale = _dscale self.window_dim = window_dim self.window_pos = window_pos self.constraint_window()
def update_sub(self, time_dif): d = vec( Stupid.key_state(K_h) - Stupid.key_state(K_f), Stupid.key_state(K_r) - Stupid.key_state(K_z), Stupid.key_state(K_g) - Stupid.key_state(K_t), ) * time_dif * 5 self.q = (self.q + Stupid.key_state(K_c, True)) % 3 [self.eye, self.target, self.up][self.q] += d
def __init__(self): Entity.__init__(self) b = shit.Brick(1, 1, 1) self.cubes = b.gen_list(), b.scale(-1, -1, -1).gen_list() self.orb = shit.Orb(0.1).gen_list() self.p = vec(0, 0, -0.5) self.bfc = False self.inverse = False
def __init__(self, pos, dimensions): self.blk = vec(0, 0) # world block the tile is in self.pos = pos # the x and y position of the tile relative to the block's bottom left and the tile's bottom left self.dim = dimensions # the dimensions of the block as a vector self.top = self.pos.y + self.dim.y - 1 # the y value of the top of the tile self.bottom = self.pos.y # the y value of the bottom of the tile self.left = self.pos.x # the x value of the left side of the tile self.right = self.pos.x + self.dim.x - 1 # the x value of the right side of the tile self.fric = -0.02 # the proportionality of the force exerted on the tile vs the force of friction that the tile exerts in return
def __init__(self,pos,dimensions): self.blk = vec(0,0) # world block the tile is in self.pos = pos # the x and y position of the tile relative to the block's bottom left and the tile's bottom left self.dim = dimensions # the dimensions of the block as a vector self.top = self.pos.y+self.dim.y-1 # the y value of the top of the tile self.bottom = self.pos.y # the y value of the bottom of the tile self.left = self.pos.x # the x value of the left side of the tile self.right = self.pos.x+self.dim.x-1 # the x value of the right side of the tile self.fric = -0.02 # the proportionality of the force exerted on the tile vs the force of friction that the tile exerts in return
def __init__(self) -> None: self.game = Game() messages.on_log += self.on_log blt.open() self.root = DisplayElement.DisplayDict(vec(0, 0)) half_width = blt.state(blt.TK_WIDTH) // 2 half_height = blt.state(blt.TK_HEIGHT) // 2 half_window = vec(half_width, blt.state(blt.TK_HEIGHT)) quarter_window = vec(half_width, half_height) event_log = DisplayElement.PrintArgs( text='', xy=vec(0, 0), bbox=half_window, align_v=DisplayElement.TextAlignmentV.Bottom) self.root.elements['events'] = DisplayElement.Clickable( event_log, Rectangle(vec(0, 0), half_window)) hta_origin = vec(half_width, 0) hta_display = DisplayElement.DisplayList(hta_origin) self.root.elements[self.game.hta] = DisplayElement.Clickable( hta_display, Rectangle(hta_origin, quarter_window)) self.on_tableau_altered(self.game.hta) htb_origin = quarter_window htb_display = DisplayElement.DisplayList(htb_origin) self.root.elements[self.game.htb] = DisplayElement.Clickable( htb_display, Rectangle(htb_origin, quarter_window)) self.on_tableau_altered(self.game.htb)
def spawn(self): spawn_rate = 5 - self.calculate_score() spawn_count = 0 while spawn_rate <= 0: spawn_rate += 10 spawn_count += 1 if randint(1, 10) >= spawn_rate: spawn_count += 1 free_spaces = [ vec(*xy) for xy in product(range(self.size.x), range(self.size.y)) if self.at_edge(vec( *xy)) and self.get_grid_item(self.occupants, vec(*xy)) is None ] for i in range(spawn_count): if len(free_spaces) == 0: break xy = choice(free_spaces) free_spaces.remove(xy) spawnee = Actor() spawnee.position = xy self.place_actor(spawnee) self.enemies.append(spawnee)
def draw_text(text, screen): """Draws given text in the middle of """ font = pygame.font.Font(None, settings.FONT_SIZE) text = font.render(text, 1, settings.TEXT_COLOR) text_position = settings.SCREEN_SIZE // 2 - vec(text.get_size()) // 2 background = pygame.Surface((settings.SCREEN_SIZE.x, text.get_size()[1])) background.fill((0, 0, 0)) background.set_alpha(settings.BACKGROUND_ALPHA) screen.blit(background, (0, text_position.y)) screen.blit(text, tuple(text_position)) pygame.display.flip()
def player_move(self, player): moved = False while not moved: kp = blt.read() if kp == blt.TK_CLOSE: moved = True self.stop = True elif kp in [blt.TK_UP, blt.TK_W]: if self.try_move(self.player, vec(0, -1)): moved = True elif kp in [blt.TK_DOWN, blt.TK_S]: if self.try_move(self.player, vec(0, 1)): moved = True elif kp in [blt.TK_LEFT, blt.TK_A]: if self.try_move(self.player, vec(-1, 0)): moved = True elif kp in [blt.TK_RIGHT, blt.TK_D]: if self.try_move(self.player, vec(1, 0)): moved = True elif kp in [blt.TK_SPACE, blt.TK_PERIOD]: moved = True elif kp == blt.TK_R: pass
def on_tableau_altered(self, tableau): tableau_display = self.root.elements[tableau] tableau_display.element.elements.clear() for y, health_point in enumerate(tableau): point_display = DisplayElement.PrintArgs(health_point.summary(), vec(0, y)) point_display_c = DisplayElement.Clickable(point_display, Rectangle(0, y)) tableau_display.element.elements.append(point_display_c) def on_point_altered(self, point): self.element = self.element._replace(text=point.summary()) health_point.after_health_change += partial( on_point_altered, point_display_c)
def run(self) -> None: # init log log = [] # draw first frame self.root.draw(vec(0, 0)) fps_limiter = FPSLimiter() blt.set('window:title="FLEOHSIS ({0} FPS)"'.format( fps_limiter.get_fps())) blt.refresh() # read-advance-display loop stop = False while not stop: fps_limiter.wait() blt.set('window:title="FLEOHSIS ({0} FPS)"'.format( fps_limiter.get_fps())) while blt.has_input(): if blt.read() == blt.TK_CLOSE: stop = True else: self.game.advance() blt.clear() self.root.draw(vec(0, 0)) blt.refresh() blt.close()
def __init__(self, pos, force=vec(0, 0), sprite_path="car.png"): self.pos = pos self.force = force self.mass = 0.01 # in kg self.acceleration = vec(0, 0) self.velocity = vec(0, 0) self.score = 0 self.sprite = pygame.image.load(sprite_path) # sprite self.transformed_sprite = pygame.image.load(sprite_path) self.rect = self.sprite.get_rect() self.rect.x = int(pos.x) self.rect.y = int(pos.y) self.dir = vec(1, 0) self.prevdir = vec(1, 0) self.angle = 0 self.forward = False self.backward = False self.left = False self.right = False self.boosting = False self.rays = [] self.tick = 0 # reset this to 0 every time you apply a new force
def __init__(self): self.img = None # pygame.img.load('path') goes on the right side of this assignment, and gives the sprite a fixed image self.blk = vec(0, 0) # block index self.pos = vec(0, 0) # position (bottom left of image) self.vel = vec(0, 0) # velocity self.secondvel = vec( 0, 0 ) # vel used for quantifying additional forces exerted on sprite after first move self.dim = vec(0, 0) # dimensions of sprite (in pixels) self.F = vec(0, 0) # net force acting on sprite self.secondF = vec( 0, 0 ) # F used for quantifying additional forces exerted on sprite after first move self.m = 1.0 # mass self.scale = vec(1., 1.) # amount of contraction on each axis self.walks = False # whether the sprite has feet with which it walks (this matters for friction) self.flipped = False # False means the sprite's image looks as loaded (facing right, probably), and True means it is flipped the other way (facing left, probably) self.solid = False # setting this to true will make the sprite interact with other sprites as though it is solid
def update_weights(self): bandwidth = 10.0e-3 bpos = ba.pos() btree = cKDTree(bpos, 5) bmaps = btree.query_ball_tree(self.elements_tree, bandwidth) self.wmap = numpy.array([[None] * self.nbElem for x in bmaps], dtype='d') for ib, clist in numpy.ndenumerate(bmaps): bp = bpos[ib] wlist = [0] * self.nbElem for ic in clist: dv = (vec((bp - self.elements_pos[ic]))).mag() assert (dv < 1) wbc = self.kfunc(dv, bandwidth) wlist[ic] = wbc self.wmap[ib] = wlist self.wmap /= self.wmap.sum(axis=1, keepdims=True)
def __init__(self): self.img = pygame.image.load('images/player/stand.png') self.blk = vec(0, 0) # block index self.pos = vec(50, 50) self.vel = vec(0, 0) # velocity self.dim = vec(self.img.get_width(), self.img.get_height()) self.secondvel = vec( 0, 0 ) # vel used for quantifying additional forces exerted on sprite after first move self.F = vec(0, 0) # net force acting on sprite self.m = 1.0 # mass self.scale = vec(1., 1.) # amount of contraction on each axis self.secondF = vec( 0, 0 ) # F used for quantifying additional forces exerted on sprite after first move self.walks = True # whether the sprite has feet with which it walks (this matters for friction) self.lastPressed = None # The key, out of left or right, that was pressed last frame self.flipped = False # False means the sprite's image looks as loaded (facing right, probably), and True means it is flipped the other way (facing left, probably) self.solid = False # setting this to true will make the sprite interact with other sprites as though it is solid self.supported = False # whether there is something for the player to jump off of self.lrCounter = vec( 0, 0 ) # Number of frames the left and right keys respectively have been held down for
def __init__(self): self.width = 10 self.height = 10 self.size = vec(10, 10) blt.set("window:title='Corpse Stacker',size={0}x{1}".format( self.size.x * 3, self.size.y)) blt.set('font: UbuntuMono-R.ttf, size=24') self.height_map = self.make_grid(0) self.player = Actor() self.player.position = self.size // 2 self.player.is_player = True self.player.character = '@' self.occupants = self.make_grid() self.place_actor(self.player) self.turn_number = 0 self.enemies = [] self.stop = False self.restart = False
def open_cell(self, coords): """Open a cell at given coordinates""" if invalid_coords(coords): return if not self.started: self.generate(coords) self.started = True clicked_cell = self.get(coords) if clicked_cell.open: return clicked_cell.open = True if clicked_cell.bomb: self.alive = False return self.cells_left -= 1 # Recursively open all adjacent cells if clicked_cell.number == 0: for x in range(-1, 2): for y in range(-1, 2): self.open_cell(coords + vec(x, y))
#print(len(self.activeRays)) nextRays = [] for dray in self.activeRays: # For every active ray, create the next rays for newRay in dray.interact(refraction_sim.c, self.dt, self.function): # For every created ray nextRays.append(newRay) # append it to the 'NextRays' list self.activeRays = nextRays # Update the 'activeRays' to the nextRays for dray in self.activeRays: # Time to draw the path the ray color, start, end = dray.draw() pygame.draw.line(screen, color, start, end, 2) #f = lambda v: 3-2*math.sin(.01*(v.x)) #f = lambda v: 5 - ((v.x - 600)**2 + (v.y - 600)**2)/200000 f = lambda v: 1 + 0.001*v.x rays = [] for i in range(0,3): rays.append(ray(vec(100,100), vec(1,1), 600+10*i, 1)) atmos = refraction_sim(f, rays, 1) screen.fill((0,0,0)) running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False atmos.take_step() pygame.display.flip() #pygame.time.wait(1000)
def iter_codes(self): br = self.bottom_right() for (x,y) in it.product(range(self.top_left.x, br.x), range(self.top_left.y, br.y)): yield (vec(x,y), self.border_code(vec(x,y)))
def __iter__(self): br = self.bottom_right() return (vec(x,y) for (x,y) in it.product(range(self.top_left.x, br.x), range(self.top_left.y, br.y)))
def A_cgs_fun_init(x): x = np.reshape(x, x_shape, order='F') y = AT_fun(A_fun(x)) return vec(y)