Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:

gas / PAS / PKV_!!!

.PAS
Скачиваний:
16
Добавлен:
15.06.2014
Размер:
62.85 Кб
Скачать
{ЙНННННННННННННННННННННННННННННННННННННННННННННННННННН»
є –Ёда®ў п ¬®¤Ґ«м ¤«п Ёбб«Ґ¤®ў ­Ёп а Ў®в®бЇ®б®Ў­®бвЁ є
є  «Ј®аЁв¬®ў а бЇ®§­®ў ­Ёп Ї®¤ўЁ¦­ле в®зҐЄ є
є Ї® ўЁ¤Ґ®Ё­д®а¬ жЁЁ ¤ЁбЄаҐв­®Ј® Ї®«п ­ Ў«о¤Ґ­Ёп є
ИННННННННННННННННННННННННННННННННННННННННННННННННННННј}
PROGRAM Pkv_Diplom (INPUT, OUTPUT);
USES
Crt ,
Graph;
TYPE
LinkD = ^PriznD;
LinkV = ^PriznV;
PriznD = RECORD
Prev : LinkD;
Time ,
X ,
Y : INTEGER;
Next : LinkD
END;
PriznV = RECORD
Prev : LinkV;
Time ,
X ,
Y ,
Vect ,
Lenth : INTEGER;
Brightness ,
Speed : REAL;
Next : LinkV;
END;
CONST
Max = 50;
VAR
ArrayBrightness : ARRAY [1..2,1..Max,1..Max] OF REAL;
ArrayDataF1 : ARRAY [1..1,1..10] OF REAL;
ArrayDataF2 : ARRAY [1..1,1..12] OF REAL;
ArrayDataF3 : ARRAY [1..1,1..13] OF REAL;
ArrayDataF4 : ARRAY [1..1,1..10] OF REAL;
ArrayDataF5 : ARRAY [1..1,1..10] OF REAL;
ArrayDataF6 : ARRAY [1..1,1..9] OF REAL;
ArrayDataF7 : ARRAY [1..1,1..10] OF REAL;
ArrayDataF8 : ARRAY [1..1,1..10] OF REAL;
ArrayDataF9 : ARRAY [1..1,1..9] OF REAL;
ArrayFunction : ARRAY [1..9] OF 1..9;
ArrayLH ,
ArrayLL : ARRAY [1..Max] OF REAL;
ArraySubBrightness : ARRAY [1..Max,1..Max] OF REAL;
ArrayWays : ARRAY [1..8,1..2] OF -1..1;
ArrayWindows : ARRAY [1..2,1..2,1..2] OF INTEGER;
InputBoolean : 0..2;
MemoryTime : 1..4;
QuantFunction : 1..9;
FirstX ,
FirstY ,
GranMaxX ,
GranMaxY ,
GranMinX ,
GranMinY ,
KoordX ,
KoordY ,
LenthX ,
LenthY ,
SizeWay ,
SizeWayMax : 1..Max;
MemDBegin : LinkD;
MemVBegin : LinkV;
MaxQuantScreen ,
NumberImitObj ,
QuantFindObj ,
QuantFindPom ,
ScreenNumber ,
SizePointX ,
SizePointY ,
SumLenthObj ,
SumLenthPom : INTEGER;
Alfa ,
AlfaMax ,
AlfaMin ,
K1 ,
K12 ,
K13 ,
Lenth ,
Lenth_MO ,
Lenth_SKO ,
LenthReal ,
LevelHigh ,
LevelLow ,
MaxBrightness ,
MinSubBrightness ,
NewPointBrightness ,
P_LO ,
P_PO ,
PointBrightness ,
PointX ,
PointY ,
Pom_SKO ,
RealPom_SKO ,
RealPom_Waiting ,
TimeBetwenScreen ,
V ,
V_max ,
V_min ,
V_SKO ,
V_Waiting ,
VolumeBrightness ,
VolumePomMO ,
VolumePomSKO ,
WaitingBrightness : REAL;
AlgSmall ,
KeyArrayBrightness ,
ModeOutScreen ,
PriznFind ,
PriznMaxBrightness ,
PriznOutScreen ,
PriznPom ,
PriznPrioritet ,
PriznSumBrightness : BOOLEAN;
ReadFile : TEXT;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  а бЇ®§­®ў ­Ёп і
АДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE Find;
VAR
UkasV ,
MemVEnd : LinkV;
UkasD : LinkD;
i ,
k ,
s ,
x ,
y : INTEGER;
LevelOldScreen ,
LevelRealScreen : REAL;
EmptyMemory : BOOLEAN;

{ Џа®жҐ¤га  г¤ «Ґ­Ёп Їа®ба®зҐ­­ле ўлЎ®а®Є
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE DelRecords;
VAR CurV ,
PrevV ,
NextV : LinkV;
CurD ,
PrevD ,
NextD :LinkD;
BEGIN
CurV := MemVBegin;
WHILE CurV <> NIL DO
BEGIN
IF CurV^.Time > MemoryTime
THEN BEGIN
PrevV := CurV^.Prev;
NextV := CurV^.Next;
DISPOSE (CurV);
IF PrevV = NIL
THEN
MemVBegin :=NextV
ELSE
PrevV^.Next :=NextV;
IF NextV <> NIL
THEN
NextV^.Prev := PrevV;
CurV := NextV
END
ELSE
CurV := CurV^.Next
END;
CurD := MemDBegin;
WHILE CurD <> NIL DO
BEGIN
IF CurD^.Time > MemoryTime
THEN BEGIN
PrevD := CurD^.Prev;
NextD := CurD^.Next;
DISPOSE (CurD);
IF PrevD = NIL
THEN
MemDBegin := NextD
ELSE
PrevD^.Next := NextD;
IF NextD <> NIL
THEN
NextD^.Prev := PrevD;
CurD := NextD
END
ELSE
CurD := CurD^.Next
END
END;

{ Џа®жҐ¤га  Їа®ўҐаЄЁ § Ї®«­Ґ­­®бвЁ Ї ¬пвЁ
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE ViewMemory;
BEGIN
IF MemAvail > 31
THEN
EmptyMemory := TRUE
ELSE BEGIN
IF PriznOutScreen
THEN BEGIN
SetViewPort (ArrayWindows [1,1,1], ArrayWindows [1,2,1],
ArrayWindows [1,1,2], ArrayWindows [1,2,2], ClipOn);
ClearViewPort;
SetColor (15);
OutTextXY (GetMaxX div 2, 2,
'Attention! Not enough memory for Find-process!')
END
ELSE BEGIN
CLRSCR;
WRITELN ('ЙНННННННННННННННННННННННННННННННННННННННННННННННННН»');
WRITELN ('є ‚­Ё¬ ­ЁҐ! ЌҐ¤®бв в®з­® Ї ¬пвЁ ¤«п а бЇ®§­®ў ­Ёп! є');
WRITELN ('ИННННННННННННННННННННННННННННННННННННННННННННННННННј');
READLN
END;
EmptyMemory := FALSE
END
END;

{ Џа®жҐ¤га  § ЇЁбЁ ўлЎ®аЄЁ ў D-Ї ¬пвм
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE IncMemD (a, b, c : INTEGER);
VAR
NewAdr ,
OldAdr : LinkD;
BEGIN
ViewMemory;
IF EmptyMemory
THEN BEGIN
{ § ЇЁбм ­®ў®Ј® н«Ґ¬Ґ­в  }
NewAdr := NEW (LinkD);
NewAdr^.Time := a;
NewAdr^.X := b;
NewAdr^.Y := c;
NewAdr^.Next := NIL;
{ ЇаЁб®Ґ¤Ё­Ґ­ЁҐ ҐЈ® Є бгйҐбвўго饩 Ї®б«Ґ¤®ў вҐ«м­®бвЁ }
IF MemDBegin = NIL
THEN BEGIN
MemDBegin := NewAdr;
NewAdr^.Prev := NIL
END
ELSE BEGIN
OldAdr := MemDBegin;
WHILE OldAdr^.Next <> NIL DO
OldAdr := OldAdr^.Next;
OldAdr^.Next := NewAdr;
NewAdr^.Prev := OldAdr
END
END
END;

{ Џа®жҐ¤га  § ЇЁбЁ ўлЎ®аЄЁ ў V-Ї ¬пвм
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE IncMemV (a, b, c, d, e : INTEGER; f, g : REAL);
VAR
NewAdr ,
OldAdr : LinkV;
BEGIN
ViewMemory;
IF EmptyMemory
THEN BEGIN
{ § ЇЁбм ­®ў®Ј® н«Ґ¬Ґ­в  }
NewAdr := NEW (LinkV);
NewAdr^.Time := a;
NewAdr^.X := b;
NewAdr^.Y := c;
NewAdr^.Vect := d;
NewAdr^.Lenth := e;
NewAdr^.Brightness := f;
NewAdr^.Speed := g;
NewAdr^.Next := NIL;
{ ЇаЁб®Ґ¤Ё­Ґ­ЁҐ ҐЈ® Є бгйҐбвўго饩 Ї®б«Ґ¤®ў вҐ«м­®бвЁ }
IF MemVBegin = NIL
THEN BEGIN
MemVBegin := NewAdr;
NewAdr^.Prev := NIL
END
ELSE BEGIN
OldAdr := MemVBegin;
WHILE OldAdr^.Next <> NIL DO
OldAdr := OldAdr^.Next;
OldAdr^.Next := NewAdr;
NewAdr^.Prev := OldAdr
END
END
END;

{ Џа®жҐ¤га  ўлў®¤  еа ­Ё¬ле ўлЎ®а®Є ­  нЄа ­
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE OutMem;
VAR CurV : LinkV;
CurD : LinkD;
BEGIN
CLRSCR;
WRITELN ('ќЉђЂЌ ЌЋЊ…ђ ', ScreenNumber);
WRITELN ('--------------------------------------------------');
CurD := MemDBegin;
WHILE CurD <> NIL DO
BEGIN
WRITELN ('T=', CurD^.Time, ', X=', CurD^.X, ', Y=', CurD^.Y, '.');
CurD := CurD^.Next
END;
WRITELN ('--------------------------------------------------');
CurV := MemVBegin;
WHILE CurV <> NIL DO
BEGIN
WRITELN ('T=', CurV^.Time, ', X=', CurV^.X, ', Y=',CurV^.Y, ',V=',
CurV^.Vect, ', L=', CurV^.Lenth);
CurV := CurV^.Next
END;
END;

{ Џа®жҐ¤га  ўлў®¤  ­  нЄа ­ ®Ў­ а㦥­­ле Ї®¬Ґе Ё ®ЎкҐЄв®ў
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE OutPoint (a : BOOLEAN; b, c : INTEGER);
VAR
m : STRING [2];
BEGIN
IF PriznOutScreen
THEN BEGIN
SetViewPort (ArrayWindows [1,1,1], ArrayWindows [1,2,1],
ArrayWindows [1,1,2], ArrayWindows [1,2,2], ClipOn);
ClearViewPort;
STR (ScreenNumber, m);
SetColor (15);
IF a
THEN BEGIN
OutTextXY (GetMaxX div 2, 2, 'Screen #' + m + ' Find object');
SetFillStyle (SolidFill, 5)
END
ELSE BEGIN
OutTextXY (GetMaxX div 2, 2, 'Screen #' + m + ' Find hindrance');
SetFillStyle (SolidFill, 1)
END;
SetViewPort (ArrayWindows [2,1,1], ArrayWindows [2,2,1],
ArrayWindows [2,1,2], ArrayWindows [2,2,2], ClipOn);
BAR (SizePointX*(x-1), SizePointY*(y-1), SizePointX*x-1,
SizePointY*y-1)
END
ELSE BEGIN
IF a
THEN BEGIN
CLRSCR;
WRITELN ('Љ ¤а ­®¬Ґа ', ScreenNumber);
WRITELN ('ЋЎкҐЄв: X=', x, ', Y=', y);
READLN
END
ELSE BEGIN
CLRSCR;
WRITELN ('Љ ¤а ­®¬Ґа ', ScreenNumber);
WRITELN ('Џ®¬Ґе : X=', x, ', Y=', y);
READLN
END
END
END;

BEGIN
UkasV := MemVBegin;
WHILE UkasV <> NIL DO
BEGIN
IF UkasV^.Next = NIL
THEN
MemVEnd := UkasV;
UkasV := UkasV^.Next
END;
UkasV := MemVBegin;
WHILE UkasV <> NIL DO
BEGIN
IF UkasV^.Vect > 2
THEN
s := UkasV^.Vect - 2
ELSE
s := UkasV^.Vect + 6;
IF UkasV^.Vect = -5
THEN
k := 8
ELSE
k := 5;
LevelOldScreen := UkasV^.Lenth * K12 + K13 * SQR (1 / UkasV^.Time -
V_Waiting) + UkasV^.Brightness + UkasV^.Speed;
FOR i:=1 TO k DO BEGIN
x := UkasV^.X + ArrayWays [s,1];
y := UkasV^.Y + ArrayWays [s,2];
IF NOT ((x < 1) OR (x > LenthX) OR (y < 1) OR (y > LenthY))
THEN
IF ArraySubBrightness [x,y] <> 0
THEN BEGIN
LevelRealScreen := LevelOldScreen + K1 * (2 *
ArraySubBrightness [x,y] -
WaitingBrightness);
IF SizeWay = SizeWayMax
THEN
if ArraySubBrightness [x,y] > VolumeBrightness
THEN
IF UkasV^.Lenth = SizeWay
THEN BEGIN
INC (QuantFindObj);
SumLenthObj := SumLenthObj + SizeWay + 1;
OutPoint (TRUE, x, y)
END
ELSE
IncMemV(1, x, y, s, UkasV^.Lenth + 1,
UkasV^.Brightness + K1 * (2 *
ArraySubBrightness [x,y] -
WaitingBrightness), UkasV^.Speed + K13 *
SQR (1 / UkasV^.Time - V_Waiting))
ELSE BEGIN
INC (QuantFindPom);
SumLenthPom := SumLenthPom + UkasV^.Lenth + 1;
OutPoint (FALSE, x, y)
END
ELSE
IF (UkasV^.Lenth = SizeWayMax) AND AlgSmall
THEN
IF LevelRealScreen > 0
THEN BEGIN
INC (QuantFindObj);
SumLenthObj := SumLenthObj + UkasV^.Lenth + 1;
OutPoint (TRUE, x, y)
END
ELSE
IF LevelRealScreen < 0
THEN BEGIN
INC (QuantFindPom);
SumLenthPom := SumLenthPom + UkasV^.Lenth +
1;
OutPoint (FALSE, x, y)
END
ELSE
IncMemV(1, x, y, s, UkasV^.Lenth + 1,
UkasV^.Brightness + K1 * (2 *
ArraySubBrightness [x,y] -
WaitingBrightness), UkasV^.Speed +
K13 * SQR (1 / UkasV^.Time -
V_Waiting))
ELSE
IF LevelRealScreen > LevelHigh
THEN BEGIN
INC (QuantFindObj);
SumLenthObj := SumLenthObj + UkasV^.Lenth + 1;
OutPoint (TRUE, x, y)
END
ELSE
IF LevelRealScreen < LevelLow
THEN BEGIN
INC (QuantFindPom);
SumLenthPom := SumLenthPom + UkasV^.Lenth +
1;
OutPoint (FALSE, x, y)
END
ELSE
IncMemV(1, x, y, s, UkasV^.Lenth + 1,
UkasV^.Brightness + K1 * (2 *
ArraySubBrightness [x,y] -
WaitingBrightness), UkasV^.Speed +
K13 * SQR (1 / UkasV^.Time -
V_Waiting))
END;
INC (s);
IF s > 8
THEN
s := 1
END;
INC (UkasV^.Time);
IF UkasV = MemVEnd
THEN
UkasV := NIL
ELSE
UkasV := UkasV^.Next
END;
IF SizeWay > 0
THEN BEGIN
UkasD := MemDBegin;
WHILE UkasD <> NIL DO
BEGIN
FOR s := 1 TO 8 DO
BEGIN
x := UkasD^.X + ArrayWays [s,1];
y := UkasD^.Y + ArrayWays [s,2];
IF NOT ( (x < 1) OR (x > LenthX) OR (y < 1) OR (y > LenthY))
THEN BEGIN
IF ArraySubBrightness [x,y] > VolumeBrightness
THEN
IF SizeWay = SizeWayMax
THEN
IncMemV (1, x, y, -5, 2, K1 * (2 *
ArraySubBrightness [x,y] -
WaitingBrightness), 0)
ELSE
IncMemV (1, x, y, -5, 1, K1 * (2 *
ArraySubBrightness [x,y] -
WaitingBrightness), 0)
ELSE
IF ArraySubBrightness [x,y] > 0
THEN BEGIN
INC (QuantFindPom);
INC (SumLenthPom);
OutPoint (FALSE, x, y)
END
END
END;
INC (UkasD^.Time);
UkasD := UkasD^.Next
END;
FOR x := GranMinX TO GranMaxX DO
FOR y := GranMinY TO GranMaxY DO
IF ArraySubBrightness [x,y] > VolumeBrightness
THEN
IncMemD (1, x, y)
ELSE
IF ArraySubBrightness [x,y] > 0
THEN BEGIN
INC (QuantFindPom);
INC (SumLenthPom);
OutPoint (FALSE, x, y)
END
END
ELSE
FOR x := GranMinX TO GranMaxX DO
FOR y := GranMinY TO GranMaxY DO
IF ArraySubBrightness [x,y] > 0
THEN
IncMemV (1, x, y, -5, 1, K1 * (2 * ArraySubBrightness [x,y] -
WaitingBrightness), 0);
DelRecords;
IF NOT (PriznOutScreen)
THEN
OutMem;
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  Ї®«г祭Ёп "а §­®бв­®© Є авЁ­л" Їг⥬ "ўаҐ¬Ґ­­®Ј® і
і ¤ЁддҐаҐ­жЁа®ў ­Ёп" і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE SubBrightness;
VAR
x ,
y : INTEGER;
pb : REAL;
BEGIN
FOR x := 1 TO LenthX DO
FOR y := 1 TO LenthY DO
BEGIN
IF KeyArrayBrightness
THEN
pb := ArrayBrightness [1,x,y] - ArrayBrightness [2,x,y]
ELSE
pb := ArrayBrightness [2,x,y] - ArrayBrightness [1,x,y];
IF (x = KoordX) AND (y = KoordY)
THEN
pb := pb + NewPointBrightness;
IF ABS (pb) < MinSubBrightness
THEN
ArraySubBrightness [x,y] := 0
ELSE
ArraySubBrightness [x,y] := ABS (pb)
END
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  б«гз ©­®Ј® ўҐйҐб⢥­­®Ј® зЁб«  ®в -1 ¤® 1, а бЇаҐ¤Ґ«Ґ­­®Ј® Ї® і
і ­®а¬ «м­®¬г § Є®­г б ¬ вҐ¬ вЁзҐбЄЁ¬ ®¦Ё¤ ­ЁҐ¬ 0 Ё б।­ҐЄў ¤а вЁзҐбЄЁ¬ і
і ®вЄ«®­Ґ­ЁҐ¬ 1 і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
FUNCTION FunctionRandom : REAL;
VAR
a ,
b ,
r ,
sq : REAL;
BEGIN
REPEAT
a := 2 * RANDOM - 1;
b := 2 * RANDOM - 1;
r := SQR (a) + SQR (b)
UNTIL
r < 1;
sq := SQRT (- LN (r) / r);
FunctionRandom := a * sq / 2
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  ¤ўЁ¦Ґ­Ёп в®зҐз­®Ј® ®ЎкҐЄв  і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE PointMovement;
BEGIN
IF ScreenNumber = 1
THEN BEGIN
Lenth := Lenth_MO + FunctionRandom * Lenth_SKO;
Alfa := AlfaMin + Random * (AlfaMax - AlfaMin);
V := V_Waiting + Random * V_SKO;
PointX := FirstX;
PointY := FirstY
END
ELSE BEGIN
PointX := PointX + V * COS (Alfa);
PointY := PointY + V * SIN (Alfa)
END;
KoordX := round (PointX);
KoordY := round (PointY);
NewPointBrightness := VolumePomMO + FunctionRandom * VolumePomSKO +
PointBrightness
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  Ё­ЁжЁ «Ё§ жЁЁ Ја дЁзҐбЄ®Ј® а ¦Ё¬  Ё § ¤ ­Ёп ®Є®­ і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE InitGraphMode;
CONST
Message = 'Copyright (c) 1996 by Popov Konstantin Valerievich';
VAR
GraphDriver ,
GraphMode ,
h ,
x1 ,
x2 ,
y1 ,
y2 : INTEGER;
BEGIN
CLRSCR;
WRITE ('ђҐ¦Ё¬ ўлў®¤  Ё§®Ўа ¦Ґ­Ёп /0-­Ґ ўлў®¤Ёвм/: ');
READLN (h);
IF h = 0
THEN
PriznOutScreen := FALSE
ELSE BEGIN
PriznOutScreen := TRUE;
WRITE ('ђҐ¦Ё¬ ўлў®¤  Ё§®Ўа ¦Ґ­Ёп /0-Є ¤а, 1-а §­®бв­ п Є авЁ­ /: ');
READLN (h);
IF h = 0
THEN
ModeOutScreen := TRUE
ELSE
ModeOutScreen := FALSE;
{ ‚ў®¤ а §¬Ґа®ў п祩ЄЁ }
WRITE ('ђ §¬Ґа аҐжҐЇв®а  Ї® ®бЁ 0X = ');
READLN (SizePointX);
WRITE ('ђ §¬Ґа аҐжҐЇв®а  Ї® ®бЁ 0Y = ');
READLN (SizePointY);
{ €­ЁжЁ «Ё§ жЁп Ја дЁзҐбЄ®Ј® ०Ё¬  }
GraphDriver := 9;
GraphMode := 2;
InitGraph (GraphDriver, GraphMode, 'D:\TP\BGI;E:\TP\BGI');
{ ‡ ¤ ­ЁҐ ⥪бв®ў®Ј® ०Ё¬  }
SetTextJustify (1, 2);
SetTextStyle (0, 0, 1);
h := TextHeight ('A');
{ ‚лў®¤  ўв®абЄЁе Їа ў }
x1 := 0;
y1 := 0;
x2 := GetMaxX;
y2 := h + 3;
SetViewPort (x1, y1, x2, y2, ClipOn);
Rectangle (0, 0, GetMaxX, h + 3);
OutTextXY (GetMaxX div 2, 2, Message);
{ ‡ ¤ ­ЁҐ ®Є­  ўлў®¤  ­®¬Ґа  Є ¤а  }
y1 := y2 + 2;
y2 := y2 + y1;
SetViewPort (x1, y1, x2, y2, ClipOn);
Rectangle (0, 0, GetMaxX, h + 3);
ArrayWindows [1,1,1] := x1 + 1;
ArrayWindows [1,1,2] := x2 - 1;
ArrayWindows [1,2,1] := y1 + 1;
ArrayWindows [1,2,2] := y2 - 1;
{ ‡ ¤ ­ЁҐ ®Є­  ўлў®¤  ­ҐЇ®б।б⢥­­® Є ¤а  }
y1 := y2 + 2;
x2 := x1 + LenthX * SizePointX + 1;
y2 := y1 + LenthY * SizePointY + 1;
SetViewPort (x1, y1, x2, y2, ClipOn);
Rectangle (0, 0, LenthX * SizePointX + 1, LenthY * SizePointY + 1);
ArrayWindows [2,1,1] := x1 + 1;
ArrayWindows [2,1,2] := x2 - 1;
ArrayWindows [2,2,1] := y1 + 1;
ArrayWindows [2,2,2] := y2 - 1
END
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  ўлў®¤  ­  нЄа ­ ®зҐаҐ¤­®Ј® Є ¤а  і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE OutScreen;
VAR
c ,
cd ,
ce ,
cp ,
d ,
i ,
j ,
op ,
x ,
y : INTEGER;
pb : REAL;
m : STRING [2];
BEGIN
SetViewPort (ArrayWindows [1,1,1], ArrayWindows [1,2,1],
ArrayWindows [1,1,2], ArrayWindows [1,2,2], ClipOn);
ClearViewPort;
STR (ScreenNumber, m);
SetColor (15);
OutTextXY (GetMaxX div 2, 2, 'Screen #' + m);
SetViewPort (ArrayWindows [2,1,1], ArrayWindows [2,2,1],
ArrayWindows [2,1,2], ArrayWindows [2,2,2], ClipOn);
ClearViewPort;
d := SizePointX * SizePointY;
FOR x :=1 TO LenthX DO
FOR y := 1 TO LenthY DO
BEGIN
c := 15;
IF ModeOutScreen
THEN
IF KeyArrayBrightness
THEN
pb := ArrayBrightness [1,x,y]
ELSE
pb := ArrayBrightness [2,x,y]
ELSE
pb := ArraySubBrightness [x,y];
IF (x = KoordX) AND (y = KoordY)
THEN BEGIN
c := 2;
IF ModeOutScreen
THEN
pb := pb + NewPointBrightness
END;
IF (pb > 0) AND (pb < MaxBrightness)
THEN BEGIN
cp := ROUND (d * pb / MaxBrightness);
ce := d - cp;
IF cp > ce
THEN BEGIN
cd := cp;
cp := ce;
ce := cd;
SetFillStyle (SolidFill, c);
BAR (SizePointX*(x-1), SizePointY*(y-1), SizePointX*x-1,
SizePointY*y-1);
c := 0
END;
cd := 0;
FOR i := 1 TO SizePointX DO
FOR j := 1 TO SizePointY DO
BEGIN
IF cd < 0
THEN BEGIN
IF cp > 1
THEN
cd := ROUND (ce / cp);
op := ROUND (RANDOM (ROUND (cd))) + 1;
END;
IF op = 0
THEN BEGIN
PutPixel (SizePointX * (x - 1) - 1 + i,
SizePointY * (y - 1) - 1 + j, c);
DEC (cp)
END
ELSE
DEC (ce);
DEC (cd);
DEC (op)
END
END
ELSE
IF NOT (pb < MaxBrightness)
THEN BEGIN
SetFillStyle (SolidFill, c);
BAR (SizePointX * x - SizePointX,
SizePointY * y - SizePointY, SizePointX * x - 1,
SizePointY * y - 1)
END
END
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  а бзҐв  Є®нддЁжЁҐ­в®ў і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE Coefficient;
VAR
i : INTEGER;
DeltaLH ,
DeltaLL : REAL;

{ ”г­ЄжЁп а бзҐв  ўҐа®пв­®бв­®Ј® Ё­вҐЈа «  ўЁ¤  e dt
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Integral (Param : REAL) : REAL;
VAR
i ,
n : LONGINT;
Summa ,
Delta : SINGLE;
BEGIN
Summa := Param;
FOR n := 1 TO ABS (ROUND (Param) * 5 ) DO
BEGIN
IF ODD (n)
THEN
Delta := -1
ELSE
Delta := 1;
FOR i := 1 TO n DO
Delta := Delta / i;
FOR i := 1 TO (2 * n + 1) DO
Delta := Delta * Param;
Delta := Delta / (2 * n + 1);
Summa := Summa + Delta
END;
Integral := Summa
END;

BEGIN
{ }
LevelHigh := LN ((1 - P_PO) / P_LO);
LevelLow := LN ((1 - P_LO) / P_PO);
{ }
DeltaLH := LevelHigh / (SizeWay - 1);
DeltaLL := LevelLow / (SizeWay - 1);
{ }
FOR i:=0 TO SizeWay - 1 DO
BEGIN
ArrayLH [i+1] := LevelHigh - i * DeltaLH;
ArrayLL [i+1] := LevelLow - i * DeltaLL
END;
{ }
DeltaLH := Integral ((V_max - V_Waiting) / V_SKO);
DeltaLL := Integral ((V_min - V_Waiting) / V_SKO);
{ }
K1 := WaitingBrightness / (2 * SQR (Pom_SKO));
K12 := LN (ABS ((V_max - V_min) / (V_SKO * (DeltaLH - DeltaLL))));
K13 := -1 / (2 * SQR (V_SKO));
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  д®а¬Ёа®ў ­Ёп ¬®¤Ґ«Ё Ё§®Ўа ¦Ґ­Ёп ®зҐаҐ¤­®Ј® Є ¤а  і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE Screen;
VAR i ,
j ,
k ,
q1 ,
q2 ,
q3 ,
q4 ,
q5 ,
q6 ,
q7 ,
q8 ,
q9 : INTEGER;
ArgumentX ,
ArgumentY ,
FunctionBrightness ,
IntegralBrightness : REAL;

{ Џа®жҐ¤га  ®ЇаҐ¤Ґ«Ґ­Ёп Є®®а¤Ё­ в ®зҐаҐ¤­®Ј® ®вбзҐв  в®© Ё«Ё Ё­®© дг­ЄжЁЁ
паЄ®бвЁ, д®а¬Ёаго饩 Ё§®Ўа ¦Ґ­ЁҐ
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
PROCEDURE Movement (x0, y0, q0, v, vq, dx, dy : REAL;
VAR ArgumentX, ArgumentY : REAL);
VAR q ,
q1 ,
s ,
x1 ,
y1 : REAL;
BEGIN
y1 := TimeBetwenScreen * (ScreenNumber - 1);
s := v * y1;
q1 := vq * y1;
ArgumentY := dy * (j - 1) - LenthY / 2;
ArgumentX := dx * (i - 1) - LenthX / 2;
x1 := SQRT (SQR (ArgumentX) + SQR (ArgumentY));
IF ArgumentX=0
THEN
ArgumentX := 1e-20;
IF ArgumentY=0
THEN
ArgumentY := 1e-20;
q := ARCTAN (ABS (ArgumentX) / ABS (ArgumentY));
IF (ArgumentX > 0) AND (ArgumentY < 0)
THEN
q := PI - q;
IF (ArgumentX < 0) AND (ArgumentY < 0)
THEN
q := PI + q;
IF (ArgumentX < 0) AND (ArgumentY > 0)
THEN
q := 2 * PI - q;
q := q + q1;
ArgumentX := ROUND (x0 +s * SIN (q0) + x1 * SIN (q) + LenthX / 2);
ArgumentY := ROUND (y0 +s * COS (q0) + x1 * COS (q) + LenthY / 2)
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "Ї«®бЄ®бвм"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function1 (a, b, c, x, y : REAL) : REAL;
VAR
c1 : REAL;
BEGIN
c1 := c;
IF a <> 0
THEN
c1 := c1 - x * c / a;
IF b <> 0
THEN
c1 := c1 - y * c / b;
IF c1 > 0
THEN
Function1 := c1
ELSE
Function1 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "гбҐзҐ­­ п Ї«®бЄ®бвм"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function2 (a, b, c, a1, b1, x, y : REAL) : REAL;
VAR
c1 : REAL;
BEGIN
IF y < b1 - x * b1 / a1
THEN BEGIN
c1 := c;
IF a <> 0
THEN
c1 := c1 - x * c / a;
IF b <> 0
THEN
c1 := c1 - y * c / b;
IF c1 > 0
THEN
Function2 := c1
ELSE
Function2 := 0
END
ELSE
Function2 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "¤ў ¦¤л гбҐзҐ­­ п Ї«®бЄ®бвм"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function3 (a, b, c, a1, b1, d, x, y : REAL) : REAL;
VAR
c1 ,
y1 : REAL;
BEGIN
y1 := b1 - x * b1 / a1;
IF (y < y1) AND (y > y1 - d)
THEN BEGIN
c1 := c;
IF a <> 0
THEN
c1 := c1 - x * c / a;
IF b <> 0
THEN
c1 := c1 - y * c / b;
IF c1 > 0
THEN
Function3 := c1
ELSE
Function3 := 0
END
ELSE
Function3 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "н««ЁЇб®Ё¤ ўа йҐ­Ёп"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function4 (a, b, c, x, y : REAL) : REAL;
VAR
c1 : REAL;
BEGIN
IF (ABS (x) < ABS (a)) AND
(ABS (y) < ABS (b - SQRT (1 - SQR (x) / SQR (a))))
THEN BEGIN
c1 := SQR (x) / SQR (a) + SQR (y) / SQR (b);
IF c1 <= 1
THEN
Function4 := c * SQRT (1 - c1)
ELSE
Function4 := 0
END
ELSE
Function4 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "н««ЁЇвЁзҐбЄЁ© жЁ«Ё­¤а"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function5 (a, b, c, x, y : REAL) : REAL;
BEGIN
IF a = 0
THEN
IF ABS (y) < ABS (b)
THEN
Function5 := c * SQRT (1 - SQR (y) / SQR (b))
ELSE
Function5 := 0
ELSE
IF ABS (x) < ABS (a)
THEN
Function5 := c * SQRT (1 - SQR (x) / SQR (a))
ELSE
Function5 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "Ї а Ў®««ЁзҐбЄЁ© жЁ«Ё­¤а"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function6 (a, b, x, y : REAL) : REAL;
BEGIN
IF a * x > 0
THEN
Function6 := SQRT (2 * a * x)
ELSE
IF b * y > 0
THEN
Function6 := SQRT (2 * b * y)
ELSE
Function6 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "®¤­®Ї®«®б­®© ЈЁЇҐаЎ®«®Ё¤"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function7 (a, b, c, x, y : REAL) : REAL;
BEGIN
IF ABS (y) < ABS (b * SQRT (1 + SQR (y) / SQR (c)))
THEN
Function7 := a * SQRT (1 - SQR (y) / SQR (b) + SQR (x) / SQR (c))
ELSE
Function7 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "ЈЁЇҐаЎ®«ЁзҐбЄЁ© Ї а Ў®«®Ё¤"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function8 (a, b, c, x, y : REAL) : REAL;
BEGIN
IF ABS (x) < ABS (a * y / b)
THEN
Function8 := c + SQR (y) / SQR (b) - SQR (x) / SQR (a)
ELSE
Function8 := 0
END;

{ ”г­ЄжЁп паЄ®бвЁ б Ї®ўҐае­®бвмо вЁЇ  "ў®«­Ёбв п Ї®ўҐае­®бвм"
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД}
FUNCTION Function9 (a, c, y : REAL) : REAL;
BEGIN
Function9 := a * COS (y) + c
END;

BEGIN
FOR i := 1 TO LenthX DO
FOR j := 1 TO LenthY DO BEGIN
IntegralBrightness := 0;
q1 := 0;
q2 := 0;
q3 := 0;
q4 := 0;
q5 := 0;
q6 := 0;
q7 := 0;
q8 := 0;
q9 := 0;
FOR k := 1 TO QuantFunction DO BEGIN
CASE ArrayFunction [k] OF
0: FunctionBrightness := 0;
1: BEGIN
INC (q1);
Movement (ArrayDataF1 [q1,1], ArrayDataF1 [q1,2],
ArrayDataF1 [q1,3], ArrayDataF1 [q1,4],
ArrayDataF1 [q1,5], ArrayDataF1 [q1,6],
ArrayDataF1 [q1,7], ArgumentX, ArgumentY);
FunctionBrightness := Function1 (ArrayDataF1 [q1,8],
ArrayDataF1 [q1,9],
ArrayDataF1 [q1,10],
ArgumentX, ArgumentY)
END;
2: BEGIN
INC (q2);
Movement (ArrayDataF2 [q2,1], ArrayDataF2 [q2,2],
ArrayDataF2 [q2,3], ArrayDataF2 [q2,4],
ArrayDataF2 [q2,5], ArrayDataF2 [q2,6],
ArrayDataF2 [q2,7], ArgumentX, ArgumentY);
FunctionBrightness := Function2 (ArrayDataF2 [q2,8],
ArrayDataF2 [q2,9],
ArrayDataF2 [q2,10],
ArrayDataF2 [q2,11],
ArrayDataF2 [q2,12],
ArgumentX, ArgumentY)
END;
3: BEGIN
INC (q3);
Movement (ArrayDataF3 [q3,1], ArrayDataF3 [q3,2],
ArrayDataF3 [q3,3], ArrayDataF3 [q3,4],
ArrayDataF3 [q3,5], ArrayDataF3 [q3,6],
ArrayDataF3 [q3,7], ArgumentX, ArgumentY);
FunctionBrightness := Function3 (ArrayDataF3 [q3,8],
ArrayDataF3 [q3,9],
ArrayDataF3 [q3,10],
ArrayDataF3 [q3,11],
ArrayDataF3 [q3,12],
ArrayDataF3 [q3,13],
ArgumentX, ArgumentY)
END;
4: BEGIN
INC (q4);
Movement (ArrayDataF4 [q4,1], ArrayDataF4 [q4,2],
ArrayDataF4 [q4,3], ArrayDataF4 [q4,4],
ArrayDataF4 [q4,5], ArrayDataF4 [q4,6],
ArrayDataF4 [q4,7], ArgumentX, ArgumentY);
FunctionBrightness := Function4 (ArrayDataF4 [q4,8],
ArrayDataF4 [q4,9],
ArrayDataF4 [q4,10],
ArgumentX, ArgumentY)
END;
5: BEGIN
INC (q5);
Movement (ArrayDataF5 [q5,1], ArrayDataF5 [q5,2],
ArrayDataF5 [q5,3], ArrayDataF5 [q5,4],
ArrayDataF5 [q5,5], ArrayDataF5 [q5,6],
ArrayDataF5 [q5,7], ArgumentX, ArgumentY);
FunctionBrightness := Function5 (ArrayDataF5 [q5,8],
ArrayDataF5 [q5,9],
ArrayDataF5 [q5,10],
ArgumentX, ArgumentY)
END;
6: BEGIN
INC (q6);
Movement (ArrayDataF6 [q6,1], ArrayDataF6 [q6,2],
ArrayDataF6 [q6,3], ArrayDataF6 [q6,4],
ArrayDataF6 [q6,5], ArrayDataF6 [q6,6],
ArrayDataF6 [q6,7], ArgumentX, ArgumentY);
FunctionBrightness := Function6(ArrayDataF6 [q6,8],
ArrayDataF6 [q6,9],
ArgumentX, ArgumentY)
END;
7: BEGIN
INC (q7);
Movement (ArrayDataF7 [q7,1], ArrayDataF7 [q7,2],
ArrayDataF7 [q7,3], ArrayDataF7 [q7,4],
ArrayDataF7 [q7,5], ArrayDataF7 [q7,6],
ArrayDataF7 [q7,7], ArgumentX, ArgumentY);
FunctionBrightness := Function7 (ArrayDataF7 [q7,8],
ArrayDataF7 [q7,9],
ArrayDataF7 [q7,10],
ArgumentX, ArgumentY)
END;
8: BEGIN
INC (q8);
Movement(ArrayDataF8 [q8,1], ArrayDataF8 [q8,2],
ArrayDataF8 [q8,3], ArrayDataF8 [q8,4],
ArrayDataF8 [q8,5], ArrayDataF8 [q8,6],
ArrayDataF8 [q8,7], ArgumentX, ArgumentY);
FunctionBrightness := Function8 (ArrayDataF8 [q8,8],
ArrayDataF8 [q8,9],
ArrayDataF8 [q8,10],
ArgumentX, ArgumentY)
END;
9: BEGIN
INC (q9);
Movement (ArrayDataF9 [q9,1], ArrayDataF9 [q9,2],
ArrayDataF9 [q9,3], ArrayDataF9 [q9,4],
ArrayDataF9 [q9,5], ArrayDataF9 [q9,6],
ArrayDataF9 [q9,7], ArgumentX, ArgumentY);
FunctionBrightness := Function9 (ArrayDataF9 [q9,8],
ArrayDataF9 [q9,9],
ArgumentY)
END
END;
IF PriznSumBrightness
THEN
IntegralBrightness := IntegralBrightness + FunctionBrightness
ELSE
IF PriznPrioritet
THEN BEGIN
IF FunctionBrightness > 0
THEN
IntegralBrightness := FunctionBrightness
END
ELSE
IF FunctionBrightness > IntegralBrightness
THEN
IntegralBrightness := FunctionBrightness
END;
IF PriznPom
THEN
IntegralBrightness := IntegralBrightness + RealPom_Waiting +
RealPom_SKO * FunctionRandom;
IF KeyArrayBrightness
THEN
ArrayBrightness [1,i,j] := IntegralBrightness
ELSE
ArrayBrightness [2,i,j] := IntegralBrightness;
IF PriznMaxBrightness AND (IntegralBrightness > MaxBrightness)
THEN
MaxBrightness := IntegralBrightness
END;
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  ўў®¤  Ї а ¬Ґва®ў дг­ЄжЁ©, гз бвўгойЁе ў ¬®¤Ґ«Ёа®ў ­ЁЁ і
і Ё§®Ўа ¦Ґ­Ёп і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE InputArrayData;
VAR
i ,
q1 ,
q2 ,
q3 ,
q4 ,
q5 ,
q6 ,
q7 ,
q8 ,
q9 : INTEGER;
BEGIN
CLRSCR;
PriznPrioritet := FALSE;
PriznSumBrightness := FALSE;
WRITELN ('‚ўҐ¤ЁвҐ бЇ®б®Ў д®а¬Ёа®ў ­Ёп Ё§®Ўа ¦Ґ­Ёп');
WRITE ('/1 -  ¤¤ЁвЁў­®, 2 - Ї® ЇаЁ®аЁвҐвг, Ё­ зҐ - Ї® ¬ ЄбЁ¬г¬г/:');
READLN (i);
IF i = 1
THEN
PriznSumBrightness := TRUE;
IF i = 2
THEN
PriznPrioritet := TRUE;
WRITE ('—Ёб«® дг­ЄжЁ©, ¬®¤Ґ«ЁагойЁе Ё§®Ўа ¦Ґ­ЁҐ (1-9) = ');
READLN (QuantFunction);
FOR i := 1 TO QuantFunction DO BEGIN
WRITE ('‚ўҐ¤ЁвҐ ­®¬Ґа ', i ,'-© дг­ЄжЁЁ: ');
READLN (ArrayFunction [i])
END;
{ ‚ў®¤ Ї а ¬Ґва®ў дг­ЄжЁ©, гз бвўгойЁе ў ¬®¤Ґ«Ёа®ў ­ЁЁ Ё§®Ўа ¦Ґ­Ёп }
q1 := 0;
q2 := 0;
q3 := 0;
q4 := 0;
q5 := 0;
q6 := 0;
q7 := 0;
q8 := 0;
q9 := 0;
FOR i := 1 TO QuantFunction DO BEGIN
CLRSCR;
WRITE ('‚ў®¤ Ї а ¬Ґва®ў ¤«п дг­ЄжЁЁ вЁЇ  ');
CASE ArrayFunction [i] OF
1: BEGIN
WRITELN ('"Ї«®бЄ®бвм":');
INC (q1)
END;
2: BEGIN
WRITELN ('"гбҐзҐ­­ п Ї«®бЄ®бвм":');
INC (q2)
END;
3: BEGIN
WRITELN ('"¤ў ¦¤л гбҐзҐ­­ п Ї«®бЄ®бвм":');
INC (q3)
END;
4: BEGIN
WRITELN ('"н««ЁЇб®Ё¤ ўа йҐ­Ёп":');
INC (q4)
END;
5: BEGIN
WRITELN ('"н««ЁЇвЁзҐбЄЁ© жЁ«Ё­¤а":');
WRITELN ('‚­Ё¬ ­ЁҐ! Ћ¤­  Ё§ Ї®«г®бҐ© (­  ®бЁ 0X Ё«Ё ­  ®бЁ ' +
'0Y) ¤®«¦­  Ўлвм а ў­  0.');
INC (q5)
END;
6: BEGIN
WRITELN ('"Ї а Ў®««ЁзҐбЄЁ© жЁ«Ё­¤а":');
WRITELN ('‚­Ё¬ ­ЁҐ! Ћ¤­  Ё§ б®бв ў«пойЁе ¤®«¦­  Ўлвм а ў­  0.');
INC (q6)
END;
7: BEGIN
WRITELN ('"®¤­®Ї®«®б­®© ЈЁЇҐаЎ®«®Ё¤":');
INC (q7)
END;
8: BEGIN
WRITELN ('"¤ўгЇ®«®б­®© ЈЁЇҐаЎ®«®Ё¤":');
INC (q8)
END;
9: BEGIN
WRITELN ('"ў®«­Ёбв п Ї®ўҐае­®бвм":');
INC (q9)
END;
END;
WRITELN;
{ ‚ў®¤ ᬥ饭Ёп бв®а®­л бҐвз вЄЁ, Ї а ««Ґ«м­®© ®бЁ 0Y }
WRITE ('‘¬ҐйҐ­ЁҐ бв®а®­л бҐвз вЄЁ, Ї а ««Ґ«м­®© ®бЁ 0Y = ');
CASE ArrayFunction [i] OF
1: READLN (ArrayDataF1 [q1,1]);
2: READLN (ArrayDataF2 [q2,1]);
3: READLN (ArrayDataF3 [q3,1]);
4: READLN (ArrayDataF4 [q4,1]);
5: READLN (ArrayDataF5 [q5,1]);
6: READLN (ArrayDataF6 [q6,1]);
7: READLN (ArrayDataF7 [q7,1]);
8: READLN (ArrayDataF8 [q8,1]);
9: READLN (ArrayDataF9 [q9,1])
END;
{ ‚ў®¤ ᬥ饭Ёп бв®а®­л бҐвз вЄЁ, Ї а ««Ґ«м­®© ®бЁ 0X }
WRITE ('‘¬ҐйҐ­ЁҐ бв®а®­л бҐвз вЄЁ, Ї а ««Ґ«м­®© ®бЁ 0X = ');
CASE ArrayFunction [i] OF
1: READLN (ArrayDataF1 [q1,2]);
2: READLN (ArrayDataF2 [q2,2]);
3: READLN (ArrayDataF3 [q3,2]);
4: READLN (ArrayDataF4 [q4,2]);
5: READLN (ArrayDataF5 [q5,2]);
6: READLN (ArrayDataF6 [q6,2]);
7: READLN (ArrayDataF7 [q7,2]);
8: READLN (ArrayDataF8 [q8,2]);
9: READLN (ArrayDataF9 [q9,2])
END;
{ ‚ў®¤ гЈ«  ¬Ґ¦¤г ­ Їа ў«Ґ­ЁҐ¬ ¤ўЁ¦Ґ­Ёп бҐвз вЄЁ Ё ®бмо +0Y }
WRITE ('“Ј®« ¬Ґ¦¤г ­ Їа ў«Ґ­ЁҐ¬ ¤ўЁ¦Ґ­Ёп бҐвз вЄЁ Ё 0Y = ');
CASE ArrayFunction [i] OF
1: READLN (ArrayDataF1 [q1,3]);
2: READLN (ArrayDataF2 [q2,3]);
3: READLN (ArrayDataF3 [q3,3]);
4: READLN (ArrayDataF4 [q4,3]);
5: READLN (ArrayDataF5 [q5,3]);
6: READLN (ArrayDataF6 [q6,3]);
7: READLN (ArrayDataF7 [q7,3]);
8: READLN (ArrayDataF8 [q8,3]);
9: READLN (ArrayDataF9 [q9,3])
END;
{ ‚ў®¤ бЄ®а®бвЁ Їаאַ«-Ј® а ў­®¬-Ј® ¤ўЁ¦Ґ­Ёп бҐвз вЄЁ }
WRITE ('‘Є®а®бвм ¤ўЁ¦Ґ­Ёп бҐвз вЄЁ = ');
CASE ArrayFunction [i] OF
1: READLN (ArrayDataF1 [q1,4]);
2: READLN (ArrayDataF2 [q2,4]);
3: READLN (ArrayDataF3 [q3,4]);
4: READLN (ArrayDataF4 [q4,4]);
5: READLN (ArrayDataF5 [q5,4]);
6: READLN (ArrayDataF6 [q6,4]);
7: READLN (ArrayDataF7 [q7,4]);
8: READLN (ArrayDataF8 [q8,4]);
9: READLN (ArrayDataF9 [q9,4])
END;
{ ‚ў®¤ гЈ«®ў®© бЄ®а®бвЁ ўа йҐ­Ёп бҐвз вЄЁ ®в­®бЁвҐ«м­® б®Ўб⢥­­®Ј® 業ва  }
WRITE ('“Ј«®ў п бЄ®а®бвм ўа йҐ­Ёп бҐвз вЄЁ = ');
CASE ArrayFunction [i] OF
1: READLN (ArrayDataF1 [q1,5]);
2: READLN (ArrayDataF2 [q2,5]);
3: READLN (ArrayDataF3 [q3,5]);
4: READLN (ArrayDataF4 [q4,5]);
5: READLN (ArrayDataF5 [q5,5]);
6: READLN (ArrayDataF6 [q6,5]);
7: READLN (ArrayDataF7 [q7,5]);
8: READLN (ArrayDataF8 [q8,5]);
9: READLN (ArrayDataF9 [q9,5])
END;
{ ‚ў®¤ Ё­вҐаў «  ¤ЁбЄаҐвЁ§ жЁЁ  аЈг¬Ґ­в®ў дг­ЄжЁ© паЄ®бвЁ ЇаЁ
ЇҐаҐе®¤Ґ ®в п祩ЄЁ Є п祩ЄҐ ­  ®бЁ 0X }
WRITE ( '€­вҐаў « ¤ЁбЄаҐвЁ§ жЁЁ ­  ®бЁ 0X = ' );
CASE ArrayFunction [i] OF
1: READLN ( ArrayDataF1 [q1, 6] );
2: READLN ( ArrayDataF2 [q2, 6] );
3: READLN ( ArrayDataF3 [q3, 6] );
4: READLN ( ArrayDataF4 [q4, 6] );
5: READLN ( ArrayDataF5 [q5, 6] );
6: READLN ( ArrayDataF6 [q6, 6] );
7: READLN ( ArrayDataF7 [q7, 6] );
8: READLN ( ArrayDataF8 [q8, 6] );
9: READLN ( ArrayDataF9 [q9, 6] )
END;
{ ‚ў®¤ Ё­вҐаў «  ¤ЁбЄаҐвЁ§ жЁЁ  ®Јг¬Ґ­в®ў дг­ЄжЁ© паЄ®бвЁ ЇаЁ
ЇҐаҐе®¤Ґ ®в п祩ЄЁ Є п祩ЄҐ ­  ®бЁ 0Y }
WRITE ( '€­вҐаў « ¤ЁбЄаҐвЁ§ жЁЁ ­  ®бЁ 0Y = ' );
CASE ArrayFunction [i] OF
1: READLN ( ArrayDataF1 [q1, 7] );
2: READLN ( ArrayDataF2 [q2, 7] );
3: READLN ( ArrayDataF3 [q3, 7] );
4: READLN ( ArrayDataF4 [q4, 7] );
5: READLN ( ArrayDataF5 [q5, 7] );
6: READLN ( ArrayDataF6 [q6, 7] );
7: READLN ( ArrayDataF7 [q7, 7] );
8: READLN ( ArrayDataF8 [q8, 7] );
9: READLN ( ArrayDataF9 [q9, 7] )
END;
{ ‚ў®¤ ¤®Ї®«­ЁвҐ«м­ле Ї а ¬Ґва®ў дг­ЄжЁЁ паЄ®бвЁ вЁЇ ... }
CASE ArrayFunction [i] OF
{ Ї«®бЄ®бвм }
1: BEGIN
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп б 0X = ');
READLN ( ArrayDataF1 [q1, 8] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп б 0Y = ');
READLN ( ArrayDataF1 [q1, 9] );
WRITE ('џаЄ®бвм ў в®зЄҐ 0,0 = ');
READLN ( ArrayDataF1 [q1, 10] )
END;
{ гбҐзҐ­­ п Ї«®бЄ®бвм }
2: BEGIN
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп б 0X = ');
READLN ( ArrayDataF2 [q2, 8] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп б 0Y = ');
READLN ( ArrayDataF2 [q2, 9] );
WRITE ('џаЄ®бвм ў в®зЄҐ 0,0 = ');
READLN ( ArrayDataF2 [q2, 10] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп гᥪ о饩 Ї«®бЄ®бвЁ б 0X = ');
READLN ( ArrayDataF2 [q2, 11] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп гᥪ о饩 Ї«®бЄ®бвЁ б 0Y = ');
READLN ( ArrayDataF2 [q2, 12] )
END;
{ ¤ў ¦¤л гбҐзҐ­­ п Ї«®бЄ®бвм }
3: BEGIN
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп б 0X = ');
READLN ( ArrayDataF3 [q3, 8] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп б 0Y = ');
READLN ( ArrayDataF3 [q3, 9] );
WRITE ('џаЄ®бвм ў в®зЄҐ 0,0 = ');
READLN ( ArrayDataF3 [q3, 10] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп гᥪ о饩 Ї«®бЄ®бвЁ б 0X = ');
READLN ( ArrayDataF3 [q3, 11] );
WRITE ('’®зЄ  ЇҐаҐбҐзҐ­Ёп гᥪ о饩 Ї«®бЄ®бвЁ б 0Y = ');
READLN ( ArrayDataF3 [q3, 12] );
WRITE ('ЁаЁ­  ¤ў ¦¤л гбҐзҐ­­®© Ї«®бЄ®бвЁ = ');
READLN ( ArrayDataF3 [q3, 13] )
END;
{ н««ЁЇб®Ё¤ ўа йҐ­Ёп }
4: BEGIN
WRITE ('Џ®«г®бм н«ЁЇб®Ё¤  ўа йҐ­Ёп ­  ®бЁ 0X = ');
READLN ( ArrayDataF4 [q4, 8] );
WRITE ('Џ®«г®бм н«ЁЇб®Ё¤  ўа йҐ­Ёп ­  ®бЁ 0Y = ');
READLN ( ArrayDataF4 [q4, 9] );
WRITE ('Џ®«г®бм н«ЁЇб®Ё¤  ўа йҐ­Ёп ­  ®бЁ паЄ®бвЁ = ');
READLN ( ArrayDataF4 [q4, 10] );
END;
{ н««ЁЇвЁзҐбЄЁ© жЁ«Ё­¤а }
5: BEGIN
WRITE ('Џ®«г®бм н«ЁЇб®Ё¤  ўа йҐ­Ёп ­  ®бЁ 0X = ');
READLN ( ArrayDataF5 [q5, 8] );
WRITE ('Џ®«г®бм н«ЁЇб®Ё¤  ўа йҐ­Ёп ­  ®бЁ 0Y = ');
READLN ( ArrayDataF5 [q5, 9] );
WRITE ('Џ®«г®бм н«ЁЇб®Ё¤  ўа йҐ­Ёп ­  ®бЁ паЄ®бвЁ = ');
READLN ( ArrayDataF5 [q5, 10] );
END;
{ Ї а Ў®««ЁзҐбЄЁ© жЁ«Ё­¤а }
6: BEGIN
WRITE ('‘®бв ў«пой п ­  ®бЁ 0X = ');
READLN ( ArrayDataF6 [q6, 8] );
WRITE ('‘®бв ў«пой п ­  ®бЁ 0Y = ');
READLN ( ArrayDataF6 [q6, 9] );
END;
{ ®¤­®Ї®«®б­®© ЈЁЇҐаЎ®«®Ё¤ }
7: BEGIN
WRITE ('Џ а ¬Ґва 1 = ');
READLN ( ArrayDataF7 [q7, 8] );
WRITE ('Џ а ¬Ґва 2 = ');
READLN ( ArrayDataF7 [q7, 9] );
WRITE ('Џ а ¬Ґва 3 = ');
READLN ( ArrayDataF7 [q7, 10] )
END;
{ ¤ўгЇ®«®б­®© ЈЁЇҐаЎ®«®Ё¤ }
8: BEGIN
WRITE ('Џ а ¬Ґва 1 = ');
READLN ( ArrayDataF8 [q8, 8] );
WRITE ('Џ а ¬Ґва 2 = ');
READLN ( ArrayDataF8 [q8, 9] );
WRITE ('Џ а ¬Ґва 3 = ');
READLN ( ArrayDataF8 [q8, 10] )
END;
{ ў®«­Ёбв п Ї®ўҐае­®бвм }
9: BEGIN
WRITE ('Џ а ¬Ґва 1 = ');
READLN ( ArrayDataF9 [q9, 8] );
WRITE ('Џ а ¬Ґва 2 = ');
READLN ( ArrayDataF9 [q9, 9] );
END
END
END
END;

{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  § ¤ ­Ёп ­ з «м­ле §­ зҐ­Ё© і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE Determination;
VAR
i,
j : INTEGER;
BEGIN
KeyArrayBrightness := true;
FOR i := 1 TO LenthX DO
FOR j := 1 TO LenthY DO BEGIN
ArrayBrightness [1,i,j] := 0;
ArrayBrightness [2,i,j] := 0;
ArraySubBrightness [i,j] := 0
END;
ScreenNumber := 1;
QuantFindObj := 0;
SumLenthObj := 0;
QuantFindPom := 0;
SumLenthPom := 0;
NumberImitObj := -1;
MemDBegin := NIL;
MemVBegin := NIL
END;
{ЪДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДї
і Џа®жҐ¤га  ®ЇаҐ¤Ґ«Ґ­Ёп ¬ ббЁў  ­ Їа ў«Ґ­Ё© і
АДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДЩ}
PROCEDURE InitArrayWays;
BEGIN
ArrayWays [1,1] := 0;
ArrayWays [1,2] := 1;
ArrayWays [2,1] := 1;
ArrayWays [2,2] := 1;
ArrayWays [3,1] := 1;
ArrayWays [3,2] := 0;
ArrayWays [4,1] := 1;
ArrayWays [4,2] := -1;
ArrayWays [5,1] := 0;
ArrayWays [5,2] := -1;
ArrayWays [6,1] := -1;
ArrayWays [6,2] := -1;
ArrayWays [7,1] := -1;
ArrayWays [7,2] := 0;
ArrayWays [8,1] := -1;
ArrayWays [8,2] := 1;
END;

{ЪДДДДДДДДДДДДДДДДДДДДї
і Ћб­®ў­ п Їа®Ја ¬¬  і
АДДДДДДДДДДДДДДДДДДДДЩ}
BEGIN
RANDOMIZE;
CLRSCR;
WRITE ('ђҐ¦Ё¬ а Ў®вл (1 - а бЇ®§­®ў ­ЁҐ, 0 - ¬®¤Ґ«Ёа®ў ­ЁҐ Ё§®Ўа ¦Ґ­Ёп): ');
READLN (InputBoolean);
IF InputBoolean = 1
THEN
PriznFind := TRUE
ELSE
PriznFind := FALSE;
{ ‚ў®¤ Ї а ¬Ґва®ў ¤«п а Ў®вл Їа®жҐбб  а бЇ®§­®ў ­Ёп }
IF PriznFind
THEN BEGIN
CLRSCR;
WRITELN ('‚ўҐ¤ЁвҐ а §¬Ґа ўлЎ®аЄЁ ¤«п а бЇ®§­ ў ­Ёп ®ЎкҐЄв  (楫®Ґ, ' +
'­Ґ Ў®«миҐ ', Max, '):');
WRITE ('SizeWay = ');
READLN (SizeWay);
WRITE ('SizeWayMax = ');
READLN (SizeWayMax);
IF (SizeWay <> SizeWayMax) OR (SizeWay = 0)
THEN BEGIN
WRITE ('’ЁЇ  «Ј®аЁв¬  (1 - гбҐзҐ­­л©, Ё­ зҐ - Ї®«­л©  «Ј®аЁв¬): ');
READLN (InputBoolean);
IF InputBoolean = 1
THEN
AlgSmall := TRUE
END;
WRITE ('‚Ґа®пв­®бвм «®¦­®Ј® ®Ў­ а㦥­Ёп ®ЎкҐЄв  (®в 0 ¤® 1) = ');
READLN (P_LO);
WRITE ('‚Ґа®пв­®бвм Ї®вҐаЁ ®ЎкҐЄв  (®в 0 ¤® 1) = ');
READLN (P_PO);
WRITE ('ЏаҐ¤Ї®« Ј Ґ¬ п паЄ®бвм ®ЎкҐЄв  = ');
READLN (WaitingBrightness);
WRITE ('ЏаҐ¤Ї®« Ј.б।­ҐЄў ¤а вЁзҐбЄ®Ґ ®вЄ«®­Ґ­ЁҐ  ¬Ї«Ёвг¤л Ї®¬Ґе = ');
READLN ( Pom_SKO );
WRITE ('Џ®а®Ј паЄ®бвЁ ®ЎкҐЄв  = ');
READLN (VolumeBrightness)
END;

{ ‚ў®¤ Ї а ¬Ґва®ў Ї®«п ­ Ў«о¤Ґ­Ёп Ё Є®«ЁзҐбвў  Є ¤а®ў }
CLRSCR;
WRITELN (' ‚ўҐ¤ЁвҐ а §¬Ґа­®бвм Ї®«п ­ Ў«о¤Ґ­Ёп (­Ґ Ў«миҐ, 祬 ', Max,
' x ', Max, '):');
WRITE ('1. Љ®«ЁзҐбвў® п祥Є Ї® Ј®аЁ§®­в «Ё (®бм 0X) = ');
READLN (LenthX);
WRITE ('2. Љ®«ЁзҐбвў® п祥Є Ї® ўҐавЁЄ «Ё (®бм 0Y) = ');
READLN (LenthY);
IF PriznFind
THEN BEGIN
WRITELN (' ‚ўҐ¤ЁвҐ Ја ­Ёжл ў­гв७­ҐЈ® Ї®«п ­ Ў«о¤Ґ­Ёп:');
WRITE ('1. ЌЁ¦­пп Ја ­Ёж  Ї® ®бЁ 0X = ');
READLN (GranMinX);
WRITE ('2. ‚Ґае­пп Ја ­Ёж  Ї® ®бЁ 0X = ');
READLN (GranMaxX);
WRITE ('3. ЌЁ¦­пп Ја ­Ёж  Ї® ®бЁ 0Y = ');
READLN (GranMinY);
WRITE ('4. ‚Ґае­пп Ја ­Ёж  Ї® ®бЁ 0Y = ');
READLN (GranMaxY)
END;
WRITE ('Њ ЄбЁ¬ «м­ п паЄ®бвм = ');
READLN (MaxBrightness);
IF MaxBrightness = 0
THEN
PriznMaxBrightness := TRUE
ELSE
PriznMaxBrightness := FALSE;
WRITE ('Њ ЄбЁ¬ «м­®Ґ зЁб«® ¬®¤Ґ«Ёа㥬ле Є ¤а®ў = ');
READLN (MaxQuantScreen);

{ § ¤ ­ЁҐ Ё­вҐаў «  ўаҐ¬Ґ­Ё ¬Ґ¦«г б®бҐ¤­Ё¬Ё Є ¤а ¬Ё }
TimeBetwenScreen := 1;

{ ўў®¤ Ї а ¬Ґва®ў Ї®¬Ґе: PriznPom, RealPom_SKO Ё RealPom_Waiting }
CLRSCR;
WRITE ('Ќ «ЁзЁҐ Ї®¬Ґе (1 - ўў®¤пвбп; 0-®вбгвбвўгов):');
READLN (InputBoolean);
IF InputBoolean = 1
THEN BEGIN
PriznPom := TRUE;
WRITELN;
WRITELN (' ’®Ј¤  ўўҐ¤ЁвҐ Ї а ¬Ґвал Ї®¬Ґе:');
WRITE ('1. ‘।­ҐЄў ¤а вЁзҐбЄ®Ґ ®вЄ«®­Ґ­ЁҐ  ¬Ї«Ёвг¤л Ї®¬Ґе = ');
READLN (RealPom_SKO);
WRITE ('2. Њ вҐ¬ вЁзҐбЄ®Ґ ®¦Ё¤ ­ЁҐ  ¬Ї«Ёвг¤л Ї®¬Ґе = ');
READLN (RealPom_Waiting)
END
ELSE
PriznPom := FALSE;

{ ‚ў®¤ Ї а ¬Ґва®ў ®ЎкҐЄв  }
CLRSCR;
WRITE ('ђҐ¦Ё¬ ўў®¤  (1 - д ©«, Ё­ зҐ - Є« ўЁ вга ): ');
READLN (InputBoolean);
IF InputBoolean = 1
THEN BEGIN
ASSIGN (ReadFile,'D:\TP\GAS\PAS\Pkv_dipl.f1');
RESET (ReadFile);
READLN (ReadFile,V_max);
READLN (ReadFile,V_min);
READLN (ReadFile,V_SKO);
READLN (ReadFile,V_Waiting);
READLN (ReadFile,FirstX);
READLN (ReadFile,FirstY);
READLN (ReadFile,AlfaMin);
READLN (ReadFile,AlfaMax);
READLN (ReadFile,Lenth_MO);
READLN (ReadFile,Lenth_SKO);
READLN (ReadFile,PointBrightness);
READLN (ReadFile,VolumePomMO);
READLN (ReadFile,VolumePomSKO);
CLOSE (ReadFile)
END
ELSE BEGIN
WRITELN ('‚ўҐ¤ЁвҐ бЄ®а®бв­лҐ Ї®Є § вҐ«Ё ¤ўЁ¦Ґ­Ёп в®зҐз­®Ј® ®ЎкҐЄв :');
WRITE ('Њ ЄбЁ¬ «м­ п бЄ®а®бвм = ');
READLN (V_max);
WRITE ('ЊЁ­Ё¬ «м­ п бЄ®а®бвм = ');
READLN (V_min);
WRITE ('‘।­ҐЄў ¤а вЁзҐбЄ®Ґ ®вЄ«®­Ґ­ЁҐ бЄ®а®бвЁ = ');
READLN (V_SKO);
WRITE ('Њ вҐ¬ вЁзҐбЄ®Ґ ®¦Ё¤ ­ЁҐ бЄ®а®бвЁ = ');
READLN (V_Waiting);
WRITE ('­ з «® ва ҐЄв®аЁЁ ­  ®бЁ 0X = ');
READLN (FirstX);
WRITE ('­ з «® ва ҐЄв®аЁЁ ­  ®бЁ 0Y = ');
READLN (FirstY);
WRITE ('ЊЁ­Ё¬ «м­л© гЈ®« = ');
READLN (AlfaMin);
WRITE ('Њ ЄбЁ¬ «м­л© гЈ®« = ');
READLN (AlfaMax);
WRITE ('Њ вҐ¬ вЁзҐбЄ®Ґ ®¦Ё¤ ­ЁҐ ¤«Ё­л ва ҐЄв®аЁЁ = ');
READLN ( Lenth_MO );
WRITE ('‘।­ҐЄў ¤а вЁзҐбЄ®Ґ ®вЄ«®­Ґ­ЁҐ ¤«Ё­л ва ҐЄв®аЁЁ = ');
READLN ( Lenth_SKO );
WRITE ('џаЄ®бвм ®ЎкҐЄв  = ');
READLN ( PointBrightness );
WRITELN ('‚ў®¤ Ї а ¬Ґва®ў Ї®¬Ґе, ЁбЄ ¦ ойЁе а §­®бв­®Ґ Ё§®Ўа ¦Ґ­ЁҐ:');
WRITE ('Њ вҐ¬ вЁзҐбЄ®Ґ ®¦Ё¤ ­ЁҐ = ');
READLN (VolumePomMO);
WRITE ('‘।­ҐЄў ¤а вЁзҐбЄ®Ґ ®вЄ«®­Ґ­ЁҐ = ');
READLN (VolumePomSKO)
END;

CLRSCR;
WRITELN ('‚ўҐ¤ЁвҐ Ї®а®Ј®ў®Ґ §­ зҐ­ЁҐ паЄ®бвЁ ЇаЁ');
WRITE ('®бгйҐбвў«Ґ­ЁЁ ®ЇҐа жЁЁ "ўаҐ¬Ґ­­®Ј® ¤ЁддҐаҐ­жЁа®ў ­Ёп": ');
READLN (MinSubBrightness);

IF PriznFind
THEN BEGIN
{ ђ бзҐв Є®нддЁжЁҐ­в®ў }
Coefficient;
{ ЋЇаҐ¤Ґ«Ґ­ЁҐ ¬ ббЁў  ­ Їа ў«Ґ­Ё© }
InitArrayWays
END;

InputArrayData;
InitGraphMode;
FOR MemoryTime := 2 TO 2 DO BEGIN
Determination;
WHILE NOT (ScreenNumber > MaxQuantScreen) DO BEGIN
Screen;
PointMovement;
SubBrightness;
IF PriznOutScreen
THEN
OutScreen;
IF PriznFind
THEN
Find;
INC (ScreenNumber);
KeyArrayBrightness := NOT (KeyArrayBrightness);
READLN
END
END;
IF PriznOutScreen
THEN
CloseGraph
END.
Соседние файлы в папке PAS