Context Navigation

status.c @ 25

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

Note: See TracBrowser for help on using the browser.

Context Navigation

root/src/map/status.c @ 25

Download in other formats: