Skins: |

NWN SCRIPTS

- Jump to comments -

Title

Scripting Library: Game Time v1.0

Author

psychospaz

Submitted / Updated

09-27-2005 / 11-22-2006

Category

Scripting routines

Expansions

Works on all versions

View Code

//::///////////////////////////////////////////////
//:: gameTime Library
//:: include_time
//:://////////////////////////////////////////////
/*
        This allows the coder to do time specific
    calculations quickly and easily as well as
    storing said times as variable on users and
    retrieving them for latter use.
        The default Time and Calendar functions are
    used but only for GetModuleTime.
*/
//:://////////////////////////////////////////////
//:: Created By: psychospaz
//:://////////////////////////////////////////////

struct gameTime
{
    int MS;
    int Sec;
    int Min;
    int Hour;
    int Day;
    int Month;
    int Year;
};

//  GetTimeSum(oldTime, addTime)
//  * Returns (gameTime = oldTime + addTime)
struct gameTime GetTimeSum(struct gameTime oldTime, struct gameTime addTime);

//  GetTimeDifference(oldTime, addTime)
//  * Returns abs(gameTime = oldTime - subTime)
//  *
//  * The result of this is always a positive gameTime, being the difference
//  * between oldTime and subTime
struct gameTime GetTimeDifference(struct gameTime oldTime, struct gameTime subTime);

//This crap is here so i dont have to calc how many gay (game) minutes per hour
int GetMinutesPerHour() { return FloatToInt(HoursToSeconds(1)/60.0); }

// GetTimeString(tTime, nLevel)
//  * tTime:    Time Variable
//  * nLevel:   Number of SubVars Displayed (3: Days, Hours, Minutes)
//  *               if (< 1) then Nothing will be shown
//  * nCaps:          Time output will be done with capital first letter.
//  * nYears:         Years will be shown if existing
//  * nMonths:        Months will be shown if existing
//  * nDays:          Days will be shown if existing
//  * nHours:         Hours will be shown if existing
//  * nMinutes:       Minutes will be shown if existing
//  * nSeconds:       Seconds will be shown if existing
//  * nMilliSeconds:  Milliseconds will be shown if existing
//  *
//  * Example Output: "2 Years, 1 Month, 12 Days, 4 Hours and 1 Minute"
string TimeToString(struct gameTime tTime, int nLevel = 1, int nCaps = FALSE, int nYears = TRUE, int nMonths = TRUE, int nDays = TRUE, int nHours = TRUE, int nMinutes = TRUE, int nSeconds = TRUE, int nMilliSeconds = TRUE);
string TimeToString(struct gameTime tTime, int nLevel = 1, int nCaps = FALSE, int nYears = TRUE, int nMonths = TRUE, int nDays = TRUE, int nHours = TRUE, int nMinutes = TRUE, int nSeconds = TRUE, int nMilliSeconds = TRUE)
{
    int nLast;
    string sMsg;

    if (tTime.Year>0 && nLevel>0 && nYears)
    {
        sMsg += IntToString(tTime.Year)+((nCaps)?" Year":" year");
        if (tTime.Year>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }
    if (tTime.Month>0 && nLevel>0 && nMonths)
    {
        if (nLast) sMsg += (nLevel==1)? " and ": ", ";
        sMsg += IntToString(tTime.Month)+((nCaps)?" Month":" month");
        if (tTime.Month>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }
    if (tTime.Day>0 && nLevel>0 && nDays)
    {
        if (nLast) sMsg += (nLevel==1)? " and ": ", ";
        sMsg += IntToString(tTime.Day)+((nCaps)?" Day":" day");
        if (tTime.Day>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }
    if (tTime.Hour>0 && nLevel>0 && nHours)
    {
        if (nLast) sMsg += (nLevel==1)? " and ": ", ";
        sMsg += IntToString(tTime.Hour)+((nCaps)?" Hour":" hour");
        if (tTime.Hour>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }

    //Don't do calculations if we don't need to.
    if (nLevel<1 || (!nMinutes && !nSeconds && !nMilliSeconds))
        return sMsg;

    //This is pretty dirty, but NWN is a filthy whore, so we're even
    tTime.MS = ((tTime.Min*60 + tTime.Sec)*1000 + tTime.MS)*60/GetMinutesPerHour();
    if (tTime.MS>=1000)
    {
        tTime.Sec = tTime.MS/1000;
        tTime.MS  = tTime.MS%1000;
    }
    if (tTime.Sec>=60)
    {
        tTime.Min = tTime.Sec/60;
        tTime.Sec = tTime.Sec%60;
    }
    //The block above recalculates Min/Sec/MS since NWN has a variable Min/Hr

    if (tTime.Min>0 && nLevel>0 && nMinutes)
    {
        if (nLast) sMsg += (nLevel==1)? " and ": ", ";
        sMsg += IntToString(tTime.Min)+((nCaps)?" Minute":" minute");
        if (tTime.Min>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }
    if (tTime.Sec>0 && nLevel>0 && nSeconds)
    {
        if (nLast) sMsg += (nLevel==1)? " and ": ", ";
        sMsg += IntToString(tTime.Sec)+((nCaps)?" Second":" second");
        if (tTime.Sec>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }
    if (tTime.MS>0 && nLevel>0 && nMilliSeconds)
    {
        if (nLast) sMsg += (nLevel==1)? " and ": ", ";
        sMsg += IntToString(tTime.MS)+((nCaps)?" Millisecond":" millisecond");
        if (tTime.MS>1)
            sMsg += "s";
        nLast = TRUE;
        nLevel--;
    }
    return sMsg;
}

/*******************************************************************************
    OBJECT TIME VARIABLES
*******************************************************************************/

//  GetLocalTime(oObject, sVar)
//  * oObject: The object on which the gameTime variable is on
//  * sVar: Name of the variable
struct gameTime GetLocalTime(object oObject, string sVar);
struct gameTime GetLocalTime(object oObject, string sVar)
{
    struct gameTime modTime;
    modTime.MS =   GetLocalInt(oObject, sVar+"_DATETIME_MS");
    modTime.Sec =  GetLocalInt(oObject, sVar+"_DATETIME_SEC");
    modTime.Min =  GetLocalInt(oObject, sVar+"_DATETIME_MIN");
    modTime.Hour = GetLocalInt(oObject, sVar+"_DATETIME_HOUR");
    modTime.Day =  GetLocalInt(oObject, sVar+"_DATETIME_DAY");
    modTime.Month =GetLocalInt(oObject, sVar+"_DATETIME_MONTH");
    modTime.Year = GetLocalInt(oObject, sVar+"_DATETIME_YEAR");
    return modTime;
}

//  SetLocalTime(oObject, sVar, t)
//  * oObject: The object on which the gameTime variable is on
//  * sVar: Name of the variable
//  * dTime: The gameTime variable to be stored
void SetLocalTime(object oObject, string sVar, struct gameTime dTime);
void SetLocalTime(object oObject, string sVar, struct gameTime dTime)
{
    SetLocalInt(oObject, sVar+"_DATETIME_MS",   dTime.MS);
    SetLocalInt(oObject, sVar+"_DATETIME_SEC",  dTime.Sec);
    SetLocalInt(oObject, sVar+"_DATETIME_MIN",  dTime.Min);
    SetLocalInt(oObject, sVar+"_DATETIME_HOUR", dTime.Hour);
    SetLocalInt(oObject, sVar+"_DATETIME_DAY",  dTime.Day);
    SetLocalInt(oObject, sVar+"_DATETIME_MONTH",dTime.Month);
    SetLocalInt(oObject, sVar+"_DATETIME_YEAR", dTime.Year);
}

/*******************************************************************************
    MODULE SPECIFIC VARS
*******************************************************************************/

// GetModuleTime
// * This is the current server/game time. It returns in gameTime format to be
// * used for storage or gameTime arithmetic
struct gameTime GetModuleTime();
struct gameTime GetModuleTime()
{
    struct gameTime modTime;
    modTime.MS =   GetTimeMillisecond();
    modTime.Sec =  GetTimeSecond();
    modTime.Min =  GetTimeMinute(); //NWN is really gay
    modTime.Hour = GetTimeHour();
    modTime.Day =  GetCalendarDay();
    modTime.Month =GetCalendarMonth();
    modTime.Year = GetCalendarYear();
    return modTime;
}


/*******************************************************************************
    RETURN SPECIFIC AMOUNTS
*******************************************************************************/

// * Returns the gameTime variable's Year
int TimeToIntYears(struct gameTime t);
int TimeToIntYears(struct gameTime t)
{
    return t.Year;
}
// * Returns the gameTime variable's Month
int TimeToIntMonths(struct gameTime t);
int TimeToIntMonths(struct gameTime t)
{
    return TimeToIntYears(t)*12 + t.Month;
}
// * Returns the gameTime variable's Day
int TimeToIntDays(struct gameTime t);
int TimeToIntDays(struct gameTime t)
{
    return TimeToIntMonths(t)*28 + t.Day;
}
// * Returns the gameTime variable's Hour
int TimeToIntHours(struct gameTime t);
int TimeToIntHours(struct gameTime t)
{
    return TimeToIntDays(t)*24 + t.Hour;
}
// * Returns the gameTime variable's Minute
int TimeToIntMinutes(struct gameTime t);
int TimeToIntMinutes(struct gameTime t)
{
    return TimeToIntHours(t)*2 + t.Min;
}
// * Returns the gameTime variable's Second
int TimeToIntSeconds(struct gameTime t);
int TimeToIntSeconds(struct gameTime t)
{
    return TimeToIntMinutes(t)*60 + t.Sec;
}
// * Returns the gameTime variable's Millisecond
int TimeToIntMilliseconds(struct gameTime t);
int TimeToIntMilliseconds(struct gameTime t)
{
    return TimeToIntSeconds(t)*1000 + t.MS;
}

// CopyDateTime(toCopy)
// * returns a gameTime copy of "toCopy"
struct gameTime CopyDateTime(struct gameTime toCopy)
{
    struct gameTime tCopy;
    tCopy.MS = toCopy.MS;
    tCopy.Sec = toCopy.Sec;
    tCopy.Min = toCopy.Min;
    tCopy.Hour = toCopy.Hour;
    tCopy.Day = toCopy.Day;
    tCopy.Month = toCopy.Month;
    tCopy.Year = toCopy.Year;
    return tCopy;
}

/*******************************************************************************
    VARIABLE TO DATE
*******************************************************************************/

//  * Returns a gameTime object "nValue" with Years
struct gameTime IntToTimeYears(int nValue);
struct gameTime IntToTimeYears(int nValue)
{
    struct gameTime t1, t2;
    t1.Year = nValue;
    return GetTimeSum(t1, t2);
}
//  * Returns a gameTime object "nValue" with Months
struct gameTime IntToTimeMonths(int nValue);
struct gameTime IntToTimeMonths(int nValue)
{
    struct gameTime t1, t2;
    t1.Month = nValue;
    return GetTimeSum(t1, t2);
}
//  * Returns a gameTime object "nValue" with Days
struct gameTime IntToTimeDays(int nValue);
struct gameTime IntToTimeDays(int nValue)
{
    struct gameTime t1, t2;
    t1.Day = nValue;
    return GetTimeSum(t1, t2);
}
//  * Returns a gameTime object "nValue" with Hours
struct gameTime IntToTimeHours(int nValue);
struct gameTime IntToTimeHours(int nValue)
{
    struct gameTime t1, t2;
    t1.Hour = nValue;
    return GetTimeSum(t1, t2);
}
//  * Returns a gameTime object "nValue" with Minutes
struct gameTime IntToTimeMinutes(int nValue);
struct gameTime IntToTimeMinutes(int nValue)
{
    struct gameTime t1, t2;
    t1.Min = nValue;
    return GetTimeSum(t1, t2);
}
//  * Returns a gameTime object "nValue" with Seconds
struct gameTime IntToTimeSeconds(int nValue);
struct gameTime IntToTimeSeconds(int nValue)
{
    struct gameTime t1, t2;
    t1.Sec = nValue;
    return GetTimeSum(t1, t2);
}
//  * Returns a gameTime object "nValue" with Milliseconds
struct gameTime IntToTimeMilliseconds(int nValue);
struct gameTime IntToTimeMilliseconds(int nValue)
{
    struct gameTime t1, t2;
    t1.MS = nValue;
    return GetTimeSum(t1, t2);
}

/*******************************************************************************
    DATE ARITHMETIC - This is so we dont overflow past int or float limits
*******************************************************************************/

struct gameTime GetTimeSum(struct gameTime oldTime, struct gameTime addTime)
{
    struct gameTime newTime = CopyDateTime(oldTime);
    int nMinsPerHour = GetMinutesPerHour();

    //Calc Everything
    newTime.MS += addTime.MS;
    if (newTime.MS>=1000)
    {
        newTime.Sec+= newTime.MS/1000;
        newTime.MS  = newTime.MS%1000;
    }
    newTime.Sec += addTime.Sec;
    if (newTime.Sec>=60)
    {
        newTime.Min+= newTime.Sec/60;
        newTime.Sec = newTime.Sec%60;
    }
    newTime.Min += addTime.Min;
    if (newTime.Min>=nMinsPerHour)
    {
        newTime.Hour+= newTime.Min/nMinsPerHour;
        newTime.Min  = newTime.Min%nMinsPerHour;
    }
    newTime.Hour += addTime.Hour;
    if (newTime.Hour>=24)
    {
        newTime.Day += newTime.Hour/24;
        newTime.Hour = newTime.Hour%24;
    }
    newTime.Day += addTime.Day;
    if (newTime.Day>=28)
    {
        newTime.Month += newTime.Day/28;
        newTime.Day =    newTime.Day%28;
    }
    newTime.Month += addTime.Month;
    if (newTime.Month>=12)
    {
        newTime.Year += newTime.Month/12;
        newTime.Month = newTime.Month%12;
    }
    newTime.Year += addTime.Year;
    return newTime;
}

//This is used in GetSubtractTime to make sure we don't get a negative gameTime
int GetIsTimeSmaller(struct gameTime baseTime, struct gameTime checkTime)
{
    if (baseTime.Year < checkTime.Year)
        return TRUE;
    else if (baseTime.Month < checkTime.Month)
        return TRUE;
    else if (baseTime.Day < checkTime.Day)
        return TRUE;
    else if (baseTime.Hour < checkTime.Hour)
        return TRUE;
    else if (baseTime.Min < checkTime.Min)
        return TRUE;
    else if (baseTime.Sec < checkTime.Sec)
        return TRUE;
    else if (baseTime.MS < checkTime.MS)
        return TRUE;

    //baseTime is greater than or equal to checkTime
    return FALSE;
}

struct gameTime GetTimeDifference(struct gameTime oldTime, struct gameTime subTime)
{
    struct gameTime newTime, newSubTime;

    //Switch the direction we subtract if oldTime is smaller than subTime
    if (GetIsTimeSmaller(oldTime, subTime))
    {
        newTime = CopyDateTime(oldTime);
        newSubTime = CopyDateTime(subTime);
    }
    else
    {
        newTime = CopyDateTime(subTime);
        newSubTime = CopyDateTime(oldTime);
    }

    //Calc Everything
    newTime.MS -= newSubTime.MS;
    if (newTime.MS<0)
    {
        newTime.Sec -= 1;
        newTime.MS  += 1000;
    }
    newTime.Sec -= newSubTime.Sec;
    if (newTime.Sec<0)
    {
        newTime.Min -= 1;
        newTime.Sec += 60;
    }
    newTime.Min -= newSubTime.Min;
    if (newTime.Min<0)
    {
        newTime.Hour-= 1;
        newTime.Min += GetMinutesPerHour();
    }
    newTime.Hour -= newSubTime.Hour;
    if (newTime.Hour<0)
    {
        newTime.Day  -= 1;
        newTime.Hour += 24;
    }
    newTime.Day -= newSubTime.Day;
    if (newTime.Day<0)
    {
        newTime.Month-= 1;
        newTime.Day  += 28;
    }
    newTime.Month -= newSubTime.Month;
    if (newTime.Month<0)
    {
        newTime.Year  -= 1;
        newTime.Month += 12;
    }
    newTime.Year -= newSubTime.Year;

    return newTime;
}

// * Returns the difference between oldTime and subTime in Years
int GetTimeDifferenceYears(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceYears(struct gameTime oldTime, struct gameTime subTime)
{
    return TimeToIntYears(oldTime)-TimeToIntYears(subTime);
}
// * Returns the difference between oldTime and subTime in Months
int GetTimeDifferenceMonths(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceMonths(struct gameTime oldTime, struct gameTime subTime)
{
    return GetTimeDifferenceYears(oldTime, subTime)*12 +
           TimeToIntMonths(oldTime)-TimeToIntMonths(subTime);
}
// * Returns the difference between oldTime and subTime in Days
int GetTimeDifferenceDays(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceDays(struct gameTime oldTime, struct gameTime subTime)
{
    return GetTimeDifferenceMonths(oldTime, subTime)*28 +
           TimeToIntDays(oldTime)-TimeToIntDays(subTime);
}
// * Returns the difference between oldTime and subTime in Hours
int GetTimeDifferenceHours(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceHours(struct gameTime oldTime, struct gameTime subTime)
{
    return GetTimeDifferenceDays(oldTime, subTime)*24 +
           TimeToIntHours(oldTime)-TimeToIntHours(subTime);
}
// * Returns the difference between oldTime and subTime in Minutes
int GetTimeDifferenceMinutes(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceMinutes(struct gameTime oldTime, struct gameTime subTime)
{
    return GetTimeDifferenceHours(oldTime, subTime)*GetMinutesPerHour() +
           TimeToIntMinutes(oldTime)-TimeToIntMinutes(subTime);
}
// * Returns the difference between oldTime and subTime in Seconds
int GetTimeDifferenceSeconds(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceSeconds(struct gameTime oldTime, struct gameTime subTime)
{
    return GetTimeDifferenceMinutes(oldTime, subTime)*60 +
           TimeToIntSeconds(oldTime)-TimeToIntSeconds(subTime);
}
// * Returns the difference between oldTime and subTime in Milliseconds
int GetTimeDifferenceMilliseconds(struct gameTime oldTime, struct gameTime subTime);
int GetTimeDifferenceMilliseconds(struct gameTime oldTime, struct gameTime subTime)
{
    return GetTimeDifferenceSeconds(oldTime, subTime)*1000 +
           TimeToIntMilliseconds(oldTime)-TimeToIntMilliseconds(subTime);
}

Select All Text | View Code in separate window

Format

Code Only

Type

Type - Combat

Includes

Custom

Description

Save this as script 'include_time' in your module and then put the line '#include "include_time"' at the top of the script you want to use it in. This library will let you save game times to objects as variables, retrieve them, compare them, do arithmetic between them, and output them.
The output for game time recalculates minutes, seconds, and milliseconds to be accurate according to game time accelleration, as to give ingame time based information accurate for the gameworld.

Files

Name	Type	Size	Downloads
include_time.txtinclude_time.txt Submitted: 09-27-2005 / Last Updated: 09-28-2005	txt	16.76Kb	279
--

SCORE OUT OF 10

10
1 votes
View Stats
Cast Your Vote!

PORTFOLIO

Add this entry to your portfolio so you can track it

Manage your existing portfolios or create a new one.

SCREENS

No Images

You Must Be Logged In to Participate.

Comments (10):

Posted by Crowdosi at 2006-12-15 21:37:04

Quick question, could I use this script to store module time on an inventory item and then jump into a different module and sync the time concurrently to the last module I was in? If so, how?

Posted by psychospaz_ at 2005-10-13 09:28:26

This took me about a day to code (not the whole day). Pretty simple stuff overall.

Except for having to figure out that minutes aren't actually minutes and that I'd have to recalculate for milliseconds, seconds and minutes for accurate game time printouts. That part pissed me off.

Posted by TakKerna at 2005-10-03 22:13:07 Voted 10.00 on 10/03/05

Aw crap *rates this time*
this is perfect in my opinion, 10 for you

Posted by TakKerna at 2005-10-03 22:08:07 Voted 10.00 on 10/03/05

Man... that is some god damn fine code. If it had a reproductive system... i ... will spare you the horrible details.

Awesome job =) and just what I need at the moment, i'll make sure to give you credits, much deserved credits.
rock.

Posted by psychospaz_ at 2005-10-02 11:57:56

You need to make a new script with the contents I posted here and save it as "include_time". THEN you '#include "include_time'" in the script you want to use it in.

I just wrote this for the PW I code for, and it works quite nicely for setting time limits on actions (per hours etc) and then telling the user how long they have left until they can do it again; accurately in gametime.

Posted by Dwarf45 ( 195.204.xxx.xxx ) at 2005-10-02 08:56:14

Hey man nice script how long time u used to script that?
---ZACH LOD--DA--MASTER--KING---

Posted by Dwarf45 ( 195.204.xxx.xxx ) at 2005-10-02 08:55:40

Hey bro sorry about that "Double post"
i wanted to ask u about something where do i place the script? and i cant put in '#include "include_time"' cuz Aurora toolset dident find that file.

Posted by Dwarf45 ( 195.204.xxx.xxx ) at 2005-10-02 08:55:06

Hey bro sorry about that "Double post"
i wanted to ask u about something where do i place the script? and i cant put in '#include "include_time"' cuz Aurora toolset dident find that file.

Posted by Dwarf45 ( 195.204.xxx.xxx ) at 2005-10-02 08:52:59

Hey man nice script how long time u used to script that?
---ZACH LOD--DA--MASTER--KING---

Posted by Dwarf45 ( 195.204.xxx.xxx ) at 2005-10-02 08:46:17

Hey man nice script how long time u used to script that?
---ZACH LOD--DA--MASTER--KING---

You must be Logged In to post comments in this section.