C++ CDate::setSec方法代码示例

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;
}