unit PCRob14;        { PCRobots 1.41;  by Helmar Becker }{ vpub }

interface

const    aFree=0;
         aWall=1;
         aDamage=3;
         aRefuel=30;

         sMiss=0;
         sWall=1;
         sHit1=2;
         sHit2=3;
         sHit3=4;
         sNotExist=5;
         sAir=6;

type      Map_buffer=array[0..8,0..8] of shortint;
          Mapbuf_ptr=^Map_buffer;


function  Configure(speed,manoeuv,range,armor,accel,invis:integer):integer;
    {->0=called before, ignored, else ver. num. <HiByte>.<LoByte> }
procedure SetPattern(Buffer:string); { 5 bytes, lower 5 bits }
procedure RegTeamIFF(name:string); { name+'t'+teamID / name+'s'+robotID; robots recognize each other only if in same team }
procedure DebugFlag(flag,setflag:integer); { flag:0,1; setflag:0,1 }
procedure RegIFF(s:string); { normal string; only once }
function  CheckIFF(Id:integer):boolean; {->robot has same IFF }
procedure RegName(s:string); { normal string; only once }
function  FindName(s:string;startid:integer):integer;{->ID, -1=not found; normal string; start with startID }
function  GetRobotID:integer; { own ID }
function  GetTeamID:integer; {->teamID, -1= not in a team, 0,1,2: TeamID }

procedure Swaptask; { EOM }
procedure Movement(speed,angle:integer); { EOM;speed>maneuverspeed:no dirchange }
function  Scan(angle,res:integer;var range:integer):integer;{->ID; EOM; id=-1:NoRobot; scans angle+-res ;res<45 }
function  Shoot(angle,range:integer):integer;{->ShellID; EOM; reloads in 50 ticks; max 7 in air }
function  ShellStat:integer; { last landed shell; 0..4:missed,wall,red,yellow,white }
function  AShellStat(ShellId:integer):integer; { 5:not exist, 6:in air }

procedure Invisibility(invis_flag:integer); { 0:visible; 1:invisible}
function  IsInvisible:boolean; { true=invisible }

procedure Getxy(var x,y:integer); { x,y: 0..999 }
function  RegisterX(X:pointer):integer; { makes vars auto-updated; 1:OK, 0:fail }
function  RegisterY(Y:pointer):integer; { call "regX(@xpos);" }
procedure GetMap(ptr:MapBuf_ptr); { 9x9 area around act. pos. }
{procedure Get_Remote_Map(ptr:MapBuf_ptr;x,y:integer); {EOM, -v1.3, x,y:0..99; 9x9 area}

function  Transmit(target,data:integer):boolean;{->success = in target-IDs recv-buf; costs 1 batt }
function  Receive(var source,data:integer):boolean;{->data exist, source=sender-ID; Robots have 20-word FIFO-buf }

function  Armor:integer; { Doc says "damage", actualy is health/armor }
function  Speed:integer; { current speed }
function  Battery:integer; { current batt }
function  Ticks:longint; { ticks since gamestart }
function  ShellsLeft:integer;

procedure BuyArmor(armor_units:integer); { 1 armor=50 batt; units<0 to sell; can not exceed config-armor }
procedure SellArmor(armor_units:integer); { actually is BuyArmor(-units) }
procedure BuyShells(shells:word); { 1 shell=10 batt; no sell }

function  L_Sin(angle:integer):longint; { scaled: 100000 means 1 }
function  L_Cos(angle:integer):longint; { scaled: 100000 means 1 }
function  L_Tan(angle:integer):longint; { scaled: 100000 means 1 }
function  L_Atan(ratio:longint):integer; { ratio scaled: 100000 means 1 }
function  L_Sqrt(value:longint):longint; { unscaled }
function  L_Atan2(y,x:integer):integer; { arctan(y/x), good if even x near 0;x=y=0 ->0 }

{
Config:     Value  Speed Manouevre Range armor Acceleration
              0      50     20%     300     50      5
              1      75     35%     500     75      7
              2     100     50%     700    100     10
              3     150     75%    1000    150     15
              4     200    100%    1500    200     20

Arena: free:0 wall:1(00001) trap:3(00011) refuel:30(11110)  ()=binary
start with 1000 shells, if invisibility device 900 shells
Automatic recharge: 4 batts/tick (only if visible!), max 1000
Movement cost: speed/10 batts/tick
Damage points: arena-edge:1, red(dist 25..48):2, yellow(5..24):8,
               white(0..4):25
Invisibility: no refuel, no recharge no scan, no fire
              max 100 ticks,
              before getting invis. again, wait as long as last invis lasted.
Refuel stations are batts, recharging 5/tick, max 2000
       refueling: standing un refuel-ststion, visible; transfer 10/tick
Speed: 100 actually means 1 dist per tick.
Shells travel at 400 ( = 4 dist/tick ).

}

implementation

uses DOS;

procedure Swaptask;
 var regs:Registers;
BEGIN
 regs.ax:=0;
 intr($e0,regs);
END;

procedure Movement(speed,angle:integer);
 var regs:Registers;
BEGIN
 regs.ax:=1;
 regs.bx:=speed;
 regs.cx:=angle;
 intr($e0,regs);
END;

function  Scan(angle,res:integer;var range:integer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=2;
 regs.bx:=angle;
 regs.cx:=res;
 intr($e0,regs);
 range:=regs.bx;
 Scan:=regs.ax;
END;

function  Shoot(angle,range:integer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=3;
 regs.bx:=angle;
 regs.cx:=range;
 intr($e0,regs);
 Shoot:=regs.ax;
END;


procedure RegTeamIFF(name:string);
var DummyI:integer;
begin
DummyI:=GetTeamID;
If DummyI >=0
  then RegIFF(name+'t'+char(48+dummyi))
  else begin
    DummyI:=GetRobotID;
    RegIFF(name+'s'+char(48+DummyI div 10)+char(48+DummyI mod 10));
  end;
end;


function AShellStat(ShellId:integer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=$2c;
 regs.bx:=ShellId;
 intr($e0,regs);
 AShellStat:=regs.ax;
END;


function RegisterX(X:pointer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=$2d;
 regs.bx:=seg(X);
 regs.cx:=ofs(X);
 intr($e0,regs);
 RegisterX:=regs.ax;
END;

function RegisterY(Y:pointer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=$2e;
 regs.bx:=seg(Y);
 regs.cx:=ofs(Y);
 intr($e0,regs);
 RegisterY:=regs.ax;
END;




{procedure Get_Remote_Map(ptr:MapBuf_ptr;x,y:integer);
{ var regs:Registers;
{BEGIN
{ regs.ax:=4; { ?? DOC says $21, but localmap is $21; PCROBOT.C says 4 }
{ regs.bx:=seg(ptr^);
{ regs.cx:=ofs(ptr^);
{ regs.dh:=x;
{ regs.dl:=y;
{ intr($e0,regs);
{END;}

procedure Getxy(var x,y:integer);
 var regs:Registers;
BEGIN
 regs.ax:=$10;
 intr($e0,regs);
 x:=regs.bx;
 y:=regs.cx;
END;

function  Transmit(target,data:integer):boolean;
 var regs:Registers;
BEGIN
 regs.ax:=$11;
 regs.bx:=target;
 regs.cx:=data;
 intr($e0,regs);
 Transmit:=(regs.ax<>0);
END;

function  Receive(var source,data:integer):boolean;
 var regs:Registers;
BEGIN
 regs.ax:=$12;
 intr($e0,regs);
 source:=regs.bx;
 data:=regs.cx;
 Receive:=(regs.ax<>0);;
END;

function  Armor:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$13;
 intr($e0,regs);
 Armor:=regs.bx;
END;

function  Speed:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$14;
 intr($e0,regs);
 Speed:=regs.bx;
END;

function  Battery:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$15;
 intr($e0,regs);
 Battery:=regs.bx;
END;

function  Ticks:longint;
 var regs:Registers;
BEGIN
 regs.ax:=$16;
 intr($e0,regs);
 Ticks:=(regs.bx shl 16)+regs.cx;
END;

function  L_Sin(angle:integer):longint;
 var regs:Registers;
BEGIN
 regs.ax:=$17;
 regs.bx:=angle;
 intr($e0,regs);
 L_Sin:=longint(regs.bx) shl 16 +regs.cx;
END;

function  L_Cos(angle:integer):longint;
 var regs:Registers;
BEGIN
 regs.ax:=$18;
 regs.bx:=angle;
 intr($e0,regs);
 L_Cos:=longint(regs.bx) shl 16+regs.cx;
END;

function  L_Tan(angle:integer):longint;
 var regs:Registers;
BEGIN
 regs.ax:=$19;
 regs.bx:=angle;
 intr($e0,regs);
 L_Tan:=longint(regs.bx) shl 16+regs.cx;
END;

function  L_Atan(ratio:longint):integer;
 var regs:Registers;
BEGIN
 regs.ax:=$1a;
 regs.bx:=(ratio shr 16);
 regs.cx:=(ratio and $ffff);
 intr($e0,regs);
 L_Atan:=regs.ax;
END;

function  L_Sqrt(value:longint):longint;
 var regs:Registers;
BEGIN
 regs.ax:=$1b;
 regs.bx:=(value shr 16);
 regs.cx:=(value and $ffff);
 intr($e0,regs);
 L_Sqrt:=longint(regs.bx) shl 16+regs.cx;
END;

procedure SetPattern(Buffer:string);
 var regs:Registers;
BEGIN
 regs.ax:=$1c;
 regs.bx:=seg(Buffer[1]);
 regs.cx:=ofs(Buffer[1]);
 intr($e0,regs);
END;

procedure DebugFlag(flag,setflag:integer);
 var regs:Registers;
BEGIN
 regs.ax:=$1d;
 regs.bx:=flag;
 regs.cx:=setflag;
 intr($e0,regs);
END;

procedure BuyArmor(armor_units:integer);
 var regs:Registers;
BEGIN
 regs.ax:=$1e;
 regs.bx:=armor_units;
 intr($e0,regs);
END;

procedure SellArmor(armor_units:integer);
 var regs:Registers;
BEGIN
 regs.ax:=$1e;
 regs.bx:=-armor_units; { negative buy = sell }
 intr($e0,regs);
END;

procedure BuyShells(shells:word);
 var regs:Registers;
BEGIN
 regs.ax:=$1f;
 regs.bx:=shells;
 intr($e0,regs);
END;

function  ShellsLeft:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$20;
 intr($e0,regs);
 ShellsLeft:=regs.bx;
END;

procedure GetMap(ptr:MapBuf_ptr);
 var regs:Registers;
BEGIN
 regs.ax:=$21;
 regs.bx:=seg(ptr^);
 regs.cx:=ofs(ptr^);
 intr($e0,regs);
END;

procedure Invisibility(invis_flag:integer);
 var regs:Registers;
BEGIN
 regs.ax:=$22;
 regs.bx:=invis_flag;
 intr($e0,regs);
END;

function  ShellStat:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$23;
 intr($e0,regs);
 ShellStat:=regs.bx;
END;

function  IsInvisible:boolean;
 var regs:Registers;
BEGIN
 regs.ax:=$24;
 intr($e0,regs);
 IsInvisible:=(regs.bx<>0);
END;

function  L_Atan2(y,x:integer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=$25;
 regs.bx:=y;
 regs.cx:=x;
 intr($e0,regs);
 L_Atan2:=regs.ax;
END;

function GetRobotID:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$26;
 intr($e0,regs);
 GetRobotID:=regs.ax;
END;

function CheckIFF(Id:integer):boolean;
 var regs:Registers;
BEGIN
 regs.ax:=$28;
 regs.bx:=Id;
 intr($e0,regs);
 CheckIFF:=(regs.ax<>0);
END;

function GetTeamID:integer;
 var regs:Registers;
BEGIN
 regs.ax:=$2b;
 intr($e0,regs);
 GetTeamID:=regs.ax;
END;

function Configure(speed,manoeuv,range,armor,accel,invis:integer):integer;
 var regs:Registers;
BEGIN
 regs.ax:=$80;
 regs.bx:=(speed and 7) + ((manoeuv and 7) shl 4) + ((range and 7) shl 8)+
		((armor and 7) shl 12);
 regs.cx:=(accel and 7) + ((invis and 1) shl 3);
 intr($e0,regs);
 Configure:=regs.ax;
END;

procedure RegIFF(s:string);
var r:registers;
begin
s:=s+#0;
r.ax:=$27;
r.bx:=seg(s[1]);
r.cx:=ofs(s[1]);
intr($e0,r);
end;

procedure RegName(s:string);
var r:registers;
begin
s:=s+#0;
r.ax:=$29;
r.bx:=seg(s[1]);
r.cx:=ofs(s[1]);
intr($e0,r);
end;

function FindName(s:string;startid:integer):integer;
var r:registers;
begin
s:=s+#0;
r.ax:=$2a;
r.bx:=seg(s[1]);
r.cx:=ofs(s[1]);
r.dx:=startid;
intr($e0,r);
FindName:=r.ax;
end;



end.

