File /obj/handlers/secure_handlers/inhume_inherit.wtf

Includes

Class Index

• collect
  The collect mapping contains all the pending payments to assassins, or refunds to requestors where the contract has timed out.
• collect_entry
  This class keeps track of a single payment (or refund)
• npc_contract
  This is the class that keeps track of possible NPC contracts.

Method index

• add_cannot_close(int, string)
  Mark someone as not able to close contracts or view the book.
• add_cannot_place(int, string)
  Mark someone as not able to place contracts.
• add_collect(string, string, int, int, int)
  Manually set up a payment for someone.
• add_contract(mixed, int, string, int)
  Add a contract to the player.
• add_enforcer(string)
  Add a player to the roster of Guild Enforcers.
• add_expired(string, int)
• add_npc_contract(string, string)
  Add a contract on the given NPC.
• add_npc_contract_details(string, string, int, int)
  Add an NPC to the mapping of inhumable targets.
• add_sacrosanct(int, string, string)
  Mark someone as not able to be inhumed.
• all_contracts_string()
  This function is used to get a sentence-like string of available contracts, it is used with the CWC families.
• allowed_to_access(string)
• allowed_to_contract(object)
  Check to make sure that this player is allowed to place contracts.
• award_contract(string, string)
  Take a currently active contract and remove it from the books, and give the assassin credit for closing it.
• calc_collect_value(string, int)
  Figure out how much a given person is owed, either pre or post taxes and fees.
• calc_collect_value_matrix(string)
  Returns either a 2-element integer array in the form ({ pretax, posttax }) or 0 if the person does not have any money owing.
• calc_contract_cost(object)
  Calculate how much the guild will charge for a contract on this player.
• calc_place(object)
  This is used to pass in a location to the money handler.
• calc_protection_cost(object, int)
  Figure out the protection cost for a given player for a given number of days.
• can_close_players(string)
  Determine whether or not a given player is allowed to view or close PK contracts.
• can_place_family_contract(object, int)
  This checks whether a family contract can be placed on a player.
• cannot_be_inhumed(string)
  If the sucker cannot be inhumed return a reason.
• check_cannot_close(string)
  Check whether someone has been marked as not allowed to close contracts.
• check_cannot_place(string)
  Check whether someone has been marked as not allowed to place contracts.
• check_expired(string)
  Check whether someone is in the _expired mapping.
• check_sacrosanct(string)
  Check whether someone has been marked as not allowed to be inhumed.
• clear_cannot_close(string)
  Admin function to allow player to close contracts again.
• clear_cannot_place(string)
  Admin function to allow player to place contracts again.
• clear_collect(string)
  Remove the collection entry for a player.
• clear_contract(string)
  Remove a contract for the given player/npc.
• clear_expired(string)
  This function clears someone from the _expired mapping.
• clear_npc_inhumed(string)
  Clear the last inhumed entry for an NPC.
• clear_oneshot_npc_contract(object, string, int)
  Code to add one-shot NPC contracts.
• clear_sacrosanct(string, int)
  Admin function to clear a sacrosanct mapping entry.
• collect_payment(object)
  Handle the payment of wages for inhumations performed.
• collect_type(string)
  Figure out whether the given person has refunds, payments, or both waiting for them.
• convert_message(string, string, string, string, string)
• convert_old_contracts(string)
  Used to convert the older existing contracts whenever the contract class changes.
• cost_inform_callback(string, string)
  Called by the login handler.
• delayed_contract(string)
  A player has logged in after a contract was requested.
• delete_benefactor(string)
• delete_enforcer(string)
  Remove a player from the list of Guild Enforcers.
• delete_sacrosanct(string)
• deposit_value_in_coffer(int)
  Add some money into the guild coffers.
• donate_money(object, mixed, string)
  This function interfaces directly with the secretaries, like pay_for_contract and new_contract.
• entering(string, string)
  Called by the login handler.
• expire_contract(string)
  This function is used to expire a contract.
• finish_up(string, string, string)
  Get the text of the message, and store it in the contract info.
• get_benefactor_list()
  Get an ordered list of benefactors.
• get_message_text(string, string)
  Get the text of the message, and then pass it on to finish_up.
• has_coded_protection(string)
  If the sucker cannot be inhumed due to having a contract or having been recently contracted then return 1.
• inform_cost(string)
  Inform the contractor of the cost of the contract and ask them to go pay up if it was accepted, or tell them why it was rejected.
• inform_customer(string)
  Send a message off to someone who has had at least one contract closed for them recently.
• initialise_handler(string)
• list_cannot_close()
  Query the entire cannot_close mapping.
• list_cannot_place()
  Query the entire cannot_place mapping.
• list_contractable_npcs(string)
  Give a nicely formatted table of NPCs that you can request contracts on, and prices.
• list_enforcers()
  Get a nice formatted string containing the names of the Guild Enforcers.
• list_expired()
  Query the entire _expired mapping.
• list_sacrosanct()
  Query the entire sacrosanct mapping.
• load_file()
• log_file(string, string, mixed * args)
• make_receipt(object, string)
  This is the code that makes the receipt that's left on the bodies of inhumed victims.
• modify_contract_cost(object, int)
• new_contract(object, string, int)
  Setup a new contract.
• ok_to_contract_npc(string)
  Figure out if it's ok to place a contract on this NPC yet.
• oneshot_npc_contract(object, string, int)
  Code to add one-shot NPC contracts.
• pay_for_contract(string, object)
  Setup a validated contract.
• pay_protection_money(object, int)
  This function interfaces directly with the secretaries, like pay_for_contract and new_contract.
• place_family_contract(object, int, string)
  This places the family contract.
• player_deleted(mixed, int)
  This is called by the refresh handler when a player deletes.
• player_refreshed(mixed, int, int)
  This is called by the refresh handler when a player refreshes.
• query_active_handler()
• query_all_contracts()
  Return a list of all the current contracts.
• query_all_messages()
  Get a list of all currently-active messages.
• query_allowed_to_access()
• query_benefactors()
• query_coffer()
  Check how much money is in the Guild coffers.
• query_contract(string)
  Admin function to check the status of a contract
• query_contract_date(string)
  Admin function to check the date of a contract.
• query_contract_info(string)
  Admin function to check the details of a contract.
• query_contract_nodeath(string)
  Admin function to check whether a contract is of the no-loss-of-life variety.
• query_contract_value(string)
  Admin function to check the value of a contract.
• query_contracts_by(string)
  This method returns a list of all the people that this person has put a contract on.
• query_contracts_in_state(int)
  This method returns a list of all the people that have a contract in a given status.
• query_enforcer(string)
  Check if a given player is a Guild Enforcer.
• query_enforcers()
  List all Guild Enforcers.
• query_inhume_record(string)
  
• query_npc_contract(string)
  Get the information for an NPC contract.
• query_npc_contracts()
  List all the possible NPC contracts.
• query_npc_time(string)
  Report the timestmp of this NPC's last inhumation.
• query_offenses(string)
  Return a nicely formatted list thingie of a person's offenses for their Special contract.
• query_payments(object)
  If the calling object is a cre, this will return a complete listing of payments due.
• query_requested_or_paid(string, string)
  Check whether the bastard requested or paid for the contract on the sucker.
• query_special_contracts()
  Get a listing of all Special contracts.
• query_times_killed(string, string)
  How many times has the assassin inhumed a particular victim?
• remove_npc_contract(string)
  Remove an NPC from the mapping of inhumable targets.
• request_npc_contract(object, string)
  Internal function for requesting an NPC contract.
• save_file()
• set_already_contracted(string)
• set_am_allowed(int)
• set_amount_string_guild(string)
• set_amount_string_nonguild(string)
• set_can_not_accept(string)
• set_cancel_contract_message(string)
• set_card_desc(string)
• set_card_lang(string)
• set_card_path(string)
• set_collecting_wages(string)
• set_completed_multiple_contract(string)
• set_completed_single_contract(string)
• set_contract_bastard(string, string, string)
  Admin function to change the current bastard of the contract.
• set_contract_nodeath(string, int)
• set_contract_pending(string)
• set_contract_status(string, int)
  Sets the status of a contract.
• set_currency(string)
• set_cwc_allowed(int)
• set_donate_negative(string)
• set_donate_thanks(string)
• set_genua_allowed(int)
• set_guild_name(string)
• set_guild_plural(string)
• set_inform(string)
• set_insurance_terms(string)
• set_klatch_allowed(int)
• set_new_contract(string)
• set_no_contract(string)
• set_no_payments(string)
• set_non_killer(string)
• set_not_allowed(string)
• set_not_pk(string)
• set_not_same_guild(string)
• set_not_yourself(string)
• set_npc_auto_flag(string, int)
  Set the automatic flag for an NPC contract.
• set_paid_with_surcharge(string)
• set_paid_without_surcharge(string)
• set_receipt_close(string)
• set_receipt_normal(string)
• set_secretary_title(string)
• set_too_soon(string)
• set_unable_to_complete(string)
• set_wages_and_refunds(string)
• someone_inhumed(object, object, int)
  Called every time someone is inhumed, by the inhume command.
• special_contract_table()
  Get a nicely-formatted, sorted, columnar table of special contracts.
• submit_message(string)
  Called when a player decides to submit a message annotation to a contract.
• tidy_up()
  This is the bookkeeping function.
• verify_data()

Public Functions

add_cannot_close

nomask void add_cannot_close(int days,
                             string who)

Mark someone as not able to close contracts or view the book. They will be unable to place contracts until time() > duration. This function is access-controlled.

Parameters:
who - Name of the person banned
days - Length of time that the player banned in days.

add_cannot_place

nomask void add_cannot_place(int days,
                             string who)

Mark someone as not able to place contracts. They will be unable to place contracts until time() > duration. This function is access-controlled.

Parameters:
who - Name of the person banned
days - Length of time that the player banned in days.

add_collect

nomask void add_collect(string who,
                        string target,
                        int refund,
                        int value,
                        int time)

Manually set up a payment for someone. This function is access controlled.

Parameters:
who - The person who the payment is for.
target - The name of the player who was inhumed (or 0 if it's a refund).
refund - Flag indicating whether this is a refund (or a payment).
value - Monetary value of the payment.
time - Timestamp for the payment.

add_contract

nomask varargs void add_contract(mixed player,
                                 int stat,
                                 string message,
                                 int nodeath)

Add a contract to the player. Generally this is used to add Special contracts, but it can be used to add any kind of contract. For special contracts, this will also keep a running tab of what crimes were committed by the player. This should only be used if you wish to circumvent the coded protection given to a player after contracts. This function is access-controlled.

Parameters:
player - The player object/name to add the contract to
stat - The status of the contract. Must be between 0 and 4

add_enforcer

nomask int add_enforcer(string name)

Add a player to the roster of Guild Enforcers. Returns 1 for success, 0 if that player is already an enforcer, or -1 if the player is not an assassin. This function is access-controlled.

Parameters:
name - The name of the player to add

Returns:
1, 0, or -1 as above

add_expired

void add_expired(string sucker,
                 int duration)

add_npc_contract

nomask int add_npc_contract(string npc,
                            string requested)

Add a contract on the given NPC. If it's not a valid npc (ie not in the npc mapping), then fail. This function is access-controlled.

Parameters:
npc - the query_name of the NPC on whom a contract should be placed.

Returns:
-1 if the NPC is not in the mapping, 0 if there is already a contract, or 1 for success.

add_npc_contract_details

nomask int add_npc_contract_details(string name,
                                    string short,
                                    int val,
                                    int auto)

Add an NPC to the mapping of inhumable targets. This function is access-controlled.

Parameters:
name - The NPC's set_name
short - The NPC's proper name, as it should appear in the books
val - the value of the contract, in AM dollars
auto - Set to 1 if this NPC should be on the list of automatically generated contracts.

Returns:
0 if there's something wrong with the parameters, -1 if there's already an NPC on file with that set_name, 1 if successful.

add_sacrosanct

nomask void add_sacrosanct(int days,
                           string who,
                           string by_what)

Mark someone as not able to be inhumed. They will be unable to be contracted until time() > duration. This function is access-controlled.

Parameters:
who - Name of the person not to be inhumed
by_what - Either the name of the player who set it or "coded_protection" if after a contract or "insurance" if paid for.
days - Length of time that the player will be protected, in days.

all_contracts_string

nomask string all_contracts_string()

This function is used to get a sentence-like string of available contracts, it is used with the CWC families.

allowed_to_access

int allowed_to_access(string player)

allowed_to_contract

int allowed_to_contract(object bastard)

Check to make sure that this player is allowed to place contracts. They are not allowed if they are disavowed from the assassins guild, or if they have been banned from placing them.

Parameters:
bastard - the player object to check

Returns:
1 if they are allowed, 0 if not allowed.

award_contract

nomask void award_contract(string sucker,
                           string assassin)

Take a currently active contract and remove it from the books, and give the assassin credit for closing it. This will set up payments and keep the certificate up to date. This function is access controlled.

Parameters:
sucker - Name of the person whose contract should be closed.
assassin - Name of the assassin to give the credit to.

calc_collect_value

nomask int calc_collect_value(string who,
                              int aftertax)

Figure out how much a given person is owed, either pre or post taxes and fees.

Parameters:
who - The name of the player to calculate the value for
aftertax - Do we want pre- or post-tax value?

Returns:
the value owed, in brass coins (monetary units)

calc_collect_value_matrix

nomask int * calc_collect_value_matrix(string who)

Returns either a 2-element integer array in the form ({ pretax, posttax }) or 0 if the person does not have any money owing.

Parameters:
who - The name of the player to check

Returns:
the pre and post tax amounts owed, or 0

calc_contract_cost

nomask int calc_contract_cost(object sucker)

Calculate how much the guild will charge for a contract on this player. This is based on guild level and anti-inhumation skills. This figure will then be massaged by validate_contract.

Parameters:
sucker - the player object to calculate the cost for.

calc_place

nomask varargs string calc_place(object player)

This is used to pass in a location to the money handler.

Returns:
The region for this handler, or "default" if it cannot be determined

calc_protection_cost

nomask int calc_protection_cost(object wimp,
                                int duration)

Figure out the protection cost for a given player for a given number of days.

Parameters:
wimp - The player object to check
duration - The number of days to check the cost for

Returns:
The cost, in brass coins

can_close_players

nomask int can_close_players(string who)

Determine whether or not a given player is allowed to view or close PK contracts. This is determined by age, guild level, number of (NPC) contracts closed, and whether or not the player handler says the assassin is active.

Parameters:
who - the name of the player to check.

Returns:
1 if they are allowed to handle PKs, 0 otherwise.

can_place_family_contract

nomask int can_place_family_contract(object sucker,
                                     int nolife)

This checks whether a family contract can be placed on a player.

Parameters:
sucker - The player (object) being contracted.
nolife - 1 if the contract should not take a life.

Returns:
0 if the contract cannot be placed or the cost of the contract which should be subtracted from the family's coffers.

cannot_be_inhumed

mixed cannot_be_inhumed(string sucker)

If the sucker cannot be inhumed return a reason. The sucker cannot be inhumed if they have a contract in any book, if they have recently been contracted at any of the specialisations, if they have paid insurance with this specialisation or if they have been granted protection by the GM of this specialisation.

Parameters:
sucker - the name of the player to check

Returns:
The reason why the player cannot be inhumed

check_cannot_close

nomask int check_cannot_close(string who)

Check whether someone has been marked as not allowed to close contracts. This function is access-controlled.

Parameters:
who - Player's name

Returns:
1 if they are not allowed to place contracts, 0 otherwise.

check_cannot_place

nomask int check_cannot_place(string who)

Check whether someone has been marked as not allowed to place contracts. This function is access-controlled.

Parameters:
who - Player's name

Returns:
1 if they are not allowed to place contracts, 0 otherwise.

check_expired

nomask int check_expired(string who)

Check whether someone is in the _expired mapping.

Parameters:
who - Player's name

Returns:
1 if they are in it, 0 otherwise.

check_sacrosanct

nomask mixed check_sacrosanct(string who)

Check whether someone has been marked as not allowed to be inhumed. This function is access-controlled.

Parameters:
who - Player's name

Returns:
The reason if they are not allowed to be inhumed, 0 otherwise.

clear_cannot_close

nomask int clear_cannot_close(string who)

Admin function to allow player to close contracts again. This function is access-controlled.

Parameters:
who - the name of the player to unban

Returns:
1 if successful, 0 otherwise.

clear_cannot_place

nomask int clear_cannot_place(string who)

Admin function to allow player to place contracts again. This function is access-controlled.

Parameters:
who - the name of the player to unban

Returns:
1 if successful, 0 otherwise.

clear_collect

nomask void clear_collect(string player)

Remove the collection entry for a player. This function is access-controlled.

Parameters:
player - The name of the player

clear_contract

nomask void clear_contract(string player)

Remove a contract for the given player/npc. Does not return any money if it's active -- use expire_contract if that's what you want to do. This function is access-controlled.

Parameters:
player - The name of the player

clear_expired

nomask int clear_expired(string who)

This function clears someone from the _expired mapping.

Parameters:
who - the name of the player to remove

Returns:
1 if successful, 0 otherwise.

clear_npc_inhumed

nomask int clear_npc_inhumed(string name)

Clear the last inhumed entry for an NPC. This function is access controlled.

Parameters:
who - the name of the NPC to clear.

Returns:
1 if successful, 0 otherwise.

clear_oneshot_npc_contract

nomask int clear_oneshot_npc_contract(object source,
                                      string sucker,
                                      int value)

Code to add one-shot NPC contracts.

clear_sacrosanct

nomask varargs int clear_sacrosanct(string who,
                                    int remove_all)

Admin function to clear a sacrosanct mapping entry. This function is access-controlled.

Parameters:
who - the name of the player to clear
remove_all - 1 if records should be removed from all the handlers.

Returns:
1 if successful, 0 otherwise.

collect_payment

nomask string collect_payment(object collector)

Handle the payment of wages for inhumations performed. This also handles returning the cash in the event of an expired contract.

Parameters:
collector - The player object doing the collecting

Returns:
The success/fail message

collect_type

nomask int collect_type(string who)

Figure out whether the given person has refunds, payments, or both waiting for them.

Parameters:
who - The name of the person to check.

Returns:
An integer code.

convert_message

varargs string convert_message(string mess,
                               string suck,
                               string bast,
                               string amt,
                               string extra)

convert_old_contracts

nomask void convert_old_contracts(string reason)

Used to convert the older existing contracts whenever the contract class changes. Always add data members at the end, and they should be initialized within convert_contract().

Parameters:
reason - A note to go into the log file of why the contracts are being updated.

cost_inform_callback

void cost_inform_callback(string p_name,
                          string type)

Called by the login handler. This sets up the validation and inform processes. Do not call this function unless you really know what you're doing. This means you.

Parameters:
p_name - The name of the player who is entering Discworld
type - The login type, one of login, logout, netdeath, or reconnect

delayed_contract

nomask void delayed_contract(string sucker)

A player has logged in after a contract was requested. Validate it and inform the bastard who requested it.

Parameters:
sucker - The player who is contracted

delete_benefactor

void delete_benefactor(string benefactor)

delete_enforcer

nomask int delete_enforcer(string name)

Remove a player from the list of Guild Enforcers. Returns 0 if they're not an enforcer to begin with, 1 if they were successfully deleted from the enforcer array. This function is access-controlled.

Parameters:
name - The name of the player to remove

Returns:
1 or 0 as above

delete_sacrosanct

void delete_sacrosanct(string who)

deposit_value_in_coffer

nomask int deposit_value_in_coffer(int amt)

Add some money into the guild coffers. This function is access-controlled.

Parameters:
amt - Amount of money, in base (brass coin) units.

Returns:
The new amount in the coffer.

donate_money

nomask string donate_money(object philanthropist,
                           mixed m_array,
                           string place)

This function interfaces directly with the secretaries, like pay_for_contract and new_contract. It pays a certain amount of money directly into the coffers. This function is access-controlled.

Parameters:
philanthropist - the player object doing the donating
value - how much money
place - what currency it's being paid in

Returns:
A string for the secretary to say.

entering

void entering(string p_name,
              string type)

Called by the login handler. This sets up the validation and inform processes. Do not call this function unless you really know what you're doing. This means you.

Parameters:
p_name - The name of the player who is entering Discworld
type - The login type, one of login, logout, netdeath, or reconnect

expire_contract

nomask void expire_contract(string sucker)

This function is used to expire a contract. This will remove it from the books, and if it is active, return the money to the bastard who paid for it. (note that this is not necessarily the person who requested it) This function is access-controlled.

Parameters:
sucker - Which contract to expire

finish_up

nomask void finish_up(string str,
                      string message,
                      string sucker)

Get the text of the message, and store it in the contract info.

Parameters:
message - The contents of the message
sucker - The name of the contracted player
str - The input to be parsed for yes/no

get_benefactor_list

string * get_benefactor_list()

Get an ordered list of benefactors.

Returns:
A list of benefactors ordered according to the amount donated (highest first).

get_message_text

nomask void get_message_text(string message,
                             string sucker)

Get the text of the message, and then pass it on to finish_up.

Parameters:
message - The contents of the message
sucker - The name of the contracted player

has_coded_protection

int has_coded_protection(string sucker)

If the sucker cannot be inhumed due to having a contract or having been recently contracted then return 1.

Parameters:
sucker - the name of the player to check

Returns:
1 if they have coded protection 0 if not.

inform_cost

nomask void inform_cost(string sucker)

Inform the contractor of the cost of the contract and ask them to go pay up if it was accepted, or tell them why it was rejected.

Parameters:
sucker - The target player's name

inform_customer

nomask void inform_customer(string bastard)

Send a message off to someone who has had at least one contract closed for them recently.

Parameters:
bastard - The name of the player to inform.

initialise_handler

void initialise_handler(string _region)

list_cannot_close

nomask mapping list_cannot_close()

Query the entire cannot_close mapping. This function is access-controlled.

Returns:
the cannot_close mapping.

list_cannot_place

nomask mapping list_cannot_place()

Query the entire cannot_place mapping. This function is access-controlled.

Returns:
the cannot_place mapping.

list_contractable_npcs

nomask string list_contractable_npcs(string place)

Give a nicely formatted table of NPCs that you can request contracts on, and prices.

Parameters:
place - the money area to calculate prices for.

Returns:
the formatted table as a string.

list_enforcers

nomask string list_enforcers()

Get a nice formatted string containing the names of the Guild Enforcers. This function is access-controlled.

Returns:
The formatted string

list_expired

nomask mapping list_expired()

Query the entire _expired mapping.

Returns:
the cannot_place mapping.

list_sacrosanct

nomask mapping list_sacrosanct()

Query the entire sacrosanct mapping. This function is access-controlled.

Returns:
the sacrosanct mapping.

load_file

nomask void load_file()

log_file

varargs void log_file(string name,
                      string fmt,
                      mixed * args ...)

make_receipt

nomask void make_receipt(object corpse,
                         string name)

This is the code that makes the receipt that's left on the bodies of inhumed victims. NPC targets don't get a receipt.

Parameters:
corpse - The corpse object into which the card should be moved
name - The name of the person who was just inhumed

modify_contract_cost

int modify_contract_cost(object sucker,
                         int cost)

new_contract

nomask string new_contract(object bastard,
                           string sucker,
                           int nodeath)

Setup a new contract. Do some rudimentary checks and then wait until the sucker logs in. Things are continued by delayed_contract.

Parameters:
bastard - The person requesting the contract
sucker - The person it's being requested on

Returns:
A string describing the status of the contract

ok_to_contract_npc

nomask int ok_to_contract_npc(string name)

Figure out if it's ok to place a contract on this NPC yet.

Parameters:
name - the name of the NPC to check.

Returns:
1 if it's ok, 0 oterwise.

oneshot_npc_contract

nomask int oneshot_npc_contract(object source,
                                string sucker,
                                int value)

Code to add one-shot NPC contracts.

pay_for_contract

nomask string pay_for_contract(string sucker,
                               object bastard)

Setup a validated contract. If you have not requested the contract, but you are PK and have enough money on you, you are allowed to pay.

Parameters:
sucker - The person whose contract is being paid for
bastard - The player object doing the paying.

Returns:
A success/fail message

pay_protection_money

nomask string pay_protection_money(object wimp,
                                   int duration)

This function interfaces directly with the secretaries, like pay_for_contract and new_contract. It pays a certain amount of money into the protection account for the player, a portion of that money going to the guild coffers. This function is access-controlled.

Parameters:
wimp - The player object requesting protection
amt - How much to pay (in brass coins)
duration - The length of time (in days) the protection will be active.

Returns:
A string for the secretary to say.

place_family_contract

nomask int place_family_contract(object sucker,
                                 int nodeath,
                                 string message)

This places the family contract.

Parameters:
sucker - The player (object) to be contracted.
nodeath - 1 if the contract should not take a life.
message - The message that should appear on the sucker's inhume card.

Returns:
1 if successful

player_deleted

nomask void player_deleted(mixed player,
                           int totally)

This is called by the refresh handler when a player deletes. I can't think of any reason why you would ever need to call this on your own, though, so you probably shouldn't.

Parameters:
player - The player object/name
totally - Int flag. 1 if the refresh was total, 0 if partial. Not used.

player_refreshed

nomask varargs void player_refreshed(mixed player,
                                     int totally,
                                     int deleted)

This is called by the refresh handler when a player refreshes. I can't think of any reason why you would ever need to call this on your own, though, so you probably shouldn't.

Parameters:
player - The player object/name
totally - Int flag. 1 if the refresh was total, 0 if partial. Not used.
deleted - Set to 1 if the player deleted instead of just refreshing.

query_active_handler

int query_active_handler()

query_all_contracts

nomask string query_all_contracts()

Return a list of all the current contracts. Creators get a more thorough rundown of information, including times and requestors' names. Players only see Active and Informed contracts, and if they're Guild Enforcers, they see Special contracts as well. This function is access-controlled.

Parameters:
display_players - set to 1 if we are displaying player contracts.

Returns:
A formatted string containing the contract listings

query_all_messages

nomask string query_all_messages()

Get a list of all currently-active messages. This function is access-controlled.

Returns:
the formatted string

query_allowed_to_access

string * query_allowed_to_access()

query_benefactors

mapping query_benefactors()

query_coffer

nomask int query_coffer()

Check how much money is in the Guild coffers. This function is access-controlled.

Returns:
Amount of money, in base (brass coin) units.

query_contract

nomask int query_contract(string who)

Admin function to check the status of a contract

Parameters:
who - Player's name

Returns:
The status of the contract, as defined in

query_contract_date

nomask int query_contract_date(string who)

Admin function to check the date of a contract. This is the last time when progress was made, so it changes as the contract is validated, accepted, and paid for.

Parameters:
who - Player's name

Returns:
The date, in integer format

query_contract_info

nomask string query_contract_info(string who)

Admin function to check the details of a contract. This returns a nicely formatted string detailing the contract's specifics. This function is access-controlled.

Parameters:
who - Player's name

Returns:
The formatted string

query_contract_nodeath

nomask int query_contract_nodeath(string who)

Admin function to check whether a contract is of the no-loss-of-life variety.

Parameters:
who - Player's name

Returns:
0 if it's a 'normal' contract, 1 if the target won't lose a life.

query_contract_value

nomask int query_contract_value(string who)

Admin function to check the value of a contract.

Parameters:
who - Player's name

Returns:
The value in monetary units

query_contracts_by

nomask string * query_contracts_by(string player)

This method returns a list of all the people that this person has put a contract on. This function is access-controlled.

Parameters:
bastard - the person who placed the contract

Returns:
the list of contracts they placed

query_contracts_in_state

nomask string * query_contracts_in_state(int status)

This method returns a list of all the people that have a contract in a given status.

Parameters:
state - The status of the contracts to list.

Returns:
the list of contracts in that state.

query_enforcer

nomask int query_enforcer(string pname)

Check if a given player is a Guild Enforcer. This function is access-controlled.

Parameters:
pname - The name of the assassin to query

Returns:
1 if they are a Guild Enforcer, 0 if not.

query_enforcers

nomask string * query_enforcers()

List all Guild Enforcers. This function is access-controlled.

Returns:
The array of enforcers' names

query_inhume_record

nomask mapping query_inhume_record(string assassin)

Parameters:
assassin - The name of the assassin to query

Returns:
A record of the assassin's inhumes, in the format (["name":val])

query_npc_contract

nomask class npc_contract query_npc_contract(string name)

Get the information for an NPC contract.

Parameters:
name - The name of the NPC to query.

Returns:
a 2-element array of the form ({ short, value (in AM dollars) }).

query_npc_contracts

nomask mapping query_npc_contracts()

List all the possible NPC contracts.

Returns:
a mapping with all the NPC contract information in it.

query_npc_time

nomask int query_npc_time(string name)

Report the timestmp of this NPC's last inhumation.

Parameters:
name - the name of he NPC to check.

Returns:
0 if the NPC is not in the list, or the time.

query_offenses

nomask string query_offenses(string player)

Return a nicely formatted list thingie of a person's offenses for their Special contract.

Parameters:
player - The name of the player

Returns:
The formatted result string

query_payments

nomask string query_payments(object who)

If the calling object is a cre, this will return a complete listing of payments due. Otherwise it will only return what payments are due to the calling player. This function is access-controlled - if you are not on the authorized list you will not see everyone's collection info.

Returns:
a formatted list of all the outstanding collections.

query_requested_or_paid

nomask int query_requested_or_paid(string sucker,
                                   string bastard)

Check whether the bastard requested or paid for the contract on the sucker. This function is access-controlled.

Parameters:
sucker - The contract in question
bastard - The person to check for involvement

Returns:
-1 if there is no contract on sucker, 0 if bastard is not involved, 1 if they are.

query_special_contracts

nomask string * query_special_contracts()

Get a listing of all Special contracts.

Returns:
An array of names

query_times_killed

nomask int query_times_killed(string killer,
                              string sucker)

How many times has the assassin inhumed a particular victim?

Parameters:
killer - The name of the assassin
sucker - The name of the victim

Returns:
The number of times killer has inhumed victim

remove_npc_contract

nomask int remove_npc_contract(string name)

Remove an NPC from the mapping of inhumable targets. This function is access-controlled.

Parameters:
name - The NPC's set_name

Returns:
0 if name is 0 or there's no NPC on file with that set_name, 1 if successful.

request_npc_contract

nomask string request_npc_contract(object bastard,
                                   string sucker)

Internal function for requesting an NPC contract.

Parameters:
bastard - the player object doing the requesting.
sucker - who to request the contract on.

Returns:
a string for the secretary to say back to you.

save_file

nomask void save_file()

set_already_contracted

void set_already_contracted(string temp)

set_am_allowed

void set_am_allowed(int allowed)

set_amount_string_guild

void set_amount_string_guild(string temp)

set_amount_string_nonguild

void set_amount_string_nonguild(string temp)

set_can_not_accept

void set_can_not_accept(string temp)

set_cancel_contract_message

void set_cancel_contract_message(string mess)

set_card_desc

void set_card_desc(string temp)

set_card_lang

void set_card_lang(string temp)

set_card_path

void set_card_path(string temp)

set_collecting_wages

void set_collecting_wages(string temp)

set_completed_multiple_contract

void set_completed_multiple_contract(string temp)

set_completed_single_contract

void set_completed_single_contract(string temp)

set_contract_bastard

nomask void set_contract_bastard(string sucker,
                                 string bastard,
                                 string reason)

Admin function to change the current bastard of the contract. This function is access-controlled.

Parameters:
sucker - The target of the contract
bastard - The name to change the bastard of record to
reason - Reason for changing the bastard (this is mandatory)

set_contract_nodeath

nomask int set_contract_nodeath(string sucker,
                                int nodeath)

set_contract_pending

void set_contract_pending(string temp)

set_contract_status

int set_contract_status(string who,
                        int status)

Sets the status of a contract. Use this with caution, as you can really bugger things up if you don't know what you're doing.

Parameters:
who - Who the contract is on.
status - The new status.

Returns:
The new status of the contract, or a negative error code.

set_currency

void set_currency(string temp)

set_cwc_allowed

void set_cwc_allowed(int allowed)

set_donate_negative

void set_donate_negative(string temp)

set_donate_thanks

void set_donate_thanks(string temp)

set_genua_allowed

void set_genua_allowed(int allowed)

set_guild_name

void set_guild_name(string mess)

set_guild_plural

void set_guild_plural(string mess)

set_inform

void set_inform(string temp)

set_insurance_terms

void set_insurance_terms(string temp)

set_klatch_allowed

void set_klatch_allowed(int allowed)

set_new_contract

void set_new_contract(string temp)

set_no_contract

void set_no_contract(string temp)

set_no_payments

void set_no_payments(string temp)

set_non_killer

void set_non_killer(string temp)

set_not_allowed

void set_not_allowed(string temp)

set_not_pk

void set_not_pk(string temp)

set_not_same_guild

void set_not_same_guild(string temp)

set_not_yourself

void set_not_yourself(string temp)

set_npc_auto_flag

int set_npc_auto_flag(string name,
                      int val)

Set the automatic flag for an NPC contract. Any value != 0 will be interpreted as 1. This funtion is access controlled.

Parameters:
name - the NPC's name to alter.
val - The new value for the flag.

Returns:
-1 if that npc is not in the books, 0 if the flag was already set to that value, 1 if it was changed.

set_paid_with_surcharge

void set_paid_with_surcharge(string temp)

set_paid_without_surcharge

void set_paid_without_surcharge(string temp)

set_receipt_close

void set_receipt_close(string temp)

set_receipt_normal

void set_receipt_normal(string temp)

set_secretary_title

void set_secretary_title(string mess)

set_too_soon

void set_too_soon(string temp)

set_unable_to_complete

void set_unable_to_complete(string temp)

set_wages_and_refunds

void set_wages_and_refunds(string temp)

someone_inhumed

nomask varargs void someone_inhumed(object sucker,
                                    object killer,
                                    int nocorpse)

Called every time someone is inhumed, by the inhume command. It sets up collection mappings as appropriate, and also updates inhume records and last_inhumed entries. Removes the contract from the books.

Parameters:
sucker - The poor sap who was just inhumed.
killer - Guess.

special_contract_table

nomask string special_contract_table()

Get a nicely-formatted, sorted, columnar table of special contracts.

Returns:
The sorted table of names

submit_message

nomask void submit_message(string sucker)

Called when a player decides to submit a message annotation to a contract. Collects some input and then calls get_message_text to continue.

tidy_up

nomask void tidy_up()

This is the bookkeeping function. It handles expiring old contracts and collections, as well as adding periodic NPC contracts. Please don't call this function unless you know exactly what it does.

verify_data

void verify_data()

Classes

• collect

  class collect {
                  class collect_entry * entries;
  }
  
  

  
  The collect mapping contains all the pending payments to assassins, or refunds to requestors where the contract has timed out.

  Members:
  entries - The array of collect_entry classes.
  

• collect_entry

  class collect_entry {
                        string target;
                        int refund;
                        int value;
                        int time;
  }
  
  

  
  This class keeps track of a single payment (or refund)

  Members:
  target - The name of the person who was under contract
  
  refund - 0 if this is a normal payment, 1 if it is a refund
  
  value - The value of the contract in units (4 units = 1 AM pence)
  
  time - When the contract was closed/expired
  

• npc_contract

  class npc_contract {
                       string short;
                       int value;
                       int auto;
  }
  
  

  
  This is the class that keeps track of possible NPC contracts. It's added into the npc_contracts mapping with the npc's set_name as a key.

  Members:
  short - The NPC's properly capitalized short, used for display.
  
  value - The value of the contract in monetary units.
  
  auto - Whether or not this contract is a candidate for automatic generation (not funded by insurance). 1 or 0.