home · contact · privacy
Plugin: Add scenario file.
[plomrogue] / server / commands.py
1 # This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
2 # or any later version. For details on its copyright, license, and warranties,
3 # see the file NOTICE in the root directory of the PlomRogue source package.
4
5
6 from server.config.world_data import world_db
7 from server.config.io import io_db
8 from server.io import log, strong_write 
9 from server.utils import integer_test, id_setter
10 from server.world import set_world_inactive, turn_over
11 from server.update_map_memory import update_map_memory
12 from server.build_fov_map import build_fov_map
13
14
15 def command_plugin(str_plugin):
16     """Run code in plugins/[str_plugin]."""
17     import os
18     if (str_plugin.replace("_", "").isalnum()
19         and os.access("plugins/server/" + str_plugin + ".py", os.F_OK)):
20         exec(open("plugins/server/" + str_plugin + ".py").read())
21         world_db["PLUGIN"] += [str_plugin]
22         return
23     print("Bad plugin name:", str_plugin)
24
25
26 def command_ping():
27     """Send PONG line to server output file."""
28     strong_write(io_db["file_out"], "PONG\n")
29
30
31 def command_quit():
32     """Abort server process."""
33     from server.io import save_world, atomic_write
34     from server.utils import opts
35     if None == opts.replay:
36         if world_db["WORLD_ACTIVE"]:
37             save_world()
38         atomic_write(io_db["path_record"], io_db["record_chunk"],
39             do_append=True)
40     raise SystemExit("received QUIT command")
41
42
43 def command_thingshere(str_y, str_x):
44     """Write to out file list of Things known to player at coordinate y, x."""
45     if world_db["WORLD_ACTIVE"]:
46         y = integer_test(str_y, 0, 255)
47         x = integer_test(str_x, 0, 255)
48         length = world_db["MAP_LENGTH"]
49         if None != y and None != x and y < length and x < length:
50             pos = (y * world_db["MAP_LENGTH"]) + x
51             strong_write(io_db["file_out"], "THINGS_HERE START\n")
52             terrain = chr(world_db["Things"][0]["T_MEMMAP"][pos])
53             terrain_name = world_db["terrain_names"][terrain]
54             strong_write(io_db["file_out"], "terrain: " + terrain_name + "\n")
55             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
56                 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
57                               for id in world_db["Things"]
58                               if not world_db["Things"][id]["carried"]
59                               if world_db["Things"][id]["T_TYPE"] == tid
60                               if y == world_db["Things"][id]["T_POSY"]
61                               if x == world_db["Things"][id]["T_POSX"]]:
62                     type = world_db["Things"][id]["T_TYPE"]
63                     name = world_db["ThingTypes"][type]["TT_NAME"]
64                     strong_write(io_db["file_out"], name + "\n")
65             else:
66                 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
67                               for mt in world_db["Things"][0]["T_MEMTHING"]
68                               if mt[0] == tid if y == mt[1] if x == mt[2]]:
69                     name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
70                     strong_write(io_db["file_out"], name + "\n")
71             strong_write(io_db["file_out"], "THINGS_HERE END\n")
72         else:
73             print("Ignoring: Invalid map coordinates.")
74     else:
75         print("Ignoring: Command only works on existing worlds.")
76
77
78 def command_seedrandomness(seed_string):
79     """Set rand seed to int(seed_string)."""
80     from server.utils import rand
81     val = integer_test(seed_string, 0, 4294967295)
82     if None != val:
83         rand.seed = val
84
85
86 def command_makeworld(seed_string):
87     """Call make_world()."""
88     val = integer_test(seed_string, 0, 4294967295)
89     if None != val:
90         from server.config.misc import make_world_func
91         make_world_func(val)
92
93
94 def command_maplength(maplength_string):
95     """Redefine map length. Invalidate map, therefore lose all things on it."""
96     val = integer_test(maplength_string, 1, 256)
97     if None != val:
98         from server.utils import libpr
99         world_db["MAP_LENGTH"] = val
100         world_db["MAP"] = False
101         set_world_inactive()
102         world_db["Things"] = {}
103         libpr.set_maplength(val)
104
105
106 def command_worldactive(worldactive_string):
107     """Toggle world_db["WORLD_ACTIVE"] if possible.
108
109     An active world can always be set inactive. An inactive world can only be
110     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
111     map. On activation, rebuild all Things' FOVs, and the player's map memory.
112     """
113     val = integer_test(worldactive_string, 0, 1)
114     if None != val:
115         if 0 != world_db["WORLD_ACTIVE"]:
116             if 0 == val:
117                 set_world_inactive()
118             else:
119                 print("World already active.")
120         elif 0 == world_db["WORLD_ACTIVE"]:
121             wait_exists = False
122             for ThingAction in world_db["ThingActions"]:
123                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
124                     wait_exists = True
125                     break
126             player_exists = False
127             for Thing in world_db["Things"]:
128                 if 0 == Thing:
129                     player_exists = True
130                     break
131             if wait_exists and player_exists and world_db["MAP"]:
132                 for id in world_db["Things"]:
133                     if world_db["Things"][id]["T_LIFEPOINTS"]:
134                         build_fov_map(world_db["Things"][id])
135                         if 0 == id:
136                             update_map_memory(world_db["Things"][id], False)
137                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
138                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
139                     world_db["Things"][0]["fovmap"] = empty_fovmap
140                 world_db["WORLD_ACTIVE"] = 1
141             else:
142                 print("Ignoring: Not all conditions for world activation met.")
143
144
145 def command_tid(id_string):
146     """Set ID of Thing to manipulate. ID unused? Create new one.
147
148     Default new Thing's type to the first available ThingType, others: zero.
149     """
150     id = id_setter(id_string, "Things", command_tid)
151     if None != id:
152         if world_db["ThingTypes"] == {}:
153             print("Ignoring: No ThingType to settle new Thing in.")
154             return
155         type = list(world_db["ThingTypes"].keys())[0]
156         from server.new_thing import new_Thing
157         world_db["Things"][id] = new_Thing(type)
158
159
160 def command_ttid(id_string):
161     """Set ID of ThingType to manipulate. ID unused? Create new one.
162
163     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
164     "", others: 0. 
165     """
166     id = id_setter(id_string, "ThingTypes", command_ttid)
167     if None != id:
168         world_db["ThingTypes"][id] = {
169             "TT_NAME": "(none)",
170             "TT_TOOLPOWER": 0,
171             "TT_LIFEPOINTS": 0,
172             "TT_PROLIFERATE": 0,
173             "TT_START_NUMBER": 0,
174             "TT_SYMBOL": "?",
175             "TT_CORPSE_ID": id,
176             "TT_TOOL": ""
177         }
178
179
180 def command_taid(id_string):
181     """Set ID of ThingAction to manipulate. ID unused? Create new one.
182
183     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
184     """
185     id = id_setter(id_string, "ThingActions", command_taid, True)
186     if None != id:
187         world_db["ThingActions"][id] = {
188             "TA_EFFORT": 1,
189             "TA_NAME": "wait"
190         }
191
192
193 def test_for_id_maker(object, category):
194     """Return decorator testing for object having "id" attribute."""
195     def decorator(f):
196         def helper(*args):
197             if hasattr(object, "id"):
198                 f(*args)
199             else:
200                 print("Ignoring: No " + category +
201                       " defined to manipulate yet.")
202         return helper
203     return decorator
204
205
206 test_Thing_id = test_for_id_maker(command_tid, "Thing")
207 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
208 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
209
210
211 @test_Thing_id
212 def command_tcommand(str_int):
213     """Set T_COMMAND of selected Thing."""
214     val = integer_test(str_int, 0)
215     if None != val:
216         if 0 == val or val in world_db["ThingActions"]:
217             world_db["Things"][command_tid.id]["T_COMMAND"] = val
218         else:
219             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
220
221
222 @test_Thing_id
223 def command_ttype(str_int):
224     """Set T_TYPE of selected Thing."""
225     val = integer_test(str_int, 0)
226     if None != val:
227         if val in world_db["ThingTypes"]:
228             world_db["Things"][command_tid.id]["T_TYPE"] = val
229         else:
230             print("Ignoring: ThingType ID belongs to no known ThingType.")
231
232
233 @test_Thing_id
234 def command_tcarries(str_int):
235     """Append int(str_int) to T_CARRIES of selected Thing.
236
237     The ID int(str_int) must not be of the selected Thing, and must belong to a
238     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
239     """
240     val = integer_test(str_int, 0)
241     if None != val:
242         if val == command_tid.id:
243             print("Ignoring: Thing cannot carry itself.")
244         elif val in world_db["Things"] \
245                 and not world_db["Things"][val]["carried"]:
246             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
247             world_db["Things"][val]["carried"] = True
248         else:
249             print("Ignoring: Thing not available for carrying.")
250     # Note that the whole carrying structure is different from the C version:
251     # Carried-ness is marked by a "carried" flag, not by Things containing
252     # Things internally.
253
254
255 @test_Thing_id
256 def command_tmemthing(str_t, str_y, str_x):
257     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
258
259     The type must fit to an existing ThingType, and the position into the map.
260     """
261     type = integer_test(str_t, 0)
262     posy = integer_test(str_y, 0, 255)
263     posx = integer_test(str_x, 0, 255)
264     if None != type and None != posy and None != posx:
265         if type not in world_db["ThingTypes"] \
266            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
267             print("Ignoring: Illegal value for thing type or position.")
268         else:
269             memthing = (type, posy, posx)
270             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
271
272
273 @test_ThingType_id
274 def command_ttname(name):
275     """Set TT_NAME of selected ThingType."""
276     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
277
278
279 @test_ThingType_id
280 def command_tttool(name):
281     """Set TT_TOOL of selected ThingType."""
282     world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
283
284
285 @test_ThingType_id
286 def command_ttsymbol(char):
287     """Set TT_SYMBOL of selected ThingType. """
288     if 1 == len(char):
289         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
290     else:
291         print("Ignoring: Argument must be single character.")
292
293
294 @test_ThingType_id
295 def command_ttcorpseid(str_int):
296     """Set TT_CORPSE_ID of selected ThingType."""
297     val = integer_test(str_int, 0)
298     if None != val:
299         if val in world_db["ThingTypes"]:
300             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
301         else:
302             print("Ignoring: Corpse ID belongs to no known ThignType.")
303
304
305 @test_ThingAction_id
306 def command_taname(name):
307     """Set TA_NAME of selected ThingAction.
308
309     The name must match a valid thing action function. If after the name
310     setting no ThingAction with name "wait" remains, call set_world_inactive().
311     """
312     if name == "wait" or name == "move" or name == "use" or name == "drop" \
313        or name == "pickup":
314         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
315         if 1 == world_db["WORLD_ACTIVE"]:
316             wait_defined = False
317             for id in world_db["ThingActions"]:
318                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
319                     wait_defined = True
320                     break
321             if not wait_defined:
322                 set_world_inactive()
323     else:
324         print("Ignoring: Invalid action name.")
325     # In contrast to the original,naming won't map a function to a ThingAction.
326
327
328 def setter(category, key, min, max=None):
329     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
330     if category is None:
331         def f(val_string):
332             val = integer_test(val_string, min, max)
333             if None != val:
334                 world_db[key] = val
335     else:
336         if category == "Thing":
337             id_store = command_tid
338             decorator = test_Thing_id
339         elif category == "ThingType":
340             id_store = command_ttid
341             decorator = test_ThingType_id
342         elif category == "ThingAction":
343             id_store = command_taid
344             decorator = test_ThingAction_id
345
346         @decorator
347         def f(val_string):
348             val = integer_test(val_string, min, max)
349             if None != val:
350                 world_db[category + "s"][id_store.id][key] = val
351     return f
352
353
354 def setter_map(maptype):
355     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
356
357     If no map of maptype exists yet, initialize it with ' ' bytes first.
358     """
359
360     def valid_map_line(str_int, mapline):
361         val = integer_test(str_int, 0, 255)
362         if None != val:
363             if val >= world_db["MAP_LENGTH"]:
364                 print("Illegal value for map line number.")
365             elif len(mapline) != world_db["MAP_LENGTH"]:
366                 print("Map line length is unequal map width.")
367             else:
368                 return val
369         return None
370
371     def nonThingMap_helper(str_int, mapline):
372         val = valid_map_line(str_int, mapline)
373         if None != val:
374             length = world_db["MAP_LENGTH"]
375             if not world_db["MAP"]:
376                 map = bytearray(b' ' * (length ** 2))
377             else:
378                 map = world_db["MAP"]
379             map[val * length:(val * length) + length] = mapline.encode()
380             if not world_db["MAP"]:
381                 world_db["MAP"] = map
382
383     @test_Thing_id
384     def ThingMap_helper(str_int, mapline):
385         val = valid_map_line(str_int, mapline)
386         if None != val:
387             length = world_db["MAP_LENGTH"]
388             if not world_db["Things"][command_tid.id][maptype]:
389                 map = bytearray(b' ' * (length ** 2))
390             else:
391                 map = world_db["Things"][command_tid.id][maptype]
392             map[val * length:(val * length) + length] = mapline.encode()
393             if not world_db["Things"][command_tid.id][maptype]:
394                 world_db["Things"][command_tid.id][maptype] = map
395
396     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
397
398
399
400 def setter_tpos(axis):
401     """Generate setter for T_POSX or  T_POSY of selected Thing.
402
403     If world is active, rebuilds animate things' fovmap, player's memory map.
404     """
405     @test_Thing_id
406     def helper(str_int):
407         val = integer_test(str_int, 0, 255)
408         if None != val:
409             if val < world_db["MAP_LENGTH"]:
410                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
411                 if world_db["WORLD_ACTIVE"] \
412                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
413                     build_fov_map(world_db["Things"][command_tid.id])
414                     if 0 == command_tid.id:
415                         update_map_memory(world_db["Things"][command_tid.id])
416             else:
417                 print("Ignoring: Position is outside of map.")
418     return helper
419
420
421 def set_command(action):
422     """Set player's T_COMMAND, then call turn_over()."""
423     id = [x for x in world_db["ThingActions"]
424           if world_db["ThingActions"][x]["TA_NAME"] == action][0]
425     world_db["Things"][0]["T_COMMAND"] = id
426     turn_over()
427
428
429 def play_wait():
430     """Try "wait" as player's T_COMMAND."""
431     set_command("wait")
432
433
434 def action_exists(action):
435     matching_actions = [x for x in world_db["ThingActions"]
436                         if world_db["ThingActions"][x]["TA_NAME"] == action]
437     if len(matching_actions) >= 1:
438         return True
439     print("No appropriate ThingAction defined.")
440     return False
441
442
443 def play_pickup():
444     """Try "pickup" as player's T_COMMAND"."""
445     if action_exists("pickup"):
446         t = world_db["Things"][0]
447         ids = [id for id in world_db["Things"] if id
448                if not world_db["Things"][id]["carried"]
449                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
450                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
451         if not len(ids):
452              log("NOTHING to pick up.")
453         else:
454             set_command("pickup")
455
456
457 def play_drop(str_arg):
458     """Try "drop" as player's T_COMMAND, int(str_arg) as T_ARGUMENT / slot."""
459     if action_exists("drop"):
460         t = world_db["Things"][0]
461         if 0 == len(t["T_CARRIES"]):
462             log("You have NOTHING to drop in your inventory.")
463         else:
464             val = integer_test(str_arg, 0, 255)
465             if None != val and val < len(t["T_CARRIES"]):
466                 world_db["Things"][0]["T_ARGUMENT"] = val
467                 set_command("drop")
468             else:
469                 print("Illegal inventory index.")
470
471
472 def play_use(str_arg):
473     """Try "use" as player's T_COMMAND, int(str_arg) as T_ARGUMENT / slot."""
474     if action_exists("use"):
475         t = world_db["Things"][0]
476         if 0 == len(t["T_CARRIES"]):
477             log("You have NOTHING to use in your inventory.")
478         else:
479             val = integer_test(str_arg, 0, 255)
480             if None != val and val < len(t["T_CARRIES"]):
481                 id = t["T_CARRIES"][val]
482                 type = world_db["Things"][id]["T_TYPE"]
483                 if not world_db["ThingTypes"][type]["TT_TOOL"] == "food":
484                     log("You CAN'T consume this thing.")
485                     return
486                 world_db["Things"][0]["T_ARGUMENT"] = val
487                 set_command("use")
488             else:
489                 print("Illegal inventory index.")
490
491
492 def play_move(str_arg):
493     """Try "move" as player's T_COMMAND, str_arg as T_ARGUMENT / direction."""
494     if action_exists("move"):
495         from server.config.world_data import directions_db, symbols_passable
496         t = world_db["Things"][0]
497         if not str_arg in directions_db:
498             print("Illegal move direction string.")
499             return
500         dir = ord(directions_db[str_arg])
501         from server.utils import mv_yx_in_dir_legal
502         move_result = mv_yx_in_dir_legal(chr(dir), t["T_POSY"], t["T_POSX"])
503         if 1 == move_result[0]:
504             pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
505             if ord("~") == world_db["MAP"][pos]:
506                 log("You can't SWIM.")
507                 return
508             if chr(world_db["MAP"][pos]) in symbols_passable:
509                 world_db["Things"][0]["T_ARGUMENT"] = dir
510                 set_command("move")
511                 return
512         log("You CAN'T move there.")
513
514
515 def command_ai():
516     """Call ai() on player Thing, then turn_over()."""
517     from server.config.actions import ai_func
518     ai_func(world_db["Things"][0])
519     turn_over()