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 ManagerBase(object):
def __init__(self, filename):
self.storage = DictStore(filename)
if 'vals' not in self.storage:
self.storage['vals'] = dict()
def _clear(self):
self.storage.clear()
self.storage['vals'] = dict()
@property
def vals(self):
"""
Returns a copy of the resources dict
"""
return self.storage['vals']
@update_storage
def add_item(self, vals, item, name=None):
if name is None:
name = item.name
vals[name] = item
@update_storage
def remove_item(self, vals, name):
del vals[name]
def __init__(self, **kwargs):
super(HexGrid, self).__init__(do_rotation=False,
scale_min=.5,
scale_max=3.,
auto_bring_to_front=False)
self.gridsize = kwargs['gridsize']
self.gametype = kwargs['gametype']
self.gui = kwargs['gui']
# Preparem atlas d'imatges pels tiles
self.baseatlas = Atlas('assets/basetiles.atlas')
self.playeratlas = Atlas('assets/playertiles.atlas')
self.uiatlas = Atlas('assets/uitiles.atlas')
# Nomes gridsize inparell
assert (self.gridsize % 2 != 0)
# Preparem store
self.store = DictStore('hexland.dict')
self.grid = []
self.deads = {1: 0, 2: 0}
self.resetScore()
self.setup()
# Si ens construeixen amb estat, el carreguem
if kwargs['state']:
self.loadState(kwargs['state'], True)
self.reloadGridGraphics()
# Si estem vs cpu, creem el jugador CPU
if not self.gametype == GAMETYPE["PVP"]:
self.cpu = CpuPlayer(self.gametype)
def delNote(touch):
#Deleting on Screen
var = sm.current
toNotesright(touch)
#
#
#delete notescreen
for item in sm.children:
if item.name == var:
sm.remove_widget(item)
#delete button
for item in notes.stack.children:
if item.name == var:
notes.stack.remove_widget(item)
#Deleting from shelve
store = DictStore('store13.dat')
#removing index
mylist = store['index']['num']
mylist.remove(var)
store['index']['num'] = mylist
#removing df item
store.delete(var)
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 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 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.'))
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 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 __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 del_data(store, name):
store = DictStore(store)
if not store.exists(name):
raise StoreException("The dice don't exist")
elif name == "default":
raise StoreException("Default can't be delete")
else:
store.delete(name)
def edit_data(store, name, data):
store = DictStore(store)
if store.exists(name):
store.put(name, data=data)
elif name == "default":
raise StoreException("Default can't be edit")
else:
raise StoreException("The dice don't exit")
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 __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()
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 __init__(self, data_path, refresh_ui):
self.refresh_ui = refresh_ui
self.data_path = data_path
fb_db = DictStore(join(data_path, 'fb.db'))
if not fb_db.exists('data'):
fb_db.put('data')
self.db = fb_db
if self.db['data'].get('token') and not platform in ('ios', 'android'):
self.token = self.db['data']['token']
self.refresh_token()
else:
pass
def test_dict_storage(self):
from kivy.storage.dictstore import DictStore
from tempfile import mkstemp
from os import unlink, close
try:
tmpfd, tmpfn = mkstemp('.dict')
close(tmpfd)
self._do_store_test_empty(DictStore(tmpfn))
self._do_store_test_filled(DictStore(tmpfn))
finally:
unlink(tmpfn)
def __init__(self,**kwargs):
super(HexGrid, self).__init__(do_rotation=False,scale_min=.5, scale_max=3.,auto_bring_to_front=False)
self.gridsize = kwargs['gridsize']
self.gametype = kwargs['gametype']
self.gui = kwargs['gui']
# Preparem atlas d'imatges pels tiles
self.baseatlas = Atlas('assets/basetiles.atlas')
self.playeratlas = Atlas('assets/playertiles.atlas')
self.uiatlas = Atlas('assets/uitiles.atlas')
# Nomes gridsize inparell
assert(self.gridsize%2 != 0)
# Preparem store
self.store = DictStore('hexland.dict')
self.grid = []
self.deads = {1:0,2:0}
self.resetScore()
self.setup()
# Si ens construeixen amb estat, el carreguem
if kwargs['state']:
self.loadState(kwargs['state'],True)
self.reloadGridGraphics()
# Si estem vs cpu, creem el jugador CPU
if not self.gametype == GAMETYPE["PVP"]:
self.cpu = CpuPlayer(self.gametype)
def findNotes(touch):
if notes.txt.text != '':
import re
keyword = notes.txt.text
matchlist = []
for x in notes.stack.children:
key = x.name
store = DictStore('store13.dat')
each = store[key]['note']
matchobj = re.search(keyword.lower(), each.lower())
if matchobj:
matchlist.append(key)
children = []
for each in notes.stack.children:
children.append(each.name)
for x in matchlist:
children.remove(x)
purge = children
for each in purge:
for item in notes.stack.children:
if each == item.name:
notes.stack.remove_widget(item)
if len(notes.stack.children) == 0:
nofound = Label(text='No matches were found.',
font_size='20sp',
text_size=(300, 300))
notes.stack.add_widget(nofound)
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 __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 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']
def get_store(store_name, subfolder=None, as_backup=False, from_backup=False):
app = App.get_running_app()
# remove .pydict
if store_name.endswith('.pydict'):
store_name.strip('.pydict')
# add _backup if its a backup
if from_backup:
store_name += '_backup'
# always add .pydict (as it was removed if it existed)
store_name += '.pydict'
if not subfolder:
# get the path (straightforward)
store_path = path.join(app.user_data_dir, store_name)
else:
# get the subfolder's path
folder_path = path.join(app.user_data_dir, subfolder)
try:
# try to make the subfolder
mkdir(folder_path)
except:
# if it already exists then simply print the line bellow and do nothing else
print('i guess its already made')
# get the store's path
store_path = path.join(folder_path, store_name)
# return the correct storage type
if as_backup is True:
# if as_backup is simply True, then try to get the store with the same name
# this is a little inefficient but who cares really
store = get_store(store_name, subfolder)
return BackupDictStore(store_path, store)
elif as_backup:
# if as_backup is specified then backup from the specified store
return BackupDictStore(store_path, as_backup)
else: # if not as backup...., just open a normal store
return DictStore(store_path)
def do_login(self, *args):
try:
values = {'username': self.username.text, 'password': self.password.text}
response = requests.post(host+'api-token-auth/', data=values)
store = DictStore('store')
try:
store.put(key='token', values=response.json()['token'])
store.put(key='username', values=self.username.text)
except KeyError:
pass
self.dismiss()
GameListWindow.__init__(self.instance)
except ConnectionError:
pass
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 HexGrid(ScatterLayout):
gridsize = NumericProperty()
gametype = NumericProperty()
grid = ListProperty()
deadGroups = ListProperty()
baseimg = ObjectProperty()
player = NumericProperty()
lastPass = BooleanProperty(False) # la ultima jugada ha sigut passar?
def __init__(self,**kwargs):
super(HexGrid, self).__init__(do_rotation=False,scale_min=.5, scale_max=3.,auto_bring_to_front=False)
self.gridsize = kwargs['gridsize']
self.gametype = kwargs['gametype']
self.gui = kwargs['gui']
# Preparem atlas d'imatges pels tiles
self.baseatlas = Atlas('assets/basetiles.atlas')
self.playeratlas = Atlas('assets/playertiles.atlas')
self.uiatlas = Atlas('assets/uitiles.atlas')
# Nomes gridsize inparell
assert(self.gridsize%2 != 0)
# Preparem store
self.store = DictStore('hexland.dict')
self.grid = []
self.deads = {1:0,2:0}
self.resetScore()
self.setup()
# Si ens construeixen amb estat, el carreguem
if kwargs['state']:
self.loadState(kwargs['state'],True)
self.reloadGridGraphics()
# Si estem vs cpu, creem el jugador CPU
if not self.gametype == GAMETYPE["PVP"]:
self.cpu = CpuPlayer(self.gametype)
def setup(self):
# Torn del jugador per defecte
self.player = 1
# Posicio i mida segons mida GRID
self.drawgridsize = self.gridsize*65,89+(int(self.gridsize/2)*(35+65))
self.size[0] = 1000
self.size[1] = 1000
self.pos = Window.size[0]/2-self.size[0]/2,Window.size[1]/2-self.size[1]/2
# Com es la illa? Aleatori
possibleBases = ['tileAutumn','tileGrass','tileSnow','tileMagic','tileLava','tileStone','tileRock']
self.baseimg = self.baseatlas[random.choice(possibleBases)]
self.setupGrid()
def getState(self):
state = {}
state["player"] = self.player
state["gametype"] = int(self.gametype)
state["deads"] = self.deads
state["tileScore"] = self.tileScore
state["terrScore"] = self.terrScore
grid = []
sz = self.gridsize
for y in range(0,sz):
row = []
for x in range(0,sz):
t = self.grid[y][x]
if t:
row.append(t.content)
else:
row.append(None)
grid.append(row)
state["grid"] = grid
return state
def loadState(self,state,fromContinue=False):
grid = state["grid"]
sz = len(grid)
# No pot passar que aixo sigui diferent
assert(sz == self.gridsize)
for y in range(0,sz):
for x in range(0,sz):
t = grid[y][x]
if t is not None:
self.grid[y][x].content = t
if fromContinue and not state["player"] == self.player: # Nomes 2 jugadors
self.nextPlayer()
self.gametype = state["gametype"]
self.deads = state["deads"]
self.tileScore = state["tileScore"]
self.terrScore = state["terrScore"]
def setupGrid(self):
# Crea i configura el grid
sz = self.gridsize
mid = int(sz/2)
for y in range(0,sz):
line = []
dif = abs(mid-y)
for x in range(0,sz):
# Comprova si hi ha casella. Les caselles superiors esquerres i inferiors
# dretes queden buides.
if y==mid or (y < mid and x >= dif) or (y>mid and x<sz-dif):
# Graphics
t = Tile(grid_x = x, grid_y = y, caller = self, content = 0)
self.add_widget(t)
line.append(t)
else:
line.append(None)
self.grid.append(line)
self.reloadGridGraphics()
def getTile(self,x,y):
# No es poden demanar index negatius
if x < 0 or y < 0:
return None
if x >= self.gridsize or y >= self.gridsize: # Ens demanen un tile inexistent
return None
return self.grid[y][x]
# Reseteja les puntuacions actuals
def resetScore(self):
self.tileScore = {1:0,2:0}
self.terrScore = {1:0,2:0}
# Reseteja els grups dels tiles
def resetTileGroups(self):
sz = self.gridsize
for y in range(0,sz):
for x in range(0,sz):
t = self.grid[y][x]
if t: t.group = 0 # No te grup
# Reseteja la marca de si el tile ha estat fet servir per puntuar terreny
def resetTileUsed(self):
sz = self.gridsize
for y in range(0,sz):
for x in range(0,sz):
t = self.grid[y][x]
if t: t.usedByTerrain = False
# Assigna tot el grup. També comprova si es un grup mort
def recursiveSetGroup(self,t,grpnum,dead=True):
t.group = grpnum
for nt in t.getNeighbors():
if nt.content == 0:
dead = False # el grup té com a minim una llibertat,
elif not nt.group and nt.content == t.content: # No te grup i mateix jugador
dead = self.recursiveSetGroup(nt,grpnum,dead)
return dead
# Assigna tot el grup de terreny buit. Torna també informacio per puntuacio de terrany
def recursiveSetTerrainGroup(self,t,grpnum,terrInfo):
t.group = grpnum
terrInfo['count']+=1
for nt in t.getNeighbors():
if nt.content and not nt.usedByTerrain: # es un jugador, el sumem i marquem com a fet servit (per a aquest grup)
nt.usedByTerrain = True
terrInfo[nt.content]+=1
elif not nt.group and nt.content == 0: # No te grup i mateix jugador
terrInfo = self.recursiveSetTerrainGroup(nt,grpnum,terrInfo)
return terrInfo
# Agrupa els tiles connectats, aprofita el bucle per comprovar grups morts i calcular puntuacio
def setTileGroups(self):
self.resetTileGroups()
self.resetScore()
self.deadGroups = []
lastGroup = 0
sz = self.gridsize
for y in range(0,sz):
for x in range(0,sz):
t = self.grid[y][x]
if t:
# Si no es buida, la sumem com a puntuacio de caselles del jugador (tile)
if t.content:
self.tileScore[t.content]+=1
if t.group == 0:
# Assignem nou grup
lastGroup += 1
if t.content:
dead = self.recursiveSetGroup(t,lastGroup)
if dead:
self.deadGroups.append(lastGroup)
else:
self.resetTileUsed()
terrInfo = {'count':0,1:0,2:0}
terrInfo = self.recursiveSetTerrainGroup(t,lastGroup,terrInfo)
# Puntuacio de terreny
if terrInfo[1]>terrInfo[2]:
self.terrScore[1]+=terrInfo['count']
elif terrInfo[1]<terrInfo[2]:
self.terrScore[2]+=terrInfo['count']
def deleteGroups(self):
if self.deadGroups:
sz = self.gridsize
for y in range(0,sz):
for x in range(0,sz):
t = self.grid[y][x]
if t and t.group in self.deadGroups:
# Contem la mort
pl = t.content
if pl in self.deads:
self.deads[pl]+=1
else:
self.deads[pl]=1
t.content = 0 # buidem casella
# Pinta de costat caselles (jugadors) i grups
def debugGrid(self):
txt = ""
sz = self.gridsize
for y in range(0,sz):
for x in range(0,sz):
t = self.grid[y][x]
if t:
txt += str(t.content)
else:
txt += " "
txt += " " # deixem un espai entre mig
for x in range(0,sz):
t = self.grid[y][x]
if t:
txt += str(t.group) if t.content else str(0) # per no liar, no imprimim els grups de caselles buides
else:
txt += " "
txt += "\n"
print txt
print self.score()
def reloadGridGraphics(self):
# Actualitza els grafics de cada tile
sz = self.gridsize
for y in range(0,sz):
for x in range(0,sz):
t = self.grid[x][y]
if t:
if t.content == 0: # No pertany a cap jugador
t.upperimg = self.baseatlas['tileNone']
elif t.upperimg == self.baseatlas['tileNone']: # Si encara no te imatge...
if t.content == 1: # Jugador 1
posibles = [i for i in self.playeratlas.textures.keys() if i.startswith("wood")]
else: # Jugador 2
posibles = [i for i in self.playeratlas.textures.keys() if i.startswith("sand")]
t.upperimg = self.playeratlas[random.choice(posibles)]
# Realitza un moviment. Torna fals si no es possible (suicidi), o true en cas contrari
def doMovement(self,t,player=None):
if t.content == 0: # si ja està ocupada res
# Per poder provar jugades desde l'ordinador
if player: t.content = player
else: t.content = self.player
self.setTileGroups()
# Validem que no hi hagi suicidi
dead = False
if t.group in self.deadGroups:
# Pot ser que sigui un suicidi d'atac: Estas matant un altre grup i per tant no mors
# Per compvoar això, si hi ha més d'un grup mort, treiem el nostre grup dels grups
# morts, matem els grups, refem els grups, i si estem vius es jugada valida
dead = True
if len(self.deadGroups) > 1:
state = self.getState()
self.deadGroups.remove(t.group)
otherDeads = self.deadGroups
self.deleteGroups()
self.setTileGroups()
if not t.group in self.deadGroups:
dead = False
self.deadGroups = otherDeads
self.loadState(state)
return not dead
# if dead:
# return False
# else:
# # Correcte, seguim jugada
# return True
else:
return False
@mainthread
def manageTurn(self,t,playerMove=True):
# Si el jugador intenta jugar mentre es el torn de la IA, no fem res
if playerMove and not self.gametype == GAMETYPE["PVP"] and self.player == 2:
return False
# En cap cas es pot jugar sobre una casella ocupada
if not t.content == 0:
return False
state = self.getState()
if self.doMovement(t):
# Correcte, seguim jugada
self.deleteGroups()
self.reloadGridGraphics()
self.lastPass = False
self.debugGrid()
# Guardem estat a cada moviment
self.nextPlayer()
self.store.put('save',state=self.getState())
else:
self.loadState(state)
launchSimpleModal("INVALID MOVE\nYou can't suicide.")
playClickSound()
@mainthread
def doPass(self,playerMove=True):
if playerMove and not self.gametype == GAMETYPE["PVP"] and self.player == 2:
return False
if not self.gametype == GAMETYPE["PVP"] and self.player == 2:
launchSimpleModal("CPU passed.")
if self.lastPass:
# Final del joc
self.gameOver()
else:
self.lastPass = True
self.nextPlayer()
def getNextPlayerNum(self,player):
if player == 1: player = 2
elif player == 2: player = 1
return player
def nextPlayer(self):
# Gestiona el canvi de jugador
self.player = self.getNextPlayerNum(self.player)
self.gui.setPlayerText(self.player)
if not self.gametype == GAMETYPE["PVP"] and self.player == 2:
self.startCpu()
def startCpu(self):
threading.Thread(target=self.cpu.move, args=(self,)).start()
# Retorna la puntuació en un moment concret, desglosada
def score(self):
score = {1:0,2:0}
deadScore = {1:0,2:0}
# Sumem mortes
deadScore[1] += self.deads[2] if 2 in self.deads else 0
deadScore[2] += self.deads[1] if 1 in self.deads else 0
for k in score.keys():
score[k]+=deadScore[k]+self.tileScore[k]+self.terrScore[k]
score['tileScore'] = self.tileScore
score['terrScore'] = self.terrScore
score['deadScore'] = deadScore
return score
@mainthread
def gameOver(self):
score = self.score()
# Qui ha guanyat?
whowin = "TIE!"
if score[1]>score[2]:
whowin = "Player 1 WINS!"
elif score[1]<score[2]:
whowin = "Player 2 WINS!"
# Esborrem partida, mostrem guanyador, tornem al menu
if self.store.exists('save'):
self.store.delete('save')
launchSimpleModal("Game Finished\nP1: "+str(score[1])+" | P2: "+str(score[2])+"\n"+whowin)
self.parent.parent.gameOver()
def add_data(store, name, data):
store = DictStore(store)
if not store.exists(name) and name != "default":
store.put(name, data=data)
else:
raise StoreException("The dice exist")
def __init__(self, filename):
self.storage = DictStore(filename)
if 'vals' not in self.storage:
self.storage['vals'] = dict()
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()
from kivy.clock import Clock
import threading
import datetime
import os
from ImageDownload import downloadimages
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)
class Mirror(App):
#configs = DictProperty()
#sys = DictProperty()
mirror_name = StringProperty()
multicast_ip = StringProperty('224.3.29.71')
multicast_port = NumericProperty(11088)
store = DictStore('mirror_config.pckl')
dgram_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
tcp_server = socket.socket()
# Returns {'Mirror name':[(ip,port),last_edited_time]} to client
def start_dgram_server(self):
# 1. Create datagram socket
self.dgram_server.bind(('', self.multicast_port))
Logger.info('Multicast server created, on ip {}, port {}'.format(
self.multicast_ip, self.multicast_port))
# 2. Add socket to multicast group
multicast_ip = socket.inet_aton(
self.multicast_ip) # Converts ip into packed 32-bit binary'
mreq = struct.pack('4sL', multicast_ip, socket.INADDR_ANY)
self.dgram_server.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, mreq)
# 3. Set socket to listening mode
while True:
Logger.info('Awaiting dgram message on ip {}, port {}'.format(
self.multicast_ip, self.multicast_port))
# 4. Receive request from client
data_encoded, address = self.dgram_server.recvfrom(4096)
Logger.info(
'Received {} bytes on datagram server, from ip {}'.format(
len(data_encoded), address))
try:
data, request = pickle.loads(data_encoded)
except:
Logger.error('Failed to unpickle data!')
# 5. Reply to client with name and id of mirror, and when it was last edited
# Packaged in tuple of form: (mirror_id,mirror_name,last_edited)
if request == 'name':
try:
mirror_data = self.store.get(MIRROR_ID)
mirror_name = mirror_data['sys']['mirror_name']
last_edited = mirror_data['sys']['last_edited']
reply = pickle.dumps((MIRROR_ID, mirror_name, last_edited),
protocol=2)
except:
Logger.error(
'Was unable to find and/or pickle mirror data! Failed to reply to multicast.'
)
try:
self.dgram_server.sendto(reply, address)
Logger.info(
'Replied to multicast request from {}'.format(address))
except:
Logger.error('Failed to send reply to multicast!')
Logger.info('Shutting down DGRAM server.')
def start_tcp_server(self):
# 1. Create socket
try:
self.tcp_server.bind(('', 54321))
self.tcp_server.listen(5)
Logger.info('Created TCP server.')
except:
Logger.critical('Failed to create TCP server!')
# 2. Set to listening mode
while True:
Logger.info('Awaiting message on TCP server.')
client, address = self.tcp_server.accept()
Logger.info('Received TCP connection from ip {}.'.format(address))
# 3. Unpack data from client. format is tuple of (data,request)
try:
data_pickled = client.recv(4096)
data, request = pickle.loads(data_pickled)
Logger.info(
'Unpickled {} bytes via TCP connection. Request: {}'.
format(len(data_pickled), request))
except:
Logger.error('Failed to unpack mirror data on TCP server!')
continue
# 4. If request is to update_phone, send mirror info back in tuple (mirror_id,mirror_data)
# mirror_data is packaged in dict of form {'sys': ..., 'config': ...}
if request == 'update_phone':
Logger.info(
'Mirror data was requested from client. Packaging config files...'
)
try:
mirror_configs = self.store.get(MIRROR_ID)
configs_pickled = pickle.dumps((MIRROR_ID, mirror_configs),
protocol=2)
except:
Logger.error(
'Failed to load and/or pickle mirror configs!')
try:
client.send(configs_pickled)
Logger.info(
'Send mirror info back to client. Closing socket.')
except:
Logger.error(
'Failed to send mirror info back to client. Closing socket.'
)
client.close()
continue
# 6. If request is to update_mirror, updates mirror's info with received data
# Received data is of the form {'sys': ...,'configs': ...}
if request == 'update_mirror':
Logger.info('Updating mirror with received config.')
try:
self.store.put(MIRROR_ID,
sys=data['sys'],
configs=data['configs'])
except:
Logger.error('Failed to save new mirror data to storage.')
# Have to schedule these so they're done on the main thread
Clock.schedule_once(self.load_mirror_info, 0)
Clock.schedule_once(self.root.load_mirror, 0)
continue
Logger.info('Shutting down TCP server.')
def generate_widget(self, widget_type, config={}):
# 1. Create default widget
if widget_type == 'Time':
new_widget = TimeWidget()
elif widget_type == 'Weather':
new_widget = WeatherWidget()
elif widget_type == 'Clock':
new_widget = ClockWidget()
else:
Logger.critical("Not implemented yet how'd you get here")
return False
# 2. Load specified configuration
config_keys = config.keys()
new_widget_properties = new_widget.properties(
) # loads ALL kivy properties in list
for key in config_keys:
if key in new_widget_properties: # if key in config file is a kivy property of the widget, update it with that value
setattr(new_widget, key, config[key])
# 3. Initialize new widget to reflect specified config settings
new_widget.initialize()
return new_widget
def on_stop(self):
Logger.info('Application closed. Shutting down TCP and UDP servers.')
self.tcp_server.close()
self.dgram_server.close()
def load_mirror_info(self, *args):
# 1. If no config file exists, create one
if not self.store.keys():
Logger.info(
"Couldn't find anything in mirror_config.pckl. Creating new one."
)
self.store.clear()
self.store.put(MIRROR_ID,
sys=deepcopy(FRESH_CONFIG_FILE['sys']),
configs=deepcopy(FRESH_CONFIG_FILE['configs']))
# 2. Extract mirror info from storage
config_data = self.store.get(MIRROR_ID)
self.sys = config_data['sys']
self.configs = config_data['configs']
Logger.info('Loaded mirror info into memory.')
def load_city_list(self):
ts = time.time()
with open('city_list.json') as f:
self.city_list = json.load(f)
Logger.info('Loaded city list in {} seconds.'.format(time.time() - ts))
def build(self):
#0. Load city list
# Load city list into memory (takes like ~1 s, so does it asynchronously)
self.load_city_list()
#1. Load mirror config info
self.load_mirror_info()
#2. Start multicast server
# This server's only purpose is to listen for a ping and send back its name, id, and last edited
dgram_thread = threading.Thread(target=self.start_dgram_server)
dgram_thread.start()
#3. Start server to listen for TCP data
# This server is used for updating mirror config info from phone
tcp_thread = threading.Thread(target=self.start_tcp_server)
tcp_thread.start()
#4. Intialize and load mirror
r = RootLayout()
return r
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)
def test_dict_storage(self):
from kivy.storage.dictstore import DictStore
data = {}
self._do_store_test_empty(DictStore(data))
self._do_store_test_filled(DictStore(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)
def __init__(self):
self.data = DictStore('data.pickle')
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)
import os
import json
import webbrowser
from kivy.network.urlrequest import UrlRequest
from kivy.storage.dictstore import DictStore
from kivy.app import App
from kivy.properties import StringProperty
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager, Screen
BASE_URL = "https://c73e12ff8ac1.ngrok.io"
USER_ID = "user1"
store = DictStore("tempo.dat")
Builder.load_string("""
<HomeScreen>:
BoxLayout:
orientation: "vertical"
Button:
text: "Create order"
on_release: root.create_order()
Button:
text: "start transaction"
on_release: root.start_transaction()
Button:
text: "check if transaction is complete"
on_release: root.is_transaction_complete()
Label:
text: root.status
import android
except ImportError:
android = None
from kivy.core.window import Window
W = 333
Window.size = (W, W * 16 / 9)
from plyer import storagepath
if android:
from jnius import autoclass
from plyer.platforms.android import activity
store = DictStore("cryptculatorapp.data")
APK_FILE_PATH = storagepath.get_downloads_dir() + '/cryptculatorapp.apk'
class CustomTextInput(TextInput):
name = StringProperty('')
def on_text(self, instance, text):
store.put(self.name, value=text)
def copy(self, data=''):
Clipboard.copy(self.selection_text)
def cut(self):
Clipboard.copy(self.selection_text)
self.delete_selection()
class TransactionManager(object):
def __init__(self, filename='transaction_storage.pickle'):
self.dict_store = DictStore(filename)
self.current_id = self.get_current_id()
self.top_hash = self.get_top_hash()
def _clear(self):
self.current_id = 0
self.dict_store.clear()
self.top_hash = None
def get_current_id(self):
try:
return self.get_val("cur_id")
except KeyError:
return 0
def set_val(self, key, val):
self.dict_store[key] = {"val": val}
def get_val(self, key):
return self.dict_store[key]['val']
def set_current_id(self):
self.set_val("cur_id", self.current_id)
def validate_user_signature(self, user, signature):
"""
Validates the user's signature. Raises an exception on failure
:param user: user
:param signature: user signature
"""
def add_transaction(self, data, ts, user, signature, uuid=None, update_hashes=True):
if uuid is None:
uuid = uuid4()
insert_idx = self._get_prev_transaction_idx(ts, uuid)
if insert_idx is None:
insert_idx = 1
else:
insert_idx += 1
self._bubble_up(insert_idx)
self.validate_user_signature(user, signature)
new_item = {
"data": data,
"ts": ts,
"user": user,
"signature": signature,
"uuid": uuid,
}
hash = self.calculate_item_hash(new_item)
new_item['hash'] = hash
self.dict_store[insert_idx] = new_item
ts_list = self.get_by_timestamp(ts)
new_item.pop('hash', None)
ts_list.append(new_item)
self.set_val(self._ts_key(ts), ts_list)
self.current_id += 1
if update_hashes:
self.update_hashes(insert_idx)
self.set_current_id()
return insert_idx
def _ts_key(self, ts):
return 'ts%s' % ts
def get_by_timestamp(self, ts):
try:
return self.get_val(self._ts_key(ts))
except KeyError:
return []
def _bubble_up(self, start_idx):
if start_idx == None:
return
for idx in xrange(self.current_id, start_idx - 1, -1):
val = self.dict_store[idx]
self.dict_store[idx + 1] = val
def calculate_item_hash(self, item_data):
ts = item_data['ts']
uuid = item_data['uuid']
prev_item = self.get_previous_transaction(ts, uuid)
if prev_item is None:
prev_hash = ""
else:
prev_hash = prev_item['hash']
return self._get_item_hash(item_data, prev_hash)
def _get_item_hash(self, item_data, prev_hash):
# ts = item_data['ts']
# data = item_data['data']
# user = item_data['user']
# sig = item_data['signature']
m = md5()
m.update("%s%s%s" % (prev_hash, item_data['ts'], item_data['uuid']))
# m.update("%s%s%s%s%s" % (prev_hash, data, ts, user, sig))
return m.hexdigest()
def _get_prev_transaction_idx(self, ts, uuid):
idx = self.current_id
while idx > 0:
cmp_ts = self.dict_store[idx]['ts']
if cmp_ts > ts:
idx -= 1
elif cmp_ts == ts:
if self.dict_store[idx]['uuid'] > uuid:
idx -= 1
else:
break
else:
break
if idx == 0:
return None
return idx
def get_previous_transaction(self, ts, uuid):
idx = self._get_prev_transaction_idx(ts, uuid)
if idx is None:
return None
return self.dict_store[idx]
def get_top_hash(self):
try:
top_transaction = self.dict_store[self.current_id]
except KeyError:
return None
return top_transaction.get('hash', None)
def update_hashes(self, idx):
prev_item = self.dict_store[idx]
prev_hash = prev_item['hash']
idx += 1
while idx <= self.current_id:
item_data = self.dict_store[idx]
prev_hash = item_data['hash'] = self._get_item_hash(item_data, prev_hash)
self.dict_store[idx] = item_data
idx += 1
self.top_hash = prev_hash
def get_transaction(self, idx):
return self.dict_store[idx]
def resolve_missing_transactions(self, target_hash, transaction_gen):
lowest_idx = None
if target_hash != self.top_hash:
for batch_of_transactions in transaction_gen:
for transaction in batch_of_transactions:
transaction = copy.copy(transaction)
transaction.pop('hash', None)
list_of_transactions = self.get_by_timestamp(transaction['ts'])
if transaction not in list_of_transactions:
insert_idx = self.add_transaction(update_hashes=False, **transaction)
if lowest_idx is None or insert_idx < lowest_idx:
lowest_idx = insert_idx
if lowest_idx is not None:
self.update_hashes(lowest_idx)
if target_hash == self.top_hash:
break
def get_transactions_recent_to_old(self, batch_size=50):
idx = self.current_id
while idx > 0:
transactions = []
for i in xrange(idx, max(0, idx - batch_size), -1):
try:
transactions.append(self.get_transaction(i))
except KeyError:
continue
transactions.sort(key=lambda x: (x['ts'] * -1, x['uuid']))
idx -= batch_size
yield transactions
def game_button(self, instance):
for element in self.response.json()['results']:
if element['login'] == instance.text:
store = DictStore('store')
store.put(key='active_game', values=element['id'])
def __init__(self, filename='transaction_storage.pickle'):
self.dict_store = DictStore(filename)
self.current_id = self.get_current_id()
self.top_hash = self.get_top_hash()
