Recode from SHIFT-JIS to unicode, then undo the conversion of backslashs and tildes.

1 files changed, 629 insertions, 629 deletions

diff --git a/src/map/battle.c b/src/map/battle.c
index 9d868c7..f81aaf0 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -29,8 +29,8 @@ int  attr_fix_table[4][10][10];
 struct Battle_Config battle_config;
 
 /*==========================================
- * “ñ“_ŠÔ‚Ì‹——£‚ð•Ô‚·
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 二点間��離を返�
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 static int distance (int x0, int y0, int x1, int y1)
@@ -43,8 +43,8 @@ static int distance (int x0, int y0, int x1, int y1)
 }
 
 /*==========================================
- * Ž©•ª‚ðƒ�ƒbƒN‚µ‚Ä‚¢‚é‘Î�Û‚Ì�”‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 自分をロック���る対象�数を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_counttargeted (struct block_list *bl, struct block_list *src,
@@ -60,8 +60,8 @@ int battle_counttargeted (struct block_list *bl, struct block_list *src,
 }
 
 /*==========================================
- * ‘Î�Û‚ÌClass‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Classを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_class (struct block_list *bl)
@@ -76,8 +76,8 @@ int battle_get_class (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚Ì•ûŒü‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�方�を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_dir (struct block_list *bl)
@@ -92,8 +92,8 @@ int battle_get_dir (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�ۂ̃Œƒxƒ‹‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�レベルを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_lv (struct block_list *bl)
@@ -108,8 +108,8 @@ int battle_get_lv (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌŽË’ö‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�射程を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_range (struct block_list *bl)
@@ -124,8 +124,8 @@ int battle_get_range (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌHP‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�HPを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_hp (struct block_list *bl)
@@ -140,8 +140,8 @@ int battle_get_hp (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌMHP‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�MHPを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_max_hp (struct block_list *bl)
@@ -183,8 +183,8 @@ int battle_get_max_hp (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌStr‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Strを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_str (struct block_list *bl)
@@ -205,15 +205,15 @@ int battle_get_str (struct block_list *bl)
             && bl->type != BL_PC)
             str += 4;
         if (sc_data[SC_BLESSING].timer != -1 && bl->type != BL_PC)
-        {                       // ƒuƒŒƒbƒVƒ“ƒO
+        {                       // ブレッシング
             int  race = battle_get_race (bl);
             if (battle_check_undead (race, battle_get_elem_type (bl))
                 || race == 6)
-                str >>= 1;      // ˆ« –‚/•sŽ€
+                str >>= 1;      // 悪 魔/�死
             else
-                str += sc_data[SC_BLESSING].val1;   // ‚»‚Ì‘¼
+                str += sc_data[SC_BLESSING].val1;   // ��他
         }
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             str += 5;
     }
     if (str < 0)
@@ -222,8 +222,8 @@ int battle_get_str (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌAgi‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Agiを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 
@@ -241,19 +241,19 @@ int battle_get_agi (struct block_list *bl)
 
     if (sc_data)
     {
-        if (sc_data[SC_INCREASEAGI].timer != -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1 && bl->type != BL_PC)   // ‘¬“x‘�‰Á(PC‚Ípc.c‚Å)
+        if (sc_data[SC_INCREASEAGI].timer != -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1 && bl->type != BL_PC)   // 速度増加(PC�pc.c�)
             agi += 2 + sc_data[SC_INCREASEAGI].val1;
 
         if (sc_data[SC_CONCENTRATE].timer != -1
             && sc_data[SC_QUAGMIRE].timer == -1 && bl->type != BL_PC)
             agi += agi * (2 + sc_data[SC_CONCENTRATE].val1) / 100;
 
-        if (sc_data[SC_DECREASEAGI].timer != -1)    // ‘¬“xŒ¸�­
+        if (sc_data[SC_DECREASEAGI].timer != -1)    // 速度減少
             agi -= 2 + sc_data[SC_DECREASEAGI].val1;
 
-        if (sc_data[SC_QUAGMIRE].timer != -1)   // ƒNƒ@ƒOƒ}ƒCƒA
+        if (sc_data[SC_QUAGMIRE].timer != -1)   // クァグマイア
             agi >>= 1;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             agi += 5;
     }
     if (agi < 0)
@@ -262,8 +262,8 @@ int battle_get_agi (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌVit‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Vitを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_vit (struct block_list *bl)
@@ -281,7 +281,7 @@ int battle_get_vit (struct block_list *bl)
     {
         if (sc_data[SC_STRIPARMOR].timer != -1 && bl->type != BL_PC)
             vit = vit * 60 / 100;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             vit += 5;
     }
 
@@ -291,8 +291,8 @@ int battle_get_vit (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌInt‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Intを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_int (struct block_list *bl)
@@ -310,17 +310,17 @@ int battle_get_int (struct block_list *bl)
     if (sc_data)
     {
         if (sc_data[SC_BLESSING].timer != -1 && bl->type != BL_PC)
-        {                       // ƒuƒŒƒbƒVƒ“ƒO
+        {                       // ブレッシング
             int  race = battle_get_race (bl);
             if (battle_check_undead (race, battle_get_elem_type (bl))
                 || race == 6)
-                int_ >>= 1;     // ˆ« –‚/•sŽ€
+                int_ >>= 1;     // 悪 魔/�死
             else
-                int_ += sc_data[SC_BLESSING].val1;  // ‚»‚Ì‘¼
+                int_ += sc_data[SC_BLESSING].val1;  // ��他
         }
         if (sc_data[SC_STRIPHELM].timer != -1 && bl->type != BL_PC)
             int_ = int_ * 60 / 100;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             int_ += 5;
     }
     if (int_ < 0)
@@ -329,8 +329,8 @@ int battle_get_int (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌDex‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Dexを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_dex (struct block_list *bl)
@@ -352,18 +352,18 @@ int battle_get_dex (struct block_list *bl)
             dex += dex * (2 + sc_data[SC_CONCENTRATE].val1) / 100;
 
         if (sc_data[SC_BLESSING].timer != -1 && bl->type != BL_PC)
-        {                       // ƒuƒŒƒbƒVƒ“ƒO
+        {                       // ブレッシング
             int  race = battle_get_race (bl);
             if (battle_check_undead (race, battle_get_elem_type (bl))
                 || race == 6)
-                dex >>= 1;      // ˆ« –‚/•sŽ€
+                dex >>= 1;      // 悪 魔/�死
             else
-                dex += sc_data[SC_BLESSING].val1;   // ‚»‚Ì‘¼
+                dex += sc_data[SC_BLESSING].val1;   // ��他
         }
 
-        if (sc_data[SC_QUAGMIRE].timer != -1)   // ƒNƒ@ƒOƒ}ƒCƒA
+        if (sc_data[SC_QUAGMIRE].timer != -1)   // クァグマイア
             dex >>= 1;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             dex += 5;
     }
     if (dex < 0)
@@ -372,8 +372,8 @@ int battle_get_dex (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌLuk‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Lukを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_luk (struct block_list *bl)
@@ -390,11 +390,11 @@ int battle_get_luk (struct block_list *bl)
 
     if (sc_data)
     {
-        if (sc_data[SC_GLORIA].timer != -1 && bl->type != BL_PC)    // ƒOƒ�ƒŠƒA(PC‚Ípc.c‚Å)
+        if (sc_data[SC_GLORIA].timer != -1 && bl->type != BL_PC)    // グロリア(PC�pc.c�)
             luk += 30;
-        if (sc_data[SC_CURSE].timer != -1)  // Žô‚¢
+        if (sc_data[SC_CURSE].timer != -1)  // 呪�
             luk = 0;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             luk += 5;
     }
     if (luk < 0)
@@ -403,8 +403,8 @@ int battle_get_luk (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌFlee‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
+ * 対象�Fleeを返�(汎用)
+ * 戻り�整数�1以上
  *------------------------------------------
  */
 int battle_get_flee (struct block_list *bl)
@@ -427,9 +427,9 @@ int battle_get_flee (struct block_list *bl)
                         (sc_data[SC_WHISTLE].val3 >> 16)) / 100;
         if (sc_data[SC_BLIND].timer != -1 && bl->type != BL_PC)
             flee -= flee * 25 / 100;
-        if (sc_data[SC_WINDWALK].timer != -1 && bl->type != BL_PC)  // ƒEƒBƒ“ƒhƒEƒH�[ƒN
+        if (sc_data[SC_WINDWALK].timer != -1 && bl->type != BL_PC)  // ウィンドウォーク
             flee += flee * (sc_data[SC_WINDWALK].val2) / 100;
-        if (sc_data[SC_SPIDERWEB].timer != -1 && bl->type != BL_PC) //ƒXƒpƒCƒ_�[ƒEƒFƒu
+        if (sc_data[SC_SPIDERWEB].timer != -1 && bl->type != BL_PC) //スパイダーウェブ
             flee -= flee * 50 / 100;
 
         if (battle_is_unarmed (bl))
@@ -442,8 +442,8 @@ int battle_get_flee (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌHit‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
+ * 対象�Hitを返�(汎用)
+ * 戻り�整数�1以上
  *------------------------------------------
  */
 int battle_get_hit (struct block_list *bl)
@@ -465,11 +465,11 @@ int battle_get_hit (struct block_list *bl)
                 hit * (sc_data[SC_HUMMING].val1 * 2 +
                        sc_data[SC_HUMMING].val2 +
                        sc_data[SC_HUMMING].val3) / 100;
-        if (sc_data[SC_BLIND].timer != -1 && bl->type != BL_PC) // Žô‚¢
+        if (sc_data[SC_BLIND].timer != -1 && bl->type != BL_PC) // 呪�
             hit -= hit * 25 / 100;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) // トゥルーサイト
             hit += 3 * (sc_data[SC_TRUESIGHT].val1);
-        if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC) //ƒRƒ“ƒZƒ“ƒgƒŒ�[ƒVƒ‡ƒ“
+        if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC) //コンセントレーション
             hit += (hit * (10 * (sc_data[SC_CONCENTRATION].val1))) / 100;
 
         if (battle_is_unarmed (bl))
@@ -481,8 +481,8 @@ int battle_get_hit (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌŠ®‘S‰ñ”ð‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
+ * 対象�完全回�を返�(汎用)
+ * 戻り�整数�1以上
  *------------------------------------------
  */
 int battle_get_flee2 (struct block_list *bl)
@@ -518,8 +518,8 @@ int battle_get_flee2 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�ۂ̃NƒŠƒeƒBƒJƒ‹‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
+ * 対象�クリティカルを返�(汎用)
+ * 戻り�整数�1以上
  *------------------------------------------
  */
 int battle_get_critical (struct block_list *bl)
@@ -547,7 +547,7 @@ int battle_get_critical (struct block_list *bl)
                  sc_data[SC_FORTUNE].val3) * 10;
         if (sc_data[SC_EXPLOSIONSPIRITS].timer != -1 && bl->type != BL_PC)
             critical += sc_data[SC_EXPLOSIONSPIRITS].val2;
-        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) //ƒgƒDƒ‹�[ƒTƒCƒg
+        if (sc_data[SC_TRUESIGHT].timer != -1 && bl->type != BL_PC) //トゥルーサイト
             critical += critical * sc_data[SC_TRUESIGHT].val1 / 100;
     }
     if (critical < 1)
@@ -556,8 +556,8 @@ int battle_get_critical (struct block_list *bl)
 }
 
 /*==========================================
- * base_atk‚̎擾
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
+ * base_atk��得
+ * 戻り�整数�1以上
  *------------------------------------------
  */
 int battle_get_baseatk (struct block_list *bl)
@@ -568,31 +568,31 @@ int battle_get_baseatk (struct block_list *bl)
     nullpo_retr (1, bl);
     sc_data = battle_get_sc_data (bl);
     if (bl->type == BL_PC && (struct map_session_data *) bl)
-        batk = ((struct map_session_data *) bl)->base_atk;  //�ݒ肳‚ê‚Ä‚¢‚ébase_atk
+        batk = ((struct map_session_data *) bl)->base_atk;  //設定�れ��るbase_atk
     else
-    {                           //‚»‚êˆÈŠO‚È‚ç
+    {                           //�れ以外�ら
         int  str, dstr;
         str = battle_get_str (bl);  //STR
         dstr = str / 10;
-        batk = dstr * dstr + str;   //base_atk‚ðŒvŽZ‚·‚é
+        batk = dstr * dstr + str;   //base_atkを計算�る
     }
     if (sc_data)
-    {                           //�ó‘ÔˆÙ�í‚ ‚è
-        if (sc_data[SC_PROVOKE].timer != -1 && bl->type != BL_PC)   //PC‚Ńvƒ�ƒ{ƒbƒN(SM_PROVOKE)�ó‘Ô
-            batk = batk * (100 + 2 * sc_data[SC_PROVOKE].val1) / 100;   //base_atk‘�‰Á
-        if (sc_data[SC_CURSE].timer != -1)  //Žô‚í‚ê‚Ä‚¢‚½‚ç
-            batk -= batk * 25 / 100;    //base_atk‚ª25%Œ¸�­
-        if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC) //ƒRƒ“ƒZƒ“ƒgƒŒ�[ƒVƒ‡ƒ“
+    {                           //状態異常�り
+        if (sc_data[SC_PROVOKE].timer != -1 && bl->type != BL_PC)   //PC�プロボック(SM_PROVOKE)状態
+            batk = batk * (100 + 2 * sc_data[SC_PROVOKE].val1) / 100;   //base_atk増加
+        if (sc_data[SC_CURSE].timer != -1)  //呪�れ���ら
+            batk -= batk * 25 / 100;    //base_atk�25%減少
+        if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC) //コンセントレーション
             batk += batk * (5 * sc_data[SC_CONCENTRATION].val1) / 100;
     }
     if (batk < 1)
-        batk = 1;               //base_atk‚Í�Å’á‚Å‚à1
+        batk = 1;               //base_atk�最低�も1
     return batk;
 }
 
 /*==========================================
- * ‘Î�Û‚ÌAtk‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Atkを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_atk (struct block_list *bl)
@@ -613,7 +613,7 @@ int battle_get_atk (struct block_list *bl)
             atk = atk * (100 + 2 * sc_data[SC_PROVOKE].val1) / 100;
         if (sc_data[SC_CURSE].timer != -1)
             atk -= atk * 25 / 100;
-        if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC) //ƒRƒ“ƒZƒ“ƒgƒŒ�[ƒVƒ‡ƒ“
+        if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC) //コンセントレーション
             atk += atk * (5 * sc_data[SC_CONCENTRATION].val1) / 100;
     }
     if (atk < 0)
@@ -622,8 +622,8 @@ int battle_get_atk (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚Ì�¶ŽèAtk‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�左手Atkを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_atk_ (struct block_list *bl)
@@ -642,8 +642,8 @@ int battle_get_atk_ (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌAtk2‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Atk2を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_atk2 (struct block_list *bl)
@@ -672,7 +672,7 @@ int battle_get_atk2 (struct block_list *bl)
                 atk2 += sc_data[SC_NIBELUNGEN].val2;
             if (sc_data[SC_STRIPWEAPON].timer != -1)
                 atk2 = atk2 * 90 / 100;
-            if (sc_data[SC_CONCENTRATION].timer != -1)  //ƒRƒ“ƒZƒ“ƒgƒŒ�[ƒVƒ‡ƒ“
+            if (sc_data[SC_CONCENTRATION].timer != -1)  //コンセントレーション
                 atk2 += atk2 * (5 * sc_data[SC_CONCENTRATION].val1) / 100;
         }
 
@@ -684,8 +684,8 @@ int battle_get_atk2 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚Ì�¶ŽèAtk2‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�左手Atk2を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_atk_2 (struct block_list *bl)
@@ -698,8 +698,8 @@ int battle_get_atk_2 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌMAtk1‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�MAtk1を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_matk1 (struct block_list *bl)
@@ -724,8 +724,8 @@ int battle_get_matk1 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌMAtk2‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�MAtk2を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_matk2 (struct block_list *bl)
@@ -749,8 +749,8 @@ int battle_get_matk2 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌDef‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�Defを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_def (struct block_list *bl)
@@ -777,38 +777,38 @@ int battle_get_def (struct block_list *bl)
     {
         if (sc_data)
         {
-            //ƒL�[ƒsƒ“ƒOŽž‚ÍDEF100
+            //キーピング時�DEF100
             if (sc_data[SC_KEEPING].timer != -1)
                 def = 100;
-            //ƒvƒ�ƒ{ƒbƒNŽž‚ÍŒ¸ŽZ
+            //プロボック時�減算
             if (sc_data[SC_PROVOKE].timer != -1 && bl->type != BL_PC)
                 def = (def * (100 - 6 * sc_data[SC_PROVOKE].val1) + 50) / 100;
-            //�푾ŒÛ‚Ì‹¿‚«Žž‚͉ÁŽZ
+            //戦太鼓�響�時�加算
             if (sc_data[SC_DRUMBATTLE].timer != -1 && bl->type != BL_PC)
                 def += sc_data[SC_DRUMBATTLE].val3;
-            //“Å‚É‚©‚©‚Á‚Ä‚¢‚鎞‚ÍŒ¸ŽZ
+            //毒������る時�減算
             if (sc_data[SC_POISON].timer != -1 && bl->type != BL_PC)
                 def = def * 75 / 100;
-            //ƒXƒgƒŠƒbƒvƒV�[ƒ‹ƒhŽž‚ÍŒ¸ŽZ
+            //ストリップシールド時�減算
             if (sc_data[SC_STRIPSHIELD].timer != -1 && bl->type != BL_PC)
                 def = def * 85 / 100;
-            //ƒVƒOƒiƒ€ƒNƒ‹ƒVƒXŽž‚ÍŒ¸ŽZ
+            //シグナムクルシス時�減算
             if (sc_data[SC_SIGNUMCRUCIS].timer != -1 && bl->type != BL_PC)
                 def = def * (100 - sc_data[SC_SIGNUMCRUCIS].val2) / 100;
-            //‰i‰“‚Ì�¬“׎ž‚ÍDEF0‚É‚È‚é
+            //永��混沌時�DEF0��る
             if (sc_data[SC_ETERNALCHAOS].timer != -1 && bl->type != BL_PC)
                 def = 0;
-            //“€Œ‹�A�Ή»Žž‚͉EƒVƒtƒg
+            //���石化時��シフト
             if (sc_data[SC_FREEZE].timer != -1
                 || (sc_data[SC_STONE].timer != -1
                     && sc_data[SC_STONE].val2 == 0))
                 def >>= 1;
-            //ƒRƒ“ƒZƒ“ƒgƒŒ�[ƒVƒ‡ƒ“Žž‚ÍŒ¸ŽZ
+            //コンセントレーション時�減算
             if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC)
                 def =
                     (def * (100 - 5 * sc_data[SC_CONCENTRATION].val1)) / 100;
         }
-        //‰r�¥’†‚͉r�¥ŽžŒ¸ŽZ—¦‚ÉŠî‚¢‚ÄŒ¸ŽZ
+        //詠唱中�詠唱時減算率�基���減算
         if (skilltimer != -1)
         {
             int  def_rate = skill_get_castdef (skillid);
@@ -822,8 +822,8 @@ int battle_get_def (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌMDef‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�MDefを返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_mdef (struct block_list *bl)
@@ -842,7 +842,7 @@ int battle_get_mdef (struct block_list *bl)
     {
         if (sc_data)
         {
-            //ƒoƒŠƒA�[�ó‘ÔŽž‚ÍMDEF100
+            //�リアー状態時�MDEF100
             if (mdef < 90 && sc_data[SC_MBARRIER].timer != -1)
             {
                 mdef += sc_data[SC_MBARRIER].val1;
@@ -851,7 +851,7 @@ int battle_get_mdef (struct block_list *bl)
             }
             if (sc_data[SC_BARRIER].timer != -1)
                 mdef = 100;
-            //“€Œ‹�A�Ή»Žž‚Í1.25”{
+            //���石化時�1.25�
             if (sc_data[SC_FREEZE].timer != -1
                 || (sc_data[SC_STONE].timer != -1
                     && sc_data[SC_STONE].val2 == 0))
@@ -866,8 +866,8 @@ int battle_get_mdef (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌDef2‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
+ * 対象�Def2を返�(汎用)
+ * 戻り�整数�1以上
  *------------------------------------------
  */
 int battle_get_def2 (struct block_list *bl)
@@ -890,7 +890,7 @@ int battle_get_def2 (struct block_list *bl)
             def2 = (def2 * (100 - 6 * sc_data[SC_PROVOKE].val1) + 50) / 100;
         if (sc_data[SC_POISON].timer != -1 && bl->type != BL_PC)
             def2 = def2 * 75 / 100;
-        //ƒRƒ“ƒZƒ“ƒgƒŒ�[ƒVƒ‡ƒ“Žž‚ÍŒ¸ŽZ
+        //コンセントレーション時�減算
         if (sc_data[SC_CONCENTRATION].timer != -1 && bl->type != BL_PC)
             def2 = def2 * (100 - 5 * sc_data[SC_CONCENTRATION].val1) / 100;
     }
@@ -900,8 +900,8 @@ int battle_get_def2 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌMDef2‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å0ˆÈ�ã
+ * 対象�MDef2を返�(汎用)
+ * 戻り�整数�0以上
  *------------------------------------------
  */
 int battle_get_mdef2 (struct block_list *bl)
@@ -929,9 +929,9 @@ int battle_get_mdef2 (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌSpeed(ˆÚ“®‘¬“x)‚ð•Ô‚·(”Ä—p)
- * –ß‚è‚Í�®�”‚Å1ˆÈ�ã
- * Speed‚Í�¬‚³‚¢‚Ù‚¤‚ªˆÚ“®‘¬“x‚ª‘¬‚¢
+ * 対象�Speed(移動速度)を返�(汎用)
+ * 戻り�整数�1以上
+ * Speed�������移動速度�速�
  *------------------------------------------
  */
 int battle_get_speed (struct block_list *bl)
@@ -948,35 +948,35 @@ int battle_get_speed (struct block_list *bl)
 
         if (sc_data)
         {
-            //‘¬“x‘�‰ÁŽž‚Í25%Œ¸ŽZ
+            //速度増加時�25%減算
             if (sc_data[SC_INCREASEAGI].timer != -1
                 && sc_data[SC_DONTFORGETME].timer == -1)
                 speed -= speed * 25 / 100;
-            //‘¬“xŒ¸�­Žž‚Í25%‰ÁŽZ
+            //速度減少時�25%加算
             if (sc_data[SC_DECREASEAGI].timer != -1)
                 speed = speed * 125 / 100;
-            //ƒNƒ@ƒOƒ}ƒCƒAŽž‚Í50%‰ÁŽZ
+            //クァグマイア時�50%加算
             if (sc_data[SC_QUAGMIRE].timer != -1)
                 speed = speed * 3 / 2;
-            //Ž„‚ð–Y‚ê‚È‚¢‚Å�cŽž‚͉ÁŽZ
+            //�を忘れ���…時�加算
             if (sc_data[SC_DONTFORGETME].timer != -1)
                 speed =
                     speed * (100 + sc_data[SC_DONTFORGETME].val1 * 2 +
                              sc_data[SC_DONTFORGETME].val2 +
                              (sc_data[SC_DONTFORGETME].val3 & 0xffff)) / 100;
-            //‹à�„Žž‚Í25%‰ÁŽZ
+            //金剛時�25%加算
             if (sc_data[SC_STEELBODY].timer != -1)
                 speed = speed * 125 / 100;
-            //ƒfƒBƒtƒFƒ“ƒ_�[Žž‚͉ÁŽZ
+            //ディフェンダー時�加算
             if (sc_data[SC_DEFENDER].timer != -1)
                 speed = (speed * (155 - sc_data[SC_DEFENDER].val1 * 5)) / 100;
-            //—x‚è�ó‘Ô‚Í4”{’x‚¢
+            //踊り状態�4���
             if (sc_data[SC_DANCING].timer != -1)
                 speed *= 4;
-            //Žô‚¢Žž‚Í450‰ÁŽZ
+            //呪�時�450加算
             if (sc_data[SC_CURSE].timer != -1)
                 speed = speed + 450;
-            //ƒEƒBƒ“ƒhƒEƒH�[ƒNŽž‚ÍLv*2%Œ¸ŽZ
+            //ウィンドウォーク時�Lv*2%減算
             if (sc_data[SC_WINDWALK].timer != -1)
                 speed -= (speed * (sc_data[SC_WINDWALK].val1 * 2)) / 100;
         }
@@ -989,8 +989,8 @@ int battle_get_speed (struct block_list *bl)
 }
 
 /*==========================================
- * ‘Î�Û‚ÌaDelay(�UŒ‚ŽžƒfƒBƒŒƒC)‚ð•Ô‚·(”Ä—p)
- * aDelay‚Í�¬‚³‚¢‚Ù‚¤‚ª�UŒ‚‘¬“x‚ª‘¬‚¢
+ * 対象�aDelay(攻撃時ディレイ)を返�(汎用)
+ * aDelay�������攻撃速度�速�
  *------------------------------------------
  */
 int battle_get_adelay (struct block_list *bl)
@@ -1007,28 +1007,28 @@ int battle_get_adelay (struct block_list *bl)
 
         if (sc_data)
         {
-            //ƒc�[ƒnƒ“ƒhƒNƒCƒbƒPƒ“Žg—pŽž‚ŃNƒ@ƒOƒ}ƒCƒA‚Å‚àŽ„‚ð–Y‚ê‚È‚¢‚Å�c‚Å‚à‚È‚¢Žž‚Í3Š„Œ¸ŽZ
+            //ツー�ンドクイッケン使用時�クァグマイア�も�を忘れ���…�も��時�3割減算
             if (sc_data[SC_TWOHANDQUICKEN].timer != -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1) // 2HQ
                 aspd_rate -= 30;
-            //ƒAƒhƒŒƒiƒŠƒ“ƒ‰ƒbƒVƒ…Žg—pŽž‚Ńc�[ƒnƒ“ƒhƒNƒCƒbƒPƒ“‚Å‚àƒNƒ@ƒOƒ}ƒCƒA‚Å‚àŽ„‚ð–Y‚ê‚È‚¢‚Å�c‚Å‚à‚È‚¢Žž‚Í
+            //アドレナリンラッシュ使用時�ツー�ンドクイッケン�もクァグマイア�も�を忘れ���…�も��時�
             if (sc_data[SC_ADRENALINE].timer != -1
                 && sc_data[SC_TWOHANDQUICKEN].timer == -1
                 && sc_data[SC_QUAGMIRE].timer == -1
                 && sc_data[SC_DONTFORGETME].timer == -1)
-            {                   // ƒAƒhƒŒƒiƒŠƒ“ƒ‰ƒbƒVƒ…
-                //Žg—pŽÒ‚ƃp�[ƒeƒBƒ�ƒ“ƒo�[‚ÅŠi�·‚ª�o‚é�Ý’è‚Å‚È‚¯‚ê‚Î3Š„Œ¸ŽZ
+            {                   // アドレナリンラッシュ
+                //使用者�パーティメン�ー�格差�出る設定���れ�3割減算
                 if (sc_data[SC_ADRENALINE].val2
                     || !battle_config.party_skill_penaly)
                     aspd_rate -= 30;
-                //‚»‚¤‚Å‚È‚¯‚ê‚Î2.5Š„Œ¸ŽZ
+                //�����れ�2.5割減算
                 else
                     aspd_rate -= 25;
             }
-            //ƒXƒsƒAƒNƒBƒbƒPƒ“Žž‚ÍŒ¸ŽZ
-            if (sc_data[SC_SPEARSQUICKEN].timer != -1 && sc_data[SC_ADRENALINE].timer == -1 && sc_data[SC_TWOHANDQUICKEN].timer == -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1)  // ƒXƒsƒAƒNƒBƒbƒPƒ“
+            //スピアクィッケン時�減算
+            if (sc_data[SC_SPEARSQUICKEN].timer != -1 && sc_data[SC_ADRENALINE].timer == -1 && sc_data[SC_TWOHANDQUICKEN].timer == -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1)  // スピアクィッケン
                 aspd_rate -= sc_data[SC_SPEARSQUICKEN].val2;
-            //—[“ú‚̃AƒTƒVƒ“ƒNƒ�ƒXŽž‚ÍŒ¸ŽZ
-            if (sc_data[SC_ASSNCROS].timer != -1 && // —[—z‚̃AƒTƒVƒ“ƒNƒ�ƒX
+            //夕日�アサシンクロス時�減算
+            if (sc_data[SC_ASSNCROS].timer != -1 && // 夕陽�アサシンクロス
                 sc_data[SC_TWOHANDQUICKEN].timer == -1
                 && sc_data[SC_ADRENALINE].timer == -1
                 && sc_data[SC_SPEARSQUICKEN].timer == -1
@@ -1036,16 +1036,16 @@ int battle_get_adelay (struct block_list *bl)
                 aspd_rate -=
                     5 + sc_data[SC_ASSNCROS].val1 +
                     sc_data[SC_ASSNCROS].val2 + sc_data[SC_ASSNCROS].val3;
-            //Ž„‚ð–Y‚ê‚È‚¢‚Å�cŽž‚͉ÁŽZ
-            if (sc_data[SC_DONTFORGETME].timer != -1)   // Ž„‚ð–Y‚ê‚È‚¢‚Å
+            //�を忘れ���…時�加算
+            if (sc_data[SC_DONTFORGETME].timer != -1)   // �を忘れ���
                 aspd_rate +=
                     sc_data[SC_DONTFORGETME].val1 * 3 +
                     sc_data[SC_DONTFORGETME].val2 +
                     (sc_data[SC_DONTFORGETME].val3 >> 16);
-            //‹à�„Žž25%‰ÁŽZ
-            if (sc_data[SC_STEELBODY].timer != -1)  // ‹à�„
+            //金剛時25%加算
+            if (sc_data[SC_STEELBODY].timer != -1)  // 金剛
                 aspd_rate += 25;
-            //‘�‘¬ƒ|�[ƒVƒ‡ƒ“Žg—pŽž‚ÍŒ¸ŽZ
+            //増速�ーション使用時�減算
             if (sc_data[i = SC_SPEEDPOTION2].timer != -1
                 || sc_data[i = SC_SPEEDPOTION1].timer != -1
                 || sc_data[i = SC_SPEEDPOTION0].timer != -1)
@@ -1053,7 +1053,7 @@ int battle_get_adelay (struct block_list *bl)
             // Fate's `haste' spell works the same as the above
             if (sc_data[SC_HASTE].timer != -1)
                 aspd_rate -= sc_data[SC_HASTE].val1;
-            //ƒfƒBƒtƒFƒ“ƒ_�[Žž‚͉ÁŽZ
+            //ディフェンダー時�加算
             if (sc_data[SC_DEFENDER].timer != -1)
                 adelay += (1100 - sc_data[SC_DEFENDER].val1 * 100);
         }
@@ -1087,16 +1087,16 @@ int battle_get_amotion (struct block_list *bl)
                 && sc_data[SC_TWOHANDQUICKEN].timer == -1
                 && sc_data[SC_QUAGMIRE].timer == -1
                 && sc_data[SC_DONTFORGETME].timer == -1)
-            {                   // ƒAƒhƒŒƒiƒŠƒ“ƒ‰ƒbƒVƒ…
+            {                   // アドレナリンラッシュ
                 if (sc_data[SC_ADRENALINE].val2
                     || !battle_config.party_skill_penaly)
                     aspd_rate -= 30;
                 else
                     aspd_rate -= 25;
             }
-            if (sc_data[SC_SPEARSQUICKEN].timer != -1 && sc_data[SC_ADRENALINE].timer == -1 && sc_data[SC_TWOHANDQUICKEN].timer == -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1)  // ƒXƒsƒAƒNƒBƒbƒPƒ“
+            if (sc_data[SC_SPEARSQUICKEN].timer != -1 && sc_data[SC_ADRENALINE].timer == -1 && sc_data[SC_TWOHANDQUICKEN].timer == -1 && sc_data[SC_QUAGMIRE].timer == -1 && sc_data[SC_DONTFORGETME].timer == -1)  // スピアクィッケン
                 aspd_rate -= sc_data[SC_SPEARSQUICKEN].val2;
-            if (sc_data[SC_ASSNCROS].timer != -1 && // —[—z‚̃AƒTƒVƒ“ƒNƒ�ƒX
+            if (sc_data[SC_ASSNCROS].timer != -1 && // 夕陽�アサシンクロス
                 sc_data[SC_TWOHANDQUICKEN].timer == -1
                 && sc_data[SC_ADRENALINE].timer == -1
                 && sc_data[SC_SPEARSQUICKEN].timer == -1
@@ -1104,12 +1104,12 @@ int battle_get_amotion (struct block_list *bl)
                 aspd_rate -=
                     5 + sc_data[SC_ASSNCROS].val1 +
                     sc_data[SC_ASSNCROS].val2 + sc_data[SC_ASSNCROS].val3;
-            if (sc_data[SC_DONTFORGETME].timer != -1)   // Ž„‚ð–Y‚ê‚È‚¢‚Å
+            if (sc_data[SC_DONTFORGETME].timer != -1)   // �を忘れ���
                 aspd_rate +=
                     sc_data[SC_DONTFORGETME].val1 * 3 +
                     sc_data[SC_DONTFORGETME].val2 +
                     (sc_data[SC_DONTFORGETME].val3 >> 16);
-            if (sc_data[SC_STEELBODY].timer != -1)  // ‹à�„
+            if (sc_data[SC_STEELBODY].timer != -1)  // 金剛
                 aspd_rate += 25;
             if (sc_data[i = SC_SPEEDPOTION2].timer != -1
                 || sc_data[i = SC_SPEEDPOTION1].timer != -1
@@ -1167,16 +1167,16 @@ int battle_get_element (struct block_list *bl)
 
     nullpo_retr (ret, bl);
     sc_data = battle_get_sc_data (bl);
-    if (bl->type == BL_MOB && (struct mob_data *) bl)   // 10‚̈Ê��Lv*2�A‚P‚̈Ê��‘®�«
+    if (bl->type == BL_MOB && (struct mob_data *) bl)   // 10���Lv*2�１���属性
         ret = ((struct mob_data *) bl)->def_ele;
     else if (bl->type == BL_PC && (struct map_session_data *) bl)
-        ret = 20 + ((struct map_session_data *) bl)->def_ele;   // –hŒä‘®�«Lv1
+        ret = 20 + ((struct map_session_data *) bl)->def_ele;   // 防御属性Lv1
 
     if (sc_data)
     {
-        if (sc_data[SC_BENEDICTIO].timer != -1) // �¹‘Ì�~•Ÿ
+        if (sc_data[SC_BENEDICTIO].timer != -1) // �体��
             ret = 26;
-        if (sc_data[SC_FREEZE].timer != -1) // “€Œ‹
+        if (sc_data[SC_FREEZE].timer != -1) // ��
             ret = 21;
         if (sc_data[SC_STONE].timer != -1 && sc_data[SC_STONE].val2 == 0)
             ret = 22;
@@ -1198,17 +1198,17 @@ int battle_get_attack_element (struct block_list *bl)
 
     if (sc_data)
     {
-        if (sc_data[SC_FROSTWEAPON].timer != -1)    // ƒtƒ�ƒXƒgƒEƒFƒ|ƒ“
+        if (sc_data[SC_FROSTWEAPON].timer != -1)    // フロストウェ�ン
             ret = 1;
-        if (sc_data[SC_SEISMICWEAPON].timer != -1)  // ƒTƒCƒYƒ~ƒbƒNƒEƒFƒ|ƒ“
+        if (sc_data[SC_SEISMICWEAPON].timer != -1)  // サイズミックウェ�ン
             ret = 2;
-        if (sc_data[SC_FLAMELAUNCHER].timer != -1)  // ƒtƒŒ�[ƒ€ƒ‰ƒ“ƒ`ƒƒ�[
+        if (sc_data[SC_FLAMELAUNCHER].timer != -1)  // フレームラン�ャー
             ret = 3;
-        if (sc_data[SC_LIGHTNINGLOADER].timer != -1)    // ƒ‰ƒCƒgƒjƒ“ƒOƒ��[ƒ_�[
+        if (sc_data[SC_LIGHTNINGLOADER].timer != -1)    // ライトニングローダー
             ret = 4;
-        if (sc_data[SC_ENCPOISON].timer != -1)  // ƒGƒ“ƒ`ƒƒƒ“ƒgƒ|ƒCƒYƒ“
+        if (sc_data[SC_ENCPOISON].timer != -1)  // エン�ャント�イズン
             ret = 5;
-        if (sc_data[SC_ASPERSIO].timer != -1)   // ƒAƒXƒyƒ‹ƒVƒI
+        if (sc_data[SC_ASPERSIO].timer != -1)   // アスペルシオ
             ret = 6;
     }
 
@@ -1226,17 +1226,17 @@ int battle_get_attack_element2 (struct block_list *bl)
 
         if (sc_data)
         {
-            if (sc_data[SC_FROSTWEAPON].timer != -1)    // ƒtƒ�ƒXƒgƒEƒFƒ|ƒ“
+            if (sc_data[SC_FROSTWEAPON].timer != -1)    // フロストウェ�ン
                 ret = 1;
-            if (sc_data[SC_SEISMICWEAPON].timer != -1)  // ƒTƒCƒYƒ~ƒbƒNƒEƒFƒ|ƒ“
+            if (sc_data[SC_SEISMICWEAPON].timer != -1)  // サイズミックウェ�ン
                 ret = 2;
-            if (sc_data[SC_FLAMELAUNCHER].timer != -1)  // ƒtƒŒ�[ƒ€ƒ‰ƒ“ƒ`ƒƒ�[
+            if (sc_data[SC_FLAMELAUNCHER].timer != -1)  // フレームラン�ャー
                 ret = 3;
-            if (sc_data[SC_LIGHTNINGLOADER].timer != -1)    // ƒ‰ƒCƒgƒjƒ“ƒOƒ��[ƒ_�[
+            if (sc_data[SC_LIGHTNINGLOADER].timer != -1)    // ライトニングローダー
                 ret = 4;
-            if (sc_data[SC_ENCPOISON].timer != -1)  // ƒGƒ“ƒ`ƒƒƒ“ƒgƒ|ƒCƒYƒ“
+            if (sc_data[SC_ENCPOISON].timer != -1)  // エン�ャント�イズン
                 ret = 5;
-            if (sc_data[SC_ASPERSIO].timer != -1)   // ƒAƒXƒyƒ‹ƒVƒI
+            if (sc_data[SC_ASPERSIO].timer != -1)   // アスペルシオ
                 ret = 6;
         }
         return ret;
@@ -1303,7 +1303,7 @@ int battle_get_mode (struct block_list *bl)
     if (bl->type == BL_MOB && (struct mob_data *) bl)
         return mob_db[((struct mob_data *) bl)->class].mode;
     else
-        return 0x01;            // ‚Æ‚è‚ ‚¦‚¸“®‚­‚Æ‚¢‚¤‚±‚Æ‚Å1
+        return 0x01;            // �り���動�������1
 }
 
 int battle_get_mexp (struct block_list *bl)
@@ -1345,7 +1345,7 @@ int battle_get_stat (int stat_id /* SP_VIT or similar */ ,
     }
 }
 
-// StatusChangeŒn‚Ì�Š“¾
+// StatusChange系�所得
 struct status_change *battle_get_sc_data (struct block_list *bl)
 {
     nullpo_retr (NULL, bl);
@@ -1416,7 +1416,7 @@ short *battle_get_option (struct block_list *bl)
 
 //-------------------------------------------------------------------
 
-// ƒ_ƒ��[ƒW‚Ì’x‰„
+// ダメージ��延
 struct battle_delay_damage_
 {
     struct block_list *src, *target;
@@ -1451,7 +1451,7 @@ int battle_delay_damage (unsigned int tick, struct block_list *src,
     return 0;
 }
 
-// ŽÀ�Û‚ÉHP‚ð‘€�ì
+// 実際�HPを�作
 int battle_damage (struct block_list *bl, struct block_list *target,
                    int damage, int flag)
 {
@@ -1460,7 +1460,7 @@ int battle_damage (struct block_list *bl, struct block_list *target,
     short *sc_count;
     int  i;
 
-    nullpo_retr (0, target);    //bl‚ÍNULL‚ŌĂ΂ê‚邱‚Æ‚ª‚ ‚é‚Ì‚Å‘¼‚Ń`ƒFƒbƒN
+    nullpo_retr (0, target);    //bl�NULL�呼�れる����る��他��ェック
 
     if (damage == 0)
         return 0;
@@ -1483,7 +1483,7 @@ int battle_damage (struct block_list *bl, struct block_list *target,
     if (!flag && (sc_count = battle_get_sc_count (target)) != NULL
         && *sc_count > 0)
     {
-        // “€Œ‹�A�Ή»�A�‡–°‚ð�Á‹Ž
+        // ���石化��眠を消去
         if (sc_data[SC_FREEZE].timer != -1)
             skill_status_change_end (target, SC_FREEZE, -1);
         if (sc_data[SC_STONE].timer != -1 && sc_data[SC_STONE].val2 == 0)
@@ -1495,7 +1495,7 @@ int battle_damage (struct block_list *bl, struct block_list *target,
     if (target->type == BL_MOB)
     {                           // MOB
         struct mob_data *md = (struct mob_data *) target;
-        if (md && md->skilltimer != -1 && md->state.skillcastcancel)    // ‰r�¥–WŠQ
+        if (md && md->skilltimer != -1 && md->state.skillcastcancel)    // 詠唱妨害
             skill_castcancel (target, 0);
         return mob_damage (bl, md, damage, 0);
     }
@@ -1505,7 +1505,7 @@ int battle_damage (struct block_list *bl, struct block_list *target,
         struct map_session_data *tsd = (struct map_session_data *) target;
 
         if (tsd && tsd->sc_data && tsd->sc_data[SC_DEVOTION].val1)
-        {                       // ƒfƒBƒ{�[ƒVƒ‡ƒ“‚ð‚©‚¯‚ç‚ê‚Ä‚¢‚é
+        {                       // ディボーションを��られ��る
             struct map_session_data *md =
                 map_id2sd (tsd->sc_data[SC_DEVOTION].val1);
             if (md && skill_devotion3 (&md->bl, target->id))
@@ -1525,8 +1525,8 @@ int battle_damage (struct block_list *bl, struct block_list *target,
         }
 
         if (tsd && tsd->skilltimer != -1)
-        {                       // ‰r�¥–WŠQ
-            // ƒtƒFƒ“ƒJ�[ƒh‚â–WŠQ‚³‚ê‚È‚¢ƒXƒLƒ‹‚©‚ÌŒŸ�¸
+        {                       // 詠唱妨害
+            // フェンカードや妨害�れ��スキル��検査
             if ((!tsd->special_state.no_castcancel || map[bl->m].flag.gvg)
                 && tsd->state.skillcastcancel
                 && !tsd->special_state.no_castcancel2)
@@ -1545,7 +1545,7 @@ int battle_damage (struct block_list *bl, struct block_list *target,
 int battle_heal (struct block_list *bl, struct block_list *target, int hp,
                  int sp, int flag)
 {
-    nullpo_retr (0, target);    //bl‚ÍNULL‚ŌĂ΂ê‚邱‚Æ‚ª‚ ‚é‚Ì‚Å‘¼‚Ń`ƒFƒbƒN
+    nullpo_retr (0, target);    //bl�NULL�呼�れる����る��他��ェック
 
     if (target->type == BL_PC
         && pc_isdead ((struct map_session_data *) target))
@@ -1563,7 +1563,7 @@ int battle_heal (struct block_list *bl, struct block_list *target, int hp,
     return 0;
 }
 
-// �UŒ‚’âŽ~
+// 攻撃�止
 int battle_stopattack (struct block_list *bl)
 {
     nullpo_retr (0, bl);
@@ -1574,7 +1574,7 @@ int battle_stopattack (struct block_list *bl)
     return 0;
 }
 
-// ˆÚ“®’âŽ~
+// 移動�止
 int battle_stopwalking (struct block_list *bl, int type)
 {
     nullpo_retr (0, bl);
@@ -1586,7 +1586,7 @@ int battle_stopwalking (struct block_list *bl, int type)
 }
 
 /*==========================================
- * ƒ_ƒ��[ƒW‚Ì‘®�«�C�³
+ * ダメージ�属性修正
  *------------------------------------------
  */
 int battle_attr_fix (int damage, int atk_elem, int def_elem)
@@ -1595,7 +1595,7 @@ int battle_attr_fix (int damage, int atk_elem, int def_elem)
 
     if (atk_elem < 0 || atk_elem > 9 || def_type < 0 || def_type > 9 ||
         def_lv < 1 || def_lv > 4)
-    {                           // ‘® �«’l‚ª‚¨‚©‚µ‚¢‚Ì‚Å‚Æ‚è‚ ‚¦‚¸‚»‚Ì‚Ü‚Ü•Ô‚·
+    {                           // 属 性値��������り�������返�
         if (battle_config.error_log)
             printf
                 ("battle_attr_fix: unknown attr type: atk=%d def_type=%d def_lv=%d\n",
@@ -1607,7 +1607,7 @@ int battle_attr_fix (int damage, int atk_elem, int def_elem)
 }
 
 /*==========================================
- * ƒ_ƒ��[ƒW�Å�IŒvŽZ
+ * ダメージ最終計算
  *------------------------------------------
  */
 int battle_calc_damage (struct block_list *src, struct block_list *bl,
@@ -1638,37 +1638,37 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
             && flag & BF_WEAPON && flag & BF_SHORT
             && skill_num != NPC_GUIDEDATTACK)
         {
-            // ƒZ�[ƒtƒeƒBƒEƒH�[ƒ‹
+            // セーフティウォール
             struct skill_unit *unit =
                 (struct skill_unit *) sc_data[SC_SAFETYWALL].val2;
             if (unit && unit->alive && (--unit->group->val2) <= 0)
                 skill_delunit (unit);
-            skill_unit_move (bl, gettick (), 1);    // �d‚ËŠ|‚¯ƒ`ƒFƒbƒN
+            skill_unit_move (bl, gettick (), 1);    // ��掛��ェック
             damage = 0;
         }
         if (sc_data[SC_PNEUMA].timer != -1 && damage > 0 && flag & BF_WEAPON
             && flag & BF_LONG && skill_num != NPC_GUIDEDATTACK)
         {
-            // ƒjƒ…�[ƒ}
+            // ニューマ
             damage = 0;
         }
 
         if (sc_data[SC_ROKISWEIL].timer != -1 && damage > 0 &&
             flag & BF_MAGIC)
         {
-            // ƒjƒ…�[ƒ}
+            // ニューマ
             damage = 0;
         }
 
         if (sc_data[SC_AETERNA].timer != -1 && damage > 0)
-        {                       // ƒŒƒbƒNƒXƒG�[ƒeƒ‹ƒi
+        {                       // レックスエーテルナ
             damage <<= 1;
             skill_status_change_end (bl, SC_AETERNA, -1);
         }
 
-        //‘®�«�ê‚̃_ƒ��[ƒW‘�‰Á
+        //属性場�ダメージ増加
         if (sc_data[SC_VOLCANO].timer != -1)
-        {                       // ƒ{ƒ‹ƒP�[ƒm
+        {                       // ボルケーノ
             if (flag & BF_SKILL && skill_get_pl (skill_num) == 3)
                 damage += damage * sc_data[SC_VOLCANO].val4 / 100;
             else if (!(flag & BF_SKILL) && (battle_get_attack_element (bl) == 3))
@@ -1676,7 +1676,7 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
         }
 
         if (sc_data[SC_VIOLENTGALE].timer != -1)
-        {                       // ƒoƒCƒIƒŒƒ“ƒgƒQƒCƒ‹
+        {                       // �イオレントゲイル
             if (flag & BF_SKILL && skill_get_pl (skill_num) == 4)
                 damage += damage * sc_data[SC_VIOLENTGALE].val4 / 100;
             else if (!(flag & BF_SKILL) && (battle_get_attack_element (bl) == 4))
@@ -1684,7 +1684,7 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
         }
 
         if (sc_data[SC_DELUGE].timer != -1)
-        {                       // ƒfƒŠƒ…�[ƒW
+        {                       // デリュージ
             if (flag & BF_SKILL && skill_get_pl (skill_num) == 1)
                 damage += damage * sc_data[SC_DELUGE].val4 / 100;
             else if (!(flag & BF_SKILL) && (battle_get_attack_element (bl) == 1))
@@ -1693,7 +1693,7 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
 
         if (sc_data[SC_ENERGYCOAT].timer != -1 && damage > 0
             && flag & BF_WEAPON)
-        {                       // ƒGƒiƒW�[ƒR�[ƒg
+        {                       // エナジーコート
             if (sd)
             {
                 if (sd->status.sp > 0)
@@ -1713,7 +1713,7 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
         }
 
         if (sc_data[SC_KYRIE].timer != -1 && damage > 0)
-        {                       // ƒLƒŠƒGƒGƒŒƒCƒ\ƒ“
+        {                       // キリエエレイソン
             sc = &sc_data[SC_KYRIE];
             sc->val2 -= damage;
             if (flag & BF_WEAPON)
@@ -1730,13 +1730,13 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
 
         if (sc_data[SC_BASILICA].timer != -1 && damage > 0)
         {
-            // ƒjƒ…�[ƒ}
+            // ニューマ
             damage = 0;
         }
         if (sc_data[SC_LANDPROTECTOR].timer != -1 && damage > 0
             && flag & BF_MAGIC)
         {
-            // ƒjƒ…�[ƒ}
+            // ニューマ
             damage = 0;
         }
 
@@ -1766,7 +1766,7 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
                                      sc_data[SC_PARRYING].val1, 1);
             }
         }
-        // ƒŠƒWƒFƒNƒgƒ\�[ƒh
+        // リジェクトソード
         if (sc_data[SC_REJECTSWORD].timer != -1 && damage > 0
             && flag & BF_WEAPON
             &&
@@ -1776,11 +1776,11 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
              || src->type == BL_MOB))
         {
             if (MRAND (100) < (10 + 5 * sc_data[SC_REJECTSWORD].val1))
-            {                   //”½ŽËŠm—¦‚Í10+5*Lv
+            {                   //�射確率�10+5*Lv
                 damage = damage * 50 / 100;
                 battle_damage (bl, src, damage, 0);
-                //ƒ_ƒ��[ƒW‚ð—^‚¦‚½‚Ì‚Í—Ç‚¢‚ñ‚¾‚ª�A‚±‚±‚©‚ç‚Ç‚¤‚µ‚Ä•\Ž¦‚·‚é‚ñ‚¾‚©‚í‚©‚ñ‚Ë‚¥
-                //ƒGƒtƒFƒNƒg‚à‚±‚ê‚Å‚¢‚¢‚Ì‚©‚í‚©‚ñ‚Ë‚¥
+                //ダメージを与����良�ん������ら����表示�るん����ん��
+                //エフェクトも�れ�������ん��
                 clif_skill_nodamage (bl, bl, ST_REJECTSWORD,
                                      sc_data[SC_REJECTSWORD].val1, 1);
                 if ((--sc_data[SC_REJECTSWORD].val2) <= 0)
@@ -1805,11 +1805,11 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
             if (gc && agit_flag == 0 && class != 1288)  // guardians cannot be damaged during non-woe [Valaris]
                 damage = 0;     // end woe check [Valaris]
             if (g == NULL)
-                damage = 0;     //ƒMƒ‹ƒh–¢‰Á“ü‚È‚çƒ_ƒ��[ƒW–³‚µ
+                damage = 0;     //ギルド未加入�らダメージ無�
             else if ((gc != NULL) && guild_isallied (g, gc))
-                damage = 0;     //Ž©�è—̃Mƒ‹ƒh‚̃Gƒ“ƒy‚È‚çƒ_ƒ��[ƒW–³‚µ
+                damage = 0;     //自�領ギルド�エンペ�らダメージ無�
             else if (g && guild_checkskill (g, GD_APPROVAL) <= 0)
-                damage = 0;     //�³‹KƒMƒ‹ƒh�³”F‚ª‚È‚¢‚ƃ_ƒ��[ƒW–³‚µ
+                damage = 0;     //正�ギルド承�����ダメージ無�
             else if (battle_config.guild_max_castles != 0
                      && guild_checkcastles (g) >=
                      battle_config.guild_max_castles)
@@ -1847,14 +1847,14 @@ int battle_calc_damage (struct block_list *src, struct block_list *bl,
             damage = 3;
     }
 
-    if (md != NULL && md->hp > 0 && damage > 0) // ”½Œ‚‚È‚Ç‚ÌMOBƒXƒLƒ‹”»’è
+    if (md != NULL && md->hp > 0 && damage > 0) // �撃���MOBスキル判定
         mobskill_event (md, flag);
 
     return damage;
 }
 
 /*==========================================
- * �C—ûƒ_ƒ��[ƒW
+ * 修練ダメージ
  *------------------------------------------
  */
 int battle_addmastery (struct map_session_data *sd, struct block_list *target,
@@ -1867,13 +1867,13 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
 
     nullpo_retr (0, sd);
 
-    // ƒf�[ƒ‚ƒ“ƒxƒCƒ“(+3 �` +30) vs •sŽ€ or ˆ«–‚ (Ž€�l‚ÍŠÜ‚ß‚È‚¢�H)
+    // デーモンベイン(+3 〜 +30) vs �死 or 悪魔 (死人�����？)
     if ((skill = pc_checkskill (sd, AL_DEMONBANE)) > 0
         && (battle_check_undead (race, battle_get_elem_type (target))
             || race == 6))
         damage += (skill * 3);
 
-    // ƒr�[ƒXƒgƒxƒCƒ“(+4 �` +40) vs “®•¨ or �©’Ž
+    // ビーストベイン(+4 〜 +40) vs 動物 or 昆虫
     if ((skill = pc_checkskill (sd, HT_BEASTBANE)) > 0
         && (race == 2 || race == 4))
         damage += (skill * 4);
@@ -1884,10 +1884,10 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
         weapon = sd->weapontype2;
     switch (weapon)
     {
-        case 0x01:             // ’ZŒ• (Updated By AppleGirl)
+        case 0x01:             // 短剣 (Updated By AppleGirl)
         case 0x02:             // 1HS
         {
-            // Œ•�C—û(+4 �` +40) •ÐŽèŒ• ’ZŒ•ŠÜ‚Þ
+            // 剣修練(+4 〜 +40) 片手剣 短剣�む
             if ((skill = pc_checkskill (sd, SM_SWORD)) > 0)
             {
                 damage += (skill * 4);
@@ -1896,7 +1896,7 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
         }
         case 0x03:             // 2HS
         {
-            // —¼ŽèŒ•�C—û(+4 �` +40) —¼ŽèŒ•
+            // 両手剣修練(+4 〜 +40) 両手剣
             if ((skill = pc_checkskill (sd, SM_TWOHAND)) > 0)
             {
                 damage += (skill * 4);
@@ -1905,29 +1905,29 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
         }
         case 0x04:             // 1HL
         {
-            // ‘„�C—û(+4 �` +40,+5 �` +50) ‘„
+            // �修練(+4 〜 +40,+5 〜 +50) �
             if ((skill = pc_checkskill (sd, KN_SPEARMASTERY)) > 0)
             {
                 if (!pc_isriding (sd))
-                    damage += (skill * 4);  // ƒyƒR‚É�æ‚Á‚Ä‚È‚¢
+                    damage += (skill * 4);  // ペコ�乗����
                 else
-                    damage += (skill * 5);  // ƒyƒR‚É�æ‚Á‚Ä‚é
+                    damage += (skill * 5);  // ペコ�乗��る
             }
             break;
         }
         case 0x05:             // 2HL
         {
-            // ‘„�C—û(+4 �` +40,+5 �` +50) ‘„
+            // �修練(+4 〜 +40,+5 〜 +50) �
             if ((skill = pc_checkskill (sd, KN_SPEARMASTERY)) > 0)
             {
                 if (!pc_isriding (sd))
-                    damage += (skill * 4);  // ƒyƒR‚É�æ‚Á‚Ä‚È‚¢
+                    damage += (skill * 4);  // ペコ�乗����
                 else
-                    damage += (skill * 5);  // ƒyƒR‚É�æ‚Á‚Ä‚é
+                    damage += (skill * 5);  // ペコ�乗��る
             }
             break;
         }
-        case 0x06:             // •ÐŽè•€
+        case 0x06:             // 片手斧
         {
             if ((skill = pc_checkskill (sd, AM_AXEMASTERY)) > 0)
             {
@@ -1943,25 +1943,25 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
             }
             break;
         }
-        case 0x08:             // ƒ�ƒCƒX
+        case 0x08:             // メイス
         {
-            // ƒ�ƒCƒX�C—û(+3 �` +30) ƒ�ƒCƒX
+            // メイス修練(+3 〜 +30) メイス
             if ((skill = pc_checkskill (sd, PR_MACEMASTERY)) > 0)
             {
                 damage += (skill * 3);
             }
             break;
         }
-        case 0x09:             // ‚È‚µ?
+        case 0x09:             // ��?
             break;
-        case 0x0a:             // �ñ
+        case 0x0a:             // �
             break;
-        case 0x0b:             // ‹|
+        case 0x0b:             // 弓
             break;
-        case 0x00:             // ‘fŽè
+        case 0x00:             // 素手
         case 0x0c:             // Knuckles
         {
-            // “SŒ�(+3 �` +30) ‘fŽè,ƒiƒbƒNƒ‹
+            // 鉄拳(+3 〜 +30) 素手,ナックル
             if ((skill = pc_checkskill (sd, MO_IRONHAND)) > 0)
             {
                 damage += (skill * 3);
@@ -1970,7 +1970,7 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
         }
         case 0x0d:             // Musical Instrument
         {
-            // ŠyŠí‚Ì—û�K(+3 �` +30) ŠyŠí
+            // 楽器�練習(+3 〜 +30) 楽器
             if ((skill = pc_checkskill (sd, BA_MUSICALLESSON)) > 0)
             {
                 damage += (skill * 3);
@@ -1979,7 +1979,7 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
         }
         case 0x0e:             // Dance Mastery
         {
-            // Dance Lesson Skill Effect(+3 damage for every lvl = +30) •Ú
+            // Dance Lesson Skill Effect(+3 damage for every lvl = +30) éž­
             if ((skill = pc_checkskill (sd, DC_DANCINGLESSON)) > 0)
             {
                 damage += (skill * 3);
@@ -1997,10 +1997,10 @@ int battle_addmastery (struct map_session_data *sd, struct block_list *target,
         }
         case 0x10:             // Katars
         {
-            // ƒJƒ^�[ƒ‹�C—û(+3 �` +30) ƒJƒ^�[ƒ‹
+            // カタール修練(+3 〜 +30) カタール
             if ((skill = pc_checkskill (sd, AS_KATAR)) > 0)
             {
-                //ƒ\ƒjƒbƒNƒuƒ��[Žž‚Í•Ê�ˆ—��i1Œ‚‚É•t‚«1/8“K‰ž)
+                //ソニックブロー時�別処�（1撃�付�1/8�応)
                 damage += (skill * 3);
             }
             break;
@@ -2031,7 +2031,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
     short *sc_count;
     short *option, *opt1, *opt2;
 
-    //return‘O‚Ì�ˆ—�‚ª‚ ‚é‚Ì‚Å�î•ñ�o—Í•”‚Ì‚Ý•Ï�X
+    //return��処���る��情報出力部��変更
     if (src == NULL || target == NULL || md == NULL)
     {
         nullpo_info (NLP_MARK);
@@ -2047,7 +2047,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
     opt1 = battle_get_opt1 (src);
     opt2 = battle_get_opt2 (src);
 
-    // ƒ^�[ƒQƒbƒg
+    // ターゲット
     if (target->type == BL_PC)
         tsd = (struct map_session_data *) target;
     else if (target->type == BL_MOB)
@@ -2090,9 +2090,9 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
                 ac_flag = 1;
         }
     }
-    flag = BF_SHORT | BF_WEAPON | BF_NORMAL;    // �UŒ‚‚ÌŽí—Þ‚Ì�Ý’è
+    flag = BF_SHORT | BF_WEAPON | BF_NORMAL;    // 攻撃�種類�設定
 
-    // ‰ñ”𗦌vŽZ�A‰ñ”ð”»’è‚ÍŒã‚Å
+    // 回�率計算�回�判定�後�
     flee = battle_get_flee (target);
     if (battle_config.agi_penaly_type > 0
         || battle_config.vit_penaly_type > 0)
@@ -2131,7 +2131,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
     else
         damage = 0;
     if (skill_num == HW_MAGICCRASHER)
-    {                           /* ƒ}ƒWƒbƒNƒNƒ‰ƒbƒVƒƒ�[‚ÍMATK‚ʼn£‚é */
+    {                           /* マジッククラッシャー�MATK�殴る */
         atkmin = battle_get_matk1 (src);
         atkmax = battle_get_matk2 (src);
     }
@@ -2147,7 +2147,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
         atkmin = atkmax;
 
     if (sc_data != NULL && sc_data[SC_MAXIMIZEPOWER].timer != -1)
-    {                           // ƒ}ƒLƒVƒ}ƒCƒYƒpƒ��[
+    {                           // マキシマイズパワー
         atkmin = atkmax;
     }
 
@@ -2159,7 +2159,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
         if (cri < 1)
             cri = 1;
     }
-    if (t_sc_data != NULL && t_sc_data[SC_SLEEP].timer != -1)   // �‡–°’†‚̓NƒŠƒeƒBƒJƒ‹‚ª”{‚É
+    if (t_sc_data != NULL && t_sc_data[SC_SLEEP].timer != -1)   // �眠中�クリティカル���
         cri <<= 1;
 
     if (ac_flag)
@@ -2176,8 +2176,8 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
     if (tsd && tsd->critical_def)
         cri = cri * (100 - tsd->critical_def) / 100;
 
-    if ((skill_num == 0 || skill_num == KN_AUTOCOUNTER) && skill_lv >= 0 && battle_config.enemy_critical && (MRAND (1000)) < cri)   // ”»’è�iƒXƒLƒ‹‚Ì�ê�‡‚Í–³Ž‹�j
-        // “G‚Ì”»’è
+    if ((skill_num == 0 || skill_num == KN_AUTOCOUNTER) && skill_lv >= 0 && battle_config.enemy_critical && (MRAND (1000)) < cri)   // 判定（スキル�場��無視）
+        // 敵�判定
     {
         damage += atkmax;
         type = 0x0a;
@@ -2190,20 +2190,20 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
             damage += atkmin + MRAND ((atkmax - atkmin + 1));
         else
             damage += atkmin;
-        // ƒXƒLƒ‹�C�³‚P�i�UŒ‚—Í”{‰»Œn�j
-        // ƒI�[ƒo�[ƒgƒ‰ƒXƒg(+5% �` +25%),‘¼�UŒ‚ŒnƒXƒLƒ‹‚Ì�ê�‡‚±‚±‚Å•â�³
-        // ƒoƒbƒVƒ…,ƒ}ƒOƒiƒ€ƒuƒŒƒCƒN,
-        // ƒ{�[ƒŠƒ“ƒOƒoƒbƒVƒ…,ƒXƒsƒAƒu�[ƒ�ƒ‰ƒ“,ƒuƒ‰ƒ“ƒfƒBƒbƒVƒ…ƒXƒsƒA,ƒXƒsƒAƒXƒ^ƒbƒu,
-        // ƒ�ƒ}�[ƒiƒCƒg,ƒJ�[ƒgƒŒƒ{ƒŠƒ…�[ƒVƒ‡ƒ“
-        // ƒ_ƒuƒ‹ƒXƒgƒŒƒCƒtƒBƒ“ƒO,ƒAƒ��[ƒVƒƒƒ��[,ƒ`ƒƒ�[ƒWƒAƒ��[,
-        // ƒ\ƒjƒbƒNƒuƒ��[
+        // スキル修正１（攻撃力�化系）
+        // オー�ートラスト(+5% 〜 +25%),他攻撃系スキル�場����補正
+        // �ッシュ,マグナムブレイク,
+        // ボーリング�ッシュ,スピアブーメラン,ブランディッシュスピア,スピアスタッブ,
+        // メマーナイト,カートレボリューション
+        // ダブルストレイフィング,アローシャワー,�ャージアロー,
+        // ソニックブロー
         if (sc_data)
-        {                       //�ó‘ÔˆÙ�í’†‚̃_ƒ��[ƒW’ljÁ
-            if (sc_data[SC_OVERTHRUST].timer != -1) // ƒI�[ƒo�[ƒgƒ‰ƒXƒg
+        {                       //状態異常中�ダメージ追加
+            if (sc_data[SC_OVERTHRUST].timer != -1) // オー�ートラスト
                 damage += damage * (5 * sc_data[SC_OVERTHRUST].val1) / 100;
-            if (sc_data[SC_TRUESIGHT].timer != -1)  // ƒgƒDƒ‹�[ƒTƒCƒg
+            if (sc_data[SC_TRUESIGHT].timer != -1)  // トゥルーサイト
                 damage += damage * (2 * sc_data[SC_TRUESIGHT].val1) / 100;
-            if (sc_data[SC_BERSERK].timer != -1)    // ƒo�[ƒT�[ƒN
+            if (sc_data[SC_BERSERK].timer != -1)    // �ーサーク
                 damage += damage * 50 / 100;
         }
 
@@ -2216,44 +2216,44 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
             flag = (flag & ~BF_SKILLMASK) | BF_SKILL;
             switch (skill_num)
             {
-                case SM_BASH:  // ƒoƒbƒVƒ…
+                case SM_BASH:  // �ッシュ
                     damage = damage * (100 + 30 * skill_lv) / 100;
                     hitrate = (hitrate * (100 + 5 * skill_lv)) / 100;
                     break;
-                case SM_MAGNUM:    // ƒ}ƒOƒiƒ€ƒuƒŒƒCƒN
+                case SM_MAGNUM:    // マグナムブレイク
                     damage =
                         damage * (5 * skill_lv + (wflag) ? 65 : 115) / 100;
                     break;
-                case MC_MAMMONITE: // ƒ�ƒ}�[ƒiƒCƒg
+                case MC_MAMMONITE: // メマーナイト
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     break;
-                case AC_DOUBLE:    // ƒ_ƒuƒ‹ƒXƒgƒŒƒCƒtƒBƒ“ƒO
+                case AC_DOUBLE:    // ダブルストレイフィング
                     damage = damage * (180 + 20 * skill_lv) / 100;
                     div_ = 2;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case AC_SHOWER:    // ƒAƒ��[ƒVƒƒƒ��[
+                case AC_SHOWER:    // アローシャワー
                     damage = damage * (75 + 5 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case AC_CHARGEARROW:   // ƒ`ƒƒ�[ƒWƒAƒ��[
+                case AC_CHARGEARROW:   // �ャージアロー
                     damage = damage * 150 / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case KN_PIERCE:    // ƒsƒA�[ƒX
+                case KN_PIERCE:    // ピアース
                     damage = damage * (100 + 10 * skill_lv) / 100;
                     hitrate = hitrate * (100 + 5 * skill_lv) / 100;
                     div_ = t_size + 1;
                     damage *= div_;
                     break;
-                case KN_SPEARSTAB: // ƒXƒsƒAƒXƒ^ƒu
+                case KN_SPEARSTAB: // スピアスタブ
                     damage = damage * (100 + 15 * skill_lv) / 100;
                     break;
-                case KN_SPEARBOOMERANG:    // ƒXƒsƒAƒu�[ƒ�ƒ‰ƒ“
+                case KN_SPEARBOOMERANG:    // スピアブーメラン
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case KN_BRANDISHSPEAR: // ƒuƒ‰ƒ“ƒfƒBƒbƒVƒ…ƒXƒsƒA
+                case KN_BRANDISHSPEAR: // ブランディッシュスピア
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     if (skill_lv > 3 && wflag == 1)
                         damage2 += damage / 2;
@@ -2270,7 +2270,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
                     damage += damage2;
                     blewcount = 0;
                     break;
-                case KN_BOWLINGBASH:   // ƒ{ƒEƒŠƒ“ƒOƒoƒbƒVƒ…
+                case KN_BOWLINGBASH:   // ボウリング�ッシュ
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     blewcount = 0;
                     break;
@@ -2281,25 +2281,25 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
                         hitrate = 1000000;
                     flag = (flag & ~BF_SKILLMASK) | BF_NORMAL;
                     break;
-                case AS_SONICBLOW: // ƒ\ƒjƒbƒNƒuƒ�ƒE
+                case AS_SONICBLOW: // ソニックブロウ
                     damage = damage * (300 + 50 * skill_lv) / 100;
                     div_ = 8;
                     break;
-                case TF_SPRINKLESAND:  // �»‚Ü‚«
+                case TF_SPRINKLESAND:  // 砂��
                     damage = damage * 125 / 100;
                     break;
-                case MC_CARTREVOLUTION:    // ƒJ�[ƒgƒŒƒ{ƒŠƒ…�[ƒVƒ‡ƒ“
+                case MC_CARTREVOLUTION:    // カートレボリューション
                     damage = (damage * 150) / 100;
                     break;
-                    // ˆÈ‰ºMOB
-                case NPC_COMBOATTACK:  // ‘½’i�UŒ‚
+                    // 以下MOB
+                case NPC_COMBOATTACK:  // 多段攻撃
                     div_ = skill_get_num (skill_num, skill_lv);
                     damage *= div_;
                     break;
-                case NPC_RANDOMATTACK: // ƒ‰ƒ“ƒ_ƒ€ATK�UŒ‚
+                case NPC_RANDOMATTACK: // ランダムATK攻撃
                     damage = damage * (MPRAND (50, 150)) / 100;
                     break;
-                    // ‘®�«�UŒ‚�i“K“–�j
+                    // 属性攻撃（�当）
                 case NPC_WATERATTACK:
                 case NPC_GROUNDATTACK:
                 case NPC_FIREATTACK:
@@ -2319,46 +2319,46 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
                 case NPC_PIERCINGATT:
                     flag = (flag & ~BF_RANGEMASK) | BF_SHORT;
                     break;
-                case RG_BACKSTAP:  // ƒoƒbƒNƒXƒ^ƒu
+                case RG_BACKSTAP:  // �ックスタブ
                     damage = damage * (300 + 40 * skill_lv) / 100;
                     hitrate = 1000000;
                     break;
-                case RG_RAID:  // ƒTƒvƒ‰ƒCƒYƒAƒ^ƒbƒN
+                case RG_RAID:  // サプライズアタック
                     damage = damage * (100 + 40 * skill_lv) / 100;
                     break;
-                case RG_INTIMIDATE:    // ƒCƒ“ƒeƒBƒ~ƒfƒCƒg
+                case RG_INTIMIDATE:    // インティミデイト
                     damage = damage * (100 + 30 * skill_lv) / 100;
                     break;
-                case CR_SHIELDCHARGE:  // ƒV�[ƒ‹ƒhƒ`ƒƒ�[ƒW
+                case CR_SHIELDCHARGE:  // シールド�ャージ
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_SHORT;
                     s_ele = 0;
                     break;
-                case CR_SHIELDBOOMERANG:   // ƒV�[ƒ‹ƒhƒu�[ƒ�ƒ‰ƒ“
+                case CR_SHIELDBOOMERANG:   // シールドブーメラン
                     damage = damage * (100 + 30 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     s_ele = 0;
                     break;
-                case CR_HOLYCROSS: // ƒz�[ƒŠ�[ƒNƒ�ƒX
+                case CR_HOLYCROSS: // ホーリークロス
                     damage = damage * (100 + 35 * skill_lv) / 100;
                     div_ = 2;
                     break;
                 case CR_GRANDCROSS:
                     hitrate = 1000000;
                     break;
-                case AM_DEMONSTRATION: // ƒfƒ‚ƒ“ƒXƒgƒŒ�[ƒVƒ‡ƒ“
+                case AM_DEMONSTRATION: // デモンストレーション
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     break;
-                case AM_ACIDTERROR:    // ƒAƒVƒbƒhƒeƒ‰�[
+                case AM_ACIDTERROR:    // アシッドテラー
                     damage = damage * (100 + 40 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 40 * skill_lv) / 100;
                     break;
-                case MO_FINGEROFFENSIVE:   //Žw’e
+                case MO_FINGEROFFENSIVE:   //指弾
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     div_ = 1;
                     break;
-                case MO_INVESTIGATE:   // ”­ ™¤
+                case MO_INVESTIGATE:   // 発 �
                     if (def1 < 1000000)
                         damage =
                             damage * (100 + 75 * skill_lv) / 100 * (def1 +
@@ -2367,61 +2367,61 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
                     hitrate = 1000000;
                     s_ele = 0;
                     break;
-                case MO_EXTREMITYFIST: // ˆ¢�C—…”e–PŒ�
+                case MO_EXTREMITYFIST: // 阿修羅覇鳳拳
                     damage = damage * 8 + 250 + (skill_lv * 150);
                     hitrate = 1000000;
                     s_ele = 0;
                     break;
-                case MO_CHAINCOMBO:    // ˜A‘Å�¶
+                case MO_CHAINCOMBO:    // 連打掌
                     damage = damage * (150 + 50 * skill_lv) / 100;
                     div_ = 4;
                     break;
-                case BA_MUSICALSTRIKE: // ƒ~ƒ…�[ƒWƒJƒ‹ƒXƒgƒ‰ƒCƒN
+                case BA_MUSICALSTRIKE: // ミュージカルストライク
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case DC_THROWARROW:    // –‚¿
+                case DC_THROWARROW:    // 矢撃�
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case MO_COMBOFINISH:   // –Ò—´Œ�
+                case MO_COMBOFINISH:   // 猛�拳
                     damage = damage * (240 + 60 * skill_lv) / 100;
                     break;
-                case CH_TIGERFIST: // •šŒÕŒ�
+                case CH_TIGERFIST: // �虎拳
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     break;
-                case CH_CHAINCRUSH:    // ˜A’Œ•öŒ‚
+                case CH_CHAINCRUSH:    // 連柱崩撃
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     div_ = skill_get_num (skill_num, skill_lv);
                     break;
-                case CH_PALMSTRIKE:    // –ÒŒÕ�d”hŽR
+                case CH_PALMSTRIKE:    // 猛虎硬派山
                     damage = damage * (50 + 100 * skill_lv) / 100;
                     break;
-                case LK_SPIRALPIERCE:  /* ƒXƒpƒCƒ‰ƒ‹ƒsƒA�[ƒX */
-                    damage = damage * (100 + 50 * skill_lv) / 100;  //‘�‰Á—Ê‚ª•ª‚©‚ç‚È‚¢‚Ì‚Å“K“–‚É
+                case LK_SPIRALPIERCE:  /* スパイラルピアース */
+                    damage = damage * (100 + 50 * skill_lv) / 100;  //増加��分�ら�����当�
                     div_ = 5;
                     if (tsd)
                         tsd->canmove_tick = gettick () + 1000;
                     else if (tmd)
                         tmd->canmove_tick = gettick () + 1000;
                     break;
-                case LK_HEADCRUSH: /* ƒwƒbƒhƒNƒ‰ƒbƒVƒ… */
+                case LK_HEADCRUSH: /* ヘッドクラッシュ */
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     break;
-                case LK_JOINTBEAT: /* ƒWƒ‡ƒCƒ“ƒgƒr�[ƒg */
+                case LK_JOINTBEAT: /* ジョイントビート */
                     damage = damage * (50 + 10 * skill_lv) / 100;
                     break;
-                case ASC_METEORASSAULT:    /* ƒ�ƒeƒIƒAƒTƒ‹ƒg */
+                case ASC_METEORASSAULT:    /* メテオアサルト */
                     damage = damage * (40 + 40 * skill_lv) / 100;
                     break;
-                case SN_SHARPSHOOTING: /* ƒVƒƒ�[ƒvƒVƒ…�[ƒeƒBƒ“ƒO */
+                case SN_SHARPSHOOTING: /* シャープシューティング */
                     damage += damage * (30 * skill_lv) / 100;
                     break;
-                case CG_ARROWVULCAN:   /* ƒAƒ��[ƒoƒ‹ƒJƒ“ */
+                case CG_ARROWVULCAN:   /* アロー�ルカン */
                     damage = damage * (160 + 40 * skill_lv) / 100;
                     div_ = 9;
                     break;
-                case AS_SPLASHER:  /* ƒxƒiƒ€ƒXƒvƒ‰ƒbƒVƒƒ�[ */
+                case AS_SPLASHER:  /* ベナムスプラッシャー */
                     damage = damage * (200 + 20 * skill_lv) / 100;
                     break;
             }
@@ -2429,11 +2429,11 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
 
         if (skill_num != NPC_CRITICALSLASH)
         {
-            // ‘Î �Û‚Ì–hŒä—Í‚É‚æ‚éƒ_ƒ��[ƒW‚ÌŒ¸�­
-            // ƒfƒBƒoƒCƒ“ƒvƒ�ƒeƒNƒVƒ‡ƒ“�i‚±‚±‚Å‚¢‚¢‚Ì‚©‚È�H�j
+            // 対 象�防御力�よるダメージ�減少
+            // ディ�インプロテクション（��������？）
             if (skill_num != MO_INVESTIGATE && skill_num != MO_EXTREMITYFIST
                 && skill_num != KN_AUTOCOUNTER && def1 < 1000000)
-            {                   //DEF, VIT–³Ž‹
+            {                   //DEF, VIT無視
                 int  t_def;
                 target_count =
                     1 + battle_counttargeted (target, src,
@@ -2513,17 +2513,17 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
         }
     }
 
-    // 0–¢–ž‚¾‚Á‚½�ê�‡1‚É•â�³
+    // 0未満���場�1�補正
     if (damage < 1)
         damage = 1;
 
-    // ‰ñ”ð�C�³
+    // 回�修正
     if (hitrate < 1000000)
         hitrate = ((hitrate > 95) ? 95 : ((hitrate < 5) ? 5 : hitrate));
-    if (hitrate < 1000000 &&    // •K’†�UŒ‚
-        (t_sc_data != NULL && (t_sc_data[SC_SLEEP].timer != -1 ||   // �‡–°‚Í•K’†
-                               t_sc_data[SC_STAN].timer != -1 ||    // ƒXƒ^ƒ“‚Í•K’†
-                               t_sc_data[SC_FREEZE].timer != -1 || (t_sc_data[SC_STONE].timer != -1 && t_sc_data[SC_STONE].val2 == 0))))    // “€Œ‹‚Í•K’†
+    if (hitrate < 1000000 &&    // 必中攻撃
+        (t_sc_data != NULL && (t_sc_data[SC_SLEEP].timer != -1 ||   // �眠�必中
+                               t_sc_data[SC_STAN].timer != -1 ||    // スタン�必中
+                               t_sc_data[SC_FREEZE].timer != -1 || (t_sc_data[SC_STONE].timer != -1 && t_sc_data[SC_STONE].val2 == 0))))    // ���必中
         hitrate = 1000000;
     if (type == 0 && MRAND (100) >= hitrate)
     {
@@ -2538,8 +2538,8 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
     if (tsd)
     {
         int  cardfix = 100, i;
-        cardfix = cardfix * (100 - tsd->subele[s_ele]) / 100;   // ‘® �«‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
-        cardfix = cardfix * (100 - tsd->subrace[s_race]) / 100; // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
+        cardfix = cardfix * (100 - tsd->subele[s_ele]) / 100;   // 属 性�よるダメージ�性
+        cardfix = cardfix * (100 - tsd->subrace[s_race]) / 100; // 種��よるダメージ�性
         if (mob_db[md->class].mode & 0x20)
             cardfix = cardfix * (100 - tsd->subrace[10]) / 100;
         else
@@ -2567,7 +2567,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
             damage = damage * cardfix / 100;
     }
     if (t_sc_data && t_sc_data[SC_ASSUMPTIO].timer != -1)
-    {                           //ƒAƒVƒƒƒ“ƒvƒeƒBƒI
+    {                           //アシャンプティオ
         if (!map[target->m].flag.pvp)
             damage = damage / 3;
         else
@@ -2577,19 +2577,19 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
     if (damage < 0)
         damage = 0;
 
-    // ‘® �«‚Ì“K—p
+    // 属 性��用
     if (!((battle_config.mob_ghostring_fix == 1) && (battle_get_element (target) == 8) && (target->type == BL_PC))) // [MouseJstr]
         if (skill_num != 0 || s_ele != 0
             || !battle_config.mob_attack_attr_none)
             damage =
                 battle_attr_fix (damage, s_ele, battle_get_element (target));
 
-    if (sc_data && sc_data[SC_AURABLADE].timer != -1)   /* ƒI�[ƒ‰ƒuƒŒ�[ƒh •K’† */
+    if (sc_data && sc_data[SC_AURABLADE].timer != -1)   /* オーラブレード 必中 */
         damage += sc_data[SC_AURABLADE].val1 * 10;
-    if (skill_num == PA_PRESSURE)   /* ƒvƒŒƒbƒVƒƒ�[ •K’†? */
+    if (skill_num == PA_PRESSURE)   /* プレッシャー 必中? */
         damage = 700 + 100 * skill_lv;
 
-    // ƒCƒ“ƒxƒiƒ€�C�³
+    // インベナム修正
     if (skill_num == TF_POISON)
     {
         damage =
@@ -2601,7 +2601,7 @@ static struct Damage battle_calc_mob_weapon_attack (struct block_list *src,
         damage = battle_attr_fix (damage, 0, battle_get_element (target));
     }
 
-    // Š®‘S‰ñ”ð‚Ì”»’è
+    // 完全回��判定
     if (skill_num == 0 && skill_lv >= 0 && tsd != NULL
         && MRAND (1000) < battle_get_flee2 (target))
     {
@@ -2664,7 +2664,7 @@ int battle_is_unarmed (struct block_list *bl)
 
 /*
  * =========================================================================
- * PC‚Ì•�Ší‚É‚æ‚é�UŒ‚
+ * PC�武器�よる攻撃
  *-------------------------------------------------------------------------
  */
 static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
@@ -2688,13 +2688,13 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     struct status_change *sc_data, *t_sc_data;
     short *sc_count;
     short *option, *opt1, *opt2;
-    int  atkmax_ = 0, atkmin_ = 0, s_ele_;  //“ñ“�—¬—p
+    int  atkmax_ = 0, atkmin_ = 0, s_ele_;  //二刀�用
     int  watk, watk_, cardfix, t_ele;
     int  da = 0, i, t_class, ac_flag = 0;
     int  idef_flag = 0, idef_flag_ = 0;
     int  target_distance;
 
-    //return‘O‚Ì�ˆ—�‚ª‚ ‚é‚Ì‚Å�î•ñ�o—Í•”‚Ì‚Ý•Ï�X
+    //return��処���る��情報出力部��変更
     if (src == NULL || target == NULL || sd == NULL)
     {
         nullpo_info (NLP_MARK);
@@ -2702,31 +2702,31 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         return wd;
     }
 
-    // ƒAƒ^ƒbƒJ�[
-    s_race = battle_get_race (src); //Ží‘°
-    s_ele = battle_get_attack_element (src);    //‘®�«
-    s_ele_ = battle_get_attack_element2 (src);  //�¶Žè‘®�«
-    sc_data = battle_get_sc_data (src); //ƒXƒe�[ƒ^ƒXˆÙ�í
-    sc_count = battle_get_sc_count (src);   //ƒXƒe�[ƒ^ƒXˆÙ�í‚Ì�”
-    option = battle_get_option (src);   //‘é‚Æ‚©ƒyƒR‚Æ‚©ƒJ�[ƒg‚Æ‚©
-    opt1 = battle_get_opt1 (src);   //�Ή»�A“€Œ‹�AƒXƒ^ƒ“�A�‡–°�AˆÃˆÅ
-    opt2 = battle_get_opt2 (src);   //“Å�AŽô‚¢�A’¾–Ù�AˆÃˆÅ�H
-
-    if (skill_num != CR_GRANDCROSS) //ƒOƒ‰ƒ“ƒhƒNƒ�ƒX‚Å‚È‚¢‚È‚ç
-        sd->state.attack_type = BF_WEAPON;  //�UŒ‚ƒ^ƒCƒv‚Í•�Ší�UŒ‚
-
-    // ƒ^�[ƒQƒbƒg
-    if (target->type == BL_PC)  //‘Î�Û‚ªPC‚È‚ç
-        tsd = (struct map_session_data *) target;   //tsd‚É‘ã“ü(tmd‚ÍNULL)
-    else if (target->type == BL_MOB)    //‘Î�Û‚ªMob‚È‚ç
-        tmd = (struct mob_data *) target;   //tmd‚É‘ã“ü(tsd‚ÍNULL)
-    t_race = battle_get_race (target);  //‘Î�Û‚ÌŽí‘°
-    t_ele = battle_get_elem_type (target);  //‘Î�Û‚Ì‘®�«
-    t_size = battle_get_size (target);  //‘Î�ۂ̃TƒCƒY
-    t_mode = battle_get_mode (target);  //‘Î�Û‚ÌMode
-    t_sc_data = battle_get_sc_data (target);    //‘Î�ۂ̃Xƒe�[ƒ^ƒXˆÙ�í
-
-//ƒI�[ƒgƒJƒEƒ“ƒ^�[�ˆ—�‚±‚±‚©‚ç
+    // アタッカー
+    s_race = battle_get_race (src); //種�
+    s_ele = battle_get_attack_element (src);    //属性
+    s_ele_ = battle_get_attack_element2 (src);  //左手属性
+    sc_data = battle_get_sc_data (src); //ステータス異常
+    sc_count = battle_get_sc_count (src);   //ステータス異常�数
+    option = battle_get_option (src);   //鷹��ペコ��カート��
+    opt1 = battle_get_opt1 (src);   //石化����スタン��眠�暗闇
+    opt2 = battle_get_opt2 (src);   //毒�呪��沈黙�暗闇？
+
+    if (skill_num != CR_GRANDCROSS) //グランドクロス����ら
+        sd->state.attack_type = BF_WEAPON;  //攻撃タイプ�武器攻撃
+
+    // ターゲット
+    if (target->type == BL_PC)  //対象�PC�ら
+        tsd = (struct map_session_data *) target;   //tsd�代入(tmd�NULL)
+    else if (target->type == BL_MOB)    //対象�Mob�ら
+        tmd = (struct mob_data *) target;   //tmd�代入(tsd�NULL)
+    t_race = battle_get_race (target);  //対象�種�
+    t_ele = battle_get_elem_type (target);  //対象�属性
+    t_size = battle_get_size (target);  //対象�サイズ
+    t_mode = battle_get_mode (target);  //対象�Mode
+    t_sc_data = battle_get_sc_data (target);    //対象�ステータス異常
+
+//オートカウンター処����ら
     if ((skill_num == 0
          || (target->type == BL_PC && battle_config.pc_auto_counter_type & 2)
          || (target->type == BL_MOB
@@ -2735,57 +2735,57 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     {
         if (skill_num != CR_GRANDCROSS && t_sc_data
             && t_sc_data[SC_AUTOCOUNTER].timer != -1)
-        {                       //ƒOƒ‰ƒ“ƒhƒNƒ�ƒX‚Å‚È‚­�A‘Î�Û‚ªƒI�[ƒgƒJƒEƒ“ƒ^�[�ó‘Ô‚Ì�ê�‡
+        {                       //グランドクロス����対象�オートカウンター状態�場�
             int  dir = map_calc_dir (src, target->x, target->y), t_dir =
                 battle_get_dir (target);
             int  dist = distance (src->x, src->y, target->x, target->y);
             if (dist <= 0 || map_check_dir (dir, t_dir))
-            {                   //‘Î�Û‚Æ‚Ì‹——£‚ª0ˆÈ‰º�A‚Ü‚½‚Í‘Î�Û‚Ì�³–Ê�H
+            {                   //対象���離�0以下����対象�正�？
                 memset (&wd, 0, sizeof (wd));
                 t_sc_data[SC_AUTOCOUNTER].val3 = 0;
                 t_sc_data[SC_AUTOCOUNTER].val4 = 1;
                 if (sc_data && sc_data[SC_AUTOCOUNTER].timer == -1)
-                {               //Ž©•ª‚ªƒI�[ƒgƒJƒEƒ“ƒ^�[�ó‘Ô
+                {               //自分�オートカウンター状態
                     int  range = battle_get_range (target);
-                    if ((target->type == BL_PC && ((struct map_session_data *) target)->status.weapon != 11 && dist <= range + 1) ||    //‘Î�Û‚ªPC‚Å•�Ší‚ª‹|–î‚Å‚È‚­ŽË’ö“à
-                        (target->type == BL_MOB && range <= 3 && dist <= range + 1))    //‚Ü‚½‚Í‘Î�Û‚ªMob‚ÅŽË’ö‚ª3ˆÈ‰º‚ÅŽË’ö“à
+                    if ((target->type == BL_PC && ((struct map_session_data *) target)->status.weapon != 11 && dist <= range + 1) ||    //対象�PC�武器�弓矢���射程内
+                        (target->type == BL_MOB && range <= 3 && dist <= range + 1))    //���対象�Mob�射程�3以下�射程内
                         t_sc_data[SC_AUTOCOUNTER].val3 = src->id;
                 }
-                return wd;      //ƒ_ƒ��[ƒW�\‘¢‘Ì‚ð•Ô‚µ‚Ä�I—¹
+                return wd;      //ダメージ構造体を返��終了
             }
             else
                 ac_flag = 1;
         }
     }
-//ƒI�[ƒgƒJƒEƒ“ƒ^�[�ˆ—�‚±‚±‚Ü‚Å
+//オートカウンター処�����
 
-    flag = BF_SHORT | BF_WEAPON | BF_NORMAL;    // �UŒ‚‚ÌŽí—Þ‚Ì�Ý’è
+    flag = BF_SHORT | BF_WEAPON | BF_NORMAL;    // 攻撃�種類�設定
 
-    // ‰ñ”𗦌vŽZ�A‰ñ”ð”»’è‚ÍŒã‚Å
+    // 回�率計算�回�判定�後�
     flee = battle_get_flee (target);
-    if (battle_config.agi_penaly_type > 0 || battle_config.vit_penaly_type > 0) //AGI�AVITƒyƒiƒ‹ƒeƒB�ݒ肪—LŒø
-        target_count += battle_counttargeted (target, src, battle_config.agi_penaly_count_lv);  //‘Î�Û‚Ì�”‚ðŽZ�o
+    if (battle_config.agi_penaly_type > 0 || battle_config.vit_penaly_type > 0) //AGI�VITペナルティ設定�有効
+        target_count += battle_counttargeted (target, src, battle_config.agi_penaly_count_lv);  //対象�数を算出
     if (battle_config.agi_penaly_type > 0)
     {
         if (target_count >= battle_config.agi_penaly_count)
-        {                       //ƒyƒiƒ‹ƒeƒB�Ý’è‚æ‚è‘Î�Û‚ª‘½‚¢
-            if (battle_config.agi_penaly_type == 1) //‰ñ”𗦂ªagi_penaly_num%‚¸‚ÂŒ¸�­
+        {                       //ペナルティ設定より対象�多�
+            if (battle_config.agi_penaly_type == 1) //回�率�agi_penaly_num%��減少
                 flee =
                     (flee *
                      (100 -
                       (target_count -
                        (battle_config.agi_penaly_count -
                         1)) * battle_config.agi_penaly_num)) / 100;
-            else if (battle_config.agi_penaly_type == 2)    //‰ñ”𗦂ªagi_penaly_num•ªŒ¸�­
+            else if (battle_config.agi_penaly_type == 2)    //回�率�agi_penaly_num分減少
                 flee -=
                     (target_count -
                      (battle_config.agi_penaly_count -
                       1)) * battle_config.agi_penaly_num;
             if (flee < 1)
-                flee = 1;       //‰ñ”𗦂Í�Å’á‚Å‚à1
+                flee = 1;       //回�率�最低�も1
         }
     }
-    hitrate = battle_get_hit (src) - flee + 80; //–½’†—¦ŒvŽZ
+    hitrate = battle_get_hit (src) - flee + 80; //命中率計算
 
     {                           // [fate] Reduce hit chance by distance
         int  dx = abs (src->x - target->x);
@@ -2801,18 +2801,18 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     dex = battle_get_dex (src); //DEX
     luk = battle_get_luk (src); //LUK
     watk = battle_get_atk (src);    //ATK
-    watk_ = battle_get_atk_ (src);  //ATK�¶Žè
+    watk_ = battle_get_atk_ (src);  //ATK左手
 
     type = 0;                   // normal
     div_ = 1;                   // single attack
 
     if (skill_num == HW_MAGICCRASHER)
-    {                           /* ƒ}ƒWƒbƒNƒNƒ‰ƒbƒVƒƒ�[‚ÍMATK‚ʼn£‚é */
-        damage = damage2 = battle_get_matk1 (src);  //damega,damega2�‰“o�ê�Abase_atk‚̎擾
+    {                           /* マジッククラッシャー�MATK�殴る */
+        damage = damage2 = battle_get_matk1 (src);  //damega,damega2�登場�base_atk��得
     }
     else
     {
-        damage = damage2 = battle_get_baseatk (&sd->bl);    //damega,damega2�‰“o�ê�Abase_atk‚̎擾
+        damage = damage2 = battle_get_baseatk (&sd->bl);    //damega,damega2�登場�base_atk��得
     }
     if (sd->attackrange > 2)
     {                           // [fate] ranged weapon?
@@ -2827,8 +2827,8 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                         sd->attackrange)) >> 8;
     }
 
-    atkmin = atkmin_ = dex;     //�Å’áATK‚ÍDEX‚Å�‰Šú‰»�H
-    sd->state.arrow_atk = 0;    //arrow_atk�‰Šú‰»
+    atkmin = atkmin_ = dex;     //最低ATK�DEX��期化？
+    sd->state.arrow_atk = 0;    //arrow_atk�期化
     if (sd->equip_index[9] >= 0 && sd->inventory_data[sd->equip_index[9]])
         atkmin =
             atkmin * (80 +
@@ -2839,22 +2839,22 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                        sd->inventory_data[sd->equip_index[8]]->wlv * 20) /
             100;
     if (sd->status.weapon == 11)
-    {                           //•�Ší‚ª‹|–î‚Ì�ê�‡
-        atkmin = watk * ((atkmin < watk) ? atkmin : watk) / 100;    //‹|—p�Å’áATKŒvŽZ
-        flag = (flag & ~BF_RANGEMASK) | BF_LONG;    //‰“‹——£�UŒ‚ƒtƒ‰ƒO‚ð—LŒø
-        if (sd->arrow_ele > 0)  //‘®�«–î‚È‚ç‘®�«‚ð–î‚Ì‘®�«‚É•Ï�X
+    {                           //武器�弓矢�場�
+        atkmin = watk * ((atkmin < watk) ? atkmin : watk) / 100;    //弓用最低ATK計算
+        flag = (flag & ~BF_RANGEMASK) | BF_LONG;    //��離攻撃フラグを有効
+        if (sd->arrow_ele > 0)  //属性矢�ら属性を矢�属性�変更
             s_ele = sd->arrow_ele;
-        sd->state.arrow_atk = 1;    //arrow_atk—LŒø‰»
+        sd->state.arrow_atk = 1;    //arrow_atk有効化
     }
 
-    // ƒTƒCƒY�C�³
-    // ƒyƒR‹R�悵‚Ä‚¢‚Ä�A‘„‚Å�UŒ‚‚µ‚½�ê�‡‚Í’†Œ^‚̃TƒCƒY�C�³‚ð100‚É‚·‚é
-    // ƒEƒFƒ|ƒ“ƒp�[ƒtƒFƒNƒVƒ‡ƒ“,ƒhƒŒƒCƒNC
+    // サイズ修正
+    // ペコ騎乗�������攻撃��場��中型�サイズ修正を100��る
+    // ウェ�ンパーフェクション,ドレイクC
     if (((sd->special_state.no_sizefix)
          || (pc_isriding (sd)
              && (sd->status.weapon == 4 || sd->status.weapon == 5)
              && t_size == 1) || skill_num == MO_EXTREMITYFIST))
-    {                           //ƒyƒR‹R�悵‚Ä‚¢‚Ä�A‘„‚Å’†Œ^‚ð�UŒ‚
+    {                           //ペコ騎乗�������中型を攻撃
         atkmax = watk;
         atkmax_ = watk_;
     }
@@ -2867,23 +2867,23 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     }
     if ((sc_data != NULL && sc_data[SC_WEAPONPERFECTION].timer != -1)
         || (sd->special_state.no_sizefix))
-    {                           // ƒEƒFƒ|ƒ“ƒp�[ƒtƒFƒNƒVƒ‡ƒ“ || ƒhƒŒƒCƒNƒJ�[ƒh
+    {                           // ウェ�ンパーフェクション || ドレイクカード
         atkmax = watk;
         atkmax_ = watk_;
     }
 
     if (atkmin > atkmax && !(sd->state.arrow_atk))
-        atkmin = atkmax;        //‹|‚Í�ŒႪ�ã‰ñ‚é�ê�‡‚ ‚è
+        atkmin = atkmax;        //弓�最低�上回る場��り
     if (atkmin_ > atkmax_)
         atkmin_ = atkmax_;
 
     if (sc_data != NULL && sc_data[SC_MAXIMIZEPOWER].timer != -1)
-    {                           // ƒ}ƒLƒVƒ}ƒCƒYƒpƒ��[
+    {                           // マキシマイズパワー
         atkmin = atkmax;
         atkmin_ = atkmax_;
     }
 
-    //ƒ_ƒuƒ‹ƒAƒ^ƒbƒN”»’è
+    //ダブルアタック判定
     if (sd->weapontype1 == 0x01)
     {
         if (skill_num == 0 && skill_lv >= 0
@@ -2891,7 +2891,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             da = (MRAND (100) < (skill * 5)) ? 1 : 0;
     }
 
-    //ŽO’i�¶
+    //三段掌
     if (skill_num == 0 && skill_lv >= 0
         && (skill = pc_checkskill (sd, MO_TRIPLEATTACK)) > 0
         && sd->status.weapon <= 16 && !sd->state.arrow_atk)
@@ -2902,24 +2902,24 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     if (sd->double_rate > 0 && da == 0 && skill_num == 0 && skill_lv >= 0)
         da = (MRAND (100) < sd->double_rate) ? 1 : 0;
 
-    // ‰ß�è�¸˜Bƒ{�[ƒiƒX
+    // �剰精錬ボーナス
     if (sd->overrefine > 0)
         damage += MPRAND (1, sd->overrefine);
     if (sd->overrefine_ > 0)
         damage2 += MPRAND (1, sd->overrefine_);
 
     if (da == 0)
-    {                           //ƒ_ƒuƒ‹ƒAƒ^ƒbƒN‚ª”­“®‚µ‚Ä‚¢‚È‚¢
-        // ƒNƒŠƒeƒBƒJƒ‹ŒvŽZ
+    {                           //ダブルアタック�発動�����
+        // クリティカル計算
         cri = battle_get_critical (src);
 
         if (sd->state.arrow_atk)
             cri += sd->arrow_cri;
         if (sd->status.weapon == 16)
-            // ƒJƒ^�[ƒ‹‚Ì�ê�‡�AƒNƒŠƒeƒBƒJƒ‹‚ð”{‚É
+            // カタール�場��クリティカルを��
             cri <<= 1;
         cri -= battle_get_luk (target) * 3;
-        if (t_sc_data != NULL && t_sc_data[SC_SLEEP].timer != -1)   // �‡–°’†‚̓NƒŠƒeƒBƒJƒ‹‚ª”{‚É
+        if (t_sc_data != NULL && t_sc_data[SC_SLEEP].timer != -1)   // �眠中�クリティカル���
             cri <<= 1;
         if (ac_flag)
             cri = 1000;
@@ -2939,8 +2939,8 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     if (tsd && tsd->critical_def)
         cri = cri * (100 - tsd->critical_def) / 100;
 
-    if (da == 0 && (skill_num == 0 || skill_num == KN_AUTOCOUNTER || skill_num == SN_SHARPSHOOTING) && skill_lv >= 0 && //ƒ_ƒuƒ‹ƒAƒ^ƒbƒN‚ª”­“®‚µ‚Ä‚¢‚È‚¢
-        (MRAND (1000)) < cri)   // ”»’è�iƒXƒLƒ‹‚Ì�ê�‡‚Í–³Ž‹�j
+    if (da == 0 && (skill_num == 0 || skill_num == KN_AUTOCOUNTER || skill_num == SN_SHARPSHOOTING) && skill_lv >= 0 && //ダブルアタック�発動�����
+        (MRAND (1000)) < cri)   // 判定（スキル�場��無視）
     {
         damage += atkmax;
         damage2 += atkmax_;
@@ -3051,27 +3051,27 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             }
         }
 
-        // ƒXƒLƒ‹�C�³‚P�i�UŒ‚—Í”{‰»Œn�j
-        // ƒI�[ƒo�[ƒgƒ‰ƒXƒg(+5% �` +25%),‘¼�UŒ‚ŒnƒXƒLƒ‹‚Ì�ê�‡‚±‚±‚Å•â�³
-        // ƒoƒbƒVƒ…,ƒ}ƒOƒiƒ€ƒuƒŒƒCƒN,
-        // ƒ{�[ƒŠƒ“ƒOƒoƒbƒVƒ…,ƒXƒsƒAƒu�[ƒ�ƒ‰ƒ“,ƒuƒ‰ƒ“ƒfƒBƒbƒVƒ…ƒXƒsƒA,ƒXƒsƒAƒXƒ^ƒbƒu,
-        // ƒ�ƒ}�[ƒiƒCƒg,ƒJ�[ƒgƒŒƒ{ƒŠƒ…�[ƒVƒ‡ƒ“
-        // ƒ_ƒuƒ‹ƒXƒgƒŒƒCƒtƒBƒ“ƒO,ƒAƒ��[ƒVƒƒƒ��[,ƒ`ƒƒ�[ƒWƒAƒ��[,
-        // ƒ\ƒjƒbƒNƒuƒ��[
+        // スキル修正１（攻撃力�化系）
+        // オー�ートラスト(+5% 〜 +25%),他攻撃系スキル�場����補正
+        // �ッシュ,マグナムブレイク,
+        // ボーリング�ッシュ,スピアブーメラン,ブランディッシュスピア,スピアスタッブ,
+        // メマーナイト,カートレボリューション
+        // ダブルストレイフィング,アローシャワー,�ャージアロー,
+        // ソニックブロー
         if (sc_data)
-        {                       //�ó‘ÔˆÙ�í’†‚̃_ƒ��[ƒW’ljÁ
+        {                       //状態異常中�ダメージ追加
             if (sc_data[SC_OVERTHRUST].timer != -1)
-            {                   // ƒI�[ƒo�[ƒgƒ‰ƒXƒg
+            {                   // オー�ートラスト
                 damage += damage * (5 * sc_data[SC_OVERTHRUST].val1) / 100;
                 damage2 += damage2 * (5 * sc_data[SC_OVERTHRUST].val1) / 100;
             }
             if (sc_data[SC_TRUESIGHT].timer != -1)
-            {                   // ƒgƒDƒ‹�[ƒTƒCƒg
+            {                   // トゥルーサイト
                 damage += damage * (2 * sc_data[SC_TRUESIGHT].val1) / 100;
                 damage2 += damage2 * (2 * sc_data[SC_TRUESIGHT].val1) / 100;
             }
             if (sc_data[SC_BERSERK].timer != -1)
-            {                   // ƒo�[ƒT�[ƒN
+            {                   // �ーサーク
                 damage += damage * 50 / 100;
                 damage2 += damage2 * 50 / 100;
             }
@@ -3086,22 +3086,22 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             flag = (flag & ~BF_SKILLMASK) | BF_SKILL;
             switch (skill_num)
             {
-                case SM_BASH:  // ƒoƒbƒVƒ…
+                case SM_BASH:  // �ッシュ
                     damage = damage * (100 + 30 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 30 * skill_lv) / 100;
                     hitrate = (hitrate * (100 + 5 * skill_lv)) / 100;
                     break;
-                case SM_MAGNUM:    // ƒ}ƒOƒiƒ€ƒuƒŒƒCƒN
+                case SM_MAGNUM:    // マグナムブレイク
                     damage =
                         damage * (5 * skill_lv + (wflag) ? 65 : 115) / 100;
                     damage2 =
                         damage2 * (5 * skill_lv + (wflag) ? 65 : 115) / 100;
                     break;
-                case MC_MAMMONITE: // ƒ�ƒ}�[ƒiƒCƒg
+                case MC_MAMMONITE: // メマーナイト
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 50 * skill_lv) / 100;
                     break;
-                case AC_DOUBLE:    // ƒ_ƒuƒ‹ƒXƒgƒŒƒCƒtƒBƒ“ƒO
+                case AC_DOUBLE:    // ダブルストレイフィング
                     if (!sd->state.arrow_atk && sd->arrow_atk > 0)
                     {
                         int  arr = MRAND ((sd->arrow_atk + 1));
@@ -3119,7 +3119,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     sd->state.arrow_atk = 1;
                     break;
-                case AC_SHOWER:    // ƒAƒ��[ƒVƒƒƒ��[
+                case AC_SHOWER:    // アローシャワー
                     if (!sd->state.arrow_atk && sd->arrow_atk > 0)
                     {
                         int  arr = MRAND ((sd->arrow_atk + 1));
@@ -3136,7 +3136,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     sd->state.arrow_atk = 1;
                     break;
-                case AC_CHARGEARROW:   // ƒ`ƒƒ�[ƒWƒAƒ��[
+                case AC_CHARGEARROW:   // �ャージアロー
                     if (!sd->state.arrow_atk && sd->arrow_atk > 0)
                     {
                         int  arr = MRAND ((sd->arrow_atk + 1));
@@ -3153,7 +3153,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     sd->state.arrow_atk = 1;
                     break;
-                case KN_PIERCE:    // ƒsƒA�[ƒX
+                case KN_PIERCE:    // ピアース
                     damage = damage * (100 + 10 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 10 * skill_lv) / 100;
                     hitrate = hitrate * (100 + 5 * skill_lv) / 100;
@@ -3161,16 +3161,16 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     damage *= div_;
                     damage2 *= div_;
                     break;
-                case KN_SPEARSTAB: // ƒXƒsƒAƒXƒ^ƒu
+                case KN_SPEARSTAB: // スピアスタブ
                     damage = damage * (100 + 15 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 15 * skill_lv) / 100;
                     break;
-                case KN_SPEARBOOMERANG:    // ƒXƒsƒAƒu�[ƒ�ƒ‰ƒ“
+                case KN_SPEARBOOMERANG:    // スピアブーメラン
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 50 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     break;
-                case KN_BRANDISHSPEAR: // ƒuƒ‰ƒ“ƒfƒBƒbƒVƒ…ƒXƒsƒA
+                case KN_BRANDISHSPEAR: // ブランディッシュスピア
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     if (skill_lv > 3 && wflag == 1)
@@ -3201,7 +3201,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     damage2 += damage4;
                     blewcount = 0;
                     break;
-                case KN_BOWLINGBASH:   // ƒ{ƒEƒŠƒ“ƒOƒoƒbƒVƒ…
+                case KN_BOWLINGBASH:   // ボウリング�ッシュ
                     damage = damage * (100 + 50 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 50 * skill_lv) / 100;
                     blewcount = 0;
@@ -3213,17 +3213,17 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                         hitrate = 1000000;
                     flag = (flag & ~BF_SKILLMASK) | BF_NORMAL;
                     break;
-                case AS_SONICBLOW: // ƒ\ƒjƒbƒNƒuƒ�ƒE
+                case AS_SONICBLOW: // ソニックブロウ
                     hitrate += 30;  // hitrate +30, thanks to midas
                     damage = damage * (300 + 50 * skill_lv) / 100;
                     damage2 = damage2 * (300 + 50 * skill_lv) / 100;
                     div_ = 8;
                     break;
-                case TF_SPRINKLESAND:  // �»‚Ü‚«
+                case TF_SPRINKLESAND:  // 砂��
                     damage = damage * 125 / 100;
                     damage2 = damage2 * 125 / 100;
                     break;
-                case MC_CARTREVOLUTION:    // ƒJ�[ƒgƒŒƒ{ƒŠƒ…�[ƒVƒ‡ƒ“
+                case MC_CARTREVOLUTION:    // カートレボリューション
                     if (sd->cart_max_weight > 0 && sd->cart_weight > 0)
                     {
                         damage =
@@ -3243,17 +3243,17 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                         damage2 = (damage2 * 150) / 100;
                     }
                     break;
-                    // ˆÈ‰ºMOB
-                case NPC_COMBOATTACK:  // ‘½’i�UŒ‚
+                    // 以下MOB
+                case NPC_COMBOATTACK:  // 多段攻撃
                     div_ = skill_get_num (skill_num, skill_lv);
                     damage *= div_;
                     damage2 *= div_;
                     break;
-                case NPC_RANDOMATTACK: // ƒ‰ƒ“ƒ_ƒ€ATK�UŒ‚
+                case NPC_RANDOMATTACK: // ランダムATK攻撃
                     damage = damage * (MPRAND (50, 150)) / 100;
                     damage2 = damage2 * (MPRAND (50, 150)) / 100;
                     break;
-                    // ‘®�«�UŒ‚�i“K“–�j
+                    // 属性攻撃（�当）
                 case NPC_WATERATTACK:
                 case NPC_GROUNDATTACK:
                 case NPC_FIREATTACK:
@@ -3274,7 +3274,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                 case NPC_PIERCINGATT:
                     flag = (flag & ~BF_RANGEMASK) | BF_SHORT;
                     break;
-                case RG_BACKSTAP:  // ƒoƒbƒNƒXƒ^ƒu
+                case RG_BACKSTAP:  // �ックスタブ
                     if (battle_config.backstab_bow_penalty == 1
                         && sd->status.weapon == 11)
                     {
@@ -3288,27 +3288,27 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     }
                     hitrate = 1000000;
                     break;
-                case RG_RAID:  // ƒTƒvƒ‰ƒCƒYƒAƒ^ƒbƒN
+                case RG_RAID:  // サプライズアタック
                     damage = damage * (100 + 40 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 40 * skill_lv) / 100;
                     break;
-                case RG_INTIMIDATE:    // ƒCƒ“ƒeƒBƒ~ƒfƒCƒg
+                case RG_INTIMIDATE:    // インティミデイト
                     damage = damage * (100 + 30 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 30 * skill_lv) / 100;
                     break;
-                case CR_SHIELDCHARGE:  // ƒV�[ƒ‹ƒhƒ`ƒƒ�[ƒW
+                case CR_SHIELDCHARGE:  // シールド�ャージ
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_SHORT;
                     s_ele = 0;
                     break;
-                case CR_SHIELDBOOMERANG:   // ƒV�[ƒ‹ƒhƒu�[ƒ�ƒ‰ƒ“
+                case CR_SHIELDBOOMERANG:   // シールドブーメラン
                     damage = damage * (100 + 30 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 30 * skill_lv) / 100;
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     s_ele = 0;
                     break;
-                case CR_HOLYCROSS: // ƒz�[ƒŠ�[ƒNƒ�ƒX
+                case CR_HOLYCROSS: // ホーリークロス
                     damage = damage * (100 + 35 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 35 * skill_lv) / 100;
                     div_ = 2;
@@ -3316,15 +3316,15 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                 case CR_GRANDCROSS:
                     hitrate = 1000000;
                     break;
-                case AM_DEMONSTRATION: // ƒfƒ‚ƒ“ƒXƒgƒŒ�[ƒVƒ‡ƒ“
+                case AM_DEMONSTRATION: // デモンストレーション
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     break;
-                case AM_ACIDTERROR:    // ƒAƒVƒbƒhƒeƒ‰�[
+                case AM_ACIDTERROR:    // アシッドテラー
                     damage = damage * (100 + 40 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 40 * skill_lv) / 100;
                     break;
-                case MO_FINGEROFFENSIVE:   //Žw’e
+                case MO_FINGEROFFENSIVE:   //指弾
                     if (battle_config.finger_offensive_type == 0)
                     {
                         damage =
@@ -3344,7 +3344,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                         div_ = 1;
                     }
                     break;
-                case MO_INVESTIGATE:   // ”­ ™¤
+                case MO_INVESTIGATE:   // 発 �
                     if (def1 < 1000000)
                     {
                         damage =
@@ -3360,7 +3360,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     s_ele = 0;
                     s_ele_ = 0;
                     break;
-                case MO_EXTREMITYFIST: // ˆ¢�C—…”e–PŒ�
+                case MO_EXTREMITYFIST: // 阿修羅覇鳳拳
                     damage =
                         damage * (8 + ((sd->status.sp) / 10)) + 250 +
                         (skill_lv * 150);
@@ -3373,16 +3373,16 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     s_ele = 0;
                     s_ele_ = 0;
                     break;
-                case MO_CHAINCOMBO:    // ˜A‘Å�¶
+                case MO_CHAINCOMBO:    // 連打掌
                     damage = damage * (150 + 50 * skill_lv) / 100;
                     damage2 = damage2 * (150 + 50 * skill_lv) / 100;
                     div_ = 4;
                     break;
-                case MO_COMBOFINISH:   // –Ò—´Œ�
+                case MO_COMBOFINISH:   // 猛�拳
                     damage = damage * (240 + 60 * skill_lv) / 100;
                     damage2 = damage2 * (240 + 60 * skill_lv) / 100;
                     break;
-                case BA_MUSICALSTRIKE: // ƒ~ƒ…�[ƒWƒJƒ‹ƒXƒgƒ‰ƒCƒN
+                case BA_MUSICALSTRIKE: // ミュージカルストライク
                     if (!sd->state.arrow_atk && sd->arrow_atk > 0)
                     {
                         int  arr = MRAND ((sd->arrow_atk + 1));
@@ -3399,7 +3399,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     sd->state.arrow_atk = 1;
                     break;
-                case DC_THROWARROW:    // –‚¿
+                case DC_THROWARROW:    // 矢撃�
                     if (!sd->state.arrow_atk && sd->arrow_atk > 0)
                     {
                         int  arr = MRAND ((sd->arrow_atk + 1));
@@ -3416,50 +3416,50 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
                     flag = (flag & ~BF_RANGEMASK) | BF_LONG;
                     sd->state.arrow_atk = 1;
                     break;
-                case CH_TIGERFIST: // •šŒÕŒ�
+                case CH_TIGERFIST: // �虎拳
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     break;
-                case CH_CHAINCRUSH:    // ˜A’Œ•öŒ‚
+                case CH_CHAINCRUSH:    // 連柱崩撃
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     div_ = skill_get_num (skill_num, skill_lv);
                     break;
-                case CH_PALMSTRIKE:    // –ÒŒÕ�d”hŽR
+                case CH_PALMSTRIKE:    // 猛虎硬派山
                     damage = damage * (50 + 100 * skill_lv) / 100;
                     damage2 = damage2 * (50 + 100 * skill_lv) / 100;
                     break;
-                case LK_SPIRALPIERCE:  /* ƒXƒpƒCƒ‰ƒ‹ƒsƒA�[ƒX */
-                    damage = damage * (100 + 50 * skill_lv) / 100;  //‘�‰Á—Ê‚ª•ª‚©‚ç‚È‚¢‚Ì‚Å“K“–‚É
-                    damage2 = damage2 * (100 + 50 * skill_lv) / 100;    //‘�‰Á—Ê‚ª•ª‚©‚ç‚È‚¢‚Ì‚Å“K“–‚É
+                case LK_SPIRALPIERCE:  /* スパイラルピアース */
+                    damage = damage * (100 + 50 * skill_lv) / 100;  //増加��分�ら�����当�
+                    damage2 = damage2 * (100 + 50 * skill_lv) / 100;    //増加��分�ら�����当�
                     div_ = 5;
                     if (tsd)
                         tsd->canmove_tick = gettick () + 1000;
                     else if (tmd)
                         tmd->canmove_tick = gettick () + 1000;
                     break;
-                case LK_HEADCRUSH: /* ƒwƒbƒhƒNƒ‰ƒbƒVƒ… */
+                case LK_HEADCRUSH: /* ヘッドクラッシュ */
                     damage = damage * (100 + 20 * skill_lv) / 100;
                     damage2 = damage2 * (100 + 20 * skill_lv) / 100;
                     break;
-                case LK_JOINTBEAT: /* ƒWƒ‡ƒCƒ“ƒgƒr�[ƒg */
+                case LK_JOINTBEAT: /* ジョイントビート */
                     damage = damage * (50 + 10 * skill_lv) / 100;
                     damage2 = damage2 * (50 + 10 * skill_lv) / 100;
                     break;
-                case ASC_METEORASSAULT:    /* ƒ�ƒeƒIƒAƒTƒ‹ƒg */
+                case ASC_METEORASSAULT:    /* メテオアサルト */
                     damage = damage * (40 + 40 * skill_lv) / 100;
                     damage2 = damage2 * (40 + 40 * skill_lv) / 100;
                     break;
-                case SN_SHARPSHOOTING: /* ƒVƒƒ�[ƒvƒVƒ…�[ƒeƒBƒ“ƒO */
+                case SN_SHARPSHOOTING: /* シャープシューティング */
                     damage += damage * (30 * skill_lv) / 100;
                     damage2 += damage2 * (30 * skill_lv) / 100;
                     break;
-                case CG_ARROWVULCAN:   /* ƒAƒ��[ƒoƒ‹ƒJƒ“ */
+                case CG_ARROWVULCAN:   /* アロー�ルカン */
                     damage = damage * (160 + 40 * skill_lv) / 100;
                     damage2 = damage2 * (160 + 40 * skill_lv) / 100;
                     div_ = 9;
                     break;
-                case AS_SPLASHER:  /* ƒxƒiƒ€ƒXƒvƒ‰ƒbƒVƒƒ�[ */
+                case AS_SPLASHER:  /* ベナムスプラッシャー */
                     damage =
                         damage * (200 + 20 * skill_lv +
                                   20 * pc_checkskill (sd,
@@ -3542,9 +3542,9 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             }
         }
         if (da == 2)
-        {                       //ŽO’i�¶‚ª”­“®‚µ‚Ä‚¢‚é‚©
+        {                       //三段掌�発動���る�
             type = 0x08;
-            div_ = 255;         //ŽO’i�¶—p‚É�c
+            div_ = 255;         //三段掌用�…
             damage =
                 damage * (100 +
                           20 * pc_checkskill (sd, MO_TRIPLEATTACK)) / 100;
@@ -3552,11 +3552,11 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
 
         if (skill_num != NPC_CRITICALSLASH)
         {
-            // ‘Î �Û‚Ì–hŒä—Í‚É‚æ‚éƒ_ƒ��[ƒW‚ÌŒ¸�­
-            // ƒfƒBƒoƒCƒ“ƒvƒ�ƒeƒNƒVƒ‡ƒ“�i‚±‚±‚Å‚¢‚¢‚Ì‚©‚È�H�j
+            // 対 象�防御力�よるダメージ�減少
+            // ディ�インプロテクション（��������？）
             if (skill_num != MO_INVESTIGATE && skill_num != MO_EXTREMITYFIST
                 && skill_num != KN_AUTOCOUNTER && def1 < 1000000)
-            {                   //DEF, VIT–³Ž‹
+            {                   //DEF, VIT無視
                 int  t_def;
                 target_count =
                     1 + battle_counttargeted (target, src,
@@ -3676,9 +3676,9 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             }
         }
     }
-    // �¸˜Bƒ_ƒ��[ƒW‚̒ljÁ
+    // 精錬ダメージ�追加
     if (skill_num != MO_INVESTIGATE && skill_num != MO_EXTREMITYFIST)
-    {                           //DEF, VIT–³Ž‹
+    {                           //DEF, VIT無視
         damage += battle_get_atk2 (src);
         damage2 += battle_get_atk_2 (src);
     }
@@ -3698,9 +3698,9 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         }
     }
     if (skill_num == LK_SPIRALPIERCE)
-    {                           /* ƒXƒpƒCƒ‰ƒ‹ƒsƒA�[ƒX */
+    {                           /* スパイラルピアース */
         if (sd->equip_index[9] >= 0)
-        {                       //�d—ʂŒljÁƒ_ƒ��[ƒW‚炵‚¢‚̂ŃV�[ƒ‹ƒhƒu�[ƒ�ƒ‰ƒ“‚ðŽQ�l‚ɒljÁ
+        {                       //���追加ダメージら����シールドブーメランを�考�追加
             int  index = sd->equip_index[9];
             if (sd->inventory_data[index]
                 && sd->inventory_data[index]->type == 4)
@@ -3715,17 +3715,17 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         }
     }
 
-    // 0–¢–ž‚¾‚Á‚½�ê�‡1‚É•â�³
+    // 0未満���場�1�補正
     if (damage < 1)
         damage = 1;
     if (damage2 < 1)
         damage2 = 1;
 
-    // ƒXƒLƒ‹�C�³‚Q�i�C—ûŒn�j
-    // �C—ûƒ_ƒ��[ƒW(‰EŽè‚Ì‚Ý) ƒ\ƒjƒbƒNƒuƒ��[Žž‚Í•Ê�ˆ—��i1Œ‚‚É•t‚«1/8“K‰ž)
+    // スキル修正２（修練系）
+    // 修練ダメージ(�手��) ソニックブロー時�別処�（1撃�付�1/8�応)
     if (skill_num != MO_INVESTIGATE && skill_num != MO_EXTREMITYFIST
         && skill_num != CR_GRANDCROSS)
-    {                           //�C—ûƒ_ƒ��[ƒW–³Ž‹
+    {                           //修練ダメージ無視
         damage = battle_addmastery (sd, target, damage, 0);
         damage2 = battle_addmastery (sd, target, damage2, 1);
     }
@@ -3736,12 +3736,12 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             hitrate = 1000000;
     }
 
-    // ‰ñ”ð�C�³
+    // 回�修正
     hitrate = (hitrate < 5) ? 5 : hitrate;
-    if (hitrate < 1000000 &&    // •K’†�UŒ‚
-        (t_sc_data != NULL && (t_sc_data[SC_SLEEP].timer != -1 ||   // �‡–°‚Í•K’†
-                               t_sc_data[SC_STAN].timer != -1 ||    // ƒXƒ^ƒ“‚Í•K’†
-                               t_sc_data[SC_FREEZE].timer != -1 || (t_sc_data[SC_STONE].timer != -1 && t_sc_data[SC_STONE].val2 == 0))))    // “€Œ‹‚Í•K’†
+    if (hitrate < 1000000 &&    // 必中攻撃
+        (t_sc_data != NULL && (t_sc_data[SC_SLEEP].timer != -1 ||   // �眠�必中
+                               t_sc_data[SC_STAN].timer != -1 ||    // スタン�必中
+                               t_sc_data[SC_FREEZE].timer != -1 || (t_sc_data[SC_STONE].timer != -1 && t_sc_data[SC_STONE].val2 == 0))))    // ���必中
         hitrate = 1000000;
     if (type == 0 && MRAND (100) >= hitrate)
     {
@@ -3752,7 +3752,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
     {
         dmg_lv = ATK_DEF;
     }
-    // ƒXƒLƒ‹�C�³‚R�i•�ŠíŒ¤‹†�j
+    // スキル修正３（武器研究）
     if ((skill = pc_checkskill (sd, BS_WEAPONRESEARCH)) > 0)
     {
         damage += skill * 2;
@@ -3767,56 +3767,56 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         }
     }
 
-//ƒXƒLƒ‹‚É‚æ‚éƒ_ƒ��[ƒW•â�³‚±‚±‚Ü‚Å
+//スキル�よるダメージ補正����
 
-//ƒJ�[ƒh‚É‚æ‚éƒ_ƒ��[ƒW’ljÁ�ˆ—�‚±‚±‚©‚ç
+//カード�よるダメージ追加処����ら
     cardfix = 100;
     if (!sd->state.arrow_atk)
-    {                           //‹|–îˆÈŠO
+    {                           //弓矢以外
         if (!battle_config.left_cardfix_to_right)
-        {                       //�¶ŽèƒJ�[ƒh•â�³�Ý’è–³‚µ
-            cardfix = cardfix * (100 + sd->addrace[t_race]) / 100;  // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW�C�³
-            cardfix = cardfix * (100 + sd->addele[t_ele]) / 100;    // ‘®�«‚É‚æ‚éƒ_ƒ��[ƒW�C�³
-            cardfix = cardfix * (100 + sd->addsize[t_size]) / 100;  // ƒTƒCƒY‚É‚æ‚éƒ_ƒ��[ƒW�C�³
+        {                       //左手カード補正設定無�
+            cardfix = cardfix * (100 + sd->addrace[t_race]) / 100;  // 種��よるダメージ修正
+            cardfix = cardfix * (100 + sd->addele[t_ele]) / 100;    // 属性�よるダメージ修正
+            cardfix = cardfix * (100 + sd->addsize[t_size]) / 100;  // サイズ�よるダメージ修正
         }
         else
         {
-            cardfix = cardfix * (100 + sd->addrace[t_race] + sd->addrace_[t_race]) / 100;   // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW�C�³(�¶Žè‚É‚æ‚é’ljÁ‚ ‚è)
-            cardfix = cardfix * (100 + sd->addele[t_ele] + sd->addele_[t_ele]) / 100;   // ‘®�«‚É‚æ‚éƒ_ƒ��[ƒW�C�³(�¶Žè‚É‚æ‚é’ljÁ‚ ‚è)
-            cardfix = cardfix * (100 + sd->addsize[t_size] + sd->addsize_[t_size]) / 100;   // ƒTƒCƒY‚É‚æ‚éƒ_ƒ��[ƒW�C�³(�¶Žè‚É‚æ‚é’ljÁ‚ ‚è)
+            cardfix = cardfix * (100 + sd->addrace[t_race] + sd->addrace_[t_race]) / 100;   // 種��よるダメージ修正(左手�よる追加�り)
+            cardfix = cardfix * (100 + sd->addele[t_ele] + sd->addele_[t_ele]) / 100;   // 属性�よるダメージ修正(左手�よる追加�り)
+            cardfix = cardfix * (100 + sd->addsize[t_size] + sd->addsize_[t_size]) / 100;   // サイズ�よるダメージ修正(左手�よる追加�り)
         }
     }
     else
-    {                           //‹|–î
-        cardfix = cardfix * (100 + sd->addrace[t_race] + sd->arrow_addrace[t_race]) / 100;  // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW�C�³(‹|–î‚É‚æ‚é’ljÁ‚ ‚è)
-        cardfix = cardfix * (100 + sd->addele[t_ele] + sd->arrow_addele[t_ele]) / 100;  // ‘®�«‚É‚æ‚éƒ_ƒ��[ƒW�C�³(‹|–î‚É‚æ‚é’ljÁ‚ ‚è)
-        cardfix = cardfix * (100 + sd->addsize[t_size] + sd->arrow_addsize[t_size]) / 100;  // ƒTƒCƒY‚É‚æ‚éƒ_ƒ��[ƒW�C�³(‹|–î‚É‚æ‚é’ljÁ‚ ‚è)
+    {                           //弓矢
+        cardfix = cardfix * (100 + sd->addrace[t_race] + sd->arrow_addrace[t_race]) / 100;  // 種��よるダメージ修正(弓矢�よる追加�り)
+        cardfix = cardfix * (100 + sd->addele[t_ele] + sd->arrow_addele[t_ele]) / 100;  // 属性�よるダメージ修正(弓矢�よる追加�り)
+        cardfix = cardfix * (100 + sd->addsize[t_size] + sd->arrow_addsize[t_size]) / 100;  // サイズ�よるダメージ修正(弓矢�よる追加�り)
     }
     if (t_mode & 0x20)
-    {                           //ƒ{ƒX
+    {                           //ボス
         if (!sd->state.arrow_atk)
-        {                       //‹|–î�UŒ‚ˆÈŠO‚È‚ç
-            if (!battle_config.left_cardfix_to_right)   //�¶ŽèƒJ�[ƒh•â�³�Ý’è–³‚µ
-                cardfix = cardfix * (100 + sd->addrace[10]) / 100;  //ƒ{ƒXƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW
-            else                //�¶ŽèƒJ�[ƒh•â�³�Ý’è‚ ‚è
-                cardfix = cardfix * (100 + sd->addrace[10] + sd->addrace_[10]) / 100;   //ƒ{ƒXƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW(�¶Žè‚É‚æ‚é’ljÁ‚ ‚è)
+        {                       //弓矢攻撃以外�ら
+            if (!battle_config.left_cardfix_to_right)   //左手カード補正設定無�
+                cardfix = cardfix * (100 + sd->addrace[10]) / 100;  //ボスモンスター�追加ダメージ
+            else                //左手カード補正設定�り
+                cardfix = cardfix * (100 + sd->addrace[10] + sd->addrace_[10]) / 100;   //ボスモンスター�追加ダメージ(左手�よる追加�り)
         }
-        else                    //‹|–î�UŒ‚
-            cardfix = cardfix * (100 + sd->addrace[10] + sd->arrow_addrace[10]) / 100;  //ƒ{ƒXƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW(‹|–î‚É‚æ‚é’ljÁ‚ ‚è)
+        else                    //弓矢攻撃
+            cardfix = cardfix * (100 + sd->addrace[10] + sd->arrow_addrace[10]) / 100;  //ボスモンスター�追加ダメージ(弓矢�よる追加�り)
     }
     else
-    {                           //ƒ{ƒX‚¶‚á‚È‚¢
+    {                           //ボス�ゃ��
         if (!sd->state.arrow_atk)
-        {                       //‹|–î�UŒ‚ˆÈŠO
-            if (!battle_config.left_cardfix_to_right)   //�¶ŽèƒJ�[ƒh•â�³�Ý’è–³‚µ
-                cardfix = cardfix * (100 + sd->addrace[11]) / 100;  //ƒ{ƒXˆÈŠOƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW
-            else                //�¶ŽèƒJ�[ƒh•â�³�Ý’è‚ ‚è
-                cardfix = cardfix * (100 + sd->addrace[11] + sd->addrace_[11]) / 100;   //ƒ{ƒXˆÈŠOƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW(�¶Žè‚É‚æ‚é’ljÁ‚ ‚è)
+        {                       //弓矢攻撃以外
+            if (!battle_config.left_cardfix_to_right)   //左手カード補正設定無�
+                cardfix = cardfix * (100 + sd->addrace[11]) / 100;  //ボス以外モンスター�追加ダメージ
+            else                //左手カード補正設定�り
+                cardfix = cardfix * (100 + sd->addrace[11] + sd->addrace_[11]) / 100;   //ボス以外モンスター�追加ダメージ(左手�よる追加�り)
         }
         else
-            cardfix = cardfix * (100 + sd->addrace[11] + sd->arrow_addrace[11]) / 100;  //ƒ{ƒXˆÈŠOƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW(‹|–î‚É‚æ‚é’ljÁ‚ ‚è)
+            cardfix = cardfix * (100 + sd->addrace[11] + sd->arrow_addrace[11]) / 100;  //ボス以外モンスター�追加ダメージ(弓矢�よる追加�り)
     }
-    //“Á’èClass—p•â�³�ˆ—�(�­�—‚Ì“ú‹L�¨ƒ{ƒ“ƒSƒ“—p�H)
+    //特定Class用補正処�(少女�日記→ボンゴン用？)
     t_class = battle_get_class (target);
     for (i = 0; i < sd->add_damage_class_count; i++)
     {
@@ -3827,22 +3827,22 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         }
     }
     if (skill_num != CR_GRANDCROSS || !battle_config.gx_cardfix)
-        damage = damage * cardfix / 100;    //ƒJ�[ƒh•â�³‚É‚æ‚éƒ_ƒ��[ƒW‘�‰Á
-//ƒJ�[ƒh‚É‚æ‚éƒ_ƒ��[ƒW‘�‰Á�ˆ—�‚±‚±‚Ü‚Å
+        damage = damage * cardfix / 100;    //カード補正�よるダメージ増加
+//カード�よるダメージ増加処�����
 
-//ƒJ�[ƒh‚É‚æ‚éƒ_ƒ��[ƒW’ljÁ�ˆ—�(�¶Žè)‚±‚±‚©‚ç
+//カード�よるダメージ追加処�(左手)���ら
     cardfix = 100;
     if (!battle_config.left_cardfix_to_right)
-    {                           //�¶ŽèƒJ�[ƒh•â�³�Ý’è–³‚µ
-        cardfix = cardfix * (100 + sd->addrace_[t_race]) / 100; // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW�C�³�¶Žè
-        cardfix = cardfix * (100 + sd->addele_[t_ele]) / 100;   // ‘® �«‚É‚æ‚éƒ_ƒ��[ƒW�C�³�¶Žè
-        cardfix = cardfix * (100 + sd->addsize_[t_size]) / 100; // ƒTƒCƒY‚É‚æ‚éƒ_ƒ��[ƒW�C�³�¶Žè
-        if (t_mode & 0x20)      //ƒ{ƒX
-            cardfix = cardfix * (100 + sd->addrace_[10]) / 100; //ƒ{ƒXƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW�¶Žè
+    {                           //左手カード補正設定無�
+        cardfix = cardfix * (100 + sd->addrace_[t_race]) / 100; // 種��よるダメージ修正左手
+        cardfix = cardfix * (100 + sd->addele_[t_ele]) / 100;   // 属 性�よるダメージ修正左手
+        cardfix = cardfix * (100 + sd->addsize_[t_size]) / 100; // サイズ�よるダメージ修正左手
+        if (t_mode & 0x20)      //ボス
+            cardfix = cardfix * (100 + sd->addrace_[10]) / 100; //ボスモンスター�追加ダメージ左手
         else
-            cardfix = cardfix * (100 + sd->addrace_[11]) / 100; //ƒ{ƒXˆÈŠOƒ‚ƒ“ƒXƒ^�[‚ɒljÁƒ_ƒ��[ƒW�¶Žè
+            cardfix = cardfix * (100 + sd->addrace_[11]) / 100; //ボス以外モンスター�追加ダメージ左手
     }
-    //“Á’èClass—p•â�³�ˆ—��¶Žè(�­�—‚Ì“ú‹L�¨ƒ{ƒ“ƒSƒ“—p�H)
+    //特定Class用補正処�左手(少女�日記→ボンゴン用？)
     for (i = 0; i < sd->add_damage_class_count_; i++)
     {
         if (sd->add_damage_classid_[i] == t_class)
@@ -3852,24 +3852,24 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         }
     }
     if (skill_num != CR_GRANDCROSS)
-        damage2 = damage2 * cardfix / 100;  //ƒJ�[ƒh•â�³‚É‚æ‚é�¶Žèƒ_ƒ��[ƒW‘�‰Á
-//ƒJ�[ƒh‚É‚æ‚éƒ_ƒ��[ƒW‘�‰Á�ˆ—�(�¶Žè)‚±‚±‚Ü‚Å
+        damage2 = damage2 * cardfix / 100;  //カード補正�よる左手ダメージ増加
+//カード�よるダメージ増加処�(左手)����
 
 // -- moonsoul (cardfix for magic damage portion of ASC_BREAKER)
     if (skill_num == ASC_BREAKER)
         damage3 = damage3 * cardfix / 100;
 
-//ƒJ�[ƒh‚É‚æ‚éƒ_ƒ��[ƒWŒ¸�Š�ˆ—�‚±‚±‚©‚ç
+//カード�よるダメージ減衰処����ら
     if (tsd)
-    {                           //‘Î�Û‚ªPC‚Ì�ê�‡
+    {                           //対象�PC�場�
         cardfix = 100;
-        cardfix = cardfix * (100 - tsd->subrace[s_race]) / 100; // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
-        cardfix = cardfix * (100 - tsd->subele[s_ele]) / 100;   // ‘®�«‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
+        cardfix = cardfix * (100 - tsd->subrace[s_race]) / 100; // 種��よるダメージ�性
+        cardfix = cardfix * (100 - tsd->subele[s_ele]) / 100;   // 属性�よるダメージ�性
         if (battle_get_mode (src) & 0x20)
-            cardfix = cardfix * (100 - tsd->subrace[10]) / 100; //ƒ{ƒX‚©‚ç‚Ì�UŒ‚‚̓_ƒ��[ƒWŒ¸�­
+            cardfix = cardfix * (100 - tsd->subrace[10]) / 100; //ボス�ら�攻撃�ダメージ減少
         else
-            cardfix = cardfix * (100 - tsd->subrace[11]) / 100; //ƒ{ƒXˆÈŠO‚©‚ç‚Ì�UŒ‚‚̓_ƒ��[ƒWŒ¸�­
-        //“Á’èClass—p•â�³�ˆ—��¶Žè(�­�—‚Ì“ú‹L�¨ƒ{ƒ“ƒSƒ“—p�H)
+            cardfix = cardfix * (100 - tsd->subrace[11]) / 100; //ボス以外�ら�攻撃�ダメージ減少
+        //特定Class用補正処�左手(少女�日記→ボンゴン用？)
         for (i = 0; i < tsd->add_def_class_count; i++)
         {
             if (tsd->add_def_classid[i] == sd->status.class)
@@ -3879,27 +3879,27 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             }
         }
         if (flag & BF_LONG)
-            cardfix = cardfix * (100 - tsd->long_attack_def_rate) / 100;    //‰“‹——£�UŒ‚‚̓_ƒ��[ƒWŒ¸�­(ƒzƒ‹ƒ“C‚Æ‚©)
+            cardfix = cardfix * (100 - tsd->long_attack_def_rate) / 100;    //��離攻撃�ダメージ減少(ホルンC��)
         if (flag & BF_SHORT)
-            cardfix = cardfix * (100 - tsd->near_attack_def_rate) / 100;    //‹ß‹——£�UŒ‚‚̓_ƒ��[ƒWŒ¸�­(ŠY“––³‚µ�H)
-        damage = damage * cardfix / 100;    //ƒJ�[ƒh•â�³‚É‚æ‚éƒ_ƒ��[ƒWŒ¸�­
-        damage2 = damage2 * cardfix / 100;  //ƒJ�[ƒh•â�³‚É‚æ‚é�¶Žèƒ_ƒ��[ƒWŒ¸�­
+            cardfix = cardfix * (100 - tsd->near_attack_def_rate) / 100;    //近�離攻撃�ダメージ減少(該当無�？)
+        damage = damage * cardfix / 100;    //カード補正�よるダメージ減少
+        damage2 = damage2 * cardfix / 100;  //カード補正�よる左手ダメージ減少
     }
-//ƒJ�[ƒh‚É‚æ‚éƒ_ƒ��[ƒWŒ¸�Š�ˆ—�‚±‚±‚Ü‚Å
+//カード�よるダメージ減衰処�����
 
-//‘Î�ۂɃXƒe�[ƒ^ƒXˆÙ�킪‚ ‚é�ê�‡‚̃_ƒ��[ƒWŒ¸ŽZ�ˆ—�‚±‚±‚©‚ç
+//対象�ステータス異常��る場��ダメージ減算処����ら
     if (t_sc_data)
     {
         cardfix = 100;
-        if (t_sc_data[SC_DEFENDER].timer != -1 && flag & BF_LONG)   //ƒfƒBƒtƒFƒ“ƒ_�[�ó‘Ԃʼn“‹——£�UŒ‚
-            cardfix = cardfix * (100 - t_sc_data[SC_DEFENDER].val2) / 100;  //ƒfƒBƒtƒFƒ“ƒ_�[‚É‚æ‚錸�Š
+        if (t_sc_data[SC_DEFENDER].timer != -1 && flag & BF_LONG)   //ディフェンダー状態���離攻撃
+            cardfix = cardfix * (100 - t_sc_data[SC_DEFENDER].val2) / 100;  //ディフェンダー�よる減衰
         if (cardfix != 100)
         {
-            damage = damage * cardfix / 100;    //ƒfƒBƒtƒFƒ“ƒ_�[•â�³‚É‚æ‚éƒ_ƒ��[ƒWŒ¸�­
-            damage2 = damage2 * cardfix / 100;  //ƒfƒBƒtƒFƒ“ƒ_�[•â�³‚É‚æ‚é�¶Žèƒ_ƒ��[ƒWŒ¸�­
+            damage = damage * cardfix / 100;    //ディフェンダー補正�よるダメージ減少
+            damage2 = damage2 * cardfix / 100;  //ディフェンダー補正�よる左手ダメージ減少
         }
         if (t_sc_data[SC_ASSUMPTIO].timer != -1)
-        {                       //ƒAƒXƒ€ƒvƒeƒBƒI
+        {                       //アスムプティオ
             if (!map[target->m].flag.pvp)
             {
                 damage = damage / 3;
@@ -3912,67 +3912,67 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             }
         }
     }
-//‘Î�ۂɃXƒe�[ƒ^ƒXˆÙ�킪‚ ‚é�ê�‡‚̃_ƒ��[ƒWŒ¸ŽZ�ˆ—�‚±‚±‚Ü‚Å
+//対象�ステータス異常��る場��ダメージ減算処�����
 
     if (damage < 0)
         damage = 0;
     if (damage2 < 0)
         damage2 = 0;
 
-    // ‘® �«‚Ì“K—p
+    // 属 性��用
     damage = battle_attr_fix (damage, s_ele, battle_get_element (target));
     damage2 = battle_attr_fix (damage2, s_ele_, battle_get_element (target));
 
-    // �¯‚Ì‚©‚¯‚ç�A‹C‹…‚Ì“K—p
+    // 星���ら�気���用
     damage += sd->star;
     damage2 += sd->star_;
     damage += sd->spiritball * 3;
     damage2 += sd->spiritball * 3;
 
     if (sc_data && sc_data[SC_AURABLADE].timer != -1)
-    {                           /* ƒI�[ƒ‰ƒuƒŒ�[ƒh •K’† */
+    {                           /* オーラブレード 必中 */
         damage += sc_data[SC_AURABLADE].val1 * 10;
         damage2 += sc_data[SC_AURABLADE].val1 * 10;
     }
     if (skill_num == PA_PRESSURE)
-    {                           /* ƒvƒŒƒbƒVƒƒ�[ •K’†? */
+    {                           /* プレッシャー 必中? */
         damage = 700 + 100 * skill_lv;
         damage2 = 700 + 100 * skill_lv;
     }
 
-    // >“ñ“�—¬‚Ì�¶‰Eƒ_ƒ��[ƒWŒvŽZ’N‚©‚â‚Á‚Ä‚­‚ê‚¥‚¥‚¥‚¥‚¦‚¦‚¦�I
-    // >map_session_data ‚É�¶Žèƒ_ƒ��[ƒW(atk,atk2)’ljÁ‚µ‚Ä
-    // >pc_calcstatus()‚Å‚â‚é‚ׂ«‚©‚È�H
-    // map_session_data ‚É�¶Žè•�Ší(atk,atk2,ele,star,atkmods)’ljÁ‚µ‚Ä
-    // pc_calcstatus()‚Ńf�[ƒ^‚ð“ü—Í‚µ‚Ä‚¢‚Ü‚·
+    // >二刀��左�ダメージ計算誰�や���れ��������
+    // >map_session_data �左手ダメージ(atk,atk2)追加��
+    // >pc_calcstatus()�やる����？
+    // map_session_data �左手武器(atk,atk2,ele,star,atkmods)追加��
+    // pc_calcstatus()�データを入力�����
 
-    //�¶Žè‚Ì‚Ý•�Ší‘•”õ
+    //左手��武器装備
     if (sd->weapontype1 == 0 && sd->weapontype2 > 0)
     {
         damage = damage2;
         damage2 = 0;
     }
-    // ‰EŽè�A�¶Žè�C—û‚Ì“K—p
+    // �手�左手修練��用
     if (sd->status.weapon > 16)
-    {                           // “ñ“�—¬‚©?
+    {                           // 二刀��?
         int  dmg = damage, dmg2 = damage2;
-        // ‰EŽè�C—û(60% �` 100%) ‰EŽè‘S”Ê
+        // �手修練(60% 〜 100%) �手全般
         skill = pc_checkskill (sd, AS_RIGHT);
         damage = damage * (50 + (skill * 10)) / 100;
         if (dmg > 0 && damage < 1)
             damage = 1;
-        // �¶Žè�C—û(40% �` 80%) �¶Žè‘S”Ê
+        // 左手修練(40% 〜 80%) 左手全般
         skill = pc_checkskill (sd, AS_LEFT);
         damage2 = damage2 * (30 + (skill * 10)) / 100;
         if (dmg2 > 0 && damage2 < 1)
             damage2 = 1;
     }
-    else                        //“ñ“�—¬‚Å‚È‚¯‚ê‚Î�¶Žèƒ_ƒ��[ƒW‚Í0
+    else                        //二刀����れ�左手ダメージ�0
         damage2 = 0;
 
-    // ‰EŽè,’ZŒ•‚Ì‚Ý
+    // �手,短剣��
     if (da == 1)
-    {                           //ƒ_ƒuƒ‹ƒAƒ^ƒbƒN‚ª”­“®‚µ‚Ä‚¢‚é‚©
+    {                           //ダブルアタック�発動���る�
         div_ = 2;
         damage += damage;
         type = 0x08;
@@ -3980,14 +3980,14 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
 
     if (sd->status.weapon == 16)
     {
-        // ƒJƒ^�[ƒ‹’ÇŒ‚ƒ_ƒ��[ƒW
+        // カタール追撃ダメージ
         skill = pc_checkskill (sd, TF_DOUBLE);
         damage2 = damage * (1 + (skill * 2)) / 100;
         if (damage > 0 && damage2 < 1)
             damage2 = 1;
     }
 
-    // ƒCƒ“ƒxƒiƒ€�C�³
+    // インベナム修正
     if (skill_num == TF_POISON)
     {
         damage =
@@ -3999,7 +3999,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         damage = battle_attr_fix (damage, 0, battle_get_element (target));
     }
 
-    // Š®‘S‰ñ”ð‚Ì”»’è
+    // 完全回��判定
     if (skill_num == 0 && skill_lv >= 0 && tsd != NULL && div_ < 255
         && MRAND (1000) < battle_get_flee2 (target))
     {
@@ -4008,7 +4008,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         dmg_lv = ATK_LUCKY;
     }
 
-    // ‘Î�Û‚ªŠ®‘S‰ñ”ð‚ð‚·‚é�ݒ肪ON‚È‚ç
+    // 対象�完全回�を�る設定�ON�ら
     if (battle_config.enemy_perfect_flee)
     {
         if (skill_num == 0 && skill_lv >= 0 && tmd != NULL && div_ < 255
@@ -4020,7 +4020,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
         }
     }
 
-    //Mob‚ÌMode‚ÉŠæ‹­ƒtƒ‰ƒO‚ª—§‚Á‚Ä‚¢‚é‚Æ‚«‚Ì�ˆ—�
+    //Mob�Mode�頑強フラグ�立���る���処�
     if (t_mode & 0x40)
     {
         if (damage > 0)
@@ -4029,23 +4029,23 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
             damage2 = 1;
     }
 
-    //bNoWeaponDamage(�Ý’èƒAƒCƒeƒ€–³‚µ�H)‚ŃOƒ‰ƒ“ƒhƒNƒ�ƒX‚¶‚á‚È‚¢�ê�‡‚̓_ƒ��[ƒW‚ª0
+    //bNoWeaponDamage(設定アイテム無�？)�グランドクロス�ゃ��場��ダメージ�0
     if (tsd && tsd->special_state.no_weapon_damage
         && skill_num != CR_GRANDCROSS)
         damage = damage2 = 0;
 
     if (skill_num != CR_GRANDCROSS && (damage > 0 || damage2 > 0))
     {
-        if (damage2 < 1)        // ƒ_ƒ��[ƒW�Å�I�C�³
+        if (damage2 < 1)        // ダメージ最終修正
             damage =
                 battle_calc_damage (src, target, damage, div_, skill_num,
                                     skill_lv, flag);
-        else if (damage < 1)    // ‰EŽè‚ªƒ~ƒX�H
+        else if (damage < 1)    // �手�ミス？
             damage2 =
                 battle_calc_damage (src, target, damage2, div_, skill_num,
                                     skill_lv, flag);
         else
-        {                       // —¼ Žè/ƒJƒ^�[ƒ‹‚Ì�ê�‡‚Í‚¿‚å‚Á‚ÆŒvŽZ‚â‚₱‚µ‚¢
+        {                       // 両 手/カタール�場���ょ��計算やや���
             int  d1 = damage + damage2, d2 = damage2;
             damage =
                 battle_calc_damage (src, target, damage + damage2, div_,
@@ -4094,7 +4094,7 @@ static struct Damage battle_calc_pc_weapon_attack (struct block_list *src,
 }
 
 /*==========================================
- * •�Šíƒ_ƒ��[ƒWŒvŽZ
+ * 武器ダメージ計算
  *------------------------------------------
  */
 struct Damage battle_calc_weapon_attack (struct block_list *src,
@@ -4104,7 +4104,7 @@ struct Damage battle_calc_weapon_attack (struct block_list *src,
 {
     struct Damage wd;
 
-    //return‘O‚Ì�ˆ—�‚ª‚ ‚é‚Ì‚Å�î•ñ�o—Í•”‚Ì‚Ý•Ï�X
+    //return��処���る��情報出力部��変更
     if (src == NULL || target == NULL)
     {
         nullpo_info (NLP_MARK);
@@ -4173,7 +4173,7 @@ struct Damage battle_calc_weapon_attack (struct block_list *src,
 }
 
 /*==========================================
- * –‚–@ƒ_ƒ��[ƒWŒvŽZ
+ * 魔法ダメージ計算
  *------------------------------------------
  */
 struct Damage battle_calc_magic_attack (struct block_list *bl,
@@ -4192,7 +4192,7 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
     struct map_session_data *sd = NULL, *tsd = NULL;
     struct mob_data *tmd = NULL;
 
-    //return‘O‚Ì�ˆ—�‚ª‚ ‚é‚Ì‚Å�î•ñ�o—Í•”‚Ì‚Ý•Ï�X
+    //return��処���る��情報出力部��変更
     if (bl == NULL || target == NULL)
     {
         nullpo_info (NLP_MARK);
@@ -4227,24 +4227,24 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
     if (skill_num > 0)
     {
         switch (skill_num)
-        {                       // Šî–{ƒ_ƒ��[ƒWŒvŽZ(ƒXƒLƒ‹‚²‚Æ‚É�ˆ—�)
-                // ƒq�[ƒ‹or�¹‘Ì
+        {                       // 基本ダメージ計算(スキル���処�)
+                // ヒールor�体
             case AL_HEAL:
             case PR_BENEDICTIO:
                 damage = skill_calc_heal (bl, skill_lv) / 2;
                 normalmagic_flag = 0;
                 break;
-            case PR_ASPERSIO:  /* ƒAƒXƒyƒ‹ƒVƒI */
-                damage = 40;    //ŒÅ’èƒ_ƒ��[ƒW
+            case PR_ASPERSIO:  /* アスペルシオ */
+                damage = 40;    //固定ダメージ
                 normalmagic_flag = 0;
                 break;
-            case PR_SANCTUARY: // ƒTƒ“ƒNƒ`ƒ…ƒAƒŠ
+            case PR_SANCTUARY: // サンク�ュアリ
                 damage = (skill_lv > 6) ? 388 : skill_lv * 50;
                 normalmagic_flag = 0;
                 blewcount |= 0x10000;
                 break;
             case ALL_RESURRECTION:
-            case PR_TURNUNDEAD:    // �UŒ‚ƒŠƒUƒŒƒNƒVƒ‡ƒ“‚ƃ^�[ƒ“ƒAƒ“ƒfƒbƒh
+            case PR_TURNUNDEAD:    // 攻撃リザレクション�ターンアンデッド
                 if (target->type != BL_PC
                     && battle_check_undead (t_race, t_ele))
                 {
@@ -4257,10 +4257,10 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                     if (thres > 700)
                         thres = 700;
 //              if(battle_config.battle_log)
-//                  printf("ƒ^�[ƒ“ƒAƒ“ƒfƒbƒh�I Šm—¦%d �ñ(�番—¦)\n", thres);
-                    if (MRAND (1000) < thres && !(t_mode & 0x20))   // �¬Œ÷
+//                  printf("ターンアンデッド� 確率%d ‰(�分率)\n", thres);
+                    if (MRAND (1000) < thres && !(t_mode & 0x20))   // �功
                         damage = hp;
-                    else        // Ž¸”s
+                    else        // 失敗
                         damage =
                             battle_get_lv (bl) + battle_get_int (bl) +
                             skill_lv * 10;
@@ -4268,7 +4268,7 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                 normalmagic_flag = 0;
                 break;
 
-            case MG_NAPALMBEAT:    // ƒiƒp�[ƒ€ƒr�[ƒg�i•ªŽUŒvŽZ�ž‚Ý�j
+            case MG_NAPALMBEAT:    // ナパームビート（分散計算込�）
                 MATK_FIX (70 + skill_lv * 10, 100);
                 if (flag > 0)
                 {
@@ -4281,7 +4281,7 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                             ("battle_calc_magic_attack(): napam enemy count=0 !\n");
                 }
                 break;
-            case MG_FIREBALL:  // ƒtƒ@ƒCƒ„�[ƒ{�[ƒ‹
+            case MG_FIREBALL:  // ファイヤーボール
             {
                 const int drate[] = { 100, 90, 70 };
                 if (flag > 2)
@@ -4290,9 +4290,9 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                     MATK_FIX ((95 + skill_lv * 5) * drate[flag], 10000);
             }
                 break;
-            case MG_FIREWALL:  // ƒtƒ@ƒCƒ„�[ƒEƒH�[ƒ‹
+            case MG_FIREWALL:  // ファイヤーウォール
 /*
-			if( (t_ele!=3 && !battle_check_undead(t_race,t_ele)) || target->type==BL_PC ) //PC‚͉Α®�«‚Å‚à”ò‚Ô�H‚»‚à‚»‚àƒ_ƒ��[ƒWŽó‚¯‚é�H
+			if( (t_ele!=3 && !battle_check_undead(t_race,t_ele)) || target->type==BL_PC ) //PC��属性�も飛�？�も�もダメージ��る？
 				blewcount |= 0x10000;
 			else
 				blewcount = 0;
@@ -4304,18 +4304,18 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                     blewcount |= 0x10000;
                 MATK_FIX (1, 2);
                 break;
-            case MG_THUNDERSTORM:  // ƒTƒ“ƒ_�[ƒXƒg�[ƒ€
+            case MG_THUNDERSTORM:  // サンダーストーム
                 MATK_FIX (80, 100);
                 break;
-            case MG_FROSTDIVER:    // ƒtƒ�ƒXƒgƒ_ƒCƒo
+            case MG_FROSTDIVER:    // フロストダイ�
                 MATK_FIX (100 + skill_lv * 10, 100);
                 break;
-            case WZ_FROSTNOVA: // ƒtƒ�ƒXƒgƒ_ƒCƒo
+            case WZ_FROSTNOVA: // フロストダイ�
                 MATK_FIX (((100 + skill_lv * 10) * (2 / 3)), 100);
                 break;
-            case WZ_FIREPILLAR:    // ƒtƒ@ƒCƒ„�[ƒsƒ‰�[
+            case WZ_FIREPILLAR:    // ファイヤーピラー
                 if (mdef1 < 1000000)
-                    mdef1 = mdef2 = 0;  // MDEF–³Ž‹
+                    mdef1 = mdef2 = 0;  // MDEF無視
                 MATK_FIX (1, 5);
                 matk1 += 50;
                 matk2 += 50;
@@ -4324,26 +4324,26 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                 MATK_FIX (100 + skill_lv * 20, 100);
                 break;
             case WZ_METEOR:
-            case WZ_JUPITEL:   // ƒ†ƒsƒeƒ‹ƒTƒ“ƒ_�[
+            case WZ_JUPITEL:   // ユピテルサンダー
                 break;
-            case WZ_VERMILION: // ƒ��[ƒhƒIƒuƒo�[ƒ~ƒŠƒIƒ“
+            case WZ_VERMILION: // ロードオブ�ーミリオン
                 MATK_FIX (skill_lv * 20 + 80, 100);
                 break;
-            case WZ_WATERBALL: // ƒEƒH�[ƒ^�[ƒ{�[ƒ‹
+            case WZ_WATERBALL: // ウォーターボール
                 matk1 += skill_lv * 30;
                 matk2 += skill_lv * 30;
                 break;
-            case WZ_STORMGUST: // ƒXƒg�[ƒ€ƒKƒXƒg
+            case WZ_STORMGUST: // ストームガスト
                 MATK_FIX (skill_lv * 40 + 100, 100);
                 blewcount |= 0x10000;
                 break;
-            case AL_HOLYLIGHT: // ƒz�[ƒŠ�[ƒ‰ƒCƒg
+            case AL_HOLYLIGHT: // ホーリーライト
                 MATK_FIX (125, 100);
                 break;
             case AL_RUWACH:
                 MATK_FIX (145, 100);
                 break;
-            case HW_NAPALMVULCAN:  // ƒiƒp�[ƒ€ƒr�[ƒg�i•ªŽUŒvŽZ�ž‚Ý�j
+            case HW_NAPALMVULCAN:  // ナパームビート（分散計算込�）
                 MATK_FIX (70 + skill_lv * 10, 100);
                 if (flag > 0)
                 {
@@ -4360,7 +4360,7 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
     }
 
     if (normalmagic_flag)
-    {                           // ˆê”Ê–‚–@ƒ_ƒ��[ƒWŒvŽZ
+    {                           // 一般魔法ダメージ計算
         int  imdef_flag = 0;
         if (matk1 > matk2)
             damage = matk2 + MRAND ((matk1 - matk2 + 1));
@@ -4426,8 +4426,8 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
     {
         int  s_class = battle_get_class (bl);
         cardfix = 100;
-        cardfix = cardfix * (100 - tsd->subele[ele]) / 100; // ‘® �«‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
-        cardfix = cardfix * (100 - tsd->subrace[race]) / 100;   // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
+        cardfix = cardfix * (100 - tsd->subele[ele]) / 100; // 属 性�よるダメージ�性
+        cardfix = cardfix * (100 - tsd->subrace[race]) / 100;   // 種��よるダメージ�性
         cardfix = cardfix * (100 - tsd->magic_subrace[race]) / 100;
         if (battle_get_mode (bl) & 0x20)
             cardfix = cardfix * (100 - tsd->magic_subrace[10]) / 100;
@@ -4447,18 +4447,18 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
     if (damage < 0)
         damage = 0;
 
-    damage = battle_attr_fix (damage, ele, battle_get_element (target));    // ‘® �«�C�³
+    damage = battle_attr_fix (damage, ele, battle_get_element (target));    // 属 性修正
 
     if (skill_num == CR_GRANDCROSS)
-    {                           // ƒOƒ‰ƒ“ƒhƒNƒ�ƒX
+    {                           // グランドクロス
         struct Damage wd;
         wd = battle_calc_weapon_attack (bl, target, skill_num, skill_lv,
                                         flag);
         damage = (damage + wd.damage) * (100 + 40 * skill_lv) / 100;
         if (battle_config.gx_dupele)
-            damage = battle_attr_fix (damage, ele, battle_get_element (target));    //‘®�«2‰ñ‚©‚©‚é
+            damage = battle_attr_fix (damage, ele, battle_get_element (target));    //属性2回��る
         if (bl == target)
-            damage = damage / 2;    //”½“®‚Í”¼•ª
+            damage = damage / 2;    //�動��分
     }
 
     div_ = skill_get_num (skill_num, skill_lv);
@@ -4479,10 +4479,10 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
                 damage = (damage * (100 - battle_config.gtb_pvp_only)) / 100;
         }
         else
-            damage = 0;         // ‰© ‹à峃J�[ƒh�i–‚–@ƒ_ƒ��[ƒW‚O�j
+            damage = 0;         // 黄 金蟲カード（魔法ダメージ�）
     }
 
-    damage = battle_calc_damage (bl, target, damage, div_, skill_num, skill_lv, aflag); // �Å�I�C�³
+    damage = battle_calc_damage (bl, target, damage, div_, skill_num, skill_lv, aflag); // 最終修正
 
     /* magic_damage_return by [AppleGirl] and [Valaris]     */
     if (target->type == BL_PC && tsd && tsd->magic_damage_return > 0)
@@ -4508,7 +4508,7 @@ struct Damage battle_calc_magic_attack (struct block_list *bl,
 }
 
 /*==========================================
- * ‚»‚Ì‘¼ƒ_ƒ��[ƒWŒvŽZ
+ * ��他ダメージ計算
  *------------------------------------------
  */
 struct Damage battle_calc_misc_attack (struct block_list *bl,
@@ -4527,7 +4527,7 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
 
     int  aflag = BF_MISC | BF_LONG | BF_SKILL;
 
-    //return‘O‚Ì�ˆ—�‚ª‚ ‚é‚Ì‚Å�î•ñ�o—Í•”‚Ì‚Ý•Ï�X
+    //return��処���る��情報出力部��変更
     if (bl == NULL || target == NULL)
     {
         nullpo_info (NLP_MARK);
@@ -4547,19 +4547,19 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
     switch (skill_num)
     {
 
-        case HT_LANDMINE:      // ƒ‰ƒ“ƒhƒ}ƒCƒ“
+        case HT_LANDMINE:      // ランドマイン
             damage = skill_lv * (dex + 75) * (100 + int_) / 100;
             break;
 
-        case HT_BLASTMINE:     // ƒuƒ‰ƒXƒgƒ}ƒCƒ“
+        case HT_BLASTMINE:     // ブラストマイン
             damage = skill_lv * (dex / 2 + 50) * (100 + int_) / 100;
             break;
 
-        case HT_CLAYMORETRAP:  // ƒNƒŒƒCƒ‚ƒA�[ƒgƒ‰ƒbƒv
+        case HT_CLAYMORETRAP:  // クレイモアートラップ
             damage = skill_lv * (dex / 2 + 75) * (100 + int_) / 100;
             break;
 
-        case HT_BLITZBEAT:     // ƒuƒŠƒbƒcƒr�[ƒg
+        case HT_BLITZBEAT:     // ブリッツビート
             if (sd == NULL || (skill = pc_checkskill (sd, HT_STEELCROW)) <= 0)
                 skill = 0;
             damage = (dex / 10 + int_ / 2 + skill * 3 + 40) * 2;
@@ -4567,22 +4567,22 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
                 damage /= flag;
             break;
 
-        case TF_THROWSTONE:    // �ΓŠ‚°
+        case TF_THROWSTONE:    // 石投�
             damage = 30;
             damagefix = 0;
             break;
 
-        case BA_DISSONANCE:    // •s‹¦˜a‰¹
+        case BA_DISSONANCE:    // ��和音
             damage =
                 (skill_lv) * 20 + pc_checkskill (sd, BA_MUSICALLESSON) * 3;
             break;
 
-        case NPC_SELFDESTRUCTION:  // Ž©”š
+        case NPC_SELFDESTRUCTION:  // 自爆
             damage = battle_get_hp (bl) - (bl == target ? 1 : 0);
             damagefix = 0;
             break;
 
-        case NPC_SMOKING:      // ƒ^ƒoƒR‚ð‹z‚¤
+        case NPC_SMOKING:      // タ�コを��
             damage = 3;
             damagefix = 0;
             break;
@@ -4608,7 +4608,7 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
             }
         }
             break;
-        case SN_FALCONASSAULT: /* ƒtƒ@ƒ‹ƒRƒ“ƒAƒTƒ‹ƒg */
+        case SN_FALCONASSAULT: /* ファルコンアサルト */
             skill = pc_checkskill (sd, HT_BLITZBEAT);
             damage =
                 (100 + 50 * skill_lv +
@@ -4627,14 +4627,14 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
         if (tsd)
         {
             cardfix = 100;
-            cardfix = cardfix * (100 - tsd->subele[ele]) / 100; // ‘®�«‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
-            cardfix = cardfix * (100 - tsd->subrace[race]) / 100;   // Ží‘°‚É‚æ‚éƒ_ƒ��[ƒW‘Ï�«
+            cardfix = cardfix * (100 - tsd->subele[ele]) / 100; // 属性�よるダメージ�性
+            cardfix = cardfix * (100 - tsd->subrace[race]) / 100;   // 種��よるダメージ�性
             cardfix = cardfix * (100 - tsd->misc_def_rate) / 100;
             damage = damage * cardfix / 100;
         }
         if (damage < 0)
             damage = 0;
-        damage = battle_attr_fix (damage, ele, battle_get_element (target));    // ‘®�«�C�³
+        damage = battle_attr_fix (damage, ele, battle_get_element (target));    // 属性修正
     }
 
     div_ = skill_get_num (skill_num, skill_lv);
@@ -4649,7 +4649,7 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
         damage = div_;
     }
 
-    damage = battle_calc_damage (bl, target, damage, div_, skill_num, skill_lv, aflag); // �Å�I�C�³
+    damage = battle_calc_damage (bl, target, damage, div_, skill_num, skill_lv, aflag); // 最終修正
 
     md.damage = damage;
     md.div_ = div_;
@@ -4664,7 +4664,7 @@ struct Damage battle_calc_misc_attack (struct block_list *bl,
 }
 
 /*==========================================
- * ƒ_ƒ��[ƒWŒvŽZˆêŠ‡�ˆ—�—p
+ * ダメージ計算一括処�用
  *------------------------------------------
  */
 struct Damage battle_calc_attack (int attack_type,
@@ -4696,7 +4696,7 @@ struct Damage battle_calc_attack (int attack_type,
 }
 
 /*==========================================
- * ’Ê�í�UŒ‚�ˆ—�‚Ü‚Æ‚ß
+ * 通常攻撃処����
  *------------------------------------------
  */
 int battle_weapon_attack (struct block_list *src, struct block_list *target,
@@ -4741,7 +4741,7 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
     if (battle_check_target (src, target, BCT_ENEMY) > 0 &&
         battle_check_range (src, target, 0))
     {
-        // �UŒ‚‘Î�ۂƂȂ肤‚é‚Ì‚Å�UŒ‚
+        // 攻撃対象��り�る��攻撃
         if (sd && sd->status.weapon == 11)
         {
             if (sd->equip_index[10] >= 0)
@@ -4833,14 +4833,14 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
         }
 
         if (wd.div_ == 255 && sd)
-        {                       //ŽO’i�¶
+        {                       //三段掌
             int  delay =
                 1000 - 4 * battle_get_agi (src) - 2 * battle_get_dex (src);
             int  skilllv;
             if (wd.damage + wd.damage2 < battle_get_hp (target))
             {
                 if ((skilllv = pc_checkskill (sd, MO_CHAINCOMBO)) > 0)
-                    delay += 300 * battle_config.combo_delay_rate / 100;    //’ljÁƒfƒBƒŒƒC‚ðconf‚É‚æ‚è’²�®
+                    delay += 300 * battle_config.combo_delay_rate / 100;    //追加ディレイをconf�より調整
 
                 skill_status_change_start (src, SC_COMBO, MO_TRIPLEATTACK,
                                            skilllv, 0, 0, delay, 0);
@@ -4855,7 +4855,7 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
         {
             clif_damage (src, target, tick, wd.amotion, wd.dmotion,
                          wd.damage, wd.div_, wd.type, wd.damage2);
-            //“ñ“�—¬�¶Žè‚ƃJƒ^�[ƒ‹’ÇŒ‚‚̃~ƒX•\Ž¦(–³—�‚â‚è�`)
+            //二刀�左手�カタール追撃�ミス表示(無�やり〜)
             if (sd && sd->status.weapon >= 16 && wd.damage2 == 0)
                 clif_damage (src, target, tick + 10, wd.amotion, wd.dmotion,
                              0, 1, 0, 0);
@@ -4967,7 +4967,7 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
                                                              skilllv, tick,
                                                              flag);
                                 break;
-                            case 1:    /* Žx‰‡Œn */
+                            case 1:    /* 支�系 */
                                 if ((sc_data[SC_AUTOSPELL].val2 == AL_HEAL
                                      || (sc_data[SC_AUTOSPELL].val2 ==
                                          ALL_RESURRECTION
@@ -5011,7 +5011,7 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
                                                      [SC_AUTOSPELL].val2,
                                                      skilllv, tick, flag);
                             break;
-                        case 1:    /* Žx‰‡Œn */
+                        case 1:    /* 支�系 */
                             if ((sc_data[SC_AUTOSPELL].val2 == AL_HEAL
                                  || (sc_data[SC_AUTOSPELL].val2 ==
                                      ALL_RESURRECTION
@@ -5064,7 +5064,7 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
                                                              skilllv, tick,
                                                              flag);
                                 break;
-                            case 1:    /* Žx‰‡Œn */
+                            case 1:    /* 支�系 */
                                 if ((sd->autospell_id == AL_HEAL
                                      || (sd->autospell_id == ALL_RESURRECTION
                                          && target->type != BL_PC))
@@ -5154,7 +5154,7 @@ int battle_weapon_attack (struct block_list *src, struct block_list *target,
                                        (int) target, (int) src,
                                        skill_get_time2 (MO_BLADESTOP, lv), 0);
         }
-        if (t_sc_data && t_sc_data[SC_SPLASHER].timer != -1)    //‰£‚Á‚½‚Ì‚Å‘Î�ۂ̃xƒiƒ€ƒXƒvƒ‰ƒbƒVƒƒ�[�ó‘Ô‚ð‰ð�œ
+        if (t_sc_data && t_sc_data[SC_SPLASHER].timer != -1)    //殴����対象�ベナムスプラッシャー状態を解除
             skill_status_change_end (target, SC_SPLASHER, -1);
 
         map_freeblock_unlock ();
@@ -5183,12 +5183,12 @@ int battle_check_undead (int race, int element)
 }
 
 /*==========================================
- * “G–¡•û”»’è(1=�m’è,0=”Û’è,-1=ƒGƒ‰�[)
- * flag&0xf0000 = 0x00000:“G‚¶‚á‚È‚¢‚©”»’è�iret:1��“G‚Å‚Í‚È‚¢�j
- *				= 0x10000:ƒp�[ƒeƒB�[”»’è�iret:1=ƒp�[ƒeƒB�[ƒ�ƒ“ƒo)
- *				= 0x20000:‘S‚Ä(ret:1=“G–¡•û—¼•û)
- *				= 0x40000:“G‚©”»’è(ret:1=“G)
- *				= 0x50000:ƒp�[ƒeƒB�[‚¶‚á‚È‚¢‚©”»’è(ret:1=ƒp�[ƒeƒB‚Å‚È‚¢)
+ * 敵味方判定(1=肯定,0=�定,-1=エラー)
+ * flag&0xf0000 = 0x00000:敵�ゃ���判定（ret:1�敵����）
+ *				= 0x10000:パーティー判定（ret:1=パーティーメン�)
+ *				= 0x20000:全�(ret:1=敵味方両方)
+ *				= 0x40000:敵�判定(ret:1=敵)
+ *				= 0x50000:パーティー�ゃ���判定(ret:1=パーティ���)
  *------------------------------------------
  */
 int battle_check_target (struct block_list *src, struct block_list *target,
@@ -5201,7 +5201,7 @@ int battle_check_target (struct block_list *src, struct block_list *target,
     nullpo_retr (0, target);
 
     if (flag & 0x40000)
-    {                           // ”½“]ƒtƒ‰ƒO
+    {                           // �転フラグ
         int  ret = battle_check_target (src, target, flag & 0x30000);
         if (ret != -1)
             return !ret;
@@ -5216,7 +5216,7 @@ int battle_check_target (struct block_list *src, struct block_list *target,
             return -1;
     }
 
-    if (src->type == BL_SKILL && target->type == BL_SKILL)  // ‘Î�Û‚ªƒXƒLƒ‹ƒ†ƒjƒbƒg‚È‚ç–³�ðŒ��m’è
+    if (src->type == BL_SKILL && target->type == BL_SKILL)  // 対象�スキルユニット�ら無�件肯定
         return -1;
 
     if (target->type == BL_PC
@@ -5235,7 +5235,7 @@ int battle_check_target (struct block_list *src, struct block_list *target,
         }
     }
 
-    // ƒXƒLƒ‹ƒ†ƒjƒbƒg‚Ì�ê�‡�A�e‚ð‹�‚ß‚é
+    // スキルユニット�場��親を求�る
     if (src->type == BL_SKILL)
     {
         int  inf2 =
@@ -5257,25 +5257,25 @@ int battle_check_target (struct block_list *src, struct block_list *target,
                 return -1;
         }
     }
-    // Mob‚Åmaster_id‚ª‚ ‚Á‚Äspecial_mob_ai‚È‚ç�A�¢Š«Žå‚ð‹�‚ß‚é
+    // Mob�master_id����special_mob_ai�ら��喚主を求�る
     if (src->type == BL_MOB)
     {
         struct mob_data *md = (struct mob_data *) src;
         if (md && md->master_id > 0)
         {
-            if (md->master_id == target->id)    // Žå‚È‚ç�m’è
+            if (md->master_id == target->id)    // 主�ら肯定
                 return 1;
             if (md->state.special_mob_ai)
             {
                 if (target->type == BL_MOB)
-                {               //special_mob_ai‚Å‘Î�Û‚ªMob
+                {               //special_mob_ai�対象�Mob
                     struct mob_data *tmd = (struct mob_data *) target;
                     if (tmd)
                     {
-                        if (tmd->master_id != md->master_id)    //�¢Š«Žå‚ªˆê��‚Å‚È‚¯‚ê‚Δےè
+                        if (tmd->master_id != md->master_id)    //�喚主�一緒���れ��定
                             return 0;
                         else
-                        {       //�¢Š«Žå‚ªˆê��‚È‚Ì‚Å�m’肵‚½‚¢‚¯‚ÇŽ©”š‚͔ےè
+                        {       //�喚主�一緒���肯定�����自爆��定
                             if (md->state.special_mob_ai > 2)
                                 return 0;
                             else
@@ -5289,20 +5289,20 @@ int battle_check_target (struct block_list *src, struct block_list *target,
         }
     }
 
-    if (src == target || ss == target)  // “¯‚¶‚È‚ç�m’è
+    if (src == target || ss == target)  // ���ら肯定
         return 1;
 
     if (target->type == BL_PC
         && pc_isinvisible ((struct map_session_data *) target))
         return -1;
 
-    if (src->prev == NULL ||    // Ž€‚ñ‚Å‚é‚È‚çƒGƒ‰�[
+    if (src->prev == NULL ||    // 死ん�る�らエラー
         (src->type == BL_PC && pc_isdead ((struct map_session_data *) src)))
         return -1;
 
     if ((ss->type == BL_PC && target->type == BL_MOB) ||
         (ss->type == BL_MOB && target->type == BL_PC))
-        return 0;               // PCvsMOB‚È‚ç”Û’è
+        return 0;               // PCvsMOB�ら�定
 
     s_p = battle_get_party_id (ss);
     s_g = battle_get_guild_id (ss);
@@ -5312,20 +5312,20 @@ int battle_check_target (struct block_list *src, struct block_list *target,
 
     if (flag & 0x10000)
     {
-        if (s_p && t_p && s_p == t_p)   // “¯‚¶ƒp�[ƒeƒB‚È‚ç�m’è�i–¡•û�j
+        if (s_p && t_p && s_p == t_p)   // ��パーティ�ら肯定（味方）
             return 1;
-        else                    // ƒp�[ƒeƒBŒŸ�õ‚Ȃ瓯‚¶ƒp�[ƒeƒB‚¶‚á‚È‚¢Žž“_‚Ŕےè
+        else                    // パーティ検索�ら��パーティ�ゃ��時点��定
             return 0;
     }
 
-    if (ss->type == BL_MOB && s_g > 0 && t_g > 0 && s_g == t_g) // “¯‚¶ƒMƒ‹ƒh/mobƒNƒ‰ƒX‚È‚ç�m’è�i–¡•û�j
+    if (ss->type == BL_MOB && s_g > 0 && t_g > 0 && s_g == t_g) // ��ギルド/mobクラス�ら肯定（味方）
         return 1;
 
 //printf("ss:%d src:%d target:%d flag:0x%x %d %d ",ss->id,src->id,target->id,flag,src->type,target->type);
 //printf("p:%d %d g:%d %d\n",s_p,t_p,s_g,t_g);
 
     if (ss->type == BL_PC && target->type == BL_PC)
-    {                           // —¼•ûPVPƒ‚�[ƒh‚È‚ç”Û’è�i“G�j
+    {                           // 両方PVPモード�ら�定（敵）
         struct skill_unit *su = NULL;
         if (src->type == BL_SKILL)
             su = (struct skill_unit *) src;
@@ -5367,9 +5367,9 @@ int battle_check_target (struct block_list *src, struct block_list *target,
                         && g->alliance[i].guild_id == t_g)
                     {
                         if (g->alliance[i].opposition)
-                            return 0;   //“G‘΃Mƒ‹ƒh‚È‚ç–³�ðŒ�‚É“G
+                            return 0;   //敵対ギルド�ら無�件�敵
                         else
-                            return 1;   //“¯–¿ƒMƒ‹ƒh‚È‚ç–³�ðŒ�‚É–¡•û
+                            return 1;   //�盟ギルド�ら無�件�味方
                     }
                 }
             }
@@ -5377,11 +5377,11 @@ int battle_check_target (struct block_list *src, struct block_list *target,
         }
     }
 
-    return 1;                   // ŠY“–‚µ‚È‚¢‚Ì‚Å–³ŠÖŒW�l•¨�i‚Ü‚ “G‚¶‚á‚È‚¢‚Ì‚Å–¡•û�j
+    return 1;                   // 該当�����無関係人物（��敵�ゃ����味方）
 }
 
 /*==========================================
- * ŽË’ö”»’è
+ * 射程判定
  *------------------------------------------
  */
 int battle_check_range (struct block_list *src, struct block_list *bl,
@@ -5399,19 +5399,19 @@ int battle_check_range (struct block_list *src, struct block_list *bl,
     dy = abs (bl->y - src->y);
     arange = ((dx > dy) ? dx : dy);
 
-    if (src->m != bl->m)        // ˆá‚¤ƒ}ƒbƒv
+    if (src->m != bl->m)        // ��マップ
         return 0;
 
-    if (range > 0 && range < arange)    // ‰“‚·‚¬‚é
+    if (range > 0 && range < arange)    // ���る
         return 0;
 
-    if (arange < 2)             // “¯‚¶ƒ}ƒX‚©—×�Ú
+    if (arange < 2)             // ��マス�隣接
         return 1;
 
 //  if(bl->type == BL_SKILL && ((struct skill_unit *)bl)->group->unit_id == 0x8d)
 //      return 1;
 
-    // �áŠQ•¨”»’è
+    // 障害物判定
     wpd.path_len = 0;
     wpd.path_pos = 0;
     wpd.path_half = 0;
@@ -5427,7 +5427,7 @@ int battle_check_range (struct block_list *src, struct block_list *bl,
 
 /*==========================================
  * Return numerical value of a switch configuration (modified by [Yor])
- * on/off, english, français, deutsch, español
+ * on/off, english, fran軋is, deutsch, espal
  *------------------------------------------
  */
 int battle_config_switch (const char *str)
@@ -5443,7 +5443,7 @@ int battle_config_switch (const char *str)
 }
 
 /*==========================================
- * �Ý’èƒtƒ@ƒCƒ‹‚ð“Ç‚Ý�ž‚Þ
+ * 設定ファイルを読�込む
  *------------------------------------------
  */
 int battle_config_read (const char *cfgName)