Moved from

Paco Hope 1 year ago
parent fefe9db2fa
commit b70430351b

@ -0,0 +1,206 @@
""" Makes the configs as a massive string """
# Used for the conditions in the <double> type
condDict = {}
def makeCFG(cfg):
ret = ''
for key, data in cfg.items():
# I know all of these fields exist because it was verified in
bindType = firstTypeIn(data.keys())
bindContent = data[bindType]
ret += branch(key, bindContent, bindType)
# Doubles are weird. All of the toggles got put into a dictionary.
# This takes all of the nested dictionaries and turns them into the right string
for key, toggles in condDict.items():
ret += f'alias +{key}_toggles "{toggles["plus_toggles"]}"\n' +\
f'alias -{key}_toggles "{toggles["minus_toggles"]}"\n' +\
f'bind {key} "+{key}_toggles"\n'
return ret
def firstTypeIn(inputList):
""" Find the first element common to both lists """
types = [
for t in types:
if t in inputList:
return t
def branch(keyName, bindContent, bindType):
if bindType == "impulse":
return impulse(keyName, bindContent)
elif bindType == "hold":
if isinstance(bindContent, str):
return simpleHold(keyName, bindContent)
return listHold(keyName, bindContent)
elif bindType == "toggle":
return toggle(keyName, bindContent)
elif bindType == "double":
return double(keyName, bindContent)
elif bindType == "repeat":
return repeat(keyName, bindContent)
def impulse(key, instruction):
if isinstance(instruction, list):
instruction = ';'.join(instruction)
allInstructions = []
for indivCmd in instruction.split(';'):
instruction = ';'.join(allInstructions)
return f'bind {key} "{instruction}"\n'
def impulseShortcuts(instruction):
splitCommand = instruction.split(' ')
cmd = splitCommand[0]
shortcuts = {
"primary": "slot1",
"secondary": "slot2",
"melee": "slot3"
if cmd in shortcuts:
for sc, expansion in shortcuts.items():
if cmd == shortcut:
splitCommand[0] = expansion
instruction = ' '.join(splitCommand)
restOfCmd = ' '.join(splitCommand[1:])
if cmd == "voice":
instruction = voice(restOfCmd)
elif cmd == "build" or cmd == "destroy":
instruction = f"{cmd} " + expandBuildings(restOfCmd)
return instruction
def voice(keyword):
keyword = keyword.lower()
allLists = [
["medic", "thanks", "go", "move up", "go left", "go right", "yes", "no", "pass to me"],
["incoming", "spy", "sentry ahead", "teleporter here", "dispenser here", "sentry here", "activate uber", "uber ready"],
["help", "battle cry", "cheers", "jeers", "positive", "negative", "nice shot", "good job"]
for menu, voiceList in enumerate(allLists):
for selection, shortcut in enumerate(voiceList):
if keyword == shortcut:
return f'voicemenu {menu} {selection}'
def expandBuildings(building):
buildingNums = {
"dispenser": "0 0",
"entrance": "1 0",
"exit": "1 1",
"sentry": "2 0"
for shortBuild, num in buildingNums.items():
if building == shortBuild:
return num
def simpleHold(key, instruction):
# This isn't quite right, fix later!
if instruction[0] != '+':
return f'bind {key} "+{instruction}"\n'
return f'bind {key} "{instruction}"\n'
def listHold(key, options):
press_str = options["press"]
if isinstance(press_str, list):
press_str = ';'.join(press_str)
release_str = options["release"]
if isinstance(release_str, list):
release_str = ';'.join(release_str)
ret = f'alias +{key}_bind "{press_str}"\n' +\
f'alias -{key}_bind "{release_str}"\n' +\
f'bind {key} "+{key}_bind"\n'
return ret
def toggle(key, instruction):
onStr = f'turn_{key}_on'
offStr = f'turn_{key}_off'
togStr = f'toggle_{key}'
ret = f'alias {onStr} "+{instruction}; alias {togStr} {offStr}"\n' +\
f'alias {offStr} "-{instruction}; alias {togStr} {onStr}"\n' +\
f'alias {togStr} "{onStr}"\n' +\
f'bind {key} "{togStr}"\n'
return ret
def double(key, options):
prim_action = options["primary"]
pBindType = firstTypeIn(prim_action.keys())
pBindContent = prim_action[pBindType]
sec_action = options["secondary"]
sBindType = firstTypeIn(sec_action.keys())
sBindContent = sec_action[sBindType]
main_str = f'{key}_main'
alt_str = f'{key}_alt'
tog_str = f'toggle_{key}'
recursive_code = branch(main_str, pBindContent, pBindType) +\
branch(alt_str, sBindContent, sBindType)
newcode = []
for line in recursive_code.split('\n'):
# For every line gotten by the recursive call, change all "bind"s to "alias",
# since main_str and alt_str aren't valid bind targes
llist = line.split(' ')
for i in range(len(llist)):
alphanum_chars = ''.join(c for c in llist[i] if c.isalnum())
if alphanum_chars == 'bind':
if llist[i][0].isalnum():
llist[i] = 'alias'
# If the first character isn't a normal character.
# Almost always because it is a double quote
llist[i] = llist[i][0] + 'alias'
newcode.append(' '.join(llist))
ret = '\n'.join(newcode) +\
f'alias +{tog_str} "bind {key} {alt_str}"\n' +\
f'alias -{tog_str} "bind {key} {main_str}"\n'+\
f'bind {key} "{main_str}"\n'
cond_name = options["condition"]
if cond_name in condDict:
# If the condition key (like "mouse4") already has toggles,
# just append another toggle string (it gets encased in quotes later)
condDict[cond_name]["plus_toggles"] += f"; +{tog_str}"
condDict[cond_name]["minus_toggles"] += f"; -{tog_str}"
# If the condition key doesn't already exist, make it with the correct values
condDict.update( {
cond_name: {
"plus_toggles": f"+{tog_str}",
"minus_toggles": f"-{tog_str}"
} )
return ret
def repeat(key, options):
return f'placeholder for {key} (repeat)\n'