enemies.pas

dos下经典游戏超级马力的完整源代码

unit Enemies;

interface

  uses
    Buffers,
    Figures,
    VGA256,
    Glitter,
    TmpObj,
    Music,
    Crt;

  const
    StartEnemiesAt  = 2;
    ForgetEnemiesAt = 5;

  const
    tpDead            =  0;
    tpDying           =  1;
    tpChibibo         =  2;
    tpFlatChibibo     =  3;
    tpDeadChibibo     =  4;
    tpRisingChamp     =  5;
    tpChamp           =  6;
    tpRisingLife      =  7;
    tpLife            =  8;
    tpRisingFlower    =  9;
    tpFlower          = 10;
    tpRisingStar      = 11;
    tpStar            = 12;
    tpFireBall        = 13;
    tpDyingFireBall   = 14;
    tpVertFish        = 15;
    tpDeadVertFish    = 16;
    tpVertFireBall    = 17;
    tpVertPlant       = 18;
    tpDeadVertPlant   = 19;
    tpRed             = 20;
    tpDeadRed         = 21;

    tpKoopa           = 50;
    tpSleepingKoopa   = 51;
    tpWakingKoopa     = 52;
    tpRunningKoopa    = 53;
    tpDyingKoopa      = 54;
    tpDeadKoopa       = 55;

    tpLiftStart       = 60;
    tpBlockLift       = 60;
    tpDonut           = 61;
    tpLiftEnd         = 69;




  const
    Left  = 0;
    Right = 1;

    kGreen = 0;
    kRed   = 1;

  const
    Turbo: Boolean = FALSE;

  var
    cdChamp,
    cdLife,
    cdFlower,
    cdStar,
    cdEnemy,
    cdHit,
    cdLift,
    cdStopJump: Byte;
    PlayerX1,
    PlayerY1,
    PlayerX2,
    PlayerY2,
    PlayerXVel,
    PlayerYVel: Integer;
    Star: Boolean;

  procedure InitEnemyFigures;
  procedure ClearEnemies;
  procedure StopEnemies;
  procedure NewEnemy (InitType, SubType, InitX, InitY, InitXVel, InitYVel,
    InitDelay: Integer);
  procedure ShowEnemies;
  procedure HideEnemies;
  procedure MoveEnemies;
  procedure StartEnemies (X: Integer; Dir: ShortInt);
  procedure HitAbove (MapX, MapY: Integer);

implementation

  {$I Chibibo.$00} {$I Chibibo.$01}
  {$I Chibibo.$02} {$I Chibibo.$03}
  {$I Champ.$00}
  {$I Poison.$00}
  {$I Life.$00}
  {$I Flower.$00}
  {$I Star.$00}
  {$I Fish.$01}
  {$I PPlant.$00} {$I PPlant.$01}
  {$I PPlant.$02} {$I PPlant.$03}
  {$I Red.$00} {$I Red.$01}

  {$I F.$00} {$I F.$01} {$I F.$02} {$I F.$03}

  {$I HIT.$00}

  {$I GrKoopa.$00} {$I GrKoopa.$01}
  {$I RdKoopa.$00} {$I RdKoopa.$01}
  {$I GrKp.$00} {$I GrKp.$01}
  {$I RdKp.$00} {$I RdKp.$01}

  {$I Lift1.$00}
  {$I Donut.$00} {$I Donut.$01}

  var
    rKoopa: array [0..3] of array [0..20 * 24] of Byte;

  const
    FireBallList: array [0..3] of Pointer = (@F000, @F001, @F002, @F003);
    KoopaList: array [Left..Right, kGreen..kRed, 0..1] of Pointer =
      (((@GrKoopa000, @GrKoopa001), (@rdKoopa000, @rdKoopa001)),
       ((@rKoopa [0], @rKoopa [1]), (@rKoopa [2], @rKoopa [3])));

  {$I Fire.$00} {$I Fire.$01}

  const
    Grounded = 0;
    Falling  = 1;

  const
    MaxEnemies = 11;
    MaxEnemiesAtOnce = 25;

  type
    EnemyRec = record
      Tp,
      SubTp,
      XPos,
      YPos,
      LastXPos,
      LastYPos,
      MapX,
      MapY,
      XVel,
      YVel,
      MoveDelay,
      DelayCounter,
      Counter,
      Status: Integer;
      DirCounter: Byte;
  {    BackGround: ScreenBuffer; }
      BackGrAddr: array [0 .. MAX_PAGE] of Word;
    end;

    EnemyListPtr = ^EnemyList;
    EnemyList = Array [1 .. MaxEnemiesAtOnce] of EnemyRec;

  var
    EnemyPictures: Array [1 .. MaxEnemies, Left .. Right] of
      ImageBuffer;
    Enemy: EnemyListPtr;
    ActiveEnemies: String [MaxEnemiesAtOnce];
    NumEnemies: Byte absolute ActiveEnemies;
    TimeCounter: Byte;

  procedure Kill (i: Integer);
  begin
    with Enemy^[i] do
    case Tp of
      tpChibibo:
      begin
        Tp := tpDeadChibibo;
        XVel := -1 + 2 * Byte ((XPos + XVel) mod W > W div 2);
        YVel := -4;
        MoveDelay := 0;
        DelayCounter := 0;
        AddScore (100);
      end;
      tpRed:
      begin
        Tp := tpDeadRed;
        XVel := -1 + 2 * Byte ((XPos + XVel) mod W > W div 2);
        YVel := -4;
        MoveDelay := 0;
        DelayCounter := 0;
        AddScore (100);
      end;
      tpKoopa, tpSleepingKoopa, tpWakingKoopa, tpRunningKoopa:
      begin
        Tp := tpDeadKoopa;
        XVel := -1 + 2 * Byte ((XPos + XVel) mod W > W div 2);
        YVel := -4;
        MoveDelay := 0;
        DelayCounter := 0;
        AddScore (100);
      end;
      tpVertFish:
      begin
        Tp := tpDeadVertFish;
        XVel := 0;
        YVel := 0;
        MoveDelay := 2;
        DelayCounter := 0;
        Status := Falling;
        AddScore (100);
      end;
      tpVertPlant:
      begin
        Tp := tpDeadVertPlant;
        DelayCounter := 0;
        YVel := 0;
        AddScore (100);
      end;
    end;
  end;

  procedure ShowStar (X, Y: Integer);
  begin
    Beep (100);
    if (X + W > XView) and (X < XView + SCREEN_WIDTH) then
      NewTempObj (tpHit, X, Y, 0, 0, W, H);
  end;

  procedure ShowFire (X, Y: Integer);
  begin
    Beep (50);
    X := X - 4;
    Y := Y - 4;
    if (X + W > XView) and (X < XView + SCREEN_WIDTH) then
      NewTempObj (tpFire, X, Y, 0, 0, W, H);
  end;

  procedure Mirror20x24 (P1, P2: Pointer);
    const
      W = 20;
      H = 24;
    type
      PlaneBuffer = array[0..H - 1, 0..W div 4 - 1] of Byte;
      PlaneBufferArray = array[0..3] of PlaneBuffer;
      PlaneBufferArrayPtr = ^PlaneBufferArray;
    var
      Source, Dest: PlaneBufferArrayPtr;
    procedure Swap (Plane1, Plane2: Byte);
      var
        i, j: Byte;
    begin
      for j := 0 to H - 1 do
        for i := 0 to W div 4 - 1 do
        begin
          Dest^[Plane2, j, i] := Source^[Plane1, j, W div 4 - 1 - i];
          Dest^[Plane1, j, i] := Source^[Plane2, j, W div 4 - 1 - i];
        end;
    end;
  begin
    Source := P1;
    Dest := P2;
    Swap (0, 3);
    Swap (1, 2);
  end;

  procedure InitEnemyFigures;
  var
    i, j: Integer;
  begin
    if MemAvail < SizeOf (Enemy^) then
    begin
      System.WriteLn ('Not enough memory');
      Halt;
    end;
    GetMem (Enemy, SizeOf (Enemy^));

    Move (@Chibibo000^, EnemyPictures [1, Right], SizeOf (ImageBuffer));
    Move (@Chibibo001^, EnemyPictures [2, Right], SizeOf (ImageBuffer));

    Move (@Chibibo002^, EnemyPictures [4, Right], SizeOf (ImageBuffer));
    Move (@Chibibo003^, EnemyPictures [5, Right], SizeOf (ImageBuffer));

    Move (@Fish001^, EnemyPictures [3, Left], SizeOf (ImageBuffer));
    Mirror (@EnemyPictures [3, Left], @EnemyPictures [3, Right]);

    Move (@Red000^, EnemyPictures [6, Left], SizeOf (ImageBuffer));
    Move (@Red001^, EnemyPictures [7, Left], SizeOf (ImageBuffer));

    Move (@GrKp000^, EnemyPictures [8, Right], SizeOf (ImageBuffer));
    Move (@GrKp001^, EnemyPictures [9, Right], SizeOf (ImageBuffer));

    Move (@RdKp000^, EnemyPictures [10, Right], SizeOf (ImageBuffer));
    Move (@RdKp001^, EnemyPictures [11, Right], SizeOf (ImageBuffer));

    for i := 1 to MaxEnemies do
      if (i in [6, 7]) then
        Mirror (@EnemyPictures [i, Left], @EnemyPictures [i, Right])
      else
        if not (i in [3]) then
          Mirror (@EnemyPictures [i, Right], @EnemyPictures [i, Left]);

    for i := 0 to 1 do
      for j := kGreen to kRed do
        Mirror20x24 (@KoopaList [Left, j, i]^, @KoopaList [Right, j, i]^);
  end;

  procedure ClearEnemies;
  var
    i: Integer;
  begin
    for i := 1 to MaxEnemiesAtOnce do
      Enemy^[i]. Tp := tpDead;
    NumEnemies := 0;
    cdChamp := 0;
    cdLife := 0;
    cdFlower := 0;
    cdStar := 0;
    cdEnemy := 0;
    cdHit := 0;
    cdLift := 0;
    cdStopJump := 0;
  end;

  procedure StopEnemies;
  var
    i, j: Integer;
  begin
    for i := 1 to NumEnemies do
    begin
      j := Ord (ActiveEnemies [i]);
      with Enemy^[j] do
        case Tp of
          tpChibibo:
            WorldMap^[MapX, MapY] := '