WebSVN – spacemission – Diff – /GamMain.pas


unit GamMain;
 
interface
 
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls, Menus, DIB, DXClass, DXSprite, DXDraws, DXInput, DXSounds,
  ShellAPI, DirectX{$IF CompilerVersion >= 23.0},
  System.UITypes{$IFEND}, ComLevelReader, DirectMusic, Global;
 
type
  TGameScene = (
    gsNone,
    gsTitle,
    gsMain,
    gsGameOver,
    gsNewLevel,
    gsWin
  );
 
  TGameInterval = (
    giLeicht,
    giMittel,
    giSchwer,
    giMaster
  );
 
  TBackground = class(TBackgroundSprite)
  strict private
    FSpeed: Double;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
  public
    property Speed: Double read FSpeed write FSpeed;
  end;
 
  TBackgroundSpecial = class(TBackgroundSprite)
  strict private
    FSpeed: Double;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
  public
    property Speed: Double read FSpeed write FSpeed;
  end;
 
  TExplosion = class(TImageSprite)
  strict private
    FCounter: Integer;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
  public
    constructor Create(AParent: TSprite); override;
  end;
 
  TPlayerOrEnemyOrItemState = (
    pesUnknown,
    pesNormal,
    pesExploding, // only boss, as preparation of pesDead
    pesDead,
    pesDeadVanished,
    pesFlyaway, // only player at mission end
    pesEntering,
    pesHovering // only some kind of enemies
  );
 
  TPlayerOrEnemyOrItem = class abstract (TImageSprite)
  strict protected
    FState: TPlayerOrEnemyOrItemState;
  public
    property State: TPlayerOrEnemyOrItemState read FState;
  end;
 
  TPlayerSprite = class(TPlayerOrEnemyOrItem)
  private
    FTamaCount: Integer; // accessed by TPlayerTamaSprite.Destroy
  strict private
    FCounter: Integer;
    FOldTamaTime: Integer;
  strict protected
    procedure DoCollision(Sprite: TSprite; var Done: Boolean); override;
    procedure DoMove(MoveCount: Integer); override;
  public
    constructor Create(AParent: TSprite); override;
    procedure FlyAway;
  end;
 
  TPlayerTamaSprite = class(TImageSprite)
  strict private
    FPlayerSprite: TPlayerSprite;
  strict protected
    property PlayerSprite: TPlayerSprite read FPlayerSprite write FPlayerSprite;
    procedure DoCollision(Sprite: TSprite; var Done: Boolean); override;
    procedure DoMove(MoveCount: Integer); override;
  public
    constructor Create(AParent: TSprite; APlayerSprite: TPlayerSprite); reintroduce;
    destructor Destroy; override;
  end;
 
  TEnemyClass = class of TEnemy;
  TEnemy = class abstract (TPlayerOrEnemyOrItem)
  strict protected
    FCounter: Integer;
    FLife: integer;
    procedure HitEnemy(ADead: Boolean); virtual;
  public
    property Life: integer read FLife;
    procedure Hit(AHitStrength: integer = 1);
    constructor Create(AParent: TSprite; ALifes: integer); reintroduce; virtual;
    destructor Destroy; override;
  end;
 
  TEnemyTama = class(TImageSprite)
  strict private
    FEnemySprite: TSprite;
  strict protected
    property EnemySprite: TSprite read FEnemySprite write FEnemySprite;
    procedure DoMove(MoveCount: Integer); override;
  public
    constructor Create(AParent: TSprite; AEnemySprite: TSprite); reintroduce;
  end;
 
  TEnemyMeteor = class(TEnemy)
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
  end;
 
  TEnemyUFO = class(TEnemy)
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
  end;
 
  TEnemyUFO2 = class(TEnemy)
  strict private
    FCounter: Integer;
    FTamaCount: Integer;
    FOldTamaTime: Integer;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
  end;
 
  TEnemyAttacker = class(TEnemy)
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
  end;
 
  TEnemyAttacker2 = class(TEnemy)
  strict private
    FCounter: Integer;
    FTamaF: Integer;
    FTamaT: Integer;
    FPutTama: Boolean;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
  end;
 
  TEnemyAttacker3 = class(TEnemy)
  strict private
    FCounter: Integer;
    FTamaCount: Integer;
    FOldTamaTime: Integer;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
  end;
 
  TEnemyBoss = class(TEnemy)
  strict private
    FCounter: Integer;
    FTamaF: Integer;
    FTamaT: Integer;
    FPutTama: Boolean;
    waiter1, waiter2: integer;
  strict protected
    procedure DoMove(MoveCount: Integer); override;
    procedure HitEnemy(ADead: Boolean); override;
  public
    constructor Create(AParent: TSprite; ALifes: integer); override;
    destructor Destroy; override;
  end;
 
  TItemClass = class of TItem;
  TItem = class abstract (TPlayerOrEnemyOrItem)
  strict protected
    procedure DoMove(MoveCount: Integer); override;
  public
    procedure Collected; virtual;
  end;
 
  TItemMedikit = class(TItem)
  public
    procedure Collected; override;
    constructor Create(AParent: TSprite); override;
  end;
 
  TMainForm = class(TDXForm)
    MainMenu: TMainMenu;
    Spiel: TMenuItem;
    GameStart: TMenuItem;
    GamePause: TMenuItem;
    Beenden: TMenuItem;
    Einstellungen: TMenuItem;
    OptionMusic: TMenuItem;
    Hilfe: TMenuItem;
    OptionSound: TMenuItem;
    Leer3: TMenuItem;
    Spielstand: TMenuItem;
    Leer5: TMenuItem;
    Neustart: TMenuItem;
    Spielgeschwindigkeit: TMenuItem;
    Leicht: TMenuItem;
    Mittel: TMenuItem;
    Schwer: TMenuItem;
    Informationen: TMenuItem;
    Leer6: TMenuItem;
    Leer1: TMenuItem;
    Cheat: TMenuItem;
    CheckUpdates: TMenuItem;
    Master: TMenuItem;
    Hilfe1: TMenuItem;
    N1: TMenuItem;
    Wasgibtesneues1: TMenuItem;
    procedure DXDrawFinalize(Sender: TObject);
    procedure DXDrawInitialize(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure DXTimerTimer(Sender: TObject; LagCount: Integer);
    procedure DXTimerActivate(Sender: TObject);
    procedure DXTimerDeactivate(Sender: TObject);
    procedure DXDrawInitializing(Sender: TObject);
    procedure GameStartClick(Sender: TObject);
    procedure GamePauseClick(Sender: TObject);
    procedure BeendenClick(Sender: TObject);
    procedure OptionSoundClick(Sender: TObject);
    procedure OptionMusicClick(Sender: TObject);
    procedure SpielstandClick(Sender: TObject);
    procedure NeustartClick(Sender: TObject);
    procedure LeichtClick(Sender: TObject);
    procedure MittelClick(Sender: TObject);
    procedure SchwerClick(Sender: TObject);
    procedure MasterClick(Sender: TObject);
    procedure FormShow(Sender: TObject);
    procedure InformationenClick(Sender: TObject);
    procedure CheatClick(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure FormDestroy(Sender: TObject);
    procedure CheckUpdatesClick(Sender: TObject);
    procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure HilfeTopicClick(Sender: TObject);
  private
    ProgrammGestartet: boolean;
    FSpeed: integer;
    FScene: TGameScene;
    FMusic: TSpaceMissionMusicTrack;
    FBlink: DWORD;
    FBlinkTime: DWORD;
    FFrame, FAngle, FCounter, FEnemyAdventPos: Integer;
    PlayerSprite: TPlayerSprite;
    TimerCS: TRTLCriticalSection;
    procedure StartScene(Scene: TGameScene);
    procedure EndScene;
    procedure BlinkStart;
    procedure BlinkUpdate;
    procedure StartSceneTitle;
    procedure SceneTitle;
    procedure EndSceneTitle;
    procedure StartSceneMain;
    procedure SceneMain;
    procedure EndSceneMain;
    procedure StartSceneGameOver;
    procedure SceneGameOver;
    procedure EndSceneGameOver;
    procedure StartSceneWin;
    procedure SceneWin;
    procedure EndSceneWin;
    procedure StartSceneNewLevel;
    procedure SceneNewLevel;
    procedure EndSceneNewLevel;
    procedure LevelNeuStarten;
  private
    { Diverse temporäre Variablen }
    Crash2: integer;
    EnemyCounter: integer;
    Crash: boolean;
    crashsound: boolean;
  public
    FNextScene: TGameScene;
    FScore: Integer;
    FBoss: TEnemyBoss;
    FNotSave: boolean;
    FLife: integer;
    FLevel: integer;
    FGameMode: TGameMode;
    FLifeAtLevelStart: integer;
    FScoreAtLevelStart: integer;
    FLevelDataAlreadyLoaded: boolean;
    FRestEnemies: integer;
    FCheats: TCheatSet;
    { VCL-Ersatz }
    dxdraw: TDxDraw;
    imagelist: TDxImageList;
    spriteengine: tdxspriteengine;
    dxsound: tdxsound;
    dxmusic: tdxmusic;
    wavelist: tdxwavelist;
    dxinput: tdxinput;
    dxtimer: tdxtimer;
    { Level-Routinen }
    LevelData: TLevelData;
    procedure NewLevel(lev: integer);
    procedure ResetLevelData;
    { Musik-Routinen }
    procedure MusicSwitchTrack(Name: TSpaceMissionMusicTrack);
    procedure PlayMusic(Name: TSpaceMissionMusicTrack);
    procedure StopMusic(Name: TSpaceMissionMusicTrack);
    procedure ResumeMusic(Name: TSpaceMissionMusicTrack);
    procedure PauseMusic(Name: TSpaceMissionMusicTrack);
    { Sound-Routinen }
    procedure PlaySound(Sound: TSpaceMissionSound; Wait: Boolean);
    { Grafik-Routinen }
    function GetSpriteGraphic(Sprite: TSpaceMissionGraphicSprite): TPictureCollectionItem;
    { Initialisiations-Routinen }
    procedure DXInit;
    procedure SoundInit;
    procedure MusicInit;
    { Einstellungs-Routinen }
    procedure LoadOptions;
    procedure WriteOptions;
    { Farb-Routinen }
    function ComposeColor(Dest, Src: TRGBQuad; Percent: Integer): TRGBQuad;
    procedure PalleteAnim(Col: TRGBQuad; Time: Integer);
  end;
 
var
  MainForm: TMainForm;
 
implementation
 
uses
  GamSplash, GamSpeicherung, ComInfo, GamCheat, MMSystem, Registry,
  ComHilfe;
 
{$R *.DFM}
 
const
  DXInputButton = [isButton1, isButton2, isButton3,
    isButton4, isButton5, isButton6, isButton7, isButton8, isButton9, isButton10, isButton11,
    isButton12, isButton13, isButton14, isButton15, isButton16, isButton17, isButton18,
    isButton19, isButton20, isButton21, isButton22, isButton23, isButton24, isButton25,
    isButton26, isButton27, isButton28, isButton29, isButton30, isButton31, isButton32];
 
resourcestring
  SWeiterMitLeertaste = 'Weiter mit Leertaste';
 
{ TBackground }
 
procedure TBackground.DoMove(MoveCount: Integer);
var
  ran: integer;
  bgs: TBackgroundSpecial;
begin
  inherited DoMove(MoveCount);
  X := X - MoveCount*(60/1000)*FSpeed;
  ran := Random(1500);
  if ran = 150 then
  begin
    bgs := TBackgroundSpecial.Create(mainform.SpriteEngine.Engine);
    bgs.SetMapSize(1, 1);
    bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundPlanet1);
    bgs.Width := Image.Width;
    bgs.Height := Image.Height;
    bgs.Y := random(mainform.dxdraw.height);
    bgs.X := mainform.dxdraw.width;
    ran := Random(2);
    if ran = 0 then
    begin
      bgs.Z := -20;
      bgs.Speed := 1.8;
    end
    else if ran = 1 then
    begin
      bgs.Z := -40;
      bgs.Speed := 0.8;
    end
    else if ran = 2 then
    begin
      bgs.Z := -60;
      bgs.Speed := 0.3;
    end;
  end
  else if ran = 500 then
  begin
    bgs := TBackgroundSpecial.Create(mainform.SpriteEngine.Engine);
    bgs.SetMapSize(1, 1);
    ran := Random(4);
    if ran = 0 then
      bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundRed)
    else if ran = 1 then
      bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundBlue)
    else if ran = 2 then
      bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundYellow)
    else if ran = 3 then
      bgs.Image := MainForm.GetSpriteGraphic(smgHintergrundRot);
    bgs.Width := Image.Width;
    bgs.Height := Image.Height;
 
    bgs.Y := random(mainform.dxdraw.height);
    bgs.X := mainform.dxdraw.width;
 
    { ran := Random(2);
    if ran = 0 then
    begin
      bgs.Z := -20;
      bgs.Speed := 1.8;
    end
    else if ran = 1 then
    begin
      bgs.Z := -40;
      bgs.Speed := 0.8;
    end
    else if ran = 2 then
    begin }
      bgs.Z := -60;
      bgs.Speed := 0.3;
    { end; }
  end;
end;
 
{ TBackgroundSpecial }
 
procedure TBackgroundSpecial.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  X := X - MoveCount*(60/1000)*FSpeed;
  if X < -Width then Dead;
end;
 
{ TExplosion }
 
constructor TExplosion.Create(AParent: TSprite);
begin
  inherited Create(AParent);
  mainform.PlaySound(smsExplosion, false);
  Image := MainForm.GetSpriteGraphic(smgExplosion);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  AnimPos := Random(AnimCount);
end;
 
procedure TExplosion.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  inc(FCounter, MoveCount);
  if FCounter > 2999 then dead;
end;
 
{ TPlayerSprite }
 
constructor TPlayerSprite.Create(AParent: TSprite);
begin
  inherited Create(AParent);
  FState := pesEntering;
  Image := MainForm.GetSpriteGraphic(smgMachine);
  Width := Image.Width;
  Height := Image.Height;
  X := -70{20};
  Y := mainform.dxdraw.surfaceHeight / 2 - (height / 2);
  Z := 2;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
end;
 
procedure TPlayerSprite.DoCollision(Sprite: TSprite; var Done: Boolean);
begin
  if (Sprite is TItem) then
  begin
    TItem(Sprite).Collected;
  end
  else if ((Sprite is TEnemy) or (Sprite is TEnemyTama)) and not (ctInfiniteLives in mainform.FCheats) then
  begin
    if not mainform.crash then
    begin
      dec(MainForm.FLife);
      mainform.Crash := true;
      if MainForm.Flife=0 then
      begin
        MainForm.PlaySound(smsExplosion, false);
        Collisioned := false;
        FCounter := 0;
        FState := pesDead;
        Done := false;
        Image := MainForm.GetSpriteGraphic(smgExplosion);
        Width := Image.Width;
        Height := Image.Height;
        AnimCount := Image.PatternCount;
        AnimLooped := False;
        AnimSpeed := DEFAULT_ANIMSPEED;
        AnimPos := 0;
      end;
    end
    else
    begin
      if not mainform.crashsound then
      begin
        MainForm.PlaySound(smsHit, False);
        mainform.crashsound := true;
      end;
    end;
  end;
end;
 
procedure TPlayerSprite.DoMove(MoveCount: Integer);
const
  WegduesKonstante = 1.75;
begin
  inherited DoMove(MoveCount);
  if State = pesNormal then
  begin
    if isUp in MainForm.DXInput.States then Y := Y - (250/1000)*MoveCount;
    if isDown in MainForm.DXInput.States then Y := Y + (250/1000)*MoveCount;
    if isLeft in MainForm.DXInput.States then X := X - (250/1000)*MoveCount;
    if isRight in MainForm.DXInput.States then X := X + (250/1000)*MoveCount;
    if X<0 then X := 0;
    if X>mainform.dxdraw.surfacewidth-Width then X := mainform.dxdraw.surfacewidth-Width;
    if Y<0 then Y := 0;
    if Y>mainform.dxdraw.surfaceheight-Height then Y := mainform.dxdraw.surfaceheight-Height;
    if isButton1 in MainForm.DXInput.States then
    begin
      if (FTamaCount<8) and (FCounter-FOldTamaTime>=100) then
      begin
        Inc(FTamaCount);
        with TPlayerTamaSprite.Create(Engine, Self) do
        begin
          X := Self.X+Self.Width;
          Y := Self.Y+Self.Height div 2-Height div 2;
          Z := 10;
        end;
        FOldTamaTime := FCounter;
      end;
    end;
    Collision;
  end
  else if State = pesDead then
  begin
    if FCounter>200 then
    begin
      FCounter := 0;
      FState := pesDeadVanished;
      Visible := false; // Cannot use "Dead;" because we need to still be able to handle pesDeadVanished
    end;
  end
  else if State = pesDeadVanished then
  begin
    if FCounter>2000 then
    begin
      MainForm.LevelNeuStarten;
      (*
      MainForm.FNextScene := gsGameOver;
      MainForm.PlaySound(smsSceneMov, false);
      MainForm.PalleteAnim(RGBQuad(0, 0, 0), 300);
      Sleep(200);
      *)
    end;
  end
  else if State = pesFlyaway then
  begin
    X := X + MoveCount*(300/1000) * (X/MainForm.DXDraw.Width + WegduesKonstante);
    if X > MainForm.DXDraw.Width+Width then
    begin
      Dead;
      inc(mainform.FLevel);
      MainForm.FLevelDataAlreadyLoaded := false; // allow NewLevel() to work again
      MainForm.FNextScene := gsNewLevel;
      MainForm.PlaySound(smsSceneMov, false);
      MainForm.PalleteAnim(RGBQuad(0, 0, 0), 300);
    end;
  end
  else if State = pesEntering then
  begin
    X := X + MoveCount*(300/1000);
    if X > 19 then FState := pesNormal;
  end;
  inc(FCounter, MoveCount);
end;
 
procedure TPlayerSprite.FlyAway;
begin
  FState := pesFlyaway;
end;
 
{ TPlayerTamaSprite }
 
constructor TPlayerTamaSprite.Create(AParent: TSprite; APlayerSprite: TPlayerSprite);
begin
  inherited Create(AParent);
  FPlayerSprite := APlayerSprite;
  Image := MainForm.GetSpriteGraphic(smgBounce);
  Z := 2;
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  MainForm.PlaySound(smsShoot, False);
end;
 
destructor TPlayerTamaSprite.Destroy;
begin
  inherited Destroy;
  Dec(FPlayerSprite.FTamaCount);
end;
 
procedure TPlayerTamaSprite.DoCollision(Sprite: TSprite; var Done: Boolean);
begin
  if (Sprite is TEnemy) and not (Sprite is TEnemyTama) then
  begin
    TEnemy(Sprite).Hit;
    Dead;
  end;
  Done := False;
end;
 
procedure TPlayerTamaSprite.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  X := X+(800/1000)*MoveCount;
  if X>=mainform.dxdraw.surfacewidth then Dead;
  Collision;
end;
 
{ TEnemy }
 
constructor TEnemy.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent);
  FLife := ALifes;
  inc(mainform.EnemyCounter);
end;
 
destructor TEnemy.Destroy;
begin
  inherited Destroy;
  dec(mainform.EnemyCounter);
end;
 
procedure TEnemy.Hit(AHitStrength: integer = 1);
begin
  Dec(FLife, AHitStrength);
  if FLife<=0 then
  begin
    Collisioned := False;
    HitEnemy(True);
  end
  else
    HitEnemy(False);
end;
 
procedure TEnemy.HitEnemy(ADead: Boolean);
begin
  if ADead then
    MainForm.PlaySound(smsExplosion, False)
  else
    MainForm.PlaySound(smsHit, False);
end;
 
{ TEnemyTama }
 
constructor TEnemyTama.Create(AParent: TSprite; AEnemySprite: TSprite);
begin
  inherited Create(AParent);
  FEnemySprite := AEnemySprite;
  Image := MainForm.GetSpriteGraphic(smgBounce2);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  MainForm.PlaySound(smsShoot, False);
end;
 
procedure TEnemyTama.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  X := X - MoveCount*(600/1000);
  if X < -Width then Dead;
end;
 
{ TEnemyMeteor }
 
constructor TEnemyMeteor.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesNormal;
  Image := MainForm.GetSpriteGraphic(smgEnemyMeteor);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  PixelCheck := True;
end;
 
procedure TEnemyMeteor.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(False);
 
  if ADead then Collisioned := True;
end;
 
procedure TEnemyMeteor.DoMove(MoveCount: Integer);
begin
  X := X - MoveCount*(250/1000);
  if X < -Width then Dead;
end;
 
{ TEnemyUFO }
 
constructor TEnemyUFO.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesNormal;
  Image := MainForm.GetSpriteGraphic(smgEnemyDisk);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
end;
 
procedure TEnemyUFO.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(ADead);
 
  if ADead then
  begin
    FState := pesDead;
    FCounter := 0;
    Inc(MainForm.FScore, 1000);
    Image := MainForm.GetSpriteGraphic(smgExplosion);
    Width := Image.Width;
    Height := Image.Height;
    AnimCount := Image.PatternCount;
    AnimLooped := False;
    AnimSpeed := DEFAULT_ANIMSPEED;
    AnimPos := 0;
  end
  else
  begin
    Inc(MainForm.FScore, 100);
  end;
end;
 
procedure TEnemyUFO.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  if State = pesNormal then
  begin
    X := X - MoveCount*(300/1000);
    Y := Y + Cos256(FCounter div 15)*2;
    if X < -Width then Dead;
  end
  else if State = pesDead then
  begin
    X := X - MoveCount*(300/1000);
    if FCounter>200 then
    begin
      FState := pesDeadVanished;
      Dead;
    end;
  end;
  inc(FCounter, MoveCount);
end;
 
{ TEnemyUFO2 }
 
constructor TEnemyUFO2.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesNormal;
  Image := MainForm.GetSpriteGraphic(smgEnemyDisk2);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
end;
 
procedure TEnemyUFO2.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(ADead);
 
  if ADead then
  begin
    FState := pesDead;
    FCounter := 0;
    Inc(MainForm.FScore, 1000);
    Image := MainForm.GetSpriteGraphic(smgExplosion);
    Width := Image.Width;
    Height := Image.Height;
    AnimCount := Image.PatternCount;
    AnimLooped := False;
    AnimSpeed := DEFAULT_ANIMSPEED;
    AnimPos := 0;
  end
  else
  begin
    Inc(MainForm.FScore, 100);
  end;
end;
 
procedure TEnemyUFO2.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  if State = pesNormal then
  begin
    X := X - MoveCount*(300/1000);
    Y := Y + Cos256(FCounter div 15)*2;
    if X < -Width then Dead;
    if FCounter-FOldTamaTime>=100 then
    begin
      Inc(FTamaCount);
      with TEnemyTama.Create(Engine, Self) do
      begin
        X := Self.X;
        Y := Self.Y+Self.Height div 2-Height div 2;
        Z := 10;
      end;
      FOldTamaTime := FCounter;
    end;
  end
  else if State = pesDead then
  begin
    X := X - MoveCount*(300/1000);
    if FCounter>200 then
    begin
      FState := pesDeadVanished;
      Dead;
    end;
  end;
  inc(FCounter, MoveCount);
end;
 
{ TEnemyAttacker }
 
constructor TEnemyAttacker.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesNormal;
  Image := MainForm.GetSpriteGraphic(smgEnemyAttacker);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  PixelCheck := True;
end;
 
procedure TEnemyAttacker.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(ADead);
 
  if ADead then
  begin
    FState := pesDead;
    FCounter := 0;
    Inc(MainForm.FScore, 1000);
    Image := MainForm.GetSpriteGraphic(smgExplosion);
    Width := Image.Width;
    Height := Image.Height;
    AnimCount := Image.PatternCount;
    AnimLooped := False;
    AnimSpeed := DEFAULT_ANIMSPEED;
    AnimPos := 0;
  end
  else
  begin
    Inc(MainForm.FScore, 100);
  end;
end;
 
procedure TEnemyAttacker.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  if State = pesNormal then
  begin
    X := X - MoveCount*(300/1000)-FCounter div 128;
    if X < -Width then Dead;
  end
  else if State = pesDead then
  begin
    X := X - MoveCount*(300/1000);
    if FCounter>200 then
    begin
      FState := pesDeadVanished;
      Dead;
    end;
  end;
  inc(FCounter, MoveCount);
end;
 
{ TEnemyAttacker2 }
 
constructor TEnemyAttacker2.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesEntering;
  Image := MainForm.GetSpriteGraphic(smgEnemyAttacker2);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  PixelCheck := True;
end;
 
procedure TEnemyAttacker2.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(ADead);
 
  if ADead then
  begin
    FState := pesDead;
    FCounter := 0;
    Inc(MainForm.FScore, 5000);
    Image := MainForm.GetSpriteGraphic(smgExplosion);
    Width := Image.Width;
    Height := Image.Height;
    AnimCount := Image.PatternCount;
    AnimLooped := False;
    AnimSpeed := DEFAULT_ANIMSPEED;
    AnimPos := 0;
  end
  else
  begin
    Inc(MainForm.FScore, 100);
  end;
end;
 
procedure TEnemyAttacker2.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  if State = pesEntering then
  begin
    if X>((mainform.dxdraw.width/4) + (mainform.dxdraw.width/2) - (width/2)){450} then
      X := X - MoveCount*(300/1000)
    else
    begin
      Collisioned := True;
      FState := pesHovering;
      FPutTama := True;
    end;
    Y := Y + Cos256(FCounter div 15)*5;
  end
  else if State = pesHovering then
  begin
    Y := Y + Cos256(FCounter div 15)*5;
    if FPutTama then
    begin
      if FTamaT>100 then
      begin
        with TEnemyTama.Create(Engine, Self) do
        begin
          Z := 1;
          X := Self.X-Width;
          Y := Self.Y+Self.Height div 2-Height div 2;
        end;
        Inc(FTamaF);
        if FTamaF>Random(30) then FPutTama := False;
        FTamaT := 0;
      end;
      FTamaT := FTamaT + MoveCount;
    end
    else
    begin
      FTamaT := FTamaT + MoveCount;
      if FTamaT>2000+Random(500) then
      begin
        FPutTama := True;
        FTamaF := 0;
        FTamaT := 0;
      end;
    end;
  end
  else if State = pesDead then
  begin
    if FCounter>200 then
    begin
      FState := pesDeadVanished;
      Dead;
    end;
  end;
  inc(FCounter, MoveCount);
end;
 
{ TEnemyAttacker3 }
 
constructor TEnemyAttacker3.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesNormal;
  Image := MainForm.GetSpriteGraphic(smgEnemyAttacker3);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  PixelCheck := True;
end;
 
procedure TEnemyAttacker3.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(ADead);
 
  if ADead then
  begin
    FState := pesDead;
    FCounter := 0;
    Inc(MainForm.FScore, 5000);
    Image := MainForm.GetSpriteGraphic(smgExplosion);
    Width := Image.Width;
    Height := Image.Height;
    AnimCount := Image.PatternCount;
    AnimLooped := False;
    AnimSpeed := DEFAULT_ANIMSPEED;
    AnimPos := 0;
  end
  else
  begin
    Inc(MainForm.FScore, 100);
  end;
end;
 
procedure TEnemyAttacker3.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  if State = pesNormal then
  begin
    X := X - (250/1000)*MoveCount;
    if X < -Width then Dead;
    if FCounter-FOldTamaTime>=100 then
    begin
      Inc(FTamaCount);
      with TEnemyTama.Create(Engine, Self) do
      begin
        X := Self.X;
        Y := Self.Y+Self.Height div 2-Height div 2;
        Z := 10;
      end;
      FOldTamaTime := FCounter;
     end;
  end
  else if State = pesDead then
  begin
    if FCounter>200 then
    begin
      FState := pesDeadVanished;
      Dead;
    end;
  end;
  inc(FCounter, MoveCount);
end;
 
{ TEnemyBoss }
 
constructor TEnemyBoss.Create(AParent: TSprite; ALifes: integer);
begin
  inherited Create(AParent, ALifes);
  FState := pesEntering;
  Image := MainForm.GetSpriteGraphic(smgEnemyBoss);
  Width := Image.Width;
  Height := Image.Height;
  MainForm.MusicSwitchTrack(smmBoss);
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  PixelCheck := True;
  Collisioned := False;
  MainForm.FBoss := Self;
  waiter1 := 0;
  waiter2 := 0;
end;
 
procedure TEnemyBoss.HitEnemy(ADead: Boolean);
begin
  inherited HitEnemy(ADead);
 
  if ADead then
  begin
    FState := pesExploding; // not pesDead for the boss!
    FCounter := 0;
    Inc(MainForm.FScore, 100000);
  end
  else
  begin
    Inc(MainForm.FScore, 100);
  end;
end;
 
destructor TEnemyBoss.Destroy;
begin
  MainForm.FBoss := nil;
  inherited;
end;
 
procedure TEnemyBoss.DoMove(MoveCount: Integer);
begin
  inherited DoMove(MoveCount);
  if State = pesEntering then
  begin
    if X>((mainform.dxdraw.width/4) + (mainform.dxdraw.width/2) - (width/4)){450} then
      X := X - MoveCount*(300/1000)
    else
    begin
      Collisioned := True;
      FState := pesHovering;
      FPutTama := True;
    end;
    Y := Y + Cos256(FCounter div 15)*5;
  end
  else if State = pesHovering then
  begin
    Y := Y + Cos256(FCounter div 15)*5;
    if FPutTama then
    begin
      if FTamaT>100 then
      begin
        with TEnemyTama.Create(Engine, Self) do
        begin
          Z := 1;
          X := Self.X-Width;
          Y := Self.Y+Self.Height div 2-Height div 2;
        end;
        Inc(FTamaF);
        if FTamaF>Random(30) then FPutTama := False;
        FTamaT := 0;
      end;
      FTamaT := FTamaT + MoveCount;
    end
    else
    begin
      FTamaT := FTamaT + MoveCount;
      if FTamaT>2000+Random(500) then
      begin
        FPutTama := True;
        FTamaF := 0;
        FTamaT := 0;
      end;
    end;
  end
  else if State = pesExploding then
  begin
    inc(waiter1);
    if waiter1 = 3 then
    begin
      waiter1 := 0;
      inc(waiter2);
      if waiter2 <= 20 then
      begin
        with TExplosion.Create(Engine) do
        begin
          Z := 10;
          X := Self.X+Random(Self.Width)-16;
          Y := Self.Y+Random(Self.Height)-16;
        end;
      end
      else
      begin
        Inc(MainForm.FScore, 10000);
        FState := pesDead;
      end;
    end;
  end
  else if State = pesDead then
  begin
    if FCounter>4000 then
    begin
      FState := pesDeadVanished;
      Dead;
    end;
  end;
  inc(FCounter, MoveCount);
end;
 
{ TItem }
 
procedure TItem.Collected;
begin
  MainForm.PlaySound(smsItemCollected, false);
  Dead;
end;
 
procedure TItem.DoMove(MoveCount: Integer);
begin
  X := X - MoveCount*(250/1000);
  if X < -Width then Dead;
end;
 
{ TItemMedikit }
 
procedure TItemMedikit.Collected;
begin
  Inc(MainForm.FLife);
  inherited;
end;
 
constructor TItemMedikit.Create(AParent: TSprite);
begin
  inherited Create(AParent);
  FState := pesNormal;
  Image := MainForm.GetSpriteGraphic(smgItemMedikit);
  Width := Image.Width;
  Height := Image.Height;
  AnimCount := Image.PatternCount;
  AnimLooped := True;
  AnimSpeed := DEFAULT_ANIMSPEED;
  PixelCheck := True;
end;
 
{ TMainForm }
 
procedure TMainForm.FormCreate(Sender: TObject);
resourcestring
  SAppTitle = 'SpaceMission %s';
begin
  Randomize;
 
  LevelData := TLevelData.Create;
 
  { Beginne VCL-Ersatz }
  dxtimer := tdxtimer.Create(self);
  dxtimer.Interval := 33;
  dxtimer.OnActivate := DXTimerActivate;
  dxtimer.OnDeactivate := DXTimerDeactivate;
  dxtimer.OnTimer := DXTimerTimer;
  dxtimer.ActiveOnly := false;
  dxtimer.Enabled := false;
 
  dxdraw := tdxdraw.Create(self);
  dxdraw.Parent := self;
  dxdraw.Align := alClient;
  dxdraw.Left := 0;
  dxdraw.Top := 0;
  dxdraw.Width := ClientWidth;
  dxdraw.Height := ClientHeight;
  dxdraw.AutoInitialize := False;
  dxdraw.AutoSize := False;
  dxdraw.Color := clBlack;
  (*
  dxdraw.Display.BitCount := 24;
  dxdraw.Display.FixedBitCount := False;
  dxdraw.Display.FixedRatio := False;
  dxdraw.Display.FixedSize := False;
  dxdraw.Display.Height := 600;
  dxdraw.Display.Width := 800;
  *)
  dxdraw.Options := [doAllowReboot, doWaitVBlank, doAllowPalette256, doCenter, {doRetainedMode,} doHardware, doSelectDriver];
  dxdraw.TabOrder := 0;
  dxdraw.Visible := true;
  dxdraw.OnFinalize := DXDrawFinalize;
  dxdraw.OnInitialize := DXDrawInitialize;
  dxdraw.OnInitializing := DXDrawInitializing;
 
  dxsound := tdxsound.Create(self);
  dxsound.AutoInitialize := false;
 
  dxmusic := TDXMusic.Create(self);
  dxmusic.DXSound := dxsound;
 
  dxinput := tdxinput.Create(self);
  dxinput.Joystick.ForceFeedback := true;
  dxinput.Keyboard.ForceFeedback := true;
 
  wavelist := tdxwavelist.Create(self);
  wavelist.DXSound := dxsound;
 
  imagelist := tdximagelist.create(self);
  imagelist.DXDraw := dxdraw;
 
  spriteengine := tdxspriteengine.create(self);
  spriteengine.DXDraw := dxdraw;
 
  InitializeCriticalSection(TimerCS);
 
  { Ende VCL-Ersatz }
 
  Application.Title := Format(SAppTitle, [ProgramVersion]);
  LoadOptions;
  DXInit;
  SoundInit;
  MusicInit;
 
  GameStartClick(GameStart);
end;
 
procedure TMainForm.GameStartClick(Sender: TObject);
begin
  StartScene(gsTitle);
end;
 
function TMainForm.GetSpriteGraphic(
  Sprite: TSpaceMissionGraphicSprite): TPictureCollectionItem;
begin
  if (Sprite<>smgNone) and (imagelist.Items.Count >= Ord(Sprite)) then
    result := imagelist.Items.Items[Ord(Sprite)-1]
  else
    result := nil;
end;
 
procedure TMainForm.HilfeTopicClick(Sender: TObject);
// Please keep this code in-sync with LevMain.pas
var
  bakTimerEnabled: boolean;
begin
  bakTimerEnabled := dxtimer.Enabled;
  try
    dxtimer.Enabled := false;
    HilfeForm.Caption := TMenuItem(Sender).Caption;
    HilfeForm.Caption := StringReplace(HilfeForm.Caption, '&&', #1, [rfReplaceAll]);
    HilfeForm.Caption := StringReplace(HilfeForm.Caption, '&', '', [rfReplaceAll]);
    HilfeForm.Caption := StringReplace(HilfeForm.Caption, #1, '&', [rfReplaceAll]);
    HilfeForm.ShowMarkDownHelp(OwnDirectory+TMenuItem(Sender).Hint);
    HilfeForm.ShowModal;
  finally
    dxtimer.Enabled := bakTimerEnabled;
  end;
end;
 
procedure TMainForm.GamePauseClick(Sender: TObject);
begin
  GamePause.Checked := not GamePause.Checked;
  DXTimer.Enabled := not GamePause.Checked;
  if GamePause.Checked then
  begin
    if Assigned(DXTimer.OnDeactivate) then
      DXTimer.OnDeactivate(DXTimer);
  end
  else
  begin
    if Assigned(DXTimer.OnActivate) then
      DXTimer.OnActivate(DXTimer);
  end;
end;
 
procedure TMainForm.DXInit;
begin
  try
    Imagelist.Items.LoadFromFile(OwnDirectory+DxgFile);
    ImageList.Items.MakeColorTable;
    DXDraw.ColorTable := ImageList.Items.ColorTable;
    DXDraw.DefColorTable := ImageList.Items.ColorTable;
    DXDraw.UpdatePalette;
    DXDraw.Finalize;
    DXDraw.Options := DXDraw.Options - [doFullScreen];
    DXDraw.autosize := true;
    DXDraw.Initialize;
  except
    //Imagelist.Items.clear;
    //application.terminate;
  end;
end;
 
procedure TMainForm.CheckUpdatesClick(Sender: TObject);
begin
  CheckForUpdates('spacemission', ProgramVersion); // do not localize
end;
 
procedure TMainForm.BeendenClick(Sender: TObject);
begin
  close;
end;
 
procedure TMainForm.OptionSoundClick(Sender: TObject);
begin
  OptionSound.Checked := not OptionSound.Checked;
  SoundInit;
  WriteOptions;
end;
 
procedure TMainForm.SoundInit;
begin
  if (WaveOutGetNumDevs < 1) or not FileExists(OwnDirectory+DxwFile) then
  begin
    OptionSound.Checked := false;
    OptionSound.Enabled := False;
    exit;
  end;
 
  if OptionSound.Checked then
  begin
    if not DXSound.Initialized then
    begin
      try
        DXSound.Initialize;
        WaveList.Items.LoadFromFile(OwnDirectory+DxwFile);
      except
        OptionSound.enabled := False;
        WaveList.items.clear;
      end;
    end;
  end
  else DXSound.Finalize;
end;
 
procedure TMainForm.MusicInit;
var
  i: integer;
begin
  if (WaveOutGetNumDevs < 1) or not FileExists(OwnDirectory+DxmFile) then
  begin
    optionmusic.Checked := false;
    optionmusic.Enabled := False;
    exit;
  end;
 
  try
    dxmusic.Midis.LoadFromFile(OwnDirectory+DxmFile);
    for i := 0 to dxmusic.Midis.Count-1 do
    begin
      if not dxmusic.Midis.Items[i].IsInitialized then
      begin
        dxmusic.Midis.Items[i].Init; // TODO: for some reason, AddPort is very slow!
        dxmusic.Midis.Items[i].Load;
      end;
    end;
  except
    optionmusic.enabled := false;
  end;
end;
 
procedure TMainForm.DXDrawInitializing(Sender: TObject);
begin
  if doFullScreen in DXDraw.Options then
  begin
    BorderStyle := bsNone;
    DXDraw.Cursor := crNone;
  end
  else
  begin
    BorderStyle := bsSingle;
    DXDraw.Cursor := crDefault;
  end;
end;
 
procedure TMainForm.DXDrawInitialize(Sender: TObject);
begin
  if Assigned(DXTimer) then DXTimer.Enabled := True;
end;
 
procedure TMainForm.DXDrawFinalize(Sender: TObject);
begin
  if Assigned(DXTimer) then DXTimer.Enabled := False;
end;
 
procedure TMainForm.DXTimerActivate(Sender: TObject);
begin
  if TDxTimer(Sender).Tag > 0 then
    TDxTimer(Sender).Tag := TDxTimer(Sender).Tag - 1; // es können mehrere activate/deactivate vorkommen, wegen dem Pause-Button
  if TDxTimer(Sender).Tag > 0 then
    exit;
  Caption := Application.Title;
  if not ProgrammGestartet then
  begin
    Programmgestartet := true;
    exit;
  end;
  ResumeMusic(FMusic);
end;
 
procedure TMainForm.DXTimerDeactivate(Sender: TObject);
resourcestring
  SPauseTitle = '%s [Pause]';
begin
  TDxTimer(Sender).Tag := TDxTimer(Sender).Tag + 1;
  Caption := Format(SPauseTitle, [Application.Title]);
  PauseMusic(FMusic);
end;
 
procedure TMainForm.DXTimerTimer(Sender: TObject; LagCount: Integer);
begin
  EnterCriticalSection(TimerCS);
  try
    if crash then
    begin
      inc(Crash2);
      if crash2 = 30 then
      begin
        Crash2 := 0;
        crash := false;
        crashsound := false;
      end;
    end;
    if not DXDraw.CanDraw then exit;
    DXInput.Update;
    case FScene of
      gsTitle   : SceneTitle;
      gsMain    : SceneMain;
      gsGameOver: SceneGameOver;
      gsWin     : SceneWin;
      gsNewLevel: SceneNewLevel;
    end;
    if FNextScene<>gsNone then
    begin
      StartScene(FNextScene);
      FNextScene := gsNone;
    end;
    DXDraw.Flip;
  finally
    LeaveCriticalSection(TimerCS);
  end;
end;
 
procedure TMainForm.BlinkStart;
begin
  FBlink := 0;
  FBlinkTime := GetTickCount;
end;
 
procedure TMainForm.WriteOptions;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    if Reg.OpenKey(RegistrySettingsKey, true) then
    begin
      Reg.WriteBool(MusicSettingKey, OptionMusic.checked);
      Reg.WriteBool(SoundSettingKey, OptionSound.checked);
      Reg.WriteInteger(SpeedSettingKey, Ord(FSpeed));
      Reg.DeleteValue('Speed'); // deprecated. Replaced by GameSpeed
      Reg.CloseKey;
    end;
  finally
    FreeAndNil(Reg);
  end;
end;
 
procedure TMainForm.LoadOptions;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    if Reg.OpenKey(RegistrySettingsKey, true) then
    begin
      if Reg.ValueExists(MusicSettingKey) then
        optionmusic.checked := Reg.ReadBool(MusicSettingKey)
      else
        optionmusic.checked := true; // default
 
      if Reg.ValueExists(SoundSettingKey) then
        optionsound.checked := Reg.ReadBool(SoundSettingKey)
      else
        optionsound.checked := true; // default
 
      if Reg.ValueExists(SpeedSettingKey) then
        FSpeed := Reg.ReadInteger(SpeedSettingKey)
      else
        FSpeed := SpeedMedium; // default
 
      Leicht.Checked := FSpeed = SpeedEasy;
      Mittel.Checked := FSpeed = SpeedMedium;
      Schwer.Checked := FSpeed = SpeedHard;
      Master.Checked := FSpeed = SpeedMaster;
 
      Reg.CloseKey;
    end;
  finally
    FreeAndNil(Reg);
  end;
  WriteOptions;
end;
 
procedure TMainForm.BlinkUpdate;
begin
  if GetTickCount<>FBlinkTime then
  begin
    FBlink := FBlink + (GetTickCount-FBlinkTime);
    FBlinkTime := GetTickCount;
  end;
end;
 
procedure TMainForm.PlaySound(Sound: TSpaceMissionSound; Wait: Boolean);
begin
  if (Sound<>smsNone) and (OptionSound.Checked) and (OptionSound.Enabled) and (WaveList.Items.Count >= Ord(Sound)) then
    WaveList.Items.Items[Ord(Sound)-1].Play(Wait);
end;
 
procedure TMainForm.MusicSwitchTrack(Name: TSpaceMissionMusicTrack);
begin
  if (not mainform.active) and (mainform.visible) then //1st Programmstart
    exit;
  if (OptionMusic.checked) and (OptionMusic.enabled) then
  begin
    StopMusic(FMusic);
    PlayMusic(Name);
  end;
  FMusic := Name;
end;
 
function TMainForm.ComposeColor(Dest, Src: TRGBQuad; Percent: Integer): TRGBQuad;
begin
  with Result do
  begin
    rgbRed := Src.rgbRed+((Dest.rgbRed-Src.rgbRed)*Percent div 256);
    rgbGreen := Src.rgbGreen+((Dest.rgbGreen-Src.rgbGreen)*Percent div 256);
    rgbBlue := Src.rgbBlue+((Dest.rgbBlue-Src.rgbBlue)*Percent div 256);
    rgbReserved := 0;
  end;
end;
 
procedure TMainForm.PalleteAnim(Col: TRGBQuad; Time: Integer);
var
  i: Integer;
  t, t2: DWORD;
  ChangePalette: Boolean;
  c: Integer;
begin
  if DXDraw.Initialized then
  begin
    c := DXDraw.Surface.ColorMatch(RGB(Col.rgbRed, Col.rgbGreen, Col.rgbBlue));
    ChangePalette := False;
    if DXDraw.CanPaletteAnimation then
    begin
      t := GetTickCount;
      while Abs(GetTickCount-t)<Time do
      begin
        t2 := Trunc(Abs(GetTickCount-t)/Time*255);
        for i := 0 to 255 do
          DXDraw.ColorTable[i] := ComposeColor(Col, DXDraw.DefColorTable[i], t2);
        DXDraw.UpdatePalette;
        ChangePalette := True;
      end;
    end
    else
    begin
      Sleep(Time);
    end;
    for i := 0 to 4 do
    begin
      DXDraw.Surface.Fill(c);
      DXDraw.Flip;
    end;
    if ChangePalette then
    begin
      DXDraw.ColorTable := DXDraw.DefColorTable;
      DXDraw.UpdatePalette;
    end;
    DXDraw.Surface.Fill(c);
    DXDraw.Flip;
  end;
end;
 
procedure TMainForm.StartScene(Scene: TGameScene);
begin
  EndScene;
  DXInput.States := DXInput.States - DXInputButton;
  FScene := Scene;
  BlinkStart;
  case FScene of
    gsTitle   : StartSceneTitle;
    gsMain    : StartSceneMain;
    gsGameOver: StartSceneGameOver;
    gsWin     : StartSceneWin;
    gsNewLevel: StartSceneNewLevel;
  end;
end;
 
procedure TMainForm.StartSceneTitle;
begin
  sleep(500);
  FCheats := [];
  FLife := StartLives;
  FLevel := 0;
  FScore := 0;
  FLevelDataAlreadyLoaded := false; // do allow NewLevel() to work again
  FNotSave := true;
  Cheat.enabled := false;
  Neustart.enabled := false;
  GamePause.enabled := false;
  GameStart.enabled := false;
  Spielgeschwindigkeit.enabled := false;
  mainform.Visible := true;
  MusicSwitchTrack(smmTitle);
end;
 
procedure TMainForm.StartSceneMain;
{var
  i, j: Integer;}
begin
  sleep(500);
  FCounter := 0;
  if not FLevelDataAlreadyLoaded then NewLevel(FLevel);
  FRestEnemies := Length(LevelData.EnemyAdventTable);
  FLifeAtLevelStart := FLife;     // Das ist wichtig, wenn man neu starten möchte
  FScoreAtLevelStart := FScore;   //
  MusicSwitchTrack(smmGame);
  FEnemyAdventPos := 0;
  FFrame := -4;
  PlayerSprite := TPlayerSprite.Create(SpriteEngine.Engine);
  with TBackground.Create(SpriteEngine.Engine) do
  begin
    SetMapSize(1, 1);
    Image := MainForm.GetSpriteGraphic(smgStar3);
    Z := -13;
    Y := 40;
    Speed := 1 / 2;
    Tile := True;
  end;
  with TBackground.Create(SpriteEngine.Engine) do
  begin
    SetMapSize(1, 1);
    Image := MainForm.GetSpriteGraphic(smgStar2);
    Z := -12;
    Y := 30;
    Speed := 1;
    Tile := True;
  end;
  with TBackground.Create(SpriteEngine.Engine) do
  begin
    SetMapSize(1, 1);
    Image := MainForm.GetSpriteGraphic(smgStar1);
    Z := -11;
    Y := 10;
    Speed := 2;
    Tile := True;
  end;
  {with TBackground.Create(SpriteEngine.Engine) do
  begin
    SetMapSize(200, 10);
    Y := 10;
    Z := -13;
    Speed := 1 / 2;
    Tile := True;
    for i := 0 to MapHeight-1 do
    begin
      for j := 0 to MapWidth-1 do
      begin
        Chips[j, i] := Image.PatternCount-Random(Image.PatternCount div 8);
        if Random(100)<95 then Chips[j, i] := -1;
      end;
    end;
  end;
  with TBackground.Create(SpriteEngine.Engine) do
  begin
    SetMapSize(200, 10);
    Y := 30;
    Z := -12;
    Speed := 1;
    Tile := True;
    for i := 0 to MapHeight-1 do
    begin
      for j := 0 to MapWidth-1 do
      begin
        Chips[j, i] := Image.PatternCount-Random(Image.PatternCount div 4);
        if Random(100)<95 then Chips[j, i] := -1;
      end;
    end;
  end;
  with TBackground.Create(SpriteEngine.Engine) do
  begin
    SetMapSize(200, 10);
    Y := 40;
    Z := -11;
    Speed := 2;
    Tile := True;
    for i := 0 to MapHeight-1 do
    begin
      for j := 0 to MapWidth-1 do
      begin
        Chips[j, i] := Image.PatternCount-Random(Image.PatternCount div 2);
        if Random(100)<95 then Chips[j, i] := -1;
      end;
    end;
  end;}
  FNotSave := false;
  Cheat.enabled := true;
  Neustart.enabled := true;
  GamePause.enabled := true;
  GameStart.enabled := true;
  Spielgeschwindigkeit.enabled := true;
end;
 
procedure TMainForm.StartSceneGameOver;
begin
  sleep(500);
  FNotSave := true; // Wenn man speichert, würde man LevelAdventTable vom vorherigen Level machen, das wär müll!
  Cheat.enabled := false;
  Spielgeschwindigkeit.enabled := false;
  Neustart.enabled := false;
  GamePause.enabled := false;
  MusicSwitchTrack(smmScene);
end;
 
procedure TMainForm.StartSceneWin;
begin
  sleep(500);
  FNotSave := true; // Wenn man speichert, würde man LevelAdventTable vom vorherigen Level machen, das wär müll!
  Cheat.enabled := false;
  Spielgeschwindigkeit.enabled := false;
  Neustart.enabled := false;
  GamePause.enabled := false;
  MusicSwitchTrack(smmScene);
end;
 
procedure TMainForm.EndScene;
begin
  case FScene of
    gsTitle   : EndSceneTitle;
    gsMain    : EndSceneMain;
    gsGameOver: EndSceneGameOver;
    gsWin     : EndSceneWin;
    gsNewLevel: EndSceneNewLevel;
  end;
end;
 
procedure TMainForm.EndSceneTitle;
begin
  {  Ende Title  }
end;
 
procedure TMainForm.EndSceneMain;
begin
  SpriteEngine.Engine.Clear;
end;
 
procedure TMainForm.EndSceneGameOver;
begin
  {  Ende GameOver  }
end;
 
procedure TMainForm.EndSceneWin;
begin
  {  Ende Win  }
end;
 
procedure TMainForm.ResetLevelData;
begin
  LevelData.Clear;
  FRestEnemies := 0;
end;
 
procedure TMainForm.NewLevel(lev: integer);
resourcestring
  SLevelInvalid = 'Die Datei für Level %d ist ungültig. Level wird übersprungen!';
var
  act: integer;
  Enemies: array[1..32] of TEnemyType;
  numEnemies: integer;
  e: TEnemyAdvent;
  bossPosition: integer;
  levFile: TLevelFile;
begin
  ResetLevelData;
  if FGameMode = gmRandom then
  begin
    {$REGION 'Random game'}
    Enemies[1] := etEnemyAttacker;     // ab Lev 1
    Enemies[2] := etEnemyMeteor;       // ab Lev 1
    Enemies[3] := etEnemyUFO;          // ab Lev 1
    Enemies[4] := etEnemyAttacker;     // ab Lev 2
    Enemies[5] := etEnemyMeteor;       // ab Lev 3
    Enemies[6] := etEnemyUFO;          // ab Lev 4
    Enemies[7] := etEnemyAttacker;     // ab Lev 5
    Enemies[8] := etEnemyMeteor;       // ab Lev 6
    Enemies[9] := etEnemyUFO;          // ab Lev 7
    Enemies[10] := etEnemyAttacker;    // ab Lev 8
    Enemies[11] := etEnemyMeteor;      // ab Lev 9
    Enemies[12] := etEnemyUFO;         // ab Lev 10
    Enemies[13] := etEnemyAttacker;    // ab Lev 11
    Enemies[14] := etEnemyMeteor;      // ab Lev 12
    Enemies[15] := etEnemyUFO;         // ab Lev 13
    Enemies[16] := etEnemyAttacker3;   // ab Lev 14
    Enemies[17] := etEnemyAttacker;    // ab Lev 15
    Enemies[18] := etEnemyMeteor;      // ab Lev 16
    Enemies[19] := etEnemyUFO;         // ab Lev 17
    Enemies[20] := etEnemyUFO2;        // ab Lev 18
    Enemies[21] := etEnemyAttacker;    // ab Lev 19
    Enemies[22] := etEnemyMeteor;      // ab Lev 20
    Enemies[23] := etEnemyUFO;         // ab Lev 21
    Enemies[24] := etEnemyAttacker2;   // ab Lev 22
    Enemies[25] := etEnemyMeteor;      // ab Lev 23
    Enemies[26] := etEnemyUFO;         // ab Lev 24
    Enemies[27] := etEnemyAttacker;    // ab Lev 25
    Enemies[28] := etEnemyAttacker;    // ab Lev 26
    Enemies[29] := etEnemyAttacker2;   // ab Lev 27
    Enemies[30] := etEnemyAttacker3;   // ab Lev 28
    Enemies[31] := etEnemyUFO;         // ab Lev 29
    Enemies[32] := etEnemyUFO2;        // ab Lev 30
    numEnemies := lev*RandomLevelAdditionalEnemiesPerLevel;
    SetLength(LevelData.EnemyAdventTable, numEnemies);
    for act := 0 to numEnemies-1 do
    begin
      e.enemyType := Enemies[min(random(lev+2)+1, High(Enemies))];
      if e.enemyType = etEnemyAttacker2 then
      begin
        //e.enemyType := Enemies[min(random(lev+2)+1, High(Enemies))];
        if Random(2) = 0 then e.enemyType := etEnemyAttacker3;
      end;
      e.x := 85-(lev+(random(lev))*2){O_o};
      if e.x < 1 then e.x := 1; // passiert bei großen Levels
      e.x := act*30 + random(e.x);
      e.y := random((LevEditRows-1)*LevEditRasterH);
      if e.enemyType = etEnemyAttacker2 then
      begin
        e.lifes := random(6)+1{O_o};
      end
      else
      begin
        if lev > RandomLevelMaxEnemyLives then
        begin
          e.lifes := random(RandomLevelMaxEnemyLives)+1;
        end
        else
        begin
          e.lifes := random(lev)+1;
        end;
      end;
 
      if (act-1) mod RandomLevelMedikitEveryX = 0 then
      begin
        e.enemyType := etItemMedikit;
        e.lifes := 0;
      end;
 
      LevelData.EnemyAdventTable[act] := e;
    end;
 
    if lev < 5 then
    begin
      // Level 1-4: No boss
      bossPosition := -1;
    end
    else if lev < 10 then
    begin
      // Level 5-9: Boss is at the end of the level
      bossPosition := numEnemies-1;
    end
    else
    begin
      // Starting with Level 10: Boss at 75% of the level
      bossPosition := round(0.75 * numEnemies);
    end;
 
    if LevelData.EnemyAdventTable[bossPosition].enemyType = etItemMedikit then
      Inc(bossPosition);
 
    if bossPosition >= 0 then
    begin
      e.enemyType := etEnemyBoss;
      //e.x := lev*75*30{O_o} div lev;
      e.x := LevelData.EnemyAdventTable[bossPosition-1].x;
      e.y := (dxdraw.surfaceheight div 2) - (MainForm.GetSpriteGraphic(smgEnemyBoss).height div 2);
      e.lifes := lev*5;
      LevelData.EnemyAdventTable[bossPosition] := e;
    end;
 
    {$ENDREGION}
  end
  else
  begin
    {$REGION 'Normal game'}
    levFile := GetLevelFileName(lev,false);
    if levFile.found then
    begin
      try
        LevelData.RasterErzwingen := false;
        LevelData.LoadFromFile(levFile.fileLocation);
      except
        showmessage(Format(SLevelInvalid, [lev]));
        ResetLevelData; // empty level = the player will continue with the next level
      end;
    end;
    {$ENDREGION}
  end;
  FLevelDataAlreadyLoaded := true; // nicht nochmal NewLevel() aufrufen. Erst wieder wenn man gewonnen hat.
end;
 
var
  TitleWasPressed: TDxInputState = isButton32;
 
procedure TMainForm.SceneTitle;
resourcestring
  SNormalGame = 'Normales Spiel';
  SRandomGame = 'Zufalls-Level';
  SLevelEditor = 'Level-Editor';
var
  Logo: TPictureCollectionItem;
  colo1, colo2: TColor;
begin
  DXDraw.Surface.Fill(0);
  Logo := GetSpriteGraphic(smgLogo);
  {Logo.DrawWaveX(DXDraw.Surface, (dxdraw.surfaceWidth div 2) - 181, 65, Logo.Width, Logo.Height, 0,
    Trunc(16 - Cos256(FBlink div 60) * 16), 32, -FBlink div 5);}
  Logo.DrawWaveX(DXDraw.Surface, trunc((dxdraw.surfaceWidth / 2) - (Logo.Width / 2)), 65, Logo.Width, Logo.Height, 0,
    2, 80, Fangle * 4);
  inc(Fangle);
 
  if FGameMode = gmUnknown then FGameMode := gmLevels;
 
  if (isUp in MainForm.DXInput.States) then TitleWasPressed := isUp;
  if (TitleWasPressed=isUp) and not (isUp in MainForm.DXInput.States) then
  begin
    TitleWasPressed := isButton32;
    if (Ord(FGameMode) <> 1) then
      FGameMode := TGameMode(Ord(FGameMode)-1);
  end;
 
  if (isDown in MainForm.DXInput.States) then TitleWasPressed := isDown;
  if (TitleWasPressed=isDown) and not (isDown in MainForm.DXInput.States) then
  begin
    TitleWasPressed := isButton32;
    if (FGameMode <> High(TGameMode)) then
      FGameMode := TGameMode(Ord(FGameMode)+1);
  end;
 
  DXDraw.Surface.Canvas.Brush.Style := bsClear;
  DXDraw.Surface.Canvas.Font.Size := 30;
 
  {$REGION 'Menu point: Normal Level'}
  if FGameMode = gmLevels then
  begin
    colo1 := clMaroon;
    colo2 := clRed;
  end
  else
  begin
    colo1 := clOlive;
    colo2 := clYellow;
  end;
  DXDraw.Surface.Canvas.Font.Color := colo1;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-152, (dxdraw.surfaceheight div 2)-52, SNormalGame);
  if FGameMode = gmLevels then
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, (dxdraw.surfaceheight div 2)-52, '>');
  DXDraw.Surface.Canvas.Font.Color := colo2;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-150, (dxdraw.surfaceheight div 2)-50, SNormalGame);
  if FGameMode = gmLevels then
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, (dxdraw.surfaceheight div 2)-50, '>');
  {$ENDREGION}
 
  {$REGION 'Menu point: Random Level'}
  if FGameMode = gmRandom then
  begin
    colo1 := clMaroon;
    colo2 := clRed;
  end
  else
  begin
    colo1 := clOlive;
    colo2 := clYellow;
  end;
  DXDraw.Surface.Canvas.Font.Color := colo1;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-152, (dxdraw.surfaceheight div 2)-2, SRandomGame);
  if FGameMode = gmRandom then
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-187, (dxdraw.surfaceheight div 2)-2, '>');
  DXDraw.Surface.Canvas.Font.Color := colo2;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-150, (dxdraw.surfaceheight div 2), SRandomGame);
  if FGameMode = gmRandom then
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, (dxdraw.surfaceheight div 2), '>');
  {$ENDREGION}
 
  {$REGION 'Menu point: Level Editor'}
  if FGameMode = gmEditor then
  begin
    colo1 := clMaroon;
    colo2 := clRed;
  end
  else
  begin
    colo1 := clOlive;
    colo2 := clYellow;
  end;
  DXDraw.Surface.Canvas.Font.Color := colo1;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-152, (dxdraw.surfaceheight div 2)+48, SLevelEditor);
  if FGameMode = gmEditor then
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, (dxdraw.surfaceheight div 2)+48, '>');
  DXDraw.Surface.Canvas.Font.Color := colo2;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-150, (dxdraw.surfaceheight div 2)+50, SLevelEditor);
  if FGameMode = gmEditor then
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, (dxdraw.surfaceheight div 2)+50, '>');
  {$ENDREGION}
 
  { if (FBlink div 300) mod 2=0 then
  begin
    DXDraw.Surface.Canvas.Font.Color := clGreen;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-187, dxdraw.surfaceheight-117, SWeiterMitLeertaste);
    DXDraw.Surface.Canvas.Font.Color := clLime;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, dxdraw.surfaceheight-115, SWeiterMitLeertaste);
  end; }
  BlinkUpdate;
  DXDraw.Surface.Canvas.Release;
 
  // Weiter mit Leertaste oder Enter
  if (isButton1 in DXInput.States) or (isButton2 in DXInput.States) then
  begin
    FLevel := 1;
    if FGameMode = gmEditor then
    begin
      ShellExecute(0, 'open', PChar(OwnDirectory+LevEditExe), '', PChar(OwnDirectory), SW_NORMAL); // do not localize
      Close;
      exit;
    end;
    if ((FGameMode=gmLevels) and not GetLevelFileName(FLevel,false).found) or
       ((FGameMode=gmRandom) and (FLevel > MaxPossibleLevels)) then
    begin
      //PlaySound('Frage', False);
      exit;
    end;
    PlaySound(smsSceneMov, False);
    PalleteAnim(RGBQuad(0, 0, 0), 300);
    Sleep(200);
    StartScene(gsMain);
  end;
end;
 
procedure TMainForm.SceneMain;
resourcestring
  SMissionSuccessful = 'Mission erfolgreich!';
  SMissionFailed = 'Mission gescheitert!';
  SPunkte = 'Punkte: %s';
  SLevel = 'Level: %d';
  SLifes = 'Leben: %d';
  SInfLifes = '';
  SBossLifes = 'Boss: %d';
  SEinheiten = 'Einheiten: %d';
var
  Enemy: TSprite;
  spriteClass: TClass;
  tmpEnemyAnzeige: integer;
begin
  SpriteEngine.Move(FSpeed);
  SpriteEngine.Dead;
  while (FEnemyAdventPos >= Low(LevelData.EnemyAdventTable)) and
    (FEnemyAdventPos <= High(LevelData.EnemyAdventTable)) and
    ((LevelData.EnemyAdventTable[FEnemyAdventPos].x / 4) <= FFrame) and
    (FRestEnemies > 0) do
  begin
    Dec(FRestEnemies);
    with LevelData.EnemyAdventTable[FEnemyAdventPos] do
    begin
      spriteClass := nil;
      case enemyType of
        //etUnknown: ;
        etEnemyAttacker:  spriteClass := TEnemyAttacker;
        etEnemyAttacker2: spriteClass := TEnemyAttacker2;
        etEnemyAttacker3: spriteClass := TEnemyAttacker3;
        etEnemyMeteor:    spriteClass := TEnemyMeteor;
        etEnemyUFO:       spriteClass := TEnemyUFO;
        etEnemyUFO2:      spriteClass := TEnemyUFO2;
        etEnemyBoss:      spriteClass := TEnemyBoss;
        etItemMedikit:    spriteClass := TItemMedikit;
      end;
      if spriteClass <> nil then
      begin
        Enemy := nil;
        if spriteClass.InheritsFrom(TEnemy) then
          Enemy := TEnemyClass(spriteClass).Create(SpriteEngine.Engine, lifes)
        else if spriteClass.InheritsFrom(TItem) then
          Enemy := TItemClass(spriteClass).Create(SpriteEngine.Engine)
        else
          Assert(False);
        Enemy.x := dxdraw.surfacewidth;
        //Enemy.y := y;
        if y <> 0 then
          Enemy.y := dxdraw.surfaceheight / ((LevEditRows*LevEditRasterH) / y)
        else
          Enemy.y := 0;
      end;
    end;
    Inc(FEnemyAdventPos);
  end;
  Inc(FFrame);
  DXDraw.Surface.Fill(0);
  if FNextScene=gsNone then
  begin
    SpriteEngine.Draw;
    DXDraw.Surface.Canvas.Brush.Style := bsClear;
    DXDraw.Surface.Canvas.Font.Size := 20;
    if flife > 0 then
    begin
      {$REGION 'Anzeige Punkte'}
      DXDraw.Surface.Canvas.Font.Color := clOlive;
      DXDraw.Surface.Canvas.Textout(9, 9, Format(SPunkte, [FloatToStrF(FScore,ffNumber,14,0)]));
      DXDraw.Surface.Canvas.Font.Color := clYellow;
      DXDraw.Surface.Canvas.Textout(10, 10, Format(SPunkte, [FloatToStrF(FScore,ffNumber,14,0)]));
      {$ENDREGION}
 
      {$REGION 'Anzeige Level'}
      DXDraw.Surface.Canvas.Font.Color := clMaroon;
      DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-141, 9, Format(SLevel, [flevel]));
      DXDraw.Surface.Canvas.Font.Color := clRed;
      DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-140, 10, Format(SLevel, [flevel]));
      {$ENDREGION}
 
      {$REGION 'Lebensanzeige'}
      if FLife<0 then FLife := 0;
      if ctInfiniteLives in FCheats then
      begin
        DXDraw.Surface.Canvas.Font.Color := clPurple;
        DXDraw.Surface.Canvas.Textout(9, dxdraw.surfaceheight-41, SInfLifes);
        DXDraw.Surface.Canvas.Font.Color := clFuchsia;
        DXDraw.Surface.Canvas.Textout(10, dxdraw.surfaceheight-40, SInfLifes);
      end
      else
      begin
        if ((Flife = 1) and ((FBlink div 300) mod 2=0)) or (Flife <> 1) then
        begin
          DXDraw.Surface.Canvas.Font.Color := clPurple;
          DXDraw.Surface.Canvas.Textout(9, dxdraw.surfaceheight-41, Format(SLifes, [flife]));
          DXDraw.Surface.Canvas.Font.Color := clFuchsia;
          DXDraw.Surface.Canvas.Textout(10, dxdraw.surfaceheight-40, Format(SLifes, [flife]));
        end;
        if Flife = 1 then BlinkUpdate;
      end;
      {$ENDREGION}
 
      {$REGION 'Anzeige Einheiten und Boss Leben'}
 
      tmpEnemyAnzeige := EnemyCounter{Auf Bildschirm} + FRestEnemies{In der Warteschlange};
      if Assigned(FBoss) and (FBoss.State<>pesDeadVanished) then Dec(tmpEnemyAnzeige);
 
      if Assigned(FBoss) and (FBoss.Life>0) then
      begin
        if (tmpEnemyAnzeige>0) then
        begin
          DXDraw.Surface.Canvas.Font.Color := clGreen;
          DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-191, dxdraw.surfaceheight-81, Format(SBossLifes, [FBoss.Life]));
          DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-191, dxdraw.surfaceheight-41, Format(SEinheiten, [tmpEnemyAnzeige]));
          DXDraw.Surface.Canvas.Font.Color := clLime;
          DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-190, dxdraw.surfaceheight-80, Format(SBossLifes, [FBoss.Life]));
          DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-190, dxdraw.surfaceheight-40, Format(SEinheiten, [tmpEnemyAnzeige]));
        end
        else
        begin
          DXDraw.Surface.Canvas.Font.Color := clGreen;
          DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-191, dxdraw.surfaceheight-41, Format(SBossLifes, [FBoss.Life]));
          DXDraw.Surface.Canvas.Font.Color := clLime;
          DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-190, dxdraw.surfaceheight-40, Format(SBossLifes, [FBoss.Life]));
        end;
      end
      else if tmpEnemyAnzeige>0 then
      begin
        DXDraw.Surface.Canvas.Font.Color := clGreen;
        DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-191, dxdraw.surfaceheight-41, Format(SEinheiten, [tmpEnemyAnzeige]));
        DXDraw.Surface.Canvas.Font.Color := clLime;
        DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-190, dxdraw.surfaceheight-40, Format(SEinheiten, [tmpEnemyAnzeige]));
      end;
      {$ENDREGION}
 
      {$REGION 'Anzeige Mission erfolgreich/gescheitert'}
      if (EnemyCounter=0) and (FRestEnemies=0) then
      begin
        DXDraw.Surface.Canvas.Font.Color := clGreen;
        DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-251, dxdraw.surfaceheight-41, SMissionSuccessful);
        DXDraw.Surface.Canvas.Font.Color := clLime;
        DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-250, dxdraw.surfaceheight-40, SMissionSuccessful);
        DXDraw.Surface.Canvas.Release;
        Sleep(1);
        inc(FCounter);
        if FCounter>150{200} then PlayerSprite.FlyAway;
      end;
      {$ENDREGION}
    end
    else
    begin
      DXDraw.Surface.Canvas.Font.Color := clMaroon;
      DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-251, dxdraw.surfaceheight-41, SMissionFailed);
      DXDraw.Surface.Canvas.Font.Color := clRed;
      DXDraw.Surface.Canvas.Textout(dxdraw.surfacewidth-250, dxdraw.surfaceheight-40, SMissionFailed);
    end;
    DXDraw.Surface.Canvas.Release;
  end;
end;
 
procedure TMainForm.SceneGameOver;
resourcestring
  SGameOver = 'Game Over!';
begin
  DXDraw.Surface.Fill(0);
 
  FNotSave := true;
  Cheat.enabled := false;
  GamePause.enabled := false;
  Neustart.enabled := false;
  Brush.Style := bsClear;
  DXDraw.Surface.Canvas.Font.Size := 35;
  DXDraw.Surface.Canvas.Font.Color := clMaroon;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfacewidth div 2)-127, 98, SGameOver);
  DXDraw.Surface.Canvas.Font.Color := clRed;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfacewidth div 2)-125, 100, SGameOver);
  if (FBlink div 300) mod 2=0 then
  begin
    DXDraw.Surface.Canvas.Font.Size := 30;
    DXDraw.Surface.Canvas.Font.Color := clOlive;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-187, dxdraw.surfaceheight-117, SWeiterMitLeertaste);
    DXDraw.Surface.Canvas.Font.Color := clYellow;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, dxdraw.surfaceheight-115, SWeiterMitLeertaste);
  end;
  BlinkUpdate;
  DXDraw.Surface.Canvas.Release;
 
  // Weiter mit Leertaste oder Enter
  if (isButton1 in DXInput.States) or (isButton2 in DXInput.States) then
  begin
    PlaySound(smsSceneMov, False);
    PalleteAnim(RGBQuad(0, 0, 0), 300);
    Sleep(200);
    StartScene(gsTitle);
  end;
end;
 
procedure TMainForm.SceneWin;
resourcestring
  SGewonnen = 'Gewonnen!';
begin
  DXDraw.Surface.Fill(0);
 
  FNotSave := true;
  Cheat.enabled := false;
  GamePause.enabled := false;
  Neustart.enabled := false;
 
  DXDraw.Surface.Canvas.Brush.Style := bsClear;
  DXDraw.Surface.Canvas.Font.Size := 35;
  DXDraw.Surface.Canvas.Font.Color := clMaroon;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-127, 98, SGewonnen);
  DXDraw.Surface.Canvas.Font.Color := clRed;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-125, 100, SGewonnen);
  if (FBlink div 300) mod 2=0 then
  begin
    DXDraw.Surface.Canvas.Font.Size := 30;
    DXDraw.Surface.Canvas.Font.Color := clOlive;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-187, dxdraw.surfaceheight-117, SWeiterMitLeertaste);
    DXDraw.Surface.Canvas.Font.Color := clYellow;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, dxdraw.surfaceheight-115, SWeiterMitLeertaste);
  end;
  BlinkUpdate;
  DXDraw.Surface.Canvas.Release;
 
  // Weiter mit Leertaste oder Enter
  if (isButton1 in DXInput.States) or (isButton2 in DXInput.States) then
  begin
    PlaySound(smsSceneMov, False);
    PalleteAnim(RGBQuad(0, 0, 0), 300);
    Sleep(200);
    StartScene(gsTitle);
  end;
end;
 
procedure TMainForm.StartSceneNewLevel;
begin
  sleep(500);
  FNotSave := true; // Wenn man speichert, würde man LevelAdventTable vom vorherigen Level machen, das wär müll!
  Cheat.enabled := false;
  Neustart.enabled := false;
  GamePause.enabled := false;
  GameStart.enabled := true;
  Spielgeschwindigkeit.enabled := false;
  Spielgeschwindigkeit.enabled := false;
  if ((FGameMode=gmLevels) and not GetLevelFileName(FLevel,false).found)
     // or ((FGameMode=gmRandom) and (FLevel > 25))
     or (FLevel > MaxPossibleLevels) then
  begin
    //PlaySound('SceneMov', False);
    PalleteAnim(RGBQuad(0, 0, 0), 300);
    Sleep(200);
    StartScene(gsWin);
    exit;
  end;
  MusicSwitchTrack(smmScene);
end;
 
procedure TMainForm.EndSceneNewLevel;
begin
  {  Ende NewLevel  }
end;
 
procedure TMainForm.SceneNewLevel;
resourcestring
  SLevelScene = 'Level %d';
begin
  DXDraw.Surface.Fill(0);
 
  DXDraw.Surface.Canvas.Brush.Style := bsClear;
  DXDraw.Surface.Canvas.Font.Size := 40;
  DXDraw.Surface.Canvas.Font.Color := clMaroon;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-(83+(length(inttostr(flevel))*22)), 98, Format(SLevelScene, [flevel]));
  DXDraw.Surface.Canvas.Font.Color := clRed;
  DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-(81+(length(inttostr(flevel))*22)), 100, Format(SLevelScene, [flevel]));
  if (FBlink div 300) mod 2=0 then
  begin
    DXDraw.Surface.Canvas.Font.Size := 30;
    DXDraw.Surface.Canvas.Font.Color := clOlive;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-187, dxdraw.surfaceheight-117, SWeiterMitLeertaste);
    DXDraw.Surface.Canvas.Font.Color := clYellow;
    DXDraw.Surface.Canvas.Textout((dxdraw.surfaceWidth div 2)-185, dxdraw.surfaceheight-115, SWeiterMitLeertaste);
  end;
  BlinkUpdate;
  DXDraw.Surface.Canvas.Release;
 
  // Weiter mit Leertaste oder Enter
  if (isButton1 in DXInput.States) or (isButton2 in DXInput.States) then
  begin
    PlaySound(smsSceneMov, False);
    PalleteAnim(RGBQuad(0, 0, 0), 300);
    Sleep(200);
    StartScene(gsMain);
  end;
end;
 
procedure TMainForm.OptionMusicClick(Sender: TObject);
begin
  OptionMusic.Checked := not OptionMusic.Checked;
  if OptionMusic.Checked then
  begin
    MusicSwitchTrack(FMusic)
  end
  else
  begin
    StopMusic(FMusic);
  end;
  WriteOptions;
end;
 
procedure TMainForm.PlayMusic(Name: TSpaceMissionMusicTrack);
begin
  if not OptionMusic.checked then exit;
  if Ord(Name) > dxmusic.Midis.Count then exit;
  dxmusic.Midis.Items[Ord(Name)-1].Play;
end;
 
procedure TMainForm.StopMusic(Name: TSpaceMissionMusicTrack);
begin
  if Name = smmNone then exit;
  if Ord(Name) > dxmusic.Midis.Count then exit;
  dxmusic.Midis.Items[Ord(Name)-1].Stop;
end;
 
procedure TMainForm.ResumeMusic(Name: TSpaceMissionMusicTrack);
begin
  if not OptionMusic.checked then exit;
  if Ord(Name) > dxmusic.Midis.Count then exit;
  dxmusic.Midis.Items[Ord(Name)-1].Play; // TODO: how to pause/resume instead play/stop
end;
 
procedure TMainForm.PauseMusic(Name: TSpaceMissionMusicTrack);
begin
  if Name = smmNone then exit;
  if Ord(Name) > dxmusic.Midis.Count then exit;
  dxmusic.Midis.Items[Ord(Name)-1].Stop; // TODO: how to pause/resume instead play/stop
end;
 
procedure TMainForm.SpielstandClick(Sender: TObject);
begin
  speicherungform.showmodal;
end;
 
procedure TMainForm.LevelNeuStarten;
begin
  FNextScene := gsNewLevel;
  FLife := FLifeAtLevelStart;
  FScore := FScoreAtLevelStart;
end;
 
procedure TMainForm.NeustartClick(Sender: TObject);
begin
  LevelNeuStarten;
end;
 
procedure TMainForm.LeichtClick(Sender: TObject);
begin
  leicht.checked := true;
  FSpeed := SpeedEasy;
  writeoptions;
end;
 
procedure TMainForm.MittelClick(Sender: TObject);
begin
  mittel.checked := true;
  FSpeed := SpeedMedium;
  writeoptions;
end;
 
procedure TMainForm.SchwerClick(Sender: TObject);
begin
  schwer.checked := true;
  FSpeed := SpeedHard;
  writeoptions;
end;
 
procedure TMainForm.MasterClick(Sender: TObject);
begin
  master.checked := true;
  FSpeed := SpeedMaster;
  writeoptions;
end;
 
procedure TMainForm.FormShow(Sender: TObject);
resourcestring
  SFileError = 'Die Datei kann von SpaceMission nicht geöffnet werden!';
var
  SavGame: TSaveData;
begin
  if Assigned(SplashForm) then
  begin
    SplashForm.Hide;
    FreeAndNil(SplashForm);
  end;
 
  dxtimer.Enabled := true;
  dxtimer.ActiveOnly := true;
 
  ResetLevelData;
  if (paramcount > 0) and (fileexists(paramstr(1))) and (ExtractFileExt(paramstr(1)).ToLower = '.sav') then
  begin
    SavGame := TSaveData.Create;
    try
      try
        SavGame.LoadFromFile(paramstr(1));
        FScore := SavGame.Score;
        FLife := SavGame.Life;
        FLevel := SavGame.Level;
        FGameMode := SavGame.GameMode;
        FLevelDataAlreadyLoaded := true; // do not call NewLevel() in StartSceneMain
        if Assigned(SavGame.LevelData) then
        begin
          LevelData.Assign(SavGame.LevelData);
        end;
      except
        on E: Exception do
        begin
          showmessage(SFileError + ' ' +E.Message);
          GameStartClick(GameStart);
          exit;
        end;
      end;
    finally
      FreeAndNil(SavGame);
    end;
    //FNextScene := gsNewLevel;
    StartScene(gsNewLevel);
    exit;
  end;
end;
 
procedure TMainForm.InformationenClick(Sender: TObject);
begin
  dxtimer.enabled := false;
  InfoForm.showmodal;
  if not mainform.gamepause.checked then mainform.dxtimer.enabled := true;
end;
 
procedure TMainForm.CheatClick(Sender: TObject);
begin
  CheatForm.showmodal;
end;
 
procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  if optionMusic.checked then StopMusic(FMusic);
  SpriteEngine.Engine.Clear;
  dxsound.Finalize;
  dxinput.Destroy;
  DXTimer.Enabled := False;
end;
 
procedure TMainForm.FormDestroy(Sender: TObject);
begin
  FreeAndNil(imagelist);
  FreeAndNil(spriteengine);
  FreeAndNil(dxdraw);
  FreeAndNil(wavelist);
  FreeAndNil(dxmusic);
  FreeAndNil(dxsound);
  //FreeAndNil(dxinput);
  FreeAndNil(dxtimer);
  DeleteCriticalSection(TimerCS);
  FreeAndNil(LevelData);
end;
 
procedure PostKeyEx32(key: Word; const shift: TShiftState; specialkey: Boolean);
{************************************************************
* Procedure PostKeyEx32
*
* Parameters:
*  key    : virtual keycode of the key to send. For printable
*           keys this is simply the ANSI code (Ord(character)).
*  shift  : state of the modifier keys. This is a set, so you
*           can set several of these keys (shift, control, alt,
*           mouse buttons) in tandem. The TShiftState type is
*           declared in the Classes Unit.
*  specialkey: normally this should be False. Set it to True to
*           specify a key on the numeric keypad, for example.
* Description:
*  Uses keybd_event to manufacture a series of key events matching
*  the passed parameters. The events go to the control with focus.
*  Note that for characters key is always the upper-case version of
*  the character. Sending without any modifier keys will result in
*  a lower-case character, sending it with [ssShift] will result
*  in an upper-case character!
// Code by P. Below
************************************************************}
type
  TShiftKeyInfo = record
    shift: Byte;
    vkey: Byte;
  end;
  byteset = set of 0..7;
const
  shiftkeys: array [1..3] of TShiftKeyInfo =
    ((shift: Ord(ssCtrl); vkey: VK_CONTROL),
    (shift: Ord(ssShift); vkey: VK_SHIFT),
    (shift: Ord(ssAlt); vkey: VK_MENU));
var
  flag: DWORD;
  bShift: ByteSet absolute shift;
  i: Integer;
begin
  for i := 1 to 3 do
  begin
    if shiftkeys[i].shift in bShift then
      keybd_event(shiftkeys[i].vkey, MapVirtualKey(shiftkeys[i].vkey, 0), 0, 0);
  end; { For }
  if specialkey then
    flag := KEYEVENTF_EXTENDEDKEY
  else
    flag := 0;
 
  keybd_event(key, MapvirtualKey(key, 0), flag, 0);
  flag := flag or KEYEVENTF_KEYUP;
  keybd_event(key, MapvirtualKey(key, 0), flag, 0);
 
  for i := 3 downto 1 do
  begin
    if shiftkeys[i].shift in bShift then
      keybd_event(shiftkeys[i].vkey, MapVirtualKey(shiftkeys[i].vkey, 0),
        KEYEVENTF_KEYUP, 0);
  end; { For }
end; { PostKeyEx32 }
 
procedure TMainForm.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if Key = VK_ESCAPE then
  begin
    // TODO: Unfortunately, you cannot see if it is already popup. It would be great if ESC closes the main menu...
    Key := 0;
    PostKeyEx32(Ord('S'), [ssAlt], False);
  end;
end;
 
end.
 
 

Rev 90	Rev 97
1	unit GamMain;	1	unit GamMain;
2		2
3	interface	3	interface
4		4
5	uses	5	uses
6	Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,	6	Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
7	StdCtrls, ExtCtrls, Menus, DIB, DXClass, DXSprite, DXDraws, DXInput, DXSounds,	7	StdCtrls, ExtCtrls, Menus, DIB, DXClass, DXSprite, DXDraws, DXInput, DXSounds,
8	ShellAPI, DirectX{$IF CompilerVersion >= 23.0},	8	ShellAPI, DirectX{$IF CompilerVersion >= 23.0},
9	System.UITypes{$IFEND}, ComLevelReader, DirectMusic, Global;	9	System.UITypes{$IFEND}, ComLevelReader, DirectMusic, Global;
10		10
11	type	11	type
12	TGameScene = (	12	TGameScene = (
13	gsNone,	13	gsNone,
14	gsTitle,	14	gsTitle,
15	gsMain,	15	gsMain,
16	gsGameOver,	16	gsGameOver,
17	gsNewLevel,	17	gsNewLevel,
18	gsWin	18	gsWin
19	);	19	);
20		20
21	TGameInterval = (	21	TGameInterval = (
22	giLeicht,	22	giLeicht,
23	giMittel,	23	giMittel,
24	giSchwer,	24	giSchwer,
25	giMaster	25	giMaster
26	);	26	);
27		27
28	TBackground = class(TBackgroundSprite)	28	TBackground = class(TBackgroundSprite)
29	strict private	29	strict private
30	FSpeed: Double;	30	FSpeed: Double;
31	strict protected	31	strict protected
32	procedure DoMove(MoveCount: Integer); override;	32	procedure DoMove(MoveCount: Integer); override;
33	public	33	public
34	property Speed: Double read FSpeed write FSpeed;	34	property Speed: Double read FSpeed write FSpeed;
35	end;	35	end;
36		36
37	TBackgroundSpecial = class(TBackgroundSprite)	37	TBackgroundSpecial = class(TBackgroundSprite)
38	strict private	38	strict private
39	FSpeed: Double;	39	FSpeed: Double;
40	strict protected	40	strict protected
41	procedure DoMove(MoveCount: Integer); override;	41	procedure DoMove(MoveCount: Integer); override;
42	public	42	public
43	property Speed: Double read FSpeed write FSpeed;	43	property Speed: Double read FSpeed write FSpeed;
44	end;	44	end;
45		45
46	TExplosion = class(TImageSprite)	46	TExplosion = class(TImageSprite)
47	strict private	47	strict private
48	FCounter: Integer;	48	FCounter: Integer;
49	strict protected	49	strict protected
50	procedure DoMove(MoveCount: Integer); override;	50	procedure DoMove(MoveCount: Integer); override;
51	public	51	public
52	constructor Create(AParent: TSprite); override;	52	constructor Create(AParent: TSprite); override;
53	end;	53	end;
54		54
55	TPlayerOrEnemyOrItemState = (	55	TPlayerOrEnemyOrItemState = (
56	pesUnknown,	56	pesUnknown,
57	pesNormal,	57	pesNormal,
58	pesExploding, // only boss, as preparation of pesDead	58	pesExploding, // only boss, as preparation of pesDead
59	pesDead,	59	pesDead,
60	pesDeadVanished,	60	pesDeadVanished,
61	pesFlyaway, // only player at mission end	61	pesFlyaway, // only player at mission end
62	pesEntering,	62	pesEntering,
63	pesHovering // only some kind of enemies	63	pesHovering // only some kind of enemies
64	);	64	);
65		65
66	TPlayerOrEnemyOrItem = class abstract (TImageSprite)	66	TPlayerOrEnemyOrItem = class abstract (TImageSprite)
67	strict protected	67	strict protected
68	FState: TPlayerOrEnemyOrItemState;	68	FState: TPlayerOrEnemyOrItemState;
69	public	69	public
70	property State: TPlayerOrEnemyOrItemState read FState;	70	property State: TPlayerOrEnemyOrItemState read FState;
71	end;	71	end;
72		72
73	TPlayerSprite = class(TPlayerOrEnemyOrItem)	73	TPlayerSprite = class(TPlayerOrEnemyOrItem)
74	private	74	private
75	FTamaCount: Integer; // accessed by TPlayerTamaSprite.Destroy	75	FTamaCount: Integer; // accessed by TPlayerTamaSprite.Destroy
76	strict private	76	strict private
77	FCounter: Integer;	77	FCounter: Integer;
78	FOldTamaTime: Integer;	78	FOldTamaTime: Integer;
79	strict protected	79	strict protected
80	procedure DoCollision(Sprite: TSprite; var Done: Boolean); override;	80	procedure DoCollision(Sprite: TSprite; var Done: Boolean); override;
81	procedure DoMove(MoveCount: Integer); override;	81	procedure DoMove(MoveCount: Integer); override;
82	public	82	public
83	constructor Create(AParent: TSprite); override;	83	constructor Create(AParent: TSprite); override;
84	procedure FlyAway;	84	procedure FlyAway;
85	end;	85	end;
86		86
87	TPlayerTamaSprite = class(TImageSprite)	87	TPlayerTamaSprite = class(TImageSprite)
88	strict private	88	strict private
89	FPlayerSprite: TPlayerSprite;	89	FPlayerSprite: TPlayerSprite;
90	strict protected	90	strict protected
91	property PlayerSprite: TPlayerSprite read FPlayerSprite write FPlayerSprite;	91	property PlayerSprite: TPlayerSprite read FPlayerSprite write FPlayerSprite;
92	procedure DoCollision(Sprite: TSprite; var Done: Boolean); override;	92	procedure DoCollision(Sprite: TSprite; var Done: Boolean); override;
93	procedure DoMove(MoveCount: Integer); override;	93	procedure DoMove(MoveCount: Integer); override;
94	public	94	public
95	constructor Create(AParent: TSprite; APlayerSprite: TPlayerSprite); reintroduce;	95	constructor Create(AParent: TSprite; APlayerSprite: TPlayerSprite); reintroduce;
96	destructor Destroy; override;	96	destructor Destroy; override;
97	end;	97	end;
98		98
99	TEnemyClass = class of TEnemy;	99	TEnemyClass = class of TEnemy;
100	TEnemy = class abstract (TPlayerOrEnemyOrItem)	100	TEnemy = class abstract (TPlayerOrEnemyOrItem)
101	strict protected	101	strict protected
102	FCounter: Integer;	102	FCounter: Integer;
103	FLife: integer;	103	FLife: integer;
104	procedure HitEnemy(ADead: Boolean); virtual;	104	procedure HitEnemy(ADead: Boolean); virtual;
105	public	105	public
106	property Life: integer read FLife;	106	property Life: integer read FLife;
107	procedure Hit(AHitStrength: integer = 1);	107	procedure Hit(AHitStrength: integer = 1);
108	constructor Create(AParent: TSprite; ALifes: integer); reintroduce; virtual;	108	constructor Create(AParent: TSprite; ALifes: integer); reintroduce; virtual;
109	destructor Destroy; override;	109	destructor Destroy; override;
110	end;	110	end;
111		111
112	TEnemyTama = class(TImageSprite)	112	TEnemyTama = class(TImageSprite)
113	strict private	113	strict private
114	FEnemySprite: TSprite;	114	FEnemySprite: TSprite;
115	strict protected	115	strict protected
116	property EnemySprite: TSprite read FEnemySprite write FEnemySprite;	116	property EnemySprite: TSprite read FEnemySprite write FEnemySprite;
117	procedure DoMove(MoveCount: Integer); override;	117	procedure DoMove(MoveCount: Integer); override;
118	public	118	public
119	constructor Create(AParent: TSprite; AEnemySprite: TSprite); reintroduce;	119	constructor Create(AParent: TSprite; AEnemySprite: TSprite); reintroduce;
120	end;	120	end;
121		121
122	TEnemyMeteor = class(TEnemy)	122	TEnemyMeteor = class(TEnemy)
123	strict protected	123	strict protected
124	procedure DoMove(MoveCount: Integer); override;	124	procedure DoMove(MoveCount: Integer); override;
125	procedure HitEnemy(ADead: Boolean); override;	125	procedure HitEnemy(ADead: Boolean); override;
126	public	126	public
127	constructor Create(AParent: TSprite; ALifes: integer); override;	127	constructor Create(AParent: TSprite; ALifes: integer); override;
128	end;	128	end;
129		129
130	TEnemyUFO = class(TEnemy)	130	TEnemyUFO = class(TEnemy)
131	strict protected	131	strict protected
132	procedure DoMove(MoveCount: Integer); override;	132	procedure DoMove(MoveCount: Integer); override;
133	procedure HitEnemy(ADead: Boolean); override;	133	procedure HitEnemy(ADead: Boolean); override;
134	public	134	public
135	constructor Create(AParent: TSprite; ALifes: integer); override;	135	constructor Create(AParent: TSprite; ALifes: integer); override;
136	end;	136	end;
137		137
138	TEnemyUFO2 = class(TEnemy)	138	TEnemyUFO2 = class(TEnemy)
139	strict private	139	strict private
140	FCounter: Integer;	140	FCounter: Integer;
141	FTamaCount: Integer;	141	FTamaCount: Integer;
142	FOldTamaTime: Integer;	142	FOldTamaTime: Integer;
143	strict protected	143	strict protected
144	procedure DoMove(MoveCount: Integer); override;	144	procedure DoMove(MoveCount: Integer); override;
145	procedure HitEnemy(ADead: Boolean); override;	145	procedure HitEnemy(ADead: Boolean); override;
146	public	146	public
147	constructor Create(AParent: TSprite; ALifes: integer); override;	147	constructor Create(AParent: TSprite; ALifes: integer); override;
148	end;	148	end;
149		149
150	TEnemyAttacker = class(TEnemy)	150	TEnemyAttacker = class(TEnemy)
151	strict protected	151	strict protected
152	procedure DoMove(MoveCount: Integer); override;	152	procedure DoMove(MoveCount: Integer); override;
153	procedure HitEnemy(ADead: Boolean); override;	153	procedure HitEnemy(ADead: Boolean); override;
154	public	154	public
155	constructor Create(AParent: TSprite; ALifes: integer); override;	155	constructor Create(AParent: TSprite; ALifes: integer); override;
156	end;	156	end;
157		157
158	TEnemyAttacker2 = class(TEnemy)	158	TEnemyAttacker2 = class(TEnemy)
159	strict private	159	strict private
160	FCounter: Integer;	160	FCounter: Integer;
161	FTamaF: Integer;	161	FTamaF: Integer;
162	FTamaT: Integer;	162	FTamaT: Integer;
163	FPutTama: Boolean;	163	FPutTama: Boolean;
164	strict protected	164	strict protected
165	procedure DoMove(MoveCount: Integer); override;	165	procedure DoMove(MoveCount: Integer); override;
166	procedure HitEnemy(ADead: Boolean); override;	166	procedure HitEnemy(ADead: Boolean); override;
167	public	167	public
168	constructor Create(AParent: TSprite; ALifes: integer); override;	168	constructor Create(AParent: TSprite; ALifes: integer); override;
169	end;	169	end;
170		170
171	TEnemyAttacker3 = class(TEnemy)	171	TEnemyAttacker3 = class(TEnemy)
172	strict private	172	strict private
173	FCounter: Integer;	173	FCounter: Integer;
174	FTamaCount: Integer;	174	FTamaCount: Integer;
175	FOldTamaTime: Integer;	175	FOldTamaTime: Integer;
176	strict protected	176	strict protected
177	procedure DoMove(MoveCount: Integer); override;	177	procedure DoMove(MoveCount: Integer); override;
178	procedure HitEnemy(ADead: Boolean); override;	178	procedure HitEnemy(ADead: Boolean); override;
179	public	179	public
180	constructor Create(AParent: TSprite; ALifes: integer); override;	180	constructor Create(AParent: TSprite; ALifes: integer); override;
181	end;	181	end;
182		182
183	TEnemyBoss = class(TEnemy)	183	TEnemyBoss = class(TEnemy)
184	strict private	184	strict private
185	FCounter: Integer;	185	FCounter: Integer;
186	FTamaF: Integer;	186	FTamaF: Integer;
187	FTamaT: Integer;	187	FTamaT: Integer;
188	FPutTama: Boolean;	188	FPutTama: Boolean;
189	waiter1, waiter2: integer;	189	waiter1, waiter2: integer;
190	strict protected	190	strict protected
191	procedure DoMove(MoveCount: Integer); override;	191	procedure DoMove(MoveCount: Integer); override;
192	procedure HitEnemy(ADead: Boolean); override;	192	procedure HitEnemy(ADead: Boolean); override;
193	public	193	public
194	constructor Create(AParent: TSprite; ALifes: integer); override;	194	constructor Create(AParent: TSprite; ALifes: integer); override;
195	destructor Destroy; override;	195	destructor Destroy; override;
196	end;	196	end;
197		197
198	TItemClass = class of TItem;	198	TItemClass = class of TItem;
199	TItem = class abstract (TPlayerOrEnemyOrItem)	199	TItem = class abstract (TPlayerOrEnemyOrItem)
200	strict protected	200	strict protected
201	procedure DoMove(MoveCount: Integer); override;	201	procedure DoMove(MoveCount: Integer); override;
202	public	202	public
203	procedure Collected; virtual;	203	procedure Collected; virtual;
204	end;	204	end;
205		205
206	TItemMedikit = class(TItem)	206	TItemMedikit = class(TItem)
207	public	207	public
208	procedure Collected; override;	208	procedure Collected; override;
209	constructor Create(AParent: TSprite); override;	209	constructor Create(AParent: TSprite); override;
210	end;	210	end;
211		211
212	TMainForm = class(TDXForm)	212	TMainForm = class(TDXForm)
213	MainMenu: TMainMenu;	213	MainMenu: TMainMenu;
214	Spiel: TMenuItem;	214	Spiel: TMenuItem;
215	GameStart: TMenuItem;	215	GameStart: TMenuItem;
216	GamePause: TMenuItem;	216	GamePause: TMenuItem;
217	Beenden: TMenuItem;	217	Beenden: TMenuItem;
218	Einstellungen: TMenuItem;	218	Einstellungen: TMenuItem;
219	OptionMusic: TMenuItem;	219	OptionMusic: TMenuItem;
220	Hilfe: TMenuItem;	220	Hilfe: TMenuItem;
221	OptionSound: TMenuItem;	221	OptionSound: TMenuItem;
222	Leer3: TMenuItem;	222	Leer3: TMenuItem;
223	Spielstand: TMenuItem;	223	Spielstand: TMenuItem;
224	Leer5: TMenuItem;	224	Leer5: TMenuItem;
225	Neustart: TMenuItem;	225	Neustart: TMenuItem;
226	Spielgeschwindigkeit: TMenuItem;	226	Spielgeschwindigkeit: TMenuItem;
227	Leicht: TMenuItem;	227	Leicht: TMenuItem;
228	Mittel: TMenuItem;	228	Mittel: TMenuItem;
229	Schwer: TMenuItem;	229	Schwer: TMenuItem;
230	Informationen: TMenuItem;	230	Informationen: TMenuItem;
231	Leer6: TMenuItem;	231	Leer6: TMenuItem;
232	Leer1: TMenuItem;	232	Leer1: TMenuItem;
233	Cheat: TMenuItem;	233	Cheat: TMenuItem;
234	CheckUpdates: TMenuItem;	234	CheckUpdates: TMenuItem;
235	Master: TMenuItem;	235	Master: TMenuItem;
236	Hilfe1: TMenuItem;	236	Hilfe1: TMenuItem;
237	N1: TMenuItem;	237	N1: TMenuItem;
238	Wasgibtesneues1: TMenuItem;	238	Wasgibtesneues1: TMenuItem;
239	procedure DXDrawFinalize(Sender: TObject);	239	procedure DXDrawFinalize(Sender: TObject);
240	procedure DXDrawInitialize(Sender: TObject);	240	procedure DXDrawInitialize(Sender: TObject);
241	procedure FormCreate(Sender: TObject);	241	procedure FormCreate(Sender: TObject);
242	procedure DXTimerTimer(Sender: TObject; LagCount: Integer);	242	procedure DXTimerTimer(Sender: TObject; LagCount: Integer);
243	procedure DXTimerActivate(Sender: TObject);	243	procedure DXTimerActivate(Sender: TObject);
244	procedure DXTimerDeactivate(Sender: TObject);	244	procedure DXTimerDeactivate(Sender: TObject);
245	procedure DXDrawInitializing(Sender: TObject);	245	procedure DXDrawInitializing(Sender: TObject);
246	procedure GameStartClick(Sender: TObject);	246	procedure GameStartClick(Sender: TObject);
247	procedure GamePauseClick(Sender: TObject);	247	procedure GamePauseClick(Sender: TObject);
248	procedure BeendenClick(Sender: TObject);	248	procedure BeendenClick(Sender: TObject);
249	procedure OptionSoundClick(Sender: TObject);	249	procedure OptionSoundClick(Sender: TObject);
250	procedure OptionMusicClick(Sender: TObject);	250	procedure OptionMusicClick(Sender: TObject);
251	procedure SpielstandClick(Sender: TObject);	251	procedure SpielstandClick(Sender: TObject);
252	procedure NeustartClick(Sender: TObject);	252	procedure NeustartClick(Sender: TObject);
253	procedure LeichtClick(Sender: TObject);	253	procedure LeichtClick(Sender: TObject);
254	procedure MittelClick(Sender: TObject);	254	procedure MittelClick(Sender: TObject);
255	procedure SchwerClick(Sender: TObject);	255	procedure SchwerClick(Sender: TObject);
256	procedure MasterClick(Sender: TObject);	256	procedure MasterClick(Sender: TObject);
257	procedure FormShow(Sender: TObject);	257	procedure FormShow(Sender: TObject);
258	procedure InformationenClick(Sender: TObject);	258	procedure InformationenClick(Sender: TObject);
259	procedure CheatClick(Sender: TObject);	259	procedure CheatClick(Sender: TObject);
260	procedure FormClose(Sender: TObject; var Action: TCloseAction);	260	procedure FormClose(Sender: TObject; var Action: TCloseAction);
261	procedure FormDestroy(Sender: TObject);	261	procedure FormDestroy(Sender: TObject);
262	procedure CheckUpdatesClick(Sender: TObject);	262	procedure CheckUpdatesClick(Sender: TObject);
263	procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);	263	procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
264	procedure HilfeTopicClick(Sender: TObject);	264	procedure HilfeTopicClick(Sender: TObject);
265	private	265	private
266	ProgrammGestartet: boolean;	266	ProgrammGestartet: boolean;
267	FSpeed: integer;	267	FSpeed: integer;
268	FScene: TGameScene;	268	FScene: TGameScene;
269	FMusic: TSpaceMissionMusicTrack;	269	FMusic: TSpaceMissionMusicTrack;
270	FBlink: DWORD;	270	FBlink: DWORD;
271	FBlinkTime: DWORD;	271	FBlinkTime: DWORD;
272	FFrame, FAngle, FCounter, FEnemyAdventPos: Integer;	272	FFrame, FAngle, FCounter, FEnemyAdventPos: Integer;
273	PlayerSprite: TPlayerSprite;	273	PlayerSprite: TPlayerSprite;
274	TimerCS: TRTLCriticalSection;	274	TimerCS: TRTLCriticalSection;
275	procedure StartScene(Scene: TGameScene);	275	procedure StartScene(Scene: TGameScene);
276	procedure EndScene;	276	procedure EndScene;
277	procedure BlinkStart;	277	procedure BlinkStart;
278	procedure BlinkUpdate;	278	procedure BlinkUpdate;
279	procedure StartSceneTitle;	279	procedure StartSceneTitle;
280	procedure SceneTitle;	280	procedure SceneTitle;
281	procedure EndSceneTitle;	281	procedure EndSceneTitle;
282	procedure StartSceneMain;	282	procedure StartSceneMain;
283	procedure SceneMain;	283	procedure SceneMain;
284	procedure EndSceneMain;	284	procedure EndSceneMain;
285	procedure StartSceneGameOver;	285	procedure StartSceneGameOver;
286	procedure SceneGameOver;	286	procedure SceneGameOver;
287	procedure EndSceneGameOver;	287	procedure EndSceneGameOver;
288	procedure StartSceneWin;	288	procedure StartSceneWin;
289	procedure SceneWin;	289	procedure SceneWin;
290	procedure EndSceneWin;	290	procedure EndSceneWin;
291	procedure StartSceneNewLevel;	291	procedure StartSceneNewLevel;
292	procedure SceneNewLevel;	292	procedure SceneNewLevel;
293	procedure EndSceneNewLevel;	293	procedure EndSceneNewLevel;
294	procedure LevelNeuStarten;	294	procedure LevelNeuStarten;
295	private	295	private
296	{ Diverse temporäre Variablen }	296	{ Diverse temporäre Variablen }
297	Crash2: integer;	297	Crash2: integer;
298	EnemyCounter: integer;	298	EnemyCounter: integer;
299	Crash: boolean;	299	Crash: boolean;
300	crashsound: boolean;	300	crashsound: boolean;
301	public	301	public
302	FNextScene: TGameScene;	302	FNextScene: TGameScene;
303	FScore: Integer;	303	FScore: Integer;
304	FBoss: TEnemyBoss;	304	FBoss: TEnemyBoss;
305	FNotSave: boolean;	305	FNotSave: boolean;
306	FLife: integer;	306	FLife: integer;
307	FLevel: integer;	307	FLevel: integer;
308	FGameMode: TGameMode;	308	FGameMode: TGameMode;
309	FLifeAtLevelStart: integer;	309	FLifeAtLevelStart: integer;
310	FScoreAtLevelStart: integer;	310	FScoreAtLevelStart: integer;
311	FLevelDataAlreadyLoaded: boolean;	311	FLevelDataAlreadyLoaded: boolean;
312	FRestEnemies: integer;	312	FRestEnemies: integer;
313	FCheats: TCheatSet;	313	FCheats: TCheatSet;
314	{ VCL-Ersatz }	314	{ VCL-Ersatz }
315	dxdraw: TDxDraw;	315	dxdraw: TDxDraw;
316	imagelist: TDxImageList;	316	imagelist: TDxImageList;
317	spriteengine: tdxspriteengine;	317	spriteengine: tdxspriteengine;
318	dxsound: tdxsound;	318	dxsound: tdxsound;
319	dxmusic: tdxmusic;	319	dxmusic: tdxmusic;
320	wavelist: tdxwavelist;	320	wavelist: tdxwavelist;
321	dxinput: tdxinput;	321	dxinput: tdxinput;
322	dxtimer: tdxtimer;	322	dxtimer: tdxtimer;
323	{ Level-Routinen }	323	{ Level-Routinen }
324	LevelData: TLevelData;	324	LevelData: TLevelData;
325	procedure NewLevel(lev: integer);	325	procedure NewLevel(lev: integer);
326	procedure ResetLevelData;	326	procedure ResetLevelData;
327	{ Musik-Routinen }	327	{ Musik-Routinen }
328	procedure MusicSwitchTrack(Name: TSpaceMissionMusicTrack);	328	procedure MusicSwitchTrack(Name: TSpaceMissionMusicTrack);
329	procedure PlayMusic(Name: TSpaceMissionMusicTrack);	329	procedure PlayMusic(Name: TSpaceMissionMusicTrack);
330	procedure StopMusic(Name: TSpaceMissionMusicTrack);	330	procedure StopMusic(Name: TSpaceMissionMusicTrack);
331	procedure ResumeMusic(Name: TSpaceMissionMusicTrack);	331	procedure ResumeMusic(Name: TSpaceMissionMusicTrack);
332	procedure PauseMusic(Name: TSpaceMissionMusicTrack);	332	procedure PauseMusic(Name: TSpaceMissionMusicTrack);
333	{ Sound-Routinen }	333	{ Sound-Routinen }
334	procedure PlaySound(Sound: TSpaceMissionSound; Wait: Boolean);	334	procedure PlaySound(Sound: TSpaceMissionSound; Wait: Boolean);
335	{ Grafik-Routinen }	335	{ Grafik-Routinen }
336	function GetSpriteGraphic(Sprite: TSpaceMissionGraphicSprite): TPictureCollectionItem;	336	function GetSpriteGraphic(Sprite: TSpaceMissionGraphicSprite): TPictureCollectionItem;
337	{ Initialisiations-Routinen }	337	{ Initialisiations-Routinen }
338	procedure DXInit;	338	procedure DXInit;
339	procedure SoundInit;	339	procedure SoundInit;
340	procedure MusicInit;	340	procedure MusicInit;
341	{ Einstellungs-Routinen }	341	{ Einstellungs-Routinen }
342	procedure LoadOptions;	342	procedure LoadOptions;
343	procedure WriteOptions;	343	procedure WriteOptions;
344	{ Farb-Routinen }	344	{ Farb-Routinen }
345	function ComposeColor(Dest, Src: TRGBQuad; Percent: Integer): TRGBQuad;	345	function ComposeColor(Dest, Src: TRGBQuad; Percent: Integer): TRGBQuad;
346	procedure PalleteAnim(Col: TRGBQuad; Time: Integer);	346	procedure PalleteAnim(Col: TRGBQuad; Time: Integer);
347	end;	347	end;
348		348
349	var	349	var
350	MainForm: TMainForm;	350	MainForm: TMainForm;
351		351
352	implementation	352	implementation
353		353
354	uses	354	uses
355	GamSplash, GamSpeicherung, ComInfo, GamCheat, MMSystem, Registry,	355	GamSplash, GamSpeicherung, ComInfo, GamCheat, MMSystem, Registry,
356	ComHilfe;	356	ComHilfe;
357		357
358	{$R *.DFM}	358	{$R *.DFM}
359		359
360	const	360	const
361	DXInputButton = [isButton1, isButton2, isButton3,	361	DXInputButton = [isButton1, isButton2, isButton3,
362	isButton4, isButton5, isButton6, isButton7, isButton8, isButton9, isButton10, isButton11,	362	isButton4, isButton5, isButton6, isButton7, isButton8, isButton9, isButton10, isButton11,
363	isButton12, isButton13, isButton14, isButton15, isButton16, isButton17, isButton18,	363	isButton12, isButton13, isButton14, isButton15, isButton16, isButton17, isButton18,
364	isButton19, isButton20, isButton21, isButton22, isButton23, isButton24, isButton25,	364	isButton19, isButton20, isButton21, isButton22, isButton23, isButton24, isButton25,
365	isButton26, isButton27, isButton28, isButton29, isButton30, isButton31, isButton32];	365	isButton26, isButton27, isButton28, isButton29, isButton30, isButton31, isButton32];
366		366
367	resourcestring	367	resourcestring
368	SWeiterMitLeertaste = 'Weiter mit Leertaste';	368	SWeiterMitLeertaste = 'Weiter mit Leertaste';
369		369
370	{ TBackground }	370	{ TBackground }
371		371
372	procedure TBackground.DoMove(MoveCount: Integer);	372	procedure TBackground.DoMove(MoveCount: Integer);
373	var	373	var
374	ran: integer;	374	ran: integer;
375	bgs: TBackgroundSpecial;	375	bgs: TBackgroundSpecial;
376	begin	376	begin
377	inherited DoMove(MoveCount);	377	inherited DoMove(MoveCount);
378	X := X - MoveCount(60/1000)FSpeed;	378	X := X - MoveCount(60/1000)FSpeed;
379	ran := Random(1500);	379	ran := Random(1500);
380	if ran = 150 then	380	if ran = 150 then
381	begin	381	begin
382	bgs := TBackgroundSpecial.Create(mainform.SpriteEngine.Engine);	382	bgs := TBackgroundSpecial.Create(mainform.SpriteEngine.Engine);
383	bgs.SetMapSize(1, 1);	383	bgs.SetMapSize(1, 1);
384	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundPlanet1);	384	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundPlanet1);
385	bgs.Width := Image.Width;	385	bgs.Width := Image.Width;
386	bgs.Height := Image.Height;	386	bgs.Height := Image.Height;
387	bgs.Y := random(mainform.dxdraw.height);	387	bgs.Y := random(mainform.dxdraw.height);
388	bgs.X := mainform.dxdraw.width;	388	bgs.X := mainform.dxdraw.width;
389	ran := Random(2);	389	ran := Random(2);
390	if ran = 0 then	390	if ran = 0 then
391	begin	391	begin
392	bgs.Z := -20;	392	bgs.Z := -20;
393	bgs.Speed := 1.8;	393	bgs.Speed := 1.8;
394	end	394	end
395	else if ran = 1 then	395	else if ran = 1 then
396	begin	396	begin
397	bgs.Z := -40;	397	bgs.Z := -40;
398	bgs.Speed := 0.8;	398	bgs.Speed := 0.8;
399	end	399	end
400	else if ran = 2 then	400	else if ran = 2 then
401	begin	401	begin
402	bgs.Z := -60;	402	bgs.Z := -60;
403	bgs.Speed := 0.3;	403	bgs.Speed := 0.3;
404	end;	404	end;
405	end	405	end
406	else if ran = 500 then	406	else if ran = 500 then
407	begin	407	begin
408	bgs := TBackgroundSpecial.Create(mainform.SpriteEngine.Engine);	408	bgs := TBackgroundSpecial.Create(mainform.SpriteEngine.Engine);
409	bgs.SetMapSize(1, 1);	409	bgs.SetMapSize(1, 1);
410	ran := Random(4);	410	ran := Random(4);
411	if ran = 0 then	411	if ran = 0 then
412	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundRed)	412	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundRed)
413	else if ran = 1 then	413	else if ran = 1 then
414	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundBlue)	414	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundBlue)
415	else if ran = 2 then	415	else if ran = 2 then
416	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundYellow)	416	bgs.Image := MainForm.GetSpriteGraphic(smgBackgroundYellow)
417	else if ran = 3 then	417	else if ran = 3 then
418	bgs.Image := MainForm.GetSpriteGraphic(smgHintergrundRot);	418	bgs.Image := MainForm.GetSpriteGraphic(smgHintergrundRot);
419	bgs.Width := Image.Width;	419	bgs.Width := Image.Width;
420	bgs.Height := Image.Height;	420	bgs.Height := Image.Height;
421		421
422	bgs.Y := random(mainform.dxdraw.height);	422	bgs.Y := random(mainform.dxdraw.height);
423	bgs.X := mainform.dxdraw.width;	423	bgs.X := mainform.dxdraw.width;
424		424
425	{ ran := Random(2);	425	{ ran := Random(2);
426	if ran = 0 then	426	if ran = 0 then
427	begin	427	begin
428	bgs.Z := -20;	428	bgs.Z := -20;
429	bgs.Speed := 1.8;	429	bgs.Speed := 1.8;
430	end	430	end
431	else if ran = 1 then	431	else if ran = 1 then
432	begin	432	begin
433	bgs.Z := -40;	433	bgs.Z := -40;
434	bgs.Speed := 0.8;	434	bgs.Speed := 0.8;
435	end	435	end
436	else if ran = 2 then	436	else if ran = 2 then
437	begin }	437	begin }
438	bgs.Z := -60;	438	bgs.Z := -60;
439	bgs.Speed := 0.3;	439	bgs.Speed := 0.3;
440	{ end; }	440	{ end; }
441	end;	441	end;
442	end;	442	end;
443		443
444	{ TBackgroundSpecial }	444	{ TBackgroundSpecial }
445		445
446	procedure TBackgroundSpecial.DoMove(MoveCount: Integer);	446	procedure TBackgroundSpecial.DoMove(MoveCount: Integer);
447	begin	447	begin
448	inherited DoMove(MoveCount);	448	inherited DoMove(MoveCount);
449	X := X - MoveCount(60/1000)FSpeed;	449	X := X - MoveCount(60/1000)FSpeed;
450	if X < -Width then Dead;	450	if X < -Width then Dead;
451	end;	451	end;
452		452
453	{ TExplosion }	453	{ TExplosion }
454		454
455	constructor TExplosion.Create(AParent: TSprite);	455	constructor TExplosion.Create(AParent: TSprite);
456	begin	456	begin
457	inherited Create(AParent);	457	inherited Create(AParent);
458	mainform.PlaySound(smsExplosion, false);	458	mainform.PlaySound(smsExplosion, false);
459	Image := MainForm.GetSpriteGraphic(smgExplosion);	459	Image := MainForm.GetSpriteGraphic(smgExplosion);
460	Width := Image.Width;	460	Width := Image.Width;
461	Height := Image.Height;	461	Height := Image.Height;
462	AnimCount := Image.PatternCount;	462	AnimCount := Image.PatternCount;
463	AnimLooped := True;	463	AnimLooped := True;
464	AnimSpeed := DEFAULT_ANIMSPEED;	464	AnimSpeed := DEFAULT_ANIMSPEED;
465	AnimPos := Random(AnimCount);	465	AnimPos := Random(AnimCount);
466	end;	466	end;
467		467
468	procedure TExplosion.DoMove(MoveCount: Integer);	468	procedure TExplosion.DoMove(MoveCount: Integer);
469	begin	469	begin
470	inherited DoMove(MoveCount);	470	inherited DoMove(MoveCount);
471	inc(FCounter, MoveCount);	471	inc(FCounter, MoveCount);
472	if FCounter > 2999 then dead;	472	if FCounter > 2999 then dead;
473	end;	473	end;
474		474
475	{ TPlayerSprite }	475	{ TPlayerSprite }
476		476
477	constructor TPlayerSprite.Create(AParent: TSprite);	477	constructor TPlayerSprite.Create(AParent: TSprite);
478	begin	478	begin
479	inherited Create(AParent);	479	inherited Create(AParent);
480	FState := pesEntering;	480	FState := pesEntering;
481	Image := MainForm.GetSpriteGraphic(smgMachine);	481	Image := MainForm.GetSpriteGraphic(smgMachine);
482	Width := Image.Width;	482	Width := Image.Width;
483	Height := Image.Height;	483	Height := Image.Height;
484	X := -70{20};	484	X := -70{20};
485	Y := mainform.dxdraw.surfaceHeight / 2 - (height / 2);	485	Y := mainform.dxdraw.surfaceHeight / 2 - (height / 2);
486	Z := 2;	486	Z := 2;
487	AnimCount := Image.PatternCount;	487	AnimCount := Image.PatternCount;
488	AnimLooped := True;	488	AnimLooped := True;
489	AnimSpeed := DEFAULT_ANIMSPEED;	489	AnimSpeed := DEFAULT_ANIMSPEED;
490	end;	490	end;
491		491
492	procedure TPlayerSprite.DoCollision(Sprite: TSprite; var Done: Boolean);	492	procedure TPlayerSprite.DoCollision(Sprite: TSprite; var Done: Boolean);
493	begin	493	begin
494	if (Sprite is TItem) then	494	if (Sprite is TItem) then
495	begin	495	begin
496	TItem(Sprite).Collected;	496	TItem(Sprite).Collected;
497	end	497	end
498	else if ((Sprite is TEnemy) or (Sprite is TEnemyTama)) and not (ctInfiniteLives in mainform.FCheats) then	498	else if ((Sprite is TEnemy) or (Sprite is TEnemyTama)) and not (ctInfiniteLives in mainform.FCheats) then
499	begin	499	begin
500	if not mainform.crash then	500	if not mainform.crash then

Subversion Repositories spacemission

spacemission/GamMain.pas @ 4 – Rev 90 → 97