Exception Not Found

MODELI NG PRACTI CE A S P. N E T C# SAMPLE PROJ ECT S I M U L AT I O N S

GAMES

Modeling Practice -
Candy Land in .NET Part
1: Overview
5 years ago by Matthew Jones ∙ 4 min read

This is Part 1 of a two-part series detailing how to simulate the Hasbro board game Candy Land as
a C# console project.

Anybody remember the game Candy Land? You know, the simple colors and sweets game that little
children play to learn how to play board games? The one that requires absolutely zero skill or
reading comprehension to play?

Thanks for reading! Would you care to

buy me a coffee?
Candy Land by amboo who?, used under license

Lemme break it down for those of you who haven't seen this game before. Players draw cards
which have simple colors (red, orange, yellow, blue, green, purple) on them, and then move to the
next matching space with that color. There are also seven "specialty" spaces with pictures of sweet
items on them, and if you draw the card with that item you go directly to that space (which also
means you could move backwards by drawing a specialty card). The rst player to reach the end of
the path wins.

Only two complications arise on the board: a couple spaces have black licorice on them, and if you
land on one of those space your next turn is skipped (which doesn't make any sense to me, seeing
as black licorice is delicious); and there are two shortcuts on the board that can be accessed by
landing on their starting spaces.

Simple enough, right? Here's the interesting part: the game is deterministic. Once the cards are
shuf ed, a person who can see the deck of cards will know who will win the game.

That means that we can write a program to simulate playing the game, and it wouldn't be too hard.
Guess what we're gonna do? Let's build a command line Candy Land simulator in C# and .NET!

Basically Awesome
Thanks for reading! Would you care to
buy me a coffee?
Before we can do anything else, we need to model the components of Candy Land as C# classes. In
any game of Candy Land, there are three basic components:

1. The players playing the game (between 2 and 4)

2. The cards the players can draw (64 in my edition)

3. The spaces the players can land on (134 in my edition)

However, there are also three higher-level objects, which are comprised of the basic objects.

1. The deck of cards that can be drawn from.

2. The board, which contains all of the spaces.

3. The game itself, which comprises the board, the deck, and the players.

We'll need all six of these objects to play a game; the latter three we will deal with in Part 2 of this
series. For now, let's start with the players.

Don't Hate the Players

We'll need some basic information about the players in order to simulate the game. Technically, the
only thing we really "need" is their turn order, but to make the simulation a little nicer we'll also
gather the players' names.

public class Player

{
public string Name { get; set; }
public int CurrentLocation { get; set; }
public int Order { get; set; }
public bool IsSkipped { get; set; }
public bool IsWinner { get; set; }
}

Note the property CurrentLocation . We need a way to store what space the player currently resides
on, and IMO the best place to put that is in the Player class itself. We'll explain the IsSkipped
property in the BoardSpace section.

The property IsWinner is a ag that the Game object will look at after each turn; as soon as one
Player has IsWinner set to true, the game is over.

Now that we've got Player de ned, we need to take a look at something that is common to the
BoardSpace and Card classes: CandyColor.

Thanks for reading! Would you care to

Have Some Candy!

buy me a coffee?
Here's the board for my game:

Thanks for reading! Would you care to

buy me a coffee?
Note that there are six "regular" colors for the spaces: red, orange, yellow, green, blue, and purple.
These six colors also appear on the cards. Further, note that there are seven "special" spaces that
can appear on both the board and the cards: star, ice cream, gingerbread, chocolate, cupcake,
lollipop, and ice pop.

Since these thirteen "values" are available to both cards and spaces, we're going to make an
Enumeration to represent them (because I like enums), and we'll call that Enum CandyColor:

public enum CandyColor

{
Red,
Orange,
Yellow,
Green,
Blue,
Purple,
Cupcake,
Star,
IceCream,
Gingerbread,
Chocolate,
Lollipop,
IcePop,
Rainbow
}

Wait, you say, what is "rainbow? Note that board's nal space has all the colors, signifying that you
can draw any color to land on it and win the game. As we'll see in later parts of this series, it's not
strictly necessary to represent this space, but I'm going to do so for posterity.

With the common values de ned, we can start building the Card and BoardSpace classes.

Is THIS Your Card?

Cards in Candy Land show a CandyColor, but can also show one or two of the "regular" colors. My
class for these Cards looks like this:

public class Card

{
public CandyColor Color { get; set; }
public int Amount { get; set; }
}

Woohoo easy part!

Thanks for reading! Would you care to
buy me a coffee?
Gimme Some Space!
The next piece to this puzzle is the class that represents the spaces on the board. In addition to the
CandyColors represented, there are two other "special" kinds of spaces:

Licorice spaces which cause any player that lands on one to have their next turn skipped (this is
why we have the Player.IsSkipped property).

Shortcut spaces which send the player forward to a different space.

Our BoardSpace class will look like this:

public class BoardSpace

{
public CandyColor Color { get; set; }
public int Position { get; set; }
public bool IsLicorice { get; set; }
public int? ShortcutDestination { get; set; }
}

Now that we've got all of our Game Components de ned, we can start writing code to set up the
game itself. We'll do that in Part 2 of this series, where we discuss Programming the Game.

SHARE THIS ARTICLE

YOU MIGHT ALSO LIK E

MODELI NG PRACTI CE MODELI NG PRACTI CE MODELI NG PRACTI CE

Modeling Ti et to Ride
in C# Part 6: Structure, Modeling Ti et to Ride Modeling Ti et to Ride
Scoring, and in C# Part 5: Player in C# Part 4: Player
Drawba s Drawing Cards Claiming Routes

Thanks for reading! Would you care to

buy me a coffee?
 NEWER ARTICLE OLDER ARTICLE

Modeling Practice - Best Practices: Fight

Candy Land in .NET Code Ambiguity with
Part 2: Programming Enumerations
the Game

Login

Add a comment

M ↓   MARKDOWN ADD COMMENT

Powered by Commento

Signup Newsletter Authors Categories Guest Writer Program

Speaking

EXCEPTION NOT FOUND © 2020 — ALL RIGHT RESERVED. PUBLISHED WITH

GHOST.

Thanks for reading! Would you care to

buy me a coffee?