Single Comment

Here are your definitions for fd and FD:

def fd cond var firstpart (checkride #0 #1 1 1 or checkaride #0 #1 -1 0 or checkaride #0 #1 1 0 or checkmaxsteps #0 #1 3) (sub FD #0 #1 and cond empty #0 (not match old FD +WB +CS) (not match space #1 FD +WB +CS)) and #0 and #1;
def FD cond var firstpart (checkride #0 #1 1 1 or checkaride #0 #1 -1 0 or checkaride #0 #1 1 0 or checkmaxsteps #0 #1 3) (sub FD #0 #1 and cond empty #0 (not match old fd +wb +cs) (not match space #1 fd +wb +cs)) and #0 and #1;

Let me format these to show the logic better:

def fd 
cond var firstpart 
  (checkride #0 #1 1 1 or checkaride #0 #1 -1 0 or checkaride #0 #1 1 0 or checkmaxsteps #0 #1 3) 
  (sub FD #0 #1 
  and cond empty #0 
    (not match old FD +WB +CS) 
    (not match space #1 FD +WB +CS)
  ) 
and #0 
and #1;

def FD 
cond var firstpart 
  (checkride #0 #1 1 1 or checkaride #0 #1 -1 0 or checkaride #0 #1 1 0 or checkmaxsteps #0 #1 3)
  (sub FD #0 #1 
  and cond empty #0 
    (not match old fd +wb +cs) 
    (not match space #1 fd +wb +cs)
  ) 
and #0 
and #1;

These first make sure that #0 and #1 are included in the function so that you can use them in parenthesized expressions. It then skips over the parenthesized expressions and goes to the variable firstpart. If its value is non-empty, it executes (checkride #0 #1 1 1 or checkaride #0 #1 -1 0 or checkaride #0 #1 1 0 or checkmaxsteps #0 #1 3), and it is empty, it executes

  (sub FD #0 #1 
  and cond empty #0 
    (not match old fd +wb +cs) 
    (not match space #1 fd +wb +cs)
  ) 

First, it checks whether #0 is empty. If it is, it executes (not match old fd +wb +cs), and it it isn't, it executes (not match space #1 fd +wb +cs). Each returns a truth value. If the truth value is true, then it will allow the execution of the subroutine FD. That subroutine looks like this:

sub FD from to;
  return cond cond empty #from capture (not empty #to) (checkleap #from #to 0 1 or checkleap #from #to 1 1) (checkleap #from #to 0 1 or checkleap #from #to 1 1 and == var ori #to) and #to;
endsub;

For some reason, this subroutine just returns a function call without making use of the imperative programming available to subroutines.

Reformatting it to show its logic, it looks like this:

sub FD from to;
  return cond 
    cond empty #from 
      capture 
      (not empty #to) 
  (checkleap #from #to 0 1 
    or checkleap #from #to 1 1) 
  (checkleap #from #to 0 1 
    or checkleap #from #to 1 1 
    and == var ori #to) 
and #to;
endsub;

If a player hasn't moved yet, #from will be occupied, and if he has moved, #from will be empty. If he has moved, the inner cond returns the value of capture, and if he hasn't, it returns true if the move would result in a capture. This value is passed to the outer cond. If it's a capturing move, it can move one space in any direction. If it's not a capturing move, its move is allowed only if the value of ori is the same as to. It looks like #ori has been set to the origin. So, this might stop it from making non-capturing moves.