Context Navigation

status.c @ 6

Revision 1, 232.2 kB (checked in by jinshiro, 17 years ago)

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

Note: See TracBrowser for help on using the browser.

Context Navigation

root/src/map/status.c @ 6

Download in other formats: