X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=roguelike-server;h=305c8aa7dbdbbbaf93af77fcf8ea1a09504c49e2;hb=e3cab0b80bfbae934a2675dc5a7430a7a47c958f;hp=b2d53e35337b87826308de324d859db1effc3018;hpb=cc55ff5aa21936644da7ac51dafed063a9533474;p=plomrogue diff --git a/roguelike-server b/roguelike-server index b2d53e3..305c8aa 100755 --- a/roguelike-server +++ b/roguelike-server @@ -110,7 +110,8 @@ def obey(command, prefix, replay=False, do_record=False): is called (and io_db["record_chunk"] written) if 15 seconds have passed since the last time it was called. The prefix string is inserted into the server's input message between its beginning 'input ' and ':'. All activity - is preceded by a server_test() call. + is preceded by a server_test() call. Commands that start with a lowercase + letter are ignored when world_db["WORLD_ACTIVE"] is False/0. """ server_test() if io_db["verbose"]: @@ -124,6 +125,8 @@ def obey(command, prefix, replay=False, do_record=False): and len(tokens) == commands_db[tokens[0]][0] + 1: if commands_db[tokens[0]][1]: commands_db[tokens[0]][2](*tokens[1:]) + elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]: + print("Ignoring lowercase-starting commands when world inactive.") elif replay: print("Due to replay mode, reading command as 'go on in record'.") line = io_db["file_record"].readline() @@ -173,10 +176,11 @@ def save_world(): return '"' + string.replace('"', '\u005C"') + '"' def mapsetter(key): - def helper(id): + def helper(id=None): string = "" - if world_db["Things"][id][key]: - map = world_db["Things"][id][key] + if key == "MAP" or world_db["Things"][id][key]: + map = world_db["MAP"] if key == "MAP" \ + else world_db["Things"][id][key] length = world_db["MAP_LENGTH"] for i in range(length): line = map[i * length:(i * length) + length].decode() @@ -207,10 +211,11 @@ def save_world(): string = "" for key in world_db: - if dict != type(world_db[key]) and key != "MAP" and \ - key != "WORLD_ACTIVE" and key != "SEED_MAP": + if (dict != type(world_db[key]) + and key != "altar" # # + and key != "MAP" and key != "WORLD_ACTIVE"): string = string + key + " " + str(world_db[key]) + "\n" - string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n" + string = string + mapsetter("MAP")() string = string + helper("ThingActions", "TA_ID") string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False}) for id in world_db["ThingTypes"]: @@ -306,7 +311,7 @@ def try_worldstate_update(): def draw_visible_Things(map, run): for id in world_db["Things"]: type = world_db["Things"][id]["T_TYPE"] - consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"] + consumable = world_db["ThingTypes"][type]["TT_TOOL"] == "food" alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"] if (0 == run and not consumable and not alive) \ or (1 == run and consumable and not alive) \ @@ -332,7 +337,7 @@ def try_worldstate_update(): type_id = world_db["Things"][id]["T_TYPE"] name = world_db["ThingTypes"][type_id]["TT_NAME"] inventory = inventory + name + "\n" - # # 7DRL additions: GOD_MOOD, GOD_FAVOR + # 7DRL additions: GOD_MOOD, GOD_FAVOR string = str(world_db["TURN"]) + "\n" + \ str(world_db["GOD_MOOD"]) + "\n" + \ str(world_db["GOD_FAVOR"]) + "\n" + \ @@ -353,7 +358,7 @@ def try_worldstate_update(): mem = world_db["Things"][0]["T_MEMMAP"][:] for i in range(2): for mt in world_db["Things"][0]["T_MEMTHING"]: - consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"] + consumable = world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food" if (i == 0 and not consumable) or (i == 1 and consumable): c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"] mem[(mt[1] * length) + mt[2]] = ord(c) @@ -414,7 +419,7 @@ def play_game(): obey(read_command(), "in file", do_record=True) -def remake_map(): +def make_map(): """(Re-)make island map. Let "~" represent water, "." land, "X" trees: Build island shape randomly, @@ -423,6 +428,8 @@ def remake_map(): to land. The cycle ends when a land cell is due to be created at the map's border. Then put some trees on the map (TODO: more precise algorithm desc). """ + # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar. + def is_neighbor(coordinates, type): y = coordinates[0] x = coordinates[1] @@ -445,8 +452,7 @@ def remake_map(): and type == chr(world_db["MAP"][pos + length - (not ind)])): return True return False - store_seed = rand.seed - rand.seed = world_db["SEED_MAP"] + world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2)) length = world_db["MAP_LENGTH"] add_half_width = (not (length % 2)) * int(length / 2) @@ -470,12 +476,34 @@ def remake_map(): and ((not single_allowed) or is_neighbor((y, x), "X")): world_db["MAP"][pos] = ord("X") i_trees += 1 - rand.seed = store_seed # This all-too-precise replica of the original C code misses iter_limit(). + n_colons = int((length ** 2) / 16) # # + i_colons = 0 # # + while (i_colons <= n_colons): # # + single_allowed = rand.next() % 256 # # + y = rand.next() % length # # + x = rand.next() % length # # + pos = (y * length) + x # # + if ("." == chr(world_db["MAP"][pos]) # # + and ((not single_allowed) or is_neighbor((y, x), ":"))): # # + world_db["MAP"][pos] = ord(":") # # + i_colons += 1 # # + altar_placed = False # # + while not altar_placed: # # + y = rand.next() % length # # + x = rand.next() % length # # + pos = (y * length) + x # # + if (("." == chr(world_db["MAP"][pos] # # + or ":" == chr(world_db["MAP"][pos])) + and not is_neighbor((y, x), 'X'))): # # + world_db["MAP"][pos] = ord("_") # # + world_db["altar"] = (y, x) # # + altar_placed = True # # def update_map_memory(t, age_map=True): """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP.""" + def age_some_memdepthmap_on_nonfov_cells(): # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so: # ord_v = ord("v") @@ -491,6 +519,7 @@ def update_map_memory(t, age_map=True): memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"]) fovmap = c_pointer_to_bytearray(t["fovmap"]) libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap) + if not t["T_MEMMAP"]: t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2)) if not t["T_MEMDEPTHMAP"]: @@ -577,6 +606,23 @@ def build_fov_map(t): raise RuntimeError("Malloc error in build_fov_Map().") +def log_help(): + """Send quick usage info to log.""" + strong_write(io_db["file_out"], "LOG " + + "Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.\n") + strong_write(io_db["file_out"], "LOG " + + "Use 'p' to pick up objects, and 'D' to drop them.\n") + strong_write(io_db["file_out"], "LOG " + + "Some objects can be used (such as: eaten) by 'u' if " + + "they are in your inventory. " + + "Use 'UP'/'DOWN' to navigate the inventory.\n") + strong_write(io_db["file_out"], "LOG " + + "Use 'l' to toggle 'look' mode (move an exploration cursor " + + "instead of the player over the map).\n") + strong_write(io_db["file_out"], "LOG See README file for more details.\n") + strong_write(io_db["file_out"], "LOG \n") + + def decrement_lifepoints(t): """Decrement t's lifepoints by 1, and if to zero, corpse it. @@ -584,8 +630,8 @@ def decrement_lifepoints(t): still display memory data. On non-player things, erase fovmap and memory. Dying actors drop all their things. """ - # # 7DRL: also decrements God's mood; deaths heavily so - # # 7DRL: return 1 if death, else 0 + # 7DRL: Also decrements God's mood; deaths heavily so. + # 7DRL: Return 1 if death, else 0. t["T_LIFEPOINTS"] -= 1 world_db["GOD_MOOD"] -= 1 # # if 0 == t["T_LIFEPOINTS"]: @@ -600,6 +646,8 @@ def decrement_lifepoints(t): if world_db["Things"][0] == t: t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2)) strong_write(io_db["file_out"], "LOG You die.\n") + strong_write(io_db["file_out"], + "LOG See README on how to start over.\n") else: t["fovmap"] = False t["T_MEMMAP"] = False @@ -638,6 +686,46 @@ def mv_yx_in_dir_legal(dir, y, x): return (test, libpr.result_y(), libpr.result_x()) +def enter_altar(): # # + """What happens when the player enters the altar.""" + if world_db["FAVOR_STAGE"] > 9000: + strong_write(io_db["file_out"], + "LOG You step on a soul-less slab of stone.\n") + return + strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n") + if world_db["FAVOR_STAGE"] == 0: + world_db["FAVOR_STAGE"] = 1 + strong_write(io_db["file_out"], "LOG The Island God speaks to you: " + + "\"I don't trust you. You intrude on the island's " + + "affairs. I think you're a nuisance at best, and a " + + "danger to my children at worst. I will give you a " + + "chance to lighten my mood, however: For a while now, " + + "I've been trying to spread the plant " + + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"] + + " (\"" + + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"] + + "\"). I have not been very successful so far. Maybe " + + "you can make yourself useful there. I will count " + + "each further " + + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"] + + " that grows to your favor.\n") + elif world_db["GOD_FAVOR"] > 9000: + world_db["FAVOR_STAGE"] = 9001 + strong_write(io_db["file_out"], "LOG The Island God speaks to you: " + + "\"You have proven yourself worthy of my respect. " + + "You were a good citizen to the island, and sometimes " + + "a better steward to its inhabitants than me. The " + + "island shall miss you when you leave. But you have " + + "earned the right to do so. Take this " + + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"] + + " and USE it when you please. It will take you to " + + "where you came from. (But do feel free to stay here " + + "as long as you like.)\"\n") + id = id_setter(-1, "Things") + world_db["Things"][id] = new_Thing(world_db["SLIPPERS"], + world_db["altar"]) + + def actor_wait(t): """Make t do nothing (but loudly, if player avatar).""" if t == world_db["Things"][0]: @@ -646,13 +734,14 @@ def actor_wait(t): def actor_move(t): """If passable, move/collide(=attack) thing into T_ARGUMENT's direction.""" - # # 7DRL: Player wounding (worse: killing) others will lower God's favor. + # 7DRL: Player wounding (worse: killing) others will lower God's favor. + # 7DRL: Player entering the altar triggers enter_altar(). + # 7DRL: Player with axe chops down trees. passable = False move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]), t["T_POSY"], t["T_POSX"]) if 1 == move_result[0]: pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2] - passable = "." == chr(world_db["MAP"][pos]) hitted = [id for id in world_db["Things"] if world_db["Things"][id] != t if world_db["Things"][id]["T_LIFEPOINTS"] @@ -674,6 +763,31 @@ def actor_move(t): if test and t == world_db["Things"][0]: # # add_gods_favor(-test) # # return + if ord("X") == world_db["MAP"][pos]: # # + carries_axe = False # # + for id in t["T_CARRIES"]: # # + type = world_db["Things"][id]["T_TYPE"] # # + if world_db["ThingTypes"][type]["TT_TOOL"] == "axe": # # + carries_axe = True # # + if carries_axe: # # + axe_name = world_db["ThingTypes"][type]["TT_NAME"] # # + if t == world_db["Things"][0]: # # + strong_write(io_db["file_out"], "LOG With your " # # + + axe_name # # + + ", you chop!\n") # # + add_gods_favor(-1) # # + chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"] + if chop_power > 0 and 0 == int(rand.next() / chop_power): # # + if t == world_db["Things"][0]: # # + strong_write(io_db["file_out"], # # + "LOG You chop the tree down.\n") # # + add_gods_favor(-10) # # + world_db["MAP"][pos] = ord(".") # # + build_fov_map(t) # # + return # # + passable = ("." == chr(world_db["MAP"][pos]) or + ":" == chr(world_db["MAP"][pos]) or # # + "_" == chr(world_db["MAP"][pos])) # # dir = [dir for dir in directions_db if directions_db[dir] == chr(t["T_ARGUMENT"])][0] if passable: @@ -685,6 +799,9 @@ def actor_move(t): build_fov_map(t) if t == world_db["Things"][0]: strong_write(io_db["file_out"], "LOG You move " + dir + ".\n") + if (move_result[1] == world_db["altar"][0] and # # + move_result[2] == world_db["altar"][1]): # # + enter_altar() # # elif t == world_db["Things"][0]: strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n") @@ -704,14 +821,16 @@ def actor_pick_up(t): nutritious = 0 for id in ids: type = world_db["Things"][id]["T_TYPE"] - if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious: - nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"] + if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \ + and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > nutritious: + nutritious = world_db["ThingTypes"][type]["TT_TOOLPOWER"] highest_id = id world_db["Things"][highest_id]["carried"] = True - if (t != world_db["Things"][0] and # # - world_db["Things"][highest_id]["T_PLAYERDROP"]): # # - x = world_db["Things"][highest_id]["T_TYPE"] - score = world_db["ThingTypes"][x]["TT_CONSUMABLE"] / 32 # # + type = world_db["Things"][highest_id]["T_TYPE"] # # + if (t != world_db["Things"][0] # # + and world_db["Things"][highest_id]["T_PLAYERDROP"] # # + and world_db["ThingTypes"][type]["TT_TOOL"] == "food"): # # + score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32 # # add_gods_favor(score) # # world_db["Things"][highest_id]["T_PLAYERDROP"] = 0 # # t["T_CARRIES"].append(highest_id) @@ -743,13 +862,29 @@ def actor_drop(t): def actor_use(t): """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory.""" # TODO: Handle case where T_ARGUMENT matches nothing. + # 7DLR: Handle SLIPPERS-type Thing use. if len(t["T_CARRIES"]): id = t["T_CARRIES"][t["T_ARGUMENT"]] type = world_db["Things"][id]["T_TYPE"] - if world_db["ThingTypes"][type]["TT_CONSUMABLE"]: + if type == world_db["SLIPPERS"]: # # + if t == world_db["Things"][0]: # # + strong_write(io_db["file_out"], "LOG You use the " # # + + world_db["ThingTypes"][type]["TT_NAME"] # # + + ". It glows in wondrous colors, and emits " # # + + "a sound as if from a dying cat. The " # # + + "Island God laughs.\n") # # + t["T_LIFEPOINTS"] = 1 # # + decrement_lifepoints(t) # # + elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe" # # + and t == world_db["Things"][0]): # # + strong_write(io_db["file_out"], # # + "LOG To use this item for chopping, move " # # + "towards a tree while carrying it in " # # + "your inventory.\n") # # + elif world_db["ThingTypes"][type]["TT_TOOL"] == "food": t["T_CARRIES"].remove(id) del world_db["Things"][id] - t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"] + t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"] if t == world_db["Things"][0]: strong_write(io_db["file_out"], "LOG You consume this object.\n") @@ -765,18 +900,20 @@ def thingproliferation(t, prol_map): """To chance of 1/TT_PROLIFERATE,create t offspring in open neighbor cell. Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be - marked '.' in prol_map. If there are several map cell candidates, one is + marked "." in prol_map. If there are several map cell candidates, one is selected randomly. """ - # # 7DRL: success increments God's mood + # 7DRL: success increments God's mood + # 7DRL: Things proliferate only on ":" ground. prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"] if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)): candidates = [] for dir in [directions_db[key] for key in directions_db]: mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"]) - if mv_result[0] and ord('.') == prol_map[mv_result[1] - * world_db["MAP_LENGTH"] - + mv_result[2]]: + if mv_result[0] and ord(":") == prol_map[mv_result[1] # # + # if mv_result[0] and ord(".") == prol_map[mv_result[1] + * world_db["MAP_LENGTH"] + + mv_result[2]]: candidates.append((mv_result[1], mv_result[2])) if len(candidates): i = rand.next() % len(candidates) @@ -784,6 +921,9 @@ def thingproliferation(t, prol_map): newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1])) world_db["Things"][id] = newT world_db["GOD_MOOD"] += 1 # # + if (world_db["FAVOR_STAGE"] > 0 # # + and t["T_TYPE"] == world_db["PLANT_0"]): + world_db["GOD_FAVOR"] += 5 def try_healing(t): @@ -791,7 +931,7 @@ def try_healing(t): On success, decrease satiation score by 32. """ - # # 7DRL: Successful heals increment God's mood. + # 7DRL: Successful heals increment God's mood. if t["T_SATIATION"] > 0 \ and t["T_LIFEPOINTS"] < \ world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \ @@ -879,7 +1019,7 @@ def get_dir_to_target(t, filter): for mt in t["T_MEMTHING"]: if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"]) + mt[2]]) \ - and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]: + and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food": return True return False @@ -931,7 +1071,7 @@ def get_dir_to_target(t, filter): if ord_blank != t["T_MEMMAP"][mt[1] * world_db["MAP_LENGTH"] + mt[2]] - if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]: + if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]: set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0) elif "s" == filter: zero_score_map_where_char_on_memdepthmap(mem_depth_c[0]) @@ -1017,26 +1157,27 @@ def get_dir_to_target(t, filter): return dir_to_target -def standing_on_consumable(t): +def standing_on_food(t): """Return True/False whether t is standing on a consumable.""" for id in [id for id in world_db["Things"] if world_db["Things"][id] != t if world_db["Things"][id]["T_POSY"] == t["T_POSY"] if world_db["Things"][id]["T_POSX"] == t["T_POSX"] if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]] - ["TT_CONSUMABLE"]]: + ["TT_TOOL"] == "food"]: return True return False def get_inventory_slot_to_consume(t): """Return slot Id of strongest consumable in t's inventory, else -1.""" - cmp_consumability = 0 + cmp_food = 0 selection = -1 i = 0 for id in t["T_CARRIES"]: type = world_db["Things"][id]["T_TYPE"] - if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability: - cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"] + if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \ + and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > cmp_food: + cmp_food = world_db["ThingTypes"][type]["TT_TOOLPOWER"] selection = i i += 1 return selection @@ -1053,7 +1194,7 @@ def ai(t): none, they will explore parts of the map unseen since ever or for at least one turn; if there is nothing to explore, they will simply wait. """ - # # 7DRL add: Don't pick up or search things when inventory is full. + # 7DRL add: Don't pick up or search things when inventory is full. t["T_COMMAND"] = [id for id in world_db["ThingActions"] if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0] if not get_dir_to_target(t, "f"): @@ -1063,7 +1204,7 @@ def ai(t): if world_db["ThingActions"][id]["TA_NAME"] == "use"][0] t["T_ARGUMENT"] = sel - elif standing_on_consumable(t) \ + elif standing_on_food(t) \ and (len(t["T_CARRIES"]) < # # world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # # t["T_COMMAND"] = [id for id in world_db["ThingActions"] @@ -1101,15 +1242,16 @@ def turn_over(): break ai(Thing) try_healing(Thing) - Thing["T_PROGRESS"] += 1 - taid = [a for a in world_db["ThingActions"] - if a == Thing["T_COMMAND"]][0] - ThingAction = world_db["ThingActions"][taid] - if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]: - eval("actor_" + ThingAction["TA_NAME"])(Thing) - Thing["T_COMMAND"] = 0 - Thing["T_PROGRESS"] = 0 hunger(Thing) + if Thing["T_LIFEPOINTS"]: + Thing["T_PROGRESS"] += 1 + taid = [a for a in world_db["ThingActions"] + if a == Thing["T_COMMAND"]][0] + ThingAction = world_db["ThingActions"][taid] + if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]: + eval("actor_" + ThingAction["TA_NAME"])(Thing) + Thing["T_COMMAND"] = 0 + Thing["T_PROGRESS"] = 0 thingproliferation(Thing, proliferable_map) if whilebreaker: break @@ -1253,32 +1395,31 @@ def command_seedrandomness(seed_string): rand.seed = val -def command_seedmap(seed_string): - """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map.""" - setter(None, "SEED_MAP", 0, 4294967295)(seed_string) - remake_map() - - def command_makeworld(seed_string): """(Re-)build game world, i.e. map, things, to a new turn 1 from seed. - Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a - "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of - TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map() - and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things + Seed rand with seed. Do more only with a "wait" ThingAction and + world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then, + world_db["Things"] emptied, call make_map() and set + world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each other. Init player's memory map. Write "NEW_WORLD" line to out file. + Call log_help(). """ - def free_pos(): + # def free_pos(plant=False): + def free_pos(plant=False): # # i = 0 while 1: err = "Space to put thing on too hard to find. Map too small?" while 1: y = rand.next() % world_db["MAP_LENGTH"] x = rand.next() % world_db["MAP_LENGTH"] - if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]): + pos = y * world_db["MAP_LENGTH"] + x; + if (not plant # # + and "." == chr(world_db["MAP"][pos])) \ + or ":" == chr(world_db["MAP"][pos]): # # break i += 1 if i == 65535: @@ -1296,7 +1437,6 @@ def command_makeworld(seed_string): if None == val: return rand.seed = val - world_db["SEED_MAP"] = val player_will_be_generated = False playertype = world_db["PLAYER_TYPE"] for ThingType in world_db["ThingTypes"]: @@ -1305,31 +1445,40 @@ def command_makeworld(seed_string): player_will_be_generated = True break if not player_will_be_generated: - print("Ignoring beyond SEED_MAP: " + - "No player type with start number >0 defined.") + print("Ignoring: No player type with start number >0 defined.") return wait_action = False for ThingAction in world_db["ThingActions"]: if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]: wait_action = True if not wait_action: - print("Ignoring beyond SEED_MAP: " + - "No thing action with name 'wait' defined.") + print("Ignoring: No thing action with name 'wait' defined.") return + if not world_db["SLIPPERS"] in world_db["ThingTypes"]: # # + print("Ignoring: No valid SLIPPERS set.") # # + return # # + if not world_db["PLANT_0"] in world_db["ThingTypes"]: # # + print("Ignoring: No valid PLANT_0 set.") # # + return # # world_db["Things"] = {} - remake_map() + make_map() world_db["WORLD_ACTIVE"] = 1 world_db["TURN"] = 1 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]): id = id_setter(-1, "Things") world_db["Things"][id] = new_Thing(playertype, free_pos()) + if not world_db["Things"][0]["fovmap"]: + empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2) + world_db["Things"][0]["fovmap"] = empty_fovmap update_map_memory(world_db["Things"][0]) for type in world_db["ThingTypes"]: for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]): if type != playertype: id = id_setter(-1, "Things") - world_db["Things"][id] = new_Thing(type, free_pos()) + plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # # + world_db["Things"][id] = new_Thing(type, free_pos(plantness)) strong_write(io_db["file_out"], "NEW_WORLD\n") + log_help() def command_maplength(maplength_string): @@ -1337,6 +1486,7 @@ def command_maplength(maplength_string): val = integer_test(maplength_string, 1, 256) if None != val: world_db["MAP_LENGTH"] = val + world_db["MAP"] = False set_world_inactive() world_db["Things"] = {} libpr.set_maplength(val) @@ -1346,12 +1496,14 @@ def command_worldactive(worldactive_string): """Toggle world_db["WORLD_ACTIVE"] if possible. An active world can always be set inactive. An inactive world can only be - set active with a "wait" ThingAction, and a player Thing (of ID 0). On - activation, rebuild all Things' FOVs, and the player's map memory. + set active with a "wait" ThingAction, and a player Thing (of ID 0), and a + map. On activation, rebuild all Things' FOVs, and the player's map memory. + Also call log_help(). """ - # In original version, map existence was also tested (unnecessarily?). + # 7DRL: altar must be on map, and (valid) SLIPPERS and PLANT_0must be set + # for world activation. val = integer_test(worldactive_string, 0, 1) - if val: + if None != val: if 0 != world_db["WORLD_ACTIVE"]: if 0 == val: set_world_inactive() @@ -1368,13 +1520,52 @@ def command_worldactive(worldactive_string): if 0 == Thing: player_exists = True break - if wait_exists and player_exists: + valid_slippers = world_db["SLIPPERS"] in world_db["ThingTypes"] # # + valid_plant0 = world_db["PLANT_0"] in world_db["ThingTypes"] # # + altar_found = False # # + if world_db["MAP"]: # # + pos = world_db["MAP"].find(b'_') # # + if pos > 0: # # + y = int(pos / world_db["MAP_LENGTH"]) # # + x = pos % world_db["MAP_LENGTH"] # # + world_db["altar"] = (y, x) # # + altar_found = True # # + if wait_exists and player_exists and world_db["MAP"] \ + and altar_found and valid_slippers and valid_plant0: # # for id in world_db["Things"]: if world_db["Things"][id]["T_LIFEPOINTS"]: build_fov_map(world_db["Things"][id]) if 0 == id: update_map_memory(world_db["Things"][id], False) + if not world_db["Things"][0]["T_LIFEPOINTS"]: + empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2) + world_db["Things"][0]["fovmap"] = empty_fovmap world_db["WORLD_ACTIVE"] = 1 + log_help() + else: + print("Ignoring: Not all conditions for world activation met.") + + +def command_slippers(str_int): # # + """Set SLIPPERS, but deactivate world if not in ThingTypes.""" + val = integer_test(str_int, 0) + if None != val: + world_db["SLIPPERS"] = val + if world_db["WORLD_ACTIVE"] and \ + world_db["SLIPPERS"] not in world_db["ThingTypes"]: + world_db["WORLD_ACTIVE"] = 0 + print("SLIPPERS matches no known ThingTypes, deactivating world.") + + +def command_plant0(str_int): # # + """Set PLANT_0, but deactivate world if not in ThingTypes.""" + val = integer_test(str_int, 0) + if None != val: + world_db["PLANT_0"] = val + if world_db["WORLD_ACTIVE"] and \ + world_db["PLANT_0"] not in world_db["ThingTypes"]: + world_db["WORLD_ACTIVE"] = 0 + print("PLANT_0 matches no known ThingTypes, deactivating world.") def test_for_id_maker(object, category): @@ -1470,12 +1661,12 @@ def command_tmemthing(str_t, str_y, str_x): def setter_map(maptype): - """Set selected Thing's map of maptype's int(str_int)-th line to mapline. + """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline. - If Thing has no map of maptype yet, initialize it with ' ' bytes first. + If no map of maptype exists yet, initialize it with ' ' bytes first. """ - @test_Thing_id - def helper(str_int, mapline): + + def valid_map_line(str_int, mapline): val = integer_test(str_int, 0, 255) if None != val: if val >= world_db["MAP_LENGTH"]: @@ -1483,15 +1674,35 @@ def setter_map(maptype): elif len(mapline) != world_db["MAP_LENGTH"]: print("Map line length is unequal map width.") else: - length = world_db["MAP_LENGTH"] - map = None - if not world_db["Things"][command_tid.id][maptype]: - map = bytearray(b' ' * (length ** 2)) - else: - map = world_db["Things"][command_tid.id][maptype] - map[val * length:(val * length) + length] = mapline.encode() + return val + return None + + def nonThingMap_helper(str_int, mapline): + val = valid_map_line(str_int, mapline) + if None != val: + length = world_db["MAP_LENGTH"] + if not world_db["MAP"]: + map = bytearray(b' ' * (length ** 2)) + else: + map = world_db["MAP"] + map[val * length:(val * length) + length] = mapline.encode() + if not world_db["MAP"]: + world_db["MAP"] = map + + @test_Thing_id + def ThingMap_helper(str_int, mapline): + val = valid_map_line(str_int, mapline) + if None != val: + length = world_db["MAP_LENGTH"] + if not world_db["Things"][command_tid.id][maptype]: + map = bytearray(b' ' * (length ** 2)) + else: + map = world_db["Things"][command_tid.id][maptype] + map[val * length:(val * length) + length] = mapline.encode() + if not world_db["Things"][command_tid.id][maptype]: world_db["Things"][command_tid.id][maptype] = map - return helper + + return nonThingMap_helper if maptype == "MAP" else ThingMap_helper def setter_tpos(axis): @@ -1518,19 +1729,21 @@ def setter_tpos(axis): def command_ttid(id_string): """Set ID of ThingType to manipulate. ID unused? Create new one. - Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0. + Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to + "", others: 0. """ id = id_setter(id_string, "ThingTypes", command_ttid) if None != id: world_db["ThingTypes"][id] = { "TT_NAME": "(none)", - "TT_CONSUMABLE": 0, + "TT_TOOLPOWER": 0, "TT_LIFEPOINTS": 0, "TT_PROLIFERATE": 0, "TT_START_NUMBER": 0, "TT_STORAGE": 0, # # "TT_SYMBOL": "?", - "TT_CORPSE_ID": id + "TT_CORPSE_ID": id, + "TT_TOOL": "" } @@ -1543,6 +1756,12 @@ def command_ttname(name): world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name +@test_ThingType_id +def command_tttool(name): + """Set TT_TOOL of selected ThingType.""" + world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name + + @test_ThingType_id def command_ttsymbol(char): """Set TT_SYMBOL of selected ThingType. """ @@ -1620,7 +1839,6 @@ commands_db = { "PING": (0, True, command_ping), "THINGS_HERE": (2, True, command_thingshere), "MAKE_WORLD": (1, False, command_makeworld), - "SEED_MAP": (1, False, command_seedmap), "SEED_RANDOMNESS": (1, False, command_seedrandomness), "TURN": (1, False, setter(None, "TURN", 0, 65535)), "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # # @@ -1628,19 +1846,23 @@ commands_db = { "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)), "MAP_LENGTH": (1, False, command_maplength), "WORLD_ACTIVE": (1, False, command_worldactive), + "MAP": (2, False, setter_map("MAP")), + "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # # + "SLIPPERS": (1, False, command_slippers), # # + "PLANT_0": (1, False, command_plant0), # # "TA_ID": (1, False, command_taid), "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)), "TA_NAME": (1, False, command_taname), "TT_ID": (1, False, command_ttid), "TT_NAME": (1, False, command_ttname), + "TT_TOOL": (1, False, command_tttool), "TT_SYMBOL": (1, False, command_ttsymbol), "TT_CORPSE_ID": (1, False, command_ttcorpseid), - "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE", - 0, 65535)), + "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)), "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER", 0, 255)), "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE", - 0, 255)), + 0, 65535)), "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)), "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # # "T_ID": (1, False, command_tid), @@ -1664,17 +1886,21 @@ commands_db = { "use": (1, False, play_commander("use", True)), "ai": (0, False, command_ai) } +# TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS. """World state database. With sane default values. (Randomness is in rand.)""" world_db = { "TURN": 0, "MAP_LENGTH": 64, - "SEED_MAP": 0, "PLAYER_TYPE": 0, "WORLD_ACTIVE": 0, "GOD_MOOD": 0, # # "GOD_FAVOR": 0, # # + "MAP": False, + "FAVOR_STAGE": 0, # # + "SLIPPERS": 0, # # + "PLANT_0": 0, # # "ThingActions": {}, "ThingTypes": {}, "Things": {}