00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "dic.h"
00021 #include "tile.h"
00022 #include "rack.h"
00023 #include "round.h"
00024 #include "pldrack.h"
00025 #include "results.h"
00026 #include "player.h"
00027 #include "ai_player.h"
00028 #include "duplicate.h"
00029 #include "debug.h"
00030
00031
00032 Duplicate::Duplicate(const Dictionary &iDic): Game(iDic)
00033 {
00034 }
00035
00036
00037 Duplicate::~Duplicate()
00038 {
00039 }
00040
00041
00042 int Duplicate::setRackRandom(int p, bool iCheck, set_rack_mode mode)
00043 {
00044 int res;
00045 do
00046 {
00047 res = helperSetRackRandom(p, iCheck, mode);
00048 } while (res == 2);
00049 return res;
00050 }
00051
00052
00053 int Duplicate::play(const string &iCoord, const string &iWord)
00054 {
00055
00056 Round round;
00057 int res = checkPlayedWord(iCoord, iWord, round);
00058 if (res != 0)
00059 {
00060 return res;
00061 }
00062
00063
00064 playRound(round, m_currPlayer);
00065
00066
00067
00068 endTurn();
00069
00070 return 0;
00071 }
00072
00073
00074 void Duplicate::duplicateAI(int n)
00075 {
00076 ASSERT(0 <= n && n < getNPlayers(), "Wrong player number");
00077 ASSERT(!m_players[n]->isHuman(), "AI requested for a human player");
00078
00079 AIPlayer *player = static_cast<AIPlayer*>(m_players[n]);
00080 player->compute(*m_dic, m_board, m_history.getSize());
00081
00082 if (player->changesLetters())
00083 {
00084
00085
00086 ASSERT(false, "AI player has nothing to play!");
00087 }
00088 else
00089 {
00090 playRound(player->getChosenRound(), n);
00091 }
00092 }
00093
00094
00095 int Duplicate::start()
00096 {
00097 ASSERT(getNPlayers(), "Cannot start a game without any player");
00098
00099 m_currPlayer = 0;
00100
00101
00102
00103 int res = setRackRandom(m_currPlayer, true, RACK_NEW);
00104
00105 if (res == 1)
00106 {
00107 end();
00108 return 1;
00109 }
00110
00111 const PlayedRack& pld = m_players[m_currPlayer]->getCurrentRack();
00112
00113 for (int i = 0; i < getNPlayers(); i++)
00114 {
00115 if (i != m_currPlayer)
00116 {
00117 m_players[i]->setCurrentRack(pld);
00118 }
00119
00120 m_hasPlayed[i] = false;
00121 }
00122
00123
00124
00125 endTurn();
00126
00127 return 0;
00128 }
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143 int Duplicate::endTurn()
00144 {
00145 int i;
00146 for (i = 0; i < getNPlayers(); i++)
00147 {
00148 if (m_players[i]->isHuman() && !m_hasPlayed[i])
00149 {
00150
00151 m_currPlayer = i;
00152
00153 return 1;
00154 }
00155 }
00156
00157
00158 if (i == getNPlayers())
00159 {
00160
00161 for (i = 0; i < getNPlayers(); i++)
00162 {
00163 if (!m_players[i]->isHuman())
00164 {
00165 duplicateAI(i);
00166 }
00167 }
00168
00169
00170 endTurnForReal();
00171 }
00172
00173
00174 return 0;
00175 }
00176
00177
00178 void Duplicate::playRound(const Round &iRound, int n)
00179 {
00180 ASSERT(0 <= n && n < getNPlayers(), "Wrong player number");
00181 Player *player = m_players[n];
00182
00183
00184 player->addPoints(iRound.getPoints());
00185 player->endTurn(iRound, m_history.getSize());
00186
00187 m_hasPlayed[n] = true;
00188 }
00189
00190
00191
00192
00193
00194
00195
00196
00197 int Duplicate::endTurnForReal()
00198 {
00199 int res, i, imax;
00200
00201
00202 imax = 0;
00203 for (i = 1; i < getNPlayers(); i++)
00204 {
00205 if (m_players[i]->getLastRound().getPoints() >
00206 m_players[imax]->getLastRound().getPoints())
00207 {
00208 imax = i;
00209 }
00210 }
00211 m_currPlayer = imax;
00212 helperPlayRound(m_players[imax]->getLastRound());
00213
00214
00215 res = setRackRandom(imax, true, RACK_NEW);
00216
00217 if (res == 1)
00218 {
00219 end();
00220 return 1;
00221 }
00222
00223 const PlayedRack& pld = m_players[imax]->getCurrentRack();
00224
00225 for (i = 0; i < getNPlayers(); i++)
00226 {
00227 if (i != imax)
00228 {
00229 m_players[i]->setCurrentRack(pld);
00230 }
00231
00232 m_hasPlayed[i] = false;
00233 }
00234
00235
00236
00237 endTurn();
00238
00239 return 0;
00240 }
00241
00242
00243 void Duplicate::end()
00244 {
00245 m_finished = true;
00246 }
00247
00248
00249 int Duplicate::setPlayer(int n)
00250 {
00251 ASSERT(0 <= n && n < getNPlayers(), "Wrong player number");
00252
00253
00254 if (!m_players[n]->isHuman())
00255 return 1;
00256
00257 m_currPlayer = n;
00258 return 0;
00259 }
00260
00261
00262 void Duplicate::prevHumanPlayer()
00263 {
00264 if (getNHumanPlayers() == 0)
00265 return;
00266
00267 do
00268 {
00269 prevPlayer();
00270 } while (!m_players[m_currPlayer]->isHuman() ||
00271 m_hasPlayed[m_currPlayer]);
00272 }
00273
00274
00275 void Duplicate::nextHumanPlayer()
00276 {
00277 if (getNHumanPlayers() == 0)
00278 return;
00279
00280 do
00281 {
00282 nextPlayer();
00283 } while (!m_players[m_currPlayer]->isHuman() ||
00284 m_hasPlayed[m_currPlayer]);
00285 }
00286
00287
00288
00289
00290
00291
00292