C++ Time::asMicroseconds方法代码示例

void Engine::update(sf::Time dt)
{
	m_entMgr->update(dt.asMicroseconds());
	
	if(Stats::get()->getLives() < 0) m_exit = true;
	m_dbg->update(dt.asMilliseconds(), m_entMgr->getPlayer()->getPos());
}

 template <typename Game> void update(const sf::Time & elapsedTime, Game *) {
     timer += elapsedTime.asMicroseconds();
     glowFadeTimer += elapsedTime.asMicroseconds();
     if (timer > 65000) {
         timer -= 65000;
         frameIndex++;
         if (frameIndex > 5) {
             frameIndex = 5;
             killFlag = true;
         }
     }
     uint8_t color =
         Easing::easeOut<2>(glowFadeTimer, static_cast<int64_t>(300000)) *
         230;
     glow.setColor(sf::Color(color, color, color, 255));
 }

 template <typename Game> void update(const sf::Time & elapsedTime, Game *) {
     timer += elapsedTime.asMicroseconds();
     glowFadeTimer += elapsedTime.asMicroseconds();
     static const int frameTransitionTime = 70000;
     if (timer > frameTransitionTime) {
         timer -= frameTransitionTime;
         frameIndex++;
         static const int maxFrame = 8;
         if (frameIndex > maxFrame) {
             frameIndex = maxFrame;
             killFlag = true;
         }
     }
     uint8_t color =
         Easing::easeOut<1>(glowFadeTimer, static_cast<int64_t>(560000)) *
         230;
     glow.setColor(sf::Color(color, color, color, 255));
 }

/**
 * advance the song by the given delta time
 * and play/stop the notes according to the events
 * present in that delta time
 */
static void playSong(
    linthesia::Context &context,
    const sf::Time& delta
) {
    auto events =context.update(delta.asMicroseconds());
    for (const auto& oneEvent : events) {
        context.midiOut.write(oneEvent.second);
    }
}

void AnimHandler::updateAnimation(const sf::Time& time_elapsed)//Update the current frame (must be called at least once before draw()!)
{
	ctime += (int)time_elapsed.asMicroseconds();
	if (ctime < currentFrame->delay) return;
	cframe++;
	if (cframe >= (int)currentAnim->frames.size() || cframe < 0)
	{
		cframe = 0;
	}
	ctime = ctime % currentFrame->delay;
	currentFrame = &currentAnim->frames[cframe];
}

SoundManager::FadedMusic::FadedMusic(
    VFileMusic& music, float target, sf::Time fadeDuration):
    target(target),
    music(&music),
    increment(0)
{
    if (fadeDuration.asMicroseconds()) {
        music.setVolume(100 - target);
        increment = (target - music.getVolume()) / fadeDuration.asSeconds();
    } else {
        music.setVolume(target);
    }
}

	void drawFpsCounter(sf::RenderWindow& aWindow, const sf::Font& aFont, sf::Time aDeltaTime)
	{
		sf::Text text;
		text.setFont(aFont);
		text.setColor(sf::Color::Red);
		text.setPosition(0, 50.0f);

		char buffer[Int64TextWidth];
		_i64toa_s(aDeltaTime.asMicroseconds(), buffer, Int64TextWidth, 10);
		//_gcvt_s(buffer, Int64TextWidth, elapsedTime, 20);

		text.setString(buffer);

		aWindow.draw(text);
	}

int main(int argv, char* argc[])
{
	sf::RenderWindow window(sf::VideoMode(windowWidth, windowHeight), "SFML and Box2D", sf::Style::Close);

	window.setVerticalSyncEnabled(false); // vsync messes with updates

	b2Vec2 gravity(0.0f, 0.0f);

	b2World world(gravity);

	sf::Clock clock;
	sf::Clock seconds;

	while (window.isOpen())
	{
		sf::Time elapsed = clock.getElapsedTime();

		if (elapsed.asMicroseconds() >= updateRate.asMicroseconds())
		{
			clock.restart();
			update(&window);
		}
		elapsed = seconds.getElapsedTime();
		if (elapsed.asSeconds() >= 1)
		{
			UPS = tick;
			FPS = frame;
			std::cout << "UPS: " << UPS << ", FPS: " << FPS << std::endl;
			tick = 0;
			frame = 0;
			seconds.restart();
		}

		render(&window);
	}



	return 0;
}

void Skier::Update_velocity( sf::Time elapsed_time ) {
  
    // This multiplier acts as a general physics speed modifier.
    // All other similar multiplying values behave as relative intensities
    // compared to other physics effects
    long double amount = elapsed_time.asMicroseconds() / 10000.0f;

    // increase lateral velocity by 'amount' if the right or left arrow key
    // is being pressed.  Decrease vertical (downward) velocity by amount
    // if the up arrow is pressed.

    if( sf::Keyboard::isKeyPressed( sf::Keyboard::Right ) ) {
        // turn right
        m_velocity += Util::Get_perpendicular_v2f( m_velocity, amount / 30.0f );
    } else if( sf::Keyboard::isKeyPressed( sf::Keyboard::Left ) ) {
        // turn left.
        m_velocity -= Util::Get_perpendicular_v2f( m_velocity, amount / 30.0f );
    }
    if( sf::Keyboard::isKeyPressed( sf::Keyboard::Up ) ) {
        // slow down...
        m_velocity.y /= 1.0f + amount / 20.0f;
    
        // ... but not too much
        if( m_velocity.y < 0.0f ) {
            m_velocity.y = 0.0f;
        }
        // friction:
        m_velocity.x /= 1.0f + amount / 20.0f;
    }
    #if 0
    if( sf::Keyboard::isKeyPressed( sf::Keyboard::Down ) ) {
        // Nothing curently
    }
    #endif

    // gravity
    m_velocity.y += amount * 2 / 980.6f;

    Normalize_velocity();
}

    void update(const sf::Time & elapsedTime, Game * pGame) {
        switch (state) {
        case State::opening:
            animationTimer += elapsedTime.asMicroseconds();
            if (animationTimer > 50000) {
                animationTimer -= 50000;
                frameIndex++;
                if (frameIndex > 5) {
                    frameIndex = 4;
                    state = State::ready;
                }
            }
            break;

        case State::ready:
            // TODO: play reward sound
            pGame->getUI().setPowerup(powerup);
            state = State::complete;
            break;

        default:
            break;
        }
    }

void Crocodile::update(sf::Time elapsed_time) {

    sf::Vector2f previous_direction = direction;
    bool key_pressed = (new_direction != sf::Vector2f(0, 0));
    bool u_turn = (new_direction == - direction);
    bool already_doing_a_turn = (path.front().length < 0);
    if (key_pressed && ! u_turn && ! already_doing_a_turn) {
        direction = new_direction;
    }

    // If the direction has changed, add 2 new path chunks:
    // one for the curve (smooth turn) and one for the straight
    // line that follows.
    if (direction != previous_direction) {
        sf::Vector2f current_head_position = sprites.front().getPosition();

        PathChunk curve;
        curve.from = previous_direction;
        curve.to = direction;
        curve.length = M_PI * curve_radius / 2.0;
        curve.position = current_head_position;
        path.push_front(curve);

        PathChunk straight_line;
        straight_line.from = direction;
        straight_line.to = direction;
        straight_line.length = - curve.length;
        straight_line.position = current_head_position
                + direction*curve_radius
                + previous_direction*curve_radius;
        path.push_front(straight_line);
    }

    // update the distance-to-head of the first path chunk
    sf::Int64 elapsed_ms = elapsed_time.asMicroseconds();
    float velocity = elapsed_ms * speed;
    path.front().length += velocity;

    // update position of all sprites
    std::vector<sf::Sprite>::iterator sprite = sprites.begin();
    std::deque<PathChunk>::iterator chunk = path.begin();
    float chunk_dist_to_head = chunk->length;
    float sprite_dist_to_head = 0.0;

    while (true) {

        if (chunk_dist_to_head >= sprite_dist_to_head) {

            sf::Vector2f prev_pos = sprite->getPosition();

            // Compute new position depending on the type of the path chunk
            sf::Vector2f new_pos;
            // offset is the distance ran on the current path chunk
            float offset = chunk_dist_to_head - sprite_dist_to_head;

            if (chunk->from == chunk->to) { // straight line
                sf::Vector2f shifting = chunk->to * offset;
                new_pos = chunk->position + shifting;

            } else { // curve

                // theta is the angle travelled along on the current path chunk
                float theta = offset / curve_radius;

                float absolute_angle;

                if (chunk->from == sf::Vector2f(1.0, 0.0)
                        && chunk->to == sf::Vector2f(0.0, 1.0)) {
                    absolute_angle = - M_PI / 2.0 + theta;

                } else if (chunk->from == sf::Vector2f(1.0, 0.0)
                        && chunk->to == sf::Vector2f(0.0, -1.0)) {
                    absolute_angle = + M_PI / 2.0 - theta;

                } else if (chunk->from == sf::Vector2f(-1.0, 0.0)
                        && chunk->to == sf::Vector2f(0.0, 1.0)) {
                    absolute_angle = - M_PI / 2.0 - theta;

                } else if (chunk->from == sf::Vector2f(-1.0, 0.0)
                        && chunk->to == sf::Vector2f(0.0, -1.0)) {
                    absolute_angle = M_PI / 2.0 + theta;

                } else if (chunk->from == sf::Vector2f(0.0, 1.0)
                        && chunk->to == sf::Vector2f(1.0, 0.0)) {
                    absolute_angle = M_PI - theta;

                } else if (chunk->from == sf::Vector2f(0.0, 1.0)
                        && chunk->to == sf::Vector2f(-1.0, 0.0)) {
                    absolute_angle = + theta;

                } else if (chunk->from == sf::Vector2f(0.0, -1.0)
                        && chunk->to == sf::Vector2f(1.0, 0.0)) {
                    absolute_angle = M_PI + theta;

                } else if (chunk->from == sf::Vector2f(0.0, -1.0)
                        && chunk->to == sf::Vector2f(-1.0, 0.0)) {
                    absolute_angle = - theta;

                } else {
                    std::cout << "should not happen" << std::endl;
//.........这里部分代码省略.........

void PlayerObject::UpdateCurrent(sf::Time p_xDtime){
	sf::Vector2f l_xVel((sf::Keyboard::isKeyPressed(sf::Keyboard::D) - sf::Keyboard::isKeyPressed(sf::Keyboard::A)), (sf::Keyboard::isKeyPressed(sf::Keyboard::S) - sf::Keyboard::isKeyPressed(sf::Keyboard::W)));
	
	setVelocity(l_xVel * (float)p_xDtime.asMicroseconds());
}

//.........这里部分代码省略.........
                    angleFunction(target.x, target.y + 8, position.x,
                                  position.y));
                pGame->getSounds().play(ResHandler::Sound::silenced,
                                        this->shared_from_this(), 220.f, 5.f);
            }
        }
        if (timer > 300) {
            timer -= 300;
            shotCount = 0;
            state = State::pause;
        }
        break;

    case State::shootBegin:
        facePlayer();
        if (timer > 80) {
            timer -= 80;
            frameTimer = 0;
            target = player.getPosition();
            state = State::shooting;
            frameIndex = 4;
        }
        break;

    case State::dashBegin:
    begin:
        facePlayer();
        if (timer > 352) {
            timer -= 352;
            state = State::dashing;
            sounds.play(ResHandler::Sound::wooshMono, this->shared_from_this(),
                        220.f, 5.f);
            frameIndex = 2;
            uint8_t tries{0};
            float dir{static_cast<float>(rng::random<359>())};
            do {
                tries++;
                if (tries > 254) {
                    state = State::shootBegin;
                    frameIndex = 3;
                    goto begin;
                }
                dir += 12;
            } while (wallInPath(walls, dir, position.x, position.y));
            hSpeed = 5 * cos(dir);
            vSpeed = 5 * sin(dir);
            if (hSpeed > 0) {
                dasherSheet.setScale(-1, 1);
            } else {
                dasherSheet.setScale(1, 1);
                dasherSheet.setScale(1, 1);
            }
        }
        break;

    case State::dashing:
        frameTimer += elapsedTime.asMilliseconds();
        if (frameTimer > 40) {
            frameTimer = 0;
            blurEffects.emplace_back(dasherSheet.getSpritePtr(), position.x,
                                     position.y);
        }
        if (timer > 250) {
            timer -= 250;
            state = State::dashEnd;
            frameIndex = 1;
            hSpeed = 0.f;
            vSpeed = 0.f;
        }

        if (Enemy::checkWallCollision(walls, position.x, position.y)) {
            hSpeed *= -1.f;
            vSpeed *= -1.f;
        }
        break;

    case State::dashEnd:
        if (timer > 150) {
            blurEffects.clear();
            timer -= 150;
            state = State::idle;
            frameIndex = 0;
        }
        break;
    }

    if (!blurEffects.empty()) {
        for (auto it = blurEffects.begin(); it != blurEffects.end();) {
            if (it->getKillFlag())
                it = blurEffects.erase(it);
            else {
                it->update(elapsedTime);
                ++it;
            }
        }
    }

    position.x += hSpeed * (elapsedTime.asMicroseconds() * 0.00005f);
    position.y += vSpeed * (elapsedTime.asMicroseconds() * 0.00005f);
}

float Game::getFPS(const sf::Time& time) {
	return (1000000.0f / time.asMicroseconds());
}

//.........这里部分代码省略.........

	sf::RectangleShape _bounding2(sf::Vector2f(_enemy.getBoundingBox().width - 1, _enemy.getBoundingBox().height - 1));
	_bounding2.setPosition(_enemy.getPosition());
	_bounding2.setFillColor(sf::Color::Transparent);
	_bounding2.setOutlineColor(sf::Color::Red);
	_bounding2.setOutlineThickness(1);

	sf::Font font;
	font.loadFromFile("VeraMono.ttf");
	sf::Text _text("Debug", font, 12);
	_text.setPosition(0, 0);

	sf::Clock clock;
	sf::Time timeSinceLastUpdate = sf::Time::Zero;

	// Start the game loop
	while (window.isOpen())
	{
		sf::Time elapsedTime = clock.restart();
		timeSinceLastUpdate += elapsedTime;

		while (timeSinceLastUpdate > TimePerFrame)
		{
			timeSinceLastUpdate -= TimePerFrame;

			// Process events
			sf::Event event;
			while (window.pollEvent(event))
			{
				// Close window : exit
				if (event.type == sf::Event::Closed)
					window.close();

				if(event.type == sf::Event::KeyPressed)
				{
					short id = 1;
					for( auto& i : _gameObjects )
					{
						i->update(event, id);
						id++;
					}
				}
			}

			if(checkCollisions(_gameObjects, _texts))
				_texts["Collision"] = "Detected";
			else
				_texts["Collision"] = "NOT Detected";

			std::map<std::string, std::string>::iterator i = _texts.begin();
			std::stringstream ss;

			for( ; i != _texts.end(); ++i )
			{
				ss << i->first << ": " << i->second << std::endl << std::endl;
			}

			_text.setString(ss.str());
		}

		_bounding1.setPosition(_player.getPosition());
		_bounding2.setPosition(_enemy.getPosition());

		_statisticsUpdateTime += elapsedTime;
		_statisticsNumFrames += 1;

		if (_statisticsUpdateTime >= sf::seconds(1.0f))
		{
			std::stringstream fps, timeupdate;
			fps << _statisticsNumFrames;
			timeupdate << _statisticsUpdateTime.asMicroseconds() / _statisticsNumFrames;

			_statisticsUpdateTime -= sf::seconds(1.0f);
			_statisticsNumFrames = 0;

			_texts["FPS"] = fps.str() + "\n" + "Time / Update = " + timeupdate.str() + "us";
		}

		window.clear();

		window.draw(_background);
		// window.draw(m_vertices, &m_tileset);
		window.draw(_cliffsBottom);
		window.draw(_cliffsTop);
		window.draw(_platform);
		window.draw(_platformBottom);

		for( auto& i : _gameObjects )
		{
			window.draw(*i);
		}

		window.draw(_text);

		window.draw(_bounding1);
		window.draw(_bounding2);

		window.display();
	}
}