Chessforeva for Web developments

Disclaimer:

 

This thing is old. Someday will rewrite. Not now. Read as it is.

You can freely copy chessforeva.gitlab.io and make a good site anywhere.

Or simply use the online version. The instruction is a reminder for me - how it's made.

 

So, anyway...

Instructions and usage:

 

Put this code in Your html in body section in the beginning:

Add c0_chess.js main javascript code by copy/paste this:

<script src="https://chessforeva.gitlab.io/c0_chess.js" type="text/javascript"></script>

Add c0_pgn.js functions only for FEN or PGN level (described later):

<script src="https://chessforeva.gitlab.io/c0_pgn.js" type="text/javascript"></script>

That includes chess javascript library, prepares workspace, declares necessary variables.
Now You may access it and create the board.
Put this code in Your html where it should be:

<script type="text/javascript">

c0_initall();

This created variables and prepared some elements.

c0_relative_size_procents=120;

The chess board can be re sized before it appears in the document. Just adjust relative size.

Or set c0_relative_size_procents=0 for automatic adjustment.

var c0_at_top=120;

var c0_at_left=20;

The chess board can be re positioned before it appears in the document. Just adjust left top corner (points px).

c0_side=1;

Which side is closest to us. 1 for white, -1 for black. Default setting is 1

c0_waitmove=false;

That variable means "do nothing" for state false (default setting). If true is adjusted then the page viewer is able to make a move by moving piece by mouse. Then additional programming is needed. It isn't so simple and some code is at Chessforeva.

c0_sidemoves=1;

Which side moves. 1 for white, -1 for black. Default setting is 1

c0_art=false;

There is art style (for true) implemented also in the code


You may also disable zooming by setting

c0_zoom=false;

Otherwise users may press zoom in/out buttons that are visible by default.

 

c0_cookies = false;
To disable board and other windows position to be saved into cookies.

 

You may set the initial top-view mode (default = true), or side-view.

c0_topview=false;

If zooming allowed, users can press button to switch modes. Art style then is ignored.

c0_board_letter=false;

This option removes letters A-H, 1-8 from the sides of the chess board. Use before initial drawings.

c0_draw_empty_board();

This draws empty board in Your page. The first drawing.

c0_draw_2D_board();

For better visibility 2D chess board in corner should be displayed. Or just don't use this function if that feature is no needed.

c0_set_start_position( "" );

The pieces should be displayed using this function. If the parameter omitted ("") then the state is the beginning of game. The variable c0_moveslist is set to empty.
The syntax for moves list: e2e4e7e5g1f3........e1g1[0]....a7a8[Q]....h2h1[R]....
e1g1[0] is 0-0
e1c1[0] is 0-0-0
a7a8[Q] is white Queen promoted on a8
h2h1[R] is black Rook promoted on h1

So, You can compose first moves and use it in parameter. c0_moveslist always contains the list after.

That's all for simple publishing purposes.

There are also other variables that can be used for advanced programming:

c0_position

Contains current chess position on board.
For example: wpa2;wpb2;wKg1;bKh8;bQg7

c0_wKingmoved,c0_bKingmoved,c0_wLRockmoved,c0_wRRockmoved,c0_bLRockmoved,c0_bRRockmoved,c0_w00,c0_b00

These variables are flags-indicators. For example c0_w00=true means that the white side has done castling before. Rock is Rook, "c" looks like incomplete "o" :D

c0_lastmovepawn

This contains number (1-8) of pawn ready for "en passant" capture.

For very advanced programmers there is possible to create DIVs that can be moved by user. Define them in c0_DV_list

Syntax: c0_DV_list="[ElementTargetId1]{DivToMoveId1};[ElementTargetId2]{DivToMoveId2}..."

There can be additional features developed in these DIVs like chess clock, position viewers, etc...

Samples of more complex usage should be obtained from the source code of chessforeva sites listed before.

Move pieces by using

c0_move_to( "e2", "e4" );

Don't forget to set up and clear after each move these variables

c0_become_from_engine="";c0_become="";

These variables manage information about which piece should be promoted (if needed) and last piece promoted on board.

Movement without changes on screen:

c0_move_to( c0_moveto(c0_convH888("e2"), c0_convH888("e4"), false);

If something more internal needed.

c0_take_back();

This function uses c0_moveslist variable to return one move before.

The programming is possible by using timer/mouse/keyboard events and javascript callback function which is called after each move of any piece on board, defined in

c0_moved_callback

For connecting purposes, use Ajax calls on events to web-servers. Ok, it's slow, but possible.
If the code is needed then just download it from the original site.

There are some internal functions that can be used. Of course, the chess logic may be corrupted. It's better to use function c0_set_start_position

c0_add_piece("wpe4");

This places white pawn on e4. Use K,Q,R,B,N for other pieces.

c0_clear_at("e4");

Remove piece if there is on e4. These functions should be connected with variables that describe current position, moves, etc.

There are functions related to chess logic available.

You can set any position on board and detect status after each move.

c0_set_board_situation

Parameters: 1.list of pieces ("wKe1;bKe3;wNe2"), 2.-5. status for white (king has moved flag, left rook has moved, right rook has moved, there was castling before), 6.-9. (the same for black, just left is on A8), 10. en passant  (0-none, 1-A,..,8-H vertical),  11.previous moves, if important, 12. which side moves 1/-1 (white/black);

Status detection functions:

c0_D_is_empty("e4")

c0_D_is_emptyline("a1","h8")

If piece is on a1 and wish to move h8 then this function returns true if b2, c3, d4, e5, f6, g7 are empty. For h8 and a1 use other detection functions. Returns true/false.

c0_D_is_check_to_king("w")
c0_D_is_mate_to_king("w")



c0_D_is_stalemate_to_king("w")



For white king use "w" parameter to detect it's status, "b" for black.

c0_D_can_be_moved("h1","h8")

Test for a possible move can be performed any time. Returns true/false.

c0_D_is_enemy("e5", "w")

If a white pawn stays on f4 then this function detects enemy on e5 and returns true.

c0_D_what_at("a4")

Function returns what's on a4. For example: "wK" (white King), "bp" (black pawn), or "" (empty).

c0_D_last_move_was()

The same as "take the tail" of variable c0_moveslist to get last move.

c0_get_next_moves()

This function returns next possible moves for current position as a list in string variable. This is much faster than looking for pieces on board at A1-A8-...-H8. You may set, if needed, two validator-functions (written by You) which should be called in loops.

c0_f_evals1() - when just found new move in variable c0_foundmove;

c0_f_evals2() - make this move internally (bit slower), and than evaluate;

Find moves possible and analyze them for best. ;)

This function can't be used recursively. The Silly chess is based on it, as example.

The sample for detection and various advanced functions is here.

Use browser's source viewer to get the code.

c0_pgn.js functions

Some of these functions may be useful.

c0_set_FEN( FEN string );

To set up position according to the chess standards of saved position (FEN).
c0_get_FEN();

To get position as a FEN string.

You should set (or ignore) after the variable c0_moveslist. This standard doesn't care about previous moves. Anyway, it may be important internally.

Chess standard of portable game notation (PGN) is supported.

c0_get_from_PGN( PGN string );

Returns a whole list of moves as a string, if moves are possible and PGN is valid. On error variable c0_errflag is set to true.

Internal array c0_PGN_header contains all the header items.

Internal variable c0_start_FEN remembers the startup pusition, if FEN tag is used in PGN header. Clear it by c0_start_FEN="" for other game.

c0_put_to_PGN(moves);

Returns a generated PGN as a string from variable moves.

Predefined array c0_PGN_header is used to generate header. On error variable c0_errflag is set to true.

In case of c0_put_to_PGN("") variable c0_moveslist is used.

For startup positions (FEN as header item) all drawings should be performed.
Standard cases do not require chess board on screen.

The demo for PGN functions is here.

Also new functions added jan.2021, chess games can be prepared as javascripts in a very short notation - one symbol for one piece move. See helper project https://gitlab.com/chessforeva/pgn2web

c0_short2list() 

Converts short notation to c0_moveslist

 

c0_short2PGN(PGN_txt)

 

Converts short notation to pgn.

Using in TWIC 2014-2020 chess tournaments 3D viewer for all main GM chess tournaments.

Fischerrandom is supported from June 2010.

Castling works well on replay modes for now.

There are 2 interal variables containing all data:

c0_fischer;

c0_fischer_cst;

10x8/other specific chess rules are NOT supported in standard c0_chess.js, c0_pgn.js libraries. Classical chess only! Or advance this code as You like.

...

And, of course, close the javascript section at the end of chess code:

</script>

Demo for interactive Chessforeva code in frame

(use mouse for activity)