charcls.pas

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

{
procedure GetGreenColorAndAdd (acolor: integer; var GreenColor, GreenAdd: integer);
begin
   if (acolor >= 256) or (acolor < 0) then acolor := 0;
   GreenColor := ColorDataTable[acolor*2];
   GreenAdd := ColorDataTable[acolor*2+1];
end;
}

{
procedure GetGreenColorAndAdd (acolor: integer; var GreenColor, GreenAdd: integer);
begin
   if acolor < 16 then begin
      GreenColor := ColorIndex[acolor];
      GreenAdd := 0;
   end else begin
      GreenColor := ColorIndex[acolor];
      GreenAdd := 3;
   end;
end;
}



////////////////////////////////////////////////////////////////////////////////
//                           TMovingMagicClass
////////////////////////////////////////////////////////////////////////////////

constructor TMovingMagicClass.Create (aAtzClass: TAtzClass);
begin
   FAtzClass := aAtzClass;
   Fillchar (OldMovingMagicR, Sizeof(OldMovingMagicR),0);
   MagicCount := 0;
   MagicType := 0;
end;

destructor  TMovingMagicClass.Destroy;
begin
   inherited destroy;
end;

procedure   TMovingMagicClass.Initialize (sid, eid, adeg, aspeed, ax, ay, atx, aty, aMagicShape, CurTick: integer; aType: byte);
begin
   if aType > 0 then begin
      MagicCount := 8-1;
      OldMovingMagicR.asid := sid;
      OldMovingMagicR.aeid := eid;
      OldMovingMagicR.aDeg := adeg;
      OldMovingMagicR.atx := atx;
      OldMovingMagicR.aty := aty;
      OldMovingMagicR.aMagicShape := aMagicShape;
      OldMovingMagicR.amf := aMagicShape;
      OldMovingMagicR.aspeed := aspeed;
      OldMovingMagicR.aType := atype;
      OldMovingMagicR.ax := ax;
      OldMovingMagicR.ay := ay;
   end;
   StartId := sid; EndId := eid;
   deg := adeg;
   speed := aspeed;
   x := ax; y := ay;
   Tx := atx; ty := aty;
   MagicShape := aMagicShape;
   MagicType := aType;
   LifeCycle := 30;
   Direction := GetDegDirection ( deg);
   SetAction (MAT_SHOW, mmAnsTick);

   MsImageLib := nil;
   MmImageLib := FAtzClass.GetImageLib ('y'+IntToStr(MagicShape)+'.atz', CurTick);
   MeImageLib := nil;

   RealX := x * UNITX + UNITX div 2;
   RealY := y * UNITY + UNITY div 2;
   FUsed := TRUE;
end;

procedure TMovingMagicClass.SetAction (aAction : TMagicActionType; CurTime: integer);
begin
   MagicCurAction := aAction;
   ActionStartTime := CurTime;
   curframe := 0;
   if MagicCurAction = MAT_SHOW then begin
      DrawX := x*UNITX + UNITXS;
      DrawY := y*UNITY - UNITYS;
      CharList.GetVarRealPos (StartId, DrawX, DrawY);
   end;
   RealX := DrawX;
   RealY := DrawY;
end;

procedure   TMovingMagicClass.Finalize;
begin
   FUsed := FALSE;
end;

procedure   TMovingMagicClass.Paint;
var
   tempframe : integer;
   overValue : integer;
begin
   tempframe := 0;
   overValue := 10;
   case MagicCurAction of
      MAT_SHOW:
         begin
            if MsImageLib = nil then exit;
            case MagicType of
               0 :
                  begin
                     if MmImageLib.Count = 80 then tempframe := curframe + Direction * 10
                     else tempframe := curframe;
                  end;
               1 :
                  begin
                     tempframe := Random(MmImageLib.Count-1);
                     overValue := random (3)+7;
                  end;
            end;
            BackScreen.DrawImageOveray ( MsImageLib.Images[tempframe], DrawX, DrawY, overValue);
         end;
      MAT_MOVE:
         begin
            if MmImageLib = nil then exit;
            case MagicType of
               0 :
                  begin
                     if MmImageLib.Count = 80 then tempframe := curframe + Direction * 10
                     else tempframe := curframe;
                  end;
               1 :
                  begin
                     tempframe := Random(MmImageLib.Count-1);
                     overValue := random (3)+7;
                  end;
            end;
            BackScreen.DrawImageOveray ( MmImageLib.Images[tempframe], DrawX, DrawY, overValue);
         end;
      MAT_HIDE:
         begin
            if MeImageLib = nil then exit;
            case MagicType of
               0 :
                  begin
                     if MmImageLib.Count = 80 then tempframe := curframe + Direction * 10
                     else tempframe := curframe;
                  end;
               1 :
                  begin
                     tempframe := Random(MmImageLib.Count-1);
                     overValue := random (3)+7;
                  end;
            end;
            BackScreen.DrawImageOveray ( MeImageLib.Images[tempframe], DrawX, DrawY, overValue);
         end;
   end;
end;

function    TMovingMagicClass.Update (CurTick: integer) : Integer;
var
   tdrawx, tdrawy, len : integer;
   PassTime : LongInt;
   tdeg : word;
begin
   Result := 0;
   if MagicCurAction = MAT_MOVE then Result := 1;

   PassTime := CurTick - integer(ActionStartTime);                    // 青悼捞 场车栏搁

   case MagicCurAction of
      MAT_SHOW :
         begin
            curframe := PassTime div MAGICNEXTTIME;
            if curframe >= 10 then SetAction (MAT_MOVE, CurTick);
            DrawX := x*UNITX + UNITXS;
            DrawY := y*UNITY - UNITYS;
            CharList.GetVarRealPos (StartId, DrawX, DrawY);
            case MagicType of
               0 : ;
               1 :
                  begin
                     if MagicCount > 0 then begin
                        with OldMovingMagicR do begin
                           CharList.AddMagic (asid, aeid, Random (360), Random(15)+10, ax+Random(5), ay+Random(5), atx+Random(5), aty+Random(5), aMagicShape, CurTick ,0);
                        end;
                        Dec (MagicCount);
                     end;
                  end;
            end;
         end;
      MAT_MOVE :
         begin
            tdrawx := Tx*UNITX+UNITXS;
            tdrawy := ty*UNITY-UNITYS;

            CharList.GetVarRealPos (EndId, tDrawX, tDrawY);

            curframe := curframe + 1;
            if curframe >= 10 then curframe := 0;
            Dec (LifeCycle);

            if LifeCycle = 0 then SetAction (MAT_HIDE, CurTick);
            GetDegNextPosition ( deg, speed, DrawX, DrawY);
            tdeg := GetDeg (DrawX, DrawY, tdrawx, tdrawy);

            len := (DrawX-tDrawx)*(DrawX-tDrawx)+(DrawY-tDrawy)*(DrawY-tDrawy);
            if len < 400 then begin
               Drawx := tDrawx;
               Drawy := tDrawy;
               SetAction (MAT_HIDE, CurTick);
               exit;
            end;

            deg := GetNewDeg (deg, tdeg, 20);
            if ArriveFlag then if abs(deg-tdeg) > 100 then SetAction (MAT_HIDE, CurTick);

            if deg = tdeg then ArriveFlag := TRUE;
            case MagicType of
               0 : ;
               1 :
                  begin
                     if MagicCount > 0 then begin
                        with OldMovingMagicR do begin
                           CharList.AddMagic (asid, aeid, Random(360), Random(15)+10, ax+Random(5), ay+Random(5), atx+Random(5), aty+Random(5), aMagicShape, CurTick ,0);
                        end;
                        Dec (MagicCount);
                     end;
                  end;
            end;
         end;
      MAT_HIDE :
         begin
            curframe := PassTime div MAGICNEXTTIME;
            if curframe >= 10 then SetAction (MAT_DESTROY, CurTick);

            DrawX := tx*UNITX + UNITXS;
            DrawY := ty*UNITY - UNITYS;
            CharList.GetVarRealPos (EndId, DrawX, DrawY);
         end;
      MAT_DESTROY : exit;
   end;
   RealX := DrawX;
   RealY := DrawY;
end;

//////////////////////////////////
//         BgEffect Class
//////////////////////////////////
constructor TBgEffect.Create (aAtzClass: TAtzClass);
begin
   FAtzClass := aAtzClass;
   BgEffectImage := TA2Image.Create (BgEffectMaxSize, BgEffectMaxSize, 0, 0);
end;

destructor  TBgEffect.Destroy;
begin
   BgEffectImage.Free;
   inherited destroy;
end;

procedure   TBgEffect.Initialize (ax, ay: integer; aBgEffectShape: integer; aLightEffectKind: TLightEffectKind);
begin
   BgEffectShape := aBgEffectShape;
   FFileName := format ('_%d.atz', [BgEffectShape]);
   EffectPositionData := EffectPositionClass.GetPosition (FFilename);
   BgOverValue := EffectPositionData.rArr[0];
   if BgOverValue < 1 then BgOverValue := 20;
   BgEffectTime := EffectPositionData.rArr[1];
   if BgEffectTime < 1 then BgEffectTime := 8;

   LightEffectKind := aLightEffectKind;

   RealX := ax * UNITX + UNITX div 2;
   RealY := ay * UNITY + UNITY div 2;
   BgEffectIndex := 0;
   DelayTick := 0;
   FUsed := TRUE;
end;

procedure   TBgEffect.Finalize;
begin
   FFileName := '';
   FUsed := FALSE;
end;

procedure   TBgEffect.Paint(aRealx, aRealy : integer);
begin
   if Used = FALSE then exit;
   if BgEffectImage <> nil then begin
      case LightEffectKind of
         lek_none :
            BackScreen.DrawImageOveray (BgEffectImage, RealX-BgEffectMaxSizeHalf, RealY-BgEffectMaxSizeHalf, BgOverValue);
         lek_follow :
            BackScreen.DrawImageOveray (BgEffectImage, aRealX-BgEffectMaxSizeHalf, aRealY-BgEffectMaxSizeHalf, BgOverValue);
         lek_future :;
      end;
   end;
end;

procedure   TBgEffect.SetFrame(CurTick : integer);
var
   ImageLib : TA2ImageLib;
begin
   if Used = FALSE then exit;
   ImageLib := FAtzClass.GetImageLib (FFileName, CurTick);
   if (ImageLib <> nil) then begin
      if BgEffectIndex > ImageLib.Count -1 then begin
         Finalize; exit;
      end;
   end;

   if (ImageLib <> nil) and (ImageLib.Images[BgEffectIndex] <> nil) then begin
      if BgEffectImage <> nil then BgEffectImage.Free;
      BgEffectImage := TA2Image.Create (BgEffectMaxSize, BgEffectMaxSize, 0, 0);
      BgEffectImage.DrawImage (ImageLib.Images[BgEffectIndex], ImageLib.Images[BgEffectIndex].px+BgEffectMaxSizeHalf, ImageLib.Images[BgEffectIndex].py+BgEffectMaxSizeHalf, TRUE);
      BgEffectImage.Optimize;
   end;

   inc (BgEffectIndex);
end;

function    TBgEffect.Update ( CurTick: integer) : Integer;
begin
   Result := 0;
   if CurTick > DelayTick + BgEffectTime then begin
      DelayTick := CurTick;
      SetFrame(CurTick);
   end;
end;

//////////////////////////////////
//         DynamicObject Class
//////////////////////////////////

constructor TDynamicObject.Create (aAtzClass: TAtzClass);
begin
   FAtzClass := aAtzClass;
   DynamicObjImage := TA2Image.Create (DynamicObjectMaxSize, DynamicObjectMaxSize, 0, 0);
   StructedTick := 0;
   StructedPercent := 0;

   FStartFrame := 0;
   FEndFrame := 0;
end;

destructor  TDynamicObject.Destroy;
begin
   DynamicObjImage.Free;
   inherited destroy;
end;

procedure   TDynamicObject.Initialize (aItemName: string; aId, ax, ay, aItemShape: integer;aStartFrame, aEndFrame: Word; aState: byte; aDynamicGuard: TDynamicGuard);
begin
   DynamicObjName := aItemName;
   id := aid; x := ax; y := ay;
   DynamicObjShape := aItemShape;
   DynamicObjectState := aState;
   if DynamicObjectState = 1 then DynamicObjIndex := Random (5+aStartFrame)
   else DynamicObjIndex := aStartFrame;
   FDynamicGuard := aDynamicGuard;
   FStartFrame := aStartFrame;
   FEndFrame := aEndFrame;
   DelayTick := 0;

   RealX := x * UNITX + UNITX div 2;
   RealY := y * UNITY + UNITY div 2;
   FUsed := TRUE;
end;

procedure   TDynamicObject.Finalize;
begin
   FUsed := FALSE;