class FadeOut(State):
def __init__(self, window, *args, **kwargs):
print "++++ new fade state"
State.__init__(self, window, "fade", *args, **kwargs)
self.old_state_batch = kwargs["old_state"]
self.duration = kwargs["duration"]
self.next_state = kwargs["next_state"]
self.next_state_args = kwargs["next_state_args"]
self.build_scene()
self.alpha = 0.0
def build_scene(self):
self.quad = batch.get_batch().add(4, GL_QUADS, GRP_BLEND_ONE_MINUS, ("v3f", fade_quad), ("c4f", fade_color * 4))
self.camera = Camera((3.8, -18.0, 1.0), (3.8, 0, 1.0))
self.attaboy = MsgQueue()
def destroy_scene(self):
pass
def on_draw(self):
set3D(self.window)
self.window.clear()
glLoadIdentity()
self.camera.focus()
batch.get_batch(self.old_state_batch).draw()
batch.get_batch().draw()
set2D(self.window)
return pyglet.event.EVENT_HANDLED
def on_key_press(self, k, args):
if k == key.F11:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
return pyglet.event.EVENT_HANDLED
def on_lose_focus(self):
pyglet.clock.unschedule(self.on_update)
self.destroy_scene()
return pyglet.event.EVENT_HANDLED
def on_gain_focus(self):
pyglet.clock.schedule_interval(self.on_update, 1.0 / 60.0)
return pyglet.event.EVENT_HANDLED
def on_update(self, dt):
self.attaboy.update(dt)
if self.alpha > 1:
self.window.replace_state(self.next_state, **self.next_state_args)
else:
color = fade_color
color[3] = self.alpha
self.quad.colors = color * 4
self.alpha += self.duration * dt
return pyglet.event.EVENT_HANDLED
class ATCGDisplay (object):
def __init__(self,):
self.attaboy = MsgQueue()
self.A = self.attaboy.on_off("a", 0.1, _BASE_COLORS['A'], pos=(-2,0,0))
self.T = self.attaboy.on_off("t", 0.1, _BASE_COLORS['T'], pos=(-2,0,-0.3))
self.C = self.attaboy.on_off("c", 0.1, _BASE_COLORS['C'], pos=(-2,0,-0.6))
self.G = self.attaboy.on_off("g", 0.1, _BASE_COLORS['G'], pos=(-2,0,-0.9))
def update(self, dt):
self.attaboy.update(dt)
class MainMenu (object):
def __init__(self, pos=Point3(6.1, 0.0, 1.9)):
self.choices = { 1: 'new game',
2: 'tutorial',
3: 'fullscreen',
4: 'about',
5: 'quit'
}
self.choice = 1
self.pos = pos
self.attaboy = MsgQueue()
self.title = VectorString("genome hero", (3,0,2.0), 0.3)
self.labels = self.build_labels()
self.labels[0].unpause()
def build_labels(self):
tl = []
x, y, z = self.pos[:]
for c in self.choices.keys():
lx, lz = x, (z + (c*-0.7))# + -0.6
l = self.attaboy.pulse(self.choices[c], 0.16, 1, (lx,0,lz))
l.pause()
tl.append(l)
return tl
def on_key_press(self, k, args):
labels = self.labels
if k == key.UP:
if self.choice == 1:
labels[self.choice-1].pause(1)
self.choice = len(self.choices)
labels[self.choice-1].unpause()
else:
labels[self.choice-1].pause(1)
self.choice -= 1
labels[self.choice-1].unpause()
elif k == key.DOWN:
if self.choice == len(self.choices):
labels[self.choice-1].pause(1)
self.choice = 1
labels[self.choice-1].unpause()
else:
labels[self.choice-1].pause(1)
self.choice += 1
labels[self.choice-1].unpause()
else:
return True
def update(self, dt):
self.attaboy.update(dt)
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0, 0, 1.0))
self.camera.subtle_motion = True
self.camera.subtle_range = (3.5, -3.5)
self.camera.subtle_speed = 0.04
self.attaboy = MsgQueue()
self.attaboy.pulse("pause", 0.25, 1, (-1.0, -1, 1)).pause(1)
self.labels = self.build_labels()
self.labels[0].unpause()
def __init__(self, pos=Point3(6.1, 0.0, 1.9)):
self.choices = { 1: 'new game',
2: 'tutorial',
3: 'fullscreen',
4: 'about',
5: 'quit'
}
self.choice = 1
self.pos = pos
self.attaboy = MsgQueue()
self.title = VectorString("genome hero", (3,0,2.0), 0.3)
self.labels = self.build_labels()
self.labels[0].unpause()
class Streak (object):
def __init__(self, streak):
self.streak = streak
self.attaboy = MsgQueue()
self.color = ([1.0, 0.0, 0.0,1.0], [0.1,0.0,0.0,1.0])
self.msg_color = ([40/255.0,220/255.0,180/255.0,1.0], [0.0,0.1,0.0,1.0])
self.display = VectorString("streak%03d" % streak, (1.6,0,-1.55), 0.08, self.color)
def inc(self):
self.streak += 1
self.display.set_string("streak%03d" % self.streak)
return self.streak
def reset(self):
self.streak = 0
self.display.set_string("streak%03d" % self.streak)
def report(self):
if messages.STREAK_TEXT.has_key(s):
self.attaboy.add_centered_fade(messages.STREAK_TEXT[s], 0.2, 1, self.msg_color)
def update(self, dt):
self.attaboy.update(dt)
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0,0,1.0))
self.score = Score(0)
self.streak = Streak(0)
self.atcg_display = ATCGDisplay()
self.endzone = EndZone((-1.4,0,-1.3), 2.8, 0.18)
self.attaboy = MsgQueue()
self.mutation = Mutation(0)
if self.win_conditions.has_key('time'):
self.timer = Timer(self.win_conditions['time'])
else:
self.timer = None
# speed_dif = self.level * 0.07 * (self.diff*0.8)
# spawn_dif = self.level * 0.07 + (self.diff*0.03)
## lower down
# self.helix = Helix(speed = 0.7 + speed_dif, spawn_rate=0.7-spawn_dif,
# starthgt=7, endhgt=-5, spins=2.5, pair_generator=self.pair_generator)
if self.level >= 4:
starthgt = 7
endhgt = -2.5
spins = 2.5
else:
starthgt = 5
endhgt = -2.5
spins = 1.5
l, d = self.level, self.diff
speed_dif = 0.8 + (l * 0.04 * (d*0.6))
spawn_dif = 0.5 - (l * 0.07 * (d*0.09))
self.helix = Helix(speed = speed_dif, spawn_rate=spawn_dif,
starthgt=starthgt, endhgt=endhgt, spins=spins, pair_generator=self.pair_generator)
self.helix.register_callbacks(self.enter_callback, self.exit_callback)
# for n in range(100):
# self.helix.update(0.1)
self.attaboy.add_centered_fade("level %d\n%s\n%s" % (self.level,
diff[self.diff], messages.EASY_LEVELS[self.level]), 0.2, 0.1)
def __init__(self,):
self.attaboy = MsgQueue()
self.A = self.attaboy.on_off("a", 0.1, _BASE_COLORS['A'], pos=(-2,0,0))
self.T = self.attaboy.on_off("t", 0.1, _BASE_COLORS['T'], pos=(-2,0,-0.3))
self.C = self.attaboy.on_off("c", 0.1, _BASE_COLORS['C'], pos=(-2,0,-0.6))
self.G = self.attaboy.on_off("g", 0.1, _BASE_COLORS['G'], pos=(-2,0,-0.9))
def __init__(self, streak):
self.streak = streak
self.attaboy = MsgQueue()
self.color = ([1.0, 0.0, 0.0,1.0], [0.1,0.0,0.0,1.0])
self.msg_color = ([40/255.0,220/255.0,180/255.0,1.0], [0.0,0.1,0.0,1.0])
self.display = VectorString("streak%03d" % streak, (1.6,0,-1.55), 0.08, self.color)
class GameState (State):
def __init__(self, window, level, diff, pair_generator, win_conditions, *args, **kwargs):
print "++++ new game state"
self.level = level
self.diff = diff
self.pair_generator = pair_generator
self.win_conditions = win_conditions
State.__init__(self, window, "game", *args, **kwargs)
self.build_scene()
self.current_rung = None
self.longest_streak = 0
self.time = 0
self.mutation_counter = 0
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0,0,1.0))
self.score = Score(0)
self.streak = Streak(0)
self.atcg_display = ATCGDisplay()
self.endzone = EndZone((-1.4,0,-1.3), 2.8, 0.18)
self.attaboy = MsgQueue()
self.mutation = Mutation(0)
if self.win_conditions.has_key('time'):
self.timer = Timer(self.win_conditions['time'])
else:
self.timer = None
# speed_dif = self.level * 0.07 * (self.diff*0.8)
# spawn_dif = self.level * 0.07 + (self.diff*0.03)
## lower down
# self.helix = Helix(speed = 0.7 + speed_dif, spawn_rate=0.7-spawn_dif,
# starthgt=7, endhgt=-5, spins=2.5, pair_generator=self.pair_generator)
if self.level >= 4:
starthgt = 7
endhgt = -2.5
spins = 2.5
else:
starthgt = 5
endhgt = -2.5
spins = 1.5
l, d = self.level, self.diff
speed_dif = 0.8 + (l * 0.04 * (d*0.6))
spawn_dif = 0.5 - (l * 0.07 * (d*0.09))
self.helix = Helix(speed = speed_dif, spawn_rate=spawn_dif,
starthgt=starthgt, endhgt=endhgt, spins=spins, pair_generator=self.pair_generator)
self.helix.register_callbacks(self.enter_callback, self.exit_callback)
# for n in range(100):
# self.helix.update(0.1)
self.attaboy.add_centered_fade("level %d\n%s\n%s" % (self.level,
diff[self.diff], messages.EASY_LEVELS[self.level]), 0.2, 0.1)
def enter_callback(self, r):
self.current_rung = r
def exit_callback(self, r):
if r.get_pair_data()[0] == None or r.get_pair_data()[1] == None:
self.bad_move()
self.current_rung = None
def destroy_scene(self):
pass
def on_draw(self):
set3D(self.window)
self.window.clear()
glLoadIdentity()
self.camera.focus()
batch.get_batch().draw()
set2D(self.window)
return pyglet.event.EVENT_HANDLED
def bad_move(self):
audio.play_sound('lose_streak')
r = self.current_rung
if r:
r.miss()
self.camera.shake(1,2, 1)
self.attaboy.add_centered_fade(messages.random_bad_move(), 0.25, 1, ([0.7,0.7,0.7,1.0], [0.1,0.1,0.1,1.0]))
self.streak.reset()
l, d = self.level, self.diff
self.helix.mutate(0.2 + (l * 0.04))
self.mutation_counter += 5 * (self.level*0.5)
if self.mutation_counter > 100:
self.lose()
self.mutation.set_mutation(self.mutation_counter)
def good_move(self):
audio.play_sound('hit')
r = self.current_rung
if r:
r.hit()
if self.mutation_counter > 1:
self.mutation_counter -= 1
self.mutation.set_mutation(self.mutation_counter)
s = self.streak.inc()
p = s*0.5*100
self.attaboy.add_score_fade(p)
self.score.inc_score(p)
def on_key_press(self, k, args):
## =A++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
if k == key.A:
self.atcg_display.A.on()
if check_hit('A', self.current_rung):
self.good_move()
else:
self.bad_move()
## =S++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
elif k == key.S:
self.atcg_display.T.on()
if check_hit('T', self.current_rung):
self.good_move()
else:
self.bad_move()
## =D++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
elif k == key.D:
self.atcg_display.C.on()
if check_hit('C', self.current_rung):
self.good_move()
else:
self.bad_move()
## =F++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
elif k == key.F:
self.atcg_display.G.on()
if check_hit('G', self.current_rung):
self.good_move()
else:
self.bad_move()
## ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
elif k == key.LEFT:
pass
elif k == key.RIGHT:
pass
elif k == key.ESCAPE:
self.pause()
return pyglet.event.EVENT_HANDLED
elif k == key.F11:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
return pyglet.event.EVENT_HANDLED
def on_key_release(self, k, args):
if k == key.A:
self.atcg_display.A.off()
elif k == key.S:
self.atcg_display.T.off()
elif k == key.D:
self.atcg_display.C.off()
elif k == key.F:
self.atcg_display.G.off()
return pyglet.event.EVENT_HANDLED
def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
pass
def lose(self):
self.window.pop_state()
self.window.replace_state(transitions.ScriptedTransition, script=script.lose, script_name="lose")
def win(self):
self.window.replace_state(transitions.ScriptedTransition, script=script.win, script_name="win")
def on_lose_focus(self):
pyglet.clock.unschedule(self.on_update)
return pyglet.event.EVENT_HANDLED
def on_gain_focus(self):
self.helix.unobscure()
self.helix.update(0.1)
pyglet.clock.schedule_interval(self.on_update, 1.0/60.0)
return pyglet.event.EVENT_HANDLED
def check_win_conditions(self):
if self.win_conditions.has_key('score'):
if self.score.points > self.win_conditions['score']:
self.win()
elif self.win_conditions.has_key('streak'):
if self.streak.streak >= self.win_conditions['streak']:
self.win()
elif self.win_conditions.has_key('time'):
if self.timer.time < 0:
self.win()
def on_update(self, dt):
self.camera.update(dt)
self.attaboy.update(dt)
self.atcg_display.update(dt)
self.check_win_conditions()
self.helix.update(dt)
if self.win_conditions.has_key('time'):
self.timer.update_time(dt)
def pause(self):
self.helix.obscure()
self.helix.update(0.1)
self.window.push_state(transitions.Pause, "game")
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0, 0, 1.0))
self.camera.subtle_motion = True
self.camera.subtle_range = (1.5, -1.5)
self.camera.subtle_speed = 0.04
self.attaboy = MsgQueue()
def build_scene(self):
self.quad = batch.get_batch().add(4, GL_QUADS, GRP_BLEND_ONE_MINUS, ("v3f", fade_quad), ("c4f", fade_color * 4))
self.camera = Camera((3.8, -18.0, 1.0), (3.8, 0, 1.0))
self.attaboy = MsgQueue()
class ScriptedTransition(State):
def __init__(self, window, *args, **kwargs):
print "++++ new level intro state"
script_name = kwargs["script_name"]
State.__init__(self, window, "scripted%s" % script_name, *args, **kwargs)
self.build_scene()
self.script = kwargs["script"][:]
self.running_text = False
self.band_pic = None
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0, 0, 1.0))
self.camera.subtle_motion = True
self.camera.subtle_range = (1.5, -1.5)
self.camera.subtle_speed = 0.04
self.attaboy = MsgQueue()
def destroy_scene(self):
pass
def on_key_press(self, k, args):
if k == key.F11:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
return pyglet.event.EVENT_HANDLED
def on_draw(self):
set3D(self.window)
self.window.clear()
glLoadIdentity()
self.camera.focus()
self.batch.draw()
set2D(self.window)
return pyglet.event.EVENT_HANDLED
def on_lose_focus(self):
pyglet.clock.unschedule(self.on_update)
self.destroy_scene()
return pyglet.event.EVENT_HANDLED
def on_gain_focus(self):
pyglet.clock.schedule_interval(self.on_update, 1.0 / 60.0)
return pyglet.event.EVENT_HANDLED
def on_update(self, dt):
self.camera.update(dt)
self.attaboy.update(dt)
if self.running_text:
if self.running_text.finished:
self.running_text = None
return pyglet.event.EVENT_HANDLED
else:
return pyglet.event.EVENT_HANDLED
elif self.band_pic:
if self.band_pic.finished:
self.band_pic.delete()
self.band_pic = None
return pyglet.event.EVENT_HANDLED
else:
self.band_pic.update(dt)
return pyglet.event.EVENT_HANDLED
if self.script:
s = self.script.pop(0)
if s[0] == "fade":
self.running_text = self.attaboy.add_centered_fade(*s[1])
elif s[0] == "game":
self.window.push_state(gamestate.GameState, s[1], s[2], s[3], s[4])
elif s[0] == "music":
if audio.playing():
audio.play_music_fade(s[1])
else:
audio.play_music(s[1])
elif s[0] == "main_menu":
self.window.replace_state(menustate.MainMenuState)
elif s[0] == "band_pic":
self.band_pic = AboutPic("./data/rsjf.png")
elif s[0] == "cc_pic":
self.band_pic = AboutPic("./data/ccsa.png")
else:
pass
# self.window.replace_state(self.next_state)
else:
# self.window.replace_state(self.next_state, **self.next_state_args)
self.window.pop_state()
return pyglet.event.EVENT_HANDLED
class Pause(State):
def __init__(self, window, *args, **kwargs):
print "++++ new pause state"
State.__init__(self, window, "pause", *args, **kwargs)
audio.attenuate_music()
self.menuloc = (-0.9, 1.0)
self.choices = {1: "resume", 2: "quit"}
self.choice = 1
self.old_state_batch = args[0]
self.build_scene()
def build_labels(self):
tl = []
x, z = self.menuloc
for c in self.choices.keys():
lx, lz = x, (z + (c * -0.4)) # + -0.6
l = self.attaboy.pulse(self.choices[c], 0.11, 1, (lx, -1, lz))
l.pause()
tl.append(l)
return tl
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0, 0, 1.0))
self.camera.subtle_motion = True
self.camera.subtle_range = (3.5, -3.5)
self.camera.subtle_speed = 0.04
self.attaboy = MsgQueue()
self.attaboy.pulse("pause", 0.25, 1, (-1.0, -1, 1)).pause(1)
self.labels = self.build_labels()
self.labels[0].unpause()
def destroy_scene(self):
pass
def on_draw(self):
set3D(self.window)
self.window.clear()
glLoadIdentity()
self.camera.focus()
batch.get_batch(self.old_state_batch).draw()
self.batch.draw()
set2D(self.window)
return pyglet.event.EVENT_HANDLED
def on_lose_focus(self):
pyglet.clock.unschedule(self.on_update)
self.destroy_scene()
return pyglet.event.EVENT_HANDLED
def on_gain_focus(self):
pyglet.clock.schedule_interval(self.on_update, 1.0 / 60.0)
return pyglet.event.EVENT_HANDLED
def on_update(self, dt):
self.camera.update(dt)
self.attaboy.update(dt)
def on_key_press(self, k, mod):
labels = self.labels
if k == key.UP:
if self.choice == 1:
labels[self.choice - 1].pause(1)
self.choice = len(self.choices)
labels[self.choice - 1].unpause()
else:
labels[self.choice - 1].pause(1)
self.choice -= 1
labels[self.choice - 1].unpause()
elif k == key.DOWN:
if self.choice == len(self.choices):
labels[self.choice - 1].pause(1)
self.choice = 1
labels[self.choice - 1].unpause()
else:
labels[self.choice - 1].pause(1)
self.choice += 1
labels[self.choice - 1].unpause()
elif k == key.ENTER:
if self.choice == 1:
audio.unattenuate_music()
self.destroy_scene()
self.window.pop_state()
elif self.choice == 2:
self.destroy_scene()
audio.play_music_fade("intro")
self.window.pop_state()
self.window.pop_state()
self.window.pop_state()
elif k == key.F11:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
elif k == key.ESCAPE:
audio.unattenuate_music()
self.destroy_scene()
self.window.pop_state()
# self.window.pop_state()
return pyglet.event.EVENT_HANDLED
def build_scene(self):
self.attaboy = MsgQueue()
self.menu = MainMenu()
self.camera = Camera((3.8, -18.0, 1.0), (3.8,0,1.0))
self.camera.subtle_motion = True
self.helix = Helix(starthgt=5, endhgt=-2, spawn_rate=0.5)
class MainMenuState (State):
def __init__(self, window, *args, **kwargs):
print "++++ new pause state"
State.__init__(self, window, "main_menu", *args, **kwargs)
self.build_scene()
def build_scene(self):
self.attaboy = MsgQueue()
self.menu = MainMenu()
self.camera = Camera((3.8, -18.0, 1.0), (3.8,0,1.0))
self.camera.subtle_motion = True
self.helix = Helix(starthgt=5, endhgt=-2, spawn_rate=0.5)
# for x in range(200):
# self.helix.anima(0.1)
def destroy_scene(self):
pass
def on_draw(self):
set3D(self.window)
self.window.clear()
glLoadIdentity()
self.camera.focus()
self.batch.draw()
set2D(self.window)
return pyglet.event.EVENT_HANDLED
def on_key_press(self, k, args):
if not self.menu.on_key_press(k, args):
return pyglet.event.EVENT_HANDLED
if k == key.ENTER:
if self.menu.choice == 1:
audio.play_music_fade('chill')
self.window.push_state(transitions.FadeOut, old_state="main_menu",
next_state=transitions.ScriptedTransition, duration=0.453,
next_state_args={ 'script': script.easy_levels, 'script_name': "easy"})
elif self.menu.choice == 2:
audio.play_music_fade('easy')
self.window.push_state(transitions.FadeOut, old_state="main_menu",
next_state=transitions.ScriptedTransition, duration=0.45,
next_state_args={ 'script': script.tutorial, 'script_name': "tutorial"})
elif self.menu.choice == 3:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
elif self.menu.choice == 4:
audio.play_music_fade('fast_groove')
self.window.push_state(transitions.FadeOut, old_state="main_menu",
next_state=transitions.ScriptedTransition, duration=0.45,
next_state_args={ 'script': script.about, 'script_name': "about"})
elif self.menu.choice == 5:
self.window.pop_state()
self.window.close()
#self.window.push_state(LevelIntroState, next_state=GameState, level=1)
elif k == key.F11:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
elif k == key.ESCAPE:
self.window.pop_state()
self.window.close()
else:
pass
return pyglet.event.EVENT_HANDLED
def on_gain_focus(self):
pyglet.clock.schedule_interval(self.on_update, 1.0/60.0)
return pyglet.event.EVENT_HANDLED
def on_lose_focus(self):
pyglet.clock.unschedule(self.on_update)
return pyglet.event.EVENT_HANDLED
def on_update(self, dt):
self.helix.update(dt)
self.menu.update(dt)
self.camera.update(dt)
self.attaboy.update(dt)
