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.
To install, copy the PHP folder (bgrPHP) or HTML folder (bgrHTML) to your
server. Make sure the subfolders have been copied too.
Both versions contain bPod and Desktop page designs.
To run a game or script in the PHP version, copy the script to the scripts/
subfolder and call the page like this:
bpod.php?s=mygame.gam
bg.php?s=mygame.gam
To create a game page in the HTML version:
Save the appropriate template file (from the templates/ folder) as a new page in
the main folder.
Paste the game file contents into the source, in the <textarea> element where
you see the PASTE SOURCE HERE comment.
The PHP version also includes:
The self-drive page, which can be used to generate .bgg scripts from .gam and
GNU game files.
The printer page, which generates a traditional image-per-position page from a
game file or script.
er, that's it.
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 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:
<!-- PASTE YOUR .gam FILE CONTENTS IN THE TEXTAREA BELOW-->
<!-- MAKE SURE THERE ARE NO BLANK LINES BETWEEN THE <TEXTAREA> AND </TEXTAREA>
TAGS-->
<textarea class="stdtextarea" id="gamsource" rows="1" cols="20" >
</textarea>
Paste the contents of the .gam file into the space between the <textarea> and </textarea>
tags.
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]Instead of gameplay ([dice] and [move] tags), each play block contains a
[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]
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.bggThe 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.
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
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:
bgconfig_bpod.js (bPod)
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:
bgstyles.css (Desktop design)
bpod.css
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"> </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.