Python project

    Im copying the description,

    Introduction
    The game of Yacht (also known as Yot, and commercially marketed as
    Yahtzee) is a game played with 5 dice. It is quite similar to the poker dice
    program that is presented in the textbook, but with a more sophisticated
    scoring system that makes it much more interesting to play. You can read
    about the game in excruciating detail in this wikipedia entry: Yahtzee.
    Our game will implement the “classic rules” that ignore things like yacht
    bonuses and jokers. In my opinion, this actually makes it a more strategic,
    skill-oriented game that is quite fun to play.

    Rules
    The game is played with 5 dice and proceeds in a series of 13 rounds. In
    each round, the player starts by rolling all 5 dice. The player can then
    choose some dice to re-roll up to a total of 3 rolls. In this respect, it is
    exactly like the dice poker in Chapter 12.
    After any roll (1, 2 or 3) the player can choose to score the dice, which
    ends the round. Scoring is done by selecting which category on the
    scorecard to fill in. The key is to make good choices. The player must
    choose a category for the round, even if the score for that category ends
    up being 0. One category is filled in each of the 13 rounds.
    The scoring categories and the points scored are as follows:
    Category Description / Points Scored
    ones 1 point for each 1 thrown
    twos 2 points for each 2 thrown
    threes 3 points for each 3 thrown
    fours 4 points for each 4 thrown
    fives 5 points for each 5 thrown
    sixes 6 points for each 6 thrown
    3 of a Kind 3 of the same number. Scores the sum of the dice.
    4 of a Kind 4 of the same number. Scores the sum of the dice.
    Full House A 3-of-a-kind and 2-of-a-kind. Scores 25 points
    Category Description / Points Scored
    Small Straight 4 numbers in a row (any order). Scores 30 points
    Big Straight 5 numbers in a row (any order). Scores 40 points
    Yacht 5 of a kind. Scores 50 points
    Chance No pattern needed. Scores the sum of the dice.
    Bonus: If the “upper total” (the sum of the first six categories) is 63 or
    above, then an additional 35 points is awarded.
    The goal is to maximize the total points.

    Program Modules
    Starter code for the project can by found on our class web page under
    handouts/yacht. There are 5 files:
    dice.py: This file is a complete implementation of a Dice class. It is
    just like the one in Chapter 12, but with the scoring method
    removed, since scoring in Yacht is quite different.
    yachtscore.py: This file contains class outlines for the objects that
    will be responsible for handling scoring. The main class is the
    ScoreCard that keeps track of the scoring as the game progresses.
    yachtapp.py: This is a minimal outline for the top-level class that
    will actually “play” the game. This corresponds to the PokerApp in the
    dice poker example. Note, as in the PokerApp, the actual user
    interface is separated from the application logic. This file can be
    used with either a text-based or a graphics-based interface.
    yachttext.py: This is a complete implementation of a very primitive
    text-based interface for the game. This is analogous to the
    textpoker.py file in the Poker example.
    yachgui.py: This is the bare outline of the graphical interface for
    the final game. This, combined with yachtapp.py, produces a fullfledged
    graphical Yacht game.
    In addition to these files, you will undoubtedly also want to make use of
    the button.py and cdieview.py files from the Poker app when you get around
    to completing the GUI portion of the project.

    Project Phases
    The work of the project will be completed and delivered in 4 phases.
    These phases represent the C, B, A, and A+ levels of the project. Your
    work is due on the last day of the term (at noon), but you must do the
    phases in order. For example, I won’t grade a phase 2 project if you
    haven’t turned in a sucessful phase 1 project. That means you should get
    started right away and turn in each phase as soon as possible.

    Phase 1 (C level): Scorers
    In this phase you are to write and test 5 scorer classes.
    In the yachtscore.py file you will find a class for a ScoreCard as well as 5
    classes that perform the different kinds of scoring that are needed. These
    5 helper classes are the “scorers.” Each scorer has a constructor and a
    single score(dice) method. The score method returns the number of points
    that the dice would be awarded by this particular scorer.
    Let’s take a concrete example. The top 6 categories in the score card (the
    ones, twos, threes, etc.) are handled with the ValueScorer class. For the
    ones catagory, we would create a ValueScorer for ones like this:
    ones = ValueScorer(1)
    Then, when we want to see how much some dice would score in that
    category, we call the score method:
    ones.score([1, 3, 4, 5, 1])
    That should return 2 (the sum of the 1’s in the list).
    Each of the scorer classes has a detailed docstring that explains the
    scorer and also shows some interactive examples. You have completed
    phase 1 when you have manually tested each of your scorer classes and
    they work as indicated in the docstrings.

    Phase 2 (B level): ScoreCard
    In this phase you will write and test the ScoreCard class. Consult the
    documentation in the yachtscore.py file to learn exactly what the various
    methods of the class do.
    It is important that you test the scorcard to make sure that it works
    properly. The testing function at the bottom of the file should be filled in
    to do this. The completee program for this phase should read dice rolls
    from a file and fill the resulting scores into the scorecard. Each line of the
    file consists of 5 dice values separated by spaces. The first set should be
    scored into catagory 0, the next into category 1, etc. The program should
    print out the updated scorecard each time a line of the file is read. You
    can use the printScorecard function from the yachttext.py file to print the
    scorecard.
    In the starter code directory you can find a file called maxrolls.txt that
    contains the roles that should give you the highest possible score for you
    test. Try your test program using this file for the input.

    Phase 3 (A level): YachtApp
    In this phase you should complete the yachtapp.py file. Start by looking at
    the interface methods that have been implemented in the yachtext.py file.
    All of your user interaction must be handled by calling on these methods.
    The YachtApp class will take care of creating and running the game. It will
    need to store the interface, dice, and scorecard as instance variables.

    Phase 4 (A+ level): YachtGui
    Create a complete graphical game by completing yachtgui.py. The exact
    form of the interface is up to you. I would suggest starting with the Poker
    app as a model and adding a graphical scorecard below it. In addition to
    the buttons on the original poker game, you will want a button for each
    scoring category. After the 3rd roll or when the user clicks the score
    button, they should then be prompted to click a category to score.
    A nice interface will make sure that only the buttons that are currently
    available are active.

    Grading
    Since this is a more substantial project and delivered in phases, it is
    worth 30 points. Most of the points will be determined by what phases
    you complete. Good style is still appreciated, and will get you to a higher
    level of the grade you earn. So a working phase 2 is some flavor of B. A

                                                                                                                                      Order Now