+# This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
+# or any later version. For details on its copyright, license, and warranties,
+# see the file NOTICE in the root directory of the PlomRogue source package.
+
+
from server.config.world_data import world_db
from server.io import log
-from server.utils import rand, libpr, c_pointer_to_bytearray
+from server.utils import rand, libpr
from server.utils import id_setter
-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
- selected randomly.
- """
- from server.config.world_data import directions_db
- from server.utils import mv_yx_in_dir_legal
- 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 sorted(directions_db.keys())]:
- 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]]:
- candidates.append((mv_result[1], mv_result[2]))
- if len(candidates):
- i = rand.next() % len(candidates)
- id = id_setter(-1, "Things")
- newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
- world_db["Things"][id] = newT
-
-
def update_map_memory(t, age_map=True):
"""Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
+ from server.utils import c_pointer_to_bytearray
def age_some_memdepthmap_on_nonfov_cells():
# OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
t["T_MEMTHING"].append((type, y, x))
-def build_fov_map(t):
- """Build Thing's FOV map."""
- t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
- fovmap = c_pointer_to_bytearray(t["fovmap"])
- map = c_pointer_to_bytearray(world_db["MAP"])
- if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
- raise RuntimeError("Malloc error in build_fov_Map().")
-
-
-def new_Thing(type, pos=(0, 0)):
- """Return Thing of type T_TYPE, with fovmap if alive and world active."""
- thing = {
- "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
- "T_ARGUMENT": 0,
- "T_PROGRESS": 0,
- "T_SATIATION": 0,
- "T_COMMAND": 0,
- "T_TYPE": type,
- "T_POSY": pos[0],
- "T_POSX": pos[1],
- "T_CARRIES": [],
- "carried": False,
- "T_MEMTHING": [],
- "T_MEMMAP": False,
- "T_MEMDEPTHMAP": False,
- "fovmap": False
- }
- if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
- build_fov_map(thing)
- return thing
-
-
def decrement_lifepoints(t):
"""Decrement t's lifepoints by 1, and if to zero, corpse it.
world_db["WORLD_ACTIVE"] = 0
-def make_map():
- """(Re-)make island map.
-
- Let "~" represent water, "." land, "X" trees: Build island shape randomly,
- start with one land cell in the middle, then go into cycle of repeatedly
- selecting a random sea cell and transforming it into land if it is neighbor
- 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).
- """
-
- def is_neighbor(coordinates, type):
- y = coordinates[0]
- x = coordinates[1]
- length = world_db["MAP_LENGTH"]
- ind = y % 2
- diag_west = x + (ind > 0)
- diag_east = x + (ind < (length - 1))
- pos = (y * length) + x
- if (y > 0 and diag_east
- and type == chr(world_db["MAP"][pos - length + ind])) \
- or (x < (length - 1)
- and type == chr(world_db["MAP"][pos + 1])) \
- or (y < (length - 1) and diag_east
- and type == chr(world_db["MAP"][pos + length + ind])) \
- or (y > 0 and diag_west
- and type == chr(world_db["MAP"][pos - length - (not ind)])) \
- or (x > 0
- and type == chr(world_db["MAP"][pos - 1])) \
- or (y < (length - 1) and diag_west
- and type == chr(world_db["MAP"][pos + length - (not ind)])):
- return True
- return False
-
- world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
- length = world_db["MAP_LENGTH"]
- add_half_width = (not (length % 2)) * int(length / 2)
- world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
- while (1):
- y = rand.next() % length
- x = rand.next() % length
- pos = (y * length) + x
- if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
- if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
- break
- world_db["MAP"][pos] = ord(".")
- n_trees = int((length ** 2) / 16)
- i_trees = 0
- while (i_trees <= n_trees):
- single_allowed = rand.next() % 32
- 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), "X")):
- world_db["MAP"][pos] = ord("X")
- i_trees += 1
- # This all-too-precise replica of the original C code misses iter_limit().
-
-
def make_world(seed):
"""(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
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.
"""
+ from server.config.world_data import symbols_passable
+ from server.config.misc import make_map_func
def free_pos():
i = 0
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]):
+ if chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]) in \
+ symbols_passable:
break
i += 1
if i == 65535:
"No thing action with name 'wait' defined.")
return
world_db["Things"] = {}
- make_map()
+ make_map_func()
world_db["WORLD_ACTIVE"] = 1
world_db["TURN"] = 1
+ from server.new_thing import new_Thing
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())
def turn_over():
"""Run game world and its inhabitants until new player input expected."""
- from server.config.actions import action_db
- from server.ai import ai
+ from server.config.actions import action_db, ai_func
+ from server.config.misc import thingproliferation_func
id = 0
whilebreaker = False
while world_db["Things"][0]["T_LIFEPOINTS"]:
if 0 == id:
whilebreaker = True
break
- ai(Thing)
+ ai_func(Thing)
try_healing(Thing)
hunger(Thing)
if Thing["T_LIFEPOINTS"]:
if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
action = action_db["actor_" + ThingAction["TA_NAME"]]
action(Thing)
- #eval("actor_" + ThingAction["TA_NAME"])(Thing)
Thing["T_COMMAND"] = 0
Thing["T_PROGRESS"] = 0
- thingproliferation(Thing, proliferable_map)
+ thingproliferation_func(Thing, proliferable_map)
if whilebreaker:
break
world_db["TURN"] += 1
projects / plomrogue / blobdiff