magic.pas

乐都SQL版传奇全套代码,绝对可编译

unit Magic;

interface
uses
  Windows, Classes, Grobal2, ObjBase, SysUtils, Math,mylist;
type
  TMagicManager = class
  private
    function MagBigHealing(PlayObject: TBaseObject; nPower, nX, nY: Integer):
      Boolean;
    function MagPushArround(PlayObject: TBaseObject; nPushLevel: Integer):
      Integer;                                                //抗拒火环
    function MagPushArround1(PlayObject: TBaseObject; nPushLevel: Integer):
      Integer;                                                //气功波
    function MagTurnUndead(BaseObject, TargeTBaseObject: TBaseObject; nTargetX,
      nTargetY: Integer; nLevel: Integer): Boolean;
    function MagMakeHolyCurtain(BaseObject: TBaseObject; nPower: Integer; nX,
      nY: Integer): Integer;
    function MagMakeGroupTransparent(BaseObject: TBaseObject; nX, nY: Integer;
      nHTime: Integer): Boolean;
    function MagTamming(BaseObject, TargeTBaseObject: TBaseObject; nTargetX,
      nTargetY: Integer; nMagicLevel: Integer): Boolean;
    function MagSaceMove(BaseObject: TBaseObject; nLevel: Integer): Boolean;
    function MagMakeFireCross(PlayObject: TPlayObject; nDamage, nHTime, nX, nY:
      Integer): Integer;
    function MagBigExplosion(BaseObject: TBaseObject; nPower, nX, nY: Integer;
      nRage: Integer): Boolean;
    function MagElecBlizzard(BaseObject: TBaseObject; nPower: Integer): Boolean;
    function MabMabe(BaseObject, TargeTBaseObject: TBaseObject; nPower, nLevel,
      nTargetX, nTargetY: Integer): Boolean;
    function MagMakeSlave(PlayObject: TPlayObject; UserMagic: pTUserMagic):
      Boolean;
    function MagMakeSinSuSlave(PlayObject: TPlayObject; UserMagic: pTUserMagic):
      Boolean;
    function MagWindTebo(PlayObject: TPlayObject; UserMagic: pTUserMagic):
      Boolean;
    function MagGroupLightening(PlayObject: TPlayObject; UserMagic: pTUserMagic;
      nTargetX, nTargetY: Integer; TargeTBaseObject: TBaseObject; var
      boSpellFire:
      Boolean): Boolean;
    function MagGroupAmyounsul(PlayObject: TPlayObject; UserMagic: pTUserMagic;
      nTargetX, nTargetY: Integer; TargeTBaseObject: TBaseObject): Boolean;
    function MagGroupDeDing(PlayObject: TPlayObject; UserMagic: pTUserMagic;
      nTargetX, nTargetY: Integer; TargeTBaseObject: TBaseObject): Boolean;
    function MagGroupMb(PlayObject: TPlayObject; UserMagic: pTUserMagic;
      nTargetX, nTargetY: Integer; TargeTBaseObject: TBaseObject): Boolean;

    function MagHbFireBall(PlayObject: TPlayObject; UserMagic: pTUserMagic;
      nTargetX, nTargetY: Integer; var TargeTBaseObject: TBaseObject): Boolean;
  public
    constructor Create();
    destructor Destroy; override;
    function MagMakePrivateTransparent(BaseObject: TBaseObject; nHTime:
      Integer): Boolean;
    function IsWarrSkill(wMagIdx: Integer): Boolean;
    function DoSpell(PlayObject: TPlayObject; UserMagic: pTUserMagic; nTargetX,
      nTargetY: Integer; TargeTBaseObject: TBaseObject): Boolean;


  end;
function MPow(UserMagic: pTUserMagic): Integer;
function GetPower(nPower: Integer; UserMagic: pTUserMagic): Integer;
function GetPower13(nInt: Integer; UserMagic: pTUserMagic): Integer;
function GetRPow(wInt: Integer): Word;
function CheckAmulet(PlayObject: TPlayObject; nCount: Integer; nType: Integer;
  var Idx: Integer): Boolean;
procedure UseAmulet(PlayObject: TPlayObject; nCount: Integer; nType: Integer; var
  Idx: Integer);

implementation

uses HUtil32, M2Share, Event, Envir;

function MPow(UserMagic: pTUserMagic): Integer;
begin
  Result := UserMagic.MagicInfo.wPower + Random(UserMagic.MagicInfo.wMaxPower -
    UserMagic.MagicInfo.wPower);
end;

function GetPower(nPower: Integer; UserMagic: pTUserMagic): Integer;
begin
  Result := ROUND(nPower / (UserMagic.MagicInfo.btTrainLv + 1) *
    (UserMagic.btLevel + 1)) + (UserMagic.MagicInfo.btDefPower +
    Random(UserMagic.MagicInfo.btDefMaxPower - UserMagic.MagicInfo.btDefPower));
end;

function GetPower13(nInt: Integer; UserMagic: pTUserMagic): Integer;
var
  d10                                   : Double;
  d18                                   : Double;
begin
  d10 := nInt / 3.0;
  d18 := nInt - d10;
  Result := ROUND(d18 / (UserMagic.MagicInfo.btTrainLv + 1) * (UserMagic.btLevel
    + 1) + d10 + (UserMagic.MagicInfo.btDefPower +
    Random(UserMagic.MagicInfo.btDefMaxPower -
    UserMagic.MagicInfo.btDefPower)));
end;

function GetRPow(wInt: Integer): Word;
begin
  if HiWord(wInt) > LoWord(wInt) then
  begin
    Result := Random(HiWord(wInt) - LoWord(wInt) + 1) + LoWord(wInt);
  end
  else
    Result := LoWord(wInt);
end;
//nType 为指定类型 1 为护身符 2 为毒药

function CheckAmulet(PlayObject: TPlayObject; nCount: Integer; nType: Integer;
  var Idx: Integer): Boolean;
var
  AmuletStdItem                         : pTStdItem;
begin
  Result := False;
  Idx := 0;
  if PlayObject.m_UseItems[U_ARMRINGL].wIndex > 0 then
  begin
    AmuletStdItem :=
      UserEngine.GetStdItem(PlayObject.m_UseItems[U_ARMRINGL].wIndex);
    if (AmuletStdItem <> nil) and (AmuletStdItem.StdMode = 25) then
    begin
      case nType of
        1:
          begin
            if (AmuletStdItem.Shape = 5) and
              (ROUND(PlayObject.m_UseItems[U_ARMRINGL].Dura / 100) >= nCount)
              then
            begin
              Idx := U_ARMRINGL;
              Result := True;
              exit;
            end;
          end;
        2:
          begin
            if (AmuletStdItem.Shape <= 2) and
              (ROUND(PlayObject.m_UseItems[U_ARMRINGL].Dura / 100) >= nCount)
              then
            begin
              Idx := U_ARMRINGL;
              Result := True;
              exit;
            end;
          end;
      end;
    end;
  end;

  if PlayObject.m_UseItems[U_BUJUK].wIndex > 0 then
  begin
    AmuletStdItem :=
      UserEngine.GetStdItem(PlayObject.m_UseItems[U_BUJUK].wIndex);
    if (AmuletStdItem <> nil) and (AmuletStdItem.StdMode = 25) then
    begin
      case nType of                                         //
        1:
          begin
            if (AmuletStdItem.Shape = 5) and
              (ROUND(PlayObject.m_UseItems[U_BUJUK].Dura / 100) >= nCount) then
            begin
              Idx := U_BUJUK;
              Result := True;
              exit;
            end;
          end;
        2:
          begin
            if (AmuletStdItem.Shape <= 2) and
              (ROUND(PlayObject.m_UseItems[U_BUJUK].Dura / 100) >= nCount) then
            begin
              Idx := U_BUJUK;
              Result := True;
              exit;
            end;
          end;
      end;
    end;
  end;
end;
//nType 为指定类型 1 为护身符 2 为毒药

procedure UseAmulet(PlayObject: TPlayObject; nCount: Integer; nType: Integer; var
  Idx: Integer);
begin
  if PlayObject.m_UseItems[Idx].Dura > nCount * 100 then
  begin
    Dec(PlayObject.m_UseItems[Idx].Dura, nCount * 100);
    PlayObject.SendMsg(PlayObject, RM_DURACHANGE, Idx,
      PlayObject.m_UseItems[Idx].Dura, PlayObject.m_UseItems[Idx].DuraMax, 0,
      '');
  end
  else
  begin
    PlayObject.m_UseItems[Idx].Dura := 0;
    PlayObject.SendDelItems(@PlayObject.m_UseItems[Idx]);
    PlayObject.m_UseItems[Idx].wIndex := 0;
  end;
end;

function TMagicManager.MagPushArround(PlayObject: TBaseObject; nPushLevel:
  Integer): Integer;                                        //00492204
var
  i, nDir, levelgap, push               : Integer;
  BaseObject                            : TBaseObject;
begin
  Result := 0;
  for i := 0 to PlayObject.m_VisibleActors.Count - 1 do
  begin
    BaseObject :=
      TBaseObject(pTVisibleBaseObject(PlayObject.m_VisibleActors[i]).BaseObject);
    if (abs(PlayObject.m_nCurrX - BaseObject.m_nCurrX) <= 1) and
      (abs(PlayObject.m_nCurrY - BaseObject.m_nCurrY) <= 1) then
    begin
      if (not BaseObject.m_boDeath) and (BaseObject <> PlayObject) then
      begin
        if (PlayObject.m_Abil.Level > BaseObject.m_Abil.Level) and (not
          BaseObject.m_boStickMode) then
        begin
          levelgap := PlayObject.m_Abil.Level - BaseObject.m_Abil.Level;
          if (Random(20) < 6 + nPushLevel * 3 + levelgap) then
          begin
            if PlayObject.IsProperTarget(BaseObject) then
            begin
              push := 1 + _MAX(0, nPushLevel - 1) + Random(2);
              nDir := GetNextDirection(PlayObject.m_nCurrX, PlayObject.m_nCurrY,
                BaseObject.m_nCurrX, BaseObject.m_nCurrY);
              BaseObject.CharPushed(nDir, push);
              Inc(Result);
            end;
          end;
        end;
      end;
    end;
  end;

end;

function TMagicManager.MagBigHealing(PlayObject: TBaseObject; nPower, nX, nY:
  Integer): Boolean;                                        //00492E50
var
  i                                     : Integer;
  BaseObjectList                        : TMyList;
  BaseObject                            : TBaseObject;
begin
  Result := False;
  BaseObjectList := TMyList.create;
  PlayObject.GetMapBaseObjects(PlayObject.m_PEnvir, nX, nY, 1, BaseObjectList);
  for i := 0 to BaseObjectList.Count - 1 do
  begin
    BaseObject := TBaseObject(BaseObjectList[i]);
    if PlayObject.IsProperFriend(BaseObject) then
    begin
      if BaseObject.m_WAbil.HP < BaseObject.m_WAbil.MaxHP then
      begin
        BaseObject.SendDelayMsg(PlayObject, RM_MAGHEALING, 0, nPower, 0, 0, '',
          800);
        Result := True;
      end;
      if PlayObject.m_boAbilSeeHealGauge then
      begin
        PlayObject.SendMsg(BaseObject, RM_10414, 0, 0, 0, 0, '');
        //?? RM_INSTANCEHEALGUAGE
      end;
    end;
  end;
  BaseObjectList.Free;
end;

constructor TMagicManager.Create;                           //0049214C
begin

end;

destructor TMagicManager.Destroy;
begin

  inherited;
end;

function TMagicManager.IsWarrSkill(wMagIdx: Integer): Boolean; //492190
begin
  Result := False;
  if wMagIdx in [SKILL_ONESWORD {3}, SKILL_ILKWANG {4}, SKILL_YEDO {7},
  SKILL_ERGUM {12}, SKILL_BANWOL {25}, SKILL_FIRESWORD {26}, SKILL_MOOTEBO {27}]
  then
    Result := True;
end;

function TMagicManager.DoSpell(PlayObject: TPlayObject;
  UserMagic: pTUserMagic; nTargetX, nTargetY: Integer;
  TargeTBaseObject: TBaseObject): Boolean;                  //0049350C
var
  boTrain                               : Boolean;
  boSpellFail                           : Boolean;
  boSpellFire                           : Boolean;
  n14                                   : Integer;
  n18                                   : Integer;
  n1C                                   : Integer;
  nPower                                : Integer;
  StdItem                               : pTStdItem;
  nAmuletIdx                            : Integer;

  function MPow(UserMagic: pTUserMagic): Integer;           //004921C8
  begin
    Result := UserMagic.MagicInfo.wPower + Random(UserMagic.MagicInfo.wMaxPower
      - UserMagic.MagicInfo.wPower);
  end;

  function GetPower(nPower: Integer): Integer;              //00493314
  begin
    Result := ROUND(nPower / (UserMagic.MagicInfo.btTrainLv + 1) *
      (UserMagic.btLevel + 1)) + (UserMagic.MagicInfo.btDefPower +
      Random(UserMagic.MagicInfo.btDefMaxPower -
      UserMagic.MagicInfo.btDefPower));
  end;

  function GetPower13(nInt: Integer): Integer;              //0049338C
  var
    d10                                 : Double;
    d18                                 : Double;
  begin
    d10 := nInt / 3.0;
    d18 := nInt - d10;
    Result := ROUND(d18 / (UserMagic.MagicInfo.btTrainLv + 1) *
      (UserMagic.btLevel + 1) + d10 + (UserMagic.MagicInfo.btDefPower +
      Random(UserMagic.MagicInfo.btDefMaxPower -