DMH-Online

NWScript:

/*******************************************************************************
Name:      Rhone's Hour-based WayPoint Walker
Author:    Thomas J. Hamman (Rhone)
E-Mail:    hammant@panther.adelphi.edu
Filename:  RH_INC_HRWPOINTS
Version:   1.2
_Changelog_
    _v1.2 (7-27-02)_
1.  A couple things that could lead to infinite looping under certain circumstances
    have been fixed.
2.  The heartbeat script now will not try to run HourWayPoints if the NPC is in
    combat or a conversation.
3.  ActionForceMoveToObject is now used for both posts and waypoints (previously
    it was used only for posts and ActionMoveToObject was used for waypoints, which
    is what the original WalkWayPoints code uses).  If there is a PC in the area,
    the function is called with a timeout value of 60.0 (the same value used for
    posts in the original code), but now if there is no PC in the NPC's area,
    a timeout of 20.0 is used.  This means that if there is no PC in the area and
    the NPC gets "stuck", the NPC will be jumped to his next waypoint or post
    after 20 seconds.
4.  The hour numbers are now more sensible, correct, and consistent with numbers
    returned by GetTimeHour().  For some reason I used 01-24 (with 24 being midnight)
    before.  Don't ask me why--it was probably in the middle of one of my
    up-until-5am-working-on-scripts nights.  00-23 (with 00 being midnight) are
    now the numbers to use for hour-based waypoints.  This also means that 24-hour
    waypoints (which previously used "00") now use 24.  So, if you previously had
    any midnight waypoints, change the 24 to 00, and if you previously had any
    24-hour waypoints, change 00 to 24.  This goes for both the waypoint tags and
    the user-defined event numbers (e.g. WP_00_NPCTag_02 and 90002 for a second
    midnight waypoint, POST_24_NPCTag and 92400 for a 24-hour post).
5.  Ambient animations can now easily be toggled on for specific posts.  See #8
    in the list of features below for directions on how to use them.
    _v1.1 (7-19-02)_
1.  NPCs now keep track of which waypoint they were walking toward with a local
    variable.  After an interruption, they will resume heading toward the next
    waypoint instead of simply going toward the nearest waypoint.
2.  The directions (see below the description) have been changed to instruct users
    to use SignalEvent(OBJECT_SELF, UserDefinedEvent(2000)) in place of
    HourWayPoints in their scripts.  Now, to have different NPCs use HourWayPoints
    with different parameters, only their OnUserDefined scripts need to be different.
    The OnHeartbeat script provided incorporates this change, and a default
    OnUserDefined script is included now as well.
    _v1.0 (7-18-02)_
Original release.

_Description_
This is a complete rewrite of the waypoint walking system in NW_I0_GENERIC,
using the original as a rough guide.  Here are its advantages:
1.  Hour-based waypoints--the main feature.  It allows for NPCs to easily be
    given daily schedules.  The tags for hour-based waypoints and posts
    (respectively) use this format:
        WP_XX_NPCTag_YY
        POST_XX_NPCTag
    Where XX is the hour -- 00 through 23 -- and YY is the order number for the
    waypoint.  NPCTag is, of course, the tag of the NPC who uses the waypoint.
    24-hour waypoints can still be used, with 24 in place of XX, and Day/Night
    waypoints can still be used with DY (for day) and NT (for night) in place of
    XX.  You must choose one system for each NPC, though--if Bob has the waypoint
    WP_24_Bob_01 then the script will never check for day/night or hour-based
    waypoints for Bob, since that wouldn't make sense.  Likewise, if Bob has
    POST_DY_Bob then the script will not check for hour-based waypoints for
    him.
2.  Circular waypoints--follow the waypoints as, for example, 1 2 3 4 1 2 3 4,
    instead of 1 2 3 4 3 2 1.  To use this, have any script for the NPC that
    runs HourWayPoints call it with the nCircle parameter TRUE, e.g.:
        HourWayPoints(FALSE, 1.0, TRUE);
3.  Terminal waypoints--i.e. follow the waypoints through to the end once, and
    then stop.  This is done by having waypoints and a post for the same time;
    the NPC will go through the waypoints once, ending and stopping at the post.
4.  The ability to run a script at each waypoint.  This is done by putting
    a script in the NPC's OnUserDefined event, with event numbers in this format:
        9XXYY
    XX is the hour of the waypoint (00 through 23 -- or 24 for 24-hour waypoints,
    25 for day waypoints, and 26 for night waypoints), and YY is the order
    number for the waypoint (use 00 for posts).  Here are some examples:
        91200   A noon post.
        90503   The third waypoint at 5am.
        92405   The fifth 24-hour waypoint.
        92501   The first day waypoint.
        92600   An all-night post.
    This opens up a world of possibilities, starting with very simple but fun
    things like having Bob go to POST_16_Bob, which triggers his 91600 event
    that has him sit in a chair.
5.  A workaround for the current bug in the GetFacing function, which allows NPC's
    to face the correct direction at their posts.  The workaround will be harmless
    when GetFacing is fixed.
6.  NPCs remember the last waypoint they were walking toward and now walk toward
    it (rather than simply the nearest waypoint) when they resume waypoints after
    an interruption.
7.  If an NPC in an area without a PC gets "stuck" (which often happens), he will
    be jumped to his next waypoint after about 20 seconds.
8.  Ambient animations can be easily toggled on for certain posts, using a
    "nAmbientAnimations" variable on the NPC.  In the user-defined event for a
    post, simply set nAmbientAnimations for the NPC to 1 (for mobile ambient
    animations) or 2 (for immobile ambient animations).  The OnHeartbeat will
    then run the ambient animations (as long as the NPC isn't busy in combat or
    conversation).  HourWayPoints safely resets nAmbientAnimations back to 0
    whenever it sends the NPC to another waypoint/post, so the animations will
    only be used where you want them to be used and won't interrupt waypoint
    walking.
_Common issues and how to deal with them_
If you call "HourWayPoints()" in a script (which you should only be doing in the
user defined event 2000), and the compiler gives you a declaration error, try
writing out the full paramters, e.g.:  HourWayPoints(FALSE, 1.0, FALSE)
I honestly have no idea why the compiler won't let my own functions just use
default parameters.
The problem with NPCs being stuck in areas without NPCs--unable to leave their
homes and go to their workplaces, for example--is now worked around by jumping
them to their next waypoint after 20 seconds of being stuck if there's no PC in
the area.  This could be problematic, however, if you actually _want_ an NPC to
get stuck and be unable to reach a waypoint.  If you have a situation like that
planned, you can temporarily set nDontWalkWP to TRUE (using SetLocalInt) for the
NPC, which will prevent HourWayPoints from running for that NPC.  If you want NPCs
to be able to get stuck as the general rule, however, you'll have to change the
ActionForceMoveToObject functions (there are 4 of these--2 in HourRunCircuit and
2 in HourGoToPost) to ActionMoveToObject (don't forget to take out the last two
parameters, which are used in ActionForceMoveToObject but not ActionMoveToObject).
If you make that change, though, don't come crying to me when your NPCs never leave
their houses. :) 
Speaking of waypoints and areas, please note that NPCs will not go straight from
a spot in one area to a waypoint that requires crossing more than one area
transition; the pathfinding just doesn't handle that, or at least didn't in my
tests.  If you want an NPC to go from, say, the second floor of his house to a
post at the local pub (which requires at least three area transitions), put a
waypoint (number 1) in the first floor of his house, a second waypoint outside his
house, and then the post in the pub.  That way none of the ActionForceMoveTos are
trying to send him through more than one area transition.
NPC pathfinding is absolutely abysmal when they have to go through a non-transition
door.  They get to area transition doors okay, but with a non-transition door they
generally just try to walk in a straight line to their waypoint and stop when
they bump into a wall.  To avoid this problem, make the path for the NPC explicit
by placing a waypoint directly in front of the door, and the next waypoint directly
on the other side of the door.  That way the NPC will bump into the door instead
of the wall, which will trigger his OnBlocked script to open it.
There's also a friendly little bug I can take no credit for which causes NPCs
walking waypoints to sometimes head in the wrong after an area transition until
they bump into something, at which point they _then_ head to a waypoint/post.  One
workaround is to use an OnEnter script for your areas which checks to see if the
entering object isn't a PC, and if so, to run HourWayPoints() for the NPC to
send it in the right direction.
Finally, the action queue can be a bit tricky when you're making your user-defined
waypoint scripts.  All I can tell you is that sometimes you have to experiment a
bit.  If an action isn't taking its turn in the action queue like it should, or
you need something that's not explicitly an action to fit into the action queue,
try putting it in a separate function and calling it inside ActionDoCommand.
_INSTRUCTIONS for using the code_
Considering this has to replace a function in a standard include file that is
included by many default scripts (several of which call the WalkWayPoints function
which we're trying to replace), the instructions unfortunately cannot be as
simple as "just put this script in this place and you're all set."  If you're
trying this in an existing module you're working on, consider making a backup
copy first.  With that aside, here is a set of steps to follow:
1.  Save this script in the script editor with whatever name you like.  For the
    rest of these instructions I'll assume you saved it as rh_inc_hrwpoints.
2.  Open nw_i0_generic in the script editor (you'll have to click on All Resources
    for it to show up).  Yes, we must tamper with this very important include file.
    After the comments and before any of the code, put in this line:
//        #include "RH_INC_HRWPOINTS"
    (Don't include the slashes--for some reason when I try saving this the
    compiler reads the #include as if it's not commented unless I use a C++ style
    comment with it.)
3.  Still in nw_i0_generic, scroll down to the end of the DetermineCombatRounds
    function, right before the SetListeningPatterns function, and look for code
    that looks like this:
        ClearAllActions();
        SetLocalObject(OBJECT_SELF, "NW_GENERIC_LAST_ATTACK_TARGET", OBJECT_INVALID);
        WalkWayPoints();
    The line numbers where this is should be in the 750s.  Running a Find on
    "WalkWayPoints()" (without the quotes) should find it.  What you need to
    do there is change the WalkWayPoints(); line to this:
        SignalEvent(OBJECT_SELF, EventUserDefined(2000));
    Now DetermineCombatRound will use the new function to return NPCs to their
    waypoints/posts after they finish combat.  (The purpose of using SignalEvent
    will be explained.)
4.  Save the edited nw_i0_generic under a new name--for the rest of these
    instructions I'll assume you saved it as my_i0_generic.
5.  Now what's important is that any script which calls WalkWayPoints() needs to
    be changed so that it runs SignalEvent(OBJECT_SELF, EventUserDefined(2000))
    instead, and includes my_i0_generic instead of nw_i0_generic.  In particular
    you need to edit these default NPC scripts:
    nw_c2_default9:  This is the default OnSpawn script for NPCs.
                     Just change WalkWayPoints() (near the end) to the SignalEvent
                     command given above and replace the include line for
                     NW_I0_GENERIC with one that includes MY_I0_GENERIC instead.
    nw_c2_default3:  This is the default OnCombatRoundEnd script.  Just change
                     the include from NW_I0_GENERIC to MY_I0_GENERIC.
6.  Save those files.  If you are going to use the new waypoint script for just
    a few NPCs and want to use the default WalkWayPoints for the rest, then save
    those files under a new name and use those in place of the defaults for the
    appropriate NPCs.  If you want all NPCs with waypoints to use the new waypoint
    script then don't be shy about saving those files with the default names so that
    they are used automatically when you create new NPCs.  This WILL NOT hurt the
    original scripts.  The toolset's built-in scripts are kept separate from your
    own scripts, and you can easily revert to the original scripts by deleting the
    new ones of the same name.  Your "overriding" scripts also don't affect other
    modules.
7.  The OnHeartbeat script for NPCs needs some added code.  A modified OnHeartbeat
    script should be included in the Post/Archive/Whatever where you found this.
    Save that as nw_c2_default1 to use it as the default OnHeartbeat for NPCs.
8.  Now that we are using SignalEvent to trigger a userdefined event, we need to
    put event number 2000 into the OnUserDefined script.  Included where you found
    this script should be a sample OnUserDefined script; save that as nw_c2_defaultd
    to use it as the default OnUserDefined for NPCs.  Then, for any NPC that you
    want using different HourWayPoints parameters, you only have to change his
    OnUserDefined.
9.  Don't forget that NPCs need an End Conversation Script that calls
    SignalEvent(OBJECT_SELF, EventUserDefined(2000)) to have them resume their
    waypoints after conversations.
10. Recompile the module after you make those changes, and ignore any compiler
    errors given for include files (like rh_inc_hrwpoints and my_i0_generic).
Have fun with the script, I hope it works well for everyone who tries it. :) 
*******************************************************************************/
void HourWayPoints(int nRun = FALSE, float fPause = 1.0, int nCircle = FALSE);
void HourRunCircuit(string sPrefix, int nWPStart = 1, int nReverse = FALSE, int nRun=FALSE, float fPause = 1.0, int nCircle = FALSE);
void HourGoToPost(object oPost, int nRun = FALSE);
int GetEventForWP(object oWP, int nNum);
string PosIntTo2DigitString(int nNum);
float GetFacingCorrectly(object oTarget);
//This should be called in place of WalkWayPoints.  There is one extra parameter
//(nCircle), which allows NPCs to walk in a circle instead of back and forth.
void HourWayPoints(int nRun = FALSE, float fPause = 1.0, int nCircle = FALSE)
{
    //nDontWalkWP can be set in scripts to temporarily disable waypoint walking
    //for a particular NPC.
    if (GetLocalInt(OBJECT_SELF, "nDontWalkWP"))
        return;
    string sWalker = GetTag(OBJECT_SELF);
    string sWPPrefix;
    string sPostPrefix;
    int nWPStart = GetLocalInt(OBJECT_SELF, "nNextWP");
    int nDay;
    object oWP;
    object oPost;
    ClearAllActions();
    //Before we start checking the hour and day/night status, let's see if the
    //NPC uses 24-hour waypoints/post.
    sWPPrefix = "WP_24_";
    sPostPrefix = "POST_24_";
    oWP = GetObjectByTag(sWPPrefix + sWalker + "_01");
    oPost = GetObjectByTag(sPostPrefix + sWalker);
    //Send NPC to 24-hour WP or Post; resume if the NPC has already started waypoints.
    if (GetIsObjectValid(oWP)) {
        if (!nWPStart)
            nWPStart = 1;
        HourRunCircuit(sWPPrefix, nWPStart, FALSE, nRun, fPause, nCircle);
        return;
    } else if (GetIsObjectValid(oPost)) {
        HourGoToPost(oPost, nRun);
        return;
    }
    //No 24-hour waypoints or posts, so let's try night/day.
    if (GetIsDay() || GetIsDawn()) {
        sWPPrefix = "WP_DY_";
        sPostPrefix = "POST_DY_";
        nDay = 1;
    } else {
        sWPPrefix = "WP_NT_";
        sPostPrefix = "POST_NT_";
        nDay = 2;
    }
    oWP = GetObjectByTag(sWPPrefix + sWalker + "_01");
    oPost = GetObjectByTag(sPostPrefix + sWalker);
    //If the NPC has day/night waypoints or posts, send him to them.
    if (GetIsObjectValid(oWP)) {
        int nOldDay = GetLocalInt(OBJECT_SELF, "nDayPoints");
        if (!(nWPStart && nOldDay && nOldDay == nDay)) {
            SetLocalInt(OBJECT_SELF, "nDayPoints", nDay);
            nWPStart = 1;
        }
        HourRunCircuit(sWPPrefix, nWPStart, FALSE, nRun, fPause, nCircle);
        return;
    } else if (GetIsObjectValid(oPost)) {
        SetLocalInt(OBJECT_SELF, "nDayPoints", nDay);
        HourGoToPost(oPost);
        return;
    }
    //Code for hour-based waypoints starts here.
    int nHour = GetTimeHour();
    sWPPrefix = "WP_" + PosIntTo2DigitString(nHour) + "_";
    sPostPrefix = "POST_" + PosIntTo2DigitString(nHour) + "_";
    oWP = GetObjectByTag(sWPPrefix + sWalker + "_01");
    oPost = GetObjectByTag(sPostPrefix + sWalker);
    //The important thing we're doing in the following loop is checking every hour,
    //starting with the current hour and counting backwards, until we either find
    //an hour for which the NPC has waypoints to walk (so an NPC with 8am waypoints
    //will keep walking them for every hour until the next hour he has waypoints
    //set for) or we reach nLastHourWalked (at which point we don't need to look
    //back any further).
    //
    //If the NPC is running HourWayPoints for the first time (e.g. he just spawned)
    //then nStartedWaypoints isn't set yet, so we set nLastHourWalked to an hour
    //ahead of the current time--that way, every hour can be checked for waypoints.
    //
    //nLastHourChecked is being set for use in the OnHeartbeat script.
    if (!GetLocalInt(OBJECT_SELF, "nStartedWaypoints")) {
        if (nHour == 23)
            SetLocalInt(OBJECT_SELF, "nLastHourWalked", 0);
        else
            SetLocalInt(OBJECT_SELF, "nLastHourWalked", nHour + 1);
    }
    while (nHour != GetLocalInt(OBJECT_SELF, "nLastHourWalked")) {
        if (GetIsObjectValid(oWP)) {
            nWPStart = 1;
            SetLocalInt(OBJECT_SELF, "nLastHourWalked", nHour);
            SetLocalInt(OBJECT_SELF, "nLastHourChecked", GetTimeHour());
            SetLocalInt(OBJECT_SELF, "nStartedWaypoints", TRUE);
            HourRunCircuit(sWPPrefix, nWPStart, FALSE, nRun, fPause, nCircle);
            return;
        } else if (GetIsObjectValid(oPost)) {
            SetLocalInt(OBJECT_SELF, "nLastHourWalked", nHour);
            SetLocalInt(OBJECT_SELF, "nLastHourChecked", GetTimeHour());
            SetLocalInt(OBJECT_SELF, "nStartedWaypoints", TRUE);
            HourGoToPost(oPost, nRun);
            return;
        } else {
            nHour--;
            if (nHour < 0)
                nHour = 23;
            sWPPrefix = "WP_" + PosIntTo2DigitString(nHour) + "_";
            sPostPrefix = "POST_" + PosIntTo2DigitString(nHour) + "_";
            oWP = GetObjectByTag(sWPPrefix + sWalker + "_01");
            oPost = GetObjectByTag(sPostPrefix + sWalker);
        }
    }
    //If we reach nLastHourWalked before finding waypoints for later hours, we
    //check to make sure that there are valid waypoints/posts for that hour and
    //send the NPC to them if so.
    if (GetIsObjectValid(oWP)) {
        SetLocalInt(OBJECT_SELF, "nLastHourWalked", nHour);
        SetLocalInt(OBJECT_SELF, "nLastHourChecked", GetTimeHour());
        SetLocalInt(OBJECT_SELF, "nStartedWaypoints", TRUE);
        HourRunCircuit(sWPPrefix, nWPStart, FALSE, nRun, fPause, nCircle);
        return;
    }
    if (GetIsObjectValid(oPost)) {
        SetLocalInt(OBJECT_SELF, "nLastHourWalked", nHour);
        SetLocalInt(OBJECT_SELF, "nLastHourChecked", GetTimeHour());
        SetLocalInt(OBJECT_SELF, "nStartedWaypoints", TRUE);
        HourGoToPost(oPost, nRun);
        return;
    }
}
//This is the replacement for the original RunCircuit (it does not use a
//RunNextCircuit equivalent), which sends the NPC to his waypoints in order.
//
//It was originally designed with a while loop to loop through the waypoints,
//but I had to change it to loop by recursion instead.  Using a while loop, I
//was unable to get the UserDefined actions (triggered by the SignalEvent at
//each waypoint) to fit in their correct place in the action queue.  No matter
//what I tried, the scripted actions for every waypoint would run at the end of
//the circuit (right before the function called itself again).  So, I made the
//function call itself again for every waypoint, and viola, the userdefined
//actions take place when they should.
//
//Note that this functions allows for circular waypoint walking through a function
//parameter (filtered down from HourWayPoints), and it also allows for waypoints
//and a post to be set for the same time--what happens then is that the NPC walks
//his waypoints once and then goes to his post, where he stays.
void HourRunCircuit(string sPrefix, int nNext = 1, int nReverse=FALSE, int nRun=FALSE, float fPause = 1.0, int nCircle = FALSE)
{
    string sWalker = GetTag(OBJECT_SELF);
    object oWP = GetWaypointByTag(sPrefix + sWalker + "_" + PosIntTo2DigitString(nNext));
    object oPost = GetWaypointByTag("POST_" + GetSubString(sPrefix, 3, 3) + sWalker);
    object oArea = GetArea(OBJECT_SELF);
    object oNearestPCArea = GetArea(GetNearestCreature(CREATURE_TYPE_PLAYER_CHAR, PLAYER_CHAR_IS_PC, OBJECT_SELF));
    if (GetIsObjectValid(oWP)) {
        SetLocalInt(OBJECT_SELF, "nNextWP", nNext);
        SetLocalInt(OBJECT_SELF, "nAmbientAnimations", 0);
        if (oArea == oNearestPCArea)
            ActionForceMoveToObject(oWP, nRun, 1.0, 60.0);
        else
            ActionForceMoveToObject(oWP, nRun, 1.0, 20.0);
        ActionWait(fPause);
        SignalEvent(OBJECT_SELF, EventUserDefined(GetEventForWP(oWP, nNext)));
        if (!nReverse)
            nNext++;
        else
            nNext--;
    } else if (GetIsObjectValid(oPost)) {
        ActionDoCommand(HourGoToPost(oPost, nRun));
        return;
    } else {
        if (nCircle) {
            nReverse = FALSE;
            nNext = 1;
        } else {
            nReverse = !nReverse;
            if (!nReverse)
                nNext += 2;
            else
                nNext -= 2;
        }
    }
    ActionDoCommand(HourRunCircuit(sPrefix, nNext, nReverse, nRun, fPause, nCircle));
}
//Go to a Post.
void HourGoToPost(object oPost, int nRun = FALSE)
{
    object oArea = GetArea(OBJECT_SELF);
    object oNearestPCArea = GetArea(GetNearestCreature(CREATURE_TYPE_PLAYER_CHAR, PLAYER_CHAR_IS_PC, OBJECT_SELF));
    SetLocalInt(OBJECT_SELF, "nNextWP", 100);
    SetLocalInt(OBJECT_SELF, "nAmbientAnimations", 0);
    if (oArea == oNearestPCArea)
        ActionForceMoveToObject(oPost, nRun, 1.0, 60.0);
    else
        ActionForceMoveToObject(oPost, nRun, 1.0, 20.0);
    float fFacing = GetFacingCorrectly(oPost);
    ActionDoCommand(SetFacing(fFacing));
    SignalEvent(OBJECT_SELF, EventUserDefined(GetEventForWP(oPost, 0)));
}

//Convert 1, 2, 3 ... 9 ints into 01, 02, 03 ... 09 strings.
string PosIntTo2DigitString(int nNum)
{
    string sString;
    if (nNum > 9)
        return IntToString(nNum);
    else if (nNum < 10 && nNum >= 0)
        return ("0" + IntToString(nNum));
    else
        return "This function is not for negative numbers.";
}
//A workaround for GetFacing, which is currently broken.  This will cease to
//be necessary when/if Bioware fixes GetFacing, but it won't break anything.
float GetFacingCorrectly(object oTarget)
{
    float fFacing;
    fFacing = GetFacing(oTarget);
    if (fFacing >= 360.0)
        fFacing = 720.0 - fFacing;
    return fFacing;
}
//This is the function for putting together a number for an event to trigger in
//the NPC's OnUserDefined script.
int GetEventForWP(object oWP, int nNum)
{
    string sTime;
    string sNum;
    string sEventNum;
    int nEventNum;
    if (!nNum) {
        sNum = "00";
        sTime = GetSubString(GetTag(oWP), 5, 2);
    } else {
        sNum = GetStringRight(GetTag(oWP), 2);
        sTime = GetSubString(GetTag(oWP), 3, 2);
    }
    if (sTime == "DY")
        sTime = "25";
    else if (sTime == "NT")
        sTime = "26";
    sEventNum = "9" + sTime + sNum;
    nEventNum = StringToInt(sEventNum);
    return nEventNum;
}

The OnHeartbeat script:

NWScript:

//::///////////////////////////////////////////////
//:: Default On Heartbeat
//:: NW_C2_DEFAULT1
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
    This script will have people perform default
    animations.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Nov 23, 2001
//:://////////////////////////////////////////////
//This script has been altered for use with Rhone's Hour-Based Waypoint Walker.
//Default WalkWayPoints-related code has been removed and replaced with new
//code for HourWayPoints.  
//
//The new code handles rerunning HourWayPoints() (through the userdefined event)
//at the appropriate times for NPCs with day/night waypoints or hour-based waypoints.
//
//It has been updated to supported ambient animations at posts.
//--Rhone
#include "MY_I0_GENERIC"
void main()
{
    if(GetSpawnInCondition(NW_FLAG_FAST_BUFF_ENEMY))
    {
        if(TalentAdvancedBuff(40.0))
        {
            SetSpawnInCondition(NW_FLAG_FAST_BUFF_ENEMY, FALSE);
            return;
        }
    }
    //If nDay has been set, and it's not equal to the current day/night status,
    //check to see if the NPC has new waypoints/posts to walk.
    if (GetLocalInt(OBJECT_SELF, "nDayPoints")) {
        int nDay;
        if (GetIsDay() || GetIsDawn())
            nDay = 1;
        else
            nDay = 2;
        if (GetLocalInt(OBJECT_SELF, "nDayPoints") != nDay)
            SignalEvent(OBJECT_SELF, EventUserDefined(2000));
    }
    //If nLastHourChecked hasn't been set for the NPC, then he's probably not
    //walking hour-based waypoints and we don't do anything else.  If it is
    //checked, and it's not equal to the current hour, we check to see if there
    //are new waypoints.  nLastHourChecked will end up being set to the current
    //hour so OnHearbeat knows not to bother checking for new waypoints again
    //until the next hour.
    int nHour = GetTimeHour();
    int nLastHourChecked = GetLocalInt(OBJECT_SELF, "nLastHourChecked");
    if (GetLocalInt(OBJECT_SELF, "nStartedWaypoints") && nHour != nLastHourChecked
       && !GetIsInCombat(OBJECT_SELF) && !IsInConversation(OBJECT_SELF)) {
        string sWalker = GetTag(OBJECT_SELF);
        object oNewWP;
        object oNewPost;
        while (nHour != nLastHourChecked) {
            oNewWP = GetObjectByTag("WP_" + PosIntTo2DigitString(nHour) + "_" + sWalker + "_01");
            oNewPost = GetObjectByTag("POST_" + PosIntTo2DigitString(nHour) + "_" + sWalker);
            if (GetIsObjectValid(oNewWP) || GetIsObjectValid(oNewPost)) {
                nHour = GetTimeHour();
                nLastHourChecked = nHour;
            } else {
                nHour--;
                if (nHour < 0)
                    nHour = 23;
            }
        }
        if (GetIsObjectValid(oNewWP) || GetIsObjectValid(oNewPost))
            SignalEvent(OBJECT_SELF, EventUserDefined(2000));
        else
            SetLocalInt(OBJECT_SELF, "nLastHourChecked", GetTimeHour());
    }
    if(!GetHasEffect(EFFECT_TYPE_SLEEP))
    {
        if(GetLocalInt(OBJECT_SELF, "nAmbientAnimations"))
        {
            if(!GetIsObjectValid(GetAttemptedAttackTarget()) && !GetIsObjectValid(GetAttemptedSpellTarget()))
            {
                if(!GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)))
                {
                    if(!GetBehaviorState(NW_FLAG_BEHAVIOR_SPECIAL) && !IsInConversation(OBJECT_SELF))
                    {
                        if(GetLocalInt(OBJECT_SELF, "nAmbientAnimations") == 1)
                        {
                            PlayMobileAmbientAnimations();
                        }
                        else if(GetIsEncounterCreature() &&
                        !GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)))
                        {
                            PlayMobileAmbientAnimations();
                        }
                        else if(GetLocalInt(OBJECT_SELF, "nAmbientAnimations") == 2 &&
                           !GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)))
                        {
                            PlayImmobileAmbientAnimations();
                        }
                    }
                    else
                    {
                        DetermineSpecialBehavior();
                    }
                }
                else
                {
                    //DetermineCombatRound();
                }
            }
        }
    }
    else
    {
        if(GetSpawnInCondition(NW_FLAG_SLEEPING_AT_NIGHT))
        {
            effect eVis = EffectVisualEffect(VFX_IMP_SLEEP);
            if(d10() > 6)
            {
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, OBJECT_SELF);
            }
        }
    }
    if(GetSpawnInCondition(NW_FLAG_HEARTBEAT_EVENT)) {
        SignalEvent(OBJECT_SELF, EventUserDefined(1001));
    }
}

Finally, the OnUserDefined script (add case statements for your own userdefined events, of course):

NWScript:

//OnUserDefined script for NPCs using hour-based waypoints.
#include "MY_I0_GENERIC"
void main()
{
    int nEvent = GetUserDefinedEventNumber();
    switch(nEvent)
    {
        case 2000:
            HourWayPoints(FALSE, 1.0, FALSE);
            break;
    }
}

_________________
"In the global sense, bringing peace means either appeasing the needs of--or, more likely, destroying--everyone." --Guardian of Helm