I have now added commands and built-in functions for using logical directions. A logical direction is one associated with a name rather than with an actual physical direction. If you program ZRF files, you are already familiar with using logical directions, because that is all that Zillions of Games uses. Until now, Game Courier has only used physical directions. Contrast how GAME Code could define a Knight's move with how Zillions of Games would:

def N checkleap 1 2;

vs.

(moves
	     (leap2 n ne)
	     (leap2 n nw)
	     (leap2 s se)
	     (leap2 s sw)
	     (leap2 e ne)
	     (leap2 e se)
	     (leap2 w nw)
	     (leap2 w sw)
      )

GAME Code could simply define a Knight as a 1-2 leaper and do mathematical calculations to check whether its move was legal, whereas ZoG needed to have every direction of movement spelled out explicitly.

Now you can do the same thing in GAME Code. The map and link commands will define directions similarly to how Zillions of Games does. The logleap and logride built-in functions will determine whether a leap or ride is legal using logical directions. The logleap function can be used for both simple leapers and lame leapers. Here are some examples:

// Chess Knight. Knight moves must be defined as single leaps.
def N logleap #0 #1 nne nnw sse ssw nww nee see sww;
// Xiangqi Knight. Lame leaps defined by separate paths, each in a pair
// of parentheses
def H logleap #0 #1 (n ne) (n nw) (s sw) (s se) (w sw) (w nw) (e se) (e ne);

The logride function can work for simple riders, winding riders, short-range riders, winding short-range riders, and turning riders. Some examples:

Simple rider. Rook
def R logride n w s e;

Winding rider.
Goes orthogonally, then outward diagonally, then alternates between
the same two directions.
def WR logride #0 #1 (n ne) (n nw) (s sw) (s se) (w sw) (w nw) (e se) (e ne);

Short-range rider. Short Rook. Non-direction z is used to stop movement.
def SR logride (n n n n z) (w w w w z) (s s s s z) (e e e e z);

Winding short-range rider. 
Like previous winding rider but limited to four spaces.
def SWR logride (n ne n ne z) (n nw n nw z) (s sw s sw z) (s se s se z) (w sw w sw z) (w nw w nw z) (e se e se z) (e ne e ne z);

Turning rider.
Moves one space orthogonally, then outward like a Bishop
def OD logride (n (ne) (nw)) (s (se) (sw)) (e (se) (ne)) (w (nw) (sw));