+def get_hints(hnt, arb):
+ template = """ {{
+ .number = {},
+ .penalty = {},
+ .turns = {},
+ .question = {},
+ .hint = {},
+ }},
+"""
+ hnt_str = ""
+ md = dict(arb)
+ for member in hnt:
+ item = member["hint"]
+ number = item["number"]
+ penalty = item["penalty"]
+ turns = item["turns"]
+ 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
+
+def get_condbits(locations):
+ cnd_str = ""
+ for (name, loc) in locations:
+ conditions = loc["conditions"]
+ hints = loc.get("hints") or []
+ flaglist = []
+ for flag in conditions:
+ if conditions[flag]:
+ flaglist.append(flag)
+ line = "|".join([("(1<<COND_%s)" % f) for f in flaglist])
+ trail = "|".join([("(1<<COND_H%s)" % f['name']) for f in hints])
+ if trail:
+ line += "|" + trail
+ if line.startswith("|"):
+ line = line[1:]
+ if not line:
+ line = "0"
+ 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_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"])-1,
+ len(db["objects"])-1,
+ len(db["hints"]),
+ 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["objects"]),
+ get_refs(db["motions"]),
+ get_refs(db["actions"]),
+ statedefines,
+ )
+
+ with open(h_name, "w") as hf:
+ hf.write(h)
+
+ with open(c_name, "w") as cf:
+ cf.write(c)
+
+# end