/**************************************************************************** * [S]imulated [M]edieval [A]dventure multi[U]ser [G]ame | \\._.// * * -----------------------------------------------------------| (0...0) * * SMAUG 1.4 (C) 1994, 1995, 1996, 1998 by Derek Snider | ).:.( * * -----------------------------------------------------------| {o o} * * SMAUG code team: Thoric, Altrag, Blodkai, Narn, Haus, | / ' ' \ * * Scryn, Rennard, Swordbearer, Gorog, Grishnakh, Nivek, |~'~.VxvxV.~'~* * Tricops and Fireblade | * * ------------------------------------------------------------------------ * * Merc 2.1 Diku Mud improvments copyright (C) 1992, 1993 by Michael * * Chastain, Michael Quan, and Mitchell Tse. * * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, * * Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. * * ------------------------------------------------------------------------ * * Table load/save Module * ****************************************************************************/ #include <time.h> #include <stdio.h> #include <string.h> #include <ctype.h> #include "mud.h" #if defined(KEY) #undef KEY #endif #define KEY( literal, field, value ) \ if ( !str_cmp( word, literal ) ) \ { \ field = value; \ fMatch = TRUE; \ break; \ } bool load_race_file(char *fname); bool load_kingdom_file(char *fname); void write_race_file(int ra); /* global variables */ int top_sn; int top_herb; int gem_num; int box_num; int forge_num; int slab_num; int boughtsaveversion; int globaltownload; TOWN_DATA *globaltownptr; MARKET_DATA *globalmarketptr; SKILLTYPE *skill_table[MAX_SKILL]; struct class_type *class_table[1]; KINGDOM_DATA *kingdom_table[MAX_KINGDOM]; NPCRACE_DATA *npcrace_table[MAX_NPCRACE_TABLE]; PORTAL_DATA *portal_show[LAST_PORTAL]; RACE_TYPE *race_table[MAX_RACE]; SKILLTYPE *herb_table[MAX_HERB]; SKILLTYPE *disease_table[MAX_DISEASE]; unsigned char battle_descriptions[7][3][100][60]; int high_value[7][3]; LANG_DATA *first_lang; LANG_DATA *last_lang; KCHEST_DATA *first_kchest; KCHEST_DATA *last_kchest; char *const skill_tname[] = { "unknown", "Spell", "Skill", "Weapon", "Tongue", "Herb", "Racial", "Disease" }; SPELL_FUN *spell_function(char *name) { if (!str_cmp(name, "spell_smaug")) return spell_smaug; if (!str_cmp(name, "spell_eye_of_god")) return spell_eye_of_god; if (!str_cmp(name, "spell_resurrection")) return spell_resurrection; if (!str_cmp(name, "spell_summon_corpse")) return spell_summon_corpse; if (!str_cmp(name, "spell_greater_resurrection")) return spell_greater_resurrection; if (!str_cmp(name, "spell_lesser_resurrection")) return spell_lesser_resurrection; if (!str_cmp(name, "spell_web")) return spell_web; if (!str_cmp(name, "spell_revitalize_spirit")) return spell_revitalize_spirit; if (!str_cmp(name, "spell_snare")) return spell_snare; if (!str_cmp(name, "spell_extradimensional_portal")) return spell_extradimensional_portal; if (!str_cmp(name, "spell_animate_dead")) return spell_animate_dead; if (!str_cmp(name, "spell_astral_walk")) return spell_astral_walk; if (!str_cmp(name, "spell_bless_weapon")) return spell_bless_weapon; if (!str_cmp(name, "spell_blindness")) return spell_blindness; if (!str_cmp(name, "spell_cause_critical")) return spell_cause_critical; if (!str_cmp(name, "spell_restore_limb")) return spell_restore_limb; if (!str_cmp(name, "spell_revitalize_limb")) return spell_revitalize_limb; if (!str_cmp(name, "spell_cause_light")) return spell_cause_light; if (!str_cmp(name, "spell_cause_serious")) return spell_cause_serious; if (!str_cmp(name, "spell_charm_person")) return spell_charm_person; if (!str_cmp(name, "spell_create_food")) return spell_create_food; if (!str_cmp(name, "spell_create_water")) return spell_create_water; if (!str_cmp(name, "spell_bless_weapon")) return spell_bless_weapon; if (!str_cmp(name, "spell_cure_blindness")) return spell_cure_blindness; if (!str_cmp(name, "spell_cure_poison")) return spell_cure_poison; if (!str_cmp(name, "spell_curse")) return spell_curse; if (!str_cmp(name, "spell_detect_poison")) return spell_detect_poison; if (!str_cmp(name, "spell_disenchant_weapon")) return spell_disenchant_weapon; if (!str_cmp(name, "spell_dispel_magic")) return spell_dispel_magic; if (!str_cmp(name, "spell_earthquake")) return spell_earthquake; if (!str_cmp(name, "spell_enchant_weapon")) return spell_enchant_weapon; if (!str_cmp(name, "spell_faerie_fire")) return spell_faerie_fire; if (!str_cmp(name, "spell_faerie_fog")) return spell_faerie_fog; if (!str_cmp(name, "spell_farsight")) return spell_farsight; if (!str_cmp(name, "spell_knock")) return spell_knock; if (!str_cmp(name, "spell_harm")) return spell_harm; if (!str_cmp(name, "spell_holy_food")) return spell_holy_food; if (!str_cmp(name, "spell_identify")) return spell_identify; if (!str_cmp(name, "spell_invis")) return spell_invis; if (!str_cmp(name, "spell_knowenemy")) return spell_knowenemy; if (!str_cmp(name, "spell_locate_object")) return spell_locate_object; if (!str_cmp(name, "spell_pass_door")) return spell_pass_door; if (!str_cmp(name, "spell_poison")) return spell_poison; if (!str_cmp(name, "spell_polymorph")) return spell_polymorph; if (!str_cmp(name, "spell_possess")) return spell_possess; if (!str_cmp(name, "spell_recharge")) return spell_recharge; if (!str_cmp(name, "spell_remove_curse")) return spell_remove_curse; if (!str_cmp(name, "spell_remove_invis")) return spell_remove_invis; if (!str_cmp(name, "spell_remove_trap")) return spell_remove_trap; if (!str_cmp(name, "spell_sleep")) return spell_sleep; if (!str_cmp(name, "spell_summon")) return spell_summon; if (!str_cmp(name, "spell_wizard_eye")) return spell_wizard_eye; if (!str_cmp(name, "spell_weaken")) return spell_weaken; if (!str_cmp(name, "spell_word_of_recall")) return spell_word_of_recall; if (!str_cmp(name, "spell_acid_breath")) return spell_acid_breath; if (!str_cmp(name, "spell_fire_breath")) return spell_fire_breath; if (!str_cmp(name, "spell_frost_breath")) return spell_frost_breath; if (!str_cmp(name, "spell_gas_breath")) return spell_gas_breath; if (!str_cmp(name, "spell_lightning_breath")) return spell_lightning_breath; if (!str_cmp(name, "spell_portal")) return spell_portal; if (!str_cmp(name, "spell_bethsaidean_touch")) return spell_bethsaidean_touch; if (!str_cmp(name, "spell_expurgation")) return spell_expurgation; if (!str_cmp(name, "spell_sacral_divinity")) return spell_sacral_divinity; if (!str_cmp(name, "spell_holy_cleansing")) return spell_holy_cleansing; if (!str_cmp(name, "reserved")) return NULL; if (!str_cmp(name, "spell_null")) return spell_null; return spell_notfound; } DO_FUN *skill_function(char *name) { switch (name[3]) { /*//T1*/ case 'a': if ( !str_cmp( name, "do_aassign" )) return do_aassign; if ( !str_cmp( name, "do_accept" )) return do_accept; if ( !str_cmp( name, "do_accounts" )) return do_accounts; if ( !str_cmp( name, "do_add_imm_host" )) return do_add_imm_host; if ( !str_cmp( name, "do_addbox" )) return do_addbox; if ( !str_cmp( name, "do_addforge" )) return do_addforge; if ( !str_cmp( name, "do_addgem" )) return do_addgem; if ( !str_cmp( name, "do_addslab" )) return do_addslab; if ( !str_cmp( name, "do_advance" )) return do_advance; if ( !str_cmp( name, "do_advanceclock" )) return do_advanceclock; if ( !str_cmp( name, "do_affected" )) return do_affected; if ( !str_cmp( name, "do_afk" )) return do_afk; if ( !str_cmp( name, "do_ahall" )) return do_ahall; if ( !str_cmp( name, "do_ahelp" )) return do_ahelp; if ( !str_cmp( name, "do_aid" )) return do_aid; if ( !str_cmp( name, "do_aim" )) return do_aim; if ( !str_cmp( name, "do_alias" )) return do_alias; if ( !str_cmp( name, "do_allow" )) return do_allow; if ( !str_cmp( name, "do_amberio" )) return do_amberio; if ( !str_cmp( name, "do_ansi" )) return do_ansi; if ( !str_cmp( name, "do_answer" )) return do_answer; if ( !str_cmp( name, "do_apply" )) return do_apply; if ( !str_cmp( name, "do_appraise" )) return do_appraise; if ( !str_cmp( name, "do_areas" )) return do_areas; if ( !str_cmp( name, "do_arena" )) return do_arena; if ( !str_cmp( name, "do_armmilitary" )) return do_armmilitary; if ( !str_cmp( name, "do_aset" )) return do_aset; if ( !str_cmp( name, "do_ask" )) return do_ask; if ( !str_cmp( name, "do_assassinate" )) return do_assassinate; if ( !str_cmp( name, "do_astat" )) return do_astat; if ( !str_cmp( name, "do_at" )) return do_at; if ( !str_cmp( name, "do_atmob" )) return do_atmob; if ( !str_cmp( name, "do_atobj" )) return do_atobj; if ( !str_cmp( name, "do_attack" )) return do_attack; if ( !str_cmp( name, "do_auction" )) return do_auction; if ( !str_cmp( name, "do_authorize" )) return do_authorize; if ( !str_cmp( name, "do_avtalk" )) return do_avtalk; if ( !str_cmp( name, "do_awho" )) return do_awho; break; case 'b': if ( !str_cmp( name, "do_backstab" )) return do_backstab; if ( !str_cmp( name, "do_balance" )) return do_balance; if ( !str_cmp( name, "do_balzhur" )) return do_balzhur; if ( !str_cmp( name, "do_bamfin" )) return do_bamfin; if ( !str_cmp( name, "do_bamfout" )) return do_bamfout; if ( !str_cmp( name, "do_ban" )) return do_ban; if ( !str_cmp( name, "do_bash" )) return do_bash; if ( !str_cmp( name, "do_bashdoor" )) return do_bashdoor; if ( !str_cmp( name, "do_bcard" )) return do_bcard; if ( !str_cmp( name, "do_beep" )) return do_beep; if ( !str_cmp( name, "do_begging" )) return do_begging; if ( !str_cmp( name, "do_berserk" )) return do_berserk; if ( !str_cmp( name, "do_bestow" )) return do_bestow; if ( !str_cmp( name, "do_bestowarea" )) return do_bestowarea; if ( !str_cmp( name, "do_bet" )) return do_bet; if ( !str_cmp( name, "do_bhold" )) return do_bhold; if ( !str_cmp( name, "do_bio" )) return do_bio; if ( !str_cmp( name, "do_blackjack" )) return do_blackjack; if ( !str_cmp( name, "do_blitz" )) return do_blitz; if ( !str_cmp( name, "do_blockmove" )) return do_blockmove; if ( !str_cmp( name, "do_boards" )) return do_boards; if ( !str_cmp( name, "do_bodybag" )) return do_bodybag; if ( !str_cmp( name, "do_brandish" )) return do_brandish; if ( !str_cmp( name, "do_break" )) return do_break; if ( !str_cmp( name, "do_breakwall" )) return do_breakwall; if ( !str_cmp( name, "do_brew" )) return do_brew; if ( !str_cmp( name, "do_bset" )) return do_bset; if ( !str_cmp( name, "do_bstat" )) return do_bstat; if ( !str_cmp( name, "do_bug" )) return do_bug; if ( !str_cmp( name, "do_build" )) return do_build; if ( !str_cmp( name, "do_buildroom" )) return do_buildroom; if ( !str_cmp( name, "do_bury" )) return do_bury; if ( !str_cmp( name, "do_buy" )) return do_buy; if ( !str_cmp( name, "do_buycaste" )) return do_buycaste; break; case 'c': if ( !str_cmp( name, "do_cache" )) return do_cache; if ( !str_cmp( name, "do_calmmount" )) return do_calmmount; if ( !str_cmp( name, "do_carrybin" )) return do_carrybin; if ( !str_cmp( name, "do_cast" )) return do_cast; if ( !str_cmp( name, "do_caste" )) return do_caste; if ( !str_cmp( name, "do_castevalues" )) return do_castevalues; if ( !str_cmp( name, "do_cedit" )) return do_cedit; if ( !str_cmp( name, "do_challenge" )) return do_challenge; if ( !str_cmp( name, "do_changes" )) return do_changes; if ( !str_cmp( name, "do_channels" )) return do_channels; if ( !str_cmp( name, "do_chaos" )) return do_chaos; if ( !str_cmp( name, "do_chat" )) return do_chat; if ( !str_cmp( name, "do_check_vnums" )) return do_check_vnums; if ( !str_cmp( name, "do_chistory" )) return do_chistory; if ( !str_cmp( name, "do_circle" )) return do_circle; if ( !str_cmp( name, "do_cityvalues" )) return do_cityvalues; if ( !str_cmp( name, "do_clans" )) return do_clans; if ( !str_cmp( name, "do_cleansing" )) return do_cleansing; if ( !str_cmp( name, "do_clearques" )) return do_clearques; if ( !str_cmp( name, "do_clearstack" )) return do_clearstack; if ( !str_cmp( name, "do_climate" )) return do_climate; if ( !str_cmp( name, "do_climb" )) return do_climb; if ( !str_cmp( name, "do_climbwall" )) return do_climbwall; if ( !str_cmp( name, "do_cloak" )) return do_cloak; if ( !str_cmp( name, "do_clones" )) return do_clones; if ( !str_cmp( name, "do_close" )) return do_close; if ( !str_cmp( name, "do_cmdtable" )) return do_cmdtable; if ( !str_cmp( name, "do_color" )) return do_color; if ( !str_cmp( name, "do_command" )) return do_command; if ( !str_cmp( name, "do_commands" )) return do_commands; if ( !str_cmp( name, "do_comment" )) return do_comment; if ( !str_cmp( name, "do_compare" )) return do_compare; if ( !str_cmp( name, "do_compress" )) return do_compress; if ( !str_cmp( name, "do_config" )) return do_config; if ( !str_cmp( name, "do_conquer" )) return do_conquer; if ( !str_cmp( name, "do_consent" )) return do_consent; if ( !str_cmp( name, "do_consider" )) return do_consider; if ( !str_cmp( name, "do_cook" )) return do_cook; if ( !str_cmp( name, "do_coords" )) return do_coords; if ( !str_cmp( name, "do_copyover" )) return do_copyover; if ( !str_cmp( name, "do_council_induct" )) return do_council_induct; if ( !str_cmp( name, "do_council_outcast" )) return do_council_outcast; if ( !str_cmp( name, "do_councils" )) return do_councils; if ( !str_cmp( name, "do_counciltalk" )) return do_counciltalk; if ( !str_cmp( name, "do_counter" )) return do_counter; if ( !str_cmp( name, "do_credits" )) return do_credits; if ( !str_cmp( name, "do_cset" )) return do_cset; if ( !str_cmp( name, "do_cutgag" )) return do_cutgag; if ( !str_cmp( name, "do_cutpurse" )) return do_cutpurse; break; case 'd': if ( !str_cmp( name, "do_daze" )) return do_daze; if ( !str_cmp( name, "do_declare" )) return do_declare; if ( !str_cmp( name, "do_decline" )) return do_decline; if ( !str_cmp( name, "do_deities" )) return do_deities; if ( !str_cmp( name, "do_delay" )) return do_delay; if ( !str_cmp( name, "do_delet" )) return do_delet; if ( !str_cmp( name, "do_delete" )) return do_delete; if ( !str_cmp( name, "do_deny" )) return do_deny; if ( !str_cmp( name, "do_deposit" )) return do_deposit; if ( !str_cmp( name, "do_depository" )) return do_depository; if ( !str_cmp( name, "do_description" )) return do_description; if ( !str_cmp( name, "do_deshield" )) return do_deshield; if ( !str_cmp( name, "do_destro" )) return do_destro; if ( !str_cmp( name, "do_destroy" )) return do_destroy; if ( !str_cmp( name, "do_destroyslay" )) return do_destroyslay; if ( !str_cmp( name, "do_detrap" )) return do_detrap; if ( !str_cmp( name, "do_devote" )) return do_devote; if ( !str_cmp( name, "do_diagnose" )) return do_diagnose; if ( !str_cmp( name, "do_dig" )) return do_dig; if ( !str_cmp( name, "do_disarm" )) return do_disarm; if ( !str_cmp( name, "do_disconnect" )) return do_disconnect; if ( !str_cmp( name, "do_dislodge" )) return do_dislodge; if ( !str_cmp( name, "do_dismiss" )) return do_dismiss; if ( !str_cmp( name, "do_dismount" )) return do_dismount; if ( !str_cmp( name, "do_dmesg" )) return do_dmesg; if ( !str_cmp( name, "do_dodge" )) return do_dodge; if ( !str_cmp( name, "do_down" )) return do_down; if ( !str_cmp( name, "do_drag" )) return do_drag; if ( !str_cmp( name, "do_draw" )) return do_draw; if ( !str_cmp( name, "do_drink" )) return do_drink; if ( !str_cmp( name, "do_drive" )) return do_drive; if ( !str_cmp( name, "do_drop" )) return do_drop; if ( !str_cmp( name, "do_duel" )) return do_duel; if ( !str_cmp( name, "do_dumpgoods" )) return do_dumpgoods; break; case 'e': if ( !str_cmp( name, "do_east" )) return do_east; if ( !str_cmp( name, "do_eat" )) return do_eat; if ( !str_cmp( name, "do_echo" )) return do_echo; if ( !str_cmp( name, "do_elbowbreak" )) return do_elbowbreak; if ( !str_cmp( name, "do_elbowjab" )) return do_elbowjab; if ( !str_cmp( name, "do_elbowstab" )) return do_elbowstab; if ( !str_cmp( name, "do_email" )) return do_email; if ( !str_cmp( name, "do_emeru" )) return do_emeru; if ( !str_cmp( name, "do_emote" )) return do_emote; if ( !str_cmp( name, "do_empty" )) return do_empty; if ( !str_cmp( name, "do_emptycorpses" )) return do_emptycorpses; if ( !str_cmp( name, "do_enter" )) return do_enter; if ( !str_cmp( name, "do_entership" )) return do_entership; if ( !str_cmp( name, "do_equipment" )) return do_equipment; if ( !str_cmp( name, "do_enhance" )) return do_enhance; if ( !str_cmp( name, "do_examine" )) return do_examine; if ( !str_cmp( name, "do_exits" )) return do_exits; if ( !str_cmp( name, "do_extract" )) return do_extract; break; case 'f': if ( !str_cmp( name, "do_feedmount" )) return do_feedmount; if ( !str_cmp( name, "do_fightoutput" )) return do_fightoutput; if ( !str_cmp( name, "do_fill" )) return do_fill; if ( !str_cmp( name, "do_findnote" )) return do_findnote; if ( !str_cmp( name, "do_finger" )) return do_finger; if ( !str_cmp( name, "do_fire" )) return do_fire; if ( !str_cmp( name, "do_fix" )) return do_fix; if ( !str_cmp( name, "do_fixchar" )) return do_fixchar; if ( !str_cmp( name, "do_fixed" )) return do_fixed; if ( !str_cmp( name, "do_fixgemslots" )) return do_fixgemslots; if ( !str_cmp( name, "do_flee" )) return do_flee; if ( !str_cmp( name, "do_flevel" )) return do_flevel; if ( !str_cmp( name, "do_flipcoin" )) return do_flipcoin; if ( !str_cmp( name, "do_foldarea" )) return do_foldarea; if ( !str_cmp( name, "do_foldqarea" )) return do_foldqarea; if ( !str_cmp( name, "do_follow" )) return do_follow; if ( !str_cmp( name, "do_for" )) return do_for; if ( !str_cmp( name, "do_forage" )) return do_forage; if ( !str_cmp( name, "do_force" )) return do_force; if ( !str_cmp( name, "do_forceclose" )) return do_forceclose; if ( !str_cmp( name, "do_forecast" )) return do_forecast; if ( !str_cmp( name, "do_forge" )) return do_forge; if ( !str_cmp( name, "do_forgealter" )) return do_forgealter; if ( !str_cmp( name, "do_forget" )) return do_forget; if ( !str_cmp( name, "do_form_password" )) return do_form_password; if ( !str_cmp( name, "do_fprompt" )) return do_fprompt; if ( !str_cmp( name, "do_fquit" )) return do_fquit; if ( !str_cmp( name, "do_free_vnums" )) return do_free_vnums; if ( !str_cmp( name, "do_freerooms" )) return do_freerooms; if ( !str_cmp( name, "do_freeze" )) return do_freeze; break; case 'g': if ( !str_cmp( name, "do_gag" )) return do_gag; if ( !str_cmp( name, "do_gamereset" )) return do_gamereset; if ( !str_cmp( name, "do_gaso" )) return do_gaso; if ( !str_cmp( name, "do_gathertinder" )) return do_gathertinder; if ( !str_cmp( name, "do_gem" )) return do_gem; if ( !str_cmp( name, "do_generatename" )) return do_generatename; if ( !str_cmp( name, "do_get" )) return do_get; if ( !str_cmp( name, "do_getresources" )) return do_getresources; if ( !str_cmp( name, "do_gfighting" )) return do_gfighting; if ( !str_cmp( name, "do_give" )) return do_give; if ( !str_cmp( name, "do_givecrown" )) return do_givecrown; if ( !str_cmp( name, "do_giveorders" )) return do_giveorders; if ( !str_cmp( name, "do_giveup" )) return do_giveup; if ( !str_cmp( name, "do_glance" )) return do_glance; if ( !str_cmp( name, "do_global_boards" )) return do_global_boards; if ( !str_cmp( name, "do_global_note" )) return do_global_note; if ( !str_cmp( name, "do_goauth" )) return do_goauth; if ( !str_cmp( name, "do_gold" )) return do_gold; if ( !str_cmp( name, "do_goldgive" )) return do_goldgive; if ( !str_cmp( name, "do_goldtake" )) return do_goldtake; if ( !str_cmp( name, "do_goto" )) return do_goto; if ( !str_cmp( name, "do_gouge" )) return do_gouge; if ( !str_cmp( name, "do_gprompt" )) return do_gprompt; if ( !str_cmp( name, "do_grab" )) return do_grab; if ( !str_cmp( name, "do_grantlicense" )) return do_grantlicense; if ( !str_cmp( name, "do_grip" )) return do_grip; if ( !str_cmp( name, "do_group" )) return do_group; if ( !str_cmp( name, "do_grub" )) return do_grub; if ( !str_cmp( name, "do_gscore" )) return do_gscore; if ( !str_cmp( name, "do_gsocial" )) return do_gsocial; if ( !str_cmp( name, "do_gtell" )) return do_gtell; if ( !str_cmp( name, "do_guilds" )) return do_guilds; if ( !str_cmp( name, "do_guildtalk" )) return do_guildtalk; if ( !str_cmp( name, "do_gwhere" )) return do_gwhere; break; case 'h': if ( !str_cmp( name, "do_heal" )) return do_heal; if ( !str_cmp( name, "do_hedit" )) return do_hedit; if ( !str_cmp( name, "do_hell" )) return do_hell; if ( !str_cmp( name, "do_help" )) return do_help; if ( !str_cmp( name, "do_helpcheck" )) return do_helpcheck; if ( !str_cmp( name, "do_helpweb" )) return do_helpweb; if ( !str_cmp( name, "do_hide" )) return do_hide; if ( !str_cmp( name, "do_hindex" )) return do_hindex; if ( !str_cmp( name, "do_hitall" )) return do_hitall; if ( !str_cmp( name, "do_hl" )) return do_hl; if ( !str_cmp( name, "do_hlist" )) return do_hlist; if ( !str_cmp( name, "do_holylight" )) return do_holylight; if ( !str_cmp( name, "do_homepage" )) return do_homepage; if ( !str_cmp( name, "do_hset" )) return do_hset; if ( !str_cmp( name, "do_huntportals" )) return do_huntportals; break; case 'i': if ( !str_cmp( name, "do_icq_number" )) return do_icq_number; if ( !str_cmp( name, "do_ide" )) return do_ide; if ( !str_cmp( name, "do_idea" )) return do_idea; if ( !str_cmp( name, "do_ignore" )) return do_ignore; if ( !str_cmp( name, "do_imbue" )) return do_imbue; if ( !str_cmp( name, "do_imm_morph" )) return do_imm_morph; if ( !str_cmp( name, "do_imm_unmorph" )) return do_imm_unmorph; if ( !str_cmp( name, "do_immreminder" )) return do_immreminder; if ( !str_cmp( name, "do_immtalk" )) return do_immtalk; if ( !str_cmp( name, "do_induct" )) return do_induct; if ( !str_cmp( name, "do_installarea" )) return do_installarea; if ( !str_cmp( name, "do_instaroom" )) return do_instaroom; if ( !str_cmp( name, "do_instazone" )) return do_instazone; if ( !str_cmp( name, "do_insult" )) return do_insult; if ( !str_cmp( name, "do_insults" )) return do_insults; if ( !str_cmp( name, "do_introduce" )) return do_introduce; if ( !str_cmp( name, "do_inventory" )) return do_inventory; if ( !str_cmp( name, "do_invis" )) return do_invis; if ( !str_cmp( name, "do_ipcompare" )) return do_ipcompare; break; case 'j': if ( !str_cmp( name, "do_jog" )) return do_jog; if ( !str_cmp( name, "do_joinkingdom" )) return do_joinkingdom; if ( !str_cmp( name, "do_junk" )) return do_junk; break; case 'k': if ( !str_cmp( name, "do_keeperset" )) return do_keeperset; if ( !str_cmp( name, "do_keeperstat" )) return do_keeperstat; if ( !str_cmp( name, "do_keys" )) return do_keys; if ( !str_cmp( name, "do_khistory" )) return do_khistory; if ( !str_cmp( name, "do_kick_back" )) return do_kick_back; if ( !str_cmp( name, "do_kickdirt" )) return do_kickdirt; if ( !str_cmp( name, "do_kickout" )) return do_kickout; if ( !str_cmp( name, "do_kinduct" )) return do_kinduct; if ( !str_cmp( name, "do_kingdomlog" )) return do_kingdomlog; if ( !str_cmp( name, "do_kingdomtalk" )) return do_kingdomtalk; if ( !str_cmp( name, "do_kneecrusher" )) return do_kneecrusher; if ( !str_cmp( name, "do_kneestrike" )) return do_kneestrike; if ( !str_cmp( name, "do_kremove" )) return do_kremove; break; case 'l': if ( !str_cmp( name, "do_languages" )) return do_languages; if ( !str_cmp( name, "do_last" )) return do_last; if ( !str_cmp( name, "do_lastname" )) return do_lastname; if ( !str_cmp( name, "do_laws" )) return do_laws; if ( !str_cmp( name, "do_learn" )) return do_learn; if ( !str_cmp( name, "do_leave" )) return do_leave; if ( !str_cmp( name, "do_leavekingdom" )) return do_leavekingdom; if ( !str_cmp( name, "do_leaveship" )) return do_leaveship; if ( !str_cmp( name, "do_lembecu" )) return do_lembecu; if ( !str_cmp( name, "do_light" )) return do_light; if ( !str_cmp( name, "do_list" )) return do_list; if ( !str_cmp( name, "do_listgroups" )) return do_listgroups; if ( !str_cmp( name, "do_listportals" )) return do_listportals; if ( !str_cmp( name, "do_litterbug" )) return do_litterbug; if ( !str_cmp( name, "do_loadarea" )) return do_loadarea; if ( !str_cmp( name, "do_loadgem" )) return do_loadgem; if ( !str_cmp( name, "do_loadquest" )) return do_loadquest; if ( !str_cmp( name, "do_loadup" )) return do_loadup; if ( !str_cmp( name, "do_lock" )) return do_lock; if ( !str_cmp( name, "do_log" )) return do_log; if ( !str_cmp( name, "do_logsettings" )) return do_logsettings; if ( !str_cmp( name, "do_look" )) return do_look; if ( !str_cmp( name, "do_lookaround" )) return do_lookaround; if ( !str_cmp( name, "do_lookmap" )) return do_lookmap; if ( !str_cmp( name, "do_loop" )) return do_loop; if ( !str_cmp( name, "do_lore" )) return do_lore; if ( !str_cmp( name, "do_low_purge" )) return do_low_purge; break; case 'm': if ( !str_cmp( name, "do_mailroom" )) return do_mailroom; if ( !str_cmp( name, "do_make" )) return do_make; if ( !str_cmp( name, "do_make_wilderness_exits" )) return do_make_wilderness_exits; if ( !str_cmp( name, "do_make_wilderness_exits2" )) return do_make_wilderness_exits2; if ( !str_cmp( name, "do_makeboard" )) return do_makeboard; if ( !str_cmp( name, "do_makeclan" )) return do_makeclan; if ( !str_cmp( name, "do_makecouncil" )) return do_makecouncil; if ( !str_cmp( name, "do_makedeity" )) return do_makedeity; if ( !str_cmp( name, "do_makekeeper" )) return do_makekeeper; if ( !str_cmp( name, "do_makerepair" )) return do_makerepair; if ( !str_cmp( name, "do_makeroom" )) return do_makeroom; if ( !str_cmp( name, "do_makeshop" )) return do_makeshop; if ( !str_cmp( name, "do_makeslay" )) return do_makeslay; if ( !str_cmp( name, "do_makestable" )) return do_makestable; if ( !str_cmp( name, "do_makewizlist" )) return do_makewizlist; if ( !str_cmp( name, "do_makeworker" )) return do_makeworker; if ( !str_cmp( name, "do_manaburst" )) return do_manaburst; if ( !str_cmp( name, "do_manashot" )) return do_manashot; if ( !str_cmp( name, "do_manatap" )) return do_manatap; if ( !str_cmp( name, "do_map" )) return do_map; if ( !str_cmp( name, "do_mapat" )) return do_mapat; if ( !str_cmp( name, "do_mapedit" )) return do_mapedit; if ( !str_cmp( name, "do_mapline" )) return do_mapline; if ( !str_cmp( name, "do_mapout" )) return do_mapout; if ( !str_cmp( name, "do_market" )) return do_market; if ( !str_cmp( name, "do_markportal" )) return do_markportal; if ( !str_cmp( name, "do_massgoto" )) return do_massgoto; if ( !str_cmp( name, "do_massign" )) return do_massign; if ( !str_cmp( name, "do_mcreate" )) return do_mcreate; if ( !str_cmp( name, "do_mdelete" )) return do_mdelete; if ( !str_cmp( name, "do_memory" )) return do_memory; if ( !str_cmp( name, "do_mfind" )) return do_mfind; if ( !str_cmp( name, "do_minfo" )) return do_minfo; if ( !str_cmp( name, "do_minvoke" )) return do_minvoke; if ( !str_cmp( name, "do_mixpotion" )) return do_mixpotion; if ( !str_cmp( name, "do_mlist" )) return do_mlist; if ( !str_cmp( name, "do_moblog" )) return do_moblog; if ( !str_cmp( name, "do_morgue" )) return do_morgue; if ( !str_cmp( name, "do_morphcreate" )) return do_morphcreate; if ( !str_cmp( name, "do_morphdestroy" )) return do_morphdestroy; if ( !str_cmp( name, "do_morphset" )) return do_morphset; if ( !str_cmp( name, "do_morphstat" )) return do_morphstat; if ( !str_cmp( name, "do_mortalize" )) return do_mortalize; if ( !str_cmp( name, "do_mount" )) return do_mount; if ( !str_cmp( name, "do_movement" )) return do_movement; if ( !str_cmp( name, "do_mp_close_passage" )) return do_mp_close_passage; if ( !str_cmp( name, "do_mp_damage" )) return do_mp_damage; if ( !str_cmp( name, "do_mp_deposit" )) return do_mp_deposit; if ( !str_cmp( name, "do_mp_fill_in" )) return do_mp_fill_in; if ( !str_cmp( name, "do_mp_log" )) return do_mp_log; if ( !str_cmp( name, "do_mp_open_passage" )) return do_mp_open_passage; if ( !str_cmp( name, "do_mp_practice" )) return do_mp_practice; if ( !str_cmp( name, "do_mp_restore" )) return do_mp_restore; if ( !str_cmp( name, "do_mp_slay" )) return do_mp_slay; if ( !str_cmp( name, "do_mp_withdraw" )) return do_mp_withdraw; if ( !str_cmp( name, "do_mpadvance" )) return do_mpadvance; if ( !str_cmp( name, "do_mpapply" )) return do_mpapply; if ( !str_cmp( name, "do_mpapplyb" )) return do_mpapplyb; if ( !str_cmp( name, "do_mpasound" )) return do_mpasound; if ( !str_cmp( name, "do_mpasupress" )) return do_mpasupress; if ( !str_cmp( name, "do_mpat" )) return do_mpat; if ( !str_cmp( name, "do_mpbodybag" )) return do_mpbodybag; if ( !str_cmp( name, "do_mpdelay" )) return do_mpdelay; if ( !str_cmp( name, "do_mpdream" )) return do_mpdream; if ( !str_cmp( name, "do_mpecho" )) return do_mpecho; if ( !str_cmp( name, "do_mpechoaround" )) return do_mpechoaround; if ( !str_cmp( name, "do_mpechoat" )) return do_mpechoat; if ( !str_cmp( name, "do_mpechozone" )) return do_mpechozone; if ( !str_cmp( name, "do_mpedit" )) return do_mpedit; if ( !str_cmp( name, "do_mpfavor" )) return do_mpfavor; if ( !str_cmp( name, "do_mpforce" )) return do_mpforce; if ( !str_cmp( name, "do_mpgive" )) return do_mpgive; if ( !str_cmp( name, "do_mpgoto" )) return do_mpgoto; if ( !str_cmp( name, "do_mpinvis" )) return do_mpinvis; if ( !str_cmp( name, "do_mpjunk" )) return do_mpjunk; if ( !str_cmp( name, "do_mpkill" )) return do_mpkill; if ( !str_cmp( name, "do_mpmload" )) return do_mpmload; if ( !str_cmp( name, "do_mpmorph" )) return do_mpmorph; if ( !str_cmp( name, "do_mpmset" )) return do_mpmset; if ( !str_cmp( name, "do_mpmusic" )) return do_mpmusic; if ( !str_cmp( name, "do_mpmusicaround" )) return do_mpmusicaround; if ( !str_cmp( name, "do_mpmusicat" )) return do_mpmusicat; if ( !str_cmp( name, "do_mpnothing" )) return do_mpnothing; if ( !str_cmp( name, "do_mpoload" )) return do_mpoload; if ( !str_cmp( name, "do_mposet" )) return do_mposet; if ( !str_cmp( name, "do_mppardon" )) return do_mppardon; if ( !str_cmp( name, "do_mppeace" )) return do_mppeace; if ( !str_cmp( name, "do_mppkset" )) return do_mppkset; if ( !str_cmp( name, "do_mppurge" )) return do_mppurge; if ( !str_cmp( name, "do_mpscatter" )) return do_mpscatter; if ( !str_cmp( name, "do_mpsound" )) return do_mpsound; if ( !str_cmp( name, "do_mpsoundaround" )) return do_mpsoundaround; if ( !str_cmp( name, "do_mpsoundat" )) return do_mpsoundat; if ( !str_cmp( name, "do_mpstat" )) return do_mpstat; if ( !str_cmp( name, "do_mptake" )) return do_mptake; if ( !str_cmp( name, "do_mpteach" )) return do_mpteach; if ( !str_cmp( name, "do_mptransfer" )) return do_mptransfer; if ( !str_cmp( name, "do_mpunmorph" )) return do_mpunmorph; if ( !str_cmp( name, "do_mpunnuisance" )) return do_mpunnuisance; if ( !str_cmp( name, "do_mpvalue" )) return do_mpvalue; if ( !str_cmp( name, "do_mrange" )) return do_mrange; if ( !str_cmp( name, "do_mset" )) return do_mset; if ( !str_cmp( name, "do_mstat" )) return do_mstat; if ( !str_cmp( name, "do_muse" )) return do_muse; if ( !str_cmp( name, "do_music" )) return do_music; if ( !str_cmp( name, "do_mwhere" )) return do_mwhere; if ( !str_cmp( name, "do_mxp" )) return do_mxp; break; case 'n': if ( !str_cmp( name, "do_name" )) return do_name; if ( !str_cmp( name, "do_neckchop" )) return do_neckchop; if ( !str_cmp( name, "do_neckpinch" )) return do_neckpinch; if ( !str_cmp( name, "do_neckrupture" )) return do_neckrupture; if ( !str_cmp( name, "do_nervepinch" )) return do_nervepinch; if ( !str_cmp( name, "do_nervestrike" )) return do_nervestrike; if ( !str_cmp( name, "do_newbiechat" )) return do_newbiechat; if ( !str_cmp( name, "do_newbieset" )) return do_newbieset; if ( !str_cmp( name, "do_news" )) return do_news; if ( !str_cmp( name, "do_newscore" )) return do_newscore; if ( !str_cmp( name, "do_newzones" )) return do_newzones; if ( !str_cmp( name, "do_niburo" )) return do_niburo; if ( !str_cmp( name, "do_nock" )) return do_nock; if ( !str_cmp( name, "do_noemote" )) return do_noemote; if ( !str_cmp( name, "do_noresolve" )) return do_noresolve; if ( !str_cmp( name, "do_north" )) return do_north; if ( !str_cmp( name, "do_northeast" )) return do_northeast; if ( !str_cmp( name, "do_northwest" )) return do_northwest; if ( !str_cmp( name, "do_notell" )) return do_notell; if ( !str_cmp( name, "do_noteroom" )) return do_noteroom; if ( !str_cmp( name, "do_notitle" )) return do_notitle; if ( !str_cmp( name, "do_npcrace" )) return do_npcrace; if ( !str_cmp( name, "do_nuisance" )) return do_nuisance; if ( !str_cmp( name, "do_nuisance" )) return do_nuisance; break; case 'o': if ( !str_cmp( name, "do_oassign" )) return do_oassign; if ( !str_cmp( name, "do_ocreate" )) return do_ocreate; if ( !str_cmp( name, "do_odelete" )) return do_odelete; if ( !str_cmp( name, "do_offered" )) return do_offered; if ( !str_cmp( name, "do_offername" )) return do_offername; if ( !str_cmp( name, "do_offers" )) return do_offers; if ( !str_cmp( name, "do_ofind" )) return do_ofind; if ( !str_cmp( name, "do_ogrub" )) return do_ogrub; if ( !str_cmp( name, "do_oinvoke" )) return do_oinvoke; if ( !str_cmp( name, "do_oldscore" )) return do_oldscore; if ( !str_cmp( name, "do_olist" )) return do_olist; if ( !str_cmp( name, "do_opedit" )) return do_opedit; if ( !str_cmp( name, "do_open" )) return do_open; // if ( !str_cmp( name, "do_opentourney" )) return do_opentourney; if ( !str_cmp( name, "do_opstat" )) return do_opstat; if ( !str_cmp( name, "do_orange" )) return do_orange; if ( !str_cmp( name, "do_order" )) return do_order; if ( !str_cmp( name, "do_orders" )) return do_orders; if ( !str_cmp( name, "do_ordertalk" )) return do_ordertalk; if ( !str_cmp( name, "do_oscatter" )) return do_oscatter; if ( !str_cmp( name, "do_oset" )) return do_oset; if ( !str_cmp( name, "do_ostat" )) return do_ostat; if ( !str_cmp( name, "do_outcast" )) return do_outcast; if ( !str_cmp( name, "do_owhere" )) return do_owhere; break; case 'p': if ( !str_cmp( name, "do_pager" )) return do_pager; if ( !str_cmp( name, "do_pardon" )) return do_pardon; if ( !str_cmp( name, "do_parry" )) return do_parry; if ( !str_cmp( name, "do_password" )) return do_password; if ( !str_cmp( name, "do_pcrename" )) return do_pcrename; if ( !str_cmp( name, "do_pcshops" )) return do_pcshops; if ( !str_cmp( name, "do_peace" )) return do_peace; if ( !str_cmp( name, "do_peasant" )) return do_peasant; if ( !str_cmp( name, "do_perfectshot" )) return do_perfectshot; if ( !str_cmp( name, "do_pfiles" )) return do_pfiles; if ( !str_cmp( name, "do_pick" )) return do_pick; if ( !str_cmp( name, "do_piggyback" )) return do_piggyback; if ( !str_cmp( name, "do_pincer" )) return do_pincer; if ( !str_cmp( name, "do_pkillcheck" )) return do_pkillcheck; if ( !str_cmp( name, "do_placemob" )) return do_placemob; if ( !str_cmp( name, "do_placeobj" )) return do_placeobj; if ( !str_cmp( name, "do_placetrainer" )) return do_placetrainer; if ( !str_cmp( name, "do_plist" )) return do_plist; if ( !str_cmp( name, "do_poison_weapon" )) return do_poison_weapon; if ( !str_cmp( name, "do_portal" )) return do_portal; if ( !str_cmp( name, "do_powerslice" )) return do_powerslice; if ( !str_cmp( name, "do_pretitle" )) return do_pretitle; if ( !str_cmp( name, "do_project" )) return do_project; if ( !str_cmp( name, "do_prompt" )) return do_prompt; if ( !str_cmp( name, "do_pset" )) return do_pset; if ( !str_cmp( name, "do_pstat" )) return do_pstat; if ( !str_cmp( name, "do_pstatus" )) return do_pstatus; if ( !str_cmp( name, "do_pull" )) return do_pull; if ( !str_cmp( name, "do_purge" )) return do_purge; if ( !str_cmp( name, "do_push" )) return do_push; if ( !str_cmp( name, "do_put" )) return do_put; break; case 'q': if ( !str_cmp( name, "do_qmob" )) return do_qmob; if ( !str_cmp( name, "do_qobj" )) return do_qobj; if ( !str_cmp( name, "do_qpset" )) return do_qpset; if ( !str_cmp( name, "do_qpstat" )) return do_qpstat; if ( !str_cmp( name, "do_quaff" )) return do_quaff; if ( !str_cmp( name, "do_qui" )) return do_qui; if ( !str_cmp( name, "do_quickcombo" )) return do_quickcombo; if ( !str_cmp( name, "do_quit" )) return do_quit; break; case 'r': if ( !str_cmp( name, "do_racetalk" )) return do_racetalk; if ( !str_cmp( name, "do_rank" )) return do_rank; if ( !str_cmp( name, "do_rankings" )) return do_rankings; if ( !str_cmp( name, "do_rap" )) return do_rap; if ( !str_cmp( name, "do_rassign" )) return do_rassign; if ( !str_cmp( name, "do_rat" )) return do_rat; if ( !str_cmp( name, "do_rdelete" )) return do_rdelete; if ( !str_cmp( name, "do_reboo" )) return do_reboo; if ( !str_cmp( name, "do_reboot" )) return do_reboot; if ( !str_cmp( name, "do_recall" )) return do_recall; if ( !str_cmp( name, "do_recho" )) return do_recho; if ( !str_cmp( name, "do_recite" )) return do_recite; if ( !str_cmp( name, "do_redit" )) return do_redit; if ( !str_cmp( name, "do_regoto" )) return do_regoto; if ( !str_cmp( name, "do_remains" )) return do_remains; if ( !str_cmp( name, "do_remove" )) return do_remove; if ( !str_cmp( name, "do_removekingdom" )) return do_removekingdom; if ( !str_cmp( name, "do_removetown" )) return do_removetown; if ( !str_cmp( name, "do_rent" )) return do_rent; if ( !str_cmp( name, "do_repair" )) return do_repair; if ( !str_cmp( name, "do_repairset" )) return do_repairset; if ( !str_cmp( name, "do_repairshops" )) return do_repairshops; if ( !str_cmp( name, "do_repairstat" )) return do_repairstat; if ( !str_cmp( name, "do_repairwall" )) return do_repairwall; if ( !str_cmp( name, "do_repeat" )) return do_repeat; if ( !str_cmp( name, "do_reply" )) return do_reply; if ( !str_cmp( name, "do_report" )) return do_report; if ( !str_cmp( name, "do_rescue" )) return do_rescue; if ( !str_cmp( name, "do_reserve" )) return do_reserve; if ( !str_cmp( name, "do_reset" )) return do_reset; if ( !str_cmp( name, "do_resetkeeper" )) return do_resetkeeper; if ( !str_cmp( name, "do_rest" )) return do_rest; if ( !str_cmp( name, "do_restore" )) return do_restore; if ( !str_cmp( name, "do_restorelimbs" )) return do_restorelimbs; if ( !str_cmp( name, "do_restoretime" )) return do_restoretime; if ( !str_cmp( name, "do_restrict" )) return do_restrict; if ( !str_cmp( name, "do_resurrection" )) return do_resurrection; if ( !str_cmp( name, "do_retell" )) return do_retell; if ( !str_cmp( name, "do_retire" )) return do_retire; if ( !str_cmp( name, "do_retran" )) return do_retran; if ( !str_cmp( name, "do_return" )) return do_return; if ( !str_cmp( name, "do_reward" )) return do_reward; if ( !str_cmp( name, "do_rgrub" )) return do_rgrub; if ( !str_cmp( name, "do_ribpuncture" )) return do_ribpuncture; if ( !str_cmp( name, "do_rip" )) return do_rip; if ( !str_cmp( name, "do_rlist" )) return do_rlist; if ( !str_cmp( name, "do_roar" )) return do_roar; if ( !str_cmp( name, "do_roll" )) return do_roll; if ( !str_cmp( name, "do_roomstat" )) return do_roomstat; if ( !str_cmp( name, "do_roundhouse" )) return do_roundhouse; if ( !str_cmp( name, "do_rpedit" )) return do_rpedit; if ( !str_cmp( name, "do_rpstat" )) return do_rpstat; if ( !str_cmp( name, "do_rreset" )) return do_rreset; if ( !str_cmp( name, "do_rset" )) return do_rset; if ( !str_cmp( name, "do_rstat" )) return do_rstat; if ( !str_cmp( name, "do_rub" )) return do_rub; if ( !str_cmp( name, "do_run" )) return do_run; break; case 's': if ( !str_cmp( name, "do_sacrifice" )) return do_sacrifice; if ( !str_cmp( name, "do_save" )) return do_save; if ( !str_cmp( name, "do_savearea" )) return do_savearea; if ( !str_cmp( name, "do_say" )) return do_say; if ( !str_cmp( name, "do_say_to_char" )) return do_say_to_char; if ( !str_cmp( name, "do_sbook" )) return do_sbook; if ( !str_cmp( name, "do_scan" )) return do_scan; if ( !str_cmp( name, "do_scatter" )) return do_scatter; if ( !str_cmp( name, "do_schedule" )) return do_schedule; if ( !str_cmp( name, "do_score" )) return do_score; if ( !str_cmp( name, "do_scribe" )) return do_scribe; if ( !str_cmp( name, "do_search" )) return do_search; if ( !str_cmp( name, "do_sedit" )) return do_sedit; if ( !str_cmp( name, "do_seeorders" )) return do_seeorders; if ( !str_cmp( name, "do_sell" )) return do_sell; if ( !str_cmp( name, "do_sendmail" )) return do_sendmail; if ( !str_cmp( name, "do_set_boot_time" )) return do_set_boot_time; if ( !str_cmp( name, "do_setcaste" )) return do_setcaste; if ( !str_cmp( name, "do_setclan" )) return do_setclan; if ( !str_cmp( name, "do_setcouncil" )) return do_setcouncil; if ( !str_cmp( name, "do_setdeity" )) return do_setdeity; if ( !str_cmp( name, "do_setfree" )) return do_setfree; if ( !str_cmp( name, "do_setgambler" )) return do_setgambler; if ( !str_cmp( name, "do_setgem" )) return do_setgem; if ( !str_cmp( name, "do_setjob" )) return do_setjob; if ( !str_cmp( name, "do_setkingdom" )) return do_setkingdom; if ( !str_cmp( name, "do_setrace" )) return do_setrace; if ( !str_cmp( name, "do_setslay" )) return do_setslay; if ( !str_cmp( name, "do_settoadvance" )) return do_settoadvance; if ( !str_cmp( name, "do_setweather" )) return do_setweather; if ( !str_cmp( name, "do_setwilderness" )) return do_setwilderness; if ( !str_cmp( name, "do_sheath" )) return do_sheath; if ( !str_cmp( name, "do_shells" )) return do_shells; if ( !str_cmp( name, "do_ships" )) return do_ships; if ( !str_cmp( name, "do_shops" )) return do_shops; if ( !str_cmp( name, "do_shopset" )) return do_shopset; if ( !str_cmp( name, "do_shopstat" )) return do_shopstat; if ( !str_cmp( name, "do_shout" )) return do_shout; if ( !str_cmp( name, "do_shove" )) return do_shove; if ( !str_cmp( name, "do_show" )) return do_show; if ( !str_cmp( name, "do_showascii" )) return do_showascii; if ( !str_cmp( name, "do_showclan" )) return do_showclan; if ( !str_cmp( name, "do_showcontrol" )) return do_showcontrol; if ( !str_cmp( name, "do_showcouncil" )) return do_showcouncil; if ( !str_cmp( name, "do_showdeity" )) return do_showdeity; if ( !str_cmp( name, "do_showentrances" )) return do_showentrances; if ( !str_cmp( name, "do_showgambler" )) return do_showgambler; if ( !str_cmp( name, "do_showhouse" )) return do_showhouse; if ( !str_cmp( name, "do_showkingdoms" )) return do_showkingdoms; if ( !str_cmp( name, "do_showlayers" )) return do_showlayers; if ( !str_cmp( name, "do_showlist" )) return do_showlist; if ( !str_cmp( name, "do_showpic" )) return do_showpic; if ( !str_cmp( name, "do_showrace" )) return do_showrace; if ( !str_cmp( name, "do_showresources" )) return do_showresources; if ( !str_cmp( name, "do_showslay" )) return do_showslay; if ( !str_cmp( name, "do_showweather" )) return do_showweather; if ( !str_cmp( name, "do_shutdow" )) return do_shutdow; if ( !str_cmp( name, "do_shutdown" )) return do_shutdown; if ( !str_cmp( name, "do_sidekick" )) return do_sidekick; if ( !str_cmp( name, "do_silence" )) return do_silence; if ( !str_cmp( name, "do_sing" )) return do_sing; if ( !str_cmp( name, "do_sit" )) return do_sit; if ( !str_cmp( name, "do_skills" )) return do_skills; if ( !str_cmp( name, "do_skin" )) return do_skin; if ( !str_cmp( name, "do_sla" )) return do_sla; if ( !str_cmp( name, "do_slay" )) return do_slay; if ( !str_cmp( name, "do_sleep" )) return do_sleep; if ( !str_cmp( name, "do_slice" )) return do_slice; if ( !str_cmp( name, "do_slist" )) return do_slist; if ( !str_cmp( name, "do_slookup" )) return do_slookup; if ( !str_cmp( name, "do_smoke" )) return do_smoke; if ( !str_cmp( name, "do_snoop" )) return do_snoop; if ( !str_cmp( name, "do_sober" )) return do_sober; if ( !str_cmp( name, "do_socials" )) return do_socials; if ( !str_cmp( name, "do_south" )) return do_south; if ( !str_cmp( name, "do_southeast" )) return do_southeast; if ( !str_cmp( name, "do_southwest" )) return do_southwest; if ( !str_cmp( name, "do_spar" )) return do_spar; if ( !str_cmp( name, "do_speak" )) return do_speak; if ( !str_cmp( name, "do_spear" )) return do_spear; if ( !str_cmp( name, "do_speed" )) return do_speed; if ( !str_cmp( name, "do_spinkick" )) return do_spinkick; if ( !str_cmp( name, "do_split" )) return do_split; if ( !str_cmp( name, "do_sset" )) return do_sset; if ( !str_cmp( name, "do_sslist" )) return do_sslist; if ( !str_cmp( name, "do_stable" )) return do_stable; if ( !str_cmp( name, "do_stack" )) return do_stack; if ( !str_cmp( name, "do_stalk" )) return do_stalk; if ( !str_cmp( name, "do_stand" )) return do_stand; if ( !str_cmp( name, "do_startarena" )) return do_startarena; if ( !str_cmp( name, "do_startfire" )) return do_startfire; if ( !str_cmp( name, "do_startkingdom" )) return do_startkingdom; if ( !str_cmp( name, "do_startroom" )) return do_startroom; if ( !str_cmp( name, "do_stat" )) return do_stat; if ( !str_cmp( name, "do_statreport" )) return do_statreport; if ( !str_cmp( name, "do_steal" )) return do_steal; if ( !str_cmp( name, "do_steership" )) return do_steership; if ( !str_cmp( name, "do_stepback" )) return do_stepback; if ( !str_cmp( name, "do_strew" )) return do_strew; if ( !str_cmp( name, "do_strip" )) return do_strip; if ( !str_cmp( name, "do_study" )) return do_study; if ( !str_cmp( name, "do_stun" )) return do_stun; if ( !str_cmp( name, "do_style" )) return do_style; if ( !str_cmp( name, "do_supplicate" )) return do_supplicate; if ( !str_cmp( name, "do_survey" )) return do_survey; if ( !str_cmp( name, "do_switch" )) return do_switch; break; case 't': if ( !str_cmp( name, "do_talent" )) return do_talent; if ( !str_cmp( name, "do_talkquest" )) return do_talkquest; if ( !str_cmp( name, "do_tamp" )) return do_tamp; if ( !str_cmp( name, "do_target" )) return do_target; if ( !str_cmp( name, "do_tcreate" )) return do_tcreate; if ( !str_cmp( name, "do_tdelete" )) return do_tdelete; if ( !str_cmp( name, "do_tell" )) return do_tell; if ( !str_cmp( name, "do_terraform" )) return do_terraform; if ( !str_cmp( name, "do_think" )) return do_think; if ( !str_cmp( name, "do_time" )) return do_time; if ( !str_cmp( name, "do_timecmd" )) return do_timecmd; if ( !str_cmp( name, "do_timmuru" )) return do_timmuru; if ( !str_cmp( name, "do_tinduct" )) return do_tinduct; if ( !str_cmp( name, "do_title" )) return do_title; if ( !str_cmp( name, "do_tkickout" )) return do_tkickout; if ( !str_cmp( name, "do_tone" )) return do_tone; if ( !str_cmp( name, "do_tornadokick" )) return do_tornadokick; if ( !str_cmp( name, "do_toss" )) return do_toss; if ( !str_cmp( name, "do_track" )) return do_track; if ( !str_cmp( name, "do_tradegoods" )) return do_tradegoods; if ( !str_cmp( name, "do_traderoutes" )) return do_traderoutes; if ( !str_cmp( name, "do_training" )) return do_training; if ( !str_cmp( name, "do_trans" )) return do_trans; if ( !str_cmp( name, "do_transfer" )) return do_transfer; if ( !str_cmp( name, "do_trap" )) return do_trap; if ( !str_cmp( name, "do_trust" )) return do_trust; if ( !str_cmp( name, "do_tset" )) return do_tset; if ( !str_cmp( name, "do_tstat" )) return do_tstat; if ( !str_cmp( name, "do_tumble" )) return do_tumble; if ( !str_cmp( name, "do_typo" )) return do_typo; break; case 'u': if ( !str_cmp( name, "do_unfoldarea" )) return do_unfoldarea; if ( !str_cmp( name, "do_unhell" )) return do_unhell; if ( !str_cmp( name, "do_unloadqarea" )) return do_unloadqarea; if ( !str_cmp( name, "do_unlock" )) return do_unlock; if ( !str_cmp( name, "do_unnuisance" )) return do_unnuisance; if ( !str_cmp( name, "do_unsilence" )) return do_unsilence; if ( !str_cmp( name, "do_up" )) return do_up; if ( !str_cmp( name, "do_updatearea" )) return do_updatearea; if ( !str_cmp( name, "do_updateskills" )) return do_updateskills; if ( !str_cmp( name, "do_uselicense" )) return do_uselicense; if ( !str_cmp( name, "do_users" )) return do_users; break; case 'v': if ( !str_cmp( name, "do_value" )) return do_value; if ( !str_cmp( name, "do_vassign" )) return do_vassign; if ( !str_cmp( name, "do_version" )) return do_version; if ( !str_cmp( name, "do_victories" )) return do_victories; if ( !str_cmp( name, "do_viewmount" )) return do_viewmount; if ( !str_cmp( name, "do_viewskills" )) return do_viewskills; if ( !str_cmp( name, "do_visible" )) return do_visible; if ( !str_cmp( name, "do_vnums" )) return do_vnums; if ( !str_cmp( name, "do_vsearch" )) return do_vsearch; break; case 'w': if ( !str_cmp( name, "do_wake" )) return do_wake; if ( !str_cmp( name, "do_warn" )) return do_warn; if ( !str_cmp( name, "do_wartalk" )) return do_wartalk; if ( !str_cmp( name, "do_watch" )) return do_watch; if ( !str_cmp( name, "do_wblock" )) return do_wblock; if ( !str_cmp( name, "do_weaponbreak" )) return do_weaponbreak; if ( !str_cmp( name, "do_wear" )) return do_wear; if ( !str_cmp( name, "do_weather" )) return do_weather; if ( !str_cmp( name, "do_webstats" )) return do_webstats; if ( !str_cmp( name, "do_west" )) return do_west; if ( !str_cmp( name, "do_where" )) return do_where; if ( !str_cmp( name, "do_whisper" )) return do_whisper; if ( !str_cmp( name, "do_who" )) return do_who; if ( !str_cmp( name, "do_whois" )) return do_whois; if ( !str_cmp( name, "do_whonumber" )) return do_whonumber; if ( !str_cmp( name, "do_wimpy" )) return do_wimpy; if ( !str_cmp( name, "do_withdraw" )) return do_withdraw; if ( !str_cmp( name, "do_wizhelp" )) return do_wizhelp; if ( !str_cmp( name, "do_wizlist" )) return do_wizlist; if ( !str_cmp( name, "do_wizlock" )) return do_wizlock; if ( !str_cmp( name, "do_wizzap" )) return do_wizzap; if ( !str_cmp( name, "do_worth" )) return do_worth; break; case 'y': if ( !str_cmp( name, "do_yell" )) return do_yell; break; case 'z': if ( !str_cmp( name, "do_zap" )) return do_zap; if ( !str_cmp( name, "do_zones" )) return do_zones; break; /*//T2*/ } return skill_notfound; } char *spell_name(SPELL_FUN * spell) { if (spell == spell_smaug) return "spell_smaug"; if (spell == spell_eye_of_god) return "spell_eye_of_god"; if (spell == spell_resurrection) return "spell_resurrection"; if (spell == spell_summon_corpse) return "spell_summon_corpse"; if (spell == spell_greater_resurrection) return "spell_greater_resurrection"; if (spell == spell_lesser_resurrection) return "spell_lesser_resurrection"; if (spell == spell_web) return "spell_web"; if (spell == spell_revitalize_spirit) return "spell_revitalize_spirit"; if (spell == spell_snare) return "spell_snare"; if (spell == spell_extradimensional_portal) return "spell_extradimensional_portal"; if (spell == spell_animate_dead) return "spell_animate_dead"; if (spell == spell_astral_walk) return "spell_astral_walk"; if (spell == spell_blindness) return "spell_blindness"; if (spell == spell_cause_critical) return "spell_cause_critical"; if (spell == spell_restore_limb) return "spell_restore_limb"; if (spell == spell_revitalize_limb) return "spell_revitalize_limb"; if (spell == spell_cause_light) return "spell_cause_light"; if (spell == spell_cause_serious) return "spell_cause_serious"; if (spell == spell_charm_person) return "spell_charm_person"; if (spell == spell_create_food) return "spell_create_food"; if (spell == spell_create_water) return "spell_create_water"; if (spell == spell_bless_weapon) return "spell_bless_weapon"; if (spell == spell_cure_blindness) return "spell_cure_blindness"; if (spell == spell_cure_poison) return "spell_cure_poison"; if (spell == spell_curse) return "spell_curse"; if (spell == spell_detect_poison) return "spell_detect_poison"; if (spell == spell_disenchant_weapon) return "spell_disenchant_weapon"; if (spell == spell_dispel_magic) return "spell_dispel_magic"; if (spell == spell_earthquake) return "spell_earthquake"; if (spell == spell_enchant_weapon) return "spell_enchant_weapon"; if (spell == spell_faerie_fire) return "spell_faerie_fire"; if (spell == spell_faerie_fog) return "spell_faerie_fog"; if (spell == spell_farsight) return "spell_farsight"; if (spell == spell_knock) return "spell_knock"; if (spell == spell_harm) return "spell_harm"; if (spell == spell_holy_food) return "spell_holy_food"; if (spell == spell_identify) return "spell_identify"; if (spell == spell_invis) return "spell_invis"; if (spell == spell_knowenemy) return "spell_knowenemy"; if (spell == spell_locate_object) return "spell_locate_object"; if (spell == spell_pass_door) return "spell_pass_door"; if (spell == spell_poison) return "spell_poison"; if (spell == spell_polymorph) return "spell_polymorph"; if (spell == spell_possess) return "spell_possess"; if (spell == spell_recharge) return "spell_recharge"; if (spell == spell_remove_curse) return "spell_remove_curse"; if (spell == spell_remove_invis) return "spell_remove_invis"; if (spell == spell_remove_trap) return "spell_remove_trap"; if (spell == spell_sleep) return "spell_sleep"; if (spell == spell_summon) return "spell_summon"; if (spell == spell_weaken) return "spell_weaken"; if (spell == spell_word_of_recall) return "spell_word_of_recall"; if (spell == spell_acid_breath) return "spell_acid_breath"; if (spell == spell_fire_breath) return "spell_fire_breath"; if (spell == spell_frost_breath) return "spell_frost_breath"; if (spell == spell_gas_breath) return "spell_gas_breath"; if (spell == spell_lightning_breath) return "spell_lightning_breath"; if (spell == spell_bethsaidean_touch) return "spell_bethsaidean_touch"; if (spell == spell_expurgation) return "spell_expurgation"; if (spell == spell_sacral_divinity) return "spell_sacral_divinity"; if (spell == spell_wizard_eye) return "spell_wizard_eye"; if (spell == spell_holy_cleansing) return "spell_holy_cleansing"; if (spell == spell_null) return "spell_null"; return "reserved"; } char *skill_name(DO_FUN * skill) { static char buf[64]; if (skill == NULL) return "reserved"; /*//T3*/ if ( skill == do_aassign ) return "do_aassign"; if ( skill == do_accept ) return "do_accept"; if ( skill == do_accounts ) return "do_accounts"; if ( skill == do_add_imm_host ) return "do_add_imm_host"; if ( skill == do_addbox ) return "do_addbox"; if ( skill == do_addforge ) return "do_addforge"; if ( skill == do_addgem ) return "do_addgem"; if ( skill == do_addslab ) return "do_addslab"; if ( skill == do_advance ) return "do_advance"; if ( skill == do_advanceclock ) return "do_advanceclock"; if ( skill == do_affected ) return "do_affected"; if ( skill == do_afk ) return "do_afk"; if ( skill == do_ahall ) return "do_ahall"; if ( skill == do_ahelp ) return "do_ahelp"; if ( skill == do_aid ) return "do_aid"; if ( skill == do_aim ) return "do_aim"; if ( skill == do_alias ) return "do_alias"; if ( skill == do_allow ) return "do_allow"; if ( skill == do_amberio ) return "do_amberio"; if ( skill == do_ansi ) return "do_ansi"; if ( skill == do_answer ) return "do_answer"; if ( skill == do_apply ) return "do_apply"; if ( skill == do_appraise ) return "do_appraise"; if ( skill == do_areas ) return "do_areas"; if ( skill == do_arena ) return "do_arena"; if ( skill == do_armmilitary ) return "do_armmilitary"; if ( skill == do_aset ) return "do_aset"; if ( skill == do_ask ) return "do_ask"; if ( skill == do_assassinate ) return "do_assassinate"; if ( skill == do_astat ) return "do_astat"; if ( skill == do_at ) return "do_at"; if ( skill == do_atmob ) return "do_atmob"; if ( skill == do_atobj ) return "do_atobj"; if ( skill == do_attack ) return "do_attack"; if ( skill == do_auction ) return "do_auction"; if ( skill == do_authorize ) return "do_authorize"; if ( skill == do_avtalk ) return "do_avtalk"; if ( skill == do_awho ) return "do_awho"; if ( skill == do_backstab ) return "do_backstab"; if ( skill == do_balance ) return "do_balance"; if ( skill == do_balzhur ) return "do_balzhur"; if ( skill == do_bamfin ) return "do_bamfin"; if ( skill == do_bamfout ) return "do_bamfout"; if ( skill == do_ban ) return "do_ban"; if ( skill == do_bash ) return "do_bash"; if ( skill == do_bashdoor ) return "do_bashdoor"; if ( skill == do_bcard ) return "do_bcard"; if ( skill == do_beep ) return "do_beep"; if ( skill == do_begging ) return "do_begging"; if ( skill == do_berserk ) return "do_berserk"; if ( skill == do_bestow ) return "do_bestow"; if ( skill == do_bestowarea ) return "do_bestowarea"; if ( skill == do_bet ) return "do_bet"; if ( skill == do_bhold ) return "do_bhold"; if ( skill == do_bio ) return "do_bio"; if ( skill == do_blackjack ) return "do_blackjack"; if ( skill == do_blitz ) return "do_blitz"; if ( skill == do_blockmove ) return "do_blockmove"; if ( skill == do_boards ) return "do_boards"; if ( skill == do_bodybag ) return "do_bodybag"; if ( skill == do_brandish ) return "do_brandish"; if ( skill == do_break ) return "do_break"; if ( skill == do_breakwall ) return "do_breakwall"; if ( skill == do_brew ) return "do_brew"; if ( skill == do_bset ) return "do_bset"; if ( skill == do_bstat ) return "do_bstat"; if ( skill == do_bug ) return "do_bug"; if ( skill == do_build ) return "do_build"; if ( skill == do_buildroom ) return "do_buildroom"; if ( skill == do_bury ) return "do_bury"; if ( skill == do_buy ) return "do_buy"; if ( skill == do_buycaste ) return "do_buycaste"; if ( skill == do_cache ) return "do_cache"; if ( skill == do_calmmount ) return "do_calmmount"; if ( skill == do_carrybin ) return "do_carrybin"; if ( skill == do_cast ) return "do_cast"; if ( skill == do_caste ) return "do_caste"; if ( skill == do_castevalues ) return "do_castevalues"; if ( skill == do_cedit ) return "do_cedit"; if ( skill == do_challenge ) return "do_challenge"; if ( skill == do_changes ) return "do_changes"; if ( skill == do_channels ) return "do_channels"; if ( skill == do_chaos ) return "do_chaos"; if ( skill == do_chat ) return "do_chat"; if ( skill == do_check_vnums ) return "do_check_vnums"; if ( skill == do_chistory ) return "do_chistory"; if ( skill == do_circle ) return "do_circle"; if ( skill == do_cityvalues ) return "do_cityvalues"; if ( skill == do_clans ) return "do_clans"; if ( skill == do_clantalk ) return "do_clantalk"; if ( skill == do_cleansing ) return "do_cleansing"; if ( skill == do_clearques ) return "do_clearques"; if ( skill == do_clearstack ) return "do_clearstack"; if ( skill == do_climate ) return "do_climate"; if ( skill == do_climb ) return "do_climb"; if ( skill == do_climbwall ) return "do_climbwall"; if ( skill == do_cloak ) return "do_cloak"; if ( skill == do_clones ) return "do_clones"; if ( skill == do_close ) return "do_close"; if ( skill == do_cmdtable ) return "do_cmdtable"; if ( skill == do_color ) return "do_color"; if ( skill == do_command ) return "do_command"; if ( skill == do_commands ) return "do_commands"; if ( skill == do_comment ) return "do_comment"; if ( skill == do_compare ) return "do_compare"; if ( skill == do_compress ) return "do_compress"; if ( skill == do_config ) return "do_config"; if ( skill == do_conquer ) return "do_conquer"; if ( skill == do_consent ) return "do_consent"; if ( skill == do_consider ) return "do_consider"; if ( skill == do_cook ) return "do_cook"; if ( skill == do_coords ) return "do_coords"; if ( skill == do_copyover ) return "do_copyover"; if ( skill == do_council_induct ) return "do_council_induct"; if ( skill == do_council_outcast ) return "do_council_outcast"; if ( skill == do_councils ) return "do_councils"; if ( skill == do_counciltalk ) return "do_counciltalk"; if ( skill == do_counter ) return "do_counter"; if ( skill == do_credits ) return "do_credits"; if ( skill == do_cset ) return "do_cset"; if ( skill == do_cutgag ) return "do_cutgag"; if ( skill == do_cutpurse ) return "do_cutpurse"; if ( skill == do_daze ) return "do_daze"; if ( skill == do_declare ) return "do_declare"; if ( skill == do_decline ) return "do_decline"; if ( skill == do_deities ) return "do_deities"; if ( skill == do_delay ) return "do_delay"; if ( skill == do_delet ) return "do_delet"; if ( skill == do_delete ) return "do_delete"; if ( skill == do_deny ) return "do_deny"; if ( skill == do_deposit ) return "do_deposit"; if ( skill == do_depository ) return "do_depository"; if ( skill == do_description ) return "do_description"; if ( skill == do_deshield ) return "do_deshield"; if ( skill == do_destro ) return "do_destro"; if ( skill == do_destroy ) return "do_destroy"; if ( skill == do_destroyslay ) return "do_destroyslay"; if ( skill == do_detrap ) return "do_detrap"; if ( skill == do_devote ) return "do_devote"; if ( skill == do_diagnose ) return "do_diagnose"; if ( skill == do_dig ) return "do_dig"; if ( skill == do_disarm ) return "do_disarm"; if ( skill == do_disconnect ) return "do_disconnect"; if ( skill == do_dislodge ) return "do_dislodge"; if ( skill == do_dismiss ) return "do_dismiss"; if ( skill == do_dismount ) return "do_dismount"; if ( skill == do_dmesg ) return "do_dmesg"; if ( skill == do_dodge ) return "do_dodge"; if ( skill == do_down ) return "do_down"; if ( skill == do_drag ) return "do_drag"; if ( skill == do_draw ) return "do_draw"; if ( skill == do_drink ) return "do_drink"; if ( skill == do_drive ) return "do_drive"; if ( skill == do_drop ) return "do_drop"; if ( skill == do_duel ) return "do_duel"; if ( skill == do_dumpgoods ) return "do_dumpgoods"; if ( skill == do_east ) return "do_east"; if ( skill == do_eat ) return "do_eat"; if ( skill == do_echo ) return "do_echo"; if ( skill == do_elbowbreak ) return "do_elbowbreak"; if ( skill == do_elbowjab ) return "do_elbowjab"; if ( skill == do_elbowstab ) return "do_elbowstab"; if ( skill == do_email ) return "do_email"; if ( skill == do_emeru ) return "do_emeru"; if ( skill == do_emote ) return "do_emote"; if ( skill == do_empty ) return "do_empty"; if ( skill == do_emptycorpses ) return "do_emptycorpses"; if ( skill == do_enter ) return "do_enter"; if ( skill == do_enhance ) return "do_enhance"; if ( skill == do_entership ) return "do_entership"; if ( skill == do_equipment ) return "do_equipment"; if ( skill == do_examine ) return "do_examine"; if ( skill == do_exits ) return "do_exits"; if ( skill == do_extract ) return "do_extract"; if ( skill == do_feedmount ) return "do_feedmount"; if ( skill == do_fightoutput ) return "do_fightoutput"; if ( skill == do_fill ) return "do_fill"; if ( skill == do_findnote ) return "do_findnote"; if ( skill == do_finger ) return "do_finger"; if ( skill == do_fire ) return "do_fire"; if ( skill == do_fix ) return "do_fix"; if ( skill == do_fixchar ) return "do_fixchar"; if ( skill == do_fixed ) return "do_fixed"; if ( skill == do_fixgemslots ) return "do_fixgemslots"; if ( skill == do_flee ) return "do_flee"; if ( skill == do_flevel ) return "do_flevel"; if ( skill == do_flipcoin ) return "do_flipcoin"; if ( skill == do_foldarea ) return "do_foldarea"; if ( skill == do_foldqarea ) return "do_foldqarea"; if ( skill == do_follow ) return "do_follow"; if ( skill == do_for ) return "do_for"; if ( skill == do_forage ) return "do_forage"; if ( skill == do_force ) return "do_force"; if ( skill == do_forceclose ) return "do_forceclose"; if ( skill == do_forecast ) return "do_forecast"; if ( skill == do_forge ) return "do_forge"; if ( skill == do_forgealter ) return "do_forgealter"; if ( skill == do_forget ) return "do_forget"; if ( skill == do_form_password ) return "do_form_password"; if ( skill == do_fprompt ) return "do_fprompt"; if ( skill == do_fquit ) return "do_fquit"; if ( skill == do_free_vnums ) return "do_free_vnums"; if ( skill == do_freerooms ) return "do_freerooms"; if ( skill == do_freeze ) return "do_freeze"; if ( skill == do_gag ) return "do_gag"; if ( skill == do_gamereset ) return "do_gamereset"; if ( skill == do_gaso ) return "do_gaso"; if ( skill == do_gathertinder ) return "do_gathertinder"; if ( skill == do_gem ) return "do_gem"; if ( skill == do_generatename ) return "do_generatename"; if ( skill == do_get ) return "do_get"; if ( skill == do_getresources ) return "do_getresources"; if ( skill == do_gfighting ) return "do_gfighting"; if ( skill == do_give ) return "do_give"; if ( skill == do_givecrown ) return "do_givecrown"; if ( skill == do_giveorders ) return "do_giveorders"; if ( skill == do_giveup ) return "do_giveup"; if ( skill == do_glance ) return "do_glance"; if ( skill == do_global_boards ) return "do_global_boards"; if ( skill == do_global_note ) return "do_global_note"; if ( skill == do_goauth ) return "do_goauth"; if ( skill == do_gold ) return "do_gold"; if ( skill == do_goldgive ) return "do_goldgive"; if ( skill == do_goldtake ) return "do_goldtake"; if ( skill == do_goto ) return "do_goto"; if ( skill == do_gouge ) return "do_gouge"; if ( skill == do_gprompt ) return "do_gprompt"; if ( skill == do_grab ) return "do_grab"; if ( skill == do_grantlicense ) return "do_grantlicense"; if ( skill == do_grip ) return "do_grip"; if ( skill == do_group ) return "do_group"; if ( skill == do_grub ) return "do_grub"; if ( skill == do_gscore ) return "do_gscore"; if ( skill == do_gsocial ) return "do_gsocial"; if ( skill == do_gtell ) return "do_gtell"; if ( skill == do_guilds ) return "do_guilds"; if ( skill == do_guildtalk ) return "do_guildtalk"; if ( skill == do_gwhere ) return "do_gwhere"; if ( skill == do_heal ) return "do_heal"; if ( skill == do_hedit ) return "do_hedit"; if ( skill == do_hell ) return "do_hell"; if ( skill == do_help ) return "do_help"; if ( skill == do_helpcheck ) return "do_helpcheck"; if ( skill == do_helpweb ) return "do_helpweb"; if ( skill == do_hide ) return "do_hide"; if ( skill == do_hindex ) return "do_hindex"; if ( skill == do_hitall ) return "do_hitall"; if ( skill == do_hl ) return "do_hl"; if ( skill == do_hlist ) return "do_hlist"; if ( skill == do_holylight ) return "do_holylight"; if ( skill == do_homepage ) return "do_homepage"; if ( skill == do_hset ) return "do_hset"; if ( skill == do_huntportals ) return "do_huntportals"; if ( skill == do_icq_number ) return "do_icq_number"; if ( skill == do_ide ) return "do_ide"; if ( skill == do_idea ) return "do_idea"; if ( skill == do_ignore ) return "do_ignore"; if ( skill == do_imbue ) return "do_imbue"; if ( skill == do_imm_morph ) return "do_imm_morph"; if ( skill == do_imm_unmorph ) return "do_imm_unmorph"; if ( skill == do_immreminder ) return "do_immreminder"; if ( skill == do_immtalk ) return "do_immtalk"; if ( skill == do_induct ) return "do_induct"; if ( skill == do_installarea ) return "do_installarea"; if ( skill == do_instaroom ) return "do_instaroom"; if ( skill == do_instazone ) return "do_instazone"; if ( skill == do_insult ) return "do_insult"; if ( skill == do_insults ) return "do_insults"; if ( skill == do_introduce ) return "do_introduce"; if ( skill == do_inventory ) return "do_inventory"; if ( skill == do_invis ) return "do_invis"; if ( skill == do_ipcompare ) return "do_ipcompare"; if ( skill == do_jog ) return "do_jog"; if ( skill == do_joinkingdom ) return "do_joinkingdom"; if ( skill == do_junk ) return "do_junk"; if ( skill == do_keeperset ) return "do_keeperset"; if ( skill == do_keeperstat ) return "do_keeperstat"; if ( skill == do_keys ) return "do_keys"; if ( skill == do_khistory ) return "do_khistory"; if ( skill == do_kick_back ) return "do_kick_back"; if ( skill == do_kickdirt ) return "do_kickdirt"; if ( skill == do_kickout ) return "do_kickout"; if ( skill == do_kinduct ) return "do_kinduct"; if ( skill == do_kingdomlog ) return "do_kingdomlog"; if ( skill == do_kingdomtalk ) return "do_kingdomtalk"; if ( skill == do_kneecrusher ) return "do_kneecrusher"; if ( skill == do_kneestrike ) return "do_kneestrike"; if ( skill == do_kremove ) return "do_kremove"; if ( skill == do_languages ) return "do_languages"; if ( skill == do_last ) return "do_last"; if ( skill == do_lastname ) return "do_lastname"; if ( skill == do_laws ) return "do_laws"; if ( skill == do_learn ) return "do_learn"; if ( skill == do_leave ) return "do_leave"; if ( skill == do_leavekingdom ) return "do_leavekingdom"; if ( skill == do_leaveship ) return "do_leaveship"; if ( skill == do_lembecu ) return "do_lembecu"; if ( skill == do_light ) return "do_light"; if ( skill == do_list ) return "do_list"; if ( skill == do_listgroups ) return "do_listgroups"; if ( skill == do_listportals ) return "do_listportals"; if ( skill == do_litterbug ) return "do_litterbug"; if ( skill == do_loadarea ) return "do_loadarea"; if ( skill == do_loadgem ) return "do_loadgem"; if ( skill == do_loadquest ) return "do_loadquest"; if ( skill == do_loadup ) return "do_loadup"; if ( skill == do_lock ) return "do_lock"; if ( skill == do_log ) return "do_log"; if ( skill == do_logsettings ) return "do_logsettings"; if ( skill == do_look ) return "do_look"; if ( skill == do_lookaround ) return "do_lookaround"; if ( skill == do_lookmap ) return "do_lookmap"; if ( skill == do_loop ) return "do_loop"; if ( skill == do_lore ) return "do_lore"; if ( skill == do_low_purge ) return "do_low_purge"; if ( skill == do_mailroom ) return "do_mailroom"; if ( skill == do_make ) return "do_make"; if ( skill == do_make_wilderness_exits ) return "do_make_wilderness_exits"; if ( skill == do_make_wilderness_exits2 ) return "do_make_wilderness_exits2"; if ( skill == do_makeboard ) return "do_makeboard"; if ( skill == do_makeclan ) return "do_makeclan"; if ( skill == do_makecouncil ) return "do_makecouncil"; if ( skill == do_makedeity ) return "do_makedeity"; if ( skill == do_makekeeper ) return "do_makekeeper"; if ( skill == do_makerepair ) return "do_makerepair"; if ( skill == do_makeroom ) return "do_makeroom"; if ( skill == do_makeshop ) return "do_makeshop"; if ( skill == do_makeslay ) return "do_makeslay"; if ( skill == do_makestable ) return "do_makestable"; if ( skill == do_makewizlist ) return "do_makewizlist"; if ( skill == do_makeworker ) return "do_makeworker"; if ( skill == do_manaburst ) return "do_manaburst"; if ( skill == do_manashot ) return "do_manashot"; if ( skill == do_manatap ) return "do_manatap"; if ( skill == do_map ) return "do_map"; if ( skill == do_mapat ) return "do_mapat"; if ( skill == do_mapedit ) return "do_mapedit"; if ( skill == do_mapline ) return "do_mapline"; if ( skill == do_mapout ) return "do_mapout"; if ( skill == do_market ) return "do_market"; if ( skill == do_markportal ) return "do_markportal"; if ( skill == do_massgoto ) return "do_massgoto"; if ( skill == do_massign ) return "do_massign"; if ( skill == do_mcreate ) return "do_mcreate"; if ( skill == do_mdelete ) return "do_mdelete"; if ( skill == do_memory ) return "do_memory"; if ( skill == do_mfind ) return "do_mfind"; if ( skill == do_minfo ) return "do_minfo"; if ( skill == do_minvoke ) return "do_minvoke"; if ( skill == do_mixpotion ) return "do_mixpotion"; if ( skill == do_mlist ) return "do_mlist"; if ( skill == do_moblog ) return "do_moblog"; if ( skill == do_morgue ) return "do_morgue"; if ( skill == do_morphcreate ) return "do_morphcreate"; if ( skill == do_morphdestroy ) return "do_morphdestroy"; if ( skill == do_morphset ) return "do_morphset"; if ( skill == do_morphstat ) return "do_morphstat"; if ( skill == do_mortalize ) return "do_mortalize"; if ( skill == do_mount ) return "do_mount"; if ( skill == do_movement ) return "do_movement"; if ( skill == do_mp_close_passage ) return "do_mp_close_passage"; if ( skill == do_mp_damage ) return "do_mp_damage"; if ( skill == do_mp_deposit ) return "do_mp_deposit"; if ( skill == do_mp_fill_in ) return "do_mp_fill_in"; if ( skill == do_mp_log ) return "do_mp_log"; if ( skill == do_mp_open_passage ) return "do_mp_open_passage"; if ( skill == do_mp_practice ) return "do_mp_practice"; if ( skill == do_mp_restore ) return "do_mp_restore"; if ( skill == do_mp_slay ) return "do_mp_slay"; if ( skill == do_mp_withdraw ) return "do_mp_withdraw"; if ( skill == do_mpadvance ) return "do_mpadvance"; if ( skill == do_mpapply ) return "do_mpapply"; if ( skill == do_mpapplyb ) return "do_mpapplyb"; if ( skill == do_mpasound ) return "do_mpasound"; if ( skill == do_mpasupress ) return "do_mpasupress"; if ( skill == do_mpat ) return "do_mpat"; if ( skill == do_mpbodybag ) return "do_mpbodybag"; if ( skill == do_mpdelay ) return "do_mpdelay"; if ( skill == do_mpdream ) return "do_mpdream"; if ( skill == do_mpecho ) return "do_mpecho"; if ( skill == do_mpechoaround ) return "do_mpechoaround"; if ( skill == do_mpechoat ) return "do_mpechoat"; if ( skill == do_mpechozone ) return "do_mpechozone"; if ( skill == do_mpedit ) return "do_mpedit"; if ( skill == do_mpfavor ) return "do_mpfavor"; if ( skill == do_mpforce ) return "do_mpforce"; if ( skill == do_mpgive ) return "do_mpgive"; if ( skill == do_mpgoto ) return "do_mpgoto"; if ( skill == do_mpinvis ) return "do_mpinvis"; if ( skill == do_mpjunk ) return "do_mpjunk"; if ( skill == do_mpkill ) return "do_mpkill"; if ( skill == do_mpmload ) return "do_mpmload"; if ( skill == do_mpmorph ) return "do_mpmorph"; if ( skill == do_mpmset ) return "do_mpmset"; if ( skill == do_mpmusic ) return "do_mpmusic"; if ( skill == do_mpmusicaround ) return "do_mpmusicaround"; if ( skill == do_mpmusicat ) return "do_mpmusicat"; if ( skill == do_mpnothing ) return "do_mpnothing"; if ( skill == do_mpnuisance ) return "do_mpnuisance"; if ( skill == do_mpoload ) return "do_mpoload"; if ( skill == do_mposet ) return "do_mposet"; if ( skill == do_mppardon ) return "do_mppardon"; if ( skill == do_mppeace ) return "do_mppeace"; if ( skill == do_mppkset ) return "do_mppkset"; if ( skill == do_mppurge ) return "do_mppurge"; if ( skill == do_mpscatter ) return "do_mpscatter"; if ( skill == do_mpsound ) return "do_mpsound"; if ( skill == do_mpsoundaround ) return "do_mpsoundaround"; if ( skill == do_mpsoundat ) return "do_mpsoundat"; if ( skill == do_mpstat ) return "do_mpstat"; if ( skill == do_mptake ) return "do_mptake"; if ( skill == do_mpteach ) return "do_mpteach"; if ( skill == do_mptransfer ) return "do_mptransfer"; if ( skill == do_mpunmorph ) return "do_mpunmorph"; if ( skill == do_mpunnuisance ) return "do_mpunnuisance"; if ( skill == do_mpvalue ) return "do_mpvalue"; if ( skill == do_mrange ) return "do_mrange"; if ( skill == do_mset ) return "do_mset"; if ( skill == do_mstat ) return "do_mstat"; if ( skill == do_muse ) return "do_muse"; if ( skill == do_music ) return "do_music"; if ( skill == do_mwhere ) return "do_mwhere"; if ( skill == do_mxp ) return "do_mxp"; if ( skill == do_name ) return "do_name"; if ( skill == do_neckchop ) return "do_neckchop"; if ( skill == do_neckpinch ) return "do_neckpinch"; if ( skill == do_neckrupture ) return "do_neckrupture"; if ( skill == do_nervepinch ) return "do_nervepinch"; if ( skill == do_nervestrike ) return "do_nervestrike"; if ( skill == do_newbiechat ) return "do_newbiechat"; if ( skill == do_newbieset ) return "do_newbieset"; if ( skill == do_news ) return "do_news"; if ( skill == do_newscore ) return "do_newscore"; if ( skill == do_newzones ) return "do_newzones"; if ( skill == do_niburo ) return "do_niburo"; if ( skill == do_nock ) return "do_nock"; if ( skill == do_noemote ) return "do_noemote"; if ( skill == do_noresolve ) return "do_noresolve"; if ( skill == do_north ) return "do_north"; if ( skill == do_northeast ) return "do_northeast"; if ( skill == do_northwest ) return "do_northwest"; if ( skill == do_notell ) return "do_notell"; if ( skill == do_noteroom ) return "do_noteroom"; if ( skill == do_notitle ) return "do_notitle"; if ( skill == do_npcrace ) return "do_npcrace"; if ( skill == do_nuisance ) return "do_nuisance"; if ( skill == do_oassign ) return "do_oassign"; if ( skill == do_ocreate ) return "do_ocreate"; if ( skill == do_odelete ) return "do_odelete"; if ( skill == do_offered ) return "do_offered"; if ( skill == do_offername ) return "do_offername"; if ( skill == do_offers ) return "do_offers"; if ( skill == do_ofind ) return "do_ofind"; if ( skill == do_ogrub ) return "do_ogrub"; if ( skill == do_oinvoke ) return "do_oinvoke"; if ( skill == do_oldscore ) return "do_oldscore"; if ( skill == do_olist ) return "do_olist"; if ( skill == do_opedit ) return "do_opedit"; if ( skill == do_open ) return "do_open"; // if ( skill == do_opentourney ) return "do_opentourney"; if ( skill == do_opstat ) return "do_opstat"; if ( skill == do_orange ) return "do_orange"; if ( skill == do_order ) return "do_order"; if ( skill == do_orders ) return "do_orders"; if ( skill == do_ordertalk ) return "do_ordertalk"; if ( skill == do_oscatter ) return "do_oscatter"; if ( skill == do_oset ) return "do_oset"; if ( skill == do_ostat ) return "do_ostat"; if ( skill == do_outcast ) return "do_outcast"; if ( skill == do_owhere ) return "do_owhere"; if ( skill == do_pager ) return "do_pager"; if ( skill == do_pardon ) return "do_pardon"; if ( skill == do_parry ) return "do_parry"; if ( skill == do_password ) return "do_password"; if ( skill == do_pcrename ) return "do_pcrename"; if ( skill == do_pcshops ) return "do_pcshops"; if ( skill == do_peace ) return "do_peace"; if ( skill == do_peasant ) return "do_peasant"; if ( skill == do_perfectshot ) return "do_perfectshot"; if ( skill == do_pfiles ) return "do_pfiles"; if ( skill == do_pick ) return "do_pick"; if ( skill == do_piggyback ) return "do_piggyback"; if ( skill == do_pincer ) return "do_pincer"; if ( skill == do_pkillcheck ) return "do_pkillcheck"; if ( skill == do_placemob ) return "do_placemob"; if ( skill == do_placeobj ) return "do_placeobj"; if ( skill == do_placetrainer ) return "do_placetrainer"; if ( skill == do_plist ) return "do_plist"; if ( skill == do_poison_weapon ) return "do_poison_weapon"; if ( skill == do_portal ) return "do_portal"; if ( skill == do_powerslice ) return "do_powerslice"; if ( skill == do_pretitle ) return "do_pretitle"; if ( skill == do_project ) return "do_project"; if ( skill == do_prompt ) return "do_prompt"; if ( skill == do_pset ) return "do_pset"; if ( skill == do_pstat ) return "do_pstat"; if ( skill == do_pstatus ) return "do_pstatus"; if ( skill == do_pull ) return "do_pull"; if ( skill == do_purge ) return "do_purge"; if ( skill == do_push ) return "do_push"; if ( skill == do_put ) return "do_put"; if ( skill == do_qmob ) return "do_qmob"; if ( skill == do_qobj ) return "do_qobj"; if ( skill == do_qpset ) return "do_qpset"; if ( skill == do_qpstat ) return "do_qpstat"; if ( skill == do_quaff ) return "do_quaff"; if ( skill == do_qui ) return "do_qui"; if ( skill == do_quickcombo ) return "do_quickcombo"; if ( skill == do_quit ) return "do_quit"; if ( skill == do_racetalk ) return "do_racetalk"; if ( skill == do_rank ) return "do_rank"; if ( skill == do_rankings ) return "do_rankings"; if ( skill == do_rap ) return "do_rap"; if ( skill == do_rassign ) return "do_rassign"; if ( skill == do_rat ) return "do_rat"; if ( skill == do_rdelete ) return "do_rdelete"; if ( skill == do_reboo ) return "do_reboo"; if ( skill == do_reboot ) return "do_reboot"; if ( skill == do_recall ) return "do_recall"; if ( skill == do_recho ) return "do_recho"; if ( skill == do_recite ) return "do_recite"; if ( skill == do_redit ) return "do_redit"; if ( skill == do_regoto ) return "do_regoto"; if ( skill == do_remains ) return "do_remains"; if ( skill == do_remove ) return "do_remove"; if ( skill == do_removekingdom ) return "do_removekingdom"; if ( skill == do_removetown ) return "do_removetown"; if ( skill == do_rent ) return "do_rent"; if ( skill == do_repair ) return "do_repair"; if ( skill == do_repairset ) return "do_repairset"; if ( skill == do_repairshops ) return "do_repairshops"; if ( skill == do_repairstat ) return "do_repairstat"; if ( skill == do_repairwall ) return "do_repairwall"; if ( skill == do_repeat ) return "do_repeat"; if ( skill == do_reply ) return "do_reply"; if ( skill == do_report ) return "do_report"; if ( skill == do_rescue ) return "do_rescue"; if ( skill == do_reserve ) return "do_reserve"; if ( skill == do_reset ) return "do_reset"; if ( skill == do_resetkeeper ) return "do_resetkeeper"; if ( skill == do_rest ) return "do_rest"; if ( skill == do_restore ) return "do_restore"; if ( skill == do_restorelimbs ) return "do_restorelimbs"; if ( skill == do_restoretime ) return "do_restoretime"; if ( skill == do_restrict ) return "do_restrict"; if ( skill == do_resurrection ) return "do_resurrection"; if ( skill == do_retell ) return "do_retell"; if ( skill == do_retire ) return "do_retire"; if ( skill == do_retran ) return "do_retran"; if ( skill == do_return ) return "do_return"; if ( skill == do_reward ) return "do_reward"; if ( skill == do_rgrub ) return "do_rgrub"; if ( skill == do_ribpuncture ) return "do_ribpuncture"; if ( skill == do_rip ) return "do_rip"; if ( skill == do_rlist ) return "do_rlist"; if ( skill == do_roar ) return "do_roar"; if ( skill == do_roll ) return "do_roll"; if ( skill == do_roomstat ) return "do_roomstat"; if ( skill == do_roundhouse ) return "do_roundhouse"; if ( skill == do_rpedit ) return "do_rpedit"; if ( skill == do_rpstat ) return "do_rpstat"; if ( skill == do_rreset ) return "do_rreset"; if ( skill == do_rset ) return "do_rset"; if ( skill == do_rstat ) return "do_rstat"; if ( skill == do_rub ) return "do_rub"; if ( skill == do_run ) return "do_run"; if ( skill == do_sacrifice ) return "do_sacrifice"; if ( skill == do_save ) return "do_save"; if ( skill == do_savearea ) return "do_savearea"; if ( skill == do_say ) return "do_say"; if ( skill == do_say_to_char ) return "do_say_to_char"; if ( skill == do_sbook ) return "do_sbook"; if ( skill == do_scan ) return "do_scan"; if ( skill == do_scatter ) return "do_scatter"; if ( skill == do_schedule ) return "do_schedule"; if ( skill == do_score ) return "do_score"; if ( skill == do_scribe ) return "do_scribe"; if ( skill == do_search ) return "do_search"; if ( skill == do_sedit ) return "do_sedit"; if ( skill == do_seeorders ) return "do_seeorders"; if ( skill == do_sell ) return "do_sell"; if ( skill == do_sendmail ) return "do_sendmail"; if ( skill == do_set_boot_time ) return "do_set_boot_time"; if ( skill == do_setcaste ) return "do_setcaste"; if ( skill == do_setclan ) return "do_setclan"; if ( skill == do_setcouncil ) return "do_setcouncil"; if ( skill == do_setdeity ) return "do_setdeity"; if ( skill == do_setfree ) return "do_setfree"; if ( skill == do_setgambler ) return "do_setgambler"; if ( skill == do_setgem ) return "do_setgem"; if ( skill == do_setjob ) return "do_setjob"; if ( skill == do_setkingdom ) return "do_setkingdom"; if ( skill == do_setrace ) return "do_setrace"; if ( skill == do_setslay ) return "do_setslay"; if ( skill == do_settoadvance ) return "do_settoadvance"; if ( skill == do_setweather ) return "do_setweather"; if ( skill == do_setwilderness ) return "do_setwilderness"; if ( skill == do_sheath ) return "do_sheath"; if ( skill == do_shells ) return "do_shells"; if ( skill == do_ships ) return "do_ships"; if ( skill == do_shops ) return "do_shops"; if ( skill == do_shopset ) return "do_shopset"; if ( skill == do_shopstat ) return "do_shopstat"; if ( skill == do_shout ) return "do_shout"; if ( skill == do_shove ) return "do_shove"; if ( skill == do_show ) return "do_show"; if ( skill == do_showascii ) return "do_showascii"; if ( skill == do_showclan ) return "do_showclan"; if ( skill == do_showcontrol ) return "do_showcontrol"; if ( skill == do_showcouncil ) return "do_showcouncil"; if ( skill == do_showdeity ) return "do_showdeity"; if ( skill == do_showentrances ) return "do_showentrances"; if ( skill == do_showgambler ) return "do_showgambler"; if ( skill == do_showhouse ) return "do_showhouse"; if ( skill == do_showkingdoms ) return "do_showkingdoms"; if ( skill == do_showlayers ) return "do_showlayers"; if ( skill == do_showlist ) return "do_showlist"; if ( skill == do_showpic ) return "do_showpic"; if ( skill == do_showrace ) return "do_showrace"; if ( skill == do_showresources ) return "do_showresources"; if ( skill == do_showslay ) return "do_showslay"; if ( skill == do_showweather ) return "do_showweather"; if ( skill == do_shutdow ) return "do_shutdow"; if ( skill == do_shutdown ) return "do_shutdown"; if ( skill == do_sidekick ) return "do_sidekick"; if ( skill == do_silence ) return "do_silence"; if ( skill == do_sing ) return "do_sing"; if ( skill == do_sit ) return "do_sit"; if ( skill == do_skills ) return "do_skills"; if ( skill == do_skin ) return "do_skin"; if ( skill == do_sla ) return "do_sla"; if ( skill == do_slay ) return "do_slay"; if ( skill == do_sleep ) return "do_sleep"; if ( skill == do_slice ) return "do_slice"; if ( skill == do_slist ) return "do_slist"; if ( skill == do_slookup ) return "do_slookup"; if ( skill == do_smoke ) return "do_smoke"; if ( skill == do_snoop ) return "do_snoop"; if ( skill == do_sober ) return "do_sober"; if ( skill == do_socials ) return "do_socials"; if ( skill == do_south ) return "do_south"; if ( skill == do_southeast ) return "do_southeast"; if ( skill == do_southwest ) return "do_southwest"; if ( skill == do_spar ) return "do_spar"; if ( skill == do_speak ) return "do_speak"; if ( skill == do_spear ) return "do_spear"; if ( skill == do_speed ) return "do_speed"; if ( skill == do_spinkick ) return "do_spinkick"; if ( skill == do_split ) return "do_split"; if ( skill == do_sset ) return "do_sset"; if ( skill == do_sslist ) return "do_sslist"; if ( skill == do_stable ) return "do_stable"; if ( skill == do_stack ) return "do_stack"; if ( skill == do_stalk ) return "do_stalk"; if ( skill == do_stand ) return "do_stand"; if ( skill == do_startarena ) return "do_startarena"; if ( skill == do_startfire ) return "do_startfire"; if ( skill == do_startkingdom ) return "do_startkingdom"; if ( skill == do_startroom ) return "do_startroom"; if ( skill == do_stat ) return "do_stat"; if ( skill == do_statreport ) return "do_statreport"; if ( skill == do_steal ) return "do_steal"; if ( skill == do_steership ) return "do_steership"; if ( skill == do_stepback ) return "do_stepback"; if ( skill == do_strew ) return "do_strew"; if ( skill == do_strip ) return "do_strip"; if ( skill == do_study ) return "do_study"; if ( skill == do_stun ) return "do_stun"; if ( skill == do_style ) return "do_style"; if ( skill == do_supplicate ) return "do_supplicate"; if ( skill == do_survey ) return "do_survey"; if ( skill == do_switch ) return "do_switch"; if ( skill == do_talent ) return "do_talent"; if ( skill == do_talkquest ) return "do_talkquest"; if ( skill == do_tamp ) return "do_tamp"; if ( skill == do_target ) return "do_target"; if ( skill == do_tcreate ) return "do_tcreate"; if ( skill == do_tdelete ) return "do_tdelete"; if ( skill == do_tell ) return "do_tell"; if ( skill == do_terraform ) return "do_terraform"; if ( skill == do_think ) return "do_think"; if ( skill == do_time ) return "do_time"; if ( skill == do_timecmd ) return "do_timecmd"; if ( skill == do_timmuru ) return "do_timmuru"; if ( skill == do_tinduct ) return "do_tinduct"; if ( skill == do_title ) return "do_title"; if ( skill == do_tkickout ) return "do_tkickout"; if ( skill == do_tone ) return "do_tone"; if ( skill == do_tornadokick ) return "do_tornadokick"; if ( skill == do_toss ) return "do_toss"; if ( skill == do_track ) return "do_track"; if ( skill == do_tradegoods ) return "do_tradegoods"; if ( skill == do_traderoutes ) return "do_traderoutes"; if ( skill == do_training ) return "do_training"; if ( skill == do_trans ) return "do_trans"; if ( skill == do_transfer ) return "do_transfer"; if ( skill == do_trap ) return "do_trap"; if ( skill == do_trust ) return "do_trust"; if ( skill == do_tset ) return "do_tset"; if ( skill == do_tstat ) return "do_tstat"; if ( skill == do_tumble ) return "do_tumble"; if ( skill == do_typo ) return "do_typo"; if ( skill == do_unfoldarea ) return "do_unfoldarea"; if ( skill == do_unhell ) return "do_unhell"; if ( skill == do_unloadqarea ) return "do_unloadqarea"; if ( skill == do_unlock ) return "do_unlock"; if ( skill == do_unnuisance ) return "do_unnuisance"; if ( skill == do_unsilence ) return "do_unsilence"; if ( skill == do_up ) return "do_up"; if ( skill == do_updatearea ) return "do_updatearea"; if ( skill == do_updateskills ) return "do_updateskills"; if ( skill == do_uselicense ) return "do_uselicense"; if ( skill == do_users ) return "do_users"; if ( skill == do_value ) return "do_value"; if ( skill == do_vassign ) return "do_vassign"; if ( skill == do_version ) return "do_version"; if ( skill == do_victories ) return "do_victories"; if ( skill == do_viewmount ) return "do_viewmount"; if ( skill == do_viewskills ) return "do_viewskills"; if ( skill == do_visible ) return "do_visible"; if ( skill == do_vnums ) return "do_vnums"; if ( skill == do_vsearch ) return "do_vsearch"; if ( skill == do_wake ) return "do_wake"; if ( skill == do_warn ) return "do_warn"; if ( skill == do_wartalk ) return "do_wartalk"; if ( skill == do_watch ) return "do_watch"; if ( skill == do_wblock ) return "do_wblock"; if ( skill == do_weaponbreak ) return "do_weaponbreak"; if ( skill == do_wear ) return "do_wear"; if ( skill == do_weather ) return "do_weather"; if ( skill == do_webstats ) return "do_webstats"; if ( skill == do_west ) return "do_west"; if ( skill == do_where ) return "do_where"; if ( skill == do_whisper ) return "do_whisper"; if ( skill == do_who ) return "do_who"; if ( skill == do_whois ) return "do_whois"; if ( skill == do_whonumber ) return "do_whonumber"; if ( skill == do_wimpy ) return "do_wimpy"; if ( skill == do_withdraw ) return "do_withdraw"; if ( skill == do_wizhelp ) return "do_wizhelp"; if ( skill == do_wizlist ) return "do_wizlist"; if ( skill == do_wizlock ) return "do_wizlock"; if ( skill == do_wizzap ) return "do_wizzap"; if ( skill == do_worth ) return "do_worth"; if ( skill == do_yell ) return "do_yell"; if ( skill == do_zap ) return "do_zap"; if ( skill == do_zones ) return "do_zones"; /*//T4*/ sprintf(buf, "(%p)", skill); return buf; } // Market data. Allows players to place objects up for sale. void save_market_data() { FILE *fp; char filename[256]; MARKET_DATA *market; sprintf(filename, "%s", MARKET_FILE); if ((fp = fopen(filename, "w")) == NULL) { bug("save_market_data: fopen", 0); perror(filename); } else { fprintf(fp, "Startpid %d\n", start_marketpid); for (market = first_market; market; market = market->next) { fprintf(fp, "#MARKET\n"); fprintf(fp, "Cost %d\n", market->cost); fprintf(fp, "Name %s~\n", market->name); fprintf(fp, "Pid %d\n", market->pid); fprintf(fp, "MPid %d\n", market->mpid); fprintf(fp, "Count %d\n", market->count); fprintf(fp, "SCount %d\n", market->scount); fprintf(fp, "End\n"); fwrite_obj(NULL, market->obj, fp, 0, OS_MARKET); } } fprintf(fp, "#END\n"); fclose(fp); return; } void fread_market(FILE * fp, MARKET_DATA *market) { bool fMatch; char *word; for (;;) { word = feof(fp) ? "End" : fread_word(fp); switch (UPPER(word[0])) { case 'C': KEY("Cost", market->cost, fread_number(fp)); KEY("Count", market->count, fread_number(fp)); break; case 'M': KEY("MPid", market->mpid, fread_number(fp)); break; case 'N': KEY("Name", market->name, fread_string(fp)); break; case 'P': KEY("Pid", market->pid, fread_number(fp)); break; case 'S': KEY("Startpid", start_marketpid, fread_number(fp)); KEY("SCount", market->scount, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) return; } } } void load_market_data() { char filename[256]; MARKET_DATA *market = NULL; FILE *fp; bool found; char letter; char *word; found = FALSE; sprintf(filename, "%s", MARKET_FILE); if ((fp = fopen(filename, "r")) != NULL) { word = fread_word(fp); start_marketpid = fread_number(fp); for (;;) { letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("load_market_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "MARKET")) { CREATE(market, MARKET_DATA, 1); fread_market(fp, market); LINK(market, first_market, last_market, next, prev); continue; } else if (!str_cmp(word, "MARKETOBJ")) { globalmarketptr = market; fread_obj(NULL, fp, OS_MARKET); continue; } else if (!str_cmp(word, "END")) break; else { bug("load_market_data: bad section: %s.", word); break; } } fclose(fp); } } // Kingdom Storage Bins, work like the Clan ones mainly void save_kingdom_chests(CHAR_DATA * ch) { FILE *fp; char filename[256]; KCHEST_DATA *kchest; if (!ch) { bug("save_kingdom_chests: Null ch pointer!", 0); return; } sprintf(filename, "%s%s", CASTE_DIR, KCHEST_FILE); if ((fp = fopen(filename, "w")) == NULL) { bug("save_kingdom_chests: fopen", 0); perror(filename); } else { for (kchest = first_kchest; kchest; kchest = kchest->next) { fprintf(fp, "#CHEST\n"); fprintf(fp, "_VNUM_\n"); fprintf(fp, "Vnum %d\n", kchest->obj->in_room->vnum); fprintf(fp, "X %d\n", kchest->obj->coord->x); fprintf(fp, "Y %d\n", kchest->obj->coord->y); fprintf(fp, "Map %d\n", kchest->obj->map); fprintf(fp, "Version %d\n", SAVEVERSION); fprintf(fp, "End\n\n"); fprintf(fp, "_CHEST_\n"); fwrite_obj(ch, kchest->obj, fp, 0, OS_KINGDOM); fprintf(fp, "#STOP\n\n\n"); } } fprintf(fp, "#END\n"); fclose(fp); return; } void fread_chest(FILE * fp, KCHEST_DATA * kchest) { int vnum = 0; int found = 0; int x, y, map; bool fMatch; char *word; char letter; ROOM_INDEX_DATA *room = NULL; OBJ_DATA *tobj, *tobj_next; x=y=map=-1; for (;;) { if (found == 1) break; word = feof(fp) ? "End" : fread_word(fp); if (!str_cmp(word, "_CHEST_")) { for (;;) { letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("fread_chest: # not found.", 0); break; } word = fread_word(fp); if (vnum != 0) room = get_room_index(vnum); if (!str_cmp(word, "OBJECT")) { if (room) { rset_supermob(room); fread_obj(supermob, fp, OS_CARRY); } else { bug("fread_chest: no room for the chest"); return; } } else { if (room) { for (tobj = supermob->first_carrying; tobj; tobj = tobj_next) { tobj_next = tobj->next_content; kchest->obj = tobj; LINK(kchest, first_kchest, last_kchest, next, prev); obj_from_char(tobj); obj_to_room(tobj, room, supermob); tobj->coord->x = x; tobj->coord->y = y; tobj->map = map; } release_supermob(); found = 1; break; } } } } else if (!str_cmp(word, "_VNUM_")) { int fnd = 0; for (;;) { word = feof(fp) ? "End" : fread_word(fp); switch (UPPER(word[0])) { case 'M': KEY("Map", map, fread_number(fp)); break; case 'V': KEY("Version", file_ver, fread_number(fp)); KEY("Vnum", vnum, fread_number(fp)); break; case 'X': KEY("X", x, fread_number(fp)); break; case 'Y': KEY("Y", y, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { fnd = 1; break; } } if (fnd == 1) break; } } else break; } file_ver = 0; } void load_kchest_file() { char filename[256]; KCHEST_DATA *kchest; FILE *fp; bool found; found = FALSE; sprintf(filename, "%s%s", CASTE_DIR, KCHEST_FILE); if ((fp = fopen(filename, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_kchest_file: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "CHEST")) { CREATE(kchest, KCHEST_DATA, 1); fread_chest(fp, kchest); continue; } else if (!str_cmp(word, "END")) break; else { char buf[MSL]; sprintf(buf, "Load_kchest_file: bad section: %s.", word); bug(buf, 0); break; } } fclose(fp); } } void save_trap_file(TRAP_DATA *strap, FILE *sfp) { char buf[MSL]; FILE *fp; TRAP_DATA *trap; if (strap) { fprintf(sfp, "Start\n"); fprintf(sfp, "Charges %d\n", strap->charges); fprintf(sfp, "MaxCharges %d\n", strap->maxcharges); fprintf(sfp, "Uid %d\n", strap->uid); fprintf(sfp, "Type %d\n", strap->type); fprintf(sfp, "Damlow %d\n", strap->damlow); fprintf(sfp, "Damhigh %d\n", strap->damhigh); fprintf(sfp, "Room %d\n", strap->room); fprintf(sfp, "Difficulty %d\n", strap->difficulty); fprintf(sfp, "Toolkit %d\n", strap->toolkit); fprintf(sfp, "Onetime %d\n", strap->onetime); fprintf(sfp, "Disarmed %d\n", strap->disarmed); fprintf(sfp, "Trapflags %s\n", print_bitvector(&strap->trapflags)); fprintf(sfp, "Resetvalue %d\n", strap->resetvalue); fprintf(sfp, "Toolnegate %d\n", strap->toolnegate); fprintf(sfp, "Frag %d\n", strap->frag); fprintf(sfp, "End\n"); fprintf(sfp, "Stop\n"); return; } sprintf(buf, "%s", TRAP_FILE); if ((fp = fopen(buf, "w")) == NULL) { perror(buf); return; } for (trap = first_trap; trap; trap = trap->next) { if (trap->uid < START_INV_TRAP) { fprintf(fp, "Start\n"); fprintf(fp, "Charges %d\n", trap->charges); fprintf(fp, "MaxCharges %d\n", trap->maxcharges); fprintf(fp, "Uid %d\n", trap->uid); fprintf(fp, "Type %d\n", trap->type); fprintf(fp, "Damlow %d\n", trap->damlow); fprintf(fp, "Damhigh %d\n", trap->damhigh); fprintf(fp, "Room %d\n", trap->room); fprintf(fp, "Difficulty %d\n", trap->difficulty); fprintf(fp, "Toolkit %d\n", trap->toolkit); fprintf(fp, "Onetime %d\n", trap->onetime); fprintf(fp, "Disarmed %d\n", trap->disarmed); fprintf(fp, "Trapflags %s\n", print_bitvector(&trap->trapflags)); fprintf(fp, "Resetvalue %d\n", trap->resetvalue); fprintf(fp, "Toolnegate %d\n", trap->toolnegate); fprintf(fp, "Frag %d\n", trap->frag); fprintf(fp, "End\n"); } } fprintf(fp, "Stop\n"); fclose(fp); } TRAP_DATA *load_trap_file(FILE *sfp) { char buf[MSL]; char *word; bool fMatch; TRAP_DATA *trap = NULL; FILE *fp; if (!sfp) { sprintf(buf, "%s", TRAP_FILE); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return NULL;; } } else fp = sfp; for (;;) { word = feof(fp) ? "Stop" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Charges", trap->charges, fread_number(fp)); break; case 'D': KEY("Damlow", trap->damlow, fread_number(fp)); KEY("Damhigh", trap->damhigh, fread_number(fp)); KEY("Difficulty", trap->difficulty, fread_number(fp)); KEY("Disarmed", trap->disarmed, fread_number(fp)); break; case 'F': KEY("Frag", trap->frag, fread_number(fp)); break; case 'M': KEY("MaxCharges", trap->maxcharges, fread_number(fp)); break; case 'O': KEY("Onetime", trap->onetime, fread_number(fp)); break; case 'R': KEY("Resetvalue", trap->resetvalue, fread_number(fp)); KEY("Room", trap->room, fread_number(fp)); break; case 'T': KEY("Type", trap->type, fread_number(fp)); KEY("Toolkit", trap->toolkit, fread_number(fp)); KEY("Trapflags", trap->trapflags, fread_bitvector(fp)); KEY("Toolnegate", trap->toolnegate, fread_number(fp)); break; case 'U': KEY("Uid", trap->uid, fread_number(fp)); break; case 'S': if (!str_cmp(word, "Start")) { CREATE(trap, TRAP_DATA, 1); fMatch = TRUE; } if (!str_cmp(word, "Stop")) { if (!sfp) fclose(fp); return trap; } break; case 'E': if (!str_cmp(word, "End")) { LINK(trap, first_trap, last_trap, next, prev); if (sfp && trap->uid > sysdata.last_invtrap_uid) { bug("Trap with uid %d is higher than sysdata.last_invtrap_uid. Fixing"); sysdata.last_invtrap_uid = trap->uid; } if (!sfp && trap->uid > sysdata.last_trap_uid) { bug("Trap with uid %d is higher than sysdata.last_trap_uid. Fixing"); sysdata.last_trap_uid = trap->uid; } fMatch = TRUE; break; } } if (!fMatch) { sprintf(buf, "load_portal_file: no match: %s", word); bug(buf, 0); } } fclose(fp); return NULL; } void fwrite_ship_data() { char buf[MSL]; FILE *fp; SHIP_DATA *ship; sprintf(buf, "%s", SHIP_FILE); if ((fp = fopen(buf, "w")) == NULL) { perror(buf); return; } fprintf(fp, "CURUID %d\n", cur_ship_uid); for (ship = first_ship; ship; ship = ship->next) { fprintf(fp, "X %d\n", ship->x); fprintf(fp, "Y %d\n", ship->y); fprintf(fp, "Map %d\n", ship->map); fprintf(fp, "TX %d\n", ship->tx); fprintf(fp, "TY %d\n", ship->ty); fprintf(fp, "TMap %d\n", ship->tmap); fprintf(fp, "Direction %d\n", ship->direction); fprintf(fp, "Size %d\n", ship->size); fprintf(fp, "Ticket %d\n", ship->ticket); fprintf(fp, "Occupants %d\n", ship->occupants); fprintf(fp, "Uid %d\n", ship->uid); fprintf(fp, "Travelroute %s~\n", ship->travelroute); fprintf(fp, "Routeplace %d\n", ship->routeplace); fprintf(fp, "Routedir %d\n", ship->routedir); fprintf(fp, "Routetime %d\n", ship->routetime); fprintf(fp, "Routetick %d\n", ship->routetick); fprintf(fp, "End \n"); } fprintf(fp, "Stop\n"); fclose(fp); } void load_ship_data() { char buf[MSL]; char *word; bool fMatch; SHIP_DATA *ship = NULL; FILE *fp; cur_ship_uid = 0; sprintf(buf, "%s", SHIP_FILE); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return; } for (;;) { word = feof(fp) ? "Stop" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("CURUID", cur_ship_uid, fread_number(fp)); break; case 'D': KEY("Direction", ship->direction, fread_number(fp)); break; case 'U': KEY("Uid", ship->uid, fread_number(fp)); break; case 'M': KEY("Map", ship->map, fread_number(fp)); break; case 'O': KEY("Occupants", ship->occupants, fread_number(fp)); break; case 'R': KEY("Routeplace", ship->routeplace, fread_number(fp)); KEY("Routedir", ship->routedir, fread_number(fp)); KEY("Routetime", ship->routetime, fread_number(fp)); KEY("Routetick", ship->routetick, fread_number(fp)); break; case 'T': KEY("Ticket", ship->ticket, fread_number(fp)); KEY("Travelroute", ship->travelroute, fread_string(fp)); KEY("TX", ship->tx, fread_number(fp)); KEY("TY", ship->ty, fread_number(fp)); KEY("TMap", ship->tmap, fread_number(fp)); break; case 'X': if (!str_cmp(word, "X")) { CREATE(ship, SHIP_DATA, 1); ship->x = fread_number(fp); fMatch = TRUE; } break; case 'Y': KEY("Y", ship->y, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(ship, first_ship, last_ship, next, prev); fMatch = TRUE; set_ship_sector(ship, 0, 0); } break; case 'S': KEY("Size", ship->size, fread_number(fp)); if (!str_cmp(word, "Stop")) { fclose(fp); return; } break; } if (!fMatch) { sprintf(buf, "load_ship_data: no match: %s", word); bug(buf, 0); } } return; } void load_portal_file() { char buf[MSL]; char *word; bool fMatch; PORTAL_DATA *portal; FILE *fp; int num = 0; sprintf(buf, "%s%s", KINGDOM_DIR, PORTAL_FILE); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return; } CREATE(portal, struct portal_data, 1); for (;;) { word = feof(fp) ? "Stop" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'D': KEY("Description", portal->desc, fread_string(fp)); break; case 'M': KEY("Map", portal->map, fread_number(fp)); break; case 'X': KEY("X", portal->x, fread_number(fp)); break; case 'Y': KEY("Y", portal->y, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { portal_show[num] = portal; num++; fMatch = TRUE; CREATE(portal, struct portal_data, 1); break; } case 'S': if (!str_cmp(word, "Stop")) { fclose(fp); sysdata.last_portal = num; return; } } if (!fMatch) { sprintf(buf, "load_portal_file: no match: %s", word); bug(buf, 0); } } sysdata.last_portal = num; fclose(fp); return; } void save_portal_file(void) { char buf[MSL]; FILE *fp; int num = 0; sprintf(buf, "%s%s", KINGDOM_DIR, PORTAL_FILE); if ((fp = fopen(buf, "w")) == NULL) { perror(buf); return; } for (num = 0; num < sysdata.last_portal; num++) { fprintf(fp, "Description %s~\n", portal_show[num]->desc); fprintf(fp, "Map %d\n", portal_show[num]->map); fprintf(fp, "X %d\n", portal_show[num]->x); fprintf(fp, "Y %d\n", portal_show[num]->y); fprintf(fp, "End\n"); } fprintf(fp, "Stop\n"); fclose(fp); } void save_npcrace_file(void) { char buf[MSL]; FILE *fp; NPCRACE_DATA *npcrace; int x; sprintf(buf, "%s", NPCRACE_FILE); if ((fp = fopen(buf, "w")) == NULL) { perror(buf); return; } fprintf(fp, "MAXQUESTDIFF %d\n", MAX_QUEST_DIFF); for (npcrace = first_npcrace; npcrace; npcrace = npcrace->next) { fprintf(fp, "Racenum %d\n", npcrace->racenum); fprintf(fp, "Racename %s~\n", npcrace->racename); fprintf(fp, "Willload "); for (x = 0; x <= MAX_QUEST_DIFF-1; x++) fprintf(fp, " %d", npcrace->willload[x]); for (x = 0; x <= MAX_QUEST_DIFF-1; x++) fprintf(fp, "\nDescription %d %s~", x, npcrace->description[x]); fprintf(fp, "\nSex "); for (x = 0; x <= MAX_QUEST_DIFF-1; x++) fprintf(fp, " %d", npcrace->sex[x]); fprintf(fp, "\nFlags "); for (x = 0; x <= MAX_QUEST_DIFF-1; x++) fprintf(fp, " %s", print_bitvector(&npcrace->flags[x])); fprintf(fp, "\nNFlags "); for (x = 0; x <= MAX_QUEST_DIFF-1; x++) fprintf(fp, " %s", print_bitvector(&npcrace->nflags[x])); fprintf(fp, "\nFulldescription "); for (x = 0; x <= MAX_QUEST_DIFF-1; x++) fprintf(fp, " %d", npcrace->fulldescription[x]); fprintf(fp, "\nEnd\n"); } fprintf(fp, "Stop\n"); fclose(fp); } void load_npcrace_file() { char buf[MSL]; char *word; bool fMatch; NPCRACE_DATA *npcrace = NULL; int x; FILE *fp; int maxnpc = -1; int maxqdiff = MAX_QUEST_DIFF; sprintf(buf, "%s", NPCRACE_FILE); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return; } for (;;) { word = feof(fp) ? "Stop" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'D': if (!str_cmp(word, "Description")) { x = fread_number(fp); npcrace->description[x] = fread_string(fp); fMatch = TRUE; } break; case 'F': if (!str_cmp(word, "Fulldescription")) { for (x = 0; x <= maxqdiff-1; x++) npcrace->fulldescription[x] = fread_number(fp); fMatch = TRUE; } if (!str_cmp(word, "Flags")) { for (x = 0; x <= maxqdiff-1; x++) npcrace->flags[x] = fread_bitvector(fp); fMatch = TRUE; } break; case 'M': KEY("MAXQUESTDIFF", maxqdiff, fread_number(fp)); break; case 'N': if (!str_cmp(word, "NFlags")) { for (x = 0; x <= maxqdiff-1; x++) npcrace->nflags[x] = fread_bitvector(fp); fMatch = TRUE; } break; case 'R': if (!str_cmp(word, "Racenum")) { CREATE(npcrace, NPCRACE_DATA, 1); npcrace->racenum = fread_number(fp); fMatch = TRUE; } KEY("Racename", npcrace->racename, fread_string(fp)); break; case 'S': if (!str_cmp(word, "Sex")) { for (x = 0; x <= maxqdiff-1; x++) npcrace->sex[x] = fread_number(fp); fMatch = TRUE; } if (!str_cmp(word, "Stop")) { for (x = 0; x <= MAX_NPCRACE_TABLE-1; x++) npcrace_table[MAX_NPCRACE_TABLE] = NULL; for (npcrace = first_npcrace; npcrace; npcrace = npcrace->next) { if (npcrace->racenum > maxnpc) maxnpc = npcrace->racenum; if (npcrace_table[npcrace->racenum]) bug("There are two enteries for number %d in the npcrace table", npcrace->racenum); npcrace_table[npcrace->racenum] = npcrace; } max_npc_race = maxnpc+1; fclose(fp); return; } break; case 'W': if (!str_cmp(word, "Willload")) { for (x = 0; x <= maxqdiff-1; x++) npcrace->willload[x] = fread_number(fp); fMatch = TRUE; } break; case 'E': if (!str_cmp(word, "End")) { LINK(npcrace, first_npcrace, last_npcrace, next, prev); fMatch = TRUE; } break; } if (!fMatch) { sprintf(buf, "load_npcrace_file: no match: %s", word); bug(buf, 0); } } fclose(fp); return; } void copy_files_contents(FILE *fsource, FILE *fdestination) { int ch; int cnt = 1; for (;;) { ch = fgetc( fsource ); if (!feof(fsource)) { fputc( ch, fdestination); if (ch == '\n') { cnt++; if (cnt >= LAST_FILE_SIZE) //limit size of this file please :-) break; } } else break; } } void write_last_file(char *entry) { FILE *fpout; FILE *fptemp; char filename[MIL]; char tempname[MIL]; sprintf(filename, "%s", LAST_LIST); sprintf(tempname, "%s", LAST_TEMP_LIST); if ((fptemp = fopen(tempname, "w")) == NULL) { bug("Cannot open: %s for writing", tempname); return; } fprintf(fptemp, "%s\n", entry); //adds new entry to top of the file if ((fpout = fopen(filename, "r")) != NULL) { copy_files_contents(fpout, fptemp); //copy the rest to the file fclose(fpout); //close the files since writing is done } fclose(fptemp); if (remove(filename) != 0 && fopen(filename, "r") != NULL) { bug("Do not have permission to delete the %s file", filename); return; } if (rename(tempname, filename) != 0) { bug("Do not have permission to rename the %s file", tempname); return; } return; } void read_last_file(CHAR_DATA *ch, int count, char *name) { FILE *fpout; char filename[MIL]; char charname[100]; int cnt = 0; int letter = 0; char *ln; char *c; char d, e; struct tm *tme; time_t now; char day[MIL]; char sday[5]; int fnd = 0; sprintf(filename, "%s", LAST_LIST); if ((fpout = fopen(filename, "r")) == NULL) { send_to_char("There is no last file to look at.\n\r", ch); return; } for (;;) { if (feof(fpout)) { fclose(fpout); ch_printf(ch, "---------------------------------------------------------------------------\n\r%d Entries Listed.\n\r", cnt); return; } else { if (count == -2 || ++cnt <= count || count == -1) { ln = fread_line(fpout); strcpy(charname, ""); if (name) //looking for a certain name { c = ln; for (;;) { if (isalpha(*c) && !isspace(*c)) { charname[letter] = *c; letter++; c++; } else { charname[letter] = '\0'; if (!str_cmp(charname, name)) { ch_printf(ch, "%s", ln); letter = 0; strcpy(charname, ""); break; } else { if (!feof(fpout)) { fread_line(fpout); c = ln; letter = 0; strcpy(charname, ""); continue; } else { cnt--; break; } } } } } else if (count == -2) //only today's entries { c = ln; now = time(0); tme = localtime(&now); strftime(day, 10, "%d", tme); for (;;) { if (!isdigit(*c)) { c++; } else { d = *c; c++; e = *c; sprintf(sday, "%c%c", d, e); if (!str_cmp(sday, day)) { fnd = 1; cnt++; ch_printf(ch, "%s", ln); break; } else { if (fnd == 1) { fclose(fpout); ch_printf(ch, "---------------------------------------------------------------------------\n\r%d Entries Listed.\n\r", cnt); return; } else break; } } } } else { ch_printf(ch, "%s", ln); } } else { fclose(fpout); ch_printf(ch, "--------------------------------------------------------------------------\n\r%d Entries Listed.\n\r", count); return; } } } } void fwrite_battle_descriptions() { FILE *fpout; char filename[MIL]; int x; int y; int z; sprintf(filename, "%s", BDESCRIPTION_LIST); if ((fpout = fopen(filename, "w")) == NULL) { bug("Cannot open: %s for writing", filename); return; } for (z = 0; z < 7; z++) { for (x = 0; x < 3; x++) { for (y = 0; y < 100; y++) { if (x == 0 && y == 0) { if (z == 0) fprintf(fpout, "#HIT\n"); if (z == 1) fprintf(fpout, "#MISS\n"); if (z == 2) fprintf(fpout, "#BLOCK\n"); if (z == 3) fprintf(fpout, "#PARRY\n"); if (z == 4) fprintf(fpout, "#DODGE\n"); if (z == 5) fprintf(fpout, "#CRIT\n"); if (z == 6) fprintf(fpout, "#INSTA\n"); } if (y == 0) { if (x == 0) fprintf(fpout, "#BASH\n"); else if (x == 1) fprintf(fpout, "#SLASH\n"); else if (x == 2) fprintf(fpout, "#STAB\n"); } if (battle_descriptions[z][x][y][0] != '\0') { fprintf(fpout, "%s~\n", battle_descriptions[z][x][y]); } if (y == 99) fprintf(fpout, "End~\n\n"); } } } fprintf(fpout, "#END\n"); fclose(fpout); } void fwrite_training_list() { FILE *fpout; char filename[MIL]; TRAINING_DATA *training; sprintf(filename, "%s", TRAINING_LIST); if ((fpout = fopen(filename, "w")) == NULL) { bug("Cannot open: %s for writing", filename); return; } for (training = first_training; training; training = training->next) { if (!training->kmob) continue; fprintf(fpout, "#TrainingStart\n"); fprintf(fpout, "Kmob %d\n", training->kmob->vnum); fprintf(fpout, "Speed %d\n", training->speed); fprintf(fpout, "Stime %d\n", training->stime); fprintf(fpout, "Etime %d\n", training->etime); fprintf(fpout, "Town %d\n", training->town); fprintf(fpout, "Kingdom %d\n", training->kingdom); if (training->x) { fprintf(fpout, "X %d\n", training->x); fprintf(fpout, "Y %d\n", training->y); fprintf(fpout, "Map %d\n", training->map); fprintf(fpout, "Bin %d\n", training->bin); fprintf(fpout, "Resource %d\n", training->resource); } fprintf(fpout, "#TrainingEnd\n"); } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_training_list() { FILE *fp; char filename[MIL]; char buf[MSL]; char *word; int fMatch; int vnum = -1; BUYKMOB_DATA *kmob; TRAINING_DATA *training = NULL; sprintf(filename, "%s", TRAINING_LIST); if ((fp = fopen(filename, "r")) != NULL) { for (;;) { word = feof(fp) ? "#End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'B': KEY("Bin", training->bin, fread_number(fp)); break; case 'E': KEY("Etime", training->etime, fread_number(fp)); break; case 'K': KEY("Kingdom", training->kingdom, fread_number(fp)); if (!str_cmp(word, "Kmob")) { fMatch = TRUE; vnum = fread_number(fp); for (kmob = first_buykmob; kmob; kmob = kmob->next) { if (kmob->vnum == vnum) break; } if (kmob) training->kmob = kmob; else vnum = -1; } break; case 'M': KEY("Map", training->map, fread_number(fp)); break; case 'R': KEY("Resource", training->resource, fread_number(fp)); break; case 'S': KEY("Speed", training->speed, fread_number(fp)); KEY("Stime", training->stime, fread_number(fp)); break; case 'T': KEY("Town", training->town, fread_number(fp)); break; case 'X': KEY("X", training->x, fread_number(fp)); break; case 'Y': KEY("Y", training->y, fread_number(fp)); break; case '#': if (!str_cmp(word, "#Trainingstart")) { CREATE(training, TRAINING_DATA, 1); fMatch = TRUE; } if (!str_cmp(word, "#Trainingend")) { fMatch = TRUE; if (vnum != -1) LINK(training, first_training, last_training, next, prev); else DISPOSE(training); //Bad node, could not find kmob in list, dispose of... } if (!str_cmp(word, "#END")) { fclose(fp); return; } } if (!fMatch) { sprintf(buf, "fread_training_list: no match: %s", word); bug(buf, 0); } } } } void fread_battle_descriptions() { FILE *fp; char filename[MIL]; char *desc; int y; int z = 0; int x = -1; int cnt = 0; sprintf(filename, "%s", BDESCRIPTION_LIST); if ((fp = fopen(filename, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_conquer_file: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "HIT")) { z = 0; continue; } else if (!str_cmp(word, "MISS")) { z = 1; continue; } else if (!str_cmp(word, "BLOCK")) { z = 2; continue; } else if (!str_cmp(word, "PARRY")) { z = 3; continue; } else if (!str_cmp(word, "DODGE")) { z = 4; continue; } else if (!str_cmp(word, "CRIT")) { z = 5; continue; } else if (!str_cmp(word, "INSTA")) { z = 6; continue; } else if (!str_cmp(word, "BASH")) y = 0; else if (!str_cmp(word, "SLASH")) y = 1; else if (!str_cmp(word, "STAB")) y = 2; else if (!str_cmp(word, "END")) { fclose(fp); return; } else { bug("fread_battle_description: bad section.", 0); exit(0); } for (;;) { if (feof(fp)) { bug("fread_battle_description: End of file was reached"); exit(0); } desc = fread_string(fp); if (!str_cmp(desc, "End")) { x = -1; high_value[z][y] = cnt; cnt = 0; break; } else { sprintf((char *) battle_descriptions[z][y][++x], desc); cnt++; } } } } else { bug("fread_battle_description: The file was not found"); exit(0); } } void write_portal_file() { FILE *fpout; char filename[MIL]; int num; sprintf(filename, "%s%s", KINGDOM_DIR, PORTAL_FILE); if ((fpout = fopen(filename, "w")) == NULL) { bug("Cannot open: %s for writing", filename); return; } for (num = 0; num < sysdata.last_portal; num++) { fprintf(fpout, "Description %s~\n", portal_show[num]->desc); fprintf(fpout, "X %d\n", portal_show[num]->x); fprintf(fpout, "Y %d\n", portal_show[num]->y); fprintf(fpout, "Map %d\n", portal_show[num]->map); fprintf(fpout, "End\n\n"); } fprintf(fpout, "Stop\n"); fclose(fpout); } void save_conquer_file() { FILE *fpout; char filename[MIL]; CONQUER_DATA *conquer; sprintf(filename, "%s%s", KINGDOM_DIR, CONQUER_FILE); if ((fpout = fopen(filename, "w")) == NULL) { bug("Cannot open: %s for writing", filename); return; } for (conquer = first_conquer; conquer; conquer = conquer->next) { fprintf(fpout, "#CONQUER\n"); fprintf(fpout, "AKingdom %d\n", conquer->akingdom); fprintf(fpout, "RKingdom %d\n", conquer->rkingdom); fprintf(fpout, "Time %d\n", conquer->time); fprintf(fpout, "Town %s~\n", conquer->ntown); fprintf(fpout, "End\n"); } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_conquer_data(FILE *fp) { bool fMatch; char *word; CONQUER_DATA *conquer; CREATE(conquer, CONQUER_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("AKingdom", conquer->akingdom, fread_number(fp)); break; case 'R': KEY("RKingdom", conquer->rkingdom, fread_number(fp)); break; case 'T': KEY("Time", conquer->time, fread_number(fp)); KEY("Town", conquer->ntown, fread_string(fp)); break; case 'E': if (!str_cmp(word, "End")) { conquer->occupied = 1; LINK(conquer, first_conquer, last_conquer, next, prev); return; } } } } void load_conquer_file() { FILE *fp; char filename[MIL]; CONQUER_DATA *conquer; CONQUER_DATA *conquernext; TOWN_DATA *town; sprintf(filename, "%s%s", KINGDOM_DIR, CONQUER_FILE); if ((fp = fopen(filename, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_conquer_file: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "CONQUER")) { fread_conquer_data(fp); continue; } else if (!str_cmp(word, "END")) { for (conquer = first_conquer; conquer; conquer = conquernext) { conquernext = conquer->next; if ((town = get_town(conquer->ntown)) == NULL) { bug("Conquer Data %d conquering %d has an invalid name of %s, removing", conquer->akingdom, conquer->rkingdom, conquer->ntown); STRFREE(conquer->ntown); UNLINK(conquer, first_conquer, last_conquer, next, prev); DISPOSE(conquer); } else conquer->town = town; } fclose(fp); return; } else { bug("Load_conquer_file: bad section.", 0); continue; } } } else { bug("Cannot open the conquer file", 0); return; } } void save_trade_file() { FILE *fpout; char filename[MIL]; TRADE_DATA *trade; sprintf(filename, "%s%s", KINGDOM_DIR, TRADE_FILE); if ((fpout = fopen(filename, "w")) == NULL) { bug("Cannot open: %s for writing", filename); return; } for (trade = first_trade; trade; trade = trade->next) { fprintf(fpout, "#TRADE\n"); fprintf(fpout, "OfferKingdom %d\n", trade->offering_kingdom); fprintf(fpout, "ReceiveKingdom %d\n", trade->receiving_kingdom); fprintf(fpout, "OfferLumber %d\n", trade->offering_res_tree); fprintf(fpout, "OfferCorn %d\n", trade->offering_res_corn); fprintf(fpout, "OfferFish %d\n", trade->offering_res_fish); fprintf(fpout, "OfferGrain %d\n", trade->offering_res_grain); fprintf(fpout, "OfferIron %d\n", trade->offering_res_iron); fprintf(fpout, "OfferGold %d\n", trade->offering_res_gold); fprintf(fpout, "OfferStone %d\n", trade->offering_res_stone); fprintf(fpout, "OfferCoins %d\n", trade->offering_gold); fprintf(fpout, "ReceiveLumber %d\n", trade->receiving_res_tree); fprintf(fpout, "ReceiveCorn %d\n", trade->receiving_res_corn); fprintf(fpout, "ReceiveFish %d\n", trade->receiving_res_fish); fprintf(fpout, "ReceiveGrain %d\n", trade->receiving_res_grain); fprintf(fpout, "ReceiveIron %d\n", trade->receiving_res_iron); fprintf(fpout, "ReceiveGold %d\n", trade->receiving_res_gold); fprintf(fpout, "ReceiveStone %d\n", trade->receiving_res_stone); fprintf(fpout, "ReceiveCoins %d\n", trade->receiving_gold); fprintf(fpout, "OfferRead %d\n", trade->offering_read); fprintf(fpout, "ReceiveRead %d\n", trade->receiving_read); fprintf(fpout, "Time %d\n", trade->time); fprintf(fpout, "Posted %d\n", trade->posted); fprintf(fpout, "End\n"); } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_trade_data(FILE *fp) { bool fMatch; char *word; TRADE_DATA *trade; CREATE(trade, TRADE_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'O': KEY("OfferKingdom", trade->offering_kingdom, fread_number(fp)); KEY("OfferLumber", trade->offering_res_tree, fread_number(fp)); KEY("OfferCorn", trade->offering_res_corn, fread_number(fp)); KEY("OfferFish", trade->offering_res_fish, fread_number(fp)); KEY("OfferGrain", trade->offering_res_grain, fread_number(fp)); KEY("OfferIron", trade->offering_res_iron, fread_number(fp)); KEY("OfferGold", trade->offering_res_gold, fread_number(fp)); KEY("OfferStone", trade->offering_res_stone, fread_number(fp)); KEY("OfferCoins", trade->offering_gold, fread_number(fp)); KEY("OfferRead", trade->offering_read, fread_number(fp)); break; case 'P': KEY("Posted", trade->posted, fread_number(fp)); break; case 'R': KEY("ReceiveKingdom", trade->receiving_kingdom, fread_number(fp)); KEY("ReceiveLumber", trade->receiving_res_tree, fread_number(fp)); KEY("ReceiveCorn", trade->receiving_res_corn, fread_number(fp)); KEY("ReceiveFish", trade->receiving_res_fish, fread_number(fp)); KEY("ReceiveGrain", trade->receiving_res_grain, fread_number(fp)); KEY("ReceiveIron", trade->receiving_res_iron, fread_number(fp)); KEY("ReceiveGold", trade->receiving_res_gold, fread_number(fp)); KEY("ReceiveStone", trade->receiving_res_stone, fread_number(fp)); KEY("ReceiveRead", trade->receiving_read, fread_number(fp)); break; case 'T': KEY("Time", trade->time, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(trade, first_trade, last_trade, next, prev); return; } } } } void load_trade_file() { FILE *fp; char filename[MIL]; sprintf(filename, "%s%s", KINGDOM_DIR, TRADE_FILE); if ((fp = fopen(filename, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_kingdom_depo: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "TRADE")) { fread_trade_data(fp); continue; } else if (!str_cmp(word, "END")) { fclose(fp); return; } else { bug("Load_kingdom_depo: bad section.", 0); continue; } } } else { bug("Cannot open the trade file", 0); return; } } void load_default_depo() { int kingdom; DEPO_ORE_DATA *dore; DEPO_ORE_DATA *ohold; DEPO_WEAPON_DATA *dweapon; DEPO_WEAPON_DATA *dweap; DEPO_WEAPON_DATA *dhold; SLAB_DATA *slab; FORGE_DATA *forge; for (kingdom = 0; kingdom <= sysdata.max_kingdom-1; kingdom++) { if (kingdom_table[kingdom]->first_ore == NULL) //no depository loaded up yet... { for (slab = first_slab; slab ; slab = slab->next) { CREATE(dore, DEPO_ORE_DATA, 1); dore->vnum = slab->vnum; LINK(dore, kingdom_table[kingdom]->first_ore, kingdom_table[kingdom]->last_ore, next, prev); for (forge = first_forge; forge; forge = forge->next) { CREATE(dweapon, DEPO_WEAPON_DATA, 1); dweapon->vnum = forge->vnum; LINK(dweapon, dore->first_weapon, dore->last_weapon, next, prev); } } } else //make sure the lists match the ore/weapon list...if they don't, remove or create.... { //check the weapon list now.....only need to do one check and then update the whole list if needed.... for (forge = first_forge; forge; forge = forge->next) { for (dweapon = kingdom_table[kingdom]->first_ore->first_weapon; dweapon; dweapon = dweapon->next) { if (forge->vnum == dweapon->vnum) break; } if (!dweapon) //Create the weapon in all the lists { for (dore = kingdom_table[kingdom]->first_ore; dore; dore = dore->next) { CREATE(dweapon, DEPO_WEAPON_DATA, 1); dweapon->vnum = forge->vnum; LINK(dweapon, dore->first_weapon, dore->last_weapon, next, prev); } } } for (dweapon = kingdom_table[kingdom]->first_ore->first_weapon; dweapon; dweapon = dhold) { dhold = dweapon->next; for (forge = first_forge; forge; forge = forge->next) { if (forge->vnum == dweapon->vnum) break; } if (!forge) { for (dore = kingdom_table[kingdom]->first_ore; dore; dore = dore->next) { for (dweap = dore->first_weapon; dweap; dweap = dweap->next) { if (dweap->vnum == dweapon->vnum) { UNLINK(dweapon, dore->first_weapon, dore->last_weapon, next, prev); DISPOSE(dweapon); } } } } } //check the ore lists last.... for (slab = first_slab; slab; slab = slab->next) { for (dore = kingdom_table[kingdom]->first_ore; dore; dore = dore->next) { if (slab->vnum == dore->vnum) break; } if (!dore) //doesn't exist in depository, create it... { CREATE(dore, DEPO_ORE_DATA, 1); dore->vnum = slab->vnum; LINK(dore, kingdom_table[kingdom]->first_ore, kingdom_table[kingdom]->last_ore, next, prev); for (forge = first_forge; forge; forge = forge->next) { CREATE(dweapon, DEPO_WEAPON_DATA, 1); dweapon->vnum = forge->vnum; LINK(dweapon, dore->first_weapon, dore->last_weapon, next, prev); } } } for (dore = kingdom_table[kingdom]->first_ore; dore; dore = ohold) { ohold = dore->next; for (slab = first_slab; slab; slab = slab->next) { if (slab->vnum == dore->vnum) break; } if (!slab) //doesn't exist in slab list, delete it.... { UNLINK(dore, kingdom_table[kingdom]->first_ore, kingdom_table[kingdom]->last_ore, next, prev); for (dweapon = dore->first_weapon; dweapon; dweapon = dweapon->next) { UNLINK(dweapon, dore->first_weapon, dore->last_weapon, next, prev); DISPOSE(dweapon); } DISPOSE(dore); } } } } } void write_depo_list() { FILE *fpout; DEPO_ORE_DATA *dore; DEPO_WEAPON_DATA *dweapon; char buf[MSL]; char filename[MIL]; int x; for (x = 0; x < sysdata.max_kingdom; x++) { sprintf(filename, "%s%s.depo", KINGDOM_DIR, kingdom_table[x]->name); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } for (dore = kingdom_table[x]->first_ore; dore; dore = dore->next) { fprintf(fpout, "#ORE\n"); fprintf(fpout, "Vnum %d\n", dore->vnum); fprintf(fpout, "Count %d\n", dore->count); fprintf(fpout, "End\n"); for (dweapon = dore->first_weapon; dweapon; dweapon = dweapon->next) { fprintf(fpout, "#WEAPON\n"); fprintf(fpout, "Vnum %d\n", dweapon->vnum); fprintf(fpout, "Count %d\n", dweapon->count); fprintf(fpout, "End\n"); } fprintf(fpout, "#NEXT\n"); } fprintf(fpout, "#END\n"); fclose(fpout); } return; } void fread_depoweapon_data(FILE *fp, DEPO_ORE_DATA *dore) { bool fMatch; char *word; int vnum = 0; int cnt = 0; DEPO_WEAPON_DATA *dweapon; FORGE_DATA *forge; for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Count", cnt, fread_number(fp)); break; case 'V': KEY("Vnum", vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { for (forge = first_forge; forge; forge = forge->next) { if (forge->vnum == vnum) { CREATE(dweapon, DEPO_WEAPON_DATA, 1); dweapon->vnum = forge->vnum; dweapon->count = cnt; LINK(dweapon, dore->first_weapon, dore->last_weapon, next, prev); break; } } return; } } } } void fread_depoore_data(FILE *fp, int kingdom) { bool fMatch; char letter; char *word; int vnum = 0; char buf[MSL]; int cnt = 0; DEPO_ORE_DATA *dore = NULL; SLAB_DATA *slab; for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Count", cnt, fread_number(fp)); break; case 'V': KEY("Vnum", vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { for (slab = first_slab; slab ; slab = slab->next) { if (slab->vnum == vnum) { CREATE(dore, DEPO_ORE_DATA, 1); dore->vnum = slab->vnum; dore->count = cnt; LINK(dore, kingdom_table[kingdom]->first_ore, kingdom_table[kingdom]->last_ore, next, prev); break; } } if (!slab) { for(;;) { word = fread_word(fp); if (!str_cmp(word, "#ORE")) { fread_depoore_data(fp, kingdom); return; } if (feof(fp)) return; } } else { for(;;) { letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_kingdom_depo: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "WEAPON")) { fread_depoweapon_data(fp, dore); continue; } else if (!str_cmp(word, "NEXT")) { //done break now return; } } } break; } } if (!fMatch) { sprintf(buf, "fread_deopore_data: no match: %s", word); bug(buf, 0); } } } void load_kingdom_depo() { FILE *fp; char filename[MIL]; int x; for (x = 0; x < sysdata.max_kingdom; x++) { sprintf(filename, "%s%s.depo", KINGDOM_DIR, kingdom_table[x]->name); if ((fp = fopen(filename, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_kingdom_depo: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "ORE")) { fread_depoore_data(fp, x); continue; } else if (!str_cmp(word, "END")) { break; } else { bug("Load_kingdom_depo: bad section.", 0); continue; } } } else { bug("Cannot open a kingdom depo file", 0); continue; } fclose(fp); } } int get_control_size(int size) { switch(size) { case 1: return 3; case 2: return 4; case 3: return 6; case 4: return 7; case 5: return 9; case 6: return 11; case 7: return 13; case 8: return 15; case 9: return 18; case 10: return 25; default: return 3; } } //Loads town data out of the kingdom void load_town_data(KINGDOM_DATA *kingdom, FILE *fp) { char *word; char buf[MSL]; bool fMatch; int x, y, map; int size; TOWN_DATA *town; DOOR_DATA *ddata = NULL; DOOR_LIST *dlist; SCHEDULE_DATA *schedule; CREATE(town, TOWN_DATA, 1); //I love it how a random 1 just appears in things.... for (x = 0; x <= 59; x++) { for (y = 0; y <= 59; y++) { town->usedpoint[x][y] = 0; } } for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case '#': if (!strcmp(word, "#BANK")) { globaltownload = 1; globaltownptr = town; fread_obj(NULL, fp, OS_BANK); globaltownload = 0; globaltownptr = NULL; fMatch = TRUE; } case 'A': KEY("Allowexpansions", town->allowexpansions, fread_number(fp)); break; case 'B': KEY("Banksize", town->banksize, fread_number(fp)); KEY("Balance", town->balance, fread_number(fp)); if (!str_cmp(word, "Barracks")) { town->barracks[0] = fread_number(fp); town->barracks[1] = fread_number(fp); town->barracks[2] = fread_number(fp); fMatch = TRUE; } if (!str_cmp(word, "BinCoords")) { for (y = 0; y <= 59; y++) { for (x = 0; x <= 59; x++) { town->bincoords[x][y] = fread_number(fp); } } fMatch = TRUE; break; } break; case 'C': KEY("Corn", town->corn, fread_number(fp)); KEY("Coinconsump", town->coinconsump, fread_number(fp)); KEY("Coins", town->coins, fread_number(fp)); if (!str_cmp(word, "Coords")) { char *string; x = fread_number(fp); town->roomcoords[x][0] = fread_number(fp); town->roomcoords[x][1] = fread_number(fp); town->roomcoords[x][2] = fread_number(fp); kingdom_sector[town->roomcoords[x][2]][town->roomcoords[x][0]][town->roomcoords[x][1]] = town->kingdom; town->roomflags[x] = fread_bitvector(fp); string = fread_string(fp); sprintf(town->roomtitles[x], string); fMatch = TRUE; break; } KEY("CTax", town->ctax, fread_number(fp)); break; case 'F': KEY("Fish", town->fish, fread_number(fp)); KEY("Foodconsump", town->foodconsump, fread_number(fp)); break; case 'L': KEY("Lumber", town->lumber, fread_number(fp)); KEY("Lumberconsump", town->lumberconsump, fread_number(fp)); KEY("LastTaxChange", town->lasttaxchange, fread_number(fp)); break; case 'S': KEY("Salestax", town->salestax, fread_number(fp)); if (!str_cmp(word, "Schedule")) { CREATE(schedule, SCHEDULE_DATA, 1); schedule->start_period = fread_number(fp); schedule->end_period = fread_number(fp); schedule->resource = fread_number(fp); schedule->reoccur = fread_number(fp); schedule->ran = fread_number(fp); schedule->x = fread_number(fp); schedule->y = fread_number(fp); schedule->map = fread_number(fp); LINK(schedule, town->first_schedule, town->last_schedule, next, prev); fMatch = TRUE; break; } KEY("Size", town->size, fread_number(fp)); KEY("Startx", town->startx, fread_number(fp)); KEY("Starty", town->starty, fread_number(fp)); KEY("Startmap", town->startmap, fread_number(fp)); KEY("Stone", town->stone, fread_number(fp)); KEY("Stoneconsump", town->stoneconsump, fread_number(fp)); break; case 'N': KEY("Name", town->name, fread_string(fp)); break; case 'H': KEY("Hold", town->hold, fread_number(fp)); break; case 'U': if (!str_cmp(word, "UsedPoint")) { for (y = 0; y <= 59; y++) { for (x = 0; x <= 59; x++) { town->usedpoint[x][y] = fread_number(fp); } } fMatch = TRUE; break; } KEY("Units", town->units, fread_number(fp)); KEY("Unitstraining", town->unitstraining, fread_number(fp)); break; case 'M': KEY("Mayor", town->mayor, fread_string(fp)); KEY("MaxDvalue", town->max_dvalue, fread_number(fp)); KEY("MaxSize", town->maxsize, fread_number(fp)); KEY("MinHAppoint", town->minhappoint, fread_number(fp)); KEY("MinWithdraw", town->minwithdraw, fread_number(fp)); KEY("Moral", town->moral, fread_number(fp)); KEY("Month", town->month, fread_number(fp)); break; case 'K': if (!str_cmp(word, "Key")) { KEY_DATA *key; CREATE(key, KEY_DATA, 1); LINK(key, town->first_key, town->last_key, next, prev); for (;;) { word = feof(fp) ? "End" : fread_word(fp); if (!str_cmp(word, "End")) { bug("%s in kingdom %d did not load properly, looped in key!", town->name, town->kingdom); break; } if (!str_cmp(word, "ENDKEY")) break; if (!str_cmp(word, "Flag")) { key->flag = fread_number(fp); continue; } if (!str_cmp(word, "Name")) { key->name = fread_string(fp); continue; } } fMatch = TRUE; break; } KEY("Kpid", town->kpid, fread_number(fp)); KEY("Kingdom", town->kingdom, fread_number(fp)); break; case 'G': KEY("Grain", town->grain, fread_number(fp)); KEY("Growth", town->growth, fread_number(fp)); KEY("Growthcheck", town->growthcheck, fread_number(fp)); KEY("Gold", town->gold, fread_number(fp)); break; case 'I': KEY("Iron", town->iron, fread_number(fp)); break; case 'R': if (!str_cmp(word, "Recall")) { town->recall[0] = fread_number(fp); town->recall[1] = fread_number(fp); town->recall[2] = fread_number(fp); fMatch = TRUE; break; } KEY("Rooms", town->rooms, fread_number(fp)); break; case 'D': if (!str_cmp(word, "Death")) { town->death[0] = fread_number(fp); town->death[1] = fread_number(fp); town->death[2] = fread_number(fp); fMatch = TRUE; break; } if (!str_cmp(word, "Doordata")) { CREATE(dlist, DOOR_LIST, 1); LINK(dlist, town->first_doorlist, town->last_doorlist, next, prev); for (;;) { word = feof(fp) ? "End" : fread_word(fp); if (!str_cmp(word, "End")) { bug("%s in kingdom %d did not load properly, looped in doordata!", town->name, town->kingdom); break; } if (!str_cmp(word, "Enddoor")) break; if (!str_cmp(word, "DCoords")) { x = fread_number(fp); ddata->roomcoordx[x] = fread_number(fp); ddata->roomcoordy[x] = fread_number(fp); ddata->roomcoordmap[x] = fread_number(fp); continue; } if (!str_cmp(word, "Doorvalue")) { CREATE(ddata, DOOR_DATA, 1); LINK(ddata, dlist->first_door, dlist->last_door, next, prev); ddata->doorvalue[0] = fread_number(fp); ddata->doorvalue[1] = fread_number(fp); ddata->doorvalue[2] = fread_number(fp); ddata->doorvalue[3] = fread_number(fp); ddata->doorvalue[4] = fread_number(fp); ddata->doorvalue[5] = fread_number(fp); ddata->doorvalue[6] = fread_number(fp); ddata->doorvalue[7] = fread_number(fp); ddata->doorvalue[8] = fread_number(fp); ddata->doorvalue[9] = fread_number(fp); continue; } if (!str_cmp(word, "Cansee")) { ddata->cansee = fread_number(fp); continue; } } fMatch = TRUE; break; } if (!str_cmp(word, "Doorstate")) { x = fread_number(fp); town->doorstate[0][x] = fread_number(fp); town->doorstate[1][x] = fread_number(fp); town->doorstate[2][x] = fread_number(fp); town->doorstate[3][x] = fread_number(fp); town->doorstate[4][x] = fread_number(fp); town->doorstate[5][x] = fread_number(fp); town->doorstate[6][x] = fread_number(fp); town->doorstate[7][x] = fread_number(fp); //Map doesn't save when a door is changed, this is to save processing for //slower machines and to keep the doors in sync by checking here... if (town->doorstate[5][x] > -1 && town->doorstate[6][x] > -1 && town->doorstate[7][x] > -1) { if (town->doorstate[0][x] == 0) map_sector[town->doorstate[7][x]][town->doorstate[5][x]][town->doorstate[6][x]] = SECT_DOOR; if (town->doorstate[0][x] == 1) map_sector[town->doorstate[7][x]][town->doorstate[5][x]][town->doorstate[6][x]] = SECT_CDOOR; if (town->doorstate[0][x] == 2) map_sector[town->doorstate[7][x]][town->doorstate[5][x]][town->doorstate[6][x]] = SECT_LDOOR; } fMatch = TRUE; break; } case 'P': KEY("Poptax", town->poptax, fread_number(fp)); break; case 'T': KEY("TPid", town->tpid, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(town, kingdom->first_town, kingdom->last_town, next, prev); map = town->roomcoords[1][2]; size = get_control_size(town->size); for (x = town->startx - size; x <= town->startx+size; x++) { for (y = town->starty - size; y <= town->starty+size; y++) { kingdom_sector[map][x][y] = town->kingdom; } } return; } KEY("Expansions", town->expansions, fread_number(fp)); } if (!fMatch) { sprintf(buf, "load_town_data: no match: %s", word); bug(buf, 0); } } return; } /* First attempt to add a structure. Will replace the old hometown code and will allowing for editing online...Spiffy -- Xerves two days before Christmas 99 */ bool load_kingdom_file(char *fname) { char buf[MSL]; char *word; bool fMatch; int kpeace[MAX_KINGDOM]; INTRO_DATA *intro; struct kingdom_data *kingdom; int x; FILE *fp; int x1, x2, x3, x4; char *ln; int toss; for (x = 0; x < sysdata.max_kingdom; x++) { kpeace[x] = 0; } sprintf(buf, "%s%s", KINGDOM_DIR, fname); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return FALSE; } CREATE(kingdom, struct kingdom_data, 1); kingdom->num = -1; kingdom->first_introduction = NULL; kingdom->last_introduction = NULL; kingdom->first_town = NULL; kingdom->last_town = NULL; //Init the que to 0 for (x = 0; x <= 25; x++) { kingdom->mob_que[x] = 0; kingdom->obj_que[x] = 0; } for (x = 0; x < sysdata.max_kingdom; x++) kingdom->cpeace[x] = -1; for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("AllowJoin", kingdom->allowjoin, fread_number(fp)); break; case 'B': KEY("BVisitorTax", kingdom->bvisitor, fread_number(fp)); break; case 'C': if (!str_cmp(word, "CPeace")) { ln = fread_line(fp); x1 = x2 = 0; sscanf(ln, "%d %d", &x1, &x2); kingdom->cpeace[x1] = x2; fMatch = TRUE; } KEY("CTax", kingdom->ctax, fread_number(fp)); break; case 'D': KEY("DTown", kingdom->dtown, fread_string(fp)); break; case 'E': if (!str_cmp(word, "End")) { fclose(fp); if (kingdom->num < 0 || kingdom->num > sysdata.max_kingdom) { sprintf(buf, "Load_kingdom_file: Kingdom (%s) bad/not found (%d)", kingdom->name ? kingdom->name : "name not found", kingdom->num); bug(buf, 0); if (kingdom->name) STRFREE(kingdom->name); DISPOSE(kingdom); return FALSE; } //Add default of Neutral when first loaded, or new kingdom arrives for (x = 0; x < sysdata.max_kingdom; x++) { if (kpeace[x] == 0) kingdom->peace[x] = 1; } kingdom_table[kingdom->num] = kingdom; return TRUE; } case 'G': //Are no longer used, kept in for support for old files KEY("Gold", toss, fread_number(fp)); break; case 'I': if (!str_cmp(word, "Intro")) { ln = fread_line(fp); x1 = x2 = x3 = 0; sscanf(ln, "%d %d %d %d", &x1, &x2, &x3, &x4); CREATE(intro, INTRO_DATA, 1); intro->pid = x1; intro->flags = x2; intro->value = x3; intro->lastseen = x4; LINK(intro, kingdom->first_introduction, kingdom->last_introduction, next, prev); fMatch = TRUE; } break; case 'L': KEY("LastIntroCheck", kingdom->lastintrocheck, fread_number(fp)); KEY("LastTax", kingdom->lasttaxchange, fread_number(fp)); KEY("LogFile", kingdom->logfile, fread_string(fp)); KEY("Logsettings", kingdom->logsettings, fread_bitvector(fp)); break; case 'K': KEY("Kingdom", kingdom->num, fread_number(fp)); KEY("KPid", kingdom->kpid, fread_number(fp)); break; case 'M': KEY("MaxLineLog", kingdom->maxlinelog, fread_number(fp)); KEY("MaxTimeLog", kingdom->maxtimelog, fread_number(fp)); KEY("MinBuild", kingdom->minbuild, fread_number(fp)); KEY("MinDepository", kingdom->mindepository, fread_number(fp)); KEY("MinPlace", kingdom->minplace, fread_number(fp)); KEY("MinReadLog", kingdom->minreadlog, fread_number(fp)); KEY("MinCommand", kingdom->mincommand, fread_number(fp)); KEY("MinAppoint", kingdom->minappoint, fread_number(fp)); KEY("MinHAppoint", kingdom->minhappoint, fread_number(fp)); KEY("MinWithdraw", kingdom->minwithdraw, fread_number(fp)); KEY("MinTrainerTax", kingdom->mintrainertax, fread_number(fp)); KEY("MinSwitchTown", kingdom->minswitchtown, fread_number(fp)); KEY("MinBookTax", kingdom->minbooktax, fread_number(fp)); KEY("MinLogSettings", kingdom->minlogsettings, fread_number(fp)); KEY("MinGeneral", kingdom->mingeneral, fread_number(fp)); break; case 'N': KEY("Name", kingdom->name, fread_string(fp)); KEY("Number1", kingdom->number1, fread_string(fp)); KEY("Number2", kingdom->number2, fread_string(fp)); break; case 'P': if (!str_cmp(word, "Peace")) { ln = fread_line(fp); x1 = x2 = 0; sscanf(ln, "%d %d", &x1, &x2); kingdom->peace[x1] = x2; kpeace[x1] = 1; fMatch = TRUE; } KEY("PopTax", kingdom->poptax, fread_number(fp)); break; case 'R': KEY("Race", kingdom->race, fread_number(fp)); KEY("Raceset", kingdom->raceset, fread_number(fp)); //Are no longer used, kept in for support for old files KEY("ResGold", toss, fread_number(fp)); KEY("ResIron", toss, fread_number(fp)); KEY("ResTree", toss, fread_number(fp)); KEY("ResCorn", toss, fread_number(fp)); KEY("ResGrain", toss, fread_number(fp)); KEY("ResStone", toss, fread_number(fp)); KEY("Ruler", kingdom->ruler, fread_string(fp)); break; case 'S': KEY("SalesTax", kingdom->salestax, fread_number(fp)); break; case 'T': if (!str_cmp(word, "Towndata")) { load_town_data(kingdom, fp); fMatch = TRUE; break; } KEY("TaxCorn", kingdom->corn_tax, fread_number(fp)); KEY("TaxFish", kingdom->fish_tax, fread_number(fp)); KEY("TaxGrain", kingdom->grain_tax, fread_number(fp)); KEY("TaxTree", kingdom->tree_tax, fread_number(fp)); KEY("TaxIron", kingdom->iron_tax, fread_number(fp)); KEY("TaxGold", kingdom->gold_tax, fread_number(fp)); KEY("TaxStone", kingdom->stone_tax, fread_number(fp)); KEY("Tier1Tax", kingdom->tier1, fread_number(fp)); KEY("Tier2Tax", kingdom->tier2, fread_number(fp)); KEY("Tier3Tax", kingdom->tier3, fread_number(fp)); KEY("Tier4Tax", kingdom->tier4, fread_number(fp)); KEY("TVisitorTax", kingdom->tvisitor, fread_number(fp)); KEY("Tier1TaxBook", kingdom->tier1book, fread_number(fp)); KEY("Tier2TaxBook", kingdom->tier2book, fread_number(fp)); KEY("Tier3TaxBook", kingdom->tier3book, fread_number(fp)); KEY("Tier4TaxBook", kingdom->tier4book, fread_number(fp)); break; } if (!fMatch) { sprintf(buf, "load_kingdom_file: no match: %s", word); bug(buf, 0); } } return FALSE; } char *parse_save_file(char *name) { static char pname[100]; int x = 0; for (;;) { if (*name == '\0') { pname[x] = *name; break; } if ((*name >= 65 && *name <= 90) || (*name >= 97 && *name <= 122)) pname[x++] = *name++; else name++; } return &pname[0]; } void write_kingdom_list() { FILE *fpout; char buf[MSL]; char filename[MIL]; int x; sprintf(filename, "%s%s", KINGDOM_DIR, KINGDOM_LIST); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } for (x = 0; x < sysdata.max_kingdom; x++) fprintf(fpout, "%s.kingdom\n", parse_save_file(kingdom_table[x]->name)); fprintf(fpout, "$"); fclose(fpout); return; } void write_kingdom_file(int cl) { FILE *fpout; char buf[MSL]; char filename[MIL]; int x, y; struct kingdom_data *kingdom = kingdom_table[cl]; TOWN_DATA *town; INTRO_DATA *intro; DOOR_LIST *dlist; DOOR_DATA *ddata; SCHEDULE_DATA *schedule; sprintf(filename, "%s%s.kingdom", KINGDOM_DIR, parse_save_file(kingdom->name)); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } fprintf(fpout, "Kingdom %d\n", cl); fprintf(fpout, "KPid %d\n", kingdom->kpid); fprintf(fpout, "Name %s~\n", kingdom->name); if (kingdom->logfile) fprintf(fpout, "LogFile %s~\n", kingdom->logfile); else { sprintf(buf, "%s%slog.txt", KINGDOM_DIR, kingdom->name); kingdom->logfile = STRALLOC(buf); fprintf(fpout, "LogFile %s~\n", kingdom->logfile); } if (kingdom->dtown) fprintf(fpout, "DTown %s~\n", kingdom->dtown); /* --Removed fprintf(fpout, "ResGold %d\n", kingdom->res_gold); fprintf(fpout, "ResIron %d\n", kingdom->res_iron); fprintf(fpout, "ResStone %d\n", kingdom->res_stone); fprintf(fpout, "ResCorn %d\n", kingdom->res_corn); fprintf(fpout, "ResGrain %d\n", kingdom->res_grain); fprintf(fpout, "ResTree %d\n", kingdom->res_tree); */ fprintf(fpout, "TaxTree %d\n", kingdom->tree_tax); fprintf(fpout, "TaxGrain %d\n", kingdom->grain_tax); fprintf(fpout, "TaxCorn %d\n", kingdom->corn_tax); fprintf(fpout, "TaxFish %d\n", kingdom->fish_tax); fprintf(fpout, "TaxStone %d\n", kingdom->stone_tax); fprintf(fpout, "TaxIron %d\n", kingdom->iron_tax); fprintf(fpout, "TaxGold %d\n", kingdom->gold_tax); //fprintf(fpout, "Gold %d\n", kingdom->gold); fprintf(fpout, "MinBuild %d\n", kingdom->minbuild); fprintf(fpout, "MinPlace %d\n", kingdom->minplace); fprintf(fpout, "MinAppoint %d\n", kingdom->minappoint); fprintf(fpout, "MinHAppoint %d\n", kingdom->minhappoint); fprintf(fpout, "MinWithdraw %d\n", kingdom->minwithdraw); fprintf(fpout, "MinReadLog %d\n", kingdom->minreadlog); fprintf(fpout, "MinLogSettings %d\n", kingdom->minlogsettings); fprintf(fpout, "MinCommand %d\n", kingdom->mincommand); fprintf(fpout, "MinDepository %d\n", kingdom->mindepository); fprintf(fpout, "MinTrainerTax %d\n", kingdom->mintrainertax); fprintf(fpout, "MinBookTax %d\n", kingdom->minbooktax); fprintf(fpout, "MinSwitchTown %d\n", kingdom->minswitchtown); fprintf(fpout, "MinGeneral %d\n", kingdom->mingeneral); fprintf(fpout, "AllowJoin %d\n", kingdom->allowjoin); fprintf(fpout, "SalesTax %d\n", kingdom->salestax); fprintf(fpout, "PopTax %d\n", kingdom->poptax); fprintf(fpout, "CTax %d\n", kingdom->ctax); fprintf(fpout, "Ruler %s~\n", kingdom->ruler); fprintf(fpout, "Race %d\n", kingdom->race); fprintf(fpout, "Raceset %d\n", kingdom->raceset); fprintf(fpout, "LastTax %d\n", kingdom->lasttaxchange); fprintf(fpout, "Tier1Tax %d\n", kingdom->tier1); fprintf(fpout, "Tier2Tax %d\n", kingdom->tier2); fprintf(fpout, "Tier3Tax %d\n", kingdom->tier3); fprintf(fpout, "Tier4Tax %d\n", kingdom->tier4); fprintf(fpout, "TVisitorTax %d\n", kingdom->tvisitor); fprintf(fpout, "Tier1TaxBook %d\n", kingdom->tier1book); fprintf(fpout, "Tier2TaxBook %d\n", kingdom->tier2book); fprintf(fpout, "Tier3TaxBook %d\n", kingdom->tier3book); fprintf(fpout, "Tier4TaxBook %d\n", kingdom->tier4book); fprintf(fpout, "BVisitorTax %d\n", kingdom->bvisitor); fprintf(fpout, "MaxLineLog %d\n", kingdom->maxlinelog); fprintf(fpout, "MaxTimeLog %d\n", kingdom->maxtimelog); if (kingdom->number1) fprintf(fpout, "Number1 %s~\n", kingdom->number1); if (kingdom->number2) fprintf(fpout, "Number2 %s~\n", kingdom->number2); for (x = 0; x < sysdata.max_kingdom; x++) { fprintf(fpout, "Peace %d %d\n", x, kingdom->peace[x]); } for (x = 0; x < sysdata.max_kingdom; x++) { fprintf(fpout, "CPeace %d %d\n", x, kingdom->cpeace[x]); } fprintf(fpout, "Logsettings %s\n", print_bitvector(&kingdom->logsettings)); fprintf(fpout, "LastIntroCheck %d\n", kingdom->lastintrocheck); for (intro = kingdom->first_introduction; intro; intro = intro->next) { fprintf(fpout, "Intro %d %d %d %d\n", intro->pid, intro->flags, intro->value, intro->lastseen); } for (town = kingdom->first_town; town; town = town->next) { fprintf(fpout, "TownData\n"); fprintf(fpout, "Name %s~\n", town->name); fprintf(fpout, "Mayor %s~\n", town->mayor); fprintf(fpout, "Kpid %d\n", town->kpid); fprintf(fpout, "Tpid %d\n", town->tpid); fprintf(fpout, "Kingdom %d\n", town->kingdom); fprintf(fpout, "Corn %d\n", town->corn); fprintf(fpout, "Fish %d\n", town->fish); fprintf(fpout, "Grain %d\n", town->grain); fprintf(fpout, "Gold %d\n", town->gold); fprintf(fpout, "Iron %d\n", town->iron); fprintf(fpout, "Lumber %d\n", town->lumber); fprintf(fpout, "Coins %d\n", town->coins); fprintf(fpout, "Stone %d\n", town->stone); fprintf(fpout, "Hold %d\n", town->hold); fprintf(fpout, "Barracks %d %d %d\n", town->barracks[0], town->barracks[1], town->barracks[2]); fprintf(fpout, "Recall %d %d %d\n", town->recall[0], town->recall[1], town->recall[2]); fprintf(fpout, "Death %d %d %d\n", town->death[0], town->death[1], town->death[2]); fprintf(fpout, "Startx %d\n", town->startx); fprintf(fpout, "Starty %d\n", town->starty); fprintf(fpout, "Startmap %d\n", town->startmap); fprintf(fpout, "Poptax %d\n", town->poptax); fprintf(fpout, "CTax %d\n", town->ctax); fprintf(fpout, "Salestax %d\n", town->salestax); fprintf(fpout, "Units %d\n", town->units); fprintf(fpout, "Unitstraining %d\n", town->unitstraining); fprintf(fpout, "Size %d\n", town->size); fprintf(fpout, "Rooms %d\n", town->rooms); fprintf(fpout, "MaxSize %d\n", town->maxsize); fprintf(fpout, "AllowExpansions %d\n", town->allowexpansions); fprintf(fpout, "Expansions %d\n", town->expansions); fprintf(fpout, "MinHAppoint %d\n", town->minhappoint); fprintf(fpout, "MinWithdraw %d\n", town->minwithdraw); fprintf(fpout, "LastTaxChange %d\n", town->lasttaxchange); fprintf(fpout, "Moral %d\n", town->moral); fprintf(fpout, "Month %d\n", town->month); fprintf(fpout, "Growth %d\n", town->growth); fprintf(fpout, "Growthcheck %d\n", town->growthcheck); fprintf(fpout, "Foodconsump %d\n", town->foodconsump); fprintf(fpout, "Stoneconsump %d\n", town->stoneconsump); fprintf(fpout, "Lumberconsump %d\n", town->lumberconsump); fprintf(fpout, "Coinconsump %d\n", town->coinconsump); fprintf(fpout, "Banksize %d\n", town->banksize); fprintf(fpout, "Balance %d\n", town->balance); for (schedule = town->first_schedule; schedule; schedule = schedule->next) { fprintf(fpout, "Schedule %d %d %d %d %d %d %d %d\n", schedule->start_period, schedule->end_period, schedule->resource, schedule->reoccur, schedule->ran, schedule->x, schedule->y, schedule->map); } fprintf(fpout, "BinCoords "); for (y = 0; y <= 59; y++) { if (y > 0) //Cosmetic thing, ha ha they must line up! fprintf(fpout, " "); for (x = 0; x <= 59; x++) { fprintf(fpout, " %d", town->bincoords[x][y]); } fprintf(fpout, "\n"); } for (x = 1; x <= 150; x++) { if (town->roomcoords[x][1] > 0) { fprintf(fpout, "Coords %d %d %d %d %s %s~\n", x, town->roomcoords[x][0], town->roomcoords[x][1], town->roomcoords[x][2], print_bitvector(&town->roomflags[x]), town->roomtitles[x]); } } for (x = 0; x <= 99; x++) { if (town->doorstate[4][x] > 0) fprintf(fpout, "Doorstate %d %d %d %d %d %d %d %d %d\n", x, town->doorstate[0][x], town->doorstate[1][x], town->doorstate[2][x], town->doorstate[3][x], town->doorstate[4][x], town->doorstate[5][x], town->doorstate[6][x], town->doorstate[7][x]); } fprintf(fpout, "UsedPoint "); for (y = 0; y <= 59; y++) { if (y > 0) //Cosmetic thing, ha ha they must line up! fprintf(fpout, " "); for (x = 0; x <= 59; x++) { fprintf(fpout, " %d", town->usedpoint[x][y]); } fprintf(fpout, "\n"); } fprintf(fpout, "MaxDvalue %d\n", town->max_dvalue); if (town->first_doorlist) { for (dlist = town->first_doorlist; dlist; dlist = dlist->next) { fprintf(fpout, "DOORDATA\n"); for (ddata = dlist->first_door; ddata; ddata = ddata->next) { //Doorvalue has to be first, the loading routine creates ddata when it finds it, so this has //to be the first entry here!!!!! fprintf(fpout, "Doorvalue %d %d %d %d %d %d %d %d %d %d\n", ddata->doorvalue[0], ddata->doorvalue[1], ddata->doorvalue[2], ddata->doorvalue[3], ddata->doorvalue[4], ddata->doorvalue[5], ddata->doorvalue[6], ddata->doorvalue[7], ddata->doorvalue[8], ddata->doorvalue[9]); for (x = 0; x <= MAX_HPOINTS-1; x++) { if (ddata->roomcoordx[x]) { fprintf(fpout, "DCoords %d %d %d %d\n", x, ddata->roomcoordx[x], ddata->roomcoordy[x], ddata->roomcoordmap[x]); } else break; } fprintf(fpout, "Cansee %d\n", ddata->cansee); } fprintf(fpout, "ENDDOOR\n"); } } if (town->first_key) { KEY_DATA *key; for (key = town->first_key; key; key = key->next) { fprintf(fpout, "KEY\n"); fprintf(fpout, "Flag %d\n", key->flag); fprintf(fpout, "Name %s~\n", key->name); fprintf(fpout, "ENDKEY\n"); } } if (town->first_bankobj) fwrite_obj(NULL, town->last_bankobj, fpout, 0, OS_BANK); fprintf(fpout, "End\n"); } fprintf(fpout, "End\n"); fclose(fpout); } /* * Load in all the kingdom files. */ void load_kingdoms() { FILE *fpList; char *filename; int num = 0; char kingdomlist[256]; char buf[MSL]; sprintf(kingdomlist, "%s%s", KINGDOM_DIR, KINGDOM_LIST); if ((fpList = fopen(kingdomlist, "r")) == NULL) { perror(kingdomlist); exit(1); } for (;;) { filename = feof(fpList) ? "$" : fread_word(fpList); if (filename[0] == '$') break; if (load_kingdom_file(filename)) { num++; } else { sprintf(buf, "Cannot load kingdom file: %s", filename); bug(buf, 0); } } sysdata.max_kingdom = num; fclose(fpList); return; } void write_channelhistory_file() { FILE *fpout; char filename[MIL]; char buf[MSL]; CHANNEL_HISTORY *chistory; sprintf(filename, "%s", CHISTORY_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } for (chistory = first_channelhistory; chistory; chistory = chistory->next) { fprintf(fpout, "CHISTORY\n"); fprintf(fpout, "%d %d %d %d %d %s~ %s~\n", chistory->channel, chistory->pid, chistory->flags, chistory->level, chistory->kpid, chistory->sender, chistory->text); } fprintf(fpout, "END\n"); fclose(fpout); return; } void read_channelhistory_file() { char *word; bool fMatch; FILE *fp; char buf[MSL]; CHANNEL_HISTORY *chistory = NULL; sprintf(buf, "%s", CHISTORY_FILE); if ((fp = fopen(buf, "r")) == NULL) { bug("Cannot open: %s for writing", buf); return; } for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': if (!str_cmp(word, "CHISTORY")) { CREATE(chistory, CHANNEL_HISTORY, 1); LINK(chistory, first_channelhistory, last_channelhistory, next, prev); chistory->channel = fread_number(fp); chistory->pid = fread_number(fp); chistory->flags = fread_number(fp); chistory->level = fread_number(fp); chistory->kpid = fread_number(fp); chistory->sender = fread_string(fp); chistory->text = fread_string(fp); fMatch = TRUE; break; } break; case 'E': if (!str_cmp(word, "End")) { fclose(fp); return; } } if (!fMatch) { bug("read_channelhistory_file: %s", word); } } return; } bool load_class_file(char *fname) { char buf[MSL]; char *word; bool fMatch; struct class_type *class; int cl = -1; FILE *fp; sprintf(buf, "%s%s", CLASS_DIR, fname); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return FALSE; } CREATE(class, struct class_type, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("AttrPrime", class->attr_prime, fread_number(fp)); break; case 'C': KEY("Class", cl, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { fclose(fp); if (cl < 0 || cl > 0) { sprintf(buf, "Load_class_file: Class (%s) bad/not found (%d)", class->who_name ? class->who_name : "name not found", cl); bug(buf, 0); if (class->who_name) STRFREE(class->who_name); DISPOSE(class); return FALSE; } class_table[cl] = class; return TRUE; } KEY("ExpBase", class->exp_base, fread_number(fp)); break; case 'G': KEY("Guild", class->guild, fread_number(fp)); break; case 'H': KEY("HpMax", class->hp_max, fread_number(fp)); KEY("HpMin", class->hp_min, fread_number(fp)); break; case 'M': KEY("Mana", class->fMana, fread_number(fp)); break; case 'N': KEY("Name", class->who_name, fread_string(fp)); break; case 'R': KEY("RemortClass", class->remort_class, fread_number(fp)); break; case 'S': if (!str_cmp(word, "Skill")) { int sn, masterydiff, group, bookinfo, bookv, stype; word = fread_word(fp); group = fread_number(fp); masterydiff = fread_number(fp); stype = fread_number(fp); bookinfo = fread_number(fp); bookv = fread_number(fp); sn = skill_lookup(word); if (cl < 0 || cl > 0) { sprintf(buf, "load_class_file: Skill %s -- class bad/not found (%d)", word, cl); bug(buf, 0); } else if (!IS_VALID_SN(sn)) { sprintf(buf, "load_class_file: Skill %s unknown", word); bug(buf, 0); } else { skill_table[sn]->masterydiff[cl] = masterydiff; skill_table[sn]->group[cl] = group; skill_table[sn]->bookinfo[cl] = bookinfo; skill_table[sn]->bookv = bookv; skill_table[sn]->stype = stype; } fMatch = TRUE; break; } break; case 'T': KEY("Thac0", class->thac0_00, fread_number(fp)); KEY("Thac32", class->thac0_32, fread_number(fp)); break; case 'W': KEY("Weapon", class->weapon, fread_number(fp)); break; } if (!fMatch) { sprintf(buf, "load_class_file: no match: %s", word); bug(buf, 0); } } return FALSE; } /* * Load in all the class files. */ void load_classes() { FILE *fpList; char *filename; char classlist[256]; char buf[MSL]; sprintf(classlist, "%s%s", CLASS_DIR, CLASS_LIST); if ((fpList = fopen(classlist, "r")) == NULL) { perror(classlist); exit(1); } for (;;) { filename = feof(fpList) ? "$" : fread_word(fpList); if (filename[0] == '$') break; if (!load_class_file(filename)) { sprintf(buf, "Cannot load class file: %s", filename); bug(buf, 0); } } fclose(fpList); return; } void write_class_file(int cl) { FILE *fpout; char buf[MSL]; char filename[MIL]; struct class_type *class = class_table[cl]; int x; sprintf(filename, "%s%s.class", CLASSDIR, class->who_name); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } fprintf(fpout, "Name %s~\n", class->who_name); fprintf(fpout, "Class %d\n", cl); fprintf(fpout, "Attrprime %d\n", class->attr_prime); fprintf(fpout, "Weapon %d\n", class->weapon); fprintf(fpout, "Guild %d\n", class->guild); fprintf(fpout, "Thac0 %d\n", class->thac0_00); fprintf(fpout, "Thac32 %d\n", class->thac0_32); fprintf(fpout, "Hpmin %d\n", class->hp_min); fprintf(fpout, "Hpmax %d\n", class->hp_max); fprintf(fpout, "Mana %d\n", class->fMana); fprintf(fpout, "Expbase %d\n", class->exp_base); fprintf(fpout, "RemortClass %d\n", class->remort_class); for (x = 0; x < top_sn; x++) { if (!skill_table[x]->name || skill_table[x]->name[0] == '\0') break; fprintf(fpout, "Skill '%s' %d %d %d %d %d\n", skill_table[x]->name, skill_table[x]->group[cl], skill_table[x]->masterydiff[cl], skill_table[x]->stype, skill_table[x]->bookinfo[cl], skill_table[x]->bookv); } fprintf(fpout, "End\n"); fclose(fpout); } /* * Load in all the race files. */ void load_races() { FILE *fpList; char *filename; char racelist[256]; char buf[MSL]; int i = 0; /* * Pre-init the race_table with blank races */ for (i = 0; i < MAX_RACE; i++) race_table[i] = NULL; sprintf(racelist, "%s%s", RACEDIR, RACE_LIST); if ((fpList = fopen(racelist, "r")) == NULL) { perror(racelist); exit(1); } for (;;) { filename = feof(fpList) ? "$" : fread_word(fpList); if (filename[0] == '$') break; if (!load_race_file(filename)) { sprintf(buf, "Cannot load race file: %s", filename); bug(buf, 0); } } for (i = 0; i < MAX_RACE; i++) { if (race_table[i] == NULL) { CREATE(race_table[i], struct race_type, 1); sprintf(race_table[i]->race_name, "%s", "unused"); } } fclose(fpList); return; } void write_race_file(int ra) { FILE *fpout; char buf[MSL]; char filename[MIL]; struct race_type *race = race_table[ra]; int i = 0; int x, y; if (!race->race_name) { sprintf(buf, "Race %d has null name, not writing .race file.", ra); bug(buf, 0); return; } sprintf(filename, "%s%s.race", RACEDIR, race->race_name); if ((fpout = fopen(filename, "w+")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } fprintf(fpout, "Name %s~\n", race->race_name); fprintf(fpout, "Race %d\n", ra); fprintf(fpout, "Str_Plus %d\n", race->str_plus); fprintf(fpout, "Dex_Plus %d\n", race->dex_plus); fprintf(fpout, "Wis_Plus %d\n", race->wis_plus); fprintf(fpout, "Int_Plus %d\n", race->int_plus); fprintf(fpout, "Con_Plus %d\n", race->con_plus); fprintf(fpout, "Cha_Plus %d\n", race->cha_plus); fprintf(fpout, "Lck_Plus %d\n", race->lck_plus); fprintf(fpout, "Agi_Plus %d\n", race->agi_plus); fprintf(fpout, "Agi_Start %d\n", race->agi_start); fprintf(fpout, "Range_Agi %d\n", race->agi_range); fprintf(fpout, "Range_Str %d\n", race->str_range); fprintf(fpout, "Range_Dex %d\n", race->dex_range); fprintf(fpout, "Range_Con %d\n", race->con_range); fprintf(fpout, "Range_Wis %d\n", race->wis_range); fprintf(fpout, "Range_Int %d\n", race->int_range); fprintf(fpout, "Hit %d\n", race->hit); fprintf(fpout, "Mana %d\n", race->mana); fprintf(fpout, "Affected %s\n", print_bitvector(&race->affected)); fprintf(fpout, "Resist %d\n", race->resist); fprintf(fpout, "Suscept %d\n", race->suscept); fprintf(fpout, "Language %d\n", race->language); fprintf(fpout, "Align %d\n", race->alignment); fprintf(fpout, "Min_Align %d\n", race->minalign); fprintf(fpout, "Max_Align %d\n", race->maxalign); fprintf(fpout, "AC_Plus %d\n", race->ac_plus); fprintf(fpout, "Exp_Mult %d\n", race->exp_multiplier); fprintf(fpout, "Attacks %s\n", print_bitvector(&race->attacks)); fprintf(fpout, "Defenses %s\n", print_bitvector(&race->defenses)); fprintf(fpout, "Height %d\n", race->height); fprintf(fpout, "Weight %d\n", race->weight); fprintf(fpout, "Weaponmin %d\n", race->weaponmin); fprintf(fpout, "Weaponstd %d\n", race->weaponstd); /* not used, take out if needed -- Xerves */ fprintf(fpout, "Weaponmax %d\n", race->weaponmax); fprintf(fpout, "RemortRace %d\n", race->remort_race); fprintf(fpout, "Hunger_Mod %d\n", race->hunger_mod); fprintf(fpout, "Thirst_mod %d\n", race->thirst_mod); fprintf(fpout, "Mana_Regen %d\n", race->mana_regen); fprintf(fpout, "HP_Regen %d\n", race->hp_regen); fprintf(fpout, "DodgeBonus %d\n", race->dodge_bonus); fprintf(fpout, "Race_Recall %d\n", race->race_recall); for (i = 0; i <= MAX_WHERE_NAME; i++) fprintf(fpout, "WhereName %s~\n", race->where_name[i]); for (x = 0; x < top_sn; x++) { if (!skill_table[x]->name || skill_table[x]->name[0] == '\0') break; if ((y = skill_table[x]->race_level[ra]) < LEVEL_IMMORTAL) fprintf(fpout, "Skill '%s' %d %d\n", skill_table[x]->name, y, skill_table[x]->race_adept[ra]); } fprintf(fpout, "End\n"); fclose(fpout); } bool load_race_file(char *fname) { char buf[MSL]; char *word; char *race_name = NULL; bool fMatch; struct race_type *race; int ra = -1; FILE *fp; int i = 0; int wear = 0; sprintf(buf, "%s%s", RACEDIR, fname); if ((fp = fopen(buf, "r")) == NULL) { perror(buf); return FALSE; } CREATE(race, struct race_type, 1); for (i = 0; i < MAX_WHERE_NAME; i++) race->where_name[i] = where_name[i]; for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("Align", race->alignment, fread_number(fp)); KEY("AC_Plus", race->ac_plus, fread_number(fp)); KEY("Agi_Start", race->agi_start, fread_number(fp)); KEY("Agi_Plus", race->agi_plus, fread_number(fp)); KEY("Affected", race->affected, fread_bitvector(fp)); KEY("Attacks", race->attacks, fread_bitvector(fp)); break; case 'C': KEY("Con_Plus", race->con_plus, fread_number(fp)); KEY("Cha_Plus", race->cha_plus, fread_number(fp)); break; case 'D': KEY("Dex_Plus", race->dex_plus, fread_number(fp)); KEY("Defenses", race->defenses, fread_bitvector(fp)); KEY("DodgeBonus", race->dodge_bonus, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { fclose(fp); if (ra < 0 || ra >= MAX_RACE) { sprintf(buf, "Load_race_file: Race (%s) bad/not found (%d)", race->race_name ? race->race_name : "name not found", ra); bug(buf, 0); DISPOSE(race); return FALSE; } race_table[ra] = race; return TRUE; } KEY("Exp_Mult", race->exp_multiplier, fread_number(fp)); break; case 'I': KEY("Int_Plus", race->int_plus, fread_number(fp)); break; case 'H': KEY("Height", race->height, fread_number(fp)); KEY("Hit", race->hit, fread_number(fp)); KEY("HP_Regen", race->hp_regen, fread_number(fp)); KEY("Hunger_mod", race->hunger_mod, fread_number(fp)); break; case 'L': KEY("Language", race->language, fread_number(fp)); KEY("Lck_Plus", race->lck_plus, fread_number(fp)); break; case 'M': KEY("Mana", race->mana, fread_number(fp)); KEY("Mana_Regen", race->mana_regen, fread_number(fp)); KEY("Min_Align", race->minalign, fread_number(fp)); race->minalign = -1000; KEY("Max_Align", race->maxalign, fread_number(fp)); race->maxalign = 1000; break; case 'N': KEY("Name", race_name, fread_string(fp)); break; case 'R': KEY("Race", ra, fread_number(fp)); KEY("Race_Recall", race->race_recall, fread_number(fp)); KEY("Range_Agi", race->agi_range, fread_number(fp)); KEY("Range_Str", race->str_range, fread_number(fp)); KEY("Range_Dex", race->dex_range, fread_number(fp)); KEY("Range_Con", race->con_range, fread_number(fp)); KEY("Range_Wis", race->wis_range, fread_number(fp)); KEY("Range_Int", race->int_range, fread_number(fp)); KEY("RemortRace", race->remort_race, fread_number(fp)); KEY("Resist", race->resist, fread_number(fp)); break; case 'S': KEY("Str_Plus", race->str_plus, fread_number(fp)); KEY("Suscept", race->suscept, fread_number(fp)); if (!str_cmp(word, "Skill")) { int sn, lev, adp; word = fread_word(fp); lev = fread_number(fp); adp = fread_number(fp); sn = skill_lookup(word); if (ra < 0 || ra >= MAX_RACE) { sprintf(buf, "load_race_file: Skill %s -- race bad/not found (%d)", word, ra); bug(buf, 0); } else if (!IS_VALID_SN(sn)) { sprintf(buf, "load_race_file: Skill %s unknown", word); bug(buf, 0); } else { skill_table[sn]->race_level[ra] = lev; skill_table[sn]->race_adept[ra] = adp; } fMatch = TRUE; break; } break; case 'T': KEY("Thirst_Mod", race->thirst_mod, fread_number(fp)); break; case 'W': KEY("Weaponmin", race->weaponmin, fread_number(fp)); KEY("Weaponstd", race->weaponstd, fread_number(fp)); KEY("Weaponmax", race->weaponmax, fread_number(fp)); KEY("Weight", race->weight, fread_number(fp)); KEY("Wis_Plus", race->wis_plus, fread_number(fp)); if (!str_cmp(word, "WhereName")) { if (ra < 0 || ra >= MAX_RACE) { char *tmp; sprintf(buf, "load_race_file: Title -- race bad/not found (%d)", ra); bug(buf, 0); tmp = fread_string_nohash(fp); DISPOSE(tmp); tmp = fread_string_nohash(fp); DISPOSE(tmp); } else if (wear < MAX_WHERE_NAME + 1) { race->where_name[wear] = fread_string_nohash(fp); ++wear; } else bug("load_race_file: Too many where_names"); fMatch = TRUE; break; } break; } if (race_name != NULL) sprintf(race->race_name, "%-.16s", race_name); if (!fMatch) { sprintf(buf, "load_race_file: no match: %s", word); bug(buf, 0); } } return FALSE; } /* * Function used by qsort to sort skills */ int skill_comp(SKILLTYPE ** sk1, SKILLTYPE ** sk2) { SKILLTYPE *skill1 = (*sk1); SKILLTYPE *skill2 = (*sk2); if (!skill1 && skill2) return 1; if (skill1 && !skill2) return -1; if (!skill1 && !skill2) return 0; if (skill1->type < skill2->type) return -1; if (skill1->type > skill2->type) return 1; return strcmp(skill1->name, skill2->name); } /* * Sort the skill table with qsort */ void sort_skill_table() { log_string("Sorting skill table..."); qsort(&skill_table[1], top_sn - 1, sizeof(SKILLTYPE *), (int (*)(const void *, const void *)) skill_comp); } /* * Remap slot numbers to sn values */ //No longer sorts slot numbers since this crap was useless and no longer used. Instead, it will search for //the names of the skills/spells and map it to the new sn. void remap_slot_numbers() { SKILLTYPE *skill; SMAUG_AFF *aff; char tmp[32]; int sn; log_string("Remapping slots to sns"); for (sn = 0; sn <= top_sn; sn++) { if ((skill = skill_table[sn]) != NULL) { for (aff = skill->affects; aff; aff = aff->next) if (aff->location == APPLY_WEAPONSPELL || aff->location == APPLY_WEARSPELL || aff->location == APPLY_REMOVESPELL || aff->location == APPLY_STRIPSN || aff->location == APPLY_RECURRINGSPELL) { if (atoi(aff->modifier) >= 0) { sprintf(tmp, "%d", skill_lookup(aff->modifier)); DISPOSE(aff->modifier); aff->modifier = str_dup(tmp); } } } } } /* * Write skill data to a file */ void fwrite_skill(FILE * fpout, SKILLTYPE * skill) { SMAUG_AFF *aff; int modifier; fprintf(fpout, "Name %s~\n", skill->name); fprintf(fpout, "Type %s\n", skill_tname[skill->type]); fprintf(fpout, "Info %d\n", skill->info); if (skill->made_char && skill->made_char[0] != '\0') fprintf(fpout, "MadeBy %s~\n", skill->made_char); if (skill->prototype) fprintf(fpout, "Prototype %d\n", skill->prototype); fprintf(fpout, "Flags %d\n", skill->flags); if (skill->target) fprintf(fpout, "Target %d\n", skill->target); /* * store as new minpos (minpos>=100 flags new style in character loading) */ if (skill->minimum_position) fprintf(fpout, "Minpos %d\n", skill->minimum_position + 100); if (skill->saves) fprintf(fpout, "Saves %d\n", skill->saves); if (skill->slot) fprintf(fpout, "Slot %d\n", skill->slot); if (skill->min_mana) fprintf(fpout, "Mana %d\n", skill->min_mana); if (skill->beats) fprintf(fpout, "Rounds %d\n", skill->beats); if (skill->targetlimb > 0) fprintf(fpout, "Targetlimb %d\n", skill->targetlimb); if (skill->range) fprintf(fpout, "Range %d\n", skill->range); if (skill->guild != -1) fprintf(fpout, "Guild %d\n", skill->guild); if (skill->skill_fun) fprintf(fpout, "Code %s\n", skill_name(skill->skill_fun)); else if (skill->spell_fun) fprintf(fpout, "Code %s\n", spell_name(skill->spell_fun)); fprintf(fpout, "Dammsg %s~\n", skill->noun_damage); if (skill->msg_off && skill->msg_off[0] != '\0') fprintf(fpout, "Wearoff %s~\n", skill->msg_off); if (skill->hit_char && skill->hit_char[0] != '\0') fprintf(fpout, "Hitchar %s~\n", skill->hit_char); if (skill->hit_vict && skill->hit_vict[0] != '\0') fprintf(fpout, "Hitvict %s~\n", skill->hit_vict); if (skill->hit_room && skill->hit_room[0] != '\0') fprintf(fpout, "Hitroom %s~\n", skill->hit_room); if (skill->hit_dest && skill->hit_dest[0] != '\0') fprintf(fpout, "Hitdest %s~\n", skill->hit_dest); if (skill->miss_char && skill->miss_char[0] != '\0') fprintf(fpout, "Misschar %s~\n", skill->miss_char); if (skill->miss_vict && skill->miss_vict[0] != '\0') fprintf(fpout, "Missvict %s~\n", skill->miss_vict); if (skill->miss_room && skill->miss_room[0] != '\0') fprintf(fpout, "Missroom %s~\n", skill->miss_room); if (skill->die_char && skill->die_char[0] != '\0') fprintf(fpout, "Diechar %s~\n", skill->die_char); if (skill->die_vict && skill->die_vict[0] != '\0') fprintf(fpout, "Dievict %s~\n", skill->die_vict); if (skill->die_room && skill->die_room[0] != '\0') fprintf(fpout, "Dieroom %s~\n", skill->die_room); if (skill->imm_char && skill->imm_char[0] != '\0') fprintf(fpout, "Immchar %s~\n", skill->imm_char); if (skill->imm_vict && skill->imm_vict[0] != '\0') fprintf(fpout, "Immvict %s~\n", skill->imm_vict); if (skill->imm_room && skill->imm_room[0] != '\0') fprintf(fpout, "Immroom %s~\n", skill->imm_room); if (skill->dice && skill->dice[0] != '\0') fprintf(fpout, "Dice %s~\n", skill->dice); if (skill->value) fprintf(fpout, "Value %d\n", skill->value); if (skill->difficulty) fprintf(fpout, "Difficulty %d\n", skill->difficulty); if (skill->participants) fprintf(fpout, "Participants %d\n", skill->participants); if (skill->components && skill->components[0] != '\0') fprintf(fpout, "Components %s~\n", skill->components); if (skill->teachers && skill->teachers[0] != '\0') fprintf(fpout, "Teachers %s~\n", skill->teachers); for (aff = skill->affects; aff; aff = aff->next) { fprintf(fpout, "Affect '%s' %d ", aff->duration, aff->location); modifier = atoi(aff->modifier); if ((aff->location == APPLY_WEAPONSPELL || aff->location == APPLY_WEARSPELL || aff->location == APPLY_REMOVESPELL || aff->location == APPLY_STRIPSN || aff->location == APPLY_RECURRINGSPELL) && IS_VALID_SN(modifier)) fprintf(fpout, "'%s' ", skill_table[modifier]->name); else fprintf(fpout, "'%s' ", aff->modifier); fprintf(fpout, "%d\n", aff->bitvector); } if (skill->type != SKILL_HERB) { int y; int min = 1000; min = 1000; for (y = 0; y < MAX_RACE; y++) if (skill->race_level[y] < min) min = skill->race_level[y]; } fprintf(fpout, "End\n\n"); } /* * Save the skill table to disk */ void save_skill_table() { int x; FILE *fpout; if ((fpout = fopen(SKILL_FILE, "w")) == NULL) { bug("Cannot open skills.dat for writting", 0); perror(SKILL_FILE); return; } for (x = 0; x < top_sn; x++) { if (!skill_table[x]->name || skill_table[x]->name[0] == '\0') break; fprintf(fpout, "#SKILL\n"); fwrite_skill(fpout, skill_table[x]); } fprintf(fpout, "#END\n"); fclose(fpout); } /* * Save the herb table to disk */ void save_herb_table() { int x; FILE *fpout; if ((fpout = fopen(HERB_FILE, "w")) == NULL) { bug("Cannot open herbs.dat for writting", 0); perror(HERB_FILE); return; } for (x = 0; x < top_herb; x++) { if (!herb_table[x]->name || herb_table[x]->name[0] == '\0') break; fprintf(fpout, "#HERB\n"); fwrite_skill(fpout, herb_table[x]); } fprintf(fpout, "#END\n"); fclose(fpout); } /* * Save the socials to disk */ void save_socials() { FILE *fpout; SOCIALTYPE *social; int x; if ((fpout = fopen(SOCIAL_FILE, "w")) == NULL) { bug("Cannot open socials.dat for writting", 0); perror(SOCIAL_FILE); return; } for (x = 0; x < 27; x++) { for (social = social_index[x]; social; social = social->next) { if (!social->name || social->name[0] == '\0') { bug("Save_socials: blank social in hash bucket %d", x); continue; } fprintf(fpout, "#SOCIAL\n"); fprintf(fpout, "Name %s~\n", social->name); if (social->char_no_arg) fprintf(fpout, "CharNoArg %s~\n", social->char_no_arg); else bug("Save_socials: NULL char_no_arg in hash bucket %d", x); if (social->others_no_arg) fprintf(fpout, "OthersNoArg %s~\n", social->others_no_arg); if (social->char_found) fprintf(fpout, "CharFound %s~\n", social->char_found); if (social->others_found) fprintf(fpout, "OthersFound %s~\n", social->others_found); if (social->vict_found) fprintf(fpout, "VictFound %s~\n", social->vict_found); if (social->char_auto) fprintf(fpout, "CharAuto %s~\n", social->char_auto); if (social->others_auto) fprintf(fpout, "OthersAuto %s~\n", social->others_auto); fprintf(fpout, "End\n\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } int get_skill(char *skilltype) { if (!str_cmp(skilltype, "Race")) return SKILL_RACIAL; if (!str_cmp(skilltype, "Spell")) return SKILL_SPELL; if (!str_cmp(skilltype, "Skill")) return SKILL_SKILL; if (!str_cmp(skilltype, "Weapon")) return SKILL_WEAPON; if (!str_cmp(skilltype, "Tongue")) return SKILL_TONGUE; if (!str_cmp(skilltype, "Herb")) return SKILL_HERB; return SKILL_UNKNOWN; } /* * Save the commands to disk * Added flags Aug 25, 1997 --Shaddai */ void save_commands() { FILE *fpout; CMDTYPE *command; int x; if ((fpout = fopen(COMMAND_FILE, "w")) == NULL) { bug("Cannot open commands.dat for writing", 0); perror(COMMAND_FILE); return; } for (x = 0; x < 126; x++) { for (command = command_hash[x]; command; command = command->next) { if (!command->name || command->name[0] == '\0') { bug("Save_commands: blank command in hash bucket %d", x); continue; } fprintf(fpout, "#COMMAND\n"); fprintf(fpout, "Name %s~\n", command->name); fprintf(fpout, "Code %s\n", skill_name(command->do_fun)); /* Oops I think this may be a bad thing so I changed it -- Shaddai */ if (command->position < 100) fprintf(fpout, "Position %d\n", command->position + 100); else fprintf(fpout, "Position %d\n", command->position); fprintf(fpout, "Level %d\n", command->level); fprintf(fpout, "FCommand %d\n", command->fcommand); fprintf(fpout, "Log %d\n", command->log); if (command->flags) fprintf(fpout, "Flags %d\n", command->flags); fprintf(fpout, "End\n\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } SKILLTYPE *fread_skill(FILE * fp) { char buf[MSL]; char *word; bool fMatch; bool got_info = FALSE; SKILLTYPE *skill; int x; CREATE(skill, SKILLTYPE, 1); skill->slot = 0; skill->min_mana = 0; for (x = 0; x < MAX_RACE; x++) { skill->race_level[x] = LEVEL_IMMORTAL; skill->race_adept[x] = 95; } skill->guild = -1; skill->target = 0; skill->skill_fun = NULL; skill->spell_fun = NULL; for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': if (!str_cmp(word, "Affect")) { SMAUG_AFF *aff; CREATE(aff, SMAUG_AFF, 1); aff->duration = str_dup(fread_word(fp)); aff->location = fread_number(fp); aff->modifier = str_dup(fread_word(fp)); aff->bitvector = fread_number(fp); if (!got_info) { for (x = 0; x < 32; x++) { if (IS_SET(aff->bitvector, 1 << x)) { aff->bitvector = x; break; } } if (x == 32) aff->bitvector = -1; } aff->next = skill->affects; skill->affects = aff; fMatch = TRUE; break; } break; case 'C': if (!str_cmp(word, "Code")) { SPELL_FUN *spellfun; DO_FUN *dofun; char *w = fread_word(fp); fMatch = TRUE; if ((spellfun = spell_function(w)) != spell_notfound) { skill->spell_fun = spellfun; skill->skill_fun = NULL; } else if ((dofun = skill_function(w)) != skill_notfound) { skill->skill_fun = dofun; skill->spell_fun = NULL; } else { bug("fread_skill: unknown skill/spell %s", w); skill->spell_fun = spell_null; } break; } KEY("Code", skill->spell_fun, spell_function(fread_word(fp))); KEY("Components", skill->components, fread_string_nohash(fp)); break; case 'D': KEY("Dammsg", skill->noun_damage, fread_string_nohash(fp)); KEY("Dice", skill->dice, fread_string_nohash(fp)); KEY("Diechar", skill->die_char, fread_string_nohash(fp)); KEY("Dieroom", skill->die_room, fread_string_nohash(fp)); KEY("Dievict", skill->die_vict, fread_string_nohash(fp)); KEY("Difficulty", skill->difficulty, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { if (skill->saves != 0 && SPELL_SAVE(skill) == SE_NONE) { bug("fread_skill(%s): Has saving throw (%d) with no saving effect.", skill->name, skill->saves); SET_SSAV(skill, SE_NEGATE); } return skill; } break; case 'F': if (!str_cmp(word, "Flags")) { skill->flags = fread_number(fp); /* * convert to new style -Thoric */ if (!got_info) { skill->info = skill->flags & (BV11 - 1); if (IS_SET(skill->flags, OLD_SF_SAVE_NEGATES)) { if (IS_SET(skill->flags, OLD_SF_SAVE_HALF_DAMAGE)) { SET_SSAV(skill, SE_QUARTERDAM); REMOVE_BIT(skill->flags, OLD_SF_SAVE_HALF_DAMAGE); } else SET_SSAV(skill, SE_NEGATE); REMOVE_BIT(skill->flags, OLD_SF_SAVE_NEGATES); } else if (IS_SET(skill->flags, OLD_SF_SAVE_HALF_DAMAGE)) { SET_SSAV(skill, SE_HALFDAM); REMOVE_BIT(skill->flags, OLD_SF_SAVE_HALF_DAMAGE); } skill->flags >>= 11; } fMatch = TRUE; break; } break; case 'G': KEY("Guild", skill->guild, fread_number(fp)); break; case 'H': KEY("Hitchar", skill->hit_char, fread_string_nohash(fp)); KEY("Hitdest", skill->hit_dest, fread_string_nohash(fp)); KEY("Hitroom", skill->hit_room, fread_string_nohash(fp)); KEY("Hitvict", skill->hit_vict, fread_string_nohash(fp)); break; case 'I': KEY("Immchar", skill->imm_char, fread_string_nohash(fp)); KEY("Immroom", skill->imm_room, fread_string_nohash(fp)); KEY("Immvict", skill->imm_vict, fread_string_nohash(fp)); if (!str_cmp(word, "Info")) { skill->info = fread_number(fp); got_info = TRUE; fMatch = TRUE; break; } break; case 'M': KEY("MadeBy", skill->made_char, fread_string_nohash(fp)); KEY("Mana", skill->min_mana, fread_number(fp)); if (!str_cmp(word, "Minlevel")) { fread_to_eol(fp); fMatch = TRUE; break; } /*KEY( "Minpos", skill->minimum_position, fread_number( fp ) ); */ /* */ if (!str_cmp(word, "Minpos")) { fMatch = TRUE; skill->minimum_position = fread_number(fp); if (skill->minimum_position < 100) { switch (skill->minimum_position) { default: case 0: case 1: case 2: case 3: case 4: break; case 5: skill->minimum_position = 6; break; case 6: skill->minimum_position = 8; break; case 7: skill->minimum_position = 9; break; case 8: skill->minimum_position = 12; break; case 9: skill->minimum_position = 13; break; case 10: skill->minimum_position = 14; break; case 11: skill->minimum_position = 15; break; } } else skill->minimum_position -= 100; break; } KEY("Misschar", skill->miss_char, fread_string_nohash(fp)); KEY("Missroom", skill->miss_room, fread_string_nohash(fp)); KEY("Missvict", skill->miss_vict, fread_string_nohash(fp)); break; case 'N': KEY("Name", skill->name, fread_string_nohash(fp)); break; case 'P': KEY("Participants", skill->participants, fread_number(fp)); KEY("Prototype", skill->prototype, fread_number(fp)); break; case 'R': KEY("Range", skill->range, fread_number(fp)); KEY("Rounds", skill->beats, fread_number(fp)); if (!str_cmp(word, "Race")) { int race = fread_number(fp); skill->race_level[race] = fread_number(fp); skill->race_adept[race] = fread_number(fp); fMatch = TRUE; break; } break; case 'S': KEY("Slot", skill->slot, fread_number(fp)); KEY("Saves", skill->saves, fread_number(fp)); break; case 'T': KEY("Target", skill->target, fread_number(fp)); KEY("Teachers", skill->teachers, fread_string_nohash(fp)); KEY("Type", skill->type, get_skill(fread_word(fp))); KEY("Targetlimb", skill->targetlimb, fread_number(fp)); break; case 'V': KEY("Value", skill->value, fread_number(fp)); break; case 'W': KEY("Wearoff", skill->msg_off, fread_string_nohash(fp)); break; } if (!fMatch) { sprintf(buf, "Fread_skill: no match: %s", word); bug(buf, 0); } } } void load_skill_table() { FILE *fp; if ((fp = fopen(SKILL_FILE, "r")) != NULL) { top_sn = 0; for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_skill_table: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "SKILL")) { if (top_sn >= MAX_SKILL) { bug("load_skill_table: more skills than MAX_SKILL %d", MAX_SKILL); fclose(fp); return; } skill_table[top_sn++] = fread_skill(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_skill_table: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open skills.dat", 0); exit(0); } } void load_herb_table() { FILE *fp; if ((fp = fopen(HERB_FILE, "r")) != NULL) { top_herb = 0; for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_herb_table: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "HERB")) { if (top_herb >= MAX_HERB) { bug("load_herb_table: more herbs than MAX_HERB %d", MAX_HERB); fclose(fp); return; } herb_table[top_herb++] = fread_skill(fp); if (herb_table[top_herb - 1]->slot == 0) herb_table[top_herb - 1]->slot = top_herb - 1; continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_herb_table: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open herbs.dat", 0); exit(0); } } void save_buykingdom_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; BUYKMOB_DATA *kmob; BUYKOBJ_DATA *kobj; BUYKTRAINER_DATA *ktrain; BUYKBIN_DATA *kbin; BTRAINER_DATA *btrain; sprintf(filename, "%s", BUYK_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } fprintf(fpout, "#Version %d\n\n", CASTEBUYVERSION); for (kmob = first_buykmob; kmob; kmob = kmob->next) { fprintf(fpout, "#MOB\n"); fprintf(fpout, "Tree %d\n", kmob->tree); fprintf(fpout, "Corn %d\n", kmob->corn); fprintf(fpout, "Grain %d\n", kmob->grain); fprintf(fpout, "Iron %d\n", kmob->iron); fprintf(fpout, "Gold %d\n", kmob->gold); fprintf(fpout, "Stone %d\n", kmob->stone); fprintf(fpout, "Coins %d\n", kmob->coins); fprintf(fpout, "Vnum %d\n", kmob->vnum); fprintf(fpout, "MinCaste %d\n", kmob->mincaste); fprintf(fpout, "Flags %s\n", print_bitvector(&kmob->flags)); fprintf(fpout, "End \n"); } for (kobj = first_buykobj; kobj; kobj = kobj->next) { fprintf(fpout, "#OBJECT\n"); fprintf(fpout, "Tree %d\n", kobj->tree); fprintf(fpout, "Corn %d\n", kobj->corn); fprintf(fpout, "Grain %d\n", kobj->grain); fprintf(fpout, "Iron %d\n", kobj->iron); fprintf(fpout, "Gold %d\n", kobj->gold); fprintf(fpout, "Stone %d\n", kobj->stone); fprintf(fpout, "Coins %d\n", kobj->coins); fprintf(fpout, "Vnum %d\n", kobj->vnum); fprintf(fpout, "MinCaste %d\n", kobj->mincaste); fprintf(fpout, "Flags %s\n", print_bitvector(&kobj->flags)); fprintf(fpout, "End \n"); } for (ktrain = first_buyktrainer; ktrain; ktrain = ktrain->next) { fprintf(fpout, "#TRAINER\n"); fprintf(fpout, "Name %s~\n", ktrain->name); fprintf(fpout, "Sn1 '%s'\n", IS_VALID_SN(ktrain->sn[0]) ? skill_table[ktrain->sn[0]]->name : "NONE"); fprintf(fpout, "Sn2 '%s'\n", IS_VALID_SN(ktrain->sn[1]) ? skill_table[ktrain->sn[1]]->name : "NONE"); fprintf(fpout, "Sn3 '%s'\n", IS_VALID_SN(ktrain->sn[2]) ? skill_table[ktrain->sn[2]]->name : "NONE"); fprintf(fpout, "Sn4 '%s'\n", IS_VALID_SN(ktrain->sn[3]) ? skill_table[ktrain->sn[3]]->name : "NONE"); fprintf(fpout, "Sn5 '%s'\n", IS_VALID_SN(ktrain->sn[4]) ? skill_table[ktrain->sn[4]]->name : "NONE"); fprintf(fpout, "Sn6 '%s'\n", IS_VALID_SN(ktrain->sn[5]) ? skill_table[ktrain->sn[5]]->name : "NONE"); fprintf(fpout, "Sn7 '%s'\n", IS_VALID_SN(ktrain->sn[6]) ? skill_table[ktrain->sn[6]]->name : "NONE"); fprintf(fpout, "Sn8 '%s'\n", IS_VALID_SN(ktrain->sn[7]) ? skill_table[ktrain->sn[7]]->name : "NONE"); fprintf(fpout, "Sn9 '%s'\n", IS_VALID_SN(ktrain->sn[8]) ? skill_table[ktrain->sn[8]]->name : "NONE"); fprintf(fpout, "Sn10 '%s'\n", IS_VALID_SN(ktrain->sn[9]) ? skill_table[ktrain->sn[9]]->name : "NONE"); fprintf(fpout, "Sn11 '%s'\n", IS_VALID_SN(ktrain->sn[10]) ? skill_table[ktrain->sn[10]]->name : "NONE"); fprintf(fpout, "Sn12 '%s'\n", IS_VALID_SN(ktrain->sn[11]) ? skill_table[ktrain->sn[11]]->name : "NONE"); fprintf(fpout, "Sn13 '%s'\n", IS_VALID_SN(ktrain->sn[12]) ? skill_table[ktrain->sn[12]]->name : "NONE"); fprintf(fpout, "Sn14 '%s'\n", IS_VALID_SN(ktrain->sn[13]) ? skill_table[ktrain->sn[13]]->name : "NONE"); fprintf(fpout, "Sn15 '%s'\n", IS_VALID_SN(ktrain->sn[14]) ? skill_table[ktrain->sn[14]]->name : "NONE"); fprintf(fpout, "Sn16 '%s'\n", IS_VALID_SN(ktrain->sn[15]) ? skill_table[ktrain->sn[15]]->name : "NONE"); fprintf(fpout, "Sn17 '%s'\n", IS_VALID_SN(ktrain->sn[16]) ? skill_table[ktrain->sn[16]]->name : "NONE"); fprintf(fpout, "Sn18 '%s'\n", IS_VALID_SN(ktrain->sn[17]) ? skill_table[ktrain->sn[17]]->name : "NONE"); fprintf(fpout, "Sn19 '%s'\n", IS_VALID_SN(ktrain->sn[18]) ? skill_table[ktrain->sn[18]]->name : "NONE"); fprintf(fpout, "Sn20 '%s'\n", IS_VALID_SN(ktrain->sn[19]) ? skill_table[ktrain->sn[19]]->name : "NONE"); fprintf(fpout, "Mastery1 %d\n", ktrain->mastery[0]); fprintf(fpout, "Mastery2 %d\n", ktrain->mastery[1]); fprintf(fpout, "Mastery3 %d\n", ktrain->mastery[2]); fprintf(fpout, "Mastery4 %d\n", ktrain->mastery[3]); fprintf(fpout, "Mastery5 %d\n", ktrain->mastery[4]); fprintf(fpout, "Mastery6 %d\n", ktrain->mastery[5]); fprintf(fpout, "Mastery7 %d\n", ktrain->mastery[6]); fprintf(fpout, "Mastery8 %d\n", ktrain->mastery[7]); fprintf(fpout, "Mastery9 %d\n", ktrain->mastery[8]); fprintf(fpout, "Mastery10 %d\n", ktrain->mastery[9]); fprintf(fpout, "Mastery11 %d\n", ktrain->mastery[10]); fprintf(fpout, "Mastery12 %d\n", ktrain->mastery[11]); fprintf(fpout, "Mastery13 %d\n", ktrain->mastery[12]); fprintf(fpout, "Mastery14 %d\n", ktrain->mastery[13]); fprintf(fpout, "Mastery15 %d\n", ktrain->mastery[14]); fprintf(fpout, "Mastery16 %d\n", ktrain->mastery[15]); fprintf(fpout, "Mastery17 %d\n", ktrain->mastery[16]); fprintf(fpout, "Mastery18 %d\n", ktrain->mastery[17]); fprintf(fpout, "Mastery19 %d\n", ktrain->mastery[18]); fprintf(fpout, "Mastery20 %d\n", ktrain->mastery[19]); fprintf(fpout, "Cost %d\n", ktrain->cost); fprintf(fpout, "Pid %d\n", ktrain->pid); fprintf(fpout, "End \n"); } for (btrain = first_boughttrainer; btrain; btrain = btrain->next) { fprintf(fpout, "#BOUGHT\n"); fprintf(fpout, "Rvnum %d\n", btrain->rvnum); fprintf(fpout, "X %d\n", btrain->x); fprintf(fpout, "Y %d\n", btrain->y); fprintf(fpout, "Map %d\n", btrain->map); fprintf(fpout, "Pid %d\n", btrain->pid); fprintf(fpout, "End\n"); } for (kbin = first_buykbin; kbin; kbin = kbin->next) { fprintf(fpout, "#Bin\n"); fprintf(fpout, "Name %s~\n", kbin->name); fprintf(fpout, "Stone %d\n", kbin->stone); fprintf(fpout, "Coins %d\n", kbin->coins); fprintf(fpout, "Hold %d\n", kbin->hold); fprintf(fpout, "MinCaste %d\n", kbin->mincaste); fprintf(fpout, "End\n"); } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_buybought_data(FILE * fp) { char buf[MSL]; char *word; bool fMatch; BTRAINER_DATA *btrain; CREATE(btrain, BTRAINER_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'M': KEY("Map", btrain->map, fread_number(fp)); break; case 'P': KEY("Pid", btrain->pid, fread_number(fp)); break; case 'R': KEY("Rvnum", btrain->rvnum, fread_number(fp)); break; case 'X': KEY("X", btrain->x, fread_number(fp)); break; case 'Y': KEY("Y", btrain->y, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(btrain, first_boughttrainer, last_boughttrainer, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_buybought_data: no match: %s", word); bug(buf, 0); } } } void fread_buyktrainer_data(FILE * fp) { char buf[MSL]; char *word; bool fMatch; BUYKTRAINER_DATA *ktrain; CREATE(ktrain, BUYKTRAINER_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Cost", ktrain->cost, fread_number(fp)); break; case 'M': KEY("Mastery1", ktrain->mastery[0], fread_number(fp)); KEY("Mastery2", ktrain->mastery[1], fread_number(fp)); KEY("Mastery3", ktrain->mastery[2], fread_number(fp)); KEY("Mastery4", ktrain->mastery[3], fread_number(fp)); KEY("Mastery5", ktrain->mastery[4], fread_number(fp)); KEY("Mastery6", ktrain->mastery[5], fread_number(fp)); KEY("Mastery7", ktrain->mastery[6], fread_number(fp)); KEY("Mastery8", ktrain->mastery[7], fread_number(fp)); KEY("Mastery9", ktrain->mastery[8], fread_number(fp)); KEY("Mastery10", ktrain->mastery[9], fread_number(fp)); KEY("Mastery11", ktrain->mastery[10], fread_number(fp)); KEY("Mastery12", ktrain->mastery[11], fread_number(fp)); KEY("Mastery13", ktrain->mastery[12], fread_number(fp)); KEY("Mastery14", ktrain->mastery[13], fread_number(fp)); KEY("Mastery15", ktrain->mastery[14], fread_number(fp)); KEY("Mastery16", ktrain->mastery[15], fread_number(fp)); KEY("Mastery17", ktrain->mastery[16], fread_number(fp)); KEY("Mastery18", ktrain->mastery[17], fread_number(fp)); KEY("Mastery19", ktrain->mastery[18], fread_number(fp)); KEY("Mastery20", ktrain->mastery[19], fread_number(fp)); break; case 'N': KEY("Name", ktrain->name, fread_string(fp)); break; case 'P': KEY("Pid", ktrain->pid, fread_number(fp)); break; case 'S': if (boughtsaveversion <= 1) { KEY("Sn1", ktrain->sn[0], fread_number(fp)); KEY("Sn2", ktrain->sn[1], fread_number(fp)); KEY("Sn3", ktrain->sn[2], fread_number(fp)); KEY("Sn4", ktrain->sn[3], fread_number(fp)); KEY("Sn5", ktrain->sn[4], fread_number(fp)); KEY("Sn6", ktrain->sn[5], fread_number(fp)); KEY("Sn7", ktrain->sn[6], fread_number(fp)); KEY("Sn8", ktrain->sn[7], fread_number(fp)); KEY("Sn9", ktrain->sn[8], fread_number(fp)); KEY("Sn10", ktrain->sn[9], fread_number(fp)); KEY("Sn11", ktrain->sn[10], fread_number(fp)); KEY("Sn12", ktrain->sn[11], fread_number(fp)); KEY("Sn13", ktrain->sn[12], fread_number(fp)); KEY("Sn14", ktrain->sn[13], fread_number(fp)); KEY("Sn15", ktrain->sn[14], fread_number(fp)); KEY("Sn16", ktrain->sn[15], fread_number(fp)); KEY("Sn17", ktrain->sn[16], fread_number(fp)); KEY("Sn18", ktrain->sn[17], fread_number(fp)); KEY("Sn19", ktrain->sn[18], fread_number(fp)); KEY("Sn20", ktrain->sn[19], fread_number(fp)); } else { if (!str_cmp(word, "Sn1")) { ktrain->sn[0] = skill_lookup(fread_word(fp)); if (ktrain->sn[0] < 0) ktrain->sn[0] = 0; } if (!str_cmp(word, "Sn2")) { ktrain->sn[1] = skill_lookup(fread_word(fp)); if (ktrain->sn[1] < 0) ktrain->sn[1] = 0; } if (!str_cmp(word, "Sn3")) { ktrain->sn[2] = skill_lookup(fread_word(fp)); if (ktrain->sn[2] < 0) ktrain->sn[2] = 0; } if (!str_cmp(word, "Sn4")) { ktrain->sn[3] = skill_lookup(fread_word(fp)); if (ktrain->sn[3] < 0) ktrain->sn[3] = 0; } if (!str_cmp(word, "Sn5")) { ktrain->sn[4] = skill_lookup(fread_word(fp)); if (ktrain->sn[4] < 0) ktrain->sn[4] = 0; } if (!str_cmp(word, "Sn6")) { ktrain->sn[5] = skill_lookup(fread_word(fp)); if (ktrain->sn[5] < 0) ktrain->sn[5] = 0; } if (!str_cmp(word, "Sn7")) { ktrain->sn[6] = skill_lookup(fread_word(fp)); if (ktrain->sn[6] < 0) ktrain->sn[6] = 0; } if (!str_cmp(word, "Sn8")) { ktrain->sn[7] = skill_lookup(fread_word(fp)); if (ktrain->sn[7] < 0) ktrain->sn[7] = 0; } if (!str_cmp(word, "Sn9")) { ktrain->sn[8] = skill_lookup(fread_word(fp)); if (ktrain->sn[8] < 0) ktrain->sn[8] = 0; } if (!str_cmp(word, "Sn10")) { ktrain->sn[9] = skill_lookup(fread_word(fp)); if (ktrain->sn[9] < 0) ktrain->sn[9] = 0; } if (!str_cmp(word, "Sn11")) { ktrain->sn[10] = skill_lookup(fread_word(fp)); if (ktrain->sn[10] < 0) ktrain->sn[10] = 0; } if (!str_cmp(word, "Sn12")) { ktrain->sn[11] = skill_lookup(fread_word(fp)); if (ktrain->sn[11] < 0) ktrain->sn[11] = 0; } if (!str_cmp(word, "Sn13")) { ktrain->sn[12] = skill_lookup(fread_word(fp)); if (ktrain->sn[12] < 0) ktrain->sn[12] = 0; } if (!str_cmp(word, "Sn14")) { ktrain->sn[13] = skill_lookup(fread_word(fp)); if (ktrain->sn[13] < 0) ktrain->sn[13] = 0; } if (!str_cmp(word, "Sn15")) { ktrain->sn[14] = skill_lookup(fread_word(fp)); if (ktrain->sn[14] < 0) ktrain->sn[14] = 0; } if (!str_cmp(word, "Sn16")) { ktrain->sn[15] = skill_lookup(fread_word(fp)); if (ktrain->sn[15] < 0) ktrain->sn[15] = 0; } if (!str_cmp(word, "Sn17")) { ktrain->sn[16] = skill_lookup(fread_word(fp)); if (ktrain->sn[16] < 0) ktrain->sn[16] = 0; } if (!str_cmp(word, "Sn18")) { ktrain->sn[17] = skill_lookup(fread_word(fp)); if (ktrain->sn[17] < 0) ktrain->sn[17] = 0; } if (!str_cmp(word, "Sn19")) { ktrain->sn[18] = skill_lookup(fread_word(fp)); if (ktrain->sn[18] < 0) ktrain->sn[18] = 0; } if (!str_cmp(word, "Sn20")) { ktrain->sn[19] = skill_lookup(fread_word(fp)); if (ktrain->sn[19] < 0) ktrain->sn[19] = 0; } fMatch = TRUE; } break; case 'E': if (!str_cmp(word, "End")) { LINK(ktrain, first_buyktrainer, last_buyktrainer, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_buykmob_data: no match: %s", word); bug(buf, 0); } } } void fread_buykmob_data(FILE * fp) { char buf[MSL]; char *word; bool fMatch; BUYKMOB_DATA *kmob; CREATE(kmob, BUYKMOB_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Coins", kmob->coins, fread_number(fp)); KEY("Corn", kmob->corn, fread_number(fp)); break; case 'F': KEY("Flags", kmob->flags, fread_bitvector(fp)); break; case 'G': KEY("Gold", kmob->gold, fread_number(fp)); KEY("Grain", kmob->grain, fread_number(fp)); break; case 'I': KEY("Iron", kmob->iron, fread_number(fp)); break; case 'M': KEY("MinCaste", kmob->mincaste, fread_number(fp)); break; case 'S': KEY("Stone", kmob->stone, fread_number(fp)); break; case 'T': KEY("Tree", kmob->tree, fread_number(fp)); break; case 'V': KEY("Vnum", kmob->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(kmob, first_buykmob, last_buykmob, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_buykmob_data: no match: %s", word); bug(buf, 0); } } } void fread_buykbin_data(FILE * fp) { char buf[MSL]; char *word; bool fMatch; BUYKBIN_DATA *kbin; CREATE(kbin, BUYKBIN_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Coins", kbin->coins, fread_number(fp)); break; case 'H': KEY("Hold", kbin->hold, fread_number(fp)); break; case 'M': KEY("MinCaste", kbin->mincaste, fread_number(fp)); break; case 'N': KEY("Name", kbin->name, fread_string(fp)); break; case 'S': KEY("Stone", kbin->stone, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(kbin, first_buykbin, last_buykbin, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_buykbin_data: no match: %s", word); bug(buf, 0); } } } void fread_buykobj_data(FILE * fp) { char buf[MSL]; char *word; bool fMatch; BUYKOBJ_DATA *kobj; CREATE(kobj, BUYKOBJ_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Coins", kobj->coins, fread_number(fp)); KEY("Corn", kobj->corn, fread_number(fp)); break; case 'F': KEY("Flags", kobj->flags, fread_bitvector(fp)); break; case 'G': KEY("Gold", kobj->gold, fread_number(fp)); KEY("Grain", kobj->grain, fread_number(fp)); break; case 'I': KEY("Iron", kobj->iron, fread_number(fp)); break; case 'M': KEY("MinCaste", kobj->mincaste, fread_number(fp)); break; case 'S': KEY("Stone", kobj->stone, fread_number(fp)); break; case 'T': KEY("Tree", kobj->tree, fread_number(fp)); break; case 'V': KEY("Vnum", kobj->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(kobj, first_buykobj, last_buykobj, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_buykobj_data: no match: %s", word); bug(buf, 0); } } } void load_buykingdom_data() { FILE *fp; char name[100]; ROOM_INDEX_DATA *room; CHAR_DATA *victim; BTRAINER_DATA *btrain; BUYKTRAINER_DATA *ktrain; boughtsaveversion = 1; //Just in case..... if ((fp = fopen(BUYK_FILE, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_buycaste_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "Version")) { boughtsaveversion = fread_number(fp); continue; } else if (!str_cmp(word, "OBJECT")) { fread_buykobj_data(fp); continue; } else if (!str_cmp(word, "MOB")) { fread_buykmob_data(fp); continue; } else if (!str_cmp(word, "TRAINER")) { fread_buyktrainer_data(fp); continue; } else if (!str_cmp(word, "BOUGHT")) { fread_buybought_data(fp); continue; } else if (!str_cmp(word, "BIN")) { fread_buykbin_data(fp); continue; } else if (!str_cmp(word, "END")) { for (btrain = first_boughttrainer; btrain; btrain = btrain->next) { for (ktrain = first_buyktrainer; ktrain; ktrain = ktrain->next) { if (btrain->pid == ktrain->pid) //load mobile { room = get_room_index(btrain->rvnum); if (!room) { bug("fread_buyktrainer_data: Invalid room %d to put a trainer in. Removing from list.", btrain->rvnum); continue; } //Load mobile and place it Now! victim = create_mobile(get_mob_index(MOB_VNUM_TRAINER)); char_to_room(victim, room); victim->m2 = ktrain->pid; victim->coord->x = btrain->x; victim->coord->y = btrain->y; victim->map = btrain->map; SET_ONMAP_FLAG(victim); STRFREE(victim->name); sprintf(name, ktrain->name); victim->name = STRALLOC(name); STRFREE(victim->short_descr); sprintf(name, ktrain->name); victim->short_descr = STRALLOC(name); STRFREE(victim->long_descr); sprintf(name, "%s is here training all that are interested.\n\r", ktrain->name); victim->long_descr = STRALLOC(name); } } } break; } else { bug("Load_buykingdom_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open buykingdom file", 0); exit(0); } } //Saves extraction mobs to file void save_extraction_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; CHAR_DATA *mob; sprintf(filename, "%s", EXTRACTION_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } for (mob = last_char; mob; mob = mob->prev) { //m1 - Resource AMT m2 - Resource MAX m3 - Cost m4 - Kingdom m5 - Resource Type m6 - Extraction effic. //m9 - Time started if (IS_NPC(mob) && IS_ACT_FLAG(mob, ACT_EXTRACTMOB) && mob->in_room) { fprintf(fpout, "#EXTRACT\n"); fprintf(fpout, "Vnum %d\n", mob->pIndexData->vnum); fprintf(fpout, "Name %s~\n", mob->name); fprintf(fpout, "Short %s~\n", mob->short_descr); fprintf(fpout, "Long %s~\n", mob->long_descr); fprintf(fpout, "Race %d\n", mob->race); fprintf(fpout, "Str %d\n", mob->perm_str); fprintf(fpout, "Int %d\n", mob->perm_int); fprintf(fpout, "Wis %d\n", mob->perm_wis); fprintf(fpout, "Lck %d\n", mob->perm_lck); fprintf(fpout, "Dex %d\n", mob->perm_dex); fprintf(fpout, "Agi %d\n", mob->perm_agi); fprintf(fpout, "Con %d\n", mob->perm_con); fprintf(fpout, "X %d\n", mob->coord->x); fprintf(fpout, "Y %d\n", mob->coord->y); fprintf(fpout, "Stx %d\n", mob->stx); fprintf(fpout, "Sty %d\n", mob->sty); fprintf(fpout, "Map %d\n", mob->map); fprintf(fpout, "Room %d\n", mob->in_room->vnum); fprintf(fpout, "Flags %s\n", print_bitvector(&mob->act)); fprintf(fpout, "RAMT %d\n", mob->m1); fprintf(fpout, "Cost %d\n", mob->m3); fprintf(fpout, "Kingdom %d\n", mob->m4); fprintf(fpout, "Resource %d\n", mob->m5); fprintf(fpout, "Town %d\n", mob->m7); fprintf(fpout, "Time %d\n", mob->m9); fprintf(fpout, "ETime %d\n", mob->m10); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_extraction_data(FILE * fp) { char *word; int vnum, x, y, map, room, ramt, cost, kingdom, ptime, etime; char *name = NULL; char *shortn = NULL; char *longn = NULL; int race, str, inte, wis, lck, dex, agi, con, resource, stx, sty, town; EXT_BV flags; bool fMatch; vnum=x=y=map=room=ramt=cost=kingdom=ptime=etime=0; race=str=inte=wis=lck=dex=agi=con=resource=stx=sty=town=0; for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("Agi", agi, fread_number(fp)); case 'C': KEY("Con", con, fread_number(fp)); KEY("Cost", cost, fread_number(fp)); break; case 'D': KEY("Dex", dex, fread_number(fp)); break; case 'F': KEY("Flags", flags, fread_bitvector(fp)); break; case 'I': KEY("Int", inte, fread_number(fp)); break; case 'K': KEY("Kingdom", kingdom, fread_number(fp)); break; case 'L': KEY("Lck", lck, fread_number(fp)); KEY("Long", longn, fread_string(fp)); break; case 'M': KEY("Map", map, fread_number(fp)); break; case 'N': KEY("Name", name, fread_string(fp)); break; case 'R': KEY("Race", race, fread_number(fp)); KEY("RAMT", ramt, fread_number(fp)); KEY("Resource", resource, fread_number(fp)); KEY("Room", room, fread_number(fp)); break; case 'S': KEY("Short", shortn, fread_string(fp)); KEY("Str", str, fread_number(fp)); KEY("Stx", stx, fread_number(fp)); KEY("Sty", sty, fread_number(fp)); break; case 'T': KEY("Time", ptime, fread_number(fp)); KEY("Town", town, fread_number(fp)); break; case 'V': KEY("Vnum", vnum, fread_number(fp)); break; case 'W': KEY("Wis", wis, fread_number(fp)); break; case 'X': KEY("X", x, fread_number(fp)); break; case 'Y': KEY("Y", y, fread_number(fp)); break; case 'E': KEY("ETime", etime, fread_number(fp)); if (!str_cmp(word, "End")) { CHAR_DATA *victim; // if (time(0) - ptime > 10800) //More than 3 hours, don't load the extraction mobs.... // return; victim = create_mobile(get_mob_index(vnum)); char_to_room(victim, get_room_index(room)); STRFREE(victim->name); victim->name = STRALLOC(name); STRFREE(victim->long_descr); victim->long_descr = STRALLOC(longn); STRFREE(victim->short_descr); victim->short_descr = STRALLOC(shortn); victim->race = race; victim->perm_str = str; victim->perm_int = inte; victim->perm_wis = wis; victim->perm_lck = lck; victim->perm_dex = dex; victim->perm_agi = agi; victim->perm_con = con; victim->coord->x = x; victim->coord->y = y; victim->map = map; victim->stx = stx; victim->sty = sty; victim->stmap = map; victim->m1 = ramt; victim->m3 = cost; victim->m4 = kingdom; victim->m5 = resource; victim->m7 = town; victim->dumptown = get_town_tpid(kingdom, town); victim->m9 = ptime; victim->m10 = etime; xCLEAR_BITS(victim->act); victim->act = flags; return; } break; } } } void load_extraction_data() { FILE *fp; if ((fp = fopen(EXTRACTION_FILE, "r")) != NULL) { for (;;) { char letter; char *word; if (feof(fp)) break; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { fread_to_eol(fp); continue; } word = fread_word(fp); if (!str_cmp(word, "EXTRACT")) { fread_extraction_data(fp); continue; } if (!str_cmp(word, "END")) { fclose(fp); return; } } fclose(fp); } } //Saves military data to file, appends the file and writes to the bottom. void save_mlist_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; CHAR_DATA *mob; sprintf(filename, "%s", MILIST_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } for (mob = last_char; mob; mob = mob->prev) { if (IS_NPC(mob) && IS_ACT_FLAG(mob, ACT_MILITARY) && mob->in_room) { fprintf(fpout, "#MIDATA\n"); fprintf(fpout, "Name %s~\n", mob->name); fprintf(fpout, "Short %s~\n", mob->short_descr); fprintf(fpout, "Long %s~\n", mob->long_descr); fprintf(fpout, "Race %d\n", mob->race); fprintf(fpout, "Str %d\n", mob->perm_str); fprintf(fpout, "Int %d\n", mob->perm_int); fprintf(fpout, "Wis %d\n", mob->perm_wis); fprintf(fpout, "Lck %d\n", mob->perm_lck); fprintf(fpout, "Dex %d\n", mob->perm_dex); fprintf(fpout, "Agi %d\n", mob->perm_agi); fprintf(fpout, "Con %d\n", mob->perm_con); fprintf(fpout, "Cost %d\n", mob->m3); fprintf(fpout, "X %d\n", mob->coord->x); fprintf(fpout, "Y %d\n", mob->coord->y); fprintf(fpout, "Map %d\n", mob->map); fprintf(fpout, "Vnum %d\n", mob->pIndexData->vnum); fprintf(fpout, "Room %d\n", mob->in_room->vnum); fprintf(fpout, "Kingdom %d\n", mob->m4); fprintf(fpout, "Flags %s\n", print_bitvector(&mob->miflags)); fprintf(fpout, "Time %d\n", mob->m9); fprintf(fpout, "Speed %d\n", mob->m10); fprintf(fpout, "Town %d\n", mob->m1); if (xIS_SET(mob->miflags, KM_INVITE)) fprintf(fpout, "IRange %d\n", mob->m5); if (xIS_SET(mob->miflags, KM_PATROL)) { fprintf(fpout, "PRange %d\n", mob->m2); fprintf(fpout, "PX %d\n", mob->m7); fprintf(fpout, "PY %d\n", mob->m8); } if (xIS_SET(mob->miflags, KM_WARN) || xIS_SET(mob->miflags, KM_ATTACKA) || xIS_SET(mob->miflags, KM_ATTACKN) || xIS_SET(mob->miflags, KM_ATTACKE)) fprintf(fpout, "WaRange %d\n", mob->m6); if (mob->position == POS_MOUNTED && mob->mount) fprintf(fpout, "Mount 1\n"); fprintf(fpout, "End\n"); file_ver = SAVEVERSION; de_equip_char(mob); if (mob->first_carrying) fwrite_obj(mob, mob->last_carrying, fpout, 0, OS_CARRY); re_equip_char(mob); fprintf(fpout, "#END\n"); } } fclose(fpout); } void fread_mlist_data(FILE * fp) { char *word; bool fMatch; int mount = 0; CHAR_DATA *lmount; MLIST_DATA *mlist; int m1 = -1; CREATE(mlist, MLIST_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("Agi", mlist->agi, fread_number(fp)); break; case 'C': KEY("Con", mlist->con, fread_number(fp)); KEY("Cost", mlist->cost, fread_number(fp)); break; case 'D': KEY("Dex", mlist->dex, fread_number(fp)); break; case 'F': KEY("Flags", mlist->miflags, fread_bitvector(fp)); break; case 'I': KEY("Int", mlist->intelligence, fread_number(fp)); KEY("IRange", mlist->irange, fread_number(fp)); break; case 'K': KEY("Kingdom", mlist->kingdom, fread_number(fp)); break; case 'L': KEY("Lck", mlist->lck, fread_number(fp)); KEY("Long", mlist->long_descr, fread_string(fp)); break; case 'M': KEY("Map", mlist->map, fread_number(fp)); KEY("Mount", mount, fread_number(fp)); break; case 'N': KEY("Name", mlist->name, fread_string(fp)); break; case 'P': KEY("PX", mlist->px, fread_number(fp)); KEY("PY", mlist->py, fread_number(fp)); KEY("PRange", mlist->prange, fread_number(fp)); break; case 'R': KEY("Race", mlist->race, fread_number(fp)); KEY("Room", mlist->room, fread_number(fp)); break; case 'S': KEY("Short", mlist->short_descr, fread_string(fp)); KEY("Speed", mlist->speed, fread_number(fp)); KEY("Str", mlist->str, fread_number(fp)); break; case 'T': KEY("Time", mlist->time, fread_number(fp)); KEY("Town", m1, fread_number(fp)); break; case 'V': KEY("Vnum", mlist->vnum, fread_number(fp)); break; case 'W': KEY("WaRange", mlist->warange, fread_number(fp)); KEY("Wis", mlist->wis, fread_number(fp)); break; case 'X': KEY("X", mlist->x, fread_number(fp)); break; case 'Y': KEY("Y", mlist->y, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { CHAR_DATA *victim; victim = create_mobile(get_mob_index(mlist->vnum)); char_to_room(victim, get_room_index(mlist->room)); victim->coord->x = mlist->x; victim->coord->y = mlist->y; victim->map = mlist->map; if (mlist->x > 0 && mlist->y > 0 && mlist->map > -1) SET_ONMAP_FLAG(victim); if (mount) { lmount = create_mobile(get_mob_index(MOB_KMOB_HORSE)); char_to_room(lmount, get_room_index(OVERLAND_SOLAN)); lmount->coord->x = victim->coord->x; lmount->coord->y = victim->coord->y; lmount->map = victim->map; lmount->m4 = mlist->kingdom; SET_ONMAP_FLAG(lmount); xSET_BIT(lmount->act, ACT_MOUNTED); victim->mount = lmount; victim->position = POS_MOUNTED; } victim->m1 = m1; victim->m3 = mlist->cost; victim->m4 = mlist->kingdom; victim->m9 = mlist->time; victim->m10 = mlist->speed; victim->miflags = mlist->miflags; if (xIS_SET(victim->miflags, KM_INVITE)) victim->m5 = mlist->irange; if (xIS_SET(victim->miflags, KM_PATROL)) { victim->m2 = mlist->prange; victim->m7 = mlist->px; victim->m8 = mlist->py; } if (mlist->name) { STRFREE(victim->name); victim->name = STRALLOC(mlist->name); } if (mlist->long_descr) { STRFREE(victim->long_descr); victim->long_descr = STRALLOC(mlist->long_descr); } if (mlist->short_descr) { STRFREE(victim->short_descr); victim->short_descr = STRALLOC(mlist->short_descr); } victim->race = mlist->race; victim->perm_str = mlist->str; victim->perm_int = mlist->intelligence; victim->perm_wis = mlist->wis; victim->perm_lck = mlist->lck; victim->perm_dex = mlist->dex; victim->perm_agi = mlist->agi; victim->perm_con = mlist->con; SET_BIT(victim->resistant, race_table[victim->race]->resist); SET_BIT(victim->susceptible, race_table[victim->race]->suscept); xSET_BITS(victim->affected_by, race_table[victim->race]->affected); if (xIS_SET(victim->miflags, KM_WARN) || xIS_SET(victim->miflags, KM_ATTACKA) || xIS_SET(victim->miflags, KM_ATTACKN) || xIS_SET(victim->miflags, KM_ATTACKE)) victim->m6 = mlist->warange; STRFREE(mlist->name); STRFREE(mlist->long_descr); STRFREE(mlist->short_descr); DISPOSE(mlist); for (;;) { char letter; if (feof(fp)) break; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { fread_to_eol(fp); continue; } word = fread_word(fp); if (!str_cmp(word, "OBJECT")) /* Objects */ { fread_obj(victim, fp, OS_CARRY); } else if (!str_cmp(word, "END")) //end the milist data { return; } } return; } } } } void load_mlist_data() { FILE *fp; if ((fp = fopen(MILIST_FILE, "r")) != NULL) { for (;;) { char letter; char *word; if (feof(fp)) break; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { fread_to_eol(fp); continue; } word = fread_word(fp); if (!str_cmp(word, "MIDATA")) { fread_mlist_data(fp); continue; } } fclose(fp); } } void save_bin_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; OBJ_DATA *obj; sprintf(filename, "%s", BIN_LIST); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } for (obj = first_object; obj; obj = obj->next) { if (obj->item_type == ITEM_HOLDRESOURCE && !obj->carried_by) { fprintf(fpout, "#BIN\n"); fprintf(fpout, "Bin1 %d\n", obj->value[2]); fprintf(fpout, "Bin2 %d\n", obj->value[4]); fprintf(fpout, "X %d\n", obj->coord->x); fprintf(fpout, "Y %d\n", obj->coord->y); fprintf(fpout, "Map %d\n", obj->map); fprintf(fpout, "Room %d\n", obj->in_room->vnum); fprintf(fpout, "Vnum %d\n", obj->pIndexData->vnum); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_bin_data(FILE * fp) { char buf[MSL]; char *word; bool fMatch; BIN_DATA *blist; CREATE(blist, BIN_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'B': KEY("Bin1", blist->bin1, fread_number(fp)); KEY("Bin2", blist->bin2, fread_number(fp)); break; case 'M': KEY("Map", blist->map, fread_number(fp)); break; case 'R': KEY("Room", blist->room, fread_number(fp)); break; case 'V': KEY("Vnum", blist->vnum, fread_number(fp)); break; case 'X': KEY("X", blist->x, fread_number(fp)); break; case 'Y': KEY("Y", blist->y, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { OBJ_INDEX_DATA *iobj; OBJ_DATA *obj; ROOM_INDEX_DATA *room; if (blist->x && blist->y && blist->room && blist->vnum) { room = get_room_index(blist->room); iobj = get_obj_index(blist->vnum); if (iobj != NULL && room != NULL) { obj = create_object(iobj, 0); blist->serial = obj->serial; obj_to_room(obj, room, room->first_person); obj->coord->x = blist->x; obj->coord->y = blist->y; obj->map = blist->map; SET_OBJ_STAT(obj, ITEM_ONMAP); obj->value[2] = blist->bin1; obj->value[4] = blist->bin2; } } LINK(blist, first_bin, last_bin, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_bin_data: no match: %s", word); bug(buf, 0); } } } void load_bin_data() { FILE *fp; if ((fp = fopen(BIN_LIST, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_bin_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "BIN")) { fread_bin_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_bin_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open bin file", 0); exit(0); } } WBLOCK_DATA* fread_wblock_data(FILE * fp) { char *word; bool fMatch; WBLOCK_DATA *wlist; CREATE(wlist, WBLOCK_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'K': KEY("Kills", wlist->kills, fread_number(fp)); break; case 'L': KEY("Level", wlist->lvl, fread_number(fp)); break; case 'M': KEY("Map", wlist->map, fread_number(fp)); break; case 'S': KEY("Startx", wlist->stx, fread_number(fp)); KEY("Starty", wlist->sty, fread_number(fp)); break; case 'T': KEY("TimeCheck", wlist->timecheck, fread_number(fp)); break; case 'E': KEY("Endx", wlist->endx, fread_number(fp)); KEY("Endy", wlist->endy, fread_number(fp)); if (!str_cmp(word, "End")) { LINK(wlist, first_wblock, last_wblock, next, prev); return wlist; } } } return NULL; } void fread_iblock_data(FILE * fp, WBLOCK_DATA *wblock) { char *word; bool fMatch; WINFO_DATA *ilist; if (wblock == NULL) { bug("fread_iblock_data: Trying to add an iblock structure to a Null wblock structure"); return; } CREATE(ilist, WINFO_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'P': KEY("Pid", ilist->pid, fread_number(fp)); break; case 'T': KEY("Time", ilist->time, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(ilist, wblock->first_player, wblock->last_player, next, prev); return; } } } return; } void create_basic_blocks() { int x; int y; int map; WBLOCK_DATA *wblock; for (map = 0; map < MAP_MAX; map++) { for (x = 1; x <= MAX_X; x = x+50) { for (y = 1; y <= MAX_Y; y = y+50) { CREATE(wblock, WBLOCK_DATA, 1); wblock->stx = x; wblock->endx = x+49; wblock->sty = y; wblock->endy = y+49; wblock->map = map; wblock->kills = 0; wblock->lvl = 10; wblock->first_player = NULL; wblock->last_player = NULL; LINK(wblock, first_wblock, last_wblock, next, prev); } } } save_wblock_data(); } void load_wblock_data() { FILE *fp; WBLOCK_DATA *wblock = NULL; int blocks = 0; if ((fp = fopen(WBLOCK_FILE, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_wblock_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "WBLOCK")) { wblock = fread_wblock_data(fp); blocks++; continue; } else if (!str_cmp(word, "IBLOCK")) { fread_iblock_data(fp, wblock); continue; } else if (!str_cmp(word, "END")) { if (blocks == 0) { create_basic_blocks(); } break; } else { bug("Load_wblock_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open wblock file", 0); exit(0); } } void save_wblock_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; WBLOCK_DATA *blist; WINFO_DATA *ilist; sprintf(filename, "%s", WBLOCK_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_wblock) { for (blist = first_wblock; blist; blist = blist->next) { fprintf(fpout, "#WBLOCK\n"); fprintf(fpout, "Startx %d\n", blist->stx); fprintf(fpout, "Starty %d\n", blist->sty); fprintf(fpout, "Endx %d\n", blist->endx); fprintf(fpout, "Endy %d\n", blist->endy); fprintf(fpout, "Map %d\n", blist->map); fprintf(fpout, "Level %d\n", blist->lvl); fprintf(fpout, "Kills %d\n", blist->kills); fprintf(fpout, "TimeCheck %d\n", blist->timecheck); fprintf(fpout, "End \n"); if (blist->first_player) { for (ilist = blist->first_player; ilist; ilist = ilist->next) { fprintf(fpout, "#IBLOCK\n"); fprintf(fpout, "Pid %d\n", ilist->pid); fprintf(fpout, "Time %d\n", ilist->time); fprintf(fpout, "End \n"); } } } } fprintf(fpout, "#END\n"); fclose(fpout); } void save_forge_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; FORGE_DATA *flist; sprintf(filename, "%s", FORGE_LIST); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_forge) { for (flist = first_forge; flist; flist = flist->next) { fprintf(fpout, "#FORGE\n"); fprintf(fpout, "name %s~\n", flist->name); fprintf(fpout, "vnum %d\n", flist->vnum); fprintf(fpout, "slabs %d\n", flist->slabnum); fprintf(fpout, "type %d\n", flist->type); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_forge_data(FILE * fp) { char *word; bool fMatch; FORGE_DATA *flist; CREATE(flist, FORGE_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'N': KEY("Name", flist->name, fread_string(fp)); break; case 'S': KEY("Slabs", flist->slabnum, fread_number(fp)); break; case 'T': KEY("Type", flist->type, fread_number(fp)); break; case 'V': KEY("Vnum", flist->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(flist, first_forge, last_forge, next, prev); return; } } // if ( !fMatch ) // { // sprintf( buf, "Fread_gem_data: no match: %s", word ); // bug( buf, 0 ); // } } } void load_forge_data() { FILE *fp; forge_num = 0; if ((fp = fopen(FORGE_LIST, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_forge_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "FORGE")) { forge_num += 1; fread_forge_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_forge_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open forge file", 0); exit(0); } } void save_slab_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; SLAB_DATA *slist; sprintf(filename, "%s", SLAB_LIST); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_slab) { for (slist = first_slab; slist; slist = slist->next) { fprintf(fpout, "#SLAB\n"); fprintf(fpout, "name %s~\n", slist->name); fprintf(fpout, "vnum %d\n", slist->vnum); fprintf(fpout, "adjective %s~\n", slist->adj); fprintf(fpout, "kmob %d\n", slist->kmob); fprintf(fpout, "qps %d\n", slist->qps); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_slab_data(FILE * fp) { char *word; bool fMatch; SLAB_DATA *slist; CREATE(slist, SLAB_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'N': KEY("Name", slist->name, fread_string(fp)); break; case 'A': KEY("Adjective", slist->adj, fread_string(fp)); break; case 'K': KEY("Kmob", slist->kmob, fread_number(fp)); break; case 'Q': KEY("Qps", slist->qps, fread_number(fp)); break; case 'V': KEY("Vnum", slist->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(slist, first_slab, last_slab, next, prev); return; } } // if ( !fMatch ) // { // sprintf( buf, "Fread_slab_data: no match: %s", word ); // bug( buf, 0 ); // } } } void load_slab_data() { FILE *fp; slab_num = 0; if ((fp = fopen(SLAB_LIST, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_slab_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "SLAB")) { slab_num += 1; fread_slab_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_slab_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open slab file", 0); exit(0); } } void save_trainer_data() { FILE *fp; char filename[MIL]; char buf[MSL]; TRAINER_DATA *tdata; sprintf(filename, "%s", TRAINER_LIST); if ((fp = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing.", filename); bug(buf, 0); return; } if (first_trainer) { for (tdata = first_trainer; tdata; tdata = tdata->next) { fprintf(fp, "#TRAINER\n"); fprintf(fp, "Version %d\n", TRAINERLISTVERSION); fprintf(fp, "Vnum %d\n", tdata->vnum); fprintf(fp, "Sn '%s' '%s' '%s' '%s' '%s'\n", IS_VALID_SN(tdata->sn[0]) ? skill_table[tdata->sn[0]]->name : "NONE", IS_VALID_SN(tdata->sn[1]) ? skill_table[tdata->sn[1]]->name : "NONE", IS_VALID_SN(tdata->sn[2]) ? skill_table[tdata->sn[2]]->name : "NONE", IS_VALID_SN(tdata->sn[3]) ? skill_table[tdata->sn[3]]->name : "NONE", IS_VALID_SN(tdata->sn[4]) ? skill_table[tdata->sn[4]]->name : "NONE"); fprintf(fp, "Sn2 '%s' '%s' '%s' '%s' '%s'\n", IS_VALID_SN(tdata->sn[5]) ? skill_table[tdata->sn[5]]->name : "NONE", IS_VALID_SN(tdata->sn[6]) ? skill_table[tdata->sn[6]]->name : "NONE", IS_VALID_SN(tdata->sn[7]) ? skill_table[tdata->sn[7]]->name : "NONE", IS_VALID_SN(tdata->sn[8]) ? skill_table[tdata->sn[8]]->name : "NONE", IS_VALID_SN(tdata->sn[9]) ? skill_table[tdata->sn[9]]->name : "NONE"); fprintf(fp, "Sn3 '%s' '%s' '%s' '%s' '%s'\n", IS_VALID_SN(tdata->sn[10]) ? skill_table[tdata->sn[10]]->name : "NONE", IS_VALID_SN(tdata->sn[11]) ? skill_table[tdata->sn[11]]->name : "NONE", IS_VALID_SN(tdata->sn[12]) ? skill_table[tdata->sn[12]]->name : "NONE", IS_VALID_SN(tdata->sn[13]) ? skill_table[tdata->sn[13]]->name : "NONE", IS_VALID_SN(tdata->sn[14]) ? skill_table[tdata->sn[14]]->name : "NONE"); fprintf(fp, "Sn4 '%s' '%s' '%s' '%s' '%s'\n", IS_VALID_SN(tdata->sn[15]) ? skill_table[tdata->sn[15]]->name : "NONE", IS_VALID_SN(tdata->sn[16]) ? skill_table[tdata->sn[16]]->name : "NONE", IS_VALID_SN(tdata->sn[17]) ? skill_table[tdata->sn[17]]->name : "NONE", IS_VALID_SN(tdata->sn[18]) ? skill_table[tdata->sn[18]]->name : "NONE", IS_VALID_SN(tdata->sn[19]) ? skill_table[tdata->sn[19]]->name : "NONE"); fprintf(fp, "Mastery %d %d %d %d %d %d %d %d %d %d\n", tdata->mastery[0], tdata->mastery[1], tdata->mastery[2], tdata->mastery[3], tdata->mastery[4], tdata->mastery[5], tdata->mastery[6], tdata->mastery[7], tdata->mastery[8], tdata->mastery[9]); fprintf(fp, "Mastery2 %d %d %d %d %d %d %d %d %d %d\n", tdata->mastery[10], tdata->mastery[11], tdata->mastery[12], tdata->mastery[13], tdata->mastery[14], tdata->mastery[15], tdata->mastery[16], tdata->mastery[17], tdata->mastery[18], tdata->mastery[19]); fprintf(fp, "End\n"); } } fprintf(fp, "#END\n"); fclose(fp); } void fread_trainer_data(FILE * fp) { char buf[MSL]; char *word; char *ln; int x1, x2, x3, x4, x5, x6, x7, x8, x9, x10; bool fMatch; TRAINER_DATA *tdata; CREATE(tdata, TRAINER_DATA, 1); boughtsaveversion = 1; //just in case.... for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'M': if (!str_cmp(word, "Mastery")) { ln = fread_line(fp); x1 = x2 = x3 = x4 = x5 = x6 = x7 = x8 = x9 = x10 = 0; sscanf(ln, "%d %d %d %d %d %d %d %d %d %d", &x1, &x2, &x3, &x4, &x5, &x6, &x7, &x8, &x9, &x10); tdata->mastery[0] = x1; tdata->mastery[1] = x2; tdata->mastery[2] = x3; tdata->mastery[3] = x4; tdata->mastery[4] = x5; tdata->mastery[5] = x6; tdata->mastery[6] = x7; tdata->mastery[7] = x8; tdata->mastery[8] = x9; tdata->mastery[9] = x10; fMatch = TRUE; } if (!str_cmp(word, "Mastery2")) { ln = fread_line(fp); x1 = x2 = x3 = x4 = x5 = x6 = x7 = x8 = x9 = x10 = 0; sscanf(ln, "%d %d %d %d %d %d %d %d %d %d", &x1, &x2, &x3, &x4, &x5, &x6, &x7, &x8, &x9, &x10); tdata->mastery[10] = x1; tdata->mastery[11] = x2; tdata->mastery[12] = x3; tdata->mastery[13] = x4; tdata->mastery[14] = x5; tdata->mastery[15] = x6; tdata->mastery[16] = x7; tdata->mastery[17] = x8; tdata->mastery[18] = x9; tdata->mastery[19] = x10; fMatch = TRUE; } break; case 'S': if (!str_cmp(word, "Sn")) { if (boughtsaveversion <= 1) { ln = fread_line(fp); x1 = x2 = x3 = x4 = x5 = x6 = x7 = x8 = x9 = x10 = 0; sscanf(ln, "%d %d %d %d %d %d %d %d %d %d", &x1, &x2, &x3, &x4, &x5, &x6, &x7, &x8, &x9, &x10); tdata->sn[0] = x1; tdata->sn[1] = x2; tdata->sn[2] = x3; tdata->sn[3] = x4; tdata->sn[4] = x5; tdata->sn[5] = x6; tdata->sn[6] = x7; tdata->sn[7] = x8; tdata->sn[8] = x9; tdata->sn[9] = x10; fMatch = TRUE; } else { tdata->sn[0] = skill_lookup(fread_word(fp)); tdata->sn[1] = skill_lookup(fread_word(fp)); tdata->sn[2] = skill_lookup(fread_word(fp)); tdata->sn[3] = skill_lookup(fread_word(fp)); tdata->sn[4] = skill_lookup(fread_word(fp)); if (tdata->sn[0] < 0) tdata->sn[0] = 0; if (tdata->sn[1] < 0) tdata->sn[1] = 0; if (tdata->sn[2] < 0) tdata->sn[2] = 0; if (tdata->sn[3] < 0) tdata->sn[3] = 0; if (tdata->sn[4] < 0) tdata->sn[4] = 0; fMatch = TRUE; } } if (!str_cmp(word, "Sn2")) { if (boughtsaveversion <= 1) { ln = fread_line(fp); x1 = x2 = x3 = x4 = x5 = x6 = x7 = x8 = x9 = x10 = 0; sscanf(ln, "%d %d %d %d %d %d %d %d %d %d", &x1, &x2, &x3, &x4, &x5, &x6, &x7, &x8, &x9, &x10); tdata->sn[10] = x1; tdata->sn[11] = x2; tdata->sn[12] = x3; tdata->sn[13] = x4; tdata->sn[14] = x5; tdata->sn[15] = x6; tdata->sn[16] = x7; tdata->sn[17] = x8; tdata->sn[18] = x9; tdata->sn[19] = x10; fMatch = TRUE; } else { tdata->sn[5] = skill_lookup(fread_word(fp)); tdata->sn[6] = skill_lookup(fread_word(fp)); tdata->sn[7] = skill_lookup(fread_word(fp)); tdata->sn[8] = skill_lookup(fread_word(fp)); tdata->sn[9] = skill_lookup(fread_word(fp)); if (tdata->sn[5] < 0) tdata->sn[5] = 0; if (tdata->sn[6] < 0) tdata->sn[6] = 0; if (tdata->sn[7] < 0) tdata->sn[7] = 0; if (tdata->sn[8] < 0) tdata->sn[8] = 0; if (tdata->sn[9] < 0) tdata->sn[9] = 0; fMatch = TRUE; } } if (!str_cmp(word, "Sn3")) { tdata->sn[10] = skill_lookup(fread_word(fp)); tdata->sn[11] = skill_lookup(fread_word(fp)); tdata->sn[12] = skill_lookup(fread_word(fp)); tdata->sn[13] = skill_lookup(fread_word(fp)); tdata->sn[14] = skill_lookup(fread_word(fp)); if (tdata->sn[10] < 0) tdata->sn[10] = 0; if (tdata->sn[11] < 0) tdata->sn[11] = 0; if (tdata->sn[12] < 0) tdata->sn[12] = 0; if (tdata->sn[13] < 0) tdata->sn[13] = 0; if (tdata->sn[14] < 0) tdata->sn[14] = 0; fMatch = TRUE; } if (!str_cmp(word, "Sn4")) { tdata->sn[15] = skill_lookup(fread_word(fp)); tdata->sn[16] = skill_lookup(fread_word(fp)); tdata->sn[17] = skill_lookup(fread_word(fp)); tdata->sn[18] = skill_lookup(fread_word(fp)); tdata->sn[19] = skill_lookup(fread_word(fp)); if (tdata->sn[15] < 0) tdata->sn[15] = 0; if (tdata->sn[16] < 0) tdata->sn[16] = 0; if (tdata->sn[17] < 0) tdata->sn[17] = 0; if (tdata->sn[18] < 0) tdata->sn[18] = 0; if (tdata->sn[19] < 0) tdata->sn[19] = 0; fMatch = TRUE; } break; case 'V': KEY("Version", boughtsaveversion, fread_number(fp)); KEY("Vnum", tdata->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(tdata, first_trainer, last_trainer, next, prev); return; } } if (!fMatch) { sprintf(buf, "Fread_trainer_data: no match: %s", word); bug(buf, 0); } } } void load_trainer_data() { FILE *fp; if ((fp = fopen(TRAINER_LIST, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_trainer_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "TRAINER")) { fread_trainer_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_trainer_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open trainer file", 0); exit(0); } } void save_barena_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; BARENA_DATA *blist; sprintf(filename, "%s", BARENA_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_barena) { for (blist = first_barena; blist; blist = blist->next) { fprintf(fpout, "#BARENA\n"); fprintf(fpout, "Name %s~\n", blist->name); fprintf(fpout, "Wins %d\n", blist->wins); fprintf(fpout, "Losses %d\n", blist->losses); fprintf(fpout, "Ties %d\n", blist->ties); fprintf(fpout, "Games %d\n", blist->games); fprintf(fpout, "Numavg %d\n", blist->numavg); fprintf(fpout, "Kills %d\n", blist->kills); fprintf(fpout, "Pkills %d\n", blist->pkills); fprintf(fpout, "Pdeaths %d\n", blist->pdeaths); fprintf(fpout, "Pranking %d\n", blist->pranking); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_barena_data(FILE * fp) { char *word; bool fMatch; BARENA_DATA *blist; CREATE(blist, BARENA_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'G': KEY("Games", blist->games, fread_number(fp)); break; case 'K': KEY("Kills", blist->kills, fread_number(fp)); break; case 'L': KEY("Losses", blist->losses, fread_number(fp)); break; case 'N': KEY("Name", blist->name, fread_string_nohash(fp)); KEY("Numavg", blist->numavg, fread_number(fp)); break; case 'P': KEY("Pdeaths", blist->pdeaths, fread_number(fp)); KEY("Pkills", blist->pkills, fread_number(fp)); KEY("Pranking", blist->pranking, fread_number(fp)); break; case 'T': KEY("Ties", blist->ties, fread_number(fp)); break; case 'W': KEY("Wins", blist->wins, fread_number(fp)); case 'E': if (!str_cmp(word, "End")) { LINK(blist, first_barena, last_barena, next, prev); return; } } // if ( !fMatch ) // { // sprintf( buf, "Fread_barena_data: no match: %s", word ); // bug( buf, 0 ); // } } } void load_barena_data() { FILE *fp; if ((fp = fopen(BARENA_FILE, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_barena_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "BARENA")) { fread_barena_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_barena_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open barena file", 0); exit(0); } } void save_box_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; BOX_DATA *boxlist; sprintf(filename, "%s", BOX_LIST); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_box) { for (boxlist = first_box; boxlist; boxlist = boxlist->next) { fprintf(fpout, "#BOX\n"); fprintf(fpout, "vnum %d\n", boxlist->vnum); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_box_data(FILE * fp) { char *word; bool fMatch; BOX_DATA *boxlist; CREATE(boxlist, BOX_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'V': KEY("Vnum", boxlist->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(boxlist, first_box, last_box, next, prev); return; } } // if ( !fMatch ) // { // sprintf( buf, "Fread_box_data: no match: %s", word ); // bug( buf, 0 ); // } } } void load_box_data() { FILE *fp; box_num = 0; if ((fp = fopen(BOX_LIST, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_box_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "BOX")) { box_num += 1; fread_box_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_box_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open box file", 0); exit(0); } } void save_gem_data() { FILE *fpout; char buf[MSL]; char filename[MIL]; GEM_DATA *glist; sprintf(filename, "%s", GEM_LIST); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_gem) { for (glist = first_gem; glist; glist = glist->next) { fprintf(fpout, "#GEM\n"); fprintf(fpout, "vnum %d\n", glist->vnum); fprintf(fpout, "cost %d\n", glist->cost); fprintf(fpout, "rarity %d\n", glist->rarity); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_gem_data(FILE * fp) { char *word; bool fMatch; GEM_DATA *glist; CREATE(glist, GEM_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Cost", glist->cost, fread_number(fp)); break; case 'R': KEY("Rarity", glist->rarity, fread_number(fp)); break; case 'V': KEY("Vnum", glist->vnum, fread_number(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(glist, first_gem, last_gem, next, prev); return; } } // if ( !fMatch ) // { // sprintf( buf, "Fread_gem_data: no match: %s", word ); // bug( buf, 0 ); // } } } void load_gem_data() { FILE *fp; gem_num = 0; if ((fp = fopen(GEM_LIST, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_gem_data: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "GEM")) { gem_num += 1; fread_gem_data(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_gem_data: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open gem file", 0); exit(0); } } void fwrite_authlist() { FILE *fpout; char buf[MSL]; char filename[MIL]; AUTHORIZE_DATA *alist; sprintf(filename, "%s", AUTHLIST_FILE); if ((fpout = fopen(filename, "w")) == NULL) { sprintf(buf, "Cannot open: %s for writing", filename); bug(buf, 0); return; } if (first_authorized) { for (alist = first_authorized; alist; alist = alist->next) { fprintf(fpout, "#AUTH\n"); fprintf(fpout, "Name %s~\n", alist->name); fprintf(fpout, "LastName %s~\n", alist->lastname); fprintf(fpout, "Authedby %s~\n", alist->authedby); fprintf(fpout, "Authdate %s~\n", alist->authdate); fprintf(fpout, "Ip %s~\n", alist->host); fprintf(fpout, "End\n"); } } fprintf(fpout, "#END\n"); fclose(fpout); } void fread_authlist(FILE * fp) { char buf[MSL]; char *word; bool fMatch; AUTHORIZE_DATA *alist; CREATE(alist, AUTHORIZE_DATA, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'A': KEY("Authedby", alist->authedby, fread_string_nohash(fp)); KEY("Authdate", alist->authdate, fread_string_nohash(fp)); break; case 'E': if (!str_cmp(word, "End")) { LINK(alist, first_authorized, last_authorized, next, prev); return; } case 'I': KEY("Ip", alist->host, fread_string_nohash(fp)); break; case 'L': KEY("LastName", alist->lastname, fread_string_nohash(fp)); break; case 'N': KEY("Name", alist->name, fread_string_nohash(fp)); break; } if (!fMatch) { sprintf(buf, "Fread_social: no match: %s", word); bug(buf, 0); } } } void load_authlist() { FILE *fp; if ((fp = fopen(AUTHLIST_FILE, "r")) != NULL) { for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_authlist: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "AUTH")) { fread_authlist(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_authlist: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open authlist file", 0); exit(0); } } void fread_social(FILE * fp) { char buf[MSL]; char *word; bool fMatch; SOCIALTYPE *social; CREATE(social, SOCIALTYPE, 1); for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("CharNoArg", social->char_no_arg, fread_string_nohash(fp)); KEY("CharFound", social->char_found, fread_string_nohash(fp)); KEY("CharAuto", social->char_auto, fread_string_nohash(fp)); break; case 'E': if (!str_cmp(word, "End")) { if (!social->name) { bug("Fread_social: Name not found", 0); free_social(social); return; } if (!social->char_no_arg) { bug("Fread_social: CharNoArg not found", 0); free_social(social); return; } add_social(social); return; } break; case 'N': KEY("Name", social->name, fread_string_nohash(fp)); break; case 'O': KEY("OthersNoArg", social->others_no_arg, fread_string_nohash(fp)); KEY("OthersFound", social->others_found, fread_string_nohash(fp)); KEY("OthersAuto", social->others_auto, fread_string_nohash(fp)); break; case 'V': KEY("VictFound", social->vict_found, fread_string_nohash(fp)); break; } if (!fMatch) { sprintf(buf, "Fread_social: no match: %s", word); bug(buf, 0); } } } void load_socials() { FILE *fp; if ((fp = fopen(SOCIAL_FILE, "r")) != NULL) { top_sn = 0; for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_socials: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "SOCIAL")) { fread_social(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_socials: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open socials.dat", 0); exit(0); } } /* * Added the flags Aug 25, 1997 --Shaddai */ void fread_command(FILE * fp) { char buf[MSL]; char *word; bool fMatch; CMDTYPE *command; CREATE(command, CMDTYPE, 1); command->lag_count = 0; /* can't have caused lag yet... FB */ command->flags = 0; /* Default to no flags set */ for (;;) { word = feof(fp) ? "End" : fread_word(fp); fMatch = FALSE; switch (UPPER(word[0])) { case '*': fMatch = TRUE; fread_to_eol(fp); break; case 'C': KEY("Code", command->do_fun, skill_function(fread_word(fp))); break; case 'E': if (!str_cmp(word, "End")) { if (!command->name) { bug("Fread_command: Name not found", 0); free_command(command); return; } if (!command->do_fun) { bug("Fread_command: Function not found", 0); free_command(command); return; } add_command(command); return; } break; case 'F': KEY("FCommand", command->fcommand, fread_number(fp)); KEY("Flags", command->flags, fread_number(fp)); break; case 'L': KEY("Level", command->level, fread_number(fp)); KEY("Log", command->log, fread_number(fp)); break; case 'N': KEY("Name", command->name, fread_string_nohash(fp)); break; case 'P': /* KEY( "Position", command->position, fread_number(fp) ); */ if (!str_cmp(word, "Position")) { fMatch = TRUE; command->position = fread_number(fp); if (command->position < 100) { switch (command->position) { default: case 0: case 1: case 2: case 3: case 4: break; case 5: command->position = 6; break; case 6: command->position = 8; break; case 7: command->position = 9; break; case 8: command->position = 12; break; case 9: command->position = 13; break; case 10: command->position = 14; break; case 11: command->position = 15; break; } } else command->position -= 100; break; } break; } if (!fMatch) { sprintf(buf, "Fread_command: no match: %s", word); bug(buf, 0); } } } void load_commands() { FILE *fp; if ((fp = fopen(COMMAND_FILE, "r")) != NULL) { top_sn = 0; for (;;) { char letter; char *word; letter = fread_letter(fp); if (letter == '*') { fread_to_eol(fp); continue; } if (letter != '#') { bug("Load_commands: # not found.", 0); break; } word = fread_word(fp); if (!str_cmp(word, "COMMAND")) { fread_command(fp); continue; } else if (!str_cmp(word, "END")) break; else { bug("Load_commands: bad section.", 0); continue; } } fclose(fp); } else { bug("Cannot open commands.dat", 0); exit(0); } } void save_classes() { write_class_file(0); } /* * Tongues / Languages loading/saving functions -Altrag */ void fread_cnv(FILE * fp, LCNV_DATA ** first_cnv, LCNV_DATA ** last_cnv) { LCNV_DATA *cnv; char letter; for (;;) { letter = fread_letter(fp); if (letter == '~' || letter == EOF) break; ungetc(letter, fp); CREATE(cnv, LCNV_DATA, 1); cnv->old = str_dup(fread_word(fp)); cnv->olen = strlen(cnv->old); cnv->new = str_dup(fread_word(fp)); cnv->nlen = strlen(cnv->new); fread_to_eol(fp); LINK(cnv, *first_cnv, *last_cnv, next, prev); } } void load_tongues() { FILE *fp; LANG_DATA *lng; char *word; char letter; if (!(fp = fopen(TONGUE_FILE, "r"))) { perror("Load_tongues"); return; } for (;;) { letter = fread_letter(fp); if (letter == EOF) return; else if (letter == '*') { fread_to_eol(fp); continue; } else if (letter != '#') { bug("Letter '%c' not #.", letter); exit(0); } word = fread_word(fp); if (!str_cmp(word, "end")) return; fread_to_eol(fp); CREATE(lng, LANG_DATA, 1); lng->name = STRALLOC(word); fread_cnv(fp, &lng->first_precnv, &lng->last_precnv); lng->alphabet = fread_string(fp); fread_cnv(fp, &lng->first_cnv, &lng->last_cnv); fread_to_eol(fp); LINK(lng, first_lang, last_lang, next, prev); } return; } void fwrite_langs(void) { FILE *fp; LANG_DATA *lng; LCNV_DATA *cnv; if (!(fp = fopen(TONGUE_FILE, "w"))) { perror("fwrite_langs"); return; } for (lng = first_lang; lng; lng = lng->next) { fprintf(fp, "#%s\n", lng->name); for (cnv = lng->first_precnv; cnv; cnv = cnv->next) fprintf(fp, "'%s' '%s'\n", cnv->old, cnv->new); fprintf(fp, "~\n%s~\n", lng->alphabet); for (cnv = lng->first_cnv; cnv; cnv = cnv->next) fprintf(fp, "'%s' '%s'\n", cnv->old, cnv->new); fprintf(fp, "\n"); } fprintf(fp, "#end\n\n"); fclose(fp); return; } //not used anymore const struct hometown_type hometown_table[] = { /* { "name", recall, death }, */ {"Rafermand", 21001, 21194}, {"New Thalos", 31405, 31404}, {NULL, 21001, 21194} };