scene.setProgramConstant('resolution', [float(RES_X), float(RES_Y)])
scene.setProgramConstant('surfaceSize', [float(RES_X), float(RES_Y)])
scene.setProgramConstant('time', timeval)
scene.setProgramConstant('mouse', [0.5, 0.5])
scene.setProgramConstant('backbuffer', 0)
scene.drawTriangles(self.ibuffer)
scene.setRenderToBackBuffer()
scene.setProgram(self.render_program)
scene.setVertexBufferAt('pos', self.vbuffer, 0,
VertexBuffer3DFormat.FLOAT_2)
scene.setProgramConstant('resolution', [float(WIDTH), float(HEIGHT)])
scene.setProgramConstant('surfaceSize', [float(WIDTH), float(HEIGHT)])
scene.setTextureAt('tex', self.texture)
scene.drawTriangles(self.ibuffer)
def set_next_shader(self):
file_name = self.shader_files[self.next_shader_index]
print(file_name)
fshader_file = open(file_name, 'r')
fshader_src = fshader_file.read()
self.heroku_program.upload(self.vshader_src, fshader_src)
self.next_shader_index += 1
if self.next_shader_index >= len(self.shader_files):
self.next_shader_index = 0
if __name__ == '__main__':
flappy.start(HerokuShaders, width=WIDTH, height=HEIGHT, title=__file__)
self.addEventListener(Event.ENTER_FRAME, self.on_enter_frame)
def on_enter_frame(self, event):
curtime = time()
dt = curtime - self.lasttime
self.xrot += dt * self.rotspeed * 0.2
self.yrot += dt * self.rotspeed * 0.5
m = Matrix3D()
m.translate(0.0, 0.0, -4.0)
m.rotate(self.xrot, self.yrot, 0.0)
self.view_mat = m
scene = self.scene
scene.clear(0.0, 0.0, 0.0, 1.0)
scene.setProgram(self.prog)
scene.setVertexBufferAt('vpos', self.vbuffer, 0,
VertexBuffer3DFormat.FLOAT_3)
scene.setVertexBufferAt('color', self.vbuffer, 3,
VertexBuffer3DFormat.FLOAT_4)
scene.setProgramConstantFromMatrix('view_mat', self.view_mat)
scene.setProgramConstantFromMatrix('proj_mat', self.proj_mat)
scene.drawTriangles(self.ibuffer)
self.lasttime = curtime
if __name__ == '__main__':
flappy.start(Cube3DExample, width=WIDTH, height=HEIGHT, title=__file__)
def update_blur(self, bx, by):
blur = BlurFilter(blurX=abs(bx), blurY=abs(by))
self.blur_txt.filters = [blur]
def set_glow(self):
self.stage.color = 0x000020
self.addChild(self.glow_txt)
self.update_func = self.update_glow
def update_glow(self, bx, by):
glow = GlowFilter(color=0x00ff00, alpha=1.0,
blurX=abs(bx), blurY=abs(by), strength=2.0)
self.glow_txt.filters = [glow]
def set_shadow(self):
self.stage.color = 0xfcdd76
self.addChild(self.shadow_txt)
self.update_func =self.update_shadow
def update_shadow(self, bx, by):
pt = Point(bx, by)
distance = pt.length
pt.normalize()
angle = (math.atan2(pt.y, pt.x) / math.pi) * 180.0
shadow = DropShadowFilter(distance=distance, angle=angle, alpha=0.5)
self.shadow_txt.filters = [shadow]
if __name__ == '__main__':
flappy.start(FiltersExample, width=WIDTH, height=HEIGHT, title=__file__)
#! /usr/bin/env python
# encoding: utf-8
import flappy
from flappy.display import Sprite
from flappy.text import TextField
class HelloWorld(Sprite):
def __init__(self):
super(HelloWorld, self).__init__()
txt = TextField()
txt.text = 'Hello World!!!'
txt.selectable = False
self.addChild(txt)
if __name__ == '__main__':
flappy.start(HelloWorld, width=320, height=200, title=__file__)
self.frame_time += dt
if self.frame_time >= self.ANIM_TIME:
self.frame_time = 0.0
self.frame += self.anim_dir
if not (0 <= self.frame < self.NFRAMES):
self.frame -= self.anim_dir
self.anim_dir = -self.anim_dir
self.x += self.speed * dt * self.direction_x
self.y += self.speed * dt * self.direction_y
if not (self.radius < self.x < (WIDTH - self.radius)):
self.direction_x = -self.direction_x
self.x = max(self.radius, min(WIDTH - self.radius, self.x))
if not (self.radius < self.y < (HEIGHT - self.radius)):
self.direction_y = -self.direction_y
self.y = max(self.radius, min(HEIGHT - self.radius, self.y))
def get_tile_data(self):
return [
self.x,
self.y,
self.tileset * self.NFRAMES + self.frame,
self.scale,
self.rotation,
]
if __name__ == '__main__':
flappy.start(ParaspritesExample, width=WIDTH,
height=HEIGHT, title=__file__)
self.stage.focus = self
def on_enter_frame(self, event):
new_time = time()
dt = new_time - self.old_time
self.vy += (GRAVITY + self.ay) * dt
self.vx += self.ax * dt
self.ball.x += self.vx * dt
self.ball.y += self.vy * dt
if (self.ball.x + BALL_RADIUS) > WIDTH:
self.vx = -self.vx * DAMP
self.ball.x = WIDTH - BALL_RADIUS
elif (self.ball.x - BALL_RADIUS) < 0.0:
self.vx = -self.vx * DAMP
self.ball.x = BALL_RADIUS
elif (self.ball.y + BALL_RADIUS) > HEIGHT:
self.vy = -self.vy * DAMP
self.ball.y = HEIGHT - BALL_RADIUS
elif (self.ball.y - BALL_RADIUS) < 0.0:
self.vy = -self.vy * DAMP
self.ball.y = BALL_RADIUS
self.ax, self.ay = 0.0, 0.0
self.old_time = new_time
if __name__ == '__main__':
flappy.start(KeyboardExample, width=WIDTH, height=HEIGHT, title=__file__)
def main():
# Starts game
_thread.start_new_thread(start_flappy, ())
generation = 1
population = 9
best_bird_ever = Bird()
best_score_ever = 0
birds = create_first_population(population)
flappy.population = population
fitnesses = np.array([])
while True:
for bird in birds:
reset_bird(bird)
flappy.start()
# todo: passer le tout en fonction
# todo: passer le tout dans flappy.py et supprimer ici
flappy.pooulation = population
flappy.score = np.zeros(population)
flappy.diff_x = np.zeros(population)
flappy.diff_y = np.zeros(population)
flappy.is_alive = np.full(population, True)
flappy.birds = np.arange(population)
# While at least one bird is alive
while len(flappy.birds) > 0:
for i in range(len(birds)):
if flappy.is_alive[i]:
bird = birds[i]
# todo : tester avant de l'enlever
bird.should_flap(0, 0)
diff_x = flappy.diff_x[i]
diff_y = flappy.diff_y[i]
bird.increase_fitness(flappy.score[i], diff_x)
# todo : resoudre le problème des scores
prediction = bird.should_flap(diff_x, diff_y)
if prediction:
flappy.flap(i)
sleep(0.03)
birds = sort_birds_by_fitness(birds)
fitnesses = np.append(fitnesses,
np.max([bird.fitness for bird in birds]))
save(fitnesses, arg())
if birds[0].fitness > best_score_ever:
best_bird_ever = best_bird_ever
best_score_ever = birds[0].fitness
print("New best score with {} !".format(best_score_ever))
if birds[0].score == 0:
print("Starting new population. This one was too bad :(")
# generation = 0
best = birds[0]
birds = create_first_population(population)
birds[0] = best
else:
birds = evolve_population(birds)
birds[population - 1] = best_bird_ever
generation += 1
