program go_hamster;
uses crt;

{ Implement come back }
{ Implement death on trace cross }
{ Implement  }

const
      GameFieldH = 33; { 33 }
      GameFieldW = 40; { 40 }
      CellSize = 2;
      BorderSize = 1;
      ScreenW = GameFieldW * CellSize + BorderSize * 2; { 82 }
      FieldHeight = ScreenW - 3; {wtf? why? maybe later}
      MinScreenH = FieldHeight;
      WidthCoefficient = 2;
      MinScreenW = ScreenW * WidthCoefficient; 
      InterfaceBarH = ScreenW - GameFieldH * CellSize - BorderSize * 2; { 14 }
      FieldBorder = '#';
      HamsterSymbol = '*';
      DelaySizeMs = 100;
      EscCode = 27;
      CtrlCCode = 3;
      ArrowLeftOrd = -75;
      ArrowRightOrd = -77;
      ArrowDownOrd = -80;
      ArrowUpOrd = -72;

type
    character = record
        curX, curY, dX, dY: integer;
    end;

function IsTerminalValid: boolean;
begin
    IsTerminalValid := 
        (ScreenWidth >= MinScreenW) and (ScreenHeight >= MinScreenH)
end;

procedure PrintTerminalHelp;
begin
    writeln('Increase your terminal size and try again.');
    if ScreenWidth < MinScreenW then
    begin
        writeln('Your terminal width: ', ScreenWidth,
                '. Required: ', MinScreenW, '.')
    end;
    if ScreenHeight < MinScreenH then
    begin
        writeln('Your terminal height: ', ScreenHeight,
                '. Required: ', MinScreenH, '.')
    end
end;

procedure GetKey(var keyCode: integer);
var 
    c: char;
begin
    c := ReadKey;
    if c = #0 then
    begin
        c := ReadKey;
        keyCode := -ord(c)
    end
    else
    begin
        keyCode := ord(c)
    end
end;

procedure DrawLineX(x, y, len: integer);
var
    i: integer;
begin
    GotoXY(x, y);
    for i := 1 to len do
        write(FieldBorder);
    GotoXY(1, 1)
end;

procedure DrawLineY(x, y, len: integer);
var
    i: integer;
begin
    for i := 1 to len do
    begin
        GotoXY(x, y + i - 1);
        write(FieldBorder)
    end;
    GotoXY(1, 1)
end;

procedure DrawRectangle(x0, y0, h, w: integer);
var
    i: integer;
begin
    clrscr;
    DrawLineX(x0, y0, w);
    for i := 1 to h - 2 do
    begin
        GotoXY(x0, y0 + i);
        write(FieldBorder);
        GotoXY(x0 + w - 1, y0 + i);
        write(FieldBorder)
    end;
    DrawLineX(x0, y0 + h - 1, w);
    GotoXY(1, 1)
end;

procedure DrawInterface;
var
    cellW: integer = ScreenW div 3;
begin
    DrawLineX(1, InterfaceBarH, ScreenW * WidthCoefficient);
    DrawLineY(cellW * WidthCoefficient, 1, InterfaceBarH);
    DrawLineY(cellW * 2 * WidthCoefficient + 1, 1, InterfaceBarH)
end;

procedure DrawArena(ScreenW, FieldHeight: integer);
begin
    DrawRectangle(1, 1, FieldHeight, ScreenW * WidthCoefficient);
    DrawInterface
end;

function Clamp(val, min, max: integer): integer;
begin
    Clamp := val;
    if val < min then
        Clamp := min;
    if val > max then
        Clamp := max
end;

procedure DrawCell(fieldX, fieldY: integer);
var
    i: integer;
begin
    GotoXY(fieldX, fieldY);
    for i := 1 to CellSize * WidthCoefficient  do
        write(HamsterSymbol);
    GotoXY(fieldX, fieldY + 1);
    for i := 1 to CellSize * WidthCoefficient  do
        write(HamsterSymbol)
end;

procedure DrawHamster(var hamster: character);
var
    fieldX, fieldY: integer;
begin
    hamster.curX := Clamp(hamster.curX, 1, GameFieldW + 1);
    hamster.curY := Clamp(hamster.curY, 1, GameFieldH);
    fieldX := 1 + (hamster.curX - 1) * CellSize * WidthCoefficient;
    fieldY := InterfaceBarH + (hamster.curY - 1) * CellSize;
    DrawCell(fieldX, fieldY)
end;

procedure UpdateDelta(keyCode: integer; var hamster: character);
begin
    case keyCode of
        ArrowLeftOrd:
        begin
            hamster.dX := -1;
            hamster.dY := 0
        end;
        ArrowRightOrd:
        begin
            hamster.dX := 1;
            hamster.dY := 0
        end;
        ArrowUpOrd:
        begin
            hamster.dX := 0;
            hamster.dY := -1
        end;
        ArrowDownOrd:
        begin
            hamster.dX := 0;
            hamster.dY := 1
        end
    end
end;

{
procedure ShowHamster(var hamster: character);
begin
    GotoXY()
end;
}

var
    keyCode: integer;
    hamster: character;
begin
    if not IsTerminalValid then
    begin
        PrintTerminalHelp;
        exit
    end;
    hamster.curX := 1;
    hamster.curY := 1;
    DrawArena(ScreenW, FieldHeight);
    while true do
    begin
        delay(DelaySizeMs);
        if keypressed then
        begin
            GetKey(keyCode);
            { writeln(keyCode); }
            if (keyCode = ArrowLeftOrd) or (keyCode = ArrowRightOrd) or
                (keyCode = ArrowUpOrd) or (keyCode = ArrowDownOrd) then
            begin
                UpdateDelta(keyCode, hamster)
            end;
            if (keyCode = EscCode) or (keyCode = CtrlCCode) then
                break
        end;
        DrawHamster(hamster);
        {
        if (hamster.curX <> 1) and (hamster.curY <> GameFieldW) and
            (hamster.curY <> 1) and (hamster.curY <> GameFieldH) then
        begin
            DrawHamster(hamster)
        end;
        }
        hamster.curX := hamster.curX + hamster.dX;
        hamster.curY := hamster.curY + hamster.dY
    end
end.