program plaadijoonis;
uses graph, crt;
type
punkt=record
       x: integer;
       y: integer;
       z: integer;
      end;

nelinurk= array[1..4]of punkt;
plaadid=array[1..100] of nelinurk;
var pinnad, pinnad2: plaadid;
arv, kpx, kpy, lk: integer;
n1, n2: real;

procedure oota; assembler;
label l1, l2;
asm
  mov dx, 3DAh
l1:
  in al, dx
  and al, 08h
  jnz l1
l2:
  in al, dx
  and al, 08h
  jz l2
end;

procedure algus;
var d, m, viga, punkt: integer;
f: text;
s: string;
begin
   assign(f, '3dj03.txt');
   reset(f);
   while not eof(f) do
   begin
     inc(arv);
     readln(f, s);
     val(copy(s, 1, 4), pinnad[arv, 1].x, viga);
     val(copy(s, 6, 4), pinnad[arv, 1].y, viga);
     val(copy(s, 11, 4), pinnad[arv, 1].z, viga);
     val(copy(s, 16, 4), pinnad[arv, 2].x, viga);
     val(copy(s, 21, 4), pinnad[arv, 2].y, viga);
     val(copy(s, 26, 4), pinnad[arv, 2].z, viga);
     val(copy(s, 31, 4), pinnad[arv, 3].x, viga);
     val(copy(s, 36, 4), pinnad[arv, 3].y, viga);
     val(copy(s, 41, 4), pinnad[arv, 3].z, viga);
     if length(s)>50 then
     begin
      val(copy(s, 46, 4), pinnad[arv, 4].x, viga);
      val(copy(s, 51, 4), pinnad[arv, 4].y, viga);
      val(copy(s, 56, 4), pinnad[arv, 4].z, viga);
     end else
      pinnad[arv, 4]:=pinnad[arv, 3];
 {    for punkt:=1 to 4 do inc(pinnad[arv, punkt].z, 500);}
   end;
   d:=VGA; m:=vgaMed;
   initgraph(d, m, '');
   kpx:=getmaxx div 2;
   kpy:=getmaxy div 2;
   n1:=0; n2:=0;
end;


procedure joonista_nelinurk(nn: nelinurk; varv: integer);
 var pp: array[1..4] of pointtype;
 i: integer;
begin
 for i:=1 to 4 do begin
     pp[i].x:=nn[i].x+kpx;
     pp[i].y:=-nn[i].y+kpy;
 end;
 setfillstyle(1, varv);
 fillpoly(4, pp);
end;

function naoga(nn: nelinurk): boolean;
type nv=record
      x, y, z: longint;
     end;
var
v1, v2: punkt;
nor: nv;
begin
 v1.x:=nn[2].x-nn[1].x; v1.y:=nn[2].y-nn[1].y; v1.z:=nn[2].z-nn[1].z;
 v2.x:=nn[3].x-nn[1].x; v2.y:=nn[3].y-nn[1].y; v2.z:=nn[3].z-nn[1].z;
 nor.x:=v1.y*v2.z-v2.y*v1.z;
 nor.y:=v2.x*v1.z-v1.x*v2.z;
 nor.z:=v1.x*v2.y-v2.x*v1.y;
 if nor.x*nn[1].x+nor.y*nn[1].y+nor.z*nn[1].z>0 then
   naoga:=true else naoga:=false;
end;

procedure joonista(p: plaadid; kogus: integer);
var i: integer;
begin
  for i:=1 to kogus do
  if naoga(p[i]) then
     joonista_nelinurk(p[i], red)
  else
    joonista_nelinurk(p[i], green);
end;

procedure paiguta(p1: plaadid; var p2: plaadid; kogus, kaugus:integer;
                  nurk1, nurk2: real);
var arv, punkt, x: integer;
begin
  for arv:=1 to kogus do
  for punkt:=1 to 4 do begin
      p2[arv, punkt].x:=round(p1[arv, punkt].x*cos(nurk1)+
                              p1[arv, punkt].y*sin(nurk1));
      p2[arv, punkt].y:=round(-p1[arv, punkt].x*sin(nurk1)+
                              p1[arv, punkt].y*cos(nurk1));
      p2[arv, punkt].z:=p1[arv, punkt].z;
  end;
  for arv:=1 to kogus do
  for punkt:=1 to 4 do begin
      x:=p2[arv, punkt].x;
      p2[arv, punkt].x:=round(p2[arv, punkt].x*cos(nurk2)+
                              p2[arv, punkt].z*sin(nurk2));
      p2[arv, punkt].z:=round(-x*sin(nurk2)+
                              p2[arv, punkt].z*cos(nurk2));
      inc(p2[arv, punkt].z, kaugus);
  end;
end;

procedure sorteeri(var p: plaadid; kogus: integer);
var i, j, maxkoht, max, k: integer;
nn: nelinurk;
begin
  for i:=1 to kogus-1 do
  begin
   maxkoht:=i;
   max:=p[i, 1].z;
   for j:=i to kogus do
   for k:=1 to 4 do
       if p[j, k].z>max then
       begin
        max:=p[j, k].z;
        maxkoht:=j;
       end;
   nn:=p[i];
   p[i]:=p[maxkoht];
   p[maxkoht]:=nn;
  end;
end;


begin
  algus;
  repeat
   if lk=0 then lk:=1 else lk:=0;
   setactivepage(lk);
   cleardevice;
   paiguta(pinnad, pinnad2, arv, 1000, 0.5, n1);
   sorteeri(pinnad2, arv);
   setfillstyle(1, black);
   bar(200, 150, 500, 400);
   joonista(pinnad2, arv);
   n1:=n1+0.05;
   if n1>2*Pi then n1:=n1-2*Pi;
   setvisualpage(lk);
   delay(60);
   oota;

  until keypressed;
   closegraph;
   readln;
end.