XMLGameEngine is a VGDL (video game description language) and an engine for running games completely contained within an XML file.
Status: Built: Checkers with a computer, marks, put back and the mouse; Reversi, Four in a Row, Tic-Tac-Toe, Dots and Boxes. Open: other board games, lookahead for action games. Reference: board games, thinking.
Turn games on cells. Maps of cells already knew which piece is where; missing were a way to say how a piece may move, and for a player to choose a piece and where it goes rather than steer it.
<moves> on a piece: <step>s and <jump class>es as cell offsets, <forced />, <promote sprite><row>. A move is data about the piece, like <poses>, not a verb; the engine works out what is legal. A set per look (<moves sprite="king">), so a king is a look.<promote> names a row, so each side writes its own.moves, so “no move on your turn loses” is an ordinary condition.<pick class> and <place /> are self verbs of a cursor using its cell. A refused verb ends its list, so <place /> then the turn’s change passes the turn only when a move is made. Whose turn it is is a variable and the cursor’s looks.<turns>-style word (that swaps whole games), crowning by a condition (conditions have no self), marking the held piece by its look (every piece would need held looks).<drop />, as on a carrier; refused once a run of jumps has begun.<marks> on the picker (held, moves, movable, last), worked out by the engine and drawn as copies on their own map; gated by look and by a variable, so an option on the title is a kept variable.<pick><only /> run by a condition.<track /> on cells; an axis trigger keeps its from=, so the mouse moves only the player’s cursor.from= is judged by the look when pressed, not as each trigger runs: one press could otherwise drop both sides’ discs.<put class> puts a copy of the first piece of the class written, so the board in the file is the start and the pieces are the supply.<moves> say decides where: <flank class> (Reversi: a line of the other class ended by one’s own), <fall /> (down a column), nothing (anywhere free), <on class> (in place of a piece of that class).<jump>, total= and <think> go by).moves. <count class into> gives a score.<line> check. Checks may not push a state, so a check sets a variable and a condition ends the game.<on class> (a line only on its place) and <close class object> (claims the boxes walled in; the put counts as refused so the turn does not pass). Each side’s lines are its own class.<onto class> on a hop or a track moves only between places of those classes, reading the map as rows like a text cursor. No rule of cell distances alone fits both across and down lines.<think> copies the board into a small table and searches with negamax and alpha-beta, depth 4 by default, by the pieces’ own <moves>. It presses keys as a person would, walking the picker, so the game’s own actions do the move. Its own key and cursor looks keep the player out of its turn.<worth sprite> hint); a side with no move loses (or passes in games of puts); a <line> check is a win, and short of that each open run is worth its pieces squared; a closing put keeps the turn.CellsStill). In games of claims, a quiet put (touching nothing) is searched once and its fellows count as equal; used only for claims, not for lines, where corners and edges differ.<computer> conditions with no search; a paddle at the top must not reach a corner-to-corner ball.<onto> for Checkers’ and Reversi’s cursors; draws by repetition or forty quiet moves.