Difference for include/sproto.h from version 1.95 to 1.96

version 1.95

version 1.96

Line 23

int apply_container(object *op, object *sack);

int esrv_apply_container(object *op, object *sack);

void move_apply(object *trap, object *victim, object *originator);

void do_learn_spell(object *op, int spell, int special_prayer);

void do_learn_spell(object *op, object *spell, int special_prayer);

void do_forget_spell(object *op, int spell);

void do_forget_spell(object *op, char *spell);

void apply_scroll(object *op, object *tmp, int dir);

int dragon_eat_flesh(object *op, object *meal);

void apply_poison(object *op, object *tmp);

Line 44

void scroll_failure(object *op, int failure, int power);

void apply_changes_to_player(object *pl, object *change);

/* attack.c */

void cancellation(object *op);

int did_make_save_item(object *op, int type, object *originator);

void save_throw_object(object *op, int type, object *originator);

int hit_map(object *op, int dir, int type);

Line 53

Line 54

void tear_down_wall(object *op);

int hit_player_attacktype(object *op, object *hitter, int dam, uint32 attacknum, int magic);

int kill_object(object *op, int dam, object *hitter, int type);

int friendly_fire(object *op, object *hitter);

int hit_player(object *op, int dam, object *hitter, int type);

void poison_player(object *op, object *hitter, int dam);

void slow_player(object *op, object *hitter, int dam);

Line 66

Line 68

int checkbanned(char *login, char *host);

/* c_chat.c */

int command_say(object *op, char *params);

int command_me(object *op, char *params);

int command_cointoss(object *op, char *params);

int command_orcknuckle(object *op, char *params);

int command_shout(object *op, char *params);

Line 128

Line 131

/* c_misc.c */

void map_info(object *op, char *search);

int command_body(object *op, char *params);

int command_spell_reset(object *op, char *params);

int command_motd(object *op, char *params);

int command_bug(object *op, char *params);

void malloc_info(object *op);

Line 192

Line 194

int command_southwest(object *op, char *params);

int command_west(object *op, char *params);

int command_stay(object *op, char *params);

int command_search(object *op, char *params);

int command_disarm(object *op, char *params);

/* c_new.c */

int execute_newserver_command(object *pl, char *command);

int command_run(object *op, char *params);

Line 206

int command_build(object *pl, char *params);

int command_uskill(object *pl, char *params);

int command_rskill(object *pl, char *params);

int command_search(object *op, char *params);

int command_disarm(object *op, char *params);

int command_throw(object *op, char *params);

int command_apply(object *op, char *params);

int sack_can_hold(object *pl, object *sack, object *op, int nrof);

void pick_up(object *op, object *alt);

Line 243

Line 246

int legal_range(object *op, int r);

void change_spell(object *op, char k);

int command_rotateshoottype(object *op, char *params);

int command_throw(object *op, char *params);

int command_rotatespells(object *op, char *params);

/* c_wiz.c */

int command_banish(object *op, char *params);

int command_loadtest(object *op, char *params);

int command_hide(object *op, char *params);

int command_setgod(object *op, char *params);

int command_banish(object *op, char *params);

int command_kick(object *op, char *params);

int command_save_overlay(object *op, char *params);

int command_toggle_shout(object *op, char *params);

int command_shutdown(object *op, char *params);

int command_goto(object *op, char *params);

int command_generate(object *op, char *params);

Line 260

Line 262

int command_teleport(object *op, char *params);

int command_create(object *op, char *params);

int command_inventory(object *op, char *params);

int command_toggle_shout(object *op, char *params);

int command_skills(object *op, char *params);

int command_dump(object *op, char *params);

int command_mon_aggr(object *op, char *params);

Line 313

Line 314

/* gods.c */

int lookup_god_by_name(char *name);

object *find_god(char *name);

void pray_at_altar(object *pl, object *altar);

char *determine_god(object *op);

void pray_at_altar(object *pl, object *altar, object *skill);

void become_follower(object *op, object *new_god);

int worship_forbids_use(object *op, object *exp_obj, uint32 flag, char *string);

void stop_using_item(object *op, int type, int number);

void update_priest_flag(object *god, object *exp_ob, uint32 flag);

char *determine_god(object *op);

archetype *determine_holy_arch(object *god, const char *type);

void god_intervention(object *op, object *god);

void god_intervention(object *op, object *god, object *skill);

int god_examines_priest(object *op, object *god);

int god_examines_item(object *god, object *item);

int get_god(object *priest);

int tailor_god_spell(object *spellop, object *caster);

void lose_priest_exp(object *pl, int loss);

/* init.c */

void set_logfile(char *val);

void call_version(void);

Line 466

void remove_all_pets(mapstruct *map);

void follow_owner(object *ob, object *owner);

void pet_move(object *ob);

object *fix_summon_pet(archetype *at, object *op, int dir, int is_golem);

void move_golem(object *op);

void control_golem(object *op, int dir);

int summon_golem(object *op, object *caster, int dir, object *spob);

object *choose_cult_monster(object *pl, object *god, int summon_level);

int summon_object(object *op, object *caster, object *spell_ob, int dir);

/* player.c */

player *find_player(char *plname);

void display_motd(object *op);

Line 589

Line 595

CFParm *UnregisterGlobalEvent(CFParm *PParm);

void GlobalEvent(CFParm *PParm);

/* resurrection.c */

void dead_player(object *op);

int cast_raise_dead_spell(object *op, object *caster, object *spell, int dir, char *arg);

int cast_raise_dead_spell(object *op, int dir, int spell_type, object *corpseobj);

int resurrection_fails(int levelcaster, int leveldead);

int resurrect_player(object *op, char *playername, int rspell);

void dead_player(object *op);

void dead_character(char *name);

int dead_player_exists(char *name);

/* rune.c */

int write_rune(object *op, int dir, int inspell, int level, char *runename);

int write_rune(object *op, object *caster, object *spell, int dir, char *runename);

void move_rune(object *op);

void rune_attack(object *op, object *victim);

void spring_trap(object *trap, object *victim);

int dispel_rune(object *op, int dir, int risk);

int dispel_rune(object *op, object *caster, object *spell, object *skill, int dir);

int trap_see(object *op, object *trap);

int trap_show(object *trap, object *where);

int trap_disarm(object *disarmer, object *trap, int risk);

int trap_disarm(object *disarmer, object *trap, int risk, object *skill);

void trap_adjust(object *trap, int difficulty);

int cast_generic_rune(object *op, object *caster, int dir, char *stringarg, int type);

/* shop.c */

int query_cost(object *tmp, object *who, int flag);

char *cost_string_from_value(int cost);

Line 619

Line 623

void sell_item(object *op, object *pl);

void shop_listing(object *op);

/* skills.c */

int attempt_steal(object *op, object *who);

int steal(object *op, int dir, object *skill);

int adj_stealchance(object *op, object *victim, int roll);

int pick_lock(object *pl, int dir, object *skill);

int steal(object *op, int dir);

int hide(object *op, object *skill);

int pick_lock(object *pl, int dir);

int jump(object *pl, int dir, object *skill);

int attempt_pick_lock(object *door, object *pl);

int do_skill_ident2(object *tmp, object *pl, int obj_class, object *skill);

int hide(object *op);

int skill_ident(object *pl, object *skill);

int attempt_hide(object *op);

int use_oratory(object *pl, int dir, object *skill);

int jump(object *pl, int dir);

int singing(object *pl, int dir, object *skill);

int skill_ident(object *pl);

int find_traps(object *pl, object *skill);

int do_skill_detect_curse(object *pl);

int remove_trap(object *op, int dir, object *skill);

int do_skill_detect_magic(object *pl);

int pray(object *pl, object *skill);

int do_skill_ident2(object *tmp, object *pl, int obj_class);

void meditate(object *pl, object *skill);

int do_skill_ident(object *pl, int obj_class);

int write_on_item(object *pl, char *params, object *skill);

int use_oratory(object *pl, int dir);

int skill_throw(object *op, object *part, int dir, char *params, object *skill);

int singing(object *pl, int dir);

int find_traps(object *pl);

int pray(object *pl);

void meditate(object *pl);

int write_on_item(object *pl, char *params);

int write_note(object *pl, object *item, char *msg);

int write_scroll(object *pl, object *scroll);

int remove_trap(object *op, int dir);

int skill_throw(object *op, object *part, int dir, char *params);

object *find_throw_ob(object *op, char *request);

object *make_throw_ob(object *orig);

int do_throw(object *op, object *part, object *toss_item, int dir);

/* skill_util.c */

void find_skill_exp_name(object *pl, object *exp, int index);

void init_skills(void);

int do_skill(object *op, object *part, int dir, char *string);

void link_player_skills(object *op);

int calc_skill_exp(object *who, object *op);

object *find_skill_by_name(object *who, char *name);

float calc_stat_mult(object *who, int sk);

int change_skill(object *who, object *new_skill, int flag);

int get_weighted_skill_stat_sum(object *who, int sk);

void clear_skill(object *who);

void init_new_exp_system(void);

int do_skill(object *op, object *part, object *skill, int dir, char *string);

void dump_skills(void);

int calc_skill_exp(object *who, object *op, object *skill);

void init_exp_obj(void);

void link_skills_to_exp(void);

int check_link(int stat, object *exp);

void read_skill_params(void);

int lookup_skill_by_name(char *string);

int check_skill_to_fire(object *who);

int check_skill_to_apply(object *who, object *item);

int init_player_exp(object *pl);

void unlink_skill(object *skillop);

int link_player_skills(object *pl);

int link_player_skill(object *pl, object *skillop);

int learn_skill(object *pl, object *scroll);

void show_skills(object *op);

int use_skill(object *op, char *string);

int change_skill(object *who, int sk_index);

int skill_attack(object *tmp, object *pl, int dir, char *string, object *skill);

int change_skill_to_skill(object *who, object *skl);

int attack_hth(object *pl, int dir, char *string, object *skill);

int attack_melee_weapon(object *op, int dir, char *string);

int attack_melee_weapon(object *op, int dir, char *string, object *skill);

int attack_hth(object *pl, int dir, char *string);

/* spell_attack.c */

int skill_attack(object *tmp, object *pl, int dir, char *string);

void forklightning(object *op, object *tmp);

int do_skill_attack(object *tmp, object *op, char *string);

void move_bolt(object *op);

int hth_damage(object *target, object *pl);

int fire_bolt(object *op, object *caster, int dir, object *spob, object *skill);

int SK_level(object *op);

void explosion(object *op);

float get_skill_time(object *op, int skillnr);

void explode_bullet(object *op);

int get_skill_stat1(object *op);

void check_bullet(object *op);

int get_skill_stat2(object *op);

void move_bullet(object *op);

int get_skill_stat3(object *op);

int fire_bullet(object *op, object *caster, int dir, object *spob);

int get_weighted_skill_stats(object *op);

void check_cone_push(object *op);

object *get_skill_from_inventory(object *op, const char *skname);

void cone_drop(object *op);

void move_cone(object *op);

int cast_cone(object *op, object *caster, int dir, object *spell);

void animate_bomb(object *op);

int create_bomb(object *op, object *caster, int dir, object *spell);

object *get_pointed_target(object *op, int dir, int range, int type);

int cast_smite_spell(object *op, object *caster, int dir, object *spell);

void move_missile(object *op);

int make_object_glow(object *op, int radius, int time);

int cast_destruction(object *op, object *caster, object *spell_ob);

int cast_curse(object *op, object *caster, object *spell_ob, int dir);

int mood_change(object *op, object *caster, object *spell);

void move_ball_spell(object *op);

void move_swarm_spell(object *op);

int fire_swarm(object *op, object *caster, object *spell, int dir);

int cast_light(object *op, object *caster, object *spell, int dir);

int cast_cause_disease(object *op, object *caster, object *spell, int dir);

/* spell_effect.c */

void spell_failure(object *op, int failure, int power);

void prayer_failure(object *op, int failure, int power);

void cast_mana_storm(object *op, int lvl);

void cast_magic_storm(object *op, object *tmp, int lvl);

void aggravate_monsters(object *op);

int recharge(object *op, object *caster, object *spell_ob);

int recharge(object *op);

void polymorph_living(object *op);

void polymorph_melt(object *who, object *op);

void polymorph_item(object *who, object *op);

void polymorph(object *op, object *who);

int cast_polymorph(object *op, int dir);

int cast_polymorph(object *op, object *caster, object *spell_ob, int dir);

int cast_create_food(object *op, object *caster, int dir, char *stringarg);

int cast_create_missile(object *op, object *caster, object *spell, int dir, char *stringarg);

int cast_speedball(object *op, int dir, int type);

int cast_create_food(object *op, object *caster, object *spell_ob, int dir, char *stringarg);

int probe(object *op, int dir);

int probe(object *op, object *caster, object *spell_ob, int dir);

int cast_invisible(object *op, object *caster, int spell_type);

int makes_invisible_to(object *pl, object *mon);

int cast_earth2dust(object *op, object *caster);

int cast_invisible(object *op, object *caster, object *spell_ob);

int cast_wor(object *op, object *caster);

int cast_earth_to_dust(object *op, object *caster, object *spell_ob);

int cast_wow(object *op, int dir, int ability, SpellTypeFrom item);

void execute_word_of_recall(object *op);

int cast_word_of_recall(object *op, object *caster, object *spell_ob);

int cast_wonder(object *op, object *caster, int dir, object *spell_ob);

int perceive_self(object *op);

int cast_create_town_portal(object *op, object *caster, int dir);

int cast_create_town_portal(object *op, object *caster, object *spell, int dir);

int cast_destruction(object *op, object *caster, int dam, int attacktype);

int magic_wall(object *op, object *caster, int dir, object *spell_ob);

int magic_wall(object *op, object *caster, int dir, int spell_type);

int dimension_door(object *op, object *caster, object *spob, int dir);

int cast_light(object *op, object *caster, int dir);

int cast_heal(object *op, object *caster, object *spell, int dir);

int dimension_door(object *op, int dir);

int cast_change_ability(object *op, object *caster, object *spell_ob, int dir);

int cast_heal(object *op, int dir, int spell_type);

int cast_bless(object *op, object *caster, object *spell_ob, int dir);

int cast_regenerate_spellpoints(object *op);

int alchemy(object *op, object *caster, object *spell_ob);

int cast_change_attr(object *op, object *caster, int dir, int spell_type);

int remove_curse(object *op, object *caster, object *spell);

int summon_pet(object *op, int dir, SpellTypeFrom item);

int cast_identify(object *op, object *caster, object *spell);

int create_bomb(object *op, object *caster, int dir, int spell_type, char *name);

int cast_detection(object *op, object *caster, object *spell);

void animate_bomb(object *op);

int cast_transfer(object *op, object *caster, object *spell, int dir);

int fire_cancellation(object *op, int dir, archetype *at, int magic);

void move_cancellation(object *op);

void cancellation(object *op);

int cast_create_missile(object *op, object *caster, int dir, char *stringarg);

int alchemy(object *op);

int remove_curse(object *op, int type, SpellTypeFrom src);

int cast_identify(object *op);

int cast_detection(object *op, int type);

int cast_pacify(object *op, object *weap, archetype *arch, int spellnum);

int summon_fog(object *op, object *caster, int dir, int spellnum);

int create_the_feature(object *op, object *caster, int dir, int spell_effect);

int cast_transfer(object *op, int dir);

int drain_magic(object *op, int dir);

void counterspell(object *op, int dir);

int summon_hostile_monsters(object *op, int n, char *monstername);

int cast_consecrate(object *op, object *caster, object *spell);

int cast_charm(object *op, object *caster, archetype *arch, int spellnum);

int animate_weapon(object *op, object *caster, object *spell, int dir);

int cast_charm_undead(object *op, object *caster, archetype *arch, int spellnum);

int cast_change_map_lightlevel(object *op, object *caster, object *spell);

object *choose_cult_monster(object *pl, object *god, int summon_level);

int create_aura(object *op, object *caster, object *spell);

int summon_cult_monsters(object *op, int old_dir);

int summon_avatar(object *op, object *caster, int dir, archetype *at, int spellnum);

object *fix_summon_pet(archetype *at, object *op, int dir, int type);

int cast_consecrate(object *op);

int finger_of_death(object *op, object *caster, int dir);

int animate_weapon(object *op, object *caster, int dir, archetype *at, int spellnum);

int cast_daylight(object *op);

int cast_nightfall(object *op);

int cast_faery_fire(object *op, object *caster);

int make_object_glow(object *op, int radius, int time);

int cast_cause_disease(object *op, object *caster, int dir, archetype *disease_arch, int type);

void move_aura(object *aura);

void move_peacemaker(object *op);

int cast_cause_conflict(object *op, object *caster, archetype *spellarch, int type);

int write_mark(object *op, object *spell, char *msg);

/* spell_util.c */

object *find_random_spell_in_ob(object *ob, char *skill);

void set_spell_skill(object *op, object *caster, object *spob, object *dest);

void init_spells(void);

void dump_spells(void);

void spell_effect(int spell_type, int x, int y, mapstruct *map, object *originator);

void spell_effect(object *spob, int x, int y, mapstruct *map, object *originator);

spell *find_spell(int spelltype);

int min_casting_level(object *caster, object *spell);

int path_level_mod(object *caster, int base_level, int spell_type);

int caster_level(object *caster, object *spell);

int casting_level(object *caster, int spell_type);

int SP_level_spellpoint_cost(object *caster, object *spell, int flags);

int check_spell_known(object *op, int spell_type);

int SP_level_dam_adjust(object *caster, object *spob);

int cast_spell(object *op, object *caster, int dir, int type, int ability, SpellTypeFrom item, char *stringarg);

int SP_level_duration_adjust(object *caster, object *spob);

int cast_create_obj(object *op, object *caster, object *new_op, int dir);

int SP_level_range_adjust(object *caster, object *spob);

int summon_monster(object *op, object *caster, int dir, archetype *at, int spellnum);

object *check_spell_known(object *op, char *name);

int fire_bolt(object *op, object *caster, int dir, int type, int magic);

object *lookup_spell_by_name(object *op, char *spname);

int fire_arch(object *op, object *caster, int dir, archetype *at, int type, int magic);

int fire_arch_from_position(object *op, object *caster, sint16 x, sint16 y, int dir, archetype *at, int type, int magic);

int cast_cone(object *op, object *caster, int dir, int strength, int spell_type, archetype *spell_arch, int magic);

void check_cone_push(object *op);

void cone_drop(object *op);

void move_cone(object *op);

void fire_a_ball(object *op, int dir, int strength);

void explosion(object *op);

void forklightning(object *op, object *tmp);

int reflwall(mapstruct *m, int x, int y, object *sp_op);

void move_bolt(object *op);

int cast_create_obj(object *op, object *caster, object *new_op, int dir);

void move_golem(object *op);

int ok_to_put_more(mapstruct *m, sint16 x, sint16 y, object *op, int immune_stop);

void control_golem(object *op, int dir);

int fire_arch_from_position(object *op, object *caster, sint16 x, sint16 y, int dir, object *spell);

void move_missile(object *op);

void regenerate_rod(object *rod);

void explode_object(object *op);

void check_fired_arch(object *op);

void move_fired_arch(object *op);

void drain_rod_charge(object *rod);

void fix_rod_speed(object *rod);

object *find_target_for_friendly_spell(object *op, int dir);

void move_ball_lightning(object *op);

int can_see_monsterP(mapstruct *m, int x, int y, int dir);

int spell_find_dir(mapstruct *m, int x, int y, object *exclude);

int SP_level_dam_adjust(object *op, object *caster, int spell_type);

int SP_level_strength_adjust(object *op, object *caster, int spell_type);

int SP_level_spellpoint_cost(object *op, object *caster, int spell_type);

void move_swarm_spell(object *op);

void fire_swarm(object *op, object *caster, int dir, archetype *swarm_type, int spell_type, int n, int magic);

int create_aura(object *op, object *caster, archetype *aura_arch, int spell_type, int magic);

int look_up_spell_by_name(object *op, char *spname);

void put_a_monster(object *op, char *monstername);

int summon_hostile_monsters(object *op, int n, char *monstername);

void shuffle_attack(object *op, int change_face);

void init_spell_param(void);

void prayer_failure(object *op, int failure, int power);

object *get_pointed_target(object *op, int dir);

void spell_failure(object *op, int failure, int power, object *skill);

int cast_smite_spell(object *op, object *caster, int dir, int type);

int cast_spell(object *op, object *caster, int dir, object *spell_ob, char *stringarg);

void move_spell_effect(object *op);

void check_spell_effect(object *op);

void apply_spell_effect(object *spell, object *victim);

/* swamp.c */

void walk_on_deep_swamp(object *op, object *victim);

void move_deep_swamp(object *op);

Line 806

Line 761

void remove_door(object *op);

void remove_door2(object *op);

void generate_monster(object *gen);

void regenerate_rod(object *rod);

void remove_force(object *op);

void remove_blindness(object *op);

void remove_confusion(object *op);

void execute_wor(object *op);

void poison_more(object *op);

void move_gate(object *op);

void move_timed_gate(object *op);

Line 825

Line 777

void move_teleporter(object *op);

void move_player_changer(object *op);

void move_firewall(object *op);

void move_firechest(object *op);

void move_player_mover(object *op);

void move_duplicator(object *op);

void move_creator(object *op);

Line 833

Line 784

int process_object(object *op);

/* timers.c */

void cftimer_process_timers(void);

void cftimer_process_event(object *ob);

int cftimer_create(int id, long delay, object *ob, int mode);

int cftimer_destroy(int id);

int cftimer_find_free_id(void);

void cftimer_process_event(object* ob);

/* weather.c */

void set_darkness_map(mapstruct *m);

void dawn_to_dusk(timeofday_t *tod);

Line 866

Line 817

void write_rainfallmap(void);

void read_rainfallmap(void);

void init_rainfall(void);

void init_weatheravoid(weather_avoids_t wa[]);

void init_weather(void);

void perform_weather(void);

void calculate_temperature(mapstruct *m, int wx, int wy);

void weather_effect(char *filename);

object *avoid_weather(int *av, mapstruct *m, int x, int y, int *gs, int grow);

void calculate_temperature(mapstruct *m, int wx, int wy);

void let_it_snow(mapstruct *m, int wx, int wy, char *filename);

void singing_in_the_rain(mapstruct *m, int wx, int wy, char *filename);

void plant_a_garden(mapstruct *m, int wx, int wy, char *filename);

void change_the_world(mapstruct *m, int wx, int wy, char *filename);

void feather_map(mapstruct *m, int wx, int wy, char *filename);

//int worldmap_to_weathermap(int x, int y, int *wx, int *wy, char *filename);

int worldmap_to_weathermap(int x, int y, int *wx, int *wy, mapstruct* m);

char *weathermap_to_worldmap_corner(int wx, int wy, int *x, int *y, int dir);

int polar_distance(int x, int y, int equator);

Line 892

Line 843

void plot_gulfstream(void);

void compute_sky(void);

void process_rain(void);

void spin_globe(void);

void write_weather_images(void);

Legend:

line(s) removed in v.1.95
line(s) changed
	line(s) added in v.1.96

File made using version 1.98 of cvs2html by leaf at 2011-07-21 19:31