/**************************************************************************
*  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
*  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
*                                                                         *
*  Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael         *
*  Chastain, Michael Quan, and Mitchell Tse.                              *
*                                                                         *
*  In order to use any part of this Merc Diku Mud, you must comply with   *
*  both the original Diku license in 'license.doc' as well the Merc       *
*  license in 'license.txt'.  In particular, you may not remove either of *
*  these copyright notices.                                               *
*                                                                         *
*  Much time and thought has gone into this software and you are          *
*  benefiting.  We hope that you share your changes too.  What goes       *
*  around, comes around.                                                  *
***************************************************************************
*       ROM 2.4 is copyright 1993-1998 Russ Taylor                        *
*       ROM has been brought to you by the ROM consortium                 *
*           Russ Taylor (rtaylor@hypercube.org)                           *
*           Gabrielle Taylor (gtaylor@hypercube.org)                      *
*           Brian Moore (zump@rom.org)                                    *
*       By using this code, you have agreed to follow the terms of the    *
*       ROM license, in the file Rom24/doc/rom.license                    *
***************************************************************************
*       1stMUD ROM Derivative (c) 2001-2003 by Ryan Jennings              *
*            http://1stmud.dlmud.com/  <r-jenn@shaw.ca>                   *
***************************************************************************/
/*
 * Our function prototypes.
 * One big lump ... this is almost every function in 1stMUD.
 */

#if !defined(PROTOTYPE_H)
#define PROTOTYPE_H

#if !defined(__GNUC__)
#define __attribute__(x)		/* nothing */
#endif

#define PROTOTYPE(x,y) EXTERN x y
#define PROTOTYPEF(x,y,a,b) EXTERN x y __attribute__((format(printf, a, b)))

/* act_comm.c */
PROTOTYPE(void check_sex, (CHAR_DATA *));
PROTOTYPE(void add_follower, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(void stop_follower, (CHAR_DATA *));
PROTOTYPE(void nuke_pets, (CHAR_DATA *));
PROTOTYPE(void die_follower, (CHAR_DATA *));
PROTOTYPE(bool is_same_group, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(int colour_lookup, (const char *));
PROTOTYPE(int cslot_lookup, (const char *));
PROTOTYPE(const char *char_colour, (CHAR_DATA *, int));
PROTOTYPE(void default_colour, (CHAR_DATA *, int));
PROTOTYPE(bool check_cstring, (char *));
PROTOTYPE(char *random_colour, (void));
PROTOTYPE(char *random_background, (void));
PROTOTYPE(void show_greeting, (DESCRIPTOR_DATA *));
PROTOTYPE(bool process_ansi_output, (DESCRIPTOR_DATA *));
PROTOTYPE(const char *color_default, (CHAR_DATA *));

PROTOTYPE(const char *color_to_tilde, (const char *));
PROTOTYPE(const char *tilde_to_color, (const char *));
PROTOTYPE(unsigned int strlen_color, (const char *));
PROTOTYPE(const char *draw_line, (CHAR_DATA *, char *, int));
PROTOTYPE(const char *smash_colour, (const char *));
PROTOTYPE(const char *stringf, (CHAR_DATA *, int, int, const char *,
								const char *));
PROTOTYPE(bool is_ansi_printed_char, (char));

PROTOTYPE(void public_ch, (CHAR_DATA *, const char *, int));

/* act_enter.c */
PROTOTYPE(ROOM_INDEX_DATA * get_random_room, (CHAR_DATA *));

/* act_info.c */
PROTOTYPE(void set_title, (CHAR_DATA *, const char *));
PROTOTYPE(char *format_who, (CHAR_DATA *, CHAR_DATA *));

/* act_move.c */
PROTOTYPE(void move_char, (CHAR_DATA *, int, bool));

/* act_obj.c */
PROTOTYPE(bool can_loot, (CHAR_DATA *, OBJ_DATA *));
PROTOTYPE(void wear_obj, (CHAR_DATA *, OBJ_DATA *, bool));
PROTOTYPE(void get_obj, (CHAR_DATA *, OBJ_DATA *, OBJ_DATA *));
PROTOTYPE(void recursive_clone, (CHAR_DATA *, OBJ_DATA *, OBJ_DATA *));
PROTOTYPE(bool obj_check, (CHAR_DATA *, OBJ_DATA *));

/* act_wiz.c */
PROTOTYPEF(void new_wiznet, (CHAR_DATA *, OBJ_DATA *, flag_t,
							 flag_t, int, const char *, ...), 6, 7);

#if !defined(NO_COPYOVER)
PROTOTYPE(void copyover_recover, (void));
PROTOTYPE(void copyover, (void));
#endif

/* alias.c */
PROTOTYPE(void substitute_alias, (DESCRIPTOR_DATA *, char *));

/* ban.c */
PROTOTYPE(bool check_ban, (const char *, int));
PROTOTYPE(void ban_site, (CHAR_DATA *, const char *));

/* comm.c */
PROTOTYPE(void show_string, (DESCRIPTOR_DATA *, char *));
PROTOTYPE(void close_socket, (DESCRIPTOR_DATA *));
PROTOTYPE(void d_print, (DESCRIPTOR_DATA *, const char *, int));
PROTOTYPE(void d_println, (DESCRIPTOR_DATA *, const char *, int));
PROTOTYPEF(void d_printf, (DESCRIPTOR_DATA *, const char *, ...), 2, 3);
PROTOTYPEF(void d_printlnf, (DESCRIPTOR_DATA *, const char *, ...), 2, 3);
PROTOTYPE(void chprint, (CHAR_DATA *, const char *));
PROTOTYPE(void chprintln, (CHAR_DATA *, const char *));
PROTOTYPE(void sendpage, (CHAR_DATA *, const char *));
PROTOTYPE(void act_new, (const char *, CHAR_DATA *, const void *,
						 const void *, flag_t, position_t));
PROTOTYPE(void perform_act, (const char *, CHAR_DATA *, const void *,
							 const void *, flag_t, CHAR_DATA *));
PROTOTYPE(const char *perform_act_string,
		  (const char *, CHAR_DATA *, const void *, const void *, bool));

PROTOTYPEF(void chprintf, (CHAR_DATA *, const char *, ...), 2, 3);
PROTOTYPEF(void chprintlnf, (CHAR_DATA *, const char *, ...), 2, 3);
PROTOTYPEF(void bugf, (const char *, ...), 1, 2);
PROTOTYPE(void fix_sex, (CHAR_DATA *));
PROTOTYPEF(void logf, (const char *, ...), 1, 2);
PROTOTYPEF(void vinterpret, (CHAR_DATA *, const char *, ...), 2, 3);
PROTOTYPEF(int strswitch, (const char *, ...), 1, 2);

/* db.c */
PROTOTYPE(void reset_area, (AREA_DATA *));	/* OLC */
PROTOTYPE(void reset_room, (ROOM_INDEX_DATA *));	/* OLC */
PROTOTYPE(char *fwrite_flags, (flag_t));
PROTOTYPE(void boot_db, (void));
PROTOTYPE(void area_update, (void));
PROTOTYPE(CHAR_DATA * create_mobile, (MOB_INDEX_DATA *));
PROTOTYPE(void clone_mobile, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(OBJ_DATA * create_object, (OBJ_INDEX_DATA *, int));
PROTOTYPE(void clone_object, (OBJ_DATA *, OBJ_DATA *));
PROTOTYPE(void clear_char, (CHAR_DATA *));
PROTOTYPE(const char *get_extra_descr, (const char *, EXTRA_DESCR_DATA *));
PROTOTYPE(MOB_INDEX_DATA * get_mob_index, (vnum_t));
PROTOTYPE(OBJ_INDEX_DATA * get_obj_index, (vnum_t));
PROTOTYPE(ROOM_INDEX_DATA * get_room_index, (vnum_t));
PROTOTYPE(PROG_CODE * get_prog_index, (vnum_t, prog_t));

PROTOTYPE(char fread_letter, (FILE *));
PROTOTYPE(int fread_number, (FILE *));
PROTOTYPE(flag_t fread_flag, (FILE *));
PROTOTYPE(const char *fread_string, (FILE *));
PROTOTYPE(const char *fread_line, (FILE *));
PROTOTYPE(const char *fread_file, (FILE *));
PROTOTYPE(void fread_to_eol, (FILE *));
PROTOTYPE(char *fread_word, (FILE *));

PROTOTYPE(char read_letter, (READ_DATA *));
PROTOTYPE(int read_number, (READ_DATA *));
PROTOTYPE(flag_t read_flag, (READ_DATA *));
PROTOTYPE(const char *read_string, (READ_DATA *));
PROTOTYPE(const char *read_line, (READ_DATA *));
PROTOTYPE(void read_to_eol, (READ_DATA *));
PROTOTYPE(char *read_word, (READ_DATA *));

PROTOTYPE(flag_t flag_convert, (char));
PROTOTYPE(const char *str_dup, (const char *));
PROTOTYPE(void _free_string, (const char *));
PROTOTYPE(int number_fuzzy, (int));
PROTOTYPE(int number_fuzzier, (int));
PROTOTYPE(int number_range, (int, int));
PROTOTYPE(int number_percent, (void));
PROTOTYPE(int number_door, (void));
PROTOTYPE(int number_bits, (int));
PROTOTYPE(long number_mm, (void));
PROTOTYPE(int dice, (int, int));
PROTOTYPE(int interpolate, (int, int, int));
PROTOTYPE(void smash_tilde, (const char *));
PROTOTYPE(int str_cmp, (const char *, const char *));
PROTOTYPE(int str_casecmp, (const char *, const char *));
PROTOTYPE(int str_ncmp, (const char *, const char *, size_t));
PROTOTYPE(int str_ncasecmp, (const char *, const char *, size_t));
PROTOTYPE(bool str_prefix, (const char *, const char *));
PROTOTYPE(bool str_infix, (const char *, const char *));
PROTOTYPE(bool str_suffix, (const char *, const char *));
PROTOTYPE(char *capitalize, (const char *));
PROTOTYPE(void append_file, (CHAR_DATA *, char *, const char *));
PROTOTYPE(void bug, (const char *));
PROTOTYPE(void log_string, (const char *));
PROTOTYPE(void tail_chain, (void));
PROTOTYPE(void new_reset, (ROOM_INDEX_DATA *, RESET_DATA *));

/* db2.c */
PROTOTYPE(void load_mobiles, (READ_DATA *));
PROTOTYPE(void load_objects, (READ_DATA *));
PROTOTYPE(FILE * file_open, (const char *, const char *));
PROTOTYPE(void file_close, (FILE *));
PROTOTYPE(void free_runbuf, (DESCRIPTOR_DATA *));
PROTOTYPEF(WRITE_DATA * open_write, (const char *,...), 1, 2);
PROTOTYPE(void close_write, (WRITE_DATA *));
PROTOTYPEF(READ_DATA * open_read, (const char *path,...), 1, 2);
PROTOTYPE(void close_read, (READ_DATA *));
PROTOTYPEF(WRITE_DATA * open_append, (const char *,...), 1, 2);
PROTOTYPE(void close_append, (WRITE_DATA *));

/* effect.c */
PROTOTYPE(void acid_effect, (void *, int, int, int));
PROTOTYPE(void cold_effect, (void *, int, int, int));
PROTOTYPE(void fire_effect, (void *, int, int, int));
PROTOTYPE(void poison_effect, (void *, int, int, int));
PROTOTYPE(void shock_effect, (void *, int, int, int));

/* fight.c */
PROTOTYPE(bool is_safe, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(bool is_safe_spell, (CHAR_DATA *, CHAR_DATA *, bool));
PROTOTYPE(void violence_update, (void));
PROTOTYPE(void multi_hit, (CHAR_DATA *, CHAR_DATA *, int));
PROTOTYPE(bool damage, (CHAR_DATA *, CHAR_DATA *, int, int, int, bool));
PROTOTYPE(void update_pos, (CHAR_DATA *));
PROTOTYPE(void stop_fighting, (CHAR_DATA *, bool));
PROTOTYPE(void check_killer, (CHAR_DATA *, CHAR_DATA *));

/* handler.c */
PROTOTYPE(AFFECT_DATA * affect_find, (AFFECT_DATA *, int));
PROTOTYPE(void affect_check, (CHAR_DATA *, int, flag_t));
PROTOTYPE(int count_users, (OBJ_DATA *));
PROTOTYPE(void deduct_cost, (CHAR_DATA *, int));
PROTOTYPE(void affect_enchant, (OBJ_DATA *));
PROTOTYPE(int check_immune, (CHAR_DATA *, int));
PROTOTYPE(int material_lookup, (const char *));
PROTOTYPE(int weapon_lookup, (const char *));
PROTOTYPE(int weapon_typ, (const char *));
PROTOTYPE(const char *weapon_name, (int));
PROTOTYPE(const char *item_name, (int));
PROTOTYPE(int attack_lookup, (const char *));
PROTOTYPE(int wiznet_lookup, (const char *));
PROTOTYPE(int class_lookup, (const char *));
PROTOTYPE(bool is_clan, (CHAR_DATA *));
PROTOTYPE(bool is_same_clan, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(bool is_old_mob, (CHAR_DATA *));
PROTOTYPE(int get_skill, (CHAR_DATA *, int));
PROTOTYPE(int get_weapon_sn, (CHAR_DATA *));
PROTOTYPE(int get_weapon_skill, (CHAR_DATA *, int));
PROTOTYPE(int get_age, (CHAR_DATA *));
PROTOTYPE(void reset_char, (CHAR_DATA *));
PROTOTYPE(int get_trust, (CHAR_DATA *));
PROTOTYPE(int get_curr_stat, (CHAR_DATA *, int));
PROTOTYPE(int get_max_train, (CHAR_DATA *, int));
PROTOTYPE(int can_carry_n, (CHAR_DATA *));
PROTOTYPE(int can_carry_w, (CHAR_DATA *));
PROTOTYPE(bool is_name, (const char *, const char *));
PROTOTYPE(bool is_exact_name, (const char *, const char *));
PROTOTYPE(void affect_to_char, (CHAR_DATA *, AFFECT_DATA *));
PROTOTYPE(void affect_to_obj, (OBJ_DATA *, AFFECT_DATA *));
PROTOTYPE(void affect_remove, (CHAR_DATA *, AFFECT_DATA *));
PROTOTYPE(void affect_remove_obj, (OBJ_DATA *, AFFECT_DATA *));
PROTOTYPE(void affect_strip, (CHAR_DATA *, int));
PROTOTYPE(bool is_affected, (CHAR_DATA *, int));
PROTOTYPE(void affect_join, (CHAR_DATA *, AFFECT_DATA *));
PROTOTYPE(void char_from_room, (CHAR_DATA *));
PROTOTYPE(void char_to_room, (CHAR_DATA *, ROOM_INDEX_DATA *));
PROTOTYPE(void obj_to_char, (OBJ_DATA *, CHAR_DATA *));
PROTOTYPE(void obj_from_char, (OBJ_DATA *));
PROTOTYPE(int apply_ac, (OBJ_DATA *, wloc_t, int));
PROTOTYPE(OBJ_DATA * get_eq_char, (CHAR_DATA *, wloc_t));
PROTOTYPE(void equip_char, (CHAR_DATA *, OBJ_DATA *, wloc_t));
PROTOTYPE(void unequip_char, (CHAR_DATA *, OBJ_DATA *));
PROTOTYPE(int count_obj_list, (OBJ_INDEX_DATA *, OBJ_DATA *));
PROTOTYPE(void obj_from_room, (OBJ_DATA *));
PROTOTYPE(void obj_to_room, (OBJ_DATA *, ROOM_INDEX_DATA *));
PROTOTYPE(void obj_to_obj, (OBJ_DATA *, OBJ_DATA *));
PROTOTYPE(void obj_from_obj, (OBJ_DATA *));
PROTOTYPE(void extract_obj, (OBJ_DATA *));
PROTOTYPE(void extract_char, (CHAR_DATA *, bool));
PROTOTYPE(CHAR_DATA * get_char_room,
		  (CHAR_DATA *, ROOM_INDEX_DATA *, const char *));
PROTOTYPE(CHAR_DATA * get_char_world, (CHAR_DATA *, const char *));
PROTOTYPE(OBJ_DATA * get_obj_type, (OBJ_INDEX_DATA *));
PROTOTYPE(OBJ_DATA * get_obj_list, (CHAR_DATA *, const char *, OBJ_DATA *));
PROTOTYPE(OBJ_DATA * get_obj_carry, (CHAR_DATA *, const char *, CHAR_DATA *));
PROTOTYPE(OBJ_DATA * get_obj_wear, (CHAR_DATA *, const char *, bool));
PROTOTYPE(OBJ_DATA * get_obj_here,
		  (CHAR_DATA *, ROOM_INDEX_DATA *, const char *));
PROTOTYPE(OBJ_DATA * get_obj_world, (CHAR_DATA *, const char *));
PROTOTYPE(OBJ_DATA * create_money, (int, int));
PROTOTYPE(int get_obj_number, (OBJ_DATA *));
PROTOTYPE(int get_obj_weight, (OBJ_DATA *));
PROTOTYPE(int get_true_weight, (OBJ_DATA *));
PROTOTYPE(bool room_is_dark, (ROOM_INDEX_DATA *));
PROTOTYPE(bool is_room_owner, (CHAR_DATA *, ROOM_INDEX_DATA *));
PROTOTYPE(bool room_is_private, (ROOM_INDEX_DATA *));
PROTOTYPE(bool can_see, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(bool can_see_obj, (CHAR_DATA *, OBJ_DATA *));
PROTOTYPE(bool can_see_room, (CHAR_DATA *, ROOM_INDEX_DATA *));
PROTOTYPE(bool can_drop_obj, (CHAR_DATA *, OBJ_DATA *));
PROTOTYPE(bool is_friend, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(bool is_full_name, (const char *, const char *));
PROTOTYPE(CHAR_DATA * get_char_id, (long));

/* interp.c */
PROTOTYPE(void interpret, (CHAR_DATA *, const char *));
PROTOTYPE(bool is_number, (const char *));
PROTOTYPE(unsigned int number_argument, (const char *, char *));
PROTOTYPE(unsigned int mult_argument, (const char *, char *));
PROTOTYPE(const char *one_argument, (const char *, char *));
PROTOTYPE(void load_disabled, (void));
PROTOTYPE(void save_disabled, (void));

/* magic.c */
PROTOTYPE(int find_spell, (CHAR_DATA *, const char *));
PROTOTYPE(int mana_cost, (CHAR_DATA *, int, int));
PROTOTYPE(int skill_lookup, (const char *));
PROTOTYPE(bool saves_spell, (int, CHAR_DATA *, int));
PROTOTYPE(void obj_cast_spell,
		  (int, int, CHAR_DATA *, CHAR_DATA *, OBJ_DATA *));
PROTOTYPE(bool check_dispel, (int, CHAR_DATA *, int));
PROTOTYPE(bool saves_dispel, (int, int, int));

/* multiclass.c */
PROTOTYPE(bool can_use_skpell, (CHAR_DATA *, int));
PROTOTYPE(bool has_spells, (CHAR_DATA *));
PROTOTYPE(bool is_class, (CHAR_DATA *, int));
PROTOTYPE(bool is_same_class, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(int number_classes, (CHAR_DATA *));
PROTOTYPE(char *class_long, (CHAR_DATA *));
PROTOTYPE(char *class_who, (CHAR_DATA *));
PROTOTYPE(char *class_short, (CHAR_DATA *));
PROTOTYPE(char *class_numbers, (CHAR_DATA *, bool));
PROTOTYPE(int skill_level, (CHAR_DATA *, int));
PROTOTYPE(int skill_rating, (CHAR_DATA *, int));
PROTOTYPE(int group_rating, (CHAR_DATA *, int));
PROTOTYPE(bool check_base_group, (CHAR_DATA *, int));
PROTOTYPE(bool is_base_skill, (CHAR_DATA *, int));
PROTOTYPE(int get_hp_gain, (CHAR_DATA *));
PROTOTYPE(int get_mana_gain, (CHAR_DATA *));
PROTOTYPE(bool is_prime_stat, (CHAR_DATA *, int));
PROTOTYPE(void add_default_groups, (CHAR_DATA *));
PROTOTYPE(void add_base_groups, (CHAR_DATA *));
PROTOTYPE(int get_stat_bonus, (CHAR_DATA *, int));
PROTOTYPE(int get_thac00, (CHAR_DATA *));
PROTOTYPE(int get_thac32, (CHAR_DATA *));
PROTOTYPE(int get_hp_max, (CHAR_DATA *));
PROTOTYPE(int lvl_bonus, (CHAR_DATA *));
PROTOTYPE(int class_mult, (CHAR_DATA *));
PROTOTYPE(bool is_race_skill, (CHAR_DATA *, int));
PROTOTYPE(int hp_max, (CHAR_DATA *));
PROTOTYPE(int prime_class, (CHAR_DATA *));

/* quest.c */
PROTOTYPE(bool chance, (int));
PROTOTYPEF(void mob_tell, (CHAR_DATA *, CHAR_DATA *, const char *, ...), 3, 4);
PROTOTYPE(void generate_quest, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(void quest_update, (void));
PROTOTYPE(bool quest_level_diff, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(void end_quest, (CHAR_DATA *, int));
PROTOTYPE(OBJ_DATA * has_questobj, (CHAR_DATA *));
PROTOTYPE(void update_questobjs, (CHAR_DATA *, OBJ_DATA *));
PROTOTYPE(int qobj_cost, (OBJ_DATA *));
PROTOTYPE(int is_qobj, (OBJ_DATA *));
PROTOTYPE(void add_apply,
		  (OBJ_DATA *, apply_t, int, where_t, int, int, flag_t, int));
PROTOTYPE(void update_all_qobjs, (CHAR_DATA *));
PROTOTYPE(void unfinished_quest, (CHAR_DATA *));

/* save.c */
PROTOTYPE(void save_char_obj, (CHAR_DATA *));
PROTOTYPE(bool load_char_obj, (DESCRIPTOR_DATA *, const char *));
PROTOTYPE(void update_corpses, (OBJ_DATA *, bool));
PROTOTYPE(void load_corpses, (void));
PROTOTYPE(void checkcorpse, (CHAR_DATA *));

/* skills.c */
PROTOTYPE(bool parse_gen_groups, (CHAR_DATA *, const char *));
PROTOTYPE(void list_group_costs, (CHAR_DATA *));
PROTOTYPE(void list_group_known, (CHAR_DATA *));
PROTOTYPE(int exp_per_level, (CHAR_DATA *, int));
PROTOTYPE(void check_improve, (CHAR_DATA *, int, bool, int));
PROTOTYPE(int group_lookup, (const char *));
PROTOTYPE(void gn_add, (CHAR_DATA *, int));
PROTOTYPE(void gn_remove, (CHAR_DATA *, int));
PROTOTYPE(void group_add, (CHAR_DATA *, const char *, bool));
PROTOTYPE(void group_remove, (CHAR_DATA *, const char *));

/* special.c */
PROTOTYPE(SPEC_FUN * spec_lookup, (const char *));
PROTOTYPE(const char *spec_name, (SPEC_FUN *));

/* statlist.c */
PROTOTYPE(void update_statlist, (CHAR_DATA *, bool));
PROTOTYPE(void show_game_stats, (CHAR_DATA *, int));

/* teleport.c */
PROTOTYPE(ROOM_INDEX_DATA * room_by_name, (char *, int, bool));

/* update.c */
PROTOTYPE(void advance_level, (CHAR_DATA *, bool));
PROTOTYPE(void gain_exp, (CHAR_DATA *, int));
PROTOTYPE(void gain_condition, (CHAR_DATA *, int, int));
PROTOTYPE(void update_handler, (void));

/* string.c */
PROTOTYPE(void string_edit, (CHAR_DATA *, const char **));
PROTOTYPE(void string_append, (CHAR_DATA *, const char **));
PROTOTYPE(const char *string_replace, (const char *, char *old, char *));
PROTOTYPE(void string_add, (CHAR_DATA *, char *));
PROTOTYPE(const char *format_string, (const char *oldstring /*, bool */ ));
PROTOTYPE(const char *first_arg, (const char *, char *, bool));
PROTOTYPE(const char *string_unpad, (const char *));
PROTOTYPE(const char *string_proper, (const char *));
PROTOTYPE(strshow_t parse_string_command,
		  (const char **, const char *, CHAR_DATA *));
PROTOTYPE(void parse_action, (const char **, int, const char *, CHAR_DATA *));

/* olc.c */
PROTOTYPE(bool run_olc_editor, (DESCRIPTOR_DATA *, char *));
PROTOTYPE(const char *olc_ed_name, (DESCRIPTOR_DATA *));
PROTOTYPE(char *olc_ed_vnum, (DESCRIPTOR_DATA *));
PROTOTYPE(void clean_area_links, (AREA_DATA *));
PROTOTYPE(bool vnum_OK, (vnum_t, vnum_t));

/* lookup.c */
PROTOTYPE(RACE_DATA * race_lookup, (const char *));
PROTOTYPE(int item_lookup, (const char *));
PROTOTYPE(int liq_lookup, (const char *));

/* mccp.c */
#if !defined(NO_MCCP)
PROTOTYPE(bool compressStart, (DESCRIPTOR_DATA *, int));
PROTOTYPE(bool compressEnd, (DESCRIPTOR_DATA *, int));
PROTOTYPE(bool processCompressed, (DESCRIPTOR_DATA *));
PROTOTYPE(bool writeCompressed, (DESCRIPTOR_DATA *, const char *, int));
#endif

PROTOTYPE(void hunt_victim, (CHAR_DATA *));
PROTOTYPEF(void announce, (CHAR_DATA *, flag_t, const char *, ...), 3, 4);

/* gquest.c */
PROTOTYPE(void auto_gquest, (void));
PROTOTYPE(bool start_gquest, (CHAR_DATA *, const char *));
PROTOTYPE(void end_gquest, (CHAR_DATA *));
PROTOTYPE(void gquest_update, (void));
PROTOTYPE(bool generate_gquest, (CHAR_DATA *));
PROTOTYPE(int count_gqmobs, (GQ_DATA *));
PROTOTYPE(int is_gqmob, (GQ_DATA *, vnum_t));
PROTOTYPE(bool is_random_gqmob, (vnum_t));

/*explored.c */
PROTOTYPE(void fread_rle, (char *, FILE *));
PROTOTYPE(void read_rle, (char *, READ_DATA *));
PROTOTYPE(void fwrite_rle, (char *, FILE *));
PROTOTYPE(int arearooms, (AREA_DATA *));
PROTOTYPE(void update_explored, (CHAR_DATA *));
PROTOTYPE(int bitcount, (char));
PROTOTYPE(int roomcount, (CHAR_DATA *));
PROTOTYPE(int areacount, (CHAR_DATA *, AREA_DATA *));

PROTOTYPE(bool emptystring, (const char *));
PROTOTYPE(void draw_map, (CHAR_DATA *, const char *));

/* war.c */
PROTOTYPE(void war_channel, (CHAR_DATA *, char *));
PROTOTYPE(void war_update, (void));
PROTOTYPE(void auto_war, (void));
PROTOTYPE(void check_war, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(bool is_safe_war, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(void war_talk, (CHAR_DATA *, const char *));
PROTOTYPE(void end_war, (void));
PROTOTYPE(bool abort_race_war, (void));
PROTOTYPE(bool abort_class_war, (void));
PROTOTYPE(bool abort_clan_war, (void));
PROTOTYPE(void extract_war, (CHAR_DATA *));

PROTOTYPE(CMD_DATA * command_lookup, (const char *));

PROTOTYPE(void delete_home, (CHAR_DATA *));
PROTOTYPE(int count_home, (CHAR_DATA *));

PROTOTYPE(void extract_auc, (CHAR_DATA *));
PROTOTYPE(AUCTION_DATA * auction_lookup, (int));
PROTOTYPE(int get_auc_id, (void));
PROTOTYPE(bool has_auction, (CHAR_DATA *));
PROTOTYPE(void reset_auc, (AUCTION_DATA *, bool));
PROTOTYPE(int count_auc, (CHAR_DATA *));
PROTOTYPE(void auction_update, (void));
PROTOTYPE(long advatoi, (const char *));

PROTOTYPE(const char *get_sector_color, (sector_t));

PROTOTYPE(OBJ_DATA * get_donation_pit, (void));
PROTOTYPE(void read_obj, (CHAR_DATA *, READ_DATA *, bool));
PROTOTYPE(void fwrite_obj, (CHAR_DATA *, OBJ_DATA *, FILE *, int, char *));
PROTOTYPE(void load_donation_pit, (void));
PROTOTYPE(void save_donation_pit, (void));

PROTOTYPE(void read_char, (CHAR_DATA *, READ_DATA *));
PROTOTYPE(void pload_default, (CHAR_DATA *));

PROTOTYPE(void check_arena, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(void extract_arena, (CHAR_DATA *));
PROTOTYPE(bool IS_IN_ARENA, (CHAR_DATA *));

PROTOTYPE(char *prog_type_to_name, (flag_t));
PROTOTYPE(void program_flow, (vnum_t, const char *, CHAR_DATA *, OBJ_DATA *,
							  ROOM_INDEX_DATA *, CHAR_DATA *, const void *arg1,
							  const void *));
PROTOTYPE(void p_act_trigger, (const char *, CHAR_DATA *, OBJ_DATA *,
							   ROOM_INDEX_DATA *, CHAR_DATA *, const void *,
							   const void *, flag_t));
PROTOTYPE(bool p_percent_trigger, (CHAR_DATA *, OBJ_DATA *, ROOM_INDEX_DATA *,
								   CHAR_DATA *, const void *, const void *,
								   flag_t));
PROTOTYPE(void p_bribe_trigger, (CHAR_DATA *, CHAR_DATA *, long));
PROTOTYPE(bool p_exit_trigger, (CHAR_DATA *, int, prog_t));
PROTOTYPE(void p_give_trigger, (CHAR_DATA *, OBJ_DATA *, ROOM_INDEX_DATA *,
								CHAR_DATA *, OBJ_DATA *, flag_t));
PROTOTYPE(void p_greet_trigger, (CHAR_DATA *, prog_t));
PROTOTYPE(void p_hprct_trigger, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(void mob_interpret, (CHAR_DATA *, const char *));
PROTOTYPE(void obj_interpret, (OBJ_DATA *, const char *));
PROTOTYPE(void room_interpret, (ROOM_INDEX_DATA *, const char *));
PROTOTYPE(void do_obj, (OBJ_DATA *, const char *));
PROTOTYPE(void do_room, (ROOM_INDEX_DATA *, const char *));

PROTOTYPE(bool is_deity_skill, (CHAR_DATA *, int));

PROTOTYPE(void update_webpasses, (CHAR_DATA *, bool));

PROTOTYPE(bool d_write, (DESCRIPTOR_DATA *, const char *, int));

PROTOTYPE(int check_buddy, (CHAR_DATA *, CHAR_DATA *));

PROTOTYPE(int srt_skills, (const void *, const void *));

PROTOTYPE(void add_help, (HELP_DATA *));
PROTOTYPE(void add_area, (AREA_DATA *));
PROTOTYPE(void unlink_area, (AREA_DATA *));

PROTOTYPEF(char *FORMATF, (const char *, ...), 1, 2);
PROTOTYPE(void *alloc_perm, (size_t));

PROTOTYPE(void update_members, (CHAR_DATA *, bool));

PROTOTYPE(void unlink_command, (CMD_DATA *));
PROTOTYPE(void add_command, (CMD_DATA *));
PROTOTYPE(void unhash_command, (CMD_DATA *));
PROTOTYPE(void hash_command, (CMD_DATA *));

PROTOTYPE(void unlink_social, (SOCIAL_DATA *));
PROTOTYPE(void add_social, (SOCIAL_DATA *));
PROTOTYPE(void unhash_social, (SOCIAL_DATA *));
PROTOTYPE(void hash_social, (SOCIAL_DATA *));

PROTOTYPE(SOCIAL_DATA * find_social, (const char *));

PROTOTYPE(void set_on_off, (CHAR_DATA *, flag_t *, flag_t, const char *,
							const char *));
PROTOTYPE(void print_on_off, (CHAR_DATA *, bool, const char *, const char *));

PROTOTYPE(char *make_colour, (void));

PROTOTYPE(char *str_time, (time_t, int, const char *));

PROTOTYPE(int calc_max_level, (CHAR_DATA *));
PROTOTYPE(const char *high_level_name, (int, bool));

PROTOTYPE(void add_random_exit, (ROOM_INDEX_DATA *, RESET_DATA *, bool));
PROTOTYPE(int get_direction, (const char *));
PROTOTYPE(int reset_door, (RESET_DATA *, bool));

PROTOTYPE(void crs_update, (void));
PROTOTYPE(const char *format_pulse, (int));
PROTOTYPE(const char *crs_sprintf, (bool, bool));
PROTOTYPE(bool read_from_descriptor, (DESCRIPTOR_DATA *));

PROTOTYPE(bool bust_a_portal, (CHAR_DATA *));
PROTOTYPE(void portal_map, (CHAR_DATA *, ROOM_INDEX_DATA *));
PROTOTYPE(void send_portal, (DESCRIPTOR_DATA *, const char *, ...));

PROTOTYPE(void send_imp, (DESCRIPTOR_DATA *, char *));

PROTOTYPE(void image_to_char, (CHAR_DATA *, const char *));
PROTOTYPE(void send_sound, (CHAR_DATA *, const char *, int));
PROTOTYPE(void send_music, (CHAR_DATA *, const char *, const char *));

PROTOTYPE(unsigned int get_line, (char *, unsigned int));
PROTOTYPE(void reformat_desc, (char *));

#if defined(__cplusplus)
#define dwrap(d, buf) (d)->wrap((buf))
#else
PROTOTYPE(void dwrap, (DESCRIPTOR_DATA *, const char *));
#endif
PROTOTYPE(void dwrapln, (DESCRIPTOR_DATA *, const char *));
PROTOTYPEF(void dwrapf, (DESCRIPTOR_DATA *, const char *, ...), 2, 3);
PROTOTYPEF(void dwraplnf, (DESCRIPTOR_DATA *, const char *, ...), 2, 3);

PROTOTYPE(char *fix_string, (const char *));

PROTOTYPE(void autodrop, (CHAR_DATA *));
PROTOTYPE(bool can_bypass, (CHAR_DATA *, CHAR_DATA *));
PROTOTYPE(long dambonus, (CHAR_DATA *, CHAR_DATA *, long, int));
PROTOTYPE(bool can_counter, (CHAR_DATA *));
PROTOTYPE(void improve_stance, (CHAR_DATA *));
PROTOTYPE(char *get_stance_name, (int));

PROTOTYPE(bool is_ignoring, (CHAR_DATA *, const char *, flag_t));
PROTOTYPE(void write_time, (void));
PROTOTYPE(void log_error, (const char *));

PROTOTYPE(void finish_note, (BOARD_DATA *, NOTE_DATA *));	/* attach a note to a board */
PROTOTYPE(void free_note, (NOTE_DATA *));	/* deallocate memory used by a note */
PROTOTYPE(void load_boards, (void));	/* load all boards */
PROTOTYPE(int board_lookup, (const char *));	/* Find a board with that name */
PROTOTYPE(bool is_note_to, (CHAR_DATA *, NOTE_DATA *));	/* is tha note to ch? */
PROTOTYPE(void personal_message, (const char *, const char *,
								  const char *, const int, const char *));
PROTOTYPE(void make_note, (const char *, const char *, const char *,
						   const char *, const int, const char *));
PROTOTYPE(void save_notes, (void));

/* for nanny */
PROTOTYPE(void handle_con_note_to, (DESCRIPTOR_DATA *, const char *));
PROTOTYPE(void handle_con_note_subject, (DESCRIPTOR_DATA *, const char *));
PROTOTYPE(void handle_con_note_expire, (DESCRIPTOR_DATA *, const char *));
PROTOTYPE(void handle_con_note_text, (DESCRIPTOR_DATA *, const char *));
PROTOTYPE(void handle_con_note_finish, (DESCRIPTOR_DATA *, const char *));

PROTOTYPE(long fread_long, (FILE *));
PROTOTYPE(long read_long, (READ_DATA *));

PROTOTYPE(char *timestr, (time_t, bool));

PROTOTYPE(int get_scr_cols, (CHAR_DATA *));
PROTOTYPE(int get_scr_lines, (CHAR_DATA *));
PROTOTYPEF(bool file_exists, (const char *,...), 1, 2);

#endif