import handler_game
import state_checks
def do_noemote(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg:
ch.send("Noemote whom?\n")
return
victim = ch.get_char_world(arg)
if not victim:
ch.send("They aren't here.\n")
return
if victim.trust >= ch.trust:
ch.send("You failed.\n")
return
if victim.comm.is_set(merc.COMM_NOEMOTE):
victim.comm = state_checks.REMOVE_BIT(victim.comm, merc.COMM_NOEMOTE)
victim.send("You can emote again.\n")
ch.send("NOEMOTE removed.\n")
handler_game.wiznet("$N restores emotes to %s." % victim.name, ch, None, merc.WIZ_PENALTIES, merc.WIZ_SECURE, 0)
else:
victim.comm = state_checks.SET_BIT(victim.comm, merc.COMM_NOEMOTE)
victim.send("You can't emote!\n")
ch.send("NOEMOTE set.\n")
handler_game.wiznet("$N revokes %s's emotes." % victim.name, ch, None, merc.WIZ_PENALTIES, merc.WIZ_SECURE, 0)
return
interp.register_command(interp.cmd_type('noemote', do_noemote, merc.POS_DEAD, merc.L5, merc.LOG_ALWAYS, 1))
import logging
logger = logging.getLogger()
import handler_ch
import interp
import merc
def do_down(ch, argument):
handler_ch.move_char(ch, merc.DIR_DOWN, False)
return
interp.register_command(interp.cmd_type('down', do_down, merc.POS_STANDING, 0, merc.LOG_NEVER, 0))
argument, arg = game_utils.read_word(argument)
if not arg:
ch.send("Follow whom?\n")
return
victim = ch.get_char_room(arg)
if not victim:
ch.send("They aren't here.\n")
return
if ch.is_affected(merc.AFF_CHARM) and ch.master:
handler_game.act("But you'd rather follow $N!", ch, None, ch.master, merc.TO_CHAR)
return
if victim == ch:
if ch.master is None:
ch.send("You already follow yourself.\n")
return
handler_ch.stop_follower(ch)
return
if not victim.is_npc() \
and victim.act.is_set(merc.PLR_NOFOLLOW) \
and not ch.is_immortal():
handler_game.act("$N doesn't seem to want any followers.\n", ch, None, victim, merc.TO_CHAR)
return
ch.act.rem_bit(merc.PLR_NOFOLLOW)
if ch.master:
handler_ch.stop_follower(ch)
handler_ch.add_follower(ch, victim)
return
interp.register_command(interp.cmd_type('follow', do_follow, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
def do_help(ch, argument):
if not argument:
argument = "summary"
found = [h for h in merc.help_list if h.level <= ch.trust and argument.lower() in h.keyword.lower()]
for pHelp in found:
if ch.desc.is_connected(nanny.con_playing):
ch.send("\n============================================================\n")
ch.send(pHelp.keyword)
ch.send("\n")
text = pHelp.text
if pHelp.text[0] == '.':
text = pHelp.text[1:]
ch.send(text + "\n")
# small hack :)
if ch.desc and ch.desc.connected != nanny.con_playing and ch.desc.connected != nanny.con_gen_groups:
break
if not found:
ch.send("No help on that word.\n")
interp.register_command(interp.cmd_type('help', do_help, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type('motd', do_help, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1, 'motd'))
interp.register_command(interp.cmd_type('imotd', do_help, merc.POS_DEAD, merc.IM, merc.LOG_NORMAL, 1, 'imotd'))
interp.register_command(interp.cmd_type('rules', do_help, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1, 'rules'))
interp.register_command(interp.cmd_type('story', do_help, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1, 'story'))
interp.register_command(interp.cmd_type('wizlist', do_help, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1, 'wizlist'))
interp.register_command(interp.cmd_type('credits', do_help, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1, 'credits'))
handler_game.act("You drink $T from $p.", ch, obj, const.liq_table[liquid].name, merc.TO_CHAR)
update.gain_condition(ch, merc.COND_DRUNK, amount * const.liq_table[liquid].proof / 36)
update.gain_condition(ch, merc.COND_FULL, amount * const.liq_table[liquid].full / 4)
update.gain_condition(ch, merc.COND_THIRST, amount * const.liq_table[liquid].thirst / 10)
update.gain_condition(ch, merc.COND_HUNGER, amount * const.liq_table[liquid].food / 2)
if not ch.is_npc() and ch.condition[merc.COND_DRUNK] > 10:
ch.send("You feel drunk.\n")
if not ch.is_npc() and ch.condition[merc.COND_FULL] > 40:
ch.send("You are full.\n")
if not ch.is_npc() and ch.condition[merc.COND_THIRST] > 40:
ch.send("Your thirst is quenched.\n")
if obj.value[3] != 0:
# The drink was poisoned !
af = handler_game.AFFECT_DATA()
handler_game.act("$n chokes and gags.", ch, None, None, merc.TO_ROOM)
ch.send("You choke and gag.\n")
af.where = merc.TO_AFFECTS
af.type = "poison"
af.level = game_utils.number_fuzzy(amount)
af.duration = 3 * amount
af.location = merc.APPLY_NONE
af.modifier = 0
af.bitvector = merc.AFF_POISON
ch.affect_join(af)
if obj.value[0] > 0:
obj.value[1] -= amount
return
interp.register_command(interp.cmd_type('drink', do_drink, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
import logging
logger = logging.getLogger()
import merc
import interp
import handler_item
def do_equipment(ch, argument):
ch.send("You are using:\n")
found = False
for slot, item_id in ch.equipped.items():
item = ch.get_eq(slot)
if not item:
continue
if item.flags.two_handed and ch.equipped['off_hand'] == item.instance_id and 'off_hand' in slot:
continue
else:
ch.send(merc.eq_slot_strings[slot])
if ch.can_see_item(item):
ch.send(handler_item.format_item_to_char(item, ch, True) + "\n")
else:
ch.send("something.\n")
found = True
if not found:
ch.send("Nothing.\n")
interp.register_command(interp.cmd_type('equipment', do_equipment, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1))
import logging
logger = logging.getLogger()
import game_utils
import merc
import interp
# 'Wimpy' originally by Dionysos.
def do_wimpy(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg:
wimpy = ch.max_hit // 5
else:
wimpy = int(arg)
if wimpy < 0:
ch.send("Your courage exceeds your wisdom.\n")
return
if wimpy > ch.max_hit // 2:
ch.send("Such cowardice ill becomes you.\n")
return
ch.wimpy = wimpy
ch.send("Wimpy set to %d hit points.\n" % wimpy)
return
interp.register_command(interp.cmd_type('wimpy', do_wimpy, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1))
handler_game.act("$E can't hear you.", ch, None, victim, merc.TO_CHAR)
return
if not victim.is_npc() and not victim.desc:
handler_game.act("$E is currently link dead.", ch, None, victim,
merc.TO_CHAR)
return
if victim.channels.is_set(merc.CHANNEL_TELL):
if victim.is_npc() or ch.is_npc() or not game_utils.str_cmp(
ch.name, victim.marriage):
handler_game.act("$E can't hear you.", ch, None, victim,
merc.TO_CHAR)
return
handler_game.act("#WYou tell $N '$t'.#n", ch, argument, victim,
merc.TO_CHAR)
handler_game.act("#W$n tells you '$t'.#n", ch, argument, victim,
merc.TO_VICT, merc.POS_DEAD)
victim.reply = ch
interp.register_command(
interp.CmdType(name="tell",
cmd_fun=cmd_tell,
position=merc.POS_MEDITATING,
level=0,
log=merc.LOG_NORMAL,
show=True,
default_arg=""))
if not item:
ch.send("You are not carrying that item.\n")
return
victim = item.chobj
if not item:
ch.send("There is nobody bound in that item.\n")
return
ch.send("Ok.\n")
victim.obj_vnum = 0
item.chobj = None
victim.chobj = None
victim.affected_by.rem_bit(merc.AFF_POLYMORPH)
victim.extra.rem_bit(merc.EXTRA_OSWITCH)
victim.morph = ""
handler_game.act("A white vapour pours out of $p and forms into $n.",
victim, item, None, merc.TO_ROOM)
handler_game.act("Your spirit floats out of $p and reforms its body.",
victim, item, None, merc.TO_CHAR)
interp.register_command(
interp.CmdType(name="release",
cmd_fun=cmd_release,
position=merc.POS_DEAD,
level=1,
log=merc.LOG_NEVER,
show=True,
default_arg=""))
and d.character.in_room and ch.can_see(d.character) \
and ch.can_see_room(d.character.in_room.instance_id):
victim = d.character
count += 1
if d.original:
ch.send("%3d) %s (in the body of %s) is in %s [[%d]]\n" %
(count, d.original.name, victim.short_descr,
victim.in_room.name, victim.in_room.vnum))
else:
ch.send("%3d) %s is in %s [[%d]]\n" %
(count, victim.name, victim.in_room.name,
victim.in_room.vnum))
return
found = False
for victim in instance.characters.values():
if victim.in_room and argument in victim.name:
found = True
count += 1
ch.send("%3d) [[%5d]] %-28s [[%5d]] %s\n" %
(count, 0 if not victim.is_npc() else victim.vnum,
victim.short_descr if victim.is_npc() else victim.name,
victim.in_room.vnum, victim.in_room.name))
if not found:
handler_game.act("You didn't find any $T.", ch, None, argument,
merc.TO_CHAR)
interp.register_command(
interp.cmd_type('mwhere', do_mwhere, merc.POS_DEAD, merc.IM,
merc.LOG_NORMAL, 1))
state_checks.WAIT_STATE(ch, sn.beats)
if random.randint(1, 99) > ch.get_skill(sn.name):
ch.send("You lost your concentration.\n")
if ch.is_pc():
ch.check_improve(sn, False, 1)
ch.mana -= mana // 2
else:
ch.mana -= mana
if ch.is_npc() or ch.guild.fMana:
# class has spells
sn.spell_fun(sn, ch.level, ch, vo, target)
else:
sn.spell_fun(sn, 3 * ch.level // 4, ch, vo, target)
if ch.is_pc():
ch.check_improve(sn, True, 1)
if (sn.target == merc.TAR_CHAR_OFFENSIVE or (sn.target == merc.TAR_OBJ_CHAR_OFF and target == merc.TARGET_CHAR)) \
and victim != ch and victim.master != ch:
for vch_id in ch.in_room.people[:]:
vch = instance.characters[vch_id]
if victim == vch and not victim.fighting:
fight.check_killer(victim, ch)
fight.multi_hit(victim, ch, merc.TYPE_UNDEFINED)
break
return
interp.register_command(
interp.cmd_type('cast', do_cast, merc.POS_FIGHTING, 0, merc.LOG_NORMAL, 1))
import logging
logger = logging.getLogger()
import interp
import merc
import database
def do_tableload(ch, argument):
if not argument:
ch.send("Reloading all tables.")
database.read.read_tables(ch)
interp.register_command(
interp.cmd_type('tableload', do_tableload, merc.POS_DEAD, merc.ML,
merc.LOG_ALWAYS, 1))
ch.send("OFF\n")
ch.send("prompt ")
if ch.comm.is_set(merc.COMM_PROMPT):
ch.send("ON\n")
else:
ch.send("OFF\n")
ch.send("combine items ")
if ch.comm.is_set(merc.COMM_COMBINE):
ch.send("ON\n")
else:
ch.send("OFF\n")
if not ch.act.is_set(merc.PLR_CANLOOT):
ch.send("Your corpse is safe from thieves.\n")
else:
ch.send("Your corpse may be looted.\n")
if ch.act.is_set(merc.PLR_NOSUMMON):
ch.send("You cannot be summoned.\n")
else:
ch.send("You can be summoned.\n")
if ch.act.is_set(merc.PLR_NOFOLLOW):
ch.send("You do not welcome followers.\n")
else:
ch.send("You accept followers.\n")
interp.register_command(
interp.cmd_type('autolist', do_autolist, merc.POS_DEAD, 0, merc.LOG_NORMAL,
1))
def do_question(ch, argument):
if not argument:
if ch.comm.is_set(merc.COMM_NOQUESTION):
ch.send("Q/A channel is now ON.\n")
ch.comm.rem_bit(merc.COMM_NOQUESTION)
else:
ch.send("Q/A channel is now OFF.\n")
ch.comm.set_bit(merc.COMM_NOQUESTION)
else: # question sent, turn Q/A on if it isn't already
if ch.comm.is_set(merc.COMM_QUIET):
ch.send("You must turn off quiet mode first.\n")
return
if ch.comm.is_set(merc.COMM_NOCHANNELS):
ch.send("The gods have revoked your channel privileges.\n")
return
ch.comm.rem_bit(merc.COMM_NOQUESTION)
ch.send("You question '%s'\n" % argument)
for d in merc.descriptor_list:
victim = handler_ch.CH(d)
if d.is_connected(nanny.con_playing) and d.character != ch \
and not victim.comm.is_set(merc.COMM_NOQUESTION) and not state_checks.IS_SET(victim.comm,
merc.COMM_QUIET):
handler_game.act("$n questions '$t'", ch, argument,
d.character, merc.TO_VICT, merc.POS_SLEEPING)
interp.register_command(
interp.cmd_type('question', do_question, merc.POS_SLEEPING, 0,
merc.LOG_NORMAL, 1))
import logging
logger = logging.getLogger()
import merc
import interp
import instance
def do_areas(ch, argument):
if argument:
ch.send("No argument is used with this command.\n")
return
col = 0
for iArea in instance.areas.values():
ch.send("%-39s" % iArea.credits)
col += 1
if col % 2 == 0:
ch.send("\n")
interp.register_command(interp.cmd_type('areas', do_areas, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1))
#
# Much time and thought has gone into this software, and you are
# benefiting. We hope that you share your changes too. What goes
# around, comes around.
import database.write.write_tables as write
import game_utils
import interp
import merc
def cmd_tabledump(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg or not game_utils.str_cmp(arg, "confirm"):
ch.send("Usage: tableload confirm\n")
return
ch.send("Dumping all tables.\n")
write.write_tables(ch)
interp.register_command(
interp.CmdType(name="tabledump",
cmd_fun=cmd_tabledump,
position=merc.POS_DEAD,
level=12,
log=merc.LOG_ALWAYS,
show=True,
default_arg=""))
logger = logging.getLogger()
import merc
import interp
import handler_game
import instance
def do_gtell(ch, argument):
if not argument:
ch.send("Tell your group what?\n")
return
if ch.comm.is_set(merc.COMM_NOTELL):
ch.send("Your message didn't get through!\n")
return
found = False
for gch in instance.characters.values():
if gch.is_same_group(ch):
handler_game.act("$n tells the group '$t'", ch, argument, gch, merc.TO_VICT, merc.POS_SLEEPING)
found = True
if found:
handler_game.act("$n tells the group '$t'", ch, argument, ch, merc.TO_CHAR, merc.POS_SLEEPING)
else:
ch.send("You do not have a group.\n")
return
interp.register_command(interp.cmd_type('gtell', do_gtell, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type(';', do_gtell, merc.POS_DEAD, 0, merc.LOG_NORMAL, 0))
vch = handler_ch.ch_desc(d)
if vch:
vch.save(logout=True, force=True)
comm.close_socket(d)
if pywars.server:
pywars.server.stop()
# noinspection PyUnusedLocal
def cmd_shutdow(ch, argument):
ch.send("If you want to SHUTDOWN, spell it out.\n")
interp.register_command(
interp.CmdType(name="shutdown",
cmd_fun=cmd_shutdown,
position=merc.POS_DEAD,
level=10,
log=merc.LOG_ALWAYS,
show=True,
default_arg=""))
interp.register_command(
interp.CmdType(name="shutdow",
cmd_fun=cmd_shutdow,
position=merc.POS_DEAD,
level=10,
log=merc.LOG_NORMAL,
show=False,
default_arg=""))
fch = instance.characters[fch_id]
if not portal or portal.value[0] == -1:
# no following through dead portals
continue
if fch.master == ch and state_checks.IS_AFFECTED(fch, merc.AFF_CHARM) \
and fch.position < merc.POS_STANDING:
fch.do_stand("")
if fch.master == ch and fch.position == merc.POS_STANDING:
if state_checks.IS_SET(ch.in_room.room_flags, merc.ROOM_LAW) \
and (state_checks.IS_NPC(fch) and fch.act.is_set(merc.ACT_AGGRESSIVE)):
handler_game.act("You can't bring $N into the city.", ch, None, fch, merc.TO_CHAR)
handler_game.act("You aren't allowed in the city.", fch, None, None, merc.TO_CHAR)
continue
handler_game.act("You follow $N.", fch, None, ch, merc.TO_CHAR)
fch.do_enter(argument)
if portal and portal.value[0] == -1:
handler_game.act("$p fades out of existence.", ch, portal, None, merc.TO_CHAR)
if ch.in_room == old_room:
handler_game.act("$p fades out of existence.", ch, portal, None, merc.TO_ROOM)
elif old_room.people:
handler_game.act("$p fades out of existence.", old_room.people, portal, None, merc.TO_CHAR)
handler_game.act("$p fades out of existence.", old_room.people, portal, None, merc.TO_ROOM)
portal.extract()
return
ch.send("Nope, can't do it.\n")
return
interp.register_command(interp.cmd_type('enter', do_enter, merc.POS_STANDING, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type('go', do_enter, merc.POS_STANDING, 0, merc.LOG_NORMAL, 0))
import logging
logger = logging.getLogger()
import merc
import interp
def do_commands(ch, argument):
col = 0
for key, cmd in interp.cmd_table.items():
if cmd.level < merc.LEVEL_HERO and cmd.level <= ch.trust and cmd.show:
ch.send("%-12s" % key)
col += 1
if col % 6 == 0:
ch.send("\n")
if col % 6 != 0:
ch.send("\n")
return
interp.register_command(
interp.cmd_type('commands', do_commands, merc.POS_DEAD, 0, merc.LOG_NORMAL,
1))
logger = logging.getLogger()
import merc
import interp
import game_utils
def do_trust(ch, argument):
argument, arg1 = game_utils.read_word(argument)
argument, arg2 = game_utils.read_word(argument)
if not arg1 or not arg2 or not arg2.isdigit():
ch.send("Syntax: trust <char> <level>.\n")
return
victim = ch.get_char_world(arg1)
if not victim:
ch.send("That player is not here.\n")
return
level = int(arg2)
if level < 0 or level > merc.MAX_LEVEL:
ch.send("Level must be 0 (reset) or 1 to %d.\n" % merc.MAX_LEVEL)
return
if level > ch.trust:
ch.send("Limited to your trust.\n")
return
victim.trust = level
return
interp.register_command(interp.cmd_type('trust', do_trust, merc.POS_DEAD, merc.ML, merc.LOG_ALWAYS, 1))
# these copyright notices.
#
# Much time and thought has gone into this software, and you are
# benefiting. We hope that you share your changes too. What goes
# around, comes around.
import interp
import merc
# Contributed by Alander.
# noinspection PyUnusedLocal
def cmd_visible(ch, argument):
ch.affect_strip("invisibility")
ch.affect_strip("mass invis")
ch.affect_strip("sneak")
ch.affected_by.rem_bit(merc.AFF_HIDE)
ch.affected_by.rem_bit(merc.AFF_INVISIBLE)
ch.affected_by.rem_bit(merc.AFF_SNEAK)
ch.send("Ok.\n")
interp.register_command(
interp.CmdType(name="visible",
cmd_fun=cmd_visible,
position=merc.POS_SLEEPING,
level=0,
log=merc.LOG_NORMAL,
show=True,
default_arg=""))
import logging
logger = logging.getLogger()
import merc
import interp
import pyprogs
from handler_game import act
def do_say(ch, argument):
if not argument:
ch.send("Say what?\n")
return
act("$n says '$T'", ch, None, argument, merc.TO_ROOM)
act("You say '$T'", ch, None, argument, merc.TO_CHAR)
pyprogs.emit_signal('say', actor=ch, argument=argument, audience=ch.in_room.people)
return
interp.register_command(interp.cmd_type('say', do_say, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type("'", do_say, merc.POS_RESTING, 0, merc.LOG_NORMAL, 0))
import logging
logger = logging.getLogger()
import handler_ch
import interp
import merc
def do_north(ch, argument):
handler_ch.move_char(ch, merc.DIR_NORTH, False)
return
interp.register_command(
interp.cmd_type('north', do_north, merc.POS_STANDING, 0, merc.LOG_NEVER,
0))
import logging
logger = logging.getLogger()
import merc
import interp
import handler_game
def do_report(ch, argument):
ch.send("You say 'I have %d/%d hp %d/%d mana %d/%d mv %d xp.'\n" % (
ch.hit, ch.max_hit,
ch.mana, ch.max_mana,
ch.move, ch.max_move,
ch.exp ))
buf = "$n says 'I have %d/%d hp %d/%d mana %d/%d mv %d xp.'" % (
ch.hit, ch.max_hit,
ch.mana, ch.max_mana,
ch.move, ch.max_move,
ch.exp )
handler_game.act(buf, ch, None, None, merc.TO_ROOM)
return
interp.register_command(interp.cmd_type('report', do_report, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
ch.send("You can train:")
if ch.perm_stat[merc.STAT_STR] < ch.get_max_train(merc.STAT_STR):
ch.send(" str")
if ch.perm_stat[merc.STAT_INT] < ch.get_max_train(merc.STAT_INT):
ch.send(" int")
if ch.perm_stat[merc.STAT_WIS] < ch.get_max_train(merc.STAT_WIS):
ch.send(" wis")
if ch.perm_stat[merc.STAT_DEX] < ch.get_max_train(merc.STAT_DEX):
ch.send(" dex")
if ch.perm_stat[merc.STAT_CON] < ch.get_max_train(merc.STAT_CON):
ch.send(" con")
ch.send(" hp mana")
return
if ch.perm_stat[stat] >= ch.get_max_train(stat):
handler_game.act("Your $T is already at maximum.", ch, None, pOutput,
merc.TO_CHAR)
return
if cost > ch.train:
ch.send("You don't have enough training sessions.\n")
return
ch.train -= cost
ch.perm_stat[stat] += 1
handler_game.act("Your $T increases!", ch, None, pOutput, merc.TO_CHAR)
handler_game.act("$n's $T increases!", ch, None, pOutput, merc.TO_ROOM)
return
interp.register_command(
interp.cmd_type('train', do_train, merc.POS_RESTING, 0, merc.LOG_NORMAL,
1))
# string an obj
obj = ch.get_item_world(arg1)
if not obj:
ch.send("Nothing like that in heaven or earth.\n")
return
if "name".startswith(arg2):
obj.name = arg3
return
if "short".startswith(arg2):
obj.short_descr = arg3
return
if "long".startswith(arg2):
obj.description = arg3
return
if "extended".startswith(arg2) or "ed".startswith(arg2):
argument, arg3 = game_utils.read_word(argument)
if argument is None:
ch.send("Syntax: oset <object> ed <keyword> <string>\n")
return
argument += "\n"
ed = world_classes.ExtraDescrData()
ed.keyword = arg3
ed.description = argument
obj.extra_descr.append(ed)
return
# echo bad use message
ch.do_string("")
interp.register_command(interp.cmd_type('string', do_string, merc.POS_DEAD, merc.L5, merc.LOG_ALWAYS, 1))
def cmd_alignment(ch, argument):
argument, arg = game_utils.read_word(argument)
if ch.is_npc():
return
if not arg:
ch.send("Please enter 'good', 'neutral', or 'evil'.\n")
return
align_list = [("good", 1000, "angelic"), ("neutral", 0, "neutral"), ("evil", -1000, "satanic")]
for (aa, bb, cc) in align_list:
if game_utils.str_cmp(arg, aa):
ch.alignment = bb
ch.send("Alignment is now {}.\n".format(cc))
return
else:
ch.cmd_alignment("")
interp.register_command(
interp.CmdType(
name="alignment",
cmd_fun=cmd_alignment,
position=merc.POS_DEAD, level=0,
log=merc.LOG_NORMAL, show=True,
default_arg=""
)
)
import logging
logger = logging.getLogger()
import interp
import merc
import database
def do_tableload(ch, argument):
if not argument:
ch.send("Reloading all tables.")
database.read.read_tables(ch)
interp.register_command(interp.cmd_type('tableload', do_tableload, merc.POS_DEAD, merc.ML, merc.LOG_ALWAYS, 1))
if ch.vampaff.is_set(merc.VAM_CHANGED):
ch.cmd_change("human")
if ch.polyaff.is_set(merc.POLY_SERPENT):
ch.cmd_serpent("")
ch.powers[merc.UNI_RAGE] = 0
ch.blood = blood
ch.send("Colour returns to your skin and you warm up a little.\n")
handler_game.act("Colour returns to $n's skin.", ch, None, None,
merc.TO_ROOM)
ch.ch_class = state_checks.prefix_lookup(const.class_table, "human")
ch.vampaff.set_bit(merc.VAM_MORTAL)
return
ch.send("You skin pales and cools.\n")
handler_game.act("$n's skin pales slightly.", ch, None, None, merc.TO_ROOM)
ch.ch_class = state_checks.prefix_lookup(const.class_table, "vampire")
ch.vampaff.rem_bit(merc.VAM_MORTAL)
interp.register_command(
interp.CmdType(name="mortal",
cmd_fun=cmd_mortal,
position=merc.POS_FIGHTING,
level=3,
log=merc.LOG_NORMAL,
show=True,
default_arg=""))
return
victim = ch.fighting
if victim:
skill = ch.get_skill("recall")
if random.randint(1, 99) < 80 * skill / 100:
if ch.is_pc():
ch.check_improve( "recall", False, 6)
state_checks.WAIT_STATE(ch, 4)
ch.send("You failed!.\n")
return
lose = 25 if ch.desc else 50
update.gain_exp(ch, 0 - lose)
if ch.is_pc():
ch.check_improve( "recall", True, 4)
ch.send("You recall from combat! You lose %d exps.\n" % lose)
fight.stop_fighting(ch, True)
ch.move /= 2
handler_game.act("$n disappears.", ch, None, None, merc.TO_ROOM)
ch.in_room.get(ch)
location.put(ch)
handler_game.act("$n appears in the room.", ch, None, None, merc.TO_ROOM)
ch.do_look("auto")
if ch.pet is not None:
ch.pet.do_recall("")
return
interp.register_command(interp.cmd_type("recall", do_recall, merc.POS_FIGHTING, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type("/", do_recall, merc.POS_FIGHTING, 0, merc.LOG_NORMAL, 0))
if ch.level != 3 and not ch.act.is_set(merc.PLR_GODLESS):
ch.send("Sorry, you must be level 3.\n")
return
if ch.act.is_set(merc.PLR_GODLESS) and game_utils.str_cmp(arg, "off"):
ch.act.rem_bit(merc.PLR_GODLESS)
ch.send("You now obey the gods.\n")
comm.info("{} now follows the whims of the gods.".format(ch.name))
elif not ch.act.is_set(merc.PLR_GODLESS) and game_utils.str_cmp(
arg, "off"):
ch.send("But you already obey the gods!\n")
elif not ch.act.is_set(merc.PLR_GODLESS) and game_utils.str_cmp(arg, "on"):
ch.act.set_bit(merc.PLR_GODLESS)
ch.send("You no longer obey the gods.\n")
comm.info("{} has rejected the gods.".format(ch.name))
elif ch.act.is_set(merc.PLR_GODLESS) and game_utils.str_cmp(arg, "on"):
ch.send("But you have already rejected the gods!\n")
else:
ch.send("Do you wish to switch it ON or OFF?\n")
interp.register_command(
interp.CmdType(name="godless",
cmd_fun=cmd_godless,
position=merc.POS_DEAD,
level=3,
log=merc.LOG_ALWAYS,
show=True,
default_arg=""))
import logging
logger = logging.getLogger()
import merc
import interp
import settings
import handler_game
# RT anti-newbie code
def do_newlock(ch, argument):
if not settings.NEWLOCK:
handler_game.wiznet("$N locks out new characters.", ch, None, 0, 0, 0)
ch.send("New characters have been locked out.\n")
settings.NEWLOCK = True
else:
handler_game.wiznet("$N allows new characters back in.", ch, None, 0, 0, 0)
ch.send("Newlock removed.\n")
settings.NEWLOCK = False
return
interp.register_command(interp.cmd_type('newlock', do_newlock, merc.POS_DEAD, merc.L4, merc.LOG_ALWAYS, 1))
ch.send("You can only clone mobiles.\n")
return
if (mob.level > 20 and not state_checks.IS_TRUSTED(ch, merc.L4)) \
or (mob.level > 10 and not state_checks.IS_TRUSTED(ch, merc.L5)) \
or (mob.level > 5 and not state_checks.IS_TRUSTED(ch, merc.L6)) \
or (mob.level > 0 and not state_checks.IS_TRUSTED(ch, merc.L7)) \
or not state_checks.IS_TRUSTED(ch, merc.L8):
ch.send("Your powers are not great enough for such a task.\n")
return
clone = object_creator.create_mobile(mob.vnum)
object_creator.clone_mobile(mob, clone)
for obj in mob.contents:
if handler_item.item_check(ch, obj):
new_obj = object_creator.create_item(obj.vnum, 0)
object_creator.clone_item(obj, new_obj)
handler_item.recursive_clone(ch, obj, new_obj)
new_obj.put(clone)
new_obj.equips_to = obj.equips_to
clone.put(ch.in_room)
handler_game.act("$n has created $N.", ch, None, clone, merc.TO_ROOM)
handler_game.act("You clone $N.", ch, None, clone, merc.TO_CHAR)
handler_game.wiznet("$N clones %s." % clone.short_descr, ch, None,
merc.WIZ_LOAD, merc.WIZ_SECURE, ch.trust)
return
interp.register_command(
interp.cmd_type('clone', do_clone, merc.POS_DEAD, merc.L5, merc.LOG_ALWAYS,
1))
# dex */
chance += ch.stat(merc.STAT_DEX)
chance -= victim.stat(merc.STAT_DEX) * 3 // 2
# speed */
if (ch.is_npc() and ch.off_flags.is_set(merc.OFF_FAST)) or ch.is_affected(merc.AFF_HASTE):
chance += 10
if (victim.is_npc() and victim.off_flags.is_set(merc.OFF_FAST)) or victim.is_affected( merc.AFF_HASTE):
chance -= 20
# level */
chance += (ch.level - victim.level) * 2
# now the attack */
if random.randint(1,99) < chance:
handler_game.act("$n trips you and you go down!",ch,None,victim, merc.TO_VICT)
handler_game.act("You trip $N and $N goes down!",ch,None,victim, merc.TO_CHAR)
handler_game.act("$n trips $N, sending $M to the ground.",ch,None,victim, merc.TO_NOTVICT)
if ch.is_pc():
ch.check_improve('trip', True, 1)
state_checks.DAZE_STATE(victim,2 * merc.PULSE_VIOLENCE)
state_checks.WAIT_STATE(ch,const.skill_table['trip'].beats)
victim.position = merc.POS_RESTING
fight.damage(ch,victim,random.randint(2, 2 + 2 * victim.size),'trip', merc.DAM_BASH,True)
else:
fight.damage(ch,victim,0,'trip', merc.DAM_BASH,True)
state_checks.WAIT_STATE(ch,const.skill_table['trip'].beats*2 // 3)
if ch.is_pc():
ch.check_improve('trip', False, 1)
fight.check_killer(ch,victim)
interp.register_command(interp.cmd_type('trip', do_trip, merc.POS_FIGHTING, 0, merc.LOG_NORMAL, 1))
# benefiting. We hope that you share your changes too. What goes
# around, comes around.
import handler_game
import interp
import merc
# noinspection PyUnusedLocal
def cmd_unpolymorph(ch, argument):
if not ch.is_affected("polymorph"):
ch.send("But you are not polymorphed!\n")
return
handler_game.act("$n's body begins to distort.", ch, None, None,
merc.TO_ROOM)
ch.affect_strip("polymorph")
handler_game.act("$n resumes $s normal form.", ch, None, None,
merc.TO_ROOM)
ch.send("You resume your normal form.\n")
interp.register_command(
interp.CmdType(name="unpolymorph",
cmd_fun=cmd_unpolymorph,
position=merc.POS_STANDING,
level=4,
log=merc.LOG_NORMAL,
show=True,
default_arg=""))
import logging
logger = logging.getLogger()
import merc
import interp
import game_utils
def do_pecho(ch, argument):
argument, arg = game_utils.read_word(argument)
if not argument or not arg:
ch.send("Personal echo what?\n")
return
victim = ch.get_char_world(arg)
if not victim:
ch.send("Target not found.\n")
return
if victim.trust >= ch.trust != merc.MAX_LEVEL:
victim.send("personal> ")
argument = argument.strip()
victim.send(argument)
victim.send("\n")
ch.send("personal> ")
ch.send(argument)
ch.send("\n")
interp.register_command(interp.cmd_type('pecho', do_pecho, merc.POS_DEAD, merc.L4, merc.LOG_ALWAYS, 1))
import logging
logger = logging.getLogger()
import merc
import interp
# afk command
def do_afk(ch, argument):
if ch.comm.is_set(merc.COMM_AFK):
ch.send("AFK mode removed. Type 'replay' to see tells.\n")
ch.comm.rem_bit(merc.COMM_AFK)
else:
ch.send("You are now in AFK mode.\n")
ch.comm.set_bit(merc.COMM_AFK)
interp.register_command(interp.cmd_type('afk', do_afk, merc.POS_SLEEPING, 0, merc.LOG_NORMAL, 1))
logger = logging.getLogger()
import merc
import interp
import game_utils
import instance
def do_mfind(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg:
ch.send("Find whom?\n")
return
fAll = False # !str_cmp( arg, "all" )
found = False
nMatch = 0
# Yeah, so iterating over all vnum's takes 10,000 loops.
# Get_mob_index is fast, and I don't feel like threading another link.
# Do you?
# -- Furey
for pMobIndex in instance.npc_templates.values():
if fAll or game_utils.is_name(arg, pMobIndex.name):
found = True
ch.send("[[%5d]] %s\n" % (pMobIndex.vnum, pMobIndex.short_descr))
if not found:
ch.send("No mobiles by that name.\n")
return
interp.register_command(interp.cmd_type('mfind', do_mfind, merc.POS_DEAD, merc.L4, merc.LOG_NORMAL, 1))
# RT set replaces sset, mset, oset, and rset
def do_set(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg:
ch.send("Syntax:\n")
ch.send(" set mob <name> <field> <value>\n")
ch.send(" set obj <name> <field> <value>\n")
ch.send(" set room <room> <field> <value>\n")
ch.send(" set skill <name> <spell or skill> <value>\n")
return
if "character".startswith(arg) or "mobile".startswith(arg):
ch.do_mset(argument)
return
if "spell".startswith(arg) or "skill".startswith(arg):
ch.do_sset(argument)
return
if "object".startswith(arg):
ch.do_oset(argument)
return
if "room".startswith(arg):
ch.do_rset(argument)
return
# echo syntax
ch.do_set("")
interp.register_command(interp.cmd_type('set', do_set, merc.POS_DEAD, merc.L2, merc.LOG_ALWAYS, 1))
if not state_checks.IS_SET(ch.wiznet, merc.WIZ_ON):
buf += "off "
for name, flag in const.wiznet_table.items():
if state_checks.IS_SET(ch.wiznet, flag.bit):
buf += name + " "
ch.send("Wiznet status:\n%s\n" % buf)
return
if "show".startswith(argument):
# list of all wiznet options
buf = ''
for name, flag in const.wiznet_table.items():
if flag.level <= ch.trust:
buf += name + " "
ch.send("Wiznet options available to you are:\n%s\n" % buf)
return
flag = state_checks.prefix_lookup(const.wiznet_table, argument)
if not flag or ch.trust < flag.level:
ch.send("No such option.\n")
return
if state_checks.IS_SET(ch.wiznet, flag.bit):
ch.send("You will no longer see %s on wiznet.\n" % flag.name)
ch.wiznet = state_checks.REMOVE_BIT(ch.wiznet, flag.bit)
return
else:
ch.send("You will now see %s on wiznet.\n" % flag.name)
ch.wiznet = state_checks.SET_BIT(ch.wiznet, flag.bit)
return
interp.register_command(interp.cmd_type('wiznet', do_wiznet, merc.POS_DEAD, merc.IM, merc.LOG_NORMAL, 1))
if item.questmaker:
ch.send("You cannot bind someone into a modified item.\n")
return
if item.chobj:
ch.send("That item already has someone bound in it.\n")
return
ch.send("Ok.\n")
handler_game.act("$n transforms into a white vapour and pours into $p.",
victim, item, None, merc.TO_ROOM)
handler_game.act("You transform into a white vapour and pour into $p.",
victim, item, None, merc.TO_CHAR)
victim.obj_vnum = item.vnum
item.chobj = victim
victim.chobj = item
victim.affected_by.set_bit(merc.AFF_POLYMORPH)
victim.extra.set_bit(merc.EXTRA_OSWITCH)
victim.morph = item.short_descr
interp.register_command(
interp.CmdType(name="bind",
cmd_fun=cmd_bind,
position=merc.POS_DEAD,
level=10,
log=merc.LOG_ALWAYS,
show=True,
default_arg=""))
def do_at(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg or not argument:
ch.send("At where what?\n")
return
location = game_utils.find_location(ch, arg)
if not location:
ch.send("No such location.\n")
return
if not ch.is_room_owner(location) and location.is_private() \
and ch.trust < merc.MAX_LEVEL:
ch.send("That room is private right now.\n")
return
original = ch.in_room
on = ch.on
original.get(ch)
location.put(ch)
ch.interpret(argument)
# See if 'ch' still exists before continuing!
# Handles 'at XXXX quit' case.
for wch in instance.characters.values():
if wch == ch:
location.get(ch)
original.put(ch)
ch.on = on
break
interp.register_command(interp.cmd_type('at', do_at, merc.POS_DEAD, merc.L6, merc.LOG_NORMAL, 1))
"Oomph! $n squeezes water out of a granite boulder.",
"$n picks $s teeth with a spear.",
"You are swept off your feet by $n's hug.",
"$n's karate chop splits a tree.",
"A strap of $n's armor breaks over $s mighty thews.",
"A boulder cracks at $n's frown.",
"Mercenaries arrive to do $n's bidding.",
"Four matched Percherons bring in $n's chariot.",
"Atlas asks $n to relieve him.",
),
},
}
def do_pose(ch, argument):
if ch.is_npc():
return
band = merc.LEVEL_HERO // len(pose_table['to_ch'][ch.guild.name])
level = min(ch.level, merc.LEVEL_HERO) // band
choice = random.randint(0, level)
handler_game.act(pose_table['to_ch'][ch.guild.name][choice], ch, None,
None, merc.TO_CHAR)
handler_game.act(pose_table['to_others'][ch.guild.name][choice], ch, None,
None, merc.TO_ROOM)
return
interp.register_command(
interp.cmd_type('pose', do_pose, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
logger = logging.getLogger()
import merc
import interp
import nanny
import state_checks
import handler_game
def do_immtalk(ch, argument):
if not argument:
if ch.comm.is_set(merc.COMM_NOWIZ):
ch.send("Immortal channel is now ON\n")
ch.comm.rem_bit(merc.COMM_NOWIZ)
else:
ch.send("Immortal channel is now OFF\n")
ch.comm.set_bit(merc.COMM_NOWIZ)
return
ch.comm.rem_bit(merc.COMM_NOWIZ)
handler_game.act("$n: $t", ch, argument, None, merc.TO_CHAR, merc.POS_DEAD)
for d in merc.descriptor_list:
if d.is_connected(nanny.con_playing) and state_checks.IS_IMMORTAL(d.character) \
and not state_checks.IS_SET(d.character.comm, merc.COMM_NOWIZ):
handler_game.act("$n: $t", ch, argument, d.character, merc.TO_VICT, merc.POS_DEAD)
interp.register_command(interp.cmd_type('immtalk', do_immtalk, merc.POS_DEAD, merc.IM, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type(':', do_immtalk, merc.POS_DEAD, merc.IM, merc.LOG_NORMAL, 0))
def cmd_mwhere(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg:
ch.send("Mwhere whom?\n")
return
buf = []
found = False
for victim in list(instance.npcs.values()):
if victim.in_room and game_utils.is_name(arg, victim.name):
found = True
buf += "[{:5}] {:<28} [{:5}] {}\n".format(victim.vnum, victim.short_descr, victim.in_room.vnum, victim.in_room.name)
if not found:
buf += "You didn't find any {}.".format(arg)
ch.send("".join(buf))
interp.register_command(
interp.CmdType(
name="mwhere",
cmd_fun=cmd_mwhere,
position=merc.POS_DEAD, level=8,
log=merc.LOG_NORMAL, show=True,
default_arg=""
)
)
ch.train -= cost
ch.perm_mana += 10
ch.max_mana += 10
ch.mana += 10
handler_game.act("Your power increases!", ch, None, None, merc.TO_CHAR)
handler_game.act("$n's power increases!", ch, None, None, merc.TO_ROOM)
return
else:
ch.send("You can train:")
if ch.perm_stat[merc.STAT_STR] < ch.get_max_train(merc.STAT_STR): ch.send(" str")
if ch.perm_stat[merc.STAT_INT] < ch.get_max_train(merc.STAT_INT): ch.send(" int")
if ch.perm_stat[merc.STAT_WIS] < ch.get_max_train(merc.STAT_WIS): ch.send(" wis")
if ch.perm_stat[merc.STAT_DEX] < ch.get_max_train(merc.STAT_DEX): ch.send(" dex")
if ch.perm_stat[merc.STAT_CON] < ch.get_max_train(merc.STAT_CON): ch.send(" con")
ch.send(" hp mana")
return
if ch.perm_stat[stat] >= ch.get_max_train(stat):
handler_game.act("Your $T is already at maximum.", ch, None, pOutput, merc.TO_CHAR)
return
if cost > ch.train:
ch.send("You don't have enough training sessions.\n")
return
ch.train -= cost
ch.perm_stat[stat] += 1
handler_game.act("Your $T increases!", ch, None, pOutput, merc.TO_CHAR)
handler_game.act("$n's $T increases!", ch, None, pOutput, merc.TO_ROOM)
return
interp.register_command(interp.cmd_type('train', do_train, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
import interp
import instance
def do_wear(ch, argument):
argument, arg = game_utils.read_word(argument)
if not arg:
ch.send("Wear, wield, or hold what?\n")
return
if arg == "all":
for item_id in ch.items:
item = instance.items.get(item_id, None)
if ch.can_see_item(item):
ch.equip(item, False, verbose_all=True)
return
else:
item = ch.get_item_carry(arg, ch)
if not item:
ch.send("You do not have that item.\n")
return
ch.equip(item, True, verbose=True, verbose_all=True)
return
interp.register_command(
interp.cmd_type('wield', do_wear, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
interp.register_command(
interp.cmd_type('hold', do_wear, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
interp.register_command(
interp.cmd_type('wear', do_wear, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
mob = practitioner
if ch.practice <= 0:
ch.send("You have no practice sessions left.\n")
return
skill = state_checks.prefix_lookup(const.skill_table, argument)
if not skill or not ch.is_npc() \
and (ch.level < skill.skill_level[ch.guild.name] or ch.learned[skill.name] < 1 \
or skill.rating[ch.guild.name] == 0):
ch.send("You can't practice that.\n")
return
adept = 100 if ch.is_npc() else ch.guild.skill_adept
if ch.learned[skill.name] >= adept:
ch.send("You are already learned at %s.\n" % skill.name)
else:
ch.practice -= 1
ch.learned[skill.name] += const.int_app[ch.stat(merc.STAT_INT)].learn // skill.rating[
ch.guild.name]
if ch.learned[skill.name] < adept:
handler_game.act("You practice $T.", ch, None, skill.name, merc.TO_CHAR)
handler_game.act("$n practices $T.", ch, None, skill.name, merc.TO_ROOM)
else:
ch.learned[skill.name] = adept
handler_game.act("You are now learned at $T.", ch, None, skill.name, merc.TO_CHAR)
handler_game.act("$n is now learned at $T.", ch, None, skill.name, merc.TO_ROOM)
return
interp.register_command(interp.cmd_type('practice', do_practice, merc.POS_SLEEPING, 0, merc.LOG_NORMAL, 1))
handler_game.act("$n places a gag over your mouth.", ch, None, victim,
merc.TO_VICT)
victim.extra.set_bit(merc.EXTRA_GAGGED)
return
if ch == victim:
handler_game.act("You remove the gag from your mouth.", ch, None,
victim, merc.TO_CHAR)
handler_game.act("$n removes the gag from $s mouth.", ch, None, victim,
merc.TO_ROOM)
victim.extra.rem_bit(merc.EXTRA_GAGGED)
return
handler_game.act("You remove the gag from $N's mouth.", ch, None, victim,
merc.TO_CHAR)
handler_game.act("$n removes the gag from $N's mouth.", ch, None, victim,
merc.TO_NOTVICT)
handler_game.act("$n removes the gag from your mouth.", ch, None, victim,
merc.TO_VICT)
victim.extra.rem_bit(merc.EXTRA_GAGGED)
interp.register_command(
interp.CmdType(name="gag",
cmd_fun=cmd_gag,
position=merc.POS_STANDING,
level=3,
log=merc.LOG_NORMAL,
show=True,
default_arg=""))
import logging
logger = logging.getLogger()
import merc
import interp
def do_holylight(ch, argument):
if ch.is_npc():
return
if ch.act.is_set(merc.PLR_HOLYLIGHT):
ch.act.rem_bit(merc.PLR_HOLYLIGHT)
ch.send("Holy light mode off.\n")
else:
ch.act.set_bit(merc.PLR_HOLYLIGHT)
ch.send("Holy light mode on.\n")
return
interp.register_command(interp.cmd_type('holylight', do_holylight, merc.POS_DEAD, merc.IM, merc.LOG_NORMAL, 1))
def do_grats(ch, argument):
if not argument:
if ch.comm.is_set(merc.COMM_NOGRATS):
ch.send("Grats channel is now ON.\n")
ch.comm.rem_bit(merc.COMM_NOGRATS)
else:
ch.send("Grats channel is now OFF.\n")
ch.comm.set_bit(merc.COMM_NOGRATS)
else: # grats message sent, turn grats on if it isn't already
if ch.comm.is_set(merc.COMM_QUIET):
ch.send("You must turn off quiet mode first.\n")
return
if ch.comm.is_set(merc.COMM_NOCHANNELS):
ch.send("The gods have revoked your channel priviliges.\n")
return
ch.comm.rem_bit(merc.COMM_NOGRATS)
ch.send("You grats '%s'\n" % argument)
for d in merc.descriptor_list:
victim = handler_ch.CH(d)
if d.is_connected(nanny.con_playing) \
and d.character != ch \
and not victim.comm.is_set(merc.COMM_NOGRATS)\
and not victim.comm.is_set(merc.COMM_QUIET):
handler_game.act("$n grats '$t'", ch, argument, d.character,
merc.TO_VICT, merc.POS_SLEEPING)
interp.register_command(
interp.cmd_type('grats', do_grats, merc.POS_SLEEPING, 0, merc.LOG_NORMAL,
1))
if state_checks.IS_SET(container.value[1], merc.CONT_CLOSED):
handler_game.act("The $d is closed.", ch, None, container.name, merc.TO_CHAR)
return
if not arg1.startswith('all'):
# 'get obj container'
item = ch.get_item_list(arg1, container.inventory)
if not item is None:
handler_game.act("I see nothing like that in the $T.", ch, None, arg2, merc.TO_CHAR)
return
handler_item.get_item(ch, item, container)
else:
# 'get all container' or 'get all.obj container'
found = False
for item_id in container.inventory[:]:
item = instance.items[item_id]
if (len(arg1) == 3 or arg1[4:] in item.name) and ch.can_see_item(item):
found = True
if container.vnum == merc.OBJ_VNUM_PIT and not ch.is_immortal():
ch.send("Don't be so greedy!\n")
return
handler_item.get_item(ch, item, container)
if not found:
if len(arg1) == 3:
handler_game.act("I see nothing in the $T.", ch, None, arg2, merc.TO_CHAR)
else:
handler_game.act("I see nothing like that in the $T.", ch, None, arg2, merc.TO_CHAR)
interp.register_command(interp.cmd_type('get', do_get, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type('take', do_get, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
ch.do_play("list")
elif obj.item_type == merc.ITEM_MONEY:
if obj.value[0] == 0:
if obj.value[1] == 0:
buf = "Odd...there's no coins in the pile.\n"
elif obj.value[1] == 1:
buf = "Wow. One gold coin.\n"
else:
buf = "There are %d gold coins in the pile.\n" % obj.value[
1]
elif obj.value[1] == 0:
if obj.value[0] == 1:
buf = "Wow. One silver coin.\n"
else:
buf = "There are %d silver coins in the pile.\n" % obj.value[
0]
else:
buf = "There are %d gold and %d silver coins in the pile.\n" % (
obj.value[1], obj.value[0])
ch.send(buf)
elif obj.item_type == merc.ITEM_DRINK_CON \
or obj.item_type == merc.ITEM_CONTAINER \
or obj.item_type == merc.ITEM_CORPSE_NPC \
or obj.item_type == merc.ITEM_CORPSE_PC:
ch.do_look("in %s" % arg)
interp.register_command(
interp.cmd_type('examine', do_examine, merc.POS_RESTING, 0,
merc.LOG_NORMAL, 1))
import logging
logger = logging.getLogger()
import merc
import interp
def do_autoloot(ch, argument):
if ch.is_npc():
return
if ch.act.is_set(merc.PLR_AUTOLOOT):
ch.send("Autolooting removed.\n")
ch.act.rem_bit(merc.PLR_AUTOLOOT)
else:
ch.send("Automatic corpse looting set.\n")
ch.act.set_bit(merc.PLR_AUTOLOOT)
interp.register_command(interp.cmd_type('autoloot', do_autoloot, merc.POS_DEAD, 0, merc.LOG_NORMAL, 1))
#
# Ported to Python by Davion of MudBytes.net using Miniboa
# (https://code.google.com/p/miniboa/).
#
# In order to use any part of this Merc Diku Mud, you must comply with
# both the original Diku license in 'license.doc' as well the Merc
# license in 'license.txt'. In particular, you may not remove either of
# these copyright notices.
#
# Much time and thought has gone into this software, and you are
# benefiting. We hope that you share your changes too. What goes
# around, comes around.
import interp
import merc
def cmd_shout(ch, argument):
ch.talk_channel(argument, merc.CHANNEL_SHOUT, "shout")
ch.wait_state(merc.PULSE_VIOLENCE)
interp.register_command(
interp.CmdType(name="shout",
cmd_fun=cmd_shout,
position=merc.POS_SITTING,
level=0,
log=merc.LOG_NORMAL,
show=True,
default_arg=""))
skills.gn_add(ch, gn)
handler_game.act("$N trains you in the art of $t", ch, gn.name, trainer, merc.TO_CHAR)
ch.train -= gn.rating[ch.guild.name]
return
if argument.lower() in const.skill_table:
sn = const.skill_table[argument.lower()]
if sn.spell_fun is not None:
handler_game.act("$N tells you 'You must learn the full group.'", ch, None, trainer, merc.TO_CHAR)
return
if sn.name in ch.learned:
handler_game.act("$N tells you 'You already know that skill!'", ch, None, trainer, merc.TO_CHAR)
return
if sn.rating[ch.guild.name] <= 0:
handler_game.act("$N tells you 'That skill is beyond your powers.'", ch, None, trainer, merc.TO_CHAR)
return
if ch.train < sn.rating[ch.guild.name]:
handler_game.act("$N tells you 'You are not yet ready for that skill.'", ch, None, trainer, merc.TO_CHAR)
return
# add the skill
ch.learned[sn.name] = 1
handler_game.act("$N trains you in the art of $t", ch, sn.name, trainer, merc.TO_CHAR)
ch.train -= sn.rating[ch.guild.name]
return
handler_game.act("$N tells you 'I do not understand...'", ch, None, trainer, merc.TO_CHAR)
return
interp.register_command(interp.cmd_type('gain', do_gain, merc.POS_STANDING, 0, merc.LOG_NORMAL, 1))
import logging
logger = logging.getLogger()
import handler_game
import merc
import interp
def do_emote(ch, argument):
if not ch.is_npc() and ch.comm.is_set(merc.COMM_NOEMOTE):
ch.send("You can't show your emotions.\n")
return
if not argument:
ch.send("Emote what?\n")
return
handler_game.act("$n $T", ch, None, argument, merc.TO_ROOM)
handler_game.act("$n $T", ch, None, argument, merc.TO_CHAR)
return
interp.register_command(interp.cmd_type('emote', do_emote, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
interp.register_command(interp.cmd_type(',', do_emote, merc.POS_RESTING, 0, merc.LOG_NORMAL, 0))
import random
import logging
logger = logging.getLogger()
import merc
import interp
def do_hide(ch, argument):
ch.send("You attempt to hide.\n")
if ch.is_affected(merc.AFF_HIDE):
ch.affected_by.rem_bit(merc.AFF_HIDE)
if random.randint(1, 99) < ch.get_skill("hide"):
ch.affected_by.set_bit(merc.AFF_HIDE)
if ch.is_pc():
ch.check_improve( "hide", True, 3)
else:
if ch.is_pc():
ch.check_improve( "hide", False, 3)
return
interp.register_command(interp.cmd_type('hide', do_hide, merc.POS_RESTING, 0, merc.LOG_NORMAL, 1))
ch.send("Ok.\n")
return
victim = ch.get_char_world(arg)
if not victim:
ch.send("They aren't here.\n")
return
if not victim.is_npc():
if ch == victim:
ch.send("Ho ho ho.\n")
return
if ch.trust <= victim.trust:
ch.send("Maybe that wasn't a good idea...\n")
victim.send("%s tried to purge you!\n" % ch.name)
return
handler_game.act("$n disintegrates $N.", ch, 0, victim, merc.TO_NOTVICT)
if victim.level > 1:
victim.save(logout=True, force=True)
d = victim.desc
victim.in_room.get(victim)
victim.extract(True)
if d:
comm.close_socket(d)
return
handler_game.act("$n purges $N.", ch, None, victim, merc.TO_NOTVICT)
victim.extract(True)
return
interp.register_command(interp.cmd_type('purge', do_purge, merc.POS_DEAD, merc.L4, merc.LOG_ALWAYS, 1))
