PageRenderTime 105ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 1ms

/src/map/pc.c

https://gitlab.com/evol/evol-server-code-old
C | 9663 lines | 7776 code | 1063 blank | 824 comment | 2852 complexity | 32a4509e89109e4b9776d128ed008b02 MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. // $Id: pc.c 101 2004-09-25 17:57:22Z Valaris $
    2. 

  2. #include <stdio.h>
    3. 

  3. #include <stdlib.h>
    4. 

  4. #include <string.h>
    5. 

  5. #include <ctype.h>
    6. 

  6. #include <time.h>
    7. 

  7. 

  8. #include "socket.h"             // [Valaris]
    9. 

  9. #include "timer.h"
    10. 

  10. #include "db.h"
    11. 

  11. 

  12. #include "malloc.h"
    13. 

  13. #include "nullpo.h"
    14. 

  14. 

  15. #include "strlib.h"
    16. 

  16. #include "atcommand.h"
    17. 

  17. #include "battle.h"
    18. 

  18. #include "chat.h"
    19. 

  19. #include "chrif.h"
    20. 

  20. #include "clif.h"
    21. 

  21. #include "guild.h"
    22. 

  22. #include "intif.h"
    23. 

  23. #include "itemdb.h"
    24. 

  24. #include "map.h"
    25. 

  25. #include "mob.h"
    26. 

  26. #include "npc.h"
    27. 

  27. #include "party.h"
    28. 

  28. #include "pc.h"
    29. 

  29. #include "script.h"
    30. 

  30. #include "skill.h"
    31. 

  31. #include "storage.h"
    32. 

  32. #include "trade.h"
    33. 

  33. 

  34. #ifdef MEMWATCH
    35. 

  35. #include "memwatch.h"
    36. 

  36. #endif
    37. 

  37. 

  38. #define PVP_CALCRANK_INTERVAL 1000    // PVP順位計算の間隔 
    39. 

  39. 

  40. //define it here, since the ifdef only occurs in this file
    41. 

  41. #define USE_ASTRAL_SOUL_SKILL
    42. 

  42. 

  43. #define STATE_BLIND 0x10
    44. 

  44. 

  45. #ifdef USE_ASTRAL_SOUL_SKILL
    46. 

  46. #define MAGIC_SKILL_THRESHOLD 200   // [fate] At this threshold, the Astral Soul skill kicks in
    47. 

  47. #endif
    48. 

  48. 

  49. #define MAP_LOG_STATS(sd, suffix)	\
    50. 

  50.         MAP_LOG_PC(sd, "STAT %d %d %d %d %d %d " suffix,            \
    51. 

  51.                    sd->status.str, sd->status.agi, sd->status.vit, sd->status.int_, sd->status.dex, sd->status.luk)
    52. 

  52. 

  53. #define MAP_LOG_XP(sd, suffix)	\
    54. 

  54.         MAP_LOG_PC(sd, "XP %d %d JOB %d %d %d ZENY %d + %d " suffix,		\
    55. 

  55.                    sd->status.base_level, sd->status.base_exp, sd->status.job_level, sd->status.job_exp, sd->status.skill_point,  sd->status.zeny, pc_readaccountreg(sd, "BankAccount"))
    56. 

  56. 

  57. #define MAP_LOG_MAGIC(sd, suffix)	\
    58. 

  58.         MAP_LOG_PC(sd, "MAGIC %d %d %d %d %d %d EXP %d %d " suffix,	\
    59. 

  59.                    sd->status.skill[TMW_MAGIC].lv,                      \
    60. 

  60.                    sd->status.skill[TMW_MAGIC_LIFE].lv,			\
    61. 

  61.                    sd->status.skill[TMW_MAGIC_WAR].lv,			\
    62. 

  62.                    sd->status.skill[TMW_MAGIC_TRANSMUTE].lv,		\
    63. 

  63.                    sd->status.skill[TMW_MAGIC_NATURE].lv,               \
    64. 

  64.                    sd->status.skill[TMW_MAGIC_ETHER].lv,                \
    65. 

  65.                    pc_readglobalreg(sd, "MAGIC_EXPERIENCE") & 0xffff,	\
    66. 

  66.                    (pc_readglobalreg(sd, "MAGIC_EXPERIENCE") >> 24) & 0xff)
    67. 

  67. 

  68. static int max_weight_base[MAX_PC_CLASS];
    69. 

  69. static int hp_coefficient[MAX_PC_CLASS];
    70. 

  70. static int hp_coefficient2[MAX_PC_CLASS];
    71. 

  71. static int hp_sigma_val[MAX_PC_CLASS][MAX_LEVEL];
    72. 

  72. static int sp_coefficient[MAX_PC_CLASS];
    73. 

  73. static int aspd_base[MAX_PC_CLASS][20];
    74. 

  74. static char job_bonus[3][MAX_PC_CLASS][MAX_LEVEL];
    75. 

  75. static int exp_table[14][MAX_LEVEL];
    76. 

  76. static char statp[255][7];
    77. 

  77. static struct
    78. 

  78. {
    79. 

  79.     int  id;
    80. 

  80.     int  max;
    81. 

  81.     struct
    82. 

  82.     {
    83. 

  83.         short id, lv;
    84. 

  84.     } need[6];
    85. 

  85. } skill_tree[3][MAX_PC_CLASS][100];
    86. 

  86. 

  87. static int atkmods[3][20];          // 武器ATKサイズ修正(size_fix.txt) 
    88. 

  88. static int refinebonus[5][3];       // 精?ボ?ナステ?ブル(refine_db.txt) 
    89. 

  89. static int percentrefinery[5][10];  // 精?成功率(refine_db.txt) 
    90. 

  90. 

  91. static int dirx[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
    92. 

  92. static int diry[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
    93. 

  93. 

  94. static unsigned int equip_pos[MAX_EQUIP_SIZE] =
    95. 

  95.     { 0x0080, 0x0008, 0x0040, 0x0004, 0x0001, 0x0200, 0x0100, 0x0010, 0x0020,
    96. 

  96.     0x0002, 0x8000, 0x0400, 0x0800
    97. 

  97. };
    98. 

  98. 

  99. int pc_attack_timer (int tid, unsigned int tick, int id, int data);
    100. 

  100. 

  101. //static struct dbt *gm_account_db;
    102. 

  102. static struct gm_account *gm_account = NULL;
    103. 

  103. static int GM_num = 0;
    104. 

  104. 

  105. const int MAX_PLAYER_CLASS = 8;
    106. 

  106. 

  107. int pc_isGM (struct map_session_data *sd)
    108. 

  108. {
    109. 

  109. //  struct gm_account *p;
    110. 

  110.     int  i;
    111. 

  111. 

  112.     nullpo_retr (0, sd);
    113. 

  113. 

  114. /*	p = numdb_search(gm_account_db, sd->status.account_id);
    115. 

  115. 	if (p == NULL)
    116. 

  116. 		return 0;
    117. 

  117. 	return p->level;*/
    118. 

  118. 

  119.     for (i = 0; i < GM_num; i++)
    120. 

  120.         if (gm_account[i].account_id == sd->status.account_id)
    121. 

  121.             return gm_account[i].level;
    122. 

  122.     return 0;
    123. 

  123. 

  124. }
    125. 

  125. 

  126. int pc_iskiller (struct map_session_data *src,
    127. 

  127.                  struct map_session_data *target)
    128. 

  128. {
    129. 

  129.     nullpo_retr (0, src);
    130. 

  130. 

  131.     if (src->bl.type != BL_PC)
    132. 

  132.         return 0;
    133. 

  133.     if (src->special_state.killer)
    134. 

  134.         return 1;
    135. 

  135. 

  136.     nullpo_retr (0, target);
    137. 

  137. 

  138.     if (target->bl.type != BL_PC)
    139. 

  139.         return 0;
    140. 

  140.     if (target->special_state.killable)
    141. 

  141.         return 1;
    142. 

  142. 

  143.     return 0;
    144. 

  144. }
    145. 

  145. 

  146. int pc_set_gm_level (int account_id, int level)
    147. 

  147. {
    148. 

  148.     int  i;
    149. 

  149.     for (i = 0; i < GM_num; i++)
    150. 

  150.     {
    151. 

  151.         if (account_id == gm_account[i].account_id)
    152. 

  152.         {
    153. 

  153.             gm_account[i].level = level;
    154. 

  154.             return 0;
    155. 

  155.         }
    156. 

  156.     }
    157. 

  157. 

  158.     GM_num++;
    159. 

  159.     gm_account = realloc (gm_account, sizeof (struct gm_account) * GM_num);
    160. 

  160.     if (!gm_account)
    161. 

  161.     {
    162. 

  162.         printf("out of memory pc_set_gm_level\n");
    163. 

  163.         exit(1);
    164. 

  164.     }
    165. 

  165.     gm_account[GM_num - 1].account_id = account_id;
    166. 

  166.     gm_account[GM_num - 1].level = level;
    167. 

  167.     return 0;
    168. 

  168. }
    169. 

  169. 

  170. int pc_getrefinebonus (int lv, int type)
    171. 

  171. {
    172. 

  172.     if (lv >= 0 && lv < 5 && type >= 0 && type < 3)
    173. 

  173.         return refinebonus[lv][type];
    174. 

  174.     return 0;
    175. 

  175. }
    176. 

  176. 

  177. static int distance (int x0, int y0, int x1, int y1)
    178. 

  178. {
    179. 

  179.     int  dx, dy;
    180. 

  180. 

  181.     dx = abs (x0 - x1);
    182. 

  182.     dy = abs (y0 - y1);
    183. 

  183.     return dx > dy ? dx : dy;
    184. 

  184. }
    185. 

  185. 

  186. static int pc_invincible_timer (int tid, unsigned int tick __attribute__ ((unused)),
    187. 

  187.                                 int id, int data __attribute__ ((unused)))
    188. 

  188. {
    189. 

  189.     struct map_session_data *sd;
    190. 

  190. 

  191.     if ((sd = (struct map_session_data *) map_id2sd (id)) == NULL
    192. 

  192.         || sd->bl.type != BL_PC)
    193. 

  193.         return 1;
    194. 

  194. 

  195.     if (sd->invincible_timer != tid)
    196. 

  196.     {
    197. 

  197.         if (battle_config.error_log)
    198. 

  198.             printf ("invincible_timer %d != %d\n", sd->invincible_timer, tid);
    199. 

  199.         return 0;
    200. 

  200.     }
    201. 

  201.     sd->invincible_timer = -1;
    202. 

  202. 

  203.     return 0;
    204. 

  204. }
    205. 

  205. 

  206. int pc_setinvincibletimer (struct map_session_data *sd, int val)
    207. 

  207. {
    208. 

  208.     nullpo_retr (0, sd);
    209. 

  209. 

  210.     if (sd->invincible_timer != -1)
    211. 

  211.         delete_timer (sd->invincible_timer, pc_invincible_timer);
    212. 

  212.     sd->invincible_timer =
    213. 

  213.         add_timer (gettick () + val, pc_invincible_timer, sd->bl.id, 0);
    214. 

  214.     return 0;
    215. 

  215. }
    216. 

  216. 

  217. int pc_delinvincibletimer (struct map_session_data *sd)
    218. 

  218. {
    219. 

  219.     nullpo_retr (0, sd);
    220. 

  220. 

  221.     if (sd->invincible_timer != -1)
    222. 

  222.     {
    223. 

  223.         delete_timer (sd->invincible_timer, pc_invincible_timer);
    224. 

  224.         sd->invincible_timer = -1;
    225. 

  225.     }
    226. 

  226.     return 0;
    227. 

  227. }
    228. 

  228. 

  229. int pc_delattacktimer (struct map_session_data *sd)
    230. 

  230. {
    231. 

  231.     nullpo_retr (0, sd);
    232. 

  232. 

  233.     if (sd->attacktimer != -1)
    234. 

  234.     {
    235. 

  235.         delete_timer (sd->attacktimer, pc_attack_timer);
    236. 

  236.         sd->attacktimer = -1;
    237. 

  237.     }
    238. 

  238. 

  239.     return 0;
    240. 

  240. }
    241. 

  241. 

  242. static int pc_spiritball_timer (int tid, unsigned int tick __attribute__ ((unused)),
    243. 

  243.                                 int id, int data __attribute__ ((unused)))
    244. 

  244. {
    245. 

  245.     struct map_session_data *sd;
    246. 

  246.     int  i;
    247. 

  247. 

  248.     if ((sd = (struct map_session_data *) map_id2sd (id)) == NULL
    249. 

  249.         || sd->bl.type != BL_PC)
    250. 

  250.         return 1;
    251. 

  251. 

  252.     if (sd->spirit_timer[0] != tid)
    253. 

  253.     {
    254. 

  254.         if (battle_config.error_log)
    255. 

  255.             printf ("spirit_timer %d != %d\n", sd->spirit_timer[0], tid);
    256. 

  256.         return 0;
    257. 

  257.     }
    258. 

  258.     sd->spirit_timer[0] = -1;
    259. 

  259.     for (i = 1; i < sd->spiritball && i < MAX_SKILL_LEVEL; i++)
    260. 

  260.     {
    261. 

  261.         sd->spirit_timer[i - 1] = sd->spirit_timer[i];
    262. 

  262.         sd->spirit_timer[i] = -1;
    263. 

  263.     }
    264. 

  264.     sd->spiritball--;
    265. 

  265.     if (sd->spiritball < 0)
    266. 

  266.         sd->spiritball = 0;
    267. 

  267.     clif_spiritball (sd);
    268. 

  268. 

  269.     return 0;
    270. 

  270. }
    271. 

  271. 

  272. int pc_addspiritball (struct map_session_data *sd, int interval, int max)
    273. 

  273. {
    274. 

  274.     nullpo_retr (0, sd);
    275. 

  275. 

  276.     if (max > MAX_SKILL_LEVEL)
    277. 

  277.         max = MAX_SKILL_LEVEL;
    278. 

  278.     if (sd->spiritball < 0)
    279. 

  279.         sd->spiritball = 0;
    280. 

  280. 

  281.     if (sd->spiritball >= max)
    282. 

  282.     {
    283. 

  283.         int  i;
    284. 

  284. 

  285.         if (sd->spirit_timer[0] != -1)
    286. 

  286.         {
    287. 

  287.             delete_timer (sd->spirit_timer[0], pc_spiritball_timer);
    288. 

  288.             sd->spirit_timer[0] = -1;
    289. 

  289.         }
    290. 

  290.         for (i = 1; i < max; i++)
    291. 

  291.         {
    292. 

  292.             sd->spirit_timer[i - 1] = sd->spirit_timer[i];
    293. 

  293.             sd->spirit_timer[i] = -1;
    294. 

  294.         }
    295. 

  295.     }
    296. 

  296.     else
    297. 

  297.         sd->spiritball++;
    298. 

  298. 

  299.     if (sd->spiritball >= 1 && sd->spiritball <= MAX_SKILL_LEVEL)
    300. 

  300.     {
    301. 

  301.         sd->spirit_timer[sd->spiritball - 1] =
    302. 

  302.             add_timer (gettick () + interval, pc_spiritball_timer, sd->bl.id, 0);
    303. 

  303.         clif_spiritball (sd);
    304. 

  304.     }
    305. 

  305. 

  306.     return 0;
    307. 

  307. }
    308. 

  308. 

  309. int pc_delspiritball (struct map_session_data *sd, int count, int type)
    310. 

  310. {
    311. 

  311.     int  i;
    312. 

  312. 

  313.     nullpo_retr (0, sd);
    314. 

  314. 

  315.     if (sd->spiritball <= 0)
    316. 

  316.     {
    317. 

  317.         sd->spiritball = 0;
    318. 

  318.         return 0;
    319. 

  319.     }
    320. 

  320. 

  321.     if (count > sd->spiritball)
    322. 

  322.         count = sd->spiritball;
    323. 

  323.     sd->spiritball -= count;
    324. 

  324.     if (count > MAX_SKILL_LEVEL)
    325. 

  325.         count = MAX_SKILL_LEVEL;
    326. 

  326. 

  327.     for (i = 0; i < count; i++)
    328. 

  328.     {
    329. 

  329.         if (sd->spirit_timer[i] != -1)
    330. 

  330.         {
    331. 

  331.             delete_timer (sd->spirit_timer[i], pc_spiritball_timer);
    332. 

  332.             sd->spirit_timer[i] = -1;
    333. 

  333.         }
    334. 

  334.     }
    335. 

  335.     for (i = count; i < MAX_SKILL_LEVEL; i++)
    336. 

  336.     {
    337. 

  337.         sd->spirit_timer[i - count] = sd->spirit_timer[i];
    338. 

  338.         sd->spirit_timer[i] = -1;
    339. 

  339.     }
    340. 

  340. 

  341.     if (!type)
    342. 

  342.         clif_spiritball (sd);
    343. 

  343. 

  344.     return 0;
    345. 

  345. }
    346. 

  346. 

  347. int pc_setrestartvalue (struct map_session_data *sd, int type)
    348. 

  348. {
    349. 

  349.     //?生や養子の場合の元の職業を算出する 
    350. 

  350.     struct pc_base_job s_class;
    351. 

  351. 

  352.     nullpo_retr (0, sd);
    353. 

  353. 

  354.     s_class = pc_calc_base_job (sd->status.class);
    355. 

  355. 

  356.     //-----------------------
    357. 

  357.     // 死亡した 
    358. 

  358.     if (sd->special_state.restart_full_recover)
    359. 

  359.      {                           // オシリスカ?ド 
    360. 

  360.         sd->status.hp = sd->status.max_hp;
    361. 

  361.         sd->status.sp = sd->status.max_sp;
    362. 

  362.     }
    363. 

  363.     else
    364. 

  364.     {
    365. 

  365.         if (s_class.job <= 5 && battle_config.restart_hp_rate == 0)
    366. 

  366.           {                        //ノビは半分回復 
    367. 

  367.             sd->status.hp = (sd->status.max_hp) / 2;
    368. 

  368.         }
    369. 

  369.         else
    370. 

  370.         {
    371. 

  371.             if (battle_config.restart_hp_rate <= 0)
    372. 

  372.                 sd->status.hp = 1;
    373. 

  373.             else
    374. 

  374.             {
    375. 

  375.                 sd->status.hp =
    376. 

  376.                     sd->status.max_hp * battle_config.restart_hp_rate / 100;
    377. 

  377.                 if (sd->status.hp <= 0)
    378. 

  378.                     sd->status.hp = 1;
    379. 

  379.             }
    380. 

  380.         }
    381. 

  381.         if (battle_config.restart_sp_rate > 0)
    382. 

  382.         {
    383. 

  383.             int  sp = sd->status.max_sp * battle_config.restart_sp_rate / 100;
    384. 

  384.             if (sd->status.sp < sp)
    385. 

  385.                 sd->status.sp = sp;
    386. 

  386.         }
    387. 

  387.     }
    388. 

  388.     if (type & 1)
    389. 

  389.         clif_updatestatus (sd, SP_HP);
    390. 

  390.     if (type & 1)
    391. 

  391.         clif_updatestatus (sd, SP_SP);
    392. 

  392. 

  393.     /* removed exp penalty on spawn [Valaris] */
    394. 

  394. 

  395.     if (type & 2 && sd->status.class > MAX_PLAYER_CLASS && battle_config.zeny_penalty > 0
    396. 

  396.         && !map[sd->bl.m].flag.nozenypenalty)
    397. 

  397.     {
    398. 

  398.         int  zeny =
    399. 

  399.             (int) ((double) sd->status.zeny *
    400. 

  400.                    (double) battle_config.zeny_penalty / 10000.);
    401. 

  401.         if (zeny < 1)
    402. 

  402.             zeny = 1;
    403. 

  403.         sd->status.zeny -= zeny;
    404. 

  404.         if (sd->status.zeny < 0)
    405. 

  405.             sd->status.zeny = 0;
    406. 

  406.         clif_updatestatus (sd, SP_ZENY);
    407. 

  407.     }
    408. 

  408.     sd->heal_xp = 0;            // [Fate] Set gainable xp for healing this player to 0
    409. 

  409. 

  410.     return 0;
    411. 

  411. }
    412. 

  412. 

  413. /*==========================================
    414. 

  414.  * 自分をロックしているMOBの?を?える(foreachclient) 
    415. 

  415.  *------------------------------------------
    416. 

  416.  */
    417. 

  417. static int pc_counttargeted_sub (struct block_list *bl, va_list ap)
    418. 

  418. {
    419. 

  419.     int  id, *c, target_lv;
    420. 

  420.     struct block_list *src;
    421. 

  421. 

  422.     nullpo_retr (0, bl);
    423. 

  423.     nullpo_retr (0, ap);
    424. 

  424. 

  425.     id = va_arg (ap, int);
    426. 

  426. 

  427.     nullpo_retr (0, c = va_arg (ap, int *));
    428. 

  428. 

  429.     src = va_arg (ap, struct block_list *);
    430. 

  430. 

  431.     target_lv = va_arg (ap, int);
    432. 

  432.     if (id == bl->id || (src && id == src->id))
    433. 

  433.         return 0;
    434. 

  434.     if (bl->type == BL_PC)
    435. 

  435.     {
    436. 

  436.         struct map_session_data *sd = (struct map_session_data *) bl;
    437. 

  437.         if (sd && sd->attacktarget == id && sd->attacktimer != -1
    438. 

  438.             && sd->attacktarget_lv >= target_lv)
    439. 

  439.             (*c)++;
    440. 

  440.     }
    441. 

  441.     else if (bl->type == BL_MOB)
    442. 

  442.     {
    443. 

  443.         struct mob_data *md = (struct mob_data *) bl;
    444. 

  444.         if (md && md->target_id == id && md->timer != -1
    445. 

  445.             && md->state.state == MS_ATTACK && md->target_lv >= target_lv)
    446. 

  446. 

  447.             (*c)++;
    448. 

  448.         //printf("md->target_lv:%d, target_lv:%d\n",((struct mob_data *)bl)->target_lv,target_lv);
    449. 

  449.     }
    450. 

  450.     return 0;
    451. 

  451. }
    452. 

  452. 

  453. int pc_counttargeted (struct map_session_data *sd, struct block_list *src,
    454. 

  454.                       int target_lv)
    455. 

  455. {
    456. 

  456.     int  c = 0;
    457. 

  457.     nullpo_retr (0, sd);
    458. 

  458. 

  459.     map_foreachinarea (pc_counttargeted_sub, sd->bl.m,
    460. 

  460.                        sd->bl.x - AREA_SIZE, sd->bl.y - AREA_SIZE,
    461. 

  461.                        sd->bl.x + AREA_SIZE, sd->bl.y + AREA_SIZE, 0,
    462. 

  462.                        sd->bl.id, &c, src, target_lv);
    463. 

  463.     return c;
    464. 

  464. }
    465. 

  465. 

  466. /*==========================================
    467. 

  467.  * ロ?カルプロトタイプ宣言 (必要な物のみ) 
    468. 

  468.  *------------------------------------------
    469. 

  469.  */
    470. 

  470. static int pc_walktoxy_sub (struct map_session_data *);
    471. 

  471. 

  472. /*==========================================
    473. 

  473.  * saveに必要なステ?タス修正を行なう 
    474. 

  474.  *------------------------------------------
    475. 

  475.  */
    476. 

  476. int pc_makesavestatus (struct map_session_data *sd)
    477. 

  477. {
    478. 

  478.     nullpo_retr (0, sd);
    479. 

  479. 

  480.     // 服の色は色?弊害が多いので保存?象にはしない 
    481. 

  481.     if (!battle_config.save_clothcolor)
    482. 

  482.         sd->status.clothes_color = 0;
    483. 

  483. 

  484.     // 死亡?態だったのでhpを1、位置をセ?ブ場所に?更 
    485. 

  485.     if (pc_isdead (sd))
    486. 

  486.     {
    487. 

  487.         pc_setrestartvalue (sd, 0);
    488. 

  488.         memcpy (&sd->status.last_point, &sd->status.save_point,
    489. 

  489.                 sizeof (sd->status.last_point));
    490. 

  490.     }
    491. 

  491.     else
    492. 

  492.     {
    493. 

  493.         memcpy (sd->status.last_point.map, sd->mapname, 24);
    494. 

  494.         sd->status.last_point.x = sd->bl.x;
    495. 

  495.         sd->status.last_point.y = sd->bl.y;
    496. 

  496.     }
    497. 

  497. 

  498.     // セ?ブ禁止マップだったので指定位置に移動 
    499. 

  499.     if (map[sd->bl.m].flag.nosave)
    500. 

  500.     {
    501. 

  501.         struct map_data *m = &map[sd->bl.m];
    502. 

  502.         if (strcmp (m->save.map, "SavePoint") == 0)
    503. 

  503.             memcpy (&sd->status.last_point, &sd->status.save_point,
    504. 

  504.                     sizeof (sd->status.last_point));
    505. 

  505.         else
    506. 

  506.             memcpy (&sd->status.last_point, &m->save,
    507. 

  507.                     sizeof (sd->status.last_point));
    508. 

  508.     }
    509. 

  509. 

  510.     //マナ?ポイントがプラスだった場合0に 
    511. 

  511.     if (battle_config.muting_players && sd->status.manner > 0)
    512. 

  512.         sd->status.manner = 0;
    513. 

  513.     return 0;
    514. 

  514. }
    515. 

  515. 

  516. /*==========================================
    517. 

  517.  * 接?時の初期化 
    518. 

  518.  *------------------------------------------
    519. 

  519.  */
    520. 

  520. int pc_setnewpc (struct map_session_data *sd, int account_id, int char_id,
    521. 

  521.                  int login_id1, int client_tick, int sex,
    522. 

  522.                  int fd __attribute__ ((unused)))
    523. 

  523. {
    524. 

  524.     nullpo_retr (0, sd);
    525. 

  525. 

  526.     sd->bl.id = account_id;
    527. 

  527.     sd->char_id = char_id;
    528. 

  528.     sd->login_id1 = login_id1;
    529. 

  529.     sd->login_id2 = 0;          // at this point, we can not know the value :(
    530. 

  530.     sd->client_tick = client_tick;
    531. 

  531.     sd->sex = sex;
    532. 

  532.     sd->state.auth = 0;
    533. 

  533.     sd->bl.type = BL_PC;
    534. 

  534.     sd->canact_tick = sd->canmove_tick = gettick ();
    535. 

  535.     sd->canlog_tick = gettick ();
    536. 

  536.     sd->state.waitingdisconnect = 0;
    537. 

  537. 

  538.     return 0;
    539. 

  539. }
    540. 

  540. 

  541. int pc_equippoint (struct map_session_data *sd, int n)
    542. 

  542. {
    543. 

  543.     int  ep = 0;
    544. 

  544.     //?生や養子の場合の元の職業を算出する 
    545. 

  545.     struct pc_base_job s_class;
    546. 

  546. 

  547.     nullpo_retr (0, sd);
    548. 

  548. 

  549.     if (n < 0 || n >= MAX_INVENTORY || !sd->inventory_data[n])
    550. 

  550.         return 0;
    551. 

  551. 

  552.     s_class = pc_calc_base_job (sd->status.class);
    553. 

  553. 

  554.     ep = sd->inventory_data[n]->equip;
    555. 

  555.     if ((sd->inventory_data[n]->look == 1 || sd->inventory_data[n]->look == 2
    556. 

  556.          || sd->inventory_data[n]->look == 6) && (ep == 2
    557. 

  557.                                                   &&
    558. 

  558.                                                   (pc_checkskill (sd, AS_LEFT)
    559. 

  559.                                                    > 0 || s_class.job == 12)))
    560. 

  560.     {
    561. 

  561.         return 34;
    562. 

  562.     }
    563. 

  563. 

  564.     return ep;
    565. 

  565. }
    566. 

  566. 

  567. int pc_setinventorydata (struct map_session_data *sd)
    568. 

  568. {
    569. 

  569.     int  i, id;
    570. 

  570. 

  571.     nullpo_retr (0, sd);
    572. 

  572. 

  573.     for (i = 0; i < MAX_INVENTORY; i++)
    574. 

  574.     {
    575. 

  575.         id = sd->status.inventory[i].nameid;
    576. 

  576.         sd->inventory_data[i] = itemdb_search (id);
    577. 

  577.     }
    578. 

  578.     return 0;
    579. 

  579. }
    580. 

  580. 

  581. int pc_calcweapontype (struct map_session_data *sd)
    582. 

  582. {
    583. 

  583.     nullpo_retr (0, sd);
    584. 

  584. 

  585.     if (sd->weapontype1 != 0 && sd->weapontype2 == 0)
    586. 

  586.         sd->status.weapon = sd->weapontype1;
    587. 

  587.     if (sd->weapontype1 == 0 && sd->weapontype2 != 0)   // 左手武器 Only
    588. 

  588.         sd->status.weapon = sd->weapontype2;
    589. 

  589.     else if (sd->weapontype1 == 1 && sd->weapontype2 == 1)  // 双短剣 
    590. 

  590.         sd->status.weapon = 0x11;
    591. 

  591.     else if (sd->weapontype1 == 2 && sd->weapontype2 == 2)  // 双単手剣 
    592. 

  592.         sd->status.weapon = 0x12;
    593. 

  593.     else if (sd->weapontype1 == 6 && sd->weapontype2 == 6)  // 双単手斧 
    594. 

  594.         sd->status.weapon = 0x13;
    595. 

  595.     else if ((sd->weapontype1 == 1 && sd->weapontype2 == 2) || (sd->weapontype1 == 2 && sd->weapontype2 == 1))  // 短剣 - 単手剣 
    596. 

  596.         sd->status.weapon = 0x14;
    597. 

  597.     else if ((sd->weapontype1 == 1 && sd->weapontype2 == 6) || (sd->weapontype1 == 6 && sd->weapontype2 == 1))  // 短剣 - 斧 
    598. 

  598.         sd->status.weapon = 0x15;
    599. 

  599.     else if ((sd->weapontype1 == 2 && sd->weapontype2 == 6) || (sd->weapontype1 == 6 && sd->weapontype2 == 2))  // 単手剣 - 斧 
    600. 

  600.         sd->status.weapon = 0x16;
    601. 

  601.     else
    602. 

  602.         sd->status.weapon = sd->weapontype1;
    603. 

  603. 

  604.     return 0;
    605. 

  605. }
    606. 

  606. 

  607. int pc_setequipindex (struct map_session_data *sd)
    608. 

  608. {
    609. 

  609.     int  i, j;
    610. 

  610. 

  611.     nullpo_retr (0, sd);
    612. 

  612. 

  613.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    614. 

  614.         sd->equip_index[i] = -1;
    615. 

  615. 

  616.     for (i = 0; i < MAX_INVENTORY; i++)
    617. 

  617.     {
    618. 

  618.         if (sd->status.inventory[i].nameid <= 0)
    619. 

  619.             continue;
    620. 

  620.         if (sd->status.inventory[i].equip)
    621. 

  621.         {
    622. 

  622.             for (j = 0; j < MAX_EQUIP_SIZE; j++)
    623. 

  623.                 if (sd->status.inventory[i].equip & equip_pos[j])
    624. 

  624.                     sd->equip_index[j] = i;
    625. 

  625.             if (sd->status.inventory[i].equip & 0x0002)
    626. 

  626.             {
    627. 

  627.                 if (sd->inventory_data[i])
    628. 

  628.                     sd->weapontype1 = sd->inventory_data[i]->look;
    629. 

  629.                 else
    630. 

  630.                     sd->weapontype1 = 0;
    631. 

  631.             }
    632. 

  632.             if (sd->status.inventory[i].equip & 0x0020)
    633. 

  633.             {
    634. 

  634.                 if (sd->inventory_data[i])
    635. 

  635.                 {
    636. 

  636.                     if (sd->inventory_data[i]->type == 4)
    637. 

  637.                     {
    638. 

  638.                         if (sd->status.inventory[i].equip == 0x0020)
    639. 

  639.                             sd->weapontype2 = sd->inventory_data[i]->look;
    640. 

  640.                         else
    641. 

  641.                             sd->weapontype2 = 0;
    642. 

  642.                     }
    643. 

  643.                     else
    644. 

  644.                         sd->weapontype2 = 0;
    645. 

  645.                 }
    646. 

  646.                 else
    647. 

  647.                     sd->weapontype2 = 0;
    648. 

  648.             }
    649. 

  649.         }
    650. 

  650.     }
    651. 

  651.     pc_calcweapontype (sd);
    652. 

  652. 

  653.     return 0;
    654. 

  654. }
    655. 

  655. 

  656. int pc_isequip (struct map_session_data *sd, int n)
    657. 

  657. {
    658. 

  658.     struct item_data *item;
    659. 

  659.     struct status_change *sc_data;
    660. 

  660.     //転生や養子の場合の元の職業を算出する 
    661. 

  661. 

  662.     nullpo_retr (0, sd);
    663. 

  663. 

  664.     if (n < 0 || n >= MAX_INVENTORY)
    665. 

  665.         return 0;
    666. 

  666. 

  667.     item = sd->inventory_data[n];
    668. 

  668.     sc_data = battle_get_sc_data (&sd->bl);
    669. 

  669.     //s_class = pc_calc_base_job(sd->status.class);
    670. 

  670. 

  671.     if (battle_config.gm_allequip > 0
    672. 

  672.         && pc_isGM (sd) >= battle_config.gm_allequip)
    673. 

  673.         return 1;
    674. 

  674. 

  675.     if (item == NULL)
    676. 

  676.         return 0;
    677. 

  677.     if (item->sex != 2 && sd->status.sex != item->sex)
    678. 

  678.         return 0;
    679. 

  679.     if (item->elv > 0 && sd->status.base_level < item->elv)
    680. 

  680.         return 0;
    681. 

  681. 

  682.     if (map[sd->bl.m].flag.pvp
    683. 

  683.         && (item->flag.no_equip == 1 || item->flag.no_equip == 3))
    684. 

  684.         return 0;
    685. 

  685.     if (map[sd->bl.m].flag.gvg
    686. 

  686.         && (item->flag.no_equip == 2 || item->flag.no_equip == 3))
    687. 

  687.         return 0;
    688. 

  688.     if (item->equip & 0x0002 && sc_data
    689. 

  689.         && sc_data[SC_STRIPWEAPON].timer != -1)
    690. 

  690.         return 0;
    691. 

  691.     if (item->equip & 0x0020 && sc_data
    692. 

  692.         && sc_data[SC_STRIPSHIELD].timer != -1)
    693. 

  693.         return 0;
    694. 

  694.     if (item->equip & 0x0010 && sc_data && sc_data[SC_STRIPARMOR].timer != -1)
    695. 

  695.         return 0;
    696. 

  696.     if (item->equip & 0x0100 && sc_data && sc_data[SC_STRIPHELM].timer != -1)
    697. 

  697.         return 0;
    698. 

  698.     return 1;
    699. 

  699. }
    700. 

  700. 

  701. /*==========================================
    702. 

  702.  * Weapon Breaking [Valaris]
    703. 

  703.  *------------------------------------------
    704. 

  704.  */
    705. 

  705. int pc_breakweapon (struct map_session_data *sd)
    706. 

  706. {
    707. 

  707.     struct item_data *item;
    708. 

  708.     char output[255];
    709. 

  709.     int  i;
    710. 

  710. 

  711.     if (sd == NULL)
    712. 

  712.         return -1;
    713. 

  713.     if (sd->unbreakable >= MRAND (100))
    714. 

  714.         return 0;
    715. 

  715.     if (sd->sc_data && sd->sc_data[SC_CP_WEAPON].timer != -1)
    716. 

  716.         return 0;
    717. 

  717. 

  718.     for (i = 0; i < MAX_INVENTORY; i++)
    719. 

  719.     {
    720. 

  720.         if (sd->status.inventory[i].equip
    721. 

  721.             && sd->status.inventory[i].equip & 0x0002
    722. 

  722.             && !sd->status.inventory[i].broken)
    723. 

  723.         {
    724. 

  724.             item = sd->inventory_data[i];
    725. 

  725.             if (!item)
    726. 

  726.                 continue;
    727. 

  727.             sd->status.inventory[i].broken = 1;
    728. 

  728.             //pc_unequipitem(sd,i,0);
    729. 

  729.             if (sd->status.inventory[i].equip
    730. 

  730.                 && sd->status.inventory[i].equip & 0x0002
    731. 

  731.                 && sd->status.inventory[i].broken == 1)
    732. 

  732.             {
    733. 

  733.                 sprintf (output, "%s has broken.", item->jname);
    734. 

  734.                 clif_emotion (&sd->bl, 23);
    735. 

  735.                 clif_displaymessage (sd->fd, output);
    736. 

  736.                 clif_equiplist (sd);
    737. 

  737.                 skill_status_change_start (&sd->bl, SC_BROKNWEAPON, 0, 0, 0,
    738. 

  738.                                            0, 0, 0);
    739. 

  739.             }
    740. 

  740.         }
    741. 

  741.         if (sd->status.inventory[i].broken == 1)
    742. 

  742.             return 0;
    743. 

  743.     }
    744. 

  744. 

  745.     return 0;
    746. 

  746. }
    747. 

  747. 

  748. /*==========================================
    749. 

  749.  * Armor Breaking [Valaris]
    750. 

  750.  *------------------------------------------
    751. 

  751.  */
    752. 

  752. int pc_breakarmor (struct map_session_data *sd)
    753. 

  753. {
    754. 

  754.     struct item_data *item;
    755. 

  755.     char output[255];
    756. 

  756.     int  i;
    757. 

  757. 

  758.     if (sd == NULL)
    759. 

  759.         return -1;
    760. 

  760.     if (sd->unbreakable >= MRAND (100))
    761. 

  761.         return 0;
    762. 

  762.     if (sd->sc_data && sd->sc_data[SC_CP_ARMOR].timer != -1)
    763. 

  763.         return 0;
    764. 

  764. 

  765.     for (i = 0; i < MAX_INVENTORY; i++)
    766. 

  766.     {
    767. 

  767.         if (sd->status.inventory[i].equip
    768. 

  768.             && sd->status.inventory[i].equip & 0x0010
    769. 

  769.             && !sd->status.inventory[i].broken)
    770. 

  770.         {
    771. 

  771.             item = sd->inventory_data[i];
    772. 

  772.             if (!item)
    773. 

  773.                 continue;
    774. 

  774.             sd->status.inventory[i].broken = 1;
    775. 

  775.             //pc_unequipitem(sd,i,0);
    776. 

  776.             if (sd->status.inventory[i].equip
    777. 

  777.                 && sd->status.inventory[i].equip & 0x0010
    778. 

  778.                 && sd->status.inventory[i].broken == 1)
    779. 

  779.             {
    780. 

  780.                 sprintf (output, "%s has broken.", item->jname);
    781. 

  781.                 clif_emotion (&sd->bl, 23);
    782. 

  782.                 clif_displaymessage (sd->fd, output);
    783. 

  783.                 clif_equiplist (sd);
    784. 

  784.                 skill_status_change_start (&sd->bl, SC_BROKNARMOR, 0, 0, 0, 0,
    785. 

  785.                                            0, 0);
    786. 

  786.             }
    787. 

  787.         }
    788. 

  788.         if (sd->status.inventory[i].broken == 1)
    789. 

  789.             return 0;
    790. 

  790.     }
    791. 

  791.     return 0;
    792. 

  792. }
    793. 

  793. 

  794. /*==========================================
    795. 

  795.  * session idに問題無し 
    796. 

  796.  * char鯖から送られてきたステータスを設定 
    797. 

  797.  *------------------------------------------
    798. 

  798.  */
    799. 

  799. int pc_authok (int id, int login_id2, time_t connect_until_time,
    800. 

  800.                short tmw_version, struct mmo_charstatus *st)
    801. 

  801. {
    802. 

  802.     struct map_session_data *sd = NULL;
    803. 

  803. 

  804. //    struct party *p;
    805. 

  805. //    struct guild *g;
    806. 

  806.     int  i;
    807. 

  807.     unsigned long tick = gettick ();
    808. 

  808.     struct sockaddr_in sai;
    809. 

  809.     socklen_t sa_len = sizeof(struct sockaddr);
    810. 

  810. 

  811.     sd = map_id2sd (id);
    812. 

  812.     if (sd == NULL)
    813. 

  813.         return 1;
    814. 

  814. 

  815.     sd->login_id2 = login_id2;
    816. 

  816.     sd->tmw_version = tmw_version;
    817. 

  817. 

  818.     memcpy (&sd->status, st, sizeof (*st));
    819. 

  819. 

  820.     if (sd->status.sex != sd->sex)
    821. 

  821.     {
    822. 

  822.         clif_authfail_fd (sd->fd, 0);
    823. 

  823.         return 1;
    824. 

  824.     }
    825. 

  825. 

  826.     MAP_LOG_STATS (sd, "LOGIN");
    827. 

  827.     MAP_LOG_XP (sd, "LOGIN");
    828. 

  828.     MAP_LOG_MAGIC (sd, "LOGIN");
    829. 

  829. 

  830.     memset (&sd->state, 0, sizeof (sd->state));
    831. 

  831.     // 基本的な初期化 
    832. 

  832.     sd->state.connect_new = 1;
    833. 

  833.     sd->bl.prev = sd->bl.next = NULL;
    834. 

  834. 

  835.     sd->weapontype1 = sd->weapontype2 = 0;
    836. 

  836.     sd->view_class = sd->status.class;
    837. 

  837.     sd->speed = DEFAULT_WALK_SPEED;
    838. 

  838.     sd->state.dead_sit = 0;
    839. 

  839.     sd->dir = 0;
    840. 

  840.     sd->head_dir = 0;
    841. 

  841.     sd->state.auth = 1;
    842. 

  842.     sd->walktimer = -1;
    843. 

  843.     sd->attacktimer = -1;
    844. 

  844.     sd->followtimer = -1;       // [MouseJstr]
    845. 

  845.     sd->skilltimer = -1;
    846. 

  846.     sd->skillitem = -1;
    847. 

  847.     sd->skillitemlv = -1;
    848. 

  848.     sd->invincible_timer = -1;
    849. 

  849.     sd->sg_count = 0;
    850. 

  850. 

  851.     sd->deal_locked = 0;
    852. 

  852.     sd->trade_partner = 0;
    853. 

  853. 

  854.     sd->inchealhptick = 0;
    855. 

  855.     sd->inchealsptick = 0;
    856. 

  856.     sd->hp_sub = 0;
    857. 

  857.     sd->sp_sub = 0;
    858. 

  858.     sd->quick_regeneration_hp.amount = 0;
    859. 

  859.     sd->quick_regeneration_sp.amount = 0;
    860. 

  860.     sd->heal_xp = 0;
    861. 

  861.     sd->inchealspirithptick = 0;
    862. 

  862.     sd->inchealspiritsptick = 0;
    863. 

  863.     sd->canact_tick = tick;
    864. 

  864.     sd->canmove_tick = tick;
    865. 

  865.     sd->attackabletime = tick;
    866. 

  866.     /* We don't want players bypassing spell restrictions. [remoitnane] */
    867. 

  867.     sd->cast_tick = tick + pc_readglobalreg (sd, "MAGIC_CAST_TICK");
    868. 

  868. 

  869.     sd->doridori_counter = 0;
    870. 

  870. 

  871.     sd->spiritball = 0;
    872. 

  872.     for (i = 0; i < MAX_SKILL_LEVEL; i++)
    873. 

  873.         sd->spirit_timer[i] = -1;
    874. 

  874.     for (i = 0; i < MAX_SKILLTIMERSKILL; i++)
    875. 

  875.         sd->skilltimerskill[i].timer = -1;
    876. 

  876. 

  877.     memset (&sd->dev, 0, sizeof (struct square));
    878. 

  878.     for (i = 0; i < 5; i++)
    879. 

  879.     {
    880. 

  880.         sd->dev.val1[i] = 0;
    881. 

  881.         sd->dev.val2[i] = 0;
    882. 

  882.     }
    883. 

  883. 

  884.      // アカウント変数の送信要求 
    885. 

  885.     intif_request_accountreg (sd);
    886. 

  886. 

  887.      // アイテムチェック 
    888. 

  888.     pc_setinventorydata (sd);
    889. 

  889.     pc_checkitem (sd);
    890. 

  890. 

  891.      // ステータス異常の初期化 
    892. 

  892.     for (i = 0; i < MAX_STATUSCHANGE; i++)
    893. 

  893.     {
    894. 

  894.         sd->sc_data[i].timer = -1;
    895. 

  895.         sd->sc_data[i].val1 = sd->sc_data[i].val2 = sd->sc_data[i].val3 =
    896. 

  896.             sd->sc_data[i].val4 = 0;
    897. 

  897.     }
    898. 

  898.     sd->sc_count = 0;
    899. 

  899.     if ((battle_config.atc_gmonly == 0 || pc_isGM (sd)) &&
    900. 

  900.         (pc_isGM (sd) >= get_atcommand_level (AtCommand_Hide)))
    901. 

  901.         sd->status.option &= (OPTION_MASK | OPTION_HIDE);
    902. 

  902.     else
    903. 

  903.         sd->status.option &= OPTION_MASK;
    904. 

  904. 

  905.     // スキルユニット関係の初期化 
    906. 

  906.     memset (sd->skillunit, 0, sizeof (sd->skillunit));
    907. 

  907.     memset (sd->skillunittick, 0, sizeof (sd->skillunittick));
    908. 

  908. 

  909.     // init ignore list
    910. 

  910.     memset (sd->ignore, 0, sizeof (sd->ignore));
    911. 

  911. 

  912.      // パーティー関係の初期化 
    913. 

  913.     sd->party_sended = 0;
    914. 

  914.     sd->party_invite = 0;
    915. 

  915.     sd->party_x = -1;
    916. 

  916.     sd->party_y = -1;
    917. 

  917.     sd->party_hp = -1;
    918. 

  918. 

  919.      // ギルド関係の初期化 
    920. 

  920.     sd->guild_sended = 0;
    921. 

  921.     sd->guild_invite = 0;
    922. 

  922.     sd->guild_alliance = 0;
    923. 

  923. 

  924.      // イベント関係の初期化 
    925. 

  925.     memset (sd->eventqueue, 0, sizeof (sd->eventqueue));
    926. 

  926.     for (i = 0; i < MAX_EVENTTIMER; i++)
    927. 

  927.         sd->eventtimer[i] = -1;
    928. 

  928. 

  929.     // 位置の設定 
    930. 

  930.     pc_setpos (sd, sd->status.last_point.map, sd->status.last_point.x,
    931. 

  931.                sd->status.last_point.y, 0);
    932. 

  932. 

  933.      // パーティ、ギルドデータの要求 
    934. 

  934.     if (sd->status.party_id > 0
    935. 

  935.         && party_search (sd->status.party_id) == NULL)
    936. 

  936.         party_request_info (sd->status.party_id);
    937. 

  937.     if (sd->status.guild_id > 0
    938. 

  938.         && guild_search (sd->status.guild_id) == NULL)
    939. 

  939.         guild_request_info (sd->status.guild_id);
    940. 

  940. 

  941.     // pvpの設定 
    942. 

  942.     sd->pvp_rank = 0;
    943. 

  943.     sd->pvp_point = 0;
    944. 

  944.     sd->pvp_timer = -1;
    945. 

  945. 

  946.     // 通知 
    947. 

  947.     clif_authok (sd);
    948. 

  948.     map_addnickdb (sd);
    949. 

  949.     if (map_charid2nick (sd->status.char_id) == NULL)
    950. 

  950.         map_addchariddb (sd->status.char_id, sd->status.name);
    951. 

  951. 

  952.      //スパノビ用死にカウンターのスクリプト変数からの読み出しとsdへのセット 
    953. 

  953.     sd->die_counter = pc_readglobalreg (sd, "PC_DIE_COUNTER");
    954. 

  954. 

  955.     if (night_flag == 1)
    956. 

  956.     {
    957. 

  957.         char tmpstr[1024];
    958. 

  958.         strcpy (tmpstr, msg_txt (500)); // Actually, it's the night...
    959. 

  959.         clif_wis_message (sd->fd, wisp_server_name, tmpstr,
    960. 

  960.                           strlen (tmpstr) + 1);
    961. 

  961.         sd->opt2 |= STATE_BLIND;
    962. 

  962.     }
    963. 

  963. 

  964.      // ステータス初期計算など
    965. 

  965.     pc_calcstatus (sd, 1);
    966. 

  966. 

  967.     if (pc_isGM (sd))
    968. 

  968.     {
    969. 

  969.         printf
    970. 

  970.             ("Connection accepted: character '%s' (account: %d; GM level %d).\n",
    971. 

  971.              sd->status.name, sd->status.account_id, pc_isGM (sd));
    972. 

  972.         clif_updatestatus (sd, SP_GM);
    973. 

  973.     }
    974. 

  974.     else
    975. 

  975.         printf ("Connection accepted: Character '%s' (account: %d).\n",
    976. 

  976.                 sd->status.name, sd->status.account_id);
    977. 

  977. 

  978.     // Message of the Dayの送信 
    979. 

  979.     {
    980. 

  980.         char buf[256];
    981. 

  981.         FILE *fp;
    982. 

  982.         if ((fp = fopen_ (motd_txt, "r")) != NULL)
    983. 

  983.         {
    984. 

  984.             while (fgets (buf, sizeof (buf) - 1, fp) != NULL)
    985. 

  985.             {
    986. 

  986.                 int  i;
    987. 

  987.                 for (i = 0; buf[i]; i++)
    988. 

  988.                 {
    989. 

  989.                     if (buf[i] == '\r' || buf[i] == '\n')
    990. 

  990.                     {
    991. 

  991.                         buf[i] = 0;
    992. 

  992.                         break;
    993. 

  993.                     }
    994. 

  994.                 }
    995. 

  995.                 clif_displaymessage (sd->fd, buf);
    996. 

  996.             }
    997. 

  997.             fclose_ (fp);
    998. 

  998.         }
    999. 

  999.     }
    1000. 

  1000. 

  1001.     sd->auto_ban_info.in_progress = 0;
    1002. 

  1002. 

  1003.     // Initialize antispam vars
    1004. 

  1004.     sd->chat_reset_due = sd->chat_lines_in = sd->chat_total_repeats =
    1005. 

  1005.         sd->chat_repeat_reset_due = 0;
    1006. 

  1006.     sd->chat_lastmsg[0] = '\0';
    1007. 

  1007. 

  1008.     memset(sd->flood_rates, 0, sizeof(sd->flood_rates));
    1009. 

  1009.     sd->packet_flood_reset_due = sd->packet_flood_in = 0;
    1010. 

  1010. 

  1011.     // Obtain IP address (if they are still connected)
    1012. 

  1012.     if (!getpeername(sd->fd, (struct sockaddr *)&sai, &sa_len))
    1013. 

  1013.         sd->ip = sai.sin_addr.s_addr;
    1014. 

  1014. 

  1015.     // message of the limited time of the account
    1016. 

  1016.     if (connect_until_time != 0)
    1017. 

  1017.     {                           // don't display if it's unlimited or unknow value
    1018. 

  1018.         char tmpstr[1024];
    1019. 

  1019.         strftime (tmpstr, sizeof (tmpstr) - 1, msg_txt (501), gmtime (&connect_until_time));    // "Your account time limit is: %d-%m-%Y %H:%M:%S."
    1020. 

  1020.         clif_wis_message (sd->fd, wisp_server_name, tmpstr,
    1021. 

  1021.                           strlen (tmpstr) + 1);
    1022. 

  1022.     }
    1023. 

  1023.     pc_calcstatus (sd, 1);
    1024. 

  1024. 

  1025.     return 0;
    1026. 

  1026. }
    1027. 

  1027. 

  1028. /*==========================================
    1029. 

  1029.  * session idに問題ありなので後始末 
    1030. 

  1030.  *------------------------------------------
    1031. 

  1031.  */
    1032. 

  1032. int pc_authfail (int id)
    1033. 

  1033. {
    1034. 

  1034.     struct map_session_data *sd;
    1035. 

  1035. 

  1036.     sd = map_id2sd (id);
    1037. 

  1037.     if (sd == NULL)
    1038. 

  1038.         return 1;
    1039. 

  1039. 

  1040.     clif_authfail_fd (sd->fd, 0);
    1041. 

  1041. 

  1042.     return 0;
    1043. 

  1043. }
    1044. 

  1044. 

  1045. static int pc_calc_skillpoint (struct map_session_data *sd)
    1046. 

  1046. {
    1047. 

  1047.     int  i, skill_points = 0;
    1048. 

  1048. 

  1049.     nullpo_retr (0, sd);
    1050. 

  1050. 

  1051.     for (i = 0; i < skill_pool_skills_size; i++)
    1052. 

  1052.     {
    1053. 

  1053.         if (skill_pool_skills[i] < 0 || skill_pool_skills[i] >= MAX_SKILL)
    1054. 

  1054.             continue;
    1055. 

  1055.         int lv = sd->status.skill[skill_pool_skills[i]].lv;
    1056. 

  1056.         if (lv)
    1057. 

  1057.             skill_points += ((lv * (lv - 1)) >> 1) - 1;
    1058. 

  1058.     }
    1059. 

  1059. 

  1060.     return skill_points;
    1061. 

  1061. }
    1062. 

  1062. 

  1063. /*==========================================
    1064. 

  1064.  * 覚えられるスキルの計算 
    1065. 

  1065.  *------------------------------------------
    1066. 

  1066.  */
    1067. 

  1067. int pc_calc_skilltree (struct map_session_data *sd)
    1068. 

  1068. {
    1069. 

  1069.     int  i, id = 0;
    1070. 

  1070.     int  c = 0, s = 0;
    1071. 

  1071.     //転生や養子の場合の元の職業を算出する 
    1072. 

  1072.     struct pc_base_job s_class;
    1073. 

  1073. 

  1074.     nullpo_retr (0, sd);
    1075. 

  1075. 

  1076.     s_class = pc_calc_base_job (sd->status.class);
    1077. 

  1077.     c = s_class.job;
    1078. 

  1078.     s = (s_class.upper == 1) ? 1 : 0;   //転生以外は通常のスキル？ 
    1079. 

  1079. 

  1080.     if ((battle_config.skillup_limit)
    1081. 

  1081.         && ((c >= 0 && c < 23) || (c >= 4001 && c < 4023)
    1082. 

  1082.             || (c >= 4023 && c < 4045)))
    1083. 

  1083.     {
    1084. 

  1084.         int  skill_point = pc_calc_skillpoint (sd);
    1085. 

  1085.         if (skill_point < 9)
    1086. 

  1086.             c = 0;
    1087. 

  1087.         else if ((sd->status.skill_point >= sd->status.job_level
    1088. 

  1088.                   && skill_point < 58) && ((c > 6 && c < 23) || (c > 4007
    1089. 

  1089.                                                                  && c < 4023)
    1090. 

  1090.                                            || (c > 4029 && c < 4045)))
    1091. 

  1091.         {
    1092. 

  1092.             switch (c)
    1093. 

  1093.             {
    1094. 

  1094.                 case 7:
    1095. 

  1095.                 case 14:
    1096. 

  1096.                     c = 1;
    1097. 

  1097.                     break;
    1098. 

  1098.                 case 8:
    1099. 

  1099.                 case 15:
    1100. 

  1100.                     c = 4;
    1101. 

  1101.                     break;
    1102. 

  1102.                 case 9:
    1103. 

  1103.                 case 16:
    1104. 

  1104.                     c = 2;
    1105. 

  1105.                     break;
    1106. 

  1106.                 case 10:
    1107. 

  1107.                 case 18:
    1108. 

  1108.                     c = 5;
    1109. 

  1109.                     break;
    1110. 

  1110.                 case 11:
    1111. 

  1111.                 case 19:
    1112. 

  1112.                 case 20:
    1113. 

  1113.                     c = 3;
    1114. 

  1114.                     break;
    1115. 

  1115.                 case 12:
    1116. 

  1116.                 case 17:
    1117. 

  1117.                     c = 6;
    1118. 

  1118.                     break;
    1119. 

  1119.                 case 4008:
    1120. 

  1120.                 case 4015:
    1121. 

  1121.                     c = 4002;
    1122. 

  1122.                     break;
    1123. 

  1123.                 case 4009:
    1124. 

  1124.                 case 4016:
    1125. 

  1125.                     c = 4005;
    1126. 

  1126.                     break;
    1127. 

  1127.                 case 4010:
    1128. 

  1128.                 case 4017:
    1129. 

  1129.                     c = 4003;
    1130. 

  1130.                     break;
    1131. 

  1131.                 case 4011:
    1132. 

  1132.                 case 4019:
    1133. 

  1133.                     c = 4006;
    1134. 

  1134.                     break;
    1135. 

  1135.                 case 4012:
    1136. 

  1136.                 case 4020:
    1137. 

  1137.                 case 4021:
    1138. 

  1138.                     c = 4004;
    1139. 

  1139.                     break;
    1140. 

  1140.                 case 4013:
    1141. 

  1141.                 case 4018:
    1142. 

  1142.                     c = 4007;
    1143. 

  1143.                     break;
    1144. 

  1144.                 case 4030:
    1145. 

  1145.                 case 4037:
    1146. 

  1146.                     c = 4024;
    1147. 

  1147.                     break;
    1148. 

  1148.                 case 4031:
    1149. 

  1149.                 case 4038:
    1150. 

  1150.                     c = 4027;
    1151. 

  1151.                     break;
    1152. 

  1152.                 case 4032:
    1153. 

  1153.                 case 4039:
    1154. 

  1154.                     c = 4025;
    1155. 

  1155.                     break;
    1156. 

  1156.                 case 4033:
    1157. 

  1157.                 case 4040:
    1158. 

  1158.                     c = 4028;
    1159. 

  1159.                     break;
    1160. 

  1160.                 case 4034:
    1161. 

  1161.                 case 4041:
    1162. 

  1162.                 case 4042:
    1163. 

  1163.                     c = 4026;
    1164. 

  1164.                     break;
    1165. 

  1165.                 case 4035:
    1166. 

  1166.                 case 4043:
    1167. 

  1167.                     c = 4029;
    1168. 

  1168.                     break;
    1169. 

  1169.                 default:
    1170. 

  1170.                     break;
    1171. 

  1171.             }
    1172. 

  1172.         }
    1173. 

  1173.     }
    1174. 

  1174. 

  1175.     /*Comment this out for now, as we manage skills differently
    1176. 

  1176.      * for(i=0;i<MAX_SKILL;i++)
    1177. 

  1177.      * if (i < TMW_MAGIC || i > TMW_MAGIC_END){ // [Fate] This hack gets TMW magic working and persisted without bothering about the skill tree.
    1178. 

  1178.      * if (sd->status.skill[i].flag != 13) sd->status.skill[i].id=0;
    1179. 

  1179.      * if (sd->status.skill[i].flag && sd->status.skill[i].flag != 13){ // cardスキルなら、 
    1180. 

  1180.      * sd->status.skill[i].lv=(sd->status.skill[i].flag==1)?0:sd->status.skill[i].flag-2;   // 本当のlvに 
    1181. 

  1181.      * sd->status.skill[i].flag=0;  // flagは0にしておく 
    1182. 

  1182.      * }
    1183. 

  1183.      * }
    1184. 

  1184.      */
    1185. 

  1185. 

  1186.     if (battle_config.gm_allskill > 0
    1187. 

  1187.         && pc_isGM (sd) >= battle_config.gm_allskill)
    1188. 

  1188.     {
    1189. 

  1189.         // 全てのスキル 
    1190. 

  1190.         for (i = 1; i < 158; i++)
    1191. 

  1191.             sd->status.skill[i].id = i;
    1192. 

  1192.         for (i = 210; i < 291; i++)
    1193. 

  1193.             sd->status.skill[i].id = i;
    1194. 

  1194.         for (i = 304; i < 337; i++)
    1195. 

  1195.             sd->status.skill[i].id = i;
    1196. 

  1196.         if (battle_config.enable_upper_class)
    1197. 

  1197.         {                       //confで無効でなければ読み込む 
    1198. 

  1198.             for (i = 355; i < MAX_SKILL; i++)
    1199. 

  1199.                 sd->status.skill[i].id = i;
    1200. 

  1200.         }
    1201. 

  1201. 

  1202.     }
    1203. 

  1203.     else
    1204. 

  1204.     {
    1205. 

  1205.         int  flag;
    1206. 

  1206.         // 通常の計算 
    1207. 

  1207.         do
    1208. 

  1208.         {
    1209. 

  1209.             flag = 0;
    1210. 

  1210.             for (i = 0; (id = skill_tree[s][c][i].id) > 0; i++)
    1211. 

  1211.             {
    1212. 

  1212.                 int  f = 1;
    1213. 

  1213.                 if (!battle_config.skillfree)
    1214. 

  1214.                 {
    1215. 

  1215.                     int  j;
    1216. 

  1216.                     for (j = 0; j < 5; j++)
    1217. 

  1217.                     {
    1218. 

  1218.                         if (skill_tree[s][c][i].need[j].id &&
    1219. 

  1219.                             pc_checkskill (sd,
    1220. 

  1220.                                            skill_tree[s][c][i].need[j].id) <
    1221. 

  1221.                             skill_tree[s][c][i].need[j].lv)
    1222. 

  1222.                             f = 0;
    1223. 

  1223.                     }
    1224. 

  1224.                 }
    1225. 

  1225.                 if (f && sd->status.skill[id].id == 0)
    1226. 

  1226.                 {
    1227. 

  1227.                     sd->status.skill[id].id = id;
    1228. 

  1228.                     flag = 1;
    1229. 

  1229.                 }
    1230. 

  1230.             }
    1231. 

  1231.         }
    1232. 

  1232.         while (flag);
    1233. 

  1233.     }
    1234. 

  1234. //  if(battle_config.etc_log)
    1235. 

  1235. //      printf("calc skill_tree\n");
    1236. 

  1236.     return 0;
    1237. 

  1237. }
    1238. 

  1238. 

  1239. /*==========================================
    1240. 

  1240.  * 重量アイコンの確認 
    1241. 

  1241.  *------------------------------------------
    1242. 

  1242.  */
    1243. 

  1243. int pc_checkweighticon (struct map_session_data *sd)
    1244. 

  1244. {
    1245. 

  1245.     int  flag = 0;
    1246. 

  1246. 

  1247.     nullpo_retr (0, sd);
    1248. 

  1248. 

  1249.     if (sd->weight * 2 >= sd->max_weight
    1250. 

  1250.         && sd->sc_data[SC_FLYING_BACKPACK].timer == -1)
    1251. 

  1251.         flag = 1;
    1252. 

  1252.     if (sd->weight * 10 >= sd->max_weight * 9)
    1253. 

  1253.         flag = 2;
    1254. 

  1254. 

  1255.     if (flag == 1)
    1256. 

  1256.     {
    1257. 

  1257.         if (sd->sc_data[SC_WEIGHT50].timer == -1)
    1258. 

  1258.             skill_status_change_start (&sd->bl, SC_WEIGHT50, 0, 0, 0, 0, 0,
    1259. 

  1259.                                        0);
    1260. 

  1260.     }
    1261. 

  1261.     else
    1262. 

  1262.     {
    1263. 

  1263.         skill_status_change_end (&sd->bl, SC_WEIGHT50, -1);
    1264. 

  1264.     }
    1265. 

  1265.     if (flag == 2)
    1266. 

  1266.     {
    1267. 

  1267.         if (sd->sc_data[SC_WEIGHT90].timer == -1)
    1268. 

  1268.             skill_status_change_start (&sd->bl, SC_WEIGHT90, 0, 0, 0, 0, 0,
    1269. 

  1269.                                        0);
    1270. 

  1270.     }
    1271. 

  1271.     else
    1272. 

  1272.     {
    1273. 

  1273.         skill_status_change_end (&sd->bl, SC_WEIGHT90, -1);
    1274. 

  1274.     }
    1275. 

  1275.     return 0;
    1276. 

  1276. }
    1277. 

  1277. 

  1278. void pc_set_weapon_look (struct map_session_data *sd)
    1279. 

  1279. {
    1280. 

  1280.     if (!sd)
    1281. 

  1281.         return;
    1282. 

  1282. 

  1283.     if (sd->attack_spell_override)
    1284. 

  1284.         clif_changelook (&sd->bl, LOOK_WEAPON,
    1285. 

  1285.                          sd->attack_spell_look_override);
    1286. 

  1286.     else
    1287. 

  1287.         clif_changelook (&sd->bl, LOOK_WEAPON, sd->status.weapon);
    1288. 

  1288. }
    1289. 

  1289. 

  1290. /*==========================================
    1291. 

  1291.  * パラメータ計算 
    1292. 

  1292.  * first==0の時、計算対象のパラメータが呼び出し前から 
    1293. 

  1293.  * 変 化した場合自動でsendするが、 
    1294. 

  1294.  * 能動的に変化させたパラメータは自前でsendするように 
    1295. 

  1295.  *------------------------------------------
    1296. 

  1296.  */
    1297. 

  1297. int pc_calcstatus (struct map_session_data *sd, int first)
    1298. 

  1298. {
    1299. 

  1299.     int  b_speed, b_max_hp, b_max_sp, b_hp, b_sp, b_weight, b_max_weight,
    1300. 

  1300.         b_paramb[6], b_parame[6], b_hit, b_flee;
    1301. 

  1301.     int  b_aspd, b_watk, b_def, b_watk2, b_def2, b_flee2, b_critical,
    1302. 

  1302.         b_attackrange, b_matk1, b_matk2, b_mdef, b_mdef2, b_class;
    1303. 

  1303.     int  b_base_atk;
    1304. 

  1304.     struct skill b_skill[MAX_SKILL];
    1305. 

  1305.     int  i, bl, index;
    1306. 

  1306.     int  skill, aspd_rate, wele, wele_, def_ele, refinedef = 0;
    1307. 

  1307.     int  str, dstr, dex;
    1308. 

  1308.     struct pc_base_job s_class;
    1309. 

  1309. 

  1310.     nullpo_retr (0, sd);
    1311. 

  1311. 

  1312.     //転生や養子の場合の元の職業を算出する 
    1313. 

  1313.     s_class = pc_calc_base_job (sd->status.class);
    1314. 

  1314. 

  1315.     b_speed = sd->speed;
    1316. 

  1316.     b_max_hp = sd->status.max_hp;
    1317. 

  1317.     b_max_sp = sd->status.max_sp;
    1318. 

  1318.     b_hp = sd->status.hp;
    1319. 

  1319.     b_sp = sd->status.sp;
    1320. 

  1320.     b_weight = sd->weight;
    1321. 

  1321.     b_max_weight = sd->max_weight;
    1322. 

  1322.     memcpy (b_paramb, &sd->paramb, sizeof (b_paramb));
    1323. 

  1323.     memcpy (b_parame, &sd->paramc, sizeof (b_parame));
    1324. 

  1324.     memcpy (b_skill, &sd->status.skill, sizeof (b_skill));
    1325. 

  1325.     b_hit = sd->hit;
    1326. 

  1326.     b_flee = sd->flee;
    1327. 

  1327.     b_aspd = sd->aspd;
    1328. 

  1328.     b_watk = sd->watk;
    1329. 

  1329.     b_def = sd->def;
    1330. 

  1330.     b_watk2 = sd->watk2;
    1331. 

  1331.     b_def2 = sd->def2;
    1332. 

  1332.     b_flee2 = sd->flee2;
    1333. 

  1333.     b_critical = sd->critical;
    1334. 

  1334.     b_attackrange = sd->attackrange;
    1335. 

  1335.     b_matk1 = sd->matk1;
    1336. 

  1336.     b_matk2 = sd->matk2;
    1337. 

  1337.     b_mdef = sd->mdef;
    1338. 

  1338.     b_mdef2 = sd->mdef2;
    1339. 

  1339.     b_class = sd->view_class;
    1340. 

  1340.     sd->view_class = sd->status.class;
    1341. 

  1341.     b_base_atk = sd->base_atk;
    1342. 

  1342. 

  1343.     pc_calc_skilltree (sd);     // スキルツリーの計算 
    1344. 

  1344. 

  1345.     sd->max_weight = max_weight_base[s_class.job] + sd->status.str * 300;
    1346. 

  1346. 

  1347.     if (first & 1)
    1348. 

  1348.     {
    1349. 

  1349.         sd->weight = 0;
    1350. 

  1350.         for (i = 0; i < MAX_INVENTORY; i++)
    1351. 

  1351.         {
    1352. 

  1352.             if (sd->status.inventory[i].nameid == 0
    1353. 

  1353.                 || sd->inventory_data[i] == NULL)
    1354. 

  1354.                 continue;
    1355. 

  1355.             sd->weight +=
    1356. 

  1356.                 sd->inventory_data[i]->weight *
    1357. 

  1357.                 sd->status.inventory[i].amount;
    1358. 

  1358.         }
    1359. 

  1359.         sd->cart_max_weight = battle_config.max_cart_weight;
    1360. 

  1360.         sd->cart_weight = 0;
    1361. 

  1361.         sd->cart_max_num = MAX_CART;
    1362. 

  1362.         sd->cart_num = 0;
    1363. 

  1363.         for (i = 0; i < MAX_CART; i++)
    1364. 

  1364.         {
    1365. 

  1365.             if (sd->status.cart[i].nameid == 0)
    1366. 

  1366.                 continue;
    1367. 

  1367.             sd->cart_weight +=
    1368. 

  1368.                 itemdb_weight (sd->status.cart[i].nameid) *
    1369. 

  1369.                 sd->status.cart[i].amount;
    1370. 

  1370.             sd->cart_num++;
    1371. 

  1371.         }
    1372. 

  1372.     }
    1373. 

  1373. 

  1374.     memset (sd->paramb, 0, sizeof (sd->paramb));
    1375. 

  1375.     memset (sd->parame, 0, sizeof (sd->parame));
    1376. 

  1376.     sd->hit = 0;
    1377. 

  1377.     sd->flee = 0;
    1378. 

  1378.     sd->flee2 = 0;
    1379. 

  1379.     sd->critical = 0;
    1380. 

  1380.     sd->aspd = 0;
    1381. 

  1381.     sd->watk = 0;
    1382. 

  1382.     sd->def = 0;
    1383. 

  1383.     sd->mdef = 0;
    1384. 

  1384.     sd->watk2 = 0;
    1385. 

  1385.     sd->def2 = 0;
    1386. 

  1386.     sd->mdef2 = 0;
    1387. 

  1387.     sd->status.max_hp = 0;
    1388. 

  1388.     sd->status.max_sp = 0;
    1389. 

  1389.     sd->attackrange = 0;
    1390. 

  1390.     sd->attackrange_ = 0;
    1391. 

  1391.     sd->atk_ele = 0;
    1392. 

  1392.     sd->def_ele = 0;
    1393. 

  1393.     sd->star = 0;
    1394. 

  1394.     sd->overrefine = 0;
    1395. 

  1395.     sd->matk1 = 0;
    1396. 

  1396.     sd->matk2 = 0;
    1397. 

  1397.     sd->speed = DEFAULT_WALK_SPEED;
    1398. 

  1398.     sd->hprate = 100;
    1399. 

  1399.     sd->sprate = 100;
    1400. 

  1400.     sd->castrate = 100;
    1401. 

  1401.     sd->dsprate = 100;
    1402. 

  1402.     sd->base_atk = 0;
    1403. 

  1403.     sd->arrow_atk = 0;
    1404. 

  1404.     sd->arrow_ele = 0;
    1405. 

  1405.     sd->arrow_hit = 0;
    1406. 

  1406.     sd->arrow_range = 0;
    1407. 

  1407.     sd->nhealhp = sd->nhealsp = sd->nshealhp = sd->nshealsp = sd->nsshealhp =
    1408. 

  1408.         sd->nsshealsp = 0;
    1409. 

  1409.     memset (sd->addele, 0, sizeof (sd->addele));
    1410. 

  1410.     memset (sd->addrace, 0, sizeof (sd->addrace));
    1411. 

  1411.     memset (sd->addsize, 0, sizeof (sd->addsize));
    1412. 

  1412.     memset (sd->addele_, 0, sizeof (sd->addele_));
    1413. 

  1413.     memset (sd->addrace_, 0, sizeof (sd->addrace_));
    1414. 

  1414.     memset (sd->addsize_, 0, sizeof (sd->addsize_));
    1415. 

  1415.     memset (sd->subele, 0, sizeof (sd->subele));
    1416. 

  1416.     memset (sd->subrace, 0, sizeof (sd->subrace));
    1417. 

  1417.     memset (sd->addeff, 0, sizeof (sd->addeff));
    1418. 

  1418.     memset (sd->addeff2, 0, sizeof (sd->addeff2));
    1419. 

  1419.     memset (sd->reseff, 0, sizeof (sd->reseff));
    1420. 

  1420.     memset (&sd->special_state, 0, sizeof (sd->special_state));
    1421. 

  1421.     memset (sd->weapon_coma_ele, 0, sizeof (sd->weapon_coma_ele));
    1422. 

  1422.     memset (sd->weapon_coma_race, 0, sizeof (sd->weapon_coma_race));
    1423. 

  1423. 

  1424.     sd->watk_ = 0;              //二刀流用(仮)
    1425. 

  1425.     sd->watk_2 = 0;
    1426. 

  1426.     sd->atk_ele_ = 0;
    1427. 

  1427.     sd->star_ = 0;
    1428. 

  1428.     sd->overrefine_ = 0;
    1429. 

  1429. 

  1430.     sd->aspd_rate = 100;
    1431. 

  1431.     sd->speed_rate = 100;
    1432. 

  1432.     sd->hprecov_rate = 100;
    1433. 

  1433.     sd->sprecov_rate = 100;
    1434. 

  1434.     sd->critical_def = 0;
    1435. 

  1435.     sd->double_rate = 0;
    1436. 

  1436.     sd->near_attack_def_rate = sd->long_attack_def_rate = 0;
    1437. 

  1437.     sd->atk_rate = sd->matk_rate = 100;
    1438. 

  1438.     sd->ignore_def_ele = sd->ignore_def_race = 0;
    1439. 

  1439.     sd->ignore_def_ele_ = sd->ignore_def_race_ = 0;
    1440. 

  1440.     sd->ignore_mdef_ele = sd->ignore_mdef_race = 0;
    1441. 

  1441.     sd->arrow_cri = 0;
    1442. 

  1442.     sd->magic_def_rate = sd->misc_def_rate = 0;
    1443. 

  1443.     memset (sd->arrow_addele, 0, sizeof (sd->arrow_addele));
    1444. 

  1444.     memset (sd->arrow_addrace, 0, sizeof (sd->arrow_addrace));
    1445. 

  1445.     memset (sd->arrow_addsize, 0, sizeof (sd->arrow_addsize));
    1446. 

  1446.     memset (sd->arrow_addeff, 0, sizeof (sd->arrow_addeff));
    1447. 

  1447.     memset (sd->arrow_addeff2, 0, sizeof (sd->arrow_addeff2));
    1448. 

  1448.     memset (sd->magic_addele, 0, sizeof (sd->magic_addele));
    1449. 

  1449.     memset (sd->magic_addrace, 0, sizeof (sd->magic_addrace));
    1450. 

  1450.     memset (sd->magic_subrace, 0, sizeof (sd->magic_subrace));
    1451. 

  1451.     sd->perfect_hit = 0;
    1452. 

  1452.     sd->critical_rate = sd->hit_rate = sd->flee_rate = sd->flee2_rate = 100;
    1453. 

  1453.     sd->def_rate = sd->def2_rate = sd->mdef_rate = sd->mdef2_rate = 100;
    1454. 

  1454.     sd->def_ratio_atk_ele = sd->def_ratio_atk_ele_ = 0;
    1455. 

  1455.     sd->def_ratio_atk_race = sd->def_ratio_atk_race_ = 0;
    1456. 

  1456.     sd->get_zeny_num = 0;
    1457. 

  1457.     sd->add_damage_class_count = sd->add_damage_class_count_ =
    1458. 

  1458.         sd->add_magic_damage_class_count = 0;
    1459. 

  1459.     sd->add_def_class_count = sd->add_mdef_class_count = 0;
    1460. 

  1460.     sd->monster_drop_item_count = 0;
    1461. 

  1461.     memset (sd->add_damage_classrate, 0, sizeof (sd->add_damage_classrate));
    1462. 

  1462.     memset (sd->add_damage_classrate_, 0, sizeof (sd->add_damage_classrate_));
    1463. 

  1463.     memset (sd->add_magic_damage_classrate, 0,
    1464. 

  1464.             sizeof (sd->add_magic_damage_classrate));
    1465. 

  1465.     memset (sd->add_def_classrate, 0, sizeof (sd->add_def_classrate));
    1466. 

  1466.     memset (sd->add_mdef_classrate, 0, sizeof (sd->add_mdef_classrate));
    1467. 

  1467.     memset (sd->monster_drop_race, 0, sizeof (sd->monster_drop_race));
    1468. 

  1468.     memset (sd->monster_drop_itemrate, 0, sizeof (sd->monster_drop_itemrate));
    1469. 

  1469.     sd->speed_add_rate = sd->aspd_add_rate = 100;
    1470. 

  1470.     sd->double_add_rate = sd->perfect_hit_add = sd->get_zeny_add_num = 0;
    1471. 

  1471.     sd->splash_range = sd->splash_add_range = 0;
    1472. 

  1472.     sd->autospell_id = sd->autospell_lv = sd->autospell_rate = 0;
    1473. 

  1473.     sd->hp_drain_rate = sd->hp_drain_per = sd->sp_drain_rate =
    1474. 

  1474.         sd->sp_drain_per = 0;
    1475. 

  1475.     sd->hp_drain_rate_ = sd->hp_drain_per_ = sd->sp_drain_rate_ =
    1476. 

  1476.         sd->sp_drain_per_ = 0;
    1477. 

  1477.     sd->short_weapon_damage_return = sd->long_weapon_damage_return = 0;
    1478. 

  1478.     sd->magic_damage_return = 0;    //AppleGirl Was Here
    1479. 

  1479.     sd->random_attack_increase_add = sd->random_attack_increase_per = 0;
    1480. 

  1480. 

  1481.     if (!sd->disguiseflag && sd->disguise)
    1482. 

  1482.     {
    1483. 

  1483.         sd->disguise = 0;
    1484. 

  1484.         pc_set_weapon_look (sd);
    1485. 

  1485.         clif_changelook (&sd->bl, LOOK_SHIELD, sd->status.shield);
    1486. 

  1486.         clif_changelook (&sd->bl, LOOK_HEAD_BOTTOM, sd->status.head_bottom);
    1487. 

  1487.         clif_changelook (&sd->bl, LOOK_HEAD_TOP, sd->status.head_top);
    1488. 

  1488.         clif_changelook (&sd->bl, LOOK_HEAD_MID, sd->status.head_mid);
    1489. 

  1489.         clif_clearchar (&sd->bl, 9);
    1490. 

  1490.         pc_setpos (sd, sd->mapname, sd->bl.x, sd->bl.y, 3);
    1491. 

  1491.     }
    1492. 

  1492. 

  1493.     sd->spellpower_bonus_target = 0;
    1494. 

  1494. 

  1495.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    1496. 

  1496.     {
    1497. 

  1497.         //+++ skiping arrow slot?
    1498. 

  1498.         if (i == 10)
    1499. 

  1499.             continue;
    1500. 

  1500. 

  1501.         index = sd->equip_index[i];
    1502. 

  1502.         if (index < 0 || index >= MAX_INVENTORY)
    1503. 

  1503.             continue;
    1504. 

  1504.         if (i == 9 && sd->equip_index[8] == index)
    1505. 

  1505.             continue;
    1506. 

  1506.         if (i == 5 && sd->equip_index[4] == index)
    1507. 

  1507.             continue;
    1508. 

  1508.         if (i == 6
    1509. 

  1509.             && (sd->equip_index[5] == index || sd->equip_index[4] == index))
    1510. 

  1510.             continue;
    1511. 

  1511. 

  1512.         if (sd->inventory_data[index])
    1513. 

  1513.         {
    1514. 

  1514.             sd->spellpower_bonus_target +=
    1515. 

  1515.                 sd->inventory_data[index]->magic_bonus;
    1516. 

  1516. 

  1517.             if (sd->inventory_data[index]->type == 4)
    1518. 

  1518.             {
    1519. 

  1519.                 if (sd->status.inventory[index].card[0] != 0x00ff
    1520. 

  1520.                     && sd->status.inventory[index].card[0] != 0x00fe
    1521. 

  1521.                     && sd->status.inventory[index].card[0] != (short) 0xff00)
    1522. 

  1522.                 {
    1523. 

  1523.                     int  j;
    1524. 

  1524.                     for (j = 0; j < sd->inventory_data[index]->slot; j++)
    1525. 

  1525.                          {        // カード 
    1526. 

  1526.                         int  c = sd->status.inventory[index].card[j];
    1527. 

  1527.                         if (c > 0)
    1528. 

  1528.                         {
    1529. 

  1529.                             argrec_t arg[2];
    1530. 

  1530.                             arg[0].name = "@slotId";
    1531. 

  1531.                             arg[0].v.i = i;
    1532. 

  1532.                             arg[1].name = "@itemId";
    1533. 

  1533.                             arg[1].v.i = sd->inventory_data[index]->nameid;
    1534. 

  1534.                             if (i == 8
    1535. 

  1535.                                 && sd->status.inventory[index].equip == 0x20)
    1536. 

  1536.                                 sd->state.lr_flag = 1;
    1537. 

  1537.                             run_script_l (itemdb_equipscript (c), 0, sd->bl.id,
    1538. 

  1538.                                         0, 2, arg);
    1539. 

  1539.                             sd->state.lr_flag = 0;
    1540. 

  1540.                         }
    1541. 

  1541.                     }
    1542. 

  1542.                 }
    1543. 

  1543.             }
    1544. 

  1544.             else if (sd->inventory_data[index]->type == 5)
    1545. 

  1545.             {                   // 防具 
    1546. 

  1546.                 if (sd->status.inventory[index].card[0] != 0x00ff
    1547. 

  1547.                     && sd->status.inventory[index].card[0] != 0x00fe
    1548. 

  1548.                     && sd->status.inventory[index].card[0] != (short) 0xff00)
    1549. 

  1549.                 {
    1550. 

  1550.                     int  j;
    1551. 

  1551.                     for (j = 0; j < sd->inventory_data[index]->slot; j++)
    1552. 

  1552.                          {                // カード 
    1553. 

  1553.                         int  c = sd->status.inventory[index].card[j];
    1554. 

  1554.                         if (c > 0) {
    1555. 

  1555.                             argrec_t arg[2];
    1556. 

  1556.                             arg[0].name = "@slotId";
    1557. 

  1557.                             arg[0].v.i = i;
    1558. 

  1558.                             arg[1].name = "@itemId";
    1559. 

  1559.                             arg[1].v.i = sd->inventory_data[index]->nameid;
    1560. 

  1560.                             run_script_l (itemdb_equipscript (c), 0, sd->bl.id,
    1561. 

  1561.                                         0, 2, arg);
    1562. 

  1562.                         }
    1563. 

  1563.                     }
    1564. 

  1564.                 }
    1565. 

  1565.             }
    1566. 

  1566.         }
    1567. 

  1567.     }
    1568. 

  1568. 

  1569. #ifdef USE_ASTRAL_SOUL_SKILL
    1570. 

  1570.     if (sd->spellpower_bonus_target < 0)
    1571. 

  1571.         sd->spellpower_bonus_target =
    1572. 

  1572.             (sd->spellpower_bonus_target * 256) /
    1573. 

  1573.             (MIN (128 + skill_power (sd, TMW_ASTRAL_SOUL), 256));
    1574. 

  1574. #endif
    1575. 

  1575. 

  1576.     if (sd->spellpower_bonus_target < sd->spellpower_bonus_current)
    1577. 

  1577.         sd->spellpower_bonus_current = sd->spellpower_bonus_target;
    1578. 

  1578. 

  1579.     wele = sd->atk_ele;
    1580. 

  1580.     wele_ = sd->atk_ele_;
    1581. 

  1581.     def_ele = sd->def_ele;
    1582. 

  1582.     memcpy (sd->paramcard, sd->parame, sizeof (sd->paramcard));
    1583. 

  1583. 

  1584.     // 装備品によるステータス変化はここで実行 
    1585. 

  1585.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    1586. 

  1586.     {
    1587. 

  1587.         //+++ skip arrow slot?
    1588. 

  1588.         if (i == 10)
    1589. 

  1589.             continue;
    1590. 

  1590. 

  1591.         index = sd->equip_index[i];
    1592. 

  1592.         if (index < 0 || index >= MAX_INVENTORY)
    1593. 

  1593.             continue;
    1594. 

  1594.         if (i == 9 && sd->equip_index[8] == index)
    1595. 

  1595.             continue;
    1596. 

  1596.         if (i == 5 && sd->equip_index[4] == index)
    1597. 

  1597.             continue;
    1598. 

  1598.         if (i == 6
    1599. 

  1599.             && (sd->equip_index[5] == index || sd->equip_index[4] == index))
    1600. 

  1600.             continue;
    1601. 

  1601.         if (sd->inventory_data[index])
    1602. 

  1602.         {
    1603. 

  1603.             sd->def += sd->inventory_data[index]->def;
    1604. 

  1604.             if (sd->inventory_data[index]->type == 4)
    1605. 

  1605.             {
    1606. 

  1606.                 int  r, wlv = sd->inventory_data[index]->wlv;
    1607. 

  1607.                 if (i == 8 && sd->status.inventory[index].equip == 0x20)
    1608. 

  1608.                 {
    1609. 

  1609.                     //二刀流用データ入力 
    1610. 

  1610.                     sd->watk_ += sd->inventory_data[index]->atk;
    1611. 

  1611.                     sd->watk_2 = (r = sd->status.inventory[index].refine) * // 精錬攻撃力 
    1612. 

  1612.                         refinebonus[wlv][0];
    1613. 

  1613.                     if ((r -= refinebonus[wlv][2]) > 0) // 過剰精錬ボーナス 
    1614. 

  1614.                         sd->overrefine_ = r * refinebonus[wlv][1];
    1615. 

  1615. 

  1616.                     if (sd->status.inventory[index].card[0] == 0x00ff)
    1617. 

  1617.                     {           // 製造武器 
    1618. 

  1618.                         sd->star_ = (sd->status.inventory[index].card[1] >> 8); // 星のかけら 
    1619. 

  1619.                         wele_ = (sd->status.inventory[index].card[1] & 0x0f);   // 属 性 
    1620. 

  1620.                     }
    1621. 

  1621.                     sd->attackrange_ += sd->inventory_data[index]->range;
    1622. 

  1622.                     sd->state.lr_flag = 1;
    1623. 

  1623.                     {
    1624. 

  1624.                         argrec_t arg[2];
    1625. 

  1625.                         arg[0].name = "@slotId";
    1626. 

  1626.                         arg[0].v.i = i;
    1627. 

  1627.                         arg[1].name = "@itemId";
    1628. 

  1628.                         arg[1].v.i = sd->inventory_data[index]->nameid;
    1629. 

  1629.                         run_script_l (sd->inventory_data[index]->equip_script, 0,
    1630. 

  1630.                                       sd->bl.id, 0, 2, arg);
    1631. 

  1631.                     }
    1632. 

  1632.                     sd->state.lr_flag = 0;
    1633. 

  1633.                 }
    1634. 

  1634.                 else
    1635. 

  1635.                 {               //二刀流武器以外 
    1636. 

  1636.                     argrec_t arg[2];
    1637. 

  1637.                     arg[0].name = "@slotId";
    1638. 

  1638.                     arg[0].v.i = i;
    1639. 

  1639.                     arg[1].name = "@itemId";
    1640. 

  1640.                     arg[1].v.i = sd->inventory_data[index]->nameid;
    1641. 

  1641.                     sd->watk += sd->inventory_data[index]->atk;
    1642. 

  1642.                     sd->watk2 += (r = sd->status.inventory[index].refine) * // 精錬攻撃力 
    1643. 

  1643.                         refinebonus[wlv][0];
    1644. 

  1644.                     if ((r -= refinebonus[wlv][2]) > 0)                     // 過剰精錬ボーナス
    1645. 

  1645.                         sd->overrefine += r * refinebonus[wlv][1];
    1646. 

  1646. 

  1647.                     if (sd->status.inventory[index].card[0] == 0x00ff)
    1648. 

  1648.                     {           // 製造武器 
    1649. 

  1649.                         sd->star += (sd->status.inventory[index].card[1] >> 8); // 星のかけら 
    1650. 

  1650.                         wele = (sd->status.inventory[index].card[1] & 0x0f);    // 属 性 
    1651. 

  1651.                     }
    1652. 

  1652.                     sd->attackrange += sd->inventory_data[index]->range;
    1653. 

  1653.                     run_script_l (sd->inventory_data[index]->equip_script, 0,
    1654. 

  1654.                                   sd->bl.id, 0, 2, arg);
    1655. 

  1655.                 }
    1656. 

  1656.             }
    1657. 

  1657.             else if (sd->inventory_data[index]->type == 5)
    1658. 

  1658.             {
    1659. 

  1659.                 argrec_t arg[2];
    1660. 

  1660.                 arg[0].name = "@slotId";
    1661. 

  1661.                 arg[0].v.i = i;
    1662. 

  1662.                 arg[1].name = "@itemId";
    1663. 

  1663.                 arg[1].v.i = sd->inventory_data[index]->nameid;
    1664. 

  1664.                 sd->watk += sd->inventory_data[index]->atk;
    1665. 

  1665.                 refinedef +=
    1666. 

  1666.                     sd->status.inventory[index].refine * refinebonus[0][0];
    1667. 

  1667.                 run_script_l (sd->inventory_data[index]->equip_script, 0,
    1668. 

  1668.                               sd->bl.id, 0, 2, arg);
    1669. 

  1669.             }
    1670. 

  1670.         }
    1671. 

  1671.     }
    1672. 

  1672. 

  1673.     if (battle_is_unarmed (&sd->bl))
    1674. 

  1674.     {
    1675. 

  1675.         sd->watk += skill_power (sd, TMW_BRAWLING) / 3; // +66 for 200
    1676. 

  1676.         sd->watk2 += skill_power (sd, TMW_BRAWLING) >> 3;   // +25 for 200
    1677. 

  1677.         sd->watk_ += skill_power (sd, TMW_BRAWLING) / 3;    // +66 for 200
    1678. 

  1678.         sd->watk_2 += skill_power (sd, TMW_BRAWLING) >> 3;  // +25 for 200
    1679. 

  1679.     }
    1680. 

  1680. 

  1681.     if (sd->equip_index[10] >= 0)
    1682. 

  1682.     {                           // 矢 
    1683. 

  1683.         index = sd->equip_index[10];
    1684. 

  1684.         if (sd->inventory_data[index])
    1685. 

  1685.           {                       //まだ属性が入っていない 
    1686. 

  1686.             argrec_t arg[2];
    1687. 

  1687.             arg[0].name = "@slotId";
    1688. 

  1688.             arg[0].v.i = i;
    1689. 

  1689.             arg[1].name = "@itemId";
    1690. 

  1690.             arg[1].v.i = sd->inventory_data[index]->nameid;
    1691. 

  1691.             sd->state.lr_flag = 2;
    1692. 

  1692.             run_script_l (sd->inventory_data[index]->equip_script, 0, sd->bl.id,
    1693. 

  1693.                         0, 2, arg);
    1694. 

  1694.             sd->state.lr_flag = 0;
    1695. 

  1695.             sd->arrow_atk += sd->inventory_data[index]->atk;
    1696. 

  1696.         }
    1697. 

  1697.     }
    1698. 

  1698.     sd->def += (refinedef + 50) / 100;
    1699. 

  1699. 

  1700.     if (sd->attackrange < 1)
    1701. 

  1701.         sd->attackrange = 1;
    1702. 

  1702.     if (sd->attackrange_ < 1)
    1703. 

  1703.         sd->attackrange_ = 1;
    1704. 

  1704.     if (sd->attackrange < sd->attackrange_)
    1705. 

  1705.         sd->attackrange = sd->attackrange_;
    1706. 

  1706.     if (sd->status.weapon == 11)
    1707. 

  1707.         sd->attackrange += sd->arrow_range;
    1708. 

  1708.     if (wele > 0)
    1709. 

  1709.         sd->atk_ele = wele;
    1710. 

  1710.     if (wele_ > 0)
    1711. 

  1711.         sd->atk_ele_ = wele_;
    1712. 

  1712.     if (def_ele > 0)
    1713. 

  1713.         sd->def_ele = def_ele;
    1714. 

  1714.     sd->double_rate += sd->double_add_rate;
    1715. 

  1715.     sd->perfect_hit += sd->perfect_hit_add;
    1716. 

  1716.     sd->get_zeny_num += sd->get_zeny_add_num;
    1717. 

  1717.     sd->splash_range += sd->splash_add_range;
    1718. 

  1718.     if (sd->speed_add_rate != 100)
    1719. 

  1719.         sd->speed_rate += sd->speed_add_rate - 100;
    1720. 

  1720.     if (sd->aspd_add_rate != 100)
    1721. 

  1721.         sd->aspd_rate += sd->aspd_add_rate - 100;
    1722. 

  1722. 

  1723.     // 武器ATKサイズ補正 (右手) 
    1724. 

  1724.     sd->atkmods[0] = atkmods[0][sd->weapontype1];
    1725. 

  1725.     sd->atkmods[1] = atkmods[1][sd->weapontype1];
    1726. 

  1726.     sd->atkmods[2] = atkmods[2][sd->weapontype1];
    1727. 

  1727.     //武器ATKサイズ補正 (左手) 
    1728. 

  1728.     sd->atkmods_[0] = atkmods[0][sd->weapontype2];
    1729. 

  1729.     sd->atkmods_[1] = atkmods[1][sd->weapontype2];
    1730. 

  1730.     sd->atkmods_[2] = atkmods[2][sd->weapontype2];
    1731. 

  1731. 

  1732. /*
    1733. 

  1733. 	// jobボーナス分 
    1734. 

  1734. 	for(i=0;i<sd->status.job_level && i<MAX_LEVEL;i++){
    1735. 

  1735. 		if(job_bonus[s_class.upper][s_class.job][i])
    1736. 

  1736. 			sd->paramb[job_bonus[s_class.upper][s_class.job][i]-1]++;
    1737. 

  1737. 	}
    1738. 

  1738. */
    1739. 

  1739. 

  1740.     if ((skill = pc_checkskill (sd, MC_INCCARRY)) > 0)  // skill can be used with an item now, thanks to orn [Valaris]
    1741. 

  1741.         sd->max_weight += skill * 1000;
    1742. 

  1742. 

  1743.     // ステータス変化による基本パラメータ補正 
    1744. 

  1744.     if (sd->sc_count)
    1745. 

  1745.     {
    1746. 

  1746.         if (sd->sc_data[SC_CONCENTRATE].timer != -1
    1747. 

  1747.             && sd->sc_data[SC_QUAGMIRE].timer == -1)
    1748. 

  1748.         {                       // 集中力向上 
    1749. 

  1749.             sd->paramb[1] +=
    1750. 

  1750.                 (sd->status.agi + sd->paramb[1] + sd->parame[1] -
    1751. 

  1751.                  sd->paramcard[1]) * (2 +
    1752. 

  1752.                                       sd->sc_data[SC_CONCENTRATE].val1) / 100;
    1753. 

  1753.             sd->paramb[4] +=
    1754. 

  1754.                 (sd->status.dex + sd->paramb[4] + sd->parame[4] -
    1755. 

  1755.                  sd->paramcard[4]) * (2 +
    1756. 

  1756.                                       sd->sc_data[SC_CONCENTRATE].val1) / 100;
    1757. 

  1757.         }
    1758. 

  1758.         if (sd->sc_data[SC_INCREASEAGI].timer != -1
    1759. 

  1759.             && sd->sc_data[SC_QUAGMIRE].timer == -1
    1760. 

  1760.             && sd->sc_data[SC_DONTFORGETME].timer == -1)
    1761. 

  1761.         {                       // 速度増加 
    1762. 

  1762.             sd->paramb[1] += 2 + sd->sc_data[SC_INCREASEAGI].val1;
    1763. 

  1763.             sd->speed -= sd->speed * 25 / 100;
    1764. 

  1764.         }
    1765. 

  1765.         if (sd->sc_data[SC_DECREASEAGI].timer != -1)    // 速度減少(agiはbattle.cで) 
    1766. 

  1766.             sd->speed = sd->speed * 125 / 100;
    1767. 

  1767.         if (sd->sc_data[SC_CLOAKING].timer != -1)
    1768. 

  1768.             sd->speed =
    1769. 

  1769.                 (sd->speed * (76 + (sd->sc_data[SC_INCREASEAGI].val1 * 3))) /
    1770. 

  1770.                 100;
    1771. 

  1771.         if (sd->sc_data[SC_BLESSING].timer != -1)
    1772. 

  1772.           {                       // ブレッシング 
    1773. 

  1773.             sd->paramb[0] += sd->sc_data[SC_BLESSING].val1;
    1774. 

  1774.             sd->paramb[3] += sd->sc_data[SC_BLESSING].val1;
    1775. 

  1775.             sd->paramb[4] += sd->sc_data[SC_BLESSING].val1;
    1776. 

  1776.         }
    1777. 

  1777.         if (sd->sc_data[SC_GLORIA].timer != -1) // グロリア
    1778. 

  1778.             sd->paramb[5] += 30;
    1779. 

  1779.         if (sd->sc_data[SC_LOUD].timer != -1 && sd->sc_data[SC_QUAGMIRE].timer == -1)   // ラウドボイス 
    1780. 

  1780.             sd->paramb[0] += 4;
    1781. 

  1781.         if (sd->sc_data[SC_QUAGMIRE].timer != -1)
    1782. 

  1782.           {                       // クァグマイア 
    1783. 

  1783.             sd->speed = sd->speed * 3 / 2;
    1784. 

  1784.             sd->paramb[1] -=
    1785. 

  1785.                 (sd->status.agi + sd->paramb[1] + sd->parame[1]) / 2;
    1786. 

  1786.             sd->paramb[4] -=
    1787. 

  1787.                 (sd->status.dex + sd->paramb[4] + sd->parame[4]) / 2;
    1788. 

  1788.         }
    1789. 

  1789.         if (sd->sc_data[SC_TRUESIGHT].timer != -1)
    1790. 

  1790.           {                       // トゥルーサイト 
    1791. 

  1791.             sd->paramb[0] += 5;
    1792. 

  1792.             sd->paramb[1] += 5;
    1793. 

  1793.             sd->paramb[2] += 5;
    1794. 

  1794.             sd->paramb[3] += 5;
    1795. 

  1795.             sd->paramb[4] += 5;
    1796. 

  1796.             sd->paramb[5] += 5;
    1797. 

  1797.         }
    1798. 

  1798.     }
    1799. 

  1799.     sd->speed -= skill_power (sd, TMW_SPEED) >> 3;
    1800. 

  1800.     sd->aspd_rate -= skill_power (sd, TMW_SPEED) / 10;
    1801. 

  1801.     if (sd->aspd_rate < 20)
    1802. 

  1802.         sd->aspd_rate = 20;
    1803. 

  1803. 

  1804. /*
    1805. 

  1805. 	//1度も死んでないJob70スパノビに+10 
    1806. 

  1806. 	if(s_class.job == 23 && sd->die_counter == 0 && sd->status.job_level >= 70){
    1807. 

  1807. 		sd->paramb[0]+= 15;
    1808. 

  1808. 		sd->paramb[1]+= 15;
    1809. 

  1809. 		sd->paramb[2]+= 15;
    1810. 

  1810. 		sd->paramb[3]+= 15;
    1811. 

  1811. 		sd->paramb[4]+= 15;
    1812. 

  1812. 		sd->paramb[5]+= 15;
    1813. 

  1813. 	}
    1814. 

  1814. */
    1815. 

  1815.     sd->paramc[0] = sd->status.str + sd->paramb[0] + sd->parame[0];
    1816. 

  1816.     sd->paramc[1] = sd->status.agi + sd->paramb[1] + sd->parame[1];
    1817. 

  1817.     sd->paramc[2] = sd->status.vit + sd->paramb[2] + sd->parame[2];
    1818. 

  1818.     sd->paramc[3] = sd->status.int_ + sd->paramb[3] + sd->parame[3];
    1819. 

  1819.     sd->paramc[4] = sd->status.dex + sd->paramb[4] + sd->parame[4];
    1820. 

  1820.     sd->paramc[5] = sd->status.luk + sd->paramb[5] + sd->parame[5];
    1821. 

  1821.     for (i = 0; i < 6; i++)
    1822. 

  1822.         if (sd->paramc[i] < 0)
    1823. 

  1823.             sd->paramc[i] = 0;
    1824. 

  1824. 

  1825.     if (sd->status.weapon == 11 || sd->status.weapon == 13
    1826. 

  1826.         || sd->status.weapon == 14)
    1827. 

  1827.     {
    1828. 

  1828.         str = sd->paramc[4];
    1829. 

  1829.         dex = sd->paramc[0];
    1830. 

  1830.     }
    1831. 

  1831.     else
    1832. 

  1832.     {
    1833. 

  1833.         str = sd->paramc[0];
    1834. 

  1834.         dex = sd->paramc[4];
    1835. 

  1835.         sd->critical += ((dex * 3) >> 1);
    1836. 

  1836.     }
    1837. 

  1837.     dstr = str / 10;
    1838. 

  1838.     sd->base_atk += str + dstr * dstr + dex / 5 + sd->paramc[5] / 5;
    1839. 

  1839. //fprintf(stderr, "baseatk = %d = x + %d + %d + %d + %d\n", sd->base_atk, str, dstr*dstr, dex/5, sd->paramc[5]/5);
    1840. 

  1840.     sd->matk1 += sd->paramc[3] + (sd->paramc[3] / 5) * (sd->paramc[3] / 5);
    1841. 

  1841.     sd->matk2 += sd->paramc[3] + (sd->paramc[3] / 7) * (sd->paramc[3] / 7);
    1842. 

  1842.     if (sd->matk1 < sd->matk2)
    1843. 

  1843.     {
    1844. 

  1844.         int  temp = sd->matk2;
    1845. 

  1845.         sd->matk2 = sd->matk1;
    1846. 

  1846.         sd->matk1 = temp;
    1847. 

  1847.     }
    1848. 

  1848.     // [Fate] New tmw magic system
    1849. 

  1849.     sd->matk1 += sd->status.base_level + sd->spellpower_bonus_current;
    1850. 

  1850. #ifdef USE_ASTRAL_SOUL_SKILL
    1851. 

  1851.     if (sd->matk1 > MAGIC_SKILL_THRESHOLD)
    1852. 

  1852.     {
    1853. 

  1853.         int  bonus = sd->matk1 - MAGIC_SKILL_THRESHOLD;
    1854. 

  1854.         // Ok if you are above a certain threshold, you get only (1/8) of that matk1
    1855. 

  1855.         // if you have Astral soul skill you can get the whole power again (and additionally the 1/8 added)
    1856. 

  1856.         sd->matk1 = MAGIC_SKILL_THRESHOLD + (bonus>>3) + ((3*bonus*skill_power(sd, TMW_ASTRAL_SOUL))>>9);
    1857. 

  1857.     }
    1858. 

  1858. #endif
    1859. 

  1859.     sd->matk2 = 0;
    1860. 

  1860.     if (sd->matk1 < 0)
    1861. 

  1861.         sd->matk1 = 0;
    1862. 

  1862. 

  1863.     sd->hit += sd->paramc[4] + sd->status.base_level;
    1864. 

  1864.     sd->flee += sd->paramc[1] + sd->status.base_level;
    1865. 

  1865.     sd->def2 += sd->paramc[2];
    1866. 

  1866.     sd->mdef2 += sd->paramc[3];
    1867. 

  1867.     sd->flee2 += sd->paramc[5] + 10;
    1868. 

  1868.     sd->critical += (sd->paramc[5] * 3) + 10;
    1869. 

  1869. 

  1870.     // 200 is the maximum of the skill
    1871. 

  1871.     // so critical chance can get multiplied by ~1.5 and setting def2 to a third when skill maxed out
    1872. 

  1872.     // def2 is the defence gained by vit, whereas "def", which is gained by armor, stays as is
    1873. 

  1873.     int spbsk = skill_power (sd, TMW_RAGING);
    1874. 

  1874.     if (spbsk!=0) {
    1875. 

  1875.         sd->critical *= (128 + spbsk)/256;
    1876. 

  1876.         sd->def2 /=      (128 + spbsk)/128;
    1877. 

  1877.     }
    1878. 

  1878. 

  1879.     if (sd->base_atk < 1)
    1880. 

  1880.         sd->base_atk = 1;
    1881. 

  1881.     if (sd->critical_rate != 100)
    1882. 

  1882.         sd->critical = (sd->critical * sd->critical_rate) / 100;
    1883. 

  1883.     if (sd->critical < 10)
    1884. 

  1884.         sd->critical = 10;
    1885. 

  1885.     if (sd->hit_rate != 100)
    1886. 

  1886.         sd->hit = (sd->hit * sd->hit_rate) / 100;
    1887. 

  1887.     if (sd->hit < 1)
    1888. 

  1888.         sd->hit = 1;
    1889. 

  1889.     if (sd->flee_rate != 100)
    1890. 

  1890.         sd->flee = (sd->flee * sd->flee_rate) / 100;
    1891. 

  1891.     if (sd->flee < 1)
    1892. 

  1892.         sd->flee = 1;
    1893. 

  1893.     if (sd->flee2_rate != 100)
    1894. 

  1894.         sd->flee2 = (sd->flee2 * sd->flee2_rate) / 100;
    1895. 

  1895.     if (sd->flee2 < 10)
    1896. 

  1896.         sd->flee2 = 10;
    1897. 

  1897.     if (sd->def_rate != 100)
    1898. 

  1898.         sd->def = (sd->def * sd->def_rate) / 100;
    1899. 

  1899.     if (sd->def < 0)
    1900. 

  1900.         sd->def = 0;
    1901. 

  1901.     if (sd->def2_rate != 100)
    1902. 

  1902.         sd->def2 = (sd->def2 * sd->def2_rate) / 100;
    1903. 

  1903.     if (sd->def2 < 1)
    1904. 

  1904.         sd->def2 = 1;
    1905. 

  1905.     if (sd->mdef_rate != 100)
    1906. 

  1906.         sd->mdef = (sd->mdef * sd->mdef_rate) / 100;
    1907. 

  1907.     if (sd->mdef < 0)
    1908. 

  1908.         sd->mdef = 0;
    1909. 

  1909.     if (sd->mdef2_rate != 100)
    1910. 

  1910.         sd->mdef2 = (sd->mdef2 * sd->mdef2_rate) / 100;
    1911. 

  1911.     if (sd->mdef2 < 1)
    1912. 

  1912.         sd->mdef2 = 1;
    1913. 

  1913. 

  1914.     // 二刀流 ASPD 修正 
    1915. 

  1915.     if (sd->status.weapon <= 16)
    1916. 

  1916.         sd->aspd +=
    1917. 

  1917.             aspd_base[s_class.job][sd->status.weapon] - (sd->paramc[1] * 4 +
    1918. 

  1918.                                                          sd->paramc[4]) *
    1919. 

  1919.             aspd_base[s_class.job][sd->status.weapon] / 1000;
    1920. 

  1920.     else
    1921. 

  1921.         sd->aspd += ((aspd_base[s_class.job][sd->weapontype1] -
    1922. 

  1922.                       (sd->paramc[1] * 4 +
    1923. 

  1923.                        sd->paramc[4]) *
    1924. 

  1924.                       aspd_base[s_class.job][sd->weapontype1] / 1000) +
    1925. 

  1925.                      (aspd_base[s_class.job][sd->weapontype2] -
    1926. 

  1926.                       (sd->paramc[1] * 4 +
    1927. 

  1927.                        sd->paramc[4]) *
    1928. 

  1928.                       aspd_base[s_class.job][sd->weapontype2] / 1000)) * 140 /
    1929. 

  1929.             200;
    1930. 

  1930. 

  1931.     aspd_rate = sd->aspd_rate;
    1932. 

  1932. 

  1933.     //攻撃速度増加 
    1934. 

  1934. 

  1935.     if ((skill = pc_checkskill (sd, AC_VULTURE)) > 0)
    1936. 

  1936.      {                           // ワシの目 
    1937. 

  1937.         sd->hit += skill;
    1938. 

  1938.         if (sd->status.weapon == 11)
    1939. 

  1939.             sd->attackrange += skill;
    1940. 

  1940.     }
    1941. 

  1941. 

  1942.     if (sd->attackrange > 2)
    1943. 

  1943.     {                           // [fate] ranged weapon?
    1944. 

  1944.         sd->attackrange += MIN (skill_power (sd, AC_OWL) / 60, 3);
    1945. 

  1945.         sd->hit += skill_power (sd, AC_OWL) / 10;   // 20 for 200
    1946. 

  1946.     }
    1947. 

  1947. 

  1948.     if ((skill = pc_checkskill (sd, BS_WEAPONRESEARCH)) > 0)    // 武器研究の命中率増加 
    1949. 

  1949.         sd->hit += skill * 2;
    1950. 

  1950.     if (sd->status.option & 2 && (skill = pc_checkskill (sd, RG_TUNNELDRIVE)) > 0)  // トンネルドライブ // トンネルドライブ 
    1951. 

  1951.         sd->speed += (1.2 * DEFAULT_WALK_SPEED - skill * 9);
    1952. 

  1952.     if (pc_iscarton (sd) && (skill = pc_checkskill (sd, MC_PUSHCART)) > 0)  // カートによる速度低下 
    1953. 

  1953.         sd->speed += (10 - skill) * (DEFAULT_WALK_SPEED * 0.1);
    1954. 

  1954.     else if (pc_isriding (sd))  // ペコペコ乗りによる速度増加 
    1955. 

  1955.         sd->speed -= (0.25 * DEFAULT_WALK_SPEED);
    1956. 

  1956.     sd->max_weight += 1000;
    1957. 

  1957.     if (sd->sc_count)
    1958. 

  1958.     {
    1959. 

  1959.         if (sd->sc_data[SC_WINDWALK].timer != -1)   //ウィンドウォーク時はLv*2%減算 
    1960. 

  1960.             sd->speed -=
    1961. 

  1961.                 sd->speed * (sd->sc_data[SC_WINDWALK].val1 * 2) / 100;
    1962. 

  1962.         if (sd->sc_data[SC_CARTBOOST].timer != -1)  // カートブースト 
    1963. 

  1963.             sd->speed -= (DEFAULT_WALK_SPEED * 20) / 100;
    1964. 

  1964.         if (sd->sc_data[SC_BERSERK].timer != -1)    //バーサーク中はIAと同じぐらい速い？ 
    1965. 

  1965.             sd->speed -= sd->speed * 25 / 100;
    1966. 

  1966.         if (sd->sc_data[SC_WEDDING].timer != -1)    //結婚中は歩くのが遅い 
    1967. 

  1967.             sd->speed = 2 * DEFAULT_WALK_SPEED;
    1968. 

  1968.     }
    1969. 

  1969. 

  1970.     if ((skill = pc_checkskill (sd, CR_TRUST)) > 0)
    1971. 

  1971.      {                           // フェイス 
    1972. 

  1972.         sd->status.max_hp += skill * 200;
    1973. 

  1973.         sd->subele[6] += skill * 5;
    1974. 

  1974.     }
    1975. 

  1975.     if ((skill = pc_checkskill (sd, BS_SKINTEMPER)) > 0)
    1976. 

  1976.         sd->subele[3] += skill * 4;
    1977. 

  1977. 

  1978.     bl = sd->status.base_level;
    1979. 

  1979. 

  1980.     sd->status.max_hp +=
    1981. 

  1981.         (3500 + bl * hp_coefficient2[s_class.job] +
    1982. 

  1982.          hp_sigma_val[s_class.job][(bl > 0) ? bl - 1 : 0]) / 100 * (100 +
    1983. 

  1983.                                                                     sd->paramc
    1984. 

  1984.                                                                     [2]) /
    1985. 

  1985.         100 + (sd->parame[2] - sd->paramcard[2]);
    1986. 

  1986.     if (s_class.upper == 1)     // [MouseJstr]
    1987. 

  1987.         sd->status.max_hp = sd->status.max_hp * 130 / 100;
    1988. 

  1988.     if (sd->hprate != 100)
    1989. 

  1989.         sd->status.max_hp = sd->status.max_hp * sd->hprate / 100;
    1990. 

  1990. 

  1991.     if (sd->sc_data && sd->sc_data[SC_BERSERK].timer != -1)
    1992. 

  1992.      {                           // バーサーク 
    1993. 

  1993.         sd->status.max_hp = sd->status.max_hp * 3;
    1994. 

  1994.         sd->status.hp = sd->status.hp * 3;
    1995. 

  1995.         if (sd->status.max_hp > battle_config.max_hp)   // removed negative max hp bug by Valaris
    1996. 

  1996.             sd->status.max_hp = battle_config.max_hp;
    1997. 

  1997.         if (sd->status.hp > battle_config.max_hp)   // removed negative max hp bug by Valaris
    1998. 

  1998.             sd->status.hp = battle_config.max_hp;
    1999. 

  1999.     }
    2000. 

  2000.     if (s_class.job == 23 && sd->status.base_level >= 99)
    2001. 

  2001.     {
    2002. 

  2002.         sd->status.max_hp = sd->status.max_hp + 2000;
    2003. 

  2003.     }
    2004. 

  2004. 

  2005.     if (sd->status.max_hp > battle_config.max_hp)   // removed negative max hp bug by Valaris
    2006. 

  2006.         sd->status.max_hp = battle_config.max_hp;
    2007. 

  2007.     if (sd->status.max_hp <= 0)
    2008. 

  2008.         sd->status.max_hp = 1;  // end
    2009. 

  2009. 

  2010.     // 最大SP計算 
    2011. 

  2011.     sd->status.max_sp +=
    2012. 

  2012.         ((sp_coefficient[s_class.job] * bl) + 1000) / 100 * (100 +
    2013. 

  2013.                                                              sd->paramc[3]) /
    2014. 

  2014.         100 + (sd->parame[3] - sd->paramcard[3]);
    2015. 

  2015.     if (s_class.upper == 1)     // [MouseJstr]
    2016. 

  2016.         sd->status.max_sp = sd->status.max_sp * 130 / 100;
    2017. 

  2017.     if (sd->sprate != 100)
    2018. 

  2018.         sd->status.max_sp = sd->status.max_sp * sd->sprate / 100;
    2019. 

  2019. 

  2020.     if ((skill = pc_checkskill (sd, HP_MEDITATIO)) > 0) // メディテイティオ 
    2021. 

  2021.         sd->status.max_sp += sd->status.max_sp * skill / 100;
    2022. 

  2022.     if ((skill = pc_checkskill (sd, HW_SOULDRAIN)) > 0) /* ソウルドレイン */ 
    2023. 

  2023.         sd->status.max_sp += sd->status.max_sp * 2 * skill / 100;
    2024. 

  2024. 

  2025.     if (sd->status.max_sp < 0 || sd->status.max_sp > battle_config.max_sp)
    2026. 

  2026.         sd->status.max_sp = battle_config.max_sp;
    2027. 

  2027. 

  2028.     //自然回復HP 
    2029. 

  2029.     sd->nhealhp = 1 + (sd->paramc[2] / 5) + (sd->status.max_hp / 200);
    2030. 

  2030.     if ((skill = pc_checkskill (sd, SM_RECOVERY)) > 0)
    2031. 

  2031.     {                           /* HP回復力向上 */ 
    2032. 

  2032.         sd->nshealhp = skill * 5 + (sd->status.max_hp * skill / 500);
    2033. 

  2033.         if (sd->nshealhp > 0x7fff)
    2034. 

  2034.             sd->nshealhp = 0x7fff;
    2035. 

  2035.     }
    2036. 

  2036.     //自然回復SP 
    2037. 

  2037.     sd->nhealsp = 1 + (sd->paramc[3] / 6) + (sd->status.max_sp / 100);
    2038. 

  2038.     if (sd->paramc[3] >= 120)
    2039. 

  2039.         sd->nhealsp += ((sd->paramc[3] - 120) >> 1) + 4;
    2040. 

  2040.     if ((skill = pc_checkskill (sd, MG_SRECOVERY)) > 0)
    2041. 

  2041.     {                           /* SP回復力向上 */ 
    2042. 

  2042.         sd->nshealsp = skill * 3 + (sd->status.max_sp * skill / 500);
    2043. 

  2043.         if (sd->nshealsp > 0x7fff)
    2044. 

  2044.             sd->nshealsp = 0x7fff;
    2045. 

  2045.     }
    2046. 

  2046. 

  2047.     if ((skill = pc_checkskill (sd, MO_SPIRITSRECOVERY)) > 0)
    2048. 

  2048.     {
    2049. 

  2049.         sd->nsshealhp = skill * 4 + (sd->status.max_hp * skill / 500);
    2050. 

  2050.         sd->nsshealsp = skill * 2 + (sd->status.max_sp * skill / 500);
    2051. 

  2051.         if (sd->nsshealhp > 0x7fff)
    2052. 

  2052.             sd->nsshealhp = 0x7fff;
    2053. 

  2053.         if (sd->nsshealsp > 0x7fff)
    2054. 

  2054.             sd->nsshealsp = 0x7fff;
    2055. 

  2055.     }
    2056. 

  2056.     if (sd->hprecov_rate != 100)
    2057. 

  2057.     {
    2058. 

  2058.         sd->nhealhp = sd->nhealhp * sd->hprecov_rate / 100;
    2059. 

  2059.         if (sd->nhealhp < 1)
    2060. 

  2060.             sd->nhealhp = 1;
    2061. 

  2061.     }
    2062. 

  2062.     if (sd->sprecov_rate != 100)
    2063. 

  2063.     {
    2064. 

  2064.         sd->nhealsp = sd->nhealsp * sd->sprecov_rate / 100;
    2065. 

  2065.         if (sd->nhealsp < 1)
    2066. 

  2066.             sd->nhealsp = 1;
    2067. 

  2067.     }
    2068. 

  2068.     if ((skill = pc_checkskill (sd, HP_MEDITATIO)) > 0)
    2069. 

  2069.      {                           // メディテイティオはSPRではなく自然回復にかかる 
    2070. 

  2070.         sd->nhealsp += 3 * skill * (sd->status.max_sp) / 100;
    2071. 

  2071.         if (sd->nhealsp > 0x7fff)
    2072. 

  2072.             sd->nhealsp = 0x7fff;
    2073. 

  2073.     }
    2074. 

  2074. 

  2075.     // 種族耐性（これでいいの？ ディバインプロテクションと同じ処理がいるかも） 
    2076. 

  2076.     if ((skill = pc_checkskill (sd, SA_DRAGONOLOGY)) > 0)
    2077. 

  2077.      {                           // ドラゴノロジー 
    2078. 

  2078.         skill = skill * 4;
    2079. 

  2079.         sd->addrace[9] += skill;
    2080. 

  2080.         sd->addrace_[9] += skill;
    2081. 

  2081.         sd->subrace[9] += skill;
    2082. 

  2082.         sd->magic_addrace[9] += skill;
    2083. 

  2083.         sd->magic_subrace[9] -= skill;
    2084. 

  2084.     }
    2085. 

  2085. 

  2086.     //Flee上昇 
    2087. 

  2087.     if ((skill = pc_checkskill (sd, TF_MISS)) > 0)
    2088. 

  2088.     {                          // 回避率増加 
    2089. 

  2089.         if (sd->status.class == 6 || sd->status.class == 4007
    2090. 

  2090.             || sd->status.class == 23)
    2091. 

  2091.         {
    2092. 

  2092.             sd->flee += skill * 3;
    2093. 

  2093.         }
    2094. 

  2094.         if (sd->status.class == 12 || sd->status.class == 17
    2095. 

  2095.             || sd->status.class == 4013 || sd->status.class == 4018)
    2096. 

  2096.             sd->flee += skill * 4;
    2097. 

  2097.         if (sd->status.class == 12 || sd->status.class == 4013)
    2098. 

  2098.             sd->speed -= sd->speed * (skill * .5) / 100;
    2099. 

  2099.     }
    2100. 

  2100.     if ((skill = pc_checkskill (sd, MO_DODGE)) > 0) // 見切り 
    2101. 

  2101.         sd->flee += (skill * 3) >> 1;
    2102. 

  2102. 

  2103.      // スキルやステータス異常による残りのパラメータ補正 
    2104. 

  2104.     if (sd->sc_count)
    2105. 

  2105.     {
    2106. 

  2106.         // ATK/DEF変化形 
    2107. 

  2107.         if (sd->sc_data[SC_ANGELUS].timer != -1)    // エンジェラス 
    2108. 

  2108.             sd->def2 =
    2109. 

  2109.                 sd->def2 * (110 + 5 * sd->sc_data[SC_ANGELUS].val1) / 100;
    2110. 

  2110.         if (sd->sc_data[SC_IMPOSITIO].timer != -1)
    2111. 

  2111.           {                       // インポシティオマヌス 
    2112. 

  2112.             sd->watk += sd->sc_data[SC_IMPOSITIO].val1 * 5;
    2113. 

  2113.             index = sd->equip_index[8];
    2114. 

  2114.             if (index >= 0 && sd->inventory_data[index]
    2115. 

  2115.                 && sd->inventory_data[index]->type == 4)
    2116. 

  2116.                 sd->watk_ += sd->sc_data[SC_IMPOSITIO].val1 * 5;
    2117. 

  2117.         }
    2118. 

  2118.         if (sd->sc_data[SC_PROVOKE].timer != -1)
    2119. 

  2119.           {                      // プロボック 
    2120. 

  2120.             sd->def2 =
    2121. 

  2121.                 sd->def2 * (100 - 6 * sd->sc_data[SC_PROVOKE].val1) / 100;
    2122. 

  2122.             sd->base_atk =
    2123. 

  2123.                 sd->base_atk * (100 + 2 * sd->sc_data[SC_PROVOKE].val1) / 100;
    2124. 

  2124.             sd->watk =
    2125. 

  2125.                 sd->watk * (100 + 2 * sd->sc_data[SC_PROVOKE].val1) / 100;
    2126. 

  2126.             index = sd->equip_index[8];
    2127. 

  2127.             if (index >= 0 && sd->inventory_data[index]
    2128. 

  2128.                 && sd->inventory_data[index]->type == 4)
    2129. 

  2129.                 sd->watk_ =
    2130. 

  2130.                     sd->watk_ * (100 +
    2131. 

  2131.                                  2 * sd->sc_data[SC_PROVOKE].val1) / 100;
    2132. 

  2132.         }
    2133. 

  2133.         if (sd->sc_data[SC_ENDURE].timer != -1)
    2134. 

  2134.             sd->mdef2 += sd->sc_data[SC_ENDURE].val1;
    2135. 

  2135.         if (sd->sc_data[SC_MINDBREAKER].timer != -1)
    2136. 

  2136.           {                       // プロボック 
    2137. 

  2137.             sd->mdef2 =
    2138. 

  2138.                 sd->mdef2 * (100 -
    2139. 

  2139.                              6 * sd->sc_data[SC_MINDBREAKER].val1) / 100;
    2140. 

  2140.             sd->matk1 =
    2141. 

  2141.                 sd->matk1 * (100 +
    2142. 

  2142.                              2 * sd->sc_data[SC_MINDBREAKER].val1) / 100;
    2143. 

  2143.             sd->matk2 =
    2144. 

  2144.                 sd->matk2 * (100 +
    2145. 

  2145.                              2 * sd->sc_data[SC_MINDBREAKER].val1) / 100;
    2146. 

  2146.         }
    2147. 

  2147.         if (sd->sc_data[SC_POISON].timer != -1) // 毒状態 
    2148. 

  2148.             sd->def2 = sd->def2 * 75 / 100;
    2149. 

  2149.         if (sd->sc_data[SC_DRUMBATTLE].timer != -1)
    2150. 

  2150.         {                       // 戦太鼓の響き 
    2151. 

  2151.             sd->watk += sd->sc_data[SC_DRUMBATTLE].val2;
    2152. 

  2152.             sd->def += sd->sc_data[SC_DRUMBATTLE].val3;
    2153. 

  2153.             index = sd->equip_index[8];
    2154. 

  2154.             if (index >= 0 && sd->inventory_data[index]
    2155. 

  2155.                 && sd->inventory_data[index]->type == 4)
    2156. 

  2156.                 sd->watk_ += sd->sc_data[SC_DRUMBATTLE].val2;
    2157. 

  2157.         }
    2158. 

  2158.         if (sd->sc_data[SC_NIBELUNGEN].timer != -1)
    2159. 

  2159.           {                       // ニーベルングの指輪 
    2160. 

  2160.             index = sd->equip_index[9];
    2161. 

  2161.             if (index >= 0 && sd->inventory_data[index]
    2162. 

  2162.                 && sd->inventory_data[index]->wlv == 3)
    2163. 

  2163.                 sd->watk += sd->sc_data[SC_NIBELUNGEN].val3;
    2164. 

  2164.             index = sd->equip_index[8];
    2165. 

  2165.             if (index >= 0 && sd->inventory_data[index]
    2166. 

  2166.                 && sd->inventory_data[index]->wlv == 3)
    2167. 

  2167.                 sd->watk_ += sd->sc_data[SC_NIBELUNGEN].val3;
    2168. 

  2168.             if (index >= 0 && sd->inventory_data[index]
    2169. 

  2169.                 && sd->inventory_data[index]->wlv == 4)
    2170. 

  2170.                 sd->watk += sd->sc_data[SC_NIBELUNGEN].val2;
    2171. 

  2171.             index = sd->equip_index[8];
    2172. 

  2172.             if (index >= 0 && sd->inventory_data[index]
    2173. 

  2173.                 && sd->inventory_data[index]->wlv == 4)
    2174. 

  2174.                 sd->watk_ += sd->sc_data[SC_NIBELUNGEN].val2;
    2175. 

  2175.         }
    2176. 

  2176. 

  2177.         if (sd->sc_data[SC_VOLCANO].timer != -1 && sd->def_ele == 3)
    2178. 

  2178.           {                       // ボルケーノ 
    2179. 

  2179.             sd->watk += sd->sc_data[SC_VIOLENTGALE].val3;
    2180. 

  2180.         }
    2181. 

  2181. 

  2182.         if (sd->sc_data[SC_SIGNUMCRUCIS].timer != -1)
    2183. 

  2183.             sd->def =
    2184. 

  2184.                 sd->def * (100 - sd->sc_data[SC_SIGNUMCRUCIS].val2) / 100;
    2185. 

  2185.         if (sd->sc_data[SC_ETERNALCHAOS].timer != -1)   // エターナルカオス 
    2186. 

  2186.             sd->def = 0;
    2187. 

  2187. 

  2188.         if (sd->sc_data[SC_CONCENTRATION].timer != -1)
    2189. 

  2189.           {                       //コンセントレーション 
    2190. 

  2190.             sd->watk =
    2191. 

  2191.                 sd->watk * (100 +
    2192. 

  2192.                             5 * sd->sc_data[SC_CONCENTRATION].val1) / 100;
    2193. 

  2193.             index = sd->equip_index[8];
    2194. 

  2194.             if (index >= 0 && sd->inventory_data[index]
    2195. 

  2195.                 && sd->inventory_data[index]->type == 4)
    2196. 

  2196.                 sd->watk_ =
    2197. 

  2197.                     sd->watk * (100 +
    2198. 

  2198.                                 5 * sd->sc_data[SC_CONCENTRATION].val1) / 100;
    2199. 

  2199.             sd->def =
    2200. 

  2200.                 sd->def * (100 -
    2201. 

  2201.                            5 * sd->sc_data[SC_CONCENTRATION].val1) / 100;
    2202. 

  2202.         }
    2203. 

  2203. 

  2204.         if (sd->sc_data[SC_MAGICPOWER].timer != -1)
    2205. 

  2205.         {                       //魔法力増幅 
    2206. 

  2206.             sd->matk1 =
    2207. 

  2207.                 sd->matk1 * (100 + 2 * sd->sc_data[SC_MAGICPOWER].val1) / 100;
    2208. 

  2208.             sd->matk2 =
    2209. 

  2209.                 sd->matk2 * (100 + 2 * sd->sc_data[SC_MAGICPOWER].val1) / 100;
    2210. 

  2210.         }
    2211. 

  2211.         if (sd->sc_data[SC_ATKPOT].timer != -1)
    2212. 

  2212.             sd->watk += sd->sc_data[SC_ATKPOT].val1;
    2213. 

  2213.         if (sd->sc_data[SC_MATKPOT].timer != -1)
    2214. 

  2214.         {
    2215. 

  2215.             sd->matk1 += sd->sc_data[SC_MATKPOT].val1;
    2216. 

  2216.             sd->matk2 += sd->sc_data[SC_MATKPOT].val1;
    2217. 

  2217.         }
    2218. 

  2218. 

  2219.         // ASPD/移動速度変化系 
    2220. 

  2220.         if (sd->sc_data[SC_TWOHANDQUICKEN].timer != -1 && sd->sc_data[SC_QUAGMIRE].timer == -1 && sd->sc_data[SC_DONTFORGETME].timer == -1) // 2HQ
    2221. 

  2221.             aspd_rate -= 30;
    2222. 

  2222.         if (sd->sc_data[SC_ADRENALINE].timer != -1
    2223. 

  2223.             && sd->sc_data[SC_TWOHANDQUICKEN].timer == -1
    2224. 

  2224.             && sd->sc_data[SC_QUAGMIRE].timer == -1
    2225. 

  2225.             && sd->sc_data[SC_DONTFORGETME].timer == -1)
    2226. 

  2226.           {                       // アドレナリンラッシュ 
    2227. 

  2227.             if (sd->sc_data[SC_ADRENALINE].val2
    2228. 

  2228.                 || !battle_config.party_skill_penaly)
    2229. 

  2229.                 aspd_rate -= 30;
    2230. 

  2230.             else
    2231. 

  2231.                 aspd_rate -= 25;
    2232. 

  2232.         }
    2233. 

  2233.         if (sd->sc_data[SC_SPEARSQUICKEN].timer != -1 && sd->sc_data[SC_ADRENALINE].timer == -1 && sd->sc_data[SC_TWOHANDQUICKEN].timer == -1 && sd->sc_data[SC_QUAGMIRE].timer == -1 && sd->sc_data[SC_DONTFORGETME].timer == -1)  // スピアクィッケン 
    2234. 

  2234.             aspd_rate -= sd->sc_data[SC_SPEARSQUICKEN].val2;
    2235. 

  2235.         if (sd->sc_data[SC_ASSNCROS].timer != -1 &&                     // 夕陽のアサシンクロス 
    2236. 

  2236.             sd->sc_data[SC_TWOHANDQUICKEN].timer == -1
    2237. 

  2237.             && sd->sc_data[SC_ADRENALINE].timer == -1
    2238. 

  2238.             && sd->sc_data[SC_SPEARSQUICKEN].timer == -1
    2239. 

  2239.             && sd->sc_data[SC_DONTFORGETME].timer == -1)
    2240. 

  2240.             aspd_rate -=
    2241. 

  2241.                 5 + sd->sc_data[SC_ASSNCROS].val1 +
    2242. 

  2242.                 sd->sc_data[SC_ASSNCROS].val2 + sd->sc_data[SC_ASSNCROS].val3;
    2243. 

  2243.         if (sd->sc_data[SC_DONTFORGETME].timer != -1)
    2244. 

  2244.         {                       // 私を忘れないで 
    2245. 

  2245.             aspd_rate +=
    2246. 

  2246.                 sd->sc_data[SC_DONTFORGETME].val1 * 3 +
    2247. 

  2247.                 sd->sc_data[SC_DONTFORGETME].val2 +
    2248. 

  2248.                 (sd->sc_data[SC_DONTFORGETME].val3 >> 16);
    2249. 

  2249.             sd->speed =
    2250. 

  2250.                 sd->speed * (100 + sd->sc_data[SC_DONTFORGETME].val1 * 2 +
    2251. 

  2251.                              sd->sc_data[SC_DONTFORGETME].val2 +
    2252. 

  2252.                              (sd->sc_data[SC_DONTFORGETME].val3 & 0xffff)) /
    2253. 

  2253.                 100;
    2254. 

  2254.         }
    2255. 

  2255.         if (sd->sc_data[i = SC_SPEEDPOTION2].timer != -1 || sd->sc_data[i = SC_SPEEDPOTION1].timer != -1 || sd->sc_data[i = SC_SPEEDPOTION0].timer != -1)   
    2256. 

  2256. 						// 増 速ポーション 
    2257. 

  2257.             aspd_rate -= sd->sc_data[i].val1;
    2258. 

  2258. 

  2259.         if (sd->sc_data[SC_HASTE].timer != -1)
    2260. 

  2260.             aspd_rate -= sd->sc_data[SC_HASTE].val1;
    2261. 

  2261. 

  2262.         /* Slow down if protected */
    2263. 

  2263. 

  2264.         if (sd->sc_data[SC_PHYS_SHIELD].timer != -1)
    2265. 

  2265.             aspd_rate += sd->sc_data[SC_PHYS_SHIELD].val1;
    2266. 

  2266. 

  2267.         // HIT/FLEE変化系 
    2268. 

  2268.         if (sd->sc_data[SC_WHISTLE].timer != -1)
    2269. 

  2269.         {                       // 口笛 
    2270. 

  2270.             sd->flee += sd->flee * (sd->sc_data[SC_WHISTLE].val1
    2271. 

  2271.                                     + sd->sc_data[SC_WHISTLE].val2 +
    2272. 

  2272.                                     (sd->sc_data[SC_WHISTLE].val3 >> 16)) /
    2273. 

  2273.                 100;
    2274. 

  2274.             sd->flee2 +=
    2275. 

  2275.                 (sd->sc_data[SC_WHISTLE].val1 + sd->sc_data[SC_WHISTLE].val2 +
    2276. 

  2276.                  (sd->sc_data[SC_WHISTLE].val3 & 0xffff)) * 10;
    2277. 

  2277.         }
    2278. 

  2278.         if (sd->sc_data[SC_HUMMING].timer != -1)    // ハミング 
    2279. 

  2279.             sd->hit +=
    2280. 

  2280.                 (sd->sc_data[SC_HUMMING].val1 * 2 +
    2281. 

  2281.                  sd->sc_data[SC_HUMMING].val2 +
    2282. 

  2282.                  sd->sc_data[SC_HUMMING].val3) * sd->hit / 100;
    2283. 

  2283.         if (sd->sc_data[SC_VIOLENTGALE].timer != -1 && sd->def_ele == 4)
    2284. 

  2284.           {                      // バイオレントゲイル 
    2285. 

  2285.             sd->flee += sd->flee * sd->sc_data[SC_VIOLENTGALE].val3 / 100;
    2286. 

  2286.         }
    2287. 

  2287.         if (sd->sc_data[SC_BLIND].timer != -1)
    2288. 

  2288.         {                       // 暗黒 
    2289. 

  2289.             sd->hit -= sd->hit * 25 / 100;
    2290. 

  2290.             sd->flee -= sd->flee * 25 / 100;
    2291. 

  2291.         }
    2292. 

  2292.         if (sd->sc_data[SC_WINDWALK].timer != -1)   // ウィンドウォーク 
    2293. 

  2293.             sd->flee += sd->flee * (sd->sc_data[SC_WINDWALK].val2) / 100;
    2294. 

  2294.         if (sd->sc_data[SC_SPIDERWEB].timer != -1)  //スパイダーウェブ 
    2295. 

  2295.             sd->flee -= sd->flee * 50 / 100;
    2296. 

  2296.         if (sd->sc_data[SC_TRUESIGHT].timer != -1)  //トゥルーサイト 
    2297. 

  2297.             sd->hit += 3 * (sd->sc_data[SC_TRUESIGHT].val1);
    2298. 

  2298.         if (sd->sc_data[SC_CONCENTRATION].timer != -1)  //コンセントレーション 
    2299. 

  2299.             sd->hit += (10 * (sd->sc_data[SC_CONCENTRATION].val1));
    2300. 

  2300. 

  2301.         // 耐性 
    2302. 

  2302.         if (sd->sc_data[SC_SIEGFRIED].timer != -1)
    2303. 

  2303.         {                       // 不死身のジークフリード 
    2304. 

  2304.             sd->subele[1] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2305. 

  2305.             sd->subele[2] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2306. 

  2306.             sd->subele[3] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2307. 

  2307.             sd->subele[4] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2308. 

  2308.             sd->subele[5] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2309. 

  2309.             sd->subele[6] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2310. 

  2310.             sd->subele[7] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2311. 

  2311.             sd->subele[8] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2312. 

  2312.             sd->subele[9] += sd->sc_data[SC_SIEGFRIED].val2;    // 水 
    2313. 

  2313.         }
    2314. 

  2314.         if (sd->sc_data[SC_PROVIDENCE].timer != -1)
    2315. 

  2315.           {                       // プロヴィデンス 
    2316. 

  2316.             sd->subele[6] += sd->sc_data[SC_PROVIDENCE].val2;   // 対 聖属性 
    2317. 

  2317.             sd->subrace[6] += sd->sc_data[SC_PROVIDENCE].val2;  // 対 悪魔 
    2318. 

  2318.         }
    2319. 

  2319. 

  2320.         // その他 
    2321. 

  2321.         if (sd->sc_data[SC_APPLEIDUN].timer != -1)
    2322. 

  2322.           {                       // イドゥンの林檎 
    2323. 

  2323.             sd->status.max_hp +=
    2324. 

  2324.                 ((5 + sd->sc_data[SC_APPLEIDUN].val1 * 2 +
    2325. 

  2325.                   ((sd->sc_data[SC_APPLEIDUN].val2 + 1) >> 1) +
    2326. 

  2326.                   sd->sc_data[SC_APPLEIDUN].val3 / 10) * sd->status.max_hp) /
    2327. 

  2327.                 100;
    2328. 

  2328.             if (sd->status.max_hp < 0
    2329. 

  2329.                 || sd->status.max_hp > battle_config.max_hp)
    2330. 

  2330.                 sd->status.max_hp = battle_config.max_hp;
    2331. 

  2331.         }
    2332. 

  2332.         if (sd->sc_data[SC_DELUGE].timer != -1 && sd->def_ele == 1)
    2333. 

  2333.           {                       // デリュージ 
    2334. 

  2334.             sd->status.max_hp +=
    2335. 

  2335.                 sd->status.max_hp * sd->sc_data[SC_DELUGE].val3 / 100;
    2336. 

  2336.             if (sd->status.max_hp < 0
    2337. 

  2337.                 || sd->status.max_hp > battle_config.max_hp)
    2338. 

  2338.                 sd->status.max_hp = battle_config.max_hp;
    2339. 

  2339.         }
    2340. 

  2340.         if (sd->sc_data[SC_SERVICE4U].timer != -1)
    2341. 

  2341.           {                       // サービスフォーユー 
    2342. 

  2342.             sd->status.max_sp +=
    2343. 

  2343.                 sd->status.max_sp * (10 + sd->sc_data[SC_SERVICE4U].val1 +
    2344. 

  2344.                                      sd->sc_data[SC_SERVICE4U].val2 +
    2345. 

  2345.                                      sd->sc_data[SC_SERVICE4U].val3) / 100;
    2346. 

  2346.             if (sd->status.max_sp < 0
    2347. 

  2347.                 || sd->status.max_sp > battle_config.max_sp)
    2348. 

  2348.                 sd->status.max_sp = battle_config.max_sp;
    2349. 

  2349.             sd->dsprate -=
    2350. 

  2350.                 (10 + sd->sc_data[SC_SERVICE4U].val1 * 3 +
    2351. 

  2351.                  sd->sc_data[SC_SERVICE4U].val2 +
    2352. 

  2352.                  sd->sc_data[SC_SERVICE4U].val3);
    2353. 

  2353.             if (sd->dsprate < 0)
    2354. 

  2354.                 sd->dsprate = 0;
    2355. 

  2355.         }
    2356. 

  2356. 

  2357.         if (sd->sc_data[SC_FORTUNE].timer != -1)    // 幸運のキス 
    2358. 

  2358.             sd->critical +=
    2359. 

  2359.                 (10 + sd->sc_data[SC_FORTUNE].val1 +
    2360. 

  2360.                  sd->sc_data[SC_FORTUNE].val2 +
    2361. 

  2361.                  sd->sc_data[SC_FORTUNE].val3) * 10;
    2362. 

  2362. 

  2363.         if (sd->sc_data[SC_EXPLOSIONSPIRITS].timer != -1)
    2364. 

  2364.         {                       // 爆裂波動 
    2365. 

  2365.             if (s_class.job == 23)
    2366. 

  2366.                 sd->critical += sd->sc_data[SC_EXPLOSIONSPIRITS].val1 * 100;
    2367. 

  2367.             else
    2368. 

  2368.                 sd->critical += sd->sc_data[SC_EXPLOSIONSPIRITS].val2;
    2369. 

  2369.         }
    2370. 

  2370. 

  2371.         if (sd->sc_data[SC_STEELBODY].timer != -1)
    2372. 

  2372.         {                       // 金剛 
    2373. 

  2373.             sd->def = 90;
    2374. 

  2374.             sd->mdef = 90;
    2375. 

  2375.             aspd_rate += 25;
    2376. 

  2376.             sd->speed = (sd->speed * 125) / 100;
    2377. 

  2377.         }
    2378. 

  2378.         if (sd->sc_data[SC_DEFENDER].timer != -1)
    2379. 

  2379.         {
    2380. 

  2380.             sd->aspd += (550 - sd->sc_data[SC_DEFENDER].val1 * 50);
    2381. 

  2381.             sd->speed =
    2382. 

  2382.                 (sd->speed * (155 - sd->sc_data[SC_DEFENDER].val1 * 5)) / 100;
    2383. 

  2383.         }
    2384. 

  2384.         if (sd->sc_data[SC_ENCPOISON].timer != -1)
    2385. 

  2385.             sd->addeff[4] += sd->sc_data[SC_ENCPOISON].val2;
    2386. 

  2386. 

  2387.         if (sd->sc_data[SC_DANCING].timer != -1)
    2388. 

  2388.         {                       // 演奏/ダンス使用中 
    2389. 

  2389.             sd->speed *= 4;
    2390. 

  2390.             sd->nhealsp = 0;
    2391. 

  2391.             sd->nshealsp = 0;
    2392. 

  2392.             sd->nsshealsp = 0;
    2393. 

  2393.         }
    2394. 

  2394.         if (sd->sc_data[SC_CURSE].timer != -1)
    2395. 

  2395.             sd->speed += 450;
    2396. 

  2396. 

  2397.         if (sd->sc_data[SC_TRUESIGHT].timer != -1)  //トゥルーサイト 
    2398. 

  2398.             sd->critical +=
    2399. 

  2399.                 sd->critical * (sd->sc_data[SC_TRUESIGHT].val1) / 100;
    2400. 

  2400. 

  2401. /*		if(sd->sc_data[SC_VOLCANO].timer!=-1)	// エンチャントポイズン(属性はbattle.cで)
    2402. 

  2402. 			sd->addeff[2]+=sd->sc_data[SC_VOLCANO].val2;//% of granting
    2403. 

  2403. 		if(sd->sc_data[SC_DELUGE].timer!=-1)	// エンチャントポイズン(属性はbattle.cで) 
    2404. 

  2404. 			sd->addeff[0]+=sd->sc_data[SC_DELUGE].val2;//% of granting
    2405. 

  2405. 		*/
    2406. 

  2406.     }
    2407. 

  2407. 

  2408.     if (sd->speed_rate != 100)
    2409. 

  2409.         sd->speed = sd->speed * sd->speed_rate / 100;
    2410. 

  2410.     if (sd->speed < 1)
    2411. 

  2411.         sd->speed = 1;
    2412. 

  2412.     if (aspd_rate != 100)
    2413. 

  2413.         sd->aspd = sd->aspd * aspd_rate / 100;
    2414. 

  2414.     if (pc_isriding (sd))       // 騎兵修練 
    2415. 

  2415.         sd->aspd =
    2416. 

  2416.             sd->aspd * (100 +
    2417. 

  2417.                         10 * (5 -
    2418. 

  2418.                               pc_checkskill (sd, KN_CAVALIERMASTERY))) / 100;
    2419. 

  2419. 

  2420.     if (sd->attack_spell_override)
    2421. 

  2421.         sd->aspd = sd->attack_spell_delay;
    2422. 

  2422. 

  2423.     if (sd->aspd < battle_config.max_aspd)
    2424. 

  2424.         sd->aspd = battle_config.max_aspd;
    2425. 

  2425.     sd->amotion = sd->aspd;
    2426. 

  2426.     sd->dmotion = 800 - sd->paramc[1] * 4;
    2427. 

  2427.     if (sd->dmotion < 400)
    2428. 

  2428.         sd->dmotion = 400;
    2429. 

  2429.     if (sd->skilltimer != -1 && (skill = pc_checkskill (sd, SA_FREECAST)) > 0)
    2430. 

  2430.     {
    2431. 

  2431.         sd->prev_speed = sd->speed;
    2432. 

  2432.         sd->speed = sd->speed * (175 - skill * 5) / 100;
    2433. 

  2433.     }
    2434. 

  2434. 

  2435.     if (sd->status.hp > sd->status.max_hp)
    2436. 

  2436.         sd->status.hp = sd->status.max_hp;
    2437. 

  2437.     if (sd->status.sp > sd->status.max_sp)
    2438. 

  2438.         sd->status.sp = sd->status.max_sp;
    2439. 

  2439. 

  2440.     if (first & 4)
    2441. 

  2441.         return 0;
    2442. 

  2442.     if (first & 3)
    2443. 

  2443.     {
    2444. 

  2444.         clif_updatestatus (sd, SP_SPEED);
    2445. 

  2445.         clif_updatestatus (sd, SP_MAXHP);
    2446. 

  2446.         clif_updatestatus (sd, SP_MAXSP);
    2447. 

  2447.         if (first & 1)
    2448. 

  2448.         {
    2449. 

  2449.             clif_updatestatus (sd, SP_HP);
    2450. 

  2450.             clif_updatestatus (sd, SP_SP);
    2451. 

  2451.         }
    2452. 

  2452.         return 0;
    2453. 

  2453.     }
    2454. 

  2454. 

  2455.     if (b_class != sd->view_class)
    2456. 

  2456.     {
    2457. 

  2457.         clif_changelook (&sd->bl, LOOK_BASE, sd->view_class);
    2458. 

  2458.         clif_changelook (&sd->bl, LOOK_WEAPON, 0);
    2459. 

  2459.     }
    2460. 

  2460. 

  2461.     if (memcmp (b_skill, sd->status.skill, sizeof (sd->status.skill))
    2462. 

  2462.         || b_attackrange != sd->attackrange)
    2463. 

  2463.         clif_skillinfoblock (sd);   // スキル送信 
    2464. 

  2464. 

  2465.     if (b_speed != sd->speed)
    2466. 

  2466.         clif_updatestatus (sd, SP_SPEED);
    2467. 

  2467.     if (b_weight != sd->weight)
    2468. 

  2468.         clif_updatestatus (sd, SP_WEIGHT);
    2469. 

  2469.     if (b_max_weight != sd->max_weight)
    2470. 

  2470.     {
    2471. 

  2471.         clif_updatestatus (sd, SP_MAXWEIGHT);
    2472. 

  2472.         pc_checkweighticon (sd);
    2473. 

  2473.     }
    2474. 

  2474.     for (i = 0; i < 6; i++)
    2475. 

  2475.         if (b_paramb[i] + b_parame[i] != sd->paramb[i] + sd->parame[i])
    2476. 

  2476.             clif_updatestatus (sd, SP_STR + i);
    2477. 

  2477.     if (b_hit != sd->hit)
    2478. 

  2478.         clif_updatestatus (sd, SP_HIT);
    2479. 

  2479.     if (b_flee != sd->flee)
    2480. 

  2480.         clif_updatestatus (sd, SP_FLEE1);
    2481. 

  2481.     if (b_aspd != sd->aspd)
    2482. 

  2482.         clif_updatestatus (sd, SP_ASPD);
    2483. 

  2483.     if (b_watk != sd->watk || b_base_atk != sd->base_atk)
    2484. 

  2484.         clif_updatestatus (sd, SP_ATK1);
    2485. 

  2485.     if (b_def != sd->def)
    2486. 

  2486.         clif_updatestatus (sd, SP_DEF1);
    2487. 

  2487.     if (b_watk2 != sd->watk2)
    2488. 

  2488.         clif_updatestatus (sd, SP_ATK2);
    2489. 

  2489.     if (b_def2 != sd->def2)
    2490. 

  2490.         clif_updatestatus (sd, SP_DEF2);
    2491. 

  2491.     if (b_flee2 != sd->flee2)
    2492. 

  2492.         clif_updatestatus (sd, SP_FLEE2);
    2493. 

  2493.     if (b_critical != sd->critical)
    2494. 

  2494.         clif_updatestatus (sd, SP_CRITICAL);
    2495. 

  2495.     if (b_matk1 != sd->matk1)
    2496. 

  2496.         clif_updatestatus (sd, SP_MATK1);
    2497. 

  2497.     if (b_matk2 != sd->matk2)
    2498. 

  2498.         clif_updatestatus (sd, SP_MATK2);
    2499. 

  2499.     if (b_mdef != sd->mdef)
    2500. 

  2500.         clif_updatestatus (sd, SP_MDEF1);
    2501. 

  2501.     if (b_mdef2 != sd->mdef2)
    2502. 

  2502.         clif_updatestatus (sd, SP_MDEF2);
    2503. 

  2503.     if (b_attackrange != sd->attackrange)
    2504. 

  2504.         clif_updatestatus (sd, SP_ATTACKRANGE);
    2505. 

  2505.     if (b_max_hp != sd->status.max_hp)
    2506. 

  2506.         clif_updatestatus (sd, SP_MAXHP);
    2507. 

  2507.     if (b_max_sp != sd->status.max_sp)
    2508. 

  2508.         clif_updatestatus (sd, SP_MAXSP);
    2509. 

  2509.     if (b_hp != sd->status.hp)
    2510. 

  2510.         clif_updatestatus (sd, SP_HP);
    2511. 

  2511.     if (b_sp != sd->status.sp)
    2512. 

  2512.         clif_updatestatus (sd, SP_SP);
    2513. 

  2513. 

  2514. /*	if(before.cart_num != before.cart_num || before.cart_max_num != before.cart_max_num ||
    2515. 

  2515. 		before.cart_weight != before.cart_weight || before.cart_max_weight != before.cart_max_weight )
    2516. 

  2516. 		clif_updatestatus(sd,SP_CARTINFO);*/
    2517. 

  2517. 

  2518.     if (sd->status.hp < sd->status.max_hp >> 2
    2519. 

  2519.         && pc_checkskill (sd, SM_AUTOBERSERK) > 0
    2520. 

  2520.         && (sd->sc_data[SC_PROVOKE].timer == -1
    2521. 

  2521.             || sd->sc_data[SC_PROVOKE].val2 == 0) && !pc_isdead (sd))
    2522. 

  2522.           // オートバーサーク発動 
    2523. 

  2523.         skill_status_change_start (&sd->bl, SC_PROVOKE, 10, 1, 0, 0, 0, 0);
    2524. 

  2524. 

  2525.     return 0;
    2526. 

  2526. }
    2527. 

  2527. 

  2528. /*==========================================
    2529. 

  2529.  * 装 備品による能力等のボーナス設定 
    2530. 

  2530.  *------------------------------------------
    2531. 

  2531.  */
    2532. 

  2532. int pc_bonus (struct map_session_data *sd, int type, int val)
    2533. 

  2533. {
    2534. 

  2534.     nullpo_retr (0, sd);
    2535. 

  2535. 

  2536.     switch (type)
    2537. 

  2537.     {
    2538. 

  2538.         case SP_STR:
    2539. 

  2539.         case SP_AGI:
    2540. 

  2540.         case SP_VIT:
    2541. 

  2541.         case SP_INT:
    2542. 

  2542.         case SP_DEX:
    2543. 

  2543.         case SP_LUK:
    2544. 

  2544.             if (sd->state.lr_flag != 2)
    2545. 

  2545.             {
    2546. 

  2546.                 sd->parame[type - SP_STR] += val;
    2547. 

  2547.                 if (sd->parame[type - SP_STR] < 0)
    2548. 

  2548.                     sd->parame[type - SP_STR] = 0;
    2549. 

  2549.             }
    2550. 

  2550.             break;
    2551. 

  2551.         case SP_ATK1:
    2552. 

  2552.             if (!sd->state.lr_flag)
    2553. 

  2553.             {
    2554. 

  2554.                 sd->watk += val;
    2555. 

  2555.                 if (sd->watk < 0)
    2556. 

  2556.                     sd->watk = 0;
    2557. 

  2557.             }
    2558. 

  2558.             else if (sd->state.lr_flag == 1)
    2559. 

  2559.             {
    2560. 

  2560.                 sd->watk_ += val;
    2561. 

  2561.                 if (sd->watk_ < 0)
    2562. 

  2562.                     sd->watk_ = 0;
    2563. 

  2563.             }
    2564. 

  2564.             break;
    2565. 

  2565.         case SP_ATK2:
    2566. 

  2566.             if (!sd->state.lr_flag)
    2567. 

  2567.             {
    2568. 

  2568.                 sd->watk2 += val;
    2569. 

  2569.                 if (sd->watk2 < 0)
    2570. 

  2570.                     sd->watk2 = 0;
    2571. 

  2571.             }
    2572. 

  2572.             else if (sd->state.lr_flag == 1)
    2573. 

  2573.             {
    2574. 

  2574.                 sd->watk_2 += val;
    2575. 

  2575.                 if (sd->watk_2 < 0)
    2576. 

  2576.                     sd->watk_2 = 0;
    2577. 

  2577.             }
    2578. 

  2578.             break;
    2579. 

  2579.         case SP_BASE_ATK:
    2580. 

  2580.             if (sd->state.lr_flag != 2)
    2581. 

  2581.             {
    2582. 

  2582.                 sd->base_atk += val;
    2583. 

  2583.                 if (sd->base_atk < 0)
    2584. 

  2584.                     sd->base_atk = 0;
    2585. 

  2585.             }
    2586. 

  2586.             break;
    2587. 

  2587.         case SP_MATK1:
    2588. 

  2588.             if (sd->state.lr_flag != 2)
    2589. 

  2589.             {
    2590. 

  2590.                 sd->matk1 += val;
    2591. 

  2591.                 if (sd->matk1 < 0)
    2592. 

  2592.                     sd->matk1 = 0;
    2593. 

  2593.             }
    2594. 

  2594.             break;
    2595. 

  2595.         case SP_MATK2:
    2596. 

  2596.             if (sd->state.lr_flag != 2)
    2597. 

  2597.             {
    2598. 

  2598.                 sd->matk2 += val;
    2599. 

  2599.                 if (sd->matk2 < 0)
    2600. 

  2600.                     sd->matk2 = 0;
    2601. 

  2601.             }
    2602. 

  2602.             break;
    2603. 

  2603.         case SP_MATK:
    2604. 

  2604.             if (sd->state.lr_flag != 2)
    2605. 

  2605.             {
    2606. 

  2606.                 sd->matk1 += val;
    2607. 

  2607.                 sd->matk2 += val;
    2608. 

  2608.                 if (sd->matk1 < 0)
    2609. 

  2609.                     sd->matk1 = 0;
    2610. 

  2610.                 if (sd->matk2 < 0)
    2611. 

  2611.                     sd->matk2 = 0;
    2612. 

  2612.             }
    2613. 

  2613.             break;
    2614. 

  2614.         case SP_DEF1:
    2615. 

  2615.             if (sd->state.lr_flag != 2)
    2616. 

  2616.             {
    2617. 

  2617.                 sd->def += val;
    2618. 

  2618.                 if (sd->def < 1)
    2619. 

  2619.                     sd->def = 1;
    2620. 

  2620.             }
    2621. 

  2621.             break;
    2622. 

  2622.         case SP_MDEF1:
    2623. 

  2623.             if (sd->state.lr_flag != 2)
    2624. 

  2624.             {
    2625. 

  2625.                 sd->mdef += val;
    2626. 

  2626.                 if (sd->mdef < 0)
    2627. 

  2627.                     sd->mdef = 0;
    2628. 

  2628.             }
    2629. 

  2629.             break;
    2630. 

  2630.         case SP_MDEF2:
    2631. 

  2631.             if (sd->state.lr_flag != 2)
    2632. 

  2632.             {
    2633. 

  2633.                 sd->mdef += val;
    2634. 

  2634.                 if (sd->mdef < 0)
    2635. 

  2635.                     sd->mdef = 0;
    2636. 

  2636.             }
    2637. 

  2637.             break;
    2638. 

  2638.         case SP_HIT:
    2639. 

  2639.             if (sd->state.lr_flag != 2)
    2640. 

  2640.             {
    2641. 

  2641.                 sd->hit += val;
    2642. 

  2642.                 if (sd->hit < 0)
    2643. 

  2643.                     sd->hit = 0;
    2644. 

  2644.             }
    2645. 

  2645.             else
    2646. 

  2646.             {
    2647. 

  2647.                 sd->arrow_hit += val;
    2648. 

  2648.                 if (sd->arrow_hit < 0)
    2649. 

  2649.                     sd->arrow_hit = 0;
    2650. 

  2650.             }
    2651. 

  2651.             break;
    2652. 

  2652.         case SP_FLEE1:
    2653. 

  2653.             if (sd->state.lr_flag != 2)
    2654. 

  2654.             {
    2655. 

  2655.                 sd->flee += val;
    2656. 

  2656.                 if (sd->flee < 0)
    2657. 

  2657.                     sd->flee = 0;
    2658. 

  2658.             }
    2659. 

  2659.             break;
    2660. 

  2660.         case SP_FLEE2:
    2661. 

  2661.             if (sd->state.lr_flag != 2)
    2662. 

  2662.             {
    2663. 

  2663.                 sd->flee2 += val * 10;
    2664. 

  2664.                 if (sd->flee2 < 0)
    2665. 

  2665.                     sd->flee2 = 0;
    2666. 

  2666.             }
    2667. 

  2667.             break;
    2668. 

  2668.         case SP_CRITICAL:
    2669. 

  2669.             if (sd->state.lr_flag != 2)
    2670. 

  2670.             {
    2671. 

  2671.                 sd->critical += val * 10;
    2672. 

  2672.                 if (sd->critical < 0)
    2673. 

  2673.                     sd->critical = 0;
    2674. 

  2674.             }
    2675. 

  2675.             else
    2676. 

  2676.             {
    2677. 

  2677.                 sd->arrow_cri += val * 10;
    2678. 

  2678.                 if (sd->arrow_cri < 0)
    2679. 

  2679.                     sd->arrow_cri = 0;
    2680. 

  2680.             }
    2681. 

  2681.             break;
    2682. 

  2682.         case SP_ATKELE:
    2683. 

  2683.             if (!sd->state.lr_flag)
    2684. 

  2684.             {
    2685. 

  2685.                 sd->atk_ele = val;
    2686. 

  2686.                 if (sd->atk_ele < 0)
    2687. 

  2687.                     sd->atk_ele = 0;
    2688. 

  2688.             }
    2689. 

  2689.             else if (sd->state.lr_flag == 1)
    2690. 

  2690.             {
    2691. 

  2691.                 sd->atk_ele_ = val;
    2692. 

  2692.                 if (sd->atk_ele_ < 0)
    2693. 

  2693.                     sd->atk_ele_ = 0;
    2694. 

  2694.             }
    2695. 

  2695.             else if (sd->state.lr_flag == 2)
    2696. 

  2696.             {
    2697. 

  2697.                 sd->arrow_ele = val;
    2698. 

  2698.                 if (sd->arrow_ele < 0)
    2699. 

  2699.                     sd->arrow_ele = 0;
    2700. 

  2700.             }
    2701. 

  2701.             break;
    2702. 

  2702.         case SP_DEFELE:
    2703. 

  2703.             if (sd->state.lr_flag != 2)
    2704. 

  2704.             {
    2705. 

  2705.                 sd->def_ele = val;
    2706. 

  2706.                 if (sd->def_ele < 0)
    2707. 

  2707.                     sd->def_ele = 0;
    2708. 

  2708.             }
    2709. 

  2709.             break;
    2710. 

  2710.         case SP_MAXHP:
    2711. 

  2711.             if (sd->state.lr_flag != 2)
    2712. 

  2712.             {
    2713. 

  2713.                 sd->status.max_hp += val;
    2714. 

  2714.                 if (sd->status.max_hp < 1)
    2715. 

  2715.                     sd->status.max_hp = 1;
    2716. 

  2716.             }
    2717. 

  2717.             break;
    2718. 

  2718.         case SP_MAXSP:
    2719. 

  2719.             if (sd->state.lr_flag != 2)
    2720. 

  2720.             {
    2721. 

  2721.                 sd->status.max_sp += val;
    2722. 

  2722.                 if (sd->status.max_sp < 1)
    2723. 

  2723.                     sd->status.max_sp = 1;
    2724. 

  2724.             }
    2725. 

  2725.             break;
    2726. 

  2726.         case SP_CASTRATE:
    2727. 

  2727.             if (sd->state.lr_flag != 2)
    2728. 

  2728.             {
    2729. 

  2729.                 sd->castrate += val;
    2730. 

  2730.                 if (sd->castrate < 1)
    2731. 

  2731.                     sd->castrate = 1;
    2732. 

  2732.             }
    2733. 

  2733.             break;
    2734. 

  2734.         case SP_MAXHPRATE:
    2735. 

  2735.             if (sd->state.lr_flag != 2)
    2736. 

  2736.             {
    2737. 

  2737.                 sd->hprate += val;
    2738. 

  2738.                 if (sd->hprate < 1)
    2739. 

  2739.                     sd->hprate = 1;
    2740. 

  2740.             }
    2741. 

  2741.             break;
    2742. 

  2742.         case SP_MAXSPRATE:
    2743. 

  2743.             if (sd->state.lr_flag != 2)
    2744. 

  2744.             {
    2745. 

  2745.                 sd->sprate += val;
    2746. 

  2746.                 if (sd->sprate < 1)
    2747. 

  2747.                     sd->sprate = 1;
    2748. 

  2748.             }
    2749. 

  2749.             break;
    2750. 

  2750.         case SP_SPRATE:
    2751. 

  2751.             if (sd->state.lr_flag != 2)
    2752. 

  2752.             {
    2753. 

  2753.                 sd->dsprate += val;
    2754. 

  2754.                 if (sd->dsprate < 1)
    2755. 

  2755.                     sd->dsprate = 1;
    2756. 

  2756.             }
    2757. 

  2757.             break;
    2758. 

  2758.         case SP_ATTACKRANGE:
    2759. 

  2759.             if (!sd->state.lr_flag)
    2760. 

  2760.             {
    2761. 

  2761.                 sd->attackrange += val;
    2762. 

  2762.                 if (sd->attackrange < 1)
    2763. 

  2763.                     sd->attackrange = 1;
    2764. 

  2764.             }
    2765. 

  2765.             else if (sd->state.lr_flag == 1)
    2766. 

  2766.             {
    2767. 

  2767.                 sd->attackrange_ += val;
    2768. 

  2768.                 if (sd->attackrange_ < 1)
    2769. 

  2769.                     sd->attackrange_ = 1;
    2770. 

  2770.             }
    2771. 

  2771.             else if (sd->state.lr_flag == 2)
    2772. 

  2772.             {
    2773. 

  2773.                 sd->arrow_range += val;
    2774. 

  2774.                 if (sd->arrow_range < 1)
    2775. 

  2775.                     sd->arrow_range = 1;
    2776. 

  2776.             }
    2777. 

  2777.             break;
    2778. 

  2778.         case SP_ADDATTACKRANGE:
    2779. 

  2779.             if (!sd->state.lr_flag)
    2780. 

  2780.             {
    2781. 

  2781.                 if (sd->attackrange == 0)
    2782. 

  2782.                     sd->attackrange = 1;
    2783. 

  2783.                 sd->attackrange += val;
    2784. 

  2784.                 if (sd->attackrange < 1)
    2785. 

  2785.                     sd->attackrange = 1;
    2786. 

  2786.             }
    2787. 

  2787.             else if (sd->state.lr_flag == 1)
    2788. 

  2788.             {
    2789. 

  2789.                 if (sd->attackrange_ == 0)
    2790. 

  2790.                     sd->attackrange_ = 1;
    2791. 

  2791.                 sd->attackrange_ += val;
    2792. 

  2792.                 if (sd->attackrange_ < 1)
    2793. 

  2793.                     sd->attackrange_ = 1;
    2794. 

  2794.             }
    2795. 

  2795.             else if (sd->state.lr_flag == 2)
    2796. 

  2796.             {
    2797. 

  2797.                 if (sd->arrow_range == 0)
    2798. 

  2798.                     sd->arrow_range = 1;
    2799. 

  2799.                 sd->arrow_range = +val;
    2800. 

  2800.                 if (sd->arrow_range < 1)
    2801. 

  2801.                     sd->arrow_range = 1;
    2802. 

  2802.             }
    2803. 

  2803.             break;
    2804. 

  2804.         case SP_ADD_SPEED:
    2805. 

  2805.             if (sd->state.lr_flag != 2)
    2806. 

  2806.                 sd->speed -= val;
    2807. 

  2807.             break;
    2808. 

  2808.         case SP_SPEED_RATE:
    2809. 

  2809.             if (sd->state.lr_flag != 2)
    2810. 

  2810.             {
    2811. 

  2811.                 if (val < 100)
    2812. 

  2812.                 {
    2813. 

  2813.                     if (sd->speed_rate > 100 - val)
    2814. 

  2814.                         sd->speed_rate = 100 - val;
    2815. 

  2815.                 }
    2816. 

  2816.                 else
    2817. 

  2817.                 {
    2818. 

  2818.                     sd->speed_rate = 1;
    2819. 

  2819.                 }
    2820. 

  2820.             }
    2821. 

  2821.             break;
    2822. 

  2822.         case SP_SPEED_ADDRATE:
    2823. 

  2823.             if (sd->state.lr_flag != 2)
    2824. 

  2824.             {
    2825. 

  2825.                 sd->speed_add_rate = sd->speed_add_rate * (100 - val) / 100;
    2826. 

  2826. //                if (sd->speed_add_rate < 0)
    2827. 

  2827. //                    sd->speed_add_rate = 0;
    2828. 

  2828.             }
    2829. 

  2829.             break;
    2830. 

  2830.         case SP_ASPD:
    2831. 

  2831.             if (sd->state.lr_flag != 2)
    2832. 

  2832.             {
    2833. 

  2833.                 if (sd->aspd >= val * 10)
    2834. 

  2834.                     sd->aspd -= val * 10;
    2835. 

  2835.                 else
    2836. 

  2836.                     sd->aspd = 1;
    2837. 

  2837.             }
    2838. 

  2838.             break;
    2839. 

  2839.         case SP_ASPD_RATE:
    2840. 

  2840.             if (sd->state.lr_flag != 2)
    2841. 

  2841.             {
    2842. 

  2842.                 if (val < 100)
    2843. 

  2843.                 {
    2844. 

  2844.                     if (sd->aspd_rate > 100 - val)
    2845. 

  2845.                         sd->aspd_rate = 100 - val;
    2846. 

  2846.                 }
    2847. 

  2847.                 else
    2848. 

  2848.                 {
    2849. 

  2849.                     sd->aspd_rate = 1;
    2850. 

  2850.                 }
    2851. 

  2851.             }
    2852. 

  2852.             break;
    2853. 

  2853.         case SP_ASPD_ADDRATE:
    2854. 

  2854.             if (sd->state.lr_flag != 2)
    2855. 

  2855.             {
    2856. 

  2856.                 sd->aspd_add_rate = sd->aspd_add_rate * (100 - val) / 100;
    2857. 

  2857. //                if (sd->aspd_add_rate < 0)
    2858. 

  2858. //                    sd->aspd_add_rate = 1;
    2859. 

  2859.             }
    2860. 

  2860.             break;
    2861. 

  2861.         case SP_HP_RECOV_RATE:
    2862. 

  2862.             if (sd->state.lr_flag != 2)
    2863. 

  2863.             {
    2864. 

  2864.                 sd->hprecov_rate += val;
    2865. 

  2865.                 if (sd->hprecov_rate < 0)
    2866. 

  2866.                     sd->hprecov_rate = 0;
    2867. 

  2867.             }
    2868. 

  2868.             break;
    2869. 

  2869.         case SP_SP_RECOV_RATE:
    2870. 

  2870.             if (sd->state.lr_flag != 2)
    2871. 

  2871.             {
    2872. 

  2872.                 sd->sprecov_rate += val;
    2873. 

  2873.                 if (sd->sprecov_rate < 0)
    2874. 

  2874.                     sd->sprecov_rate = 0;
    2875. 

  2875.             }
    2876. 

  2876.             break;
    2877. 

  2877.         case SP_CRITICAL_DEF:
    2878. 

  2878.             if (sd->state.lr_flag != 2)
    2879. 

  2879.             {
    2880. 

  2880.                 sd->critical_def += val;
    2881. 

  2881.                 if (sd->critical_def < 0)
    2882. 

  2882.                     sd->critical_def = 0;
    2883. 

  2883.             }
    2884. 

  2884.             break;
    2885. 

  2885.         case SP_NEAR_ATK_DEF:
    2886. 

  2886.             if (sd->state.lr_flag != 2)
    2887. 

  2887.             {
    2888. 

  2888.                 sd->near_attack_def_rate += val;
    2889. 

  2889.                 if (sd->near_attack_def_rate < 0)
    2890. 

  2890.                     sd->near_attack_def_rate = 0;
    2891. 

  2891.             }
    2892. 

  2892.             break;
    2893. 

  2893.         case SP_LONG_ATK_DEF:
    2894. 

  2894.             if (sd->state.lr_flag != 2)
    2895. 

  2895.             {
    2896. 

  2896.                 sd->long_attack_def_rate += val;
    2897. 

  2897.                 if (sd->long_attack_def_rate < 0)
    2898. 

  2898.                     sd->long_attack_def_rate = 0;
    2899. 

  2899.             }
    2900. 

  2900.             break;
    2901. 

  2901.         case SP_DOUBLE_RATE:
    2902. 

  2902.             if (sd->state.lr_flag == 0 && sd->double_rate < val)
    2903. 

  2903.             {
    2904. 

  2904.                 sd->double_rate = val;
    2905. 

  2905.                 if (sd->double_rate < 0)
    2906. 

  2906.                     sd->double_rate = 0;
    2907. 

  2907.             }
    2908. 

  2908.             break;
    2909. 

  2909.         case SP_DOUBLE_ADD_RATE:
    2910. 

  2910.             if (sd->state.lr_flag == 0)
    2911. 

  2911.             {
    2912. 

  2912.                 sd->double_add_rate += val;
    2913. 

  2913. //                if (sd->double_add_rate < 0)
    2914. 

  2914. //                    sd->double_add_rate = 0;
    2915. 

  2915.             }
    2916. 

  2916.             break;
    2917. 

  2917.         case SP_MATK_RATE:
    2918. 

  2918.             if (sd->state.lr_flag != 2)
    2919. 

  2919.             {
    2920. 

  2920.                 sd->matk_rate += val;
    2921. 

  2921.                 if (sd->matk_rate < 0)
    2922. 

  2922.                     sd->matk_rate = 0;
    2923. 

  2923.             }
    2924. 

  2924.             break;
    2925. 

  2925.         case SP_IGNORE_DEF_ELE:
    2926. 

  2926.             if (!sd->state.lr_flag)
    2927. 

  2927.                 sd->ignore_def_ele |= 1 << val;
    2928. 

  2928.             else if (sd->state.lr_flag == 1)
    2929. 

  2929.                 sd->ignore_def_ele_ |= 1 << val;
    2930. 

  2930.             break;
    2931. 

  2931.         case SP_IGNORE_DEF_RACE:
    2932. 

  2932.             if (!sd->state.lr_flag)
    2933. 

  2933.                 sd->ignore_def_race |= 1 << val;
    2934. 

  2934.             else if (sd->state.lr_flag == 1)
    2935. 

  2935.                 sd->ignore_def_race_ |= 1 << val;
    2936. 

  2936.             break;
    2937. 

  2937.         case SP_ATK_RATE:
    2938. 

  2938.             if (sd->state.lr_flag != 2)
    2939. 

  2939.             {
    2940. 

  2940.                 sd->atk_rate += val;
    2941. 

  2941.                 if (sd->atk_rate < 0)
    2942. 

  2942.                     sd->atk_rate = 0;
    2943. 

  2943.             }
    2944. 

  2944.             break;
    2945. 

  2945.         case SP_MAGIC_ATK_DEF:
    2946. 

  2946.             if (sd->state.lr_flag != 2)
    2947. 

  2947.             {
    2948. 

  2948.                 sd->magic_def_rate += val;
    2949. 

  2949.                 if (sd->magic_def_rate < 0)
    2950. 

  2950.                     sd->magic_def_rate = 0;
    2951. 

  2951.             }
    2952. 

  2952.             break;
    2953. 

  2953.         case SP_MISC_ATK_DEF:
    2954. 

  2954.             if (sd->state.lr_flag != 2)
    2955. 

  2955.             {
    2956. 

  2956.                 sd->misc_def_rate += val;
    2957. 

  2957.                 if (sd->misc_def_rate < 0)
    2958. 

  2958.                     sd->misc_def_rate = 0;
    2959. 

  2959.             }
    2960. 

  2960.             break;
    2961. 

  2961.         case SP_IGNORE_MDEF_ELE:
    2962. 

  2962.             if (sd->state.lr_flag != 2)
    2963. 

  2963.                 sd->ignore_mdef_ele |= 1 << val;
    2964. 

  2964.             break;
    2965. 

  2965.         case SP_IGNORE_MDEF_RACE:
    2966. 

  2966.             if (sd->state.lr_flag != 2)
    2967. 

  2967.                 sd->ignore_mdef_race |= 1 << val;
    2968. 

  2968.             break;
    2969. 

  2969.         case SP_PERFECT_HIT_RATE:
    2970. 

  2970.             if (sd->state.lr_flag != 2 && sd->perfect_hit < val)
    2971. 

  2971.             {
    2972. 

  2972.                 sd->perfect_hit = val;
    2973. 

  2973.                 if (sd->perfect_hit < 0)
    2974. 

  2974.                     sd->perfect_hit = 0;
    2975. 

  2975.             }
    2976. 

  2976.             break;
    2977. 

  2977.         case SP_PERFECT_HIT_ADD_RATE:
    2978. 

  2978.             if (sd->state.lr_flag != 2)
    2979. 

  2979.             {
    2980. 

  2980.                 sd->perfect_hit_add += val;
    2981. 

  2981. //                if (sd->perfect_hit_add < 0)
    2982. 

  2982. //                    sd->perfect_hit_add = 0;
    2983. 

  2983.             }
    2984. 

  2984.             break;
    2985. 

  2985.         case SP_CRITICAL_RATE:
    2986. 

  2986.             if (sd->state.lr_flag != 2)
    2987. 

  2987.             {
    2988. 

  2988.                 sd->critical_rate += val;
    2989. 

  2989.                 if (sd->critical_rate < 0)
    2990. 

  2990.                     sd->critical_rate = 0;
    2991. 

  2991.             }
    2992. 

  2992.             break;
    2993. 

  2993.         case SP_GET_ZENY_NUM:
    2994. 

  2994.             if (sd->state.lr_flag != 2 && sd->get_zeny_num < val)
    2995. 

  2995.             {
    2996. 

  2996.                 sd->get_zeny_num = val;
    2997. 

  2997.                 if (sd->get_zeny_num < 0)
    2998. 

  2998.                     sd->get_zeny_num = 0;
    2999. 

  2999.             }
    3000. 

  3000.             break;
    3001. 

  3001.         case SP_ADD_GET_ZENY_NUM:
    3002. 

  3002.             if (sd->state.lr_flag != 2)
    3003. 

  3003.             {
    3004. 

  3004.                 sd->get_zeny_add_num += val;
    3005. 

  3005. //                if (sd->get_zeny_add_num < 0)
    3006. 

  3006. //                    sd->get_zeny_add_num = 0;
    3007. 

  3007.             }
    3008. 

  3008.             break;
    3009. 

  3009.         case SP_DEF_RATIO_ATK_ELE:
    3010. 

  3010.             if (!sd->state.lr_flag)
    3011. 

  3011.                 sd->def_ratio_atk_ele |= 1 << val;
    3012. 

  3012.             else if (sd->state.lr_flag == 1)
    3013. 

  3013.                 sd->def_ratio_atk_ele_ |= 1 << val;
    3014. 

  3014.             break;
    3015. 

  3015.         case SP_DEF_RATIO_ATK_RACE:
    3016. 

  3016.             if (!sd->state.lr_flag)
    3017. 

  3017.                 sd->def_ratio_atk_race |= 1 << val;
    3018. 

  3018.             else if (sd->state.lr_flag == 1)
    3019. 

  3019.                 sd->def_ratio_atk_race_ |= 1 << val;
    3020. 

  3020.             break;
    3021. 

  3021.         case SP_HIT_RATE:
    3022. 

  3022.             if (sd->state.lr_flag != 2)
    3023. 

  3023.             {
    3024. 

  3024.                 sd->hit_rate += val;
    3025. 

  3025.                 if (sd->hit_rate < 0)
    3026. 

  3026.                     sd->hit_rate = 0;
    3027. 

  3027.             }
    3028. 

  3028.             break;
    3029. 

  3029.         case SP_FLEE_RATE:
    3030. 

  3030.             if (sd->state.lr_flag != 2)
    3031. 

  3031.             {
    3032. 

  3032.                 sd->flee_rate += val;
    3033. 

  3033.                 if (sd->flee_rate < 0)
    3034. 

  3034.                     sd->flee_rate = 0;
    3035. 

  3035.             }
    3036. 

  3036.             break;
    3037. 

  3037.         case SP_FLEE2_RATE:
    3038. 

  3038.             if (sd->state.lr_flag != 2)
    3039. 

  3039.             {
    3040. 

  3040.                 sd->flee2_rate += val;
    3041. 

  3041.                 if (sd->flee2_rate < 0)
    3042. 

  3042.                     sd->flee2_rate = 0;
    3043. 

  3043.             }
    3044. 

  3044.             break;
    3045. 

  3045.         case SP_DEF_RATE:
    3046. 

  3046.             if (sd->state.lr_flag != 2)
    3047. 

  3047.             {
    3048. 

  3048.                 sd->def_rate += val;
    3049. 

  3049.                 if (sd->def_rate < 0)
    3050. 

  3050.                     sd->def_rate = 0;
    3051. 

  3051.             }
    3052. 

  3052.             break;
    3053. 

  3053.         case SP_DEF2_RATE:
    3054. 

  3054.             if (sd->state.lr_flag != 2)
    3055. 

  3055.             {
    3056. 

  3056.                 sd->def2_rate += val;
    3057. 

  3057.                 if (sd->def2_rate < 0)
    3058. 

  3058.                     sd->def2_rate = 0;
    3059. 

  3059.             }
    3060. 

  3060.             break;
    3061. 

  3061.         case SP_MDEF_RATE:
    3062. 

  3062.             if (sd->state.lr_flag != 2)
    3063. 

  3063.             {
    3064. 

  3064.                 sd->mdef_rate += val;
    3065. 

  3065.                 if (sd->mdef_rate < 0)
    3066. 

  3066.                     sd->mdef_rate = 0;
    3067. 

  3067.             }
    3068. 

  3068.             break;
    3069. 

  3069.         case SP_MDEF2_RATE:
    3070. 

  3070.             if (sd->state.lr_flag != 2)
    3071. 

  3071.             {
    3072. 

  3072.                 sd->mdef2_rate += val;
    3073. 

  3073.                 if (sd->mdef2_rate < 0)
    3074. 

  3074.                     sd->mdef2_rate = 0;
    3075. 

  3075.             }
    3076. 

  3076.             break;
    3077. 

  3077.         case SP_RESTART_FULL_RECORVER:
    3078. 

  3078.             if (sd->state.lr_flag != 2)
    3079. 

  3079.                 sd->special_state.restart_full_recover = 1;
    3080. 

  3080.             break;
    3081. 

  3081.         case SP_NO_CASTCANCEL:
    3082. 

  3082.             if (sd->state.lr_flag != 2)
    3083. 

  3083.                 sd->special_state.no_castcancel = 1;
    3084. 

  3084.             break;
    3085. 

  3085.         case SP_NO_CASTCANCEL2:
    3086. 

  3086.             if (sd->state.lr_flag != 2)
    3087. 

  3087.                 sd->special_state.no_castcancel2 = 1;
    3088. 

  3088.             break;
    3089. 

  3089.         case SP_NO_SIZEFIX:
    3090. 

  3090.             if (sd->state.lr_flag != 2)
    3091. 

  3091.                 sd->special_state.no_sizefix = 1;
    3092. 

  3092.             break;
    3093. 

  3093.         case SP_NO_MAGIC_DAMAGE:
    3094. 

  3094.             if (sd->state.lr_flag != 2)
    3095. 

  3095.                 sd->special_state.no_magic_damage = 1;
    3096. 

  3096.             break;
    3097. 

  3097.         case SP_NO_WEAPON_DAMAGE:
    3098. 

  3098.             if (sd->state.lr_flag != 2)
    3099. 

  3099.                 sd->special_state.no_weapon_damage = 1;
    3100. 

  3100.             break;
    3101. 

  3101.         case SP_NO_GEMSTONE:
    3102. 

  3102.             if (sd->state.lr_flag != 2)
    3103. 

  3103.                 sd->special_state.no_gemstone = 1;
    3104. 

  3104.             break;
    3105. 

  3105.         case SP_INFINITE_ENDURE:
    3106. 

  3106.             if (sd->state.lr_flag != 2)
    3107. 

  3107.                 sd->special_state.infinite_endure = 1;
    3108. 

  3108.             break;
    3109. 

  3109.         case SP_SPLASH_RANGE:
    3110. 

  3110.             if (sd->state.lr_flag != 2 && sd->splash_range < val)
    3111. 

  3111.             {
    3112. 

  3112.                 sd->splash_range = val;
    3113. 

  3113.                 if (sd->splash_range < 0)
    3114. 

  3114.                     sd->splash_range = 0;
    3115. 

  3115.             }
    3116. 

  3116.             break;
    3117. 

  3117.         case SP_SPLASH_ADD_RANGE:
    3118. 

  3118.             if (sd->state.lr_flag != 2)
    3119. 

  3119.             {
    3120. 

  3120.                 sd->splash_add_range += val;
    3121. 

  3121. //                if (sd->splash_add_range < 0)
    3122. 

  3122. //                    sd->splash_add_range = 0;
    3123. 

  3123.             }
    3124. 

  3124.             break;
    3125. 

  3125.         case SP_SHORT_WEAPON_DAMAGE_RETURN:
    3126. 

  3126.             if (sd->state.lr_flag != 2)
    3127. 

  3127.             {
    3128. 

  3128.                 sd->short_weapon_damage_return += val;
    3129. 

  3129.                 if (sd->short_weapon_damage_return < 0)
    3130. 

  3130.                     sd->short_weapon_damage_return = 0;
    3131. 

  3131.             }
    3132. 

  3132.             break;
    3133. 

  3133.         case SP_LONG_WEAPON_DAMAGE_RETURN:
    3134. 

  3134.             if (sd->state.lr_flag != 2)
    3135. 

  3135.             {
    3136. 

  3136.                 sd->long_weapon_damage_return += val;
    3137. 

  3137.                 if (sd->long_weapon_damage_return < 0)
    3138. 

  3138.                     sd->long_weapon_damage_return = 0;
    3139. 

  3139.             }
    3140. 

  3140.             break;
    3141. 

  3141.         case SP_MAGIC_DAMAGE_RETURN:   //AppleGirl Was Here
    3142. 

  3142.             if (sd->state.lr_flag != 2)
    3143. 

  3143.             {
    3144. 

  3144.                 sd->magic_damage_return += val;
    3145. 

  3145.                 if (sd->magic_damage_return < 0)
    3146. 

  3146.                     sd->magic_damage_return = 0;
    3147. 

  3147.             }
    3148. 

  3148.             break;
    3149. 

  3149.         case SP_ALL_STATS:     // [Valaris]
    3150. 

  3150.             if (sd->state.lr_flag != 2)
    3151. 

  3151.             {
    3152. 

  3152.                 sd->parame[SP_STR - SP_STR] += val;
    3153. 

  3153.                 if (sd->parame[SP_STR - SP_STR] < 1)
    3154. 

  3154.                     sd->parame[SP_STR - SP_STR] = 1;
    3155. 

  3155.                 sd->parame[SP_AGI - SP_STR] += val;
    3156. 

  3156.                 if (sd->parame[SP_AGI - SP_STR] < 1)
    3157. 

  3157.                     sd->parame[SP_AGI - SP_STR] = 1;
    3158. 

  3158.                 sd->parame[SP_VIT - SP_STR] += val;
    3159. 

  3159.                 if (sd->parame[SP_VIT - SP_STR] < 1)
    3160. 

  3160.                     sd->parame[SP_VIT - SP_STR] = 1;
    3161. 

  3161.                 sd->parame[SP_INT - SP_STR] += val;
    3162. 

  3162.                 if (sd->parame[SP_INT - SP_STR] < 1)
    3163. 

  3163.                     sd->parame[SP_INT - SP_STR] = 1;
    3164. 

  3164.                 sd->parame[SP_DEX - SP_STR] += val;
    3165. 

  3165.                 if (sd->parame[SP_DEX - SP_STR] < 1)
    3166. 

  3166.                     sd->parame[SP_DEX - SP_STR] = 1;
    3167. 

  3167.                 sd->parame[SP_LUK - SP_STR] += val;
    3168. 

  3168.                 if (sd->parame[SP_LUK - SP_STR] < 1)
    3169. 

  3169.                     sd->parame[SP_LUK - SP_STR] = 1;
    3170. 

  3170.                 clif_updatestatus (sd, 13);
    3171. 

  3171.                 clif_updatestatus (sd, 14);
    3172. 

  3172.                 clif_updatestatus (sd, 15);
    3173. 

  3173.                 clif_updatestatus (sd, 16);
    3174. 

  3174.                 clif_updatestatus (sd, 17);
    3175. 

  3175.                 clif_updatestatus (sd, 18);
    3176. 

  3176.             }
    3177. 

  3177.             break;
    3178. 

  3178.         case SP_AGI_VIT:       // [Valaris]
    3179. 

  3179.             if (sd->state.lr_flag != 2)
    3180. 

  3180.             {
    3181. 

  3181.                 sd->parame[SP_AGI - SP_STR] += val;
    3182. 

  3182.                 if (sd->parame[SP_AGI - SP_STR] < 1)
    3183. 

  3183.                     sd->parame[SP_AGI - SP_STR] = 1;
    3184. 

  3184.                 sd->parame[SP_VIT - SP_STR] += val;
    3185. 

  3185.                 if (sd->parame[SP_VIT - SP_STR] < 1)
    3186. 

  3186.                     sd->parame[SP_VIT - SP_STR] = 1;
    3187. 

  3187.                 clif_updatestatus (sd, 14);
    3188. 

  3188.                 clif_updatestatus (sd, 15);
    3189. 

  3189.             }
    3190. 

  3190.             break;
    3191. 

  3191.         case SP_AGI_DEX_STR:   // [Valaris]
    3192. 

  3192.             if (sd->state.lr_flag != 2)
    3193. 

  3193.             {
    3194. 

  3194.                 sd->parame[SP_AGI - SP_STR] += val;
    3195. 

  3195.                 if (sd->parame[SP_AGI - SP_STR] < 1)
    3196. 

  3196.                     sd->parame[SP_AGI - SP_STR] = 1;
    3197. 

  3197.                 sd->parame[SP_DEX - SP_STR] += val;
    3198. 

  3198.                 if (sd->parame[SP_DEX - SP_STR] < 1)
    3199. 

  3199.                     sd->parame[SP_DEX - SP_STR] = 1;
    3200. 

  3200.                 sd->parame[SP_STR - SP_STR] += val;
    3201. 

  3201.                 if (sd->parame[SP_STR - SP_STR] < 1)
    3202. 

  3202.                     sd->parame[SP_STR - SP_STR] = 1;
    3203. 

  3203.                 clif_updatestatus (sd, 14);
    3204. 

  3204.                 clif_updatestatus (sd, 17);
    3205. 

  3205.                 clif_updatestatus (sd, 13);
    3206. 

  3206.             }
    3207. 

  3207.             break;
    3208. 

  3208.         case SP_PERFECT_HIDE:  // [Valaris]
    3209. 

  3209.             if (sd->state.lr_flag != 2)
    3210. 

  3210.             {
    3211. 

  3211.                 sd->perfect_hiding = 1;
    3212. 

  3212.             }
    3213. 

  3213.             break;
    3214. 

  3214.         case SP_DISGUISE:      // Disguise script for items [Valaris]
    3215. 

  3215.             if (sd->state.lr_flag != 2 && sd->disguiseflag == 0)
    3216. 

  3216.             {
    3217. 

  3217.                 if (pc_isriding (sd))
    3218. 

  3218.                 {               // temporary prevention of crash caused by peco + disguise, will look into a better solution [Valaris]
    3219. 

  3219.                     clif_displaymessage (sd->fd,
    3220. 

  3220.                                          "Cannot wear disguise when riding a Peco.");
    3221. 

  3221.                     break;
    3222. 

  3222.                 }
    3223. 

  3223.                 sd->disguise = val;
    3224. 

  3224.                 clif_clearchar (&sd->bl, 9);
    3225. 

  3225.                 pc_setpos (sd, sd->mapname, sd->bl.x, sd->bl.y, 3);
    3226. 

  3226.             }
    3227. 

  3227.             break;
    3228. 

  3228.         case SP_UNBREAKABLE:
    3229. 

  3229.             if (sd->state.lr_flag != 2)
    3230. 

  3230.             {
    3231. 

  3231.                 sd->unbreakable += val;
    3232. 

  3232.                 if (sd->unbreakable < 0)
    3233. 

  3233.                     sd->unbreakable = 0;
    3234. 

  3234.             }
    3235. 

  3235.             break;
    3236. 

  3236.         case SP_DEAF:
    3237. 

  3237.             sd->special_state.deaf = 1;
    3238. 

  3238.             break;
    3239. 

  3239.         default:
    3240. 

  3240.             if (battle_config.error_log)
    3241. 

  3241.                 printf ("pc_bonus: unknown type %d %d !\n", type, val);
    3242. 

  3242.             break;
    3243. 

  3243.     }
    3244. 

  3244.     return 0;
    3245. 

  3245. }
    3246. 

  3246. 

  3247. /*==========================================
    3248. 

  3248.  * 装 備品による能力等のボーナス設定 
    3249. 

  3249.  *------------------------------------------
    3250. 

  3250.  */
    3251. 

  3251. int pc_bonus2 (struct map_session_data *sd, int type, int type2, int val)
    3252. 

  3252. {
    3253. 

  3253.     int  i;
    3254. 

  3254. 

  3255.     nullpo_retr (0, sd);
    3256. 

  3256. 

  3257.     switch (type)
    3258. 

  3258.     {
    3259. 

  3259.         case SP_ADDELE:
    3260. 

  3260.             if (type2 < 0 || type2 >= 10)
    3261. 

  3261.                 break;
    3262. 

  3262. 

  3263.             if (!sd->state.lr_flag)
    3264. 

  3264.                 sd->addele[type2] += val;
    3265. 

  3265.             else if (sd->state.lr_flag == 1)
    3266. 

  3266.                 sd->addele_[type2] += val;
    3267. 

  3267.             else if (sd->state.lr_flag == 2)
    3268. 

  3268.                 sd->arrow_addele[type2] += val;
    3269. 

  3269.             break;
    3270. 

  3270.         case SP_ADDRACE:
    3271. 

  3271.             if (type2 < 0 || type2 >= 12)
    3272. 

  3272.                 break;
    3273. 

  3273. 

  3274.             if (!sd->state.lr_flag)
    3275. 

  3275.                 sd->addrace[type2] += val;
    3276. 

  3276.             else if (sd->state.lr_flag == 1)
    3277. 

  3277.                 sd->addrace_[type2] += val;
    3278. 

  3278.             else if (sd->state.lr_flag == 2)
    3279. 

  3279.                 sd->arrow_addrace[type2] += val;
    3280. 

  3280.             break;
    3281. 

  3281.         case SP_ADDSIZE:
    3282. 

  3282.             if (type2 < 0 || type2 >= 3)
    3283. 

  3283.                 break;
    3284. 

  3284. 

  3285.             if (!sd->state.lr_flag)
    3286. 

  3286.                 sd->addsize[type2] += val;
    3287. 

  3287.             else if (sd->state.lr_flag == 1)
    3288. 

  3288.                 sd->addsize_[type2] += val;
    3289. 

  3289.             else if (sd->state.lr_flag == 2)
    3290. 

  3290.                 sd->arrow_addsize[type2] += val;
    3291. 

  3291.             break;
    3292. 

  3292.         case SP_SUBELE:
    3293. 

  3293.             if (type2 < 0 || type2 >= 10)
    3294. 

  3294.                 break;
    3295. 

  3295. 

  3296.             if (sd->state.lr_flag != 2)
    3297. 

  3297.                 sd->subele[type2] += val;
    3298. 

  3298.             break;
    3299. 

  3299.         case SP_SUBRACE:
    3300. 

  3300.             if (type2 < 0 || type2 >= 12)
    3301. 

  3301.                 break;
    3302. 

  3302. 

  3303.             if (sd->state.lr_flag != 2)
    3304. 

  3304.                 sd->subrace[type2] += val;
    3305. 

  3305.             break;
    3306. 

  3306.         case SP_ADDEFF:
    3307. 

  3307.             if (type2 < 0 || type2 >= 10)
    3308. 

  3308.                 break;
    3309. 

  3309. 

  3310.             if (sd->state.lr_flag != 2)
    3311. 

  3311.                 sd->addeff[type2] += val;
    3312. 

  3312.             else
    3313. 

  3313.                 sd->arrow_addeff[type2] += val;
    3314. 

  3314.             break;
    3315. 

  3315.         case SP_ADDEFF2:
    3316. 

  3316.             if (type2 < 0 || type2 >= 10)
    3317. 

  3317.                 break;
    3318. 

  3318. 

  3319.             if (sd->state.lr_flag != 2)
    3320. 

  3320.                 sd->addeff2[type2] += val;
    3321. 

  3321.             else
    3322. 

  3322.                 sd->arrow_addeff2[type2] += val;
    3323. 

  3323.             break;
    3324. 

  3324.         case SP_RESEFF:
    3325. 

  3325.             if (type2 < 0 || type2 >= 10)
    3326. 

  3326.                 break;
    3327. 

  3327. 

  3328.             if (sd->state.lr_flag != 2)
    3329. 

  3329.                 sd->reseff[type2] += val;
    3330. 

  3330.             break;
    3331. 

  3331.         case SP_MAGIC_ADDELE:
    3332. 

  3332.             if (type2 < 0 || type2 >= 10)
    3333. 

  3333.                 break;
    3334. 

  3334. 

  3335.             if (sd->state.lr_flag != 2)
    3336. 

  3336.                 sd->magic_addele[type2] += val;
    3337. 

  3337.             break;
    3338. 

  3338.         case SP_MAGIC_ADDRACE:
    3339. 

  3339.             if (type2 < 0 || type2 >= 12)
    3340. 

  3340.                 break;
    3341. 

  3341. 

  3342.             if (sd->state.lr_flag != 2)
    3343. 

  3343.                 sd->magic_addrace[type2] += val;
    3344. 

  3344.             break;
    3345. 

  3345.         case SP_MAGIC_SUBRACE:
    3346. 

  3346.             if (type2 < 0 || type2 >= 12)
    3347. 

  3347.                 break;
    3348. 

  3348. 

  3349.             if (sd->state.lr_flag != 2)
    3350. 

  3350.                 sd->magic_subrace[type2] += val;
    3351. 

  3351.             break;
    3352. 

  3352.         case SP_ADD_DAMAGE_CLASS:
    3353. 

  3353.             if (!sd->state.lr_flag)
    3354. 

  3354.             {
    3355. 

  3355.                 for (i = 0; i < sd->add_damage_class_count; i++)
    3356. 

  3356.                 {
    3357. 

  3357.                     if (sd->add_damage_classid[i] == type2)
    3358. 

  3358.                     {
    3359. 

  3359.                         sd->add_damage_classrate[i] += val;
    3360. 

  3360.                         break;
    3361. 

  3361.                     }
    3362. 

  3362.                 }
    3363. 

  3363.                 if (i >= sd->add_damage_class_count
    3364. 

  3364.                     && sd->add_damage_class_count < 10)
    3365. 

  3365.                 {
    3366. 

  3366.                     sd->add_damage_classid[sd->add_damage_class_count] =
    3367. 

  3367.                         type2;
    3368. 

  3368.                     sd->add_damage_classrate[sd->add_damage_class_count] +=
    3369. 

  3369.                         val;
    3370. 

  3370.                     sd->add_damage_class_count++;
    3371. 

  3371.                 }
    3372. 

  3372.             }
    3373. 

  3373.             else if (sd->state.lr_flag == 1)
    3374. 

  3374.             {
    3375. 

  3375.                 for (i = 0; i < sd->add_damage_class_count_; i++)
    3376. 

  3376.                 {
    3377. 

  3377.                     if (sd->add_damage_classid_[i] == type2)
    3378. 

  3378.                     {
    3379. 

  3379.                         sd->add_damage_classrate_[i] += val;
    3380. 

  3380.                         break;
    3381. 

  3381.                     }
    3382. 

  3382.                 }
    3383. 

  3383.                 if (i >= sd->add_damage_class_count_
    3384. 

  3384.                     && sd->add_damage_class_count_ < 10)
    3385. 

  3385.                 {
    3386. 

  3386.                     sd->add_damage_classid_[sd->add_damage_class_count_] =
    3387. 

  3387.                         type2;
    3388. 

  3388.                     sd->add_damage_classrate_[sd->add_damage_class_count_] +=
    3389. 

  3389.                         val;
    3390. 

  3390.                     sd->add_damage_class_count_++;
    3391. 

  3391.                 }
    3392. 

  3392.             }
    3393. 

  3393.             break;
    3394. 

  3394.         case SP_ADD_MAGIC_DAMAGE_CLASS:
    3395. 

  3395.             if (sd->state.lr_flag != 2)
    3396. 

  3396.             {
    3397. 

  3397.                 for (i = 0; i < sd->add_magic_damage_class_count; i++)
    3398. 

  3398.                 {
    3399. 

  3399.                     if (sd->add_magic_damage_classid[i] == type2)
    3400. 

  3400.                     {
    3401. 

  3401.                         sd->add_magic_damage_classrate[i] += val;
    3402. 

  3402.                         break;
    3403. 

  3403.                     }
    3404. 

  3404.                 }
    3405. 

  3405.                 if (i >= sd->add_magic_damage_class_count
    3406. 

  3406.                     && sd->add_magic_damage_class_count < 10)
    3407. 

  3407.                 {
    3408. 

  3408.                     sd->add_magic_damage_classid
    3409. 

  3409.                         [sd->add_magic_damage_class_count] = type2;
    3410. 

  3410.                     sd->add_magic_damage_classrate
    3411. 

  3411.                         [sd->add_magic_damage_class_count] += val;
    3412. 

  3412.                     sd->add_magic_damage_class_count++;
    3413. 

  3413.                 }
    3414. 

  3414.             }
    3415. 

  3415.             break;
    3416. 

  3416.         case SP_ADD_DEF_CLASS:
    3417. 

  3417.             if (sd->state.lr_flag != 2)
    3418. 

  3418.             {
    3419. 

  3419.                 for (i = 0; i < sd->add_def_class_count; i++)
    3420. 

  3420.                 {
    3421. 

  3421.                     if (sd->add_def_classid[i] == type2)
    3422. 

  3422.                     {
    3423. 

  3423.                         sd->add_def_classrate[i] += val;
    3424. 

  3424.                         break;
    3425. 

  3425.                     }
    3426. 

  3426.                 }
    3427. 

  3427.                 if (i >= sd->add_def_class_count
    3428. 

  3428.                     && sd->add_def_class_count < 10)
    3429. 

  3429.                 {
    3430. 

  3430.                     sd->add_def_classid[sd->add_def_class_count] = type2;
    3431. 

  3431.                     sd->add_def_classrate[sd->add_def_class_count] += val;
    3432. 

  3432.                     sd->add_def_class_count++;
    3433. 

  3433.                 }
    3434. 

  3434.             }
    3435. 

  3435.             break;
    3436. 

  3436.         case SP_ADD_MDEF_CLASS:
    3437. 

  3437.             if (sd->state.lr_flag != 2)
    3438. 

  3438.             {
    3439. 

  3439.                 for (i = 0; i < sd->add_mdef_class_count; i++)
    3440. 

  3440.                 {
    3441. 

  3441.                     if (sd->add_mdef_classid[i] == type2)
    3442. 

  3442.                     {
    3443. 

  3443.                         sd->add_mdef_classrate[i] += val;
    3444. 

  3444.                         break;
    3445. 

  3445.                     }
    3446. 

  3446.                 }
    3447. 

  3447.                 if (i >= sd->add_mdef_class_count
    3448. 

  3448.                     && sd->add_mdef_class_count < 10)
    3449. 

  3449.                 {
    3450. 

  3450.                     sd->add_mdef_classid[sd->add_mdef_class_count] = type2;
    3451. 

  3451.                     sd->add_mdef_classrate[sd->add_mdef_class_count] += val;
    3452. 

  3452.                     sd->add_mdef_class_count++;
    3453. 

  3453.                 }
    3454. 

  3454.             }
    3455. 

  3455.             break;
    3456. 

  3456.         case SP_HP_DRAIN_RATE:
    3457. 

  3457.             if (!sd->state.lr_flag)
    3458. 

  3458.             {
    3459. 

  3459.                 sd->hp_drain_rate += type2;
    3460. 

  3460.                 sd->hp_drain_per += val;
    3461. 

  3461.             }
    3462. 

  3462.             else if (sd->state.lr_flag == 1)
    3463. 

  3463.             {
    3464. 

  3464.                 sd->hp_drain_rate_ += type2;
    3465. 

  3465.                 sd->hp_drain_per_ += val;
    3466. 

  3466.             }
    3467. 

  3467.             break;
    3468. 

  3468.         case SP_SP_DRAIN_RATE:
    3469. 

  3469.             if (!sd->state.lr_flag)
    3470. 

  3470.             {
    3471. 

  3471.                 sd->sp_drain_rate += type2;
    3472. 

  3472.                 sd->sp_drain_per += val;
    3473. 

  3473.             }
    3474. 

  3474.             else if (sd->state.lr_flag == 1)
    3475. 

  3475.             {
    3476. 

  3476.                 sd->sp_drain_rate_ += type2;
    3477. 

  3477.                 sd->sp_drain_per_ += val;
    3478. 

  3478.             }
    3479. 

  3479.             break;
    3480. 

  3480.         case SP_WEAPON_COMA_ELE:
    3481. 

  3481.             if (type2 < 0 || type2 >= 10)
    3482. 

  3482.                 break;
    3483. 

  3483. 

  3484.             if (sd->state.lr_flag != 2)
    3485. 

  3485.                 sd->weapon_coma_ele[type2] += val;
    3486. 

  3486.             break;
    3487. 

  3487.         case SP_WEAPON_COMA_RACE:
    3488. 

  3488.             if (type2 < 0 || type2 >= 12)
    3489. 

  3489.                 break;
    3490. 

  3490. 

  3491.             if (sd->state.lr_flag != 2)
    3492. 

  3492.                 sd->weapon_coma_race[type2] += val;
    3493. 

  3493.             break;
    3494. 

  3494.         case SP_RANDOM_ATTACK_INCREASE:    // [Valaris]
    3495. 

  3495.             if (sd->state.lr_flag != 2)
    3496. 

  3496.             {
    3497. 

  3497.                 sd->random_attack_increase_add = type2;
    3498. 

  3498.                 sd->random_attack_increase_per += val;
    3499. 

  3499.                 break;
    3500. 

  3500.             }                   // end addition
    3501. 

  3501.         default:
    3502. 

  3502.             if (battle_config.error_log)
    3503. 

  3503.                 printf ("pc_bonus2: unknown type %d %d %d!\n", type, type2,
    3504. 

  3504.                         val);
    3505. 

  3505.             break;
    3506. 

  3506.     }
    3507. 

  3507.     return 0;
    3508. 

  3508. }
    3509. 

  3509. 

  3510. int pc_bonus3 (struct map_session_data *sd, int type, int type2, int type3,
    3511. 

  3511.                int val)
    3512. 

  3512. {
    3513. 

  3513.     int  i;
    3514. 

  3514. 

  3515.     nullpo_retr (0, sd);
    3516. 

  3516. 

  3517.     switch (type)
    3518. 

  3518.     {
    3519. 

  3519.         case SP_ADD_MONSTER_DROP_ITEM:
    3520. 

  3520.             if (sd->state.lr_flag != 2)
    3521. 

  3521.             {
    3522. 

  3522.                 for (i = 0; i < sd->monster_drop_item_count; i++)
    3523. 

  3523.                 {
    3524. 

  3524.                     if (sd->monster_drop_itemid[i] == type2)
    3525. 

  3525.                     {
    3526. 

  3526.                         sd->monster_drop_race[i] |= 1 << type3;
    3527. 

  3527.                         if (sd->monster_drop_itemrate[i] < val)
    3528. 

  3528.                             sd->monster_drop_itemrate[i] = val;
    3529. 

  3529.                         break;
    3530. 

  3530.                     }
    3531. 

  3531.                 }
    3532. 

  3532.                 if (i >= sd->monster_drop_item_count
    3533. 

  3533.                     && sd->monster_drop_item_count < 10)
    3534. 

  3534.                 {
    3535. 

  3535.                     sd->monster_drop_itemid[sd->monster_drop_item_count] =
    3536. 

  3536.                         type2;
    3537. 

  3537.                     sd->monster_drop_race[sd->monster_drop_item_count] |=
    3538. 

  3538.                         1 << type3;
    3539. 

  3539.                     sd->monster_drop_itemrate[sd->monster_drop_item_count] =
    3540. 

  3540.                         val;
    3541. 

  3541.                     sd->monster_drop_item_count++;
    3542. 

  3542.                 }
    3543. 

  3543.             }
    3544. 

  3544.             break;
    3545. 

  3545.         case SP_AUTOSPELL:
    3546. 

  3546.             if (sd->state.lr_flag != 2)
    3547. 

  3547.             {
    3548. 

  3548.                 sd->autospell_id = type2;
    3549. 

  3549.                 sd->autospell_lv = type3;
    3550. 

  3550.                 sd->autospell_rate = val;
    3551. 

  3551.             }
    3552. 

  3552.             break;
    3553. 

  3553.         default:
    3554. 

  3554.             if (battle_config.error_log)
    3555. 

  3555.                 printf ("pc_bonus3: unknown type %d %d %d %d!\n", type, type2,
    3556. 

  3556.                         type3, val);
    3557. 

  3557.             break;
    3558. 

  3558.     }
    3559. 

  3559. 

  3560.     return 0;
    3561. 

  3561. }
    3562. 

  3562. 

  3563. /*==========================================
    3564. 

  3564.  * スクリプトによるスキル所得 
    3565. 

  3565.  *------------------------------------------
    3566. 

  3566.  */
    3567. 

  3567. int pc_skill (struct map_session_data *sd, int id, int level, int flag)
    3568. 

  3568. {
    3569. 

  3569.     nullpo_retr (0, sd);
    3570. 

  3570. 

  3571.     if (id < 0 || id >= MAX_SKILL)
    3572. 

  3572.         return 0;
    3573. 

  3573. 

  3574.     if (level > MAX_SKILL_LEVEL)
    3575. 

  3575.     {
    3576. 

  3576.         if (battle_config.error_log)
    3577. 

  3577.             printf ("support card skill only!\n");
    3578. 

  3578.         return 0;
    3579. 

  3579.     }
    3580. 

  3580.     if (!flag && (sd->status.skill[id].id == id || level == 0))
    3581. 

  3581.      {                           // クエスト所得ならここで条件を確認して送信する 
    3582. 

  3582.         sd->status.skill[id].lv = level;
    3583. 

  3583.         pc_calcstatus (sd, 0);
    3584. 

  3584.         clif_skillinfoblock (sd);
    3585. 

  3585.     }
    3586. 

  3586.     else if (sd->status.skill[id].lv < level)
    3587. 

  3587.     {                           // 覚えられるがlvが小さいなら 
    3588. 

  3588.         sd->status.skill[id].id = id;
    3589. 

  3589.         sd->status.skill[id].lv = level;
    3590. 

  3590.     }
    3591. 

  3591. 

  3592.     return 0;
    3593. 

  3593. }
    3594. 

  3594. 

  3595. /*==========================================
    3596. 

  3596.  * カード挿入 
    3597. 

  3597.  *------------------------------------------
    3598. 

  3598.  */
    3599. 

  3599. int pc_insert_card (struct map_session_data *sd, int idx_card, int idx_equip)
    3600. 

  3600. {
    3601. 

  3601.     nullpo_retr (0, sd);
    3602. 

  3602. 

  3603.     if (idx_card >= 0 && idx_card < MAX_INVENTORY && idx_equip >= 0
    3604. 

  3604.         && idx_equip < MAX_INVENTORY && sd->inventory_data[idx_card])
    3605. 

  3605.     {
    3606. 

  3606.         int  i;
    3607. 

  3607.         int  nameid = sd->status.inventory[idx_equip].nameid;
    3608. 

  3608.         int  cardid = sd->status.inventory[idx_card].nameid;
    3609. 

  3609.         int  ep = sd->inventory_data[idx_card]->equip;
    3610. 

  3610. 

  3611.         if (nameid <= 0 || sd->inventory_data[idx_equip] == NULL || (sd->inventory_data[idx_equip]->type != 4 && sd->inventory_data[idx_equip]->type != 5) ||   
    3612. 

  3612.            // 装 備じゃない 
    3613. 

  3613.             (sd->status.inventory[idx_equip].identify == 0) ||  // 未鑑定 
    3614. 

  3614.             (sd->status.inventory[idx_equip].card[0] == 0x00ff) ||  // 製造武器 
    3615. 

  3615.             (sd->status.inventory[idx_equip].card[0] == 0x00fe) || ((sd->inventory_data[idx_equip]->equip & ep) == 0) ||    // 装 備個所違い 
    3616. 

  3616.             (sd->inventory_data[idx_equip]->type == 4 && ep == 32) ||   // 両 手武器と盾カード 
    3617. 

  3617.             (sd->status.inventory[idx_equip].card[0] == (short) 0xff00)
    3618. 

  3618.             || sd->status.inventory[idx_equip].equip)
    3619. 

  3619.         {
    3620. 

  3620. 

  3621.             clif_insert_card (sd, idx_equip, idx_card, 1);
    3622. 

  3622.             return 0;
    3623. 

  3623.         }
    3624. 

  3624.         for (i = 0; i < sd->inventory_data[idx_equip]->slot; i++)
    3625. 

  3625.         {
    3626. 

  3626.             if (sd->status.inventory[idx_equip].card[i] == 0)
    3627. 

  3627.             {
    3628. 

  3628.                  // 空きスロットがあったので差し込む 
    3629. 

  3629.                 sd->status.inventory[idx_equip].card[i] = cardid;
    3630. 

  3630. 

  3631.                      // カードは減らす 
    3632. 

  3632.                 clif_insert_card (sd, idx_equip, idx_card, 0);
    3633. 

  3633.                 pc_delitem (sd, idx_card, 1, 1);
    3634. 

  3634.                 return 0;
    3635. 

  3635.             }
    3636. 

  3636.         }
    3637. 

  3637.     }
    3638. 

  3638.     else
    3639. 

  3639.         clif_insert_card (sd, idx_equip, idx_card, 1);
    3640. 

  3640. 

  3641.     return 0;
    3642. 

  3642. }
    3643. 

  3643. 

  3644. //
    3645. 

  3645. // アイテム物 
    3646. 

  3646. //
    3647. 

  3647. 

  3648. /*==========================================
    3649. 

  3649.  * スキルによる買い値修正 
    3650. 

  3650.  *------------------------------------------
    3651. 

  3651.  */
    3652. 

  3652. int pc_modifybuyvalue (struct map_session_data *sd, int orig_value)
    3653. 

  3653. {
    3654. 

  3654.     int  skill, val = orig_value, rate1 = 0, rate2 = 0;
    3655. 

  3655.     if ((skill = pc_checkskill (sd, MC_DISCOUNT)) > 0)  // ディスカウント 
    3656. 

  3656.         rate1 = 5 + skill * 2 - ((skill == 10) ? 1 : 0);
    3657. 

  3657.     if ((skill = pc_checkskill (sd, RG_COMPULSION)) > 0)    // コムパルションディスカウント 
    3658. 

  3658.         rate2 = 5 + skill * 4;
    3659. 

  3659.     if (rate1 < rate2)
    3660. 

  3660.         rate1 = rate2;
    3661. 

  3661.     if (rate1)
    3662. 

  3662.         val = (int) ((double) orig_value * (double) (100 - rate1) / 100.);
    3663. 

  3663.     if (val < 0)
    3664. 

  3664.         val = 0;
    3665. 

  3665.     if (orig_value > 0 && val < 1)
    3666. 

  3666.         val = 1;
    3667. 

  3667. 

  3668.     return val;
    3669. 

  3669. }
    3670. 

  3670. 

  3671. /*==========================================
    3672. 

  3672.  * スキルによる売り値修正 
    3673. 

  3673.  *------------------------------------------
    3674. 

  3674.  */
    3675. 

  3675. int pc_modifysellvalue (struct map_session_data *sd, int orig_value)
    3676. 

  3676. {
    3677. 

  3677.     int  skill, val = orig_value, rate = 0;
    3678. 

  3678.     if ((skill = pc_checkskill (sd, MC_OVERCHARGE)) > 0)    // オーバーチャージ 
    3679. 

  3679.         rate = 5 + skill * 2 - ((skill == 10) ? 1 : 0);
    3680. 

  3680.     if (rate)
    3681. 

  3681.         val = (int) ((double) orig_value * (double) (100 + rate) / 100.);
    3682. 

  3682.     if (val < 0)
    3683. 

  3683.         val = 0;
    3684. 

  3684.     if (orig_value > 0 && val < 1)
    3685. 

  3685.         val = 1;
    3686. 

  3686. 

  3687.     return val;
    3688. 

  3688. }
    3689. 

  3689. 

  3690. /*==========================================
    3691. 

  3691.  * アイテムを買った時に、新しいアイテム欄を使うか、 
    3692. 

  3692.  * 3万個制限にかかるか確認 
    3693. 

  3693.  *------------------------------------------
    3694. 

  3694.  */
    3695. 

  3695. int pc_checkadditem (struct map_session_data *sd, int nameid, int amount)
    3696. 

  3696. {
    3697. 

  3697.     int  i;
    3698. 

  3698. 

  3699.     nullpo_retr (0, sd);
    3700. 

  3700. 

  3701.     if (itemdb_isequip (nameid))
    3702. 

  3702.         return ADDITEM_NEW;
    3703. 

  3703. 

  3704.     for (i = 0; i < MAX_INVENTORY; i++)
    3705. 

  3705.     {
    3706. 

  3706.         if (sd->status.inventory[i].nameid == nameid)
    3707. 

  3707.         {
    3708. 

  3708.             if (sd->status.inventory[i].amount + amount > MAX_AMOUNT)
    3709. 

  3709.                 return ADDITEM_OVERAMOUNT;
    3710. 

  3710.             return ADDITEM_EXIST;
    3711. 

  3711.         }
    3712. 

  3712.     }
    3713. 

  3713. 

  3714.     if (amount > MAX_AMOUNT)
    3715. 

  3715.         return ADDITEM_OVERAMOUNT;
    3716. 

  3716.     return ADDITEM_NEW;
    3717. 

  3717. }
    3718. 

  3718. 

  3719. /*==========================================
    3720. 

  3720.  * 空きアイテム欄の個数 
    3721. 

  3721.  *------------------------------------------
    3722. 

  3722.  */
    3723. 

  3723. int pc_inventoryblank (struct map_session_data *sd)
    3724. 

  3724. {
    3725. 

  3725.     int  i, b;
    3726. 

  3726. 

  3727.     nullpo_retr (0, sd);
    3728. 

  3728. 

  3729.     for (i = 0, b = 0; i < MAX_INVENTORY; i++)
    3730. 

  3730.     {
    3731. 

  3731.         if (sd->status.inventory[i].nameid == 0)
    3732. 

  3732.             b++;
    3733. 

  3733.     }
    3734. 

  3734. 

  3735.     return b;
    3736. 

  3736. }
    3737. 

  3737. 

  3738. /*==========================================
    3739. 

  3739.  * お金を払う 
    3740. 

  3740.  *------------------------------------------
    3741. 

  3741.  */
    3742. 

  3742. int pc_payzeny (struct map_session_data *sd, int zeny)
    3743. 

  3743. {
    3744. 

  3744.     double z;
    3745. 

  3745. 

  3746.     nullpo_retr (0, sd);
    3747. 

  3747. 

  3748.     z = (double) sd->status.zeny;
    3749. 

  3749.     if (sd->status.zeny < zeny || z - (double) zeny > MAX_ZENY)
    3750. 

  3750.         return 1;
    3751. 

  3751.     sd->status.zeny -= zeny;
    3752. 

  3752.     clif_updatestatus (sd, SP_ZENY);
    3753. 

  3753. 

  3754.     return 0;
    3755. 

  3755. }
    3756. 

  3756. 

  3757. /*==========================================
    3758. 

  3758.  * お金を得る 
    3759. 

  3759.  *------------------------------------------
    3760. 

  3760.  */
    3761. 

  3761. int pc_getzeny (struct map_session_data *sd, int zeny)
    3762. 

  3762. {
    3763. 

  3763.     double z;
    3764. 

  3764. 

  3765.     nullpo_retr (0, sd);
    3766. 

  3766. 

  3767.     z = (double) sd->status.zeny;
    3768. 

  3768.     if (z + (double) zeny > MAX_ZENY)
    3769. 

  3769.     {
    3770. 

  3770.         zeny = 0;
    3771. 

  3771.         sd->status.zeny = MAX_ZENY;
    3772. 

  3772.     }
    3773. 

  3773.     sd->status.zeny += zeny;
    3774. 

  3774.     clif_updatestatus (sd, SP_ZENY);
    3775. 

  3775. 

  3776.     return 0;
    3777. 

  3777. }
    3778. 

  3778. 

  3779. /*==========================================
    3780. 

  3780.  * アイテムを探して、インデックスを返す 
    3781. 

  3781.  *------------------------------------------
    3782. 

  3782.  */
    3783. 

  3783. int pc_search_inventory (struct map_session_data *sd, int item_id)
    3784. 

  3784. {
    3785. 

  3785.     int  i;
    3786. 

  3786. 

  3787.     nullpo_retr (-1, sd);
    3788. 

  3788. 

  3789.     for (i = 0; i < MAX_INVENTORY; i++)
    3790. 

  3790.     {
    3791. 

  3791.         if (sd->status.inventory[i].nameid == item_id &&
    3792. 

  3792.             (sd->status.inventory[i].amount > 0 || item_id == 0))
    3793. 

  3793.             return i;
    3794. 

  3794.     }
    3795. 

  3795. 

  3796.     return -1;
    3797. 

  3797. }
    3798. 

  3798. 

  3799. int pc_count_all_items (struct map_session_data *player, int item_id)
    3800. 

  3800. {
    3801. 

  3801.     int  i;
    3802. 

  3802.     int  count = 0;
    3803. 

  3803. 

  3804.     nullpo_retr (0, player);
    3805. 

  3805. 

  3806.     for (i = 0; i < MAX_INVENTORY; i++)
    3807. 

  3807.     {
    3808. 

  3808.         if (player->status.inventory[i].nameid == item_id)
    3809. 

  3809.             count += player->status.inventory[i].amount;
    3810. 

  3810.     }
    3811. 

  3811. 

  3812.     return count;
    3813. 

  3813. }
    3814. 

  3814. 

  3815. int pc_remove_items (struct map_session_data *player, int item_id, int count)
    3816. 

  3816. {
    3817. 

  3817.     int  i;
    3818. 

  3818. 

  3819.     nullpo_retr (0, player);
    3820. 

  3820. 

  3821.     for (i = 0; i < MAX_INVENTORY && count; i++)
    3822. 

  3822.     {
    3823. 

  3823.         if (player->status.inventory[i].nameid == item_id)
    3824. 

  3824.         {
    3825. 

  3825.             int  to_delete = count;
    3826. 

  3826.             /* only delete as much as we have */
    3827. 

  3827.             if (to_delete > player->status.inventory[i].amount)
    3828. 

  3828.                 to_delete = player->status.inventory[i].amount;
    3829. 

  3829. 

  3830.             count -= to_delete;
    3831. 

  3831. 

  3832.             pc_delitem (player, i, to_delete,
    3833. 

  3833.                         0 /* means `really delete and update status' */ );
    3834. 

  3834. 

  3835.             if (!count || count < 0)
    3836. 

  3836.                 return 0;
    3837. 

  3837.         }
    3838. 

  3838.     }
    3839. 

  3839.     return 0;
    3840. 

  3840. }
    3841. 

  3841. 

  3842. /*==========================================
    3843. 

  3843.  * アイテム追加。個数のみitem構造体の数字を無視 
    3844. 

  3844.  *------------------------------------------
    3845. 

  3845.  */
    3846. 

  3846. int pc_additem (struct map_session_data *sd, struct item *item_data,
    3847. 

  3847.                 int amount)
    3848. 

  3848. {
    3849. 

  3849.     struct item_data *data;
    3850. 

  3850.     int  i, w;
    3851. 

  3851. 

  3852.     nullpo_retr (1, sd);
    3853. 

  3853.     nullpo_retr (1, item_data);
    3854. 

  3854. 

  3855.     MAP_LOG_PC (sd, "PICKUP %d %d", item_data->nameid, amount);
    3856. 

  3856. 

  3857.     if (item_data->nameid <= 0 || amount <= 0)
    3858. 

  3858.         return 1;
    3859. 

  3859.     data = itemdb_search (item_data->nameid);
    3860. 

  3860.     if (!data)
    3861. 

  3861.         return 1;
    3862. 

  3862. 

  3863.     if ((w = data->weight * amount) + sd->weight > sd->max_weight)
    3864. 

  3864.         return 2;
    3865. 

  3865. 

  3866.     i = MAX_INVENTORY;
    3867. 

  3867. 

  3868.     if (!itemdb_isequip2 (data))
    3869. 

  3869.     {
    3870. 

  3870.         // 装 備品ではないので、既所有品なら個数のみ変化させる 
    3871. 

  3871.         for (i = 0; i < MAX_INVENTORY; i++)
    3872. 

  3872.             if (sd->status.inventory[i].nameid == item_data->nameid &&
    3873. 

  3873.                 sd->status.inventory[i].card[0] == item_data->card[0]
    3874. 

  3874.                 && sd->status.inventory[i].card[1] == item_data->card[1]
    3875. 

  3875.                 && sd->status.inventory[i].card[2] == item_data->card[2]
    3876. 

  3876.                 && sd->status.inventory[i].card[3] == item_data->card[3])
    3877. 

  3877.             {
    3878. 

  3878.                 if (sd->status.inventory[i].amount + amount > MAX_AMOUNT)
    3879. 

  3879.                     return 5;
    3880. 

  3880.                 sd->status.inventory[i].amount += amount;
    3881. 

  3881.                 clif_additem (sd, i, amount, 0);
    3882. 

  3882.                 break;
    3883. 

  3883.             }
    3884. 

  3884.     }
    3885. 

  3885.     if (i >= MAX_INVENTORY)
    3886. 

  3886.     {
    3887. 

  3887.         // 装 備品か未所有品だったので空き欄へ追加 
    3888. 

  3888.         i = pc_search_inventory (sd, 0);
    3889. 

  3889.         if (i >= 0)
    3890. 

  3890.         {
    3891. 

  3891.             memcpy (&sd->status.inventory[i], item_data,
    3892. 

  3892.                     sizeof (sd->status.inventory[0]));
    3893. 

  3893. 

  3894.             if (item_data->equip)
    3895. 

  3895.                 sd->status.inventory[i].equip = 0;
    3896. 

  3896. 

  3897.             sd->status.inventory[i].amount = amount;
    3898. 

  3898.             sd->inventory_data[i] = data;
    3899. 

  3899.             clif_additem (sd, i, amount, 0);
    3900. 

  3900.         }
    3901. 

  3901.         else
    3902. 

  3902.             return 4;
    3903. 

  3903.     }
    3904. 

  3904.     sd->weight += w;
    3905. 

  3905.     clif_updatestatus (sd, SP_WEIGHT);
    3906. 

  3906. 

  3907.     return 0;
    3908. 

  3908. }
    3909. 

  3909. 

  3910. /*==========================================
    3911. 

  3911.  * アイテムを減らす 
    3912. 

  3912.  *------------------------------------------
    3913. 

  3913.  */
    3914. 

  3914. int pc_delitem (struct map_session_data *sd, int n, int amount, int type)
    3915. 

  3915. {
    3916. 

  3916.     nullpo_retr (1, sd);
    3917. 

  3917. 

  3918.     if (n < 0 || n >= MAX_INVENTORY)
    3919. 

  3919.         return 1;
    3920. 

  3920. 

  3921.     if (amount <= 0)
    3922. 

  3922.         return 1;
    3923. 

  3923. 

  3924.     if (sd->trade_partner != 0)
    3925. 

  3925.         trade_tradecancel (sd);
    3926. 

  3926. 

  3927.     if (sd->status.inventory[n].nameid == 0 || amount <= 0
    3928. 

  3928.         || sd->status.inventory[n].amount < amount
    3929. 

  3929.         || sd->inventory_data[n] == NULL)
    3930. 

  3930.         return 1;
    3931. 

  3931. 

  3932.     sd->status.inventory[n].amount -= amount;
    3933. 

  3933.     sd->weight -= sd->inventory_data[n]->weight * amount;
    3934. 

  3934.     if (sd->status.inventory[n].amount <= 0)
    3935. 

  3935.     {
    3936. 

  3936.         if (sd->status.inventory[n].equip)
    3937. 

  3937.             pc_unequipitem (sd, n, 0);
    3938. 

  3938.         memset (&sd->status.inventory[n], 0,
    3939. 

  3939.                 sizeof (sd->status.inventory[0]));
    3940. 

  3940.         sd->inventory_data[n] = NULL;
    3941. 

  3941.     }
    3942. 

  3942.     if (!(type & 1))
    3943. 

  3943.         clif_delitem (sd, n, amount);
    3944. 

  3944.     if (!(type & 2))
    3945. 

  3945.         clif_updatestatus (sd, SP_WEIGHT);
    3946. 

  3946. 

  3947.     return 0;
    3948. 

  3948. }
    3949. 

  3949. 

  3950. /*==========================================
    3951. 

  3951.  * アイテムを落す 
    3952. 

  3952.  *------------------------------------------
    3953. 

  3953.  */
    3954. 

  3954. int pc_dropitem (struct map_session_data *sd, int n, int amount)
    3955. 

  3955. {
    3956. 

  3956.     nullpo_retr (1, sd);
    3957. 

  3957. 

  3958.     if (sd->trade_partner != 0 || sd->npc_id != 0 || sd->state.storage_flag)
    3959. 

  3959.         return 0;               // no dropping while trading/npc/storage
    3960. 

  3960. 

  3961.     if (n < 0 || n >= MAX_INVENTORY)
    3962. 

  3962.         return 0;
    3963. 

  3963. 

  3964.     if (amount <= 0)
    3965. 

  3965.         return 0;
    3966. 

  3966. 

  3967.     if (sd->status.inventory[n].nameid <= 0 ||
    3968. 

  3968.         sd->status.inventory[n].amount < amount ||
    3969. 

  3969.         sd->trade_partner != 0 || sd->status.inventory[n].amount <= 0 ||
    3970. 

  3970.         (itemdb_attr (sd->status.inventory[n].nameid) & ITEM_ATTR_DONTDROP))
    3971. 

  3971.         return 1;
    3972. 

  3972. 

  3973.     pc_unequipinvyitem (sd, n, 0);
    3974. 

  3974. 

  3975.     map_addflooritem (&sd->status.inventory[n], amount, sd->bl.m, sd->bl.x,
    3976. 

  3976.                       sd->bl.y, NULL, NULL, NULL, 0);
    3977. 

  3977.     pc_delitem (sd, n, amount, 0);
    3978. 

  3978. 

  3979.     return 0;
    3980. 

  3980. }
    3981. 

  3981. 

  3982. /*==========================================
    3983. 

  3983.  * アイテムを拾う 
    3984. 

  3984.  *------------------------------------------
    3985. 

  3985.  */
    3986. 

  3986. 

  3987. static int can_pick_item_up_from (struct map_session_data *self, int other_id)
    3988. 

  3988. {
    3989. 

  3989.     /* From ourselves or from no-one? */
    3990. 

  3990.     if (!self || self->bl.id == other_id || !other_id)
    3991. 

  3991.         return 1;
    3992. 

  3992. 

  3993.     struct party *p = party_search (self->status.party_id);
    3994. 

  3994. 

  3995.     struct map_session_data *other = map_id2sd (other_id);
    3996. 

  3996. 

  3997.     /* Other no longer exists? */
    3998. 

  3998.     if (!other)
    3999. 

  3999.         return 1;
    4000. 

  4000. 

  4001.     /* From our partner? */
    4002. 

  4002.     if (self->status.partner_id == other->status.char_id)
    4003. 

  4003.         return 1;
    4004. 

  4004. 

  4005.     /* From a party member? */
    4006. 

  4006.     if (self->status.party_id
    4007. 

  4007.         && self->status.party_id == other->status.party_id
    4008. 

  4008.         && p && p->item != 0)
    4009. 

  4009.         return 1;
    4010. 

  4010. 

  4011.     /* From someone who is far away? */
    4012. 

  4012.     /* On another map? */
    4013. 

  4013.     if (other->bl.m != self->bl.m)
    4014. 

  4014.         return 1;
    4015. 

  4015.     else
    4016. 

  4016.     {
    4017. 

  4017.         int  distance_x = abs (other->bl.x - self->bl.x);
    4018. 

  4018.         int  distance_y = abs (other->bl.y - self->bl.y);
    4019. 

  4019.         int  distance = (distance_x > distance_y) ? distance_x : distance_y;
    4020. 

  4020. 

  4021.         return distance > battle_config.drop_pickup_safety_zone;
    4022. 

  4022.     }
    4023. 

  4023. }
    4024. 

  4024. 

  4025. int pc_takeitem (struct map_session_data *sd, struct flooritem_data *fitem)
    4026. 

  4026. {
    4027. 

  4027.     unsigned int tick = gettick ();
    4028. 

  4028.     int  can_take;
    4029. 

  4029. 

  4030.     nullpo_retr (0, sd);
    4031. 

  4031.     nullpo_retr (0, fitem);
    4032. 

  4032. 

  4033.     /* Sometimes the owners reported to us are buggy: */
    4034. 

  4034. 

  4035.     if (fitem->first_get_id == fitem->third_get_id
    4036. 

  4036.         || fitem->second_get_id == fitem->third_get_id)
    4037. 

  4037.         fitem->third_get_id = 0;
    4038. 

  4038. 

  4039.     if (fitem->first_get_id == fitem->second_get_id)
    4040. 

  4040.     {
    4041. 

  4041.         fitem->second_get_id = fitem->third_get_id;
    4042. 

  4042.         fitem->third_get_id = 0;
    4043. 

  4043.     }
    4044. 

  4044. 

  4045.     can_take = can_pick_item_up_from (sd, fitem->first_get_id);
    4046. 

  4046.     if (!can_take)
    4047. 

  4047.         can_take = fitem->first_get_tick <= tick
    4048. 

  4048.             && can_pick_item_up_from (sd, fitem->second_get_id);
    4049. 

  4049. 

  4050.     if (!can_take)
    4051. 

  4051.         can_take = fitem->second_get_tick <= tick
    4052. 

  4052.             && can_pick_item_up_from (sd, fitem->third_get_id);
    4053. 

  4053. 

  4054.     if (!can_take)
    4055. 

  4055.         can_take = fitem->third_get_tick <= tick;
    4056. 

  4056. 

  4057.     if (can_take)
    4058. 

  4058.     {
    4059. 

  4059.         /* Can pick up */
    4060. 

  4060. 

  4061.         int  flag;
    4062. 

  4062.         if ((flag =
    4063. 

  4063.              pc_additem (sd, &fitem->item_data, fitem->item_data.amount)))
    4064. 

  4064.             // 重量overで取得失敗 
    4065. 

  4065.             clif_additem (sd, 0, 0, flag);
    4066. 

  4066.         else
    4067. 

  4067.         {
    4068. 

  4068.             /* 取得成功 */ 
    4069. 

  4069.             if (sd->attacktimer != -1)
    4070. 

  4070.                 pc_stopattack (sd);
    4071. 

  4071.             clif_takeitem (&sd->bl, &fitem->bl);
    4072. 

  4072.             map_clearflooritem (fitem->bl.id);
    4073. 

  4073.         }
    4074. 

  4074.         return 0;
    4075. 

  4075.     }
    4076. 

  4076. 

  4077.     /* Otherwise, we can't pick up */
    4078. 

  4078.     clif_additem (sd, 0, 0, 6);
    4079. 

  4079.     return 0;
    4080. 

  4080. }
    4081. 

  4081. 

  4082. int pc_isUseitem (struct map_session_data *sd, int n)
    4083. 

  4083. {
    4084. 

  4084.     struct item_data *item;
    4085. 

  4085.     int  nameid;
    4086. 

  4086. 

  4087.     nullpo_retr (0, sd);
    4088. 

  4088. 

  4089.     if (n < 0 || n >= MAX_INVENTORY)
    4090. 

  4090.         return 0;
    4091. 

  4091. 

  4092.     item = sd->inventory_data[n];
    4093. 

  4093.     nameid = sd->status.inventory[n].nameid;
    4094. 

  4094. 

  4095.     if (item == NULL)
    4096. 

  4096.         return 0;
    4097. 

  4097.     if (itemdb_type (nameid) != 0 && itemdb_type (nameid) != 2)
    4098. 

  4098.         return 0;
    4099. 

  4099. /*
    4100. 

  4100.     if ((nameid == 605) && map[sd->bl.m].flag.gvg)
    4101. 

  4101.         return 0;
    4102. 

  4102.     if (nameid == 601
    4103. 

  4103.         && (map[sd->bl.m].flag.noteleport || map[sd->bl.m].flag.gvg))
    4104. 

  4104.     {
    4105. 

  4105.         clif_skill_teleportmessage (sd, 0);
    4106. 

  4106.         return 0;
    4107. 

  4107.     }
    4108. 

    4109. 

  4109.     if (nameid == 602 && map[sd->bl.m].flag.noreturn)
    4110. 

  4110.         return 0;
    4111. 

  4111.     if (nameid == 604
    4112. 

  4112.         && (map[sd->bl.m].flag.nobranch || map[sd->bl.m].flag.gvg))
    4113. 

  4113.         return 0;
    4114. 

  4114. */
    4115. 

  4115.     if (item->sex != 2 && sd->status.sex != item->sex)
    4116. 

  4116.         return 0;
    4117. 

  4117.     if (item->elv > 0 && sd->status.base_level < item->elv)
    4118. 

  4118.         return 0;
    4119. 

  4119. 

  4120.     return 1;
    4121. 

  4121. }
    4122. 

  4122. 

  4123. /*==========================================
    4124. 

  4124.  * アイテムを使う 
    4125. 

  4125.  *------------------------------------------
    4126. 

  4126.  */
    4127. 

  4127. int pc_useitem (struct map_session_data *sd, int n)
    4128. 

  4128. {
    4129. 

  4129.     nullpo_retr (1, sd);
    4130. 

  4130. 

  4131.     if (n >= 0 && n < MAX_INVENTORY && sd->inventory_data[n])
    4132. 

  4132.     {
    4133. 

  4133.         const int amount = sd->status.inventory[n].amount;
    4134. 

  4134.         if (sd->status.inventory[n].nameid <= 0
    4135. 

  4135.             || amount <= 0
    4136. 

  4136.             || sd->sc_data[SC_BERSERK].timer != -1 || !pc_isUseitem (sd, n))
    4137. 

  4137.         {
    4138. 

  4138.             clif_useitemack (sd, n, 0, 0);
    4139. 

  4139.             return 1;
    4140. 

  4140.         }
    4141. 

  4141. 

  4142.         if (itemdb_attr (sd->status.inventory[n].nameid) && ITEM_ATTR_DONTUSE)
    4143. 

  4143.             return 0;
    4144. 

  4144. 

  4145.         run_script (sd->inventory_data[n]->use_script, 0, sd->bl.id, 0);
    4146. 

  4146. 

  4147.         if (itemdb_type (sd->status.inventory[n].nameid) != 2 &&
    4148. 

  4148.             !(itemdb_attr (sd->status.inventory[n].nameid) && ITEM_ATTR_DONTREMOVE))
    4149. 

  4149.         {
    4150. 

  4150.             clif_useitemack (sd, n, amount - 1, 1);
    4151. 

  4151.             pc_delitem (sd, n, 1, 1);
    4152. 

  4152.         }
    4153. 

  4153.     }
    4154. 

  4154. 

  4155.     return 0;
    4156. 

  4156. }
    4157. 

  4157. 

  4158. /*==========================================
    4159. 

  4159.  * カートアイテム追加。個数のみitem構造体の数字を無視 
    4160. 

  4160.  *------------------------------------------
    4161. 

  4161.  */
    4162. 

  4162. int pc_cart_additem (struct map_session_data *sd, struct item *item_data,
    4163. 

  4163.                      int amount)
    4164. 

  4164. {
    4165. 

  4165.     struct item_data *data;
    4166. 

  4166.     int  i, w;
    4167. 

  4167. 

  4168.     nullpo_retr (1, sd);
    4169. 

  4169.     nullpo_retr (1, item_data);
    4170. 

  4170. 

  4171.     if (item_data->nameid <= 0 || amount <= 0)
    4172. 

  4172.         return 1;
    4173. 

  4173.     data = itemdb_search (item_data->nameid);
    4174. 

  4174. 

  4175.     if ((w = data->weight * amount) + sd->cart_weight > sd->cart_max_weight)
    4176. 

  4176.         return 1;
    4177. 

  4177. 

  4178.     i = MAX_CART;
    4179. 

  4179.     if (!itemdb_isequip2 (data))
    4180. 

  4180.     {
    4181. 

  4181.         // 装 備品ではないので、既所有品なら個数のみ変化させる 
    4182. 

  4182.         for (i = 0; i < MAX_CART; i++)
    4183. 

  4183.         {
    4184. 

  4184.             if (sd->status.cart[i].nameid == item_data->nameid &&
    4185. 

  4185.                 sd->status.cart[i].card[0] == item_data->card[0]
    4186. 

  4186.                 && sd->status.cart[i].card[1] == item_data->card[1]
    4187. 

  4187.                 && sd->status.cart[i].card[2] == item_data->card[2]
    4188. 

  4188.                 && sd->status.cart[i].card[3] == item_data->card[3])
    4189. 

  4189.             {
    4190. 

  4190.                 if (sd->status.cart[i].amount + amount > MAX_AMOUNT)
    4191. 

  4191.                     return 1;
    4192. 

  4192.                 sd->status.cart[i].amount += amount;
    4193. 

  4193.                 clif_cart_additem (sd, i, amount, 0);
    4194. 

  4194.                 break;
    4195. 

  4195.             }
    4196. 

  4196.         }
    4197. 

  4197.     }
    4198. 

  4198.     if (i >= MAX_CART)
    4199. 

  4199.     {
    4200. 

  4200.         // 装 備品か未所有品だったので空き欄へ追加 
    4201. 

  4201.         for (i = 0; i < MAX_CART; i++)
    4202. 

  4202.         {
    4203. 

  4203.             if (sd->status.cart[i].nameid == 0)
    4204. 

  4204.             {
    4205. 

  4205.                 memcpy (&sd->status.cart[i], item_data,
    4206. 

  4206.                         sizeof (sd->status.cart[0]));
    4207. 

  4207.                 sd->status.cart[i].amount = amount;
    4208. 

  4208.                 sd->cart_num++;
    4209. 

  4209.                 clif_cart_additem (sd, i, amount, 0);
    4210. 

  4210.                 break;
    4211. 

  4211.             }
    4212. 

  4212.         }
    4213. 

  4213.         if (i >= MAX_CART)
    4214. 

  4214.             return 1;
    4215. 

  4215.     }
    4216. 

  4216.     sd->cart_weight += w;
    4217. 

  4217.     clif_updatestatus (sd, SP_CARTINFO);
    4218. 

  4218. 

  4219.     return 0;
    4220. 

  4220. }
    4221. 

  4221. 

  4222. /*==========================================
    4223. 

  4223.  * カートアイテムを減らす 
    4224. 

  4224.  *------------------------------------------
    4225. 

  4225.  */
    4226. 

  4226. int pc_cart_delitem (struct map_session_data *sd, int n, int amount, int type)
    4227. 

  4227. {
    4228. 

  4228.     nullpo_retr (1, sd);
    4229. 

  4229. 

  4230.     if (n < 0 || n >= MAX_CART || amount <= 0)
    4231. 

  4231.         return 1;
    4232. 

  4232. 

  4233.     if (!pc_iscarton (sd))
    4234. 

  4234.         return 1;
    4235. 

  4235. 

  4236.     if (sd->status.cart[n].nameid == 0 || sd->status.cart[n].amount < amount)
    4237. 

  4237.         return 1;
    4238. 

  4238. 

  4239.     sd->status.cart[n].amount -= amount;
    4240. 

  4240.     sd->cart_weight -= itemdb_weight (sd->status.cart[n].nameid) * amount;
    4241. 

  4241.     if (sd->status.cart[n].amount <= 0)
    4242. 

  4242.     {
    4243. 

  4243.         memset (&sd->status.cart[n], 0, sizeof (sd->status.cart[0]));
    4244. 

  4244.         sd->cart_num--;
    4245. 

  4245.     }
    4246. 

  4246.     if (!type)
    4247. 

  4247.     {
    4248. 

  4248.         clif_cart_delitem (sd, n, amount);
    4249. 

  4249.         clif_updatestatus (sd, SP_CARTINFO);
    4250. 

  4250.     }
    4251. 

  4251. 

  4252.     return 0;
    4253. 

  4253. }
    4254. 

  4254. 

  4255. /*==========================================
    4256. 

  4256.  * カートへアイテム移動 
    4257. 

  4257.  *------------------------------------------
    4258. 

  4258.  */
    4259. 

  4259. int pc_putitemtocart (struct map_session_data *sd, int idx, int amount)
    4260. 

  4260. {
    4261. 

  4261.     struct item *item_data;
    4262. 

  4262. 

  4263.     nullpo_retr (0, sd);
    4264. 

  4264. 

  4265.     if (idx < 0 || idx >= MAX_INVENTORY)
    4266. 

  4266.         return 1;
    4267. 

  4267. 

  4268.     nullpo_retr (0, item_data = &sd->status.inventory[idx]);
    4269. 

  4269. 

  4270.     if (!pc_iscarton (sd))
    4271. 

  4271.         return 1;
    4272. 

  4272.     if (item_data->nameid == 0 || item_data->amount < amount)
    4273. 

  4273.         return 1;
    4274. 

  4274. 

  4275.     if (itemdb_attr (sd->status.inventory[idx].nameid) & ITEM_ATTR_DONTMOVETOCART)
    4276. 

  4276.         return 1;
    4277. 

  4277. 

  4278.     if (pc_cart_additem (sd, item_data, amount) == 0)
    4279. 

  4279.         return pc_delitem (sd, idx, amount, 0);
    4280. 

  4280. 

  4281.     return 1;
    4282. 

  4282. }
    4283. 

  4283. 

  4284. /*==========================================
    4285. 

  4285.  * カート内のアイテム数確認(個数の差分を返す) 
    4286. 

  4286.  *------------------------------------------
    4287. 

  4287.  */
    4288. 

  4288. int pc_cartitem_amount (struct map_session_data *sd, int idx, int amount)
    4289. 

  4289. {
    4290. 

  4290.     struct item *item_data;
    4291. 

  4291. 

  4292.     nullpo_retr (-1, sd);
    4293. 

  4293. 

  4294.     if (idx < 0 || idx >= MAX_CART)
    4295. 

  4295.         return -1;
    4296. 

  4296. 

  4297.     nullpo_retr (-1, item_data = &sd->status.cart[idx]);
    4298. 

  4298. 

  4299.     if (!pc_iscarton (sd))
    4300. 

  4300.         return -1;
    4301. 

  4301.     if (item_data->nameid == 0 || !item_data->amount)
    4302. 

  4302.         return -1;
    4303. 

  4303.     return item_data->amount - amount;
    4304. 

  4304. }
    4305. 

  4305. 

  4306. /*==========================================
    4307. 

  4307.  * カートからアイテム移動 
    4308. 

  4308.  *------------------------------------------
    4309. 

  4309.  */
    4310. 

  4310. 

  4311. int pc_getitemfromcart (struct map_session_data *sd, int idx, int amount)
    4312. 

  4312. {
    4313. 

  4313.     struct item *item_data;
    4314. 

  4314.     int  flag;
    4315. 

  4315. 

  4316.     nullpo_retr (0, sd);
    4317. 

  4317. 

  4318.     if (idx < 0 || idx >= MAX_CART)
    4319. 

  4319.         return 1;
    4320. 

  4320. 

  4321.     nullpo_retr (0, item_data = &sd->status.cart[idx]);
    4322. 

  4322. 

  4323.     if (!pc_iscarton (sd))
    4324. 

  4324.         return 1;
    4325. 

  4325.     if (item_data->nameid == 0 || item_data->amount < amount)
    4326. 

  4326.         return 1;
    4327. 

  4327.     if ((flag = pc_additem (sd, item_data, amount)) == 0)
    4328. 

  4328.         return pc_cart_delitem (sd, idx, amount, 0);
    4329. 

  4329. 

  4330.     clif_additem (sd, 0, 0, flag);
    4331. 

  4331.     return 1;
    4332. 

  4332. }
    4333. 

  4333. 

  4334. /*==========================================
    4335. 

  4335.  * アイテム鑑定 
    4336. 

  4336.  *------------------------------------------
    4337. 

  4337.  */
    4338. 

  4338. int pc_item_identify (struct map_session_data *sd, int idx)
    4339. 

  4339. {
    4340. 

  4340.     int  flag = 1;
    4341. 

  4341. 

  4342.     nullpo_retr (0, sd);
    4343. 

  4343. 

  4344.     if (idx >= 0 && idx < MAX_INVENTORY)
    4345. 

  4345.     {
    4346. 

  4346.         if (sd->status.inventory[idx].nameid > 0
    4347. 

  4347.             && sd->status.inventory[idx].identify == 0)
    4348. 

  4348.         {
    4349. 

  4349.             flag = 0;
    4350. 

  4350.             sd->status.inventory[idx].identify = 1;
    4351. 

  4351.         }
    4352. 

  4352.         clif_item_identified (sd, idx, flag);
    4353. 

  4353.     }
    4354. 

  4354.     else
    4355. 

  4355.         clif_item_identified (sd, idx, flag);
    4356. 

  4356. 

  4357.     return !flag;
    4358. 

  4358. }
    4359. 

  4359. 

  4360. /*==========================================
    4361. 

  4361.  * スティル品公開 
    4362. 

  4362.  *------------------------------------------
    4363. 

  4363.  */
    4364. 

  4364. int pc_show_steal (struct block_list *bl, va_list ap)
    4365. 

  4365. {
    4366. 

  4366.     struct map_session_data *sd;
    4367. 

  4367.     int  itemid;
    4368. 

  4368.     int  type;
    4369. 

  4369. 

  4370.     struct item_data *item = NULL;
    4371. 

  4371.     char output[100];
    4372. 

  4372. 

  4373.     nullpo_retr (0, bl);
    4374. 

  4374.     nullpo_retr (0, ap);
    4375. 

  4375.     nullpo_retr (0, sd = va_arg (ap, struct map_session_data *));
    4376. 

  4376. 

  4377.     itemid = va_arg (ap, int);
    4378. 

  4378.     type = va_arg (ap, int);
    4379. 

  4379. 

  4380.     if (!type)
    4381. 

  4381.     {
    4382. 

  4382.         if ((item = itemdb_exists (itemid)) == NULL)
    4383. 

  4383.             sprintf (output, "%s stole an Unknown_Item.", sd->status.name);
    4384. 

  4384.         else
    4385. 

  4385.             sprintf (output, "%s stole %s.", sd->status.name, item->jname);
    4386. 

  4386.         clif_displaymessage (((struct map_session_data *) bl)->fd, output);
    4387. 

  4387.     }
    4388. 

  4388.     else
    4389. 

  4389.     {
    4390. 

  4390.         sprintf (output,
    4391. 

  4391.                  "%s has not stolen the item because of being  overweight.",
    4392. 

  4392.                  sd->status.name);
    4393. 

  4393.         clif_displaymessage (((struct map_session_data *) bl)->fd, output);
    4394. 

  4394.     }
    4395. 

  4395. 

  4396.     return 0;
    4397. 

  4397. }
    4398. 

  4398. 

  4399. /*==========================================
    4400. 

  4400.  *
    4401. 

  4401.  *------------------------------------------
    4402. 

  4402.  */
    4403. 

  4403. //** pc.c: Small Steal Item fix by fritz
    4404. 

  4404. int pc_steal_item (struct map_session_data *sd, struct block_list *bl)
    4405. 

  4405. {
    4406. 

  4406.     if (sd != NULL && bl != NULL && bl->type == BL_MOB)
    4407. 

  4407.     {
    4408. 

  4408.         struct mob_data *md;
    4409. 

  4409.         md = (struct mob_data *) bl;
    4410. 

  4410.         if (!md->state.steal_flag && mob_db[md->class].mexp <= 0 && !(mob_db[md->class].mode & 0x20) && md->sc_data[SC_STONE].timer == -1 && md->sc_data[SC_FREEZE].timer == -1 && (!(md->class > 1324 && md->class < 1364)))   // prevent stealing from treasure boxes [Valaris]
    4411. 

  4411.         {
    4412. 

  4412.             int  skill;
    4413. 

  4413.             skill =
    4414. 

  4414.                 sd->paramc[4] - mob_db[md->class].dex + pc_checkskill (sd,
    4415. 

  4415.                                                                        TF_STEAL)
    4416. 

  4416.                 + 10;
    4417. 

  4417. 

  4418.             if (0 < skill)
    4419. 

  4419.             {
    4420. 

  4420.                 int  i, rate, itemid, flag, count;
    4421. 

  4421.                 for (count = 8; count <= 8 && count != 0; count--)
    4422. 

  4422.                 {
    4423. 

  4423.                     i = rand () % 8;
    4424. 

  4424.                     itemid = mob_db[md->class].dropitem[i].nameid;
    4425. 

  4425. 

  4426.                     if (itemid > 0 && itemdb_type (itemid) != 6)
    4427. 

  4427.                     {
    4428. 

  4428.                         if (!battle_config.item_rate_common)
    4429. 

  4429.                         {
    4430. 

  4430.                             rate =
    4431. 

  4431.                                 (mob_db[md->class].dropitem[i].p /
    4432. 

  4432.                                  battle_config.item_rate_common * 100 * skill) /
    4433. 

  4433.                                 100;
    4434. 

  4434.                         }
    4435. 

  4435.                         else
    4436. 

  4436.                         {
    4437. 

  4437.                             rate =
    4438. 

  4438.                                 (mob_db[md->class].dropitem[i].p /
    4439. 

  4439.                                  1 * 100 * skill) / 100;
    4440. 

  4440.                         }
    4441. 

  4441. 

  4442.                         if (rand () % 10000 < rate)
    4443. 

  4443.                         {
    4444. 

  4444.                             struct item tmp_item;
    4445. 

  4445.                             memset (&tmp_item, 0, sizeof (tmp_item));
    4446. 

  4446.                             tmp_item.nameid = itemid;
    4447. 

  4447.                             tmp_item.amount = 1;
    4448. 

  4448.                             tmp_item.identify = 1;
    4449. 

  4449.                             flag = pc_additem (sd, &tmp_item, 1);
    4450. 

  4450.                             if (battle_config.show_steal_in_same_party)
    4451. 

  4451.                             {
    4452. 

  4452.                                 party_foreachsamemap (pc_show_steal, sd, 1,
    4453. 

  4453.                                                       sd, tmp_item.nameid, 0);
    4454. 

  4454.                             }
    4455. 

  4455. 

  4456.                             if (flag)
    4457. 

  4457.                             {
    4458. 

  4458.                                 if (battle_config.show_steal_in_same_party)
    4459. 

  4459.                                 {
    4460. 

  4460.                                     party_foreachsamemap (pc_show_steal, sd,
    4461. 

  4461.                                                           1, sd,
    4462. 

  4462.                                                           tmp_item.nameid, 1);
    4463. 

  4463.                                 }
    4464. 

  4464. 

  4465.                                 clif_additem (sd, 0, 0, flag);
    4466. 

  4466.                             }
    4467. 

  4467.                             md->state.steal_flag = 1;
    4468. 

  4468.                             return 1;
    4469. 

  4469.                         }
    4470. 

  4470.                     }
    4471. 

  4471.                 }
    4472. 

  4472.             }
    4473. 

  4473.         }
    4474. 

  4474.     }
    4475. 

  4475.     return 0;
    4476. 

  4476. }
    4477. 

  4477. 

  4478. /*==========================================
    4479. 

  4479.  *
    4480. 

  4480.  *------------------------------------------
    4481. 

  4481.  */
    4482. 

  4482. int pc_steal_coin (struct map_session_data *sd, struct block_list *bl)
    4483. 

  4483. {
    4484. 

  4484.     if (sd != NULL && bl != NULL && bl->type == BL_MOB)
    4485. 

  4485.     {
    4486. 

  4486.         struct mob_data *md = (struct mob_data *) bl;
    4487. 

  4487.         if (md && !md->state.steal_coin_flag && md->sc_data
    4488. 

  4488.             && md->sc_data[SC_STONE].timer == -1
    4489. 

  4489.             && md->sc_data[SC_FREEZE].timer == -1)
    4490. 

  4490.         {
    4491. 

  4491.             int  rate, skill;
    4492. 

  4492.             skill = pc_checkskill (sd, RG_STEALCOIN) * 10;
    4493. 

  4493.             rate =
    4494. 

  4494.                 skill + (sd->status.base_level - mob_db[md->class].lv) * 3 +
    4495. 

  4495.                 sd->paramc[4] * 2 + sd->paramc[5] * 2;
    4496. 

  4496.             if (MRAND (1000) < rate)
    4497. 

  4497.             {
    4498. 

  4498.                 pc_getzeny (sd, mob_db[md->class].lv * 10 + MRAND (100));
    4499. 

  4499.                 md->state.steal_coin_flag = 1;
    4500. 

  4500.                 return 1;
    4501. 

  4501.             }
    4502. 

  4502.         }
    4503. 

  4503.     }
    4504. 

  4504. 

  4505.     return 0;
    4506. 

  4506. }
    4507. 

  4507. 

  4508. //
    4509. 

  4509. //
    4510. 

  4510. //
    4511. 

  4511. /*==========================================
    4512. 

  4512.  * PCの位置設定 
    4513. 

  4513.  *------------------------------------------
    4514. 

  4514.  */
    4515. 

  4515. int pc_setpos (struct map_session_data *sd, char *mapname_org, int x, int y,
    4516. 

  4516.                int clrtype)
    4517. 

  4517. {
    4518. 

  4518.     char mapname[24];
    4519. 

  4519.     int  m = 0, c = 0, disguise = 0;
    4520. 

  4520. 

  4521.     nullpo_retr (0, sd);
    4522. 

  4522.     nullpo_retr (0, mapname_org);
    4523. 

  4523. 

  4524.     if (sd->chatID)             // チャットから出る 
    4525. 

  4525.         chat_leavechat (sd);
    4526. 

  4526.     if (sd->trade_partner)      // 取引を中断する
    4527. 

  4527.         trade_tradecancel (sd);
    4528. 

  4528.     if (sd->state.storage_flag == 1)
    4529. 

  4529.         storage_storage_quit (sd);  // 倉庫を開いてるなら保存する 
    4530. 

  4530.     else if (sd->state.storage_flag == 2)
    4531. 

  4531.         storage_guild_storage_quit (sd, 0);
    4532. 

  4532. 

  4533.     if (sd->party_invite > 0)   // パーティ勧誘を拒否する 
    4534. 

  4534.         party_reply_invite (sd, sd->party_invite_account, 0);
    4535. 

  4535.     if (sd->guild_invite > 0)   // ギルド勧誘を拒否する 
    4536. 

  4536.         guild_reply_invite (sd, sd->guild_invite, 0);
    4537. 

  4537.     if (sd->guild_alliance > 0)  // ギルド同盟勧誘を拒否する 
    4538. 

  4538.         guild_reply_reqalliance (sd, sd->guild_alliance_account, 0);
    4539. 

  4539. 

  4540.     skill_castcancel (&sd->bl, 0);  // 詠唱中断 
    4541. 

  4541.     pc_stop_walking (sd, 0);        // 歩行中断 
    4542. 

  4542.     pc_stopattack (sd);             // 攻撃中断 
    4543. 

  4543. 

  4544.     if (pc_issit (sd))
    4545. 

  4545.     {
    4546. 

  4546. //        pc_setstand (sd); // [fate] Nothing wrong with warping while sitting
    4547. 

  4547.         skill_gangsterparadise (sd, 0);
    4548. 

  4548.     }
    4549. 

  4549. 

  4550.     if (sd->sc_data[SC_TRICKDEAD].timer != -1)
    4551. 

  4551.         skill_status_change_end (&sd->bl, SC_TRICKDEAD, -1);
    4552. 

  4552.     if (sd->status.option & 2)
    4553. 

  4553.         skill_status_change_end (&sd->bl, SC_HIDING, -1);
    4554. 

  4554.     if (sd->status.option & 4)
    4555. 

  4555.         skill_status_change_end (&sd->bl, SC_CLOAKING, -1);
    4556. 

  4556.     if (sd->status.option & 16386)
    4557. 

  4557.         skill_status_change_end (&sd->bl, SC_CHASEWALK, -1);
    4558. 

  4558.     if (sd->sc_data[SC_BLADESTOP].timer != -1)
    4559. 

  4559.         skill_status_change_end (&sd->bl, SC_BLADESTOP, -1);
    4560. 

  4560.     if (sd->sc_data[SC_DANCING].timer != -1)    // clear dance effect when warping [Valaris]
    4561. 

  4561.         skill_stop_dancing (&sd->bl, 0);
    4562. 

  4562. 

  4563.     if (sd->disguise)
    4564. 

  4564.     {                           // clear disguises when warping [Valaris]
    4565. 

  4565.         clif_clearchar (&sd->bl, 9);
    4566. 

  4566.         disguise = sd->disguise;
    4567. 

  4567.         sd->disguise = 0;
    4568. 

  4568.     }
    4569. 

  4569. 

  4570.     memcpy (mapname, mapname_org, 16);
    4571. 

  4571.     mapname[16] = 0;
    4572. 

  4572.     if (strstr (mapname, ".gat") == NULL && strlen (mapname) < 16)
    4573. 

  4573.     {
    4574. 

  4574.         strcat (mapname, ".gat");
    4575. 

  4575.     }
    4576. 

  4576. 

  4577.     m = map_mapname2mapid (mapname);
    4578. 

  4578.     if (m < 0)
    4579. 

  4579.     {
    4580. 

  4580.         if (sd->mapname[0])
    4581. 

  4581.         {
    4582. 

  4582.             int  ip, port;
    4583. 

  4583.             if (map_mapname2ipport (mapname, &ip, &port) == 0)
    4584. 

  4584.             {
    4585. 

  4585.                 skill_stop_dancing (&sd->bl, 1);
    4586. 

  4586.                 skill_unit_out_all (&sd->bl, gettick (), 1);
    4587. 

  4587.                 clif_clearchar_area (&sd->bl, clrtype & 0xffff);
    4588. 

  4588.                 skill_gangsterparadise (sd, 0);
    4589. 

  4589.                 map_delblock (&sd->bl);
    4590. 

  4590.                 memcpy (sd->mapname, mapname, 24);
    4591. 

  4591.                 sd->bl.x = x;
    4592. 

  4592.                 sd->bl.y = y;
    4593. 

  4593.                 sd->state.waitingdisconnect = 1;
    4594. 

  4594.                 pc_makesavestatus (sd);
    4595. 

  4595.                 //The storage close routines save the char data. [Skotlex]
    4596. 

  4596.                 if (!sd->state.storage_flag)
    4597. 

  4597.                     chrif_save (sd);
    4598. 

  4598.                 else if (sd->state.storage_flag == 1)
    4599. 

  4599.                     storage_storage_quit (sd);
    4600. 

  4600.                 else if (sd->state.storage_flag == 2)
    4601. 

  4601.                     storage_guild_storage_quit (sd, 1);
    4602. 

  4602. 

  4603.                 chrif_changemapserver (sd, mapname, x, y, ip, port);
    4604. 

  4604.                 return 0;
    4605. 

  4605.             }
    4606. 

  4606.         }
    4607. 

  4607. #if 0
    4608. 

  4608.         clif_authfail_fd (sd->fd, 0);   // cancel
    4609. 

  4609.         clif_setwaitclose (sd->fd);
    4610. 

  4610. #endif
    4611. 

  4611.         return 1;
    4612. 

  4612.     }
    4613. 

  4613. 

  4614.     if (x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys)
    4615. 

  4615.         x = y = 0;
    4616. 

  4616.     if ((x == 0 && y == 0) || (c = read_gat (m, x, y)) == 1 || c == 5)
    4617. 

  4617.     {
    4618. 

  4618.         if (x || y)
    4619. 

  4619.         {
    4620. 

  4620.             if (battle_config.error_log)
    4621. 

  4621.                 printf ("stacked (%d,%d)\n", x, y);
    4622. 

  4622.         }
    4623. 

  4623.         do
    4624. 

  4624.         {
    4625. 

  4625.             x = MRAND (map[m].xs - 2) + 1;
    4626. 

  4626.             y = MRAND (map[m].ys - 2) + 1;
    4627. 

  4627.         }
    4628. 

  4628.         while ((c = read_gat (m, x, y)) == 1 || c == 5);
    4629. 

  4629.     }
    4630. 

  4630. 

  4631.     if (sd->mapname[0] && sd->bl.prev != NULL)
    4632. 

  4632.     {
    4633. 

  4633.         skill_unit_out_all (&sd->bl, gettick (), 1);
    4634. 

  4634.         clif_clearchar_area (&sd->bl, clrtype & 0xffff);
    4635. 

  4635.         skill_gangsterparadise (sd, 0);
    4636. 

  4636.         map_delblock (&sd->bl);
    4637. 

  4637.         clif_changemap (sd, map[m].name, x, y); // [MouseJstr]
    4638. 

  4638.     }
    4639. 

  4639. 

  4640.     if (disguise)               // disguise teleport fix [Valaris]
    4641. 

  4641.         sd->disguise = disguise;
    4642. 

  4642. 

  4643.     memcpy (sd->mapname, mapname, 24);
    4644. 

  4644.     sd->bl.m = m;
    4645. 

  4645.     sd->to_x = x;
    4646. 

  4646.     sd->to_y = y;
    4647. 

  4647. 

  4648.     // moved and changed dance effect stopping
    4649. 

  4649. 

  4650.     sd->bl.x = x;
    4651. 

  4651.     sd->bl.y = y;
    4652. 

  4652. 

  4653. //  map_addblock(&sd->bl);  /// ブロック登録とspawnは 
    4654. 

  4654. //  clif_spawnpc(sd);
    4655. 

  4655. 

  4656.     return 0;
    4657. 

  4657. }
    4658. 

  4658. 

  4659. /*==========================================
    4660. 

  4660.  * PCのランダムワープ 
    4661. 

  4661.  *------------------------------------------
    4662. 

  4662.  */
    4663. 

  4663. int pc_randomwarp (struct map_session_data *sd, int type)
    4664. 

  4664. {
    4665. 

  4665.     int  x, y, c, i = 0;
    4666. 

  4666.     int  m;
    4667. 

  4667. 

  4668.     nullpo_retr (0, sd);
    4669. 

  4669. 

  4670.     m = sd->bl.m;
    4671. 

  4671. 

  4672.     if (map[sd->bl.m].flag.noteleport)  // テレポート禁止 
    4673. 

  4673.         return 0;
    4674. 

  4674. 

  4675.     do
    4676. 

  4676.     {
    4677. 

  4677.         x = MRAND (map[m].xs - 2) + 1;
    4678. 

  4678.         y = MRAND (map[m].ys - 2) + 1;
    4679. 

  4679.     }
    4680. 

  4680.     while (((c = read_gat (m, x, y)) == 1 || c == 5) && (i++) < 1000);
    4681. 

  4681. 

  4682.     if (i < 1000)
    4683. 

  4683.         pc_setpos (sd, map[m].name, x, y, type);
    4684. 

  4684. 

  4685.     return 0;
    4686. 

  4686. }
    4687. 

  4687. 

  4688. /*==========================================
    4689. 

  4689.  * 現在位置のメモ 
    4690. 

  4690.  *------------------------------------------
    4691. 

  4691.  */
    4692. 

  4692. int pc_memo (struct map_session_data *sd, int i)
    4693. 

  4693. {
    4694. 

  4694.     int  skill;
    4695. 

  4695.     int  j;
    4696. 

  4696. 

  4697.     nullpo_retr (0, sd);
    4698. 

  4698. 

  4699.     skill = pc_checkskill (sd, AL_WARP);
    4700. 

  4700. 

  4701.     if (i >= MIN_PORTAL_MEMO)
    4702. 

  4702.         i -= MIN_PORTAL_MEMO;
    4703. 

  4703.     else if (map[sd->bl.m].flag.nomemo
    4704. 

  4704.              || (map[sd->bl.m].flag.nowarpto
    4705. 

  4705.                  && battle_config.any_warp_GM_min_level > pc_isGM (sd)))
    4706. 

  4706.     {
    4707. 

  4707.         clif_skill_teleportmessage (sd, 1);
    4708. 

  4708.         return 0;
    4709. 

  4709.     }
    4710. 

  4710. 

  4711.     if (skill < 1)
    4712. 

  4712.     {
    4713. 

  4713.         clif_skill_memo (sd, 2);
    4714. 

  4714.     }
    4715. 

  4715. 

  4716.     if (skill < 2 || i < -1 || i > 2)
    4717. 

  4717.     {
    4718. 

  4718.         clif_skill_memo (sd, 1);
    4719. 

  4719.         return 0;
    4720. 

  4720.     }
    4721. 

  4721. 

  4722.     for (j = 0; j < 3; j++)
    4723. 

  4723.     {
    4724. 

  4724.         if (strcmp (sd->status.memo_point[j].map, map[sd->bl.m].name) == 0)
    4725. 

  4725.         {
    4726. 

  4726.             i = j;
    4727. 

  4727.             break;
    4728. 

  4728.         }
    4729. 

  4729.     }
    4730. 

  4730. 

  4731.     if (i == -1)
    4732. 

  4732.     {
    4733. 

  4733.         for (i = skill - 3; i >= 0; i--)
    4734. 

  4734.         {
    4735. 

  4735.             memcpy (&sd->status.memo_point[i + 1], &sd->status.memo_point[i],
    4736. 

  4736.                     sizeof (struct point));
    4737. 

  4737.         }
    4738. 

  4738.         i = 0;
    4739. 

  4739.     }
    4740. 

  4740.     memcpy (sd->status.memo_point[i].map, map[sd->bl.m].name, 24);
    4741. 

  4741.     sd->status.memo_point[i].x = sd->bl.x;
    4742. 

  4742.     sd->status.memo_point[i].y = sd->bl.y;
    4743. 

  4743. 

  4744.     clif_skill_memo (sd, 0);
    4745. 

  4745. 

  4746.     return 1;
    4747. 

  4747. }
    4748. 

  4748. 

  4749. /*==========================================
    4750. 

  4750.  *
    4751. 

  4751.  *------------------------------------------
    4752. 

  4752.  */
    4753. 

  4753. int pc_can_reach (struct map_session_data *sd, int x, int y)
    4754. 

  4754. {
    4755. 

  4755.     struct walkpath_data wpd;
    4756. 

  4756. 

  4757.     nullpo_retr (0, sd);
    4758. 

  4758. 

  4759.     if (sd->bl.x == x && sd->bl.y == y)    // 同じマス 
    4760. 

  4760.         return 1;
    4761. 

  4761. 

  4762.     // 障害物判定 
    4763. 

  4763.     wpd.path_len = 0;
    4764. 

  4764.     wpd.path_pos = 0;
    4765. 

  4765.     wpd.path_half = 0;
    4766. 

  4766.     return (path_search (&wpd, sd->bl.m, sd->bl.x, sd->bl.y, x, y, 0) !=
    4767. 

  4767.             -1) ? 1 : 0;
    4768. 

  4768. }
    4769. 

  4769. 

  4770. //
    4771. 

  4771. // 歩 行物 
    4772. 

  4772. //
    4773. 

  4773. /*==========================================
    4774. 

  4774.  * 次の1歩にかかる時間を計算 
    4775. 

  4775.  *------------------------------------------
    4776. 

  4776.  */
    4777. 

  4777. static int calc_next_walk_step (struct map_session_data *sd)
    4778. 

  4778. {
    4779. 

  4779.     nullpo_retr (0, sd);
    4780. 

  4780. 

  4781.     if (sd->walkpath.path_pos >= sd->walkpath.path_len)
    4782. 

  4782.         return -1;
    4783. 

  4783.     if (sd->walkpath.path[sd->walkpath.path_pos] & 1)
    4784. 

  4784.         return sd->speed * 14 / 10;
    4785. 

  4785. 

  4786.     return sd->speed;
    4787. 

  4787. }
    4788. 

  4788. 

  4789. /*==========================================
    4790. 

  4790.  * 半歩進む(timer関数) 
    4791. 

  4791.  *------------------------------------------
    4792. 

  4792.  */
    4793. 

  4793. static int pc_walk (int tid, unsigned int tick, int id, int data)
    4794. 

  4794. {
    4795. 

  4795.     struct map_session_data *sd;
    4796. 

  4796.     int  i;
    4797. 

  4797. 

  4798.     sd = map_id2sd (id);
    4799. 

  4799.     if (sd == NULL)
    4800. 

  4800.         return 0;
    4801. 

  4801. 

  4802.     if (sd->walktimer != tid)
    4803. 

  4803.     {
    4804. 

  4804.         if (battle_config.error_log)
    4805. 

  4805.             printf ("pc_walk %d != %d\n", sd->walktimer, tid);
    4806. 

  4806.         return 0;
    4807. 

  4807.     }
    4808. 

  4808.     sd->walktimer = -1;
    4809. 

  4809.     if (sd->walkpath.path_pos >= sd->walkpath.path_len
    4810. 

  4810.         || sd->walkpath.path_pos != data)
    4811. 

  4811.         return 0;
    4812. 

  4812. 

  4813.     //歩いたので息吹のタイマーを初期化 
    4814. 

  4814.     sd->inchealspirithptick = 0;
    4815. 

  4815.     sd->inchealspiritsptick = 0;
    4816. 

  4816. 

  4817.     sd->walkpath.path_half ^= 1;
    4818. 

  4818.     if (sd->walkpath.path_half == 0)
    4819. 

  4819.      {                           // マス目中心へ到着 
    4820. 

  4820.         sd->walkpath.path_pos++;
    4821. 

  4821.         if (sd->state.change_walk_target)
    4822. 

  4822.         {
    4823. 

  4823.             pc_walktoxy_sub (sd);
    4824. 

  4824.             return 0;
    4825. 

  4825.         }
    4826. 

  4826.     }
    4827. 

  4827.     else
    4828. 

  4828.      {                           // マス目境界へ到着 
    4829. 

  4829.         int  ctype;
    4830. 

  4830.         int  moveblock;
    4831. 

  4831.         int  x, y, dx, dy;
    4832. 

  4832.         if (sd->walkpath.path[sd->walkpath.path_pos] >= 8)
    4833. 

  4833.             return 1;
    4834. 

  4834. 

  4835.         x = sd->bl.x;
    4836. 

  4836.         y = sd->bl.y;
    4837. 

  4837.         ctype = map_getcell (sd->bl.m, x, y);
    4838. 

  4838.         if (ctype == 1 || ctype == 5)
    4839. 

  4839.         {
    4840. 

  4840.             pc_stop_walking (sd, 1);
    4841. 

  4841.             return 0;
    4842. 

  4842.         }
    4843. 

  4843.         sd->dir = sd->head_dir = sd->walkpath.path[sd->walkpath.path_pos];
    4844. 

  4844.         dx = dirx[(int) sd->dir];
    4845. 

  4845.         dy = diry[(int) sd->dir];
    4846. 

  4846.         ctype = map_getcell (sd->bl.m, x + dx, y + dy);
    4847. 

  4847.         if (ctype == 1 || ctype == 5)
    4848. 

  4848.         {
    4849. 

  4849.             pc_walktoxy_sub (sd);
    4850. 

  4850.             return 0;
    4851. 

  4851.         }
    4852. 

  4852. 

  4853.         moveblock = (x / BLOCK_SIZE != (x + dx) / BLOCK_SIZE
    4854. 

  4854.                      || y / BLOCK_SIZE != (y + dy) / BLOCK_SIZE);
    4855. 

  4855. 

  4856.         sd->walktimer = 1;
    4857. 

  4857.         map_foreachinmovearea (clif_pcoutsight, sd->bl.m, x - AREA_SIZE,
    4858. 

  4858.                                y - AREA_SIZE, x + AREA_SIZE, y + AREA_SIZE,
    4859. 

  4859.                                dx, dy, 0, sd);
    4860. 

  4860. 

  4861.         x += dx;
    4862. 

  4862.         y += dy;
    4863. 

  4863. 

  4864.         if (moveblock)
    4865. 

  4865.             map_delblock (&sd->bl);
    4866. 

  4866.         sd->bl.x = x;
    4867. 

  4867.         sd->bl.y = y;
    4868. 

  4868.         if (moveblock)
    4869. 

  4869.             map_addblock (&sd->bl);
    4870. 

  4870. 

  4871.         if (sd->sc_data[SC_DANCING].timer != -1)
    4872. 

  4872.             skill_unit_move_unit_group ((struct skill_unit_group *)
    4873. 

  4873.                                         sd->sc_data[SC_DANCING].val2,
    4874. 

  4874.                                         sd->bl.m, dx, dy);
    4875. 

  4875. 

  4876.         map_foreachinmovearea (clif_pcinsight, sd->bl.m, x - AREA_SIZE,
    4877. 

  4877.                                y - AREA_SIZE, x + AREA_SIZE, y + AREA_SIZE,
    4878. 

  4878.                                -dx, -dy, 0, sd);
    4879. 

  4879.         sd->walktimer = -1;
    4880. 

  4880. 

  4881.         if (sd->status.party_id > 0)
    4882. 

  4882.           {                       // パーティのＨＰ情報通知検査 
    4883. 

  4883.             struct party *p = party_search (sd->status.party_id);
    4884. 

  4884.             if (p != NULL)
    4885. 

  4885.             {
    4886. 

  4886.                 int  p_flag = 0;
    4887. 

  4887.                 map_foreachinmovearea (party_send_hp_check, sd->bl.m,
    4888. 

  4888.                                        x - AREA_SIZE, y - AREA_SIZE,
    4889. 

  4889.                                        x + AREA_SIZE, y + AREA_SIZE, -dx, -dy,
    4890. 

  4890.                                        BL_PC, sd->status.party_id, &p_flag);
    4891. 

  4891.                 if (p_flag)
    4892. 

  4892.                     sd->party_hp = -1;
    4893. 

  4893.             }
    4894. 

  4894.         }
    4895. 

  4895.         if (sd->status.option & 4) // クローキングの消滅検査 
    4896. 

  4896.             skill_check_cloaking (&sd->bl);
    4897. 

  4897.           /* ディボーション検査 */ 
    4898. 

  4898.         for (i = 0; i < 5; i++)
    4899. 

  4899.             if (sd->dev.val1[i])
    4900. 

  4900.             {
    4901. 

  4901.                 skill_devotion3 (&sd->bl, sd->dev.val1[i]);
    4902. 

  4902.                 break;
    4903. 

  4903.             }
    4904. 

  4904.         /* 被ディボーション検査 */ 
    4905. 

  4905.         if (sd->sc_data && sd->sc_data[SC_DEVOTION].val1)
    4906. 

  4906.         {
    4907. 

  4907.             skill_devotion2 (&sd->bl, sd->sc_data[SC_DEVOTION].val1);
    4908. 

  4908.         }
    4909. 

  4909. 

  4910.         skill_unit_move (&sd->bl, tick, 1); // スキルユニットの検査
    4911. 

  4911. 

  4912.         if (map_getcell (sd->bl.m, x, y) & 0x80)
    4913. 

  4913.             npc_touch_areanpc (sd, sd->bl.m, x, y);
    4914. 

  4914.         else
    4915. 

  4915.             npc_untouch_areanpc(sd);
    4916. 

  4916.     }
    4917. 

  4917.     if ((i = calc_next_walk_step (sd)) > 0)
    4918. 

  4918.     {
    4919. 

  4919.         i = i >> 1;
    4920. 

  4920.         if (i < 1 && sd->walkpath.path_half == 0)
    4921. 

  4921.             i = 1;
    4922. 

  4922.         sd->walktimer =
    4923. 

  4923.             add_timer (tick + i, pc_walk, id, sd->walkpath.path_pos);
    4924. 

  4924.     }
    4925. 

  4925. 

  4926.     return 0;
    4927. 

  4927. }
    4928. 

  4928. 

  4929. /*==========================================
    4930. 

  4930.  * 移動可能か確認して、可能なら歩行開始 
    4931. 

  4931.  *------------------------------------------
    4932. 

  4932.  */
    4933. 

  4933. static int pc_walktoxy_sub (struct map_session_data *sd)
    4934. 

  4934. {
    4935. 

  4935.     struct walkpath_data wpd;
    4936. 

  4936.     int  i;
    4937. 

  4937. 

  4938.     nullpo_retr (1, sd);
    4939. 

  4939. 

  4940.     if (path_search
    4941. 

  4941.         (&wpd, sd->bl.m, sd->bl.x, sd->bl.y, sd->to_x, sd->to_y, 0))
    4942. 

  4942.         return 1;
    4943. 

  4943.     memcpy (&sd->walkpath, &wpd, sizeof (wpd));
    4944. 

  4944. 

  4945.     clif_walkok (sd);
    4946. 

  4946.     sd->state.change_walk_target = 0;
    4947. 

  4947. 

  4948.     if ((i = calc_next_walk_step (sd)) > 0)
    4949. 

  4949.     {
    4950. 

  4950.         i = i >> 2;
    4951. 

  4951.         sd->walktimer = add_timer (gettick () + i, pc_walk, sd->bl.id, 0);
    4952. 

  4952.     }
    4953. 

  4953.     clif_movechar (sd);
    4954. 

  4954. 

  4955.     return 0;
    4956. 

  4956. }
    4957. 

  4957. 

  4958. /*==========================================
    4959. 

  4959.  * pc歩 行要求 
    4960. 

  4960.  *------------------------------------------
    4961. 

  4961.  */
    4962. 

  4962. int pc_walktoxy (struct map_session_data *sd, int x, int y)
    4963. 

  4963. {
    4964. 

  4964. 

  4965.     nullpo_retr (0, sd);
    4966. 

  4966. 

  4967.     sd->to_x = x;
    4968. 

  4968.     sd->to_y = y;
    4969. 

  4969. 

  4970.     if (pc_issit (sd))
    4971. 

  4971.         pc_setstand (sd);
    4972. 

  4972. 

  4973.     if (sd->walktimer != -1 && sd->state.change_walk_target == 0)
    4974. 

  4974.     {
    4975. 

  4975.         // 現在歩いている最中の目的地変更なのでマス目の中心に来た時に 
    4976. 

  4976.         // timer関数からpc_walktoxy_subを呼ぶようにする 
    4977. 

  4977.         sd->state.change_walk_target = 1;
    4978. 

  4978.     }
    4979. 

  4979.     else
    4980. 

  4980.     {
    4981. 

  4981.         pc_walktoxy_sub (sd);
    4982. 

  4982.     }
    4983. 

  4983. 

  4984.     return 0;
    4985. 

  4985. }
    4986. 

  4986. 

  4987. /*==========================================
    4988. 

  4988.  * 歩 行停止 
    4989. 

  4989.  *------------------------------------------
    4990. 

  4990.  */
    4991. 

  4991. int pc_stop_walking (struct map_session_data *sd, int type)
    4992. 

  4992. {
    4993. 

  4993.     nullpo_retr (0, sd);
    4994. 

  4994. 

  4995.     if (sd->walktimer != -1)
    4996. 

  4996.     {
    4997. 

  4997.         delete_timer (sd->walktimer, pc_walk);
    4998. 

  4998.         sd->walktimer = -1;
    4999. 

  4999.     }
    5000. 

  5000.     sd->walkpath.path_len = 0;
    5001. 

  5001.     sd->to_x = sd->bl.x;
    5002. 

  5002.     sd->to_y = sd->bl.y;
    5003. 

  5003.     if (type & 0x01)
    5004. 

  5004.         clif_fixpos (&sd->bl);
    5005. 

  5005.     if (type & 0x02 && battle_config.pc_damage_delay)
    5006. 

  5006.     {
    5007. 

  5007.         unsigned int tick = gettick ();
    5008. 

  5008.         int  delay = battle_get_dmotion (&sd->bl);
    5009. 

  5009.         if (sd->canmove_tick < tick)
    5010. 

  5010.             sd->canmove_tick = tick + delay;
    5011. 

  5011.     }
    5012. 

  5012. 

  5013.     return 0;
    5014. 

  5014. }
    5015. 

  5015. 

  5016. void pc_touch_all_relevant_npcs (struct map_session_data *sd)
    5017. 

  5017. {
    5018. 

  5018.     if (!sd)
    5019. 

  5019.         return;
    5020. 

  5020. 

  5021.     if (map_getcell (sd->bl.m, sd->bl.x, sd->bl.y) & 0x80)
    5022. 

  5022.         npc_touch_areanpc (sd, sd->bl.m, sd->bl.x, sd->bl.y);
    5023. 

  5023.     else
    5024. 

  5024.         npc_untouch_areanpc(sd);
    5025. 

  5025. }
    5026. 

  5026. 

  5027. /*==========================================
    5028. 

  5028.  *
    5029. 

  5029.  *------------------------------------------
    5030. 

  5030.  */
    5031. 

  5031. int pc_movepos (struct map_session_data *sd, int dst_x, int dst_y)
    5032. 

  5032. {
    5033. 

  5033.     int  moveblock;
    5034. 

  5034.     int  dx, dy, dist;
    5035. 

  5035. 

  5036.     struct walkpath_data wpd;
    5037. 

  5037. 

  5038.     nullpo_retr (0, sd);
    5039. 

  5039. 

  5040.     if (path_search (&wpd, sd->bl.m, sd->bl.x, sd->bl.y, dst_x, dst_y, 0))
    5041. 

  5041.         return 1;
    5042. 

  5042. 

  5043.     sd->dir = sd->head_dir = map_calc_dir (&sd->bl, dst_x, dst_y);
    5044. 

  5044. 

  5045.     dx = dst_x - sd->bl.x;
    5046. 

  5046.     dy = dst_y - sd->bl.y;
    5047. 

  5047.     dist = distance (sd->bl.x, sd->bl.y, dst_x, dst_y);
    5048. 

  5048. 

  5049.     moveblock = (sd->bl.x / BLOCK_SIZE != dst_x / BLOCK_SIZE
    5050. 

  5050.                  || sd->bl.y / BLOCK_SIZE != dst_y / BLOCK_SIZE);
    5051. 

  5051. 

  5052.     map_foreachinmovearea (clif_pcoutsight, sd->bl.m, sd->bl.x - AREA_SIZE,
    5053. 

  5053.                            sd->bl.y - AREA_SIZE, sd->bl.x + AREA_SIZE,
    5054. 

  5054.                            sd->bl.y + AREA_SIZE, dx, dy, 0, sd);
    5055. 

  5055. 

  5056.     if (moveblock)
    5057. 

  5057.         map_delblock (&sd->bl);
    5058. 

  5058.     sd->bl.x = dst_x;
    5059. 

  5059.     sd->bl.y = dst_y;
    5060. 

  5060.     if (moveblock)
    5061. 

  5061.         map_addblock (&sd->bl);
    5062. 

  5062. 

  5063.     map_foreachinmovearea (clif_pcinsight, sd->bl.m, sd->bl.x - AREA_SIZE,
    5064. 

  5064.                            sd->bl.y - AREA_SIZE, sd->bl.x + AREA_SIZE,
    5065. 

  5065.                            sd->bl.y + AREA_SIZE, -dx, -dy, 0, sd);
    5066. 

  5066. 

  5067.     if (sd->status.party_id > 0)
    5068. 

  5068.      {                           // パーティのＨＰ情報通知検査
    5069. 

  5069.         struct party *p = party_search (sd->status.party_id);
    5070. 

  5070.         if (p != NULL)
    5071. 

  5071.         {
    5072. 

  5072.             int  flag = 0;
    5073. 

  5073.             map_foreachinmovearea (party_send_hp_check, sd->bl.m,
    5074. 

  5074.                                    sd->bl.x - AREA_SIZE, sd->bl.y - AREA_SIZE,
    5075. 

  5075.                                    sd->bl.x + AREA_SIZE, sd->bl.y + AREA_SIZE,
    5076. 

  5076.                                    -dx, -dy, BL_PC, sd->status.party_id,
    5077. 

  5077.                                    &flag);
    5078. 

  5078.             if (flag)
    5079. 

  5079.                 sd->party_hp = -1;
    5080. 

  5080.         }
    5081. 

  5081.     }
    5082. 

  5082. 

  5083.     if (sd->status.option & 4)  // クローキングの消滅検査 
    5084. 

  5084.         skill_check_cloaking (&sd->bl);
    5085. 

  5085. 

  5086.     skill_unit_move (&sd->bl, gettick (), dist + 7);    // スキルユニットの検査 
    5087. 

  5087. 

  5088.     pc_touch_all_relevant_npcs (sd);
    5089. 

  5089.     return 0;
    5090. 

  5090. }
    5091. 

  5091. 

  5092. //
    5093. 

  5093. // 武器戦闘 
    5094. 

  5094. //
    5095. 

  5095. /*==========================================
    5096. 

  5096.  * スキルの検索 所有していた場合Lvが返る 
    5097. 

  5097.  *------------------------------------------
    5098. 

  5098.  */
    5099. 

  5099. int pc_checkskill (struct map_session_data *sd, int skill_id)
    5100. 

  5100. {
    5101. 

  5101.     if (sd == NULL)
    5102. 

  5102.         return 0;
    5103. 

  5103.     if (skill_id >= 10000)
    5104. 

  5104.     {
    5105. 

  5105.         struct guild *g;
    5106. 

  5106.         if (sd->status.guild_id > 0
    5107. 

  5107.             && (g = guild_search (sd->status.guild_id)) != NULL)
    5108. 

  5108.             return guild_checkskill (g, skill_id);
    5109. 

  5109.         return 0;
    5110. 

  5110.     }
    5111. 

  5111. 

  5112.     if (skill_id < 0 || skill_id >= MAX_SKILL)
    5113. 

  5113.         return 0;
    5114. 

  5114. 

  5115.     if (sd->status.skill[skill_id].id == skill_id)
    5116. 

  5116.         return (sd->status.skill[skill_id].lv);
    5117. 

  5117. 

  5118.     return 0;
    5119. 

  5119. }
    5120. 

  5120. 

  5121. /*==========================================
    5122. 

  5122.  * 武器変更によるスキルの継続チェック 
    5123. 

  5123.  * 引数： 
    5124. 

  5124.  *   struct map_session_data *sd	セッションデータ 
    5125. 

  5125.  *   int nameid						装備品ID 
    5126. 

  5126.  * 返り値： 
    5127. 

  5127.  *   0		変更なし 
    5128. 

  5128.  *   -1		スキルを解除 
    5129. 

  5129.  *------------------------------------------
    5130. 

  5130.  */
    5131. 

  5131. int pc_checkallowskill (struct map_session_data *sd)
    5132. 

  5132. {
    5133. 

  5133.     nullpo_retr (0, sd);
    5134. 

  5134. 

  5135.     if (sd->sc_data == NULL)
    5136. 

  5136.         return 0;
    5137. 

  5137. 

  5138.     if (!(skill_get_weapontype (KN_TWOHANDQUICKEN) & (1 << sd->status.weapon))
    5139. 

  5139.         && sd->sc_data[SC_TWOHANDQUICKEN].timer != -1)
    5140. 

  5140.     {                           // 2HQ
    5141. 

  5141.         skill_status_change_end (&sd->bl, SC_TWOHANDQUICKEN, -1);   // 2HQを解除 
    5142. 

  5142.         return -1;
    5143. 

  5143.     }
    5144. 

  5144.     if (!(skill_get_weapontype (LK_AURABLADE) & (1 << sd->status.weapon))
    5145. 

  5145.         && sd->sc_data[SC_AURABLADE].timer != -1)
    5146. 

  5146.      {                           /* オーラブレード */ 
    5147. 

  5147.         skill_status_change_end (&sd->bl, SC_AURABLADE, -1);    /* オーラブレードを解除 */ 
    5148. 

  5148.         return -1;
    5149. 

  5149.     }
    5150. 

  5150.     if (!(skill_get_weapontype (LK_PARRYING) & (1 << sd->status.weapon))
    5151. 

  5151.         && sd->sc_data[SC_PARRYING].timer != -1)
    5152. 

  5152.      {                           /* パリイング */ 
    5153. 

  5153.         skill_status_change_end (&sd->bl, SC_PARRYING, -1); /* パリイングを解除 */ 
    5154. 

  5154.         return -1;
    5155. 

  5155.     }
    5156. 

  5156.     if (!(skill_get_weapontype (LK_CONCENTRATION) & (1 << sd->status.weapon))
    5157. 

  5157.         && sd->sc_data[SC_CONCENTRATION].timer != -1)
    5158. 

  5158.      {                           /* コンセントレーション */ 
    5159. 

  5159.         skill_status_change_end (&sd->bl, SC_CONCENTRATION, -1);    /* コンセントレーションを解除 */ 
    5160. 

  5160.         return -1;
    5161. 

  5161.     }
    5162. 

  5162.     if (!(skill_get_weapontype (CR_SPEARQUICKEN) & (1 << sd->status.weapon))
    5163. 

  5163.         && sd->sc_data[SC_SPEARSQUICKEN].timer != -1)
    5164. 

  5164.      {                            // スピアクィッケン 
    5165. 

  5165.         skill_status_change_end (&sd->bl, SC_SPEARSQUICKEN, -1);     // スピアクイッケンを解除 
    5166. 

  5166.         return -1;
    5167. 

  5167.     }
    5168. 

  5168.     if (!(skill_get_weapontype (BS_ADRENALINE) & (1 << sd->status.weapon))
    5169. 

  5169.         && sd->sc_data[SC_ADRENALINE].timer != -1)
    5170. 

  5170.      {                           // アドレナリンラッシュ 
    5171. 

  5171.         skill_status_change_end (&sd->bl, SC_ADRENALINE, -1);   // アドレナリンラッシュを解除 
    5172. 

  5172.         return -1;
    5173. 

  5173.     }
    5174. 

  5174. 

  5175.     if (sd->status.shield <= 0)
    5176. 

  5176.     {
    5177. 

  5177.         if (sd->sc_data[SC_AUTOGUARD].timer != -1)
    5178. 

  5178.           {                       // オートガード 
    5179. 

  5179.             skill_status_change_end (&sd->bl, SC_AUTOGUARD, -1);
    5180. 

  5180.             return -1;
    5181. 

  5181.         }
    5182. 

  5182.         if (sd->sc_data[SC_DEFENDER].timer != -1)
    5183. 

  5183.           {                       // ディフェンダー 
    5184. 

  5184.             skill_status_change_end (&sd->bl, SC_DEFENDER, -1);
    5185. 

  5185.             return -1;
    5186. 

  5186.         }
    5187. 

  5187.         if (sd->sc_data[SC_REFLECTSHIELD].timer != -1)
    5188. 

  5188.           {                       //リフレクトシールド 
    5189. 

  5189.             skill_status_change_end (&sd->bl, SC_REFLECTSHIELD, -1);
    5190. 

  5190.             return -1;
    5191. 

  5191.         }
    5192. 

  5192.     }
    5193. 

  5193. 

  5194.     return 0;
    5195. 

  5195. }
    5196. 

  5196. 

  5197. /*==========================================
    5198. 

  5198.  * 装 備品のチェック 
    5199. 

  5199.  *------------------------------------------
    5200. 

  5200.  */
    5201. 

  5201. int pc_checkequip (struct map_session_data *sd, int pos)
    5202. 

  5202. {
    5203. 

  5203.     int  i;
    5204. 

  5204. 

  5205.     nullpo_retr (-1, sd);
    5206. 

  5206. 

  5207.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    5208. 

  5208.     {
    5209. 

  5209.         if (pos & equip_pos[i])
    5210. 

  5210.             return sd->equip_index[i];
    5211. 

  5211.     }
    5212. 

  5212. 

  5213.     return -1;
    5214. 

  5214. }
    5215. 

  5215. 

  5216. /*==========================================
    5217. 

  5217.  * 転生職や養子職の元の職業を返す 
    5218. 

  5218.  *------------------------------------------
    5219. 

  5219.  */
    5220. 

  5220. struct pc_base_job pc_calc_base_job (int b_class)
    5221. 

  5221. {
    5222. 

  5222.     struct pc_base_job bj;
    5223. 

  5223.     //転生や養子の場合の元の職業を算出する 
    5224. 

  5224.     if (b_class < MAX_PC_CLASS)
    5225. 

  5225.     {                           //通常 
    5226. 

  5226.         bj.job = b_class;
    5227. 

  5227.         bj.upper = 0;
    5228. 

  5228.     }
    5229. 

  5229.     else if (b_class >= 4001 && b_class < 4023)
    5230. 

  5230.     {                           //転生職 
    5231. 

  5231.         bj.job = b_class - 4001;
    5232. 

  5232.         bj.upper = 1;
    5233. 

  5233.     }
    5234. 

  5234.     else if (b_class == 23 + 4023 - 1)
    5235. 

  5235.     {                           //養子スパノビ 
    5236. 

  5236.         bj.job = b_class - (4023 - 1);
    5237. 

  5237.         bj.upper = 2;
    5238. 

  5238.     }
    5239. 

  5239.     else
    5240. 

  5240.     {                           //養子スパノビ以外の養子 
    5241. 

  5241.         bj.job = b_class - 4023;
    5242. 

  5242.         bj.upper = 2;
    5243. 

  5243.     }
    5244. 

  5244. 

  5245.     if (battle_config.enable_upper_class == 0)
    5246. 

  5246.     {                           //confで無効になっていたらupper=0 
    5247. 

  5247.         bj.upper = 0;
    5248. 

  5248.     }
    5249. 

  5249. 

  5250.     if (bj.job == 0)
    5251. 

  5251.     {
    5252. 

  5252.         bj.type = 0;
    5253. 

  5253.     }
    5254. 

  5254.     else if (bj.job < 7)
    5255. 

  5255.     {
    5256. 

  5256.         bj.type = 1;
    5257. 

  5257.     }
    5258. 

  5258.     else
    5259. 

  5259.     {
    5260. 

  5260.         bj.type = 2;
    5261. 

  5261.     }
    5262. 

  5262. 

  5263.     return bj;
    5264. 

  5264. }
    5265. 

  5265. 

  5266. /*==========================================
    5267. 

  5267.  * PCの攻撃 (timer関数) 
    5268. 

  5268.  *------------------------------------------
    5269. 

  5269.  */
    5270. 

  5270. int pc_attack_timer (int tid, unsigned int tick, int id,
    5271. 

  5271.                      int data __attribute__ ((unused)))
    5272. 

  5272. {
    5273. 

  5273.     struct map_session_data *sd;
    5274. 

  5274.     struct block_list *bl;
    5275. 

  5275.     struct status_change *sc_data;
    5276. 

  5276.     short *opt;
    5277. 

  5277.     int  attack_spell_delay;
    5278. 

  5278. 

  5279.     sd = map_id2sd (id);
    5280. 

  5280.     if (sd == NULL)
    5281. 

  5281.         return 0;
    5282. 

  5282.     if (sd->attacktimer != tid)
    5283. 

  5283.     {
    5284. 

  5284.         if (battle_config.error_log)
    5285. 

  5285.             printf ("pc_attack_timer %d != %d\n", sd->attacktimer, tid);
    5286. 

  5286.         return 0;
    5287. 

  5287.     }
    5288. 

  5288.     if (sd->attacktimer != -1)
    5289. 

  5289.         pc_delattacktimer (sd);
    5290. 

  5290. //    sd->attacktimer = -1;
    5291. 

  5291. 

  5292.     if (sd->bl.prev == NULL)
    5293. 

  5293.         return 0;
    5294. 

  5294. 

  5295.     bl = map_id2bl (sd->attacktarget);
    5296. 

  5296.     if (bl == NULL || bl->prev == NULL)
    5297. 

  5297.         return 0;
    5298. 

  5298. 

  5299.     if (bl->type == BL_PC && pc_isdead ((struct map_session_data *) bl))
    5300. 

  5300.         return 0;
    5301. 

  5301. 

  5302.     // 同じmapでないなら攻撃しない 
    5303. 

  5303.     // PCが死んでても攻撃しない 
    5304. 

  5304.     if (sd->bl.m != bl->m || pc_isdead (sd))
    5305. 

  5305.         return 0;
    5306. 

  5306. 

  5307.     if (sd->opt1 > 0 || sd->status.option & 2 || sd->status.option & 16388) // 異常などで攻撃できない 
    5308. 

  5308.         return 0;
    5309. 

  5309. 

  5310.     if (sd->sc_data[SC_AUTOCOUNTER].timer != -1)
    5311. 

  5311.         return 0;
    5312. 

  5312.     if (sd->sc_data[SC_BLADESTOP].timer != -1)
    5313. 

  5313.         return 0;
    5314. 

  5314. 

  5315.     if ((opt = battle_get_option (bl)) != NULL && *opt & 0x46)
    5316. 

  5316.         return 0;
    5317. 

  5317.     if (((sc_data = battle_get_sc_data (bl)) != NULL
    5318. 

  5318.          && sc_data[SC_TRICKDEAD].timer != -1)
    5319. 

  5319.         || ((sc_data = battle_get_sc_data (bl)) != NULL
    5320. 

  5320.             && sc_data[SC_BASILICA].timer != -1))
    5321. 

  5321.         return 0;
    5322. 

  5322. 

  5323.     if (sd->skilltimer != -1 && pc_checkskill (sd, SA_FREECAST) <= 0)
    5324. 

  5324.         return 0;
    5325. 

  5325. 

  5326.     if (!battle_config.sdelay_attack_enable
    5327. 

  5327.         && pc_checkskill (sd, SA_FREECAST) <= 0)
    5328. 

  5328.     {
    5329. 

  5329.         if (DIFF_TICK (tick, sd->canact_tick) < 0)
    5330. 

  5330.         {
    5331. 

  5331.             clif_skill_fail (sd, 1, 4, 0);
    5332. 

  5332.             return 0;
    5333. 

  5333.         }
    5334. 

  5334.     }
    5335. 

  5335. 

  5336.     if (sd->attackabletime > tick)
    5337. 

  5337.         return 0;               // cannot attack yet
    5338. 

  5338. 

  5339.     attack_spell_delay = sd->attack_spell_delay;
    5340. 

  5340.     if (attack_spell_delay < battle_config.max_aspd)
    5341. 

  5341.     {
    5342. 

  5342.         attack_spell_delay = battle_config.max_aspd;
    5343. 

  5343.     }
    5344. 

  5344. 

  5345.     if (sd->attack_spell_override   // [Fate] If we have an active attack spell, use that
    5346. 

  5346.         && spell_attack (id, sd->attacktarget))
    5347. 

  5347.     {
    5348. 

  5348.         // Return if the spell succeeded.  If the spell had disspiated, spell_attack() may fail.
    5349. 

  5349.         sd->attackabletime = tick + attack_spell_delay;
    5350. 

  5350. 

  5351.     }
    5352. 

  5352.     else
    5353. 

  5353.     {
    5354. 

  5354.         int  dist, range;
    5355. 

  5355.         dist = distance (sd->bl.x, sd->bl.y, bl->x, bl->y);
    5356. 

  5356.         range = sd->attackrange;
    5357. 

  5357.         if (sd->status.weapon != 11)
    5358. 

  5358.             range++;
    5359. 

  5359.         if (dist > range)
    5360. 

  5360.         {                       // 届 かないので移動 
    5361. 

  5361.             //if(pc_can_reach(sd,bl->x,bl->y))
    5362. 

  5362.             //clif_movetoattack(sd,bl);
    5363. 

  5363.             return 0;
    5364. 

  5364.         }
    5365. 

  5365. 

  5366.         if (dist <= range && !battle_check_range (&sd->bl, bl, range))
    5367. 

  5367.         {
    5368. 

  5368.             if (pc_can_reach (sd, bl->x, bl->y) && sd->canmove_tick < tick
    5369. 

  5369.                 && (sd->sc_data[SC_ANKLE].timer == -1
    5370. 

  5370.                     || sd->sc_data[SC_SPIDERWEB].timer == -1))
    5371. 

  5371.                 // TMW client doesn't support this
    5372. 

  5372.                 //pc_walktoxy(sd,bl->x,bl->y);
    5373. 

  5373.                 clif_movetoattack (sd, bl);
    5374. 

  5374.             sd->attackabletime = tick + (sd->aspd << 1);
    5375. 

  5375.         }
    5376. 

  5376.         else
    5377. 

  5377.         {
    5378. 

  5378.             int  skill;
    5379. 

  5379. 

  5380.             if (battle_config.pc_attack_direction_change)
    5381. 

  5381.                 sd->dir = sd->head_dir = map_calc_dir (&sd->bl, bl->x, bl->y);  // 向き設定 
    5382. 

  5382. 

  5383.             if (sd->walktimer != -1)
    5384. 

  5384.                 pc_stop_walking (sd, 1);
    5385. 

  5385. 

  5386.             if (sd->sc_data[SC_COMBO].timer == -1)
    5387. 

  5387.             {
    5388. 

  5388.                 map_freeblock_lock ();
    5389. 

  5389.                 pc_stop_walking (sd, 0);
    5390. 

  5390.                 sd->attacktarget_lv =
    5391. 

  5391.                     battle_weapon_attack (&sd->bl, bl, tick, 0);
    5392. 

  5392.                 if (!(battle_config.pc_cloak_check_type & 2)
    5393. 

  5393.                     && sd->sc_data[SC_CLOAKING].timer != -1)
    5394. 

  5394.                     skill_status_change_end (&sd->bl, SC_CLOAKING, -1);
    5395. 

  5395.                 map_freeblock_unlock ();
    5396. 

  5396. 

  5397.                 if (sd->skilltimer != -1 && (skill = pc_checkskill (sd, SA_FREECAST)) > 0)  // フリーキャスト 
    5398. 

  5398.                     sd->attackabletime =
    5399. 

  5399.                         tick + ((sd->aspd << 1) * (150 - skill * 5) / 100);
    5400. 

  5400.                 else
    5401. 

  5401.                     sd->attackabletime = tick + (sd->aspd << 1);
    5402. 

  5402.             }
    5403. 

  5403.             else if (sd->attackabletime <= tick)
    5404. 

  5404.             {
    5405. 

  5405.                 if (sd->skilltimer != -1 && (skill = pc_checkskill (sd, SA_FREECAST)) > 0)
    5406. 

  5406.                     sd->attackabletime =
    5407. 

  5407.                         tick + ((sd->aspd << 1) * (150 - skill * 5) / 100);
    5408. 

  5408.                 else
    5409. 

  5409.                     sd->attackabletime = tick + (sd->aspd << 1);
    5410. 

  5410.             }
    5411. 

  5411.             if (sd->attackabletime <= tick)
    5412. 

  5412.                 sd->attackabletime = tick + (battle_config.max_aspd << 1);
    5413. 

  5413.         }
    5414. 

  5414.     }
    5415. 

  5415. 

  5416.     if (sd->state.attack_continue)
    5417. 

  5417.     {
    5418. 

  5418.         sd->attacktimer =
    5419. 

  5419.             add_timer (sd->attackabletime, pc_attack_timer, sd->bl.id, 0);
    5420. 

  5420.     }
    5421. 

  5421. 

  5422.     return 0;
    5423. 

  5423. }
    5424. 

  5424. 

  5425. /*==========================================
    5426. 

  5426.  * 攻撃要求 
    5427. 

  5427.  * typeが1なら継続攻撃 
    5428. 

  5428.  *------------------------------------------
    5429. 

  5429.  */
    5430. 

  5430. int pc_attack (struct map_session_data *sd, int target_id, int type)
    5431. 

  5431. {
    5432. 

  5432.     struct block_list *bl;
    5433. 

  5433.     int  d;
    5434. 

  5434. 

  5435.     nullpo_retr (0, sd);
    5436. 

  5436. 

  5437.     bl = map_id2bl (target_id);
    5438. 

  5438.     if (bl == NULL)
    5439. 

  5439.         return 1;
    5440. 

  5440. 

  5441.     if (bl->type == BL_NPC)
    5442. 

  5442.     {                           // monster npcs [Valaris]
    5443. 

  5443.         npc_click (sd, RFIFOL (sd->fd, 2), 0);
    5444. 

  5444.         return 0;
    5445. 

  5445.     }
    5446. 

  5446. 

  5447.     if (!battle_check_target (&sd->bl, bl, BCT_ENEMY))
    5448. 

  5448.         return 1;
    5449. 

  5449.     if (sd->attacktimer != -1)
    5450. 

  5450.         pc_stopattack (sd);
    5451. 

  5451.     sd->attacktarget = target_id;
    5452. 

  5452.     sd->state.attack_continue = type;
    5453. 

  5453. 

  5454.     d = DIFF_TICK (sd->attackabletime, gettick ());
    5455. 

  5455.     if (d > 0 && d < 2000)
    5456. 

  5456.     {                           // 攻撃delay中 
    5457. 

  5457.         sd->attacktimer =
    5458. 

  5458.             add_timer (sd->attackabletime, pc_attack_timer, sd->bl.id, 0);
    5459. 

  5459.     }
    5460. 

  5460.     else
    5461. 

  5461.     {
    5462. 

  5462.         // 本来timer関数なので引数を合わせる 
    5463. 

  5463.         pc_attack_timer (-1, gettick (), sd->bl.id, 0);
    5464. 

  5464.     }
    5465. 

  5465. 

  5466.     return 0;
    5467. 

  5467. }
    5468. 

  5468. 

  5469. /*==========================================
    5470. 

  5470.  * 継続攻撃停止 
    5471. 

  5471.  *------------------------------------------
    5472. 

  5472.  */
    5473. 

  5473. int pc_stopattack (struct map_session_data *sd)
    5474. 

  5474. {
    5475. 

  5475.     nullpo_retr (0, sd);
    5476. 

  5476. 

  5477.     if (sd->attacktimer != -1)
    5478. 

  5478.     {
    5479. 

  5479.         delete_timer (sd->attacktimer, pc_attack_timer);
    5480. 

  5480.         sd->attacktimer = -1;
    5481. 

  5481.     }
    5482. 

  5482.     sd->attacktarget = 0;
    5483. 

  5483.     sd->state.attack_continue = 0;
    5484. 

  5484. 

  5485.     return 0;
    5486. 

  5486. }
    5487. 

  5487. 

  5488. int pc_follow_timer (int tid, unsigned int tick, int id,
    5489. 

  5489.                      int data __attribute__ ((unused)))
    5490. 

  5490. {
    5491. 

  5491.     struct map_session_data *sd, *bl;
    5492. 

  5492. 

  5493.     sd = map_id2sd (id);
    5494. 

  5494.     if (sd == NULL || sd->followtimer != tid)
    5495. 

  5495.         return 0;
    5496. 

  5496. 

  5497.     sd->followtimer = -1;
    5498. 

  5498. 

  5499.     do
    5500. 

  5500.     {
    5501. 

  5501.         if (sd->bl.prev == NULL)
    5502. 

  5502.             break;
    5503. 

  5503. 

  5504.         bl = (struct map_session_data *) map_id2bl (sd->followtarget);
    5505. 

  5505. 

  5506.         if (bl == NULL)
    5507. 

  5507.             return 0;
    5508. 

  5508. 

  5509.         if (bl->bl.prev == NULL)
    5510. 

  5510.             break;
    5511. 

  5511. 

  5512.         if (bl->bl.type == BL_PC
    5513. 

  5513.             && pc_isdead ((struct map_session_data *) bl))
    5514. 

  5514.             return 0;
    5515. 

  5515. 

  5516.         if (sd->skilltimer == -1 && sd->attacktimer == -1
    5517. 

  5517.             && sd->walktimer == -1)
    5518. 

  5518.         {
    5519. 

  5519.             if ((sd->bl.m == bl->bl.m)
    5520. 

  5520.                 && pc_can_reach (sd, bl->bl.x, bl->bl.y))
    5521. 

  5521.             {
    5522. 

  5522.                 if (distance (sd->bl.x, sd->bl.y, bl->bl.x, bl->bl.y) > 5)
    5523. 

  5523.                     pc_walktoxy (sd, bl->bl.x, bl->bl.y);
    5524. 

  5524.             }
    5525. 

  5525.             else
    5526. 

  5526.                 pc_setpos ((struct map_session_data *) sd, bl->mapname,
    5527. 

  5527.                            bl->bl.x, bl->bl.y, 3);
    5528. 

  5528.         }
    5529. 

  5529.     }
    5530. 

  5530.     while (0);
    5531. 

  5531. 

  5532.     sd->followtimer =
    5533. 

  5533.         add_timer (tick + sd->aspd, pc_follow_timer, sd->bl.id, 0);
    5534. 

  5534. 

  5535.     return 0;
    5536. 

  5536. }
    5537. 

  5537. 

  5538. int pc_follow (struct map_session_data *sd, int target_id)
    5539. 

  5539. {
    5540. 

  5540.     struct block_list *bl;
    5541. 

  5541. 

  5542.     nullpo_retr (0, sd);
    5543. 

  5543. 

  5544.     bl = map_id2bl (target_id);
    5545. 

  5545.     if (bl == NULL)
    5546. 

  5546.         return 1;
    5547. 

  5547.     sd->followtarget = target_id;
    5548. 

  5548.     if (sd->followtimer != -1)
    5549. 

  5549.     {
    5550. 

  5550.         delete_timer (sd->followtimer, pc_follow_timer);
    5551. 

  5551.         sd->followtimer = -1;
    5552. 

  5552.     }
    5553. 

  5553. 

  5554.     pc_follow_timer (-1, gettick (), sd->bl.id, 0);
    5555. 

  5555. 

  5556.     return 0;
    5557. 

  5557. }
    5558. 

  5558. 

  5559. int pc_checkbaselevelup (struct map_session_data *sd)
    5560. 

  5560. {
    5561. 

  5561.     nullpo_retr (0, sd);
    5562. 

  5562. 

  5563.     int  next = pc_nextbaseexp (sd);
    5564. 

  5564. 

  5565.     if (sd->status.base_exp >= next && next > 0)
    5566. 

  5566.     {
    5567. 

  5567.         struct pc_base_job s_class = pc_calc_base_job (sd->status.class);
    5568. 

  5568. 

  5569.         // base側レベルアップ処理 
    5570. 

  5570.         sd->status.base_exp -= next;
    5571. 

  5571. 

  5572.         sd->status.base_level++;
    5573. 

  5573.         sd->status.status_point += (sd->status.base_level + 14) / 4;
    5574. 

  5574.         clif_updatestatus (sd, SP_STATUSPOINT);
    5575. 

  5575.         clif_updatestatus (sd, SP_BASELEVEL);
    5576. 

  5576.         clif_updatestatus (sd, SP_NEXTBASEEXP);
    5577. 

  5577.         pc_calcstatus (sd, 0);
    5578. 

  5578.         pc_heal (sd, sd->status.max_hp, sd->status.max_sp);
    5579. 

  5579. 

  5580.           //スパノビはキリエ、イムポ、マニピ、グロ、サフラLv1がかかる 
    5581. 

  5581.         if (s_class.job == 23)
    5582. 

  5582.         {
    5583. 

  5583.             skill_status_change_start (&sd->bl,
    5584. 

  5584.                                        SkillStatusChangeTable[PR_KYRIE], 1, 0,
    5585. 

  5585.                                        0, 0, skill_get_time (PR_KYRIE, 1), 0);
    5586. 

  5586.             skill_status_change_start (&sd->bl,
    5587. 

  5587.                                        SkillStatusChangeTable[PR_IMPOSITIO],
    5588. 

  5588.                                        1, 0, 0, 0,
    5589. 

  5589.                                        skill_get_time (PR_IMPOSITIO, 1), 0);
    5590. 

  5590.             skill_status_change_start (&sd->bl,
    5591. 

  5591.                                        SkillStatusChangeTable[PR_MAGNIFICAT],
    5592. 

  5592.                                        1, 0, 0, 0,
    5593. 

  5593.                                        skill_get_time (PR_MAGNIFICAT, 1), 0);
    5594. 

  5594.             skill_status_change_start (&sd->bl,
    5595. 

  5595.                                        SkillStatusChangeTable[PR_GLORIA], 1,
    5596. 

  5596.                                        0, 0, 0, skill_get_time (PR_GLORIA, 1),
    5597. 

  5597.                                        0);
    5598. 

  5598.             skill_status_change_start (&sd->bl,
    5599. 

  5599.                                        SkillStatusChangeTable[PR_SUFFRAGIUM],
    5600. 

  5600.                                        1, 0, 0, 0,
    5601. 

  5601.                                        skill_get_time (PR_SUFFRAGIUM, 1), 0);
    5602. 

  5602.         }
    5603. 

  5603. 

  5604.         clif_misceffect (&sd->bl, 0);
    5605. 

  5605.           //レベルアップしたのでパーティー情報を更新する 
    5606. 

  5606.         //(公平範囲チェック) 
    5607. 

  5607.         party_send_movemap (sd);
    5608. 

  5608.         MAP_LOG_XP (sd, "LEVELUP") return 1;
    5609. 

  5609.     }
    5610. 

  5610. 

  5611.     return 0;
    5612. 

  5612. }
    5613. 

  5613. 

  5614. /*========================================
    5615. 

  5615.  * Compute the maximum for sd->skill_point, i.e., the max. number of skill points that can still be filled in
    5616. 

  5616.  *----------------------------------------
    5617. 

  5617.  */
    5618. 

  5618. int pc_skillpt_potential (struct map_session_data *sd)
    5619. 

  5619. {
    5620. 

  5620.     int  skill_id;
    5621. 

  5621.     int  potential = 0;
    5622. 

  5622. 

  5623.     nullpo_retr (0, sd);
    5624. 

  5624. 

  5625. #define RAISE_COST(x) (((x)*((x)-1))>>1)
    5626. 

  5626. 

  5627.     for (skill_id = 0; skill_id < MAX_SKILL; skill_id++)
    5628. 

  5628.         if (sd->status.skill[skill_id].id != 0
    5629. 

  5629.             && sd->status.skill[skill_id].lv < skill_db[skill_id].max_raise)
    5630. 

  5630.             potential += RAISE_COST (skill_db[skill_id].max_raise)
    5631. 

  5631.                 - RAISE_COST (sd->status.skill[skill_id].lv);
    5632. 

  5632. #undef RAISE_COST
    5633. 

  5633. 

  5634.     return potential;
    5635. 

  5635. }
    5636. 

  5636. 

  5637. int pc_checkjoblevelup (struct map_session_data *sd)
    5638. 

  5638. {
    5639. 

  5639.     nullpo_retr (0, sd);
    5640. 

  5640. 

  5641.     int  next = pc_nextjobexp (sd);
    5642. 

  5642. 

  5643.     if (sd->status.job_exp >= next && next > 0)
    5644. 

  5644.     {
    5645. 

  5645.         if (pc_skillpt_potential (sd) < sd->status.skill_point)
    5646. 

  5646.         {                       // [Fate] Bah, this is is painful.
    5647. 

  5647.             // But the alternative is quite error-prone, and eAthena has far worse performance issues...
    5648. 

  5648.             sd->status.job_exp = next - 1;
    5649. 

  5649.             pc_calcstatus(sd,0);
    5650. 

  5650.             return 0;
    5651. 

  5651.         }
    5652. 

  5652. 

  5653.         // job側レベルアップ処理 
    5654. 

  5654.         sd->status.job_exp -= next;
    5655. 

  5655.         clif_updatestatus (sd, SP_NEXTJOBEXP);
    5656. 

  5656.         sd->status.skill_point++;
    5657. 

  5657.         clif_updatestatus (sd, SP_SKILLPOINT);
    5658. 

  5658.         pc_calcstatus (sd, 0);
    5659. 

  5659. 

  5660.         MAP_LOG_PC (sd, "SKILLPOINTS-UP %d", sd->status.skill_point);
    5661. 

  5661. 

  5662.         if (sd->status.job_level < 250
    5663. 

  5663.             && sd->status.job_level < sd->status.base_level * 2)
    5664. 

  5664.             sd->status.job_level++; // Make levelling up a little harder
    5665. 

  5665. 

  5666.         clif_misceffect (&sd->bl, 1);
    5667. 

  5667.         return 1;
    5668. 

  5668.     }
    5669. 

  5669. 

  5670.     return 0;
    5671. 

  5671. }
    5672. 

  5672. 

  5673. /*==========================================
    5674. 

  5674.  * 経験値取得 
    5675. 

  5675.  *------------------------------------------
    5676. 

  5676.  */
    5677. 

  5677. int pc_gainexp (struct map_session_data *sd, int base_exp, int job_exp)
    5678. 

  5678. {
    5679. 

  5679.     return pc_gainexp_reason (sd, base_exp, job_exp,
    5680. 

  5680.                               PC_GAINEXP_REASON_KILLING);
    5681. 

  5681. }
    5682. 

  5682. 

  5683. int pc_gainexp_reason (struct map_session_data *sd, int base_exp, int job_exp,
    5684. 

  5684.                        int reason)
    5685. 

  5685. {
    5686. 

  5686.     char output[256];
    5687. 

  5687.     nullpo_retr (0, sd);
    5688. 

  5688. 

  5689.     if (sd->bl.prev == NULL || pc_isdead (sd))
    5690. 

  5690.         return 0;
    5691. 

  5691. 

  5692.     if ((battle_config.pvp_exp == 0) && map[sd->bl.m].flag.pvp) // [MouseJstr]
    5693. 

  5693.         return 0;               // no exp on pvp maps
    5694. 

  5694. 

  5695.     MAP_LOG_PC (sd, "GAINXP %d %d %s", base_exp, job_exp,
    5696. 

  5696.                 ((reason ==
    5697. 

  5697.                   2) ? "SCRIPTXP" : ((reason == 1) ? "HEALXP" : "KILLXP")));
    5698. 

  5698. 

  5699.     if (sd->sc_data[SC_RICHMANKIM].timer != -1)
    5700. 

  5700.     {                           // added bounds checking [Vaalris]
    5701. 

  5701.         base_exp +=
    5702. 

  5702.             base_exp * (25 + sd->sc_data[SC_RICHMANKIM].val1 * 25) / 100;
    5703. 

  5703.         job_exp +=
    5704. 

  5704.             job_exp * (25 + sd->sc_data[SC_RICHMANKIM].val1 * 25) / 100;
    5705. 

  5705.     }
    5706. 

  5706. 

  5707.     if (sd->status.guild_id > 0)
    5708. 

  5708.      {                           // ギルドに上納 
    5709. 

  5709.         base_exp -= guild_payexp (sd, base_exp);
    5710. 

  5710.         if (base_exp < 0)
    5711. 

  5711.             base_exp = 0;
    5712. 

  5712.     }
    5713. 

  5713. 

  5714.     if (!battle_config.multi_level_up && pc_nextbaseafter (sd))
    5715. 

  5715.     {
    5716. 

  5716.         while (sd->status.base_exp + base_exp >= pc_nextbaseafter (sd)
    5717. 

  5717.                && sd->status.base_exp <= pc_nextbaseexp (sd)
    5718. 

  5718.                && pc_nextbaseafter (sd) > 0)
    5719. 

  5719.         {
    5720. 

  5720.             base_exp *= .90;
    5721. 

  5721.         }
    5722. 

  5722.     }
    5723. 

  5723. 

  5724.     sd->status.base_exp += base_exp;
    5725. 

  5725. 

  5726.     // [Fate] Adjust experience points that healers can extract from this character
    5727. 

  5727.     if (reason != PC_GAINEXP_REASON_HEALING)
    5728. 

  5728.     {
    5729. 

  5729.         const int max_heal_xp =
    5730. 

  5730.             20 + (sd->status.base_level * sd->status.base_level);
    5731. 

  5731. 

  5732.         sd->heal_xp += base_exp;
    5733. 

  5733.         if (sd->heal_xp > max_heal_xp)
    5734. 

  5734.             sd->heal_xp = max_heal_xp;
    5735. 

  5735.     }
    5736. 

  5736. 

  5737.     if (sd->status.base_exp < 0)
    5738. 

  5738.         sd->status.base_exp = 0;
    5739. 

  5739. 

  5740.     while (pc_checkbaselevelup (sd));
    5741. 

  5741. 

  5742.     clif_updatestatus (sd, SP_BASEEXP);
    5743. 

  5743.     if (!battle_config.multi_level_up && pc_nextjobafter (sd))
    5744. 

  5744.     {
    5745. 

  5745.         while (sd->status.job_exp + job_exp >= pc_nextjobafter (sd)
    5746. 

  5746.                && sd->status.job_exp <= pc_nextjobexp (sd)
    5747. 

  5747.                && pc_nextjobafter (sd) > 0)
    5748. 

  5748.         {
    5749. 

  5749.             job_exp *= .90;
    5750. 

  5750.         }
    5751. 

  5751.     }
    5752. 

  5752. 

  5753.     sd->status.job_exp += job_exp;
    5754. 

  5754.     if (sd->status.job_exp < 0)
    5755. 

  5755.         sd->status.job_exp = 0;
    5756. 

  5756. 

  5757.     while (pc_checkjoblevelup (sd));
    5758. 

  5758. 

  5759.     clif_updatestatus (sd, SP_JOBEXP);
    5760. 

  5760. 

  5761.     if (battle_config.disp_experience)
    5762. 

  5762.     {
    5763. 

  5763.         sprintf (output,
    5764. 

  5764.                  "Experienced Gained Base:%d Job:%d", base_exp, job_exp);
    5765. 

  5765.         clif_disp_onlyself (sd, output, strlen (output));
    5766. 

  5766.     }
    5767. 

  5767. 

  5768.     return 0;
    5769. 

  5769. }
    5770. 

  5770. 

  5771. int pc_extract_healer_exp (struct map_session_data *sd, int max)
    5772. 

  5772. {
    5773. 

  5773.     int  amount;
    5774. 

  5774.     nullpo_retr (0, sd);
    5775. 

  5775. 

  5776.     amount = sd->heal_xp;
    5777. 

  5777.     if (max < amount)
    5778. 

  5778.         amount = max;
    5779. 

  5779. 

  5780.     sd->heal_xp -= amount;
    5781. 

  5781.     return amount;
    5782. 

  5782. }
    5783. 

  5783. 

  5784. /*==========================================
    5785. 

  5785.  * base level側必要経験値計算 
    5786. 

  5786.  *------------------------------------------
    5787. 

  5787.  */
    5788. 

  5788. int pc_nextbaseexp (struct map_session_data *sd)
    5789. 

  5789. {
    5790. 

  5790.     int  i;
    5791. 

  5791. 

  5792.     nullpo_retr (0, sd);
    5793. 

  5793. 

  5794.     if (sd->status.base_level >= MAX_LEVEL || sd->status.base_level <= 0)
    5795. 

  5795.         return 0;
    5796. 

  5796. 

  5797.     if (sd->status.class <= MAX_PLAYER_CLASS)
    5798. 

  5798.         i = 0;
    5799. 

  5799.     else if (sd->status.class <= 6)
    5800. 

  5800.         i = 1;
    5801. 

  5801.     else if (sd->status.class <= 22)
    5802. 

  5802.         i = 2;
    5803. 

  5803.     else if (sd->status.class == 23)
    5804. 

  5804.         i = 3;
    5805. 

  5805.     else if (sd->status.class == 4001)
    5806. 

  5806.         i = 4;
    5807. 

  5807.     else if (sd->status.class <= 4007)
    5808. 

  5808.         i = 5;
    5809. 

  5809.     else
    5810. 

  5810.         i = 6;
    5811. 

  5811. 

  5812.     return exp_table[i][sd->status.base_level - 1];
    5813. 

  5813. }
    5814. 

  5814. 

  5815. /*==========================================
    5816. 

  5816.  * job level側必要経験値計算 
    5817. 

  5817.  *------------------------------------------
    5818. 

  5818.  */
    5819. 

  5819. int pc_nextjobexp (struct map_session_data *sd)
    5820. 

  5820. {
    5821. 

  5821.     nullpo_retr (0, sd);
    5822. 

  5822. 

  5823.     // [fate]  For normal levels, this ranges from 20k to 50k, depending on job level.
    5824. 

  5824.     // Job level is at most twice the player's experience level (base_level).  Levelling
    5825. 

  5825.     // from 2 to 9 is 44 points, i.e., 880k to 2.2M job experience points (this is per
    5826. 

  5826.     // skill, obviously.)
    5827. 

  5827. 

  5828.     return 20000 + sd->status.job_level * 150;
    5829. 

  5829. }
    5830. 

  5830. 

  5831. /*==========================================
    5832. 

  5832.  * base level after next [Valaris]
    5833. 

  5833.  *------------------------------------------
    5834. 

  5834.  */
    5835. 

  5835. int pc_nextbaseafter (struct map_session_data *sd)
    5836. 

  5836. {
    5837. 

  5837.     int  i;
    5838. 

  5838. 

  5839.     nullpo_retr (0, sd);
    5840. 

  5840. 

  5841.     if (sd->status.base_level >= MAX_LEVEL || sd->status.base_level <= 0)
    5842. 

  5842.         return 0;
    5843. 

  5843. 

  5844.     if (sd->status.class <= MAX_PLAYER_CLASS)
    5845. 

  5845.         i = 0;
    5846. 

  5846.     else if (sd->status.class <= 6)
    5847. 

  5847.         i = 1;
    5848. 

  5848.     else if (sd->status.class <= 22)
    5849. 

  5849.         i = 2;
    5850. 

  5850.     else if (sd->status.class == 23)
    5851. 

  5851.         i = 3;
    5852. 

  5852.     else if (sd->status.class == 4001)
    5853. 

  5853.         i = 4;
    5854. 

  5854.     else if (sd->status.class <= 4007)
    5855. 

  5855.         i = 5;
    5856. 

  5856.     else
    5857. 

  5857.         i = 6;
    5858. 

  5858. 

  5859.     return exp_table[i][sd->status.base_level];
    5860. 

  5860. }
    5861. 

  5861. 

  5862. /*==========================================
    5863. 

  5863.  * job level after next [Valaris]
    5864. 

  5864.  *------------------------------------------
    5865. 

  5865.  */
    5866. 

  5866. int pc_nextjobafter (struct map_session_data *sd)
    5867. 

  5867. {
    5868. 

  5868.     int  i;
    5869. 

  5869. 

  5870.     nullpo_retr (0, sd);
    5871. 

  5871. 

  5872.     if (sd->status.job_level >= MAX_LEVEL || sd->status.job_level <= 0)
    5873. 

  5873.         return 0;
    5874. 

  5874. 

  5875.     if (sd->status.class <= MAX_PLAYER_CLASS)
    5876. 

  5876.         i = 7;
    5877. 

  5877.     else if (sd->status.class <= 6)
    5878. 

  5878.         i = 8;
    5879. 

  5879.     else if (sd->status.class <= 22)
    5880. 

  5880.         i = 9;
    5881. 

  5881.     else if (sd->status.class == 23)
    5882. 

  5882.         i = 10;
    5883. 

  5883.     else if (sd->status.class == 4001)
    5884. 

  5884.         i = 11;
    5885. 

  5885.     else if (sd->status.class <= 4007)
    5886. 

  5886.         i = 12;
    5887. 

  5887.     else
    5888. 

  5888.         i = 13;
    5889. 

  5889. 

  5890.     return exp_table[i][sd->status.job_level];
    5891. 

  5891. }
    5892. 

  5892. 

  5893. /*==========================================
    5894. 

  5894.  * 必要ステータスポイント計算 
    5895. 

  5895.  *------------------------------------------
    5896. 

  5896.  */
    5897. 

  5897. int pc_need_status_point (struct map_session_data *sd, int type)
    5898. 

  5898. {
    5899. 

  5899.     int  val;
    5900. 

  5900. 

  5901.     nullpo_retr (-1, sd);
    5902. 

  5902. 

  5903.     if (type < SP_STR || type > SP_LUK)
    5904. 

  5904.         return -1;
    5905. 

  5905.     val =
    5906. 

  5906.         type == SP_STR ? sd->status.str :
    5907. 

  5907.         type == SP_AGI ? sd->status.agi :
    5908. 

  5908.         type == SP_VIT ? sd->status.vit :
    5909. 

  5909.         type == SP_INT ? sd->status.int_ :
    5910. 

  5910.         type == SP_DEX ? sd->status.dex : sd->status.luk;
    5911. 

  5911. 

  5912.     return (val + 9) / 10 + 1;
    5913. 

  5913. }
    5914. 

  5914. 

  5915. /*==========================================
    5916. 

  5916.  * 能力値成長 
    5917. 

  5917.  *------------------------------------------
    5918. 

  5918.  */
    5919. 

  5919. int pc_statusup (struct map_session_data *sd, int type)
    5920. 

  5920. {
    5921. 

  5921.     int  need, val = 0;
    5922. 

  5922. 

  5923.     nullpo_retr (0, sd);
    5924. 

  5924. 

  5925.     switch (type)
    5926. 

  5926.     {
    5927. 

  5927.         case SP_STR:
    5928. 

  5928.             val = sd->status.str;
    5929. 

  5929.             break;
    5930. 

  5930.         case SP_AGI:
    5931. 

  5931.             val = sd->status.agi;
    5932. 

  5932.             break;
    5933. 

  5933.         case SP_VIT:
    5934. 

  5934.             val = sd->status.vit;
    5935. 

  5935.             break;
    5936. 

  5936.         case SP_INT:
    5937. 

  5937.             val = sd->status.int_;
    5938. 

  5938.             break;
    5939. 

  5939.         case SP_DEX:
    5940. 

  5940.             val = sd->status.dex;
    5941. 

  5941.             break;
    5942. 

  5942.         case SP_LUK:
    5943. 

  5943.             val = sd->status.luk;
    5944. 

  5944.             break;
    5945. 

  5945.         default:
    5946. 

  5946.             break;
    5947. 

  5947.     }
    5948. 

  5948. 

  5949.     need = pc_need_status_point (sd, type);
    5950. 

  5950.     if (type < SP_STR || type > SP_LUK || need < 0
    5951. 

  5951.         || need > sd->status.status_point
    5952. 

  5952.         || val >= battle_config.max_parameter)
    5953. 

  5953.     {
    5954. 

  5954.         clif_statusupack (sd, type, 0, val);
    5955. 

  5955.         return 1;
    5956. 

  5956.     }
    5957. 

  5957.     switch (type)
    5958. 

  5958.     {
    5959. 

  5959.         case SP_STR:
    5960. 

  5960.             val = ++sd->status.str;
    5961. 

  5961.             break;
    5962. 

  5962.         case SP_AGI:
    5963. 

  5963.             val = ++sd->status.agi;
    5964. 

  5964.             break;
    5965. 

  5965.         case SP_VIT:
    5966. 

  5966.             val = ++sd->status.vit;
    5967. 

  5967.             break;
    5968. 

  5968.         case SP_INT:
    5969. 

  5969.             val = ++sd->status.int_;
    5970. 

  5970.             break;
    5971. 

  5971.         case SP_DEX:
    5972. 

  5972.             val = ++sd->status.dex;
    5973. 

  5973.             break;
    5974. 

  5974.         case SP_LUK:
    5975. 

  5975.             val = ++sd->status.luk;
    5976. 

  5976.             break;
    5977. 

  5977.         default:
    5978. 

  5978.             break;
    5979. 

  5979.     }
    5980. 

  5980.     sd->status.status_point -= need;
    5981. 

  5981.     if (need != pc_need_status_point (sd, type))
    5982. 

  5982.     {
    5983. 

  5983.         clif_updatestatus (sd, type - SP_STR + SP_USTR);
    5984. 

  5984.     }
    5985. 

  5985.     clif_updatestatus (sd, SP_STATUSPOINT);
    5986. 

  5986.     clif_updatestatus (sd, type);
    5987. 

  5987.     pc_calcstatus (sd, 0);
    5988. 

  5988.     clif_statusupack (sd, type, 1, val);
    5989. 

  5989. 

  5990.     MAP_LOG_STATS (sd, "STATUP");
    5991. 

  5991. 

  5992.     return 0;
    5993. 

  5993. }
    5994. 

  5994. 

  5995. /*==========================================
    5996. 

  5996.  * 能力値成長 
    5997. 

  5997.  *------------------------------------------
    5998. 

  5998.  */
    5999. 

  5999. int pc_statusup2 (struct map_session_data *sd, int type, int val)
    6000. 

  6000. {
    6001. 

  6001.     nullpo_retr (0, sd);
    6002. 

  6002. 

  6003.     if (type < SP_STR || type > SP_LUK)
    6004. 

  6004.     {
    6005. 

  6005.         clif_statusupack (sd, type, 0, 0);
    6006. 

  6006.         return 1;
    6007. 

  6007.     }
    6008. 

  6008.     switch (type)
    6009. 

  6009.     {
    6010. 

  6010.         case SP_STR:
    6011. 

  6011.             if (sd->status.str + val >= battle_config.max_parameter)
    6012. 

  6012.                 val = battle_config.max_parameter;
    6013. 

  6013.             else if (sd->status.str + val < 1)
    6014. 

  6014.                 val = 1;
    6015. 

  6015.             else
    6016. 

  6016.                 val += sd->status.str;
    6017. 

  6017.             sd->status.str = val;
    6018. 

  6018.             break;
    6019. 

  6019.         case SP_AGI:
    6020. 

  6020.             if (sd->status.agi + val >= battle_config.max_parameter)
    6021. 

  6021.                 val = battle_config.max_parameter;
    6022. 

  6022.             else if (sd->status.agi + val < 1)
    6023. 

  6023.                 val = 1;
    6024. 

  6024.             else
    6025. 

  6025.                 val += sd->status.agi;
    6026. 

  6026.             sd->status.agi = val;
    6027. 

  6027.             break;
    6028. 

  6028.         case SP_VIT:
    6029. 

  6029.             if (sd->status.vit + val >= battle_config.max_parameter)
    6030. 

  6030.                 val = battle_config.max_parameter;
    6031. 

  6031.             else if (sd->status.vit + val < 1)
    6032. 

  6032.                 val = 1;
    6033. 

  6033.             else
    6034. 

  6034.                 val += sd->status.vit;
    6035. 

  6035.             sd->status.vit = val;
    6036. 

  6036.             break;
    6037. 

  6037.         case SP_INT:
    6038. 

  6038.             if (sd->status.int_ + val >= battle_config.max_parameter)
    6039. 

  6039.                 val = battle_config.max_parameter;
    6040. 

  6040.             else if (sd->status.int_ + val < 1)
    6041. 

  6041.                 val = 1;
    6042. 

  6042.             else
    6043. 

  6043.                 val += sd->status.int_;
    6044. 

  6044.             sd->status.int_ = val;
    6045. 

  6045.             break;
    6046. 

  6046.         case SP_DEX:
    6047. 

  6047.             if (sd->status.dex + val >= battle_config.max_parameter)
    6048. 

  6048.                 val = battle_config.max_parameter;
    6049. 

  6049.             else if (sd->status.dex + val < 1)
    6050. 

  6050.                 val = 1;
    6051. 

  6051.             else
    6052. 

  6052.                 val += sd->status.dex;
    6053. 

  6053.             sd->status.dex = val;
    6054. 

  6054.             break;
    6055. 

  6055.         case SP_LUK:
    6056. 

  6056.             if (sd->status.luk + val >= battle_config.max_parameter)
    6057. 

  6057.                 val = battle_config.max_parameter;
    6058. 

  6058.             else if (sd->status.luk + val < 1)
    6059. 

  6059.                 val = 1;
    6060. 

  6060.             else
    6061. 

  6061.                 val = sd->status.luk + val;
    6062. 

  6062.             sd->status.luk = val;
    6063. 

  6063.             break;
    6064. 

  6064.         default:
    6065. 

  6065.             break;
    6066. 

  6066.     }
    6067. 

  6067.     clif_updatestatus (sd, type - SP_STR + SP_USTR);
    6068. 

  6068.     clif_updatestatus (sd, type);
    6069. 

  6069.     pc_calcstatus (sd, 0);
    6070. 

  6070.     clif_statusupack (sd, type, 1, val);
    6071. 

  6071.     MAP_LOG_STATS (sd, "STATUP2");
    6072. 

  6072. 

  6073.     return 0;
    6074. 

  6074. }
    6075. 

  6075. 

  6076. /*==========================================
    6077. 

  6077.  * スキルポイント割り振り 
    6078. 

  6078.  *------------------------------------------
    6079. 

  6079.  */
    6080. 

  6080. int pc_skillup (struct map_session_data *sd, int skill_num)
    6081. 

  6081. {
    6082. 

  6082.     nullpo_retr (0, sd);
    6083. 

  6083. 

  6084.     if (skill_num < 0 || skill_num >= MAX_SKILL)
    6085. 

  6085.         return 0;
    6086. 

  6086. 

  6087.     if (sd->status.skill[skill_num].id != 0
    6088. 

  6088.         && sd->status.skill_point >= sd->status.skill[skill_num].lv
    6089. 

  6089.         && sd->status.skill[skill_num].lv < skill_db[skill_num].max_raise)
    6090. 

  6090.     {
    6091. 

  6091.         sd->status.skill_point -= sd->status.skill[skill_num].lv;
    6092. 

  6092.         sd->status.skill[skill_num].lv++;
    6093. 

  6093. 

  6094.         pc_calcstatus (sd, 0);
    6095. 

  6095.         clif_skillup (sd, skill_num);
    6096. 

  6096.         clif_updatestatus (sd, SP_SKILLPOINT);
    6097. 

  6097.         clif_skillinfoblock (sd);
    6098. 

  6098.         MAP_LOG_PC(sd, "SKILLUP %d %d %d",
    6099. 

  6099.                    skill_num, sd->status.skill[skill_num].lv, skill_power(sd, skill_num));
    6100. 

  6100.     }
    6101. 

  6101. 

  6102.     return 0;
    6103. 

  6103. }
    6104. 

  6104. 

  6105. /*==========================================
    6106. 

  6106.  * /allskill
    6107. 

  6107.  *------------------------------------------
    6108. 

  6108.  */
    6109. 

  6109. int pc_allskillup (struct map_session_data *sd)
    6110. 

  6110. {
    6111. 

  6111.     int  i, id;
    6112. 

  6112.     int  c = 0, s = 0;
    6113. 

  6113.     //転生や養子の場合の元の職業を算出する 
    6114. 

  6114.     struct pc_base_job s_class;
    6115. 

  6115. 

  6116.     nullpo_retr (0, sd);
    6117. 

  6117. 

  6118.     s_class = pc_calc_base_job (sd->status.class);
    6119. 

  6119.     c = s_class.job;
    6120. 

  6120.     s = (s_class.upper == 1) ? 1 : 0;   //転生以外は通常のスキル？ 
    6121. 

  6121. 

  6122.     for (i = 0; i < MAX_SKILL; i++)
    6123. 

  6123.         sd->status.skill[i].id = 0;
    6124. 

  6124. 

  6125.     if (battle_config.gm_allskill > 0
    6126. 

  6126.         && pc_isGM (sd) >= battle_config.gm_allskill)
    6127. 

  6127.     {
    6128. 

  6128.         // 全てのスキル 
    6129. 

  6129.         for (i = 1; i < 158; i++)
    6130. 

  6130.             sd->status.skill[i].lv = skill_get_max (i);
    6131. 

  6131.         for (i = 210; i < 291; i++)
    6132. 

  6132.             sd->status.skill[i].lv = skill_get_max (i);
    6133. 

  6133.         for (i = 304; i < MAX_SKILL; i++)
    6134. 

  6134.             sd->status.skill[i].lv = skill_get_max (i);
    6135. 

  6135.     }
    6136. 

  6136.     else
    6137. 

  6137.     {
    6138. 

  6138.         for (i = 0; (id = skill_tree[s][c][i].id) > 0; i++)
    6139. 

  6139.         {
    6140. 

  6140.             if (sd->status.skill[id].id == 0 && skill_get_inf2 (id) & 0x01)
    6141. 

  6141.                 sd->status.skill[id].lv = skill_get_max (id);
    6142. 

  6142.         }
    6143. 

  6143.     }
    6144. 

  6144.     pc_calcstatus (sd, 0);
    6145. 

  6145. 

  6146.     return 0;
    6147. 

  6147. }
    6148. 

  6148. 

  6149. /*==========================================
    6150. 

  6150.  * /resetlvl
    6151. 

  6151.  *------------------------------------------
    6152. 

  6152.  */
    6153. 

  6153. int pc_resetlvl (struct map_session_data *sd, int type)
    6154. 

  6154. {
    6155. 

  6155.     int  i;
    6156. 

  6156. 

  6157.     nullpo_retr (0, sd);
    6158. 

  6158. 

  6159.     for (i = 1; i < MAX_SKILL; i++)
    6160. 

  6160.     {
    6161. 

  6161.         sd->status.skill[i].lv = 0;
    6162. 

  6162.     }
    6163. 

  6163. 

  6164.     if (type == 1)
    6165. 

  6165.     {
    6166. 

  6166.         sd->status.skill_point = 0;
    6167. 

  6167.         sd->status.base_level = 1;
    6168. 

  6168.         sd->status.job_level = 1;
    6169. 

  6169.         sd->status.base_exp = 0;
    6170. 

  6170.         sd->status.job_exp = 0;
    6171. 

  6171.         if (sd->status.option != 0)
    6172. 

  6172.             sd->status.option = 0;
    6173. 

  6173. 

  6174.         sd->status.str = 1;
    6175. 

  6175.         sd->status.agi = 1;
    6176. 

  6176.         sd->status.vit = 1;
    6177. 

  6177.         sd->status.int_ = 1;
    6178. 

  6178.         sd->status.dex = 1;
    6179. 

  6179.         sd->status.luk = 1;
    6180. 

  6180.         if (sd->status.class == 4001)
    6181. 

  6181.             sd->status.status_point = 100;
    6182. 

  6182.     }
    6183. 

  6183. 

  6184.     if (type == 2)
    6185. 

  6185.     {
    6186. 

  6186.         sd->status.skill_point = 0;
    6187. 

  6187.         sd->status.base_level = 1;
    6188. 

  6188.         sd->status.job_level = 1;
    6189. 

  6189.         sd->status.base_exp = 0;
    6190. 

  6190.         sd->status.job_exp = 0;
    6191. 

  6191.     }
    6192. 

  6192.     if (type == 3)
    6193. 

  6193.     {
    6194. 

  6194.         sd->status.base_level = 1;
    6195. 

  6195.         sd->status.base_exp = 0;
    6196. 

  6196.     }
    6197. 

  6197.     if (type == 4)
    6198. 

  6198.     {
    6199. 

  6199.         sd->status.job_level = 1;
    6200. 

  6200.         sd->status.job_exp = 0;
    6201. 

  6201.     }
    6202. 

  6202. 

  6203.     clif_updatestatus (sd, SP_STATUSPOINT);
    6204. 

  6204.     clif_updatestatus (sd, SP_STR);
    6205. 

  6205.     clif_updatestatus (sd, SP_AGI);
    6206. 

  6206.     clif_updatestatus (sd, SP_VIT);
    6207. 

  6207.     clif_updatestatus (sd, SP_INT);
    6208. 

  6208.     clif_updatestatus (sd, SP_DEX);
    6209. 

  6209.     clif_updatestatus (sd, SP_LUK);
    6210. 

  6210.     clif_updatestatus (sd, SP_BASELEVEL);
    6211. 

  6211.     clif_updatestatus (sd, SP_JOBLEVEL);
    6212. 

  6212.     clif_updatestatus (sd, SP_STATUSPOINT);
    6213. 

  6213.     clif_updatestatus (sd, SP_NEXTBASEEXP);
    6214. 

  6214.     clif_updatestatus (sd, SP_NEXTJOBEXP);
    6215. 

  6215.     clif_updatestatus (sd, SP_SKILLPOINT);
    6216. 

  6216. 

  6217.     clif_updatestatus (sd, SP_USTR);    // Updates needed stat points - Valaris
    6218. 

  6218.     clif_updatestatus (sd, SP_UAGI);
    6219. 

  6219.     clif_updatestatus (sd, SP_UVIT);
    6220. 

  6220.     clif_updatestatus (sd, SP_UINT);
    6221. 

  6221.     clif_updatestatus (sd, SP_UDEX);
    6222. 

  6222.     clif_updatestatus (sd, SP_ULUK);    // End Addition
    6223. 

  6223. 

  6224.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    6225. 

  6225.     {                           // unequip items that can't be equipped by base 1 [Valaris]
    6226. 

  6226.         if (sd->equip_index[i] >= 0)
    6227. 

  6227.             if (!pc_isequip (sd, sd->equip_index[i]))
    6228. 

  6228.             {
    6229. 

  6229.                 pc_unequipitem (sd, sd->equip_index[i], 1);
    6230. 

  6230.                 sd->equip_index[i] = -1;
    6231. 

  6231.             }
    6232. 

  6232.     }
    6233. 

  6233. 

  6234.     clif_skillinfoblock (sd);
    6235. 

  6235.     pc_calcstatus (sd, 0);
    6236. 

  6236. 

  6237.     MAP_LOG_STATS (sd, "STATRESET");
    6238. 

  6238. 

  6239.     return 0;
    6240. 

  6240. }
    6241. 

  6241. 

  6242. /*==========================================
    6243. 

  6243.  * /resetstate
    6244. 

  6244.  *------------------------------------------
    6245. 

  6245.  */
    6246. 

  6246. int pc_resetstate (struct map_session_data *sd)
    6247. 

  6247. {
    6248. 

  6248. #define sumsp(a) ((a)*((a-2)/10+2) - 5*((a-2)/10)*((a-2)/10) - 6*((a-2)/10) -2)
    6249. 

  6249. //  int add=0; // Removed by Dexity
    6250. 

  6250. 

  6251.     nullpo_retr (0, sd);
    6252. 

  6252. 

  6253.     if (sd->status.base_level < 1)
    6254. 

  6254.         return 0;
    6255. 

  6255. 

  6256. //  New statpoint table used here - Dexity
    6257. 

  6257.     sd->status.status_point = atoi (statp[sd->status.base_level - 1]);
    6258. 

  6258. //  End addition
    6259. 

  6259. 

  6260. //  Removed by Dexity - old count
    6261. 

  6261. //  add += sumsp(sd->status.str);
    6262. 

  6262. //  add += sumsp(sd->status.agi);
    6263. 

  6263. //  add += sumsp(sd->status.vit);
    6264. 

  6264. //  add += sumsp(sd->status.int_);
    6265. 

  6265. //  add += sumsp(sd->status.dex);
    6266. 

  6266. //  add += sumsp(sd->status.luk);
    6267. 

  6267. //  sd->status.status_point+=add;
    6268. 

  6268. 

  6269.     clif_updatestatus (sd, SP_STATUSPOINT);
    6270. 

  6270. 

  6271.     sd->status.str = 1;
    6272. 

  6272.     sd->status.agi = 1;
    6273. 

  6273.     sd->status.vit = 1;
    6274. 

  6274.     sd->status.int_ = 1;
    6275. 

  6275.     sd->status.dex = 1;
    6276. 

  6276.     sd->status.luk = 1;
    6277. 

  6277. 

  6278.     clif_updatestatus (sd, SP_STR);
    6279. 

  6279.     clif_updatestatus (sd, SP_AGI);
    6280. 

  6280.     clif_updatestatus (sd, SP_VIT);
    6281. 

  6281.     clif_updatestatus (sd, SP_INT);
    6282. 

  6282.     clif_updatestatus (sd, SP_DEX);
    6283. 

  6283.     clif_updatestatus (sd, SP_LUK);
    6284. 

  6284. 

  6285.     clif_updatestatus (sd, SP_USTR);    // Updates needed stat points - Valaris
    6286. 

  6286.     clif_updatestatus (sd, SP_UAGI);
    6287. 

  6287.     clif_updatestatus (sd, SP_UVIT);
    6288. 

  6288.     clif_updatestatus (sd, SP_UINT);
    6289. 

  6289.     clif_updatestatus (sd, SP_UDEX);
    6290. 

  6290.     clif_updatestatus (sd, SP_ULUK);    // End Addition
    6291. 

  6291. 

  6292.     pc_calcstatus (sd, 0);
    6293. 

  6293. 

  6294.     return 0;
    6295. 

  6295. }
    6296. 

  6296. 

  6297. /*==========================================
    6298. 

  6298.  * /resetskill
    6299. 

  6299.  *------------------------------------------
    6300. 

  6300.  */
    6301. 

  6301. int pc_resetskill (struct map_session_data *sd)
    6302. 

  6302. {
    6303. 

  6303.     int  i;
    6304. 

  6304. 

  6305.     nullpo_retr (0, sd);
    6306. 

  6306. 

  6307.     sd->status.skill_point += pc_calc_skillpoint (sd);
    6308. 

  6308. 

  6309.     for (i = 1; i < MAX_SKILL; i++)
    6310. 

  6310.         if (pc_checkskill (sd, i) > 0)
    6311. 

  6311.         {
    6312. 

  6312.             sd->status.skill[i].lv = 0;
    6313. 

  6313.             sd->status.skill[i].flags = 0;
    6314. 

  6314.         }
    6315. 

  6315. 

  6316.     clif_updatestatus (sd, SP_SKILLPOINT);
    6317. 

  6317.     clif_skillinfoblock (sd);
    6318. 

  6318.     pc_calcstatus (sd, 0);
    6319. 

  6319. 

  6320.     return 0;
    6321. 

  6321. }
    6322. 

  6322. 

  6323. /*==========================================
    6324. 

  6324.  * pcにダメージを与える 
    6325. 

  6325.  *------------------------------------------
    6326. 

  6326.  */
    6327. 

  6327. int pc_damage (struct block_list *src, struct map_session_data *sd,
    6328. 

  6328.                int damage)
    6329. 

  6329. {
    6330. 

  6330.     int  i = 0, j = 0;
    6331. 

  6331.     struct pc_base_job s_class;
    6332. 

  6332. 

  6333.     nullpo_retr (0, sd);
    6334. 

  6334. 

  6335.     //転生や養子の場合の元の職業を算出する 
    6336. 

  6336.     s_class = pc_calc_base_job (sd->status.class);
    6337. 

  6337.     // 既に死んでいたら無効 
    6338. 

  6338.     if (pc_isdead (sd))
    6339. 

  6339.         return 0;
    6340. 

  6340.     // 座ってたら立ち上がる 
    6341. 

  6341.     if (pc_issit (sd))
    6342. 

  6342.     {
    6343. 

  6343.         pc_setstand (sd);
    6344. 

  6344.         skill_gangsterparadise (sd, 0);
    6345. 

  6345.     }
    6346. 

  6346. 

  6347.     if (src)
    6348. 

  6348.     {
    6349. 

  6349.         if (src->type == BL_PC)
    6350. 

  6350.         {
    6351. 

  6351.             MAP_LOG_PC (sd, "INJURED-BY PC%d FOR %d",
    6352. 

  6352.                         ((struct map_session_data *) src)->status.char_id,
    6353. 

  6353.                         damage);
    6354. 

  6354.         }
    6355. 

  6355.         else
    6356. 

  6356.         {
    6357. 

  6357.             MAP_LOG_PC (sd, "INJURED-BY MOB%d FOR %d", src->id, damage);
    6358. 

  6358.         }
    6359. 

  6359.     }
    6360. 

  6360.     else
    6361. 

  6361.         MAP_LOG_PC (sd, "INJURED-BY null FOR %d", damage);
    6362. 

  6362. 

  6363.     // 歩 いていたら足を止める 
    6364. 

  6364.     if (sd->sc_data[SC_ENDURE].timer == -1
    6365. 

  6365.         && !sd->special_state.infinite_endure)
    6366. 

  6366.         pc_stop_walking (sd, 3);
    6367. 

  6367.     // 演奏/ダンスの中断 
    6368. 

  6368.     if (damage > sd->status.max_hp >> 2)
    6369. 

  6369.         skill_stop_dancing (&sd->bl, 0);
    6370. 

  6370. 

  6371.     sd->status.hp -= damage;
    6372. 

  6372. 

  6373.     if (sd->sc_data[SC_TRICKDEAD].timer != -1)
    6374. 

  6374.         skill_status_change_end (&sd->bl, SC_TRICKDEAD, -1);
    6375. 

  6375.     if (sd->status.option & 2)
    6376. 

  6376.         skill_status_change_end (&sd->bl, SC_HIDING, -1);
    6377. 

  6377.     if (sd->status.option & 4)
    6378. 

  6378.         skill_status_change_end (&sd->bl, SC_CLOAKING, -1);
    6379. 

  6379.     if (sd->status.option & 16386)
    6380. 

  6380.         skill_status_change_end (&sd->bl, SC_CHASEWALK, -1);
    6381. 

  6381. 

  6382.     if (sd->status.hp > 0)
    6383. 

  6383.     {
    6384. 

  6384.           // まだ生きているならHP更新 
    6385. 

  6385.         clif_updatestatus (sd, SP_HP);
    6386. 

  6386. 

  6387.         if (sd->status.hp < sd->status.max_hp >> 2
    6388. 

  6388.             && pc_checkskill (sd, SM_AUTOBERSERK) > 0
    6389. 

  6389.             && (sd->sc_data[SC_PROVOKE].timer == -1
    6390. 

  6390.                 || sd->sc_data[SC_PROVOKE].val2 == 0))
    6391. 

  6391.                // オートバーサーク発動 
    6392. 

  6392.             skill_status_change_start (&sd->bl, SC_PROVOKE, 10, 1, 0, 0, 0,
    6393. 

  6393.                                        0);
    6394. 

  6394. 

  6395.         sd->canlog_tick = gettick ();
    6396. 

  6396. 

  6397.         if (sd->status.party_id > 0)
    6398. 

  6398.         {                       // on-the-fly party hp updates [Valaris]
    6399. 

  6399.             struct party *p = party_search (sd->status.party_id);
    6400. 

  6400.             if (p != NULL)
    6401. 

  6401.                 clif_party_hp (p, sd);
    6402. 

  6402.         }                       // end addition [Valaris]
    6403. 

  6403. 

  6404.         return 0;
    6405. 

  6405.     }
    6406. 

  6406. 

  6407.     MAP_LOG_PC (sd, "DEAD%s", "");
    6408. 

  6408. 

  6409.     // Character is dead!
    6410. 

  6410. 

  6411.     sd->status.hp = 0;
    6412. 

  6412.     // [Fate] Stop quickregen
    6413. 

  6413.     sd->quick_regeneration_hp.amount = 0;
    6414. 

  6414.     sd->quick_regeneration_sp.amount = 0;
    6415. 

  6415.     skill_update_heal_animation (sd);
    6416. 

  6416. 

  6417.     pc_setdead (sd);
    6418. 

  6418. 

  6419.     pc_stop_walking (sd, 0);
    6420. 

  6420.     skill_castcancel (&sd->bl, 0);  // 詠唱の中止 
    6421. 

  6421.     clif_clearchar_area (&sd->bl, 1);
    6422. 

  6422.     skill_unit_out_all (&sd->bl, gettick (), 1);
    6423. 

  6423.     if (sd->sc_data[SC_BLADESTOP].timer != -1)  //白刃は事前に解除 
    6424. 

  6424.         skill_status_change_end (&sd->bl, SC_BLADESTOP, -1);
    6425. 

  6425.     pc_setglobalreg (sd, "PC_DIE_COUNTER", ++sd->die_counter);  //死にカウンター書き込み 
    6426. 

  6426.     skill_status_change_clear (&sd->bl, 0);   // ステータス異常を解除する 
    6427. 

  6427.     clif_updatestatus (sd, SP_HP);
    6428. 

  6428.     pc_calcstatus (sd, 0);
    6429. 

  6429.     // [Fate] Reset magic
    6430. 

  6430.     sd->cast_tick = gettick ();
    6431. 

  6431.     magic_stop_completely (sd);
    6432. 

  6432. 

  6433.     for (i = 0; i < 5; i++)
    6434. 

  6434.         if (sd->dev.val1[i])
    6435. 

  6435.         {
    6436. 

  6436.             skill_status_change_end (&map_id2sd (sd->dev.val1[i])->bl,
    6437. 

  6437.                                      SC_DEVOTION, -1);
    6438. 

  6438.             sd->dev.val1[i] = sd->dev.val2[i] = 0;
    6439. 

  6439.         }
    6440. 

  6440. 

  6441.     if (battle_config.death_penalty_type > 0 && sd->status.base_level >= 20)
    6442. 

  6442.     {                           // changed penalty options, added death by player if pk_mode [Valaris]
    6443. 

  6443.         if (!map[sd->bl.m].flag.nopenalty && !map[sd->bl.m].flag.gvg)
    6444. 

  6444.         {
    6445. 

  6445.             if (battle_config.death_penalty_type == 1
    6446. 

  6446.                 && battle_config.death_penalty_base > 0)
    6447. 

  6447.                 sd->status.base_exp -=
    6448. 

  6448.                     (double) pc_nextbaseexp (sd) *
    6449. 

  6449.                     (double) battle_config.death_penalty_base / 10000;
    6450. 

  6450.             if (battle_config.pk_mode && src && src->type == BL_PC)
    6451. 

  6451.                 sd->status.base_exp -=
    6452. 

  6452.                     (double) pc_nextbaseexp (sd) *
    6453. 

  6453.                     (double) battle_config.death_penalty_base / 10000;
    6454. 

  6454.             else if (battle_config.death_penalty_type == 2
    6455. 

  6455.                      && battle_config.death_penalty_base > 0)
    6456. 

  6456.             {
    6457. 

  6457.                 if (pc_nextbaseexp (sd) > 0)
    6458. 

  6458.                     sd->status.base_exp -=
    6459. 

  6459.                         (double) sd->status.base_exp *
    6460. 

  6460.                         (double) battle_config.death_penalty_base / 10000;
    6461. 

  6461.                 if (battle_config.pk_mode && src && src->type == BL_PC)
    6462. 

  6462.                     sd->status.base_exp -=
    6463. 

  6463.                         (double) sd->status.base_exp *
    6464. 

  6464.                         (double) battle_config.death_penalty_base / 10000;
    6465. 

  6465.             }
    6466. 

  6466.             if (sd->status.base_exp < 0)
    6467. 

  6467.                 sd->status.base_exp = 0;
    6468. 

  6468.             clif_updatestatus (sd, SP_BASEEXP);
    6469. 

  6469. 

  6470.             if (battle_config.death_penalty_type == 1
    6471. 

  6471.                 && battle_config.death_penalty_job > 0)
    6472. 

  6472.                 sd->status.job_exp -=
    6473. 

  6473.                     (double) pc_nextjobexp (sd) *
    6474. 

  6474.                     (double) battle_config.death_penalty_job / 10000;
    6475. 

  6475.             if (battle_config.pk_mode && src && src->type == BL_PC)
    6476. 

  6476.                 sd->status.job_exp -=
    6477. 

  6477.                     (double) pc_nextjobexp (sd) *
    6478. 

  6478.                     (double) battle_config.death_penalty_job / 10000;
    6479. 

  6479.             else if (battle_config.death_penalty_type == 2
    6480. 

  6480.                      && battle_config.death_penalty_job > 0)
    6481. 

  6481.             {
    6482. 

  6482.                 if (pc_nextjobexp (sd) > 0)
    6483. 

  6483.                     sd->status.job_exp -=
    6484. 

  6484.                         (double) sd->status.job_exp *
    6485. 

  6485.                         (double) battle_config.death_penalty_job / 10000;
    6486. 

  6486.                 if (battle_config.pk_mode && src && src->type == BL_PC)
    6487. 

  6487.                     sd->status.job_exp -=
    6488. 

  6488.                         (double) sd->status.job_exp *
    6489. 

  6489.                         (double) battle_config.death_penalty_job / 10000;
    6490. 

  6490.             }
    6491. 

  6491.             if (sd->status.job_exp < 0)
    6492. 

  6492.                 sd->status.job_exp = 0;
    6493. 

  6493.             clif_updatestatus (sd, SP_JOBEXP);
    6494. 

  6494.         }
    6495. 

  6495.     }
    6496. 

  6496.      //ナイトメアモードアイテムドロップ 
    6497. 

  6497.     if (map[sd->bl.m].flag.pvp_nightmaredrop)
    6498. 

  6498.     {                           // Moved this outside so it works when PVP isnt enabled and during pk mode [Ancyker]
    6499. 

  6499.         for (j = 0; j < MAX_DROP_PER_MAP; j++)
    6500. 

  6500.         {
    6501. 

  6501.             int  id = map[sd->bl.m].drop_list[j].drop_id;
    6502. 

  6502.             int  type = map[sd->bl.m].drop_list[j].drop_type;
    6503. 

  6503.             int  per = map[sd->bl.m].drop_list[j].drop_per;
    6504. 

  6504.             if (id == 0)
    6505. 

  6505.                 continue;
    6506. 

  6506.             if (id == -1)
    6507. 

  6507.                {                   //ランダムドロップ 
    6508. 

  6508.                 int  eq_num = 0, eq_n[MAX_INVENTORY];
    6509. 

  6509.                 memset (eq_n, 0, sizeof (eq_n));
    6510. 

  6510.                 //先ず装備しているアイテム数をカウント 
    6511. 

  6511.                 for (i = 0; i < MAX_INVENTORY; i++)
    6512. 

  6512.                 {
    6513. 

  6513.                     if ((type == 1 && !sd->status.inventory[i].equip)
    6514. 

  6514.                         || (type == 2 && sd->status.inventory[i].equip)
    6515. 

  6515.                         || type == 3)
    6516. 

  6516.                     {
    6517. 

  6517.                         //InventoryIndexを格納 
    6518. 

  6518.                         int  k;
    6519. 

  6519.                         for (k = 0; k < MAX_INVENTORY; k++)
    6520. 

  6520.                         {
    6521. 

  6521.                             if (eq_n[k] <= 0)
    6522. 

  6522.                             {
    6523. 

  6523.                                 eq_n[k] = i;
    6524. 

  6524.                                 break;
    6525. 

  6525.                             }
    6526. 

  6526.                         }
    6527. 

  6527.                         eq_num++;
    6528. 

  6528.                     }
    6529. 

  6529.                 }
    6530. 

  6530.                 if (eq_num > 0)
    6531. 

  6531.                 {
    6532. 

  6532.                     int  n = eq_n[MRAND (eq_num)];  //該当アイテムの中からランダム 
    6533. 

  6533.                     if (MRAND (10000) < per)
    6534. 

  6534.                     {
    6535. 

  6535.                         if (sd->status.inventory[n].equip)
    6536. 

  6536.                             pc_unequipitem (sd, n, 0);
    6537. 

  6537.                         pc_dropitem (sd, n, 1);
    6538. 

  6538.                     }
    6539. 

  6539.                 }
    6540. 

  6540.             }
    6541. 

  6541.             else if (id > 0)
    6542. 

  6542.             {
    6543. 

  6543.                 for (i = 0; i < MAX_INVENTORY; i++)
    6544. 

  6544.                 {
    6545. 

  6545.                     if (sd->status.inventory[i].nameid == id    //ItemIDが一致していて 
    6546. 

  6546.                         && MRAND (10000) < per                  //ドロップ率判定もOKで 
    6547. 

  6547.                         && ((type == 1 && !sd->status.inventory[i].equip)   //タイプ判定もOKならドロップ 
    6548. 

  6548.                             || (type == 2 && sd->status.inventory[i].equip)
    6549. 

  6549.                             || type == 3))
    6550. 

  6550.                     {
    6551. 

  6551.                         if (sd->status.inventory[i].equip)
    6552. 

  6552.                             pc_unequipitem (sd, i, 0);
    6553. 

  6553.                         pc_dropitem (sd, i, 1);
    6554. 

  6554.                         break;
    6555. 

  6555.                     }
    6556. 

  6556.                 }
    6557. 

  6557.             }
    6558. 

  6558.         }
    6559. 

  6559.     }
    6560. 

  6560.     // pvp
    6561. 

  6561.     if (map[sd->bl.m].flag.pvp && !battle_config.pk_mode)
    6562. 

  6562.     {                           // disable certain pvp functions on pk_mode [Valaris]
    6563. 

  6563.           //ランキング計算 
    6564. 

  6564.         if (!map[sd->bl.m].flag.pvp_nocalcrank)
    6565. 

  6565.         {
    6566. 

  6566.             sd->pvp_point -= 5;
    6567. 

  6567.             if (src && src->type == BL_PC)
    6568. 

  6568.                 ((struct map_session_data *) src)->pvp_point++;
    6569. 

  6569.             //} //fixed wrong '{' placement by Lupus
    6570. 

  6570.             pc_setdead (sd);
    6571. 

  6571.         }
    6572. 

  6572.         // 強制送還 
    6573. 

  6573.         if (sd->pvp_point < 0)
    6574. 

  6574.         {
    6575. 

  6575.             sd->pvp_point = 0;
    6576. 

  6576.             pc_setstand (sd);
    6577. 

  6577.             pc_setrestartvalue (sd, 3);
    6578. 

  6578.             pc_setpos (sd, sd->status.save_point.map, sd->status.save_point.x,
    6579. 

  6579.                        sd->status.save_point.y, 0);
    6580. 

  6580.         }
    6581. 

  6581.     }
    6582. 

  6582.     //GvG
    6583. 

  6583.     if (map[sd->bl.m].flag.gvg)
    6584. 

  6584.     {
    6585. 

  6585.         pc_setstand (sd);
    6586. 

  6586.         pc_setrestartvalue (sd, 3);
    6587. 

  6587.         pc_setpos (sd, sd->status.save_point.map, sd->status.save_point.x,
    6588. 

  6588.                    sd->status.save_point.y, 0);
    6589. 

  6589.     }
    6590. 

  6590. 

  6591.     if (src && src->type == BL_PC)
    6592. 

  6592.     {
    6593. 

  6593.         // [Fate] PK death, trigger scripts
    6594. 

  6594.         argrec_t arg[3];
    6595. 

  6595.         arg[0].name = "@killerrid";
    6596. 

  6596.         arg[0].v.i = src->id;
    6597. 

  6597.         arg[1].name = "@victimrid";
    6598. 

  6598.         arg[1].v.i = sd->bl.id;
    6599. 

  6599.         arg[2].name = "@victimlvl";
    6600. 

  6600.         arg[2].v.i = sd->status.base_level;
    6601. 

  6601.         npc_event_doall_l ("OnPCKilledEvent", sd->bl.id, 3, arg);
    6602. 

  6602.         npc_event_doall_l ("OnPCKillEvent", src->id, 3, arg);
    6603. 

  6603.     }
    6604. 

  6604.     npc_event_doall_l ("OnPCDieEvent", sd->bl.id, 0, NULL);
    6605. 

  6605. 

  6606.     return 0;
    6607. 

  6607. }
    6608. 

  6608. 

  6609. //
    6610. 

  6610. // script関 連 
    6611. 

  6611. //
    6612. 

  6612. /*==========================================
    6613. 

  6613.  * script用PCステータス読み出し 
    6614. 

  6614.  *------------------------------------------
    6615. 

  6615.  */
    6616. 

  6616. int pc_readparam (struct map_session_data *sd, int type)
    6617. 

  6617. {
    6618. 

  6618.     int  val = 0;
    6619. 

  6619.     struct pc_base_job s_class;
    6620. 

  6620. 

  6621.     nullpo_retr (0, sd);
    6622. 

  6622. 

  6623.     s_class = pc_calc_base_job (sd->status.class);
    6624. 

  6624. 

  6625.     switch (type)
    6626. 

  6626.     {
    6627. 

  6627.         case SP_SKILLPOINT:
    6628. 

  6628.             val = sd->status.skill_point;
    6629. 

  6629.             break;
    6630. 

  6630.         case SP_STATUSPOINT:
    6631. 

  6631.             val = sd->status.status_point;
    6632. 

  6632.             break;
    6633. 

  6633.         case SP_ZENY:
    6634. 

  6634.             val = sd->status.zeny;
    6635. 

  6635.             break;
    6636. 

  6636.         case SP_BASELEVEL:
    6637. 

  6637.             val = sd->status.base_level;
    6638. 

  6638.             break;
    6639. 

  6639.         case SP_JOBLEVEL:
    6640. 

  6640.             val = sd->status.job_level;
    6641. 

  6641.             break;
    6642. 

  6642.         case SP_CLASS:
    6643. 

  6643.             if (val >= 24 && val < 45)
    6644. 

  6644.                 val += 3978;
    6645. 

  6645.             else
    6646. 

  6646.                 val = sd->status.class;
    6647. 

  6647.             break;
    6648. 

  6648.         case SP_UPPER:
    6649. 

  6649.             val = s_class.upper;
    6650. 

  6650.             break;
    6651. 

  6651.         case SP_SEX:
    6652. 

  6652.             val = sd->sex;
    6653. 

  6653.             break;
    6654. 

  6654.         case SP_WEIGHT:
    6655. 

  6655.             val = sd->weight;
    6656. 

  6656.             break;
    6657. 

  6657.         case SP_MAXWEIGHT:
    6658. 

  6658.             val = sd->max_weight;
    6659. 

  6659.             break;
    6660. 

  6660.         case SP_BASEEXP:
    6661. 

  6661.             val = sd->status.base_exp;
    6662. 

  6662.             break;
    6663. 

  6663.         case SP_JOBEXP:
    6664. 

  6664.             val = sd->status.job_exp;
    6665. 

  6665.             break;
    6666. 

  6666.         case SP_NEXTBASEEXP:
    6667. 

  6667.             val = pc_nextbaseexp (sd);
    6668. 

  6668.             break;
    6669. 

  6669.         case SP_NEXTJOBEXP:
    6670. 

  6670.             val = pc_nextjobexp (sd);
    6671. 

  6671.             break;
    6672. 

  6672.         case SP_HP:
    6673. 

  6673.             val = sd->status.hp;
    6674. 

  6674.             break;
    6675. 

  6675.         case SP_MAXHP:
    6676. 

  6676.             val = sd->status.max_hp;
    6677. 

  6677.             break;
    6678. 

  6678.         case SP_SP:
    6679. 

  6679.             val = sd->status.sp;
    6680. 

  6680.             break;
    6681. 

  6681.         case SP_MAXSP:
    6682. 

  6682.             val = sd->status.max_sp;
    6683. 

  6683.             break;
    6684. 

  6684.         case SP_STR:
    6685. 

  6685.             val = sd->status.str;
    6686. 

  6686.             break;
    6687. 

  6687.         case SP_AGI:
    6688. 

  6688.             val = sd->status.agi;
    6689. 

  6689.             break;
    6690. 

  6690.         case SP_VIT:
    6691. 

  6691.             val = sd->status.vit;
    6692. 

  6692.             break;
    6693. 

  6693.         case SP_INT:
    6694. 

  6694.             val = sd->status.int_;
    6695. 

  6695.             break;
    6696. 

  6696.         case SP_DEX:
    6697. 

  6697.             val = sd->status.dex;
    6698. 

  6698.             break;
    6699. 

  6699.         case SP_LUK:
    6700. 

  6700.             val = sd->status.luk;
    6701. 

  6701.             break;
    6702. 

  6702.         case SP_FAME:
    6703. 

  6703.             val = sd->fame;
    6704. 

  6704.             break;
    6705. 

  6705.         default:
    6706. 

  6706.             break;
    6707. 

  6707.     }
    6708. 

  6708. 

  6709.     return val;
    6710. 

  6710. }
    6711. 

  6711. 

  6712. /*==========================================
    6713. 

  6713.  * script用PCステータス設定 
    6714. 

  6714.  *------------------------------------------
    6715. 

  6715.  */
    6716. 

  6716. int pc_setparam (struct map_session_data *sd, int type, int val)
    6717. 

  6717. {
    6718. 

  6718.     int  i = 0, up_level = 50;
    6719. 

  6719.     struct pc_base_job s_class;
    6720. 

  6720. 

  6721.     nullpo_retr (0, sd);
    6722. 

  6722. 

  6723.     s_class = pc_calc_base_job (sd->status.class);
    6724. 

  6724. 

  6725.     switch (type)
    6726. 

  6726.     {
    6727. 

  6727.         case SP_BASELEVEL:
    6728. 

  6728.             if (val > sd->status.base_level)
    6729. 

  6729.             {
    6730. 

  6730.                 for (i = 1; i <= (val - sd->status.base_level); i++)
    6731. 

  6731.                     sd->status.status_point +=
    6732. 

  6732.                         (sd->status.base_level + i + 14) / 4;
    6733. 

  6733.             }
    6734. 

  6734.             sd->status.base_level = val;
    6735. 

  6735.             sd->status.base_exp = 0;
    6736. 

  6736.             clif_updatestatus (sd, SP_BASELEVEL);
    6737. 

  6737.             clif_updatestatus (sd, SP_NEXTBASEEXP);
    6738. 

  6738.             clif_updatestatus (sd, SP_STATUSPOINT);
    6739. 

  6739.             clif_updatestatus (sd, SP_BASEEXP);
    6740. 

  6740.             pc_calcstatus (sd, 0);
    6741. 

  6741.             pc_heal (sd, sd->status.max_hp, sd->status.max_sp);
    6742. 

  6742.             break;
    6743. 

  6743.         case SP_JOBLEVEL:
    6744. 

  6744.             if (sd->status.class <= MAX_PLAYER_CLASS)
    6745. 

  6745.                 up_level -= 40;
    6746. 

  6746.             if ((sd->status.class == 23)
    6747. 

  6747.                 || (sd->status.class >= 4001 && sd->status.class <= 4022))
    6748. 

  6748.                 up_level += 20;
    6749. 

  6749.             if (val >= sd->status.job_level)
    6750. 

  6750.             {
    6751. 

  6751.                 if (val > up_level)
    6752. 

  6752.                     val = up_level;
    6753. 

  6753.                 sd->status.skill_point += (val - sd->status.job_level);
    6754. 

  6754.                 sd->status.job_level = val;
    6755. 

  6755.                 sd->status.job_exp = 0;
    6756. 

  6756.                 clif_updatestatus (sd, SP_JOBLEVEL);
    6757. 

  6757.                 clif_updatestatus (sd, SP_NEXTJOBEXP);
    6758. 

  6758.                 clif_updatestatus (sd, SP_JOBEXP);
    6759. 

  6759.                 clif_updatestatus (sd, SP_SKILLPOINT);
    6760. 

  6760.                 pc_calcstatus (sd, 0);
    6761. 

  6761.                 clif_misceffect (&sd->bl, 1);
    6762. 

  6762.             }
    6763. 

  6763.             else
    6764. 

  6764.             {
    6765. 

  6765.                 sd->status.job_level = val;
    6766. 

  6766.                 sd->status.job_exp = 0;
    6767. 

  6767.                 clif_updatestatus (sd, SP_JOBLEVEL);
    6768. 

  6768.                 clif_updatestatus (sd, SP_NEXTJOBEXP);
    6769. 

  6769.                 clif_updatestatus (sd, SP_JOBEXP);
    6770. 

  6770.                 pc_calcstatus (sd, 0);
    6771. 

  6771.             }
    6772. 

  6772.             clif_updatestatus (sd, type);
    6773. 

  6773.             break;
    6774. 

  6774.         case SP_SKILLPOINT:
    6775. 

  6775.             sd->status.skill_point = val;
    6776. 

  6776.             break;
    6777. 

  6777.         case SP_STATUSPOINT:
    6778. 

  6778.             sd->status.status_point = val;
    6779. 

  6779.             break;
    6780. 

  6780.         case SP_ZENY:
    6781. 

  6781.             sd->status.zeny = val;
    6782. 

  6782.             break;
    6783. 

  6783.         case SP_BASEEXP:
    6784. 

  6784.             if (pc_nextbaseexp (sd) > 0)
    6785. 

  6785.             {
    6786. 

  6786.                 sd->status.base_exp = val;
    6787. 

  6787.                 if (sd->status.base_exp < 0)
    6788. 

  6788.                     sd->status.base_exp = 0;
    6789. 

  6789.                 pc_checkbaselevelup (sd);
    6790. 

  6790.             }
    6791. 

  6791.             break;
    6792. 

  6792.         case SP_JOBEXP:
    6793. 

  6793.             if (pc_nextjobexp (sd) > 0)
    6794. 

  6794.             {
    6795. 

  6795.                 sd->status.job_exp = val;
    6796. 

  6796.                 if (sd->status.job_exp < 0)
    6797. 

  6797.                     sd->status.job_exp = 0;
    6798. 

  6798.                 pc_checkjoblevelup (sd);
    6799. 

  6799.             }
    6800. 

  6800.             break;
    6801. 

  6801.         case SP_SEX:
    6802. 

  6802.             sd->sex = val;
    6803. 

  6803.             break;
    6804. 

  6804.         case SP_WEIGHT:
    6805. 

  6805.             sd->weight = val;
    6806. 

  6806.             break;
    6807. 

  6807.         case SP_MAXWEIGHT:
    6808. 

  6808.             sd->max_weight = val;
    6809. 

  6809.             break;
    6810. 

  6810.         case SP_HP:
    6811. 

  6811.             sd->status.hp = val;
    6812. 

  6812.             break;
    6813. 

  6813.         case SP_MAXHP:
    6814. 

  6814.             sd->status.max_hp = val;
    6815. 

  6815.             break;
    6816. 

  6816.         case SP_SP:
    6817. 

  6817.             sd->status.sp = val;
    6818. 

  6818.             break;
    6819. 

  6819.         case SP_MAXSP:
    6820. 

  6820.             sd->status.max_sp = val;
    6821. 

  6821.             break;
    6822. 

  6822.         case SP_STR:
    6823. 

  6823.             sd->status.str = val;
    6824. 

  6824.             break;
    6825. 

  6825.         case SP_AGI:
    6826. 

  6826.             sd->status.agi = val;
    6827. 

  6827.             break;
    6828. 

  6828.         case SP_VIT:
    6829. 

  6829.             sd->status.vit = val;
    6830. 

  6830.             break;
    6831. 

  6831.         case SP_INT:
    6832. 

  6832.             sd->status.int_ = val;
    6833. 

  6833.             break;
    6834. 

  6834.         case SP_DEX:
    6835. 

  6835.             sd->status.dex = val;
    6836. 

  6836.             break;
    6837. 

  6837.         case SP_LUK:
    6838. 

  6838.             sd->status.luk = val;
    6839. 

  6839.             break;
    6840. 

  6840.         case SP_FAME:
    6841. 

  6841.             sd->fame = val;
    6842. 

  6842.             break;
    6843. 

  6843.         default:
    6844. 

  6844.             break;
    6845. 

  6845.     }
    6846. 

  6846.     clif_updatestatus (sd, type);
    6847. 

  6847. 

  6848.     return 0;
    6849. 

  6849. }
    6850. 

  6850. 

  6851. /*==========================================
    6852. 

  6852.  * HP/SP回復 
    6853. 

  6853.  *------------------------------------------
    6854. 

  6854.  */
    6855. 

  6855. int pc_heal (struct map_session_data *sd, int hp, int sp)
    6856. 

  6856. {
    6857. 

  6857. //  if(battle_config.battle_log)
    6858. 

  6858. //      printf("heal %d %d\n",hp,sp);
    6859. 

  6859. 

  6860.     nullpo_retr (0, sd);
    6861. 

  6861. 

  6862.     if (pc_checkoverhp (sd))
    6863. 

  6863.     {
    6864. 

  6864.         if (hp > 0)
    6865. 

  6865.             hp = 0;
    6866. 

  6866.     }
    6867. 

  6867.     if (pc_checkoversp (sd))
    6868. 

  6868.     {
    6869. 

  6869.         if (sp > 0)
    6870. 

  6870.             sp = 0;
    6871. 

  6871.     }
    6872. 

  6872. 

  6873.     if (sd->sc_data && sd->sc_data[SC_BERSERK].timer != -1) //バーサーク中は回復させないらしい 
    6874. 

  6874.         return 0;
    6875. 

  6875. 

  6876.     if (hp + sd->status.hp > sd->status.max_hp)
    6877. 

  6877.         hp = sd->status.max_hp - sd->status.hp;
    6878. 

  6878.     if (sp + sd->status.sp > sd->status.max_sp)
    6879. 

  6879.         sp = sd->status.max_sp - sd->status.sp;
    6880. 

  6880.     sd->status.hp += hp;
    6881. 

  6881.     if (sd->status.hp <= 0)
    6882. 

  6882.     {
    6883. 

  6883.         sd->status.hp = 0;
    6884. 

  6884.         pc_damage (NULL, sd, 1);
    6885. 

  6885.         hp = 0;
    6886. 

  6886.     }
    6887. 

  6887.     sd->status.sp += sp;
    6888. 

  6888.     if (sd->status.sp <= 0)
    6889. 

  6889.         sd->status.sp = 0;
    6890. 

  6890.     if (hp)
    6891. 

  6891.         clif_updatestatus (sd, SP_HP);
    6892. 

  6892.     if (sp)
    6893. 

  6893.         clif_updatestatus (sd, SP_SP);
    6894. 

  6894. 

  6895.     if (sd->status.party_id > 0)
    6896. 

  6896.     {                           // on-the-fly party hp updates [Valaris]
    6897. 

  6897.         struct party *p = party_search (sd->status.party_id);
    6898. 

  6898.         if (p != NULL)
    6899. 

  6899.             clif_party_hp (p, sd);
    6900. 

  6900.     }                           // end addition [Valaris]
    6901. 

  6901. 

  6902.     return hp + sp;
    6903. 

  6903. }
    6904. 

  6904. 

  6905. /*==========================================
    6906. 

  6906.  * HP/SP回復 
    6907. 

  6907.  *------------------------------------------
    6908. 

  6908.  */
    6909. 

  6909. static int pc_itemheal_effect (struct map_session_data *sd, int hp, int sp);
    6910. 

  6910. 

  6911. static int                      // Compute how quickly we regenerate (less is faster) for that amount
    6912. 

  6912. pc_heal_quick_speed (int amount)
    6913. 

  6913. {
    6914. 

  6914.     if (amount >= 100)
    6915. 

  6915.     {
    6916. 

  6916.         if (amount >= 500)
    6917. 

  6917.             return 0;
    6918. 

  6918.         if (amount >= 250)
    6919. 

  6919.             return 1;
    6920. 

  6920.         return 2;
    6921. 

  6921.     }
    6922. 

  6922.     else
    6923. 

  6923.     {                           // < 100
    6924. 

  6924.         if (amount >= 50)
    6925. 

  6925.             return 3;
    6926. 

  6926.         if (amount >= 20)
    6927. 

  6927.             return 4;
    6928. 

  6928.         return 5;
    6929. 

  6929.     }
    6930. 

  6930. }
    6931. 

  6931. 

  6932. static void
    6933. 

  6933. pc_heal_quick_accumulate (int new_amount,
    6934. 

  6934.                           struct quick_regeneration *quick_regen, int max)
    6935. 

  6935. {
    6936. 

  6936.     if (!quick_regen)
    6937. 

  6937.         return;
    6938. 

  6938. 

  6939.     int  current_amount = quick_regen->amount;
    6940. 

  6940.     int  current_speed = quick_regen->speed;
    6941. 

  6941. 

  6942.     if (current_amount + new_amount == 0)
    6943. 

  6943.         return;
    6944. 

  6944. 

  6945.     int  new_speed = pc_heal_quick_speed (new_amount);
    6946. 

  6946. 

  6947.     int  average_speed = 1;
    6948. 

  6948.     if (current_amount != new_amount)
    6949. 

  6949.         average_speed = ((new_speed * new_amount) + (current_speed * current_amount)) / (current_amount + new_amount); // new_amount > 0, current_amount >= 0
    6950. 

  6950. 

  6951.     quick_regen->speed = average_speed;
    6952. 

  6952.     quick_regen->amount = MIN (current_amount + new_amount, max);
    6953. 

  6953. 

  6954.     quick_regen->tickdelay = MIN (quick_regen->speed, quick_regen->tickdelay);
    6955. 

  6955. }
    6956. 

  6956. 

  6957. int pc_itemheal (struct map_session_data *sd, int hp, int sp)
    6958. 

  6958. {
    6959. 

  6959.     nullpo_retr (0, sd);
    6960. 

  6960. 

  6961.     /* defer healing */
    6962. 

  6962.     if (hp > 0)
    6963. 

  6963.     {
    6964. 

  6964.         pc_heal_quick_accumulate (hp,
    6965. 

  6965.                                   &sd->quick_regeneration_hp,
    6966. 

  6966.                                   sd->status.max_hp - sd->status.hp);
    6967. 

  6967.         hp = 0;
    6968. 

  6968.     }
    6969. 

  6969.     if (sp > 0)
    6970. 

  6970.     {
    6971. 

  6971.         pc_heal_quick_accumulate (sp,
    6972. 

  6972.                                   &sd->quick_regeneration_sp,
    6973. 

  6973.                                   sd->status.max_sp - sd->status.sp);
    6974. 

  6974. 

  6975.         sp = 0;
    6976. 

  6976.     }
    6977. 

  6977. 

  6978.     /* Hurt right away, if necessary */
    6979. 

  6979.     if (hp < 0 || sp < 0)
    6980. 

  6980.         pc_itemheal_effect (sd, hp, sp);
    6981. 

  6981. 

  6982.     return 0;
    6983. 

  6983. }
    6984. 

  6984. 

  6985. /* pc_itemheal_effect is invoked once every 0.5s whenever the pc
    6986. 

  6986.  * has health recovery queued up (cf. pc_natural_heal_sub).
    6987. 

  6987.  */
    6988. 

  6988. static int pc_itemheal_effect (struct map_session_data *sd, int hp, int sp)
    6989. 

  6989. {
    6990. 

  6990.     int  bonus;
    6991. 

  6991. //  if(battle_config.battle_log)
    6992. 

  6992. //      printf("heal %d %d\n",hp,sp);
    6993. 

  6993. 

  6994.     nullpo_retr (0, sd);
    6995. 

  6995. 

  6996.     if (sd->sc_data && sd->sc_data[SC_GOSPEL].timer != -1)  //バーサーク中は回復させないらしい 
    6997. 

  6997.         return 0;
    6998. 

  6998. 

  6999.     if (sd->state.potionpitcher_flag)
    7000. 

  7000.     {
    7001. 

  7001.         sd->potion_hp = hp;
    7002. 

  7002.         sd->potion_sp = sp;
    7003. 

  7003.         return 0;
    7004. 

  7004.     }
    7005. 

  7005. 

  7006.     if (pc_checkoverhp (sd))
    7007. 

  7007.     {
    7008. 

  7008.         if (hp > 0)
    7009. 

  7009.             hp = 0;
    7010. 

  7010.     }
    7011. 

  7011.     if (pc_checkoversp (sd))
    7012. 

  7012.     {
    7013. 

  7013.         if (sp > 0)
    7014. 

  7014.             sp = 0;
    7015. 

  7015.     }
    7016. 

  7016.     if (hp > 0)
    7017. 

  7017.     {
    7018. 

  7018.         bonus =
    7019. 

  7019.             (sd->paramc[2] << 1) + 100 + pc_checkskill (sd, SM_RECOVERY) * 10;
    7020. 

  7020.         if (bonus != 100)
    7021. 

  7021.             hp = hp * bonus / 100;
    7022. 

  7022.         bonus = 100 + pc_checkskill (sd, AM_LEARNINGPOTION) * 5;
    7023. 

  7023.         if (bonus != 100)
    7024. 

  7024.             hp = hp * bonus / 100;
    7025. 

  7025.     }
    7026. 

  7026.     if (sp > 0)
    7027. 

  7027.     {
    7028. 

  7028.         bonus =
    7029. 

  7029.             (sd->paramc[3] << 1) + 100 + pc_checkskill (sd,
    7030. 

  7030.                                                         MG_SRECOVERY) * 10;
    7031. 

  7031.         if (bonus != 100)
    7032. 

  7032.             sp = sp * bonus / 100;
    7033. 

  7033.         bonus = 100 + pc_checkskill (sd, AM_LEARNINGPOTION) * 5;
    7034. 

  7034.         if (bonus != 100)
    7035. 

  7035.             sp = sp * bonus / 100;
    7036. 

  7036.     }
    7037. 

  7037.     if (hp + sd->status.hp > sd->status.max_hp)
    7038. 

  7038.         hp = sd->status.max_hp - sd->status.hp;
    7039. 

  7039.     if (sp + sd->status.sp > sd->status.max_sp)
    7040. 

  7040.         sp = sd->status.max_sp - sd->status.sp;
    7041. 

  7041.     sd->status.hp += hp;
    7042. 

  7042.     if (sd->status.hp <= 0)
    7043. 

  7043.     {
    7044. 

  7044.         sd->status.hp = 0;
    7045. 

  7045.         pc_damage (NULL, sd, 1);
    7046. 

  7046.         hp = 0;
    7047. 

  7047.     }
    7048. 

  7048.     sd->status.sp += sp;
    7049. 

  7049.     if (sd->status.sp <= 0)
    7050. 

  7050.         sd->status.sp = 0;
    7051. 

  7051.     if (hp)
    7052. 

  7052.         clif_updatestatus (sd, SP_HP);
    7053. 

  7053.     if (sp)
    7054. 

  7054.         clif_updatestatus (sd, SP_SP);
    7055. 

  7055. 

  7056.     return 0;
    7057. 

  7057. }
    7058. 

  7058. 

  7059. /*==========================================
    7060. 

  7060.  * HP/SP回復 
    7061. 

  7061.  *------------------------------------------
    7062. 

  7062.  */
    7063. 

  7063. int pc_percentheal (struct map_session_data *sd, int hp, int sp)
    7064. 

  7064. {
    7065. 

  7065.     nullpo_retr (0, sd);
    7066. 

  7066. 

  7067.     if (sd->state.potionpitcher_flag)
    7068. 

  7068.     {
    7069. 

  7069.         sd->potion_per_hp = hp;
    7070. 

  7070.         sd->potion_per_sp = sp;
    7071. 

  7071.         return 0;
    7072. 

  7072.     }
    7073. 

  7073. 

  7074.     if (pc_checkoverhp (sd))
    7075. 

  7075.     {
    7076. 

  7076.         if (hp > 0)
    7077. 

  7077.             hp = 0;
    7078. 

  7078.     }
    7079. 

  7079.     if (pc_checkoversp (sd))
    7080. 

  7080.     {
    7081. 

  7081.         if (sp > 0)
    7082. 

  7082.             sp = 0;
    7083. 

  7083.     }
    7084. 

  7084.     if (hp)
    7085. 

  7085.     {
    7086. 

  7086.         if (hp >= 100)
    7087. 

  7087.         {
    7088. 

  7088.             sd->status.hp = sd->status.max_hp;
    7089. 

  7089.         }
    7090. 

  7090.         else if (hp <= -100)
    7091. 

  7091.         {
    7092. 

  7092.             sd->status.hp = 0;
    7093. 

  7093.             pc_damage (NULL, sd, 1);
    7094. 

  7094.         }
    7095. 

  7095.         else
    7096. 

  7096.         {
    7097. 

  7097.             sd->status.hp += sd->status.max_hp * hp / 100;
    7098. 

  7098.             if (sd->status.hp > sd->status.max_hp)
    7099. 

  7099.                 sd->status.hp = sd->status.max_hp;
    7100. 

  7100.             if (sd->status.hp <= 0)
    7101. 

  7101.             {
    7102. 

  7102.                 sd->status.hp = 0;
    7103. 

  7103.                 pc_damage (NULL, sd, 1);
    7104. 

  7104.                 hp = 0;
    7105. 

  7105.             }
    7106. 

  7106.         }
    7107. 

  7107.     }
    7108. 

  7108.     if (sp)
    7109. 

  7109.     {
    7110. 

  7110.         if (sp >= 100)
    7111. 

  7111.         {
    7112. 

  7112.             sd->status.sp = sd->status.max_sp;
    7113. 

  7113.         }
    7114. 

  7114.         else if (sp <= -100)
    7115. 

  7115.         {
    7116. 

  7116.             sd->status.sp = 0;
    7117. 

  7117.         }
    7118. 

  7118.         else
    7119. 

  7119.         {
    7120. 

  7120.             sd->status.sp += sd->status.max_sp * sp / 100;
    7121. 

  7121.             if (sd->status.sp > sd->status.max_sp)
    7122. 

  7122.                 sd->status.sp = sd->status.max_sp;
    7123. 

  7123.             if (sd->status.sp < 0)
    7124. 

  7124.                 sd->status.sp = 0;
    7125. 

  7125.         }
    7126. 

  7126.     }
    7127. 

  7127.     if (hp)
    7128. 

  7128.         clif_updatestatus (sd, SP_HP);
    7129. 

  7129.     if (sp)
    7130. 

  7130.         clif_updatestatus (sd, SP_SP);
    7131. 

  7131. 

  7132.     return 0;
    7133. 

  7133. }
    7134. 

  7134. 

  7135. /*==========================================
    7136. 

  7136.  * 職変更 
    7137. 

  7137.  * 引数 job 職業 0〜23 
    7138. 

  7138.  *		upper 通常 0, 転生 1, 養子 2, そのまま -1
    7139. 

  7139.  *------------------------------------------
    7140. 

  7140.  */
    7141. 

  7141. int pc_jobchange (struct map_session_data *sd, int job, int upper)
    7142. 

  7142. {
    7143. 

  7143.     nullpo_retr (0, sd);
    7144. 

  7144. 

  7145.     int  i;
    7146. 

  7146.     int  b_class = 0;
    7147. 

  7147.     //転生や養子の場合の元の職業を算出する 
    7148. 

  7148.     struct pc_base_job s_class = pc_calc_base_job (sd->status.class);
    7149. 

  7149. 

  7150.     if ((job > 23) && (job < 68))
    7151. 

  7151.         job += 3977;
    7152. 

  7152. 

  7153.     if ((job > 69) && (job < 4000))
    7154. 

  7154.         return 1;
    7155. 

  7155. 

  7156.     if (upper < 0)              //現在転生かどうかを判断する 
    7157. 

  7157.         upper = s_class.upper;
    7158. 

  7158. 

  7159.     if (upper == 0)
    7160. 

  7160.     {                           //通常職ならjobそのまんま 
    7161. 

  7161.         b_class = job;
    7162. 

  7162.     }
    7163. 

  7163.     else if (upper == 1)
    7164. 

  7164.     {
    7165. 

  7165.         if (job == 23)
    7166. 

  7166.         {                       //転生にスパノビは存在しないのでお断り 
    7167. 

  7167.             return 1;
    7168. 

  7168.         }
    7169. 

  7169.         else
    7170. 

  7170.         {
    7171. 

  7171.             b_class = job + 4001;
    7172. 

  7172.         }
    7173. 

  7173.     }
    7174. 

  7174.     else if (upper == 2)
    7175. 

  7175.     {                           //養子に結婚はないけどどうせ次で蹴られるからいいや
    7176. 

  7176.         b_class = (job == 23) ? job + 4022 : job + 4023;
    7177. 

  7177.     }
    7178. 

  7178.     else
    7179. 

  7179.     {
    7180. 

  7180.         return 1;
    7181. 

  7181.     }
    7182. 

  7182. 

  7183.     if ((sd->status.sex == 0 && job == 19) || (sd->status.sex == 1 && job == 20) || (sd->status.sex == 0 && job == 4020) || (sd->status.sex == 1 && job == 4021) || job == 22 || sd->status.class == b_class)   //♀はバードになれない、♂はダンサーになれない、結婚衣裳もお断り 
    7184. 

  7184.         return 1;
    7185. 

  7185. 

  7186.     sd->status.class = sd->view_class = b_class;
    7187. 

  7187. 

  7188.     sd->status.job_level = 1;
    7189. 

  7189.     sd->status.job_exp = 0;
    7190. 

  7190.     clif_updatestatus (sd, SP_JOBLEVEL);
    7191. 

  7191.     clif_updatestatus (sd, SP_JOBEXP);
    7192. 

  7192.     clif_updatestatus (sd, SP_NEXTJOBEXP);
    7193. 

  7193. 

  7194.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    7195. 

  7195.     {
    7196. 

  7196.         if (sd->equip_index[i] >= 0)
    7197. 

  7197.             if (!pc_isequip (sd, sd->equip_index[i]))
    7198. 

  7198.                 pc_unequipitem (sd, sd->equip_index[i], 1);    // 装備外し 	
    7199. 

  7199.     }
    7200. 

  7200. 

  7201.     clif_changelook (&sd->bl, LOOK_BASE, sd->view_class);   // move sprite update to prevent client crashes with incompatible equipment [Valaris]
    7202. 

  7202.     if (sd->status.clothes_color > 0)
    7203. 

  7203.         clif_changelook (&sd->bl, LOOK_CLOTHES_COLOR,
    7204. 

  7204.                          sd->status.clothes_color);
    7205. 

  7205.     if (battle_config.muting_players && sd->status.manner < 0)
    7206. 

  7206.         clif_changestatus (&sd->bl, SP_MANNER, sd->status.manner);
    7207. 

  7207. 

  7208.     pc_calcstatus (sd, 0);
    7209. 

  7209.     pc_checkallowskill (sd);
    7210. 

  7210.     pc_equiplookall (sd);
    7211. 

  7211.     clif_equiplist (sd);
    7212. 

  7212. 

  7213.     if (pc_isriding (sd))
    7214. 

  7214.     {                           // remove peco status if changing into invalid class [Valaris]
    7215. 

  7215.         if (!(pc_checkskill (sd, KN_RIDING)))
    7216. 

  7216.             pc_setoption (sd, sd->status.option | -0x0000);
    7217. 

  7217.         if (pc_checkskill (sd, KN_RIDING) > 0)
    7218. 

  7218.             pc_setriding (sd);
    7219. 

  7219.     }
    7220. 

  7220. 

  7221.     return 0;
    7222. 

  7222. }
    7223. 

  7223. 

  7224. /*==========================================
    7225. 

  7225.  * 見た目変更 
    7226. 

  7226.  *------------------------------------------
    7227. 

  7227.  */
    7228. 

  7228. int pc_equiplookall (struct map_session_data *sd)
    7229. 

  7229. {
    7230. 

  7230.     nullpo_retr (0, sd);
    7231. 

  7231. 

  7232.     clif_changelook (&sd->bl, LOOK_WEAPON, 0);
    7233. 

  7233. //  clif_changelook(&sd->bl,LOOK_SHOES,0);
    7234. 

  7234.     clif_changelook (&sd->bl, LOOK_HEAD_BOTTOM, sd->status.head_bottom);
    7235. 

  7235.     clif_changelook (&sd->bl, LOOK_HEAD_TOP, sd->status.head_top);
    7236. 

  7236.     clif_changelook (&sd->bl, LOOK_HEAD_MID, sd->status.head_mid);
    7237. 

  7237. 

  7238.     clif_changelook_accessories (&sd->bl, NULL);
    7239. 

  7239. 

  7240.     return 0;
    7241. 

  7241. }
    7242. 

  7242. 

  7243. /*==========================================
    7244. 

  7244.  * 見た目変更 
    7245. 

  7245.  *------------------------------------------
    7246. 

  7246.  */
    7247. 

  7247. int pc_changelook (struct map_session_data *sd, int type, int val)
    7248. 

  7248. {
    7249. 

  7249.     nullpo_retr (0, sd);
    7250. 

  7250. 

  7251.     switch (type)
    7252. 

  7252.     {
    7253. 

  7253.         case LOOK_HAIR:
    7254. 

  7254.             sd->status.hair = val;
    7255. 

  7255.             break;
    7256. 

  7256.         case LOOK_WEAPON:
    7257. 

  7257.             sd->status.weapon = val;
    7258. 

  7258.             break;
    7259. 

  7259.         case LOOK_HEAD_BOTTOM:
    7260. 

  7260.             sd->status.head_bottom = val;
    7261. 

  7261.             break;
    7262. 

  7262.         case LOOK_HEAD_TOP:
    7263. 

  7263.             sd->status.head_top = val;
    7264. 

  7264.             break;
    7265. 

  7265.         case LOOK_HEAD_MID:
    7266. 

  7266.             sd->status.head_mid = val;
    7267. 

  7267.             break;
    7268. 

  7268.         case LOOK_HAIR_COLOR:
    7269. 

  7269.             sd->status.hair_color = val;
    7270. 

  7270.             break;
    7271. 

  7271.         case LOOK_CLOTHES_COLOR:
    7272. 

  7272.             sd->status.clothes_color = val;
    7273. 

  7273.             break;
    7274. 

  7274.         case LOOK_SHIELD:
    7275. 

  7275.             sd->status.shield = val;
    7276. 

  7276.             break;
    7277. 

  7277.         case LOOK_SHOES:
    7278. 

  7278.             break;
    7279. 

  7279.         default:
    7280. 

  7280.             break;
    7281. 

  7281.     }
    7282. 

  7282.     clif_changelook (&sd->bl, type, val);
    7283. 

  7283. 

  7284.     return 0;
    7285. 

  7285. }
    7286. 

  7286. 

  7287. /*==========================================
    7288. 

  7288.  * 付属品(鷹,ペコ,カート)設定 
    7289. 

  7289.  *------------------------------------------
    7290. 

  7290.  */
    7291. 

  7291. int pc_setoption (struct map_session_data *sd, int type)
    7292. 

  7292. {
    7293. 

  7293.     nullpo_retr (0, sd);
    7294. 

  7294. 

  7295.     sd->status.option = type;
    7296. 

  7296.     clif_changeoption (&sd->bl);
    7297. 

  7297.     pc_calcstatus (sd, 0);
    7298. 

  7298. 

  7299.     return 0;
    7300. 

  7300. }
    7301. 

  7301. 

  7302. /*==========================================
    7303. 

  7303.  * カート設定 
    7304. 

  7304.  *------------------------------------------
    7305. 

  7305.  */
    7306. 

  7306. int pc_setcart (struct map_session_data *sd, int type)
    7307. 

  7307. {
    7308. 

  7308.     int  cart[6] = { 0x0000, 0x0008, 0x0080, 0x0100, 0x0200, 0x0400 };
    7309. 

  7309. 

  7310.     nullpo_retr (0, sd);
    7311. 

  7311.     if (type < 0 || type >= 6)
    7312. 

  7312.         return 0;
    7313. 

  7313. 

  7314.     if (pc_checkskill (sd, MC_PUSHCART) > 0)
    7315. 

  7315.      {                           // プッシュカートスキル所持 
    7316. 

  7316.         if (!pc_iscarton (sd))
    7317. 

  7317.           {                      // カートを付けていない 
    7318. 

  7318.             pc_setoption (sd, cart[type]);
    7319. 

  7319.             clif_cart_itemlist (sd);
    7320. 

  7320.             clif_cart_equiplist (sd);
    7321. 

  7321.             clif_updatestatus (sd, SP_CARTINFO);
    7322. 

  7322.             clif_status_change (&sd->bl, 0x0c, 0);
    7323. 

  7323.         }
    7324. 

  7324.         else
    7325. 

  7325.         {
    7326. 

  7326.             pc_setoption (sd, cart[type]);
    7327. 

  7327.         }
    7328. 

  7328.     }
    7329. 

  7329. 

  7330.     return 0;
    7331. 

  7331. }
    7332. 

  7332. 

  7333. /*==========================================
    7334. 

  7334.  * 鷹設定 
    7335. 

  7335.  *------------------------------------------
    7336. 

  7336.  */
    7337. 

  7337. int pc_setfalcon (struct map_session_data *sd)
    7338. 

  7338. {
    7339. 

  7339.     nullpo_retr (0, sd);
    7340. 

  7340. 

  7341.     if (pc_checkskill (sd, HT_FALCON) > 0)
    7342. 

  7342.      {                           // ファルコンマスタリースキル所持 
    7343. 

  7343.         pc_setoption (sd, sd->status.option | 0x0010);
    7344. 

  7344.     }
    7345. 

  7345. 

  7346.     return 0;
    7347. 

  7347. }
    7348. 

  7348. 

  7349. /*==========================================
    7350. 

  7350.  * ペコペコ設定 
    7351. 

  7351.  *------------------------------------------
    7352. 

  7352.  */
    7353. 

  7353. int pc_setriding (struct map_session_data *sd)
    7354. 

  7354. {
    7355. 

  7355.     nullpo_retr (0, sd);
    7356. 

  7356. 

  7357.     if (sd->disguise > 0)
    7358. 

  7358.     {                           // temporary prevention of crash caused by peco + disguise, will look into a better solution [Valaris]
    7359. 

  7359.         clif_displaymessage (sd->fd,
    7360. 

  7360.                              "Cannot mount a Peco while in disguise.");
    7361. 

  7361.         return 0;
    7362. 

  7362.     }
    7363. 

  7363. 

  7364.     if ((pc_checkskill (sd, KN_RIDING) > 0))
    7365. 

  7365.      {                           // ライディングスキル所持 
    7366. 

  7366.         pc_setoption (sd, sd->status.option | 0x0020);
    7367. 

  7367. 

  7368. //        if (sd->status.class == 7)
    7369. 

  7369. //            sd->status.class = sd->view_class = 13;
    7370. 

  7370. 

  7371.         if (sd->status.class == 14)
    7372. 

  7372.             sd->status.class = sd->view_class = 21;
    7373. 

  7373. 

  7374.         if (sd->status.class == 4008)
    7375. 

  7375.             sd->status.class = sd->view_class = 4014;
    7376. 

  7376. 

  7377.         if (sd->status.class == 4015)
    7378. 

  7378.             sd->status.class = sd->view_class = 4022;
    7379. 

  7379.     }
    7380. 

  7380. 

  7381.     return 0;
    7382. 

  7382. }
    7383. 

  7383. 

  7384. /*==========================================
    7385. 

  7385.  * script用変数の値を読む 
    7386. 

  7386.  *------------------------------------------
    7387. 

  7387.  */
    7388. 

  7388. int pc_readreg (struct map_session_data *sd, int reg)
    7389. 

  7389. {
    7390. 

  7390.     int  i;
    7391. 

  7391. 

  7392.     nullpo_retr (0, sd);
    7393. 

  7393. 

  7394.     for (i = 0; i < sd->reg_num; i++)
    7395. 

  7395.         if (sd->reg[i].index == reg)
    7396. 

  7396.             return sd->reg[i].data;
    7397. 

  7397. 

  7398.     return 0;
    7399. 

  7399. }
    7400. 

  7400. 

  7401. /*==========================================
    7402. 

  7402.  * script用変数の値を設定 
    7403. 

  7403.  *------------------------------------------
    7404. 

  7404.  */
    7405. 

  7405. int pc_setreg (struct map_session_data *sd, int reg, int val)
    7406. 

  7406. {
    7407. 

  7407.     int  i;
    7408. 

  7408. 

  7409.     nullpo_retr (0, sd);
    7410. 

  7410. 

  7411.     for (i = 0; i < sd->reg_num; i++)
    7412. 

  7412.     {
    7413. 

  7413.         if (sd->reg[i].index == reg)
    7414. 

  7414.         {
    7415. 

  7415.             sd->reg[i].data = val;
    7416. 

  7416.             return 0;
    7417. 

  7417.         }
    7418. 

  7418.     }
    7419. 

  7419.     sd->reg_num++;
    7420. 

  7420.     sd->reg = realloc (sd->reg, sizeof (*(sd->reg)) * sd->reg_num);
    7421. 

  7421.     if (sd->reg == NULL)
    7422. 

  7422.     {
    7423. 

  7423.         printf ("out of memory : pc_setreg\n");
    7424. 

  7424.         exit (1);
    7425. 

  7425.     }
    7426. 

  7426. /*	memset(sd->reg + (sd->reg_num - 1) * sizeof(*(sd->reg)), 0,
    7427. 

  7427. 		sizeof(*(sd->reg)));
    7428. 

  7428. */
    7429. 

  7429.     sd->reg[i].index = reg;
    7430. 

  7430.     sd->reg[i].data = val;
    7431. 

  7431. 

  7432.     return 0;
    7433. 

  7433. }
    7434. 

  7434. 

  7435. /*==========================================
    7436. 

  7436.  * script用文字列変数の値を読む 
    7437. 

  7437.  *------------------------------------------
    7438. 

  7438.  */
    7439. 

  7439. char *pc_readregstr (struct map_session_data *sd, int reg)
    7440. 

  7440. {
    7441. 

  7441.     int  i;
    7442. 

  7442. 

  7443.     nullpo_retr (0, sd);
    7444. 

  7444. 

  7445.     for (i = 0; i < sd->regstr_num; i++)
    7446. 

  7446.         if (sd->regstr[i].index == reg)
    7447. 

  7447.             return sd->regstr[i].data;
    7448. 

  7448. 

  7449.     return NULL;
    7450. 

  7450. }
    7451. 

  7451. 

  7452. /*==========================================
    7453. 

  7453.  * script用文字列変数の値を設定 
    7454. 

  7454.  *------------------------------------------
    7455. 

  7455.  */
    7456. 

  7456. int pc_setregstr (struct map_session_data *sd, int reg, char *str)
    7457. 

  7457. {
    7458. 

  7458.     int  i;
    7459. 

  7459. 

  7460.     nullpo_retr (0, sd);
    7461. 

  7461.     nullpo_retr (0, str);
    7462. 

  7462. 

  7463.     if (strlen (str) + 1 > sizeof (sd->regstr[0].data))
    7464. 

  7464.     {
    7465. 

  7465.         printf ("pc_setregstr(): String too long!\n");
    7466. 

  7466.         return 0;
    7467. 

  7467.     }
    7468. 

  7468. 

  7469.     for (i = 0; i < sd->regstr_num; i++)
    7470. 

  7470.         if (sd->regstr[i].index == reg)
    7471. 

  7471.         {
    7472. 

  7472.             strcpy (sd->regstr[i].data, str);
    7473. 

  7473.             return 0;
    7474. 

  7474.         }
    7475. 

  7475.     sd->regstr_num++;
    7476. 

  7476.     str = aStrdup (str);
    7477. 

  7477.     sd->regstr =
    7478. 

  7478.         realloc (sd->regstr, sizeof (sd->regstr[0]) * sd->regstr_num);
    7479. 

  7479.     if (sd->regstr == NULL)
    7480. 

  7480.     {
    7481. 

  7481.         printf ("out of memory : pc_setreg\n");
    7482. 

  7482.         exit (1);
    7483. 

  7483.     }
    7484. 

  7484. /*	memset(sd->reg + (sd->reg_num - 1) * sizeof(*(sd->reg)), 0,
    7485. 

  7485. 		sizeof(*(sd->reg)));
    7486. 

  7486. */
    7487. 

  7487.     sd->regstr[i].index = reg;
    7488. 

  7488.     strcpy (sd->regstr[i].data, str);
    7489. 

  7489. 

  7490.     aFree (str);
    7491. 

  7491.     return 0;
    7492. 

  7492. }
    7493. 

  7493. 

  7494. /*==========================================
    7495. 

  7495.  * script用グローバル変数の値を読む 
    7496. 

  7496.  *------------------------------------------
    7497. 

  7497.  */
    7498. 

  7498. int pc_readglobalreg (struct map_session_data *sd, char *reg)
    7499. 

  7499. {
    7500. 

  7500.     int  i;
    7501. 

  7501. 

  7502.     nullpo_retr (0, sd);
    7503. 

  7503.     nullpo_retr (0, reg);
    7504. 

  7504. 

  7505.     for (i = 0; i < sd->status.global_reg_num; i++)
    7506. 

  7506.     {
    7507. 

  7507.         if (strcmp (sd->status.global_reg[i].str, reg) == 0)
    7508. 

  7508.             return sd->status.global_reg[i].value;
    7509. 

  7509.     }
    7510. 

  7510. 

  7511.     return 0;
    7512. 

  7512. }
    7513. 

  7513. 

  7514. /*==========================================
    7515. 

  7515.  * script用グローバル変数の値を設定 
    7516. 

  7516.  *------------------------------------------
    7517. 

  7517.  */
    7518. 

  7518. int pc_setglobalreg (struct map_session_data *sd, char *reg, int val)
    7519. 

  7519. {
    7520. 

  7520.     int  i;
    7521. 

  7521. 

  7522.     nullpo_retr (0, sd);
    7523. 

  7523.     nullpo_retr (0, reg);
    7524. 

  7524. 

  7525.     //PC_DIE_COUNTERがスクリプトなどで変更された時の処理 
    7526. 

  7526.     if (strcmp (reg, "PC_DIE_COUNTER") == 0 && sd->die_counter != val)
    7527. 

  7527.     {
    7528. 

  7528.         sd->die_counter = val;
    7529. 

  7529.         pc_calcstatus (sd, 0);
    7530. 

  7530.     }
    7531. 

  7531.     if (val == 0)
    7532. 

  7532.     {
    7533. 

  7533.         for (i = 0; i < sd->status.global_reg_num; i++)
    7534. 

  7534.         {
    7535. 

  7535.             if (strcmp (sd->status.global_reg[i].str, reg) == 0)
    7536. 

  7536.             {
    7537. 

  7537.                 sd->status.global_reg[i] =
    7538. 

  7538.                     sd->status.global_reg[sd->status.global_reg_num - 1];
    7539. 

  7539.                 sd->status.global_reg_num--;
    7540. 

  7540.                 break;
    7541. 

  7541.             }
    7542. 

  7542.         }
    7543. 

  7543.         return 0;
    7544. 

  7544.     }
    7545. 

  7545.     for (i = 0; i < sd->status.global_reg_num; i++)
    7546. 

  7546.     {
    7547. 

  7547.         if (strcmp (sd->status.global_reg[i].str, reg) == 0)
    7548. 

  7548.         {
    7549. 

  7549.             sd->status.global_reg[i].value = val;
    7550. 

  7550.             return 0;
    7551. 

  7551.         }
    7552. 

  7552.     }
    7553. 

  7553.     if (sd->status.global_reg_num < GLOBAL_REG_NUM)
    7554. 

  7554.     {
    7555. 

  7555.         strcpy (sd->status.global_reg[i].str, reg);
    7556. 

  7556.         sd->status.global_reg[i].value = val;
    7557. 

  7557.         sd->status.global_reg_num++;
    7558. 

  7558.         return 0;
    7559. 

  7559.     }
    7560. 

  7560.     if (battle_config.error_log)
    7561. 

  7561.         printf ("pc_setglobalreg : couldn't set %s (GLOBAL_REG_NUM = %d)\n",
    7562. 

  7562.                 reg, GLOBAL_REG_NUM);
    7563. 

  7563. 

  7564.     return 1;
    7565. 

  7565. }
    7566. 

  7566. 

  7567. /*==========================================
    7568. 

  7568.  * script用アカウント変数の値を読む 
    7569. 

  7569.  *------------------------------------------
    7570. 

  7570.  */
    7571. 

  7571. int pc_readaccountreg (struct map_session_data *sd, char *reg)
    7572. 

  7572. {
    7573. 

  7573.     int  i;
    7574. 

  7574. 

  7575.     nullpo_retr (0, sd);
    7576. 

  7576.     nullpo_retr (0, reg);
    7577. 

  7577. 

  7578.     for (i = 0; i < sd->status.account_reg_num; i++)
    7579. 

  7579.     {
    7580. 

  7580.         if (strcmp (sd->status.account_reg[i].str, reg) == 0)
    7581. 

  7581.             return sd->status.account_reg[i].value;
    7582. 

  7582.     }
    7583. 

  7583. 

  7584.     return 0;
    7585. 

  7585. }
    7586. 

  7586. 

  7587. /*==========================================
    7588. 

  7588.  * script用アカウント変数の値を設定 
    7589. 

  7589.  *------------------------------------------
    7590. 

  7590.  */
    7591. 

  7591. int pc_setaccountreg (struct map_session_data *sd, char *reg, int val)
    7592. 

  7592. {
    7593. 

  7593.     int  i;
    7594. 

  7594. 

  7595.     nullpo_retr (0, sd);
    7596. 

  7596.     nullpo_retr (0, reg);
    7597. 

  7597. 

  7598.     if (val == 0)
    7599. 

  7599.     {
    7600. 

  7600.         for (i = 0; i < sd->status.account_reg_num; i++)
    7601. 

  7601.         {
    7602. 

  7602.             if (strcmp (sd->status.account_reg[i].str, reg) == 0)
    7603. 

  7603.             {
    7604. 

  7604.                 sd->status.account_reg[i] =
    7605. 

  7605.                     sd->status.account_reg[sd->status.account_reg_num - 1];
    7606. 

  7606.                 sd->status.account_reg_num--;
    7607. 

  7607.                 break;
    7608. 

  7608.             }
    7609. 

  7609.         }
    7610. 

  7610.         intif_saveaccountreg (sd);
    7611. 

  7611.         return 0;
    7612. 

  7612.     }
    7613. 

  7613.     for (i = 0; i < sd->status.account_reg_num; i++)
    7614. 

  7614.     {
    7615. 

  7615.         if (strcmp (sd->status.account_reg[i].str, reg) == 0)
    7616. 

  7616.         {
    7617. 

  7617.             sd->status.account_reg[i].value = val;
    7618. 

  7618.             intif_saveaccountreg (sd);
    7619. 

  7619.             return 0;
    7620. 

  7620.         }
    7621. 

  7621.     }
    7622. 

  7622.     if (sd->status.account_reg_num < ACCOUNT_REG_NUM)
    7623. 

  7623.     {
    7624. 

  7624.         strcpy (sd->status.account_reg[i].str, reg);
    7625. 

  7625.         sd->status.account_reg[i].value = val;
    7626. 

  7626.         sd->status.account_reg_num++;
    7627. 

  7627.         intif_saveaccountreg (sd);
    7628. 

  7628.         return 0;
    7629. 

  7629.     }
    7630. 

  7630.     if (battle_config.error_log)
    7631. 

  7631.         printf ("pc_setaccountreg : couldn't set %s (ACCOUNT_REG_NUM = %d)\n",
    7632. 

  7632.                 reg, ACCOUNT_REG_NUM);
    7633. 

  7633. 

  7634.     return 1;
    7635. 

  7635. }
    7636. 

  7636. 

  7637. /*==========================================
    7638. 

  7638.  * script用アカウント変数2の値を読む 
    7639. 

  7639.  *------------------------------------------
    7640. 

  7640.  */
    7641. 

  7641. int pc_readaccountreg2 (struct map_session_data *sd, char *reg)
    7642. 

  7642. {
    7643. 

  7643.     int  i;
    7644. 

  7644. 

  7645.     nullpo_retr (0, sd);
    7646. 

  7646.     nullpo_retr (0, reg);
    7647. 

  7647. 

  7648.     for (i = 0; i < sd->status.account_reg2_num; i++)
    7649. 

  7649.     {
    7650. 

  7650.         if (strcmp (sd->status.account_reg2[i].str, reg) == 0)
    7651. 

  7651.             return sd->status.account_reg2[i].value;
    7652. 

  7652.     }
    7653. 

  7653. 

  7654.     return 0;
    7655. 

  7655. }
    7656. 

  7656. 

  7657. /*==========================================
    7658. 

  7658.  * script用アカウント変数2の値を設定 
    7659. 

  7659.  *------------------------------------------
    7660. 

  7660.  */
    7661. 

  7661. int pc_setaccountreg2 (struct map_session_data *sd, char *reg, int val)
    7662. 

  7662. {
    7663. 

  7663.     int  i;
    7664. 

  7664. 

  7665.     nullpo_retr (1, sd);
    7666. 

  7666.     nullpo_retr (1, reg);
    7667. 

  7667. 

  7668.     if (val == 0)
    7669. 

  7669.     {
    7670. 

  7670.         for (i = 0; i < sd->status.account_reg2_num; i++)
    7671. 

  7671.         {
    7672. 

  7672.             if (strcmp (sd->status.account_reg2[i].str, reg) == 0)
    7673. 

  7673.             {
    7674. 

  7674.                 sd->status.account_reg2[i] =
    7675. 

  7675.                     sd->status.account_reg2[sd->status.account_reg2_num - 1];
    7676. 

  7676.                 sd->status.account_reg2_num--;
    7677. 

  7677.                 break;
    7678. 

  7678.             }
    7679. 

  7679.         }
    7680. 

  7680.         chrif_saveaccountreg2 (sd);
    7681. 

  7681.         return 0;
    7682. 

  7682.     }
    7683. 

  7683.     for (i = 0; i < sd->status.account_reg2_num; i++)
    7684. 

  7684.     {
    7685. 

  7685.         if (strcmp (sd->status.account_reg2[i].str, reg) == 0)
    7686. 

  7686.         {
    7687. 

  7687.             sd->status.account_reg2[i].value = val;
    7688. 

  7688.             chrif_saveaccountreg2 (sd);
    7689. 

  7689.             return 0;
    7690. 

  7690.         }
    7691. 

  7691.     }
    7692. 

  7692.     if (sd->status.account_reg2_num < ACCOUNT_REG2_NUM)
    7693. 

  7693.     {
    7694. 

  7694.         strcpy (sd->status.account_reg2[i].str, reg);
    7695. 

  7695.         sd->status.account_reg2[i].value = val;
    7696. 

  7696.         sd->status.account_reg2_num++;
    7697. 

  7697.         chrif_saveaccountreg2 (sd);
    7698. 

  7698.         return 0;
    7699. 

  7699.     }
    7700. 

  7700.     if (battle_config.error_log)
    7701. 

  7701.         printf
    7702. 

  7702.             ("pc_setaccountreg2 : couldn't set %s (ACCOUNT_REG2_NUM = %d)\n",
    7703. 

  7703.              reg, ACCOUNT_REG2_NUM);
    7704. 

  7704. 

  7705.     return 1;
    7706. 

  7706. }
    7707. 

  7707. 

  7708. /*==========================================
    7709. 

  7709.  * 精錬成功率 
    7710. 

  7710.  *------------------------------------------
    7711. 

  7711.  */
    7712. 

  7712. int pc_percentrefinery (struct map_session_data *sd, struct item *item)
    7713. 

  7713. {
    7714. 

  7714.     int  percent;
    7715. 

  7715. 

  7716.     nullpo_retr (0, item);
    7717. 

  7717. 

  7718.     //++++ need check itemdb_wlv (item->nameid)?
    7719. 

  7719.     percent = percentrefinery[itemdb_wlv (item->nameid)][(int) item->refine];
    7720. 

  7720.     percent += pc_checkskill (sd, BS_WEAPONRESEARCH);   // 武器研究スキル所持 
    7721. 

  7721. 

  7722.     // 確率の有効範囲チェック 
    7723. 

  7723.     if (percent > 100)
    7724. 

  7724.     {
    7725. 

  7725.         percent = 100;
    7726. 

  7726.     }
    7727. 

  7727.     else if (percent < 0)
    7728. 

  7728.     {
    7729. 

  7729.         percent = 0;
    7730. 

  7730.     }
    7731. 

  7731. 

  7732.     return percent;
    7733. 

  7733. }
    7734. 

  7734. 

  7735. /*==========================================
    7736. 

  7736.  * イベントタイマー処理 
    7737. 

  7737.  *------------------------------------------
    7738. 

  7738.  */
    7739. 

  7739. int pc_eventtimer (int tid, unsigned int tick __attribute__ ((unused)), int id, int data)
    7740. 

  7740. {
    7741. 

  7741.     struct map_session_data *sd = map_id2sd (id);
    7742. 

  7742.     int  i;
    7743. 

  7743.     if (sd == NULL)
    7744. 

  7744.         return 0;
    7745. 

  7745. 

  7746.     for (i = 0; i < MAX_EVENTTIMER; i++)
    7747. 

  7747.     {
    7748. 

  7748.         if (sd->eventtimer[i] == tid)
    7749. 

  7749.         {
    7750. 

  7750.             sd->eventtimer[i] = -1;
    7751. 

  7751.             npc_event (sd, (const char *) data, 0);
    7752. 

  7752.             break;
    7753. 

  7753.         }
    7754. 

  7754.     }
    7755. 

  7755.     free ((void *) data);
    7756. 

  7756.     if (i == MAX_EVENTTIMER)
    7757. 

  7757.     {
    7758. 

  7758.         if (battle_config.error_log)
    7759. 

  7759.             printf ("pc_eventtimer: no such event timer\n");
    7760. 

  7760.     }
    7761. 

  7761. 

  7762.     return 0;
    7763. 

  7763. }
    7764. 

  7764. 

  7765. /*==========================================
    7766. 

  7766.  * イベントタイマー追加 
    7767. 

  7767.  *------------------------------------------
    7768. 

  7768.  */
    7769. 

  7769. int pc_addeventtimer (struct map_session_data *sd, int tick, const char *name)
    7770. 

  7770. {
    7771. 

  7771.     int  i;
    7772. 

  7772. 

  7773.     nullpo_retr (0, sd);
    7774. 

  7774. 

  7775.     for (i = 0; i < MAX_EVENTTIMER; i++)
    7776. 

  7776.         if (sd->eventtimer[i] == -1)
    7777. 

  7777.             break;
    7778. 

  7778. 

  7779.     if (i < MAX_EVENTTIMER)
    7780. 

  7780.     {
    7781. 

  7781.         char *evname = (char *) aCalloc (24, sizeof (char));
    7782. 

  7782.         safestrncpy (evname, name, 24);
    7783. 

  7783.         sd->eventtimer[i] = add_timer (gettick () + tick,
    7784. 

  7784.                                        pc_eventtimer, sd->bl.id,
    7785. 

  7785.                                        (int) evname);
    7786. 

  7786.         return 1;
    7787. 

  7787.     }
    7788. 

  7788. 

  7789.     return 0;
    7790. 

  7790. }
    7791. 

  7791. 

  7792. /*==========================================
    7793. 

  7793.  * イベントタイマー削除 
    7794. 

  7794.  *------------------------------------------
    7795. 

  7795.  */
    7796. 

  7796. int pc_deleventtimer (struct map_session_data *sd, const char *name)
    7797. 

  7797. {
    7798. 

  7798.     int  i;
    7799. 

  7799. 

  7800.     nullpo_retr (0, sd);
    7801. 

  7801.     nullpo_retr (0, name);
    7802. 

  7802. 

  7803.     for (i = 0; i < MAX_EVENTTIMER; i++)
    7804. 

  7804.         if (sd->eventtimer[i] != -1 && strcmp ((char
    7805. 

  7805.                                                 *) (get_timer (sd->eventtimer
    7806. 

  7806.                                                                [i])->data),
    7807. 

  7807.                                                name) == 0)
    7808. 

  7808.         {
    7809. 

  7809.             delete_timer (sd->eventtimer[i], pc_eventtimer);
    7810. 

  7810.             sd->eventtimer[i] = -1;
    7811. 

  7811.             break;
    7812. 

  7812.         }
    7813. 

  7813. 

  7814.     return 0;
    7815. 

  7815. }
    7816. 

  7816. 

  7817. /*==========================================
    7818. 

  7818.  * イベントタイマーカウント値追加 
    7819. 

  7819.  *------------------------------------------
    7820. 

  7820.  */
    7821. 

  7821. int pc_addeventtimercount (struct map_session_data *sd, const char *name,
    7822. 

  7822.                            int tick)
    7823. 

  7823. {
    7824. 

  7824.     int  i;
    7825. 

  7825. 

  7826.     nullpo_retr (0, sd);
    7827. 

  7827.     nullpo_retr (0, name);
    7828. 

  7828. 

  7829.     for (i = 0; i < MAX_EVENTTIMER; i++)
    7830. 

  7830.         if (sd->eventtimer[i] != -1 && strcmp ((char
    7831. 

  7831.                                                 *) (get_timer (sd->eventtimer
    7832. 

  7832.                                                                [i])->data),
    7833. 

  7833.                                                name) == 0)
    7834. 

  7834.         {
    7835. 

  7835.             addtick_timer (sd->eventtimer[i], tick);
    7836. 

  7836.             break;
    7837. 

  7837.         }
    7838. 

  7838. 

  7839.     return 0;
    7840. 

  7840. }
    7841. 

  7841. 

  7842. /*==========================================
    7843. 

  7843.  * イベントタイマー全削除 
    7844. 

  7844.  *------------------------------------------
    7845. 

  7845.  */
    7846. 

  7846. int pc_cleareventtimer (struct map_session_data *sd)
    7847. 

  7847. {
    7848. 

  7848.     int  i;
    7849. 

  7849. 

  7850.     nullpo_retr (0, sd);
    7851. 

  7851. 

  7852.     for (i = 0; i < MAX_EVENTTIMER; i++)
    7853. 

  7853.         if (sd->eventtimer[i] != -1)
    7854. 

  7854.         {
    7855. 

  7855.             delete_timer (sd->eventtimer[i], pc_eventtimer);
    7856. 

  7856.             sd->eventtimer[i] = -1;
    7857. 

  7857.         }
    7858. 

  7858. 

  7859.     return 0;
    7860. 

  7860. }
    7861. 

  7861. 

  7862. //
    7863. 

  7863. // 装 備物 
    7864. 

  7864. //
    7865. 

  7865. /*==========================================
    7866. 

  7866.  * アイテムを装備する 
    7867. 

  7867.  *------------------------------------------
    7868. 

  7868.  */
    7869. 

  7869. static int
    7870. 

  7870. pc_signal_advanced_equipment_change (struct map_session_data *sd, int n)
    7871. 

  7871. {
    7872. 

  7872.     nullpo_retr (0, sd);
    7873. 

  7873. 

  7874.     if (n < 0 || n >= MAX_INVENTORY)
    7875. 

  7875.         return 0;
    7876. 

  7876. 

  7877.     if (sd->status.inventory[n].equip & 0x0040)
    7878. 

  7878.         clif_changelook (&sd->bl, LOOK_SHOES, 0);
    7879. 

  7879.     if (sd->status.inventory[n].equip & 0x0004)
    7880. 

  7880.         clif_changelook (&sd->bl, LOOK_GLOVES, 0);
    7881. 

  7881.     if (sd->status.inventory[n].equip & 0x0008)
    7882. 

  7882.         clif_changelook (&sd->bl, LOOK_CAPE, 0);
    7883. 

  7883.     if (sd->status.inventory[n].equip & 0x0010)
    7884. 

  7884.         clif_changelook (&sd->bl, LOOK_MISC1, 0);
    7885. 

  7885.     if (sd->status.inventory[n].equip & 0x0080)
    7886. 

  7886.         clif_changelook (&sd->bl, LOOK_MISC2, 0);
    7887. 

  7887.     return 0;
    7888. 

  7888. }
    7889. 

  7889. 

  7890. int pc_equipitem (struct map_session_data *sd, int n, int pos)
    7891. 

  7891. {
    7892. 

  7892.     int  i, nameid, arrow, view;
    7893. 

  7893.     struct item_data *id;
    7894. 

  7894.     //転生や養子の場合の元の職業を算出する 
    7895. 

  7895. 

  7896.     nullpo_retr (0, sd);
    7897. 

  7897. 

  7898.     if (n < 0 || n >= MAX_INVENTORY)
    7899. 

  7899.     {
    7900. 

  7900.         clif_equipitemack (sd, 0, 0, 0);
    7901. 

  7901.         return 0;
    7902. 

  7902.     }
    7903. 

  7903. 

  7904.     nameid = sd->status.inventory[n].nameid;
    7905. 

  7905.     id = sd->inventory_data[n];
    7906. 

  7906.     pos = pc_equippoint (sd, n);
    7907. 

  7907. 

  7908.     if (battle_config.battle_log)
    7909. 

  7909.         printf ("equip %d(%d) %x:%x\n", nameid, n, id->equip, pos);
    7910. 

  7910.     if (!pc_isequip (sd, n) || !pos || sd->status.inventory[n].broken == 1)
    7911. 

  7911.     {                           // [Valaris]
    7912. 

  7912.         clif_equipitemack (sd, n, 0, 0);    // fail
    7913. 

  7913.         return 0;
    7914. 

  7914.     }
    7915. 

  7915. 

  7916. // -- moonsoul (if player is berserk then cannot equip)
    7917. 

  7917. //
    7918. 

  7918.     if (sd->sc_data[SC_BERSERK].timer != -1)
    7919. 

  7919.     {
    7920. 

  7920.         clif_equipitemack (sd, n, 0, 0);    // fail
    7921. 

  7921.         return 0;
    7922. 

  7922.     }
    7923. 

  7923. 

  7924.     if (pos == 0x88)
    7925. 

  7925.      {                          // アクセサリ用例外処理 
    7926. 

  7926.         int  epor = 0;
    7927. 

  7927.         if (sd->equip_index[0] >= 0)
    7928. 

  7928.             epor |= sd->status.inventory[sd->equip_index[0]].equip;
    7929. 

  7929.         if (sd->equip_index[1] >= 0)
    7930. 

  7930.             epor |= sd->status.inventory[sd->equip_index[1]].equip;
    7931. 

  7931.         epor &= 0x88;
    7932. 

  7932.         pos = epor == 0x08 ? 0x80 : 0x08;
    7933. 

  7933.     }
    7934. 

  7934. 

  7935.     // 二刀流処理 
    7936. 

  7936.     if ((pos == 0x22)           // 一応、装備要求箇所が二刀流武器かチェックする 
    7937. 

  7937.         && (id->equip == 2)     // 単 手武器 
    7938. 

  7938.         && (pc_checkskill (sd, AS_LEFT) > 0 || sd->status.class == 12))  // 左手修錬有 
    7939. 

  7939.     {
    7940. 

  7940.         int  tpos = 0;
    7941. 

  7941.         if (sd->equip_index[8] >= 0)
    7942. 

  7942.             tpos |= sd->status.inventory[sd->equip_index[8]].equip;
    7943. 

  7943.         if (sd->equip_index[9] >= 0)
    7944. 

  7944.             tpos |= sd->status.inventory[sd->equip_index[9]].equip;
    7945. 

  7945.         tpos &= 0x02;
    7946. 

  7946.         pos = tpos == 0x02 ? 0x20 : 0x02;
    7947. 

  7947.     }
    7948. 

  7948. 

  7949.     arrow = pc_search_inventory (sd, pc_checkequip (sd, 9));    // Added by RoVeRT
    7950. 

  7950.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    7951. 

  7951.     {
    7952. 

  7952.         if (pos & equip_pos[i])
    7953. 

  7953.         {
    7954. 

  7954.             if (sd->equip_index[i] >= 0)    //Slot taken, remove item from there.
    7955. 

  7955.                 pc_unequipitem (sd, sd->equip_index[i], 1);
    7956. 

  7956.             sd->equip_index[i] = n;
    7957. 

  7957.         }
    7958. 

  7958.     }
    7959. 

  7959.     // 弓矢装備 
    7960. 

  7960.     if (pos == 0x8000)
    7961. 

  7961.     {
    7962. 

  7962.         clif_arrowequip (sd, n);
    7963. 

  7963.         clif_arrow_fail (sd, 3);    // 3=矢が装備できました 
    7964. 

  7964.     }
    7965. 

  7965.     else
    7966. 

  7966.     {
    7967. 

  7967.         /* Don't update re-equipping if we're using a spell */
    7968. 

  7968.         if (!(pos == 4 && sd->attack_spell_override))
    7969. 

  7969.             clif_equipitemack (sd, n, pos, 1);
    7970. 

  7970.     }
    7971. 

  7971. 

  7972.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    7973. 

  7973.     {
    7974. 

  7974.         if (pos & equip_pos[i])
    7975. 

  7975.             sd->equip_index[i] = n;
    7976. 

  7976.     }
    7977. 

  7977.     sd->status.inventory[n].equip = pos;
    7978. 

  7978. 

  7979.     if (sd->inventory_data[n])
    7980. 

  7980.     {
    7981. 

  7981.         view = sd->inventory_data[n]->look;
    7982. 

  7982.         if (view == 0)
    7983. 

  7983.             view = sd->inventory_data[n]->nameid;
    7984. 

  7984.     }
    7985. 

  7985.     else
    7986. 

  7986.     {
    7987. 

  7987.         view = 0;
    7988. 

  7988.     }
    7989. 

  7989. 

  7990.     if (sd->status.inventory[n].equip & 0x0002)
    7991. 

  7991.     {
    7992. 

  7992.         sd->weapontype1 = view;
    7993. 

  7993.         pc_calcweapontype (sd);
    7994. 

  7994.         pc_set_weapon_look (sd);
    7995. 

  7995.     }
    7996. 

  7996.     if (sd->status.inventory[n].equip & 0x0020)
    7997. 

  7997.     {
    7998. 

  7998.         if (sd->inventory_data[n])
    7999. 

  7999.         {
    8000. 

  8000.             if (sd->inventory_data[n]->type == 4)
    8001. 

  8001.             {
    8002. 

  8002.                 sd->status.shield = 0;
    8003. 

  8003.                 if (sd->status.inventory[n].equip == 0x0020)
    8004. 

  8004.                     sd->weapontype2 = view;
    8005. 

  8005.             }
    8006. 

  8006.             else if (sd->inventory_data[n]->type == 5)
    8007. 

  8007.             {
    8008. 

  8008.                 sd->status.shield = view;
    8009. 

  8009.                 sd->weapontype2 = 0;
    8010. 

  8010.             }
    8011. 

  8011.         }
    8012. 

  8012.         else
    8013. 

  8013.             sd->status.shield = sd->weapontype2 = 0;
    8014. 

  8014.         pc_calcweapontype (sd);
    8015. 

  8015.         clif_changelook (&sd->bl, LOOK_SHIELD, sd->status.shield);
    8016. 

  8016.     }
    8017. 

  8017.     if (sd->status.inventory[n].equip & 0x0001)
    8018. 

  8018.     {
    8019. 

  8019.         sd->status.head_bottom = view;
    8020. 

  8020.         clif_changelook (&sd->bl, LOOK_HEAD_BOTTOM, sd->status.head_bottom);
    8021. 

  8021.     }
    8022. 

  8022.     if (sd->status.inventory[n].equip & 0x0100)
    8023. 

  8023.     {
    8024. 

  8024.         sd->status.head_top = view;
    8025. 

  8025.         clif_changelook (&sd->bl, LOOK_HEAD_TOP, sd->status.head_top);
    8026. 

  8026.     }
    8027. 

  8027.     if (sd->status.inventory[n].equip & 0x0200)
    8028. 

  8028.     {
    8029. 

  8029.         sd->status.head_mid = view;
    8030. 

  8030.         clif_changelook (&sd->bl, LOOK_HEAD_MID, sd->status.head_mid);
    8031. 

  8031.     }
    8032. 

  8032.     if (sd->status.inventory[n].equip & 0x0400)
    8033. 

  8033.     {
    8034. 

  8034.         clif_changelook (&sd->bl, LOOK_EVOL_RING1, view);
    8035. 

  8035.     }
    8036. 

  8036.     if (sd->status.inventory[n].equip & 0x0800)
    8037. 

  8037.     {
    8038. 

  8038.         clif_changelook (&sd->bl, LOOK_EVOL_RING2, view);
    8039. 

  8039.     }
    8040. 

  8040. 

  8041.     pc_signal_advanced_equipment_change (sd, n);
    8042. 

  8042. 

  8043.     pc_checkallowskill (sd);    // 装備品でスキルか解除されるかチェック 
    8044. 

  8044.     if (itemdb_look (sd->status.inventory[n].nameid) == 11 && arrow)
    8045. 

  8045.     {                           // Added by RoVeRT
    8046. 

  8046.         clif_arrowequip (sd, arrow);
    8047. 

  8047.         sd->status.inventory[arrow].equip = 32768;
    8048. 

  8048.     }
    8049. 

  8049.     pc_calcstatus (sd, 0);
    8050. 

  8050. 

  8051.     if (sd->special_state.infinite_endure)
    8052. 

  8052.     {
    8053. 

  8053.         if (sd->sc_data[SC_ENDURE].timer == -1)
    8054. 

  8054.             skill_status_change_start (&sd->bl, SC_ENDURE, 10, 1, 0, 0, 0, 0);
    8055. 

  8055.     }
    8056. 

  8056.     else
    8057. 

  8057.     {
    8058. 

  8058.         if (sd->sc_data[SC_ENDURE].timer != -1 && sd->sc_data[SC_ENDURE].val2)
    8059. 

  8059.             skill_status_change_end (&sd->bl, SC_ENDURE, -1);
    8060. 

  8060.     }
    8061. 

  8061. 

  8062.     if (sd->sc_data[SC_SIGNUMCRUCIS].timer != -1
    8063. 

  8063.         && !battle_check_undead (7, sd->def_ele))
    8064. 

  8064.         skill_status_change_end (&sd->bl, SC_SIGNUMCRUCIS, -1);
    8065. 

  8065.     if (sd->sc_data[SC_DANCING].timer != -1
    8066. 

  8066.         && (sd->status.weapon != 13 && sd->status.weapon != 14))
    8067. 

  8067.         skill_stop_dancing (&sd->bl, 0);
    8068. 

  8068. 

  8069.     return 0;
    8070. 

  8070. }
    8071. 

  8071. 

  8072. /*==========================================
    8073. 

  8073.  * 装 備した物を外す 
    8074. 

  8074.  *------------------------------------------
    8075. 

  8075.  */
    8076. 

  8076. int pc_unequipitem (struct map_session_data *sd, int n, int type)
    8077. 

  8077. {
    8078. 

  8078.     nullpo_retr (0, sd);
    8079. 

  8079. 

  8080.     if (n < 0 || n >= MAX_INVENTORY)
    8081. 

  8081.         return 0;
    8082. 

  8082. 

  8083. // -- moonsoul  (if player is berserk then cannot unequip)
    8084. 

  8084. //
    8085. 

  8085.     if (sd->sc_data[SC_BERSERK].timer != -1)
    8086. 

  8086.     {
    8087. 

  8087.         clif_unequipitemack (sd, n, 0, 0);
    8088. 

  8088.         return 0;
    8089. 

  8089.     }
    8090. 

  8090. 

  8091.     if (battle_config.battle_log)
    8092. 

  8092.         printf ("unequip %d %x:%x\n", n, pc_equippoint (sd, n),
    8093. 

  8093.                 sd->status.inventory[n].equip);
    8094. 

  8094.     if (sd->status.inventory[n].equip)
    8095. 

  8095.     {
    8096. 

  8096.         int  i;
    8097. 

  8097.         for (i = 0; i < MAX_EQUIP_SIZE; i++)
    8098. 

  8098.         {
    8099. 

  8099.             if (sd->status.inventory[n].equip & equip_pos[i])
    8100. 

  8100.                 sd->equip_index[i] = -1;
    8101. 

  8101.         }
    8102. 

  8102.         if (sd->status.inventory[n].equip & 0x0002)
    8103. 

  8103.         {
    8104. 

  8104.             sd->weapontype1 = 0;
    8105. 

  8105.             sd->status.weapon = sd->weapontype2;
    8106. 

  8106.             pc_calcweapontype (sd);
    8107. 

  8107.             pc_set_weapon_look (sd);
    8108. 

  8108.         }
    8109. 

  8109.         if (sd->status.inventory[n].equip & 0x0020)
    8110. 

  8110.         {
    8111. 

  8111.             sd->status.shield = sd->weapontype2 = 0;
    8112. 

  8112.             pc_calcweapontype (sd);
    8113. 

  8113.             clif_changelook (&sd->bl, LOOK_SHIELD, sd->status.shield);
    8114. 

  8114.         }
    8115. 

  8115.         if (sd->status.inventory[n].equip & 0x0001)
    8116. 

  8116.         {
    8117. 

  8117.             sd->status.head_bottom = 0;
    8118. 

  8118.             clif_changelook (&sd->bl, LOOK_HEAD_BOTTOM,
    8119. 

  8119.                              sd->status.head_bottom);
    8120. 

  8120.         }
    8121. 

  8121.         if (sd->status.inventory[n].equip & 0x0100)
    8122. 

  8122.         {
    8123. 

  8123.             sd->status.head_top = 0;
    8124. 

  8124.             clif_changelook (&sd->bl, LOOK_HEAD_TOP, sd->status.head_top);
    8125. 

  8125.         }
    8126. 

  8126.         if (sd->status.inventory[n].equip & 0x0200)
    8127. 

  8127.         {
    8128. 

  8128.             sd->status.head_mid = 0;
    8129. 

  8129.             clif_changelook (&sd->bl, LOOK_HEAD_MID, sd->status.head_mid);
    8130. 

  8130.         }
    8131. 

  8131.         if (sd->status.inventory[n].equip & 0x0400)
    8132. 

  8132.         {
    8133. 

  8133.             clif_changelook (&sd->bl, LOOK_EVOL_RING1, 0);
    8134. 

  8134.         }
    8135. 

  8135.         if (sd->status.inventory[n].equip & 0x0800)
    8136. 

  8136.         {
    8137. 

  8137.             clif_changelook (&sd->bl, LOOK_EVOL_RING2, 0);
    8138. 

  8138.         }
    8139. 

  8139.         pc_signal_advanced_equipment_change (sd, n);
    8140. 

  8140. 

  8141.         if (sd->sc_data[SC_BROKNWEAPON].timer != -1
    8142. 

  8142.             && sd->status.inventory[n].equip & 0x0002
    8143. 

  8143.             && sd->status.inventory[i].broken == 1)
    8144. 

  8144.             skill_status_change_end (&sd->bl, SC_BROKNWEAPON, -1);
    8145. 

  8145. 

  8146.         clif_unequipitemack (sd, n, sd->status.inventory[n].equip, 1);
    8147. 

  8147.         sd->status.inventory[n].equip = 0;
    8148. 

  8148.         if (!type)
    8149. 

  8149.             pc_checkallowskill (sd);
    8150. 

  8150.         if (sd->weapontype1 == 0 && sd->weapontype2 == 0)
    8151. 

  8151.             skill_encchant_eremental_end (&sd->bl, -1);
    8152. 

  8152.     }
    8153. 

  8153.     else
    8154. 

  8154.     {
    8155. 

  8155.         clif_unequipitemack (sd, n, 0, 0);
    8156. 

  8156.     }
    8157. 

  8157.     if(sd->inventory_data[n] && sd->inventory_data[n]->unequip_script)
    8158. 

  8158.     {
    8159. 

  8159.         argrec_t arg[2];
    8160. 

  8160.         arg[0].name = "@slotId";
    8161. 

  8161.         arg[0].v.i = 0;
    8162. 

  8162.         arg[1].name = "@itemId";
    8163. 

  8163.         arg[1].v.i = sd->inventory_data[n]->nameid;
    8164. 

  8164.         run_script_l (sd->inventory_data[n]->unequip_script, 0, sd->bl.id, 0, 2, arg);
    8165. 

  8165.     }
    8166. 

  8166. 

  8167.     if (!type)
    8168. 

  8168.     {
    8169. 

  8169.         pc_calcstatus (sd, 0);
    8170. 

  8170.         if (sd->sc_data[SC_SIGNUMCRUCIS].timer != -1
    8171. 

  8171.             && !battle_check_undead (7, sd->def_ele))
    8172. 

  8172.             skill_status_change_end (&sd->bl, SC_SIGNUMCRUCIS, -1);
    8173. 

  8173.     }
    8174. 

  8174. 

  8175.     return 0;
    8176. 

  8176. }
    8177. 

  8177. 

  8178. int pc_unequipinvyitem (struct map_session_data *sd, int n, int type)
    8179. 

  8179. {
    8180. 

  8180.     int  i;
    8181. 

  8181. 

  8182.     nullpo_retr (1, sd);
    8183. 

  8183. 

  8184.     for (i = 0; i < MAX_EQUIP_SIZE; i++)
    8185. 

  8185.     {
    8186. 

  8186.         if (equip_pos[i] > 0 && sd->equip_index[i] == n)
    8187. 

  8187.         {                       //Slot taken, remove item from there.
    8188. 

  8188.             pc_unequipitem (sd, sd->equip_index[i], type);
    8189. 

  8189.             sd->equip_index[i] = -1;
    8190. 

  8190.         }
    8191. 

  8191.     }
    8192. 

  8192. 

  8193.     return 0;
    8194. 

  8194. }
    8195. 

  8195. 

  8196. /*==========================================
    8197. 

  8197.  * アイテムのindex番号を詰めたり 
    8198. 

  8198.  * 装 備品の装備可能チェックを行なう 
    8199. 

  8199.  *------------------------------------------
    8200. 

  8200.  */
    8201. 

  8201. int pc_checkitem (struct map_session_data *sd)
    8202. 

  8202. {
    8203. 

  8203.     int  i, j, k, id, calc_flag = 0;
    8204. 

  8204.     struct item_data *it = NULL;
    8205. 

  8205. 

  8206.     nullpo_retr (0, sd);
    8207. 

  8207. 

  8208.     // 所持品空き詰め 
    8209. 

  8209.     for (i = j = 0; i < MAX_INVENTORY; i++)
    8210. 

  8210.     {
    8211. 

  8211.         if ((id = sd->status.inventory[i].nameid) == 0)
    8212. 

  8212.             continue;
    8213. 

  8213.         if (battle_config.item_check && !itemdb_available (id))
    8214. 

  8214.         {
    8215. 

  8215.             if (battle_config.error_log)
    8216. 

  8216.                 printf ("illeagal item id %d in %d[%s] inventory.\n", id,
    8217. 

  8217.                         sd->bl.id, sd->status.name);
    8218. 

  8218.             pc_delitem (sd, i, sd->status.inventory[i].amount, 3);
    8219. 

  8219.             continue;
    8220. 

  8220.         }
    8221. 

  8221.         if (i > j)
    8222. 

  8222.         {
    8223. 

  8223.             memcpy (&sd->status.inventory[j], &sd->status.inventory[i],
    8224. 

  8224.                     sizeof (struct item));
    8225. 

  8225.             sd->inventory_data[j] = sd->inventory_data[i];
    8226. 

  8226.         }
    8227. 

  8227.         j++;
    8228. 

  8228.     }
    8229. 

  8229.     if (j < MAX_INVENTORY)
    8230. 

  8230.         memset (&sd->status.inventory[j], 0,
    8231. 

  8231.                 sizeof (struct item) * (MAX_INVENTORY - j));
    8232. 

  8232.     for (k = j; k < MAX_INVENTORY; k++)
    8233. 

  8233.         sd->inventory_data[k] = NULL;
    8234. 

  8234. 

  8235.      // カート内空き詰め 
    8236. 

  8236.     for (i = j = 0; i < MAX_CART; i++)
    8237. 

  8237.     {
    8238. 

  8238.         if ((id = sd->status.cart[i].nameid) == 0)
    8239. 

  8239.             continue;
    8240. 

  8240.         if (battle_config.item_check && !itemdb_available (id))
    8241. 

  8241.         {
    8242. 

  8242.             if (battle_config.error_log)
    8243. 

  8243.                 printf ("illeagal item id %d in %d[%s] cart.\n", id,
    8244. 

  8244.                         sd->bl.id, sd->status.name);
    8245. 

  8245.             pc_cart_delitem (sd, i, sd->status.cart[i].amount, 1);
    8246. 

  8246.             continue;
    8247. 

  8247.         }
    8248. 

  8248.         if (i > j)
    8249. 

  8249.         {
    8250. 

  8250.             memcpy (&sd->status.cart[j], &sd->status.cart[i],
    8251. 

  8251.                     sizeof (struct item));
    8252. 

  8252.         }
    8253. 

  8253.         j++;
    8254. 

  8254.     }
    8255. 

  8255.     if (j < MAX_CART)
    8256. 

  8256.         memset (&sd->status.cart[j], 0,
    8257. 

  8257.                 sizeof (struct item) * (MAX_CART - j));
    8258. 

  8258. 

  8259.     // 装 備位置チェック 
    8260. 

  8260. 

  8261.     for (i = 0; i < MAX_INVENTORY; i++)
    8262. 

  8262.     {
    8263. 

  8263. 

  8264.         it = sd->inventory_data[i];
    8265. 

  8265. 

  8266.         if (sd->status.inventory[i].nameid == 0)
    8267. 

  8267.             continue;
    8268. 

  8268.         if (sd->status.inventory[i].equip & ~pc_equippoint (sd, i))
    8269. 

  8269.         {
    8270. 

  8270.             sd->status.inventory[i].equip = 0;
    8271. 

  8271.             calc_flag = 1;
    8272. 

  8272.         }
    8273. 

  8273.         //装備制限チェック 
    8274. 

  8274.         if (sd->status.inventory[i].equip && map[sd->bl.m].flag.pvp
    8275. 

  8275.             && (it->flag.no_equip == 1 || it->flag.no_equip == 3))
    8276. 

  8276.         {                       //PvP制限 
    8277. 

  8277.             sd->status.inventory[i].equip = 0;
    8278. 

  8278.             calc_flag = 1;
    8279. 

  8279.         }
    8280. 

  8280.         else if (sd->status.inventory[i].equip && map[sd->bl.m].flag.gvg
    8281. 

  8281.                  && (it->flag.no_equip == 2 || it->flag.no_equip == 3))
    8282. 

  8282.         {                       //GvG制限 
    8283. 

  8283.             sd->status.inventory[i].equip = 0;
    8284. 

  8284.             calc_flag = 1;
    8285. 

  8285.         }
    8286. 

  8286.     }
    8287. 

  8287. 

  8288.     pc_setequipindex (sd);
    8289. 

  8289.     if (calc_flag)
    8290. 

  8290.         pc_calcstatus (sd, 2);
    8291. 

  8291. 

  8292.     return 0;
    8293. 

  8293. }
    8294. 

  8294. 

  8295. int pc_checkoverhp (struct map_session_data *sd)
    8296. 

  8296. {
    8297. 

  8297.     nullpo_retr (0, sd);
    8298. 

  8298. 

  8299.     if (sd->status.hp == sd->status.max_hp)
    8300. 

  8300.         return 1;
    8301. 

  8301.     if (sd->status.hp > sd->status.max_hp)
    8302. 

  8302.     {
    8303. 

  8303.         sd->status.hp = sd->status.max_hp;
    8304. 

  8304.         clif_updatestatus (sd, SP_HP);
    8305. 

  8305.         return 2;
    8306. 

  8306.     }
    8307. 

  8307. 

  8308.     return 0;
    8309. 

  8309. }
    8310. 

  8310. 

  8311. int pc_checkoversp (struct map_session_data *sd)
    8312. 

  8312. {
    8313. 

  8313.     nullpo_retr (0, sd);
    8314. 

  8314. 

  8315.     if (sd->status.sp == sd->status.max_sp)
    8316. 

  8316.         return 1;
    8317. 

  8317.     if (sd->status.sp > sd->status.max_sp)
    8318. 

  8318.     {
    8319. 

  8319.         sd->status.sp = sd->status.max_sp;
    8320. 

  8320.         clif_updatestatus (sd, SP_SP);
    8321. 

  8321.         return 2;
    8322. 

  8322.     }
    8323. 

  8323. 

  8324.     return 0;
    8325. 

  8325. }
    8326. 

  8326. 

  8327. /*==========================================
    8328. 

  8328.  * PVP順位計算用(foreachinarea) 
    8329. 

  8329.  *------------------------------------------
    8330. 

  8330.  */
    8331. 

  8331. int pc_calc_pvprank_sub (struct block_list *bl, va_list ap)
    8332. 

  8332. {
    8333. 

  8333.     struct map_session_data *sd1, *sd2 = NULL;
    8334. 

  8334. 

  8335.     nullpo_retr (0, bl);
    8336. 

  8336.     nullpo_retr (0, ap);
    8337. 

  8337.     nullpo_retr (0, sd1 = (struct map_session_data *) bl);
    8338. 

  8338.     nullpo_retr (0, sd2 = va_arg (ap, struct map_session_data *));
    8339. 

  8339. 

  8340.     if (sd1->pvp_point > sd2->pvp_point)
    8341. 

  8341.         sd2->pvp_rank++;
    8342. 

  8342.     return 0;
    8343. 

  8343. }
    8344. 

  8344. 

  8345. /*==========================================
    8346. 

  8346.  * PVP順位計算 
    8347. 

  8347.  *------------------------------------------
    8348. 

  8348.  */
    8349. 

  8349. int pc_calc_pvprank (struct map_session_data *sd)
    8350. 

  8350. {
    8351. 

  8351.     int  old;
    8352. 

  8352.     struct map_data *m;
    8353. 

  8353. 

  8354.     nullpo_retr (0, sd);
    8355. 

  8355.     nullpo_retr (0, m = &map[sd->bl.m]);
    8356. 

  8356. 

  8357.     old = sd->pvp_rank;
    8358. 

  8358. 

  8359.     if (!(m->flag.pvp))
    8360. 

  8360.         return 0;
    8361. 

  8361.     sd->pvp_rank = 1;
    8362. 

  8362.     map_foreachinarea (pc_calc_pvprank_sub, sd->bl.m, 0, 0, m->xs, m->ys,
    8363. 

  8363.                        BL_PC, sd);
    8364. 

  8364.     if (old != sd->pvp_rank || sd->pvp_lastusers != m->users)
    8365. 

  8365.         clif_pvpset (sd, sd->pvp_rank, sd->pvp_lastusers = m->users, 0);
    8366. 

  8366.     return sd->pvp_rank;
    8367. 

  8367. }
    8368. 

  8368. 

  8369. /*==========================================
    8370. 

  8370.  * PVP順位計算(timer) 
    8371. 

  8371.  *------------------------------------------
    8372. 

  8372.  */
    8373. 

  8373. int pc_calc_pvprank_timer (int tid __attribute__ ((unused)), unsigned int tick __attribute__ ((unused)), int id, int data)
    8374. 

  8374. {
    8375. 

  8375.     struct map_session_data *sd = NULL;
    8376. 

  8376.     if (battle_config.pk_mode)  // disable pvp ranking if pk_mode on [Valaris]
    8377. 

  8377.         return 0;
    8378. 

  8378. 

  8379.     sd = map_id2sd (id);
    8380. 

  8380.     if (sd == NULL)
    8381. 

  8381.         return 0;
    8382. 

  8382.     sd->pvp_timer = -1;
    8383. 

  8383.     if (pc_calc_pvprank (sd) > 0)
    8384. 

  8384.         sd->pvp_timer = add_timer (gettick () + PVP_CALCRANK_INTERVAL,
    8385. 

  8385.                                    pc_calc_pvprank_timer, id, data);
    8386. 

  8386.     return 0;
    8387. 

  8387. }
    8388. 

  8388. 

  8389. /*==========================================
    8390. 

  8390.  * sdは結婚しているか(既婚の場合は相方のchar_idを返す) 
    8391. 

  8391.  *------------------------------------------
    8392. 

  8392.  */
    8393. 

  8393. int pc_ismarried (struct map_session_data *sd)
    8394. 

  8394. {
    8395. 

  8395.     if (sd == NULL)
    8396. 

  8396.         return -1;
    8397. 

  8397.     if (sd->status.partner_id > 0)
    8398. 

  8398.         return sd->status.partner_id;
    8399. 

  8399.     else
    8400. 

  8400.         return 0;
    8401. 

  8401. }
    8402. 

  8402. 

  8403. /*==========================================
    8404. 

  8404.  * sdがdstsdと結婚(dstsd→sdの結婚処理も同時に行う) 
    8405. 

  8405.  *------------------------------------------
    8406. 

  8406.  */
    8407. 

  8407. int pc_marriage (struct map_session_data *sd, struct map_session_data *dstsd)
    8408. 

  8408. {
    8409. 

  8409.     if (sd == NULL || dstsd == NULL || sd->status.partner_id > 0
    8410. 

  8410.         || dstsd->status.partner_id > 0)
    8411. 

  8411.         return -1;
    8412. 

  8412.     sd->status.partner_id = dstsd->status.char_id;
    8413. 

  8413.     dstsd->status.partner_id = sd->status.char_id;
    8414. 

  8414.     return 0;
    8415. 

  8415. }
    8416. 

  8416. 

  8417. /*==========================================
    8418. 

  8418.  * sdが離婚(相手はsd->status.partner_idに依る)(相手も同時に離婚・結婚指輪自動剥奪) 
    8419. 

  8419.  *------------------------------------------
    8420. 

  8420.  */
    8421. 

  8421. int pc_divorce (struct map_session_data *sd)
    8422. 

  8422. {
    8423. 

  8423.     struct map_session_data *p_sd = NULL;
    8424. 

  8424.     if (sd == NULL || !pc_ismarried (sd))
    8425. 

  8425.         return -1;
    8426. 

  8426. 

  8427.     // If both are on map server we don't need to bother the char server
    8428. 

  8428.     if ((p_sd =
    8429. 

  8429.          map_nick2sd (map_charid2nick (sd->status.partner_id))) != NULL)
    8430. 

  8430.     {
    8431. 

  8431.         if (p_sd->status.partner_id != sd->status.char_id
    8432. 

  8432.             || sd->status.partner_id != p_sd->status.char_id)
    8433. 

  8433.         {
    8434. 

  8434.             printf ("pc_divorce: Illegal partner_id sd=%d p_sd=%d\n",
    8435. 

  8435.                     sd->status.partner_id, p_sd->status.partner_id);
    8436. 

  8436.             return -1;
    8437. 

  8437.         }
    8438. 

  8438.         p_sd->status.partner_id = 0;
    8439. 

  8439.         sd->status.partner_id = 0;
    8440. 

  8440. 

  8441.         if (sd->npc_flags.divorce)
    8442. 

  8442.         {
    8443. 

  8443.             sd->npc_flags.divorce = 0;
    8444. 

  8444.             map_scriptcont (sd, sd->npc_id);
    8445. 

  8445.         }
    8446. 

  8446.     }
    8447. 

  8447.     else
    8448. 

  8448.         chrif_send_divorce (sd->status.char_id);
    8449. 

  8449. 

  8450.     return 0;
    8451. 

  8451. }
    8452. 

  8452. 

  8453. /*==========================================
    8454. 

  8454.  * sdの相方のmap_session_dataを返す 
    8455. 

  8455.  *------------------------------------------
    8456. 

  8456.  */
    8457. 

  8457. struct map_session_data *pc_get_partner (struct map_session_data *sd)
    8458. 

  8458. {
    8459. 

  8459.     struct map_session_data *p_sd = NULL;
    8460. 

  8460.     char *nick;
    8461. 

  8461.     if (sd == NULL || !pc_ismarried (sd))
    8462. 

  8462.         return NULL;
    8463. 

  8463. 

  8464.     nick = map_charid2nick (sd->status.partner_id);
    8465. 

  8465. 

  8466.     if (nick == NULL)
    8467. 

  8467.         return NULL;
    8468. 

  8468. 

  8469.     if ((p_sd = map_nick2sd (nick)) == NULL)
    8470. 

  8470.         return NULL;
    8471. 

  8471. 

  8472.     return p_sd;
    8473. 

  8473. }
    8474. 

  8474. 

  8475. int pc_set_lang (struct map_session_data *sd, int lang)
    8476. 

  8476. {
    8477. 

  8477.     if (sd == NULL)
    8478. 

  8478.         return -1;
    8479. 

  8479. 

  8480.     sd->status.language = lang;
    8481. 

  8481.     return 0;
    8482. 

  8482. }
    8483. 

  8483. 

  8484. //
    8485. 

  8485. // 自然回復物 
    8486. 

  8486. //
    8487. 

  8487. /*==========================================
    8488. 

  8488.  * SP回復量計算 
    8489. 

  8489.  *------------------------------------------
    8490. 

  8490.  */
    8491. 

  8491. static int natural_heal_tick, natural_heal_prev_tick, natural_heal_diff_tick;
    8492. 

  8492. static int pc_spheal (struct map_session_data *sd)
    8493. 

  8493. {
    8494. 

  8494.     int  a;
    8495. 

  8495.     struct guild_castle *gc = NULL;
    8496. 

  8496. 

  8497.     nullpo_retr (0, sd);
    8498. 

  8498. 

  8499.     a = natural_heal_diff_tick;
    8500. 

  8500.     if (pc_issit (sd))
    8501. 

  8501.         a += a;
    8502. 

  8502.     if (sd->sc_data[SC_MAGNIFICAT].timer != -1) // マグニフィカート  
    8503. 

  8503.         a += a * sd->sc_data[SC_MAGNIFICAT].val1;
    8504. 

  8504. 

  8505.     gc = guild_mapname2gc (sd->mapname);    // Increased guild castle regen [Valaris]
    8506. 

  8506.     if (gc)
    8507. 

  8507.     {
    8508. 

  8508.         struct guild *g;
    8509. 

  8509.         g = guild_search (sd->status.guild_id);
    8510. 

  8510.         if (g && g->guild_id == gc->guild_id)
    8511. 

  8511.             a += a;
    8512. 

  8512.     }                           // end addition [Valaris]
    8513. 

  8513. 

  8514.     return a;
    8515. 

  8515. }
    8516. 

  8516. 

  8517. /*==========================================
    8518. 

  8518.  * HP回復量計算 
    8519. 

  8519.  *------------------------------------------
    8520. 

  8520.  */
    8521. 

  8521. static int pc_hpheal (struct map_session_data *sd)
    8522. 

  8522. {
    8523. 

  8523.     int  a;
    8524. 

  8524.     struct guild_castle *gc;
    8525. 

  8525. 

  8526.     nullpo_retr (0, sd);
    8527. 

  8527. 

  8528.     a = natural_heal_diff_tick;
    8529. 

  8529.     if (pc_issit (sd))
    8530. 

  8530.         a += a;
    8531. 

  8531.     if (sd->sc_data[SC_MAGNIFICAT].timer != -1) // Modified by RoVeRT
    8532. 

  8532.         a += a * sd->sc_data[SC_MAGNIFICAT].val1;
    8533. 

  8533. 

  8534.     gc = guild_mapname2gc (sd->mapname);    // Increased guild castle regen [Valaris]
    8535. 

  8535.     if (gc)
    8536. 

  8536.     {
    8537. 

  8537.         struct guild *g;
    8538. 

  8538.         g = guild_search (sd->status.guild_id);
    8539. 

  8539.         if (g && g->guild_id == gc->guild_id)
    8540. 

  8540.             a += a;
    8541. 

  8541.     }                           // end addition [Valaris]
    8542. 

  8542. 

  8543.     return a;
    8544. 

  8544. }
    8545. 

  8545. 

  8546. static int pc_natural_heal_hp (struct map_session_data *sd)
    8547. 

  8547. {
    8548. 

  8548.     int  bhp;
    8549. 

  8549.     int  inc_num, bonus, hp_flag;
    8550. 

  8550. 

  8551.     nullpo_retr (0, sd);
    8552. 

  8552. 

  8553.     if (sd->sc_data[SC_TRICKDEAD].timer != -1)  // Modified by RoVeRT
    8554. 

  8554.         return 0;
    8555. 

  8555. 

  8556.     if (pc_checkoverhp (sd))
    8557. 

  8557.     {
    8558. 

  8558.         sd->hp_sub = sd->inchealhptick = 0;
    8559. 

  8559.         return 0;
    8560. 

  8560.     }
    8561. 

  8561. 

  8562.     bhp = sd->status.hp;
    8563. 

  8563.     hp_flag = (pc_checkskill (sd, SM_MOVINGRECOVERY) > 0
    8564. 

  8564.                && sd->walktimer != -1);
    8565. 

  8565. 

  8566.     if (sd->walktimer == -1)
    8567. 

  8567.     {
    8568. 

  8568.         inc_num = pc_hpheal (sd);
    8569. 

  8569.         if (sd->sc_data[SC_TENSIONRELAX].timer != -1)
    8570. 

  8570.           {                       // テンションリラックス 
    8571. 

  8571.             sd->hp_sub += 2 * inc_num;
    8572. 

  8572.             sd->inchealhptick += 3 * natural_heal_diff_tick;
    8573. 

  8573.         }
    8574. 

  8574.         else
    8575. 

  8575.         {
    8576. 

  8576.             sd->hp_sub += inc_num;
    8577. 

  8577.             sd->inchealhptick += natural_heal_diff_tick;
    8578. 

  8578.         }
    8579. 

  8579.     }
    8580. 

  8580.     else if (hp_flag)
    8581. 

  8581.     {
    8582. 

  8582.         inc_num = pc_hpheal (sd);
    8583. 

  8583.         sd->hp_sub += inc_num;
    8584. 

  8584.         sd->inchealhptick = 0;
    8585. 

  8585.     }
    8586. 

  8586.     else
    8587. 

  8587.     {
    8588. 

  8588.         sd->hp_sub = sd->inchealhptick = 0;
    8589. 

  8589.         return 0;
    8590. 

  8590.     }
    8591. 

  8591. 

  8592.     if (sd->hp_sub >= battle_config.natural_healhp_interval)
    8593. 

  8593.     {
    8594. 

  8594.         bonus = sd->nhealhp;
    8595. 

  8595.         if (hp_flag)
    8596. 

  8596.         {
    8597. 

  8597.             bonus >>= 2;
    8598. 

  8598.             if (bonus <= 0)
    8599. 

  8599.                 bonus = 1;
    8600. 

  8600.         }
    8601. 

  8601.         while (sd->hp_sub >= battle_config.natural_healhp_interval)
    8602. 

  8602.         {
    8603. 

  8603.             sd->hp_sub -= battle_config.natural_healhp_interval;
    8604. 

  8604.             if (sd->status.hp + bonus <= sd->status.max_hp)
    8605. 

  8605.                 sd->status.hp += bonus;
    8606. 

  8606.             else
    8607. 

  8607.             {
    8608. 

  8608.                 sd->status.hp = sd->status.max_hp;
    8609. 

  8609.                 sd->hp_sub = sd->inchealhptick = 0;
    8610. 

  8610.             }
    8611. 

  8611.         }
    8612. 

  8612.     }
    8613. 

  8613.     if (bhp != sd->status.hp)
    8614. 

  8614.         clif_updatestatus (sd, SP_HP);
    8615. 

  8615. 

  8616.     if (sd->nshealhp > 0)
    8617. 

  8617.     {
    8618. 

  8618.         if (sd->inchealhptick >= battle_config.natural_heal_skill_interval
    8619. 

  8619.             && sd->status.hp < sd->status.max_hp)
    8620. 

  8620.         {
    8621. 

  8621.             bonus = sd->nshealhp;
    8622. 

  8622.             while (sd->inchealhptick >=
    8623. 

  8623.                    battle_config.natural_heal_skill_interval)
    8624. 

  8624.             {
    8625. 

  8625.                 sd->inchealhptick -=
    8626. 

  8626.                     battle_config.natural_heal_skill_interval;
    8627. 

  8627.                 if (sd->status.hp + bonus <= sd->status.max_hp)
    8628. 

  8628.                     sd->status.hp += bonus;
    8629. 

  8629.                 else
    8630. 

  8630.                 {
    8631. 

  8631.                     bonus = sd->status.max_hp - sd->status.hp;
    8632. 

  8632.                     sd->status.hp = sd->status.max_hp;
    8633. 

  8633.                     sd->hp_sub = sd->inchealhptick = 0;
    8634. 

  8634.                 }
    8635. 

  8635.                 clif_heal (sd->fd, SP_HP, bonus);
    8636. 

  8636.             }
    8637. 

  8637.         }
    8638. 

  8638.     }
    8639. 

  8639.     else
    8640. 

  8640.         sd->inchealhptick = 0;
    8641. 

  8641. 

  8642.     return 0;
    8643. 

  8643. 

  8644. /*
    8645. 

  8645.     if (sd->sc_data[SC_APPLEIDUN].timer != -1)
    8646. 

  8646.     {                           // Apple of Idun
    8647. 

  8647.         if (sd->inchealhptick >= 6000 && sd->status.hp < sd->status.max_hp)
    8648. 

  8648.         {
    8649. 

  8649.             bonus = skill * 20;
    8650. 

  8650.             while (sd->inchealhptick >= 6000)
    8651. 

  8651.             {
    8652. 

  8652.                 sd->inchealhptick -= 6000;
    8653. 

  8653.                 if (sd->status.hp + bonus <= sd->status.max_hp)
    8654. 

  8654.                     sd->status.hp += bonus;
    8655. 

  8655.                 else
    8656. 

  8656.                 {
    8657. 

  8657.                     bonus = sd->status.max_hp - sd->status.hp;
    8658. 

  8658.                     sd->status.hp = sd->status.max_hp;
    8659. 

  8659.                     sd->hp_sub = sd->inchealhptick = 0;
    8660. 

  8660.                 }
    8661. 

  8661.                 clif_heal (sd->fd, SP_HP, bonus);
    8662. 

  8662.             }
    8663. 

  8663.         }
    8664. 

  8664.     }
    8665. 

  8665.     else
    8666. 

  8666.         sd->inchealhptick = 0;
    8667. 

    8668. 

  8668.     return 0;
    8669. 

  8669. */
    8670. 

  8670. }
    8671. 

  8671. 

  8672. static int pc_natural_heal_sp (struct map_session_data *sd)
    8673. 

  8673. {
    8674. 

  8674.     int  bsp;
    8675. 

  8675.     int  inc_num, bonus;
    8676. 

  8676. 

  8677.     nullpo_retr (0, sd);
    8678. 

  8678. 

  8679.     if (sd->sc_data[SC_TRICKDEAD].timer != -1)  // Modified by RoVeRT
    8680. 

  8680.         return 0;
    8681. 

  8681. 

  8682.     if (pc_checkoversp (sd))
    8683. 

  8683.     {
    8684. 

  8684.         sd->sp_sub = sd->inchealsptick = 0;
    8685. 

  8685.         return 0;
    8686. 

  8686.     }
    8687. 

  8687. 

  8688.     bsp = sd->status.sp;
    8689. 

  8689. 

  8690.     inc_num = pc_spheal (sd);
    8691. 

  8691.     if (sd->sc_data[SC_EXPLOSIONSPIRITS].timer == -1)
    8692. 

  8692.         sd->sp_sub += inc_num;
    8693. 

  8693.     if (sd->walktimer == -1)
    8694. 

  8694.         sd->inchealsptick += natural_heal_diff_tick;
    8695. 

  8695.     else
    8696. 

  8696.         sd->inchealsptick = 0;
    8697. 

  8697. 

  8698.     if (sd->sp_sub >= battle_config.natural_healsp_interval)
    8699. 

  8699.     {
    8700. 

  8700.         bonus = sd->nhealsp;;
    8701. 

  8701.         while (sd->sp_sub >= battle_config.natural_healsp_interval)
    8702. 

  8702.         {
    8703. 

  8703.             sd->sp_sub -= battle_config.natural_healsp_interval;
    8704. 

  8704.             if (sd->status.sp + bonus <= sd->status.max_sp)
    8705. 

  8705.                 sd->status.sp += bonus;
    8706. 

  8706.             else
    8707. 

  8707.             {
    8708. 

  8708.                 sd->status.sp = sd->status.max_sp;
    8709. 

  8709.                 sd->sp_sub = sd->inchealsptick = 0;
    8710. 

  8710.             }
    8711. 

  8711.         }
    8712. 

  8712.     }
    8713. 

  8713. 

  8714.     if (bsp != sd->status.sp)
    8715. 

  8715.         clif_updatestatus (sd, SP_SP);
    8716. 

  8716. 

  8717.     if (sd->nshealsp > 0)
    8718. 

  8718.     {
    8719. 

  8719.         if (sd->inchealsptick >= battle_config.natural_heal_skill_interval
    8720. 

  8720.             && sd->status.sp < sd->status.max_sp)
    8721. 

  8721.         {
    8722. 

  8722.             struct pc_base_job s_class = pc_calc_base_job (sd->status.class);
    8723. 

  8723.             if (sd->doridori_counter && s_class.job == 23)
    8724. 

  8724.                 bonus = sd->nshealsp * 2;
    8725. 

  8725.             else
    8726. 

  8726.                 bonus = sd->nshealsp;
    8727. 

  8727.             sd->doridori_counter = 0;
    8728. 

  8728.             while (sd->inchealsptick >=
    8729. 

  8729.                    battle_config.natural_heal_skill_interval)
    8730. 

  8730.             {
    8731. 

  8731.                 sd->inchealsptick -=
    8732. 

  8732.                     battle_config.natural_heal_skill_interval;
    8733. 

  8733.                 if (sd->status.sp + bonus <= sd->status.max_sp)
    8734. 

  8734.                     sd->status.sp += bonus;
    8735. 

  8735.                 else
    8736. 

  8736.                 {
    8737. 

  8737.                     bonus = sd->status.max_sp - sd->status.sp;
    8738. 

  8738.                     sd->status.sp = sd->status.max_sp;
    8739. 

  8739.                     sd->sp_sub = sd->inchealsptick = 0;
    8740. 

  8740.                 }
    8741. 

  8741.                 clif_heal (sd->fd, SP_SP, bonus);
    8742. 

  8742.             }
    8743. 

  8743.         }
    8744. 

  8744.     }
    8745. 

  8745.     else
    8746. 

  8746.         sd->inchealsptick = 0;
    8747. 

  8747. 

  8748.     return 0;
    8749. 

  8749. }
    8750. 

  8750. 

  8751. static int pc_spirit_heal_hp (struct map_session_data *sd, int level __attribute__ ((unused)))
    8752. 

  8752. {
    8753. 

  8753.     nullpo_retr (0, sd);
    8754. 

  8754. 

  8755.     int  interval = battle_config.natural_heal_skill_interval;;
    8756. 

  8756.     struct status_change *sc_data = battle_get_sc_data (&sd->bl);
    8757. 

  8757.     nullpo_retr (0, sc_data);
    8758. 

  8758. 

  8759.     if (pc_checkoverhp (sd))
    8760. 

  8760.     {
    8761. 

  8761.         sd->inchealspirithptick = 0;
    8762. 

  8762.         return 0;
    8763. 

  8763.     }
    8764. 

  8764. 

  8765.     sd->inchealspirithptick += natural_heal_diff_tick;
    8766. 

  8766. 

  8767.     if (sd->max_weight && sd->weight * 100 / sd->max_weight >=
    8768. 

  8768.         battle_config.natural_heal_weight_rate
    8769. 

  8769.         && sc_data[SC_FLYING_BACKPACK].timer == -1)
    8770. 

  8770.         interval += interval;
    8771. 

  8771. 

  8772.     if (sd->inchealspirithptick >= interval)
    8773. 

  8773.     {
    8774. 

  8774.         int  bonus_hp;
    8775. 

  8775.         bonus_hp = sd->nsshealhp;
    8776. 

  8776.         while (sd->inchealspirithptick >= interval)
    8777. 

  8777.         {
    8778. 

  8778.             if (pc_issit (sd))
    8779. 

  8779.             {
    8780. 

  8780.                 sd->inchealspirithptick -= interval;
    8781. 

  8781.                 if (sd->status.hp < sd->status.max_hp)
    8782. 

  8782.                 {
    8783. 

  8783.                     if (sd->status.hp + bonus_hp <= sd->status.max_hp)
    8784. 

  8784.                         sd->status.hp += bonus_hp;
    8785. 

  8785.                     else
    8786. 

  8786.                     {
    8787. 

  8787.                         bonus_hp = sd->status.max_hp - sd->status.hp;
    8788. 

  8788.                         sd->status.hp = sd->status.max_hp;
    8789. 

  8789.                     }
    8790. 

  8790.                     clif_heal (sd->fd, SP_HP, bonus_hp);
    8791. 

  8791.                     sd->inchealspirithptick = 0;
    8792. 

  8792.                 }
    8793. 

  8793.             }
    8794. 

  8794.             else
    8795. 

  8795.             {
    8796. 

  8796.                 sd->inchealspirithptick -= natural_heal_diff_tick;
    8797. 

  8797.                 break;
    8798. 

  8798.             }
    8799. 

  8799.         }
    8800. 

  8800.     }
    8801. 

  8801. 

  8802.     return 0;
    8803. 

  8803. }
    8804. 

  8804. 

  8805. static int pc_spirit_heal_sp (struct map_session_data *sd, int level __attribute__ ((unused)))
    8806. 

  8806. {
    8807. 

  8807.     int  interval = battle_config.natural_heal_skill_interval;
    8808. 

  8808. 

  8809.     nullpo_retr (0, sd);
    8810. 

  8810. 

  8811.     if (pc_checkoversp (sd))
    8812. 

  8812.     {
    8813. 

  8813.         sd->inchealspiritsptick = 0;
    8814. 

  8814.         return 0;
    8815. 

  8815.     }
    8816. 

  8816. 

  8817.     sd->inchealspiritsptick += natural_heal_diff_tick;
    8818. 

  8818. 

  8819.     if (sd->max_weight && sd->weight * 100 / sd->max_weight >=
    8820. 

  8820.         battle_config.natural_heal_weight_rate)
    8821. 

  8821.         interval += interval;
    8822. 

  8822. 

  8823.     if (sd->inchealspiritsptick >= interval)
    8824. 

  8824.     {
    8825. 

  8825.         int  bonus_sp;
    8826. 

  8826.         bonus_sp = sd->nsshealsp;
    8827. 

  8827.         while (sd->inchealspiritsptick >= interval)
    8828. 

  8828.         {
    8829. 

  8829.             if (pc_issit (sd))
    8830. 

  8830.             {
    8831. 

  8831.                 sd->inchealspiritsptick -= interval;
    8832. 

  8832.                 if (sd->status.sp < sd->status.max_sp)
    8833. 

  8833.                 {
    8834. 

  8834.                     if (sd->status.sp + bonus_sp <= sd->status.max_sp)
    8835. 

  8835.                         sd->status.sp += bonus_sp;
    8836. 

  8836.                     else
    8837. 

  8837.                     {
    8838. 

  8838.                         bonus_sp = sd->status.max_sp - sd->status.sp;
    8839. 

  8839.                         sd->status.sp = sd->status.max_sp;
    8840. 

  8840.                     }
    8841. 

  8841.                     clif_heal (sd->fd, SP_SP, bonus_sp);
    8842. 

  8842.                     sd->inchealspiritsptick = 0;
    8843. 

  8843.                 }
    8844. 

  8844.             }
    8845. 

  8845.             else
    8846. 

  8846.             {
    8847. 

  8847.                 sd->inchealspiritsptick -= natural_heal_diff_tick;
    8848. 

  8848.                 break;
    8849. 

  8849.             }
    8850. 

  8850.         }
    8851. 

  8851.     }
    8852. 

  8852. 

  8853.     return 0;
    8854. 

  8854. }
    8855. 

  8855. 

  8856. /*==========================================
    8857. 

  8857.  * HP/SP 自然回復 各クライアント 
    8858. 

  8858.  *------------------------------------------
    8859. 

  8859.  */
    8860. 

  8860. static int pc_itemheal_effect (struct map_session_data *sd, int hp, int sp);
    8861. 

  8861. 

  8862. static int
    8863. 

  8863. pc_quickregenerate_effect (struct quick_regeneration *quick_regen,
    8864. 

  8864.                            int heal_speed)
    8865. 

  8865. {
    8866. 

  8866.     nullpo_retr (0, quick_regen);
    8867. 

  8867. 

  8868.     if (!(quick_regen->tickdelay--))
    8869. 

  8869.     {
    8870. 

  8870.         int  bonus =
    8871. 

  8871.             MIN (heal_speed * battle_config.itemheal_regeneration_factor,
    8872. 

  8872.                  quick_regen->amount);
    8873. 

  8873. 

  8874.         quick_regen->amount -= bonus;
    8875. 

  8875. 

  8876.         quick_regen->tickdelay = quick_regen->speed;
    8877. 

  8877. 

  8878.         return bonus;
    8879. 

  8879.     }
    8880. 

  8880. 

  8881.     return 0;
    8882. 

  8882. }
    8883. 

  8883. 

  8884. static int pc_natural_heal_sub (struct map_session_data *sd, va_list ap __attribute__ ((unused)))
    8885. 

  8885. {
    8886. 

  8886.     int  skill;
    8887. 

  8887. 

  8888.     nullpo_retr (0, sd);
    8889. 

  8889. 

  8890.     if (sd->heal_xp > 0)
    8891. 

  8891.     {
    8892. 

  8892.         if (sd->heal_xp < 64)
    8893. 

  8893.             --sd->heal_xp;      // [Fate] Slowly reduce XP that healers can get for healing this char
    8894. 

  8894.         else
    8895. 

  8895.             sd->heal_xp -= (sd->heal_xp >> 6);
    8896. 

  8896.     }
    8897. 

  8897. 

  8898.     // Hijack this callback:  Adjust spellpower bonus
    8899. 

  8899.     if (sd->spellpower_bonus_target < sd->spellpower_bonus_current)
    8900. 

  8900.     {
    8901. 

  8901.         sd->spellpower_bonus_current = sd->spellpower_bonus_target;
    8902. 

  8902.         pc_calcstatus (sd, 0);
    8903. 

  8903.     }
    8904. 

  8904.     else if (sd->spellpower_bonus_target > sd->spellpower_bonus_current)
    8905. 

  8905.     {
    8906. 

  8906.         sd->spellpower_bonus_current +=
    8907. 

  8907.             1 +
    8908. 

  8908.             ((sd->spellpower_bonus_target -
    8909. 

  8909.               sd->spellpower_bonus_current) >> 5);
    8910. 

  8910.         pc_calcstatus (sd, 0);
    8911. 

  8911.     }
    8912. 

  8912. 

  8913.     if (sd->sc_data[SC_HALT_REGENERATE].timer != -1)
    8914. 

  8914.         return 0;
    8915. 

  8915. 

  8916.     if (sd->quick_regeneration_hp.amount || sd->quick_regeneration_sp.amount)
    8917. 

  8917.     {
    8918. 

  8918.         int  hp_bonus = pc_quickregenerate_effect (&sd->quick_regeneration_hp,
    8919. 

  8919.                                                    (sd->sc_data[SC_POISON].timer == -1 || sd->sc_data[SC_SLOWPOISON].timer != -1) ? sd->nhealhp : 1);   
    8920. 

  8920. // [fate] slow down when poisoned
    8921. 

  8921.         int  sp_bonus = pc_quickregenerate_effect (&sd->quick_regeneration_sp,
    8922. 

  8922.                                                    sd->nhealsp);
    8923. 

  8923. 

  8924.         pc_itemheal_effect (sd, hp_bonus, sp_bonus);
    8925. 

  8925.     }
    8926. 

  8926.     skill_update_heal_animation (sd);   // if needed.
    8927. 

  8927. 

  8928. // -- moonsoul (if conditions below altered to disallow natural healing if under berserk status)
    8929. 

  8929.     if ((sd->sc_data[SC_FLYING_BACKPACK].timer != -1
    8930. 

  8930.          || battle_config.natural_heal_weight_rate > 100
    8931. 

  8931.          || (sd->max_weight && sd->weight * 100 / sd->max_weight <
    8932. 

  8932.          battle_config.natural_heal_weight_rate)) && !pc_isdead (sd)
    8933. 

  8933.         && !pc_ishiding (sd) && sd->sc_data[SC_POISON].timer == -1)
    8934. 

  8934.     {
    8935. 

  8935.         pc_natural_heal_hp (sd);
    8936. 

  8936.         if (sd->sc_data && sd->sc_data[SC_EXTREMITYFIST].timer == -1 && //阿修羅状態ではSPが回復しない 
    8937. 

  8937.             sd->sc_data[SC_DANCING].timer == -1 &&  //ダンス状態ではSPが回復しない 
    8938. 

  8938.             sd->sc_data[SC_BERSERK].timer == -1     //バーサーク状態ではSPが回復しない 
    8939. 

  8939.             )
    8940. 

  8940.             pc_natural_heal_sp (sd);
    8941. 

  8941.     }
    8942. 

  8942.     else
    8943. 

  8943.     {
    8944. 

  8944.         sd->hp_sub = sd->inchealhptick = 0;
    8945. 

  8945.         sd->sp_sub = sd->inchealsptick = 0;
    8946. 

  8946.     }
    8947. 

  8947.     if ((skill = pc_checkskill (sd, MO_SPIRITSRECOVERY)) > 0
    8948. 

  8948.         && !pc_ishiding (sd) && sd->sc_data[SC_POISON].timer == -1
    8949. 

  8949.         && sd->sc_data[SC_BERSERK].timer == -1)
    8950. 

  8950.     {
    8951. 

  8951.         pc_spirit_heal_hp (sd, skill);
    8952. 

  8952.         pc_spirit_heal_sp (sd, skill);
    8953. 

  8953.     }
    8954. 

  8954.     else
    8955. 

  8955.     {
    8956. 

  8956.         sd->inchealspirithptick = 0;
    8957. 

  8957.         sd->inchealspiritsptick = 0;
    8958. 

  8958.     }
    8959. 

  8959.     return 0;
    8960. 

  8960. }
    8961. 

  8961. 

  8962. /*==========================================
    8963. 

  8963.  * HP/SP自然回復 (interval timer関数) 
    8964. 

  8964.  *------------------------------------------
    8965. 

  8965.  */
    8966. 

  8966. int pc_natural_heal (int tid __attribute__ ((unused)), unsigned int tick, int id __attribute__ ((unused)), int data __attribute__ ((unused)))
    8967. 

  8967. {
    8968. 

  8968.     natural_heal_tick = tick;
    8969. 

  8969.     natural_heal_diff_tick =
    8970. 

  8970.         DIFF_TICK (natural_heal_tick, natural_heal_prev_tick);
    8971. 

  8971.     clif_foreachclient (pc_natural_heal_sub);
    8972. 

  8972. 

  8973.     natural_heal_prev_tick = tick;
    8974. 

  8974.     return 0;
    8975. 

  8975. }
    8976. 

  8976. 

  8977. /*==========================================
    8978. 

  8978.  * セーブポイントの保存 
    8979. 

  8979.  *------------------------------------------
    8980. 

  8980.  */
    8981. 

  8981. int pc_setsavepoint (struct map_session_data *sd, char *mapname, int x, int y)
    8982. 

  8982. {
    8983. 

  8983.     nullpo_retr (0, sd);
    8984. 

  8984.     nullpo_retr (0, mapname);
    8985. 

  8985. 

  8986.     safestrncpy (sd->status.save_point.map, mapname, 24);
    8987. 

  8987.     sd->status.save_point.x = x;
    8988. 

  8988.     sd->status.save_point.y = y;
    8989. 

  8989. 

  8990.     return 0;
    8991. 

  8991. }
    8992. 

  8992. 

  8993. /*==========================================
    8994. 

  8994.  * 自動セーブ 各クライアント 
    8995. 

  8995.  *------------------------------------------
    8996. 

  8996.  */
    8997. 

  8997. static int last_save_fd, save_flag;
    8998. 

  8998. static int pc_autosave_sub (struct map_session_data *sd, va_list ap __attribute__ ((unused)))
    8999. 

  8999. {
    9000. 

  9000.     nullpo_retr (0, sd);
    9001. 

  9001. 

  9002.     if (save_flag == 0 && sd->fd > last_save_fd)
    9003. 

  9003.     {
    9004. 

  9004.         struct guild_castle *gc = NULL;
    9005. 

  9005.         int  i;
    9006. 

  9006. 

  9007.         pc_makesavestatus (sd);
    9008. 

  9008.         chrif_save (sd);
    9009. 

  9009. 

  9010.         for (i = 0; i < MAX_GUILDCASTLE; i++)
    9011. 

  9011.         {
    9012. 

  9012.             gc = guild_castle_search (i);
    9013. 

  9013.             if (!gc)
    9014. 

  9014.                 continue;
    9015. 

  9015.             if (gc->visibleG0 == 1)
    9016. 

  9016.                 guild_castledatasave (gc->castle_id, 18, gc->Ghp0);
    9017. 

  9017.             if (gc->visibleG1 == 1)
    9018. 

  9018.                 guild_castledatasave (gc->castle_id, 19, gc->Ghp1);
    9019. 

  9019.             if (gc->visibleG2 == 1)
    9020. 

  9020.                 guild_castledatasave (gc->castle_id, 20, gc->Ghp2);
    9021. 

  9021.             if (gc->visibleG3 == 1)
    9022. 

  9022.                 guild_castledatasave (gc->castle_id, 21, gc->Ghp3);
    9023. 

  9023.             if (gc->visibleG4 == 1)
    9024. 

  9024.                 guild_castledatasave (gc->castle_id, 22, gc->Ghp4);
    9025. 

  9025.             if (gc->visibleG5 == 1)
    9026. 

  9026.                 guild_castledatasave (gc->castle_id, 23, gc->Ghp5);
    9027. 

  9027.             if (gc->visibleG6 == 1)
    9028. 

  9028.                 guild_castledatasave (gc->castle_id, 24, gc->Ghp6);
    9029. 

  9029.             if (gc->visibleG7 == 1)
    9030. 

  9030.                 guild_castledatasave (gc->castle_id, 25, gc->Ghp7);
    9031. 

  9031.         }
    9032. 

  9032. 

  9033.         save_flag = 1;
    9034. 

  9034.         last_save_fd = sd->fd;
    9035. 

  9035.     }
    9036. 

  9036. 

  9037.     return 0;
    9038. 

  9038. }
    9039. 

  9039. 

  9040. /*==========================================
    9041. 

  9041.  * 自動セーブ (timer関数) 
    9042. 

  9042.  *------------------------------------------
    9043. 

  9043.  */
    9044. 

  9044. int pc_autosave (int tid __attribute__ ((unused)), unsigned int tick __attribute__ ((unused)), int id __attribute__ ((unused)), int data __attribute__ ((unused)))
    9045. 

  9045. {
    9046. 

  9046.     int  interval;
    9047. 

  9047. 

  9048.     save_flag = 0;
    9049. 

  9049.     clif_foreachclient (pc_autosave_sub);
    9050. 

  9050.     if (save_flag == 0)
    9051. 

  9051.         last_save_fd = 0;
    9052. 

  9052. 

  9053.     int tmp = clif_countusers () + 1;
    9054. 

  9054.     if (tmp)
    9055. 

  9055.         interval = autosave_interval / tmp;
    9056. 

  9056.     else
    9057. 

  9057.         interval = 1;
    9058. 

  9058. 

  9059.     if (interval <= 0)
    9060. 

  9060.         interval = 1;
    9061. 

  9061.     add_timer (gettick () + interval, pc_autosave, 0, 0);
    9062. 

  9062. 

  9063.     return 0;
    9064. 

  9064. }
    9065. 

  9065. 

  9066. int pc_read_gm_account (int fd)
    9067. 

  9067. {
    9068. 

  9068.     int  i = 0;
    9069. 

  9069.     free (gm_account);
    9070. 

  9070.     GM_num = 0;
    9071. 

  9071. 

  9072.     gm_account =
    9073. 

  9073.         calloc (sizeof (struct gm_account) * ((RFIFOW (fd, 2) - 4) / 5), 1);
    9074. 

  9074.     if (!gm_account)
    9075. 

  9075.     {
    9076. 

  9076.         printf("out of memory pc_read_gm_account\n");
    9077. 

  9077.         exit(1);
    9078. 

  9078.     }
    9079. 

  9079.     for (i = 4; i < RFIFOW (fd, 2); i = i + 5)
    9080. 

  9080.     {
    9081. 

  9081.         gm_account[GM_num].account_id = RFIFOL (fd, i);
    9082. 

  9082.         gm_account[GM_num].level = (int) RFIFOB (fd, i + 4);
    9083. 

  9083.         //printf("GM account: %d -> level %d\n", gm_account[GM_num].account_id, gm_account[GM_num].level);
    9084. 

  9084.         GM_num++;
    9085. 

  9085.     }
    9086. 

  9086.     return GM_num;
    9087. 

  9087. }
    9088. 

  9088. 

  9089. /*==========================================
    9090. 

  9090.  * timer to do the day
    9091. 

  9091.  *------------------------------------------
    9092. 

  9092.  */
    9093. 

  9093. int map_day_timer (int tid __attribute__ ((unused)), unsigned int tick __attribute__ ((unused)), int id __attribute__ ((unused)), int data __attribute__ ((unused)))
    9094. 

  9094. {                               // by [yor]
    9095. 

  9095.     struct map_session_data *pl_sd = NULL;
    9096. 

  9096.     char tmpstr[1024];
    9097. 

  9097. 

  9098.     if (battle_config.day_duration > 0)
    9099. 

  9099.     {                           // if we want a day
    9100. 

  9100.         if (night_flag != 0)
    9101. 

  9101.         {
    9102. 

  9102.             int  i;
    9103. 

  9103.             strcpy (tmpstr, msg_txt (502)); // The day has arrived!
    9104. 

  9104.             night_flag = 0;     // 0=day, 1=night [Yor]
    9105. 

  9105.             for (i = 0; i < fd_max; i++)
    9106. 

  9106.             {
    9107. 

  9107.                 if (session[i] && (pl_sd = session[i]->session_data)
    9108. 

  9108.                     && pl_sd->state.auth)
    9109. 

  9109.                 {
    9110. 

  9110.                     pl_sd->opt2 &= ~STATE_BLIND;
    9111. 

  9111.                     clif_changeoption (&pl_sd->bl);
    9112. 

  9112.                     clif_wis_message (pl_sd->fd, wisp_server_name, tmpstr,
    9113. 

  9113.                                       strlen (tmpstr) + 1);
    9114. 

  9114.                 }
    9115. 

  9115.             }
    9116. 

  9116.         }
    9117. 

  9117.     }
    9118. 

  9118. 

  9119.     return 0;
    9120. 

  9120. }
    9121. 

  9121. 

  9122. /*==========================================
    9123. 

  9123.  * timer to do the night
    9124. 

  9124.  *------------------------------------------
    9125. 

  9125.  */
    9126. 

  9126. int map_night_timer (int tid __attribute__ ((unused)), unsigned int tick __attribute__ ((unused)), int id __attribute__ ((unused)), int data __attribute__ ((unused)))
    9127. 

  9127. {                               // by [yor]
    9128. 

  9128.     struct map_session_data *pl_sd = NULL;
    9129. 

  9129.     char tmpstr[1024];
    9130. 

  9130. 

  9131.     if (battle_config.night_duration > 0)
    9132. 

  9132.     {                           // if we want a night
    9133. 

  9133.         if (night_flag == 0)
    9134. 

  9134.         {
    9135. 

  9135.             int  i;
    9136. 

  9136.             strcpy (tmpstr, msg_txt (503)); // The night has fallen...
    9137. 

  9137.             night_flag = 1;     // 0=day, 1=night [Yor]
    9138. 

  9138.             for (i = 0; i < fd_max; i++)
    9139. 

  9139.             {
    9140. 

  9140.                 if (session[i] && (pl_sd = session[i]->session_data)
    9141. 

  9141.                     && pl_sd->state.auth)
    9142. 

  9142.                 {
    9143. 

  9143.                     pl_sd->opt2 |= STATE_BLIND;
    9144. 

  9144.                     clif_changeoption (&pl_sd->bl);
    9145. 

  9145.                     clif_wis_message (pl_sd->fd, wisp_server_name, tmpstr,
    9146. 

  9146.                                       strlen (tmpstr) + 1);
    9147. 

  9147.                 }
    9148. 

  9148.             }
    9149. 

  9149.         }
    9150. 

  9150.     }
    9151. 

  9151. 

  9152.     return 0;
    9153. 

  9153. }
    9154. 

  9154. 

  9155. void pc_setstand (struct map_session_data *sd)
    9156. 

  9156. {
    9157. 

  9157.     nullpo_retv (sd);
    9158. 

  9158. 

  9159.     if (sd->sc_data && sd->sc_data[SC_TENSIONRELAX].timer != -1)
    9160. 

  9160.         skill_status_change_end (&sd->bl, SC_TENSIONRELAX, -1);
    9161. 

  9161. 

  9162.     sd->state.dead_sit = 0;
    9163. 

  9163. }
    9164. 

  9164. 

  9165. //
    9166. 

  9166. // 初期化物 
    9167. 

  9167. //
    9168. 

  9168. /*==========================================
    9169. 

  9169.  * 設定ファイル読み込む 
    9170. 

  9170.  * exp.txt 必要経験値 
    9171. 

  9171.  * job_db1.txt 重量,hp,sp,攻撃速度 
    9172. 

  9172.  * job_db2.txt job能力値ボーナス 
    9173. 

  9173.  * skill_tree.txt 各職毎のスキルツリー 
    9174. 

  9174.  * attr_fix.txt 属性修正テーブル 
    9175. 

  9175.  * size_fix.txt サイズ補正テーブル
    9176. 

  9176.  * refine_db.txt 精錬データテーブル 
    9177. 

  9177.  *------------------------------------------
    9178. 

  9178.  */
    9179. 

  9179. int pc_readdb (void)
    9180. 

  9180. {
    9181. 

  9181.     int  i, j, k;
    9182. 

  9182.     FILE *fp;
    9183. 

  9183.     char line[2024], *p;
    9184. 

  9184. 

  9185.     // 必要経験値読み込み 
    9186. 

  9186. 

  9187.     fp = fopen_ ("db/exp.txt", "r");
    9188. 

  9188.     if (fp == NULL)
    9189. 

  9189.     {
    9190. 

  9190.         printf ("can't read db/exp.txt\n");
    9191. 

  9191.         return 1;
    9192. 

  9192.     }
    9193. 

  9193.     i = 0;
    9194. 

  9194.     while (fgets (line, sizeof (line) - 1, fp))
    9195. 

  9195.     {
    9196. 

  9196.         int  bn, b1, b2, b3, b4, b5, b6, jn, j1, j2, j3, j4, j5, j6;
    9197. 

  9197.         if (line[0] == '/' && line[1] == '/')
    9198. 

  9198.             continue;
    9199. 

  9199.         if (sscanf
    9200. 

  9200.             (line, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", &bn, &b1, &b2,
    9201. 

  9201.              &b3, &b4, &b5, &b6, &jn, &j1, &j2, &j3, &j4, &j5, &j6) != 14)
    9202. 

  9202.             continue;
    9203. 

  9203.         exp_table[0][i] = bn;
    9204. 

  9204.         exp_table[1][i] = b1;
    9205. 

  9205.         exp_table[2][i] = b2;
    9206. 

  9206.         exp_table[3][i] = b3;
    9207. 

  9207.         exp_table[4][i] = b4;
    9208. 

  9208.         exp_table[5][i] = b5;
    9209. 

  9209.         exp_table[6][i] = b6;
    9210. 

  9210.         exp_table[7][i] = jn;
    9211. 

  9211.         exp_table[8][i] = j1;
    9212. 

  9212.         exp_table[9][i] = j2;
    9213. 

  9213.         exp_table[10][i] = j3;
    9214. 

  9214.         exp_table[11][i] = j4;
    9215. 

  9215.         exp_table[12][i] = j5;
    9216. 

  9216.         exp_table[13][i] = j6;
    9217. 

  9217.         i++;
    9218. 

  9218.         if (i >= battle_config.maximum_level)
    9219. 

  9219.             break;
    9220. 

  9220.     }
    9221. 

  9221.     fclose_ (fp);
    9222. 

  9222.     printf ("read db/exp.txt done\n");
    9223. 

  9223. 

  9224.     // JOB補正数値１ 
    9225. 

  9225.     fp = fopen_ ("db/job_db1.txt", "r");
    9226. 

  9226.     if (fp == NULL)
    9227. 

  9227.     {
    9228. 

  9228.         printf ("can't read db/job_db1.txt\n");
    9229. 

  9229.         return 1;
    9230. 

  9230.     }
    9231. 

  9231.     i = 0;
    9232. 

  9232.     while (fgets (line, sizeof (line) - 1, fp))
    9233. 

  9233.     {
    9234. 

  9234.         char *split[50];
    9235. 

  9235.         if (line[0] == '/' && line[1] == '/')
    9236. 

  9236.             continue;
    9237. 

  9237.         for (j = 0, p = line; j < 21 && p; j++)
    9238. 

  9238.         {
    9239. 

  9239.             split[j] = p;
    9240. 

  9240.             p = strchr (p, ',');
    9241. 

  9241.             if (p)
    9242. 

  9242.                 *p++ = 0;
    9243. 

  9243.         }
    9244. 

  9244.         if (j < 21)
    9245. 

  9245.             continue;
    9246. 

  9246.         max_weight_base[i] = atoi (split[0]);
    9247. 

  9247.         hp_coefficient[i] = atoi (split[1]);
    9248. 

  9248.         hp_coefficient2[i] = atoi (split[2]);
    9249. 

  9249.         sp_coefficient[i] = atoi (split[3]);
    9250. 

  9250.         for (j = 0; j < 17; j++)
    9251. 

  9251.             aspd_base[i][j] = atoi (split[j + 4]);
    9252. 

  9252.         i++;
    9253. 

  9253. // -- moonsoul (below two lines added to accommodate high numbered new class ids)
    9254. 

  9254.         if (i == 24)
    9255. 

  9255.             i = 4001;
    9256. 

  9256.         if (i == MAX_PC_CLASS)
    9257. 

  9257.             break;
    9258. 

  9258.     }
    9259. 

  9259.     fclose_ (fp);
    9260. 

  9260.     printf ("read db/job_db1.txt done\n");
    9261. 

  9261. 

  9262.     // JOBボーナス 
    9263. 

  9263.     fp = fopen_ ("db/job_db2.txt", "r");
    9264. 

  9264.     if (fp == NULL)
    9265. 

  9265.     {
    9266. 

  9266.         printf ("can't read db/job_db2.txt\n");
    9267. 

  9267.         return 1;
    9268. 

  9268.     }
    9269. 

  9269.     i = 0;
    9270. 

  9270.     while (fgets (line, sizeof (line) - 1, fp))
    9271. 

  9271.     {
    9272. 

  9272.         if (line[0] == '/' && line[1] == '/')
    9273. 

  9273.             continue;
    9274. 

  9274.         for (j = 0, p = line; j < MAX_LEVEL && p; j++)
    9275. 

  9275.         {
    9276. 

  9276.             if (sscanf (p, "%d", &k) == 0)
    9277. 

  9277.                 break;
    9278. 

  9278.             job_bonus[0][i][j] = k;
    9279. 

  9279.             job_bonus[2][i][j] = k; //養子職のボーナスは分からないので仮 
    9280. 

  9280.             p = strchr (p, ',');
    9281. 

  9281.             if (p)
    9282. 

  9282.                 p++;
    9283. 

  9283.         }
    9284. 

  9284.         i++;
    9285. 

  9285. // -- moonsoul (below two lines added to accommodate high numbered new class ids)
    9286. 

  9286.         if (i == 24)
    9287. 

  9287.             i = 4001;
    9288. 

  9288.         if (i == MAX_PC_CLASS)
    9289. 

  9289.             break;
    9290. 

  9290.     }
    9291. 

  9291.     fclose_ (fp);
    9292. 

  9292.     printf ("read db/job_db2.txt done\n");
    9293. 

  9293. 

  9294.     // JOBボーナス2 転生職用 
    9295. 

  9295.     fp = fopen_ ("db/job_db2-2.txt", "r");
    9296. 

  9296.     if (fp == NULL)
    9297. 

  9297.     {
    9298. 

  9298.         printf ("can't read db/job_db2-2.txt\n");
    9299. 

  9299.         return 1;
    9300. 

  9300.     }
    9301. 

  9301.     i = 0;
    9302. 

  9302.     while (fgets (line, sizeof (line) - 1, fp))
    9303. 

  9303.     {
    9304. 

  9304.         if (line[0] == '/' && line[1] == '/')
    9305. 

  9305.             continue;
    9306. 

  9306.         for (j = 0, p = line; j < MAX_LEVEL && p; j++)
    9307. 

  9307.         {
    9308. 

  9308.             if (sscanf (p, "%d", &k) == 0)
    9309. 

  9309.                 break;
    9310. 

  9310.             job_bonus[1][i][j] = k;
    9311. 

  9311.             p = strchr (p, ',');
    9312. 

  9312.             if (p)
    9313. 

  9313.                 p++;
    9314. 

  9314.         }
    9315. 

  9315.         i++;
    9316. 

  9316.         if (i == MAX_PC_CLASS)
    9317. 

  9317.             break;
    9318. 

  9318.     }
    9319. 

  9319.     fclose_ (fp);
    9320. 

  9320.     printf ("read db/job_db2-2.txt done\n");
    9321. 

  9321. 

  9322.      // スキルツリー 
    9323. 

  9323.     memset (skill_tree, 0, sizeof (skill_tree));
    9324. 

  9324.     fp = fopen_ ("db/skill_tree.txt", "r");
    9325. 

  9325.     if (fp == NULL)
    9326. 

  9326.     {
    9327. 

  9327.         printf ("can't read db/skill_tree.txt\n");
    9328. 

  9328.         return 1;
    9329. 

  9329.     }
    9330. 

  9330.     while (fgets (line, sizeof (line) - 1, fp))
    9331. 

  9331.     {
    9332. 

  9332.         char *split[50];
    9333. 

  9333.         if (line[0] == '/' && line[1] == '/')
    9334. 

  9334.             continue;
    9335. 

  9335.         for (j = 0, p = line; j < 13 && p; j++)
    9336. 

  9336.         {
    9337. 

  9337.             split[j] = p;
    9338. 

  9338.             p = strchr (p, ',');
    9339. 

  9339.             if (p)
    9340. 

  9340.                 *p++ = 0;
    9341. 

  9341.         }
    9342. 

  9342.         if (j < 13)
    9343. 

  9343.             continue;
    9344. 

  9344.         i = atoi (split[0]);
    9345. 

  9345.         for (j = 0; skill_tree[0][i][j].id; j++);
    9346. 

  9346.         skill_tree[0][i][j].id = atoi (split[1]);
    9347. 

  9347.         skill_tree[0][i][j].max = atoi (split[2]);
    9348. 

  9348.         skill_tree[2][i][j].id = atoi (split[1]);   //養子職は良く分からないので暫定 
    9349. 

  9349.         skill_tree[2][i][j].max = atoi (split[2]);  //養子職は良く分からないので暫定 
    9350. 

  9350.         for (k = 0; k < 5; k++)
    9351. 

  9351.         {
    9352. 

  9352.             skill_tree[0][i][j].need[k].id = atoi (split[k * 2 + 3]);
    9353. 

  9353.             skill_tree[0][i][j].need[k].lv = atoi (split[k * 2 + 4]);
    9354. 

  9354.             skill_tree[2][i][j].need[k].id = atoi (split[k * 2 + 3]);   //養子職は良く分からないので暫定 
    9355. 

  9355.             skill_tree[2][i][j].need[k].lv = atoi (split[k * 2 + 4]);   //養子職は良く分からないので暫定 
    9356. 

  9356.         }
    9357. 

  9357.     }
    9358. 

  9358.     fclose_ (fp);
    9359. 

  9359.     printf ("read db/skill_tree.txt done\n");
    9360. 

  9360. 

  9361.     // 属性修正テーブル 
    9362. 

  9362.     for (i = 0; i < 4; i++)
    9363. 

  9363.         for (j = 0; j < 10; j++)
    9364. 

  9364.             for (k = 0; k < 10; k++)
    9365. 

  9365.                 attr_fix_table[i][j][k] = 100;
    9366. 

  9366.     fp = fopen_ ("db/attr_fix.txt", "r");
    9367. 

  9367.     if (fp == NULL)
    9368. 

  9368.     {
    9369. 

  9369.         printf ("can't read db/attr_fix.txt\n");
    9370. 

  9370.         return 1;
    9371. 

  9371.     }
    9372. 

  9372.     while (fgets (line, sizeof (line) - 1, fp))
    9373. 

  9373.     {
    9374. 

  9374.         char *split[10];
    9375. 

  9375.         int  lv, n;
    9376. 

  9376.         if (line[0] == '/' && line[1] == '/')
    9377. 

  9377.             continue;
    9378. 

  9378.         for (j = 0, p = line; j < 3 && p; j++)
    9379. 

  9379.         {
    9380. 

  9380.             split[j] = p;
    9381. 

  9381.             p = strchr (p, ',');
    9382. 

  9382.             if (p)
    9383. 

  9383.                 *p++ = 0;
    9384. 

  9384.         }
    9385. 

  9385.         lv = atoi (split[0]);
    9386. 

  9386.         if (lv < 1 || lv >= 4 + 1)
    9387. 

  9387.             continue;
    9388. 

  9388. 

  9389.         n = atoi (split[1]);
    9390. 

  9390.         if (n > 10)
    9391. 

  9391.             continue;
    9392. 

  9392. 

  9393. //      printf("%d %d\n",lv,n);
    9394. 

  9394. 

  9395.         for (i = 0; i < n;)
    9396. 

  9396.         {
    9397. 

  9397.             if (!fgets (line, sizeof (line) - 1, fp))
    9398. 

  9398.                 break;
    9399. 

  9399.             if (line[0] == '/' && line[1] == '/')
    9400. 

  9400.                 continue;
    9401. 

  9401. 

  9402.             for (j = 0, p = line; j < n && p; j++)
    9403. 

  9403.             {
    9404. 

  9404.                 while (*p == 32 && *p > 0)
    9405. 

  9405.                     p++;
    9406. 

  9406.                 attr_fix_table[lv - 1][i][j] = atoi (p);
    9407. 

  9407.                 if (battle_config.attr_recover == 0
    9408. 

  9408.                     && attr_fix_table[lv - 1][i][j] < 0)
    9409. 

  9409.                     attr_fix_table[lv - 1][i][j] = 0;
    9410. 

  9410.                 p = strchr (p, ',');
    9411. 

  9411.                 if (p)
    9412. 

  9412.                     *p++ = 0;
    9413. 

  9413.             }
    9414. 

  9414. 

  9415.             i++;
    9416. 

  9416.         }
    9417. 

  9417.     }
    9418. 

  9418.     fclose_ (fp);
    9419. 

  9419.     printf ("read db/attr_fix.txt done\n");
    9420. 

  9420. 

  9421.     // サイズ補正テーブル 
    9422. 

  9422.     for (i = 0; i < 3; i++)
    9423. 

  9423.         for (j = 0; j < 20; j++)
    9424. 

  9424.             atkmods[i][j] = 100;
    9425. 

  9425.     fp = fopen_ ("db/size_fix.txt", "r");
    9426. 

  9426.     if (fp == NULL)
    9427. 

  9427.     {
    9428. 

  9428.         printf ("can't read db/size_fix.txt\n");
    9429. 

  9429.         return 1;
    9430. 

  9430.     }
    9431. 

  9431.     i = 0;
    9432. 

  9432.     while (fgets (line, sizeof (line) - 1, fp))
    9433. 

  9433.     {
    9434. 

  9434.         char *split[20];
    9435. 

  9435.         if (line[0] == '/' && line[1] == '/')
    9436. 

  9436.             continue;
    9437. 

  9437.         if (atoi (line) <= 0)
    9438. 

  9438.             continue;
    9439. 

  9439.         memset (split, 0, sizeof (split));
    9440. 

  9440.         for (j = 0, p = line; j < 20 && p; j++)
    9441. 

  9441.         {
    9442. 

  9442.             split[j] = p;
    9443. 

  9443.             p = strchr (p, ',');
    9444. 

  9444.             if (p)
    9445. 

  9445.                 *p++ = 0;
    9446. 

  9446.         }
    9447. 

  9447.         for (j = 0; j < 20 && split[j]; j++)
    9448. 

  9448.             atkmods[i][j] = atoi (split[j]);
    9449. 

  9449.         i++;
    9450. 

  9450.     }
    9451. 

  9451.     fclose_ (fp);
    9452. 

  9452.     printf ("read db/size_fix.txt done\n");
    9453. 

  9453. 

  9454.     // 精錬データテーブル 
    9455. 

  9455.     for (i = 0; i < 5; i++)
    9456. 

  9456.     {
    9457. 

  9457.         for (j = 0; j < 10; j++)
    9458. 

  9458.             percentrefinery[i][j] = 100;
    9459. 

  9459.         refinebonus[i][0] = 0;
    9460. 

  9460.         refinebonus[i][1] = 0;
    9461. 

  9461.         refinebonus[i][2] = 10;
    9462. 

  9462.     }
    9463. 

  9463.     fp = fopen_ ("db/refine_db.txt", "r");
    9464. 

  9464.     if (fp == NULL)
    9465. 

  9465.     {
    9466. 

  9466.         printf ("can't read db/refine_db.txt\n");
    9467. 

  9467.         return 1;
    9468. 

  9468.     }
    9469. 

  9469.     i = 0;
    9470. 

  9470.     while (fgets (line, sizeof (line) - 1, fp))
    9471. 

  9471.     {
    9472. 

  9472.         char *split[16];
    9473. 

  9473.         if (line[0] == '/' && line[1] == '/')
    9474. 

  9474.             continue;
    9475. 

  9475.         if (atoi (line) <= 0)
    9476. 

  9476.             continue;
    9477. 

  9477.         memset (split, 0, sizeof (split));
    9478. 

  9478.         for (j = 0, p = line; j < 16 && p; j++)
    9479. 

  9479.         {
    9480. 

  9480.             split[j] = p;
    9481. 

  9481.             p = strchr (p, ',');
    9482. 

  9482.             if (p)
    9483. 

  9483.                 *p++ = 0;
    9484. 

  9484.         }
    9485. 

  9485.         refinebonus[i][0] = atoi (split[0]);    // 精錬ボーナス 
    9486. 

  9486.         refinebonus[i][1] = atoi (split[1]);    // 過剰精錬ボーナス 
    9487. 

  9487.         refinebonus[i][2] = atoi (split[2]);    // 安全精錬限界 
    9488. 

  9488.         for (j = 0; j < 10 && split[j]; j++)
    9489. 

  9489.             percentrefinery[i][j] = atoi (split[j + 3]);
    9490. 

  9490.         i++;
    9491. 

  9491.     }
    9492. 

  9492.     fclose_ (fp);               //Lupus. close this file!!!
    9493. 

  9493.     printf ("read db/refine_db.txt done\n");
    9494. 

  9494. 

  9495.     return 0;
    9496. 

  9496. }
    9497. 

  9497. 

  9498. static int pc_calc_sigma (void)
    9499. 

  9499. {
    9500. 

  9500.     int  i, j, k;
    9501. 

  9501. 

  9502.     for (i = 0; i < MAX_PC_CLASS; i++)
    9503. 

  9503.     {
    9504. 

  9504.         memset (hp_sigma_val[i], 0, sizeof (hp_sigma_val[i]));
    9505. 

  9505.         for (k = 0, j = 2; j <= MAX_LEVEL; j++)
    9506. 

  9506.         {
    9507. 

  9507.             k += hp_coefficient[i] * j + 50;
    9508. 

  9508.             k -= k % 100;
    9509. 

  9509.             hp_sigma_val[i][j - 1] = k;
    9510. 

  9510.         }
    9511. 

  9511.     }
    9512. 

  9512.     return 0;
    9513. 

  9513. }
    9514. 

  9514. 

  9515. static void pc_statpointdb (void)
    9516. 

  9516. {
    9517. 

  9517.     char *buf_stat;
    9518. 

  9518.     int  i = 0, j = 0, k = 0, l = 0, end = 0;
    9519. 

  9519. 

  9520.     FILE *stp;
    9521. 

  9521. 

  9522.     stp = fopen_ ("db/statpoint.txt", "r");
    9523. 

  9523. 

  9524.     if (stp == NULL)
    9525. 

  9525.     {
    9526. 

  9526.         printf ("can't read db/statpoint.txt\n");
    9527. 

  9527.         return;
    9528. 

  9528.     }
    9529. 

  9529. 

  9530.     fseek (stp, 0, SEEK_END);
    9531. 

  9531.     end = ftell (stp);
    9532. 

  9532.     rewind (stp);
    9533. 

  9533. 

  9534.     buf_stat = (char *) malloc (end + 1);
    9535. 

  9535.     l = fread (buf_stat, 1, end, stp);
    9536. 

  9536.     fclose_ (stp);
    9537. 

  9537.     printf ("read db/statpoint.txt done (size=%d)\n", l);
    9538. 

  9538. 

  9539.     for (i = 0; i < 255; i++)
    9540. 

  9540.     {
    9541. 

  9541.         j = 0;
    9542. 

  9542.         while (*(buf_stat + k) != '\n')
    9543. 

  9543.         {
    9544. 

  9544.             statp[i][j] = *(buf_stat + k);
    9545. 

  9545.             j++;
    9546. 

  9546.             k++;
    9547. 

  9547.         }
    9548. 

  9548.         statp[i][j + 1] = '\0';
    9549. 

  9549.         k++;
    9550. 

  9550.     }
    9551. 

  9551. 

  9552.     free (buf_stat);
    9553. 

  9553. }
    9554. 

  9554. 

  9555. /*==========================================
    9556. 

  9556.  * pc関 係初期化 
    9557. 

  9557.  *------------------------------------------
    9558. 

  9558.  */
    9559. 

  9559. int do_init_pc (void)
    9560. 

  9560. {
    9561. 

  9561.     pc_readdb ();
    9562. 

  9562.     pc_statpointdb ();
    9563. 

  9563.     pc_calc_sigma ();
    9564. 

  9564. 

  9565. //  gm_account_db = numdb_init();
    9566. 

  9566. 

  9567.     add_timer_func_list (pc_walk, "pc_walk");
    9568. 

  9568.     add_timer_func_list (pc_attack_timer, "pc_attack_timer");
    9569. 

  9569.     add_timer_func_list (pc_natural_heal, "pc_natural_heal");
    9570. 

  9570.     add_timer_func_list (pc_invincible_timer, "pc_invincible_timer");
    9571. 

  9571.     add_timer_func_list (pc_eventtimer, "pc_eventtimer");
    9572. 

  9572.     add_timer_func_list (pc_calc_pvprank_timer, "pc_calc_pvprank_timer");
    9573. 

  9573.     add_timer_func_list (pc_autosave, "pc_autosave");
    9574. 

  9574.     add_timer_func_list (pc_spiritball_timer, "pc_spiritball_timer");
    9575. 

  9575.     add_timer_interval ((natural_heal_prev_tick =
    9576. 

  9576.                          gettick () + NATURAL_HEAL_INTERVAL), pc_natural_heal,
    9577. 

  9577.                         0, 0, NATURAL_HEAL_INTERVAL);
    9578. 

  9578.     add_timer (gettick () + autosave_interval, pc_autosave, 0, 0);
    9579. 

  9579. 

  9580.     // add night/day timer (by [yor])
    9581. 

  9581.     add_timer_func_list (map_day_timer, "map_day_timer");   // by [yor]
    9582. 

  9582.     add_timer_func_list (map_night_timer, "map_night_timer");   // by [yor]
    9583. 

  9583.     {
    9584. 

  9584.         int  day_duration = battle_config.day_duration;
    9585. 

  9585.         int  night_duration = battle_config.night_duration;
    9586. 

  9586.         if (day_duration < 60000)
    9587. 

  9587.             day_duration = 60000;
    9588. 

  9588.         if (night_duration < 60000)
    9589. 

  9589.             night_duration = 60000;
    9590. 

  9590.         if (battle_config.night_at_start == 0)
    9591. 

  9591.         {
    9592. 

  9592.             night_flag = 0;     // 0=day, 1=night [Yor]
    9593. 

  9593.             day_timer_tid =
    9594. 

  9594.                 add_timer_interval (gettick () + day_duration +
    9595. 

  9595.                                     night_duration, map_day_timer, 0, 0,
    9596. 

  9596.                                     day_duration + night_duration);
    9597. 

  9597.             night_timer_tid =
    9598. 

  9598.                 add_timer_interval (gettick () + day_duration,
    9599. 

  9599.                                     map_night_timer, 0, 0,
    9600. 

  9600.                                     day_duration + night_duration);
    9601. 

  9601.         }
    9602. 

  9602.         else
    9603. 

  9603.         {
    9604. 

  9604.             night_flag = 1;     // 0=day, 1=night [Yor]
    9605. 

  9605.             day_timer_tid =
    9606. 

  9606.                 add_timer_interval (gettick () + night_duration,
    9607. 

  9607.                                     map_day_timer, 0, 0,
    9608. 

  9608.                                     day_duration + night_duration);
    9609. 

  9609.             night_timer_tid =
    9610. 

  9610.                 add_timer_interval (gettick () + day_duration +
    9611. 

  9611.                                     night_duration, map_night_timer, 0, 0,
    9612. 

  9612.                                     day_duration + night_duration);
    9613. 

  9613.         }
    9614. 

  9614.     }
    9615. 

  9615. 

  9616.     return 0;
    9617. 

  9617. }
    9618. 

  9618. 

  9619. void pc_cleanup (struct map_session_data *sd)
    9620. 

  9620. {
    9621. 

  9621.     magic_stop_completely (sd);
    9622. 

  9622. }
    9623. 

  9623. 

  9624. void pc_invisibility (struct map_session_data *sd, int enabled)
    9625. 

  9625. {
    9626. 

  9626.     if (enabled && !(sd->status.option & OPTION_INVISIBILITY))
    9627. 

  9627.     {
    9628. 

  9628.         clif_clearchar_area (&sd->bl, 3);
    9629. 

  9629.         sd->status.option |= OPTION_INVISIBILITY;
    9630. 

  9630.         clif_status_change (&sd->bl, CLIF_OPTION_SC_INVISIBILITY, 1);
    9631. 

  9631.     }
    9632. 

  9632.     else if (!enabled)
    9633. 

  9633.     {
    9634. 

  9634.         sd->status.option &= ~OPTION_INVISIBILITY;
    9635. 

  9635.         clif_status_change (&sd->bl, CLIF_OPTION_SC_INVISIBILITY, 0);
    9636. 

  9636.         pc_setpos (sd, map[sd->bl.m].name, sd->bl.x, sd->bl.y, 3);
    9637. 

  9637.     }
    9638. 

  9638. }
    9639. 

  9639. 

  9640. int pc_logout (struct map_session_data *sd) // [fate] Player logs out
    9641. 

  9641. {
    9642. 

  9642.     unsigned int tick = gettick ();
    9643. 

  9643. 

  9644.     if (!sd)
    9645. 

  9645.         return 0;
    9646. 

  9646. 

  9647.     if (sd->sc_data[SC_POISON].timer != -1)
    9648. 

  9648.         sd->status.hp = 1;      // Logging out while poisoned -> bad
    9649. 

  9649. 

  9650.     /*
    9651. 

  9651.      * Trying to rapidly sign out/in or switch characters to avoid a spell's
    9652. 

  9652.      * cast time is also bad. [remoitnane]
    9653. 

  9653.      */
    9654. 

  9654.     if (sd->cast_tick > tick)
    9655. 

  9655.     {
    9656. 

  9656.         if (pc_setglobalreg (sd, "MAGIC_CAST_TICK", sd->cast_tick - tick))
    9657. 

  9657.             sd->status.sp = 1;
    9658. 

  9658.     }
    9659. 

  9659.     else
    9660. 

  9660.         pc_setglobalreg (sd, "MAGIC_CAST_TICK", 0);
    9661. 

  9661. 

  9662.     MAP_LOG_STATS (sd, "LOGOUT") return 0;
    9663. 

  9663. }
    9664. 

  9664.