void CTimeManager::endDayEventHandler(const IGameEvent &event)
{
// Only one "NoMoreEventsToday" event is on the events queue at time,
// so we need to add a new event of this type for tomorrow
CDate date = event.getDate();
date.setDay(date.getDay()+1);
date.setHour(23);
date.setMin(59);
date.setSec(59);
CGameEngine::getInstance()->getEventManager()->addEvent(new CEndDayEvent(date));
}
IGame* CSinglePlayerGame::load(const CPfGames &game)
{
LOG_DEBUG("CSinglePlayerGame::load");
CSinglePlayerGame *singlePlayerGame = new CSinglePlayerGame(game);
singlePlayerGame->loadGameEvents();
CDate date = singlePlayerGame->m_optionManager->getGameCurrentDate();
CGameEngine::getInstance()->getTimeManager()->setCurrentTime(date);
date.setHour(23);
date.setMin(59);
date.setSec(59);
CGameEngine::getInstance()->getEventManager()->addEvent(new CEndDayEvent(date));
return singlePlayerGame;
}
void CSeasonGenerator::generateSeason(CSinglePlayerGame &game)
{
CEventManager *eventMngr = CGameEngine::getInstance()->getEventManager();
IDAOFactory *daoFactory = game.getIDAOFactory();
IPfSeasonsDAO *seasonsDAO = daoFactory->getIPfSeasonsDAO();
IPfCompetitionsBySeasonDAO *competitionsBySeasonDAO = daoFactory->getIPfCompetitionsBySeasonDAO();
IPfTeamsDAO *teamsDAO = daoFactory->getIPfTeamsDAO();
IPfTeamsByCompetitionsDAO *teamsByCompetitionsDAO = daoFactory->getIPfTeamsByCompetitionsDAO();
CPfSeasons *season = seasonsDAO->findLastSeason();
if( season==NULL || season->getXSeason_str()=="" ){
throw PFEXCEPTION("[CSeasonGenerator::generateSeason] Last season was not found, new season generation is aborted.");
}
int year = season->getNYear()+1;
std::ostringstream sseason;
sseason << year << "/" << (year+1);
// the min & max date necesary for the season events
CDate minDate = CDate::MAX_DATE;
CDate maxDate = CDate::MIN_DATE;
// create the new season
CPfSeasons newSeason;
newSeason.setNYear(year);
newSeason.setSSeason(sseason.str());
daoFactory->getIPfSeasonsDAO()->insertReg(&newSeason);
// retrieve the competitions associated with the last season
std::vector<CPfCompetitionsBySeason*> *competitionsBySeasonList = competitionsBySeasonDAO->findByXFkSeason(season->getXSeason_str());
// for each competition, create a new competition by season and insert the relevant matches
std::vector<CPfCompetitionsBySeason*>::iterator itCompetitionsBySeason;
for( itCompetitionsBySeason=competitionsBySeasonList->begin(); itCompetitionsBySeason!=competitionsBySeasonList->end(); itCompetitionsBySeason++ ){
CPfCompetitionsBySeason *competitionBySeason = *itCompetitionsBySeason;
// create the new competition by season
CPfCompetitionsBySeason *newCompetitionBySeason = new CPfCompetitionsBySeason();
newCompetitionBySeason->setDBeginCompetition(getSameWeekDayOneYearLater(competitionBySeason->getDBeginCompetition()));
newCompetitionBySeason->setDEndCompetition(getSameWeekDayOneYearLater(competitionBySeason->getDEndCompetition()));
newCompetitionBySeason->setXFkCompetition_str(competitionBySeason->getXFkCompetition_str());
newCompetitionBySeason->setXFkSeason_str(newSeason.getXSeason_str());
competitionsBySeasonDAO->insertReg(newCompetitionBySeason);
// retrieve the teams registered in previous season on the same competition
std::vector<CPfTeams*> *teamsList = teamsDAO->findByXFKCompetitionAndXFKSeason(competitionBySeason->getXFkCompetition_str(), competitionBySeason->getXFkSeason_str());
std::vector<CPfTeams*>::iterator itTeams;
for( itTeams=teamsList->begin(); itTeams!=teamsList->end(); itTeams++ ){
CPfTeams *team = *itTeams;
// the team will be associate with the competition for the new season
CPfTeamsByCompetitions *newTeamByCompetition = new CPfTeamsByCompetitions();
newTeamByCompetition->setXFkCompetitionBySeason_str(newCompetitionBySeason->getXCompetitionBySeason_str());
newTeamByCompetition->setXFkTeam_str(team->getXTeam_str());
teamsByCompetitionsDAO->insertReg(newTeamByCompetition);
delete newTeamByCompetition;
}
eventMngr->addEvent(new CStartCompetitionEvent(newCompetitionBySeason->getDBeginCompetition()));
//Shuffle teams to create random calendar
std::random_shuffle(teamsList->begin(), teamsList->end());
generateLeagueMatches(game, *newCompetitionBySeason, teamsList); // TODO: Maybe not all competitions are leagues
eventMngr->addEvent(new CEndCompetitionEvent(newCompetitionBySeason->getDEndCompetition()));
// Retrieve the min & max date for the season events
if( newCompetitionBySeason->getDBeginCompetition()<minDate ){
minDate = newCompetitionBySeason->getDBeginCompetition();
}
if( newCompetitionBySeason->getDEndCompetition()>maxDate ){
maxDate = newCompetitionBySeason->getDEndCompetition();
}
teamsDAO->freeVector(teamsList);
delete newCompetitionBySeason;
}
minDate.setSec(minDate.getSec()-1);
maxDate.setSec(maxDate.getSec()+1);
// enqueue the start & end season events
eventMngr->addEvent(new CStartSeasonEvent(minDate));
eventMngr->addEvent(new CEndSeasonEvent(maxDate));
game.getOptionManager()->setGameCurrentSeason(newSeason.getXSeason());
competitionsBySeasonDAO->freeVector(competitionsBySeasonList);
delete season;
}
void CSinglePlayerGame::loadGameEvents()
{
int xSeason = m_optionManager->getGameCurrentSeason();
CEventManager *eventMngr = CGameEngine::getInstance()->getEventManager();
IPfCompetitionPhasesBySeasonDAO *competitionPhasesBySeasonDAO = m_daoFactory->getIPfCompetitionPhasesBySeasonDAO();
IPfCompetitionPhasesDAO *competitionPhasesDAO = m_daoFactory->getIPfCompetitionPhasesDAO();
IPfMatchesDAO *matchesDAO = m_daoFactory->getIPfMatchesDAO();
// the min & max date necesary for the season events
CDate minDate = CDate::MAX_DATE;
CDate maxDate = CDate::MIN_DATE;
// retrieve the competitions for the current season
std::vector<CPfCompetitionPhasesBySeason*> *competitionPhasesBySeasonList = competitionPhasesBySeasonDAO->findByXFkSeason(xSeason);
std::vector<CPfCompetitionPhasesBySeason*>::iterator itCompetitionPhasesBySeason;
bool someCompetitionStarted = false;
for( itCompetitionPhasesBySeason=competitionPhasesBySeasonList->begin(); itCompetitionPhasesBySeason!=competitionPhasesBySeasonList->end(); itCompetitionPhasesBySeason++ ){
CPfCompetitionPhasesBySeason *competitionPhaseBySeason = *itCompetitionPhasesBySeason;
CPfCompetitionPhases *competitionPhase = competitionPhasesDAO->findByXCompetitionPhase(competitionPhaseBySeason->getXFkCompetitionPhase_str());
// for each competition are retrieved the respective matches
std::vector<CPfMatches*> *matchesList = matchesDAO->findByXFkCompetitionAndXFkSeason(competitionPhase->getXFkCompetition_str(), competitionPhaseBySeason->getXFkSeason_str());
std::vector<CPfMatches*>::iterator itMatches;
bool someMatchPlayed = false;
for( itMatches=matchesList->begin(); itMatches!=matchesList->end(); itMatches++ ){
CPfMatches *match = *itMatches;
if( match->getLPlayed() ){
someMatchPlayed = true;
someCompetitionStarted = true;
}else{
eventMngr->addEvent(new CMatchEvent(match->getDMatch(), match->getXMatch()));
}
}
if( !someMatchPlayed ){
eventMngr->addEvent(new CStartCompetitionEvent(competitionPhaseBySeason->getDBeginCompetitionPhase()));
}
eventMngr->addEvent(new CEndCompetitionEvent(competitionPhaseBySeason->getDEndCompetitionPhase()));
// Retrieve the min & max date for the season events
if( competitionPhaseBySeason->getDBeginCompetitionPhase()<minDate ){
minDate = competitionPhaseBySeason->getDBeginCompetitionPhase();
}
if( competitionPhaseBySeason->getDEndCompetitionPhase()>maxDate ){
maxDate = competitionPhaseBySeason->getDEndCompetitionPhase();
}
matchesDAO->freeVector(matchesList);
}
minDate.setSec(minDate.getSec()-1);
maxDate.setSec(maxDate.getSec()+1);
// enqueue the start & end season events
if( !someCompetitionStarted ){
eventMngr->addEvent(new CStartSeasonEvent(minDate));
}
eventMngr->addEvent(new CEndSeasonEvent(maxDate));
competitionPhasesBySeasonDAO->freeVector(competitionPhasesBySeasonList);
}
IGame* CSinglePlayerGame::newGame(const CPfUsers &user, const std::string &gameName, const std::string &coachName)
{
LOG_DEBUG("CSinglePlayerGame::newGame");
CDate nowDate;
CPfGames game;
game.setDLastSaved(nowDate);
game.setSDriverName("SQLite");
game.setSConnectionString(CResourceManager::getInstance()->getDbFileName());
game.setSGameName(gameName);
game.setSGameType(S_GAME_TYPE_SINGLEPLAYER);
game.setXFkUser(user.getXUser());
// With this way, here we only need to set the initial environment for
// a new game, forgetting the creation of attributes for a CSinglePlayerGame
// object. This task rests now on constructor.
CSinglePlayerGame *singlePlayerGame = new CSinglePlayerGame(game);
// retrieve the last season in the database and the end date of the itself
CDate maxDate = CDate::MIN_DATE;
CPfSeasons *season = singlePlayerGame->m_daoFactory->getIPfSeasonsDAO()->findLastSeason();
if( season->getXSeason() == 0 ){
throw PFEXCEPTION("The last season is NULL");
}
IPfCompetitionPhasesBySeasonDAO *competitionBySeasonDAO = singlePlayerGame->m_daoFactory->getIPfCompetitionPhasesBySeasonDAO();
std::vector<CPfCompetitionPhasesBySeason*> *competitionsBySeasonList = competitionBySeasonDAO->findByXFkSeason(season->getXSeason_str());
std::vector<CPfCompetitionPhasesBySeason*>::iterator itCompetitionsBySeason;
for( itCompetitionsBySeason=competitionsBySeasonList->begin(); itCompetitionsBySeason!=competitionsBySeasonList->end(); itCompetitionsBySeason++ ){
CPfCompetitionPhasesBySeason *competitionBySeason = *itCompetitionsBySeason;
if( competitionBySeason->getDEndCompetitionPhase()>maxDate ){
maxDate = competitionBySeason->getDEndCompetitionPhase();
}
}
singlePlayerGame->m_optionManager->setGameNew(true);
singlePlayerGame->m_optionManager->setGameCurrentDate(maxDate);
singlePlayerGame->m_optionManager->setGameCurrentSeason(season->getXSeason());
// Create player's coach
// TODO: create coach in another way. Maybe player settings?
CPfCoaches *playerCoach = new CPfCoaches();
playerCoach->setSName(coachName);
playerCoach->setSShortName(coachName);
playerCoach->setSPhoto("p_unknown");
playerCoach->setXFkFormationSelected(1);
playerCoach->setXFkCountry(1);
singlePlayerGame->m_daoFactory->getIPfCoachesDAO()->insertReg(playerCoach);
singlePlayerGame->m_optionManager->setGamePlayerCoach(playerCoach->getXCoach());
delete playerCoach;
competitionBySeasonDAO->freeVector(competitionsBySeasonList);
delete season;
singlePlayerGame->loadGameEvents();
CDate date = singlePlayerGame->m_optionManager->getGameCurrentDate();
CGameEngine::getInstance()->getTimeManager()->setCurrentTime(date);
date.setHour(23);
date.setMin(59);
date.setSec(59);
CGameEngine::getInstance()->getEventManager()->addEvent(new CEndDayEvent(date));
return singlePlayerGame;
}