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))