with FLOAT_MATH_LIB ; use FLOAT_MATH_LIB ;
with TEXT_IO , INTEGER_TEXT_IO , FLOAT_TEXT_IO ;
use  TEXT_IO , INTEGER_TEXT_IO , FLOAT_TEXT_IO ;

package HW6BPKG is  -- just the basic control structure for HW6

  T : FLOAT := 0.0 ;  -- Global to all tasks and main program

  task TARGET is  -- TASK SPECIFICATION FOR TARGET
    entry ZOOM ;
  end TARGET ;

--   task  PLANE is    -- TASK SPECIFICATION FOR PLANE    \
--      entry FLY ;                                        \_ HW7
--   end PLANE ;                                           /
--   task MISSILE is   -- TASK SPECIFICATION FOR MISSILE  \
--      entry ZIP ;                                        \_ HW8
--   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 ( X , Y : FLOAT ;
                 PLOT_STR : STRING ) ;
  end SHARED ;
end HW6BPKG ;

package body HW6BPKG is

  task body TARGET is  -- TASK BODY FOR TARGET
    TGT_X : FLOAT := 2.0 ;  -- right middel of screen
    TGT_Y : FLOAT := 1.0 ;
    TGT_VX : FLOAT ;  -- target velocity needed for HW7
    TGT_VY : FLOAT ;
    TGT_XOLD : FLOAT ;  -- old X,Y for velocity computation
    TGT_YOLD : FLOAT ;
  begin
    accept ZOOM do
      null ;  -- Go immediately to parallel execution
    end ;
    while T < 8.0 loop  -- This is the timing loop
      T := T + 0.03 ;

--                   PUT YOUR CODE HERE TO COMPUTE TGT_X etc.
--
-- provide for sharing results with PLANE task
      SHARED.REPORT ( 1 , TGT_X , TGT_Y , TGT_VX , TGT_VY ) ;

-- go plot position
      SHARED.PLOT ( TGT_X , TGT_Y , "*" ) ;

--               you might erase old plot or make vapor trail
    end loop ;
  end TARGET ;

  task body SHARED is  -- SHARED TASK BODY
    type SH_VEC is array ( 1 .. 2 ) of FLOAT ;
    X_VALS : SH_VEC ;
    Y_VALS : SH_VEC ;
    VX_VALS : SH_VEC ;
    VY_VALS : SH_VEC ;
    I : INTEGER ;
    J : INTEGER ;
    ESC_STR : STRING ( 1 .. 1 ) ;

    function STRIP(S:STRING) return string is
    begin
      return S(2..S'LAST);
    end STRIP;
  begin
    loop
      select
        accept REPORT ( WHO : INTEGER ;
                        X , Y , VX , VY : FLOAT ) do
          X_VALS ( WHO ) := X ;
          Y_VALS ( WHO ) := Y ;
          VX_VALS ( WHO ) := VX ;
          VY_VALS ( WHO ) := VX ;
        end ;
      or
        accept READ_OUT ( WHO : INTEGER ;
                          X , Y , VX , VY : out FLOAT ) do
          X := X_VALS ( WHO ) ;
          Y := Y_VALS ( WHO ) ;
          VX := VX_VALS ( WHO ) ;
          VY := VY_VALS ( WHO ) ;
        end ;
      or
        accept PLOT ( X , Y : FLOAT ;
                      PLOT_STR : STRING ) do
          I := INTEGER ( Y * 10.0 ) + 1 ;
          J := INTEGER ( X * 30.0 ) + 1 ;
          ESC_STR ( 1 ) := ASCII.ESC ;

-- use concatenation in order to get one  put
          PUT ( ESC_STR & "[" & STRIP(INTEGER'IMAGE(I)) & ";" & 
                STRIP(INTEGER'IMAGE(J)) & "f" & PLOT_STR) ;
        end ;
      or
        terminate ;
      end select ;
    end loop ;
  end SHARED ;
end HW6BPKG ;

with TEXT_IO ; use TEXT_IO ;
with HW6BPKG ; use HW6BPKG ;

procedure HW6B is  -- one possible main procedure for HW6
begin
  PUT ( ASCII.ESC ) ;
  PUT ( "[2J" ) ;  -- CLEAR VT100 SCREEN
  TARGET.ZOOM ;
  while T < 8.0 loop  -- T is time from package HW6BPKG.
    SHARED.PLOT ( 0.0 , 0.0 , " " ) ;

-- This loop keeps the main program alive.
  end loop ;  -- The PLOT provides output so that

-- control gets to the tasks
-- This is needed to prevent premature
-- termination .
end HW6B ;