Author: pkollman

This week began with preparing for the final presentation and full integration. For full integration, I set up the environment we used for our mini demo in our final presentation. I got a poker table for the actual game and big TV to display the Player UI. After that, me and team worked together on fixing the bugs in our overall system and controlling variables like color temperature and distance variation of chips on the table.

Moving forward, me and the rest of the team will be finishing the final poster, demo, and report. End of the semester came so quick!

This week we fully integrated the entire system with exceptions to the CV algorithm having some tweaking to be completed.

The servo subsystem is fully integrated and has been tested to meet accuracy requirements. It is extremely accurate and moves extremely quickly to the correct player.

The chip color configuration has been tweaked for Brandon’s new CV algorithm as well, and there are now options to edit the Big Blind Value.

On my end, I’ve tested the software and Dealer UI robustly. I’ve tried to break it as many ways as possible, but everything goes smoothly.

We’ve been compiling these metrics for the Final Presentation slides and look forward to presenting this week.

This week Steve and I finished the poker game progression logic. Pressing Play Game on the home screen initializes the game and places the small blind position at player 1.

As the round progresses, each player as the choice to fold, raise, call, or check when allowed.

Folding removes the players from the hand, and their icon become red.

Turn logic has been implemented. Our debugging can be seen in the middle of the screen, and here it shows the progression from “preflop” to “flop”. The four round modes are preflop, flop, the turn, and river.

When a game ends, the players all return back to the hand, and the small blind chip progresses to the next player at the table.

What is left to do is update the stack sizes with information read from Brandon’s CV algorithm, and to point the servo at the current player acting. The current player acting is highlighted by the green circle icon.

Very productive week 😀

 

I started this week by centralizing more information in the Game State Tracker. I created a config.py file which all the different subsystems can refer to for central player and table information.

Steve and I also made great progress together, and integrated the Dealer UI with the Servo library controls. We implemented a basic protocol where the Dealer UI can rotate the servo to a specific angle using inputs on the keyboard.

Moving forward, Steve and I also are working out the logic of turn progression in a poker game. We plan on using ordered lists of the players at the table to determine the progression of a poker round. The front of the list will always denote the Small Blind, which is usually the first player to act in a round. Once we have implemented the logic for poker turn progression, we will be able to rotate the Servo to the proper player position at the table.

This week I began working on the Game State Tracker and reorganizing the way the Dealer UI is structured. I am changing the structure so that the Game State Tracker will be central source of information versus other modules communicating with the Dealer UI for some game information.

For instance, one of the changes that I made defining a “Player” class and placing this module in the Game State Tracker.

Maintaining this class and other types of central table information will be key to writing the Game State Tracker in the future. Looking to make a lot of progress in the next couple days.

This week I made substantial progress on writing the foundation for the Player UI and Dealer UI. I used a game module called “Pygame” to write the following GUIs.

This is a basic home-screen that will be used for the Dealer UI. Clicking on each square takes your to the appropriate screen.

This is the “Start Game” screen which simply displays the current players in the game and the pot size in the middle.

This is the “Add /Delete Players” screen which allows you to add and remove players from the table. Clicking on a specific spot will prompt the user to provide a name for the player.

I was last working on the “Chip Color Configuration” screen which will allow the user to change the denominations for the the given chip colors (white, red, green, blue, black).

In the upcoming weeks, I plan to refine these interfaces and also complete a “Stack Size” calibration screen which will allow the Dealer to edit the stack sizes of the players in the game.

I will be more focused on refining these interfaces and making them easily integrable into the main system and the Game State Tracker.

 

This week the majority of my work was spent doing the design report. After doing our presentation, we realized a lot of our design choices were unspecified or didn’t have enough detail. For me personally, this meant specifying how  the Dealer UI and Player UI would interact with the other subsystems. So this week, I worked on writing pseudocode for the interconnections between my UI modules and the Game State Tracker.  Deciding as a team how our modules will interact with each other was a major decision we made this week. I also remedied an issue with our shipment orders for parts, so hopefully everything will be shipped by the end of this weekend.

This week began with the design presentations. I thought our presentation went very well and I enjoyed learning from other teams and the issues they face. In regards to my personal work, I’ve chosen to use a module called “Pygame” for the UI and GUI  of our game. I haven’t used this module in awhile, so this week I’ve been playing around with its features and planning out how I’m going to structure my modules for the game. I’ve been doing this on my personal laptop while I wait for my Raspberry Pi order to come in. I am also returning to Pittsburgh soon where I plan to meet up with Steve and begin working together as a “2/3” team (sorry Brandon). Looking forward to next week, and finally being able to grind out some code as a team.