LECTURE 7    Introduction to Ada I             586.1
              Continuation of tasking

   You should be working on Homework 6 and starting Homework 7.
Only turn in one compilation listing for the combined 6,7 and 8.
Real time demonstrations of your program running are a part of the
assignment. Have the completed program ready so you just type  $ RUN


   Included here are files form ECLUS::PUSERS:[ADA.HANDOUT]HW8* 
They are a more complete starter set if you are having trouble
or running out of time. You will learn more by developing from the
HW6* starting point.

HW8.ADA an example main procedure

-- This just makes T's  P's  and M's travel around on screen
-- 
-- Attached is HW8_SCREEN_IO, a package version of previous handout
--
-- This is optional information for HW6,7 and 8
--

with HW8PKG  ; use HW8PKG  ;
with HW8_SCREEN_IO ; use HW8_SCREEN_IO ;

procedure HW8 is
begin
   CLEAR_SCREEN ;
                   -- just start all 3
   TARGET.ZOOM ;
   PLANE.FLY  ;
   MISSILE.ZIP ;
   -- use sharred plot with a space at 0.0, 0.0 if needed.
end HW8 ;

HW8PKG.ADA


package HW8PKG is

   T : FLOAT := 0.0 ; -- global clock, TARGET does updates

   task  TARGET is   -- TASK SPECIFICATION FOR TARGET
      entry ZOOM  ;
   end TARGET ;
 
   task  PLANE is    -- TASK SPECIFICATION FOR PLANE
      entry FLY ;
   end PLANE ;
 
   task MISSILE is   -- TASK SPECIFICATION FOR MISSILE
      entry ZIP ;
   end MISSILE ;
 
   task SHARED is    -- SHARED TASK SPECIFICATION
      entry REPORT   (WHO:INTEGER ; X,Y,VX,VY:FLOAT) ;
      entry READ_OUT (WHO:INTEGER ; X,Y,VX,VY: out FLOAT) ;
      entry PLOT     (WHO:STRING ; X,Y:FLOAT) ;
   end SHARED ;
end HW8PKG ;
 
 
with FLOAT_MATH_LIB ; use FLOAT_MATH_LIB ;
with TEXT_IO ; use TEXT_IO  ;
with HW8_SCREEN_IO ; use HW8_SCREEN_IO ;

package body HW8PKG is
   task body TARGET is   
     TGT_X    : FLOAT := 2.0 ;
     TGT_Y    : FLOAT := 1.0 ;
     TGT_XOLD : FLOAT ;
     TGT_YOLD : FLOAT ;
   begin
      accept ZOOM ;
         loop
            T        := T + 0.03 ;
            TGT_XOLD := TGT_X ;
            TGT_YOLD := TGT_Y ;
            TGT_X    := COS(3.0*T) + 1.0 ;
            TGT_Y    := SIN(5.0*T) + 1.0 ;
            SHARED.PLOT  (" ",TGT_XOLD,TGT_YOLD) ;
            SHARED.PLOT  ("T",TGT_X,TGT_Y) ;
            exit when T > 12.0 ;
         end loop ;
         abort PLANE ; -- optional here, could also be in main procedure
         abort MISSILE ;
         abort SHARED ;
   end TARGET ;
 

   task body PLANE is    -- TASK BODY FOR PLANE
     PLANE_X    : FLOAT := 1.1 ;
     PLANE_Y    : FLOAT := 0.0 ;
     PLANE_XOLD : FLOAT ;
     PLANE_YOLD : FLOAT ;
   begin
      accept FLY ;
         loop
            PLANE_XOLD := PLANE_X ;
            PLANE_YOLD := PLANE_Y ;
            PLANE_X    := COS(1.0*T) + 1.0 ;
            PLANE_Y    := SIN(1.0*T) + 1.0 ;
            SHARED.PLOT    (" ",PLANE_XOLD,PLANE_YOLD) ;
            SHARED.PLOT    ("P",PLANE_X,PLANE_Y) ;
         end loop ;
   end PLANE ;
 
   task body MISSILE is   -- TASK BODY FOR MISSILE
     MIS_X    : FLOAT ;
     MIS_Y    : FLOAT ;
   begin
      accept ZIP ;
         loop
            MIS_X    := 0.5*COS(2.0*T) + 1.0 ;
            MIS_Y    := 0.5*SIN(2.0*T) + 1.0 ;
            SHARED.PLOT    ("M",MIS_X,MIS_Y) ;
         end loop ;
   end MISSILE ;

   task body SHARED is    -- SHARED TASK BODY
   begin
      loop
         select
            accept REPORT   (WHO:INTEGER ; X,Y,VX,VY:FLOAT) do
               null ; -- fill in for homework
            end ;
         or
            accept READ_OUT (WHO:INTEGER ; X,Y,VX,VY: out FLOAT) do
               null ; -- file in for homework
            end ;
         or
            accept PLOT     (WHO:STRING ; X,Y:FLOAT) do
               declare
                  I : INTEGER := INTEGER ( Y * 12.0 + 0.5 ) ;
                  J : INTEGER := INTEGER ( X * 39.0 + 0.5 ) ;
               begin
                  PUT_CHAR(I,J,WHO );
               end ;
            end ;
         or
            terminate ;
         end select ;
      end loop ;
   end SHARED ;
end HW8PKG ;

HW8_SCREEN_IO.ADA

package HW8_SCREEN_IO is

  procedure PUT_CHAR ( LINE : in INTEGER ;
                       COLUMN : in INTEGER ;
                       PLOT_STR : in STRING ) ;

  procedure PUT_BOLD ( LINE : in INTEGER ;
                       COLUMN : in INTEGER ;
                       PLOT_STR : in STRING ) ;
  procedure CLEAR_SCREEN ;

end HW8_SCREEN_IO ;

with TEXT_IO ; use TEXT_IO ;
package body HW8_SCREEN_IO is

  package INT_IO is new INTEGER_IO ( INTEGER ) ; use INT_IO ;

  procedure PUT_CHAR ( LINE : in INTEGER ;
                       COLUMN : in INTEGER ;
                       PLOT_STR : in STRING ) is

    L , C : INTEGER ;
    LCH , CCH : INTEGER := 1 ;
  begin
-- Validate the value passed for the line number - between 1 and 23
--  23 is needed because when program terminates it scrools screen if
--  at bottom as is the case here.
--              Don't raise, a fuss - just clip at top and bottom
    L := LINE ;
    if L < 1 then
      L := 1 ;
    elsif L > 23 then
      L := 23 ;
    end if ;

-- Validate the value passed for the column number - between 0 and 79
--               Don't raise a fuss, just clip at each edge
    C := COLUMN ;
    if C < 1 then
      C := 1 ;
    elsif C + PLOT_STR'LENGTH > 80 then
      C := 80 - PLOT_STR'LENGTH ;
    end if ;
-- Now output the whole string, prefixed with <ESC> [ and terminated with "f"
    PUT ( ASCII.ESC & "[" ) ;
    PUT ( L , 0 ) ;
    PUT ( ";" ) ;
    PUT ( C , 0 ) ;
    PUT ( "f" & PLOT_STR ) ;
  end PUT_CHAR ;

  procedure PUT_BOLD ( LINE : in INTEGER ;
                       COLUMN : in INTEGER ;
                       PLOT_STR : in STRING ) is
  begin
    PUT_CHAR( LINE, COLUMN, ASCII.ESC & "[1m" & PLOT_STR & ASCII.ESC & "[0m" ) ;
  end PUT_BOLD ;


  procedure CLEAR_SCREEN is
  begin
    PUT ( ASCII.ESC & "[2J" ) ;  -- Clear the screen and home cursor
  end CLEAR_SCREEN ;
end HW8_SCREEN_IO ;