API tools faq
paste
Advertisement
Guest User

functions

a guest
Aug 8th, 2015
292
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 21.67 KB | None | 0 0
raw download clone embed print report
  1. //Start of basic attack functions
  2.  
  3. public ObscuredInt GetDamage(NewBattleBase Attacker, NewBattleBase Defender, int att_count, float SkillValue, ref int cri_cursor, ref int evade_cursor, bool IsCriticalableforSkill)
  4. {
  5.     ObscuredBool bool1;
  6.     ObscuredBool bool2;
  7.     P3Character character1;
  8.     ObscuredFloat float1;
  9.     ObscuredFloat float2;
  10.     ObscuredFloat float3;
  11.     ObscuredFloat float4;
  12.     ObscuredFloat float5;
  13.     ObscuredFloat float6;
  14.     ObscuredFloat float7;
  15.     ObscuredInt int1;
  16.     ObscuredInt int2;
  17.     ObscuredInt int3;
  18.     ObscuredInt int4;
  19.     ObscuredInt int5;
  20.     ObscuredInt int6;
  21.     ObscuredInt int7;
  22.     ObscuredInt int8;
  23.     P3Monster monster1;
  24.     int num1;
  25.     int num2;
  26.     int num3;
  27.     int num4;
  28.     int num5;
  29.     long num6;
  30.     DateTime time1;
  31.     DateTime time2;
  32.     DateTime time3;
  33.     int1 = 0;
  34.     bool1 = false;
  35.     bool2 = false;
  36.     int2 = Util.GetRandom(0, ((int)this.damage_random));
  37.     (0F ? Attacker.Stat_Critical : ((ObscuredInt)ObscuredInt.op_Implicit(Attacker.Stat_Critical)))
  38.     if (IsCriticalableforSkill)
  39.     {
  40.         num1 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.critical);
  41.         num2 = P3GlobalDatas.cServerRandomMgr.GetData(eCursorType.critical, 1, 100);
  42.         new object[4][0] = "P3GlobalDatas.cServerRandomMgr.GetData(Critical) : Skill ";
  43.         new object[4][1] = SkillValue;
  44.         new object[4][2] = " = ";
  45.         new object[4][3] = num2;
  46.         Debug.Log(string.Concat(new object[4]));
  47.         bool1 = (num2 ? true : false);
  48.         cri_cursor = num1;
  49.     }
  50.     goto Label_0110;
  51.     num3 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.critical);
  52.     num4 = P3GlobalDatas.cServerRandomMgr.GetData(eCursorType.critical, 1, 100);
  53.     Debug.Log(("P3GlobalDatas.cServerRandomMgr.GetData(Critical) : " + num4));
  54.     bool1 = (num4 ? true : false);
  55.     cri_cursor = num3;
  56.     Label_0110:
  57.     if (bool1)
  58.     {
  59.         Attacker.IsDamagedCri = true;
  60.         Defender.IsDamagedCri = true;
  61.         goto Label_013C;
  62.     }
  63.     else
  64.     {
  65.         Attacker.IsDamagedCri = false;
  66.         Defender.IsDamagedCri = false;
  67.         Label_013C:
  68.     }
  69.     int3 = 0;
  70.     int4 = 0;
  71.     int5 = 0;
  72.     if (Attacker.IsTypeCharacter())
  73.     {
  74.         character1 = ((P3Character)Attacker._P3Base);
  75.         int3 = character1.iLevel;
  76.         int4 = character1.tiCharacter.stat_index;
  77.         int5 = this.GetGradeCorrection(((int)int4));
  78.         goto Label_01C5;
  79.     }
  80.     else
  81.     {
  82.         monster1 = ((P3Monster)Attacker._P3Base);
  83.         int3 = monster1.iLv;
  84.         int4 = monster1.grade;
  85.         int5 = this.GetGradeCorrection(((int)int4));
  86.         Label_01C5:
  87.     }
  88.     if ((SkillValue > 0F))
  89.     {
  90.         bool2 = false;
  91.         evade_cursor = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.evade);
  92.         goto Label_02A1;
  93.     }
  94.     else
  95.     {
  96.         if (Defender.IshaveBuff(eSkillEffectType.FREEZE))
  97.         {
  98.             bool2 = false;
  99.             evade_cursor = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.evade);
  100.             goto Label_02A1;
  101.         }
  102.         else
  103.         {
  104.             int6 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.evade);
  105.             int7 = P3GlobalDatas.cServerRandomMgr.GetData(eCursorType.evade, 1, 100);
  106.             evade_cursor = int6;
  107.             int8 = ((Defender.Stat_Evade - Attacker.Stat_Critical) + 10);
  108.             if ((int8 <= int7))
  109.             {
  110.                 bool2 = false;
  111.                 goto Label_028A;
  112.             }
  113.             else
  114.             {
  115.                 bool2 = true;
  116.                 Label_028A:
  117.             }
  118.             if (!NewSkillManager.Instance.IsEvadeAvailable(Defender))
  119.             {
  120.                 bool2 = false;
  121.                 Label_02A1:
  122.             }
  123.         }
  124.     }
  125.     if ((att_count < 2))
  126.     {
  127.         Attacker.IsMissedTarget = bool2;
  128.         goto Label_02C5;
  129.     }
  130.     else
  131.     {
  132.         Attacker.IsMissedTarget2 = bool2;
  133.         Label_02C5:
  134.     }
  135.     if (!bool2)
  136.     {
  137.         float1 = 0F;
  138.         time1 = DateTime.Now;
  139.         this.CheckSkillComboTimeOut(time1);
  140.         num5 = this.SkillComboCount;
  141.         if ((att_count < 2))
  142.         {
  143.             Attacker.LastNormalAttackTimeStamp = time1;
  144.             goto Label_030F;
  145.         }
  146.         else
  147.         {
  148.             Attacker.LastNormalAttackTimeStamp2 = time1;
  149.             Label_030F:
  150.         }
  151.         new string[5][0] = "Damage calc start time : ";
  152.         time2 = Util.GetDateTimeNowByServer(time1);
  153.         new string[5][1] = time2.ToString();
  154.         new string[5][2] = "(";
  155.         time3 = Util.GetDateTimeNowByServer(time1);
  156.         num6 = time3.Ticks;
  157.         new string[5][3] = num6.ToString();
  158.         new string[5][4] = ")";
  159.         Debug.Log(string.Concat(new string[5]));
  160.         if ((SkillValue > 0F))
  161.         {
  162.             float1 = SkillValue;
  163.             goto Label_0393;
  164.         }
  165.         else
  166.         {
  167.             float1 = ((float)Attacker.Stat_Attack);
  168.             Label_0393:
  169.         }
  170.         float2 = ((float)Defender.Stat_Defense);
  171.         float3 = (float1 / float2);
  172.         float4 = 1F;
  173.         float5 = 1F;
  174.         if (Attacker.IsPlayer())
  175.         {
  176.             if ((P3GlobalDatas.BattleSceneType == cSceneType.ePVP))
  177.             {
  178.                 float4 = (NewBattleManager.Instance.Element_rate(((int)Attacker.ElementType), ((int)Defender.ElementType)) + (Mathf.Max((num5 - 1F), 0F) * 0.02F));
  179.                 goto Label_045C;
  180.             }
  181.             else
  182.             {
  183.                 float4 = (Attacker.ElementStatRate + (Mathf.Max((num5 - 1F), 0F) * 0.02F));
  184.                 Label_045C:
  185.             }
  186.             goto Label_0488;
  187.         }
  188.         else
  189.         {
  190.             float4 = NewBattleManager.Instance.Element_rate(((int)Attacker.ElementType), ((int)Defender.ElementType));
  191.             Label_0488:
  192.         }
  193.         if (!P3GlobalDatas.UseFormation2)
  194.         {
  195.             float4 += Attacker.FormationStatRateForATT;
  196.             goto Label_04C2;
  197.         }
  198.         else
  199.         {
  200.             float4 = 1F;
  201.             Label_04C2:
  202.         }
  203.         if (Defender.IsPlayer())
  204.         {
  205.             if ((P3GlobalDatas.BattleSceneType == cSceneType.ePVP))
  206.             {
  207.                 float5 = (NewBattleManager.Instance.Element_rate(((int)Defender.ElementType), ((int)Attacker.ElementType)) + (Mathf.Max((num5 - 1F), 0F) * 0.02F));
  208.                 goto Label_054A;
  209.             }
  210.             else
  211.             {
  212.                 float5 = (Defender.ElementStatRate + (Mathf.Max((num5 - 1F), 0F) * 0.02F));
  213.                 Label_054A:
  214.             }
  215.             goto Label_0576;
  216.         }
  217.         else
  218.         {
  219.             float5 = NewBattleManager.Instance.Element_rate(((int)Defender.ElementType), ((int)Attacker.ElementType));
  220.             Label_0576:
  221.         }
  222.         if (!P3GlobalDatas.UseFormation2)
  223.         {
  224.             float5 += Defender.FormationStatRateForDEF;
  225.             goto Label_05B0;
  226.         }
  227.         else
  228.         {
  229.             float5 = 1F;
  230.             Label_05B0:
  231.         }
  232.         Debug.Log((("Defender.ElementStatRate[" + Defender.ElementStatRate) + "]"));
  233.         this.damage_basic = Attacker.GetDamageGrade();
  234.         float6 = ((float3 * ((ObscuredFloat)this.damage_basic)) + int2);
  235.         float6 *= (1F + ((int3 + int5) / this.damage_level_rate));
  236.         if (bool1)
  237.         {
  238.             float6 *= ((ObscuredFloat)1.5F);
  239.         }
  240.         Debug.Log((("skillComboCount[" + num5) + "]"));
  241.         Defender.IsElementDamaged = false;
  242.         Defender.elementDamaged = 0;
  243.         float6 = ((float6 * float4) - (((float6 * float4) * float5) - (float6 * float4)));
  244.         new object[4][0] = (float6 * float4);
  245.         new object[4][1] = (float6 * float4);
  246.         new object[4][2] = float5;
  247.         new object[4][3] = (float6 * float4);
  248.         Debug.Log(string.Format("pre_damage = ({0})-(({1})*{2}-({3}))", new object[4]));
  249.         if (Object.op_Implicit(Attacker))
  250.         {
  251.             if (Object.op_Implicit(Defender))
  252.             {
  253.                 Debug.Log(((("Attacker name = " + Attacker.get_name()) + " Defender name") + Defender.get_name()));
  254.             }
  255.         }
  256.         Debug.Log(("pre_damage = " + float6));
  257.         if ((SkillValue <= 0F))
  258.         {
  259.             if (this._Attacker.IsPlayer())
  260.             {
  261.                 float6 = NewBattleManager.Instance.m_UserSkill.GetUserSkillforDamageUP(((float)float6));
  262.             }
  263.             if ((P3GlobalDatas.BattleSceneType == cSceneType.ePVP))
  264.             {
  265.                 if (this._Attacker.IsEnemy())
  266.                 {
  267.                     float6 = NewBattleManager.Instance.m_EnemyUserSkill.GetUserSkillforDamageUP(((float)float6));
  268.                 }
  269.                 if (Defender.IsEnemy())
  270.                 {
  271.                     float6 = NewBattleManager.Instance.m_EnemyUserSkill.GetUserSkillforDamageDown(((float)float6));
  272.                 }
  273.             }
  274.             if (Defender.IsPlayer())
  275.             {
  276.                 float6 = NewBattleManager.Instance.m_UserSkill.GetUserSkillforDamageDown(((float)float6));
  277.             }
  278.         }
  279.         if (P3GlobalDatas.bDamageBoosting)
  280.         {
  281.             float7 = (1F + (this.DamageBoosting * ((ObscuredInt)0.01F)));
  282.             float6 *= float7;
  283.         }
  284.         int1 = Convert.ToInt32(Math.Truncate(((double)float6)));
  285.         this.debug_damage_stat = float3;
  286.         this.debug_damage_basic = ((float)this.damage_basic);
  287.         this.debug_random = ((float)int2);
  288.         this.debug_level_offset = (int3 + int5);
  289.         this.debug_level_rate = ((float)this.damage_level_rate);
  290.         this.debug_element_rate = float4;
  291.         this.debug_result_damage = ((float)int1);
  292.         goto Label_091B;
  293.     }
  294.     else
  295.     {
  296.         int1 = 0;
  297.         this.debug_result_damage = ((float)int1);
  298.         Label_091B:
  299.     }
  300.     return int1;
  301. }
  302.  
  303.  
  304. public float GetUserSkillforDamageUP(float fDamage)
  305. {
  306.     float num1;
  307.     float num2;
  308.     num1 = 0F;
  309.     num2 = 0F;
  310.     num2 = this.GetValueForVariableType(eUserSkillForBattle.NORMAL_DAMAGE_UP, eSkillVariablesType.Rate);
  311.     num1 = ((float)Convert.ToInt32(Math.Truncate((fDamage * (1F + (num2 / 100F))))));
  312.     return num1;
  313. }
  314.  
  315. public float GetUserSkillforDamageDown(float fDamage)
  316. {
  317.     float num1;
  318.     float num2;
  319.     num1 = 0F;
  320.     num2 = 0F;
  321.     num2 = this.GetValueForVariableType(eUserSkillForBattle.NORMAL_DAMAGE_DOWN, eSkillVariablesType.Rate);
  322.     num1 = ((float)Convert.ToInt32(Math.Truncate((fDamage * (1F - (num2 / 100F))))));
  323.     return num1;
  324. }
  325.  
  326. public float Element_rate(int element_type, int target_element)
  327. {
  328.     bool bool1;
  329.     bool1 = this.element_result.Get(element_type, target_element);
  330.     if (bool1)
  331.     {
  332.         if ((P3GlobalDatas.BattleSceneType == cSceneType.eDungeon))
  333.         {
  334.             Debug.Log((("P3GlobalBattleDatas._puzzlelogic.tiDungeon.element_rate[" + P3GlobalBattleDatas._puzzlelogic.tiDungeon.element_rate) + "]"));
  335.             return ((P3GlobalBattleDatas._puzzlelogic.tiDungeon.element_rate / 100F) + 1F);
  336.         }
  337.         if ((P3GlobalDatas.BattleSceneType == cSceneType.eSuperBoss))
  338.         {
  339.             return ((this.superboss_element_rate / ((ObscuredFloat)100F)) + 1F);
  340.         }
  341.         if ((P3GlobalDatas.BattleSceneType == cSceneType.ePVP))
  342.         {
  343.             return ((this.pvp_element_rate / ((ObscuredFloat)100F)) + 1F);
  344.         }
  345.         if ((P3GlobalDatas.BattleSceneType == cSceneType.eGiantBoss))
  346.         {
  347.             return ((this.pvp_element_rate / ((ObscuredFloat)100F)) + 1F);
  348.         }
  349.         if ((P3GlobalDatas.BattleSceneType == cSceneType.eWave))
  350.         {
  351.             return ((this.pvp_element_rate / ((ObscuredFloat)100F)) + 1F);
  352.         }
  353.     }
  354.     return 1F;
  355. }
  356. ///endof basic attack functions
  357. ///start of skill attack functions
  358. public float GetUserSkillForSkillDamageRate(float fStat_Attack, float fRateA, eSkillScopeType SkillScope)
  359. {
  360.     float num1;
  361.     float num2;
  362.     float num3;
  363.     Debug.Log("GetUserSkillForSkillDamageRate");
  364.     num1 = 0F;
  365.     num2 = this.GetUserSkillForSkillDamageDownRate(SkillScope);
  366.     num3 = (fRateA - num2);
  367.     Debug.Log(("DownRate fUserSkillRate " + num2));
  368.     Debug.Log(("fResultRate " + num3));
  369.     Debug.Log(("fStat_Attack " + fStat_Attack));
  370.     num1 = ((float)Convert.ToInt32(Math.Truncate((fStat_Attack * (num3 / 100F)))));
  371.     Debug.Log(("fTotalDamage " + num1));
  372.     return num1;
  373. }
  374.  
  375. public float GetUserSkillForSkillDamage(bool IsPlayer, float fStat_Attack, float fRateA, eSkillScopeType SkillScope)
  376. {
  377.     if (IsPlayer)
  378.     {
  379.         return this.m_UserSkill.GetUserSkillForSkillDamageRate(fStat_Attack, fRateA, SkillScope);
  380.     }
  381.     return this.m_EnemyUserSkill.GetUserSkillForSkillDamageRate(fStat_Attack, fRateA, SkillScope);
  382. }
  383.  
  384.  
  385. public override void execute()
  386. {
  387.     NewBattleBase base1;
  388.     NewBattleBase base2;
  389.     bool bool1;
  390.     bool bool2;
  391.     sDamage damage1;
  392.     sDamage damage2;
  393.     sDamage damage3;
  394.     sDamage damage4;
  395.     ActionDamageInfo info1;
  396.     ActionDamageInfo info2;
  397.     float num1;
  398.     int num10;
  399.     int num11;
  400.     int num2;
  401.     int num3;
  402.     int num4;
  403.     int num5;
  404.     int num6;
  405.     int num7;
  406.     int num8;
  407.     int num9;
  408.     num1 = 0F;
  409.     num2 = 0;
  410.     this._SkillData.ResultSkillVar_a = ((float)ObscuredInt.op_Implicit(this._goUser.Stat_Attack));
  411.     this._goUser.preCalcDamage = this._SkillData.ResultSkillVar_a;
  412.     bool1 = NewBattleManager.Instance.bIsSkillCritical;
  413.     if ((this._SkillData.skillScopeType == eSkillScopeType.All))
  414.     {
  415.         base1 = null;
  416.         num3 = 0;
  417.         while ((num3 < this._Targets.get_Count()))
  418.         {
  419.             base1 = this._Targets.get_Item(num3);
  420.             num4 = 0;
  421.             num5 = 0;
  422.             num6 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.double_attack);
  423.             num7 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.added_skill);
  424.             if (base1.IsPlayer())
  425.             {
  426.                 num1 = NewBattleManager.Instance.GetUserSkillForSkillDamage(base1.IsPlayer(), ((float)this._goUser.Stat_Attack), this._SkillData.iSkillVariables_a, this._SkillData.skillScopeType);
  427.                 num2 = NewBattleManager.Instance.GetSkillDamage(this._goUser, base1, num1, ref &num4, ref &num5, bool1);
  428.                 goto Label_0197;
  429.             }
  430.             else
  431.             {
  432.                 if ((P3GlobalDatas.BattleSceneType == cSceneType.ePVP))
  433.                 {
  434.                     if (base1.IsEnemy())
  435.                     {
  436.                         num1 = NewBattleManager.Instance.GetUserSkillForSkillDamage(base1.IsPlayer(), ((float)this._goUser.Stat_Attack), this._SkillData.iSkillVariables_a, this._SkillData.skillScopeType);
  437.                         num2 = NewBattleManager.Instance.GetSkillDamage(this._goUser, base1, num1, ref &num4, ref &num5, bool1);
  438.                     }
  439.                     goto Label_0197;
  440.                 }
  441.                 else
  442.                 {
  443.                     num2 = NewBattleManager.Instance.GetSkillDamage(this._goUser, base1, this._SkillData.ResultSkillVar_a, ref &num4, ref &num5, bool1);
  444.                     Label_0197:
  445.                 }
  446.             }
  447.             this._goUser.preCalcDamage = ((float)num2);
  448.             base1.preCalcDamage = ((float)num2);
  449.             damage1 = base.CreateDamage(((float)num2), this._SkillData, false, true, eHitActiontype._None);
  450.             damage1.SetCursorInfo(num4, num5, num6, num7);
  451.             info1 = new ActionDamageInfo(base1, this._goUser, damage1);
  452.             if (!NewSkillManager.Instance.IsOnlyIgnoreDamage(base1))
  453.             {
  454.                 if (NewSkillManager.Instance.IsSkillMissState(this._goUser))
  455.                 {
  456.                 }
  457.                 this._goUser.preCalcDamage = 0F;
  458.                 base1.preCalcDamage = 0F;
  459.                 damage2 = base.CreateDamage(0F, this._SkillData, true, true, eHitActiontype._None);
  460.                 damage2.SetCursorInfo(num4, num5, num6, num7);
  461.                 if (NewSkillManager.Instance.IsOnlyIgnoreDamage(base1))
  462.                 {
  463.                     damage2.fShieldDamage = ((float)num2);
  464.                     base1._PreCalShieldHP += ((ObscuredFloat)num2);
  465.                 }
  466.                 info1 = new ActionDamageInfo(base1, this._goUser, damage2);
  467.                 base1.AddSkillAction(eBattleActionType.MISSED, info1, ((bool)this._goUser.IsSkillChanceItem));
  468.                 goto Label_032D;
  469.             }
  470.             else
  471.             {
  472.                 if ((base1.PreCalcHp <= ((float)Mathf.Abs(num2))))
  473.                 {
  474.                     base1.PreCalcHp = (base1.PreCalcHp + ((float)num2));
  475.                     base1.IsDeadReady = true;
  476.                     base1.AddSkillAction(eBattleActionType.DEATH, info1, ((bool)this._goUser.IsSkillChanceItem));
  477.                     goto Label_032D;
  478.                 }
  479.                 else
  480.                 {
  481.                     base1.PreCalcHp = (base1.PreCalcHp + ((float)num2));
  482.                     base1.AddSkillAction(eBattleActionType.DAMAGED, info1, ((bool)this._goUser.IsSkillChanceItem));
  483.                     Label_032D:
  484.                 }
  485.             }
  486.             if (!NewSkillManager.Instance.IsSkillMissState(this._goUser))
  487.             {
  488.                 if (!NewSkillManager.Instance.IsOnlyIgnoreDamage(base1))
  489.                 {
  490.                     if ((Mathf.Abs(num2) > 0))
  491.                     {
  492.                         NewBattleManager.Instance.VampireSkillProcess(this._goUser, base1);
  493.                     }
  494.                 }
  495.             }
  496.             num3 += 1;
  497.             Label_0375:
  498.         }
  499.         if (!NewSkillManager.Instance.IsSkillMissState(this._goUser))
  500.         {
  501.             base.DamageReflectProcess();
  502.         }
  503.         goto Label_070C;
  504.     }
  505.     else
  506.     {
  507.         base2 = this._goUser.GetSkillTarget();
  508.         if (base2.IsDeadState())
  509.         {
  510.             return;
  511.         }
  512.         num8 = 0;
  513.         num9 = 0;
  514.         num10 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.double_attack);
  515.         num11 = P3GlobalDatas.cServerRandomMgr.GetCurSor(eCursorType.added_skill);
  516.         if (base2.IsPlayer())
  517.         {
  518.             num1 = NewBattleManager.Instance.GetUserSkillForSkillDamage(base2.IsPlayer(), ((float)this._goUser.Stat_Attack), this._SkillData.iSkillVariables_a, this._SkillData.skillScopeType);
  519.             num2 = NewBattleManager.Instance.GetSkillDamage(this._goUser, base2, num1, ref &num8, ref &num9, bool1);
  520.             goto Label_04EB;
  521.         }
  522.         else
  523.         {
  524.             if ((P3GlobalDatas.BattleSceneType == cSceneType.ePVP))
  525.             {
  526.                 if (base2.IsEnemy())
  527.                 {
  528.                     num1 = NewBattleManager.Instance.GetUserSkillForSkillDamage(base2.IsPlayer(), ((float)this._goUser.Stat_Attack), this._SkillData.iSkillVariables_a, this._SkillData.skillScopeType);
  529.                     num2 = NewBattleManager.Instance.GetSkillDamage(this._goUser, base2, num1, ref &num8, ref &num9, bool1);
  530.                 }
  531.                 goto Label_04EB;
  532.             }
  533.             else
  534.             {
  535.                 num2 = NewBattleManager.Instance.GetSkillDamage(this._goUser, base2, this._SkillData.ResultSkillVar_a, ref &num8, ref &num9, bool1);
  536.                 Label_04EB:
  537.             }
  538.         }
  539.         this._goUser.preCalcDamage = ((float)num2);
  540.         this._goUser.cursor_cri = num8;
  541.         this._goUser.cursor_evd = num9;
  542.         damage3 = base.CreateDamage(((float)num2), this._SkillData, false, true, this._goUser.HitActionType);
  543.         damage3.SetCursorInfo(num8, num9, num10, num11);
  544.         this._goUser.HitActionType = eHitActiontype._None;
  545.         info2 = new ActionDamageInfo(base2, this._goUser, damage3, this._goUser.WeaponType);
  546.         bool2 = false;
  547.         if (!NewSkillManager.Instance.IsOnlyIgnoreDamage(base2))
  548.         {
  549.             if (NewSkillManager.Instance.IsSkillMissState(this._goUser))
  550.             {
  551.             }
  552.             damage4 = base.CreateDamage(0F, this._SkillData, true, true, eHitActiontype._None);
  553.             damage4.SetCursorInfo(num8, num9, num10, num11);
  554.             if (NewSkillManager.Instance.IsOnlyIgnoreDamage(base2))
  555.             {
  556.                 damage4.fShieldDamage = ((float)num2);
  557.                 base2._PreCalShieldHP += ((ObscuredFloat)num2);
  558.             }
  559.             info2 = new ActionDamageInfo(base2, this._goUser, damage4);
  560.             base2.AddSkillAction(eBattleActionType.MISSED, info2, ((bool)this._goUser.IsSkillChanceItem));
  561.             bool2 = true;
  562.             goto Label_069C;
  563.         }
  564.         else
  565.         {
  566.             if ((base2.PreCalcHp <= ((float)Mathf.Abs(num2))))
  567.             {
  568.                 base2.PreCalcHp = (base2.PreCalcHp + ((float)num2));
  569.                 base2.IsDeadReady = true;
  570.                 base2.AddSkillAction(eBattleActionType.DEATH, info2, ((bool)this._goUser.IsSkillChanceItem));
  571.                 goto Label_069C;
  572.             }
  573.             else
  574.             {
  575.                 base2.PreCalcHp = (base2.PreCalcHp + ((float)num2));
  576.                 base2.AddSkillAction(eBattleActionType.DAMAGED, info2, ((bool)this._goUser.IsSkillChanceItem));
  577.                 Label_069C:
  578.             }
  579.         }
  580.         if (!NewSkillManager.Instance.IsSkillMissState(this._goUser))
  581.         {
  582.             if (!NewSkillManager.Instance.IsOnlyIgnoreDamage(base2))
  583.             {
  584.                 if ((Mathf.Abs(num2) > 0))
  585.                 {
  586.                     NewBattleManager.Instance.VampireSkillProcess(this._goUser, base2);
  587.                     if (!bool2)
  588.                     {
  589.                         NewBattleManager.Instance.ReflectSkillProcess(this._goUser, base2);
  590.                     }
  591.                     NewBattleManager.Instance.ShieldSkillProcess(this._goUser, base2, true);
  592.                     Label_070C:
  593.                 }
  594.             }
  595.         }
  596.     }
  597. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!