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)
