def newTilePositions(self):
"""returns list(TileAttr) for all tiles except bonus tiles.
The tiles are not associated to any board."""
result = list()
isScoringGame = self.player.game.isScoringGame()
newUpperMelds = list(self.player.exposedMelds)
if isScoringGame:
newLowerMelds = list(self.player.concealedMelds)
else:
if self.player.concealedMelds:
newLowerMelds = sorted(self.player.concealedMelds, key=meldKey)
else:
tileStr = 'R' + ''.join(self.player.concealedTileNames)
handStr = ' '.join([tileStr, self.player.mjString()])
content = Hand.cached(self.player, handStr)
newLowerMelds = list(Meld(x) for x in content.sortedMeldsContent.split())
if newLowerMelds:
if self.rearrangeMelds:
if newLowerMelds[0].pairs[0] == 'Xy':
newLowerMelds = sorted(newLowerMelds, key=len, reverse=True)
else:
# generate one meld with all sorted tiles
newLowerMelds = [Meld(sorted(sum((x.pairs for x in newLowerMelds), []), key=elementKey))]
for yPos, melds in ((0, newUpperMelds), (self.lowerY, newLowerMelds)):
meldDistance = self.concealedMeldDistance if yPos else self.exposedMeldDistance
meldX = 0
for meld in melds:
for idx in range(len(meld)):
result.append(TileAttr(self, meld, idx, meldX, yPos))
meldX += 1
meldX += meldDistance
return sorted(result, key=lambda x: x.yoffset * 100 + x.xoffset)
def computeHand(self, withTile=None, robbedTile=None, singleRule=None, asWinner=False):
"""returns a Hand object, using a cache"""
game = self.game
if not game.isScoringGame():
# maybe we need a more extended class hierarchy for Player, VisiblePlayer, ScoringPlayer,
# PlayingPlayer but not now. Just make sure that ExplainView can always call the
# same computeHand regardless of the game type
return Player.computeHand(self, withTile=withTile, robbedTile=robbedTile, asWinner=asWinner)
if not self.handBoard:
return None
string = ' '.join([self.scoringString(), self.__mjstring(singleRule, asWinner), self.__lastString(asWinner)])
return Hand.cached(self, string, computedRules=singleRule)
def computeHand(self, withTile=None, robbedTile=None, dummy=None, asWinner=False):
"""returns Hand for this player"""
assert not (self._concealedMelds and self.__concealedTileNames)
assert not isinstance(self.lastTile, Tile)
assert not isinstance(withTile, Tile)
melds = ['R' + ''.join(self.__concealedTileNames)]
if withTile:
melds[0] += withTile
melds.extend(x.joined for x in self._exposedMelds)
melds.extend(x.joined for x in self._concealedMelds)
melds.extend(''.join(x.element) for x in self.__bonusTiles)
mjString = self.mjString(asWinner)
melds.append(mjString)
if mjString.startswith('M') and (withTile or self.lastTile):
melds.append('L%s%s' % (withTile or self.lastTile, self.lastMeld.joined))
return Hand.cached(self, ' '.join(melds), robbedTile=robbedTile)
def computeHand(self,
withTile=None,
robbedTile=None,
singleRule=None,
asWinner=False):
"""returns a Hand object, using a cache"""
game = self.game
if not game.isScoringGame():
# maybe we need a more extended class hierarchy for Player, VisiblePlayer, ScoringPlayer,
# PlayingPlayer but not now. Just make sure that ExplainView can always call the
# same computeHand regardless of the game type
return Player.computeHand(self,
withTile=withTile,
robbedTile=robbedTile,
asWinner=asWinner)
if not self.handBoard:
return None
string = ' '.join([
self.scoringString(),
self.__mjstring(singleRule, asWinner),
self.__lastString(asWinner)
])
return Hand.cached(self, string, computedRules=singleRule)
