battle.c

最新的仙镜传说服务器C语言源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "battle.h"

#include "timer.h"

#include "map.h"
#include "pc.h"
#include "skill.h"
#include "mob.h"
#include "itemdb.h"
#include "clif.h"
#include "pet.h"
#include "guild.h"

int attr_fix_table[4][10][10];

struct Battle_Config battle_config;

static int distance(int x0,int y0,int x1,int y1)
{
	int dx,dy;

	dx=abs(x0-x1);
	dy=abs(y0-y1);
	return dx>dy ? dx : dy;
}

// 奺庬僷儔儊乕僞強摼

int battle_counttargeted(struct block_list *bl,struct block_list *src)
{
	if(bl->type == BL_PC)
		return pc_counttargeted((struct map_session_data *)bl,src);
	else if(bl->type == BL_MOB)
		return mob_counttargeted((struct mob_data *)bl,src);
	return 0;
}

int battle_get_class(struct block_list *bl)
{
	if(bl->type==BL_MOB)
		return ((struct mob_data *)bl)->class;
	else if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->status.class;
	else if(bl->type==BL_PET)
		return ((struct pet_data *)bl)->class;
	else
		return 0;
}
int battle_get_dir(struct block_list *bl)
{
	if(bl->type==BL_MOB)
		return ((struct mob_data *)bl)->dir;
	else if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->dir;
	else if(bl->type==BL_PET)
		return ((struct pet_data *)bl)->dir;
	else
		return 0;
}
int battle_get_lv(struct block_list *bl)
{
	if(bl->type==BL_MOB)
		return mob_db[((struct mob_data *)bl)->class].lv;
	else if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->status.base_level;
	else if(bl->type==BL_PET)
		return ((struct pet_data *)bl)->msd->pet.level;
	else
		return 0;
}
int battle_get_range(struct block_list *bl)
{
	if(bl->type==BL_MOB)
		return mob_db[((struct mob_data *)bl)->class].range;
	else if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->attackrange;
	else if(bl->type==BL_PET)
		return mob_db[((struct pet_data *)bl)->class].range;
	else
		return 0;
}
int battle_get_hp(struct block_list *bl)
{
	if(bl->type==BL_MOB)
		return ((struct mob_data *)bl)->hp;
	else if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->status.hp;
	else
		return 1;
}
int battle_get_max_hp(struct block_list *bl)
{
	if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->status.max_hp;
	else {
		struct status_change *sc_data=battle_get_sc_data(bl);
		int max_hp=1;
		if(bl->type==BL_MOB) {
			max_hp = mob_db[((struct mob_data*)bl)->class].max_hp;
			if(mob_db[((struct mob_data*)bl)->class].mexp > 0) {
				if(battle_config.mvp_hp_rate != 100)
					max_hp = (max_hp * battle_config.mvp_hp_rate)/100;
			}
			else {
				if(battle_config.monster_hp_rate != 100)
					max_hp = (max_hp * battle_config.monster_hp_rate)/100;
			}
		}
		else if(bl->type==BL_PET) {
			max_hp = mob_db[((struct pet_data*)bl)->class].max_hp;
			if(mob_db[((struct pet_data*)bl)->class].mexp > 0) {
				if(battle_config.mvp_hp_rate != 100)
					max_hp = (max_hp * battle_config.mvp_hp_rate)/100;
			}
			else {
				if(battle_config.monster_hp_rate != 100)
					max_hp = (max_hp * battle_config.monster_hp_rate)/100;
			}
		}
		if(sc_data) {
			if(sc_data[SC_APPLEIDUN].timer!=-1)
				max_hp += ((5+sc_data[SC_APPLEIDUN].val1*2+((sc_data[SC_APPLEIDUN].val2+1)>>1)
						+sc_data[SC_APPLEIDUN].val3/10) * max_hp)/100;
		}
		if(max_hp < 1) max_hp = 1;
		return max_hp;
	}
	return 1;
}
int battle_get_str(struct block_list *bl)
{
	int str=0;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_MOB)
		str = mob_db[((struct mob_data *)bl)->class].str;
	else if(bl->type==BL_PC)
		return ((struct map_session_data *)bl)->paramc[0];
	else if(bl->type==BL_PET)
		str = mob_db[((struct pet_data *)bl)->class].str;

	if(sc_data) {
		if(sc_data[SC_LOUD].timer!=-1 && sc_data[SC_QUAGMIRE].timer == -1 && bl->type != BL_PC)
			str += 4;
		if( sc_data[SC_BLESSING].timer != -1 && bl->type != BL_PC){	// 僽儗僢僔儞僌
			int race=battle_get_race(bl);
			if(battle_check_undead(race,battle_get_elem_type(bl)) || race==6 )	str >>= 1;	// 埆 杺/晄巰
			else str += sc_data[SC_BLESSING].val1;	// 偦偺懠
		}
	}
	if(str < 0) str = 0;
	return str;
}
int battle_get_agi(struct block_list *bl)
{
	int agi=0;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_MOB)
		agi=mob_db[((struct mob_data *)bl)->class].agi;
	else if(bl->type==BL_PC)
		agi=((struct map_session_data *)bl)->paramc[1];
	else if(bl->type==BL_PET)
		agi=mob_db[((struct pet_data *)bl)->class].agi;

	if(sc_data) {
		if( sc_data[SC_INCREASEAGI].timer!=-1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1 &&
			bl->type != BL_PC)	// 懍搙憹壛(PC偼pc.c偱)
			agi += 2+sc_data[SC_INCREASEAGI].val1;

		if(sc_data[SC_CONCENTRATE].timer!=-1 && sc_data[SC_QUAGMIRE].timer == -1 && bl->type != BL_PC)
			agi += agi*(2+sc_data[SC_CONCENTRATE].val1)/100;

		if(sc_data[SC_DECREASEAGI].timer!=-1)	// 懍搙尭彮
			agi -= 2+sc_data[SC_DECREASEAGI].val1;

		if(sc_data[SC_QUAGMIRE].timer!=-1 )	// 僋傽僌儅僀傾
			agi >>= 1;
	}
	if(agi < 0) agi = 0;
	return agi;
}
int battle_get_vit(struct block_list *bl)
{
	int vit=0;
	struct status_change *sc_data=battle_get_sc_data(bl);
	if(bl->type==BL_MOB)
		vit=mob_db[((struct mob_data *)bl)->class].vit;
	else if(bl->type==BL_PC)
		vit=((struct map_session_data *)bl)->paramc[2];
	else if(bl->type==BL_PET)
		vit=mob_db[((struct pet_data *)bl)->class].vit;
	if(bl->type!=BL_PC && sc_data && sc_data[SC_STRIPARMOR].timer != -1)
		vit = vit*60/100;
	if(vit < 0) vit = 0;
	return vit;
}
int battle_get_int(struct block_list *bl)
{
	int int_=0;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_MOB)
		int_=mob_db[((struct mob_data *)bl)->class].int_;
	else if(bl->type==BL_PC)
		int_=((struct map_session_data *)bl)->paramc[3];
	else if(bl->type==BL_PET)
		int_=mob_db[((struct pet_data *)bl)->class].int_;

	if(sc_data) {
		if( sc_data[SC_BLESSING].timer != -1 && bl->type != BL_PC){	// 僽儗僢僔儞僌
			int race=battle_get_race(bl);
			if(battle_check_undead(race,battle_get_elem_type(bl)) || race==6 )	int_ >>= 1;	// 埆 杺/晄巰
			else int_ += sc_data[SC_BLESSING].val1;	// 偦偺懠
		}
		if( sc_data[SC_STRIPHELM].timer != -1 && bl->type != BL_PC)
			int_ = int_*90/100;

	}
	if(int_ < 0) int_ = 0;
	return int_;
}
int battle_get_dex(struct block_list *bl)
{
	int dex=0;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_MOB)
		dex=mob_db[((struct mob_data *)bl)->class].dex;
	else if(bl->type==BL_PC)
		dex=((struct map_session_data *)bl)->paramc[4];
	else if(bl->type==BL_PET)
		dex=mob_db[((struct pet_data *)bl)->class].dex;

	if(sc_data) {
		if(sc_data[SC_CONCENTRATE].timer!=-1 && sc_data[SC_QUAGMIRE].timer == -1 && bl->type != BL_PC)
			dex += dex*(2+sc_data[SC_CONCENTRATE].val1)/100;

		if( sc_data[SC_BLESSING].timer != -1 && bl->type != BL_PC){	// 僽儗僢僔儞僌
			int race=battle_get_race(bl);
			if(battle_check_undead(race,battle_get_elem_type(bl)) || race==6 )	dex >>= 1;	// 埆 杺/晄巰
			else dex += sc_data[SC_BLESSING].val1;	// 偦偺懠
		}

		if(sc_data[SC_QUAGMIRE].timer!=-1 )	// 僋傽僌儅僀傾
			dex >>= 1;
	}
	if(dex < 0) dex = 0;
	return dex;
}
int battle_get_luk(struct block_list *bl)
{
	int luk=0;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_MOB)
		luk=mob_db[((struct mob_data *)bl)->class].luk;
	else if(bl->type==BL_PC)
		luk=((struct map_session_data *)bl)->paramc[5];
	else if(bl->type==BL_PET)
		luk=mob_db[((struct pet_data *)bl)->class].luk;

	if(sc_data) {
		if(sc_data[SC_GLORIA].timer!=-1 && bl->type != BL_PC)	// 僌儘儕傾(PC偼pc.c偱)
			luk += 30;
		if(sc_data[SC_CURSE].timer!=-1 )		// 庺偄
			luk=0;
	}
	if(luk < 0) luk = 0;
	return luk;
}

int battle_get_flee(struct block_list *bl)
{
	int flee=1;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_PC)
		flee=((struct map_session_data *)bl)->flee;
	else
		flee=battle_get_agi(bl) + battle_get_lv(bl);

	if(sc_data) {
		if(sc_data[SC_WHISTLE].timer!=-1 && bl->type != BL_PC)
			flee += flee*(sc_data[SC_WHISTLE].val1+sc_data[SC_WHISTLE].val2
					+(sc_data[SC_WHISTLE].val3>>16))/100;
		if(sc_data[SC_BLIND].timer!=-1 && bl->type != BL_PC)
			flee -= flee*25/100;
	}
	if(flee < 1) flee = 1;
	return flee;
}
int battle_get_hit(struct block_list *bl)
{
	int hit=1;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_PC)
		hit=((struct map_session_data *)bl)->hit;
	else
		hit=battle_get_dex(bl) + battle_get_lv(bl);

	if(sc_data) {
		if(sc_data[SC_HUMMING].timer!=-1 && bl->type != BL_PC)	// 
			hit += hit*(sc_data[SC_HUMMING].val1*2+sc_data[SC_HUMMING].val2
					+sc_data[SC_HUMMING].val3)/100;
		if(sc_data[SC_BLIND].timer!=-1 && bl->type != BL_PC)		// 庺偄
			hit -= hit*25/100;
	}
	if(hit < 1) hit = 1;
	return hit;
}
int battle_get_flee2(struct block_list *bl)
{
	int flee2=1;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_PC) {
		flee2 = battle_get_luk(bl) + 10;
		flee2 += ((struct map_session_data *)bl)->flee2 - (((struct map_session_data *)bl)->paramc[5] + 10);
	}
	else
		flee2=battle_get_luk(bl)+1;

	if(sc_data) {
		if(sc_data[SC_WHISTLE].timer!=-1 && bl->type != BL_PC)
			flee2 += (sc_data[SC_WHISTLE].val1+sc_data[SC_WHISTLE].val2
					+(sc_data[SC_WHISTLE].val3&0xffff))*10;
	}
	if(flee2 < 1) flee2 = 1;
	return flee2;
}
int battle_get_critical(struct block_list *bl)
{
	int critical=1;
	struct status_change *sc_data=battle_get_sc_data(bl);

	if(bl->type==BL_PC) {
		critical = battle_get_luk(bl)*3 + 10;
		critical += ((struct map_session_data *)bl)->critical - ((((struct map_session_data *)bl)->paramc[5]*3) + 10);
	}
	else
		critical=battle_get_luk(bl)*3 + 1;

	if(sc_data) {
		if(sc_data[SC_FORTUNE].timer!=-1 && bl->type != BL_PC)
			critical += (10+sc_data[SC_FORTUNE].val1+sc_data[SC_FORTUNE].val2
					+sc_data[SC_FORTUNE].val3)*10;
		if(sc_data[SC_EXPLOSIONSPIRITS].timer!=-1 && bl->type != BL_PC)
			critical += sc_data[SC_EXPLOSIONSPIRITS].val2;
	}
	if(critical < 1) critical = 1;
	return critical;
}

int battle_get_baseatk(struct block_list *bl)
{
	struct status_change *sc_data=battle_get_sc_data(bl);
	int batk=1;
	if(bl->type == BL_PC)
		batk = ((struct map_session_data *)bl)->base_atk;
	else {
		int str,dstr;
		str = battle_get_str(bl);
		dstr = str/10;
		batk = dstr*dstr + str;
	}
	if(sc_data) {
		if(sc_data[SC_PROVOKE].timer!=-1 && bl->type != BL_PC)
			batk = batk*(100+2*sc_data[SC_PROVOKE].val1)/100;
		if(sc_data[SC_CURSE].timer!=-1 )
			batk -= batk*25/100;
	}
	if(batk < 1) batk = 1;
	return batk;
}

int battle_get_atk(struct block_list *bl)
{
	struct status_change *sc_data=battle_get_sc_data(bl);
	int atk=0;
	if(bl->type==BL_PC)
		atk = ((struct map_session_data*)bl)->watk;
	else if(bl->type==BL_MOB)
		atk = mob_db[((struct mob_data*)bl)->class].atk1;
	else if(bl->type==BL_PET)
		atk = mob_db[((struct pet_data*)bl)->class].atk1;

	if(sc_data) {
		if(sc_data[SC_PROVOKE].timer!=-1 && bl->type != BL_PC)
			atk = atk*(100+2*sc_data[SC_PROVOKE].val1)/100;
		if(sc_data[SC_CURSE].timer!=-1 )
			atk -= atk*25/100;
	}
	if(atk < 0) atk = 0;
	return atk;
}
int battle_get_atk_(struct block_list *bl)
{
	if(bl->type==BL_PC){
		int atk=((struct map_session_data*)bl)->watk_;

		if(((struct map_session_data *)bl)->sc_data[SC_CURSE].timer!=-1 )
			atk -= atk*25/100;
		return atk;
	}
	else
		return 0;