X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=newdungeon.py;h=7f37b36f82b2c2af8dfe46be24ac732244588fe7;hb=c080ea85bbba8def903facaf8e94e4b04e3924e2;hp=1ff4327e486798ec76e300a68859b9fb9ab62372;hpb=39eed7d678588438a7abe97354987816e9305096;p=open-adventure.git diff --git a/newdungeon.py b/newdungeon.py index 1ff4327..7f37b36 100755 --- a/newdungeon.py +++ b/newdungeon.py @@ -1,8 +1,10 @@ #!/usr/bin/python3 -# This is the new open-adventure dungeon generator. It'll eventually replace the existing dungeon.c It currently outputs a .h and .c pair for C code. +# This is the new open-adventure dungeon generator. It'll eventually +# replace the existing dungeon.c It currently outputs a .h and .c pair +# for C code. -import yaml +import sys, yaml yaml_name = "adventure.yaml" h_name = "newdb.h" @@ -44,11 +46,12 @@ h_template = """/* Generated from adventure.yaml - do not hand-hack! */ typedef struct {{ const char* inventory; + int plac, fixd; bool is_treasure; const char** longs; const char** sounds; const char** texts; -}} object_description_t; +}} object_t; typedef struct {{ const char* small; @@ -85,21 +88,35 @@ typedef struct {{ const char* hint; }} hint_t; +typedef struct {{ + const char** words; +}} motion_t; + +typedef struct {{ + const char** words; + const long message; +}} action_t; + extern const location_t locations[]; -extern const object_description_t object_descriptions[]; -extern const const char* arbitrary_messages[]; -extern const const class_t classes[]; +extern const object_t objects[]; +extern const char* arbitrary_messages[]; +extern const class_t classes[]; extern const turn_threshold_t turn_thresholds[]; extern const obituary_t obituaries[]; extern const hint_t hints[]; extern long conditions[]; +extern const long actspk[]; +extern const motion_t motions[]; +extern const action_t actions[]; -#define NLOCATIONS {} +#define NLOCATIONS {} #define NOBJECTS {} #define NHINTS {} #define NCLASSES {} #define NDEATHS {} #define NTHRESHOLDS {} +#define NACTIONS {} +#define NTRAVEL {} enum arbitrary_messages_refs {{ {} @@ -109,7 +126,15 @@ enum locations_refs {{ {} }}; -enum object_descriptions_refs {{ +enum object_refs {{ +{} +}}; + +enum motion_refs {{ +{} +}}; + +enum action_refs {{ {} }}; @@ -140,7 +165,7 @@ const location_t locations[] = {{ {} }}; -const object_description_t object_descriptions[] = {{ +const object_t objects[] = {{ {} }}; @@ -156,6 +181,19 @@ long conditions[] = {{ {} }}; +const long actspk[] = {{ + NO_MESSAGE, +{} +}}; + +const motion_t motions[] = {{ +{} +}}; + +const action_t actions[] = {{ +{} +}}; + /* end */ """ @@ -218,7 +256,7 @@ def get_turn_thresholds(trn): return trn_str def get_locations(loc): - template = """ {{ + template = """ {{ // {} .description = {{ .small = {}, .big = {}, @@ -228,18 +266,20 @@ def get_locations(loc): }}, """ loc_str = "" - for item in loc: + for (i, item) in enumerate(loc): short_d = make_c_string(item[1]["description"]["short"]) long_d = make_c_string(item[1]["description"]["long"]) sound = item[1].get("sound", "SILENT") loud = "true" if item[1].get("loud") else "false" - loc_str += template.format(short_d, long_d, sound, loud) + loc_str += template.format(i, short_d, long_d, sound, loud) loc_str = loc_str[:-1] # trim trailing newline return loc_str -def get_object_descriptions(obj): - template = """ {{ +def get_objects(obj): + template = """ {{ // {} .inventory = {}, + .plac = {}, + .fixd = {}, .is_treasure = {}, .longs = (const char* []) {{ {} @@ -253,14 +293,15 @@ def get_object_descriptions(obj): }}, """ obj_str = "" - for item in obj: - i_msg = make_c_string(item[1]["inventory"]) + for (i, item) in enumerate(obj): + attr = item[1] + i_msg = make_c_string(attr["inventory"]) longs_str = "" - if item[1]["longs"] == None: + if attr["longs"] == None: longs_str = " " * 12 + "NULL," else: labels = [] - for l_msg in item[1]["longs"]: + for l_msg in attr["longs"]: if not isinstance(l_msg, str): labels.append(l_msg) l_msg = l_msg[1] @@ -275,21 +316,31 @@ def get_object_descriptions(obj): statedefines += "#define %s\t%d /* %s */\n" % (label, i, message) statedefines += "\n" sounds_str = "" - if item[1].get("sounds") == None: + if attr.get("sounds") == None: sounds_str = " " * 12 + "NULL," else: - for l_msg in item[1]["sounds"]: + for l_msg in attr["sounds"]: sounds_str += " " * 12 + make_c_string(l_msg) + ",\n" sounds_str = sounds_str[:-1] # trim trailing newline texts_str = "" - if item[1].get("texts") == None: + if attr.get("texts") == None: texts_str = " " * 12 + "NULL," else: - for l_msg in item[1]["texts"]: + for l_msg in attr["texts"]: texts_str += " " * 12 + make_c_string(l_msg) + ",\n" texts_str = texts_str[:-1] # trim trailing newline - treasure = "true" if item[1].get("treasure") else "false" - obj_str += template.format(i_msg, treasure, longs_str, sounds_str, texts_str) + locs = attr.get("locations", ["LOC_NOWHERE", "LOC_NOWHERE"]) + immovable = attr.get("immovable", False) + try: + if type(locs) == str: + locs = [locnames.index(locs), -1 if immovable else 0] + else: + locs = [locnames.index(x) for x in locs] + except IndexError: + sys.stderr.write("dungeon: unknown object location in %s\n" % locs) + sys.exit(1) + treasure = "true" if attr.get("treasure") else "false" + obj_str += template.format(i, i_msg, locs[0], locs[1], treasure, longs_str, sounds_str, texts_str) obj_str = obj_str[:-1] # trim trailing newline return obj_str @@ -323,8 +374,8 @@ def get_hints(hnt, arb): number = item["number"] penalty = item["penalty"] turns = item["turns"] - question = make_c_string(md[item["question"]]) - hint = make_c_string(md[item["hint"]]) + question = make_c_string(item["question"]) + hint = make_c_string(item["hint"]) hnt_str += template.format(number, penalty, turns, question, hint) hnt_str = hnt_str[:-1] # trim trailing newline return hnt_str @@ -349,32 +400,168 @@ def get_condbits(locations): cnd_str += " " + line + ",\t// " + name + "\n" return cnd_str +def recompose(type_word, value): + "Compose the internal code for a vocabulary word from its YAML entry" + parts = ("motion", "action", "object", "special") + try: + return value + 1000 * parts.index(type_word) + except KeyError: + sys.stderr.write("dungeon: %s is not a known word\n" % word) + sys.exit(1) + except IndexError: + sys.stderr.write("%s is not a known word classifier\n" % attrs["type"]) + sys.exit(1) + +def get_actspk(actspk): + res = "" + for (i, word) in actspk.items(): + res += " %s,\n" % word + return res + +def buildtravel(locs, objs, voc): + ltravel = [] + lkeys = [] + verbmap = {} + for entry in db["vocabulary"]: + if entry["type"] == "motion" and entry["value"] not in verbmap: + verbmap[entry["word"]] = entry["value"] + def dencode(action, name): + "Decode a destination number" + if action[0] == "goto": + try: + return locnames.index(action[1]) + except ValueError: + sys.stderr.write("dungeon: unknown location %s in goto clause of %s\n" % (cond[1], name)) + elif action[0] == "special": + return 300 + action[1] + elif action[0] == "speak": + try: + return 500 + msgnames.index(action[1]) + except ValueError: + sys.stderr.write("dungeon: unknown location %s in carry clause of %s\n" % (cond[1], name)) + else: + print(cond) + raise ValueError + def cencode(cond, name): + if cond is None: + return 0; + elif cond[0] == "pct": + return cond[1] + elif cond[0] == "carry": + try: + return 100 + objnames.index(cond[1]) + except ValueError: + sys.stderr.write("dungeon: unknown object name %s in carry clause of %s\n" % (cond[1], name)) + sys.exit(1) + elif cond[0] == "with": + try: + return 200 + objnames.index(cond[1]) + except IndexError: + sys.stderr.write("dungeon: unknown object name %s in with clause of \n" % (cond[1], name)) + sys.exit(1) + elif cond[0] == "not": + # FIXME: Allow named as well as numbered states + try: + return 300 + objnames.index(cond[1]) + 100 * cond[2] + except ValueError: + sys.stderr.write("dungeon: unknown object name %s in not clause of %s\n" % (cond[1], name)) + sys.exit(1) + else: + print(cond) + raise ValueError + # Much more to be done here + for (i, (name, loc)) in enumerate(locs): + if "travel" in loc: + for rule in loc["travel"]: + tt = [i] + dest = dencode(rule["action"], name) + 1000 * cencode(rule.get("cond"), name) + tt.append(dest) + tt += [verbmap[e] for e in rule["verbs"]] + if not rule["verbs"]: + tt.append(1) + ltravel.append(tuple(tt)) + return (tuple(ltravel), lkeys) + +def get_motions(motions): + template = """ {{ + .words = {}, + }}, +""" + mot_str = "" + for motion in motions: + contents = motion[1] + if contents["words"] == None: + mot_str += template.format("NULL") + continue + c_words = [make_c_string(s) for s in contents["words"]] + words_str = "(const char* []) {" + ", ".join(c_words) + "}" + mot_str += template.format(words_str) + return mot_str + +def get_actions(actions): + template = """ {{ + .words = {}, + .message = {}, + }}, +""" + act_str = "" + for action in actions: + contents = action[1] + + if contents["words"] == None: + words_str = "NULL" + else: + c_words = [make_c_string(s) for s in contents["words"]] + words_str = "(const char* []) {" + ", ".join(c_words) + "}" + + if contents["message"] == None: + message = "NO_MESSAGE" + else: + message = contents["message"] + + act_str += template.format(words_str, message) + act_str = act_str[:-1] # trim trailing newline + return act_str + if __name__ == "__main__": with open(yaml_name, "r") as f: db = yaml.load(f) + locnames = [x[0] for x in db["locations"]] + msgnames = [el[0] for el in db["arbitrary_messages"]] + objnames = [el[0] for el in db["objects"]] + (travel, key) = buildtravel(db["locations"], db["objects"], db["vocabulary"]) + # FIXME: pack the Section 3 representation into the runtime format. + c = c_template.format( h_name, get_arbitrary_messages(db["arbitrary_messages"]), get_class_messages(db["classes"]), get_turn_thresholds(db["turn_thresholds"]), get_locations(db["locations"]), - get_object_descriptions(db["object_descriptions"]), + get_objects(db["objects"]), get_obituaries(db["obituaries"]), get_hints(db["hints"], db["arbitrary_messages"]), get_condbits(db["locations"]), + get_actspk(db["actspk"]), + get_motions(db["motions"]), + get_actions(db["actions"]), ) h = h_template.format( - len(db["locations"]), - len(db["object_descriptions"]), + len(db["locations"])-1, + len(db["objects"])-1, len(db["hints"]), - len(db["classes"]), + len(db["classes"])-1, len(db["obituaries"]), len(db["turn_thresholds"]), + len(db["actspk"]), + len(travel), get_refs(db["arbitrary_messages"]), get_refs(db["locations"]), - get_refs(db["object_descriptions"]), + get_refs(db["objects"]), + get_refs(db["motions"]), + get_refs(db["actions"]), statedefines, )