X-Git-Url: https://jxself.org/git/?p=open-adventure.git;a=blobdiff_plain;f=newdungeon.py;h=60625997f907ddc4976fd39b1ce406f5d546637f;hp=092c342e52038588bc08550cc985fb3bbca5e4d0;hb=3b780dd57e295b57ba78649e008fede10e07cdd9;hpb=537c4511e2f3802421f79aed7b6af16d66adb518 diff --git a/newdungeon.py b/newdungeon.py index 092c342..6062599 100755 --- a/newdungeon.py +++ b/newdungeon.py @@ -1,23 +1,97 @@ #!/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. - -import yaml +# 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. +# +# The nontrivial part of this is the compilation of the YAML for +# movement rules to the travel array that's actually used by +# playermove(). This program first compiles the YAML to a form +# identical to the data in section 3 of the old adventure.text file, +# then a second stage unpacks that data into the travel array. +# +# Here are the rules of the intermediate form: +# +# Each row of data contains a location number (X), a second +# location number (Y), and a list of motion numbers (see section 4). +# each motion represents a verb which will go to Y if currently at X. +# Y, in turn, is interpreted as follows. Let M=Y/1000, N=Y mod 1000. +# If N<=300 it is the location to go to. +# If 300500 message N-500 from section 6 is printed, +# and he stays wherever he is. +# Meanwhile, M specifies the conditions on the motion. +# If M=0 it's unconditional. +# If 0 +#include + +#define SILENT -1 /* no sound */ + +/* Symbols for cond bits */ +#define COND_LIT 0 /* Light */ +#define COND_OILY 1 /* If bit 2 is on: on for oil, off for water */ +#define COND_FLUID 2 /* Liquid asset, see bit 1 */ +#define COND_NOARRR 3 /* Pirate doesn't go here unless following */ +#define COND_NOBACK 4 /* Cannot use "back" to move away */ +#define COND_ABOVE 5 +#define COND_DEEP 6 /* Deep - e.g where dwarves are active */ +#define COND_FOREST 7 /* In the forest */ +#define COND_FORCED 8 /* Only one way in or out of here */ +/* Bits past 10 indicate areas of interest to "hint" routines */ +#define COND_HBASE 10 /* Base for location hint bits */ +#define COND_HCAVE 11 /* Trying to get into cave */ +#define COND_HBIRD 12 /* Trying to catch bird */ +#define COND_HSNAKE 13 /* Trying to deal with snake */ +#define COND_HMAZE 14 /* Lost in maze */ +#define COND_HDARK 15 /* Pondering dark room */ +#define COND_HWITT 16 /* At Witt's End */ +#define COND_HCLIFF 17 /* Cliff with urn */ +#define COND_HWOODS 18 /* Lost in forest */ +#define COND_HOGRE 19 /* Trying to deal with ogre */ +#define COND_HJADE 20 /* Found all treasures except jade */ typedef struct {{ const char* inventory; + int plac, fixd; + bool is_treasure; const char** longs; -}} object_description_t; + const char** sounds; + const char** texts; +}} object_t; typedef struct {{ const char* small; @@ -26,6 +100,8 @@ typedef struct {{ typedef struct {{ descriptions_t description; + const long sound; + const bool loud; }} location_t; typedef struct {{ @@ -52,19 +128,54 @@ typedef struct {{ const char* hint; }} hint_t; -extern location_t locations[]; -extern object_description_t object_descriptions[]; +typedef struct {{ + const char** words; +}} motion_t; + +typedef struct {{ + const char** words; + const long message; +}} action_t; + +typedef struct {{ + const long motion; + const long dest; + const bool stop; +}} travelop_t; + +/* Abstract out the encoding of words in the travel array. Gives us + * some hope of getting to a less cryptic representation than we + * inherited from FORTRAN, someday. To understand these, read the + * encoding description for travel. + */ +#define T_DESTINATION(entry) MOD((entry).dest, 1000) +#define T_NODWARVES(entry) ((entry).dest / 1000 == 100) +#define T_HIGH(entry) ((entry).dest) +#define T_TERMINATE(entry) ((entry).motion == 1) +#define L_SPEAK(loc) ((loc) - 500) + +extern const location_t locations[]; +extern const object_t objects[]; extern const char* arbitrary_messages[]; extern const class_t classes[]; -extern turn_threshold_t turn_thresholds[]; -extern obituary_t obituaries[]; -extern hint_t hints[]; -extern const long conditions[]; - -extern const size_t CLSSES; -extern const int maximum_deaths; -extern const int turn_threshold_count; -#define HINT_COUNT {} +extern const turn_threshold_t turn_thresholds[]; +extern const obituary_t obituaries[]; +extern const hint_t hints[]; +extern long conditions[]; +extern const motion_t motions[]; +extern const action_t actions[]; +extern const travelop_t travel[]; +extern const long tkey[]; + +#define NLOCATIONS {} +#define NOBJECTS {} +#define NHINTS {} +#define NCLASSES {} +#define NDEATHS {} +#define NTHRESHOLDS {} +#define NACTIONS {} +#define NTRAVEL {} +#define NKEYS {} enum arbitrary_messages_refs {{ {} @@ -74,10 +185,21 @@ enum locations_refs {{ {} }}; -enum object_descriptions_refs {{ +enum object_refs {{ {} }}; +enum motion_refs {{ +{} +}}; + +enum action_refs {{ +{} +}}; + +/* State definitions */ + +{} #endif /* end NEWDB_H */ """ @@ -94,33 +216,43 @@ const class_t classes[] = {{ {} }}; -turn_threshold_t turn_thresholds[] = {{ +const turn_threshold_t turn_thresholds[] = {{ {} }}; -location_t locations[] = {{ +const location_t locations[] = {{ {} }}; -object_description_t object_descriptions[] = {{ +const object_t objects[] = {{ {} }}; -obituary_t obituaries[] = {{ +const obituary_t obituaries[] = {{ {} }}; -hint_t hints[] = {{ +const hint_t hints[] = {{ {} }}; -const long conditions[] = {{ +long conditions[] = {{ {} }}; -const size_t CLSSES = {}; -const int maximum_deaths = {}; -const int turn_threshold_count = {}; +const motion_t motions[] = {{ +{} +}}; + +const action_t actions[] = {{ +{} +}}; + +{} + +const travelop_t travel[] = {{ +{} +}}; /* end */ """ @@ -184,40 +316,91 @@ def get_turn_thresholds(trn): return trn_str def get_locations(loc): - template = """ {{ + template = """ {{ // {} .description = {{ .small = {}, .big = {}, }}, + .sound = {}, + .loud = {}, }}, """ 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"]) - loc_str += template.format(short_d, long_d) + sound = item[1].get("sound", "SILENT") + loud = "true" if item[1].get("loud") else "false" + 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* []) {{ +{} + }}, + .sounds = (const char* []) {{ +{} + }}, + .texts = (const char* []) {{ {} }}, }}, """ 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: - for l_msg in item[1]["longs"]: + labels = [] + for l_msg in attr["longs"]: + if not isinstance(l_msg, str): + labels.append(l_msg) + l_msg = l_msg[1] longs_str += " " * 12 + make_c_string(l_msg) + ",\n" longs_str = longs_str[:-1] # trim trailing newline - obj_str += template.format(i_msg, longs_str) + if labels: + global statedefines + statedefines += "/* States for %s */\n" % item[0] + for (i, (label, message)) in enumerate(labels): + if len(message) >= 45: + message = message[:45] + "..." + statedefines += "#define %s\t%d /* %s */\n" % (label, i, message) + statedefines += "\n" + sounds_str = "" + if attr.get("sounds") == None: + sounds_str = " " * 12 + "NULL," + else: + 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 attr.get("texts") == None: + texts_str = " " * 12 + "NULL," + else: + for l_msg in attr["texts"]: + texts_str += " " * 12 + make_c_string(l_msg) + ",\n" + texts_str = texts_str[:-1] # trim trailing newline + 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 @@ -251,8 +434,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 @@ -277,16 +460,209 @@ 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_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 + +def bigdump(arr): + out = "" + for (i, entry) in enumerate(arr): + if i % 10 == 0: + if out and out[-1] == ' ': + out = out[:-1] + out += "\n " + out += str(arr[i]) + ", " + out = out[:-2] + "\n" + return out + +def buildtravel(locs, objs, voc): + ltravel = [] + 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: + obj = objnames.index(cond[1]) + if type(cond[2]) == int: + state = cond[2] + else: + for (i, stateclause) in enumerate(objs[obj][1]["longs"]): + if type(stateclause) == list: + if stateclause[0] == cond[2]: + state = i + break + else: + sys.stderr.write("dungeon: unmatched state symbol %s in not clause of %s\n" % (cond[2], name)) + sys.exit(0); + return 300 + obj + 100 * state + 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 + + 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)) + + # At this point the ltravel data is in the Section 3 + # representation from the FORTRAN version. Next we perform the + # same mapping into the runtime format. This was the C translation + # of the FORTRAN code: + # long loc; + # while ((loc = GETNUM(database)) != -1) { + # long newloc = GETNUM(NULL); + # long L; + # if (TKEY[loc] == 0) { + # TKEY[loc] = TRVS; + # } else { + # TRAVEL[TRVS - 1] = -TRAVEL[TRVS - 1]; + # } + # while ((L = GETNUM(NULL)) != 0) { + # TRAVEL[TRVS] = newloc * 1000 + L; + # TRVS = TRVS + 1; + # if (TRVS == TRVSIZ) + # BUG(TOO_MANY_TRAVEL_OPTIONS); + # } + # TRAVEL[TRVS - 1] = -TRAVEL[TRVS - 1]; + # } + # + # In order to de-crypticize the runtime code, we're going to break these + # magic numbers up into a struct. + travel = [[0, 0, False]] + tkey = [0] + oldloc = 0 + while ltravel: + rule = list(ltravel.pop(0)) + loc = rule.pop(0) + newloc = rule.pop(0) + if loc != oldloc: + tkey.append(len(travel)) + oldloc = loc + elif travel: + travel[-1][2] = not travel[-1][2] + while rule: + travel.append([rule.pop(0), newloc, False]) + travel[-1][2] = True + return (travel, tkey) + +def get_travel(travel): + template = """ {{ + .motion = {}, + .dest = {}, + .stop = {}, + }}, +""" + out = "" + for entry in travel: + out += template.format(entry[0], entry[1], entry[2]).lower() + out = out[:-1] # trim trailing newline + return out + if __name__ == "__main__": with open(yaml_name, "r") as f: db = yaml.load(f) - h = h_template.format( - len(db["hints"]), - get_refs(db["arbitrary_messages"]), - get_refs(db["locations"]), - get_refs(db["object_descriptions"]), - ) + 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, tkey) = buildtravel(db["locations"], + db["objects"], + db["vocabulary"]) c = c_template.format( h_name, @@ -294,13 +670,32 @@ if __name__ == "__main__": 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"]), - len(db["classes"]), + get_motions(db["motions"]), + get_actions(db["actions"]), + "const long tkey[] = {%s};" % bigdump(tkey), + get_travel(travel), + ) + + h = h_template.format( + len(db["locations"])-1, + len(db["objects"])-1, + len(db["hints"]), + len(db["classes"])-1, len(db["obituaries"]), len(db["turn_thresholds"]), + len(db["actions"]), + len(travel), + len(tkey), + get_refs(db["arbitrary_messages"]), + get_refs(db["locations"]), + get_refs(db["objects"]), + get_refs(db["motions"]), + get_refs(db["actions"]), + statedefines, ) with open(h_name, "w") as hf: