def update(self, dt):
# print(f"dt : {dt*60}")
time_factor = dt * 60
self.calculate_offset()
self.update_vertical_lines()
self.update_horizontal_lines()
self.update_tiles()
self.update_ship()
self.update_score()
if not self.state_game_over and self.state_game_started:
# vitesses relatives à la taille de l'écran'
speed_y = self.SPEED * self.height / 1000
speed_x = self.current_speed_x * self.width / 1000
self.current_offset_y += speed_y * time_factor
self.current_offset_x += speed_x * time_factor
while self.current_offset_y >= self.y_road_spacing:
self.current_offset_y -= self.y_road_spacing
self.current_y_loop += 1
self.generate_tiles_coordinates()
if not self.check_ship_collision() and not self.state_game_over:
print("GAME OVER")
self.menu_title = "GAME OVER"
self.menu_button_title = "RESTART"
self.state_game_over = True
self.menu_widget.opacity = 1
self.sound_music1.stop()
self.sound_gameover_impact.play()
# self.sound_gameover_impact.seek(0)
Clock.schedule_once(self.play_voice_game_over, 1)
def on_close_tab(self, instance, *args):
'''Event handler to close icon
:param instance: tab instance
'''
d = get_designer()
if d.popup:
return False
self.switch_to(instance)
if instance.has_modification:
# show a dialog to ask if can close
confirm_dlg = ConfirmationDialog(
'All unsaved changes will be lost.\n'
'Do you want to continue?')
popup = Popup(
title='New',
content=confirm_dlg,
size_hint=(None, None),
size=('200pt', '150pt'),
auto_dismiss=False)
def close_tab(*args):
d.close_popup()
self._perform_close_tab(instance)
confirm_dlg.bind(
on_ok=close_tab,
on_cancel=d.close_popup)
popup.open()
d.popup = popup
else:
Clock.schedule_once(partial(self._perform_close_tab, instance))
def __init__(self, **kwargs):
super(MainWidget, self).__init__(**kwargs)
# print(f"INIT W = {self.width} // H = {self.height}")
self.init_vertical_lines()
self.init_horizontal_lines()
self.current_offset_y = 0
self.current_offset_x = 0
self.current_speed_x = 0
self.current_y_loop = 0
self.init_audio()
self.state_game_started = False
self.state_game_over = False
self.init_tiles()
self.init_ship()
self.pre_fill_tiles_coordinates()
self.generate_tiles_coordinates()
if is_desktop():
self._keyboard = Window.request_keyboard(self._keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
self._keyboard.bind(on_key_up=self._on_keyboard_up)
Clock.schedule_interval(self.update, 1.0 / 60.)
self.sound_galaxy.play()
def buttonPlay(self):
"""再生ボタンクリック時"""
try:
if not Holder.getStatus() == "" and not Holder.getStatus(
) == "play":
# 再生中でなければ
try:
pygame.mixer.music.play(0, Holder.getSlideValue())
Clock.schedule_interval(self.position, 0.1)
self.image_play = "image/pause.png"
# self.sound_vlc.play()
# self.sound_vlc.set_time(int(Holder.getSlideValue() * 1000))
Holder.setStatus("play")
except:
pass
else:
Holder.setSlideValue(self.ids.slider.value)
pygame.mixer.music.pause()
self.image_play = "image/play.png"
# self.sound_vlc.pause()
Clock.unschedule(self.position)
Holder.setStatus("pause")
except:
pass
def callback1(self, dt):
if dt >= 0.9:
self.manager.get_screen('board1').popup.dismiss()
self.manager.current = 'board2'
else:
self.manager.get_screen('board1').popup.open()
Clock.schedule_once(self.callback1, 1)
def initiate_downloads(self, image_urls, *_):
global close_pools
close_pools = False
Clock.schedule_once(partial(self.preload, len(image_urls)), 0)
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
results = [
executor.submit(self.download_image, url, index)
for index, url in enumerate(image_urls)
]
for future in concurrent.futures.as_completed(results):
try:
if future.result() is None: break
image_byte = future.result()[0]
filename = future.result()[1]
index = future.result()[2]
if image_byte is not None:
print(f"Image Downloaded -> {filename}")
Clock.schedule_once(
partial(self.update_images, image_byte, filename,
index), 0)
except:
print("Some Download Exception...")
print(
f"All {len(image_urls)} tasks {'done' if not close_pools else 'cancelled'}."
)
def update(self, dt):
time_factor = dt * 60
self.update_vertical_lines()
self.update_horizontal_lines()
self.update_tiles()
self.update_ship()
if not self.state_game_over and self.state_game_start:
speed_y = self.SPEED * self.height / 100
self.current_offset_y += speed_y * time_factor
spacing_y = self.H_LINES_SPACING * self.height
while self.current_offset_y >= spacing_y:
self.current_offset_y -= spacing_y
self.current_y_loop += 1
self.score_txt = "SCORE: " + str(self.current_y_loop)
self.generate_tiles_cordinated()
speed_x = self.current_speed_x * self.width / 100
self.current_offset_x += speed_x * time_factor
if not self.check_ship_collision() and not self.state_game_over:
self.state_game_over = True
self.menu_title = "G A M E O V E R"
self.menu_button_title = "RESTART"
self.menu_widget.opacity = 1
self.sound_music1.stop()
self.sound_gameover_impact.play()
self.sound_voice.play()
Clock.schedule_once(self.play_game_over_voice_sound, 3)
print("Over")
def __init__(self, **kwargs):
super(NavigationDrawerLeftRightIconButton, self).__init__(**kwargs)
self._set_active_color()
self.theme_cls.bind(primary_color=self._set_active_color_primary,
accent_color=self._set_active_color_accent)
Clock.schedule_once(lambda x: self.on_left_icon(self, self.icon))
Clock.schedule_once(lambda x: self.on_right_icon(self, self.icon))
def keyboard_on_key_down(self, window, keycode, text, modifiers):
code, key = keycode
if (code not in (276, 273) and self.cursor_index() < self.prompt_pos) or \
(code == 8 and self.cursor_index() == self.prompt_pos):
self.cursor = self.get_cursor_from_index(self.prompt_pos)
return
if code == 13:
self.validate_cursor_pos()
text = self.text[self._cursor_pos:]
if text.strip().startswith('clear'):
self.text = ''
self._cursor_pos = 0
self.prompt()
return
elif text.strip():
Clock.schedule_once(partial(self._run_cmd, text))
else:
Clock.schedule_once(self.prompt)
elif code in [8, 127]:
self.cancel_selection()
elif code == 99 and modifiers == ['ctrl']:
self.cancel_selection()
return super().keyboard_on_key_down(window, keycode, text, modifiers)
def keyboard_on_key_down(self, window: Keyboard, keycode: Tuple[int, str],
text: str,
modifiers: ObservableList) -> Union[None, bool]:
"""
Captures specific key presses
and executes accordingly.
"""
if keycode[0] in KEYS['enter']:
self.validate_cursor_pos()
text = self.text[self._cursor_pos - 1:]
if text.strip():
Clock.schedule_once(partial(self._run_cmd, text))
else:
Clock.schedule_once(self.prompt)
elif keycode[0] in KEYS['del', 'backspace']:
self.cancel_selection()
elif keycode[0] in KEYS['c'] and 'ctrl' in modifiers:
self.shell.stop()
if self.cursor_index() < self._cursor_pos:
return False
return super(TerminalInput,
self).keyboard_on_key_down(window, keycode, text,
modifiers)
def search(self, keyword, source):
cancel_search = True
self.search_list.data = []
scraper = MangaScraper(source)
mangas = scraper.search_online(keyword)
Clock.schedule_once(partial(self.update_search_list, mangas, source), 1)
def __init__(self, **kwargs):
super(LatestView, self).__init__(**kwargs)
Logger.info('LatestView: Initialized {}'.format(self))
Clock.schedule_once(self.pr, 9)
self.connn = Connector()
def refresh_callback(self, *args):
def refresh_callback(interval):
self.ids.box.clear_widgets()
self.set_list()
self.ids.refresh_layout.refresh_done()
self.tick = 0
Clock.schedule_once(refresh_callback, 1)
def init_game(self, mode):
game = Game()
controller = Controller(game)
ai = AI(game)
first_player = Player(PieceColor.WHITE, controller,
ai if mode == GameMode.AI_VS_HUMAN else None)
second_player = Player(PieceColor.BLACK, controller,
ai if mode == GameMode.HUMAN_VS_AI else None)
players = [first_player, second_player]
game_board = GameBoardWidget(game)
for player in players:
if player.type == PlayerType.HUMAN:
game_board.move_receive_from_ui.append(
player.move_receive_from_ui_handler)
if first_player.type == PlayerType.AI:
first_player.move_complete_event(PieceColor.BLACK)
Clock.schedule_interval(lambda delta_time: game_board.update(), 0.03)
self.clear_widgets()
game_widget = GameWidget(game)
size = (game_board.width, game_board.height + 50)
game_widget.size = size
Window.size = size
game_widget.set_game_board(game_board)
self.add_widget(game_widget)
def __init__(self, capteur, titre="", **kvargs):
super().__init__(**kvargs)
self.g = []
self.titre = titre
self.L = 300
self.H = 200
self.graphX = []
self.graphY = []
self.y_mid = self.H / 2
self.capteur = capteur
self.label_titre = Label(text=self.titre,
color=(1, 0.5, 0),
text_size=(self.width, self.height),
size_hint=(1, 2),
padding_y=0)
self.add_widget(self.label_titre)
Clock.schedule_interval(self.update, FREQ)
self.temps = 0
pas = int(300/10*FREQ)
# pas = 3
max_graph = int(10/FREQ)
# max_graph = 90
if self.capteur.nom == "Altitude":
for i in range(0, max_graph):
self.graphX.append(pas*i)
self.graphY.append(0)
else:
for i in range(0, max_graph):
self.graphX.append(pas*i)
# pas*i = 89*3 =
self.graphY.append(self.y_mid)
def on_enter(self):
global ENTRY_PLAYER
if ENTRY_PLAYER == 0:
MAIN_SOUND.stop()
ENTRY_PLAYER = 1
self.ids.grid.top = 760
self.ids.grid.right = 1350
for i in range(NUMBER_OF_BUTTONS):
for j in range(NUMBER_OF_BUTTONS):
button = Button(text="")
button.size_hint = (100, 100)
button.coords = (i, j)
button.bind(on_press=self.button_pressed)
for ship in SHIPS_OF_PLAYER:
if ship[0] == (i, j):
button.background_color = ship[1]
button.name = str(ship[2])
self.ids.grid.add_widget(button)
self.manager.current = 'board2'
self.popup.open()
Clock.schedule_once(self.callback, 1.5)
def on_touch_up(self, touch):
if self.inspection_entity is not None:
Clock.unschedule(self.show_inspection)
if self.inspection_entity.is_enemy():
if self.ids.move_hud.move_hud_open:
# If the move hud is open, we are specifiying a single target
self.characters_targeting[
self.ids.move_hud.index_open] = self.inspection_entity
self.animate_targeting_circle(self.inspection_entity)
self.target_specified = False
else:
if not self.target_specified or self.inspection_entity != self.characters_targeting[
0]:
self.target_specified = True
self.animate_targeting_circle(self.inspection_entity)
for index in range(len(self.characters_targeting)):
self.characters_targeting[
index] = self.inspection_entity
elif self.inspection_entity == self.characters_targeting[
0]:
self.target_specified = False
self.ids.targeting_circle.opacity = 0
self.inspection_entity = None
result = super().on_touch_up(touch)
return result
def on_text(self, *args):
'''updates the tab width when it has a new title
'''
def update_width(*args):
self.width = min(self.texture_size[0] + 40, 200)
Clock.schedule_once(update_width)
def add_label(self, dt):
label = Label(text='Are you excited?\nBeacuse I do!', font_name='Ubuntu-C.ttf', color=[0,0,0,1],
size_hint=(0.8, 0.2),valign='center', halign='center', pos_hint={"x":0.1, "y":0}, font_size=self.width/10)
self.manager.ids.loading_screen.add_widget(label)
Clock.schedule_once(lambda d: self.manager.ids.loading_screen.remove_widget(label), 5)
def on_close_tab(self, instance, *args):
'''Event handler to close icon
:param instance: tab instance
'''
d = get_designer()
if d.popup:
return False
self.switch_to(instance)
if instance.has_modification:
# show a dialog to ask if can close
confirm_dlg = ConfirmationDialog(
'All unsaved changes will be lost.\n'
'Do you want to continue?')
popup = Popup(title='New',
content=confirm_dlg,
size_hint=(None, None),
size=('200pt', '150pt'),
auto_dismiss=False)
def close_tab(*args):
d.close_popup()
self._perform_close_tab(instance)
confirm_dlg.bind(on_ok=close_tab, on_cancel=d.close_popup)
popup.open()
d.popup = popup
else:
Clock.schedule_once(partial(self._perform_close_tab, instance))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.rw = RootWidget(gameStatus='Not Completed')
self.add_widget(self.rw)
# call update() every second
#Clock.schedule_interval(self.rw.update, 1.0)
Clock.schedule_interval(self.update, 1.0)
def update(self, obj):
if self.rw.gameStatus == 'Completed':
Clock.unschedule(self.update)
self.rw.clear_widgets()
self.manager.current = 'optionscreen'
else:
self.rw.update(self.rw)
def toggle_play_state(self):
app = App.get_running_app()
is_playing = app.play_state == "play"
if is_playing:
task = lambda x: setattr(App.get_running_app(), "play_state", "pause")
else:
task = lambda x: setattr(App.get_running_app(), "play_state", "play")
Clock.schedule_once(task, 0.1)
def __init__(self, nom=""):
try:
self.ser = serial.Serial('/dev/cu.usbmodem1411', 9600)
except:
print("no reception")
self.nom = nom
self.data = .0
Clock.schedule_interval(self.recepteur_update, FREQ)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.ball_size = dp(50)
self.vx = dp(10)
self.vy = dp(10)
with self.canvas:
self.ball = Ellipse(pos=(100, 100), size=(self.ball_size, self.ball_size))
Clock.schedule_interval(self.update, 1/60)
def on_text(self, *args):
"""updates the tab width when it has a new title
"""
def update_width(*args):
self.width = min(self.texture_size[0] + 40, 200)
Clock.schedule_once(update_width)
def on_reset(self):
self.root.msg_text = "Victory!"
self.root.popup_label.text = "Victory!\nTouch to start"
self.root.popup.open()
Clock.unschedule(self.counting)
self.root.score += int(1.0 / ((self.root.clock_time / 60.0)**2 + 1) *
20)
self.root.clock_time = 0
self.should_restart = True
def on_slider_value(self, widget):
print("Slider value: " + str(widget.value))
self.slider_value = int(widget.value)
# stop scheduler
Clock.unschedule(
self.event) # https://kivy.org/doc/stable/api-kivy.clock.html
# restart scheduler at a new speed if cursor > 0
if self.slider_value > 0:
self.start()
def _add(self, route):
"""Adds the route unless there is a path conflict"""
if route.path in self._routes:
raise Exception("Route path must be unique")
self._routes[route.path] = route
super(Router, self).add_widget(route)
if route.path == self.selected_route:
Clock.schedule_once(lambda *_: self._set_current_route(route.path),
0)
def __init__(self, recepteur, **kwargs):
super().__init__(**kwargs)
Clock.schedule_interval(self.update_controle_tir, .1)
self.launch_time = None
self.date_since_launch = None
self.recepteur = recepteur
self.feu_reception = RelativeLayout()
self.feu_reception.add_widget(Label(text="Reception:"))
self.add_widget(self.feu_reception)
def build(self):
self.plot.points = [(point[0], point[1]) for point in
self.eog.gesture_list]
# self.plot.points = [(x, sin(x / 100.)) for x in range(self.counter,
# self.counter + 10)]
self.graph.add_plot(self.plot)
Clock.schedule_interval(self.update, 1.0 / 60.0)
return self.graph
def animations(self, dt):
self.manager.current = 'loading'
anim_big = Animation(angle=10800, duration=250)
anim_small = Animation(angle=-10800, duration=500)
anim_big.start(self.manager.ids.loading_screen.ids.big)
anim_small.start(self.manager.ids.loading_screen.ids.small)
Clock.schedule_once(self.add_label, 5)
def build(self):
self.plot.points = [(point[0], point[1]) for point in
self.user.userECG.ecgListFFT]
# self.plot.points = [(x, sin(x / 100.)) for x in range(self.counter,
# self.counter + 10)]
self.graph.add_plot(self.plot)
Clock.schedule_interval(self.update, 1.0 / 60.0)
return self.graph
def on_touch_down(self, touch):
if self.opacity == 0:
return False
if self.disabled:
return False
if super().on_touch_down(touch):
Clock.schedule_once(self.show_description, 0.3)
if self.state == 'down':
return True
return False
def __init__(self, avatar, **kwargs):
if not avatar:
if kwargs['text'].startswith('#'):
avatar = assets['no_chat_avatar']
else:
avatar = assets['no_user_avatar']
self.avatar = avatar
kwargs['text'] = kwargs['text'].ljust(18)
super().__init__(**kwargs)
Clock.schedule_once(self.init_ui, 0)
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 on_pre_enter(self):
for child in self.ids.grid.children:
child.background_color = [1, 1, 1, 1]
def my_callback(dt):
view.dismiss()
view = ModalView(size=(100, 100))
view.background = 'img.jpg'
view.open()
Clock.schedule_once(my_callback, 5)
def __init__(self, **kwargs):
super(NewsWidget, self).__init__(**kwargs)
self.app = App.get_running_app()
app_config = self.app.config
provider = app_config.get('news', 'provider')
news_module = imp.load_source(provider, os.path.join(PROJECT_PATH, 'libs', "news", "%s.py" % provider))
self.news_provider = news_module.News()
Clock.schedule_interval(self.update_news, 600)
Clock.schedule_interval(self.rotate_news, app_config.getint('news', 'cycle_interval'))
self.update_news()
self.key_handler = self.app.key_handler
self.key_handler.bind('down', lambda *args: self.rotate_news(direction='next', manual=True))
self.key_handler.bind('up', lambda *args: self.rotate_news(direction='prev', manual=True))
def on_start(self):
ble_central.init()
ble_peripheral.init()
ble_central.set_callbacks(on_state=self.central_state_changed,
on_discover=self.discover)
ble_peripheral.set_callbacks(on_state=self.peripheral_state_changed,
on_service_added=self.peripheral_service_added,
on_service_error=self.peripheral_service_error,
on_advertising_started=self.peripheral_adv,
on_advertising_error=self.peripheral_adv,
on_characteristic_subscribed=self.char_sub,
on_characteristic_write=self.char_write)
self.scanning = ble_central.is_scanning
Clock.schedule_interval(self.update_list, 0.5)
def __init__(self, **kw):
super().__init__(**kw)
self.playlist = StaticPlaylist([
])
self.__cached_playlist = list(self.playlist)
self.load_audio()
def update_position(_):
if self.sound and self.sound.state == 'play':
self.last_sound_position = self.sound.get_pos()
Clock.schedule_interval(update_position, 1.5)
def on_close_tab(self, instance, *args):
"""Event handler to close icon
:param instance: tab instance
"""
self.switch_to(instance)
if instance.has_modification:
# show a dialog to ask if can close
confirm_dlg = ConfirmationDialog("All unsaved changes will be lost.\n" "Do you want to continue?")
self._popup = Popup(
title="New", content=confirm_dlg, size_hint=(None, None), size=("200pt", "150pt"), auto_dismiss=False
)
confirm_dlg.bind(on_ok=partial(self._perform_close_tab, instance), on_cancel=self._popup.dismiss)
self._popup.open()
else:
Clock.schedule_once(partial(self._perform_close_tab, instance))
def pull(*args):
'''Do a pull in a separated thread
'''
try:
remote_repo.pull(progress=progress)
def set_progress_done(*args):
progress.label.text = 'Completed!'
Clock.schedule_once(set_progress_done, 1)
progress.stop()
show_message('Git remote pull completed!', 5)
except GitCommandError as e:
progress.label.text = 'Failed to pull!\n' + str(e)
get_designer().close_popup()
def __init__(self, **kwargs):
super(ZbarQrcodeDetector, self).__init__(**kwargs)
# my code
#
self.add_widget(self.labell)
def Course_thread(dt):
self.labell.text = "24923849"
self._examplefunc()
print "r"
#self.examplefunc("rrrr")
#self._send_request_dzyk(
# 'bal_sum/', params=None,
# success=self._get_commands_result_dzyk_balance_allsum, error=self._get_commands_error_dzyk)
Clock.schedule_interval(Course_thread, 1)
# ID of the command being executed
self._cmd_id = None
# List of the "completed" statuses.
# The first status should be "Done"
self._completed = []
# If True - sends a request to retrieve a command status
self._wait_completion = False
# requested command
self._command = (0, '')
#----------------------------------
self._camera = AndroidCamera(
size=self.camera_size,
size_hint=(None, None))
self._camera.bind(on_preview_frame=self._detect_qrcode_frame)
self.add_widget(self._camera)
# create a scanner used for detecting qrcode
self._scanner = ImageScanner()
self._scanner.setConfig(0, Config.ENABLE, 0)
self._scanner.setConfig(Symbol.QRCODE, Config.ENABLE, 1)
self._scanner.setConfig(0, Config.X_DENSITY, 3)
self._scanner.setConfig(0, Config.Y_DENSITY, 3)
def push(*args):
'''Do a push in a separated thread
'''
try:
remote_repo.push(self.repo.active_branch.name,
progress=progress)
def set_progress_done(*args):
progress.label.text = 'Completed!'
Clock.schedule_once(set_progress_done, 1)
progress.stop()
show_message('Git remote push completed!', 5)
except GitCommandError as e:
progress.label.text = 'Failed to push!\n' + str(e)
self._popup.dismiss()
def _send_command_result(self, request, response):
# Parses API-call response
try:
if response['status'] not in self._completed:
# Executing in progress
self._cmd_id = response['id']
if self._wait_completion:
Clock.schedule_once(self._get_status, 1)
else:
# Command "completed"
if response['status'] == self._completed[0]:
self.last_accepted_command = response['code_dsp']
self._progress_complete(
'Command "%s" is %s' %
(response['code_dsp'], response['status_dsp']))
except Exception as e:
XError(text=str(e)[:256])
def _reset_screensaver(self, *args, **kwargs):
# Change screen only of key is not left/right (what we use to navigate screens)
if self.screen_manager.current == self.saver_screen and (
'key' not in kwargs or kwargs['key'] not in ['right', 'left']):
while self.screen_manager.current != self.default_screen:
self._key_left()
if self.saver_scheduler:
self.saver_scheduler.cancel()
if self._screensaver_enabled():
self.saver_scheduler = Clock.schedule_once(self._start_screensaver,
float(self.config.get('main', 'screensaver_timeout')))
def on_webdebugger(self, *args):
'''when running from webdebugger'''
self.dispatch('on_module', mod='webdebugger', data=[])
Clock.schedule_once(partial(webbrowser.open,
'http://localhost:5000/'), 5)
def stop(self):
'''Start the label updating in a separated thread
'''
Clock.unschedule(self.update_text)
def show_findmenu(self, visible, *args):
'''Makes find menu visible/invisible
'''
self.in_find = visible
if visible:
Clock.schedule_once(self._focus_find)
def on_current_tab(self, tabbed_panel, *args):
'''Event handler to tab selection changes
'''
self.show_findmenu(False)
Clock.schedule_once(partial(self._selected_content, tabbed_panel))
def start(self):
'''Start the label updating in a separated thread
'''
Clock.schedule_interval(self.update_text, 0.2)
def on_start(self):
Clock.schedule_interval(self.update, 0)
def __init__(self, **kwargs):
super(DesignerContent, self).__init__(**kwargs)
self.find_tool.bind(on_close=partial(self.show_findmenu, False))
self.find_tool.bind(on_next=self.find_tool_next)
self.find_tool.bind(on_prev=self.find_tool_prev)
self.focus_code_input = Clock.create_trigger(self._focus_input)
def resume_watching(self, delay=1):
'''Resume the watcher
:param delay: seconds to start the watching
'''
Clock.schedule_once(self._resume_watching, delay)
def on_webdebugger(self, *args):
"""when running from webdebugger"""
self.dispatch("on_module", mod="webdebugger", data=[])
Clock.schedule_once(partial(webbrowser.open, "http://localhost:5000/"), 5)
def my_callback(self, dt):
self.current += dt
if self.current > 2:
global CURRENT_PLAYER, LIST_OF_TARGETS1, LIST_OF_TARGETS, CURRENT, SOME_LIST, AMOUNT1, finish
grid = self.manager.get_screen('board1').ids.grid
rand = random.randint(0, len(LIST_OF_TARGETS) - 1)
TARGETS = LIST_OF_TARGETS
if len(LIST_OF_TARGETS1):
rand = random.randint(0, len(LIST_OF_TARGETS1) - 1)
TARGETS = LIST_OF_TARGETS1
for child in grid.children:
if child.coords == TARGETS[rand]:
if child.background_color == [1, 1, 1, 1]:
child.text = 'X'
child.background_color = [1, 0, 0, 1]
self.popup1.dismiss()
Clock.unschedule(self.my_callback)
CURRENT_PLAYER *= -1
self.sound.stop()
self.sound = SoundLoader.load('files/Not_ship.wav')
self.sound.play()
Clock.schedule_once(self.callback1, 0.7)
TARGETS.remove(child.coords)
else:
x, y = child.coords
CURRENT += 1
AMOUNT1 += 1
SOME_LIST.append((x, y))
if (x + 1, y + 1) in TARGETS:
TARGETS.remove((x + 1, y + 1))
if (x - 1, y - 1) in TARGETS:
TARGETS.remove((x - 1, y - 1))
if (x + 1, y - 1) in TARGETS:
TARGETS.remove((x + 1, y - 1))
if (x - 1, y + 1) in TARGETS:
TARGETS.remove((x - 1, y + 1))
if (x + 1, y + 1) in LIST_OF_TARGETS:
LIST_OF_TARGETS.remove((x + 1, y + 1))
if (x - 1, y - 1) in LIST_OF_TARGETS:
LIST_OF_TARGETS.remove((x - 1, y - 1))
if (x + 1, y - 1) in LIST_OF_TARGETS:
LIST_OF_TARGETS.remove((x + 1, y - 1))
if (x - 1, y + 1) in LIST_OF_TARGETS:
LIST_OF_TARGETS.remove((x - 1, y + 1))
if (x + 1, y) not in LIST_OF_TARGETS1 and (x + 1, y) in LIST_OF_TARGETS:
LIST_OF_TARGETS1.append((x + 1, y))
LIST_OF_TARGETS.remove((x + 1, y))
if (x - 1, y) not in LIST_OF_TARGETS1 and (x - 1, y) in LIST_OF_TARGETS:
LIST_OF_TARGETS1.append((x - 1, y))
LIST_OF_TARGETS.remove((x - 1, y))
if (x, y - 1) not in LIST_OF_TARGETS1 and (x, y - 1) in LIST_OF_TARGETS:
LIST_OF_TARGETS1.append((x, y - 1))
LIST_OF_TARGETS.remove((x, y - 1))
if (x, y + 1) not in LIST_OF_TARGETS1 and (x, y + 1) in LIST_OF_TARGETS:
LIST_OF_TARGETS1.append((x, y + 1))
LIST_OF_TARGETS.remove((x, y + 1))
child.background_color = [0, 1, 0, 1]
AMOUNT1 = 4 + 3 * 2 + 2 * 3 + 4
if AMOUNT1 == 4 + 3 * 2 + 2 * 3 + 4:
self.popup1.dismiss()
Clock.unschedule(self.my_callback)
finish = SoundLoader.load('files/proval.mp3')
finish.play()
winner = ModalView(size_hint=(0.75, 0.5))
winner.background = 'files/You_Lost.png'
# victory_label = Label(text='You Lost!!!!!', font_size=50)
# winner.add_widget(victory_label)
winner.bind(on_dismiss=self.somefunc)
winner.open()
return
TARGETS.remove((x, y))
if CURRENT == int(child.name):
LIST_OF_TARGETS1[:] = []
if self.sound != '':
self.sound.stop()
self.sound = SoundLoader.load('files/boom.mp3')
self.sound.play()
for ship in SOME_LIST:
x, y = ship
s = [1, 0, -1]
t = [1, 0, -1]
for xx in s:
for yy in t:
for child in grid.children:
if child.coords == (x + xx, y + yy) and (x + xx, y + yy) not in SOME_LIST:
child.text = 'X'
child.background_color = [1, 0, 0, 1]
SOME_LIST = []
CURRENT = 0
else:
if self.sound != '':
self.sound.stop()
self.sound = SoundLoader.load('files/bomb2.wav')
self.sound.play()
self.current = 0
return
child = self.popup1.children[0]
if child.text[-1:-4:-1] == '...':
child.text = child.text[:-3]
else:
child.text += '.'
def _perform_kill_run(self, *args):
'''Stop the running project/command and then run the project
'''
self._popup.dismiss()
self.stop()
Clock.schedule_once(self.run)
def callback(self, dt):
self.manager.current = 'board1'
self.popup1.open()
self.current = 0
Clock.schedule_interval(self.my_callback, 1.0)
def button_pressed(self, button):
if button.text == 'YES':
self.manager.current = 'main'
self.popup.dismiss()
else:
global CURRENT_PLAYER, AMOUNT, CURRENT1, SOME_LIST1, finish
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])
if CURRENT1 == ship[2]:
if self.sound != '':
self.sound.stop()
self.sound = SoundLoader.load('files/boom.mp3')
self.sound.play()
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
else:
if self.sound != '':
self.sound.stop()
self.sound = SoundLoader.load('files/bomb2.wav')
self.sound.play()
AMOUNT += 1
AMOUNT = 4 + 3 * 2 + 2 * 3 + 4
if AMOUNT == 4 + 3 * 2 + 2 * 3 + 4:
finish = SoundLoader.load('files/winner.mp3')
finish.play()
winner = ModalView(size_hint=(0.75, 0.5))
winner.background = 'files/youWin.png'
# victory_label = Label(text='You WIN!!!!!', font_size=50)
# winner.add_widget(victory_label)
winner.bind(on_dismiss=self.somefunc)
winner.open()
break
if button.background_color == [1, 1, 1, 1]:
button.text = 'X'
if self.sound != '':
self.sound.stop()
self.sound = SoundLoader.load('files/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, **kwargs):
super(NavigationDrawerIconButton, self).__init__(**kwargs)
self._set_active_color()
self.theme_cls.bind(primary_color=self._set_active_color_primary, accent_color=self._set_active_color_accent)
Clock.schedule_once(lambda x: self.on_icon(self, self.icon))
