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)
