BG Replay (V1.0.1) Installation Guide

Thanks for downloading BG Replay. Getting it set up on your computer or web server is easy. This page describes how to do it.

This is version 1.0.2 of BG Replay. See the changelog for details of updates from previous versions.

This is an initial release of BG Replay, and there will be updates over the next few months. Keep checking back at www.paulspages.co.uk/bgreplay for new versions.

If you use BG Replay on your website, I'd really like to know about it (so I can have fun watching the backgammon games!), so please let me know. 

I hope you have fun with this software!

Paul Stephens.

(The colours used on this page will adjust automatically for printing.)

Contents:

Licence agreement
Should you use the PHP or HTML version?
Installing the PHP version
Getting started – PHP version
Installing the HTML version
Getting started – HTML version
The BG Print page
The BG Self-Drive page
Getting started with BG Script
Using scripts to create tutorials
Using scripts to create menus
.bgm match files
Customising the graphics and page designs
Q&A

Sorry about the legal stuff below, but these days you can't be too careful, and the last thing I want is someone suing me for the distress caused by BG Replay displaying a move wrongly and thus ruining their chances of becoming world backgammon champion. Basically, if you use BG Replay for free, you take full responsibility for it.

Also, if you're going to use BG Replay in something you charge people money for, then I'd like a small consideration for its use (don't worry though, I'm not looking to get rich - or anything like it - from this!)

Licence agreement - please read carefully

BG Replay (consisting of the HTML, PHP and JavaScript code, plus graphics and sample game and script files, supplied in this package) is © Paul Stephens, 2005. All rights reserved. You may use these items free of charge on non-commercial websites, and on your own computer, subject to the licence terms listed below. If you wish to use BG Replay on a commercial website (i.e. one that charges a subscription or other fees for access), or distribute it as part of a commercial package, please contact the author at paul@paulspages.co.uk.

Licence for non-commercial use.

1. The software is supplied as is. I make no warranty of any kind concerning its fitness for any purpose.

2. You use the software at your own risk. I take no responsibility for any loss or damage resulting from the use of the software.

3. If you publish pages containing BG Replay elements on your website, you are responsible for any loss or damage suffered by your website's visitors as a result of its use.

4. You may publish pages containing some or all elements of the BG Replay package on a non-commercial website (i.e. one for which there is no subscription or other access fee), provided that all copyright notices in the HTML and .js files are left intact. Banner ads which pay only on click-through (e.g. Google AdSense) do not count as making a site commercial.

5. You may redistribute BG Replay as part of a non-commercial package (e.g. send a copy to a friend), provided that all copyright notices in the HTML and .js files are left intact.

6. You may not redistribute any part of BG Replay as part of a commercial package or service, or use any part of it in a page which forms part of a commercial website.

By using BG Replay, or any element of the BG Replay package, you agree to the licence terms above.


OK, that's the legal stuff over - on to the software!

Instant setup guide for people who are familiar with HTML, web servers, etc.


More detailed explanations


First question - should you use the PHP or HTML version?

This .zip file contains two subfolders, bgrPHP and bgrHTML.


If you can run the PHP version, then it’s best to do so. Instead of having to create lots of different HTML pages, you just copy your game files into the BG Replay scripts/ folder and they’re ready to go. Any changes you make to the page designs will be automatically applied to all games, and your website’s visitors will experience shorter download times.

The PHP version also supports .bgm match files, and includes the Printer and Self Drive pages. It works with PHP version 4.3 and later.



Installing the PHP version

Installing BG Replay is just a matter of copying the files from the downloaded .zip to a disk folder. On some versions of Windows you may be able to do this directly from the .zip file (shown as a 'compressed folder' in Windows Explorer). Alternatively you may have to unzip the files first.

After installing BG replay, make sure that these sub-folders exist in the BG Replay folder:

images/
scripts/
bpodimages/
 



Getting started – PHP version

This kit contains two BG Replay page designs – bPod (‘bpod.php’) and Desktop (‘bg.php’).

These pages will run all your .gam, .mat, GNU text-export and native-mode BG Script files. You tell the page which file to run each time via a parameter which you add to the page’s name. Files must be stored in the right place, and have the right filename extensions (see below).

Where to store game files and scripts

How to run a game


Installing the HTML version

Installing BG Replay is just a matter of copying the files from the downloaded .zip to a disk folder. On some versions of Windows you may be able to do this directly from the .zip file (shown as a 'compressed folder' in Windows Explorer). Alternatively you may have to unzip the files first.

After installing BG replay, make sure that these sub-folders exist in the BG Replay folder:

images/
bpodimages/
templates/



Getting started – HTML version

In the HTML (bgrHTML) version, you have to create a separate copy of the page for each backgammon game, with the game file or script embedded in it.

This kit contains two BG Replay page designs – bPod and Desktop. The bgrHTML/templates folder contains a set of templates for each page design. These let you create game pages based on .gam. and GNU text-export files, and native mode bgg scripts.


To create a page based on a .gam file:


To create a page based on a GNU text-export file:


To create a page based on a native-mode BG Script file:

(For details on BG Script, see ‘Getting started with BG Script‘ below.)


The BG Print page (PHP version only)

The PHP versions of the system also contains the BG Print page (as seen on the BG Replay website).

This reads game and script files like the bPod and Desktop pages, but produces a traditional layout, with one board image per position. This can be viewed on screen, or printed out. A separate style sheet adjusts the colours for printing.

To use the print page:




The BG Self-Drive page (PHP version only)


The PHP versions of the system also contains the BG Replay self-drive page (as seen on the BG Replay website).

You can use this to generate BG Script versions of your .gam and GNU text-export files, which will load more quickly (see “Getting started with BG Script’, below, for details).

To use the the self-drive page:



Getting started with BG Script

NOTE - you don't need to write any BG Script code in order to display games on the web.
Exporting games from GNU Backgammon in text-export format will produce games with text commentary (if you've written some) plus move and cube analysis (if you've analysed the game in GNU). BG Script allows you to do things beyond this, such as write tutorials.

Bg Script is BG Replay’s own scripting language. As well as handling standard backgammon gameplay, it lets you create free-format tutorials and demonstrations, with direct control over the board and pieces. It can also be used to create menus of links which appear in the page’s text display areas.

BG Replay pages convert all game files (.gam and GBU text-export) to BG Script before running them. If you wish, you can create BG Script versions of your game files using the Self-Drive page (see above), then save them as .bgg files. These will load more quickly, because the page doesn’t have to convert them each time they’re run.

Here’s a script for the first two dice rolls of a game:

[pagetitle Paul's Backgammon Basics]
[gametitle Sample Game 1]
[playername1 Tom]
[playername2 Jerry] 
[horizl][povplr2][povclrw]

[play][player2]
[posID 24HPwATDgc/ABMA]
[dice 21][move 13/11 24/23]
[precomment]White opens with the lowest possible dice roll. [/precomment]
[postcomment]White plays GNU's top-ranking choice of moves.[/postcomment]
[/play]

[play]
[player1]
[posID 14HPwATDgc+QBKA]
[dice 23][move 13/11 24/21]
[precomment]2-3 isn't much better than 2-1[/precomment]
[postcomment]Red's in the slightly better position here.[/postcomment]
[/play]

The first few tags set the page and game titles, and player names.

[horizl][povplr2][povclrw] sets left horizontal orientation (24-points on the left), and specifies that the Point Of View Player (playing from top to bottom of the board) is player 2, and playing white.

Each [play]…[/play] block defines a roll of the dice plus the resulting moves. The blocks also contain [precomment] and [postcomment] text – the former is displayed after the dice roll but before the move, the latter after the move.

[posID 14HPwATDgc+QBKA] sets the board position before the move. The value is a superset of the GNU Backgammon position ID string, as follows:

Chs   Content
1   Player number (1 or 2)
2 to 15   Standard 14-character GNU position ID
16   (optional – not shown here): current cube owner (1 or 2)
17 onwards    (optional – not shown here): current cube value (2 upwards, e.g. 16).
 


PosIDs are optional – you can create a bgg game script without them, and the page will calculate the posIDs for you (assuming a standard start-of-game position) each time it runs the script. However a script that does have posIDs for every play will load noticeably more quickly than one without.

Scripts which have been generated from .gam and GNU files by the Self-Drive page (see above) have posIDs included.

Scripts are plain text files, so can be created in any text editor.

See ‘game01.bgg’ in the scripts/ sub-folder of the PHP version (bgrPHP/scripts/) for an example of a full game script, including cube play and GNU move and cube analysis.

NOTE – when BG Replay reads GNU text-export files, it automatically converts comment text to [postcomment]…[/ postcomment] blocks. If the GNU comment text includes a [split] tag, the text before the [split] is converted to a [precomment]… [/precomment] block.

Move and cube analysis data in GNU files is automatically converted to [analysemove] and [analysecube] blocks.

 



Using scripts to create tutorials.

Here’s the first part of the script for the ‘Rules of backgammon’ tutorial:

[pagetitle Paul's Backgammon Basics - The Rules]
[playername1 Red]
[playername2 White]
[horizl][povplr2][povclrw]
[play][player1][title Introduction]
[posID 14HPwATDgc/ABMA]
[command steps]
[steps]
[step]labels::0[/step]
[step]dispstats::n[/step]
[step]say::<b>BACKGAMMON BASICS</b>[/step]
[step]setpos::1AAAAAAAAAAAAAA[/step]
[step]clearmoved::[/step]
[step]say::<br><br>Welcome to Backgammon Basics!<br><br>This introduction takes 
you through the rules of backgammon.
<br><br>It's a fairly simple game, so it won't take long - then you can begin 
the lifelong process of learning how to play well!
<br><br>Press 'Next' to start.
[/step]
[/steps]
[/play]
[play][player1][title The Board]
[posID 1AAAAAAAAAAAAAA]
[command steps]
[steps]
[step]labels::2[/step]
[step]dispstats::n[/step]
[step]say::<b>THE BACKGAMMON BOARD</b><b></b>[/step]
[step]say::<br><br>The backgammon board contains 24 triangles, called 'points' (or 'pips').[/step] [step]wait::2000[/step] [step]say::<br><br>From your point of view, they're numbered as shown here, from 24 to 1.[/step] [step]wait::2000[/step] [step]say::<br><br>Your aim is to move pieces around the board like this
(from higher to lower-numbered points), and eventually off into the side-tray.[/step] [step]setpos::1AAAAAAAAAQAAAA[/step] [step]wait::500[/step] [step]move2::24/13 13/12 12/1 1/0[/step] [step]wait::1200[/step] [step]say::<br><br>Your opponent, meanwhile, is trying to do the same thing in the opposite direction. Your 1-point is their 24-point, and so on.[/step] [step]labels::1[/step] [step]setpos::2AAAAAAAAAQAAAA[/step] [step]wait::500[/step] [step]move1::24/13 13/12 12/1 1/0[/step] [step]labels::2[/step] [/steps] [/play]
Instead of gameplay ([dice] and [move] tags), each play block contains a
[command steps] tag, followed by a [steps]…[/steps] block, itself containing
a series of [step]…[/step] commands.

[step]labels::2[/step]
sets the board labels (1 to 24) for player 2.

[step]dispstats::n[/step]
sets the statistics display (player names, pip counts and position IDs) off.

[step]wait::2000[/step]
pauses for 2 seconds before the next step

[step]move2::24/13 13/12 12/1 1/0[/step]
moves 24/13 13/12 12/1 1/0 for player 2.

[step]say::<br><br>From your point of view… [/step]
displays text on the screen. Note that this text can include HTML tags (<br> in this example).

Note the :: (two colons) separator between each step command (e.g. ‘wait’) and its accompanying value (e.g. ‘2000’).

For the full tutorial, including examples of most of the available [steps] commands, see bgbasics.bgg in the scripts/ sub-folder of the PHP version (bgrPHP/scripts/).
 


Using scripts to create menus.

You can use a [steps] block to create in-page menus. Here’s the contents of the file ‘bpodmenu.bgg’:

 [pagetitle Welcome to
bPod!] [playername1
Red] [playername2
White]

[horizl][povplr2][povclrw] [play][player1][noprompts][title
Introduction] [posID
1AAAAAAAAAAAAAA] [command
steps]
[steps]
[step]labels::0[/step]
[step]dispstats::n[/step]
[step]say::<b>MENU</b>[/step]
[step]say::
<br><br> <ahref="bpod.php?s= bgbasics.bgg">The rules of
backgammon</a><br>
<br> <ahref="bpod.php?s= game01.bgg">Sample
Game</a><br>
<br> <ahref="bpod.php?s=tj1pod.bgm">Tom vs Jerry (7 point match)</a>
<br>
<span style="font-size:10px">(Actually GNU vs GNU at intermediate setting
- knockabout stuff with plenty of hits)</span>
<br><br>
<b>OR</b><br><br>
See it on the <b><a href="bg.php">BG Replay Desktop.</a></b>
<br><br>
<a href=".">(Return to the main menu)</a>
[/step]
[/steps]
[/play]

This script clears the board, then shows a single page with HTML for hyperlinks to other pages. To set up your own menu, copy bpodmenu.bgg, and put your own hyperlinks and text in the say:: commands.



.bgm match files.

A match (.bgm) file is essentially a list of game files, which BG Replay treats as a group. Match files can only be used with the PHP versions of the BG Replay pages.

When you tell BG Replay to play a match file (as in the link to
‘bpod.php?s=tj1pod.bgm’ in the example menu file above), it does the following:

1. Creates a menu page automatically, with links to each game file in the .bgm file’s list.

2. When playing a game from the list, activates the page’s Next game, Previous Game and Menu buttons, so the user can navigate directly between games, and back to the menu.

Here are the contents of a .bgm file:

tj1.bgm
bgmenu.bgg
Tom vs Jerry
Match to 7 points tj1.bgt tj1_002.bgt tj1_003.bgt tj1_004.bgt tj1_005.bgt tj1_006.bgt tj1_007.bgt
The format of these files is very rigid, so the data must be entered exactly as shown, with no blank lines between entries, and no extra characters such as commas.

Line 1 is the name of the .bgm file (used by the Menu button when playing games)

Line 2 is the name of this menu’s parent menu (i.e. the one the page will return to if the menu button is pressed while its own menu is showing). This must be supplied (i.e. you can’t miss out this line).

Line 3 is the page title. It must be supplied (i.e. you can’t miss out this line).

Line 4 is the game title. It must be supplied (i.e. you can’t miss out this line).

Lines 5 onwards are the names of the game files, one per line. These can be any mixture of .bgg, .gam and .bgt (GNU text-export) files. You can have as many files as you like in a match.


Full details of the BG Script language, plus a script-editor version of the BG Replay page, will be available in the BG Replay SDK, available later this year.
 


Customising the graphics and page designs

BG replay is designed to work with any page layout and set of graphic images. The bPod and Desktop page are just two examples of pages that can be built around the BG Replay system.

You will need to be familiar with editing HTML source code in order to change the design of the pages.

Changing  the board and playing piece graphics
Each page design stores its image files in a particular folder ('images/' for the Desktop, 'bpodimages/' for bPod). Check the image files in either of these folders with an image-editing program, and it will be obvious which files are the board, dice, counters etc.

You can create a folder with your own images, and 'point' either version of the page at that instead. If the dimensions of the graphics are exactly the same as the original ones used with the page, that's all you need to do.

To point a page at a different images folder, find this block of source code:

myBG = new bgBoard(
	"myBG", 	// Board ID as string - must be the ID used in this assignment
	"w",	// Colour used by the POV player (top to bottom of on-screen board). Default "w"		
	"bpodimages/", // Optional image path (e.g. "images/") must include trailing / if used
	"l",	// Horizontal orientation - default "l" for top-left
	2)		// Player number shown as the POV player. Default 1
myBG.resetBoard()

Replace the 'Optional image path' parameter ("bpodimages/" in this example) with the name of your image folder (don't forget the trailing "/"). The page will now read its image files from that folder.

NOTE - Some page designs store other images in their images folder, and reference them from other parts of the page. For example the bPod design stores the bPod background image in bpodimages/, and references it from an inline style sheet attached to a <DIV>. To alter any such references,  search and replace on the previous value (e.g. 'bpodimages/').

Changing the dimensions of the graphics
If the dimensions of your graphics are not exactly the same as the original ones used with the page (e.g. the board, counters etc are bigger or smaller), then you need to edit the config file for that page.

A config file is a javascript code file that specifies the sizes of the images, and locations such as the left edge of each point on the board.

The files supplied are as follows:

Here's an extract from bgconfig.js

this.yupper = 12 // starting y coord for upper-table points (upper edge of playing area)
this.ylower = 292 // starting y coord for lower-table points (lower edge of playing area)
this.pieceheight = 24 // Height of piece in play (width is the same)
this.sideheight = 9 // height of piece in off-tray (width is same as in-play piece)

All measurements are in pixels. To change the dimensions used, just edit the values.

To link a new config file into a page, find this statement in the page source (in the <head> section):

<script language="javascript" src="bgconfig_bpod.js"></script>

(the file name will be 'bgconfig.js' for the Desktop page design).  Change the src= value to the  name of your config file.

Changing the fonts, background colours etc in a page.

Each page design has its own .css style sheet:

To change the fonts, background colours etc used in a page, edit its style sheet. CSS stylesheet language is beyond the scope of this document, but most of the items are fairly self-explanatory.
NOTE - a couple of fonts, which are linked directly to the board, are defined in the config file instead.

A page's style sheet is linked in via this statement:

<link rel="stylesheet" href="bpod.css" type="text/css">

To use a different style sheet with a page, change the href= parameter of this statement.

Changing the physical layout of a page.

It's easy to change the basic structure of the page, making it look as different as the bPod does from the Desktop design.

The page contains a series of HTML container elements (DIVs, SPANs, FORMs etc) which hold the the board display, control buttons and text displays. You can put these containers anywhere you want on the page, and assign any styles you like to them.

At the end of the page source is a script which creates the Game object, the code which manages all these displays (it also generates the HTML for the buttons). (NOTE - the single exception to this is the board, which is handled separately - see below).

Here's the Game object creation code from the bPod design:

myGame = new bgGame(
	"myGame", // ID - must be the same as the name above
	"bpod.php", // filename of this page
	myBG, // ID of board object (NOTE as a name, not a string)
	"gamescript", // ID of element containing game script
	"rollcontrolsarea", // Element to contain control buttons
	"playcontrolsarea", // Element to contain play controls
	"promptdisparea", // Optional area for "Press next to continue" prompts
	"afterplaycontrolsarea", // Element to contain after-play (replay/next) controls
	null, // Element to hold animation speed controls
	"matchcontrolsarea",// Element to hold next/previous game and menu buttons
	"rolldisp", // Display element for roll data
	"movedisp", // Display element for move data
	"precompdisp", // Display element for pre comment
	"postcompdisp", // Display element for post comment
	"ptitle", // Display element for page title
	"gtitle", // Display element for game title
	"p1title", // Display element for player 1 name & stats
	"p2title", // Display element for player 2 name & stats
	"gameIntroDisp", // Display element for game intro
	"analysemovedisp", // analyseMove table display area
	"analysecubedisp", // analyseCube table display area
	"matchdatadisp", // match header information display area
	null, // end of game stats (from GNU .txt format) display area
	false, // Set dev (play editor) mode on
	"devForm", // Dev form ID - mandatory when dev is true
	null) // match string (optional) for PHP versions only

Values such as "playcontrolsarea" and "precompdisp" are the names of HTML elements which have been created earlier in the page. Here's the HTML code which defines "precompdisp":

<p class="precompdisp" id="precompdisp" style="margin-left:0">&nbsp;</p>

This is a paragraph (<p>) tag, although it could have been a <div> or <span>, depending on the page design.

IMPORTANT - the names of these elements must be defined by id= attributes (e.g. id="precompdisp"), not name= attributes.

Here's the definition for "rollcontrolsarea":

<span id="rollcontrolsarea" style="position:absolute;left:326;top:387"></span>

This span holds the Autoplay button, roll selector and other controls, and is initially empty. The game object generates the HTML code to define the controls, and puts it into the element. The buttons thus appear wherever you've placed the "rollcontrolsarea" element on the page.

TIP - if you don't want some elements to appear on the page, put them inside a hidden container. For example, if you wanted to exclude the cube analysis and match statistics displays from a page design, you could do it like this:

<div style="display:none">
<div id="analysecubedisp"></div>
<div id="matchdatadisp"></div>
</div>

Placing the backgammon board

The board display (plus counters, dice etc) aren't created by the Game object, but by the Board object.  Here's the code which defines and places the bPod's board object:

<span style="position:absolute;left:329;top:94;visibility:visible" id="boardTD">
<script>
myBG = new bgBoard(
	"myBG", // Board ID as string - must be the ID used in this assignment
	"w", // Colour used by the POV player (top to bottom of on-screen board). Default "w"
	"bpodimages/", // Optional image path (e.g. "images/") must include trailing / if used
	"l", // Horizontal orientation - default "l" for top-left
	2) // Player number shown as the POV player. Default 1
myBG.resetBoard()
</script>
</span>

(This is the code mentioned earlier in connection with image folders).

The board object generates the images for the board and pieces, so the board will appear wherever you place this code on the page. In the bPod it's inside an absolutely-positioned <span>, while in the Desktop design it's in a floating table cell.



Q&A

Here is the Q&A section from the BG Replay website, in case you want to refer to it.

What is BG Replay?
It's a fancy name I've thought up for a set of program functions that can read saved backgammon files and play them back in an animated web page, complete with commentary text and move/cube analyses. Instead of having to show a separate screenshot for each position, the page shows a single backgammon board with the pieces moving over it.

Who is it aimed at?
People who run websites, and want to publish backgammon games and tutorials on their web pages.

Are the web pages interactive?
Yes. The user can play each move individually, skip between plays, jump directly to plays and use autoplay mode to run a game automatically.

What do my site visitors need in order to view these pages?
Web Pages that use BG Replay run on Internet Explorer, Mozilla Firefox and Opera, plus any other browser that supports the full Document Object Model. The system is written in JavaScript, so doesn't require any browser plug-ins or downloads.

What do I need to run these pages from my web host?
Just some web space. Free space provided by ISPs is fine, although if your server supports the PHP programming language (most paid-for servers do, including Windows ones) you can use the PHP versions of the pages, which make organising your site much easier (see below for more details).

So does it mean that I don't need to author each game's web page individually?
Exactly. Create your standard game page once, then feed as many different games as you like through it.

Can I use the program code with my own graphics and web page design?
Absolutely. The system is designed to be 'skinnable', so you can use your own board and piece graphics (any size), and your own page design and styles. The bPod and Desktop designs shown above are just two examples of what can be done. I'd be happy to quote for custom page design work, although it would cost, as I do this for a living.

What types of backgammon files can it read?
Currently single-game .gam (Jellyfish), multi-game .mat (match files) and BGU Backgammon's text export formats (see the self-drive version for more details).  Other formats on request, although I don't fancy tackling GNU's .sgf format much. The system also has its own script file format (see below), and can read and generate its own dialect of XML.

Does it handle matches?
Yes. You can create .bgm files (essentially lists of game files). The PHP versions of the pages treat the game files listed in the .bgm as a match, automatically generating a menu page and letting the user step between games by pressing the << and >> buttons (see the 'Tom vs Jerry' match in the sample pages). Version 1.0.2 and later of the PHP pages also suport Jellyfish .mat files - just feed them in and the page creates the menu page automatically.

Do I need to edit the game files to make them playable in BG Replay?
No. The system will play them back exactly as saved by the backgammon program. GNU files must be saved (or renamed) with a .bgt name extension (e.g. "Game1.bgt"), but they're exactly the same as .txt ones (the .bgt files in the Tom vs Jerry match are unmodified GNU exports). The system automatically picks up player names and match scores from GNU export files.

I like the traditional, picture-per-move page design. And what about printing?
It does the traditional layout too, from the same game files (see image, right). These pages adjust their colours automatically for printing. Press the 'printer version' button in the desktop page to see an example.

How do I get commentary text and move/cube analyses in my game files?
Create them in GNU, and they're imported automatically from GNU text export files (TIP - GNU will export an entire match as a set of individual game files, just right for this purpose). Candidate moves in analysis tables are converted into demonstration links (try one in the sample pages). Commentary text is displayed as comments. An authoring version of the BG Replay desktop page will be available soon (I've just got to make it look presentable), which will allow you to add comments and other items to an imported script.

How did you do that Rules of Backgammon tutorial?
The script was written in BG Replay's own scripting language. This lets you set up positions (using GNU ID strings) then control the dice, cube, pieces and other display items directly. You can mix 'regular' game plays and tutorial sequences in a single script. All game files are converted to internal script format before running; try putting a .gam or GNU file through the self-drive version (above) and you can see the generated script at the bottom of the page.

Why isn't the script language based on XML?
Mainly because it's tricky to include HTML code in XML files, and you need to do that in order to format the text in comments. The system does support an XML dialect though (see the Self-Drive page for an example), so you can write scripts in XML if you want to.

Why do your sample pages use PHP?
The PHP pages used on this site save effort by allowing a single copy of each page to read any game script. PHP pages also handle .bgm match files automatically. If your web server doesn't support the PHP server-side programming language, you can embed your game files in 'static' versions of the pages instead. These pages can be run from any web server (e.g. AOL members' webspace) or directly from your PC's hard disk, CD-ROM etc.

Is BG Replay free?
For non-commercial use, yes. BG Replay and the bPod and desktop page designs are copyright software, but are free for use on non-commercial websites. If you want to use it on a commercial website, or distribute it with a commercial package, please contact me at . (Don't worry, I'm not looking to make a fortune, just to get a few quid back for the time I've spent on it!).

How do I get it?
I'm developing an issue pack as we speak, which will be available Real Soon Now. Please keep checking this page.

Backgammon is a tightly-knit world and I've never heard of you. Who are you?
My name's Paul Stephens and I'm not a very good backgammon player. I am, however, keen to learn, which is why I was trawling the web for backgammon tutorials (it's OK, I've bought a second-hand copy of Paul Magriel's book now), and discovering that none of them were animated. I decided to spend just a couple of hours seeing how hard it would be to animate a board in JavaScript, and it took off from there.

Was it really worth all that effort to design an animated backgammon page?
Of course not, but it was fun to do (I like programming) and I do think it adds something to the way backgammon can be presented on the web. My last fun JavaScript project was a jokey simulation of a satellite TV bingo channel, so I'm definitely heading upmarket with this one.