Context Navigation

status.c @ 23

Revision 22, 247.0 kB (checked in by jinshiro, 17 years ago)

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

Note: See TracBrowser for help on using the browser.

Context Navigation

root/src/map/status.c @ 23

Download in other formats: