player_skills.pas

RO模拟器!!适合玩仙境传说的玩家们呦~

            tc.ATK[0][4] := tc.Skill[2].Data.Data1[tc.Skill[2].Lv];
        end;
    end;


    { -------------------------------------------------- }
    { - Job: Swordsman --------------------------------- }
    { - Job ID: 1 -------------------------------------- }
    { - Skill Name: Two-Handed Sword Mastery ----------- }
    { - Skill ID Name: SM_TWOHAND ---------------------- }
    { - Skill ID: 3 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_two_handed_sword_mastery(tc : TChara) : Integer;
    begin
        if (tc.WeaponType[0] = 3) then begin
            tc.ATK[0][4] := tc.Skill[3].Data.Data1[tc.Skill[3].Lv];
        end;
    end;


    { -------------------------------------------------- }
    { - Job: Swordsman --------------------------------- }
    { - Job ID: 1 -------------------------------------- }
    { - Skill Name: HP Recovery ------------------------ }
    { - Skill ID Name: SM_RECOVERY --------------------- }
    { - Skill ID: 4 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_hp_recovery(tc : TChara; Tick : Cardinal) : Integer;
    var
        j : Integer;
    begin
        if (tc.HPRTick + 10000 <= Tick) and (tc.Sit <> 1) and (tc.Option and 6 = 0) then begin
            if tc.HP <> tc.MAXHP then begin
                j := (5 + tc.MAXHP div 500) * tc.Skill[4].Lv;
                if tc.HP + j > tc.MAXHP then j := tc.MAXHP - tc.HP;
                tc.HP := tc.HP + j;
                WFIFOW(0, $013d);
                WFIFOW(2, $0005);
                WFIFOW(4, j);
                tc.Socket.SendBuf(buf, 6);
                SendCStat1(tc, 0, 5, tc.HP);
            end;
            tc.HPRTick := Tick;
        end;
    end;
    
    
    { -------------------------------------------------- }
    { - Job: Swordsman --------------------------------- }
    { - Job ID: 1 -------------------------------------- }
    { - Skill Name: Bash ------------------------------- }
    { - Skill ID Name: SM_BASH ------------------------- }
    { - Skill ID: 5 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_bash(tc : TChara; Tick : Cardinal) : Integer;
    var
        ts : TMob;
        tc1 : TChara;
        tm : TMap;
        tl : TSkillDB;
    begin
        SKILL_TYPE := 3;

        tm := Map.Objects[Map.IndexOf(tc.Map)] as TMap;
        tl := tc.Skill[tc.MSkill].Data;

        if tc.MTargetType = 0 then begin
            ts := tc.AData;
            frmMain.DamageCalc1(tm, tc, ts, Tick, 0, tl.Data1[tc.MUseLV], tl.Element, tl.Data2[tc.MUseLV]);

            if (tc.Skill[145].Lv <> 0) and (tc.MSkill = 5) and (tc.MUseLV > 5) then begin
                if Random(1000) < tc.Skill[145].Data.Data1[tc.MUseLV] * 10 then begin
                    if (ts.Stat1 <> 3) then begin
                        ts.nStat := 3;
                        ts.BodyTick := Tick + tc.aMotion;
                    end else begin
                        ts.BodyTick := ts.BodyTick + 30000;
                    end;
                end;
            end;
        end else begin
            tc1 := tc.AData;
            frmMain.DamageCalc3(tm, tc, tc1, Tick, 0, tl.Data1[tc.MUseLV], tl.Element, tl.Data2[tc.MUseLV]);
        end;

        Result := 1;
    end;


    { -------------------------------------------------- }
    { - Job: Swordsman --------------------------------- }
    { - Job ID: 1 -------------------------------------- }
    { - Skill Name: Provoke ---------------------------- }
    { - Skill ID Name: SM_PROVOKE ---------------------- }
    { - Skill ID: 6 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_provoke(tc : TChara) : Integer;
    var
        ts : TMob;
        tc1 : TChara;
        tm : TMap;
        tl : TSkillDB;
        rand : Integer;
        k, r : Integer;
        rx, ry : Integer;
    begin
        SKILL_TYPE := 1;
        Result := -1;
        
        tm := Map.Objects[Map.IndexOf(tc.Map)] as TMap;
        tl := tc.Skill[tc.MSkill].Data;

        rand := Random(100);
        if ( (tc.Skill[tc.MSkill].Lv * 3 + 50) >= rand ) then begin
            { Provoke Successful. % chance checked. } 
            if tc.MTargetType = 0 then begin
                ts := tc.AData;

                if ( (ts.Data.Race <> 1) and (ts.Data.MEXP = 0) ) then begin
                    { PvM: Provoke Succcessful. No Undead or MVP. }
                    ts.ATKPer := word(tl.Data1[tc.MUseLV]);
                    ts.DEFPer := word(tl.Data2[tc.MUseLV]);
                    ts.ATarget := tc.ID;
                    ts.ARangeFlag := false;
                    ts.AData := tc;
                end else begin
                    { PvM: Provoke Failed. Wrong Race/Type. }
                    Result := 0;
                end;
            end else begin
                { PvP: Provoke Successful }
                tc1 := tc.AData;

                if (tc1.Sit <> 1) then begin

                    k := 0;
                    r := 0;
                    while ( (k = 0) and (r < 100) ) do begin
                        Randomize;
                        rx := randomrange(-tc1.Range,tc1.Range) + tc.Point.X;
                        Randomize;
                        ry := randomrange(-tc1.Range,tc1.Range) + tc.Point.Y;
                        k := Path_Finding(tc1.path, tm, tc1.Point.X, tc1.Point.Y, rx, ry, 1);
                        inc(r);
                    end;

                    if ( (rx = tc.Point.X) and (ry = tc.Point.y) ) then k := 0;

                    if ( (k <> 0) ) then begin
                        tc1.NextFlag := true;
                        tc1.nextpoint.X := rx;
                        tc1.nextpoint.Y := ry;
                        tc1.tgtPoint := tc1.NextPoint;
                    end;

                    WFIFOW( 0, $0139);
                    WFIFOL( 2, tc.ID);
                    WFIFOW( 6, tc.Point.X);
                    WFIFOW( 8, tc.Point.Y);
                    WFIFOW(10, tc1.Point.X);
                    WFIFOW(12, tc1.Point.Y);
                    WFIFOW(14, tc1.Range);
                    tc1.Socket.SendBuf(buf, 16);

                    tc1.MTargetType := 1;
                    tc1.AMode := 2;
                    tc1.ATarget := tc.ID;
                    tc1.AData := tc;

                    if tc1.ATick + tc1.ADelay - 200 < timeGetTime() then
                    tc1.ATick := timeGetTime() - tc1.ADelay + 200;

                    tc1.DamageFixS[1] := word(tl.Data1[tc.MUseLV]);
                    tc1.DEF1 := word(tl.Data2[tc.MUseLV]) * tc1.DEF1 div 100;
                end else begin
                    { Provoke failed. Target Dead. }
                    Result := 0;
                end;
            end;
        end else begin
            { Provoke failed. % chance too low. }
            Result := 0;
        end;
    end;


    { -------------------------------------------------- }
    { - Job: Swordsman --------------------------------- }
    { - Job ID: 1 -------------------------------------- }
    { - Skill Name: Magnum Break ----------------------- }
    { - Skill ID Name: SM_MAGNUM ----------------------- }
    { - Skill ID: 7 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_magnum_break(tc : TChara; sl : TStringList) : TStringList;
    begin
        SKILL_TYPE := 4;
        sl := find_targets(tc, sl, 2);
        Result := sl;
    end;


    { -------------------------------------------------- }
    { - Job: Swordsman --------------------------------- }
    { - Job ID: 1 -------------------------------------- }
    { - Skill Name: Endure ----------------------------- }
    { - Skill ID Name: SM_ENDURE ----------------------- }
    { - Skill ID: 8 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_endure() : Integer;
    begin
        SKILL_TYPE := 2;
        Result := -1;
    end;


    { -------------------------------------------------- }
    { - Job: Mage -------------------------------------- }
    { - Job ID: 2 -------------------------------------- }
    { - Skill Name: SP Recovery ------------------------ }
    { - Skill ID Name: MG_SRECOVERY -------------------- }
    { - Skill ID: 9 ------------------------------------ }
    { -------------------------------------------------- }
    function skill_sp_recovery(tc : TChara; Tick : Cardinal) : Integer;
    var
        j : Integer;
    begin
        if (tc.Skill[9].Lv <> 0) and (tc.SPRTick + 10000 <= Tick) and (tc.Sit <> 1 ) and (tc.Option and 6 = 0) then begin
            if tc.SP <> tc.MAXSP then begin
                j := (3 + tc.MAXSP * 2 div 1000) * tc.Skill[9].Lv;
                if tc.SP + j > tc.MAXSP then j := tc.MAXSP - tc.SP;
                tc.SP := tc.SP + j;
                WFIFOW(0, $013d);
                WFIFOW(2, $0007);
                WFIFOW(4, j);
                tc.Socket.SendBuf(buf, 6);
                SendCStat1(tc, 0, 7, tc.SP);
            end;
            tc.SPRTick := Tick;
        end;
    end;


    { -------------------------------------------------- }
    { - Job: Mage -------------------------------------- }
    { - Job ID: 2 -------------------------------------- }
    { - Skill Name: Sight ------------------------------ }
    { - Skill ID Name: MG_SIGHT ------------------------ }
    { - Skill ID: 10 ----------------------------------- }
    { -------------------------------------------------- }
    function skill_sight(tc : TChara; Tick : Cardinal) : Integer;
    var
        tm : TMap;
        tc1 : TChara;
        k1 : Integer;
        sl : TStringList;
    begin
        SKILL_TYPE := 2;
        Result := -1;

        sl := TStringList.Create;
        sl.Clear;

        tm := Map.Objects[Map.IndexOf(tc.Map)] as TMap;

        if (tc.MSkill = 10) then tc.Option := tc.Option or 1 else tc.Option := tc.Option or $2000;
        UpdateOption(tm, tc);

        sl := find_targets(tc, sl, 1);

        if sl.Count <> 0 then begin
            for k1 := 0 to sl.Count - 1 do begin
                tc1 := sl.Objects[k1] as TChara;
                if (tc1.Option and 6 <> 0) then begin
                    tc1.Option := tc1.Option and $FFF9;
                    tc1.Hidden := false;
                    tc1.SkillTick := tc1.Skill[51].Tick;
                    tc1.SkillTickID := 51;
                    CalcStat(tc1, Tick);

                    UpdateOption(tm, tc1);

                    // Colus, 20031228: Tunnel Drive speed update
                    if (tc1.Skill[213].Lv <> 0) then begin
                        SendCStat1(tc1, 0, 0, tc1.Speed);
                    end;
                end;
            end;
        end;

        sl.Free;
    end;


    { -------------------------------------------------- }
    { - Job: Archer ------------------------------------ }
    { - Job ID: 3 -------------------------------------- }
    { - Skill Name: Double Strafe ---------------------- }
    { - Skill ID Name: AC_DOUBLE ----------------------- }
    { - Skill ID: 46 ----------------------------------- }
    { -------------------------------------------------- }
    function skill_double_strafe(tc : TChara; Tick : Cardinal) : Integer;
    var
        ts : TMob;
        tc1 : TChara;
        tm : TMap;
        tl : TSkillDB;
    begin
        SKILL_TYPE := 3;

        { Alex: We need to reset this to standard damage to prevent doubling. }
        dmg[0] := dmg[0] div 2;

        tm := Map.Objects[Map.IndexOf(tc.Map)] as TMap;
        tl := tc.Skill[tc.MSkill].Data;

        if (tc.Weapon = 11) then begin
            if tc.MTargetType = 0 then begin
                ts := tc.AData;
                frmMain.DamageCalc1(tm, tc, ts, Tick, 0, tl.Data1[tc.MUseLV], tl.Element, 0);
            end else begin
                tc1 := tc.AData;
                frmMain.DamageCalc3(tm, tc, tc1, Tick, 0, tl.Data1[tc.MUseLV], tl.Element, 0);
            end;

            dmg[0] := dmg[0] * 2;
            Result := 2;
        end else begin
            SKILL_TYPE := 1;
            Result := 6;
        end;
    end;

end.