Python OF Fortune!

Wheel of Fortune - Python Style

CST205: Final Project

Brian Begun * Wendy Gray * Christopher Dixon * William Gillihan

- Press play to start the presentation -

 Project Objective
Primary Element: Develop interactive game play.

Secondary Element: Modify and utilize sound with in the game.

Includes: synthesized game sounds, and sound dialog from
movies.

Tertiary Element: Load image and display to player if they

win.
 Game Objective
Python OF Fortune: is a game based on the classic television
game show Wheel of Fortune.

The Goal: Solve a puzzle one letter at a time.

The Theme: Famous movie quotes.

You Win! If you can complete the puzzle.

You Lose! If you run out of money before you can complete
the puzzle.
 How To Play
Initial Amount: Player starts with $1000

Spin The Wheel: No real wheel here. Instead random dollar

amounts between $100 and $1000 tick up the screen. The
amount that finishes the spin is the value of the players
letter guess.

Guess A Correct Letter: Player is rewarded spin amount for

every instance of the letter.

Guess A Wrong Letter: Player is penalized spin amount for a

wrong guess.
 Python Of Fortune vs. Wheel Of Fortune
Command Line Television Show
Random Text Function() With Sound Tones Real Wheel Spinning
Guess A Letter Guess A Letter
Correct Guess = More Money $$$ Correct Guess = More Money $$$
Wrong Guess = You Lose Money $$$ Wrong Guess = You Lose Money $$$
Play Completed Words of Dialog Puzzle Not Available
Run Out Of Money = You Lose! Run Out Of Money = You Lose!
Finish The Puzzle = You Win The Game! Finish The Puzzle = You Win The Game!
Our Approach
 Our Approach
Brainstorm
Narrow down ideas
Finalize idea
Breakdown process
Pseudo code the process
List out all necessary assets
Distribute project development to group members
Meet and review work in progress
Integrate parts of code back into project
Debug and debug AGAIN!
 Our Approach
Brainstorm: We threw out several ideas that would allow us
to combine the three requirements: Sound or image
manipulation, and a strategy game.

Narrow Down Ideas: Our list quickly reduced to something

using the game show Wheel of Fortune as the base.

Finalize Idea: To include the other two elements, we combined

the concept of the game show with sound manipulation. Using
movie dialog seemed to be the most straight-forward theme for
the game.
 Our Approach
Breakdown Process: We detailed how the game would work.
1. Player choice menu
2. Load game sound file.
3. Have one master dialog file to play back the puzzles.
4. Spin the wheel
a. Generate random numbers (in currency formatting).
b. Display random numbers with sound effects to simulate spin.
5. Create in-game sound effects using python sound generation.
6. Ability to play parts of the dialog that the player had completed
(only when words were completed).
7. Reward/penalize player for correct/wrong guesses.
8. Display movie poster if the player completes the puzzle.
9. Display correct guesses in line with dashes to represent yet to be
guessed letters (just like hangman project).
 Our Approach
Pseudo Process: Using pseudo code, we described how the game
process would work.

def playSound(phraseState): def spinWheel():

for word in phraseState: ranDollars = random.int()
wordComplete = true x = 0
for letter in word: play(start spin sound)
if letter == _ while x < 10:
wordComplete = false print random.int()
if wordComplete == true x += 1
play section of dialogClip at print \n
normal volume print \n
else play(ding finish spin sound)
play section of dialogClip at 0 print ranDollars #End of spin
volume dollar amount for user
return ranDollars
 Our Approach
List out all necessary assets:
Game Sounds
Spinning sound

Final result [Wheelspin]

Wrong answer (Buzz)

Right answer (Ding Ding Ding)

Congrats you won! (Ta DA!)

You lost (DA Da da)

Dialog file (game puzzles)

Movie posters
 Our Approach
Distribute Project Development To Group Members:
Wendy: exeGuess() - Execute guess function. Process players guess and act on if right/wrong
guess.

Bill: printPhrase() - Grabs puzzle text, and parses it into single letters and dashes, depending
upon Wendys exeGuess().
spinWheel() - Generate random numbers (currency formatting). Print to screen with spinning wheel
sound each time. Return final result: Value of players guess.
In game sound effects - Build functions to play synthesized game sounds.

Chris: playSound() - Parses out dialog sound file and plays back only words that player completes,
using pre-defined sample indexes.

Brian: pythonOfFortune() and userMenu() - Main functions to execute game and player option menu.
Build game dialog sound file and index words - Cut three movie dialogs together into one file.
Idendify and list start and end sample indexes for every word in all dialog.
 Our Approach
Meet And Review Work In Progress: After working separately on our
individual responsibilities, we met as a group, discussed our
progress, and made some tweaks to our workflow when necessary.

Integrate Parts Of Code Back Into Project: As are code parts were
coming together, we would upload them to gitHub into our master game
file.

Debug and Debug AGAIN!: While this may seem pretty obvious, we
would run our game with as many scenarios as we could think of to
see where it may break.
 Results - The Home Stretch!
Finalized our concept

Worked out game flow

Conceptualized code (pseudo code)

Divided up the workload to each group member

Re-integrate all members code back into the game.

Debug

Debug Again!
Python of Fortune - Demonstration
 Start the game: pythonOfFortune()

Demo
When starting the game, the player
must first select the /assets
folder, which contains the image and
sound assets.

The initial amount to play with is:

$1000
NOTE: Because we are using an old version of python (ver 2.2).
We cannot set relative path ahead of time.
 Main menu and player options:

Demo
Type one of the following options:

spin - spin the wheel and guess a letter.

play sound - play the completed part of
the puzzle.
exit - type at anytime to quit the game.
 Lets spin the wheel!

Demo
Our version of a wheel spin is to
print random dollar values one at a
time with a click sound in-between
to simulate the wheel hitting marks
(just like the television show!).

We hit $240.
 Time to guess a letter:

Demo
Please guess a letter: a

Wow! We got 4 as!

Since our spin resulted in $240, our
reward for choosing correctly is
$240 x 4 = $960.

Our current total is: $1960

 Were feeling lucky, after our
next spin, lets pick another
letter...bummer wrong guess this
time:

Demo
The player spins again. This time the
result is: $130

Please guess a letter: f

Your guess was wrong!

Bummer. Because we guessed wrong, $130

was subtracted from our running total of
$1960. Our new total is now: $1830
 We completed a word, we can now
play some of the dialog!

Demo
After the player completes at least one
word from the puzzle, he/she can now
play sound to hear that part of the
dialog. As the player completes more
words, the play sound function will
play those parts of the dialog. If they
complete the puzzle, they can hear the
entire phrase. Then YOU WIN!!!!
 Wendy: Project Responsibilities
In this project, it was my responsibility to create the
following functionality:
Initialize the game by randomly picking from a database of
quotes and assigning variables accordingly
Evaluate a guessed letter by checking for whether itd been
already guessed, existence in quote and number of
occurrences, and reward or deduct money accordingly.
Check for game win/loss and play appropriate sounds.
Upon win, display an image taken from the quotes movie
with the title and quote displayed on it.
 Bill: Project Responsibilities
In this project, it was my responsibility to create the
following functionality:
Write function that loads phrase into a sentence list of
word lists and returns it along with a matching list of
blanks with non alpha characters left intact
Function to grab puzzle text, and parse it into sentence
and/or dash form, used by Wendys execute guess function.
Function to generate random numbers and simulate player
spinning wheel and return amount player is playing for.
Functions for in-game sound effects (e.g. wheelspin,
correct guess, incorrect guess, win, lose)
 Chris: Project Responsibilities
In this project, it was my responsibility to create the
following functionality:
I created the playSound() function. My function takes the
phrase in its current state and plays the section of the
audio clip where the word has been completed. It does this
by traversing each letter of each word in the list. If an
underscore exists in place of a letter, the word is not
complete and playSound() will not play that section of the
sound. I also added a list of the start and end sample
indices for the playSound() function to know where to find
the audio for each word.
 Brian: Project Responsibilities
In this project, it was my responsibility to create the
following functionality:
Cut all movie dialog together into one file

Index all samples for start & end of each word in dialog

Build pythonOfFortune() introduction function

Build userMenu() function, which calls all other game

functions.

Build and organize power point (google slides)

presentation.
 Wendy: What I learned In CST205
The Top Three Things I Learned in this Course:

Good tools to communicate and collaborate are critical for

multi-person coding (i.e. gitHub, Google Docs & Hangouts,
collabedit.com)

Choosing the best IDE is very important to avoid

limitations in coding; JES had some problems that
hindered some project development.

Efficiently planning your code, including psuedocoding,

will greatly decrease the amount of time spent debugging
 Bill: What I learned In CST205
The Top Three Things I Learned in this Course:

Pair Programming enables greater creativity, and cleaner

code in Software Development.

Large projects are simplified through following a top-down

process, and use of pseudocode during the design process.

Debugging is an integral part of any project, and should be

done as frequently as possible
 Chris: What I learned In CST205
The Top Three Things I Learned in this Course:

Group projects can quickly become very complicated and

challenging to debug. Good planning and organization are
essential to make the program work correctly.

Other group members can bring a lot of talent to a project

in unexpected ways. I was impressed with the other
members expertise on all of our collaborations.

You can make huge changes on multimedia files with just a

few lines of code. The projects were very fun to work
on.
 Brian: What I learned In CST205
The Top Three Things I Learned in this Course:

Developing program workflow (using pseudo code) is an

important step, and can reduce or eliminate code
integration down the road.

Better understanding on how to manipulate sound and image

data using python.

Good collaboration and communication are critical to a

teams ultimate success.
 Python OF Fortune!
Wheel of Fortune - Python Style

CST205: Final Project

Brian Begun * Wendy Gray * Christopher Dixon * William Gillihan