mirror of
https://github.com/wesnoth/wesnoth
synced 2024-09-21 00:13:57 +00:00
69f3aa45e8
This is a clutter-reduction step, separating the packaging and code-integrity checks from the stuff for maintaining mainline campaigns. I've also added documentation comments to some scripts.
280 lines
11 KiB
Python
Executable File
280 lines
11 KiB
Python
Executable File
#!/bin/env python
|
|
|
|
import sys
|
|
import os
|
|
import getopt
|
|
import re
|
|
|
|
overwrite = 0
|
|
defaultValue = 4
|
|
suffix = ''
|
|
|
|
RE_SCENARIO = '.*?\[multiplayer\].*?\[\/multiplayer\]'
|
|
scenario_block = re.compile(RE_SCENARIO, re.DOTALL)
|
|
|
|
RE_SIDE = re.compile('( |\t)*\[side\].*?\[\/side\]( |\t)*\n', re.DOTALL)
|
|
side_block = re.compile(RE_SIDE, re.DOTALL)
|
|
|
|
RE_AI = re.compile('( |\t)*\[ai\].*?\[\/ai\]( |\t)*\n', re.DOTALL)
|
|
ai_block = re.compile(RE_AI, re.DOTALL)
|
|
|
|
AI_SIDE = re.compile('(?P<text>( |\t)*side=(\w| |\-|\,|\t)*)\n', re.DOTALL)
|
|
AI_TIME = re.compile('(?P<text>( |\t)*time_of_day=(\w| |\-|\,|\t)*)', re.DOTALL)
|
|
AI_TURNS = re.compile('(?P<text>( |\t)*turns=(\w| |\-|\,|\t)*)', re.DOTALL)
|
|
AI_SCOUTS = re.compile('(?P<text>( |\t)*villages_per_scout=(\w| |\-|\,|\t)*)', re.DOTALL)
|
|
AI_SCOUTS_VALUE = re.compile('(?P<text>(?<=villages_per_scout=)(\d)*)', re.DOTALL)
|
|
AI_CAN_RECRUIT = re.compile('(?P<text>(?<=canrecruit=)(\d)*)', re.DOTALL)
|
|
AI_START = re.compile('(?P<text>( |\t)*\[ai\](\w| |\t)*\n)', re.DOTALL)
|
|
|
|
IF_TEXT = "[if]\n"
|
|
ENDIF_TEXT = "[/if]\n"
|
|
ELSE_TEXT = "[else]\n"
|
|
ENDELSE_TEXT = "[/else]"
|
|
|
|
SCOUTS_TEXT = "\n\tvillages_per_scout=0"
|
|
AI_SCOUTS_TEXT = "\n\t[ai]" + SCOUTS_TEXT.replace('\n','\n\t') + "\n\t[/ai]"
|
|
|
|
def applySearch(text, RE, groupId):
|
|
data = RE.search(text, 0)
|
|
if data <> None:
|
|
return data.group(groupId)
|
|
else:
|
|
return ""
|
|
|
|
def updateDescription(ai,sides):
|
|
if ai.value <> "":
|
|
new = defaultValue*sides
|
|
ai.updated_description = ai.updated_description.replace(ai.value,"%s"%(new))
|
|
|
|
def getIndent(itemText,subitemText):
|
|
item = re.compile('^( |\t)*').search(itemText).group()
|
|
subitem = re.compile('^( |\t)*').search(subitemText).group()
|
|
if item == '' or subitem == '':
|
|
return subitem
|
|
if item[0] == '\t' and subitem[0] == '\t':
|
|
return (len(subitem)-len(item)) * '\t'
|
|
if item[0] == ' ' and subitem[0] == ' ':
|
|
return (len(subitem)-len(item)) * ' '
|
|
return '\t'
|
|
|
|
class wikiAi:
|
|
def __init__(self):
|
|
self.start = ""
|
|
self.scouts = ""
|
|
self.full_description = ""
|
|
self.updated_description = ""
|
|
|
|
def addAiData(self,aiContent):
|
|
if aiContent <> None:
|
|
self.start = applySearch(aiContent, AI_START, 'text')
|
|
self.scouts = applySearch(aiContent, AI_SCOUTS, 'text')
|
|
self.full_description = aiContent
|
|
self.updated_description = aiContent
|
|
self.value = applySearch(aiContent, AI_SCOUTS_VALUE, 'text')
|
|
|
|
class wikiAiList(list):
|
|
def __str__(self):
|
|
output = ""
|
|
for item in self:
|
|
output = output + item.full_description + " ; "
|
|
return output
|
|
|
|
class wikiSide:
|
|
def __init__(self):
|
|
self.full_description = ''
|
|
self.updated_description = ''
|
|
self.side = ""
|
|
# Will only contain one element
|
|
self.ai = wikiAiList()
|
|
self.scouts_setting = False
|
|
|
|
def addAiData(self,sideContent):
|
|
if sideContent <> None:
|
|
aiDetail = ai_block.search(sideContent,0)
|
|
while aiDetail <> None:
|
|
if applySearch(aiDetail.group(), AI_TIME, 'text') == "":
|
|
if applySearch(aiDetail.group(), AI_TURNS, 'text') == "":
|
|
self.ai.append(wikiAi())
|
|
self.ai[self.getCurrentAiNumber()].addAiData(aiDetail.group())
|
|
if self.ai[self.getCurrentAiNumber()].scouts <> "":
|
|
self.scouts_setting = True
|
|
break
|
|
searchStart = aiDetail.end()
|
|
aiDetail = ai_block.search(sideContent,searchStart)
|
|
|
|
|
|
def updateAi(self,sides):
|
|
if len(self.ai) == 0:
|
|
self.ai.append(wikiAi())
|
|
space = re.compile('^( |\t)*').search(self.full_description).group()
|
|
indent = getIndent(self.full_description,self.side)
|
|
side_scout_text = AI_SCOUTS_TEXT.replace('\t',indent)
|
|
side_scout_text = side_scout_text.replace('\n','\n' + space)
|
|
self.ai[self.getCurrentAiNumber()].addAiData(side_scout_text)
|
|
self.updated_description = self.updated_description.replace('\n',self.ai[self.getCurrentAiNumber()].full_description + '\n',1)
|
|
updateDescription(self.ai[0],sides)
|
|
else:
|
|
if self.scouts_setting == False:
|
|
space = re.compile('^( |\t)*').search(self.full_description).group()
|
|
indent = getIndent(self.full_description,self.side)
|
|
side_scout_text = AI_SCOUTS_TEXT.replace('\t',indent)
|
|
side_scout_text = side_scout_text.replace('\n','\n' + space)
|
|
self.ai[0].updated_description = self.ai[0].updated_description.replace(self.ai[0].start,self.ai[0].start.replace('\n',side_scout_text + '\n'))
|
|
updateDescription(self.ai[0],sides)
|
|
else:
|
|
if overwrite == 1:
|
|
updateDescription(self.ai[0],sides)
|
|
if self.ai[0].full_description <> self.ai[0].updated_description:
|
|
self.updated_description = self.updated_description.replace(self.ai[0].full_description,self.ai[0].updated_description,1)
|
|
|
|
def getCurrentAiNumber(self):
|
|
return len(self.ai)-1
|
|
|
|
class wikiSideList(list):
|
|
def __str__(self):
|
|
output = ""
|
|
for item in self:
|
|
output = output + item.full_description + " ; "
|
|
return output
|
|
|
|
class wikiScenario:
|
|
def __init__(self):
|
|
self.side = wikiSideList()
|
|
self.full_description = ''
|
|
self.updated_description = ''
|
|
|
|
def parseScenario (self,scenarioContent):
|
|
self.addScenarioData(scenarioContent)
|
|
sideDetail = side_block.search(scenarioContent,0)
|
|
while (sideDetail <> None):
|
|
self.addSideData(sideDetail.group())
|
|
self.addAiData(sideDetail.group())
|
|
searchStart = sideDetail.end()
|
|
sideDetail = side_block.search(scenarioContent,searchStart)
|
|
self.updateAi()
|
|
|
|
def addScenarioData(self, scenarioContent):
|
|
self.full_description = scenarioContent
|
|
self.updated_description = scenarioContent
|
|
|
|
def addSideData(self, sideContent):
|
|
canrecruit = applySearch(sideContent, AI_CAN_RECRUIT, 'text')
|
|
if canrecruit <> "" and canrecruit == "0":
|
|
return
|
|
self.side.append(wikiSide())
|
|
self.side[self.getCurrentSideNumber()].full_description = sideContent
|
|
self.side[self.getCurrentSideNumber()].updated_description = sideContent
|
|
self.side[self.getCurrentSideNumber()].side = applySearch(sideContent, AI_SIDE, 'text')
|
|
|
|
def addAiData(self,aiContent):
|
|
self.side[self.getCurrentSideNumber()].addAiData(aiContent)
|
|
|
|
def updateAi(self):
|
|
for side in self.side:
|
|
side.updateAi(len(self.side))
|
|
for side in self.side:
|
|
if side.full_description <> side.updated_description:
|
|
self.updated_description = self.updated_description.replace(side.full_description,side.updated_description,1)
|
|
|
|
def getCurrentSideNumber(self):
|
|
return len(self.side)-1
|
|
|
|
class wikiScenarioList(list):
|
|
def __str__(self):
|
|
output = ""
|
|
for scenario in self:
|
|
output = output + scenario.full_description + " ; "
|
|
return output
|
|
|
|
def addScenario(self, scenario):
|
|
self.append(scenario)
|
|
|
|
def parseAll (resourcesFile,dirName, fileList):
|
|
scenarioListIndex = 0
|
|
scenarioList = wikiScenarioList()
|
|
for fileName in fileList:
|
|
if os.path.splitext(fileName)[1] <> '.cfg':
|
|
continue
|
|
if os.path.isdir(os.path.join(dirName,fileName)):
|
|
continue
|
|
f = file(os.path.join(dirName,fileName))
|
|
fileContent = f.read()
|
|
f.close()
|
|
searchStart = 0
|
|
scenario = scenario_block.match(fileContent,searchStart)
|
|
while (scenario <> None):
|
|
scenarioList.addScenario(wikiScenario())
|
|
scenarioList[scenarioListIndex].parseScenario(scenario.group(0))
|
|
searchStart = scenario.end()
|
|
scenario = scenario_block.search(fileContent,searchStart)
|
|
scenarioListIndex = scenarioListIndex + 1
|
|
updated_file = fileContent
|
|
for scenarioItem in scenarioList:
|
|
if scenarioItem.full_description <> scenarioItem.updated_description:
|
|
updated_file = updated_file.replace(scenarioItem.full_description,scenarioItem.updated_description)
|
|
if updated_file <> fileContent:
|
|
(basename_out, ext_out) = os.path.splitext(fileName)
|
|
basename_out = basename_out + suffix + ext_out
|
|
f = file(basename_out,'w')
|
|
f.write(updated_file)
|
|
f.close
|
|
|
|
def printUsage():
|
|
print "scoutDefault.py [-hRO] [-d directory] [-f file] [-x extension]"
|
|
print "-h : print this message"
|
|
print "-R : recursively parse directories"
|
|
print "-O : overwrite village_per_scout vaue in scenario"
|
|
print "-d : directory to look for file to parse"
|
|
print "-f : name of the file to parse"
|
|
print "-x : suffix to append to filename"
|
|
print "Example of use:"
|
|
print " ./scoutDefault.py -h"
|
|
print " Get help"
|
|
print " ./scoutDefault.py -f 2p_Blitz.cfg -x _new"
|
|
print " Run the script and write output on 2p_Blitz_new.cfg"
|
|
print " ./scoutDefault.py -d /usr/local/share/wesnoth/data/scenarios"
|
|
print " Run the script on all file under that directory"
|
|
print " ./scoutDefault.py -R -d /usr/local/share/wesnoth"
|
|
print " Run the script on all directories under that directory"
|
|
print " ./scoutDefault.py -f 2p_Blitz.cfg -O"
|
|
print " Run the script on 2p_Blitz.cfg and delete previous value"
|
|
|
|
recursive = 0
|
|
entryPoint = os.getcwd()
|
|
entryFile = os.listdir(os.getcwd())
|
|
resourcesFile = {}
|
|
try:
|
|
(opts, argsProper) = getopt.getopt(sys.argv[1:], 'ROhf:d:x:v:"')
|
|
except getopt.GetoptError, e:
|
|
print 'Error parsing command-line arguments: %s' % e
|
|
printUsage()
|
|
sys.exit(1)
|
|
for (option, parameter) in opts:
|
|
if option == '-h': # Print the commandline help and exit.
|
|
printUsage()
|
|
sys.exit(0)
|
|
elif option == '-R':
|
|
recursive = 1
|
|
elif option == '-O':
|
|
overwrite = 1
|
|
elif option == '-d':
|
|
if not os.path.exists(parameter):
|
|
print 'Error: %s directory does not exist' % parameter
|
|
sys.exit(1)
|
|
elif not os.path.isdir(parameter):
|
|
print 'Error: %s is not a directory' % parameter
|
|
sys.exit(1)
|
|
entryPoint = parameter
|
|
entryFile = os.listdir(entryPoint)
|
|
elif option == '-f':
|
|
entryFile = []
|
|
entryFile.append(os.path.basename(parameter))
|
|
entryPoint = os.path.dirname(parameter)
|
|
elif option == '-x':
|
|
suffix = parameter
|
|
|
|
if recursive == 1:
|
|
os.path.walk(entryPoint,parseAll,resourcesFile)
|
|
else:
|
|
parseAll(resourcesFile,entryPoint,entryFile)
|