Airborne: attack the opponent directly by flying over any opposing creatures.Return new ArrayList(protoDeck) // Return copy of prototype deckĪnd the class to manage the deck. Private static final List protoDeck = new ArrayList() All very simple using enums and Collections public class Card The java 1.5 enum tutorial has a interesting way to implement a deck of cards, building up the deck, shuffling and dealing. For the round function of the feistel network, I'd recommend something like murmurhash3 because it's fast and has a good avalanche effect, which would make the shuffles appear well randomized.Ĭheck out my blog post for even more detailed info and source code:

One really good way to come up with a custom sized encryption algorithm like this would be to use a feistel network, which lets you customize size and quality depending on your needs. Your algorithm doesn't need to be cryptographic quality (and it shouldn't be, cause that would be computationally expensive!). To reshuffle the deck, set the index back to zero and change the encryption key (shuffle seed). Since encrypting 0-63 will result in 0-63 as output, in a different order, you are just ignoring any value that comes out >= 52 so that you have your algorithm that takes in 0-51 and spits out 0-51. If the value is >= 52, you ignore it and generate a new number (and increment the index again of course). To draw the next card from the deck you'd have an index variable which started at zero, you'd encrypt that index, increment the index and look at the value that came out of the cipher. In this case you'd have to make or find an encryption algorithm that took in 6 bits and spit out 6 bits (0-63). In other words you have your shuffle and don't even need to do any actual shuffling. Since encryption is reversible by definition that means any 2 input numbers cannot encrypt to the same output number, which means if you encrypted 0 to 51, you'd get 0 to 51 as output in a different order. I'd like to chime in and mention 'format preserving encryption' as a method for shuffling cards in a game.Įssentially what you'd have is an encryption algorithm that takes in a value 0 to 51, and a key (shuffle seed) and spits out a value 0 to 51. In pseudocode, with n being the number of cards in the deck, and a being an array representing the deck, the algorithm looks like this: for each i in do If we randomly selected the card which was already in that position, then no swap is performed.Īfter swapping (or not swapping, if we randomly selected the card which was already in the position we were considering), we move on to the next position in the deck and continue. When we have made the random selection, we swap the card at the position we're currently considering with the card we randomly selected. Now, we consider each position in the deck, one at a time, starting from the bottom, and working our way up to the top.įor each position, we randomly select one of the cards which is at that position or at a lower-numbered position (remember, the top of the deck is 0, and we're working our way up from the bottom of the deck, so for each position, you're effectively picking up all the cards at and above that position and randomly picking one of those cards). For example, the card on top of the deck is at position 0, the card beneath that is at position 1 (because there is 1 card higher than it - the top card), and in a standard 52-card deck, the bottom card is at position 51, as 51 cards are higher than it in the deck. We're going to be talking about 'position' in the deck, where 'position' is how many cards are higher in the deck than the card in that position. For this discussion, you can have any number of cards in the deck, and they may start in any order. What I'm presenting here is a very slightly simplified version of the algorithm covered on that page under The modern algorithm.Ĭonsider a deck of cards. There's a good reference for implementing card shuffling correctly on Wikipedia. Card shuffling is an algorithm which is easy to write intuitively, and get entirely wrong by doing so.

Static card inscryption