unit GameUtilityUnit;

{$mode objfpc}{$H+}


interface

uses
  Classes, SysUtils, Graphics;

const SQUARE = 32;
const STARTING_LEVEL = 1;
const MAXLEVEL = 5;
const IMAGE_DIR = 'images//';
const SOUND_DIR = 'sounds//';
const MAP_DIR = 'maps//';
const HIGHSCORE_FILE = 'score.txt';
const AMBUSHER_SQR = 5.0;
const KILLING_TIME = 10*1000;
const FPS = 50;
const STARTING_LIFES = 5;
const SCORE_DISPLAY_TIME = 5000;
const FRAME_WIDTH = 672;
const FRAME_HEIGHT = 800;

type
  TDirection = (UP, LEFT ,DOWN ,RIGHT ,NONE);
  TGameMode = (MMENU, MGAME, MOPTIONS, MHIGHSCORE, MSTATIC);
  TLocation = record
    X, Y :Real;
  end;
  TGameElement = (Nothing, Ball, Food, SPAWN, UL, UR, DL, DR, RL, UD, URL, URD, ULD, RLD, W, A, S, D ,X, O);
  TGameNetwork = array of array of TGameElement;
  TGameElementImages = array[TGameElement] of TBitMap;
  TPlayerImages = array[TDirection] of TBitMap;
  TASpot = record
    Food :Integer;
    SqrXY :TLocation;
  end;
 TMove = record
   Direction :TDirection;
   Destination :TLocation;
 end;

 TASpots = array of TASpot;
 TMoves = array of TMove;

function Distance(Location1, Location2 :TLocation): Real;
function ConvertToLocation(X, Y :Integer): TLocation;
function Sort(Locs :TMoves; Spot :TLocation): TMoves;
function PseudoMove(Loc :TLocation; Dir :TDirection): TLocation;
function Intersects(Loc1, Loc2 :TLocation): Boolean;
function Invert(Dir :TDirection): TDirection;
function GetPointForAmbusher(Map :TGameNetwork): TLocation;
function GetHighScore: Integer;
procedure WriteHighScore(Score :Integer);

operator = (Loc1, Loc2 : TLocation) b : Boolean;

implementation

function GetHighScore: Integer;
var T :TextFile;
begin
  try
    AssignFile(T, HIGHSCORE_FILE);
    Reset(T);
    Read(T, Result);
    CloseFile(T);
  except on E : EInOutError do Result := 0; end;
end;

procedure WriteHighScore(Score: Integer);
var T :TextFile;
begin
  AssignFile(T, HIGHSCORE_FILE);
  Rewrite(T);
  Write(T, Score);
  CloseFile(T);
end;

function Distance(Location1, Location2 :TLocation): Real;
begin
  Result := Sqrt(Sqr(Location1.X - Location2.X) + Sqr(Location1.Y - Location2.Y));
end;

function ConvertToLocation(X,Y :Integer): TLocation;
begin
  Result.X := X;
  Result.Y := Y;
end;

function ConvertToLocation(X,Y :Real): TLocation;
begin
Result.X := X;
Result.Y := Y;
end;

function SortAndFind(Locs :TASpots): TASpot;
var Swapped :Boolean;
    I :Integer;
    Temp :TASpot;
begin
  Swapped := True;
  while Swapped do
  begin
    Swapped := False;
    For I := 0 to Length(Locs) - 2 do
    begin
      if Locs[I].Food>Locs[I + 1].Food then
      begin
        Temp := Locs[I + 1];
        Locs[I + 1] := Locs[I];
        Locs[I] := Temp;
        Swapped := True;
      end;
    end;
  end;
  Result := Locs[0];
end;


function Sort(Locs :TMoves; Spot :TLocation):TMoves;
var Swapped :Boolean;
    I :Integer;
    Temp :TMove;
begin
  Swapped := True;
  while Swapped do
  begin
    Swapped := False;
    For I := 0 to Length(Locs) - 2 do
    begin
      if Distance(Locs[I].Destination,Spot)>Distance(Locs[I+1].Destination,Spot) then
      begin
        Temp := Locs[I + 1];
        Locs[I + 1] := Locs[I];
        Locs[I] := Temp;
        Swapped := True;
      end;
    end;
  end;
  Result := Locs;
end;


operator = (Loc1, Loc2 : TLocation) b : Boolean;
begin
  Result := (Loc1.X = Loc2.X) and (Loc1.Y = Loc2.Y);
end;

function PseudoMove(Loc :TLocation; Dir :TDirection): TLocation;
begin
  case Dir of
    LEFT: Result.X := Loc.X - SQUARE;
    RIGHT: Result.X := Loc.X + SQUARE;
    UP: Result.Y := Loc.Y - SQUARE;
    DOWN: Result.Y := Loc.Y + SQUARE;
  end;
end;

function Intersects(Loc1, Loc2:TLocation): Boolean;
begin
  Result := False;
  if (Abs(Loc1.X - Loc2.X) <= SQUARE) and (Abs(Loc1.Y - Loc2.Y) <= SQUARE) then Result := True;
end;


function Invert(Dir :TDirection): TDirection;
begin
  case Dir of
    LEFT: Result := RIGHT;
    RIGHT: Result := LEFT;
    UP: Result := DOWN;
    DOWN: Result := UP;
    else Result := None;
  end;
end;

function GetFoodInSquare(Map: TGameNetwork; SqrX0Y0:TLocation): Integer;
var X0, Y0, I, J :Integer;
begin
  Result := 0;
  X0 := Round(SqrX0Y0.X);
  Y0 := Round(SqrX0Y0.Y);
  for I := X0 to Round(X0 + AMBUSHER_SQR) do
  begin
      for J := Y0 to Round(Y0 + AMBUSHER_SQR) do
      begin
        if Map[J][I] = Food then Inc(Result);
      end;
  end;
end;

function GetPointForAmbusher(Map: TGameNetwork): TLocation;
var
  Spots :TASpots;
  SqrCr :Array of TLocation;
  I, J, X ,Y :Integer;
  Temp :TLocation;
begin
  for I := 0 to (Length(Map) div Round(AMBUSHER_SQR)) do
  begin
    for J := 0 to (Length(Map[I]) div Round(AMBUSHER_SQR)) do
    begin
      SetLength(SqrCr, Length(SqrCr) + 1);
      X := J;
      Y := I;
      if Length(Map) <= Round((J + 1) * AMBUSHER_SQR) then X := Round(X - (AMBUSHER_SQR - Length(Map) mod Round(AMBUSHER_SQR)));
      if Length(Map[I]) <= Round((I + 1) * AMBUSHER_SQR) then Y := Round(Y - (AMBUSHER_SQR - Length(Map) mod Round(AMBUSHER_SQR)));
      SqrCr[Length(SqrCr)-1] := ConvertToLocation(X, Y);
    end;
  end;
  SetLength(SPots, Length(SqrCr));
  for I:=0 to Length(SqrCr)-1 do
  begin
    Spots[I].SqrXY := SqrCr[I];
    Spots[I].Food := GetFoodInSquare(Map, SqrCr[I]);
  end;
  Temp := SortAndFind(Spots).SqrXY;
  Result := ConvertToLocation((Temp.X+Round(AMBUSHER_SQR / 2.0)) * SQUARE,(Temp.Y + Round(AMBUSHER_SQR / 2.0)) * SQUARE);
end;

end.