示例#1
0
void Player::logic()
{
    switch (mAction)
    {
        case STAND:
        case SIT:
        case DEAD:
        case HURT:
           break;

        case WALK:
            mFrame = (get_elapsed_time(mWalkTime) * 6) / getWalkSpeed();
            if (mFrame >= 6)
                nextStep();
            break;

        case ATTACK:
            int rotation = 0;
            std::string particleEffect = "";
            int frames = 4;

            if (mEquippedWeapon &&
                mEquippedWeapon->getAttackType() == ACTION_ATTACK_BOW)
            {
                frames = 5;
            }

            mFrame = (get_elapsed_time(mWalkTime) * frames) / mAttackSpeed;

            //attack particle effect
            if (mEquippedWeapon)
                particleEffect = mEquippedWeapon->getParticleEffect();

            if (!particleEffect.empty() && mParticleEffects && mFrame == 1)
            {
                switch (mDirection)
                {
                    case DOWN: rotation = 0; break;
                    case LEFT: rotation = 90; break;
                    case UP: rotation = 180; break;
                    case RIGHT: rotation = 270; break;
                    default: break;
                }
                Particle *p;
                p = particleEngine->addEffect("graphics/particles/" +
                                              particleEffect, 0, 0, rotation);
                controlParticle(p);
            }

            if (mFrame >= frames)
                nextStep();

            break;
    }

    Being::logic();
}
示例#2
0
文件: perft.c 项目: tompko/Patrician
int perft_test_perft(EPDFile* epdFile)
{
	int i = 0;
	Timer totalTimer, perftTimer;
	printf("Testing %i perfts\n", epdFile->numEPD);

	start_timer(&totalTimer);

	for (i = 0; i < epdFile->numEPD; ++i)
	{
		EPD* epd = &epdFile->epds[i];
		int depth = 1;
		char depthKey[8];
		unsigned int perftExpected = 0, perftActual;

		printf("%i/%i %s\n", i + 1, epdFile->numEPD, epd->description);

		while (1)
		{
			snprintf(depthKey, 8, "D%i", depth);

			if (!epd_has_operation(epd, depthKey))
			{
				break;
			}

			perftExpected = epd_uint_operation(epd, depthKey);

			start_timer(&perftTimer);
			perftActual = perft_perft(&epd->board, depth);
			stop_timer(&perftTimer);

			printf("perft %i: %i [%03fs] (%i) %s\n", depth, perftActual, get_elapsed_time(&perftTimer), perftExpected,
			perftActual == perftExpected ? "PASS" : "FAIL");
			if (perftActual != perftExpected)
			{
				printf("Fail in perft test\n");
				printf("FEN: %s\n", epd->description);
				printf("Level: %i\n", depth);
				printf("Expected: %i\n", perftExpected);
				printf("Found: %i\n", perftActual);
				return 0;
			}

			++depth;
		}

		printf("\n");
	}

	stop_timer(&totalTimer);
	printf("Perft suite finished in %03fs\n", get_elapsed_time(&totalTimer));

	return 1;
}
示例#3
0
文件: map.cpp 项目: Philipp-S/mana
void Map::updateAmbientLayers(float scrollX, float scrollY)
{
    static int lastTick = tick_time; // static = only initialized at first call

    if (mLastScrollX == 0.0f && mLastScrollY == 0.0f)
    {
        // First call - initialisation
        mLastScrollX = scrollX;
        mLastScrollY = scrollY;
    }

    // Update Overlays
    float dx = scrollX - mLastScrollX;
    float dy = scrollY - mLastScrollY;
    int timePassed = get_elapsed_time(lastTick);

    std::list<AmbientLayer*>::iterator i;
    for (i = mBackgrounds.begin(); i != mBackgrounds.end(); i++)
    {
        (*i)->update(timePassed, dx, dy);
    }
    for (i = mForegrounds.begin(); i != mForegrounds.end(); i++)
    {
        (*i)->update(timePassed, dx, dy);
    }
    mLastScrollX = scrollX;
    mLastScrollY = scrollY;
    lastTick = tick_time;
}
示例#4
0
文件: main.c 项目: lgblgblgb/xemu
/* This is the emulation timing stuff
 * Should be called at the END of the emulation loop.
 * Input parameter: microseconds needed for the "real" (emulated) computer to do our loop 
 * This function also does the sleep itself */
static void emu_timekeeping_delay ( int td_em )
{
	int td, td_pc = get_elapsed_time(et_start, &et_end, NULL);	// the time was needed for our emulation loop
	if (td_pc < 0) {
		DEBUG("TIMING: negative amount of time spent for an emulation loop?!" NL);
		td = 0;
	} else
		td = td_em - td_pc; // the time difference (+X = PC is faster - real time EP emulation, -X = EP is faster - real time EP emulation is not possible)
	DEBUG("DELAY: pc=%d em=%d sleep=%d" NL, td_pc, td_em, td);
	/* for reporting only: BEGIN */
	td_em_ALL += td_em;
	td_pc_ALL += td_pc;
	if (td_count_ALL == 50) {
		char buf[256];
		//DEBUG("STAT: count = %d, EM = %d, PC = %d, usage = %f%" NL, td_count_ALL, td_em_ALL, td_pc_ALL, 100.0 * (double)td_pc_ALL / (double)td_em_ALL);
		snprintf(buf, sizeof buf, "%s [%.2fMHz ~ %d%%]%s", WINDOW_TITLE " v" VERSION " ",
			CPU_CLOCK / 1000000.0,
			td_em_ALL ? (td_pc_ALL * 100 / td_em_ALL) : -1,
			paused ? " PAUSED" : ""
		);
		SDL_SetWindowTitle(sdl_win, buf);
		td_count_ALL = 0;
		td_pc_ALL = 0;
		td_em_ALL = 0;
	} else
		td_count_ALL++;
	/* for reporting only: END */
	td_balancer += td;
	/* insane time-diff balancer values ... */
	if (td_balancer >  1000000 || td_balancer < -1000000)
		td_balancer = 0;
	DEBUG("Balancer = %d" NL, td_balancer);
	// Should be the last, as with Emscripten, it's not a real sleep, but the settimeout JS stuff ...
	emu_sleep(td_balancer);
}
示例#5
0
文件: main.c 项目: lgblgblgb/xemu
/* Should be started on each time, emulation is started/resumed (ie after any delay in emulation like pause, etc)
 * You DO NOT need this during the active emulation loop! */
void emu_timekeeping_start ( void )
{
	(void)get_elapsed_time(0, &et_start, &unix_time);
	et_end = et_start;
	td_balancer = 0;
	rtc_update_trigger = 1;
}
示例#6
0
//=================================================================================================
void eve::thr::profiler::get_sample(eve::thr::profiler_sample & p_sample) const noexcept
{
	p_sample.name_			  = get_name();
	p_sample.sample_time_	  = get_sample_time();
	p_sample.time_elapsed_	  = get_elapsed_time();
	p_sample.clock_cycle_num_ = get_clock_cycle_num();
}
示例#7
0
void executor_test(string_t description, function func)
{
    pre_executor_test(description);
    start_clock();
    func();
    stop_clock();
    post_executor_test(get_elapsed_time());
}
示例#8
0
//
// Member Function
//
int CWallPadKcm::Write(UCHAR *pData, int size)
{
	CContextSetup* pContextSetup = NULL;
	int ret = ERROR;
	ULONG ulTick, delay;

	if(m_serial.IsOpen())
	{
		DBGMSG(DBG_WALLPAD, "[WallPad:KCM] Try To Write\r\n");
		DBGDMP(DBG_WALLPAD, pData, size, TRUE);

		//수신중일경우 대기
		ulTick = get_mono_time();
		while(m_isRecv) 
		{ 
			usleep(1000); 
			if(get_elapsed_time(ulTick) >= 300)
			{
				DBGMSG(DBG_WALLPAD, "[WallPad:KCM] Wait for read done: Timeout!!\r\n");
				return -1;
			}
		}

		// 485 Enable
		g_gpio_mtm.SetGpioOutPin(GPIO_RS485_CTRL, LOW);

		// TX Enable후 최초 패킷을 전송하기까지 1.5[ms] 지연
		usleep(10);

		ret = m_serial.Write(pData, size);
		if(ret == size)
		{
			memcpy((UCHAR *)&m_packet, pData, sizeof(KCM_PACKET));
		}
		else
		{
			DBGMSG(DBG_WALLPAD, "[WallPad:KCM] Write Bytes Error, write=%d, expect=%d\e\n", ret, size);
		}

		//마지막 패킷 전송후 TX Disable 하기까지 지연 (패킷사이즈 전송시간 + 1.5[ms])
		delay = (size * 1042) + 10;	// 9600[bps]에서 1start+8bit+1stop 전송속도는 1.04167[ms] 이므로 21 byte는 21.875[ms]
		usleep(delay);

		// 485 Disable
		g_gpio_mtm.SetGpioOutPin(GPIO_RS485_CTRL, HIGH);

	#if 1
		if(g_isContextSetupWallPad)
		{
			pContextSetup = (CContextSetup*)g_state.GetCurrContext();
			if(pContextSetup)
			{
				pContextSetup->PrintPacket(pData, size, CYAN, FALSE);
			}
		}
	#endif
	}
示例#9
0
 void update_frame_time() {
     frame_time_ = get_elapsed_time();
     if(frame_time_ > 0.25) {
         frame_time_ = 0.25;
     }        
     
     if(is_fixed_) {
         accumulator_ += frame_time_;
     }         
 }
示例#10
0
/***
 * Print out an optional message followed by the current timer timing.
 */
void Timer::check(const char* msg)
{
  // Print an optional message, something like "Checking timer t";
  if (msg) {
    std::cerr << msg << " : ";
  }

//  VERBOSE(1, "[" << std::setiosflags(std::ios::fixed) << std::setprecision(2) << (running ? elapsed_time() : 0) << "] seconds\n");
  std::cerr << "[" << (running ? get_elapsed_time() : 0) << "] seconds\n";
}
示例#11
0
文件: dtq.c 项目: AHCALMonitoring/dim
int dtq_clear_entry(TIMR_ENT *entry)
{
	int time_left, deltat = 0;

	DISABLE_AST
	deltat = get_elapsed_time();
	time_left = entry->time_left - deltat;
	entry->time_left = entry->time + deltat;
	ENABLE_AST
	return(time_left);
}
示例#12
0
文件: main.c 项目: lgblgblgb/xemu
static void emu_timekeeping_check ( void )
{
	// check how much time we slept, initiated by last call of emu_timekeeping_delay()
	// we also store current UT in "unix_time" to be used by emulator (ie, RTC emulation)
	int td = get_elapsed_time(et_end, &et_start, &unix_time);
	if (td >= 0)			// td should be greater than zero or sleep was about for _minus_ time? eh, give me that time machine, dude! :)
		td_balancer -= td;	// time-difference balancer, decrease with time slept
	else
		DEBUG("TIMING: negative amount of time spent for sleeping?!" NL);
	rtc_update_trigger = 1;
}
示例#13
0
void Monster::logic()
{
    if (mAction != STAND)
    {
        mFrame = (get_elapsed_time(mWalkTime) * 4) / getWalkSpeed();

        if (mFrame >= 4 && mAction != DEAD)
            nextStep();
    }

    Being::logic();
}
示例#14
0
void LocalPlayer::setWalkingDir(int dir)
{
    mWalkingDir = dir;

    // If we're not already walking, start walking.
    if (mAction != WALK && dir
#ifdef TMWSERV_SUPPORT
        && get_elapsed_time(mLocalWalkTime) >= walkingKeyboardDelay
#endif
       )
    {
        walk(dir);
    }
}
示例#15
0
//
// Obtain and print the elapsed time to the result file
//
void print_elapsed_time()
{
	double elapsed ;
	double resolution ;

	// Obtain and display elapsed execution time
	elapsed = get_elapsed_time() ;
	resolution = 1.0 / CLOCKS_PER_SEC ;

	fprintf(result_file,
			"  Elapsed time:            %9.3f (%8.6f sec resolution)\n",
			elapsed, 
			resolution) ;
}
示例#16
0
文件: game.cpp 项目: lightbits/akari
void gen_heightmap()
{
	use_shader(shader_generate);
	uniform("time", get_elapsed_time());
	blend_mode(false);
	depth_test(false);
	depth_write(false);
	glBindFramebuffer(GL_FRAMEBUFFER, rt_heightmap.fbo);
	glViewport(0, 0, rt_heightmap.width, rt_heightmap.height);
	clearc(0x00000000);
	mesh_quad.draw();
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glViewport(0, 0, window_width, window_height);
}
示例#17
0
int main(int argc, char** argv)
{
    srand(time(NULL));

    initialize_state();

    initialize_timer();

    print_state(stdout, 1.0f);
    printf("Score: %d\n", game_state.score);

    char input;

    double dTime = 0;
    while (1)
    {
        dTime += get_elapsed_time();
        if (dTime > 1)
        {
            printf("Tick.\n");
            dTime -= 1;
        }
    }

    while (input = getchar())
    {
        switch (input)
        {
        case 'D':
            if (move_down()) return 0;
            break;
        case 'G':
            if (gravity_tick()) return 0;
            break;
        case 'L':
            move_left();
            break;
        case 'R':
            move_right();
            break;
        case 'U':
            rotate();
            break;
        }
        print_state(stdout, 1.0f);
        printf("Score: %d\n", game_state.score);
    }

    return 0;
}
示例#18
0
//=================================================================================================
void eve::thr::profiler::store_sample(void)
{
	eve::thr::profiler_sample s;
	s.name_					= get_name();
	s.sample_time_			= get_sample_time();
	s.time_elapsed_			= get_elapsed_time();
	s.clock_cycle_num_		= get_clock_cycle_num();

	// FIFO storage.
	if (samples_.size() > samples_num_)
	{
		samples_.erase(samples_.begin());
	}
	samples_.emplace_back(std::move(s));
}
示例#19
0
void Viewport::mouseDragged(gcn::MouseEvent &event)
{
    if (!mMap || !player_node)
        return;

    if (mPlayerFollowMouse && !event.isShiftPressed())
    {
        if (get_elapsed_time(mLocalWalkTime) >= walkingMouseDelay)
        {
            mLocalWalkTime = tick_time;
            player_node->setDestination(event.getX() + (int) mPixelViewX,
                                        event.getY() + (int) mPixelViewY);
            player_node->pathSetByMouse();
        }
    }
}
示例#20
0
bool test_resize_image(qivon::Image<unsigned char> &_src, size_t _width, size_t _height) {
    if (_src.isEmpty())
        return false;

    qivon::Image<unsigned char> resized_img;

    set_start_now();

    qivon::resizeImage(_src, resized_img, _width, _height);

    std::cout << __FUNCTION__ << " time " << get_elapsed_time() << " ms\n";

    if (resized_img.isEmpty())
        return false;
    else
        return qivon::writePngFile("resize.png", resized_img);
}
示例#21
0
文件: dtq.c 项目: AHCALMonitoring/dim
int dtq_task(void *dummy)
{
int deltat;
static int to_go;

	if(dummy){}
	while(1)
	{
		if(DIM_next_time)
		{
			DISABLE_AST
			DIM_time_left = DIM_next_time;
			if(DIM_time_left == -1)
				DIM_time_left = 0;
			to_go = DIM_next_time;
			DIM_next_time = 0;
			ENABLE_AST
		}
		if(DIM_time_left < 0)
		{
			DIM_time_left = 0;
			alrm_sig_handler(2);
#ifndef WIN32
			return(1);
#endif
		}
		else if(DIM_time_left > 0)
		{
			dim_usleep(100000);
			deltat = get_elapsed_time();
			DIM_time_left = to_go - deltat;
			if(DIM_time_left <= 0)
			{
				alrm_sig_handler(2);
#ifndef WIN32
				return(1);
#endif
			}
		}
		else
		{
			dim_usleep(1000);
		}
	}
}
示例#22
0
文件: dtq.c 项目: AHCALMonitoring/dim
static int stop_it()
{
	int min_time;
    int deltat = 0;

	DISABLE_AST
	if(Alarm_runs)
	{
		my_alarm(0);
        deltat = get_elapsed_time();
		if(deltat != 0)
			DIM_last_time = get_current_time(&DIM_last_time_millies);
		Alarm_runs = 0;
	}
	min_time = get_minimum(deltat);
	ENABLE_AST
	return(min_time);
}
示例#23
0
bool test_crop_image(qivon::Image<unsigned char> &_src,
                     size_t _start_x, size_t _start_y, size_t _end_x, size_t _end_y) {
    if (_src.isEmpty())
        return false;

    qivon::Image<unsigned char> cropped_img;

    set_start_now();

    qivon::cropImage(_src, cropped_img, _start_x, _start_y, _end_x, _end_y);

    std::cout << __FUNCTION__ << " time " << get_elapsed_time() << " ms\n";

    if (cropped_img.isEmpty())
        return false;
    else
        return qivon::writePngFile("crop.png", cropped_img);
}
示例#24
0
bool test_mean_filter_3x3(qivon::Image<unsigned char> &_src, size_t _run_time) {
  if (_src.isEmpty())
    return false;

  qivon::Image<unsigned char> mean;

  set_start_now();

  for (size_t i = 0; i < _run_time; ++i)
    qivon::meanFilter3x3(_src, mean);

  std::cout << __FUNCTION__ << " time " << get_elapsed_time() / _run_time << " ms\n";

  if (mean.isEmpty())
    return false;
  else
    return qivon::writePngFile("mean.png", mean);
}
示例#25
0
int Being::getOffset(char pos, char neg) const
{
    // Check whether we're walking in the requested direction
    if (mAction != WALK ||  !(mDirection & (pos | neg)))
        return 0;

    int offset = (get_elapsed_time(mWalkTime) * 32) / mWalkSpeed;

    // We calculate the offset _from_ the _target_ location
    offset -= 32;
    if (offset > 0)
        offset = 0;

    // Going into negative direction? Invert the offset.
    if (mDirection & pos)
        offset = -offset;

    return offset;
}
示例#26
0
文件: dtq.c 项目: AHCALMonitoring/dim
int dtq_rem_entry(int queue_id, TIMR_ENT *entry)
{
	int time_left, deltat = 0;

	DISABLE_AST
	deltat = get_elapsed_time();
	time_left = entry->time_left - deltat;
	if( Inside_ast ) 
	{
		timer_queues[queue_id].remove_entries++;
		entry->time = -1;
		ENABLE_AST
		return(time_left);
	}
	dll_remove(entry);
	free(entry);

	ENABLE_AST
	return(time_left);
}
示例#27
0
    JNIEXPORT void JNICALL Java_com_arm_malideveloper_openglessdk_computeparticles_ComputeParticles_step
    (JNIEnv *env, jclass jcls)
    {
        double curr_tick = get_elapsed_time();
        double dt = curr_tick - last_tick;
        last_tick = curr_tick;

        update_app(dt);
        render_app(dt);

        GLenum error = glGetError();
        bool were_errors = false;
        while (error != GL_NO_ERROR)
        {
            LOGD("An OPENGL error occured %s", get_gl_error_msg(error));
            were_errors = true;
            error = glGetError();
        }
        if (were_errors) exit(1);
    }
示例#28
0
/** Service the switch queue.  This function is called
 * periodically to see if any pending switch transitions have
 * completed their debounce time.  If any switch becomes
 * unstable before the period expires, it will be removed
 * from the queue prior to this function being called.  So
 * all that is needed here is to decrement the timers, and if
 * one reaches zero, consider that switch transitioned.
 */
void switch_service_queue (void)
{
	pending_switch_t *entry;
	U8 elapsed_time;

	/* See how long since the last time we serviced the queue.
	This is in 16ms ticks. */
	elapsed_time = get_elapsed_time (switch_last_service_time);

	entry = switch_queue;
	while (unlikely (entry < switch_queue_top))
	{
		entry->timer -= elapsed_time;
		if (entry->timer <= 0)
		{
			/* Debounce interval is complete.  The entry can be removed
			from the queue */
			switch_queue_remove (entry);

			/* See if the switch held its state during the debounce period */
			if (bit_test (sw_unstable, entry->id))
			{
				/* Debouncing failed, so don't process the switch.
				 * Restart IRQ-level scanning. */
				disable_irq ();
				bit_off (sw_stable, entry->id);
				bit_off (sw_unstable, entry->id);
				enable_irq ();
			}
			else
			{
				/* Debouncing succeeded, so process the switch */
				switch_transitioned (entry->id);
			}
		}
		entry++;
	}

	switch_last_service_time = get_sys_time ();
}
示例#29
0
void Map::drawOverlay(Graphics *graphics,
                      float scrollX, float scrollY, int detail)
{
    static int lastTick = tick_time;

    // Detail 0: no overlays
    if (detail <= 0) return;

    if (mLastScrollX == 0.0f && mLastScrollY == 0.0f)
    {
        // First call - initialisation
        mLastScrollX = scrollX;
        mLastScrollY = scrollY;
    }

    // Update Overlays
    int timePassed = get_elapsed_time(lastTick);
    float dx = scrollX - mLastScrollX;
    float dy = scrollY - mLastScrollY;

    std::list<AmbientOverlay*>::iterator i;
    for (i = mOverlays.begin(); i != mOverlays.end(); i++)
    {
        (*i)->update(timePassed, dx, dy);
    }
    mLastScrollX = scrollX;
    mLastScrollY = scrollY;
    lastTick = tick_time;

    // Draw overlays
    for (i = mOverlays.begin(); i != mOverlays.end(); i++)
    {
        (*i)->draw(graphics, graphics->getWidth(), graphics->getHeight());

        // Detail 1: only one overlay, higher: all overlays
        if (detail == 1)
            break;
    }
}
示例#30
0
文件: main.cpp 项目: DoubleVV12/SoM
int main()
{
//    sf::RenderWindow window(sf::VideoMode::getDesktopMode(), "SFML works!", sf::Style::Fullscreen);
    sf::RenderWindow window(sf::VideoMode(704,480), "SFML works!", sf::Style::Close);
//    sf::RenderWindow window(sf::VideoMode(1680,1050), "SFML works!", sf::Style::Close);
//    window.setFramerateLimit(120);

    Game g;
    Game_view game(&g);
//    sf::Time dt;

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
            if (event.type == sf::Event::KeyReleased);
                game.handle_event(&event);
        }

        dt = get_elapsed_time();
        game.handle_event();
        game.handle_camera();
        game.animate();

        window.clear();
        window.draw(game);
//        window.setMouseCursorVisible(false); //TODO : à activer plus tard
        window.setView(game.get_camera());
        window.display();
    }

    return 0;
}