top of page

Interactive Monopoly

Physical Computing, Programming, Fabrication | April - May 2023

We built a functional Pittsburgh-specific Monopoly game by integrating a physical and digital board transmitting messages using 2 Arduino Megas. Creating a capacitive touch sensor with RGB LEDs integrated with a laser-cut wooden board and 3D-printed game pieces, alongside a Python application for gameplay and UI, the game both digitally and physically reflects various aspects of Monopoly including player money, rolling dice, purchasing property, paying rent, jail, and more. 

​

Our objective was to translate a primarily 2D version of this common game which requires multiple physical components into a unique interactive experience offering increased portability, convenience with rapid setup, and immersiveness.

Team Members: Spoorthi Cherivirala, Tim Carullo, Allie Feldman 

Programming & Physical Computing​​

Arduino
Python
PyFirmata
PySerial

Fabrication 

Adobe Illustrator
Figma
Laser Cutting
Fusion 360
3D Printing
Frame 12 (3).png
Game Overview

INTRODUCTION

Game Overview

Why Monopoly?

Monopoly is ranked as the most popular board game of all time, with more than 500 million players worldwide. Like many classic board games, Monopoly requires a setup process before beginning any game, involving distributing money, properties, and other game pieces. Evidently, the game has so much appeal that many parents are willing to endure this tedious setup process and keep track of the game’s small pieces to play the game with their children. While there are many variants of Monopoly with a diverse range of themes, none of these variants explore an altered gameplay including digital interactivity. We believe that incorporating interactive aspects to board games, such as Monopoly, would allow for a much more immersive and carefree board game experience. Our Monopoly spinoff greatly reduces the number of required physical pieces without compromising the sensation of physical gameplay. In this variation, Pittsburgh Monopoly, players’ bank account balances, owned properties, and interplayer transactions are moderated and updated by a computer application capable of both reading and writing to the game board, which would connect to a computer by a USB-A cable.

Our Goal

Our idea is to create an interactive board game based off of the game Monopoly. The objective of the game is the same as it is in Monopoly: to be the last player standing with money. The game will be able to support up to 3 players, using a supplemental Python application to manage various aspects of the game such as how much money players currently have, rolling dice, and purchasing property. The purpose of our project is to translate a primarily 2D version of this common game into a unique interactive experience the user is able to immerse themselves in. To add customizability to our idea, we plan to simplify and translate the traditional monopoly setup to be relevant to people who live in Pittsburgh. For instance, properties will be modeled off various landmarks in Pittsburgh (e.g. Cathedral of Learning, Phipps Conservatory). By integrating a physical and digital board, we create a sense of portability, convenience with rapid setup, and immersiveness. .

Game Demo Video (with audio)

Game Components

348362315_1171806156819911_3820374549044705993_n (1).jpg
image18.png

Physical board and digital board reflect the changes of

each other using 2 Arduino Megas to transmit messages 

Gameplay Breakdown

  • Pass Go: Gain $100, $100 added to PNC Parking

    • Money Management: Reflected on digital board 

  • Land on Property: Buy that property if not owned, Pay rent if owed to the owner

    • Property Costs & Names: Displayed on the physical board

    • Property Ownership: Indicated on the digital board and LED

    • Property & Piece Detection: Physical Board

  • PNC Free Parking: Gain all money in the pot

  • CMU Jail: Automatically Skips 2 Turns

Fabrication

IMPLEMENTATION DETAILS

Fabrication (Laser Cutting & 3D Printing & Soldering)

Physical Circuit Board 

We created the capacitive touch sensor with 256 nodes using 16 transmitter and receiver lines with copper tape overlapping in even increments to ensure conductivity, where the paper in between acts as an insulator between the two layers. 

This required several iterations since the copper tape and electrical tape were flimsy and the initial soldering was not conductive enough. We ended up recreating the board multiple times, covering each line with copper tape on both sides then hot gluing the pins down to a firm cardboard piece. Prior to creating a 16 by 16 board we first experimented with smaller boards (such as 9 and 4x4 grids). Above include photos of our iterations. 

Physical Wooden Board

Next, we crafted a laser-cut board so that each property space would correspond to exactly 4 distinct nodes on the sensor grid. The board was created using Adobe Illustrator in order to set the correct spots to engrave and cut.

Properties are all Pittsburgh specific such as: 

  • Row 1: Pittsburgh Attractions (Phipps, PPG Place, Cathedral of Learning, Schenley, Incline)

  • Row 2: Popular Food Locations (Pamela’s, The Porch, Stack’d, Millie’s, Noodlehead)

  • Row 3: Museums (Mattress Factory, National Aviary, Andy Warhol, Randyland, Point State)

  • Row 4: Universities (CMU, Pitt, Duquesne, Chatham, Point Park) 

To the left is the vector illustration file (on the right) and the finished laser cut board (on the left). The middle of the board is also removable to allow for future expansions with LCD displays and more interactive components. We also had to cut multiple iterations to ensure the alignment was perfect and that 4 distinct nodes for each property were exposed. 

Distinguishable Game Pieces

Next, we 3D modeled the pieces in Fusion 360 (second image below) ensuring that each player piece has a different conductive bottom (first image) with a different surface area to ensure it would touch a distinct number of nodes, able to be distinguished when fitting exactly in the property spaces. After testing the pieces, the signal was extremely weak so we also covered the bottoms with conductive tape.

Physical Computing

Physical Computing (Circuitry & Arduino, Sensors: Capacitive Touch, LEDs)

Capacative Touch Sensing

In order to convert physical gameboard interaction to digital information, we, essentially, created a capacitive “touchscreen” out of a lightweight insulator (a piece of paper in our prototype) and conductive lines, and placed this touchscreen underneath the wooden board. The cutouts in the board on each game square expose the transmitter and receiver lines, made out of highly conductive copper tape. As explained in the previous section, the dimensions of the board as well as the size and spacing between conductive lines was designed to read the shapes at the bottom of the game pieces.

 

We used “Multi-Touch Kit”, a library and tutorial created by researchers at the University of Saarland, to parse the receiver signals powered by the transmitter lines. We used a standard 16-channel multiplexer to fire each of the 16 transmitter lines on a cycling timer encoded onto the Arduino and applied 100kΩ of resistance to each of the receiver lines, which we connected back to the Arduino’s analog ports. Below includes the circuit diagram for a smaller 8-channel board which we extrapolated for 16 channels using an Arduino Mega. 

The main function of our Arduino code is to initialize the pins for our output multiplexer bits, signals, and our 16 analog ports.
A read function given by the library we edited allows you to toggle back and forth between raw data and boolean data. Analyzing the raw data (serial monitor output displayed below), we set a threshold of 30 in order to determine touch. We also changed the

serial print of that read function to truncate all 1s and 0s onto one line in order to send it to Python over Serial. 
 

Sending Arduino -> Python 

Based on the capacitive touch sensor data, if the signal is above our set threshold (30), returns 1, if not returns 0 for all 16 x 16 nodes. Then we translate the signals to a 256-bit array, sent to Python over Serial. In Python, we attribute all of the 256 nodes to the specific properties.
. 

RGB LEDs

Arduino Mega receives data from Python with pin information and colors to output when a specific property is purchased by a specific player. We connected 5 RGB LEDs as proof of concept for our properties lighting up (circuit diagram and wiring shown below). The Arduino code uses StandardFirmata for turning on LEDs. In order to connect all properties with ground, we need more pins in the Arduino or will determine how to chain LEDs with all color channels. 



. 

Programming

Programming (Python Game Development & UI & Arduino Integration)

Python Gameplay

We used Python to develop the game and interface, as well as to integrate with our Arduino’s serial output. We utilized CMU Graphics for graphics and event listening as well as pyserial and pyfirmata for Arduino integration. The Python application we created manages various aspects of the game logic such as money tracking, dice rolls, passing go, purchasing properties, and paying rent. It also listens to mouse input when a user clicks to boy properties/ rolls during their turn. 

Piece Detection 

One of the key features of our game is the ability to interact with the physical board. When a player lands on a property, the corresponding nodes on the touch sensor are activated, allowing Python to detect which property the player has landed on. We implemented this by sending Arduino input in the form of a 256-bit array to Python and parsing the bits and assigning them to specific properties where each property has 4 nodes, indicating which ones were touched with a 1.

​​

Sending Python -> Arduino 

We also sent data to the Arduino to blink LEDs when a player buys a property at its given location. We ran into permission issues with Serial (for reading) & Firmata (for writing) from the same port so had to open another port using a second Arduino Mega in order to send pins and colors to the Arduino when required from Python code. We experimented with opening virtual ports however they weren't as compatible with Windows. 

Next Steps

Next Steps

Obstacles

We ran into multiple hardware and software issues during the development process. Some of our primary issues are listed below: 

  • Not enough channels with an Arduino Uno, which resulted in requiring an Arduino Mega but we then needed a strong computer in order to power it

  • The capacitive signal was too weak for thresholds and the soldering was not conductive enough which made touch localization difficult to pinpoint and parse using the raw data

  • Needed multiple open ports for writing to & reading from (between Arduino & Python) 

  • Properly sending/parsing signals from Python to Arduino (inconsistent Serial readings)

  • Needed more Arduino pins for LEDs or determine how to chain LEDs

Scalability

The concept of hybrid interactivity can be expanded to many other board games that also use multiple physical pieces for their operation. Other physical components could be easily integrated into games such as Candyland or Battleship to ensure that they are immersive in the 3D realm. The touchscreen sensor could be easily used for different game sensing, only requiring new programming for game logic and the construction of the physical board. 

Next Steps

  • Integrate LCD displays to indicate dice rolls and money for players

  • Experiment with improving localized touch signals using stronger copper wire

  • Minimize wires required for RGB LEDS through chaining

  • Figure out how to open virtual ports in order to remove the second Arduino Mega

References

Code References

References​​

Our Implementation Code

Python Code (Game implementation & Arduino Integration 

Arduino Monopoly Code 

MultiTouchKit Library Edited 

Python Graphics Implementation Folder 

bottom of page