sleepermud/lib/pymodules/movement.py

'''
movement.py

all of the functions concerned with movement and position change
'''
import inform, hooks, mudsys, mud



# a ranking of positions
positions     = ["unconscious", "sleeping", "sitting", "standing", "flying"]
pos_act       = ["collapse",   "sleep",    "sit",     "stand",    "fly"]

# stuff for handling movement
dir_name = ["north", "east", "south", "west", "northeast", "northwest",
                 "southwest", "southeast", "up", "down"]
dir_abbr = ["n", "e", "s", "w", "ne", "nw", "sw", "se", "u", "d"]
dir_opp  = [  2,   3,   0,   1,   6,     7,    4,    5,   9,   8]



def try_use_furniture(ch, obj, pos):
    '''attempts to resituate a person on the piece of furniture'''
    # are we already on it?
    if ch.on == obj:
        ch.send("You are already " +ch.on.furniture_type+ " " +ch.on.name+ ".")
    # make sure we have room
    elif obj.furniture_capacity <= len(obj.chars):
        ch.send("There isn't any room left.")
    else:
        # are we already on something? get up first
        if ch.on:
            mud.message(ch,None,ch.on,None,True,"to_char",
                        "You stand up from $o.")
            mud.message(ch,None,ch.on,None,True,"to_room",
                        "$n stands up from $o.")
            ch.on = None

        # send our mud.messages for sitting down
        act = pos_act[positions.index(pos)]
        mud.message(ch, None, obj, None, True,
                    "to_char", "You " + act + " " + obj.furniture_type + " $o.")
        mud.message(ch, None, obj, None, True,
                    "to_room", "$n " + act + " " + obj.furniture_type + " $o.")

        # place ourselves down on our new furniture
        ch.on  = obj
        ch.pos = pos
        return True

    # we didn't manage to get on the furniture
    return False

def try_change_pos(ch, pos):
    '''this function attempts to change the position of the person'''
    if ch.pos == pos:
        ch.send("You are already " + pos + ".")
        return False
    else:
        if ch.pos == "flying":
            mud.message(ch,None,None,None,True, "to_char", "You stop flying.")
            mud.message(ch,None,None,None,True, "to_room", "$n stops flying.")

        act = pos_act[positions.index(pos)]
        mud.message(ch, None, None, None, True, "to_char", "You " + act + ".")
        mud.message(ch, None, None, None, True, "to_room", "$n "  + act + "s.")
        ch.pos = pos
        return True

def cmd_sit(ch, cmd, arg):
    '''If standing, attempts to sit on the ground.'''
    try:
        obj, = mud.parse_args(ch, True, cmd, arg, "| [on] obj.room")
    except: return

    if obj == None:
        try_change_pos(ch, "sitting")
    elif obj.istype("furniture"):
        try_use_furniture(ch, obj, "sitting")
    else:
        ch.send("You cannot sit on " + ch.see_as(obj) + ".")

def cmd_sleep(ch, cmd, arg):
    '''If awake, attempts to lay down and sleep.'''
    try:
        obj, = mud.parse_args(ch, True, cmd, arg, "| [on] obj.room")
    except: return

    if obj == None:
        try_change_pos(ch, "sleeping")
    elif obj.istype("furniture"):
        try_use_furniture(ch, obj, "sleeping")
    else:
        ch.send("You cannot sleep on " + ch.see_as(obj) + ".")

def cmd_stand(ch, cmd, arg):
    '''If sitting, attempts to stand. If flying, attempts to land.'''
    try_change_pos(ch, "standing")

def cmd_wake(ch, cmd, arg):
    '''If sleep, attempts to wake up and sit.'''
    mud.message(ch,None,None,None,True, "to_char",
                "You stop sleeping and sit up.")
    mud.message(ch,None,None,None,True, "to_room",
                "$n stops sleeping and sits up.")
    ch.pos = "sitting"

def dir_opposite(dir):
    '''returns the opposite direction of the specified one, or None if none.'''
    try:
        return dir_name[dir_opp[dir_index(dir)]]
    except: return None

def dir_index(dir):
    '''returns the index of the direction name'''
    try:
        return dir_name.index(dir)
    except: pass
    try:
        return dir_abbr.index(dir)
    except: pass
    return -1

def try_move_mssg(ch, dir):
    '''Handles all moving of characters from one room to another, through
       commands. Attempts a move. If successful, returns the exit left through.
       Informs people of our moving'''
    ex, success = try_move(ch, dir, True)
    return ex

def try_move(ch, dir, mssg = False):
    '''Handles all moving of characters from one room to another, through
       commands. Attempts a move. If successful, returns the exit left
       through.'''
    ex      = ch.room.exit(dir)
    success = False

    exname = "it"
    if ex != None and ex.name != "":
        exname = ex.name
    
    # did we find an exit?
    if ex == None or not ch.cansee(ex):
        ch.send("Alas, there is no exit in that direction.")
    elif ex.is_closed:
        ch.send("You will have to open " + exname + " first.")
    elif ex.dest == None:
        ch.send("It doesn't look like " + exname + " leads anywhere!")
    else:
        old_room = ch.room
        dirnum   = dir_index(dir)

        # send out our leave mud.messages as needed. Is anyone in the old room?
        if mssg == True:
            if ex.leave_mssg != '':
                mud.message(ch, None, None, None, True, "to_room",ex.leave_mssg)
            elif dirnum == -1:
                mud.message(ch, None, None, None, True, "to_room", "$n leaves.")
            else:
                mud.message(ch, None, None, None, True, "to_room",
                            "$n leaves " + dir_name[dirnum] + ".")

        # run our leave hooks
        hooks.run("exit", hooks.build_info("ch rm ex", (ch, ch.room, ex)))

        # if a hook hasn't moved us, go through with going through the exit
        if ch.room == old_room:
            ch.room = ex.dest

        # stuff that happens before we 'look'
        hooks.run("pre_enter", hooks.build_info("ch rm", (ch, ch.room)))
            
        ch.act("look")

        # send out our enter mud.messages as needed
        if mssg == True:
            if ex.enter_mssg != '':
                mud.message(ch,None,None,None,True,"to_room",ex.enter_mssg)
            elif dirnum == -1:
                mud.message(ch,None,None,None,True,"to_room","$n has arrived.")
            else:
                mud.message(ch, None, None, None, True, "to_room",
                            "$n arrives from the "+dir_name[dir_opp[dirnum]]+".")

        # run our enter hooks
        hooks.run("enter", hooks.build_info("ch rm", (ch, ch.room)))
        success = True

    # return the exit we found (if we found any)
    return ex, success

def cmd_move(ch, cmd, arg):
    '''A basic movement command, relocating you to another room in the
       specified direction.'''
    # cmd_move is the basic entry to all of the movement utilities.
    # See try_move() in movement.py
    try_move_mssg(ch, cmd)



################################################################################
# mud commands
################################################################################
mudsys.add_cmd("north",     "n",  cmd_move, "player", True)
mudsys.add_cmd("west",      "w",  cmd_move, "player", True)
mudsys.add_cmd("east",      "e",  cmd_move, "player", True)
mudsys.add_cmd("south",     "s",  cmd_move, "player", True)
mudsys.add_cmd("up",        "u",  cmd_move, "player", True)
mudsys.add_cmd("down",      "d",  cmd_move, "player", True)
mudsys.add_cmd("northwest", None, cmd_move, "player", True)
mudsys.add_cmd("northeast", None, cmd_move, "player", True)
mudsys.add_cmd("southwest", None, cmd_move, "player", True)
mudsys.add_cmd("southeast", None, cmd_move, "player", True)
mudsys.add_cmd("nw",        None, cmd_move, "player", True)
mudsys.add_cmd("ne",        None, cmd_move, "player", True)
mudsys.add_cmd("sw",        None, cmd_move, "player", True)
mudsys.add_cmd("se",        None, cmd_move, "player", True)

mudsys.add_cmd("wake",      None, cmd_wake, "player", True)
mudsys.add_cmd("sleep",     None, cmd_sleep,"player", True)
mudsys.add_cmd("stand",     None, cmd_stand,"player", True)
mudsys.add_cmd("land",      None, cmd_stand,"player", True)
mudsys.add_cmd("sit",       None, cmd_sit,  "player", True)

# The mud needs to know our command for movement as well
mudsys.set_cmd_move(cmd_move)

# useful mud methods
mud.dir_opposite = dir_opposite

def chk_can_move(ch, cmd):
    if not ch.pos in ["standing", "flying"]:
        ch.send("You cannot do that while " + ch.pos + "!")
        return False

for cmd in ["north", "west", "east", "south", "up", "down", "northwest",
            "northeast", "southwest", "southeast", "nw", "ne", "sw", "se"]:
    mudsys.register_dflt_move_cmd(cmd)
mudsys.register_move_check(chk_can_move)

def chk_wake(ch, cmd):
    if not ch.pos == "sleeping":
        ch.send("You must be asleep to wake up.")
        return False
mudsys.add_cmd_check("wake", chk_wake)

def chk_sleep(ch, cmd):
    if ch.pos == "sleeping":
        ch.send("You are already sleeping!")
        return False
    elif ch.pos == "unconscious":
        ch.send("You cannot sleep while you are unconscious.")
        return False
mudsys.add_cmd_check("sleep", chk_sleep)

def chk_stand(ch, cmd):
    if ch.pos == "standing":
        ch.send("You are already standing!")
        return False
    elif ch.pos != "sitting":
        ch.send("You cannot stand while " + ch.pos + ".")
        return False
mudsys.add_cmd_check("stand", chk_stand)

def chk_land(ch, cmd):
    if ch.pos == "standing":
        ch.send("You are already on the ground!")
        return False
    elif ch.pos != "flying":
        ch.send("You cannot land if you are not flying.")
        return False
mudsys.add_cmd_check("land", chk_land)

def chk_sit(ch, cmd):
    if ch.pos == "sitting":
        ch.send("You are already sitting!")
        return False
    elif ch.pos != "standing":
        ch.send("You must be standing to sit.")
        return False
mudsys.add_cmd_check("sit", chk_sit)