Context Navigation

status.c @ 13

Revision 13, 249.3 kB (checked in by jinshiro, 17 years ago)

Rev	Line
[1]	1	// Copyright (c) Athena Dev Teams - Licensed under GNU GPL
	2	// For more information, see LICENCE in the main folder
	3
	4	#include "../common/cbasetypes.h"
	5	#include "../common/timer.h"
	6	#include "../common/nullpo.h"
	7	#include "../common/showmsg.h"
	8	#include "../common/malloc.h"
	9	#include "../common/utils.h"
	10	#include "../common/ers.h"
	11
	12	#include "map.h"
	13	#include "path.h"
	14	#include "pc.h"
	15	#include "pet.h"
	16	#include "npc.h"
	17	#include "mob.h"
	18	#include "clif.h"
	19	#include "guild.h"
	20	#include "skill.h"
	21	#include "itemdb.h"
	22	#include "battle.h"
	23	#include "chrif.h"
	24	#include "skill.h"
	25	#include "status.h"
	26	#include "script.h"
	27	#include "unit.h"
	28	#include "mercenary.h"
	29	#include "vending.h"
	30
	31	#include <time.h>
	32	#include <stdio.h>
	33	#include <stdlib.h>
	34	#include <memory.h>
	35	#include <string.h>
	36
	37
	38	//Regen related flags.
	39	#define RGN_HP 0x01
	40	#define RGN_SP 0x02
	41	#define RGN_SHP 0x04
	42	#define RGN_SSP 0x08
	43
	44	static int max_weight_base[CLASS_COUNT];
	45	static int hp_coefficient[CLASS_COUNT];
	46	static int hp_coefficient2[CLASS_COUNT];
	47	static int hp_sigma_val[CLASS_COUNT][MAX_LEVEL+1];
	48	static int sp_coefficient[CLASS_COUNT];
	49	static int aspd_base[CLASS_COUNT][MAX_WEAPON_TYPE]; //[blackhole89]
	50	static int refinebonus[MAX_REFINE_BONUS][3]; // žB{[iXe[u(refine_db.txt)
	51	int percentrefinery[5][MAX_REFINE+1]; // žB¬÷Š(refine_db.txt)
	52	static int atkmods[3][MAX_WEAPON_TYPE]; // íATKTCYC³(size_fix.txt)
	53	static char job_bonus[CLASS_COUNT][MAX_LEVEL];
	54
	55	static struct eri *sc_data_ers; //For sc_data entries
	56	static struct status_data dummy_status;
	57
	58	int current_equip_item_index; //Contains inventory index of an equipped item. To pass it into the EQUP_SCRIPT [Lupus]
	59	int current_equip_card_id; //To prevent card-stacking (from jA) [Skotlex]
	60	//we need it for new cards 15 Feb 2005, to check if the combo cards are insrerted into the CURRENT weapon only
	61	//to avoid cards exploits
	62
	63	static sc_type SkillStatusChangeTable[MAX_SKILL]; // skill -> status
	64	static int StatusIconChangeTable[SC_MAX]; // status -> icon
	65	unsigned long StatusChangeFlagTable[SC_MAX]; // status -> flags
	66	static int StatusSkillChangeTable[SC_MAX]; // status -> skill
	67
	68	sc_type status_skill2sc(int skill)
	69	{
	70	int sk = skill_get_index(skill);
	71	if( sk == 0 ) {
	72	ShowError("status_skill2sc: Unsupported skill id %d\n", skill);
	73	return SC_NONE;
	74	}
	75	return SkillStatusChangeTable[sk];
	76	}
	77
	78	int status_sc2skill(sc_type sc)
	79	{
	80	if( sc < 0 \|\| sc >= SC_MAX ) {
	81	ShowError("status_skill2sc: Unsupported status change id %d\n", sc);
	82	return 0;
	83	}
	84
	85	return StatusSkillChangeTable[sc];
	86	}
	87
	88	#define add_sc(skill,sc) set_sc(skill,sc,SI_BLANK,SCB_NONE)
	89
	90	static void set_sc(int skill, sc_type sc, int icon, unsigned int flag)
	91	{
	92	int sk = skill_get_index(skill);
	93	if( sk == 0 ) {
	94	ShowError("set_sc: Unsupported skill id %d\n", skill);
	95	return;
	96	}
	97	if( sc < 0 \|\| sc >= SC_MAX ) {
	98	ShowError("set_sc: Unsupported status change id %d\n", sc);
	99	return;
	100	}
	101
	102	if( StatusSkillChangeTable[sc] == 0 )
	103	StatusSkillChangeTable[sc] = skill;
	104	if( StatusIconChangeTable[sc] == SI_BLANK )
	105	StatusIconChangeTable[sc] = icon;
	106	StatusChangeFlagTable[sc] \|= flag;
	107
	108	if( SkillStatusChangeTable[sk] == SC_NONE )
	109	SkillStatusChangeTable[sk] = sc;
	110	}
	111
	112	void initChangeTables(void)
	113	{
	114	int i;
	115	for (i = 0; i < SC_MAX; i++)
	116	StatusIconChangeTable[i] = SI_BLANK;
	117	for (i = 0; i < MAX_SKILL; i++)
	118	SkillStatusChangeTable[i] = SC_NONE;
	119
	120	memset(StatusSkillChangeTable, 0, sizeof(StatusSkillChangeTable));
	121	memset(StatusChangeFlagTable, 0, sizeof(StatusChangeFlagTable));
	122
	123	//First we define the skill for common ailments. These are used in skill_additional_effect through sc cards. [Skotlex]
	124	set_sc( MG_STONECURSE , SC_STONE , SI_BLANK , SCB_DEF_ELE\|SCB_DEF\|SCB_MDEF );
	125	set_sc( MG_FROSTDIVER , SC_FREEZE , SI_BLANK , SCB_DEF_ELE\|SCB_DEF\|SCB_MDEF );
	126	set_sc( NPC_STUNATTACK , SC_STUN , SI_BLANK , SCB_NONE );
	127	set_sc( NPC_SLEEPATTACK , SC_SLEEP , SI_BLANK , SCB_NONE );
	128	set_sc( NPC_POISON , SC_POISON , SI_BLANK , SCB_DEF2\|SCB_REGEN );
	129	set_sc( NPC_CURSEATTACK , SC_CURSE , SI_BLANK , SCB_LUK\|SCB_BATK\|SCB_WATK\|SCB_SPEED );
	130	set_sc( NPC_SILENCEATTACK , SC_SILENCE , SI_BLANK , SCB_NONE );
	131	set_sc( DC_WINKCHARM , SC_CONFUSION , SI_BLANK , SCB_NONE );
[10]	132	//Custom Jobs (blackmagic)
	133	set_sc( AD_PWFEAR , SC_FEAR , SI_HALLUCINATION , SCB_SPEED ); //Fear Status by [Brainstorm]
	134	//Custom Job End
[1]	135	set_sc( NPC_BLINDATTACK , SC_BLIND , SI_BLANK , SCB_HIT\|SCB_FLEE );
	136	set_sc( LK_HEADCRUSH , SC_BLEEDING , SI_BLEEDING , SCB_REGEN );
	137	set_sc( NPC_POISON , SC_DPOISON , SI_BLANK , SCB_DEF2\|SCB_REGEN );
	138
	139	//The main status definitions
	140	add_sc( SM_BASH , SC_STUN );
	141	set_sc( SM_PROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF\|SCB_DEF2\|SCB_BATK\|SCB_WATK );
	142	add_sc( SM_MAGNUM , SC_WATK_ELEMENT );
	143	set_sc( SM_ENDURE , SC_ENDURE , SI_ENDURE , SCB_MDEF\|SCB_DSPD );
	144	add_sc( MG_SIGHT , SC_SIGHT );
	145	add_sc( MG_SAFETYWALL , SC_SAFETYWALL );
	146	add_sc( MG_FROSTDIVER , SC_FREEZE );
	147	add_sc( MG_STONECURSE , SC_STONE );
	148	add_sc( AL_RUWACH , SC_RUWACH );
	149	add_sc( AL_PNEUMA , SC_PNEUMA );
	150	set_sc( AL_INCAGI , SC_INCREASEAGI , SI_INCREASEAGI , SCB_AGI\|SCB_SPEED );
	151	set_sc( AL_DECAGI , SC_DECREASEAGI , SI_DECREASEAGI , SCB_AGI\|SCB_SPEED );
	152	set_sc( AL_CRUCIS , SC_SIGNUMCRUCIS , SI_SIGNUMCRUCIS , SCB_DEF );
	153	set_sc( AL_ANGELUS , SC_ANGELUS , SI_ANGELUS , SCB_DEF2 );
	154	set_sc( AL_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR\|SCB_INT\|SCB_DEX );
	155	set_sc( AC_CONCENTRATION , SC_CONCENTRATE , SI_CONCENTRATE , SCB_AGI\|SCB_DEX );
	156	set_sc( TF_HIDING , SC_HIDING , SI_HIDING , SCB_SPEED );
	157	add_sc( TF_POISON , SC_POISON );
	158	set_sc( KN_TWOHANDQUICKEN , SC_TWOHANDQUICKEN , SI_TWOHANDQUICKEN , SCB_ASPD );
	159	add_sc( KN_AUTOCOUNTER , SC_AUTOCOUNTER );
	160	set_sc( PR_IMPOSITIO , SC_IMPOSITIO , SI_IMPOSITIO , SCB_WATK );
	161	set_sc( PR_SUFFRAGIUM , SC_SUFFRAGIUM , SI_SUFFRAGIUM , SCB_NONE );
	162	set_sc( PR_ASPERSIO , SC_ASPERSIO , SI_ASPERSIO , SCB_ATK_ELE );
	163	set_sc( PR_BENEDICTIO , SC_BENEDICTIO , SI_BENEDICTIO , SCB_DEF_ELE );
	164	set_sc( PR_SLOWPOISON , SC_SLOWPOISON , SI_SLOWPOISON , SCB_REGEN );
	165	set_sc( PR_KYRIE , SC_KYRIE , SI_KYRIE , SCB_NONE );
	166	set_sc( PR_MAGNIFICAT , SC_MAGNIFICAT , SI_MAGNIFICAT , SCB_REGEN );
	167	set_sc( PR_GLORIA , SC_GLORIA , SI_GLORIA , SCB_LUK );
	168	add_sc( PR_LEXDIVINA , SC_SILENCE );
	169	set_sc( PR_LEXAETERNA , SC_AETERNA , SI_AETERNA , SCB_NONE );
	170	add_sc( WZ_METEOR , SC_STUN );
	171	add_sc( WZ_VERMILION , SC_BLIND );
	172	add_sc( WZ_FROSTNOVA , SC_FREEZE );
	173	add_sc( WZ_STORMGUST , SC_FREEZE );
	174	set_sc( WZ_QUAGMIRE , SC_QUAGMIRE , SI_QUAGMIRE , SCB_AGI\|SCB_DEX\|SCB_ASPD\|SCB_SPEED );
	175	set_sc( BS_ADRENALINE , SC_ADRENALINE , SI_ADRENALINE , SCB_ASPD );
	176	set_sc( BS_WEAPONPERFECT , SC_WEAPONPERFECTION, SI_WEAPONPERFECTION, SCB_NONE );
	177	set_sc( BS_OVERTHRUST , SC_OVERTHRUST , SI_OVERTHRUST , SCB_NONE );
	178	set_sc( BS_MAXIMIZE , SC_MAXIMIZEPOWER , SI_MAXIMIZEPOWER , SCB_NONE );
	179	add_sc( HT_LANDMINE , SC_STUN );
	180	add_sc( HT_ANKLESNARE , SC_ANKLE );
	181	add_sc( HT_SANDMAN , SC_SLEEP );
	182	add_sc( HT_FLASHER , SC_BLIND );
	183	add_sc( HT_FREEZINGTRAP , SC_FREEZE );
	184	set_sc( AS_CLOAKING , SC_CLOAKING , SI_CLOAKING , SCB_CRI\|SCB_SPEED );
	185	add_sc( AS_SONICBLOW , SC_STUN );
	186	set_sc( AS_GRIMTOOTH , SC_SLOWDOWN , SI_BLANK , SCB_SPEED );
	187	set_sc( AS_ENCHANTPOISON , SC_ENCPOISON , SI_ENCPOISON , SCB_ATK_ELE );
	188	set_sc( AS_POISONREACT , SC_POISONREACT , SI_POISONREACT , SCB_NONE );
	189	add_sc( AS_VENOMDUST , SC_POISON );
	190	add_sc( AS_SPLASHER , SC_SPLASHER );
	191	set_sc( NV_TRICKDEAD , SC_TRICKDEAD , SI_TRICKDEAD , SCB_REGEN );
	192	set_sc( SM_AUTOBERSERK , SC_AUTOBERSERK , SI_AUTOBERSERK , SCB_NONE );
	193	add_sc( TF_SPRINKLESAND , SC_BLIND );
	194	add_sc( TF_THROWSTONE , SC_STUN );
	195	set_sc( MC_LOUD , SC_LOUD , SI_LOUD , SCB_STR );
	196	set_sc( MG_ENERGYCOAT , SC_ENERGYCOAT , SI_ENERGYCOAT , SCB_NONE );
	197	set_sc( NPC_EMOTION , SC_MODECHANGE , SI_BLANK , SCB_MODE );
	198	add_sc( NPC_EMOTION_ON , SC_MODECHANGE );
	199	set_sc( NPC_ATTRICHANGE , SC_ELEMENTALCHANGE , SI_BLANK , SCB_DEF_ELE );
	200	add_sc( NPC_CHANGEWATER , SC_ELEMENTALCHANGE );
	201	add_sc( NPC_CHANGEGROUND , SC_ELEMENTALCHANGE );
	202	add_sc( NPC_CHANGEFIRE , SC_ELEMENTALCHANGE );
	203	add_sc( NPC_CHANGEWIND , SC_ELEMENTALCHANGE );
	204	add_sc( NPC_CHANGEPOISON , SC_ELEMENTALCHANGE );
	205	add_sc( NPC_CHANGEHOLY , SC_ELEMENTALCHANGE );
	206	add_sc( NPC_CHANGEDARKNESS , SC_ELEMENTALCHANGE );
	207	add_sc( NPC_CHANGETELEKINESIS, SC_ELEMENTALCHANGE );
	208	add_sc( NPC_POISON , SC_POISON );
	209	add_sc( NPC_BLINDATTACK , SC_BLIND );
	210	add_sc( NPC_SILENCEATTACK , SC_SILENCE );
	211	add_sc( NPC_STUNATTACK , SC_STUN );
	212	add_sc( NPC_PETRIFYATTACK , SC_STONE );
	213	add_sc( NPC_CURSEATTACK , SC_CURSE );
	214	add_sc( NPC_SLEEPATTACK , SC_SLEEP );
	215	add_sc( NPC_MAGICALATTACK , SC_MAGICALATTACK );
	216	set_sc( NPC_KEEPING , SC_KEEPING , SI_BLANK , SCB_DEF );
	217	add_sc( NPC_DARKBLESSING , SC_COMA );
	218	set_sc( NPC_BARRIER , SC_BARRIER , SI_BLANK , SCB_MDEF\|SCB_DEF );
	219	add_sc( NPC_DEFENDER , SC_ARMOR );
	220	add_sc( NPC_LICK , SC_STUN );
	221	set_sc( NPC_HALLUCINATION , SC_HALLUCINATION , SI_HALLUCINATION , SCB_NONE );
	222	add_sc( NPC_REBIRTH , SC_KAIZEL );
	223	add_sc( RG_RAID , SC_STUN );
	224	set_sc( RG_STRIPWEAPON , SC_STRIPWEAPON , SI_STRIPWEAPON , SCB_WATK );
	225	set_sc( RG_STRIPSHIELD , SC_STRIPSHIELD , SI_STRIPSHIELD , SCB_DEF );
	226	set_sc( RG_STRIPARMOR , SC_STRIPARMOR , SI_STRIPARMOR , SCB_VIT );
	227	set_sc( RG_STRIPHELM , SC_STRIPHELM , SI_STRIPHELM , SCB_INT );
	228	add_sc( AM_ACIDTERROR , SC_BLEEDING );
	229	set_sc( AM_CP_WEAPON , SC_CP_WEAPON , SI_CP_WEAPON , SCB_NONE );
	230	set_sc( AM_CP_SHIELD , SC_CP_SHIELD , SI_CP_SHIELD , SCB_NONE );
	231	set_sc( AM_CP_ARMOR , SC_CP_ARMOR , SI_CP_ARMOR , SCB_NONE );
	232	set_sc( AM_CP_HELM , SC_CP_HELM , SI_CP_HELM , SCB_NONE );
	233	set_sc( CR_AUTOGUARD , SC_AUTOGUARD , SI_AUTOGUARD , SCB_NONE );
	234	add_sc( CR_SHIELDCHARGE , SC_STUN );
	235	set_sc( CR_REFLECTSHIELD , SC_REFLECTSHIELD , SI_REFLECTSHIELD , SCB_NONE );
	236	add_sc( CR_HOLYCROSS , SC_BLIND );
	237	add_sc( CR_GRANDCROSS , SC_BLIND );
	238	add_sc( CR_DEVOTION , SC_DEVOTION );
	239	set_sc( CR_PROVIDENCE , SC_PROVIDENCE , SI_PROVIDENCE , SCB_PC );
	240	set_sc( CR_DEFENDER , SC_DEFENDER , SI_DEFENDER , SCB_SPEED\|SCB_ASPD );
	241	set_sc( CR_SPEARQUICKEN , SC_SPEARQUICKEN , SI_SPEARQUICKEN , SCB_ASPD );
	242	set_sc( MO_STEELBODY , SC_STEELBODY , SI_STEELBODY , SCB_DEF\|SCB_MDEF\|SCB_ASPD\|SCB_SPEED );
	243	add_sc( MO_BLADESTOP , SC_BLADESTOP_WAIT );
	244	add_sc( MO_BLADESTOP , SC_BLADESTOP );
	245	set_sc( MO_EXPLOSIONSPIRITS , SC_EXPLOSIONSPIRITS, SI_EXPLOSIONSPIRITS, SCB_CRI\|SCB_REGEN );
	246	set_sc( MO_EXTREMITYFIST , SC_EXTREMITYFIST , SI_BLANK , SCB_REGEN );
	247	add_sc( SA_MAGICROD , SC_MAGICROD );
	248	set_sc( SA_AUTOSPELL , SC_AUTOSPELL , SI_AUTOSPELL , SCB_NONE );
	249	set_sc( SA_FLAMELAUNCHER , SC_FIREWEAPON , SI_FIREWEAPON , SCB_ATK_ELE );
	250	set_sc( SA_FROSTWEAPON , SC_WATERWEAPON , SI_WATERWEAPON , SCB_ATK_ELE );
	251	set_sc( SA_LIGHTNINGLOADER , SC_WINDWEAPON , SI_WINDWEAPON , SCB_ATK_ELE );
	252	set_sc( SA_SEISMICWEAPON , SC_EARTHWEAPON , SI_EARTHWEAPON , SCB_ATK_ELE );
	253	set_sc( SA_VOLCANO , SC_VOLCANO , SI_LANDENDOW , SCB_WATK );
	254	set_sc( SA_DELUGE , SC_DELUGE , SI_LANDENDOW , SCB_MAXHP );
	255	set_sc( SA_VIOLENTGALE , SC_VIOLENTGALE , SI_LANDENDOW , SCB_FLEE );
	256	add_sc( SA_REVERSEORCISH , SC_ORCISH );
	257	add_sc( SA_COMA , SC_COMA );
	258	set_sc( BD_ENCORE , SC_DANCING , SI_BLANK , SCB_SPEED\|SCB_REGEN );
	259	add_sc( BD_RICHMANKIM , SC_RICHMANKIM );
	260	set_sc( BD_ETERNALCHAOS , SC_ETERNALCHAOS , SI_BLANK , SCB_DEF2 );
	261	set_sc( BD_DRUMBATTLEFIELD , SC_DRUMBATTLE , SI_BLANK , SCB_WATK\|SCB_DEF );
	262	set_sc( BD_RINGNIBELUNGEN , SC_NIBELUNGEN , SI_BLANK , SCB_WATK );
	263	add_sc( BD_ROKISWEIL , SC_ROKISWEIL );
	264	add_sc( BD_INTOABYSS , SC_INTOABYSS );
	265	set_sc( BD_SIEGFRIED , SC_SIEGFRIED , SI_BLANK , SCB_PC );
	266	add_sc( BA_FROSTJOKER , SC_FREEZE );
	267	set_sc( BA_WHISTLE , SC_WHISTLE , SI_BLANK , SCB_FLEE\|SCB_FLEE2 );
	268	set_sc( BA_ASSASSINCROSS , SC_ASSNCROS , SI_BLANK , SCB_ASPD );
	269	add_sc( BA_POEMBRAGI , SC_POEMBRAGI );
	270	set_sc( BA_APPLEIDUN , SC_APPLEIDUN , SI_BLANK , SCB_MAXHP );
	271	add_sc( DC_SCREAM , SC_STUN );
	272	set_sc( DC_HUMMING , SC_HUMMING , SI_BLANK , SCB_HIT );
	273	set_sc( DC_DONTFORGETME , SC_DONTFORGETME , SI_BLANK , SCB_SPEED\|SCB_ASPD );
	274	set_sc( DC_FORTUNEKISS , SC_FORTUNE , SI_BLANK , SCB_CRI );
	275	set_sc( DC_SERVICEFORYOU , SC_SERVICE4U , SI_BLANK , SCB_MAXSP\|SCB_PC );
	276	add_sc( NPC_DARKCROSS , SC_BLIND );
	277	add_sc( NPC_GRANDDARKNESS , SC_BLIND );
	278	set_sc( NPC_STOP , SC_STOP , SI_STOP , SCB_NONE );
	279	set_sc( NPC_WEAPONBRAKER , SC_BROKENWEAPON , SI_BROKENWEAPON , SCB_NONE );
	280	set_sc( NPC_ARMORBRAKE , SC_BROKENARMOR , SI_BROKENARMOR , SCB_NONE );
	281	set_sc( NPC_CHANGEUNDEAD , SC_CHANGEUNDEAD , SI_UNDEAD , SCB_DEF_ELE );
	282	set_sc( NPC_POWERUP , SC_INCHITRATE , SI_BLANK , SCB_HIT );
	283	set_sc( NPC_AGIUP , SC_INCFLEERATE , SI_BLANK , SCB_FLEE );
	284	add_sc( NPC_INVISIBLE , SC_CLOAKING );
	285	set_sc( LK_AURABLADE , SC_AURABLADE , SI_AURABLADE , SCB_NONE );
	286	set_sc( LK_PARRYING , SC_PARRYING , SI_PARRYING , SCB_NONE );
	287	set_sc( LK_CONCENTRATION , SC_CONCENTRATION , SI_CONCENTRATION , SCB_BATK\|SCB_WATK\|SCB_HIT\|SCB_DEF\|SCB_DEF2\|SCB_MDEF\|SCB_DSPD );
	288	set_sc( LK_TENSIONRELAX , SC_TENSIONRELAX , SI_TENSIONRELAX , SCB_REGEN );
	289	set_sc( LK_BERSERK , SC_BERSERK , SI_BERSERK , SCB_DEF\|SCB_DEF2\|SCB_MDEF\|SCB_MDEF2\|SCB_FLEE\|SCB_SPEED\|SCB_ASPD\|SCB_MAXHP\|SCB_REGEN );
	290	set_sc( HP_ASSUMPTIO , SC_ASSUMPTIO , SI_ASSUMPTIO , SCB_NONE );
	291	add_sc( HP_BASILICA , SC_BASILICA );
	292	set_sc( HW_MAGICPOWER , SC_MAGICPOWER , SI_MAGICPOWER , SCB_MATK );
	293	add_sc( PA_SACRIFICE , SC_SACRIFICE );
	294	set_sc( PA_GOSPEL , SC_GOSPEL , SI_BLANK , SCB_SPEED\|SCB_ASPD );
	295	add_sc( PA_GOSPEL , SC_SCRESIST );
	296	add_sc( CH_TIGERFIST , SC_STOP );
	297	set_sc( ASC_EDP , SC_EDP , SI_EDP , SCB_NONE );
	298	set_sc( SN_SIGHT , SC_TRUESIGHT , SI_TRUESIGHT , SCB_STR\|SCB_AGI\|SCB_VIT\|SCB_INT\|SCB_DEX\|SCB_LUK\|SCB_CRI\|SCB_HIT );
	299	set_sc( SN_WINDWALK , SC_WINDWALK , SI_WINDWALK , SCB_FLEE\|SCB_SPEED );
	300	set_sc( WS_MELTDOWN , SC_MELTDOWN , SI_MELTDOWN , SCB_NONE );
	301	set_sc( WS_CARTBOOST , SC_CARTBOOST , SI_CARTBOOST , SCB_SPEED );
	302	set_sc( ST_CHASEWALK , SC_CHASEWALK , SI_BLANK , SCB_SPEED );
	303	set_sc( ST_REJECTSWORD , SC_REJECTSWORD , SI_REJECTSWORD , SCB_NONE );
	304	add_sc( ST_REJECTSWORD , SC_AUTOCOUNTER );
	305	set_sc( CG_MARIONETTE , SC_MARIONETTE , SI_MARIONETTE , SCB_STR\|SCB_AGI\|SCB_VIT\|SCB_INT\|SCB_DEX\|SCB_LUK );
	306	set_sc( CG_MARIONETTE , SC_MARIONETTE2 , SI_MARIONETTE2 , SCB_STR\|SCB_AGI\|SCB_VIT\|SCB_INT\|SCB_DEX\|SCB_LUK );
	307	add_sc( LK_SPIRALPIERCE , SC_STOP );
	308	add_sc( LK_HEADCRUSH , SC_BLEEDING );
	309	set_sc( LK_JOINTBEAT , SC_JOINTBEAT , SI_JOINTBEAT , SCB_BATK\|SCB_DEF2\|SCB_SPEED\|SCB_ASPD );
	310	add_sc( HW_NAPALMVULCAN , SC_CURSE );
	311	set_sc( PF_MINDBREAKER , SC_MINDBREAKER , SI_BLANK , SCB_MATK\|SCB_MDEF2 );
	312	add_sc( PF_MEMORIZE , SC_MEMORIZE );
	313	add_sc( PF_FOGWALL , SC_FOGWALL );
	314	set_sc( PF_SPIDERWEB , SC_SPIDERWEB , SI_BLANK , SCB_FLEE );
	315	set_sc( WE_BABY , SC_BABY , SI_BABY , SCB_NONE );
	316	set_sc( TK_RUN , SC_RUN , SI_RUN , SCB_SPEED\|SCB_DSPD );
	317	set_sc( TK_RUN , SC_SPURT , SI_SPURT , SCB_STR );
	318	set_sc( TK_READYSTORM , SC_READYSTORM , SI_READYSTORM , SCB_NONE );
	319	set_sc( TK_READYDOWN , SC_READYDOWN , SI_READYDOWN , SCB_NONE );
	320	add_sc( TK_DOWNKICK , SC_STUN );
	321	set_sc( TK_READYTURN , SC_READYTURN , SI_READYTURN , SCB_NONE );
	322	set_sc( TK_READYCOUNTER , SC_READYCOUNTER , SI_READYCOUNTER , SCB_NONE );
	323	set_sc( TK_DODGE , SC_DODGE , SI_DODGE , SCB_NONE );
	324	set_sc( TK_SPTIME , SC_TKREST , SI_TKREST , SCB_NONE );
	325	add_sc( TK_SEVENWIND , SC_SEVENWIND );
	326	set_sc( TK_SEVENWIND , SC_GHOSTWEAPON , SI_GHOSTWEAPON , SCB_ATK_ELE );
	327	set_sc( TK_SEVENWIND , SC_SHADOWWEAPON , SI_SHADOWWEAPON , SCB_ATK_ELE );
	328	set_sc( SG_SUN_WARM , SC_WARM , SI_WARM , SCB_NONE );
	329	add_sc( SG_MOON_WARM , SC_WARM );
	330	add_sc( SG_STAR_WARM , SC_WARM );
	331	set_sc( SG_SUN_COMFORT , SC_SUN_COMFORT , SI_SUN_COMFORT , SCB_DEF2 );
	332	set_sc( SG_MOON_COMFORT , SC_MOON_COMFORT , SI_MOON_COMFORT , SCB_FLEE );
	333	set_sc( SG_STAR_COMFORT , SC_STAR_COMFORT , SI_STAR_COMFORT , SCB_ASPD );
	334	add_sc( SG_FRIEND , SC_SKILLRATE_UP );
	335	set_sc( SG_KNOWLEDGE , SC_KNOWLEDGE , SI_BLANK , SCB_PC );
	336	set_sc( SG_FUSION , SC_FUSION , SI_BLANK , SCB_SPEED );
	337	set_sc( BS_ADRENALINE2 , SC_ADRENALINE2 , SI_ADRENALINE2 , SCB_ASPD );
	338	set_sc( SL_KAIZEL , SC_KAIZEL , SI_KAIZEL , SCB_NONE );
	339	set_sc( SL_KAAHI , SC_KAAHI , SI_KAAHI , SCB_NONE );
	340	set_sc( SL_KAUPE , SC_KAUPE , SI_KAUPE , SCB_NONE );
	341	set_sc( SL_KAITE , SC_KAITE , SI_KAITE , SCB_NONE );
	342	add_sc( SL_STUN , SC_STUN );
	343	set_sc( SL_SWOO , SC_SWOO , SI_BLANK , SCB_SPEED );
	344	set_sc( SL_SKE , SC_SKE , SI_BLANK , SCB_BATK\|SCB_WATK\|SCB_DEF\|SCB_DEF2 );
	345	set_sc( SL_SKA , SC_SKA , SI_BLANK , SCB_DEF\|SCB_MDEF\|SCB_ASPD );
	346	set_sc( SL_SMA , SC_SMA , SI_SMA , SCB_NONE );
	347	set_sc( ST_PRESERVE , SC_PRESERVE , SI_PRESERVE , SCB_NONE );
	348	set_sc( PF_DOUBLECASTING , SC_DOUBLECAST , SI_DOUBLECAST , SCB_NONE );
	349	set_sc( HW_GRAVITATION , SC_GRAVITATION , SI_BLANK , SCB_ASPD );
	350	add_sc( WS_CARTTERMINATION , SC_STUN );
	351	set_sc( WS_OVERTHRUSTMAX , SC_MAXOVERTHRUST , SI_MAXOVERTHRUST , SCB_NONE );
	352	set_sc( CG_LONGINGFREEDOM , SC_LONGING , SI_BLANK , SCB_SPEED\|SCB_ASPD );
	353	add_sc( CG_HERMODE , SC_HERMODE );
	354	set_sc( ITEM_ENCHANTARMS , SC_ENCHANTARMS , SI_BLANK , SCB_ATK_ELE );
	355	set_sc( SL_HIGH , SC_SPIRIT , SI_SPIRIT , SCB_PC );
	356	set_sc( KN_ONEHAND , SC_ONEHAND , SI_ONEHAND , SCB_ASPD );
	357	set_sc( GS_FLING , SC_FLING , SI_BLANK , SCB_DEF\|SCB_DEF2 );
	358	add_sc( GS_CRACKER , SC_STUN );
	359	add_sc( GS_DISARM , SC_STRIPWEAPON );
	360	add_sc( GS_PIERCINGSHOT , SC_BLEEDING );
	361	set_sc( GS_MADNESSCANCEL , SC_MADNESSCANCEL , SI_MADNESSCANCEL , SCB_BATK\|SCB_ASPD );
	362	set_sc( GS_ADJUSTMENT , SC_ADJUSTMENT , SI_ADJUSTMENT , SCB_HIT\|SCB_FLEE );
	363	set_sc( GS_INCREASING , SC_INCREASING , SI_ACCURACY , SCB_AGI\|SCB_DEX\|SCB_HIT );
	364	set_sc( GS_GATLINGFEVER , SC_GATLINGFEVER , SI_GATLINGFEVER , SCB_BATK\|SCB_FLEE\|SCB_SPEED\|SCB_ASPD );
	365	set_sc( NJ_TATAMIGAESHI , SC_TATAMIGAESHI , SI_BLANK , SCB_NONE );
	366	set_sc( NJ_SUITON , SC_SUITON , SI_BLANK , SCB_AGI\|SCB_SPEED );
	367	add_sc( NJ_HYOUSYOURAKU , SC_FREEZE );
	368	set_sc( NJ_NEN , SC_NEN , SI_NEN , SCB_STR\|SCB_INT );
	369	set_sc( NJ_UTSUSEMI , SC_UTSUSEMI , SI_UTSUSEMI , SCB_NONE );
	370	set_sc( NJ_BUNSINJYUTSU , SC_BUNSINJYUTSU , SI_BUNSINJYUTSU , SCB_DYE );
	371
	372	add_sc( NPC_ICEBREATH , SC_FREEZE );
	373	add_sc( NPC_ACIDBREATH , SC_POISON );
	374	add_sc( NPC_HELLJUDGEMENT , SC_CURSE );
	375	add_sc( NPC_WIDESILENCE , SC_SILENCE );
	376	add_sc( NPC_WIDEFREEZE , SC_FREEZE );
	377	add_sc( NPC_WIDEBLEEDING , SC_BLEEDING );
	378	add_sc( NPC_WIDESTONE , SC_STONE );
	379	add_sc( NPC_WIDECONFUSE , SC_CONFUSION );
	380	add_sc( NPC_WIDESLEEP , SC_SLEEP );
	381	add_sc( NPC_WIDESIGHT , SC_SIGHT );
	382	add_sc( NPC_EVILLAND , SC_BLIND );
	383	add_sc( NPC_MAGICMIRROR , SC_MAGICMIRROR );
	384	set_sc( NPC_SLOWCAST , SC_SLOWCAST , SI_SLOWCAST , SCB_NONE );
	385	set_sc( NPC_CRITICALWOUND , SC_CRITICALWOUND , SI_CRITICALWOUND , SCB_NONE );
	386	set_sc( NPC_STONESKIN , SC_ARMORCHANGE , SI_BLANK , SCB_DEF\|SCB_MDEF );
	387	add_sc( NPC_ANTIMAGIC , SC_ARMORCHANGE );
	388	add_sc( NPC_WIDECURSE , SC_CURSE );
	389	add_sc( NPC_WIDESTUN , SC_STUN );
	390
	391	set_sc( CR_SHRINK , SC_SHRINK , SI_SHRINK , SCB_NONE );
	392	set_sc( RG_CLOSECONFINE , SC_CLOSECONFINE2 , SI_CLOSECONFINE2 , SCB_NONE );
	393	set_sc( RG_CLOSECONFINE , SC_CLOSECONFINE , SI_CLOSECONFINE , SCB_FLEE );
	394	set_sc( WZ_SIGHTBLASTER , SC_SIGHTBLASTER , SI_SIGHTBLASTER , SCB_NONE );
	395	set_sc( DC_WINKCHARM , SC_WINKCHARM , SI_WINKCHARM , SCB_NONE );
	396	add_sc( MO_BALKYOUNG , SC_STUN );
	397	add_sc( SA_ELEMENTWATER , SC_ELEMENTALCHANGE );
	398	add_sc( SA_ELEMENTFIRE , SC_ELEMENTALCHANGE );
	399	add_sc( SA_ELEMENTGROUND , SC_ELEMENTALCHANGE );
	400	add_sc( SA_ELEMENTWIND , SC_ELEMENTALCHANGE );
	401
	402	set_sc( HLIF_AVOID , SC_AVOID , SI_BLANK , SCB_SPEED );
	403	set_sc( HLIF_CHANGE , SC_CHANGE , SI_BLANK , SCB_VIT\|SCB_INT );
	404	set_sc( HFLI_FLEET , SC_FLEET , SI_BLANK , SCB_ASPD\|SCB_BATK\|SCB_WATK );
	405	set_sc( HFLI_SPEED , SC_SPEED , SI_BLANK , SCB_FLEE );
	406	set_sc( HAMI_DEFENCE , SC_DEFENCE , SI_BLANK , SCB_DEF );
	407	set_sc( HAMI_BLOODLUST , SC_BLOODLUST , SI_BLANK , SCB_BATK\|SCB_WATK );
	408
	409	set_sc( GD_LEADERSHIP , SC_GUILDAURA , SI_BLANK , SCB_STR\|SCB_AGI\|SCB_VIT\|SCB_DEX );
	410	set_sc( GD_BATTLEORDER , SC_BATTLEORDERS , SI_BLANK , SCB_STR\|SCB_INT\|SCB_DEX );
	411	set_sc( GD_REGENERATION , SC_REGENERATION , SI_BLANK , SCB_REGEN );
[13]	412	//Custom Jobs (blackmagic)
	413	// Custom Jobs Skills [Brain]
	414	add_sc( AD_PWBLIND , SC_BLIND);
	415	add_sc( AD_PWFEAR , SC_FEAR);
	416	set_sc( AD_LUST , SC_LUST , SI_JOINTBEAT , SCB_ASPD\|SCB_BATK\|SCB_WATK\|SCB_REGEN);
	417
	418	set_sc( NC_DECREPIFY , SC_DECREPIFY , SI_BLEEDING , SCB_SPEED\|SCB_BATK\|SCB_WATK\|SCB_DEF2\|SCB_MDEF2);
	419	set_sc( NC_DARKMOON , SC_DARKMOON , SI_MOON_COMFORT , SCB_FLEE\|SCB_HIT);
	420	add_sc( NC_DARKMOON , SC_BLIND);
	421	set_sc( NC_REQUIEM , SC_REQUIEM , SI_KAIZEL , SCB_BATK\|SCB_WATK);
	422	add_sc( NC_GHOULTOUCH , SC_POISON);
	423	set_sc( NC_PWSUFFER , SC_SUFFER , SI_BLANK , SCB_DEF\|SCB_DEF2);
	424	set_sc( NC_DEATHPACT , SC_DEATHPACT , SI_BIOMOBTRICKDEAD , SCB_DEF_ELE\|SCB_REGEN);
	425
	426	set_sc( WL_SEARING , SC_SEARING , SI_BLANK , SCB_NONE);
	427	set_sc( WL_IMMOLATE , SC_IMMOLATE , SI_BLANK , SCB_NONE);
	428	add_sc( WL_SHADOWBURN , SC_STUN);
	429	set_sc( WL_PWAGONY , SC_AGONY , SI_BLANK , SCB_MDEF\|SCB_MDEF2);
	430	set_sc( WL_CURSETONGUES , SC_CURSETONGUES , SI_SLOWCAST , SCB_NONE);
	431	set_sc( WL_CURSEDOOM , SC_DOOM , SI_BLANK , SCB_NONE);
	432	set_sc( WL_CURSEWEAKNESS , SC_CURSEWEAKNESS , SI_STRIPWEAPON , SCB_BATK\|SCB_WATK);
	433	set_sc( WL_CURSEEXHAUST , SC_CURSEEXHAUST , SI_CRITICALWOUND , SCB_DEF\|SCB_MDEF);
	434	add_sc( WL_HOWLOFTERROR , SC_FEAR);
	435	set_sc( WL_HOWLOFPAIN , SC_PROVOKE , SI_PROVOKE , SCB_DEF\|SCB_DEF2\|SCB_BATK\|SCB_WATK);
	436	set_sc( WL_OVERWHELMING , SC_OVERWHELMING , SI_ENERGYCOAT , SCB_DEF\|SCB_MDEF\|SCB_MATK\|SCB_REGEN\|SCB_DEF_ELE);
	437
[10]	438	set_sc( ALL_ATFIELD , SC_ATFIELD , SI_UTSUSEMI ,SCB_NONE);
	439	//Custom Job End
[1]	440
	441	// Storing the target job rather than simply SC_SPIRIT simplifies code later on.
	442	SkillStatusChangeTable[SL_ALCHEMIST] = (sc_type)MAPID_ALCHEMIST,
	443	SkillStatusChangeTable[SL_MONK] = (sc_type)MAPID_MONK,
	444	SkillStatusChangeTable[SL_STAR] = (sc_type)MAPID_STAR_GLADIATOR,
	445	SkillStatusChangeTable[SL_SAGE] = (sc_type)MAPID_SAGE,
	446	SkillStatusChangeTable[SL_CRUSADER] = (sc_type)MAPID_CRUSADER,
	447	SkillStatusChangeTable[SL_SUPERNOVICE] = (sc_type)MAPID_SUPER_NOVICE,
	448	SkillStatusChangeTable[SL_KNIGHT] = (sc_type)MAPID_KNIGHT,
	449	SkillStatusChangeTable[SL_WIZARD] = (sc_type)MAPID_WIZARD,
	450	SkillStatusChangeTable[SL_PRIEST] = (sc_type)MAPID_PRIEST,
	451	SkillStatusChangeTable[SL_BARDDANCER] = (sc_type)MAPID_BARDDANCER,
	452	SkillStatusChangeTable[SL_ROGUE] = (sc_type)MAPID_ROGUE,
	453	SkillStatusChangeTable[SL_ASSASIN] = (sc_type)MAPID_ASSASSIN,
	454	SkillStatusChangeTable[SL_BLACKSMITH] = (sc_type)MAPID_BLACKSMITH,
	455	SkillStatusChangeTable[SL_HUNTER] = (sc_type)MAPID_HUNTER,
	456	SkillStatusChangeTable[SL_SOULLINKER] = (sc_type)MAPID_SOUL_LINKER,
	457
	458	//Status that don't have a skill associated.
	459	StatusIconChangeTable[SC_WEIGHT50] = SI_WEIGHT50;
	460	StatusIconChangeTable[SC_WEIGHT90] = SI_WEIGHT90;
	461	StatusIconChangeTable[SC_ASPDPOTION0] = SI_ASPDPOTION;
	462	StatusIconChangeTable[SC_ASPDPOTION1] = SI_ASPDPOTION;
	463	StatusIconChangeTable[SC_ASPDPOTION2] = SI_ASPDPOTION;
	464	StatusIconChangeTable[SC_ASPDPOTION3] = SI_ASPDPOTION;
	465	StatusIconChangeTable[SC_SPEEDUP0] = SI_SPEEDPOTION1;
	466	StatusIconChangeTable[SC_SPEEDUP1] = SI_SPEEDPOTION2;
	467	StatusIconChangeTable[SC_INCSTR] = SI_INCSTR;
	468	StatusIconChangeTable[SC_MIRACLE] = SI_SPIRIT;
	469	StatusIconChangeTable[SC_INTRAVISION] = SI_INTRAVISION;
	470	StatusIconChangeTable[SC_STRFOOD] = SI_FOODSTR;
	471	StatusIconChangeTable[SC_AGIFOOD] = SI_FOODAGI;
	472	StatusIconChangeTable[SC_VITFOOD] = SI_FOODVIT;
	473	StatusIconChangeTable[SC_INTFOOD] = SI_FOODINT;
	474	StatusIconChangeTable[SC_DEXFOOD] = SI_FOODDEX;
	475	StatusIconChangeTable[SC_LUKFOOD] = SI_FOODLUK;
	476	StatusIconChangeTable[SC_FLEEFOOD]= SI_FOODFLEE;
	477	StatusIconChangeTable[SC_HITFOOD] = SI_FOODHIT;
	478	//Cash Items
	479	StatusIconChangeTable[SC_EXPBOOST] = SI_EXPBOOST;
	480	StatusIconChangeTable[SC_ITEMBOOST] = SI_ITEMBOOST;
	481	StatusIconChangeTable[SC_LIFEINSURANCE] = SI_LIFEINSURANCE;
	482	StatusIconChangeTable[SC_BOSSMAPINFO] = SI_BOSSMAPINFO;
	483	StatusIconChangeTable[SC_DEF_RATE] = SI_DEF_RATE;
	484	StatusIconChangeTable[SC_MDEF_RATE] = SI_MDEF_RATE;
	485	StatusIconChangeTable[SC_INCCRI] = SI_INCCRI;
	486	StatusIconChangeTable[SC_INCHEALRATE] = SI_INCHEALRATE;
	487	StatusIconChangeTable[SC_HPREGEN] = SI_HPREGEN;
	488	StatusIconChangeTable[SC_SPCOST_RATE] = SI_SPCOST_RATE;
	489	StatusIconChangeTable[SC_COMMONSC_RESIST] = SI_COMMONSC_RESIST;
	490	StatusIconChangeTable[SC_ARMOR_RESIST] = SI_ARMOR_RESIST;
	491
	492	//Other SC which are not necessarily associated to skills.
	493	StatusChangeFlagTable[SC_ASPDPOTION0] = SCB_ASPD;
	494	StatusChangeFlagTable[SC_ASPDPOTION1] = SCB_ASPD;
	495	StatusChangeFlagTable[SC_ASPDPOTION2] = SCB_ASPD;
	496	StatusChangeFlagTable[SC_ASPDPOTION3] = SCB_ASPD;
	497	StatusChangeFlagTable[SC_SPEEDUP0] = SCB_SPEED;
	498	StatusChangeFlagTable[SC_SPEEDUP1] = SCB_SPEED;
	499	StatusChangeFlagTable[SC_ATKPOTION] = SCB_BATK;
	500	StatusChangeFlagTable[SC_MATKPOTION] = SCB_MATK;
	501	StatusChangeFlagTable[SC_INCALLSTATUS] \|= SCB_STR\|SCB_AGI\|SCB_VIT\|SCB_INT\|SCB_DEX\|SCB_LUK;
	502	StatusChangeFlagTable[SC_INCSTR] \|= SCB_STR;
	503	StatusChangeFlagTable[SC_INCAGI] \|= SCB_AGI;
	504	StatusChangeFlagTable[SC_INCVIT] \|= SCB_VIT;
	505	StatusChangeFlagTable[SC_INCINT] \|= SCB_INT;
	506	StatusChangeFlagTable[SC_INCDEX] \|= SCB_DEX;
	507	StatusChangeFlagTable[SC_INCLUK] \|= SCB_LUK;
	508	StatusChangeFlagTable[SC_INCHIT] \|= SCB_HIT;
	509	StatusChangeFlagTable[SC_INCHITRATE] \|= SCB_HIT;
	510	StatusChangeFlagTable[SC_INCFLEE] \|= SCB_FLEE;
	511	StatusChangeFlagTable[SC_INCFLEERATE] \|= SCB_FLEE;
	512	StatusChangeFlagTable[SC_INCCRI] \|= SCB_CRI;
	513	StatusChangeFlagTable[SC_INCFLEE2] \|= SCB_FLEE2;
	514	StatusChangeFlagTable[SC_INCDEF] \|= SCB_DEF;
	515	StatusChangeFlagTable[SC_INCMHPRATE] \|= SCB_MAXHP;
	516	StatusChangeFlagTable[SC_INCMSPRATE] \|= SCB_MAXSP;
	517	StatusChangeFlagTable[SC_INCASPDRATE] \|= SCB_ASPD;
	518	StatusChangeFlagTable[SC_INCATKRATE] \|= SCB_BATK\|SCB_WATK;
	519	StatusChangeFlagTable[SC_INCMATKRATE] \|= SCB_MATK;
	520	StatusChangeFlagTable[SC_INCDEFRATE] \|= SCB_DEF;
	521	StatusChangeFlagTable[SC_INCBASEATK] \|= SCB_BATK;
	522	StatusChangeFlagTable[SC_STRFOOD] \|= SCB_STR;
	523	StatusChangeFlagTable[SC_AGIFOOD] \|= SCB_AGI;
	524	StatusChangeFlagTable[SC_VITFOOD] \|= SCB_VIT;
	525	StatusChangeFlagTable[SC_INTFOOD] \|= SCB_INT;
	526	StatusChangeFlagTable[SC_DEXFOOD] \|= SCB_DEX;
	527	StatusChangeFlagTable[SC_LUKFOOD] \|= SCB_LUK;
	528	StatusChangeFlagTable[SC_HITFOOD] \|= SCB_HIT;
	529	StatusChangeFlagTable[SC_FLEEFOOD] \|= SCB_FLEE;
	530	StatusChangeFlagTable[SC_BATKFOOD] \|= SCB_BATK;
	531	StatusChangeFlagTable[SC_WATKFOOD] \|= SCB_WATK;
	532	StatusChangeFlagTable[SC_MATKFOOD] \|= SCB_MATK;
	533	StatusChangeFlagTable[SC_ARMOR_ELEMENT] \|= SCB_PC;
	534	StatusChangeFlagTable[SC_ARMOR_RESIST] \|= SCB_PC;
	535	StatusChangeFlagTable[SC_SPCOST_RATE] \|= SCB_PC;
	536	StatusChangeFlagTable[SC_WALKSPEED] \|= SCB_SPEED;
	537
	538	if (!battle_config.display_hallucination) //Disable Hallucination.
	539	StatusIconChangeTable[SC_HALLUCINATION] = SI_BLANK;
	540	}
	541
	542	static void initDummyData(void)
	543	{
	544	memset(&dummy_status, 0, sizeof(dummy_status));
	545	dummy_status.hp =
	546	dummy_status.max_hp =
	547	dummy_status.max_sp =
	548	dummy_status.str =
	549	dummy_status.agi =
	550	dummy_status.vit =
	551	dummy_status.int_ =
	552	dummy_status.dex =
	553	dummy_status.luk =
	554	dummy_status.hit = 1;
	555	dummy_status.speed = 2000;
	556	dummy_status.adelay = 4000;
	557	dummy_status.amotion = 2000;
	558	dummy_status.dmotion = 2000;
	559	dummy_status.ele_lv = 1; //Min elemental level.
	560	dummy_status.mode = MD_CANMOVE;
	561	}
	562
	563	/*==========================================
	564	* žB{[iX
	565	------------------------------------------/
	566	int status_getrefinebonus(int lv,int type)
	567	{
	568	if (lv >= 0 && lv < 5 && type >= 0 && type < 3)
	569	return refinebonus[lv][type];
	570	return 0;
	571	}
	572
	573	//Sets HP to given value. Flag is the flag passed to status_heal in case
	574	//final value is higher than current (use 2 to make a healing effect display
	575	//on players) It will always succeed (overrides Berserk block), but it can't kill.
	576	int status_set_hp(struct block_list *bl, unsigned int hp, int flag)
	577	{
	578	struct status_data *status;
	579	if (hp < 1) return 0;
	580	status = status_get_status_data(bl);
	581	if (status == &dummy_status)
	582	return 0;
	583
	584	if (hp > status->max_hp) hp = status->max_hp;
	585	if (hp == status->hp) return 0;
	586	if (hp > status->hp)
	587	return status_heal(bl, hp - status->hp, 0, 1\|flag);
	588	return status_zap(bl, status->hp - hp, 0);
	589	}
	590
	591	//Sets SP to given value. Flag is the flag passed to status_heal in case
	592	//final value is higher than current (use 2 to make a healing effect display
	593	//on players)
	594	int status_set_sp(struct block_list *bl, unsigned int sp, int flag)
	595	{
	596	struct status_data *status;
	597
	598	status = status_get_status_data(bl);
	599	if (status == &dummy_status)
	600	return 0;
	601
	602	if (sp > status->max_sp) sp = status->max_sp;
	603	if (sp == status->sp) return 0;
	604	if (sp > status->sp)
	605	return status_heal(bl, 0, sp - status->sp, 1\|flag);
	606	return status_zap(bl, 0, status->sp - sp);
	607	}
	608
	609	int status_charge(struct block_list* bl, int hp, int sp)
	610	{
	611	if(!(bl->type&BL_CONSUME))
	612	return hp+sp; //Assume all was charged so there are no 'not enough' fails.
	613	return status_damage(NULL, bl, hp, sp, 0, 3);
	614	}
	615
	616	//Inflicts damage on the target with the according walkdelay.
	617	//If flag&1, damage is passive and does not triggers cancelling status changes.
	618	//If flag&2, fail if target does not has enough to substract.
	619	//If flag&4, if killed, mob must not give exp/loot.
	620	int status_damage(struct block_list src,struct block_list target,int hp, int sp, int walkdelay, int flag)
	621	{
	622	struct status_data *status;
	623	struct status_change *sc;
	624
	625	if(sp && !(target->type&BL_CONSUME))
	626	sp = 0; //Not a valid SP target.
	627
	628	if (hp < 0) { //Assume absorbed damage.
	629	status_heal(target, -hp, 0, 1);
	630	hp = 0;
	631	}
	632
	633	if (sp < 0) {
	634	status_heal(target, 0, -sp, 1);
	635	sp = 0;
	636	}
	637
	638	if (!hp && !sp)
	639	return 0;
	640
	641	if (target->type == BL_SKILL)
	642	return skill_unit_ondamaged((struct skill_unit *)target, src, hp, gettick());
	643
	644	status = status_get_status_data(target);
	645
	646	if (status == &dummy_status \|\| !status->hp)
	647	return 0; //Invalid targets: no damage or dead
	648
	649	// Let through. battle.c/skill.c have the whole logic of when it's possible or
	650	// not to hurt someone (and this check breaks pet catching) [Skotlex]
	651	// if (!target->prev && !(flag&2))
	652	// return 0; //Cannot damage a bl not on a map, except when "charging" hp/sp
	653
	654	sc = status_get_sc(target);
	655
	656	if (sc && !sc->count)
	657	sc = NULL;
	658
	659	if (hp && !(flag&1)) {
	660	if (sc) {
	661	struct status_change_entry *sce;
	662	if ((sce=sc->data[SC_DEVOTION]) && src && battle_getcurrentskill(src) != PA_PRESSURE)
	663	{ //Devotion prevents any of the other ailments from ending.
	664	struct map_session_data *sd2 = map_id2sd(sce->val1);
	665	if (sd2 && sd2->devotion[sce->val2] == target->id && check_distance_bl(target, &sd2->bl, sce->val3))
	666	{
	667	clif_damage(&sd2->bl, &sd2->bl, gettick(), 0, 0, hp, 0, 0, 0);
	668	status_fix_damage(NULL, &sd2->bl, hp, 0);
	669	return 0;
	670	}
	671	status_change_end(target, SC_DEVOTION, -1);
	672	}
	673	if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
	674	status_change_end(target,SC_STONE,-1);
	675	status_change_end(target,SC_FREEZE,-1);
	676	status_change_end(target,SC_SLEEP,-1);
	677	status_change_end(target,SC_WINKCHARM,-1);
	678	status_change_end(target,SC_CONFUSION,-1);
	679	status_change_end(target,SC_TRICKDEAD,-1);
	680	status_change_end(target,SC_HIDING,-1);
	681	status_change_end(target,SC_CLOAKING,-1);
	682	status_change_end(target,SC_CHASEWALK,-1);
[10]	683	status_change_end(target,SC_FEAR, -1);//Custom Jobs (blackmagic)
[1]	684	if ((sce=sc->data[SC_ENDURE]) && !sce->val4) {
	685	//Endure count is only reduced by non-players on non-gvg maps.
	686	//val4 signals infinite endure. [Skotlex]
	687	if (src && src->type != BL_PC && !map_flag_gvg(target->m)
	688	&& --(sce->val2) < 0)
	689	status_change_end(target, SC_ENDURE, -1);
	690	}
	691	if ((sce=sc->data[SC_GRAVITATION]) && sce->val3 == BCT_SELF)
	692	{
	693	struct skill_unit_group sg = (struct skill_unit_group )sce->val4;
	694	if (sg) {
	695	skill_delunitgroup(target,sg);
	696	sce->val4 = 0;
	697	status_change_end(target, SC_GRAVITATION, -1);
	698	}
	699	}
	700	if(sc->data[SC_DANCING] && (unsigned int)hp > status->max_hp>>2)
	701	skill_stop_dancing(target);
	702	}
	703	unit_skillcastcancel(target, 2);
	704	}
	705
	706	if ((unsigned int)hp >= status->hp) {
	707	if (flag&2) return 0;
	708	hp = status->hp;
	709	}
	710
	711	if ((unsigned int)sp > status->sp) {
	712	if (flag&2) return 0;
	713	sp = status->sp;
	714	}
	715
	716	status->hp-= hp;
	717	status->sp-= sp;
	718
	719	if (sc && hp && status->hp) {
	720	if (sc->data[SC_AUTOBERSERK] &&
	721	(!sc->data[SC_PROVOKE] \|\| !sc->data[SC_PROVOKE]->val2) &&
	722	status->hp < status->max_hp>>2)
	723	sc_start4(target,SC_PROVOKE,100,10,1,0,0,0);
	724	if (sc->data[SC_BERSERK] && status->hp <= 100)
	725	status_change_end(target, SC_BERSERK, -1);
	726	}
	727
	728	switch (target->type)
	729	{
	730	case BL_PC: pc_damage((TBL_PC*)target,src,hp,sp); break;
	731	case BL_MOB: mob_damage((TBL_MOB*)target, src, hp); break;
	732	case BL_HOM: merc_damage((TBL_HOM*)target,src,hp,sp); break;
	733	}
	734
	735	if (status->hp)
	736	{ //Still lives!
	737	if (walkdelay)
	738	unit_set_walkdelay(target, gettick(), walkdelay, 0);
	739	return hp+sp;
	740	}
	741
	742	status->hp = 1; //To let the dead function cast skills and all that.
	743	//NOTE: These dead functions should return: [Skotlex]
	744	//0: Death cancelled, auto-revived.
	745	//Non-zero: Standard death. Clear status, cancel move/attack, etc
	746	//&2: Also remove object from map.
	747	//&4: Also delete object from memory.
	748	switch (target->type) {
	749	case BL_PC: flag = pc_dead((TBL_PC*)target,src); break;
	750	case BL_MOB: flag = mob_dead((TBL_MOB*)target, src, flag&4?3:0); break;
	751	case BL_HOM: flag = merc_hom_dead((TBL_HOM*)target,src); break;
	752	default: //Unhandled case, do nothing to object.
	753	flag = 0;
	754	break;
	755	}
	756
	757	if(!flag) //Death cancelled.
	758	return hp+sp;
	759
	760	//Normal death
	761	status->hp = 0;
	762	if (battle_config.clear_unit_ondeath &&
	763	battle_config.clear_unit_ondeath&target->type)
	764	skill_clear_unitgroup(target);
	765
	766	if(target->type&BL_REGEN)
	767	{ //Reset regen ticks.
	768	struct regen_data *regen = status_get_regen_data(target);
	769	if (regen) {
	770	memset(&regen->tick, 0, sizeof(regen->tick));
	771	if (regen->sregen)
	772	memset(&regen->sregen->tick, 0, sizeof(regen->sregen->tick));
	773	if (regen->ssregen)
	774	memset(&regen->ssregen->tick, 0, sizeof(regen->ssregen->tick));
	775	}
	776	}
	777
	778	if (!(flag&8) && sc && sc->data[SC_KAIZEL]) { //flag&8 = disable Kaizel
	779	int time = skill_get_time2(SL_KAIZEL,sc->data[SC_KAIZEL]->val1);
	780	status_revive(target, sc->data[SC_KAIZEL]->val2, 0);
	781	status_change_clear(target,0);
	782	clif_skill_nodamage(target,target,ALL_RESURRECTION,1,1);
	783	sc_start(target,status_skill2sc(PR_KYRIE),100,10,time);
	784	return hp+sp;
	785	}
	786
	787	status_change_clear(target,0);
	788
	789	if(flag&4) //Delete from memory. (also invokes map removal code)
	790	unit_free(target,1);
	791	else
	792	if(flag&2) //remove from map
	793	unit_remove_map(target,1);
	794	else
	795	{ //Some death states that would normally be handled by unit_remove_map
	796	unit_stop_attack(target);
	797	unit_stop_walking(target,0);
	798	unit_skillcastcancel(target,0);
	799	clif_clearunit_area(target,1);
	800	skill_unit_move(target,gettick(),4);
	801	skill_cleartimerskill(target);
	802	}
	803
	804	return hp+sp;
	805	}
	806
	807	//Heals a character. If flag&1, this is forced healing (otherwise stuff like Berserk can block it)
	808	//If flag&2, when the player is healed, show the HP/SP heal effect.
	809	int status_heal(struct block_list *bl,int hp,int sp, int flag)
	810	{
	811	struct status_data *status;
	812	struct status_change *sc;
	813
	814	status = status_get_status_data(bl);
	815
	816	if (status == &dummy_status \|\| !status->hp)
	817	return 0;
	818
	819	sc = status_get_sc(bl);
	820	if (sc && !sc->count)
	821	sc = NULL;
	822
	823	if (hp < 0) {
	824	status_damage(NULL, bl, -hp, 0, 0, 1);
	825	hp = 0;
	826	}
	827
	828	if(hp) {
	829	if (!(flag&1) && sc && sc->data[SC_BERSERK])
	830	hp = 0;
	831
	832	if((unsigned int)hp > status->max_hp - status->hp)
	833	hp = status->max_hp - status->hp;
	834	}
	835
	836	if(sp < 0) {
	837	status_damage(NULL, bl, 0, -sp, 0, 1);
	838	sp = 0;
	839	}
	840
	841	if(sp) {
	842	if((unsigned int)sp > status->max_sp - status->sp)
	843	sp = status->max_sp - status->sp;
	844	}
	845
	846	if(!sp && !hp) return 0;
	847
	848	status->hp+= hp;
	849	status->sp+= sp;
	850
	851	if(hp && sc &&
	852	sc->data[SC_AUTOBERSERK] &&
	853	sc->data[SC_PROVOKE] &&
	854	sc->data[SC_PROVOKE]->val2==1 &&
	855	status->hp>=status->max_hp>>2
	856	) //End auto berserk.
	857	status_change_end(bl,SC_PROVOKE,-1);
	858
	859	// send hp update to client
	860	switch(bl->type) {
	861	case BL_PC: pc_heal((TBL_PC*)bl,hp,sp,flag&2?1:0); break;
	862	case BL_MOB: mob_heal((TBL_MOB*)bl,hp); break;
	863	case BL_HOM: merc_hom_heal((TBL_HOM*)bl,hp,sp); break;
	864	}
	865
	866	return hp+sp;
	867	}
	868
	869	//Does percentual non-flinching damage/heal. If mob is killed this way,
	870	//no exp/drops will be awarded if there is no src (or src is target)
	871	//If rates are > 0, percent is of current HP/SP
	872	//If rates are < 0, percent is of max HP/SP
	873	//If !flag, this is heal, otherwise it is damage.
	874	//Furthermore, if flag==2, then the target must not die from the substraction.
	875	int status_percent_change(struct block_list src,struct block_list target,signed char hp_rate, signed char sp_rate, int flag)
	876	{
	877	struct status_data *status;
	878	unsigned int hp =0, sp = 0;
	879
	880	status = status_get_status_data(target);
	881
	882	//Change the equation when the values are high enough to discard the
	883	//imprecision in exchange of overflow protection [Skotlex]
	884	//Also add 100% checks since those are the most used cases where we don't
	885	//want aproximation errors.
	886	if (hp_rate > 99)
	887	hp = status->hp;
	888	else if (hp_rate > 0)
	889	hp = status->hp>10000?
	890	hp_rate*(status->hp/100):
	891	(hp_rate*status->hp)/100;
	892	else if (hp_rate < -99)
	893	hp = status->max_hp;
	894	else if (hp_rate < 0)
	895	hp = status->max_hp>10000?
	896	(-hp_rate)*(status->max_hp/100):
	897	(-hp_rate*status->max_hp)/100;
	898	if (hp_rate && !hp)
	899	hp = 1;
	900
	901	if (flag == 2 && hp >= status->hp)
	902	hp = status->hp-1; //Must not kill target.
	903
	904	//Should be safe to not do overflow protection here, noone should have
	905	//millions upon millions of SP
	906	if (sp_rate > 99)
	907	sp = status->sp;
	908	else if (sp_rate > 0)
	909	sp = (sp_rate*status->sp)/100;
	910	else if (sp_rate < -99)
	911	sp = status->max_sp;
	912	else if (sp_rate < 0)
	913	sp = (-sp_rate)*status->max_sp/100;
	914	if (sp_rate && !sp)
	915	sp = 1;
	916
	917	//Ugly check in case damage dealt is too much for the received args of
	918	//status_heal / status_damage. [Skotlex]
	919	if (hp > INT_MAX) {
	920	hp -= INT_MAX;
	921	if (flag)
	922	status_damage(src, target, INT_MAX, 0, 0, (!src\|\|src==target?5:1));
	923	else
	924	status_heal(target, INT_MAX, 0, 0);
	925	}
	926	if (sp > INT_MAX) {
	927	sp -= INT_MAX;
	928	if (flag)
	929	status_damage(src, target, 0, INT_MAX, 0, (!src\|\|src==target?5:1));
	930	else
	931	status_heal(target, 0, INT_MAX, 0);
	932	}
	933	if (flag)
	934	return status_damage(src, target, hp, sp, 0, (!src\|\|src==target?5:1));
	935	return status_heal(target, hp, sp, 0);
	936	}
	937
	938	int status_revive(struct block_list *bl, unsigned char per_hp, unsigned char per_sp)
	939	{
	940	struct status_data *status;
	941	unsigned int hp, sp;
	942	if (!status_isdead(bl)) return 0;
	943
	944	status = status_get_status_data(bl);
	945	if (status == &dummy_status)
	946	return 0; //Invalid target.
	947
	948	hp = status->max_hp * per_hp/100;
	949	sp = status->max_sp * per_sp/100;
	950
	951	if(hp > status->max_hp - status->hp)
	952	hp = status->max_hp - status->hp;
	953	else if (per_hp && !hp)
	954	hp = 1;
	955
	956	if(sp > status->max_sp - status->sp)
	957	sp = status->max_sp - status->sp;
	958	else if (per_sp && !sp)
	959	sp = 1;
	960
	961	status->hp += hp;
	962	status->sp += sp;
	963
	964	if (bl->prev) //Animation only if character is already on a map.
	965	clif_resurrection(bl, 1);
	966	switch (bl->type) {
	967	case BL_PC: pc_revive((TBL_PC*)bl, hp, sp); break;
	968	case BL_MOB: mob_revive((TBL_MOB*)bl, hp); break;
	969	case BL_HOM: merc_hom_revive((TBL_HOM*)bl, hp, sp); break;
	970	}
	971	return 1;
	972	}
	973
	974	/*==========================================
	975	* Checks whether the src can use the skill on the target,
	976	* taking into account status/option of both source/target. [Skotlex]
	977	* flag:
	978	* 0 - Trying to use skill on target.
	979	* 1 - Cast bar is done.
	980	* 2 - Skill already pulled off, check is due to ground-based skills or splash-damage ones.
	981	* src MAY be null to indicate we shouldn't check it, this is a ground-based skill attack.
	982	* target MAY Be null, in which case the checks are only to see
	983	* whether the source can cast or not the skill on the ground.
	984	------------------------------------------/
	985	int status_check_skilluse(struct block_list src, struct block_list target, int skill_num, int flag)
	986	{
	987	struct status_data *status;
	988	struct status_change sc=NULL, tsc;
	989	int hide_flag;
	990
	991	status = src?status_get_status_data(src):&dummy_status;
	992
	993	if (src && status_isdead(src))
	994	return 0;
	995
	996	if (!skill_num) { //Normal attack checks.
	997	if (!(status->mode&MD_CANATTACK))
	998	return 0; //This mode is only needed for melee attacking.
	999	//Dead state is not checked for skills as some skills can be used
	1000	//on dead characters, said checks are left to skill.c [Skotlex]
	1001	if (target && status_isdead(target))
	1002	return 0;
	1003	}
	1004
	1005	if (skill_num == PA_PRESSURE && flag && target) {
	1006	//Gloria Avoids pretty much everything....
	1007	tsc = status_get_sc(target);
	1008	if(tsc && tsc->option&OPTION_HIDE)
	1009	return 0;
	1010	return 1;
	1011	}
	1012
	1013	if (((src && map_getcell(src->m,src->x,src->y,CELL_CHKBASILICA)) \|\|
	1014	(target && target != src && map_getcell(target->m,target->x,target->y,CELL_CHKBASILICA)))
	1015	&& !(status->mode&MD_BOSS))
	1016	{ //Basilica Check
	1017	if (!skill_num) return 0;
	1018	hide_flag = skill_get_inf(skill_num);
	1019	if (hide_flag&INF_ATTACK_SKILL)
	1020	return 0;
	1021	if (hide_flag&INF_GROUND_SKILL && skill_get_unit_target(skill_num)&BCT_ENEMY)
	1022	return 0;
	1023	}
	1024
	1025	//Should fail when used on top of Land Protector [Skotlex]
	1026	if (src && skill_num == AL_TELEPORT && map_getcell(src->m, src->x, src->y, CELL_CHKLANDPROTECTOR)
	1027	&& !(status->mode&MD_BOSS))
	1028	return 0;
	1029
	1030	if (src) sc = status_get_sc(src);
	1031
	1032	if(sc && sc->count)
	1033	{
	1034	if(sc->opt1 >0)
	1035	{ //Stuned/Frozen/etc
	1036	if (flag != 1) //Can't cast, casted stuff can't damage.
	1037	return 0;
	1038	if (!(skill_get_inf(skill_num)&INF_GROUND_SKILL))
	1039	return 0; //Targetted spells can't come off.
	1040	}
	1041
	1042	if (
	1043	(sc->data[SC_TRICKDEAD] && skill_num != NV_TRICKDEAD)
	1044	\|\| (sc->data[SC_AUTOCOUNTER] && !flag)
	1045	\|\| (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF && skill_num != PA_GOSPEL)
	1046	\|\| (sc->data[SC_GRAVITATION] && sc->data[SC_GRAVITATION]->val3 == BCT_SELF && flag != 2)
	1047	)
	1048	return 0;
	1049
	1050	if (sc->data[SC_WINKCHARM] && target && !flag)
	1051	{ //Prevents skill usage
	1052	clif_emotion(src, 3);
	1053	return 0;
	1054	}
	1055
	1056	if (sc->data[SC_BLADESTOP]) {
	1057	switch (sc->data[SC_BLADESTOP]->val1)
	1058	{
	1059	case 5: if (skill_num == MO_EXTREMITYFIST) break;
	1060	case 4: if (skill_num == MO_CHAINCOMBO) break;
	1061	case 3: if (skill_num == MO_INVESTIGATE) break;
	1062	case 2: if (skill_num == MO_FINGEROFFENSIVE) break;
	1063	default: return 0;
	1064	}
	1065	}
	1066
	1067	if (sc->data[SC_DANCING] && flag!=2)
	1068	{
	1069	if(sc->data[SC_LONGING])
	1070	{ //Allow everything except dancing/re-dancing. [Skotlex]
	1071	if (skill_num == BD_ENCORE \|\|
	1072	skill_get_inf2(skill_num)&(INF2_SONG_DANCE\|INF2_ENSEMBLE_SKILL)
	1073	)
	1074	return 0;
	1075	} else
	1076	switch (skill_num) {
	1077	case BD_ADAPTATION:
	1078	case CG_LONGINGFREEDOM:
	1079	case BA_MUSICALSTRIKE:
	1080	case DC_THROWARROW:
	1081	break;
	1082	default:
	1083	return 0;
	1084	}
	1085	if ((sc->data[SC_DANCING]->val1&0xFFFF) == CG_HERMODE && skill_num == BD_ADAPTATION)
	1086	return 0; //Can't amp out of Wand of Hermode :/ [Skotlex]
	1087	}
	1088
	1089	if (skill_num && //Do not block item-casted skills.
	1090	(src->type != BL_PC \|\| ((TBL_PC*)src)->skillitem != skill_num)
	1091	) { //Skills blocked through status changes...
	1092	if (!flag && ( //Blocked only from using the skill (stuff like autospell may still go through
	1093	sc->data[SC_SILENCE] \|\|
	1094	(sc->data[SC_MARIONETTE] && skill_num != CG_MARIONETTE) \|\|
	1095	(sc->data[SC_MARIONETTE2] && skill_num == CG_MARIONETTE) \|\|
	1096	sc->data[SC_STEELBODY] \|\|
	1097	sc->data[SC_BERSERK]
	1098	))
	1099	return 0;
	1100
	1101	//Skill blocking.
	1102	if (
	1103	(sc->data[SC_VOLCANO] && skill_num == WZ_ICEWALL) \|\|
	1104	(sc->data[SC_ROKISWEIL] && skill_num != BD_ADAPTATION) \|\|
	1105	(sc->data[SC_HERMODE] && skill_get_inf(skill_num) & INF_SUPPORT_SKILL) \|\|
	1106	(sc->data[SC_NOCHAT] && sc->data[SC_NOCHAT]->val1&MANNER_NOSKILL)
	1107	)
	1108	return 0;
	1109
	1110	}
	1111	}
	1112
	1113	if (sc && sc->option)
	1114	{
	1115	if (sc->option&OPTION_HIDE)
	1116	switch (skill_num) { //Usable skills while hiding.
	1117	case TF_HIDING:
	1118	case AS_GRIMTOOTH:
	1119	case RG_BACKSTAP:
	1120	case RG_RAID:
	1121	case NJ_SHADOWJUMP:
	1122	case NJ_KIRIKAGE:
	1123	break;
	1124	default:
	1125	//Non players can use all skills while hidden.
	1126	if (!skill_num \|\| src->type == BL_PC)
	1127	return 0;
	1128	}
	1129	if (sc->option&OPTION_CHASEWALK && skill_num != ST_CHASEWALK)
	1130	return 0;
	1131	}
	1132	if (target == NULL \|\| target == src) //No further checking needed.
	1133	return 1;
	1134
	1135	tsc = status_get_sc(target);
	1136
	1137	if(tsc && tsc->count)
	1138	{
	1139	if(!skill_num && !(status->mode&MD_BOSS) && tsc->data[SC_TRICKDEAD])
	1140	return 0;
	1141	if((skill_num == WZ_STORMGUST \|\| skill_num == NJ_HYOUSYOURAKU)
	1142	&& tsc->data[SC_FREEZE])
	1143	return 0;
	1144	if(skill_num == PR_LEXAETERNA && (tsc->data[SC_FREEZE] \|\| (tsc->data[SC_STONE] && tsc->opt1 == OPT1_STONE)))
	1145	return 0;
	1146	}
	1147
	1148	//If targetting, cloak+hide protect you, otherwise only hiding does.
	1149	hide_flag = flag?OPTION_HIDE:(OPTION_HIDE\|OPTION_CLOAK\|OPTION_CHASEWALK);
	1150
	1151	//You cannot hide from ground skills.
	1152	if(skill_get_ele(skill_num,1) == ELE_EARTH) //TODO: Need Skill Lv here :/
	1153	hide_flag &= ~OPTION_HIDE;
	1154
	1155	switch (target->type)
	1156	{
	1157	case BL_PC:
	1158	{
	1159	struct map_session_data sd = (TBL_PC) target;
	1160	if (pc_isinvisible(sd))
	1161	return 0;
	1162	if (tsc->option&hide_flag && !(status->mode&MD_BOSS) &&
	1163	(sd->special_state.perfect_hiding \|\| !(status->mode&MD_DETECTOR)))
	1164	return 0;
	1165	}
	1166	break;
	1167	case BL_ITEM: //Allow targetting of items to pick'em up (or in the case of mobs, to loot them).
	1168	//TODO: Would be nice if this could be used to judge whether the player can or not pick up the item it targets. [Skotlex]
	1169	if (status->mode&MD_LOOTER)
	1170	return 1;
	1171	return 0;
	1172	case BL_HOM:
	1173	//Can't use support skills on homun (only master/self can)
	1174	//Placed here instead of battle_check_target because support skill
	1175	//invocations don't call that function.
	1176	if (skill_num && battle_config.hom_setting&0x1 &&
	1177	skill_get_inf(skill_num)&INF_SUPPORT_SKILL &&
	1178	battle_get_master(target) != src)
	1179	return 0;
	1180	default:
	1181	//Check for chase-walk/hiding/cloaking opponents.
	1182	if (tsc && tsc->option&hide_flag && !(status->mode&(MD_BOSS\|MD_DETECTOR)))
	1183	return 0;
	1184	}
	1185	return 1;
	1186	}
	1187
	1188	//Checks whether the source can see and chase target.
	1189	int status_check_visibility(struct block_list src, struct block_list target)
	1190	{
	1191	int view_range;
	1192	struct status_data* status = status_get_status_data(src);
	1193	struct status_change* tsc = status_get_sc(target);
	1194	switch (src->type) {
	1195	case BL_MOB:
	1196	view_range = ((TBL_MOB*)src)->min_chase;
	1197	break;
	1198	case BL_PET:
	1199	view_range = ((TBL_PET*)src)->db->range2;
	1200	break;
	1201	default:
	1202	view_range = AREA_SIZE;
	1203	}
	1204
	1205	if (src->m != target->m \|\| !check_distance_bl(src, target, view_range))
	1206	return 0;
	1207
	1208	switch (target->type)
	1209	{ //Check for chase-walk/hiding/cloaking opponents.
	1210	case BL_PC:
	1211	if(tsc->option&(OPTION_HIDE\|OPTION_CLOAK\|OPTION_CHASEWALK) &&
	1212	!(status->mode&MD_BOSS) &&
	1213	(
	1214	((TBL_PC*)target)->special_state.perfect_hiding \|\|
	1215	!(status->mode&MD_DETECTOR)
	1216	))
	1217	return 0;
	1218	break;
	1219	default:
	1220	if (tsc && tsc->option&(OPTION_HIDE\|OPTION_CLOAK\|OPTION_CHASEWALK) &&
	1221	!(status->mode&(MD_BOSS\|MD_DETECTOR)))
	1222	return 0;
	1223	}
	1224
	1225	return 1;
	1226	}
	1227
	1228	void status_calc_bl(struct block_list *bl, unsigned long flag);
	1229
	1230	// Basic ASPD value
	1231	int status_base_amotion_pc(struct map_session_data* sd, struct status_data* status)
	1232	{
	1233	int amotion;
	1234
	1235	// base weapon delay
	1236	amotion = (sd->status.weapon < MAX_WEAPON_TYPE)
	1237	? (aspd_base[pc_class2idx(sd->status.class_)][sd->status.weapon]) // single weapon
	1238	: (aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype1] + aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype2])*7/10; // dual-wield
	1239
	1240	// percentual delay reduction from stats
	1241	amotion-= amotion * (4*status->agi + status->dex)/1000;
	1242
	1243	// raw delay adjustment from bAspd bonus
	1244	amotion+= sd->aspd_add;
	1245
	1246	return amotion;
	1247	}
	1248
	1249	static unsigned short status_base_atk(struct block_list bl, struct status_data status)
	1250	{
	1251	int flag = 0, str, dex, dstr;
	1252
	1253	if(!(bl->type&battle_config.enable_baseatk))
	1254	return 0;
	1255
	1256	if (bl->type == BL_PC)
	1257	switch(((TBL_PC*)bl)->status.weapon){
	1258	case W_BOW:
	1259	case W_MUSICAL:
	1260	case W_WHIP:
	1261	case W_REVOLVER:
	1262	case W_RIFLE:
	1263	case W_GATLING:
	1264	case W_SHOTGUN:
	1265	case W_GRENADE:
	1266	flag = 1;
	1267	}
	1268	if (flag) {
	1269	str = status->dex;
	1270	dex = status->str;
	1271	} else {
	1272	str = status->str;
	1273	dex = status->dex;
	1274	}
	1275	//Normally only players have base-atk, but homunc have a different batk
	1276	// equation, hinting that perhaps non-players should use this for batk.
	1277	// [Skotlex]
	1278	dstr = str/10;
	1279	str += dstr*dstr;
	1280	if (bl->type == BL_PC)
	1281	str+= dex/5 + status->luk/5;
	1282	return cap_value(str, 0, USHRT_MAX);
	1283	}
	1284
	1285	#define status_base_matk_max(status) (status->int_+(status->int_/5)*(status->int_/5))
	1286	#define status_base_matk_min(status) (status->int_+(status->int_/7)*(status->int_/7))
	1287
	1288	//Fills in the misc data that can be calculated from the other status info (except for level)
	1289	void status_calc_misc(struct block_list bl, struct status_data status, int level)
	1290	{
	1291	//Non players get the value set, players need to stack with previous bonuses.
	1292	if (bl->type != BL_PC)
	1293	status->batk =
	1294	status->hit = status->flee =
	1295	status->def2 = status->mdef2 =
	1296	status->cri = status->flee2 = 0;
	1297
	1298	status->matk_min = status_base_matk_min(status);
	1299	status->matk_max = status_base_matk_max(status);
	1300
	1301	status->hit += level + status->dex;
	1302	status->flee += level + status->agi;
	1303	status->def2 += status->vit;
	1304	status->mdef2 += status->int_ + (status->vit>>1);
	1305
	1306	if (bl->type&battle_config.enable_critical)
	1307	status->cri += status->luk*3 + 10;
	1308	else
	1309	status->cri = 0;
	1310
	1311	if (bl->type&battle_config.enable_perfect_flee)
	1312	status->flee2 += status->luk + 10;
	1313	else
	1314	status->flee2 = 0;
	1315
	1316	if (status->batk) {
	1317	int temp = status->batk + status_base_atk(bl, status);
	1318	status->batk = cap_value(temp, 0, USHRT_MAX);
	1319	} else
	1320	status->batk = status_base_atk(bl, status);
	1321	if (status->cri)
	1322	switch (bl->type) {
	1323	case BL_MOB:
	1324	if(battle_config.mob_critical_rate != 100)
	1325	status->cri = status->cri*battle_config.mob_critical_rate/100;
	1326	if(!status->cri && battle_config.mob_critical_rate)
	1327	status->cri = 10;
	1328	break;
	1329	case BL_PC:
	1330	//Players don't have a critical adjustment setting as of yet.
	1331	break;
	1332	default:
	1333	if(battle_config.critical_rate != 100)
	1334	status->cri = status->cri*battle_config.critical_rate/100;
	1335	if (!status->cri && battle_config.critical_rate)
	1336	status->cri = 10;
	1337	}
	1338	if(bl->type&BL_REGEN)
	1339	status_calc_regen(bl, status, status_get_regen_data(bl));
	1340	}
	1341
	1342	//Skotlex: Calculates the initial status for the given mob
	1343	//first will only be false when the mob leveled up or got a GuardUp level.
	1344	//first&2: Class-change invoked.
	1345	int status_calc_mob(struct mob_data* md, int first)
	1346	{
	1347	struct status_data *status;
	1348	struct block_list *mbl = NULL;
	1349	int flag=0;
	1350
	1351	if(first)
	1352	{ //Set basic level on respawn.
	1353	if (md->spawn && !(first&2))
	1354	md->level = md->spawn->level;
	1355	else
	1356	md->level = md->db->lv; // [Valaris]
	1357	}
	1358
	1359	//Check if we need custom base-status
	1360	if (battle_config.mobs_level_up && md->level > md->db->lv)
	1361	flag\|=1;
	1362
	1363	if (md->special_state.size)
	1364	flag\|=2;
	1365
	1366	if (md->guardian_data && md->guardian_data->guardup_lv)
	1367	flag\|=4;
	1368
	1369	if (battle_config.slaves_inherit_speed && md->master_id)
	1370	flag\|=8;
	1371
	1372	if (md->master_id && md->special_state.ai>1)
	1373	flag\|=16;
	1374
[13]	1375	//Custom Jobs (blackmagic)
	1376	if (md->master_id && md->special_state.ai)
[10]	1377	flag\|=32; //Adept/Necro/Warlock Summon Stats Bonus [Brainstorm]
	1378	//Custom Job End
	1379
[1]	1380	if (!flag)
	1381	{ //No special status required.
	1382	if (md->base_status) {
	1383	aFree(md->base_status);
	1384	md->base_status = NULL;
	1385	}
	1386	if(first)
	1387	memcpy(&md->status, &md->db->status, sizeof(struct status_data));
	1388	return 0;
	1389	}
	1390	if (!md->base_status)
	1391	md->base_status = (struct status_data*)aCalloc(1, sizeof(struct status_data));
	1392
	1393	status = md->base_status;
	1394	memcpy(status, &md->db->status, sizeof(struct status_data));
	1395
	1396
	1397	if (flag&(8\|16))
	1398	mbl = map_id2bl(md->master_id);
	1399
	1400	if (flag&8 && mbl) {
	1401	struct status_data *mstatus = status_get_base_status(mbl);
	1402	if (mstatus &&
	1403	battle_config.slaves_inherit_speed&(mstatus->mode&MD_CANMOVE?1:2))
	1404	status->speed = mstatus->speed;
	1405	}
	1406
	1407	if (flag&16 && mbl)
	1408	{ //Max HP setting from Summon Flora/marine Sphere
	1409	struct unit_data *ud = unit_bl2ud(mbl);
	1410	//Remove special AI when this is used by regular mobs.
	1411	if (mbl->type == BL_MOB && !((TBL_MOB*)mbl)->special_state.ai)
	1412	md->special_state.ai = 0;
	1413	if (ud)
	1414	{ // different levels of HP according to skill level
	1415	if (ud->skillid == AM_SPHEREMINE) {
	1416	status->max_hp = 2000 + 400*ud->skilllv;
	1417	} else { //AM_CANNIBALIZE
	1418	status->max_hp = 1500 + 200ud->skilllv + 10status_get_lv(mbl);
	1419	status->mode\|= MD_CANATTACK\|MD_AGGRESSIVE;
	1420	}
	1421	status->hp = status->max_hp;
	1422	}
	1423	}
	1424
	1425	if (flag&1)
	1426	{ // increase from mobs leveling up [Valaris]
	1427	int diff = md->level - md->db->lv;
	1428	status->str+= diff;
	1429	status->agi+= diff;
	1430	status->vit+= diff;
	1431	status->int_+= diff;
	1432	status->dex+= diff;
	1433	status->luk+= diff;
	1434	status->max_hp += diff*status->vit;
	1435	status->max_sp += diff*status->int_;
	1436	status->hp = status->max_hp;
	1437	status->sp = status->max_sp;
	1438	status->speed -= diff;
	1439	}
	1440
	1441
	1442	if (flag&2)
	1443	{ // change for sized monsters [Valaris]
	1444	if (md->special_state.size==1) {
	1445	status->max_hp>>=1;
	1446	status->max_sp>>=1;
	1447	if (!status->max_hp) status->max_hp = 1;
	1448	if (!status->max_sp) status->max_sp = 1;
	1449	status->hp=status->max_hp;
	1450	status->sp=status->max_sp;
	1451	status->str>>=1;
	1452	status->agi>>=1;
	1453	status->vit>>=1;
	1454	status->int_>>=1;
	1455	status->dex>>=1;
	1456	status->luk>>=1;
	1457	if (!status->str) status->str = 1;
	1458	if (!status->agi) status->agi = 1;
	1459	if (!status->vit) status->vit = 1;
	1460	if (!status->int_) status->int_ = 1;
	1461	if (!status->dex) status->dex = 1;
	1462	if (!status->luk) status->luk = 1;
	1463	} else if (md->special_state.size==2) {
	1464	status->max_hp<<=1;
	1465	status->max_sp<<=1;
	1466	status->hp=status->max_hp;
	1467	status->sp=status->max_sp;
	1468	status->str<<=1;
	1469	status->agi<<=1;
	1470	status->vit<<=1;
	1471	status->int_<<=1;
	1472	status->dex<<=1;
	1473	status->luk<<=1;
	1474	}
	1475	}
	1476
	1477	status_calc_misc(&md->bl, status, md->level);
	1478
	1479	if(flag&4)
	1480	{ // Strengthen Guardians - custom value +10% / lv
	1481	struct guild_castle *gc;
	1482	gc=guild_mapname2gc(map[md->bl.m].name);
	1483	if (!gc)
	1484	ShowError("status_calc_mob: No castle set at map %s\n", map[md->bl.m].name);
	1485	else {
	1486	status->max_hp += 2000 * gc->defense;
	1487	status->max_sp += 200 * gc->defense;
	1488	status->hp = status->max_hp;
	1489	status->sp = status->max_sp;
	1490	}
	1491	status->batk += status->batk * 10*md->guardian_data->guardup_lv/100;
	1492	status->rhw.atk += status->rhw.atk * 10*md->guardian_data->guardup_lv/100;
	1493	status->rhw.atk2 += status->rhw.atk2 * 10*md->guardian_data->guardup_lv/100;
	1494	status->aspd_rate -= 100*md->guardian_data->guardup_lv;
	1495	}
	1496
[10]	1497	//Custom Jobs (blackmagic)
[13]	1498	//Summon Bonus from Skills [Brainstorm]
	1499	if(flag&32)
	1500	{
	1501	mbl = map_id2bl(md->master_id);
	1502	if(mbl)
	1503	{
	1504	struct unit_data *ud = unit_bl2ud(mbl);
	1505	//Remove special AI when this is used by regular mobs.
	1506	if (mbl->type == BL_MOB && !((TBL_MOB*)mbl)->special_state.ai)
	1507	md->special_state.ai = 0;
	1508
	1509	int master_lv = status_get_lv(mbl);
	1510	int skill_mastery = pc_checkskill((TBL_PC*)mbl,AD_SUMMONS);
	1511	int undead_mastery = pc_checkskill((TBL_PC*)mbl,NC_UNDEAD);
	1512
	1513	if (ud->skillid == AD_FAMILIAR)
	1514	{
	1515	status->max_hp += (skill_mastery10) + (master_lv10);
	1516	status->str += (master_lv) + (skill_mastery);
	1517	status->dex += (master_lv) + (skill_mastery);
	1518	status->agi += (master_lv) + (skill_mastery);
	1519	status->int_ += (master_lv) + (skill_mastery);
	1520	status->vit += (master_lv) + (skill_mastery);
	1521	status->luk += (master_lv) + (skill_mastery);
	1522	status->rhw.atk += (skill_mastery*3)
	1523	+ (status->str+((status->str/10)*(status->str/10))+(status->dex/5)+(status->luk/10));
	1524	status->rhw.atk2 += (skill_mastery*3)
	1525	+ (status->str+((status->str/10)*(status->str/10))+(status->dex/5)+(status->luk/10));
	1526	status->speed -= skill_mastery;
	1527	status->def += (master_lv)/10 + (skill_mastery);
	1528	status->mdef += (master_lv)/10 + (skill_mastery);
	1529	//These are not automatically recalculated
	1530	status->hit += (master_lv*2) + (skill_mastery);
	1531	status->flee += (master_lv*2) + (skill_mastery);
	1532	status->def2 += (master_lv) + (skill_mastery);
	1533	status->mdef2 += (master_lv) + (skill_mastery);
	1534	}
	1535	else if(status->race==RC_UNDEAD)
	1536	{
	1537	status->max_hp += (undead_mastery10) + (master_lv2);
	1538	status->str += (undead_mastery*3) + (skill_mastery);
	1539	status->dex += (undead_mastery*3) + (skill_mastery);
	1540	status->agi += (undead_mastery*3) + (skill_mastery);
	1541	status->int_ += (undead_mastery*3) + (skill_mastery);
	1542	status->vit += (undead_mastery*3) + (skill_mastery);
	1543	status->luk += (undead_mastery*3) + (skill_mastery);
	1544	status->rhw.atk += (undead_mastery3) + (skill_mastery3)
	1545	+ (status->str+((status->str/10)*(status->str/10))+(status->dex/5)+(status->luk/10));
	1546	status->rhw.atk2 += (undead_mastery3) + (skill_mastery3)
	1547	+ (status->str+((status->str/10)*(status->str/10))+(status->dex/5)+(status->luk/10));
	1548	status->speed -= undead_mastery;
	1549	status->def += undead_mastery;
	1550	status->mdef += undead_mastery;
	1551	//These are not automatically recalculated
	1552	status->hit += (undead_mastery*3) + (skill_mastery);
	1553	status->flee += (undead_mastery*3) + (skill_mastery);
	1554	status->def2 += (undead_mastery*3) + (skill_mastery);
	1555	status->mdef2 += (undead_mastery*3) + (skill_mastery);
	1556	}
	1557	}
	1558	else ShowError("status_calc_mob: Monster summoned without a master at %s\n", map[md->bl.m].name);
[10]	1559	}
	1560	//Custom Job End
	1561
[1]	1562	//Initial battle status
	1563	if (!first)
	1564	status_calc_bl(&md->bl, SCB_ALL);
	1565	else
	1566	memcpy(&md->status, status, sizeof(struct status_data));
	1567	return 1;
	1568	}
	1569
	1570	//Skotlex: Calculates the stats of the given pet.
	1571	int status_calc_pet(struct pet_data *pd, int first)
	1572	{
	1573	nullpo_retr(0, pd);
	1574
	1575	if (first) {
	1576	memcpy(&pd->status, &pd->db->status, sizeof(struct status_data));
	1577	pd->status.mode\|= MD_CANMOVE; //so they can chase their master!
	1578	pd->status.speed = pd->petDB->speed;
	1579	}
	1580
	1581	if (battle_config.pet_lv_rate && pd->msd)
	1582	{
	1583	struct map_session_data *sd = pd->msd;
	1584	int lv;
	1585
	1586	lv =sd->status.base_level*battle_config.pet_lv_rate/100;
	1587	if (lv < 0)
	1588	lv = 1;
	1589	if (lv != pd->pet.level \|\| first)
	1590	{
	1591	struct status_data bstat = &pd->db->status, status = &pd->status;
	1592	pd->pet.level = lv;
	1593	if (!first) //Lv Up animation
	1594	clif_misceffect(&pd->bl, 0);
	1595	status->rhw.atk = (bstat->rhw.atk*lv)/pd->db->lv;
	1596	status->rhw.atk2 = (bstat->rhw.atk2*lv)/pd->db->lv;
	1597	status->str = (bstat->str*lv)/pd->db->lv;
	1598	status->agi = (bstat->agi*lv)/pd->db->lv;
	1599	status->vit = (bstat->vit*lv)/pd->db->lv;
	1600	status->int_ = (bstat->int_*lv)/pd->db->lv;
	1601	status->dex = (bstat->dex*lv)/pd->db->lv;
	1602	status->luk = (bstat->luk*lv)/pd->db->lv;
	1603
	1604	status->rhw.atk = cap_value(status->rhw.atk, 1, battle_config.pet_max_atk1);
	1605	status->rhw.atk2 = cap_value(status->rhw.atk2, 2, battle_config.pet_max_atk2);
	1606	status->str = cap_value(status->str,1,battle_config.pet_max_stats);
	1607	status->agi = cap_value(status->agi,1,battle_config.pet_max_stats);
	1608	status->vit = cap_value(status->vit,1,battle_config.pet_max_stats);
	1609	status->int_= cap_value(status->int_,1,battle_config.pet_max_stats);
	1610	status->dex = cap_value(status->dex,1,battle_config.pet_max_stats);
	1611	status->luk = cap_value(status->luk,1,battle_config.pet_max_stats);
	1612
	1613	status_calc_misc(&pd->bl, &pd->status, lv);
	1614
	1615	if (!first) //Not done the first time because the pet is not visible yet
	1616	clif_send_petstatus(sd);
	1617	}
	1618	} else if (first) {
	1619	status_calc_misc(&pd->bl, &pd->status, pd->db->lv);
	1620	if (!battle_config.pet_lv_rate && pd->pet.level != pd->db->lv)
	1621	pd->pet.level = pd->db->lv;
	1622	}
	1623
	1624	//Support rate modifier (1000 = 100%)
	1625	pd->rate_fix = 1000*(pd->pet.intimate - battle_config.pet_support_min_friendly)/(1000- battle_config.pet_support_min_friendly) +500;
	1626	if(battle_config.pet_support_rate != 100)
	1627	pd->rate_fix = pd->rate_fix*battle_config.pet_support_rate/100;
	1628	return 1;
	1629	}
	1630
	1631	/// Helper function for status_base_pc_maxhp(), used to pre-calculate the hp_sigma_val[] array
	1632	static void status_calc_sigma(void)
	1633	{
	1634	int i,j;
	1635
	1636	for(i = 0; i < CLASS_COUNT; i++)
	1637	{
	1638	unsigned int k = 0;
	1639	hp_sigma_val[i][0] = hp_sigma_val[i][1] = 0;
	1640	for(j = 2; j <= MAX_LEVEL; j++)
	1641	{
	1642	k += (hp_coefficient[i]*j + 50) / 100;
	1643	hp_sigma_val[i][j] = k;
	1644	if (k >= INT_MAX)
	1645	break; //Overflow protection. [Skotlex]
	1646	}
	1647	for(; j <= MAX_LEVEL; j++)
	1648	hp_sigma_val[i][j] = INT_MAX;
	1649	}
	1650	}
	1651
	1652	/// Calculates base MaxHP value according to class and base level
	1653	/// The recursive equation used to calculate level bonus is (using integer operations)
	1654	/// f(0) = 35 \| f(x+1) = f(x) + A + (x + B)*C/D
	1655	/// which reduces to something close to
	1656	/// f(x) = 35 + x(A + BC/D) + sum(i=2..x){ i*C/D }
	1657	static unsigned int status_base_pc_maxhp(struct map_session_data* sd, struct status_data* status)
	1658	{
	1659	unsigned int val = pc_class2idx(sd->status.class_);
	1660	val = 35 + sd->status.base_level*hp_coefficient2[val]/100 + hp_sigma_val[val][sd->status.base_level];
	1661
	1662	if((sd->class_&MAPID_UPPERMASK) == MAPID_NINJA \|\| (sd->class_&MAPID_UPPERMASK) == MAPID_GUNSLINGER)
	1663	val += 100; //Since their HP can't be approximated well enough without this.
	1664	if((sd->class_&MAPID_UPPERMASK) == MAPID_TAEKWON && sd->status.base_level >= 90 && pc_famerank(sd->status.char_id, MAPID_TAEKWON))
	1665	val *= 3; //Triple max HP for top ranking Taekwons over level 90.
	1666	if((sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE && sd->status.base_level >= 99)
	1667	val += 2000; //Supernovice lvl99 hp bonus.
	1668
	1669	val += val * status->vit/100; // +1% per each point of VIT
	1670
	1671	if (sd->class_&JOBL_UPPER)
	1672	val += val * 25/100; //Trans classes get a 25% hp bonus
	1673	else if (sd->class_&JOBL_BABY)
	1674	val -= val * 30/100; //Baby classes get a 30% hp penalty
	1675	return val;
	1676	}
	1677
	1678	static unsigned int status_base_pc_maxsp(struct map_session_data* sd, struct status_data *status)
	1679	{
	1680	unsigned int val;
	1681
	1682	val = 10 + sd->status.base_level*sp_coefficient[pc_class2idx(sd->status.class_)]/100;
	1683	val += val * status->int_/100;
	1684
	1685	if (sd->class_&JOBL_UPPER)
	1686	val += val * 25/100;
	1687	else if (sd->class_&JOBL_BABY)
	1688	val -= val * 30/100;
	1689	if ((sd->class_&MAPID_UPPERMASK) == MAPID_TAEKWON && sd->status.base_level >= 90 && pc_famerank(sd->status.char_id, MAPID_TAEKWON))
	1690	val *= 3; //Triple max SP for top ranking Taekwons over level 90.
	1691
	1692	return val;
	1693	}
	1694
	1695
	1696	//Calculates player data from scratch without counting SC adjustments.
	1697	//Should be invoked whenever players raise stats, learn passive skills or change equipment.
	1698	int status_calc_pc(struct map_session_data* sd,int first)
	1699	{
	1700	static int calculating = 0; //Check for recursive call preemption. [Skotlex]
	1701	struct status_data b_status, *status;
	1702	const struct status_change *sc = &sd->sc;
	1703	struct skill b_skill[MAX_SKILL];
	1704
	1705	int b_weight,b_max_weight;
	1706	int i,index;
	1707	int skill,refinedef=0;
	1708
	1709	if (++calculating > 10) //Too many recursive calls!
	1710	return -1;
	1711
	1712	memcpy(&b_status, &sd->battle_status, sizeof(struct status_data));
	1713	memcpy(b_skill,&sd->status.skill,sizeof(b_skill));
	1714	b_weight = sd->weight;
	1715	b_max_weight = sd->max_weight;
	1716
	1717	pc_calc_skilltree(sd); // XLc?ÌvZ
	1718
	1719	sd->max_weight = max_weight_base[pc_class2idx(sd->status.class_)]+sd->status.str*300;
	1720
	1721	if(first&1) {
	1722	//Load Hp/SP from char-received data.
	1723	sd->battle_status.hp = sd->status.hp;
	1724	sd->battle_status.sp = sd->status.sp;
	1725	sd->regen.sregen = &sd->sregen;
	1726	sd->regen.ssregen = &sd->ssregen;
	1727	sd->weight=0;
	1728	for(i=0;i<MAX_INVENTORY;i++){
	1729	if(sd->status.inventory[i].nameid==0 \|\| sd->inventory_data[i] == NULL)
	1730	continue;
	1731	sd->weight += sd->inventory_data[i]->weight*sd->status.inventory[i].amount;
	1732	}
	1733	sd->cart_weight=0;
	1734	sd->cart_num=0;
	1735	for(i=0;i<MAX_CART;i++){
	1736	if(sd->status.cart[i].nameid==0)
	1737	continue;
	1738	sd->cart_weight+=itemdb_weight(sd->status.cart[i].nameid)*sd->status.cart[i].amount;
	1739	sd->cart_num++;
	1740	}
	1741	}
	1742
	1743	status = &sd->base_status;
	1744	// these are not zeroed. [zzo]
	1745	sd->hprate=100;
	1746	sd->sprate=100;
	1747	sd->castrate=100;
	1748	sd->delayrate=100;
	1749	sd->dsprate=100;
	1750	sd->speed_rate = 100;
	1751	sd->hprecov_rate = 100;
	1752	sd->sprecov_rate = 100;
	1753	sd->atk_rate = sd->matk_rate = 100;
	1754	sd->critical_rate = sd->hit_rate = sd->flee_rate = sd->flee2_rate = 100;
	1755	sd->def_rate = sd->def2_rate = sd->mdef_rate = sd->mdef2_rate = 100;
	1756	sd->regen.state.block = 0;
	1757
	1758	// zeroed arrays, order follows the order in map.h.
	1759	// add new arrays to the end of zeroed area in map.h (see comments) and size here. [zzo]
	1760	memset (sd->param_bonus, 0, sizeof(sd->param_bonus)
	1761	+ sizeof(sd->param_equip)
	1762	+ sizeof(sd->subele)
	1763	+ sizeof(sd->subrace)
	1764	+ sizeof(sd->subrace2)
	1765	+ sizeof(sd->subsize)
	1766	+ sizeof(sd->reseff)
	1767	+ sizeof(sd->weapon_coma_ele)
	1768	+ sizeof(sd->weapon_coma_race)
	1769	+ sizeof(sd->weapon_atk)
	1770	+ sizeof(sd->weapon_atk_rate)
	1771	+ sizeof(sd->arrow_addele)
	1772	+ sizeof(sd->arrow_addrace)
	1773	+ sizeof(sd->arrow_addsize)
	1774	+ sizeof(sd->magic_addele)
	1775	+ sizeof(sd->magic_addrace)
	1776	+ sizeof(sd->magic_addsize)
	1777	+ sizeof(sd->critaddrace)
	1778	+ sizeof(sd->expaddrace)
	1779	+ sizeof(sd->ignore_mdef)
	1780	+ sizeof(sd->itemgrouphealrate)
	1781	+ sizeof(sd->sp_gain_race)
	1782	);
	1783
	1784	memset (&sd->right_weapon.overrefine, 0, sizeof(sd->right_weapon) - sizeof(sd->right_weapon.atkmods));
	1785	memset (&sd->left_weapon.overrefine, 0, sizeof(sd->left_weapon) - sizeof(sd->left_weapon.atkmods));
	1786
	1787	if (sd->special_state.intravision) //Clear status change.
	1788	clif_status_load(&sd->bl, SI_INTRAVISION, 0);
	1789
	1790	memset(&sd->special_state,0,sizeof(sd->special_state));
	1791	memset(&status->max_hp, 0, sizeof(struct status_data)-(sizeof(status->hp)+sizeof(status->sp)));
	1792
	1793	//FIXME: Most of these stuff should be calculated once, but how do I fix the memset above to do that? [Skotlex]
	1794	status->speed = DEFAULT_WALK_SPEED;
	1795	//Give them all modes except these (useful for clones)
	1796	status->mode = MD_MASK&~(MD_BOSS\|MD_PLANT\|MD_DETECTOR\|MD_ANGRY);
	1797
	1798	status->size = (sd->class_&JOBL_BABY)?0:1;
	1799	if (battle_config.character_size && pc_isriding(sd)) { //[Lupus]
	1800	if (sd->class_&JOBL_BABY) {
	1801	if (battle_config.character_size&2)
	1802	status->size++;
	1803	} else
	1804	if(battle_config.character_size&1)
	1805	status->size++;
	1806	}
	1807	status->aspd_rate = 1000;
	1808	status->ele_lv = 1;
[10]	1809	//Custom Jobs (blackmagic)
[13]	1810	status->race = RC_DEMIHUMAN;// This define players default race to DEMIHUMAN [Brain]
	1811	if(pc_checkskill(sd,NC_PHYLACTERY)>0) status->def_ele = ELE_UNDEAD; //Phylactery turns you UNDEAD 1 instead of NEUTRAL
[10]	1812	//Custom Job End
[1]	1813
[10]	1814
[1]	1815	//zero up structures...
	1816	memset(&sd->autospell,0,sizeof(sd->autospell)
	1817	+ sizeof(sd->autospell2)
	1818	+ sizeof(sd->addeff)
	1819	+ sizeof(sd->addeff2)
	1820	+ sizeof(sd->skillatk)
	1821	+ sizeof(sd->skillheal)
	1822	+ sizeof(sd->hp_loss)
	1823	+ sizeof(sd->sp_loss)
	1824	+ sizeof(sd->hp_regen)
	1825	+ sizeof(sd->sp_regen)
	1826	+ sizeof(sd->skillblown)
	1827	+ sizeof(sd->skillcast)
	1828	+ sizeof(sd->add_def)
	1829	+ sizeof(sd->add_mdef)
	1830	+ sizeof(sd->add_mdmg)
	1831	+ sizeof(sd->add_drop)
	1832	+ sizeof(sd->itemhealrate)
	1833	);
	1834	// clear autoscripts...
	1835	pc_autoscript_clear(sd->autoscript, ARRAYLENGTH(sd->autoscript));
	1836	pc_autoscript_clear(sd->autoscript2, ARRAYLENGTH(sd->autoscript2));
	1837
	1838	// vars zeroing. ints, shorts, chars. in that order.
	1839	memset (&sd->arrow_atk, 0,sizeof(sd->arrow_atk)
	1840	+ sizeof(sd->arrow_ele)
	1841	+ sizeof(sd->arrow_cri)
	1842	+ sizeof(sd->arrow_hit)
	1843	+ sizeof(sd->nsshealhp)
	1844	+ sizeof(sd->nsshealsp)
	1845	+ sizeof(sd->critical_def)
	1846	+ sizeof(sd->double_rate)
	1847	+ sizeof(sd->long_attack_atk_rate)
	1848	+ sizeof(sd->near_attack_def_rate)
	1849	+ sizeof(sd->long_attack_def_rate)
	1850	+ sizeof(sd->magic_def_rate)
	1851	+ sizeof(sd->misc_def_rate)
	1852	+ sizeof(sd->ignore_mdef_ele)
	1853	+ sizeof(sd->ignore_mdef_race)
	1854	+ sizeof(sd->perfect_hit)
	1855	+ sizeof(sd->perfect_hit_add)
	1856	+ sizeof(sd->get_zeny_rate)
	1857	+ sizeof(sd->get_zeny_num)
	1858	+ sizeof(sd->double_add_rate)
	1859	+ sizeof(sd->short_weapon_damage_return)
	1860	+ sizeof(sd->long_weapon_damage_return)
	1861	+ sizeof(sd->magic_damage_return)
	1862	+ sizeof(sd->random_attack_increase_add)
	1863	+ sizeof(sd->random_attack_increase_per)
	1864	+ sizeof(sd->break_weapon_rate)
	1865	+ sizeof(sd->break_armor_rate)
	1866	+ sizeof(sd->crit_atk_rate)
	1867	+ sizeof(sd->classchange)
	1868	+ sizeof(sd->speed_add_rate)
	1869	+ sizeof(sd->aspd_add)
	1870	+ sizeof(sd->setitem_hash)
	1871	+ sizeof(sd->setitem_hash2)
	1872	// shorts
	1873	+ sizeof(sd->splash_range)
	1874	+ sizeof(sd->splash_add_range)
	1875	+ sizeof(sd->hp_gain_value)
	1876	+ sizeof(sd->sp_gain_value)
	1877	+ sizeof(sd->sp_vanish_rate)
	1878	+ sizeof(sd->sp_vanish_per)
	1879	+ sizeof(sd->unbreakable)
	1880	+ sizeof(sd->unbreakable_equip)
	1881	+ sizeof(sd->unstripable_equip)
	1882	);
	1883
	1884	// Parse equipment.
	1885	for(i=0;i<EQI_MAX-1;i++) {
	1886	current_equip_item_index = index = sd->equip_index[i]; //We pass INDEX to current_equip_item_index - for EQUIP_SCRIPT (new cards solution) [Lupus]
	1887	if(index < 0)
	1888	continue;
	1889	if(i == EQI_HAND_R && sd->equip_index[EQI_HAND_L] == index)
	1890	continue;
	1891	if(i == EQI_HEAD_MID && sd->equip_index[EQI_HEAD_LOW] == index)
	1892	continue;
	1893	if(i == EQI_HEAD_TOP && (sd->equip_index[EQI_HEAD_MID] == index \|\| sd->equip_index[EQI_HEAD_LOW] == index))
	1894	continue;
	1895	if(!sd->inventory_data[index])
	1896	continue;
	1897
	1898	status->def += sd->inventory_data[index]->def;
	1899
	1900	if(first&1 && sd->inventory_data[index]->equip_script)
	1901	{ //Execute equip-script on login
	1902	run_script(sd->inventory_data[index]->equip_script,0,sd->bl.id,0);
	1903	if (!calculating)
	1904	return 1;
	1905	}
	1906
	1907	if(sd->inventory_data[index]->type == IT_WEAPON) {
	1908	int r,wlv = sd->inventory_data[index]->wlv;
	1909	struct weapon_data *wd;
	1910	struct weapon_atk *wa;
	1911
	1912	if (wlv >= MAX_REFINE_BONUS)
	1913	wlv = MAX_REFINE_BONUS - 1;
	1914	if(i == EQI_HAND_L && sd->status.inventory[index].equip == EQP_HAND_L) {
	1915	wd = &sd->left_weapon; // Left-hand weapon
	1916	wa = &status->lhw;
	1917	} else {
	1918	wd = &sd->right_weapon;
	1919	wa = &status->rhw;
	1920	}
	1921	wa->atk += sd->inventory_data[index]->atk;
	1922	wa->atk2 = (r=sd->status.inventory[index].refine)*refinebonus[wlv][0];
	1923	if((r-=refinebonus[wlv][2])>0) //Overrefine bonus.
	1924	wd->overrefine = r*refinebonus[wlv][1];
	1925
	1926	wa->range += sd->inventory_data[index]->range;
	1927	if(sd->inventory_data[index]->script) {
	1928	if (wd == &sd->left_weapon) {
	1929	sd->state.lr_flag = 1;
	1930	run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
	1931	sd->state.lr_flag = 0;
	1932	} else
	1933	run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
	1934	if (!calculating) //Abort, run_script retriggered this. [Skotlex]
	1935	return 1;
	1936	}
	1937
	1938	if(sd->status.inventory[index].card[0]==CARD0_FORGE)
	1939	{ // Forged weapon
	1940	wd->star += (sd->status.inventory[index].card[1]>>8);
	1941	if(wd->star >= 15) wd->star = 40; // 3 Star Crumbs now give +40 dmg
	1942	if(pc_famerank(MakeDWord(sd->status.inventory[index].card[2],sd->status.inventory[index].card[3]) ,MAPID_BLACKSMITH))
	1943	wd->star += 10;
	1944
	1945	if (!wa->ele) //Do not overwrite element from previous bonuses.
	1946	wa->ele = (sd->status.inventory[index].card[1]&0x0f);
	1947	}
	1948	}
	1949	else if(sd->inventory_data[index]->type == IT_ARMOR) {
	1950	refinedef += sd->status.inventory[index].refine*refinebonus[0][0];
	1951	if(sd->inventory_data[index]->script) {
	1952	run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
	1953	if (!calculating) //Abort, run_script retriggered this. [Skotlex]
	1954	return 1;
	1955	}
	1956	}
	1957	}
	1958
	1959	if(sd->equip_index[EQI_AMMO] >= 0){
	1960	index = sd->equip_index[EQI_AMMO];
	1961	if(sd->inventory_data[index]){ // Arrows
	1962	sd->arrow_atk += sd->inventory_data[index]->atk;
	1963	sd->state.lr_flag = 2;
	1964	run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
	1965	sd->state.lr_flag = 0;
	1966	if (!calculating) //Abort, run_script retriggered status_calc_pc. [Skotlex]
	1967	return 1;
	1968	}
	1969	}
	1970
	1971	//Store equipment script bonuses
	1972	memcpy(sd->param_equip,sd->param_bonus,sizeof(sd->param_equip));
	1973	memset(sd->param_bonus, 0, sizeof(sd->param_bonus));
	1974
	1975	status->def += (refinedef+50)/100;
	1976
	1977	//Parse Cards
	1978	for(i=0;i<EQI_MAX-1;i++) {
	1979	current_equip_item_index = index = sd->equip_index[i]; //We pass INDEX to current_equip_item_index - for EQUIP_SCRIPT (new cards solution) [Lupus]
	1980	if(index < 0)
	1981	continue;
	1982	if(i == EQI_HAND_R && sd->equip_index[EQI_HAND_L] == index)
	1983	continue;
	1984	if(i == EQI_HEAD_MID && sd->equip_index[EQI_HEAD_LOW] == index)
	1985	continue;
	1986	if(i == EQI_HEAD_TOP && (sd->equip_index[EQI_HEAD_MID] == index \|\| sd->equip_index[EQI_HEAD_LOW] == index))
	1987	continue;
	1988
	1989	if(sd->inventory_data[index]) {
	1990	int j,c;
	1991	struct item_data *data;
	1992
	1993	//Card script execution.
	1994	if(itemdb_isspecial(sd->status.inventory[index].card[0]))
	1995	continue;
	1996	for(j=0;j<sd->inventory_data[index]->slot;j++){
	1997	current_equip_card_id= c= sd->status.inventory[index].card[j];
	1998	if(!c)
	1999	continue;
	2000	data = itemdb_exists(c);
	2001	if(!data)
	2002	continue;
	2003	if(first&1 && data->equip_script)
	2004	{ //Execute equip-script on login
	2005	run_script(data->equip_script,0,sd->bl.id,0);
	2006	if (!calculating)
	2007	return 1;
	2008	}
	2009	if(!data->script)
	2010	continue;
	2011	if(data->flag.no_equip) { //Card restriction checks.
	2012	if(map[sd->bl.m].flag.restricted && data->flag.no_equip&map[sd->bl.m].zone)
	2013	continue;
	2014	if(map[sd->bl.m].flag.pvp && data->flag.no_equip&1)
	2015	continue;
	2016	if(map_flag_gvg(sd->bl.m) && data->flag.no_equip&2)
	2017	continue;
	2018	}
	2019	if(i == EQI_HAND_L && sd->status.inventory[index].equip == EQP_HAND_L)
	2020	{ //Left hand status.
	2021	sd->state.lr_flag = 1;
	2022	run_script(data->script,0,sd->bl.id,0);
	2023	sd->state.lr_flag = 0;
	2024	} else
	2025	run_script(data->script,0,sd->bl.id,0);
	2026	if (!calculating) //Abort, run_script his function. [Skotlex]
	2027	return 1;
	2028	}
	2029	}
	2030	}
	2031
	2032	if(sd->pd && battle_config.pet_status_support)
	2033	{ // Pet
	2034	struct pet_data *pd=sd->pd;
	2035	if(pd && pd->pet.intimate > 0 &&
	2036	(!battle_config.pet_equip_required \|\| pd->pet.equip > 0) &&
	2037	pd->state.skillbonus == 1 && pd->bonus) //Skotlex: Readjusted for pets
	2038	pc_bonus(sd,pd->bonus->type, pd->bonus->val);
	2039	}
	2040	//param_bonus now holds card bonuses.
	2041
	2042	if(status->rhw.range < 1) status->rhw.range = 1;
	2043	if(status->lhw.range < 1) status->lhw.range = 1;
	2044	if(status->rhw.range < status->lhw.range)
	2045	status->rhw.range = status->lhw.range;
	2046
	2047	sd->double_rate += sd->double_add_rate;
	2048	sd->perfect_hit += sd->perfect_hit_add;
	2049	sd->splash_range += sd->splash_add_range;
	2050	if(sd->speed_add_rate)
	2051	sd->speed_rate += sd->speed_add_rate;
	2052
	2053	// Damage modifiers from weapon type
	2054	sd->right_weapon.atkmods[0] = atkmods[0][sd->weapontype1];
	2055	sd->right_weapon.atkmods[1] = atkmods[1][sd->weapontype1];
	2056	sd->right_weapon.atkmods[2] = atkmods[2][sd->weapontype1];
	2057	sd->left_weapon.atkmods[0] = atkmods[0][sd->weapontype2];
	2058	sd->left_weapon.atkmods[1] = atkmods[1][sd->weapontype2];
	2059	sd->left_weapon.atkmods[2] = atkmods[2][sd->weapontype2];
	2060
	2061	if(pc_isriding(sd) &&
	2062	(sd->status.weapon==W_1HSPEAR \|\| sd->status.weapon==W_2HSPEAR))
	2063	{ //When Riding with spear, damage modifier to mid-class becomes
	2064	//same as versus large size.
	2065	sd->right_weapon.atkmods[1] = sd->right_weapon.atkmods[2];
	2066	sd->left_weapon.atkmods[1] = sd->left_weapon.atkmods[2];
	2067	}
	2068
	2069	// ----- STATS CALCULATION -----
	2070
	2071	// Job bonuses
	2072	index = pc_class2idx(sd->status.class_);
	2073	for(i=0;i<(int)sd->status.job_level && i<MAX_LEVEL;i++){
	2074	if(!job_bonus[index][i])
	2075	continue;
	2076	switch(job_bonus[index][i]) {
	2077	case 1: status->str++; break;
	2078	case 2: status->agi++; break;
	2079	case 3: status->vit++; break;
	2080	case 4: status->int_++; break;
	2081	case 5: status->dex++; break;
	2082	case 6: status->luk++; break;
	2083	}
	2084	}
	2085
	2086	// If a Super Novice has never died and is at least joblv 70, he gets all stats +10
	2087	if((sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE && sd->die_counter == 0 && sd->status.job_level >= 70){
	2088	status->str += 10;
	2089	status->agi += 10;
	2090	status->vit += 10;
	2091	status->int_+= 10;
	2092	status->dex += 10;
	2093	status->luk += 10;
	2094	}
	2095
	2096	// Absolute modifiers from passive skills
	2097	if(pc_checkskill(sd,BS_HILTBINDING)>0)
	2098	status->str++;
	2099	if((skill=pc_checkskill(sd,SA_DRAGONOLOGY))>0)
	2100	status->int_ += (skill+1)/2; // +1 INT / 2 lv
	2101	if((skill=pc_checkskill(sd,AC_OWL))>0)
	2102	status->dex += skill;
	2103
[10]	2104	//Custom Jobs (blackmagic)
[13]	2105
	2106	if((skill=pc_checkskill(sd,WL_DEMONOLOGY))>0) //Warlock Demonology [Brain]
[10]	2107	status->str += skill/2; //+1 str per 2 skill points
	2108	//Custom Job End
	2109
[1]	2110	// Bonuses from cards and equipment as well as base stat, remember to avoid overflows.
	2111	i = status->str + sd->status.str + sd->param_bonus[0] + sd->param_equip[0];
	2112	status->str = cap_value(i,0,USHRT_MAX);
	2113	i = status->agi + sd->status.agi + sd->param_bonus[1] + sd->param_equip[1];
	2114	status->agi = cap_value(i,0,USHRT_MAX);
	2115	i = status->vit + sd->status.vit + sd->param_bonus[2] + sd->param_equip[2];
	2116	status->vit = cap_value(i,0,USHRT_MAX);
	2117	i = status->int_+ sd->status.int_+ sd->param_bonus[3] + sd->param_equip[3];
	2118	status->int_ = cap_value(i,0,USHRT_MAX);
	2119	i = status->dex + sd->status.dex + sd->param_bonus[4] + sd->param_equip[4];
	2120	status->dex = cap_value(i,0,USHRT_MAX);
	2121	i = status->luk + sd->status.luk + sd->param_bonus[5] + sd->param_equip[5];
	2122	status->luk = cap_value(i,0,USHRT_MAX);
	2123
	2124	// ------ BASE ATTACK CALCULATION ------
	2125
	2126	// Base batk value is set on status_calc_misc
	2127	// weapon-type bonus (FIXME: Why is the weapon_atk bonus applied to base attack?)
	2128	if (sd->status.weapon < MAX_WEAPON_TYPE && sd->weapon_atk[sd->status.weapon])
	2129	status->batk += sd->weapon_atk[sd->status.weapon];
	2130	// Absolute modifiers from passive skills
	2131	if((skill=pc_checkskill(sd,BS_HILTBINDING))>0)
	2132	status->batk += 4;
	2133
	2134	// ----- HP MAX CALCULATION -----
	2135
	2136	// Basic MaxHP value
	2137	//We hold the standard Max HP here to make it faster to recalculate on vit changes.
	2138	sd->status.max_hp = status_base_pc_maxhp(sd,status);
	2139	//This is done to handle underflows from negative Max HP bonuses
	2140	i = sd->status.max_hp + (int)status->max_hp;
	2141	status->max_hp = cap_value(i, 0, INT_MAX);
	2142
	2143	// Absolute modifiers from passive skills
	2144	if((skill=pc_checkskill(sd,CR_TRUST))>0)
	2145	status->max_hp += skill*200;
	2146
[10]	2147	//Custom Jobs (blackmagic)
[13]	2148	if((skill=pc_checkskill(sd,AD_PROFANE))>0) // Adept Profane Soul [Brain]
[10]	2149	status->max_hp += status->max_hp * (skill*3)/100;
	2150	//Custom Job End
	2151
[1]	2152	// Apply relative modifiers from equipment
	2153	if(sd->hprate < 0)
	2154	sd->hprate = 0;
	2155	if(sd->hprate!=100)
	2156	status->max_hp = status->max_hp * sd->hprate/100;
	2157	if(battle_config.hp_rate != 100)
	2158	status->max_hp = status->max_hp * battle_config.hp_rate/100;
	2159
	2160	if(status->max_hp > (unsigned int)battle_config.max_hp)
	2161	status->max_hp = battle_config.max_hp;
	2162	else if(!status->max_hp)
	2163	status->max_hp = 1;
	2164
	2165	// ----- SP MAX CALCULATION -----
	2166
	2167	// Basic MaxSP value
	2168	sd->status.max_sp = status_base_pc_maxsp(sd,status);
	2169	//This is done to handle underflows from negative Max SP bonuses
	2170	i = sd->status.max_sp + (int)status->max_sp;
	2171	status->max_sp = cap_value(i, 0, INT_MAX);
	2172
	2173	// Absolute modifiers from passive skills
	2174	if((skill=pc_checkskill(sd,SL_KAINA))>0)
	2175	status->max_sp += 30*skill;
	2176	if((skill=pc_checkskill(sd,HP_MEDITATIO))>0)
	2177	status->max_sp += status->max_sp * skill/100;
	2178	if((skill=pc_checkskill(sd,HW_SOULDRAIN))>0)
	2179	status->max_sp += status->max_sp * 2*skill/100;
	2180
[10]	2181	//Custom Jobs (blackmagic)
[13]	2182	if((skill=pc_checkskill(sd,AD_PROFANE))>0) // Adept Profane Soul [Brain]
[10]	2183	status->max_sp += sd->status.max_sp * (skill*3)/100;
	2184	//Custom Job End
	2185
[1]	2186	// Apply relative modifiers from equipment
	2187	if(sd->sprate < 0)
	2188	sd->sprate = 0;
	2189	if(sd->sprate!=100)
	2190	status->max_sp = status->max_sp * sd->sprate/100;
	2191	if(battle_config.sp_rate != 100)
	2192	status->max_sp = status->max_sp * battle_config.sp_rate/100;
	2193
	2194	if(status->max_sp > (unsigned int)battle_config.max_sp)
	2195	status->max_sp = battle_config.max_sp;
	2196	else if(!status->max_sp)
	2197	status->max_sp = 1;
	2198
	2199	// ----- RESPAWN HP/SP -----
	2200	//
	2201	//Calc respawn hp and store it on base_status
	2202	if (sd->special_state.restart_full_recover)
	2203	{
	2204	status->hp = status->max_hp;
	2205	status->sp = status->max_sp;
	2206	} else {
	2207	if((sd->class_&MAPID_BASEMASK) == MAPID_NOVICE && !(sd->class_&JOBL_2)
	2208	&& battle_config.restart_hp_rate < 50)
	2209	status->hp=status->max_hp>>1;
	2210	else
	2211	status->hp=status->max_hp * battle_config.restart_hp_rate/100;
	2212	if(!status->hp)
	2213	status->hp = 1;
	2214
	2215	status->sp = status->max_sp * battle_config.restart_sp_rate /100;
	2216	}
	2217
	2218	// ----- MISC CALCULATION -----
	2219	status_calc_misc(&sd->bl, status, sd->status.base_level);
	2220
	2221	//Equipment modifiers for misc settings
	2222	if(sd->matk_rate < 0)
	2223	sd->matk_rate = 0;
	2224	if(sd->matk_rate != 100){
	2225	status->matk_max = status->matk_max * sd->matk_rate/100;
	2226	status->matk_min = status->matk_min * sd->matk_rate/100;
	2227	}
	2228
	2229	if(sd->hit_rate < 0)
	2230	sd->hit_rate = 0;
	2231	if(sd->hit_rate != 100)
	2232	status->hit = status->hit * sd->hit_rate/100;
	2233
	2234	if(sd->flee_rate < 0)
	2235	sd->flee_rate = 0;
	2236	if(sd->flee_rate != 100)
	2237	status->flee = status->flee * sd->flee_rate/100;
	2238
	2239	if(sd->def2_rate < 0)
	2240	sd->def2_rate = 0;
	2241	if(sd->def2_rate != 100)
	2242	status->def2 = status->def2 * sd->def2_rate/100;
	2243
	2244	if(sd->mdef2_rate < 0)
	2245	sd->mdef2_rate = 0;
	2246	if(sd->mdef2_rate != 100)
	2247	status->mdef2 = status->mdef2 * sd->mdef2_rate/100;
	2248
	2249	if(sd->critical_rate < 0)
	2250	sd->critical_rate = 0;
	2251	if(sd->critical_rate != 100)
	2252	status->cri = status->cri * sd->critical_rate/100;
	2253
	2254	if(sd->flee2_rate < 0)
	2255	sd->flee2_rate = 0;
	2256	if(sd->flee2_rate != 100)
	2257	status->flee2 = status->flee2 * sd->flee2_rate/100;
	2258
	2259	// ----- HIT CALCULATION -----
	2260
	2261	// Absolute modifiers from passive skills
	2262	if((skill=pc_checkskill(sd,BS_WEAPONRESEARCH))>0)
	2263	status->hit += skill*2;
	2264	if((skill=pc_checkskill(sd,AC_VULTURE))>0){
	2265	status->hit += skill;
	2266	if(sd->status.weapon == W_BOW)
	2267	status->rhw.range += skill;
	2268	}
	2269	if(sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE)
	2270	{
	2271	if((skill=pc_checkskill(sd,GS_SINGLEACTION))>0)
	2272	status->hit += 2*skill;
	2273	if((skill=pc_checkskill(sd,GS_SNAKEEYE))>0) {
	2274	status->hit += skill;
	2275	status->rhw.range += skill;
	2276	}
	2277	}
	2278
[10]	2279	//Custom Jobs (blackmagic)
[13]	2280	if((skill=pc_checkskill(sd,AD_FERVOR))>0) // Adept Unholy Fevor [Brain]
[10]	2281	status->hit += skill*2;
	2282	//Custom Job End
	2283
[1]	2284	// ----- FLEE CALCULATION -----
	2285
	2286	// Absolute modifiers from passive skills
	2287	if((skill=pc_checkskill(sd,TF_MISS))>0)
	2288	status->flee += skill*(sd->class_&JOBL_2 && (sd->class_&MAPID_BASEMASK) == MAPID_THIEF? 4 : 3);
	2289	if((skill=pc_checkskill(sd,MO_DODGE))>0)
	2290	status->flee += (skill*3)>>1;
	2291
[10]	2292	//Custom Jobs (blackmagic)
[13]	2293	if((skill=pc_checkskill(sd,AD_FERVOR))>0) // Adept Unholy Fevor [Brain]
[10]	2294	status->flee += skill*2;
	2295	//Custom Job End
	2296
[1]	2297	// ----- EQUIPMENT-DEF CALCULATION -----
	2298
	2299	// Apply relative modifiers from equipment
	2300	if(sd->def_rate < 0)
	2301	sd->def_rate = 0;
	2302	if(sd->def_rate != 100) {
	2303	i = status->def * sd->def_rate/100;
	2304	status->def = cap_value(i, CHAR_MIN, CHAR_MAX);
	2305	}
[10]	2306	//Custom Jobs (blackmagic)
[13]	2307	// Absolute modifiers from passive skills
	2308	if((skill=pc_checkskill(sd,AD_DARKFAITH))>0) // Adept Dark Faith [Brain]
[10]	2309	status->mdef += 1*skill;
	2310	//Custom Job End
[1]	2311	if (!battle_config.weapon_defense_type && status->def > battle_config.max_def)
	2312	{
	2313	status->def2 += battle_config.over_def_bonus*(status->def -battle_config.max_def);
	2314	status->def = (unsigned char)battle_config.max_def;
	2315	}
	2316
	2317	// ----- EQUIPMENT-MDEF CALCULATION -----
	2318
	2319	// Apply relative modifiers from equipment
	2320	if(sd->mdef_rate < 0)
	2321	sd->mdef_rate = 0;
	2322	if(sd->mdef_rate != 100) {
	2323	i = status->mdef * sd->mdef_rate/100;
	2324	status->mdef = cap_value(i, CHAR_MIN, CHAR_MAX);
	2325	}
	2326
	2327	if (!battle_config.magic_defense_type && status->mdef > battle_config.max_def)
	2328	{
	2329	status->mdef2 += battle_config.over_def_bonus*(status->mdef -battle_config.max_def);
	2330	status->mdef = (signed char)battle_config.max_def;
	2331	}
	2332
	2333	// ----- WALKING SPEED CALCULATION -----
	2334
	2335	if(sd->speed_rate < 0)
	2336	sd->speed_rate = 0;
	2337	if(sd->speed_rate != 100)
	2338	status->speed = status->speed*sd->speed_rate/100;
	2339
	2340	// Relative modifiers from passive skills
	2341	if((sd->class_&MAPID_UPPERMASK) == MAPID_ASSASSIN && (skill=pc_checkskill(sd,TF_MISS))>0)
	2342	status->speed -= status->speed * skill/100;
	2343	if(pc_isriding(sd) && pc_checkskill(sd,KN_RIDING)>0)
	2344	status->speed -= status->speed * 25/100;
	2345	if(pc_iscarton(sd) && (skill=pc_checkskill(sd,MC_PUSHCART))>0)
	2346	status->speed += status->speed * (100-10*skill)/100;
	2347
	2348	if(status->speed < battle_config.max_walk_speed)
	2349	status->speed = battle_config.max_walk_speed;
	2350
	2351	// ----- ASPD CALCULATION -----
	2352	// Unlike other stats, ASPD rate modifiers from skills/SCs/items/etc are first all added together, then the final modifier is applied
	2353
	2354	// Basic ASPD value
	2355	i = status_base_amotion_pc(sd,status);
	2356	status->amotion = cap_value(i,battle_config.max_aspd,2000);
	2357
	2358	// Relative modifiers from passive skills
	2359	if((skill=pc_checkskill(sd,SA_ADVANCEDBOOK))>0 && sd->status.weapon == W_BOOK)
	2360	status->aspd_rate -= 5*skill;
	2361	if((skill = pc_checkskill(sd,SG_DEVIL)) > 0 && !pc_nextjobexp(sd))
	2362	status->aspd_rate -= 30*skill;
	2363	if((skill=pc_checkskill(sd,GS_SINGLEACTION))>0 &&
	2364	(sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE))
	2365	status->aspd_rate -= ((skill+1)/2) * 10;
	2366	if(pc_isriding(sd))
	2367	status->aspd_rate += 500-100*pc_checkskill(sd,KN_CAVALIERMASTERY);
	2368
	2369	status->adelay = 2*status->amotion;
	2370
	2371
	2372	// ----- DMOTION -----
	2373	//
	2374	i = 800-status->agi*4;
	2375	status->dmotion = cap_value(i, 400, 800);
	2376	if(battle_config.pc_damage_delay_rate != 100)
	2377	status->dmotion = status->dmotion*battle_config.pc_damage_delay_rate/100;
	2378
	2379	// ----- MISC CALCULATIONS -----
	2380
	2381	// Weight
	2382	if((skill=pc_checkskill(sd,MC_INCCARRY))>0)
	2383	sd->max_weight += 2000*skill;
	2384	if(pc_isriding(sd) && pc_checkskill(sd,KN_RIDING)>0)
	2385	sd->max_weight += 10000;
	2386	if(sc->data[SC_KNOWLEDGE])
	2387	sd->max_weight += sd->max_weight*sc->data[SC_KNOWLEDGE]->val1/10;
	2388	if((skill=pc_checkskill(sd,ALL_INCCARRY))>0)
	2389	sd->max_weight += 2000*skill;
	2390
	2391	if (pc_checkskill(sd,SM_MOVINGRECOVERY)>0)
	2392	sd->regen.state.walk = 1;
	2393	else
	2394	sd->regen.state.walk = 0;
	2395
	2396	// Skill SP cost
	2397	if((skill=pc_checkskill(sd,HP_MANARECHARGE))>0 )
	2398	sd->dsprate -= 4*skill;
	2399
	2400	if(sc->data[SC_SERVICE4U])
	2401	sd->dsprate -= sc->data[SC_SERVICE4U]->val3;
	2402
	2403	if(sc->data[SC_SPCOST_RATE])
	2404	sd->dsprate -= sc->data[SC_SPCOST_RATE]->val1;
	2405
	2406	//Underflow protections.
	2407	if(sd->dsprate < 0)
	2408	sd->dsprate = 0;
	2409	if(sd->castrate < 0)
	2410	sd->castrate = 0;
	2411	if(sd->delayrate < 0)
	2412	sd->delayrate = 0;
	2413	if(sd->hprecov_rate < 0)
	2414	sd->hprecov_rate = 0;
	2415	if(sd->sprecov_rate < 0)
	2416	sd->sprecov_rate = 0;
	2417
	2418	// Anti-element and anti-race
	2419	if((skill=pc_checkskill(sd,CR_TRUST))>0)
	2420	sd->subele[ELE_HOLY] += skill*5;
	2421	if((skill=pc_checkskill(sd,BS_SKINTEMPER))>0) {
	2422	sd->subele[ELE_NEUTRAL] += skill;
	2423	sd->subele[ELE_FIRE] += skill*4;
	2424	}
	2425	if((skill=pc_checkskill(sd,SA_DRAGONOLOGY))>0 ){
	2426	skill = skill*4;
	2427	sd->right_weapon.addrace[RC_DRAGON]+=skill;
	2428	sd->left_weapon.addrace[RC_DRAGON]+=skill;
	2429	sd->magic_addrace[RC_DRAGON]+=skill;
	2430	sd->subrace[RC_DRAGON]+=skill;
	2431	}
	2432
[10]	2433
	2434	//Custom Jobs (blackmagic)
[13]	2435	if((skill=pc_checkskill(sd,AD_DARKFAITH))>0) // Adept Dark Faith [Brain]
	2436	sd->subele[ELE_DARK] += skill*5;
	2437	if((skill=pc_checkskill(sd,WL_DEMONOLOGY))>0 ){ //Warlock Demonology [Brain]
	2438	skill = skill*5;
	2439	sd->right_weapon.addrace[RC_DEMON]+=skill;
	2440	sd->magic_addrace[RC_DEMON]+=skill;
	2441	sd->subrace[RC_DEMON]+=skill;
[10]	2442	}
[13]	2443	if((pc_checkskill(sd,NC_PHYLACTERY))>0){ // Necro Phylactery [Brain]
	2444	sd->subele[ELE_NEUTRAL] += 10; //And increases neutral resistance by 10%
	2445	}
[10]	2446	//Custom Job End
	2447
[1]	2448	if(sc->count){
	2449	if(sc->data[SC_CONCENTRATE])
	2450	{ //Update the card-bonus data
	2451	sc->data[SC_CONCENTRATE]->val3 = sd->param_bonus[1]; //Agi
	2452	sc->data[SC_CONCENTRATE]->val4 = sd->param_bonus[4]; //Dex
	2453	}
	2454	if(sc->data[SC_SIEGFRIED]){
	2455	i = sc->data[SC_SIEGFRIED]->val2;
	2456	sd->subele[ELE_WATER] += i;
	2457	sd->subele[ELE_EARTH] += i;
	2458	sd->subele[ELE_FIRE] += i;
	2459	sd->subele[ELE_WIND] += i;
	2460	sd->subele[ELE_POISON] += i;
	2461	sd->subele[ELE_HOLY] += i;
	2462	sd->subele[ELE_DARK] += i;
	2463	sd->subele[ELE_GHOST] += i;
	2464	sd->subele[ELE_UNDEAD] += i;
	2465	}
	2466	if(sc->data[SC_PROVIDENCE]){
	2467	sd->subele[ELE_HOLY] += sc->data[SC_PROVIDENCE]->val2;
	2468	sd->subrace[RC_DEMON] += sc->data[SC_PROVIDENCE]->val2;
	2469	}
[10]	2470
	2471	//Custom Jobs (blackmagic)
[13]	2472	if(sd->sc.data[SC_DEATHPACT]) //Necro Death Pact [Brain]
[10]	2473	sd->subele[ELE_NEUTRAL] += sd->sc.data[SC_DEATHPACT]->val2;
	2474	//Custom Job End
	2475
[1]	2476	if(sc->data[SC_ARMOR_ELEMENT])
	2477	{ //This status change should grant card-type elemental resist.
	2478	sd->subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT]->val1;
	2479	sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT]->val2;
	2480	sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT]->val3;
	2481	sd->subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT]->val4;
	2482	}
	2483	if(sc->data[SC_ARMOR_RESIST])
	2484	{ // Undead Scroll
	2485	sd->subele[ELE_WATER] += sc->data[SC_ARMOR_RESIST]->val1;
	2486	sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_RESIST]->val2;
	2487	sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_RESIST]->val3;
	2488	sd->subele[ELE_WIND] += sc->data[SC_ARMOR_RESIST]->val4;
	2489	}
	2490	}
	2491
	2492	status_cpy(&sd->battle_status, status);
	2493	status_calc_bl(&sd->bl, SCB_ALL); //Status related changes.
	2494	status = &sd->battle_status; //Need to compare versus this.
	2495
	2496	// ----- CLIENT-SIDE REFRESH -----
	2497	if(memcmp(b_skill,sd->status.skill,sizeof(sd->status.skill)))
	2498	clif_skillinfoblock(sd);
	2499	if(b_status.speed != status->speed)
	2500	clif_updatestatus(sd,SP_SPEED);
	2501	if(b_weight != sd->weight)
	2502	clif_updatestatus(sd,SP_WEIGHT);
	2503	if(b_max_weight != sd->max_weight) {
	2504	clif_updatestatus(sd,SP_MAXWEIGHT);
	2505	pc_updateweightstatus(sd);
	2506	}
	2507	if(b_status.str != status->str)
	2508	clif_updatestatus(sd,SP_STR);
	2509	if(b_status.agi != status->agi)
	2510	clif_updatestatus(sd,SP_AGI);
	2511	if(b_status.vit != status->vit)
	2512	clif_updatestatus(sd,SP_VIT);
	2513	if(b_status.int_ != status->int_)
	2514	clif_updatestatus(sd,SP_INT);
	2515	if(b_status.dex != status->dex)
	2516	clif_updatestatus(sd,SP_DEX);
	2517	if(b_status.luk != status->luk)
	2518	clif_updatestatus(sd,SP_LUK);
	2519	if(b_status.hit != status->hit)
	2520	clif_updatestatus(sd,SP_HIT);
	2521	if(b_status.flee != status->flee)
	2522	clif_updatestatus(sd,SP_FLEE1);
	2523	if(b_status.amotion != status->amotion)
	2524	clif_updatestatus(sd,SP_ASPD);
	2525	if(b_status.rhw.atk != status->rhw.atk \|\|
	2526	b_status.lhw.atk != status->lhw.atk \|\|
	2527	b_status.batk != status->batk)
	2528	clif_updatestatus(sd,SP_ATK1);
	2529	if(b_status.def != status->def)
	2530	clif_updatestatus(sd,SP_DEF1);
	2531	if(b_status.rhw.atk2 != status->rhw.atk2 \|\|
	2532	b_status.lhw.atk2 != status->lhw.atk2)
	2533	clif_updatestatus(sd,SP_ATK2);
	2534	if(b_status.def2 != status->def2)
	2535	clif_updatestatus(sd,SP_DEF2);
	2536	if(b_status.flee2 != status->flee2)
	2537	clif_updatestatus(sd,SP_FLEE2);
	2538	if(b_status.cri != status->cri)
	2539	clif_updatestatus(sd,SP_CRITICAL);
	2540	if(b_status.matk_max != status->matk_max)
	2541	clif_updatestatus(sd,SP_MATK1);
	2542	if(b_status.matk_min != status->matk_min)
	2543	clif_updatestatus(sd,SP_MATK2);
	2544	if(b_status.mdef != status->mdef)
	2545	clif_updatestatus(sd,SP_MDEF1);
	2546	if(b_status.mdef2 != status->mdef2)
	2547	clif_updatestatus(sd,SP_MDEF2);
	2548	if(b_status.rhw.range != status->rhw.range)
	2549	clif_updatestatus(sd,SP_ATTACKRANGE);
	2550	if(b_status.max_hp != status->max_hp)
	2551	clif_updatestatus(sd,SP_MAXHP);
	2552	if(b_status.max_sp != status->max_sp)
	2553	clif_updatestatus(sd,SP_MAXSP);
	2554	if(b_status.hp != status->hp)
	2555	clif_updatestatus(sd,SP_HP);
	2556	if(b_status.sp != status->sp)
	2557	clif_updatestatus(sd,SP_SP);
	2558
	2559	calculating = 0;
	2560	return 0;
	2561	}
	2562
	2563	int status_calc_homunculus(struct homun_data *hd, int first)
	2564	{
	2565	struct status_data b_status, *status;
	2566	struct s_homunculus *hom;
	2567	int skill;
	2568	int amotion;
	2569
	2570	memcpy(&b_status, &hd->base_status, sizeof(struct status_data));
	2571	hom = &hd->homunculus;
	2572
	2573	status = &hd->base_status;
	2574
	2575	status->str = hom->str / 10;
	2576	status->agi = hom->agi / 10;
	2577	status->vit = hom->vit / 10;
	2578	status->dex = hom->dex / 10;
	2579	status->int_ = hom->int_ / 10;
	2580	status->luk = hom->luk / 10;
	2581
	2582	if (first) { //[orn]
	2583	const struct s_homunculus_db *db = hd->homunculusDB;
	2584	status->def_ele = db->element;
	2585	status->ele_lv = 1;
	2586	status->race = db->race;
	2587	status->size = (hom->class_ == db->evo_class)?db->evo_size:db->base_size;
	2588	status->rhw.range = 1 + status->size;
	2589	status->mode = MD_CANMOVE\|MD_CANATTACK;
	2590	status->speed = DEFAULT_WALK_SPEED;
	2591	if (battle_config.hom_setting&0x8 && hd->master)
	2592	status->speed = status_get_speed(&hd->master->bl);
	2593
	2594	status->hp = 1;
	2595	status->sp = 1;
	2596	}
	2597	skill = hom->level/10 + status->vit/5;
	2598	status->def = cap_value(skill, 0, 99);
	2599
	2600	skill = hom->level/10 + status->int_/5;
	2601	status->mdef = cap_value(skill, 0, 99);
	2602
	2603	status->max_hp = hom->max_hp ;
	2604	status->max_sp = hom->max_sp ;
	2605
	2606	merc_hom_calc_skilltree(hd);
	2607
	2608	if((skill=merc_hom_checkskill(hd,HAMI_SKIN)) > 0)
	2609	status->def += skill * 4;
	2610
	2611	if((skill = merc_hom_checkskill(hd,HVAN_INSTRUCT)) > 0)
	2612	{
	2613	status->int_ += 1 +skill/2 +skill/4 +skill/5;
	2614	status->str += 1 +skill/3 +skill/3 +skill/4;
	2615	}
	2616
	2617	if((skill=merc_hom_checkskill(hd,HAMI_SKIN)) > 0)
	2618	status->max_hp += skill * 2 * status->max_hp / 100;
	2619
	2620	if((skill = merc_hom_checkskill(hd,HLIF_BRAIN)) > 0)
	2621	status->max_sp += (1 +skill/2 -skill/4 +skill/5) * status->max_sp / 100 ;
	2622
	2623	if (first) {
	2624	hd->battle_status.hp = hom->hp ;
	2625	hd->battle_status.sp = hom->sp ;
	2626	}
	2627
	2628	status->rhw.atk = status->dex;
	2629	status->rhw.atk2 = status->str + hom->level;
	2630
	2631	status->aspd_rate = 1000;
	2632
	2633	amotion = (1000 -4status->agi -status->dex) hd->homunculusDB->baseASPD/1000;
	2634	status->amotion = cap_value(amotion,battle_config.max_aspd,2000);
	2635	status->adelay = status->amotion; //It seems adelay = amotion for Homunculus.
	2636
	2637	status_calc_misc(&hd->bl, status, hom->level);
	2638	status_cpy(&hd->battle_status, status);
	2639	status_calc_bl(&hd->bl, SCB_ALL); //Status related changes.
	2640
	2641	if( memcmp(&b_status, status, sizeof(struct status_data)) && !first )
	2642	clif_hominfo(hd->master,hd,0) ;
	2643
	2644	return 1;
	2645	}
	2646
	2647	static unsigned short status_calc_str(struct block_list ,struct status_change ,int);
	2648	static unsigned short status_calc_agi(struct block_list ,struct status_change ,int);
	2649	static unsigned short status_calc_vit(struct block_list ,struct status_change ,int);
	2650	static unsigned short status_calc_int(struct block_list ,struct status_change ,int);
	2651	static unsigned short status_calc_dex(struct block_list ,struct status_change ,int);
	2652	static unsigned short status_calc_luk(struct block_list ,struct status_change ,int);
	2653	static unsigned short status_calc_batk(struct block_list ,struct status_change ,int);
	2654	static unsigned short status_calc_watk(struct block_list ,struct status_change ,int);
	2655	static unsigned short status_calc_matk(struct block_list ,struct status_change ,int);
	2656	static signed short status_calc_hit(struct block_list ,struct status_change ,int);
	2657	static signed short status_calc_critical(struct block_list ,struct status_change ,int);
	2658	static signed short status_calc_flee(struct block_list ,struct status_change ,int);
	2659	static signed short status_calc_flee2(struct block_list ,struct status_change ,int);
	2660	static signed char status_calc_def(struct block_list ,struct status_change ,int);
	2661	static signed short status_calc_def2(struct block_list ,struct status_change ,int);
	2662	static signed char status_calc_mdef(struct block_list ,struct status_change ,int);
	2663	static signed short status_calc_mdef2(struct block_list ,struct status_change ,int);
	2664	static unsigned short status_calc_speed(struct block_list ,struct status_change ,int);
	2665	static short status_calc_aspd_rate(struct block_list ,struct status_change ,int);
	2666	static unsigned short status_calc_dmotion(struct block_list bl, struct status_change sc, int dmotion);
	2667	static unsigned int status_calc_maxhp(struct block_list ,struct status_change ,unsigned int);
	2668	static unsigned int status_calc_maxsp(struct block_list ,struct status_change ,unsigned int);
	2669	static unsigned char status_calc_element(struct block_list bl, struct status_change sc, int element);
	2670	static unsigned char status_calc_element_lv(struct block_list bl, struct status_change sc, int lv);
	2671	static unsigned short status_calc_mode(struct block_list bl, struct status_change sc, int mode);
	2672
	2673	//Calculates base regen values.
	2674	void status_calc_regen(struct block_list bl, struct status_data status, struct regen_data *regen)
	2675	{
	2676	struct map_session_data *sd;
	2677	int val, skill;
	2678
	2679	if (!(bl->type&BL_REGEN) \|\| !regen)
	2680	return;
	2681	sd = BL_CAST(BL_PC,bl);
	2682
	2683	val = 1 + (status->vit/5) + (status->max_hp/200);
	2684
	2685	if (sd && sd->hprecov_rate != 100)
	2686	val = val*sd->hprecov_rate/100;
	2687
	2688	regen->hp = cap_value(val, 1, SHRT_MAX);
	2689
	2690	val = 1 + (status->int_/6) + (status->max_sp/100);
	2691	if(status->int_ >= 120)
	2692	val += ((status->int_-120)>>1) + 4;
	2693
	2694	if(sd && sd->sprecov_rate != 100)
	2695	val = val*sd->sprecov_rate/100;
	2696
	2697	regen->sp = cap_value(val, 1, SHRT_MAX);
	2698
	2699	if(sd)
	2700	{
	2701	struct regen_data_sub *sregen;
	2702	if((skill=pc_checkskill(sd,HP_MEDITATIO)) > 0)
	2703	{
	2704	val = regen->sp(100+3skill)/100;
	2705	regen->sp = cap_value(val, 1, SHRT_MAX);
	2706	}
	2707	//Only players have skill/sitting skill regen for now.
	2708	sregen = regen->sregen;
	2709
	2710	val = 0;
	2711	if((skill=pc_checkskill(sd,SM_RECOVERY)) > 0)
	2712	val += skill5 + skillstatus->max_hp/500;
	2713	sregen->hp = cap_value(val, 0, SHRT_MAX);
	2714
	2715	val = 0;
	2716	if((skill=pc_checkskill(sd,MG_SRECOVERY)) > 0)
	2717	val += skill3 + skillstatus->max_sp/500;
	2718	if((skill=pc_checkskill(sd,NJ_NINPOU)) > 0)
	2719	val += skill3 + skillstatus->max_sp/500;
	2720	sregen->sp = cap_value(val, 0, SHRT_MAX);
	2721
	2722	// Skill-related recovery (only when sit)
	2723	sregen = regen->ssregen;
	2724
	2725	val = 0;
	2726	if((skill=pc_checkskill(sd,MO_SPIRITSRECOVERY)) > 0)
	2727	val += skill4 + skillstatus->max_hp/500;
	2728
	2729	if((skill=pc_checkskill(sd,TK_HPTIME)) > 0 && sd->state.rest)
	2730	val += skill30 + skillstatus->max_hp/500;
	2731	sregen->hp = cap_value(val, 0, SHRT_MAX);
	2732
	2733	val = 0;
	2734	if((skill=pc_checkskill(sd,TK_SPTIME)) > 0 && sd->state.rest)
	2735	{
	2736	val += skill3 + skillstatus->max_sp/500;
	2737	if ((skill=pc_checkskill(sd,SL_KAINA)) > 0) //Power up Enjoyable Rest
	2738	val += (30+10skill)val/100;
	2739	}
	2740	if((skill=pc_checkskill(sd,MO_SPIRITSRECOVERY)) > 0)
	2741	val += skill2 + skillstatus->max_sp/500;
	2742	sregen->sp = cap_value(val, 0, SHRT_MAX);
	2743	}
	2744
	2745	if(bl->type==BL_HOM)
	2746	{
	2747	struct homun_data hd = (TBL_HOM)bl;
	2748	if((skill=merc_hom_checkskill(hd,HAMI_SKIN)) > 0)
	2749	{
	2750	val = regen->hp(100+5skill)/100;
	2751	regen->hp = cap_value(val, 1, SHRT_MAX);
	2752	}
	2753	if((skill = merc_hom_checkskill(hd,HLIF_BRAIN)) > 0)
	2754	{
	2755	val = regen->sp(100+3skill)/100;
	2756	regen->sp = cap_value(val, 1, SHRT_MAX);
	2757	}
	2758	}
	2759	}
	2760
	2761	//Calculates SC related regen rates.
	2762	void status_calc_regen_rate(struct block_list bl, struct regen_data regen, struct status_change *sc)
	2763	{
	2764	if (!(bl->type&BL_REGEN) \|\| !regen)
	2765	return;
	2766
	2767	regen->flag = RGN_HP\|RGN_SP;
	2768	if(regen->sregen)
	2769	{
	2770	if (regen->sregen->hp)
	2771	regen->flag\|=RGN_SHP;
	2772
	2773	if (regen->sregen->sp)
	2774	regen->flag\|=RGN_SSP;
	2775	regen->sregen->rate.hp = regen->sregen->rate.sp = 1;
	2776	}
	2777	if (regen->ssregen)
	2778	{
	2779	if (regen->ssregen->hp)
	2780	regen->flag\|=RGN_SHP;
	2781
	2782	if (regen->ssregen->sp)
	2783	regen->flag\|=RGN_SSP;
	2784	regen->ssregen->rate.hp = regen->ssregen->rate.sp = 1;
	2785	}
	2786	regen->rate.hp = regen->rate.sp = 1;
	2787
	2788	if (!sc \|\| !sc->count)
	2789	return;
	2790
	2791	if (
	2792	(sc->data[SC_POISON] && !sc->data[SC_SLOWPOISON])
	2793	\|\| (sc->data[SC_DPOISON] && !sc->data[SC_SLOWPOISON])
	2794	\|\| sc->data[SC_BERSERK]
	2795	\|\| sc->data[SC_TRICKDEAD]
	2796	\|\| sc->data[SC_BLEEDING]
[10]	2797	//Custom Jobs (blackmagic)
[13]	2798	\|\| sc->data[SC_LUST] // Adept Blood Lust, stops hp regen [Brain]
[10]	2799	\|\| sc->data[SC_DEATHPACT] // Necro Death Pact
	2800	//Custom Job End
[1]	2801	) //No regen
	2802	regen->flag = 0;
	2803
	2804	if (
	2805	sc->data[SC_EXTREMITYFIST]
	2806	\|\| sc->data[SC_DANCING]
	2807	\|\| (sc->data[SC_EXPLOSIONSPIRITS]
	2808	&& (!sc->data[SC_SPIRIT] \|\| sc->data[SC_SPIRIT]->val2 != SL_MONK))
[10]	2809	//Custom Jobs (blackmagic)
	2810	\|\| sc->data[SC_OVERWHELMING] // Warlock Overwhelming Evil, stops sp regen [Brain]
	2811	//Custom Job End
[1]	2812	) //No natural SP regen
	2813	regen->flag &=~RGN_SP;
	2814
	2815	if(
	2816	sc->data[SC_TENSIONRELAX]
	2817	) {
	2818	regen->rate.hp += 2;
	2819	if (regen->sregen)
	2820	regen->sregen->rate.hp += 3;
	2821	}
	2822	if (sc->data[SC_MAGNIFICAT])
	2823	{
	2824	regen->rate.hp += 1;
	2825	regen->rate.sp += 1;
	2826	}
	2827	if (sc->data[SC_REGENERATION])
	2828	{
	2829	const struct status_change_entry *sce = sc->data[SC_REGENERATION];
	2830	if (!sce->val4)
	2831	{
	2832	regen->rate.hp += sce->val2;
	2833	regen->rate.sp += sce->val3;
	2834	} else
	2835	regen->flag&=~sce->val4; //Remove regen as specified by val4
	2836	}
	2837	}
	2838
	2839	//Calculates some attributes that depends on modified stats from status changes.
	2840	void status_calc_bl_sub_pc(struct map_session_data *sd, unsigned long flag)
	2841	{
	2842	struct status_data status = &sd->battle_status, b_status = &sd->base_status;
	2843	int skill;
	2844
	2845	if(flag&(SCB_MAXHP\|SCB_VIT))
	2846	{
	2847	flag\|=SCB_MAXHP; //Ensures client-side refresh
	2848
	2849	status->max_hp = status_base_pc_maxhp(sd,status);
	2850	status->max_hp += b_status->max_hp - sd->status.max_hp;
	2851
	2852	status->max_hp = status_calc_maxhp(&sd->bl, &sd->sc, status->max_hp);
	2853
	2854	if(status->max_hp > (unsigned int)battle_config.max_hp)
	2855	status->max_hp = battle_config.max_hp;
	2856	else if(!status->max_hp)
	2857	status->max_hp = 1;
	2858
	2859	if(status->hp > status->max_hp) {
	2860	status->hp = status->max_hp;
	2861	clif_updatestatus(sd,SP_HP);
	2862	}
	2863	}
	2864
	2865	if(flag&(SCB_MAXSP\|SCB_INT))
	2866	{
	2867	flag\|=SCB_MAXSP;
	2868
	2869	status->max_sp = status_base_pc_maxsp(sd,status);
	2870	status->max_sp += b_status->max_sp - sd->status.max_sp;
	2871
	2872	status->max_sp = status_calc_maxsp(&sd->bl, &sd->sc, status->max_sp);
	2873
	2874	if(status->max_sp > (unsigned int)battle_config.max_sp)
	2875	status->max_sp = battle_config.max_sp;
	2876	else if(!status->max_sp)
	2877	status->max_sp = 1;
	2878
	2879	if(status->sp > status->max_sp) {
	2880	status->sp = status->max_sp;
	2881	clif_updatestatus(sd,SP_SP);
	2882	}
	2883	}
	2884
	2885	if(flag&SCB_MATK) {
	2886	//New matk
	2887	status->matk_min = status_base_matk_min(status);
	2888	status->matk_max = status_base_matk_max(status);
	2889
	2890	//Bonuses from previous matk
	2891	if(sd->matk_rate != 100){
	2892	status->matk_max = status->matk_max * sd->matk_rate/100;
	2893	status->matk_min = status->matk_min * sd->matk_rate/100;
	2894	}
	2895
	2896	status->matk_min = status_calc_matk(&sd->bl, &sd->sc, status->matk_min);
	2897	status->matk_max = status_calc_matk(&sd->bl, &sd->sc, status->matk_max);
	2898
	2899	if(sd->sc.data[SC_MAGICPOWER]) { //Store current matk values
	2900	sd->sc.mp_matk_min = status->matk_min;
	2901	sd->sc.mp_matk_max = status->matk_max;
	2902	}
	2903	}
	2904
	2905	if(flag&SCB_SPEED) {
	2906	if(status->speed < battle_config.max_walk_speed)
	2907	status->speed = battle_config.max_walk_speed;
	2908
	2909	if ((skill=pc_checkskill(sd,SA_FREECAST))>0) {
	2910	//Store casting walk speed for quick restoration. [Skotlex]
	2911	sd->prev_speed = status->speed * (175-5*skill)/100;
	2912	if(sd->ud.skilltimer != -1) { //Swap speed.
	2913	skill = status->speed;
	2914	status->speed = sd->prev_speed;
	2915	sd->prev_speed = skill;
	2916	}
	2917	}
	2918	}
	2919	if(flag&(SCB_ASPD\|SCB_AGI\|SCB_DEX)) {
	2920	flag\|=SCB_ASPD;
	2921
	2922	skill = status_base_amotion_pc(sd,status);
	2923	status->aspd_rate = status_calc_aspd_rate(&sd->bl, &sd->sc , b_status->aspd_rate);
	2924
	2925	// Apply all relative modifiers
	2926	if(status->aspd_rate != 1000)
	2927	skill = skill *status->aspd_rate/1000;
	2928
	2929	status->amotion = cap_value(skill,battle_config.max_aspd,2000);
	2930
	2931	status->adelay = 2*status->amotion;
	2932	if ((skill=pc_checkskill(sd,SA_FREECAST))>0) {
	2933	//Store casting adelay for quick restoration. [Skotlex]
	2934	sd->prev_adelay = status->adelay(150-5skill)/100;
	2935	if(sd->ud.skilltimer != -1) { //Swap adelay.
	2936	skill = status->adelay;
	2937	status->adelay = sd->prev_adelay;
	2938	sd->prev_adelay = skill;
	2939	}
	2940	}
	2941
	2942	}
	2943
	2944	if(flag&(SCB_AGI\|SCB_DSPD)) {
	2945	if (b_status->agi == status->agi)
	2946	status->dmotion = status_calc_dmotion(&sd->bl, &sd->sc, b_status->dmotion);
	2947	else {
	2948	skill = 800-status->agi*4;
	2949	status->dmotion = cap_value(skill, 400, 800);
	2950	if(battle_config.pc_damage_delay_rate != 100)
	2951	status->dmotion = status->dmotion*battle_config.pc_damage_delay_rate/100;
	2952	//It's safe to ignore b_status->dmotion since no bonus affects it.
	2953	status->dmotion = status_calc_dmotion(&sd->bl, &sd->sc, status->dmotion);
	2954	}
	2955	}
	2956
	2957	if(flag&(SCB_INT\|SCB_MAXSP\|SCB_VIT\|SCB_MAXHP))
	2958	status_calc_regen(&sd->bl, status, &sd->regen);
	2959
	2960	if(flag&SCB_REGEN)
	2961	status_calc_regen_rate(&sd->bl, &sd->regen, &sd->sc);
	2962
	2963	if (flag == SCB_ALL)
	2964	return; //Refresh is done on invoking function (status_calc_pc)
	2965
	2966	if(flag&SCB_STR)
	2967	clif_updatestatus(sd,SP_STR);
	2968	if(flag&SCB_AGI)
	2969	clif_updatestatus(sd,SP_AGI);
	2970	if(flag&SCB_VIT)
	2971	clif_updatestatus(sd,SP_VIT);
	2972	if(flag&SCB_INT)
	2973	clif_updatestatus(sd,SP_INT);
	2974	if(flag&SCB_DEX)
	2975	clif_updatestatus(sd,SP_DEX);
	2976	if(flag&SCB_LUK)
	2977	clif_updatestatus(sd,SP_LUK);
	2978	if(flag&SCB_HIT)
	2979	clif_updatestatus(sd,SP_HIT);
	2980	if(flag&SCB_FLEE)
	2981	clif_updatestatus(sd,SP_FLEE1);
	2982	if(flag&SCB_ASPD)
	2983	clif_updatestatus(sd,SP_ASPD);
	2984	if(flag&SCB_SPEED)
	2985	clif_updatestatus(sd,SP_SPEED);
	2986	if(flag&(SCB_BATK\|SCB_WATK))
	2987	clif_updatestatus(sd,SP_ATK1);
	2988	if(flag&SCB_DEF)
	2989	clif_updatestatus(sd,SP_DEF1);
	2990	if(flag&SCB_WATK)
	2991	clif_updatestatus(sd,SP_ATK2);
	2992	if(flag&SCB_DEF2)
	2993	clif_updatestatus(sd,SP_DEF2);
	2994	if(flag&SCB_FLEE2)
	2995	clif_updatestatus(sd,SP_FLEE2);
	2996	if(flag&SCB_CRI)
	2997	clif_updatestatus(sd,SP_CRITICAL);
	2998	if(flag&SCB_MATK) {
	2999	clif_updatestatus(sd,SP_MATK1);
	3000	clif_updatestatus(sd,SP_MATK2);
	3001	}
	3002	if(flag&SCB_MDEF)
	3003	clif_updatestatus(sd,SP_MDEF1);
	3004	if(flag&SCB_MDEF2)
	3005	clif_updatestatus(sd,SP_MDEF2);
	3006	if(flag&SCB_RANGE)
	3007	clif_updatestatus(sd,SP_ATTACKRANGE);
	3008	if(flag&SCB_MAXHP)
	3009	clif_updatestatus(sd,SP_MAXHP);
	3010	if(flag&SCB_MAXSP)
	3011	clif_updatestatus(sd,SP_MAXSP);
	3012	}
	3013
	3014	//Calculates some attributes that depends on modified stats from status changes.
	3015	void status_calc_bl_sub_hom(struct homun_data *hd, unsigned long flag) //[orn]
	3016	{
	3017	struct status_data status = &hd->battle_status, b_status = &hd->base_status;
	3018	int skill = 0;
	3019
	3020
	3021	if(flag&(SCB_MAXHP\|SCB_VIT))
	3022	{
	3023	flag\|=SCB_MAXHP; //Ensures client-side refresh
	3024	// Apply relative modifiers from equipment
	3025	if(status->max_hp > (unsigned int)battle_config.max_hp)
	3026	status->max_hp = battle_config.max_hp;
	3027	else if(!status->max_hp)
	3028	status->max_hp = 1;
	3029	if(status->hp > status->max_hp)
	3030	status->hp = status->max_hp;
	3031	}
	3032	if(flag&(SCB_MAXSP\|SCB_INT))
	3033	{
	3034	flag\|=SCB_MAXSP;
	3035	if(status->max_sp > (unsigned int)battle_config.max_sp)
	3036	status->max_sp = battle_config.max_sp;
	3037	else if(!status->max_sp)
	3038	status->max_sp = 1;
	3039	if(status->sp > status->max_sp)
	3040	status->sp = status->max_sp;
	3041	}
	3042	if(flag&(SCB_VIT\|SCB_DEF))
	3043	{ //Since vit affects def, recalculate def.
	3044	flag\|=SCB_DEF;
	3045	status->def = status_calc_def(&hd->bl, &hd->sc, b_status->def);
	3046	status->def+=(status->vit/5 - b_status->vit/5);
	3047	}
	3048	if(flag&(SCB_INT\|SCB_MDEF))
	3049	{
	3050	flag\|=SCB_MDEF;
	3051	status->mdef = status_calc_mdef(&hd->bl, &hd->sc, b_status->mdef);
	3052	status->mdef+= (status->int_/5 - b_status->int_/5);
	3053	}
	3054	if(flag&SCB_DEX) {
	3055	flag \|=SCB_WATK;
	3056	status->rhw.atk = status_calc_watk(&hd->bl, &hd->sc, b_status->rhw.atk);
	3057	status->rhw.atk+= (status->dex - b_status->dex);
	3058	}
	3059	if(flag&SCB_STR) {
	3060	flag \|=SCB_WATK;
	3061	status->rhw.atk2 = status_calc_watk(&hd->bl, &hd->sc, b_status->rhw.atk2);
	3062	status->rhw.atk2+= (status->str - b_status->str);
	3063	}
	3064	if(flag\|SCB_WATK && status->rhw.atk2 < status->rhw.atk)
	3065	status->rhw.atk2 = status->rhw.atk;
	3066
	3067	if(flag&SCB_MATK && battle_config.hom_setting&0x20) //Hom Min Matk is always the same as Max Matk
	3068	status->matk_min = status->matk_max;
	3069
	3070	if(flag&SCB_SPEED && battle_config.hom_setting&0x8 && hd->master)
	3071	status->speed = status_get_speed(&hd->master->bl);
	3072
	3073	if(flag&(SCB_ASPD\|SCB_AGI\|SCB_DEX)) {
	3074	flag\|=SCB_ASPD;
	3075
	3076	skill = (1000 -4*status->agi -status->dex)
	3077	*hd->homunculusDB->baseASPD/1000;
	3078
	3079	status->aspd_rate = status_calc_aspd_rate(&hd->bl, &hd->sc , b_status->aspd_rate);
	3080	if(status->aspd_rate != 1000)
	3081	skill = skill*status->aspd_rate/1000;
	3082
	3083	status->amotion = cap_value(skill,battle_config.max_aspd,2000);
	3084	status->adelay = status->amotion;
	3085	}
	3086
	3087	if(flag&(SCB_AGI\|SCB_DSPD)) {
	3088	skill = 800-status->agi*4;
	3089	status->dmotion = cap_value(skill, 400, 800);
	3090	status->dmotion = status_calc_dmotion(&hd->bl, &hd->sc, b_status->dmotion);
	3091	}
	3092
	3093	if(flag&(SCB_INT\|SCB_MAXSP\|SCB_VIT\|SCB_MAXHP) && flag != SCB_ALL)
	3094	status_calc_regen(&hd->bl, status, &hd->regen);
	3095
	3096	if(flag&SCB_REGEN)
	3097	status_calc_regen_rate(&hd->bl, &hd->regen, &hd->sc);
	3098
	3099	if (flag == SCB_ALL)
	3100	return; //Refresh is done on invoking function (status_calc_hom)
	3101
	3102	if (hd->master && flag&(
	3103	SCB_STR\|SCB_AGI\|SCB_VIT\|SCB_INT\|SCB_DEX\|SCB_LUK\|
	3104	SCB_HIT\|SCB_FLEE\|SCB_CRI\|SCB_FLEE2\|
	3105	SCB_DEF\|SCB_DEF2\|SCB_MDEF\|SCB_MDEF2\|
	3106	SCB_BATK\|SCB_WATK\|SCB_MATK\|SCB_ASPD\|SCB_SPEED\|
	3107	SCB_RANGE\|SCB_MAXHP\|SCB_MAXSP)
	3108	)
	3109	clif_hominfo(hd->master,hd,0);
	3110	}
	3111
	3112	void status_calc_bl(struct block_list *bl, unsigned long flag)
	3113	{
	3114	struct status_data b_status, status;
	3115	struct status_change *sc;
	3116	int temp;
	3117	TBL_PC *sd;
	3118	b_status = status_get_base_status(bl);
	3119	status = status_get_status_data(bl);
	3120	sc = status_get_sc(bl);
	3121
	3122	if (!b_status \|\| !status)
	3123	return;
	3124
	3125	sd = BL_CAST(BL_PC,bl);
	3126
	3127	if(sd && flag&SCB_PC)
	3128	{ //Recalc everything.
	3129	status_calc_pc(sd,0);
	3130	return;
	3131	}
	3132
	3133	if((!(bl->type&BL_REGEN)) && (!sc \|\| !sc->count)) { //No difference.
	3134	status_cpy(status, b_status);
	3135	return;
	3136	}
	3137
	3138	if(flag&SCB_STR) {
	3139	status->str = status_calc_str(bl, sc, b_status->str);
	3140	flag\|=SCB_BATK;
	3141	}
	3142
	3143	if(flag&SCB_AGI) {
	3144	status->agi = status_calc_agi(bl, sc, b_status->agi);
	3145	flag\|=SCB_FLEE;
	3146	}
	3147
	3148	if(flag&SCB_VIT) {
	3149	status->vit = status_calc_vit(bl, sc, b_status->vit);
	3150	flag\|=SCB_DEF2\|SCB_MDEF2;
	3151	}
	3152
	3153	if(flag&SCB_INT) {
	3154	status->int_ = status_calc_int(bl, sc, b_status->int_);
	3155	flag\|=SCB_MATK\|SCB_MDEF2;
	3156	}
	3157
	3158	if(flag&SCB_DEX) {
	3159	status->dex = status_calc_dex(bl, sc, b_status->dex);
	3160	flag\|=SCB_BATK\|SCB_HIT;
	3161	}
	3162
	3163	if(flag&SCB_LUK) {
	3164	status->luk = status_calc_luk(bl, sc, b_status->luk);
	3165	flag\|=SCB_BATK\|SCB_CRI\|SCB_FLEE2;
	3166	}
	3167
	3168	if(flag&SCB_BATK && b_status->batk) {
	3169	status->batk = status_base_atk(bl,status);
	3170	temp = b_status->batk - status_base_atk(bl,b_status);
	3171	if (temp)
	3172	{
	3173	temp += status->batk;
	3174	status->batk = cap_value(temp, 0, USHRT_MAX);
	3175	}
	3176	status->batk = status_calc_batk(bl, sc, status->batk);
	3177	}
	3178
	3179	if(flag&SCB_WATK) {
	3180	status->rhw.atk = status_calc_watk(bl, sc, b_status->rhw.atk);
	3181	if (!sd) //Should not affect weapon refine bonus
	3182	status->rhw.atk2 = status_calc_watk(bl, sc, b_status->rhw.atk2);
	3183	if(b_status->lhw.atk) {
	3184	if (sd) {
	3185	sd->state.lr_flag = 1;
	3186	status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk);
	3187	sd->state.lr_flag = 0;
	3188	} else {
	3189	status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk);
	3190	status->lhw.atk2= status_calc_watk(bl, sc, b_status->lhw.atk2);
	3191	}
	3192	}
	3193	}
	3194
	3195	if(flag&SCB_HIT) {
	3196	if (status->dex == b_status->dex)
	3197	status->hit = status_calc_hit(bl, sc, b_status->hit);
	3198	else
	3199	status->hit = status_calc_hit(bl, sc, b_status->hit +(status->dex - b_status->dex));
	3200	}
	3201
	3202	if(flag&SCB_FLEE) {
	3203	if (status->agi == b_status->agi)
	3204	status->flee = status_calc_flee(bl, sc, b_status->flee);
	3205	else
	3206	status->flee = status_calc_flee(bl, sc, b_status->flee +(status->agi - b_status->agi));
	3207	}
	3208
	3209	if(flag&SCB_DEF)
	3210	status->def = status_calc_def(bl, sc, b_status->def);
	3211
	3212	if(flag&SCB_DEF2) {
	3213	if (status->vit == b_status->vit)
	3214	status->def2 = status_calc_def2(bl, sc, b_status->def2);
	3215	else
	3216	status->def2 = status_calc_def2(bl, sc, b_status->def2 + (status->vit - b_status->vit));
	3217	}
	3218
	3219	if(flag&SCB_MDEF)
	3220	status->mdef = status_calc_mdef(bl, sc, b_status->mdef);
	3221
	3222	if(flag&SCB_MDEF2) {
	3223	if (status->int_ == b_status->int_ && status->vit == b_status->vit)
	3224	status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2);
	3225	else
	3226	status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2 +(status->int_ - b_status->int_) +((status->vit - b_status->vit)>>1));
	3227	}
	3228
	3229	if(flag&SCB_SPEED) {
	3230	struct unit_data *ud = unit_bl2ud(bl);
	3231	status->speed = status_calc_speed(bl, sc, b_status->speed);
	3232	//Re-walk to adjust speed (we do not check if walktimer != -1
	3233	//because if you step on something while walking, the moment this
	3234	//piece of code triggers the walk-timer is set on -1) [Skotlex]
	3235	if (ud)
	3236	ud->state.change_walk_target = ud->state.speed_changed = 1;
	3237	}
	3238
	3239	if(flag&SCB_CRI && b_status->cri) {
	3240	if (status->luk == b_status->luk)
	3241	status->cri = status_calc_critical(bl, sc, b_status->cri);
	3242	else
	3243	status->cri = status_calc_critical(bl, sc, b_status->cri + 3*(status->luk - b_status->luk));
	3244	}
	3245
	3246	if(flag&SCB_FLEE2 && b_status->flee2) {
	3247	if (status->luk == b_status->luk)
	3248	status->flee2 = status_calc_flee2(bl, sc, b_status->flee2);
	3249	else
	3250	status->flee2 = status_calc_flee2(bl, sc, b_status->flee2 +(status->luk - b_status->luk));
	3251	}
	3252
	3253	if(flag&SCB_ATK_ELE) {
	3254	status->rhw.ele = status_calc_attack_element(bl, sc, b_status->rhw.ele);
	3255	if (sd) sd->state.lr_flag = 1;
	3256	status->lhw.ele = status_calc_attack_element(bl, sc, b_status->lhw.ele);
	3257	if (sd) sd->state.lr_flag = 0;
	3258	}
	3259
	3260	if(flag&SCB_DEF_ELE) {
	3261	status->def_ele = status_calc_element(bl, sc, b_status->def_ele);
	3262	status->ele_lv = status_calc_element_lv(bl, sc, b_status->ele_lv);
	3263	}
	3264
	3265	if(flag&SCB_MODE)
	3266	{
	3267	status->mode = status_calc_mode(bl, sc, b_status->mode);
	3268	//Since mode changed, reset their state.
	3269	if (!(status->mode&MD_CANATTACK))
	3270	unit_stop_attack(bl);
	3271	if (!(status->mode&MD_CANMOVE))
	3272	unit_stop_walking(bl,0);
	3273	}
	3274
	3275	// No status changes alter these yet.
	3276	// if(flag&SCB_SIZE)
	3277	// if(flag&SCB_RACE)
	3278	// if(flag&SCB_RANGE)
	3279
	3280	if(sd) {
	3281	//The remaining are handled quite different by players, so use their own function.
	3282	status_calc_bl_sub_pc(sd, flag);
	3283	return;
	3284	}
	3285
	3286	if(flag&SCB_MAXHP) {
	3287	status->max_hp = status_calc_maxhp(bl, sc, b_status->max_hp);
	3288	if (status->hp > status->max_hp) //FIXME: Should perhaps a status_zap should be issued?
	3289	status->hp = status->max_hp;
	3290	}
	3291
	3292	if(flag&SCB_MAXSP) {
	3293	status->max_sp = status_calc_maxsp(bl, sc, b_status->max_sp);
	3294	if (status->sp > status->max_sp)
	3295	status->sp = status->max_sp;
	3296	}
	3297
	3298	if(flag&SCB_MATK) {
	3299	status->matk_min = status_base_matk_min(status);
	3300	status->matk_max = status_base_matk_max(status);
	3301	status->matk_min = status_calc_matk(bl, sc, status->matk_min);
	3302	status->matk_max = status_calc_matk(bl, sc, status->matk_max);
	3303	if(sc->data[SC_MAGICPOWER]) { //Store current matk values
	3304	sc->mp_matk_min = status->matk_min;
	3305	sc->mp_matk_max = status->matk_max;
	3306	}
	3307	}
	3308
	3309	if(bl->type == BL_HOM) {
	3310	//The remaining are handled quite different by homunculus, so use their own function.
	3311	status_calc_bl_sub_hom((TBL_HOM*)bl, flag);
	3312	return;
	3313	}
	3314
	3315	if(flag&SCB_ASPD) {
	3316	status->aspd_rate = status_calc_aspd_rate(bl, sc , b_status->aspd_rate);
	3317	temp = status->aspd_rate*b_status->amotion/1000;
	3318	status->amotion = cap_value(temp, battle_config.monster_max_aspd, 2000);
	3319
	3320	temp = status->aspd_rate*b_status->adelay/1000;
	3321	status->adelay = cap_value(temp, battle_config.monster_max_aspd<<1, 4000);
	3322	}
	3323
	3324	if(flag&SCB_DSPD)
	3325	status->dmotion = status_calc_dmotion(bl, sc, b_status->dmotion);
	3326
	3327	if(bl->type&BL_REGEN) {
	3328	if(flag&(SCB_VIT\|SCB_MAXHP\|SCB_INT\|SCB_MAXSP))
	3329	status_calc_regen(bl, status, status_get_regen_data(bl));
	3330	if(flag&SCB_REGEN)
	3331	status_calc_regen_rate(bl, status_get_regen_data(bl), sc);
	3332	}
	3333	}
	3334	/*==========================================
	3335	* Apply shared stat mods from status changes [DracoRPG]
	3336	------------------------------------------/
	3337	static unsigned short status_calc_str(struct block_list bl, struct status_change sc, int str)
	3338	{
	3339	if(!sc \|\| !sc->count)
	3340	return cap_value(str,0,USHRT_MAX);
	3341
	3342	if(sc->data[SC_INCALLSTATUS])
	3343	str += sc->data[SC_INCALLSTATUS]->val1;
	3344	if(sc->data[SC_INCSTR])
	3345	str += sc->data[SC_INCSTR]->val1;
	3346	if(sc->data[SC_STRFOOD])
	3347	str += sc->data[SC_STRFOOD]->val1;
	3348	if(sc->data[SC_BATTLEORDERS])
	3349	str += 5;
	3350	if(sc->data[SC_GUILDAURA] && sc->data[SC_GUILDAURA]->val3>>16)
	3351	str += (sc->data[SC_GUILDAURA]->val3)>>16;
	3352	if(sc->data[SC_LOUD])
	3353	str += 4;
	3354	if(sc->data[SC_TRUESIGHT])
	3355	str += 5;
	3356	if(sc->data[SC_SPURT])
	3357	str += 10;
	3358	if(sc->data[SC_NEN])
	3359	str += sc->data[SC_NEN]->val1;
	3360	if(sc->data[SC_BLESSING]){
	3361	if(sc->data[SC_BLESSING]->val2)
	3362	str += sc->data[SC_BLESSING]->val2;
	3363	else
	3364	str >>= 1;
	3365	}
	3366	if(sc->data[SC_MARIONETTE])
	3367	str -= ((sc->data[SC_MARIONETTE]->val3)>>16)&0xFF;
	3368	if(sc->data[SC_MARIONETTE2])
	3369	str += ((sc->data[SC_MARIONETTE2]->val3)>>16)&0xFF;
	3370	if(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && str < 50)
	3371	str = 50;
	3372
	3373	return (unsigned short)cap_value(str,0,USHRT_MAX);
	3374	}
	3375
	3376	static unsigned short status_calc_agi(struct block_list bl, struct status_change sc, int agi)
	3377	{
	3378	if(!sc \|\| !sc->count)
	3379	return cap_value(agi,0,USHRT_MAX);
	3380
	3381	if(sc->data[SC_CONCENTRATE] && !sc->data[SC_QUAGMIRE])
	3382	agi += (agi-sc->data[SC_CONCENTRATE]->val3)*sc->data[SC_CONCENTRATE]->val2/100;
	3383	if(sc->data[SC_INCALLSTATUS])
	3384	agi += sc->data[SC_INCALLSTATUS]->val1;
	3385	if(sc->data[SC_INCAGI])
	3386	agi += sc->data[SC_INCAGI]->val1;
	3387	if(sc->data[SC_AGIFOOD])
	3388	agi += sc->data[SC_AGIFOOD]->val1;
	3389	if(sc->data[SC_GUILDAURA] && (sc->data[SC_GUILDAURA]->val4)>>16)
	3390	agi += (sc->data[SC_GUILDAURA]->val4)>>16;
	3391	if(sc->data[SC_TRUESIGHT])
	3392	agi += 5;
	3393	if(sc->data[SC_INCREASEAGI])
	3394	agi += sc->data[SC_INCREASEAGI]->val2;
	3395	if(sc->data[SC_INCREASING])
	3396	agi += 4; // added based on skill updates [Reddozen]
	3397	if(sc->data[SC_DECREASEAGI])
	3398	agi -= sc->data[SC_DECREASEAGI]->val2;
	3399	if(sc->data[SC_QUAGMIRE])
	3400	agi -= sc->data[SC_QUAGMIRE]->val2;
	3401	if(sc->data[SC_SUITON] && sc->data[SC_SUITON]->val3)
	3402	agi -= sc->data[SC_SUITON]->val2;
	3403	if(sc->data[SC_MARIONETTE])
	3404	agi -= ((sc->data[SC_MARIONETTE]->val3)>>8)&0xFF;
	3405	if(sc->data[SC_MARIONETTE2])
	3406	agi += ((sc->data[SC_MARIONETTE2]->val3)>>8)&0xFF;
	3407	if(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && agi < 50)
	3408	agi = 50;
	3409
	3410	return (unsigned short)cap_value(agi,0,USHRT_MAX);
	3411	}
	3412
	3413	static unsigned short status_calc_vit(struct block_list bl, struct status_change sc, int vit)
	3414	{
	3415	if(!sc \|\| !sc->count)
	3416	return cap_value(vit,0,USHRT_MAX);
	3417
	3418	if(sc->data[SC_INCALLSTATUS])
	3419	vit += sc->data[SC_INCALLSTATUS]->val1;
	3420	if(sc->data[SC_INCVIT])
	3421	vit += sc->data[SC_INCVIT]->val1;
	3422	if(sc->data[SC_VITFOOD])
	3423	vit += sc->data[SC_VITFOOD]->val1;
	3424	if(sc->data[SC_CHANGE])
	3425	vit += sc->data[SC_CHANGE]->val2;
	3426	if(sc->data[SC_GUILDAURA] && sc->data[SC_GUILDAURA]->val3&0xFFFF)
	3427	vit += sc->data[SC_GUILDAURA]->val3&0xFFFF;
	3428	if(sc->data[SC_TRUESIGHT])
	3429	vit += 5;
	3430	if(sc->data[SC_STRIPARMOR])
	3431	vit -= vit * sc->data[SC_STRIPARMOR]->val2/100;
	3432	if(sc->data[SC_MARIONETTE])
	3433	vit -= sc->data[SC_MARIONETTE]->val3&0xFF;
	3434	if(sc->data[SC_MARIONETTE2])
	3435	vit += sc->data[SC_MARIONETTE2]->val3&0xFF;
	3436	if(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && vit < 50)
	3437	vit = 50;
	3438
	3439	return (unsigned short)cap_value(vit,0,USHRT_MAX);
	3440	}
	3441
	3442	static unsigned short status_calc_int(struct block_list bl, struct status_change sc, int int_)
	3443	{
	3444	if(!sc \|\| !sc->count)
	3445	return cap_value(int_,0,USHRT_MAX);
	3446
	3447	if(sc->data[SC_INCALLSTATUS])
	3448	int_ += sc->data[SC_INCALLSTATUS]->val1;
	3449	if(sc->data[SC_INCINT])
	3450	int_ += sc->data[SC_INCINT]->val1;
	3451	if(sc->data[SC_INTFOOD])
	3452	int_ += sc->data[SC_INTFOOD]->val1;
	3453	if(sc->data[SC_CHANGE])
	3454	int_ += sc->data[SC_CHANGE]->val3;
	3455	if(sc->data[SC_BATTLEORDERS])
	3456	int_ += 5;
	3457	if(sc->data[SC_TRUESIGHT])
	3458	int_ += 5;
	3459	if(sc->data[SC_BLESSING]){
	3460	if (sc->data[SC_BLESSING]->val2)
	3461	int_ += sc->data[SC_BLESSING]->val2;
	3462	else
	3463	int_ >>= 1;
	3464	}
	3465	if(sc->data[SC_STRIPHELM])
	3466	int_ -= int_ * sc->data[SC_STRIPHELM]->val2/100;
	3467	if(sc->data[SC_NEN])
	3468	int_ += sc->data[SC_NEN]->val1;
	3469	if(sc->data[SC_MARIONETTE])
	3470	int_ -= ((sc->data[SC_MARIONETTE]->val4)>>16)&0xFF;
	3471	if(sc->data[SC_MARIONETTE2])
	3472	int_ += ((sc->data[SC_MARIONETTE2]->val4)>>16)&0xFF;
	3473	if(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && int_ < 50)
	3474	int_ = 50;
	3475
	3476	return (unsigned short)cap_value(int_,0,USHRT_MAX);
	3477	}
	3478
	3479	static unsigned short status_calc_dex(struct block_list bl, struct status_change sc, int dex)
	3480	{
	3481	if(!sc \|\| !sc->count)
	3482	return cap_value(dex,0,USHRT_MAX);
	3483
	3484	if(sc->data[SC_CONCENTRATE] && !sc->data[SC_QUAGMIRE])
	3485	dex += (dex-sc->data[SC_CONCENTRATE]->val4)*sc->data[SC_CONCENTRATE]->val2/100;
	3486
	3487	if(sc->data[SC_INCALLSTATUS])
	3488	dex += sc->data[SC_INCALLSTATUS]->val1;
	3489	if(sc->data[SC_INCDEX])
	3490	dex += sc->data[SC_INCDEX]->val1;
	3491	if(sc->data[SC_DEXFOOD])
	3492	dex += sc->data[SC_DEXFOOD]->val1;
	3493	if(sc->data[SC_BATTLEORDERS])
	3494	dex += 5;
	3495	if(sc->data[SC_GUILDAURA] && sc->data[SC_GUILDAURA]->val4&0xFFFF)
	3496	dex += sc->data[SC_GUILDAURA]->val4&0xFFFF;
	3497	if(sc->data[SC_TRUESIGHT])
	3498	dex += 5;
	3499	if(sc->data[SC_QUAGMIRE])
	3500	dex -= sc->data[SC_QUAGMIRE]->val2;
	3501	if(sc->data[SC_BLESSING]){
	3502	if (sc->data[SC_BLESSING]->val2)
	3503	dex += sc->data[SC_BLESSING]->val2;
	3504	else
	3505	dex >>= 1;
	3506	}
	3507	if(sc->data[SC_INCREASING])
	3508	dex += 4; // added based on skill updates [Reddozen]
	3509	if(sc->data[SC_MARIONETTE])
	3510	dex -= ((sc->data[SC_MARIONETTE]->val4)>>8)&0xFF;
	3511	if(sc->data[SC_MARIONETTE2])
	3512	dex += ((sc->data[SC_MARIONETTE2]->val4)>>8)&0xFF;
	3513	if(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && dex < 50)
	3514	dex = 50;
	3515
	3516	return (unsigned short)cap_value(dex,0,USHRT_MAX);
	3517	}
	3518
	3519	static unsigned short status_calc_luk(struct block_list bl, struct status_change sc, int luk)
	3520	{
	3521	if(!sc \|\| !sc->count)
	3522	return cap_value(luk,0,USHRT_MAX);
	3523
	3524	if(sc->data[SC_CURSE])
	3525	return 0;
	3526	if(sc->data[SC_INCALLSTATUS])
	3527	luk += sc->data[SC_INCALLSTATUS]->val1;
	3528	if(sc->data[SC_INCLUK])
	3529	luk += sc->data[SC_INCLUK]->val1;
	3530	if(sc->data[SC_LUKFOOD])
	3531	luk += sc->data[SC_LUKFOOD]->val1;
	3532	if(sc->data[SC_TRUESIGHT])
	3533	luk += 5;
	3534	if(sc->data[SC_GLORIA])
	3535	luk += 30;
	3536	if(sc->data[SC_MARIONETTE])
	3537	luk -= sc->data[SC_MARIONETTE]->val4&0xFF;
	3538	if(sc->data[SC_MARIONETTE2])
	3539	luk += sc->data[SC_MARIONETTE2]->val4&0xFF;
	3540	if(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && luk < 50)
	3541	luk = 50;
	3542
	3543	return (unsigned short)cap_value(luk,0,USHRT_MAX);
	3544	}
	3545
	3546	static unsigned short status_calc_batk(struct block_list bl, struct status_change sc, int batk)
	3547	{
	3548	if(!sc \|\| !sc->count)
	3549	return cap_value(batk,0,USHRT_MAX);
	3550
	3551	if(sc->data[SC_INCBASEATK])
	3552	batk += sc->data[SC_INCBASEATK]->val1;
	3553	if(sc->data[SC_ATKPOTION])
	3554	batk += sc->data[SC_ATKPOTION]->val1;
	3555	if(sc->data[SC_BATKFOOD])
	3556	batk += sc->data[SC_BATKFOOD]->val1;
	3557	if(sc->data[SC_INCATKRATE])
	3558	batk += batk * sc->data[SC_INCATKRATE]->val1/100;
	3559	if(sc->data[SC_PROVOKE])
	3560	batk += batk * sc->data[SC_PROVOKE]->val3/100;
	3561	if(sc->data[SC_CONCENTRATION])
	3562	batk += batk * sc->data[SC_CONCENTRATION]->val2/100;
	3563	if(sc->data[SC_SKE])
	3564	batk += batk * 3;
	3565	if(sc->data[SC_BLOODLUST])
	3566	batk += batk * sc->data[SC_BLOODLUST]->val2/100;
	3567	if(sc->data[SC_JOINTBEAT] && sc->data[SC_JOINTBEAT]->val2&BREAK_WAIST)
	3568	batk -= batk * 25/100;
	3569	if(sc->data[SC_CURSE])
	3570	batk -= batk * 25/100;
	3571	//Curse shouldn't effect on this? <- Curse OR Bleeding??
	3572	// if(sc->data[SC_BLEEDING])
	3573	// batk -= batk * 25/100;
	3574	if(sc->data[SC_FLEET])
	3575	batk += batk * sc->data[SC_FLEET]->val3/100;
	3576	if(sc->data[SC_GATLINGFEVER])
	3577	batk += sc->data[SC_GATLINGFEVER]->val3;
	3578	if(sc->data[SC_MADNESSCANCEL])
	3579	batk += 100;
[10]	3580	//Custom Jobs (blackmagic)
[13]	3581	if(sc->data[SC_LUST]) // Adept Blood Lust [Brain]
	3582	batk += batk * sc->data[SC_LUST]->val2/100;
	3583	if(sc->data[SC_CURSEWEAKNESS]) // Warlock Curse of Weakness [Brain]
	3584	batk -= batk * sc->data[SC_CURSEWEAKNESS]->val2/100;
	3585	if(sc->data[SC_DECREPIFY]) // Necromancer Decrepify [Brain]
	3586	if(sc->data[SC_DECREPIFY]->val2>=2)
	3587	batk -= batk * 25/100;
[10]	3588
	3589	//Custom Job End
[1]	3590	return (unsigned short)cap_value(batk,0,USHRT_MAX);
	3591	}
	3592
	3593	static unsigned short status_calc_watk(struct block_list bl, struct status_change sc, int watk)
	3594	{
	3595	if(!sc \|\| !sc->count)
	3596	return cap_value(watk,0,USHRT_MAX);
	3597
	3598	if(sc->data[SC_IMPOSITIO])
	3599	watk += sc->data[SC_IMPOSITIO]->val2;
	3600	if(sc->data[SC_WATKFOOD])
	3601	watk += sc->data[SC_WATKFOOD]->val1;
	3602	if(sc->data[SC_DRUMBATTLE])
	3603	watk += sc->data[SC_DRUMBATTLE]->val2;
	3604	if(sc->data[SC_VOLCANO])
	3605	watk += sc->data[SC_VOLCANO]->val2;
	3606	if(sc->data[SC_INCATKRATE])
	3607	watk += watk * sc->data[SC_INCATKRATE]->val1/100;
	3608	if(sc->data[SC_PROVOKE])
	3609	watk += watk * sc->data[SC_PROVOKE]->val3/100;
	3610	if(sc->data[SC_CONCENTRATION])
	3611	watk += watk * sc->data[SC_CONCENTRATION]->val2/100;
	3612	if(sc->data[SC_SKE])
	3613	watk += watk * 3;
	3614	if(sc->data[SC_NIBELUNGEN]) {
	3615	if (bl->type != BL_PC)
	3616	watk += sc->data[SC_NIBELUNGEN]->val2;
	3617	else {
	3618	TBL_PC sd = (TBL_PC)bl;
	3619	int index = sd->equip_index[sd->state.lr_flag?EQI_HAND_L:EQI_HAND_R];
	3620	if(index >= 0 && sd->inventory_data[index] && sd->inventory_data[index]->wlv == 4)
	3621	watk += sc->data[SC_NIBELUNGEN]->val2;
	3622	}
	3623	}
	3624	if(sc->data[SC_BLOODLUST])
	3625	watk += watk * sc->data[SC_BLOODLUST]->val2/100;
	3626	if(sc->data[SC_FLEET])
	3627	watk += watk * sc->data[SC_FLEET]->val3/100;
	3628	if(sc->data[SC_CURSE])
	3629	watk -= watk * 25/100;
	3630	if(sc->data[SC_STRIPWEAPON])
	3631	watk -= watk * sc->data[SC_STRIPWEAPON]->val2/100;
[10]	3632	//Custom Jobs (blackmagic)
[13]	3633	if(sc->data[SC_LUST]) // Adept Blood Lust [Brain]
	3634	watk += watk * sc->data[SC_LUST]->val2/100;
	3635	if(sc->data[SC_REQUIEM]){ //Necro Requiem [Brain]
	3636	if(sc->data[SC_REQUIEM]->val2)
	3637	watk += sc->data[SC_REQUIEM]->val2*10;
	3638	if(sc->data[SC_REQUIEM]->val3)
	3639	watk -= sc->data[SC_REQUIEM]->val3*10;
	3640	}
	3641	if(sc->data[SC_CURSEWEAKNESS]) // Warlock Curse of Weakness [Brain]
	3642	watk -= watk * sc->data[SC_CURSEWEAKNESS]->val2/100;
	3643	if(sc->data[SC_DECREPIFY]) // Necromancer Decrepify [Brain]
	3644	if(sc->data[SC_DECREPIFY]->val2>=2)
[10]	3645	watk -= watk * 25/100;
	3646	//Custom Job End
[1]	3647
	3648	return (unsigned short)cap_value(watk,0,USHRT_MAX);
	3649	}
	3650
	3651	static unsigned short status_calc_matk(struct block_list bl, struct status_change sc, int matk)
	3652	{
	3653	if(!sc \|\| !sc->count)
	3654	return cap_value(matk,0,USHRT_MAX);
	3655
	3656	if(sc->data[SC_MATKPOTION])
	3657	matk += sc->data[SC_MATKPOTION]->val1;
	3658	if(sc->data[SC_MATKFOOD])
	3659	matk += sc->data[SC_MATKFOOD]->val1;
	3660	if(sc->data[SC_MAGICPOWER])
	3661	matk += matk * sc->data[SC_MAGICPOWER]->val3/100;
	3662	if(sc->data[SC_MINDBREAKER])
	3663	matk += matk * sc->data[SC_MINDBREAKER]->val2/100;
	3664	if(sc->data[SC_INCMATKRATE])
	3665	matk += matk * sc->data[SC_INCMATKRATE]->val1/100;
[10]	3666	//Custom Jobs (blackmagic)
[13]	3667	if(sc->data[SC_OVERWHELMING]) // Warlock Overwhelming Evil [Brain]
[10]	3668	matk += matk * sc->data[SC_OVERWHELMING]->val2/100;
	3669	//Custom Job End
[1]	3670
	3671	return (unsigned short)cap_value(matk,0,USHRT_MAX);
	3672	}
	3673
	3674	static signed short status_calc_critical(struct block_list bl, struct status_change sc, int critical)
	3675	{
	3676	if(!sc \|\| !sc->count)
	3677	return cap_value(critical,10,SHRT_MAX);
	3678
	3679	if (sc->data[SC_INCCRI])
	3680	critical += sc->data[SC_INCCRI]->val2;
	3681	if (sc->data[SC_EXPLOSIONSPIRITS])
	3682	critical += sc->data[SC_EXPLOSIONSPIRITS]->val2;
	3683	if (sc->data[SC_FORTUNE])
	3684	critical += sc->data[SC_FORTUNE]->val2;
	3685	if (sc->data[SC_TRUESIGHT])
	3686	critical += sc->data[SC_TRUESIGHT]->val2;
	3687	if(sc->data[SC_CLOAKING])
	3688	critical += critical;
	3689
	3690	return (short)cap_value(critical,10,SHRT_MAX);
	3691	}
	3692
	3693	static signed short status_calc_hit(struct block_list bl, struct status_change sc, int hit)
	3694	{
	3695
	3696	if(!sc \|\| !sc->count)
	3697	return cap_value(hit,1,SHRT_MAX);
	3698
	3699	if(sc->data[SC_INCHIT])
	3700	hit += sc->data[SC_INCHIT]->val1;
	3701	if(sc->data[SC_HITFOOD])
	3702	hit += sc->data[SC_HITFOOD]->val1;
	3703	if(sc->data[SC_TRUESIGHT])
	3704	hit += sc->data[SC_TRUESIGHT]->val3;
	3705	if(sc->data[SC_HUMMING])
	3706	hit += sc->data[SC_HUMMING]->val2;
	3707	if(sc->data[SC_CONCENTRATION])
	3708	hit += sc->data[SC_CONCENTRATION]->val3;
	3709	if(sc->data[SC_INCHITRATE])
	3710	hit += hit * sc->data[SC_INCHITRATE]->val1/100;
	3711	if(sc->data[SC_BLIND])
	3712	hit -= hit * 25/100;
	3713	if(sc->data[SC_ADJUSTMENT])
	3714	hit -= 30;
	3715	if(sc->data[SC_INCREASING])
	3716	hit += 20; // RockmanEXE; changed based on updated [Reddozen]
[10]	3717	//Custom Jobs (blackmagic)
[13]	3718	if(sc->data[SC_DARKMOON]){ //Necro Dark Moon [Brain]
	3719	if(sc->data[SC_DARKMOON]->val2)
	3720	hit += sc->data[SC_DARKMOON]->val2;
	3721	if(sc->data[SC_DARKMOON]->val3)
	3722	hit -= sc->data[SC_DARKMOON]->val3;
[10]	3723	}
	3724	//Custom Job End
[1]	3725
	3726	return (short)cap_value(hit,1,SHRT_MAX);
	3727	}
	3728
	3729	static signed short status_calc_flee(struct block_list bl, struct status_change sc, int flee)
	3730	{
	3731	if (bl->type == BL_PC && map_flag_gvg(bl->m)) //GVG grounds flee penalty, placed here because it's "like" a status change. [Skotlex]
	3732	flee -= flee * battle_config.gvg_flee_penalty/100;
	3733
	3734	if(!sc \|\| !sc->count)
	3735	return cap_value(flee,1,SHRT_MAX);
	3736
	3737	if(sc->data[SC_INCFLEE])
	3738	flee += sc->data[SC_INCFLEE]->val1;
	3739	if(sc->data[SC_FLEEFOOD])
	3740	flee += sc->data[SC_FLEEFOOD]->val1;
	3741	if(sc->data[SC_WHISTLE])
	3742	flee += sc->data[SC_WHISTLE]->val2;
	3743	if(sc->data[SC_WINDWALK])
	3744	flee += sc->data[SC_WINDWALK]->val2;
	3745	if(sc->data[SC_INCFLEERATE])
	3746	flee += flee * sc->data[SC_INCFLEERATE]->val1/100;
	3747	if(sc->data[SC_VIOLENTGALE])
	3748	flee += sc->data[SC_VIOLENTGALE]->val2;
	3749	if(sc->data[SC_MOON_COMFORT]) //SG skill [Komurka]
	3750	flee += sc->data[SC_MOON_COMFORT]->val2;
	3751	if(sc->data[SC_CLOSECONFINE])
	3752	flee += 10;
	3753	if(sc->data[SC_SPIDERWEB])
	3754	flee -= flee * 50/100;
	3755	if(sc->data[SC_BERSERK])
	3756	flee -= flee * 50/100;
	3757	if(sc->data[SC_BLIND])
	3758	flee -= flee * 25/100;
	3759	if(sc->data[SC_ADJUSTMENT])
	3760	flee += 30;
	3761	if(sc->data[SC_GATLINGFEVER])
	3762	flee -= sc->data[SC_GATLINGFEVER]->val4;
	3763	if(sc->data[SC_SPEED])
	3764	flee += 10 + sc->data[SC_SPEED]->val1 * 10 ;
[10]	3765	//Custom Jobs (blackmagic)
[13]	3766	if(sc->data[SC_DARKMOON]){ //Necro Dark Moon [Brain]
	3767	if(sc->data[SC_DARKMOON]->val2)
	3768	flee += sc->data[SC_DARKMOON]->val2;
	3769	if(sc->data[SC_DARKMOON]->val3)
	3770	flee -= sc->data[SC_DARKMOON]->val3;
[10]	3771	}
	3772	//Custom Job End
[1]	3773
	3774	return (short)cap_value(flee,1,SHRT_MAX);
	3775	}
	3776
	3777	static signed short status_calc_flee2(struct block_list bl, struct status_change sc, int flee2)
	3778	{
	3779	if(!sc \|\| !sc->count)
	3780	return cap_value(flee2,10,SHRT_MAX);
	3781
	3782	if(sc->data[SC_INCFLEE2])
	3783	flee2 += sc->data[SC_INCFLEE2]->val2;
	3784	if(sc->data[SC_WHISTLE])
	3785	flee2 += sc->data[SC_WHISTLE]->val3*10;
	3786
	3787	return (short)cap_value(flee2,10,SHRT_MAX);
	3788	}
	3789
	3790	static signed char status_calc_def(struct block_list bl, struct status_change sc, int def)
	3791	{
	3792	if(!sc \|\| !sc->count)
	3793	return (signed char)cap_value(def,CHAR_MIN,CHAR_MAX);
	3794
	3795	if(sc->data[SC_BERSERK])
	3796	return 0;
	3797	if(sc->data[SC_SKA])
	3798	return sc->data[SC_SKA]->val3;
	3799	if(sc->data[SC_BARRIER])
	3800	return 100;
	3801	if(sc->data[SC_KEEPING])
	3802	return 90;
	3803	if(sc->data[SC_STEELBODY])
	3804	return 90;
	3805	if(sc->data[SC_INCDEF])
	3806	def += sc->data[SC_INCDEF]->val1;
	3807	if(sc->data[SC_ARMORCHANGE])
	3808	def += sc->data[SC_ARMORCHANGE]->val2;
	3809	if(sc->data[SC_DRUMBATTLE])
	3810	def += sc->data[SC_DRUMBATTLE]->val3;
	3811	if(sc->data[SC_DEFENCE]) //[orn]
	3812	def += sc->data[SC_DEFENCE]->val2 ;
	3813	if(sc->data[SC_INCDEFRATE])
	3814	def += def * sc->data[SC_INCDEFRATE]->val1/100;
	3815	if(sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
	3816	def >>=1;
	3817	if(sc->data[SC_FREEZE])
	3818	def >>=1;
	3819	if(sc->data[SC_SIGNUMCRUCIS])
	3820	def -= def * sc->data[SC_SIGNUMCRUCIS]->val2/100;
	3821	if(sc->data[SC_CONCENTRATION])
	3822	def -= def * sc->data[SC_CONCENTRATION]->val4/100;
	3823	if(sc->data[SC_SKE])
	3824	def >>=1;
	3825	if(sc->data[SC_PROVOKE] && bl->type != BL_PC) // Provoke doesn't alter player defense->
	3826	def -= def * sc->data[SC_PROVOKE]->val4/100;
	3827	if(sc->data[SC_STRIPSHIELD])
	3828	def -= def * sc->data[SC_STRIPSHIELD]->val2/100;
	3829	if (sc->data[SC_FLING])
	3830	def -= def * (sc->data[SC_FLING]->val2)/100;
[10]	3831	//Custom Jobs (blackmagic)
[13]	3832	if(sc->data[SC_SUFFER]) // Necro Power Word: Suffer [Brain]
	3833	def <<=1; // -25% def
	3834	if (sc->data[SC_CURSEEXHAUST]) // Warlock Curse of Exhaustion [Brain]
	3835	def -= sc->data[SC_CURSEEXHAUST]->val2;
	3836	if (sc->data[SC_OVERWHELMING]) // Warlock Overwhelming Evil [Brain]
[10]	3837	def += sc->data[SC_OVERWHELMING]->val1;
	3838	//Custom Job End
[1]	3839
	3840	return (signed char)cap_value(def,CHAR_MIN,CHAR_MAX);
	3841	}
	3842
	3843	static signed short status_calc_def2(struct block_list bl, struct status_change sc, int def2)
	3844	{
	3845	if(!sc \|\| !sc->count)
	3846	return cap_value(def2,1,SHRT_MAX);
	3847
	3848	if(sc->data[SC_BERSERK])
	3849	return 0;
	3850	if(sc->data[SC_ETERNALCHAOS])
	3851	return 0;
	3852	if(sc->data[SC_SUN_COMFORT])
	3853	def2 += sc->data[SC_SUN_COMFORT]->val2;
	3854	if(sc->data[SC_ANGELUS])
	3855	def2 += def2 * sc->data[SC_ANGELUS]->val2/100;
	3856	if(sc->data[SC_CONCENTRATION])
	3857	def2 -= def2 * sc->data[SC_CONCENTRATION]->val4/100;
	3858	if(sc->data[SC_POISON])
	3859	def2 -= def2 * 25/100;
	3860	if(sc->data[SC_DPOISON])
	3861	def2 -= def2 * 25/100;
	3862	if(sc->data[SC_SKE])
	3863	def2 -= def2 * 50/100;
	3864	if(sc->data[SC_PROVOKE])
	3865	def2 -= def2 * sc->data[SC_PROVOKE]->val4/100;
	3866	if(sc->data[SC_JOINTBEAT]){
	3867	def2 -= def2 *
	3868	( ( sc->data[SC_JOINTBEAT]->val2&BREAK_SHOULDER ? 50 : 0 )
	3869	+ ( sc->data[SC_JOINTBEAT]->val2&BREAK_WAIST ? 25 : 0 ) );
	3870	}
	3871	if(sc->data[SC_FLING])
	3872	def2 -= def2 * (sc->data[SC_FLING]->val3)/100;
	3873
[10]	3874	//Custom Jobs (blackmagic)
[13]	3875	if(sc->data[SC_SUFFER]) // Necro Power Word: Suffer [Brain]
	3876	def2 -= def2 * 25/100; // -25% def
	3877	if(sc->data[SC_DECREPIFY]) // Necromancer Decrepify [Brain]
	3878	if(sc->data[SC_DECREPIFY]->val2>=4)
[10]	3879	def2 -= def2 * 25/100;
	3880	//Custom Job End
	3881
[1]	3882	return (short)cap_value(def2,1,SHRT_MAX);
	3883	}
	3884
	3885	static signed char status_calc_mdef(struct block_list bl, struct status_change sc, int mdef)
	3886	{
	3887	if(!sc \|\| !sc->count)
	3888	return (signed char)cap_value(mdef,CHAR_MIN,CHAR_MAX);
	3889
	3890	if(sc->data[SC_BERSERK])
	3891	return 0;
	3892	if(sc->data[SC_BARRIER])
	3893	return 100;
	3894	if(sc->data[SC_STEELBODY])
	3895	return 90;
	3896	if(sc->data[SC_SKA])
	3897	return 90;
	3898	if(sc->data[SC_ARMORCHANGE])
	3899	mdef += sc->data[SC_ARMORCHANGE]->val3;
	3900	if(sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
	3901	mdef += 25*mdef/100;
	3902	if(sc->data[SC_FREEZE])
	3903	mdef += 25*mdef/100;
	3904	if(sc->data[SC_ENDURE] && sc->data[SC_ENDURE]->val4 == 0)
	3905	mdef += sc->data[SC_ENDURE]->val1;
	3906	if(sc->data[SC_CONCENTRATION])
	3907	mdef += 1; //Skill info says it adds a fixed 1 Mdef point.
[10]	3908	//Custom Jobs (blackmagic)
[13]	3909	if(sc->data[SC_AGONY]) // Warlock Power Word: Agony [Brain]
	3910	mdef -= 25*mdef/100; // -25% mdef
	3911	if (sc->data[SC_CURSEEXHAUST]) // Warlock Curse of Exhaustion [Brain]
	3912	mdef -= sc->data[SC_CURSEEXHAUST]->val2;
	3913	if (sc->data[SC_OVERWHELMING]) // Warlock Overwhelming Evil [Brain]
[10]	3914	mdef += sc->data[SC_OVERWHELMING]->val1;
	3915	//Custom Job End
[1]	3916
	3917	return (signed char)cap_value(mdef,CHAR_MIN,CHAR_MAX);
	3918	}
	3919
	3920	static signed short status_calc_mdef2(struct block_list bl, struct status_change sc, int mdef2)
	3921	{
	3922	if(!sc \|\| !sc->count)
	3923	return cap_value(mdef2,1,SHRT_MAX);
	3924
	3925	if(sc->data[SC_BERSERK])
	3926	return 0;
	3927	if(sc->data[SC_MINDBREAKER])
	3928	mdef2 -= mdef2 * sc->data[SC_MINDBREAKER]->val3/100;
[10]	3929	//Custom Jobs (blackmagic)
[13]	3930	if(sc->data[SC_AGONY]) // Warlock Power Word: Agony [Brain]
	3931	mdef2 -= mdef2 * 25/100; // -25% mdef
	3932	if(sc->data[SC_DECREPIFY]) // Necromancer Decrepify [Brain]
	3933	if(sc->data[SC_DECREPIFY]->val2>=5)
[10]	3934	mdef2 -= mdef2 * 25/100;
	3935	//Custom Job End
[1]	3936
	3937	return (short)cap_value(mdef2,1,SHRT_MAX);
	3938	}
	3939
	3940	static unsigned short status_calc_speed(struct block_list bl, struct status_change sc, int speed)
	3941	{
	3942	//Default speed coming in means there's no speed_rate adjustments.
	3943	int new_speed = speed;
	3944	bool default_speed = (speed == DEFAULT_WALK_SPEED);
	3945
	3946	if(!sc \|\| !sc->count)
	3947	return cap_value(speed,10,USHRT_MAX);
	3948
	3949	if(sc->data[SC_WALKSPEED])
	3950	new_speed = sc->data[SC_WALKSPEED]->val1;
	3951
	3952	// Fixed reductions
	3953	if(sc->data[SC_CURSE])
	3954	new_speed += 450;
	3955	if(sc->data[SC_SWOO])
	3956	new_speed += 450; //Let's use Curse's slow down momentarily (exact value unknown)
	3957	if(sc->data[SC_WEDDING])
	3958	new_speed += 300;
	3959
	3960	if(!sc->data[SC_GATLINGFEVER])
	3961	{ //These two stack with everything (but only one of either)
	3962	if(sc->data[SC_SPEEDUP1])
	3963	new_speed -= new_speed * 50/100;
	3964	else if(sc->data[SC_AVOID])
	3965	new_speed -= new_speed * sc->data[SC_AVOID]->val2/100;
	3966
	3967	speed = new_speed;
	3968
	3969	//These stack independently
	3970	if(sc->data[SC_RUN])
	3971	new_speed -= new_speed * 50/100;
	3972	if(sc->data[SC_INCREASEAGI])
	3973	new_speed -= new_speed * 25/100;
	3974	if(sc->data[SC_FUSION])
	3975	new_speed -= new_speed * 25/100;
	3976
	3977	//These only apply if you don't have increase agi and/or fusion and/or sprint
	3978	if(speed == new_speed)
	3979	{
	3980	//Don't allow buff from non speed potion consumables to stack with equips!
	3981	if(sc->data[SC_SPEEDUP0] && default_speed)
	3982	new_speed -= new_speed * 25/100;
	3983	else if(sc->data[SC_CARTBOOST])
	3984	new_speed -= new_speed * 20/100;
	3985	else if(sc->data[SC_BERSERK])
	3986	new_speed -= new_speed * 20/100;
	3987	else if(sc->data[SC_WINDWALK])
	3988	new_speed -= new_speed * sc->data[SC_WINDWALK]->val3/100;
[10]	3989	//Custom Jobs (blackmagic)
[13]	3990	else if(sc->data[SC_FEAR]) //Fear Status by [Brainstorm]
[10]	3991	new_speed -= new_speed * 25/100;
	3992	//Custom Job End
[1]	3993	}
	3994
	3995	}
	3996
	3997	speed = new_speed;
	3998
	3999	//% reductions (they stack)
	4000	if(sc->data[SC_DANCING] && sc->data[SC_DANCING]->val3&0xFFFF)
	4001	speed += speed*(sc->data[SC_DANCING]->val3&0xFFFF)/100;
	4002	if(sc->data[SC_DECREASEAGI])
	4003	speed = speed * 100/75;
	4004	if(sc->data[SC_STEELBODY])
	4005	speed = speed * 100/75;
	4006	if(sc->data[SC_QUAGMIRE])
	4007	speed = speed * 100/50;
	4008	if(sc->data[SC_SUITON] && sc->data[SC_SUITON]->val3)
	4009	speed = speed * 100/sc->data[SC_SUITON]->val3;
	4010	if(sc->data[SC_DONTFORGETME])
	4011	speed = speed * 100/sc->data[SC_DONTFORGETME]->val3;
	4012	if(sc->data[SC_DEFENDER])
	4013	speed = speed * 100/sc->data[SC_DEFENDER]->val3;
	4014	if(sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_ENEMY)
	4015	speed = speed * 100/75;
	4016	if(sc->data[SC_JOINTBEAT] && sc->data[SC_JOINTBEAT]->val2&(BREAK_ANKLE\|BREAK_KNEE)) {
	4017	speed = speed * 100/(100
	4018	- ( sc->data[SC_JOINTBEAT]->val2&BREAK_ANKLE ? 50 : 0 )
	4019	- ( sc->data[SC_JOINTBEAT]->val2&BREAK_KNEE ? 30 : 0 ));
	4020	}
	4021	if(sc->data[SC_CLOAKING])
	4022	speed = speed * 100 /(
	4023	(sc->data[SC_CLOAKING]->val4&1?25:0) //Wall speed bonus
	4024	+sc->data[SC_CLOAKING]->val3); //Normal adjustment bonus->
	4025
	4026	if(sc->data[SC_LONGING])
	4027	speed = speed * 100/sc->data[SC_LONGING]->val3;
	4028	if(sc->data[SC_HIDING] && sc->data[SC_HIDING]->val3)
	4029	speed = speed * 100/sc->data[SC_HIDING]->val3;
	4030	if(sc->data[SC_CHASEWALK])
	4031	speed = speed * 100/sc->data[SC_CHASEWALK]->val3;
	4032	if(sc->data[SC_GATLINGFEVER])
	4033	speed = speed * 100/75;
	4034	if(sc->data[SC_SLOWDOWN])
	4035	speed = speed * 100/75;
[10]	4036	//Custom Jobs (blackmagic)
[13]	4037	if(sc->data[SC_DECREPIFY]) // Necromancer Decrepify [Brain]
[10]	4038	speed = speed * 100/75; //-25% walkspeed
	4039	//Custom Job End
[1]	4040
	4041	return (short)cap_value(speed,10,USHRT_MAX);
	4042	}
	4043
	4044	static short status_calc_aspd_rate(struct block_list bl, struct status_change sc, int aspd_rate)
	4045	{
	4046	int i;
	4047	if(!sc \|\| !sc->count)
	4048	return cap_value(aspd_rate,0,SHRT_MAX);
	4049
	4050	if(!sc->data[SC_QUAGMIRE])
	4051	{
	4052	int max = 0;
	4053	if(sc->data[SC_STAR_COMFORT])
	4054	max = sc->data[SC_STAR_COMFORT]->val2;
	4055
	4056	if(sc->data[SC_TWOHANDQUICKEN] &&
	4057	max < sc->data[SC_TWOHANDQUICKEN]->val2)
	4058	max = sc->data[SC_TWOHANDQUICKEN]->val2;
	4059
	4060	if(sc->data[SC_ONEHAND] &&
	4061	max < sc->data[SC_ONEHAND]->val2)
	4062	max = sc->data[SC_ONEHAND]->val2;
	4063
	4064	if(sc->data[SC_ADRENALINE2] &&
	4065	max < sc->data[SC_ADRENALINE2]->val3)
	4066	max = sc->data[SC_ADRENALINE2]->val3;
	4067
	4068	if(sc->data[SC_ADRENALINE] &&
	4069	max < sc->data[SC_ADRENALINE]->val3)
	4070	max = sc->data[SC_ADRENALINE]->val3;
	4071
	4072	if(sc->data[SC_SPEARQUICKEN] &&
	4073	max < sc->data[SC_SPEARQUICKEN]->val2)
	4074	max = sc->data[SC_SPEARQUICKEN]->val2;
	4075
	4076	if(sc->data[SC_GATLINGFEVER] &&
	4077	max < sc->data[SC_GATLINGFEVER]->val2)
	4078	max = sc->data[SC_GATLINGFEVER]->val2;
	4079
	4080	if(sc->data[SC_FLEET] &&
	4081	max < sc->data[SC_FLEET]->val2)
	4082	max = sc->data[SC_FLEET]->val2;
	4083
	4084	if(sc->data[SC_ASSNCROS] &&
	4085	max < sc->data[SC_ASSNCROS]->val2)
	4086	{
	4087	if (bl->type!=BL_PC)
	4088	max = sc->data[SC_ASSNCROS]->val2;
	4089	else
	4090	switch(((TBL_PC*)bl)->status.weapon)
	4091	{
	4092	case W_BOW:
	4093	case W_REVOLVER:
	4094	case W_RIFLE:
	4095	case W_GATLING:
	4096	case W_SHOTGUN:
	4097	case W_GRENADE:
	4098	break;
	4099	default:
	4100	max = sc->data[SC_ASSNCROS]->val2;
	4101	}
	4102	}
	4103	aspd_rate -= max;
	4104
	4105	//These stack with the rest of bonuses.
	4106	if(sc->data[SC_BERSERK])
	4107	aspd_rate -= 300;
	4108	else if(sc->data[SC_MADNESSCANCEL])
	4109	aspd_rate -= 200;
[10]	4110	//Custom Jobs (blackmagic)
[13]	4111	else if(sc->data[SC_LUST]) // Adept Blood Lust [Brain]
[10]	4112	aspd_rate -= sc->data[SC_LUST]->val2*10;
	4113	//Custom Job End
[1]	4114	}
	4115
	4116	if(sc->data[SC_INCASPDRATE])
	4117	aspd_rate -= sc->data[SC_INCASPDRATE]->val2;
	4118	if(sc->data[i=SC_ASPDPOTION3] \|\|
	4119	sc->data[i=SC_ASPDPOTION2] \|\|
	4120	sc->data[i=SC_ASPDPOTION1] \|\|
	4121	sc->data[i=SC_ASPDPOTION0])
	4122	aspd_rate -= sc->data[i]->val2;
	4123	if(sc->data[SC_DONTFORGETME])
	4124	aspd_rate += sc->data[SC_DONTFORGETME]->val2;
	4125	if(sc->data[SC_LONGING])
	4126	aspd_rate += sc->data[SC_LONGING]->val2;
	4127	if(sc->data[SC_STEELBODY])
	4128	aspd_rate += 250;
	4129	if(sc->data[SC_SKA])
	4130	aspd_rate += 250;
	4131	if(sc->data[SC_DEFENDER])
	4132	aspd_rate += sc->data[SC_DEFENDER]->val4;
	4133	if(sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_ENEMY)
	4134	aspd_rate += 250;
	4135	if(sc->data[SC_GRAVITATION])
	4136	aspd_rate += sc->data[SC_GRAVITATION]->val2;
	4137	if(sc->data[SC_JOINTBEAT]) {
	4138	if( sc->data[SC_JOINTBEAT]->val2&BREAK_WRIST )
	4139	aspd_rate += 250;
	4140	if( sc->data[SC_JOINTBEAT]->val2&BREAK_KNEE )
	4141	aspd_rate += 100;
	4142	}
	4143
	4144	return (short)cap_value(aspd_rate,0,SHRT_MAX);
	4145	}
	4146
	4147	static unsigned short status_calc_dmotion(struct block_list bl, struct status_change sc, int dmotion)
	4148	{
	4149	if(!sc \|\| !sc->count \|\| map_flag_gvg(bl->m))
	4150	return cap_value(dmotion,0,USHRT_MAX);
	4151
	4152	if (sc->data[SC_ENDURE])
	4153	return 0;
	4154	if (sc->data[SC_CONCENTRATION])
	4155	return 0;
	4156	if(sc->data[SC_RUN])
	4157	return 0;
	4158
	4159	return (unsigned short)cap_value(dmotion,0,USHRT_MAX);
	4160	}
	4161
	4162	static unsigned int status_calc_maxhp(struct block_list bl, struct status_change sc, unsigned int maxhp)
	4163	{
	4164	if(!sc \|\| !sc->count)
	4165	return cap_value(maxhp,1,UINT_MAX);
	4166
	4167	if(sc->data[SC_INCMHPRATE])
	4168	maxhp += maxhp * sc->data[SC_INCMHPRATE]->val1/100;
	4169	if(sc->data[SC_APPLEIDUN])
	4170	maxhp += maxhp * sc->data[SC_APPLEIDUN]->val2/100;
	4171	if(sc->data[SC_DELUGE])
	4172	maxhp += maxhp * sc->data[SC_DELUGE]->val2/100;
	4173	if(sc->data[SC_BERSERK])
	4174	maxhp += maxhp * 2;
	4175
	4176	return cap_value(maxhp,1,UINT_MAX);
	4177	}
	4178
	4179	static unsigned int status_calc_maxsp(struct block_list bl, struct status_change sc, unsigned int maxsp)
	4180	{
	4181	if(!sc \|\| !sc->count)
	4182	return cap_value(maxsp,1,UINT_MAX);
	4183
	4184	if(sc->data[SC_INCMSPRATE])
	4185	maxsp += maxsp * sc->data[SC_INCMSPRATE]->val1/100;
	4186	if(sc->data[SC_SERVICE4U])
	4187	maxsp += maxsp * sc->data[SC_SERVICE4U]->val2/100;
	4188
	4189	return cap_value(maxsp,1,UINT_MAX);
	4190	}
	4191
	4192	static unsigned char status_calc_element(struct block_list bl, struct status_change sc, int element)
	4193	{
	4194	if(!sc \|\| !sc->count)
	4195	return element;
	4196
	4197	if(sc->data[SC_FREEZE])
	4198	return ELE_WATER;
	4199	if(sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
	4200	return ELE_EARTH;
	4201	if(sc->data[SC_BENEDICTIO])
	4202	return ELE_HOLY;
	4203	if(sc->data[SC_CHANGEUNDEAD])
	4204	return ELE_UNDEAD;
	4205	if(sc->data[SC_ELEMENTALCHANGE])
	4206	return sc->data[SC_ELEMENTALCHANGE]->val2;
[10]	4207	//Custom Jobs (blackmagic)
[13]	4208	if( sc->data[SC_DEATHPACT]) // Necro Death Pact [Brain]
	4209	return ELE_UNDEAD;
	4210	if( sc->data[SC_OVERWHELMING]) // Warlock Overwhelming Evil [Brain]
[10]	4211	return ELE_DARK;
	4212	//Custom Job End
[1]	4213	return (unsigned char)cap_value(element,0,UCHAR_MAX);
	4214	}
	4215
	4216	static unsigned char status_calc_element_lv(struct block_list bl, struct status_change sc, int lv)
	4217	{
	4218	if(!sc \|\| !sc->count)
	4219	return lv;
	4220
	4221	if(sc->data[SC_FREEZE])
	4222	return 1;
	4223	if(sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
	4224	return 1;
	4225	if(sc->data[SC_BENEDICTIO])
	4226	return 1;
	4227	if(sc->data[SC_CHANGEUNDEAD])
	4228	return 1;
	4229	if(sc->data[SC_ELEMENTALCHANGE])
	4230	return sc->data[SC_ELEMENTALCHANGE]->val1;
[10]	4231	//Custom Jobs (blackmagic)
[13]	4232	if( sc->data[SC_DEATHPACT]) // Necro Death Pact [Brain]
[10]	4233	return 1;
[13]	4234	if( sc->data[SC_OVERWHELMING]) // Warlock Overwhelming Evil [Brain]
	4235	return 1;
[10]	4236	//Custom Job End
[1]	4237
	4238	return (unsigned char)cap_value(lv,1,4);
	4239	}
	4240
	4241
	4242	unsigned char status_calc_attack_element(struct block_list bl, struct status_change sc, int element)
	4243	{
	4244	if(!sc \|\| !sc->count)
	4245	return element;
	4246	if(sc->data[SC_ENCHANTARMS])
	4247	return sc->data[SC_ENCHANTARMS]->val2;
	4248	if(sc->data[SC_WATERWEAPON])
	4249	return ELE_WATER;
	4250	if(sc->data[SC_EARTHWEAPON])
	4251	return ELE_EARTH;
	4252	if(sc->data[SC_FIREWEAPON])
	4253	return ELE_FIRE;
	4254	if(sc->data[SC_WINDWEAPON])
	4255	return ELE_WIND;
	4256	if(sc->data[SC_ENCPOISON])
	4257	return ELE_POISON;
	4258	if(sc->data[SC_ASPERSIO])
	4259	return ELE_HOLY;
	4260	if(sc->data[SC_SHADOWWEAPON])
	4261	return ELE_DARK;
	4262	if(sc->data[SC_GHOSTWEAPON])
	4263	return ELE_GHOST;
	4264	return (unsigned char)cap_value(element,0,UCHAR_MAX);
	4265	}
	4266
	4267	static unsigned short status_calc_mode(struct block_list bl, struct status_change sc, int mode)
	4268	{
	4269	if(!sc \|\| !sc->count)
	4270	return mode;
	4271	if(sc->data[SC_MODECHANGE]) {
	4272	if (sc->data[SC_MODECHANGE]->val2)
	4273	mode = sc->data[SC_MODECHANGE]->val2; //Set mode
	4274	if (sc->data[SC_MODECHANGE]->val3)
	4275	mode\|= sc->data[SC_MODECHANGE]->val3; //Add mode
	4276	if (sc->data[SC_MODECHANGE]->val4)
	4277	mode&=~sc->data[SC_MODECHANGE]->val4; //Del mode
	4278	}
	4279	return cap_value(mode,0,USHRT_MAX);
	4280	}
	4281
	4282	/*==========================================
	4283	* Quick swap of adelay/speed when starting ending SA_FREECAST
	4284	------------------------------------------/
	4285	void status_freecast_switch(struct map_session_data *sd)
	4286	{
	4287	struct status_data *status;
	4288	unsigned short b_speed,tmp;
	4289
	4290	status = &sd->battle_status;
	4291
	4292	b_speed = status->speed;
	4293
	4294	tmp = status->speed;
	4295	status->speed = sd->prev_speed;
	4296	sd->prev_speed = tmp;
	4297
	4298	tmp = status->adelay;
	4299	status->adelay = sd->prev_adelay;
	4300	sd->prev_adelay = tmp;
	4301
	4302	if(b_speed != status->speed)
	4303	clif_updatestatus(sd,SP_SPEED);
	4304	}
	4305
	4306	const char* status_get_name(struct block_list *bl)
	4307	{
	4308	nullpo_retr(0, bl);
	4309	switch (bl->type) {
	4310	case BL_PC: return ((TBL_PC )bl)->fakename[0] != '\0' ? ((TBL_PC)bl)->fakename : ((TBL_PC*)bl)->status.name;
	4311	case BL_MOB: return ((TBL_MOB*)bl)->name;
	4312	case BL_PET: return ((TBL_PET*)bl)->pet.name;
	4313	case BL_HOM: return ((TBL_HOM*)bl)->homunculus.name;
	4314	case BL_NPC: return ((TBL_NPC*)bl)->name;
	4315	}
	4316	return "Unknown";
	4317	}
	4318
	4319	/*==========================================
	4320	* ÎÛÌClassðÔ·(Äp)
	4321	* ßèÍ®Å0Èã
	4322	------------------------------------------/
	4323	int status_get_class(struct block_list *bl)
	4324	{
	4325	nullpo_retr(0, bl);
	4326	switch( bl->type )
	4327	{
	4328	case BL_PC: return ((TBL_PC*)bl)->status.class_;
	4329	case BL_MOB: return ((TBL_MOB*)bl)->vd->class_; //Class used on all code should be the view class of the mob.
	4330	case BL_PET: return ((TBL_PET*)bl)->pet.class_;
	4331	case BL_HOM: return ((TBL_HOM*)bl)->homunculus.class_;
	4332	case BL_NPC: return ((TBL_NPC*)bl)->class_;
	4333	}
	4334	return 0;
	4335	}
	4336	/*==========================================
	4337	* ÎÛÌxðÔ·(Äp)
	4338	* ßèÍ®Å0Èã
	4339	------------------------------------------/
	4340	int status_get_lv(struct block_list *bl)
	4341	{
	4342	nullpo_retr(0, bl);
	4343	switch (bl->type) {
	4344	case BL_PC: return ((TBL_PC*)bl)->status.base_level;
	4345	case BL_MOB: return ((TBL_MOB*)bl)->level;
	4346	case BL_PET: return ((TBL_PET*)bl)->pet.level;
	4347	case BL_HOM: return ((TBL_HOM*)bl)->homunculus.level;
	4348	}
	4349	return 1;
	4350	}
	4351
	4352	struct regen_data status_get_regen_data(struct block_list bl)
	4353	{
	4354	nullpo_retr(NULL, bl);
	4355	switch (bl->type) {
	4356	case BL_PC: return &((TBL_PC*)bl)->regen;
	4357	case BL_HOM: return &((TBL_HOM*)bl)->regen;
	4358	default:
	4359	return NULL;
	4360	}
	4361	}
	4362
	4363	struct status_data status_get_status_data(struct block_list bl)
	4364	{
	4365	nullpo_retr(&dummy_status, bl);
	4366
	4367	switch (bl->type) {
	4368	case BL_PC: return &((TBL_PC*)bl)->battle_status;
	4369	case BL_MOB: return &((TBL_MOB*)bl)->status;
	4370	case BL_PET: return &((TBL_PET*)bl)->status;
	4371	case BL_HOM: return &((TBL_HOM*)bl)->battle_status;
	4372	default:
	4373	return &dummy_status;
	4374	}
	4375	}
	4376
	4377	struct status_data status_get_base_status(struct block_list bl)
	4378	{
	4379	nullpo_retr(NULL, bl);
	4380	switch (bl->type) {
	4381	case BL_PC: return &((TBL_PC*)bl)->base_status;
	4382	case BL_MOB: return ((TBL_MOB)bl)->base_status ? ((TBL_MOB)bl)->base_status : &((TBL_MOB*)bl)->db->status;
	4383	case BL_PET: return &((TBL_PET*)bl)->db->status;
	4384	case BL_HOM: return &((TBL_HOM*)bl)->base_status;
	4385	default:
	4386	return NULL;
	4387	}
	4388	}
	4389
	4390	signed char status_get_def(struct block_list *bl)
	4391	{
	4392	struct unit_data *ud;
	4393	struct status_data *status = status_get_status_data(bl);
	4394	int def = status?status->def:0;
	4395	ud = unit_bl2ud(bl);
	4396	if (ud && ud->skilltimer != -1)
	4397	def -= def * skill_get_castdef(ud->skillid)/100;
	4398	return cap_value(def, CHAR_MIN, CHAR_MAX);
	4399	}
	4400
	4401	unsigned short status_get_speed(struct block_list *bl)
	4402	{
	4403	if(bl->type==BL_NPC)//Only BL with speed data but no status_data [Skotlex]
	4404	return ((struct npc_data *)bl)->speed;
	4405	return status_get_status_data(bl)->speed;
	4406	}
	4407
	4408	int status_get_party_id(struct block_list *bl)
	4409	{
	4410	nullpo_retr(0, bl);
	4411	switch (bl->type) {
	4412	case BL_PC:
	4413	return ((TBL_PC*)bl)->status.party_id;
	4414	case BL_PET:
	4415	if (((TBL_PET*)bl)->msd)
	4416	return ((TBL_PET*)bl)->msd->status.party_id;
	4417	break;
	4418	case BL_MOB:
	4419	{
	4420	struct mob_data md=(TBL_MOB)bl;
	4421	if( md->master_id>0 )
	4422	{
	4423	struct map_session_data *msd;
	4424	if (md->special_state.ai && (msd = map_id2sd(md->master_id)) != NULL)
	4425	return msd->status.party_id;
	4426	return -md->master_id;
	4427	}
	4428	}
	4429	break;
	4430	case BL_HOM:
	4431	if (((TBL_HOM*)bl)->master)
	4432	return ((TBL_HOM*)bl)->master->status.party_id;
	4433	break;
	4434	case BL_SKILL:
	4435	return ((TBL_SKILL*)bl)->group->party_id;
	4436	}
	4437	return 0;
	4438	}
	4439
	4440	int status_get_guild_id(struct block_list *bl)
	4441	{
	4442	nullpo_retr(0, bl);
	4443	switch (bl->type) {
	4444	case BL_PC:
	4445	return ((TBL_PC*)bl)->status.guild_id;
	4446	case BL_PET:
	4447	if (((TBL_PET*)bl)->msd)
	4448	return ((TBL_PET*)bl)->msd->status.guild_id;
	4449	break;
	4450	case BL_MOB:
	4451	{
	4452	struct map_session_data *msd;
	4453	struct mob_data md = (struct mob_data )bl;
	4454	if (md->guardian_data) //Guardian's guild [Skotlex]
	4455	return md->guardian_data->guild_id;
	4456	if (md->special_state.ai && (msd = map_id2sd(md->master_id)) != NULL)
	4457	return msd->status.guild_id; //Alchemist's mobs [Skotlex]
	4458	}
	4459	break;
	4460	case BL_HOM:
	4461	if (((TBL_HOM*)bl)->master)
	4462	return ((TBL_HOM*)bl)->master->status.guild_id;
	4463	break;
	4464	case BL_NPC:
	4465	if (((TBL_NPC*)bl)->subtype == SCRIPT)
	4466	return ((TBL_NPC*)bl)->u.scr.guild_id;
	4467	break;
	4468	case BL_SKILL:
	4469	return ((TBL_SKILL*)bl)->group->guild_id;
	4470	}
	4471	return 0;
	4472	}
	4473
	4474	int status_get_emblem_id(struct block_list *bl)
	4475	{
	4476	nullpo_retr(0, bl);
	4477	switch (bl->type) {
	4478	case BL_PC:
	4479	return ((TBL_PC*)bl)->guild_emblem_id;
	4480	case BL_PET:
	4481	if (((TBL_PET*)bl)->msd)
	4482	return ((TBL_PET*)bl)->msd->guild_emblem_id;
	4483	break;
	4484	case BL_MOB:
	4485	{
	4486	struct map_session_data *msd;
	4487	struct mob_data md = (struct mob_data )bl;
	4488	if (md->guardian_data) //Guardian's guild [Skotlex]
	4489	return md->guardian_data->emblem_id;
	4490	if (md->special_state.ai && (msd = map_id2sd(md->master_id)) != NULL)
	4491	return msd->guild_emblem_id; //Alchemist's mobs [Skotlex]
	4492	}
	4493	break;
	4494	case BL_HOM:
	4495	if (((TBL_HOM*)bl)->master)
	4496	return ((TBL_HOM*)bl)->master->guild_emblem_id;
	4497	break;
	4498	case BL_NPC:
	4499	if (((TBL_NPC)bl)->subtype == SCRIPT && ((TBL_NPC)bl)->u.scr.guild_id > 0) {
	4500	struct guild g = guild_search(((TBL_NPC)bl)->u.scr.guild_id);
	4501	if (g)
	4502	return g->emblem_id;
	4503	}
	4504	break;
	4505	}
	4506	return 0;
	4507	}
	4508
	4509	int status_get_mexp(struct block_list *bl)
	4510	{
	4511	nullpo_retr(0, bl);
	4512	if(bl->type==BL_MOB)
	4513	return ((struct mob_data *)bl)->db->mexp;
	4514	if(bl->type==BL_PET)
	4515	return ((struct pet_data *)bl)->db->mexp;
	4516	return 0;
	4517	}
	4518	int status_get_race2(struct block_list *bl)
	4519	{
	4520	nullpo_retr(0, bl);
	4521	if(bl->type == BL_MOB)
	4522	return ((struct mob_data *)bl)->db->race2;
	4523	if(bl->type==BL_PET)
	4524	return ((struct pet_data *)bl)->db->race2;
	4525	return 0;
	4526	}
	4527
	4528	int status_isdead(struct block_list *bl)
	4529	{
	4530	nullpo_retr(0, bl);
	4531	return status_get_status_data(bl)->hp == 0;
	4532	}
	4533
	4534	int status_isimmune(struct block_list *bl)
	4535	{
	4536	struct status_change *sc =status_get_sc(bl);
	4537	if (sc && sc->data[SC_HERMODE])
	4538	return 100;
	4539
	4540	if (bl->type == BL_PC &&
	4541	((TBL_PC*)bl)->special_state.no_magic_damage >= battle_config.gtb_sc_immunity)
	4542	return ((TBL_PC*)bl)->special_state.no_magic_damage;
	4543	return 0;
	4544	}
	4545
	4546	struct view_data* status_get_viewdata(struct block_list *bl)
	4547	{
	4548	nullpo_retr(NULL, bl);
	4549	switch (bl->type) {
	4550	case BL_PC: return &((TBL_PC*)bl)->vd;
	4551	case BL_MOB: return ((TBL_MOB*)bl)->vd;
	4552	case BL_PET: return &((TBL_PET*)bl)->vd;
	4553	case BL_NPC: return ((TBL_NPC*)bl)->vd;
	4554	case BL_HOM: return ((TBL_HOM*)bl)->vd;
	4555	}
	4556	return NULL;
	4557	}
	4558
	4559	void status_set_viewdata(struct block_list *bl, int class_)
	4560	{
	4561	struct view_data* vd;
	4562	nullpo_retv(bl);
	4563	if (mobdb_checkid(class_) \|\| mob_is_clone(class_))
	4564	vd = mob_get_viewdata(class_);
	4565	else if (npcdb_checkid(class_) \|\| (bl->type == BL_NPC && class_ == WARP_CLASS))
	4566	vd = npc_get_viewdata(class_);
	4567	else if (homdb_checkid(class_))
	4568	vd = merc_get_hom_viewdata(class_);
	4569	else
	4570	vd = NULL;
	4571
	4572	switch (bl->type) {
	4573	case BL_PC:
	4574	{
	4575	TBL_PC* sd = (TBL_PC*)bl;
	4576	if (pcdb_checkid(class_)) {
	4577	if (sd->sc.option&OPTION_WEDDING)
	4578	class_ = JOB_WEDDING;
	4579	else
	4580	if (sd->sc.option&OPTION_SUMMER)
	4581	class_ = JOB_SUMMER;
	4582	else
	4583	if (sd->sc.option&OPTION_XMAS)
	4584	class_ = JOB_XMAS;
	4585	else
	4586	if (sd->sc.option&OPTION_RIDING)
	4587	switch (class_)
	4588	{ //Adapt class to a Mounted one.
	4589	case JOB_KNIGHT:
	4590	class_ = JOB_KNIGHT2;
	4591	break;
	4592	case JOB_CRUSADER:
	4593	class_ = JOB_CRUSADER2;
	4594	break;
	4595	case JOB_LORD_KNIGHT:
	4596	class_ = JOB_LORD_KNIGHT2;
	4597	break;
	4598	case JOB_PALADIN:
	4599	class_ = JOB_PALADIN2;
	4600	break;
	4601	case JOB_BABY_KNIGHT:
	4602	class_ = JOB_BABY_KNIGHT2;
	4603	break;
	4604	case JOB_BABY_CRUSADER:
	4605	class_ = JOB_BABY_CRUSADER2;
	4606	break;
	4607	}
	4608	sd->vd.class_ = class_;
	4609	clif_get_weapon_view(sd, &sd->vd.weapon, &sd->vd.shield);
	4610	sd->vd.head_top = sd->status.head_top;
	4611	sd->vd.head_mid = sd->status.head_mid;
	4612	sd->vd.head_bottom = sd->status.head_bottom;
	4613	sd->vd.hair_style = sd->status.hair;
	4614	sd->vd.hair_color = sd->status.hair_color;
	4615	sd->vd.cloth_color = sd->status.clothes_color;
	4616	sd->vd.sex = sd->status.sex;
	4617	} else if (vd)
	4618	memcpy(&sd->vd, vd, sizeof(struct view_data));
	4619	else
	4620	ShowError("status_set_viewdata (PC): No view data for class %d\n", class_);
	4621	}
	4622	break;
	4623	case BL_MOB:
	4624	{
	4625	TBL_MOB* md = (TBL_MOB*)bl;
	4626	if (vd)
	4627	md->vd = vd;
	4628	else
	4629	ShowError("status_set_viewdata (MOB): No view data for class %d\n", class_);
	4630	}
	4631	break;
	4632	case BL_PET:
	4633	{
	4634	TBL_PET* pd = (TBL_PET*)bl;
	4635	if (vd) {
	4636	memcpy(&pd->vd, vd, sizeof(struct view_data));
	4637	if (!pcdb_checkid(vd->class_)) {
	4638	pd->vd.hair_style = battle_config.pet_hair_style;
	4639	if(pd->pet.equip) {
	4640	pd->vd.head_bottom = itemdb_viewid(pd->pet.equip);
	4641	if (!pd->vd.head_bottom)
	4642	pd->vd.head_bottom = pd->pet.equip;
	4643	}
	4644	}
	4645	} else
	4646	ShowError("status_set_viewdata (PET): No view data for class %d\n", class_);
	4647	}
	4648	break;
	4649	case BL_NPC:
	4650	{
	4651	TBL_NPC* nd = (TBL_NPC*)bl;
	4652	if (vd)
	4653	nd->vd = vd;
	4654	else
	4655	ShowError("status_set_viewdata (NPC): No view data for class %d\n", class_);
	4656	}
	4657	break;
	4658	case BL_HOM: //[blackhole89]
	4659	{
	4660	struct homun_data hd = (struct homun_data)bl;
	4661	if (vd)
	4662	hd->vd = vd;
	4663	else
	4664	ShowError("status_set_viewdata (HOMUNCULUS): No view data for class %d\n", class_);
	4665	}
	4666	break;
	4667	}
	4668	vd = status_get_viewdata(bl);
	4669	if (vd && vd->cloth_color && (
	4670	(vd->class_==JOB_WEDDING && battle_config.wedding_ignorepalette)
	4671	\|\| (vd->class_==JOB_XMAS && battle_config.xmas_ignorepalette)
	4672	\|\| (vd->class_==JOB_SUMMER && battle_config.summer_ignorepalette)
	4673	))
	4674	vd->cloth_color = 0;
	4675	}
	4676
	4677	struct status_change status_get_sc(struct block_list bl)
	4678	{
	4679	nullpo_retr(NULL, bl);
	4680	switch (bl->type) {
	4681	case BL_PC: return &((TBL_PC*)bl)->sc;
	4682	case BL_MOB: return &((TBL_MOB*)bl)->sc;
	4683	case BL_NPC: return &((TBL_NPC*)bl)->sc;
	4684	case BL_HOM: return &((TBL_HOM*)bl)->sc;
	4685	}
	4686	return NULL;
	4687	}
	4688
	4689	void status_change_init(struct block_list *bl)
	4690	{
	4691	struct status_change *sc = status_get_sc(bl);
	4692	nullpo_retv(sc);
	4693	memset(sc, 0, sizeof (struct status_change));
	4694	}
	4695
	4696	//Applies SC defense to a given status change.
	4697	//Returns the adjusted duration based on flag values.
	4698	//the flag values are the same as in status_change_start.
	4699	int status_get_sc_def(struct block_list *bl, enum sc_type type, int rate, int tick, int flag)
	4700	{
	4701	int sc_def, tick_def = 0;
	4702	struct status_data* status;
	4703	struct status_change* sc;
	4704	struct map_session_data *sd;
	4705
	4706	nullpo_retr(0, bl);
	4707
	4708	//Status that are blocked by Golden Thief Bug card or Wand of Hermod
	4709	if (status_isimmune(bl))
	4710	switch (type)
	4711	{
	4712	case SC_DECREASEAGI:
	4713	case SC_SILENCE:
	4714	case SC_COMA:
	4715	case SC_INCREASEAGI:
	4716	case SC_BLESSING:
	4717	case SC_SLOWPOISON:
	4718	case SC_IMPOSITIO:
	4719	case SC_AETERNA:
	4720	case SC_SUFFRAGIUM:
	4721	case SC_BENEDICTIO:
	4722	case SC_PROVIDENCE:
	4723	case SC_KYRIE:
	4724	case SC_ASSUMPTIO:
	4725	case SC_ANGELUS:
	4726	case SC_MAGNIFICAT:
	4727	case SC_GLORIA:
	4728	case SC_WINDWALK:
	4729	case SC_MAGICROD:
	4730	case SC_HALLUCINATION:
	4731	case SC_STONE:
	4732	case SC_QUAGMIRE:
	4733	case SC_SUITON:
	4734	return 0;
	4735	}
	4736
	4737	sd = BL_CAST(BL_PC,bl);
	4738	status = status_get_status_data(bl);
	4739	switch (type)
	4740	{
	4741	case SC_STUN:
	4742	case SC_POISON:
	4743	case SC_DPOISON:
	4744	case SC_SILENCE:
	4745	case SC_BLEEDING:
	4746	sc_def = 3 +status->vit;
	4747	break;
	4748	case SC_SLEEP:
	4749	sc_def = 3 +status->int_;
	4750	break;
	4751	case SC_DECREASEAGI:
	4752	if (sd) tick>>=1; //Half duration for players.
	4753	case SC_STONE:
	4754	case SC_FREEZE:
	4755	sc_def = 3 +status->mdef;
	4756	break;
	4757	case SC_CURSE:
	4758	//Special property: inmunity when luk is greater than level
	4759	if (status->luk > status_get_lv(bl))
	4760	return 0;
	4761	else
	4762	sc_def = 3 +status->luk;
	4763	tick_def = status->vit;
	4764	break;
	4765	case SC_BLIND: //TODO: These 50/50 factors are guessed. Need to find actual value.
	4766	sc_def = 3 +(status->vit + status->int_)/2;
	4767	break;
	4768	case SC_CONFUSION:
	4769	sc_def = 3 +(status->str + status->int_)/2;
	4770	break;
	4771	case SC_ANKLE:
	4772	if(status->mode&MD_BOSS) // Lasts 5 times less on bosses
	4773	tick /= 5;
	4774	sc_def = status->agi / 2;
	4775	break;
	4776	case SC_MAGICMIRROR:
	4777	case SC_ARMORCHANGE:
	4778	if (sd) //Duration greatly reduced for players.
	4779	tick /= 15;
	4780	//No defense against it (buff).
	4781	default:
	4782	//Effect that cannot be reduced? Likely a buff.
	4783	if (!(rand()%10000 < rate))
	4784	return 0;
	4785	return tick?tick:1;
	4786	}
	4787
	4788	if (sd) {
	4789
	4790	if (battle_config.pc_sc_def_rate != 100)
	4791	sc_def = sc_def*battle_config.pc_sc_def_rate/100;
	4792
	4793	if (sc_def < battle_config.pc_max_sc_def)
	4794	sc_def += (battle_config.pc_max_sc_def - sc_def)*
	4795	status->luk/battle_config.pc_luk_sc_def;
	4796	else
	4797	sc_def = battle_config.pc_max_sc_def;
	4798
	4799	if (tick_def) {
	4800	if (battle_config.pc_sc_def_rate != 100)
	4801	tick_def = tick_def*battle_config.pc_sc_def_rate/100;
	4802	}
	4803
	4804	} else {
	4805
	4806	if (battle_config.mob_sc_def_rate != 100)
	4807	sc_def = sc_def*battle_config.mob_sc_def_rate/100;
	4808
	4809	if (sc_def < battle_config.mob_max_sc_def)
	4810	sc_def += (battle_config.mob_max_sc_def - sc_def)*
	4811	status->luk/battle_config.mob_luk_sc_def;
	4812	else
	4813	sc_def = battle_config.mob_max_sc_def;
	4814
	4815	if (tick_def) {
	4816	if (battle_config.mob_sc_def_rate != 100)
	4817	tick_def = tick_def*battle_config.mob_sc_def_rate/100;
	4818	}
	4819	}
	4820
	4821	sc = status_get_sc(bl);
	4822	if (sc && sc->count)
	4823	{
	4824	if (sc->data[SC_SCRESIST])
	4825	sc_def += sc->data[SC_SCRESIST]->val1; //Status resist
	4826	else if (sc->data[SC_SIEGFRIED])
	4827	sc_def += sc->data[SC_SIEGFRIED]->val3; //Status resistance.
	4828	}
	4829
	4830	//When no tick def, reduction is the same for both.
	4831	if (!tick_def) tick_def = sc_def;
	4832
	4833	//Natural resistance
	4834	if (!(flag&8)) {
	4835	rate -= rate*sc_def/100;
	4836
	4837	//Item resistance (only applies to rate%)
	4838	if(sd && SC_COMMON_MIN <= type && type <= SC_COMMON_MAX)
	4839	{
	4840	if( sd->reseff[type-SC_COMMON_MIN] > 0 )
	4841	rate -= rate*sd->reseff[type-SC_COMMON_MIN]/10000;
	4842	if( sd->sc.data[SC_COMMONSC_RESIST] )
	4843	rate -= rate*sd->sc.data[SC_COMMONSC_RESIST]->val1;
	4844	}
	4845	}
	4846	if (!(rand()%10000 < rate))
	4847	return 0;
	4848
	4849	//Why would a status start with no duration? Presume it has
	4850	//duration defined elsewhere.
	4851	if (!tick) return 1;
	4852
	4853	//Rate reduction
	4854	if (flag&2)
	4855	return tick;
	4856
	4857	tick -= tick*tick_def/100;
	4858	// Changed to 5 seconds according to recent tests [Playtester]
	4859	if (type == SC_ANKLE && tick < 5000)
	4860	tick = 5000;
	4861	return tick<=0?0:tick;
	4862	}
	4863
	4864	/*==========================================
	4865	* Starts a status change.
	4866	* 'type' = type, 'val1~4' depend on the type.
	4867	* 'rate' = base success rate. 10000 = 100%
	4868	* 'tick' is base duration
	4869	* 'flag':
	4870	* &1: Cannot be avoided (it has to start)
	4871	* &2: Tick should not be reduced (by vit, luk, lv, etc)
	4872	* &4: sc_data loaded, no value has to be altered.
	4873	* &8: rate should not be reduced
	4874	------------------------------------------/
	4875	int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val1,int val2,int val3,int val4,int tick,int flag)
	4876	{
	4877	struct map_session_data *sd = NULL;
	4878	struct status_change* sc;
	4879	struct status_change_entry* sce;
	4880	struct status_data *status;
	4881	struct view_data *vd;
	4882	int opt_flag, calc_flag, undead_flag;
	4883
	4884	nullpo_retr(0, bl);
	4885	sc = status_get_sc(bl);
	4886	status = status_get_status_data(bl);
	4887
	4888	if( type <= SC_NONE \|\| type >= SC_MAX )
	4889	{
	4890	ShowError("status_change_start: invalid status change (%d)!\n", type);
	4891	return 0;
	4892	}
	4893
	4894	if( !sc )
	4895	return 0; //Unable to receive status changes
	4896
	4897	if( status_isdead(bl) )
	4898	return 0;
	4899
	4900	if( bl->type == BL_MOB )
	4901	{
	4902	struct mob_data *md = BL_CAST(BL_MOB,bl);
	4903	if( (md->class_ == MOBID_EMPERIUM && type != SC_SAFETYWALL && type != SC_PNEUMA) \|\| md->barricade )
	4904	return 0; //Emperium can't be afflicted by status changes
	4905	}
	4906
	4907	sd = BL_CAST(BL_PC, bl);
	4908
	4909	//Adjust tick according to status resistances
	4910	if( !(flag&(1\|4)) )
	4911	{
	4912	tick = status_get_sc_def(bl, type, rate, tick, flag);
	4913	if( !tick ) return 0;
	4914	}
	4915
	4916	undead_flag = battle_check_undead(status->race,status->def_ele);
	4917	//Check for inmunities / sc fails
	4918	switch (type)
	4919	{
	4920	case SC_FREEZE:
	4921	case SC_STONE:
	4922	//Undead are immune to Freeze/Stone
	4923	if (undead_flag && !(flag&1))
	4924	return 0;
	4925	case SC_SLEEP:
	4926	case SC_STUN:
	4927	if (sc->opt1)
	4928	return 0; //Cannot override other opt1 status changes. [Skotlex]
	4929	break;
	4930	case SC_SIGNUMCRUCIS:
	4931	//Only affects demons and undead element (but not players)
	4932	if((!undead_flag && status->race!=RC_DEMON) \|\| bl->type == BL_PC)
	4933	return 0;
	4934	break;
	4935	case SC_AETERNA:
	4936	if (sc->data[SC_STONE] \|\| sc->data[SC_FREEZE])
	4937	return 0;
	4938	break;
	4939	case SC_KYRIE:
	4940	if (bl->type == BL_MOB)
	4941	return 0;
	4942	break;
	4943	case SC_OVERTHRUST:
	4944	if (sc->data[SC_MAXOVERTHRUST])
	4945	return 0; //Overthrust can't take effect if under Max Overthrust. [Skotlex]
	4946	break;
	4947	case SC_ADRENALINE:
	4948	if(sd && !pc_check_weapontype(sd,skill_get_weapontype(BS_ADRENALINE)))
	4949	return 0;
	4950	if (sc->data[SC_QUAGMIRE] \|\|
	4951	sc->data[SC_DECREASEAGI]
	4952	)
	4953	return 0;
	4954	break;
	4955	case SC_ADRENALINE2:
	4956	if(sd && !pc_check_weapontype(sd,skill_get_weapontype(BS_ADRENALINE2)))
	4957	return 0;
	4958	if (sc->data[SC_QUAGMIRE] \|\|
	4959	sc->data[SC_DECREASEAGI]
	4960	)
	4961	return 0;
	4962	break;
	4963	case SC_ONEHAND:
	4964	case SC_TWOHANDQUICKEN:
	4965	if(sc->data[SC_DECREASEAGI])
	4966	return 0;
	4967	case SC_CONCENTRATE:
	4968	case SC_INCREASEAGI:
	4969	case SC_SPEARQUICKEN:
	4970	case SC_TRUESIGHT:
	4971	case SC_WINDWALK:
	4972	case SC_CARTBOOST:
	4973	case SC_ASSNCROS:
[10]	4974	//Custom Jobs (blackmagic)
	4975	case SC_LUST: // Adept Blood Lust [Brain]
	4976	//Custom Job End
[1]	4977	if (sc->data[SC_QUAGMIRE])
	4978	return 0;
	4979	break;
	4980	case SC_CLOAKING:
	4981	//Avoid cloaking with no wall and low skill level. [Skotlex]
	4982	//Due to the cloaking card, we have to check the wall versus to known
	4983	//skill level rather than the used one. [Skotlex]
	4984	//if (sd && val1 < 3 && skill_check_cloaking(bl,NULL))
	4985	if( sd && pc_checkskill(sd, AS_CLOAKING) < 3 && !skill_check_cloaking(bl,NULL) )
	4986	return 0;
	4987	break;
	4988	case SC_MODECHANGE:
	4989	{
	4990	int mode;
	4991	struct status_data *bstatus = status_get_base_status(bl);
	4992	if (!bstatus) return 0;
	4993	if (sc->data[type])
	4994	{ //Pile up with previous values.
	4995	if(!val2) val2 = sc->data[type]->val2;
	4996	val3 \|= sc->data[type]->val3;
	4997	val4 \|= sc->data[type]->val4;
	4998	}
	4999	mode = val2?val2:bstatus->mode; //Base mode
	5000	if (val4) mode&=~val4; //Del mode
	5001	if (val3) mode\|= val3; //Add mode
	5002	if (mode == bstatus->mode) { //No change.
	5003	if (sc->data[type]) //Abort previous status
	5004	return status_change_end(bl, type, -1);
	5005	return 0;
	5006	}
	5007	}
	5008	break;
	5009	//Strip skills, need to divest something or it fails.
	5010	case SC_STRIPWEAPON:
	5011	if (sd) {
	5012	int i;
	5013	opt_flag = 0; //Reuse to check success condition.
	5014	if(sd->unstripable_equip&EQP_WEAPON)
	5015	return 0;
	5016	i = sd->equip_index[EQI_HAND_L];
	5017	if (i>=0 && sd->inventory_data[i] &&
	5018	sd->inventory_data[i]->type == IT_WEAPON)
	5019	{
	5020	opt_flag\|=1;
	5021	pc_unequipitem(sd,i,3); //L-hand weapon
	5022	}
	5023
	5024	i = sd->equip_index[EQI_HAND_R];
	5025	if (i>=0 && sd->inventory_data[i] &&
	5026	sd->inventory_data[i]->type == IT_WEAPON)
	5027	{
	5028	opt_flag\|=2;
	5029	pc_unequipitem(sd,i,3);
	5030	}
	5031	if (!opt_flag) return 0;
	5032	}
	5033	if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
	5034	break;
	5035	case SC_STRIPSHIELD:
	5036	if (sd) {
	5037	int i;
	5038	if(sd->unstripable_equip&EQP_SHIELD)
	5039	return 0;
	5040	i = sd->equip_index[EQI_HAND_L];
	5041	if (i<0 \|\| !sd->inventory_data[i] \|\|
	5042	sd->inventory_data[i]->type != IT_ARMOR)
	5043	return 0;
	5044	pc_unequipitem(sd,i,3);
	5045	}
	5046	if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
	5047	break;
	5048	case SC_STRIPARMOR:
	5049	if (sd) {
	5050	int i;
	5051	if(sd->unstripable_equip&EQP_ARMOR)
	5052	return 0;
	5053	i = sd->equip_index[EQI_ARMOR];
	5054	if (i<0 \|\| !sd->inventory_data[i])
	5055	return 0;
	5056	pc_unequipitem(sd,i,3);
	5057	}
	5058	if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
	5059	break;
	5060	case SC_STRIPHELM:
	5061	if (sd) {
	5062	int i;
	5063	if(sd->unstripable_equip&EQP_HELM)
	5064	return 0;
	5065	i = sd->equip_index[EQI_HEAD_TOP];
	5066	if (i<0 \|\| !sd->inventory_data[i])
	5067	return 0;
	5068	pc_unequipitem(sd,i,3);
	5069	}
	5070	if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
	5071	break;
	5072	}
	5073
	5074	//Check for BOSS resistances
	5075	if(status->mode&MD_BOSS && !(flag&1)) {
	5076	if (type>=SC_COMMON_MIN && type <= SC_COMMON_MAX)
	5077	return 0;
	5078	switch (type) {
	5079	case SC_BLESSING:
	5080	if (status->race!=RC_UNDEAD && status->race!=RC_DEMON)
	5081	break;
	5082	case SC_QUAGMIRE:
	5083	case SC_DECREASEAGI:
	5084	case SC_PROVOKE:
	5085	case SC_COMA:
	5086	case SC_GRAVITATION:
	5087	case SC_SUITON:
	5088	case SC_STRIPWEAPON:
	5089	case SC_STRIPSHIELD:
	5090	case SC_STRIPARMOR:
	5091	case SC_STRIPHELM:
	5092	case SC_RICHMANKIM:
	5093	case SC_ROKISWEIL:
	5094	case SC_FOGWALL:
[10]	5095	//Custom Jobs (blackmagic)
[13]	5096	//New status [Brainstorm]
	5097	case SC_FEAR:
	5098	case SC_DECREPIFY:
	5099	case SC_DARKMOON:
	5100	case SC_REQUIEM:
	5101	case SC_CURSETONGUES:
	5102	case SC_CURSEWEAKNESS:
[10]	5103	case SC_CURSEEXHAUST:
	5104	//Custom Job End
[1]	5105	return 0;
	5106	}
	5107	}
	5108
	5109	//Before overlapping fail, one must check for status cured.
	5110	switch (type)
	5111	{
	5112	case SC_BLESSING:
	5113	//TO-DO Blessing and Agi up should do 1 damage against players on Undead Status, even on PvM
	5114	//but cannot be plagiarized (this requires aegis investigation on packets and official behavior) [Brainstorm]
	5115	if (status->race!=RC_UNDEAD && status->race!=RC_DEMON) {
	5116	if (sc->data[SC_CURSE])
	5117	status_change_end(bl,SC_CURSE,-1);
	5118	if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
	5119	status_change_end(bl,SC_STONE,-1);
[10]	5120	//Custom Jobs (blackmagic)
[13]	5121	// Warlock Curses are canceled by blessing [Brain]
	5122	if (sc->data[SC_CURSEWEAKNESS])
	5123	status_change_end(bl,SC_CURSEWEAKNESS,-1);
	5124	if (sc->data[SC_CURSETONGUES])
	5125	status_change_end(bl,SC_CURSETONGUES,-1);
	5126	if (sc->data[SC_CURSEEXHAUST])
	5127	status_change_end(bl,SC_CURSEEXHAUST,-1);
	5128	if (sc->data[SC_DOOM]) // This skill would be way funnier if we could igore this concept, no?
[10]	5129	status_change_end(bl,SC_DOOM,-1);//But then people would abuse on WoEs
	5130	//Custom Job End
[1]	5131	}
	5132	break;
[10]	5133	//Custom Jobs (blackmagic)
[13]	5134	case SC_CURSEWEAKNESS: // Warlock Curse of Weakness removes Impositio Manus [Brain]
	5135	if (sc->data[SC_IMPOSITIO])
	5136	status_change_end(bl,SC_IMPOSITIO,-1);
	5137	if (sc->data[SC_BLESSING]) //The opposite is also valid, curses cancel blessing [Brain]
	5138	status_change_end(bl,SC_BLESSING,-1);
[10]	5139	break;
[13]	5140	case SC_CURSETONGUES: // Warlock Curse of Tongues removes Suffragium [Brain]
	5141	if (sc->data[SC_SUFFRAGIUM])
	5142	status_change_end(bl,SC_SUFFRAGIUM,-1);
	5143	if (sc->data[SC_BLESSING])
	5144	status_change_end(bl,SC_BLESSING,-1);
	5145	break;
	5146	case SC_CURSEEXHAUST: // Warlock Curse of Exhaustion removes angelus [Brain]
	5147	if (sc->data[SC_ANGELUS])
	5148	status_change_end(bl,SC_ANGELUS,-1);
	5149	case SC_DOOM:
	5150	if (sc->data[SC_BLESSING])
	5151	status_change_end(bl,SC_BLESSING,-1);
	5152	break;
	5153	case SC_IMPOSITIO: // Impositio Manus removes Curse of Weakness [Brain]
	5154	if (sc->data[SC_CURSEWEAKNESS])
	5155	status_change_end(bl,SC_CURSEWEAKNESS,-1);
	5156	break;
	5157	case SC_SUFFRAGIUM: // Suffragium removes Curse of Tongues [Brain]
	5158	if (sc->data[SC_CURSETONGUES])
	5159	status_change_end(bl,SC_CURSETONGUES,-1);
	5160	break;
	5161	case SC_ANGELUS: // Angelus removes Curse of Exhaustion [Brain]
	5162	if (sc->data[SC_CURSEEXHAUST])
	5163	status_change_end(bl,SC_CURSEEXHAUST,-1);
	5164	break;
[10]	5165	//Custom Job End
[1]	5166	case SC_INCREASEAGI:
	5167	status_change_end(bl,SC_DECREASEAGI,-1);
	5168	break;
	5169	case SC_QUAGMIRE:
	5170	status_change_end(bl,SC_CONCENTRATE,-1);
	5171	status_change_end(bl,SC_TRUESIGHT,-1);
	5172	status_change_end(bl,SC_WINDWALK,-1);
	5173	//Also blocks the ones below...
	5174	case SC_DECREASEAGI:
	5175	status_change_end(bl,SC_CARTBOOST,-1);
	5176	//Also blocks the ones below...
	5177	case SC_DONTFORGETME:
	5178	status_change_end(bl,SC_INCREASEAGI,-1);
	5179	status_change_end(bl,SC_ADRENALINE,-1);
	5180	status_change_end(bl,SC_ADRENALINE2,-1);
	5181	status_change_end(bl,SC_SPEARQUICKEN,-1);
	5182	status_change_end(bl,SC_TWOHANDQUICKEN,-1);
	5183	status_change_end(bl,SC_ONEHAND,-1);
[10]	5184	//Custom Jobs (blackmagic)
[13]	5185	if(sc->data[SC_LUST]) // Adept Blood Lust [Brain]
[10]	5186	status_change_end(bl,SC_LUST,-1);
	5187	//Custom Job End
[1]	5188	break;
	5189	case SC_ONEHAND:
	5190	//Removes the Aspd potion effect, as reported by Vicious. [Skotlex]
	5191	status_change_end(bl,SC_ASPDPOTION0,-1);
	5192	status_change_end(bl,SC_ASPDPOTION1,-1);
	5193	status_change_end(bl,SC_ASPDPOTION2,-1);
	5194	status_change_end(bl,SC_ASPDPOTION3,-1);
	5195	break;
	5196	case SC_MAXOVERTHRUST:
	5197	//Cancels Normal Overthrust. [Skotlex]
	5198	status_change_end(bl, SC_OVERTHRUST, -1);
	5199	break;
	5200	case SC_KYRIE:
	5201	//Cancels Assumptio
	5202	status_change_end(bl,SC_ASSUMPTIO,-1);
	5203	break;
	5204	case SC_DELUGE:
	5205	if (sc->data[SC_FOGWALL] && sc->data[SC_BLIND])
	5206	status_change_end(bl,SC_BLIND,-1);
	5207	break;
	5208	case SC_SILENCE:
	5209	if (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF)
	5210	status_change_end(bl,SC_GOSPEL,-1);
	5211	break;
	5212	case SC_HIDING:
	5213	status_change_end(bl, SC_CLOSECONFINE, -1);
	5214	status_change_end(bl, SC_CLOSECONFINE2, -1);
	5215	break;
	5216	case SC_BERSERK:
	5217	if(battle_config.berserk_cancels_buffs)
	5218	{
	5219	status_change_end(bl,SC_ONEHAND,-1);
	5220	status_change_end(bl,SC_TWOHANDQUICKEN,-1);
	5221	status_change_end(bl,SC_CONCENTRATION,-1);
	5222	status_change_end(bl,SC_PARRYING,-1);
	5223	status_change_end(bl,SC_AURABLADE,-1);
	5224	}
	5225	break;
	5226	case SC_ASSUMPTIO:
	5227	status_change_end(bl,SC_KYRIE,-1);
	5228	status_change_end(bl,SC_KAITE,-1);
	5229	break;
	5230	case SC_KAITE:
	5231	status_change_end(bl,SC_ASSUMPTIO,-1);
	5232	break;
	5233	case SC_CARTBOOST:
	5234	if(sc->data[SC_DECREASEAGI])
	5235	{ //Cancel Decrease Agi, but take no further effect [Skotlex]
	5236	status_change_end(bl,SC_DECREASEAGI,-1);
	5237	return 0;
	5238	}
	5239	break;
	5240	case SC_FUSION:
	5241	status_change_end(bl,SC_SPIRIT,-1);
	5242	break;
	5243	case SC_ADJUSTMENT:
	5244	status_change_end(bl,SC_MADNESSCANCEL,-1);
	5245	break;
[10]	5246	//Custom Jobs (blackmagic)
[13]	5247	case SC_FREEZE: //Frozen status ends immolating AND searing status [Brain]
	5248	if(sc->data[SC_IMMOLATE])
	5249	status_change_end(bl,SC_IMMOLATE,-1);
	5250	case SC_IMMOLATE: // Warlock Immolate [Brain]
	5251	if(sc->data[SC_SEARING]) //Immolating status ends searing status
	5252	status_change_end(bl,SC_SEARING,-1);
[10]	5253	break;
	5254	//Custom Job End
[1]	5255	case SC_MADNESSCANCEL:
	5256	status_change_end(bl,SC_ADJUSTMENT,-1);
	5257	break;
	5258	//NPC_CHANGEUNDEAD will debuff Blessing and Agi Up
	5259	case SC_CHANGEUNDEAD:
	5260	status_change_end(bl,SC_BLESSING,-1);
	5261	status_change_end(bl,SC_INCREASEAGI,-1);
	5262	break;
	5263
	5264	}
	5265
	5266	//Check for overlapping fails
	5267	if((sce=sc->data[type]))
	5268	{
	5269	switch (type)
	5270	{
	5271	case SC_ADRENALINE:
	5272	case SC_ADRENALINE2:
	5273	case SC_WEAPONPERFECTION:
	5274	case SC_OVERTHRUST:
	5275	if (sce->val2 > val2)
	5276	return 0;
	5277	break;
	5278	case SC_HPREGEN:
	5279	case SC_SPREGEN:
	5280	case SC_STUN:
	5281	case SC_SLEEP:
	5282	case SC_POISON:
	5283	case SC_CURSE:
	5284	case SC_SILENCE:
	5285	case SC_CONFUSION:
[10]	5286	//Custom Jobs (blackmagic)
	5287	case SC_FEAR: //Fear Status by [Brainstorm]
	5288	//Custom Job End
[1]	5289	case SC_BLIND:
	5290	case SC_BLEEDING:
	5291	case SC_DPOISON:
	5292	case SC_CLOSECONFINE2: //Can't be re-closed in.
	5293	case SC_MARIONETTE:
	5294	case SC_MARIONETTE2:
	5295	case SC_NOCHAT:
	5296	case SC_CHANGE: //Otherwise your Hp/Sp would get refilled while still within effect of the last invocation.
	5297	return 0;
	5298	case SC_COMBO:
	5299	case SC_DANCING:
	5300	case SC_DEVOTION:
	5301	case SC_ASPDPOTION0:
	5302	case SC_ASPDPOTION1:
	5303	case SC_ASPDPOTION2:
	5304	case SC_ASPDPOTION3:
	5305	case SC_ATKPOTION:
	5306	case SC_MATKPOTION:
	5307	case SC_ENCHANTARMS:
	5308	case SC_ARMOR_ELEMENT:
	5309	case SC_ARMOR_RESIST:
	5310	break;
	5311	case SC_GOSPEL:
	5312	//Must not override a casting gospel char.
	5313	if(sce->val4 == BCT_SELF)
	5314	return 0;
	5315	if(sce->val1 > val1)
	5316	return 1;
	5317	break;
	5318	case SC_ENDURE:
	5319	if(sce->val4 && !val4)
	5320	return 1; //Don't let you override infinite endure.
	5321	if(sce->val1 > val1)
	5322	return 1;
	5323	break;
	5324	case SC_KAAHI:
	5325	if(sce->val1 > val1)
	5326	return 1;
	5327	//Delete timer if it exists.
	5328	if (sce->val4 != -1) {
	5329	delete_timer(sce->val4,kaahi_heal_timer);
	5330	sce->val4=-1;
	5331	}
	5332	break;
	5333	case SC_JAILED:
	5334	//When a player is already jailed, do not edit the jail data.
	5335	val2 = sce->val2;
	5336	val3 = sce->val3;
	5337	val4 = sce->val4;
	5338	break;
	5339	case SC_JOINTBEAT:
	5340	val2 \|= sce->val2; // stackable ailments
	5341	default:
	5342	if(sce->val1 > val1)
	5343	return 1; //Return true to not mess up skill animations. [Skotlex]
	5344	}
	5345	}
	5346
	5347	vd = status_get_viewdata(bl);
	5348	calc_flag = StatusChangeFlagTable[type];
	5349	if(!(flag&4)) //&4 - Do not parse val settings when loading SCs
	5350	switch(type)
	5351	{
	5352	case SC_DECREASEAGI:
	5353	case SC_INCREASEAGI:
	5354	val2 = 2 + val1; //Agi change
	5355	break;
	5356	case SC_ENDURE:
	5357	val2 = 7; // Hit-count [Celest]
	5358	if (!(flag&1) && sd && !map_flag_gvg(bl->m) && (type != SC_ENDURE \|\| !val4))
	5359	{ //See if there are devoted characters, and pass the status to them. [Skotlex]
	5360	//(but do not pass infinite endure)
	5361	struct map_session_data *tsd;
	5362	int i;
	5363	for (i = 0; i < 5; i++)
	5364	{
	5365	if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
	5366	status_change_start(&tsd->bl,type,10000,val1,val2,val3,val4,tick,1);
	5367	}
	5368	}
	5369	//val4 signals infinite endure (if val4 == 2 it is infinite endure from Berserk)
	5370	if(val4)
	5371	tick = -1;
	5372	break;
	5373	case SC_AUTOBERSERK:
	5374	if (status->hp < status->max_hp>>2 &&
	5375	(!sc->data[SC_PROVOKE] \|\| sc->data[SC_PROVOKE]->val2==0))
	5376	sc_start4(bl,SC_PROVOKE,100,10,1,0,0,60000);
	5377	tick = -1;
	5378	break;
	5379	case SC_SIGNUMCRUCIS:
	5380	val2 = 10 + 4*val1; //Def reduction
	5381	tick = -1;
	5382	clif_emotion(bl,4);
	5383	break;
	5384	case SC_MAXIMIZEPOWER:
	5385	val2 = tick>0?tick:60000;
	5386	break;
	5387	case SC_EDP: // [Celest]
	5388	val2 = val1 + 2; //Chance to Poison enemies.
	5389	val3 = 50(val1+1); //Damage increase (+50 +50lv%)
	5390	break;
	5391	case SC_POISONREACT:
	5392	val2=(val1+1)/2 + val1/10; // Number of counters [Skotlex]
	5393	val3=50; // + 5*val1; //Chance to counter. [Skotlex]
	5394	break;
	5395	case SC_MAGICROD:
	5396	val2 = val1*20; //SP gained
	5397	break;
	5398	case SC_KYRIE:
	5399	val2 = status->max_hp * (val1 * 2 + 10) / 100; //%Max HP to absorb
	5400	val3 = (val1 / 2 + 5); //Hits
	5401	break;
	5402	case SC_MAGICPOWER:
	5403	//val1: Skill lv
	5404	val2 = 1; //Lasts 1 invocation
	5405	val3 = 5*val1; //Matk% increase
	5406	tick = -1;
	5407	break;
	5408	case SC_SACRIFICE:
	5409	val2 = 5; //Lasts 5 hits
	5410	tick = -1;
	5411	break;
	5412	case SC_ENCPOISON:
	5413	val2= 250+50*val1; //Poisoning Chance (2.5+0.5%) in 1/10000 rate
	5414	case SC_ASPERSIO:
	5415	case SC_FIREWEAPON:
	5416	case SC_WATERWEAPON:
	5417	case SC_WINDWEAPON:
	5418	case SC_EARTHWEAPON:
	5419	case SC_SHADOWWEAPON:
	5420	case SC_GHOSTWEAPON:
	5421	skill_enchant_elemental_end(bl,type);
	5422	break;
	5423	case SC_ELEMENTALCHANGE:
	5424	// val1 : Element Lvl (if called by skill lvl 1, takes random value between 1 and 4)
	5425	// val2 : Element (When no element, random one is picked)
	5426	// val3 : 0 = called by skill 1 = called by script (fixed level)
	5427	if( !val2 ) val2 = rand()%ELE_MAX;
	5428
	5429	if( val1 == 1 && val3 == 0 )
	5430	val1 = 1 + rand()%4;
	5431	else if( val1 > 4 )
	5432	val1 = 4; // Max Level
	5433	val3 = 0; // Not need to keep this info.
	5434	break;
	5435	case SC_PROVIDENCE:
	5436	val2=val1*5; //Race/Ele resist
	5437	break;
	5438	case SC_REFLECTSHIELD:
	5439	val2=10+val1*3; //% Dmg reflected
	5440	if (sd && !(flag&1))
	5441	{ //Pass it to devoted chars.
	5442	struct map_session_data *tsd;
	5443	int i;
	5444	for (i = 0; i < 5; i++)
	5445	{ //Pass the status to the other affected chars. [Skotlex]
	5446	if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
	5447	status_change_start(&tsd->bl,type,10000,val1,val2,0,0,tick,1);
	5448	}
	5449	}
	5450	break;
	5451	case SC_STRIPWEAPON:
	5452	if (!sd) //Watk reduction
	5453	val2 = 5*val1;
	5454	break;
	5455	case SC_STRIPSHIELD:
	5456	if (!sd) //Def reduction
	5457	val2 = 3*val1;
	5458	break;
	5459	case SC_STRIPARMOR:
	5460	if (!sd) //Vit reduction
	5461	val2 = 8*val1;
	5462	break;
	5463	case SC_STRIPHELM:
	5464	if (!sd) //Int reduction
	5465	val2 = 8*val1;
	5466	break;
	5467	case SC_AUTOSPELL:
	5468	//Val1 Skill LV of Autospell
	5469	//Val2 Skill ID to cast
	5470	//Val3 Max Lv to cast
	5471	val4 = 5 + val1*2; //Chance of casting
	5472	break;
	5473	case SC_VOLCANO:
	5474	if (status->def_ele == ELE_FIRE)
	5475	val2 = val1*10; //Watk increase
	5476	else
	5477	val2 = 0;
	5478	break;
	5479	case SC_VIOLENTGALE:
	5480	if (status->def_ele == ELE_WIND)
	5481	val2 = val1*3; //Flee increase
	5482	else
	5483	val2 = 0;
	5484	break;
	5485	case SC_DELUGE:
	5486	if(status->def_ele == ELE_WATER)
	5487	val2 = deluge_eff[val1-1]; //HP increase
	5488	else
	5489	val2 = 0;
	5490	break;
	5491	case SC_SUITON:
	5492	if (!val2 \|\| (sd && (sd->class_&MAPID_UPPERMASK) == MAPID_NINJA)) {
	5493	//No penalties.
	5494	val2 = 0; //Agi penalty
	5495	val3 = 0; //Walk speed penalty
	5496	break;
	5497	}
	5498	val3 = 50;
	5499	val2 = 3*((val1+1)/3);
	5500	if (val1 > 4) val2--;
	5501	break;
	5502	case SC_ONEHAND:
	5503	case SC_TWOHANDQUICKEN:
	5504	val2 = 300;
	5505	if (val1 > 10) //For boss casted skills [Skotlex]
	5506	val2 += 20*(val1-10);
	5507	break;
	5508	case SC_SPEARQUICKEN:
	5509	val2 = 200+10*val1;
	5510	break;
	5511	case SC_DANCING:
	5512	//val1 : Skill ID + LV
	5513	//val2 : Skill Group of the Dance.
	5514	//val3 : Brings the skilllv (merged into val1 here)
	5515	//val4 : Partner
	5516	if (val1 == CG_MOONLIT)
	5517	clif_status_change(bl,SI_MOONLIT,1);
	5518	val1\|= (val3<<16);
	5519	val3 = 0; //Tick duration/Speed penalty.
	5520	//Store walk speed change in lower part of val3
	5521	if (sd && !(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_BARDDANCER))
	5522	val3 = 500-40*pc_checkskill(sd,(sd->status.sex?BA_MUSICALLESSON:DC_DANCINGLESSON));
	5523	val3\|= ((tick/1000)<<16)&0xFFFF0000; //Store tick in upper part of val3
	5524	tick = 1000;
	5525	break;
	5526	case SC_LONGING:
	5527	val2 = 500-100*val1; //Aspd penalty.
	5528	val3 = 50+10*val1; //Walk speed adjustment.
	5529	break;
	5530	case SC_EXPLOSIONSPIRITS:
	5531	val2 = 75 + 25*val1; //Cri bonus
	5532	break;
	5533	case SC_ASPDPOTION0:
	5534	case SC_ASPDPOTION1:
	5535	case SC_ASPDPOTION2:
	5536	case SC_ASPDPOTION3:
	5537	val2 = 50*(2+type-SC_ASPDPOTION0);
	5538	break;
	5539
	5540	case SC_WEDDING:
	5541	case SC_XMAS:
	5542	case SC_SUMMER:
	5543	if (!vd) return 0;
	5544	//Store previous values as they could be removed.
	5545	val1 = vd->class_;
	5546	val2 = vd->weapon;
	5547	val3 = vd->shield;
	5548	val4 = vd->cloth_color;
	5549	unit_stop_attack(bl);
	5550	clif_changelook(bl,LOOK_WEAPON,0);
	5551	clif_changelook(bl,LOOK_SHIELD,0);
	5552	clif_changelook(bl,LOOK_BASE,type==SC_WEDDING?JOB_WEDDING:type==SC_XMAS?JOB_XMAS:JOB_SUMMER);
	5553	clif_changelook(bl,LOOK_CLOTHES_COLOR,vd->cloth_color);
	5554	break;
	5555	case SC_NOCHAT:
	5556	tick = 60000;
	5557	val1 = battle_config.manner_system; //Mute filters.
	5558	if (sd)
	5559	{
	5560	clif_changestatus(&sd->bl,SP_MANNER,sd->status.manner);
	5561	clif_updatestatus(sd,SP_MANNER);
	5562	}
	5563	break;
	5564
	5565	case SC_STONE:
	5566	val3 = tick/1000; //Petrified HP-damage iterations.
	5567	if(val3 < 1) val3 = 1;
	5568	tick = val4; //Petrifying time.
	5569	if (tick < 1000)
	5570	tick = 1000; //Min time
	5571	calc_flag = 0; //Actual status changes take effect on petrified state.
	5572	break;
	5573
	5574	case SC_DPOISON:
	5575	//Lose 10/15% of your life as long as it doesn't brings life below 25%
	5576	if (status->hp > status->max_hp>>2)
	5577	{
	5578	int diff = status->max_hp*(bl->type==BL_PC?10:15)/100;
	5579	if (status->hp - diff < status->max_hp>>2)
	5580	diff = status->hp - (status->max_hp>>2);
	5581	status_zap(bl, diff, 0);
	5582	}
	5583	// fall through
	5584	case SC_POISON: /* Å */
	5585	val3 = tick/1000; //Damage iterations
	5586	if(val3 < 1) val3 = 1;
	5587	tick = 1000;
	5588	//val4: HP damage
	5589	if (bl->type == BL_PC)
	5590	val4 = (type == SC_DPOISON) ? 3 + status->max_hp/50 : 3 + status->max_hp*3/200;
	5591	else
	5592	val4 = (type == SC_DPOISON) ? 3 + status->max_hp/100 : 3 + status->max_hp/200;
	5593
	5594	break;
	5595	case SC_CONFUSION:
	5596	clif_emotion(bl,1);
	5597	break;
[10]	5598	//Custom Jobs (blackmagic)
[13]	5599	case SC_FEAR: //Fear Status by [Brainstorm]
	5600	clif_emotion(bl,16); // e_wah
	5601	if(sd) tick /= 2;
[10]	5602	break;
	5603	//Custom Job End
[1]	5604	case SC_BLEEDING:
	5605	val4 = tick/10000;
	5606	if (!val4) val4 = 1;
	5607	tick = 10000;
	5608	break;
	5609	case SC_HPREGEN:
	5610	case SC_SPREGEN:
	5611	if( val1 == 0 ) return 0;
	5612	// val1 = heal percent/amout
	5613	// val2 = seconds between heals
	5614	// val4 = total of heals
	5615	if( val2 < 1 ) val2 = 1;
	5616	if( (val4 = tick/(val2 * 1000)) < 1 )
	5617	val4 = 1;
	5618	tick = val2 * 1000; // val2 = Seconds between heals
	5619	break;
	5620	case SC_HIDING:
	5621	val2 = tick/1000;
	5622	tick = 1000;
	5623	//Store speed penalty on val3.
	5624	if(sd && (val3 = pc_checkskill(sd,RG_TUNNELDRIVE))>0)
	5625	val3 = 20 + 6*val3;
	5626	val4 = val1+3; //Seconds before SP substraction happen.
	5627	break;
	5628	case SC_CHASEWALK:
	5629	val2 = tick>0?tick:10000; //Interval at which SP is drained.
	5630	val3 = 65+val1*5; //Speed adjustment.
	5631	if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_ROGUE)
	5632	val3 += 60;
	5633	val4 = 10+val1*2; //SP cost.
	5634	if (map_flag_gvg(bl->m)) val4 *= 5;
	5635	break;
	5636	case SC_CLOAKING:
	5637	if (!sd) //Monsters should be able to walk with no penalties. [Skotlex]
	5638	val1 = 10;
	5639	val2 = tick>0?tick:60000; //SP consumption rate.
	5640	val3 = 0;
	5641	if (sd && (sd->class_&MAPID_UPPERMASK) == MAPID_ASSASSIN && (val3=pc_checkskill(sd,TF_MISS))>0)
	5642	val3 *= -1; //Substract the Dodge speed bonus.
	5643	val3+= 70+val1*3; //Speed adjustment without a wall.
	5644	//With a wall, it is val3 +25.
	5645	//val4&1 signals the presence of a wall.
	5646	//val4&2 makes cloak not end on normal attacks [Skotlex]
	5647	//val4&4 makes cloak not end on using skills
	5648	if (bl->type == BL_PC) //Standard cloaking.
	5649	val4 \|= battle_config.pc_cloak_check_type&7;
	5650	else
	5651	val4 \|= battle_config.monster_cloak_check_type&7;
	5652	break;
	5653	case SC_SIGHT: /* TCg/At */
	5654	case SC_RUWACH:
	5655	case SC_SIGHTBLASTER:
	5656	val3 = skill_get_splash(val2, val1); //Val2 should bring the skill-id.
	5657	val2 = tick/250;
	5658	tick = 10;
	5659	break;
	5660
	5661	//Permanent effects.
	5662	case SC_AETERNA:
	5663	case SC_MODECHANGE:
	5664	case SC_WEIGHT50:
	5665	case SC_WEIGHT90:
	5666	case SC_BROKENWEAPON:
	5667	case SC_BROKENARMOR:
	5668	case SC_READYSTORM:
	5669	case SC_READYDOWN:
	5670	case SC_READYCOUNTER:
	5671	case SC_READYTURN:
	5672	case SC_DODGE:
	5673	tick = -1;
	5674	break;
	5675
	5676	case SC_AUTOGUARD:
	5677	if (!(flag&1))
	5678	{
	5679	struct map_session_data *tsd;
	5680	int i,t;
	5681	for(i=val2=0;i<val1;i++) {
	5682	t = 5-(i>>1);
	5683	val2 += (t < 0)? 1:t;
	5684	}
	5685	if (sd)
	5686	for (i = 0; i < 5; i++)
	5687	{ //Pass the status to the other affected chars. [Skotlex]
	5688	if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
	5689	status_change_start(&tsd->bl,type,10000,val1,val2,0,0,tick,1);
	5690	}
	5691	}
	5692	break;
	5693
	5694	case SC_DEFENDER:
	5695	if (!(flag&1))
	5696	{
	5697	struct map_session_data *tsd;
	5698	int i;
	5699	val2 = 5 + 15*val1; //Damage reduction
	5700	val3 = 65 + 5*val1; //Speed adjustment
	5701	val4 = 250 - 50*val1; //Aspd adjustment
	5702
	5703	if (sd)
	5704	for (i = 0; i < 5; i++)
	5705	{ //See if there are devoted characters, and pass the status to them. [Skotlex]
	5706	if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
	5707	status_change_start(&tsd->bl,type,10000,val1,5+val1*5,val3,val4,tick,1);
	5708	}
	5709	}
	5710	break;
	5711
	5712	case SC_TENSIONRELAX:
	5713	if (sd) {
	5714	pc_setsit(sd);
	5715	clif_sitting(&sd->bl);
	5716	}
	5717	val2 = 12; //SP cost
	5718	val4 = 10000; //Decrease at 10secs intervals.
	5719	val3 = tick/val4;
	5720	tick = val4;
	5721	break;
	5722	case SC_PARRYING:
	5723	val2 = 20 + val1*3; //Block Chance
	5724	break;
	5725
	5726	case SC_WINDWALK:
	5727	val2 = (val1+1)/2; // Flee bonus is 1/1/2/2/3/3/4/4/5/5
	5728	val3 = 4*val2; //movement speed % increase is 4 times that
	5729	break;
	5730
	5731	case SC_JOINTBEAT:
	5732	if( val2&BREAK_NECK )
	5733	sc_start(bl,SC_BLEEDING,100,val1,skill_get_time2(status_sc2skill(type),val1));
	5734	break;
	5735
	5736	case SC_BERSERK:
	5737	if (!sc->data[SC_ENDURE] \|\| !sc->data[SC_ENDURE]->val4)
	5738	sc_start4(bl, SC_ENDURE, 100,10,0,0,2, tick);
	5739	//HP healing is performing after the calc_status call.
	5740	//Val2 holds HP penalty
	5741	if (!val4) val4 = skill_get_time2(status_sc2skill(type),val1);
	5742	if (!val4) val4 = 10000; //Val4 holds damage interval
	5743	val3 = tick/val4; //val3 holds skill duration
	5744	tick = val4;
	5745	break;
	5746
	5747	case SC_GOSPEL:
	5748	if(val4 == BCT_SELF) { // self effect
	5749	val2 = tick/10000;
	5750	tick = 10000;
	5751	status_change_clear_buffs(bl,3); //Remove buffs/debuffs
	5752	}
	5753	break;
	5754
	5755	case SC_MARIONETTE:
	5756	if (sd) {
	5757	val3 = 0;
	5758	val2 = sd->status.str>>1;
	5759	if (val2 > 0xFF) val2 = 0xFF;
	5760	val3\|=val2<<16;
	5761
	5762	val2 = sd->status.agi>>1;
	5763	if (val2 > 0xFF) val2 = 0xFF;
	5764	val3\|=val2<<8;
	5765
	5766	val2 = sd->status.vit>>1;
	5767	if (val2 > 0xFF) val2 = 0xFF;
	5768	val3\|=val2;
	5769
	5770	val4 = 0;
	5771	val2 = sd->status.int_>>1;
	5772	if (val2 > 0xFF) val2 = 0xFF;
	5773	val4\|=val2<<16;
	5774
	5775	val2 = sd->status.dex>>1;
	5776	if (val2 > 0xFF) val2 = 0xFF;
	5777	val4\|=val2<<8;
	5778
	5779	val2 = sd->status.luk>>1;
	5780	if (val2 > 0xFF) val2 = 0xFF;
	5781	val4\|=val2;
	5782	} else {
	5783	struct status_data *b_status = status_get_base_status(bl);
	5784	if (!b_status)
	5785	return 0;
	5786
	5787	val3 = 0;
	5788	val2 = b_status->str>>1;
	5789	if (val2 > 0xFF) val2 = 0xFF;
	5790	val3\|=val2<<16;
	5791
	5792	val2 = b_status->agi>>1;
	5793	if (val2 > 0xFF) val2 = 0xFF;
	5794	val3\|=val2<<8;
	5795
	5796	val2 = b_status->vit>>1;
	5797	if (val2 > 0xFF) val2 = 0xFF;
	5798	val3\|=val2;
	5799
	5800	val4 = 0;
	5801	val2 = b_status->int_>>1;
	5802	if (val2 > 0xFF) val2 = 0xFF;
	5803	val4\|=val2<<16;
	5804
	5805	val2 = b_status->dex>>1;
	5806	if (val2 > 0xFF) val2 = 0xFF;
	5807	val4\|=val2<<8;
	5808
	5809	val2 = b_status->luk>>1;
	5810	if (val2 > 0xFF) val2 = 0xFF;
	5811	val4\|=val2;
	5812	}
	5813	val2 = tick/1000;
	5814	tick = 1000;
	5815	break;
	5816	case SC_MARIONETTE2:
	5817	{
	5818	struct block_list *pbl = map_id2bl(val1);
	5819	struct status_change *psc = pbl?status_get_sc(pbl):NULL;
	5820	struct status_change_entry *psce = psc?psc->data[SC_MARIONETTE]:NULL;
	5821	int stat,max;
	5822	if (!psce)
	5823	return 0;
	5824	val2 = tick /1000;
	5825	val3 = val4 = 0;
	5826	if (sd) {
	5827	max = pc_maxparameter(sd); //Cap to max parameter. [Skotlex]
	5828	//Str
	5829	stat = (psce->val3>>16)&0xFF;
	5830	if (sd->status.str+stat > max)
	5831	stat =max-sd->status.str;
	5832	val3 \|= stat<<16;
	5833	//Agi
	5834	stat = (psce->val3>>8)&0xFF;
	5835	if (sd->status.agi+stat > max)
	5836	stat =max-sd->status.agi;
	5837	val3 \|= stat<<8;
	5838	//Vit
	5839	stat = psce->val3&0xFF;
	5840	if (sd->status.vit+stat > max)
	5841	stat =max-sd->status.vit;
	5842	val3 \|= stat;
	5843	//Int
	5844	stat = (psce->val4>>16)&0xFF;
	5845	if (sd->status.int_+stat > max)
	5846	stat =max-sd->status.int_;
	5847	val4 \|= stat<<16;
	5848	//Dex
	5849	stat = (psce->val4>>8)&0xFF;
	5850	if (sd->status.dex+stat > max)
	5851	stat =max-sd->status.dex;
	5852	val4 \|= stat<<8;
	5853	//Luk
	5854	stat = psce->val4&0xFF;
	5855	if (sd->status.luk+stat > max)
	5856	stat =max-sd->status.luk;
	5857	val4 \|= stat;
	5858	} else {
	5859	struct status_data *b_status = status_get_base_status(bl);
	5860	if (!b_status) return 0;
	5861	max = 0xFF; //Assume a 256 max parameter
	5862	//Str
	5863	stat = (psce->val3>>16)&0xFF;
	5864	if (b_status->str+stat > max)
	5865	stat = max - b_status->str;
	5866	val3 \|= stat<<16;
	5867	//Agi
	5868	stat = (psce->val3>>8)&0xFF;
	5869	if (b_status->agi+stat > max)
	5870	stat = max - b_status->agi;
	5871	val3 \|= stat<<8;
	5872	//Vit
	5873	stat = psce->val3&0xFF;
	5874	if (b_status->vit+stat > max)
	5875	stat = max - b_status->vit;
	5876	val3 \|= stat;
	5877	//Int
	5878	stat = (psce->val4>>16)&0xFF;
	5879	if (b_status->int_+stat > max)
	5880	stat = max - b_status->int_;
	5881	val4 \|= stat<<16;
	5882	//Dex
	5883	stat = (psce->val4>>8)&0xFF;
	5884	if (b_status->dex+stat > max)
	5885	stat = max - b_status->dex;
	5886	val4 \|= stat<<8;
	5887	//Luk
	5888	stat = psce->val4&0xFF;
	5889	if (b_status->luk+stat > max)
	5890	stat = max - b_status->luk;
	5891	val4 \|= stat;
	5892	}
	5893	tick = 1000;
	5894	break;
	5895	}
	5896	case SC_REJECTSWORD:
	5897	val2 = 15*val1; //Reflect chance
	5898	val3 = 3; //Reflections
	5899	tick = -1;
	5900	break;
	5901
	5902	case SC_MEMORIZE:
	5903	val2 = 5; //Memorized casts.
	5904	tick = -1;
	5905	break;
	5906
	5907	case SC_GRAVITATION:
	5908	val2 = 50*val1; //aspd reduction
	5909	break;
	5910
	5911	case SC_REGENERATION:
	5912	if (val1 == 1)
	5913	val2 = 2;
	5914	else
	5915	val2 = val1; //HP Regerenation rate: 200% 200% 300%
	5916	val3 = val1; //SP Regeneration Rate: 100% 200% 300%
	5917	//if val4 comes set, this blocks regen rather than increase it.
	5918	break;
	5919
	5920	case SC_DEVOTION:
	5921	{
	5922	struct map_session_data *src;
	5923	if ((src = map_id2sd(val1)) && src->sc.count)
	5924	{ //Try to inherit the status from the Crusader [Skotlex]
	5925	//Ideally, we should calculate the remaining time and use that, but we'll trust that
	5926	//once the Crusader's status changes, it will reflect on the others.
	5927	const enum sc_type types[] = { SC_AUTOGUARD, SC_DEFENDER, SC_REFLECTSHIELD, SC_ENDURE };
	5928	enum sc_type type2;
	5929	int i = map_flag_gvg(bl->m)?2:3;
	5930	while (i >= 0) {
	5931	type2 = types[i];
	5932	if (src->sc.data[type2])
	5933	sc_start(bl,type2,100,src->sc.data[type2]->val1,
	5934	skill_get_time(status_sc2skill(type2),src->sc.data[type2]->val1));
	5935	i--;
	5936	}
	5937	}
	5938	break;
	5939	}
	5940
	5941	case SC_COMA: //Coma. Sends a char to 1HP. If val2, do not zap sp
	5942	status_zap(bl, status->hp-1, val2?0:status->sp);
	5943	return 1;
	5944	break;
	5945	case SC_CLOSECONFINE2:
	5946	{
	5947	struct block_list *src = val2?map_id2bl(val2):NULL;
	5948	struct status_change *sc2 = src?status_get_sc(src):NULL;
	5949	struct status_change_entry *sce2 = sc2?sc2->data[SC_CLOSECONFINE]:NULL;
	5950	if (src && sc2) {
	5951	if (!sce2) //Start lock on caster.
	5952	sc_start4(src,SC_CLOSECONFINE,100,val1,1,0,0,tick+1000);
	5953	else { //Increase count of locked enemies and refresh time.
	5954	(sce2->val2)++;
	5955	delete_timer(sce2->timer, status_change_timer);
	5956	sce2->timer = add_timer(gettick()+tick+1000, status_change_timer, src->id, SC_CLOSECONFINE);
	5957	}
	5958	} else //Status failed.
	5959	return 0;
	5960	}
	5961	break;
	5962	case SC_KAITE:
	5963	val2 = 1+val1/5; //Number of bounces: 1 + skilllv/5
	5964	break;
	5965	case SC_KAUPE:
	5966	switch (val1) {
	5967	case 3: //33*3 + 1 -> 100%
	5968	val2++;
	5969	case 1:
	5970	case 2: //33, 66%
	5971	val2 += 33*val1;
	5972	val3 = 1; //Dodge 1 attack total.
	5973	break;
	5974	default: //Custom. For high level mob usage, higher level means more blocks. [Skotlex]
	5975	val2 = 100;
	5976	val3 = val1-2;
	5977	break;
	5978	}
	5979	break;
	5980
[10]	5981	//Custom Jobs (blackmagic)
[13]	5982	case SC_ATFIELD: // AT-Field [Brainstorm]
	5983	val2 = 100; // 100% Block chance
	5984	val3 = 100; // Dodge 100 attacks total.
	5985	val4 = tick/1000;
	5986	tick = 1000;
[10]	5987	break;
	5988	//Custom Job End
	5989
[1]	5990	case SC_COMBO:
	5991	{
	5992	//val1: Skill ID
	5993	//val2: When given, target (for autotargetting skills)
	5994	//val3: When set, this combo time should NOT delay attack/movement
	5995	//val4: Combo time
	5996	struct unit_data *ud = unit_bl2ud(bl);
	5997	switch (val1) {
	5998	case TK_STORMKICK:
	5999	clif_skill_nodamage(bl,bl,TK_READYSTORM,1,1);
	6000	break;
	6001	case TK_DOWNKICK:
	6002	clif_skill_nodamage(bl,bl,TK_READYDOWN,1,1);
	6003	break;
	6004	case TK_TURNKICK:
	6005	clif_skill_nodamage(bl,bl,TK_READYTURN,1,1);
	6006	break;
	6007	case TK_COUNTER:
	6008	clif_skill_nodamage(bl,bl,TK_READYCOUNTER,1,1);
	6009	break;
	6010	}
	6011	if (ud && !val3)
	6012	{
	6013	ud->attackabletime = gettick()+tick;
	6014	unit_set_walkdelay(bl, gettick(), tick, 1);
	6015	}
	6016	val4 = tick; //Store combo-time in val4.
	6017	}
	6018	break;
	6019	case SC_TKREST:
	6020	val2 = 11-val1; //Chance to consume: 11-skilllv%
	6021	break;
	6022	case SC_RUN:
	6023	val4 = gettick(); //Store time at which you started running.
	6024	tick = -1;
	6025	break;
	6026	case SC_KAAHI:
	6027	val2 = 200*val1; //HP heal
	6028	val3 = 5*val1; //SP cost
	6029	val4 = -1; //Kaahi Timer.
	6030	break;
	6031	case SC_BLESSING:
	6032	if (status->race!=RC_UNDEAD && status->race!=RC_DEMON)
	6033	val2 = val1;
	6034	else
	6035	val2 = 0; //0 -> Half stat.
	6036	break;
[10]	6037	//Custom Jobs (blackmagic)
[13]	6038	case SC_REQUIEM: //Necro Requiem and Dark Moon [Brain]
	6039	case SC_DARKMOON:
	6040	if (undead_flag \|\| status->race==RC_UNDEAD \|\| status->race==RC_DEMON)
	6041	val2 = val1; //Demon and Undead get buffed
	6042	else if(status->race==RC_FORMLESS \|\| status->def_ele==ELE_GHOST \|\| bl->type == BL_PC)
	6043	{
	6044	val1 = 0; //No status change for Formless and Ghosts, and non-undead players
	6045	tick = 0; //Cancel status to not show requiem icon without a reason
	6046	}
	6047	else
	6048	val3 = val1; //Everything else (living) get negative status (requiem only)
	6049	break;
	6050	case SC_DECREPIFY: //Necro Decrepify [Brain]
	6051	val2 = val1;
[10]	6052	break;
	6053	//Custom Job End
[1]	6054	case SC_TRICKDEAD:
	6055	if (vd) vd->dead_sit = 1;
	6056	tick = -1;
	6057	break;
	6058	case SC_CONCENTRATE:
	6059	val2 = 2 + val1;
	6060	if (sd) { //Store the card-bonus data that should not count in the %
	6061	val3 = sd->param_bonus[1]; //Agi
	6062	val4 = sd->param_bonus[4]; //Dex
	6063	} else {
	6064	val3 = val4 = 0;
	6065	}
	6066	break;
	6067	case SC_MAXOVERTHRUST:
	6068	val2 = 20*val1; //Power increase
	6069	break;
	6070	case SC_OVERTHRUST:
	6071	//val2 holds if it was casted on self, or is bonus received from others
	6072	val3 = 5*val1; //Power increase
	6073	if(sd && pc_checkskill(sd,BS_HILTBINDING)>0)
	6074	tick += tick / 10;
	6075	break;
	6076	case SC_ADRENALINE2:
	6077	case SC_ADRENALINE:
	6078	val3 = (val2) ? 300 : 200; // aspd increase
	6079	case SC_WEAPONPERFECTION:
	6080	if(sd && pc_checkskill(sd,BS_HILTBINDING)>0)
	6081	tick += tick / 10;
	6082	break;
	6083	case SC_CONCENTRATION:
	6084	val2 = 5*val1; //Batk/Watk Increase
	6085	val3 = 10*val1; //Hit Increase
	6086	val4 = 5*val1; //Def reduction
	6087	break;
	6088	case SC_ANGELUS:
	6089	val2 = 5*val1; //def increase
	6090	break;
	6091	case SC_IMPOSITIO:
	6092	val2 = 5*val1; //watk increase
	6093	break;
[10]	6094	//Custom Jobs (blackmagic)
[13]	6095	case SC_CURSEWEAKNESS: // Warlock Curse of Weakness [Brain]
	6096	val2 = 5*val1; //batk/watk decrease
[10]	6097	break;
[13]	6098	case SC_CURSEEXHAUST: // Warlock Curse of Exhaustion [Brain]
	6099	val2 = 2*val1; //def/mdef decrease
	6100	break;
	6101	case SC_CURSETONGUES: // Warlock Curse of Tongues [Brain]
	6102	val2 = 10*val1; //casttime increase
	6103	break;
[10]	6104	//Custom Job End
[1]	6105	case SC_MELTDOWN:
	6106	val2 = 100*val1; //Chance to break weapon
	6107	val3 = 70*val1; //Change to break armor
	6108	break;
	6109	case SC_TRUESIGHT:
	6110	val2 = 10*val1; //Critical increase
	6111	val3 = 3*val1; //Hit increase
	6112	break;
	6113	case SC_SUN_COMFORT:
	6114	val2 = (status_get_lv(bl) + status->dex + status->luk)/2; //def increase
	6115	break;
	6116	case SC_MOON_COMFORT:
	6117	val2 = (status_get_lv(bl) + status->dex + status->luk)/10; //flee increase
	6118	break;
	6119	case SC_STAR_COMFORT:
	6120	val2 = (status_get_lv(bl) + status->dex + status->luk); //Aspd increase
	6121	break;
	6122	case SC_QUAGMIRE:
	6123	val2 = (sd?5:10)*val1; //Agi/Dex decrease.
	6124	break;
	6125
	6126	// gs_something1 [Vicious]
	6127	case SC_GATLINGFEVER:
	6128	val2 = 20*val1; //Aspd increase
	6129	val3 = 20+10*val1; //Batk increase
	6130	val4 = 5*val1; //Flee decrease
	6131	break;
	6132
	6133	case SC_FLING:
	6134	if (bl->type == BL_PC)
	6135	val2 = 0; //No armor reduction to players.
	6136	else
	6137	val2 = 5*val1; //Def reduction
	6138	val3 = 5*val1; //Def2 reduction
	6139	break;
	6140	case SC_PROVOKE:
	6141	//val2 signals autoprovoke.
	6142	val3 = 2+3*val1; //Atk increase
	6143	val4 = 5+5*val1; //Def reduction.
	6144	break;
	6145	case SC_AVOID:
	6146	val2 = 10*val1; //Speed change rate.
	6147	break;
	6148	case SC_DEFENCE:
	6149	val2 = 2*val1; //Def bonus
	6150	break;
	6151	case SC_BLOODLUST:
	6152	val2 = 20+10*val1; //Atk rate change.
	6153	val3 = 3*val1; //Leech chance
	6154	val4 = 20; //Leech percent
	6155	break;
	6156	case SC_FLEET:
	6157	val2 = 30*val1; //Aspd change
	6158	val3 = 5+5*val1; //bAtk/wAtk rate change
	6159	break;
[10]	6160	//Custom Jobs (blackmagic)
[13]	6161	case SC_LUST: // Adept Blood Lust [Brain]
	6162	val2 = 5+3*val1; //Aspd/bAtk/wAtk change
	6163	val3 = tick>0?tick:1000; //Interval at which HP is drained.
[10]	6164	break;
[13]	6165	case SC_DEATHPACT: // Necro Death Pact [Brain]
	6166	val2 = 5*val1; //Neutral property resistance
	6167	val3 = tick>0?tick:10000; //Interval at which HP is drained.
	6168	break;
	6169	case SC_OVERWHELMING: // Warlock Overwhelming Evil [Brain]
	6170	val2 = 2*val1; //matk bonus
	6171	val3 = tick>0?tick:1000; //Interval at which SP is drained.
	6172	break;
[10]	6173	//Custom Job End
[1]	6174	case SC_MINDBREAKER:
	6175	val2 = 20*val1; //matk increase.
	6176	val3 = 12*val1; //mdef2 reduction.
	6177	break;
	6178	case SC_SKA:
	6179	val2 = tick/1000;
	6180	val3 = rand()%100; //Def changes randomly every second...
	6181	tick = 1000;
	6182	break;
	6183	case SC_JAILED:
	6184	//Val1 is duration in minutes. Use INT_MAX to specify 'unlimited' time.
	6185	tick = val1>0?1000:250;
	6186	if (sd)
	6187	{
	6188	if (sd->mapindex != val2)
	6189	{
	6190	int pos = (bl->x&0xFFFF)\|(bl->y<<16), //Current Coordinates
	6191	map = sd->mapindex; //Current Map
	6192	//1. Place in Jail (val2 -> Jail Map, val3 -> x, val4 -> y
	6193	pc_setpos(sd,(unsigned short)val2,val3,val4, 3);
	6194	//2. Set restore point (val3 -> return map, val4 return coords
	6195	val3 = map;
	6196	val4 = pos;
	6197	} else if (!val3 \|\| val3 == sd->mapindex) { //Use save point.
	6198	val3 = sd->status.save_point.map;
	6199	val4 = (sd->status.save_point.x&0xFFFF)
	6200	\|(sd->status.save_point.y<<16);
	6201	}
	6202	}
	6203	break;
	6204	case SC_UTSUSEMI:
	6205	val2=(val1+1)/2; // number of hits blocked
	6206	val3=skill_get_blewcount(NJ_UTSUSEMI, val1); //knockback value.
	6207	break;
	6208	case SC_BUNSINJYUTSU:
	6209	val2=(val1+1)/2; // number of hits blocked
	6210	break;
	6211	case SC_CHANGE:
	6212	val2= 30*val1; //Vit increase
	6213	val3= 20*val1; //Int increase
	6214	break;
	6215	case SC_SWOO:
	6216	if(status->mode&MD_BOSS)
	6217	tick /= 5; //TODO: Reduce skill's duration. But for how long?
	6218	break;
	6219	case SC_SPIDERWEB:
	6220	if (bl->type == BL_PC)
	6221	tick /=2;
	6222	break;
	6223	case SC_ARMOR:
	6224	//NPC_DEFENDER:
	6225	val2 = 80; //Damage reduction
	6226	//Attack requirements to be blocked:
	6227	val3 = BF_LONG; //Range
	6228	val4 = BF_WEAPON\|BF_MISC; //Type
	6229	break;
	6230	case SC_ENCHANTARMS:
	6231	//end previous enchants
	6232	skill_enchant_elemental_end(bl,type);
	6233	//Make sure the received element is valid.
	6234	if (val2 >= ELE_MAX)
	6235	val2 = val2%ELE_MAX;
	6236	else if (val2 < 0)
	6237	val2 = rand()%ELE_MAX;
	6238	break;
	6239	case SC_CRITICALWOUND:
	6240	val2 = 20*val1; //Heal effectiveness decrease
	6241	break;
	6242	case SC_MAGICMIRROR:
	6243	case SC_SLOWCAST:
	6244	val2 = 20*val1; //Magic reflection/cast rate
	6245	break;
	6246
	6247	case SC_ARMORCHANGE:
	6248	if (val2 == NPC_ANTIMAGIC)
	6249	{ //Boost mdef
	6250	val2 =-20;
	6251	val3 = 20;
	6252	} else { //Boost def
	6253	val2 = 20;
	6254	val3 =-20;
	6255	}
	6256	val2*=val1; //20% per level
	6257	val3*=val1;
	6258	break;
	6259	case SC_EXPBOOST:
	6260	if (val1 < 0)
	6261	val1 = 0;
	6262	break;
	6263	case SC_INCASPDRATE:
	6264	case SC_INCFLEE2:
	6265	case SC_INCCRI:
	6266	val2 = val1*10; //Actual boost (since 100% = 1000)
	6267	break;
	6268	case SC_SUFFRAGIUM:
	6269	val2 = 15 * val1; //Speed cast decrease
	6270	break;
	6271	case SC_INCHEALRATE:
	6272	if (val1 < 1)
	6273	val1 = 1;
	6274	break;
	6275	case SC_HALLUCINATION:
	6276	val2 = 5+val1; //Factor by which displayed damage is increased by
	6277	break;
	6278	case SC_DOUBLECAST:
	6279	val2 = 30+10*val1; //Trigger rate
	6280	break;
	6281	case SC_KAIZEL:
	6282	val2 = 10*val1; //% of life to be revived with
	6283	break;
	6284	// case SC_ARMOR_ELEMENT:
	6285	// case SC_ARMOR_RESIST:
	6286	// Mod your resistance against elements:
	6287	// val1 = water \| val2 = earth \| val3 = fire \| val4 = wind
	6288	// break;
	6289	case SC_FASTCAST:
	6290	//Place here SCs that have no SCB_* data, no skill associated, no ICON
	6291	//associated, and yet are not wrong/unknown. [Skotlex]
	6292	break;
	6293	default:
	6294	if( calc_flag == SCB_NONE && StatusSkillChangeTable[type] == 0 && StatusIconChangeTable[type] == 0 )
	6295	{ //Status change with no calc, no icon, and no skill associated...?
	6296	ShowError("UnknownStatusChange [%d]\n", type);
	6297	return 0;
	6298	}
	6299	}
	6300	else //Special considerations when loading SC data.
	6301	switch( type )
	6302	{
	6303	case SC_WEDDING:
	6304	case SC_XMAS:
	6305	case SC_SUMMER:
	6306	clif_changelook(bl,LOOK_WEAPON,0);
	6307	clif_changelook(bl,LOOK_SHIELD,0);
	6308	clif_changelook(bl,LOOK_BASE,type==SC_WEDDING?JOB_WEDDING:type==SC_XMAS?JOB_XMAS:JOB_SUMMER);
	6309	clif_changelook(bl,LOOK_CLOTHES_COLOR,val4);
	6310	break;
	6311	case SC_KAAHI:
	6312	val4 = -1;
	6313	break;
	6314	//In case the speed reduction comes loaded incorrectly, prevent division by 0.
	6315	case SC_DONTFORGETME:
	6316	case SC_CLOAKING:
	6317	case SC_LONGING:
	6318	case SC_HIDING:
	6319	case SC_CHASEWALK:
	6320	case SC_DEFENDER:
	6321	if (!val3) val3 = 100;
	6322	break;
	6323	}
	6324
	6325	//Those that make you stop attacking/walking....
	6326	switch (type)
	6327	{
	6328	case SC_FREEZE:
	6329	case SC_STUN:
	6330	case SC_SLEEP:
	6331	case SC_STONE:
	6332	if (sd && pc_issit(sd)) //Avoid sprite sync problems.
	6333	pc_setstand(sd);
	6334	case SC_TRICKDEAD:
	6335	unit_stop_attack(bl);
	6336	skill_stop_dancing(bl);
	6337	// Cancel cast when get status [LuzZza]
	6338	if (battle_config.sc_castcancel&bl->type)
	6339	unit_skillcastcancel(bl, 0);
	6340	case SC_STOP:
	6341	case SC_CONFUSION:
	6342	case SC_CLOSECONFINE:
	6343	case SC_CLOSECONFINE2:
	6344	case SC_ANKLE:
	6345	case SC_SPIDERWEB:
	6346	unit_stop_walking(bl,1);
	6347	break;
	6348	case SC_HIDING:
	6349	case SC_CLOAKING:
	6350	case SC_CHASEWALK:
	6351	unit_stop_attack(bl);
	6352	break;
	6353	case SC_SILENCE:
	6354	if (battle_config.sc_castcancel&bl->type)
	6355	unit_skillcastcancel(bl, 0);
	6356	break;
[10]	6357	//Custom Jobs (blackmagic)
[13]	6358	case SC_FEAR: //Fear Status by [Brainstorm]
	6359	unit_stop_attack(bl);
[10]	6360	break;
	6361	//Custom Job End
[1]	6362	}
	6363
	6364	// Set option as needed.
	6365	opt_flag = 1;
	6366	switch(type)
	6367	{
	6368	//OPT1
	6369	case SC_STONE: sc->opt1 = OPT1_STONEWAIT; break;
	6370	case SC_FREEZE: sc->opt1 = OPT1_FREEZE; break;
	6371	case SC_STUN: sc->opt1 = OPT1_STUN; break;
	6372	case SC_SLEEP: sc->opt1 = OPT1_SLEEP; break;
	6373	//OPT2
	6374	case SC_POISON: sc->opt2 \|= OPT2_POISON; break;
	6375	case SC_CURSE: sc->opt2 \|= OPT2_CURSE; break;
	6376	case SC_SILENCE: sc->opt2 \|= OPT2_SILENCE; break;
	6377	case SC_SIGNUMCRUCIS: sc->opt2 \|= OPT2_SIGNUMCRUCIS; break;
	6378	case SC_BLIND: sc->opt2 \|= OPT2_BLIND; break;
	6379	case SC_ANGELUS: sc->opt2 \|= OPT2_ANGELUS; break;
	6380	case SC_BLEEDING: sc->opt2 \|= OPT2_BLEEDING; break;
	6381	case SC_DPOISON: sc->opt2 \|= OPT2_DPOISON; break;
	6382	//OPT3
	6383	case SC_TWOHANDQUICKEN:
	6384	case SC_SPEARQUICKEN:
	6385	case SC_CONCENTRATION:
	6386	sc->opt3 \|= 0x1;
	6387	opt_flag = 0;
	6388	break;
	6389	case SC_MAXOVERTHRUST:
	6390	case SC_OVERTHRUST:
	6391	case SC_SWOO: //Why does it shares the same opt as Overthrust? Perhaps we'll never know...
	6392	sc->opt3 \|= 0x2;
	6393	opt_flag = 0;
	6394	break;
	6395	case SC_ENERGYCOAT:
	6396	case SC_SKE:
	6397	sc->opt3 \|= 0x4;
	6398	opt_flag = 0;
	6399	break;
	6400	case SC_INCATKRATE:
	6401	//Simulate Explosion Spirits effect for NPC_POWERUP [Skotlex]
	6402	if (bl->type != BL_MOB) {
	6403	opt_flag = 0;
	6404	break;
	6405	}
	6406	case SC_EXPLOSIONSPIRITS:
	6407	sc->opt3 \|= 0x8;
	6408	opt_flag = 0;
	6409	break;
	6410	case SC_STEELBODY:
	6411	case SC_SKA:
	6412	sc->opt3 \|= 0x10;
	6413	opt_flag = 0;
	6414	break;
	6415	case SC_BLADESTOP:
	6416	sc->opt3 \|= 0x20;
	6417	opt_flag = 0;
	6418	break;
	6419	//0x40 missing?
	6420	case SC_BERSERK:
	6421	sc->opt3 \|= 0x80;
	6422	opt_flag = 0;
	6423	break;
	6424	//0x100 missing?
	6425	case SC_DANCING:
	6426	if ((val1&0xFFFF) == CG_MOONLIT)
	6427	sc->opt3 \|= 0x200;
	6428	opt_flag = 0;
	6429	break;
	6430	case SC_MARIONETTE:
	6431	case SC_MARIONETTE2:
	6432	sc->opt3 \|= 0x400;
	6433	opt_flag = 0;
	6434	break;
	6435	case SC_ASSUMPTIO:
	6436	sc->opt3 \|= 0x800;
	6437	opt_flag = 0;
	6438	break;
	6439	case SC_WARM: //SG skills [Komurka]
	6440	sc->opt3 \|= 0x1000;
	6441	opt_flag = 0;
	6442	break;
	6443	case SC_KAITE:
	6444	sc->opt3 \|= 0x2000;
	6445	opt_flag = 0;
	6446	break;
	6447	case SC_BUNSINJYUTSU:
	6448	sc->opt3 \|= 0x4000;
	6449	opt_flag = 0;
	6450	break;
	6451	case SC_SPIRIT:
	6452	sc->opt3 \|= 0x8000;
	6453	opt_flag = 0;
	6454	break;
	6455	case SC_CHANGEUNDEAD:
	6456	sc->opt3 \|= 0x10000;
	6457	opt_flag = 0;
	6458	break;
	6459	// TODO: unknown option (looks like the aura of biolab mobs)
	6460	// case ???:
	6461	// sc->opt3 \|= 0x20000;
	6462	// opt_flag = 0;
	6463	// break;
	6464	//OPTION
	6465	case SC_HIDING:
	6466	sc->option \|= OPTION_HIDE;
	6467	break;
	6468	case SC_CLOAKING:
	6469	sc->option \|= OPTION_CLOAK;
	6470	break;
	6471	case SC_CHASEWALK:
	6472	sc->option \|= OPTION_CHASEWALK\|OPTION_CLOAK;
	6473	break;
	6474	case SC_SIGHT:
	6475	sc->option \|= OPTION_SIGHT;
	6476	break;
	6477	case SC_RUWACH:
	6478	sc->option \|= OPTION_RUWACH;
	6479	break;
	6480	case SC_WEDDING:
	6481	sc->option \|= OPTION_WEDDING;
	6482	break;
	6483	case SC_XMAS:
	6484	sc->option \|= OPTION_XMAS;
	6485	break;
	6486	case SC_SUMMER:
	6487	sc->option \|= OPTION_SUMMER;
	6488	break;
	6489	case SC_ORCISH:
	6490	sc->option \|= OPTION_ORCISH;
	6491	break;
	6492	case SC_FUSION:
	6493	sc->option \|= OPTION_FLYING;
	6494	break;
	6495	default:
	6496	opt_flag = 0;
	6497	}
	6498
	6499	//On Aegis, when turning on a status change, first goes the option packet, then the sc packet.
	6500	if(opt_flag)
	6501	clif_changeoption(bl);
	6502
	6503	if (calc_flag&SCB_DYE)
	6504	{ //Reset DYE color
	6505	if (vd && vd->cloth_color)
	6506	{
	6507	val4 = vd->cloth_color;
	6508	clif_changelook(bl,LOOK_CLOTHES_COLOR,0);
	6509	}
	6510	calc_flag&=~SCB_DYE;
	6511	}
	6512
	6513	if (vd && pcdb_checkid(vd->class_)) //Only for players sprites, client crashes if they receive this for a mob o.O [Skotlex]
	6514	clif_status_change(bl,StatusIconChangeTable[type],1);
	6515	else if (sd) //Send packet to self otherwise (disguised player?)
	6516	clif_status_load(bl,StatusIconChangeTable[type],1);
	6517
	6518	//Don't trust the previous sce assignment, in case the SC ended somewhere between there and here.
	6519	if((sce=sc->data[type]))
	6520	{// reuse old sc
	6521	if( sce->timer != INVALID_TIMER )
	6522	delete_timer(sce->timer, status_change_timer);
	6523	}
	6524	else
	6525	{// new sc
	6526	++(sc->count);
	6527	sce = sc->data[type] = ers_alloc(sc_data_ers, struct status_change_entry);
	6528	}
	6529	sce->val1 = val1;
	6530	sce->val2 = val2;
	6531	sce->val3 = val3;
	6532	sce->val4 = val4;
	6533	if (tick >= 0)
	6534	sce->timer = add_timer(gettick() + tick, status_change_timer, bl->id, type);
	6535	else
	6536	sce->timer = INVALID_TIMER; //Infinite duration
	6537
	6538	if (calc_flag)
	6539	status_calc_bl(bl,calc_flag);
	6540
	6541	if(sd && sd->pd)
	6542	pet_sc_check(sd, type); //Skotlex: Pet Status Effect Healing
	6543
	6544	if (type==SC_BERSERK) {
	6545	sce->val2 = 5*status->max_hp/100;
	6546	status_heal(bl, status->max_hp, 0, 1); //Do not use percent_heal as this healing must override BERSERK's block.
	6547	status_set_sp(bl, 0, 0); //Damage all SP
	6548	} else if (type==SC_CHANGE) //Heal all HP/SP
	6549	status_percent_heal(bl, 100, 100);
	6550
	6551	if (type==SC_RUN) {
	6552	struct unit_data *ud = unit_bl2ud(bl);
	6553	if (ud)
	6554	ud->state.running = unit_run(bl);
	6555	}
	6556	return 1;
	6557	}
	6558	/*==========================================
	6559	* Xe[^XÙíSð
	6560	* type:
	6561	* 0 - ???
	6562	* 1 - ???
	6563	* 2 - ???
	6564	------------------------------------------/
	6565	int status_change_clear(struct block_list* bl, int type)
	6566	{
	6567	struct status_change* sc;
	6568	int i;
	6569
	6570	sc = status_get_sc(bl);
	6571
	6572	if (!sc \|\| !sc->count)
	6573	return 0;
	6574
	6575	if(sc->data[SC_DANCING])
	6576	skill_stop_dancing(bl);
	6577
	6578	for(i = 0; i < SC_MAX; i++)
	6579	{
	6580	if(!sc->data[i])
	6581	continue;
	6582
	6583	if(type == 0)
	6584	switch (i)
	6585	{ //Type 0: PC killed -> Place here statuses that do not dispel on death.
	6586	case SC_EDP:
	6587	case SC_MELTDOWN:
	6588	case SC_XMAS:
	6589	case SC_SUMMER:
	6590	case SC_NOCHAT:
	6591	case SC_FUSION:
	6592	case SC_TKREST:
	6593	case SC_READYSTORM:
	6594	case SC_READYDOWN:
	6595	case SC_READYCOUNTER:
	6596	case SC_READYTURN:
	6597	case SC_DODGE:
	6598	case SC_JAILED:
	6599	case SC_EXPBOOST:
	6600	case SC_ITEMBOOST:
	6601	continue;
	6602	}
	6603
	6604	status_change_end(bl, (sc_type)i, INVALID_TIMER);
	6605
	6606	if( type == 1 && sc->data[i] )
	6607	{ //If for some reason status_change_end decides to still keep the status when quitting. [Skotlex]
	6608	(sc->count)--;
	6609	if (sc->data[i]->timer != INVALID_TIMER)
	6610	delete_timer(sc->data[i]->timer, status_change_timer);
	6611	ers_free(sc_data_ers, sc->data[i]);
	6612	sc->data[i] = NULL;
	6613	}
	6614	}
	6615
	6616	sc->opt1 = 0;
	6617	sc->opt2 = 0;
	6618	sc->opt3 = 0;
	6619	sc->option &= OPTION_MASK;
	6620
	6621	if( type == 0 \|\| type == 2 )
	6622	clif_changeoption(bl);
	6623
	6624	return 1;
	6625	}
	6626
	6627	/*==========================================
	6628	* Xe[^XÙíI¹
	6629	------------------------------------------/
	6630	int status_change_end(struct block_list* bl, enum sc_type type, int tid)
	6631	{
	6632	struct map_session_data *sd;
	6633	struct status_change *sc;
	6634	struct status_change_entry *sce;
	6635	struct status_data *status;
	6636	struct view_data *vd;
	6637	int opt_flag=0, calc_flag;
	6638
	6639	nullpo_retr(0, bl);
	6640
	6641	sc = status_get_sc(bl);
	6642	status = status_get_status_data(bl);
	6643
	6644	if(type < 0 \|\| type >= SC_MAX \|\| !sc \|\| !(sce = sc->data[type]))
	6645	return 0;
	6646
	6647	sd = BL_CAST(BL_PC,bl);
	6648
	6649	if (sce->timer != tid && tid != -1)
	6650	return 0;
	6651
	6652	if (tid == -1) {
	6653	if (type == SC_ENDURE && sce->val4)
	6654	//Do not end infinite endure.
	6655	return 0;
	6656	if (sce->timer != -1) //Could be a SC with infinite duration
	6657	delete_timer(sce->timer,status_change_timer);
	6658	if (sc->opt1)
	6659	switch (type) {
	6660	//"Ugly workaround" [Skotlex]
	6661	//delays status change ending so that a skill that sets opt1 fails to
	6662	//trigger when it also removed one
	6663	case SC_STONE:
	6664	sce->val3 = 0; //Petrify time counter.
	6665	case SC_FREEZE:
	6666	case SC_STUN:
	6667	case SC_SLEEP:
	6668	if (sce->val1) {
	6669	//Removing the 'level' shouldn't affect anything in the code
	6670	//since these SC are not affected by it, and it lets us know
	6671	//if we have already delayed this attack or not.
	6672	sce->val1 = 0;
	6673	sce->timer = add_timer(gettick()+10, status_change_timer, bl->id, type);
	6674	return 1;
	6675	}
	6676	}
	6677	}
	6678
	6679	sc->data[type] = NULL;
	6680	(sc->count)--;
	6681
	6682	vd = status_get_viewdata(bl);
	6683	calc_flag = StatusChangeFlagTable[type];
	6684	switch(type){
	6685	case SC_WEDDING:
	6686	case SC_XMAS:
	6687	case SC_SUMMER:
	6688	if (!vd) break;
	6689	if (sd)
	6690	{ //Load data from sd->status.* as the stored values could have changed.
	6691	//Must remove OPTION to prevent class being rechanged.
	6692	sc->option &= type==SC_WEDDING?~OPTION_WEDDING:type==SC_XMAS?~OPTION_XMAS:~OPTION_SUMMER;
	6693	clif_changeoption(&sd->bl);
	6694	status_set_viewdata(bl, sd->status.class_);
	6695	} else {
	6696	vd->class_ = sce->val1;
	6697	vd->weapon = sce->val2;
	6698	vd->shield = sce->val3;
	6699	vd->cloth_color = sce->val4;
	6700	}
	6701	clif_changelook(bl,LOOK_BASE,vd->class_);
	6702	clif_changelook(bl,LOOK_CLOTHES_COLOR,vd->cloth_color);
	6703	clif_changelook(bl,LOOK_WEAPON,vd->weapon);
	6704	clif_changelook(bl,LOOK_SHIELD,vd->shield);
	6705	break;
	6706	case SC_RUN:
	6707	{
	6708	struct unit_data *ud = unit_bl2ud(bl);
	6709	bool begin_spurt = true;
	6710	if (ud) {
	6711	if(!ud->state.running)
	6712	begin_spurt = false;
	6713	ud->state.running = 0;
	6714	if (ud->walktimer != -1)
	6715	unit_stop_walking(bl,1);
	6716	}
	6717	if (begin_spurt && sce->val1 >= 7 &&
	6718	DIFF_TICK(gettick(), sce->val4) <= 1000 &&
	6719	(!sd \|\| (sd->weapontype1 == 0 && sd->weapontype2 == 0))
	6720	)
	6721	sc_start(bl,SC_SPURT,100,sce->val1,skill_get_time2(status_sc2skill(type), sce->val1));
	6722	}
	6723	break;
	6724	case SC_AUTOBERSERK:
	6725	if (sc->data[SC_PROVOKE] && sc->data[SC_PROVOKE]->val2 == 1)
	6726	status_change_end(bl,SC_PROVOKE,-1);
	6727	break;
	6728
	6729	case SC_ENDURE:
	6730	case SC_DEFENDER:
	6731	case SC_REFLECTSHIELD:
	6732	case SC_AUTOGUARD:
	6733	if (sd) {
	6734	struct map_session_data *tsd;
	6735	int i;
	6736	for (i = 0; i < 5; i++)
	6737	{ //Clear the status from the others too [Skotlex]
	6738	if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])) && tsd->sc.data[type])
	6739	status_change_end(&tsd->bl,type,-1);
	6740	}
	6741	}
	6742	break;
	6743	case SC_DEVOTION:
	6744	{
	6745	struct map_session_data *md = map_id2sd(sce->val1);
	6746	//The status could have changed because the Crusader left the game. [Skotlex]
	6747	if (md)
	6748	{
	6749	md->devotion[sce->val2] = 0;
	6750	clif_devotion(md,NULL);
	6751	}
	6752	//Remove inherited status [Skotlex]
	6753	status_change_end(bl,SC_AUTOGUARD,-1);
	6754	status_change_end(bl,SC_DEFENDER,-1);
	6755	status_change_end(bl,SC_REFLECTSHIELD,-1);
	6756	status_change_end(bl,SC_ENDURE,-1);
	6757	}
	6758	break;
	6759	case SC_BLADESTOP:
	6760	if(sce->val4)
	6761	{
	6762	struct block_list tbl = (struct block_list )sce->val4;
	6763	struct status_change *tsc = status_get_sc(tbl);
	6764	sce->val4 = 0;
	6765	if(tsc && tsc->data[SC_BLADESTOP])
	6766	{
	6767	tsc->data[SC_BLADESTOP]->val4 = 0;
	6768	status_change_end(tbl,SC_BLADESTOP,-1);
	6769	}
	6770	clif_bladestop(bl,tbl,0);
	6771	}
	6772	break;
	6773	case SC_DANCING:
	6774	{
	6775	struct map_session_data *dsd;
	6776	struct status_change_entry *dsc;
	6777	struct skill_unit_group *group;
	6778	if(sce->val2)
	6779	{
	6780	group = (struct skill_unit_group *)sce->val2;
	6781	sce->val2 = 0;
	6782	skill_delunitgroup(bl, group);
	6783	}
	6784	if(sce->val4 && sce->val4 != BCT_SELF && (dsd=map_id2sd(sce->val4))){
	6785	dsc = dsd->sc.data[type];
	6786	if(dsc)
	6787	{ //This will prevent recursive loops.
	6788	dsc->val2 = dsc->val4 = 0;
	6789	status_change_end(&dsd->bl, type, -1);
	6790	}
	6791	}
	6792	}
	6793	if ((sce->val1&0xFFFF) == CG_MOONLIT)
	6794	clif_status_change(bl,SI_MOONLIT,0);
	6795
	6796	status_change_end(bl,SC_LONGING,-1);
	6797	break;
	6798	case SC_NOCHAT:
	6799	if (sd && sd->status.manner < 0 && tid != -1)
	6800	sd->status.manner = 0;
	6801	if (sd)
	6802	{
	6803	clif_changestatus(&sd->bl,SP_MANNER,sd->status.manner);
	6804	clif_updatestatus(sd,SP_MANNER);
	6805	}
	6806	break;
[10]	6807	//Custom Jobs (blackmagic)
[13]	6808	case SC_SPLASHER:
[10]	6809	case SC_DOOM: // Warlock Curse of Doom [Brain]
	6810	//Custom Job End
[1]	6811	{
	6812	struct block_list *src=map_id2bl(sce->val3);
	6813	if(src && tid!=-1)
	6814	skill_castend_damage_id(src, bl, sce->val2, sce->val1, gettick(), SD_LEVEL );
	6815	}
	6816	break;
	6817	case SC_CLOSECONFINE2:
	6818	{
	6819	struct block_list *src = sce->val2?map_id2bl(sce->val2):NULL;
	6820	struct status_change *sc2 = src?status_get_sc(src):NULL;
	6821	if (src && sc2 && sc2->data[SC_CLOSECONFINE]) {
	6822	//If status was already ended, do nothing.
	6823	//Decrease count
	6824	if (--(sc2->data[SC_CLOSECONFINE]->val1) <= 0) //No more holds, free him up.
	6825	status_change_end(src, SC_CLOSECONFINE, -1);
	6826	}
	6827	}
	6828	case SC_CLOSECONFINE:
	6829	if (sce->val2 > 0) {
	6830	//Caster has been unlocked... nearby chars need to be unlocked.
	6831	int range = 1
	6832	+skill_get_range2(bl, status_sc2skill(type), sce->val1)
	6833	+skill_get_range2(bl, TF_BACKSLIDING, 1); //Since most people use this to escape the hold....
	6834	map_foreachinarea(status_change_timer_sub,
	6835	bl->m, bl->x-range, bl->y-range, bl->x+range,bl->y+range,BL_CHAR,bl,sce,type,gettick());
	6836	}
	6837	break;
	6838	case SC_COMBO: //Clear last used skill when it is part of a combo.
	6839	if (sd && sd->skillid_old == sce->val1)
	6840	sd->skillid_old = sd->skilllv_old = 0;
	6841	break;
	6842
	6843	case SC_MARIONETTE:
	6844	case SC_MARIONETTE2: /// Marionette target
	6845	if (sce->val1)
	6846	{ // check for partner and end their marionette status as well
	6847	enum sc_type type2 = (type == SC_MARIONETTE) ? SC_MARIONETTE2 : SC_MARIONETTE;
	6848	struct block_list *pbl = map_id2bl(sce->val1);
	6849	struct status_change* sc2 = pbl?status_get_sc(pbl):NULL;
	6850
	6851	if (sc2 && sc2->data[type2])
	6852	{
	6853	sc2->data[type2]->val1 = 0;
	6854	status_change_end(pbl, type2, -1);
	6855	}
	6856	}
	6857	break;
	6858
	6859	case SC_BERSERK:
	6860	//If val2 is removed, no HP penalty (dispelled?) [Skotlex]
	6861	if(status->hp > 100 && sce->val2)
	6862	status_set_hp(bl, 100, 0);
	6863	if(sc->data[SC_ENDURE] && sc->data[SC_ENDURE]->val4 == 2)
	6864	{
	6865	sc->data[SC_ENDURE]->val4 = 0;
	6866	status_change_end(bl, SC_ENDURE, -1);
	6867	}
	6868	sc_start4(bl, SC_REGENERATION, 100, 10,0,0,(RGN_HP\|RGN_SP),
	6869	skill_get_time(LK_BERSERK, sce->val1));
	6870	break;
	6871	case SC_GOSPEL:
	6872	if (sce->val3) { //Clear the group.
	6873	struct skill_unit_group group = (struct skill_unit_group )sce->val3;
	6874	sce->val3 = 0;
	6875	skill_delunitgroup(bl, group);
	6876	}
	6877	break;
	6878	case SC_HERMODE:
	6879	if(sce->val3 == BCT_SELF)
	6880	skill_clear_unitgroup(bl);
	6881	break;
	6882	case SC_BASILICA: //Clear the skill area. [Skotlex]
	6883	skill_clear_unitgroup(bl);
	6884	break;
	6885	case SC_TRICKDEAD:
	6886	if (vd) vd->dead_sit = 0;
	6887	break;
	6888	case SC_WARM:
	6889	if (sce->val4) { //Clear the group.
	6890	struct skill_unit_group group = (struct skill_unit_group )sce->val4;
	6891	sce->val4 = 0;
	6892	skill_delunitgroup(bl, group);
	6893	}
	6894	break;
	6895	case SC_KAAHI:
	6896	//Delete timer if it exists.
	6897	if (sce->val4 != -1)
	6898	delete_timer(sce->val4,kaahi_heal_timer);
	6899	break;
	6900	case SC_JAILED:
	6901	if(tid == -1)
	6902	break;
	6903	//natural expiration.
	6904	if(sd && sd->mapindex == sce->val2)
	6905	pc_setpos(sd,(unsigned short)sce->val3,sce->val4&0xFFFF, sce->val4>>16, 3);
	6906	break; //guess hes not in jail :P
	6907	case SC_CHANGE:
	6908	if (tid == -1)
	6909	break;
	6910	// "lose almost all their HP and SP" on natural expiration.
	6911	status_set_hp(bl, 10, 0);
	6912	status_set_sp(bl, 10, 0);
	6913	break;
	6914	case SC_AUTOTRADE:
	6915	if (tid == -1)
	6916	break;
	6917	vending_closevending(sd);
	6918	map_quit(sd);
	6919	// Because map_quit calls status_change_end with tid -1
	6920	// from here it's not neccesary to continue
	6921	return 1;
	6922	break;
	6923	}
	6924
	6925	opt_flag = 1;
	6926	switch(type){
	6927	case SC_STONE:
	6928	case SC_FREEZE:
	6929	case SC_STUN:
	6930	case SC_SLEEP:
	6931	sc->opt1 = 0;
	6932	break;
	6933
	6934	case SC_POISON:
	6935	case SC_CURSE:
	6936	case SC_SILENCE:
	6937	case SC_BLIND:
	6938	sc->opt2 &= ~(1<<(type-SC_POISON));
	6939	break;
	6940	case SC_DPOISON:
	6941	sc->opt2 &= ~OPT2_DPOISON;
	6942	break;
	6943	case SC_SIGNUMCRUCIS:
	6944	sc->opt2 &= ~OPT2_SIGNUMCRUCIS;
	6945	break;
	6946
	6947	case SC_HIDING:
	6948	sc->option &= ~OPTION_HIDE;
	6949	opt_flag\|= 2\|4; //Check for warp trigger + AoE trigger
	6950	break;
	6951	case SC_CLOAKING:
	6952	sc->option &= ~OPTION_CLOAK;
	6953	opt_flag\|= 2;
	6954	break;
	6955	case SC_CHASEWALK:
	6956	sc->option &= ~(OPTION_CHASEWALK\|OPTION_CLOAK);
	6957	opt_flag\|= 2;
	6958	break;
	6959	case SC_SIGHT:
	6960	sc->option &= ~OPTION_SIGHT;
	6961	break;
	6962	case SC_WEDDING:
	6963	sc->option &= ~OPTION_WEDDING;
	6964	break;
	6965	case SC_XMAS:
	6966	sc->option &= ~OPTION_XMAS;
	6967	break;
	6968	case SC_SUMMER:
	6969	sc->option &= ~OPTION_SUMMER;
	6970	break;
	6971	case SC_ORCISH:
	6972	sc->option &= ~OPTION_ORCISH;
	6973	break;
	6974	case SC_RUWACH:
	6975	sc->option &= ~OPTION_RUWACH;
	6976	break;
	6977	case SC_FUSION:
	6978	sc->option &= ~OPTION_FLYING;
	6979	break;
	6980	//opt3
	6981	case SC_TWOHANDQUICKEN:
	6982	case SC_ONEHAND:
	6983	case SC_SPEARQUICKEN:
	6984	case SC_CONCENTRATION:
	6985	sc->opt3 &= ~0x1;
	6986	opt_flag = 0;
	6987	break;
	6988	case SC_OVERTHRUST:
	6989	case SC_MAXOVERTHRUST:
	6990	case SC_SWOO:
	6991	sc->opt3 &= ~0x2;
	6992	opt_flag = 0;
	6993	break;
	6994	case SC_ENERGYCOAT:
	6995	case SC_SKE:
	6996	sc->opt3 &= ~0x4;
	6997	opt_flag = 0;
	6998	break;
	6999	case SC_INCATKRATE: //Simulated Explosion spirits effect.
	7000	if (bl->type != BL_MOB)
	7001	{
	7002	opt_flag = 0;
	7003	break;
	7004	}
	7005	case SC_EXPLOSIONSPIRITS:
	7006	sc->opt3 &= ~0x8;
	7007	opt_flag = 0;
	7008	break;
	7009	case SC_STEELBODY:
	7010	case SC_SKA:
	7011	sc->opt3 &= ~0x10;
	7012	opt_flag = 0;
	7013	break;
	7014	case SC_BLADESTOP:
	7015	sc->opt3 &= ~0x20;
	7016	opt_flag = 0;
	7017	break;
	7018	case SC_BERSERK:
	7019	sc->opt3 &= ~0x80;
	7020	opt_flag = 0;
	7021	break;
	7022	case SC_DANCING:
	7023	if ((sce->val1&0xFFFF) == CG_MOONLIT)
	7024	sc->opt3 &= ~0x200;
	7025	opt_flag = 0;
	7026	break;
	7027	case SC_MARIONETTE:
	7028	case SC_MARIONETTE2:
	7029	sc->opt3 &= ~0x400;
	7030	opt_flag = 0;
	7031	break;
	7032	case SC_ASSUMPTIO:
	7033	sc->opt3 &= ~0x800;
	7034	opt_flag = 0;
	7035	break;
	7036	case SC_WARM: //SG skills [Komurka]
	7037	sc->opt3 &= ~0x1000;
	7038	opt_flag = 0;
	7039	break;
	7040	case SC_KAITE:
	7041	sc->opt3 &= ~0x2000;
	7042	opt_flag = 0;
	7043	break;
	7044	case SC_BUNSINJYUTSU:
	7045	sc->opt3 &= ~0x4000;
	7046	opt_flag = 0;
	7047	break;
	7048	case SC_SPIRIT:
	7049	sc->opt3 &= ~0x8000;
	7050	opt_flag = 0;
	7051	break;
	7052	case SC_CHANGEUNDEAD:
	7053	sc->opt3 &= ~0x10000;
	7054	opt_flag = 0;
	7055	break;
	7056	// TODO:
	7057	// case ???:
	7058	// sc->opt3 &= ~0x20000;
	7059	// opt_flag = 0;
	7060	// break;
	7061	default:
	7062	opt_flag = 0;
	7063	}
	7064
	7065	if (calc_flag&SCB_DYE)
	7066	{ //Restore DYE color
	7067	if (vd && !vd->cloth_color && sce->val4)
	7068	clif_changelook(bl,LOOK_CLOTHES_COLOR,sce->val4);
	7069	calc_flag&=~SCB_DYE;
	7070	}
	7071
	7072	//On Aegis, when turning off a status change, first goes the sc packet, then the option packet.
	7073	if (vd && pcdb_checkid(vd->class_))
	7074	clif_status_change(bl,StatusIconChangeTable[type],0);
	7075	else if (sd)
	7076	clif_status_load(bl,StatusIconChangeTable[type],0);
	7077
	7078	if(opt_flag)
	7079	clif_changeoption(bl);
	7080
	7081	if (calc_flag)
	7082	status_calc_bl(bl,calc_flag);
	7083
	7084	if(opt_flag&4) //Out of hiding, invoke on place.
	7085	skill_unit_move(bl,gettick(),1);
	7086
	7087	if(opt_flag&2 && sd && map_getcell(bl->m,bl->x,bl->y,CELL_CHKNPC))
	7088	npc_touch_areanpc(sd,bl->m,bl->x,bl->y); //Trigger on-touch event.
	7089
	7090	ers_free(sc_data_ers, sce);
	7091	return 1;
	7092	}
	7093
	7094	int kaahi_heal_timer(int tid, unsigned int tick, int id, intptr data)
	7095	{
	7096	struct block_list *bl;
	7097	struct status_change *sc;
	7098	struct status_change_entry *sce;
	7099	struct status_data *status;
	7100	int hp;
	7101
	7102	if(!((bl=map_id2bl(id))&&
	7103	(sc=status_get_sc(bl)) &&
	7104	(sce = sc->data[SC_KAAHI])))
	7105	return 0;
	7106
	7107	if(sce->val4 != tid) {
	7108	ShowError("kaahi_heal_timer: Timer mismatch: %d != %d\n", tid, sce->val4);
	7109	sce->val4=-1;
	7110	return 0;
	7111	}
	7112
	7113	status=status_get_status_data(bl);
	7114	if(!status_charge(bl, 0, sce->val3)) {
	7115	sce->val4=-1;
	7116	return 0;
	7117	}
	7118
	7119	hp = status->max_hp - status->hp;
	7120	if (hp > sce->val2)
	7121	hp = sce->val2;
	7122	if (hp)
	7123	status_heal(bl, hp, 0, 2);
	7124	sce->val4=-1;
	7125	return 1;
	7126	}
	7127
	7128	/*==========================================
	7129	* Xe[^XÙíI¹^C}[
	7130	------------------------------------------/
	7131	int status_change_timer(int tid, unsigned int tick, int id, intptr data)
	7132	{
	7133	enum sc_type type = (sc_type)data;
	7134	struct block_list *bl;
	7135	struct map_session_data *sd;
	7136	struct status_data *status;
	7137	struct status_change *sc;
	7138	struct status_change_entry *sce;
	7139
	7140	bl = map_id2bl(id);
	7141	if(!bl)
	7142	{
	7143	ShowDebug("status_change_timer: Null pointer id: %d data: %d\n", id, data);
	7144	return 0;
	7145	}
	7146	sc = status_get_sc(bl);
	7147	status = status_get_status_data(bl);
	7148
	7149	if(!(sc && (sce = sc->data[type])))
	7150	{
	7151	ShowDebug("status_change_timer: Null pointer id: %d data: %d bl-type: %d\n", id, data, bl->type);
	7152	return 0;
	7153	}
	7154
	7155	if( sce->timer != tid )
	7156	{
	7157	ShowError("status_change_timer: Mismatch for type %d: %d != %d (bl id %d)\n",type,tid,sce->timer, bl->id);
	7158	return 0;
	7159	}
	7160
	7161	sd = BL_CAST(BL_PC, bl);
	7162
	7163	// set the next timer of the sce (don't assume the status still exists)
	7164	#define sc_timer_next(t,f,i,d) \
	7165	if( (sce=sc->data[type]) ) \
	7166	sce->timer = add_timer(t,f,i,d); \
	7167	else \
	7168	ShowError("status_change_timer: Unexpected NULL status change id: %d data: %d\n", id, data)
	7169
	7170	switch(type)
	7171	{
	7172	case SC_MAXIMIZEPOWER:
	7173	case SC_CLOAKING:
	7174	if(!status_charge(bl, 0, 1))
	7175	break; //Not enough SP to continue.
	7176	sc_timer_next(sce->val2+tick, status_change_timer, bl->id, data);
	7177	return 0;
[10]	7178	//Custom Jobs (blackmagic)
[13]	7179	case SC_LUST: // Adept Blood Lust [Brain]
	7180	if(!status_charge(bl, status->max_hp/100, 0))
	7181	break; //Not enough HP to continue.
	7182	sc_timer_next(sce->val3+tick, status_change_timer, bl->id, data);
[10]	7183	return 0;
[13]	7184	case SC_DEATHPACT: // Necro Death Pact [Brain]
	7185	// Drains 1 HP every second (status wont kill, but dying will cancel it)
	7186	status_charge(bl, 1, 0);
	7187	sc_timer_next(sce->val3+tick, status_change_timer, bl->id, data);
	7188	return 0;
	7189	case SC_OVERWHELMING: // Warlock Overwhelming Evil [Brain]
	7190	if(!status_charge(bl, 0, status->max_sp/100))
	7191	break; //Not enough SP to continue.
	7192	sc_timer_next(sce->val3+tick, status_change_timer, bl->id, data);
	7193	return 0;
[10]	7194	//Custom Job End
[1]	7195
	7196	case SC_CHASEWALK:
	7197	if(!status_charge(bl, 0, sce->val4))
	7198	break; //Not enough SP to continue.
	7199
	7200	if (!sc->data[SC_INCSTR]) {
	7201	sc_start(bl, SC_INCSTR,100,1<<(sce->val1-1),
	7202	(sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_ROGUE?10:1) //SL bonus -> x10 duration
	7203	*skill_get_time2(status_sc2skill(type),sce->val1));
	7204	}
	7205	sc_timer_next(sce->val2+tick, status_change_timer, bl->id, data);
	7206	return 0;
	7207	break;
	7208
	7209	case SC_SKA:
	7210	if(--(sce->val2)>0){
	7211	sce->val3 = rand()%100; //Random defense.
	7212	sc_timer_next(1000+tick, status_change_timer,bl->id, data);
	7213	return 0;
	7214	}
	7215	break;
	7216
	7217	case SC_HIDING:
	7218	if(--(sce->val2)>0){
	7219
	7220	if(sce->val2 % sce->val4 == 0 && !status_charge(bl, 0, 1))
	7221	break; //Fail if it's time to substract SP and there isn't.
	7222
	7223	sc_timer_next(1000+tick, status_change_timer,bl->id, data);
	7224	return 0;
	7225	}
	7226	break;
	7227
	7228	case SC_SIGHT:
	7229	case SC_RUWACH:
	7230	case SC_SIGHTBLASTER:
	7231	map_foreachinrange( status_change_timer_sub, bl, sce->val3, BL_CHAR, bl, sce, type, tick);
	7232
	7233	if( --(sce->val2)>0 ){
	7234	sc_timer_next(250+tick, status_change_timer, bl->id, data);
	7235	return 0;
	7236	}
	7237	break;
	7238
	7239	case SC_PROVOKE:
	7240	if(sce->val2) { //Auto-provoke (it is ended in status_heal)
	7241	sc_timer_next(1000*60+tick,status_change_timer, bl->id, data );
	7242	return 0;
	7243	}
	7244	break;
	7245
	7246	case SC_STONE:
	7247	if(sc->opt1 == OPT1_STONEWAIT && sce->val3) {
	7248	sce->val4 = 0;
	7249	unit_stop_walking(bl,1);
	7250	sc->opt1 = OPT1_STONE;
	7251	clif_changeoption(bl);
	7252	sc_timer_next(1000+tick,status_change_timer, bl->id, data );
	7253	status_calc_bl(bl, StatusChangeFlagTable[type]);
	7254	return 0;
	7255	}
	7256	if(--(sce->val3) > 0) {
	7257	if(++(sce->val4)%5 == 0 && status->hp > status->max_hp/4)
	7258	status_percent_damage(NULL, bl, 1, 0, false);
	7259	sc_timer_next(1000+tick,status_change_timer, bl->id, data );
	7260	return 0;
	7261	}
	7262	break;
	7263
	7264	case SC_POISON:
	7265	if(status->hp <= status->max_hp>>2) //Stop damaging after 25% HP left.
	7266	break;
	7267	case SC_DPOISON:
	7268	if (--(sce->val3) > 0) {
	7269	if (!sc->data[SC_SLOWPOISON]) {
	7270	bool flag;
	7271	map_freeblock_lock();
	7272	status_zap(bl, sce->val4, 0);
	7273	flag = !sc->data[type]; //We check for this rather than 'killed' since the target could have revived with kaizel.
	7274	map_freeblock_unlock();
	7275	if (flag) return 0; //target died, SC cancelled already.
	7276	}
	7277	sc_timer_next(1000 + tick, status_change_timer, bl->id, data );
	7278	return 0;
	7279	}
	7280	break;
	7281
	7282	case SC_TENSIONRELAX:
	7283	if(status->max_hp > status->hp && --(sce->val3) > 0){
	7284	sc_timer_next(sce->val4+tick, status_change_timer, bl->id, data);
	7285	return 0;
	7286	}
	7287	break;
	7288
	7289	case SC_BLEEDING:
	7290	if (--(sce->val4) >= 0) {
	7291	int flag;
	7292	map_freeblock_lock();
	7293	status_fix_damage(NULL, bl, rand()%600 + 200, 0);
	7294	flag = !sc->data[type];
	7295	map_freeblock_unlock();
	7296	if (flag) return 0; //SC already ended.
	7297	sc_timer_next(10000 + tick, status_change_timer, bl->id, data);
	7298	return 0;
	7299	}
	7300	break;
	7301
	7302	case SC_KNOWLEDGE:
	7303	if (!sd) break;
	7304	if(bl->m == sd->feel_map[0].m \|\|
	7305	bl->m == sd->feel_map[1].m \|\|
	7306	bl->m == sd->feel_map[2].m)
	7307	{ //Timeout will be handled by pc_setpos
	7308	sce->timer = INVALID_TIMER;
	7309	return 0;
	7310	}
	7311	break;
	7312
	7313	case SC_HPREGEN:
	7314	case SC_SPREGEN:
	7315	if( sd && --(sce->val4) >= 0 )
	7316	{
	7317	// val1 < 0 = per max% \| val1 > 0 = exact amount
	7318	int hp = 0, sp = 0;
	7319	if( type == SC_HPREGEN && status->hp < status->max_hp )
	7320	hp = (sce->val1 < 0) ? (int)(sd->status.max_hp * -1 * sce->val1 / 100.) : sce->val1 ;
	7321	else if( type == SC_SPREGEN && status->sp < status->max_sp )
	7322	sp = (sce->val1 < 0) ? (int)(sd->status.max_sp * -1 * sce->val1 / 100.) : sce->val1 ;
	7323
	7324	status_heal(bl, hp, sp, 2);
	7325	sc_timer_next((sce->val2 * 1000) + tick, status_change_timer, bl->id, data );
	7326	return 0;
	7327	}
	7328	break;
	7329
	7330	case SC_DANCING: //_XXLÌÔSPÁï
	7331	{
	7332	int s = 0;
	7333	int sp = 1;
	7334	int counter = (sce->val3)>>16;
	7335	if (--counter <= 0)
	7336	break;
	7337	sce->val3&= 0xFFFF; //Remove counter
	7338	sce->val3\|=(counter<<16);//Reset it.
	7339	switch(sce->val1&0xFFFF){
	7340	case BD_RICHMANKIM:
	7341	case BD_DRUMBATTLEFIELD:
	7342	case BD_RINGNIBELUNGEN:
	7343	case BD_SIEGFRIED:
	7344	case BA_DISSONANCE:
	7345	case BA_ASSASSINCROSS:
	7346	case DC_UGLYDANCE:
	7347	s=3;
	7348	break;
	7349	case BD_LULLABY:
	7350	case BD_ETERNALCHAOS:
	7351	case BD_ROKISWEIL:
	7352	case DC_FORTUNEKISS:
	7353	s=4;
	7354	break;
	7355	case CG_HERMODE:
	7356	case BD_INTOABYSS:
	7357	case BA_WHISTLE:
	7358	case DC_HUMMING:
	7359	case BA_POEMBRAGI:
	7360	case DC_SERVICEFORYOU:
	7361	s=5;
	7362	break;
	7363	case BA_APPLEIDUN:
	7364	s=6;
	7365	break;
	7366	case CG_MOONLIT:
	7367	//Moonlit's cost is 4sp*skill_lv [Skotlex]
	7368	sp= 4*(sce->val1>>16);
	7369	//Upkeep is also every 10 secs.
	7370	case DC_DONTFORGETME:
	7371	s=10;
	7372	break;
	7373	}
	7374	if (s && (counter%s == 0))
	7375	{
	7376	if (sc->data[SC_LONGING])
	7377	sp*= 3;
	7378	if (!status_charge(bl, 0, sp))
	7379	break;
	7380	}
	7381	sc_timer_next(1000+tick, status_change_timer, bl->id, data);
	7382	return 0;
	7383	}
	7384	break;
	7385
	7386	case SC_DEVOTION:
	7387	//FIXME: use normal status duration instead of a looping timer
	7388	if( (sce->val4 -= 1000) > 0 )
	7389	{
	7390	sc_timer_next(1000+tick, status_change_timer, bl->id, data);
	7391	return 0;
	7392	}
	7393	break;
	7394
	7395	case SC_BERSERK:
	7396	// 5% every 10 seconds [DracoRPG]
	7397	if(--(sce->val3)>0 && status_charge(bl, sce->val2, 0))
	7398	{
	7399	sc_timer_next(sce->val4+tick, status_change_timer, bl->id, data);
	7400	return 0;
	7401	}
	7402	break;
	7403
	7404	case SC_NOCHAT:
	7405	if(sd){
	7406	sd->status.manner++;
	7407	clif_changestatus(bl,SP_MANNER,sd->status.manner);
	7408	clif_updatestatus(sd,SP_MANNER);
	7409	if (sd->status.manner < 0)
	7410	{ //Every 60 seconds your manner goes up by 1 until it gets back to 0.
	7411	sc_timer_next(60000+tick, status_change_timer, bl->id, data);
	7412	return 0;
	7413	}
	7414	}
	7415	break;
	7416
	7417	case SC_SPLASHER:
	7418	// custom Venom Splasher countdown timer
	7419	//if (sce->val4 % 1000 == 0) {
	7420	// char timer[10];
	7421	// snprintf (timer, 10, "%d", sce->val4/1000);
	7422	// clif_message(bl, timer);
	7423	//}
	7424	if((sce->val4 -= 500) > 0) {
	7425	sc_timer_next(500 + tick, status_change_timer, bl->id, data);
	7426	return 0;
	7427	}
	7428	break;
[10]	7429	//Custom Jobs (blackmagic)
[13]	7430	case SC_DOOM: // Warlock Curse of Doom [Brain]
	7431	if((sce->val4 -= 500) > 0) {
	7432	sc_timer_next(500 + tick, status_change_timer, bl->id, data);
	7433	return 0;
	7434	}
[10]	7435	break;
	7436	//Custom Job End
[1]	7437
	7438	case SC_MARIONETTE:
	7439	case SC_MARIONETTE2:
	7440	{
	7441	struct block_list *pbl = map_id2bl(sce->val1);
	7442	if (pbl && check_distance_bl(bl, pbl, 7) && (sce->val2)-->0)
	7443	{
	7444	sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
	7445	return 0;
	7446	}
	7447	}
	7448	break;
	7449
	7450	case SC_GOSPEL:
	7451	if(sce->val4 == BCT_SELF && --(sce->val2) > 0)
	7452	{
	7453	int hp, sp;
	7454	hp = (sce->val1 > 5) ? 45 : 30;
	7455	sp = (sce->val1 > 5) ? 35 : 20;
	7456	if(!status_charge(bl, hp, sp))
	7457	break;
	7458	sc_timer_next(10000+tick, status_change_timer, bl->id, data);
	7459	return 0;
	7460	}
	7461	break;
	7462
	7463	case SC_GUILDAURA:
	7464	{
	7465	struct block_list *tbl = map_id2bl(sce->val2);
	7466
	7467	if (tbl && battle_check_range(bl, tbl, 2)){
	7468	sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
	7469	return 0;
	7470	}
	7471	}
	7472	break;
	7473
	7474	case SC_JAILED:
	7475	if(sce->val1 == INT_MAX \|\| --(sce->val1) > 0)
	7476	{
	7477	sc_timer_next(60000+tick, status_change_timer, bl->id,data);
	7478	return 0;
	7479	}
	7480	break;
	7481
	7482	case SC_BLIND:
	7483	if(sc->data[SC_FOGWALL])
	7484	{ //Blind lasts forever while you are standing on the fog.
	7485	sc_timer_next(5000+tick, status_change_timer, bl->id, data);
	7486	return 0;
	7487	}
	7488	break;
	7489	}
	7490
	7491	// default for all non-handled control paths is to end the status
	7492	return status_change_end( bl,type,tid );
	7493	#undef sc_timer_next
	7494	}
	7495
	7496	/*==========================================
	7497	* Xe[^XÙí^C}[ÍÍ
	7498	------------------------------------------/
	7499	int status_change_timer_sub(struct block_list* bl, va_list ap)
	7500	{
	7501	struct map_session_data sd, tsd;
	7502	struct status_change* tsc;
	7503
	7504	struct block_list* src = va_arg(ap,struct block_list*);
	7505	struct status_change_entry* sce = va_arg(ap,struct status_change_entry*);
	7506	enum sc_type type = (sc_type)va_arg(ap,int); //gcc: enum args get promoted to int
	7507	unsigned int tick = va_arg(ap,unsigned int);
	7508
	7509	if (status_isdead(bl))
	7510	return 0;
	7511
	7512	tsc = status_get_sc(bl);
	7513
	7514	sd = BL_CAST(BL_PC, src);
	7515	tsd = BL_CAST(BL_PC, bl);
	7516
	7517	switch( type )
	7518	{
	7519	case SC_SIGHT: /* TCg */
	7520	case SC_CONCENTRATE:
	7521	status_change_end(bl, SC_HIDING, -1);
	7522	status_change_end(bl, SC_CLOAKING, -1);
	7523	break;
	7524	case SC_RUWACH: /* At */
	7525	if (tsc && (tsc->data[SC_HIDING] \|\| tsc->data[SC_CLOAKING])) {
	7526	status_change_end(bl, SC_HIDING, -1);
	7527	status_change_end(bl, SC_CLOAKING, -1);
	7528	if(battle_check_target( src, bl, BCT_ENEMY ) > 0)
	7529	skill_attack(BF_MAGIC,src,src,bl,AL_RUWACH,1,tick,0);
	7530	}
	7531	break;
	7532	case SC_SIGHTBLASTER:
	7533	if (battle_check_target( src, bl, BCT_ENEMY ) > 0 &&
	7534	status_check_skilluse(src, bl, WZ_SIGHTBLASTER, 2))
	7535	{
	7536	skill_attack(BF_MAGIC,src,src,bl,WZ_SIGHTBLASTER,1,tick,0);
	7537	if (sce) sce->val2 = 0; //This signals it to end.
	7538	}
	7539	break;
	7540	case SC_CLOSECONFINE:
	7541	//Lock char has released the hold on everyone...
	7542	if (tsc && tsc->data[SC_CLOSECONFINE2] && tsc->data[SC_CLOSECONFINE2]->val2 == src->id) {
	7543	tsc->data[SC_CLOSECONFINE2]->val2 = 0;
	7544	status_change_end(bl, SC_CLOSECONFINE2, -1);
	7545	}
	7546	break;
	7547	}
	7548	return 0;
	7549	}
	7550
	7551	/*==========================================
	7552	* Clears buffs/debuffs of a character.
	7553	* type&1 -> buffs, type&2 -> debuffs
	7554	------------------------------------------/
	7555	int status_change_clear_buffs (struct block_list* bl, int type)
	7556	{
	7557	int i;
	7558	struct status_change *sc= status_get_sc(bl);
	7559
	7560	if (!sc \|\| !sc->count)
	7561	return 0;
	7562
	7563	if (type&2) //Debuffs
	7564	for( i = SC_COMMON_MIN; i <= SC_COMMON_MAX; i++ )
	7565	{
	7566	if(sc->data[i])
	7567	status_change_end(bl,(sc_type)i,-1);
	7568	}
	7569
	7570	for( i = SC_COMMON_MAX+1; i < SC_MAX; i++ )
	7571	{
	7572	if(!sc->data[i])
	7573	continue;
	7574
	7575	switch (i) {
	7576	//Stuff that cannot be removed
	7577	case SC_WEIGHT50:
	7578	case SC_WEIGHT90:
	7579	case SC_COMBO:
	7580	case SC_SMA:
	7581	case SC_DANCING:
	7582	case SC_GUILDAURA:
	7583	case SC_SAFETYWALL:
	7584	case SC_PNEUMA:
	7585	case SC_NOCHAT:
	7586	case SC_JAILED:
	7587	case SC_ANKLE:
	7588	case SC_BLADESTOP:
	7589	case SC_CP_WEAPON:
	7590	case SC_CP_SHIELD:
	7591	case SC_CP_ARMOR:
	7592	case SC_CP_HELM:
	7593	case SC_STRFOOD:
	7594	case SC_AGIFOOD:
	7595	case SC_VITFOOD:
	7596	case SC_INTFOOD:
	7597	case SC_DEXFOOD:
	7598	case SC_LUKFOOD:
	7599	case SC_HITFOOD:
	7600	case SC_FLEEFOOD:
	7601	case SC_BATKFOOD:
	7602	case SC_WATKFOOD:
	7603	case SC_MATKFOOD:
[10]	7604	//Custom Jobs (blackmagic)
	7605	case SC_DOOM: // Warlock Curse of Doom [Brain]
	7606	//Custom Job End
[1]	7607	continue;
	7608
	7609	//Debuffs that can be removed.
	7610	case SC_HALLUCINATION:
	7611	case SC_QUAGMIRE:
	7612	case SC_SIGNUMCRUCIS:
	7613	case SC_DECREASEAGI:
	7614	case SC_SLOWDOWN:
	7615	case SC_MINDBREAKER:
	7616	case SC_WINKCHARM:
	7617	case SC_STOP:
	7618	case SC_ORCISH:
	7619	case SC_STRIPWEAPON:
	7620	case SC_STRIPSHIELD:
	7621	case SC_STRIPARMOR:
	7622	case SC_STRIPHELM:
	7623	if (!(type&2))
	7624	continue;
	7625	break;
	7626	//The rest are buffs that can be removed.
	7627	case SC_BERSERK:
	7628	if (!(type&1))
	7629	continue;
	7630	sc->data[i]->val2 = 0;
	7631	break;
	7632	default:
	7633	if (!(type&1))
	7634	continue;
	7635	break;
	7636	}
	7637	status_change_end(bl,(sc_type)i,-1);
	7638	}
	7639	return 0;
	7640	}
	7641
	7642	//Natural regen related stuff.
	7643	static unsigned int natural_heal_prev_tick,natural_heal_diff_tick;
	7644	static int status_natural_heal(struct block_list* bl, va_list args)
	7645	{
	7646	struct regen_data *regen;
	7647	struct status_data *status;
	7648	struct status_change *sc;
	7649	struct unit_data *ud;
	7650	struct view_data *vd = NULL;
	7651	struct regen_data_sub *sregen;
	7652	struct map_session_data *sd;
	7653	int val,rate,bonus = 0,flag;
	7654
	7655	if (!(bl->type&BL_REGEN))
	7656	return 0;
	7657
	7658	regen = status_get_regen_data(bl);
	7659	if (!regen) return 0;
	7660	status = status_get_status_data(bl);
	7661	sc = status_get_sc(bl);
	7662	if (sc && !sc->count)
	7663	sc = NULL;
	7664	sd = BL_CAST(BL_PC,bl);
	7665
	7666	flag = regen->flag;
	7667	if (flag&RGN_HP && (status->hp >= status->max_hp \|\| regen->state.block&1))
	7668	flag&=~(RGN_HP\|RGN_SHP);
	7669	if (flag&RGN_SP && (status->sp >= status->max_sp \|\| regen->state.block&2))
	7670	flag&=~(RGN_SP\|RGN_SSP);
	7671
	7672	if (flag && (
	7673	status_isdead(bl) \|\|
	7674	(sc && sc->option&(OPTION_HIDE\|OPTION_CLOAK\|OPTION_CHASEWALK))
	7675	))
	7676	flag=0;
	7677
	7678	if (sd) {
	7679	if (sd->hp_loss.value \|\| sd->sp_loss.value)
	7680	pc_bleeding(sd, natural_heal_diff_tick);
	7681	if (sd->hp_regen.value \|\| sd->sp_regen.value)
	7682	pc_regen(sd, natural_heal_diff_tick);
	7683	}
	7684
	7685	if(flag&(RGN_SHP\|RGN_SSP) && regen->ssregen &&
	7686	(vd = status_get_viewdata(bl)) && vd->dead_sit == 2)
	7687	{ //Apply sitting regen bonus.
	7688	sregen = regen->ssregen;
	7689	if(flag&(RGN_SHP))
	7690	{ //Sitting HP regen
	7691	val = natural_heal_diff_tick * sregen->rate.hp;
	7692	if (regen->state.overweight)
	7693	val>>=1; //Half as fast when overweight.
	7694	sregen->tick.hp += val;
	7695	while(sregen->tick.hp >= (unsigned int)battle_config.natural_heal_skill_interval)
	7696	{
	7697	sregen->tick.hp -= battle_config.natural_heal_skill_interval;
	7698	if(status_heal(bl, sregen->hp, 0, 3) < sregen->hp)
	7699	{ //Full
	7700	flag&=~(RGN_HP\|RGN_SHP);
	7701	break;
	7702	}
	7703	}
	7704	}
	7705	if(flag&(RGN_SSP))
	7706	{ //Sitting SP regen
	7707	val = natural_heal_diff_tick * sregen->rate.sp;
	7708	if (regen->state.overweight)
	7709	val>>=1; //Half as fast when overweight.
	7710	sregen->tick.sp += val;
	7711	while(sregen->tick.sp >= (unsigned int)battle_config.natural_heal_skill_interval)
	7712	{
	7713	sregen->tick.sp -= battle_config.natural_heal_skill_interval;
	7714	if(status_heal(bl, 0, sregen->sp, 3) < sregen->sp)
	7715	{ //Full
	7716	flag&=~(RGN_SP\|RGN_SSP);
	7717	break;
	7718	}
	7719	}
	7720	}
	7721	}
	7722
	7723	if (flag && regen->state.overweight)
	7724	flag=0;
	7725
	7726	ud = unit_bl2ud(bl);
	7727
	7728	if (flag&(RGN_HP\|RGN_SHP\|RGN_SSP) && ud && ud->walktimer != -1)
	7729	{
	7730	flag&=~(RGN_SHP\|RGN_SSP);
	7731	if(!regen->state.walk)
	7732	flag&=~RGN_HP;
	7733	}
	7734
	7735	if (!flag)
	7736	return 0;
	7737
	7738	if (flag&(RGN_HP\|RGN_SP))
	7739	{
	7740	if(!vd) vd = status_get_viewdata(bl);
	7741	if(vd && vd->dead_sit == 2)
	7742	bonus++;
	7743	if(regen->state.gc)
	7744	bonus++;
	7745	}
	7746
	7747	//Natural Hp regen
	7748	if (flag&RGN_HP)
	7749	{
	7750	rate = natural_heal_diff_tick*(regen->rate.hp+bonus);
	7751	if (ud && ud->walktimer != -1)
	7752	rate/=2;
	7753	regen->tick.hp += rate;
	7754
	7755	if(regen->tick.hp >= (unsigned int)battle_config.natural_healhp_interval)
	7756	{
	7757	val = 0;
	7758	do {
	7759	val += regen->hp;
	7760	regen->tick.hp -= battle_config.natural_healhp_interval;
	7761	} while(regen->tick.hp >= (unsigned int)battle_config.natural_healhp_interval);
	7762	if (status_heal(bl, val, 0, 1) < val)
	7763	flag&=~RGN_SHP; //full.
	7764	}
	7765	}
	7766
	7767	//Natural SP regen
	7768	if(flag&RGN_SP)
	7769	{
	7770	regen->tick.sp += natural_heal_diff_tick*(regen->rate.sp+bonus);
	7771
	7772	if(regen->tick.sp >= (unsigned int)battle_config.natural_healsp_interval)
	7773	{
	7774	val = 0;
	7775	do {
	7776	val += regen->sp;
	7777	regen->tick.sp -= battle_config.natural_healsp_interval;
	7778	} while(regen->tick.sp >= (unsigned int)battle_config.natural_healsp_interval);
	7779	if (status_heal(bl, 0, val, 1) < val)
	7780	flag&=~RGN_SSP; //full.
	7781	}
	7782	}
	7783
	7784	if (!regen->sregen)
	7785	return flag;
	7786
	7787	//Skill regen
	7788	sregen = regen->sregen;
	7789
	7790	if(flag&RGN_SHP)
	7791	{ //Skill HP regen
	7792	sregen->tick.hp += natural_heal_diff_tick * sregen->rate.hp;
	7793
	7794	while(sregen->tick.hp >= (unsigned int)battle_config.natural_heal_skill_interval)
	7795	{
	7796	sregen->tick.hp -= battle_config.natural_heal_skill_interval;
	7797	if(status_heal(bl, sregen->hp, 0, 3) < sregen->hp)
	7798	break; //Full
	7799	}
	7800	}
	7801	if(flag&RGN_SSP)
	7802	{ //Skill SP regen
	7803	sregen->tick.sp += natural_heal_diff_tick * sregen->rate.sp;
	7804	while(sregen->tick.sp >= (unsigned int)battle_config.natural_heal_skill_interval)
	7805	{
	7806	val = sregen->sp;
	7807	if (sd && sd->state.doridori) {
	7808	val*=2;
	7809	sd->state.doridori = 0;
	7810	if ((rate = pc_checkskill(sd,TK_SPTIME)))
	7811	sc_start(bl,status_skill2sc(TK_SPTIME),
	7812	100,rate,skill_get_time(TK_SPTIME, rate));
	7813	if (
	7814	(sd->class_&MAPID_UPPERMASK) == MAPID_STAR_GLADIATOR &&
	7815	rand()%10000 < battle_config.sg_angel_skill_ratio
	7816	) { //Angel of the Sun/Moon/Star
	7817	clif_feel_hate_reset(sd);
	7818	pc_resethate(sd);
	7819	pc_resetfeel(sd);
	7820	}
	7821	}
	7822	sregen->tick.sp -= battle_config.natural_heal_skill_interval;
	7823	if(status_heal(bl, 0, val, 3) < val)
	7824	break; //Full
	7825	}
	7826	}
	7827	return flag;
	7828	}
	7829
	7830	//Natural heal main timer.
	7831	static int status_natural_heal_timer(int tid, unsigned int tick, int id, intptr data)
	7832	{
	7833	natural_heal_diff_tick = DIFF_TICK(tick,natural_heal_prev_tick);
	7834	map_foreachiddb(status_natural_heal);
	7835	natural_heal_prev_tick = tick;
	7836	return 0;
	7837	}
	7838
	7839	int status_readdb(void)
	7840	{
	7841	int i,j,class_;
	7842	FILE *fp;
	7843	char line[1024], path[1024],*p;
	7844
	7845	sprintf(path, "%s/job_db1.txt", db_path);
	7846	fp=fopen(path,"r"); // Job-specific values (weight, HP, SP, ASPD)
	7847	if(fp==NULL){
	7848	ShowError("can't read %s\n", path);
	7849	return 1;
	7850	}
	7851	i = 0;
	7852	while(fgets(line, sizeof(line), fp))
	7853	{
	7854	//NOTE: entry MAX_WEAPON_TYPE is not counted
	7855	char* split[5 + MAX_WEAPON_TYPE];
	7856	i++;
	7857	if(line[0]=='/' && line[1]=='/')
	7858	continue;
	7859	for(j=0,p=line; j < 5 + MAX_WEAPON_TYPE && p; j++){
	7860	split[j]=p;
	7861	p=strchr(p,',');
	7862	if(p) *p++=0;
	7863	}
	7864	if(j < 5 + MAX_WEAPON_TYPE)
	7865	{ //Weapon #.MAX_WEAPON_TYPE is constantly not load. Fix to that: replace < with <= [blackhole89]
	7866	ShowDebug("%s: Not enough columns at line %d\n", path, i);
	7867	continue;
	7868	}
	7869	class_ = atoi(split[0]);
	7870	if(!pcdb_checkid(class_))
	7871	continue;
	7872	class_ = pc_class2idx(class_);
	7873	max_weight_base[class_]=atoi(split[1]);
	7874	hp_coefficient[class_]=atoi(split[2]);
	7875	hp_coefficient2[class_]=atoi(split[3]);
	7876	sp_coefficient[class_]=atoi(split[4]);
	7877	for(j=0;j<MAX_WEAPON_TYPE;j++)
	7878	aspd_base[class_][j]=atoi(split[j+5]);
	7879	}
	7880	fclose(fp);
	7881	ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
	7882
	7883	memset(job_bonus,0,sizeof(job_bonus)); // Job-specific stats bonus
	7884	sprintf(path, "%s/job_db2.txt", db_path);
	7885	fp=fopen(path,"r");
	7886	if(fp==NULL){
	7887	ShowError("can't read %s\n", path);
	7888	return 1;
	7889	}
	7890	while(fgets(line, sizeof(line), fp))
	7891	{
	7892	char *split[MAX_LEVEL+1]; //Job Level is limited to MAX_LEVEL, so the bonuses should likewise be limited to it. [Skotlex]
	7893	if(line[0]=='/' && line[1]=='/')
	7894	continue;
	7895	for(j=0,p=line;j<MAX_LEVEL+1 && p;j++){
	7896	split[j]=p;
	7897	p=strchr(p,',');
	7898	if(p) *p++=0;
	7899	}
	7900	class_ = atoi(split[0]);
	7901	if(!pcdb_checkid(class_))
	7902	continue;
	7903	class_ = pc_class2idx(class_);
	7904	for(i=1;i<j && split[i];i++)
	7905	job_bonus[class_][i-1]=atoi(split[i]);
	7906	}
	7907	fclose(fp);
	7908	ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
	7909
	7910	// TCYâ³e?u
	7911	for(i=0;i<3;i++)
	7912	for(j=0;j<MAX_WEAPON_TYPE;j++)
	7913	atkmods[i][j]=100;
	7914	sprintf(path, "%s/size_fix.txt", db_path);
	7915	fp=fopen(path,"r");
	7916	if(fp==NULL){
	7917	ShowError("can't read %s\n", path);
	7918	return 1;
	7919	}
	7920	i=0;
	7921	while(fgets(line, sizeof(line), fp))
	7922	{
	7923	char *split[MAX_WEAPON_TYPE];
	7924	if(line[0]=='/' && line[1]=='/')
	7925	continue;
	7926	if(atoi(line)<=0)
	7927	continue;
	7928	memset(split,0,sizeof(split));
	7929	for(j=0,p=line;j<MAX_WEAPON_TYPE && p;j++){
	7930	split[j]=p;
	7931	p=strchr(p,',');
	7932	if(p) *p++=0;
	7933	atkmods[i][j]=atoi(split[j]);
	7934	}
	7935	i++;
	7936	}
	7937	fclose(fp);
	7938	ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
	7939
	7940	// ž?f?^e?u
	7941	for(i=0;i<5;i++){
	7942	for(j=0;j<MAX_REFINE; j++)
	7943	percentrefinery[i][j]=100;
	7944	percentrefinery[i][j]=0; //Slot MAX+1 always has 0% success chance [Skotlex]
	7945	refinebonus[i][0]=0;
	7946	refinebonus[i][1]=0;
	7947	refinebonus[i][2]=10;
	7948	}
	7949
	7950	sprintf(path, "%s/refine_db.txt", db_path);
	7951	fp=fopen(path,"r");
	7952	if(fp==NULL){
	7953	ShowError("can't read %s\n", path);
	7954	return 1;
	7955	}
	7956	i=0;
	7957	while(fgets(line, sizeof(line), fp))
	7958	{
	7959	char *split[MAX_REFINE+4];
	7960	if(line[0]=='/' && line[1]=='/')
	7961	continue;
	7962	if(atoi(line)<=0)
	7963	continue;
	7964	memset(split,0,sizeof(split));
	7965	for(j=0,p=line;j<MAX_REFINE+4 && p;j++){
	7966	split[j]=p;
	7967	p=strchr(p,',');
	7968	if(p) *p++=0;
	7969	}
	7970	refinebonus[i][0]=atoi(split[0]); // ž?{?iX
	7971	refinebonus[i][1]=atoi(split[1]); // ß?ž?{?iX
	7972	refinebonus[i][2]=atoi(split[2]); // ÀSž?ÀE
	7973	for(j=0;j<MAX_REFINE && split[j+3];j++)
	7974	percentrefinery[i][j]=atoi(split[j+3]);
	7975	i++;
	7976	}
	7977	fclose(fp); //Lupus. close this file!!!
	7978	ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
	7979
	7980	return 0;
	7981	}
	7982
	7983	/*==========================================
	7984	* XLÖWú»
	7985	------------------------------------------/
	7986	int do_init_status(void)
	7987	{
	7988	add_timer_func_list(status_change_timer,"status_change_timer");
	7989	add_timer_func_list(kaahi_heal_timer,"kaahi_heal_timer");
	7990	add_timer_func_list(status_natural_heal_timer,"status_natural_heal_timer");
	7991	initChangeTables();
	7992	initDummyData();
	7993	status_readdb();
	7994	status_calc_sigma();
	7995	natural_heal_prev_tick = gettick();
	7996	sc_data_ers = ers_new(sizeof(struct status_change_entry));
	7997	add_timer_interval(natural_heal_prev_tick + NATURAL_HEAL_INTERVAL, status_natural_heal_timer, 0, 0, NATURAL_HEAL_INTERVAL);
	7998	return 0;
	7999	}
	8000	void do_final_status(void)
	8001	{
	8002	ers_destroy(sc_data_ers);
	8003	}

Note: See TracBrowser for help on using the browser.

Context Navigation

root/src/map/status.c @ 13

Download in other formats: