piecepackr: Board game graphics

Dice

2023-03-20T00:00:00-07:00

Contents

Traditional six-sided pipped dice
Polyhedral dice
Fudge/Fate dice
Piecepack dice
Chess dice
Custom dice

piecepackr comes with built-in configurations for a variety of dice via the game_systems() function.

Traditional six-sided pipped dice

Note

Chinese dominoes were introduced in piecepackr v1.13.

The dice configuration provides standard pipped dice in six colors with the suit controlling the color and the rank controlling the number of pips [1]. The dominoes_chinese and dominoes_chinese_black configurations provide Asian-style dice (and Chinese dominoes). dominoes_chinese has a white background with black and red pips while dominoes_chinese_black has a black background with white and red pips.

library("piecepackr")
envir <- game_systems()
grid.piece("die_face", suit = 1:6, rank = 1:6, cfg = envir$dice,
           x = 1:6, y = 1, default.units = "in", op_scale = 0.5)
grid.piece("die_face", suit = 1:6, rank = 1:6,
           cfg = rep(c("dominoes_chinese", "dominoes_chinese_black"), length.out = 6), envir = envir,
           x = 1:6, y = 2, default.units = "in", op_scale = 0.5)

Traditional pipped dice (Western and Asian-style)

[1]	The die pieces in other configurations such as the various “dominoes” configurations may also contain standard six-sided dice when appropriate.

Polyhedral dice

Note

The polyhedral dice were introduced in piecepackr v1.13.

The dice_d4, dice_numeral, dice_d8, dice_d10, dice_d10_percentile, dice_d12, and dice_d20 configurations provide the seven polyhedral dice most commonly used by wargames, roleplaying games, and trading card games in six colors controlled by suit.

library("piecepackr")
envir <- game_systems()
grid.piece("die_face", suit = c(1:6, 1), rank = 1:7,
           cfg = paste0("dice_", c("d4", "numeral", "d8", "d10_percentile", "d10", "d12", "d20")),
           envir = envir, x = 1:7, y = 1, default.units = "in", op_scale = 0.5)

Polyhedral dice

Fudge/Fate dice

Note

The Fudge dice were introduced in piecepackr v1.11.

The dice_fudge configuration use the six-sided Fudge dice with two plus, two minus, and two blank faces most commonly used in the Fudge and Fate roleplaying games.

library("piecepackr")
grid.piece("die_face", suit = 1:6, rank = 1:6, cfg = game_systems()$dice_fudge,
           x = 1:6, y = 1, default.units = "in", op_scale = 0.5)

Fudge dice

Piecepack dice

Note

The inverted piecepack was introduced in piecepackr v1.10.

The piecepack, dual_piecepacks_expansion, playing_cards_expansion, and piecepack_inverted configurations provide piecepack dice [2].

library("piecepackr")
envir <- game_systems("dejavu")
cfg <- rep(c("piecepack", "dual_piecepacks_expansion", "playing_cards_expansion", "piecepack_inverted"), each = 4)
grid.piece("die_face", suit = rep(1:4, 4), rank = 2,
           cfg = cfg, envir = envir,
           x = rep(1:4, each = 4), y = rep(1:4, 4),
           default.units = "in", op_scale = 0.5)

Piecepack dice

[2]	There are also piecepack dice in the `hexpack` and `subpack` configurations but these are just small versions of the `piecepack` dice.

Chess dice

Note

The chess1 and chess2 configurations were introduced in piecepackr v1.6.

The chess1 and chess2 configurations provide chess dice.

library("piecepackr")
envir <- game_systems("dejavu")
grid.piece("die_face", suit = 1:6, rank = 1:6,
           cfg = envir$chess1, x = 1:6, y = 1,
           default.units = "in", op_scale = 0.5)

Chess dice

Custom dice

piecepackr allows for custom six-sided dice. One can use configurations and custom grob functions to customize the faces of the dice and use the die_arrangement configuration to customize the ordering, rotation, and size of the faces when visualized in a 3D projection or arranged in a Print & Play layout.

Licenses FAQ

2020-11-28T00:00:00-08:00

This article contains some of my thoughts and opinions on piecepack game licenses. Note however that I am not a lawyer and this should not be construed as legal advice. Also, as I am a citizen of the United States, these opinions are heavily informed by American law and may be poorly suited for residents of other countries.

Warning

I am not a lawyer. My legal opinions should not be construed as legal advice.

Contents

How can I protect the intellectual property in my piecepack game?
What license should I use for my piecepack game?
Can I offer individuals more than one choice of licenses they can use?
Why is the CC BY-SA 4.0 license better than the GFDL?
piecepackr is licensed under the MIT license, is its output automatically MIT licensed too?
Footnotes

How can I protect the intellectual property in my piecepack game?

In the United States there are four forms of protection for piecepack games:

Technically games may be protected by utility or design patent. However patenting a game using just the piecepack components may no longer be possible after the Alice Corporation Pty Ltd. v. CLS Bank Int’l decision which made it harder to patent mere ideas (e.g. see Ex Parte Kuester).
Copyright does not offer much protection for board games:

Copyright does not protect the idea for a game, its name or title, or the method or methods for playing it. Nor does copyright protect any idea, system, method, device, or trademark material involved in developing, merchandising, or playing a game. Once a game has been made public, nothing in the copyright law prevents others from developing another game based on similar principles. Copyright protects only the particular manner of an author’s expression in literary, artistic, or musical form.

However

Material prepared in connection with a game may be subject to copyright if it contains a sufficient amount of literary or pictorial expression. For example, the text matter describing the rules of the game or the pictorial matter appearing on the gameboard or container may be registrable.
Elements of a board game may be protected by trademark

As noted above, game names are an obvious option for trademark protection, but game designers and publishers have also sought to register and protect trade dress in game board designs, distinctive card layouts, and even game tokens.

I’m not sure though how much effective trademark protection is actually provided for a game using public domain piecepack components especially if it is being offered for free download and isn’t being sold commercially. How much protection is there for new card games playable with a standard deck of playing cards or for chess variants?
Although not enforceable by American law, probably the most effective form of protection against piecepack game “theft” are actually the norms within the piecepack community in particular and more broadly the board game (designer) community against “stealing” (other designers’) games. This form of IP is similar to how comedians protect their jokes and magicians protect their tricks. This means that although piecepack games can generally be legally cloned (e.g. see the court case of Bang! versus Legends of the Three Kingdoms) such cloning may likely be rare since it violates community norms and would likely be socially sanctioned.

What license should I use for my piecepack game?

If you want individuals to be able to do whatever they want with your game choose the Creative Commons CC0 1.0 Universal Public Domain Dedication (CC0 1.0) [1]. If you want to be very permissive about what individuals can do with your game, but want them to give you credit then choose the Creative Commons Attribution 4.0 International license (CC BY 4.0). If you want individuals who adapt your game to have to give their users the same freedom you gave them then choose the Creative Commons Attribution-ShareAlike 4.0 International license (CC BY-SA 4.0).

Why not use a license with a non-commercial clause?

It prevents certain use cases without offering much more protection from commercial explotaition than a “copyleft” “ShareAlike” license and does not actually legally prevent all scenarios where individuals may “profit” from the work:
- http://www.opensourcejahrbuch.de/download/jb2006/chapter_06/osjb2006-06-02-en-moeller.pdf
- https://creativecommons.org/2017/02/24/update-great-minds-v-fedex-office-litigation-involving-nc-sa/
- Note most piecepack games can generally be legally “cloned” regardless of chosen license (at least in the United States) so in particular a “noncommercial” license does not offer much protection in our specific use case.
What exactly non-commercial means is not well defined:
- https://www.cnet.com/news/does-the-noncommercial-creative-commons-license-make-sense/
- https://wiki.creativecommons.org/wiki/Defining_Noncommercial
Certain free culture distribution channels (like free software repos) refuse to distribute media with a non-commercial clause, so your game is less likely to be included in a collection of good free culture piecepack games.

Why not use a license with a no-derivatives clause?

Given that most piecepack games can generally be legally “cloned” regardless of chosen license what is your goal in preventing derivatives? In particular what is the harm discouraging your game being translated into another language for players who don’t know English, it being enhanced with additional diagrams, or it being converted into a pamphlet that can be distributed at a game convention or library?
Note however though a Creative Commons license with a no-derivatives clause is better than the default “All Rights Reserved” since it allows the game to be preserved and shared by third parties (such as the piecepack wiki) so is to be recommended for game designers who really don’t want to use a more permissive license (even if “copyleft”).

Why not use a custom license?

People do not like spending time trying to understand a custom license.
Custom licenses are often ambiguous or contain legal mistakes. In particular with custom licenses in old piecepack games, it is often not clear whether derivatives are allowed at all.
Custom licenses are often not compatible with other free cultural work licenses.

Why not use an earlier Creative Commons license?

The 4.0 branch of Creative Commons license are the latest and greatest Creative Commons licenses and incorporates wisdom learned implementing the earlier licenses.
In particular with CC BY-SA 4.0 has a very forward-looking ShareLike compatibility mechanism that greatly simplifies future license compliance when combining assets from “compatible” licenses since users only need to comply with the terms of the last license applied instead of needing to read and comply with every license in the “license stack”:
- https://wiki.creativecommons.org/wiki/ShareAlike_compatibility
This means your game is more likely to stay relevant decades into the future.

Can I offer individuals more than one choice of licenses they can use?

Yes, this known as multi-licensing. In the common case of offering exactly two license choices this is known as “dual-licensing”. Dual-licensing an old piecepack game under a modern Creative Commons license can be done after the fact by a declaration by the author without manually editing all the old games. Technically under American law any author of a jointly authored game can unilaterally dual license their game under a Creative Commons license. [2]

Why is the CC BY-SA 4.0 license better than the GFDL?

Both the Creative Commons Attribution-ShareAlike and the GNU Free Documentation License (GFDL) licenses are Free Cultural Works copyleft licenses [3]. Why is the GFDL license more of a hassle to work with than the CC BY-SA 4.0 license?

Lets consider the following use case, a fan wants to adapt your ruleset by adding some illustrations, condensing it into a easy to handout one-page leaflet, and then hand out 101 copies for free at a local game convention (maybe translating into the local language). Here is a table of some requirements that are more of a hassle with the GFDL license than the CC BY-SA 4.0 license:

Leaflet adaption requirements
GFDL	CC BY-SA 4.0
They must include the text of the entire GFDL license in the leaflet. [4] Note that GFDL v1.3 is 3,691 words long and such a leaflet may need to devote more space to the license than your game…	One may include a URI (hyperlink) to the CC BY-SA 4.0 license instead of the full text of the license. [5]
Beginning of the leaflet cannot be the name of the game (assuming you put the name of the game on top of your ruleset). [6]	Putting the name of the game at the top of the leaflet is fine.
They must either bundle with each single-page leaflet a physcial copy of the electronic source (e.g. attach a flash drive or burnt CD to each single-page leaflet) or include a link to a website with the electronic source that they must keep up for at least one year after the convention. [7]	No legal need to offer electronic source but may not apply any “Effective Technological Measures” to make it hard to copy/modify the leaflet. [8]

piecepackr is licensed under the MIT license, is its output automatically MIT licensed too?

Although the code of piecepackr is licensed under the MIT license under American law the graphical output will probably either be the copyright of the creator or not sufficiently creative to warrant copyright protection. In general under American law copyright is assigned to the software user and not the software program (which as an algorithm is not considered a creative agent). However there may be conditions where the graphical output of piecepackr is protected by someone else’s copyright (or trademark):

Although the copyright protection of typefaces varies internationally, under American law typefaces cannot be protected by copyright but software fonts can be protected by copyright. In a couple of graphic devices (in particular cairo_pdf) piecepackr will embed copyrightable font software into the resulting image. For example in the chess demo I had to get written permission from the author, Hans Bodlaender, to use the Chess Utrecht font in one of my designs.
It is possible with a custom grob function to embed images, depending on which images you embed you could easily fall afoul of copyright/trademark law. The Triactor demo is an example of embedding images in a game diagram which required me to comply with the CC BY-NC-SA 2.0 license of the Triactor rule set.
piecepackr‘s configuration (especially with custom grob function) is sufficiently flexible that one could configure and use a board game design that is protected under someone else’s copyright/trademark. For example the spin-off package piecenikr generates images for Looney Labs’ patented and trademarked Looney Pyramids game system.

Note that the piecepackr‘s built-in configurations returned by the game_systems() command should avoid any of these potential issues:

Uses fonts which should allow you to embed them in images/documents without even requiring attribution.
Does not embed any outside copyrighted images. [9]
Only contains public domain game systems (which should not suffer from copyright / trademark issues).

Footnotes

[1]	Not all countries recognize dedicating into the public domain, the CC0 acts as a “public domain equivalent license” in such jurisdictions.

[2]	This is not true in all countries, for example in the United Kingdom all joint authors must agree to dual-license a rule set.

[3]	Assuming the GFDL work doesn’t have any invariant sections (and zero of the piecepack games released under the GFDL have an invariant section).

[4]	“you must do these things in the Modified Version… Include an unaltered copy of this License.”

[5]	“You must include the text of, or the URI or hyperlink to, the Adapter’s License You apply.” (emphasis mine)

[6]	“you must do these things in the Modified Version: … Use … a title distinct from that of the Document”

[7]

“you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.”

[8]

“You may not … apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter’s License You apply.” Merely printing a CC BY-SA work on paper is not considered to be an “Effective Technological Measure” but deliberately using “security printing” technology like “simulated watermarking” to make it harder to photocopy/scan a document may qualify.

[9]

The outline for meeple shape used in the “meeples” configuration (also used in some face cards in the playing cards) was extracted (converted into a dataset of normalized x, y coordinates) from Meeple icon by Delapouite / CC BY 3.0. Since “simple shapes” nor data can be copyrighted under American law this meeple outline is not copyrightable in the United States. However, in other legal jurisdictions with stricter copyright laws you may need to give the proper CC BY attribution if you use any of the meeples.

Essential elements of a piecepack

2020-11-15T00:00:00-08:00

In 2001 James “Kyle” Droscha invented the piecepack and laid out a “prescriptive” Anatomy of a Piecepack standard with design decisions further described in a FAQ. As others have noted, there are several piecepack designs that do not strictly follow the prescriptive “Anatomy of a piecepack” standard but it is still possible to play most piecepack games with them anyways. This begs the question: “What are the essential elements of a piecepack?”.

Contents

Essential information sets of a piecepack
Footnotes

Essential information sets of a piecepack

Here is my opinion of the essential elements of a piecepack [1]:

4 “suits” and 6 “ranks” [2]
24 square “tiles” (one for each pairing of suit and rank) [3]
- The “face” of the tile reveals its suit, rank, and direction [4]
- The “back” of the tile hides its suit, rank, and direction [5]
24 circular “coins” (one for each pairing of suit and rank) [6]
- The “face” of the coin reveals its rank and direction while hiding its suit [7]
- The “back” of the coin reveals its suit and direction while hiding its rank
- Must fit within a quarter of a tile
4 “pawns” (one for each suit)
- Each pawn reveals its suit
- Each pawn may (but need not) reveal a direction
- Must fit within a quarter of a tile
4 dice (one for each suit)
- The 6 “ranks” are mapped onto the six “faces” of each die and each “face” reveals the suit and rank [8]
- One may (but need not) make the direction of the die obvious [9]
- Must fit within a quarter of a tile [10]

Footnotes

[1]

Note although adhering to the below information sets will make it possible to play any piecepack game, having your piecepack more closely adhere to the Anatomy of a Piecepack standard may lead to better ergonomics with existing piecepack games (e.g. themes will match, there may be less hassle mapping game rulesets to your piecepack, etc.).

[2]	Additional suits and/or ranks are fine and descriptively not uncommon.

[3]	Hexagonal “tiles” (and triangular “coins”) leads to a Hexpack, a related game system.

[4]

Descriptively not all piecepack designs reveal an unambiguous direction on every tile face. However, the arguably the most popular piecepack game, Alien City, depends on the tile faces having an unambiguous direction. In particular since the Anatomy of a piecepack standard indicates direction by placing a suit symbol in the upper left corner of each tile face Alien City is best played on piecepack tiles with a specially marked corner on each tile face. Additionally, descriptively some piecepack designs have tile faces that reveal multiple directions.

[5] Descriptively, although all piecepack tile backs hide suit and rank, many piecepack design tile backs do not fully hide direction (i.e. they have “checkered” backs which “leak” information about the direction of the front). However any piecepack that follows the Anatomy of a piecepack standard will have tile backs which hide the direction of the front while visually dividing the piece into four quadrants via a +.

[6]	There exist dexterity games that assume a circular game piece (for multidirectional flicking). Circular game pieces may also be used to play hexagonal games.

[7]	Descriptively some piecepacks have coin faces that do not hide the suit but this generally seems to be regarded as a mistake. However extra game pieces that reveal both suit and rank are a “common accessory” (e.g. piecepack pyramids or the tiles from a matching “mini” piecepack)

[8]	Technically in the Anatomy of a Piecepack standard the “null” face is completely blank and one needs to infer its suit by looking at the sides of the die.

[9]	Unlike some piecepack pawns which may not have a “direction”, one may always assign a “direction” to a piecepack die i.e. the direction of the highest ranked die side.

[10]	This requirement is not in the standard but instead is suggested in James “Kyle” Droscha’s piecepack design FAQ. However, descriptively all piecepack designs seem to comply with this, some piecepack games depend on this, and practically speaking a die would need to be unusually large to not comply.

Go

2020-09-03T00:00:00-07:00

Version 1.5.2 of piecepackr comes with built-in configurations for Go boards and stones in a variety of colors and sizes via the game_systems() function. Here is an example diagram for a game of Multi-player go:

library("ppdf")
library("piecepackr")

stopifnot(packageVersion("ppdf") >= "0.2.0-13",
          packageVersion("piecepackr") >= "1.15.0-9")

dfb <- go_board()
dfB <- go_bits(suit = "blue",
               x = c(2,2,2, 3,3, 4,4, 5,5, 6,6,6, 7,7, 8),
               y = c(11,13,14, 12,15, 13,16, 12,16, 12,13,16, 15,17, 16))
dfR <- go_bits(suit = "red",
               x = c(3,3, 4, 5, 6, 7, 8,8, 9),
               y = c(2:3, 4, 3, 4, 4, 2:3, 2))
dfY <- go_bits(suit = "yellow",
               x = 20 - c(3, 4, 5,5, 7, 8, 9,9,9),
               y = 20 - c(3, 2, 2:3, 2, 5, 2:4))
dfG <- go_bits(suit = "green",
               x = 20 - rep.int(3:6, times = c(5L, 4L, 3L, 2L)),
               y = c(4,5,7,12,13, 6,7, 10,11, 7,9,10, 8,9))
dfK <- go_bits(
    suit = "black",
    x = rep.int(2:17,
                times = c(5L, 5L, 4L, 5L, 2L, 4L, 7L, 5L, 5L, 4L, 5L, 6L, 2L, 6L, 6L, 2L)),
    y = c(2:3,8:9,12, 4:5,10,13:14, 5,10,14:15, 6,8,10:11,14, 5,11,
          5,7,12,14, 4,7,9,11:13,15, 3:4,11,14,16, 8:9,14:16,
          3,6,8,15, 9:11,16,18, 6,8:9,11:12,16, 6:7,
          5:6,8,11:12,16, 3,5,12,14,16:17, 3,16)
)
dfW <- go_bits(
    suit = "white",
    x = rep.int(3:14,
                times = c(1L, 1L, 1L, 3L, 3L, 2L, 5L, 3L, 4L, 4L, 2L, 1L)),
    y = c(9,9,9, 7:8,10, 8,10:11, 8,10, 8:10,12:13, 10:11,13,
          9,11,13:14, 7:8,12:13, 7,10, 11)
)
df <- rbind(dfb, dfB, dfR, dfY, dfG, dfK, dfW)

envir <- game_systems(shading = TRUE, background_color = "burlywood")
pmap_piece(df, envir = envir, default.units = "in")

2D Multi-player Go diagram

Relativity

2020-05-08T00:00:00-07:00

Relativity is a piecepack game by Ron and Marty Hale-Evans. It is a two-player abstract game with interesting movement mechanics. Being able to distinguish ranks is important while being able to distinguish suits is not important so a piecepack design optimized for playing this game may consider coloring ranks instead of suits.

library("piecepackr")
library("ppn")
cfg <- as.list(game_systems("dejavu")$piecepack)
cfg$suit_color <- "black"
cfg$background_color.r1 <- "#E69F00"
cfg$background_color.r2 <- "#56B4E9"
cfg$background_color.r3 <- "#009E73"
cfg$background_color.r4 <- "#F0E442"
cfg$background_color.r5 <- "#D55E00"
cfg$background_color.r6 <- "#F079A7"
cfg <- pp_cfg(cfg)

ppn_file <- system.file("ppn/relativity.ppn", package = "ppn")
game <- read_ppn(ppn_file)[[1]]
animate_game(game, file = "relativity.gif", annotate = FALSE,
             cfg = cfg, trans = op_transform, op_scale = 0.5,
             n_transitions = 5, n_pauses = 2, fps = 9)

Animation of a round of a game of Relativity

Looney Pyramids

2020-03-30T00:00:00-07:00

Contents

Intro
Martian Chess

Intro

Looney Pyramids aka Icehouse pieces is a game system invented by Andrew Looney. The following are good sites of information about Looney Pyramids:

https://www.looneylabs.com/looney-pyramids (official site)
https://www.icehousegames.org/wiki/index.php?title=Main_Page (unofficial wiki)

The package piecenikr provides a looney_pyramids() function that provides an icehouse_piceces configuration to make Looney Pyramids graphics with piecepackr.

library("piecepackr")
library("piecenikr")
library("tibble")
cfg <- looney_pyramids()$icehouse_pieces

dft <- tibble(piece_side="tile_back", x=1.5, y=1.5, suit=NA, rank=NA, angle=NA)
dfp <- tibble(piece_side=c("pyramid_face", "pyramid_left", "pyramid_right", "pyramid_back"),
             x=c(1,2,2,1), y=c(2,2,1,1), suit=1:4, rank=c(1:3,3), angle=seq(90, 360, 90))
df1 <- rbind(dft, dfp)

dft <- tibble(piece_side="tile_back", x=3.5, y=3.5, suit=NA, rank=NA, angle=NA)
dfp <- tibble(piece_side="pyramid_top", x=2+c(1,2,2,1,1,2,2,2), y=2+c(2,2,1,1,1,1,1,1),
             suit=c(1:6,2,3), rank=c(1:3,3,1,2,1,1), angle=seq(0, 630, 90))
df2 <- rbind(dft, dfp)
df <- rbind(df1, df2)

pmap_piece(df, grid.piece, cfg = cfg, default.units = "in")

Looney Pyramids (2D)

Martian Chess

Here are some example 4-player setup diagrams for Andy Looney’s game Martian Chess drawn in various projections using piecenikr and piecepackr.

library("piecepackr")
library("piecenikr")

df <- piecenikr::df_martian_chess(n_players = 4, seed = 42)
envir <- c(game_systems(), looney_pyramids())

pmap_piece(df, envir=envir, default.units="in", trans=op_transform)

Setup for Andy Looney’s Martian Chess (2D)

pmap_piece(df, envir=envir, default.units="in", trans=op_transform,
           op_angle = 90, op_scale=0.5)

Setup for Andy Looney’s Martian Chess (3D oblique)

envir <- c(game_systems("sans3d"), looney_pyramids())
library("rgl")
open3d(silent = TRUE)
bg3d("white")
if (Sys.which("wmctrl") != "") system("wmctrl -r RGL -e 0,-1,-1,1080,1080")
view3d(phi=-30, zoom = 0.8)
pmap_piece(df, piece3d, envir=envir, trans=op_transform)

Setup for Andy Looney’s Martian Chess (3D rgl)

Checkers

2020-02-19T00:00:00-08:00

Version 1.3 of piecepackr comes with built-in configurations for checker boards and checkers in a variety of colors and sizes via the game_systems() function. The boards for the checkers1 configuration has 1” cells and the checkers2 configuration has 2” cells. Number of rows/columns is controlled by the board component’s rank and the color of the board and checker bit components are controlled by the suit. The face of the board has checkers and the back has lines. Here is an example of the setup for Dan Troyka’s game Breakthrough as well as Robert Abbott’s game Crossings.

library("piecepackr")
library("ppdf")

stopifnot(packageVersion("ppdf") >= "0.2.0-13",
          packageVersion("piecepackr") >= "1.15.0-9")

df_board <- checker_board()
df_w <- checker_bits(suit = "white", x = rep(1:8, 2), y = rep(1:2, each=8))
df_b <- checker_bits(suit = "red", x = rep(1:8, 2), y = rep(7:8, each=8))
df <- rbind(df_board, df_w, df_b)

envir <- game_systems()
pmap_piece(df, envir=envir, default.units="in", trans=op_transform, op_scale=0.5)

Setup for Dan Troyka’s Breakthrough as well as Robert Abbott’s Crossings

Dominoes

2020-02-16T00:00:00-08:00

Contents

Western dominoes and dice
Chinese dominoes and dice

piecepackr comes with built-in configurations for double-18 dominoes in six color schemes as well as Chinese dominoes in two color schemes via the game_systems() function.

Western dominoes and dice

Note

Double-12 dominoes were introduced in piecepackr v1.3 and were extended to double-18 dominoes in v1.9.

There are seven dominoes configurations: dominoes, dominoes_black, dominoes_blue, dominoes_green, dominoes_red, dominoes_white, and dominoes_yellow with the “rank” controlling the number of pips on the “top” side and the “suit” controlling the number of pips on the “bottom” side. Currently there is no difference in appearance between the dominoes and dominoes_white configurations returned by game_systems() [1]. The dice configuration provides standard six-sided dice with the suit controlling the color and the rank controlling the number of pips [2]. Here is an example diagram:

library("piecepackr")
library("grid")
library("tibble")

envir <- game_systems()
df_dominoes <- tibble(piece_side = "tile_face",
                      x=rep(4:1, 3), y=rep(2*3:1, each=4),
                      suit=1:12, rank=7:18+1,
                      cfg = paste0("dominoes_",
                                   rep(c("black", "red", "green", "blue", "yellow", "white"), 2)))
df_dice <- tibble(piece_side = "die_face", x=6, y=0.5+1:6, suit=1:6, rank=1:6, cfg="dice")
df <- rbind(df_dominoes, df_dice)
pmap_piece(df, default.units="in", envir=envir, op_scale=0.5, trans=op_transform)

Double-18 dominoes and standard 6-sided dice

[1] Semantically the “dominoes” is meant to represent a more general notion of a dominoes set. game_systems() implements it as a dominoes set with black pips on white tiles but users could theoretically replace it with alternative dominoes set implementations such as tiles with colored numbers. Semantically the various colored dominoes sets are meant to be visually distinct with each other and to visually match the pieces from other game systems-in particular the piecepack game Japan assumes two different double-6 dominoes sets that match two of the piecepack suits.

[2] Technically, each of the dominoes configurations also has matching six-sided “die” pieces. These are equivalent to the pipped six-sided dice in dice when using the configurations returned by game_systems(). However semantically they need not be equivalent e.g. if you had a modified “dominoes” configuration with colored numbers instead of pips and also updated its “die” pieces to also use colored numbers instead of pips then these dice may no longer match the dice from the “dice” configuration.

Chinese dominoes and dice

Note

Chinese dominoes were introduced in piecepackr v1.13.

The configurations dominoes_chinese and dominoes_chinese_black provide Chinese dominoes and Asian-style dice. dominoes_chinese has a white background with black and red pips while dominoes_chinese_black has a black background with white and red pips.

library("piecepackr")
library("tibble")

df1 <- tibble(piece_side = "tile_face",
              suit = c(rep(1, 6L), 2L, rep(2, 4L), rep(3, 3L), 3, rep(4, 3), 5, 5, 6),
              rank = c(1:6, 2L, 3:6, 3:5, 6, 4:6, 5:6, 6),
              cfg = rep(c("dominoes_chinese", "dominoes_chinese_black", "dominoes_chinese"),
                        each = 7L),
              x = rep(1:7, 3L),
              y = c(rep(c(1.5, 4.0, 6.5), each = 7L)))
df2 <- tibble(piece_side = "die_face",
              suit = 1, rank = 1:6,
              cfg = rep(c("dominoes_chinese", "dominoes_chinese_black", "dominoes_chinese"),
                        each = 2L),
              x = 8.5, y = c(1, 2.25, 3.5, 4.75, 6.0, 7.25))
df <- rbind(df1, df2)

pmap_piece(df, envir = game_systems(), default.units = "in",
           trans = op_transform, op_scale = 0.5)

Chinese dominoes and 6-sided dice

Generating alternative textures for James H. Vipond’s piecepack components

2020-02-08T00:00:00-08:00

James H. Vipond is a 3D artist who has created high quality Wavefront OBJ files and associated textures of piecepack game pieces. Wavefront OBJ files allow one to make 3D graphics with a variety of software programs. Although Vipond has created some nice png textures to go with his OBJ files you may want to be able to use other piecepack designs. Here is some example code that given a particular piecepackr configuration will allow one to generate appropriate png textures for use with Vipond’s OBJ assets.

Contents

Code
Configuration notes

Code

library("piecepackr")
library("grid")
save_3d_textures <- function(cfg = pp_cfg(), directory = tempdir()) {
    cfg <- as_pp_cfg(cfg)
    for (suit in 1:cfg$n_suits) {
        write_die_texture(suit, cfg, directory)
        write_pawn_texture(suit, cfg, directory)
        for (rank in 1:cfg$n_ranks) {
            write_coin_texture(suit, rank, cfg, directory)
            write_tile_texture(suit, rank, cfg, directory)
        }
    }
    invisible(NULL)
}

write_pawn_texture <- function(suit = 1, cfg = pp_cfg(), directory = tempdir()) {
    f <- file.path(directory, paste0("pawn_belt_s", suit, ".png"))
    png(f, height = 265, width = 189)
    grid.piece("belt_face", suit = suit,
               x = 2 / 5, width = 4 / 5, height = 2 / 3, use_pictureGrob = TRUE, cfg = cfg)
    dev.off()
}

write_coin_texture <- function(suit = 1, rank = 1, cfg = pp_cfg(), directory = tempdir()) {
    f <- file.path(directory, paste0("coin_s", suit, "_r", rank, ".png"))
    png(f, height = 2048, width = 2048)
    pushViewport(viewport(clip = "off"))
    grid.piece(c("coin_back", "coin_face"), suit = suit, rank = rank, angle = c(0, 180),
               x = c(1 / 4, 3 / 4), width = 1 / 2, height = 1 / 2, use_pictureGrob = TRUE, cfg = cfg)
    popViewport()
    dev.off()
}

write_die_texture <- function(suit = 1, cfg = pp_cfg(), directory = tempdir()) {
    f <- file.path(directory, paste0("die_s", suit, ".png"))
    png(f, height = 512, width = 512)
    opt <- cfg$get_piece_opt("die_face", suit, 3)
    grid.rect(gp = gpar(col = NA, fill = opt$background_color))
    grid.piece("die_face", suit = suit, rank = c(6, 5, 1, 2, 4, 3),
               x = rep(c(3 / 12, 9 / 12), 3),
               y = rep(c(3 / 3, 2 / 3, 1 / 3) - 1 / 6, each = 2),
               width = 1 / 3, height = 1 / 3, use_pictureGrob = TRUE, cfg = cfg)
    dev.off()
}

write_tile_texture <- function(suit = 1, rank = 1, cfg = pp_cfg(), directory = tempdir()) {
    f <- file.path(directory, paste0("tile_face_s", suit, "_r", rank, ".png"))
    png(f, height = 250, width = 250)
    grid.piece("tile_face", suit = suit, rank = rank,
           width = 1, height = 1, use_pictureGrob = TRUE, cfg = cfg)
    dev.off()
}

Configuration notes

Here are some tips for creating good configurations to work well with Vipond’s assets:

Don’t use border lines. You can achieve this by setting border_color = "transparent".
Note the height to width ratio of Vipond’s pawn belts are 265 to 189 whereas the default for piecepackr is 0.5” to 2.356194” (in order to fully wrap around a 3/4” diameter pawn). You may consider setting belt_face.width=1, belt_face.height=265/189 if using save_3d_textures.
You may want to put thought into your edge color for certain pieces like tiles and coins. To simulate a black laser-cut burned look perhaps use edge_color.tile = "black", edge_color.coin = "black".

Reversi

2020-01-05T00:00:00-08:00

Contents

Reversi-friendly piecepack design
Playing reversi with a piecepack stackpack

Reversi-friendly piecepack design

In the game of Reversi one player is represented by the suited side of piecepack components while the other player is represented by the unsuited side of piecepack components. A reversi-friendly piecepack design makes it easier to distinguish between the suited and unsuited sides of piecepack components. One simple option would be to design a piecepack where the background of the suited sides are black and those of the unsuited sides are white.

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
reversi1 <- as.list(game_systems("dejavu")$piecepack)
reversi1$background_color.suited <- "grey20"
reversi1$suit_color <- "#D55E00,white,gold,#56b4e9"
reversi1$edge_color.coin <- reversi1$edge_color.tile <- "#E69F00"

dejavu_credit <- c("\u25cf This piecepack uses characters from the font Dejavu Sans.",
                    "\thttps://dejavu-fonts.github.io/",
                    "\thttps://dejavu-fonts.github.io/License.html")
reversi1$credit <- dejavu_credit
reversi1$description <- ""
reversi1$title <- "Reversi-friendly piecepack"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    reversi1$copyright <- "\u00a9 2020 Trevor L Davis.  Some Rights Reserved."
    reversi1$spdx_id <- "CC-BY-SA-4.0"
}

reversi1_borders <- pp_cfg(reversi1)
reversi1$border_color <- NULL
reversi1$border_lex <- NULL
reversi1_cutlines <- pp_cfg(reversi1)
reversi1$background_color.suited <- "black"
bleed <- list(border_lex=0, border_color=NA_character_)
reversi1_bleed <- pp_cfg(c(bleed, reversi1))
ppdf::piecepack_preview() |> pmap_piece(cfg=reversi1_cutlines, default.units="in")

A preview of a reversi-friendly piecepack

Playing reversi with a piecepack stackpack

A single piecepack (24 coins) lacks enough pieces to play the full 8x8 version of Reversi but a piecepack stackpack has enough pieces (24 supercoins plus 24 subtiles plus 24 subcoins).

library("dplyr", warn.conflicts=FALSE)
library("ppdf")
library("tibble")

envir <- list(piecepack=reversi1_borders, subpack=to_subpack(reversi1_borders))

df_pt <- piecepack_rect_board_tiles(nrow=8, ncol=8)
df_pt$cfg <- "piecepack"
df_btf <- tibble(piece_side="tile_face", cfg="subpack",
                x=c(1,4,5,7,8,3,8,2,4,7,8,6,8),
                y=c(8,8,8,8,8,7,7,5,5,4,3,2,2),
                suit=c(1,3,3,4,4,2,2,2,3,4,1,1,4),
                rank=c(4,3,2,5,6,2,3,4,5,2,5,3,1))
df_btb <- tibble(piece_side="tile_back", cfg="subpack",
                 x=c(5,6,2,7,1,3,6,2,4,3,5),
                 y=c(7,7,6,6,5,4,4,3,2,1,1))
df_pcb <- tibble(piece_side="coin_back", cfg="piecepack",
                x=c(2,3,6,2,4,8,2,5,8,7,5,7),
                y=c(8,8,8,7,6,6,4,4,4,3,2,2),
                suit=rep(1:4, 3))
df_pcf <- tibble(piece_side="coin_face", cfg="piecepack",
                 x=c(1,4,5,6,3,7, 1,1,4,5,2,6),
                 y=c(7,7,6,6,5,5, 4,3,3,3,2,1),
                 rank=c(6:1,1:6))
df_bcb <- tibble(piece_side="coin_back", cfg="subpack",
                x=c(3,5,8,6), y=c(6,5,5,3), suit=4:1)
df_bcf <- tibble(piece_side="coin_face", cfg="subpack",
                 x=c(7,1,6,4,3,1,3,1,2,4,7,8),
                 y=c(7,6,5,4,3,2,2,rep(1,5)), rank=c(6:1, 1:6))
df <- bind_rows(df_pt, df_btf, df_btb, df_pcb, df_bcb, df_pcf, df_bcf)
pmap_piece(df, envir=envir, default.units="in", trans=op_transform, op_scale=0.5)

End diagram for a game of Reversi

Triactor (JCD Piecepack)

2019-11-15T00:00:00-08:00

Jonathan C. Dietrich is a notable piecepack designer who has written several piecepack games, developed VASSAL’s piecepack module, and designed the JCD piecepack. In this demo we’ll be making a starting diagram for the game Triactor that he co-authored using a piecepackr configuration that directly uses his JCD piecepack images contained in VASSAL’s piecepack module.

Contents

JCD piecepack configuration
Triactor

JCD piecepack configuration

Note

I contacted Jonathon C. Dietrich and he wrote that it is fine to use the VASSAL piecepack module images in game diagrams but that attribution is required.

The strategy for our JCD piecepack configuration will be to extract the gif images from VASSAL’s piecepack module (which is actually a zip file) and then use piecepackr‘s picturePieceGrobFn to make a grob function that directly uses those images. If you don’t want checkered tile backs set checkered=FALSE.

library("piecepackr")

if (!file.exists("Piecepack_v0_15_BUNDLE.zip")) {
    download.file("http://www.vassalengine.org/mediawiki/images/6/6a/Piecepack_v0_15_BUNDLE.zip")
}
z1 <- "Piecepack_v0_15_BUNDLE.zip"
z2 <- unzip(z1, "piecepack/piecepack.mod", exdir=tempdir())
unzip(z2, exdir=tempdir())
directory <- file.path(tempdir(), "images")

jcd_filename_fn <- function(directory, set="piecepack", checkered=TRUE) {
    suits <- switch(set,
                    piecepack = c("s", "m", "c", "a"),
                    playing_cards_expansion = c("h", "p", "b", "d"),
                    four_seasons_expansion = c("f", "w", "u", "n"))
    ranks <- as.character(0:5)
    fp <- function(prefix, suffix) {
        file.path(directory, paste0(prefix, "-", suffix, ".gif"))
    }
    function(directory, piece_side, suit, rank) {
        s <- suits[suit]
        r <- ranks[rank]
        sr <- paste0(s, r)
        switch(piece_side,
               coin_back = fp("coin", s), coin_face = fp("coin", r),
               die_face = fp("die", sr),
               pawn_back = fp("pawn", paste0(s, "2")),
               pawn_face = fp("pawn", paste0(s, "1")),
               tile_back = fp("tile", ifelse(checkered, "back1", "back2")),
               tile_face = fp("tile", sr))
    }
}

credit <- c("This piecepack uses JCD Piecepack images from the VASSAL piecepack module by Jonathan C. Dietrich",
            "\thttp://www.piecepack.org/JCD.html",
            "\thttp://www.vassalengine.org/wiki/Module:Piecepack",
            "\thttps://www.ludism.org/ppwiki/JonathanDietrich",
            "\thttps://www.ludism.org/ppwiki/VassalModule")

piecepack <- list(grob_fn = picturePieceGrobFn(directory, jcd_filename_fn(directory)),
                  suit_color="#c54242,#8c8c7b,#bdb53a,#429cc5,black",
                  border_color="black", border_lex.tile=4,
                  border_lex.coin=4, depth.coin=0.125,
                  width.pawn=0.75, height.pawn=(52/55)*0.75,
                  shape.pawn="concave5", shape_r.pawn=0.22,
                  edge_color.tile="#c5945a", edge_color.coin="#c5945a", edge_color.pawn="black",
                  credit=credit)

pce <- piecepack
pce$grob_fn <- picturePieceGrobFn(directory, jcd_filename_fn(directory, set="playing_cards_expansion"))
pce$suit_color="#c03a3a,#848473,#848473,#c03a3a,black"

fse <- piecepack
fse$grob_fn <- picturePieceGrobFn(directory, jcd_filename_fn(directory, set="four_seasons_expansion"))
fse$suit_color="#e9bf60,#eee0cd,#9ce0dc,#eb88c4,black"

jcd <- list(piecepack = pp_cfg(piecepack),
            playing_cards_expansion = pp_cfg(pce),
            four_seasons_expansion = pp_cfg(fse))

Triactor

Triactor: A Day at the Piecepack Downs is a game by Jonathan C. Dietrich, Julie Taylor, and Ken MacKeigan that won “Best Eye Candy” in the 6th piecepack game design competition “Group Projects”. We’ll make a starting diagram for Triactor including embedding the optional Print-and-Play playmat that comes with it.

library("grid")
library("magick") |> suppressPackageStartupMessages()
library("ppdf")
if (!file.exists("Triactor.pdf")) {
    download.file("http://www.piecepack.org/rules/Triactor.pdf")
}
if(!require("pdftools") |> suppressPackageStartupMessages()) {
    install.packages("pdftools") # dependency for 'image_read_pdf'
}
playmat <- rasterGrob(as.raster(image_read_pdf("Triactor.pdf", pages=8)))

png("../share/rules/triactor.png", width=21, height=13, units="in", res=72)
pushViewport(viewport(x=unit(10.8, "in"), y=unit(6.6, "in"), width=unit(8.5, "in"), height=unit(11.0, "in"), angle=90))
grid.draw(playmat)
popViewport()
pmap_piece(piecepack_triactor(), envir=jcd, default.units="in", op_scale=0.5, trans=op_transform)
invisible(dev.off())

Starting diagram for Triactor. Uses JCD piecepack images contained in VASSAL’s piecepack module by Jonathan C. Dietrich and the Triactor playmat by Jonathan C. Dietrich, Julie Taylor, and Ken MacKeigan / CC BY-NC-SA 2.0

Game starting arrangement functions

2019-10-25T00:00:00-07:00

The package ppdf contains functions that generate the starting piece arrangements for several piecepack games. These functions return data frames that can be used directly with piecepackr::pmap_piece() or ppcli::cat_piece() to generate piecepack game diagrams or they can be used with ppn‘s Portable Piecepack Notation parser read_ppn() to initially setup the game pieces.

Contents

Directly generating starting diagrams
Use with Portable Piecepack Notation
Supported Game Start Functions
- Contained in ppdf
- Contained in piecenikr

Directly generating starting diagrams

The game start functions all return a data frame that can be used directly with piecepackr::pmap_piece() or ppcli::cat_piece():

library("ppcli")
library("ppdf")
cat_piece(piecepack_fide_chess())

download.file("https://trevorldavis.com/piecepackr/share/demo_cfgs.RData")
cfgs <- new.env()
load("demo_cfgs.RData", envir=cfgs)
pmap_piece(piecepack_fide_chess(), cfg=cfgs$chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

Use with Portable Piecepack Notation

The game start functions can also be used with Portable Piecepack Notation to initially set the game pieces via the metadata field GameType:

GameType: Four Field Kono

1. b1:b3 1... d3:b3 2. c1:c3 2... a3:c3 3. c2-c1 3... b4:b2 4. a1-b1 4... b3:b1
5. d1:b1 5... c3-c2 6. a2-a3 6... b2:d2 7. a3-b3 7... c4-c3 8. c1-d1 8... d4-d3
9. b1-b2 9... d2:b2 10. b3-a3 10... b2-b1 {Player 1's loss is assured with the
 separation of their two remaining pieces and they should resign in a real game}
11. a3-a2 11... b1-c1 12. d1-d2 12... c1-d1 13. a2-a3 13... a4-b4
14. a3-a4 14... b4-c4 15. a4-b4 15... c4-d4 16. b4-a4 16... d4:d2 {Player 2 wins}

It is also possible to pass in arguments to the game start function by passing a “mapping” to the GameType field:

---
GameType:
  Name: Fujisan
  Coins: "44452n24n3aa/a25335325ann"
...
1. a1-b1 2. n2-k2 3. b1-e1 4. e1-j1 5. j1-j2 6. j2-l2 7. k2-m2
8. m2-m1 9. l2-l1 10. n1-k1 11. m1-i1 12. i1-d1 13. d1-d2 14. l1-i1
15. i1-i2 16. k1-k2 17. k2-e2 18. i2-c2 19. a2-f2 20. e2-h2 21. h2-g2
22. c2-h2 23. h2-h1 24. d2-h2 25. f2-b2 26. b2-b1 27. b1-g1

In particular for supported games playable with either a piecepack or another game system (like a checkers board) one can inform PPN of the alternative game system to use via a System argument to the GameType field:

---
GameType:
  Name: Four Field Kono
  System: Checkers
...
1. b1:b3 1... d3:b3 2. c1:c3 2... a3:c3 3. c2-c1 3... b4:b2 4. a1-b1 4... b3:b1
5. d1:b1 5... c3-c2 6. a2-a3 6... b2:d2 7. a3-b3 7... c4-c3 8. c1-d1 8... d4-d3
9. b1-b2 9... d2:b2 10. b3-a3 10... b2-b1 {Player 1's loss is assured with the
 separation of their two remaining pieces and they should resign in a real game}
11. a3-a2 11... b1-c1 12. d1-d2 12... c1-d1 13. a2-a3 13... a4-b4
14. a3-a4 14... b4-c4 15. a4-b4 15... c4-d4 16. b4-a4 16... d4:d2 {Player 2 wins}

Supported Game Start Functions

Contained in ppdf

Some games supported in ppdf

Alquerque Games

Setups for alquerque sets
game	methods	comment
Alquerque	`alquerque_alquerque()`
Bagh-chal	`alquerque_baghchal()`

Checkers Games

Setups for checkers/draughts sets
game	methods	comment
(American) Checkers AKA (English) Draughts	`checker_american_checkers()` aka `checker_english_checkers()` aka `checker_checkers()`
American Pool Checkers	`checker_american_pool_checkers()`
Bashni AKA Column Checkers	`checker_bashni()` aka `checker_column_checkers()`
Brazilian Checkers AKA Brazilian Draughts	`checker_brazilian_checkers()`
Breakthrough	`checker_breakthrough()`
Canadian Checkers AKA Canadian Draughts	`checker_canadian_checkers()`
Corner Checkers AKA Corner Draughts	`checker_corner_checkers()`
Crossings	`checker_crossings()`
Czech Checkers AKA Czech Draughts	`checker_czech_checkers()`
Dameo	`checker_dameo()`
Dao	`piecepack_dao()`
Dodgem	`checker_dodgem()`
Focus	`checker_focus()`
Four Field Kono	`checker_four_field_kono()`
Frisian Checkers AKA Frisian Draughts	`checker_frisian_checkers()`
Gothic Checkers AKA Gothic Draughts	`checker_gothic_checkers()`
Grasshopper	`checker_grasshopper()`
International Checkers AKA International Draughts	`checker_international_checkers()`
Italian Checkers AKA Italian Draughts	`checker_italian_checkers()`
Jamaican Checkers AKA Jamaican Draughts	`checker_jamaican_checkers()`
Jul-Gonu	`checker_julgonu()`
Kangaroo	`checker_kangaroo()`
Lasca	`checker_lasca()`
Lines of Action	`checker_lines_of_action()`
Malaysian Checkers AKA Singaporean Checkers	`checker_malaysian_checkers()` aka `checker_singaporean_checkers()`
One Way Checkers AKA One Way Draughts	`checker_one_way_checkers()`
Portuguese Checkers AKA Portuguese Draughts	`checker_portuguese_checkers()`
Russian Checkers AKA Russian Draughts	`checker_russian_checkers()`
Spanish Checkers AKA Spanish Draughts	`checker_spanish_checkers()`
Thai Checkers AKA Thai Draughts AKA Mak-hot AKA Makhos	`checker_thai_checkers()`
Turkish Checkers AKA Turkish Draughts AKA Dama	`checker_turkish_checkers()`
Unified Pool Checkers	`checker_unified_pool_checkers()`
Zimbabwean Pool Checkers	`checker_zimbabwean_pool_checkers()`

Chess Games

Setups for chess sets
game	methods	comment
Fischer Random Chess AKA Chess960	`chess_fischer_random_chess()` aka `chess_chess960()`
Horde Chess	`chess_horde_chess()`
(International) Chess	`chess_international_chess()` aka `chess_chess()`
Monochrome Chess	`chess_monochrome_chess()`
Racing Kings	`chess_racing_kings()`

Domino Games

Setups for sets of dominoes
game	methods	comment
Bee Donimoes	`domino_bee_donimoes()`
Concentration	`domino_concentration()`
Domino Finder	`domino_finder()`
(Domino) Fuji-san	`domino_fujisan()`
(Domino) Patience	`domino_patience()`
Domino Runners	`domino_runners()`
Dominoes Freecell	`domino_freecell()`
Luzon	`domino_luzon()`
The Jubilee	`domino_the_jubilee()`
The Sultan	`domino_the_sultan()`

Go Games

Setups for go sets
game	methods	comment
Go	`go_go()`
Gomoku	`go_gomoku()`

Morris Games

Setups for morris sets
game	methods	comment
Five Men’s Morris	`morris_five_mens_morris()`
Nine Men’s Morris	`morris_nine_mens_morris()`
Seven Men’s Morris	`morris_seven_mens_morris()`
Six Men’s Morris	`morris_six_mens_morris()`
Ten Men’s Morris aka Lasker Morris	`morris_ten_mens_morris()` aka `morris_lasker_morris()`
Three Men’s Morris	`morris_three_mens_morris()`
Twelve Men’s Morris	`morris_twelve_mens_morris()`

Piecepack Games

Setups for piecepack sets
game	methods	comment
12345ive!	`piecepack_12345ive()`
Achi	`piecepack_achi()`
Alice Chess	`piecepack_alice_chess()`
Alien City	`piecepack_alien_city()`
Alquerque AKA Qirkat	`piecepack_alquerque()`
(American) Checkers AKA (English) Draughts	`piecepack_american_checkers()`, `piecepack_english_checkers()`, `piecepack_checkers()`
American Pool Checkers	`piecepack_american_pool_checkers()`
Awithlaknannai Mosona	`piecepack_awithlaknannai_mosona()`
Backgammon	`piecepack_backgammon()`
Bagh-chal	`piecepack_baghchal()`
Bashni AKA Column Checkers	`piecepack_bashni()` aka `piecepack_column_checkers()`
Black Pawn Trucking	`piecepack_black_pawn_trucking()`
Brain Burn	`piecepack_brain_burn()`
Brandubh AKA Brandub	`piecepack_brandubh()`
Brazilian Checkers AKA Brazilian Draughts	`piecepack_brazilian_checkers()`
Breakthrough	`piecepack_breakthrough()`
Burbuja	`piecepack_burbuja()`
Cardinal’s Guards	`piecepack_cardinals_guards()`
Cell Management	`piecepack_cell_management()`
Change Change	`piecepack_change_change()`
Chariots	`piecepack_chariots()`
Chaturaji	`piecepack_chaturaji()`
Chinese Checkers AKA (Piecepack) Halma	`piecepack_chinese_checkers()` aka `piecepack_halma()`
Climbing Man	`piecepack_climbing_man()`
Coin Collectors	`piecepack_coin_collectors()`
Corner Checkers AKA Corner Draughts	`piecepack_corner_checkers()`
Cribbage	`piecepack_cribbage()` aka `piecepack_cribbage_board()`
Crocodile Hop	`piecepack_crocodile_hop()`
Crossings	`piecepack_crossings()`
Czech Checkers AKA Czech Draughts	`piecepack_czech_checkers()`
Dao	`piecepack_dao()`
Dara	`piecepack_dara()`
Desfases	`piecepack_desfases()`
Dodgem	`piecepack_dodgem()`
Dominoids	`piecepack_dominoids()`
Easy Slider	`piecepack_easy_slider()`
Evade	`piecepack_evade()`
Everest	`piecepack_everest()`
Fischer Random Chess AKA Chess960	`piecepack_fischer_random_chess()` aka `piecepack_chess960()`
Four Blind Mice	`piecepack_four_blind_mice()`
Four Field Kono	`piecepack_four_field_kono()`
Four Seasons Chess	`piecepack_four_seasons_chess()`
Froggy Bottom	`piecepack_froggy_bottom()`
Fuji-san	`piecepack_fujisan()`
Galaxy Express	`piecepack_galaxy_express()`
Gothic Checkers AKA Gothic Draughts	`piecepack_gothic_checkers()`
Grasshopper	`piecepack_grasshopper()`
Ice Floe	`piecepack_ice_floe()`
Iceberg	`piecepack_iceberg()`
(International) Chess	`piecepack_international_chess()` aka `piecepack_chess()`
Italian Checkers AKA Italian Draughts	`piecepack_italian_checkers()`
Jamaican Checkers AKA Jamaican Draughts	`piecepack_jamaican_checkers()`
Japan	`piecepack_japan()`
Jul-Gonu	`piecepack_julgonu()`
Kangaroo	`piecepack_kangaroo()`
King’s Valley	`piecepack_kings_valley()`
Lab Rats	`piecepack_lab_rats()`
Landlocked	`piecepack_landlocked()`
Leapfrog	`piecepack_leapfrog()`
Ley Lines	`piecepack_ley_lines()`
Lines of Action	`piecepack_lines_of_action()`
Ludo	`piecepack_ludo()`
Lukawan	`piecepack_lukawan()`
Mathrix	`piecepack_mathrix()`
Minishogi	`piecepack_minishogi()`
Nine Men’s Morris	`piecepack_nine_mens_morris()`
One Man Thrag!	`piecepack_one_man_thrag()`
One Way Checkers AKA One Way Draughts	`piecepack_one_way_checkers()`
Pass the Food	`piecepack_pass_the_food()`
Pawns Crossing	`piecepack_pawns_crossing()`
Piece Gaps	`piecepack_piece_gaps()`
Piece Packing Pirates	`piecepack_piece_packing_pirates()`
(Piecepack) Klondike	`piecepack_klondike()`
Piecepackman	`piecepack_piecepackman()`	Currently only supports the “Roundabout” variant
Plans of Action	`piecepack_plans_of_action()`
Portuguese Checkers AKA Portuguese Draughts	`piecepack_portuguese_checkers()`
Quatri	`piecepack_quatri()`
Racing Kings	`piecepack_racing_kings()`
Relativity	`piecepack_relativity()`
Russian Checkers AKA Russian Draughts	`piecepack_russian_checkers()`
Salta	`piecepack_salta()`
San Andreas	`piecepack_san_andreas()`
Sarcophagus	`piecepack_sarcophagus()`
Seega	`piecepack_seega()`
Ship It!	`piecepack_ship_it()`
Shogi AKA Japanese Chess	`piecepack_shogi()` aka `piecepack_japanese_chess()`
Shopping Mall	`piecepack_shopping_mall()`
Skyscrapers	`piecepack_skyscrapers()`
Slides of Action	`piecepack_slides_of_action()`
Spanish Checkers AKA Spanish Draughts	`piecepack_spanish_checkers()`
Speedy Towers	`piecepack_speedy_towers()`	Currently only supports the two players variant
Steppin’ Stones	`piecepack_steppin_stones()`
Tablan	`piecepack_tablan()`
Tablut	`piecepack_tablut()`
Tariffs	`piecepack_tariffs()`
Thai Checkers AKA Thai Draughts AKA Mak-hot AKA Makhos	`piecepack_thai_checkers()`
The “In” Crowd	`piecepack_the_in_crowd()`
The Magic Bag	`piecepack_the_magic_bag()`
The Penguin Game	`piecepack_the_penguin_game()`
Three Musketeers	`piecepack_three_musketeers()`
Tic-tac-toe	`piecepack_tic_tac_toe()`
Tornado vs. Trailer Park	`piecepack_tornado_vs_trailer_park()`
Tower of Babel AKA (Piecepack) Accordion	`piecepack_tower_of_babel()` aka `piecepack_accordion()`
Tracers	`piecepack_tracers()`
Triactor	`piecepack_triactor()`
Tula	`piecepack_tula()`	Also supports Tim Schutz’s variants 1–4
Turkish Checkers AKA Turkish Draughts AKA Dama	`piecepack_turkish_checkers()`
Twelve Men’s Morris	`piecepack_twelve_mens_morris()`
Ultima AKA Baroque Chess	`piecepack_ultima()` aka `piecepack_baroque_chess()`
Unified Pool Checkers	`piecepack_unified_pool_checkers()`
Wormholes	`piecepack_wormholes()`
Xiangqi AKA Chinese Chess	`piecepack_xiangqi()` aka `piecepack_chinese_chess()`
Yoté	`piecepack_yote()`
Zimbabwean Pool Checkers	`piecepack_zimbabwean_pool_checkers()`

Reversi Games

Setups for reversi sets
game	methods	comment
Ming Mang	`reversi_ming_mang()`
Reversi	`reversi_reversi()`

Stackpack Games

Setups for stackpack sets
game	methods	comment
Alice Chess	`stackpack_alice_chess()`
Chaturaji	`stackpack_chaturaji()`
Fischer Random Chess AKA Chess960	`stackpack_fischer_random_chess()` aka `stackpack_chess960()`
Four Seasons Chess	`stackpack_four_seasons_chess()`
Horde Chess	`stackpack_horde_chess()`
(International) Chess	`stackpack_international_chess()` aka `stackpack_chess()`
Salta	`stackpack_salta()`
Shogi aka Japanese Chess	`stackpack_shogi()` aka `stackpack_japanese_chess()`
Ultima aka Baroque Chess	`stackpack_ultima()` aka `stackpack_baroque_chess()`
Xiangqi AKA Chinese Chess	`stackpack_xiangqi()` aka `stackpack_chinese_chess()`

Contained in piecenikr

Please note some Looney Pyramids / piecepack hybrids like Alien City are contained in the ppdf package.

Setups for the Looney Pyramid game system
game	methods	comment
Martian Chess	`icehouse_martian_chess()`

Chess

2019-10-12T00:00:00-07:00

This article includes some demos of chess-ranked piecepacks as well as the starting diagrams of several chess variants playable with a piecepack.

Contents

Print-and-play chess-ranked piecepacks
Some chess variants playable with a piecepack
Some chess variants playable with a piecepack stackpack

Print-and-play chess-ranked piecepacks

Chess-ranked piecepack

The simplest chess-ranked piecepack would be to simply swap in the six chess rank symbols for the six piecepack rank symbols.

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
noto_credit <- c("\u25cf This piecepack uses characters from Google Noto Fonts. OFL 1.1.",
                 "\thttps://www.google.com/get/noto/")

chess1 <-  list(suit_text = "🌞,🌜,👑,⚜,꩜",
      suit_fontfamily = "Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
      suit_cex = "0.6,0.7,0.75,0.9,0.9",
      suit_color = "darkred,black,darkgreen,darkblue,black",
      rank_text = "♟,♞,♝,♜,♛,♚",
      rank_fontfamily = "Noto Sans Symbols")
chess1$description <- 'This is a chess-ranked piecepack that swaps in the six chess rank symbols for the six piecepack rank symbols.'
chess1$credit <- c(noto_credit)
chess1$title <- "Chess-ranked piecepack"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    chess1$copyright <- "\u00a9 2020 Trevor L Davis.  Some Rights Reserved."
    chess1$spdx_id <- "CC-BY-SA-4.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
chess1_cutlines <- pp_cfg(chess1)
chess1_borders <- pp_cfg(c(borders, chess1))
chess1_bleed <- pp_cfg(c(bleed, chess1))
ppdf::piecepack_preview() |> pmap_piece(cfg=chess1_cutlines, default.units="in")

Chess-ranked piecepack

French-suited chess-ranked piecepack

Note

This custom grob function uses the function pp_shape() which was introduced in piecepackr v1.5.1

If you use a custom grob function one can easily add checkers to either the tile face or back. Using the French (playing card) suits may make it easier to play two-player games (like many chess variants). Since we aren’t using the suit symbol as the ace symbol we can move the tile face rank symbol to the lower right for aesthetic reasons without loss of essential piecepack information (can still always tell which is the “special” corner and what are the tile’s suit and rank).

library("grid")
checkeredPieceGrob <- function(piece_side, suit, rank, cfg) {
    cfg <- as_pp_cfg(cfg)
    opt <- cfg$get_piece_opt(piece_side, suit, rank)
    shape <- pp_shape(opt$shape, opt$shape_t, opt$shape_r, opt$back)

    background_grob <- shape$shape(gp=gpar(col=NA, fill=opt$background_color))
    checkers_grob <- shape$checkers(gp=gpar(fill=opt$gridline_color))

    gp_ps <- gpar(col=opt$ps_color, fontsize=opt$ps_fontsize,
                  fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
    ps_grob <- textGrob(opt$ps_text, x=opt$ps_x, y=opt$ps_y, gp=gp_ps)

    gp_dm <- gpar(col=opt$dm_color, fontsize=opt$dm_fontsize,
                  fontfamily=opt$dm_fontfamily, fontface=opt$ps_fontface)
    dm_grob <- textGrob(opt$dm_text, x=opt$dm_x, y=opt$dm_y, gp=gp_dm)

    border_grob <- shape$shape(gp=gpar(col=opt$border_color, fill=NA, lex=opt$border_lex))

    gl <- gList(background_grob, checkers_grob, ps_grob, dm_grob, border_grob)

    gTree(children=gl, name=piece_side)
}
chess2 <- list(suit_color = "darkred,black,dimgrey,hotpink2,grey",
  suit_text = "♥,♠,♣,♦,",
  suit_fontfamily = "Noto Sans Symbols",
  rank_text = "♟,♞,♝,♜,♛,♚",
  rank_fontfamily = "Noto Sans Symbols",
  suit_text.s5 = "꩜",
  suit_fontfamily.s5 = "Noto Sans Cham",
  suit_cex.s5 = 0.9,
  gridline_color.tile_face="grey",
  ps_t.tile_face=-45, ps_r.tile_face=0.3535534, ps_cex.tile_face=0.6,
  grob_fn.tile_face=checkeredPieceGrob)
chess2$description <- 'This is a French-suited chess-ranked piecepack.'
chess2$credit <- c(noto_credit)
chess2$title <- "French-suited chess-ranked piecepack"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    chess2$copyright <- "\u00a9 2020 Trevor L Davis.  Some Rights Reserved."
    chess2$spdx_id <- "CC-BY-SA-4.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
chess2_cutlines <- pp_cfg(chess2)
chess2_borders <- pp_cfg(c(borders, chess2))
chess2_bleed <- pp_cfg(c(bleed, chess2))
ppdf::piecepack_preview() |> pmap_piece(cfg=chess2_cutlines, default.units="in")

French-suited chess-ranked piecepack

Mirrored-color-scheme chess piecepacks

Having two piecepacks with a mirror-color-scheme makes it really easy to play games like Bughouse chess or Reversi/Othello. Here we’ll design one piecepack with six “black” suits and another with six “red” suits.

Black-suited mirrored-color-scheme chess-ranked piecepack

chess3 <- list(suit_text = "♠,♣,🌜,⚓,,,★",
  suit_fontfamily = "Noto Sans Symbols,Noto Sans Symbols,Noto Sans Symbols2,DejaVu Sans,Quivira,Quivira,Noto Sans Symbols",
  suit_cex = "1,1,0.8,0.8,1,1,1",
  suit_color = "black,black,black,black,black,black,darkred",
  grob_fn.tile_back=checkeredPieceGrob,
  suit_text.coin_back = "♟",
  suit_fontfamily.coin_back = "Noto Sans Symbols",
  suit_cex.coin_back = "1",
  dm_text.coin_back = "♠,♣,🌜,⚓,,,★",
  dm_fontfamily.coin_back = "Noto Sans Symbols,Noto Sans Symbols,Noto Sans Symbols2,DejaVu Sans,Quivira,Quivira,Noto Sans Symbols",
  dm_cex.coin_back = "1,1,0.8,1,1,1,1",
  dm_text.coin_face = "★",
  rank_text = "♟,♞,♝,♜,♛,♚", rank_fontfamily="Noto Sans Symbols")
chess3$description <- 'This is a chess-ranked piecepack with a mirrored-color-scheme.'
chess3$credit <- c(noto_credit)
chess3$title <- "Black-suited mirrored-color-scheme chess-ranked piecepack"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    chess3$copyright <- "\u00a9 2020 Trevor L Davis.  Some Rights Reserved."
    chess3$spdx_id <- "CC-BY-SA-4.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
chess3_cutlines <- pp_cfg(chess3)
chess3_borders <- pp_cfg(c(borders, chess3))
chess3_bleed <- pp_cfg(c(bleed, chess3))
ppdf::piecepack_preview() |> pmap_piece(cfg=chess3_cutlines, default.units="in")

Black-suited mirrored-color-scheme chess-ranked piecepack

Red-suited mirrored-color-scheme chess-ranked piecepack

chess4 <- chess3
chess4$suit_text <- "♥,♦,🌞,♚,,,★"
chess4$suit_fontfamily <- "Noto Sans Symbols,Noto Sans Symbols,Noto Emoji,Noto Sans Symbols,Quivira,Quivira,Noto Sans Symbols"
chess4$suit_cex <- "1,1,0.8,1,1,1,1"
chess4$suit_color <- "darkred,darkred,darkred,darkred,darkred,darkred,black"
chess4$dm_text.coin_back <- "♥,♦,🌞,♚,,,★"
chess4$dm_fontfamily.coin_back <- "Noto Sans Symbols,Noto Sans Symbols,Noto Emoji,Noto Sans Symbols,Quivira,Quivira,Noto Sans Symbols"
chess4$dm_cex.coin_back <- "1,1,0.8,1,1,1,1"
chess4$title <- "Red-suited mirrored-color-scheme chess-ranked piecepack"
chess4_cutlines <- pp_cfg(chess4)
chess4_borders <- pp_cfg(c(borders, chess4))
chess4_bleed <- pp_cfg(c(bleed, chess4))
ppdf::piecepack_preview() |> pmap_piece(cfg=chess4_cutlines, default.units="in")

Red-suited mirrored-color-scheme chess-ranked piecepack

Both-piecepack-and-chess-ranked piecepack

Note

This custom grob function uses the function pp_shape() which was introduced in piecepackr v1.5.1

With a custom grob function and the right chess font one can make a piecepack that has both the piecepack ranks and the chess ranks.

chessRankGrob <- function(piece_side, suit, rank, cfg=pp_cfg()) {
    cfg <- as_pp_cfg(cfg)
    opt <- cfg$get_piece_opt(piece_side, suit, rank)
    shape <- pp_shape(opt$shape, opt$shape_t, opt$shape_r, opt$back)

    # Background
    gp_bg <- gpar(col=NA, lwd=0, fill=opt$background_color)
    if (packageVersion("piecepackr") > '1.13')
        background_grob <- shape$shape(gp=gp_bg, mat_width = opt$mat_width)
    else
        background_grob <- shape$shape(gp=gp_bg)

    # Gridlines, Mat
    gp_gl <- gpar(col = opt$gridline_color, lex = opt$gridline_lex)
    if (packageVersion("piecepackr") > '1.13')
        gl_grob <- shape$gridlines(gp = gp_gl, mat_width = opt$mat_width)
    else
        gl_grob <- shape$gridlines(gp = gp_gl)
    mat_grob <- shape$mat(opt$mat_width, gp = gpar(fill = opt$mat_color))

    # Primary symbol
    chess_ranks <- c("P", "N", "B", "R", "Q", "K")
    hjusts <- c(0.52, 0.5, 0.48, 0.52, 0.48, 0.52)
    if (piece_side %in% c("tile_face", "coin_face", "coin_back", "die_face")) {
        gp_ps <- gpar(col="white",
                      fontsize=opt$ps_fontsize,
                      fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
        ps_grob <- textGrob(opt$ps_text, x=opt$ps_x, y=opt$ps_y, gp=gp_ps)
        fontsize <- list(tile_face=100, coin_back=70, coin_face=70, die_face=45,
                         matchstick_face=20, pyramid_left=30, pyramid_right=30)
        chess_rank <- ifelse(piece_side == "coin_back", "P", chess_ranks[rank])
        gp_c <- gpar(col=opt$ps_color, fontsize=fontsize[[piece_side]],
                      fontfamily="Chess Utrecht")
        c_grob <- textGrob(chess_rank, hjust=ifelse(chess_rank=="P", hjusts[1], hjusts[rank]), gp=gp_c)
        ps_grob <- grobTree(c_grob, ps_grob)
    } else {
        gp_ps <- gpar(col=opt$ps_color, fontsize=opt$ps_fontsize,
                      fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
        ps_grob <- textGrob(opt$ps_text, x=opt$ps_x, y=opt$ps_y, gp=gp_ps)
    }

    # Directional mark
    gp_dm <- gpar(col=opt$dm_color, fontsize=opt$dm_fontsize,
                  fontfamily=opt$dm_fontfamily, fontface=opt$ps_fontface)
    dm_grob <- textGrob(opt$dm_text, x=opt$dm_x, y=opt$dm_y, gp=gp_dm)

    # Border
    border_grob <- shape$shape(gp=gpar(col=opt$border_color, fill=NA, lex=opt$border_lex))
    gl <- gList(background_grob, gl_grob, mat_grob,
                ps_grob, dm_grob, border_grob)

    gTree(children=gl, name=piece_side)
}
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="0.6,0.7,0.75,0.90,0.9")
colors <- list(ps_color.s2.tile_face="black", ps_color.s2.coin_back="black", ps_color.s2.die_face="black",
               invert_colors.pawn=TRUE,
               mat_width.tile_back=0.05, mat_color.tile_back="white",
               invert_colors.matchstick=TRUE, invert_colors.pyramid=TRUE,
               border_color.matchstick="grey", border_color.s2.pyramid="white")
orthodox_ranks <- list(rank_text=",\uaa5c,2,3,4,5", use_suit_as_ace=TRUE,
                       rank_fontfamily="Noto Sans",
                       rank_fontfamily.r2="Noto Sans Cham", rank_cex.r2.matchstick=0.7)
misc <- list(grob_fn=chessRankGrob,
             dm_text.coin="", dm_text.die="",
             ps_cex.tile_face=0.5, ps_cex.r2.tile_face=0.3, ps_cex.s4.r2.tile_face=0.5,
             ps_cex.coin=0.9, ps_cex.coin_back=0.3, ps_cex.r2.coin_face=0.7,
             ps_cex.die_face=0.7, ps_cex.r2.die_face=0.5, ps_cex.s4.r2.die_face=0.6,
             ps_t.coin=-90, ps_r.coin=0.2, ps_r.coin_back=0.05,
             ps_t.die=-90, ps_r.die=0.2, ps_t.tile_face=-90, ps_r.tile_face=0.1)
chess5 <- c(piecepack_suits, orthodox_ranks, misc, colors)
chess5$description <- 'This is a piecepack that has both the piecepack ranks and the chess ranks.'
utrecht_credit <- c("\u25cf This piecepack uses characters from the Chess Utrecht font.",
                    "\t\u00a9 1996 by Hans Bodlaender.  Use of the font is free.",
                    "\thttps://www.chessvariants.com/d.font/utrecht.html")
noto_credit <- c("\u25cf This piecepack uses characters from Google Noto Fonts. OFL 1.1.",
                 "\thttps://www.google.com/get/noto/")
chess5$credit <- c(utrecht_credit, noto_credit)
chess5$title <- "Piecepack-and-chess-ranked piecepack"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    chess5$copyright <- "\u00a9 2020 Trevor L Davis.  Some Rights Reserved."
    chess5$spdx_id <- "CC-BY-SA-4.0"
}
borders <- list(edge_color.coin="grey", edge_color.tile="grey",
                border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
chess5_cutlines <- pp_cfg(chess5)
chess5_borders <- pp_cfg(c(borders, chess5))
chess5_bleed <- pp_cfg(c(chess5, bleed))
ppdf::piecepack_preview() |> pmap_piece(cfg=chess5_cutlines, default.units="in")

A piecepack with both piecepack and chess ranks

Some chess variants playable with a piecepack

Alice Chess

Alice Chess is chess variant invented in 1953 by V.R. Parton played on two boards.

pmap_piece(ppdf::piecepack_alice_chess(), cfg=chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

Alice Chess starting diagram

Chaturaji

Chaturaji (aka Chaturanga for four players aka Choupat) is an old four-person chess variant.

pmap_piece(ppdf::piecepack_chaturaji(), cfg=chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

Chaturaji starting diagram

(International) Chess

(International) Chess is a classic board game playable with a single piecepack.

pmap_piece(ppdf::piecepack_international_chess(), cfg=chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

(FIDE) Chess starting diagram

Four seasons chess

Four seasons chess is an old 4 player chess variant recorded in the Acedrex de Los Quatros Tiempos.

pmap_piece(ppdf::piecepack_four_seasons_chess(), cfg=chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

Four seasons chess starting diagram

Ultima

Ultima is chess variant invented by Robert Abbot and published in Recreational Mathematics Magazine in August 1962 under the name Baroque chess.

pmap_piece(ppdf::piecepack_ultima(), cfg=chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

Ultima starting diagram

Xiangqi (Chinese Chess)

Xiangqi (also called Chinese chess) is a popular board game in Chinese communities and is a member of the chess family of games.

pmap_piece(ppdf::piecepack_xiangqi(), cfg=chess5_borders, op_scale=0.5,
           trans=op_transform, default.units="in")

Xiangqi (Chinese Chess) starting diagram

Some chess variants playable with a piecepack stackpack

A piecepack stackpack is also handy for playing several chess variants since every player’s pieces can then be suited.

two_player_scheme <- pp_cfg(list(suit_text="🌞,🌜,👑,⚜,꩜",
         suit_cex="0.6,0.7,0.75,0.9,0.9",
        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
        suit_color="#D55E00,#000000,#F0E442,#0072B2,#009E73",
        background_color="#000000,#D55E00,#0072B2,#F0E442,white",
        border_color="black", border_lex=5, depth.coin = 0.25,
        border_color.tile_back="#009E73", border_lex.tile_back=5
))
two_player_stackpack <- list(piecepack = two_player_scheme,
                             subpack = to_subpack(two_player_scheme))

Chaturaji

pmap_piece(ppdf::stackpack_chaturaji(), envir = two_player_stackpack,
           op_scale = 0.5, trans=op_transform, default.units = "in")

Chaturaji diagram

(International) Chess

pmap_piece(ppdf::stackpack_international_chess(), envir = two_player_stackpack, op_scale=0.5,
           trans=op_transform, default.units="in")

Chess starting diagram

Shogi (Japanese Chess)

pmap_piece(ppdf::stackpack_shogi(), envir = two_player_stackpack, op_scale=0.5,
           trans=op_transform, default.units="in")

Shogi starting diagram

Xiangqi (Chinese Chess)

pmap_piece(ppdf::stackpack_xiangqi(), envir = two_player_stackpack, op_scale=0.5,
           trans=op_transform, default.units="in")

Xiangqi starting diagram

Everest

2019-10-07T00:00:00-07:00

Everest is a piecepack game by Mark A. Biggar featuring programmed movement. It is a “King of the Hill” game that features a visually striking board with the tiles physically arranged as a hill. Here is the starting diagram for it using an “icy” piecepack tile color scheme to match its snowy Himalayan Yeti theme:

library("piecepackr")
library("ppdf")

icy_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,darkblue", border_color="black", border_lex=6,
                         edge_color.pawn="black", edge_color.tile="lightblue", depth.pawn=0.25)
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c",
                    suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                    suit_cex="0.6,0.7,0.75,0.9,0.9")
cfg <- pp_cfg(c(piecepack_suits, icy_colorscheme))
pmap_piece(piecepack_everest(), cfg=cfg, default.units="in", op_scale=1.0, trans=op_transform)

Starting diagram for a game of Everest

Unicode piecepack diagrams

2019-09-02T00:00:00-07:00

This article includes details on how to make piecepack game diagrams using just Unicode. There is another article full of tables of useful piecepack Unicode symbols.

Contents

Unicode text diagram theory
- Rank and Suit symbols
  - Rotation
  - Color
- Coins
- Dice
- Pawns
- Tiles
Functions to generate Unicode diagrams
Game Bit Fonts

Unicode text diagram theory

Rank and Suit symbols

The standard (and many non-standard) piecepack suit and rank symbols are available in Unicode. See the Unicode symbols article for tables of piecepack Unicode suit and rank symbols.

Rotation

Although Unicode in general doesn’t support character rotations for some rank/suit symbols Unicode also has glyphs that are (or look like they are) rotated versions of those glyhps (i.e. both ☾ and ☽ (crescent) moons and both † and ⸸ daggers) or are symbols that are symmetric across certain (or all) axes of rotation such as the (alchemical) sun symbol ☉. For some piecepack game diagrams you’ll want to have rotated versions of your rank/suit symbols in order to indicate rotated coins, tiles, dice, and perhaps directional pawns. Often Unicode will only have (if any) one or two rotations but will sometimes have more rotations - in particular Unicode 12.0 includes all 45 degree rotations of chess piece glyphs.

Color

In general Unicode itself doesn’t encode color. But many text platforms do support coloring individiual characters such as terminals:

And web pages:

If on such a platform you could color the suit/rank symbols in the appropriate suit color or perhaps (as suggested by Michael Van Biesbrouck) use color to indicate levels of height.

Coins

To represent a piecepack coin simply take the relevant (potentially rotated) suit/rank symbol and combine with the “Combining Enclosing Circle” U+20DD. Theoretically Unicode also supports adding a directional mark to the suit/rank symbol with one of the several Combining Diacritical Marks (should be done before adding the enclosing circle) but I couldn’t get such a glyph combination to look nice in any of the (monoscale) fonts I tried.

Dice

To represent a piecepack die simply take the relevant (potentially rotated) suit/rank symbol and combine with the “Combining Enclosing Square” U+20DE. If you need to support 45/135/225/315 degree rotations there is also “Combining Enclosing Diamond” U+20DF (although depending on your aesthetics you may want to use that for your pawn). Piecepack dice that follow the Anatomy of a piecepack standard don’t have directional/suit marks but if you really want some one possibility found in Unicode’s Combining Diacritical Marks are the s, m, c, and a superscripts.

Pawns

Depending on your aesthetics (and whether you need directional pawns and/or need to be able to distinguish pawns without aid of color) there are different options for pawns:

Combine the relevant (potentially rotated) suit symbol with the “Combining Enclosing Diamond” U+20DF. This supports rotation in 90 degree rotations and lets you use your suit symbol.
Combine the relevant suit symbol with the “Combining Enclosing Upward Pointing Triangle” U+20E4. Still lets you use your suit symbol but doesn’t support any rotations (but standard piecepack pawns are not inherently directional anyways).
Use the (chess) pawn symbol ♟ U+265F. Hard to distinguish suits unless you can apply color (and the people reading your diagrams aren’t color-blind). With Unicode 12.0 can rotate the pawn symbol in all 45 degree rotations.
Use the two chess pawn symbols and two chess bishop symbols for the four piecepack pawns. Even if can’t apply color should be visually distinct (although maybe hard to remember which goes with each suit) and with Unicode 12.0 can rotate in all 45 degree rotations.

Tiles

Tiles are drawn using box-drawing characters. An individual tile is drawn with 5x5 (for a total of 25) characters but when other tiles are placed “adjacently” they will “share” border characters (so for example 2x2 tiles will be 9x9 characters). When placing pieces in the “cells” of the tile place them on the even rows/columns of the tile. When placing pieces on the “points” of the tile place them on the odd rows/columns of the tile.

Functions to generate Unicode diagrams

The ppcli R packages has a prototype function cat_piece() which generates piecepack Unicode text diagrams given data frame input (the same data frame input supported by pmap_piece()). The diagrams generated by it look okay (but not perfect) with my terminal set to use GNU FreeMono (with a couple other fonts implicitly providing glyph backup support):

library("ppcli")
library("ppdf")
cat_piece(piecepack_fide_chess())

cat_piece(piecepack_xiangqi())

cat_piece(piecepack_backgammon())

The ppn R package also can generate piecepack Unicode text diagrams of moves in a game recorded in Portable Piecepack Notation (PPN) files with the function cat_move() (it is a wrapper around cat_piece()):

library("ppn")
ppn <- read_ppn(system.file("ppn/relativity.ppn", package="ppn"))
game <- ppn[[1]]
cat_move(game)

Game Bit Fonts

Game Bit Mono and Duo are a pair of bitmap fonts with with special piecepack support in its Private Use Area:

Game Bit Duo is a fixed-width duospaced font. “Fullwidth” Characters intended for use in diagrams are square whereas some blocks such as Basic Latin are “halfwidth” to better support text rendering. Game Bit Mono is the same as Game Bit Duo except all characters are square.
Has support for several public domain game systems both in Unicode proper and its Private Use Area. In particular in its Private Use Area has the important piecepack rank/suit symbols including support for all rotated versions of the glyphs. These symbols look nice when combined with various combining/enclosing marks to create piecepack coins, dice, and pawns.
Supports all Box Drawing and Block Elements characters. These combine well with the game bits so it looks like those pieces are truly on top of the tiles (i.e. no lines going through the “edge” of piecepack coins, dice, pawns or awkward gaps between lines and piece “edges”). Includes additional box-drawing characters in its Private Use Area.

Unicode Piecepack Symbols

2019-08-29T00:00:00-07:00

This article includes tables of potentially useful Unicode symbols for making piecepack graphics. There is another article with more info on making piecepack Unicode diagrams.

Contents

Suit Symbols
Piecepack Ranks
- Null
- Ace
- Dozenal Extensions
- Chess
Zodiac Symbols
How to use with piecepackr
Footnotes

Suit Symbols

Neutral/Wild Unsuit

Note

Noto Sans Cham is one of the few fonts that support the “Cham Punctuation Spiral” (arguably the best spiral in Unicode).

Spirals
Glyph	Code	Name
꩜	U+AA5C	Cham Punctuation Spiral
🍥	U+1F365	Fish Cake with Swirl Design
@	U+0040	At Sign
☯	U+262F	Yin Yang
🌀	U+1F300	Cyclone
∂	U+2202	Partial Differential
໑	U+0ED1	Lao Digit One

Joker Stars
Glyph	Code	Name
★	U+2605	Black Star
☆	U+2606	White Star
✪	U+272A	Circled White Star
✯	U+272F	Pinwheel Star
	U+0E00A	Black Joker Symbol (Quivira PUA)
	U+0E00B	White Joker Symbol (Quivira PUA)

Piecepack suits

Note

The orthodox demo gives an example of an Anatomy of a piecepack standard piecepack.

Suns
Glyph	Code	Name
☉	U+2609	sun
🌞	U+1f31e	sun with face
☀	U+2600	black sun with rays
☼	U+263c	white sun with rays
⛅	U+26c5	sun behind cloud
✺	U+273a	sixteen pointed asterisk
❂	U+2742	circled open centre eight pointed star
❊	U+274a	eight teardrop-spoked propeller asterisk
❋	U+274b	heavy eight teardrop-spoked propeller asterisk
✹	U+2739	twelve pointed black star
🟒	U+1f7d2	light twelve pointed black star
🟓	U+1f7d3	heavy twelve pointed black star
⛯	U+26ef	map symbol for lighthouse
⛭	U+26ed	gear with hub

Moons
Glyph	Code	Name
☽	U+263d	first quarter moon
☾	U+263e	last quarter moon
⏾	U+23fe	power sleep symbol
🌑	U+1f311	new moon symbol
🌒	U+1f312	waxing crescent moon symbol
🌓	U+1f313	first quarter moon symbol
🌔	U+1f314	waxing gibbous moon symbol
🌕	U+1f315	full moon symbol
🌖	U+1f316	waning gibbous moon symbol
🌗	U+1f317	last quarter moon symbol
🌘	U+1f318	waning crescent moon symbol
🌙	U+1f319	crescent moon
🌚	U+1f31a	new moon with face
🌛	U+1f31b	first quarter moon with face
🌜	U+1f31c	last quarter moon with face
🌝	U+1f31d	full moon with face
◐	U+25d0	circle with left half black
◑	U+25d1	circle with right half black

Crowns
Glyph	Code	Name
👑	U+1f451	crown
♛	U+265b	black chess queen
♚	U+265a	black chess king
♕	U+2655	white chess queen
♔	U+2654	white chess queen
ȸ	U+0238	small letter db digraph

Note

According to the Anatomy of a Piecepack standard the “Fleur-de-lis” should be used for the Arms symbol but the popular JCD piecepack uses an “Anchor” [1] and I’ve tinkered with using the “Dagger” [2].

Arms
Glyph	Code	Name
⚜	U+269c	fleur-de-lis
⚓	U+2693	anchor
†	U+2020	Dagger
Ϯ	U+03ee	Coptic capital letter dei

French suits

Note

The dual piecepacks demo has examples of French-suited piecepacks.

French
Glyph	Code	Name
♠	U+2660	Black Spade Suit
♤	U+2664	White Spade Suit
♥	U+2665	Black Heart Suit
♡	U+2661	White Heart Suit
♦	U+2666	Black Diamond Suit
♢	U+2662	White Diamond Suit
♣	U+2663	Black Club Suit
♧	U+2667	White Club Suit

Swiss/German suits

Note

These symbols aren’t in Unicode proper but are in Quivira‘s Private Use Area. The dual piecepacks demo has examples of Swiss-suited piecepacks.

Swiss/German suits in Quivira’s Private Use Area
Glyph	Code	Name
	U+0E000	German Playing Card Symbol Acorns
	U+0E001	German Playing Card Symbol Leaves
	U+0E002	German Playing Card Symbol Hearts
	U+0E003	German Playing Card Symbol Bells
	U+0E004	Swiss Playing Card Symbol Shields
	U+0E005	Swiss Playing Card Symbol Roses

Possible Swiss suits in Unicode proper
Glyph	Code	Name
⛨	U+26E8	Black Cross on Shield
🛡	U+1F6E1	Shield
⛊	U+26CA	Turned Black Shogi Piece
⛉	U+26C9	Turned White Shogi Piece
🌹	U+1F339	Rose
⚘	U+2698	Flower
❀	U+2740	White Florette
🌰	U+1F330	Chestnut
🔔	U+1F514	Bell
🎐	U+1F390	Wind Chime

Latin suits

Note

These symbols aren’t in Unicode proper but are in Quivira‘s Private Use Area. The dual piecepacks demo has an example of a Latin-suited piecepacks.

Latin suits in Quivira’s Private Use Area
Glyph	Code	Name
	U+0E006	Spanish Playing Card Symbol Clubs
	U+0E007	Spanish Playing Card Symbol Swords
	U+0E008	Spanish Playing Card Symbol Cups
	U+0E009	Spanish Playing Card Symbol Coins

Possible Latin suits in Unicode proper
Glyph	Code	Name
⚚	U+2624	Caduceus
⚕️	U+2695	Medical Symbol
🗡️	U+1F5E1	Dagger
𐃉	U+100C9	Linear B Ideogram B233 Sword
⚔	U+2694	Crossed Swords
🏆	U+1F3C6	Trophy
🥤	U+1F964	Cup With Straw
☕	U+2615	Hot Beverage
𐇛	U+101DB	Phaistos Disc Sign Shield
💰	U+1F4B0	Money Bag

Elements Suits

Note

The Chinese zodiac demo uses some Element symbols as suits.

Elements symbols
Glyph	Code	Name
🜁	U+1F701	Alchemical Symbol for Air
☁️	U+2601	Cloud
🌪️	U+1F32A	Cloud with Tornado
💨	U+1F4A8	Dashing Symbol
🌀	U+1F300	Cyclone
🌬️	U+1F32C	Wind Blowing Face
🌥️	U+1F325	Sun Behind Large Cloud
🌦️	U+1F326	Sun Behind Rain Cloud
🌨️	U+1F328	Cloud with Snow
🌩️	U+1F329	Cloud with Lightning
🜂	U+1F702	Alchemical Symbol for Fire
🔥	U+1F525	Fire
🜃	U+1F703	Alchemical Symbol for Earth
⛰️	U+26F0	Mountain
🌋	U+1F30B	Volcano
🌲	U+1F332	Evergreen Tree
💎	U+1F48E	Gem Stone
🜄	U+1F704	Alchemical Symbol for Water
🌊	U+1F30A	Water Wave

Seasons Suits

Seasons symbols
Glyph	Code	Name
⛄	U+26C4	Snowman Without Snow
❄️	U+2744	Snowflake
🌼	U+1F33C	Blossom
🥒	U+1F952	Cucumber
🍐	U+1F350	Pear
🍏	U+1F34F	Green Apple
🥑	U+1F951	Avocado
🍈	U+1F348	Melon
🌴	U+1F334	Palm Tree
🍉	U+1F349	Watermelon
🌾	U+1F33E	Sheaf of Rice
🌽	U+1F33D	Ear of Corn
🎃	U+1F383	Jack-O-Lantern
🍂	U+1F342	Fallen Leaf
🍁	U+1F341	Maple Leaf

Piecepack Ranks

Null

Null Symbol
Glyph	Code	Name
	U+0020	Space
N	U+004E	Latin Capital letter N
n	U+006E	Latin Small letter n
∅	U+2205	Empty Set
0	U+0030	Digit Zero

Ace

Ace Symbol
Glyph	Code	Name
A	U+0041	Latin Capital letter A
a	U+0061	Latin Small Letter A
@	U+0040	At sign
1	U+0031	Digit One

Dozenal Extensions

Dozenal Symbols
Glyph	Code	Name
X	U+2169	Roman Numeral Ten
↊	U+218B	Turned Digit 2
↋	U+218B	Turned Digit 3

Chess

Chess Symbols
Glyph	Code	Name
♚	U+265A	Black Chess King
♛	U+265B	Black Chess Queen
♜	U+265C	Black Chess Rook
♝	U+265D	Black Chess Bishop
♞	U+265E	Black Chess Knight
♟	U+265F	Black Chess Pawn
♔	U+2654	White Chess King
♕	U+2655	White Chess Queen
♖	U+2656	White Chess Rook
♗	U+2657	White Chess Bishop
♘	U+2658	White Chess Knight
♙	U+2659	White Chess Pawn

Zodiac Symbols

Western Zodiac
Glyph	Code	Name
♈︎	U+2648	Aries
♉︎	U+2649	Taurus
♊︎	U+264A	Gemini
♋︎	U+264B	Cancer
♌︎	U+264C	Leo
♍︎	U+264D	Virgo
♎︎	U+264E	Libra
♏︎	U+264F	Scorpio
♐︎	U+2650	Sagittarius
♑︎	U+2651	Capricorn
♒︎	U+2652	Aquarius
♓︎	U+2653	Pisces

Note

The Chinese zodiac demo uses Chinese zodiac symbols as rank symbols.

Chinese Zodiac
Glyph	Code	Name
🐀	U+1F400	Rat
🐁	U+1F401	Mouse
🐭	U+1F42D	Mouse Face
🐂	U+1F402	Ox
🐃	U+1F403	Water Buffalo
🐄	U+1F404	Cow
🐮	U+1F42E	Cow Face
🐅	U+1F405	Tiger
🐯	U+1F42F	Tiger Face
🐇	U+1F407	Rabbit
🐰	U+1F430	Rabbit Face
🐉	U+1F409	Dragon
🐲	U+1F432	Dragon Face
🐍	U+1F40D	Snake
🐎	U+1F40E	Horse
🐴	U+1F434	Horse Face
🐏	U+1F40F	Ram
🐐	U+1F410	Goat
🐑	U+1F411	Ewe
🐒	U+1F412	Monkey
🐵	U+1F435	Monkey Face
🐓	U+1F413	Rooster
🐔	U+1F414	Chicken
🐕	U+1F415	Dog
🐶	U+1F436	Dog Face
🐖	U+1F416	Pig
🐗	U+1F417	Boar
🐷	U+1F437	Pig Face

How to use with piecepackr

Assuming you have appropriate fonts on your system, in order to use a particular Unicode glyph with piecepackr‘s configuration lists you prepend the Unicode hexadecimal code with a \u if the Unicode hexadecimal code is 4 “digits” long and \U if the Unicode hexadecimal form is more than 4 “digits” long. If your locales and encodings are set-up properly you can also just directly use the Unicode character directly.

library("piecepackr")
ranks_noto <- list(rank_text="n,a,2,3,4,5", rank_fontfamily="Noto Sans")
dark_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,grey")
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="0.6,0.7,0.75,0.9,0.9")
dual1 <- c(piecepack_suits, dark_colorscheme, ranks_noto)
dual1 <- pp_cfg(dual1)
ppdf::piecepack_preview() |> pmap_piece(cfg=dual1, default.units="in")

A preview of the piecepack-suited piecepack

Some characters have both a text and emoji form. You can force the text form or the emoji form by adding the appropriate “Variation Selector” after the code.

Variation Selectors
Code	Name
U+FE0E	text variation selector
U+FE0F	emoji variation selector

cat("\U1f31e\ufe0e\n")

## 🌞︎

cat("\U1f31e\ufe0f\n")

## 🌞️

Footnotes

[1]	For compatibility with the Anchor-and-Crowns suited Empire Deck.

[2]	Unicode has a Turned version of the Dagger which is useful for making Unicode text diagrams.

Portable Piecepack Notation

2019-08-01T00:00:00-07:00

Version: 0.14.2

Portable Piecepack Notation (PPN) is a human-readable plaintext file format for storing board games. The default Movetext parser is designed to be provide a fairly flexible notation system out of the box for playing a large variety of games but the structure is designed allow support for parsing alternative notation systems in the future as well. Originally intended for notating piecepack games, it also provides some support for other game systems as well. There is a prototype parser for this file format written in R that can be used to generate 2D/3D graphical images, plaintext Unicode diagrams, and animations for the games saved in this file format.

Warning

The “Portable Piecepack Notation” is in alpha development and the specification is not likely to remain stable. I’d appreciate alpha testers to test things out but probably not a good idea to start storing large amount of games in the format just yet.

Contents

Examples

Chess

An example game of chess:

---
GameType: International Chess
...
{"The Immortal Game: Adolf Anderssen - Lionel Kieseritzky, 1851"}
1. e2-e4 1... e7-e5 2. f2-f4 2... e5:f4
3. f1-c4 3... d8-h4 4. e1-f1 4... b7-b5
5. c4:b5 5... g8-f6 6. g1-f3 6... h4-h6
7. d2-d3 7... f6-h5 8. f3-h4 8... h6-g5
9. h4-f5 9... c7-c6 10. g2-g4 10... h5-f6
11. h1-g1 11... c6:b5 12. h2-h4 12... g5-g6
13. h4-h5 13... g6-g5 14. d1-f3 14... f6-g8
15. c1:f4 15... g5-f6 16. b1-c3 16... f8-c5
17. c3-d5 17... f6:b2 18. f4-d6 18... c5:g1
19. e4-e5 19... b2:a1 20. f1-e2 20... b8-a6
21. f5:g7  21... e8-d8 22. f3-f6 22... g8:f6
23. d6-e7 {checkmate!}

Checkers

An example game of checkers:

---
GameType: American Checkers
...
1. e3-d4 1... d6-e5 2. d2-e3 2... h6-g5
3. g3-h4 3... e7-d6 4. f2-g3 4... b6-a5
5. g3-f4 5... e5-g3;*f4 6. h2-f4;f4-h6;*g3*g5 6.... c7-b6
7. c1-d2 7... f6-e5 8. d4-f6;*e5 8... g7-e5;*f6
9. e3-d4 9... e5-f4 10. d4-e5 10... d6-c5
11. c3-b4 11... c5-d4 12. d2-e3 12... f4-d2;*e3
13. e1-c3;*d2 13... d4-e3 14. c3-d4 14... e3-d2
15. b4-c5 15... d2-e1;Mv@e1 16. b2-c3 16... 2e1-d2
17. a3-b4 17... 2d2-e3 18. a1-b2 18... d8-c7
19. b2-a3 19... f8-e7 20. c5-d6 20... e7-c5;*d6
21. b4-d6;*c5 21... 2e3-c5;2c5-e7;*d4*d6 22. g1-f2 22... 2e7-d6
23. e5-f6 23... b6-c5 24. f2-e3 24... a7-b6
25. h4-g5 25... 2d6-e5 26. f6-e7 26... b8-a7
27. e7-d8;A@d8 27... c5-d4  28. e3-c5;*d4 28... b6-d4;d4-b2;*c3*c5
29. 2d8-b6;*c7 29... a7-c5;*2b6 30. g5-f6 30... 2e5-g7;*f6
31. h6-f8;*2g7 C@f8 31... b2-c1;Sv@c1 32. 2f8-e7 32... a5-b4
33. 2e7-d6 33... b4-c3 34. 2d6-b4;2b4-d2;*c3*c5 34.... 2c1-e3;*2d2
35. a3-b4 35... 2e3-d4 36. b4-a5 36... 2d4-c5
37. a5-b6 37... 2c5-a7;*b6

Desfases

An example game of Desfases:

---
GameType:
    Name: Desfases
    Seed: 42
...
1S. ?S{n,a,2,3,5}@>90; a1-a4; ?Sd~3
1M. ?M{n,a,2,4,5}@>90; e3-c1; ?Md~2
1C. ?C{n,2,3,4,5}@>90; e2-e4; ?Cd~n
1A. ?A{n,a,2,4,5}@>90; b5-e5; ?Ad~2
2S. ?S{a,2,4}@>90; a4-b3; ?Sd~2
2M. ?M{0..4}@>90; c1-b2; ?Md~a
2C. ?C{0..5}@>90; &?dC[2]-c3; ?Cnc{~b,_%?Cd}
2A. ?A{0..4}@>90; e5-d4; ?Ad~a
3S. ?S{n,a,3,4,5}@>90; b3-a2; ?Sd~a
3M. ?M{0..4}@>90; b2-a3; ?Md~n
3C. ?C{1..5}@>90; &?dC[2]-e5; ?C4c{~b,_%?Cd} ?Cd~4
3A. ?A{a,2,3,5}@>90; d4-d2; ?Ad~n
4S. ?S{n,a,2,4,5}@>90; a2-b2; ?Sd~n
4M. ?M{0..4}@>90; &?dM[2]-b3; ?M2c{~b,_%?Md} ?Md~2
4C. ?C{0..5}@>90; e4-a4; ?Cd~3
4A. ?A{n,2,3}@>90; &?dA[2]-d3; ?Aac{~b,_%?Ad} ?Ad~a
5S. ?S{n,a,4}@>90; &?dS[2]-a2; ?Snc{~b,_%?Sd} ?Sd~n
5M. ?M{n,a,2,3,5}@>90; a3-a1; ?Md~a
5C. ?C{0..4}@>90; a4-b3; ?dC~2
5A. ?A{n,2,3,4}@>90; d2-e2; ?dA~n
6S. ?S{n,a,5}@>90; &?dS[2]-c2; ?S2c{~b,_%?Sd} ?Sd~2
6M. ?M{n,a,2,3,5}@>90; a1-a3; ?Md~n
6C. ?C{n,2,4}@>90; b3-a4; ?Cd~a
6A. ?A{0..3}@>90; &?dA[2]-e3; ?A2c{~b,_%?Ad} ?Ad~2
{ 15 more rounds to complete a full game... }

Four Field Kono

An example game of Four Field Kono:

GameType: Four Field Kono

1. b1:b3 1... d3:b3 2. c1:c3 2... a3:c3 3. c2-c1 3... b4:b2 4. a1-b1 4... b3:b1
5. d1:b1 5... c3-c2 6. a2-a3 6... b2:d2 7. a3-b3 7... c4-c3 8. c1-d1 8... d4-d3
9. b1-b2 9... d2:b2 10. b3-a3 10... b2-b1 {Player 1's loss is assured with the
 separation of their two remaining pieces and they should resign in a real game}
11. a3-a2 11... b1-c1 12. d1-d2 12... c1-d1 13. a2-a3 13... a4-b4
14. a3-a4 14... b4-c4 15. a4-b4 15... c4-d4 16. b4-a4 16... d4:d2 {Player 2 wins}

Fuji-san

A game of Fuji-san with a specific starting coin setup:

---
GameType:
  Name: Fujisan
  Coins: "44452n24n3aa/a25335325ann"
...
1. a1-b1 2. n2-k2 3. b1-e1 4. e1-j1 5. j1-j2 6. j2-l2 7. k2-m2 8. m2-m1
9. l2-l1 10. n1-k1 11. m1-i1 12. i1-d1 13. d1-d2 14. l1-i1 15. i1-i2 16. k1-k2
17. k2-e2 18. i2-c2 19. a2-f2 20. e2-h2 21. h2-g2 22. c2-h2 23. h2-h1 24. d2-h2
25. f2-b2 26. b2-b1 27. b1-g1

Ice Floe

A game of Ice Floe:

---
GameType: Ice Floe
...
PlacePawns. pS@e11 pM@k6 pC@f0 pA@(0,5)
RollDice. dS5@f11 dMa@k5 dC3@e0 dA2@(0,6)
PlacePyramids. xn{S@h7,M@d5,C@j1,A@b1}; xa{S@d3,M@f3,C@j9,A@f9};
               x2{S@b5,M@b9,C@h1,A@j3}; x3{S@h5,M@d9,C@d7,A@f1};
               x4{S@h9,M@b3,C@d1,A@b7}; x5{S@h3,M@j7,C@f7,A@j5};
Round1. ?xS4-3L; ?xM3-f10; *4?Ca; ?xC2-g3; ?xAn-d4;-h4; *4?C2;
        ?d{S~5,M~n,C~n,A~a} . c5A@g11 c4A@k4 c3A@d0 cnS@(0,7) . *2?An . *?M2
Round2. ?xMn-3L;-2U; ?xC3-b8; *4?S4; ?xA3-3R; ?xSa-3L;
        ?d{S~5,M~a,C~n,A~a} . 2@g0; 2@d11; a@h0; */cf; ?c5~C ?c{4,3,n}~S . *2?Sn; *?S3
Round3. ?xC4-4R; ?xA3-3L; ?xSn-3L; ?xM2-2SE;-f8; *4?Aa;
        ?d{S~5,M~4,C~5,A~5} . ?c{5,3,n}~M ?c4~C . *2?M5 . *?S5
Round4. ?xA3-2UL;-b4;*4?A2; ?xS2-4U; 2?Ma-2U; ?xC4-i3;
        ?d{S~3,M~3,C~2,A~3} . ?c{5,4}~C ?c3~A ?cn~M;
        a@(0,4); 2@k3; 2@(0,3); a@{k2,d11} . */cf; *3?C3; *?M4
{ Final coins: Suns: none; Moons: none; Crowns: none; Arms: none }
{ Final score: Suns: 3, Moons: 2, Crowns: 3, Arms: 0 }

Japan

An example game of Japan:

---
  GameType:
    Name: Japan
    Seed: 42
...
1R. R`6-3'<@(10.5,3)
1B. B`4-4'<@(2.5,5)
2R. R`1-5'@(12,4.5)
2B. B`6-4'@(4,6.5)
3R. R`5-2'<@(7.5,2)
3B. Ada@(7,1); (8,1)-(15,3)
4R. R`0-1'@(13,2.5)
4B. (7,1)-(14,3); ?Ad~5; (14,2)-(15,2)
5R. Sp@(12,2); (12,3)-(0,4)
5B. B`2-6'<@(1.5,6)
6R. Sda@(1,4); (1,5)-(0,5)
6B. Ap@(2,7); (1,7)-(15,3)
7R. R`2-0'<@(12.5,7)
7B. B`2-1'@(11,7.5); (12,8)-(15,3)
8R. R`1-3'<@(13.5,6); (14,7)-(0,4)
8B. B`0-2'@(5,2.5)
9R. R`5-5'@(11,5.5); (12,6)-(0,2)
9B. B`1-5'<@(2.5,3)
10R. R`3-3'@(10,4.5); (11,4)-(0,6)
10B. B`1-1'@(3,1.5)
11R. R`6-1'@(1,2.5); *(2,2)
11B. B`5-4'<@(8.5,4)
12R. R`6-2'<@(9.5,2)
12B. B`3-1'>@(3.5,4)
13R. R`6-4'@(9,6.5)
13B. (14,3)-(10,7); (10,7)~4; (10,6)-(15,4)
14R. R`6-0'@(8,5.5); (9,5)-(0,5)
14B. (8.5,4){~v,-(14\,2.5)} B`0-0'<@(8.5,4)
15R. R`6-5'@(7,4.5)
15B. B`6-3'@(6,4.5)
16R. */Sp
16B. B`6-5'<@(6.5,6)
17R. R`6-6'<@(3.5,8)
17B. ?Ad-(3,6); ?Ad~3; (3,7)-(15,7)
18R. (3.5,8)-(7.5,8) R`0-0'>@(3.5,8)
18B. B`6-6'<@(5.5,7)
19R. R`2-4'@(12,1.5)
19B. ?Ad-(14,5); ?Ad~2
20R. ?Sd-(6,3); ?Sd~5; (6,2)-(0,3)
20B. */Ap
21R. Sp@(8,3); (7,3)-(0,6) (9,3)-(0,7)
21B. Ap@(13,4); (14,4)-(15,6) (13,5)-(0,2)
22R. */Sp
22B. */Ap
23R. Sp@(11,2); (11,1)-(0,5)
23B. Ap@(5,5); (4,5)-(15,5) (5,4)-(15,4) (5,6)-(15,7)
24R. ?Sd-(7,7); ?Sd~4; (8,7)-(0,7)
24B. ?Ad-(4,1); ?Ad~n
25R. ?Sd-(4,3); ?Sd~3; (4,2)-(0,6)

Martian Chess

An example game of Martian Chess:

---
MovetextParser: Icehouse
GameType:
  Name: Martian Chess
  Seed: 42
...
1. d3-d4 1... b6-c5
2. d4-c4 2... b7-b5
3. c5-c0 c4-c5 3... b3-b9 b5-b3
4. b3-a3 4... c3-a9 c5-c3
5. d2-d3 5... c7-d6
6. a6-a0 d3-a6 6... a3_%a9 a6-a3
7. a7-b0 a3-a7 7... b2-d9 b8-b2
8. c3-c4 8... c6-b5
9. b5-d0 b2-b5 9... b1-c9 b5-b1
10. c4-a4 10... a4_%b9 a7-a4
11. a8_%a0 a4-a8 11... d6-c7
12. b1-b3 12... a8-d5
13. d5_%d0 d1-d5 13... b3_%c9 d5-b3
14. b3-c4 14... c8_%c7
15. 2c7-b0 c4-c7 15... c2_%d9 c7-c2

Plans of Action

An example game of Plans of Action:

---
GameType:
    Name: Plans of Action
    Coins: SASASS/MMACSS/CACCAA/MCMCMM
...
(5,3)-4U; (3,3)-2L; 5(5.5,5.5)$>90!; (5,5)-4L; (2,5)-3R;-2D; (3,5)-2D;
({2..7},3)-2D; (3,4)-3U; (4,5)-2U; (6,4)-3L;-4U; (6,6)-2U; (2,6)-4R; (1,5)-4R;
(7,6)-3D;-2L; (4,6)-3R; (6,6)-3D;-3L; (5,3)-3L; (7,6)-3D; (3,3)-2U; (7,3)-3L;
({3,5,6,7},5)-2D; (5,4)-4L; (1,3)-3U; (5,7)-3D; (1,4)-5R; (1,6)-2D; (7,4)-2U;
(3,6)-3R; (5,6)-2L;-2D; ({1..6},4)-2D; (4,7)-2D;-2R; (3,7)-3D;-2R; (3,8)-2D;
(6,8)-2L;-2D; (6,5)-3U;-2R;-2D; (5,4)-2U;

Relativity

An example game of Relativity:

---
Round: Night
GameType:
    Name: Relativity
    Coins: "n45a5n/3a2243/3n4a2n/a25345"
...
{ Notes: Space has power of adjacency while Time has power of sequence }
1S. d3#e3 1T. d3#d1
2S. c2#c3 2T. d2#b1;M2@e6
3S. b2#a2 3T. e3#b2
4S. f1#f4 4T. e2#a3;M3@e6
5S. c4#d4 5T. f1#a1
6S. c1#c4;M5@b6 6T. b3#a3
7S. f3#a3 7T. d1#a3
8S. f2#f3 8T. b1#d2
9S. f3#a3;Mn@b6 9T. e2#c2
10S. e1#f1 10T. f1#d4
11S. c2#c3 11T. d4#c4
12S. b2#c2 12T. c1#e2;Ma@e6

Tablut

An example game of Tablut:

---
GameType: Tablut
...
1. a4-a3 1... c5-c3 2. d1-d3 2... e7-c7
3. f1-f3;*e3 3... e4-e3;*d3 4. f9-f7 4... g5-g3;*f3
5. h5-g5 5... d5-d1 6. d9-d3 6... f5-f1;*e1
7. a3-b3;*c3 7... c7-c3;*d3 8. i4-e4;*e3 8... g3-e3;*e4
9. i5-i4 9... e5-f5 10. i6-f6 10... f5-f4
11. a5-a4 11... f4-g4 12. e2-g2 12... e3-g3
13. f6-f4 13... e6-e4;*f4 14. f7-f4 14... g4-h4
15. f4-g4;*h4

Tic-Tac-Toe

A simple game of Tic-Tac-Toe with no automatic setup:

---
Event: Example Tic-Tac-Toe Game
Result: 1-0
...
setup. t@b2
1. S@b2 1... M@a2 {? (1... M@a1)}
2. S@c1 2... M@a3
3. S@a1 3... M@c3
4. S@b1 {X wins}

PPN File Structure

PPN files are text files ending in .ppn containing one or more games in PPN notation.

Each game in the file should start with a line beginning with ---
- This line is recommended but optional for the first game in a PPN file. If the first game in each PPN file begins with a --- then one can build larger PPN file archives by simply concatenating smaller PPN files together (i.e. with the *nix cat command).
Each game starts with a Metadata section and ends with a Movetext section.
PPN files should be assumed to use an UTF-8 character encoding (this includes ASCII) with no maximum line length.

Metadata

The Metadata section should be a single “Mapping” expressed in YAML.
- It is recommended to use the subset of YAML understood by both the 1.1 and 1.2 YAML standards since not all popular parsers understand both (or just YAML 1.2).
It should begin with a line starting with ---
- This is the same --- we said begins each game.
- The --- is recommended but optional for the first game in a PPN file.
It should end with a line starting with ...
- This ... is recommended but optional if the Metadata section does not have any empty lines and there is at least one empty line between the Metadata and Movetext sections.
- If there are no lines starting with ... and no empty lines the Metadata section should be assumed to be empty.
All Metadata keys are optional.
- If the Metadata section is empty PPN parsers should use the default Movetext parser described in a later section to interpret the Movetext (without doing any initial game piece setup).
- One can specify the Movetext parser to use (possibly a diferent one for each game) via the MovetextParser key with a string indicating the parser to use. Movetext parsers are passed both the Metadata section and the Movetext section.

Movetext

Regardless of the Movetext parser to be used the Movetext should not have any lines starting with --- or ...
Should be (initially) parsed as UTF-8 text without restrictions on line length.
Additional restrictions based on which Movetext parser is used to parse it. The default Movetext parser and its additional restrictions are described in the Default Movetext Parser section.

Default Movetext Parser

The default Movetext Parser supports automatic Setup for various piecepack games via the Metadata mapping.
The default Movetext Parser supports the following Movetext elements:
Each element needs to be separated from other elements by whitespace
- Whitespace is defined as tabs, newlines, form feeds, and any character in the Unicode Z Category.
- All whitespace between elements (and in comments) will be converted to single spaces.
The default parser keeps track of the (x,y) coordinates of pieces and an ordering they can be placed on the board to reproduce the state of the board after that move. For convenience we will sometimes refer to pieces placed on the board later (earlier) in this ordering as being placed “above” (“beneath”) those placed earlier (later) in this ordering, please note however that in real life a high stack of pieces placed earlier may physically be “above” an adjacent single piece placed later.

Setup

Currently the Movetext Parser uses the SetUp field in the Metadata to provide game setup, if that field is missing it will use the GameType field to provide game setup. This value should either be a string with the game’s name or a mapping with the field Name with the game’s name and optionally System of the game system to use (for games that can be played with multiple game systems); all other values of this mapping will be passed to the setup.
- Although in general tags will treated case sensitive in this case we first process the string by converting to lower case, removing apostrophes and hyphens, “squishing” the whitespace, and converting spaces to underscores e.g. “Nine Men’s Morris” will be treated as equivalent to “nine_mens_morris”. Occasionally we will provide aliases e.g. “Baroque chess” will be treated as an alias for “Ultima”.
- GameType example of just string of game’s name for setup:
```
GameType: Four Field Kono
```
- GameType example that allows passing more info to setup:
```
GameType:
  Name: Fujisan
  Seed: 11
```
- SetUp and GameType can be used together when a game variant shares its physical setup with another game. GameType records the game being played while SetUp specifies the piece arrangement to use:
```
GameType: Suicide Chess
SetUp: Chess
```
- A SetUp of None will explicitly do an initial board setup with no pieces at all, useful for games you will set up manually in the movetext:
```
GameType: Tic-Tac-Toe
SetUp: None
...
setup. t@b2
```
If there is neither a SetUp field nor a GameType field then this will also result in an initial board setup with no pieces at all.

Parser options

The following built-in parsers are available via the MovetextParser field. They are all built on top of the default parser but differ in their default game system for Setup and their default configuration for colored bits (●):
- piecepack — the standard piecepack parser; this is the default parser used when no MovetextParser is specified (also accessible as default for backwards compatibility)
- alquerque — for alquerque-style games; colored bits use an alquerque configuration
- checker — for checker/draughts games; colored bits use a checkers configuration
- chess — for chess games; colored bits use a chess configuration
- domino — for domino games
- go — for go games; colored bits use a go configuration
- marble — for marble games; colored bits use a marbles configuration
- morris — for Morris games (e.g. Nine Men’s Morris); colored bits use a morris configuration
- tarot — for card games; since French tarot is a superset of the traditional 52-card deck this parser works for both tarot and regular playing card games
Optional arguments can be passed to the parser via the MovetextParser mapping form e.g.:
```
MovetextParser:
  Name: piecepack
  ScalingFactor: 2
```
- ScalingFactor changes how many “inches” a coordinate unit represents i.e. with ScalingFactor: 2 then a1 corresponds to an x-coordinate of 2 inches and a y-coordinate of 2 inches. Accepted by all parsers.
- CellWidth sets the width of each board cell in inches. Valid values are 1 or 2 (default 2). Accepted by the checker and chess parsers e.g.:
```
MovetextParser:
  Name: checker
  CellWidth: 1
```

Macros

The default Movetext Parse performs macro substitution in the Movetext.

Macros are strings surrounded by a ` and ' e.g. `q'@b2 {The default "q" macro is for a black chess queen}.
Macros can be defined in three places (with any identically named macros earlier in this list replacing those later in the list):
1. In a “Macros” field in the Metadata
2. By a specified game setup function
3. The parser includes some builtin macros.
Macro names cannot include whitespace nor the semi-colon ;.
Macro substitution happens after “moves” and “comments” are identified (and split).

Comments

Comments are any text between braces { and }
- All whitespace will be parsed as single spaces, in particular comments can span multiple lines
- Braces are not allowed within comment braces
- Must have white space before the { and after the } (otherwise will be considered to be a brace expansion)

MoveNumbers

Ordinary MoveNumbers are one or more letters, numbers, periods, and/or underscores followed by at least one period
- Unlike in PGN MoveNumbers must end in (at least one) period.
- Ordinary MoveNumbers must have white space before and after.
- One must not have any line start with ... (which could interfere in determining where the Metadata ends).
A single period . (surrounded by white space) is a special shortcut for writing the previous MoveNumber with an extra period added to the end of it e.g. 2. a4-b4 . b4-c4 is equivalent to 2. a4-b4 2.. b4-c4
The semi-colon ; is a special shortcut for writing the minimal a single period MoveNumber (adding some spaces around it if necessary) e.g. 2. a4-b4;b4-c4 is equivalent to 2. a4-b4 . b4-c4 which is equivalent to 2. a4-b4 2.. b4-c4 [1].
Putting MoveNumbers in one’s Movetext is optional but if they exist PPN parsers will often break down and label moves by MoveNumbers (to make animations of a game or visualize the game state at a particular point in the game).

[1]	The intention for this is quickly indicating little “submoves” within a larger proper “move” that we’d like to be able to separately visualize but that we don’t want to semantically mark as a completely separate “move”.

Moves

Moves are comprised of PieceSpec, Location, PieceId, and MoveToken.
One can use Unix-shell-style brace expansions as a shortcut for expressing multiple moves e.g.:
```
t@{b,d}{2..8..2} {Shortcut for t@b2 t@b4 t@b6 t@b8 t@d2 t@d4 t@d6 t@d8}
*{b..f}2 {Shortcut for *b2 *c2 *d2 *e2 *f2}
```
- Unlike Bash-style brace expansions must have a “preamble” or “postscript” otherwise will be interpreted as a comment (but the preamble or postscript can be another brace expansion)

PieceSpec

The default Movetext parser supports specifying pieces by their Piece, Side, Suit, Rank, Angle, and (game system) Configuration.
Any attribute specifications beginning with a comma , must go after the other attribute specifications, otherwise it does not matter which order the piece attributes are specified. However the following ordering may improve readability (omitting any unnecessary elements as necessary):
1. Piece
2. Side
3. Suit
4. Rank
5. Angle
6. Configuration
When necessary the default Movetext will make Assumptions about unspecified elements.

Piece (type)

t for “tile”
c for “coin” if piecepack suit and “checkers2” “bit” if colored suit
d for “die”
p for “pawn”
m for “matchstick” if piecepack suit and “meeples” “bit” if colored suit
s for “saucer” if piecepack suit and “go” stone “bit” if colored suit
● or () for “bit”
▲ or /\ for “pyramid”
🂠 or [] for “card”
■ or [X] for “board”
- Defaults to a “checkers2” board
⚀, ⚁, ⚂, ⚃, ⚄, ⚅ sets the Configuration to “dice”, Piece to “die”, and sets the appropriate Rank (from 1 to 6).
The Unicode chess glyphs sets the Configuration to “chess2”, Piece to “bit”, and sets the appropriate Rank (and possibly Suit)
The Unicode playing card glyphs sets the Configuration to “playing_cards_tarot”, Piece to “card”, and sets the appropriate Rank and possibly Suit.
The Unicode dominoes glyphs sets the Configuration to an appropriate “dominoes” configuration, Piece to “tile”, and sets the appropriate Rank and Suit.
○ indicates a “go” “bit” defaulting to the White Suit.
▦ or [#] indicates a “go” “board” defaulting to the Black Suit.
⛂ and ⛀ indicate a “checkers2” “bit” face-down (men), and ⛃ and ⛁ indicate a “checkers2” “bit” face-up (kings). Without an explicit Suit, ⛂ and ⛃ default to the Black suit and ⛀ and ⛁ default to the White suit.

Side Up

f for “face”
b for “back”
l for “left”
r for “right”
x for “top”

Suit and Configuration

S, M, C, A for “Suns”, “Moons”, “Crowns”, and “Arms” Suit and “piecepack” Configuration
- If a μ or u is present will assume component comes from a (piecepack stackpack) “subpack” Configuration aka “mini piecepack” instead of a normal sized piecepack
- If a ⬢ (U+2B22) is present will assume component comes from a “hexpack” Configuration (a hexagonal piecepack)
♥, ♠, ♣, ♦ for “Hearts”, “Spades”, “Clubs”, and “Diamonds” Suit and “playing_cards_expansion” Configuration
♡, ♤, ♧, ♢ for (inverted 4-colored) “Hearts”, “Spades”, “Clubs”, and “Diamonds” Suit and “dual_piecepacks_expansion” Configuration
R, K, G, B, Y, W for “Red”, “Black”, “Green”, “Blue”, “Yellow”, or “White” Suit
- If a “bit” indicated by ●, ○, or s or a “board” indicated by ▦ or [#] then “go”
- If a “bit” indicated by c, ⛂, ⛀, ⛃, or ⛁ or a “board” indicated by ■ or [X] then “checkers2”
- If a dominoes “tile” Piece then an appropriate colored dominoes [2]
- If a “pyramid” Piece then an “icehouse_pieces” Configuration (invented by Andy Looney aka Looney Labs’ “Looney pyramids”)
- If a μ or u is present will assume component comes from a smaller sized set:
  - “checkers1” instead of a “checkers2” set
  - “chess1” instead of a “chess2” set
,sN manually sets the internal “suit” to the positive integer N and ,C' manually sets the internal “configuration” to the string C.
⚀, ⚁, ⚂, ⚃, ⚄, ⚅ sets the Configuration to “dice”, Piece to “die”, and sets the appropriate Rank (from 1 to 6).
The Unicode chess glyphs sets the Configuration to “chess2”, Piece to “bit”, and sets the appropriate Rank (and possibly Suit)
The Unicode playing card glyphs sets the Configuration to “playing_cards_tarot”, Piece to “card”, and sets the appropriate Rank and possibly Suit.
The Unicode dominoes glyphs sets the Configuration to an appropriate “dominoes” configuration, Piece to “tile”, and sets the appropriate Rank and Suit.
○ indicates a “go” “bit” defaulting to the White Suit (equivalent to W●).
▦ or [#] indicates a “go” “board” defaulting to Black
⛂ and ⛀ indicate a “checkers2” “bit” (men), and ⛃ and ⛁ indicate a “checkers2” “bit” face-up (kings). Without an explicit Suit, ⛂ and ⛃ default to the Black suit and ⛀ and ⛁ default to the White suit.

Rank

0 or n, 1 or a, 2, 3, 4, 5, 6, 7, 8, 9
- 0 and 1 are aliases for the “null” n and the “ace” a especially useful with brace expansions e.g. {5..0}@b5 {Place six coins face up at b5 with a null on top and 5 on bottom}
- 6, 7, 8, 9 don’t exist in a standard piecepack but could exist in piecepack expansions or in components from other game systems.
By default the rank in most game systems are indexed starting with zero, the following game systems are indexed starting with one:
- Icehouse pieces go from 1-pip to 3-pip pieces indicated by 1, 2, and 3 respectively.
,rN manually sets the internal “rank” to the integer N.
⚀, ⚁, ⚂, ⚃, ⚄, ⚅ sets the Configuration to “dice”, Piece to “die”, and sets the appropriate Rank (from 1 to 6).
The Unicode chess glyphs sets the Configuration to “chess2”, Piece to “bit”, and sets the appropriate Rank (and possibly Suit)
The Unicode playing card glyphs sets the Configuration to “playing_cards_tarot”, Piece to “card”, and sets the appropriate Rank and Suit.
The Unicode dominoes glyphs sets the Configuration to an appropriate “dominoes” configuration, Piece to “tile”, and sets the appropriate Rank and Suit.

Angle

^ is 0 degree rotation aka oriented “up”
< is a 90 degree rotation aka oriented “left”
v is a 180 degree rotation aka oriented “down”
> is a 270 degree rotation aka oriented “right”
,aN manually sets an N (numeric double) degree rotation.

Assumptions

If missing Piece:
- If Side is l, r, or x then assumed to be a “pyramid”
- Otherwise if a colored suit then assumed to be a “bit”
- Otherwise if both Suit and Rank are missing or neither Suit and Rank are missing assumed to be a “tile”
- Finally assumed to be a “coin”
If missing Side:
- Pyramids are assumed to be “top” up.
- Tiles and cards are assumed to be “back” up if missing suit and/or rank (else “face”).
- Coins and saucers are assumed to be “face” up if missing suit (else “back”).
- Bits are assumed to be “back” up unless a “chess2” or “chess1” piece
- Else assumed to be “face” up.
If missing Suit:
- Assumed to be “Suns” for “piecepack”, “hexpack”, and “subpack” pieces
- “Hearts” for “playing_cards_expansion” and “dual_piecepacks_expansion” pieces
- “White” for “dice” pieces
- “Red” for “icehouse_pieces” pieces
If missing Rank assumed to be “null” for piecepack pieces [3] while “icehouse_pieces” and “dice” are assumed to be 1-pip.
If missing Angle should be assumed to be oriented straight “up” (i.e. 0 degrees)

Examples

t tile back
Aa> ace of Arms tile (face) oriented “right”
μAa> “subpack” ace of Arms tile (face) oriented “right”
C Crowns coin back (oriented “up”)
cC3b^ (3 of) Crowns coin back (explicitly) oriented “up”
nv null coin face oriented “down”
<dM4 4 of Moons die oriented “left”
d (null of Suns) dice
pM Moons pawn
p♥ Hearts pawn
p (Suns) pawn
K3▲ 3-pipped black icehouse pyramid top

[2]	“dominoes_black”, “dominoes_blue”, “dominoes_green”, “dominoes_red”, “dominoes_white”, and “dominoes_yellow”

[3]	Internally even piecepack pawns and saucers are assigned a rank even though they normally don’t have a rank. Dice are assigned the rank of the face oriented upwards even though technically the dice themselves actually have six ranks.

Location

The default Movetext parser supports locations by Cartesian coordinates, chess-algebraic-style coordinates, or by preceding a PieceId with an &.

Examples:

(2.5,3.5)
(3,2)
c2

Cartesian coordinates

Cartesian coordinates are a left parenthesis followed by a digits (including up to one period) followed by a comma followed by digits (including up to one period) ending in a right parenthesis.
- The digits will be considered to be a “floating-point” number.
- The number left of the comma will be the x-coordinate and the number right of the comma the y-coordinate.

Chess-algebraic-style coordinates

Chess-algebraic-style coordinates begin with lowercase letters followed by digits.
The lowercase letters are considered to be the x-coordinate encoded as a base-26 number using the Roman letters as numerals.
- For the purposes of this there is no “zero”. a is considered equal to 1, z is considered equal to 26, and aa is considered equal to 27.
The digits are considered to the y-coordinate encoded as a (base-10) integer.

Relative coordinates

Relative coordinates has three forms:
1. Offset are coordinates relative to the pieces being moved
2. Offset|Location are coordinates relative to Location (which itself could be expressed in relative coordinates)
3. Offset$PieceId are coordinates relative to the Location of PieceId (it is a shortcut for Offset|&PieceId)
Offset can be specified in two ways:
1. <X,Y> where X is the x-coordinate relative offset and Y is the y-coordinate relative offset e.g. ?pS-<4,-2> {move the suns pawn four to the right and two down from its current position} or ?pS-<-2,3>$?pA {move the suns pawn two to the left and three up relative to the arms pawn}
2. N Direction is a N distance relative offset in the Direction direction
  - The directions are U, R, D, L or alternatively N, E, S, W and represent “Up”, “Right”, “Down” and “Left” orthogonal moves i.e. ?pS-3R {move the suns pawn three to the right}
  - The “intercardinal” directions (i.e. NE, SE, SW, NW as well as UR, DR, DL, UL) represent diagonal moves on a rectangular board i.e. ?pS-3NE {move the suns pawn three to the right and three up}
  - The “half-wind” directions (i.e. NNE, NEN, ESE, SSE, SSW, WSW, WNW, NNW as well as U,R,D,L equivalents) represent diagonal moves on a hexagonal board i.e. ?pS-3NNE {move the suns pawn three in a hexagonal diagonal direction up and right}.
    - Use NNE, SSE, SSW, NNW directions on hexagonal boards that allow horizontal moves and ENE, ESE, WSW, WNW directions on hexagonal boards that allow vertical moves.
    - Note that real-life “half-wind” directions are multiples of 22.5 degrees while the “half-wind” directions in PPN are instead rounded to multiples of 30 degrees (to correspond to hex board movement angles).

Get location from PieceId

A PieceId string preceded by a & indicates the x,y coordinates of that piece.
- The & is optional in front of a ? e.g. 3?A4-2R is a shortcut for 3&?A4-2R
- For the PieceId form N Location it returns the x,y coordinates of that Location.
- Otherwise if PieceId identifies several pieces (e.g. “greedy” search) then it returns the x,y, coordinates of the “last” piece (according to internal ordering of pieces).
An empty Location string is a shortcut for just & i.e. the location of the “last active” piece(s).

PieceId

A PieceId is used to identify specific pieces on the board. Currently PPN supports the following types of PieceId:

A Location is used to identify the top piece at that Location
N Location is used to identify the top N pieces at that Location
- An example would be 2b4-b3*2a2 {Move top two pieces at b4 to b3 and remove top two pieces at a2}
- If there are less than N pieces at that exact Location it will identify the N nearest pieces to the Location (according to 2D Euclidean distance)
Location[Slice] is used to identify a “slice” of pieces at that Location
- Pieces at a location are indexed starting with 1 with pieces “later” in the internal ordering (i.e. “above”) having a lower index
- An example would be b4[1]_%b3[2] {Move the top piece at b4 directly under the secord piece at b3}
- Another example would be b4[3:6]-b3 {Move the third, fourth, fifth, and sixth pieces (from the top) at b4 to b3}
- Another example would be *(2,4)[1,3,5] {Remove the first, third, and fifth pieces (from the top) located at (2,4)}
?PieceSpec is used to identify a single piece with a “non-greedy” search based on their PieceSpec
- First, the PieceSpec is parsed and only the explicitly listed features are searched against. If there is a unique match it is identified e.g. ?dS identifies the “Suns” dice in a game with a single piecepack.
- Second, if no match the PieceSpec is parsed and all assumptions listed in PieceSpec are made including angle, if there are any matches the one last in the internal play order is returned.
- Third, if no match the PieceSpec is parsed and all assumptions listed in PieceSpec are made except angle, if there are any matches the one last in the internal play order is returned e.g. ?S5 identifies the “5 of Suns” tile in a game with a single piecepack.
/PieceSpec is used to identify piece(s) with a “greedy” search based on their PieceSpec
- The PieceSpec is parsed and only the explicitly listed features are searched against e.g. /M identifies all the “Moons” pieces, /cf identifies all the coins face up, etc.
A PieceId preceded by a ^ identifies the piece from the game state at the beginning of the move
- An example would be a1-a2 a2-a3 {equivalent to a1-a3} versus a1-a2 ^a2-a3 {equivalent to a2-a3 a1-a2}.
An empty PieceId corresponds to the last “active” piece(s).
- An example would be ?Sp-a4;-a5;* {equivalent to ?Sp-a4 . ?Sp-a5 . *?Sp}
- Note if this refers to multiple pieces then the Location of these pieces is then that of the “active” piece last in the internal ordering of pieces. However if these pieces were originally specified by the N Location PieceId formulation then the Location originally corresponded to Location but now does not.

MoveToken

The default movetext parser supports the following MoveTokens:

Adding new pieces

@ and \ are used to “drop” new pieces onto the board.
- PieceSpec@Location means drop PieceSpec on top of Location, it will be placed after all other pieces in the internal ordering.
- PieceSpec\Location means drop PieceSpec at Location, it will be placed before all the other pieces in the internal ordering (i.e. the bottom).
- PieceSpec@Location%PieceId means drop PieceSpec on top of Location, it will be placed after PieceId in the internal ordering.
- PieceSpec\Location%PieceId means drop PieceSpec at Location, it will be placed before PieceId in the internal ordering.
- PieceSpec@%PieceId is a shortcut for PieceSpec@&PieceId%PieceId i.e. drop PieceSpec directly above PieceId.
- PieceSpec\%PieceId is a shortcut for PieceSpec\&PieceId%PieceId i.e. drop PieceSpec directly under PieceId.

Removing pieces

* is used to remove pieces from the board. *PieceId means remove the piece(s) identified by PieceId.
- Unlike most other MoveTokens it can be added at the end of other Moves e.g. b5-c5*b4*b3 {Move top piece at b5 to c5 and remove top pieces at b4 and b3}.

Moving pieces

- and _ (or ‿) used to move existing pieces elsewhere on the board.
- PieceId-Location means moving the piece(s) identified by PieceId to Location, it will be placed after all the other pieces in the internal ordering.
- PieceId_Location means moving the piece(s) identified by PieceId to Location, it will be placed before all the other pieces in the internal ordering.
- PieceId1-Location%PieceId2 means moving the piece(s) identified by PieceId1 to Location, it will be placed after the piece identified by PieceId2 in the internal ordering.
- PieceId1_Location%PieceId2 means moving the piece(s) identified by PieceId1 to Location, it will be placed before the piece identified by PieceId2 in the internal ordering.
- PieceId-%PieceId2 is a shortcut for PieceId1-&PieceId2%PieceId2 i.e. move PieceId1 directly above PieceId2.
- PieceId_%PieceId2 is a shortcut for PieceId1_&PieceId2%PieceId2 i.e. move PieceId1 directly underneath PieceId2.
- ‿ (U+203F) can be used instead of _. _ is easier to type and found in more fonts but ‿ is harder to confuse with - (especially in handwritten notes).
- !PieceId is a shortcut for PieceId-<0,0> i.e. move the piece(s) identified by PieceId to the end of the internal ordering without changing its x,y coordinates.
# is used to represent a “piece swap”. Let Location1 and Location2 represent the Location of PieceId1 and PieceId2 respectively, then PieceId1#PieceId2 is equivalent to ^PieceId1-Location2 ^PieceId2-Location1.
: is used to represent a “displacement capture”. PieceId1:PieceId2 means find the Location of the piece(s) identified by PieceId2, remove the PieceId2 piece(s), and move the PieceId1 piece(s) to that Location.
- The PieceId1 piece(s) that are moved will be placed after all the other pieces in the internal ordering.
- Let Location be the location of the piece(s) represented by PieceId2, then PieceId1:PieceId2 is equivalent to *PieceId2 PieceId1-Location.
@> and $> are used to rotate pieces clockwise.
- PieceId@>Degrees rotates each of the piece(s) represented by PieceId clockwise Degrees degrees.
- PieceId@>Degrees|Location rotates each of the piece(s) represented by PieceId clockwise Degrees degrees around Location.
- PieceId1@>Degrees$PieceId2 is a shortcut for PieceId1@>Degrees|&PieceId2 i.e. rotate each of the piece(s) represented by PieceId1 clockwise Degrees degrees around the Location of PieceId2.
- PieceId$>Degrees is a shortcut for PieceId@>Degrees$PieceId e.g. depending on the context 3?Sa$>90 could mean spin the Suns of arms tile 90 degrees including the two pieces on top of it.
+ is used to “flip” pieces. +PieceId means “flip” the piece(s) identified by PieceId.
- A “pyramid_top” flips to “pyramid_face” while other pyramid sides flip to “pyramid_top”.
- “die_face” flips to “die_face” but with a new rank plus three modulo six.
- All other pieces flip back and forth from “back” to “face”, “top” to “base”, and “left” to “right”.
- Unlike most other MoveTokens it can be added at the end of other Moves.

Updating/replacing pieces

= is used “replace” pieces on the board with new pieces. PieceId=PieceSpec means replace the piece identified PieceId to PieceSpec (with all assumptions) e.g. b5=S> {replace top piece at b5 with Suns coin back oriented right}.
~ is used “update” pieces on the board with new characteristics. PieceId~PieceSpec means update the piece identified PieceId according to only the explicitly listed elements in PieceSpec e.g. ?dS~3 means have the “Suns” die now show the 3 rank on top without updating orientation.

Appendix

Default Macros

The default movetext parser has the following built-in macros (these can be over-ridden by the Setup function or by the user in the Metadata):

Default parser’s built-in macros
macro	replacement	hexadecimal
H	♥	U+2665
S	♠	U+2660
C	♣	U+2663
D	♦	U+2666
WH	♤	U+2664
WS	♡	U+2661
WD	♢	U+2662
WC	♧	U+2667
RJ	🂿	U+1f0bf
BJ	🃏	U+1f0cf
WJ	🃟	U+1f0df
TF	🃠	U+1f0e0
p	♟	U+265f
n	♞	U+265e
b	♝	U+265d
r	♜	U+265c
q	♛	U+265b
k	♚	U+265a
P	♙	U+2659
N	♘	U+2658
B	♗	U+2657
R	♖	U+2656
Q	♕	U+2655
K	♔	U+2654
SA	🂡	U+1f0a1
S2	🂢	U+1f0a2
S3	🂣	U+1f0a3
S4	🂤	U+1f0a4
S5	🂥	U+1f0a5
S6	🂦	U+1f0a6
S7	🂧	U+1f0a7
S8	🂨	U+1f0a8
S9	🂩	U+1f0a9
ST	🂪	U+1f0aa
SJ	🂫	U+1f0ab
SC	🂬	U+1f0ac
SQ	🂭	U+1f0ad
SK	🂮	U+1f0ae
HA	🂱	U+1f0b1
H2	🂲	U+1f0b2
H3	🂳	U+1f0b3
H4	🂴	U+1f0b4
H5	🂵	U+1f0b5
H6	🂶	U+1f0b6
H7	🂷	U+1f0b7
H8	🂸	U+1f0b8
H9	🂹	U+1f0b9
HT	🂺	U+1f0ba
HJ	🂻	U+1f0bb
HC	🂼	U+1f0bc
HQ	🂽	U+1f0bd
HK	🂾	U+1f0be
DA	🃁	U+1f0c1
D2	🃂	U+1f0c2
D3	🃃	U+1f0c3
D4	🃄	U+1f0c4
D5	🃅	U+1f0c5
D6	🃆	U+1f0c6
D7	🃇	U+1f0c7
D8	🃈	U+1f0c8
D9	🃉	U+1f0c9
DT	🃊	U+1f0ca
DJ	🃋	U+1f0cb
DC	🃌	U+1f0cc
DQ	🃍	U+1f0cd
DK	🃎	U+1f0ce
CA	🃑	U+1f0d1
C2	🃒	U+1f0d2
C3	🃓	U+1f0d3
C4	🃔	U+1f0d4
C5	🃕	U+1f0d5
C6	🃖	U+1f0d6
C7	🃗	U+1f0d7
C8	🃘	U+1f0d8
C9	🃙	U+1f0d9
CT	🃚	U+1f0da
CJ	🃛	U+1f0db
CC	🃜	U+1f0dc
CQ	🃝	U+1f0dd
CK	🃞	U+1f0de
T1	🃡	U+1f0e1
T2	🃢	U+1f0e2
T3	🃣	U+1f0e3
T4	🃤	U+1f0e4
T5	🃥	U+1f0e5
T6	🃦	U+1f0e6
T7	🃧	U+1f0e7
T8	🃨	U+1f0e8
T9	🃩	U+1f0e9
T10	🃪	U+1f0ea
T11	🃫	U+1f0eb
T12	🃬	U+1f0ec
T13	🃭	U+1f0ed
T14	🃮	U+1f0ee
T15	🃯	U+1f0ef
T16	🃰	U+1f0f0
T17	🃱	U+1f0f1
T18	🃲	U+1f0f2
T19	🃳	U+1f0f3
T20	🃴	U+1f0f4
T21	🃵	U+1f0f5
0-0	🁣	U+1f063
0-1	🁤	U+1f064
0-2	🁥	U+1f065
0-3	🁦	U+1f066
0-4	🁧	U+1f067
0-5	🁨	U+1f068
0-6	🁩	U+1f069
1-0	🁪	U+1f06a
1-1	🁫	U+1f06b
1-2	🁬	U+1f06c
1-3	🁭	U+1f06d
1-4	🁮	U+1f06e
1-5	🁯	U+1f06f
1-6	🁰	U+1f070
2-0	🁱	U+1f071
2-1	🁲	U+1f072
2-2	🁳	U+1f073
2-3	🁴	U+1f074
2-4	🁵	U+1f075
2-5	🁶	U+1f076
2-6	🁷	U+1f077
3-0	🁸	U+1f078
3-1	🁹	U+1f079
3-2	🁺	U+1f07a
3-3	🁻	U+1f07b
3-4	🁼	U+1f07c
3-5	🁽	U+1f07d
3-6	🁾	U+1f07e
4-0	🁿	U+1f07f
4-1	🂀	U+1f080
4-2	🂁	U+1f081
4-3	🂂	U+1f082
4-4	🂃	U+1f083
4-5	🂄	U+1f084
4-6	🂅	U+1f085
5-0	🂆	U+1f086
5-1	🂇	U+1f087
5-2	🂈	U+1f088
5-3	🂉	U+1f089
5-4	🂊	U+1f08a
5-5	🂋	U+1f08b
5-6	🂌	U+1f08c
6-0	🂍	U+1f08d
6-1	🂎	U+1f08e
6-2	🂏	U+1f08f
6-3	🂐	U+1f090
6-4	🂑	U+1f091
6-5	🂒	U+1f092
6-6	🂓	U+1f093

Extending the PPN R parser

If one would like to help develop the prototype R parser here are some notes.

Adding a new game (setup)

To add a new game setup one writes an R function called game_system_game_name where game_system is the game system (e.g. piecepack, checker, chess) and game_name is the name of the game, both converted to “snake case” e.g. piecepack_four_field_kono or checker_four_field_kono. It must return a tibble::tibble() of the pieces in order of placement onto the board with the following columns (name matters, order doesn’t):

piece_side
x
y
suit
rank
angle (only needed if any are non-zero)
cfg (only needed if there are non-piecepack components)

The function can optionally take arguments to influence the setup, some existing arguments other game setup functions take are:

seed: For games with random setups passing the same seed should return the same setup
tiles, dice, coins: For games with random setups pass in a string that instructs exactly how one would like the tiles, dice, or coins arranged
has_matchsticks, has_subpack: Provide an alternative setup if the player has (piecepack) matchsticks or a (piecepack) subpack

Before returning the tibble one may add additional “attributes” using the attr() function, currently a handful of functions set a scale_factor attribute which adjusts how many inches a coordinate unit is worth.

If the game is a piecepack game or a game that is played with traditional components (like checkers sets, chess sets, dominoes, etc.) it should ideally be contributed to the ppdf R package. If it is a Looney pyramids game it should ideally be contributed to the piecenikr R package.

There are several pre-existing game setup functions in the R packages ppdf and piecenikr that can be used for inspiration.

Adding a new game notation parser

If you’d like to use a different game notation other than that of the default movetext parser then it is possible to write and use alternative game notation parsers that can be used with PPN files. One may then indicate the alternative parser to use via the MovetextParser field in the game’s metadata. One should write an R function named pname_parser where pname is a descriptive name in “snake case”. The first argument of the function should be movetext which will receive a character vector of the PPN movetext and second argument should be metadata which will receive a list of the PPN metadata. Additionally if the MovetextParser element of the metadata was passed additional arguments those will be passed to the function as well. For example the default movetext parser supports an optional scale_factor argument which lets a user adjust how many inches a coordinate unit is worth. The parser function should return a list which (ideally) contains the following fields (at least) so one can visualize the results using existing functions like plot_move() or animate_game():

movetext: A character vector of the movetext passed into the parser
metadata: A named list of the metadata passed into the parser
moves: A named list of the parsed “moves”
comments: A named list of the parsed move “comments”
dfs: A named list of tibble game states after each move. The first “move” often represents the initial game setup.

One potential hack for writing a parser would to convert your game’s notation into that of the default movetext parser and have it then parse the game.

Hexpack

2019-06-28T00:00:00-07:00

The Hexpack is a piecepack expansion by Daniel Wilcox and Nathan Morse that essentially introduces hexagonal tiles and triagonal coins. In this demo we’ll show how to configure a hexpack that matches our default piecepack and make a simple diagram using it as well as show how to use the built-in hexpack configurations that come with piecepackr.

Contents

Configuring a hexpack
Using the built-in hexpacks

Configuring a hexpack

The trickiest part of configuring a hexpack is figuring out the correct dimensions for the hexagonal tiles. The suggested size of the hexagonal tiles in a hexpack is one that allows the hexagons to circumscribe a 2” circumference circle which implies that they in turn are circumscribed by a 4 / sqrt(3) circumference circle:

library("piecepackr")
hexpack <- pp_cfg(list(shape.tile="convex6", border_lex=3,
                   shape_t.tile="60",  dm_t.tile_face=-90,
                   width.tile=4/sqrt(3), height.tile=4/sqrt(3),
                   shape.coin="convex3", invert_colors.suited=TRUE))

When making hex diagrams it is often helpful to think in polar coordinates so piecepackr provides the helper functions to_x, to_y, to_t, and to_r to help developers convert back and forth between polar coordinates and Cartesian coordinates. We’ll make a simple diagram using these functions and the hexpack configuration we just made:

library("tibble")

x0 <- 5
y0 <- 4.5
df_t1 <- tibble(piece_side="tile_back", x=x0, y=y0)

theta <- seq(90, by=-60, length.out=6)
r <- 0.7
df_c <- tibble(piece_side="coin_face", rank=1:6,
               x=x0+to_x(theta,r), y=y0+to_y(theta,r),
               angle=theta+90)

r <- 2
df_t2 <- tibble(piece_side="tile_face",
                suit=1:6%%4+1, rank=1:6,
                x=x0+to_x(theta,r), y=y0+to_y(theta,r),
                angle=theta+-90)

r <- 6/sqrt(3)
df_t3 <- tibble(piece_side="tile_back",
                x=x0+to_x(theta+30, r),
                y=y0+to_y(theta+30, r))

df <- dplyr::bind_rows(df_t1, df_c, df_t2, df_t3)
pmap_piece(df, cfg=hexpack, default.units="in",
           op_scale=0.5, op_angle=60, trans=op_transform)

Example hexpack diagram

Using the built-in hexpacks

piecepackr provides a couple built-in hexpack configurations via the function game_systems [1]:

df$cfg <- "hexpack"
pmap_piece(df, envir=game_systems("dejavu"), default.units="in",
           op_scale=0.5, op_angle=60, trans=op_transform)

Example hexpack diagram with the built-in ‘dejavu’ hexpack

[1]	New in piecepackr version 1.2.

Chinese Zodiac ranked piecepack PnP

2019-06-23T00:00:00-07:00

The orthodox piecepack ranks are a tad abstract and my toddler son is Chinese-American so I think a Chinese Zodiac ranked piecepack could be a design that is a little more approachable for my son. The Chinese Zodiac‘s 12 animals are divided into 4 trines so we’ll make a piecepack using all the animals from two of the trines as ranks and another piecepack using the remaining animals from the other two trines as ranks. For suits we’ll use the Five Elements: Wood, Fire, Earth, Metal, and Water.

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
zodiac_cn1 <- list(rank_text = "🐀,🐉,🐒,🐂,🐍,🐓",
      suit_text = "🌲,🔥,⛰️,🏆,🌊,",
      rank_fontfamily = "Noto Emoji",
      suit_fontfamily = "Noto Emoji,Noto Emoji,Noto Emoji,Noto Sans Symbols2,Noto Emoji",
      rank_cex = 0.6, suit_cex = "0.6,0.5,0.6,0.6,0.5",
      suit_color = "darkgreen,red3,chocolate4,black,darkblue,grey")
noto_credit <- c("\u25cf This piecepack uses characters from Google Noto Fonts. OFL 1.1.",
                 "\thttps://www.google.com/get/noto/")
zodiac_cn1$credit <- noto_credit
zodiac_cn1$description <- c('This piecepack uses ranks and suits from the Chinese Zodiac')
zodiac_cn1$title <- "Chinese Zodiac (Trines 1+2)"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    zodiac_cn1$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    zodiac_cn1$spdx_id <- "CC-BY-SA-4.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
zodiac_cn1_cutlines <- pp_cfg(zodiac_cn1)
zodiac_cn1_borders <- pp_cfg(c(borders, zodiac_cn1))
zodiac_cn1_bleed <- pp_cfg(c(bleed, zodiac_cn1))
ppdf::piecepack_preview() |> pmap_piece(cfg=zodiac_cn1_cutlines, default.units="in")

Chinese Zodiac ranked piecepack (Trines 1 and 2)

zodiac_cn2 <- as.list(zodiac_cn1)
zodiac_cn2$rank_text <- "🐅,🐎,🐕,🐇,🐏,🐖"
zodiac_cn2$title <- "Chinese Zodiac (Trines 3+4)"
zodiac_cn2_cutlines <- pp_cfg(zodiac_cn2)
zodiac_cn2_borders <- pp_cfg(c(borders, zodiac_cn2))
zodiac_cn2_bleed <- pp_cfg(c(bleed, zodiac_cn2))
ppdf::piecepack_preview() |> pmap_piece(cfg=zodiac_cn2_cutlines, default.units="in")

Chinese Zodiac ranked piecepack (Trines 3 and 4)

Rainbow Deck suited piecepack PnP

2019-06-23T00:00:00-07:00

The Rainbow Deck by Chen Changcai is a cardgame system that can be used to play hundreds of games. It has 12 suits divided by 6 suit symbols with each suit symbol having a dark and light color associated with it. It is straightforward to make six-suited piecepacks to use as an accessory to the Rainbow Deck. The Rainbow Deck itself is licensed under a CC BY-SA-NC license but Chen Changcai was kind enough to give me permission to create Rainbow Deck suited piecepacks under a CC BY-SA 4.0 license requesting that I please provide a link back to his Rainbow Deck BoardGameGeek page.

Since dark suits show up best on a light background and light suits show up best on a dark background we’ll make two 6-suited piecepacks that do just that (note that this means that these two Rainbow Deck suited piecepacks will be dual piecepacks).

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
rainbow1 <- list(suit_text = "♥,★,♣,♦,♛,♠,꩜",
    rank_fontfamily = "Noto Sans",
    suit_fontfamily = paste0(paste(rep("Noto Sans Symbols", 6), collapse=","), ",Noto Sans Cham"),
    suit_cex = "1,1,1,1,0.85,1,0.9",
    suit_color = "#ff0000,#ffc000,#008000,#0000ff,#800080,#000000,white",
    border_color = "grey",
    background_color.unsuited = "sienna")
noto_credit <- c("\u25cf This piecepack uses characters from Google Noto Fonts. OFL 1.1.",
                 "\thttps://www.google.com/get/noto/")
RD_credit <- c("\u25cf The Rainbow Deck is by Chen Changcai",
               "\thttps://boardgamegeek.com/boardgame/59655/rainbow-deck",
               "\tUsed with permission of the author.")
rainbow1$credit <- c(noto_credit, RD_credit)
rainbow1$description <- c('This piecepack uses the suits from Chen Changcai\'s "Rainbow Deck"',
                "\thttps://boardgamegeek.com/boardgame/59655/rainbow-deck")
rainbow1$title <- "Rainbow Deck (dark suits)"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    rainbow1$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    rainbow1$spdx_id <- "CC-BY-SA-4.0"
}
bleed <- list(border_lex=0, border_color=NA_character_)
rainbow1_cutlines <- pp_cfg(rainbow1)
rainbow1_bleed <- pp_cfg(c(bleed, rainbow1))
ppdf::piecepack_preview() |> pmap_piece(cfg=rainbow1_cutlines, default.units="in")

Rainbow Deck suited piecepack (Dark suits)

rainbow2 <- rainbow1
rainbow2$suit_color <- "#ff80c0,#ffff80,#80ff00,#80ffff,#c080ff,#c0c0c0,white"
rainbow2$background_color.suited <- "black"
rainbow2$title <- "Rainbow Deck (light suits)"
rainbow2_cutlines <- pp_cfg(rainbow2)
rainbow2_bleed <- pp_cfg(c(bleed, rainbow2))
ppdf::piecepack_preview() |> pmap_piece(cfg=rainbow2_cutlines, default.units="in")

Rainbow Deck suited piecepack (Light suits)

Tak

2019-06-16T00:00:00-07:00

Contents

Standard Tak pieces
Playing Tak with a piecepack stackpack

Tak is a two-player abstract designed by James Ernest and Patrick Rothfuss that is best visualized in 3D.

Standard Tak pieces

First we’ll show an example of configuring piecepackr to draw standard Tak game pieces.

Since one often plays Tak on differently sized boards one common Tak board design is to have boards made with colored cells arranged in rings from the center plus extra symbols in rings placed at the points so it is easy to see smaller sub-boards. To start we’ll write a function to draw the Tak board.

library("grid")
library("piecepackr")
grobTakBoard <- function(...) {
    g <- "darkgreen"
    w <- "grey"
    fill <- c(rep(g, 5),
              rep(c(g, rep(w, 3), g),3),
              rep(g, 5))
    inner <- rectGrob(x = rep(1:5, 5), y = rep(5:1, each=5),
                 width=1, height=1, default.units="in",
                 gp=gpar(col="gold", fill=fill, lwd=3))
    outer <- rectGrob(gp=gpar(col="black", fill="grey", gp=gpar(lex=2)))
    circles <- circleGrob(x=0.5+rep(1:4, 4), y=0.5+rep(4:1, each=4), r=0.1,
                         gp=gpar(col=NA, fill="gold"), default.units="in")
    rects <- rectGrob(x=0.5+c(0:5, rep(c(0,5), 4), 0:5),
                      y=0.5+c(rep(5,6), rep(c(4:1), each=2), rep(0, 6)),
                      width=0.2, height=0.2,
                      gp=gpar(col=NA, fill="orange"), default.units="in")
    grobTree(outer, inner, circles, rects)
}

Then we’ll configure a Tak set and write some helper functions to draw Tak pieces with it.

cfg <- pp_cfg(list(suit_text=",,,", suit_color="white,tan4,", invert_colors=TRUE,
            ps_text="", dm_text="",
            width.board=6, height.board=6, depth.board=1/4,
            grob_fn.board=grobTakBoard,
            width.r1.bit=0.6, height.r1.bit=0.6, depth.r1.bit=1/4, shape.r1.bit="rect",
            width.r2.bit=0.6, height.r2.bit=1/4, depth.r2.bit=0.6, shape.r2.bit="rect",
            width.pawn=0.5, height.pawn=0.5, depth.pawn=0.8, shape.pawn="circle",
            edge_color="white,tan4", border_lex=2,
            edge_color.board="tan", border_color.board="black"))
g.p <- function(...) {
    grid.piece(..., op_scale=0.7, op_angle=45, cfg=cfg, default.units="in")
}
draw_tak_board <- function(x, y) {
    g.p("board_back", x=x+0.5, y=y+0.5)
}
draw_flat_stone <- function(x, y, suit=1) {
    z <- 1/4*seq(along=suit)+1/8
    g.p("bit_back", x=x+0.5, y=y+0.5, z=z, suit=suit, rank=1)
}
draw_standing_stone <- function(x, y, suit=1, n_beneath=0, angle=0) {
    z <- (n_beneath+1)*1/4+0.3
    g.p("bit_back", x=x+0.5, y=y+0.5, z=z, suit=suit, rank=2, angle=angle)
}
draw_capstone <- function(x, y, suit=1, n_beneath=0) {
    z <- (n_beneath+1)*1/4+0.4
    g.p("pawn_back", x=x+0.5, y=y+0.5, z=z, suit=suit)
}

Then we’ll draw an example Tak game diagram:

pushViewport(viewport(width=inch(6), height=inch(6)))
draw_tak_board(3, 3)
draw_flat_stone(1, 1, 1)
draw_flat_stone(1, 2, 2)
draw_flat_stone(2, 4, 1)
draw_capstone(2, 4, 2, n_beneath=1)
draw_flat_stone(2, 5, 2)
draw_flat_stone(3, 4, 1:2)
draw_flat_stone(3, 3, c(2,1,1,2))
draw_flat_stone(3, 2, 1:2)
draw_flat_stone(3, 1, 2)
draw_standing_stone(4, 2, 2, angle=90)
draw_flat_stone(5, 2, 1)
draw_capstone(5, 3, 1)
popViewport()

Tak game diagram with traditional pieces

Playing Tak with a piecepack stackpack

The game of Tak can also be played with a piecepack stackpack. One can make the board with supertiles. One player will use supercoins as flat stones, subpawns as standing stones, and superpawns as capstones while the other player will use subtiles as flat stones, subdice as standing stones, and superdice as capstones - assuming pawns with circular bases the pieces will be “circles” versus “squares”.

We’ll draw the same game diagram as before but using a piecepack stackpack:

library("dplyr", warn.conflicts=FALSE)
library("ppdf")
library("tibble")

df_board <- piecepack_rect_board_tiles(nrow=5, ncol=5)
df_board$cfg <- "piecepack"
df_fs1 <- tibble(piece_side="coin_back", cfg="piecepack",
                 x=c(1,2,3,3,5), y=c(1,4,2,4,2), suit=c(4:1,3))
df_fs2 <- tibble(piece_side="tile_face", cfg="subpack",
                 x=c(1,2,3,3,3,3), y=c(2,5,4,3,2,1), suit=c(4:1,3,2), rank=1:6)
df_fs3 <- tibble(piece_side="coin_back", cfg="piecepack",
                 x=c(3,3), y=c(3,3), suit=1:2)
df_fs4 <- tibble(piece_side="tile_face", cfg="subpack", x=3, y=3, suit=1, rank=3)
df_ss <- tibble(piece_side="die_face", cfg="subpack", x=4,y=2, suit=1, rank=1)
df_cs <- tibble(piece_side=c("die_face", "pawn_face"), cfg="piecepack",
                x=c(2,5), y=c(4,3), suit=2:3)
df <- bind_rows(df_board, df_fs1, df_fs2, df_fs3, df_fs4, df_ss, df_cs)

systems <- game_systems("dejavu")
piecepack <- as.list(systems$piecepack)
piecepack$edge_color.coin <- piecepack$edge_color.tile <- "tan4"
piecepack$shape.pawn <- "circle"
piecepack$height.pawn <- 0.75
piecepack$width.pawn <- 0.75
piecepack$depth.pawn <- 1.0
piecepack$dm_text.pawn <- ""
piecepack$ps_r.pawn <- 0
subpack <- as.list(to_subpack(piecepack))
subpack$depth.pawn <- 0.5
subpack$width.tile <- 0.7

envir <- list(piecepack = pp_cfg(piecepack), subpack = pp_cfg(subpack))

pmap_piece(df, default.units="in", trans=op_transform, op_scale=0.5, envir=envir)

Tak game diagram with stackpack pieces

3D Projections

2019-06-10T00:00:00-07:00

piecepackr has some basic support for projecting 3D board games onto a 2D diagram. It can make diagrams using an orthographic or oblique parallel projection using R’s grid graphics library. It can also render images using the rayrender, rayvertex, and rgl 3D graphics packages. These latter packages usually use a perspective projection but can be configured to produce parallel projections.

Contents

Orthographic projections (grid)
Oblique projections (grid)
- ‘op_transform()’ helper function
- Mixed Projections
3D graphics packages: rayrender, rayvertex, and rgl

Orthographic projections (grid)

By default piecepackr‘s grid.piece() function makes an approximate “top view” orthographic projection with pieces drawn later “placed on top” of (and potentially hiding) pieces drawn earlier:

library("piecepackr")
options(piecepackr.default.units = "in",
        piecepackr.cfg = game_systems("dejavu")$piecepack)
grid.piece("tile_back", x=0.5+c(3,1,3,1), y=0.5+c(3,3,1,1))
grid.piece("tile_back", x=0.5+3, y=0.5+1)
grid.piece("tile_back", x=0.5+3, y=0.5+1)
grid.piece("die_face", suit=3, rank=5, x=1, y=1)
grid.piece("pawn_face", x=1, y=4, angle=0)
grid.piece("coin_back", x=3, y=4, angle=180)
grid.piece("coin_back", suit=4, x=3, y=4, angle=180)
grid.piece("coin_back", suit=2, x=3, y=1, angle=90)

‘Top view’ orthographic projection of a piecepack game

grid.piece() makes an exact “top view” orthographic projection under the following conditions:

All pieces are placed “flat” parallel/perpendicular to the game table. Although most piecepack games do this there are exceptions like San Andreas where some tiles may shift from flat to “leaning” (and vice versa) during the course of a game.
The game doesn’t use pyramids placed on their side [1]. However you in this case one can approximate an orthographic projection by doing an oblique projection with a very small scale factor i.e. op_scale = 0.001 [2].

[1]	Instead we just draw the visible pyramid face. This is ideal for print-and-play layouts and usually works okay for game diagrams as well.

[2]	(1, 2) If using a version of piecepackr older than v1.11.0 use the minimum op_scale value of 0.01.

Oblique projections (grid)

Note

The oblique projections of dice sides, two-sided tokens placed on their side, and pyramids were improved in piecepackr v1.11.1. These enhancements require R 4.2 and a graphics device that supports the “affine transformation” feature such as the “cairo” devices e.g. png(type = "cairo") or cairo_pdf().

With a little more effort by the piecepackr programmer one can also make oblique projections with grid.piece() which makes it much easier to tell when pieces have been placed on top of other pieces:

library("piecepackr")
options(piecepackr.default.units = "in",
        piecepackr.cfg = game_systems("dejavu")$piecepack,
        piecepackr.op_angle = 45, piecepackr.op_scale = 0.5)

grid.piece("tile_back", x=0.5+c(3,1,3,1), y=0.5+c(3,3,1,1))
grid.piece("tile_back", x=0.5+3, y=0.5+1, z=1/4+1/8)
grid.piece("tile_back", x=0.5+3, y=0.5+1, z=2/4+1/8)
grid.piece("die_face", suit=3, rank=5, x=1, y=1, z=1/4+1/4)
grid.piece("pawn_top", x=1, y=4, z=1/4+1/8, angle=180)
grid.piece("coin_back", x=3, y=4, z=1/4+1/8, angle=180)
grid.piece("coin_back", suit=4, x=3, y=4, z=2/4+1/8, angle=180)
grid.piece("coin_back", suit=2, x=3, y=1, z=3/4+1/8, angle=90)

Oblique projection of a piecepack game

op_scale and op_angle are the arguments that control the appearance of the oblique projection. op_scale determines how much to scale the length of the piece’s edge along op_angle. An op_scale of 0.5 is commonly used in the cabinet projection, an op_scale of 1.0 is used in the cavalier projection, and an op_scale of 0.001 [2] gives you a “top view” orthographic projection. op_angle controls what angle the edges the pieces “go up” - it defaults to 45 degrees.

Depending on your preferences you may want to change up your pawns look and/or the color of your piece edges:

library("piecepackr")
cfg <- pp_cfg(list(width.pawn=0.75, height.pawn=0.75, depth.pawn=1,
                   dm_text.pawn="", shape.pawn="convex6", invert_colors.pawn=TRUE,
                   edge_color.coin="tan", edge_color.tile="tan",
                   border_lex=2, border_color="black"))
options(piecepackr.default.units = "in", piecepackr.cfg = cfg,
        piecepackr.op_angle = 45, piecepackr.op_scale = 0.5)
grid.piece("tile_back", x=0.5+c(3,1,3,1), y=0.5+c(3,3,1,1))
grid.piece("tile_back", x=0.5+3, y=0.5+1, z=1/4+1/8)
grid.piece("tile_back", x=0.5+3, y=0.5+1, z=2/4+1/8)
grid.piece("die_face", suit=3, rank=5, x=1, y=1, z=1/4+1/4)
grid.piece("pawn_face", x=1, y=4, z=1/4+1/2, angle=0)
grid.piece("coin_back", x=3, y=4, z=1/4+1/16, angle=180)
grid.piece("coin_back", suit=4, x=3, y=4, z=1/4+1/8+1/16, angle=180)
grid.piece("coin_back", suit=2, x=3, y=1, z=3/4+1/8, angle=90)

One can configure the appearance of the pawns and piece edges

piecepackr can make an exact oblique projection under the same conditions it needs to do an exact orthographic projection (i.e. all pieces laid parallel/perpendicular to the board).

‘op_transform()’ helper function

To directly make oblique projection graphics with grid.piece() the programmer needs to figure out what height (the z argument) the various pieces are in relation to table and carefully arrange the grid.piece() calls so the pieces on top and/or in front are drawn later. An easier way to make oblique projection graphics is to use pmap_piece() with the helper function op_transform() as pmap_piece()‘s trans argument. op_transform() uses heuristics to make educated guesses about the height the game pieces are at and what order they should be drawn in:

library("piecepackr")
df <- tibble::tibble(piece_side="tile_back",
                     x=c(2,2,2,4,6,6,4,2,5),
                     y=c(4,4,4,4,4,2,2,2,3))
pmap_piece(df, op_angle=135, op_scale=0.5, trans=op_transform)

Using ‘op_transform()’ with ‘pmap_piece()’ to make educated oblique projection guesses

op_transform() currently uses the following heuristic to guess which game pieces overlap:

We “bound” each piece’s shape with either a circle or a convex polygon (if the piece’s shape is exactly a circle or a convex polygon this bound is exact).
If two pieces’ bounding circle/polygon overlap then we guess that the pieces overlap [3].
Piece “A“‘s “z” value is estimated to be equal to the “z” value of the highest “overlapping” piece beneath “A” (let’s call it “B”) plus half of “B“‘s depth and half of “A“‘s depth. If there are no overlapping pieces beneath “A” its “z” value is just half of “A“‘s depth.

op_transform currently uses the following heuristic to sort the order of drawing game pieces:

Generalize each “bounding box” from the previous section into a “bounding cube” whose top is equal to the top of the game piece.
Piece’s whose “bounding cube” top is higher (on “z” axis) are drawn later, for any tie those whose “bounding cube” top (“y” axis) is higher or lower (depending on the “op_angle”) is drawn later, and finally for any remaining tie those whose “bounding cube” is more left or right (depending on the “op_angle”) is drawn later [4].

[3]	For circles and convex polygons any overlap can inferred via an application of the Separating Axis Theorem.

[4]

In certain scenarios this may give the wrong ordering. An example may be a really tall pawn next to a stack of tiles that altogether are shorter than the pawn. For the common case of a single layer of tiles plus a single layer of pieces on top of the tiles this is very unlikely to have a false indentification. If there is a false identification one can sometimes change the dimensions of the pieces or the “op_angle” value to get a “correct” ordering. In an extreme case one can use tiles, coins, pawns, and dice all 1/2” tall which should always render the correct ordering (assuming their “z” values were correctly estimated).

Mixed Projections

Technically since each grid.piece() function can have its own op_scale and op_angle arguments one can mix and match projections in a single diagram:

library("piecepackr")
draw_3tiles <- function(x, y, op_angle) {
    grid.piece("tile_back", x=x, y=y, z=(1:3)/4-1/8, op_angle=op_angle)
}
draw_3tiles(2, 5, 180)
draw_3tiles(8, 5, 0)
draw_3tiles(5, 2, -90)
draw_3tiles(5, 8, 90)
draw_3tiles(8, 8, 45)
draw_3tiles(2, 8, 135)
draw_3tiles(2, 2, 225)
draw_3tiles(8, 2, -45)

One can technically mix oblique projections within one diagram

3D graphics packages: rayrender, rayvertex, and rgl

rayrender

Note

piece() added in piecepackr v1.3.1.

piece() creates rayrender objects.

library("piecepackr")
library("ppdf")
library("rayrender")
df <- ppdf::piecepack_four_field_kono()
options(piecepackr.cfg = game_systems("dejavu3d")$piecepack,
        piecepackr.trans = op_transform)
l <- pmap_piece(df, piece, scale = 0.98, res = 150)
scene <- Reduce(rayrender::add_object, l)
png("rayrender.png", width=6, height=6, units = "in", res=100, type="cairo")
render_scene(scene, lookat = c(2.5, 2.5, 0), lookfrom = c(2.5, -2, 13), clamp_value=8)
invisible(dev.off())

3D render with the rayrender package

rayvertex

Note

piece_mesh() added in piecepackr v1.9.1.

piece_mesh() creates rayvertex objects.

library("piecepackr")
library("ppdf")
library("rayvertex", warn.conflicts = FALSE) # masks rayrender::r_obj
df <- ppdf::piecepack_international_chess()
options(piecepackr.cfg = game_systems("dejavu3d", round=TRUE, pawn="joystick")$piecepack,
        piecepackr.trans = op_transform)
l <- pmap_piece(df, piece_mesh, trans=op_transform, scale = 0.98, res = 150, as_top="pawn_face")
table <- sphere_mesh(c(0, 0, -1e3), radius=1e3, material = material_list(diffuse="grey40"))
scene <- Reduce(rayvertex::add_shape, l, init=table)
png("rayvertex.png", width=6, height=6, units = "in", res=100, type="cairo")
rayvertex::rasterize_scene(scene, lookat = c(4.5, 4, 0), lookfrom=c(4.5, -16, 20),
                           light_info = directional_light(c(5, -7, 7), intensity = 2.5))
invisible(dev.off())

3D render with the rayvertex package

rgl

Note

piece3d() added in piecepackr v1.3.1.

piece3d() draws pieces using the rgl graphic system which leverages OpenGL and WebGL.

library("piecepackr")
library("ppdf")
library("rgl", warn.conflicts = FALSE) # masks rayrender::text3d

invisible(rgl::open3d())
rgl::view3d(phi=-30, zoom = 0.8)

df <- ppdf::piecepack_four_field_kono()
options(piecepackr.cfg = game_systems("dejavu3d")$piecepack,
        piecepackr.trans = op_transform)
pmap_piece(df, piece3d, scale = 0.98, res = 150)

3D render with the rgl package

Parallel projections

It is also possible to do a parallel projection with the 3D graphics libraries rayrender, rayvertex, and rgl:

rayrender: Set fov = 0 in render_ao() / render_preview / render_scene(). Choose camera size/placement/direction carefully.
rayvertex: Set fov = 0 in rasterize_lines() / rasterize_scene(). Choose camera size/placement/direction carefully.
rgl: Set view3d(fov = 0). Choose polar coordinates carefully.

Dingbats PnP

2019-05-31T00:00:00-07:00

In 2013 Daniel Ajoy released his PiecePack Design Variation under a CC BY 3.0 license. Besides using Dingbat suit symbols instead of the standard piecepack suits Daniel Ajoy’s “Dingbats” piecepack had the following features:

Uses a yellow suit instead of a black suit
The tile faces of two suits are ‘white’ and two are ‘black’
Fronts of the tiles are divided into four sectors
The null and ace rank have distinctive symbols

For more info about the design please read Daniel Ajoy‘s description and design notes at https://boardgamegeek.com/filepage/91234/piecepack-design-variation.

Homemade PiecePack by Daniel Ajoy / CC BY-NC-SA 3.0

Note

The custom grob function in this article uses the function pp_shape() which was introduced in piecepackr v1.5.1

It is possible to emulate Ajoy’s Dingbats piecepack in piecepackr but in order to emulate his tile faces and null/ace rank symbols we’ll need to write and use a custom grob function in order to add some extra circles/stars on the tile faces and add an extra circle to his null/ace rank symbols.

library("grid")
library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
ajoyDingbatsGrob <- function(piece_side, suit, rank, cfg=pp_cfg()) {
    cfg <- as_pp_cfg(cfg)
    opt <- cfg$get_piece_opt(piece_side, suit, rank)
    shape <- pp_shape(opt$shape, opt$shape_t, opt$shape_r, opt$back)

    # Background
    gp_bg <- gpar(col=NA, fill=opt$background_color)
    if (packageVersion("piecepackr") > '1.13')
        background_grob <- shape$shape(gp=gp_bg, mat_width = opt$mat_width)
    else
        background_grob <- shape$shape(gp=gp_bg)

    # Gridlines, Mat
    gl_grob <- shape$gridlines(gp = gpar(col = opt$gridline_color, lex = opt$gridline_lex))
    mat_grob <- shape$mat(opt$mat_width, gp = gpar(fill = opt$mat_color))

    if (piece_side == "tile_face") {
        outside_circle_grob <- circleGrob(r=0.25, gp=gpar(col=NA, fill=opt$ps_color))
        col2 <- ifelse(opt$ps_color == "white", "black", "white")
        gp2 <- gpar(col=NA, fill=col2)
        if (rank < 3) {
            inner_circle_grob <- circleGrob(r=0.23, gp=gp2)
        } else {
            inner_circle_grob <- grobTree(pp_shape("concave24", 0, 0.45)$shape(gp=gp2),
                                          vp=viewport(width=0.47, height=0.47))
        }
        circle_grob <- grobTree(outside_circle_grob, inner_circle_grob)
    } else {
        circle_grob <- nullGrob()
    }

    # Primary symbol
    gp_ps <- gpar(col=opt$ps_color, fontsize=opt$ps_fontsize,
                  fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
    ps_grob <- textGrob(opt$ps_text, x=opt$ps_x, y=opt$ps_y, gp=gp_ps)
    if (!is.null(opt$ps_text) && opt$ps_text %in% c("6", "1", "\u0285")) { # "\u03b9", "\u0196", "\u0666", "\u158d"
        gp_c <- gpar(col=opt$ps_color, fontsize=0.95*opt$ps_fontsize,
                      fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
        c_grob <- textGrob("\u25ef", x=opt$ps_x, y=opt$ps_y, gp=gp_c)
        ps_grob <- grobTree(c_grob, ps_grob)
    }

    # Directional mark
    gp_dm <- gpar(col=opt$dm_color, fontsize=opt$dm_fontsize,
                  fontfamily=opt$dm_fontfamily, fontface=opt$ps_fontface)
    dm_grob <- textGrob(opt$dm_text, x=opt$dm_x, y=opt$dm_y, gp=gp_dm)

    # Border
    border_grob <- shape$shape(gp=gpar(col=opt$border_color, fill=NA, lex=opt$border_lex))
    gl <- gList(background_grob, gl_grob, mat_grob, circle_grob,
                ps_grob, dm_grob, border_grob)

    gTree(children=gl, name=piece_side)
}
colors <- list(background_color="#00BFFF,#CD5C5C,#FFD700,#3CB371,white",
               suit_color="black",
               ps_color.s1.tile_face="white", ps_color.s4.tile_face="white",
               gridline_color.tile_face="black",
               mat_width.tile=0.05, mat_color.tile="black")
suits <- list(suit_text="\u2744,\u273d,\u2720,\u27b9,",
              suit_cex="0.9,0.9,0.8,1.0,1")
ranks <- list(rank_text="6,\u0285,2,3,4,5", rank_cex="0.6,0.6,0.8,0.8,0.8,0.8")
misc <- list(dm_text.coin="\u25b2", ps_cex.coin=0.9, fontfamily="Dejavu Sans",
             grob_fn=ajoyDingbatsGrob)
dingbats1 <- c(colors, suits, ranks, misc)
dejavu_credit <- c("\u25cf This piecepack uses characters from the font Dejavu Sans.",
                    "\thttps://dejavu-fonts.github.io/",
                    "\thttps://dejavu-fonts.github.io/License.html")
ajoy_credit <- c('\u25cf This piecepack emulates Daniel Ajoy\'s "Piecepack Design Variation". CC BY 3.0.',
                 "\thttps://boardgamegeek.com/filepage/91234/piecepack-design-variation",
                 "\thttps://boardgamegeek.com/user/DanielAjoy",
                 "\thttp://creativecommons.org/licenses/by/3.0")
description <- c('This piecepack emulates Daniel Ajoy\'s "Piecepack Design Variation" aka "Dingbats piecepack" which has the following features:',
                 "\u25cf Uses a yellow suit instead of a black suit",
                 "\u25cf The tile faces of two suits are 'white' and two are 'black'",
                 "\u25cf Fronts of the tiles are divided into four sectors",
                 "\u25cf The null and ace rank have distinctive symbols",
                 "\u25cf For more info see Daniel Ajoy's description and design notes at",
                "\thttps://boardgamegeek.com/filepage/91234/piecepack-design-variation")
dingbats1$description <- description
dingbats1$credit <- c(dejavu_credit, ajoy_credit)
dingbats1$title <- "Dingbats piecepack (Dingbat suits)"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dingbats1$copyright <- "\u00a9 2020 Trevor L Davis.  Some Rights Reserved."
    dingbats1$spdx_id <- "CC-BY-3.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
dingbats1_cutlines <- pp_cfg(dingbats1)
dingbats1_borders <- pp_cfg(c(borders, dingbats1))
dingbats1_bleed <- pp_cfg(c(bleed, dingbats1))
ppdf::piecepack_preview() |> pmap_piece(cfg=dingbats1_cutlines, default.units="in")

A preview of a ‘Dingbats’ piecepack

Ajoy’s PiecePack Design Variation PnP file also included a deck using the French suits. Modifying the above “Dingbats piecepack” configuration list in order to build this deck is straightforward.

dingbats2 <- as.list(dingbats1)
dingbats2$background_color="#FF5F50,white,#8B795E,#999999,white"
dingbats2$suit_text="\u2666,\u2665,\u2663,\u2660,"
dingbats2$suit_cex <- NULL
dingbats2$suit_color="darkred,darkred,black,black,black"
dingbats2$dm_color="black"
dingbats2$dm_color.tile_face=dingbats2$suit_color
dingbats2$dm_color.die_face=dingbats2$suit_color
dingbats2$ps_color.die_face="black"
dingbats2$dm_color.matchstick_face=dingbats2$suit_color
dingbats2$ps_color.matchstick_face="black"
dingbats2$ps_color.pyramid_left="black"
dingbats2$ps_color.pyramid_right="black"
dingbats2$ps_color.s1.tile_face="black"
dingbats2$ps_color.s2.tile_face="black"
dingbats2$ps_color.s3.tile_face="white"
dingbats2$title <- "Dingbats piecepack (French suits)"
dingbats2_cutlines <- pp_cfg(dingbats2)
dingbats2_borders <- pp_cfg(c(borders, dingbats2))
dingbats2_bleed <- pp_cfg(c(bleed, dingbats2))
ppdf::piecepack_preview() |> pmap_piece(cfg=dingbats2_cutlines, default.units="in")

A ‘Dingbats’ style piecepack with French suits

Orthodox PnP

2019-05-26T00:00:00-07:00

For a number of reasons the default piecepack made by piecepackr does not comply with the Anatomy of a Piecepack standard. But not to fear - one can easily configure a piecepack that looks like one of the original piecepacks.

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="0.6,0.7,0.75,0.9,0.9")
dark_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,black",
                         border_color="black")
orthodox_ranks <- list(rank_text=",\uaa5c,2,3,4,5", use_suit_as_ace=TRUE,
                       rank_fontfamily="Noto Sans",
                       rank_fontfamily.r2="Noto Sans Cham", rank_cex.r2.matchstick=0.7)
saucer <- list(suit_text.saucer_face = "", suit_text.saucer_back = "",
              dm_text.saucer = "|", dm_fontfamily.saucer = "Noto Sans",
              dm_r.saucer = 0.42, dm_color.saucer = "black",
              invert_colors.saucer_face = TRUE,
              mat_width.saucer_face=0.3, mat_color.saucer="white",
              width.saucer = 7/8, height.saucer=7/8)
coin <- list(dm_text.coin = "|",
              dm_fontfamily.coin = "Noto Sans",
              dm_r.coin = 0.42,
              dm_color.coin = "black")
die <- list(dm_text.die = "")
pawn <- list(suit_text.pawn = "",
          dm_text.pawn = "",
          invert_colors.pawn = TRUE)
pyramids <- list(rank_text.pyramid="A,B,C,D,E,F", use_suit_as_ace.pyramid=FALSE,
                 dm_t.pyramid_face=270, dm_r.pyramid_face=0.28, dm_cex.pyramid_face=3.5,
                 dm_text.pyramid_face = "|", dm_fontfamily.pyramid_face = "Noto Sans",
                 dm_color.pyramid_face="black", ps_color.pyramid_left = "black",
                 ps_color.pyramid_right = "black",
                 ps_t.pyramid_face=90, ps_r.pyramid_face=0.07, ps_cex.pyramid_face=0.4)
matchsticks <- list(invert_colors.matchstick=TRUE, use_suit_as_ace.matchstick=FALSE,
                    dm_r.r1.matchstick=0)
orthodox1 <- c(piecepack_suits, dark_colorscheme, orthodox_ranks, saucer, coin,
               die, pawn, pyramids, matchsticks)
noto_credit <- c("\u25cf This piecepack uses characters from Google Noto Fonts. OFL 1.1.",
                 "\thttps://www.google.com/get/noto/")
description <- "This 'orthodox' piecepack fully complies with the 'Anatomy of a Piecepack' standard"
orthodox1$description <- description
orthodox1$credit <- noto_credit
orthodox1$title <- "Orthodox piecepack (Green Crowns)"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    orthodox1$copyright <- "Created in 2019 by Trevor L Davis.  No Rights Reserved."
    orthodox1$spdx_id <- "CC0-1.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
orthodox1_cutlines <- pp_cfg(orthodox1)
orthodox1_borders <- pp_cfg(c(borders, orthodox1))
orthodox1_bleed <- pp_cfg(c(bleed, orthodox1))
ppdf::piecepack_preview() |> pmap_piece(cfg=orthodox1_cutlines, default.units="in")

A preview of an ‘orthodox’ piecepack made by piecepackr

orthodox2 <- as.list(orthodox1)
orthodox2$suit_color="darkred,black,gold,darkblue,black"
orthodox2$title <- "Orthodox piecepack (Gold Crowns)"
orthodox2_cutlines <- pp_cfg(orthodox2)
orthodox2_borders <- pp_cfg(c(borders, orthodox2))
orthodox2_bleed <- pp_cfg(c(bleed, orthodox2))
ppdf::piecepack_preview() |> pmap_piece(cfg=orthodox2_cutlines, default.units="in")

An ‘orthodox’ piecepack with gold crowns

orthodox3 <- as.list(orthodox1)
orthodox3$suit_text <- "♥,♠,♣,♦,\uaa5c"
orthodox3$suit_cex <- "1,1,1,1,0.9"
orthodox3$suit_color <- "darkred,black,black,darkred,black"
orthodox3$suit_fontfamily <- "Noto Sans Symbols"
orthodox3$suit_fontfamily.s5 <- "Noto Sans Cham"
orthodox3$suit_text.pawn = NULL
orthodox3$suit_cex.pawn = 0.5
orthodox3$suit_text.saucer_face = NULL
orthodox3$suit_cex.saucer_face <- 0.5
orthodox3$title <- "French-suited piecepack (Orthodox)"
orthodox3$description <- "A French-suited piecepack that otherwise complies with the 'Anatomy of a Piecepack' standard"
orthodox3_cutlines <- pp_cfg(orthodox3)
orthodox3_borders <- pp_cfg(c(borders, orthodox3))
orthodox3_bleed <- pp_cfg(c(bleed, orthodox3))
ppdf::piecepack_preview() |> pmap_piece(cfg=orthodox3_cutlines, default.units="in")

French-suited piecepack in an orthodox style

Backgammon

2019-05-17T00:00:00-07:00

Backgammon is one of the oldest known board games. Like other classic board games like checkers and chess it is also possible to play with a single piecepack. Below is a starting diagram for playing a game of backgammon with a piecepack using a paired suit-color design.

library("grid")
library("piecepackr")
library("ppdf")
cfg <- pp_cfg(list(suit_text="🌞,🌜,👑,⚜,꩜",
                   suit_cex="0.6,0.7,0.75,0.9,0.9",
                   suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                   suit_color="#D55E00,#000000,#F0E442,#0072B2,#009E73",
                   background_color="#000000,#D55E00,#0072B2,#F0E442,white",
                   annotation_color = "#E69F00"
))
pmap_piece(piecepack_backgammon(), cfg=cfg, default.units="in")

Starting diagram for a game of backgammon

Tablut

2019-05-17T00:00:00-07:00

Tablut is a historical (hnefa)tafl game played by the Sámi people until at least the 1700s whose rules were written down by the Swedish naturalist Linnaeus in 1732. Below is a starting diagram for playing a game of Tablut with a piecepack.

library("piecepackr")
library("ppdf")
cfg <- pp_cfg(list(suit_text="🌞,🌜,👑,⚜,꩜",
     suit_cex="0.6,0.7,0.75,0.9,0.9",
    suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
    suit_color="darkred,black,darkgreen,darkblue,black",
    border_lex=4, border_color="black", mat_width.tile_back=0.05, mat_color="white",
    invert_colors.suited = TRUE, edge_color.coin="tan", edge_color.tile="tan",
    shape.pawn="convex6", depth.pawn=1.0, height.pawn=0.75, width.pawn=0.75, dm_text.pawn=""
))
df <- piecepack_tablut(die_width = 0.5)
pmap_piece(df, cfg=cfg, default.units="in", trans=op_transform, op_scale=0.7)

Starting diagram for a game of Tablut

And here is animation of a game of Tablut:

library("ppn")
game <- read_ppn(system.file("ppn/tablut.ppn", package = "ppn"))[[1]]
animate_game(game, file = "../images/knitr/tablut.gif",
                      cfg = cfg, trans = op_transform, op_scale = 0.7,
                      n_transitions = 6, n_pauses = 3, fps = 9)

Animation of a Tablut game

Cribbage

2019-05-16T00:00:00-07:00

Cribbage is a popular two-person card game that usually requires a special cribbage board to keep score. Below is a diagram of using a piecepack to make an effective cribbage board.

library("grid")
library("piecepackr")
library("ppdf")
cfg <- pp_cfg(list(suit_color="darkred,black,darkgreen,darkblue,black",
                   border_color="black", border_lex=4))
pmap_piece(piecepack_cribbage_board(), cfg=cfg, default.units="in")

textGrob_cribbage_board <- function(suit_colors = rep("black", 4)) {
    gp1 <- gpar(col = c(suit_colors[1], suit_colors[2]), fontsize = 32)
    gp2 <- gpar(col = c(suit_colors[3], suit_colors[4]), fontsize = 32)
    grobTree(textGrob(1:30, x = 0.5, y = 3:32, default.units = "in", gp = gp1),
             textGrob(31:60, x = 3.5, y = 32:3, default.units = "in", gp = gp1),
             textGrob(1:30, x = 5.5, y = 3:32, default.units = "in", gp = gp2),
             textGrob(31:60, x = 8.5, y = 32:3, default.units = "in", gp = gp2)
             )
}
grid.draw(textGrob_cribbage_board(cfg$get_suit_color()))

Using a piecepack as a Cribbage Board

Custom grob functions

2019-04-23T00:00:00-07:00

Contents

Intro
Examples
- Checkered Tile Backs
- Pawn Belts with Three Suit Symbols
Low-level utilities

Intro

Note

The custom grob functions in this article use the function pp_shape() which was introduced in piecepackr v1.5.1

Although using piecepackr‘s configuration lists provide a powerful high-level way to alter the appearance of your piecepack graphics piecepackr also allows one to modify the appearance of your piecepack graphics even more with the use of custom grob functions.

Examples

Checkered Tile Backs

Warning

Some people (including the inventor James “Kyle” Droscha) feel that adding checkers to the back of one’s piecepack is a bad idea, in particular they leak information about the direction of the tile face.

The default grob function doesn’t support adding checkers to the back of your piecepack tiles but piecepackr does include a utility function checkersGrob that can be used via a custom grob function:

library("grid")
library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")

checkeredPieceGrob <- function(piece_side, suit, rank, cfg) {
    cfg <- as_pp_cfg(cfg)
    opt <- cfg$get_piece_opt(piece_side, suit, rank)
    shape <- pp_shape(opt$shape, opt$shape_t, opt$shape_r, opt$back)

    background_grob <- shape$shape(gp=gpar(col=NA, fill=opt$background_color))
    checkers_grob <- shape$checkers(gp=gpar(fill=opt$gridline_color))
    border_grob <- shape$shape(gp=gpar(col=opt$border_color, fill=NA, lex=opt$border_lex))
    gl <- gList(background_grob, checkers_grob, border_grob)
    gTree(children=gl, name=piece_side)
}
cfg <- list(grob_fn.tile_back=checkeredPieceGrob)
ppdf::piecepack_preview() |> pmap_piece(cfg=cfg, default.units="in")

Custom grob function to use checkers on the tile back

The above custom grob function was written fairly generally so it can also support convex# polygons (i.e. “Hexpack” tiles):

cfg <- list(grob_fn.tile_back=checkeredPieceGrob, shape.tile="convex6",
            shape.coin="convex3", shape.saucer="convex3")
ppdf::piecepack_preview() |> pmap_piece(cfg=cfg, default.units="in")

‘checkersGrob’ even works on hexagon shaped tiles

Pawn Belts with Three Suit Symbols

The pawn belts in Jonathan Dietrich’s JCD piecepack and Chris Sakkas’ Nine-Suit Piecepack both feature three suit symbols but it is difficult to replicate such a belt with piecepackr‘s default draw function since it only supports one primary symbol and one directional mark [*].

pawnBeltGrob <- function(piece_side, suit, rank, cfg) {
    cfg <- as_pp_cfg(cfg)
    opt <- cfg$get_piece_opt(piece_side, suit, rank)
    shape <- pp_shape(opt$shape, opt$shape_t, opt$shape_r, opt$back)

    background_grob <- shape$shape(gp=gpar(col=NA, fill=opt$background_color))
    center_grob <- rectGrob(width=0.3, gp=gpar(col=NA, fill=opt$ps_color))
    gp_ps1 <- gpar(col=opt$background_color, fontsize=opt$ps_fontsize,
                  fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
    ps_grob1 <- textGrob(opt$ps_text, x=opt$ps_x, y=opt$ps_y, gp=gp_ps1)
    gp_ps2 <- gpar(col=opt$ps_color, fontsize=opt$ps_fontsize,
                  fontfamily=opt$ps_fontfamily, fontface=opt$ps_fontface)
    ps_grob2 <- textGrob(opt$ps_text, x=c(0.2, 0.8), gp=gp_ps2)
    border_grob <- shape$shape(gp=gpar(col=opt$border_color, fill=NA, lex=opt$border_lex))
    gl <- gList(background_grob, center_grob, ps_grob1, ps_grob2, border_grob)

    gTree(children=gl, name=piece_side)
}
cfg <- list(grob_fn.belt=pawnBeltGrob)
grid.piece("belt_face", s=3, cfg=cfg)

Pawn belts with three suit symbols

[*] Technically if awkwardly you could replicate it by customizing the mat on the belt and putting two suit symbols separated by a bunch of whitespace as the directional mark symbols but the amount of whitespace needed would vary with the font and the fontsize so not a general solution and would require trial and error.

Low-level utilities

piecepackr comes with several utility functions that can aid in the writing of custom grob functions. For more documentation you can use the help function:

help("pp_shape")
help("pp_utils")

In order to draw custom grob functions it may also be helpful to learn more about grid‘s API.

Configuration lists

2019-04-17T00:00:00-07:00

Contents

Intro
Configuration cascading
Table of configuration list styles
Configuration List R6 Object
Storing/sharing configuration lists

Intro

piecepackr allows one to alter the appearance of one’s board game pieces through the use of configuration lists. Here is an example:

library("grid")
library("piecepackr")
library("ppdf")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
dark_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,black",
                         invert_colors.suited=TRUE)
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="0.6,0.7,0.75,0.9,0.9")
traditional_ranks <- list(use_suit_as_ace=TRUE, rank_text=",a,2,3,4,5")
cfg <- c(piecepack_suits, dark_colorscheme, traditional_ranks)
gp_text <- gpar(fontsize=25, fontface="bold")
grid.text("ppdf::piecepack_preview() |> pmap_piece()", x=0.25, y=0.90, gp=gp_text)
pushViewport(viewport(x=0.25, y=0.43, width=inch(6)))
ppdf::piecepack_preview() |> pmap_piece(default.units="in")
popViewport()
grid.text("ppdf::piecepack_preview() |> pmap_piece(cfg=cfg)", x=0.75, y=0.90, gp=gp_text)
pushViewport(viewport(x=0.75, y=0.43, width=inch(6)))
ppdf::piecepack_preview() |> pmap_piece(cfg=cfg, default.units="in")
popViewport()

Configuration list example

There are lot more examples of customizing piecepack piece appearances with configuration lists in the Print & Play demos.

Although one can further customize the appearance of one’s board game pieces through the use of custom grob functions the default piecepackr grob function uses the configuration list to determine a board game component’s shape, “primary” symbol,”directional mark” symbol, and gridlines (if any). This program uses the abstraction that every board game component has a “component_side” name (like belt_face), a suit, a rank, a primary symbol, a directional mark symbol, and embellishments like border lines, grid lines, and padding. On top of the normal “suited” piecepack suits this program also recognizes an extra “unsuit” suit which is used to configure “neutral” components like tile backs and coin faces. Although the primary and directional mark symbols can be configured directly (i.e. tile_face.ps_fontsize) they are often configured indirectly by specifying various “suit” and “rank” symbol configurations (i.e. rank_cex).

Configurations are often allowed to be comma-separated to be able to specify different values for different suits or ranks e.g. background_color=white or background_color=pink,grey,grey,pink,white (note how the last [5th] element specifies that the “unsuit” background color should be “white”).

Configuration cascading

The configurations in this program “cascade” (sort of like in “Cascading Style Sheets”). A style configuration has the following format:

style_name(.suit)(.rank)(.component)

The configuration “cascade” priorities are as follows:

Direct styles have priority over indirect styles e.g. dm_text has priority over suit_text.tile_face for which symbol is used in the corner of the tile face and in turn suit_fontfamily has priority over fontfamily for which fonts are used on the coin back. This is because indirect styles are only used to a generate reasonable default if a direct style cannot be found.
Then if there is a tie .component_side has priority over .component which has priority over no component specification e.g. dm_text.saucer_back has priority over dm_text.saucer which has priority over just dm_text.
Then if there is still a tie .r# has priority over no rank specification e.g. invert_colors.r1 has priority over invert_colors.
Then if there is still a tie .s# has priority over .suited / .unsuited which has priority over no suit specification e.g. invert_colors.s2 has priority over invert_colors.suited has priority over just invert_colors.

Table of configuration list styles

Configuration list styles
name	description	indirect setters	comma-separated
ps_text	“primary symbol” text	suit_text, rank_text, use_suit_as_ace
ps_fontface	fontface of “primary symbol” symbol	suit_fontface, rank_fontface, fontface, use_suit_as_ace
ps_fontfamily	font of “primary symbol” symbol	suit_fontfamily, rank_fontfamily, fontfamily, use_suit_as_ace
ps_fontsize	fontsize of “primary symbol” symbol
ps_cex	Multiplier to apply to the “primary symbol” fontsize (cumulative with `cex`)	suit_cex, rank_cex, use_suit_as_ace
ps_t	Angle (in degrees) of polar coordinates of “primary symbol” (from center)		suit
ps_r	Radius from center (relative units) of polar coordinates of “primary symbol”		suit
ps_color	Color of “primary symbol”	suit_color, background_color, invert_colors
dm_text	“directional mark” text	suit_text	suit
dm_fontface	font of “directional mark”	suit_fontface, fontface	suit
dm_fontfamily	font of “directional mark”	suit_fontfamily, fontfamily	suit
dm_fontsize	fontsize of “directional mark”
dm_cex	Multiplier to apply to the “directional mark” fontsize (cumulative with `cex`)	suit_cex	suit
dm_t	Angle (in degrees) of polar coordinates of “directional mark” symbol (from center)		suit
dm_r	Radius from center (relative units) of polar coordinates of “directional mark”		suit
dm_color	Color of “directional mark” symbol	suit_color, background_color, invert_colors	suit
shape	Shape of component: either `rect`, `circle`, `halma`, `kite`, `pyramid`, `concave#` or `convex#` where `#` is the number of outside polygon vertices
shape_t	If shape is `concave#` or `convex#` then angle of first vertex (in degrees) of the polygon
shape_r	If shape is `concave#` then how far from the center are the inner vertices (from 0 to 0.5)
background_color	Background color of the component	suit_color, invert_colors	suit
invert_colors	Should we switch the background color with the suit color?
border_color	Color of the border of the component		suit
border_lex	Multiplier to apply to the default border line width
gridline_color	Color of the gridlines	suit_color, background_color, invert_colors	suit
gridline_lex	Multiplier to apply to the default grid line width
edge_color	Which color to use for the edge of the piece when drawn with an oblique projection.	suit_color, background_color	suit
annotation_color	What color to suggest for annotating graphics
mat_color	Color of the “matting”	suit_color, background_color, invert_colors	suit
mat_width	Width of the “matting” (from 0.0 to 1.0)		padding
suit_text	Suit symbols to use as “primary” symbol or “directional mark”		suit
suit_fontface	Font(s) of the suit symbols	fontface	suit
suit_fontfamily	Font(s) of the suit symbols	fontfamily	suit
suit_cex	Multiplier to apply to the suit symbols fontsize		suit
suit_color	Suit colors		suit
rank_text	Rank symbols to use as “primary” symbol	suit_text, use_suit_as_ace	rank
rank_fontface	Font(s) of the rank symbols	suit_fontface, use_suit_as_ace, fontface	rank
rank_fontfamily	Font(s) of the rank symbols	suit_fontfamily, use_suit_as_ace, fontfamily	rank
rank_cex	Multiplier to apply to the rank symbols fontsize	suit_cex, use_suit_as_ace	rank
use_suit_as_ace	Boolean for whether the suit symbol should be used for the ‘ace’ rank
cex	Multiplier to apply to all the fontsizes
fontfamily	Default font ‘family’
fontface	Default font ‘face’
n_ranks	Number of ranks	rank_text
n_suits	Number of suits	suit_text
coin_arrangement	Number of degrees the direction of the bottom of the coin differs from top of coin
die_arrangement	Arrangement of dice (for use in 3D projections and paper Print & Play arrangements). Either `"counter_up"`, `"counter_down"`, `"opposites_sum_to_5"`, or (a comma-separated string of) the integers `1`, `2`, `3`, `4`, `5`, and `6` (in any order) with each integer optionally followed by `^` (default), `<`, `v`, or `>`.
width	Width of component in inches
height	Height of component in inches	width
depth	Depth of the component in inches	width
grob_fn	Which grob function to use to make a 2D `grob` of the game piece.
grob_with_bleed_fn	Which function to use to make a `grob` of the game piece with a “bleed”. Introduced in v1.10.
op_grob_fn	Which function to use to make a 3D `grob` of the game piece when the piece is drawn with an oblique projection. Introduced in v1.3.
obj_fn	Which function to use to save Wavefront OBJ file of the game piece (which is used by default `piece()` and `piece3d()` functions). Introduced in v1.4.
rayrender_fn	Which function to use to create game pieces for use with rayrender graphic system (via `piece()` function). Introduced in v1.4.
rayvertex_fn	Which function to use to create game pieces for use with rayvertex graphic system (via `piece_mesh()` function). Introduced in v1.9.
rgl_fn	Which function to use to draw game pieces in rgl graphic system (via `piece3d()` function). Introduced in v1.4.
title	Title of the piecepack
description	Description of the piecepack
credit	Additional credits
copyright	Additional copyrights
spdx_id	[SPDX Identifier](https://spdx.org/licenses/) for the graphical design license. Introduced in v1.10.
lacks_rank	Which “piece_side“‘s should we assume don’t vary by rank. Introduced in v1.7.
lacks_suit	Which “piece_side“‘s should we assume don’t vary by suit. Introduced in v1.7.
shadow_fn	Which function to use to make a `grob` of the edges of the game piece when the piece is drawn with a 3D oblique projection. Deprecated in v1.3 (use `op_grob_fn` instead). Removed in v1.10.

Configuration List R6 Object

If you will be drawing lots of piecepack images you should use the pp_cfg function to create a configuration list R6 object. It (on-the-fly) builds a cache so it really speeds up future component drawing.

cfg <- pp_cfg(cfg)

Storing/sharing configuration lists

One can export configuration lists using R’s RData binary format and the save command and re-load them back in with the load command. Simple configuration lists can alternatively be stored in plaintext using formats like JSON (i.e. via the jsonlite package).

save(cfg, file="my_cfg.RData")
load("my_cfg.RData")

This website offers for download demo_cfgs.RData which contains every Print & Play demos configuration list.

download.file("https://trevorldavis.com/piecepackr/share/demo_cfgs.RData")
cfgs <- new.env()
load("demo_cfgs.RData", envir=cfgs)

names(cfgs)

##  [1] "chess5_bleed"        "dual4_bleed"         "default1_bleed"
##  [4] "dingbats1_borders"   "chess1_borders"      "orthodox3_bleed"
##  [7] "zodiac_cn2_bleed"    "reversi1_bleed"      "rainbow2_cutlines"
## [10] "orthodox2_cutlines"  "dual3_cutlines"      "dingbats2_bleed"
## [13] "dual3_bleed"         "rainbow1_cutlines"   "default1_borders"
## [16] "reversi1_cutlines"   "default1_cutlines"   "dingbats1_cutlines"
## [19] "chess5_cutlines"     "dual4_cutlines"      "zodiac_cn2_cutlines"
## [22] "dingbats1_bleed"     "dual2_bleed"         "dual6_bleed"
## [25] "chess2_bleed"        "orthodox2_bleed"     "chess3_bleed"
## [28] "orthodox3_cutlines"  "dingbats2_borders"   "orthodox3_borders"
## [31] "chess1_cutlines"     "orthodox2_borders"   "dingbats2_cutlines"
## [34] "chess4_cutlines"     "dual5_cutlines"      "orthodox1_borders"
## [37] "zodiac_cn1_cutlines" "dual1_bleed"         "rainbow1_bleed"
## [40] "chess4_bleed"        "dual1_cutlines"      "chess1_bleed"
## [43] "orthodox1_bleed"     "dual5_bleed"         "chess2_cutlines"
## [46] "reversi1_borders"    "chess3_cutlines"     "zodiac_cn1_borders"
## [49] "chess3_borders"      "rainbow2_bleed"      "zodiac_cn1_bleed"
## [52] "orthodox1_cutlines"  "dual6_cutlines"      "chess4_borders"
## [55] "zodiac_cn2_borders"  "chess2_borders"      "dual2_cutlines"
## [58] "chess5_borders"

print(cfgs$dual5_cutlines)

## $background_color : grey70
## $copyright : © 2019 Trevor L Davis.  Some Rights Reserved.
## $credit : ● This piecepack uses characters from the font Quivira. Public Domain.,        http://www.quivira-font.com/
## $description :
## $fontfamily : Quivira
## $invert_colors.suited : TRUE
## $lacks_rank : tile_back,coin_back,card_back,pawn_face,pawn_back,belt_face,saucer_face,saucer_back,suitdie_face
## $lacks_suit : tile_back,saucer_back,coin_face,card_back
## $n_ranks : 6
## $n_suits : 4
## $rank_text : ,a,2,3,4,5
## $spdx_id : CC-BY-SA-4.0
## $suit_color : black,black,black,black,grey40
## $suit_text : ,,,,
## $title : Swiss-suited (Black)
## $use_suit_as_ace : TRUE

ppdf::piecepack_preview() |> pmap_piece(cfg=cfgs$dual5_cutlines, default.units="in")

Preview of ‘dual5_cutlines’ configuration from ‘demo_cfgs.RData’

pushViewport(viewport(width=inch(6), height=inch(4)))
grid.piece("tile_face", rank=1:6,
           cfg=paste0("dual", 1:6, "_cutlines"), envir=cfgs,
           x=inch(rep(c(1,3,5), 2)), y=inch(rep(c(1,3), each=3)))
popViewport()

Can use multiple configurations stored in an environment at the same time

Intro to piecepackr’s API

2019-04-11T00:00:00-07:00

piecepackr is an R package to easily make piecepack graphics. It can be used to make piecepack game diagrams and animations as well as Print & Play layouts so you can make your own piecepack.

The core function is grid.piece() which can be used to draw any piecepack component:

library("piecepackr")
grid.piece("tile_face", s=1:4, r=1:4, x=inch(seq(1, 7, by=2)))

tile faces

grid.piece("coin_face", r=1:4, x=inch(seq(0.5, 3.5)))

coin faces

grid.piece("pawn_face", s=3)

clubs pawn (face)

grid.piece("die_face", s=2, r=1)

null of spades die (face)

piecepackr features an advanced configuration system that allows users to customize the appearance of the piecepack being used in their graphics. By default it uses an accessible french-suited configuration that should work out of the box on several OSes without the user needing to mess around with their system fonts but user’s can customize their piecepack’s appearance via use of a configuration list:

dark_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,black",
                         invert_colors.suited=TRUE)
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="0.6,0.7,0.75,0.9,0.9")
traditional_ranks <- list(use_suit_as_ace=TRUE, rank_text=",a,2,3,4,5")
cfg <- c(piecepack_suits, dark_colorscheme, traditional_ranks)
grid.piece("tile_face", s=1:4, r=1:4, x=inch(seq(1, 7, by=2)), cfg=cfg)

tile faces

grid.piece("coin_face", r=1:4, x=inch(seq(0.5, 3.5)), cfg=cfg)

coin faces

grid.piece("pawn_face", s=3, cfg=cfg)

crowns pawn (face)

grid.piece("die_face", s=2, r=1, cfg=cfg)

null of moons die (face)

ppdf::piecepack_preview() |> pmap_piece() allows one to see a preview of a given configuration list:

stopifnot(packageVersion("ppdf") >= "0.3.0-14")
ppdf::piecepack_preview() |> pmap_piece(cfg=cfg, default.units="in")

‘piecepack_preview()’ allows one to see a preview of a configuration

Once you have a configuration you like one can use save_print_and_play to make a Print & Play pdf of your piecepack and save_piece_images to make individual images of every piecepack component (in case you would prefer to make your own layout or rule diagram in software like Inkscape):

save_print_and_play(cfg, "my_piecepack.pdf", size="letter")
save_piece_images(cfg)

If you will be drawing a bunch of piecepack graphics you may want to use the pp_cfg function which will add a “component opt” cache to your configuration (will make grid.piece work faster):

cfg <- pp_cfg(cfg)

If you are comfortable manipulating R data frames pmap_piece is a wrapper around grid.piece that can digest data frame input:

df <- tibble::tribble(~piece_side, ~suit, ~x, ~y,
                      "tile_back", NA, 2, 2,
                      "coin_back", 1, 2, 2,
                      "coin_back", 2, 1, 2,
                      "coin_back", 1, 3, 1,
                      "coin_back", 2, 1, 3,
                      "coin_back", 1, 1, 1,
                      "coin_back", 2, 3, 3,
                      "coin_back", 1, 2, 1)
df$angle <- ifelse(df$suit == 2, 180, 0)
pmap_piece(df, cfg=cfg, default.units="inches")

Tic-tac-toe example

More documentation about piecepackr’s API can be found in the package’s man pages.

Animations

2019-04-09T00:00:00-07:00

Contents

Directly using the {animations} package
Using {ppn}’s ‘animate_game’ function

Directly using the {animations} package

Note

Besides the animation package you may find gifski and tweenr helpful.

Here is a simple example of using the saveGIF() function from the animation package and piecepackr::grid.piece directly to make a GIF animation of a tic-tac-toe game of “Suns” versus “Moons” played on the “lines” of a single tile back:

library("animation")
library("grid")
library("piecepackr")
draw_tictactoe_game_step <- function(n, cfg=list()) {
    grid.newpage()
    pushViewport(viewport(width=inch(4), height=inch(4)))
    if (n > 0) grid.piece("tile_back", cfg=cfg)
    if (n > 1) grid.piece("coin_back", suit=1, cfg=cfg, x=inch(2),y=inch(2))
    if (n > 2) grid.piece("coin_back", suit=2, cfg=cfg, x=inch(1),y=inch(2), angle=180)
    if (n > 3) grid.piece("coin_back", suit=1, cfg=cfg, x=inch(3),y=inch(1))
    if (n > 4) grid.piece("coin_back", suit=2, cfg=cfg, x=inch(1),y=inch(3), angle=180)
    if (n > 5) grid.piece("coin_back", suit=1, cfg=cfg, x=inch(1),y=inch(1))
    if (n > 6) grid.piece("coin_back", suit=2, cfg=cfg, x=inch(3),y=inch(3), angle=180)
    if (n > 7) grid.piece("coin_back", suit=1, cfg=cfg, x=inch(2),y=inch(1))
    if (n > 8) grid.segments(x0=inch(0.5), y0=inch(1), x1=inch(3.5), y1=inch(1),
                             gp=gpar(col="blue", lwd=4))
    popViewport()
}
draw_tictactoe_game <- function(cfg=list()) {
    for (ii in 0:9) { draw_tictactoe_game_step(ii, cfg) }
}
cfg <- game_systems("dejavu")$piecepack
saveGIF({draw_tictactoe_game(cfg)}, movie.name="tictactoe.gif",
    ani.height=480, ani.width=480, ani.res=120, ani.dev="png", ani.type="png")

Animation of a tic-tac-toe game

Using {ppn}’s ‘animate_game’ function

ppn has a convenience function animate_game() that can be used to animate games recorded in Portable Piecepack Notation:

library("piecepackr")
library("ppgamer")
library("ppn")
dark_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,black",
                      invert_colors.suited=TRUE, border_color="black", border_lex=2)
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                    suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                    suit_cex="0.6,0.7,0.75,0.9,0.9")
traditional_ranks <- list(use_suit_as_ace=TRUE, rank_text=",a,2,3,4,5")
cfg3d <- list(width.pawn=0.75, height.pawn=0.75, depth.pawn=0.375,
                   dm_text.pawn="", shape.pawn="convex6", invert_colors.pawn=TRUE,
                   edge_color.coin="tan", edge_color.tile="tan")
cfg <- pp_cfg(c(piecepack_suits, dark_colorscheme, traditional_ranks, cfg3d))

puzzle2 <- matrix(c(4,4,4,5,2,0,2,4,0,3,1,1,
                    1,2,5,3,3,5,3,2,5,1,0,0), nrow=2, byrow=TRUE)
s2 <- solve_fujisan(coins=puzzle2)
game <- read_ppn(textConnection(s2$ppn))[[1]]
animate_game(game, file="fujisan.gif", cfg=cfg,
             op_scale=1, op_angle=90, trans=op_transform)

Animation of a Fuji-san game

Dual piecepacks PnP

2019-04-07T00:00:00-07:00

This is the demo of the six piecepacks that were included in the “dual piecepacks” proof-of-concept: one piecepack-suited piecepack, one latin-suited piecepack (inverted color scheme), two french-suited piecepacks (one ‘black’ suits, one ‘white’ suits), and two swiss-suited piecepacks (one dark grayscale color scheme, one light grayscale color scheme). One could use the piecepack-suited, latin-suited, and one of the french-suited piecepacks to build a “trial hoardpack”.

Contents

Dual piecepacks intro
Dual piecepacks #1 (Un-inverted Piecepack-suits and Inverted Latin-suits)
Dual piecepacks #2 (“Black” and “White” French-suits)
Dual piecepacks #3 (“Black” and “White” Swiss-suits)

Dual piecepacks intro

“Dual piecepacks” are eight piecepack suits with the following properties:

The eight suits suits can be “easily” visually distinguished
The eight suits can be “easily” visually split into two separate groups of four suits
Each “suit” in a group can be “easily” visually linked with exactly one suit in the other group

This gives one the following nice properties:

One can play games requiring one piecepack deck plus an expansion piecepack deck by treating the eight suits as separate suits
One can play games requiring two piecepack decks by treating each pair of linked suits as the same suit
One can play games that are “SixPack” friendly by taking three suits from each visually distinct group. One can scale this down to games that are “Playing Cards Expansion” friendly or even scale up to four-grouped-suits versus four-grouped-suits friendly games (like Canadian checkers or Bughouse chess).
One can play entirely new games provided by the extra layer of relationships. Proof-of-concept new game is Dual Piecepacks Poker.

It is possible to construct three piecepacks where each pair of piecepack decks are “dual piecepacks” (e.g. piecepack-suited + inverted latin-suited + light french-suited). This could be called a “trial HoardPack” (apparently “trial” is the proper “three” analogue to “dual”).

Dual piecepacks #1 (Un-inverted Piecepack-suits and Inverted Latin-suits)

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
ranks_noto <- list(rank_text="n,a,2,3,4,5", rank_fontfamily="Noto Sans")
dark_colorscheme <- list(suit_color="darkred,black,darkgreen,darkblue,grey")
piecepack_suits <- list(suit_text="\U0001f31e,\U0001f31c,\U0001f451,\u269c,\uaa5c", # 🌞,🌜,👑,⚜,꩜
                        suit_fontfamily="Noto Emoji,Noto Sans Symbols2,Noto Emoji,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="0.6,0.7,0.75,0.9,0.9")
noto_credit <- c("\u25cf This piecepack uses characters from Google Noto Fonts. OFL 1.1.",
                 "\thttps://www.google.com/get/noto/")
dual1 <- c(piecepack_suits, dark_colorscheme, ranks_noto)
dual1$credit <- noto_credit
dual1$description <- ""
dual1$title <- "Piecepack-suited (Un-inverted colors)"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dual1$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    dual1$spdx_id <- "CC-BY-SA-4.0"
}
bleed <- list(border_lex=0, border_color=NA_character_)
dual1_cutlines <- pp_cfg(dual1)
dual1_bleed <- pp_cfg(c(bleed, dual1))
ppdf::piecepack_preview() |> pmap_piece(cfg=dual1_cutlines, default.units="in")

A preview of the piecepack-suited piecepack

latin_suits <- list(suit_text="\ue008,\ue007,\ue006,\ue009,\uaa5c",
                        suit_fontfamily="Quivira,Quivira,Quivira,Quivira,Noto Sans Cham",
                        suit_cex="0.9,1,1,1,0.9",
                        invert_colors.suited=TRUE)
quivira_credit <- c("\u25cf This piecepack uses characters from the font Quivira. Public Domain.",
                    "\thttp://www.quivira-font.com/")

dual2 <- c(latin_suits, dark_colorscheme, ranks_noto)
dual2$credit <- c(quivira_credit, noto_credit)
dual2$description <- ""
dual2$title <- "Latin-suited (Inverted colors)"
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dual2$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    dual2$spdx_id <- "CC-BY-SA-4.0"
}
dual2_cutlines <- pp_cfg(dual2)
dual2_bleed <- pp_cfg(c(bleed, dual2))
ppdf::piecepack_preview() |> pmap_piece(cfg=dual2_cutlines, default.units="in")

A preview of the latin-suited piecepack

Dual piecepacks #2 (“Black” and “White” French-suits)

french_suits_black <- list(suit_text="\u2665,\u2660,\u2663,\u2666,\uaa5c", # ♥,♠,♣,♦,꩜
                        suit_fontfamily="Noto Sans Symbols,Noto Sans Symbols,Noto Sans Symbols,Noto Sans Symbols,Noto Sans Cham",
                        suit_cex="1,1,1,1,0.9")
dual3 <- c(french_suits_black, dark_colorscheme, ranks_noto)
dual3$title <- "French-suited (Black)"
dual3$credit <- noto_credit
dual3$description <- ""
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dual3$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    dual3$spdx_id <- "CC-BY-SA-4.0"
}
dual3_cutlines <- pp_cfg(dual3)
dual3_bleed <- pp_cfg(c(bleed, dual3))
ppdf::piecepack_preview() |> pmap_piece(cfg=dual3_cutlines, default.units="in")

A preview of the ‘black’ french-suited piecepack

french_suits_white <- french_suits_black
french_suits_white$suit_text <- "\u2661,\u2664,\u2667,\u2662,\uaa5c" # ♡,♤,♧,♢,꩜
dual4 <- c(french_suits_white, dark_colorscheme, ranks_noto)
dual4$title <- "French-suited (White)"
dual4$credit <- noto_credit
dual4$description <- ""
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dual4$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    dual4$spdx_id <- "CC-BY-SA-4.0"
}
dual4_cutlines <- pp_cfg(dual4)
dual4_bleed <- pp_cfg(c(bleed, dual4))
ppdf::piecepack_preview() |> pmap_piece(cfg=dual4_cutlines, default.units="in")

A preview of the ‘white’ french-suited piecepack

Dual piecepacks #3 (“Black” and “White” Swiss-suits)

orthodox_ranks <- list(rank_text=",a,2,3,4,5",
                       use_suit_as_ace=TRUE)
black_colorscheme <- list(suit_color="black,black,black,black,grey40",
                          background_color="grey70",
                          invert_colors.suited=TRUE)
swiss_suits <- list(suit_text="\ue005,\ue004,\ue000,\ue003,\ue00a",
                    fontfamily="Quivira")
dual5 <- c(swiss_suits, black_colorscheme, orthodox_ranks)
dual5$title <- "Swiss-suited (Black)"
dual5$credit <- quivira_credit
dual5$description <- ""
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dual5$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    dual5$spdx_id <- "CC-BY-SA-4.0"
}
dual5_cutlines <- pp_cfg(dual5)
dual5_bleed <- pp_cfg(c(bleed, dual5))
ppdf::piecepack_preview() |> pmap_piece(cfg=dual5_cutlines, default.units="in")

A preview of the ‘black’ swiss-suited piecepack

white_colorscheme <- black_colorscheme
white_colorscheme$suit_color <- "white,white,white,white,grey40"
dual6 <- c(swiss_suits, white_colorscheme, orthodox_ranks)
dual6$title <- "Swiss-suited (White)"
dual6$credit <- quivira_credit
dual6$description <- ""
if (packageVersion("piecepackr") >= "1.10.0-8") {
    dual6$copyright <- "\u00a9 2019 Trevor L Davis.  Some Rights Reserved."
    dual6$spdx_id <- "CC-BY-SA-4.0"
}
dual6_cutlines <- pp_cfg(dual6)
dual6_bleed <- pp_cfg(c(bleed, dual6))
ppdf::piecepack_preview() |> pmap_piece(cfg=dual6_cutlines, default.units="in")

A preview of the ‘white’ swiss-suited piecepack

Default PnP

2019-04-06T00:00:00-07:00

The default type of piecepack built by this software if the user does no configuration. The default piecepack has the following properties.

Uses symbols only found in R’s default sans font so that it works on multiple OS platforms out of the box without the user needing to mess with their fonts (unfortunately this means we can’t use the traditional piecepack suits).
Builds a 4-suited piecepack using multicolored french-suits for compatibility with french-suited playing cards and other potential game accessories (like Icehouse Pyramids).
Has a suit symbol on every suited component so the suits are accessible for the color-blind (as well as being decipharable for the non-color-blind if game diagrams are printed in grayscale).
Uses a white background so not a lot of toner needs to be used in printing out diagrams.
Uses a colorblind barrier-free color palette.

library("piecepackr")
stopifnot(packageVersion("ppdf") >= "0.3.0-14")
default1 <- list()
default1$description <- 'This is the default piecepack produced by `pp_cfg()`.'
default1$title <- "{piecepackr}'s default piecepack"
default1$credit <- ""
if (packageVersion("piecepackr") >= "1.10.0-8") {
    default1$copyright <- "Created in 2019 by Trevor L Davis.  No Rights Reserved."
    default1$spdx_id <- "CC0-1.0"
}
borders <- list(border_lex=4, border_color="black")
bleed <- list(border_lex=0, border_color=NA_character_)
default1_cutlines <- pp_cfg(default1)
default1_borders <- pp_cfg(c(borders, default1))
default1_bleed <- pp_cfg(c(bleed, default1))
ppdf::piecepack_preview() |> pmap_piece(cfg=default1_cutlines, default.units="in")

A preview of the default piecepack made by piecepackr