PROGRAM Artillery_Battle ;  { Pascal/M version }

 { *** WRITTEN BY      Jim Bearden
                       Cancer Center, University of Hawaii
                       1236 Lauhala Street
                       Honolulu, Hawaii 96813

   *** DATE WRITTEN    December, 1981

   *** PROGRAM SUMMARY:
         This program simulates an artillery battle between two players.
       The initial setup (ground elevation on each side, locations of
       bunkers, height of the central "hill" or "valley", and wind
       direction and velocity) is generated at random for each game.
       Each player then enters the angle (in degrees above the horizontal)
       and velocity (in meters per second) of his shot. Flight of the
       projectile and its point of impact are displayed, as long as it
       remains on the screen. This program uses only ASCII characters and
       cursor positioning (no graphics capability required), so it should
       be usable on any CRT terminal with an addressable cursor (presently
       set up for a 24 x 80 screen size, but may be adapted to other sizes
       by changing constants as shown).
 }

 {$D- (Disable "Debug" option for increased speed) }

 CONST
   Grnd_sym  = '-' ; { Character used to represent ground surface in profile }
   Burst_sym = '*' ; { Represents point of impact on ground }
   Air_sym   = '+' ; { Represents projectile in flight }
   Max_X     =  79 ; { Number of screen columns - 1 }
   Max_Y     =  20 ; { Number of screen lines - 4 }
   Scale     = 100 ; { Number of meters represented by each screen unit }
   Max_wind  =  25 ; { Maximum allowed wind velocity, in meters/sec }
   Side_1    =  25 ; { Width of level ground section on player 1's side }
   Side_2    =  25 ; { Same, player 2's side }
   Center    =  30 ; { Width of center ("hill" or "valley") section }
     { Sum of (Side_1 + Side_2 + Center) must equal width of screen }
   Acc_g     = 9.8 ; { Acceleration of normal earth gravity, in meters/sec }
   Bell      =   7 ; { ASCII equivalent of "bell" sound }

 VAR
   X_pos_1, X_pos_2,   { Locations (on X-axis) of bunkers of players 1 and 2 }
   Level_1, Level_2,   { Heights of level ground sections on each side }
   Center_ht       : 0..Max_X ;
   Wind_vel        : -Max_wind..Max_wind ;
   Ground          : ARRAY [0..Max_X] OF Integer ;
   Direct_hit      : ARRAY [1..2] OF Boolean ;
   Rnd_num         : Real ;
   Answer          : Char ;
   Quit            : Boolean ;

PROCEDURE Set_Up_Game ;

 VAR
   X, Y : 0..Max_X ;

BEGIN { Set_Up_Game }

 { Set up initial conditions from random-number generator }
 Level_1 := Round (Max_Y * Random (0) / 2) ;
 Level_2 := Round (Max_Y * Random (0) / 2) ;
 Center_ht := Round (Max_Y * Random (0)) ;
 X_pos_1 := Round ((Side_1 - 3) * Random (0) + 1) ;
 X_pos_2 := Round ((Side_2 - 3) * Random (0) + Max_X - Side_2 + 1) ;
 Wind_vel := Round (2 * Max_wind * Random (0) - Max_wind) ;

 { Display initial layout and initialize "Ground" values }
 Conact (0) ;
 FOR X := 0 TO (Side_1 - 1) DO
   BEGIN
     Y := Level_1 ;
     GotoXY (X, (Max_Y - Y)) ;
     Write (Grnd_sym) ;
     Ground [X] := Y ;
   END ;
 FOR X := 0 TO (Center DIV 2 - 1) DO
   BEGIN
     Y := Round (Level_1 + (Center_ht - Level_1) * (X + 1) / (Center / 2)) ;
     GotoXY ((X + Side_1), (Max_Y - Y)) ;
     Write (Grnd_sym) ;
     Ground [X + Side_1] := Y ;
   END ;
 FOR X := 0 TO (Center DIV 2 - 1) DO
   BEGIN
     Y := Center_ht - Round ((Center_ht - Level_2) * (X + 1) / (Center / 2)) ;
     GotoXY ((X + Side_1 + Center DIV 2), (Max_Y - Y)) ;
     Write (Grnd_sym) ;
     Ground [X + Side_1 + Center DIV 2] := Y ;
   END ;
 FOR X := 0 TO (Side_2 - 1) DO
   BEGIN
     Y := Level_2 ;
     GotoXY ((X + Side_1 + Center), (Max_Y - Y)) ;
     Write (Grnd_sym) ;
     Ground [X + Side_1 + Center] := Y ;
   END ;

 { Show location of both players' bunkers }
 GotoXY (X_pos_1 - 1, (Max_Y - Ground [X_pos_1])) ;
 Write ('[1]') ;
 GotoXY (X_pos_2 - 1, (Max_Y - Ground [X_pos_2])) ;
 Write ('[2]') ;

 GotoXY (0, (Max_Y + 2)) ;
 Conact (1) ;
 Write ('Wind is to the ') ;
 IF Wind_vel <= 0 THEN
   Write ('LEFT ')
 ELSE
   Write ('RIGHT ') ;
 Write ('at ', Abs (Wind_vel), ' meters/sec; ') ;
 Write ('each bar (-) is 100 meters.') ;

 GotoXY (0, Max_Y + 3) ;
 Conact (1) ;
 Write ('When prompted, enter angle (degrees) and velocity (meters/sec)') ;
 Write (', or 0,0 to quit.') ;

 GotoXY (0, (Max_Y - Level_1 + 1)) ;
 Write ('Player #1: ') ;
 GotoXY ((Side_1 + Center), (Max_Y - Level_2 + 1)) ;
 Write ('Player #2: ') ;

 FOR X := 1 TO 2 DO
   Direct_hit [X] := False ;
 Quit := False ;

END ; { Set_Up_Game }


PROCEDURE Fire (Player : Integer) ;

 CONST
   Spaces    = 11 ;
   Pi        = 3.14159 ;
   Time_int  = 100 ;

 VAR
   Angle, Init_vel,
   Last_X, Last_Y,
   Next_X, Next_Y,
   X_vel, Y_vel    : Real ;
   N, Loc_X, Loc_Y : Integer ;
   Hit, On_screen  : Boolean ;

FUNCTION Wind_Fac (X_pos, Y_pos : Real) : Real ;

 CONST
   Wind_pct  = 0.1 ; { "Coupling factor" between wind and projectile }

 VAR
   Shielded  : Boolean ;

BEGIN { Wind_Fac }

 IF Wind_vel > 0 THEN
   IF Center_ht > Level_1 THEN
     Shielded := (X_pos > (Side_1 + Center DIV 2 + 1)) AND (Y_pos < Center_ht)
   ELSE
     Shielded := (X_pos > Side_1) AND (Y_pos < Level_1)
 ELSE
   IF Center_ht > Level_2 THEN
     Shielded := (X_pos < (Side_1 + Center DIV 2)) AND (Y_pos < Center_ht)
   ELSE
     Shielded := (X_pos < (Side_1 + Center)) AND (Y_pos < Level_2) ;

 IF Shielded THEN
   Wind_Fac := 0
 ELSE
   Wind_Fac := Wind_vel * Wind_pct ;

END { Wind_Fac } ;

BEGIN { Fire }

 IF Player = 1 THEN
   GotoXY (Spaces, (Max_Y - Level_1 + 1))
 ELSE
   GotoXY ((Side_1 + Center + Spaces), (Max_Y - Level_2 + 1)) ;
 Read (Angle, Init_vel) ;

 { Routine for early termination of game by either player }
 IF (Angle <= 0) OR (Init_vel <= 0) THEN
   BEGIN
     Quit := True ;
     Exit (Fire) ;
   END ;

 { Set up zero-time co-ordinates and velocities }
 Angle := Angle * Pi / 180 ; { Convert degrees to radians }
 X_vel := Init_vel * Cos (Angle) ;
 IF Player = 2 THEN
   X_vel := -X_vel ;
 Y_vel := Init_vel * Sin (Angle) ;
 IF Player = 1 THEN
   BEGIN
     Last_X := X_pos_1 ;
     Last_Y := Ground [X_pos_1] ;
   END
 ELSE
   BEGIN
     Last_X := X_pos_2 ;
     Last_Y := Ground [X_pos_2] ;
   END ;
 Hit := False ;
 On_screen := False ;

 REPEAT

   { Compute velocities and positions after next second of travel }
   X_vel := X_vel + Wind_Fac (Last_X, Last_Y) ;
   Y_vel := Y_vel - Acc_g ;
   IF On_screen THEN { Erase last symbol printed during air travel }
     BEGIN
       GotoXY (Loc_X, (Max_Y - Loc_Y)) ;
       Write (' ') ;
     END ;
   Next_X := Last_X + (X_vel / Scale) ;
   Loc_X := Round (Next_X) ;
   Next_Y := Last_Y + (Y_vel / Scale) ;
   Loc_Y := Round (Next_Y) ;

   IF (Loc_Y < 0) AND NOT (Loc_X IN [0..Max_X]) THEN { Hit ground off screen }
     BEGIN
       Hit := True ;
       Write (Chr (Bell)) ;
     END
   ELSE IF Loc_X IN [0..Max_X] THEN
     IF Loc_Y <= Ground [Loc_X] THEN { Hit ground on screen }
       BEGIN
         Loc_X := Round (Last_X + (Next_X - Last_X) / (Next_Y - Last_Y)) ;
         Hit := True ;
         Write (Chr (Bell)) ;
         IF (Abs (Loc_X - X_pos_1)) <= 1 THEN
           Direct_hit [1] := True
         ELSE IF (Abs (Loc_X - X_pos_2)) <= 1 THEN
           Direct_hit [2] := True
         ELSE
           BEGIN
             GotoXY (Loc_X, (Max_Y - Ground [Loc_X])) ;
             Write (Burst_sym) ;
           END ;
       END
     ELSE { Still in flight above ground }
       BEGIN
         On_screen := Loc_Y IN [0..Max_Y] ;
         IF On_screen THEN
           BEGIN
             GotoXY (Loc_X, (Max_Y - Loc_Y)) ;
             Write (Air_sym) ;
           END
         ELSE
           GotoXY (Loc_X, 0) ;
         FOR N := 1 TO Time_int DO { Nothing } ;
           { Time delay for display }
       END
   ELSE
     BEGIN
       On_screen := False ;
       GotoXY (0, (Max_Y + 3)) ;
     END ;

   { Update co-ordinates for next calculation }
   Last_X := Next_X ;
   Last_Y := Next_Y ;

 UNTIL Hit ;

END ; { Fire }


PROCEDURE Show_Hit ;

 VAR
   N : Integer ;

BEGIN { Show_Hit }

 IF Direct_hit [1] THEN
   GotoXY ((X_pos_1 - 1), (Max_Y - Level_1))
 ELSE
   GotoXY ((X_pos_2 - 1), (Max_Y - Level_2)) ;
 FOR N := 1 TO 3 DO
   Write (Burst_sym) ;

 IF Direct_hit [1] THEN
   GotoXY (0, (Max_Y - Level_1 + 1))
 ELSE
   GotoXY ((Side_1 + Center), (Max_Y - Level_2 + 1)) ;
 Conact (1) ;
 Writeln ('BLEEP!!! Wiped out!!!') ;

 FOR N := 1 TO 200 DO
   Write (Chr (Bell)) ;

END ; { Show_Hit }


BEGIN { Main program }

 Conact (0) ;
 Writeln ('Welcome to ARTILLERY BATTLE') ;
 Writeln ;

 { Routine to randomize pseudo-random-number generator }
 Write ('Press any key to start the game: ') ;
 WHILE Filebusy (Keyboard) DO
   Rnd_num := Random (0) ;
 Read (Keyboard, Answer) ;

 REPEAT

   Set_Up_Game ;

   REPEAT
     Fire (1) ;
     IF NOT (Direct_hit [1] OR Direct_hit [2] OR Quit) THEN
       Fire (2) ;
   UNTIL (Direct_hit [1] OR Direct_hit [2] OR Quit) ;

   IF NOT Quit THEN
     Show_hit ;

   GotoXY (0, (Max_Y + 2)) ;
   Conact (1) ;
   GotoXY (0, (Max_Y + 3)) ;
   Conact (1) ;
   Write ('Another game (Y/n) ? ') ;
   Read (Answer) ;

 UNTIL Answer IN ['N','n'] ;

END . { Main program }

You are viewing proxied material from gopher.floodgap.com. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.