def build(self):
global rootW, rootH
global unitW, unitH
global cx, cy
global clickSnd, wrongSnd
global fUpdateTime
global bButtonLock
fUpdateTime = 1.0/60.0
bButtonLock = False
clickSnd = SoundLoader.load("click.wav")
clickSnd.volume = 1.0
wrongSnd = SoundLoader.load("wrong.wav")
wrongSnd.volume = 1.0
rootW = Window.size[0]
rootH = Window.size[1]
unitW = rootW / 10.0
unitH = rootH / 10.0
cx = rootW / 2
cy = rootH / 2
self.bPopup = False
self.root = NumPuzzleRoot()
self.root.size = (rootW, rootH)
self.root.start()
self.bind(on_start = self.post_build_init)
return self.root
def __init__(self, sound=None):
super(KoalasMainWidget, self).__init__()
self.size = Window.size
self.start_menu = None
self.points = 0
self.liana_width = self.width / 15
liana = Image(x=self.width / 2 - self.liana_width / 2,
y=self.height,
source='img/koalas/Steble_01.png',
size=(self.liana_width, self.height),
)
self.add_widget(liana)
anim = Animation(x=liana.x, y=0, d=2)
anim.start(liana)
Clock.schedule_interval(self.__reduce_transparency, 0.05)
self.add_widget(StartMenu())
if sound:
self.sound = sound
else:
self.sound = SoundLoader.load('sound/koalas.ogg')
self.wrong_sound = SoundLoader.load('sound/wrong.ogg')
self.sound.loop = True
self.sound.play()
def setLevelImages(self):
random.shuffle(self.levelInfos[levelProps[0]])
random.shuffle(self.levelInfos[levelProps[1]])
self.ids.tool1.setImage(self.levelInfos[levelProps[0]][0][0])
self.ids.tool1.isGoal = self.levelInfos[levelProps[0]][0][1]
self.ids.tool2.setImage(self.levelInfos[levelProps[0]][1][0])
self.ids.tool2.isGoal = self.levelInfos[levelProps[0]][1][1]
self.ids.tool3.setImage(self.levelInfos[levelProps[0]][2][0])
self.ids.tool3.isGoal = self.levelInfos[levelProps[0]][2][1]
self.ids.person1.setImage(self.levelInfos[levelProps[1]][0][0])
self.ids.person1.isGoal = self.levelInfos[levelProps[1]][0][1]
self.ids.person2.setImage(self.levelInfos[levelProps[1]][1][0])
self.ids.person2.isGoal = self.levelInfos[levelProps[1]][1][1]
self.ids.person3.setImage(self.levelInfos[levelProps[1]][2][0])
self.ids.person3.isGoal = self.levelInfos[levelProps[1]][2][1]
self.ids.sceneImage.source = self.levelInfos[levelProps[2]]
self.winSound = SoundLoader.load(self.levelInfos[levelProps[4]])
self.failSound = SoundLoader.load('res/sounds/fail.wav')
def build(self): self.data_path = os.path.realpath(os.path.dirname(sys.argv[0])) + os.sep + "Data" + os.sep self.load_ether() #self.test() #self.solution() self.screenManager = ScreenManager(transition=FadeTransition()) self.splash = Splash(name="splash") self.menu = Menu(name="menu") self.help = Help(name="help") self.game = Game(name="game") self.screenManager.add_widget(self.splash) self.screenManager.add_widget(self.menu) self.screenManager.add_widget(self.help) self.screenManager.add_widget(self.game) sound_intro = SoundLoader.load(filename= self.data_path + '42286__erh__f-eh-angelic-3.ogg') self.sound_find = SoundLoader.load(filename= self.data_path + '30342__junggle__waterdrop25.ogg') sound_intro.play() self.showSplash() return self.screenManager
def __init__(self, **kwargs):
self.app = App.get_running_app()
self.app.pfish = self
self.eatsound = SoundLoader.load(self.app.path+'/eat.wav')
self.diesound = SoundLoader.load(self.app.path+'/die.wav')
super(PlayerFish, self).__init__(**kwargs)
Clock.schedule_interval(self.collision, 1/60.0)
def build(self):
self.sound = {}
self.title = 'DB Shooter'
from kivy.base import EventLoop
EventLoop.ensure_window()
self.window = EventLoop.window
# start the background music:
self.music = SoundLoader.load('sound/background.mp3')
self.music.volume = self.config.getint('General', 'Music') / 100.0
self.music.bind(on_stop=self.replaySound)
self.music.play()
# create the root widget and give it a reference of the view / application instance
self.MyViewController = MyViewController(app=self)
self.root = self.MyViewController.view
# load all other sounds:
self.sound['pop'] = SoundLoader.load('sound/pop.mp3')
self.sound['popping'] = SoundLoader.load('sound/popping.mp3')
self.sound['swoosh'] = SoundLoader.load('sound/swoosh.mp3')
sound_volume = self.config.getint('General', 'Sound') / 100.0
for item in self.sound:
self.sound[item].volume = sound_volume
# if the user started the game the first time, display quick start guide
if self.config.get('General', 'FirstStartup') == 'Yes':
Clock.schedule_once(self.displayHelpScreen,0)
self.config.set('General', 'FirstStartup', 'No')
self.config.write()
def __init__(self, *args, **kwargs):
super(ChiliTriosGame, self).__init__(*args, **kwargs)
# Create Menu
cmenu = Factory.ChiliMenu(chiligame=self)
cmenu.chiligame = self
self.menu = Popup(title='CHILI TRIOS', content=cmenu,
size_hint=(None, None), size=(400, 400),
title_size='18sp', separator_height='4dp',
separator_color=[0, 0.5, 1, 0.9],
auto_dismiss=False)
# Load sets and create menu buttons for each one.
sets = os.listdir('card_sets')
for n, i in enumerate(sets):
path = ''.join(['card_sets/', i])
set_name = i.split('.')[0]
self.sets_list.append([set_name, path])
# Add setbutton to menu
set_menubtn = Factory.SetButton(text=set_name.capitalize())
set_menubtn.set_id = n
self.menu.content.set_options.add_widget(set_menubtn)
self.menu.content.set_options.add_widget(
Factory.SetButton(text="Random")) # Random button
# Iinitialize Helpers.
Helper.chiligame = self
self.helpers = {
'show': self.showcards_helper, 'guess': self.guessobj_helper}
# Game sound effects
self.match_sound = SoundLoader.load('sound/match.ogg')
self.win_sound = SoundLoader.load('sound/win.ogg')
self.forbidden_sound = SoundLoader.load('sound/forbidden.ogg')
def cancel_timer(self):
SoundLoader.load('media/cancel.wav').play()
self.timer_is_running = False
self.timer_is_paused = False
Clock.unschedule(self._decrement_timer)
Clock.unschedule(self._stir_notification)
self.current_timer = 0
self.start_pause_resume_button.text = "Start Timer"
def __init__(self,*args,**kwargs):
super(Field,self).__init__(**kwargs)
self.crash_sound = SoundLoader.load("audio/crash.ogg")
self.speed_sound = SoundLoader.load("audio/car-run.ogg")
self.stop_sound = SoundLoader.load("audio/car-brake.ogg")
self.score_sound = SoundLoader.load("audio/score.ogg")
self.sounds = [self.crash_sound,self.speed_sound,self.stop_sound,
self.score_sound]
def loadMySound(self, iconFile):
key = iconFile.split(".png")[0].split(sep)[1]
if self.sounds.has_key(key):
self.mySound = SoundLoader.load(choice(self.sounds[key]))
else:
self.mySound = SoundLoader.load(choice(self.sounds['default']))
if self.mySound:
self.mySound.volume = 1.0
def __init__(self, game_manager=None, **kwargs):
super(GameWidget, self).__init__(**kwargs)
# Widget-related stuff
self.map_widget = None
self.log_widget = None
self.status_widget = None
# Connecting to manager
self.game_manager = game_manager
self.game_manager.game_widget = self
self.rebuild_widgets()
# Sound object
self.boombox = {'moved': SoundLoader.load('dshoof.wav'),
'attacked': SoundLoader.load('dspunch.wav'),
'exploded': SoundLoader.load('dsbarexp.wav'),
'shot': SoundLoader.load('dspistol.wav')}
# Sound in kivy seems to be loaded lazily. Files are not actually read until they are necessary,
# which leads to lags for up to half a second when a sound is used for the first time. The following
# two lines are forcing them to be loaded right now.
for sound in self.boombox.keys():
self.boombox[sound].seek(0)
# Keyboard controls
# Initializing keyboard bindings and key lists
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_key_down)
# Keys not in this list are ignored by _on_key_down
self.allowed_keys = [ # Movement
'spacebar', '.',
'h', 'j', 'k', 'l',
'y', 'u', 'b', 'n',
'up', 'down', 'left', 'right',
'numpad1', 'numpad2', 'numpad3', 'numpad4', 'numpad5',
'numpad6', 'numpad7', 'numpad8', 'numpad9', 'numpad0',
# PC stats viewctory.create_widget(a)
'c',
# Used for inventory & spell systems
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9',
# Inventory management
'g', ',', 'd', 'i',
# Targeted effects
'z', 'x', 'f',
# Others
'escape', 'enter', 'numpadenter']
# Keys in this list are processed by self.map_widget.map
self.map_keys = ['spacebar', '.',
'h', 'j', 'k', 'l',
'y', 'u', 'b', 'n',
'up', 'down', 'left', 'right',
'numpad1', 'numpad2', 'numpad3', 'numpad4', 'numpad5',
'numpad6', 'numpad7', 'numpad8', 'numpad9',
'g', ',']
self.key_parser = KeyParser()
# Game state
self.game_state = 'playing'
# Stuff for various game states
self.state_widget = None
self.target_coordinates = (None, None)
self.targeted_item_number = None
def init_sounds(self):
if self.pre_post_flag == 1:
self.phrases_A = ['growth_02_buffy',
'fixed_03_buffy',
'growth_04_buffy',
'fixed_05_buffy',
'fixed_07_buffy',
'growth_08_buffy',
'fixed_09_buffy',
'growth_10_buffy',
'fixed_11_buffy',
'growth_12_buffy']
self.phrases_B = ['fixed_02_fluffy',
'growth_03_fluffy',
'fixed_04_fluffy',
'growth_05_fluffy',
'growth_07_fluffy',
'fixed_08_fluffy',
'growth_09_fluffy',
'fixed_10_fluffy',
'growth_11_fluffy',
'fixed_12_fluffy']
elif self.pre_post_flag == 2:
self.phrases_A = ['fixed_01_buffy',
'growth_02_buffy',
'fixed_03_buffy',
'growth_04_buffy',
'growth_06_buffy',
'fixed_07_buffy',
'growth_08_buffy',
'fixed_13_buffy',
'growth_16_buffy',
'fixed_17_buffy']
self.phrases_B = ['growth_01_fluffy',
'fixed_02_fluffy',
'growth_03_fluffy',
'fixed_04_fluffy',
'fixed_06_fluffy',
'growth_07_fluffy',
'fixed_08_fluffy',
'growth_13_fluffy',
'fixed_16_fluffy',
'growth_17_fluffy']
self.number_of_questions = len(self.phrases_A)
self.question = 'which'
self.sound_question = SoundLoader.load("./sounds/" + self.question + ".wav")
self.intro1 = 'intro1'
self.sound_intro1 = SoundLoader.load("./sounds/" + self.intro1 + ".wav")
self.intro2 = 'intro2'
self.sound_intro2 = SoundLoader.load("./sounds/" + self.intro2 + ".wav")
self.sounds_A = []
self.sounds_B = []
for n in range(len(self.phrases_A)):
self.sounds_A.append(SoundLoader.load("./sounds/" + self.phrases_A[n] + ".wav"))
self.sounds_B.append(SoundLoader.load("./sounds/" + self.phrases_B[n] + ".wav"))
def __init__(self):
ret = super(Game, self).__init__()
self.sounds = dict()
self.sounds['firing'] = SoundLoader.load("sounds/firing.ogg")
self.sounds['enemy_death'] = SoundLoader.load("sounds/enemy_death.ogg")
self.sounds['game_over'] = SoundLoader.load("sounds/game_over.ogg")
self.top_points = 0
self.points = 0
self.reset_state()
return ret
def button_pressed(self, button):
if button.text == 'YES':
self.manager.current = 'main'
self.popup.dismiss()
else:
global CURRENT_PLAYER, AMOUNT, CURRENT1, SOME_LIST1
row, column = button.coords
status_index = row * 10 + column
already_played = self.status[status_index]
if not already_played and CURRENT_PLAYER == 1:
self.status[status_index] = CURRENT_PLAYER
for ship in SHIPS_OF_COMP:
if ship[0] == (row, column):
CURRENT1 += 1
SOME_LIST1.append((row, column))
button.background_color = ship[1]
#button.text = str(ship[2])
self.sound.stop()
self.sound = SoundLoader.load('bomb2.wav')
self.sound.play()
if CURRENT1 == ship[2]:
for ship in SOME_LIST1:
x, y = ship
s = [1, 0, -1]
t = [1, 0, -1]
for xx in s:
for yy in t:
for child in self.ids.grid.children:
if child.coords == (x + xx, y + yy) and (x + xx, y + yy) not in SOME_LIST1:
child.text = 'X'
child.background_color = [1, 0, 0, 1]
SOME_LIST1 = []
CURRENT1 = 0
AMOUNT += 1
if AMOUNT == 4 + 3 * 2 + 2 * 3 + 4:
Winner.play()
winner.children[0].text = 'You WIN!!!!!'
winner.bind(on_dismiss = self.somefunc)
winner.open()
break
if button.background_color == [1, 1, 1, 1]:
button.text = 'X'
self.sound.stop()
self.sound = SoundLoader.load('Not_ship.wav')
self.sound.play()
button.background_color = [1, 0, 0, 1]
Clock.schedule_once(self.callback, 1)
CURRENT_PLAYER *= -1
def __init__(self, app, *args, **kwargs):
super(ScreenOne, self).__init__(*args, **kwargs)
self.app = app
self.questions = ["44%6", "x*x = 4 so x is", "Largest Democracy in the World?", "When did World War 2 begin?", "Total no of kivy properties", "Planet with rings", "NYC", "Speed of light(km/s)"]
self.answers = [1, 3, 3, 2, 3, 2, 1, 2]
self.thunder = SL.load("static/lightning.wav")
self.rain_music = SL.load("static/rain.wav")
self.rain_music.loop = True
assert len(self.questions) == len(self.answers)
self.create_objects()
self.update()
def _initialize_sound(self):
"""
initializes and eventually starts the sound for the current step
:return:
True if everything is ok
False if the sound shouldn't / coundn't be started
"""
#Logger.debug("[{}]".format(self.seq_snds[self.idx_stp]))
if self.seq_snds[self.idx_stp] == "":
Logger.debug('_initialize_sound no sound played for step {}'.format(
self.idx_stp))
return False
else:
if self.seq_snds[self.idx_stp] == "default":
Logger.debug('_initialize_sound default sound for step {}\
({})'.format(self.idx_stp, self.default_snd))
self.sound = SoundLoader.load(self.default_snd)
else:
Logger.debug('_initialize_sound loading sound for step {}\
({})'.format(self.idx_stp, self.seq_snds[self.idx_stp]))
if os.path.exists(self.seq_snds[self.idx_stp]):
self.sound = self.seq_snds[self.idx_stp]
else:
self.sound = SoundLoader.load(os.path.join(self.base_seq_dir, self.seq_snds[self.idx_stp]))
if self.sound is None:
Logger.debug("_initialize_sound: not a valid sound for step {}: {}".format(
self.idx_stp, self.seq_snds[self.idx_stp]))
return False
elif self.sound.state == 'stop':
self.sound.play()
if platform == "android":
self.music_folder = "/sdcard/Music/PerAttivita" # ToDo: not good at all
self.time_sound_played = time.time() + int(os.path.basename(self.default_snd).split("_")[0])
# ToDo: eliminate this ugly condition
elif platform == "win":
self.music_folder = "C:\Mao\Progetti\Musica\MusicaSuNexus\PerAttivita" # ToDo: not good at all
self.time_sound_played = time.time() + self.sound.length
else:
self.music_folder = "." # ToDo: not good at all
self.time_sound_played = time.time()
#Logger.info("New sequence: Loading the mucis folder: {}".format(self.music_folder))
# self.sound_manager.scan_music_folder(self.music_folder)
# ToDo sound_manager
Logger.debug('activity_click: Sound {} end playing sound on{}. Sound\
length is {}. Now is{}'.format(self.sound.filename, self.time_sound_played,
self.sound.length, time.time()))
return True
else:
Logger.debug("activity_click: Sound in not expected state {} for step {}: {}".format(
self.sound.state,
self.idx_stp,
self.seq_snds[self.idx_stp]))
return False
def __init__(self, **kwargs):
super(CameraPreview, self).__init__(**kwargs)
self.bind(
preferred_picture_size=self.resolve_picture_size,
supported_picture_sizes=self.resolve_picture_size,
preferred_preview_size=self.resolve_preview_size,
supported_preview_sizes=self.resolve_preview_size,
autofocus_supported=self.update_focus_feature,
focus_areas_supported=self.update_focus_feature)
self.focus_move_sound = SoundLoader.load('sounds/camera-focusing.mp3')
self.focus_done_sound = SoundLoader.load('sounds/camera-focus-beep.mp3')
self.shutter_sound = SoundLoader.load('sounds/camera-shutter-click.mp3')
def __init__(self, *args, **kwargs):
super(GestureBoard, self).__init__()
self.gdb = GestureDatabase()
self.error_sound = SoundLoader.load('error.mp3')
self.success_sound = SoundLoader.load('success.mp3')
#Gestures
for key, ges in gestures.items():
self.gdb.add_gesture(ges)
self.sort_letter()
def __init__(self):
ret = super(Game, self).__init__()
Config.adddefaultsection('records')
Config.setdefault('records', 'top_points', '0')
self.sounds = dict()
self.sounds['firing'] = SoundLoader.load("sounds/firing.ogg")
self.sounds['enemy_death'] = SoundLoader.load("sounds/enemy_death.ogg")
self.sounds['game_over'] = SoundLoader.load("sounds/game_over.ogg")
self.top_points = int(Config.get('records', 'top_points'))
self.points = 0
self.reset_state()
return ret
def _type_a_letter(self, dt):
''' Types the next letter and plays a typewriter sound.
'''
# Play the sound
SoundLoader.load('9098__ddohler__typewriter.wav').play()
# Append the next letter
self.the_label.text += self.type_this[self.string_pos]
# Advance the position
self.string_pos += 1
# If there are more letters, schedule the next one at a random time
# between 0.25 and 0.75 seconds from now.
if self.string_pos < len(self.type_this):
Clock.schedule_once(self._type_a_letter,
random.uniform(0.25, 0.75))
def sound_control(self, which):
if which == 'create':
self.sound = SoundLoader.load("table_created.mp3")
elif which == 'insert':
self.sound = SoundLoader.load("data_inserted.mp3")
elif which == 'select':
self.sound = SoundLoader.load("data_selected.mp3")
else:
self.sound = SoundLoader.load("runtimeerror.mp3")
if self.sound.status != 'stop':
self.sound.stop()
if not self.mute_flag:
self.sound.play()
def init_track_data(self, track_name):
self.current_track_name = track_name
self.bands = Bands(track_name, track_manager.get_music_folder_path(), self.bands)
self.track_sound = SoundLoader.load(self.get_current_track_path())
self.sound_data = SoundData(self.get_current_track_path(), self.bands)
self.dance = Dance(self.sound_data, self.play_track, self.on_stop_dancing)
self.settings_group.reload(self.bands)
def get_message(self, msg):
self.print_message("playing: "+msg)
sound = SoundLoader.load("audio/"+msg)
if sound:
#print("Sound found at %s" % sound.source)
#print("Sound is %.3f seconds" % sound.length)
sound.play()
def load_sounds(self):
self.symbol_to_sound = QueryDict()
sound_ids = list('0123456789') + list(SOUND_ID_TO_SYMBOL)
for sound_id in sound_ids:
filename = SOUND_FILENAME_PATTERN.format(sound_id)
symbol = SOUND_ID_TO_SYMBOL.get(sound_id, sound_id)
self.symbol_to_sound[symbol] = SoundLoader.load(filename)
def lose_the_cow(self, cow):
sound = SoundLoader.load('sound/moo_%s.ogg' % random.randint(0, 2))
sound.play()
self.life -= 1
self.remove_widget(self.life_list[-1])
del self.life_list[-1]
self.cows[cow.index] = None
# self.cows = self.cows[:cow.index-1] + self.cows[cow.index:]
self.remove_widget(cow)
x = random.randint(0, Window.width - COW_WIDTH)
# c_w_e_c = False # Collides_with_existing_cow
# while not c_w_e_c:
# for cow_ in self.cows:
# if cow_ and cow_.collide_point(x):
# c_w_e_c = True
# x = random.randint(0, Window.width - COW_WIDTH)
# break
# c_w_e_c = True
self.add_cow(x, cow.index, True)
if self.life == 0:
self.game_over()
return
def start_screen(self):
"""Displays the start screen with the title and play button. Also sets the initial difficulty variables."""
self.clear_widgets()
#create the logo
self.logo = Label(text='Expression Collector',font_size=0.1*Window.height)
self.logo.center_x = Window.width/2
self.logo.center_y = Window.height/2
self.add_widget(self.logo)
#create the playbtn
self.playbtn = Button(text='play',font_size=0.05*Window.height,background_color=[0,0,0,0])
self.playbtn.center_x = Window.width/2
self.playbtn.center_y = Window.height/2 - 0.1*Window.height
self.playbtn.bind(on_release=self.play)
self.add_widget(self.playbtn)
#create the howtoplaybtn 100 px under the playbtn
self.howtoplaybtn = Button(text='how to play',font_size=0.05*Window.height,background_color=[0,0,0,0])
self.howtoplaybtn.center_x = Window.width/2
self.howtoplaybtn.center_y = self.playbtn.center_y - 100
self.howtoplaybtn.bind(on_release=self.howtoplay)
self.add_widget(self.howtoplaybtn)
#make bindings to make start screen fluid
Window.bind(size=self.adjust_start_widgets)
#create initial difficulty variables
self.MINUTE = 0 #it has been 0 minutes so far
self.MAX_NUMBER = 2 # the biggest number that can be part of an expression
self.MAX_LENGTH = 2 #the maximum number of numbers in an expression
self.AVAILABLE_OPERATORS = ['+','-'] #at first just + and - operators are available
self.sound = SoundLoader.load('startscreen.wav')
self.sound.loop = True
self.sound.play()
def PlaySound(uSoundName, fSoundVolume=-1):
''' plays a given sound with a given volume '''
try:
oTup = oORCA.oTheScreen.aSounds.get(uSoundName)
fVolume = fSoundVolume
if oTup:
uSoundFile = oTup[0]
SoundVolume = oTup[1]
if uSoundFile:
oSound = SoundLoader.load(uSoundFile)
aSounds[uSoundFile]=oSound
if oSound:
if oSound.status != 'stop':
oSound.stop()
if isinstance(fSoundVolume, string_types):
if fSoundVolume!=u'':
fVolume=ToFloat(fSoundVolume)
if not fVolume==-1 and not fVolume==u'':
fVolume=fVolume*SoundVolume
else:
fVolume=SoundVolume
oSound.volume=fVolume
#SoundLoader._set_volume(fVolume)
if fVolume>0:
oSound.play()
return True
except Exception as e:
LogError(u'Playing sound failed:'+uSoundName,e)
return False
def __init__(self, points=0):
super(CowStartMenu, self).__init__()
self.size = Window.size
if points == 0:
self.text = INVITE_TEXT
return
elif points >= 600:
self.text = 'Cows really love you.'
elif points >= 500:
self.text = 'Did you really play this game so long?'
elif points >= 400:
self.text = 'Impressing.'
elif points >= 300:
self.text = 'Great!'
elif points >= 200:
self.text = 'Good!'
elif points >= 100:
self.text = 'Nice!'
elif points < 100:
self.text = "It's okay."
self.sound = SoundLoader.load('sound/menu.ogg')
self.sound.volume = 0.2
self.sound.play()
self.text += ' %s points.\nAgain?' % points
def play(self,*args):
"""Goes from the start screen to the game screen. Creates the playerexpr, grid, and random Exprs."""
#Delete the logo and button
self.remove_widget(self.logo)
self.remove_widget(self.playbtn)
self.remove_widget(self.howtoplaybtn)
#Delete start screen music, load game music
self.sound.stop()
self.sound = SoundLoader.load('game.wav')
self.sound.loop = True
self.sound.play()
#create the grid
global grid
grid = Grid()
grid.adjust_grid() #Adjust/draw the grid to the initial window size
Window.bind(size=grid.adjust_grid) #bind Window.size -> grid.adjust_grid
self.add_widget(grid)
#create the playerexpr
global playerexpr
playerexpr = PlayerExpr(value=1,text='1',color=[1,1,1,1],font_size=grid.cell_height)
self.add_widget(playerexpr)
Clock.schedule_interval(playerexpr.check_collisions,1/30.0) #Check for collisions with PlayerExpr
Clock.schedule_interval(self.create_expr,2) #create Expr objects for the game
Clock.schedule_interval(self.make_harder,60) #make the game harder every 60 seconds
#play bindings
Window.bind(size=self.reposition_children) #bind window resizing to repositioning all of its children
def __init__(self, **kwargs):
super(RunivyGame, self).__init__(**kwargs)
self.ground = Image('data/ground.png').texture
self.ground.wrap = "repeat"
self.music = SoundLoader.load("data/music.mp3")
self.music.loop = True
self.music.play()
def start_sound(self, event):
self.timer = SoundLoader.load('./cartoon001.wav')
self.timer.play()
def play_sound(self):
global sound
sound = SoundLoader.load('theme_song.mp3')
if sound:
sound.play()
self.player.stop()
super(SoundGstplayer, self).stop()
def unload(self):
if self.player:
self.player.unload()
self.player = None
def seek(self, position):
self.player.seek(position / self.length)
def get_pos(self):
return self.player.get_position()
def _get_length(self):
return self.player.get_duration()
def on_volume(self, instance, volume):
self.player.set_volume(volume)
def _get_uri(self):
uri = self.filename
if not uri:
return
if not '://' in uri:
uri = 'file:' + pathname2url(realpath(uri))
return uri
SoundLoader.register(SoundGstplayer)
def btn_pressed(self, instance):
#здесь можно сделать рандом я знаю как
sound = SoundLoader.load('02036.mp3')
sound.play()
def Sound(self, index):
sound = SoundLoader.load('audio/%d.wav' % index)
if sound:
sound.play()
return True
def __init__(self, **kwargs):
super().__init__(**kwargs)
game_sounds = 'assets/sounds/Game/'
slug_sounds = 'assets/Sounds/Slugs Winning/'
# game
self.background_music = SoundLoader.load(game_sounds + 'Background Music.mp3')
self.slugs_running_sound = SoundLoader.load(game_sounds + 'Slugs Running.mp3')
self.gameover_sound = SoundLoader.load(game_sounds + 'Game Over.mp3')
self.go_sound = SoundLoader.load(game_sounds + 'Go.mp3')
# slugs
self.speedster.win_sound = SoundLoader.load(slug_sounds + 'Speedster Win.mp3')
self.trusty.win_sound = SoundLoader.load(slug_sounds + 'Trusty Win.mp3')
self.iffy.win_sound = SoundLoader.load(slug_sounds + 'Iffy Win.mp3')
self.slowpoke.win_sound = SoundLoader.load(slug_sounds + 'Slowpoke Win.mp3')
# default volumes
self.slugs_running_sound.volume = .2
self.go_sound.volume = .1
self.gameover_sound.volume = .1
# sounds
self.sounds = [self.background_music,
self.slugs_running_sound,
self.gameover_sound,
self.go_sound,
self.speedster.win_sound,
self.trusty.win_sound,
self.iffy.win_sound,
self.slowpoke.win_sound]
# background music
self.background_music.volume = .1
self.background_music.loop = True
self.background_music.play()
# accidents
self.acc_broken_leg = BrokenLegAccident()
self.acc_overheat = OverheatAccident()
self.acc_heart_attack = HeartAttackAccident()
self.acc_grass = GrassAccident()
self.acc_asleep = AsleepAccident()
self.acc_blind = BlindAccident()
self.acc_puddle = PuddleAccident()
self.acc_electroshock = ElectroshockAccident()
self.acc_turning_back = TurningBackAccident()
self.acc_shooting_eyes = ShootingEyesAccident()
self.acc_rubberized = RubberizedAccident()
self.acc_devoured = DevouredAccident()
self.accidents = [self.acc_broken_leg,
self.acc_overheat,
self.acc_heart_attack,
self.acc_grass,
self.acc_asleep,
self.acc_blind,
self.acc_puddle,
self.acc_electroshock,
self.acc_turning_back,
self.acc_shooting_eyes,
self.acc_rubberized,
self.acc_devoured]
from pprint import pprint
from kivymd.app import MDApp
from kivy.uix.boxlayout import BoxLayout
from kivymd.uix.list import OneLineListItem, TwoLineIconListItem, IconLeftWidget, OneLineIconListItem
from kivy.core.audio import SoundLoader
from audio_android import SoundAndroid
from collections import defaultdict
import os
SoundLoader.register(SoundAndroid)
class PlayerWindow(BoxLayout):
music_list = []
music_list2 = []
full = {}
playing = ''
directory = r'\Users\music-path'
def __init__(self, **kwargs):
super(PlayerWindow, self).__init__(**kwargs)
self.get_music(self.directory)
self.load_music()
def get_music(self, path):
for roots, directory, file in os.walk(path):
for mp3 in file:
if mp3.endswith('.mp3') or mp3.endswith('.m4a'):
def __init__(self, filename, count):
self.buf = [SoundLoader.load(filename) for i in range(count)]
class RLSinglePlayerView(Screen):
dictIndexToButtonName = {
1: "btn1",
2: "btn2",
3: "btn3",
4: "btn4",
5: "btn5",
6: "btn6",
7: "btn7",
8: "btn8",
9: "btn9"
}
soundClick = SoundLoader.load("assets/menu_selection_click.ogg")
state_space = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
game = TicTacToeGame()
player = Player("Player", "X")
enemy = RLBot("Computer", "O")
game.add_player([player, enemy])
player.start_first()
game.start()
def set_all_button_disable(self, isDisable):
for index in range(1, len(self.dictIndexToButtonName) + 1):
self.ids[self.dictIndexToButtonName[index]].disabled = isDisable
def set_all_button_text(self, value):
for index in range(1, len(self.dictIndexToButtonName) + 1):
self.ids[self.dictIndexToButtonName[index]].text = value
def restart_game(self):
self.game = TicTacToeGame()
self.player = Player("Human", "X")
self.enemy = RLBot("AI", "O")
self.game.add_player([self.player, self.enemy])
self.player.start_first()
self.game.start()
self.state_space = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
self.reset_button()
def reset_button(self):
self.set_all_button_text("")
self.set_all_button_disable(False)
def btnRestart_press(self, btn):
self.restart_game()
self.reset_button()
self.state_space = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
def btnMainMenu_press(self, btn):
self.restart_game()
self.manager.current = "selection"
def btnRLGame_press(self, btn):
if (self.soundClick):
self.soundClick.play()
if (not self.game.isOver):
if (self.player.isTurn):
selectedNum = 0
totalButton = len(self.dictIndexToButtonName)
for index in range(1, totalButton + 1):
if (btn == self.ids[self.dictIndexToButtonName[index]]):
selectedNum = index
break
self.player.pick(selectedNum)
self.game.remove_choice(selectedNum)
self.game.play(self.state_space, "X", selectedNum)
print("Human placed at :" + str(selectedNum))
btn.text = self.player.marking
btn.disabled = True
self.game.check_winner()
if (self.game.isHasWinner
or len(self.game.lstAvailableChoice) == 0):
self.game.over()
self.game.next_turn()
if (self.enemy.isTurn):
selectedNum = self.enemy.get_Predicted_Values(self.state_space)
if (selectedNum == 0):
self.game.over()
elif (selectedNum > 0):
self.game.play(self.state_space, "O", selectedNum)
print("AI placed at :" + str(selectedNum))
if (selectedNum > 0):
self.enemy.pick(selectedNum)
self.game.remove_choice(selectedNum)
self.ids[self.dictIndexToButtonName[
selectedNum]].text = self.enemy.marking
self.ids[self.dictIndexToButtonName[
selectedNum]].disabled = True
self.game.check_winner()
if (self.game.isHasWinner
or len(self.game.lstAvailableChoice) == 0):
self.game.over()
self.game.next_turn()
def btnRLGame_release(self, btn):
if (self.game.isOver):
self.set_all_button_disable(True)
boxLayout = BoxLayout(orientation="vertical")
dlgGameOver = Popup(title="Game Over",
size_hint=(None, None),
size=(500, 400),
auto_dismiss=False)
lblWinner = Label(text="")
lblWinner.font_size = 24
btnRestart = Button(text="Restart")
btnRestart.bind(on_press=self.btnRestart_press)
btnRestart.bind(on_release=dlgGameOver.dismiss)
btnMainMenu = Button(text="MainMenu")
btnMainMenu.bind(on_press=self.btnMainMenu_press)
btnMainMenu.bind(on_release=dlgGameOver.dismiss)
if (self.player.isWin):
lblWinner.text += "You won!"
elif (self.enemy.isWin):
lblWinner.text += "Yay!! I won"
else:
lblWinner.text = "Its a draw! Hmmm...."
boxLayout.add_widget(lblWinner)
boxLayout.add_widget(btnRestart)
boxLayout.add_widget(btnMainMenu)
dlgGameOver.content = boxLayout
dlgGameOver.open()
class PongGame(FloatLayout):
# sound 'test.wav')
past = [0, 0, 0]
inputlabel1 = NumericProperty(0)
inputlabel2 = NumericProperty(0)
inputlabel3 = NumericProperty(0)
Gvar0 = SoundLoader.load('g1.wav')
Gvar1 = SoundLoader.load('gis1.wav')
Gvar2 = SoundLoader.load('a1.wav')
Gvar3 = SoundLoader.load('ais1.wav')
Gvar4 = SoundLoader.load('b1.wav')
Gvar5 = SoundLoader.load('c2.wav')
Gvar6 = SoundLoader.load('cis2.wav')
Gvar7 = SoundLoader.load('d2.wav')
Gvar8 = SoundLoader.load('dis2.wav')
Gvar9 = SoundLoader.load('e2.wav')
Gvar10 = SoundLoader.load('f2.wav')
Gvar11 = SoundLoader.load('fis2.wav')
Gvar12 = SoundLoader.load('g2.wav')
#Gvar12 = Gvar0
#Gvar12.pitch=2
#var0 = SoundLoader.load( 'c2.wav')
#Cvar1 = SoundLoader.load( 'cis2.wav')
#Cvar2 = SoundLoader.load( 'd2.wav')
#Cvar3 = SoundLoader.load( 'dis2.wav')
#Cvar4 = SoundLoader.load( 'e2.wav')
#Cvar5 = SoundLoader.load( 'f2.wav')
#Cvar6 = SoundLoader.load( 'fis2.wav')
#Cvar7 = SoundLoader.load( 'g2.wav')
#Cvar8 = SoundLoader.load( 'gis2.wav')
#Cvar9 = SoundLoader.load( 'a2.wav')
#Cvar10 = SoundLoader.load( 'ais2.wav')
#Cvar11 = SoundLoader.load( 'b2.wav')
#Cvar12 = SoundLoader.load( 'c3.wav')
Dvar0 = SoundLoader.load('d2.wav')
Dvar1 = SoundLoader.load('dis2.wav')
Dvar2 = SoundLoader.load('e2.wav')
Dvar3 = SoundLoader.load('f2.wav')
Dvar4 = SoundLoader.load('fis2.wav')
Dvar5 = SoundLoader.load('g2.wav')
Dvar6 = SoundLoader.load('gis2.wav')
Dvar7 = SoundLoader.load('a2.wav')
Dvar8 = SoundLoader.load('ais2.wav')
Dvar9 = SoundLoader.load('b2.wav')
Dvar10 = SoundLoader.load('c3.wav')
Dvar11 = SoundLoader.load('cis3.wav')
Dvar12 = SoundLoader.load('d3.wav')
for i in range(0, 13):
exec('Gvar%s.loop=True' % (str(i)))
#exec('Cvar%s.loop=True'%(str(i)))
exec('Dvar%s.loop=True' % (str(i)))
Gvar0.play()
#Cvar0.play()
Dvar0.play()
# sound.seek(self.inputlabel1)
def update(self, dt):
if self.inputlabel1 != self.past[0]:
exec('self.Gvar%s.stop()' % (str(self.past[0])))
#for i in range(0,13):
# if int(i)!=int(self.inputlabel1):
# exec('try:self.Gvar%s.stop()\nexcept:pass'%(str(i)))
exec('self.Gvar%s.play()' % (str(int(self.inputlabel1))))
#if self.inputlabel2 != self.past[1]:
#exec('self.Cvar%s.stop()'%(str(self.past[1])))
#for i in range(0,13):
# if int(i)!=int(self.inputlabel2):
# exec('try:self.Cvar%s.stop()\nexcept:pass;'%(i))
#exec('self.Cvar%s.play()'%(str(int(self.inputlabel2))))
if self.inputlabel3 != self.past[2]:
exec('self.Dvar%s.stop()' % (str(self.past[2])))
#for i in range(0,13):
# if int(i)!=int(self.inputlabel3):
# exec('try:self.Dvar%s.stop()\nexcept:pass;'%(i))
exec('self.Dvar%s.play()' % (str(int(self.inputlabel3))))
self.past[0] = int(self.inputlabel1)
#self.past[1]=int(self.inputlabel2)
self.past[2] = int(self.inputlabel3)
def on_pause(self):
return True
def on_resume(self):
pass
def on_stop(self):
pass
# not working...
from kivy.core.audio import SoundLoader
sound = SoundLoader.load('../resources/fat.mp3')
if sound:
print("Sound found at %s" % sound.source)
print("Sound is %.3f seconds" % sound.length)
sound.play()
super(SoundAndroidPlayer, self).play()
def stop(self):
if not self._mediaplayer:
return
self._mediaplayer.stop()
self._mediaplayer.prepare()
def seek(self, position):
if not self._mediaplayer:
return
self._mediaplayer.seekTo(float(position) * 1000)
def get_pos(self):
if self._mediaplayer:
return self._mediaplayer.getCurrentPosition() / 1000.
return super(SoundAndroidPlayer, self).get_pos()
def on_volume(self, instance, volume):
if self._mediaplayer:
volume = float(volume)
self._mediaplayer.setVolume(volume, volume)
def _get_length(self):
if self._mediaplayer:
return self._mediaplayer.getDuration() / 1000.
return super(SoundAndroidPlayer, self)._get_length()
SoundLoader.register(SoundAndroidPlayer)
size: self.size
''')
# Load in the configuration options set from the main app
# TODO: Figure out how to load settings upon use, not load
# Consider moving it and its dependents into the run function
tw_config = ConfigParser()
tw_config.read('main.ini')
caesar_config = dict(tw_config.items('trainingwheels'))
print(caesar_config)
# Success audio setup
if path.exists(caesar_config['success_audio_path']):
print(caesar_config['success_audio_path'])
success_sound = SoundLoader.load(caesar_config['success_audio_path'])
if success_sound:
print('woohoo, success sound')
else:
print('doh, no sound')
# Failure audio setup
if path.exists(caesar_config['failure_audio_path']):
print(caesar_config['failure_audio_path'])
failure_sound = SoundLoader.load(caesar_config['failure_audio_path'])
if failure_sound:
print('woohoo, failure sound')
else:
print('doh, no sound')
# Initiate timing
def update_time(self, sec):
self.pomodoro_time -= 1
p_minutes, p_seconds = self.pomodoro_time // 60, self.pomodoro_time % 60
self.root.ids.time.text = (
'[color=#ffffff][b]%02d[/b]:[b]%02d[/b][/color]' %
(p_minutes, p_seconds))
if self.mode == 1 and self.pomodoro_time == 0:
if self.cycles == 3:
self.mode = 3
self.root.ids.time.text = '[color=#ffffff][b]20[/b]:[b]00[/b][/color]'
self.pomodoro_time = 1200
sound = SoundLoader.load('timer.ogg')
if sound:
sound.play()
else:
self.mode = 2
self.root.ids.time.text = '[color=#ffffff][b]05[/b]:[b]00[/b][/color]'
self.pomodoro_time = 300
sound = SoundLoader.load('timer.ogg')
if sound:
sound.play()
if self.mode == 2 and self.pomodoro_time == 0:
self.cycles = self.cycles + 1
self.mode = 1
self.root.ids.time.text = '[color=#ffffff][b]25[/b]:[b]00[/b][/color]'
self.pomodoro_time = 1500
sound = SoundLoader.load('timer.ogg')
if sound:
sound.play()
if self.mode == 3 and self.pomodoro_time == 0:
self.restart()
sound = SoundLoader.load('timer.ogg')
if sound:
sound.play()
if self.mode == 1:
self.root.ids.info.text = 'Time to work!'
self.root.ids.mode.text = 'Pomodoro'
self.root.ids.tabs.background_color = (0.898, 0.37, 0.34, 1)
self.root.ids.toolbar.md_bg_color = (0.858, 0.32, 0.30, 1)
self.root.ids.clr.col = (0.898, 0.37, 0.34, 1)
if self.mode == 2:
self.root.ids.info.text = 'Time for a break'
self.root.ids.mode.text = 'Short Break'
self.root.ids.tabs.background_color = (0.274, 0.55, 0.568, 1)
self.root.ids.toolbar.md_bg_color = (0.304, 0.58, 0.598, 1)
self.root.ids.clr.col = (0.274, 0.55, 0.568, 1)
self.root.ids.start_btn.disabled = True
self.root.ids.start_btn.opacity = 0
if self.mode == 3:
self.root.ids.info.text = 'Time for a break'
self.root.ids.mode.text = 'Long Break'
self.root.ids.tabs.background_color = (0.2627, 0.494, 0.65, 1)
self.root.ids.toolbar.md_bg_color = (0.2927, 0.524, 0.68, 1)
self.root.ids.clr.col = (0.2627, 0.494, 0.65, 1)
self.root.ids.start_btn.disabled = True
self.root.ids.start_btn.opacity = 0
def do_click(self, number):
filename = "Sounds/audio" + number + ".mp3"
sound = SoundLoader.load(filename)
sound.play()
def setup_ui(self):
layout = BoxLayout(orientation='vertical')
# 注意，你需要在当前目录放一个音乐文件并替换 a.mp3 这个名字为你的音乐文件
audio = SoundLoader.load('a.mp3')
audio.play()
return layout
def alarm_owner(self):
sound = SoundLoader.load('alert.wav')
sound.play()
class Enemy(Image):
sound = SoundLoader.load('Data/Sounds/killed_enemy.wav')
sound.volume = 0.1
sound.loop = False
def __init__(self, ai_settings, number):
super().__init__()
self.ai_settings = ai_settings
self.allow_stretch = True
self.keep_ratio = False
self.source = 'Data/Enemy/Enemy3.gif'
self.pos = (80, randrange(0, self.ai_settings.screen_height * 0.87))
self.size = (40, 50)
self.anim_delay = 0.05
self.health_points = 3
self.max_hp = self.health_points
self.speed = 1
self.damage = 1
self.style = 'Enemy'
self.level = number #Уровень зомби
#Вычисление статы зомби
if number <= 10:
self.speed = 1 + 0.1 * number
else:
self.speed += 1
self.max_hp += number - 10
self.health_points += number - 10
self.damage = 1 + int(
number / 10) #Для расчёта убытка для замка и урона по башням
self.price = 1 #деньги за зомби
self.income = 1 #Доход за зомби
self.hp = Image(source='Data/hp.png',
size=(15, 15),
center=(self.right - 40, self.top))
self.hp_label = Label(text=str(self.health_points),
font_size=16,
color=[.6, 0, 0, 1],
pos=(self.center_x - 10, self.top),
font_name='Data/MATURASC.TTF')
def update_position(self, bow_towers, magic_towers, frozen_enemies,
old_traps, traps):
'''Обновление позиции зомби'''
if self.check_enemy_freedom(frozen_enemies, old_traps, traps):
self.random_walk(bow_towers, magic_towers) #свободное блуждание
def check_enemy_freedom(self, frozen_enemies, old_traps, traps):
'''Проверяет не пойман ли враг в ловушку'''
if self in frozen_enemies:
return False
if len(traps) > 0: #Если ловушки есть
collisions_result = [
self not in trap.enemies for trap in old_traps
]
if collisions_result == [
True for i in range(len(old_traps))
]: #Проверяем нет ли врага среди пойманных
return True
else: #Если ловушек нет,
return True #то сразу возвращает True
def random_walk(self, bow_towers, magic_towers): #свободное блуждание
result1 = self.check_towers(
bow_towers) #Контактирует ли зомби с башнями лучников
result2 = self.check_towers(
magic_towers) #Контактирует ли зомби с магическими башнями
x_step = self.generate_x_step(result1, result2)
y_step = self.generate_y_step(result1, result2)
self.pos = (self.pos[0] + x_step, self.pos[1] + y_step)
def generate_x_step(self, result1, result2):
'''Генерирует шаг по x'''
s = self.speed
if ((result1 == False) or (result2 == False)):
s = 2
x_direction = -1 #направление
else:
x_direction = 1 #Очень низкий шанс идти назад.
x_distance = choice([
s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s,
s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s * 2,
s * 2
])
x_step = x_distance * x_direction / 2
return x_step
def generate_y_step(self, result1, result2):
'''Генерирует шаг по y'''
s = self.speed
y_direction = 1
if (result1 == False) or (result2 == False):
y_direction = -1
elif self.y < 0:
y_direction = 1
elif self.top > self.ai_settings.screen_height * 0.87: #компенсация доски
y_direction = -1
else:
y_direction = choice([-1, 1])
y_distance = s
y_step = y_distance * y_direction
return y_step
def check_towers(self, towers):
'''Проверяет коллизии с башнями, это определяет поведение зомби'''
if len(towers) > 0:
collisions_result = [
self.collide_widget(tower) for tower in towers
]
if collisions_result == [False for i in range(len(towers))]:
return True
else:
return False
else:
return True
def check_trap_collision(self, traps, old_traps):
'''Проверка коллизии врага и ловушки'''
for trap in traps:
if int(self.center_x) in range(
int(trap.x) + int(trap.width / 3),
int(trap.right) - int(trap.width / 3)) and int(
self.y) in range(int(trap.y), int(trap.top)):
trap.enemies.append(self) #Враг становится захваченным
trap.source = 'Data/Trap.gif' #Анимация закрытия
old_traps.append(trap) #Ловушка становится старой
traps.remove(trap) #Удаляется из списка ловушек
break
def initialize_speed(self):
if self.level <= 10:
self.speed = 1 + 0.1 * self.level
else:
self.speed += 1
def initialize_death(self, screen):
'''Изменения происходящие в случае смерти'''
self.source = 'Data/Enemy/EnemyDeath' + str(randint(1, 3)) + '.gif'
screen.remove_widget(self.hp) #удаление изображения хп врага
screen.remove_widget(self.hp_label) #удаление метки хп врага
self._avplayer.play()
super(SoundAvplayer, self).play()
def stop(self):
if not self._avplayer:
return
self._avplayer.stop()
super(SoundAvplayer, self).stop()
def seek(self, position):
if not self._avplayer:
return
self._avplayer.playAtTime_(float(position))
def get_pos(self):
if self._avplayer:
return self._avplayer.currentTime
return super(SoundAvplayer, self).get_pos()
def on_volume(self, instance, volume):
if self._avplayer:
self._avplayer.volume = float(volume)
def _get_length(self):
if self._avplayer:
return self._avplayer.duration
return super(SoundAvplayer, self)._get_length()
SoundLoader.register(SoundAvplayer)
def load_sounds(self):
self.sounds = {}
for i in range(3):
fname = 'sound' + str(1) + '.wav'
self.sounds[i] = SoundLoader.load(fname)
from kivy.utils import get_color_from_hex
class MultiAudio:
_next = 0
def __init__(self, filename, count):
self.buf = [SoundLoader.load(filename) for i in range(count)]
def play(self):
self.buf[self._next].play()
self._next = (self._next + 1) % len(self.buf)
snd_bump = MultiAudio('bump.wav', 4)
snd_game_over = SoundLoader.load('game_over.wav')
class BaseWidget(Widget):
def load_tileable(self, name):
t = Image('%s.png' % name).texture
t.wrap = 'repeat'
setattr(self, 'tx_%s' % name, t)
class Background(BaseWidget):
tx_floor = ObjectProperty(None)
tx_grass = ObjectProperty(None)
tx_cloud = ObjectProperty(None)
def set_background_size(self, t):
# create common animations
darkening_animation = Animation(opacity=0, duration=0.5)
lighting_animation = Animation(opacity=1.0, duration=0.5)
# get the live music events
live_music_events = update_live_music_events()
# create list to hold all the MyButton instances
all_buttons = []
# save the file path to the font used in a variable
font_path = 'Font/Raleway-Regular.ttf'
# load the app sounds
background_music = SoundLoader.load('Sounds/backgroundmusic.wav')
button_sound = SoundLoader.load('Sounds/buttonsound.wav')
# open the user_settings.json file and get the user settings
with open('user_settings.json') as fs:
json_data = json.load(fs)
last_setting = json_data.get('music_active')
previous_searches = json_data.get('user_searches')
last_today_search = previous_searches.get('search_today')
last_future_search = previous_searches.get('search_future')
# lower button sound
if button_sound:
button_sound.volume = 0.1
# loop background music, lower it's volume and if the last music setting is true, play the music
in dragBlockCore.py. To add new type of blocks change this file.
"""
from kivy.uix.relativelayout import RelativeLayout
from kivy.uix.boxlayout import BoxLayout
from kivy.core.audio import SoundLoader
from kivy.uix.label import Label
from kivy.uix.button import Button
from kivy.graphics import Rectangle
from kivy.graphics import Color
from kivy.uix.widget import Widget
from wifi import my_socket
from dragBlockCore import DragBlock
from random import randrange, shuffle
from kivy.app import App
play_sound_fail = SoundLoader.load('sounds/start_fail.wav')
play_sound_succes = SoundLoader.load('sounds/start_succes.wav')
class NumberBlock(DragBlock):
"""Block that works as number for blocks that can hold numbers.
Attributes:
counter (int): Current number in the block.
plusButton (Button): Button to add the current number.
minusButton (Button): Button to decrease the current number.
"""
def __init__(self, type, id, source_photo, size, style, **kwargs):
super(NumberBlock, self).__init__(type, id, source_photo, size, style,
**kwargs)
self.counter = 1
def build(self):
#обновление конфигураций при запуске приложения
self.config.set('val', 'first', 'RUB')
self.config.update_config('conv.ini')
self.config.set('val', 'second', 'USD')
self.config.update_config('conv.ini')
self.sound = SoundLoader.load('sound.wav') #звук нажатия кнопок
flt = FloatLayout(size_hint=(1, 1)) #основной виджет экрана
#виджеты располагаются в порядке сверху вниз
self.top_btn = Button(disabled=True,
size_hint=(1, .07),
background_color=(.42, .68, .87, 1),
background_disabled_normal='',
pos_hint={'top': 1},
text=self.text,
font_size='14sp',
font_name='arial.ttf')
flt.add_widget(self.top_btn)
#значения переводимой валюты и итог
bxl_btn = Button(size_hint=(1, .15),
pos_hint={'top': .90},
disabled=True,
background_color=(.42, .68, .87, 1),
background_disabled_normal='')
bxl = GridLayout(size_hint=(1, .15),
pos_hint={'top': .90},
cols=2,
rows=2)
x = Window.size[0] * 0.77
y = Window.size[1] * 0.066
self.lbl_1 = Label(text='0',
color=(.8, .8, .8, 1),
font_size='32sp',
font_name='MilanoFont.ttf',
size_hint=(.9, .5),
halign='left',
text_size=(x, y))
self.zn_1 = Label(text='₽', font_size='32sp', size_hint=(.1, .5))
self.lbl_2 = Label(text='0',
color=(.8, .8, .8, 1),
font_size='32sp',
font_name='MilanoFont.ttf',
size_hint=(.9, .5),
halign='left',
disabled=True,
text_size=(x, y))
self.zn_2 = Label(text='$', font_size='32sp', size_hint=(.1, .5))
bxl.add_widget(self.lbl_1)
bxl.add_widget(self.zn_1)
bxl.add_widget(self.lbl_2)
bxl.add_widget(self.zn_2)
flt.add_widget(bxl_btn)
flt.add_widget(bxl)
#левая выезжающая кнопка выбора валюты
self.l_btn = AnButt(size_hint=(1.01, .15),
pos_hint={
'top': .75,
'center_x': -.25
},
on_press=self.anim_l)
self.bx_l = BoxLayout(
size_hint=(1, .15), pos_hint={
'top': .75,
'center_x': -.25
}) #виджет, содержащий в себе отдельные кнопки валют
self.lb_1 = Label(size_hint=(.2, 1),
text='€',
color=(.9, .9, .9, 1),
font_size='28sp')
self.lb_2 = Label(size_hint=(.2, 1),
text='$',
color=(.9, .9, .9, 1),
font_size='28sp')
self.lb_3 = Label(size_hint=(.2, 1),
text='¥',
color=(.9, .9, .9, 1),
font_size='28sp')
self.lb_4 = Label(size_hint=(.2, 1),
text='£',
color=(.9, .9, .9, 1),
font_size='28sp')
self.lb_5 = Label(size_hint=(.2, 1), text='₽', font_size='28sp')
n = [self.lb_1, self.lb_2, self.lb_3, self.lb_4, self.lb_5]
for i in n:
self.bx_l.add_widget(i)
flt.add_widget(self.l_btn)
flt.add_widget(self.bx_l)
#правая выезжающая кнопка выбора валюты
self.r_btn = NaButt(size_hint=(1.01, .15),
pos_hint={
'top': .75,
'center_x': 1.25
},
on_press=self.anim_r)
self.bx_r = BoxLayout(size_hint=(1, .15),
pos_hint={
'top': .75,
'center_x': 1.25
})
self.rb_1 = Label(size_hint=(.2, 1), text='$', font_size='28sp')
self.rb_2 = Label(size_hint=(.2, 1),
text='₽',
color=(.9, .9, .9, 1),
font_size='28sp')
self.rb_3 = Label(size_hint=(.2, 1),
text='¥',
color=(.9, .9, .9, 1),
font_size='28sp')
self.rb_4 = Label(size_hint=(.2, 1),
text='£',
color=(.9, .9, .9, 1),
font_size='28sp')
self.rb_5 = Label(size_hint=(.2, 1),
text='€',
color=(.9, .9, .9, 1),
font_size='28sp')
n = [self.rb_1, self.rb_2, self.rb_3, self.rb_4, self.rb_5]
for i in n:
self.bx_r.add_widget(i)
flt.add_widget(self.r_btn)
flt.add_widget(self.bx_r)
#кнопка 'OK'
self.ok = Number(num='ok',
size_hint=(.2, .2),
pos_hint={
'center_x': 0.5,
'top': .67
},
on_press=self.ok_press)
flt.add_widget(self.ok)
#сетка калькулятора
self.grl = GridLayout(size_hint=(1, .45),
pos_hint={'top': .47},
cols=3,
rows=4,
spacing=10,
padding=-5)
self.grl.add_widget(
Number(num=7, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=8, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=9, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=4, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=5, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=6, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=1, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=2, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=3, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num='p', size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num=0, size_hint=(.3, .4), on_press=self.numbers))
self.grl.add_widget(
Number(num='b', size_hint=(.3, .4), on_press=self.numbers))
flt.add_widget(self.grl)
return flt
def unload(self):
self.stop()
self._data = None
def seek(self, position):
if not self._data:
return
if _platform == 'android' and self._channel:
self._channel.seek(position)
def get_pos(self):
if self._data is not None:
if _platform == 'android' and self._channel:
return self._channel.get_pos()
return mixer.music.get_pos()
return 0
def on_volume(self, instance, volume):
if self._data is not None:
self._data.set_volume(volume)
def _get_length(self):
if _platform == 'android' and self._channel:
return self._channel.get_length()
if self._data is not None:
return self._data.get_length()
return super(SoundPygame, self)._get_length()
SoundLoader.register(SoundPygame)
def build(self):
w = Widget()
file_n = "C:/Users/Jaggu/Downloads/07 - Savyasachi [NaaSong.Org].mp3"
file_n1 = AudioSegment.from_mp3(file_n)
file_name = "./output/in.wav"
file_n1.export(file_name, format="wav")
mono_wav, sampling_rate = librosa.load(file_name, duration=270)
stereo_wav, sampling_rate = librosa.load(file_name,
mono=False,
duration=270)
tempo, beat_frames = librosa.beat.beat_track(y=stereo_wav[0],
sr=sampling_rate)
length = mono_wav.shape[0]
#sample value that indicates transition
end_of_beat = int((tempo / 120) * sampling_rate)
#this is the rate the amplitude will increase by over
down_value = 0.17
amplitude_down_faster = np.linspace(1, down_value, 2 * end_of_beat)
amplitude_up_faster = np.linspace(down_value, 1, 2 * end_of_beat)
#make a seccond up and down that move differently
amplitude_down_slower = np.linspace(1, down_value, 4 * end_of_beat)
amplitude_up_slower = np.linspace(down_value, 1, 4 * end_of_beat)
#flag to determine if sound should be maintained
left_up = False
right_up = False
left_maintain = False
right_maintain = True
i = 0
while i < length - 4 * end_of_beat:
fast = np.random.choice([True, False])
#if left channel flagged to go up
if left_up:
if fast:
#turn left up and turn right down, with faster ramp
stereo_wav[0, i:i + (2 * end_of_beat)] = mono_wav[i:i + (
2 * end_of_beat)] * amplitude_up_faster
stereo_wav[1, i:i + (2 * end_of_beat)] = mono_wav[i:i + (
2 * end_of_beat)] * amplitude_down_faster
#set left maintain flag
left_up = False
#right_up = True
left_maintain = True
i += (2 * end_of_beat)
else:
#turn left up and right down, with slower ramp
stereo_wav[0, i:i + (4 * end_of_beat)] = mono_wav[i:i + (
4 * end_of_beat)] * amplitude_up_slower
stereo_wav[1, i:i + (4 * end_of_beat)] = mono_wav[i:i + (
4 * end_of_beat)] * amplitude_down_slower
#set left maintain flag
left_up = False
#right_up = True
left_maintain = True
i += (4 * end_of_beat)
#if right channel flagged to go up
elif right_up:
if fast:
#turn up right and turn down left
stereo_wav[1, i:i + (2 * end_of_beat)] = mono_wav[i:i + (
2 * end_of_beat)] * amplitude_up_faster
stereo_wav[0, i:i + (2 * end_of_beat)] = mono_wav[i:i + (
2 * end_of_beat)] * amplitude_down_faster
right_up = False
#left_up = True
right_maintain = True
i += (2 * end_of_beat)
else:
#turn up right and turn down left
stereo_wav[1, i:i + (4 * end_of_beat)] = mono_wav[i:i + (
4 * end_of_beat)] * amplitude_up_slower
stereo_wav[0, i:i + (4 * end_of_beat)] = mono_wav[i:i + (
4 * end_of_beat)] * amplitude_down_slower
right_up = False
#left_up = True
right_maintain = True
i += (4 * end_of_beat)
#if left channel flagged to stay constant
elif left_maintain:
stereo_wav[0, i:i + end_of_beat] = mono_wav[i:i + end_of_beat]
stereo_wav[1, i:i +
end_of_beat] = mono_wav[i:i +
end_of_beat] * down_value
right_up = True
left_maintain = False
i += end_of_beat
#maintain right channel for 1 bar
elif right_maintain:
stereo_wav[1, i:i + end_of_beat] = mono_wav[i:i + end_of_beat]
stereo_wav[0, i:i +
end_of_beat] = mono_wav[i:i +
end_of_beat] * down_value
right_maintain = False
left_up = True
i += end_of_beat
stereo_wav[0,
(length // (4 * end_of_beat)) * (4 * end_of_beat):] *= 0.25
stereo_wav[1,
(length // (4 * end_of_beat)) * (4 * end_of_beat):] *= 0.25
wav = stereo_wav
librosa.output.write_wav('./output/out.wav', wav, sampling_rate)
tfm = sox.Transformer()
tfm.treble(gain_db=5, slope=0.3)
tfm.bass(gain_db=5, slope=0.3)
tfm.build('./output/out.wav', './output/eff.wav')
sound = SoundLoader().load('./output/eff.wav')
if sound is not None:
sound.volume = 1
sound.play()
return w
reset4 = Animation(opacity=0)
reset4.start(self.root.ids.label4)
reset4.start(self.root.ids.hasil)
reset4.start(self.root.ids.label4)
reset4.start(self.root.ids.poin)
reset4.start(self.root.ids.label5)
reset4.start(self.root.ids.totalpoin)
anima1 = Animation(opacity=1, duration=4)
anima2 = Animation(opacity=1, duration=4.5)
anima3 = Animation(opacity=1, duration=5)
anima4 = Animation(opacity=1, duration=5.5)
anima5 = Animation(opacity=1, duration=6)
anima6 = Animation(opacity=1, duration=6.5)
anima7 = Animation(opacity=1, duration=7)
anima1.start(self.root.ids.title1)
anima2.start(self.root.ids.title2)
anima3.start(self.root.ids.title3)
anima4.start(self.root.ids.title4)
anima5.start(self.root.ids.title5)
anima6.start(self.root.ids.title6)
anima7.start(self.root.ids.title7)
if __name__ == '__main__':
sound = SoundLoader.load('./Voyage.wav')
sound.volume = 0.4
sound.loop = True
sound.play()
main().run()
def play_music(self):
self.sound = SoundLoader.load('Jesse_Cook-Dance_Of_Spring.ogg')
self.sound.play()
def __init__(self):
self.soundfile = 'sound/soft-bells.mp3'
self.sound = SoundLoader.load(self.soundfile)
def build(self):
sound = SoundLoader.load("nuclear-warning.mp3")
return Manager(sound)
