void KDeckDefStatic::Init(System::File::KTabFile2* fileReader)
{
char buf[1024];
fileReader->GetInteger("ID", 0, (int*)&m_Id);
fileReader->GetInteger("HeroID", 0, (int*)&m_heroID);
fileReader->GetInteger("HeroHp", 0, (int*)&m_heroHp);
fileReader->GetInteger("Res", 0, (int*)&m_res);
fileReader->GetInteger("Rnd", 0, (int*)&m_rnd);
fileReader->GetInteger("HeroStrong", 0, (int*)&m_heroStrong);
fileReader->GetInteger("ResLucky", 0, (int*)&m_resLucky);
fileReader->GetInteger("HeroLucky", 0, (int*)&m_heroLucky);
fileReader->GetInteger("Fate", 0, (int*)&m_fate);
fileReader->GetString("DECK", "", buf, 1023);
setDeck(buf);
fileReader->GetInteger("DrawNum", 0, (int*)&m_drawNum);
fileReader->GetString("HeroSkill", "", buf, 1023);
setHeroSkill(buf);
fileReader->GetString("Dynamic", "", buf, 1023);
setDynamic(buf);
}
void WndDeckEditor::actLoadDeckFromClipboard()
{
if (!confirmClose())
return;
DlgLoadDeckFromClipboard dlg;
if (!dlg.exec())
return;
setDeck(dlg.getDeckList());
setWindowModified(true);
}
void RDPanelButton::reset()
{
if(button_length[button_hook_mode]>0) {
setActiveLength(button_length[button_hook_mode]);
}
else {
setActiveLength(button_length[0]);
}
button_start_time=QTime();
button_end_time=QTime();
setColor(button_default_color);
if(button_cart!=0) {
WriteKeycap(-1);
}
setDeck(-1);
button_play_deck=NULL;
}
void WndDeckEditor::actLoadDeck()
{
if (!confirmClose())
return;
QFileDialog dialog(this, tr("Load deck"));
dialog.setDirectory(settingsCache->getDeckPath());
dialog.setNameFilters(DeckList::fileNameFilters);
if (!dialog.exec())
return;
QString fileName = dialog.selectedFiles().at(0);
DeckList::FileFormat fmt = DeckList::getFormatFromNameFilter(dialog.selectedNameFilter());
DeckList *l = new DeckList;
if (l->loadFromFile(fileName, fmt))
setDeck(l, fileName, fmt);
else
delete l;
}
int main (){
int seed = 1000;
int r,i;
int result = 0;
bool pass = true;
int p=0;
int handPos;
int k[10] = { adventurer, council_room, feast, gardens, mine
, remodel, smithy, village, baron, great_hall };
struct gameState G;
printf("TESTING VILLAGE CARD\n");
for(p=0; p<MAX_PLAYERS; p++){
switch(p){
case 0:
printf("Testing for village card at index 0 of hand\n");
break;
case 1:
printf("Testing for village card at last index of hand\n");
break;
case 2:
printf("Normal testing mode\n");
break;
case 3:
printf("Normal testing mode\n");
break;
}
memset(&G, 23, sizeof(struct gameState)); // clear the game state
r = initializeGame(MAX_PLAYERS, k, seed, &G); // initialize a new game
//set deck for each player
setDeck(&G);
//change each player's hand, with at least 1 village card
setHand(&G);
//set handpos of village card
for(i=0; i< G.handCount[p]; i++){
if(G.hand[p][i] == village){
handPos = i;
}
}
result = checkVillage(p, &G, handPos);
if (result == -1){
pass = false;
}
if (pass == true){
printf("ALL TESTS PASSED!\n");
}else{
printf("FAILURES\n");
}
}
return 0;
}
void Engine::init(DataReader& reader, const std::vector<Player*> players, const std::vector<GameObserver*>& observers)
{
// check that engine is not initialized yet
assert(!mPlayerIdCounter);
assert(mGeneratedIds.empty());
assert(mPlayers.empty());
assert(!mDeck);
assert(mGameObservers.empty());
// read players count
std::vector<const PlayerId*>::size_type playersCount;
reader.read(playersCount);
assert(players.size() == playersCount);
// add players
for (std::vector<Player*>::const_iterator it = players.begin(); it != players.end(); ++it) {
add(**it);
}
const Card defaultCard(SUIT_LAST, RANK_LAST);
// read each player cards
for (std::vector<const PlayerId*>::const_iterator it = mGeneratedIds.begin(); it != mGeneratedIds.end(); ++it) {
CardSet& playerCards = mPlayersCards[*it];
assert(playerCards.empty());
reader.read(playerCards, defaultCard);
mPlayers[*it]->cardsRestored(playerCards);
}
// read deck
Deck deck;
reader.read(deck, defaultCard);
Suit trumpSuit;
reader.read(trumpSuit);
deck.setTrumpSuit(trumpSuit);
setDeck(deck);
// read current player index
unsigned int currentPlayerindex;
reader.read(currentPlayerindex);
mCurrentPlayer = mGeneratedIds[currentPlayerindex];
// read current round index
reader.read(mRoundIndex);
bool roundRunning;
reader.read(roundRunning);
if (roundRunning) {
mCurrentRoundIndex = &mRoundIndex;
// read current round data
std::vector<const PlayerId*>::size_type attackersAmount;
reader.read(attackersAmount);
while (attackersAmount--) {
unsigned int attackerIndex;
reader.read(attackerIndex);
mAttackers.push_back(mGeneratedIds[attackerIndex]);
}
unsigned int defenderIndex;
reader.read(defenderIndex);
mDefender = mGeneratedIds[defenderIndex];
reader.read(mPassedCounter);
unsigned int currentRoundAttackerIndex;
reader.read(currentRoundAttackerIndex);
mCurrentRoundAttackerId = mGeneratedIds[currentRoundAttackerIndex];
std::vector<Card> attackCards;
reader.read(attackCards, defaultCard);
for (std::vector<Card>::iterator it = attackCards.begin(); it != attackCards.end(); ++it) {
mTableCards.addAttackCard(*it);
}
std::vector<Card> defendCards;
reader.read(defendCards, defaultCard);
for (std::vector<Card>::iterator it = defendCards.begin(); it != defendCards.end(); ++it) {
mTableCards.addDefendCard(*it);
}
reader.read(mMaxAttackCards);
reader.read(mDefendFailed);
mPickAttackCardFromTable = !mDefendFailed && attackCards.size() == defendCards.size() + 1;
}
// append observers
mGameObservers.insert(mGameObservers.end(), observers.begin(), observers.end());
std::map<const PlayerId*, unsigned int> playersCards;
for (PlayerIds::const_iterator it = mGeneratedIds.begin(); it != mGeneratedIds.end(); ++it) {
playersCards[*it] = mPlayersCards[*it].size();
}
std::for_each(mGameObservers.begin(), mGameObservers.end(), GameRestoredNotification(mGeneratedIds, playersCards, mDeck->size(), mDeck->trumpSuit(), mTableCards));
// initialize observers
unsigned int savedObservers;
reader.read(savedObservers);
assert(savedObservers == mGameObservers.size());
for (std::vector<GameObserver*>::iterator it = mGameObservers.begin(); it != mGameObservers.end(); ++it) {
unsigned int observerDataStart = reader.position();
(*it)->init(reader);
unsigned int actualObserverDataSize = reader.position() - observerDataStart;
unsigned int expectedObserverDataSize;
reader.read(expectedObserverDataSize);
assert(actualObserverDataSize == expectedObserverDataSize);
}
}
Char::Char( CATEGORY cat, Vec2 lc, TileDeck *dk, Layer *tgtlayer, int client_id, int internal_id ) : Prop2D(), category(cat), clean_at(0), client_id(client_id), internal_id(internal_id) {
setScl(24,24);
setDeck(dk);
setLoc(lc);
tgtlayer->insertProp(this);
}
Particle(TileDeck *dk) : Prop2D() {
setDeck(dk);
setScl(32);
setIndex(0);
v = Vec2( range(-100,100), range(-100,100) );
}
int main (){
int seed = 1000;
int numPlayer = 2;
int flag; //0=no cards in deck,
int r;
int result = 0;
bool pass = true;
int p=0;
int k[10] = { adventurer, council_room, feast, gardens, mine
, remodel, smithy, village, baron, great_hall };
struct gameState G;
memset(&G, 23, sizeof(struct gameState)); // clear the game state
r = initializeGame(numPlayer, k, seed, &G); // initialize a new game
printf("TESTING DRAW CARD\n");
for(p=0; p<numPlayer; p++){
printf("Testing for player %d\n", p+1);
/*EDGE CASES*/
//CHECK for 0 cards in deck
printf("Testing for no cards in deck\n");
flag = 0;
G.deckCount[p] = 0;
setDiscardDeck(p, &G);
result = checkDrawCard(p, &G, flag);
if (result == -1){
pass = false;
}
//check for neg cards in deck
printf("Testing for neg cards in deck\n");
flag = 0;
G.deckCount[p] = -5;
setDiscardDeck(p, &G);
result = checkDrawCard(p, &G, flag);
if (result == -1){
pass = false;
}
//testing for max cards in deck
printf("Testing for max cards in deck\n");
flag = 1;
G.deckCount[p] = MAX_DECK;
setDeck(p, &G);
result = checkDrawCard(p, &G, flag);
if (result == -1){
pass = false;
}
/**NORMAL CASES**/
printf("Testing for 10 cards in deck\n");
flag = 1;
G.deckCount[p] = 10;
setDiscardDeck(p, &G);
result = checkDrawCard(p, &G, flag);
if (result == -1){
pass = false;
}
//check for 0 cards in hand
printf("Testing for 0 cards in hand\n");
flag = 1;
G.deckCount[p] = 10;
G.handCount[p] =0;
setDiscardDeck(p, &G);
result = checkDrawCard(p, &G, flag);
if (result == -1){
pass = false;
}
if (pass == true){
printf("ALL TESTS PASSED!\n");
}else{
printf("FAILURES\n");
}
}
return 0;
}
