uskills.pas

千年源代码,只缺少控件,可以做二次开发用,好不容易得来的

unit uSkills;

interface

uses
   Windows, Classes, SysUtils, BasicObj, DefType, uAnsTick, AnsStringCls;

const
   DIVRESULT_NONE = 0;
   DIVRESULT_WHATSELL = 1;
   DIVRESULT_WHATBUY = 2;
   DIVRESULT_SELLITEM = 3;
   DIVRESULT_BUYITEM = 4;
   DIVRESULT_HOWMUCH = 5;

type
   TSpeechData = record
      rSayString : String;
      rSpeechTick : integer;
      rDelayTime : integer;
   end;
   PTSpeechData = ^TSpeechData;

   TDeallerData = record
      rHearString : String;
      rSayString : String;
      rNeedItem : array[0..5 - 1] of TCheckItem;
      rGiveItem : array[0..5 - 1] of TCheckItem;
   end;
   PTDeallerData = ^TDeallerData;

   TGroupSkill = class;

   TLifeObject = class (TBasicObject)             // 蜡历绰 力寇....
   private
      OldPos : TPoint;
   protected
      CreatedX, CreatedY, ActionWidth : word;
      
      DontAttacked : Boolean; // 厚公厘...
      SoundNormal : TEffectData;
      SoundAttack : TEffectData;
      SoundDie : TEffectData;
      SoundStructed : TEffectData;

      FreezeTick : integer;
      DiedTick : integer;
      HitedTick : integer;
      WalkTick : integer;

      WalkSpeed : integer;
      LifeData : TLifeData;
      LifeObjectState : TLifeObjectState;
      CurLife, MaxLife : integer;

      FBoCopy : Boolean;
      CopiedList : TList;
      CopyBoss : TLifeObject;

      procedure InitialEx;
      procedure Initial (aMonsterName, aViewName : String);
      procedure StartProcess; override;
      procedure EndProcess; override;
      function  AllowCommand (CurTick: integer): Boolean;
      function  CommandHited (aAttacker: integer; aHitData: THitData; apercent: integer): integer;
      procedure CommandChangeCharState (aFeatureState: TFeatureState);
      procedure CommandHit (CurTick: integer);
      procedure CommandTurn (adir: word);
      procedure CommandSay (astr: string);
      function  ShootMagic (var aMagic: TMagicData; Bo : TBasicObject) : Boolean;
      function  GotoXyStand (ax, ay: word): integer;
      function  GotoXyStandAI (ax, ay : word) : Integer;
      function  FieldProc (hfu: Longint; Msg: word; var SenderInfo: TBasicData; var aSubData: TSubData): Integer; override;

      procedure ShowEffect (aEffectNumber : Word; aEffectKind : TLightEffectKind);
   public
      constructor Create;
      destructor  Destroy; override;

      function GetLifeObjectState : TLifeObjectState;
      procedure CopyDie (aBasicObject : TBasicObject);
      procedure CopyBossDie;

      procedure SetHideState (aHideState : THiddenState);
   end;

   TBuySellSkill = class
   private
      BasicObject : TBasicObject;

      boLogItem : Boolean;

      BuyItemList : TList;
      SellItemList : TList;

      FileName : String;

      procedure Clear;

      function DivHearing (aHearStr: string; var Sayer, aItemName: string; var aItemCount: integer): integer;

   public
      constructor Create (aBasicObject : TBasicObject);
      destructor Destroy; override;

      function LoadFromFile (aFileName : String) : Boolean;
      function ProcessMessage (aStr : String; SenderInfo : TBasicData) : Boolean;

      property CanLogItem : Boolean read boLogItem;
   end;

   TSpeechSkill = class
   private
      BasicObject : TBasicObject;

      SpeechList : TList;
      CurSpeechIndex : Integer;
      SpeechTick : Integer;

      procedure Clear;
   public
      constructor Create (aBasicObject : TBasicObject);
      destructor Destroy; override;

      function LoadFromFile (aFileName : String) : Boolean;
      procedure ProcessMessage (CurTick : Integer);
   end;
   
   TDeallerSkill = class
   private
      BasicObject : TBasicObject;

      DataList : TList;

      procedure Clear;
   public
      constructor Create (aBasicObject : TBasicObject);
      destructor Destroy; override;

      function LoadFromFile (aFileName : String) : Boolean;
      function ProcessMessage (aStr : String; SenderInfo : TBasicData) : Boolean;
   end;

   TAttackSkill = class
   private
      BasicObject : TBasicObject;
      Boss : TBasicObject;
      ObjectBoss : TDynamicObject;

      DeadAttackName : String;

      SaveID : Integer;
      TargetID : Integer;
      EscapeID : Integer;

      SaveNextState : TLifeObjectState;

      TargetPosTick : Integer;

      AttackMagic : TMagicData;

      boGroupSkill : Boolean;
      GroupSkill : TGroupSkill;

      BowCount : Integer;
      BowAvailTick : Integer;
      BowAvailInterval : Integer;
      boBowAvail : Boolean;

      TargetStartTick : Integer;
      TargetArrivalTick : Integer;
   public
      TargetX : Integer;
      TargetY : Integer;
   
      HateHumanID : Integer;
      CurNearViewHumanId : Integer;
      EscapeLife : Integer;

      ViewWidth : integer;

      boGroup : Boolean;
      boBoss : Boolean;
      boVassal: Boolean;
      boAutoAttack : Boolean;
      boAttack : Boolean;
      boChangeTarget : Boolean;
      boViewHuman : Boolean;
      
      VassalCount: integer;

      boSelfTarget : Boolean;
   public
      constructor Create (aBasicObject : TBasicObject);
      destructor Destroy; override;

      procedure SetSelf (aSelf : TBasicObject);
      procedure SetBoss (aBoss : TBasicObject);

      procedure SetObjectBoss (aBoss : TDynamicObject);
      function  GetObjectBoss : TDynamicObject;
      
      procedure SetDeadAttackName (aName : String);
      procedure SetTargetID (aTargetID : Integer; boCaller : Boolean);
      procedure SetHelpTargetID (aTargetID : Integer);
      procedure SetHelpTargetIDandPos (aTargetID, aX, aY : Integer);
      
      procedure SetSaveIDandPos (aTargetID : Integer; aTargetX, aTargetY : Word; aNextState : TLifeObjectState);

      procedure SetEscapeID (aEscapeID : Integer);
      procedure SetAttackMagic (aAttackMagic : TMagicData);
      procedure SetSelfTarget (boFlag : Boolean);

      procedure SetGroupSkill;
      procedure AddGroup (aBasicObject : TBasicObject);

      procedure ProcessNone (CurTick : Integer);
      procedure ProcessEscape (CurTick : Integer);
      procedure ProcessFollow (CurTick : Integer);
      function  ProcessAttack (CurTick : Integer; aBasicObject : TBasicObject) : Boolean;
      procedure ProcessMoveAttack (CurTick : Integer);
      procedure ProcessDeadAttack (CurTick : Integer);
      procedure ProcessMoveWork (CurTick : Integer);
      function  ProcessMove (CurTick : Integer) : Boolean;

      procedure HelpMe (aMeID, aTargetID, aX, aY : Integer);
      procedure CancelHelp (aTargetID : Integer);

      procedure NoticeDie;
      procedure MemberDie (aBasicObject : TBasicObject);

      property GetTargetID : Integer read TargetID;
      property GetSaveID : Integer read SaveID;
      property GetNextState : TLifeObjectState read SaveNextState;
      property GetDeadAttackName : String read DeadAttackName;
      property ArrivalTick : Integer read TargetArrivalTick;
   end;

   TGroupSkill = class
   private
      BasicObject : TBasicObject;
      MemberList : TList;
   public
      constructor Create (aBasicObject : TBasicObject);
      destructor Destroy; override;

      procedure AddMember (aBasicObject : TBasicObject);
      procedure DeleteMember (aBasicObject : TBasicObject);
      procedure BossDie;
      procedure ChangeBoss (aBasicObject : TBasicObject);

      procedure FollowMe;
      procedure FollowEachOther;
      procedure Attack (aTargetID : Integer);
      procedure MoveAttack (aTargetID, aX, aY : Integer);
      procedure CancelTarget (aTargetID : Integer);
   end;

implementation

uses
   svMain, SubUtil, aUtil32, svClass, uNpc, uMonster, uAIPath, FieldMsg,
   MapUnit, UserSDB, uUser, uItemLog;

///////////////////////////////////
//         LifeObject
///////////////////////////////////
constructor TLifeObject.Create;
begin
   inherited Create;
   FBoCopy := false;
   CopiedList := nil;
   CopyBoss := nil;
end;

destructor  TLifeObject.Destroy;
begin
   FBoCopy := false;
   CopiedList := nil;
   CopyBoss := nil;
   inherited destroy;
end;

function TLifeObject.GetLifeObjectState : TLifeObjectState;
begin
   Result := LifeObjectState;
end;

procedure TLifeObject.CopyDie (aBasicObject : TBasicObject);
var
   i : Integer;
begin
   if CopiedList = nil then exit;
   for i := 0 to CopiedList.Count - 1 do begin
      if aBasicObject = CopiedList[i] then begin
         CopiedList.Delete (i);
         exit;
      end;
   end;
end;

procedure TLifeObject.CopyBossDie;
begin
   CopyBoss := nil;
   FboAllowDelete := true;
end;

procedure TLifeObject.SetHideState (aHideState : THiddenState);
begin
   BasicData.Feature.rHideState := aHideState;
   BocChangeFeature;
end;

procedure TLifeObject.InitialEx;
begin
   LifeData.damageBody    := 55;
   LifeData.damageHead    := 0;
   LifeData.damageArm     := 0;
   LifeData.damageLeg     := 0;
   LifeData.armorBody     := 0;
   LifeData.armorHead     := 0;
   LifeData.armorArm      := 0;
   LifeData.armorLeg      := 0;
   LifeData.AttackSpeed   := 150;
   LifeData.avoid         := 25;
   LifeData.recovery      := 70;

   DontAttacked := FALSE;

   LifeObjectState := los_none;
   BasicData.Feature.rfeaturestate := wfs_normal;
end;

procedure  TLifeObject.Initial (aMonsterName, aViewName : String);
begin
   inherited Initial (aMonsterName, aViewName);

   LifeData.damageBody    := 55;
   LifeData.damageHead    := 0;
   LifeData.damageArm     := 0;
   LifeData.damageLeg     := 0;
   LifeData.armorBody     := 0;
   LifeData.armorHead     := 0;
   LifeData.armorArm      := 0;
   LifeData.armorLeg      := 0;
   LifeData.AttackSpeed   := 150;
   LifeData.avoid         := 25;
   LifeData.recovery      := 70;

   DontAttacked := FALSE;

   LifeObjectState := los_init;
end;

procedure   TLifeObject.StartProcess;
var
   CurTick : integer;
begin
   inherited StartProcess;
   
   CurTick := mmAnsTick;

   FreezeTick := CurTick;
   DiedTick := CurTick;
   HitedTick := CurTick;
   WalkTick := CurTick;

   LifeObjectState := los_none;
end;

procedure TLifeObject.EndProcess;
var
   i : Integer;
begin
   LifeObjectState := los_exit;

   if CopyBoss <> nil then begin
      CopyBoss.CopyDie (Self);
      CopyBoss := nil;
   end;
   if CopiedList <> nil then begin
      for i := 0 to CopiedList.Count - 1 do begin
         TLifeObject (CopiedList[i]).CopyBossDie;
      end;
      CopiedList.Free;
      CopiedList := nil;
   end;
   
   inherited EndProcess;
end;

function  TLifeObject.AllowCommand (CurTick: integer): Boolean;