Giters

beyarkay / card_game_builder

Got a cardgame idea? This project will convert it to printable PDFs which you can cut out!

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool

Card Game Builder

(There may be some rude language in the game files)

Quickstart

Go to the release page and download the PDFs for the card games you want. The instructions for each game are on the first page of the pdf. Currently, the card games available are:

  • Cards Against Humanity
  • Chameleon
  • Code Names
  • Dont Get Got
  • Fake Artist Goes To NYC
  • Fear Pong
  • Get Legless
  • Insider
  • Most Of These People Are Lying
  • No Thanks
  • Paranoia
  • Red Flags
  • So You're In A Hot Air Balloon

Convert card game ideas into printable PDFs you can cut out!

Lots of card games boil down to basically just a load of creative prompts on cardboard which you. Think Cards Against Humanities, Red Flags, Chameleon, etc.

This project aims to make it simple to create your own card games by writing up your prompts in a file. The Rust program will then convert that file to a PDF with nicely formatted cards which you can print off, cut out, and then play with.

Examples

Red Flags (see Red_Flags_Basics.pdf) for the full pdf):

So you're in a hot air balloon:

Most of these People are Lying:

Features

  • Open source
  • Multiple card games are already in the repository
  • Easy (and flexible) interface via standard YAML markup files

How to print the files and start playing

First you'll need to download the PDF files. You can easily do this by going to the release page and downloading the games you're interested in. Instructions and game information are all on the first page of the pdf.

Once you've got the PDF, it's really worth the effort to take it to a print shop and ask them to print it out for you on card, and then ask to use their guillotine (or ask if they'll cut it up for you). This makes the game much more playable than trying to print it out yourself on regular printer paper.

Once you've got all your cards cut out, I highly recommend buying a box or two of small circle stickers and putting one sticker around the corner of each playing card. This will make it obvious which game it is (ie a red circle for the game Red Flags or a black dot for Cards Against Humanity) and also make it much easier to keep all the cards the right way up.

You can also often get long thin plastic boxes from a plastics warehouse which are perfect for holding the cards.

Beyond this, you're basically done. Enjoy the game and be sure to leave comments/feature requests if you find something that could be improved!

Creating your own card game

Making your own card game is super simple. First, you'll need to download the code:

Installation

Assuming you've installed git and have also installed rust, and LaTeX, simply git clone and then cargo run:

  1. git clone https://github.com/beyarkay/card_game_builder.git
  2. cd card_game_builder
  3. cargo run --release

Defining your own game as a YAML file

The Rust code expects to be given a .yaml file, and will write one or more .pdf files. This .yaml file is what you'll write to describe your game, and must include everything about that game, including:

  • The name of the game, version number (following SemVer), instructions, number of players, duration, authors, and website:
name: Red Flags
version: 0.1.0
instructions: We are all introducing one lucky
    friend to what we believe is their perfect match!
    When it's your turn, choose 2 perks you believe
    they would like in a person they date. After all
    perks are placed, you will have the chance to
    destroy your opponents adding a red flag to their
    applicant. Then your friend has to pick the best
    (or least worst) applicant, if yours gets picked,
    you get a point!
num_players: 4 or more
authors: Darin Ross, Skybound Games
website: https://www.amazon.com/Red-Flags-400-Card-Main-Game/dp/B018EXPGPI
duration: Multiple rounds of about 20 minutes each
...
  • The game format is designed to allow you to expand upon the game later. You do this by defining one or more expansions (like The Base Game, The Halloween Expansion, The Nerdy Expansion, etc) and then each of these expansions should have one or more categories. Expansions are described in more detail below.
  • The categories are used if you need different types of cards (like red flags and green flags in the game Red Flags, or like black cards and white cards in the game Cards Against Humanities).
  • Within each category is where you actually write your prompts for the game. For example:
...                     # The preamble described above isn't included here
expansions:                 
  - base:               # This is the `base` expansion, defining the main game
    name: The Base Game # Each expansion should have a name, which will be
                        # printed on the card
    categories:         # The base expansion has 2 categories:
      - red_flags:      # The first category is Red, for bad personality traits
        name: Red       # Each category should have a name, which will be
                        # printed on the card
        items:
          - Adds you as an emergency contact on the first date
          - They had your phone number before you had officially met
          - Compulsive liar
          ...
      - green_flags:    # The second category is Green, for good personality traits
        name: Green
        items:
          - They know how to take a compliment
          - They make your ex jealous
          - Has a magic bag that contains unlimited cheese
          ...

See the full yaml file for Red Flags for a complete example, or see the template yaml file for something you can copy-paste and then fill out the details yourself.

All the 'metadata' information (instructions, number of players, creation date, etc) will be printed on the first few cards and specially formatted so that you can just bundle the instructions together with the playing cards in the same box and not have to worry about losing it.

Halp! Printing all this is getting expensive

If you've got a lot (over 500) cards, then printing them out all at once might be too expensive. You can define expansions of your card game, such that each expansion is mutually exclusive. This allows you to first create a small batch of cards, print them out, and then if you want to create more cards you can define them as a second expansion in the same .yaml file and tell the program to only print out the second expansion. This way you can split the costs into smaller batches, or give the base game as a gift, and later give expansions to the same game as subsequent gifts.

You could also treat the different expansions as themes for the game, like The Halloween Expansion, The Sexy Expansion, The University Expansion, The "People I've Dated" Expansion, etc.

Example yaml using multiple expansions:

...
expansions:
  - base:                       # The base expansion, for the base game
    name: The Base Game
    categories:
      - red_flags:
        ...
      - orange_flags:
        ...
      - green_flags:
        ...
  - nerdier:                    # The Nerdy expansion, for nerdy red flags
    name: Nerdier Red Flags
    categories:
      - red_flags:
        ...
      - orange_flags:
        ...
      - green_flags:
        ...
  - fairy_tale:                 # The Fairy-tale expansion, for magical flags
    name: Fairy-tale Flags
    categories:
      - red_flags:
        ...
      - orange_flags:
        ...
      - green_flags:
        ...

YAML Card Game File to PDF

Once you've created your yaml file, you'll need to run the rust code to compile the yaml to a PDf that you can print.

This is as simple as running the Rust code and passing in the path to your .yaml file.

cd card_game_builder
cargo run games/cards_against_humanities.yaml

You can optionally pass in the expansion(s) you'd like to generate as quoted strings:

cd card_game_builder
cargo run card_game_builder games/cards_against_humanities.yaml "The Sexy Expansion" "The Chrismas Expansion"

The .yaml files are first converted to LaTeX, via the flashcards class, and then that LaTeX file is compiled to a pdf document. If the LaTeX compilation succeeds, then the original tex files are deleted.

Contributions

Contributions are very welcome! And they don't have to be code either. If you've got a card game file that you'd like to contribute, then submit a pull request and I'll add it.

Features, bug fixes, and improvements are also welcome!

Future game ideas

Future code ideas

  • Actually convert .tex files to LaTeX automatically
  • Actually have front matter on the first few cards
  • Use the GitHub releases feature instead of committing .pdf files to source control

About

Got a cardgame idea? This project will convert it to printable PDFs which you can cut out!

Languages

Language:TeX 73.4%Language:Rust 26.6%