def allPosTag(self):
i = float(1)
tot = len(glob.glob(self.folderDialoghiClean + '*'))
ifile = len(glob.glob(self.folderDialoghiPosTag + '*'))
for fil in glob.glob(self.folderDialoghiClean + u'*'):
try:
dlg = []
for line in SaveLoad.LoadLines(fil):
if len(line.strip()) > 0:
line = unicode(line)
line = line.lower()
l = self.pos.PosTag(line)
dlg.append(l)
#salvo il file postaggato e senza \n inutili
filename = str(ifile) + u'.txt'
filename = self.folderDialoghiPosTag + filename
#salvo il file dei dialoghi
if SaveLoad.SaveByte(dlg, filename):
ifile += 1
except:
#potrebbero esserci errori di qualsiasi natura nei file, in questo caso ignoro il file e passo al successivo
pass
print "elaborazione file ", fil[len(self.folderDialoghiClean
):], " - ", i, " / ", tot
i += 1
def __Save(self):
print SaveLoad.SaveByte(self.rankRes, "self.rankRes")
for i in self.rankRes.iteritems():
for v in i:
v = v + u"\n"
SaveLoad.SaveLinesA(v, 'tutti i dialoghi k.txt')
return
#old
for k in self.rankRes.keys():
i = 0
try:
for v in self.rankRes[k]:
try:
dati = k + self.__SEPATATORE + v
k = self.pulisci.PulisciFilename(k)
#per evitar problemi con la lunghezza dei file
if len(k) > 90:
k = k[:90]
filename = self.folderDialoghi + k + str(
i) + self.extFile
print "file: ", filename, "Saved:", SaveLoad.SaveLines(
dati, filename)
i += 1
except:
pass
except:
pass
def loadChar(self): sl.loadChar(self) self.remakeClass() for key in self.abil.keys(): self.updateAbilities(None,key) sl.getSkills()
def save(self):
print('save to: ', self.file_manager().current_workpath() + '\save.json')
#TODO: save functions in file
SaveLoad.save(self.file_manager().current_workpath() + '\save.json', self.get_data())
self._saved = True
dispatcher.send(_SAVED_STATUS, sender= self, status= True)
def take_input(self, eventList, gameStateObj, metaDataObj):
for event in eventList:
if event.type == KEYUP:
if event.key == OPTIONS['DOWN']:
SOUNDDICT['Select 6'].play()
gameStateObj.activeMenu.moveDown()
elif event.key == OPTIONS['UP']:
SOUNDDICT['Select 6'].play()
gameStateObj.activeMenu.moveUp()
elif event.key == OPTIONS['BACK']:
SOUNDDICT['Select 4'].play()
gameStateObj.activeMenu = None # Remove menu
gameStateObj.stateMachine.back()
return
elif event.key == OPTIONS['SELECT']:
SOUNDDICT['Select 1'].play()
waitTime = pygame.time.get_ticks()
selection = gameStateObj.save_slots[gameStateObj.activeMenu.getSelectionIndex()]
gameStateObj.build_new() # Make the gameStateObj ready for a new game
levelfolder = 'Data/Level' + str(gameStateObj.currentLevelIndex)
# Load the first level
SaveLoad.load_level(levelfolder, selection, gameStateObj, metaDataObj)
gameStateObj.activeMenu.options[gameStateObj.activeMenu.getSelectionIndex()] = metaDataObj['name']
gameStateObj.saveSlot = selection
gameStateObj.stateMachine.changeState('turn_change')
gameStateObj.stateMachine.changeState('start_wait')
return
def take_input(self, eventList, gameStateObj, metaDataObj):
for event in eventList:
if event.type == KEYUP:
if event.key == OPTIONS['DOWN']:
SOUNDDICT['Select 6'].play()
gameStateObj.activeMenu.moveDown()
elif event.key == OPTIONS['UP']:
SOUNDDICT['Select 6'].play()
gameStateObj.activeMenu.moveUp()
elif event.key == OPTIONS['BACK']:
SOUNDDICT['Select 4'].play()
gameStateObj.activeMenu = None # Remove menu
gameStateObj.stateMachine.changeState('start_option')
return
elif event.key == OPTIONS['SELECT']:
SOUNDDICT['Select 1'].play()
selection = gameStateObj.save_slots[gameStateObj.activeMenu.getSelectionIndex()]
gameStateObj.activeMenu = None # Remove menu
if (self.restart and selection.out_save) or (not self.restart and (selection.in_save or selection.in_suspend)):
logger.debug('Loading game...')
SaveLoad.loadGame(gameStateObj, metaDataObj, selection, self.restart)
if self.restart:
levelfolder = 'Data/Level' + str(gameStateObj.currentLevelIndex)
# Load the first level
SaveLoad.load_level(levelfolder, selection, gameStateObj, metaDataObj)
# State is switched to correct state automatically
else:
gameStateObj.stateMachine.changeState('start_option')
return
def take_input(self, eventList, gameStateObj, metaDataObj):
for event in eventList:
if event.type == KEYUP:
if event.key == OPTIONS['RIGHT']:
SOUNDDICT['Select 6'].play()
gameStateObj.childMenu.moveDown()
elif event.key == OPTIONS['LEFT']:
SOUNDDICT['Select 6'].play()
gameStateObj.childMenu.moveUp()
elif event.key == OPTIONS['BACK']:
SOUNDDICT['Select 4'].play()
gameStateObj.childMenu = None # Remove menu
gameStateObj.stateMachine.back()
return
elif event.key == OPTIONS['SELECT']:
selection = gameStateObj.childMenu.getSelection()
if selection == 'Overwrite':
SOUNDDICT['Select 1'].play()
gameStateObj.stateMachine.clear()
gameStateObj.stateMachine.changeState('turn_change') # after we're done waiting, go to turn_change, start the GAME!
SaveLoad.suspendGame(gameStateObj, gameStateObj.childMenu.owner, level = 'c')
gameStateObj.stateMachine.changeState('start_wait')
levelfolder = 'Data/Level' + str(gameStateObj.currentLevelIndex)
# Load the next level
SaveLoad.load_level(levelfolder, gameStateObj.childMenu.owner, gameStateObj, metaDataObj)
gameStateObj.activeMenu.options[gameStateObj.activeMenu.getSelectionIndex()] = metaDataObj['name']
elif selection == 'Back':
SOUNDDICT['Select 4'].play()
gameStateObj.stateMachine.back()
return
def __Load(self):
#carico le liste di dati
pos=SaveLoad.LoadLines(self.__folder+"SentiPos.txt")
neg=SaveLoad.LoadLines(self.__folder+"SentiNeg.txt")
self.dictsentiScore={}
self.sentiPos=list()
for word in pos:
word=word.strip()
word=self.__PosTagger.PosTag(word)
if word!=list():
word=self.__Stem.StemWord(word[0])
self.dictsentiScore[word[0]]=float(1)
self.sentiPos.append(word[0])
self.sentiNeg=list()
for word in neg:
word=word.strip()
word=self.__PosTagger.PosTag(word)
if word!=list():
word=self.__Stem.StemWord(word[0])
self.dictsentiScore[word[0]]=float(-1)
self.sentiNeg.append(word[0])
self.__stopWords=SaveLoad.LoadByte(self.__stopWordsFilename)
if not self.__stopWords:
print "file stopwords mancante...\nestrazione in corso"
paisaWordsDataExtractor.paisaWordsDataExtractor()
if not self.__Load():
print "processo di estrazione corrotto\nimpossibile procedere..."
return False
return True
def __Load(self):
self.__unigram_tagger = SaveLoad.LoadByte(
self.__unigram_taggerFileName)
self.__bigram_tagger = SaveLoad.LoadByte(self.__bigram_taggerFileName)
if self.__bigram_tagger != False and self.__unigram_tagger != False:
return True
return False
def qclLoad(fname):
qclayers = QCLayers()
# print "Loading "+fname
filehandle = open(fname, 'r')
SaveLoad.qclLoad(filehandle, qclayers, None)
qclayers.update_alloys()
qclayers.update_strain()
qclayers.populate_x()
qclayers.populate_x_band()
return qclayers
def createAutomataReturnTimeSamples(N,K,currentFolderPath,sampleLength,samplesAmount):
automataList=[]
print "gatherData:"
automataTypeFolderName=SaveLoad.generateAutomataTypeFolderName(N,K)
SaveLoad.gatherData(automataList,currentFolderPath+'/'+"SavedAutomata"+'/'+automataTypeFolderName)
print "statsToFile:"
#countAverarageStabilityAndCycleAmount(automataList)
savePath=currentFolderPath+"/"+"Statistics"+"/"+"ReturnTime"+"/"+automataTypeFolderName
if not os.path.exists(savePath):
os.makedirs(savePath)
returnTimeToFiles(N,K,automataList,savePath,sampleLength)
def main():
x = 1000
y = 800
try:
universe = SaveLoad.load_universe("universe")
except:
map_size = 5
universe = Universe.Universe()
#currently need more things before going over faction size 8
universe.create_map(map_size)
universe.create_factions(map_size + 3)
#pygame_object = Pygame_Object(1920,1080)
pygame_object = Pygame_Object(x,y, universe)
error = 0
while (error == 0):
pygame_object.game_display.fill(Colour.black)
pygame_object.draw_view()
pygame_object.draw_ui(universe.factions[universe.turn])
#draw everything, then capture events
error = pygame_object.capture_events()
#Ui elements selected here
if (pygame_object.mouse_down):
#mouse button finished clicking button
if (pygame_object.ui.ui_element_clicked[0] and pygame_object.current_view == 0): #end turn button clicked
universe.turn = (universe.turn + 1) % len(universe.factions)
pygame_object.turn_end()
pygame_object.clear_ui_elements()
pygame_object.turn_start() #update goals for new faction
elif (pygame_object.ui.ui_element_clicked[0] and pygame_object.current_view == 1): #return from inner system view
pygame_object.current_view = 0
pygame_object.clear_ui_elements()
#pygame_object.mouse_released = False
# pygame_object.clear_ui_elements()
pygame_object.update()
SaveLoad.save_universe("universe", universe)
def __CaricaDlg(self, dlgname):
self.dlg = SaveLoad.LoadLines(self.folder + "\\dialoghiRaw\\" +
dlgname + self.extdlg)
self.dictWordScoreRow = SaveLoad.LoadByte(self.folder + dlgname +
self.extdictWordScoreRow)
self.dictWordIndex = SaveLoad.LoadByte(self.folder + dlgname +
self.extdictWordIndex)
if not (self.dictWordScoreRow and self.dictWordIndex):
print "file dict mancanti\ncreazione in corso..."
CreaDatiQuestEngine.CreaDatiQuestEngine(dlgname)
#ricarico i dati
self.dictWordScoreRoww = SaveLoad.LoadByte(
self.folder + dlgname + self.extdictWordScoreRow)
self.dictWordIndex = SaveLoad.LoadByte(self.folder + dlgname +
self.extdictWordIndex)
def AvviaCreazioneDati(self):
sentWithSentimento = list()
i = 0
files = glob.glob(self.__folderdialoghi + '*')
for file in files:
print file
dlg = SaveLoad.LoadLines(file)
for line in dlg:
line = self.SentiAnaliz.StimaSentimentoFrase(line)
if line != list():
for l in line:
if l != list():
sentWithSentimento.append(l)
# print 'file', i
i += 1
if i > 50:
return sentWithSentimento
return sentWithSentimento
def Load(self):
self.classificatoreSenti=SaveLoad.LoadByte(self.classificatoreSentiFilename)
if self.classificatoreSenti:
return True
return False
def Save(self):
try:
# SaveLoad.SaveByte(self.lemma, self.lemmaFilename)
# SaveLoad.SaveByte(self.radiciList, self.radiciListFilename)
#
# SaveLoad.SaveByte(self.lemmaRadice, self.lemmaRadiceFilename)
# SaveLoad.SaveByte(self.lemmaSuffisso, self.lemmaSuffissoFilename)
#
# SaveLoad.SaveByte(self.lemmaTipo, self.lemmaTipoFilename)
# SaveLoad.SaveByte(self.lemmaTipoEsteso, self.lemmaTipoEstesoFilename)
#
# SaveLoad.SaveByte(self.lemmaTipoListLemma, self.lemmaTipolistLemmaFilename)
#
# SaveLoad.SaveByte(self.lemmaTipoListVocabolo, self.lemmaTipoListVocaboloFilename)
#
# SaveLoad.SaveByte(self.tipoList, self.tipoListFilename)
#
#
#
# #sicuro da tenere
# SaveLoad.SaveByte(self.parole,self.paroleFilename)
#
# self.SalvaRadici()
#
self.SalvaAbrev()
print SaveLoad.SaveByte(self.suffissiTag, self.suffissiTagFilename)
return True
except:
return False
def __ElaboraFiles(self):
#elabora tutti i file
#le frasi con solo i tag
self.tagsent = list()
#le frasi con solo le words
self.sentsent = list()
i = float(1)
#files=glob.glob(self.folderDialoghiPosTag+u'*')
files = ["C:\\Esame TTR\\tutti i dialoghi.txt"]
tot = len(files)
print tot
for fil in files:
print "elaborazione file ", fil[len(self.folderDialoghiPosTag
):], " - ", i, " / ", tot
#to del self.
#self.dlg=SaveLoad.LoadByte(fil)
self.dlg = SaveLoad.LoadLines(fil)
if self.dlg:
for j in xrange(len(self.dlg) -
1): #-1 perchè non devo fare l'ultima!
k = self.getSent(self.dlg[j])
v = self.getSent(self.dlg[j + 1])
k = u" ".join(k)
k = k.strip()
v = u" ".join(v)
v = v.strip()
self.sentsentSuccessiva[k].append(v)
i += 1
def CleanAllFile(self):
files = glob.glob(self.folderRawSubfactory + '*')
tot = len(files)
print tot
i = float(0)
for fil in files:
print "elaborazione file ", fil[len(self.folderRawSubfactory
):], " - ", i, " / ", tot
try:
with codecs.open(fil, 'r', 'cp1252') as f:
dati = f.readlines()
self.CleanDialogo(dati)
except:
try:
with codecs.open(fil, 'r', 'utf-8') as f:
dati = f.readlines()
self.CleanDialogo(dati)
except:
pass
dlg = self.CleanDialogo(dati)
# filename=fil[len(self.folderRawSubfactory):-4]
# filename="".join([w for w in filename if w.isalpha()])
# filename=filename[:-17]
filename = self.CleanFilenameSubFactory(fil)
filename = self.folderTMPClean + filename + u'.txt'
#salvo il file dei dialoghi
SaveLoad.SaveLinesA(dlg, filename)
i = i + 1
def __init__ (self):
self.qta=155
self.__folder="risorse\\Dati\\"
self.__foldertaggedsents =self.__folder+"training\\paisaTagged"
self.wordsFreqFilename=self.__folder+"wordFreq.fdist"
self.stopWordsFilename=self.__folder+"StopWords.list"
self.folderDialoghiPosTag=self.__folder+"dialoghi\\postag\\"
self.domandeMostFreqFilename=self.__folder+"domandeMostFreq.txt"
self.sentimentiMostFreqFilename=self.__folder+"sentimentiMostFreq.txt"
self.emozioniMostFreqFilename=self.__folder+"emozioniMostFreq.txt"
self.wordsFreq=SaveLoad.LoadByte(self.wordsFreqFilename)
# self.stopWords=SaveLoad.LoadByte(self.stopWords)
self.noun=set()
self.verb=set()
self.SentimentiMostFreq()
self.EmozioniMostFreq()
#domande prese da internet come "in-cultura" popolare e keywords di google
self.DomaneMostFreq()
#keywords prese dai dialoghi e mischiate random!
self.ElaboraDati()
self.EstraiMostFreq()
self.EstraiYahooAnswers(self.qta)
def __Load(self):
"""
Load
input: None
hidden: carica i dati
output: True se il processo termina correttamente
"""
self.__grammars = SaveLoad.LoadByte(self.__grammarsFilename)
if not self.__grammars:
import GrammarExtractor
GrammarExtractor.GrammarExtractor()
self.__grammars = SaveLoad.LoadByte(self.__grammarsFilename)
return True
def SentimentiMostFreq(self):
lines=SaveLoad.LoadLines(self.sentimentiMostFreqFilename)
for line in lines:
try:
print line
keyRicerca=line.strip()
_=YahooAnswer.YahooAnswer(answer=keyRicerca, ordinamento='rillevanza', numeroRisultati=3)
except:
pass
def make_array(cube, dim, cut=50, t=0, s=0, w=0, nw=nw, nt=nt, ns=4):
'''
Make a 3d cube in a chosen direction. x,y,[t,s or w]
INPUT:
cube : filename, has to be .icube or .fcube
dim : chosen cube direction. t,s or w. Input as string.
cut : trims pixels off of the images edge to remove edge detector effects. Default = 50 px
t : chosen timestep default = 0
s : chosen stokes paramater default = 0
w : chosen wavelength step default = 0
nw : number of wavelength steps. Should be defined outside function or as global.
nt : number of scans. Should be defined outside function or as global.
ns : number of stokes parameters. Default = 4.
OUTPUT:
numpy cube with a shape of 'len(dim), nx,ny'
AUTHOR: A.G.M. Pietrow (2018)
EXAMPLE:
cube = 'cube.icube'
nw = 20
nt = 4
cube_w = make_array(cube, 'w') # returns a wavelength cut cube @ s=0 and t=0.
cube_w = make_array(cube, 'w', s=1, t=3) # returns a wavelength cut cube @ s=1 and t=3.
cube_t = make_array(cube, 't', s=2, w=10) # returns a timeseries in line core @ s=2
'''
if dim == 't':
#t = var
var_counter = nt
elif dim == 's':
#s = var
var_counter = ns
elif dim == 'w':
#w = var
var_counter = nw
else:
raise ValueError("Dim must be \'t\',\'s\' or \'w\'.")
cube_array = []
for i in range(var_counter):
idx = t*nw*ns + s*nw + w
im = sl.get(cube,idx)[cut:-cut, cut:-cut]
cube_array = np.append(cube_array, im)
nx, ny = im.shape
if dim == 't':
t = t + 1
elif dim == 's':
s = s + 1
elif dim == 'w':
w = w + 1
return cube_array.reshape(var_counter, nx,ny)
def generate_attacker_phase(self, gameStateObj, metaDataObj, defender):
result = Result(self.attacker, defender)
# Start
if isinstance(defender, UnitObject.UnitObject) or isinstance(defender, TileObject.TileObject):
to_hit = self.attacker.compute_hit(defender, gameStateObj, self.item, mode="Attack")
if self.event_combat:
roll = 0
else:
roll = (random.randint(0, 99) + random.randint(0, 99))/2
#if OPTIONS['debug']: print('To Hit:', to_hit, ' Roll:', roll)
if self.item.weapon:
if roll < to_hit and not (defender in self.splash and any(status.evasion for status in defender.status_effects)) or isinstance(defender, TileObject.TileObject):
result.outcome = True
result.def_damage = self.attacker.compute_damage(defender, gameStateObj, self.item, mode='Attack')
# Missed but does half damage
elif self.item.half:
result.def_damage = self.attacker.compute_damage(defender, gameStateObj, self.item, mode='Attack')/2
elif self.item.spell:
if not self.item.hit or roll < to_hit:
result.outcome = True
if self.item.damage is not None:
result.def_damage = self.attacker.compute_damage(defender, gameStateObj, self.item, mode='Attack')
elif self.item.heal is not None:
result.def_damage = -self.attacker.compute_heal(defender, gameStateObj, self.item, mode='Attack')
else:
result.outcome = True
result.def_damage = -int(eval(self.item.heal)) if self.item.heal else 0
if self.attacker is not defender and self.item.heal:
result.def_damage -= sum(status.caretaker for status in self.attacker.status_effects if status.caretaker)
if self.item.movement:
result.def_movement = self.item.movement
if self.item.self_movement:
result.atk_movement = self.item.self_movement
if result.outcome:
# Handle status
for status in self.item.status:
status_object = StatusObject.statusparser(str(status.id))
result.def_status.append(status_object)
# Handle summon
if self.item.summon:
result.summoning.append(SaveLoad.create_summon(metaDataObj, self.item.summon, self.attacker, self.def_pos))
# Handle lifelink and vampire
if result.def_damage > 0:
if self.item.lifelink:
result.atk_damage -= result.def_damage
# Handle Vampire Status
for status in self.attacker.status_effects:
if status.vampire and defender.currenthp - result.def_damage <= 0 and \
not any(status.miracle and (not status.count or status.count.count > 0) for status in defender.status_effects):
result.atk_damage -= eval(status.vampire)
return result
def __Load():
__stopWords = SaveLoad.LoadByte(__stopWordsFilename)
if not __stopWords:
print "file stopwords mancante...\nestrazione in corso"
paisaWordsDataExtractor.paisaWordsDataExtractor()
if not __Load():
print "processo di estrazione corrotto\nimpossibile procedere..."
return False
return True
def __init__(self):
self.__folder = "risorse\\Dati\\"
self.__folderdialoghi = self.__folder + "\\dialoghi\\dialoghiRaw\\"
self.SentiAnaliz = ParseCreaDatiSentimentAnalysis.ParseCreaDatiSentimentAnalysis(
)
self.__SentimTrainsetFilename = self.__folder + "SentiTrainSet.list"
dati = self.AvviaCreazioneDati()
print SaveLoad.SaveByte(dati, self.__SentimTrainsetFilename)
def get_tile_from_id(self, tile_id):
for terrain in self.terraindata.getroot().findall('terrain'):
if tile_id == terrain.find('id').text or tile_id == int(terrain.find('id').text):
tile = TileObject(terrain.get('name'), terrain.find('minimap').text, None, \
SaveLoad.intify_comma_list(terrain.find('mcost').text), \
terrain.find('walk').text, terrain.find('fly').text, \
[terrain.find('DEF').text, terrain.find('AVO').text])
return tile
else:
logger.error('Could not find tile matching id: %s', tile_id)
return None # Couldn't find any that match id
def __ElaboraFile(self, file):
dlg = SaveLoad.LoadLines(file)
if dlg:
for j in xrange(len(dlg) - 1): #-1 perchè non devo fare l'ultima!
k = self.getSent(dlg[j])
v = self.getSent(dlg[j + 1])
k = u"".join(k)
k = k.strip()
v = u"".join(v)
v = v.strip()
self.sentsentSuccessiva[k].append(v)
def load(self, load_info):
# Rebuild gameStateObj
self.allunits = [UnitObject.UnitObject(info) for info in load_info['allunits']]
self.allreinforcements = load_info['allreinforcements']
self.prefabs = load_info['prefabs']
map_info = load_info['map']
self.playtime = load_info['playtime']
self.convoy = load_info['convoy']
self.currentLevelIndex = load_info['currentLevelIndex']
self.money = load_info['money']
self.turncount = load_info['turncount']
self.game_constants = load_info['game_constants']
self.objective = load_info['objective']
support_dict = load_info['support']
self.event_triggers = load_info['event_triggers']
self.talk_options = load_info['talk_options']
self.base_conversations = load_info['base_conversations']
self.stateMachine = StateMachine.StateMachine(load_info['state_list'][0], load_info['state_list'][1])
self.statistics = load_info['statistics']
self.message = [Dialogue.Dialogue_Scene(scene) for scene in load_info['message']]
self.unlocked_lore = load_info['unlocked_lore']
self.counters = load_info['counters']
print([unit.name for unit in self.allunits])
# Map
self.map = SaveLoad.create_map('Data/Level' + str(self.currentLevelIndex))
self.map.replay_commands(map_info['command_list'], self.currentLevelIndex)
self.map.command_list = map_info['command_list']
for position, current_hp in map_info['HP']:
self.map.tiles[position].currenthp = currenthp
# Support
if CONSTANTS['support']:
self.support = Support.Support_Graph('Data/support_nodes.txt', 'Data/support_edges.txt')
self.support.deserialize(support_dict)
else:
self.support = None
self.generic()
# Set up blitting surface
if self.map:
mapSurfWidth = self.map.width * TILEWIDTH
mapSurfHeight = self.map.height * TILEHEIGHT
self.mapSurf = pygame.Surface((mapSurfWidth, mapSurfHeight))
self.grid_manager = AStar.Grid_Manager(self.map)
for unit in self.allunits:
if unit.position:
self.grid_manager.set_unit_node(unit.position, unit.team)
def main(func="logo"):
print("START GAME")
if hashlib.md5(os.getlogin().encode()).hexdigest() == "f945be3c345040fbe66cea5910001877":
func = "mainMenu"
try:
os.environ["SDL_VIDEO_CENTERED"] = "1"
cProfile.run("gameScreens." + func + "()", "logs/Out.txt")
except Exception as e:
if "Reload:" in str(e):
curFunc = str(e).strip("Reload:")
print("Reload:", curFunc)
reload(gameScreens)
main(curFunc)
print("EXCEPTION:")
print(traceback.print_exc())
if not os.path.exists("Crash Reports"):
os.makedirs("Crash Reports")
name = "Crash Reports/Crash Report " + time.strftime("%Y-%m-%d_%H.%M.%S") + ".txt"
remPath = str(unhexlify("433a2f55736572732f4a616d6573205761746572732f446f63756d656e74732f574f524b53504143452f"))
with open(name, "w") as crash:
t = traceback.format_exc(limit=8)
t = t.replace("\\", "/")
t = t.replace(remPath, "")
t = t.split("\n")[0] + "\n" + "\n".join(t.split("\n")[12:])
crash.write(t)
with open(name, "r") as crash:
gameScreens.crashScreen(crash.read())
py.quit()
with open("Logs/Calltime Dump.txt", "w") as fc:
p = pstats.Stats("logs/Out.txt", stream=fc)
p.strip_dirs()
d = p.__dict__["stats"]
funcstats = {}
for k, v in d.items():
funcstats[k] = v[2]
p.sort_stats("time").print_stats()
SaveLoad.uploadStats(funcstats)
def ElaboraDati(self):
files=glob.glob(self.folderDialoghiPosTag+'*')
tot=len(files)
i=1
for file in files:
dati=SaveLoad.LoadByte(file)
for line in dati:
for word in line:
if word[1]==u"NOUN":
self.noun.add(word[0])
elif word[1]==u"VER":
self.verb.add(word[0])
print "Elaborato", i, "/",tot
i+=1
def test_solve_basis(self):
with open("../example/PQLiu.json") as f:
qcl = SaveLoad.qclLoad(f)
qcl.layerSelected = 3
qcl.NonParabolic = False
qcl.populate_x()
qcl.solve_basis()
# axes = plt.axes()
# plot_band(axes, qcl)
# plt.show()
np.testing.assert_equal(qcl.eigenEs.shape, (18, ),
'solve_basis eigenEs calculation wrong')
np.testing.assert_equal(qcl.psis.shape, (18, 1038),
'solve_basis psis calculation wrong')
def __init__(self, dlgname):
self.extdlg = '.txt'
self.extdlgData = ".dat"
self.extdlgVoc = ".voc"
self.extdictWordScoreRow = '.dictWordsScoreRows'
self.folder = "risorse\\Dati\\dialoghi\\"
dlg = SaveLoad.LoadLines(self.folder + "dialoghiRaw\\" + dlgname +
self.extdlg)
if dlg:
self.__Tfidf(dlg)
self.__Save(dlgname)
else:
print "file di dialogo mancante\nimpossibile procedere..."
def __Load(self):
"""
Load
input: None
hidden: carica il tokenize
output: True se il processo termina correttamente
"""
self.__sentsTokenizer = SaveLoad.LoadByte(self.__sentsTokenFileName)
if not self.__sentsTokenizer:
self.__corpus = nltk.corpus.ConllCorpusReader(
self.__foldertaggedsents, '.*', self.__lst_pos)
return False
return True
def populate_tiles(self, colorKeyObj, offset=(0,0)):
for x in range(offset[0], len(colorKeyObj)):
for y in range(offset[1], len(colorKeyObj[x])):
cur = colorKeyObj[x-offset[0]][y-offset[1]]
for terrain in self.terraindata.getroot().findall('terrain'):
colorKey = terrain.find('color').text.split(',')
if (int(cur[0]) == int(colorKey[0]) and int(cur[1]) == int(colorKey[1]) and int(cur[2]) == int(colorKey[2])):
# Instantiate
self.tiles[(x,y)] = TileObject(terrain.get('name'), terrain.find('minimap').text, (x,y), \
SaveLoad.intify_comma_list(terrain.find('mcost').text), \
terrain.find('walk').text, terrain.find('fly').text, \
[terrain.find('DEF').text, terrain.find('AVO').text])
if 'HP' in self.tile_info_dict[(x,y)]: # Tile hp is needed so apply that here
self.tiles[(x,y)].give_hp_stat(self.tile_info_dict[(x,y)]['HP'])
break
else: # Never found terrain...
logger.error('Terrain matching colorkey %s never found.', cur)
def __Save(self):
"""
Save
input: None
hidden: salva il tokenize
output: True se il processo termina correttamente
"""
try:
SaveLoad.SaveByte(self.__sentsTokenizer, self.__sentsTokenFileName)
return True
except:
return False
def load(self, filename):
print('load from: ', filename)
data = SaveLoad.load(filename)
try:
self._build(data)
self._filename = filename
self._saved = True
dispatcher.send(_FILE_LOADED, sender= self)
dispatcher.send(_UNDO_STATUS, sender= self, status= False)
dispatcher.send(_REDO_STATUS, sender= self, status= False)
dispatcher.send(_SAVED_STATUS, sender= self, status= True)
self._undobuffer = []
self._redobuffer = []
except:
import traceback
traceback.print_exc()
def __Train(self):
try:
abl = SaveLoad.LoadLines(self.__abbrvFilename)
train = self.__corpus.tagged_sents()[:]
if abl != False:
punkt_param = nltk.tokenize.punkt.PunktParameters()
punkt_param.abbrev_types = abl
self.__sentsTokenizer = nltk.tokenize.punkt.PunktSentenceTokenizer(
punkt_param)
self.__sentsTokenizer.train(train)
return True
else:
self.__DefaultSentTokenize()
except:
#carico il tokenizer di default
self.__DefaultSentTokenize()
def updatefig(t=t, s=s, w=w, *args):
global var, meanim, stdim
var += 1
if var == var_counter:
var = 0
if dim == 't':
t = var
elif dim == 's':
s = var
elif dim == 'w':
w = var
else:
raise ValueError("Dim must be t,s or w.")
idx = t * nw * ns + s * nw + w
im = sl.get(cube, idx)[cut:-cut, cut:-cut]
meanim = np.mean(im)
stdim = np.std(im)
if mn == sd and mn == 0:
a = plt.imshow(im,
vmax=meanim + 2 * stdim,
vmin=meanim - 2 * stdim,
cmap='gray',
animated=True)
else:
a = plt.imshow(im,
vmax=mn + 2 * sd,
vmin=mn - 2 * sd,
cmap='gray',
animated=True)
print(a, t, s, w, meanim, stdim)
return a,
def itemparser(itemstring, itemdata=None):
if itemdata is None: # Just in case so we don't have to keep passing itemdat around
itemdata = ET.parse('Data/items.xml')
Items = []
if itemstring: # itemstring needs to exist
idlist = itemstring.split(',')
for itemid in idlist:
droppable = False
if itemid.startswith('d'):
itemid = itemid[1:] # Strip the first d off
droppable = True
for item in itemdata.getroot().findall('item'):
if item.find('id').text == itemid:
spritetype = item.find('spritetype').text
spriteid = item.find('spriteid').text
components = item.find('components').text
if components:
components = components.split(',')
else:
components = []
name = item.get('name')
value = item.find('value').text
rng = item.find('RNG').text
desc = item.find('desc').text
aoe = AOEComponent('Normal', 0)
if 'weapon' in components or 'spell' in components:
weapontype = item.find('weapontype').text
if weapontype == 'None':
weapontype = []
else:
weapontype = weapontype.split(',')
else:
weapontype = []
if 'locked' in components:
locked = True
else:
locked = False
status = []
status_on_hold = []
my_components = {}
for component in components:
if component == 'uses':
uses = item.find('uses').text
my_components['uses'] = UsesComponent(int(uses))
elif component == 'c_uses':
c_uses = item.find('c_uses').text
my_components['c_uses'] = CUsesComponent(int(c_uses))
elif component == 'weapon':
stats = [item.find('stats')[0].text, item.find('stats')[1].text, item.find('stats')[2].text]
my_components['weapon'] = WeaponComponent(stats)
elif component == 'usable':
my_components['usable'] = UsableComponent()
elif component == 'spell':
lvl = item.find('LVL').text
targets = item.find('targets').text
my_components['spell'] = SpellComponent(lvl, targets)
elif component == 'status':
statusid = item.find('status').text.split(',')
for s_id in statusid:
status.append(StatusObject.statusparser(s_id)) # Item now has associated status object.
elif component == 'status_on_hold':
statusid = item.find('status_on_hold').text.split(',')
for s_id in statusid:
status_on_hold.append(StatusObject.statusparser(s_id)) # Item now has associated status on hold object
elif component == 'effective':
effective_against = item.find('effective').text.split(',')
my_components['effective'] = EffectiveComponent(effective_against)
elif component == 'permanent_stat_increase':
stat_increase = SaveLoad.intify_comma_list(item.find('stat_increase').text)
my_components['permanent_stat_increase'] = PermanentStatIncreaseComponent(stat_increase)
elif component == 'aoe':
info_line = item.find('aoe').text.split(',')
aoe = AOEComponent(info_line[0], int(info_line[1]))
elif component == 'heal':
my_components['heal'] = item.find('heal').text
elif component == 'damage':
my_components['damage'] = int(item.find('damage').text)
elif component == 'hit':
my_components['hit'] = int(item.find('hit').text)
elif component == 'weight':
my_components['WT'] = int(item.find('WT').text)
elif component == 'exp':
my_components['exp'] = int(item.find('exp').text)
elif component == 'wexp_increase':
my_components['wexp_increase'] = int(item.find('wexp_increase').text)
elif component in ['movement', 'self_movement']:
mode, magnitude = item.find(component).text.split(',')
my_components[component] = MovementComponent(mode, magnitude)
elif component == 'summon':
summon = item.find('summon')
klass = summon.find('klass').text
items = summon.find('items').text
name = summon.find('name').text
desc = summon.find('desc').text
ai = summon.find('ai').text
s_id = summon.find('s_id').text
my_components['summon'] = SummonComponent(klass, items, name, desc, ai, s_id)
else:
my_components[component] = True
currentItem = ItemObject(itemid, name, spritetype, spriteid, my_components, value, rng, desc, \
aoe, weapontype, status, status_on_hold, droppable=droppable, locked=locked)
Items.append(currentItem)
return Items
def drawSaveLoadCharacter(self): BsaveCharacter = Button(self.root, text="Save Character", command= lambda: sl.saveChar(self)) BloadCharacter = Button(self.root, text="Load Character", command= lambda: self.loadChar()) BsaveCharacter.grid(row=20, column=12, columnspan=2) BloadCharacter.grid(row=22, column=12, columnspan=2)
def __Save(self, dlgname):
print "file Saved:", SaveLoad.SaveByte(
self.data, self.folder + dlgname + self.extdlgData)
print "file Saved:", SaveLoad.SaveByte(
self.vocab, self.folder + dlgname + self.extdlgVoc)
def load(self, load_info):
logger.info("Load")
# Rebuild gameStateObj
self.allunits = [
UnitObject.UnitObject(info) for info in load_info['allunits']
]
self.factions = load_info['factions'] if 'factions' in load_info else (
load_info['groups'] if 'groups' in load_info else {})
self.allreinforcements = load_info['allreinforcements']
self.prefabs = load_info['prefabs']
self.triggers = load_info.get('triggers', dict())
map_info = load_info['map']
self.playtime = load_info['playtime']
self.convoy = [
ItemMethods.deserialize(item_dict)
for item_dict in load_info['convoy']
]
self.convoy = [item for item in self.convoy if item]
self.turncount = load_info['turncount']
self.game_constants = load_info['game_constants']
self.level_constants = load_info['level_constants']
self.objective = CustomObjects.Objective.deserialize(
load_info['objective']) if load_info['objective'] else None
self.phase_music = CustomObjects.PhaseMusic.deserialize(
load_info['phase_music']) if load_info['phase_music'] else None
support_dict = load_info['support']
self.talk_options = load_info['talk_options']
self.base_conversations = load_info['base_conversations']
self.stateMachine = StateMachine.StateMachine(
load_info['state_list'][0], load_info['state_list'][1])
self.statistics = load_info['statistics']
# self.message = [Dialogue.Dialogue_Scene(scene) for scene in load_info['message']]
self.message = []
self.unlocked_lore = load_info['unlocked_lore']
self.market_items = load_info.get('market_items', set())
self.mode = load_info.get('mode', self.default_mode())
# Map
self.map = SaveLoad.create_map('Data/Level' +
str(self.game_constants['level']))
if map_info:
self.map.replay_commands(map_info['command_list'],
self.game_constants['level'])
self.map.command_list = map_info['command_list']
for position, current_hp in map_info['HP']:
self.map.tiles[position].set_hp(current_hp)
# Statuses
for index, info in enumerate(load_info['allunits']):
for s_dict in info['status_effects']:
if isinstance(s_dict, dict):
StatusObject.deserialize(s_dict, self.allunits[index],
self)
else:
self.allunits[index].status_effects.append(s_dict)
# Support
if cf.CONSTANTS['support']:
self.support = Support.Support_Graph('Data/support_nodes.txt',
'Data/support_edges.txt')
self.support.deserialize(support_dict)
else:
self.support = None
# Set up blitting surface
if self.map:
mapSurfWidth = self.map.width * GC.TILEWIDTH
mapSurfHeight = self.map.height * GC.TILEHEIGHT
self.mapSurf = Engine.create_surface((mapSurfWidth, mapSurfHeight))
self.grid_manager = AStar.Grid_Manager(self.map)
self.boundary_manager = CustomObjects.BoundaryManager(self.map)
for unit in self.allunits:
if unit.position:
self.grid_manager.set_unit_node(unit.position, unit)
self.generic()
if 'phase_info' in load_info:
self.phase.current, self.phase.previous = load_info['phase_info']
def __init__(self):
self.__folder = "risorse\\Dati\\"
self.stopWordFilename = self.__folder + "StopWords.list"
self.stopWords = SaveLoad.LoadByte(self.stopWordFilename)
#! /usr/bin/python
from Item import Item, Saved
import gtk, gobject
import Settings, ClipBoard, Window, SaveLoad
import xml.dom.minidom
dom = xml.dom.minidom.parse("save.xml")
archive = SaveLoad.getArchived(dom)
saved = SaveLoad.getSaved(dom)
if __name__ == '__main__':
gobject.timeout_add(400, ClipBoard.clipListener)
Window.Window()
gtk.main()
def __CreaCorpus(self, dlgfilename):
all_sents = SaveLoad.LoadLines(dlgfilename)
corpus, vocab = self.__corpus2vectors(all_sents)
return corpus, vocab
def statusparser(status_string, statusdata=None):
if statusdata is None: # Just in case so we don't have to keep passing statusdata around
statusdata = ET.parse('Data/status.xml')
Status = []
if status_string: # itemstring needs to exist
for status in statusdata.getroot().findall('status'):
if status.find('id').text == status_string:
components = status.find('components').text
if components:
components = components.split(',')
else:
components = []
name = status.get('name')
desc = status.find('desc').text
icon_index = status.find('icon_index').text if status.find('icon_index') is not None else None
if icon_index:
icon_index = tuple(int(num) for num in icon_index.split(','))
else:
icon_index = (0,0)
my_components = {}
for component in components:
if component == 'time':
time = status.find('time').text
my_components['time'] = TimeComponent(time)
elif component == 'stat_change':
my_components['stat_change'] = SaveLoad.intify_comma_list(status.find('stat_change').text)
elif component == 'upkeep_stat_change':
stat_change = SaveLoad.intify_comma_list(status.find('upkeep_stat_change').text)
my_components['upkeep_stat_change'] = UpkeepStatChangeComponent(stat_change)
elif component == 'endstep_stat_change':
stat_change = SaveLoad.intify_comma_list(status.find('endstep_stat_change').text)
my_components['endstep_stat_change'] = UpkeepStatChangeComponent(stat_change)
elif component == 'rhythm_stat_change':
change, reset, init_count, limit = status.find('rhythm_stat_change').text.split(';')
change = SaveLoad.intify_comma_list(change)
reset = SaveLoad.intify_comma_list(reset)
init_count = int(init_count)
limit = int(limit)
my_components['rhythm_stat_change'] = RhythmStatChangeComponent(change, reset, init_count, limit)
elif component == 'endstep_rhythm_stat_change':
change, reset, init_count, limit = status.find('endstep_rhythm_stat_change').text.split(';')
change = SaveLoad.intify_comma_list(change)
reset = SaveLoad.intify_comma_list(reset)
init_count = int(init_count)
limit = int(limit)
my_components['endstep_rhythm_stat_change'] = RhythmStatChangeComponent(change, reset, init_count, limit)
# Combat changes
elif component == 'avoid':
avoid = status.find('avoid').text
my_components['avoid'] = avoid
elif component == 'hit':
hit = status.find('hit').text
my_components['hit'] = hit
elif component == 'mt':
mt = status.find('mt').text
my_components['mt'] = mt
elif component == 'conditional_avoid':
avoid, conditional = status.find('conditional_avoid').text.split(';')
my_components['conditional_avoid'] = ConditionalComponent('conditional_avoid', avoid, conditional)
elif component == 'conditional_hit':
hit, conditional = status.find('conditional_hit').text.split(';')
my_components['conditional_hit'] = ConditionalComponent('conditional_hit', hit, conditional)
elif component == 'conditional_mt':
mt, conditional = status.find('conditional_mt').text.split(';')
my_components['conditional_mt'] = ConditionalComponent('conditional_mt', mt, conditional)
elif component == 'conditional_resist':
mt, conditional = status.find('conditional_resist').text.split(';')
my_components['conditional_resist'] = ConditionalComponent('conditional_resist', mt, conditional)
elif component == 'weakness':
damage_type, num = status.find('weakness').text.split(',')
my_components['weakness'] = WeaknessComponent(damage_type, num)
# Others...
elif component == 'rescue':
my_components['rescue'] = RescueComponent()
elif component == 'count':
my_components['count'] = CountComponent(int(status.find('count').text))
elif component == 'vampire':
my_components['vampire'] = status.find('vampire').text
elif component == 'caretaker':
my_components['caretaker'] = int(status.find('caretaker').text)
elif component == 'hp_percentage':
percentage = status.find('hp_percentage').text
my_components['hp_percentage'] = HPPercentageComponent(percentage)
elif component == 'upkeep_animation':
info_line = status.find('upkeep_animation').text
split_line = info_line.split(',')
my_components['upkeep_animation'] = UpkeepAnimationComponent(split_line[0], split_line[1], split_line[2], split_line[3])
elif component == 'always_animation':
info_line = status.find('always_animation').text
split_line = info_line.split(',')
my_components['always_animation'] = AlwaysAnimationComponent(split_line[0], split_line[1], split_line[2], split_line[3])
elif component == 'active':
charge = int(status.find('active').text)
my_components['active'] = ActiveSkill.active_skill_dict[name](name, charge)
elif component == 'passive':
my_components['passive'] = ActiveSkill.passive_skill_dict[name](name)
elif component == 'aura':
aura_range = int(status.find('range').text)
child = status.find('child').text
target = status.find('target').text
my_components['aura'] = ActiveSkill.Aura(aura_range, target, child)
elif component == 'status_after_battle':
child = status.find('status_after_battle').text
my_components['status_after_battle'] = child
elif component == 'status_on_complete':
child = status.find('status_on_complete').text
my_components['status_on_complete'] = child
elif component == 'ai':
ai = status.find('ai').text
my_components['ai'] = ai
else:
my_components[component] = True
currentStatus = StatusObject(status_string, name, my_components, desc, icon_index)
return currentStatus
