C++ setLevel函数代码示例

ERR_Code
aCatGroup::SetParent( aCatGroup * parent )
{
	aSQLTable * t = table();
	if ( !t ) return err_notable;
	qulonglong idp = 0, uid = getUid();
	if ( parent ) idp = parent->getUid();
	if ( idp == uid ) return err_cyclereparent;
	qulonglong level, tmpid = idp;
	aCatGroup tg( obj, db );
	while ( tmpid )
	{
		tg.select(tmpid);
		tmpid = tg.parentUid();
		if ( tmpid == uid ) return err_cyclereparent;
	}
	QString query;
	query = QString("UPDATE %1 SET idp=%2 WHERE id=%3").arg(t->tableName).arg(idp).arg(uid);
	level = parent->Value("Level").toULongLong();
//	printf("%s\n",(const char*)query);
	QSqlDatabase tdb = *db->db();
	tdb.exec(query);
	if ( !tdb.lastError().type() )
	{
		if (idp) setLevel(level+1);
		else setLevel(0);
		return err_noerror;
	}
	else return err_execerror;
}

void Dmc3xlTimeline::onTimer(Timer *sender)
{
#ifdef DEBUG
    debugString("Dmc3xlTimeline::onTimer");
    debug(sender->id);
#endif
    switch (sender->id)
    {
    case TIMER_SWITCH_UP:
        sendSwitchUp();
        setLedDuration(ledRight, 1, 100);
        break;
    case TIMER_SWITCH_DOWN:
        sendSwitchDown();
        setLedDuration(ledLeft, 1, 100);
        break;
    case TIMER_LEVEL_UP:
        setLevel();
        sendLevel();
        setLedDuration(ledRight, 1, 100);
        break;
    case TIMER_LEVEL_DOWN:
        setLevel();
        sendLevel();
        setLedDuration(ledLeft, 1, 100);
        break;
    }
}

void OgreApp::activatePerformSingleTap(float x, float y)
{
    player->addAction(ACTION_SINGLE_TAP);
    if (x >= globals.pauseButton_posX && x <= globals.pauseButton_posX + globals.pauseButton_width &&
        y >= globals.pauseButton_posY && y <= globals.pauseButton_posY + globals.pauseButton_posY) {
        if (!pause) setPause(true);
    }
#ifdef DEBUG_MODE
    else if (y <= 100 && x <= globals.screenWidth / 2) {
        setLevel(EVEN, false);
    } else if (y <= 100 && x > globals.screenWidth / 2) {
        setLevel(EVEN);
    }
#endif
}

void Game::updateGameInfos(int nbLinesDeleted)
{
	setLinesCompleted(getLinesCompleted() + nbLinesDeleted);
	setLevel(computeLevel());
	setFallIterationDelay(computeFallIterationDelay());
	setScore(computeScore(nbLinesDeleted) + getScore());
}

void Level::update(double delta, sf::Event& evt, sf::View& v)
{

	if(ltype == Menu)
	{
		//if spacebar is pressed in menu, start game
		if(evt.type == sf::Event::KeyPressed)
			if(evt.key.code == sf::Keyboard::Space)
				setLevel(Stage1);
	} else {
		//step an iteration of box2d world
		b2world->Step(delta/1000, 8, 3);

		//set view
		//remember to change from first dynamic entity to the player position
		
		v.setCenter(player->anim.xpos+20, player->anim.ypos+30);

		//iterate through dentity list and update
		auto itr = dentitylist.begin();
		for(itr; itr != dentitylist.end(); ++itr)
		{
			(*itr)->update(delta);
		}
	
		//update player
		player->Player::update(evt, delta);

		//update enemies
	}
}

std::vector<std::string> LoggerDB::processConfigString(
    folly::StringPiece config) {
  std::vector<std::string> errors;
  if (config.empty()) {
    return errors;
  }

  std::vector<StringPiece> pieces;
  folly::split(",", config, pieces);
  for (const auto& p : pieces) {
    auto idx = p.rfind('=');
    if (idx == folly::StringPiece::npos) {
      errors.emplace_back(
          folly::sformat("missing '=' in logger configuration: \"{}\"", p));
      continue;
    }

    auto category = p.subpiece(0, idx);
    auto level_str = p.subpiece(idx + 1);
    LogLevel level;
    try {
      level = stringToLogLevel(level_str);
    } catch (const std::exception&) {
      errors.emplace_back(folly::sformat(
          "invalid log level \"{}\" for category \"{}\"", level_str, category));
      continue;
    }

    setLevel(category, level);
  }

  return errors;
}

	DevLog()
	{
		addChannel( MSG_DEV );
		setLevel( 3 );

		pos = 0;
	}

bool Level6::initWithDifficulty(int difficulty)
{
    if ( !Layer::init() )
    {
        return false;
    }

	SpriteFrameCache::getInstance()->addSpriteFramesWithFile("sprite_level6-hd.plist");
	SpriteFrameCache::getInstance()->addSpriteFramesWithFile("sprite_level6_2-hd.plist");
	setLevel(6);
	this->difficulty = difficulty;
	initMap();
	
	std::vector<Point> points;
	points.push_back(Point(40,360));
	points.push_back(Point(40,610));
	points.push_back(Point(756,940));
	points.push_back(Point(1145,560));
	addWaveProgressBars(points);
	waveFlags.at(0)->restartWaveFlag();
	waveFlags.at(1)->restartWaveFlag();
	waveFlags.at(2)->restartWaveFlag();
	waveFlags.at(3)->restartWaveFlag();
	SoundManager::playJungleBattle();
	return true;
}

void Logger::configure(std::string level,std::string format,std::string filename){

  _filename = filename;
  _format = format;
  _enabled = true;
  setLevel(level);
}

bool ArrowTower::init()
{
	if (!TowerBase::init())
	{
		return false;
	}

	setScope(120);
	setLethality(1);
	setTowerValue(120);
	setRate(3);
	setLevel(0);
	setTowerType(0);



	auto ll = getLevel();
	if( ll == 0 )
	{
		tower= Sprite::createWithSpriteFrameName("tower1.png");
	}
	else if ( ll == 1)
	{
		tower= Sprite::createWithSpriteFrameName("tower2.png");
	}
	else 
	{
		tower= Sprite::createWithSpriteFrameName("tower3.png");
	}
	this->addChild(tower);
	schedule(schedule_selector(ArrowTower::rotateAndShoot), 0.8f);
	return true;
}

void GameScene::setGameState(GameState gameState) {
    qDebug() << "Game state set " << gameState;
    // If the gameState was game over, restart the level
    if(m_gameState == GameOver && gameState == GameRunning) {
        setLevel(level());
    }
    this->m_gameState = gameState;
    if(gameState == GameStarted) {
        pauseGame();
    }
    if(gameState == GamePaused) {
        pauseGame();
    }
    if(gameState == GameOver) {
        pauseGame();
    }
    if(gameState == GameRunning) {
        setLevelUpgrade(false);
        continueGame();
    }
    if(gameState == GameInstructionPause) {
        pauseGame();
    }
    emit gameStateChanged(gameState);
}

Spawn::Spawn(Spawn& s, uint16_t id)
  : Item(tSpawn, id)
{
  setName(s.name());
  setLastName(s.lastName());
  Item::setPoint(s.x(), s.y(), s.z());
  setPetOwnerID(s.petOwnerID());
  setLight(s.light());
  setGender(s.gender());
  setDeity(s.deity());
  setRace(s.race());
  setClassVal(s.classVal());
  setHP(s.HP());
  setMaxHP(s.maxHP());
  setGuildID(s.GuildID());
  setLevel(s.level());
  for (int i = 0; i <= tLastCoreWearSlot; i++)
    setEquipment(i, s.equipment(i));
  setEquipment(tUnknown1, 0);
  setTypeflag(s.typeflag());
  setNPC(s.NPC());
  setAnimation(s.animation());
  setDeltas(s.deltaX(), s.deltaY(), s.deltaZ());
  setHeading(s.heading(), s.deltaHeading());
  setConsidered(s.considered());

  // the new copy will own the spawn track list
  m_spawnTrackList.setAutoDelete(false);
  m_spawnTrackList = s.m_spawnTrackList;
  s.m_spawnTrackList.setAutoDelete(false);
  m_spawnTrackList.setAutoDelete(true);
}

void Pokemon::levelUpTo(int level)
{
	for (auto currentLevel = level_; currentLevel <= level - 1;)
	{
		setLevel(++currentLevel, false);
	}
}

void OgreApp::activatePerformLeftMove()
{
    player->addAction(ACTION_SWIPE_LEFT);
    switch (gameState)
    {
        case STATE_PLAY:
        {
            if (pause)
            {
                setPause(false);
            }
            else
            {
                if (player->setVineDirRequest(Util::rightOf(player->getVineDest())) && !tunnel->isDone())
                {
                    float val = player->getDesireRoll();
                    player->setDesireRoll(val + 45);
                }
                globals.moveLeft = true;
            }
            break;
        }
        case STATE_PROMPT:
        {
            gameState = STATE_PLAY;
            levelMgr->repeatPreviousPhase();
            setLevel();
            break;
        }
    }
}

int main()
{
  // check logger performance for 'NULL configuration'
  logger::registry().registerHandle(logger::makeLoggerRegistryHandle());
  auto logger = logger::registry()->registerLogger("");
  //logger->setMessageService(std::make_shared< logger::NullMessageService >());
  auto messageService = std::make_shared< logger::StdOutMessageService >();
  logger->setMessageService(messageService);
  logger->setLevel(logger::MessageLevel::DEBUG);

  auto start = std::chrono::high_resolution_clock::now();
  const auto COUNT = 100; // a hundred million
  for (auto i = 0; i < COUNT; ++i)
  {
    LOG_DEBUG("debug message no: %d", i);
    LOG_ERROR("error message no: %d", i);
  }
  messageService->flush();
  auto end = std::chrono::high_resolution_clock::now();

  auto duration = end - start;
  std::chrono::duration<float> seconds = duration;// std::chrono::duration_cast<std::chrono::seconds>(duration);

  auto msPerLine = std::chrono::duration_cast<std::chrono::nanoseconds>(duration) / COUNT;
  printf("work time: %f sec [%lld ns * %d]\n", seconds.count(), msPerLine.count(), COUNT);

  return 0;
}