def next_frame(self):
while (True):
for x in range(self.square.width):
w = (self.min_freq + x) / float(
self.cycles) # pendulum frequency
y_top = (cos(w * self.counter) + 1) * self.square.height / 2
for y in range(self.square.height):
if self.up_down:
c = change_color(self.color, x * self.gradient /
1500.0) if y < y_top else self.black
else:
c = change_color(self.color, x * self.gradient /
1500.0) if y > y_top else self.black
self.square.set_cell((x, y), dim_color(c, 0.5))
self.counter += 1
if self.counter % (int(2 * pi * self.cycles)) == 0:
self.min_freq = up_or_down(self.min_freq, 1, 3, 10)
self.gradient = up_or_down(self.gradient, 2, 5, 15)
self.color = random_color_range(self.color, 0.007)
self.up_down = not self.up_down
yield self.speed # random time set in init function
def next_frame(self):
while True:
for x in range(self.width):
w = (self.min_freq + x) / float(
self.cycles) # pendulum frequency
y_top = (cos(w * self.counter) + 1) * hex.HEX_SIZE / 2
for y in range(hex.HEX_SIZE):
if self.up_down:
c = change_color(self.color, x * self.gradient /
1500.0) if y < y_top else black()
else:
c = change_color(self.color, x * self.gradient /
1500.0) if y > y_top else black()
h = x // hex.HEX_SIZE
hex_x = x % hex.HEX_SIZE
self.hexes.set_cell(
(h, hex_x - hex.HEX_OFFSET, y - hex.HEX_OFFSET),
dim_color(c, 0.5))
self.counter += 1
if self.counter % (int(2 * pi * self.cycles)) == 0:
self.min_freq = up_or_down(self.min_freq, 1, 3, 10)
self.gradient = up_or_down(self.gradient, 2, 5, 15)
self.color = random_color_range(self.color, 0.007)
self.up_down = not self.up_down
yield self.speed # random time set in init function
def next_frame(self):
for i in range(0, 1000): # number of steps per game
# Calculate each hex's fate
for cell in self.life_hexes.life_map:
self.life_hexes.decide_fate(cell)
# Push all at once the new fates into current state
for cell in self.life_hexes.life_map:
self.life_hexes.get(cell).push_state()
# Draw the actual hexes, but only the ones in the display
for cell in self.hexes.cellmap.keys():
mapped_cell = self.life_hexes.get(cell)
if mapped_cell:
color = self.on_color if mapped_cell.is_alive(
) else self.off_color
self.hexes.set_cell(cell, color)
# Slowly change the colors
if helpfunc.one_in(10):
self.on_color = change_color(self.on_color, 0.1)
if helpfunc.one_in(5):
if self.off_color != black(): # Black - keep as black
self.off_color = change_color(self.off_color, -0.05)
yield self.speed # random time set in init function
def input(self, key):
"""
キー入力
"""
if key == "space":
# ポーズ
self.can_drop = not self.can_drop
elif key == "Escape":
self.reset()
self.game.reset()
elif key == "c":
change_color()
elif key == "w":
print("Input: HOLD")
self.hold()
elif key == "e":
print("Input: ROTATE:e")
# 回転
self.__rotate(clockwise=True)
elif key == "q":
print("Input: ROTATE:q")
# 回転
self.__rotate(clockwise=False)
elif key == "a" and not self.__is_collision_left():
# 移動 左
self.block.pos_x -= 1
elif key == "s":
# ハードドロップ
self.__hard_drop()
elif key == "d" and not self.__is_collision_right():
# 移動 右
self.block.pos_x += 1
def next_frame(self):
while True:
# Randomly fire a bullet
for h in helpfunc.all_hexes():
spin_center = (h, 4, 0)
self.bullets.append(Bullet(hexmodel=self.hexes, color=self.spincolor,
pos=choice(self.mirror_hexes(spin_center))))
self.draw_background()
self.draw_spinners(spin_center)
# Draw the bullets
for bullet in self.bullets:
if not bullet.move_bullet(): # bullet has moved off the board
self.bullets.remove(bullet) # kill the bullet
self.time += 1
# Random move the spin centers
if helpfunc.one_in(10):
new_spot = choice(helpfunc.hex_ring(spin_center, 1))
if self.hexes.cell_exists(choice(helpfunc.hex_ring(spin_center, 1))):
spin_center = new_spot
# Change the colors
self.background = change_color(self.background, 0.05)
self.spincolor = change_color(self.background, -0.1)
yield self.speed # random time set in init function
def next_frame(self):
self.square.clear()
while (True):
if self.counter % self.density == 0:
color1 = change_color(self.color1, self.inc * 5 / 1500.0)
color2 = change_color(self.color2, self.inc * 5 / 1500.0)
dx = self.inc / 100.0
dy = 1.0 - dx
self.bricks.add_brick(color1,
life=200,
pos=(0, self.square.height - 1),
length=0,
pitch=1,
length_x=0,
length_y=0,
dx=dx,
dy=dy,
accel_x=0,
accel_y=0,
use_faders=True,
change=0.4)
self.bricks.add_brick(color2,
life=1000,
pos=(self.square.width - 1,
self.square.height - 1),
length=0,
pitch=1,
length_x=0,
length_y=0,
dx=-dx,
dy=dy,
accel_x=0,
accel_y=0,
use_faders=True,
change=0.2)
self.inc = (self.inc + 1) % 100
self.bricks.move_bricks()
self.counter += 1
yield self.speed # random time set in init function
def next_frame(self):
self.ripples = [Ripple(self.hexes, h) for h in helpfunc.all_hexes()]
while True:
# Check how many rips are in play
# If no rips, add one. If rips < 6 then add one more randomly
if len(self.ripples) < 6 * helpfunc.NUM_HEXES and helpfunc.one_in(
20):
self.ripples.append(Ripple(self.hexes))
for ripple in self.ripples:
ripple.draw(self.color, self.time, self.width)
# Slowly change the colors
if helpfunc.one_in(10):
self.color = change_color(self.color, 0.07)
# Decrease the life of each ripple - kill a ripple if life is zero
for ripple in self.ripples:
if not ripple.decrease_time():
self.ripples.remove(ripple)
self.time += 1
yield self.speed # random time set in init function
def next_frame(self):
self.sparkles = [
Sparkle(self.hexes, pos=self.hexes.rand_cell(), color=self.color)
for _ in range(self.spark_num)
]
while True:
while len(self.sparkles) < self.spark_num:
self.sparkles.append(
Sparkle(self.hexes,
pos=self.hexes.rand_cell(),
color=self.color))
self.hexes.black_all_cells()
# Draw the sparkles
for sparkle in self.sparkles:
sparkle.draw_sparkle()
if not sparkle.fade_sparkle():
self.sparkles.remove(sparkle)
if helpfunc.one_in(5):
self.color = change_color(self.color, 0.02)
yield self.speed # random time set in init function
def next_frame(self):
while (True):
# Randomly add a center swirl
if len(self.liveswirls) == 0 or one_in(30):
for sq in range(self.square.num_squares):
newswirl = Swirl(self.square, sq, self.maincolor,
get_center(sq), rand_dir(),
choice([1, 2, 4]), 0, self.longevity)
self.liveswirls.append(newswirl)
self.maincolor = change_color(self.maincolor, 0.02)
for s in self.liveswirls:
s.draw_swirl()
# Chance for branching
if one_in(15): # Create a fork
newdir = turn_left(s.dir) # always fork left
newswirl = Swirl(self.square, sq, s.color, s.pos, newdir,
s.sym, s.life, s.longevity)
self.liveswirls.append(newswirl)
if s.move_swirl() == False: # Swirl has moved off the board
self.liveswirls.remove(s) # kill the branch
if one_in(20):
self.longevity = up_or_down(self.longevity, 2, 40, 100)
if one_in(40):
self.maincolor = random_color_range(self.maincolor, 0.02)
yield self.speed
def next_frame(self):
self.square.clear()
while (True):
waggle = sin(2 * pi * self.get_fract(self.counter, self.wag_speed)
) # Up and Down motion results = -1 to +1
for x in range(self.square.width):
for y in range(self.square.height):
intensity = sin(float(x) / self.repeat) * cos(
float(y) / self.repeat) # -1 to 1
spread = intensity * waggle # (-1 to 1) * (-1 to 1) = -1 to 1
self.square.set_cell(
(x, y),
dim_color(
change_color(self.color,
spread * MAX_COLOR / 6000.0), 0.3))
if waggle == 0 and one_in(10):
self.repeat = up_or_down(self.repeat, 1, 1, 4)
# Change the colors
if one_in(10):
self.color = random_color_range(self.color, 0.007)
self.counter += 1
yield self.speed
def next_frame(self):
while (True):
before_cells = [
k for k, v in self.cellmap.iteritems() if v == True
]
self.check_life()
after_cells = [k for k, v in self.cellmap.iteritems() if v == True]
if self.counter % 400 == 0 or \
(len(before_cells) == len(after_cells) and len(before_cells) < 10 * self.square.squares): # Have cells changed?
self.square.clear()
self.color = random_color()
for i in range(randint(self.min_start, self.max_start)):
self.light_square(choice(self.cellmap.keys()))
yield self.speed
self.counter += 1
self.color = change_color(self.color, 0.02)
if one_in(200):
self.speed = up_or_down(self.speed, 0.1, 0.2, 2.0)
yield self.speed
def next_frame(self): while (True): if one_in(self.density): base_color = random_color_range(self.color, 0.05) x = randint(0, self.square.width) width = randint(2,5) for i in range(width): color = change_color(base_color, i * 0.01) self.bricks.add_brick(color, life=self.life, pos=(x+i, 0), length=self.length, pitch=1, length_x=-1, length_y=-1, dx=1, dy=1, use_faders=True, change=self.fade) self.bricks.add_brick(color, life=self.life, pos=(x+i, 0), length=self.length, pitch=1, length_x=1, length_y=-1, dx=-1, dy=1, use_faders=True, change=self.fade) self.bricks.add_brick(color, life=self.life, pos=(x+i, self.square.height), length=self.length, pitch=1, length_x=-1, length_y=1, dx=1, dy=-1, use_faders=True, change=self.fade) self.bricks.add_brick(color, life=self.life, pos=(x+i, self.square.height), length=self.length, pitch=1, length_x=1, length_y=1, dx=-1, dy=-1, use_faders=True, change=self.fade) self.bricks.move_bricks(refresh=False) # Change the colors if one_in(10): self.color = random_color_range(self.color, 0.2) if one_in(50): self.fade = up_or_down(self.fade, 1, 2, 10) if one_in(50): self.density = up_or_down(self.density, 1, 2, 10) yield self.speed # random time set in init function
def next_frame(self):
while True:
self.hexes.black_all_cells()
for y in range(hex.HEX_SIZE):
w = (self.min_freq + y) / float(
self.cycles) # pendulum frequency
x = int((cos(w * self.counter) + 1) * self.width / 2)
h = x // hex.HEX_SIZE
hex_x = x % hex.HEX_SIZE
self.faders.add_fader(
change_color(self.color, y * self.gradient / 1500.0),
(h, hex_x - hex.HEX_OFFSET, y - hex.HEX_OFFSET),
intense=1.0,
growing=False,
change=0.05)
self.faders.cycle_faders()
self.counter += 1
if self.counter % (int(2 * pi * self.cycles)) == 0:
self.color = random_color_range(self.color, 0.15)
self.gradient = up_or_down(self.gradient, 5, 15, 40)
yield self.speed # random time set in init function
def next_frame(self):
while (True):
# Check how many branches are in play
# If no branches, add one. If branches < 10, add more branches randomly
while len(self.livebranches) < 10 or one_in(10):
sq = self.square.rand_square() # Pick a random Square
newbranch = Branch(self.square, sq,
random_color_range(self.maincolor, 0.02),
choice(self.square.edges(sq)), self.maindir,
0)
self.livebranches.append(newbranch)
for b in self.livebranches:
b.draw_branch()
# Chance for branching
if one_in(5): # Create a fork
new_dir = turn_left_or_right(b.dir)
new_branch = Branch(self.square, b.square_num,
change_color(b.color, 0.03), b.pos,
new_dir, b.life)
self.livebranches.append(new_branch)
if b.move_branch() == False: # branch has moved off the board
self.livebranches.remove(b) # kill the branch
# Infrequently change the dominate direction
if one_in(10):
self.maindir = turn_left_or_right(self.maindir)
yield self.speed # random time set in init function
def next_frame(self):
while (True):
self.square.black_all_cells()
for y in range(self.square.height):
w = (self.min_freq + y) / float(
self.cycles) # pendulum frequency
x = int((cos(w * self.counter) + 1) * self.square.width / 2)
self.faders.add_fader(change_color(self.color,
y * self.gradient / 1500.0),
(x, y),
intense=1.0,
growing=False,
change=0.05)
self.faders.cycle_faders()
self.counter += 1
if self.counter % (int(2 * pi * self.cycles)) == 0:
self.color = random_color_range(self.color, 0.15)
self.gradient = up_or_down(self.gradient, 5, 15, 40)
yield self.speed # random time set in init function
def __init__(self, squaremodel):
self.name = "BounceCannons"
self.square = squaremodel
self.bricks = Bricks(squaremodel, bounce=True)
self.speed = 0.01
self.color1 = rand_color()
self.color2 = change_color(self.color1, 0.5)
self.density = randint(20, 50)
def draw_drop(self):
if self.current_size == 0: # just draw the center
self.hexes.set_cell(self.center, self.color)
else:
self.hexes.set_cells(
helpfunc.hex_ring(self.center, self.current_size),
change_color(self.color,
0.008 * self.current_size * self.bands))
def __init__(self, squaremodel):
self.name = "BounceCannons2"
self.square = squaremodel
self.bricks = Bricks(squaremodel)
self.speed = 0.05
self.color1 = rand_color()
self.color2 = change_color(self.color1, 0.5)
self.density = randint(1, 5)
self.length = randint(1, 10)
def __init__(self, squaremodel):
self.name = "Waterfall"
self.square = squaremodel
self.bricks = Bricks(squaremodel, bounce=False)
self.speed = 0.1
self.color1 = rand_color()
self.color2 = change_color(self.color1, 0.5)
self.density = randint(2, 5)
self.accel = randint(1, 10)
self.fade = randint(1, 5)
def __init__(self, squaremodel):
self.name = "WavePendulum"
self.square = squaremodel
self.speed = 0.05
self.counter = 0
self.background = rand_color()
self.color = change_color(self.background, 0.5)
self.min_freq = 10 # fastest pendulum does this many cycles in one loop
self.cycle_time = 5 # speed of one cycle
self.cycles = int(self.cycle_time / self.speed)
self.gradient = 3
def next_frame(self):
# self.square.clear()
while (True):
for x in range(self.square.width):
for y in range(self.square.height):
color = change_color(self.color1, -y *
0.02) if x % 2 else change_color(
self.color2, y * 0.02)
self.square.set_cell((x, y), dim_color(color, 0.33))
# Change the colors
if one_in(10):
self.color1 = change_color(self.color1, 0.007)
if one_in(2):
self.color2 = change_color(self.color2, -0.007)
yield self.speed # random time set in init function
def draw_rotater(self):
for l in range(self.length):
for i in range(self.sym):
rad = 2 * 3.14159 * (self.angle + (i * 360 / self.sym)) / 360
pos = (round(self.pos[0] + (sin(rad) * l)),
round(self.pos[1] + (cos(rad) * l)))
self.faders.add_fader(change_color(self.color, l * 0.01),
pos,
intense=0.8,
growing=False,
change=self.change)
self.faders.cycle_faders(False)
def next_frame(self):
self.set_up_spinners()
while True:
# Draw the spinners - draw exploding spinners last
for s in self.spinners:
s.draw_spinner(self.spincolor, self.explode_color, self.time)
if not s.is_resting():
s.move_spinner()
# Explode a spinner
if self.all_resting() and helpfunc.one_in(5):
choice(self.spinners).explode_spinner()
# Change the colors
self.explode_color = change_color(self.explode_color, 0.05)
self.spincolor = change_color(self.spincolor, -0.01)
self.time += 1
yield self.speed # random time set in init function
def next_frame(self):
while True:
self.hexes.set_all_cells(dim_color(self.background, 0.3))
for x in range(hex.NUM_HEXES * hex.HEX_SIZE):
w = (self.min_freq + x) / float(self.cycles) # pendulum frequency
y = int((cos(w * self.counter) + 1) * hex.HEX_SIZE / 2)
h = x // hex.HEX_SIZE
hex_x = x % hex.HEX_SIZE
self.hexes.set_cell((h, hex_x - hex.HEX_OFFSET, y - hex.HEX_OFFSET),
change_color(self.color, y * self.gradient / 1500.0))
self.counter += 1
if self.counter % (int(2 * pi * self.cycles)) == 0:
self.min_freq = up_or_down(self.min_freq, 1, 3, 10)
self.gradient = up_or_down(self.gradient, 1, 0, 10)
self.color = change_color(self.color, 0.15)
self.background = random_color_range(self.background, 0.015)
yield self.speed
def next_frame(self):
while (True):
self.square.set_all_cells(dim_color(self.background, 0.3))
for x in range(self.square.width):
w = (self.min_freq + x) / float(
self.cycles) # pendulum frequency
y = int((cos(w * self.counter) + 1) * self.square.height / 2)
self.square.set_cell((x, y),
change_color(self.color,
y * self.gradient / 1500.0))
self.counter += 1
if self.counter % (int(2 * pi * self.cycles)) == 0:
self.min_freq = up_or_down(self.min_freq, 1, 3, 10)
self.gradient = up_or_down(self.gradient, 1, 0, 10)
self.color = change_color(self.color, 0.15)
self.background = random_color_range(self.background, 0.015)
yield self.speed
def next_frame(self):
while True:
# Check how many snakes are in play
# If no snakes, add one. Otherwise if snakes < 4, add more snakes randomly
if not self.live_snakes or helpfunc.one_in(10):
start_pos = self.snakemap.pick_open_hex()
if start_pos: # Found a valid starting position
self.next_snake_id += 1
self.main_color = change_color(self.main_color, 0.1)
self.snakemap.put_snake_value(start_pos,
self.next_snake_id)
new_snake = Snake(self.hexes, self.main_color,
self.next_snake_id, start_pos)
self.live_snakes[self.next_snake_id] = new_snake
for id, snake in self.live_snakes.items():
if snake.alive:
snake.draw_snake() # Draw the snake head
# Try to move the snake
next_pos = helpfunc.hex_in_direction(
snake.pos, snake.direction
) # Get the coord of where the snake will go
if self.snakemap.is_open_hex(
next_pos): # Is the new spot open?
snake.pos = next_pos # Yes, update snake position
self.snakemap.put_snake_value(
snake.pos, snake.snakeID
) # Put snake on the virtual snake map
else:
dirs = self.snakemap.get_valid_directions(
snake.pos) # Blocked, check possible directions
if dirs: # Are there other places to go?
snake.direction = choice(
dirs) # Yes, pick a random new direction
snake.pos = helpfunc.hex_in_direction(
snake.pos, snake.direction)
self.snakemap.put_snake_value(
snake.pos, snake.snakeID)
else: # No directions available
snake.alive = False # Kill the snake
self.snakemap.remove_snake_path(
snake.snakeID) # Snake is killed
yield self.speed # random time set in init function
def draw(self):
# Draw the center hex - Not included in the ring model
x = self.gauss(self.a, self.c, 0)
self.hexes.set_cell(self.pos, gradient_wheel(self.color, 1 + x))
# Draw the rings
for i in range(
0, 15): # total number of rings - can be bigger than display
x = self.gauss(self.a, self.c, i + 1)
self.hexes.set_cells(helpfunc.hex_ring(self.pos, i),
gradient_wheel(self.color, 1 + x))
self.time = (self.time + 16) % 720
self.a = sin(radians(self.time))
if helpfunc.one_in(8):
self.color = change_color(self.color, 0.02)
def next_frame(self):
while True:
if self.time == 0:
self.pos = self.get_pin_centers(randint(3, 10))
self.c = randint(2, 5) # Width of well
self.hexes.set_all_cells(self.color)
# Draw the rings
for ring in range(
12, 0,
-1): # total number of rings - can be bigger than display
for center in self.pos:
h, x, y, = center
x = self.gauss(self.a, self.c, ring + 1, h)
atten = 1 + x if x < 0 else x
if abs(atten) < self.min_bright:
atten = self.min_bright
color = gradient_wheel(self.color, atten)
self.hexes.set_cells(helpfunc.hex_ring(center, ring),
color)
# Draw the center hexes - Not included in the ring model
for center in self.pos:
h, x, y, = center
x = self.gauss(self.a, self.c, ring + 1, h)
atten = 1 + x if x < 0 else x
if abs(atten) < self.min_bright:
atten = self.min_bright
color = gradient_wheel(self.color, atten)
self.hexes.set_cells(self.pos, color)
if helpfunc.one_in(8):
self.color = change_color(self.color, 0.1)
self.time = (self.time + 4) % 720
self.a = sin(radians(self.time))
yield self.speed # random time set in init function
def next_frame(self):
while True:
fractal = self.mandelbrot_set(
self.calc_edges(self.counter, self.center), self.square.width,
self.square.height, self.maxiter)
for x in range(self.square.width):
for y in range(self.square.height):
value = fractal[x, y]
color = change_color(self.color, value *
20) if value < self.maxiter else (0,
0,
0)
self.square.set_cell((x, y), color)
self.counter += 1
yield self.speed # random time set in init function
def next_frame(self):
while True:
for h in helpfunc.all_hexes():
self.hexes.set_cell(
self.centers[h],
gradient_wheel(self.color[h],
self.get_att(self.width[h], 0, self.time)))
# Draw the rings
for ring in range(
15
): # total number of rings - can be bigger than display
color = gradient_wheel(
self.color[h],
self.get_att(self.width[h], ring, self.time))
self.hexes.set_cells(
helpfunc.hex_ring(self.centers[h], ring), color)
# Slowly change the colors
if helpfunc.one_in(4):
self.color[h] = change_color(self.color[h], 0.05)
# Move the center of the ripple like a drunken mason
if helpfunc.one_in(5):
while True:
new_hex = choice(helpfunc.neighbors(self.centers[h]))
if self.hexes.cell_exists(new_hex):
self.centers[h] = new_hex
break
self.time += 1
yield self.speed # random time set in init function
