hgespriteengine.pas

完整的Delphi游戏开发控件

procedure TAnimatedSprite.SetAnimStart(Value: Integer);
begin
     if FAnimStart <> Value then
     begin
          FAnimStart := Value;
          FAnimPos := Value;
     end;
end;

function Mod2f(i: Double; i2: Integer): Double;
begin
     if i2=0 then
          Result := i
     else
     begin
          Result := i-Trunc(i / i2) * i2;
          if Result<0 then
               Result := i2 + Result;
     end;
end;

procedure TAnimatedSprite.DoMove(const MoveCount: Single);
begin
     if not FDoAnimate then Exit;
     case FAnimPlayMode of
          pmForward: //12345 12345  12345
          begin
               FAnimPos := FAnimPos + FAnimSpeed * MoveCount;
               if (FAnimPos >= FAnimStart + FAnimCount ) then
               begin
                    if (Trunc(FAnimPos))= FAnimStart then OnAnimStart;
                    if (Trunc(FAnimPos)) = FAnimStart + FAnimCount then
                    begin
                         FAnimEnded := True;
                         OnAnimEnd;
                    end;

                    if FAnimLooped then
                       FAnimPos := FAnimStart
                    else
                    begin
                         FAnimPos := FAnimStart + FAnimCount-1 ;
                         FDoAnimate := False;
                    end;
               end;
               FPatternIndex := Trunc(FAnimPos);
               FImageIndex := Trunc(FAnimPos);
               {
               FAnimPos := FAnimPos + FAnimSpeed*MoveCount;
               if FAnimLooped then
               begin
                    if FAnimCount>0 then
                         FAnimPos := Mod2f(FAnimPos, FAnimCount)
                    else
                         FAnimPos := 0;
               end
               else
               begin
                    if FAnimPos>=FAnimCount then
                    begin
                         FAnimPos := FAnimCount-1;
                         FAnimSpeed := 0;
                    end;
                    if FAnimPos<0 then
                    begin
                         FAnimPos := 0;
                         FAnimSpeed := 0;
                    end;
               end;
               if (Trunc(AnimPos))= FAnimStart then OnAnimStart;
               if (Trunc(FAnimPos)) = FAnimStart + FAnimCount then
               begin
                    FAnimEnded := True;
                    OnAnimEnd;
               end;
               FPatternIndex := Trunc(FAnimPos)+FAnimStart;
               FImageIndex := Trunc(FAnimPos)+FAnimStart;
          }
          end;
          pmBackward: //54321 54321 54321
          begin
               FAnimPos := FAnimPos - FAnimSpeed * MoveCount;
               if (FAnimPos < FAnimStart) then
               begin
                   if FAnimLooped then
                        FAnimPos := FAnimStart + FAnimCount
               else
               begin
                   // FAnimPos := FAnimStart;
                     FAnimPos := FAnimStart + FAnimCount;
                    FDoAnimate := False;
               end;
               end;
               FPatternIndex := Trunc(FAnimPos);
               FImageIndex := Trunc(FAnimPos);
          end;
          pmPingPong: // 12345432123454321
          begin
               FAnimPos := FAnimPos + FAnimSpeed * MoveCount;
               if FAnimLooped then
               begin
                    if (FAnimPos > FAnimStart + FAnimCount - 1) or (FAnimPos < FAnimStart) then
                        FAnimSpeed := -FAnimSpeed;
               end
               else
               begin
                    if (FAnimPos > FAnimStart + FAnimCount) or (FAnimPos < FAnimStart) then
                         FAnimSpeed := -FAnimSpeed;
                    if (Trunc(FAnimPos)) = (FAnimStart + FAnimCount) then
                              FDoFlag1 := True;
                    if (Trunc(FAnimPos) = FAnimStart) and (FDoFlag1) then
                              FDoFlag2 := True;
                    if (FDoFlag1) and (FDoFlag2) then
                    begin
                         //FAnimPos := FAnimStart;
                         FDoAnimate := False;
                         FDoFlag1 := False;
                         FDoFlag2 := False;
                    end;
               end;
                   FPatternIndex := Round(FAnimPos);
                   FImageIndex := Round(FAnimPos);
          end;
     end;
   // FPatternIndex := Trunc(FAnimPos);
   // FImageIndex := Trunc(FAnimPos);
end;

procedure TAnimatedSprite.SetAnim(AniImageName: string; AniStart, AniCount: Integer; AniSpeed: Single; AniLooped, DoMirror, DoAnimate: Boolean;
                  PlayMode: TAnimPlayMode = pmForward);
begin
     ImageName := AniImageName;
     FAnimStart := AniStart;
     FAnimCount := AniCount;
     FAnimSpeed := AniSpeed;
     FAnimLooped:= AniLooped;
     MirrorX := DoMirror;
     FDoAnimate := DoAnimate;
     FAnimPlayMode := PlayMode;

    if (FPatternIndex < FAnimStart) or (FPatternIndex >= FAnimCount + FAnimStart) then
    begin
         FPatternIndex := FAnimStart mod fanimcount ;
         FAnimPos := FAnimStart;
    end;
end;

procedure TAnimatedSprite.SetAnim(AniImageName: string; AniStart, AniCount: Integer; AniSpeed: Single; AniLooped: Boolean;
                  PlayMode: TAnimPlayMode = pmForward);
begin
     ImageName := AniImageName;
     FAnimStart := AniStart;
     FAnimCount := AniCount;
     FAnimSpeed := AniSpeed;
     FAnimLooped:= AniLooped;
     FAnimPlayMode := PlayMode;
     if (FPatternIndex < FAnimStart) or (FPatternIndex >= FAnimCount + FAnimStart) then
     begin
          FPatternIndex := FAnimStart mod fanimcount;
          FAnimPos := FAnimStart;
     end;
end;

procedure TAnimatedSprite.OnAnimStart;
begin
end;

procedure TAnimatedSprite.OnAnimEnd;
begin
end;

{ TParticleSprite}
constructor TParticleSprite.Create(const AParent: TSprite);
begin
     inherited;
     FAccelX := 0;
     FAccelY := 0;
     FVelocityX := 0;
     FVelocityY := 0;
     FUpdateSpeed :=0;
     FDecay := 0;
     FLifeTime := 1;
end;

procedure TParticleSprite.DoMove(const MoveCount: Single);
begin
     inherited;
     X := X + FVelocityX * UpdateSpeed * MoveCount;
     Y := Y + FVelocityY * UpdateSpeed * MoveCount;
     FVelocityX := FVelocityX + FAccelX * UpdateSpeed;
     FVelocityY := FVelocityY + FAccelY * UpdateSpeed;
     FLifeTime := FLifeTime - FDecay * MoveCount;
     if FLifeTime <= 0 then Dead;
end;

{  TPlayerSprite   }
constructor TPlayerSprite.Create(const AParent: TSprite);
begin
     inherited;
     FVelocityX := 0;
     FVelocityY := 0;
     Acceleration := 0;
     Decceleration := 0;
     Speed := 0;
     MinSpeed := 0;
     MaxSpeed := 0;
     FDirection := 0;
end;

procedure TPlayerSprite.SetSpeed(Value: Single);
begin
     if FSpeed > FMaxSpeed then
          FSpeed := FMaxSpeed
     else
          if FSpeed < FMinSpeed then
               FSpeed := FMinSpeed;
     FSpeed := Value;
     VelocityX := Cos256(FDirection + 192) * Speed;
     VelocityY := Sin256(FDirection + 192) * Speed;
end;

procedure TPlayerSprite.SetDirection(Value: Integer);
begin
     FDirection := Value;
     VelocityX := Cos256(FDirection + 192) * Speed;
     VelocityY := Sin256(FDirection + 192) * Speed;
end;

procedure TPlayerSprite.FlipXDirection;
begin
     if FDirection >= 64 then
          FDirection := 192 + (64 - FDirection)
     else
          if FDirection > 0 then
               FDirection := 256 - FDirection;
end;

procedure TPlayerSprite.FlipYDirection;
begin
     if FDirection > 128 then
          FDirection := 128 + (256 - FDirection)
     else
          FDirection := 128 - FDirection;
end;

procedure TPlayerSprite.Accelerate;
begin
     if FSpeed <> FMaxSpeed then
     begin
          FSpeed := FSpeed + FAcc;
          if FSpeed > FMaxSpeed then
               FSpeed := FMaxSpeed;
          VelocityX := Cos256(FDirection + 192) * Speed;
          VelocityY := Sin256(FDirection + 192) * Speed;
     end;
end;

procedure TPlayerSprite.Deccelerate;
begin
     if FSpeed <> FMinSpeed then
     begin
          FSpeed := FSpeed - FDcc;
          if FSpeed < FMinSpeed then
               FSpeed := FMinSpeed;
          VelocityX := Cos256(FDirection + 192) * Speed;
          VelocityY := Sin256(FDirection + 192) * Speed;
     end;
end;

procedure TPlayerSprite.UpdatePos(const MoveCount: Single);
begin
     inherited;
     X := X + VelocityX * MoveCount;
     Y := Y + VelocityY * MoveCount;
end;

{TFaderSprite}
procedure TFaderSprite.DoMove(const MoveCount: Single);
var
   a, b: Single;
begin
     inherited;
     FFadeEnded := False;
     a := Counter * 0.01;
     b := 1 - a;
     FCurR := Round(FSrcR * b + a * FDestR);
     FCurG := Round(FSrcG * b + a * FDestG);
     FCurB := Round(FSrcB * b + a * FDestB);
     FCurA := Round(FSrcA * b + a * FDestA);
     Counter := Counter + FSpeed * MoveCount;
     if Counter >= 100 then
     begin
          if FMultiFade then
          begin
               Inc(FCurrentColorCount);
               if FCurrentColorCount > FNumColors then
               begin
                    if FLooped then
                    begin
                         Counter := 0;
                         FCurrentColorCount := 0;
                         FCurCol := FMultiCols;
                         SetSourceColor(FCurR, FCurG, FCurB, FCurA);
                         SetDestinationColor(FCurCol^);
                         Exit;
                    end
                    else
                    begin
                         Counter := 100;
                         FFadeEnded := True;
                         FMultiFade := False;
                         FMulti := False;
                         FreeMem(FMultiCols);
                    end;
                    Exit;
               end;
               Inc(FCurCol);
               Counter := 0;
               SetSourceColor(FCurR, FCurG, FCurB, FCurA);
               SetDestinationColor(FCurCol^);
          end
          else
          if FMirrorFade then
          begin
               Inc(FMirrorCount);
               if (FMirrorCount > 1) and (FLooped = False) then
               begin
                    Counter := 100;
                    FFadeEnded := True;
               end
               else
               begin
                    Counter := 0;
                    SetDestinationColor(FSrcR, FSrcG, FSrcB, FSrcA);
                    SetSourceColor(FCurR, FCurG, FCurB, FCurA);
               end;
          end
          else
          begin
               if (FLooped) then Counter := 0
               else
               begin
                    Counter := 100;
                    FFadeEnded := True;
               end;
          end;
     end;
     Self.Red := FCurR;
     Self.Green := FCurG;
     Self.Blue := FCurB;
     Self.Alpha := FCurA;
end;

procedure TFaderSprite.Reset;
begin
     Counter := 0;
     FMirrorCount := 0;
     FFadeEnded := False;
end;

procedure TFaderSprite.SetSourceColor(Red, Green, Blue, Alpha: Byte);
begin
     FSrcR := Red;
     FSrcG := Green;
     FSrcB := Blue;
     FSrcA := Alpha;
     FCurR := Red;
     FCurG := Green;
     FCurB := Blue;
     FCurA := Alpha;
end;

procedure TFaderSprite.SetDestinationColor(Red, Green, Blue, Alpha: Byte);
begin
     FDestR := Red;
     FDestG := Green;
     FDestB := Blue;
     FDestA := Alpha;
end;

procedure TFaderSprite.SetDestinationColor(Color: Cardinal);
begin
     SetDestinationColor(ARGB(Alpha, Green, Blue , Alpha));
end;

procedure TFaderSprite.SetSourceColor(Color: Cardinal);
begin