예제 #1
0
CPHSynchronize*	CCharacterPhysicsSupport::PHGetSyncItem	(u16 item)
{
	if(movement()->CharacterExist()) 
		return movement()->GetSyncItem();
	else	
		return m_EntityAlife.CPhysicsShellHolder::PHGetSyncItem(item);
}
예제 #2
0
void CALifeMonsterBrain::process_task			()
{
	CALifeSmartTerrainTask			*task = smart_terrain().task(&object());
	THROW3							(task,"smart terrain returned nil task, while npc is registered in it",smart_terrain().name_replace());
	movement().path_type			(MovementManager::ePathTypeGamePath);
	movement().detail().target		(*task);
}
예제 #3
0
void CCharacterPhysicsSupport::set_movement_position( const Fvector &pos)
{
	VERIFY( movement() );

	CollisionCorrectObjPos( pos, true );
	
	movement()->SetPosition( m_EntityAlife.Position() );
}
예제 #4
0
void CAI_Rat::set_rew_cur_position()
{
	Fvector tTemp;
	tTemp.setHP(-movement().m_body.current.yaw,-movement().m_body.current.pitch);
	tTemp.normalize_safe();
	tTemp.mul(m_fUnderFireDistance);
	m_tSpawnPosition.add(Position(),tTemp);
}
예제 #5
0
void CAI_Rat::SelectAnimation(const Fvector& /**_view/**/, const Fvector& /**_move/**/, float /**speed/**/)
{
	IKinematicsAnimated	*tpVisualObject = smart_cast<IKinematicsAnimated*>(Visual());
	MotionID			tpGlobalAnimation;

	if (!g_Alive()) {
		for (int i=0 ;i<2; ++i) {
			if (m_tRatAnimations.tNormal.tGlobal.tpaDeath[i] == m_tpCurrentGlobalAnimation) {
				tpGlobalAnimation = m_tpCurrentGlobalAnimation;
				break;
			}
		}
		if (!tpGlobalAnimation) {
			if (m_tpCurrentGlobalAnimation == m_tRatAnimations.tNormal.tGlobal.tpaIdle[1])
				tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaDeath[0];
			else
				tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaDeath[::Random.randI(0,2)];
		}
	}
	else {
		if (m_bFiring)
			tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaAttack[2];
		else
			if (angle_difference(movement().m_body.target.yaw,movement().m_body.current.yaw) <= MIN_TURN_ANGLE)
				if (m_fSpeed < 0.2f) {
					if (m_bStanding)
						tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaIdle[1];
					else
						tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaIdle[0];
				}
				else
					if (_abs(m_fSpeed - m_fAttackSpeed) < EPS_L)
						tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tRunAttack;
					else
						if (_abs(m_fSpeed - m_fMaxSpeed) < EPS_L)
							tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tRun.fwd;
						else
							tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tWalk.fwd;
			else {
				if (left_angle(-movement().m_body.target.yaw,-movement().m_body.current.yaw))
//					tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaIdle[0];
					tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpTurnLeft;
				else
//					tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpaIdle[0];
					tpGlobalAnimation = m_tRatAnimations.tNormal.tGlobal.tpTurnRight;
			}
	}

	if (tpGlobalAnimation != m_tpCurrentGlobalAnimation)
		m_tpCurrentGlobalBlend = tpVisualObject->PlayCycle(m_tpCurrentGlobalAnimation = tpGlobalAnimation);

#ifdef DEBUG
	if (psAI_Flags.is(aiAnimation)) {
		IKinematicsAnimated	*skeleton_animated = smart_cast<IKinematicsAnimated*>(Visual());
		Msg					("%6d %s animation : %s (%f,%f)",Device.dwTimeGlobal,"Global",skeleton_animated->LL_MotionDefName_dbg(m_tpCurrentGlobalAnimation),movement().m_body.current.yaw,movement().m_body.target.yaw);
	}
#endif
}
예제 #6
0
void CAI_Rat::init_state_under_fire()
{
	if (!switch_if_enemy()&&get_if_dw_time()&&m_tLastSound.dwTime >= m_dwLastUpdateTime)
	{
		Fvector tTemp;
		tTemp.setHP(-movement().m_body.current.yaw,-movement().m_body.current.pitch);
		tTemp.normalize_safe();
		tTemp.mul(m_fUnderFireDistance);
		m_tSpawnPosition.add(Position(),tTemp);
	}
	m_tGoalDir = m_tSpawnPosition;
}
예제 #7
0
void CCharacterPhysicsSupport::in_NetSpawn( CSE_Abstract* e )
{
	m_sv_hit = SHit();
	if( m_EntityAlife.use_simplified_visual	( ) )
	{
		m_flags.set( fl_death_anim_on, TRUE );
		IKinematics*	ka = smart_cast<IKinematics*>( m_EntityAlife.Visual( ) );
		VERIFY( ka );
		ka->CalculateBones_Invalidate( );
		ka->CalculateBones( TRUE );
		CollisionCorrectObjPos( m_EntityAlife.Position( ) );
		m_pPhysicsShell		= P_build_Shell( &m_EntityAlife, false );
		ka->CalculateBones_Invalidate( );
		ka->CalculateBones( TRUE );
		return;
	}
	CPHDestroyable::Init();//this zerows colbacks !!;
	IRenderVisual *pVisual = m_EntityAlife.Visual();
	IKinematicsAnimated*ka= smart_cast<IKinematicsAnimated*>( pVisual );
	IKinematics*pK= smart_cast<IKinematics*>( pVisual );
	VERIFY( &e->spawn_ini() );
	m_death_anims.setup( ka, *e->s_name , pSettings );
	if( !m_EntityAlife.g_Alive() )
	{
		if( m_eType == etStalker )
			ka->PlayCycle( "waunded_1_idle_0" );
		else
			ka->PlayCycle( "death_init" );

	}else if( !m_EntityAlife.animation_movement_controlled( ) )
		ka->PlayCycle( "death_init" );///непонятно зачем это вообще надо запускать
									  ///этот хак нужен, потому что некоторым монстрам 
									  ///анимация после спона, может быть вообще не назначена
	pK->CalculateBones_Invalidate( );
	pK->CalculateBones( TRUE );
	
	CPHSkeleton::Spawn( e );
	movement( )->EnableCharacter();
	movement( )->SetPosition(m_EntityAlife.Position( ) );
	movement( )->SetVelocity	( 0, 0, 0 );
	if(m_eType!=etActor)
	{
		m_flags.set( fl_specific_bonce_demager, TRUE );
		m_BonceDamageFactor = 1.f;
	}
	if( Type( ) == etStalker )
	{
		m_hit_animations.SetupHitMotions( *smart_cast<IKinematicsAnimated*>( m_EntityAlife.Visual( ) ) );
	}
	anim_mov_state.init( );

	anim_mov_state.active = m_EntityAlife.animation_movement_controlled( );
}
예제 #8
0
void CAI_Rat::init_free_recoil()
{
	m_dwLostRecoilTime	= Device.dwTimeGlobal;
	m_tRecoilPosition	= m_tLastSound.tSavedPosition;
	if (!switch_if_enemy()&&!switch_if_time())
	{
		Fvector tTemp;
		tTemp.setHP(-movement().m_body.current.yaw,-movement().m_body.current.pitch);
		tTemp.normalize_safe();
		tTemp.mul(m_fUnderFireDistance);
		m_tSpawnPosition.add(Position(),tTemp);
	}
}
예제 #9
0
/** ------------------------------------------------------------------------------------------------------------- *
 * @brief movement
 ** ------------------------------------------------------------------------------------------------------------- */
void CodeMotionPass::movement(PabloBlock * const block) {
    sink(block);
    for (Statement * stmt : *block) {
        if (isa<If>(stmt)) {
            movement(cast<If>(stmt)->getBody());
        } else if (isa<While>(stmt)) {
            movement(cast<While>(stmt)->getBody());
            // TODO: if we analyzed the probability of this loop being executed once, twice, or many times, we could
            // determine whether hoisting will helpful or harmful to the expected run time.
            hoistLoopInvariants(cast<While>(stmt));
        }
    }
    reschedule(block);
}
bool
BounceColliderComponent::collision(ColliderComponent &c, float d, const CollisionData &data)
{
	MMUNUSED(c);
	MMUNUSED(d);
	MMUNUSED(data);

	const Math::Vector2 &l_vel = movement()->velocity();
	const float l_mag = l_vel.magnitude();
	const Math::Vector2 l_normal = l_vel.normalized(l_mag);
	Math::Vector2 l_pvel = (l_normal * (2.f * l_normal.dot(l_vel * -1.f)) + l_vel);
	movement()->velocity() = l_pvel.normalize(l_pvel.magnitude()) * l_mag;

	return(true);
}
예제 #11
0
void draw(roomGrid *room_grid, progress *puzzle, char *instructions_list[NUM_INSTRUCTIONS], Chicken *hen)
{
    SDL_Surface *background, *sprite, *chicken;
    SDL_Texture *backtex, *spritetex, *chickentex;

    load_image(room_grid, &background, &backtex, "lab1sheet.png");
    load_image(room_grid, &sprite, &spritetex, "prof2.png");
    load_image(room_grid, &chicken, &chickentex, "chicken.png");

    initialise_roomgrid_components(room_grid, puzzle);
    position_sprite(room_grid);
    Mix_PlayChannel(-1, room_grid -> mus, -1);

    while (room_grid -> gamerunning)
    {
        
        movement(room_grid, puzzle, instructions_list, hen);     
        collision_detection(room_grid);
        SDL_RenderClear(room_grid -> renderer);
        draw_room(background, backtex, room_grid);

        /*RenderClear to wipe framebuffer, RenderCopy to compose final framebuffer, RenderPresent puts on screen*/
        SDL_RenderCopy(room_grid -> renderer, spritetex, &room_grid -> rcObj, &room_grid -> rcSprite);
        SDL_RenderPresent(room_grid -> renderer);
    }

    // SDL_Delay(5000);
    SDL_DestroyTexture(backtex);
    SDL_DestroyTexture(spritetex);
    SDL_DestroyTexture(chickentex);
    SDL_DestroyRenderer(room_grid -> renderer);
    SDL_DestroyWindow(room_grid -> window);
}
예제 #12
0
 bool ChargeSystem::solve()
 {
   const double c_smallVelocitiesSq = 0.0001*0.0001;
   const int c_maxIters = 1000000;
   normalize();
   int n = d_particles.size();
   std::vector<PhasePoint> newPP( n );
   int iter = 0;
   do
   {
     for( int i = 0; i < n; ++i)
     {
       PhasePoint& pp = d_particles[i];
       PhasePoint& newpp = newPP[i];
       newpp.d_p = pp.d_p + d_t * pp.d_v;
       makeUnit(newpp.d_p);
       newpp.d_v = pp.d_v + d_t * getForce(i); // unit mass
       newpp.d_v -= (newpp.d_p * newpp.d_v) * newpp.d_p; // dv * dp == 0 always
     }
     d_particles.swap(newPP);
     ++iter;
   } 
   while( movement() > c_smallVelocitiesSq && iter < c_maxIters);
   return iter < c_maxIters;
 }
예제 #13
0
u16	CCharacterPhysicsSupport::PHGetSyncItemsNumber( )
{
	if(movement()->CharacterExist())
		return 1;
	else 
		return m_EntityAlife.CPhysicsShellHolder::PHGetSyncItemsNumber();
}
예제 #14
0
/**
 * \brief Check if the bottom of the "that" item was
 *        lower than \a m_value, relative to the top of the "self" item.
 * \param info Informations on the collision.
 * \param self The first item in the collision.
 * \param that The other item in the collision.
 */
bool bear::universe::bottom_contact_is_lower::operator()
  ( const collision_info& info, physical_item& self, physical_item& that ) const
{
  bear::universe::position_type origin( that.get_bottom_middle() );
  claw::math::line_2d<bear::universe::coordinate_type> movement
    ( origin, info.other_previous_state().get_bottom_middle() - origin );
  bear::universe::coordinate_type that_bottom;
  bear::universe::coordinate_type y_bound;

  switch ( info.get_collision_side() )
    {
    case zone::middle_right_zone:
      that_bottom = movement.y_value( self.get_right() );
      y_bound = m_line.y_value( self.get_width() );
      break;
    case zone::middle_left_zone:
      that_bottom = movement.y_value( self.get_top_left().x );
      y_bound = m_line.y_value( self.get_top_left().x );
      break;
    case zone::middle_zone:
      that_bottom = info.other_previous_state().get_bottom();
      y_bound = m_line.y_value
        ( info.other_previous_state().get_center_of_mass().x
          - self.get_top_left().x );
      break;
    default:
      {
        CLAW_ASSERT( false, "This test is for left/middle/right collisions" );
      }
    }

  return that_bottom - (int)self.get_top_left().y < y_bound;
} // bottom_contact_is_lower::operator()()
예제 #15
0
void updatePackman(Packman &packman, float elapsedTime, Field &field)
{
    const float step = PACKMAN_SPEED * elapsedTime;

    updatePackmanDirection(packman);

    sf::Vector2f movement(0.f, 0.f);
    switch (packman.direction)
    {
    case Direction::UP:
        movement.y -= step;
        break;
    case Direction::DOWN:
        movement.y += step;
        break;
    case Direction::LEFT:
        movement.x -= step;
        break;
    case Direction::RIGHT:
        movement.x += step;
        break;
    case Direction::NONE:
        break;
    }
    if (checkFieldWallsCollision(field, packman.shape.getGlobalBounds(), movement))
    {
        // Останавливаем пакмана при столкновении
        packman.direction = Direction::NONE;
    }
    packman.eatenCookies += eatAllCookiesInBounds(field, packman.shape.getGlobalBounds());
    packman.shape.move(movement);
}
예제 #16
0
void FolderViewListView::dragMoveEvent(QDragMoveEvent* e) {
  if(movement() != Static)
    QListView::dragMoveEvent(e);
  else
    QAbstractItemView::dragMoveEvent(e);
  static_cast<FolderView*>(parent())->childDragMoveEvent(e);
}
예제 #17
0
void EnemyLog::update(float deltaTime   , Background *bg) {
    _aliveTimer += deltaTime;
    if(!_destroying && _aliveTimer > 5) {
        //_alive = false;
        _index = 0;
        _destroying = true;
        _animTimer.restart();
        move(-31, -31);
    }

    if(_spawning){
        updateSprite(true);
        return;
    }
    if(_destroying){
        updateSprite(false);
        return;
    }

    setTexture(*_texture, true);
    if(getOrigin().x == 0){
        setPosition(getPosition().x + getLocalBounds().width/2+32, getPosition().y + getLocalBounds().height/2+32);
        setOrigin( getLocalBounds().width/2, getLocalBounds().height/2);
    }

    movement(deltaTime, bg);

}
예제 #18
0
void GameView::updateScreen(const EventManager& eventManager)
{
	sf::Vector2f movement(0.f, 0.f);
	if(_moveUp)
	{
		movement.y =eventManager.getYPosition();
	}
	if(_moveDown)
	{
		movement.y =eventManager.getYPosition();
	}
	if(_moveLeft)
	{
		_playerID.setTexture(_playerTexture);
		_playerID.setRotation(0);
		movement.x =eventManager.getXPosition();
	}
	if(_moveRight)
	{
		_playerID.setRotation(180);
		movement.x =eventManager.getXPosition();
	}
	_playerID.move(movement);

}
예제 #19
0
파일: hw1.cpp 프로젝트: gaararose/hw1
int main(void)
{
	int done = 0;
	srand(time(NULL));
	initXWindows();
	init_opengl();
	//declare game object
	Game game;
	game.n = 0;

	//declare a box shape
	//game.box.width = 100;
	//game.box.height = 10;
	//game.box.center.x = 120 + 5*65;
	//game.box.center.y = 500 - 5*60;

	//start animation
	while (!done) {
		while (XPending(dpy)) {
			XEvent e;
			XNextEvent(dpy, &e);
			check_mouse(&e, &game);
			done = check_keys(&e);
		}
		movement(&game);
		render(&game);
		bubbles(&game);
		glXSwapBuffers(dpy, win);
	}
	cleanupXWindows();
	return 0;
}
예제 #20
0
//Checks to see if there is an arc in the edge
int getARC (Game g, path pathToEdge) {
	
	int arcCode = 0;
	char *path = pathToEdge;
	int xPtA = 0;
	int yPtA = 0;
	int zPtA = 0;
	int xPtB = 0;
	int yPtB = 0;
	int zPtB = 0;

	edge arc; //Edge to be checked
	arc.pointA = pathMovement (path);
	arc.pointB = movement (arc.pointA, BACK);


	xPtA = arc.pointA.x + 3;
	yPtA = arc.pointA.y + 3;
	zPtA = arc.pointA.z + 3;
	xPtB = arc.pointB.x + 3;
	yPtB = arc.pointB.y + 3;
	zPtB = arc.pointB.z + 3;

	arcCode = g->gameBoard.arc[xPtA][yPtA][zPtA][xPtB][yPtB][zPtB];
	
	return arcCode;
}
예제 #21
0
파일: Background.cpp 프로젝트: gigak/game
void pBack::MoveBack()
{
	sf::Vector2f movement(0.f,0.f);

	movement.y +=speed;
	pSprite.move( movement * time.asSeconds() );
}
예제 #22
0
int main(void)
{

    int done=0;
    srand(time(NULL));
    initXWindows();
    init_opengl();
    //declare game object
    Game game;
    //start animation
    while(!done) {
        while(XPending(dpy)) {
            XEvent e;
            XNextEvent(dpy, &e);
            check_mouse(&e, &game);
            done = check_keys(&e, &game);
        }
        movement(&game);
        render(&game);
        glXSwapBuffers(dpy, win);
    }
    cleanupXWindows();
    cleanup_fonts();
    return 0;
}
예제 #23
0
//Tests conditions for path, which needs 1 BPS and 1 BQN
//Ensure paths are connected to other paths & are legal paths
//Does not leave into the sea, and path is vacant
int arcConditions (Game g, action a, int player) {

	int answer = TRUE;
	char *path = a.destination;
	edge arc;
	arc.pointA = pathMovement (path);
	arc.pointB = movement (arc.pointA, BACK);

	if ((getStudents (g, player, STUDENT_BPS) >= 1) 
		&& (getStudents (g, player, STUDENT_BQN) >= 1)
		&& (a.destination[0] != BACK)) { //doesn't move back into the sea
		answer = TRUE;
	} else {
		answer = FALSE;
	}

	//check if they're inside the boundaries
	if (answer == TRUE
		&& abs (arc.pointA.x) >= 3
		&& abs (arc.pointA.y) >= 3
		&& abs (arc.pointA.z) >= 3) {
		answer = FALSE;
	}

	//Checks to see that they are actual adjacent vertexes
	if (answer == TRUE 
		&& abs(arc.pointA.x+arc.pointA.y+arc.pointA.z) != 2 
		&& (arc.pointA.x+arc.pointA.y+arc.pointA.z+arc.pointB.x+arc.pointB.y+arc.pointB.z != 0)
		&& (getARC (g, a.destination) != VACANT_ARC)) {
		answer = FALSE;
	} 

	return answer;
}
예제 #24
0
void Stalfos::update(std::vector<std::shared_ptr<GameObject>>* worldMap) {
	if (isCollidingWithPlayer(worldMap)){
		Player* temp = (Player*)findPlayer(worldMap).get();
		temp->takeDamage(worldMap, this);
	}
	checkParalyzeStatus();
	if (isCollidingWithBoomerang(worldMap)){
		Sound::playSound(GameSound::EnemyHit);
		isParalyzed = true;
		ThrownBoomrang* boom = (ThrownBoomrang*)findBoomerang(worldMap).get();
		if (!boom->isReturning)
			boom->isReturning = true;
	}
	if (pushbackStep == 0 && !isParalyzed){
		movement(worldMap);
		tryToChangeDirection();
	}
	else if(pushbackStep!=0 && !isParalyzed)
		pushbackUpdate();
	for (int i = 0; i < 3; i++)
		walkingAnimation[i]->updateAnimationFrame(position);
	if (healthPoint <= 0)
		processDeath(worldMap);
	else checkInvincibility();
	updateMasks();
}
예제 #25
0
int main(int argc, char **argv)
{
  /**
  * The ros::init() function needs to see argc and argv so that it can perform
  * any ROS arguments and name remapping that were provided at the command line. For programmatic
  * remappings you can use a different version of init() which takes remappings
  * directly, but for most command-line programs, passing argc and argv is the easiest
  * way to do it. The third argument to init() is the name of the node.
  *
  * You must call one of the versions of ros::init() before using any other
  * part of the ROS system.
  */
  ros::init(argc, argv, "movement_node");

  /**
  * NodeHandle is the main access point to communications with the ROS system.
  * The first NodeHandle constructed will fully initialize this node, and the last
  * NodeHandle destructed will close down the node.
  */
  ros::NodeHandle n;

  // create an instance of the subscriber class
  Movement movement(n);

  // initialize the class (for details see comments in class)
  movement.init();

  // Do not use the ROS::Spin, but instead use own implementation
  movement.spin();

  return 0;
}
예제 #26
0
/**
 * Query if the auton will initiate an event.
 * This will call up the LUA autons initEvent function which will
 * either return a 'null' string or data to build an
 * external event.
 * @return EventQueue::eEvent pointer to an external event or
 * a null pointer in which case nothing happens.
 */
std::unique_ptr<EventQueue::eEvent> AgentLuaInterface::takeStep()
{
    if(removed) return NULL;
    if(nofile) return NULL;
    lua_settop(L,0);

    try
    {
        lua_getglobal(L, "_TakeStep");
        if(lua_pcall(L,0,0,0) !=LUA_OK)
        {
            Output::Inst()->kprintf("<b><font color=\"brown\">Lua error on takeStep. %s, %s</font></b></>", filename.c_str() ,lua_tostring(L,-1));
            Output::RunSimulation.store(false);
            return NULL;
        }

        if(moving)
        {
            movement();
        }

        getSyncData();

        return NULL;

    }
    catch(std::exception &e)
    {
        Output::Inst()->kprintf("<b><font color=\"red\">Exception on takeStep. %s, %s</font></b></>", filename.c_str()  ,e.what());
        Output::RunSimulation.store(false);
    }
    return NULL;
}
예제 #27
0
int main()
{
    char userInput[100];
    char *firstWord;
    char *secondWord;
    long numInput;
    int boundsCheck;
    myStruct * ptrName; 
    ptrName = malloc(sizeof(myStruct));

     initscr();

    drawInterface();

    ptrName->yPos = 13; //This is the center of the interface
    ptrName->xPos = 37;

    ptrName->angle = 0;
    ptrName->pd = 1; //Pen is down
    ptrName->tStatus = 1; //Turtle is not hidden

    mvaddch(ptrName->yPos,ptrName->xPos,'@');
    
     do
    {
        mvwprintw(stdscr, 27, 47, "Message Board ");
        mvwprintw(stdscr, 27, 8, "Input? ");
        getstr(userInput);
        mvwprintw(stdscr, 30, 40,"You entered: %s",userInput);

        /*Splitting the user input*/
        firstWord = strtok(userInput, " ");
        secondWord = strtok(NULL, " ");
        
        if (secondWord!=NULL) 
        { 
            numInput = atol(secondWord); //converting to integer
        }
    
        clearLine(27,8);

        boundsCheck = checkBounds(ptrName); //checking the bounds (DOES NOT WORK YET)

        if (boundsCheck == 1)
        {
            movement(firstWord, numInput, ptrName);
        }

        
        refresh();

    }while (strcmp(userInput,"quit")!=0);

    refresh();
    endwin();
    free(ptrName);

    return 0;
}
예제 #28
0
void CCharacterPhysicsSupport::UpdateCollisionActivatingDellay( )
{
	VERIFY( m_collision_activating_delay );
	VERIFY( movement() );
	m_collision_activating_delay->update();
	if( !m_collision_activating_delay->active() )
		xr_delete(m_collision_activating_delay);
}
예제 #29
0
/* sec 0616 */
void synch_v (void)
{
  if (cur_v != dvi_v)
  {
    movement(cur_v - dvi_v, down1);
    dvi_v = cur_v;
  }
}
예제 #30
0
/* sec 0616 */
void synch_h (void)
{
  if (cur_h != dvi_h)
  {
    movement(cur_h - dvi_h, right1);
    dvi_h = cur_h;
  }
}