void OracleImporter::httpRequestFinished(int requestId, bool error)
{
if (error) {
QMessageBox::information(0, tr("HTTP"), tr("Error."));
return;
}
if (requestId != reqId)
return;
CardSet *set = new CardSet(setsToDownload[setIndex].getShortName(), setsToDownload[setIndex].getLongName());
if (!setHash.contains(set->getShortName()))
setHash.insert(set->getShortName(), set);
buffer->seek(0);
buffer->close();
int cards = importTextSpoiler(set, buffer->data());
++setIndex;
if (setIndex == setsToDownload.size()) {
emit setIndexChanged(cards, setIndex, QString());
setIndex = -1;
} else {
downloadNextFile();
emit setIndexChanged(cards, setIndex, setsToDownload[setIndex].getLongName());
}
}
int OracleImporter::startImport()
{
clear();
int setCards = 0, setIndex= 0;
QListIterator<SetToDownload> it(allSets);
const SetToDownload * curSet;
// add an empty set for tokens
CardSet *tokenSet = new CardSet(TOKENS_SETNAME, tr("Dummy set containing tokens"), "Tokens");
sets.insert(TOKENS_SETNAME, tokenSet);
while (it.hasNext())
{
curSet = & it.next();
if(!curSet->getImport())
continue;
CardSet *set = new CardSet(curSet->getShortName(), curSet->getLongName(), curSet->getSetType(), curSet->getReleaseDate());
if (!sets.contains(set->getShortName()))
sets.insert(set->getShortName(), set);
int setCards = importTextSpoiler(set, curSet->getCards());
++setIndex;
emit setIndexChanged(setCards, setIndex, curSet->getLongName());
}
emit setIndexChanged(setCards, setIndex, QString());
// total number of sets
return setIndex;
}
void CardDatabase::loadSetsFromXml(QXmlStreamReader &xml)
{
while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement)
break;
if (xml.name() == "set") {
QString shortName, longName, setType;
QDate releaseDate;
while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement)
break;
if (xml.name() == "name")
shortName = xml.readElementText();
else if (xml.name() == "longname")
longName = xml.readElementText();
else if (xml.name() == "settype")
setType = xml.readElementText();
else if (xml.name() == "releasedate")
releaseDate = QDate::fromString(xml.readElementText(), Qt::ISODate);
}
CardSet * newSet = getSet(shortName);
newSet->setLongName(longName);
newSet->setSetType(setType);
newSet->setReleaseDate(releaseDate);
}
}
}
int OracleImporter::startImport()
{
clear();
int setCards = 0, setIndex= 0;
QListIterator<SetToDownload> it(allSets);
const SetToDownload * curSet;
while (it.hasNext())
{
curSet = & it.next();
if(!curSet->getImport())
continue;
CardSet *set = new CardSet(curSet->getShortName(), curSet->getLongName());
if (!setHash.contains(set->getShortName()))
setHash.insert(set->getShortName(), set);
int setCards = importTextSpoiler(set, curSet->getCards());
++setIndex;
emit setIndexChanged(setCards, setIndex, curSet->getLongName());
}
emit setIndexChanged(setCards, setIndex, QString());
// total number of sets
return setIndex;
}
int main(int argc, char *argv[])
{
// Setup deck of cards
CardSet deck;
for (Rank r = RANK_BEGIN; r != RANK_END; ++r) {
for (Suit s = SUIT_BEGIN; s != SUIT_END; ++s) {
Card card(r, s);
deck.insert(card);
}
}
unsigned long long count = 0;
// Test each starting hand
for (CardSet::const_iterator i = deck.begin(); i != deck.end(); ++i) {
CardSet::const_iterator j = i;
for (++j; j != deck.end(); ++j) {
string hole = Card::pairString(*i, *j);
CardSet test(deck);
Hand hand;
test.erase(*i); hand.append(*i);
test.erase(*j); hand.append(*j);
count++;
board(hole, test, hand);
}
}
cout << "TOTAL: " << count << endl;
printStats();
return 0;
}
bool Engine::setDeck(const Deck &deck)
{
if (mDeck) {
// already set
return false;
}
if (deck.empty()) {
// nothing to do with empty card set
return false;
}
if (mPlayers.size() < 2) {
// add more players
return false;
}
mDeck = new Deck(deck);
CardSet cards;
cards.insert(deck.begin(), deck.end());
std::for_each(mGameObservers.begin(), mGameObservers.end(), GameStartNotification(mDeck->trumpSuit(), mGeneratedIds, cards));
return true;
}
TEST(CardSetTest, fill)
{
using namespace pokerstove;
CardSet all;
all.fill();
EXPECT_EQ(STANDARD_DECK_SIZE, all.size());
}
bool Dealer::accept(CardSet & opened) {
Card openedRank;
if (discarded.isEmpty() && opened.isEmpty() )
return false; // regarded as "pass for empty discard pile."
if (!discarded.isEmpty() && discarded.size() != opened.size()) // the number of cards must be match. no five cards w/ Jkr allowed.
return false;
if (!checkRankUniqueness(opened))
return false;
openedRank = getCardRank(opened);
if (!discarded.isEmpty()) // 場にカードがでていないのであれば無条件に受理
if (!openedRank.isGreaterThan(discardedRank))
return false;
// passed all the checks.
discarded.makeEmpty(); //clear();
discarded.insert(opened); // discarded.insertAll(opened);
opened.makeEmpty(); //clear();
discardedRank=openedRank;
return true;
}
CardSet PokerHand::cardSet () const
{
CardSet cs;
for (uint8_t i=0; i<_ncards; i++)
cs.insert (Card(_cards[i]));
return cs;
}
CardSet pokerstove::canonizeToBoard(const CardSet& board, const CardSet& hand)
{
CardSet cboard = board.canonize();
vector<int> perms = findSuitPermutation(board, cboard);
CardSet chand = hand.rotateSuits(perms[0],perms[1],perms[2],perms[3]);
return chand;
}
void Observer::cardsPickedUp(const PlayerId *playerId, const CardSet &cardSet)
{
mPlayersCards[playerId] += cardSet.size();
CardSet& set = mCurrentRoundData->mPickedUpCards[playerId];
unsigned int oldSize = set.size();
set.insert(cardSet.begin(), cardSet.end());
assert(oldSize + cardSet.size() == set.size());
}
CardSet PokerHand::cardSet (size_t first, size_t len) const
{
CardSet cs;
size_t last = min(first+len, static_cast<size_t>(_ncards));
for (size_t i=first; i<last; i++)
cs.insert (_cards[i]);
return cs;
}
CardSet CardSet::canonize(const CardSet& other) const
{
CardSet cother = other.canonize();
vector<int> perms = findSuitPermutation(other, cother);
CardSet hand = *this;
CardSet chand = hand.rotateSuits(perms[0],perms[1],perms[2],perms[3]);
return chand;
}
bool Engine::findByPtr(const CardSet& cards, const Card* card)
{
for (CardSet::const_iterator it = cards.begin(); it != cards.end(); ++it) {
if (&*it == card) {
return true;
}
}
return false;
}
void SetList::enableAll()
{
for (int i = 0; i < size(); ++i)
{
CardSet *set = at(i);
set->setIsKnown(true);
set->setEnabled(true);
}
}
void SetList::markAllAsKnown()
{
for (int i = 0; i < size(); ++i)
{
CardSet *set = at(i);
if(!set->getIsKnown())
{
set->setIsKnown(true);
}
}
}
int SetList::getUnknownSetsNum()
{
int num=0;
for (int i = 0; i < size(); ++i)
{
CardSet *set = at(i);
if(!set->getIsKnown())
++num;
}
return num;
}
int SetList::getEnabledSetsNum()
{
int num=0;
for (int i = 0; i < size(); ++i)
{
CardSet *set = at(i);
if(set->getEnabled())
++num;
}
return num;
}
void Observer::cardsDropped(const PlayerId *playerId, const CardSet &cardSet)
{
mPlayersCards[playerId] -= cardSet.size();
if (mCurrentRoundData->mDroppedCards.find(playerId) == mCurrentRoundData->mDroppedCards.end()) {
mCurrentRoundData->mDroppedCards[playerId] = CardSet();
}
CardSet& set = mCurrentRoundData->mDroppedCards[playerId];
unsigned int oldSize = set.size();
set.insert(cardSet.begin(), cardSet.end());
assert(oldSize + cardSet.size() == set.size());
}
QVariant SetsModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || (index.column() >= 2) || (index.row() >= rowCount()) || (role != Qt::DisplayRole))
return QVariant();
CardSet *set = sets[index.row()];
switch (index.column()) {
case 0: return set->getShortName();
case 1: return set->getLongName();
default: return QVariant();
}
}
bool Dealer::checkRankUniqueness(CardSet & cs) {
int j = 0;
if (cs.size() == 0)
return false;
if (cs[j].isJoker())
j++;
for (int i = j+1; i < cs.size(); i++) {
if (cs[i].isJoker()){continue;} // 追加：途中にJkrを許す
if (cs[j].getNumber() != cs[i].getNumber() )
return false;
}
return true;
}
CardSet* Rules::getLegalCards(MatchState& iMatchState, const CardSet& iCardSet)
{
if (iMatchState.isFirstRound())
{
return (CardSet*)&iCardSet;
}
CardSet* legalCardSet = iCardSet.getCardsBySuit(iMatchState._masterSuit);
//cout << "legal cards: " << endl;
//UserInterface::showPlayerCards(*legalCardSet);
if(legalCardSet->size() == 0)
return (CardSet*)&iCardSet;
else
return legalCardSet;
}
void SetList::guessSortKeys()
{
// sort by release date DESC; invalid dates to the bottom.
QDate distantFuture(2050, 1, 1);
int aHundredYears = 36500;
for (int i = 0; i < size(); ++i)
{
CardSet *set = at(i);
QDate date = set->getReleaseDate();
if(date.isNull())
set->setSortKey(aHundredYears);
else
set->setSortKey(date.daysTo(distantFuture));
}
}
bool LittleThinkPlayer::follow(const GameState & gstat, CardSet & s) {
CardSet pile(gstat.pile);
Card tmp;
std::cout << gstat << std::endl;
s.makeEmpty(); //clear();
sortInHand();
std::cout << "( " << inHand() << " )" << std::endl;
inHand().pickup(tmp, -1); // とにかく選ぶ．
s.insert(tmp);
// the card idential to tmp is already removed from the hand.
// cardSetOfSameRanks(s, pile.size());
// たとえば、複数枚のカードを探す関数。ただしこの関数は未実装。
// 現状ではこの follow は Player.cc のものと等価
return true;
}
void board(const string& hole, const CardSet& deck, const Hand& hand)
{
HandStats s = stats[hole];
for (CardSet::const_iterator i = deck.begin(); i != deck.end(); ++i) {
CardSet::const_iterator j = i;
for (++j; j != deck.end(); ++j) {
CardSet::const_iterator k = j;
for (++k; k != deck.end(); ++k) {
s.count++;
s.outs[ board_rank(hand, *i, *j, *k) ]++;
}
}
}
stats[hole] = s;
}
std::set<CardSet>
expandRankSet(size_t numCards)
{
combinations cards(52,numCards);
do
{
CardSet hand;
for (size_t i=0; i<num_cards; i++)
{
hand.insert (Card(cards[i]));
}
collection.insert(hand.canonize());
rankHands[hand.rankstr()] = hand.rankColex();
}
while (cards.next());
}
int Evaluator::getHandRank(const CardSet& hand) {
if (hand.ToCards().size() < 5 || hand.ToCards().size() > 7) {
return 0;
}
int rank = Card::MAX_ID + 1;
for (auto card : hand.ToCards()) {
rank = handRanks[rank + card.id()];
}
if (hand.ToCards().size() != 7) {
rank = handRanks[rank];
}
return rank;
}
QString PictureLoader::getPicUrl(CardInfo *card)
{
if (!picDownload) return QString("");
CardSet *set = card->getPreferredSet();
QString picUrl = QString("");
// if sets have been defined for the card, they can contain custom picUrls
if(set)
{
// first check if Hq is enabled and a custom Hq card url exists in cards.xml
if(picDownloadHq)
{
picUrl = card->getCustomPicURLHq(set->getShortName());
if (!picUrl.isEmpty())
return picUrl;
}
// then, test for a custom, non-Hq card url in cards.xml
picUrl = card->getCustomPicURL(set->getShortName());
if (!picUrl.isEmpty())
return picUrl;
}
// otherwise, fallback to the default url
picUrl = picDownloadHq ? settingsCache->getPicUrlHq() : settingsCache->getPicUrl();
picUrl.replace("!name!", QUrl::toPercentEncoding(card->getCorrectedName()));
if (set) {
picUrl.replace("!setcode!", QUrl::toPercentEncoding(set->getShortName()));
picUrl.replace("!setname!", QUrl::toPercentEncoding(set->getLongName()));
}
int muid = card->getPreferredMuId();
if (muid)
picUrl.replace("!cardid!", QUrl::toPercentEncoding(QString::number(muid)));
if (picUrl.contains("!name!") ||
picUrl.contains("!setcode!") ||
picUrl.contains("!setname!") ||
picUrl.contains("!cardid!")) {
qDebug() << "Insufficient card data to download" << card->getName() << "Url:" << picUrl;
return QString("");
}
return picUrl;
}
// This one is not fully optimized
PokerEvaluation CardSet::evaluateRanksLow2to7() const
{
PokerEvaluation high;
PokerEvaluation h;
// if there are five or fewer cards, we just evaluate the high,
// fix the wheel, and take the complement
switch (size())
{
case 0:
case 1:
case 2:
case 3:
case 4:
high = evaluateHighRanks();
break;
case 5:
high = evaluateHighRanks();
high.fixWheel2to7(rankMask());
break;
default:
// this is a slow way to handle the general case.
// TODO: specialize the code for the 6 and 7 card cases.
vector<Card> cards = this->cards();
combinations combo(size(), FULL_HAND_SIZE);
PokerEvaluation best;
do
{
CardSet candidate;
for (size_t i=0; i<static_cast<size_t>(FULL_HAND_SIZE); i++)
candidate.insert(cards[combo[i]]);
PokerEvaluation e = candidate.evaluateRanksLow2to7();
if (e > best)
best = e;
}
while (combo.next());
return best;
}
high.flip();
return high;
}
void World::distributeCards()
{
unsigned int cardsForOnePlayer = m_deck.size() / m_players.size();
if (m_deck.size() % m_players.size() != 0)
{
std::cerr << "Attention : le nombre de cartes (" << m_deck.size() << ") devrait etre divisible par le nombre de joueurs (" << m_players.size() << ")" << std::endl;
throw "Le nombre de cartes n'est pas divisible par le nombre de joueurs";
}
for (unsigned int i = 0; i < m_players.size(); i++)
{
CardSet hand;
for (unsigned int j = 0; j<cardsForOnePlayer; j++)
{
hand.push_back(m_deck.at(i*cardsForOnePlayer + j));
}
m_players.at(i)->setHand(hand);
}
}
