source/client/Controller.py
def sharedBoardPrepAndPlay(self, visible_scards):
        """ Playing cards is a 4 step process:
         1.  Verify it's your turn.
         2.  process cards, this will set tempnumbers properly and put them in dictionary controller.processed_cards.
            in the process, some rules of runs are verified (have meld requirement, not playing on other players,
            no repeats of cards in runs, and Aces can't turn corners).
         3. Assign any ambiguous wild cards (they are wilds that end up at the ends of runs).
         4. Double check additional rules, including Liverpool specific rules.  If pass, then play the cards.
         """
        if self._state.turn_phase != Turn_Phases[3]:
            self.note = "You can only play on your turn and only after you draw"
            return
        self.processed_full_board = {}
        try:
            # calculate  self.processed_full_board
            self.processCards(visible_scards)
        except Exception as err:
            self.note = "{0}".format(err)
            # if play fails reset Aces and Wilds in prepared cards so they can be reassigned.
            self.resetPreparedWildsAces()
            return
        self.num_wilds = len(self.unassigned_wilds_dict.keys())
        if self.num_wilds > 0:
            self.note = 'Play will not complete until you designate wild cards using key strokes' \
                        ' [h for hi, l for low].'
        else:
            # final rules check, if pass, then play (will use played_cards dictionary to send update to server).
            self.play()
 Playing cards is a 4 step process:
         1.  Verify it's your turn.
         2.  process cards, this will set tempnumbers properly and put them in dictionary controller.processed_cards.
            in the process, some rules of runs are verified (have meld requirement, not playing on other players,
            no repeats of cards in runs, and Aces can't turn corners).
         3. Assign any ambiguous wild cards (they are wilds that end up at the ends of runs).
         4. Double check additional rules, including Liverpool specific rules.  If pass, then play the cards.
         
Playing cards is a 4 step process:
1.  Verify it's your turn.
2.  process cards, this will set tempnumbers properly and put them in dictionary controller.processed_cards.
in the process, some rules of runs are verified (have meld requirement, not playing on other players,
no repeats of cards in runs, and Aces can't turn corners).
3. Assign any ambiguous wild cards (they are wilds that end up at the ends of runs).
4. Double check additional rules, including Liverpool specific rules.  If pass, then play the cards.
Playing cards is a 4 step process : 1 . Verify it ' s your turn . 2 . process cards this will set tempnumbers properly and put them in dictionary controller . processed_cards . in the process some rules of runs are verified ( have meld requirement not playing on other players no repeats of cards in runs and Aces can ' t turn corners ) . 3 . Assign any ambiguous wild cards ( they are wilds that end up at the ends of runs ) . 4 . Double check additional rules including Liverpool specific rules . If pass then play the cards .
def sharedBoardPrepAndPlay(self, visible_scards):
        if self._state.turn_phase != Turn_Phases[3]:
            self.note = "You can only play on your turn and only after you draw"
            return
        self.processed_full_board = {}
        try:
            self.processCards(visible_scards)
        except Exception as err:
            self.note = "{0}".format(err)
            self.resetPreparedWildsAces()
            return
        self.num_wilds = len(self.unassigned_wilds_dict.keys())
        if self.num_wilds > 0:
            self.note = 'Play will not complete until you designate wild cards using key strokes' \
                        ' [h for hi, l for low].'
        else:
            self.play()
def sharedBoardPrepAndPlay ( self , visible_scards ) : if self . _state . turn_phase != Turn_Phases [ 3 ] : self . note = "You can only play on your turn and only after you draw" return self . processed_full_board = { } try : self . processCards ( visible_scards ) except Exception as err : self . note = "{0}" . format ( err ) self . resetPreparedWildsAces ( ) return self . num_wilds = len ( self . unassigned_wilds_dict . keys ( ) ) if self . num_wilds > 0 : self . note = 'Play will not complete until you designate wild cards using key strokes' ' [h for hi, l for low].' else : self . play ( )
Playing cards is a 4 step process:
1.
Playing cards is a 4 step process : 1 .
""" Playing cards is a 4 step process:
         1.  Verify it's your turn.
         2.  process cards, this will set tempnumbers properly and put them in dictionary controller.processed_cards.
            in the process, some rules of runs are verified (have meld requirement, not playing on other players,
            no repeats of cards in runs, and Aces can't turn corners).
         3. Assign any ambiguous wild cards (they are wilds that end up at the ends of runs).
         4. Double check additional rules, including Liverpool specific rules.  If pass, then play the cards.
         """ # calculate  self.processed_full_board # if play fails reset Aces and Wilds in prepared cards so they can be reassigned. # final rules check, if pass, then play (will use played_cards dictionary to send update to server).
self
visible_scards