powerblaster.dpr

完整的Delphi游戏开发控件

program PowerBlaster;

{$R *.res}

uses
  Windows, Classes, SysUtils, HGEImages, HGECanvas, HGEDef, HGE, StrUtils,
  Math, HGEFont, HGESpriteEngine;

type
  TEnemyKind = (Ship, SquareShip, AnimShip, Mine);

  TMapRec = record
      X, Y, Z: Integer;
      ImageName: string[50];
  end;

  TBullet = class(TAnimatedSprite)
  private
    DestAngle: Single;
    FMoveSpeed: Integer;
    FCounter: Integer;
  public
    constructor Create(const AParent: TSprite); override;
    procedure DoMove(const MoveCount: Single); override;
    property MoveSpeed: Integer read FMoveSpeed write FMoveSpeed;
  end;

  TPlayerBullet = class(TAnimatedSprite)
  private
    FDestX, FDestY: Integer;
    FCounter: Integer;
    FMoveSpeed: Integer;
  public
    procedure DoMove(const MoveCount: Single); override;
    procedure DoCollision(const Sprite: TSprite); override;
    property DestX: Integer read FDestX write FDestX;
    property DestY: Integer read FDestY write FDestY;
    property MoveSpeed: Integer read FMoveSpeed write FMoveSpeed;
  end;

  TEnemy = class(TAnimatedSprite)
  private
    FMoveSpeed: Single;
    FTempMoveSpeed: Single;
    FRotateSpeed: Single;
    FDestX, FDestY: Integer;
    FDestAngle: Integer;
    FLookAt: Boolean;
    FKind: TEnemykind;
    FLife: Integer;
    FBullet: TBullet;
  public
    function InOffScreen: Boolean;
    procedure DoMove(const MoveCount: Single); override;
    property Kind: TEnemyKind read FKind write FKind;
    property MoveSpeed: Single read FMoveSpeed write FMoveSpeed;
    property TempMoveSpeed: Single  read FTempMoveSpeed write FTempMoveSpeed;
    property RotateSpeed: Single read FRotateSpeed write FRotateSpeed;
    property DestX: Integer read FDestX write FDestX;
    property DestY: Integer read FDestY write FDestY;
    property DestAngle: Integer read  FDestAngle write FDestAngle;
    property LookAt: Boolean read  FLookAt write  FLookAt;
    property Life: Integer read FLife write FLife;
    property Bullet: TBullet read  FBullet write  FBullet;
  end;

  TAsteroids = class(TAnimatedSprite)
  private
    FStep: Single;
    FMoveSpeed: Single;
    FRange: Single;
    FSeed: Integer;
    FPosX: Integer;
    FPosY: Integer;
    FLife: Integer;
  public
    procedure DoMove(const MoveCount: Single); override;
    property MoveSpeed: Single read FMoveSpeed write FMoveSpeed;
    property Step: Single read FStep write FStep;
    property Seed: Integer read FSeed write FSeed;
    property Range: Single read FRange write FRange;
    property PosX: Integer read FPosX write FPosX;
    property PosY: Integer read FPosY write FPosY;
    property Life: Integer read FLife write FLife;
  end;

  TFort = class(TAnimatedSprite)
  private
     FLife: Integer;
     FBullet: TBullet;
  public
    procedure DoMove(const MoveCount: Single); override;
    property Bullet: TBullet read  FBullet write  FBullet;
    property Life: Integer read FLife write FLife;
  end;

  TPlayerShip = class(TPlayerSprite)
  private
    FDoAccelerate: Boolean;
    FDoDeccelerate: Boolean;
    FLife: Single;
    FBullet: TPlayerBullet;
    FReady: Boolean;
    FReadyTime: Integer;
  public
    procedure DoMove(const MoveCount: Single); override;
    procedure DoCollision(const Sprite: TSprite); override;
    property DoAccelerate: Boolean read  FDoaccelerate write FDoAccelerate;
    property DoDeccelerate: Boolean read  FDoDeccelerate write  FDoDeccelerate;
    property Bullet: TPlayerBullet read FBullet  write FBullet;
    property Life: Single read FLife write FLife;
  end;

  TTail = class(TPlayerSprite)
  private
    FCounter: Integer;
  public
    procedure DoMove(const MoveCount: Single); override;
    property Counter: Integer read FCounter write FCounter;
  end;

  TExplosion = class(TPlayerSprite)
  public
    procedure DoMove(const MoveCount: Single); override;
  end;

  TSpark = class(TPlayerSprite)
  public
    procedure DoMove(const MoveCount: Single); override;
  end;

  TBonus = class(TAnimatedSprite)
  private
    FPX, FPY: Single;
    FStep: Single;
    FMoveSpeed: Single;
  public
    procedure DoMove(const MoveCount: Single); override;
    property PX: Single read FPX write FPX;
    property PY: Single read FPY write FPY;
    property Step:Single read FStep write FStep;
    property MoveSpeed:Single read FMoveSpeed write FMoveSpeed;
  end;


var
  HGE: IHGE = nil;
  Images: THGEimages;
  Canvas: THGECanvas;
  Fnt: IHGEFont;
  SpriteEngine: TSpriteEngine;
  CursorX, CursorY: Single;
  SpaceLayer,MistLayer1,MistLayer2: TSpriteEngine;
  PlayerShip: TPlayerShip;
  FileSize: Integer;
  MapData: array of TMapRec;
  UserRefreshRate: Integer;
  Counter, Score: Integer;

procedure LoadMap(FileName: string);
var
   Fs: TFileStream;
begin
     Fs := TFileStream.Create(ExtractFilePath(ParamStr(0)) + FileName, fmOpenRead);
     Fs.ReadBuffer(FileSize, SizeOf(FileSize));
     SetLength(MapData, FileSize);
     Fs.ReadBuffer(MapData[0], SizeOf(TMapRec) * FileSize);
     Fs.Destroy;
end;

procedure CreateMap(OffsetX, OffsetY: Integer);
var
    I: Integer;
begin
     for I := 0 to FileSize - 1  do
     begin
          if LeftStr(MapData[I].ImageName, 4) = 'Tile' then
          begin
               with  TSprite.Create(SpriteEngine) do
               begin
                    ImageName := MapData[I].ImageName;
                    Width := PatternWidth;
                    Height:= PatternHeight;
                    X := MapData[I].X + OffsetX;
                    Y := MapData[I].Y + OffsetY;
                    Z := MapData[I].Z;
                    Moved := False;
               end;
          end;
          //
          if LeftStr(MapData[I].ImageName, 4) = 'Fort' then
          begin
               with  TFort.Create(SpriteEngine) do
               begin
                    ImageName := MapData[I].ImageName;
                    DrawMode := 1;
                    Docenter := True;
                    Width := PatternWidth;
                    Height:= PatternHeight;
                    X := MapData[I].X + OffsetX - 2500 + 22;
                    Y := MapData[I].Y + OffsetY - 2500 + 40;
                    Z := MapData[I].Z;
                    Collisioned := True;
                    CollideRadius := 24;
                    Life := 5;
               end;
          end;
     end;
end;

procedure CreateSpark(PosX, PosY: Single);
var
   I, Pattern: Integer;
const
  RandNumber: array[0..1] of Integer = (5,9);
begin
     Pattern := RandomFrom(RandNumber);
     for I := 0 to 128 do
     begin
          with TSpark.Create(SpriteEngine) do
          begin
               ImageName := 'Particles';
               Width := PatternWidth;
               Height := PatternHeight;
               BlendMode :=  Blend_Add2X;
               X := PosX + -Random(30);
               Y := PosY + Random(30);
               Z := 12000;
               PatternIndex := Pattern;
               ScaleX := 1.2;
               ScaleY := 1.2;
               Red := Random(250);
               Green := Random(250);
               Blue := Random(250);
               case UserRefreshRate of
                    60:
                    begin
                         Acceleration := 0.02*1.2;
                         MinSpeed := 0.8*1.2;
                         MaxSpeed := -(0.4 + Random(2))*1.2;
                    end;
                    75:
                    begin
                         Acceleration := 0.02*1.1;
                         MinSpeed := 0.8*1.1;
                         MaxSpeed := -(0.4 + Random(2))*1.1
                    end;
                    85:
                    begin
                         Acceleration := 0.02*1.2;
                         MinSpeed := 0.8*1.2;
                         MaxSpeed := -(0.4 + Random(2))*1.2
                    end;

               end;
               Direction := I * 2;
          end;
    end;
end;

procedure CreateBonus(BonusName: string; PosX, PosY: Single);
begin
     if (Random(3) = 1) or (Random(3) = 2) then
     begin
          with TBonus.Create(SpriteEngine) do
          begin
               ImageName := BonusName;
               Width := PatternWidth;
               Height := PatternHeight;
               MoveSpeed := 0.251;
               PX := PosX - 50;
               PY := PosY - 100;
               Z := 12000;
               ScaleX := 1.5;
               ScaleY := 1.5;
               DoCenter := True;
               Collisioned := True;
               CollideRadius := 24;
               SetAnim(ImageName, 0, PatternCount, 0.25, True, False, True);
          end;
     end;
end;

procedure LoadImages;
var
  FileSearchRec: TSearchRec;
begin
  if FindFirst(ExtractFilePath(ParamStr(0)) + 'Gfx\'+ '*.png', faAnyfile, FileSearchRec) = 0 then
  repeat
    Images.LoadFromFile('Gfx\'+FileSearchRec.Name);
  until  FindNext(FileSearchRec) <> 0;
  FindClose(FileSearchRec);
  Images.LoadFromFile('Space.jpg');
  Images.LoadFromFile('AnimShip0.png',48,62);
  Images.LoadFromFile('AnimShip1.png',64,64);
  Images.LoadFromFile('Bonus0.png',32, 32);
  Images.LoadFromFile('Bonus1.png',32, 32);
  Images.LoadFromFile('Bonus2.png',32,32);
  Images.LoadFromFile('Explode.png',64,64);
  Images.LoadFromFile('Explosion2.png',64, 64);
  Images.LoadFromFile('Explosion3.png',64, 64);
  Images.LoadFromFile('Explosions.png',64, 64);
  Images.LoadFromFile('Money.png',32,32);
  Images.LoadFromFile('Roids0.png',64,64);
  Images.LoadFromFile('Roids1.png',96,96);
  Images.LoadFromFile('Roids2.png',128, 128);
  Images.LoadFromFile('Shield.png',111, 105);
  Images.LoadFromFile('Particles.png',32, 32);
end;

procedure CreateGame;
var
  MonitorFrequency, I: Integer;
  DC: THandle;
const
  RandNumber: array[0..1] of Double=(-0.15, 0.15);  
begin
     Randomize;
     DC := GetDC(HGE.System_GetState(HGE_HWND) );
     MonitorFrequency := GetDeviceCaps(DC, VREFRESH);
     case MonitorFrequency of
          60..70: UserRefreshRate := 60;
          71..75: UserRefreshRate := 75;
          76..85: UserRefreshRate := 85;
          86..100: UserRefreshRate  := 100;
          101..120: UserRefreshRate := 120;
          else
          UserRefreshRate := 85;
     end;
     SpriteEngine := TSpriteEngine.Create(nil);
     Spriteengine.Images := Images;
     Spriteengine.Canvas := Canvas;
     SpriteEngine.VisibleWidth:=850;
     SpriteEngine.VisibleHeight:=650;
     //
     SpaceLayer := TSpriteEngine.Create(nil);
     SpaceLayer.Images:= Images;
     SpaceLayer.Canvas := Canvas;
     //
     MistLayer1 := TSpriteEngine.Create(nil);
     MistLayer1.Images:= Images;
     MistLayer1.Canvas := Canvas;
     //
     MistLayer2 := TSpriteEngine.Create(nil);
     MistLayer2.Images:= Images;
     MistLayer2.Canvas := Canvas;

     //create enemys
     for I := 0 to 400 do
     begin
          with TEnemy.Create(SpriteEngine) do
          begin
               Kind := TEnemyKind(Random(4));
               DrawMode := 1;
               X := Random(8000) - 2500;
               Y := Random(8000) - 2500;
               Z := 10000;
               Collisioned := True;
               case UserRefreshRate of
                    60:
                    begin
                         MoveSpeed := (1 + (Random(4) * 0.5))*1.5;
                         RotateSpeed := 0.5 + (Random(4) * 0.4)*1.5;
                    end;
                    75:
                    begin
                         MoveSpeed := (1 + (Random(4) * 0.5))*1.25;
                         RotateSpeed := 0.5 + (Random(4) * 0.4) *1.25;
                    end;
                    85:
                    begin
                         MoveSpeed := 1 + (Random(4) * 0.5);
                         RotateSpeed := 0.5 + (Random(4) * 0.4);
                    end;
               end;

               Life := 4;