Danny Jo

Introduction

Looking back in time I just realised that I’ve been to three poker evenings with some mates from work. I’ve never really been a great fan of poker and to be honest I’m still not a massive fan, don’t get me wrong, we end up having a brilliant evening together. A pub meal, a few beers and some poker, great combination. Therefore I decided the other day that I wanted to try and build a poker server/client using web technology alone, in this case a Java webapp with some nice HTML5.

Phase 1

I’ve now entered the first phase of this project, inception if you like, it’s a one man band thing so don’t expect progress to be too grand every day. I’ve decided to try and keep updating the world on my progress on this project and therefore new blog posts will appear here over time.

This first phase is all about figuring out what I want the end product to be and a possible design to go with. So far it looks pretty good, it’s going to be simple, really simple, there will be a web page which allows people to view a list of available tables to join or allow them to create one. There will be the need for some sort of credentials storage or similar, maybe connect it with facebook or similar in order for users to have some way of uniquely identifying themselves. The plan is to host this whole thing on the Amazon Cloud and possibly also use Amazon SimpleDB for persistence (still under investigation). Something else I’ve decided to use for this is HTML5′s websockets specification. It’s something that I’ve been keen on learning for a while and here’s my chance.

At the moment I’ve designed and implemented what will represent a card and a deck of cards.

public class Card implements Comparable {

    public enum Suit {
        HEARTS,
        DIAMONDS,
        CLUBS,
        SPADES
    }

    public enum Value {
        TWO(2),
        THREE(3),
        FOUR(4),
        FIVE(5),
        SIX(6),
        SEVEN(7),
        EIGHT(8),
        NINE(9),
        TEN(10),
        JACK(11),
        QUEEN(12),
        KING(13),
        ACE(14);

        private final int value;

        public int getValue() {
            return this.value;
        }

        private Value(final int value) {
            this.value = value;
        }
    }

    private final Suit suit;

    private final Value value;

    public Card(final Suit suit, final Value value) {
        this.suit = suit;
        this.value = value;
    }

    public Suit getSuit() {
        return this.suit;
    }

    public Value getValue() {
        return this.value;
    }

    @Override
    public String toString() {
        final StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(this.value.toString()).append(" of ").append(this.suit.toString());

        return stringBuilder.toString();
    }

    @Override
    public int hashCode() {
        return 19 * this.suit.ordinal();
    }

    @Override
    public boolean equals(final Object object) {
        if (object != null && object instanceof Card) {
            final Card other = (Card) object;
            return (other.suit.equals(this.suit) && other.value.getValue() == this.value.getValue());
        }

        return false;
    }

    public int compareTo(final Card other) {
        if (other.suit.ordinal() > this.suit.ordinal()) {
            return -1;
        } else if (other.suit.ordinal() < this.suit.ordinal()) {
            return 1;
        } else if (other.suit.ordinal() == this.suit.ordinal()) {
            if (other.value.getValue() > this.value.getValue()) {
                return -1;
            } else if (other.value.getValue() < this.value.getValue()) {
                return 1;
            }
        }

        return 0;
    }
}

That's the basics of a card, easy. I've also created the interface for the deck.

public interface Deck {

    /**
     * Takes the top card off the deck and returns it, therefore decreasing the
     * amount of cards in the deck.
     * 
     * @return {@link Card}
     */
    public Card takeTopCard();

    /**
     * Shuffles the deck, no matter how many cards are left.
     */
    public void shuffle();

    /**
     * Rebuilds the deck of cards.
     */
    public void gatherAllCards();

    /**
     * Lets you know how many cards are left in the deck.
     * 
     * @return the number of cards left in the deck.
     */
    public int cardsLeft();
}

I will try and reveal some more interesting code in my next article.

Phase 2

The next phase will be more about getting some sort of proof of concept up and running, probably as an EC2 instance either manually or using the Elastic Beanstalk. Hopefully I will have some working code that uses websockets to push information about the table to the browser. The main thing to get sorted I believe will be the actual poker engine itself.

That will have to be it for now, I will post another article once I have some more interesting facts.