Jaysyn/Aschbourne_PRC8
Jaysyn/Aschbourne_PRC8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
Aschbourne_PRC8/_module/nss/cs_rest.nss
GetOffMyYarn 69879d6957 Areas and Fixes 
Added CCOH and missing areas
Changed some areas to be craftable,
Fixed some on death issues,
Fixed the Gaurd
2024-08-30 11:38:44 -04:00

3312 lines
151 KiB
Plaintext
Raw Blame History

//============================================================================
//
// Name: CS Resting Subsystem - Main Include File
// File: cs_rest
// Author: Craig Smith (Galap) <craig@smith.dropbear.id.au>
//
// $Id: cs_rest.nss,v 1.7 2004/12/29 10:17:07 cs Exp $
// $Source: /local/cvs/nwn/resting/cs_rest.nss,v $
//
//----------------------------------------------------------------------------
// This software is distributed in the hope that it will be useful. It is
// provided "as is" WITHOUT WARRANTY OF ANY KIND, either expressed or implied,
// including, but not limited to, the implied warranties of merchantability
// and fitness for a particular purpose. You may redistribute or modify this
// software for your own purposes so long as all original credit information
// remains intact.
//----------------------------------------------------------------------------
//
// Introduction
// ------------
// The CS Resting Subsystem provides a framework for setting various popular
// forms of resting rules in a module, and allows these resting rules to be
// changed dynamically while the module is running.
//
// Installing The CS Resting Subsystem
// -----------------------------------
// To install the CS Resting Subsystem, you need to import the scripts and
// blueprints into your module. Open the module in the Aurora Toolset and
// select the File menu. Then select the Import item from the menu and
// navigate through your computer's directory structure until you locate
// the ERF file for the CS Resting Subsystem. Select the ERF file and click
// on the Ok button. If the toolset warns you about missing files with a .ncs
// extension, ignore the warning and continue--the .ncs files are compiled
// script files and will be created if necessary when you build your module.
// Once the import finishes, you have installed the CS Resting Subsystem!
//
// To use the CS Resting Subsystem in a module, you will need to change
// the module's OnPlayerRest event handler to be the "cs_rest_handler"
// script. To do this, pull down the Edit menu and select Module Properties.
// Select the Events tab and either drop down the list for the OnPlayerRest
// event to scroll through and find "cs_rest_handler", or simply delete the
// script name that is already there and type in "cs_rest_handler" in place.
// Then select the Ok button and you're done.
//
// Configuring Resting
// -------------------
// One of the design goals of the CS Resting Subsystem package is that the
// resting rules must be able to be managed and configured completely
// through the standard toolset interface *without* the need to resort to
// editing scripts. It is of course possible to extend the resting subsystem
// through writing your own resting profiles or user scripts, however if you
// choose to do so, you will also need to manage any configuration for your
// own resting extension. For most situations, however, the standard resting
// subsystem should be sufficient.
//
// To this end, configuration is handled through the use of a container and
// special items. I personally use chests but any placeable object with an
// inventory will work. Place the container object somewhere in your module
// and then change its tag to be "CS_REST_GLOBAL_CONFIG". Since this container
// is accessed by tag, it may be placed anywhere in the module though it
// should be placed somewhere that players cannot access. I recommend creating
// a DM room area and placing things like this global config container there.
//
// Once you have a placed the container with the correct tag, you now need
// to place the custom configuration items into the container, and modify
// any of the item tags as required for your needs. Items that represent
// integer values must have their tags set to the integer itself. Some other
// items require their tags to be set to strings such as the names of scripts.
//
// Once you have created the configuration container and put all of the desired
// configuration items into its inventory, the resting subsystem will function
// as specified by the items. This particular container is referred to as the
// global configuration container, but the resting subsystem allows the use of
// other configuration containers as well (see Other Configuration Facilities
// for more details). The custom configuration items are found under the
// "Special|Custom4" category of the Custom items palette.
//
// NOTE: If you don't place the global configuration container and set the
// "CS Rest: Enable" and "CS Rest: Default Profile" items as the absolute
// minimum configuration, the CS Resting Subsystem will *not* function and
// the standard Bioware default resting will remain in place.
//
// The complete list of available items, with descriptions, follows.
//
// CS Rest: Enable
// Default value: FALSE
// Enabled the resting subsystem, enforcing the rules as configured through
// the use of these items. The resting subsystem is *disabled* by default
// and one of these items *must* be placed in a configuration container
// before it will function. To use this item, you simply place it in the
// configuration container's inventory. No change to this item's tag is
// required. This item is the opposite of the Disable item below and only
// one of the two may be used at the same time.
// CS Rest: Disable
// Default value: TRUE
// Disable the resting subsystem, returning the player to the standard
// Bioware resting rules if placed in the global configuration container,
// or just causing an area or trigger configuration container to be
// ignored. To use this item, you simply place it in the configuration
// container's inventory. No change to this item's tag is required. This
// item is the opposite of the Enable item above and only one of the two
// may be used at the same time.
// CS Rest: Default Profile
// Default value: Not set
// Sets the name of the resting profile script to be executed by default
// when a player is not within a resting trigger. The tag of this item
// should be set to the name of one of the standard profile scripts:
// cs_rest_cnt This script disallows resting completely
// cs_rest_cmp This script allows resting
// cs_rest_rom This script only allows resting when in a room with
// all doors closed.
// One of these items *must* be placed in the global config container with
// its tag set correctly or the resting subsystem will fail to operate in
// an expected manner. It it of course possible to write your own scripts
// for handling resting profile. See Creating Your Own Resting Profile
// for further information, though please note that there is no need to
// create new resting profiles in most situations (and most probably *all*
// situations, since I can't think of any more).
// CS Rest: Standard HP
// Default value: TRUE
// Use the standard Bioware-style of HP regain and allow the player to
// regain all lost hit points after resting. To use this item, you simply
// place it in the configuration container's inventory. No change to this
// item's tag is required. This item is the opposite of the 3rd Ed Style HP
// item below and only one of the two may be used at the same time.
// CS Rest: 3rd Ed Style HP
// Default value: FALSE
// Use a style of HP gain modelled on the 3rd edition D&D manuals, wherein
// players regain one hit point per level each time they rest. If resting
// is interrupted part way through, the player will regain hit points in
// a pro-rata fashion, i.e. if resting was half complete, the player will
// regain half the number of hit points that they would have otherwise
// To use this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. This item is the
// opposite of the Standard HP item above and only one of the two may be
// used at the same time.
// CS Rest: Day Only
// Default value: FALSE
// Sets the resting subsystem to allow resting only during daylight hours.
// To use this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. Note that this
// item is the opposite of the Night Only item below. Only one of the two
// items may be used at the same time. The All Hours below item may be
// used to reset either Day Only or Night Only operation.
// CS Rest: Night Only
// Default value: FALSE
// Sets the resting subsystem to allow resting only during night hours.
// To use this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. Note that this
// item is the opposite of the Night Only item above. Only one of the two
// items may be used at the same time. The All Hours item below may be
// used to reset either Day Only or Night Only operation.
// CS Rest: All Hours
// Default value: TRUE
// Sets the resting subsystem to allow resting at any time of the day or
// night. This item may be used after setting day only or night only
// operation to restore the resting subsystem to its default operation. To
// use this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. Note that this
// item should not be used at the same time as either the Day Only or
// Night Only items. Remove such items from the configuration container's
// inventory before placing this item.
// CS Rest: Day Start
// Default value: 6
// Sets the hour of the day at which the resting subsystem considers "day"
// to begin. When the resting subsystem is operating in Day Only mode, it
// will only allow resting after this hour, or only before this hour if
// in Night Only mode. The Day Start value may be set to any integer
// between 0 and 22 inclusive. To use this item, you must set its
// tag to an integer value.
// CS Rest: Day End
// Default value: 18
// Sets the hour of the day at which the resting subsystem considers "day"
// to end. When the resting subsystem is operating in Day Only mode, it
// will only allow resting before this hour, or only after this hour if in
// Night Only mode. The Day End value may be set to any integer between
// 1 and 23 inclusive. To use this item, you must set its tag to an
// integer value.
// CS Rest: Armour Not Allowed
// Default value: FALSE
// Stops players from resting when then are wearing rigid armour or
// helmets. Armour of AC 5 or less may be worn while resting. To use
// this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. Note that this
// item is the opposite of the Armour Allowed item below. Only one of the
// two items may be used at the same time.
// CS Rest: Armour Allowed
// Default value: TRUE
// Allow player to rest regardless of the armour they are wearing. To
// use this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. Note that this
// item is the opposite of the Armour Not Allowed item above. Only one
// of the two items may be used at the same time.
// CS Rest: Weapons Not Allowed
// Default value: FALSE
// Stops players from resting when then are carrying weapons. To use this
// item, you simply place it in the configuration container's inventory.
// No change to this item's tag is required. Note that this item is the
// opposite of the Weapons Allowed item below. Only one of the two items
// may be used at the same time.
// CS Rest: Weapons Allowed
// Default value: TRUE
// Allow player to rest regardless of whether they are armed or not. To
// use this item, you simply place it in the configuration container's
// inventory. No change to this item's tag is required. Note that this
// item is the opposite of the Weapons Not Allowed item above. Only one
// of the two items may be used at the same time.
// CS Rest: Fade Screen
// Default value: FALSE
// Fade the player's screen display to black when resting starts, and fade
// back to a visible screen again when resting finishes.
// CS Rest: 1 Minute Limit
// CS Rest: 2 Minute Limit
// CS Rest: 3 Minute Limit
// CS Rest: 4 Minute Limit
// CS Rest: 5 Minute Limit
// CS Rest: 6 Minute Limit
// CS Rest: 7 Minute Limit
// CS Rest: 8 Minute Limit
// CS Rest: 9 Minute Limit
// CS Rest: 10 Minute Limit
// CS Rest: 12 Minute Limit
// CS Rest: 14 Minute Limit
// CS Rest: 16 Minute Limit
// CS Rest: 18 Minute Limit
// CS Rest: 20 Minute Limit
// CS Rest: 25 Minute Limit
// CS Rest: 30 Minute Limit
// Default Value: No Limit
// All of these items may be used to control how frequently players may
// rest. Pick the item that matches the time limit you wish to set and
// place it into the configuration container. No change to the item's tag
// is necessary. You may only use one of these items at a time, and you
// may not use any of these items at the same time as the Rest Time Limit
// or No Limit items below.
// CS Rest: Rest Time Limit
// Default Value: No Limit
// Use this item if you wish more fine-grained control over the time limit
// between resting. Place this item in a configuration container and then
// change its tag to an integer value representing the number of seconds
// that players must wait before being allowed to rest again. You may not
// use this item at the same time as any of the time limit items above, or
// the No Limit item below.
// CS Rest: No Limit
// Default value: No Limit
// Use this item to restore the default unlimited resting behaviour like
// the standard Bioware resting system. To use this item, you simply place
// it in the configuration container's inventory. No change to this item's
// tag is required. You may not use this item at the same time as any of
// the time limit items or the Rest Time Limit item above.
// CS Rest: Bedroll In Use
// Default value: FALSE
// Use bedrolls if the player has one in his or her inventory on resting.
// When bedrolls are in use, the player only regains full hit points, as
// per the regain style in use, when they have a bedroll. If they do not
// have a bedroll, then only half the normal number of hit points will be
// regained. Bedrolls are consumable items and after being used 20 times,
// they are destroyed. To use this item, you must place it in the
// configuration container's inventory and change its tag to be the same
// as the item that is to be used as a bedroll, e.g. if you have an item
// with a tag of "BEDROLL" that you intend for players to use as a bedroll,
// then you must set the tag of *this* item to "BEDROLL" as well. This
// item is the opposite of the Bedroll Not Used item below and you may
// not use the two items at the same time. Note that there is not yet any
// persistence used for storing the number of times a bedroll has been
// used.
// CS Rest: Bedroll Not Used
// Default value: TRUE
// Allow players to rest without bedrolls with no penalty to hit point
// regain. To use this item, you simply place it in the configuration
// container's inventory. No change to this item's tag is required. This
// item is the opposite of the Bedroll In Use item above and you may not
// use the two items at the same time.
// CS Rest: Bedroll HP multiplier
// Default value: 50
// This item sets the numerical modifier applied to hit points when
// bedrolls are in use and the player does not have one. If the player
// does not have a bedroll when resting, the hitpoints regained will be
// multiplied by the value set with this item to determine the final
// number of hit points regained. To define this value, set the item's
// tag to the pecentage number for the multiplier, e.g. for half hit
// points, use 50, for a third use 33, etc. By default, this value is 50,
// so players will regain half the normal hit points when resting without
// a bedroll. If you were to set this value to 25, then players would
// regain a quarter of the number of hitpoints, and setting this value to
// 100 would mean that bedrolls would have no effect at all (which is
// kind of silly but nevertheless will work). Setting this value to 0
// will stop players from being allowed to rest at all if they do not
// have a bedroll.
// CS Rest: HP Multiplier
// Default value: 100
// This item sets a numerical value that is used as a multiplier against
// the number of hit points that a player would normally regain from
// resting *when non-standard rest modes are in use*, i.e. the number
// of hitpoints is calculated first, and then multiplied by the value
// set with this item to determine the final number of hit points regained.
// To define this value, set the item's tag to the percentage number for
// the multiplier, e.g. for half hit points, use 50, etc. By default,
// this value is 100 (i.e. 100% or full hit points) and will have no effect
// on the hit points regained by players. If you were to set this value to
// 200, then players would regain twice the number of hitpoints, setting
// the value to 300 would give three times the normal number, and 50 will
// give half. Note that if you are using the standard HP regain policy,
// as set by the Standard HP item above (or if you set no item for HP
// regain at all) then this item is ignored as the standard regain policy
// returns the player the most hit points possible.
// CS Rest: Use CON Bonus
// Default value: FALSE
// Use this item to give players additional hit points equal to their CON
// bonus *when non-standard rest modes are in use*. Note that if you are
// using the standard HP regain policy, as set by the Standard HP item
// above (or if you set no item for HP regain at all) then this item is
// ignored as the standard regain policy returns the player the most hit
// points possible anyway. The CON bonus hit points are applied *after*
// the calculation of the multiplier value, so if 3rd edition style HP
// regain is enabled with a multipler of 2, players will receive hit
// points equalling (level * 2) + CON Bonus. This item is the opposite of
// the No CON Bonus item below and you may not use both items at the same
// time.
// CS Rest: No CON Bonus
// Default value: TRUE
// Use this item to disable the addition of CON bonus hit points when a
// non-standard hit point regain policy is in use. This item is the
// opposite of the Use CON Bonus item above and you may not use both
// items at the same time.
// CS Rest: User Script
// Default value: Not set
// Sets the name of the user script to be executed at specific points in
// the resting process. The tag of this item should be set to the name
// of the script to be executed. There are no standard user scripts
// provided with the CS Resting Subsystem as by definition all customised
// features must be provided by users of the subsystem. See Writing User
// Scripts for more information.
// CS Rest: Text Messages
// Default value: TRUE, with built in messages from cs_rest_text script
// This item will enable the display of floaty text messages, and allows
// the text of the messages to be changed. Once an instance of this item
// has been placed in the relevant configuration container, edit the item
// properties and click on the Description tab, then select the Variables
// button if you wish to change the text of the messages. The item
// contains all of the default messages already, so simply select the one
// to be changed, and change or overwrite the message that is displayed in
// the text field at the bottom of the dialogue box. Select the Replace
// button to update the message variable on the item, and then repeat
// for any other messages that require change. Then click Ok to save the
// changes to the item. The names of the variables, and explanation of
// when the corresponding messages are displayed, are:
// Variable Name Displayed When
// ------------- --------------
// cs_rest_startText A player starts resting.
// cs_rest_finishText A player finishes resting properly.
// cs_rest_cancelText A rest attempt is interrupted and
// so is unfinished. The player concerned
// will regain a portion of normal HP.
// cs_rest_cannotText A player may not rest due to rule
// restrictions.
// cs_rest_tooSoonText A time limit rule is in force and the
// player has not waited long enough.
// cs_rest_dayOnlyText The Day Only rest rule is in force and
// a player tries to rest at night.
// cs_rest_nightOnlyText The Night Only rest rule is in force
// and a player tries to rest during the
// day.
// cs_rest_noArmourText The No Armour rest rule is in force
// and the player is wearing armour, a
// helmet or carrying a shield.
// cs_rest_noWeaponText The no Weapons rest rule is in force
// and the player is carrying a weapon.
// cs_rest_bedrollRuinedText A bedroll is used for the last time
// before it becomes useless. The player
// gains a full rest, but must then
// replace the bedroll.
// cs_rest_notComfortable The Bedroll rest rule is in force, the
// player has no bedroll, but the bedroll
// multiplier is set to a value > 0.
// cs_rest_enterZoneText The player enters a Safe Camp resting
// trigger.
// cs_rest_exitZoneText The player leaves a Safe Camp resting
// trigger.
// cs_rest_unsafeText A player tries to rest within a Safe
// Room trigger without closing all doors.
// cs_rest_enterNoZoneText The player enters a No Rest resting
// trigger.
// cs_rest_exitNoZoneText The player leaves a no Rest resting
// trigger.
// cs_rest_noBedrollText The Bedroll rest rule is in force, the
// player has no bedroll, and the bedroll
// multiplier is set to 0.
// When a text message is displayed, any occurances of the string "<MIN>"
// will be replaced with the number of minutes remaining until the player
// will be permitted to rest again. This is really only useful in the
// "cs_rest_tooSoonText" variable. In addition, any variable that is set
// to the string "off" will not be displayed. This allows the individual
// messages to be controlled. This item is the opposite of the No Messages
// item below and you may not use both items at the same time.
// CS Rest: No Messages
// Default value: FALSE
// Use this item to disable the display of any floaty text messages. This
// item is the opposite of the Text Messages item above and you may not use
// both items at the same time.
// CS Rest: Effects
// Default value: FALSE
// Use this item to apply visual effects to resting players. Once a copy of
// this item has been placed in the relevant configuration container, edit
// the item properties and click on the Description tab, then select the
// Variables button to change the effects to be applied. The item already
// has the necessary variable, which is named "cs_rest_effects", set though
// with an empty value. Select the variable name in the list, and enter
// the numeric effect constant values desired in the text field at the
// bottom of the dialogue box, separated by commas. Select the Replace
// button to update the variable on the item, then click Ok to save the
// changes to the item. The numeric effect constants can be determined by
// opening the script named "nwscript" in the script editor and searching
// for "VFX". Don't forget to select the "All Resources" radio button.
// I'd list them all here, but there are many hundreds and most are not
// very useful for resting purposes. Some effects that may be quite useful
// for resting are:
// Description Constant Name Value
// ----------- ------------- -----
// Darkness VFX_DUR_DARKNESS 1
// Sleep VFX_IMP_SLEEP 94
// As an example, to set darkness and sleep effects on a player during
// resting, use a value of "1,94" for the "cs_rest_effects" variable
// on the item. Note that these are *visual* effects only, and some may
// run for fixed durations, finishing either before or after the resting
// period.
// CS Rest: Enable Debug
// Default value: FALSE
// Use this item to enable debug output from the resting subsystem. The
// debug output will be written to the message window of the player who
// is resting, and to server log. Debug is managed with the CS Debug
// subsystem, a separate package for displaying debug information. A
// minimal set of scripts from the CS Debug package is included with the
// CS Resting Subsystem.
//
// Using The Resting Triggers
// --------------------------
// The resting triggers track the entry and exit of players, and apply specific
// resting rules while a player is within the bounds of the trigger. The three
// standard triggers provided with the CS Resting Subsystem are the Camp
// trigger, the Room trigger and the No Rest trigger.
//
// NOTE: you do not need to use the triggers to make use of the resting
// subsystem, however in many instances the triggers are easier and more
// flexible to work with. Should you wish to block resting in most parts of
// an area and only allow resting at specific points, such as campsites, then
// using Camp triggers is the logical approach. Likewise, if you only wish to
// stop players from resting at specific points, such as within a boss room,
// then the No Rest trigger is the perfect tool.
//
// Placing a resting trigger basically involves drawing one somewhere in an
// area and setting any configuration necessary. The following steps provide
// a minimal guide to creating a Camp Trigger.
//
// 1/. Select the "CS Camp Resting Trigger" trigger from the "Generic
// Triggers" category of the Custom triggers palette.
// 2/. Draw a trigger polygon somewhere in an area, such as around a campfire
// tile.
// 3/. Edit the properties of the trigger (right click within the polygon
// and select "Properties" from the menu that is displayed) and change
// the Tag field to something sensible for your module. If you place
// more than one trigger with the same tag, they will all use the same
// configuration. This feature allows a module to have resting triggers
// that provide different combinations of resting rules.
// 4/. If you wish, create a container and place configuration items in
// its inventory to modify the operation of the trigger (see the section
// on configuring the CS Resting Subsystem for more details).
//
// You now have a functioning rest trigger. Save your module and load
// it up in Neverwinter Nights to see what happens, however unless you have
// placed a configuration container and changed the default operation, the
// trigger won't actually do anything different to standard Bioware resting.
//
// Other Configuration Facilities
// ------------------------------
// It is possible however to configure resting triggers differently to the
// global rules defined in the global configuration container. You do this
// by creating another container and setting its tag to match that of the
// trigger in question with the string "_REST_CONFIG" appended, i.e. if the
// trigger has a tag of "NoRestZone", the container's tag must be set to
// "NoRestZone_REST_CONFIG". If the tag is not set correctly, the trigger
// won't be able to find the container so be sure to double check this.
// Note that the length of the tag set on the trigger may not be more than
// 20 characters, since "_REST_CONFIG" is 12 characters. Tags are may a maximum
// of 32 characters, so 32 - 12 leaves 20 for the trigger tag.
//
// Once you create a configuration container that is specific to a trigger,
// any configuration items that you place in it will apply only to triggers
// with matching tags (and to *all* triggers with matching tags).
//
// But wait, there's more! It is also possible, in exactly the same way, to
// apply a set of resting rules to a specific area! Say you create an area
// and set its tag to be "BigBadForest". Create a container, set its tag to
// be "BigBadForest_REST_CONFIG" and place some configuration items in the
// container. This particular resting configuration will now apply to all
// players whenever they rest within that area. If however, there is a
// trigger within the area that has a different set of rules, the trigger's
// own rules will apply should the player rest within it.
//
// When a player rests, the resting subsystem will apply the most specific
// rules that it can find based on where the player actually rests. First
// a check is made to see if the player is within a trigger, then the area
// is checked for a specific config container, and finally the global config
// container is checked. It is important to note that this search is performed
// for each configuration item, not just for the configuration container itself
// and so if an item is not present in a trigger's configuration container,
// but *is* present in the global container or an area container, the resting
// subsystem will still apply it to the player! If you wish a specific rest
// rule to apply, then be careful which container you put it in.
//
// A Worked Example Of Setting Up The CS Resting Subsystem
// -------------------------------------------------------
// Ok, lets take a closer look at precisely how to make use to the CS Resting
// Subsystem. Let's say that you're building a module containing three areas: a
// city, an inn and a forest. You decide that there should be limited resting
// available in the forest, but no resting should be possible in the city
// itself since players are supposed to rest in the inn. Within the inn, full
// resting operates.
//
// First set the module's OnPlayerRest event script to "cs_rest_handler".
// Pull down the Edit menu and select Module Properties. Select the Events
// tab and either drop down the list for the OnPlayerRest event to scroll
// through and find "cs_rest_handler", or simply delete the script name
// that is already there and type in "cs_rest_handler" in place. Now select
// the Ok button and the module's rest script is set.
//
// Now create three areas and set their tags to be "TheCity", "TheInn" and
// "BigBadForest". Since the configuration containers for the resting subsystem
// should not be accessible to players, create a fourth area specifically to
// hold the configuration containers. DMs can jump to this area if necessary,
// and when editing the module in the toolset the location of the containers
// is irrelevant. For this module, the global resting rules will apply to the
// forest area while the city and inn have their own specific configuration.
//
// Create three containers and place them in the fourth area. Set their tags to
// be "CS_REST_GLOBAL_CONFIG", "TheCity_REST_CONFIG" and "TheInn_REST_CONFIG".
// Place configuration items into the three containers as indicated below:
//
// Container tagged "CS_REST_GLOBAL_CONFIG":
// CS Rest: Enable
// CS Rest: 3rd Ed Style HP
// CS Rest: Default Profile; set this item's tag to "cs_rest_cmp"
// CS Rest: 4 Minute Limit
//
// Container tagged "TheCity_REST_CONFIG":
// CS Rest: Default Profile; set this item's tag to "cs_rest_cnt"
//
// Container tagged "TheInn_REST_CONFIG":
// CS Rest: Standard HP
// CS Rest: Armour Not Allowed
// CS Rest: No Limit
//
// We're done! You now have a module configured to use the CS Resting Subsystem
// instead of the Bioware default resting. In the forest area, and by extension
// any others areas you may add to this module, players may rest once every 4
// minutes and will regain 1 hit point per level. No resting is permitted in
// the city area at all, and players may rest as often as they wish, and regain
// full hit points each time, in the inn but they will have to remove their
// armour to do it.
//
// Notice how not all configuration items need to be set in each container.
// When the resting subsystem is looking for a particular rule, such as whether
// to allow resting in armour, it looks first in any trigger-specific
// container that exists, then it looks in the area-specific container, and
// then it checks the global container. The first item found sets the rule for
// that resting session for that player. If no item is found, the default
// operation is assumed. In this example, you will see that the inn area's
// configuration container does not need to contain a CS Rest: Default Profile
// item since it can use the same script that is set in the configuration for
// the global container. It does however need to have the CS Rest: No Limit
// item to reset resting to unlimited times otherwise the 4 minute limit set
// in the global container would also apply.
//
// Writing User Scripts
// --------------------
// A user script can be used to add module-specific resting rules to those
// evaluated when determining whether a player should be permitted to rest.
// User scripts can also allow interoperation with other systems, such as
// a wandering monster system, and can be used to implement plot-specific
// logic that is triggered when players rest. User scripts are not required
// for normal use of the resting subsystem, but provide instead a powerful
// facility for extending the resting subsystem to meet specific module
// requirements. Some scripting knowledge is required to properly make use
// of the user scripts facility.
//
// A given user script will be executed potentially at four points during the
// rest cycle for a player: when rules are being evaluated to determine whether
// the player may rest, when the player starts to rest, when the player
// finishes resting, and when resting is cancelled for any reason. Only one of
// finish resting or cancel resting will be executed, and if a player is not
// permitted to rest due to not satisfying an active rest rule, then the user
// script will only be executed for the rule evaluation stage. User scripts
// are always executed with the player who is attempting to rest as the
// current object (i.e. OBJECT_SELF within the user script will refer to
// the player).
//
// When the resting subsystem is determining a player's eligibility to rest,
// a set of builtin rules are evaluated against the player. These rules may
// be enabled through configuration and are things like No Armour, Day Only,
// etc. Each of the rules that has been enabled will be checked and the result
// stored for the rest session. Once all rules have been evaluated, the player
// is only permitted to rest if every single rule allows it.
//
// When a user script is executed for evaluation of rest rules, the builder
// may add additional rules for the module. The builder may also override
// the evaluation of the builtin rules by performing additional checks and
// potentially changing the previously calculated result for a rule. For
// example, the No Weapons rule may be enabled, which will prevent a player
// from resting while holding a weapon. The module builder may however decide
// that daggers are small enough to be no hinderance and so would like to
// allow resting if the equipped weapon is a dagger. When a player rests
// with an equipped dagger, the resting subsystem builtin rule will fail, thus
// indicating that resting is not permitted. A user script may then be written
// that performs an additional check on the weapon to see if it is a dagger.
// If so, the previously calculated result of the builtin rule can be reset,
// allowing the player to rest. Of course, if the player fails any other
// rule, she will still not be allowed to rest anyway.
//
// The other execution points for the user script, i.e. when resting starts,
// finishes or is cancelled, are provided specifically for adding custom
// module-specific functionality rather than interacting with the resting
// subsystem itself. The user script may initiate a cutscene when resting
// finishes for example, or generate a random wandering monster encounter
// when resting starts. These execution points are provided for use by builders
// when integrating the resting subsystem into other aspects of a module.
//
// In structure, a user script closely resembles a standard NWN user-defined
// event handler script. Each execution point is numbered and the script calls
// a function, cs_rest_GetUserScriptState(), to determine the execution point
// for which it has been executed. This function will return one of the
// following constants:
// CS_REST_START_RESTING
// CS_REST_STOP_RESTING
// CS_REST_CANCEL_RESTING
// CS_REST_RULE_CHECK
//
// Once the execution point number has been obtained, a set of if statements
// or a switch statement is used to perform the necessary functionality. When
// the execution point number is CS_REST_RULE_CHECK, the following functions
// may also be used:
// cs_rest_GetIsRuleEnabled returns TRUE if a specific rule is
// enabled in configuration.
// cs_rest_GetRule returns TRUE if a specific rule has
// has been failed (i.e. the player may
// not rest.
// cs_rest_SetRule used to force a specific rule to a
// given state (TRUE will cause the player
// to be unable to rest).
// cs_rest_SetOverrideProfile changes the profile that will be used
// for the current rest session *only*.
// The next time the player rests, the
// profile will automatically revert to
// that which is active for the player
// (should the player be inside a trigger)
// or the default profile if the player
// has no profile.
//
// These functions allow the user script to control the rest rules. The rest
// rules are indicated by using the following constants when calling the
// functions above:
// CS_REST_RULE_LAST_REST
// CS_REST_RULE_DAY_ONLY
// CS_REST_RULE_NIGHT_ONLY
// CS_REST_RULE_NO_ARMOUR
// CS_REST_RULE_NO_WEAPONS
// CS_REST_RULE_NO_BEDROLL
// CS_REST_RULE_USER_1
// CS_REST_RULE_USER_2
// CS_REST_RULE_USER_3
// CS_REST_RULE_USER_4
// CS_REST_RULE_USER_5
// CS_REST_RULE_USER_6
// CS_REST_RULE_USER_7
// CS_REST_RULE_USER_8
// CS_REST_RULE_USER_9
// CS_REST_RULE_USER_10
// CS_REST_RULE_USER_11
// CS_REST_RULE_USER_12
// CS_REST_RULE_USER_13
// CS_REST_RULE_USER_14
// CS_REST_RULE_USER_15
// CS_REST_RULE_USER_16
//
// These constants identify the builtin rest rules provided by the resting
// subsystem, and also the 16 user rules that are available for use by builders
// within user scripts. The user rules will be honoured by the resting
// subsystem in exactly the same way as the builtin rules, with the single
// exception that the resting subsystem will never change the state of a user
// rule. All user rules are always enabled, and will always be FALSE (i.e.
// the player is allowed to rest) when the user script is executed. Changing
// any user rule to a state of TRUE through the cs_rest_SetRule() function
// will prevent the player from resting.
//
// When the execution point is CS_REST_START_RESTING, the following functions
// may also be used:
// cs_rest_SetAbort Causing the rest process to be aborted
// as if it had not started. This allows
// last minute decisions to be made as to
// whether a player may rest, despite the
// player having successfully satisfied all
// enabled rest rules.
// cs_rest_SetOverrideProfile changes the profile that will be used
// for the current rest session *only*.
// The next time the player rests, the
// profile will automatically revert to
// that which is active for the player
// (should the player be inside a trigger)
// or the default profile if the player
// has no profile.
//
// Consult the help text for each function for further details, and read
// through the sample code in An Example User Script. The script named
// cs_rest_sample is template script that may used as a starting point for
// user scripts. The script named cs_rest_wndmonst is a functional example
// that demonstrates how the Bioware HotU wandering monster system may be
// integrated into the resting subsystem.
//
// An Example User Script
// ----------------------
// The sample script in this section shows how to implement the example
// presented in Writing User Scripts.
//
// #include "cs_rest"
// void main() {
// int state = cs_rest_GetUserScriptState();
// if (state == CS_REST_START_RESTING) {
// }
// else if (state == CS_REST_STOP_RESTING) {
// }
// else if (state == CS_REST_CANCEL_RESTING) {
// }
// else if (state == CS_REST_RULE_CHECK) {
// // Has the No Weapons rule actually been enabled?
// if (cs_rest_GetIsRuleEnabled(CS_REST_RULE_NO_WEAPONS)) {
// // Retrieve the items in the resting player's hands.
// object right = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND);
// // If the player has a dagger in her right hand, we have to
// // check a little more carefully before resetting the No
// // Weapons rule and allowing her to rest.
// if ((GetBaseItemType(right) == BASE_ITEM_DAGGER) {
// // If the player has nothing in her left hand, or a dagger,
// // a shield, or a torch, she's ok to rest for this rule.
// // Anything else will be assumed to be another weapon
// // and so the resting state for the No Weapons rule will
// // be left unchanged.
// int left = GetBaseItemType(
// GetItemInSlot(INVENTORY_SLOT_LEFTHAND)
// );
// if ((left == BASE_ITEM_INVALID) ||
// (left == BASE_ITEM_TORCH) ||
// (left == BASE_ITEM_SMALLSHIELD) ||
// (left == BASE_ITEM_LARGESHIELD) ||
// (left == BASE_ITEM_TOWERSHIELD) ||
// (left == BASE_ITEM_DAGGER)
// ) {
// // The player only has a dagger or an allowed item
// // equipped, so the No Weapon rule can be reset.
// // Note that shields are checked as part of the
// // No Armour rule, not the No WSeapons rule.
// cs_rest_SetRule(CS_REST_RULE_NO_WEAPONS, FALSE);
// }
// }
// }
// }
// }
//
// Creating Your Own Resting Profile
// ---------------------------------
// A resting profile sets the fundamental operation of the resting subsystem.
// Resting profiles are represented by scripts that call the basic functions
// of the resting subsystem in response to the engine's rest events, sometimes
// performing additional checks (such as the safe room profile used by the
// CS Safe Room Trigger, which checks that all doors in a room are closed
// before executing the resting). The three standard profiles provided with
// resting subsystem are:
// Name Script
// -------------- ------
// Safe/Camp Rest cs_rest_cmp
// Safe Room Rest cs_rest_rom
// No Rest cs_rest_cnt
//
// Resting profiles are used in two places: when setting a default profile
// for the global rest configuration or in an area's rest configuration,
// or when creating a resting trigger. Using a resting profile from a
// configuration container is simply a matter of setting the profile script
// name using the Default Profile config item, after writing the profile
// script, of course. Creating a profile for use with a trigger is slightly
// more complex. Creating a rest profile is a task for a moderately skilled
// scripter with good knowledge of how the resting subsystem works.
//
// There are three components to a rest profile when it is used from a
// trigger: a trigger OnEnter script, a trigger OnExit script, and the
// resting profile script itself. The OnEnter script is a simple modification
// of an existing OnEnter script, since the only thing that has to change is
// the name of the resting profile script contained within it. The standard
// OnExit script provided by the resting subsystem should work for all new
// resting profile triggers as well, so the only real work comes about when
// writing the resting profile script itself.
//
// The standard resting profiles should be sufficient for most purposes, as
// most custom operation may be added theough the user script facility in a
// more elegant manner.
//
// An Example Resting Profile
// --------------------------
// To illustrate how resting profiles are created, the Safe Room Rest profile
// script and its corresponding trigger OnEnter script are shown here. The
// standard trigger OnExit script, cs_rest_trg_exit, should be sufficient
// for any new resting profile trigger.
//
// This is the trigger OnEnter script for the Safe Room Rest trigger. It first
// checks to ensure that the creature who has entered the trigger is a player,
// and then it sets the name of the resting profile script ("cs_rest_rom")
// as the player's resting profile using the cs_rest_SetProfile() function.
// The trigger itself is set as the object that the player has entered using
// the cs_rest_SetTriggeringObject() function (this is so the resting subsystem
// knows which configuration container to search for). Finally, a floaty text
// message is displayed indicating that the player has entered a rest trigger.
// The cs_rest_RetrieveConfig() function is used to determine whether floaty
// text messages are enabled (a check is performed within the function call).
// Basically all OnEnter scripts for resting triggers will look identical to
// this script except for the name of the rest profile script.
//
// #include "cs_rest"
// void main() {
// object pc = GetEnteringObject();
// if (GetIsPC(pc)) {
// // Set tracking information for this trigger.
// cs_rest_SetProfile(pc, "cs_rest_rom");
// cs_rest_SetTriggeringObject(pc, OBJECT_SELF);
// struct cs_rest_config cfg = cs_rest_RetrieveConfig(pc);
// cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_ENTER_REST);
// }
// }
//
// This is the Safe Room Rest profile script. It retrieves the current rest
// session config from the player with the cs_rest_GetConfig() function (all
// resting configuration has by this stage been retrieved from containers and
// stored as local variables on the player). The specific rest event is then
// checked to determine whether a start, stop or cancel event is currently
// being processed. The stop and cancel events simply require standard rest
// processing so the cs_rest_StopResting() and cs_rest_CancelResting()
// functions are called. For a start resting event, the trigger that the
// player has entered is searched for doors, and the state of every door
// is checked to make sure it has been closed. Only if there are actually
// doors, and all of them are closed, is the player allowed to rest. The
// configuration values retrieved from the player at the start of the function
// are passed to most resting subsystem functions to minimise the need to
// continually read local variables.
//
// #include "cs_rest"
// void main() {
// object pc = GetLastPCRested();
// if (GetIsPC(pc)) {
// struct cs_rest_config cfg = cs_rest_GetConfig(pc);
// int restType = GetLastRestEventType();
// if (restType == REST_EVENTTYPE_REST_STARTED) {
// // Find all doors within the area of the triggering object the
// // PC is within.
// int doorsFound = 0;
// int openDoors = 0;
// if (GetIsObjectValid(cfg.trigger)) {
// object door = GetFirstInPersistentObject(
// cfg.trigger,
// OBJECT_TYPE_DOOR
// );
// while (GetIsObjectValid(door)) {
// doorsFound++;
// if (GetIsOpen(door)) {
// openDoors++;
// }
// door = GetNextInPersistentObject(
// cfg.trigger,
// OBJECT_TYPE_DOOR
// );
// }
// }
//
// // Do we stop the player from resting? This is a safe room rest
// // check. Players may only rest if they have taken steps to
// // ensure their own safety, i.e. closing all doors. Resting is
// // not permitted if:
// // - there are no doors in this trigger
// // - a door within this trigger is open
// if (!doorsFound || openDoors) {
// cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_UNSAFE);
// AssignCommand(pc, ClearAllActions());
// }
// else {
// cs_rest_StartResting(pc, cfg);
// }
// }
// else if (restType == REST_EVENTTYPE_REST_FINISHED) {
// cs_rest_StopResting(pc, cfg);
// }
// else if (restType == REST_EVENTTYPE_REST_CANCELLED) {
// cs_rest_CancelResting(pc, cfg);
// }
// }
// }
//
// Using the CS Resting Subsystem Within A Persistent World
// --------------------------------------------------------
// In general, The CS Resting Subsystem will function correctly when used in a
// persistent world environment. The one thing that may cause issues is the
// last resting time, which must be calculated and stored each time a player
// rests. When a player logs in after a server restart, she will be able to
// rest immediately, which may not be what is desired. There are however a
// set of functions provided that address this situation.
//
// The cs_rest_GetState() and cs_rest_SetState() functions may be used to
// store the information needed to restore a player's resting situation to
// a specific point. The cs_rest_GetState() function may be used to retrieve
// resting information for a player, which may then be stored in a persistence
// mechanism such as a database. This resting information is returned in the
// form of a string for convenience. The cs_rest_SetState() function may be
// used to restore the resting information for when that player logs into
// the server again.
//
// The use of these two functions must be performed through scripting and so
// is not handled as part of the normal configuration of the resting subsystem.
// It is not necessary to use these functions in anything other than a
// persistent world, and not even in every one of those. Please try using the
// resting subsystem first before making use of these functions.
//
// Acknowledgements
// ----------------
// Many thanks go to __Abaddon__ and Elorin for being sounding boards of
// ideas and for telling me when I'm being stupid. Elorin finds bugs and I
// fix them. Sigh. Provsul has been of great assistance in providing better
// support for persistent worlds.
//
// To Do
// -----
// - Party-only resting.
// - Rations.
//
// Revision History
// ----------------
// 0.8.0dev Changed builtin resting rules to act upon a bitmapped flag
// integer, thus allowing all rules to operate independently.
// Some internal consistency tweaks, constant renaming and
// the like to make the code more maintainable. Added execution
// of user script immediately after evaluating builtin rules,
// and on start, stop and cancel of resting. Added User Script
// config item. Updated to release 1.6.0 of CS Debug. Updated
// documentation. Finally added support for changing the floaty
// text messages through the usual dynamic configuration model,
// and noew allow individual floaty messages to be disabled.
// Added the Effects config item. Added override profile.
// 0.7.3dev Added the Bedroll HP Multiplier config item. Changed the
// generation of the remaining minutes message to be more
// sensible.
// 0.7.2dev Rewrote the still dysfunctional time manipulation to use
// a double-int method of tracking times, thus providing more
// than sufficient scope for managing the DR calendar at any
// minutes-per-hour resolution that anyone may care to use.
// Shields are now considered armour with regard to resting.
// 0.7.1dev More debug messages. Corrected some minor issues related to
// time manipulation changes. Restored incorrect trigger tags.
// 0.7.0dev Some documentation updates. Added persistence hooks. Updated
// to release 1.5.0 of CS Debug. Added internal debug config
// support to allow debug output for the resting subsystem to
// be controlled through the resting subsystem configuration.
// Armour and weapons checks are now controlled through separate
// configuration items. Internal changes to time manipulation.
// 0.6.6dev Documentation corrections. No code change.
// 0.6.5dev Removed Destroy config item and associated code. The idea of
// destroying the config and keeping static copies of the rules
// as local variables never really made sense anyway. Added Use
// CON Bonus, No CON Bonus and HP Multiplier configuration items.
// 0.6.1dev Fixed No Messages configuration item so that it works.
// Added separate floaty messages for entering and exiting no
// rest zones.
// 0.6.0dev Major refactoring to eliminate proliferation of get/set
// functions and replace most with a single set of functions.
// Much cleaner code now. First draft of documentation. Added
// fade screen to black function and corresponding config item.
// Even more debug! Added No Messages configuration item.
// 0.5.0dev Added bedrolls and associated configuration items--still
// mostly untested. Corrected overzealous armour restrictions
// (forced resting naked is probably a bit over the top :).
// Included equipped weapons in the "armour check". Added
// resting never permitted function for special purposes.
// Added config cleanup when not destroying config containers,
// thus allowing defaults to re-apply the next time the container
// is read.
// 0.4.0dev Incorporated 3rd ed style resting as a configurable option
// for all triggers, and removed the 3rd ed trigger. Added
// global and area configuration facility. Added day/night
// only configuration items. Added armour configuration items.
// 0.3.0dev Added 3rd edition rules profile. Improved safe room resting
// by accounting for multiple doors. Rejigged framework to use
// two scripts per profile (enter/rest) rather than four
// (enter/start/stop/cancel). Added dynamic configuration.
// Added time limits. Added floaty text.
// 0.2.0dev Added profile support. Added safe room profile.
// 0.1.0dev Basic framework. Safe campsites.
//
//============================================================================
#include "cs_dbg"
#include "cs_token"
#include "cs_rest_text"
// The version numbering I use is comprised of a tripartite version number
// and a trailing string. The version is arranged into 1.2.3 form, where 1 is
// the major release number, 2 is the minor release number and 3 is the bugfix
// level. Each number in the version starts at 0 and increments each time a
// change is made to the code that classifies as that level. The trailing
// string is either "dev", "beta" or "final" depending upon whether the code
// is still under development (it will have bugs, count on it), is considered
// to be beta quality (i.e. technically finished but probably has bugs), or
// finished, tested and believed to be correctly functional. If you wish to
// report a bug, please include the version number with your bug report.
const string cs_rest_version = "0.8.0dev";
//============================================================================
//
// Data Types and Constants
//
//============================================================================
// The maximum length of tags. This is used for error validation.
const int CS_REST_MAX_TAG_LENGTH = 32;
// Constants for default values when using bedrolls.
const int CS_REST_DEF_BEDROLL_MAX_USE = 20;
const float CS_REST_DEF_BEDROLL_MULTIPLIER = 0.5;
const float CS_REST_DEF_MULTIPLIER = 1.0;
// The tag of the global rest container.
const string CS_REST_TAG_CONFIG = "CS_REST_GLOBAL_CONFIG";
// The suffix added to an area or trigger tag to generate the matching
// rest container tag.
const string CS_REST_TAG_CONFIG_SUFFIX = "_REST_CONFIG";
// Floaty text message IDs.
const int CS_REST_TXT_START = 1;
const int CS_REST_TXT_FINISH = 2;
const int CS_REST_TXT_CANCEL = 3;
const int CS_REST_TXT_CANNOT = 4;
const int CS_REST_TXT_TOO_SOON = 5;
const int CS_REST_TXT_DAY_ONLY = 6;
const int CS_REST_TXT_NIGHT_ONLY = 7;
const int CS_REST_TXT_NO_ARMOUR = 8;
const int CS_REST_TXT_NO_WEAPON = 9;
const int CS_REST_TXT_BEDROLL_RUINED = 10;
const int CS_REST_TXT_NOT_COMFORTABLE = 11;
const int CS_REST_TXT_ENTER_REST = 12;
const int CS_REST_TXT_EXIT_REST = 13;
const int CS_REST_TXT_UNSAFE = 14;
const int CS_REST_TXT_ENTER_NO_REST = 15;
const int CS_REST_TXT_EXIT_NO_REST = 16;
const int CS_REST_TXT_NO_BEDROLL = 17;
// Names of resrefs for configuration items.
const string CS_REST_RR_DEBUG_ON = "cs_rest_cfg_dbgo";
const string CS_REST_RR_ENABLE = "cs_rest_cfg_enbl";
const string CS_REST_RR_DISABLE = "cs_rest_cfg_dsbl";
const string CS_REST_RR_PROFILE = "cs_rest_cfg_prfl";
const string CS_REST_RR_TIME_LIMIT = "cs_rest_cfg_time";
const string CS_REST_RR_TIME_PREFIX = "cs_rest_cfg_tm";
const string CS_REST_RR_HP_3ED = "cs_rest_cfg_3ed";
const string CS_REST_RR_HP_STD = "cs_rest_cfg_std";
const string CS_REST_RR_NO_ARMOUR = "cs_rest_cfg_armn";
const string CS_REST_RR_YES_ARMOUR = "cs_rest_cfg_army";
const string CS_REST_RR_NO_WEAPONS = "cs_rest_cfg_wepn";
const string CS_REST_RR_YES_WEAPONS = "cs_rest_cfg_wepy";
const string CS_REST_RR_NO_BEDROLL = "cs_rest_cfg_bedn";
const string CS_REST_RR_YES_BEDROLL = "cs_rest_cfg_bedy";
const string CS_REST_RR_BEDROLL_MULTIPLIER = "cs_rest_cfg_bedm";
const string CS_REST_RR_DAY_ONLY = "cs_rest_cfg_donl";
const string CS_REST_RR_NIGHT_ONLY = "cs_rest_cfg_nonl";
const string CS_REST_RR_ALL_HOURS = "cs_rest_cfg_allh";
const string CS_REST_RR_DAY_START = "cs_rest_cfg_days";
const string CS_REST_RR_DAY_END = "cs_rest_cfg_daye";
const string CS_REST_RR_FADE_TO_BLACK = "cs_rest_cfg_fade";
const string CS_REST_RR_NO_MESSAGES = "cs_rest_cfg_nmsg";
const string CS_REST_RR_USE_CON_BONUS = "cs_rest_cfg_cony";
const string CS_REST_RR_NO_CON_BONUS = "cs_rest_cfg_conn";
const string CS_REST_RR_HP_MULTIPLIER = "cs_rest_cfg_hmul";
const string CS_REST_RR_USER_SCRIPT = "cs_rest_cfg_uscr";
const string CS_REST_RR_TEXT_MESSAGES = "cs_rest_cfg_text";
const string CS_REST_RR_EFFECTS = "cs_rest_cfg_efct";
// Names of local variables used within the resting code.
const string CS_REST_VAR_DEBUG = "cs_rest_debug";
const string CS_REST_VAR_PERMITTED = "cs_rest_permitted";
const string CS_REST_VAR_RULE_FLAGS = "cs_rest_ruleFlags";
const string CS_REST_VAR_ENABLE = "cs_rest_enable";
const string CS_REST_VAR_STARTED = "cs_rest_started";
const string CS_REST_VAR_NEVER_PERMITTED = "cs_rest_neverPermitted";
//const string CS_REST_VAR_PLAYER_ALLOWED = "cs_rest_playerAllowed";
const string CS_REST_VAR_PLAYER_PROFILE = "cs_rest_playerProfile";
const string CS_REST_VAR_DEFAULT_PROFILE = "cs_rest_defaultProfile";
const string CS_REST_VAR_OVERRIDE_PROFILE = "cs_rest_overrideProfile";
const string CS_REST_VAR_TIME_LIMIT = "cs_rest_timeLimit";
const string CS_REST_VAR_LAST_REST_DAYS = "cs_rest_lastRestDays";
const string CS_REST_VAR_LAST_REST_SECONDS = "cs_rest_lastRestSeconds";
const string CS_REST_VAR_SAVE_HP = "cs_rest_savedHP";
const string CS_REST_VAR_HP_3ED = "cs_rest_3ed";
const string CS_REST_VAR_NO_ARMOUR = "cs_rest_noArmour";
const string CS_REST_VAR_NO_WEAPONS = "cs_rest_noWeapons";
const string CS_REST_VAR_BEDROLL_IN_USE = "cs_rest_bedrollInUse";
const string CS_REST_VAR_BEDROLL_TAG = "cs_rest_bedrollTag";
const string CS_REST_VAR_BEDROLL_USE = "cs_rest_bedrollUse";
const string CS_REST_VAR_BEDROLL_MULTIPLIER = "cs_rest_bedrollMultiplier";
const string CS_REST_VAR_DAY_MODE = "cs_rest_dayMode";
const string CS_REST_VAR_DAY_START = "cs_rest_dayStart";
const string CS_REST_VAR_DAY_END = "cs_rest_dayEnd";
const string CS_REST_VAR_TRIGGER = "cs_rest_trigger";
const string CS_REST_VAR_MULTIPLIER = "cs_rest_multiplier";
const string CS_REST_VAR_FADE_TO_BLACK = "cs_rest_fadeToBlack";
const string CS_REST_VAR_FADE_DONE = "cs_rest_fadeDone";
const string CS_REST_VAR_NO_MESSAGES = "cs_rest_noMessages";
const string CS_REST_VAR_CON_BONUS = "cs_rest_conBonus";
const string CS_REST_VAR_NO_REST_ZONE = "cs_rest_noRestZone";
const string CS_REST_VAR_USER_SCRIPT = "cs_rest_userScript";
const string CS_REST_VAR_USER_SCRIPT_STATE = "cs_rest_userScriptState";
const string CS_REST_VAR_EFFECTS = "cs_rest_effects";
// Constants for indicating when resting is permitted.
const int CS_REST_DAY_AND_NIGHT = 0;
const int CS_REST_DAY_ONLY = 1;
const int CS_REST_NIGHT_ONLY = 2;
// Constants for state tracking whether resting actually began.
const int CS_REST_STARTED = 1;
const int CS_REST_ABORTED = 2;
// Constants for use with user hook scripts.
const int CS_REST_START_RESTING = 1;
const int CS_REST_STOP_RESTING = 2;
const int CS_REST_CANCEL_RESTING = 3;
const int CS_REST_RULE_CHECK = 4;
// Names of variables that hold floaty text message strings.
const string CS_REST_VAR_START_TEXT = "cs_rest_startText";
const string CS_REST_VAR_FINISH_TEXT = "cs_rest_finishText";
const string CS_REST_VAR_CANCEL_TEXT = "cs_rest_cancelText";
const string CS_REST_VAR_CANNOT_TEXT = "cs_rest_cannotText";
const string CS_REST_VAR_TOO_SOON_TEXT = "cs_rest_tooSoonText";
const string CS_REST_VAR_DAY_ONLY_TEXT = "cs_rest_dayOnlyText";
const string CS_REST_VAR_NIGHT_ONLY_TEXT = "cs_rest_nightOnlyText";
const string CS_REST_VAR_NO_ARMOUR_TEXT = "cs_rest_noArmourText";
const string CS_REST_VAR_NO_WEAPON_TEXT = "cs_rest_noWeaponText";
const string CS_REST_VAR_BEDROLL_RUINED_TEXT = "cs_rest_bedrollRuinedText";
const string CS_REST_VAR_NOT_COMFORTABLE_TEXT = "cs_rest_notComfortable";
const string CS_REST_VAR_ENTER_REST_TEXT = "cs_rest_enterZoneText";
const string CS_REST_VAR_EXIT_REST_TEXT = "cs_rest_exitZoneText";
const string CS_REST_VAR_UNSAFE_TEXT = "cs_rest_unsafeText";
const string CS_REST_VAR_ENTER_NO_REST_TEXT = "cs_rest_enterNoZoneText";
const string CS_REST_VAR_EXIT_NO_REST_TEXT = "cs_rest_exitNoZoneText";
const string CS_REST_VAR_NO_BEDROLL_TEXT = "cs_rest_noBedrollText";
// Rest rule bitmapped IDs for rule checks.
const int CS_REST_RULE_LAST_REST = 0x00000001;
const int CS_REST_RULE_DAY_ONLY = 0x00000002;
const int CS_REST_RULE_NIGHT_ONLY = 0x00000004;
const int CS_REST_RULE_NO_ARMOUR = 0x00000008;
const int CS_REST_RULE_NO_WEAPONS = 0x00000010;
const int CS_REST_RULE_NO_BEDROLL = 0x00000020;
const int CS_REST_RULE_RESERVED_1 = 0x00000040;
const int CS_REST_RULE_RESERVED_2 = 0x00000080;
const int CS_REST_RULE_RESERVED_3 = 0x00000100;
const int CS_REST_RULE_RESERVED_4 = 0x00000200;
const int CS_REST_RULE_RESERVED_5 = 0x00000400;
const int CS_REST_RULE_RESERVED_6 = 0x00000800;
const int CS_REST_RULE_RESERVED_7 = 0x00001000;
const int CS_REST_RULE_RESERVED_8 = 0x00002000;
const int CS_REST_RULE_RESERVED_9 = 0x00004000;
const int CS_REST_RULE_RESERVED_10 = 0x00008000;
const int CS_REST_RULE_USER_1 = 0x10000000;
const int CS_REST_RULE_USER_2 = 0x20000000;
const int CS_REST_RULE_USER_3 = 0x40000000;
const int CS_REST_RULE_USER_4 = 0x80000000;
const int CS_REST_RULE_USER_5 = 0x01000000;
const int CS_REST_RULE_USER_6 = 0x02000000;
const int CS_REST_RULE_USER_7 = 0x04000000;
const int CS_REST_RULE_USER_8 = 0x08000000;
const int CS_REST_RULE_USER_9 = 0x00100000;
const int CS_REST_RULE_USER_10 = 0x00200000;
const int CS_REST_RULE_USER_11 = 0x00400000;
const int CS_REST_RULE_USER_12 = 0x00800000;
const int CS_REST_RULE_USER_13 = 0x00010000;
const int CS_REST_RULE_USER_14 = 0x00020000;
const int CS_REST_RULE_USER_15 = 0x00040000;
const int CS_REST_RULE_USER_16 = 0x00080000;
// A configuration structure that tracks the operational parameters for a
// resting session.
struct cs_rest_config {
object debug; // The object to which debug messages are sent.
int permitted; // If resting is permitted for a given session.
int ruleFlags; // A bitmapped flag word for tracking rules.
int lastRestDays; // Days since start of calendar since of last rest.
int lastRestSeconds; // Seconds within day of last rest.
int savedHitPoints; // Number of HP when resting session was begin.
int enabled; // If this rest system is actually enabled at all.
int started; // If a resting session has been begun.
int neverPermitted; // If resting for the creature is never allowed.
// int allowed; // XXX Don't know. Might not be used anymore.
string profile; // The current profile for the player.
string defaultProfile; // The default profile if not otherwise set.
string overrideProfile; // A profile that exists only for the rest session.
int limit; // Number of seconds between rests.
int use3Ed; // Use 3rd Edition-style HP regain.
int noArmour; // Armour may not be equipped while resting.
int noWeapons; // Weapons may not be equipped while resting.
int useBedroll; // A bedroll must be available to rest.
string bedrollTag; // The tag of bedroll items.
float bedrollMultiplier;// A multiplier for HP regaing in bedroll resting.
int dayMode; // Resting may only occur during the day or night.
int dayStart; // The hour at which "day" starts.
int dayEnd; // The hour at which "day" ends.
object trigger; // The trigger in which the player exists.
float multiplier; // A multiplier for HP regain.
int fadeToBlack; // If the screen should fade to black while resting.
int noMessages; // If floating messages should be displayed.
int useConBonus; // If CON bonus should be added to HP regain.
string userScript; // Name of rule script provided by builder.
string effects; // A set of effect numbers to apply.
};
// A representation of a date and time broken down into number of days
// since the beginning of the calendar and a number of seconds within the
// current day.
struct cs_rest_time {
int days; // The number of days since the beginning of the calendar.
int seconds; // The number of seconds elapsed within the current day.
};
//============================================================================
//
// Function Prototypes and toolset IDE documentation.
//
//============================================================================
// Set the rest profile to be associated with the specified player.
//
// pc The player for whom to set the profile.
// profile The name of the profile to associate with the player.
void cs_rest_SetProfile(object pc, string profile);
// Remove any rest profile that may be associated with the specified
// player.
//
// pc The player from whom to remove any profile.
void cs_rest_DeleteProfile(object pc);
// Set the session-specific rest profile to be associated with the specified
// player. Session profiles are only used for the specific resting session
// in which they are set.
//
// pc The player for whom to set the profile.
// profile The name of the profile to associate with the player.
void cs_rest_SetOverrideProfile(object pc, string profile);
// Remove any session-specific rest profile that may be associated with the
// specified player. Session profiles are only used for the specific resting
// session in which they are set.
//
// pc The player from whom to remove any profile.
void cs_rest_DeleteOverrideProfile(object pc);
// Set the object that associated the rest profile with the specified player.
//
// pc The player for whom to set the triggering object.
// profile The triggering object.
void cs_rest_SetTriggeringObject(object pc, object trigger);
// Remove any triggering object that may be stored for the specified player.
//
// pc The player from whom to remove any triggering object.
void cs_rest_DeleteTriggeringObject(object pc);
// Set a rule flag to a specific state (i.e. TRUE or FALSE). Rule flags are
// used to track whether a player has satisfied a specific rule that will
// block resting. Resting will only be permitted if *no* rules have been
// satisfied and all rule flags are FALSE.
//
// cfg The current rest config for a player.
// rule The specific rule flag that is to be changed.
// value Either TRUE to set the flag or FALSE to clear it.
// returns The modified rest config.
struct cs_rest_config cs_rest_SetRuleFlag(struct cs_rest_config cfg, int rule, int value);
// Determine the state of a specific rule flag.
//
// cfg The current rest config for a player.
// rule The specific rule flag that is to be checked.
// returns TRUE if the flag is set otherwise FALSE.
int cs_rest_GetRuleFlag(struct cs_rest_config cfg, int rule);
// Execute the resting script associated with the rest profile that has
// been set for the specified player.
//
// pc The player for whom to run the script.
// cfg A set of configuration data for a player.
void cs_rest_ExecuteRestScript(object pc, struct cs_rest_config cfg);
// Return the current time as a since the beginning of the calendar.
//
// returns The current time.
struct cs_rest_time cs_rest_GetCurrentTime(struct cs_rest_config cfg);
// Process the configuration for the rest subsystem.
//
// pc The player for whom to process configuration.
// container A container object containing the configuration.
// cfg A set of configuration data for a player.
// returns The updated configuration data.
struct cs_rest_config cs_rest_ProcessConfig(object pc, object container, struct cs_rest_config cfg);
// Search for and compile together all of the configuration that applies to
// a specific player.
//
// pc The player for whom to search for configuration.
// returns The player's resting configuration
struct cs_rest_config cs_rest_RetrieveConfig(object pc);
// Read any messages that exist as variables on the specified item and set
// them to be used for the specified player's rest session.
//
// pc The player for whom to change messages.
// cfg The player's resting configuration.
// item The item containing message text variables.
void cs_rest_UpdateMessages(object pc, struct cs_rest_config cfg, object item);
// Display a floating text message on a player from those messages defined
// by the rest system. If floaty messages are disabled for the resting zone
// in which this function is invoked (i.e. cfg.noMessage is TRUE), no
// messages will be displayed.
//
// pc The player on whom to display the message.
// cfg The player's resting configuration.
// id The ID of the message to be displayed. This value may be one
// of the following constants:
// CS_REST_TXT_START
// CS_REST_TXT_FINISH
// CS_REST_TXT_CANCEL
// CS_REST_TXT_CANNOT
// CS_REST_TXT_TOO_SOON
// CS_REST_TXT_DAY_ONLY
// CS_REST_TXT_NIGHT_ONLY
// CS_REST_TXT_NO_ARMOUR
// CS_REST_TXT_NO_WEAPON
// CS_REST_TXT_BEDROLL_RUINED
// CS_REST_TXT_NOT_COMFORTABLE
// CS_REST_TXT_ENTER_REST_ZONE
// CS_REST_TXT_EXIT_REST_ZONE
// CS_REST_TXT_UNSAFE
// CS_REST_TXT_ENTER_NO_REST_ZONE
// CS_REST_TXT_EXIT_NO_REST_ZONE
// CS_REST_TXT_NO_BEDROLL
void cs_rest_ShowFloatingTextByID(object pc, struct cs_rest_config cfg, int id);
// Retrieve rest configuration from an object.
//
// returns The configuration data found.
struct cs_rest_config cs_rest_GetConfig(object container);
// Set current rest configuration on an object.
//
// container The object on which to set the config.
// cfg A set of configuration data.
void cs_rest_SetConfig(object container, struct cs_rest_config cfg);
// Delete rest configuration from an object.
//
// container The object from which to delete the configuration data.
void cs_rest_DeleteConfig(object container);
// Generate a string containing the data needed to restore the resting
// state of a player in the event of a system failure, or after a player
// logs out. This function should be called periodically while a server
// is running, if persistent state is being stored in such a fashion, or
// whenever a player logs out.
//
// NOTE: This function is not needed for the normal operation of the
// resting subsystem and should be used only for integration into modules
// that run as persistent worlds.
//
// pc The object from which to retrieve the config.
// returns The persistence state in string form.
string cs_rest_GetState(object container);
// Set the resting state for a player from a previous call to the
// cs_rest_GetState() function. This function should be called when
// a player logs into a server running as a persistent module.
//
// NOTE: This function is not needed for the normal operation of the
// resting subsystem and should be used only for integration into modules
// that run as persistent worlds.
//
// pc The object on which to set the config.
// state A string containing state information.
// timeOffset The amount of time in seconds by which the time values
// in the resting state should be adjusted. Adjusting the
// time will usually be unnecessary.
void cs_rest_SetState(object container, string state, int timeOffset=0);
// Set the user hook script state for a resting session.
//
// pc The player who is resting.
// state The state for the hook script. This should be one of the
// following constants:
// CS_REST_START_RESTING
// CS_REST_STOP_RESTING
// CS_REST_CANCEL_RESTING
// CS_REST_RULE_CHECK
void cs_rest_SetUserScriptState(object pc, int state);
// Determine the resting state for which the user hook script has been
// executed.
//
// pc The player who is resting. If not specified, this defaults
// to the current object.
// returns The script hook state. This will be one of the following
// constants:
// CS_REST_START_RESTING
// CS_REST_STOP_RESTING
// CS_REST_CANCEL_RESTING
// CS_REST_RULE_CHECK
int cs_rest_GetUserScriptState(object pc=OBJECT_SELF);
// Delete the user script state variable from the specified player.
//
// pc The player from which the variable is to be deleted.
void cs_rest_DeleteUserScriptState(object pc);
// Determine whether a specific rest rule has been enabled in the resting
// system configuration. Though the user rules can be checked with this
// function, they are always enabled.
//
// This function may only be used within the CS_REST_RULE_CHECK execution
// point for a user script.
//
// rule The specific rest rule that is to be checked. This value
// must be one of the following constants:
// CS_REST_RULE_LAST_REST
// CS_REST_RULE_DAY_ONLY
// CS_REST_RULE_NIGHT_ONLY
// CS_REST_RULE_NO_ARMOUR
// CS_REST_RULE_NO_WEAPONS
// CS_REST_RULE_NO_BEDROLL
// CS_REST_RULE_USER_1
// CS_REST_RULE_USER_2
// CS_REST_RULE_USER_3
// CS_REST_RULE_USER_4
// CS_REST_RULE_USER_5
// CS_REST_RULE_USER_6
// CS_REST_RULE_USER_7
// CS_REST_RULE_USER_8
// CS_REST_RULE_USER_9
// CS_REST_RULE_USER_10
// CS_REST_RULE_USER_11
// CS_REST_RULE_USER_12
// CS_REST_RULE_USER_13
// CS_REST_RULE_USER_14
// CS_REST_RULE_USER_15
// CS_REST_RULE_USER_16
// state TRUE if the rule is enabled, which means the rest subsystem
// will evaluate the rule when determining whether a player is
// allowed to rest, otherwise FALSE.
// pc The player who is resting. This value will default to the
// current object, which will always be the resting player when
// this function is called from a user script.
// returns TRUE if the specified rule has been enabled in the rest
// subsystem configuration, or FALSE if the rule is not enabled.
int cs_rest_GetIsRuleEnabled(int rule, object pc=OBJECT_SELF);
// Determine the current state of a specific rest rule, either a builtin rule
// or a user rule. The builtin rules are evaluated before the user script is
// executed. User rules are provided specifically for use by builders, will
// always be FALSE initially, and will never be changed by the rest subsystem.
//
// This function may only be used within the CS_REST_RULE_CHECK execution
// point for a user script.
//
// rule The specific rest rule that is to be checked. This value
// must be one of the following constants:
// CS_REST_RULE_LAST_REST
// CS_REST_RULE_DAY_ONLY
// CS_REST_RULE_NIGHT_ONLY
// CS_REST_RULE_NO_ARMOUR
// CS_REST_RULE_NO_WEAPONS
// CS_REST_RULE_NO_BEDROLL
// CS_REST_RULE_USER_1
// CS_REST_RULE_USER_2
// CS_REST_RULE_USER_3
// CS_REST_RULE_USER_4
// CS_REST_RULE_USER_5
// CS_REST_RULE_USER_6
// CS_REST_RULE_USER_7
// CS_REST_RULE_USER_8
// CS_REST_RULE_USER_9
// CS_REST_RULE_USER_10
// CS_REST_RULE_USER_11
// CS_REST_RULE_USER_12
// CS_REST_RULE_USER_13
// CS_REST_RULE_USER_14
// CS_REST_RULE_USER_15
// CS_REST_RULE_USER_16
// pc The player who is resting. This value will default to the
// current object, which will always be the resting player when
// this function is called from a user script.
// returns TRUE if the rule has been evaluated and the player does not
// satisfy it (which will prevent the player from resting),
// otherwise FALSE (which will allow the player to rest).
int cs_rest_GetRule(int rule, object pc=OBJECT_SELF);
// Set or clear the specified rule for a resting player. When the rule is
// set, i.e. the state is TRUE, the player will not be permitted to rest.
// If any rule at all is set to TRUE, the player will be prevented from
// resting. This function may be used to change the state of one of the
// builtin rest rules, or a user rule. User rules are provided specifically
// for use by builders.
//
// If a builtin rest rule is not enabled in the configuration for the resting
// subsystem, then changing the state of that rule will have no effect. The
// user rules are always considered enabled.
//
// This function may only be used within the CS_REST_RULE_CHECK execution
// point for a user script.
//
// rule The specific rest rule that is to be changed. This value
// must be one of the following constants:
// CS_REST_RULE_LAST_REST
// CS_REST_RULE_DAY_ONLY
// CS_REST_RULE_NIGHT_ONLY
// CS_REST_RULE_NO_ARMOUR
// CS_REST_RULE_NO_WEAPONS
// CS_REST_RULE_NO_BEDROLL
// CS_REST_RULE_USER_1
// CS_REST_RULE_USER_2
// CS_REST_RULE_USER_3
// CS_REST_RULE_USER_4
// CS_REST_RULE_USER_5
// CS_REST_RULE_USER_6
// CS_REST_RULE_USER_7
// CS_REST_RULE_USER_8
// CS_REST_RULE_USER_9
// CS_REST_RULE_USER_10
// CS_REST_RULE_USER_11
// CS_REST_RULE_USER_12
// CS_REST_RULE_USER_13
// CS_REST_RULE_USER_14
// CS_REST_RULE_USER_15
// CS_REST_RULE_USER_16
// state TRUE if the rule is to be set, which will disallow resting,
// otherwise FALSE to allow resting.
// pc The player who is resting. This value will default to the
// current object, which will always be the resting player when
// this function is called from a user script.
void cs_rest_SetRule(int rule, int state, object pc=OBJECT_SELF);
// Abort resting for a specific player even if that player has satisfied all
// enabled rest rules.
//
// This function may only be used within the CS_REST_START_RESTING execution
// point for a user script.
//
// pc The player who is resting. This value will default to the
// current object, which will always be the resting player when
// this function is called from a user script.
void cs_rest_SetAbort(object pc=OBJECT_SELF);
//----------------------------------------------------------------------------
// Double integer precision date arithmetic support.
const int cs_rest_secondsPerMinute = 60;
int cs_rest_secondsPerHour = FloatToInt(HoursToSeconds(1));
const int cs_rest_hoursPerDay = 24;
int cs_rest_secondsPerDay = cs_rest_hoursPerDay * cs_rest_secondsPerHour;
const int cs_rest_daysPerMonth = 28;
const int cs_rest_daysPerYear = 336;
struct cs_rest_time cs_rest_GetCurrentTime(struct cs_rest_config cfg) {
struct cs_rest_time time;
time.days = GetCalendarYear() * cs_rest_daysPerYear;
time.days += GetCalendarMonth() * cs_rest_daysPerMonth;
time.days += GetCalendarDay();
time.seconds = GetTimeHour() * cs_rest_secondsPerHour;
time.seconds += GetTimeMinute() * cs_rest_secondsPerMinute;
time.seconds += GetTimeSecond();
return time;
}
// Add b to a.
struct cs_rest_time cs_rest_AddTime(struct cs_rest_time a, struct cs_rest_time b) {
a.seconds += b.seconds;
if (a.seconds >= cs_rest_secondsPerDay) {
a.seconds -= cs_rest_secondsPerDay;
a.days++;
}
a.days += b.days;
return a;
}
// Subtract b from a.
struct cs_rest_time cs_rest_SubtractTime(struct cs_rest_time a, struct cs_rest_time b) {
a.seconds -= b.seconds;
if (a.seconds < 0) {
a.seconds += cs_rest_secondsPerDay;
a.days--;
}
a.days -= b.days;
return a;
}
// Determine if a is greater than b.
int cs_rest_GetIsTimeGreater(struct cs_rest_time a, struct cs_rest_time b) {
if (a.days > b.days) return TRUE;
if (a.days < b.days) return FALSE;
if (a.seconds > b.seconds) return TRUE;
return FALSE;
}
// Determine if a is less than b.
int cs_rest_GetIsTimeLess(struct cs_rest_time a, struct cs_rest_time b) {
if (a.days < b.days) return TRUE;
if (a.days > b.days) return FALSE;
if (a.seconds < b.seconds) return TRUE;
return FALSE;
}
// Determine whether a equals b.
int cs_rest_GetIsTimeEqual(struct cs_rest_time a, struct cs_rest_time b) {
if ((a.days == b.days) && (a.seconds == b.seconds)) return TRUE;
return FALSE;
}
// Convert a time to a string representation.
string cs_rest_TimeToString(struct cs_rest_time time) {
return IntToString(time.days) + "." + IntToString(time.seconds);
}
// Construct a time value from individual values.
struct cs_rest_time cs_rest_Time(int days, int seconds) {
struct cs_rest_time time;
time.days = days;
time.seconds = seconds;
return time;
}
//----------------------------------------------------------------------------
void cs_rest_ShowConfig(struct cs_rest_config cfg) {
if (cs_dbg_GetIsEnabled() || GetIsObjectValid(cfg.debug)) {
// Data generated within the rest system.
cs_dbg_Trace(
"cfg.permitted: " + IntToString(cfg.permitted),
cfg.debug
);
cs_dbg_Trace(
"cfg.ruleFlags: " + IntToString(cfg.ruleFlags),
cfg.debug
);
cs_dbg_Trace(
"cfg.started: " + IntToString(cfg.started),
cfg.debug
);
cs_dbg_Trace(
"cfg.savedHitPoints: " + IntToString(cfg.savedHitPoints),
cfg.debug
);
cs_dbg_Trace(
"cfg.profile: " + cfg.profile,
cfg.debug
);
cs_dbg_Trace(
"cfg.overrideProfile: " + cfg.overrideProfile,
cfg.debug
);
cs_dbg_Trace(
"cfg.trigger: " + GetName(cfg.trigger),
cfg.debug
);
cs_dbg_Trace(
"cfg.lastRest: " +
cs_rest_TimeToString(cs_rest_Time(cfg.lastRestDays, cfg.lastRestSeconds)),
cfg.debug
);
// Configuration data.
cs_dbg_Trace(
"cfg.debug: " + ObjectToString(cfg.debug),
cfg.debug
);
cs_dbg_Trace(
"cfg.enabled: " + IntToString(cfg.enabled),
cfg.debug
);
cs_dbg_Trace(
"cfg.neverPermitted: " + IntToString(cfg.neverPermitted),
cfg.debug
);
// cs_dbg_Trace(
// "cfg.allowed: " + IntToString(cfg.allowed),
// cfg.debug
// );
cs_dbg_Trace(
"cfg.defaultProfile: " + cfg.defaultProfile,
cfg.debug
);
cs_dbg_Trace(
"cfg.limit: " + IntToString(cfg.limit),
cfg.debug
);
cs_dbg_Trace(
"cfg.use3Ed: " + IntToString(cfg.use3Ed),
cfg.debug
);
cs_dbg_Trace(
"cfg.noArmour: " + IntToString(cfg.noArmour),
cfg.debug
);
cs_dbg_Trace(
"cfg.noWeapons: " + IntToString(cfg.noWeapons),
cfg.debug
);
cs_dbg_Trace(
"cfg.useBedroll: " + IntToString(cfg.useBedroll),
cfg.debug
);
cs_dbg_Trace(
"cfg.bedrollTag: " + cfg.bedrollTag,
cfg.debug
);
cs_dbg_Trace(
"cfg.bedrollMultiplier: " + FloatToString(cfg.bedrollMultiplier),
cfg.debug
);
cs_dbg_Trace(
"cfg.dayMode: " + IntToString(cfg.dayMode),
cfg.debug
);
cs_dbg_Trace(
"cfg.dayStart: " + IntToString(cfg.dayStart),
cfg.debug
);
cs_dbg_Trace(
"cfg.dayEnd: " + IntToString(cfg.dayEnd),
cfg.debug
);
cs_dbg_Trace(
"cfg.multiplier: " + FloatToString(cfg.multiplier),
cfg.debug
);
cs_dbg_Trace(
"cfg.fadeToBlack: " + IntToString(cfg.fadeToBlack),
cfg.debug
);
cs_dbg_Trace(
"cfg.noMessages: " + IntToString(cfg.noMessages),
cfg.debug
);
cs_dbg_Trace(
"cfg.useConBonus: " + IntToString(cfg.useConBonus),
cfg.debug
);
cs_dbg_Trace(
"cfg.userScript: " + cfg.userScript,
cfg.debug
);
cs_dbg_Trace(
"cfg.effects: " + cfg.effects,
cfg.debug
);
}
}
//----------------------------------------------------------------------------
struct cs_rest_config cs_rest_GetConfig(object container) {
struct cs_rest_config cfg;
cfg.debug = GetLocalObject(container, CS_REST_VAR_DEBUG);
cs_dbg_Enter("cs_rest_GetConfig(" + GetName(container) + ")", cfg.debug);
// Data generated within the rest system.
cfg.permitted = GetLocalInt(container, CS_REST_VAR_PERMITTED);
cfg.ruleFlags = GetLocalInt(container, CS_REST_VAR_RULE_FLAGS);
cfg.started = GetLocalInt(container, CS_REST_VAR_STARTED);
cfg.savedHitPoints = GetLocalInt(container, CS_REST_VAR_SAVE_HP);
cfg.profile = GetLocalString(container, CS_REST_VAR_PLAYER_PROFILE);
cfg.overrideProfile = GetLocalString(container, CS_REST_VAR_OVERRIDE_PROFILE);
cfg.trigger = GetLocalObject(container, CS_REST_VAR_TRIGGER);
cfg.lastRestDays = GetLocalInt(container, CS_REST_VAR_LAST_REST_DAYS);
cfg.lastRestSeconds = GetLocalInt(container, CS_REST_VAR_LAST_REST_SECONDS);
// Configuration data.
cfg.enabled = GetLocalInt(container, CS_REST_VAR_ENABLE);
cfg.neverPermitted = GetLocalInt(container, CS_REST_VAR_NEVER_PERMITTED);
// cfg.allowed = GetLocalInt(container, CS_REST_VAR_PLAYER_ALLOWED);
cfg.defaultProfile = GetLocalString(container, CS_REST_VAR_DEFAULT_PROFILE);
cfg.limit = GetLocalInt(container, CS_REST_VAR_TIME_LIMIT);
cfg.use3Ed = GetLocalInt(container, CS_REST_VAR_HP_3ED);
cfg.noArmour = GetLocalInt(container, CS_REST_VAR_NO_ARMOUR);
cfg.noWeapons = GetLocalInt(container, CS_REST_VAR_NO_WEAPONS);
cfg.useBedroll = GetLocalInt(container, CS_REST_VAR_BEDROLL_IN_USE);
cfg.bedrollTag = GetLocalString(container, CS_REST_VAR_BEDROLL_TAG);
cfg.bedrollMultiplier = GetLocalFloat(container, CS_REST_VAR_BEDROLL_MULTIPLIER);
cfg.dayMode = GetLocalInt(container, CS_REST_VAR_DAY_MODE);
cfg.dayStart = GetLocalInt(container, CS_REST_VAR_DAY_START);
cfg.dayEnd = GetLocalInt(container, CS_REST_VAR_DAY_END);
cfg.multiplier = GetLocalFloat(container, CS_REST_VAR_MULTIPLIER);
cfg.fadeToBlack = GetLocalInt(container, CS_REST_VAR_FADE_TO_BLACK);
cfg.noMessages = GetLocalInt(container, CS_REST_VAR_NO_MESSAGES);
cfg.useConBonus = GetLocalInt(container, CS_REST_VAR_CON_BONUS);
cfg.userScript = GetLocalString(container, CS_REST_VAR_USER_SCRIPT);
cfg.effects = GetLocalString(container, CS_REST_VAR_EFFECTS);
if (cfg.bedrollMultiplier < 0.0f) {
cfg.bedrollMultiplier = 0.5f;
}
if (cfg.multiplier <= 0.0f) {
cfg.multiplier = 1.0f;
}
cs_rest_ShowConfig(cfg);
cs_dbg_Exit("cs_rest_GetConfig", cfg.debug);
return cfg;
}
//----------------------------------------------------------------------------
void cs_rest_SetConfig(object container, struct cs_rest_config cfg) {
cs_dbg_Enter("cs_rest_SetConfig(" + GetName(container) + ")", cfg.debug);
cs_rest_ShowConfig(cfg);
if (cfg.bedrollMultiplier < 0.0f) {
cfg.bedrollMultiplier = 0.5f;
}
if (cfg.multiplier <= 0.0f) {
cfg.multiplier = 1.0f;
}
// Data generated within the rest system.
SetLocalInt(container, CS_REST_VAR_PERMITTED, cfg.permitted);
SetLocalInt(container, CS_REST_VAR_RULE_FLAGS, cfg.ruleFlags);
SetLocalInt(container, CS_REST_VAR_STARTED, cfg.started);
SetLocalInt(container, CS_REST_VAR_SAVE_HP, cfg.savedHitPoints);
SetLocalString(container, CS_REST_VAR_PLAYER_PROFILE, cfg.profile);
SetLocalString(container, CS_REST_VAR_OVERRIDE_PROFILE, cfg.overrideProfile);
SetLocalObject(container, CS_REST_VAR_TRIGGER, cfg.trigger);
SetLocalInt(container, CS_REST_VAR_LAST_REST_DAYS, cfg.lastRestDays);
SetLocalInt(container, CS_REST_VAR_LAST_REST_SECONDS, cfg.lastRestSeconds);
// Configuration data.
SetLocalObject(container, CS_REST_VAR_DEBUG, cfg.debug);
SetLocalInt(container, CS_REST_VAR_ENABLE, cfg.enabled);
SetLocalInt(container, CS_REST_VAR_NEVER_PERMITTED, cfg.neverPermitted);
// SetLocalInt(container, CS_REST_VAR_PLAYER_ALLOWED, cfg.allowed);
SetLocalString(container, CS_REST_VAR_DEFAULT_PROFILE, cfg.defaultProfile);
SetLocalInt(container, CS_REST_VAR_TIME_LIMIT, cfg.limit);
SetLocalInt(container, CS_REST_VAR_HP_3ED, cfg.use3Ed);
SetLocalInt(container, CS_REST_VAR_NO_ARMOUR, cfg.noArmour);
SetLocalInt(container, CS_REST_VAR_NO_WEAPONS, cfg.noWeapons);
SetLocalInt(container, CS_REST_VAR_BEDROLL_IN_USE, cfg.useBedroll);
SetLocalString(container, CS_REST_VAR_BEDROLL_TAG, cfg.bedrollTag);
SetLocalFloat(container, CS_REST_VAR_BEDROLL_MULTIPLIER, cfg.bedrollMultiplier);
SetLocalInt(container, CS_REST_VAR_DAY_MODE, cfg.dayMode);
SetLocalInt(container, CS_REST_VAR_DAY_START, cfg.dayStart);
SetLocalInt(container, CS_REST_VAR_DAY_END, cfg.dayEnd);
SetLocalFloat(container, CS_REST_VAR_MULTIPLIER, cfg.multiplier);
SetLocalInt(container, CS_REST_VAR_FADE_TO_BLACK, cfg.fadeToBlack);
SetLocalInt(container, CS_REST_VAR_NO_MESSAGES, cfg.noMessages);
SetLocalInt(container, CS_REST_VAR_CON_BONUS, cfg.useConBonus);
SetLocalString(container, CS_REST_VAR_USER_SCRIPT, cfg.userScript);
SetLocalString(container, CS_REST_VAR_EFFECTS, cfg.effects);
cs_dbg_Exit("cs_rest_SetConfig", cfg.debug);
}
//----------------------------------------------------------------------------
void cs_rest_DeleteConfig(object container) {
object debug = GetLocalObject(container, CS_REST_VAR_DEBUG);
cs_dbg_Enter("cs_rest_DeleteConfig(" + GetName(container) + ")", debug);
// Data generated within the rest system and used only when a player is
// actually resting. It is not necessary to store this data within a
// persistence mechanism since should either a player log out or the
// server crash, the player won't be resting anymore and so this data
// will be superfluous.
DeleteLocalInt(container, CS_REST_VAR_PERMITTED);
DeleteLocalInt(container, CS_REST_VAR_RULE_FLAGS);
DeleteLocalString(container, CS_REST_VAR_OVERRIDE_PROFILE);
DeleteLocalInt(container, CS_REST_VAR_STARTED);
DeleteLocalInt(container, CS_REST_VAR_SAVE_HP);
// These variables are used by the resting system to track the current
// state of the player with regard to resting policies, however since
// the values are set through trigger scripts, it is not necessary to
// store the data in a persistence mechanism as it will simply be
// recreated when the player logs in again and reenters the trigger.
// The following variables are deleted elsewhere and are listed
// here merely for completion. These deletions should not be
// uncommented.
// DeleteLocalString(container, CS_REST_VAR_PLAYER_PROFILE);
// DeleteLocalObject(container, CS_REST_VAR_TRIGGER);
// These variables are maintained across rests and constitute the
// persistent data within the resting subsystem. Should full persistence
// be desired, this data should be stored for each player and restored
// to each player when they log in. The following variables are deleted
// elsewhere if necessary and are listed here merely for completion.
// These deletions should not be uncommented.
// DeleteLocalInt(container, CS_REST_VAR_LAST_REST_DAYS);
// DeleteLocalInt(container, CS_REST_VAR_LAST_REST_SECONDS);
// Configuration data. This data is generated from the configuration
// containers each time a player rests and so it is not necessary for
// any of this data to be stored in a persistence mechanism.
DeleteLocalObject(container, CS_REST_VAR_DEBUG);
DeleteLocalInt(container, CS_REST_VAR_ENABLE);
DeleteLocalInt(container, CS_REST_VAR_NEVER_PERMITTED);
// DeleteLocalInt(container, CS_REST_VAR_PLAYER_ALLOWED);
DeleteLocalString(container, CS_REST_VAR_DEFAULT_PROFILE);
DeleteLocalInt(container, CS_REST_VAR_TIME_LIMIT);
DeleteLocalInt(container, CS_REST_VAR_HP_3ED);
DeleteLocalInt(container, CS_REST_VAR_NO_ARMOUR);
DeleteLocalInt(container, CS_REST_VAR_NO_WEAPONS);
DeleteLocalInt(container, CS_REST_VAR_BEDROLL_IN_USE);
DeleteLocalString(container, CS_REST_VAR_BEDROLL_TAG);
DeleteLocalFloat(container, CS_REST_VAR_BEDROLL_MULTIPLIER);
DeleteLocalInt(container, CS_REST_VAR_DAY_MODE);
DeleteLocalInt(container, CS_REST_VAR_DAY_START);
DeleteLocalInt(container, CS_REST_VAR_DAY_END);
DeleteLocalFloat(container, CS_REST_VAR_MULTIPLIER);
DeleteLocalInt(container, CS_REST_VAR_FADE_TO_BLACK);
DeleteLocalInt(container, CS_REST_VAR_NO_MESSAGES);
DeleteLocalInt(container, CS_REST_VAR_CON_BONUS);
DeleteLocalString(container, CS_REST_VAR_USER_SCRIPT);
DeleteLocalString(container, CS_REST_VAR_EFFECTS);
// Custom text messages.
DeleteLocalString(container, CS_REST_VAR_START_TEXT);
DeleteLocalString(container, CS_REST_VAR_FINISH_TEXT);
DeleteLocalString(container, CS_REST_VAR_CANCEL_TEXT);
DeleteLocalString(container, CS_REST_VAR_CANNOT_TEXT);
DeleteLocalString(container, CS_REST_VAR_TOO_SOON_TEXT);
DeleteLocalString(container, CS_REST_VAR_DAY_ONLY_TEXT);
DeleteLocalString(container, CS_REST_VAR_NIGHT_ONLY_TEXT);
DeleteLocalString(container, CS_REST_VAR_NO_ARMOUR_TEXT);
DeleteLocalString(container, CS_REST_VAR_NO_WEAPON_TEXT);
DeleteLocalString(container, CS_REST_VAR_BEDROLL_RUINED_TEXT);
DeleteLocalString(container, CS_REST_VAR_NOT_COMFORTABLE_TEXT);
DeleteLocalString(container, CS_REST_VAR_ENTER_REST_TEXT);
DeleteLocalString(container, CS_REST_VAR_EXIT_REST_TEXT);
DeleteLocalString(container, CS_REST_VAR_UNSAFE_TEXT);
DeleteLocalString(container, CS_REST_VAR_ENTER_NO_REST_TEXT);
DeleteLocalString(container, CS_REST_VAR_EXIT_NO_REST_TEXT);
DeleteLocalString(container, CS_REST_VAR_NO_BEDROLL_TEXT);
cs_dbg_Exit("cs_rest_DeleteConfig", debug);
}
//----------------------------------------------------------------------------
string cs_rest_GetProfile(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
string profile = GetLocalString(pc, CS_REST_VAR_PLAYER_PROFILE);
cs_dbg_Trace(
"cs_rest_GetProfile(" + GetName(pc) + "): " + profile,
debug
);
return profile;
}
//----------------------------------------------------------------------------
void cs_rest_SetProfile(object pc, string profile) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetProfile(" + GetName(pc) + "): " + profile,
debug
);
SetLocalString(pc, CS_REST_VAR_PLAYER_PROFILE, profile);
}
//----------------------------------------------------------------------------
string cs_rest_GetOverrideProfile(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
string profile = GetLocalString(pc, CS_REST_VAR_OVERRIDE_PROFILE);
cs_dbg_Trace(
"cs_rest_GetOverrideProfile(" + GetName(pc) + "): " + profile,
debug
);
return profile;
}
//----------------------------------------------------------------------------
void cs_rest_SetOverrideProfile(object pc, string profile) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetOverrideProfile(" + GetName(pc) + "): " + profile,
debug
);
SetLocalString(pc, CS_REST_VAR_OVERRIDE_PROFILE, profile);
}
//----------------------------------------------------------------------------
void cs_rest_DeleteProfile(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_DeleteProfile(" + GetName(pc) + ")",
debug
);
DeleteLocalString(pc, CS_REST_VAR_PLAYER_PROFILE);
}
//----------------------------------------------------------------------------
void cs_rest_SetUserScriptState(object pc, int state) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetUserScriptState(" + GetName(pc) + ", " + IntToString(state) + ")",
debug
);
SetLocalInt(pc, CS_REST_VAR_USER_SCRIPT_STATE, state);
}
//----------------------------------------------------------------------------
int cs_rest_GetUserScriptState(object pc=OBJECT_SELF) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
int state = GetLocalInt(pc, CS_REST_VAR_USER_SCRIPT_STATE);
cs_dbg_Trace(
"cs_rest_GetUserScriptState(" + GetName(pc) + "): " + IntToString(state),
debug
);
return state;
}
//----------------------------------------------------------------------------
void cs_rest_DeleteUserScriptState(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_DeleteUserScriptState(" + GetName(pc) + ")",
debug
);
DeleteLocalString(pc, CS_REST_VAR_USER_SCRIPT_STATE);
}
//----------------------------------------------------------------------------
int cs_rest_GetIsRuleEnabled(int rule, object pc=OBJECT_SELF) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
int state = TRUE;
switch(rule) {
case CS_REST_RULE_LAST_REST:
state = (GetLocalInt(pc, CS_REST_VAR_TIME_LIMIT) > 0);
break;
case CS_REST_RULE_DAY_ONLY:
state = (GetLocalInt(pc, CS_REST_VAR_DAY_MODE) == CS_REST_DAY_ONLY);
break;
case CS_REST_RULE_NIGHT_ONLY:
state = (GetLocalInt(pc, CS_REST_VAR_DAY_MODE) == CS_REST_NIGHT_ONLY);
break;
case CS_REST_RULE_NO_ARMOUR:
state = GetLocalInt(pc, CS_REST_VAR_NO_ARMOUR);
break;
case CS_REST_RULE_NO_WEAPONS:
state = GetLocalInt(pc, CS_REST_VAR_NO_WEAPONS);
break;
case CS_REST_RULE_NO_BEDROLL:
state = GetLocalInt(pc, CS_REST_VAR_BEDROLL_IN_USE);
break;
}
cs_dbg_Trace(
"cs_rest_GetIsRuleEnabled(" +
IntToString(rule) + ", " +
GetName(pc) + "): " +
IntToString(state),
debug
);
return state;
}
//----------------------------------------------------------------------------
int cs_rest_GetRule(int rule, object pc=OBJECT_SELF) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
int flags = GetLocalInt(pc, CS_REST_VAR_RULE_FLAGS);
int state = flags & rule;
cs_dbg_Trace(
"cs_rest_GetRule(" +
IntToString(rule) + ", " +
GetName(pc) + "): " +
IntToString(state),
debug
);
return state;
}
//----------------------------------------------------------------------------
void cs_rest_SetRule(int rule, int state, object pc=OBJECT_SELF) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Enter(
"cs_rest_SetRule(" +
IntToString(rule) + ", " +
IntToString(state) + ", " +
GetName(pc) + ")",
debug
);
if (cs_rest_GetIsRuleEnabled(rule, pc)) {
int flags = GetLocalInt(pc, CS_REST_VAR_RULE_FLAGS);
cs_dbg_Trace("flags before: " + IntToHexString(flags));
if (state) {
// We want to set the flag.
flags |= rule;
}
else {
// We want to clear the flag.
flags &= ~rule;
}
cs_dbg_Trace("flags after: " + IntToHexString(flags));
SetLocalInt(pc, CS_REST_VAR_RULE_FLAGS, flags);
}
else {
cs_dbg_Trace("disabled rule");
}
cs_dbg_Exit("cs_rest_SetRule", debug);
}
//----------------------------------------------------------------------------
void cs_rest_SetAbort(object pc=OBJECT_SELF) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetAbort(" +
GetName(pc) + ")",
debug
);
SetLocalInt(pc, CS_REST_VAR_PERMITTED, FALSE);
}
//----------------------------------------------------------------------------
struct cs_rest_time cs_rest_GetLastRestTime(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
struct cs_rest_time time = cs_rest_Time(
GetLocalInt(pc, CS_REST_VAR_LAST_REST_DAYS),
GetLocalInt(pc, CS_REST_VAR_LAST_REST_SECONDS)
);
cs_dbg_Trace(
"cs_rest_GetLastRestTime(" + GetName(pc) + "): " +
cs_rest_TimeToString(time),
debug
);
return time;
}
//----------------------------------------------------------------------------
void cs_rest_SetLastRestTime(object pc, struct cs_rest_time time) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetLastRestTime(" + GetName(pc) + "): " +
cs_rest_TimeToString(time),
debug
);
SetLocalInt(pc, CS_REST_VAR_LAST_REST_DAYS, time.days);
SetLocalInt(pc, CS_REST_VAR_LAST_REST_SECONDS, time.seconds);
}
//----------------------------------------------------------------------------
object cs_rest_GetTriggeringObject(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
object trigger = GetLocalObject(pc, CS_REST_VAR_TRIGGER);
cs_dbg_Trace(
"cs_rest_GetTriggeringObject(" + GetName(pc) + "): " +
GetName(trigger),
debug
);
return trigger;
}
//----------------------------------------------------------------------------
void cs_rest_SetTriggeringObject(object pc, object trigger) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetTriggeringObject(" + GetName(pc) + "): " +
GetName(trigger),
debug
);
SetLocalObject(pc, CS_REST_VAR_TRIGGER, trigger);
}
//----------------------------------------------------------------------------
void cs_rest_DeleteTriggeringObject(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_DeleteTriggeringObject(" + GetName(pc) + ")",
debug
);
DeleteLocalObject(pc, CS_REST_VAR_TRIGGER);
}
//----------------------------------------------------------------------------
string cs_rest_GetState(object pc) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
string state = "";
struct cs_rest_time lastRest = cs_rest_GetLastRestTime(pc);
state += IntToString(lastRest.days);
state += ":";
state += IntToString(lastRest.seconds);
cs_dbg_Trace("cs_rest_GetState: " + state, debug);
return state;
}
//----------------------------------------------------------------------------
void cs_rest_SetState(object pc, string state, int timeOffset=0) {
object debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Trace(
"cs_rest_SetState(" +
GetName(pc) + ", " +
state + ", " +
IntToString(timeOffset) + ")",
debug
);
cs_tkn_SetTokenString(state, ":");
int lastRestDays = StringToInt(cs_tkn_GetNextToken());
int lastRestSeconds = StringToInt(cs_tkn_GetNextToken());
struct cs_rest_time lastRest = cs_rest_Time(lastRestDays, lastRestSeconds);
if (timeOffset != 0) {
lastRest = cs_rest_AddTime(lastRest, cs_rest_Time(0, timeOffset));
}
cs_rest_SetLastRestTime(pc, lastRest);
}
//----------------------------------------------------------------------------
int cs_rest_GetIsWearingHelm(object pc, struct cs_rest_config cfg) {
int result = FALSE;
int head = GetBaseItemType(GetItemInSlot(INVENTORY_SLOT_HEAD, pc));
if (head == BASE_ITEM_HELMET) {
result = TRUE;
}
cs_dbg_Trace(
"cs_rest_GetIsWearingHelm(" + GetName(pc) + "): " +
IntToString(result),
cfg.debug
);
return result;
}
//----------------------------------------------------------------------------
int cs_rest_GetIsWearingArmour(object pc, struct cs_rest_config cfg) {
int result = FALSE;
object armour = GetItemInSlot(INVENTORY_SLOT_CHEST, pc);
if (GetItemACValue(armour) > 5) {
result = TRUE;
}
cs_dbg_Trace(
"cs_rest_GetIsWearingArmour(" + GetName(pc) + "): " +
IntToString(result),
cfg.debug
);
return result;
}
//----------------------------------------------------------------------------
int cs_rest_GetIsArmed(object pc, struct cs_rest_config cfg) {
int result = 0;
if (GetIsObjectValid(pc)) {
int hand1 = GetBaseItemType(
GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, pc)
);
if (hand1 != BASE_ITEM_INVALID) {
result++;
}
int hand2 = GetBaseItemType(
GetItemInSlot(INVENTORY_SLOT_LEFTHAND, pc)
);
if (!((hand2 == BASE_ITEM_INVALID) ||
(hand2 == BASE_ITEM_TORCH) ||
(hand2 == BASE_ITEM_SMALLSHIELD) ||
(hand2 == BASE_ITEM_LARGESHIELD) ||
(hand2 == BASE_ITEM_TOWERSHIELD))
) {
result++;
}
}
cs_dbg_Trace(
"cs_rest_GetIsArmed(" + GetName(pc) + "): " + IntToString(result),
cfg.debug
);
return result;
}
//----------------------------------------------------------------------------
int cs_rest_GetIsShieldEquipped(object pc, struct cs_rest_config cfg) {
int result = 0;
if (GetIsObjectValid(pc)) {
int hand2 = GetBaseItemType(
GetItemInSlot(INVENTORY_SLOT_LEFTHAND, pc)
);
if ((hand2 == BASE_ITEM_SMALLSHIELD) ||
(hand2 == BASE_ITEM_LARGESHIELD) ||
(hand2 == BASE_ITEM_TOWERSHIELD)
) {
result = TRUE;
}
}
cs_dbg_Trace(
"cs_rest_GetIsShieldEquipped(" + GetName(pc) + "): " +
IntToString(result),
cfg.debug
);
return result;
}
//----------------------------------------------------------------------------
struct cs_rest_config cs_rest_SetRuleFlag(struct cs_rest_config cfg, int rule, int value) {
cs_dbg_Enter(
"cs_rest_SetRuleFlag(" +
IntToString(rule) + ", " +
IntToString(value) + ")",
cfg.debug
);
cs_dbg_Trace("before flags: " + IntToString(cfg.ruleFlags));
if (value) {
// We want to set the flag.
cfg.ruleFlags |= rule;
}
else {
// We want to clear the flag.
cfg.ruleFlags &= ~rule;
}
cs_dbg_Trace("after flags: " + IntToString(cfg.ruleFlags));
cs_dbg_Exit("cs_rest_SetRuleFlag");
return cfg;
}
//----------------------------------------------------------------------------
int cs_rest_GetRuleFlag(struct cs_rest_config cfg, int rule) {
int flag = cfg.ruleFlags &= rule;
cs_dbg_Trace("cs_rest_GetRuleFlag(" + IntToString(rule) +"): " + IntToString(flag));
return flag;
}
//----------------------------------------------------------------------------
struct cs_rest_config cs_rest_GetIsRestPermitted(
object pc,
struct cs_rest_config cfg
) {
// By default, resting is permitted and no rule flags are set.
cfg.permitted = TRUE;
cfg.ruleFlags = 0;
// Check whether this creature is ever allowed to rest at all.
if (cfg.neverPermitted) {
cfg.permitted = FALSE;
}
// Check for a rest time limit.
if (cfg.permitted && (cfg.limit > 0)) {
// Determine the current time.
struct cs_rest_time currentTime = cs_rest_GetCurrentTime(cfg);
// Determine the time at which resting is next available by adding
// the current rest limit to the last rest time.
struct cs_rest_time nextRest = cs_rest_Time(
cfg.lastRestDays,
cfg.lastRestSeconds
);
nextRest = cs_rest_AddTime(nextRest, cs_rest_Time(0, cfg.limit));
cs_dbg_Trace(
"current time: " + cs_rest_TimeToString(currentTime),
cfg.debug
);
cs_dbg_Trace(
"Next rest time: " + cs_rest_TimeToString(nextRest),
cfg.debug
);
if (cs_rest_GetIsTimeLess(currentTime, nextRest)) {
// The required time period has not passed so the player
// may not rest yet.
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_TOO_SOON);
cfg = cs_rest_SetRuleFlag(cfg, CS_REST_RULE_LAST_REST, TRUE);
}
}
// Check for day only resting.
if (cfg.permitted && (cfg.dayMode == CS_REST_DAY_ONLY)) {
int hour = GetTimeHour();
if ((hour < cfg.dayStart) || (hour >= cfg.dayEnd)) {
cs_dbg_Trace("Day-only set and it is not day", cfg.debug);
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_DAY_ONLY);
cfg = cs_rest_SetRuleFlag(cfg, CS_REST_RULE_DAY_ONLY, TRUE);
}
}
// Check for night only resting.
if (cfg.permitted && (cfg.dayMode == CS_REST_NIGHT_ONLY)) {
int hour = GetTimeHour();
if ((hour >= cfg.dayStart) && (hour < cfg.dayEnd)) {
cs_dbg_Trace("Night-only set and it is not night", cfg.debug);
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_NIGHT_ONLY);
cfg = cs_rest_SetRuleFlag(cfg, CS_REST_RULE_NIGHT_ONLY, TRUE);
}
}
// Check if wearing armour.
if (cfg.permitted && cfg.noArmour) {
if (cs_rest_GetIsWearingHelm(pc, cfg) ||
cs_rest_GetIsShieldEquipped(pc, cfg) ||
cs_rest_GetIsWearingArmour(pc, cfg)
) {
cs_dbg_Trace("Armour is not permitted while resting", cfg.debug);
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_NO_ARMOUR);
cfg = cs_rest_SetRuleFlag(cfg, CS_REST_RULE_NO_ARMOUR, TRUE);
}
}
// Check if carrying weapons.
if (cfg.permitted && cfg.noWeapons) {
if (cs_rest_GetIsArmed(pc, cfg)) {
cs_dbg_Trace("Arms are not permitted while resting", cfg.debug);
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_NO_WEAPON);
cfg = cs_rest_SetRuleFlag(cfg, CS_REST_RULE_NO_WEAPONS, TRUE);
}
}
// Check if carrying a bedroll.
if (cfg.permitted && cfg.useBedroll) {
object item = GetItemPossessedBy(pc, cfg.bedrollTag);
if (GetIsObjectValid(item)) {
// Increment a usage count on the bedroll.
// XXX This may need to be persistent.
int used = GetLocalInt(item, CS_REST_VAR_BEDROLL_USE);
used++;
if (used > CS_REST_DEF_BEDROLL_MAX_USE) {
cs_dbg_Trace("Bedroll has been destroyed through use", cfg.debug);
DestroyObject(item);
cs_rest_ShowFloatingTextByID(pc,cfg,CS_REST_TXT_BEDROLL_RUINED);
}
else {
cs_dbg_Trace("Incrementing bedroll use count", cfg.debug);
SetLocalInt(item, CS_REST_VAR_BEDROLL_USE, used);
}
}
else {
// Is there hit point regain without a bedroll?
if (cfg.bedrollMultiplier > 0.0) {
// No bedroll means only partial hit points regained.
cs_dbg_Trace("Resting without a bedroll reduces regain", cfg.debug);
cfg.multiplier = cfg.multiplier * cfg.bedrollMultiplier;
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_NOT_COMFORTABLE);
}
else {
// No bedroll means no rest allowed at all.
cs_dbg_Trace("Resting without a bedroll not permitted", cfg.debug);
cfg = cs_rest_SetRuleFlag(cfg, CS_REST_RULE_NO_BEDROLL, TRUE);
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_NO_BEDROLL);
}
}
}
// Execute external script hook for rest rule evaluation. We don't even
// bother executing the user script if the never permitted flag is set,
// since by definition the player will not be permitted to rest no matter
// what.
if ((cfg.userScript != "") && !cfg.neverPermitted) {
cs_rest_SetConfig(pc, cfg);
cs_rest_SetUserScriptState(pc, CS_REST_RULE_CHECK);
ExecuteScript(cfg.userScript, pc);
cs_rest_DeleteUserScriptState(pc);
cfg = cs_rest_GetConfig(pc);
}
if (cfg.permitted) {
// If resting is still permitted at this point, check whether any
// of the rules should disallow it. Any rule that is set will cause
// resting to be not permitted.
cs_dbg_Trace("Checking rule evaluation", cfg.debug);
cfg.permitted = (cfg.ruleFlags == 0);
cs_dbg_Trace(
"Permitted after rule evaluation: " + IntToString(cfg.permitted),
cfg.debug
);
}
cs_dbg_Trace(
"cs_rest_GetIsRestPermitted(" + GetName(pc) + "): " +
IntToString(cfg.permitted),
cfg.debug
);
return cfg;
}
//----------------------------------------------------------------------------
void cs_rest_ExecuteRestScript(object pc, struct cs_rest_config cfg) {
cs_dbg_Enter("cs_rest_ExecuteRestScript(" + GetName(pc) + ")", cfg.debug);
// Make sure that we have a rest profile.
string profile = cfg.profile;
if (profile == "") {
// No configured profile so fall back on the default.
profile = cfg.defaultProfile;
cs_dbg_Trace("No profile, assuming default: " + profile, cfg.debug);
}
if (cfg.overrideProfile != "") {
// There's an override so use that instead.
profile = cfg.overrideProfile;
cs_dbg_Trace("Using override profile instead: " + profile, cfg.debug);
}
cs_dbg_Trace("Running rest script: " + profile, cfg.debug);
ExecuteScript(profile, GetModule());
cs_dbg_Exit("cs_rest_ExecuteRestScript", cfg.debug);
}
//----------------------------------------------------------------------------
struct cs_rest_config cs_rest_ProcessConfig(
object pc,
object container,
struct cs_rest_config cfg
) {
cs_dbg_Enter("cs_rest_ProcessConfig(" + GetTag(container) + ")", cfg.debug);
// Do we have a valid object from which to configure?
if (GetIsObjectValid(container) && GetHasInventory(container)) {
cs_dbg_Trace(
"Valid configuration object: " + GetResRef(container),
cfg.debug
);
// Sort through all items in the configuration object's inventory,
// checking each one to see if it is something that we recognise.
object item = GetFirstItemInInventory(container);
while (GetIsObjectValid(item)) {
string resref = GetResRef(item);
if (resref == CS_REST_RR_DEBUG_ON) {
// Found a debug on value. The presence of this item is
// enough to indicate that debugging should be enabled.
// When debug is enabled, messages are sent to the player
// current resting.
cfg.debug = pc;
cs_dbg_EnableDestination(CS_DBG_ALL);
cs_dbg_Trace("Enabling debugging", cfg.debug);
}
else if (resref == CS_REST_RR_ENABLE) {
// Found an enable value. The presence of this item is
// enough to indicate that the rest system is active.
cfg.enabled = TRUE;
cs_dbg_Trace("Enabling resting", cfg.debug);
}
else if (resref == CS_REST_RR_DISABLE) {
// Found a disable value. The presence of this item is
// enough to indicate that the rest system is inactive.
cfg.enabled = FALSE;
cs_dbg_Trace("Disabling resting", cfg.debug);
}
else if (resref == CS_REST_RR_HP_3ED) {
// Found a 3ed HP value. The presence of this item is
// enough to indicate that the rest system should use 3rd
// edition style hit point rules.
cfg.use3Ed = TRUE;
cs_dbg_Trace("Using 3rd Ed Style HP", cfg.debug);
}
else if (resref == CS_REST_RR_HP_STD) {
// Found a standard HP value. The presence of this item is
// enough to indicate that the rest system should use normal
// hit point rules.
cfg.use3Ed = FALSE;
cs_dbg_Trace("Using standard HP", cfg.debug);
}
else if (resref == CS_REST_RR_PROFILE) {
// Found a profile value. Set the default profile to be
// a script the same name as this item's tag.
string profile = GetStringLowerCase(GetTag(item));
cfg.defaultProfile = profile;
cs_dbg_Trace("Default profile is " + profile, cfg.debug);
}
else if (resref == CS_REST_RR_DAY_ONLY) {
// Found a day-only value. The presence of this item is
// enough to indicate that resting should only be permitted
// during daylight hours.
cfg.dayMode = CS_REST_DAY_ONLY;
cs_dbg_Trace("Setting day only mode", cfg.debug);
}
else if (resref == CS_REST_RR_NIGHT_ONLY) {
// Found a night-only value. The presence of this item is
// enough to indicate that resting should only be permitted
// during night hours.
cfg.dayMode = CS_REST_NIGHT_ONLY;
cs_dbg_Trace("Setting night only mode", cfg.debug);
}
else if (resref == CS_REST_RR_ALL_HOURS) {
// Found an all-hours value. The presence of this item is
// enough to indicate that resting is permitted at all
// times during the day and night.
cfg.dayMode = CS_REST_DAY_AND_NIGHT;
cs_dbg_Trace("Setting resting for all hours", cfg.debug);
}
else if (resref == CS_REST_RR_DAY_START) {
// Found a start of day value. Convert the item's tag into an
// integer and use it as the starting hour for the "day".
int hour = StringToInt(GetTag(item));
if ((hour >= 0) && (hour < 23)) {
cfg.dayStart = hour;
cs_dbg_Trace(
"Setting day start: " + IntToString(hour),
cfg.debug
);
}
}
else if (resref == CS_REST_RR_DAY_END) {
// Found an end of day value. Convert the item's tag into an
// integer and use it as the ending hour for the "day".
int hour = StringToInt(GetTag(item));
if ((hour > 0) && (hour <= 23)) {
cfg.dayEnd = hour;
cs_dbg_Trace(
"Setting day end: " + IntToString(hour),
cfg.debug
);
}
}
else if (resref == CS_REST_RR_NO_ARMOUR) {
// Found a no armour value. The presence of this item is
// enough to indicate that resting is not permitted while
// wearing armour.
cfg.noArmour = TRUE;
cs_dbg_Trace("Setting no armour mode", cfg.debug);
}
else if (resref == CS_REST_RR_YES_ARMOUR) {
// Found an armour allowed value. The presence of this item
// is enough to indicate that resting is permitted even while
// armour is being worn.
cfg.noArmour = FALSE;
cs_dbg_Trace("Setting armour allowed mode", cfg.debug);
}
else if (resref == CS_REST_RR_NO_WEAPONS) {
// Found a no weapons value. The presence of this item is
// enough to indicate that resting is not permitted while
// weapons are equipped.
cfg.noWeapons = TRUE;
cs_dbg_Trace("Setting no weapons mode", cfg.debug);
}
else if (resref == CS_REST_RR_YES_WEAPONS) {
// Found a weapons allowed value. The presence of this item
// is enough to indicate that resting is permitted even while
// weapons are equipped.
cfg.noWeapons = FALSE;
cs_dbg_Trace("Setting weapons allowed mode", cfg.debug);
}
else if (resref == CS_REST_RR_NO_BEDROLL) {
// Found a no bedroll value. The presence of this item is
// enough to indicate that bedrolls are ignored completely
// for purposes of calculating hit point regain.
cfg.useBedroll = FALSE;
cs_dbg_Trace("Setting no bedroll mode", cfg.debug);
}
else if (resref == CS_REST_RR_YES_BEDROLL) {
// Found a bedroll in use value. The presence of this item
// is enough to indicate that bedrolls are used to determine
// the number of hit points regained while resting, while
// its tag contains the tag of the item that is to considered
// to be a bedroll.
cfg.useBedroll = TRUE;
cfg.bedrollTag = GetTag(item);
cs_dbg_Trace("Setting bedroll mode: " + GetTag(item), cfg.debug);
}
else if (resref == CS_REST_RR_BEDROLL_MULTIPLIER) {
// Found a bedroll HP multiplier value. The tag of this item
// provides a multiplier for hit points regained by players
// when bedrolls are in effect and no bedroll is present.
float multiplier = StringToInt(GetTag(item))/100.0;
if ((multiplier < 0.0) && (multiplier >= 100.0)) {
multiplier = CS_REST_DEF_BEDROLL_MULTIPLIER;
cs_dbg_Trace(
"Invalid Bedroll HP multiplier: " + GetTag(item),
cfg.debug
);
}
cfg.bedrollMultiplier = multiplier;
if (multiplier > 0.0) {
cs_dbg_Trace(
"Bedroll HP multiplier is " + FloatToString(cfg.multiplier),
cfg.debug
);
}
else {
cs_dbg_Trace(
"Resting without a bedroll is disabled",
cfg.debug
);
}
}
else if ((resref == CS_REST_RR_TIME_LIMIT) ||
(GetStringLeft(resref, 14) == CS_REST_RR_TIME_PREFIX)){
// Found a time limit value. Set the resting time limit to be
// an integer taken from this item's tag.
if (GetStringLowerCase(GetTag(item)) != "none") {
int limit = StringToInt(GetTag(item));
cfg.limit = limit;
cs_dbg_Trace(
"Time limit is " + IntToString(limit) + " seconds",
cfg.debug
);
}
else {
cs_dbg_Trace("Time limit does not apply", cfg.debug);
}
}
else if (resref == CS_REST_RR_FADE_TO_BLACK) {
// Found a fade to black value. The presence of this item
// is enough to indicate that the screen should fade to black
// when a player rests.
cfg.fadeToBlack = TRUE;
cs_dbg_Trace("The screen will fade to black", cfg.debug);
}
else if (resref == CS_REST_RR_NO_MESSAGES) {
// Found a no messages value. The presence of this item
// is enough to indicate the display of messages should be
// suppressed.
cfg.noMessages = TRUE;
cs_dbg_Trace("No floaty messages will be displayed", cfg.debug);
}
else if (resref == CS_REST_RR_USE_CON_BONUS) {
// Found a use CON bonus value. The presence of this item
// is enough to indicate that players should receive their
// CON bonus as hit points when resting.
cfg.useConBonus = TRUE;
cs_dbg_Trace("CON bonus will be used", cfg.debug);
}
else if (resref == CS_REST_RR_NO_CON_BONUS) {
// Found a no CON bonus value. The presence of this item
// is enough to indicate that players should not receive their
// CON bonus as hit points when resting.
cfg.useConBonus = FALSE;
cs_dbg_Trace("CON bonus will be not used", cfg.debug);
}
else if (resref == CS_REST_RR_HP_MULTIPLIER) {
// Found a HP multiplier value. The tag of this item provides
// a multiplier for hit points regained by players.
float multiplier = StringToInt(GetTag(item))/100.0;
if ((multiplier <= 0.0) && (multiplier >= 100.0)) {
multiplier = CS_REST_DEF_MULTIPLIER;
cs_dbg_Trace(
"Invalid HP multiplier: " + GetTag(item),
cfg.debug
);
}
cfg.multiplier = multiplier;
cs_dbg_Trace(
"HP multiplier is " + FloatToString(cfg.multiplier),
cfg.debug
);
}
else if (resref == CS_REST_RR_USER_SCRIPT) {
// Found a user script value. The tag of this item provides
// the name of a script to be executed at user hook points.
cfg.userScript = GetStringLowerCase(GetTag(item));
cs_dbg_Trace("User script is " + cfg.userScript, cfg.debug);
}
else if (resref == CS_REST_RR_TEXT_MESSAGES) {
// Found a container item for text messages. A set of
// variables on this item may override the default messages.
cs_dbg_Trace("Floaty messages will be displayed", cfg.debug);
cfg.noMessages = FALSE;
cs_rest_UpdateMessages(pc, cfg, item);
}
else if (resref == CS_REST_RR_EFFECTS) {
// Found an effects value. A set of effects may be applied
// to a player when resting, derived from the value of a
// variable on this item.
cs_dbg_Trace("Effects will be applied", cfg.debug);
cfg.effects = GetLocalString(item, CS_REST_VAR_EFFECTS);
}
else {
cs_dbg_Trace("Unrecognised item: " + resref, cfg.debug);
}
item = GetNextItemInInventory(container);
}
}
else {
cs_dbg_Trace(
"Not a valid configuration object: " + GetResRef(container),
cfg.debug
);
}
// Validate and override hour settings if they are obviously screwy.
if ((cfg.dayStart < 1) || (cfg.dayStart > cfg.dayEnd)) {
cfg.dayStart = 6;
}
if ((cfg.dayEnd > 23) || (cfg.dayEnd < cfg.dayStart)) {
cfg.dayEnd = 18;
}
cs_dbg_Exit("cs_rest_ProcessConfig", cfg.debug);
return cfg;
}
//----------------------------------------------------------------------------
// Find our configuration. First we find a global configuration object,
// then an area-specific one for the area that the player is in, and
// if there is a profile set for the resting player we look for a profile
// configuration object.
struct cs_rest_config cs_rest_RetrieveConfig(object pc) {
struct cs_rest_config cfg;
cfg.debug = GetLocalObject(pc, CS_REST_VAR_DEBUG);
cs_dbg_Enter("cs_rest_RetrieveConfig(" + GetName(pc) + ")", cfg.debug);
// Initialise default values.
cfg.bedrollMultiplier = CS_REST_DEF_BEDROLL_MULTIPLIER;
cfg.multiplier = CS_REST_DEF_MULTIPLIER;
// Pull in internal state from the PC if any.
cfg.profile = cs_rest_GetProfile(pc);
cfg.overrideProfile = cs_rest_GetOverrideProfile(pc);
cfg.trigger = cs_rest_GetTriggeringObject(pc);
cfg.permitted = GetLocalInt(pc, CS_REST_VAR_PERMITTED);
cfg.ruleFlags = GetLocalInt(pc, CS_REST_VAR_RULE_FLAGS);
cfg.started = GetLocalInt(pc, CS_REST_VAR_STARTED);
cfg.savedHitPoints = GetLocalInt(pc, CS_REST_VAR_SAVE_HP);
struct cs_rest_time time = cs_rest_GetLastRestTime(pc);
cfg.lastRestDays = time.days;
cfg.lastRestSeconds = time.seconds;
// Find the global config container.
cs_dbg_Trace("Searching global config: " + CS_REST_TAG_CONFIG, cfg.debug);
object container = GetObjectByTag(CS_REST_TAG_CONFIG);
if (!GetIsObjectValid(container)) {
// Try again in lowercase just to be sure.
container = GetObjectByTag(GetStringLowerCase(CS_REST_TAG_CONFIG));
}
if (GetIsObjectValid(container)) {
cs_dbg_Trace("Global config found", cfg.debug);
cfg = cs_rest_ProcessConfig(pc, container, cfg);
}
else {
cs_dbg_Trace("Global config not found", cfg.debug);
}
// Find any area config container.
string tag = GetTag(GetArea(pc)) + CS_REST_TAG_CONFIG_SUFFIX;
cs_dbg_Trace("Searching area config: " + tag, cfg.debug);
if (GetStringLength(tag) > CS_REST_MAX_TAG_LENGTH) {
cs_dbg_Trace(
"Rest config tag > " +
IntToString(CS_REST_MAX_TAG_LENGTH) +
" characters. This will cause problems.",
cfg.debug
);
}
container = GetObjectByTag(tag);
if (!GetIsObjectValid(container)) {
// Try again in lowercase just to be sure.
container = GetObjectByTag(GetStringLowerCase(tag));
}
if (GetIsObjectValid(container)) {
cs_dbg_Trace("Area config found", cfg.debug);
cfg = cs_rest_ProcessConfig(pc, container, cfg);
}
else {
cs_dbg_Trace("Area config not found", cfg.debug);
}
// Find a trigger config container if any.
container = cfg.trigger;
if (GetIsObjectValid(container)) {
tag = GetTag(container) + CS_REST_TAG_CONFIG_SUFFIX;
cs_dbg_Trace("Searching trigger config: " + tag, cfg.debug);
if (GetStringLength(tag) > CS_REST_MAX_TAG_LENGTH) {
cs_dbg_Trace(
"Rest config tag > " +
IntToString(CS_REST_MAX_TAG_LENGTH) +
" characters. This will cause problems.",
cfg.debug
);
}
container = GetObjectByTag(tag);
if (!GetIsObjectValid(container)) {
// Try again in lowercase just to be sure.
container = GetObjectByTag(GetStringLowerCase(tag));
}
if (GetIsObjectValid(container)) {
cs_dbg_Trace("Trigger config found", cfg.debug);
cfg = cs_rest_ProcessConfig(pc, container, cfg);
}
else {
cs_dbg_Trace("Trigger config not found", cfg.debug);
}
}
else {
cs_dbg_Trace("Searching trigger config: not inside a trigger", cfg.debug);
}
cs_dbg_Exit("cs_rest_RetrieveConfig", cfg.debug);
return cfg;
}
//----------------------------------------------------------------------------
void cs_rest_UpdateMessages(object pc, struct cs_rest_config cfg, object item) {
SetLocalString(pc, CS_REST_VAR_START_TEXT, GetLocalString(item, CS_REST_VAR_START_TEXT));
SetLocalString(pc, CS_REST_VAR_FINISH_TEXT, GetLocalString(item, CS_REST_VAR_FINISH_TEXT));
SetLocalString(pc, CS_REST_VAR_CANCEL_TEXT, GetLocalString(item, CS_REST_VAR_CANCEL_TEXT));
SetLocalString(pc, CS_REST_VAR_CANNOT_TEXT, GetLocalString(item, CS_REST_VAR_CANNOT_TEXT));
SetLocalString(pc, CS_REST_VAR_TOO_SOON_TEXT, GetLocalString(item, CS_REST_VAR_TOO_SOON_TEXT));
SetLocalString(pc, CS_REST_VAR_DAY_ONLY_TEXT, GetLocalString(item, CS_REST_VAR_DAY_ONLY_TEXT));
SetLocalString(pc, CS_REST_VAR_NIGHT_ONLY_TEXT, GetLocalString(item, CS_REST_VAR_NIGHT_ONLY_TEXT));
SetLocalString(pc, CS_REST_VAR_NO_ARMOUR_TEXT, GetLocalString(item, CS_REST_VAR_NO_ARMOUR_TEXT));
SetLocalString(pc, CS_REST_VAR_NO_WEAPON_TEXT, GetLocalString(item, CS_REST_VAR_NO_WEAPON_TEXT));
SetLocalString(pc, CS_REST_VAR_BEDROLL_RUINED_TEXT, GetLocalString(item, CS_REST_VAR_BEDROLL_RUINED_TEXT));
SetLocalString(pc, CS_REST_VAR_NOT_COMFORTABLE_TEXT, GetLocalString(item, CS_REST_VAR_NOT_COMFORTABLE_TEXT));
SetLocalString(pc, CS_REST_VAR_ENTER_REST_TEXT, GetLocalString(item, CS_REST_VAR_ENTER_REST_TEXT));
SetLocalString(pc, CS_REST_VAR_EXIT_REST_TEXT, GetLocalString(item, CS_REST_VAR_EXIT_REST_TEXT));
SetLocalString(pc, CS_REST_VAR_UNSAFE_TEXT, GetLocalString(item, CS_REST_VAR_UNSAFE_TEXT));
SetLocalString(pc, CS_REST_VAR_ENTER_NO_REST_TEXT, GetLocalString(item, CS_REST_VAR_ENTER_NO_REST_TEXT));
SetLocalString(pc, CS_REST_VAR_EXIT_NO_REST_TEXT, GetLocalString(item, CS_REST_VAR_EXIT_NO_REST_TEXT));
SetLocalString(pc, CS_REST_VAR_NO_BEDROLL_TEXT, GetLocalString(item, CS_REST_VAR_NO_BEDROLL_TEXT));
}
//----------------------------------------------------------------------------
void cs_rest_ShowFloatingTextByID(object pc, struct cs_rest_config cfg, int id){
cs_dbg_Enter(
"cs_rest_ShowFloatingTextByID(" +
GetName(pc) + ", " +
IntToString(id) + ")",
cfg.debug
);
if (cfg.noMessages) {
// Bail out if messages are turned off.
cs_dbg_Trace("message display is disabled");
cs_dbg_Exit("cs_rest_ShowFloatingTextByID", cfg.debug);
return;
}
// object mod = GetModule();
string text = "";
cs_dbg_Trace("Message ID: " + IntToString(id), cfg.debug);
switch (id) {
case CS_REST_TXT_START:
text = GetLocalString(pc, CS_REST_VAR_START_TEXT);
if (text == "") {
text = CS_REST_MSG_START;
}
break;
case CS_REST_TXT_FINISH:
text = GetLocalString(pc, CS_REST_VAR_FINISH_TEXT);
if (text == "") {
text = CS_REST_MSG_FINISH;
}
break;
case CS_REST_TXT_CANCEL:
text = GetLocalString(pc, CS_REST_VAR_CANCEL_TEXT);
if (text == "") {
text = CS_REST_MSG_CANCEL;
}
break;
case CS_REST_TXT_CANNOT:
text = GetLocalString(pc, CS_REST_VAR_CANNOT_TEXT);
if (text == "") {
text = CS_REST_MSG_CANNOT;
}
break;
case CS_REST_TXT_TOO_SOON:
text = GetLocalString(pc, CS_REST_VAR_TOO_SOON_TEXT);
if (text == "") {
text = CS_REST_MSG_TOO_SOON;
}
break;
case CS_REST_TXT_DAY_ONLY:
text = GetLocalString(pc, CS_REST_VAR_DAY_ONLY_TEXT);
if (text == "") {
text = CS_REST_MSG_DAY_ONLY;
}
break;
case CS_REST_TXT_NIGHT_ONLY:
text = GetLocalString(pc, CS_REST_VAR_NIGHT_ONLY_TEXT);
if (text == "") {
text = CS_REST_MSG_NIGHT_ONLY;
}
break;
case CS_REST_TXT_NO_ARMOUR:
text = GetLocalString(pc, CS_REST_VAR_NO_ARMOUR_TEXT);
if (text == "") {
text = CS_REST_MSG_NO_ARMOUR;
}
break;
case CS_REST_TXT_NO_WEAPON:
text = GetLocalString(pc, CS_REST_VAR_NO_WEAPON_TEXT);
if (text == "") {
text = CS_REST_MSG_NO_WEAPON;
}
break;
case CS_REST_TXT_BEDROLL_RUINED:
text = GetLocalString(pc, CS_REST_VAR_BEDROLL_RUINED_TEXT);
if (text == "") {
text = CS_REST_MSG_BEDROLL_RUINED;
}
break;
case CS_REST_TXT_NOT_COMFORTABLE:
text = GetLocalString(pc, CS_REST_VAR_NOT_COMFORTABLE_TEXT);
if (text == "") {
text = CS_REST_MSG_NOT_COMFORTABLE;
}
break;
case CS_REST_TXT_ENTER_REST:
text = GetLocalString(pc, CS_REST_VAR_ENTER_REST_TEXT);
if (text == "") {
text = CS_REST_MSG_ENTER_REST;
}
break;
case CS_REST_TXT_EXIT_REST:
text = GetLocalString(pc, CS_REST_VAR_EXIT_REST_TEXT);
if (text == "") {
text = CS_REST_MSG_EXIT_REST;
}
break;
case CS_REST_TXT_UNSAFE:
text = GetLocalString(pc, CS_REST_VAR_UNSAFE_TEXT);
if (text == "") {
text = CS_REST_MSG_UNSAFE;
}
break;
case CS_REST_TXT_ENTER_NO_REST:
text = GetLocalString(pc, CS_REST_VAR_ENTER_NO_REST_TEXT);
if (text == "") {
text = CS_REST_MSG_ENTER_NO_REST;
}
break;
case CS_REST_TXT_EXIT_NO_REST:
text = GetLocalString(pc, CS_REST_VAR_EXIT_NO_REST_TEXT);
if (text == "") {
text = CS_REST_MSG_EXIT_NO_REST;
}
break;
case CS_REST_TXT_NO_BEDROLL:
text = GetLocalString(pc, CS_REST_VAR_NO_BEDROLL_TEXT);
if (text == "") {
text = CS_REST_MSG_NO_BEDROLL;
}
break;
default:
cs_dbg_Trace("Message ID not recognised", cfg.debug);
break;
}
if (text != "") {
if (text == "off") {
cs_dbg_Trace("message is disabled");
}
else {
// Expand references in the string.
cs_dbg_Trace("Expanding embedded references", cfg.debug);
int pos = FindSubString(text, "<MIN>");
if (pos > 0) {
// Number of minutes before next rest.
struct cs_rest_time currentTime = cs_rest_GetCurrentTime(cfg);
struct cs_rest_time nextRest = cs_rest_Time(
cfg.lastRestDays,
cfg.lastRestSeconds
);
nextRest = cs_rest_AddTime(nextRest, cs_rest_Time(0, cfg.limit));
cs_dbg_Trace(
"current time: " + cs_rest_TimeToString(currentTime),
cfg.debug
);
cs_dbg_Trace(
"Next rest time: " + cs_rest_TimeToString(nextRest),
cfg.debug
);
struct cs_rest_time left = cs_rest_SubtractTime(nextRest, currentTime);
int minutes = (left.seconds / cs_rest_secondsPerMinute);
string replace = "";
if (minutes == 0) {
replace = "less than a minute";
}
else {
replace = IntToString(minutes) + " minute";
if (minutes > 1) {
replace += "s";
}
}
text =
GetStringLeft(text, pos) +
replace +
GetStringRight(text, GetStringLength(text) - pos - 5);
}
FloatingTextStringOnCreature(text, pc, FALSE);
}
}
cs_dbg_Exit("cs_rest_ShowFloatingTextByID", cfg.debug);
}
//----------------------------------------------------------------------------
void cs_rest_ApplyEffects(object pc, struct cs_rest_config cfg) {
cs_dbg_Enter("cs_rest_ApplyEffects(" + GetName(pc) + ")", cfg.debug);
cs_dbg_Trace("effects to apply: " + cfg.effects);
cs_tkn_SetTokenString(cfg.effects);
while(!cs_tkn_GetIsLastToken()) {
string token = cs_tkn_GetNextToken();
int effectID = StringToInt(token);
if (effectID > 0) {
cs_dbg_Trace("applying effect: " + token);
effect eff = EffectVisualEffect(effectID);
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eff, pc, 22.0);
}
else {
cs_dbg_Trace("effect failed to parse: " + token);
}
}
cs_dbg_Exit("cs_rest_ApplyEffects", cfg.debug);
}
//----------------------------------------------------------------------------
// This function is used as a failsafe if, for whatever reason, the resting
// fails to stop and so the screen remains faded to black. Leaving players
// with a black screen is not friendly.
void cs_rest_fadeUpFallback(object pc, object debug) {
cs_dbg_Enter("cs_rest_fadeUpFallback(" + GetName(pc) + ")", debug);
if (!GetLocalInt(pc, CS_REST_VAR_FADE_DONE)) {
cs_dbg_Trace("Fade up failed! Fallback kicked in.", debug);
FadeFromBlack(pc);
}
else {
cs_dbg_Trace("Fade up worked ok.", debug);
}
DeleteLocalInt(pc, CS_REST_VAR_FADE_DONE);
cs_dbg_Exit("cs_rest_fadeUpFallback", debug);
}
//----------------------------------------------------------------------------
void cs_rest_StartResting(object pc, struct cs_rest_config cfg) {
cs_dbg_Enter("cs_rest_StartResting(" + GetName(pc) + ")", cfg.debug);
cfg.savedHitPoints = GetCurrentHitPoints(pc);
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_START);
// If we're configured to fade the screen to black, do so here.
if (cfg.fadeToBlack) {
cs_dbg_Trace("Fading to black", cfg.debug);
FadeToBlack(pc);
// Failsafe fade just in case resting is aborted somehow.
// Yeah yeah, I'm paranoid. I know.
DelayCommand(25.0, cs_rest_fadeUpFallback(pc, cfg.debug));
}
// Apply any effects indicated by the user.
cs_rest_ApplyEffects(pc, cfg);
cs_rest_SetConfig(pc, cfg);
cs_dbg_Exit("cs_rest_StartResting", cfg.debug);
}
//----------------------------------------------------------------------------
void cs_rest_StopResting(object pc, struct cs_rest_config cfg) {
cs_dbg_Enter("cs_rest_StopResting(" + GetName(pc) + ")", cfg.debug);
// Did the rest system actually kick in?
if (cfg.started == CS_REST_STARTED) {
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_FINISH);
if (cfg.use3Ed) {
// Reduce player's HP back to stored value + level.
int oldHP = cfg.savedHitPoints;
if (oldHP > 0) {
// Determine how many HP the PC regains.
int gained = GetHitDice(pc);
gained = FloatToInt(IntToFloat(gained) * cfg.multiplier);
if (cfg.useConBonus) {
gained += GetAbilityModifier(ABILITY_CONSTITUTION, pc);
}
if (gained < 1) {
// Player always regains at least 1 HP.
gained = 1;
}
cs_dbg_Trace("gained: " + IntToString(gained), cfg.debug);
// Determine the number of HP the PC should now have.
int newHP = oldHP + gained;
// If the new HP value is less than full HP, we need to reduce
// the PC's HP down again.
if (newHP < GetMaxHitPoints(pc)) {
effect damage = EffectDamage(
GetCurrentHitPoints(pc) - newHP,
DAMAGE_TYPE_MAGICAL,
DAMAGE_POWER_PLUS_FIVE
);
ApplyEffectToObject(DURATION_TYPE_INSTANT, damage, pc);
// Calculate display value.
newHP = newHP - oldHP;
}
else {
// Calculate display value.
newHP = GetMaxHitPoints(pc) - oldHP;
}
cs_dbg_Trace(
GetName(pc) + " regained " +
IntToString(newHP) + " hit points",
cfg.debug
);
}
else {
cs_dbg_Trace(
GetName(pc) + " has 0 hit points! This is bad...",
cfg.debug
);
}
}
// Set config that we actually want to keep for next time.
cs_rest_SetLastRestTime(pc, cs_rest_GetCurrentTime(cfg));
// If we faded the screen to black, fade back up again.
if (cfg.fadeToBlack) {
cs_dbg_Trace("Fading screen up", cfg.debug);
FadeFromBlack(pc);
SetLocalInt(pc, CS_REST_VAR_FADE_DONE, TRUE);
}
}
else if (cfg.started != CS_REST_ABORTED) {
cs_dbg_Trace(
GetName(pc) + ": resting stopped after never starting!",
cfg.debug
);
}
cs_dbg_Exit("cs_rest_StopResting", cfg.debug);
}
//----------------------------------------------------------------------------
void cs_rest_CancelResting(object pc, struct cs_rest_config cfg) {
cs_dbg_Enter("cs_rest_CancelResting(" + GetName(pc) + ")", cfg.debug);
// Did the rest system actually kick in?
if (cfg.started == CS_REST_STARTED) {
cs_rest_ShowFloatingTextByID(pc, cfg, CS_REST_TXT_CANCEL);
if (cfg.use3Ed) {
// Reduce player's HP to stored value + proportion of level, i.e.
// if the player rests for half a normal rest period, he gets half
// his level in HP. If the player is only slightly injured, i.e.
// less than his level in damage, then the normal resting is left
// alone which results in slower healing if interrupted close to
// full hit points. Ah well.
int oldHP = cfg.savedHitPoints;
if (oldHP > 0) {
int maxHP = GetMaxHitPoints(pc);
if (oldHP != maxHP) {
// Determine how many HP the PC regains.
int currentHP = GetCurrentHitPoints(pc);
int gained = FloatToInt(IntToFloat(GetHitDice(pc)) *
((IntToFloat(currentHP - oldHP)) /
(IntToFloat(maxHP - oldHP))));
gained = FloatToInt(IntToFloat(gained) * cfg.multiplier);
if (cfg.useConBonus) {
gained += GetAbilityModifier(ABILITY_CONSTITUTION, pc);
}
if (gained < 1) {
// Player always regains at least 1 HP.
gained = 1;
}
cs_dbg_Trace("gained: " + IntToString(gained), cfg.debug);
// Determine the number of HP the PC should now have.
int newHP = oldHP + gained;
// If the PC has more HP than he should, we need to reduce
// the PC's HP down again.
if (currentHP > newHP) {
effect damage = EffectDamage(
currentHP - newHP,
DAMAGE_TYPE_MAGICAL,
DAMAGE_POWER_PLUS_FIVE
);
ApplyEffectToObject(DURATION_TYPE_INSTANT, damage, pc);
}
else {
gained = currentHP - oldHP;
}
cs_dbg_Trace(
GetName(pc) + " regained " +
IntToString(gained) + " hit points",
cfg.debug
);
}
}
else {
cs_dbg_Trace(
GetName(pc) + " has 0 hit points! This is bad...",
cfg.debug
);
}
}
// Set config that we actually want to keep for next time.
cs_rest_SetLastRestTime(pc, cs_rest_GetCurrentTime(cfg));
// If we faded the screen to black, fade back up again.
if (cfg.fadeToBlack) {
cs_dbg_Trace("Fading screen up", cfg.debug);
FadeFromBlack(pc);
SetLocalInt(pc, CS_REST_VAR_FADE_DONE, TRUE);
}
}
else if (cfg.started != CS_REST_ABORTED) {
cs_dbg_Trace(
GetName(pc) + ": resting cancelled after never starting!",
cfg.debug
);
}
cs_dbg_Exit("cs_rest_CancelResting", cfg.debug);
}
Reference in New Issue View Git Blame Copy Permalink