class ShipOrderFire(object):
messages = [
u"Let 'em have it!",
u"Fire!",
u"Give 'em a full broadside!",
]
SOUNDS = [
media('let_em_have_it.wav', streaming=False),
media('fire.wav', streaming=False),
media('give_em_full_broadside.wav', streaming=False),
]
def __init__(self):
self.message, self.sound = random.choice(zip(self.messages, self.SOUNDS))
def get_message(self, ship):
return self.message
def act(self, ship):
try:
self.sound.play()
except MediaException:
pass
ship.fire()
def __init__(self, number):
self.keysdown = []
self.controllable = False
self.entities = []
self.level = number
self.musicres = [[
resource.media('epikboss_INTRO.ogg'),
resource.media('epikboss_loop.wav')
]]
self.musicplayer = media.Player()
self.batch = graphics.Batch()
self.expsfx = media.Player()
self.expsfx.queue(World.explo)
self.expsfx.eos_action = "pause"
self.s1sfx = media.Player()
self.s1sfx.queue(World.s1)
self.s1sfx.eos_action = "pause"
self.s2sfx = media.Player()
self.s2sfx.queue(World.s2)
self.s2sfx.eos_action = "pause"
self.s3sfx = media.Player()
self.s3sfx.queue(World.s3)
self.s3sfx.eos_action = "pause"
self.layers = (pyglet.graphics.OrderedGroup(0),
pyglet.graphics.OrderedGroup(1),
pyglet.graphics.OrderedGroup(2),
pyglet.graphics.OrderedGroup(3),
pyglet.graphics.OrderedGroup(4))
self.ui = UI(self)
class SettingsMenu(Menu):
activate_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
select_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
def __init__(self):
super(SettingsMenu, self).__init__()
set_menu_theme(self)
# then add the items
self.home = MenuItem('Home', self.on_home)
self.fullscreen = MenuItem('Toggle Full Screen', self.on_fullscreen)
self.tutorial = MenuItem('Toggle Tutorial', self.on_tutorial)
self.items = [
(self.home),
(self.fullscreen),
(self.tutorial),
]
self.create_menu(self.items, zoom_in(), zoom_out())
def on_home(self):
if constants.MUSIC:
theme_player.stop()
director.pop()
def on_fullscreen(self):
director.window.set_fullscreen(not director.window.fullscreen)
def on_tutorial(self):
constants.SHOW_TUTORIAL = not constants.SHOW_TUTORIAL
class LevelMenu(Menu):
activate_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
select_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
def __init__(self,txt):
super(LevelMenu, self).__init__("Select Level")
class EndMenu(Menu):
activate_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
select_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
def __init__(self,txt,curLevel):
super(EndMenu, self).__init__("Game Over, You " + txt)
self.levelName = ""
self.level = curLevel
set_menu_theme(self)
self.ok = MenuItem("Back to Main Menu",director.pop)
if txt == "Lost":
self.retry = MenuItem("Retry Level", self.on_retry)
items = [(self.ok),(self.retry)]
self.levelName = "level"+str(curLevel)
elif curLevel <= 5:
self.win = MenuItem("Next Level", self.on_win)
items = [(self.ok),(self.win),]
self.levelName = "level"+str(curLevel+1)
else:
self.end_scene = MenuItem("You Fired Mr Winely!",director.pop)
items = [(self.ok),self.end_scene]
self.create_menu(items,ScaleTo(1.3, duration=0.2),ScaleTo(1.0, duration=0.2))
def on_win(self):
Objects.reset_game()
server = Objects.get_server(self.levelName)
server.curLevel = self.level+1
utils.play_sound("Enter.wav")
game = Scene(server.map, server)
game.add(ImageLayer(os.path.join("images", "backgrounds", "notebook-paper.png")), z=BACKGROUND_Z)
director.push(game)
menu_player.stop()
self.game_started = True
def on_retry(self):
Objects.reset_game()
server = Objects.get_server(self.levelName)
server.curLevel = self.level
utils.play_sound("Enter.wav")
game = Scene(server.map, server)
game.add(ImageLayer(os.path.join("images", "backgrounds", "notebook-paper.png")), z=BACKGROUND_Z)
director.push(game)
menu_player.stop()
self.game_started = True
def on_quit(self):
director.pop()
def __init__(self, songs):
"""The Music object will keep a playlist of songs, looping through them when played."""
super(Music, self).__init__()
for song in songs:
song = media(song)
self.queue(song)
self.songs = cycle(songs)
self.queue(media(self.songs.next()))
def make_sound(filename):
sound = resource.media(filename, streaming=False)
def vplay():
player = sound.play()
player.volume = sound_volume
return player
sound.vplay = vplay
return sound
def __init__(self, sounds):
"""Load sounds into memory for immediate playing."""
self.sounds = {}
for sound in sounds:
try:
self.sounds[sound] = media(sound, streaming=False)
except ResourceNotFoundException:
pass
def __init__(self):
self.sound_on = False
self.music_on = False
def make_sound(filename):
sound = resource.media(filename, streaming=False)
def vplay():
player = sound.play()
player.volume = sound_volume
return player
sound.vplay = vplay
return sound
self.click = make_sound("click.wav")
self.your_focus = make_sound("your_focus.wav")
self.opponent_focus = make_sound("opponent_focus.wav")
self.end_turn = make_sound("end_turn.wav")
self.start_combat = make_sound("combat.wav")
self.gamestart = make_sound("gamestart.wav")
self.gameover = make_sound("gameover.wav")
self.mana = make_sound("mana.wav")
self.manaspent = make_sound("manaspent.wav")
self.tap = make_sound("tap.wav")
#self.clink = make_sound("ding.wav")
#self.enter_sound = make_sound("card_entering_play.wav")
#self.leave_sound = make_sound("card_leaving_play.wav")
#self.play_ability = make_sound("play_ability.wav")
#self.untap = make_sound("untap.wav")
#self.lifeloss = make_sound("lifeloss.wav")
if toggle_music:
self.player = media.Player()
self.player.queue(resource.media(background_file, streaming=True))
self.player.eos_action = self.player.EOS_LOOP
else:
self.player = None
self.connections = [(self.gamestart, GameEvent.GameStartEvent()),
(self.gameover, GameEvent.GameOverEvent()),
(self.your_focus, GUIEvent.MyPriority()),
(self.opponent_focus, GUIEvent.OpponentPriority()),
(self.end_turn, GameEvent.NewTurnEvent()),
(self.start_combat, GameEvent.DeclareAttackersEvent()),
(self.tap, GameEvent.CardTapped()),
#(self.tap, GameEvent.CardUntapped()),
#(self.lifeloss, GameEvent.LifeLostEvent()),
#(self.mana, GameEvent.ManaAdded()),
(self.manaspent,GameEvent.ManaSpent()),
#(self.clink, GUIEvent.FocusCard(), sender=dispatcher.Anonymous, priority=dispatcher.UI_PRIORITY)),
#(self_ability, GameEvent.AbilityAnnounced()),
#(self.enter_sound, GameEvent.CardEnteredZone()),
#(self.leave_sound, GameEvent.CardLeftZone()),
]
class Sound:
resource.path.append("../res/sound")
resource.reindex()
try:
snd = resource.media("main_theme.mp3", streaming=False)
except Exception as e:
music = DummyPlayer()
print(e)
else:
music = media.Player()
music.queue(snd)
music.loop = True
sounds_name = [
"big_jump", "brick_smash", "bump", "coin", "death", "flagpole",
"game_over", "out_of_time", "powerup", "powerup_appears", "small_jump",
"stage_clear", "stomp"
]
sounds = defaultdict(DummyPlayer)
for sound in sounds_name:
try:
sounds[sound] = resource.media(sound + ".mp3", streaming=False)
except Exception as e:
print(e)
@classmethod
def play(cls, name):
if name == "mario":
cls.music.play()
else:
cls.sounds[name].play()
@classmethod
def stop(cls, name):
if name == "mario":
cls.music.pause()
class ShipOrderDecelerate(ShipOrderAccelerate):
messages = [
u'',
u"Ease off the mails'l!",
u"Ease off all sail!",
u"All stop!"
]
SOUND = media('ease_off_the_mainsl.wav', streaming=False)
def act(self, ship):
try:
self.SOUND.play()
except MediaException:
pass
ship.sail.set(max(0, ship.sail.target - 1))
class ShipOrderHelm(object):
messages = [
u'Rudder amidships!',
u'A little to {self.direction}!',
u'Turn to {self.direction}!',
u'Hard ta {self.direction}!'
]
SOUNDS = {
'centre': media('rudder_amidships.wav', streaming=False),
'port': [
media('a_little_to_port.wav', streaming=False),
media('turn_to_port.wav', streaming=False),
media('hard_to_port.wav', streaming=False),
],
'starboard': [
media('a_little_to_starboard.wav', streaming=False),
media('turn_to_starboard.wav', streaming=False),
media('hard_to_starboard.wav', streaming=False),
],
}
def __init__(self, direction, strength):
assert direction in ('port', 'starboard')
assert 0 <= strength <= 3
self.direction = direction
self.strength = -strength if direction == 'starboard' else strength
def get_message(self, ship):
return self.messages[abs(self.strength)].format(self=self)
def act(self, ship):
if self.strength == 0:
sound = self.SOUNDS['centre']
else:
sound = self.SOUNDS[self.direction][abs(self.strength) - 1]
try:
sound.play()
except MediaException:
pass
ship.helm.set(self.strength)
class ShipOrderAccelerate(object):
messages = [
u'',
u'A touch more sail!',
u'More sail!',
u'Give me every scrap of sail!',
]
SOUND = media('more_sail.wav', streaming=False)
def __init__(self, strength):
assert 0 <= strength <= 3
self.strength = strength
def get_message(self, ship):
return self.messages[self.strength].format(self=self)
def act(self, ship):
try:
self.SOUND.play()
except MediaException:
pass
ship.sail.set(min(3, ship.sail.target + 1))
class MainMenu(Menu):
activate_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
select_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
def __init__(self):
super(MainMenu, self).__init__('Noteworks')
set_menu_theme(self)
self.levelName = constants.DEFAULT_MAP
# then add the items
self.instructions = MenuItem('Instructions', self.on_intro)
self.space1 = MenuItem('', self.on_intro)
self.single = MenuItem('Single-Player', self.on_single_player)
self.space2 = MenuItem('', self.on_intro)
self.mult = MenuItem("Multi-Player", self.on_multi)
self.space3 = MenuItem('', self.on_intro)
self.level = EntryMenuItem("Level Name:",self.on_level,self.levelName)
self.space4 = MenuItem('', self.on_intro)
self.ip = EntryMenuItem("Server IP:",self.on_ip,constants.SERVER_IP)
self.space4 = MenuItem('', self.on_intro)
self.exit = MenuItem('Exit', self.on_quit)
self.items = [
(self.instructions),
#(self.space1),
(self.single),
#(self.space2),
(self.mult),
#(self.space3),
(self.level),
#(self.space4),
self.ip,
(self.exit),
]
self.create_menu(self.items, zoom_in(), zoom_out())
self.game_started = False
def on_intro(self):
utils.play_sound("Enter.wav")
image = os.path.join("images", "backgrounds", "notebook-paper.png")
director.push(Scene(Intro(image)))
def on_level(self,val):
self.levelName = str(val)
def on_ip(self,val):
constants.SERVER_IP = str(val)
def on_enter(self):
super(MainMenu, self).on_enter()
constants.MUSIC = True
menu_player.set_volume(2)
if self.game_started:
Objects.reset_game()
self.game_started = False
# buggy
# self.children[0][1].do(self.children[0][1].selected_effect) # making first item selected
def on_single_player(self):
Objects.get_server(self.levelName)
server = Objects.get_controller()
utils.play_sound("Enter.wav")
game = Scene(server.map, server)
game.add(ImageLayer(
os.path.join("images", "backgrounds", "notebook-paper.png")), z=BACKGROUND_Z)
director.push(game)
menu_player.stop()
self.game_started = True
# play_intro_animation(page_turn) #this is taking 2-3 seconds to load --Robert
# director.replace( FadeTransition(main_scene,2,page_turn) )
def on_quit(self):
from twisted.internet import reactor
reactor.stop()
director.pop()
def on_multi(self):
utils.play_sound("Enter.wav")
s = Scene(MultiplayerMenu(self.levelName))
s.add(ImageLayer(os.path.join("images", "backgrounds", "menu-chalkboard.png")))
director.push(s)
def init_globals():
global keys
keys = [
"GRAVE", "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9", "_0",
"MINUS", "EQUAL", "BACKSPACE", "TAB", "Q", "W", "E", "R", "T", "Y",
"U", "I", "O", "P", "BRACKETLEFT", "BRACKETRIGHT", "BACKSLASH",
"CAPSLOCK", "A", "S", "D", "F", "G", "H", "J", "K", "L", "SEMICOLON",
"APOSTROPHE", "ENTER", "LSHIFT", "Z", "X", "C", "V", "B", "N", "M",
"COMMA", "PERIOD", "SLASH", "RSHIFT"
]
pyglet.resource.path = ["assets/", "audio/"]
pyglet.resource.reindex()
with pyglet.resource.file("keyboard.json") as f:
data = json.loads(f.read())
global key_rects
key_rects = {
keys[i]: data["frames"][str(i)]["frame"]
for i in range(len(keys))
}
for key in keys:
key_rects[key]["y"] = 320 - key_rects[key]["y"] - key_rects[key]["h"]
global balls
balls = []
global trapped_balls
trapped_balls = []
global dead_balls
dead_balls = []
global ctrl_rect
ctrl_rect = data["frames"][str(len(data["frames"]) - 1)]["frame"]
ctrl_rect["y"] = 320 - ctrl_rect["y"] - ctrl_rect["h"]
global launcher_state
# [ctrl is pushed, frames it has been held, frames for 90+90deg]
launcher_state = [False, 0, 150]
global level_idx
level_idx = -1
global level
level = {"default": ["none"]}
global keys_pressed
keys_pressed = {key: False for key in keys}
global key_sounds
key_sounds = [
media("keyboard_%d.wav" % i, streaming=False) for i in range(1, 8)
]
global bounce_sounds
bounce_sounds = [
media("keyboard_%d.wav" % i, streaming=False) for i in range(1, 3)
]
global launch_sounds
launch_sounds = [
media("launch.wav", streaming=False),
media("launch_empty.wav", streaming=False)
]
global background_music_player
background_music_player = pyglet.media.Player()
background_music_player.volume = 0.025
background_music = [
media("Eva_soundtrack.wav", streaming=False),
media("DzGrimX_soundtrack.wav", streaming=False)
]
background_music_player.queue(background_music)
global moths
moths = []
global menuActive # 0 = game, 1 = title, 2 = tutorial
menuActive = 1
global dead_beachball_sprites
dead_beachball_sprites = []
global num_pressed
num_pressed = 0
explosion_images_image = resource.image('explosion.png')
explosion_images = pyglet.image.ImageGrid(explosion_images_image, 2, 8)
explosion_images = explosion_images.get_texture_sequence()
for explosion_image in explosion_images:
center_anchor(explosion_image)
explosion_animation = \
pyglet.image.Animation.from_image_sequence(explosion_images,
EXPLOSION_ANIMATION_PERIOD,
loop=False)
pointer_image = resource.image('pointer.png')
pointer_image.anchor_x = pointer_image.width // 2
pointer_image.anchor_y = pointer_image.height // 2
pointer_image_flip = resource.image('pointer.png', flip_x=True)
explosion_sound = resource.media('explosion.wav', streaming=False)
bullet_sound = resource.media('bullet.wav', streaming=False)
starfield = Starfield(resource.image('starfield.jpg'))
player = Player(resource.image('ship.png'), wrapping_batch)
win.push_handlers(player)
# --------------------------------------------------------------------------
# Global game state vars
# --------------------------------------------------------------------------
overlay = None
in_game = False
paused = False
score = 0
explosion_images_image = resource.image('explosion.png')
explosion_images = pyglet.image.ImageGrid(explosion_images_image, 2, 8)
explosion_images = explosion_images.get_texture_sequence()
map(center_anchor, explosion_images)
explosion_animation = \
pyglet.image.Animation.from_image_sequence(explosion_images,
EXPLOSION_ANIMATION_PERIOD,
loop=False)
pointer_image = resource.image('pointer.png')
pointer_image.anchor_x = pointer_image.width // 2
pointer_image.anchor_y = pointer_image.height // 2
pointer_image_flip = resource.image('pointer.png', flip_x=True)
explosion_sound = resource.media('explosion.wav', streaming=False)
bullet_sound = resource.media('bullet.wav', streaming=False)
starfield = Starfield(resource.image('starfield.jpg'))
player = Player(resource.image('ship.png'), wrapping_batch)
win.push_handlers(player)
# --------------------------------------------------------------------------
# Global game state vars
# --------------------------------------------------------------------------
overlay = None
in_game = False
paused = False
score = 0
else:
# Remove the new tail square because we didn't eat food.
tail.pop(0)
def game_over_condition():
# Collision with edge.
condition1 = snk_x + snk_dx < 0 or snk_x + snk_dx > window.width - cell_size or snk_y + snk_dy < 0 or snk_y + snk_dy > window.height - cell_size
# Collision with self.
condition2 = (snk_x, snk_y) in tail
return condition1 or condition2
# Setting streaming=false means we can play two eats at a time.
# Without this, eating two foods in quick succession can generate
# an error.
eat = resource.media('resources/eat_eff.wav', streaming=False)
crash = resource.media('resources/crash_eff.wav')
bgm1 = resource.media('resources/bgm1.wav')
bgm2 = resource.media('resources/bgm2.wav')
bgm3 = resource.media('resources/bgm3.wav')
bgm4 = resource.media('resources/bgm4.wav')
bgm5 = resource.media('resources/bgm5.wav')
playlist = cycle(
[bgm1, bgm2, bgm3, bgm4, bgm5]
) # itertools.cycle - list that loops back to the start when you reach the end
player = media.Player()
player.queue(playlist)
player.play()
# Not the length of the snake, but the width and height of a single snake segment.
class MultiplayerMenu(Menu):
activate_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
select_sound = media(
os.path.join('sounds', "Menu.wav"), streaming=False)
def __init__(self,levelName):
super(MultiplayerMenu, self).__init__('Multi-Player')
self.host = MenuItem("Start Server and Wait", self.new_game)
self.start = MenuItem("Finish Waiting, Start Game", self.start_game)
self.join = MenuItem("Join Game", self.join_game)
self.back = MenuItem("Back", self.on_quit)
self.levelName = levelName
items = [
(self.host),
(self.start),
(self.join),
(self.back),
]
set_menu_theme(self)
self.create_menu(items, zoom_in(), zoom_out())
self.game_started = False
def on_enter(self):
super(MultiplayerMenu, self).on_enter()
if self.game_started:
Objects.reset_game()
self.game_started = False
def new_game(self):
constants.MULTIPLAYER = True
utils.play_sound("Enter.wav")
Objects.get_server(self.levelName).start_server()
# start server and wait
def start_game(self):
constants.MULTIPLAYER = True
server = Objects.get_controller()
server.client_start_game()
if server.serverStarted:
utils.play_sound("Enter.wav")
game = Scene(server.map, server)
menu_player.stop()
game.add(ImageLayer(
os.path.join("images", "backgrounds", "notebook-paper.png")), z=BACKGROUND_Z)
director.push(game)
self.game_started = True
else:
print "start server first"
def join_game(self):
constants.MULTIPLAYER = True
utils.play_sound("Enter.wav")
c = Objects.get_client()
c.start_server() # start client server
connection = c.server_connect() # connect to game server
if not connection:
c.stop_server()
menu_player.stop()
self.game_started = True
def on_quit(self):
director.pop()
explosion_images_image = resource.image("explosion.png")
explosion_images = pyglet.image.ImageGrid(explosion_images_image, 2, 8)
explosion_images = explosion_images.get_texture_sequence()
for explosion_image in explosion_images:
center_anchor(explosion_image)
explosion_animation = pyglet.image.Animation.from_image_sequence(
explosion_images, EXPLOSION_ANIMATION_PERIOD, loop=False
)
pointer_image = resource.image("pointer.png")
pointer_image.anchor_x = pointer_image.width // 2
pointer_image.anchor_y = pointer_image.height // 2
pointer_image_flip = resource.image("pointer.png", flip_x=True)
explosion_sound = resource.media("explosion.wav", streaming=False)
bullet_sound = resource.media("bullet.wav", streaming=False)
starfield = Starfield(resource.image("starfield.png"))
player = Player(resource.image("ship.png"), wrapping_batch)
win.push_handlers(player)
# --------------------------------------------------------------------------
# Global game state vars
# --------------------------------------------------------------------------
overlay = None
in_game = False
paused = False
score = 0
ACCEL = 10
DECEL = 0.1
MAX_SPEED = 192
BULLET_SPEED = 288
BULLET_TIMEOUT = 10
DAMAGE = 5
SCREEN_W = 640
SCREEN_H = 480
FPS = 60.
PLAYER1_WIN_TEXT = 'Player-1 has won the battle!'
PLAYER2_WIN_TEXT = 'Player-2 has won the battle!'
graphics_batch = Batch()
bullets = []
snd_bullet = resource.media('zap1.wav', streaming=False)
snd_hit = resource.media('switch3.wav', streaming=False)
def load_pic(filename):
pic = resource.image(filename)
pic.anchor_x, pic.anchor_y = pic.width/2, pic.height/2
return pic
options = {
'pause': key.P,
'back': key.Q,
'p1_left': key.A,
'p1_up': key.W,
'p1_right': key.D,
'p1_down': key.S,
'p1_fire': key.SPACE,
def __init__(self):
return
self.click = resource.media("click.wav", streaming=False)
self.your_focus = resource.media("your_focus.wav", streaming=False)
self.opponent_focus = resource.media("opponent_focus.wav",
streaming=False)
self.end_turn = resource.media("end_turn.wav", streaming=False)
self.start_combat = resource.media("combat.wav", streaming=False)
self.gamestart = resource.media("gamestart.wav", streaming=False)
self.gameover = resource.media("gameover.wav", streaming=False)
self.mana = resource.media("mana.wav", streaming=False)
self.manaspent = resource.media("manaspent.wav", streaming=False)
self.tap = resource.media("tap.wav", streaming=False)
#self.clink = resource.media("ding.wav", streaming=False)
#self.enter_sound = resource.media("card_entering_play.wav", streaming=False)
#self.leave_sound = resource.media("card_leaving_play.wav", streaming=False)
#self.play_ability = resource.media("play_ability.wav", streaming=False)
#self.untap = resource.media("untap.wav", streaming=False)
#self.lifeloss = resource.media("lifeloss.wav", streaming=False)
self.player = media.Player()
self.player.queue(resource.media("background.ogg", streaming=True))
self.player.eos_action = self.player.EOS_LOOP
self.connections = [
(self.gamestart, GameEvent.GameStartEvent()),
(self.gameover, GameEvent.GameOverEvent()),
(self.your_focus, GUIEvent.MyPriority()),
(self.opponent_focus, GUIEvent.OpponentPriority()),
(self.end_turn, GameEvent.NewTurnEvent()),
(self.start_combat, GameEvent.DeclareAttackersEvent()),
(self.tap, GameEvent.CardTapped()),
#(self.tap, GameEvent.CardUntapped()),
#(self.lifeloss, GameEvent.LifeLostEvent()),
#(self.mana, GameEvent.ManaAdded()),
(self.manaspent, GameEvent.ManaSpent()),
#(self.clink, GUIEvent.FocusCard(), sender=dispatcher.Anonymous, priority=dispatcher.UI_PRIORITY)),
#(self_ability, GameEvent.AbilityAnnounced()),
#(self.enter_sound, GameEvent.CardEnteredZone()),
#(self.leave_sound, GameEvent.CardLeftZone()),
]
import pyglet
pyglet.options['audio'] = ('directsound', 'silent')
import pyglet.resource as res
import pyglet.media as md
res.path = ["res", "res/sound"]
res.reindex()
brick = res.image("bricks3.png")
# brick = res.image("brick-wall.png")
tree = res.image("beech.png")
pinetree = res.image("pine-tree2.png")
box = res.image("wooden-crate3.png")
player = res.image("gecko4.png")
player_down = res.image("gecko4.png", rotate=180)
player_left = res.image("gecko4.png", rotate=270)
player_right = res.image("gecko4.png", rotate=90)
target = res.image("boxtarget_2.png")
backmusic = res.media("backmusic.mp3", streaming=False)
def on_eos(self):
"""Ensure that the sound queue is looped."""
super(Music, self).on_eos()
self.queue(media(self.songs.next()))
def loadCurrentSong(self):
self.songText = self.allsongs[self.pos]
return resource.media("%s/%s" % (self.directory, self.songText))
def __init__(self, sound):
self.sound = media(sound, streaming=False)
#!/bin/python
from pyglet.resource import media
from pyglet.media import Player
player_fx_interact = Player()
player_fx_walk = Player()
player_music = Player()
player_ambience = Player()
player_fx_interact.volume = 0.8
player_fx_walk.volume = 0.3
player_music.volume = 0.1
player_ambience.volume = 0.8
player_ambience.pitch = 0.6
effects = {'player_respawn': media('assets/music/opengameart-org/magic-missile.wav', streaming=False),
'player_interact_block_dirt': media('assets/music/freesound-org/crunch1.wav', streaming=False),
'player_jump': media('assets/music/freesound-org/jump2.wav', streaming=False),
'player_walk': media('assets/music/opengameart-org/stepdirt_1.wav', streaming=False)
}
songs = {'nice1': media('assets/music/soundimage-org/monkey-island-band_looping.wav', streaming=False)
}
ambience = {'wind': [media('assets/music/opengameart-org/wind0.wav', streaming=False),
media('assets/music/opengameart-org/wind1.wav', streaming=False),
media('assets/music/opengameart-org/wind2.wav', streaming=False)]
}
def play(name):
med = media(name)
med.play()
sleep(med.duration - 0.3)
return med
def loadCurrentSong(self):
self.songText = self.allsongs[self.pos]
return resource.media("%s/%s" %(self.directory, self.songText))
def init_globals():
global keys
keys = [
"GRAVE", "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9", "_0",
"MINUS", "EQUAL", "BACKSPACE", "TAB", "Q", "W", "E", "R", "T", "Y",
"U", "I", "O", "P", "BRACKETLEFT", "BRACKETRIGHT", "BACKSLASH",
"CAPSLOCK", "A", "S", "D", "F", "G", "H", "J", "K", "L", "SEMICOLON",
"APOSTROPHE", "ENTER", "LSHIFT", "Z", "X", "C", "V", "B", "N", "M",
"COMMA", "PERIOD", "SLASH", "RSHIFT"
]
with open("assets/keyboard.json") as f:
data = json.loads(f.read())
global key_rects
key_rects = {
keys[i]: data["frames"][str(i)]["frame"]
for i in range(len(keys))
}
for key in keys:
key_rects[key]["y"] = 320 - key_rects[key]["y"] - key_rects[key]["h"]
global balls
balls = []
global trapped_balls
trapped_balls = []
global dead_balls
dead_balls = []
global ctrl_rect
ctrl_rect = data["frames"][str(len(data["frames"]) - 1)]["frame"]
ctrl_rect["y"] = 320 - ctrl_rect["y"] - ctrl_rect["h"]
global level_idx
level_idx = -1
global level
level = {"default": ["none"]}
global keys_pressed
keys_pressed = {key: False for key in keys}
global key_sounds
key_sounds = [
media("audio/keyboard_%d.wav" % i, streaming=False)
for i in range(1, 8)
]
global bounce_sounds
bounce_sounds = [
media("audio/keyboard_%d.wav" % i, streaming=False)
for i in range(1, 3)
]
global launch_sounds
launch_sounds = [
media("audio/launch.wav", streaming=False),
media("audio/launch_empty.wav", streaming=False)
]
global background_music_player
background_music_player = pyglet.media.Player()
background_music_player.volume = 0.01
background_music = [
media("audio/Eva_soundtrack.mp3", streaming=False),
media("audio/DzGrimX_soundtrack.mp3", streaming=False)
]
background_music_player.queue(background_music)
global moths
moths = []
def play_sound(filename):
if constants.SOUND and not constants.MULTIPLAYER:
sound = media(os.path.join('sounds', filename), streaming=False)
sound.play()
def __init__(self):
return
self.click = resource.media("click.wav", streaming=False)
self.your_focus = resource.media("your_focus.wav", streaming=False)
self.opponent_focus = resource.media("opponent_focus.wav", streaming=False)
self.end_turn = resource.media("end_turn.wav", streaming=False)
self.start_combat = resource.media("combat.wav", streaming=False)
self.gamestart = resource.media("gamestart.wav", streaming=False)
self.gameover = resource.media("gameover.wav", streaming=False)
self.mana = resource.media("mana.wav", streaming=False)
self.manaspent = resource.media("manaspent.wav", streaming=False)
self.tap = resource.media("tap.wav", streaming=False)
#self.clink = resource.media("ding.wav", streaming=False)
#self.enter_sound = resource.media("card_entering_play.wav", streaming=False)
#self.leave_sound = resource.media("card_leaving_play.wav", streaming=False)
#self.play_ability = resource.media("play_ability.wav", streaming=False)
#self.untap = resource.media("untap.wav", streaming=False)
#self.lifeloss = resource.media("lifeloss.wav", streaming=False)
self.player = media.Player()
self.player.queue(resource.media("background.ogg", streaming=True))
self.player.eos_action = self.player.EOS_LOOP
self.connections = [(self.gamestart, GameEvent.GameStartEvent()),
(self.gameover, GameEvent.GameOverEvent()),
(self.your_focus, GUIEvent.MyPriority()),
(self.opponent_focus, GUIEvent.OpponentPriority()),
(self.end_turn, GameEvent.NewTurnEvent()),
(self.start_combat, GameEvent.DeclareAttackersEvent()),
(self.tap, GameEvent.CardTapped()),
#(self.tap, GameEvent.CardUntapped()),
#(self.lifeloss, GameEvent.LifeLostEvent()),
#(self.mana, GameEvent.ManaAdded()),
(self.manaspent,GameEvent.ManaSpent()),
#(self.clink, GUIEvent.FocusCard(), sender=dispatcher.Anonymous, priority=dispatcher.UI_PRIORITY)),
#(self_ability, GameEvent.AbilityAnnounced()),
#(self.enter_sound, GameEvent.CardEnteredZone()),
#(self.leave_sound, GameEvent.CardLeftZone()),
]
def play_sound(filename):
if constants.SOUND and not constants.MULTIPLAYER:
sound = media(os.path.join('sounds', filename), streaming=False)
sound.play()
score_label_2 = Label('0',
font_size=48,
x = 3 * window.width/4,
y = window.height,
anchor_x = 'center',
anchor_y = 'top')
state = 'playing'
pause_label = Label('PAUSED',
font_size=36,
x = window.width/2,
y = window.height/2,
anchor_x = 'center', anchor_y = 'center')
bounce_sound = resource.media('sounds/bounce.wav', streaming=False)
goal_sound = resource.media('sounds/goal.wav', streaming=False)
music = resource.media('sounds/ride-the-storm.ogg')
music_player = Player()
music_player.queue(music)
music_player.volume = 0.5
music_player.eos_action = music_player.EOS_LOOP
music_player.play()
@window.event
def on_draw():
window.clear()
if state == 'playing' or state == 'scored':
ball.draw()
paddle1.draw()
class Ship(EventDispatcher, Positionable):
# Y up, -z forward
GUNS = {
'port': [
(Point3(1.17, 1.44, 1.47), Vector3(15, 0.2, 0)),
(Point3(1.17, 1.44, 0), Vector3(15, 0.2, 0)),
],
'starboard': [
(Point3(-1.17, 1.44, 1.47), Vector3(-15, 0.2, 0)),
(Point3(-1.17, 1.44, 0), Vector3(-15, 0.2, 0)),
],
}
SHAPES = [
Sphere(Point3(0, 1, z), 1.3)
for z in xrange(-3, 4)
]
WIND = Vector3(1, 0, 0)
MODELS = mast_models
SINKING_SOUND = media('bubble1.mp3', streaming=False)
CANNON_SOUND = media('cannon2.mp3', streaming=False)
faction = 1
def __init__(self, pos=Point3(0, 0, 0), angle=0, max_health=3):
super(Ship, self).__init__(pos)
self.model = GroupNode([
ModelNode(hull_model),
ModelNode(self.MODELS[0], pos=Point3(0, 1.18, 2.67)),
ModelNode(self.MODELS[3], pos=Point3(0, 1.08, 0.61)),
ModelNode(self.MODELS[6], pos=Point3(0, 1.18, -1.2)),
])
self.emitters = [WakeEmitter(self)]
self.body = Body(self, self.SHAPES)
self.angle = angle
self.helm = InterpolatingController(0)
self.sail = InterpolatingController(2) # amount of sail we have up
self.roll = 0.0
self.t = 0
self.last_broadside = 'port'
self.alive = True
self.health = self.max_health = max_health
def get_targets(self, lookahead=10, range=30):
"""Get a dictionary of potential targets on either side.
We look for targets that are within a distance of range units and up to
lookahead units ahead or astern of us.
"""
if not self.world:
return []
targets = {
'port': [],
'starboard': []
}
m = self.get_matrix()
forward = m * Vector3(0, 0, -1)
port = m * Vector3(1, 0, 0)
range2 = range * range
for o in self.world.objects:
if isinstance(o, Ship) and o is not self:
rel = o.pos - self.pos
if abs(rel.dot(forward)) < lookahead and rel.magnitude_squared() < range2:
side = 'port' if rel.dot(port) > 0 else 'starboard'
targets[side].append(o)
return targets
def fire(self):
"""Fire the cannons!
This is an automagical firing system that will work out whether either
side has a promising target. In the case that they both do, alternate
sides.
"""
if not self.alive:
return
targets = self.get_targets()
if bool(targets['port']) ^ bool(targets['starboard']):
side = 'port' if targets['port'] else 'starboard'
# print len(targets[side]), "targets to", side + " cap'n"
else:
side = 'port' if self.last_broadside == 'starboard' else 'starboard'
# print "Haven't fired to", side, "for a while"
# Fire one gun now, schedule the rest to fire over the next 0.5s
guns = range(len(self.GUNS[side]))
random.shuffle(guns)
num = guns.pop()
wpos = self.fire_gun(side, num)
for num in guns:
self.world.clock.schedule_once(
lambda dt, num: self.fire_gun(side, num),
random.uniform(0.0, 0.5),
num
)
self.last_broadside = side
self.world.spawn(MuzzleFlash(wpos))
def fire_gun(self, side, num):
pos, v = self.GUNS[side][num]
m = self.get_matrix()
v += Vector3(
0.0,
random.normalvariate(0.0, 0.2),
random.normalvariate(0.0, 0.2)
)
wvec = m * v
up = Vector3(0, 1, 0)
wvec -= up * 0.5 * wvec.dot(up)
wpos = m * pos
p = self.CANNON_SOUND.play()
p.position = wpos
self.world.spawn(Cannonball(wpos, wvec, owner=self))
spawn_smoke(wpos, wvec)
return wpos
def update_masts(self, sail):
hull, foremast, mainmast, mizzenmast = self.model.nodes
if sail < 0.7:
foremast.model_instance = self.MODELS[0]
elif sail < 2.3:
foremast.model_instance = self.MODELS[1]
else:
foremast.model_instance = self.MODELS[2]
if sail < 0.5:
mainmast.model_instance = self.MODELS[3]
elif sail < 1.5:
mainmast.model_instance = self.MODELS[4]
else:
mainmast.model_instance = self.MODELS[5]
if sail < 0.8:
mizzenmast.model_instance = self.MODELS[6]
elif sail < 2.0:
mizzenmast.model_instance = self.MODELS[7]
else:
mizzenmast.model_instance = self.MODELS[8]
def damage(self, amount=1):
"""Apply damage to this ship.
Return True if the ship was killed as a result.
"""
if not self.alive:
return False
self.health -= amount
if self.health <= 0:
self.kill()
return True
return False
def kill(self):
if self.alive:
p = self.SINKING_SOUND.play()
p.position = self.pos
self.alive = False
self.helm.set_immediate(0)
self.sail.set_immediate(0)
self.world.clock.schedule_once(
lambda dt: self.world.destroy(self), 7.0)
self.dispatch_event('on_death')
def get_quaternion(self):
"""Get the Quarternion of the ship's current heading."""
return Quaternion.new_rotate_axis(self.angle, Vector3(0, 1, 0))
def get_forward(self):
"""Get the forward unit vector."""
return self.get_quaternion() * Vector3(0, 0, 1)
def get_starboard(self):
"""Get the starboard unit vector."""
return self.get_quaternion() * Vector3(-1.0, 0, 0)
def get_wind_angle(self):
return map_angle(self.world.wind_angle - self.angle)
def update(self, dt):
self.t += dt
if self.alive:
self.helm.update(dt)
self.sail.update(dt)
self.update_masts(self.sail.current)
# damp roll
self.roll *= pow(0.6, dt)
# Compute some bobbing motion
rollmoment = 0.05 * sin(self.t)
pitch = 0.02 * sin(0.31 * self.t)
# Compute the forward vector from the curent heading
q = self.get_quaternion()
forward = q * Vector3(0, 0, 1)
angular_velocity = self.helm.current * min(forward.dot(self.vel), 2) * 0.03
angle_to_wind = map_angle(self.world.wind_angle - self.angle)
sail_power = get_sail_power(angle_to_wind)
heeling_moment = get_heeling_moment(angle_to_wind)
rollmoment += angular_velocity * 0.5 # lean over from centrifugal force of turn
rollmoment -= heeling_moment * 0.05 * self.sail.current # heel from wind force
# Update ship angle and position
self.angle = map_angle(self.angle + angular_velocity * dt)
accel = forward * self.sail.current * sail_power * 0.5 * dt
self.vel += accel
self.vel *= pow(0.7, dt) # Drag
self.pos += self.vel * dt
# Float
if self.alive:
self.pos += Vector3(0, -0.5, 0) * self.pos.y * dt
else:
self.pos += Vector3(0, -1, 0) * dt
self.roll += rollmoment * dt
# Apply ship angle and position to model
self.rot = (
q *
Quaternion.new_rotate_axis(pitch, Vector3(1, 0, 0)) *
Quaternion.new_rotate_axis(self.roll, Vector3(0, 0, 1))
)
rotangle, (rotx, roty, rotz) = self.rot.get_angle_axis()
self.model.rotation = (degrees(rotangle), rotx, roty, rotz)
self.model.pos = self.pos
# Adjust sail angle to wind direction
if self.alive:
sail_angle = get_sail_setting(angle_to_wind)
for sail in self.model.nodes[1:]:
sail.rotation = degrees(sail_angle), 0, 1, 0
