home · contact · privacy
TCE: Add movement sound mapping.
[plomrogue] / plugins / server / TheCrawlingEater.py
index 7f8ca0be400d1725e72177b8887b1eb6726d74be..b97328d1068f12aa3c2fb11fad5cb0467eae95cf 100644 (file)
@@ -20,14 +20,17 @@ def play_drink():
 
 
 def actor_drink(t):
-    pos = world_db["Things"][0]["pos"]
+    pos = t["pos"]
     if chr(world_db["MAP"][pos]) == "0" and \
                 world_db["wetmap"][pos] > ord("0") and t["T_KIDNEY"] < 32:
-        log("You DRINK.")
+        if world_db["Things"][0] == t:
+            log("You DRINK.")
         t["T_KIDNEY"] += 1
         world_db["wetmap"][pos] -= 1
         if world_db["wetmap"][pos] == ord("0"):
             world_db["MAP"][pos] = ord("0")
+    elif t == world_db["Things"][0]:
+        log("YOU FAIL TO DRINK " + str(world_db["MAP"][pos] - ord("0")))
 
 
 def play_pee():
@@ -81,6 +84,17 @@ def play_move(str_arg):
         move_result = mv_yx_in_dir_legal(chr(d), t["T_POSY"], t["T_POSX"])
         if 1 == move_result[0]:
             pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
+            hitted = [tid for tid in world_db["Things"]
+                      if world_db["Things"][tid]["T_POSY"] == move_result[1]
+                      if world_db["Things"][tid]["T_POSX"] == move_result[2]]
+            if len(hitted) > 0:
+                if t["T_STOMACH"] >= 32 and t["T_KIDNEY"] >= 32:
+                    if t == world_db["Things"][0]:
+                        log("You're too FULL to suck from another creature.")
+                    return
+                world_db["Things"][0]["T_ARGUMENT"] = d
+                world_db["set_command"]("eat")
+                return
             if chr(world_db["MAP"][pos]) in "34":
                 if t["T_STOMACH"] >= 32:
                     if t == world_db["Things"][0]:
@@ -104,30 +118,36 @@ def actor_eat(t):
                                      t["T_POSY"], t["T_POSX"])
     if 1 == move_result[0]:
         pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
-        #hitted = [tid for tid in world_db["Things"]
-        #          if world_db["Things"][tid] != t
-        #          if world_db["Things"][tid]["T_LIFEPOINTS"]
-        #          if world_db["Things"][tid]["T_POSY"] == move_result[1]
-        #          if world_db["Things"][tid]["T_POSX"] == move_result[2]]
-        #if len(hitted):
-        #    hit_id = hitted[0]
-        #    hitted_tid = world_db["Things"][hit_id]["T_TYPE"]
-        #    if t == world_db["Things"][0]:
-        #        hitted_name = world_db["ThingTypes"][hitted_tid]["TT_NAME"]
-        #        log("You BUMP into " + hitted_name + ".")
-        #    elif 0 == hit_id:
-        #        hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
-        #        log(hitter_name +" BUMPS into you.")
-        #    return
+        hitted = [tid for tid in world_db["Things"]
+                  if world_db["Things"][tid]["T_POSY"] == move_result[1]
+                  if world_db["Things"][tid]["T_POSX"] == move_result[2]]
+        if len(hitted):
+            hit_id = hitted[0]
+            hitted_tid = world_db["Things"][hit_id]["T_TYPE"]
+            if t == world_db["Things"][0]:
+                hitted_name = world_db["ThingTypes"][hitted_tid]["TT_NAME"]
+                log("You SUCK from " + hitted_name + ".")
+            elif 0 == hit_id:
+                hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
+                log(hitter_name +" SUCKS from you.")
+            hitted = world_db["Things"][hit_id]
+            if t["T_STOMACH"] < 32:
+                t["T_STOMACH"] = t["T_STOMACH"] + 1
+                hitted["T_STOMACH"] -= 1
+            if t["T_KIDNEY"] < 32:
+                t["T_KIDNEY"] = t["T_KIDNEY"] + 1
+                hitted["T_KIDNEY"] -= 1
+            return
         passable = chr(world_db["MAP"][pos]) in symbols_passable
-    if passable:
+    if passable and t == world_db["Things"][0]:
         log("You try to EAT, but fail.")
     else:
         height = world_db["MAP"][pos] - ord("0")
         if t["T_STOMACH"] >= 32 or height == 5:
             return
         t["T_STOMACH"] += 1
-        log("You EAT.")
+        if t == world_db["Things"][0]:
+            log("You EAT.")
         eaten = (height == 3 and 0 == int(rand.next() % 2)) or \
                 (height == 4 and 0 == int(rand.next() % 5))
         if eaten:
@@ -145,28 +165,26 @@ def actor_move(t):
                                      t["T_POSY"], t["T_POSX"])
     if 1 == move_result[0]:
         pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
-        #hitted = [tid for tid in world_db["Things"]
-        #          if world_db["Things"][tid] != t
-        #          if world_db["Things"][tid]["T_LIFEPOINTS"]
-        #          if world_db["Things"][tid]["T_POSY"] == move_result[1]
-        #          if world_db["Things"][tid]["T_POSX"] == move_result[2]]
-        #if len(hitted):
-        #    hit_id = hitted[0]
-        #    hitted_tid = world_db["Things"][hit_id]["T_TYPE"]
-        #    if t == world_db["Things"][0]:
-        #        hitted_name = world_db["ThingTypes"][hitted_tid]["TT_NAME"]
-        #        log("You BUMP into " + hitted_name + ".")
-        #    elif 0 == hit_id:
-        #        hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
-        #        log(hitter_name +" BUMPS into you.")
-        #    return
+        hitted = [tid for tid in world_db["Things"]
+                  if world_db["Things"][tid]["T_POSY"] == move_result[1]
+                  if world_db["Things"][tid]["T_POSX"] == move_result[2]]
+        if len(hitted):
+            hit_id = hitted[0]
+            hitted_tid = world_db["Things"][hit_id]["T_TYPE"]
+            if t == world_db["Things"][0]:
+                hitted_name = world_db["ThingTypes"][hitted_tid]["TT_NAME"]
+                log("You BUMP into " + hitted_name + ".")
+            elif 0 == hit_id:
+                hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
+                log(hitter_name +" BUMPS into you.")
+            return
         passable = chr(world_db["MAP"][pos]) in symbols_passable
     if passable:
         t["T_POSY"] = move_result[1]
         t["T_POSX"] = move_result[2]
         t["pos"] = move_result[1] * world_db["MAP_LENGTH"] + move_result[2]
-        build_fov_map(t)
-    else:
+        world_db["soundmap"][t["pos"]] = ord("9")
+    elif t == world_db["Things"][0]:
         log("You try to MOVE there, but fail.")
 
 
@@ -192,6 +210,14 @@ def die(t, message):
         t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
         t["T_MEMMAP"][t["pos"]] = ord("@")
         log(message)
+    else:
+        world_db["MAP"][t["pos"]] = ord("5")
+        world_db["HUMILITY"] = t["T_KIDNEY"] + t["T_BLADDER"] + \
+            (world_db["wetmap"][t["pos"]] - ord("0"))
+        world_db["wetmap"][t["pos"]] = 0
+        tid = next(tid for tid in world_db["Things"]
+                   if world_db["Things"][tid] == t)
+        del world_db["Things"][tid]
 world_db["die"] = die
 
 
@@ -217,7 +243,7 @@ def make_map():
                 and ((not single_allowed) or is_neighbor((y, x), "0")):
             world_db["MAP"][pos] = ord("0")
             i_ground += 1
-    n_water = int((length ** 2) / 64)
+    n_water = int((length ** 2) / 32)
     i_water = 0
     while (i_water <= n_water):
         y, x, pos = new_pos()
@@ -247,6 +273,7 @@ def turn_over():
     from server.io import try_worldstate_update
     from server.config.io import io_db
     from server.utils import rand
+    from server.build_fov_map import build_fov_map
     while world_db["Things"][0]["T_LIFEPOINTS"]:
         for tid in [tid for tid in world_db["Things"]]:
             if not tid in world_db["Things"]:
@@ -257,6 +284,7 @@ def turn_over():
                     continue
                 if not t["T_COMMAND"]:
                     update_map_memory(t)
+                    build_fov_map(t)
                     if 0 == tid:
                         return
                     world_db["ai"](t)
@@ -286,36 +314,48 @@ def turn_over():
                         world_db["die"](t, "You DIE of hunger.")
                     elif t["T_KIDNEY"] <= 0:
                         world_db["die"](t, "You DIE of dehydration.")
-        water = 0
-        positions_to_wet = []
-        for pos in range(world_db["MAP_LENGTH"] ** 2):
-            if world_db["MAP"][pos] == ord("0") \
-                    and world_db["wetmap"][pos] < ord("5"):
-                positions_to_wet += [pos]
-        i_positions_to_wet = len(positions_to_wet)
         for pos in range(world_db["MAP_LENGTH"] ** 2):
             wetness = world_db["wetmap"][pos] - ord("0")
             height = world_db["MAP"][pos] - ord("0")
             if height == 0 and wetness > 0 \
                     and 0 == rand.next() % ((2 ** 13) / (2 ** wetness)):
                 world_db["MAP"][pos] = ord("-")
-                if pos in positions_to_wet:
-                    positions_to_wet.remove(pos)
-                    i_positions_to_wet -= 1
             if ((wetness > 0 and height != 0) or wetness > 1) \
                 and 0 == rand.next() % 5:
                 world_db["wetmap"][pos] -= 1
-                water += 1
-                i_positions_to_wet -= 1
-            if i_positions_to_wet == 0:
-                break
-        if water > 0:
-            while water > 0:
+                world_db["HUMIDITY"] += 1
+        if world_db["HUMIDITY"] > 0:
+            if world_db["HUMIDITY"] > 2 and 0 == rand.next() % 2:
+                world_db["NEW_SPAWN"] += 1
+                world_db["HUMIDITY"] -= 1
+            if world_db["NEW_SPAWN"] >= 16:
+                world_db["NEW_SPAWN"] -= 16
+                from server.new_thing import new_Thing
+                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]) !=\
+                        "5":
+                        from server.utils import id_setter
+                        tid = id_setter(-1, "Things")
+                        world_db["Things"][tid] = new_Thing(
+                            world_db["PLAYER_TYPE"], (y, x))
+                        pos = y * world_db["MAP_LENGTH"] + x
+                        break
+            positions_to_wet = []
+            for pos in range(world_db["MAP_LENGTH"] ** 2):
+                if world_db["MAP"][pos] == ord("0") \
+                        and world_db["wetmap"][pos] < ord("5"):
+                    positions_to_wet += [pos]
+            while world_db["HUMIDITY"] > 0 and len(positions_to_wet) > 0:
                 select = rand.next() % len(positions_to_wet)
                 pos = positions_to_wet[select]
                 world_db["wetmap"][pos] += 1
                 positions_to_wet.remove(pos)
-                water -= 1
+                world_db["HUMIDITY"] -= 1
+        for pos in range(world_db["MAP_LENGTH"] ** 2):
+            if world_db["soundmap"][pos] > ord("0"):
+                world_db["soundmap"][pos] -= 1
         world_db["TURN"] += 1
         io_db["worldstate_updateable"] = True
         try_worldstate_update()
@@ -345,15 +385,42 @@ def play_wait():
         world_db["set_command"]("wait")
 
 
-def save_wetmap():
+def save_maps():
     length = world_db["MAP_LENGTH"]
     string = ""
     for i in range(length):
         line = world_db["wetmap"][i * length:(i * length) + length].decode()
         string = string + "WETMAP" + " "  + str(i) + " " + line + "\n"
+    for i in range(length):
+        line = world_db["soundmap"][i * length:(i * length) + length].decode()
+        string = string + "SOUNDMAP" + " "  + str(i) + " " + line + "\n"
     return string
 
 
+def soundmapset(str_int, mapline):
+    def valid_map_line(str_int, mapline):
+        from server.utils import integer_test
+        val = integer_test(str_int, 0, 255)
+        if None != val:
+            if val >= world_db["MAP_LENGTH"]:
+                print("Illegal value for map line number.")
+            elif len(mapline) != world_db["MAP_LENGTH"]:
+                print("Map line length is unequal map width.")
+            else:
+                return val
+        return None
+    val = valid_map_line(str_int, mapline)
+    if None != val:
+        length = world_db["MAP_LENGTH"]
+        if not world_db["soundmap"]:
+            m = bytearray(b' ' * (length ** 2))
+        else:
+            m = world_db["soundmap"]
+        m[val * length:(val * length) + length] = mapline.encode()
+        if not world_db["soundmap"]:
+            world_db["soundmap"] = m
+
+
 def wetmapset(str_int, mapline):
     def valid_map_line(str_int, mapline):
         from server.utils import integer_test
@@ -377,6 +444,13 @@ def wetmapset(str_int, mapline):
         if not world_db["wetmap"]:
             world_db["wetmap"] = m
 
+
+def write_soundmap():
+    from server.worldstate_write_helpers import write_map
+    length = world_db["MAP_LENGTH"]
+    return write_map(world_db["soundmap"], world_db["MAP_LENGTH"])
+
+
 def write_wetmap():
     from server.worldstate_write_helpers import write_map
     length = world_db["MAP_LENGTH"]
@@ -398,6 +472,12 @@ def get_dir_to_target(t, target):
     from server.utils import rand, libpr, c_pointer_to_bytearray
     from server.config.world_data import symbols_passable
 
+    def get_map_score(pos):
+        result = libpr.get_map_score(pos)
+        if result < 0:
+            raise RuntimeError("No score map allocated for get_map_score().")
+        return result
+
     def zero_score_map_where_char_on_memdepthmap(c):
         map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
         if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
@@ -415,6 +495,11 @@ def get_dir_to_target(t, target):
             raise RuntimeError("No movement cost map allocated for "
                                "set_movement_cost_map().")
 
+    def animates_in_fov(maplength):
+        return [Thing for Thing in world_db["Things"].values()
+                if Thing["T_LIFEPOINTS"] and 118 == t["fovmap"][Thing["pos"]]
+                and (not Thing == t)]
+
     def seeing_thing():
         def exists(gen):
             try:
@@ -440,6 +525,9 @@ def get_dir_to_target(t, target):
                           if ord("0") <= t["T_MEMMAP"][pos] <= ord("2")
                           if (t["fovmap"] != ord("v")
                               or world_db["terrain_fullness"](pos) < 5))
+        elif target in {"hunt", "flee"} and t["fovmap"]:
+            return exists(Thing for
+                          Thing in animates_in_fov(world_db["MAP_LENGTH"]))
         return False
 
     def init_score_map():
@@ -467,6 +555,9 @@ def get_dir_to_target(t, target):
                  or world_db["terrain_fullness"](pos) < 5)]
         elif target == "search":
             zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
+        elif target in {"hunt", "flee"}:
+            [set_map_score(Thing["pos"], 0) for
+             Thing in animates_in_fov(world_db["MAP_LENGTH"])]
 
     def rand_target_dir(neighbors, cmp, dirs):
         candidates = []
@@ -492,13 +583,25 @@ def get_dir_to_target(t, target):
         dirs = "edcxsw"
         eye_pos = t["pos"]
         neighbors = get_neighbor_scores(dirs, eye_pos)
-        minmax_start = 65535 - 1
+        minmax_start = 0 if "flee" == target else 65535 - 1
         minmax_neighbor = minmax_start
         for i in range(len(dirs)):
-            if minmax_neighbor > neighbors[i]:
+            if ("flee" == target and get_map_score(t["pos"]) < neighbors[i] and
+                minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
+               or ("flee" != target and minmax_neighbor > neighbors[i]):
                 minmax_neighbor = neighbors[i]
         if minmax_neighbor != minmax_start:
             dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
+        if "flee" == target:
+            distance = get_map_score(t["pos"])
+            fear_distance = 5
+            attack_distance = 1
+            if not dir_to_target:
+                if attack_distance >= distance:
+                    dir_to_target = rand_target_dir(neighbors,
+                                                    distance - 1, dirs)
+            elif dir_to_target and fear_distance < distance:
+                dir_to_target = 0
         return dir_to_target, minmax_neighbor
 
     dir_to_target = False
@@ -523,7 +626,9 @@ def get_dir_to_target(t, target):
             if 1 != move_result[0]:
                 return False, 0
             pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
-            if world_db["MAP"][pos] > ord("2"):
+            hitted = [tid for tid in world_db["Things"]
+                      if world_db["Things"][tid]["pos"] == pos]
+            if world_db["MAP"][pos] > ord("2") or len(hitted) > 0:
                 action = "eat"
             t["T_COMMAND"] = [taid for taid in world_db["ThingActions"]
                               if world_db["ThingActions"][taid]["TA_NAME"]
@@ -558,6 +663,7 @@ def ai(t):
 
     t["T_COMMAND"] = thing_action_id("wait")
     needs = {
+        "flee": 24,
         "safe_pee": (world_db["terrain_fullness"](t["pos"]) * t["T_BLADDER"]) / 4,
         "safe_drop": (world_db["terrain_fullness"](t["pos"]) * t["T_BOWEL"]) / 4,
         "food": 33 - t["T_STOMACH"],
@@ -594,11 +700,15 @@ def ai(t):
                             world_db["get_dir_to_target"](t, "food")[0]:
                         return
                 continue
-            if world_db["get_dir_to_target"](t, need[0])[0]:
-                return
-            elif t["T_STOMACH"] < 32 and \
-                    need[0] in {"fluid_certain", "fluid_potential"} and \
-                    world_db["get_dir_to_target"](t, "food")[0]:
+            if need[0] in {"fluid_certain", "fluid_potential", "food"}:
+                if world_db["get_dir_to_target"](t, need[0])[0]:
+                    return
+                elif world_db["get_dir_to_target"](t, "hunt")[0]:
+                    return
+                elif need[0] != "food" and t["T_STOMACH"] < 32 and \
+                        world_db["get_dir_to_target"](t, "food")[0]:
+                    return
+            elif world_db["get_dir_to_target"](t, need[0])[0]:
                 return
 world_db["ai"] = ai
 
@@ -609,6 +719,7 @@ io_db["worldstate_write_order"] += [["T_KIDNEY", "player_int"]]
 io_db["worldstate_write_order"] += [["T_BOWEL", "player_int"]]
 io_db["worldstate_write_order"] += [["T_BLADDER", "player_int"]]
 io_db["worldstate_write_order"] += [[write_wetmap, "func"]]
+io_db["worldstate_write_order"] += [[write_soundmap, "func"]]
 import server.config.world_data
 server.config.world_data.symbols_hide = "345"
 server.config.world_data.symbols_passable = "012-"
@@ -616,8 +727,13 @@ server.config.world_data.thing_defaults["T_STOMACH"] = 16
 server.config.world_data.thing_defaults["T_BOWEL"] = 0
 server.config.world_data.thing_defaults["T_KIDNEY"] = 16
 server.config.world_data.thing_defaults["T_BLADDER"] = 0
+world_db["soundmap"] = bytearray(b"0" * world_db["MAP_LENGTH"] ** 2)
 world_db["wetmap"] = bytearray(b"0" * world_db["MAP_LENGTH"] ** 2)
-io_db["hook_save"] = save_wetmap
+if not "NEW_SPAWN" in world_db:
+    world_db["NEW_SPAWN"] = 0
+if not "HUMIDITY" in world_db:
+    world_db["HUMIDITY"] = 0
+io_db["hook_save"] = save_maps
 import server.config.make_world_helpers
 server.config.make_world_helpers.make_map = make_map
 from server.config.commands import commands_db
@@ -631,11 +747,14 @@ commands_db["drink"] = (0, False, play_drink)
 commands_db["pee"] = (0, False, play_pee)
 commands_db["use"] = (1, False, lambda x: None)
 commands_db["pickup"] = (0, False, lambda: None)
+commands_db["NEW_SPAWN"] = (1, False, setter(None, "NEW_SPAWN", 0, 255))
+commands_db["HUMIDITY"] = (1, False, setter(None, "HUMIDITY", 0, 65535))
 commands_db["T_STOMACH"] = (1, False, setter("Thing", "T_STOMACH", 0, 255))
 commands_db["T_KIDNEY"] = (1, False, setter("Thing", "T_KIDNEY", 0, 255))
 commands_db["T_BOWEL"] = (1, False, setter("Thing", "T_BOWEL", 0, 255))
 commands_db["T_BLADDER"] = (1, False, setter("Thing", "T_BLADDER", 0, 255))
 commands_db["WETMAP"] = (2, False, wetmapset)
+commands_db["SOUNDMAP"] = (2, False, soundmapset)
 from server.actions import actor_wait
 import server.config.actions
 server.config.actions.action_db = {