737 lines
23 KiB
Python
737 lines
23 KiB
Python
from BaseClasses import Item, Location
|
|
from typing import Tuple, Union, Set, List, Dict
|
|
import string
|
|
import pkgutil
|
|
|
|
|
|
class TerrariaItem(Item):
|
|
game = "Terraria"
|
|
|
|
|
|
class TerrariaLocation(Location):
|
|
game = "Terraria"
|
|
|
|
|
|
def add_token(
|
|
tokens: List[Tuple[int, int, Union[str, int, None]]],
|
|
token: Union[str, int],
|
|
token_index: int,
|
|
):
|
|
if token == "":
|
|
return
|
|
if type(token) == str:
|
|
tokens.append((token_index, 0, token.rstrip()))
|
|
elif type(token) == int:
|
|
tokens.append((token_index, 1, token))
|
|
|
|
|
|
IDENT = 0
|
|
NUM = 1
|
|
SEMI = 2
|
|
HASH = 3
|
|
AT = 4
|
|
NOT = 5
|
|
AND = 6
|
|
OR = 7
|
|
LPAREN = 8
|
|
RPAREN = 9
|
|
END_OF_LINE = 10
|
|
|
|
CHAR_TO_TOKEN_ID = {
|
|
";": SEMI,
|
|
"#": HASH,
|
|
"@": AT,
|
|
"~": NOT,
|
|
"&": AND,
|
|
"|": OR,
|
|
"(": LPAREN,
|
|
")": RPAREN,
|
|
}
|
|
|
|
TOKEN_ID_TO_CHAR = {id: char for char, id in CHAR_TO_TOKEN_ID.items()}
|
|
|
|
|
|
def tokens(rule: str) -> List[Tuple[int, int, Union[str, int, None]]]:
|
|
token_list = []
|
|
token = ""
|
|
token_index = 0
|
|
escaped = False
|
|
for index, char in enumerate(rule):
|
|
if escaped:
|
|
if token == "":
|
|
token_index = index
|
|
token += char
|
|
escaped = False
|
|
elif char == "\\":
|
|
if type(token) == int:
|
|
add_token(token_list, token, token_index)
|
|
token = ""
|
|
escaped = True
|
|
elif char == "/" and token.endswith("/"):
|
|
add_token(token_list, token[:-1], token_index)
|
|
return token_list
|
|
elif token == "" and char.isspace():
|
|
pass
|
|
elif token == "" and char.isdigit():
|
|
token_index = index
|
|
token = int(char)
|
|
elif type(token) == int and char.isdigit():
|
|
token = token * 10 + int(char)
|
|
elif (id := CHAR_TO_TOKEN_ID.get(char)) != None:
|
|
add_token(token_list, token, token_index)
|
|
token_list.append((index, id, None))
|
|
token = ""
|
|
else:
|
|
if token == "":
|
|
token_index = index
|
|
token += char
|
|
|
|
add_token(token_list, token, token_index)
|
|
return token_list
|
|
|
|
|
|
NAME = 0
|
|
NAME_SEMI = 1
|
|
FLAG_OR_SEMI = 2
|
|
POST_FLAG = 3
|
|
FLAG = 4
|
|
FLAG_ARG = 5
|
|
FLAG_ARG_END = 6
|
|
COND_OR_SEMI = 7
|
|
POST_COND = 8
|
|
COND = 9
|
|
LOC = 10
|
|
FN = 11
|
|
POST_FN = 12
|
|
FN_ARG = 13
|
|
FN_ARG_END = 14
|
|
END = 15
|
|
GOAL = 16
|
|
|
|
POS_FMT = [
|
|
"name or `#`",
|
|
"`;`",
|
|
"flag or `;`",
|
|
"`;`, `|`, or `(`",
|
|
"flag",
|
|
"text or number",
|
|
"`)`",
|
|
"name, `#`, `@`, `~`, `(`, or `;`",
|
|
"`;`, `&`, `|`, or `)`",
|
|
"name, `#`, `@`, `~`, or `(`",
|
|
"name",
|
|
"name",
|
|
"`(`, `;`, `&`, `|`, or `)`",
|
|
"text or number",
|
|
"`)`",
|
|
"end of line",
|
|
"goal",
|
|
]
|
|
|
|
RWD_NAME = 0
|
|
RWD_NAME_SEMI = 1
|
|
RWD_FLAG = 2
|
|
RWD_FLAG_SEMI = 3
|
|
RWD_END = 4
|
|
RWD_LABEL = 5
|
|
|
|
RWD_POS_FMT = ["name or `#`", "`;`", "flag", "`;`", "end of line", "name"]
|
|
|
|
|
|
def unexpected(line: int, char: int, id: int, token, pos, pos_fmt, file):
|
|
if id == IDENT or id == NUM:
|
|
token_fmt = f"`{token}`"
|
|
elif id == END_OF_LINE:
|
|
token_fmt = "end of line"
|
|
else:
|
|
token_fmt = f"`{TOKEN_ID_TO_CHAR[id]}`"
|
|
|
|
raise Exception(
|
|
f"in `{file}`, found {token_fmt} at {line + 1}:{char + 1}; expected {pos_fmt[pos]}"
|
|
)
|
|
|
|
|
|
COND_ITEM = 0
|
|
COND_LOC = 1
|
|
COND_FN = 2
|
|
COND_GROUP = 3
|
|
|
|
|
|
def validate_conditions(
|
|
rule: str,
|
|
rule_indices: dict,
|
|
conditions: List[
|
|
Tuple[
|
|
bool, int, Union[str, Tuple[Union[bool, None], list]], Union[str, int, None]
|
|
]
|
|
],
|
|
):
|
|
for _, type, condition, _ in conditions:
|
|
if type == COND_ITEM:
|
|
if condition not in rule_indices:
|
|
raise Exception(f"item `{condition}` in `{rule}` is not defined")
|
|
elif type == COND_LOC:
|
|
if condition not in rule_indices:
|
|
raise Exception(f"location `{condition}` in `{rule}` is not defined")
|
|
elif type == COND_FN:
|
|
if condition not in {
|
|
"npc",
|
|
"calamity",
|
|
"pickaxe",
|
|
"hammer",
|
|
"mech_boss",
|
|
"minions",
|
|
}:
|
|
raise Exception(f"function `{condition}` in `{rule}` is not defined")
|
|
elif type == COND_GROUP:
|
|
_, conditions = condition
|
|
validate_conditions(rule, rule_indices, conditions)
|
|
|
|
|
|
def mark_progression(
|
|
conditions: List[
|
|
Tuple[
|
|
bool, int, Union[str, Tuple[Union[bool, None], list]], Union[str, int, None]
|
|
]
|
|
],
|
|
progression: Set[str],
|
|
rules: list,
|
|
rule_indices: dict,
|
|
loc_to_item: dict,
|
|
):
|
|
for _, type, condition, _ in conditions:
|
|
if type == COND_ITEM:
|
|
prog = condition in progression
|
|
progression.add(loc_to_item[condition])
|
|
_, flags, _, conditions = rules[rule_indices[condition]]
|
|
if (
|
|
not prog
|
|
and "Achievement" not in flags
|
|
and "Location" not in flags
|
|
and "Item" not in flags
|
|
):
|
|
mark_progression(
|
|
conditions, progression, rules, rule_indices, loc_to_item
|
|
)
|
|
elif type == COND_LOC:
|
|
_, _, _, conditions = rules[rule_indices[condition]]
|
|
mark_progression(conditions, progression, rules, rule_indices, loc_to_item)
|
|
elif type == COND_GROUP:
|
|
_, conditions = condition
|
|
mark_progression(conditions, progression, rules, rule_indices, loc_to_item)
|
|
|
|
|
|
def read_data() -> (
|
|
Tuple[
|
|
# Goal to rule index that ends that goal's range and the locations required
|
|
List[Tuple[int, Set[str]]],
|
|
# Rules
|
|
List[
|
|
Tuple[
|
|
# Rule
|
|
str,
|
|
# Flag to flag arg
|
|
Dict[str, Union[str, int, None]],
|
|
# True = or, False = and, None = N/A
|
|
Union[bool, None],
|
|
# Conditions
|
|
List[
|
|
Tuple[
|
|
# True = positive, False = negative
|
|
bool,
|
|
# Condition type
|
|
int,
|
|
# Condition name or list (True = or, False = and, None = N/A) (list shares type with outer)
|
|
Union[str, Tuple[Union[bool, None], List]],
|
|
# Condition arg
|
|
Union[str, int, None],
|
|
]
|
|
],
|
|
]
|
|
],
|
|
# Rule to rule index
|
|
Dict[str, int],
|
|
# Label to rewards
|
|
Dict[str, List[str]],
|
|
# Reward to flags
|
|
Dict[str, Set[str]],
|
|
# Item name to ID
|
|
Dict[str, int],
|
|
# Location name to ID
|
|
Dict[str, int],
|
|
# NPCs
|
|
List[str],
|
|
# Pickaxe to pick power
|
|
Dict[str, int],
|
|
# Hammer to hammer power
|
|
Dict[str, int],
|
|
# Mechanical bosses
|
|
List[str],
|
|
# Calamity final bosses
|
|
List[str],
|
|
# Progression rules
|
|
Set[str],
|
|
# Armor to minion count,
|
|
Dict[str, int],
|
|
# Accessory to minion count,
|
|
Dict[str, int],
|
|
]
|
|
):
|
|
next_id = 0x7E0000
|
|
item_name_to_id = {}
|
|
|
|
goals = []
|
|
goal_indices = {}
|
|
rules = []
|
|
rule_indices = {}
|
|
loc_to_item = {}
|
|
|
|
npcs = []
|
|
pickaxes = {}
|
|
hammers = {}
|
|
mech_boss_loc = []
|
|
mech_bosses = []
|
|
final_boss_loc = []
|
|
final_bosses = []
|
|
armor_minions = {}
|
|
accessory_minions = {}
|
|
|
|
progression = set()
|
|
|
|
for line, rule in enumerate(
|
|
pkgutil.get_data(__name__, "Rules.dsv").decode().splitlines()
|
|
):
|
|
goal = None
|
|
name = None
|
|
flags = {}
|
|
|
|
sign = True
|
|
operator = None
|
|
outer = []
|
|
conditions = []
|
|
|
|
pos = NAME
|
|
for char, id, token in tokens(rule):
|
|
if pos == NAME:
|
|
if id == IDENT:
|
|
name = token
|
|
pos = NAME_SEMI
|
|
elif id == HASH:
|
|
pos = GOAL
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == NAME_SEMI:
|
|
if id == SEMI:
|
|
pos = FLAG_OR_SEMI
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FLAG_OR_SEMI:
|
|
if id == IDENT:
|
|
flag = token
|
|
pos = POST_FLAG
|
|
elif id == SEMI:
|
|
pos = COND_OR_SEMI
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == POST_FLAG:
|
|
if id == SEMI:
|
|
if flag is not None:
|
|
if flag in flags:
|
|
raise Exception(
|
|
f"set flag `{flag}` at {line + 1}:{char + 1} that was already set"
|
|
)
|
|
flags[flag] = None
|
|
flag = None
|
|
pos = COND_OR_SEMI
|
|
elif id == OR:
|
|
pos = FLAG
|
|
elif id == LPAREN:
|
|
pos = FLAG_ARG
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FLAG:
|
|
if id == IDENT:
|
|
if flag is not None:
|
|
if flag in flags:
|
|
raise Exception(
|
|
f"set flag `{flag}` at {line + 1}:{char + 1} that was already set"
|
|
)
|
|
flags[flag] = None
|
|
flag = None
|
|
flag = token
|
|
pos = POST_FLAG
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FLAG_ARG:
|
|
if id == IDENT or id == NUM:
|
|
if flag in flags:
|
|
raise Exception(
|
|
f"set flag `{flag}` at {line + 1}:{char + 1} that was already set"
|
|
)
|
|
flags[flag] = token
|
|
flag = None
|
|
pos = FLAG_ARG_END
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FLAG_ARG_END:
|
|
if id == RPAREN:
|
|
pos = POST_FLAG
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == COND_OR_SEMI:
|
|
if id == IDENT:
|
|
conditions.append((sign, COND_ITEM, token, None))
|
|
sign = True
|
|
pos = POST_COND
|
|
elif id == HASH:
|
|
pos = LOC
|
|
elif id == AT:
|
|
pos = FN
|
|
elif id == NOT:
|
|
sign = not sign
|
|
pos = COND
|
|
elif id == LPAREN:
|
|
outer.append((sign, None, conditions))
|
|
conditions = []
|
|
sign = True
|
|
pos = COND
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == POST_COND:
|
|
if id == SEMI:
|
|
if outer:
|
|
raise Exception(
|
|
f"found `;` at {line + 1}:{char + 1} after unclosed `(`"
|
|
)
|
|
pos = END
|
|
elif id == AND:
|
|
if operator is True:
|
|
raise Exception(
|
|
f"found `&` at {line + 1}:{char + 1} in group containing `|`"
|
|
)
|
|
operator = False
|
|
pos = COND
|
|
elif id == OR:
|
|
if operator is False:
|
|
raise Exception(
|
|
f"found `|` at {line + 1}:{char + 1} in group containing `&`"
|
|
)
|
|
operator = True
|
|
pos = COND
|
|
elif id == RPAREN:
|
|
if not outer:
|
|
raise Exception(
|
|
f"found `)` at {line + 1}:{char + 1} without matching `(`"
|
|
)
|
|
condition = operator, conditions
|
|
sign, operator, conditions = outer.pop()
|
|
conditions.append((sign, COND_GROUP, condition, None))
|
|
sign = True
|
|
pos = POST_COND
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == COND:
|
|
if id == IDENT:
|
|
conditions.append((sign, COND_ITEM, token, None))
|
|
sign = True
|
|
pos = POST_COND
|
|
elif id == HASH:
|
|
pos = LOC
|
|
elif id == AT:
|
|
pos = FN
|
|
elif id == NOT:
|
|
sign = not sign
|
|
elif id == LPAREN:
|
|
outer.append((sign, operator, conditions))
|
|
conditions = []
|
|
sign = True
|
|
operator = None
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == LOC:
|
|
if id == IDENT:
|
|
conditions.append((sign, COND_LOC, token, None))
|
|
sign = True
|
|
pos = POST_COND
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FN:
|
|
if id == IDENT:
|
|
function = token
|
|
pos = POST_FN
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == POST_FN:
|
|
if id == LPAREN:
|
|
pos = FN_ARG
|
|
elif id == SEMI:
|
|
conditions.append((sign, COND_FN, function, None))
|
|
pos = END
|
|
elif id == AND:
|
|
conditions.append((sign, COND_FN, function, None))
|
|
sign = True
|
|
if operator is True:
|
|
raise Exception(
|
|
f"found `&` at {line + 1}:{char + 1} in group containing `|`"
|
|
)
|
|
operator = False
|
|
pos = COND
|
|
elif id == OR:
|
|
conditions.append((sign, COND_FN, function, None))
|
|
sign = True
|
|
if operator is False:
|
|
raise Exception(
|
|
f"found `|` at {line + 1}:{char + 1} in group containing `&`"
|
|
)
|
|
operator = True
|
|
pos = COND
|
|
elif id == RPAREN:
|
|
conditions.append((sign, COND_FN, function, None))
|
|
if not outer:
|
|
raise Exception(
|
|
f"found `)` at {line + 1}:{char + 1} without matching `(`"
|
|
)
|
|
condition = operator, conditions
|
|
sign, operator, conditions = outer.pop()
|
|
conditions.append((sign, COND_GROUP, condition, None))
|
|
sign = True
|
|
pos = POST_COND
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FN_ARG:
|
|
if id == IDENT or id == NUM:
|
|
conditions.append((sign, COND_FN, function, token))
|
|
sign = True
|
|
pos = FN_ARG_END
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == FN_ARG_END:
|
|
if id == RPAREN:
|
|
pos = POST_COND
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
elif pos == END:
|
|
unexpected(line, char, id, token, pos)
|
|
elif pos == GOAL:
|
|
if id == IDENT:
|
|
goal = token
|
|
pos = END
|
|
else:
|
|
unexpected(line, char, id, token, pos, POS_FMT, "Rules.dsv")
|
|
|
|
if pos != NAME and pos != FLAG_OR_SEMI and pos != COND_OR_SEMI and pos != END:
|
|
unexpected(line, char + 1, END_OF_LINE, None, pos, POS_FMT, "Rules.dsv")
|
|
|
|
if name:
|
|
if name in rule_indices:
|
|
raise Exception(
|
|
f"rule `{name}` on line `{line + 1}` shadows a previous rule"
|
|
)
|
|
rule_indices[name] = len(rules)
|
|
rules.append((name, flags, operator, conditions))
|
|
|
|
if "Item" in flags:
|
|
item_name = flags["Item"] or f"Post-{name}"
|
|
if item_name in item_name_to_id:
|
|
raise Exception(
|
|
f"item `{item_name}` on line `{line + 1}` shadows a previous item"
|
|
)
|
|
item_name_to_id[item_name] = next_id
|
|
next_id += 1
|
|
loc_to_item[name] = item_name
|
|
else:
|
|
loc_to_item[name] = name
|
|
|
|
if "Npc" in flags:
|
|
npcs.append(name)
|
|
|
|
if (power := flags.get("Pickaxe")) is not None:
|
|
pickaxes[name] = power
|
|
|
|
if (power := flags.get("Hammer")) is not None:
|
|
hammers[name] = power
|
|
|
|
if "Mech Boss" in flags:
|
|
mech_bosses.append(flags["Item"] or f"Post-{name}")
|
|
mech_boss_loc.append(name)
|
|
|
|
if "Final Boss" in flags:
|
|
final_bosses.append(flags["Item"] or f"Post-{name}")
|
|
final_boss_loc.append(name)
|
|
|
|
if (minions := flags.get("ArmorMinions")) is not None:
|
|
armor_minions[name] = minions
|
|
|
|
if (minions := flags.get("Minions")) is not None:
|
|
accessory_minions[name] = minions
|
|
|
|
if goal:
|
|
if goal in goal_indices:
|
|
raise Exception(
|
|
f"goal `{goal}` on line `{line + 1}` shadows a previous goal"
|
|
)
|
|
goal_indices[goal] = len(goals)
|
|
goals.append((len(rules), set()))
|
|
|
|
for name, flags, _, _ in rules:
|
|
if "Goal" in flags:
|
|
_, items = goals[
|
|
goal_indices[
|
|
name.translate(str.maketrans("", "", string.punctuation))
|
|
.replace(" ", "_")
|
|
.lower()
|
|
]
|
|
]
|
|
items.add(name)
|
|
|
|
_, mech_boss_items = goals[goal_indices["mechanical_bosses"]]
|
|
mech_boss_items.update(mech_boss_loc)
|
|
|
|
_, final_boss_items = goals[goal_indices["calamity_final_bosses"]]
|
|
final_boss_items.update(final_boss_loc)
|
|
|
|
for name, _, _, conditions in rules:
|
|
validate_conditions(name, rule_indices, conditions)
|
|
|
|
for name, flags, _, conditions in rules:
|
|
prog = False
|
|
if (
|
|
"Npc" in flags
|
|
or "Goal" in flags
|
|
or "Pickaxe" in flags
|
|
or "Hammer" in flags
|
|
or "Mech Boss" in flags
|
|
or "Minions" in flags
|
|
or "ArmorMinions" in flags
|
|
):
|
|
progression.add(loc_to_item[name])
|
|
prog = True
|
|
if prog or "Location" in flags or "Achievement" in flags:
|
|
mark_progression(conditions, progression, rules, rule_indices, loc_to_item)
|
|
|
|
# Will be randomized via `slot_randoms` / `self.multiworld.random`
|
|
label = None
|
|
labels = {}
|
|
rewards = {}
|
|
|
|
for line in pkgutil.get_data(__name__, "Rewards.dsv").decode().splitlines():
|
|
reward = None
|
|
flags = set()
|
|
|
|
pos = RWD_NAME
|
|
for char, id, token in tokens(line):
|
|
if pos == RWD_NAME:
|
|
if id == IDENT:
|
|
reward = f"Reward: {token}"
|
|
pos = RWD_NAME_SEMI
|
|
elif id == HASH:
|
|
pos = RWD_LABEL
|
|
else:
|
|
unexpected(line, char, id, token, pos, RWD_POS_FMT, "Rewards.dsv")
|
|
elif pos == RWD_NAME_SEMI:
|
|
if id == SEMI:
|
|
pos = RWD_FLAG
|
|
else:
|
|
unexpected(line, char, id, token, pos, RWD_POS_FMT, "Rewards.dsv")
|
|
elif pos == RWD_FLAG:
|
|
if id == IDENT:
|
|
if token in flags:
|
|
raise Exception(
|
|
f"set flag `{token}` at {line + 1}:{char + 1} that was already set"
|
|
)
|
|
flags.add(token)
|
|
pos = RWD_FLAG_SEMI
|
|
else:
|
|
unexpected(line, char, id, token, pos, RWD_POS_FMT, "Rewards.dsv")
|
|
elif pos == RWD_FLAG_SEMI:
|
|
if id == SEMI:
|
|
pos = RWD_END
|
|
else:
|
|
unexpected(line, char, id, token, pos, RWD_POS_FMT, "Rewards.dsv")
|
|
elif pos == RWD_END:
|
|
unexpected(line, char, id, token, pos, RWD_POS_FMT, "Rewards.dsv")
|
|
elif pos == RWD_LABEL:
|
|
if id == IDENT:
|
|
label = token
|
|
if label in labels:
|
|
raise Exception(
|
|
f"started label `{label}` at {line + 1}:{char + 1} that was already used"
|
|
)
|
|
labels[label] = []
|
|
pos = RWD_END
|
|
else:
|
|
unexpected(line, char, id, token, pos, RWD_POS_FMT, "Rewards.dsv")
|
|
|
|
if pos != RWD_NAME and pos != RWD_FLAG and pos != RWD_END:
|
|
unexpected(line, char + 1, END_OF_LINE, None, pos)
|
|
|
|
if reward:
|
|
if reward in rewards:
|
|
raise Exception(
|
|
f"reward `{reward}` on line `{line + 1}` shadows a previous reward"
|
|
)
|
|
rewards[reward] = flags
|
|
|
|
if not label:
|
|
raise Exception(
|
|
f"reward `{reward}` on line `{line + 1}` is not labeled"
|
|
)
|
|
labels[label].append(reward)
|
|
|
|
if reward in item_name_to_id:
|
|
raise Exception(
|
|
f"item `{reward}` on line `{line + 1}` shadows a previous item"
|
|
)
|
|
item_name_to_id[reward] = next_id
|
|
next_id += 1
|
|
|
|
item_name_to_id["Reward: Coins"] = next_id
|
|
item_name_to_id["Victory"] = next_id + 1
|
|
next_id += 2
|
|
|
|
location_name_to_id = {}
|
|
|
|
for name, flags, _, _ in rules:
|
|
if "Location" in flags or "Achievement" in flags:
|
|
if name in location_name_to_id:
|
|
raise Exception(f"location `{name}` shadows a previous location")
|
|
location_name_to_id[name] = next_id
|
|
next_id += 1
|
|
|
|
return (
|
|
goals,
|
|
rules,
|
|
rule_indices,
|
|
labels,
|
|
rewards,
|
|
item_name_to_id,
|
|
location_name_to_id,
|
|
npcs,
|
|
pickaxes,
|
|
hammers,
|
|
mech_bosses,
|
|
final_bosses,
|
|
progression,
|
|
armor_minions,
|
|
accessory_minions,
|
|
)
|
|
|
|
|
|
(
|
|
goals,
|
|
rules,
|
|
rule_indices,
|
|
labels,
|
|
rewards,
|
|
item_name_to_id,
|
|
location_name_to_id,
|
|
npcs,
|
|
pickaxes,
|
|
hammers,
|
|
mech_bosses,
|
|
final_bosses,
|
|
progression,
|
|
armor_minions,
|
|
accessory_minions,
|
|
) = read_data()
|