def setLista(self,
lista): #verificar se o goal esta na lista, se nao seta matar
#comparar com a que ja esta no robo, e se a caca que ele esta ido atras ainda existe
listaatt = Treasure(lista)
#listaatt = listaatt.ordenaListaCaca(self.getPos)
if (not self.getGoal in listaatt.getString()):
self.treasure = listaatt
self.setMatar(True)
else:
self.treasure = listaatt
def __init__(self):
self.tables = {
"A": [],
"B": [],
"C": [],
"D": [],
"E": [],
"F": [],
"G": [],
"H": [],
"I": []
}
for i in A:
self.tables["A"].append(Treasure.magic_item(i))
for i in B:
self.tables["B"].append(Treasure.magic_item(i))
for i in C:
self.tables["C"].append(Treasure.magic_item(i))
for i in D:
self.tables["D"].append(Treasure.magic_item(i))
for i in E:
self.tables["E"].append(Treasure.magic_item(i))
for i in F:
self.tables["F"].append(Treasure.magic_item(i))
for i in G:
self.tables["G"].append(Treasure.magic_item(i))
for i in H:
self.tables["H"].append(Treasure.magic_item(i))
for i in I:
self.tables["I"].append(Treasure.magic_item(i))
def trap_fn(row, level):
trap = "<p class='Text Body'>Trap: %s" % Dice.tableroller(
Traps.traptable)[1]
treasure = ""
if row[3]:
trlst = treasureformat(Treasure.Treasure("U%d" % level))
treasure = " with Treasure: %s" % string.join(trlst, ", ")
return trap + treasure
def monster_fn(row, level):
level = min(level, 8)
rand_tbl = randenc_select[level]
contents = Dice.tableroller(rand_tbl)
treasure = ""
if type(contents[1]) is type(""): # it's a monster
monster = contents[2]
hd = monster["hd"]
if hd[1] == 8:
monster["hitdice"] = "%d" % hd[0]
else:
monster["hitdice"] = "%dd%d" % hd[:-1]
if hd[2] != 0:
if hd[2] > 0:
monster["hitdice"] = "%s+%d" % (monster["hitdice"], hd[2])
else:
monster["hitdice"] = "%s%d" % (monster["hitdice"], hd[2])
tt = None
if type(monster["tt"]) == tuple:
tt = monster["tt"]
ls = []
for i in tt:
ls.append(str(i))
monster["tt"] = string.join(ls, ", ")
else:
tt = (monster["tt"], )
num = monster["noapp"]
num = Dice.D(*num)
if row[3]:
if monster["tt"] != "None":
treasure = None
try:
types, tr = Treasure.Factory(tt)
except:
tr = []
treasure = " with Treasure Type %s" % monster[-1]
trlst = treasureformat(tr)
if not treasure:
treasure = " with Treasure: " + string.join(trlst, ", ")
monster["num"] = num
monster = (statblock_fmt % monster)
hplist = []
for i in range(num):
hplist.append(Adventurer.hitpointblock(max(1, Dice.D(*hd))))
monster = monster + string.join(hplist, "\n")
elif type(contents[1]) != type(""):
args = contents[3:]
monster = contents[1](*args)
treasure = ""
else:
monster = contents[1]
if row[3]:
treasure = "with Treasure"
return "%s<p class='Text Body'>%s" % (monster, treasure)
class Room:
x = 0
y = 0
monster_list = []
treasure_list = []
monster_list.append(Creature.giant_spider_rarity())
monster_list.append(Creature.skeleton_rarity())
monster_list.append(Creature.orc_rarity())
monster_list.append(Creature.troll_rarity())
treasure_list.append(Treasure.gemstone_rarity())
treasure_list.append(Treasure.gold_jewelry_rarity())
treasure_list.append(Treasure.loose_coins_rarity())
treasure_list.append(Treasure.small_treasure_chest_rarity())
def __init__(self, x, y):
self.x = x
self.y = y
def getx(self):
return self.x
def gety(self):
return self.y
def __init__(self, vel, modo, sentido, posin, li):
threading.Thread.__init__(self)
self.setDaemon(False)
self.velocidade = vel
self.l = LargeMotor('outA') # esquerda
self.r = LargeMotor('outD') # direita
self.cl = ColorSensor()
self.colors = ('unknown', 'black', 'blue', 'green', 'yellow', 'red',
'white', 'brown')
self.id = 'a0:f3:c1:0b:3c:48'
#self.cor = cor
self.sentido = sentido
self.modo = modo
self.posX = int(posin[0])
self.posY = int(posin[2])
self.treasure = Treasure(li)
self.parado = True
self.estounacaca = False
self.goal = 0
self.matar = False
self.setPausar()
self.ladversario = []
self.enviar = False
def __init__(self):
self.tables = {"A" : [], "B" : [], "C" : [], "D" : [], "E" : [], "F" : [], "G" : [] , "H" : [], "I" : []}
for i in A:
self.tables["A"].append(Treasure.magic_item(i))
for i in B:
self.tables["B"].append(Treasure.magic_item(i))
for i in C:
self.tables["C"].append(Treasure.magic_item(i))
for i in D:
self.tables["D"].append(Treasure.magic_item(i))
for i in E:
self.tables["E"].append(Treasure.magic_item(i))
for i in F:
self.tables["F"].append(Treasure.magic_item(i))
for i in G:
self.tables["G"].append(Treasure.magic_item(i))
for i in H:
self.tables["H"].append(Treasure.magic_item(i))
for i in I:
self.tables["I"].append(Treasure.magic_item(i))
def execute(self):
#allow these commands regardless
creature = self.level.get_current_room().creature
if( self.command == "help" ):
self.execute_help()
elif( self.command == "vhelp" ):
self.execute_vhelp()
elif( self.command == "map" ):
self.execute_map()
elif( self.command == "look-around" ):
self.execute_lookaround()
elif( self.command == "study" ):
self.execute_study()
elif( self.command[0:9] == "inventory" ):
self.execute_inventory()
elif( self.command[0:7] == "inspect" ):
self.execute_inspect()
elif( self.command == "switch-weapon" ):
self.execute_switch_weapon()
elif( self.command == "switch-armor" ):
self.execute_switch_armor()
elif( self.command == "status" ):
self.execute_status()
#if there are NO creatures in the room, then allow these
#command
elif( self.level.get_current_room().creature == None ):
if( self.command == "pickup" ):
self.execute_pickup()
elif( self.command[0:4] == "drop" ):
self.execute_drop()
elif( self.command == 'use-potion' ):
self.execute_use_potion()
elif( self.command == 'buy-attribute' ):
self.execute_buy_attribute()
#possibly generate mob since there is no creature in a room
if( creature == None and self.level.mob_size > 0):
if( random.randrange(100) > 80 ):
cf = Creature_Factory()
c = cf.generate()
self.level.get_current_room().creature = c
self.level.mob_size -= 1
print c.name + " entered the room!"
#if there is a creature in the room, then allow these commands
elif( self.level.get_current_room().creature != None ):
if( self.command == "flee" ):
self.execute_flee()
elif( self.command == "attack" ):
self.execute_attack()
elif( self.command == "magic-attack" ):
self.execute_magic_attack()
elif(self.command == 'use-potion' ):
self.execute_use_potion()
#check if the creature or the player is dead
if(creature != None):
if( creature.hp <= 0 ):
diff = creature.level - self.player.level
xp = 0
if diff >= 0:
xp = creature.calc_experience() * (diff+1)
else:
tmp = (diff * -20) // 100
xp = int(creature.calc_experience() * tmp)
self.player.grant_xp(xp)
print "You gained %s XP for slaying the" % xp,
print creature.name + "."
print "You collected %s gold coins from the corpse." % creature.gold
self.player.gold += creature.gold
tf = Treasure()
treasure = tf.generate(creature.level)
for t in treasure:
self.level.get_current_room().item.append(t)
for p in creature.all_equipment():
self.level.get_current_room().item.append(p)
self.level.get_current_room().creature = None
if(self.player.hp <= 0):
print "Game Over! You died sucka!"
sys.exit()
def treasure(self):
# metod for trease initialize
t = Treasure()
return t.generate_treasure()
def __init__(self, hoard):
self.coins = Treasure.Coins(hoard["coins"])
self.hoards = []
for t in hoard["treasure"]:
self.hoards.append(Treasure.hoard_treasure_line(t))
def __init__(self, coins_list):
self.lines = []
for c in coins_list:
self.lines.append(Treasure.Coins(c))
def __init__(self, hoard):
self.coins = Treasure.Coins(hoard["coins"])
self.hoards = []
for t in hoard["treasure"]:
self.hoards.append(Treasure.hoard_treasure_line(t))
def null_fn(row, level):
if row[3]:
trlst = treasureformat(Treasure.Treasure("U%d" % level))
return "<p class='Text Body'>" + row[
2] + " with Treasure: " + string.join(trlst, ", ")
return "<p class='Text Body'>" + row[2]
class Robo(threading.Thread):
def __init__(self, vel, modo, sentido, posin, li):
threading.Thread.__init__(self)
self.setDaemon(False)
self.velocidade = vel
self.l = LargeMotor('outA') # esquerda
self.r = LargeMotor('outD') # direita
self.cl = ColorSensor()
self.colors = ('unknown', 'black', 'blue', 'green', 'yellow', 'red',
'white', 'brown')
self.id = 'a0:f3:c1:0b:3c:48'
#self.cor = cor
self.sentido = sentido
self.modo = modo
self.posX = int(posin[0])
self.posY = int(posin[2])
self.treasure = Treasure(li)
self.parado = True
self.estounacaca = False
self.goal = 0
self.matar = False
self.setPausar()
self.ladversario = []
self.enviar = False
def getEnviar(self):
return self.enviar
def setEnviar(self, valor):
self.enviar = valor
def getladversario(self):
#return self.ladversario
return self.ladversario
def setladversario(self, ladversario):
self.ladversario = ladversario
def setMatar(self, val):
self.matar = val
def getGoal(self):
return str(self.goal)
def getTreasure(self):
return self.treasure
def isNacaca(self):
return self.estounacaca
def run(self):
j = 0
self.moverAutomatico()
#self.treasure.ordenaListaCaca(self.getPos())
#time.sleep(4)
def getPos(self):
return (str(self.posX) + ":" + str(self.posY))
def isParado(self):
return self.parado
def setLista(self,
lista): #verificar se o goal esta na lista, se nao seta matar
#comparar com a que ja esta no robo, e se a caca que ele esta ido atras ainda existe
listaatt = Treasure(lista)
#listaatt = listaatt.ordenaListaCaca(self.getPos)
if (not self.getGoal in listaatt.getString()):
self.treasure = listaatt
self.setMatar(True)
else:
self.treasure = listaatt
def command(self, comando):
if comando in 'Ww':
self.moverFrente()
elif comando in 'Aa':
self.moverEsquerda()
elif comando in 'Ss':
self.moverRetornar()
elif comando in 'Dd':
self.moverDireita()
elif comando in 'Vv':
self.obterCaca()
else:
self.setPausar()
#Isso aqui eh aqui mesmo?
def obterCaca(self):
self.estounacaca = True
#isso aqui eh aqui mesmo?
def atualizarMapa(self):
pass
def getId(self):
return self.id
def getColor(self):
return self.cor
def setVel(self, vel):
if vel < 1000 and vel > 0:
self.velocidade = vel
else:
print('Somente valores de 0 a 999')
def setPausar(self):
self.r.stop(stop_action="hold")
self.l.stop(stop_action="hold")
def setSentido(self, sentido):
if sentido in 'NSLO':
self.sentido = sentido
else:
print('Somente permitidos N ou S ou L ou O para sentido')
def setNacaca(self, val):
self.estounacaca = val
def goToPos(self, pos):
tesX = int(pos[0])
tesY = int(pos[2])
if self.sentido in ['L', 'O']:
if tesX > self.posX:
self.goLeste(tesX)
elif tesX < self.posX:
self.goOeste(tesX)
if tesY > self.posY:
self.goNorte(tesY)
elif tesY < self.posY:
self.goSul(tesY)
print("Cheguei na posicao: " + pos)
elif self.sentido in ['N', 'S']:
if tesY > self.posY:
self.goNorte(tesY)
elif tesY < self.posY:
self.goSul(tesY)
if tesX > self.posX:
self.goLeste(tesX)
elif tesX < self.posX:
self.goOeste(tesX)
print("Cheguei na posicao:" + pos)
#retorna uma lista com as posicoes a serem percorridas
#entre a posicao atual do robo (self.posX e self.posY) e a caca (self.goal)
#exemplo: entre Robo em (0:0) virado para Norte ou sul
#e Tesouro em (3:2) ele retorna uma lista assim: ['0:1', '0:2', '1:2', '2:2', '3:2']
#se fosse com o sentido em lLeste ou Oeste seria: ['1:0', '2:0', '3:0', '3:1', '3:2']
def fazCaminho(self):
#posicao tesouro em int
tesX = int(self.goal[0])
tesY = int(self.goal[2])
#posicao robo em int
robX = self.posX
robY = self.posY
#posicao robo e tesouro em String
posRob = str(robX) + ':' + str(robY)
posTes = str(tesX) + ':' + str(tesY)
#lista de posicoes para ir na horizontal
#lista de posicoes para ir na vertical
lhorizontal = []
lvertical = []
#sao o passo da funcao range, exemplos:
#range(0, 5, 2) = [0, 2, 4]
#range(0, 5, 1) = [0, 1, 2, 3, 4]
aux = 666
auy = 666
#define se devemos ir somando ou subtraindo no passo do range
#se o robo estiver a esquerda do tesouro:
# ele deve ir para a direita
#se o robo estiver a direita do tesouro:
# ele deve ir para a esquerda
if robX < tesX:
aux = 1
else:
aux = -1
#define se devemos ir somando ou subtraindo no passo do range
#se o robo estiver para baixo do tesouro:
# ele deve ir para cima do tesouro
#se o robo estiver para cima do tesouro:
# ele deve ir para baixo
if robY < tesY:
auy = 1
else:
auy = -1
#se o robo nao esta em cima do tesouro:
# se o sentido atual for Norte ou Sul:
# deve primeiro se mexer/listar na vertical
# senao:
# deve primeiro se mexer/listar na horizontal
if posRob != posTes:
if self.sentido in ['N', 'S']:
for i in range(robY + auy, tesY + auy, auy):
coordenada = str(robX) + ':' + str(i)
lvertical.append(coordenada)
#soh existe variavel coordenada se ele faz o for aqui de cima
#e ele soh entra nesse for se robo e tesouro nao estiverem na msm linha
if robY != tesY:
robY = int(coordenada[2])
for i in range(robX + aux, tesX + aux, aux):
coordenada = str(i) + ':' + str(robY)
lhorizontal.append(coordenada)
else:
for i in range(robX + aux, tesX + aux, aux):
coordenada = str(i) + ':' + str(robY)
lhorizontal.append(coordenada)
#soh existe variavel coordenada se ele faz o for aqui de cima
#e ele soh entra nesse for se robo e tesouro nao estiverem na msm coluna
if robX != tesX:
robX = int(coordenada[0])
for i in range(robY + auy, tesY + auy, auy):
coordenada = str(robX) + ':' + str(i)
lvertical.append(coordenada)
if self.sentido in ['N', 'S']:
return lvertical + lhorizontal
else:
return lhorizontal + lvertical
# Exemplo: Robo esta em (0:0) e precisa ir pra (0:1), mas em (0:1) ha um adversario.
# entao ele verifica qual a proxima posicao que deve ir depois de (0:1), vamos supor que seja (0:2).
# entao ele faz um desvio pela lateral
# Esse metodo nao movimenta o robo, apenas retorna uma lista das posicoes que devem ser tomadas para
# contornar o adversario em forma de C
def desviaEmC(self, proxProx):
# Se existir uma posicao alem da proxima
if proxProx != 0:
# Se estiver na regiao e na mesma coluna
if self.posX != 0 and self.posY < 5 and self.posX == int(
proxProx[0]) and self.posY < int(proxProx[2]):
pos1 = str(self.posX - 1) + ':' + str(self.posY)
pos2 = str(self.posX - 1) + ':' + str(self.posY + 1)
pos3 = str(self.posX - 1) + ':' + str(self.posY + 2)
return [pos1, pos2, pos3]
# Se estiver na regiao e na mesma coluna
elif self.posX != 0 and self.posY > 1 and self.posX == int(
proxProx[0]) and self.posY > int(proxProx[2]):
pos1 = str(self.posX - 1) + ':' + str(self.posY)
pos2 = str(self.posX - 1) + ':' + str(self.posY - 1)
pos3 = str(self.posX - 1) + ':' + str(self.posY - 2)
return [pos1, pos2, pos3]
# Se estiver na regiao e na mesma linha
elif self.posY != 6 and self.posX < 5 and self.posY == int(
proxProx[2]) and self.posX < int(proxProx[0]):
pos1 = str(self.posX) + ':' + str(self.posY + 1)
pos2 = str(self.posX + 1) + ':' + str(self.posY + 1)
pos3 = str(self.posX + 2) + ':' + str(self.posY + 1)
return [pos1, pos2, pos3]
# Se estiver na regiao e na mesma linha
elif self.posY != 6 and self.posX > 1 and self.posY == int(
proxProx[2]) and self.posX > int(proxProx[0]):
pos1 = str(self.posX) + ':' + str(self.posY + 1)
pos2 = str(self.posX - 1) + ':' + str(self.posY + 1)
pos3 = str(self.posX - 2) + ':' + str(self.posY + 1)
return [pos1, pos2, pos3]
#tratando extremos daqui pra baixo
elif self.posX == 0 and self.posY < 5 and int(
proxProx[0]) == 0 and self.posY < int(proxProx[2]):
pos1 = str(self.posX + 1) + ':' + str(self.posY)
pos2 = str(self.posX + 1) + ':' + str(self.posY + 1)
pos3 = str(self.posX + 1) + ':' + str(self.posY + 2)
return [pos1, pos2, pos3]
elif self.posX == 0 and self.posY > 1 and int(
proxProx[0]) == 0 and self.posY > int(proxProx[2]):
pos1 = str(self.posX + 1) + ':' + str(self.posY)
pos2 = str(self.posX + 1) + ':' + str(self.posY - 1)
pos3 = str(self.posX + 1) + ':' + str(self.posY - 2)
return [pos1, pos2, pos3]
elif self.posY == 6 and self.posX < 5 and int(
proxProx[2]) == 6 and self.posX < int(proxProx[0]):
pos1 = str(self.posX) + ':' + str(self.posY - 1)
pos2 = str(self.posX + 1) + ':' + str(self.posY - 1)
pos3 = str(self.posX + 2) + ':' + str(self.posY - 1)
return [pos1, pos2, pos3]
elif self.posY == 6 and self.posX > 1 and int(
proxProx[2]) == 6 and self.posX > int(proxProx[0]):
pos1 = str(self.posX) + ':' + str(self.posY - 1)
pos2 = str(self.posX - 1) + ':' + str(self.posY - 1)
pos3 = str(self.posX - 2) + ':' + str(self.posY - 1)
return [pos1, pos2, pos3]
#Deve se chamar essa funcao quando o robo esta na frente de uma posicao impedida por outro robo
#Por exemplo: Se o robo esta em 1:3 e sentido norte e a funcao eh chamada, logo, presume-se que
#a posicao que devemos desviar eh a posicao 1:4 pois seria a proxima que o robo iria.
#Se o sentido fosse sul, a posicao bloqueada seria suposta como a 1:2
#Se o sentido fosse oeste, a posicao bloqueada seria suposta como a 2:3
#Se o sentido fosse leste, a posicao bloqueada seria suposta como a 0:3
#A funcao retorna uma lista com as posicoes a serem percorridas ate a caca desviando da
#posicao bloqueada
def desviaEmL(self):
tesX = int(self.goal[0])
tesY = int(self.goal[2])
robX = self.posX
robY = self.posY
posRob = str(robX) + ':' + str(robY)
posTes = str(tesX) + ':' + str(tesY)
lhorizontal = []
lvertical = []
aux = 666
auy = 666
if robX < tesX:
aux = 1
else:
aux = -1
if robY < tesY:
auy = 1
else:
auy = -1
if posRob != posTes:
if self.sentido in ['L', 'O']:
for i in range(robY + auy, tesY + auy, auy):
coordenada = str(robX) + ':' + str(i)
lvertical.append(coordenada)
if robY != tesY:
robY = int(coordenada[2])
for i in range(robX + aux, tesX + aux, aux):
coordenada = str(i) + ':' + str(robY)
lhorizontal.append(coordenada)
else:
for i in range(robX + aux, tesX + aux, aux):
coordenada = str(i) + ':' + str(robY)
lhorizontal.append(coordenada)
if robX != tesX:
robX = int(coordenada[0])
for i in range(robY + auy, tesY + auy, auy):
coordenada = str(robX) + ':' + str(i)
lvertical.append(coordenada)
if self.sentido in ['L', 'O']:
return lvertical + lhorizontal
else:
return lhorizontal + lvertical
def desvia(self, lcaminho, posOcupada):
posOcupadaX = int(posOcupada[0])
posOcupadaY = int(posOcupada[2])
index = lcaminho.index(posOcupada)
#tente pegar a proximo->proximo pos
try:
proxProx = lcaminho[index + 1] #isso da erro se n houver na lista
proxProxX = int(proxProx[0])
proxProxY = int(proxProx[2])
except:
proxProx = 0
#se robo e 'proxima->proxima pos' estao na msm linha ou coluna, desvia em C
if (self.posX == proxProxX
or self.posY == proxProxY) and (proxProx != 0):
ldesvio = self.desviaEmC(proxProx)
formaDoDesvio = 'C'
else:
ldesvio = self.desviaEmL()
formaDoDesvio = 'L'
#versao mais facil
for i in ldesvio:
self.goToPos(i)
return formaDoDesvio
# #######################################################
# for posDesv in ldesvio:
# if(not self.matar):
# if (self.treasure.getList()):
# print('Caminho de desvio: ')
# print(ldesvio)
# print('Indo para posicao de desvio: ')
# print(posDesv)
# self.parado = False
# ladversario = self.getladversario()
# if posDesv not in ladversario: #se a posicao que to indo n tem adversario
# self.goToPos(posDesv)
# else:
# self.desvia(lcaminho, posDesv)
# self.parado = True
# print("posicao do robo " + str(self.posX) + ":" + str(self.posY))
# print("posicao do goal " + str(self.goal))
# time.sleep(3)
# if(str(self.goal) == (str(self.posX) + ":" + str(self.posY))):
# self.estounacaca = True
# self.parado = True
# time.sleep(3)
# else:
# self.setPausar()
# print("acabou o desvio")
#NOVO'
def moverAutomatico(self):
formaDoDesvio = -1
self.ladversario = "1:1,2:2"
while (True):
if (not self.matar):
self.treasure.ordenaListaCaca(self.getPos())
#lcaca = self.treasure.getList()
print('Cacas a pegar: ' + self.treasure.getString())
if (self.treasure.getList()):
self.goal = self.treasure.popTreasure()
print('Indo para caca: ' + str(self.goal))
print("CAMINHO")
print(self.fazCaminho())
lcaminho = self.fazCaminho()
for i in lcaminho:
if (not self.matar):
self.parado = False
print(i)
ladversario = self.getladversario()
if i not in ladversario: #se a posicao que to indo n tem adversario
self.goToPos(i)
else:
formaDoDesvio = self.desvia(lcaminho, i)
self.parado = True
print("posicao do robo " +
(str(self.posX) + ":" + str(self.posY)))
print("posicao do goal " + str(self.goal))
time.sleep(3)
if formaDoDesvio == 'L':
print(
'Desvio feito em L. Indo para proximo tesouro')
break
if (str(self.goal) == (str(self.posX) + ":" +
str(self.posY))):
self.estounacaca = True
self.parado = True
time.sleep(3)
#self.estounacaca = False
#self.parado = False
else:
self.matar = True
else:
self.setPausar()
#print("acabou cacas")
def goLeste(self, x):
if self.sentido == 'N':
self.moverDireita()
while x > self.posX:
self.moverFrente()
elif self.sentido == 'L':
while x > self.posX:
self.moverFrente()
elif self.sentido == 'S':
self.moverEsquerda()
while x > self.posX:
self.moverFrente()
elif self.sentido == 'O':
self.moverRetornar()
while x > self.posX:
self.moverFrente()
def goOeste(self, x):
if self.sentido == 'N':
self.moverEsquerda()
while x < self.posX:
self.moverFrente()
elif self.sentido == 'L':
self.moverRetornar()
while x < self.posX:
self.moverFrente()
elif self.sentido == 'S':
self.moverDireita()
while x < self.posX:
self.moverFrente()
elif self.sentido == 'O':
while x < self.posX:
self.moverFrente()
def goSul(self, y):
if self.sentido == 'S':
while y < self.posY:
self.moverFrente()
elif self.sentido == 'O':
self.moverEsquerda()
while y < self.posY:
self.moverFrente()
elif self.sentido == 'N':
self.moverRetornar()
while y < self.posY:
self.moverFrente()
elif self.sentido == 'L':
self.moverDireita()
while y < self.posY:
self.moverFrente()
def goNorte(self, y):
if self.sentido == 'N':
while y > self.posY:
self.moverFrente()
elif self.sentido == 'L':
self.moverEsquerda()
while y > self.posY:
self.moverFrente()
elif self.sentido == 'S':
self.moverRetornar()
while y > self.posY:
self.moverFrente()
elif self.sentido == 'O':
self.moverDireita()
while y > self.posY:
self.moverFrente()
def moverFrente(self):
#self.enviar = True
self.parado = False
print("movendo frente")
#time.sleep(10)
#self.parado = True
self.cl.mode = 'COL-COLOR'
if self.colors[self.cl.value()] == "green" or self.colors[
self.cl.value()] == "yellow" or self.colors[
self.cl.value()] == "blue":
while self.colors[self.cl.value()] == "green" or self.colors[
self.cl.value()] == "yellow" or self.colors[
self.cl.value()] == "blue":
self.r.run_forever(speed_sp=self.velocidade)
self.l.run_forever(speed_sp=self.velocidade)
else:
self.setPausar()
#self.enviar = False
if self.colors[self.cl.value()] == "unknown":
while self.colors[self.cl.value()] != "black":
self.r.run_forever(speed_sp=self.velocidade)
while self.colors[self.cl.value()] != "green":
while self.colors[self.cl.value()] == "black":
self.r.run_forever(speed_sp=self.velocidade / 2)
self.l.run_forever(speed_sp=self.velocidade)
while self.colors[self.cl.value()] == "white":
self.r.run_forever(speed_sp=self.velocidade)
self.l.run_forever(speed_sp=self.velocidade / 2)
if self.colors[self.cl.value()] == "yellow":
self.l.run_forever(speed_sp=self.velocidade)
self.r.run_forever(speed_sp=self.velocidade)
time.sleep(0.1)
break
if self.colors[self.cl.value()] == "blue":
self.l.run_forever(speed_sp=self.velocidade)
self.r.run_forever(speed_sp=self.velocidade)
time.sleep(0.1)
break
else:
self.l.run_forever(speed_sp=self.velocidade)
self.r.run_forever(speed_sp=self.velocidade)
time.sleep(0.1)
#self.enviar = False
self.setPausar()
if self.colors[self.cl.value()] == "green":
#atualizando sentido
if self.sentido == 'O':
self.posX -= 1
elif self.sentido == 'S':
self.posY -= 1
elif self.sentido == 'L':
self.posX += 1
elif self.sentido == 'N':
self.posY += 1
self.parado = True
self.enviar = True
print("Posicao atual " + self.getPos())
self.enviar = False
def moverEsquerda(self):
self.parado = False
print("Indo para esquerda")
self.cl.mode = 'COL-COLOR'
while self.colors[self.cl.value()] != "black":
self.l.run_forever(speed_sp=0)
self.r.run_forever(speed_sp=self.velocidade)
else:
self.setPausar()
self.setPausar()
#atualizando sentido
if self.sentido == 'N':
self.sentido = 'O'
elif self.sentido == 'O':
self.sentido = 'S'
elif self.sentido == 'S':
self.sentido = 'L'
elif self.sentido == 'L':
self.sentido = 'N'
self.moverFrente()
self.parado = True
def moverDireita(self):
self.parado = False
print("Indo para direita")
self.cl.mode = 'COL-COLOR'
while self.colors[self.cl.value()] == "green":
self.l.run_forever(speed_sp=self.velocidade)
self.r.run_forever(speed_sp=self.velocidade)
else:
self.r.stop(stop_action="hold")
#print(self.cl.value())
while self.colors[self.cl.value()] == "black":
self.l.run_forever(speed_sp=self.velocidade)
self.r.run_forever(speed_sp=0)
# print(self.cl.value())
while self.colors[self.cl.value()] != "black":
self.r.stop(stop_action="hold")
self.l.run_forever(speed_sp=self.velocidade)
#self.r.run_forever(speed_sp=40)
#print(self.cl.value())
#while
#else:
# self.r.run_forever(speed_sp=self.velocidade)
#atualizando sentido
if self.sentido == 'N':
self.sentido = 'L'
elif self.sentido == 'L':
self.sentido = 'S'
elif self.sentido == 'S':
self.sentido = 'O'
elif self.sentido == 'O':
self.sentido = 'N'
self.moverFrente()
self.parado = True
def moverRetornar(self):
self.parado = False
print("Retornando")
self.cl.mode = 'COL-COLOR'
while self.colors[self.cl.value()] == "green":
self.l.run_forever(speed_sp=-self.velocidade)
while self.colors[self.cl.value()] == "black":
self.l.run_forever(speed_sp=-self.velocidade)
while self.colors[self.cl.value()] != "black":
self.l.run_forever(speed_sp=-self.velocidade)
self.setPausar()
#atualizando sentido
if self.sentido == 'N':
self.sentido = 'S'
elif self.sentido == 'S':
self.sentido = 'N'
elif self.sentido == 'O':
self.sentido = 'L'
elif self.sentido == 'L':
self.sentido = 'O'
self.parado = True
self.moverFrente()
def initialize_page(self, fields, pages, external_data):
enemies = fields['Monster Team']
# xp_text = ', '.join([f'{e["Name"]}: {e["XP Value"]}xp' for e in enemies])
# print(enemies[0]['XP Value'])
# self.xp_total = sum(e['XP Value'] if type(e['XP Value']) is int else 0 for e in enemies)
# xp_text = f'''{self.xp_total} XP Total'''
lair = external_data['Lair Data']
if lair is None:
self.treasure = treasure_dict = {
'cp': 0,
'sp': 0,
'ep': 0,
'gp': 0,
'pp': 0,
'items': []
}
else:
self.treasure = treasure_dict = Treasure.parse_treasure_text(
lair['Treasure'], wandering=False)
for enemy in enemies:
if 'Treasure' in enemy:
treasure = Treasure.parse_treasure_text(enemy['Treasure'])
else:
treasure = {
c['Entry_ID']: int(c['Data'])
for c in enemy['Characters_meta']
if c['Type'] == 'Treasure'
}
treasure['items'] = [
i['Entry_ID'] for i in enemy['Characters_meta']
if i['Type'] == 'Equipment'
]
for k, v in treasure.items():
treasure_dict[k] += v
# import pprint
# pprint.pprint(treasure_dict['items'])
# treasure_text =\
# f'''cp: {treasure_dict['cp']}<br />sp: {treasure_dict['sp']}<br />ep: {treasure_dict['ep']}<br />\
# gp: {treasure_dict['gp']}<br />pp: {treasure_dict['pp']}'''
def get_full_items(items):
items_table = DbQuery.getTable('Items')
items_indexed = {i['unique_id']: i for i in items_table}
full_items = []
for item in items:
if type(item) is tuple:
gem_type, actual_value = item
gem_type_list = [
i for i in items_table if i['Subcategory'] == gem_type
]
gem_item = gem_type_list[Dice.randomInt(
0,
len(gem_type_list) - 1)]
gem_item = copy(gem_item)
gem_item['Value'] = actual_value
full_items.append(gem_item)
elif type(item) is list:
print('list:', item)
else:
item_dict = copy(items_indexed[item])
if item_dict['Category'] == 'Jewellery':
item_dict['Value'] = Dice.rollString(
item_dict['Value'])
full_items.append(item_dict)
return full_items
treasure_dict['items'] = get_full_items(treasure_dict['items'])
return {
# 'XP Text': xp_text,
# 'Treasure Text': treasure_text,
'CP': treasure_dict['cp'],
'SP': treasure_dict['sp'],
'EP': treasure_dict['ep'],
'GP': treasure_dict['gp'],
'PP': treasure_dict['pp'],
'Items': treasure_dict['items'],
}
def accept(self, fields, pages, external_data):
encounters = DbQuery.getTable('Encounters')
encounters_indexed = {e['unique_id']: e for e in encounters}
characters = DbQuery.getTable('Characters')
characters_indexed = {c['unique_id']: c for c in characters}
character_classes = DbQuery.getTable('Classes')
c_classes_indexed = {c['unique_id']: c for c in character_classes}
party_treasure = [
t for t in self.campaign['Campaigns_meta']
if t['Type'] == 'Party Treasure'
]
everything_else = [
e for e in self.campaign['Campaigns_meta']
if e['Type'] != 'Party Treasure'
]
# new_treasure = deepcopy(pages['Wrap Up'].treasure)
new_treasure = {
'cp': fields['CP'],
'sp': fields['SP'],
'ep': fields['EP'],
'gp': fields['GP'],
'pp': fields['PP'],
'items': fields['Items'],
}
new_treasure_xp_value = Treasure.get_xp_value(new_treasure)
for pt in party_treasure:
t = pt['Data']
t = json.loads(t)
for k, v in t.items():
# print(k, v)
new_treasure[k] += v
new_treasure_entry = {
'Type': 'Party Treasure',
'Entry_ID': None,
'Data': json.dumps(new_treasure),
'Notes': None
}
everything = everything_else + [
new_treasure_entry,
]
DbQuery.begin()
DbQuery.deleteRow('Campaigns_meta', 'campaign_id',
self.campaign['unique_id'])
for i in everything:
row = self.campaign['unique_id'], i['Type'], i['Entry_ID'], i[
'Data'], i['Notes']
DbQuery.insertRow('Campaigns_meta', row)
# DbQuery.commit()
self.campaign['Campaigns_meta'] = everything
encounter_id = pages['Encounter Tracker'].encounter_id
enemies_serialized = encounters_indexed[encounter_id]['enemy_team']
enemies = json.loads(enemies_serialized)
xp_total = sum(e['XP Value'] for e in enemies)
if fields['Include Treasure XP']:
xp_total += new_treasure_xp_value
pc_team = external_data['PC Team']
xp_eligible = []
for pc in pc_team:
pc_id = pc['unique_id']
pc = characters_indexed[pc_id]
current_hp = get_character_hp(pc)
if current_hp > 0:
xp_eligible.append(pc)
num_of_eligible = len(xp_eligible)
xp_per = xp_total // num_of_eligible
# print(xp_total, num_of_eligible, xp_per)
from decimal import Decimal
for pc in xp_eligible:
pc_id = pc['unique_id']
xp_list = str(pc['XP']).split('/')
add_xp = xp_per // len(xp_list)
pc_class_list = pc['Classes'].split('/')
if len(pc_class_list) == 1:
cl = c_classes_indexed[pc_class_list[0]]
xp_bonus_string = cl['Experience_Bonus']
xp_bonus = SystemSettings.parse_xp_bonus(xp_bonus_string, pc)
if xp_bonus:
add_xp = int(add_xp *
(1 + Decimal(xp_bonus) / Decimal(100)))
new_xp_list = [int(xp) + add_xp for xp in xp_list]
new_xp = '/'.join(str(xp) for xp in new_xp_list)
DbQuery.update_cols('Characters', 'unique_id', pc_id, ('XP', ),
(new_xp, ))
DbQuery.commit()