fish_i_main.nss

/*
Filename:        fish_i_main.nss
System:          SM's Fishing System (include script)
Author:          Michael A. Sinclair (Squatting Monk) <squattingmonk@gmail.com>
Date Created:    Aug. 12, 2015
Summary:
Fishing System include script. This file holds functions and constants commonly
used in the system. This file should not be altered by end users. For
configurable settings and functions, see fish_c_config.

This script is consumed as an include directive by fish_c_config.

Revision Info should only be included for post-release revisions.
-----------------
Revision Date:
Revision Author:
Revision Summary:

*/

// List handling utilities
#include "util_i_lists"

// -----------------------------------------------------------------------------
//                                  Constants
// -----------------------------------------------------------------------------

// Blueprints and tags
const string FISH_WP_DATA    = "fish_datapoint";
const string FISH_WP_FISHING = "fish_fishingspot";
const string FISH_WP_GENERIC = "nw_waypoint001";
const string FISH_DEFAULT    = "nw_it_msmlmisc20";

// Local variables names.
const string FISH_BLACKLIST       = "BLACKLIST";
const string FISH_DEBUG           = "DEBUG";
const string FISH_DESCRIPTION     = "DESCRIPTION";
const string FISH_DISTANCE        = "DISTANCE";
const string FISH_ENVIRONMENT     = "ENVIRONMENT";
const string FISH_EQUIPMENT       = "EQUIPMENT";
const string FISH_FREQUENCY       = "FREQUENCY";
const string FISH_MESSAGE         = "MSG";
const string FISH_MOD             = "MOD";
const string FISH_NAME            = "NAME";
const string FISH_RESREF          = "RESREF";
const string FISH_STACK           = "STACK";
const string FISH_TACKLE          = "TACKLE";
const string FISH_TACKLE_ALLOWED  = "ALLOWED";
const string FISH_TACKLE_REQUIRED = "REQUIRED";
const string FISH_TACKLE_SLOT     = "SLOT";
const string FISH_TAG             = "TAG";
const string FISH_WHITELIST       = "WHITELIST";

// Fishing events for animation
const int FISH_EVENT_START       = 0;
const int FISH_EVENT_NIBBLE      = 1;
const int FISH_EVENT_CATCH       = 2;
const int FISH_EVENT_NO_CATCH    = 3;
const int FISH_EVENT_NO_NIBBLE   = 4;
const int FISH_EVENT_USE_TACKLE  = 5;
const int FISH_EVENT_BAD_TARGET  = 6;
const int FISH_EVENT_NO_SPOT     = 7;
const int FISH_EVENT_NO_TACKLE   = 8;

struct FishingData
{
    // We store all our data on a waypoint accessed through the global variable
    // Fish.Data. The waypoint is auto-generated by InitializeFishingSystem().
    // We do this to reduce the number of local variables stored on the module,
    // which helps reduce access time when dealing with large numbers of
    // variables.
    object Data;

    object PC;          // The PC currently fishing
    object Spot;        // The current fishing spot
    string Environment; // The environment the PC is fishing in
    object Item;        // The PC's current fishing equipment
    string Type;        // The type of equipment the PC is using
    string Tackle;      // List of what tackle the equipment is using
    string Full;        // List of tackle slots with tackle in them
    string Empty;       // List of tackle slots with no tackle in them
    int    Debug;       // Whether to debug fishing functions
};


// -----------------------------------------------------------------------------
//                              Global Variables
// -----------------------------------------------------------------------------

// Data structure to hold all variables for this fishing attempt. We instantiate
// it here so it is accessible to all the functions within this script. All data
// is set by fish_t_equipment.nss. The user should use the GetFishing*()
// functions instead of accessing this variable directly.
struct FishingData Fish;


// -----------------------------------------------------------------------------
//                             Function Prototypes
// -----------------------------------------------------------------------------

// ----- Variable Accessor Functions -------------------------------------------

// ---< GetFishFloat >---
// ---< fish_i_main >---
// Gets a local float of sVarName from sKey. If sKey is blank, will get the
// globally set float. If sKey has not had a float set explicitly by
// SetFishFloat(), this will return any globally set float.
float GetFishFloat(string sVarName, string sKey = "");

// ---< GetFishInt >---
// ---< fish_i_main >---
// Gets a local int of sVarName from sKey. If sKey is blank, will get the
// globally set int. If sKey has not had an int set explicitly by SetFishInt(),
// this will return any globally set int.
int GetFishInt(string sVarName, string sKey = "");

// ---< GetFishString >---
// ---< fish_i_main >---
// Gets a local string of sVarName from sKey. If sKey is blank, will get the
// globally set string. If sKey has not had a string set explicitly by
// SetFishString(), this will return any globally set string.
string GetFishString(string sVarName, string sKey = "");

// ---< SetFishFloat >---
// ---< fish_i_main >---
// Sets a local float of sVarName with fValue on every item in sList. If sList
// is blank, will set the float globally.
void SetFishFloat(string sVarName, float fValue, string sList = "");

// ---< SetFishInt >---
// ---< fish_i_main >---
// Sets a local int of sVarName with nValue on every item in sList. If sList
// is blank, will set the int globally.
void SetFishInt(string sVarName, int nValue, string sList = "");

// ---< SetFishString >---
// ---< fish_i_main >---
// Sets a local string of sVarName with sValue on every item in sList. If sList
// is blank, will set the string globally.
void SetFishString(string sVarName, string sValue, string sList = "");


// ----- Debug Functions -------------------------------------------------------

// ---< SetFishingDebugMode >---
// ---< fish_i_main >---
// Sets debug mode on oTarget to bDebug. If oTarget is invalid, will change
// debug mode for the whole module. If debug mode is on, fishing will generate
// debug messages. This may be useful for tracking down errors in any of the
// config functions.
void SetFishingDebugMode(int bDebug, object oTarget = OBJECT_INVALID);

// ---< GetFishingDebugMode >---
// ---< fish_i_main >---
// Gets whether oTarget has debug mode on. If oTarget is invalid, will return
// debug mode for the whole module. If debug mode is on, fishing will generate
// debug messages. This may be useful for tracking down errors in any of the
// config functions.
int GetFishingDebugMode(object oTarget = OBJECT_INVALID);

// ---< FishingDebug >---
// ---< fish_i_main >---
// If debug mode is on, sends sMessage to the fishing PC and writes the message
// to the log. This is done using the action queue, so the PC will see the
// message at the appropriate time.
void FishingDebug(string sMessage);


// ----- Fishing Equipment and Tackle Functions --------------------------------

// ---< AddFishingTackleSlot >---
// ---< fish_i_main >---
// Defines the tackle slot sSlot as being found on equipment type sEquipment.
// Tackle that fits into sSlot can be used on sEquipment. if bRequired is TRUE,
// sSlot must be filled with matching tackle for the equipment to be used.
//
// This function can be called multiple times for a given equipment type,
// defining a new slot each time. For bulk usage, however, consider using
// AddFishingTackleSlots() instead.
//
// You can create your own types of equipment:
// 1. Give your item a "Cast Spell: OnActivate (Self Only)" item property with
//    unlimited uses.
// 2. Set its tag to "fish_t_equipment_*", where * is the type of equipment your
//    item is. Alternatively, set the tag to "fish_t_equipment" and use the
//    resref as the equipment type. This will be the value you should use to
//    refer to your equipment type in this setting and in the config functions.
void AddFishingTackleSlot(string sEquipment, string sSlot, int bRequired = FALSE);

// ---< AddFishingTackleSlots >---
// ---< fish_i_main >---
// Defines the required and optional tackle slots for a list of equipment types.
// Tackle that doesn't match one of these slots can't be used on the equipment.
// Parameters:
// - sEquipmentList: a comma-separated list of equipment types
// - sSlotList: a comma-separated list of tackle slots that the equipment has
//   but are not required for the equipment to be used.
// - sRequiredSlotList: a comma-separated list of tackle slots that must be
//   filled for the equipment to be successfully used. If a slot is defined both
//   here and in sSlotList, this one takes precedence.
//
// You can create your own types of equipment:
// 1. Give your item a "Cast Spell: OnActivate (Self Only)" item property with
//    unlimited uses.
// 2. Set its tag to "fish_t_equipment_*", where * is the type of equipment your
//    item is. Alternatively, set the tag to "fish_t_equipment" and use the
//    resref as the equipment type. This will be the value you should use to
//    refer to your equipment type in this setting and in the config functions.
void AddFishingTackleSlots(string sEquipmentList, string sSlotList, string sRequiredSlotList = "");

// ---< GetFishingTackleSlots >---
// ---< fish_i_main >---
// Returns a comma-separated list of the tackle slots enabled for sEquipment. If
// bRequiredOnly is TRUE, will limit the list to required tackle types.
string GetFishingTackleSlots(string sEquipment, int bRequiredOnly = FALSE);

// ---< CanUseFishingTackle >---
// ---< fish_i_main >---
// Returns whether sEquipment has a tackle slot that fits sTackle.
int CanUseFishingTackle(string sEquipment, string sTackle);

// ---< HasFishingTackleSlot >---
// ---< fish_i_main >---
// Returns whether sEquipment uses tackle slot sSlot. If bRequiredOnly is TRUE,
// will return whether the slot is required for use.
int HasFishingTackleSlot(string sEquipment, string sSlot, int bRequiredOnly = FALSE);

// ---< SetIsFishingTackle >---
// ---< fish_i_main >---
// Sets every tackle type in the comma-separated list sTackleList as fitting the
// tackle slot sSlot. If sSlot is blank, will use the tackle name as the slot.
//
// Any equipment that has been defined as tackle cannot be used to fish; it can
// only be applied to fishing equipment items that have a slot for the tackle.
//
// You can create your own types of equipment:
// 1. Give your item a "Cast Spell: OnActivate (Self Only)" item property with
//    unlimited uses.
// 2. Set its tag to "fish_t_equipment_*", where * is the type of equipment your
//    item is. Alternatively, set the tag to "fish_t_equipment" and use the
//    resref as the equipment type. This will be the value you should use to
//    refer to your equipment type in this setting and in the config functions.
void SetIsFishingTackle(string sTackleList, string sSlot = "");

// ---< GetFishingTackleSlot >---
// ---< fish_i_main >---
// Returns the slot occupied by sTackle.
string GetFishingTackleSlot(string sTackle);

// ---< IsFishingTackle >---
// ---< fish_i_main >---
// Returns whether sEquipment is a type of fishing tackle.
int GetIsFishingTackle(string sEquipment);

// ---< GetFishingTackle >---
// ---< fish_i_main >---
// Returns a list of the tackle being used in sSlot on oEquipment. If oEquipment
// is invalid, returns the tackle being used on the PC's currently equipped
// fishing equipment. If sSlot is empty, will return a CSV list of all tackle on
// oEquipment.
string GetFishingTackle(string sSlot = "", object oEquipment = OBJECT_INVALID);

// ---< SetFishingDistance >---
// ---< fish_i_main >---
// Gets the maximum distance, in meters, that a PC may be from a waypoint
// fishing spot to fish using sEquipment. If sEquipment is blank, will get a
// default fishing distance.
// Note: the PC will always be able to fish in a trigger fishing spot if he is
// inside of it.
float GetFishingDistance(string sEquipment);

// ---< SetFishingDistance >---
// ---< fish_i_main >---
// Sets the maximum distance, in meters, that a PC may be from a waypoint
// fishing spot to fish using any of the listed equipment.
// Parameters:
// - fMax: If this value is 0.0 or less, the PC will be able to fish in any area
//   with a waypoint fishing spot regardless of how far he is from it.
// - sEquipmentList: a comma-separated list of equipment types that have this
//   maximum distance. If this value is blank, will set a default fishing
//   distance for any equipment type with no explicit setting.
// Note: the PC will always be able to fish in a trigger fishing spot if he is
// inside of it.
void SetFishingDistance(float fMax, string sEquipmentList = "");


// ----- Fish Frequency Functions ----------------------------------------------

// ---< AddFish >---
// ---< fish_i_main >---
// Adds every fish in the CSV list sFishList to the global fish list and sets
// the frequency at which the fish is normally found. The frequency is the
// percentage of time the fish will pass the nibble check and be caught. This
// frequency can be modified by the environment, equipment, or tackle and can be
// modified by the builder using the OnFishNibble() config function.
// Note: a frequency of 0 or lower will guarantee that a fish will not be caught
// unless its probability is raised in some way, and a value of 100 or higher
// will guarantee the fish will be caught unless its probability is decreased in
// some way.
void AddFish(int nFreq, string sFishList);

// ---< GetFish >---
// ---< fish_i_main >---
// Returns the nNth (where 0 is the first) fish that has been defined with
// AddFish(). This can be used in combination with GetFishCount() to loop
// through all defined fish.
string GetFish(int nNth);

// ---< GetFishCount >---
// ---< fish_i_main >---
// Returns the number of fish defined with AddFish(). This can be used in
// combination with GetFish() to loop through all defined fish.
int GetFishCount();

// ---< GetFishFrequency >---
// ---< fish_i_main >---
// Gets the frequency of sFish. This is the percentage of time the fish will
// pass the nibble check and be caught. This frequency can be modified by the
// environment, equipment, or tackle and can be modified by the builder using
// the OnFishNibble() config function.
int GetFishFrequency(string sFish);

// ---< GetFishResRef >---
// ---< fish_i_main >---
// Gets the resref used to create sFish on a successful catch. If the value has
// not been defined for sFish, any globally defined value will be inherited.
string GetFishResRef(string sFish);

// ---< SetFishResRef >---
// ---< fish_i_main >---
// Sets the resref used to create every fish in sFishList on a successful catch.
// If sResRef is blank, any created fish will use the fish's ID as its resref.
// If sFishList is blank, the resref will be defined globally: any fish without
// an explicitly defined resref will use sResRef instead.
void SetFishResRef(string sResRef, string sFishList = "");

// ---< GetFishName >---
// ---< fish_i_main >---
// Gets the name applied to sFish on a successful catch. If the value has not
// been defined for sFish, any globally defined value will be inherited.
string GetFishName(string sFish);

// ---< SetFishName >---
// ---< fish_i_main >---
// Sets the name applied to every fish in sFishList on a successful catch. If
// sName is blank, any created fish will not have its name changed on creation.
// If sFishList is blank, the name will be defined globally: any fish without
// an explicitly defined name will use sName instead.
void SetFishName(string sName, string sFishList = "");

// ---< GetFishTag >---
// ---< fish_i_main >---
// Gets the tag applied to sFish on a successful catch. If the value has not
// been defined for sFish, any globally defined value will be inherited.
string GetFishTag(string sFish);

// ---< SetFishTag >---
// ---< fish_i_main >---
// Sets the tag applied to every fish in sFishList on a successful catch. If
// sTag is blank, any created fish will not have its tag changed on creation.
// If sFishList is blank, the tag will be defined globally: any fish without
// an explicitly defined tag will use sTag instead.
void SetFishTag(string sTag, string sFishList = "");

// ---< GetFishDescription >---
// ---< fish_i_main >---
// Gets the description applied to sFish on a successful catch. If the value has
// not been defined for sFish, any globally defined value will be inherited.
string GetFishDescription(string sFish);

// ---< SetFishName >---
// ---< fish_i_main >---
// Sets the name applied to every fish in sFishList on a successful catch. If
// sName is blank, any created fish will not have its name changed on creation.
// If sFishList is blank, the name will be defined globally: any fish without
// an explicitly defined name will use sName instead.
void SetFishDescription(string sDescription, string sFishList = "");

// ---< GetFishStackSize >---
// ---< fish_i_main >---
// Gets the stack size used to create sFish on a successful catch. If the value
// has not been defined for sFish, any globally defined value will be inherited.
int GetFishStackSize(string sFish);

// ---< SetFishStackSize >---
// ---< fish_i_main >---
// Sets the stack size used to create every fish in sFishList on a successful
// catch. If nStackSize is < 1, any created fish will use a stack size of 1. If
// sFishList is blank, the stack size will be defined globally: any fish without
// an explicitly defined stack size will use nStackSize instead.
void SetFishStackSize(int nStackSize, string sFishList = "");

// ---< SetFishModifier >---
// ---< fish_i_main >---
// Sets the modifier to catch every fish in sFishList when using any item in
// sModifierList. sType is a key to access the correct list of modifiers. The
// SetFish*Modifier() functions are wrappers for this function.
void SetFishModifier(string sType, int nValue, string sModifierList, string sFishList);

// ---< GetFishModifier >---
// ---< fish_i_main >---
// Gets the modifier to catch sFish when using sModifier. sType is a key to
// access the correct list of modifiers. The GetFish*Modifier() functions are
// wrappers for this function.
int GetFishModifier(string sType, string sModifier, string sFish);

// ---< SetFishEnvironmentModifier >---
// ---< fish_i_main >---
// Sets the environment modifier for every fish in sFishList to nValue for every
// environment in sEnvironmentList.
// Parameters:
// - nValue: a modifier to the percentage of the time a fish will be found in
//   this environment.
// - sEnvironmentList: a comma-separated list of environments for the fish.
// - sFishList: a comma-separated list of the blueprints used to create the fish
//   on a successful catch.
void SetFishEnvironmentModifier(int nValue, string sEnvironmentList, string sFishList);

// ---< GetFishEnvironmentModifier >---
// ---< fish_i_main >---
// Gets the frequency modifier to catch sFish when fishing in sEnvironment.
int GetFishEnvironmentModifier(string sEnvironment, string sFish);

// ---< SetFishEquipmentModifier >---
// ---< fish_i_main >---
// Sets the equipment modifier for every fish in sFishList to nValue for every
// equipment item in sEquipmentList.
// Parameters:
// - nValue: a modifier to the percentage of the time a fish will be caught when
//   using this equipment.
// - sEquipmentList: a comma-separated list of equipment for the fish.
// - sFishList: a comma-separated list of the blueprints used to create the fish
//   on a successful catch.
void SetFishEquipmentModifier(int nValue, string sEquipmentList, string sFishList);

// ---< GetFishEquipmentModifier >---
// ---< fish_i_main >---
// Gets the frequency modifier that sFish has when fishing with sEquipment.
int GetFishEquipmentModifier(string sEquipment, string sFish);

// ---< SetFishTackleSlotModifier >---
// ---< fish_i_main >---
// Sets a modifier for every fish in sFishList to nValue for every tackle slot
// in sSlotList. If the PC is using tackle that falls into any of these slots,
// the modifier will be applied.
// Parameters:
// - nValue: a modifier to the percentage of the time a fish will be caught when
//   using tackle that fits this slot.
// - sSlotList: a comma-separated list of tackle slots.
// - sFishList: a comma-separated list of the blueprints used to create the fish
//   on a successful catch.
void SetFishTackleSlotModifier(int nValue, string sSlotList, string sFishList);

// ---< GetFishTackleSlotModifier >---
// ---< fish_i_main >---
// Gets the frequency modifier to catch sFish when fishing with tackle matching
// sSlot.
int GetFishTackleSlotModifier(string sSlot, string sFish);

// ---< SetFishTackleModifier >---
// ---< fish_i_main >---
// Sets the tackle modifier for every fish in sFishList to nValue for every
// tackle item in sTackleList.
// Parameters:
// - nValue: a modifier to the percentage of the time a fish will be caught when
//   using this tackle.
// - sTackleList: a comma-separated list of tackle items.
// - sFishList: a comma-separated list of the blueprints used to create the fish
//   on a successful catch.
void SetFishTackleModifier(int nValue, string sTackleList, string sFishList);

// ---< GetFishTackleModifier >---
// ---< fish_i_main >---
// Gets the frequency modifier to catch sFish when fishing with sTackle.
int GetFishTackleModifier(string sTackle, string sFish);

// ---< WhitelistFish >---
// ---< fish_i_main >---
// Sets every fish in sFishList as being catchable only when fishing with a
// condition in sWhitelist. sType is a key to access the correct list of
// conditions. The WhitelistFish*() functions are wrappers for this function.
void WhitelistFish(string sType, string sWhitelist, string sFishList);

// ---< WhitelistFishEnvironment >---
// ---< fish_i_main >---
// Sets every fish in sFishList as being catchable only when fishing in an
// environment in sWhitelist. If a fishing spot has multiple environments, only
// one must be present for the fish to be able to be caught.
void WhitelistFishEnvironment(string sWhitelist, string sFishList);

// ---< WhitelistFishEquipment >---
// ---< fish_i_main >---
// Sets every fish in sFishList as being catchable only when fishing with
// equipment in sWhitelist.
void WhitelistFishEquipment(string sWhitelist, string sFishList);

// ---< WhitelistFishTackleSlot >---
// ---< fish_i_main >---
// Sets every fish in sFishList as being catchable only when fishing with tackle
// in all slots found in sWhitelist. The PC will not be penalized for not having
// tackle his equipment does not support; if you wish this to happen, limit the
// equipment the fish can be caught with using WhitelistFishEquipment(). If the
// PC's equipment supports multiple tackle slots found in this list, all of them
// must be filled to catch this fish.
void WhitelistFishTackleSlot(string sWhitelist, string sFishList);

// ---< WhitelistFishTackle >---
// ---< fish_i_main >---
// Sets every fish in sFishList as being catchable only when fishing with tackle
// found in sWhitelist. The PC will not be penalized for not having tackle his
// equipment does not support; if you wish this to happen, limit the equipment
// the fish can be caught with using WhitelistFishEquipment(). Any tackle slot
// which can be filled by a tackle item in this list must be so. If there is no
// tackle in this list that can fill a given slot, the PC may use any tackle in
// that slot to catch the fish.
void WhitelistFishTackle(string sWhitelist, string sFishList);

// ---< BlacklistFish >---
// ---< fish_i_main >---
// Sets every fish in sFishList as not being catchable when fishing with a
// condition in sBlacklist. sType is a key to access the correct list of
// conditions. The BlacklistFish*() functions are wrappers for this function.
void BlacklistFish(string sType, string sBlacklist, string sFishList);

// ---< BlacklistFishEnvironment >---
// ---< fish_i_main >---
// Sets every fish in sFishList as not being catchable only when fishing in an
// environment in sBlacklist. If a fishing spot has multiple environments, only
// one must be present for the fish to not be able to be caught.
void BlacklistFishEnvironment(string sBlacklist, string sFishList);

// ---< BlacklistFishEquipment >---
// ---< fish_i_main >---
// Sets every fish in sFishList as not being catchable when fishing with
// equipment in sBlacklist.
void BlacklistFishEquipment(string sBlacklist, string sFishList);

// ---< BlacklistFishTackleSlot >---
// ---< fish_i_main >---
// Sets every fish in sFishList as not being catchable when fishing with tackle
// in any slot found in sBlacklist. If the PC's equipment supports multiple
// tackle slots found in this list, all of them must be empty to catch this fish.
void BlacklistFishTackleSlot(string sBlacklist, string sFishList);

// ---< BlacklistFishTackle >---
// ---< fish_i_main >---
// Sets every fish in sFishList as not being catchable when fishing with tackle
// found in sBlacklist.
void BlacklistFishTackle(string sBlacklist, string sFishList);

// ---< GetFishWhitelist >---
// ---< fish_i_main >---
// Returns the whitelist for sFish. sType is a key to access the correct list.
string GetFishWhitelist(string sType, string sFish);

// ---< HasFishWhitelist >---
// ---< fish_i_main >---
// Returns whether a whitelist exists for sFish of type sType. sType is a key to
// access the correct list of conditions.
int HasFishWhitelist(string sType, string sFish);

// ---< InFishWhitelist >---
// ---< fish_i_main >---
// Returns whether sFish's whitelist of type sType contains sItem. sType is a
// key to access the correct list of conditions.
int InFishWhitelist(string sType, string sItem, string sFish);

// ---< GetFishBlacklist >---
// ---< fish_i_main >---
// Returns the blacklist for sFish. sType is a key to access the correct list.
string GetFishBlacklist(string sType, string sFish);

// ---< HasFishBlacklist >---
// ---< fish_i_main >---
// Returns whether a blacklist exists for sFish of type sType. sType is a key to
// access the correct list of conditions.
int HasFishBlacklist(string sType, string sFish);

// ---< InFishBlacklist >---
// ---< fish_i_main >---
// Returns whether sFish's blacklist of type sType contains sItem. sType is a
// key to access the correct list of conditions.
int InFishBlacklist(string sType, string sItem, string sFish);


// ----- Fishing Message Functions ---------------------------------------------

// ---< AddFishMessage >---
// ---< fish_i_main >---
// Adds to a list of messages that may be displayed to the player during nEvent.
// Parameters:
// - nEvent: a FISH_EVENT_* constant matching when the message will be sent. You
//   can also use your own event numbers, as long as they are > 10.
// - sKeyList: a comma-separated list of keys to identify the proper message to
//   send. If sKeyList is blank, the message will be defined globally.
// - sKey: a key to identify the proper message to return.
//   - For the START, NO_NIBBLE, and BAD_SPOT events, the key should be an
//     equipment type.
//   - For the NIBBLE, CATCH, and NO_CATCH events, the key should be an
//     equipment type or a fish.
//   - The NO_TACKLE, USE_TACKLE, or BAD_TARGET events may be either an
//     equipment type or a tackle slot.
//   - Other events are up to the builder to implement. Key them as you wish.
//   - If blank, will return a globally defined message for this event.
//   - Keys will inherit globally defined messages, even if the key has
//     explicitly defined messages.
// - sMessage: the message to display to the PC.
// Example usage:
// AddFishMessage(FISH_EVENT_START, "pole", "You cast your line. Now to wait.");
// AddFishMessage(FISH_EVENT_START, "pole", "What a cast!");
// AddFishMessage(FISH_EVENT_START, "spear, net", "You wait, eyes intent on the water.");
// AddFishMessage(FISH_EVENT_CATCH, "", "You caught a fish!");
void AddFishMessage(int nEvent, string sKeyList, string sMessage);

// ---< GetFishMessage >---
// ---< fish_i_main >---
// Returns a random message to be displayed to the player during nEvent. You can
// add messages to display using AddFishMessage().
// Parameters:
// - nEvent: a FISH_EVENT_* constant matching when the message will be sent. You
//   can also use your own event numbers, as long as they are > 10.
// - sKey: a key to identify the proper message to return.
//   - For the START, NO_NIBBLE, and BAD_SPOT events, the key should be an
//     equipment type.
//   - For the NIBBLE, CATCH, and NO_CATCH events, the key should be an
//     equipment type or a fish.
//   - The NO_TACKLE, USE_TACKLE, or BAD_TARGET events may be either an
//     equipment type or a tackle slot.
//   - Other events are up to the builder to implement. Key them as you wish.
//   - If blank, will return a globally defined message for this event.
//   - Keys will inherit globally defined messages, even if the key has
//     explicitly defined messages.
// Example usage:
// GetFishMessage(FISH_EVENT_START, "pole");
string GetFishMessage(int nEvent, string sKey = "");

// ---< FloatingFishMessage >---
// ---< fish_i_main >---
// Causes a random message to be displayed to the player during nEvent. You can
// add messages to display using AddFishMessage(). If you wish to add the
// message into the action queue so it is displayed at the proper time, use
// ActionFloatingFishMessage() instead.
// Parameters:
// - nEvent: a FISH_EVENT_* constant matching when the message will be sent. You
//   can also use your own event numbers, as long as they are > 10.
// - sKey: a key to identify the proper message to return.
//   - For the START, NO_NIBBLE, and BAD_SPOT events, the key should be an
//     equipment type.
//   - For the NIBBLE, CATCH, and NO_CATCH events, the key should be an
//     equipment type or a fish.
//   - The NO_TACKLE, USE_TACKLE, or BAD_TARGET events may be either an
//     equipment type or a tackle slot.
//   - Other events are up to the builder to implement. Key them as you wish.
//   - If blank, will return a globally defined message for this event.
//   - Keys will inherit globally defined messages, even if the key has
//     explicitly defined messages.
// Example usage:
// FloatingFishMessage(FISH_EVENT_START, "pole");
void FloatingFishMessage(int nEvent, string sKey = "");


// ----- Public Accessor Functions ---------------------------------------------

// ---< GetFishingSpot >---
// ---< fish_i_main >---
// Returns the fishing spot object where the PC is currently fishing.
object GetFishingSpot();

// ---< GetFishingEnvironment >---
// ---< fish_i_main >---
// Returns the environment of the given fishing spot. If oSpot is invalid,
// returns the environment of the spot the PC is currently fishing in.
string GetFishingEnvironment(object oSpot = OBJECT_INVALID);

// ---< GetFishingEquipment >---
// ---< fish_i_main >---
// Returns the fishing equipment the PC is currently using to fish.
object GetFishingEquipment();

// ---< GetFishingEquipmentType >---
// ---< fish_i_main >---
// Returns the type of the given fishing equipment. If oEquipment is invalid,
// will return the type of equipment the PC is currently using to fish. You can
// create your own types of fishing equipment: simply give your item a "Cast
// Spell: OnActivate (Self Only)" item property with unlimited uses and set its
// tag to "fish_t_equipment_X", where X is the type of equipment your item is.
// That value should then be compared with the return value of this function to
// see whether that type of equipment is being used.
string GetFishingEquipmentType(object oEquipment = OBJECT_INVALID);

// ---< RemoveFishingTackle >---
// ---< fish_i_main >---
// Removes the tackle occupying sSlot from oEquipment, replacing it in the PC's
// inventory if bReplace is TRUE. If oEquipment is invalid, will search the PC's
// currently equipped fishing item.
object RemoveFishingTackle(string sSlot, int bReplace, object oEquipment = OBJECT_INVALID);

// ----- Action Wrappers -------------------------------------------------------

// ---< ActionFloatingTextString >---
// ---< fish_i_main >---
// Inserts FloatingTextStringOnCreature() into OBJECT_SELF's action queue. Will
// not broadcast sMessage to the PC's faction. You can use this to provide
// flavor text to your PCs.
void ActionFloatingTextString(string sMessage);

// ---< ActionFloatingFishMessage >---
// ---< fish_i_main >---
// Inserts FloatingFishMessage() into OBJECT_SELF's action queue. Will not
// broadcast sMessage to the PC's faction. You can use this to provide context-
// specific flavor text to your PCs.
void ActionFloatingFishMessage(int nEvent, string sKey = "");

// ---< ActionRemoveFishingTackle >---
// ---< fish_i_main >---
// Removes sTackle from the PC's fishing equipment, replacing it into the PC's
// inventory if bReplace is TRUE. This is inserted into the action queue so the
// PC can retain his tackle if he aborts the fishing sequence.
void ActionRemoveFishingTackle(string sTackle, int bReplace);

// ---< ActionCreateFish >---
// ---< fish_i_main >---
// Creates sFish on the PC. Plays the FISH_EVENT_CATCH message for sFish. This
// is inserted into the action queue so the PC will not catch the fish if he
// aborts the fishing sequence.
void ActionCreateFish(string sFish);

// ---< ObjectToAction >---
// ---< fish_i_main >---
// Convert oObject into a void. Use this to pass an object-returning function as
// a parameter to an ActionDoCommand() function.
void ObjectToAction(object oObject);

// ----- Config Functions ------------------------------------------------------

// These functions are defined in fish_c_config, but we declare them here so we
// can use them in our internal functions.

// ---< OnFishingSetup >---
// ---< fish_c_config >---
// This is a configurable function you can use to alter the fish, environments,
// and baits used in your module. All of the following code will run the first
// time a fishing pole is used in your module.
void OnFishingSetup();

// ---< OnFishingTackleUsed >---
// ---< fish_c_config >---
// This is a configurable function that runs when the PC uses a fishing tackle
// item and has fishing equipment equipped. Returns whether the tackle should be
// added to the equipped item. Example uses include removing the tackle from the
// player's inventory when used, giving back tackle already applied to the same
// slot, or requiring a hook type of tackle to be applied before allowing a bait
// type of tackle.
//
// You can add tackle to a fish's list using AddFishTackle() in the
// OnFishingSetup() config function below. This function takes a comma-separated
// list of fish and and tackle, making it easy to add many tackle types to many
// fish. The function also allows you to add a modifier to the chances a fish
// will bite when the PC is using that tackle. This allows fish to prefer
// different tackle.
//
// Parameters:
// - oEquipment: the PC's currently equipped fishing equipment
// - oTackle: the tackle item being used
// - sSlot: the slot the tackle is being applied to
// Returns: whether to apply the tackle to the equipment.
int OnFishingTackleUsed(object oEquipment, object oTackle, string sSlot);

// ---< OnFishingStart >---
// ---< fish_c_config >---
// This is a configurable function that runs when the PC uses fishing equipment.
// Returns whether the PC is able to fish. Example uses include setting a max
// distance to the fishing spot based on his equipment, providing flavor text
// about the cast, adding additional restrictions for fishing, or setting a time
// limit between fish bites.
// - OBJECT_SELF: the PC fishing
int OnFishingStart();

// ---< OnFishRequirements >---
// ---< fish_c_config >---
// This is a configurable function that allows you to prevent a fish from
// performing a nibble check. Use this when there are instances that will always
// bar a fish from biting. Example uses include making some fish only active at
// night, during rain, or with certain tackle combinations. For simple
// environment, equipment, or tackle restrictions, consider using the
// WhitelistFish*() and BlacklistFish*() functions in OnFishingSetup() instead.
// - OBJECT_SELF: the PC attempting to catch the fish.
// - sFish: the resref of the fish whose bite we're testing.
// Returns: whether or not the fish may attempt to nibble (TRUE/FALSE).
int OnFishRequirements(string sFish);

// ---< OnFishNibble >---
// ---< fish_c_config >---
// This is a configurable function that allows you to modify the chances a type
// of fish will bite. Example uses include giving fish preferences for different
// types of bait, making fish more or less likely to bite at different times of
// day or month, or keeping a type of fish from biting if it's been "fished out"
// of the spot.
// - OBJECT_SELF: the PC attempting to catch the fish.
// - sFish: the resref of the fish whose chances to bite we're testing.
// Returns: an amount to add to the chance the fish will bite.
int OnFishNibble(string sFish);

// ---< OnFishNibbleFail >---
// ---< fish_c_config >---
// This is a configurable function to handle what happens when the PC fails to
// get a fish to nibble on the line. Example uses include notifying the PC of
// his failure, adding a chance of losing his bait, or having him catch seaweed
// or an old boot instead.
// - OBJECT_SELF: the PC who failed to catch a fish.
// Returns: whether to display the failure animation and message.
int OnFishNibbleFail();

// ---< OnFishNibbleSuccess >---
// ---< fish_c_config >---
// This is a configurable function to handle what happens when a PC gets a fish
// on the line. Returns whether the PC is successful at catching the fish.
// Example uses include giving flavor text about the fish, requiring an ability
// check to catch it, or setting the fishing spot as unavailable for a time.
// - OBJECT_SELF: the PC fishing.
// - sFish: the resref of the fish the PC has on the line.
int OnFishNibbleSuccess(string sFish);

// ---< OnFishCatch >---
// ---< fish_c_config >---
// This is a configurable function to intercept the actual creation of the fish.
// Returns whether the system should create the fish. Example uses include
// removing the PC's bait, copying a fish from a container rather than creating
// one from a blueprint (to save on palette items), increasing a persistently
// stored fishing skill, or even just giving the player some XP.
int OnFishCatch(string sFish);

// ---< PlayFishingAnimation >---
// ---< fish_c_config >---
// This is a configurable function to handle the animations for different stages
// of the fishing. Returns whether or not to play the default animation.
// - nEvent: the fishing event which is currently playing
//   - FISH_EVENT_START: plays when fishing begins (after OnFishingStart())
//   - FISH_EVENT_NIBBLE: plays when a fish has passed the nibble check
//   - FISH_EVENT_CATCH: plays when a PC successfully catches a fish
//   - FISH_EVENT_NO_CATCH: plays when a fish nibbled but was not caught
//   - FISH_EVENT_NO_NIBBLE: plays when no fish nibbled at all
int PlayFishingAnimation(int nEvent);

// ----- System Functions ------------------------------------------------------

// These functions should only be used by the internal system.

// ---< InitializeFishingSystem >---
// ---< fish_i_main >---
// Runs the config function OnFishingSetup() if it has not been run yet.
// Note: This is an internal function and should not be used by the builder.
void InitializeFishingSystem(object oPC, object oItem);

// ---< HandleFishingTackle >---
// ---< fish_i_main >---
// If the item the PC is currently using is a tackle item, checks to see if the
// item can be used on oTarget (if oTarget is invalid, checks the PC's currently
// equipped item). If so, it applies the tackle. Sends a FISH_EVENT_USE_TACKLE
// or FISH_EVENT_BAD_TARGET message to the PC as appropriate. Returns TRUE if
// the item was tackle.
// Note: This is an internal function and should not be used by the builder.
int HandleFishingTackle(object oTarget);

// ---< VerifyFishingTackle >---
// ---< fish_i_main >---
// Returns whether the PC is using all the required tackle for his equipment. If
// a required slot does not have tackle in it, will send a FISH_EVENT_NO_TACKLE
// message for the equipment type and the tackle slot to the PC.
// Note: This is an internal function and should not be used by the builder.
int VerifyFishingTackle();

// ---< VerifyFishingSpot >---
// ---< fish_i_main >---
// Returns whether the nearest fishing spot is near enough to the PC. Will also
// return TRUE if the PC is inside a fishing spot trigger. The maximum distance
// depends on the value set by SetFishingDistance() (either for the equipment in
// use or globally. If a fishing spot near enough to the PC is not found, will
// send a FISH_EVENT_NO_SPOT message to the PC.
// Note: This is an internal function and should not be used by the builder.
int VerifyFishingSpot();

// ---< ActionFishEvent >---
// ---< fish_i_main >---
// Sends the appropiate message to the PC based on his equipment type, then runs
// the config function PlayFishingAnimation() for the appropriate event.
// Note: This is an internal function and should not be used by the builder.
void ActionFishEvent(int nEvent);

// ---< ActionFish >---
// ---< fish_i_main >---
// Does the actual fishing. This function runs OnActivate when oEquipment is
// used. We place it into a separate function so we can AssignCommand() it to
// the PC and refer to him as OBJECT_SELF.
// Note: This is an internal function and should not be used by the builder.
void ActionFish();


// -----------------------------------------------------------------------------
//                          Function Implementations
// -----------------------------------------------------------------------------

// ----- Variable Accessor Functions -------------------------------------------

float GetFishFloat(string sVarName, string sKey = "")
{
    if (sKey == "" || !GetLocalInt(Fish.Data, "F: " + sKey + sVarName))
        return GetLocalFloat(Fish.Data, sVarName);

    return GetLocalFloat(Fish.Data, sKey + sVarName);
}

int GetFishInt(string sVarName, string sKey = "")
{
    if (sKey == "" || !GetLocalInt(Fish.Data, "I: " + sKey + sVarName))
        return GetLocalInt(Fish.Data, sVarName);

    return GetLocalInt(Fish.Data, sKey + sVarName);
}

string GetFishString(string sVarName, string sKey = "")
{
    if (sKey == "" || !GetLocalInt(Fish.Data, "S: " + sKey + sVarName))
        return GetLocalString(Fish.Data, sVarName);

    return GetLocalString(Fish.Data, sKey + sVarName);
}

void SetFishFloat(string sVarName, float fValue, string sList = "")
{
    string sKey;
    int i, nCount = CountList(sList);
    for (i = 0; i < nCount; i++)
    {
        sKey = GetListItem(sList, i);
        SetLocalFloat(Fish.Data, sKey + sVarName, fValue);
        SetLocalInt(Fish.Data, "F: " + sKey + sVarName, TRUE);
    }

    // If no key is provided, set the value globally.
    if (!nCount)
        SetLocalFloat(Fish.Data, sVarName, fValue);
}

void SetFishInt(string sVarName, int nValue, string sList = "")
{
    string sKey;
    int i, nCount = CountList(sList);
    for (i = 0; i < nCount; i++)
    {
        sKey = GetListItem(sList, i);
        SetLocalInt(Fish.Data, sKey + sVarName, nValue);
        SetLocalInt(Fish.Data, "I: " + sKey + sVarName, TRUE);
    }

    // If no key is provided, set the value globally.
    if (!nCount)
        SetLocalInt(Fish.Data, sVarName, nValue);
}

void SetFishString(string sVarName, string sValue, string sList = "")
{
    string sKey;
    int i, nCount = CountList(sList);
    for (i = 0; i < nCount; i++)
    {
        sKey = GetListItem(sList, i);
        SetLocalString(Fish.Data, sKey + sVarName, sValue);
        SetLocalInt(Fish.Data, "S: " + sKey + sVarName, TRUE);
    }

    // If no key is provided, set the value globally.
    if (!nCount)
        SetLocalString(Fish.Data, sVarName, sValue);
}


// ----- Debug Functions -------------------------------------------------------

void SetFishingDebugMode(int bDebug, object oTarget = OBJECT_INVALID)
{
    if (!GetIsObjectValid(oTarget))
    {
        if (GetIsObjectValid(Fish.Data))
            oTarget = Fish.Data;
        else
        {
            // If Fish.Data is not set, we are being called from outside the
            // fishing system. Get the fishing data point. If it doesn't exist,
            // then the fishing system has not been set up and this will have no
            // effect.
            oTarget = GetWaypointByTag(FISH_WP_DATA);
            if (!GetIsObjectValid(oTarget))
                return;
        }
    }

    SetLocalInt(oTarget, FISH_DEBUG, bDebug);
    Fish.Debug = bDebug;
}

int GetFishingDebugMode(object oTarget = OBJECT_INVALID)
{
    if (!GetIsObjectValid(oTarget))
    {
        if (GetIsObjectValid(Fish.Data))
            return Fish.Debug;

        // If Fish.Data is not set, we are being called from outside the fishing
        // system. Get the fishing data point. If it doesn't exist, then the
        // fishing system has not been set up and this will have no effect.
        oTarget = GetWaypointByTag(FISH_WP_DATA);
    }

    return GetLocalInt(oTarget, FISH_DEBUG);
}

void FishingDebug(string sMessage)
{
    if (Fish.Debug)
    {
        if (Fish.PC == OBJECT_SELF)
            ActionDoCommand(SendMessageToPC(Fish.PC, sMessage));
        else
            SendMessageToPC(Fish.PC, sMessage);

        PrintString(sMessage);
    }
}


// ----- Fishing Equipment and Tackle Functions --------------------------------

// Sets the following for each <tackle> and <slot> combination:
// Name                       Type      Purpose
// <equipment>ALLOWED<slot>   int       whether <slot> is a tackle slot used by <equipment>
// <equipment>REQUIRED<slot>  int       whether <slot> is a tackle slot required by <equipment>
// <equipment>ALLOWED         CSV list  all tackle slots used by <equipment>
// <equipment>REQUIRED        CSV list  all tackle slots required by <equipment>
void AddFishingTackleSlot(string sEquipment, string sSlot, int bRequired = FALSE)
{
    if (sEquipment == "" || sSlot == "")
        return;

    // Prevent adding the slot multiple times
    int bAdded = GetLocalInt(Fish.Data, sEquipment + FISH_TACKLE_ALLOWED + sSlot);
    if (bAdded && (!bRequired || GetLocalInt(Fish.Data, sEquipment + FISH_TACKLE_REQUIRED + sSlot)))
        return;

    FishingDebug("Adding tackle slot " + sSlot + " to " + sEquipment + "'s " +
                 (bRequired ? "required" : "optional") + " tackle list");

    if (!bAdded)
    {
        // Add the slot to a master list for the equipment
        AddLocalListItem(Fish.Data, sEquipment + FISH_TACKLE_ALLOWED, sSlot);
        SetLocalInt(Fish.Data, sEquipment + FISH_TACKLE_ALLOWED + sSlot, TRUE);
    }

    // Slots that were already added can still be upgraded to required
    if (bRequired)
    {
        // Add the slot to a list of required slots for the equipment
        AddLocalListItem(Fish.Data, sEquipment + FISH_TACKLE_REQUIRED, sSlot);
        SetLocalInt(Fish.Data, sEquipment + FISH_TACKLE_REQUIRED + sSlot, TRUE);
    }
}

void AddFishingTackleSlots(string sEquipmentList, string sSlotList, string sRequiredSlotList = "")
{
    // Sanity check
    if (sEquipmentList == "") return;

    string sEquipment, sSlot;
    int i, nEquipment = CountList(sEquipmentList);
    int j, nRequired  = CountList(sRequiredSlotList);
    int    nSlot      = CountList(sSlotList);


    for (i = 0; i < nEquipment; i++)
    {
        sEquipment = GetListItem(sEquipmentList);
        if (sEquipment == "")
            continue;

        for (j = 0; j < nRequired; j++)
        {
            sSlot = GetListItem(sRequiredSlotList, j);
            AddFishingTackleSlot(sEquipment, sSlot, TRUE);
        }

        for (j = 0; j < nSlot; j++)
        {
            sSlot = GetListItem(sSlotList, j);
            AddFishingTackleSlot(sEquipment, sSlot, FALSE);
        }
    }
}

string GetFishingTackleSlots(string sEquipment, int bRequiredOnly = FALSE)
{
    if (bRequiredOnly)
        return GetLocalString(Fish.Data, sEquipment + FISH_TACKLE_REQUIRED);

    return GetLocalString(Fish.Data, sEquipment + FISH_TACKLE_ALLOWED);
}

int CanUseFishingTackle(string sEquipment, string sTackle)
{
    string sSlot = GetFishingTackleSlot(sTackle);
    return HasFishingTackleSlot(sEquipment, sSlot);
}

int HasFishingTackleSlot(string sEquipment, string sSlot, int bRequiredOnly = FALSE)
{
    if (bRequiredOnly)
        return GetLocalInt(Fish.Data, sEquipment + FISH_TACKLE_REQUIRED + sSlot);

    return GetLocalInt(Fish.Data, sEquipment + FISH_TACKLE_ALLOWED + sSlot);
}

// Internal function used by SetIsFishingTackle(). Adds a tackle slot to the
// master tackle slot list if it does not already exist.
void SetIsFishingTackleSlot(string sSlot)
{
    if (sSlot == "" ||
        GetLocalInt(Fish.Data, FISH_TACKLE_SLOT + sSlot))
        return;

    FishingDebug("Adding tackle slot " + sSlot);

    // Add the slot to a reference list
    AddLocalListItem(Fish.Data, FISH_TACKLE_SLOT, sSlot);

    // Note that the slot exists for quick lookup
    SetLocalInt(Fish.Data, FISH_TACKLE_SLOT + sSlot, TRUE);
}

// Sets the following for each <tackle> and <slot> combination:
// Name              Type      Purpose
// "TACKLE"          CSV list  all <tackle> items
// "SLOT"            CSV list  all <slot> types
// "SLOT<slot>"      CSV list  all <tackle> of type <slot>
// "<tackle>SLOT"    string    the <slot> for <tackle>
// "SLOT<slot>"      int       whether <slot> is a defined tackle slot
// "TACKLE<tackle>"  int       whether <tackle> is a defined tackle item
void SetIsFishingTackle(string sTackleList, string sSlot = "")
{
    // If the slot is blank, the tackle type will be the slot
    int bTackleIsSlot = (sSlot == "");

    // Add the tackle slot to a reference list.
    if (!bTackleIsSlot)
        SetIsFishingTackleSlot(sSlot);

    // Loop through the tackle types.
    string sTackle;
    string sSlotTackleList = GetLocalString(Fish.Data, FISH_TACKLE_SLOT + sSlot);
    string sGlobalTackleList = GetLocalString(Fish.Data, FISH_TACKLE);
    int i, nCount = CountList(sTackleList);
    for (i = 0; i < nCount; i++)
    {
        sTackle = GetListItem(sTackleList, i);

        // If the tackle has already been defined, skip it
        if (GetLocalInt(Fish.Data, FISH_TACKLE + sTackle))
            continue;

        // If the tackle is its own slot name...
        if (bTackleIsSlot)
        {
            sSlot = sTackle;
            SetIsFishingTackleSlot(sSlot);

            // Add the tackle to the slot's master list
            AddLocalListItem(Fish.Data, FISH_TACKLE_SLOT + sSlot, sTackle);
        }
        else
            sSlotTackleList = AddListItem(sSlotTackleList, sTackle);

        FishingDebug("Adding tackle type " + sTackle + " matching slot " + sSlot);

        // Add the tackle item to a reference list
        sGlobalTackleList = AddListItem(sGlobalTackleList, sTackle);

        // Set the tackle's slot type
        SetLocalString(Fish.Data, sTackle + FISH_TACKLE_SLOT, sSlot);

        // Note that the slot exists for quick lookup
        SetLocalInt(Fish.Data, FISH_TACKLE + sTackle, TRUE);
    }

    // Save the tackle lists
    SetLocalString(Fish.Data, FISH_TACKLE, sGlobalTackleList);
    if (!bTackleIsSlot)
        SetLocalString(Fish.Data, FISH_TACKLE_SLOT + sSlot, sSlotTackleList);
}

string GetFishingTackleSlot(string sTackle)
{
    return GetLocalString(Fish.Data, sTackle + FISH_TACKLE_SLOT);
}

int GetIsFishingTackle(string sType)
{
    FishingDebug("Checking if " + sType + " is in the list of tackle items: " + GetLocalString(Fish.Data, FISH_TACKLE));
    return GetLocalInt(Fish.Data, FISH_TACKLE + sType);
}

string GetFishingTackle(string sSlot = "", object oEquipment = OBJECT_INVALID)
{
    if (!GetIsObjectValid(oEquipment))
        oEquipment = Fish.Item;

    if (sSlot != "")
        return GetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot);

    string sTackle, sTackleList;
    int i, nCount = CountStringList(oEquipment, FISH_TACKLE_SLOT);
    for (i = 0; i < nCount; i++)
    {
        sSlot = GetListString(oEquipment, i, FISH_TACKLE_SLOT);
        sTackle = GetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot);
        sTackleList = AddListItem(sTackleList, sTackle);
    }

    return sTackleList;
}

float GetFishingDistance(string sEquipment)
{
    return GetFishFloat(FISH_DISTANCE, sEquipment);
}

void SetFishingDistance(float fMax, string sEquipmentList = "")
{
    SetFishFloat(FISH_DISTANCE, fMax, sEquipmentList);
}


// ----- Fish Frequency Functions ----------------------------------------------

// Sets the following for each <frequency> and <fish> combination:
// Name               Type         Purpose
// ""                 string list  all fish
// ""                 int          whether the fish has been added
// "<fish>FREQUENCY"  int          the unmodified <frequency> at which <fish> appears
void AddFish(int nFreq, string sFishList)
{
    string sFish;

    int i, nCount = CountList(sFishList);
    for (i = 0; i < nCount; i++)
    {
        sFish = GetListItem(sFishList, i);
        if (!GetLocalInt(Fish.Data, sFish))
        {
            AddListString(Fish.Data, sFish);
            SetLocalInt(Fish.Data, sFish, TRUE);
            SetLocalInt(Fish.Data, sFish + FISH_FREQUENCY, nFreq);
            FishingDebug("Adding fish " + sFish + " with frequency " + IntToString(nFreq));
        }
    }
}

string GetFish(int nNth)
{
    return GetListString(Fish.Data, nNth);
}

int GetFishCount()
{
    return CountStringList(Fish.Data);
}

int GetFishFrequency(string sFish)
{
    return GetLocalInt(Fish.Data, sFish + FISH_FREQUENCY);
}

string GetFishResRef(string sFish)
{
    return GetFishString(FISH_RESREF, sFish);
}

void SetFishResRef(string sResRef, string sFishList = "")
{
    SetFishString(FISH_RESREF, sResRef, sFishList);
}

string GetFishName(string sFish)
{
    return GetFishString(FISH_NAME, sFish);
}

void SetFishName(string sName, string sFishList = "")
{
    SetFishString(FISH_NAME, sName, sFishList);
}

string GetFishTag(string sFish)
{
    return GetFishString(FISH_TAG, sFish);
}

void SetFishTag(string sTag, string sFishList = "")
{
    SetFishString(FISH_TAG, sTag, sFishList);
}

string GetFishDescription(string sFish)
{
    return GetFishString(FISH_DESCRIPTION, sFish);
}

void SetFishDescription(string sDescription, string sFishList = "")
{
    SetFishString(FISH_DESCRIPTION, sDescription, sFishList);
}

int GetFishStackSize(string sFish)
{
    return GetFishInt(FISH_STACK, sFish);
}

void SetFishStackSize(int nStackSize, string sFishList = "")
{
    SetFishInt(FISH_STACK, nStackSize, sFishList);
}

// Sets the following for each <modifier> and <fish> combination:
// Name                         Type  Purpose
// "<fish><type><modifier>MOD"  int   value of <modifier> to catch <fish>
void SetFishModifier(string sType, int nValue, string sModifierList, string sFishList)
{
    string sModifier;
    int i, nCount = CountList(sModifierList);
    for (i = 0; i < nCount; i++)
    {
        sModifier = GetListItem(sModifierList, i);
        SetFishInt(sType + sModifier + FISH_MOD, nValue, sFishList);
    }
}

int GetFishModifier(string sType, string sModifier, string sFish)
{
    return GetFishInt(sType + sModifier + FISH_MOD, sFish);
}

void SetFishEnvironmentModifier(int nValue, string sEnvironmentList, string sFishList)
{
    SetFishModifier(FISH_ENVIRONMENT, nValue, sEnvironmentList, sFishList);
}

int GetFishEnvironmentModifier(string sEnvironment, string sFish)
{
    return GetFishModifier(FISH_ENVIRONMENT, sEnvironment, sFish);
}

void SetFishEquipmentModifier(int nValue, string sEquipmentList, string sFishList)
{
    SetFishModifier(FISH_EQUIPMENT, nValue, sEquipmentList, sFishList);
}

int GetFishEquipmentModifier(string sEquipment, string sFish)
{
    return GetFishModifier(FISH_EQUIPMENT, sEquipment, sFish);
}

void SetFishTackleSlotModifier(int nValue, string sSlotList, string sFishList)
{
    SetFishModifier(FISH_TACKLE_SLOT, nValue, sSlotList, sFishList);
}

int GetFishTackleSlotModifier(string sSlot, string sFish)
{
    return GetFishModifier(FISH_TACKLE_SLOT, sSlot, sFish);
}

void SetFishTackleModifier(int nValue, string sTackleList, string sFishList)
{
    SetFishModifier(FISH_TACKLE, nValue, sTackleList, sFishList);
}

int GetFishTackleModifier(string sTackle, string sFish)
{
    return GetFishModifier(FISH_TACKLE, sTackle, sFish);
}

// Internal function used by AddFishListItems(). It should not be used by the
// builder. Adds an item to the black/whitelist if it is not already there.
// Returns whether the addition was successful.
// TODO: make this a public function for making custom lists.
int AddFishListItem(string sListType, string sItemType, string sItem, string sFish)
{
    // Sanity check
    // TODO: consider allowing making the list global and inheritable
    if (sFish == "" || sItem == "")
        return FALSE;

    string sMessage = sFish + "'s " + GetStringLowerCase(sItemType) + " " + GetStringLowerCase(sListType);

    // Check if the item has already been listed
    string sVarName = sItemType + sFish + sListType;
    if (GetLocalInt(Fish.Data, sVarName + sItem))
    {
        FishingDebug(sItem + " is already in " + sMessage + ". Skipping...");
        return FALSE;
    }

    // This is the master list of items in the sItemType white/blacklist
    string sList = AddLocalListItem(Fish.Data, sVarName, sItem);
    FishingDebug("Adding " + sItem + " to " + sMessage + ". Updated list: " + sList);

    // Allows us to short-circuit reading the list to see if the item is there
    SetLocalInt(Fish.Data, sVarName + sItem, TRUE);
    return TRUE;
}

// Internal function used by the White/BlaclistFish() functions. It should not
// be used by the builder. Adds an item to the black/whitelist of each fish in
// sFishList if it is not already there. Returns whether the addition was
// successful.
// TODO: make this a public function for making custom lists.
void AddFishListItems(string sListType, string sItemType, string sItemList, string sFishList)
{
    string sFish, sItem;
    int i, nFish = CountList(sFishList);
    int j, nItems = CountList(sItemList);

    for (i = 0; i < nFish; i++)
    {
        sFish = GetListItem(sFishList, i);

        for (j = 0; j < nItems; j++)
        {
            sItem = GetListItem(sItemList, j);
            AddFishListItem(sListType, sItemType, sItem, sFish);
        }
    }
}

void WhitelistFish(string sType, string sWhitelist, string sFishList)
{
    AddFishListItems(FISH_WHITELIST, sType, sWhitelist, sFishList);
}

void WhitelistFishEnvironment(string sEnvironmentList, string sFishList)
{
    WhitelistFish(FISH_ENVIRONMENT, sEnvironmentList, sFishList);
}

void WhitelistFishEquipment(string sEquipmentList, string sFishList)
{
    WhitelistFish(FISH_EQUIPMENT, sEquipmentList, sFishList);
}

void WhitelistFishTackleSlot(string sTackleSlotList, string sFishList)
{
    WhitelistFish(FISH_TACKLE_SLOT, sTackleSlotList, sFishList);
}

void WhitelistFishTackle(string sTackleList, string sFishList)
{
    string sTackle, sSlot, sFish;
    int i, nTackle = CountList(sTackleList);
    int j, nFish = CountList(sFishList);

    for (i = 0; i < nTackle; i++)
    {
        sTackle = GetListItem(sTackleList, i);
        sSlot = GetFishingTackleSlot(sTackle);

        for (j = 0; j < nFish; j++)
        {
            sFish = GetListItem(sFishList, j);

            // Whitelist both the tackle and its slot so the tackle won't be
            // refused because of its slot.
            AddFishListItem(FISH_WHITELIST, FISH_TACKLE_SLOT, sSlot,   sFish);
            AddFishListItem(FISH_WHITELIST, FISH_TACKLE,      sTackle, sFish);
        }
    }
}

void BlacklistFish(string sType, string sBlacklist, string sFishList)
{
    AddFishListItems(FISH_BLACKLIST, sType, sBlacklist, sFishList);
}

void BlacklistFishEnvironment(string sEnvironmentList, string sFishList)
{
    BlacklistFish(FISH_ENVIRONMENT, sEnvironmentList, sFishList);
}

void BlacklistFishEquipment(string sEquipmentList, string sFishList)
{
    BlacklistFish(FISH_EQUIPMENT, sEquipmentList, sFishList);
}

void BlacklistFishTackleSlot(string sTackleSlotList, string sFishList)
{
    BlacklistFish(FISH_TACKLE_SLOT, sTackleSlotList, sFishList);
}

void BlacklistFishTackle(string sTackleList, string sFishList)
{
    BlacklistFish(FISH_TACKLE, sTackleList, sFishList);
}

string GetFishWhitelist(string sType, string sFish)
{
    return GetLocalString(Fish.Data, sType + sFish + FISH_WHITELIST);
}

int HasFishWhitelist(string sType, string sFish)
{
    return (GetFishWhitelist(sType, sFish) != "");
}

int InFishWhitelist(string sType, string sItem, string sFish)
{
    return GetLocalInt(Fish.Data, sType + sFish + FISH_WHITELIST + sItem);
}

string GetFishBlacklist(string sType, string sFish)
{
    return GetLocalString(Fish.Data, sType + sFish + FISH_BLACKLIST);
}

int HasFishBlacklist(string sType, string sFish)
{
    return (GetFishBlacklist(sType, sFish) != "");
}

int InFishBlacklist(string sType, string sItem, string sFish)
{
    return GetLocalInt(Fish.Data, sType + sFish + FISH_BLACKLIST + sItem);
}


// ----- Fishing Message Functions ---------------------------------------------

// Sets the following each run
// Name                 Type         Purpose
// "<key>MSG(<event>)"  string list  messages for <key> during <event>
void AddFishMessage(int nEvent, string sKeyList, string sMessage)
{
    // Sanity check
    if (sMessage == "")
        return;

    string sListName = FISH_MESSAGE + "(" + IntToString(nEvent) +  ")";
    int i, nCount = CountList(sKeyList);
    for (i = 0; i < nCount; i++)
        AddListString(Fish.Data, sMessage, GetListItem(sKeyList, i) + sListName);

    // Handle global messages
    if (!nCount)
        AddListString(Fish.Data, sMessage, sListName);
}

string GetFishMessage(int nEvent, string sKey = "")
{
    string sListName = FISH_MESSAGE + "(" + IntToString(nEvent) +  ")";

    // If we have no key, get a random message from the global list
    int nGlobalCount = CountStringList(Fish.Data, sListName);
    if (sKey == "")
        return GetListString(Fish.Data, Random(nGlobalCount), sListName);

    // Pick a random message from either the global or local message lists.
    int nLocalCount = CountStringList(Fish.Data, sKey + sListName);
    int nIndex      = Random(nLocalCount + nGlobalCount);

    if (nIndex < nLocalCount)
        return GetListString(Fish.Data, nIndex, sKey + sListName);
    else
        return GetListString(Fish.Data, nIndex - nLocalCount, sListName);
}

void FloatingFishMessage(int nEvent, string sKey = "")
{
    string sMessage = GetFishMessage(nEvent, sKey);
    FloatingTextStringOnCreature(sMessage, Fish.PC, FALSE);
}


// ----- Public Accessor Functions ---------------------------------------------

object GetFishingSpot()
{
    return Fish.Spot;
}

string GetFishingEnvironment(object oSpot = OBJECT_INVALID)
{
    if (!GetIsObjectValid(oSpot))
        return Fish.Environment;

    return GetName(oSpot);
}

object GetFishingEquipment()
{
    return Fish.Item;
}

string GetFishingEquipmentType(object oEquipment = OBJECT_INVALID)
{
    string sType;

    // If the object is valid, use its tag.
    if (GetIsObjectValid(oEquipment))
    {
        // Ensure this is actually fishing equipment
        string sTag = GetTag(oEquipment);
        if (FindSubString(sTag, "fish_t_equipment") == -1)
            return "";

        // Anything after "fish_t_equipment_" is the type
        sType = GetStringRight(sTag, GetStringLength(sTag) - 17);

        // If we have nothing after the tag, default to the resref.
        return (sType == "" ? GetResRef(oEquipment) : sType);
    }

    return Fish.Type;
}

// Private function. Changes the given fishing equipment's description to show
// the tackle used.
void BuildFishingEquipmentDescription(object oEquipment)
{
    string sDescription = GetDescription(oEquipment, TRUE) + "\n\nTackle equipped: ";
    string sTackleList = GetFishingTackle("", oEquipment);
    string sTackle, sSlot, sName, sNameList;
    int i, nCount = CountList(sTackleList);

    for (i = 0; i < nCount; i++)
    {
        sTackle = GetListItem(sTackleList, i);
        sSlot = GetFishingTackleSlot(sTackle);
        sName = GetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_NAME);
        sNameList = AddListItem(sNameList, sName);
    }

    sDescription += (sNameList == "" ? "None" : sNameList);
    SetDescription(oEquipment, sDescription);
}

object RemoveFishingTackle(string sSlot, int bReplace, object oEquipment = OBJECT_INVALID)
{
    if (!GetIsObjectValid(oEquipment))
        oEquipment = Fish.Item;

    // If the slot is not in use, abort.
    int nSlot = FindListString(oEquipment, sSlot, FISH_TACKLE_SLOT);
    if (nSlot < 0)
        return OBJECT_INVALID;

    object oTackle;
    if (bReplace)
    {
        // Get the stored data and replace the currently equipped tackle item.
        string sTag    = GetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_TAG);
        string sName   = GetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_NAME);
        string sResRef = GetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_RESREF);

        oTackle = CreateItemOnObject(sResRef, Fish.PC, 1, sTag);
        SetName(oTackle, sName);
    }

    // Clean up.
    DeleteLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot);
    DeleteLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_TAG);
    DeleteLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_NAME);
    DeleteLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_RESREF);
    DeleteListString(oEquipment, nSlot, FISH_TACKLE_SLOT);

    BuildFishingEquipmentDescription(oEquipment);
    return oTackle;
}

// ----- Action Wrappers -------------------------------------------------------

void ActionFloatingTextString(string sMessage)
{
    ActionDoCommand(FloatingTextStringOnCreature(sMessage, Fish.PC, FALSE));
}

void ActionFloatingFishMessage(int nEvent, string sKey = "")
{
    ActionDoCommand(FloatingFishMessage(nEvent, sKey));
}

void ActionRemoveFishingTackle(string sTackle, int bReplace)
{
    ActionDoCommand(ObjectToAction(RemoveFishingTackle(sTackle, bReplace)));
}

// Private function for ActionCreateFish()
void CreateFish(string sFish)
{
    FloatingFishMessage(FISH_EVENT_CATCH, sFish);

    string sResRef = GetFishResRef(sFish);
    if (sResRef == "")
        sResRef = sFish;

    int nStackSize = GetFishStackSize(sFish);
    if (nStackSize < 1)
        nStackSize = 1;

    string sTag  = GetFishTag(sFish);
    object oFish = CreateItemOnObject(sResRef, Fish.PC, nStackSize, sTag);

    SetName(oFish, GetFishName(sFish));
    SetDescription(oFish, GetFishDescription(sFish));
}

void ActionCreateFish(string sFish)
{
    ActionDoCommand(CreateFish(sFish));
}

void ObjectToAction(object oObject){}

// ----- Private System Functions ----------------------------------------------

void InitializeFishingSystem(object oPC, object oItem)
{
    // Set our globals
    Fish.PC   = oPC;
    Fish.Item = oItem;
    Fish.Type = GetFishingEquipmentType(Fish.Item);
    Fish.Data = GetWaypointByTag(FISH_WP_DATA);

    // Should we debug?
    Fish.Debug = GetLocalInt(Fish.Data, FISH_DEBUG) ? TRUE :
                 GetLocalInt(oPC,       FISH_DEBUG) ? TRUE :
                 GetLocalInt(oItem,     FISH_DEBUG);

    // Make sure the fishing datapoint is set up
    if (!GetIsObjectValid(Fish.Data))
    {
        Fish.Data = CreateObject(OBJECT_TYPE_WAYPOINT, FISH_WP_GENERIC, GetStartingLocation(), FALSE, FISH_WP_DATA);

        // Run our config function.
        OnFishingSetup();

        // If the user did not define any fish, add a default one
        if (!GetFishCount())
            AddFish(30, FISH_DEFAULT);

        // If the user did not define a max fishing distance default, set one
        if (GetFishingDistance("") <= 0.0)
            SetFishingDistance(5.0);
    }
}

int HandleFishingTackle(object oEquipment)
{
    // If this isn't tackle, abort.
    if (!GetIsFishingTackle(Fish.Type))
        return FALSE;

    // If the PC has used the tackle on a target, target the equipped item.
    if (!GetIsObjectValid(oEquipment) || GetItemPossessor(oEquipment) != Fish.PC)
        oEquipment = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, Fish.PC);

    string sType = GetFishingEquipmentType(oEquipment);
    string sSlot = GetFishingTackleSlot(Fish.Type);
    FishingDebug("Trying to use a " + Fish.Type + " tackle item (slot: " + sSlot +
                 ") on equipment: " + GetName(oEquipment) +
                 " (allowed slots: " + GetFishingTackleSlots(sType) + ").");
    if (sType == "" || !HasFishingTackleSlot(sType, sSlot)
                    || !OnFishingTackleUsed(oEquipment, Fish.Item, sSlot))
    {
        // The tackle was not used on the correct type of item. Notify the PC.
        FloatingFishMessage(FISH_EVENT_BAD_TARGET, Fish.Type);
        return TRUE;
    }

    // We can use this tackle on our equipment!
    AddListString(oEquipment, sSlot, FISH_TACKLE_SLOT, TRUE);
    SetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot,               Fish.Type);
    SetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_TAG,    GetTag(Fish.Item));
    SetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_NAME,   GetName(Fish.Item));
    SetLocalString(oEquipment, FISH_TACKLE_SLOT + sSlot + FISH_RESREF, GetResRef(Fish.Item));

    // Build the equipment's description so the PC can tell which tackle is used.
    BuildFishingEquipmentDescription(oEquipment);

    // Get the appropriate message and send it to the PC.
    FloatingFishMessage(FISH_EVENT_USE_TACKLE, Fish.Type);
    return TRUE;
}

int VerifyFishingTackle()
{
    // Get the list of required tackle for this equipment.
    string sSlot, sSlots = GetFishingTackleSlots(Fish.Type, TRUE);
    int i, nCount = CountList(sSlots);
    for (i = 0; i < nCount; i++)
    {
        sSlot = GetListItem(sSlots, i);
        if (GetFishingTackle(sSlot, Fish.Item) == "")
        {
            // Notify the PC that he needs the proper tackle. Send a message for
            // the equipment and for the tackle.
            FloatingFishMessage(FISH_EVENT_NO_TACKLE, Fish.Type);
            FloatingFishMessage(FISH_EVENT_NO_TACKLE, sSlot);
            return FALSE;
        }
    }

    // If we fell through, we have all the tackle we need.
    return TRUE;
}

int VerifyFishingSpot()
{
    // Get the maximum distance the PC can fish from. 0.0 means no max distance.
    float fMax = GetFishFloat(FISH_DISTANCE, Fish.Type);
    int i, bNoMax = fMax <= 0.0;

    // Find the nearest fishing spot
    Fish.Spot = GetNearestObjectByTag(FISH_WP_FISHING, Fish.PC, ++i);

    while (GetIsObjectValid(Fish.Spot))
    {
        // Only use a trigger if we are inside of it.
        if (GetIsInSubArea(Fish.PC, Fish.Spot))
            return TRUE;

        // Use non-trigger fishing spots only if there is no max distance or we
        // are in range of it.
        if (GetObjectType(Fish.Spot) != OBJECT_TYPE_TRIGGER &&
           (bNoMax || GetDistanceBetween(Fish.PC, Fish.Spot) <= fMax))
            return TRUE;

        Fish.Spot = GetNearestObjectByTag(FISH_WP_FISHING, Fish.PC, ++i);
    }

    // No fishing spot was found, so notify the PC.
    FloatingFishMessage(FISH_EVENT_NO_SPOT, Fish.Type);
    return FALSE;
}

void ActionFishEvent(int nEvent)
{
    ActionFloatingFishMessage(nEvent, Fish.Type);

    // If the builder has not enabled a custom animation for this event, play
    // the default one.
    if (PlayFishingAnimation(nEvent))
    {
        switch (nEvent)
        {
            case FISH_EVENT_START:
                PlaySound("as_na_splash1");
                ActionPlayAnimation(ANIMATION_LOOPING_TALK_NORMAL, 1.0, IntToFloat(Random(10) + 4));
                break;

            case FISH_EVENT_NIBBLE:
                ActionPlayAnimation(ANIMATION_FIREFORGET_SALUTE);
                ActionPlayAnimation(ANIMATION_LOOPING_SPASM, 0.1, 6.0);
                ActionPlayAnimation(ANIMATION_FIREFORGET_SALUTE);
                break;

            case FISH_EVENT_CATCH:
                PlaySound("as_na_splash2");
                ActionPlayAnimation(ANIMATION_FIREFORGET_VICTORY1);
                break;

            case FISH_EVENT_NO_CATCH:
                PlaySound("as_na_splash2");
                ActionPlayAnimation(ANIMATION_FIREFORGET_TAUNT);
                break;

            case FISH_EVENT_NO_NIBBLE:
                ActionPlayAnimation(ANIMATION_FIREFORGET_PAUSE_BORED);
                break;

        }
    }
}

// Private function for CheckFishRequirements(). Returns whether sFish can be
// caught using the current equipment.
int CheckFishEquipment(string sFish)
{
    if (InFishBlacklist(FISH_EQUIPMENT, Fish.Type, sFish))
    {
        FishingDebug("  " + Fish.Type + " was found in the equipment blacklist.");
        return FALSE;
    }

    if (HasFishWhitelist(FISH_EQUIPMENT, sFish))
    {
        if (!InFishWhitelist(FISH_EQUIPMENT, Fish.Type, sFish))
        {
            FishingDebug("  " + Fish.Type + " was not found in the equipment whitelist.");
            return FALSE;
        }

        FishingDebug("  " + Fish.Type + " was found in the equipment whitelist.");
    }

    return TRUE;
}

// Private function for CheckFishRequirements(). Returns whether sFish can be
// caught in the current environment.
int CheckFishEnvironment(string sFish)
{
    int bWhite = HasFishWhitelist(FISH_ENVIRONMENT, sFish);
    int bBlack = HasFishBlacklist(FISH_ENVIRONMENT, sFish);

    // Abort if the fish does not have a whitelist or blacklist of this type.
    if (!bWhite && !bBlack)
        return TRUE;

    string sEnvironment;
    int i, bAny, nCount = CountList(Fish.Environment);
    for (i = 0; i < nCount; i++)
    {
        sEnvironment = GetListItem(Fish.Environment, i);

        // If the environment is in the blacklist, abort.
        if (bBlack && InFishBlacklist(FISH_ENVIRONMENT, sEnvironment, sFish))
        {
            FishingDebug("  " + sEnvironment + " was found in the environment blacklist.");
            return FALSE;
        }

        // Only check the whitelist if we have one and have not already found a
        // whitelisted environment.
        if (!bAny && bWhite && InFishWhitelist(FISH_ENVIRONMENT, sEnvironment, sFish))
        {
            FishingDebug("  " + sEnvironment + " was found in the environment whitelist.");
            bAny = TRUE;
        }
    }

    // Return if there was a whitelist an any of our environments were in it.
    if (bWhite)
    {
        if (bAny)
            return TRUE;

        FishingDebug("  No environment in " + Fish.Environment + " was found in the environment whitelist.");
        return FALSE;
    }

    return TRUE;
}

// Private function for CheckFishRequirements(). Returns whether sFish can be
// caught using the equipped tackle slots.
int CheckFishTackleSlots(string sFish)
{
    string sSlot, sTackle;
    int i, nCount = CountList(Fish.Full);

    // Iterate through the full slots and see if any are in the blacklist.
    for (i = 0; i < nCount; i++)
    {
        sSlot = GetListItem(Fish.Full, i);
        if (InFishBlacklist(FISH_TACKLE_SLOT, sSlot, sFish))
        {
            FishingDebug("  " + sSlot + " was full and found in the slot blacklist.");
            return FALSE;
        }

        sTackle = GetFishingTackle(sSlot, Fish.Item);
        if (InFishBlacklist(FISH_TACKLE, sTackle, sFish))
        {
            FishingDebug("  " + sTackle + " was found in the tackle blacklist.");
            return FALSE;
        }

        // If the tackle slot is whitelisted, check if the tackle is whitelisted
        if (InFishWhitelist(FISH_TACKLE_SLOT, sSlot, sFish) &&
            HasFishWhitelist(FISH_TACKLE, sFish) &&
            !InFishWhitelist(FISH_TACKLE, sTackle, sFish))
        {
            FishingDebug("  " + sTackle + " was not found in the tackle whitelist for slot " + sSlot + ".");
            return FALSE;
        }
    }

    // Iterate through the empty slots and see if any are in the whitelist.
    if (HasFishWhitelist(FISH_TACKLE_SLOT, sFish))
    {
        nCount = CountList(Fish.Empty);
        for (i = 0; i < nCount; i++)
        {
            sSlot = GetListItem(Fish.Empty, i);
            if (InFishWhitelist(FISH_TACKLE_SLOT, sSlot, sFish))
            {
                FishingDebug("  " + sSlot + " was empty and found in the slot whitelist.");
                return FALSE;
            }
        }
    }

    // No full slots were blacklisted, and no empty slots were whitelisted.
    return TRUE;
}

// Private Function for ActionFish(). Returns an error message if sFish cannot
// be caught in the given environment or with the given equipment, tackle slots,
// or tackle.
string CheckFishRequirements(string sFish)
{
    if (!CheckFishEquipment(sFish))
        return "  Skipping " + sFish + ": fish cannot be caught with equipment " + Fish.Type;

    if (!CheckFishEnvironment(sFish))
        return "  Skipping " + sFish + ": fish cannot be caught with environment " + Fish.Environment;

    if (!CheckFishTackleSlots(sFish))
        return "  Skipping " + sFish + ": fish cannot be caught with tackle " + Fish.Tackle;

    if (!OnFishRequirements(sFish))
        return "  Skipping " + sFish + ": fish failed OnFishRequirements() check";

    return "";
}

void ActionFish()
{
    // Set the environment based on the fishing spot
    Fish.Environment = GetFishingEnvironment(Fish.Spot);

    // Load our tackle
    Fish.Tackle = GetFishingTackle("", Fish.Item);

    // Load our tackle slots
    string sSlot, sSlots = GetFishingTackleSlots(Fish.Type);
    int i, nSlots = CountList(sSlots);
    for (i = 0; i < nSlots; i++)
    {
        sSlot = GetListItem(sSlots, i);
        if (GetFishingTackle(sSlot, Fish.Item) == "")
            Fish.Empty = AddListItem(Fish.Empty, sSlot);
        else
            Fish.Full = AddListItem(Fish.Full, sSlot);
    }

    // Run the config function to see if we're allowed to fish.
    if (!OnFishingStart()) return;

    FishingDebug("\nTrying to fish in a "+ Fish.Environment + " using a " + Fish.Type + " using tackle " + Fish.Tackle);

    // Face the fishing spot.
    SetFacingPoint(GetPosition(GetFishingSpot()));
    ActionFishEvent(FISH_EVENT_START);

    // Test for a nibble
    float  fChance = 1.0;
    string sFish, sEnvironment, sTackle, sMessage;
    int n, nFreq, nMod, nChance, nTemp;

    int nTackle       = CountList(Fish.Tackle);
    int nEnvironments = CountList(Fish.Environment);

    // To keep fish earlier in the list from dominating, let's pick a random
    // index and start iterating from there.
    int nCount = GetFishCount();
    int nStart = Random(nCount);

    for (i = 0; i < nCount; i++)
    {
        sFish = GetFish((nStart + i) % nCount);
        FishingDebug("\nTrying to catch a " + sFish);

        // Check the requirements for this fish
        sMessage = CheckFishRequirements(sFish);
        if (sMessage != "")
        {
            // If we got an error message, show it and move to the next fish.
            FishingDebug(sMessage);
            continue;
        }

        // Get environment modifiers
        for (n = 0; n < nEnvironments; n++)
        {
            sEnvironment = GetListItem(Fish.Environment, n);
            nTemp += GetFishEnvironmentModifier(Fish.Environment, sFish);
        }

        nMod = nTemp / nCount;
        FishingDebug("  Applying environment mod: " + IntToString(nMod));

        // Get equipment modifier
        nTemp = GetFishEquipmentModifier(Fish.Type, sFish);
        FishingDebug("  Applying equipment mod: " + IntToString(nTemp));
        nMod += nTemp;

        // If we have fishing tackle, get all the modifiers from it.
        for (n = 0; n < nTackle; n++)
        {
            sTackle = GetListItem(Fish.Tackle, n);
            nTemp   = GetFishTackleModifier(sTackle, sFish);
            FishingDebug("  Applying tackle mod (" + sTackle + "): " + IntToString(nTemp));
            nMod += nTemp;

            sSlot = GetFishingTackleSlot(sTackle);
            nTemp = GetFishTackleSlotModifier(sSlot, sFish);
            FishingDebug("  Applying tackle slot mod (" + sSlot + "): " + IntToString(nTemp));
            nMod += nTemp;
        }

        // Get the frequency the fish bites and allow the user to modify it.
        nFreq = GetFishFrequency(sFish);
        nMod += OnFishNibble(sFish);
        nChance = nFreq + nMod;

        FishingDebug("nFreq: "  + IntToString(nFreq) +
                     " nMod: "  + IntToString(nMod) +
                     " = "      + IntToString(nChance) +
                     "% chance of catching this fish.");

        // Check whether the fish bites.
        int nRoll = Random(100);
        FishingDebug("Rolled a " +  IntToString(nRoll));

        if (nRoll < nChance)
        {
            FishingDebug("Success! Checking if we can reel in the " + sFish);

            // A fish took our line! Let's check if we catch it.
            ActionFishEvent(FISH_EVENT_NIBBLE);
            if (OnFishNibbleSuccess(sFish))
            {
                FishingDebug("Success! Reeling in the " + sFish);
                ActionFishEvent(FISH_EVENT_CATCH);
                if (OnFishCatch(sFish))
                    ActionCreateFish(sFish);
            }
            else
                ActionFishEvent(FISH_EVENT_NO_CATCH);

            return;
        }
        else if (Fish.Debug)
            fChance *= (IntToFloat(100 - nChance) / 100);
    }

    // No fish bit. Run the failure config function.
    FishingDebug("\nNo fish bit! The chance of this happening was " + FloatToString(fChance * 100, 0, 2) + "%");
    if (OnFishNibbleFail())
        ActionFishEvent(FISH_EVENT_NO_NIBBLE);
}