class Menu(Widget): logo_img = ObjectProperty(None) def __init__(self, **kwargs): self.uiatlas = Atlas('assets/uitiles.atlas') self.store = DictStore('hexland.dict') super(Menu, self).__init__(**kwargs) self.logo_img.size_hint = 0.1,0.1 Animation(size_hint=(0.8,0.3),t='out_bounce').start(self.logo_img) def new(self): self.parent.setup() def load(self): state = self.store.get('save')['state'] size = len(state['grid']) vs = state['gametype'] self.parent.start(size,vs,state) def help(self): self.parent.help() def credits(self): self.parent.credits() def continueDisabled(self): return not self.store.exists('save')
class StorageManager(object): def __init__(self): self.data = DictStore('data.pickle') def get(self, key): return self.data.get(key)['val'] def get_dict(self, key): return self.data.get(key) def set(self, key, val): self.data.put(key, val=val) def set_dict(self, key, **vals): self.data.put(key, **vals)
class Menu(Widget): logo_img = ObjectProperty(None) def __init__(self, **kwargs): self.uiatlas = Atlas('assets/uitiles.atlas') self.store = DictStore('hexland.dict') super(Menu, self).__init__(**kwargs) self.logo_img.size_hint = 0.1, 0.1 Animation(size_hint=(0.8, 0.3), t='out_bounce').start(self.logo_img) def new(self): self.parent.setup() def load(self): state = self.store.get('save')['state'] size = len(state['grid']) vs = state['gametype'] self.parent.start(size, vs, state) def help(self): self.parent.help() def credits(self): self.parent.credits() def continueDisabled(self): return not self.store.exists('save')
def send_points(self): try: store = DictStore('store') try: pk = store.get('active_game')['values'] token = store.get('token')['values'] values = {'authorization': 'Token {}'.format(token)} points = {'points': self.sum_to_display} requests.post(host+'main/game/{}/add_points/'.format(str(pk)), headers=values, data=points) # try to create new round requests.post(host+'main/game/{}/new_deal/'.format(str(pk)), headers=values) except KeyError: pass except ConnectionError: pass
def create_new_game(self): if self.password.text != '' and self.login.text != '': values = {'login': self.login.text, 'password': self.password.text} store = DictStore('store') token = store.get('token')['values'] headers = {'authorization': 'Token {}'.format(token)} requests.post(host+'main/game/', data=values, headers=headers) self.join_game()
def join_game(self, *args): values = {'login': self.login.text, 'password': self.password.text} store = DictStore('store') token = store.get('token')['values'] headers = {'authorization': 'Token {}'.format(token)} response = requests.post(host+'main/game/join/', data=values, headers=headers) print(response) GameListWindow.__init__(self.instance) store = DictStore('store') if str(response) == '<Response [200]>': store.put(key='active_game', values=response.json()['id']) self.dismiss()
def __init__(self, **kwargs): super(GameListWindow, self).__init__(**kwargs) try: try: self.remove_widget(self.children[-1]) self.remove_widget(self.children[1]) except IndexError: pass store = DictStore('store') try: token = store.get('token')['values'] except KeyError: token = '' values = {'authorization': 'Token {}'.format(token)} self.response = requests.get(self.http, headers=values) try: self.username = store.get('username')['values'] except KeyError: self.username = '' grid = GridLayout(id='my_grid', cols=1, pos=(0, 0), size_hint=[self.size_hint_x, .9]) for element in self.response.json()['results']: grid.add_widget(Button(text=element['login'], on_release=self.game_button)) new_grid = GridLayout(rows=1) if self.response.json()['previous'] is not None: new_grid.add_widget(Button(id='previous_button', text='Poprzednie', on_press=self.previous_button)) if self.response.json()['next'] is not None: new_grid.add_widget(Button(id='next_button', text='Następne', on_press=self.next_button)) grid.add_widget(new_grid) self.add_widget(grid) except ConnectionError: self.add_widget(Label(text='Brak połączenia z serwerem. Sprawdź połączenie z Internetem.'))
class MySettings(object): def __init__(self, *args): self.store = DictStore('user.dat') self.clientCoutnry = 'notSpecified' self.previousRound = '' self.intRound = 0 self.dictRounds = { '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five' } self.round = 'zero' self.IP_Adress = 'http://localhost:8080' self.question = '' self.questionAddition = '' self.numberOfQuestion = '' self.votingResult = { 'zero_yes': 0, 'zero_no': 0, 'one_yes': 0, 'one_no': 0, 'two_yes': 0, 'two_no': 0, 'three_yes': 0, 'three_no': 0, 'four_yes': 0, 'four_no': 0, 'five_yes': 0, 'five_no': 0, 'final_yes': 0, 'final_no': 0 } if self.store.exists('IP'): self.IP_Adress = self.store.get('IP')['data']
class Engine: def __init__(self, dispatch, resume=True): self.__dispatch = dispatch self.__worker = WorkerThread() self.hist = [Position(initial, 0, (True, True), (True, True), 0, 0)] self.board = chess.Board() self.redo = [] self.searcher = Searcher() self.store = DictStore('fisher.dat') if resume: self.load_game() @mainthread def dispatch(self, event, *args): self.__dispatch(event, *args) @property def is_game_over(self): return self.board.is_game_over() @property def moves(self): return self.board.move_stack # convert sunfish position into a list of pieces with their file and rank def position(self, pos=None): pos = pos or self.hist[-1] pieces = [] for rank, row in enumerate(pos.board.split()): for file, p in enumerate(row): if p == '.': continue pieces.append('{}{}{}'.format(p, 'abcdefgh'[file], 8 - rank)) return pieces def validate(self, _move): try: move = chess.Move.from_uci(_move) except: return None while True: if move in self.board.legal_moves: return move if self.humans_turn: break # Sunfish move deemed illegal by python-chess? likely a promotion assert not move.promotion if not self.humans_turn: move.promotion = chess.QUEEN def apply_move(self, _move): move = self.validate(self.decode(_move)) if move: self.board.push(move) self.hist.append(self.hist[-1].move(_move)) # after the machine's move, check if redo list still valid if self.humans_turn: self.check_redo() self.dispatch('on_update', *self.status(), move.uci()) if not self.is_game_over: return move def input_move(self, move): move = self.parse_and_validate(move) if move and self.apply_move(move): self.search_move() def parse_and_validate(self, move): if not self.is_game_over: match = re.match('([a-h][1-8])' * 2, move) if match: return parse(match.group(1)), parse(match.group(2)) def decode(self, move): if not self.humans_turn: move = [119 - m for m in move] return '{}{}'.format(*(render(m) for m in move)) # Fire up the engine to look for a move -- in the background thread def search_move(self): def search(): start = time.time() for _depth, move, _score in self.searcher.search( self.hist[-1], self.hist): if time.time() - start > 1: break self.apply_move(move) self.save_game() self.__worker.send_message(search) def status_message(self): if self.board.is_stalemate(): return 'Stalemate' if self.board.is_checkmate(): return 'Checkmate!' if self.board.is_check(): return 'Check!' return 'Your turn' if self.humans_turn else 'Thinking...' @property def humans_turn(self): return self.board.turn == chess.WHITE def status(self): pos = self.hist[-1] if self.hist else None if pos and not self.humans_turn: pos = pos.rotate() return self.position(pos), self.status_message() def __can_use(self, moves_list): return len(moves_list) > 0 and (self.humans_turn or self.is_game_over) def can_undo(self): return self.__can_use(self.moves) def can_redo(self): return self.__can_use(self.redo) def check_redo(self): if self.redo and self.last_move != self.redo[-1]: # history took a different turn; redo list is invalid self.redo.clear() def undo_move(self): assert self.can_undo() assert len(self.hist) >= 2 # Assuming human plays white -- careful if/when implementing a "switch" feature # Moves count should be even, unless we lost. # Length of position history is odd because of initial empty position. assert len(self.hist) % 2 or self.is_game_over n = 1 if len(self.moves) % 2 else 2 self.hist = self.hist[:-n] self.redo.append(self.moves[-n].uci()) while n > 0: self.board.pop() n -= 1 self.redo.append(self.last_move) self.dispatch('on_update', *self.status(), self.last_move) def redo_move(self): assert self.redo assert len(self.redo) % 2 == 0 move = self.redo.pop() assert move == self.last_move move = self.redo.pop() self.input_move(move) def start(self): if not self.humans_turn: self.search_move() @property def last_move(self): return self.moves[-1].uci() if self.moves else None def load_game(self): Logger.debug('{}: load'.format(__name__)) if self.store.exists('game'): data = self.store.get('game') self.hist = data.get('hist', []) for move in data.get('moves', []): self.board.push(move) def save_game(self): Logger.debug('{}: save'.format(__name__)) self.store.put('game', hist=self.hist, moves=self.moves)
class Program: def __init__(self, isim, time, kanal): self.isim = isim self.time = time self.kanal = kanal store = DictStore('data.py') Programlar = [] Kanallar_settings = [False] * 47 if (store.exists('1')): print('loading data') for i in range(0, len(Kanallar_settings)): Kanallar_settings[i] = store.get(str(i))['state'] class WindowManager(ScreenManager): pass class ChooseWindow(Screen): renklist = ListProperty(None) def storedata(self): for i in range(0, len(Kanallar_settings)): store.put(str(i), state=Kanallar_settings[i]) def press_kanal(self, i, obje): Kanallar_settings[i] = not Kanallar_settings[i]
class MySettings(object): __finalDay = None __startDay = None __count = 0 __isNotReady = True __store = None __isKontrabas = False def __init__(self): self.__store = DictStore('user.dat') if self.__store.store_exists('finalDay') and self.__store.get('finalDay')['data']: self.__startDay = self.__store.get('startDay')['data'] self.__finalDay = self.__store.get('finalDay')['data'] self.__count = self.__store.get('count')['data'] self.__isKontrabas = self.__store.get('isKontrabas')['data'] self.__isNotReady = False else: self.reset() def parseDate(self, dateText): if dateText: return datetime.strptime(dateText, "%S-%M-%H %d-%m-%Y") else: None def reset(self): self.__isNotReady = True self.__startDay = None self.__finalDay = None self.__count = 0 self.__isKontrabas = False self.__store.put('finalDay', data=None) self.__store.put('count', data=0) self.__store.put('isKontrabas', data=False) def __getattr__(self, attr): if attr == 'isNotReady': return self.__isNotReady if attr == 'startDay': return self.parseDate(self.__startDay) if attr == 'finalDay': return self.parseDate(self.__finalDay) if attr == 'counter': return self.__count if attr == 'isKontrabas': return self.__isKontrabas return None def __setattr__(self, key, value): if key == 'startDay': if value: self.__startDay = value.strftime("%S-%M-%H %d-%m-%Y") else: self.__startDay = value self.__store.put('startDay', data=self.__startDay) return if key == 'finalDay': if value: self.__finalDay = value.strftime("%S-%M-%H %d-%m-%Y") else: self.__finalDay = value self.__store.put('finalDay', data=self.__finalDay) return if key == 'counter': self.__count = value self.__store.put('count', data=value) return if key == 'isKontrabas': self.__isKontrabas = value self.__store.put('isKontrabas', data=value) return super(MySettings, self).__setattr__(key, value)
class GameWindow(Screen): store = DictStore('store') pk = 0 token = '' values = {'authorization': 'Token {}'.format(token)} response = '' def __init__(self, **kwargs): super(GameWindow, self).__init__(**kwargs) try: self.update() except ConnectionError: pass def update(self, *args): try: self.store = DictStore('store') try: self.pk = self.store.get('active_game')['values'] self.token = self.store.get('token')['values'] except KeyError: pass self.values = {'authorization': 'Token {}'.format(self.token)} # remove widgets to replace them by updates for element in self.children: if element.id is not None: self.remove_widget(element) response = requests.get(host+'main/game/{}/'.format(str(self.pk)), headers=self.values) if str(response) == '<Response [200]>': self.response = response.json() try: if self.response['detail'] == 'Not found.': pass else: self.draw_ui() except KeyError: self.draw_ui() except ConnectionError: self.add_widget(Label(text='Brak połączenia z serwerem. Sprawdź połączenie z Internetem.')) def draw_ui(self): grid = GridLayout(id='my_grid', anchor_y='top', cols=1, pos=(0, 0), size_hint=[self.size_hint_x, self.size_hint_y]) grid_scoreboard = GridLayout(cols=1, anchor_y='top', size_hint=[self.size_hint_x, .32]) grid_scoreboard.add_widget(Label(text='Tablica wyników:')) for element in self.response['scoreboard']: grid_scoreboard.add_widget(Label(text='{} {}'.format(element[1], element[0]))) grid_last_round = GridLayout(cols=1, anchor_y='top', size_hint=[self.size_hint_x, .32]) try: grid_last_round.add_widget(Label(text='Runda nr {}:'.format(self.response['deals'][0]['count']))) for element in self.response['deals'][0]['points']: label = Label(text='{} {}'.format(element['points'], element['user']['username'])) grid_last_round.add_widget(label) except IndexError: pass grid_all_rounds = GridLayout(cols=1, anchor_y='top', size_hint=[self.size_hint_x, .6]) for element in self.response['deals'][1:11]: grid_all_rounds.add_widget(Button(text='Runda {}'.format(element['count']), on_release=self.display_round)) grid.add_widget(Label(pos=(0, 0), text=self.response['login'], size_hint=[self.size_hint_x, .04])) grid.add_widget(grid_scoreboard) grid.add_widget(grid_last_round) grid.add_widget(grid_all_rounds) self.add_widget(grid) def display_round(self, instance): count = int(instance.text[6:]) grid = GridLayout(anchor_y='top', cols=1, size_hint=[self.size_hint_x, self.size_hint_y]) try: for element in self.response['deals']: if element['count'] == count: for i in element['points']: label = Label(text='{} {}'.format(i['points'], i['user']['username'])) grid.add_widget(label) except IndexError: pass popup = Popup(content=grid, title=instance.text, size=("300dp", "250dp"), size_hint=(None, None), auto_dismiss=True) popup.open()
class Analytics(EventDispatcher): gameEnemies = NumericProperty() gameDamage = NumericProperty() towersBought = NumericProperty() towersSold = NumericProperty() towerUpgrades = NumericProperty() maxTowerLevel = NumericProperty() finalWave = NumericProperty() gameTimeEnd = NumericProperty() moneyEarned = NumericProperty() moneySpent = NumericProperty() def on_gameEnemies(self, instance, value): self.numEnemies = value def on_gameDamage(self, instance, value): self.gameDamage = value def on_towersBought(self, instance, value): self.towersBought = value def on_towersSold(self, instance, value): self.towersSold = value def on_towerUpgrades(self, instance, value): self.towerUpgrades = value def on_maxTowerLevel(self, instance, value): self.maxTowerLevel = value def on_finalWave(self, instance, value): self.finalWave = value def on_gameTimeEnd(self, instance, value): self.gameLength = self.gameTimeEnd - self.gameTimeStart if self.gameLength >= 60: self.gameLength = (self.gameLength / 60, self.gameLength % 60) else: self.gameLength = (0, self.gameLength) def on_moneyEarned(self, instance, value): self.moneyEarned = value def on_moneySpent(self, instance, value): self.moneySpent = value def __init__(self): super(Analytics, self).__init__() self.gameTimeStart = 0 self.gameTimeEnd = 0 self.playerData = DictStore('player_data.txt') if self.playerData.exists('lastgame'): self.numEnemies = self.playerData.get('lastgame')['numEnemies'] self.gameDamage = self.playerData.get('lastgame')['gameDamage'] self.towersBought = self.playerData.get('lastgame')['towersBought'] self.towersSold = self.playerData.get('lastgame')['towersSold'] self.towerUpgrades = self.playerData.get( 'lastgame')['towerUpgrades'] self.maxTowerLevel = self.playerData.get( 'lastgame')['maxTowerLevel'] self.finalWave = self.playerData.get('lastgame')['finalWave'] self.moneyEarned = self.playerData.get('lastgame')['moneyEarned'] self.moneySpent = self.playerData.get('lastgame')['moneySpent'] self.gameLength = self.playerData.get('lastgame')['gameLength'] self.score = self.playerData.get('lastgame')['score'] else: self.numEnemies = 0 self.gameDamage = 0 self.towersBought = 0 self.towersSold = 0 self.towerUpgrades = 0 self.maxTowerLevel = 1 self.finalWave = 1 self.moneyEarned = 0 self.moneySpent = 0 self.gameLength = (0, 0) self.score = 0 if self.playerData.exists('totals'): self.totalGames = self.playerData.get('totals')['totalGames'] self.totalEnemies = self.playerData.get('totals')['totalEnemies'] self.totalDamage = self.playerData.get('totals')['totalDamage'] self.totalBought = self.playerData.get('totals')['totalBought'] self.totalSold = self.playerData.get('totals')['totalSold'] self.totalUpgraded = self.playerData.get('totals')['totalUpgraded'] self.highestTowerLevel = self.playerData.get( 'totals')['highestTowerLevel'] self.latestWave = self.playerData.get('totals')['latestWave'] self.totalEarned = self.playerData.get('totals')['totalEarned'] self.totalSpent = self.playerData.get('totals')['totalSpent'] self.timePlayed = self.playerData.get('totals')['timePlayed'] else: self.totalGames = 0 self.totalEnemies = 0 self.totalDamage = 0 self.totalBought = 0 self.totalSold = 0 self.totalUpgraded = 0 self.highestTowerLevel = 1 self.latestWave = 1 self.totalEarned = 0 self.totalSpent = 0 self.timePlayed = {'hours': 0, 'minutes': 0, 'seconds': 0} def _print(self): if self.gameEnemies != 0: print["Num Enemies: ", self.numEnemies, "Total Damage: ", int(self.gameDamage), "Towers Bought: ", self.towersBought, "Towers Sold: ", self.towersSold, "Tower Upgrades: ", self.towerUpgrades, "Max Tower Level: ", self.maxTowerLevel, "Final Wave: ", self.finalWave, "Game Length: ", str(int(self.gameLength[0])) + " minutes " + str(int(self.gameLength[1])) + " seconds", "Money Earned: ", self.moneyEarned, "Money Spent: ", self.moneySpent, "total Enemies: ", self.totalEnemies, "total Damage: ", self.totalDamage, "total Bought: ", self.totalBought, "total Sold: ", self.totalSold, "total Upgraded: ", self.totalUpgraded, "highest Level: ", self.highestTowerLevel, "latest Wave: ", self.latestWave, "total Earned: ", self.totalEarned, "total Spent: ", self.totalSpent, "total time played: ", self.timePlayed, "total games: ", self.totalGames] def updateData(self): self.totalGames += 1 self.totalEnemies += self.numEnemies self.totalDamage += int(self.gameDamage) self.totalBought += self.towersBought self.totalSold += self.towersSold self.totalUpgraded += self.towerUpgrades if self.highestTowerLevel < self.maxTowerLevel: self.highestTowerLevel = self.maxTowerLevel if self.latestWave < self.finalWave: self.latestWave = self.finalWave self.totalEarned += self.moneyEarned self.totalSpent += self.moneySpent self.timePlayed['minutes'] += int(self.gameLength[0]) self.timePlayed['seconds'] += int(self.gameLength[1]) if self.timePlayed['seconds'] > 60: self.timePlayed['seconds'] = int(self.timePlayed['seconds'] % 60) self.timePlayed['minutes'] += 1 if self.timePlayed['minutes'] > 60: self.timePlayed['minutes'] = int(self.timePlayed['minutes'] % 60) self.timePlayed['hours'] += 1 def store_data(self): self.playerData.put('lastgame', numEnemies=self.numEnemies, gameDamage=self.gameDamage, towersBought=self.towersBought, towersSold=self.towersSold, towerUpgrades=self.towerUpgrades, maxTowerLevel=self.maxTowerLevel, finalWave=self.finalWave, gameLength=self.gameLength, moneyEarned=self.moneyEarned, moneySpent=self.moneySpent, score=self.score) self.playerData.put('totals', totalGames=self.totalGames, totalEnemies=self.totalEnemies, totalDamage=self.totalDamage, totalBought=self.totalBought, totalSold=self.totalSold, totalUpgraded=self.totalUpgraded, highestTowerLevel=self.highestTowerLevel, latestWave=self.latestWave, timePlayed=self.timePlayed, totalEarned=self.totalEarned, totalSpent=self.totalSpent)
class irc1App(App): def build(self): if platform == 'android': from android import AndroidService service = AndroidService('irc1\'s service', 'running') service.start('service started') self.service = service osc.init() oscid = osc.listen(ipAddr='127.0.0.1', port=activityport) osc.bind(oscid, self.main_api_callback, '/api/main') Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0.1) self.icon = 'data/icon.png' self.servers = DictStore('servers.db') self.msg_animation = Animation(opacity=1, transition='out_cubic') self.screenmain = ScreenMain() self.running = {} self.boxes = {} for name in sorted(dict(self.servers.find()).keys()): data = self.servers.get(name) box = ServerBox(name=name) self.boxes[name] = box self.screenmain.ids.servers.add_widget(box) manager = ScreenManager(transition=SlideTransition(duration=0.2)) manager.add_widget(self.screenmain) return manager def go_back(self): name = self.root.current if name == 'ScreenMain': pause_app() else: self.root.transition.direction = 'right' self.root.current = 'ScreenMain' def init_connection(self, name): if name not in self.servers: return if name not in self.running: Animation(background_color=(0.1, 1, 0.1, 1)).start( self.boxes[name].ids.servername) screen = ScreenConversation(name=name) data = self.servers.get(name) self.running[name] = screen self.root.add_widget(screen) screen.ids.nick.text = data['nick'] osc.sendMsg( '/api/main', [ 'connect', name, data['host'], data['port'], data['nick'], data['password'], data['auth_nickserv'], data['scripts'] ] + data['autojoin'], port=serviceport) self.root.transition.direction = 'left' self.root.current = name def close_connection(self, name): osc.sendMsg('/api/main', ['disconnect', name], port=serviceport) if name not in self.running: return Animation(background_color=(1, 1, 1, 1)).start(self.boxes[name].ids.servername) self.root.transition.direction = 'right' self.root.current = 'ScreenMain' self.root.remove_widget(self.running[name]) del self.running[name] def disconnect_all(self): for name, data in self.servers.find(): self.close_connection(name) def update_or_add_server(self, popup, name=''): host = str(popup.ids.host.text).strip() port = int(str(popup.ids.port.text).strip()) nick = str(popup.ids.nick.text).strip() password = str(popup.ids.password.text) auth_nickserv = popup.ids.auth_nickserv.active scripts = str(popup.ids.scripts.text).strip() autojoin = str(popup.ids.autojoin.text).strip() autojoin = autojoin.replace(',', ' ').split() data = { 'host': host, 'port': port, 'nick': nick, 'password': password, 'auth_nickserv': auth_nickserv, 'scripts': scripts, 'autojoin': autojoin } if name: self.servers.put(name, **data) return name = '%s:%d' % (host, port) if self.servers.exists(name): return if not host or not port > 0 or not nick: return self.servers.put(name, **data) box = ServerBox(name=name) self.boxes[name] = box self.screenmain.ids.servers.add_widget(box) self.screenmain.ids.serverscroll.scroll_to(box) def del_server(self, serverbox): name = serverbox.name if self.servers.exists(name): self.servers.delete(name) del_animation = Animation(opacity=0, duration=0.2) del_animation.bind( on_complete=lambda *x: serverbox.parent.remove_widget(serverbox)) del_animation.start(serverbox) del self.boxes[name] def log_msg(self, name, message): label = ChatLabel(text=message) self.running[name].ids.chatlog.add_widget(label) self.running[name].ids.chatscroll.scroll_to(label) if self.root.current == name: self.msg_animation.start(label) else: label.opacity = 1 def input_focus(self, name, dt): self.running[name].ids.message.focus = True def send_msg(self, name, message): Clock.schedule_once(partial(self.input_focus, name), 0) osc.sendMsg('/api/main', ['send', name, message], port=serviceport) def change_channel(self, name, channel): osc.sendMsg('/api/main', ['channel', name, channel], port=serviceport) def main_api_callback(self, message, *args): # print message[2:] if len(message) > 3: name = message[3] if name not in self.running: return if message[2] == 'nick': nick = message[4] self.running[name].ids.nick.text = nick elif message[2] == 'channel': channel, channels = message[4], message[5:] self.running[name].ids.channel.text = channel or 'No channel' self.running[name].ids.channel.values = [ x or 'No channel' for x in channels ] elif message[2] == 'check': osc.sendMsg('/api/main', ['unread', name], port=serviceport) elif message[2] == 'unread': self.log_msg(name, message[4]) def on_start(self): Window.softinput_mode = 'below_target' hook_keyboard() def on_pause(self): return True def on_resume(self): pass def on_stop(self): if platform == 'android': self.service.stop()
class Player(): def __init__(self): self.health = playerhealth self.money = 0 self.gems = 0 self.upgPathSelectLvl = 5 self.abilities = list() self.wavenum = 0 self.gameover = False self.towerSelected = None self.tbbox = None self.layout = None self.wavestart = 999 self.next_wave = False self.pausetime = 0 self.state = "Start" self.restart = False self.score = 0 self.newMoveList = False self.wavetime = None self.wavetimeInt = None self.myDispatcher = EventDispatcher.EventDisp() self.analytics = Analytics.Analytics() self.store = DictStore('settings.txt') if self.store.exists('audio'): self.soundOn = self.store.get('audio')['soundOn'] self.musicOn = self.store.get('audio')['musicOn'] else: self.soundOn = True self.musicOn = True def setResources(self): if Map.mapvar.difficulty == 'easy': self.money = 2000 self.gems = 5 self.myDispatcher.Money = str(self.money) self.myDispatcher.Gems = str(self.gems) elif Map.mapvar.difficulty == 'medium': self.money = 1000 self.gems = 4 self.myDispatcher.Money = str(self.money) self.myDispatcher.Gems = str(self.gems) else: self.money = 300 self.gems = 3 self.myDispatcher.Money = str(self.money) self.myDispatcher.Gems = str(self.gems) self.myDispatcher.Score = str(self.score) self.myDispatcher.Timer = str(self.wavetimeInt) self.myDispatcher.Health = str(self.health) def setupCoinAnim(self): self.coinAnimating = False self.coinanim = Animation(pos=(__main__.ids.coinimage.x, __main__.ids.coinimage.y+20), duration=.1) + \ Animation(pos=(__main__.ids.coinimage.x, __main__.ids.coinimage.y), duration=.1) self.coinanim.on_complete(self.toggleCoinAnim) def toggleCoinAnim(self): self.coinAnimating = False def die(self): '''Set gameover to True to reset the game''' self.gameover = True def genWaveList(self): self.waveList, self.waveTypeList = Wavegen.wavegen() # [{'wavenum': 1, 'setnum': 1, 'enemytype': 'b', 'enemymods': []}, dict repeats] self.wavetime = Map.mapvar.waveseconds self.wavetimeInt = int(Map.mapvar.waveseconds) def storeSettings(self): self.store.put('audio', soundOn=self.soundOn,musicOn=self.musicOn) self.store.put('gameplay', difficulty = Map.mapvar.difficulty, numpaths = Map.mapvar.numpaths, waveorder = Map.mapvar.waveOrder)