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 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)
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()
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 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 note_Update(touch):
curnote = sm.children[0]
newnotetext = curnote.txt.text
notecolor_nw_up = curnote.dropdown.main.background_color
notecolor_nw_up = list(notecolor_nw_up)
if curnote.txt.text != '':
var = sm.current
sm.transition = WipeTransition()
sm.current = 'notes'
store = DictStore('store13.dat')
mylist = store['index']['num']
mylist.remove(var)
store['index']['num'] = mylist
#removing df item
store.delete(var)
#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)
#adding new note
#working out timestamp
timenow = time.asctime(time.localtime(time.time()))
timenow = str(timenow)
timeraw = timenow[7:19]
strip = timeraw.replace(' ', '')
timemark = strip.replace(':', '')
timestamp = timemark
notetime = 'On ' + timenow[:10] + ' at ' + timenow[
11:19]
#StoreData
if 'index' in store.keys():
card = store['index']['num']
card.append(timestamp)
store['index']['num'] = card
else:
store['index'] = {'num': []}
card = store['index']['num']
card.append(timestamp)
store['index']['num'] = card
store[timestamp] = {
'note': newnotetext,
'notetime': notetime,
'color': notecolor_nw_up
}
#Note
note = Note(newnotetext[10:], timestamp)
#NoteButton
notebutton = note.button
notebutton.background_color = notecolor_nw_up
notebutton.name = timestamp
if len(newnotetext) > 20:
notebutton.text = newnotetext[:
20] + '...' + '\n %s' % notetime
else:
notebutton.text = newnotetext + '\n ' + notetime
notes.stack.add_widget(notebutton,
len(notes.stack.children))
#NoteScreen
notescreen = note.notescreen
notescreen.name = timestamp
notescreen.txt.text = newnotetext
notescreen.dropdown.main.background_color = notecolor_nw_up
sm.add_widget(notescreen)
notescreen.update_button.bind(on_release=note_Update)
notescreen.actionprevious.bind(on_release=toNotesright)
notescreen.delete_button.bind(on_release=delNote)
