def receive_message(inter_ob, data, txt):
global call_catch_tell
if call_catch_tell is None:
symbol_ob = ldmud.Symbol('ob')
symbol_txt = ldmud.Symbol('txt')
call_catch_tell = ldmud.efuns.unbound_lambda(
ldmud.Array((
symbol_ob,
symbol_txt,
)),
ldmud.Array(
(ldmud.Closure(ldmud.get_master(), "efun::call_resolved"),
ldmud.Array((ldmud.Closure(ldmud.get_master(),
'&'), ldmud.Symbol('result'))),
symbol_ob, "catch_tell", symbol_txt)))
current_ob = ldmud.efuns.this_object()
if current_ob == inter_ob or not ldmud.efuns.bind_lambda(
call_catch_tell, current_ob)(inter_ob, txt):
data.call_control_ob("receive_message", inter_ob, txt)
if data.snooper is not None:
try:
ldmud.efuns.tell_object(data.snooper, "%" + txt)
except:
pass
def efun_say(msg: (str, ldmud.Array, ldmud.Object, ldmud.Mapping,
ldmud.Struct),
excludes: (
ldmud.Object,
ldmud.Array,
) = None) -> None:
def base_efun():
if excludes is None:
ldmud.efuns.say(msg)
else:
ldmud.efuns.say(msg, excludes)
if not isinstance(msg, str):
return base_efun()
# Determine the recipients
current_ob = ldmud.efuns.this_object()
if ldmud.efuns.living(current_ob):
initiator = current_ob
else:
initiator = ldmud.efuns.this_player()
if not initiator:
initiator = current_ob
recipients = set()
env = ldmud.efuns.environment(initiator)
if env:
recipients.add(env)
recipients.update(ldmud.efuns.all_inventory(env))
recipients.update(ldmud.efuns.all_inventory(initiator))
if isinstance(excludes, ldmud.Object):
recipients.discard(excludes)
recipients.discard(initiator)
elif isinstance(excludes, ldmud.Array):
recipients.difference_update(excludes)
else:
recipients.discard(initiator)
# Check if there are any of us in there
inter_obs = recipients.intersection(control.interactives)
if not len(inter_obs):
return base_efun()
# Send to the remaining...
if len(inter_obs) < len(recipients):
if isinstance(excludes, ldmud.Object):
excludes = ldmud.Array((excludes, initiator, *inter_obs))
elif isinstance(excludes, ldmud.Array):
excludes += ldmud.Array(inter_obs)
else:
excludes = ldmud.Array((initiator, *inter_obs))
ldmud.efuns.say(msg, excludes)
# And now send to all our interactives
for inter_ob in inter_obs:
data = control.interactives.get(inter_ob, None)
if data:
receive_message(inter_ob, data, msg)
def efun_input_to_info(inter_ob: ldmud.Object) -> ldmud.Array:
data = control.interactives.get(inter_ob, None)
if data is None:
return ldmud.efuns.input_to_info(inter_ob)
else:
result = []
for it in reversed(data.inputto):
result.append(ldmud.Array((it.cb_ob, it.cb_fun, *it.args)))
return ldmud.Array(result)
def efun_tell_room(room: (ldmud.Object, str),
msg: (str, ldmud.Array, ldmud.Object, ldmud.Mapping,
ldmud.Struct),
excludes: (
ldmud.Object,
ldmud.Array,
) = None) -> None:
def base_efun():
if excludes is None:
ldmud.efuns.tell_room(room, msg)
else:
ldmud.efuns.tell_room(room, msg, excludes)
if not isinstance(msg, str):
return base_efun()
# Determine the recipients
if isinstance(room, str):
env = ldmud.efuns.find_object(room)
if not env:
# If the room does not exist, there isn't one of ours in it.
return base_efun()
else:
env = room
recipients = set()
recipients.add(env)
recipients.update(ldmud.efuns.all_inventory(env))
if isinstance(excludes, ldmud.Object):
recipients.discard(excludes)
elif isinstance(excludes, ldmud.Array):
recipients.difference_update(excludes)
# Check if there are any of us in there
inter_obs = recipients.intersection(control.interactives)
if not len(inter_obs):
return base_efun()
# Send to the remaining...
if len(inter_obs) < len(recipients):
if isinstance(excludes, ldmud.Object):
excludes = ldmud.Array((excludes, *inter_obs))
elif isinstance(excludes, ldmud.Array):
excludes += ldmud.Array(inter_obs)
else:
excludes = ldmud.Array(inter_obs)
ldmud.efuns.tell_room(room, msg, excludes)
# And now send to all our interactives
for inter_ob in inter_obs:
data = control.interactives.get(inter_ob, None)
if data:
receive_message(inter_ob, data, msg)
def testSlice(self):
arr = ldmud.Array(range(8))
self.assertEqual(list(arr[3:5]), [3, 4])
self.assertEqual(list(arr[5:3:-1]), [5, 4])
self.assertEqual(list(arr[::-2]), list(range(7, 0, -2)))
arr[::-1] = arr
self.assertEqual(list(arr), list(range(7, -1, -1)))
arr[5:10] = ldmud.Array([10])
self.assertEqual(list(arr), [7, 6, 5, 4, 3, 10])
arr[4:2:-1] = ldmud.Array([100, 101, 102, 103, 104])
self.assertEqual(list(arr), [7, 6, 5, 104, 103, 102, 101, 100, 10])
def testDeletion(self):
parr = list(range(20))
arr = ldmud.Array(range(20))
del arr[5]
del parr[5]
self.assertEqual(list(arr), parr)
del arr[1:3]
del parr[1:3]
self.assertEqual(list(arr), parr)
del arr[3:1]
del parr[3:1]
self.assertEqual(list(arr), parr)
del arr[4:2:-1]
del parr[4:2:-1]
self.assertEqual(list(arr), parr)
del arr[0:10:3]
del parr[0:10:3]
self.assertEqual(list(arr), parr)
del arr[10:0:-3]
del parr[10:0:-3]
self.assertEqual(list(arr), parr)
def testLvalueArrayItem(self):
arr = ldmud.Array([10, 11, 12])
lv = ldmud.Lvalue(arr)
lv[2].value = 42
self.assertEqual(arr[2], 42)
arr[0] = 100
self.assertEqual(lv[0].value, 100)
def testQuotedArrayInitQuotes(self):
qa = ldmud.QuotedArray(ldmud.Array([2, 1]), quotes=5)
self.assertIsNotNone(qa)
self.assertEqual(len(qa.array), 2)
self.assertEqual(qa.array[0], 2)
self.assertEqual(qa.array[1], 1)
self.assertEqual(qa.quotes, 5)
def testInitIter(self):
arr = ldmud.Array(range(10))
self.assertIsNotNone(arr)
self.assertEqual(len(arr), 10)
self.assertTrue(0 in arr)
self.assertTrue(9 in arr)
self.assertFalse(10 in arr)
def efun_caller_stack(add_inter: int = None) -> ldmud.Array:
if current_interactive is None:
return ldmud.efuns.caller_stack(add_inter or 0)[1:]
elif add_inter:
return ldmud.efuns.caller_stack()[1:] + ldmud.Array((current_interactive,))
else:
return ldmud.efuns.caller_stack()[1:]
def testQuotedArrayInitQuotedArray(self):
qa1 = ldmud.QuotedArray(ldmud.Array([4, 3]), quotes=2)
qa2 = ldmud.QuotedArray(qa1, quotes=3)
self.assertIsNotNone(qa2)
self.assertEqual(len(qa2.array), 2)
self.assertEqual(qa2.array[0], 4)
self.assertEqual(qa2.array[1], 3)
self.assertEqual(qa2.quotes, 5)
def testInitValues(self):
arr = ldmud.Array([42, 1.5, "Hi"])
self.assertIsNotNone(arr)
self.assertEqual(len(arr), 3)
self.assertFalse(0 in arr)
self.assertTrue(42 in arr)
self.assertTrue(1.5 in arr)
self.assertTrue("Hi" in arr)
def testItemGetSet(self):
arr = ldmud.Array(size=4)
arr[0] = 10
arr[1] = 21
arr[2] = 52
arr[3] = "Me"
self.assertEqual(arr[0], 10)
self.assertEqual(arr[1], 21)
self.assertEqual(arr[2], 52)
self.assertEqual(arr[3], "Me")
def efun_spell_suggest(text: str) -> ldmud.Array:
"""
SYNOPSIS
string* spell_suggest(string word)
DESCRIPTION
Returns correctly spelled suggestions for the given word.
SEE ALSO
spell_check(E)
"""
if not speller:
raise RuntimeError("Spellchecker is not initialized.")
return ldmud.Array(speller.suggest(text))
def console(line=""):
ob = ldmud.efuns.this_object()
obname = ldmud.efuns.object_name(ob)
if obname in consoles:
console = consoles[obname]
else:
console = LDMudConsole(len(line) == 0)
consoles[obname] = console
(output, prompt) = console.input(line)
if prompt is None:
del consoles[obname]
return ldmud.Array((
output,
prompt,
))
def get_sockaddr(self):
info = socket.getaddrinfo(self.hostaddr,
self.hostport,
type=socket.SOCK_STREAM)
if not len(info):
return None
info = info[0]
raw = struct.pack("<H", info[0]) + struct.pack(">H", info[4][1])
if family == socket.AF_INET6:
raw += 4 * b"\x00"
raw += socket.inet_pton(info[0], info[4][0])
if family == socket.AF_INET:
raw += 8 * b"\x00"
elif family == socket.AF_INET6:
raw += 4 * b"\x00"
return ldmud.Array(raw)
def parse_array(self, *args, **kwargs):
(val, end) = self.orig_parse_array(*args, **kwargs)
return (ldmud.Array(val), end)
def efun_interactive_info(inter_ob: ldmud.Object, what: int):
data = control.interactives.get(inter_ob, None)
if data is None:
return ldmud.efuns.interactive_info(inter_ob, what)
else:
if what >= 0 and what in data.options:
return data.options[what]
def error():
raise ValueError("Illegal value for interactive_into()")
def query_snooper():
master = ldmud.get_master()
if master != ldmud.efuns.this_object():
result = util.lfun_call(master, "valid_query_snoop", inter_ob)
if not isinstance(result, int) or result == 0:
return 0
return data.snooper
def query_snoopers():
snooper = query_snooper()
if snooper:
return ldmud.Array((snooper, ))
else:
return ldmud.Array()
return {
IC_MAX_WRITE_BUFFER_SIZE:
lambda: ldmud.efuns.interactive_info(0, what),
IC_SOCKET_BUFFER_SIZE:
lambda: 0,
IC_COMBINE_CHARSET_AS_STRING:
lambda: "",
IC_COMBINE_CHARSET_AS_ARRAY:
lambda: ldmud.Array(
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)),
IC_CONNECTION_CHARSET_AS_STRING:
lambda: ''.join(map(chr, range(1, 128))),
IC_CONNECTION_CHARSET_AS_ARRAY:
lambda: ldmud.Array((254, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255)),
IC_QUOTE_IAC:
lambda: 1,
IC_TELNET_ENABLED:
lambda: 1,
IC_MCCP:
lambda: 0,
IC_PROMPT:
lambda: 0,
IC_MAX_COMMANDS:
lambda: -1,
IC_MODIFY_COMMAND:
lambda: 0,
IC_ENCODING:
lambda: ldmud.efuns.interactive_info(0, what),
II_IP_NAME:
lambda: data.hostname,
II_IP_NUMBER:
lambda: data.hostaddr,
II_IP_PORT:
lambda: data.hostport,
II_IP_ADDRESS:
lambda: data.get_sockaddr(),
II_MUD_PORT:
lambda: data.mudport,
II_MCCP_STATS:
lambda: 0,
II_INPUT_PENDING:
lambda: len(data.inputto) and data.inputto[0].cb_ob,
II_EDITING:
lambda: 0,
II_IDLE:
lambda: data.get_idle(),
II_SNOOP_NEXT:
query_snooper,
II_SNOOP_PREV:
lambda: 0,
II_SNOOP_ALL:
query_snoopers,
}.get(what, error)()
def testRepeat(self):
arr = ldmud.Array([1, 2, 3]) * 10
self.assertIsNotNone(arr)
self.assertEqual(len(arr), 30)
self.assertTrue(1 in arr)
self.assertTrue(3 in arr)
def testConcat(self):
arr = ldmud.Array([1, 2, 3]) + ldmud.Array([4, 5, 6])
self.assertIsNotNone(arr)
self.assertEqual(len(arr), 6)
self.assertTrue(1 in arr)
self.assertTrue(6 in arr)
def query_snoopers():
snooper = query_snooper()
if snooper:
return ldmud.Array((snooper, ))
else:
return ldmud.Array()
def get_hook_info():
return ldmud.Array((
num_hb,
ldmud.Array(ob_list),
))
def testInitSize(self):
arr = ldmud.Array(size=10)
self.assertIsNotNone(arr)
self.assertEqual(len(arr), 10)
self.assertTrue(0 in arr)
self.assertFalse(1 in arr)
def efun_users() -> ldmud.Array:
return ldmud.efuns.users() + ldmud.Array(interactives.keys())
def testInitEmpty(self):
arr = ldmud.Array()
self.assertIsNotNone(arr)
self.assertEqual(len(arr), 0)
def testLvalueArrayRange(self):
arr = ldmud.Array([10, 11, 12])
lv = ldmud.Lvalue(arr)
lv[1:2].value = ldmud.Array([111, 112])
self.assertEqual(list(lv.value), [10, 111, 112, 12])
